반응형

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

 

1699번: 제곱수의 합

어떤 자연수 N은 그보다 작거나 같은 제곱수들의 합으로 나타낼 수 있다. 예를 들어 11=32+12+12(3개 항)이다. 이런 표현방법은 여러 가지가 될 수 있는데, 11의 경우 11=22+22+12+12+12(5개 항)도 가능하다

www.acmicpc.net

 

처음에 재귀함수로 풀다가 계속 시간초과가 나서 

 

dp로 풀었다

 

 

#include <bits/stdc++.h>
#include <unordered_set>
using namespace std;

int n, ans = INT_MAX;
vector<int> v;

int dp[100001];

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);

    fill(dp+1, dp + 100001, INT_MAX);
    cin >> n;

	for (int i = 1; i * i <= n; i++) {
        int tmp = i * i;
        for (int j = 0; j <= n; j++) {
            if (j - tmp >= 0) {
                dp[j] = min(dp[j], dp[j - tmp] + 1);
            }
        }
	}


    cout << dp[n] << '\n';

    return 0;
}

 

반응형
반응형
#include <bits/stdc++.h>
using namespace std;

int arr[100001];
bool vis[100001];
bool done[100001];

int cnt= 0;
void DFS(int x) {
    vis[x] = 1;
    int nx = arr[x];

    if (!vis[nx]) {
        DFS(nx);
    }
    else if(!done[nx]) {
        for (int i = nx; i != x; i = arr[i]) {
            cnt++;
        }
        cnt++;
    }

    done[x] = 1;
}


int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
   
    int t;
    cin >> t;
    for (int T = 0; T < t; T++) {
        int n;
        cin >> n;

        memset(arr, 0, sizeof(arr));
        memset(vis, 0, sizeof(vis));
        memset(done, 0, sizeof(done));

        cnt = 0;

        for (int i = 1; i <= n; i++) {
            cin >> arr[i];
        }

        
        for (int i = 1; i <= n; i++) {
            if (!vis[i]) {
                DFS(i);
            }
        }

        cout << n - cnt << '\n';
    }


    return 0;
}

DFS로 O(n)으로 cycle을 찾아 낼 수 있다

반응형
반응형

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

 

11003번: 최솟값 찾기

N개의 수 A1, A2, ..., AN과 L이 주어진다. Di = Ai-L+1 ~ Ai 중의 최솟값이라고 할 때, D에 저장된 수를 출력하는 프로그램을 작성하시오. 이때, i ≤ 0 인 Ai는 무시하고 D를 구해야 한다.

www.acmicpc.net

 

 

시간초과 이유

ios::sync_with_stdio(0);
cin.tie(0);

입출력을 cin, cout으로 할 경우

위 두줄을 써주지 않으면 시간초과가 발생합니다.

위 두줄에 대한 설명은 하단 링크를 참고하시면 됩니다.

 

https://dingcoding.tistory.com/62

 

ios::sync_with_stdio(false), cin.tie(0) 쓰는 이유, 백준 시간초과 해결

1. ios::sync_with_stdio(false), cin.tie(0) 은 무엇인가? 보통 백준, 프로그래머스 같은 온라인 저지 사이트에서 C++을 이용하여 알고리즘 문제를 풀 때 시간초과를 방지하기 위해서 이 두 줄을 추가해줍니

dingcoding.tistory.com

 

cin, cout을 사용하지 않고

scanf printf 로 입출력을 하면 통과가 되는 것 같아요.

 

 

 


슬라이딩 윈도우 알고리즘

 

저도 이 문제를 풀면서 이 방법이 슬라이딩 윈도우라고 하는 걸 처음 알았네요

 

1 2 3 4 5 6 7 8 9 10 11 12 13

1부터 10까지의 합은 55입니다.

 

그렇다면 2부터 11까지의 합을 구하는 방법은

 

2 , 3, 4 ... 11까지 더하는 방법과

 

1부터 10의 합에서 1을 빼고 11을 더해주는 방법이 있습니다.

 

두번째 방법을 슬라이딩 윈도우 알고리즘이라고 하네요

 

 


입력받는 수가 500만 정도 되기 때문에

