평생 공부 블로그 : Today I Learned‍ 🌙

[Github 블로그] 블로그를 public Repository 로 전환했습니다.

2021-08-31T00:00:00+00:00

블로그 코드를 공개하기 위해 블로그 저장소 의 보기 권한을 public 으로 변경하였습니다. 지저분한 코드지만 블로그 만드는데 도움이 되었으면 좋겠습니다. 감사합니다.😍

🌜 개인 공부 기록용 블로그입니다. 오류나 틀린 부분이 있을 경우 
언제든지 댓글 혹은 메일로 지적해주시면 감사하겠습니다! 😄

맨 위로 이동하기

[백준 1368][💛2] 물대기 (MST, 크루스칼)

2021-07-26T00:00:00+00:00

🚀 난이도

💛 골드 2

🚀 문제

https://www.acmicpc.net/problem/1368

🚀 내 풀이 ⭕

풀이 참고 : https://conkjh032.tistory.com/386

우물을 직접 판 논에서 물을 끌어와 쓰는 논들은, 우물을 직접 판 해당 논을 루트로 하는 트리에서 연결된다고 생각할 수 있다. 그러면 트리가 여러개가 될 수 있는 셈인데 어떻게 해야하지..? 라는 고민을 했었다.

고민을 하다가 구글링을 하여 다른 분의 풀이를 보았는데 생각보다 심플한 풀이였다. 가상의 노드를 하나 더 만든 후 이를 루트로 하고 우물을 직접 파는 비용도 추가하는 것이다. 이렇게 생각하면 우물을 직접 파는 비용도, 연결하는 비용도 하나의 그래프로 연결할 수 있다. 위 링크 블로그에서 그림을 보면 쉽게 이해가 될 것이다.

가상의 노드를 루트로 두고, 우물을 직접 파는 비용으로 논들과 이 루트를 연결하는 것으로 그래프를 시작한다면 하나의 그래프로 통합시킬 수 있는 셈이다.

이렇게 하나의 그래프로 만든 후 평범하게! MST 최소신장트리 알고리즘 적용하여 풀이하면 된다. 나는 크루스칼 알고리즘을 사용했다.

#include <bits/stdc++.h>

using namespace std;

struct Edge { int a, b, cost; };
bool cmp(const Edge& a, const Edge& b) { return a.cost < b.cost; }
int parent[301];

int get_root(int x) {
	if (x == parent[x])
		return x;
	return parent[x] = get_root(parent[x]);
}

void union_graph(int a, int b) {
	int par_a = get_root(a);
	int par_b = get_root(b);
	if (par_a < par_b) parent[par_b] = par_a;
	else parent[par_a] = par_b;
}

bool is_same_graph(int a, int b) {
	int par_a = get_root(a);
	int par_b = get_root(b);
	if (par_a == par_b) return true;
	else return false;
}

int main() {
	freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);

	int N;
	cin >> N;
	
	vector<Edge> edges;
	for (int i = 1; i <= N; ++i) {
		int cost;
		cin >> cost;
		edges.push_back({ 0, i, cost });
	}
	for (int i = 1; i <= N; ++i) {
		for (int j = 1; j <= N; ++j) {
			int cost;
			cin >> cost;

			if (i != j) 
				edges.push_back({ i, j, cost });
		}
	}

	sort(edges.begin(), edges.end(), cmp);

	for (int i = 0; i <= N; ++i)
		parent[i] = i;

	int total_cost = 0;
	for (int i = 0; i < edges.size(); ++i) {
		if (is_same_graph(edges[i].a, edges[i].b) == false) {
			union_graph(edges[i].a, edges[i].b);
			total_cost += edges[i].cost;
		}
	}
	cout << total_cost;
}

처음엔 아래와 같이 풀이를 해서 틀렸었다. 자기 자신과 연결되는 비용은 항상 0 이기 때문에 이를 피하기 위해서 저렇게 짰었던건데 이렇게 짜면 입력받는 처리가 되지 못해 뒤로 밀려서 틀린 풀이가 되버렸다. 0 도 cin 을 통해 입력 받은 후에 continue 시켰어야 했다.

	for (int i = 1; i <= N; ++i) {
		for (int j = 1; j <= N; ++j) {
			if (i == j) continue;
			
			int cost;
			cin >> cost;
			edges.push_back({ i, j, cost });
		}
	}

🌜 개인 공부 기록용 블로그입니다. 오류나 틀린 부분이 있을 경우 
언제든지 댓글 혹은 메일로 지적해주시면 감사하겠습니다! 😄

맨 위로 이동하기

[백준 20366][💛3] 같이 눈사람 만들래? (조합, 투포인터)

2021-07-26T00:00:00+00:00

🚀 난이도

💛 골드 3

🚀 문제

https://www.acmicpc.net/problem/20366

🚀 내 풀이

어려웠다.. 결국 다른 분들의 풀이로 공부를 했던 문제였다. 😅

🔥 첫 번째 풀이 (조합)

코드 출처 블로그 https://imnotabear.tistory.com/379

