s; // 괄호 저장하는 스택
+
+ for(int i = 0; i < input.length(); i++) {
+ char ch = input[i];
+ switch(ch) {
+ case '(': case '[': // 여는 괄호는 무조건 push
+ s.push(ch);
+ break;
+ case ')': // 닫는 소괄호
+ if(s.empty() || s.top() != '(') {
+ return false;
+ }
+ s.pop();
+ break;
+ case ']': // 닫는 대괄호
+ if(s.empty() || s.top() != '[') {
+ return false;
+ }
+ s.pop();
+ break;
+ }
+ }
+ return s.empty();
+}
+
+/*
+ * [괄호 균형 확인하기]
+ * 1. 여는 괄호는 바로 스택에 넣는다.
+ * 2. 닫는 괄호가 나오면 가장 최근에 넣었던 여는 괄호와 비교한다.
+ * 2-1. 닫는 괄호와 여는 괄호의 종류가 같다면 해당 닫는 괄호가 균형을 이룬다.
+ * 2-2. 직전에 나온 여는 괄호가 없거나 그 종류가 다르다면 해당 닫는 괄호가 균형을 이루지 못한다.
+ * 3. 모든 닫는 괄호가 여는 괄호와 짝을 이루었더라도 스택에 여는 괄호가 남아있다면 균형을 이루지 못한다.
+*/
+
+
+int main() {
+ string input;
+
+ while(true) {
+ // 입력
+ getline(cin, input);
+ if(input == ".") {
+ break;
+ }
+
+ // 연산 & 출력
+ if(isBalanced(input)) {
+ cout << "yes\n";
+ }
+ else {
+ cout << "no\n";
+ }
+ }
+ return 0;
+}
\ No newline at end of file
diff --git "a/02_\354\212\244\355\203\235, \355\201\220, \353\215\261/\355\225\204\354\210\230/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/02_\354\212\244\355\203\235, \355\201\220, \353\215\261/\355\225\204\354\210\230/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/03_\354\240\225\354\210\230\353\241\240/README.md" "b/03_\354\240\225\354\210\230\353\241\240/README.md"
index e69de29b..e88e26f4 100644
--- "a/03_\354\240\225\354\210\230\353\241\240/README.md"
+++ "b/03_\354\240\225\354\210\230\353\241\240/README.md"
@@ -0,0 +1,77 @@
+# 정수론 (Number Theory)
+
+[메인으로 돌아가기](https://github.com/Altu-Bitu-Official/Altu-Bitu-4)
+
+## 💻 튜터링
+
+### 라이브 코딩
+
+| 문제 번호 | 문제 이름 | 난이도 | 풀이 링크 | 분류 |
+| :-----------------------------------------------------------------------: | :----------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------: | :----------: | :-----------------: |
+| 2609 | 최대공약수와 최소공배수 | 
| [바로가기](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/03_%EC%A0%95%EC%88%98%EB%A1%A0/%EB%9D%BC%EC%9D%B4%EB%B8%8C%20%EC%BD%94%EB%94%A9/2609.cpp) | 유클리드 호제법 |
+| 2960 | 에라토스테네스의 체 | 
| [바로가기](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/03_%EC%A0%95%EC%88%98%EB%A1%A0/%EB%9D%BC%EC%9D%B4%EB%B8%8C%20%EC%BD%94%EB%94%A9/2960.cpp) | 에라토스테네스의 체 |
+| 16563 | 어려운 소인수분해 | 
| [바로가기](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/03_%EC%A0%95%EC%88%98%EB%A1%A0/%EB%9D%BC%EC%9D%B4%EB%B8%8C%20%EC%BD%94%EB%94%A9/16563.cpp) | 에라토스테네스의 체 |
+
+## ✏️ 과제
+
+### 마감기한
+
+~ 3 / 7 (화) 18:59 - 과제 제출
+~ 3 / 9 (목) 23:59 - 추가 제출
+
+### 필수
+
+| 문제 번호 | 문제 이름 | 난이도 | 풀이 링크 | 분류 |
+| :---------------------------------------------------------------------: | :--------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------: | :-------: | :-----------------: |
+| 2840 | 행운의 바퀴 | | [C++_v1](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/03_%EC%A0%95%EC%88%98%EB%A1%A0/%ED%95%84%EC%88%98/2840_v1.cpp)[C++_v2](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/03_%EC%A0%95%EC%88%98%EB%A1%A0/%ED%95%84%EC%88%98/2840_v2.cpp) | 구현, 시뮬레이션 |
+| 6588 | 골드바흐의 추측 | 
| [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/03_%EC%A0%95%EC%88%98%EB%A1%A0/%ED%95%84%EC%88%98/6588.cpp) | 에라토스테네스의 체 |
+| 1735 | 분수 합 | 
| [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/03_%EC%A0%95%EC%88%98%EB%A1%A0/%ED%95%84%EC%88%98/1735.cpp) | 유클리드 호제법 |
+
+### 도전
+
+| 문제 번호 | 문제 이름 | 난이도 | 풀이 링크 | 분류 |
+| :---------------------------------------------------------------------: | :---------------------------------------------------------------------------: | :--------------------------------------------------------------------------------: | :-------: | :----------------------------: |
+| 9421 | 소수상근수 | | [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/03_%EC%A0%95%EC%88%98%EB%A1%A0/%EB%8F%84%EC%A0%84/9421.cpp) | 에라토스테네스의 체, 소수 판정 |
+| 2981 | 검문 | | [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/03_%EC%A0%95%EC%88%98%EB%A1%A0/%EB%8F%84%EC%A0%84/2981.cpp) | 유클리드 호제법 |
+
+---
+
+### 힌트
+
+
+행운의 바퀴
+
+ 바퀴를 배열로 고정시키고, 화살표를 움직인다면 화살표는 배열의 왼쪽 방향으로 이동하겠죠? 바퀴를 돌리는 횟수가 매우 클 수도 있으니 인덱스가 음수가 되지 않도록 유의해야 해요.
+
+
+
+
+골드바흐의 추측
+
+ b - a가 가장 큰 경우가 언제일지 잘 생각해보아요! n = a + b를 만족시키는 두 소수들을 어디서부터 탐색하면 좋을까요?
+
+
+
+
+분수 합
+
+ 기약분수는 분모와 분자가 더 이상 약분되지 않는 분수를 말하죠! 어렵게 생각하지 말고 차근차근 두 분수를 더하고 약분해줍시다.
+
+
+
+
+소수상근수
+
+ 소수를 찾았다면 상근수인지 판단하면 되겠네요. 문제에서 주어진 그대로 구현해볼까요? 각 자릿수의 제곱의 합을 구할 때, 언제 그만둬야 할지 잘 생각해봐야겠어요.
+
+
+
+
+
+검문
+
+ 입력으로 주어진 모든 수에 대하여 나눴을 때 나머지가 모두 같게 하는 M을 보다 효율적으로 판단해주려면 어떻게 해야 할까요? 접근이 어렵다면 각 수를 몫과 나머지로 나타내보면 좋을 것 같아요.
+
+
+
+---
diff --git "a/03_\354\240\225\354\210\230\353\241\240/\352\260\225\354\235\230 \354\236\220\353\243\214/03_\354\240\225\354\210\230\353\241\240_\353\254\270\354\240\234\355\225\264\354\204\244.pdf" "b/03_\354\240\225\354\210\230\353\241\240/\352\260\225\354\235\230 \354\236\220\353\243\214/03_\354\240\225\354\210\230\353\241\240_\353\254\270\354\240\234\355\225\264\354\204\244.pdf"
new file mode 100644
index 00000000..d2858f91
Binary files /dev/null and "b/03_\354\240\225\354\210\230\353\241\240/\352\260\225\354\235\230 \354\236\220\353\243\214/03_\354\240\225\354\210\230\353\241\240_\353\254\270\354\240\234\355\225\264\354\204\244.pdf" differ
diff --git "a/03_\354\240\225\354\210\230\353\241\240/\352\260\225\354\235\230 \354\236\220\353\243\214/03_\354\240\225\354\210\230\353\241\240_\354\235\264\353\241\240.pdf" "b/03_\354\240\225\354\210\230\353\241\240/\352\260\225\354\235\230 \354\236\220\353\243\214/03_\354\240\225\354\210\230\353\241\240_\354\235\264\353\241\240.pdf"
new file mode 100644
index 00000000..aca45450
Binary files /dev/null and "b/03_\354\240\225\354\210\230\353\241\240/\352\260\225\354\235\230 \354\236\220\353\243\214/03_\354\240\225\354\210\230\353\241\240_\354\235\264\353\241\240.pdf" differ
diff --git "a/03_\354\240\225\354\210\230\353\241\240/\352\260\225\354\235\230 \354\236\220\353\243\214/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/03_\354\240\225\354\210\230\353\241\240/\352\260\225\354\235\230 \354\236\220\353\243\214/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/03_\354\240\225\354\210\230\353\241\240/\353\217\204\354\240\204/2981.cpp" "b/03_\354\240\225\354\210\230\353\241\240/\353\217\204\354\240\204/2981.cpp"
new file mode 100644
index 00000000..5d1912b8
--- /dev/null
+++ "b/03_\354\240\225\354\210\230\353\241\240/\353\217\204\354\240\204/2981.cpp"
@@ -0,0 +1,66 @@
+#include
+#include
+#include // sort() 이용
+
+using namespace std;
+
+// 최대공약수(GCD) 계산 함수: 유클리드 호제법 이용
+int getGCD(int a, int b) {
+ if (b == 0) {
+ return a;
+ }
+ return getGCD(b, a % b);
+}
+
+// 가능한 M 검색 함수
+vector solution(int n, vector &numbers) {
+ vector result; //가능한 M 저장
+
+ // 1. 검문소 사이 간격의 최대공약수(최대 M) 계산
+ int gcd = numbers[1] - numbers[0];
+ for (int i = 2; i < n; i++) {
+ gcd = getGCD(gcd, numbers[i] - numbers[i - 1]);
+ }
+
+ // 2. 가능한 모든 M 찾기: 최대공약수의 약수 찾기
+ for (int i = 2; i * 2 <= gcd; i++) {
+ if (gcd % i == 0) {
+ result.push_back(i);
+ }
+ }
+ result.push_back(gcd);
+
+ return result;
+}
+
+/* [백준 2981: 검문]
+ * A, B, C를 M으로 나눴을 때의 나머지가 모두 같을 때, 이 나머지 값을 K라 하면
+ * A = M * a + K, B = M * b + K, C = M * c + K 이므로
+ * B - A = (M * b + K) - (M * a + K) = M(b - a)
+ * C - B = (M * c + K) - (M * b + K) = M(c - b)
+ * 즉, 우리가 구해야 하는 M은 각 검문소 사이 간격 간의 모든 공약수!
+ *
+ * 1. 검문소 사이 간격 간의 최대공약수 구하기
+ * 2. 1에서 구한 최대공약수의 모든 약수 구하기
+ * (모든 약수를 구할 때 시간초과 주의!)
+ */
+
+int main() {
+ // 입력
+ int n;
+ cin >> n;
+ vector numbers(n);
+ for (int i = 0; i < n; i++) {
+ cin >> numbers[i];
+ }
+
+ // 연산
+ sort(numbers.begin(), numbers.end());
+ vector result = solution(n, numbers);
+
+ // 출력
+ for (int i : result) {
+ cout << i << " ";
+ }
+ return 0;
+}
\ No newline at end of file
diff --git "a/03_\354\240\225\354\210\230\353\241\240/\353\217\204\354\240\204/9421.cpp" "b/03_\354\240\225\354\210\230\353\241\240/\353\217\204\354\240\204/9421.cpp"
new file mode 100644
index 00000000..68e78e52
--- /dev/null
+++ "b/03_\354\240\225\354\210\230\353\241\240/\353\217\204\354\240\204/9421.cpp"
@@ -0,0 +1,81 @@
+#include
+#include
+#include
+
+using namespace std;
+
+// 각 자리수의 제곱의 합 계산 함수
+int getSum(int n) {
+ int total = 0, tmp;
+ while (n != 0) {
+ tmp = n % 10;
+ n /= 10;
+ total += tmp * tmp;
+ }
+ return total;
+}
+// 소수 여부 반환 함수: 에라토스테네스의 체 이용
+vector getPrimes(int n) {
+ vector is_prime(n+1, true);
+ is_prime[0] = is_prime[1] = false;
+ for (int i = 2; i * i <= n; i++) {
+ if (!is_prime[i]) {
+ continue;
+ }
+ for (int j = i * i; j <= n; j += i) {
+ is_prime[j] = false;
+ }
+ }
+ return is_prime;
+}
+// 소수상근수 여부 반환 함수
+bool is_valid(int n) {
+ set visited;
+ visited.insert(n);
+ while(1) {
+ n = getSum(n);
+ if (n == 1) {
+ return true;
+ }
+ if (visited.find(n) != visited.end()) {
+ return false;
+ }
+ visited.insert(n);
+ }
+}
+
+// n보다 작거나 같은 소수상근수 벡터 반환
+vector solution(int n) {
+ vector is_prime = getPrimes(n);
+ vector result;
+ for (int i = 2; i <= n; i++) {
+ if (is_prime[i] && is_valid(i)) {
+ result.push_back(i);
+ }
+ }
+ return result;
+}
+
+/* [백준 9421: 소수상근수]
+ * 상근수는 각 자리수의 제곱의 합을 재귀적으로 계산했을 때 1이 되는 수이다.
+ * 즉, 각 자리수의 제곱의 합을 재귀적으로 계산했을 때
+ * 이전에 나왔던 값이 다시 나온다면 그 수는 상근수가 될 수 없다.
+ * 1. n보다 작거나 같은 모든 소수를 찾는다.
+ * 2. n보다 작거나 같은 소수들이 상근수인지 판단한다.
+ * 3. 소수이면서 상근수이면 결과값으로 추가한다.
+ */
+
+int main() {
+ // 입력
+ int n;
+ cin >> n;
+
+ // 연산
+ vector result = solution(n);
+
+ // 출력
+ for (int num : result) {
+ cout << num << "\n";
+ }
+ return 0;
+}
diff --git "a/03_\354\240\225\354\210\230\353\241\240/\353\217\204\354\240\204/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/03_\354\240\225\354\210\230\353\241\240/\353\217\204\354\240\204/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/03_\354\240\225\354\210\230\353\241\240/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/16563.cpp" "b/03_\354\240\225\354\210\230\353\241\240/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/16563.cpp"
new file mode 100644
index 00000000..9adb3b4e
--- /dev/null
+++ "b/03_\354\240\225\354\210\230\353\241\240/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/16563.cpp"
@@ -0,0 +1,61 @@
+#include
+#include
+
+const int MAX = 5000000; //k의 최대 범위
+using namespace std;
+
+vector getPrimes() {
+ vector primes(MAX + 1, 0);
+ for(int i = 2; i * i <= MAX; i++) {
+ if(primes[i] != 0) { //소수가 아니면 탐색 X
+ continue;
+ }
+
+ //j의 가장 작은 소인수는 i
+ for(int j = i * i; j <= MAX; j += i) {
+ if (primes[j] == 0) {
+ primes[j] = i;
+ }
+ }
+ }
+ return primes;
+}
+vector getPrimeFactors(int k, vector &primes) {
+ vector factors; //소인수 저장
+
+ while(primes[k] != 0) { //k가 소수가 될 때까지
+ factors.push_back(primes[k]);
+ k /= primes[k];
+ }
+ factors.push_back(k);
+ return factors;
+}
+int main() {
+ //입출력 속도 향상
+ ios::sync_with_stdio(false);
+ cin.tie(NULL);
+ cout.tie(NULL);
+
+ //입력
+ int n, k;
+ cin>>n;
+
+ //소수 경로 구하기
+ vector primes = getPrimes();
+
+ //n개의 케이스 입력
+ while (n--) {
+ cin >> k;
+
+ //소인수분해
+ vector factors = getPrimeFactors(k, primes);
+
+ //출력
+ for (int num : factors) {
+ cout << num << " ";
+ }
+ cout << "\n";
+ }
+
+ return 0;
+}
\ No newline at end of file
diff --git "a/03_\354\240\225\354\210\230\353\241\240/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/2609.cpp" "b/03_\354\240\225\354\210\230\353\241\240/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/2609.cpp"
new file mode 100644
index 00000000..c276e8a8
--- /dev/null
+++ "b/03_\354\240\225\354\210\230\353\241\240/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/2609.cpp"
@@ -0,0 +1,49 @@
+#include
+#include
+
+using namespace std;
+
+//O(n)으로 최대공약수(gcd) 구하기
+int getGcdBad(int a, int b) {
+ for (int i = min(a, b); i > 0; i--) {
+ //i가 a의 약수이자 b의 약수이면 -> i는 공약수
+ if (a % i == 0 && b % i == 0) {
+ return i;
+ }
+ }
+ return 1;
+}
+
+//재귀 이용하여 최대공약수(gcd) 구하기
+int getGcdRecur(int a, int b) {
+ if (b == 0) {
+ return a;
+ }
+ return getGcdRecur(b, a%b);
+}
+
+//반복문 이용하여 최대공약수(gcd) 구하기
+int getGcdIter(int a, int b) {
+ int tmp;
+ while (b != 0) {
+ tmp = a % b;
+ a = b;
+ b = tmp;
+ }
+ return a;
+}
+
+int main() {
+ //입력
+ int a, b;
+ cin >> a >> b;
+
+ //최대공약수
+ int gcd = getGcdRecur(max(a, b), min(a, b));
+ //최소공배수
+ int lcm = a * b / gcd;
+
+ //출력
+ cout << gcd << "\n" << lcm;
+ return 0;
+}
\ No newline at end of file
diff --git "a/03_\354\240\225\354\210\230\353\241\240/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/2960.cpp" "b/03_\354\240\225\354\210\230\353\241\240/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/2960.cpp"
new file mode 100644
index 00000000..51687a6b
--- /dev/null
+++ "b/03_\354\240\225\354\210\230\353\241\240/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/2960.cpp"
@@ -0,0 +1,36 @@
+#include
+#include
+
+using namespace std;
+
+int findPrime(int n, int k) {
+ vector is_prime(n + 1, true); //소수 여부 저장
+ int cnt = 0; //현재 지워진 수의 개수 저장
+
+ for (int i = 2; i <= n; i++) {
+ if (!is_prime[i]) { //이미 지워진 수이면 탐색 X
+ continue;
+ }
+ for (int j = i; j <= n; j += i) {
+ if (!is_prime[j]) { //이미 지워진 수이면 탐색 X
+ continue;
+ }
+ if ((++cnt) == k) {
+ //지금 지워지는 수가 k번째 지워지는 수이면 현재 수 반환
+ return j;
+ }
+ is_prime[j] = false; //현재 수 지우기
+ }
+ }
+ return -1;
+}
+int main() {
+ //입력
+ int n, k, cnt = 0;
+ cin >> n >> k;
+
+ //출력
+ cout << findPrime(n, k);
+
+ return 0;
+}
\ No newline at end of file
diff --git "a/03_\354\240\225\354\210\230\353\241\240/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/03_\354\240\225\354\210\230\353\241\240/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/03_\354\240\225\354\210\230\353\241\240/\355\225\204\354\210\230/1735.cpp" "b/03_\354\240\225\354\210\230\353\241\240/\355\225\204\354\210\230/1735.cpp"
new file mode 100644
index 00000000..beb65fe9
--- /dev/null
+++ "b/03_\354\240\225\354\210\230\353\241\240/\355\225\204\354\210\230/1735.cpp"
@@ -0,0 +1,35 @@
+#include
+
+using namespace std;
+
+// 최대공약수(GCD) 계산 함수: 유클리드 호제법 이용
+int getGCD(int a, int b) {
+ if (b == 0) return a;
+ return getGCD(b, a % b);
+}
+
+/* [백준 1735: 분수 합]
+ * a/b + c/d = (a*d)/(b*d) + (b*c)/(b*d) = (a*d + b*c)/(b*d)
+ * 위 분수를 기약분수로 나타낸 것을 x/y라 하고,
+ * gcd를 (a*d + b*c)와 (b*d)의 최대공약수라 하면
+ * x = (a*d + b*c) / gcd
+ * y = (b*d) / gcd
+*/
+
+int main() {
+ // 입력
+ int a, b, c, d;
+ cin >> a >> b >> c >> d;
+
+ // 연산
+ int x = (a * d) + (b * c); // 분자
+ int y = b * d; // 분모
+ int gcd = getGCD(x, y);
+ x = x / gcd; // 기약분수의 분자
+ y = y / gcd; // 기약분수의 분모
+
+ // 출력
+ cout << x << " " << y;
+
+ return 0;
+}
diff --git "a/03_\354\240\225\354\210\230\353\241\240/\355\225\204\354\210\230/2840_v1.cpp" "b/03_\354\240\225\354\210\230\353\241\240/\355\225\204\354\210\230/2840_v1.cpp"
new file mode 100644
index 00000000..59d34724
--- /dev/null
+++ "b/03_\354\240\225\354\210\230\353\241\240/\355\225\204\354\210\230/2840_v1.cpp"
@@ -0,0 +1,76 @@
+#include
+#include
+
+using namespace std;
+
+typedef pair ci;
+const int ALPHA = 26;
+
+/*
+ [2840 행운의 바퀴 ver1]
+ - 문제에서 주어진대로 화살표를 고정시키고, 바퀴를 시계방향으로 돌려서 문제를 푼다.
+ - 배열을 ?로 초기화 해주고, 입력한대로 처리한다
+ - 바퀴를 배열로 보고 시계방향으로 바퀴를 회전시키면, 화살표가 가리키고 있는 배열의 원소는 인덱스가 감소하는 것처럼
+ 보인다.
+ <주의 사항>
+ 1. ?이 아닌 문자가 저장되어있는데, 다른 문자를 저장하려는 경우
+ 2. 룰렛에 중복되는 문자가 있는 경우
+ ** 바퀴를 돌리는 횟수가 매우 클 수도 있다. 이 부분을 유의하여 인덱스를 처리하자!
+ ex) n=3 인데, 바퀴를 10번 돌릴수도 있다.
+*/
+
+// 특정 화살표에서 시작한 행운의 바퀴 리턴
+string arrowStartWheel(int index, int n, vector &wheel) {
+ string ans = "";
+
+ for (int i = 0; i < n; i++) {
+ ans += wheel[(i + index) % n];
+ }
+
+ return ans;
+}
+
+string makeWheel(int n, vector &record) {
+ vector wheel(n, '?'); //?로 초기화
+ vector is_available(ALPHA, false); // 알파벳 중복 체크
+
+ int index = 0; // 화살표가 가리키는 인덱스
+
+ for (int i = 0; i < record.size(); i++) {
+ int rot = record[i].first;
+ int ch = record[i].second;
+
+ index = (index - rot + 100 * n) % n;
+
+ if (wheel[index] == ch) {
+ continue;
+ }
+
+ // 주의사항 체크
+ // 원판의 해당 위치에 다른 문자가 저장되어있거나, 이미 다른 곳에 문자가 사용된 경우
+ if (wheel[index] != '?' || is_available[ch - 'A']) {
+ return "!";
+ }
+
+ wheel[index] = ch; // 원판에 기록
+ is_available[ch - 'A'] = true; // 알파벳 사용을 표시
+ }
+
+ return arrowStartWheel(index, n, wheel);
+}
+
+int main() {
+ // 입력
+ int n, k;
+ cin >> n >> k;
+
+ vector record(k, {0, 0}); // 바퀴 회전 기록
+ for (int i = 0; i < k; i++) {
+ cin >> record[i].first >> record[i].second;
+ }
+
+ // 출력
+ cout << makeWheel(n, record);
+
+ return 0;
+}
\ No newline at end of file
diff --git "a/03_\354\240\225\354\210\230\353\241\240/\355\225\204\354\210\230/2840_v2.cpp" "b/03_\354\240\225\354\210\230\353\241\240/\355\225\204\354\210\230/2840_v2.cpp"
new file mode 100644
index 00000000..1563d2a0
--- /dev/null
+++ "b/03_\354\240\225\354\210\230\353\241\240/\355\225\204\354\210\230/2840_v2.cpp"
@@ -0,0 +1,73 @@
+#include
+#include
+
+using namespace std;
+
+typedef pair ci;
+const int ALPHA = 26;
+
+/*
+ [2840 행운의 바퀴 ver2]
+ - 화살표를 이동시키는 방식으로 문제를 푼다.
+ - 이후 출력시 방향을 바꾸어 출력한다.
+ - 배열을 ?로 초기화 해주고, 입력대로 처리한다
+ <주의 사항>
+ 1. ?이 아닌 문자가 저장되어있는데, 다른 문자를 저장하려는 경우
+ 2. 룰렛에 중복되는 문자가 있는 경우
+*/
+
+// 특정 화살표에서 시작한 행운의 바퀴 리턴
+string arrowStartWheel(int index, int n, vector &wheel) {
+ string ans = "";
+
+ for (int i = n; i > 0; i--) {
+ ans += wheel[(i + index) % n];
+ }
+
+ return ans;
+}
+
+string makeWheel(int n, vector &record) {
+ vector wheel(n, '?'); //?로 초기화
+ vector is_available(ALPHA, false); // 알파벳 중복 체크
+
+ int index = 0; // 화살표가 가리키는 인덱스
+
+ for (int i = 0; i < record.size(); i++) {
+ int rot = record[i].first;
+ int ch = record[i].second;
+
+ index = (index + rot) % n; // 화살표 이동
+
+ if (wheel[index] == ch) {
+ continue;
+ }
+
+ // 주의사항 체크
+ // 다른 문자가 저장되어있거나, 이미 다른 곳에 문자가 사용된 경우
+ if (wheel[index] != '?' || is_available[ch - 'A']) {
+ return "!";
+ }
+
+ wheel[index] = ch; // 원판에 기록
+ is_available[ch - 'A'] = true; // 알파벳 사용을 표시
+ }
+
+ return arrowStartWheel(index, n, wheel);
+}
+
+int main() {
+ // 입력
+ int n, k;
+ cin >> n >> k;
+
+ vector record(k, {0, 0}); // 바퀴 회전 기록
+ for (int i = 0; i < k; i++) {
+ cin >> record[i].first >> record[i].second;
+ }
+
+ // 출력
+ cout << makeWheel(n, record);
+
+ return 0;
+}
diff --git "a/03_\354\240\225\354\210\230\353\241\240/\355\225\204\354\210\230/6588.cpp" "b/03_\354\240\225\354\210\230\353\241\240/\355\225\204\354\210\230/6588.cpp"
new file mode 100644
index 00000000..fb7c19b2
--- /dev/null
+++ "b/03_\354\240\225\354\210\230\353\241\240/\355\225\204\354\210\230/6588.cpp"
@@ -0,0 +1,68 @@
+#include
+#include
+#include
+
+using namespace std;
+
+// 소수 여부 반환 함수: 에라토스테네스의 체 이용
+vector getPrimes(int n) {
+ vector is_prime(n + 1, true);
+ is_prime[0] = is_prime[1] = false;
+ for (int i = 2; i * i <= n; i++) {
+ if (!is_prime[i]) {
+ continue;
+ }
+ for (int j = i * i; j <= n; j += i) {
+ is_prime[j] = false;
+ }
+ }
+ return is_prime;
+}
+
+// n = a + b를 만족시키는 a 반환
+int goldbach(int n, vector &is_prime) {
+ for (int a = 3; a <= n / 2; a+= 2) {
+ // 2보다 큰 짝수 소수는 존재하지 않으므로
+ // a = 3부터 탐색해도 a와 b 모두 홀수여야 한다는 조건 만족
+ if (is_prime[a] && is_prime[n - a]) {
+ return a;
+ }
+ }
+ // n = a + b를 만족시키는 홀수 소수 a, b가 없으면 0 반환
+ return 0;
+}
+
+/* [백준 6588: 골드바흐의 추측]
+ * 1. 3보다 크거나 같고 n / 2보다 작거나 같은 소수 a를 오름차순으로 탐색한다.
+ * 2. 1에서 찾은 a에 대하여 n - a(=b)도 소수이면 골드바흐의 추측이 성립한다.
+ * 3. 골드바흐의 추측이 성립하면 a를, 성립하지 않으면 0을 반환한다.
+ */
+
+int main() {
+ // 입력
+ vector arr;
+ int input;
+ while(1) {
+ cin >> input;
+ if (input == 0) {
+ break;
+ }
+ arr.push_back(input);
+ }
+
+ // 연산
+ int max_num = *max_element(arr.begin(), arr.end());
+ vector is_prime = getPrimes(max_num);
+
+ for (int i = 0; i < arr.size(); i++) {
+ int a = goldbach(arr[i], is_prime);
+
+ // 출력
+ if (a != 0) { // n = a + b를 만족하는 a, b가 존재하면
+ cout << arr[i] << " = " << a << " + " << arr[i] - a << "\n";
+ } else { // 존재하지 않으면
+ cout << "Goldbach's conjecture is wrong.\n";
+ }
+ }
+ return 0;
+}
diff --git "a/03_\354\240\225\354\210\230\353\241\240/\355\225\204\354\210\230/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/03_\354\240\225\354\210\230\353\241\240/\355\225\204\354\210\230/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/README.md" "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/README.md"
index e69de29b..207c4c26 100644
--- "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/README.md"
+++ "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/README.md"
@@ -0,0 +1,77 @@
+# 브루트 포스 (Brute Force)
+
+[메인으로 돌아가기](https://github.com/Altu-Bitu-Official/Altu-Bitu-4)
+
+## 💻 튜터링
+
+### 라이브 코딩
+
+| 문제 번호 | 문제 이름 | 난이도 | 풀이 링크 | 분류 |
+| :---------------------------------------------------------------------: | :----------------------------------------------------------------------------: | :-------------------------------------------------------------------------------: | :----------: | :---------------: |
+| 2309 | 일곱 난쟁이 | | [바로가기](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/04_%EB%B8%8C%EB%A3%A8%ED%8A%B8%20%ED%8F%AC%EC%8A%A4/%EB%9D%BC%EC%9D%B4%EB%B8%8C%20%EC%BD%94%EB%94%A9/2309.cpp) | 브루트 포스, 정렬 |
+| 2231 | 분해합 | 
| [바로가기](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/04_%EB%B8%8C%EB%A3%A8%ED%8A%B8%20%ED%8F%AC%EC%8A%A4/%EB%9D%BC%EC%9D%B4%EB%B8%8C%20%EC%BD%94%EB%94%A9/2231.cpp) | 브루트 포스 |
+
+## ✏️ 과제
+
+### 마감기한
+
+~ 3 / 14 (화) 18:59 - 과제 제출
+~ 3 / 16 (목) 23:59 - 추가 제출
+
+### 필수
+
+| 문제 번호 | 문제 이름 | 난이도 | 풀이 링크 | 분류 |
+| :---------------------------------------------------------------------: | :----------------------------------------------------------------------------: | :-------------------------------------------------------------------------------: | :-------: | :--------------: |
+| 1063 | 킹 | | [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/04_%EB%B8%8C%EB%A3%A8%ED%8A%B8%20%ED%8F%AC%EC%8A%A4/%ED%95%84%EC%88%98/1063.cpp) | 구현, 시뮬레이션 |
+| 1436 | 영화감독 숌 | 
| [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/04_%EB%B8%8C%EB%A3%A8%ED%8A%B8%20%ED%8F%AC%EC%8A%A4/%ED%95%84%EC%88%98/1436.cpp) | 브루트 포스 |
+| 1065 | 한수 | | [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/04_%EB%B8%8C%EB%A3%A8%ED%8A%B8%20%ED%8F%AC%EC%8A%A4/%ED%95%84%EC%88%98/1065.cpp) | 브루트 포스 |
+
+### 도전
+
+| 문제 번호 | 문제 이름 | 난이도 | 풀이 링크 | 분류 |
+| :-----------------------------------------------------------------------: | :-------------------------------------------------------------------------: | :-------------------------------------------------------------------------------: | :-------: | :---------: |
+| 14620 | 꽃길 | 
| [C++_v1](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/04_%EB%B8%8C%EB%A3%A8%ED%8A%B8%20%ED%8F%AC%EC%8A%A4/%EB%8F%84%EC%A0%84/14620_v1.cpp) [C++_v2](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/04_%EB%B8%8C%EB%A3%A8%ED%8A%B8%20%ED%8F%AC%EC%8A%A4/%EB%8F%84%EC%A0%84/14620_v2.cpp) | 브루트 포스 |
+| 3085 | 사탕게임 | | [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/04_%EB%B8%8C%EB%A3%A8%ED%8A%B8%20%ED%8F%AC%EC%8A%A4/%EB%8F%84%EC%A0%84/3085.cpp) | 브루트 포스 |
+
+---
+
+### 힌트
+
+
+킹
+
+ 문자형 변수의 연산은 비교적 자유로워요! 또 킹과 돌의 움직임이 모두 판 안에서 이뤄질 때만 다음으로 움직일 수 있는 점을 신경써주세요!
+
+
+
+
+영화감독 숌
+
+ 각 숫자마다 6이 세 개 이상 연속되는지 확인해보세요. 숫자가 어렵다면 문자열로 바꿔도 괜찮을 것 같네요!
+
+
+
+
+한수
+
+ 각 숫자마다 자리 수들이 등차 수열인지 확인해보세요. 숫자가 어렵다면 문자열로 바꿔도 괜찮을 것 같네요!
+
+
+
+
+꽃길
+
+ 그래프의 크기가 최대 10 x 10 이네요? 세개의 꽃을 심을 수 있는 모든 경우의 수를 탐색해보아도 괜찮겠어요. 꽃이 피는 자리가 그래프의 테두리에 있는 경우는 없네요.
+씨앗을 다 심었다면 특정 위치에 씨앗을 심을 경우 5칸의 비용이 얼마인지를 알아야하고, 또 그렇게 씨앗을 심었을때 꽃잎이 죽지 않는지를 판단해야겠네요!
+
+
+
+
+
+사탕게임
+
+ 범위가 크지 않으니 바꿀 수 있는 사탕을 하나하나 다 바꿔봐도 좋아요. 각 행과 열에서 먹을 수 있는 사탕의 수를 세는게 중요하겠네요.
+
+
+
+---
diff --git "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\352\260\225\354\235\230 \354\236\220\353\243\214/04_\353\270\214\353\243\250\355\212\270\355\217\254\354\212\244_\353\254\270\354\240\234\355\225\264\354\204\244.pdf" "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\352\260\225\354\235\230 \354\236\220\353\243\214/04_\353\270\214\353\243\250\355\212\270\355\217\254\354\212\244_\353\254\270\354\240\234\355\225\264\354\204\244.pdf"
new file mode 100644
index 00000000..258e2633
Binary files /dev/null and "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\352\260\225\354\235\230 \354\236\220\353\243\214/04_\353\270\214\353\243\250\355\212\270\355\217\254\354\212\244_\353\254\270\354\240\234\355\225\264\354\204\244.pdf" differ
diff --git "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\352\260\225\354\235\230 \354\236\220\353\243\214/04_\353\270\214\353\243\250\355\212\270\355\217\254\354\212\244_\354\235\264\353\241\240.pdf" "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\352\260\225\354\235\230 \354\236\220\353\243\214/04_\353\270\214\353\243\250\355\212\270\355\217\254\354\212\244_\354\235\264\353\241\240.pdf"
new file mode 100644
index 00000000..1a1870aa
Binary files /dev/null and "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\352\260\225\354\235\230 \354\236\220\353\243\214/04_\353\270\214\353\243\250\355\212\270\355\217\254\354\212\244_\354\235\264\353\241\240.pdf" differ
diff --git "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\352\260\225\354\235\230 \354\236\220\353\243\214/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\352\260\225\354\235\230 \354\236\220\353\243\214/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\217\204\354\240\204/14620_v1.cpp" "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\217\204\354\240\204/14620_v1.cpp"
new file mode 100644
index 00000000..c91f32a7
--- /dev/null
+++ "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\217\204\354\240\204/14620_v1.cpp"
@@ -0,0 +1,58 @@
+#include
+#include
+#include
+
+using namespace std;
+const int MAX_N = 11;
+const int MAX_ANS = 200 * 15;
+
+int getScore(int r, int c, vector> gr) {
+ return gr[r - 1][c] + gr[r][c - 1] + gr[r + 1][c] + gr[r][c + 1] + gr[r][c];
+}
+
+int solution(int n, vector> gr) {
+ int answer = MAX_ANS;
+ int r1, c1, r2, c2, r3, c3;
+ n -= 2;
+
+ for (int i = 0; i < n * n; i++) { //씨앗을 심을 세 곳의 할당값(r,c)을 선택
+ r1 = i / n + 1; c1 = i % n + 1; // 할당값으로 행과 열 계산
+ for (int j = 0; j < n * n; j++) {
+ r2 = j / n + 1; c2 = j % n + 1;
+ if (abs(r1 - r2) + abs(c1 - c2) <= 2) {
+ continue; //겹치는 경우 제외
+ }
+ for (int t = 0; t < n * n; t++) {
+ r3 = t / n + 1; c3 = t % n + 1;
+ if (abs(r1 - r3) + abs(c1 - c3) <= 2 || abs(r2 - r3) + abs(c2 - c3) <= 2) {
+ continue;//겹치는 경우 제외
+ }
+ answer = min(answer, getScore(r1, c1, gr) + getScore(r2, c2, gr) + getScore(r3, c3, gr)); //합산
+ }
+ }
+ }
+ return answer;
+}
+/* 꽃길 14620
+ * 테투리를 제외한 칸 (n-2) * (n-2) 칸 중에 3칸을 고르면 됩니다.
+ * 3칸 중 어떤 두 칸 (r1,c1), (r2,c2)가 abs(r1 - r2) + abs(c1 - c2) <= 2 인 경우를 제외시키면 됩니다.
+ *! 칸을 고를 때, (n-2) * (n-2) 크기의 판에 순서대로 0 ~ (n-2)*(n-2) - 1 만큼의 숫자를 할당했다고 가정합시다.
+ *! 그러면 어떤 칸이 x (0 <= x < (n-2)*(n-2))값을 가진다면, 그 칸의 행(r)은 x / (n-2) + 1 이고 열(c)은 x % (n-2) + 1 입니다.
+ *! 이 방법이 어렵다면 6중 반복문으로 행과 열을 골라주어도 됩니다.
+ */
+int main()
+{
+ int n;
+ vector> gr(MAX_N, vector(MAX_N));
+ //입력
+ cin >> n;
+
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < n; j++) {
+ cin >> gr[i][j];
+ }
+ }
+ //연산 & 출력
+ cout << solution(n, gr);
+ return 0;
+}
\ No newline at end of file
diff --git "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\217\204\354\240\204/14620_v2.cpp" "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\217\204\354\240\204/14620_v2.cpp"
new file mode 100644
index 00000000..f961059f
--- /dev/null
+++ "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\217\204\354\240\204/14620_v2.cpp"
@@ -0,0 +1,80 @@
+#include
+#include
+#include
+
+using namespace std;
+const int MAX = 3000;
+
+vector> board;
+vector> check;
+int dr[5] = { 0, -1, 1, 0, 0 };
+int dc[5] = { 0, 0, 0, -1, 1 };
+int ans = MAX;
+
+int chkFlower(int r, int c) {
+
+ int sum = 0;
+ for (int i = 0; i < 5; i++) {
+ int nr = r + dr[i];
+ int nc = c + dc[i];
+ if (check[nr][nc]) { // 이미 꽃 있다면
+ return -1;
+ }
+ sum += board[nr][nc];
+ }
+ return sum;
+}
+void plant(int r, int c, bool marking_type) { //상하좌우로 꽃 심거나 돌려놓기.
+
+
+ for (int i = 0; i < 5; i++) {
+ int nr = r + dr[i];
+ int nc = c + dc[i];
+
+ check[nr][nc] = marking_type;
+ }
+
+}
+void minFlower(int cnt, int sum) {
+
+ if (cnt == 3) {
+ ans = min(ans, sum);
+ return;
+ }
+ for (int i = 1; i < board.size() - 1; i++) {
+ for (int j = 1; j < board.size() - 1; j++) {
+ int sumFlower = chkFlower(i, j);
+ if (sumFlower == -1) {
+ continue;
+ }
+ plant(i, j, 1);
+ minFlower(cnt + 1, sum + sumFlower);
+ plant(i, j, 0);
+ }
+ }
+}
+/* 꽃길 14620 백트랙킹 버전
+ 백트랙킹을 공부하고 나서 다시 풀어보세요~
+*/
+
+int main() {
+
+ int n;
+
+ // 입력
+ cin >> n;
+
+ board.assign(n, vector(n, 0));
+ check.assign(n, vector(n, false));
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < n; j++) {
+ cin >> board[i][j];
+ }
+ }
+
+ // 연산 & 출력
+ minFlower(0, 0);
+
+ cout << ans;
+ return 0;
+}
\ No newline at end of file
diff --git "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\217\204\354\240\204/3085.cpp" "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\217\204\354\240\204/3085.cpp"
new file mode 100644
index 00000000..1a9d55f0
--- /dev/null
+++ "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\217\204\354\240\204/3085.cpp"
@@ -0,0 +1,73 @@
+#include
+#include
+#include
+
+using namespace std;
+
+/*
+입력 범위가 작으므로, 사탕을 전부 바꿔보며 계산하자
+*/
+
+int n;
+vector arr;
+int dr[2] = {1, 0};
+int dc[2] = {0, 1};
+
+int countCandy(int row, int col, int dir) {
+ int result = 0, cnt = 0;
+ char prev = ' ';
+ for (int i = 0; i < n; i++) {
+ if (prev == arr[row][col]) { //연속된 사탕
+ cnt++;
+ result = max(result, cnt);
+ } else { //불연속
+ cnt = 1;
+ prev = arr[row][col];
+ }
+ row += dr[dir];
+ col += dc[dir];
+ }
+ return result;
+}
+
+int findCandy() {
+ int result = 0;
+ for (int i = 0; i < n; i++) {
+ result = max(result, countCandy(0, i, 0)); //같은 열
+ result = max(result, countCandy(i, 0, 1)); //같은 행
+ }
+ return result;
+}
+
+int switchCandy(int row, int col, char candy) {
+ int result = 0;
+ for (int i = 0; i < 2; i++) {
+ int nr = row + dr[i], nc = col + dc[i];
+ if (nr < n && nc < n && candy != arr[nr][nc]) {
+ swap(arr[row][col], arr[nr][nc]);
+ result = max(result, findCandy());
+ swap(arr[row][col], arr[nr][nc]);
+ }
+ }
+ return result;
+}
+
+int main() {
+ // 입력
+ cin >> n;
+ arr.assign(n, "");
+ for (int i = 0; i < n; i++) {
+ cin >> arr[i];
+ }
+ // 연산
+ int result = 0;
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < n; j++) {
+ result = max(result, switchCandy(i, j, arr[i][j]));
+ }
+ }
+
+ // 출력
+ cout << result;
+ return 0;
+}
diff --git "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\217\204\354\240\204/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\217\204\354\240\204/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/2231.cpp" "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/2231.cpp"
new file mode 100644
index 00000000..78d3546c
--- /dev/null
+++ "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/2231.cpp"
@@ -0,0 +1,24 @@
+#include
+#include
+
+using namespace std;
+
+int main() {
+ int answer = 0, n;
+ //입력
+ cin >> n;
+ //연산
+ for (int i = 1; i < n; i++) {
+ string s = to_string(i);
+ int sum_num = i;
+ for (int j = 0; j < s.size(); j++) {
+ sum_num += s[j] - '0';
+ }
+ if (sum_num == n) {
+ answer = i;
+ break;
+ }
+ }
+ //출력
+ cout << answer;
+}
diff --git "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/2309.cpp" "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/2309.cpp"
new file mode 100644
index 00000000..2e0a0555
--- /dev/null
+++ "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/2309.cpp"
@@ -0,0 +1,31 @@
+#include
+#include
+#include
+
+using namespace std;
+
+int main()
+{
+ int n = 9, sum_height = 0, num;
+ vector v;
+ //입력
+ while (n--) {
+ cin >> num;
+ v.push_back(num);
+ sum_height += num;
+ }
+ sort(v.begin(), v.end()); //정렬
+ //연산 & 출력
+ for (int i = 0; i < 8; i++) {
+ for (int j = i + 1; j < 9; j++) {
+ if (sum_height - v[i] - v[j] == 100) {
+ for (int k = 0; k < 9; k++) {
+ if (k != i && k != j) {
+ cout << v[k] << '\n';
+ }
+ }
+ return 0;
+ }
+ }
+ }
+}
diff --git "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\355\225\204\354\210\230/1063.cpp" "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\355\225\204\354\210\230/1063.cpp"
new file mode 100644
index 00000000..38c639bc
--- /dev/null
+++ "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\355\225\204\354\210\230/1063.cpp"
@@ -0,0 +1,90 @@
+#include
+#include
+#include
+
+using namespace std;
+typedef paircc;
+
+cc move(string input, char x, char y) {//이동 함수 x : 열, y : 행
+ for (int i = 0; i < input.size(); i++) {
+ char how = input[i];
+ if (how == 'R') {
+ x++;
+ }
+ else if (how == 'L') {
+ x--;
+ }
+ else if (how == 'B') {
+ y--;
+ }
+ else {//T
+ y++;
+
+ }
+ }
+
+ return { x, y };
+
+}
+
+bool checkRange(cc position) {//범위 체크 하는 함수
+
+ if (position.first < 'A' || position.first > 'H'
+ || position.second < '1' || position.second > '8') {
+ return false;
+ }
+
+ return true;
+}
+
+bool isSame(cc k, cc s) {
+
+ return (k.first == s.first && k.second == s.second);
+
+}
+
+/*
+* HINT : 문자형 변수의 연산은 비교적 자유로워요! 또 킹과 돌의 움직임이 모두 판 안에서 이뤄질 때만 다음으로 움직일 수 있는 점을 신경써주세요!
+* 1. king 이동 (move)
+* 2. king과 stone의 위치 동일 -> stone 이동 (move)
+* 3. king과 stone의 위치 점검 (checkRange
+*/
+
+int main() {
+
+ cc k, s;//king, stone
+ int n;
+ string input;
+
+ //입력
+ cin >> k.first >> k.second >> s.first >> s.second >> n;
+
+ //연산
+ while (n--) {
+ cin >> input;
+
+ cc next_k, next_s;//이동 후 위치 저장할 변수
+
+ //king 이동
+ next_k = move(input, k.first, k.second);
+
+ //stone 이동
+ if (isSame(next_k,s)) {
+ next_s = move(input, s.first, s.second);
+ }
+ else {
+ next_s = s;
+ }
+
+ //범위 체크
+ if (checkRange(next_k) && checkRange(next_s)){//이동한 king과 stone가 유효 범위면 최종적으로 이동
+ k = next_k;
+ s = next_s;
+ }
+
+ }
+
+ //출력
+ cout << k.first << k.second <<'\n'<< s.first << s.second ;
+ return 0;
+}
\ No newline at end of file
diff --git "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\355\225\204\354\210\230/1065.cpp" "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\355\225\204\354\210\230/1065.cpp"
new file mode 100644
index 00000000..29c72a7e
--- /dev/null
+++ "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\355\225\204\354\210\230/1065.cpp"
@@ -0,0 +1,33 @@
+#include
+#include
+
+using namespace std;
+
+int solution(int num) {
+ int cnt = 99; // 100 미만의 숫자는 그 자체로 등차수열이다
+ for (int i = 100; i <= num; i++) {
+ int hun = i / 100; // 백의 자릿수
+ int ten = (i / 10) % 10; // 십의 자릿수
+ int one = i % 10;
+
+ if ((hun - ten) == (ten - one)) { // 각 자릿수가 수열을 이루면
+ cnt++;
+ }
+ }
+ return cnt;
+}
+
+int main()
+{
+ int n;
+ //입력
+ cin >> n;
+ //연산 & 출력
+ if (n <= 99) {
+ cout << n;
+ }
+ else {
+ cout << solution(n);
+ }
+ return 0;
+}
diff --git "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\355\225\204\354\210\230/1436.cpp" "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\355\225\204\354\210\230/1436.cpp"
new file mode 100644
index 00000000..6606c2d9
--- /dev/null
+++ "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\355\225\204\354\210\230/1436.cpp"
@@ -0,0 +1,40 @@
+#include
+#include
+
+using namespace std;
+
+int main()
+{
+ int n, cnt = 0;
+ //입력
+ cin >> n;
+ //연산 & 출력
+ for (int i = 666; i < 2066666666; i++) {
+ // 방법 1
+ string s = to_string(i);
+ int suc = 0; // 연속하는 6의 개수
+ for (int j = 0; j < s.length(); j++) {
+ if (s[j] == '6') {
+ suc++;
+ }
+ else {
+ suc = 0;
+ }
+ if (suc == 3) {
+ cnt++;
+ break;
+ }
+ }
+ /*
+ * 방법 2
+ * s.substr(j, 3) == "666"
+ * substr 사용법 : https://en.cppreference.com/w/cpp/string/basic_string/substr
+ * 방법 3
+ * if (s.find("666") != -1)
+ * find 사용법 : https://en.cppreference.com/w/cpp/string/basic_string/find
+ */
+ if (cnt == n) {
+ return cout << s, 0;
+ }
+ }
+}
\ No newline at end of file
diff --git "a/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\355\225\204\354\210\230/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/04_\353\270\214\353\243\250\355\212\270 \355\217\254\354\212\244/\355\225\204\354\210\230/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/README.md" "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/README.md"
index e69de29b..1e1bc161 100644
--- "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/README.md"
+++ "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/README.md"
@@ -0,0 +1,75 @@
+# 우선순위 큐 (Priority Queue)
+
+[메인으로 돌아가기](https://github.com/Altu-Bitu-Official/Altu-Bitu-4)
+
+## 💻 튜터링
+
+### 라이브 코딩
+
+| 문제 번호 | 문제 이름 | 난이도 | 풀이 링크 | 분류 |
+| :-----------------------------------------------------------------------: | :---------------------------------------------------------------------------: | :--------------------------------------------------------------------------------: | :----------: | :---------: |
+| 11279 | 최대 힙 | | [바로가기1](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/05_%EC%9A%B0%EC%84%A0%EC%88%9C%EC%9C%84%20%ED%81%90/%EB%9D%BC%EC%9D%B4%EB%B8%8C%20%EC%BD%94%EB%94%A9/11279_v1.cpp) [바로가기2](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/05_%EC%9A%B0%EC%84%A0%EC%88%9C%EC%9C%84%20%ED%81%90/%EB%9D%BC%EC%9D%B4%EB%B8%8C%20%EC%BD%94%EB%94%A9/11279_v2.cpp) | 우선순위 큐 |
+| 11286 | 절댓값 힙 | | [바로가기](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/05_%EC%9A%B0%EC%84%A0%EC%88%9C%EC%9C%84%20%ED%81%90/%EB%9D%BC%EC%9D%B4%EB%B8%8C%20%EC%BD%94%EB%94%A9/11286.cpp) | 우선순위 큐 |
+
+## ✏️ 과제
+
+### 마감기한
+
+~ 3 / 21 (화) 18:59 - 과제 제출
+~ 3 / 23 (목) 23:59 - 추가 제출
+
+### 필수
+
+| 문제 번호 | 문제 이름 | 난이도 | 풀이 링크 | 분류 |
+| :-----------------------------------------------------------------------: | :---------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------: | :-------: | :---------------: |
+| 2607 | 비슷한 단어 | | [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/05_%EC%9A%B0%EC%84%A0%EC%88%9C%EC%9C%84%20%ED%81%90/%ED%95%84%EC%88%98/2607.cpp) | 구현, 문자열 |
+| 14235 | 크리스마스 선물 | | [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/05_%EC%9A%B0%EC%84%A0%EC%88%9C%EC%9C%84%20%ED%81%90/%ED%95%84%EC%88%98/14235.cpp) | 우선순위 큐 |
+| 2075 | N번째 큰 수 | | [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/05_%EC%9A%B0%EC%84%A0%EC%88%9C%EC%9C%84%20%ED%81%90/%ED%95%84%EC%88%98/2075.cpp) | 우선순위 큐, 정렬 |
+
+### 도전
+
+| 문제 번호 | 문제 이름 | 난이도 | 풀이 링크 | 분류 |
+| :--------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------: | :-------: | :---------: |
+| 프로그래머스 | 디스크 컨트롤러 | **Lv.3** | [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/05_%EC%9A%B0%EC%84%A0%EC%88%9C%EC%9C%84%20%ED%81%90/%EB%8F%84%EC%A0%84/%EB%94%94%EC%8A%A4%ED%81%AC%EC%BB%A8%ED%8A%B8%EB%A1%A4%EB%9F%AC.cpp) | 우선순위 큐 |
+| 1655 | 가운데를 말해요 | 
| [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/05_%EC%9A%B0%EC%84%A0%EC%88%9C%EC%9C%84%20%ED%81%90/%EB%8F%84%EC%A0%84/1655.cpp) | 우선순위 큐 |
+
+---
+
+### 힌트
+
+
+비슷한 단어
+
+ 문제의 조건대로 구현해주시면 됩니다 :)
+
+
+
+
+크리스마스 선물
+
+ 아이들에게 주는 선물의 특징을 고려해 자료구조를 선택해보세요!
+
+
+
+
+N번째 큰 수
+
+ 상위 n개의 숫자에서 n번째 숫자는 가장 작은 숫자네요!
+
+
+
+
+디스크 컨트롤러
+
+ 현재 시각에서 요청된 task 중 소요시간이 가장 적은 task를 우선으로 실행해야 해요! 시간이 흘러감에 따라 수행돼야 하는 기능을 생각해보세요!
+
+
+
+
+가운데를 말해요
+
+ 가운데를 찾기 위해 현재까지 입력된 숫자 중 비교적 작은 값과 큰 값을 따로 저장하면 좋을 것 같네요!
+
+
+
+---
diff --git "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\352\260\225\354\235\230 \354\236\220\353\243\214/05_\354\232\260\354\204\240\354\210\234\354\234\204\355\201\220_\353\254\270\354\240\234\355\225\264\354\204\244.pdf" "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\352\260\225\354\235\230 \354\236\220\353\243\214/05_\354\232\260\354\204\240\354\210\234\354\234\204\355\201\220_\353\254\270\354\240\234\355\225\264\354\204\244.pdf"
new file mode 100644
index 00000000..218d86df
Binary files /dev/null and "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\352\260\225\354\235\230 \354\236\220\353\243\214/05_\354\232\260\354\204\240\354\210\234\354\234\204\355\201\220_\353\254\270\354\240\234\355\225\264\354\204\244.pdf" differ
diff --git "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\352\260\225\354\235\230 \354\236\220\353\243\214/05_\354\232\260\354\204\240\354\210\234\354\234\204\355\201\220_\354\235\264\353\241\240.pdf" "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\352\260\225\354\235\230 \354\236\220\353\243\214/05_\354\232\260\354\204\240\354\210\234\354\234\204\355\201\220_\354\235\264\353\241\240.pdf"
new file mode 100644
index 00000000..82156e2e
Binary files /dev/null and "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\352\260\225\354\235\230 \354\236\220\353\243\214/05_\354\232\260\354\204\240\354\210\234\354\234\204\355\201\220_\354\235\264\353\241\240.pdf" differ
diff --git "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\352\260\225\354\235\230 \354\236\220\353\243\214/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\352\260\225\354\235\230 \354\236\220\353\243\214/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\217\204\354\240\204/1655.cpp" "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\217\204\354\240\204/1655.cpp"
new file mode 100644
index 00000000..7e961d59
--- /dev/null
+++ "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\217\204\354\240\204/1655.cpp"
@@ -0,0 +1,72 @@
+#include
+#include
+#include
+
+using namespace std;
+
+/*
+* HINT : 가운데를 찾기 위해 현재까지 입력된 숫자중 비교적 작은 값과 큰 값을 따로 저장하면 좋을 것 같네요!
+*/
+
+void balance(priority_queue& max_pq,
+ priority_queue, greater<>>& min_pq) {
+ int M, m;
+
+ if (max_pq.top() > min_pq.top()) { // max_pq의 가장 큰 값이 min_pq의 가장 작은 값보다 크다면 저장 위치가 잘못된 것!
+ // 각각의 top값을 바꿔서 저장
+ M = max_pq.top();
+ m = min_pq.top();
+
+ max_pq.pop();
+ min_pq.pop();
+
+ max_pq.push(m);
+ min_pq.push(M);
+ }
+
+ return;
+}
+
+/*
+* 입력된 수들 중 비교적 작은 값은 최대힙에 저장하고 큰 값은 최소힙에 저장하자
+* 가운데를 찾기 위해서는 최대힙과 최소힙 개수 차이가 0이나 1이어야 한다
+* 최대힙의 top값이 가운데이도록 하기 위해 최대힙의 사이즈가 최소힙의 사이즈와 같거나 1 더 크게 저장하자
+* 개수를 기준으로 저장했기에 저장 위치가 잘못됐을 수도 있다. -> 균형을 맞춰주자 (balance)
+*/
+
+int main() {
+
+ ios_base::sync_with_stdio(false);
+ cin.tie(NULL);
+ cout.tie(NULL);
+
+ int n, input;
+ priority_queue max_pq; // 비교적 작은 값을 저장해둔 최대힙
+ priority_queue, greater<>> min_pq; // 비교적 큰 값을 저장해둔 최소힙
+
+ // 입력
+ cin >> n;
+
+ // 연산 + 출력
+ for (int i = 0; i < n; i++) {
+ cin >> input;
+
+ // max_pq의 사이즈가 min_pq의 사이즈와 같거나 하나 더 많도록 저장
+ if (max_pq.size() > min_pq.size()) {
+ min_pq.push(input);
+ }
+ else {
+ max_pq.push(input);
+ }
+
+ // 두 개의 pq모두 원소가 존재할 때 균형을 맞춰주자
+ if (!max_pq.empty() && !min_pq.empty()) {
+ balance(max_pq, min_pq);
+ }
+
+ // 출력
+ cout << max_pq.top() << "\n";
+
+ }
+ return 0;
+}
\ No newline at end of file
diff --git "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\217\204\354\240\204/\353\224\224\354\212\244\355\201\254_\354\273\250\355\212\270\353\241\244\353\237\254.cpp" "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\217\204\354\240\204/\353\224\224\354\212\244\355\201\254_\354\273\250\355\212\270\353\241\244\353\237\254.cpp"
new file mode 100644
index 00000000..dc288f44
--- /dev/null
+++ "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\217\204\354\240\204/\353\224\224\354\212\244\355\201\254_\354\273\250\355\212\270\353\241\244\353\237\254.cpp"
@@ -0,0 +1,72 @@
+#include
+#include
+#include
+#include
+
+using namespace std;
+
+// HINT : 현재 시각에서 요청된 task 중 소요시간이 가장 적은 task를 우선으로 실행해야 해요! 시간이 흘러감에 따라 수행돼야 하는 기능을 생각해보세요!
+
+struct sortMinTime {
+ bool operator()(vector a, vector b) {
+ return a[1] > b[1];
+ }
+};
+
+int solution(vector> jobs) { // 요청시간, 소요시간
+ int answer = 0;
+ int curt_time = 0; // 현재 시간
+ int total_time = 0; // 대기 시간
+ int next_request_job = 0; // 다음으로 요청되는 task 인덱스 번호
+ int job_cnt = jobs.size();
+ priority_queue, vector>, sortMinTime> pq; // 소요시간이 작은 순으로 정렬해주는 우선순위 큐
+
+
+ sort(jobs.begin(), jobs.end()); // task를 요청 시간이 작은 순으로 정렬
+
+
+ while (next_request_job < job_cnt || !pq.empty()) {
+
+ // 현재 요청된 task는 없지만 task가 남아 있는 경우
+ if (pq.empty()) {
+ curt_time = jobs[next_request_job][0];
+ pq.push(jobs[next_request_job++]);
+ }
+
+ // 현재 요청된 task 중 소요시간이 가장 적은 task 수행
+ vector curt_job = pq.top();
+ pq.pop();
+ total_time += ((curt_time - curt_job[0]) + curt_job[1]); // (요청부터 실행까지 delay된 시간) + (요청부터 종료까지 total 시간)
+ curt_time += curt_job[1];
+
+ // 현재 시간까지 요청된 task를 큐에 push
+ while (next_request_job < job_cnt && jobs[next_request_job][0] <= curt_time) {
+ pq.push(jobs[next_request_job++]);
+ }
+
+ }
+ answer = int(total_time / job_cnt);
+
+ return answer;
+}
+
+/*
+* 1. 현재 시각에서 요청된 task 중 소요시간이 가장 적은 task를 우선으로 실행해야 한다!
+* 2. pq의 top 에 있는 task를 수행함에 따라 total_time과 curt_time을 변경하자!
+* 3. curt_time에 따라 요청된 task는 pq에 삽입하고
+*/
+
+int main() {
+ vector> jobs;
+ int n;
+ cout << "task수 입력 : ";
+ cin >> n;
+ cout << "\ntask 요청시간 소요시간 입력(빈칸으로 구분)\n";
+ while (n--) {
+ vector time(2);
+ cin >> time[0] >> time[1];
+ jobs.push_back(time);
+ }
+ cout << solution(jobs);
+ return 0;
+}
\ No newline at end of file
diff --git "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\217\204\354\240\204/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\217\204\354\240\204/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/11279_v1.cpp" "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/11279_v1.cpp"
new file mode 100644
index 00000000..b1090455
--- /dev/null
+++ "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/11279_v1.cpp"
@@ -0,0 +1,35 @@
+#include
+#include
+
+using namespace std;
+
+int main() {
+
+ ios_base::sync_with_stdio(false);
+ cin.tie(NULL);
+ cout.tie(NULL);
+
+ int n, x;
+ priority_queue max_heap;
+
+ // 입력
+ cin >> n;
+
+ // 연산+출력
+ while (n--) {
+ cin >> x;
+ if (x == 0) {
+ if (max_heap.empty()) { // 비어있다면 0출력
+ cout << "0\n";
+ }
+ else { // 가장 큰 값 출력하고 제거
+ cout << max_heap.top() << '\n';
+ max_heap.pop();
+ }
+ }
+ else { // x삽입
+ max_heap.push(x);
+ }
+ }
+ return 0;
+}
\ No newline at end of file
diff --git "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/11279_v2.cpp" "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/11279_v2.cpp"
new file mode 100644
index 00000000..27118d7c
--- /dev/null
+++ "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/11279_v2.cpp"
@@ -0,0 +1,86 @@
+#include
+#include
+
+using namespace std;
+
+// heap이 비어있는지 확인
+bool isEmpty(vector &heap) {
+ return heap.size() == 1;
+}
+
+// heap에 x 삽입
+void push(vector &heap, int x) {
+
+ // 0. 현재 힙의 크기 = 새로 push 할 데이터의 초기 인덱스
+ int idx = heap.size();
+ // 1. 힙의 마지막 자리에 x 삽입
+ heap.push_back(x);
+
+ // 부모노드와 비교하면서 바꿀 수 있을 때까지...
+ while (idx > 1 && heap[idx] > heap[idx / 2]) {
+ swap(heap[idx], heap[idx / 2]); // 부모노드와 swap
+ idx /= 2; // 현재 x가 위치한 인덱스
+ }
+ return;
+}
+
+// heap에서 값을 제거하고, 그 값을 리턴합
+int pop(vector &heap) {
+ // 우선 루트노드 값을 복사
+ int item = heap[1];
+ // 루트노트에 가장 뒤에 있는 값을 옮겨준다.
+ heap[1] = heap[heap.size() - 1];
+ heap.pop_back(); // 데이터 제거
+
+ int size = heap.size(); // 힙의 크기
+ int parent = 1, child = 2;
+
+ // 자식노드가 존재하는 동안 비교 진행
+ while (child < size) {
+ // 오른쪽 자식 노드가 존재한다면, 둘 중에 큰 쪽을 선택
+ if (child + 1 < size && heap[child + 1] > heap[child]) {
+ child += 1;
+ }
+
+ // 부모노드가 자식노드보다 값이 작은 경우 swap
+ if (heap[parent] < heap[child]) {
+ swap(heap[parent], heap[child]);
+ parent = child;
+ child = parent * 2;
+ } else { // 자식보다 부모노드가 큰 상황이므로 더 이상 swap은 필요 없음
+ break;
+ }
+ }
+ return item;
+}
+
+int main() {
+ // 입출력 속도 향상
+ ios_base::sync_with_stdio(false);
+ cin.tie(NULL);
+ cout.tie(NULL);
+
+ int n, x;
+ // 입력
+ cin >> n;
+
+ // heap 초기화
+ vector heap_vec;
+ heap_vec.push_back(0);
+
+ while (n--) {
+ cin >> x;
+ if (x == 0) {
+ // 비었다면 0 출력
+ if (isEmpty(heap_vec)) {
+ cout << "0\n";
+ } else { // 가장 큰 값 출력하고 제거
+ cout << pop(heap_vec) << '\n';
+ }
+ } else {
+ // 최대 힙에 x를 삽입
+ push(heap_vec, x);
+ }
+ }
+ return 0;
+}
\ No newline at end of file
diff --git "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/11286.cpp" "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/11286.cpp"
new file mode 100644
index 00000000..ced890ed
--- /dev/null
+++ "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/11286.cpp"
@@ -0,0 +1,47 @@
+#include
+#include
+
+using namespace std;
+
+struct cmp {
+ bool operator()(const int& x1, const int& x2) {
+ if (abs(x2) != abs(x1)) { // 절댓값이 다르다면 절댓값 작은 수를 앞으로
+ return abs(x2) < abs(x1);
+ }
+ return x2 < x1; // 절댓값이 동일하다면 값이 작은 수를 앞으로
+ }
+};
+/*
+* 우선순위 기준
+* 1. 절댓값 작은 수
+* 2. 값이 작은 수
+*/
+int main() {
+
+ ios_base::sync_with_stdio(false);
+ cin.tie(0);
+ cout.tie(0);
+
+ int n, x;
+ priority_queue, cmp> pq;
+ cin >> n;
+
+ while (n--) {
+ cin >> x;
+
+ if (x == 0) { // 출력 + 삭제
+ if (pq.empty()) {
+ cout << "0\n";
+ }
+ else {
+ cout << pq.top() << '\n';
+ pq.pop();
+ }
+
+ }
+ else { // 삽입
+ pq.push(x);
+ }
+ }
+ return 0;
+}
\ No newline at end of file
diff --git "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\355\225\204\354\210\230/14235.cpp" "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\355\225\204\354\210\230/14235.cpp"
new file mode 100644
index 00000000..8a0f2cb3
--- /dev/null
+++ "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\355\225\204\354\210\230/14235.cpp"
@@ -0,0 +1,50 @@
+#include
+#include
+
+using namespace std;
+
+/*
+* HINT : 아이들에게 주는 선물의 특징을 고려해 자료구조를 선택해봐요!
+*/
+
+/*
+ * 아이들에게 주는 선물 : 가치가 가장 큰 선물 -> 선물을 우선순위 큐에 저장
+ * 1. 아이들을 만난 경우
+ * 1) 큐가 비어있으면 -1 출력
+ * 2) 큐의 top값 출력
+ * 2. 선물 충전 -> 큐에 삽입
+ */
+int main() {
+
+ ios_base::sync_with_stdio(false);
+ cin.tie(NULL);
+ cout.tie(NULL);
+
+ int n, input, gift;
+ priority_queue pq;
+
+ // 입력
+ cin >> n;
+
+ // 연산 + 출력
+ while (n--) {
+
+ cin >> input;
+ if (!input) { // 아이들을 만난 경우
+ if (pq.empty()) {
+ cout << "-1\n";
+ }
+ else {
+ cout << pq.top() << '\n';
+ pq.pop();
+ }
+ }
+ else { // 선물을 충전하는 경우
+ while (input--) {
+ cin >> gift;
+ pq.push(gift);
+ }
+ }
+ }
+ return 0;
+}
\ No newline at end of file
diff --git "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\355\225\204\354\210\230/2075.cpp" "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\355\225\204\354\210\230/2075.cpp"
new file mode 100644
index 00000000..6779d50c
--- /dev/null
+++ "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\355\225\204\354\210\230/2075.cpp"
@@ -0,0 +1,42 @@
+#include
+#include
+
+using namespace std;
+
+/*
+* HINT : 상위 n개의 숫자에서 n번째 숫자는 가장 작은 숫자네요!
+*/
+
+/*
+* 입력되는 수 중 n번째로 큰 수를 찾자!
+* -> 최종으로 상위 n개를 저장할 수 있는 구조 -> n개 이상일 때 가장 작은 값을 삭제할 수 있는 구조
+* -> 최소힙을 이용하자
+* -> 입력을 최소힙에 push하고 힙의 사이즈가 n보다 크다면 top값을 제거해주자
+* ->최종적으로 상위 n개의 숫자가 저장되고 top값이 n번째 큰 수가 된다!
+*/
+
+int main() {
+
+ ios_base::sync_with_stdio(false);
+ cin.tie(0);
+ cout.tie(0);
+
+ int n, num;
+ priority_queue, greater> pq; // 최소힙
+
+ // 입력
+ cin >> n;
+
+ // 연산
+ for (int i = 0; i < n*n; i++) {
+ cin >> num;
+ pq.push(num);
+ if (pq.size() > n) {// 저장된 숫자의 개수가 n보다 많으면 가장 작은 값(top 값)을 제거
+ pq.pop();
+ }
+ }
+
+ // 출력
+ cout << pq.top();
+ return 0;
+}
\ No newline at end of file
diff --git "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\355\225\204\354\210\230/2607.cpp" "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\355\225\204\354\210\230/2607.cpp"
new file mode 100644
index 00000000..d1907332
--- /dev/null
+++ "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\355\225\204\354\210\230/2607.cpp"
@@ -0,0 +1,70 @@
+#include
+#include
+
+using namespace std;
+const int NUM_CHARS = 26;
+
+/*
+* 원본 단어와의 차이의 개수를 센다.
+*/
+
+/*
+ * [비슷한 단어]
+ *
+ * 단어가 같은 구성일 조건
+ * 1. 두 개의 단어가 같은 종류의 문자로 이루어짐
+ * 2. 같은 문자는 같은 개수만큼 있음
+ *
+ * 비슷한 단어의 조건
+ * 1. 한 단어에서 한 문자를 더하거나, 빼면 같은 구성이 됨
+ * -> 두 단어에서 다른 문자의 개수가 총 1개
+ * 2. 한 단어에서 한 문자를 바꾸면 같은 구성이 됨
+ * -> 두 단어에서 다른 문자의 개수가 총 2개
+ * -> !주의! 이때, 두 단어의 길이가 같아야 함 cf) doll | do
+ */
+
+// 각 알파벳의 개수 세기
+void countFreq(string word, vector &freq) {
+ for (int i = 0; i < word.length(); i++) {
+ freq[word[i] - 'A']++;
+ }
+}
+
+int countDiff(string word, vector original_freq) {
+ vector freq(NUM_CHARS, 0);
+ int diff = 0; // 원본 단어와의 차이
+
+ countFreq(word, freq); // 각 알파벳의 개수 세기
+
+ // 원본 단어와 다른 알파벳 개수 구하기
+ for (int i = 0; i < NUM_CHARS; i++) {
+ diff += abs(original_freq[i] - freq[i]);
+ }
+ return diff;
+}
+
+int main() {
+ int N, ans=0;
+ string original;
+ // 입력
+ cin >> N;
+ cin >> original;
+ vector original_freq(NUM_CHARS, 0);
+
+ // 연산
+ countFreq(original, original_freq);
+
+ for (int i = 1; i < N; i++) {
+ string word;
+ cin >> word;
+
+ int diff = countDiff(word, original_freq);
+ // 비슷한 단어 세기
+ if (diff == 0 || diff == 1 || diff == 2 && original.length() == word.length()) {
+ ans++;
+ }
+ }
+ // 출력
+ cout << ans;
+ return 0;
+}
\ No newline at end of file
diff --git "a/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\355\225\204\354\210\230/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/05_\354\232\260\354\204\240\354\210\234\354\234\204 \355\201\220/\355\225\204\354\210\230/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/README.md" "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/README.md"
index e69de29b..9d91dd26 100644
--- "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/README.md"
+++ "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/README.md"
@@ -0,0 +1,76 @@
+# 그리디 알고리즘 (Greedy Algorithm)
+
+[메인으로 돌아가기](https://github.com/Altu-Bitu-Official/Altu-Bitu-4)
+
+## 💻 튜터링
+
+### 라이브 코딩
+
+| 문제 번호 | 문제 이름 | 난이도 | 풀이 링크 | 분류 |
+| :--------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------: | :----------: | :----: |
+| 11047 | 동전 0 | | [바로가기](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/06_%EA%B7%B8%EB%A6%AC%EB%94%94%20%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98/%EB%9D%BC%EC%9D%B4%EB%B8%8C%20%EC%BD%94%EB%94%A9/11047.cpp) | 그리디 |
+| 1931 | 회의실 배정 | | [바로가기](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/06_%EA%B7%B8%EB%A6%AC%EB%94%94%20%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98/%EB%9D%BC%EC%9D%B4%EB%B8%8C%20%EC%BD%94%EB%94%A9/1931.cpp) | 그리디 |
+| 프로그래머스 | 체육복 | **Lv.1** | [바로가기](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/06_%EA%B7%B8%EB%A6%AC%EB%94%94%20%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98/%EB%9D%BC%EC%9D%B4%EB%B8%8C%20%EC%BD%94%EB%94%A9/%EC%B2%B4%EC%9C%A1%EB%B3%B5.cpp) | 그리디 |
+
+## ✏️ 과제
+
+### 마감기한
+
+~ 3 / 28 (화) 18:59 - 과제 제출
+~ 3 / 30 (목) 23:59 - 추가 제출
+
+### 필수
+
+| 문제 번호 | 문제 이름 | 난이도 | 풀이 링크 | 분류 |
+| :-----------------------------------------------------------------------: | :--------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------: | :-------: | :---------------: |
+| 18111 | 마인크래프트 | | [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/06_%EA%B7%B8%EB%A6%AC%EB%94%94%20%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98/%ED%95%84%EC%88%98/18111.cpp) | 구현, 브루트 포스 |
+| 1213 | 팰린드롬 만들기 | | [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/06_%EA%B7%B8%EB%A6%AC%EB%94%94%20%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98/%ED%95%84%EC%88%98/1213.cpp) | 그리디, 문자열 |
+| 17451 | 평행 우주 | | [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/06_%EA%B7%B8%EB%A6%AC%EB%94%94%20%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98/%ED%95%84%EC%88%98/17451.cpp) | 그리디, 수학 |
+
+### 도전
+
+| 문제 번호 | 문제 이름 | 난이도 | 풀이 링크 | 분류 |
+| :--------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------: | :-------: | :----------: |
+| 19539 | 사과나무 | 
| [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/06_%EA%B7%B8%EB%A6%AC%EB%94%94%20%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98/%EB%8F%84%EC%A0%84/19539.cpp) | 그리디, 수학 |
+| 프로그래머스 | 큰 수 만들기 | **Lv.2** | [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/06_%EA%B7%B8%EB%A6%AC%EB%94%94%20%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98/%EB%8F%84%EC%A0%84/%ED%81%B0_%EC%88%98_%EB%A7%8C%EB%93%A4%EA%B8%B0.cpp) | 그리디 |
+
+---
+
+### 힌트
+
+
+마인크래프트
+
+ 블록 높이의 최댓값을 살펴보아요. 입력의 크기가 작을 땐 어떻게 접근하면 좋을까요?
+
+
+
+
+팰린드롬 만들기
+
+ 팰린드롬이 존재하려면 어떤 조건을 만족해야 할까요?
+
+
+
+
+평행 우주
+
+ 자료형마다 값의 범위가 정해져 있다는걸 명심하세요. 어디에서부터 속도를 확인하는 게 더 유리할까요?
+
+
+
+
+사과나무
+
+ 골드라고 겁먹지 말아요:) 나무가 자라는 높이의 수학적인 성질을 이용하면 어렵지 않은 문제입니다!
+
+
+
+
+큰 수 만들기
+
+ 앞에 있는 숫자를 버리지 않고 뒤에 있는 숫자를 버리는 조건이 무엇일까요?
+
+
+
+---
diff --git "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\352\260\225\354\235\230 \354\236\220\353\243\214/06_\352\267\270\353\246\254\353\224\224\354\225\214\352\263\240\353\246\254\354\246\230_\353\254\270\354\240\234\355\225\264\354\204\244.pdf" "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\352\260\225\354\235\230 \354\236\220\353\243\214/06_\352\267\270\353\246\254\353\224\224\354\225\214\352\263\240\353\246\254\354\246\230_\353\254\270\354\240\234\355\225\264\354\204\244.pdf"
new file mode 100644
index 00000000..3fa42bf0
Binary files /dev/null and "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\352\260\225\354\235\230 \354\236\220\353\243\214/06_\352\267\270\353\246\254\353\224\224\354\225\214\352\263\240\353\246\254\354\246\230_\353\254\270\354\240\234\355\225\264\354\204\244.pdf" differ
diff --git "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\352\260\225\354\235\230 \354\236\220\353\243\214/06_\352\267\270\353\246\254\353\224\224\354\225\214\352\263\240\353\246\254\354\246\230_\354\235\264\353\241\240.pdf" "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\352\260\225\354\235\230 \354\236\220\353\243\214/06_\352\267\270\353\246\254\353\224\224\354\225\214\352\263\240\353\246\254\354\246\230_\354\235\264\353\241\240.pdf"
new file mode 100644
index 00000000..5d290576
Binary files /dev/null and "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\352\260\225\354\235\230 \354\236\220\353\243\214/06_\352\267\270\353\246\254\353\224\224\354\225\214\352\263\240\353\246\254\354\246\230_\354\235\264\353\241\240.pdf" differ
diff --git "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\352\260\225\354\235\230 \354\236\220\353\243\214/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\352\260\225\354\235\230 \354\236\220\353\243\214/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\217\204\354\240\204/19539.cpp" "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\217\204\354\240\204/19539.cpp"
new file mode 100644
index 00000000..5f214ab8
--- /dev/null
+++ "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\217\204\354\240\204/19539.cpp"
@@ -0,0 +1,50 @@
+#include
+#include
+
+using namespace std;
+/*
+* 1. 한 번 물을 줄 때마다 3씩 나무가 자라므로, 나무 높이의 합(sum)은 3의 배수가 되어야 합니다.
+* (이 때, 물을 주는 횟수 k는 `sum/3`이 됩니다.)
+* 2. `홀수+홀수=짝수`, `짝수+짝수=짝수`, `홀수+홀수=짝수` 입니다.
+* 따라서 k번 물을 준다면 홀수 높이는 최대 k개만 가능합니다.
+*/
+
+void summation(int &sum, int &height){
+ sum += height;
+}
+
+void countOdd(int &height, int &odd){
+ if (height % 2) { //홀수 높이의 개수 세기
+ odd++;
+ }
+}
+
+bool solve(int sum, int odd) {
+ if (sum % 3) { //최종 나무 높이의 합이 3의 배수여야 함
+ return false;
+ }
+ if (odd > sum / 3) { // (sum/3)은 물을 주는 횟수
+ return false;
+ }
+ return true;
+}
+int main() {
+ int n, sum = 0, odd = 0;
+
+ // 입력
+ cin >> n;
+
+ // 입력 & 연산
+ for (int i = 0; i < n; i++) {
+ int height;
+ cin >> height;
+ summation(sum, height);
+ countOdd(height, odd);
+ }
+
+ // 연산 & 출력
+ solve(sum, odd) ? cout << "YES" : cout << "NO";
+ //삼항연산자
+ // `condition ? A : B` 형태 => condition이 참인 경우 A 실행(사용), condition이 거짓인 경우 B 실행(사용)
+ return 0;
+}
\ No newline at end of file
diff --git "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\217\204\354\240\204/\355\201\260_\354\210\230_\353\247\214\353\223\244\352\270\260.cpp" "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\217\204\354\240\204/\355\201\260_\354\210\230_\353\247\214\353\223\244\352\270\260.cpp"
new file mode 100644
index 00000000..65799cb9
--- /dev/null
+++ "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\217\204\354\240\204/\355\201\260_\354\210\230_\353\247\214\353\223\244\352\270\260.cpp"
@@ -0,0 +1,32 @@
+#include
+#include
+/*
+* 결론적으로 (문자열 길이 - k)개 만큼의 숫자를 합쳐 리턴해주면 된다.
+* 즉, 앞에서부터 k, k+1, ... 번째 까지의 숫자들에 대해 최댓값을 하나씩 포함시키면 된다.
+* 이 때, 이미 추가한 숫자가 있다면 그 뒤에 해당하는 숫자만을 추가해야 한다.
+* (앞 숫자를 추가할 경우, 최댓값이 보장되지 않음)
+*/
+using namespace std;
+
+string solution(string number, int k) {
+ string answer = "";
+ int max_val = 0;
+ int max_idx = 0;
+ int idx = 0;
+ while (idx < number.length()) {
+ if (max_val < number[idx]) {//최댓값, 최댓값의 인덱스 갱신
+ max_val = number[idx];
+ max_idx = idx;
+ }
+ if (idx == k) { //k: 한 번 탐색하는 인덱스의 최댓값
+ // k까지 다 탐색하면, 앞서 탐색한 숫자들 중 최댓값부터 다시 탐색을 시작한다
+ // (앞부분을 추가하지 않기 위함)
+ idx = max_idx;
+ k++; //다음 탐색 범위 확대(k, k+1, ..., number.length() )
+ answer.push_back(max_val);
+ max_val = 0; //새로운 최댓값을 찾아야 하므로 최댓값 초기화
+ }
+ idx++;
+ }
+ return answer;
+}
diff --git "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\217\204\354\240\204/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\217\204\354\240\204/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/11047.cpp" "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/11047.cpp"
new file mode 100644
index 00000000..7f0532bc
--- /dev/null
+++ "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/11047.cpp"
@@ -0,0 +1,26 @@
+#include
+#include
+
+using namespace std;
+/*
+ * 큰 가치의 동전부터 사용하여 거슬러주면 되므로 그리디 알고리즘 이용
+ * 동전 사용할 때마다 동전 개수와 남은 금액 갱신, 남은 금액 0 될 때까지 반복
+ */
+int main() {
+ int n, k, cnt = 0; //cnt: count(필요한 동전 개수)
+ // 입력
+ cin >> n >> k;
+ vector val(n); //동전 n종류의 값 입력받을 벡터
+ for (int i = 0; i < n; i++) {
+ cin >> val[i];
+ }
+ // 연산
+ for (int i = n - 1; i >= 0; i--) { //큰 가치의 돈부터 사용
+ cnt += k / val[i]; //동전 개수 갱신: 남은 금액/동전 가치 더하기
+ k %= val[i]; //남은 금액 갱신: 동전 사용하고 남은 금액으로(나머지 연산자)
+ }
+ // 출력
+ cout << cnt;
+
+ return 0;
+}
diff --git "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/1931.cpp" "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/1931.cpp"
new file mode 100644
index 00000000..242bc59c
--- /dev/null
+++ "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/1931.cpp"
@@ -0,0 +1,38 @@
+#include
+#include
+#include
+
+using namespace std;
+/*
+ * 회의가 끝나는 시각이 빠른 회의부터 배정하면 되므로 그리디 알고리즘을 이용한다.
+ * 이 때, 마지막으로 진행한 회의가 끝난 시각보다 빠른 시각에 시작하는 회의는 배정이 불가능한 점을 고려해야 한다.
+ */
+
+int main() {
+ ios_base::sync_with_stdio(0);
+ cin.tie(0), cout.tie(0);
+ // 입력
+ int n;
+ cin >> n;
+ vector>v;
+ for (int i = 0; i < n; i++) {
+ int start, end;
+ cin >> start >> end;
+ v.push_back({ end,start }); //회의가 끝나는 시각을 기준으로 정렬할 것이므로 편의상 end부터 입력
+ }
+ // 연산
+ sort(v.begin(), v.end()); //끝나는 시각 기준 오름차순 정렬
+
+ int finish_conference = 0, answer = 0;
+ for (int i = 0; i < v.size(); i++) {//회의 끝나는 시각이 빠른 순서대로 배정
+ if (v[i].second < finish_conference) { //회의 시작하는 시각이 기존 종료 시각보다 빠르다면 회의실 배정 불가
+ continue;
+ }
+ finish_conference = v[i].first; //회의 종료 시각 갱신
+ answer++; //배정 가능 회의 수 갱신
+ }
+ // 출력
+ cout << answer;
+
+ return 0;
+}
\ No newline at end of file
diff --git "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/\354\262\264\354\234\241\353\263\265.cpp" "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/\354\262\264\354\234\241\353\263\265.cpp"
new file mode 100644
index 00000000..f5d2f3f2
--- /dev/null
+++ "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/\354\262\264\354\234\241\353\263\265.cpp"
@@ -0,0 +1,58 @@
+#include
+#include
+#include
+
+using namespace std;
+/*
+ * 각 학생들이 가지고 있는 체육복의 개수를 배열에 저장
+ * 1번 학생부터 양 옆의 학생으로부터 대여가 가능한지 여부를 확인하여 빌려준다.
+ * 최종적으로 체육복 개수가 1개 이상인 학생들의 인원을 센다.
+ */
+
+int solution(int n, vector lost, vector reserve) {
+ int answer = 0;
+
+ vector student(n + 1, 1); //체육복 개수 정보 담음
+
+ //입력내용대로 초기화
+ for (int i = 0; i < reserve.size(); i++) { //여벌 체육복이 있는 학생은 플러스
+ student[reserve[i]]++;
+ }
+ for (int i = 0; i < lost.size(); i++) { //체육복을 잃어버린 학생은 마이너스
+ student[lost[i]]--;
+ }
+
+ //1번부터 체육복 대여 가능 여부 체크
+ for (int i = 1; i <= n; i++) { //1번 학생부터 체크하며 양옆으로 체육복을 빌릴 수 있는가 확인
+ if (student[i] > 0) { //빌릴 필요가 없으면 넘어가기
+ continue;
+ }
+
+ if (student[i - 1] == 2) { //앞 번호 학생에게 여벌 체육복이 있는 경우
+ student[i - 1]--;
+ student[i]++;
+ }
+ else if (student[i + 1] == 2) { //뒷 번호 학생에게 여벌 체육복이 있는 경우
+ student[i] = student[i + 1] = 1;
+ }
+ }
+
+ for (int i = 1; i <= n; i++) { //체육복을 입을 수 있는 학생 수 세기
+ if (student[i] > 0) {
+ answer++;
+ }
+ }
+
+ return answer;
+}
+
+//프로그래머스 테스트용으로 실행 가능한 메인 함수
+int main() {
+ vector lost = {2, 4};
+ vector reserve = {1, 3, 5};
+ int n = 5;
+
+ cout << solution(n, lost, reserve);
+
+ return 0;
+}
diff --git "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\355\225\204\354\210\230/1213.cpp" "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\355\225\204\354\210\230/1213.cpp"
new file mode 100644
index 00000000..204c12db
--- /dev/null
+++ "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\355\225\204\354\210\230/1213.cpp"
@@ -0,0 +1,62 @@
+#include
+#include
+#include
+
+using namespace std;
+
+/*
+* A부터 순서대로 이용하면 알파벳순으로 가장 빠른 팰린드롬을 만들 수 있다 -> 그리디 알고리즘
+* 모든 알파벳이 짝수 개씩 존재하거나, 홀수 개 알파벳이 한 종류만 있는 경우에만 팰린드롬이 존재한다.
+*/
+const int NUM_CHAR = 26; // 알파벳 총 개수: 26개
+
+void pushString(string &str, int times, char ch) {
+ // str이라는 문자열의 뒤에 ch 문자를 times 횟수만큼 추가
+ while (times--) {
+ str += ch;
+ }
+}
+
+string isPalindrom(vector freq){
+ string answer = "";
+ int odd_index = -1; // 홀수 개수인 알파벳의 인덱스 체크
+ // 팰린드롬 앞부분 만들기 & 가능한지 여부 체크
+ for (int i = 0; i < NUM_CHAR; i++) {
+ if (freq[i] % 2 == 1) {
+ if (odd_index!=-1) { // 이미 홀수 개수인 알파벳이 존재한다면 팰린드롬 불가능
+ return("I'm Sorry Hansoo");
+ }
+ odd_index = i; // 홀수 개수인 알파벳이 처음이라면 인덱스 체크
+ }
+ pushString(answer, freq[i] / 2, 'A' + i);
+ }
+
+ // 홀수 개수 알파벳 존재한다면 가운데 문자 추가
+ if (odd_index != -1) {
+ answer += 'A' + odd_index;
+ }
+
+ // 팰린드롬 뒷부분 체크
+ for (int i = NUM_CHAR-1; i >= 0; i--) {
+ pushString(answer, freq[i] / 2, 'A' + i);
+ }
+
+ return answer;
+}
+int main() {
+
+ // 입력
+ string name;
+ cin >> name;
+
+ vector freq(NUM_CHAR, 0); // 알파벳 26개마다 빈도수를 센다. 인덱스 0:'A', 1:'B', ...
+
+ // 연산
+ for (int i = 0; i < name.length(); i++) {
+ freq[name[i] - 'A']++; // 각 알파벳의 개수 세기
+ }
+
+ // 연산 & 출력
+ cout << isPalindrom(freq);
+ return 0;
+}
\ No newline at end of file
diff --git "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\355\225\204\354\210\230/17451.cpp" "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\355\225\204\354\210\230/17451.cpp"
new file mode 100644
index 00000000..c2b6b1a4
--- /dev/null
+++ "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\355\225\204\354\210\230/17451.cpp"
@@ -0,0 +1,32 @@
+#include
+#include
+#include
+
+using namespace std;
+
+/*
+* 힌트: 자료형마다 값의 범위가 정해져 있다는걸 명심하세요. 어디에서부터 속도를 확인하는 게 더 유리할까요?
+*
+* 마지막 행성부터 시작하여, 출발속도가 현재 행성의 필요속도의 배수면서도 증가하도록 만든다.
+*/
+
+int main() {
+ int n;
+ vector planet;
+ // 입력
+ cin >> n;
+ for (int i = 0; i < n; i++) {
+ double input;
+ cin >> input;
+ planet.push_back(input);
+ }
+
+ // 연산
+ double ans = 1;
+ for (int i = n - 1; i >= 0; i--) {
+ ans = ceil(ans / planet[i]) * planet[i];
+ }
+
+ // 출력
+ cout << (long long)ans;
+}
\ No newline at end of file
diff --git "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\355\225\204\354\210\230/18111.cpp" "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\355\225\204\354\210\230/18111.cpp"
new file mode 100644
index 00000000..56b02a2c
--- /dev/null
+++ "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\355\225\204\354\210\230/18111.cpp"
@@ -0,0 +1,83 @@
+#include
+#include
+
+using namespace std;
+
+typedef pair pii;
+
+const int MAX_HEIGHT = 257;
+const int INF = 987'654'321;
+
+// 모든 땅의 높이를 height로 만드는 비용 계산
+int calcCost(int height, int n, int m, int b, vector>& blocks) {
+ int cost = 0;
+ int added = 0; // 추가해야 하는 블록의 총 개수
+ int removed = 0; // 제거해야 하는 블록의 총 개수
+
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < m; j++) {
+ int gap = abs(height - blocks[i][j]);
+
+ if (blocks[i][j] > height) {
+ // 목표 높이보다 높은 칸인 경우, gap개의 블록 제거
+ removed += gap;
+ }
+ else if (blocks[i][j] < height) {
+ // 목표 높이보다 낮은 칸인 경우, gap개의 블록 추가
+ added += gap;
+ }
+ }
+ }
+
+ // 전체 비용 계산
+ cost = 2 * removed + added;
+
+ // 블록 개수가 부족하다면 모든 땅의 높이를 height로 만드는 것이 불가능
+ return (added > (b + removed)) ? INF : cost;
+}
+
+// 모든 땅의 높이를 같게 만드는 최소 비용과 그 때의 땅의 높이
+pii makeGroundEven(int n, int m, int b, vector>& ground) {
+ int minCost = INF;
+ int height = 0;
+
+ // 모든 높이를 다 만들어보고 최소 비용 찾기
+ for (int i = 0; i < MAX_HEIGHT; i++) {
+ int cost = calcCost(i, n, m, b, ground);
+ if (cost <= minCost) {
+ minCost = cost;
+ height = i;
+ }
+ }
+
+ return {minCost, height};
+}
+
+/**
+ * 블록 높이의 최댓값이 256밖에 되지 않으므로
+ * 모든 칸을 높이 n(0~256)으로 만드는 모든 경우를 시도해보고
+ * 그 중에서 비용이 최소가 될 때를 찾는다.
+ *
+ * 모든 칸을 높이 n으로 만드는
+ */
+
+int main() {
+ int n, m, b;
+
+ // 입력
+ cin >> n >> m >> b;
+ vector> ground(n, vector(m));
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < m; j++) {
+ cin >> ground[i][j];
+ }
+ }
+
+ // 연산
+ pii answer = makeGroundEven(n, m, b, ground);
+
+ // 출력
+ cout << answer.first << " " << answer.second << "\n";
+
+ return 0;
+}
\ No newline at end of file
diff --git "a/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\355\225\204\354\210\230/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251" "b/06_\352\267\270\353\246\254\353\224\224 \354\225\214\352\263\240\353\246\254\354\246\230/\355\225\204\354\210\230/\355\214\214\354\235\274\354\227\205\353\241\234\353\223\234\354\232\251"
deleted file mode 100644
index e69de29b..00000000
diff --git a/07_DFS & BFS/README.md b/07_DFS & BFS/README.md
new file mode 100644
index 00000000..2e70e8df
--- /dev/null
+++ b/07_DFS & BFS/README.md
@@ -0,0 +1,76 @@
+# DFS & BFS
+
+[메인으로 돌아가기](https://github.com/Altu-Bitu-Official/Altu-Bitu-4)
+
+## 💻 튜터링
+
+### 라이브 코딩
+
+|문제 번호|문제 이름|난이도|풀이 링크|분류|
+| :-----: | :-----: | :-----: | :-----: | :-----: |
+|1260|DFS와 BFS||[C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/07_DFS%20%26%20BFS/%EB%9D%BC%EC%9D%B4%EB%B8%8C%20%EC%BD%94%EB%94%A9/1260.cpp)|DFS, BFS|
+|2606|바이러스||[C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/07_DFS%20%26%20BFS/%EB%9D%BC%EC%9D%B4%EB%B8%8C%20%EC%BD%94%EB%94%A9/2606.cpp)|DFS, BFS|
+|7576|토마토||[C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/07_DFS%20%26%20BFS/%EB%9D%BC%EC%9D%B4%EB%B8%8C%20%EC%BD%94%EB%94%A9/7576.cpp)|BFS|
+
+## ✏️ 과제
+
+### 마감기한
+
+~ 4 / 4 (화) 18:59 - 과제 제출
+~ 4 / 6 (목) 23:59 - 추가 제출
+
+### 필수
+
+| 문제 번호 | 문제 이름 | 난이도 | 풀이 링크 | 분류 |
+| :---------------------------------------------------------------------: | :------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------: | :-------: | :---------------: |
+| 2615 | 오목 | | [C++_v1](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/07_DFS%20%26%20BFS/%ED%95%84%EC%88%98/2615_v1.cpp) [C++_v2](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/07_DFS%20%26%20BFS/%ED%95%84%EC%88%98/2615_v2.cpp) | 구현, 브루트 포스 |
+| 4963 | 섬의 개수 | | [C++_v1](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/07_DFS%20%26%20BFS/%ED%95%84%EC%88%98/4963_v1.cpp) [C++_v2](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/07_DFS%20%26%20BFS/%ED%95%84%EC%88%98/4963_v2.cpp) | DFS, BFS |
+| 1325 | 효율적인 해킹 | | [C++_v1](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/07_DFS%20%26%20BFS/%ED%95%84%EC%88%98/1325_v1.cpp) [C++_v2](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/07_DFS%20%26%20BFS/%ED%95%84%EC%88%98/1325_v2.cpp) | DFS, BFS |
+
+### 도전
+
+| 문제 번호 | 문제 이름 | 난이도 | 풀이 링크 | 분류 |
+| :-------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------: | :-------: | :--: |
+| 프로그래머스 | 게임 맵 최단거리 | **Lv.2** | [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/07_DFS%20%26%20BFS/%EB%8F%84%EC%A0%84/%EA%B2%8C%EC%9E%84_%EB%A7%B5_%EC%B5%9C%EB%8B%A8%EA%B1%B0%EB%A6%AC.cpp) | BFS |
+| 19538 | 루머 | | [C++](https://github.com/Altu-Bitu-Official/Altu-Bitu-4/blob/main/07_DFS%20%26%20BFS/%EB%8F%84%EC%A0%84/19538.cpp) | BFS |
+
+---
+
+### 힌트
+
+
+오목
+
+ 여섯 알 이상이 연속이면 오목으로 인정하지 않고, 딱 다섯 알이 연속인 경우에는 가장 왼쪽 위에 있는 돌을 출력한다는 조건을 잘 기억해주세요! 이 조건을 잘 응용해보면 탐색 방향도 정해볼 수 있겠네요.
+
+
+
+
+섬의 개수
+
+ 탐색을 한 번 하면 하나의 영역을 구할 수 있어요!
+
+
+
+
+효율적인 해킹
+
+ a가 b를 신뢰할 때, b를 해킹하면 a도 해킹할 수 있어요. 인접 리스트를 이용해서 단방향 그래프를 구현해볼까요?
+
+
+
+
+게임 맵 최단거리
+
+ 최단거리를 구하는 문제네요. BFS를 사용해볼까요?
+
+
+
+
+루머
+
+ 주변인의 절반 이상이 루머를 믿을 때 본인도 루머를 믿어요! 루머를 믿는 사람은 자신의 주변인에게 루머를 "동시에" 퍼뜨리고 있다는 것을 주의해주세요.
+
+
+
+---
diff --git "a/07_DFS & BFS/\352\260\225\354\235\230 \354\236\220\353\243\214/07_DFS&BFS_\353\254\270\354\240\234\355\225\264\354\204\244.pdf" "b/07_DFS & BFS/\352\260\225\354\235\230 \354\236\220\353\243\214/07_DFS&BFS_\353\254\270\354\240\234\355\225\264\354\204\244.pdf"
new file mode 100644
index 00000000..435236ba
Binary files /dev/null and "b/07_DFS & BFS/\352\260\225\354\235\230 \354\236\220\353\243\214/07_DFS&BFS_\353\254\270\354\240\234\355\225\264\354\204\244.pdf" differ
diff --git "a/07_DFS & BFS/\352\260\225\354\235\230 \354\236\220\353\243\214/07_DFS&BFS_\354\235\264\353\241\240.pdf" "b/07_DFS & BFS/\352\260\225\354\235\230 \354\236\220\353\243\214/07_DFS&BFS_\354\235\264\353\241\240.pdf"
new file mode 100644
index 00000000..11602688
Binary files /dev/null and "b/07_DFS & BFS/\352\260\225\354\235\230 \354\236\220\353\243\214/07_DFS&BFS_\354\235\264\353\241\240.pdf" differ
diff --git "a/07_DFS & BFS/\353\217\204\354\240\204/19538.cpp" "b/07_DFS & BFS/\353\217\204\354\240\204/19538.cpp"
new file mode 100644
index 00000000..38abce2d
--- /dev/null
+++ "b/07_DFS & BFS/\353\217\204\354\240\204/19538.cpp"
@@ -0,0 +1,83 @@
+#include
+#include
+#include
+#include
+
+using namespace std;
+
+const int NOT_BELIEVE = -1;
+
+vector bfs(int n, vector> &adj_list, vector &spreader) {
+ vector result(n+1, NOT_BELIEVE); // 루머 믿기 시작한 시간
+ vector adj_believer_cnt(n+1, 0); // 루머를 믿는 주변인의 수
+ queue q;
+
+ for(int i = 0; i < spreader.size(); i++) { // 루머 유포자 세팅
+ int p = spreader[i]; // 루머 유포자 p
+ result[p] = 0; // (== 루머 유포자는 처음부터 루머를 믿고 있기 때문에 0초 세팅)
+ q.push(p);
+ }
+
+ while(!q.empty()) {
+ int node = q.front(); // 루머를 믿는 node
+ int w = result[node]; // node가 루머를 믿기 시작한 시간
+ q.pop();
+
+ for(int i = 0; i < adj_list[node].size(); i++) {
+ /*
+ * node가 주변인 next_node에게 루머를 유포하고자 한다.
+ * node가 루머를 믿고 있으므로 루머를 믿는 next_node의 주변인의 수가 증가한다.
+ */
+ int next_node = adj_list[node][i];
+ adj_believer_cnt[next_node]++; // (== next_node의 주변인 node가 루머를 믿는다)
+
+ /*
+ * [next_node가 루머를 믿기 시작하는 경우]
+ * 1. 아직 루머를 믿고 있지 않으며
+ * 2. next_node의 주변인의 절반 이상이 루머를 믿고 있다.
+ */
+ if(result[next_node] == NOT_BELIEVE && adj_believer_cnt[next_node] >= ceil((float) adj_list[next_node].size() / 2)) {
+ result[next_node] = w+1;
+ q.push(next_node);
+ }
+ }
+ }
+ return result;
+}
+
+/*
+ * [루머 유포하기]
+ * 전제조건 : "주변인의 절반 이상이 루머를 믿을 때 본인도 루머를 믿는다."
+ * -> 루머를 믿는 주변인의 수를 계산해야 한다.
+*/
+
+int main() {
+ int n, m, p;
+ vector> adj_list;
+ vector spreader; // 루머 유포자 번호 저장
+
+ // 입력
+ cin >> n;
+ adj_list.assign(n+1, vector (0));
+ for(int i = 1; i <= n; i++) { // i사람 주변인 입력
+ while(true) {
+ cin >> p;
+ if(p == 0) {
+ break;
+ }
+ adj_list[i].push_back(p);
+ }
+ }
+ cin >> m;
+ spreader.assign(m, 0);
+ for(int i = 0; i < m; i++) {
+ cin >> spreader[i];
+ }
+
+ // 연산 & 출력
+ vector result = bfs(n, adj_list, spreader);
+ for(int i = 1; i <= n; i++) {
+ cout << result[i] << ' ';
+ }
+ return 0;
+}
\ No newline at end of file
diff --git "a/07_DFS & BFS/\353\217\204\354\240\204/\352\262\214\354\236\204_\353\247\265_\354\265\234\353\213\250\352\261\260\353\246\254.cpp" "b/07_DFS & BFS/\353\217\204\354\240\204/\352\262\214\354\236\204_\353\247\265_\354\265\234\353\213\250\352\261\260\353\246\254.cpp"
new file mode 100644
index 00000000..829f049d
--- /dev/null
+++ "b/07_DFS & BFS/\353\217\204\354\240\204/\352\262\214\354\236\204_\353\247\265_\354\265\234\353\213\250\352\261\260\353\246\254.cpp"
@@ -0,0 +1,62 @@
+#include
+#include
+#include
+
+using namespace std;
+
+typedef pair pi;
+int dr[4] = {-1, 1, 0, 0};
+int dc[4] = {0, 0, -1, 1};
+
+const int NOT_VISITED = -1;
+
+int bfs(vector> &maps) { // 상대 팀 진영에 도착하기 이해 지나가야 하는 칸의 수 반환
+ int n = maps.size(), m = maps[0].size();
+ vector> w(n, vector (m, NOT_VISITED)); // 해당 칸까지 가기 위해 지나가야 하는 칸 수
+ queue q;
+
+ // 시작점 push
+ q.push({0, 0});
+ w[0][0] = 1;
+
+ while(!q.empty()) {
+ int r = q.front().first;
+ int c = q.front().second;
+ if(r == n-1 && c == m-1) { // 상대팀 진영에 도착한 경우
+ return w[n-1][m-1];
+ }
+ int weight = w[r][c]; // (r,c)까지 이동하는데 지나간 칸의 수
+ q.pop();
+
+ for(int i = 0; i < 4; i++) {
+ int nr = r + dr[i];
+ int nc = c + dc[i];
+
+ // 다음 칸으로 이동할 수 있는 경우 (== 벽이 아니고 방문한 적이 없는 칸인 경우)
+ if(nr >= 0 && nr < n && nc >= 0 && nc < m && maps[nr][nc] && w[nr][nc] == NOT_VISITED) {
+ q.push({nr, nc});
+ w[nr][nc] = weight+1;
+ }
+ }
+ }
+ return w[n-1][m-1];
+}
+
+int solution(vector > maps)
+{
+ return bfs(maps);
+}
+
+/*
+ * 상대 팀 진영에 도착하기 위해 지나가야 하는 칸의 개수 구하기
+ * == 최단 거리 구하기
+ * -> bfs를 이용한다!
+*/
+
+int main() {
+ vector> maps = {{1,0,1,1,1},{1,0,1,0,1},{1,0,1,1,1},{1,1,1,0,1},{0,0,0,0,1}};
+
+ // 연산 & 출력
+ cout << solution(maps);
+ return 0;
+}
\ No newline at end of file
diff --git "a/07_DFS & BFS/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/1260.cpp" "b/07_DFS & BFS/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/1260.cpp"
new file mode 100644
index 00000000..d7f8e297
--- /dev/null
+++ "b/07_DFS & BFS/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/1260.cpp"
@@ -0,0 +1,101 @@
+#include
+#include
+#include
+#include
+
+using namespace std;
+
+vector visited_recur;
+
+vector dfs(int n, int v, vector> &edge) {
+ vector result;
+ vector visited (n+1, false);
+ stack s;
+
+ s.push(v);
+ visited[v] = true;
+ result.push_back(v);
+
+ while(!s.empty()) {
+ int node = s.top();
+ bool child = false;
+
+ for(int i = 1; i <= n; i++) {
+ if(edge[node][i] && !visited[i]) {
+ child = true;
+ s.push(i);
+ visited[i] = true;
+ result.push_back(i);
+ break;
+ }
+ }
+ if(!child) {
+ s.pop();
+ }
+ }
+ return result;
+}
+
+void dfsRecur(int n, int node, vector> &edge) {
+ visited_recur[node] = true;
+ cout << node << ' ';
+
+ for(int i = 1; i <= n; i++) {
+ if(edge[node][i] && !visited_recur[i]) {
+ dfsRecur(n, i, edge);
+ }
+ }
+}
+
+vector bfs(int n, int v, vector> &edge) {
+ vector result;
+ vector visited (n+1, false);
+ queue q;
+
+ q.push(v);
+ visited[v] = true;
+
+ while(!q.empty()) {
+ int node = q.front();
+ q.pop();
+ result.push_back(node);
+
+ for(int i = 1; i <= n; i++) {
+ if(edge[node][i] && !visited[i]) {
+ q.push(i);
+ visited[i] = true;
+ }
+ }
+ }
+ return result;
+}
+
+int main() {
+ int n, m, v, n1, n2;
+ vector> edge;
+
+ // 입력
+ cin >> n >> m >> v;
+ edge.assign(n+1, vector (n+1, false));
+ visited_recur.assign(n+1, false);
+ while(m--) {
+ cin >> n1 >> n2;
+ edge[n1][n2] = true;
+ edge[n2][n1] = true;
+ }
+
+ // 연산
+ vector dfs_result = dfs(n, v, edge);
+ vector bfs_result = bfs(n, v, edge);
+
+ // 출력
+ for(int i = 0; i < dfs_result.size(); i++) {
+ cout << dfs_result[i] << ' ';
+ }
+ cout << '\n';
+ //dfsRecur(n, v, edge);
+ for(int i = 0; i < bfs_result.size(); i++) {
+ cout << bfs_result[i] << ' ';
+ }
+ return 0;
+}
\ No newline at end of file
diff --git "a/07_DFS & BFS/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/2606.cpp" "b/07_DFS & BFS/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/2606.cpp"
new file mode 100644
index 00000000..99f76b09
--- /dev/null
+++ "b/07_DFS & BFS/\353\235\274\354\235\264\353\270\214 \354\275\224\353\224\251/2606.cpp"
@@ -0,0 +1,69 @@
+#include
+#include
+#include 
| [C++]() | 구현 |
-|