가능하면 시간 복잡도 O(N)과 가깝게 해결해야합니다.

 

 

 

 

1 5 2 3 6 2 3 7 3 5 2 6

1에서 최솟값은 1

 

1 5에서 최솟값은 1

 

1 5 2 에서 최솟값은 1입니다

 

5 2 3의 최솟값은 2

 

2 3 6 의 최솟값은 3

 

3 6 2의 최솟값은 2

 

...

 

하다보면 작은 수만 중요하다는 걸 알게 됩니다.

 

 

숫자를 덱에 입력받으면서,

현재 입력받은 숫자보다 앞에 등장한 수가 크다면

앞에 있는 큰 수 들을 pop 해주면서 작은 숫자 위주로 저장합니다.

 

그러다보면 자연적으로 덱의 front로 작은 숫자가 밀리게 되는데

작은 숫자의 값이 구간에 해당하지 않는다면 역시 pop 해주면 됩니다.

 

 

숫자를 하나씩 받아가면서 필요없는 건 제거해주는 과정이

슬라이딩 윈도우 알고리즘과 동일합니다.

 

 

 


 

문제풀이코드 C++

#include <bits/stdc++.h>
using namespace std;

int n, l, arr[5000001];

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);

    cin >> n >> l;

    deque<int> dq;

    for (int i = 0; i < n; i++) {
        int t;
        cin >> t;
        arr[i] = t;

        if (dq.empty()) {
            dq.push_back(t);
        }
        else {
            while (!dq.empty() && dq.back() > t) {
                dq.pop_back();
            }
            dq.push_back(t);
        }

        if ((i - l >= 0) && (arr[i - l] == dq.front())) {
            dq.pop_front();
        }

        cout << dq.front() << ' ';
    }

}

문제 11003번

 

반응형
반응형

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

 

15683번: 감시

스타트링크의 사무실은 1×1크기의 정사각형으로 나누어져 있는 N×M 크기의 직사각형으로 나타낼 수 있다. 사무실에는 총 K개의 CCTV가 설치되어져 있는데, CCTV는 5가지 종류가 있다. 각 CCTV가 감

www.acmicpc.net

#include <bits/stdc++.h>
using namespace std;

int n, m, arr[9][9], ans = INT_MAX;
vector<pair<int, int> > cctv;

void up(int arr[][9], int x, int y) {
	for (int i = x - 1; i >= 0; i--) {

		if (arr[i][y] == 0) {
			arr[i][y] = -1;
		}
		else if (arr[i][y] == 6) {
			break;
		}
	}
}

void down(int arr[][9], int x, int y) {
	for (int i = x + 1; i < n; i++) {
		if (arr[i][y] == 0) {
			arr[i][y] = -1;
		}
		else if (arr[i][y] == 6) {
			break;
		}
	}
}

void Left(int arr[][9], int x, int y) {
	for (int i = y - 1; i >= 0; i--) {
		if (arr[x][i] == 0) {
			arr[x][i] = -1;
		}
		else if (arr[x][i] == 6) {
			break;
		}
	}

}

void Right(int arr[][9], int x, int y) {
	for (int i = y + 1; i < m; i++) {
		if (arr[x][i] == 0) {
			arr[x][i] = -1;
		}
		else if (arr[x][i] == 6) {
			break;
		}
	}

}

void arr_init(int tmp[][9], int arr[][9]) {
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			tmp[i][j] = arr[i][j];
		}
	}

}