최대 입력 크기가 600 이기 때문에 서로 다른 4 개의 눈 덩이 조합을 뽑는다면 시간 초과가 발생할 것이다.(600 C 4) 우선 2 개의 눈덩이끼리의 조합을 구하여 그 눈덩이들을 묶어 나열한다.(이를 snowman 라고 하겠다.) 눈덩이 2 개로 눈사람 하나를 만드는 것이기 때문에 이 bind 에서 엘사의 눈사람, 안나의 눈사람으로서 2 개를 뽑는다. 즉, 눈덩이 2 개를 뽑아 하나의 원소로서 묶어 나열한 snowman 에서 또 2 개를 뽑아 눈사람 2 개를 조합으로 뽑는 식이다. 여기까지만 생각해보면 N C 2 * N C 2 가 되어 엄청나게 큰 입력 크기가 될 것 같지만..

문제에서 구하고자 하는 것은 엘사 눈사람과 안나 눈사람 “최소 길이 차이”를 구하는 것이기 때문에 눈덩이 2 개를 조합으로 뽑아 묶아 나열한 snowman 를 먼저 정렬을 한 후, 각 원소마다 자신의 바로 뒤에 있는 것을 선택하여 그것과 키 차이를 구하면 된다. 오름차순으로 정렬을 한 상태인데다가 최소 길이 차이를 구하는 것이기에 자신의 뒤에 있는, 즉 자신 보다 키가 큰 눈사람들 중 전부 다 비교할 필요 없이 그냥 바로 뒤에 있는 눈사람을 선택해주면 되는 것이다. 그게 바로 자신보다 키 큰 눈 사람 중에서 자신과 가장 최소로 차이 나는 눈사람이 되는 것이기 때문이다! (‘자신’을 안나 눈사람, ‘안나 눈사람 보다 큰 눈사람들 중에서 가장 최소로 차이 나는 눈사람’을 엘사 눈사람이라고 하자.)따라서 이때의 시간 복잡도는 N C 2 * N C 2 이 아닌 대략 N C 2 가 된다.

다만! 서로 다른 눈덩이를 써야하기 때문에 뽑힌 4 개의 눈덩이는 같은 index 여서는 안된다. 모두 다른 인덱스여야 한다! 두 눈덩이(인덱스)를 뽑아 모아둔 snowman에서 또 2 개를 뽑는 것이다 보니 뽑은 두 눈사람 중 같은 눈덩이가(즉 인덱스가 동일한) 있을 수 있다.

따라서 정렬된 상태에서 현재 안나의 눈사람으로 설정된 눈사람 중 뒤에 위치한 눈사람들 중에서 넷 다 서로 다른 눈덩이라는 전제가 처음으로 성립하는 눈사람을 엘사 눈사람으로 지정한 후 두 눈사람의 키 차이를 구하면 될 것이다. N C 2 의 시간 복잡도 동안 차례로 안나의 눈사람으로 설정한 후 두 눈 사람의 키 차이를 구하여 최소값을 업데이트 해 나가면 된다.

#include <bits/stdc++.h>

using namespace std;

struct Elem { int index1, index2, sum; }; // 이 구조체 하나가 눈사람이나 마찬가지다. index 1,2 로 두 눈덩이 구분(인덱스), sum 은 눈사람 길이가 됨. 
bool cmp(const Elem& a, const Elem& b) {
	return a.sum < b.sum; // 눈사람 키 별로 정렬
}

int main() {
	freopen("input.txt", "r", stdin);
	ios::sync_with_stdio(false);
	cin.tie(NULL); cout.tie(NULL);

	int N;
	cin >> N;

	vector<int> snow(N);
	for (int i = 0; i < N; ++i)
		cin >> snow[i];

	// 1️⃣ 두 눈덩이의 조합, 즉 NC2 개의 조합을 구한다. 이를 snowman 에 저장. 즉, 만들 수 있는 눈사람들 나열!
	vector<Elem> snowman;
	for (int i = 0; i < N - 1; ++i)
		for (int j = i + 1; j < N; ++j)
			snowman.push_back({ i, j, snow[i] + snow[j] });
	
	// 2️⃣ 눈사람들 키 별로 정렬
	sort(snowman.begin(), snowman.end(), cmp);

	// 3️⃣ 정렬된 snowman 을 순회하면서 각 원소를 안나 눈사람으로 설정한 후 그 뒤에 있는 것들 중 (즉, 안나보다 키 큰 눈사람) 
	// 처음으로 서로 다른 4 개의 눈덩이를 사용한 경우가 되는 눈사람을 엘사 눈사람으로 설정한 후 키 차이를 구하고 바~~~로 빠져나오면 된다.  
	// 이러면 거의 NC2 의 시간복잡도 보장할 것이다.
	int answer = INT_MAX;
	for (int i = 0; i < snowman.size() - 1; ++i) {
		Elem anna = snowman[i];
		for (int j = i + 1; j < snowman.size(); ++j) {
			Elem elsa = snowman[j];
			if (elsa.index1 != anna.index1 && elsa.index1 != anna.index2 && elsa.index2 != anna.index1 && elsa.index2 != anna.index2) {
				answer = min(answer, elsa.sum - anna.sum);
				break;
			}
		}
	}
	cout << answer;
}

🔥 두 번째 풀이 (투포인터)

코드 출처 블로그 https://velog.io/@pss407/%EB%B0%B1%EC%A4%8020366-%EA%B0%99%EC%9D%B4-%EB%88%88%EC%82%AC%EB%9E%8C-%EB%A7%8C%EB%93%A4%EB%9E%98

