diff --git "a/12\354\233\224 7\354\235\274/23059.cpp" "b/12\354\233\224 7\354\235\274/23059.cpp" new file mode 100644 index 0000000..178b8fe --- /dev/null +++ "b/12\354\233\224 7\354\235\274/23059.cpp" @@ -0,0 +1,80 @@ +#include +#include +#include +#include +#include + +using namespace std; + +unordered_map indegree; +unordered_map> graph; + +//위상정렬 +vector topologicalSort(set& item) { + vector result; //result배열 + priority_queue, greater<>> pq, pq_temp; //우선순위 큐 + + for (auto iter = item.begin(); iter != item.end(); iter++) { //아이템 확인하면서 + if (indegree.find(*iter) == indegree.end()) //진입차수가 존재하지 않는다면(0 이라면) + pq.push(*iter); //큐에 넣는다. + } + while (!pq.empty()) { //비어있지않다면 + string node = pq.top(); //node에 top(위에있는 값을 넣고) + pq.pop(); //큐에서 제거한다 + + result.push_back(node); //현재 정점 순서에 삽입 + for (int i = 0; i < graph[node].size(); i++) { //그 정점에서 연결된 노드전부확인 + string next_node = graph[node][i]; //다음 노드 방문 + indegree[next_node]--; //연결된 정점의 진입차수를 1씩 감소 + if (indegree[next_node] == 0) //연결된 정점의 진입차수가 0이 되었다면 + pq_temp.push(next_node); //우선 pq_temp에 삽입 + } + if (pq.empty() && !pq_temp.empty()) //이전에 진입차수가 0이였던 정점을 모두 탐색했고, 새로 탐색할 정점이 있다면 + swap(pq, pq_temp); //swap + } + return result; //result배열 반환 +} + +/** + * 문자열을 인덱스로 사용해야 하기때문에 map을 사용 + * + * !주의! 일반 map을 사용하면 시간초과. 따라서 map보다 검색 속도가 빠른 unordered_map 사용해야 함 + * -> map은 이진 탐색 트리 형태로 key값을 정렬해서 시간 복잡도가 logN 이지만, unordered_map은 hash형태로 저장해서 시간 복잡도가 1이다 + * !주의! 위상 정렬을 할 때 원래는 여러 결과가 가능하지만 해당 문제는 순서배치가 중요 (순서는 예제 3 참고) + * 1. 진입차수가 0인 정점들끼리 정렬해서 사용해야 함 + * 2. 진입차수가 0인 정점이 동시에 여러 개일 경우 해당 정점들을 먼저 순서에 배치해야 함. + * -> 따라서 우선순위 큐를 사용하여 진입차수가 0인 정점들을 관리. 이때 동시에 진입차수가 0이 된 정점들을 먼저 배치해야 하므로 우선순위 큐를 2개 사용. + */ + +int main() { + ios_base::sync_with_stdio(false); + cin.tie(NULL); + cout.tie(NULL); + + set item; //존재하는 아이템(정점) + int n; + string a, b; + + //입력 + cin >> n; + while (n--) { //입력수만큼 노드 입력 + cin >> a >> b; //a < b + indegree[b]++; //진입차수 증가 + graph[a].push_back(b); //단방향 그래프 + item.insert(a); //아이템 삽입 + item.insert(b); //아이템 삽입 + } + + //연산 + vector result = topologicalSort(item); + + //출력 + if (result.size() != item.size()) { + cout << "-1\n"; //-1출력 + return 0; //끝 + } + for (int i = 0; i < result.size(); i++) //배열 크기만큼 돌면서 + cout << result[i] << '\n'; //배열 출력 + + return 0; //끝 +} \ No newline at end of file diff --git "a/12\354\233\224 7\354\235\274/2623.cpp" "b/12\354\233\224 7\354\235\274/2623.cpp" new file mode 100644 index 0000000..dfa8970 --- /dev/null +++ "b/12\354\233\224 7\354\235\274/2623.cpp" @@ -0,0 +1,66 @@ +#include +#include +#include + +using namespace std; + +//위상정렬 +vector topologicalSort(int n, vector& indegree, vector>& graph) { + vector result; //배열형성 + queue q; //큐 형성 + + for (int i = 1; i <= n; i++) { //반복문 돌면서 + if (!indegree[i]) //진입차수가 0이라면 + q.push(i); //큐에 넣기 + } + + while (!q.empty()) { //비어있지않으면 + int node = q.front(); //가장 먼저 넣은 값을 꺼낸뒤 + q.pop(); //pop하여 제거 + + result.push_back(node); //현재 정점 순서에 삽입 + for (int i = 0; i < graph[node].size(); i++) { //그래프를 다 돌면서 + int next_node = graph[node][i]; //다음 노드를 찾고 + indegree[next_node]--; //연결된 정점의 진입차수를 1씩 감소 + if (!indegree[next_node]) //연결된 정점의 진입차수가 0이 되었다면 + q.push(next_node); //next_node를 큐에 넣는다. + } + } + return result;//정점순서대로 삽입된 배열 반환 +} + +/** + * 기본적인 위상 정렬 문제 + * 현재 가수와 바로 전 가수 사이의 선후관계를 정의 + * 순서를 정하는 것이 불가능한 경우(위상정렬을 할 수 없는 경우)는 모든 정점을 탐색하지 못한 경우 + */ + +int main() { + int n, m, cnt, prev, cur; //초기화 + + //입력 + cin >> n >> m; //입력 + vector indegree(n + 1, 0); //배열 초기화 + vector> graph(n + 1, vector(0)); //그래프 초기화 + while (m--) { //m개수 만큼 + cin >> cnt; //담당 가수의 수 + cin >> prev; //처음 가수 입력 + while (--cnt) { //선후관계 정의 + cin >> cur; //입력 + indegree[cur]++; //진입차수 증가 + graph[prev].push_back(cur);//그래프에 넣기 + prev = cur; //갱신 + } + } + + //연산 + vector result = topologicalSort(n, indegree, graph); //위상정렬한값을 result로 반환받기 + + //출력 + if (result.size() != n) { //순서를 정하는 것이 불가한 경우 + cout << "0\n"; //0을 출력하고 + return 0; //끝 + } + for (int i = 0; i < result.size(); i++) //배열값을 출력해서 + cout << result[i] << '\n'; //정렬된 값을 보여준다. +} \ No newline at end of file diff --git "a/12\354\233\224 7\354\235\274/2637.cpp" "b/12\354\233\224 7\354\235\274/2637.cpp" new file mode 100644 index 0000000..4d36051 --- /dev/null +++ "b/12\354\233\224 7\354\235\274/2637.cpp" @@ -0,0 +1,64 @@ +#include +#include +#include + +using namespace std; +typedef pair ci; + +//위상정렬 + DP +vector> topologicalSort(int n, vector& indegree, vector>& graph) { + queue q; //큐 배열 + vector> dp(n + 1, vector(n + 1, 0)); //각 부품이 몇 개 필요한지 저장 + + for (int i = 1; i <= n; i++) { //반복하면서 진입차수 확인 + if (!indegree[i]) { //진입차수가 0이라면 -> 기본 부품 + q.push(i); //큐 넣기 + dp[i][i] = 1; //기본 부품 초기화 + } + } + while (!q.empty()) { //큐 비어있지않다면 + int node = q.front(); //가장 먼저 넣은 값을 꺼낸뒤 + q.pop(); //큐에서 제거한다 + + for (int i = 0; i < graph[node].size(); i++) { //그래프 다 돌면서 + int next_node = graph[node][i].first; //다음 노드를 찾아서 확인한다 + int cnt = graph[node][i].second; //필요한 부품 수 + indegree[next_node]--; //연결된 정점의 진입차수를 1씩 감소 + if (!indegree[next_node]) //연결된 정점의 진입차수가 0이 되었다면 + q.push(next_node); //큐에서 제거 + + for (int j = 1; j <= n; j++) //반복문 돌면서 + dp[next_node][j] += dp[node][j] * cnt; //(현재 정점을 이루는 부품 개수 * 필요한 현재 정점의 개수)를 더함 + } + } + return dp; //dp반환 +} + +/** + * 각 부품마다 종류별 필요한 부품 개수를 저장하기 위해 2차원 배열 사용 (행: 부품, 열: 행을 이루는데 각 부품별 필요한 개수) + * 위상 정렬 순서에 따라, 이어진 다음 정점의 부품별 개수를 (현재 정점을 이루는 부품별 개수 * 필요한 현재 정점 수)를 더해주며 구함 + */ + +int main() { + int n, m, x, y, k; //초기화 + + //입력 + cin >> n >> m; + vector> graph(n + 1, vector(0)); //그래프 초기화 + vector indegree(n + 1, 0); //진입차수 초기화 + while (m--) { //m개만큼 입력 + cin >> x >> y >> k; //y -> x + indegree[x]++; //진입차수 증가 + graph[y].push_back({ x, k }); //그래프에 넣기 + } + + //연산 + vector> result = topologicalSort(n, indegree, graph); + + //출력 + for (int i = 1; i <= n; i++) { + if (result[i][i]) //기본 부품이라면 + cout << i << ' ' << result[n][i] << '\n'; //출력 + } + return 0; //끝 +} \ No newline at end of file diff --git "a/12\354\233\224 7\354\235\274/3085.cpp" "b/12\354\233\224 7\354\235\274/3085.cpp" new file mode 100644 index 0000000..2e278b7 --- /dev/null +++ "b/12\354\233\224 7\354\235\274/3085.cpp" @@ -0,0 +1,76 @@ +#include +#include +#include + +using namespace std; + +vector> board; +int dr[2] = { 1, 0 }; +int dc[2] = { 0, 1 }; + +int cntCandy(int n, int row, int col, int dir) { + int ans = 0, cnt = 0; //초기화 + char cur = ' '; //초기화 + for (int i = 0; i < n; i++) { //입력된 값만큼 반복문을 돌면서 + if (cur == board[row][col]) { //연속된 사탕 + cnt++; //cnt를 증가시키고 + ans = max(ans, cnt); //최대값을 ans에 넣는다 + } + else { //불연속 + cnt = 1; //cnt횟ㅅ를 초기화 시키고 + cur = board[row][col]; //현재값을 cur에 넣는다. + } + row += dr[dir]; //방향 바꾸기 + col += dc[dir]; //열 방향 바꾸기 + } + return ans; //ans값반환(캔디 개수) +} + +int findCandy(int n) { + int ans = 0; //초기화 + for (int i = 0; i < n; i++) { //반복문을 돌면서 + ans = max(ans, cntCandy(n, 0, i, 0)); //같은 열에 대해 + ans = max(ans, cntCandy(n, i, 0, 1)); //같은 행에 대해 + } + return ans; //cntCandy를 통해 얻은 max값을 찾는다 +} + +int switchCandy(int n, int row, int col, char candy) { + int ans = 0; //초기화 + for (int i = 0; i < 2; i++) { //오른쪽, 아래에 있는 사탕과 바꿔보기 + int nr = row + dr[i], nc = col + dc[i]; //행,열 방향 바꾸기 + if (nr < n && nc < n && candy != board[nr][nc]) { //범위내에있고 board에 없는 값이면 + swap(board[row][col], board[nr][nc]); //새로운 것과 기존것을 바꾸고 + ans = max(ans, findCandy(n)); //ans값도 갱신한뒤 + swap(board[row][col], board[nr][nc]); //다시 기존것과 새로운것을 swap한다 + } + } + return ans; //그후 갱신된 ans값을 반환한다. +} + +/** + * 입력 범위가 크지 않으므로 바꿀 수 있는 사탕을 모두 바꿔보며 먹을 수 있는 사탕 계산 + * 오른쪽, 아래에 있는 사탕과만 바꿔도 모든 경우 고려 가능(왼쪽, 위 고려 X) + * + * 1. 사탕의 색이 다른 사탕만 교환하기 + * 2. 각 열, 행이 모두 같은 사탕일 때 사탕의 개수가 갱신되지 않도록 주의 (ans 갱신을 line 18~21에서 하는 경우) + */ +int main() { + int n, max_candy = 0; //초기화 + + //입력 + cin >> n; + board.assign(n, vector(n, ' '));//board를 입력하기위해 초기화 시킨다. + for (int i = 0; i < n; i++) //반복문돌면서 + for (int j = 0; j < n; j++) //board를 + cin >> board[i][j]; //입력한다. + + //연산 + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) //반복문 돌면서 + max_candy = max(max_candy, switchCandy(n, i, j, board[i][j])); //max값을 찾는다 + } + + //출력 + cout << max_candy; +} \ No newline at end of file diff --git "a/12\354\233\224 7\354\235\274/\354\271\264\353\223\234\354\247\235\353\247\236\354\266\224\352\270\260.cpp" "b/12\354\233\224 7\354\235\274/\354\271\264\353\223\234\354\247\235\353\247\236\354\266\224\352\270\260.cpp" new file mode 100644 index 0000000..ed9e1be --- /dev/null +++ "b/12\354\233\224 7\354\235\274/\354\271\264\353\223\234\354\247\235\353\247\236\354\266\224\352\270\260.cpp" @@ -0,0 +1,138 @@ +#include +#include +#include +#include + +using namespace std; +typedef pair ci; +const int SIZE = 4; + +int dr[4] = { -1, 1, 0, 0 }; +int dc[4] = { 0, 0, -1, 1 }; + +vector> findCard(vector>& board) { //존재하는 모든 카드의 위치를 리턴하는 함수 + vector> card_pos(7, vector(0)); //최대 카드 수 + int cnt = 0; //cnt 초기화 + for (int i = 0; i < SIZE; i++) { //board를 조회화기위해 + for (int j = 0; j < SIZE; j++) { //이중배열사용 + cnt = max(cnt, board[i][j]); //board가 기존 cnt보다 크면 갱신 + if (board[i][j]) //카드라면 위치 저장 + card_pos[board[i][j]].emplace_back(i, j); //위치저장 + } + } + card_pos.resize(cnt + 1); //실제 존재하는 카드의 수만큼 크기 조절 + return card_pos; //위치 반환 +} + +pair ctrl(int row, int col, int dir, vector>& tmp) { //컨트롤로 이동하는 좌표를 리턴하는 함수 + while (true) { //무한 반복 + row += dr[dir]; //위치 갱신 + col += dc[dir]; //위치 갱신 + if (row < 0 || row >= SIZE || col < 0 || col >= SIZE) //해당 방향에 카드가 하나도 없다면 그 방향의 가장 마지막 칸으로 이동 + return make_pair(row - dr[dir], col - dc[dir]); //pair를 반환 + if (tmp[row][col] != 0) //누른 키 방향에 있는 가장 가까운 카드 + return make_pair(row, col); //pair를 반환 + } +} + +int bfs(int r1, int c1, int r2, int c2, vector>& tmp) { //현재 커서에서 목표 카드로 이동하는 가장 적은 비용을 리턴하는 함수 + vector> visited(SIZE, vector(SIZE, 0)); //방문 유무 확인 + queue> q; //큐 + visited[r1][c1] = 1; //반드시 엔터를 누르게 될 것. 엔터를 미리 눌렀다 가정하고 1로 표시 + q.push({ r1, c1 }); //초기값 넣어주기 + + while (!q.empty()) { //비어있지 않을동안 + int row = q.front().first; //행 갱신 + int col = q.front().second; //열 갱신 + int dist = visited[row][col]; //dist갱신 + q.pop(); //큐에 있는 값 빼기 + + if (row == r2 && col == c2) //목표 카드에 도달했다면 + return dist; //dist값 반환 + + for (int i = 0; i < 4; i++) { //컨트롤 입력 이동 + pair np = ctrl(row, col, i, tmp); //컨트롤 값 np에 넣어 조회 + if (visited[np.first][np.second]) //방문한 값이면 넘어가기 + continue; + visited[np.first][np.second] = dist + 1; //아니라면 갱신해주기 + q.push(np); //np값 큐에서 제거 + } + + for (int i = 0; i < 4; i++) { //방향키 입력 이동 + int nr = row + dr[i], nc = col + dc[i]; //새로운 행,열 선언 + if (nr < 0 || nr >= 4 || nc < 0 || nc >= 4 || visited[nr][nc]) //범위와에 그리고 방문했는지 확인 + continue;//그럼 그냥 넘어가기 + visited[nr][nc] = dist + 1; //아니라면 새로 갱신 + q.push({ nr, nc }); //새로운 값 넣어주기 + } + } + return -1; //목표 카드에 도달하지 못함 (실제로는 일어나지 않는 일) +} + +int matchCard(int bit, int num, int r, int c, vector& seq, vector>& cards, vector> tmp) { //조합에 대해 카드를 매칭하는 함수 + int ans = 0; //ans값초기화 + for (int i = 0; i < num; i++) {//반복문 돌면서 캐릭터 전부 조회 + int cur = seq[i]; //이번에 매칭할 캐릭터 + int now = 0; //해당 캐릭터의 0번째 카드부터 선택한다고 가정 + if (bit & (1 << i)) //만약 해당 위치의 비트가 1을 표시했다면 1번째 카드부터 선택 + now = 1; //매칭 카드 인덱스 1로 + + for (int j = 0; j < 2; j++) {//반복문 돌면서새로 갱신될부분 검사 + now = (now + j) % 2; //이번에 매칭할 카드 인덱스 + int nr = cards[cur][now].first, nc = cards[cur][now].second; //이번에 매칭할 카드 위치 + ans += bfs(r, c, nr, nc, tmp); //현재 커서에서 목표 카드까지 이동하는 비용 + + //카드 삭제 + 커서 이동 + tmp[nr][nc] = 0; //카드 삭제 + r = nr; //기존거 대체 + c = nc; //기존열 대체 + } + } + return ans; //ans반환 +} + +int solution(vector> board, int r, int c) { + int answer = 1e9; //가장 큰값으로 초기화 해둔다. + + vector> cards = findCard(board); //존재하는 모든 카드의 위치 + int card_cnt = cards.size() - 1; //카드의 개수 + + vector seq(card_cnt); //순열을 위한 배열 + for (int i = 0; i < card_cnt; i++) //순열을 위한 반복문 + seq[i] = i + 1; //갱신 + + do { //가능한 모든 카드 순서에 대해 + for (int bit = 0; bit < (1 << card_cnt); bit++) { //0, 1번째 카드 중 어떤 카드를 먼저 뒤집을지 결정 + answer = min(answer, matchCard(bit, card_cnt, r, c, seq, cards, board)); //최소값을 찾는다 + } + } while (next_permutation(seq.begin(), seq.end()));//next_permutation의 값이 false일경우 stop + return answer; //최소의 answer를 반환 +} + +/** + * 아이디어 + * 1. 범위가 크지 않음 + * 2. 존재하는 모든 카드의 종류는 6개, 카드 2장이 한 쌍을 이룬다. + * 3. 뒤집을 카드 순서를 정하는 모든 경우의 수는 6!(카드 순서) * 2^6(2개의 카드 중 어떤 카드를 먼저 뒤집을지) -> 브루트포스 가능 + * 4. 이번에 목표로 하는 카드에 대해 현재 커서에서 목표 카드까지 가는 최단 경로를 구하며 이동 횟수 전부 구하고 최솟값 갱신 + * + * 구현 + * 1. 존재하는 모든 카드의 위치를 저장하며 카드의 개수 세기 (findCard) + * 2. 가능한 모든 카드의 순서(next_permutation)와 각 카드를 뒤집을 순서(bitmask)를 결정 + * ex) seq = {3, 1, 2}, bit = 011 일 때 + * 3번, 1번, 2번 카드의 순서로 뒤집는다. + * 3번 카드는 1번째 카드부터, 1번 카드는 0번째 카드부터, 2번 카드는 1번째 카드부터 뒤집는다. + * bit의 011이 앞에서부터 각각 1, 2, 3번 카드와 대응함 + * 3. 현재 카드 순서와 각 카드를 뒤집는 순서에 대한 커서 이동 횟수 계산 (matchCard) + * 현재 커서 위치와 목표 카드 위치에 대해 bfs 함수 실행 + * 컨트롤 입력을 고려해야 하기 때문에 4방향에 대한 방향 이동에 추가로 컨트롤 입력도 처리한다.(ctrl) + * 4. 매 조합에 따라 board가 갱신되므로 board를 복사한 tmp 사용 + * 공식 풀이 : https://tech.kakao.com/2021/01/25/2021-kakao-recruitment-round-1/ + */ +int main() { + vector> board = { {1, 0, 0, 3}, + {2, 0, 0, 0}, + {0, 0, 0, 2}, + {3, 0, 1, 0} }; //초기설정 + cout << solution(board, 1, 0); //출력 +} \ No newline at end of file