void DFS(int arr[][9], int L) {

	int tmp[9][9];
	arr_init(tmp, arr);

	if (L == cctv.size()) {

		int cnt = 0;
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				if (arr[i][j] == 0) {
					cnt++;
				}
			}
		}
		ans = min(cnt, ans);

		return;

	}
	else {
		int x = cctv[L].first;
		int y = cctv[L].second;

		if (arr[x][y] == 1) {
			up(tmp, x, y);
			DFS(tmp, L + 1);
			arr_init(tmp, arr);

			down(tmp, x, y);
			DFS(tmp, L + 1);
			arr_init(tmp, arr);

			Left(tmp, x, y);
			DFS(tmp, L + 1);
			arr_init(tmp, arr);

			Right(tmp, x, y);
			DFS(tmp, L + 1);
			arr_init(tmp, arr);

		}
		else if (arr[x][y] == 2) {
			up(tmp, x, y);
			down(tmp, x, y);
			DFS(tmp, L + 1);
			arr_init(tmp, arr);

			Left(tmp, x, y);
			Right(tmp, x, y);
			DFS(tmp, L + 1);
			arr_init(tmp, arr);

		}
		else if (arr[x][y] == 3) {
			up(tmp, x, y);
			Left(tmp, x, y);
			DFS(tmp, L + 1);
			arr_init(tmp, arr);

			up(tmp, x, y);
			Right(tmp, x, y);
			DFS(tmp, L + 1);
			arr_init(tmp, arr);

			down(tmp, x, y);
			Left(tmp, x, y);
			DFS(tmp, L + 1);
			arr_init(tmp, arr);

			down(tmp, x, y);
			Right(tmp, x, y);
			DFS(tmp, L + 1);
			arr_init(tmp, arr);
		}
		else if (arr[x][y] == 4) {
			up(tmp, x, y);
			down(tmp, x, y);
			Left(tmp, x, y);
			DFS(tmp, L + 1);
			arr_init(tmp, arr);

			up(tmp, x, y);
			down(tmp, x, y);
			Right(tmp, x, y);
			DFS(tmp, L + 1);
			arr_init(tmp, arr);

			up(tmp, x, y);
			Left(tmp, x, y);
			Right(tmp, x, y);
			DFS(tmp, L + 1);
			arr_init(tmp, arr);


			down(tmp, x, y);
			Left(tmp, x, y);
			Right(tmp, x, y);
			DFS(tmp, L + 1);
			arr_init(tmp, arr);
		}
		else if (arr[x][y] == 5) {
			up(tmp, x, y);
			down(tmp, x, y);
			Left(tmp, x, y);
			Right(tmp, x, y);
			DFS(tmp, L + 1);
			arr_init(tmp, arr);
		}
	}
}

int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);

	cin >> n >> m;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			cin >> arr[i][j];

			if (arr[i][j] > 0 && arr[i][j] <= 5) {
				cctv.push_back({ i,j });
			}
		}
	}


	DFS(arr, 0);


	cout << ans << '\n';

	return 0;
}

백준 15683번

반응형
반응형

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

 

12100번: 2048 (Easy)

첫째 줄에 보드의 크기 N (1 ≤ N ≤ 20)이 주어진다. 둘째 줄부터 N개의 줄에는 게임판의 초기 상태가 주어진다. 0은 빈 칸을 나타내며, 이외의 값은 모두 블록을 나타낸다. 블록에 쓰여 있는 수는 2

www.acmicpc.net

#include <bits/stdc++.h>
using namespace std;

int n, arr[21][21], ans = 0;



void print(int arr[][21]) {
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			cout << arr[i][j] << ' ';
		}
		cout << '\n';
	}

	cout << "---------------------------------\n";
	return;
}

void up(int arr_[][21]) {
	bool merged[21][21];
	memset(merged, 0, sizeof(merged));
	for (int i = 1; i < n; i++) {
		for (int j = 0; j < n; j++) {
			if (arr_[i][j] > 0) {
				int p = i-1;

				while ((p - 1 >= 0) && (arr_[p][j] == 0)) {
					p--;
				}

				if (arr_[p][j] == 0) {
					swap(arr_[i][j], arr_[p][j]);
				}
				else {
					if ((arr_[p][j] == arr_[i][j]) && (merged[p][j] == 0)) {
						merged[p][j] = 1;
						arr_[p][j] *= 2;
						arr_[i][j] = 0;
					}
					else {
						swap(arr_[i][j], arr_[p + 1][j]);
					}
				}
			}
		}
	}
}