안나의 눈사람에 사용될 두 눈덩이를 먼저 고정시켜 놓은 후 (i와 j를 사용) 이 안나의 눈사람을 기준으로 하여, 안나의 두 눈덩이 사이 내에서 엘사 두 눈덩이를 투포인터 방식으로 결정해나간다. ((left, right를 사용) 그렇기 때문에 안나의 눈덩이는 최소 3 칸 이상 차이가 나야한다. 안나의 두 눈덩이를 고정시키는데 대략 N^2 만큼의 시간 복잡도 안에서 엘사의 두 눈덩이를 투포인터로 결정해나가기 때문에 첫번째 풀이보다는 실행 시간이 좀 더 걸릴 것이다. (엘사 안나 둘 중 누구를 투포인터를 적용할지는 중요하지 않다.)

조합을 구하듯 이중 반복문을 돌려 i 와 j를 고정하여 안나 눈사람을 정한다.(이 둘은 최소 3 이상 차이가 나야 한다.) 이 i와 j 사이의 범위에서 left, right 투포인터 알고리즘을 적용하여 엘사 눈사람을 정한다. i, j, left, right 모두 눈덩이를 가리키는 포인터가 된다.(인덱스)

✨ 투포인터 left, right 는 각각 양 끝에서 시작한다. 또한 눈덩이 배열을 오름차순 정렬을 미리 해놓는다.

투포인터 이동 기준 (즉, 고정된 안나의 두 눈덩이를 기준으로 엘사의 눈덩이를 어떻게 변경시켜나갈 것인가)
- 현재의 i, j, left, right 로 두 눈사람이 모두 결정되었다면 키 차이를 구한다.
  - (snow[left] + snow[right]) - (snow[i] + snow[j])
- 엘사 눈사람이 안나 눈사람보다 키가 크다면 (즉, 위 식의 결과가 양수)
  - 최소 차이에 도달하기 위해선 앞으로 엘사의 키가 더 작아져야 한다. 따라서 right 왼쪽으로 한칸 이동! (정렬 되어있으니 가능)
- 엘사 눈사람이 안나 눈사람보다 키가 작다면 (즉, 위 식의 결과가 음수)
  - 최소 차이에 도달하기 위해선 앞으로 엘사의 키가 더 커져야 한다. 따라서 left 오른쪽으로 한칸 이동! (정렬 되어있으니 가능)
- “차이” 는 절대값이어야 하는 개념이기 때문.

무작정 4 개의 눈덩이를 뽑아보는게 아닌, 안나의 두 눈덩이만 뽑아둔 후 그 기준으로 엘사의 눈덩이는 투포인터로 O(N) 으로 결정하는 방식 ! 엘사의 모든 눈덩이 경우의 수를 다 구하지 않는다. 전체적으론 대략 N^3 의 시간 복잡도가 소요될 듯 하다.

#include <bits/stdc++.h>

using namespace std;

struct Elem { int index1, index2, sum; };
bool cmp(const Elem& a, const Elem& b) {
	return a.sum < b.sum;
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios::sync_with_stdio(false);
	cin.tie(NULL); cout.tie(NULL);

	int N;
	cin >> N;

	vector<int> snow(N);
	for (int i = 0; i < N; ++i)
		cin >> snow[i];

	sort(snow.begin(), snow.end()); // 눈덩이 크기 순으로 정렬 

	int answer = INT_MAX;
	for (int i = 0; i < N - 3; ++i) {
		for (int j = i + 3; j < N; ++j) {
			// i ~ j 범위의 양끝에서 시작
			// left 와 right 는 엘사의 눈덩이
			int left = i + 1;
			int right = j - 1;

			while (left < right) {
                int anna = snow[i] + snow[j]; // 안나 눈사람
                int elsa = snow[left] + snow[right]; // 엘사 눈사람
				int result = elsa - anna;
				
				answer = min(answer, abs(result)); 
				
				if (result > 0)  // 현재 엘사가 더 크다면 최소 키 차이를 구하기 위해선 앞으로 엘사가 더 작아져야 한다.
					right = right - 1;
				else  // 현재 엘사가 더 작다면 최소 키 차이를 구하기 위해선 앞으로 엘사가 더 커져야 한다.
					left = left + 1;
			}
		}
	}
	cout << answer;
}

🌜 개인 공부 기록용 블로그입니다. 오류나 틀린 부분이 있을 경우 
언제든지 댓글 혹은 메일로 지적해주시면 감사하겠습니다! 😄

맨 위로 이동하기

[백준 20437][💛5] 문자열 게임 2

2021-07-26T00:00:00+00:00

🚀 난이도

💛 골드 5

🚀 문제

https://www.acmicpc.net/problem/20437

🚀 내 풀이

푼 지가 꽤 오래되어 가물가물 하지만… 오랜 시간 고민하다가 포기하고 구글링했던 문제로 기억한다..⭐ 내가 크게 간과했던 것은 3 번과 4 번을 별개로 생각했던 것이다. 3 번은 어떤 문자를 정확히 K 개 포함하면서 가장 짧은 연속 문자열의 길이 를 구하는 것이기 때문에 4 번처럼 문자열의 첫 번째와 마지막 글자가 같아야할 수 밖에 없다 ! ! !

그렇기 때문에 3, 4 번 이 둘을 별개로 생각하지 않고, 어떤 문자를 정확히 K 개 포함하고 문자열의 첫 번째와 마지막 글자가 해당 문자로 같은 문자열들을 구하고 최소 길이와 최대 길이를 구하면 된다.

🔥 첫 번째 풀이

코드 출처 블로그 https://taxol1203.github.io/codingtest/bj-%EB%AC%B8%EC%9E%90%EC%97%B4-%EA%B2%8C%EC%9E%842/

위 링크의 풀이를 참고하였다.

1️⃣ str 의 알파벳 문자별로 등장 빈도수를 저장한다.
2️⃣ K 와 같거나 K 보다 큰 빈도수를 가진 문자들만을 대상으로(이때 이 문자가 부분 문자열의 시작 문자가 됨), 해당 문자를 만날 때마다, 즉 동일한 문자를 만날 때마다 카운트 하고(이 과정에서 자동으로 시작 문자와 끝 문자가 같게 됨) 그 카운트 수가 K 가 되었을 때 최소 길이, 최대 길이를 업데이트 하면 된다.
- 나는 처음에 count[str[i] - ‘a’] == K 에 해당하는 문자만 해야하지 않을까? 왜지? 하고 생각했었다. 근데 아니다 !!!!! K 개 미만으로 적은 문자들에 대해서는 조건에 만족하는 부분 문자열을 구할 수 조차 없기에 넘어가야 하는게 맞지만, K 개 이상인 문자들에 대해서는 충분히 그 안에서도 K 개의 부분 문자열을 만들 수 있기 때문이다. 예를 들어 abcafa 라는 문자열이 있고 K 가 2 라고 가정해보자면, a 는 3 번 등장하므로 K 와 일치하지는 않지만 abca 혹은 afa 혹은 abcafa 이런 K = 2 개가 속한 문자열을 만들 수 있는 것이다. 내가 착각했었던 부분이다. 따라서 count[str[i] - ‘a’] >= K 조건에 만족하는 문자들에 대해서만 진행해야 하는 것이 맞다.

#include <bits/stdc++.h>

using namespace std;

int main() {
    //freopen("input.txt", "r", stdin);
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);

    int T; cin >> T;
    while(T--) {
        string str; 
        int K; 
        cin >> str;
        cin >> K;
        
        // str 의 알파벳 문자별로 등장 빈도수 저장
        vector<int> count(26);
        for (int i = 0; i < str.length(); i++)
            ++count[str[i] - 'a']; // ex) count[0] = 3 은 'a' 가 str 에 3 번 등장했다는 뜻
        
        int answer3 = INT_MAX; 
        int answer4 = -1;
        for (int i = 0; i < str.length(); ++i) {
            // ⭐ 빈도수가 K 개 미만인 문자들은 문자열도 못 만들므로 패스
            if (count[str[i] - 'a'] < K)
                continue;

            int cnt = 0;
            for (int j = i; j < str.length(); ++j) {  // 연속 문자열의 시작 문자 str[i]
                if (str[i] == str[j])  // str[j] 와 같다면 카운팅! (자동으로 시작문자 = 끝문자 인 연속 문자열이 되는 것이나 마찬가지)
                    ++cnt;
                
                if (cnt == K) {  // 카운트 수가 K 와 같을 때 길이 업데이트
                    answer3 = min(answer3, j - i + 1);
                    answer4 = max(answer4, j - i + 1);
                    break;
                }
            }
        }
        
        if (answer3 == INT_MAX || answer4 == -1) 
            cout << -1 << "\n";
        else 
            cout << answer3 << " " << answer4 << "\n";
    }
}

