From 6198f590d4419d258c43eb2f4db226aa70b2d67a Mon Sep 17 00:00:00 2001 From: choikang Date: Mon, 10 Nov 2025 20:47:48 +0900 Subject: [PATCH 01/13] =?UTF-8?q?=EB=B0=B1=EC=A4=80=20-=20=ED=96=89?= =?UTF-8?q?=EB=B3=B5=EC=9C=A0=EC=B9=98=EC=9B=90(11=5F10)=20=ED=92=80?= =?UTF-8?q?=EC=9D=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../README.MD" | 50 +++++++++++++++++++ ...\354\234\240\354\271\230\354\233\220.java" | 45 +++++++++++++++++ 2 files changed, 95 insertions(+) create mode 100644 "src/\353\260\261\354\244\200/Gold/\355\226\211\353\263\265\354\234\240\354\271\230\354\233\220/README.MD" create mode 100644 "src/\353\260\261\354\244\200/Gold/\355\226\211\353\263\265\354\234\240\354\271\230\354\233\220/\355\226\211\353\263\265\354\234\240\354\271\230\354\233\220.java" diff --git "a/src/\353\260\261\354\244\200/Gold/\355\226\211\353\263\265\354\234\240\354\271\230\354\233\220/README.MD" "b/src/\353\260\261\354\244\200/Gold/\355\226\211\353\263\265\354\234\240\354\271\230\354\233\220/README.MD" new file mode 100644 index 0000000..1022e62 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\355\226\211\353\263\265\354\234\240\354\271\230\354\233\220/README.MD" @@ -0,0 +1,50 @@ +[문제 링크](https://www.acmicpc.net/problem/13164) + +# 13164번: 행복 유치원 + +| 시간 제한 | 메모리 제한 | 제출 | 정답 | 맞힌 사람 | 정답 비율 | +| :---: | :---: | :---: | :---: | :---: | :---: | +| 1 초 | 512 MB | 11387 | 6480 | 5251 | 56.670% | + +----- + +## 문제 + +행복 유치원 원장인 태양이는 어느 날 N명의 원생들을 키 순서대로 일렬로 줄 세우고, 총 K개의 조로 나누려고 한다. 각 조에는 원생이 적어도 한 명 있어야 하며, 같은 조에 속한 원생들은 서로 인접해 있어야 한다. 조별로 인원수가 같을 필요는 없다. + +이렇게 나뉘어진 조들은 각자 단체 티셔츠를 맞추려고 한다. 조마다 티셔츠를 맞추는 비용은 조에서 가장 키가 큰 원생과 가장 키가 작은 원생의 키 차이만큼 든다. 최대한 비용을 아끼고 싶어 하는 태양이는 K개의 조에 대해 티셔츠 만드는 비용의 합을 최소로 하고 싶어한다. 태양이를 도와 최소의 비용을 구하자. + +----- + +## 입력 + +입력의 첫 줄에는 유치원에 있는 원생의 수를 나타내는 자연수 N(1 ≤ N ≤ 300,000)과 나누려고 하는 조의 개수를 나타내는 자연수 K(1 ≤ K ≤ N)가 공백으로 구분되어 주어진다. 다음 줄에는 원생들의 키를 나타내는 N개의 자연수가 공백으로 구분되어 줄 서 있는 순서대로 주어진다. 태양이는 원생들을 키 순서대로 줄 세웠으므로, 왼쪽에 있는 원생이 오른쪽에 있는 원생보다 크지 않다. 원생의 키는 10\9\를 넘지 않는 자연수이다. + +----- + +## 출력 + +티셔츠 만드는 비용이 최소가 되도록 K개의 조로 나누었을 때, 티셔츠 만드는 비용을 출력한다. + +----- + +## 예제 입력 1 + +``` +5 3 +1 3 5 6 10 +``` + +## 예제 출력 1 + +``` +3 +``` + +----- + +## 힌트 + +1조: 1, 3 +2조: 5, 6 +3조: 10 \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Gold/\355\226\211\353\263\265\354\234\240\354\271\230\354\233\220/\355\226\211\353\263\265\354\234\240\354\271\230\354\233\220.java" "b/src/\353\260\261\354\244\200/Gold/\355\226\211\353\263\265\354\234\240\354\271\230\354\233\220/\355\226\211\353\263\265\354\234\240\354\271\230\354\233\220.java" new file mode 100644 index 0000000..b0b502e --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\355\226\211\353\263\265\354\234\240\354\271\230\354\233\220/\355\226\211\353\263\265\354\234\240\354\271\230\354\233\220.java" @@ -0,0 +1,45 @@ +package 백준.Gold.행복유치원; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.util.Arrays; +import java.util.StringTokenizer; + +public class 행복유치원 { + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + StringTokenizer st = new StringTokenizer(br.readLine()); + + int n = Integer.parseInt(st.nextToken()); + int k = Integer.parseInt(st.nextToken()); + + // 키를 담을 배열 + int[] height = new int[n]; + st = new StringTokenizer(br.readLine()); + for(int i=0;i Date: Sun, 16 Nov 2025 17:52:39 +0900 Subject: [PATCH 02/13] =?UTF-8?q?=EB=B0=B1=EC=A4=80=20-=20=EC=9B=94?= =?UTF-8?q?=EB=93=9C=EC=BB=B5=20=ED=92=80=EC=9D=B4(11=5F13)=20=20=20=20=20?= =?UTF-8?q?=20=20=EA=B0=80=EA=B9=8C=EC=9A=B4=20=EC=A1=B0=EC=83=81=20?= =?UTF-8?q?=EC=9E=AC=ED=92=80=EC=9D=B4(11=5F16)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../MY.MD" | 94 ++++++++++++++++++ ...\355\206\265\354\241\260\354\203\201.java" | 55 +++++++++++ ...355\206\265\354\241\260\354\203\2012.java" | 49 ++++++++++ .../README.MD" | 84 ++++++++++++++++ ...\354\233\224\353\223\234\354\273\265.java" | 97 +++++++++++++++++++ ...354\233\224\353\223\234\354\273\2652.java" | 96 ++++++++++++++++++ ...54\354\246\230\354\242\205\353\245\230.MD" | 6 ++ 7 files changed, 481 insertions(+) create mode 100644 "src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/MY.MD" create mode 100644 "src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201.java" create mode 100644 "src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\2012.java" create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/README.MD" create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\265.java" create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\2652.java" create mode 100644 "src/\353\260\261\354\244\200/\354\225\214\352\263\240\353\246\254\354\246\230\354\242\205\353\245\230.MD" diff --git "a/src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/MY.MD" "b/src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/MY.MD" new file mode 100644 index 0000000..0eae42d --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/MY.MD" @@ -0,0 +1,94 @@ + // 배열 문제를 풀면서 항상 헷갈리고 거부감이 들었던 부분은 + // 배열의 크기를 어떤식으로 할당하는건지의 문제 어떨떄는 n+1, 어떨때는 n-1 boolean[] 배열의 크기 이런건 어떤식으로 정해지는건지 +배열 크기 선언에 대해서 헷갈리는 부분이 있어서 정리해보고자 한다 +배열 선언을 할 때 배열의 크기 N만큼 만들어줄 때와 그렇지 않고 N+1만큼의 크기를 만들어줄때를 비교해보자면 +new int[n] 은 0부터 n-1까지 인덱스를 쓰는 경우에 0인덱스를 살려서 사용하는 문제의 경우 그대로 n만큼의 크기를 +만약 문제에서 1번 노드, 3번 사람, 5번 도시와 같이 숫자가 1부터 주어질 경우에는 0부터 n까지의 크기 new int[n+1]을 +사용해 0은 무시하고 1부터 인덱스를 사용하여 편의성을 더한다 만약 크기가 n이고 16번 노드는 +parent[b-1] = a-1 과 같이 복잡하게 계산해주어야 하지만 만약 n+1이라면 +parent[b] = a 와 같이 16번 노드는 16번 인덱스에 저장하면 되고 실수를 방지할 수 있게 된다 + +parent[B] = A; (3584번 LCA 문제) +만약 int[n]으로 만들었다면, 16번 노드는 15번 인덱스에 저장해야 합니다. + +parent[B-1] = A-1; // 코드가 지저분해지고 헷갈림 +int[n+1]로 만들면, 16번 노드는 그냥 16번 인덱스에 저장하면 됩니다. +parent[B] = A; // 코드가 직관적이고 실수가 줄어듦 + +결론: 문제의 '번호'와 배열의 '인덱스'를 일치시키기 위해 n+1을 사용합니다. + +`while` 루프의 조건을 정하는 건 처음엔 정말 헷갈리죠. + +`!=`를 써야 할지 `==`를 써야 할지 헷갈릴 때 쓰는 **가장 확실한 꿀팁**은, `while`의 조건을 "언제 멈추는가?"가 아니라 \*\*"이 루프가 계속 돌아가야 하는 이유(조건)"\*\*로 생각하는 것입니다. + +`while`은 괄호 안의 조건이 `true`인 \*\*"동안"\*\*에만 계속 돕니다. + +----- + +## \#\# 1. `!=` (Not Equal) / `>` / `<` 를 쓸 때 + +**"\~가 될 때까지"** 라는 **목표 지향적** 루프에 씁니다. + +변수가 계속 변하면서 **특정 "목표 값"에 도달하면 멈춰야 할 때** 사용합니다. + +* **멈추는 조건:** `n == 0` + +* **계속 도는 조건:** "n이 0이 아닌 **동안**" → `while (n != 0)` (혹은 `while (n > 0)`) + +* **멈추는 조건:** `stack.isEmpty() == true` (스택이 비면 멈춤) + +* **계속 도는 조건:** "스택이 비어있지 않은 **동안**" → `while (!stack.isEmpty())` + +* **멈추는 조건:** `answer == input` (정답을 맞히면 멈춤) + +* **계속 도는 조건:** "정답과 입력이 다른 **동안**" → `while (answer != input)` + +----- + +## \#\# 2. `==` (Equal) / `boolean` 변수를 쓸 때 + +**"\~인 동안"** 이라는 **상태 유지** 루프에 씁니다. + +특정 변수가 `true`이거나 특정 상태일 때만 계속 돌아야 할 때 사용합니다. + +* **계속 도는 조건:** "`isRun`이라는 '깃발'이 `true`인 **동안**" + +* **코드:** `while (isRun == true)` (또는 간단히 `while (isRun)`) + +* *(루프 안에서 `if (...) { isRun = false; }` 코드로 멈춤)* + +* **계속 도는 조건:** "`count`가 10보다 작은 **동안**" + +* **코드:** `while (count < 10)` + +----- + +## \#\# 🚨 가장 치명적인 실수: `=` vs `==` + +초보자가 가장 많이 하는 실수입니다. + +* **`=` (할당 연산자):** 값을 **"넣어라"** (덮어쓰기) +* **`==` (비교 연산자):** 값이 **"같은지 물어봐라"** (True/False) + +#### **❌ 잘못된 코드 (거의 99% 무한루프)** + +```java +int x = 0; +while (x = 5) { // 🛑 실수! x에 5를 "넣어라" + // x는 5가 되고, while(5)는 true로 취급되어 무한히 돕니다. +} +``` + +#### **✅ 올바른 코드** + +```java +int x = 0; +while (x == 5) { // "x가 5와 같은가?" (지금은 false라 안 돔) + // ... +} + +while (x != 5) { // "x가 5와 다른가?" (true라 돔) + // ... + x++; +} +``` \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201.java" "b/src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201.java" new file mode 100644 index 0000000..78b7b09 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201.java" @@ -0,0 +1,55 @@ +package 백준.Gold.가장가까운_공통조상; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.util.StringTokenizer; + +public class 가까운_공통조상 { + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + int t = Integer.parseInt(br.readLine()); //테스트 케이스 수 + + // t가 2이면 2번 실행 t-- 이기 때문에 2 그리고 1 실행되고 0일때는 실행 x + while (t-->0) { + // 정점 n을 받기 + int n = Integer.parseInt(br.readLine()); + // 부모 배열 선언 + int[] parent = new int[n + 1]; + // 부모 자식 관계 맺어주기 + for(int i=0;i 0) { + int n = Integer.parseInt(br.readLine()); + + // map을 이용해줘도 될거 같음 map을 이용해서 푸는 방법과 array를 이용해서 푸는 방법 2가지로 풀어보기 + int[] parents=new int[n + 1]; //n+1로 설정해준 이유는 인덱스를 1부터 사용하기 위함이고 + + for (int i = 0; i < n - 1; i++) { + StringTokenizer st = new StringTokenizer(br.readLine()); + int a = Integer.parseInt(st.nextToken()); + int b = Integer.parseInt(st.nextToken()); + parents[b]=a; + } + + StringTokenizer st = new StringTokenizer(br.readLine()); + int node1 = Integer.parseInt(st.nextToken()); + int node2 = Integer.parseInt(st.nextToken()); + + int currentNode = node1; + boolean[] visited = new boolean[n+1]; + while (currentNode != 0) { + visited[currentNode] = true; + currentNode = parents[currentNode]; + } + + currentNode = node2; + while (currentNode != 0) { + if (visited[currentNode]) { + System.out.println(sb.append(currentNode).toString()); + break; + } + currentNode = parents[currentNode]; + } + } + + //내가 헷갈렸던 부분 node1의 부모가 node2인데 그럼 node2는 부모 노드가 아리나 자신부터 검증해줘야 함 + } +} diff --git "a/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/README.MD" "b/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/README.MD" new file mode 100644 index 0000000..05fe1ab --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/README.MD" @@ -0,0 +1,84 @@ +[문제 링크](https://www.acmicpc.net/problem/6987) + +# 6987번: 월드컵 + +| 시간 제한 | 메모리 제한 | 제출 | 정답 | 맞힌 사람 | 정답 비율 | +| :---: | :---: | :---: | :---: | :---: | :---: | +| 1 초 | 128 MB | 19114 | 5825 | 3832 | 30.055% | + +----- + +## 문제 + +월드컵 조별 최종 예선에서는 6개국으로 구성된 각 조별로 동일한 조에 소속된 국가들과 한 번씩, 각 국가별로 총 5번의 경기를 치른다. 조별리그가 끝난 후, 기자가 보내온 각 나라의 승, 무승부, 패의 수가 가능한 결과인지를 판별하려고 한다. 다음은 가능한 결과와 가능하지 않은 결과의 예이다. + +| 나라 | 승 | 무승부 | 패 | +| :--: | :-: | :----: | :-: | +| A | 5 | 0 | 0 | +| B | 3 | 0 | 2 | +| C | 2 | 0 | 3 | +| D | 0 | 0 | 5 | +| E | 4 | 0 | 1 | +| F | 1 | 0 | 4 | +**예제 1 가능한 결과** + +| 나라 | 승 | 무승부 | 패 | +| :--: | :-: | :----: | :-: | +| A | 4 | 1 | 0 | +| B | 3 | 0 | 2 | +| C | 4 | 1 | 0 | +| D | 1 | 1 | 3 | +| E | 0 | 0 | 5 | +| F | 1 | 1 | 3 | +**예제 2 가능한 결과** + +| 나라 | 승 | 무승부 | 패 | +| :--: | :-: | :----: | :-: | +| A | 5 | 0 | 0 | +| B | 4 | 0 | 1 | +| C | 2 | 2 | 1 | +| D | 2 | 0 | 3 | +| E | 1 | 0 | 4 | +| F | 0 | 0 | 5 | +**예제 3 불가능한 결과** + +| 나라 | 승 | 무승부 | 패 | +| :--: | :-: | :----: | :-: | +| A | 5 | 0 | 0 | +| B | 3 | 1 | 1 | +| C | 2 | 1 | 2 | +| D | 2 | 0 | 3 | +| E | 0 | 0 | 5 | +| F | 1 | 0 | 4 | +**예제 4 불가능한 결과** + +네 가지의 결과가 주어질 때 각각의 결과에 대하여 가능하면 1, 불가능하면 0을 출력하는 프로그램을 작성하시오. + +----- + +## 입력 + +첫째 줄부터 넷째 줄까지 각 줄마다 6개국의 결과가 나라별로 승, 무승부, 패의 순서로 빈칸을 하나 사이에 두고 18개의 숫자로 주어진다. 승, 무, 패의 수는 6보다 작거나 같은 자연수 또는 0이다. + +----- + +## 출력 + +입력에서 주어진 네 가지 결과에 대하여 가능한 결과는 1, 불가능한 결과는 0을 빈칸을 하나 사이에 두고 출력한다. + +----- + +## 예제 입력 1 + +``` +5 0 0 3 0 2 2 0 3 0 0 5 4 0 1 1 0 4 +4 1 0 3 0 2 4 1 0 1 1 3 0 0 5 1 1 3 +5 0 0 4 0 1 2 2 1 2 0 3 1 0 4 0 0 5 +5 0 0 3 1 1 2 1 2 2 0 3 0 0 5 1 0 4 +``` + +## 예제 출력 1 + +``` +1 1 0 0 +``` \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\265.java" "b/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\265.java" new file mode 100644 index 0000000..ce00e91 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\265.java" @@ -0,0 +1,97 @@ +package 백준.Gold.월드컵; + +import java.io.*; +import java.util.StringTokenizer; + +public class 월드컵 { + static int[][] result; + static int[][] matches; + + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + StringBuilder sb = new StringBuilder(); + + // 6개 팀의 모든 경기 조합 생성 (15경기) + matches = new int[15][2]; + int idx = 0; + for (int i = 0; i < 6; i++) { + for (int j = i + 1; j < 6; j++) { + matches[idx][0] = i; + matches[idx][1] = j; + idx++; + } + } + + // 4개의 테스트 케이스 처리 + for (int t = 0; t < 4; t++) { + result = new int[6][3]; // 6개 팀, [승, 무, 패] + StringTokenizer st = new StringTokenizer(br.readLine()); + + boolean possible = true; + for (int i = 0; i < 6; i++) { + for (int j = 0; j < 3; j++) { + result[i][j] = Integer.parseInt(st.nextToken()); + } + // 각 팀은 5경기를 해야 함 + if (result[i][0] + result[i][1] + result[i][2] != 5) { + possible = false; + } + } + + if (possible && dfs(0)) { + sb.append("1 "); + } else { + sb.append("0 "); + } + } + + System.out.println(sb); + } + + static boolean dfs(int matchIdx) { + // 15경기를 모두 처리했으면 + if (matchIdx == 15) { + // 모든 팀의 승무패가 0인지 확인 + for (int i = 0; i < 6; i++) { + for (int j = 0; j < 3; j++) { + if (result[i][j] != 0) { + return false; + } + } + } + return true; + } + + int teamA = matches[matchIdx][0]; + int teamB = matches[matchIdx][1]; + + // 경우 1: A팀 승, B팀 패 + if (result[teamA][0] > 0 && result[teamB][2] > 0) { + result[teamA][0]--; + result[teamB][2]--; + if (dfs(matchIdx + 1)) return true; + result[teamA][0]++; + result[teamB][2]++; + } + + // 경우 2: 무승부 + if (result[teamA][1] > 0 && result[teamB][1] > 0) { + result[teamA][1]--; + result[teamB][1]--; + if (dfs(matchIdx + 1)) return true; + result[teamA][1]++; + result[teamB][1]++; + } + + // 경우 3: A팀 패, B팀 승 + if (result[teamA][2] > 0 && result[teamB][0] > 0) { + result[teamA][2]--; + result[teamB][0]--; + if (dfs(matchIdx + 1)) return true; + result[teamA][2]++; + result[teamB][0]++; + } + + return false; + } +} diff --git "a/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\2652.java" "b/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\2652.java" new file mode 100644 index 0000000..840539f --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\2652.java" @@ -0,0 +1,96 @@ +package 백준.Gold.월드컵; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.util.ArrayList; +import java.util.StringTokenizer; + +public class 월드컵2 { + static ArrayList matches = new ArrayList<>(); + static int[][] result = new int[6][3]; + + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + StringBuilder sb = new StringBuilder(); + + // 6경기에 나올 수 있는 모든 매치 15개의 경우를 리스트에 저장 + for (int i = 0; i < 6; i++) { + for (int j = i + 1; j < 6; j++) { + matches.add(new int[]{i, j}); + } + } + //System.out.println(Arrays.deepToString(matches.toArray())); + + // 6팀의 승무패의 정보를 받아 2차원 배열에 저장하기 + for (int t = 0; t < 4; t++) { + StringTokenizer st = new StringTokenizer(br.readLine()); //입력 받기 + boolean possible = true; + + for (int i = 0; i < 6; i++) { + for (int j = 0; j < 3; j++) { + result[i][j] = Integer.parseInt(st.nextToken()); + } + boolean istrue = true; + if (result[i][0] + result[i][1] + result[i][2] != 5) { + possible=false; + } + } + + if (possible && dfs(0)) { + sb.append("1 "); + } else { + sb.append("0 "); + } + } + + System.out.println(sb.toString().trim()); + } + + static boolean dfs(int matchIndex) { + // 15번 경기를 치뤘는데 남아있는 승무패가 있다면 그 즉시 틀린 것이므로 false 반환하고 복귀 + if (matchIndex == 15) { + for (int i = 0; i < 6; i++) { + for(int j=0;j<3;j++){ + if (result[i][j] != 0) { + return false; + } + } + } + // 이 경우에 종료 조건 + return true; + } + + // 위에 종료 조건이 아니라면 이어서 진행 + // team은 재귀 들어가면 matchIndex가 1씩 커짐 그래서 이건 따로 선언해줘야 하는거 + int teamA = matches.get(matchIndex)[0]; + int teamB = matches.get(matchIndex)[1]; + + if (result[teamA][0] > 0 && result[teamB][2] > 0) { + result[teamA][0]--; + result[teamB][2]--; + if(dfs(matchIndex+1)) return true; + result[teamA][0]++; + result[teamB][2]++; + } + + if(result[teamA][1]>0 && result[teamB][1]>0){ + result[teamA][1]--; + result[teamB][1]--; + if(dfs(matchIndex+1)) return true; + result[teamA][1]++; + result[teamB][1]++; + } + + if (result[teamA][2] > 0 && result[teamB][0] > 0) { + result[teamA][2]--; + result[teamB][0]--; + if(dfs(matchIndex+1)) return true; + result[teamA][2]++; + result[teamB][0]++; + } + + return false; + + } +} diff --git "a/src/\353\260\261\354\244\200/\354\225\214\352\263\240\353\246\254\354\246\230\354\242\205\353\245\230.MD" "b/src/\353\260\261\354\244\200/\354\225\214\352\263\240\353\246\254\354\246\230\354\242\205\353\245\230.MD" new file mode 100644 index 0000000..b495485 --- /dev/null +++ "b/src/\353\260\261\354\244\200/\354\225\214\352\263\240\353\246\254\354\246\230\354\242\205\353\245\230.MD" @@ -0,0 +1,6 @@ +https://code.plus/course/41 - 알고리즘 기초1 +https://code.plus/course/42 - 알고리즘 기초2 +https://code.plus/course/43 - 알고리즘 중급1 +https://code.plus/course/44 - 알고리즘 중급2 +https://code.plus/course/45 - 알고리즘 중급3 + From 377972352a034449732685a9796fd1714d491574 Mon Sep 17 00:00:00 2001 From: choikang Date: Sun, 16 Nov 2025 17:52:39 +0900 Subject: [PATCH 03/13] =?UTF-8?q?=EB=B0=B1=EC=A4=80=20-=20=EC=88=98=20?= =?UTF-8?q?=EC=B0=BE=EA=B8=B0(11=5F17)=20=ED=92=80=EC=9D=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../MY.MD" | 94 ++++++++++++++++++ ...\355\206\265\354\241\260\354\203\201.java" | 55 +++++++++++ ...355\206\265\354\241\260\354\203\2012.java" | 50 ++++++++++ .../README.MD" | 84 ++++++++++++++++ ...\354\233\224\353\223\234\354\273\265.java" | 97 +++++++++++++++++++ ...354\233\224\353\223\234\354\273\2652.java" | 96 ++++++++++++++++++ .../README.MD" | 46 +++++++++ ...\354\210\230\354\260\276\352\270\260.java" | 56 +++++++++++ ...64\353\266\204\355\203\220\354\203\211.md" | 7 ++ ...54\354\246\230\354\242\205\353\245\230.MD" | 6 ++ 10 files changed, 591 insertions(+) create mode 100644 "src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/MY.MD" create mode 100644 "src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201.java" create mode 100644 "src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\2012.java" create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/README.MD" create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\265.java" create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\2652.java" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\210\230\354\260\276\352\270\260/README.MD" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\210\230\354\260\276\352\270\260/\354\210\230\354\260\276\352\270\260.java" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\210\230\354\260\276\352\270\260/\354\235\264\353\266\204\355\203\220\354\203\211.md" create mode 100644 "src/\353\260\261\354\244\200/\354\225\214\352\263\240\353\246\254\354\246\230\354\242\205\353\245\230.MD" diff --git "a/src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/MY.MD" "b/src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/MY.MD" new file mode 100644 index 0000000..0eae42d --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/MY.MD" @@ -0,0 +1,94 @@ + // 배열 문제를 풀면서 항상 헷갈리고 거부감이 들었던 부분은 + // 배열의 크기를 어떤식으로 할당하는건지의 문제 어떨떄는 n+1, 어떨때는 n-1 boolean[] 배열의 크기 이런건 어떤식으로 정해지는건지 +배열 크기 선언에 대해서 헷갈리는 부분이 있어서 정리해보고자 한다 +배열 선언을 할 때 배열의 크기 N만큼 만들어줄 때와 그렇지 않고 N+1만큼의 크기를 만들어줄때를 비교해보자면 +new int[n] 은 0부터 n-1까지 인덱스를 쓰는 경우에 0인덱스를 살려서 사용하는 문제의 경우 그대로 n만큼의 크기를 +만약 문제에서 1번 노드, 3번 사람, 5번 도시와 같이 숫자가 1부터 주어질 경우에는 0부터 n까지의 크기 new int[n+1]을 +사용해 0은 무시하고 1부터 인덱스를 사용하여 편의성을 더한다 만약 크기가 n이고 16번 노드는 +parent[b-1] = a-1 과 같이 복잡하게 계산해주어야 하지만 만약 n+1이라면 +parent[b] = a 와 같이 16번 노드는 16번 인덱스에 저장하면 되고 실수를 방지할 수 있게 된다 + +parent[B] = A; (3584번 LCA 문제) +만약 int[n]으로 만들었다면, 16번 노드는 15번 인덱스에 저장해야 합니다. + +parent[B-1] = A-1; // 코드가 지저분해지고 헷갈림 +int[n+1]로 만들면, 16번 노드는 그냥 16번 인덱스에 저장하면 됩니다. +parent[B] = A; // 코드가 직관적이고 실수가 줄어듦 + +결론: 문제의 '번호'와 배열의 '인덱스'를 일치시키기 위해 n+1을 사용합니다. + +`while` 루프의 조건을 정하는 건 처음엔 정말 헷갈리죠. + +`!=`를 써야 할지 `==`를 써야 할지 헷갈릴 때 쓰는 **가장 확실한 꿀팁**은, `while`의 조건을 "언제 멈추는가?"가 아니라 \*\*"이 루프가 계속 돌아가야 하는 이유(조건)"\*\*로 생각하는 것입니다. + +`while`은 괄호 안의 조건이 `true`인 \*\*"동안"\*\*에만 계속 돕니다. + +----- + +## \#\# 1. `!=` (Not Equal) / `>` / `<` 를 쓸 때 + +**"\~가 될 때까지"** 라는 **목표 지향적** 루프에 씁니다. + +변수가 계속 변하면서 **특정 "목표 값"에 도달하면 멈춰야 할 때** 사용합니다. + +* **멈추는 조건:** `n == 0` + +* **계속 도는 조건:** "n이 0이 아닌 **동안**" → `while (n != 0)` (혹은 `while (n > 0)`) + +* **멈추는 조건:** `stack.isEmpty() == true` (스택이 비면 멈춤) + +* **계속 도는 조건:** "스택이 비어있지 않은 **동안**" → `while (!stack.isEmpty())` + +* **멈추는 조건:** `answer == input` (정답을 맞히면 멈춤) + +* **계속 도는 조건:** "정답과 입력이 다른 **동안**" → `while (answer != input)` + +----- + +## \#\# 2. `==` (Equal) / `boolean` 변수를 쓸 때 + +**"\~인 동안"** 이라는 **상태 유지** 루프에 씁니다. + +특정 변수가 `true`이거나 특정 상태일 때만 계속 돌아야 할 때 사용합니다. + +* **계속 도는 조건:** "`isRun`이라는 '깃발'이 `true`인 **동안**" + +* **코드:** `while (isRun == true)` (또는 간단히 `while (isRun)`) + +* *(루프 안에서 `if (...) { isRun = false; }` 코드로 멈춤)* + +* **계속 도는 조건:** "`count`가 10보다 작은 **동안**" + +* **코드:** `while (count < 10)` + +----- + +## \#\# 🚨 가장 치명적인 실수: `=` vs `==` + +초보자가 가장 많이 하는 실수입니다. + +* **`=` (할당 연산자):** 값을 **"넣어라"** (덮어쓰기) +* **`==` (비교 연산자):** 값이 **"같은지 물어봐라"** (True/False) + +#### **❌ 잘못된 코드 (거의 99% 무한루프)** + +```java +int x = 0; +while (x = 5) { // 🛑 실수! x에 5를 "넣어라" + // x는 5가 되고, while(5)는 true로 취급되어 무한히 돕니다. +} +``` + +#### **✅ 올바른 코드** + +```java +int x = 0; +while (x == 5) { // "x가 5와 같은가?" (지금은 false라 안 돔) + // ... +} + +while (x != 5) { // "x가 5와 다른가?" (true라 돔) + // ... + x++; +} +``` \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201.java" "b/src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201.java" new file mode 100644 index 0000000..78b7b09 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\352\260\200\354\236\245\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201/\352\260\200\352\271\214\354\232\264_\352\263\265\355\206\265\354\241\260\354\203\201.java" @@ -0,0 +1,55 @@ +package 백준.Gold.가장가까운_공통조상; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.util.StringTokenizer; + +public class 가까운_공통조상 { + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + int t = Integer.parseInt(br.readLine()); //테스트 케이스 수 + + // t가 2이면 2번 실행 t-- 이기 때문에 2 그리고 1 실행되고 0일때는 실행 x + while (t-->0) { + // 정점 n을 받기 + int n = Integer.parseInt(br.readLine()); + // 부모 배열 선언 + int[] parent = new int[n + 1]; + // 부모 자식 관계 맺어주기 + for(int i=0;i 0) { + int n = Integer.parseInt(br.readLine()); + + // map을 이용해줘도 될거 같음 map을 이용해서 푸는 방법과 array를 이용해서 푸는 방법 2가지로 풀어보기 + int[] parents=new int[n + 1]; //n+1로 설정해준 이유는 인덱스를 1부터 사용하기 위함이고 + + for (int i = 0; i < n - 1; i++) { + StringTokenizer st = new StringTokenizer(br.readLine()); + int a = Integer.parseInt(st.nextToken()); + int b = Integer.parseInt(st.nextToken()); + parents[b]=a; + } + + StringTokenizer st = new StringTokenizer(br.readLine()); + int node1 = Integer.parseInt(st.nextToken()); + int node2 = Integer.parseInt(st.nextToken()); + + int currentNode = node1; + boolean[] visited = new boolean[n+1]; + while (currentNode != 0) { + visited[currentNode] = true; + currentNode = parents[currentNode]; + } + + currentNode = node2; + while (currentNode != 0) { + if (visited[currentNode]) { + sb.append(currentNode).append("\n"); + break; + } + currentNode = parents[currentNode]; + } + } + + //내가 헷갈렸던 부분 node1의 부모가 node2인데 그럼 node2는 부모 노드가 아리나 자신부터 검증해줘야 함 + System.out.println(sb); + } +} diff --git "a/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/README.MD" "b/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/README.MD" new file mode 100644 index 0000000..05fe1ab --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/README.MD" @@ -0,0 +1,84 @@ +[문제 링크](https://www.acmicpc.net/problem/6987) + +# 6987번: 월드컵 + +| 시간 제한 | 메모리 제한 | 제출 | 정답 | 맞힌 사람 | 정답 비율 | +| :---: | :---: | :---: | :---: | :---: | :---: | +| 1 초 | 128 MB | 19114 | 5825 | 3832 | 30.055% | + +----- + +## 문제 + +월드컵 조별 최종 예선에서는 6개국으로 구성된 각 조별로 동일한 조에 소속된 국가들과 한 번씩, 각 국가별로 총 5번의 경기를 치른다. 조별리그가 끝난 후, 기자가 보내온 각 나라의 승, 무승부, 패의 수가 가능한 결과인지를 판별하려고 한다. 다음은 가능한 결과와 가능하지 않은 결과의 예이다. + +| 나라 | 승 | 무승부 | 패 | +| :--: | :-: | :----: | :-: | +| A | 5 | 0 | 0 | +| B | 3 | 0 | 2 | +| C | 2 | 0 | 3 | +| D | 0 | 0 | 5 | +| E | 4 | 0 | 1 | +| F | 1 | 0 | 4 | +**예제 1 가능한 결과** + +| 나라 | 승 | 무승부 | 패 | +| :--: | :-: | :----: | :-: | +| A | 4 | 1 | 0 | +| B | 3 | 0 | 2 | +| C | 4 | 1 | 0 | +| D | 1 | 1 | 3 | +| E | 0 | 0 | 5 | +| F | 1 | 1 | 3 | +**예제 2 가능한 결과** + +| 나라 | 승 | 무승부 | 패 | +| :--: | :-: | :----: | :-: | +| A | 5 | 0 | 0 | +| B | 4 | 0 | 1 | +| C | 2 | 2 | 1 | +| D | 2 | 0 | 3 | +| E | 1 | 0 | 4 | +| F | 0 | 0 | 5 | +**예제 3 불가능한 결과** + +| 나라 | 승 | 무승부 | 패 | +| :--: | :-: | :----: | :-: | +| A | 5 | 0 | 0 | +| B | 3 | 1 | 1 | +| C | 2 | 1 | 2 | +| D | 2 | 0 | 3 | +| E | 0 | 0 | 5 | +| F | 1 | 0 | 4 | +**예제 4 불가능한 결과** + +네 가지의 결과가 주어질 때 각각의 결과에 대하여 가능하면 1, 불가능하면 0을 출력하는 프로그램을 작성하시오. + +----- + +## 입력 + +첫째 줄부터 넷째 줄까지 각 줄마다 6개국의 결과가 나라별로 승, 무승부, 패의 순서로 빈칸을 하나 사이에 두고 18개의 숫자로 주어진다. 승, 무, 패의 수는 6보다 작거나 같은 자연수 또는 0이다. + +----- + +## 출력 + +입력에서 주어진 네 가지 결과에 대하여 가능한 결과는 1, 불가능한 결과는 0을 빈칸을 하나 사이에 두고 출력한다. + +----- + +## 예제 입력 1 + +``` +5 0 0 3 0 2 2 0 3 0 0 5 4 0 1 1 0 4 +4 1 0 3 0 2 4 1 0 1 1 3 0 0 5 1 1 3 +5 0 0 4 0 1 2 2 1 2 0 3 1 0 4 0 0 5 +5 0 0 3 1 1 2 1 2 2 0 3 0 0 5 1 0 4 +``` + +## 예제 출력 1 + +``` +1 1 0 0 +``` \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\265.java" "b/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\265.java" new file mode 100644 index 0000000..ce00e91 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\265.java" @@ -0,0 +1,97 @@ +package 백준.Gold.월드컵; + +import java.io.*; +import java.util.StringTokenizer; + +public class 월드컵 { + static int[][] result; + static int[][] matches; + + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + StringBuilder sb = new StringBuilder(); + + // 6개 팀의 모든 경기 조합 생성 (15경기) + matches = new int[15][2]; + int idx = 0; + for (int i = 0; i < 6; i++) { + for (int j = i + 1; j < 6; j++) { + matches[idx][0] = i; + matches[idx][1] = j; + idx++; + } + } + + // 4개의 테스트 케이스 처리 + for (int t = 0; t < 4; t++) { + result = new int[6][3]; // 6개 팀, [승, 무, 패] + StringTokenizer st = new StringTokenizer(br.readLine()); + + boolean possible = true; + for (int i = 0; i < 6; i++) { + for (int j = 0; j < 3; j++) { + result[i][j] = Integer.parseInt(st.nextToken()); + } + // 각 팀은 5경기를 해야 함 + if (result[i][0] + result[i][1] + result[i][2] != 5) { + possible = false; + } + } + + if (possible && dfs(0)) { + sb.append("1 "); + } else { + sb.append("0 "); + } + } + + System.out.println(sb); + } + + static boolean dfs(int matchIdx) { + // 15경기를 모두 처리했으면 + if (matchIdx == 15) { + // 모든 팀의 승무패가 0인지 확인 + for (int i = 0; i < 6; i++) { + for (int j = 0; j < 3; j++) { + if (result[i][j] != 0) { + return false; + } + } + } + return true; + } + + int teamA = matches[matchIdx][0]; + int teamB = matches[matchIdx][1]; + + // 경우 1: A팀 승, B팀 패 + if (result[teamA][0] > 0 && result[teamB][2] > 0) { + result[teamA][0]--; + result[teamB][2]--; + if (dfs(matchIdx + 1)) return true; + result[teamA][0]++; + result[teamB][2]++; + } + + // 경우 2: 무승부 + if (result[teamA][1] > 0 && result[teamB][1] > 0) { + result[teamA][1]--; + result[teamB][1]--; + if (dfs(matchIdx + 1)) return true; + result[teamA][1]++; + result[teamB][1]++; + } + + // 경우 3: A팀 패, B팀 승 + if (result[teamA][2] > 0 && result[teamB][0] > 0) { + result[teamA][2]--; + result[teamB][0]--; + if (dfs(matchIdx + 1)) return true; + result[teamA][2]++; + result[teamB][0]++; + } + + return false; + } +} diff --git "a/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\2652.java" "b/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\2652.java" new file mode 100644 index 0000000..840539f --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\354\233\224\353\223\234\354\273\265/\354\233\224\353\223\234\354\273\2652.java" @@ -0,0 +1,96 @@ +package 백준.Gold.월드컵; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.util.ArrayList; +import java.util.StringTokenizer; + +public class 월드컵2 { + static ArrayList matches = new ArrayList<>(); + static int[][] result = new int[6][3]; + + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + StringBuilder sb = new StringBuilder(); + + // 6경기에 나올 수 있는 모든 매치 15개의 경우를 리스트에 저장 + for (int i = 0; i < 6; i++) { + for (int j = i + 1; j < 6; j++) { + matches.add(new int[]{i, j}); + } + } + //System.out.println(Arrays.deepToString(matches.toArray())); + + // 6팀의 승무패의 정보를 받아 2차원 배열에 저장하기 + for (int t = 0; t < 4; t++) { + StringTokenizer st = new StringTokenizer(br.readLine()); //입력 받기 + boolean possible = true; + + for (int i = 0; i < 6; i++) { + for (int j = 0; j < 3; j++) { + result[i][j] = Integer.parseInt(st.nextToken()); + } + boolean istrue = true; + if (result[i][0] + result[i][1] + result[i][2] != 5) { + possible=false; + } + } + + if (possible && dfs(0)) { + sb.append("1 "); + } else { + sb.append("0 "); + } + } + + System.out.println(sb.toString().trim()); + } + + static boolean dfs(int matchIndex) { + // 15번 경기를 치뤘는데 남아있는 승무패가 있다면 그 즉시 틀린 것이므로 false 반환하고 복귀 + if (matchIndex == 15) { + for (int i = 0; i < 6; i++) { + for(int j=0;j<3;j++){ + if (result[i][j] != 0) { + return false; + } + } + } + // 이 경우에 종료 조건 + return true; + } + + // 위에 종료 조건이 아니라면 이어서 진행 + // team은 재귀 들어가면 matchIndex가 1씩 커짐 그래서 이건 따로 선언해줘야 하는거 + int teamA = matches.get(matchIndex)[0]; + int teamB = matches.get(matchIndex)[1]; + + if (result[teamA][0] > 0 && result[teamB][2] > 0) { + result[teamA][0]--; + result[teamB][2]--; + if(dfs(matchIndex+1)) return true; + result[teamA][0]++; + result[teamB][2]++; + } + + if(result[teamA][1]>0 && result[teamB][1]>0){ + result[teamA][1]--; + result[teamB][1]--; + if(dfs(matchIndex+1)) return true; + result[teamA][1]++; + result[teamB][1]++; + } + + if (result[teamA][2] > 0 && result[teamB][0] > 0) { + result[teamA][2]--; + result[teamB][0]--; + if(dfs(matchIndex+1)) return true; + result[teamA][2]++; + result[teamB][0]++; + } + + return false; + + } +} diff --git "a/src/\353\260\261\354\244\200/Silver/\354\210\230\354\260\276\352\270\260/README.MD" "b/src/\353\260\261\354\244\200/Silver/\354\210\230\354\260\276\352\270\260/README.MD" new file mode 100644 index 0000000..3a1b380 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\354\210\230\354\260\276\352\270\260/README.MD" @@ -0,0 +1,46 @@ +[문제 링크](https://www.acmicpc.net/problem/1920) + +# 1920번: 수 찾기 + +| 시간 제한 | 메모리 제한 | 제출 | 정답 | 맞힌 사람 | 정답 비율 | +| :---: | :---: | :---: | :---: | :---: | :---: | +| 1 초 | 128 MB | 339255 | 111873 | 73148 | 31.181% | + +----- + +## 문제 + +N개의 정수 A[1], A[2], …, A[N]이 주어져 있을 때, 이 안에 X라는 정수가 존재하는지 알아내는 프로그램을 작성하시오. + +----- + +## 입력 + +첫째 줄에 자연수 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 줄에는 N개의 정수 A[1], A[2], …, A[N]이 주어진다. 다음 줄에는 M(1 ≤ M ≤ 100,000)이 주어진다. 다음 줄에는 M개의 수들이 주어지는데, 이 수들이 A안에 존재하는지 알아내면 된다. 모든 정수의 범위는 $-2^{31}$ 보다 크거나 같고 $2^{31}$보다 작다. + +----- + +## 출력 + +M개의 줄에 답을 출력한다. 존재하면 1을, 존재하지 않으면 0을 출력한다. + +----- + +## 예제 입력 1 + +``` +5 +4 1 5 2 3 +5 +1 3 7 9 5 +``` + +## 예제 출력 1 + +``` +1 +1 +0 +0 +1 +``` \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/\354\210\230\354\260\276\352\270\260/\354\210\230\354\260\276\352\270\260.java" "b/src/\353\260\261\354\244\200/Silver/\354\210\230\354\260\276\352\270\260/\354\210\230\354\260\276\352\270\260.java" new file mode 100644 index 0000000..024040a --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\354\210\230\354\260\276\352\270\260/\354\210\230\354\260\276\352\270\260.java" @@ -0,0 +1,56 @@ +package 백준.Silver.수찾기; + +import java.io.*; +import java.util.*; + +public class 수찾기 { + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + StringBuilder sb = new StringBuilder(); + + int n = Integer.parseInt(br.readLine()); + int[] a = new int[n]; + + StringTokenizer st = new StringTokenizer(br.readLine()); + for(int i=0;i a[mid]) { + left = mid + 1; + } else { + right = mid - 1; + } + } + return false; + } +} diff --git "a/src/\353\260\261\354\244\200/Silver/\354\210\230\354\260\276\352\270\260/\354\235\264\353\266\204\355\203\220\354\203\211.md" "b/src/\353\260\261\354\244\200/Silver/\354\210\230\354\260\276\352\270\260/\354\235\264\353\266\204\355\203\220\354\203\211.md" new file mode 100644 index 0000000..e541393 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\354\210\230\354\260\276\352\270\260/\354\235\264\353\266\204\355\203\220\354\203\211.md" @@ -0,0 +1,7 @@ +정리해보자면 1초안에 연산이 끝날려면 약 1억번의 연산 100000000 10의8승번인데 문제에서 입력으로 최대 100000 즉 10의5승 만큼 받을 수 있고
+n이 10의5승일때 m도 10의5승이면 만약 n*m일경우 10의 10승 으로 시간 초과가 나게 됨 그래서 이분탐색을 쓰는것 + +이분 탐색은 정렬된 배열에서만 동작
+- m은 찾을 값들이고 n개의 배열에서 찾기 때문에 탐색 대상인 a를 정렬하고 찾을 값들인 m은 정렬하지 않아도 됨 + +- 반씩 뚝뚝 잘라서 찾기 때문에, 데이터가 10만 개여도 약 16~17번만 비교하면 찾을 수 있습니다. ($log_2 100,000 \approx 17$)총 $10만 \times 17 \approx 170만$ 번 연산으로 충분합니다. (1초 안에 거뜬함 ✅) diff --git "a/src/\353\260\261\354\244\200/\354\225\214\352\263\240\353\246\254\354\246\230\354\242\205\353\245\230.MD" "b/src/\353\260\261\354\244\200/\354\225\214\352\263\240\353\246\254\354\246\230\354\242\205\353\245\230.MD" new file mode 100644 index 0000000..b495485 --- /dev/null +++ "b/src/\353\260\261\354\244\200/\354\225\214\352\263\240\353\246\254\354\246\230\354\242\205\353\245\230.MD" @@ -0,0 +1,6 @@ +https://code.plus/course/41 - 알고리즘 기초1 +https://code.plus/course/42 - 알고리즘 기초2 +https://code.plus/course/43 - 알고리즘 중급1 +https://code.plus/course/44 - 알고리즘 중급2 +https://code.plus/course/45 - 알고리즘 중급3 + From 61f153e7364760812c83095aeec7f60726923faa Mon Sep 17 00:00:00 2001 From: choikang Date: Wed, 17 Dec 2025 10:35:19 +0900 Subject: [PATCH 04/13] =?UTF-8?q?=EB=B0=B1=EC=A4=80=20-=20=ED=88=AC?= =?UTF-8?q?=ED=8F=AC=EC=9D=B8=ED=84=B0=20=EB=AC=B8=EC=A0=9C=20=ED=92=80?= =?UTF-8?q?=EC=9D=B4(12=5F17)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .idea/misc.xml | 5 +- Day_Algorithm.iml | 6 + .../README.MD" | 95 +++++++++++++++ ...\353\213\250\352\262\275\353\241\234.java" | 113 ++++++++++++++++++ ...353\213\250\352\262\275\353\241\2342.java" | 62 ++++++++++ ...0\353\223\244\354\235\230\355\225\2512.py" | 25 ++++ .../README.MD" | 74 ++++++++++++ ...0\353\223\244\354\235\230\355\225\2515.py" | 22 ++++ .../SpinLock.java" | 35 ++++++ .../TasLock.java" | 48 ++++++++ .../optimisticLock.java" | 39 ++++++ untitled/untitled.iml | 11 ++ 12 files changed, 534 insertions(+), 1 deletion(-) create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\265\234\353\213\250\352\262\275\353\241\234/README.MD" create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\265\234\353\213\250\352\262\275\353\241\234/\354\265\234\353\213\250\352\262\275\353\241\234.java" create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\265\234\353\213\250\352\262\275\353\241\234/\354\265\234\353\213\250\352\262\275\353\241\2342.java" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\210\230\353\223\244\354\235\230\355\225\2512/\354\210\230\353\223\244\354\235\230\355\225\2512.py" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\210\230\353\223\244\354\235\230\355\225\2515/README.MD" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\210\230\353\223\244\354\235\230\355\225\2515/\354\210\230\353\223\244\354\235\230\355\225\2515.py" create mode 100644 "src/\353\271\205\353\215\260\354\235\264\355\204\260/\352\263\265\354\234\240\354\271\264\354\232\264\355\204\260/SpinLock.java" create mode 100644 "src/\353\271\205\353\215\260\354\235\264\355\204\260/\352\263\265\354\234\240\354\271\264\354\232\264\355\204\260/TasLock.java" create mode 100644 "src/\353\271\205\353\215\260\354\235\264\355\204\260/\352\263\265\354\234\240\354\271\264\354\232\264\355\204\260/optimisticLock.java" create mode 100644 untitled/untitled.iml diff --git a/.idea/misc.xml b/.idea/misc.xml index e77b125..e037bbb 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,5 +1,8 @@ + + - + \ No newline at end of file diff --git a/Day_Algorithm.iml b/Day_Algorithm.iml index c90834f..ed4ef2a 100644 --- a/Day_Algorithm.iml +++ b/Day_Algorithm.iml @@ -1,5 +1,10 @@ + + + + + @@ -7,5 +12,6 @@ + \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Gold/\354\265\234\353\213\250\352\262\275\353\241\234/README.MD" "b/src/\353\260\261\354\244\200/Gold/\354\265\234\353\213\250\352\262\275\353\241\234/README.MD" new file mode 100644 index 0000000..a6f4ee7 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\354\265\234\353\213\250\352\262\275\353\241\234/README.MD" @@ -0,0 +1,95 @@ +[문제 링크](https://www.acmicpc.net/problem/1753) + +# 1753번: 최단경로 + +| 시간 제한 | 메모리 제한 | 제출 | 정답 | 맞힌 사람 | 정답 비율 | +| :---: | :---: | :---: | :---: | :---: | :---: | +| 1 초 | 256 MB | 255183 | 81404 | 42217 | 27.096% | + +----- + +## 문제 + +방향그래프가 주어지면 주어진 시작점에서 다른 모든 정점으로의 최단 경로를 구하는 프로그램을 작성하시오. 단, 모든 간선의 가중치는 10 이하의 자연수이다. + +----- + +## 입력 + +첫째 줄에 정점의 개수 V와 간선의 개수 E가 주어진다. (1 ≤ V ≤ 20,000, 1 ≤ E ≤ 300,000) 모든 정점에는 1부터 V까지 번호가 매겨져 있다고 가정한다. 둘째 줄에는 시작 정점의 번호 K(1 ≤ K ≤ V)가 주어진다. 셋째 줄부터 E개의 줄에 걸쳐 각 간선을 나타내는 세 개의 정수 (u, v, w)가 순서대로 주어진다. 이는 u에서 v로 가는 가중치 w인 간선이 존재한다는 뜻이다. u와 v는 서로 다르며 w는 10 이하의 자연수이다. 서로 다른 두 정점 사이에 여러 개의 간선이 존재할 수도 있음에 유의한다. + +----- + +## 출력 + +첫째 줄부터 V개의 줄에 걸쳐, i번째 줄에 i번 정점으로의 최단 경로의 경로값을 출력한다. 시작점 자신은 0으로 출력하고, 경로가 존재하지 않는 경우에는 INF를 출력하면 된다. + +----- + +## 예제 입력 1 + +``` +5 6 +1 +5 1 1 +1 2 2 +1 3 3 +2 3 4 +2 4 5 +3 4 6 +``` + +## 예제 출력 1 + +``` +0 +2 +3 +7 +INF +``` + +----- + +## 💡 이 문제를 풀기 위한 핵심 개념 + +이 문제는 \*\*"다익스트라 알고리즘 (Dijkstra's Algorithm)"\*\*을 사용하여 풀어야 하는 가장 대표적인 문제입니다. + +### 1\. 왜 다익스트라 인가요? + +* **문제 유형:** "한 시작점"에서 "다른 모든 정점"까지의 최단 경로를 구해야 합니다. (Single Source Shortest Path) +* **가중치:** 간선에 가중치(비용)가 있습니다. (가중치가 없으면 BFS로 풀 수 있지만, 여기서는 가중치가 있으므로 BFS는 불가능합니다.) +* **가중치 값:** 가중치가 모두 \*\*양수(자연수)\*\*입니다. (음수 가중치가 있다면 벨만-포드 알고리즘을 써야 하지만, 양수만 있으므로 다익스트라가 훨씬 효율적입니다.) + +### 2\. 다익스트라 알고리즘의 원리 + +다익스트라는 **그리디(Greedy) 알고리즘**의 일종입니다. +핵심 아이디어는 **"지금 당장 갈 수 있는 곳 중, 가장 비용이 적게 드는 곳부터 방문한다"** 입니다. + +**동작 과정:** + +1. **준비물:** + + * `dist[]` 배열: 시작점에서 각 노드까지 가는 최단 거리를 저장. 처음엔 모두 \*\*무한대(INF)\*\*로 초기화하고, 시작점만 `0`으로 설정합니다. + * **우선순위 큐 (Priority Queue):** 현재 방문할 수 있는 노드 중 **거리가 가장 짧은 노드**를 빠르게($O(\log N)$) 꺼내기 위해 사용합니다. + +2. **알고리즘 흐름:** + + 1. 시작 노드를 우선순위 큐에 넣습니다. (거리 0) + 2. 큐에서 **가장 거리가 짧은 노드**를 꺼냅니다. (현재 노드) + 3. 현재 노드를 거쳐서 주변 노드(이웃)로 가는 거리를 계산합니다. + * `새로운 거리` = `현재 노드까지의 거리` + `이웃으로 가는 간선 가중치` + 4. 만약 `새로운 거리`가 기존에 알고 있던 `이웃 노드의 거리(dist[이웃])`보다 **짧다면**: + * `dist[이웃]`을 `새로운 거리`로 갱신(Update)합니다. + * 갱신된 정보 `(이웃 노드, 새로운 거리)`를 우선순위 큐에 넣습니다. + 5. 큐가 빌 때까지 2\~4번을 반복합니다. + +### 3\. 자료구조 선택 (주의사항) + +* **인접 리스트 vs 인접 행렬:** + * 정점(V)이 20,000개입니다. 인접 행렬(`int[20001][20001]`)을 쓰면 메모리가 약 1.6GB가 필요하여 **메모리 초과**가 납니다. + * 따라서 \*\*인접 리스트 (`ArrayList>`)\*\*를 사용해야 합니다. +* **우선순위 큐 사용:** + * 큐에 넣을 때 비용이 적은 것이 먼저 나오도록 정렬 기준(`Comparable` 인터페이스 구현)을 만들어야 합니다. + +https://roytravel.tistory.com/340 diff --git "a/src/\353\260\261\354\244\200/Gold/\354\265\234\353\213\250\352\262\275\353\241\234/\354\265\234\353\213\250\352\262\275\353\241\234.java" "b/src/\353\260\261\354\244\200/Gold/\354\265\234\353\213\250\352\262\275\353\241\234/\354\265\234\353\213\250\352\262\275\353\241\234.java" new file mode 100644 index 0000000..c91c64d --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\354\265\234\353\213\250\352\262\275\353\241\234/\354\265\234\353\213\250\352\262\275\353\241\234.java" @@ -0,0 +1,113 @@ +package 백준.Gold.최단경로; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.PriorityQueue; +import java.util.StringTokenizer; + +// 1. 도착 지점과 가중치를 담을 Node 클래스 (Comparable 구현) +class Node implements Comparable { + int end; + int weight; + + public Node(int end, int weight) { + this.end = end; + this.weight = weight; + } + + // 우선순위 큐에서 가중치가 작은 순서대로 정렬되도록 설정 + @Override + public int compareTo(Node other) { + return this.weight - other.weight; + } +} + +public class 최단경로 { + // 무한대를 의미하는 값 (가중치 최대 10 * 정점 최대 20,000 = 200,000 이므로 넉넉하게 설정) + static final int INF = 100_000_000; + static int v, e, k; + static ArrayList[] graph; // 인접 리스트 + static int[] dist; // 최단 거리 테이블 + + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + StringTokenizer st = new StringTokenizer(br.readLine()); + + v = Integer.parseInt(st.nextToken()); // 정점의 개수 + e = Integer.parseInt(st.nextToken()); // 간선의 개수 + k = Integer.parseInt(br.readLine()); // 시작 정점 번호 + + // 2. 그래프 초기화 (ArrayList의 배열 사용) + graph = new ArrayList[v + 1]; + for (int i = 1; i <= v; i++) { + graph[i] = new ArrayList<>(); + } + + // 최단 거리 테이블 초기화 (모두 INF로) + dist = new int[v + 1]; + Arrays.fill(dist, INF); + + // 3. 간선 정보 입력 받기 + for (int i = 0; i < e; i++) { + st = new StringTokenizer(br.readLine()); + int start = Integer.parseInt(st.nextToken()); + int end = Integer.parseInt(st.nextToken()); + int weight = Integer.parseInt(st.nextToken()); + + // start에서 end로 가는 가중치 weight인 간선 추가 + graph[start].add(new Node(end, weight)); + } + + // 4. 다익스트라 알고리즘 실행 + dijkstra(k); + + // 5. 결과 출력 + StringBuilder sb = new StringBuilder(); + for (int i = 1; i <= v; i++) { + if (dist[i] == INF) { + sb.append("INF\n"); + } else { + sb.append(dist[i]).append("\n"); + } + } + System.out.print(sb); + } + + // 다익스트라 알고리즘 + private static void dijkstra(int start) { + // 우선순위 큐 생성 (가중치 오름차순) + PriorityQueue pq = new PriorityQueue<>(); + + // 시작점 초기화 + pq.add(new Node(start, 0)); + dist[start] = 0; + + while (!pq.isEmpty()) { + // 큐에서 가장 거리가 짧은 노드 꺼내기 + Node currentNode = pq.poll(); + int curIdx = currentNode.end; + int curDist = currentNode.weight; + + // [방문 처리] 현재 꺼낸 거리보다 이미 저장된 거리가 더 짧다면 스킵 (이미 방문한 셈) + if (dist[curIdx] < curDist) { + continue; + } + + // 현재 노드와 연결된 주변 노드들 확인 + for (Node nextNode : graph[curIdx]) { + // (현재까지 온 거리 + 다음 노드로 가는 거리) 계산 + int cost = dist[curIdx] + nextNode.weight; + + // 계산한 거리가 기존에 알고 있던 거리보다 짧다면 갱신 + if (cost < dist[nextNode.end]) { + dist[nextNode.end] = cost; + // 갱신된 정보를 큐에 넣기 + pq.add(new Node(nextNode.end, cost)); + } + } + } + } +} \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Gold/\354\265\234\353\213\250\352\262\275\353\241\234/\354\265\234\353\213\250\352\262\275\353\241\2342.java" "b/src/\353\260\261\354\244\200/Gold/\354\265\234\353\213\250\352\262\275\353\241\234/\354\265\234\353\213\250\352\262\275\353\241\2342.java" new file mode 100644 index 0000000..3c14a9b --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\354\265\234\353\213\250\352\262\275\353\241\234/\354\265\234\353\213\250\352\262\275\353\241\2342.java" @@ -0,0 +1,62 @@ +package 백준.Gold.최단경로; + +import java.io.*; +import java.util.*; + +record Node2(int end, int weight) {} + +public class 최단경로2 { + public static void main(String[] args) throws IOException { + BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); + StringTokenizer st = new StringTokenizer(br.readLine()); + + int V = Integer.parseInt(st.nextToken()); + int E = Integer.parseInt(st.nextToken()); + int K = Integer.parseInt(br.readLine()); + + // 2. 그래프 초기화 (여전히 반복문은 필요합니다) + ArrayList[] graph = new ArrayList[V + 1]; + for (int i = 1; i <= V; i++) graph[i] = new ArrayList<>(); + + // 3. 간선 입력 + for (int i = 0; i < E; i++) { + st = new StringTokenizer(br.readLine()); + int u = Integer.parseInt(st.nextToken()); + int v = Integer.parseInt(st.nextToken()); + int w = Integer.parseInt(st.nextToken()); + graph[u].add(new Node2(v, w)); + } + + // 4. 다익스트라 준비 + int[] dist = new int[V + 1]; + Arrays.fill(dist, 100_000_000); // INF값 직접 입력 (상수 선언 생략) + dist[K] = 0; + + // 5. 우선순위 큐 (람다식으로 정렬 기준 정의: 가중치 기준 오름차순) + PriorityQueue pq = new PriorityQueue<>((a, b) -> a.weight() - b.weight()); + pq.add(new Node2(K, 0)); + + // 6. 다익스트라 로직 + while (!pq.isEmpty()) { + Node2 cur = pq.poll(); + + // 방문 처리 (레코드 필드는 .end(), .weight()로 접근하거나 변수명 그대로 접근) + if (dist[cur.end()] < cur.weight()) continue; + + for (Node2 next : graph[cur.end()]) { + int nextDist = dist[cur.end()] + next.weight(); + if (nextDist < dist[next.end()]) { + dist[next.end()] = nextDist; + pq.add(new Node2(next.end(), nextDist)); + } + } + } + + // 7. 출력 + StringBuilder sb = new StringBuilder(); + for (int i = 1; i <= V; i++) { + sb.append(dist[i] == 100_000_000 ? "INF" : dist[i]).append('\n'); + } + System.out.print(sb); + } +} diff --git "a/src/\353\260\261\354\244\200/Silver/\354\210\230\353\223\244\354\235\230\355\225\2512/\354\210\230\353\223\244\354\235\230\355\225\2512.py" "b/src/\353\260\261\354\244\200/Silver/\354\210\230\353\223\244\354\235\230\355\225\2512/\354\210\230\353\223\244\354\235\230\355\225\2512.py" new file mode 100644 index 0000000..3586b82 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\354\210\230\353\223\244\354\235\230\355\225\2512/\354\210\230\353\223\244\354\235\230\355\225\2512.py" @@ -0,0 +1,25 @@ +import sys + +n,m = map(int,sys.stdin.readline().split()) +nums = list(map(int,sys.stdin.readline().split())) + +start=0 +end=1 +count=0 +sum=nums[start] + +while True: + if summ: + sum-=nums[start] + start+=1 + elif sum==m: + count+=1 + sum-=nums[start] + start+=1 + +print(count) \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/\354\210\230\353\223\244\354\235\230\355\225\2515/README.MD" "b/src/\353\260\261\354\244\200/Silver/\354\210\230\353\223\244\354\235\230\355\225\2515/README.MD" new file mode 100644 index 0000000..d9fc4af --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\354\210\230\353\223\244\354\235\230\355\225\2515/README.MD" @@ -0,0 +1,74 @@ +[문제 링크](https://www.acmicpc.net/problem/2018) + +# [Silver V] 수들의 합 5 - 2018 + +### 성능 요약 + +메모리: 32 MB, 시간: 2 초 + +### 분류 + +수학, 투 포인터 + +### 문제 설명 + +어떠한 자연수 N은, 몇 개의 연속된 자연수의 합으로 나타낼 수 있다. 당신은 어떤 자연수 N(1 ≤ N ≤ 10,000,000)에 대해서, 이 N을 몇 개의 연속된 자연수의 합으로 나타내는 가지수를 알고 싶어한다. 이때, 사용하는 자연수는 N이하여야 한다. + +예를 들어, 15를 나타내는 방법은 15, 7+8, 4+5+6, 1+2+3+4+5의 4가지가 있다. 반면에 10을 나타내는 방법은 10, 1+2+3+4의 2가지가 있다. + +N을 입력받아 가지수를 출력하는 프로그램을 작성하시오. + +### 입력 + +첫 줄에 정수 N이 주어진다. + +### 출력 + +입력된 자연수 N을 몇 개의 연속된 자연수의 합으로 나타내는 가지수를 출력하시오. + +### 예제 입력 1 + +``` +15 + +``` + +### 예제 출력 1 + +``` +4 + +``` + +--- + +### 💡 문제 풀이 (핵심 아이디어) + +#### 1. 시간 복잡도 분석 + +* 입력되는 N의 최댓값은 **10,000,000(천만)**입니다. +* 시간 제한은 2초이므로, $O(N^2)$의 이중 반복문을 사용하면 연산 횟수가 약 $10^{14}$가 되어 **시간 초과**가 발생합니다. +* 따라서 **O(N)**의 시간 복잡도를 가지는 **투 포인터(Two Pointers)** 알고리즘을 사용해야 합니다. + +#### 2. 투 포인터 전략 + +* `start_index`와 `end_index` 두 개의 포인터를 사용하여 연속된 구간의 합(`sum`)을 조절합니다. +* 초기 상태: `start = 1`, `end = 1`, `sum = 1`, `count = 1` (N 자기 자신인 경우 포함) + +#### 3. 알고리즘 동작 원리 + +반복문을 돌며 `end_index`가 `N`이 될 때까지 다음 규칙을 수행합니다. + +1. **`sum == N` (정답을 찾음):** +* `count`를 1 증가시킵니다. +* 다음 경우의 수를 찾기 위해 `end`를 증가시키고 합에 더합니다. + + +2. **`sum > N` (합이 너무 큼):** +* 값을 줄여야 하므로 앞쪽(`start`) 값을 `sum`에서 빼고, `start`를 오른쪽으로 한 칸 이동합니다. +* **순서 주의:** `sum -= start` 후 `start += 1` + + +3. **`sum < N` (합이 부족함):** +* 값을 늘려야 하므로 뒤쪽(`end`)을 오른쪽으로 한 칸 이동하고, 그 값을 `sum`에 더합니다. +* **순서 주의:** `end += 1` 후 `sum += end` diff --git "a/src/\353\260\261\354\244\200/Silver/\354\210\230\353\223\244\354\235\230\355\225\2515/\354\210\230\353\223\244\354\235\230\355\225\2515.py" "b/src/\353\260\261\354\244\200/Silver/\354\210\230\353\223\244\354\235\230\355\225\2515/\354\210\230\353\223\244\354\235\230\355\225\2515.py" new file mode 100644 index 0000000..a2916a6 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\354\210\230\353\223\244\354\235\230\355\225\2515/\354\210\230\353\223\244\354\235\230\355\225\2515.py" @@ -0,0 +1,22 @@ +import sys + +n=int(sys.stdin.readline()) + +sum=1 +start=1 +end=1 +count=1 + +while end!=n: + if sum>n: + sum-=start + start+=1 + elif sum { + private Lock lock; + private int head; + private int tail; + private T[] items; + + public SpinLock(int cap) { + lock = new ReentrantLock(); + items = (T[]) new Object[cap]; + head = 0; + tail = 0; + } + + public T deq() { + lock.lock(); + try { + if (head == tail) { + throw new EmptyStackException(); + } + T x = items[head % items.length]; + items[head % items.length] = null; + head++; + return x; + }finally { + lock.unlock(); + } + } +} + diff --git "a/src/\353\271\205\353\215\260\354\235\264\355\204\260/\352\263\265\354\234\240\354\271\264\354\232\264\355\204\260/TasLock.java" "b/src/\353\271\205\353\215\260\354\235\264\355\204\260/\352\263\265\354\234\240\354\271\264\354\232\264\355\204\260/TasLock.java" new file mode 100644 index 0000000..223dde7 --- /dev/null +++ "b/src/\353\271\205\353\215\260\354\235\264\355\204\260/\352\263\265\354\234\240\354\271\264\354\232\264\355\204\260/TasLock.java" @@ -0,0 +1,48 @@ +package 빅데이터.공유카운터; + + +import java.util.concurrent.atomic.AtomicBoolean; + +// 1. 하드웨어의 TAS 동작을 흉내 낸 클래스 (개념 이해용) +class MyAtomicBoolean { + private boolean value; + + public MyAtomicBoolean(boolean initialValue) { + this.value = initialValue; + } + + // 여기가 핵심! (사용자님이 주신 코드) + // 하드웨어에서는 이 과정이 '원자적(Atomic)'으로 한 번에 일어납니다. + public synchronized boolean getAndSet(boolean newValue) { + boolean prior = value; // 1. 이전 값을 기억한다 (Old Value) + value = newValue; // 2. 무조건 새 값으로 덮어쓴다 (Write) + return prior; // 3. 기억해둔 이전 값을 반환한다 + } + + public synchronized void set(boolean newValue) { + this.value = newValue; + } +} + +// 2. 위 클래스를 이용한 TAS 락 구현 +public class TasLock { + // 락의 상태 (false: 풀림, true: 잠김) + AtomicBoolean state = new AtomicBoolean(false); + + public void lock() { + // ------------------------------------------------------- + // [핵심 로직] + // 1. state.getAndSet(true)를 실행한다. + // 2. 만약 반환값이 false라면? (내가 1등으로 잠금) -> 루프 탈출, 락 획득! + // 3. 만약 반환값이 true라면? (누가 이미 잠가둠) -> 계속 뺑뺑이 (Spin) + // ------------------------------------------------------- + while (state.getAndSet(true)) { + // 락을 얻을 때까지 무한 대기 (Busy Wait) + } + } + + public void unlock() { + // 락을 푼다 (상태를 false로 변경) + state.set(false); + } +} diff --git "a/src/\353\271\205\353\215\260\354\235\264\355\204\260/\352\263\265\354\234\240\354\271\264\354\232\264\355\204\260/optimisticLock.java" "b/src/\353\271\205\353\215\260\354\235\264\355\204\260/\352\263\265\354\234\240\354\271\264\354\232\264\355\204\260/optimisticLock.java" new file mode 100644 index 0000000..bc5f3d9 --- /dev/null +++ "b/src/\353\271\205\353\215\260\354\235\264\355\204\260/\352\263\265\354\234\240\354\271\264\354\232\264\355\204\260/optimisticLock.java" @@ -0,0 +1,39 @@ +package 빅데이터.공유카운터; + +public class optimisticLock { + public boolean remove(T item) { + int key = item.hashCode(); + retry: + while (true) { + Node pred = head; + Node curr = pred.next; + while (curr.key <= key) { + if(curr) + } + } + } + + public void a() { + int value; + + public boolean sychronized cas(int expect, int update){ + if (value == expect) { + value=update; + return true; + } + return false; + } + } + + + + boolean validate(Node prec, Node curr) { + Node node = head; + while (node.key <= prec.key) { + if (node == prec) { + return prec.key == curr; + } + } + return false; + } +} diff --git a/untitled/untitled.iml b/untitled/untitled.iml new file mode 100644 index 0000000..3dd7882 --- /dev/null +++ b/untitled/untitled.iml @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file From 53258b2583cfc831f87686db8ef6ee68cd77518f Mon Sep 17 00:00:00 2001 From: choikang Date: Tue, 23 Dec 2025 15:31:04 +0900 Subject: [PATCH 05/13] =?UTF-8?q?=EB=B0=B1=EC=A4=80=20-=20BFS=20=EB=AC=B8?= =?UTF-8?q?=EC=A0=9C=20=ED=92=80=EC=9D=B4(12=5F23)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .idea/misc.xml | 2 +- .../Silver/N\352\263\274M1/README.md" | 0 .../N\352\263\274M1/n\352\263\274m1.py" | 29 +++++++ .../README.MD" | 52 ++++++++++++ ...5\352\265\254\355\225\230\352\270\2601.py" | 85 +++++++++++++++++++ 5 files changed, 167 insertions(+), 1 deletion(-) create mode 100644 "src/\353\260\261\354\244\200/Silver/N\352\263\274M1/README.md" create mode 100644 "src/\353\260\261\354\244\200/Silver/N\352\263\274M1/n\352\263\274m1.py" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\230\201\354\227\255\352\265\254\355\225\230\352\270\260/README.MD" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\230\201\354\227\255\352\265\254\355\225\230\352\270\260/\354\230\201\354\227\255\352\265\254\355\225\230\352\270\2601.py" diff --git a/.idea/misc.xml b/.idea/misc.xml index e037bbb..c936568 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -12,7 +12,7 @@ - + \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/README.md" "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/README.md" new file mode 100644 index 0000000..e69de29 diff --git "a/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/n\352\263\274m1.py" "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/n\352\263\274m1.py" new file mode 100644 index 0000000..d63a0d6 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/n\352\263\274m1.py" @@ -0,0 +1,29 @@ +import sys + +# 입력 받기 +N, M = map(int, sys.stdin.readline().split()) + +rs = [] # 결과를 담을 리스트 (스택 역할) +chk = [False] * (N + 1) # 방문 여부 체크 (1~N 인덱스 사용) + +def recur(num): + # [1] 종료 조건: M개를 모두 골랐으면 출력 + if num == M: + print(' '.join(map(str, rs))) # [1, 2] -> "1 2" 출력 + return + + # [2] 1부터 N까지 반복 + for i in range(1, N + 1): + if chk[i] == False: # 아직 안 쓴 숫자라면 + chk[i] = True # 1. 방문 표시 (찜하기) + rs.append(i) # 2. 결과 리스트에 넣기 + + recur(num + 1) # 3. 다음 숫자 고르러 더 깊이 들어감 (재귀) + + # [3] 백트래킹 (가장 중요한 부분!) + # 재귀에서 돌아왔다는 건 i를 포함한 모든 경우를 다 봤다는 뜻 + chk[i] = False # 4. 방문 표시 해제 (다음에 쓰기 위해) + rs.pop() # 5. 결과 리스트에서 빼기 (원상복구) + +# 함수 시작 (0개 고른 상태에서 출발) +recur(0) diff --git "a/src/\353\260\261\354\244\200/Silver/\354\230\201\354\227\255\352\265\254\355\225\230\352\270\260/README.MD" "b/src/\353\260\261\354\244\200/Silver/\354\230\201\354\227\255\352\265\254\355\225\230\352\270\260/README.MD" new file mode 100644 index 0000000..6fb7753 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\354\230\201\354\227\255\352\265\254\355\225\230\352\270\260/README.MD" @@ -0,0 +1,52 @@ +# [Silver I] 영역 구하기 - 2583 + +[문제 링크](https://www.acmicpc.net/problem/2583) + +### 성능 요약 + +메모리: 34160 KB, 시간: 68 ms (Python3 기준) + +### 분류 + +너비 우선 탐색(BFS), 깊이 우선 탐색(DFS), 그래프 이론, 그래프 탐색 + +### 문제 설명 + +눈금의 간격이 1인 () 크기의 모눈종이가 있다. 이 모눈종이 위에 눈금에 맞추어 개의 직사각형을 그릴 때, 이들 개의 직사각형의 내부를 제외한 나머지 부분이 몇 개의 분리된 영역으로 나누어진다. + +예를 들어 인 모눈종이 위에 <그림 1>과 같이 직사각형 3개를 그렸다면, 그 나머지 영역은 <그림 2>와 같이 3개의 분리된 영역으로 나누어지게 된다. + +<그림 2>와 같이 분리된 세 영역의 넓이는 각각 1, 7, 13이 된다. + +과 그리고 개의 직사각형의 좌표가 주어질 때, 개의 직사각형 내부를 제외한 나머지 부분이 몇 개의 분리된 영역으로 나누어지는지, 그리고 분리된 각 영역의 넓이가 얼마인지를 구하여 이를 출력하는 프로그램을 작성하시오. + +### 입력 + +첫째 줄에 과 , 그리고 가 빈칸을 사이에 두고 차례로 주어진다. 는 모두 100 이하의 자연수이다. + +둘째 줄부터 개의 줄에는 한 줄에 하나씩 직사각형의 왼쪽 아래 꼭짓점의 좌표값과 오른쪽 위 꼭짓점의 좌표값이 빈칸을 사이에 두고 차례로 주어진다. + +모눈종이의 왼쪽 아래 꼭짓점의 좌표는 $(0,0)$이고, 오른쪽 위 꼭짓점의 좌표는 $(N,M)$이다. 입력되는 개의 직사각형들이 모눈종이 전체를 채우는 경우는 없다. + +### 출력 + +첫째 줄에 분리되어 나누어지는 영역의 개수를 출력한다. +둘째 줄에는 각 영역의 넓이를 **오름차순으로 정렬**하여 빈칸을 사이에 두고 출력한다. + +### 예제 입력 1 + +```text +5 7 3 +0 2 4 4 +1 1 2 5 +4 0 6 2 + +``` + +### 예제 출력 1 + +```text +3 +1 7 13 + +``` \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/\354\230\201\354\227\255\352\265\254\355\225\230\352\270\260/\354\230\201\354\227\255\352\265\254\355\225\230\352\270\2601.py" "b/src/\353\260\261\354\244\200/Silver/\354\230\201\354\227\255\352\265\254\355\225\230\352\270\260/\354\230\201\354\227\255\352\265\254\355\225\230\352\270\2601.py" new file mode 100644 index 0000000..f003f83 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\354\230\201\354\227\255\352\265\254\355\225\230\352\270\260/\354\230\201\354\227\255\352\265\254\355\225\230\352\270\2601.py" @@ -0,0 +1,85 @@ +import sys +from collections import deque + +m,n,k, = map(int, sys.stdin.readline().split()) +graph = [[0]*n for _ in range(m)] + +# for row in graph: +# print(row) + +for _ in range(k): + x1,y1,x2,y2=map(int,sys.stdin.readline().split()) + for x in range(x1,x2): + for y in range(y1,y2): + graph[y][x]=1 + +def bfs(y,x): + q=deque([(y,x)]) + graph[y][x]=1 + size=1 + + while q: + cy,cx = q.popleft() + for dy,dx in ([(0,-1),(0,1),(-1,0),(1,0)]): + ny,nx = cy+dy, cx+dx + if(0<=ny Date: Mon, 29 Dec 2025 14:54:53 +0900 Subject: [PATCH 06/13] =?UTF-8?q?=EB=B0=B1=EC=A4=80=20-=20dp=20=EB=AC=B8?= =?UTF-8?q?=EC=A0=9C=20=ED=92=80=EC=9D=B4(12=5F29)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../N\352\263\274M1/n\352\263\274m1.py" | 66 +++++++++++++------ ...44\355\203\225\353\260\260\353\213\254.py" | 17 +++++ 2 files changed, 62 insertions(+), 21 deletions(-) create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\204\244\355\203\225\353\260\260\353\213\254/\354\204\244\355\203\225\353\260\260\353\213\254.py" diff --git "a/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/n\352\263\274m1.py" "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/n\352\263\274m1.py" index d63a0d6..735f229 100644 --- "a/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/n\352\263\274m1.py" +++ "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/n\352\263\274m1.py" @@ -1,29 +1,53 @@ import sys -# 입력 받기 -N, M = map(int, sys.stdin.readline().split()) +n,m, = map(int, sys.stdin.readline().split()) +rs = [] +checked = [False] * (n+1) -rs = [] # 결과를 담을 리스트 (스택 역할) -chk = [False] * (N + 1) # 방문 여부 체크 (1~N 인덱스 사용) - -def recur(num): - # [1] 종료 조건: M개를 모두 골랐으면 출력 - if num == M: - print(' '.join(map(str, rs))) # [1, 2] -> "1 2" 출력 +def recursive(num): + if(num==m): + print(*rs) return - # [2] 1부터 N까지 반복 - for i in range(1, N + 1): - if chk[i] == False: # 아직 안 쓴 숫자라면 - chk[i] = True # 1. 방문 표시 (찜하기) - rs.append(i) # 2. 결과 리스트에 넣기 + for i in range(1,n+1): + if(checked[i]==False): + checked[i]=True + rs.append(i) + + recursive(num+1) + + checked[i]=False + rs.pop() - recur(num + 1) # 3. 다음 숫자 고르러 더 깊이 들어감 (재귀) +recursive(0) - # [3] 백트래킹 (가장 중요한 부분!) - # 재귀에서 돌아왔다는 건 i를 포함한 모든 경우를 다 봤다는 뜻 - chk[i] = False # 4. 방문 표시 해제 (다음에 쓰기 위해) - rs.pop() # 5. 결과 리스트에서 빼기 (원상복구) -# 함수 시작 (0개 고른 상태에서 출발) -recur(0) +# import sys +# +# # 입력 받기 +# N, M = map(int, sys.stdin.readline().split()) +# +# rs = [] # 결과를 담을 리스트 (스택 역할) +# chk = [False] * (N + 1) # 방문 여부 체크 (1~N 인덱스 사용) +# +# def recur(num): +# # [1] 종료 조건: M개를 모두 골랐으면 출력 +# if num == M: +# print(' '.join(map(str, rs))) # [1, 2] -> "1 2" 출력 +# return +# +# # [2] 1부터 N까지 반복 +# for i in range(1, N + 1): +# if chk[i] == False: # 아직 안 쓴 숫자라면 +# chk[i] = True # 1. 방문 표시 (찜하기) +# rs.append(i) # 2. 결과 리스트에 넣기 +# +# recur(num + 1) # 3. 다음 숫자 고르러 더 깊이 들어감 (재귀) +# +# # [3] 백트래킹 (가장 중요한 부분!) +# # 재귀에서 돌아왔다는 건 i를 포함한 모든 경우를 다 봤다는 뜻 +# chk[i] = False # 4. 방문 표시 해제 (다음에 쓰기 위해) +# rs.pop() # 5. 결과 리스트에서 빼기 (원상복구) +# +# # 함수 시작 (0개 고른 상태에서 출발) +# recur(0) diff --git "a/src/\353\260\261\354\244\200/Silver/\354\204\244\355\203\225\353\260\260\353\213\254/\354\204\244\355\203\225\353\260\260\353\213\254.py" "b/src/\353\260\261\354\244\200/Silver/\354\204\244\355\203\225\353\260\260\353\213\254/\354\204\244\355\203\225\353\260\260\353\213\254.py" new file mode 100644 index 0000000..394d830 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\354\204\244\355\203\225\353\260\260\353\213\254/\354\204\244\355\203\225\353\260\260\353\213\254.py" @@ -0,0 +1,17 @@ +import sys + +n=int(sys.stdin.readline()) + +inf = float('inf') +dp=[inf] * 5006 + +dp[3]=1 +dp[5]=1 + +for i in range(6,n+1): + dp[i] = min(dp[i-3],dp[i-5])+1 + +if(dp[n]==inf): + print("-1") +else: + print(dp[n]) From 580634ea0db417362e9257ca7a3e139004300f73 Mon Sep 17 00:00:00 2001 From: choikang Date: Thu, 8 Jan 2026 23:28:27 +0900 Subject: [PATCH 07/13] =?UTF-8?q?=EB=B0=B1=EC=A4=80=20-=20=EC=B9=98?= =?UTF-8?q?=ED=82=A8=EB=B0=B0=EB=8B=AC=20=EB=AC=B8=EC=A0=9C=20=ED=92=80?= =?UTF-8?q?=EC=9D=B4(01=5F06)=20=20=20=20=20-=20n=EA=B3=BCm2=20=EB=AC=B8?= =?UTF-8?q?=EC=A0=9C=20=ED=92=80=EC=9D=B4(01=5F08)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...54\354\223\264\353\262\204\354\240\204.py" | 0 ...30\355\202\250\353\260\260\353\213\254.py" | 185 ++++++++++++++++++ ...54\354\265\234\354\240\201\355\231\224.py" | 74 +++++++ ...67\352\260\210\353\246\260\352\261\260.md" | 108 ++++++++++ .../N\352\263\274M1/n\352\263\274m1.py" | 26 ++- .../N\352\263\274M2/N\352\263\274M2.py" | 17 ++ 6 files changed, 401 insertions(+), 9 deletions(-) create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\271\230\355\202\250\353\260\260\353\213\254/\353\235\274\354\235\264\353\270\214\353\237\254\353\246\254\354\223\264\353\262\204\354\240\204.py" create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\271\230\355\202\250\353\260\260\353\213\254/\354\271\230\355\202\250\353\260\260\353\213\254.py" create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\271\230\355\202\250\353\260\260\353\213\254/\354\271\230\355\202\250\353\260\260\353\213\254\354\265\234\354\240\201\355\231\224.py" create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\271\230\355\202\250\353\260\260\353\213\254/\355\227\267\352\260\210\353\246\260\352\261\260.md" create mode 100644 "src/\353\260\261\354\244\200/Silver/N\352\263\274M2/N\352\263\274M2.py" diff --git "a/src/\353\260\261\354\244\200/Gold/\354\271\230\355\202\250\353\260\260\353\213\254/\353\235\274\354\235\264\353\270\214\353\237\254\353\246\254\354\223\264\353\262\204\354\240\204.py" "b/src/\353\260\261\354\244\200/Gold/\354\271\230\355\202\250\353\260\260\353\213\254/\353\235\274\354\235\264\353\270\214\353\237\254\353\246\254\354\223\264\353\262\204\354\240\204.py" new file mode 100644 index 0000000..e69de29 diff --git "a/src/\353\260\261\354\244\200/Gold/\354\271\230\355\202\250\353\260\260\353\213\254/\354\271\230\355\202\250\353\260\260\353\213\254.py" "b/src/\353\260\261\354\244\200/Gold/\354\271\230\355\202\250\353\260\260\353\213\254/\354\271\230\355\202\250\353\260\260\353\213\254.py" new file mode 100644 index 0000000..7b8b9f1 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\354\271\230\355\202\250\353\260\260\353\213\254/\354\271\230\355\202\250\353\260\260\353\213\254.py" @@ -0,0 +1,185 @@ +import sys + +n,m = map(int,sys.stdin.readline().split()) +city= [list(map(int,sys.stdin.readline().split())) for _ in range(n)] + +chickens=[] +selected_chickens=[] +houses=[] +answer=float("inf") + +for r in range(n): + for c in range(n): + if city[r][c]==1: + houses.append((r,c)) + elif city[r][c]==2: + chickens.append((r,c)) + +def dfs(index,count): + global answer + if count==m: + chicken_dist=0 + for hr,hc in houses: + min_dist=float("inf") + for cr,cc in selected_chickens: + min_dist=min(min_dist,abs(hr-cr)+abs(hc-cc)) + chicken_dist+=min_dist + answer=min(answer,chicken_dist) + return + + for i in range(index,len(chickens)): + selected_chickens.append(chickens[i]) + dfs(i+1,count+1) + selected_chickens.pop() + +dfs(0,0) +print(answer) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +# import sys +# +# # n과 m 입력받기 +# n,m = int(sys.stdin.readline().split()) +# # 도시 입력받기 +# city = [list(map(int,sys.stdin.readline().split())) for _ in range(n)] +# # 집과 치킨집 좌표를 담은 리스트 만들기 +# houses = [] +# chickens = [] +# selected_chickens = [] +# # city를 전체 탐색하면서 1로 표시된 곳은 houses에 추가 2로 표시된 곳은 chickens에 추가 +# for r in range(n): +# for c in range(n): +# if city[r][c]==1: +# houses.append((r,c)) +# elif city[r][c]==2: +# chickens.append((r,c)) +# # dfs 매개변수 현재 치킨집의 인덱스 종료조건 최대 m개 +# def dfs(index,count): +# if count==m: +# total_dist=0 +# for hr,hc in houses: +# min_dist=float('inf') +# for cr,cc in selected_chickens: +# dist = abs(hr-cr) + abs(hc-cc) +# min_dist = min(min_dist,dist) #영수집에서 치킨집 a와b중 더 거리가 최소인 값 +# total_dist+=min_dist +# return total_dist +# # 종료조건 m개가 되었다면 집에서 치킨집까지의 최소 거리를 구하고 각 집의 최소거리를 모두 더했을때의 최소 +# # 종료조건 m이 안되었다면 치킨집의 인덱스를 하나 더해주고 현재 치킨집 개수 +1 + + + + + + + + + + + + + + + + + + + + +# import sys +# +# N, M = map(int, sys.stdin.readline().split()) +# city = [list(map(int, sys.stdin.readline().split())) for _ in range(N)] +# +# houses = [] +# chickens = [] +# +# # 1. 집과 치킨집 좌표 수집 +# for r in range(N): +# for c in range(N): +# if city[r][c] == 1: +# houses.append((r, c)) +# elif city[r][c] == 2: +# chickens.append((r, c)) +# +# # 정답(최솟값) 저장 변수 +# result = float('inf') +# +# # 선택된 치킨집들을 담을 리스트 (N과 M에서의 'rs' 역할) +# selected_chickens = [] +# +# # ========================================== +# # 여기가 바로 [백트래킹] 파트입니다! ⭐ +# # ========================================== +# def dfs(idx, count): +# global result +# +# # [종료 조건] M개를 다 골랐다면? (M개 폐업 안 시키고 살림) +# if count == M: +# # 이 조합으로 도시의 치킨 거리 계산 (완전 탐색) +# total_dist = 0 +# for hr, hc in houses: +# min_dist = float('inf') +# for cr, cc in selected_chickens: +# dist = abs(hr - cr) + abs(hc - cc) +# min_dist = min(min_dist, dist) +# total_dist += min_dist +# +# # (가지치기: 이미 최솟값 넘어가면 중단) +# if total_dist >= result: +# return +# +# # 최솟값 갱신 +# result = min(result, total_dist) +# return +# +# # [재귀 호출] 현재 위치(idx)부터 끝까지 하나씩 골라봄 +# for i in range(idx, len(chickens)): +# # 1. 치킨집 선택 (바구니에 담기) +# selected_chickens.append(chickens[i]) +# +# # 2. 다음 치킨집 고르러 가기 (깊이 + 1) +# dfs(i + 1, count + 1) +# +# # 3. 백트래킹 (다녀와서 바구니에서 빼기 - 원상복구) 🔙 +# selected_chickens.pop() +# +# # 백트래킹 시작 (0번 인덱스부터, 현재 0개 선택됨) +# dfs(0, 0) +# +# print(result) +# diff --git "a/src/\353\260\261\354\244\200/Gold/\354\271\230\355\202\250\353\260\260\353\213\254/\354\271\230\355\202\250\353\260\260\353\213\254\354\265\234\354\240\201\355\231\224.py" "b/src/\353\260\261\354\244\200/Gold/\354\271\230\355\202\250\353\260\260\353\213\254/\354\271\230\355\202\250\353\260\260\353\213\254\354\265\234\354\240\201\355\231\224.py" new file mode 100644 index 0000000..f391469 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\354\271\230\355\202\250\353\260\260\353\213\254/\354\271\230\355\202\250\353\260\260\353\213\254\354\265\234\354\240\201\355\231\224.py" @@ -0,0 +1,74 @@ +import sys + +# 빠른 입력을 위해 사용 +input = sys.stdin.readline + +N, M = map(int, input().split()) + +houses = [] +chickens = [] + +# 1. 지도 전체를 돌며 집과 치킨집 좌표만 추출 +for r in range(N): + row = list(map(int, input().split())) + for c in range(N): + if row[c] == 1: + houses.append((r, c)) + elif row[c] == 2: + chickens.append((r, c)) + +# [최적화 핵심] 모든 집과 모든 치킨집 사이의 거리를 미리 계산해둠 (표 만들기) +# dist_table[h][c] = h번째 집과 c번째 치킨집 사이의 거리 +# 이렇게 하면 나중에 뺄셈 계산 없이 표에서 숫자만 쏙 꺼내오면 됨 +dist_table = [] +for hr, hc in houses: + temp = [] + for cr, cc in chickens: + dist = abs(hr - cr) + abs(hc - cc) + temp.append(dist) + dist_table.append(temp) + +result = float('inf') +selected_indices = [] # 내가 선택한 치킨집의 '번호(index)'를 저장 + +def dfs(idx, count): + global result + + # [종료 조건] M개를 모두 골랐을 때 -> 거리 계산 시작 + if count == M: + current_city_chicken_dist = 0 + + # 모든 집에 대하여 (미리 만든 표를 보고 최소 거리 찾기) + for h in range(len(houses)): + min_dist_for_house = float('inf') + + # 내가 선택한 치킨집들 중에서 가장 가까운 거리 찾기 + for c_idx in selected_indices: + # 계산(abs) 안 하고 표에서 값만 가져옴 -> 속도 UP + dist = dist_table[h][c_idx] + + # 최솟값 갱신 + if dist < min_dist_for_house: + min_dist_for_house = dist + + current_city_chicken_dist += min_dist_for_house + + # [가지치기] 이미 현재 최솟값(result)을 넘어버렸다면 중단 (더 볼 필요 없음) + if current_city_chicken_dist >= result: + return + + # 최종적으로 더 작으면 결과 갱신 + if current_city_chicken_dist < result: + result = current_city_chicken_dist + return + + # [백트래킹] idx부터 치킨집 하나씩 골라보기 + for i in range(idx, len(chickens)): + selected_indices.append(i) # 치킨집 번호 담기 + dfs(i + 1, count + 1) # 다음 거 고르러 가기 + selected_indices.pop() # 다녀와서 빼기 (원상복구) + +# 0번 치킨집부터 시작, 현재 0개 선택함 +dfs(0, 0) + +print(result) \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Gold/\354\271\230\355\202\250\353\260\260\353\213\254/\355\227\267\352\260\210\353\246\260\352\261\260.md" "b/src/\353\260\261\354\244\200/Gold/\354\271\230\355\202\250\353\260\260\353\213\254/\355\227\267\352\260\210\353\246\260\352\261\260.md" new file mode 100644 index 0000000..47032a5 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\354\271\230\355\202\250\353\260\260\353\213\254/\355\227\267\352\260\210\353\246\260\352\261\260.md" @@ -0,0 +1,108 @@ +맞습니다! 처음엔 그 기준이 헷갈리는 게 당연합니다. +하지만 딱 **두 가지 질문**만 던져보면, `idx`가 필요한지 아닌지 바로 판단할 수 있습니다. + +핵심은 **"순서가 중요한가?"**와 **"중복을 허용하는가?"**입니다. + +--- + +### 1. 기준: "순서가 상관없는가?" (조합, Combination) + +👉 **치킨 배달 문제** + +* **상황:** 치킨집 A와 B를 뽑는 것이나, B와 A를 뽑는 것이나 **똑같은 경우**입니다. (팀 구성) +* **판단:** "아, `(A, B)`를 뽑았으면 `(B, A)`는 굳이 또 안 봐도 되는구나!" +* **전략:** 내 뒤에 있는 애들만 보면 됩니다. (앞으로 전진만 함) +* **필요한 매개변수:** **`idx` (시작점)** +* `idx`를 넘겨줘서 `for i in range(idx, N):` 처럼 **앞쪽은 아예 쳐다도 안 보게** 만들어야 합니다. + + + +```python +# 조합 (순서 상관 X) -> idx 필수! +def dfs(idx, count): + if count == M: return + + # 내 현재 위치(idx)부터 뒤쪽만 봄 + for i in range(idx, N): + dfs(i + 1, count + 1) + +``` + +--- + +### 2. 기준: "순서가 중요한가?" (순열, Permutation) + +👉 **N과 M (1)번 문제** (1부터 N까지 자연수 중 M개를 고른 수열) + +* **상황:** `(1, 2)`와 `(2, 1)`은 **다른 경우**입니다. (달리기 등수 매기기) +* **판단:** "내가 1등으로 2를 뽑았어도, 나중에 1등으로 1을 뽑고 2등으로 2를 뽑는 건 다른 거니까 다시 봐야 해!" +* **전략:** 매번 **처음(0번)부터** 다시 훑어봐야 합니다. 대신 **"이미 쓴 숫자"**만 피하면 됩니다. +* **필요한 매개변수:** `idx` 필요 없음 ❌ (대신 `visited` 체크 배열이 필요) +* 항상 `for i in range(0, N):` 으로 처음부터 돕니다. + + + +```python +# 순열 (순서 중요 O) -> idx 필요 없음! (visited 필요) +def dfs(count): + if count == M: return + + # 무조건 처음(0)부터 다시 훑음 + for i in range(0, N): + if not visited[i]: # 이미 쓴 것만 아니면 됨 + visited[i] = True + dfs(count + 1) + visited[i] = False + +``` + +--- + +### ⚖️ 딱 정해드립니다 (판단 요령) + +문제를 읽고 다음과 같이 자문해보세요. + +#### Q1. "A랑 B 뽑은 거랑, B랑 A 뽑은 게 같은 취급인가?" + +* **YES (같다/팀 뽑기):** +* 👉 **조합 (Combination)** +* **매개변수:** `idx`, `count` +* **코드:** `range(idx, N)`, 재귀는 `dfs(i + 1, count + 1)` +* *예: 치킨 배달, 로또 번호 뽑기* + + +* **NO (다르다/줄 세우기):** +* 👉 **순열 (Permutation)** +* **매개변수:** `count` (단, `visited` 배열 별도 필요) +* **코드:** `range(0, N)`, 재귀는 `dfs(count + 1)` +* *예: N과 M (1), 이어달리기 주자 배치* + + + +--- + +### 💡 하나 더! (중복 허용 여부) + +가끔 **"중복을 허용해서 뽑아라"** (같은 치킨집 2번 골라도 됨, 주사위 던지기 등) 문제도 나옵니다. + +* **중복 순열 (순서 O, 중복 O):** +* `idx` 필요 없음, `visited`도 필요 없음. +* 그냥 `range(0, N)` 돌리고 `dfs(count + 1)` + + +* **중복 조합 (순서 X, 중복 O):** +* `idx` 필요함. +* 단, 나 자신을 또 뽑아도 되니까 `dfs(i, count + 1)` (i에 +1을 안 함) + + + +### 🚀 요약표 + +| 문제 유형 | 상황 예시 | 순서 | 중복 | 필요 매개변수 | 재귀 호출 | +| --- | --- | --- | --- | --- | --- | +| **조합 (치킨배달)** | 대표 2명 뽑기 | X | X | **idx**, count | `dfs(i+1, cnt+1)` | +| **순열 (N과M 1)** | 반장, 부반장 뽑기 | O | X | count (+visited) | `dfs(cnt+1)` | +| **중복 조합** | 같은 메뉴 2개 가능 | X | O | **idx**, count | `dfs(i, cnt+1)` | +| **중복 순열** | 비밀번호 4자리 | O | O | count | `dfs(cnt+1)` | + +이제 **"순서가 상관있나?"** 이 질문 하나만 던지면 `idx`를 넣을지 말지 바로 감이 오실 거예요! \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/n\352\263\274m1.py" "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/n\352\263\274m1.py" index 735f229..ff9e2e3 100644 --- "a/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/n\352\263\274m1.py" +++ "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/n\352\263\274m1.py" @@ -1,22 +1,30 @@ import sys -n,m, = map(int, sys.stdin.readline().split()) +n, m = map(int, sys.stdin.readline().split()) rs = [] -checked = [False] * (n+1) + +# [변경 1] 0번부터 n-1번 인덱스를 쓸 거니까 크기는 n이면 충분합니다. +checked = [False] * n def recursive(num): - if(num==m): + if num == m: print(*rs) return - for i in range(1,n+1): - if(checked[i]==False): - checked[i]=True - rs.append(i) + # [변경 2] range(n) -> 0, 1, 2, ..., n-1 까지 돕니다. + for i in range(n): + + # checked[0], checked[1]... 을 검사합니다. + if checked[i] == False: + checked[i] = True + + # [변경 3] i는 0이지만, 문제에서 원하는 숫자는 1이어야 하죠? + # 그래서 넣을 때만 1을 더해서 넣어줍니다. + rs.append(i + 1) - recursive(num+1) + recursive(num + 1) - checked[i]=False + checked[i] = False rs.pop() recursive(0) diff --git "a/src/\353\260\261\354\244\200/Silver/N\352\263\274M2/N\352\263\274M2.py" "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M2/N\352\263\274M2.py" new file mode 100644 index 0000000..d28b826 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M2/N\352\263\274M2.py" @@ -0,0 +1,17 @@ +import sys + +n,m = map(int,sys.stdin.readline().split()) + +answer=[] + +def dfs(index,count): + if count==m: + print(*answer) + return + + for i in range(index,n): + answer.append(i+1) + dfs(i+1, count+1) + answer.pop() + +dfs(0,0) \ No newline at end of file From 8fce42ffb2167890390b3c2d59d990ae57442d07 Mon Sep 17 00:00:00 2001 From: choikang Date: Fri, 9 Jan 2026 16:43:40 +0900 Subject: [PATCH 08/13] =?UTF-8?q?=EB=B0=B1=EC=A4=80=20-=20n=EA=B3=BCm4=20?= =?UTF-8?q?=EB=AC=B8=EC=A0=9C=20=ED=92=80=EC=9D=B4(01=5F09)=20=20=20=20=20?= =?UTF-8?q?-=20n-queen=20=EB=AC=B8=EC=A0=9C=20=ED=92=80=EC=9D=B4(01=5F09)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Gold/N_Queen/howtosolve.md" | 7 +++++ .../Gold/N_Queen/n-queen.py" | 27 +++++++++++++++++++ .../N\352\263\274M4/N\352\263\274M4.py" | 15 +++++++++++ 3 files changed, 49 insertions(+) create mode 100644 "src/\353\260\261\354\244\200/Gold/N_Queen/howtosolve.md" create mode 100644 "src/\353\260\261\354\244\200/Gold/N_Queen/n-queen.py" create mode 100644 "src/\353\260\261\354\244\200/Silver/N\352\263\274M4/N\352\263\274M4.py" diff --git "a/src/\353\260\261\354\244\200/Gold/N_Queen/howtosolve.md" "b/src/\353\260\261\354\244\200/Gold/N_Queen/howtosolve.md" new file mode 100644 index 0000000..72c1e79 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/N_Queen/howtosolve.md" @@ -0,0 +1,7 @@ +1. 순차적인 결정: 1번 줄 결정 -> 2번 줄 결정 -> ---(트리 구조) +2. 지금 이 결정이 괜찮은지 바로 체크 +3. 안될 놈이면 뒤의 잘못된 경우의 수를 가지치기 해버리면 탐색 시간이 확 줄어듬 + +경우의 수가 너무 많아서 다 해볼 순 없는데, 순서대로 진행하면서 중간에 틀린걸 감지할 수 있으니, 가다가 아니면 되돌아오는 방식을 풀기 +n이 작음 보통 백트래킹 문제는 10-15사이 +선택의 연속: a를 고르고 그다음 b를 고르고 앞의 선택이 뒤의 선택에 영향을 줄 때 \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Gold/N_Queen/n-queen.py" "b/src/\353\260\261\354\244\200/Gold/N_Queen/n-queen.py" new file mode 100644 index 0000000..4d3f6e9 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/N_Queen/n-queen.py" @@ -0,0 +1,27 @@ +import sys + +n=int(sys.stdin.readline()) + +map=[0]*n +answer=0 + +# 가지치기 +def check(row_index): + for i in range(row_index): + if map[row_index]==map[i] or abs(map[row_index]-map[i])==abs(row_index-i): + return False + return True + +def dfs(row_index): + global answer + if row_index==n: + answer+=1 + return + + for col_index in range(n): + map[row_index]=col_index + if check(row_index): + dfs(row_index+1) + +dfs(0) +print(answer) \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/N\352\263\274M4/N\352\263\274M4.py" "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M4/N\352\263\274M4.py" new file mode 100644 index 0000000..96ebfbc --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M4/N\352\263\274M4.py" @@ -0,0 +1,15 @@ +import sys + +n,m=map(int,sys.stdin.readline().split()) +rs=[] + +def dfs(index,count): + if m==count: + print(*rs) + return + for i in range(index,n): + rs.append(i+1) + dfs(i,count+1) + rs.pop() + +dfs(0,0) \ No newline at end of file From d5f04b1ab14579e4faa1bce2406f3bb052373db4 Mon Sep 17 00:00:00 2001 From: choikang Date: Sun, 18 Jan 2026 22:26:47 +0900 Subject: [PATCH 09/13] =?UTF-8?q?=EB=B0=B1=EC=A4=80=20-=20n=EA=B3=BCm3=20?= =?UTF-8?q?=EB=AC=B8=EC=A0=9C=20=ED=92=80=EC=9D=B4(01=5F05)=20=20=20=20=20?= =?UTF-8?q?-=20=EC=97=B0=EC=82=B0=EC=9E=90=EB=81=BC=EC=9B=8C=EB=84=A3?= =?UTF-8?q?=EA=B8=B0=20=EB=AC=B8=EC=A0=9C=20=ED=92=80=EC=9D=B4(01=5F18)=20?= =?UTF-8?q?=20=20=20=20-=20=EC=8A=A4=ED=83=80=ED=8A=B8=EC=99=80=EB=A7=81?= =?UTF-8?q?=ED=81=AC=20=EB=AC=B8=EC=A0=9C=20=ED=92=80=EC=9D=B4(01=5F18?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Silver/N\352\263\274M1/README.md" | 124 ++++++++++++++++ .../Silver/N\352\263\274M2/readme.md" | 96 ++++++++++++ .../N\352\263\274M3/N\352\263\274M3.py" | 16 ++ .../Silver/N\352\263\274M3/README.md" | 132 +++++++++++++++++ .../Silver/N\352\263\274M4/README.md" | 111 ++++++++++++++ .../README.md" | 0 .../README.md" | 0 .../readme.md" | 138 ++++++++++++++++++ ...70\354\231\200\353\247\201\355\201\254.py" | 109 ++++++++++++++ ...0\354\231\200\353\247\201\355\201\2542.py" | 27 ++++ .../readme.md" | 0 ...74\354\233\214\353\204\243\352\270\260.py" | 44 ++++++ 12 files changed, 797 insertions(+) create mode 100644 "src/\353\260\261\354\244\200/Silver/N\352\263\274M2/readme.md" create mode 100644 "src/\353\260\261\354\244\200/Silver/N\352\263\274M3/N\352\263\274M3.py" create mode 100644 "src/\353\260\261\354\244\200/Silver/N\352\263\274M3/README.md" create mode 100644 "src/\353\260\261\354\244\200/Silver/N\352\263\274M4/README.md" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\204\244\355\203\225\353\260\260\353\213\254/README.md" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\210\230\353\223\244\354\235\230\355\225\2512/README.md" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254/readme.md" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254.py" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\2542.py" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260/readme.md" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260.py" diff --git "a/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/README.md" "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/README.md" index e69de29..b41ca9c 100644 --- "a/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/README.md" +++ "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M1/README.md" @@ -0,0 +1,124 @@ + +[문제 링크](https://www.acmicpc.net/problem/15649) + +# 15649번: N과 M (1) + +| 시간 제한 | 메모리 제한 | 제출 | 정답 | 맞힌 사람 | 정답 비율 | +| :---: | :---: | :---: | :---: | :---: | :---: | +| 1 초 | 512 MB | 100000+ | - | - | 62.7% | + +----- + +## 문제 + +자연수 N과 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오. + +* 1부터 N까지 자연수 중에서 중복 없이 M개를 고른 수열 + +----- + +## 입력 + +첫째 줄에 자연수 N과 M이 주어진다. (1 ≤ M ≤ N ≤ 8) + +----- + +## 출력 + +한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다. 중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다. + +수열은 사전 순으로 증가하는 순서로 출력해야 한다. + +----- + +## 예제 입력 1 + + +``` + +3 1 + +``` + +## 예제 출력 1 + + +``` + +1 +2 +3 + +``` + +## 예제 입력 2 + + +``` + +4 2 + +``` + +## 예제 출력 2 + + +``` + +1 2 +1 3 +1 4 +2 1 +2 3 +2 4 +3 1 +3 2 +3 4 +4 1 +4 2 +4 3 + +``` + +## 예제 입력 3 + + +``` + +4 4 + +``` + +## 예제 출력 3 + + +``` + +1 2 3 4 +1 2 4 3 +1 3 2 4 +1 3 4 2 +1 4 2 3 +1 4 3 2 +2 1 3 4 +2 1 4 3 +2 3 1 4 +2 3 4 1 +2 4 1 3 +2 4 3 1 +3 1 2 4 +3 1 4 2 +3 2 1 4 +3 2 4 1 +3 4 1 2 +3 4 2 1 +4 1 2 3 +4 1 3 2 +4 2 1 3 +4 2 3 1 +4 3 1 2 +4 3 2 1 + +``` + +``` \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/N\352\263\274M2/readme.md" "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M2/readme.md" new file mode 100644 index 0000000..ebe3e57 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M2/readme.md" @@ -0,0 +1,96 @@ + +[문제 링크](https://www.acmicpc.net/problem/15650) + +# 15650번: N과 M (2) + +| 시간 제한 | 메모리 제한 | 제출 | 정답 | 맞힌 사람 | 정답 비율 | +| :---: | :---: | :---: | :---: | :---: | :---: | +| 1 초 | 512 MB | 60000+ | - | - | 74.5% | + +----- + +## 문제 + +자연수 N과 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오. + +* 1부터 N까지 자연수 중에서 중복 없이 M개를 고른 수열 +* 고른 수열은 오름차순이어야 한다. + +----- + +## 입력 + +첫째 줄에 자연수 N과 M이 주어진다. (1 ≤ M ≤ N ≤ 8) + +----- + +## 출력 + +한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다. 중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다. + +수열은 사전 순으로 증가하는 순서로 출력해야 한다. + +----- + +## 예제 입력 1 + + +``` + +3 1 + +``` + +## 예제 출력 1 + + +``` + +1 +2 +3 + +``` + +## 예제 입력 2 + + +``` + +4 2 + +``` + +## 예제 출력 2 + + +``` + +1 2 +1 3 +1 4 +2 3 +2 4 +3 4 + +``` + +## 예제 입력 3 + + +``` + +4 4 + +``` + +## 예제 출력 3 + + +``` + +1 2 3 4 + +``` + +``` \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/N\352\263\274M3/N\352\263\274M3.py" "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M3/N\352\263\274M3.py" new file mode 100644 index 0000000..eb04b5f --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M3/N\352\263\274M3.py" @@ -0,0 +1,16 @@ +import sys + +n,m=map(int,sys.stdin.readline().split()) +rs=[] + +def dfs(index,count): + if count==m: + print(*rs) + return + for i in range(n): + rs.append(i+1) + dfs(i+1,count+1) + rs.pop() + +dfs(0,0) + diff --git "a/src/\353\260\261\354\244\200/Silver/N\352\263\274M3/README.md" "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M3/README.md" new file mode 100644 index 0000000..f48d31e --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M3/README.md" @@ -0,0 +1,132 @@ + +[문제 링크](https://www.acmicpc.net/problem/15651) + +# 15651번: N과 M (3) + +| 시간 제한 | 메모리 제한 | 제출 | 정답 | 맞힌 사람 | 정답 비율 | +| :---: | :---: | :---: | :---: | :---: | :---: | +| 1 초 | 512 MB | 50000+ | - | - | 66.8% | + +----- + +## 문제 + +자연수 N과 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오. + +* 1부터 N까지 자연수 중에서 M개를 고른 수열 +* 같은 수를 여러 번 골라도 된다. + +----- + +## 입력 + +첫째 줄에 자연수 N과 M이 주어진다. (1 ≤ M ≤ N ≤ 7) + +----- + +## 출력 + +한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다. 중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다. + +수열은 사전 순으로 증가하는 순서로 출력해야 한다. + +----- + +## 예제 입력 1 + + +``` + +3 1 + +``` + +## 예제 출력 1 + + +``` + +1 +2 +3 + +``` + +## 예제 입력 2 + + +``` + +4 2 + +``` + +## 예제 출력 2 + + +``` + +1 1 +1 2 +1 3 +1 4 +2 1 +2 2 +2 3 +2 4 +3 1 +3 2 +3 3 +3 4 +4 1 +4 2 +4 3 +4 4 + +``` + +## 예제 입력 3 + + +``` + +3 3 + +``` + +## 예제 출력 3 + + +``` + +1 1 1 +1 1 2 +1 1 3 +1 2 1 +1 2 2 +1 2 3 +1 3 1 +1 3 2 +1 3 3 +2 1 1 +2 1 2 +2 1 3 +2 2 1 +2 2 2 +2 2 3 +2 3 1 +2 3 2 +2 3 3 +3 1 1 +3 1 2 +3 1 3 +3 2 1 +3 2 2 +3 2 3 +3 3 1 +3 3 2 +3 3 3 + +``` + +``` \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/N\352\263\274M4/README.md" "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M4/README.md" new file mode 100644 index 0000000..7bb440f --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/N\352\263\274M4/README.md" @@ -0,0 +1,111 @@ + +[문제 링크](https://www.acmicpc.net/problem/15652) + +# 15652번: N과 M (4) + +| 시간 제한 | 메모리 제한 | 제출 | 정답 | 맞힌 사람 | 정답 비율 | +| :---: | :---: | :---: | :---: | :---: | :---: | +| 1 초 | 512 MB | 40000+ | - | - | 76.7% | + +----- + +## 문제 + +자연수 N과 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오. + +* 1부터 N까지 자연수 중에서 M개를 고른 수열 +* 같은 수를 여러 번 골라도 된다. +* 고른 수열은 비내림차순이어야 한다. + * 길이가 K인 수열 A가 A[1] ≤ A[2] ≤ ... ≤ A[K-1] ≤ A[K]를 만족하면, 비내림차순이라고 한다. + +----- + +## 입력 + +첫째 줄에 자연수 N과 M이 주어진다. (1 ≤ M ≤ N ≤ 8) + +----- + +## 출력 + +한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다. 중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다. + +수열은 사전 순으로 증가하는 순서로 출력해야 한다. + +----- + +## 예제 입력 1 + + +``` + +3 1 + +``` + +## 예제 출력 1 + + +``` + +1 +2 +3 + +``` + +## 예제 입력 2 + + +``` + +4 2 + +``` + +## 예제 출력 2 + + +``` + +1 1 +1 2 +1 3 +1 4 +2 2 +2 3 +2 4 +3 3 +3 4 +4 4 + +``` + +## 예제 입력 3 + + +``` + +3 3 + +``` + +## 예제 출력 3 + + +``` + +1 1 1 +1 1 2 +1 1 3 +1 2 2 +1 2 3 +1 3 3 +2 2 2 +2 2 3 +2 3 3 +3 3 3 + +``` + +``` \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/\354\204\244\355\203\225\353\260\260\353\213\254/README.md" "b/src/\353\260\261\354\244\200/Silver/\354\204\244\355\203\225\353\260\260\353\213\254/README.md" new file mode 100644 index 0000000..e69de29 diff --git "a/src/\353\260\261\354\244\200/Silver/\354\210\230\353\223\244\354\235\230\355\225\2512/README.md" "b/src/\353\260\261\354\244\200/Silver/\354\210\230\353\223\244\354\235\230\355\225\2512/README.md" new file mode 100644 index 0000000..e69de29 diff --git "a/src/\353\260\261\354\244\200/Silver/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254/readme.md" "b/src/\353\260\261\354\244\200/Silver/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254/readme.md" new file mode 100644 index 0000000..3a405bd --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254/readme.md" @@ -0,0 +1,138 @@ + +[문제 링크](https://www.acmicpc.net/problem/14889) + +# 14889번: 스타트와 링크 + +| 시간 제한 | 메모리 제한 | 제출 | 정답 | 맞힌 사람 | 정답 비율 | +| :---: | :---: | :---: | :---: | :---: | :---: | +| 2 초 | 512 MB | 100000+ | - | - | 47.7% | + +----- + +## 문제 + +오늘은 스타트링크에 다니는 사람들이 모여서 축구를 해보려고 한다. 축구는 평일 오후에 하고 의무 참석도 아니다. 축구를 하기 위해 모인 사람은 총 N명이고 N은 짝수이다. 이제 N/2명으로 이루어진 스타트 팀과 링크 팀으로 사람들을 나눠야 한다. + +BOJ를 운영하는 회사 답게 사람에게 번호를 1부터 N까지로 배정했고, 아래와 같은 능력치를 조사했다. 능력치 Sij는 i번 사람과 j번 사람이 같은 팀에 속했을 때, 팀에 더해지는 능력치이다. 팀의 능력치는 팀에 속한 모든 쌍의 능력치 Sij의 합이다. Sij는 Sji와 다를 수도 있으며, i번 사람과 j번 사람이 같은 팀에 속했을 때, 팀에 더해지는 능력치는 Sij와 Sji이다. + +N=4이고, S가 아래와 같은 경우를 살펴보자. + +| i \ j | 1 | 2 | 3 | 4 | +| :---: | :---: | :---: | :---: | :---: | +| **1** | 0 | 1 | 2 | 3 | +| **2** | 4 | 0 | 5 | 6 | +| **3** | 7 | 1 | 0 | 2 | +| **4** | 3 | 4 | 5 | 0 | + +예를 들어, 1, 2번이 스타트 팀, 3, 4번이 링크 팀에 속한 경우에 두 팀의 능력치는 아래와 같다. + +* 스타트 팀: $S_{12} + S_{21} = 1 + 4 = 5$ +* 링크 팀: $S_{34} + S_{43} = 2 + 5 = 7$ + +1, 2번이 스타트 팀, 3, 4번이 링크 팀에 속했을 때, 두 팀의 능력치 차이는 |5 - 7| = 2이다. 만약 1, 3번이 스타트 팀, 2, 4번이 링크 팀에 속하면, 두 팀의 능력치 차이는 |(2 + 7) - (6 + 4)| = 1이 된다. + +축구를 재미있게 하기 위해서 스타트 팀의 능력치와 링크 팀의 능력치의 차이를 최소로 하려고 한다. 최솟값을 출력하는 프로그램을 작성하시오. + +----- + +## 입력 + +첫째 줄에 N(4 ≤ N ≤ 20, N은 짝수)이 주어진다. 둘째 줄부터 N개의 줄에 S가 주어진다. 각 줄은 N개의 수로 이루어져 있고, i번 줄의 j번째 수는 Sij 이다. Sii는 항상 0이고, 나머지 Sij는 1보다 크거나 같고, 100보다 작거나 같은 정수이다. + +----- + +## 출력 + +첫째 줄에 스타트 팀과 링크 팀의 능력치의 차이의 최솟값을 출력한다. + +----- + +## 예제 입력 1 + + +``` + +4 +0 1 2 3 +4 0 5 6 +7 1 0 2 +3 4 5 0 + +``` + +## 예제 출력 1 + + +``` + +0 + +``` + +## 예제 입력 2 + + +``` + +6 +0 1 2 3 4 5 +1 0 2 3 4 5 +1 2 0 3 4 5 +1 2 3 0 4 5 +1 2 3 4 0 5 +1 2 3 4 5 0 + +``` + +## 예제 출력 2 + + +``` + +2 + +``` + +## 예제 입력 3 + + +``` + +8 +0 5 4 5 4 5 4 5 +4 0 5 1 2 3 4 5 +9 8 0 1 2 3 1 2 +9 9 9 0 9 9 9 9 +1 1 1 1 0 1 1 1 +8 7 6 5 4 0 3 2 +9 1 9 1 9 1 0 9 +6 5 4 3 2 1 9 0 + +``` + +## 예제 출력 3 + + +``` + +1 + +``` + +----- + +## 💡 핵심 포인트 (Key Logic) + +1. **조합(Combination) 구현**: N명 중 N/2명을 뽑는 모든 경우의 수를 탐색한다. (백트래킹) +* `visited` 배열을 사용하여 뽑힌 사람은 `True`(스타트 팀), 안 뽑힌 사람은 `False`(링크 팀)으로 구분한다. +* **N과 M (2)** 방식(오름차순 탐색)을 사용하여 중복 계산을 방지한다. (`dfs(i + 1, count + 1)`) + +2. **팀 능력치 계산**: +* 별도의 팀 리스트를 만들지 않고, `visited` 배열을 2중 `for`문으로 순회하며 점수를 계산한다. +* `visited[i]`와 `visited[j]`가 둘 다 `True`이면 스타트 팀 합계에 추가. +* `visited[i]`와 `visited[j]`가 둘 다 `False`이면 링크 팀 합계에 추가. + +3. **최솟값 갱신**: +* 각 조합마다 `abs(start_sum - link_sum)`을 계산하여 전역 변수 `min_diff`를 갱신한다. + +``` \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254.py" "b/src/\353\260\261\354\244\200/Silver/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254.py" new file mode 100644 index 0000000..1be10a5 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254.py" @@ -0,0 +1,109 @@ +import sys + +n=int(sys.stdin.readline()) +board=[list(map(int,sys.stdin.readline().split())) for _ in range(n)] +rs=float("inf") +visited=[False]*n + +def dfs(index,count): + global rs + if count==(n//2): + startSum=0 + linkSum=0 + + for i in range(n): + for j in range(n): + if visited[i] and visited[j]: + startSum+=board[i][j] + elif not visited[i] and not visited[j]: + linkSum+=board[i][j] + + rs=min(rs,abs(startSum-linkSum)) + return rs + + for i in range(index,n): + if visited[i]==False: + visited[i]=True + dfs(i+1,count+1) + visited[i]=False +dfs(0,0) +print(rs) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +# import sys +# +# # [1] 입력 받기 +# input = sys.stdin.readline +# N = int(input()) +# board = [list(map(int, input().split())) for _ in range(N)] +# +# # [2] 방문 여부 체크 (True: 스타트팀, False: 링크팀) +# visited = [False] * N +# min_diff = float('inf') # 최솟값 저장용 (무한대로 초기화) +# +# def dfs(idx, count): +# global min_diff +# +# # [3] 종료 조건: 팀원이 N/2명 모였을 때 (스타트 팀 완성) +# if count == N // 2: +# start_power = 0 +# link_power = 0 +# +# # [4] 능력치 계산 (2중 for문) +# # 전체 인원(N)을 돌면서 팀을 구분해 점수를 더함 +# for i in range(N): +# for j in range(N): +# # 두 명 다 True면 -> 스타트 팀 시너지 +# if visited[i] and visited[j]: +# start_power += board[i][j] +# # 두 명 다 False면 -> 링크 팀 시너지 +# elif not visited[i] and not visited[j]: +# link_power += board[i][j] +# +# # [5] 차이의 최솟값 갱신 +# min_diff = min(min_diff, abs(start_power - link_power)) +# return +# +# # [6] 백트래킹 (조합 만들기: N과 M 2번 로직) +# # idx부터 시작하여 중복 방지 & 오름차순 유지 (순서 없는 조합) +# for i in range(idx, N): +# if not visited[i]: +# visited[i] = True # 스타트 팀 영입 +# dfs(i + 1, count + 1) +# visited[i] = False # 방출 (백트래킹) +# +# # 실행 (0번 사람부터 탐색 시작) +# dfs(0, 0) +# print(min_diff) \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\2542.py" "b/src/\353\260\261\354\244\200/Silver/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\2542.py" new file mode 100644 index 0000000..b196462 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\254/\354\212\244\355\203\200\355\212\270\354\231\200\353\247\201\355\201\2542.py" @@ -0,0 +1,27 @@ +import sys +n=int(sys.stdin.readline()) +board=[list(map(int, sys.stdin.readline().split())) for _ in range(n)] +min_value=1e9 +visited=[False]*n +def dfs(index,count): + global min_value + if count==n//2: + start=0 + link=0 + for i in range(n): + for j in range(n): + if visited[i] and visited[j]: + start+=board[i][j] + elif visited[i]==False and visited[j]==False: + link+=board[i][j] + min_value=min(min_value,abs(start-link)) + return min_value + + for i in range(index,n): + if visited[i]==False: + visited[i]=True + dfs(i+1,count+1) + visited[i]=False + +dfs(0,0) +print(min_value) \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260/readme.md" "b/src/\353\260\261\354\244\200/Silver/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260/readme.md" new file mode 100644 index 0000000..e69de29 diff --git "a/src/\353\260\261\354\244\200/Silver/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260.py" "b/src/\353\260\261\354\244\200/Silver/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260.py" new file mode 100644 index 0000000..b2a9e29 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260.py" @@ -0,0 +1,44 @@ +import sys +n=int(sys.stdin.readline()) +nums=list(map(int,sys.stdin.readline().split())) # 2,3 +op_counts=list(map(int,sys.stdin.readline().split())) # 1112 +min_value=1e9 +max_value=-1e9 +selected_op=[] + +def dfs(depth): + global min_value,max_value + #깊이가 n과 같아지면 즉 숫자가 목표하는 n만큼 전부 선택되면 + if depth==n-1: + # 더해지기 전해 처음 값은 고정 + now=nums[0] + # 숫자가4개면 연산자는3개 n-1만큼 반복 + for i in range(n-1): + # now의 값을 점차 연산해주는데 +,-각 연산자의 경우일떄를 나눠줌 + if selected_op[i]==0: + now+=nums[i+1] + elif selected_op[i]==1: + now-=nums[i+1] + elif selected_op[i]==2: + now*=nums[i+1] + elif selected_op[i]==3: + now=int(now/nums[i+1]) + + min_value=min(min_value,now) + max_value=max(max_value,now) + return + + #연산자를 선택 + for i in range(4): + if op_counts[i]>0: + op_counts[i]-=1 + selected_op.append(i) + dfs(depth+1) + selected_op.pop() + op_counts[i]+=1 + +dfs(0) +print(max_value) +print(min_value) + + From c4b593929b2a0709ec864f48b4fd73835e386dfc Mon Sep 17 00:00:00 2001 From: choikang Date: Mon, 19 Jan 2026 17:35:59 +0900 Subject: [PATCH 10/13] =?UTF-8?q?=EB=B0=B1=EC=A4=80=20-=20=ED=8A=B8?= =?UTF-8?q?=EB=A6=AC=EC=9D=98=20=EB=B6=80=EB=AA=A8=20=EC=B0=BE=EA=B8=B0=20?= =?UTF-8?q?=EB=AC=B8=EC=A0=9C=20=ED=92=80=EC=9D=B4(01=5F19)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../README.MD" | 90 +++++++++++++++++++ ...00\353\252\250\354\260\276\352\270\260.py" | 33 +++++++ 2 files changed, 123 insertions(+) create mode 100644 "src/\353\260\261\354\244\200/Silver/\355\212\270\353\246\254\354\235\230\353\266\200\353\252\250\354\260\276\352\270\260/README.MD" create mode 100644 "src/\353\260\261\354\244\200/Silver/\355\212\270\353\246\254\354\235\230\353\266\200\353\252\250\354\260\276\352\270\260/\355\212\270\353\246\254\354\235\230\353\266\200\353\252\250\354\260\276\352\270\260.py" diff --git "a/src/\353\260\261\354\244\200/Silver/\355\212\270\353\246\254\354\235\230\353\266\200\353\252\250\354\260\276\352\270\260/README.MD" "b/src/\353\260\261\354\244\200/Silver/\355\212\270\353\246\254\354\235\230\353\266\200\353\252\250\354\260\276\352\270\260/README.MD" new file mode 100644 index 0000000..cc2f73f --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\355\212\270\353\246\254\354\235\230\353\266\200\353\252\250\354\260\276\352\270\260/README.MD" @@ -0,0 +1,90 @@ + +[문제 링크](https://www.acmicpc.net/problem/11725) + +# 11725번: 트리의 부모 찾기 + +| 시간 제한 | 메모리 제한 | 제출 | 정답 | 맞힌 사람 | 정답 비율 | +| --- | --- | --- | --- | --- | --- | +| 1 초 | 256 MB | 158321 | 67923 | 47352 | 41.714% | + +--- + +## 문제 + +루트 없는 트리가 주어진다. 이때, 트리의 루트를 1이라고 정했을 때, 각 노드의 부모를 구하는 프로그램을 작성하시오. + +--- + +## 입력 + +첫째 줄에 노드의 개수 N (2 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 N-1개의 줄에 트리 상에서 연결된 두 정점이 주어진다. + +--- + +## 출력 + +첫째 줄부터 N-1개의 줄에 각 노드의 부모 노드 번호를 2번 노드부터 순서대로 출력한다. + +--- + +## 예제 입력 1 + +``` +7 +1 6 +6 3 +3 5 +4 1 +2 4 +4 7 + +``` + +## 예제 출력 1 + +``` +4 +6 +1 +3 +1 +4 + +``` + +--- + +## 예제 입력 2 + +``` +12 +1 2 +1 3 +2 4 +3 5 +3 6 +4 7 +4 8 +5 9 +5 10 +6 11 +6 12 + +``` + +## 예제 출력 2 + +``` +1 +1 +2 +3 +3 +4 +4 +5 +5 +6 +6 + +``` \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/\355\212\270\353\246\254\354\235\230\353\266\200\353\252\250\354\260\276\352\270\260/\355\212\270\353\246\254\354\235\230\353\266\200\353\252\250\354\260\276\352\270\260.py" "b/src/\353\260\261\354\244\200/Silver/\355\212\270\353\246\254\354\235\230\353\266\200\353\252\250\354\260\276\352\270\260/\355\212\270\353\246\254\354\235\230\353\266\200\353\252\250\354\260\276\352\270\260.py" new file mode 100644 index 0000000..43dcadd --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\355\212\270\353\246\254\354\235\230\353\266\200\353\252\250\354\260\276\352\270\260/\355\212\270\353\246\254\354\235\230\353\266\200\353\252\250\354\260\276\352\270\260.py" @@ -0,0 +1,33 @@ +import sys +from collections import deque +def bfs(current): + queue=deque([current]) + # 현재 정점 방문 처리 + visited[current]=True + # 현재 정점과 연결된 정점들 중 아직 방문하지 않은 정점이 있다면 + while queue: + current = queue.popleft() + for next in graph[current]: + if not visited[next]: + visited[next]=True + parent[next]=current + queue.append(next) + +#정점의 개수 +n=int(sys.stdin.readline()) +#그래프 +graph=[[]for _ in range(n+1)] +#해당 정점을 방문했는지 여부 +visited=[False]*(n+1) +#부모 자식 관계 +parent=[0]*(n+1) + +for _ in range(n-1): + a,b=map(int,sys.stdin.readline().split()) + graph[a].append(b) + graph[b].append(a) + +bfs(1) + +for i in range(2,(n+1)): + print(parent[i]) From e1ef6c323911dd090f19947e3f1b6e589d67aaff Mon Sep 17 00:00:00 2001 From: choikang Date: Wed, 21 Jan 2026 22:24:59 +0900 Subject: [PATCH 11/13] =?UTF-8?q?=EB=B0=B1=EC=A4=80=20-=20=EC=97=B0?= =?UTF-8?q?=EA=B5=AC=EC=86=8C=20=EB=AC=B8=EC=A0=9C=20=ED=92=80=EC=9D=B4(01?= =?UTF-8?q?=5F21)=20=20=20=20=20-=20=EC=95=8C=ED=8C=8C=EB=B2=B3=20?= =?UTF-8?q?=EB=AC=B8=EC=A0=9C=20=ED=92=80=EC=9D=B4(01=5F20)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../README.MD" | 3 + .../\354\225\214\355\214\214\353\262\263.py" | 37 +++++ .../\354\227\260\352\265\254\354\206\214.py" | 136 ++++++++++++++++++ .../readme.md" | 112 +++++++++++++++ ...4\354\233\214\353\204\243\352\270\2602.py" | 44 ++++++ 5 files changed, 332 insertions(+) create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/README.MD" create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/\354\225\214\355\214\214\353\262\263.py" create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\227\260\352\265\254\354\206\214/\354\227\260\352\265\254\354\206\214.py" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\2602.py" diff --git "a/src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/README.MD" "b/src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/README.MD" new file mode 100644 index 0000000..133fb83 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/README.MD" @@ -0,0 +1,3 @@ +이 문제에서 얻어갈 부분 문자열을 어떻게 체크해줄 수 있는지 - 아스키코드를 이용해 해당 문자의 아스키코드 인덱스 이용 +백트래킹 문제여도 기저조건은 없을 수 있다는점 기저조건은 단순히 반복문을 돌았을때 조건에 만족안하면 함수가 반환되기만 하면 됨 +시작 조건을 true로 만족하게 하고 시작하는 문제도 있다는 것 유의 diff --git "a/src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/\354\225\214\355\214\214\353\262\263.py" "b/src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/\354\225\214\355\214\214\353\262\263.py" new file mode 100644 index 0000000..8b9bc6b --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/\354\225\214\355\214\214\353\262\263.py" @@ -0,0 +1,37 @@ +import sys + +# r,c 입력받기 +R,C=map(int,sys.stdin.readline().split()) +# board[][] 리스트 +board=[list(sys.stdin.readline().strip()) for _ in range(R)] +# 검증 +# print(" \n".join(map(str,board))) +# 알파벳 visited 배열 선언 26개 +visited=[False]*26 +max_value=-1e9 +# 상하좌우 좌표 +dr=[1,-1,0,0] +dc=[0,0,1,-1] + +def dfs(r,c,count): + global max_value + # 기저조건은 따로 없음 + max_value=max(max_value,count) + # r,c 상하좌우 이동했을때의 경우 + for i in range(4): + nr,nc= r+dr[i],c+dc[i] + # 맵 밖으로 나가면 continue 가지마라 + if not (0<=nr 조합) +# for i in range(start, N * M): +# r = i // M # 행 계산 +# c = i % M # 열 계산 +# +# if board[r][c] == 0: # 빈 칸이라면 +# board[r][c] = 1 # [체크] 벽 세움 (visited = True 역할) +# +# # 다음 재귀 호출 (벽 개수+1, 다음 인덱스 i+1 부터 탐색) +# make_wall(count + 1, i + 1) +# +# board[r][c] = 0 # [해제] 벽 허물기 (visited = False 역할) +# +# # 메인 실행 +# make_wall(0, 0) +# print(max_safe_area) \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260/readme.md" "b/src/\353\260\261\354\244\200/Silver/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260/readme.md" index e69de29..266f99e 100644 --- "a/src/\353\260\261\354\244\200/Silver/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260/readme.md" +++ "b/src/\353\260\261\354\244\200/Silver/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260/readme.md" @@ -0,0 +1,112 @@ +네, 텍스트로만 복사되어 오면서 같은 아래첨자나 같은 특수 기호들이 깨지거나 가독성이 떨어져 보였을 겁니다. + +깔끔하게 **수식(LaTeX)**과 **표**를 적용하여 정리해 드립니다. + +--- + +[문제 링크](https://www.acmicpc.net/problem/14888) + +# 14888번: 연산자 끼워넣기 + +| 시간 제한 | 메모리 제한 | 제출 | 정답 | 맞힌 사람 | 정답 비율 | +| --- | --- | --- | --- | --- | --- | +| 2 초 | 512 MB | 131,936 | 61,879 | 41,321 | 47.431% | + +--- + +## 문제 + +개의 수로 이루어진 수열 이 주어진다. 또, 수와 수 사이에 끼워넣을 수 있는 개의 연산자가 주어진다. 연산자는 덧셈(+), 뺄셈(-), 곱셈(), 나눗셈()으로만 이루어져 있다. + +우리는 수와 수 사이에 연산자를 하나씩 넣어서, 수식을 하나 만들 수 있다. 이때, **주어진 수의 순서를 바꾸면 안 된다.** + +예를 들어, 6개의 수로 이루어진 수열이 `1, 2, 3, 4, 5, 6`이고, 주어진 연산자가 덧셈(+) 2개, 뺄셈(-) 1개, 곱셈() 1개, 나눗셈() 1개인 경우에는 총 60가지의 식을 만들 수 있다. 예를 들어, 아래와 같은 식을 만들 수 있다. + +* +* +* +* + +**식의 계산은 연산자 우선 순위를 무시하고 앞에서부터 진행해야 한다.** 또, 나눗셈은 정수 나눗셈으로 몫만 취한다. + +음수를 양수로 나눌 때는 C++14의 기준을 따른다. 즉, **양수로 바꾼 뒤 몫을 취하고, 그 몫을 음수로 바꾼 것과 같다.** 이에 따라서, 위의 식 4개의 결과를 계산해보면 아래와 같다. + +* +* +* +* + +개의 수와 개의 연산자가 주어졌을 때, 만들 수 있는 식의 결과가 **최대인 것과 최소인 것을 구하는 프로그램**을 작성하시오. + +--- + +## 입력 + +첫째 줄에 수의 개수 $N(2 \le N \le 11)$가 주어진다. 둘째 줄에는 이 주어진다. + +셋째 줄에는 합이 인 4개의 정수가 주어지는데, 차례대로 덧셈(+)의 개수, 뺄셈(-)의 개수, 곱셈()의 개수, 나눗셈()의 개수이다. + +--- + +## 출력 + +첫째 줄에 만들 수 있는 식의 결과의 **최댓값**을, 둘째 줄에는 **최솟값**을 출력한다. + +연산자를 어떻게 끼워넣어도 항상 -10억보다 크거나 같고, 10억보다 작거나 같은 결과가 나오는 입력만 주어진다. 또한, 앞에서부터 계산했을 때, 중간에 계산되는 식의 결과도 항상 -10억보다 크거나 같고, 10억보다 작거나 같다. + +--- + +## 예제 입력 1 + +``` +2 +5 6 +0 0 1 0 + +``` + +## 예제 출력 1 + +``` +30 +30 + +``` + +--- + +## 예제 입력 2 + +``` +3 +3 4 5 +1 0 1 0 + +``` + +## 예제 출력 2 + +``` +35 +17 + +``` + +--- + +## 예제 입력 3 + +``` +6 +1 2 3 4 5 6 +2 1 1 1 + +``` + +## 예제 출력 3 + +``` +54 +-24 + +``` \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\2602.py" "b/src/\353\260\261\354\244\200/Silver/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\2602.py" new file mode 100644 index 0000000..61cc9a1 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\260/\354\227\260\354\202\260\354\236\220\353\201\274\354\233\214\353\204\243\352\270\2602.py" @@ -0,0 +1,44 @@ +import sys + +input=sys.stdin.readline() +n=int(input) +nums=list(map(int,sys.stdin.readline().split())) +op=list(map(int,sys.stdin.readline().split())) +selected_op=[] +min_value=1e9 +max_value=-1e9 + +def dfs(depth): + global min_value,max_value + # 기저조건: 연산자의 개수가 수열의 개수-1이 될 때 + if depth==n-1: + #첫번째 값 정해주기 + total=nums[0] + # 연산자 개수만큼 반복하면서 기저조건의 세계관의 총합 구해주기가 안됨 + # 생각해보니까 nums 기준으로 안해줘도 되네 + for i in range(len(selected_op)): #0,1,2 + # 기호가 플러스라면 + if selected_op[i]==0: + total+=nums[i+1] + elif selected_op[i]==1: + total-=nums[i+1] + elif selected_op[i]==2: + total*=nums[i+1] + elif selected_op[i]==3: + total=int(total/nums[i+1]) + min_value=min(min_value,total) + max_value=max(max_value,total) + return + + #연산자 개수 4만큼 반복 + for i in range(4): + # 각 연산자가 0개가 되지 않을때까지 + if not op[i]==0: + op[i]-=1 + selected_op.append(i) + dfs(depth+1) + selected_op.pop() + op[i]+=1 +dfs(0) +print(max_value) +print(min_value) \ No newline at end of file From cc961463393f2ff2b628d36075760f967eac953d Mon Sep 17 00:00:00 2001 From: choikang Date: Fri, 23 Jan 2026 22:49:07 +0900 Subject: [PATCH 12/13] =?UTF-8?q?=EB=B0=B1=EC=A4=80=20-=20=EB=93=A3?= =?UTF-8?q?=EB=B3=B4=EC=9E=A1=20=EB=AC=B8=EC=A0=9C=20=ED=92=80=EC=9D=B4(01?= =?UTF-8?q?=5F22)=20=20=20=20=20-=20=EC=95=8C=ED=8C=8C=EB=B2=B3=20?= =?UTF-8?q?=EB=AC=B8=EC=A0=9C=20=EB=B3=B5=EC=8A=B5(01=5F23)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../README.MD" | 24 ++++++++ .../\354\225\214\355\214\214\353\262\2632.py" | 23 ++++++++ .../Readme.md" | 0 .../\353\223\243\353\263\264\354\236\241.py" | 59 +++++++++++++++++++ ...54\355\217\254\354\235\270\355\204\260.py" | 39 ++++++++++++ 5 files changed, 145 insertions(+) create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/\354\225\214\355\214\214\353\262\2632.py" create mode 100644 "src/\353\260\261\354\244\200/Gold/\354\227\260\352\265\254\354\206\214/Readme.md" create mode 100644 "src/\353\260\261\354\244\200/Silver/\353\223\243\353\263\264\354\236\241/\353\223\243\353\263\264\354\236\241.py" create mode 100644 "src/\353\260\261\354\244\200/Silver/\353\223\243\353\263\264\354\236\241/\353\223\243\353\263\264\354\236\241\355\210\254\355\217\254\354\235\270\355\204\260.py" diff --git "a/src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/README.MD" "b/src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/README.MD" index 133fb83..e1e74c8 100644 --- "a/src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/README.MD" +++ "b/src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/README.MD" @@ -1,3 +1,27 @@ +https://www.acmicpc.net/problem/1987 + +### 1. 🔍 차이점 비교 + +| 특징 | 연구소 (Laboratory) | 알파벳 (Alphabet) | +| --- | --- | --- | +| **행동** | **점프 가능** (텔레포트) | **한 칸씩 이동** (뚜벅이) | +| **규칙** | (0,0)에 벽 세우고, 바로 (5,5)에 벽 세워도 됨 | (0,0) 다음엔 무조건 (0,1)이나 (1,0)으로 가야 함 | +| **알고리즘** | **조합 (Combination)** | **DFS/BFS (Pathfinding)** | +| **코드** | `for i in range(start, N*M):` | `for i in range(4):` (상하좌우) | + + +### ⚡ 한눈에 보는 비교 + +| 비교 항목 | N과 M (2) | **알파벳 (1987번)** | +| --- | --- | --- | +| **핵심 로직** | **조합 (Combination)** | **경로 탐색 (Pathfinding)** | +| **이동 방향** | ➡️ **오직 전진** (인덱스 증가) | ⬆️⬇️⬅️➡️ **상하좌우** (자유) | +| **중복 제어** | `start` 인덱스가 막아줌 | **`visited` 배열이 막아줌** | +| **비유** | "번호표 순서대로 나오세요." | "왔던 길(알파벳) 다시 밟지 마세요." | + + + +이 문제가 백트래킹과도 연관이 있지만 dfs나 bfs로 풀어야 하는 이유는 0,0의 위치에서 가장 가까운 거리부터 이동해야 되기 때문 이 문제에서 얻어갈 부분 문자열을 어떻게 체크해줄 수 있는지 - 아스키코드를 이용해 해당 문자의 아스키코드 인덱스 이용 백트래킹 문제여도 기저조건은 없을 수 있다는점 기저조건은 단순히 반복문을 돌았을때 조건에 만족안하면 함수가 반환되기만 하면 됨 시작 조건을 true로 만족하게 하고 시작하는 문제도 있다는 것 유의 diff --git "a/src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/\354\225\214\355\214\214\353\262\2632.py" "b/src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/\354\225\214\355\214\214\353\262\2632.py" new file mode 100644 index 0000000..fea80c5 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\354\225\214\355\214\214\353\262\263/\354\225\214\355\214\214\353\262\2632.py" @@ -0,0 +1,23 @@ +import sys +input=sys.stdin.readline +n,m=map(int,input().split()) +board=[list(input().strip())for _ in range(n)] +max_value=-1e9 +visited=[0]*26 + +def dfs(r,c,count): + global max_value + max_value=max(max_value,count) + for dr,dc in [(-1,0),(1,0),(0,-1),(0,1)]: + nr,nc=r+dr,c+dc + if 0<=nr Set으로 저장 (O(N)) +# # 해시 테이블에 저장하므로 나중에 찾을 때 O(1) +# listen = set() +# for _ in range(N): +# listen.add(input().strip()) +# +# # 3. 보도 못한 사람 -> Set으로 저장 (O(M)) +# see = set() +# for _ in range(M): +# see.add(input().strip()) +# +# # 4. 교집합(&) 구하고 사전순 정렬 (O(KlogK)) +# # '&' 연산자가 내부적으로 최적화되어 있어서 매우 빠름 +# result = sorted(list(listen & see)) +# +# # 5. 출력 +# print(len(result)) +# for name in result: +# print(name) \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Silver/\353\223\243\353\263\264\354\236\241/\353\223\243\353\263\264\354\236\241\355\210\254\355\217\254\354\235\270\355\204\260.py" "b/src/\353\260\261\354\244\200/Silver/\353\223\243\353\263\264\354\236\241/\353\223\243\353\263\264\354\236\241\355\210\254\355\217\254\354\235\270\355\204\260.py" new file mode 100644 index 0000000..9ac5ddd --- /dev/null +++ "b/src/\353\260\261\354\244\200/Silver/\353\223\243\353\263\264\354\236\241/\353\223\243\353\263\264\354\236\241\355\210\254\355\217\254\354\235\270\355\204\260.py" @@ -0,0 +1,39 @@ +import sys +input = sys.stdin.readline + +N, M = map(int, input().split()) + +# 1. 리스트로 입력 받기 +listen = [input().strip() for _ in range(N)] +see = [input().strip() for _ in range(M)] + +# 2. 반드시 둘 다 정렬해야 함! (핵심) -> O(NlogN + MlogM) +listen.sort() +see.sort() + +# 3. 투 포인터 탐색 -> O(N + M) +p1, p2 = 0, 0 +result = [] + +while p1 < N and p2 < M: + # Case 1: 두 이름이 같으면? -> 듣보잡 발견! + if listen[p1] == see[p2]: + result.append(listen[p1]) + p1 += 1 + p2 += 1 + + # Case 2: listen 쪽 이름이 사전순으로 더 작으면? + # 예: 'alice' vs 'bob' -> 'alice'는 절대 뒤에 나올 'bob'과 같을 수 없음 + # p1을 뒤로 한 칸 땡겨서 키워줘야 함 + elif listen[p1] < see[p2]: + p1 += 1 + + # Case 3: see 쪽 이름이 더 작으면? + # p2를 뒤로 땡김 + else: # listen[p1] > see[p2] + p2 += 1 + +# 4. 출력 (이미 정렬된 상태에서 찾았으므로 또 정렬할 필요 없음) +print(len(result)) +for name in result: + print(name) \ No newline at end of file From f0e946ac7b11c9ef8e883b1169229983393ba914 Mon Sep 17 00:00:00 2001 From: choikang Date: Mon, 26 Jan 2026 17:04:25 +0900 Subject: [PATCH 13/13] =?UTF-8?q?=EB=B0=B1=EC=A4=80=20-=20=EC=84=AC?= =?UTF-8?q?=EC=9D=98=EA=B0=9C=EC=88=98=20=EB=AC=B8=EC=A0=9C=20=ED=92=80?= =?UTF-8?q?=EC=9D=B4(01=5F26)=20=20=20=20=20-=20A=EC=99=80B2=20=EB=AC=B8?= =?UTF-8?q?=EC=A0=9C=20=ED=92=80=EC=9D=B4(01=5F26)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Gold/A\354\231\200B2/A\354\231\200B2.py" | 54 +++++++++++ .../Gold/A\354\231\200B2/README.MD" | 93 +++++++++++++++++++ .../Readme.md" | 9 ++ .../\355\206\240\353\247\210\355\206\240.py" | 35 +++++++ .../Readme.md" | 76 +++++++++++++++ ...54\354\235\230\352\260\234\354\210\230.py" | 29 ++++++ 6 files changed, 296 insertions(+) create mode 100644 "src/\353\260\261\354\244\200/Gold/A\354\231\200B2/A\354\231\200B2.py" create mode 100644 "src/\353\260\261\354\244\200/Gold/A\354\231\200B2/README.MD" create mode 100644 "src/\353\260\261\354\244\200/Gold/\355\206\240\353\247\210\355\206\240/Readme.md" create mode 100644 "src/\353\260\261\354\244\200/Gold/\355\206\240\353\247\210\355\206\240/\355\206\240\353\247\210\355\206\240.py" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\204\254\354\235\230\352\260\234\354\210\230/Readme.md" create mode 100644 "src/\353\260\261\354\244\200/Silver/\354\204\254\354\235\230\352\260\234\354\210\230/\354\204\254\354\235\230\352\260\234\354\210\230.py" diff --git "a/src/\353\260\261\354\244\200/Gold/A\354\231\200B2/A\354\231\200B2.py" "b/src/\353\260\261\354\244\200/Gold/A\354\231\200B2/A\354\231\200B2.py" new file mode 100644 index 0000000..13d4bde --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/A\354\231\200B2/A\354\231\200B2.py" @@ -0,0 +1,54 @@ +import sys +input=sys.stdin.readline +S=input().strip() +T=input().strip() + +def dfs(T): + if len(T)==len(S): + if T==S: + print(1) + exit() + elif T!=S: + return + if T[-1]=="A": + new_a=T[:-1] + dfs(new_a) + if T[0]=="B": + new_b=T[1:] + new_b=new_b[::-1] + dfs(new_b) + +dfs(T) +print(0) + +# import sys +# input = sys.stdin.readline +# +# S = input().strip() +# T = input().strip() +# +# def dfs(t): +# # 1. 종료 조건: 길이가 같아졌을 때 +# if len(t) == len(S): +# return t == S # 같으면 True, 다르면 False 반환 +# +# # 2. 가지치기 & 재귀 호출 +# +# # Case A: 맨 뒤가 'A'라면 -> 떼고 재귀 +# if t[-1] == 'A': +# if dfs(t[:-1]): # A를 뗀 문자열을 넘김 +# return True +# +# # Case B: 맨 앞이 'B'라면 -> 떼고 뒤집어서 재귀 +# if t[0] == 'B': +# # t[1:] (B 떼기) -> [::-1] (뒤집기) +# if dfs(t[1:][::-1]): +# return True +# +# return False # 둘 다 안 되면 False +# +# # 실행 +# if dfs(T): +# print(1) +# else: +# print(0) \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Gold/A\354\231\200B2/README.MD" "b/src/\353\260\261\354\244\200/Gold/A\354\231\200B2/README.MD" new file mode 100644 index 0000000..eb71daa --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/A\354\231\200B2/README.MD" @@ -0,0 +1,93 @@ +역방향 풀이의 3가지 핵심 신호 +1. 자유도 +정방향: 자유도가 높음 +역방향: 맨 뒤가 A여야만 뗼 수 있음, 그리고 맨 앞이 B여야만 뒤집고 뗄 수 있음 +2. 생성 VS 소멸 +정방향: 만들어가는 과정 -> 생성의 영역 +역방향: 축소하는 과정 -> 소멸의 과정 역추적 +3. 도착하는 곳이 특정 문자열 패턴일때 +숫자 5 -> 100을 만드는 과정은 정해져 있지 않아 오히려 BFS와 같은 최단거리가 적합 +문자열 S->T 구체적인 한가지 방식으로 문자열이 만들어짐 + +### Return 과 exit() 의 차이 +### 문자열 슬라이싱 하는 방법 +### 재귀 함수에서 매개변수 T를 진짜로 자르면 깊이 탐색했다가 돌아와서 예를 들어 dfs(3)의 길이가 3부터 시작해야 되는데 T를 진짜로 건들면 줄어든 T로 탐색하기 때문에 오류남 + + +--- + +# [Gold V] A와 B 2 - 12919 + +[문제 링크](https://www.acmicpc.net/problem/12919) + +### 성능 요약 + +메모리: 512 MB, 시간: 2 초 + +### 분류 + +문자열, 브루트포스 알고리즘, 재귀, 백트래킹 + +### 문제 설명 + +수빈이는 A와 B로만 이루어진 영어 단어가 존재한다는 사실에 놀라움을 금치 못하고 있다. 수빈이는 지금까지 많은 단어를 만들었는데, 그것을 모두 외우기는 너무 어렵기 때문에, 단어를 만들 때 감으로 만들려고 한다. 수빈이는 알파벳 A와 B로만 이루어진 단어 S를 주어졌을 때, 이 단어를 알파벳 A와 B로만 이루어진 단어 T로 바꿀 수 있는지 궁금해졌다. + +S를 T로 바꾸는 게임은 다음과 같은 두 가지 연산만 가능하다. + +1. 문자열의 뒤에 A를 추가한다. +2. 문자열의 뒤에 B를 추가하고 문자열을 뒤집는다. + +주어진 조건을 이용해서 S를 T로 만들 수 있는지 없는지 알아내는 프로그램을 작성하시오. + +### 입력 + +첫째 줄에 S가 둘째 줄에 T가 주어진다. (1 ≤ S의 길이 ≤ 49, 2 ≤ T의 길이 ≤ 50, S의 길이 < T의 길이) + +### 출력 + +S를 T로 바꿀 수 있으면 1을, 없으면 0을 출력한다. + +### 예제 입력 1 + +```text +A +BABA + +``` + +### 예제 출력 1 + +```text +1 + +``` + +### 예제 입력 2 + +```text +BAAAAABAA +BAABAAAAAB + +``` + +### 예제 출력 2 + +```text +1 + +``` + +### 예제 입력 3 + +```text +A +ABBA + +``` + +### 예제 출력 3 + +```text +0 + +``` \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Gold/\355\206\240\353\247\210\355\206\240/Readme.md" "b/src/\353\260\261\354\244\200/Gold/\355\206\240\353\247\210\355\206\240/Readme.md" new file mode 100644 index 0000000..77bd010 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\355\206\240\353\247\210\355\206\240/Readme.md" @@ -0,0 +1,9 @@ +토마토 익는게 bfs로 큐에 있는걸 다 빼는게 최소 일수를 보장해주는 이유 +1일차 그룹이 끝나고 -> 2일차 그룹이 전파 되는식 +큐를 이용하면 진짜 동시는 아니지만 하루에 전파되는건 동시에 처리 되는것처럼 흉내내는게 가능 예를 들어 +[A,B]라고 하면 +A즉 익은 토마토 주위 토마토를 익혔다고 치면 +[B,a1,a2] +그 다음 b 토마토 +[a1,a2,b1,b2,b3] +와 같이 1일차 A,B가 동시에 끝나고 다음으로 퍼진 토마토들이 이어서 퍼지게 됨 \ No newline at end of file diff --git "a/src/\353\260\261\354\244\200/Gold/\355\206\240\353\247\210\355\206\240/\355\206\240\353\247\210\355\206\240.py" "b/src/\353\260\261\354\244\200/Gold/\355\206\240\353\247\210\355\206\240/\355\206\240\353\247\210\355\206\240.py" new file mode 100644 index 0000000..048d489 --- /dev/null +++ "b/src/\353\260\261\354\244\200/Gold/\355\206\240\353\247\210\355\206\240/\355\206\240\353\247\210\355\206\240.py" @@ -0,0 +1,35 @@ +import sys +from collections import deque +input=sys.stdin.readline +m,n,h=map(int,input().split()) # 가로,세로,높이 +box=[[list(map(int,input().split())) for _ in range(n)] for _ in range(h)] +max_day=0 +q=deque() + +for i in range(h): + for j in range(n): + for k in range(m): + if box[i][j][k]==1: + q.append((i,j,k)) + +def bfs(): + global min_day + while q: + qh,qr,qc=q.popleft() + for dh,dr,dc in [[1,0,0],[-1,0,0],[0,1,0],[0,-1,0],[0,0,1],[0,0,-1]]: + nh,nr,nc=qh+dh,qr+dr,qc+dc + if 0<=nh