void down(int arr_[][21]) {
	bool merged[21][21];
	memset(merged, 0, sizeof(merged));
	for (int i = n-2; i >= 0; i--) {
		for (int j = 0; j < n; j++) {
			if (arr_[i][j] > 0) {
				int p = i + 1;

				while ((p + 1 <= n - 1) && (arr_[p][j] == 0)) {
					p++;
				}

				if (arr_[p][j] == 0) {
					swap(arr_[i][j], arr_[p][j]);
				}
				else {
					if ((arr_[p][j] == arr_[i][j]) && (merged[p][j] == 0)) {
						merged[p][j] = 1;
						arr_[p][j] *= 2;
						arr_[i][j] = 0;
					}
					else {
						swap(arr_[i][j], arr_[p - 1][j]);
					}
				}

			
			}
		}
	}
}


void Left(int arr_[][21]) {
	bool merged[21][21];
	memset(merged, 0, sizeof(merged));
	for (int i = 0; i < n; i++) {
		for (int j = 1; j < n; j++) {
			if (arr_[i][j] > 0) {
				int p = j - 1;

				while ((p - 1 >= 0) && (arr_[i][p] == 0)) {
					p--;
				}

				if (arr_[i][p] == 0) {
					swap(arr_[i][p], arr_[i][j]);
				}
				else {
					if ((arr_[i][p] == arr_[i][j]) && (merged[i][p] == 0)) {
						merged[i][p] = 1;
						arr_[i][p] *= 2;
						arr_[i][j] = 0;
					}
					else {
						swap(arr_[i][j], arr_[i][p+1]);
					}
				}


			}
		}
	}
}



void Right(int arr_[][21]) {
	bool merged[21][21];
	memset(merged, 0, sizeof(merged));
	for (int i = 0; i < n; i++) {
		for (int j = n - 2; j >= 0; j--) {
			if (arr_[i][j] > 0) {
				int p = j + 1;

				while ((p + 1 <= n - 1) && (arr_[i][p] == 0)) {
					p++;
				}

				if (arr_[i][p] == 0) {
					swap(arr_[i][p], arr_[i][j]);
				}
				else {
					if ((arr_[i][p] == arr_[i][j]) && (merged[i][p] == 0)) {
						merged[i][p] = 1;
						arr_[i][p] *= 2;
						arr_[i][j] = 0;
					}
					else {
						swap(arr_[i][j], arr_[i][p-1]);
					}
				}

			}
		}
	}
}


void copyArray(int arr_[][21], int arr[][21]) {
	for (int i = 0; i < 21; i++) {
		for (int j = 0; j < 21; j++) {
			arr_[i][j] = arr[i][j];
		}
	}
}

void DFS(int arr[][21], int L) {

	int arr_[21][21];
	copyArray(arr_, arr);

	if (L == 5) {
		int maxx = 0;
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				maxx = max(arr[i][j], maxx);
			}
		}
		ans = max(ans, maxx);

	}
	else {
		up(arr_);
		DFS(arr_, L + 1);

		copyArray(arr_, arr);
		down(arr_);
		DFS(arr_, L + 1);


		copyArray(arr_, arr);
		Left(arr_);
		DFS(arr_, L + 1);

		copyArray(arr_, arr);
		Right(arr_);
		DFS(arr_, L + 1);

	}
}



int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);

	cin >> n;

	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			cin >> arr[i][j];
		}
	}


	DFS(arr, 0);




	cout << ans << '\n';
	return 0;
}

 

백준 12100번 2048

반응형
반응형

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

 

12094번: 2048 (Hard)

첫째 줄에 보드의 크기 N (1 ≤ N ≤ 20)이 주어진다. 둘째 줄부터 N개의 줄에는 게임판의 초기 상태가 주어진다. 0은 빈 칸을 나타내며, 이외의 값은 모두 블록을 나타낸다. 블록에 쓰여 있는 수는 2

www.acmicpc.net

 

#include <bits/stdc++.h>
using namespace std;

int n, arr[21][21], ans = 0, real_ans=0;
int L_max[11];