🔥 두 번째 풀이 (투포인터)

코드 출처 블로그 https://blog.naver.com/PostView.nhn?blogId=gustn3964&logNo=222291615095&categoryNo=0&parentCategoryNo=0&viewDate=&currentPage=1&postListTopCurrentPage=1&from=postView

아이디어가 좋은 풀이라고 느꼈다!

1️⃣ 이차원 배열을 선언하여 문자(인덱스)별로 그 문자가 등장하는 위치 인덱스들을 저장한다.
2️⃣ 어차피 어떠한 문자로 시작하고 끝이나는 문자열을 구해야하는 것이기 때문에 문자 별 위치 인덱스들에서 두 포인터가 가리키는 인덱스의 사이에 K 개 만큼의 고정적인 문자 수를 유지한 채로 두 포인터를 한 칸씩 옮겨나가면 된다.
- 예를 들어 a 문자가 5, 8, 13, 15 위치에 있고 (즉, alpha_pos[0] 는 {5, 8, 13, 15}) K 가 3 이라면 투포인터는 차례로 (5, 13) -> (8, 15) 이 순서로 각각 가리키게 된다. 5 와 13 위치엔 같은 문자가 있으며 5 와 13 사이엔 5, 8, 13 이렇게 K = 3 개의 동일한 문자가 있게 된다. 마찬가지로 8, 15 위치엔 같은 문자가 있으며 8 과 15 사이엔 8, 13, 15 이렇게 K = 3 개의 동일한 문자가 있게 된다.
- alpha_pos[문자] 해당 문자의 위치들이 기록된 배열(전부 동일한 문자를 가리키는 위치들)에서 사이에 K 개의 문자가 포함되도록 거리를 유치한 채 두 포인터를 모두 1 씩 증가하면 됨
- 따라서 왼쪽 포인터는 alpha_pos[문자][0] 을 가리키는 것 에서, 오른쪽 포인터는 alpha_pos[문자][K - 1] 을 가리키는 것에서 출발한다. (초기값)

