diff --git "a/11\354\233\224 30\354\235\274/1368.cpp" "b/11\354\233\224 30\354\235\274/1368.cpp" new file mode 100644 index 0000000..7a278f3 --- /dev/null +++ "b/11\354\233\224 30\354\235\274/1368.cpp" @@ -0,0 +1,68 @@ +#include +#include +#include + +using namespace std; +const int INF = 1e5 + 1; //상수 선언 + +int prim(int size, int start, vector>& graph) { + int sum = 0; //초기화 + vector dist(size, INF); //각 논까지의 비용 + vector visited(size, false); //논 방문 여부 + priority_queue, vector>, greater<>> pq; //우선순위 큐 선언 + + //초기화 + dist[start] = 0; + pq.push({ 0, start }); + + while (!pq.empty()) { + int cost = pq.top().first; //간선 가중치 + int cur = pq.top().second; //현재 논 + pq.pop(); //제거하기 + + if (visited[cur]) //이미 확인했던 정점 + continue; + sum += cost; //MST 간선 가중치 총합 + visited[cur] = true; //방문 처리 + + for (int i = 0; i < size; i++) { //반복문돌기 + if (!visited[i] && graph[cur][i] < dist[i]) { //미방문 정점이면서 더 짧은 간선을 통해 갈 수 있다면 + dist[i] = graph[cur][i]; //갱신후 + pq.push({ dist[i], i }); //우선순위 큐에 넣어주기 + } + } + } + return sum; //반환 +} + +/** + * 각 논들 사이의 간선도 고려하고, 우물을 파는 경우도 고려? -> 복잡 + * 논에 추가로 모든 우물과 연결되는 수원이 있다고 가정! + * ->직접 논에 우물을 파는 경우는 수원과 각 논 사이의 간선 가중치라고 할 수 있음 + * + * 0 2 2 2 5 + * 2 0 3 3 4 + * 2 3 0 4 4 + * 2 3 4 0 3 + * 5 4 4 3 0 + * + * 인덱스 0 ~ n-1은 논, 인덱스 n은 수원 + * 1개 이상의 논은 반드시 직접 우물을 파야 하므로 수원(n)에서 시작하는 프림 알고리즘 + */ +int main() { + int n, w; //선언 + + cin >> n; //입력 + vector> graph(n + 1, vector(n + 1, 0)); //이중배열 초기화 + for (int i = 0; i < n; i++) { //수원으로부터 물을 끌어오는 비용 + cin >> w; //입력 + graph[i][n] = graph[n][i] = w; //그래프 무방향 표시 + } + + for (int i = 0; i < n; i++) { //반복문 돌면서 그래프 노드(비용) 입력 + for (int j = 0; j < n; j++) + cin >> graph[i][j]; //논들 사이에서 물을 끌어오는 비용 + } + + cout << prim(n + 1, n, graph); //수원에서 시작하는 프림 알고리즘 +} \ No newline at end of file diff --git "a/11\354\233\224 30\354\235\274/16202.cpp" "b/11\354\233\224 30\354\235\274/16202.cpp" new file mode 100644 index 0000000..547119c --- /dev/null +++ "b/11\354\233\224 30\354\235\274/16202.cpp" @@ -0,0 +1,87 @@ +#include +#include +#include +#include + +using namespace std; +typedef tuple tp; //튜플 선언 + +vector parent; //부모 배열 + +//Find 연산 +int findParent(int node) { + if (parent[node] < 0) //값이 음수면 루트 정점 + return node; //node 반환 + return parent[node] = findParent(parent[node]); //그래프 압축하며 루트 정점 찾기 +} + +//Union 연산 +bool unionInput(int x, int y) { + int xp = findParent(x); //부모찾기 + int yp = findParent(y); //부모찾기 + + if (xp == yp) //같은 집합에 있다면 유니온 할 수 없음 + return false; //유니온 불가 + if (parent[xp] < parent[yp]) { //새로운 루트 xp + parent[xp] += parent[yp]; //노드개수 표시 + parent[yp] = xp; //xp를 부모로 + } + else { //새로운 루트 yp + parent[yp] += parent[xp]; //노드개수 표시 + parent[xp] = yp; //yp를 부모로 + } + return true; //유니온했음 +} + +int kruskal(int n, int idx, vector& edges) { + int cnt = 0, sum = 0; //초기화 + for (int i = idx; i < edges.size(); i++) { + if (cnt == n - 1) //n-1개의 간선을 모두 연결함 + break;//중단 + int dist = get<0>(edges[i]); //튜플값 받아오기 + int x = get<1>(edges[i]);//튜플값 받아오기 + int y = get<2>(edges[i]);//튜플값 받아오기 + + if (unionInput(x, y)) { //union하기 + cnt++; //개수 추가 + sum += dist; //거리 증가 + } + } + if (cnt < n - 1) //mst를 만들 수 없음 + return 0; //0으로 표시 + return sum; //거리 반환 +} + +/** + * MST 알고리즘을 여러 번 실행해도 될까? + * 1. 크루스칼 알고리즘의 시간 복잡도는 O(ElogE) + * 이는 오직 간선을 정렬하는 연산의 시간 복잡도! + * 즉, 모든 간선을 한 번 정렬해서 저장해두면 이후 몇 번의 알고리즘을 수행하여도 연산 시간에 큰 영향이 없음 + * 2. 간선 재사용을 위해 우선순위 큐가 아닌 벡터에 저장하고 크루스칼 알고리즘 k번 실행 + * 3. 매번 크루스칼을 수행할 때마다 제일 먼저 추가한 간선을 제외함 + * -> 제외될 간선은 배열의 0번째 간선부터 1, 2, 3번째 간선으로 순차적 제외 + * 4. 만약 한 번 MST를 만들 수 없다는게 확인됐다면 이후에도 MST를 만들 수 없으므로 flag 변수로 불필요한 연산 절약 + */ +int main() { + int n, m, k, x, y; //초기화 + + cin >> n >> m >> k; //입력 + vector edges; //재사용할거라 우선순위 큐가 아닌 벡터에 저장 + for (int i = 1; i <= m; i++) { //반복 + cin >> x >> y; //입력 + edges.emplace_back(i, x, y); //튜플벡터에 넣어준다 + } + + bool flag = false; //flag + for (int i = 0; i < k; i++) { //반복돌면서 mst만든다 + if (flag) { //더이상 mst를 만들 수 없음 + cout << 0 << ' '; + continue; + } + parent.assign(n + 1, -1); //초기화 + int ans = kruskal(n, i, edges); //sum받기 + if (ans == 0) //0이면 mst를 만들수없다는 뜻으로 flag표시 + flag = true; //true로 해서 위에서 conitnue하도록 만든다 + cout << ans << ' '; //ans출력 + } +} \ No newline at end of file diff --git "a/11\354\233\224 30\354\235\274/16235.cpp" "b/11\354\233\224 30\354\235\274/16235.cpp" new file mode 100644 index 0000000..f0300fc --- /dev/null +++ "b/11\354\233\224 30\354\235\274/16235.cpp" @@ -0,0 +1,116 @@ +#include +#include +#include +#include +#include +#include + +using namespace std; +typedef vector> matrix; //이중배열 +typedef tuple tp; //튜플 요소 3개 + +queue spring(matrix& land, deque& tree, queue>& breeding_tree) { + queue dead_tree; //queue선언 + int size = tree.size(); //size 선언 + while (size--) { //모든 나무 검사 + int age = get<0>(tree.front()); //나이 + int row = get<1>(tree.front()); //행 + int col = get<2>(tree.front()); //열 + tree.pop_front(); //앞에 있는 값을 제거한다. + + if (land[row][col] < age) { //자신의 나이만큼 양분을 먹을 수 없다면 + dead_tree.push({ age, row, col }); //죽었다고 표시 + continue; //계속하기 + } + land[row][col] -= age; //나이만큼 제외하기 + tree.emplace_back(age + 1, row, col); //트리에 새로 추가 + if ((age + 1) % 5 == 0) //나이가 5의 배수라면 + breeding_tree.push({ row, col }); //새로 추가 + } + return dead_tree; +} + +void summer(queue& dead_tree, matrix& land) { + while (!dead_tree.empty()) { //죽은 나무가 있는 배열이 비어있지않다면 + int age = get<0>(dead_tree.front()); //죽은 나무의 나이 + int row = get<1>(dead_tree.front()); //죽은 나무의 행 위치 + int col = get<2>(dead_tree.front()); //죽은 나무의 열 위치 + dead_tree.pop(); //하나씩 뺀다 + land[row][col] += (age / 2); //land에 갱신 + } +} + +void fall(int n, deque& tree, queue>& breeding_tree) { + int dr[8] = { -1, 1, 0, 0, -1, -1, 1, 1 }; //방향표시 상하좌우 대각선 + int dc[8] = { 0, 0, -1, 1, -1, 1, -1, 1 }; //방향표시 + + while (!breeding_tree.empty()) { + int row = breeding_tree.front().first; //번식할 나무의 행 + int col = breeding_tree.front().second; //번식할 나무의 열 + breeding_tree.pop(); //번식나누에 있는거 하나빼기 + + for (int j = 0; j < 8; j++) { //방향돌려보기 + int nr = row + dr[j]; //행 + int nc = col + dc[j]; //열 + if (nr < 0 || nr >= n || nc < 0 || nc >= n) //배열 범위를 넘어섰다면 제외 + continue; //반복문 재시작 + tree.push_front({ 1, nr, nc }); //새로 생긴 나무 + } + } +} + +void winter(int n, matrix& a, matrix& land) { + for (int i = 0; i < n; i++) //반복문 돌면서 land 새로 추가 + for (int j = 0; j < n; j++) //이중반복문 + land[i][j] += a[i][j]; //land 추가 +} + +/** + * [문제 설명] - 단순 구현 문제 + * 봄: 하나의 칸마다 나이가 어린 나무부터 자신의 나이만큼 양분을 먹고, 나이가 1 증가함 + * 각 칸에 양분이 부족해 자신의 나이만큼 양분을 못 먹는 나무는 즉시 죽음 + * 여름: 봄에 죽은 나무가 양분으로 변함. 죽은 나무마다 나이를 2로 나눈 값이 양분으로 추가 (소수점 버림) + * 가을: 나이가 5의 배수인 나무가 번식. 인접한 8개 칸에 나이가 1인 나무가 생김 + * 겨울: 로봇(S2D2)이 땅을 돌아다니면서 A[r][c]만큼 각 칸에 양분 추가 + * + * K년이 지난 후 상도의 땅에 살아있는 나무의 개수 + * + * [문제 풀이] + * a: 로봇(S2D2)가 겨울에 주는 양분의 양 + * land: 땅의 양분 + * breeding_tree: 나이가 5의 배수인 트리 (번식할 트리) + * tree: 땅에 심은 나무 나이, 행, 열 정보 + * -> deque 컨테이너를 활용해 번식한 나무를 앞에 넣어주면 입력 후에만 정렬해서 사용 가능 + * + * 문제의 설명대로 계절별 연산을 진행 + */ + +int main() { + int n, m, k, x, y, z; + + //입력 + cin >> n >> m >> k; + matrix a(n, vector(n, 0)); //초기화 + matrix land(n, vector(n, 5)); //처음 양분 모든 칸에 5 + queue> breeding_tree; //번식할 트리 + deque tree; //tree전체 + for (int i = 0; i < n; i++) + for (int j = 0; j < n; j++) + cin >> a[i][j]; //반복문 돌면서 입력받기 + while (m--) { + cin >> x >> y >> z; //입력 + tree.emplace_back(z, x - 1, y - 1); //(0, 0)부터 시작하도록 구현하기위해 1을 빼준 인덱스에 접근 + } + + //연산 + sort(tree.begin(), tree.end()); //어린 나이 순으로 정렬 + while (k--) { //k만큼 반복돌기 + queue dead_tree = spring(land, tree, breeding_tree); //봄이 지나고 죽은 나무 + summer(dead_tree, land); //여름 + fall(n, tree, breeding_tree); //가을 + winter(n, a, land); //겨울 + } + + //출력 + cout << tree.size(); //나무 크기 출력 +} \ No newline at end of file diff --git "a/11\354\233\224 30\354\235\274/1713.cpp" "b/11\354\233\224 30\354\235\274/1713.cpp" new file mode 100644 index 0000000..1a76969 --- /dev/null +++ "b/11\354\233\224 30\354\235\274/1713.cpp" @@ -0,0 +1,54 @@ +#include +#include +#include + +using namespace std; +typedef pair ci; //pair재정의 + +map::iterator delCandidate(map& candidate) { + auto del = candidate.begin(); //처음 후보를 삭제한다 가정 + int cnt = candidate.begin()->second.first; //처음 후보의 추천 횟수 + int t = candidate.begin()->second.second; //처음 후보의 게시 시간 + for (auto iter = ++candidate.begin(); iter != candidate.end(); iter++) { //후보 반복돌면서 + int cur_cnt = iter->second.first; //추천횟수 + int cur_t = iter->second.second; //게시시간 + if (cur_cnt < cnt) { //추천 횟수가 가장 작은 후보 찾기 + cnt = cur_cnt; //추천 획수 갱신 + t = cur_t; //게시시간 갱신 + del = iter; //del에 넣기 + } + else if (cur_cnt == cnt && cur_t < t) { //추천 횟수가 가장 작은 후보가 여러명이라면, 게시 시간이 오래된 후보 찾기 + t = cur_t; //게시시간 갱신 + del = iter; //del에 넣기 + } + } + return del; //반환 +} + +/** + * 1. 비어있는 사진틀이 없는 경우, 가장 추천수가 작은 학생 중 게시 시간이 오래된 학생을 삭제 + * 2. 후보 학생을 바로 찾기 위해 본 풀이는 map 컨테이너를 사용해 구현 + * + * !주의! 게시 시간 정보 저장 시, 후보로 올라간 가장 첫 시간을 저장. 이미 후보에 있는데 게시 시간이 갱신되지 않도록 주의. + */ + +int main() { + int n, m, input; //변수선언 + + //입력 & 연산 + cin >> n >> m; + map candidate; //first: 후보 학생, second: {추천 횟수, 게시 시간} + for (int i = 0; i < m; i++) { //반복문 돌면서 + cin >> input; //입력받기 + if (candidate.size() == n && candidate.find(input) == candidate.end()) //비어있는 사진틀이 없는 경우 + candidate.erase(delCandidate(candidate)); //제거 + + if (candidate.find(input) == candidate.end()) //첫 게시라면 + candidate[input].second = i; //초기화 + candidate[input].first++; //추천 횟수 증가 + } + + //출력 + for (auto iter = candidate.begin(); iter != candidate.end(); iter++) + cout << iter->first << ' '; //정답 출력 +} \ No newline at end of file diff --git "a/11\354\233\224 30\354\235\274/1774.cpp" "b/11\354\233\224 30\354\235\274/1774.cpp" new file mode 100644 index 0000000..b38ebd1 --- /dev/null +++ "b/11\354\233\224 30\354\235\274/1774.cpp" @@ -0,0 +1,98 @@ +#include +#include +#include +#include +#include + +using namespace std; +typedef pair ci; //pair ci로 재선언 +typedef tuple tp; //tuple 선언 + +vector parent; //parent 배열 + +//Find 연산 +int findParent(int node) { + if (parent[node] < 0) //값이 음수면 루트 정점 + return node; //node 반환 + return parent[node] = findParent(parent[node]); //그래프 압축하며 루트 정점 찾기 +} + +//Union 연산 +bool unionInput(int x, int y) { + int xp = findParent(x); //부모찾기 + int yp = findParent(y); //부모찾기 + + if (xp == yp) //같은 집합에 있다면 유니온 할 수 없음 + return false; //못하므로 false반환 + if (parent[xp] < parent[yp]) { //새로운 루트 xp + parent[xp] += parent[yp]; //가장 노드 개수 많은게 부모할수있게 표시 + parent[yp] = xp; //xp를 부모로 + } + else { //새로운 루트 yp + parent[yp] += parent[xp]; //가장 노드 개수 많은게 부모할수있게 표시 + parent[xp] = yp; //yp를 부모로 + } + return true; //true반환 +} + +double kruskal(int v, priority_queue, greater<>>& pq) { + int cnt = 0; //초기화 + double sum = 0; //초기화 + + while (cnt < v - 1) { //사용한 간선의 수가 v-1보다 적을 동안 + double cost = get<0>(pq.top()); //cost에 넣어주고 + int x = get<1>(pq.top()); //각각 x + int y = get<2>(pq.top());//y에 넣어준다/ + + pq.pop();//그후 제거 + if (unionInput(x, y)) { //유니온 했다면 + cnt++; //사용된 간선 증가 + sum += cost; //간선의 가중치 + } + } + return sum; //가중치 반환 +} + +/** + * 4386번 : 별자리 만들기의 응용 문제 + * 이미 연결된 정점들이 존재한다는 것을 제외하고는 4386번과 동일 + * + * 1. 임의의 두 별에 대한 거리(간선) 모두 구하기 + * 2. 이미 존재하는 통로들 표시 + * !주의! 통로의 개수가 m개라면 v-m-1개의 간선만 더 추가하면 될까? + * 이미 연결된 통로들도 사이클을 이룰 수 있기 때문에 유니온 연산을 하며 사이클 없이 연결된 간선만 세기 + * 3. 이미 연결된 통로의 수를 k개라고 하면 v-k-1개의 간선을 추가로 선택 + */ +int main() { + //초기화 + int n, m, a, b, v = 0; + priority_queue, greater<>> pq; + + //입력 + cin >> n >> m; + parent.assign(n + 1, -1); //재초기화 + vector stars(n + 1); //초기화 + for (int i = 1; i <= n; i++) //입력 + cin >> stars[i].first >> stars[i].second; + + + //연산 + //임의의 두 별에 대한 거리(간선) 모두 구하기 + for (int i = 1; i <= n - 1; i++) { //반복문 돌면서 + for (int j = i + 1; j <= n; j++) { + double xd = stars[i].first - stars[j].first; //간선 구해서 넣어준다 + double yd = stars[i].second - stars[j].second; //간선 구하기 + pq.push({ sqrt(xd * xd + yd * yd), i, j }); //구한 간선을 pq에 넣어준다 + } + } + while (m--) { //m만큼 반복문 돌면서 + cin >> a >> b; //입력 + if (unionInput(a, b)) //이미 연결된 통로 + v++; + } + + //연산 & 출력 + cout << fixed; //소수점 고정 + cout.precision(2); //2자리까지 + cout << kruskal(n - v, pq); //출력 +} \ No newline at end of file