void up(int arr_[][21]) {
	bool merged[21][21];
	memset(merged, 0, sizeof(merged));
	for (int i = 1; i < n; i++) {
		for (int j = 0; j < n; j++) {
			if (arr_[i][j] > 0) {
				int p = i-1;

				while ((p - 1 >= 0) && (arr_[p][j] == 0)) {
					p--;
				}

				if (arr_[p][j] == 0) {
					swap(arr_[i][j], arr_[p][j]);
				}
				else {
					if ((arr_[p][j] == arr_[i][j]) && (merged[p][j] == 0)) {
						merged[p][j] = 1;
						arr_[p][j] *= 2;
						arr_[i][j] = 0;
					}
					else {
						swap(arr_[i][j], arr_[p + 1][j]);
					}
				}
			}
		}
	}
}


void down(int arr_[][21]) {
	bool merged[21][21];
	memset(merged, 0, sizeof(merged));
	for (int i = n-2; i >= 0; i--) {
		for (int j = 0; j < n; j++) {
			if (arr_[i][j] > 0) {
				int p = i + 1;

				while ((p + 1 <= n - 1) && (arr_[p][j] == 0)) {
					p++;
				}

				if (arr_[p][j] == 0) {
					swap(arr_[i][j], arr_[p][j]);
				}
				else {
					if ((arr_[p][j] == arr_[i][j]) && (merged[p][j] == 0)) {
						merged[p][j] = 1;
						arr_[p][j] *= 2;
						arr_[i][j] = 0;
					}
					else {
						swap(arr_[i][j], arr_[p - 1][j]);
					}
				}
			}
		}
	}
}


void Left(int arr_[][21]) {
	bool merged[21][21];
	memset(merged, 0, sizeof(merged));
	for (int i = 0; i < n; i++) {
		for (int j = 1; j < n; j++) {
			if (arr_[i][j] > 0) {
				int p = j - 1;

				while ((p - 1 >= 0) && (arr_[i][p] == 0)) {
					p--;
				}

				if (arr_[i][p] == 0) {
					swap(arr_[i][p], arr_[i][j]);
				}
				else {
					if ((arr_[i][p] == arr_[i][j]) && (merged[i][p] == 0)) {
						merged[i][p] = 1;
						arr_[i][p] *= 2;
						arr_[i][j] = 0;
					}
					else {
						swap(arr_[i][j], arr_[i][p+1]);
					}
				}
			}
		}
	}
}


void Right(int arr_[][21]) {
	bool merged[21][21];
	memset(merged, 0, sizeof(merged));
	for (int i = 0; i < n; i++) {
		for (int j = n - 2; j >= 0; j--) {
			if (arr_[i][j] > 0) {
				int p = j + 1;

				while ((p + 1 <= n - 1) && (arr_[i][p] == 0)) {
					p++;
				}

				if (arr_[i][p] == 0) {
					swap(arr_[i][p], arr_[i][j]);
				}
				else {
					if ((arr_[i][p] == arr_[i][j]) && (merged[i][p] == 0)) {
						merged[i][p] = 1;
						arr_[i][p] *= 2;
						arr_[i][j] = 0;
					}
					else {
						swap(arr_[i][j], arr_[i][p-1]);
					}
				}

			}
		}
	}
}

void copyArray(int arr_[][21], int arr[][21]) {
	for (int i = 0; i < 21; i++) {
		for (int j = 0; j < 21; j++) {
			arr_[i][j] = arr[i][j];
		}
	}
}

bool isdif(int arr_[][21], int arr[][21]){
	for (int i = 0; i < 21; i++) {
		for (int j = 0; j < 21; j++) {
			if (arr_[i][j] != arr[i][j]) {
				return true;
			}
		}
	}
	return false;
}


void DFS(int arr[][21], int L) {
	int arr_[21][21];
	copyArray(arr_, arr);

	int maxx = 0;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			maxx = max(arr[i][j], maxx);
		}
	}

	if (maxx <= L_max[L]) {
		return;
	}

	real_ans = max(real_ans, maxx);

	if (L == 10) {
		if (ans < maxx) {
			ans = maxx;

			int tmp = ans;
			while (L > 0) {
				L_max[L--] = tmp;
				tmp /= 2;
			}
		}
		return;
	}


	else {
		up(arr_);
		if (isdif(arr_, arr)) DFS(arr_, L + 1);

		copyArray(arr_, arr);
		down(arr_);
		if (isdif(arr_, arr)) DFS(arr_, L + 1);

		copyArray(arr_, arr);
		Left(arr_);
		if (isdif(arr_, arr)) DFS(arr_, L + 1);

		copyArray(arr_, arr);
		Right(arr_);
		if (isdif(arr_, arr)) DFS(arr_, L + 1);
	}
}