#include <bits/stdc++.h>

using namespace std;

int main() {
    //freopen("input.txt", "r", stdin);
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);

    int T; cin >> T;
    for (int i = 0; i < T; i++) {
        string str; 
        int K;
        cin >> str;
        cin >> K;

        vector<int> alpha_pos[26];
        int answer3 = INT_MAX; int answer4 = -1;
         
         // 문자(인덱스)별로 그 문자가 등장하는 위치 인덱스들을 저장
        for (int j = 0; j < str.length(); j++) 
            alpha_pos[str[j] - 'a'].push_back(j);
        
        for (int j = 0; j < 26; j++) {
            if (alpha_pos[j].size() >= K) {
                int l = 0; 
                int r = K - 1;

                int temp3 = alpha_pos[j][r] - alpha_pos[j][l] + 1; 
                int temp4 = alpha_pos[j][r] - alpha_pos[j][l] + 1;
                while (r < alpha_pos[j].size() - 1) {
                    r++; 
                    l++;
                    temp3 = min(alpha_pos[j][r] - alpha_pos[j][l] + 1, temp3);
                    temp4 = max(alpha_pos[j][r] - alpha_pos[j][l] + 1, temp4);
                }
                answer3 = min(temp3, answer3);
                answer4 = max(temp4, answer4);
            }
        }
        if (answer3 == INT_MAX) 
            cout << -1 << "\n";
        else 
            cout << answer3 << " " << answer4 << "\n";
        
    }
}

🌜 개인 공부 기록용 블로그입니다. 오류나 틀린 부분이 있을 경우 
언제든지 댓글 혹은 메일로 지적해주시면 감사하겠습니다! 😄

맨 위로 이동하기

[백준 9663][💛5] N-Queen (백트래킹)

2021-07-26T00:00:00+00:00

🚀 난이도

💛 골드 5

🚀 문제

https://www.acmicpc.net/problem/9663

🚀 내 풀이

🔥 첫 번째 풀이 ❌ (시간초과)

프로그래머스의 N-Queen에서 제출했던 풀이와 비슷하지만 이번 백준의 N-Queen 에서는 통과하지 못했다..! 백준이 입력 크기가 더 크다. 프로그래머스는 N = 12, 백준은 N = 15 가 최대이다. 시간복잡도가 O(N!) 에 가깝기 때문에 3 만큼만 차이나지만 전체적인 시간복잡도 차이는 어마어마한 것이다..ㅠ ㅠ N = 15 에서는 통과하기 힘든 풀이였던 것 같다.

#include <bits/stdc++.h>

using namespace std;

int N, answer;
bool board[15][15];

void dfs(int row) {
	if (row == N) {
		++answer;
		return;
	}
	
	for (int col = 0; col < N; ++col) {
		bool cond1 = true;
		for (int i = 0; i < row; ++i) {
			if (board[i][col]) {
				cond1 = false;
				break;
			}
		}
		bool cond2 = true;
		for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; --i, --j) {
			if (board[i][j]) {
				cond2 = false;
				break;
			}
		}
		bool cond3 = true;
		for (int i = row - 1, j = col + 1; i >= 0 && j < N; --i, ++j) {
			if (board[i][j]) {
				cond3 = false;
				break;
			}
		}
		if (cond1 && cond2 && cond3) {
			board[row][col] = true;
			dfs(row + 1);
			board[row][col] = false;
		}
	}
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);
	
	cin >> N;
	
	dfs(0);
	
	cout << answer;
}

🔥 두 번째 풀이 ⭕

구글링 해보니 대부분 이 풀이로 제출하면 시간 초과 없이 통과하셨더 것 같다! 그런데 사실.. 첫 번째 풀이는 왜 시간초과가 나고 이 풀이는 왜 시간초과가 나지 않는지 잘 모르겠다..! 😥 두 풀이의 dfs 연산 횟수는 동일한데.. 첫 번째 풀이는 안에 있는 for문을 1 개 썼다는 정도이고 두 번째 풀이는 안쪽 for 문을 3 개 썼다는 정도의 차이인데 이 차이로 시간 초과가 발생한 것일까? 잘 모르겠다.. 알려주시면 너무 감사할 것 같아요 흑흑…

#include <bits/stdc++.h>

using namespace std;

int N, answer;
int queen[15]; // 인덱스는 row 가 된다. row 별 어느 col 에 두었는지 그 col 값을 기록.

void dfs(int row) {
	if (row == N) {
		++answer;
		return;
	}
	
	for (int col = 0; col < N; ++col) {
		queen[row] = col; 
		
		bool promising = true;
		for (int i = 0; i < row; ++i) {
			if (queen[i] == queen[row] || abs(queen[i] - queen[row]) == abs(i - row)) {
				promising = false;
				break;
			}
		}

		if (promising)
			dfs(row + 1);
	}
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);
	
	cin >> N;
	
	dfs(0);
	
	cout << answer;
}

🌜 개인 공부 기록용 블로그입니다. 오류나 틀린 부분이 있을 경우 
언제든지 댓글 혹은 메일로 지적해주시면 감사하겠습니다! 😄

맨 위로 이동하기

[백준 9489][💛4] 사촌

2021-07-25T00:00:00+00:00

🚀 난이도

💛 골드 4

🚀 문제

https://www.acmicpc.net/problem/9489

🚀 내 풀이 ⭕

사촌 사이는 조부모가 같고 부모는 다른 사이이다. (부모끼리는 형제) 나는 그냥.. 정말 직관적이고 단순하게 풀었다!

1️⃣ 우선 arr[i] 모든 노드마다 자신의 부모와 자신의 자식들을 각각 2 가지 map 에 저장하였다.(arr[i] 의 부모를 알 수 있도록 반복자를 두었고 연속된 수가 끊기면 반복자를 다음 노드로 옮겨주는 식으로 현재 부모를 가리키도록 했다.)

2️⃣ 위에서 구한 두 map 을 사용하여 K 노드의 사촌의 수를 누적합 한다. K 의 할아버지의 자식들 (K의 삼촌들 + 부모) 에서 부모는 제외하고 삼촌들의 자식 수를 세면 된다.

#include <bits/stdc++.h>

using namespace std;

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);

	while (true) {  // 반복 1번 당 테스트케이스 1개 
		int N, K;
		cin >> N >> K;
		if (N == 0 || K == 0) // 0 0 입력시 입력 종료
			break;

		vector<int> arr(N);
		for (int i = 0; i < N; ++i)
			cin >> arr[i];

		map<int, int> parent; // key : 노드 번호   value : key 노드의 부모 노드 번호
		parent[arr[0]] = 0;  // arr[0] 는 루트 노드이다. 루트는 부모가 없기에 부모를 0 으로 지정
		map<int, vector<int>> children; // key : 노드 번호   value : key 노드의 자식 노드'들'
		map<int, int>::iterator parent_ptr;  // parent 맵 처음부터 순회할 반복자 (조상 노드부터 BFS 방식으로 순회하는 느낌일듯..!)

        // 1️⃣ 노드마다 자신의 부모와 자식들 map 에 전부 저장! 
		for (int i = 1; i < N; ++i) {
			if (arr[i] - arr[i - 1] > 1) { // 다음 노드로 포인터 옮기기 (연속된 집합에 속하는 노드들은 같은 부모의 자식이다. 이 집합이 끝났으니 이제 다음 노드들은 다음 노드의 자식들이라는 것이기 때문에 포인터 옮김)
				if (i == 1) parent_ptr = parent.begin();
				else ++parent_ptr;
			}
			parent[arr[i]] = parent_ptr->first;
			children[parent_ptr->first].push_back(arr[i]);
		}
        
		// 2️⃣ 사촌 가려내기 작업
        // 루트노드와 루트노드의 직속 자식들은 사촌이 없다.
		if (parent[K] == K || parent[K] == arr[0])
			cout << 0 << '\n';
		// 그외
		else {
			int grandParent = parent[parent[K]]; // K 노드의 할아버지
			vector<int> uncles = children[grandParent]; // K 노드의 할아버지의 자식들 (= K의 부모 + K의 삼촌들)
			int count = 0;
			for (int i = 0; i < uncles.size(); ++i)
				if (uncles[i] != parent[K]) // K 의 삼촌들의 자식들만 세면 된다.
					count += children[uncles[i]].size();
			cout << count << '\n';
		}
	}
}

🌜 개인 공부 기록용 블로그입니다. 오류나 틀린 부분이 있을 경우 
언제든지 댓글 혹은 메일로 지적해주시면 감사하겠습니다! 😄

맨 위로 이동하기

[백준 4358][💛5] 생태학 (map, 소수 출력)

2021-07-24T00:00:00+00:00

🚀 난이도

💛 골드 5

🚀 문제

https://www.acmicpc.net/problem/4358

🚀 내 풀이 ⭕

주의해야할 점
- 공백을 포함하여 문자열 입력 받기. key 는 공백이 포함된 문자열. 👉 getline
- 소수점 넷째자리
map 은 추가할 때 자동 정렬이 되므로 (이진 탐색 트리라서) 이 map 을 그냥 반복자를 이용해 출력하면 끝!

#include <bits/stdc++.h>

using namespace std;

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);

	map<string, int> trees;
	string tree_name;
	double size = 0;
	while (getline(cin, tree_name)) {  // 입력이 더 이상 없을 때까지 반복!
		trees[tree_name]++;
		size++;
	}
	
	cout << fixed << setprecision(4); // 소수점 넷째자리
	for (auto& tree : trees)
		cout << tree.first << " " << (tree.second / size) * 100 << '\n';
}

🌜 개인 공부 기록용 블로그입니다. 오류나 틀린 부분이 있을 경우 
언제든지 댓글 혹은 메일로 지적해주시면 감사하겠습니다! 😄

맨 위로 이동하기

[백준 1987][💛4] 알파벳 (DFS, 백트래킹)

2021-07-11T00:00:00+00:00

🚀 난이도

💛 골드 4

🚀 문제

https://www.acmicpc.net/problem/1987

🚀 내 풀이 ⭕