int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);

	cin >> n;

	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			cin >> arr[i][j];
		}
	}

	DFS(arr, 0);

	cout << real_ans << '\n';


	return 0;
}

반응형
반응형

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

 

10423번: 전기가 부족해

첫째 줄에는 도시의 개수 N(1 ≤ N ≤ 1,000)과 설치 가능한 케이블의 수 M(1 ≤ M ≤ 100,000)개, 발전소의 개수 K(1 ≤ K ≤ N)개가 주어진다. 둘째 줄에는 발전소가 설치된 도시의 번호가 주어진다. 셋째

www.acmicpc.net

#include <bits/stdc++.h>
using namespace std;


vector<char> elec;
vector<pair<int, int> > graph[1001];

struct Edge {
	int x, val;
	bool operator<(const Edge& b) const {
		return val > b.val;
	}
};

bool vis[1001];
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);

	int n, m, k;
	cin >> n >> m >> k;

	priority_queue<Edge> Q;


	for (int i = 0; i < k; i++) {
		int c;
		cin >> c;
		Q.push({ c,0 });
	}

	for (int i = 0; i < m; i++) {
		int a, b, c;
		cin >> a >> b >> c;
		graph[a].push_back({ b,c });
		graph[b].push_back({ a,c });
	}

	int ans = 0;

	while (!Q.empty()) {
		int x = Q.top().x;
		int val = Q.top().val;
		Q.pop();

		if (vis[x] == 0) {
			vis[x] = 1;
			ans += val;

			for (int i = 0; i < graph[x].size(); i++) {
				int nx = graph[x][i].first;
				int nd = graph[x][i].second;

				if (vis[nx] == 0) {
					Q.push({ nx,nd });
				}
			}
		}
	}

	cout << ans << '\n';
	

	return 0;
}

백준 10423번 전기가 부족해

반응형
반응형

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

 

1774번: 우주신과의 교감

(1,1) (3,1) (2,3) (4,3) 이렇게 우주신들과 황선자씨의 좌표가 주어졌고 1번하고 4번이 연결되어 있다. 그렇다면 1번하고 2번을 잇는 통로를 만들고 3번하고 4번을 잇는 통로를 만들면 신들과 선자씨끼

www.acmicpc.net

#include <bits/stdc++.h>
using namespace std;

int unf[1001];

int Find(int x) {
	if (x == unf[x]) {
		return x;
	}
	else return unf[x] = Find(unf[x]);
}

void Union(int a, int b) {
	a = Find(a);
	b = Find(b);
	if (a != b) {
		unf[a] = b;
	}
}

struct Edge {
	int x, y;
	double val;
	bool operator<(const Edge& b)const {
		return val > b.val;
	}
};

double distance(int x1, int y1, int x2, int y2) {
	return sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2));
}

int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);

	int n, m;
	cin >> n >> m;

	priority_queue<Edge> Q;
	for (int i = 0; i < 1001; i++) {
		unf[i] = i;
	}

	vector<pair<int,int> > v;
	for (int i = 0; i < n; i++) {
		int a, b;
		cin >> a >> b;
		v.push_back({ a, b });
	}

	for (int i = 0; i < m; i++) {
		int a, b;
		cin >> a >> b;
		Union(a-1, b-1);
	}


	for (int i = 0; i < n; i++) {
		for (int j = i + 1; j < n; j++) {
			double dist = distance(v[i].first, v[i].second, v[j].first, v[j].second);
			Q.push({ i,j,dist });
		}
	}

	double ans = 0;

	while (!Q.empty()) {
		int x = Q.top().x;
		int y = Q.top().y;
		double val = Q.top().val;
		Q.pop();

		if (Find(x) != Find(y)) {
			Union(x, y);
			ans += val;
		}
	}

	cout << fixed;
	cout.precision(2);
	cout << ans << '\n';

	return 0;
}

백준 1774번

 

반응형

+ Recent posts