뭔가 생김새는 BFS 문제 같았지만.. 문제를 읽어보니 백트래킹으로 풀어야 하는 문제였다. 왜냐하면 현재까지 선택해 온 경로에서 한번 방문 했었던 종류의 알파벳은 사용할 수 가 없기 때문이다. 즉, 현재까지 “선택해 온 알파벳”들의 정보가 필요하다. N-Queen 문제와 유사하다. BFS 는 너비 우선 탐색을 하기 때문에 이렇게 “선택해 온 경로”의 정보를 담기는 힘들다.

#include <bits/stdc++.h>

using namespace std;

int R, C, answer;
int dr[4] = { -1, 1, 0 , 0 };
int dc[4] = { 0, 0, -1 , 1 };
char board[20][20];
bool visited[26]; // 알파벳 별 방문 체크 (현재의 경로 기준이므로 성공이든 실패든 재귀 함수가 호출을 끝내고 돌아오면 다시 false 로 바꿔 방문 체크를 해제해준다.)

void dfs(int r, int c, int dist) {
	
	bool canGo = false;
	for (int i = 0; i < 4; ++i) {
		int nextR = r + dr[i];
		int nextC = c + dc[i];

		if (nextR < 0 || nextR >= R || nextC < 0 || nextC >= C) continue; // 갈 수 없는 곳 1 (보드 범위를 넘어섬)
		char nextAlpha = board[nextR][nextC];
		if (visited[nextAlpha - 'A']) continue; // 갈 수 없는 곳 2 (현재의 경로 내에서 이전에 방문했었던 알파벳)

		canGo = true; // 갈 수 있는 곳 하나라도 발견했다면 true
		visited[nextAlpha - 'A'] = true;
		dfs(nextR, nextC, dist + 1);
		visited[nextAlpha - 'A'] = false; // ⭐ 또 다른 경로에서 해당 알파벳이 다시 선택될 수 있도록
	}

	if (!canGo) { // 더 이상 갈 수 있는 곳이 없다면! (즉, for문에서 재귀 한번도 못 돌림. 더 이상 나아갈 경로가 없음)
		answer = max(answer, dist);
		return;
	}
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);

	cin >> R >> C;
	for (int i = 0; i < R; ++i)
		for (int j = 0; j < C; ++j)
			cin >> board[i][j];

	char nextAlpha = board[0][0];
	visited[nextAlpha - 'A'] = true; // 출발 지점 체크
	dfs(0, 0, 1); // 문제에서 시작점도 카운팅에 포함된다고 했으므로 1 에서 시작
	
	cout << answer;
}

🌜 개인 공부 기록용 블로그입니다. 오류나 틀린 부분이 있을 경우 
언제든지 댓글 혹은 메일로 지적해주시면 감사하겠습니다! 😄

맨 위로 이동하기

[백준 14940][💛5] 쉬운 최단거리 (BFS)

2021-07-10T00:00:00+00:00

🚀 난이도

💛 골드 5

🚀 문제

https://www.acmicpc.net/problem/14940

🚀 내 풀이 ⭕

정말 기본적인 BFS 문제!

문제에서 목표지점이라고 주어진 부분을 시작점이라고 생각한다.
- 하나의 시작점으로부터 모든 지점까지의 거리를 구하는 BFS
도달할 수 없는 위치는 -1로 출력을 해야 한다.
- if (Dist[i][j] == 0 && Map[i][j] == 1)
  - 갈 수 있는 곳임에도 불구하고 Map[i][j] == 1, BFS 결과 목표지점으로부터 거리가 0 인 곳은 갈 수 없는 곳이나 마찬가지이다.

#include <bits/stdc++.h>

using namespace std;

int N, M;
int dx[4] = { -1, 1, 0, 0 };
int dy[4] = { 0, 0, -1, 1 };
struct Pos { int x, y; };
int Map[1000][1000];
int Dist[1000][1000];

void bfs(Pos dest) {  // 매개변수 출발지. (문제에선 목표지점으로 주어져서 dest 로 이름 짓긴했지만..)
	queue<Pos> q;
	vector<vector<bool>> visited(N, vector<bool>(M));

	q.push(dest);
	Dist[dest.x][dest.y] = 0;
	visited[dest.x][dest.y] = true;

	while (!q.empty()) {
		Pos now = q.front();
		q.pop();

		for (int i = 0; i < 4; ++i) {
			int nextX = now.x + dx[i];
			int nextY = now.y + dy[i];

			if (nextX < 0 || nextX >= N || nextY < 0 || nextY >= M) continue;
			if (Map[nextX][nextY] == 0) continue;
			if (visited[nextX][nextY]) continue;

			q.push({ nextX, nextY });
			Dist[nextX][nextY] = Dist[now.x][now.y] + 1;
			visited[nextX][nextY] = true;
		}
	}
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);

	Pos dest;
	cin >> N >> M;
	for (int i = 0; i < N; ++i) {
		for (int j = 0; j < M; ++j) {
			cin >> Map[i][j];
			if (Map[i][j] == 2) {
                // 출발지 저장
				dest.x = i;
				dest.y = j;
			}
		}
	}

	bfs(dest);
	for (int i = 0; i < N; ++i) {
		for (int j = 0; j < M; ++j) {
			if (Dist[i][j] == 0 && Map[i][j] == 1)
				cout << -1 << ' ';
			else
				cout << Dist[i][j] << ' ';
		}	
		cout << '\n';
	}
}

🌜 개인 공부 기록용 블로그입니다. 오류나 틀린 부분이 있을 경우 
언제든지 댓글 혹은 메일로 지적해주시면 감사하겠습니다! 😄

맨 위로 이동하기

[백준 20164][💛5] 홀수 홀릭 호석

2021-07-10T00:00:00+00:00

🚀 난이도

💛 골드 5

🚀 문제

https://www.acmicpc.net/problem/20164

~~홀수에 미친 호석이~~

🚀 내 풀이 ⭕

재귀적으로 다음 과정을 수행하면 된다.

현재의 문자열 길이가 3 이상이라면 👉 문자열 길이를 세 부분으로 나누어 홀수 개수를 세고 합친다.(합친건 다음 재귀 문자열이 된다.)
1. 문자열 길이를 S 라고 한다면 S-1 C 2 개의 조합을 구한다.
  - 예를 들어 “82019” 라면, 이 문자열을 3 개의 부분으로 나누기 위해선 “8💓2💓0💓1💓9” 이렇게 4 개의 💓 에서 2 개를 뽑는 것이라고 생각할 수 있다. 즉, 문자열을 나눌 수 있는 사이사이 부분은 항상 S-1개가 있는데 이 중에서 2 개를 뽑아 이 위치를 기준으로 substr를 통해 문자열을 3 개로 쪼갤 수 있는 것이다.
  - 임의로 세 파트로 나눈다고 하였으니 현재의 문자열 길이를 기준으로 S-1 C 2 조합을 모두 구한 후 하나하나 재귀 돌리면 된다.
  - N은 입력 크기가 아주 크나 이 N 의 길이 S 는 10 을 넘지 않으므로 시간 복잡도는 걱정하지 않아도 된다.
2. 세 파트로 나눈 문자열 각각에서 홀수 개수를 구한다.
  - check_odd 함수를 만들어 이 함수에서 처리하도로 하였다.
3. 문자열을 정수로 변환하여 합한 후 이를 다시 문자열로 변환하여 다음 재귀에서의 현재 문자열이 되도록 한다.
현재의 문자열 길이가 2 라면 👉 문자열 길이를 두 부분으로 나누어 홀수 개수를 세고 합친다.(합친건 다음 재귀 문자열이 된다.)
- 그냥 s[0] 과 s[1] 로 나누면 된다.
```
// 여기서 하나 배운게 있는데, char 문자 하나를 string 화 하려면 길이를 설정하는 생성자를 호출하여 1 로 설정해주면 된다.
string s1(1, s[0]), s2(1, s[1]);
```
현재의 문자열 길이가 1 이라면 👉 재귀 종료 조건!, 현재 단계까지 구해왔던 홀수 개수의 최소값과 최대값 업데이트

조합에 대하여

나는 prev_permutation 을 사용하여 조합을 구했다.
- (C++) 조합(Combination) 구현하기
근데 딱 2 개만 뽑는 조합을 구하는 것이기 때문에 굳이 나처럼 prev_permutation 쓸 필요 없이 이중 for문을 사용하여 조합을 구해도 된다.
- 2 개 뽑는 조합은 아래와 같은 이중 for문으로 구할 수 있다. i와 j가 뽑은 두 개의 수가 된다.
```
// 이런식!
for(int i = 1; i <= N - 1; ++i)
    for(int j = i + 1; j <= N; ++j)
```

#include <bits/stdc++.h>

using namespace std;

int Min = INT_MAX;
int Max = 0;

int check_odd(string s) {
	int cnt = 0;
	for (int i = 0; i < s.length(); ++i) // 문자열의 한 문자 한 문자 다 검사 
		if ((s[i] - '0') % 2 == 1) // 해당 문자를 숫자로 변환했을 때 홀수라면
			++cnt;
	return cnt;
}

void odd_holic(string s, int totalCount) {
	if (s.length() == 1) {
		totalCount += check_odd(s);
		Min = min(Min, totalCount);
		Max = max(Max, totalCount);
		return;
	}
	else if (s.length() == 2) {
		string s1(1, s[0]), s2(1, s[1]);

		string next = to_string((s[0] - '0') + (s[1] - '0'));
		int nowCount = check_odd(s1) + check_odd(s2);
		odd_holic(next, totalCount + nowCount);
	}
	else if (s.length() >= 3) {
		vector<bool> comb(s.length() - 1, false);
		for (int i = 0; i < 2; ++i)
			comb[i] = true;

		do {
			vector<int> boundary;
			for (int i = 0; i < s.length() - 1; ++i) 
				if (comb[i])
					boundary.push_back(i);
			string s1 = s.substr(0, boundary[0] + 1);
			string s2 = s.substr(boundary[0] + 1, boundary[1] - boundary[0]);
			string s3 = s.substr(boundary[1] + 1, s.length() - 1 - boundary[1]);

			string next = to_string(stoi(s1) + stoi(s2) + stoi(s3));
			int nowCount = check_odd(s1) + check_odd(s2) + check_odd(s3);
			odd_holic(next, totalCount + nowCount);

		} while (prev_permutation(comb.begin(), comb.end()));
	}
}

int main() {
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);

	string N;
	cin >> N;
	
	odd_holic(N, 0);
	cout << Min << ' ' << Max;
}

🌜 개인 공부 기록용 블로그입니다. 오류나 틀린 부분이 있을 경우 
언제든지 댓글 혹은 메일로 지적해주시면 감사하겠습니다! 😄

맨 위로 이동하기