diff --git a/.DS_Store b/.DS_Store
deleted file mode 100644
index d61688b..0000000
Binary files a/.DS_Store and /dev/null differ
diff --git a/1. Recursion & Brute Force/.DS_Store b/1. Recursion & Brute Force/.DS_Store
deleted file mode 100644
index 3eb8c3e..0000000
Binary files a/1. Recursion & Brute Force/.DS_Store and /dev/null differ
diff --git a/1. Recursion & Brute Force/APSS_boardcover_sungchan/.DS_Store b/1. Recursion & Brute Force/APSS_boardcover_sungchan/.DS_Store
deleted file mode 100644
index f6e1c96..0000000
Binary files a/1. Recursion & Brute Force/APSS_boardcover_sungchan/.DS_Store and /dev/null differ
diff --git a/1. Recursion & Brute Force/APSS_clocksync_sungchan/.DS_Store b/1. Recursion & Brute Force/APSS_clocksync_sungchan/.DS_Store
deleted file mode 100644
index a11fded..0000000
Binary files a/1. Recursion & Brute Force/APSS_clocksync_sungchan/.DS_Store and /dev/null differ
diff --git a/1. Recursion & Brute Force/APSS_picnic_sungchan/.DS_Store b/1. Recursion & Brute Force/APSS_picnic_sungchan/.DS_Store
deleted file mode 100644
index b4e0d27..0000000
Binary files a/1. Recursion & Brute Force/APSS_picnic_sungchan/.DS_Store and /dev/null differ
diff --git a/1. Recursion & Brute Force/BJ_14501_sungchan/resign.cpp b/1. Recursion & Brute Force/BJ_14501_sungchan/resign.cpp
new file mode 100644
index 0000000..27bd217
--- /dev/null
+++ b/1. Recursion & Brute Force/BJ_14501_sungchan/resign.cpp	
@@ -0,0 +1,26 @@
+//
+// Created by 진성찬 on 2022/01/08.
+//
+
+#include <iostream>
+using namespace std;
+int N, *T, *P;
+
+int revenue(int start) {
+    int on, off;
+    if(start >= N) return 0;
+    if(start + T[start] > N) on = 0;
+    else on = P[start] + revenue(start+T[start]);
+    off = revenue(start+1);
+    return max(on, off);
+}
+
+int main() {
+    cin >> N;
+    T = new int[N];
+    P = new int[N];
+    for(int i = 0; i < N; i++) {
+        cin >> T[i] >> P[i];
+    }
+    cout << revenue(0);
+}
\ No newline at end of file
diff --git a/1. Recursion & Brute Force/BJ_2448_sungchan/star.cpp b/1. Recursion & Brute Force/BJ_2448_sungchan/star.cpp
new file mode 100644
index 0000000..76256a2
--- /dev/null
+++ b/1. Recursion & Brute Force/BJ_2448_sungchan/star.cpp	
@@ -0,0 +1,60 @@
+//
+// Created by 진성찬 on 2022/01/08.
+//
+
+
+#include <iostream>
+#include <string>
+#include <vector>
+using namespace std;
+int N;
+string stars = "  *  \n"
+               " * * \n"
+               "*****";
+
+string star(int N);
+
+vector<string> split(string s, string divid) {
+    vector<string> v;
+    int start = 0;
+    int d = s.find(divid);
+    while(d != -1) {
+        v.push_back(s.substr(start, d-start));
+        start = d + 1;
+        d = s.find(divid, start);
+    }
+    v.push_back(s.substr(start, d - start));
+    return v;
+}
+
+string combine(int N) {
+    string one = star(N);
+    vector<string> lines = split(one, "\n");
+
+    string two = "";
+    for(int i = 0; i < N; i++) {
+        two += lines.at(i);
+        two += " ";
+        two += lines.at(i);
+        if(i != N-1) two += "\n";
+    }
+
+    string new_lines = "";
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) new_lines += ' ';
+        new_lines += lines.at(i);
+        for(int j = 0; j < N; j++) new_lines += ' ';
+        new_lines += "\n";
+    }
+    return new_lines + two;
+}
+
+string star(int N) {
+    if(N == 3) return stars;
+    else return combine(N/2);
+}
+
+int main() {
+    cin >> N;
+    cout << star(N);
+}
diff --git a/1. Recursion & Brute Force/BJ_3080_sungchan/.idea/misc.xml b/1. Recursion & Brute Force/BJ_3080_sungchan/.idea/misc.xml
new file mode 100644
index 0000000..79b3c94
--- /dev/null
+++ b/1. Recursion & Brute Force/BJ_3080_sungchan/.idea/misc.xml	
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
+</project>
\ No newline at end of file
diff --git a/1. Recursion & Brute Force/BJ_3080_sungchan/.idea/modules.xml b/1. Recursion & Brute Force/BJ_3080_sungchan/.idea/modules.xml
new file mode 100644
index 0000000..e87152d
--- /dev/null
+++ b/1. Recursion & Brute Force/BJ_3080_sungchan/.idea/modules.xml	
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/백준_3080_sungchan.iml" filepath="$PROJECT_DIR$/.idea/백준_3080_sungchan.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file
diff --git a/1. Recursion & Brute Force/BJ_3080_sungchan/.idea/vcs.xml b/1. Recursion & Brute Force/BJ_3080_sungchan/.idea/vcs.xml
new file mode 100644
index 0000000..b2bdec2
--- /dev/null
+++ b/1. Recursion & Brute Force/BJ_3080_sungchan/.idea/vcs.xml	
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
+  </component>
+</project>
\ No newline at end of file
diff --git "a/1. Recursion & Brute Force/BJ_3080_sungchan/.idea/\353\260\261\354\244\200_3080_sungchan.iml" "b/1. Recursion & Brute Force/BJ_3080_sungchan/.idea/\353\260\261\354\244\200_3080_sungchan.iml"
new file mode 100644
index 0000000..f08604b
--- /dev/null
+++ "b/1. Recursion & Brute Force/BJ_3080_sungchan/.idea/\353\260\261\354\244\200_3080_sungchan.iml"	
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module classpath="CMake" type="CPP_MODULE" version="4" />
\ No newline at end of file
diff --git a/1. Recursion & Brute Force/BJ_3080_sungchan/beautifulname.cpp b/1. Recursion & Brute Force/BJ_3080_sungchan/beautifulname.cpp
new file mode 100644
index 0000000..a95c2c8
--- /dev/null
+++ b/1. Recursion & Brute Force/BJ_3080_sungchan/beautifulname.cpp	
@@ -0,0 +1,92 @@
+#include <iostream>
+#include <algorithm>
+#define MOD 1000000007
+int N;
+using namespace std;
+string* names;
+int* start_num;
+int* end_num;
+long long factorial[28];
+
+bool comp(string s1, string s2) {
+    return s1 < s2;
+}
+
+void mutual_finder(string* names) {
+    start_num = new int[N-1];
+    end_num = new int[N-1];
+    for(int i = 0; i < N - 1; i++) { // finding mutual string between names[i] and names[i+1]
+        string mutual = "";
+        int len1 = names[i].size();
+        int len2 = names[i+1].size();
+        for(int j = 0; j < len1; j++) {
+            if(j >= len2) break;
+            else if(names[i][j] == names[i+1][j]) mutual += names[i][j];
+            else break;
+        }
+        if(mutual == "") {
+            start_num[i] = 0;
+            end_num[i] = N-1;
+        } else {
+            int mutual_size = mutual.size();
+            bool start_done = false;
+            for(int j = 0; j <= i; j++) {
+                if(names[j].size() < mutual_size) continue;
+                for(int k = 0; k < mutual_size; k++) {
+                    if(mutual[k] != names[j][k]) break;
+                    if(k == mutual_size - 1) {
+                        start_done = true;
+                        start_num[i] = j;
+                    }
+                }
+                if(start_done) break;
+            }
+            bool end_done = false;
+            for(int j = N-1; j >= i+1; j--) {
+                if(names[j].size() < mutual_size) continue;
+                for(int k = 0; k < mutual_size; k++) {
+                    if(mutual[k] != names[j][k]) break;
+                    if(k == mutual_size - 1) {
+                        end_done = true;
+                        end_num[i] = j;
+                    }
+                }
+                if(end_done) break;
+            }
+        }
+    }
+    factorial[0] = 1;
+    for(int i = 1; i <= 27; i++) factorial[i] = (i * factorial[i-1]) % MOD;
+}
+
+int counter(int start, int end) {
+    if(start == end) return 1;
+    else if(start + 1 == end) return 2;
+
+    int index_number = 0;
+    int* index = new int[end-start];
+    for(int i = start; i < end; i++) {
+        if(start_num[i] == start && end_num[i] == end) {
+            index[index_number++] = i;
+        }
+    }
+    index[index_number] = end;
+
+    long long count = (factorial[index_number + 1] * counter(start, index[0])) % MOD;
+    for(int i = 0; i < index_number; i++) {
+        count = (count * counter(index[i] + 1, index[i+1])) % MOD;
+    }
+
+    return count;
+}
+
+int main() {
+    cin >> N;
+    names = new string[N];
+    for(int i = 0; i < N; i++) {
+        cin >> names[i];
+    }
+    sort(names, names+N, comp);
+    mutual_finder(names);
+    cout << counter(0, N-1);
+}
diff --git a/2. DC & DP/APSS_fanmeeting_sungchan/fanmeeting.cpp b/2. DC & DP/APSS_fanmeeting_sungchan/fanmeeting.cpp
new file mode 100644
index 0000000..cfa578d
--- /dev/null
+++ b/2. DC & DP/APSS_fanmeeting_sungchan/fanmeeting.cpp	
@@ -0,0 +1,80 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+int C;
+
+vector<int> multiply(const vector<int>& a, const vector<int>& b) {
+    vector<int> c(a.size() + b.size(), 0);
+    for(int i = 0; i < a.size(); i++)
+        for(int j = 0; j < b.size(); j++)
+            c[i+j] += a[i] * b[j];
+    return c;
+}
+
+void addTo(vector<int>& a, const vector<int>& b, int k) {
+    if(a.size() < b.size() + k) {
+        for(int i = a.size(); i < b.size() + k; i++) a.push_back(0);
+    }
+    for(int i = 0; i < b.size(); i++) a[i+k] += b[i];
+}
+
+void subFrom(vector<int>& a, const vector<int>& b) {
+    for(int i = 0; i < b.size(); i++) a[i] -= b[i];
+}
+
+vector<int> karatsuba(vector<int> a, vector<int> b) {
+    int an = a.size(), bn = b.size();
+    if(an < bn) return karatsuba(b, a);
+    if(an == 0 || bn == 0) return vector<int>();
+    if(an <= 100) return multiply(a, b);
+    int half = an / 2;
+
+    vector<int> a0(a.begin(), a.begin() + half);
+    vector<int> a1(a.begin() + half, a.end());
+    vector<int> b0(b.begin(), b.begin() + min<int>(b.size(), half));
+    vector<int> b1(b.begin() + min<int>(b.size(), half), b.end());
+    vector<int> z2 = karatsuba(a1, b1);
+    vector<int> z0 = karatsuba(a0, b0);
+
+    addTo(a0, a1, 0);
+    addTo(b0, b1, 0);
+    vector<int> z1 = karatsuba(a0, b0);
+    subFrom(z1, z0);
+    subFrom(z1, z2);
+
+    vector<int> ret;
+    addTo(ret, z0, 0);
+    addTo(ret, z1, half);
+    addTo(ret, z2, half + half);
+
+    return ret;
+}
+
+int counter(string members, string fans, bool trim) {
+    int member_size = members.size();
+    int fan_size = fans.size();
+
+    vector<int> male_member(member_size), male_fan(fan_size);
+    for(int i = 0; i < member_size; i++) male_member[i] = (members[i] == 'M');
+    for(int i = 0; i < fan_size; i++) male_fan[i] = (fans[fan_size - i - 1] == 'M');
+    vector<int> karatsubas = karatsuba(male_member, male_fan);
+    int answer = 0;
+    for(int i  = member_size - 1; i < fan_size; i++) {
+        if(karatsubas[i] == 0) answer++;
+    }
+    return answer;
+}
+
+int main() {
+    cin >> C;
+    string* members = new string[C];
+    string* fans = new string[C];
+    for(int i = 0; i < C; i++) {
+        cin >> members[i];
+        cin >> fans[i];
+    }
+
+    for(int i = 0; i < C; i++) {
+        cout << counter(members[i], fans[i], false) << endl;
+    }
+}
\ No newline at end of file
diff --git a/2. DC & DP/APSS_fence_sungchan/fence.cpp b/2. DC & DP/APSS_fence_sungchan/fence.cpp
new file mode 100644
index 0000000..7277df6
--- /dev/null
+++ b/2. DC & DP/APSS_fence_sungchan/fence.cpp	
@@ -0,0 +1,111 @@
+
+#include <iostream>
+#include <vector>
+using namespace std;
+int C, num, height;
+vector<vector<int>> boards;
+
+int rectangle(vector<int> board) {
+    int size = board.size();
+    if(size == 1) return board.at(0);
+    if(size == 2) return max(max(board.at(0), board.at(1)), 2 * min(board.at(0), board.at(1)));
+
+    vector<int> left(board.begin(), board.begin() + size/2);
+    vector<int> right(board.begin() + size/2, board.begin() + size);
+    int left_max = rectangle(left);
+    int right_max = rectangle(right);
+
+    int height = min(board.at(size/2 - 1), board.at(size/2));
+    int mid_max = 2 * height;
+
+    int left_index = -1;
+    for(int i = size/2 - 2; i >= 0; i--) {
+        if(board.at(i) >= height) mid_max += height;
+        else {
+            left_index = i;
+            break;
+        }
+    }
+
+    int right_index = -1;
+    for(int i = size/2 + 1; i < size; i++) {
+        if(board.at(i) >= height) mid_max += height;
+        else {
+            right_index = i;
+            break;
+        }
+    }
+
+    if(left_index != -1) {
+        if(right_index != -1) {
+            int max_height = height;
+            while(true) {
+                if(left_index < 0) {
+                    if(right_index == size) break;
+                    max_height = min(max_height, board.at(right_index));
+                    if(max_height * (right_index + 1) > mid_max) mid_max = max_height * (right_index + 1);
+                    right_index++;
+                } else if (right_index == size) {
+                    max_height = min(max_height, board.at(left_index));
+                    if(max_height * (size - left_index) > mid_max) mid_max = max_height * (size - left_index);
+                    left_index--;
+                } else {
+                    int left_height = board.at(left_index);
+                    int right_height = board.at(right_index);
+                    if(left_height >= right_height && left_height <= max_height) {
+                        max_height = left_height;
+                        if((right_index - left_index) * max_height > mid_max) mid_max = (right_index - left_index) * max_height;
+                        left_index--;
+                    } else if(right_height > left_height && right_height <= max_height) {
+                        max_height = right_height;
+                        if((right_index - left_index) * max_height > mid_max) mid_max = (right_index - left_index) * max_height;
+                        right_index++;
+                    } else if(max_height >= left_height) {
+                        if((right_index - left_index) * max_height > mid_max) mid_max = (right_index - left_index) * max_height;
+                        right_index++;
+                    } else if(max_height >= right_height) {
+                        if((right_index - left_index) * max_height > mid_max) mid_max = (right_index - left_index) * max_height;
+                        left_index--;
+                    } else {
+                        if((right_index - left_index + 1) * max_height > mid_max) mid_max = (right_index - left_index + 1) * max_height;
+                        left_index--;
+                        right_index++;
+                    }
+                }
+            }
+        } else { // right_index == -1
+            int new_height = board.at(left_index);
+            if(new_height * (size - left_index) > mid_max) mid_max = new_height * (size - left_index);
+            for(int i = left_index - 1; i >= 0; i--) {
+                new_height = min(new_height, board.at(i));
+                if(new_height * (size - i) > mid_max) mid_max = new_height * (size - i);
+            }
+        }
+    } else if(right_index != -1) { // left_index == -1
+        int new_height = board.at(right_index);
+        if(new_height * (right_index + 1) > mid_max) mid_max = new_height * (right_index + 1);
+        for(int i = right_index + 1; i < size; i++) {
+            new_height = min(new_height, board.at(i));
+            if(new_height * (i + 1) > mid_max) mid_max = new_height * (i + 1);
+        }
+    }
+
+    return max(max(left_max, right_max), mid_max);
+}
+
+int main() {
+    cin >> C;
+    for(int i = 0; i < C; i++) {
+        cin >> num;
+        vector<int> board;
+        boards.push_back(board);
+        for(int j = 0; j < num; j++) {
+            cin >> height;
+            boards.at(i).push_back(height);
+        }
+    }
+
+    for(int i = 0; i < C; i++) {
+        cout << rectangle(boards.at(i)) << endl;
+    }
+}
\ No newline at end of file
diff --git a/2. DC & DP/APSS_quadtree_sungchan/quadtree.cpp b/2. DC & DP/APSS_quadtree_sungchan/quadtree.cpp
new file mode 100644
index 0000000..7793429
--- /dev/null
+++ b/2. DC & DP/APSS_quadtree_sungchan/quadtree.cpp	
@@ -0,0 +1,41 @@
+//
+// Created by 진성찬 on 2022/01/13.
+//
+
+#include <iostream>
+using namespace std;
+int C;
+
+string upside_down(string input) {
+    if(input.size() == 1) return input;
+    int* index = new int[5];
+    index[0] = 1;
+    for(int i = 1; i < 4; i++) {
+        int x_num = 0;
+        int other_num = 0;
+        int idx = index[i-1];
+        while(x_num * 3 + 1 != other_num) {
+            if(input.at(idx++) == 'x') x_num++;
+            else other_num++;
+        }
+        index[i] = idx;
+    }
+    index[4] = input.size();
+
+    string* substring = new string[4];
+    for(int i = 0; i < 4; i++) {
+        substring[i] = upside_down(input.substr(index[i], index[i+1] - index[i]));
+    }
+    return "x" + substring[2] + substring[3] + substring[0] + substring[1];
+}
+
+int main() {
+    cin >> C;
+    string* images = new string[C];
+    for(int i = 0; i < C; i++) {
+        cin >> images[i];
+    }
+    for(int i = 0; i < C; i++) {
+        cout << upside_down(images[i]) << endl;
+    }
+}
\ No newline at end of file
diff --git a/2. DC & DP/APSS_quantization_sungchan/quantization.cpp b/2. DC & DP/APSS_quantization_sungchan/quantization.cpp
new file mode 100644
index 0000000..52b9b4b
--- /dev/null
+++ b/2. DC & DP/APSS_quantization_sungchan/quantization.cpp	
@@ -0,0 +1,61 @@
+#include <iostream>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+int C;
+int seq[50][100];
+int length[50];
+int quant[50];
+int cache[100][100][10];
+
+int getErrorSum(int* seq, int start, int end) {
+    int sum = 0;
+    for(int i = start; i <= end; i++) sum += seq[i];
+    int mean = round((float) sum / (float) (end - start + 1));
+    int errorsum = 0;
+    for(int i = start; i <= end; i++) errorsum += (mean - seq[i]) * (mean - seq[i]);
+    return errorsum;
+}
+
+
+int quantize(int* sequence, int quant, int length, int start, int end) {
+    if(length <= quant) return 0;
+    if(cache[start][end][quant-1] != -1) return cache[start][end][quant-1];
+    int minimum = getErrorSum(sequence, start, end);
+    if(quant == 1) {
+        cache[start][end][0] = minimum;
+        return minimum;
+    }
+    for(int i = start; i <= end - quant + 1; i++) {
+        int error = getErrorSum(sequence, start, i) + quantize(sequence, quant-1, length-(i-start+1), i+1, end);
+        if(error < minimum) minimum = error;
+    }
+    cache[start][end][quant-1] = minimum;
+    return minimum;
+}
+
+void initialize() {
+    for(int i = 0; i < 100; i++)
+        for(int j = 0; j < 100; j++)
+            for(int k = 0; k < 10; k++)
+                cache[i][j][k] = -1;
+}
+
+int main() {
+    cin >> C;
+    for(int i = 0; i < C; i++) {
+        cin >> length[i];
+        cin >> quant[i];
+        for(int j = 0; j < length[i]; j++){
+            cin >> seq[i][j];
+        }
+        sort(seq[i], seq[i] + length[i]);
+    }
+
+    for(int i = 0; i < C; i++) {
+        initialize();
+        cout << quantize(seq[i], quant[i], length[i], 0, length[i]-1) << endl;
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/2. DC & DP/APSS_wildcard_sungchan/wildcard.cpp b/2. DC & DP/APSS_wildcard_sungchan/wildcard.cpp
new file mode 100644
index 0000000..418a9ea
--- /dev/null
+++ b/2. DC & DP/APSS_wildcard_sungchan/wildcard.cpp	
@@ -0,0 +1,75 @@
+#include <iostream>
+#include <algorithm>
+using namespace std;
+int C;
+string* W;
+string** files;
+
+bool comp(string s1, string s2) {
+    return s1 < s2;
+}
+
+bool matchMemoized(const string& W, const string& S, int w, int s, int cache[101][101]) {
+    int& ret = cache[w][s];
+    if(ret != -1) return ret;
+    if(w < W.size() && s < S.size() && W[w] == '?' || W[w] == S[s]) return ret = matchMemoized(W, S, w+1, s+1, cache);
+    if(w == W.size()) return ret = (s == S.size());
+    if(W[w] == '*') {
+        if(matchMemoized(W, S, w+1, s, cache) || (s < S.size() && matchMemoized(W, S, w, s+1, cache))) return ret = 1;
+    }
+    return ret = 0;
+}
+
+bool match(const string& w, const string& s) {
+    int pos = 0;
+    while(pos < s.size() && pos < w.size() && (w[pos] == '?' || w[pos] == s[pos])) pos++;
+
+    if(pos == w.size()) return pos == s.size();
+    if(w[pos] == '*') {
+        for(int skip = 0; pos+skip <= s.size(); skip++) {
+            if(match(w.substr(pos+1), s.substr(pos+skip))) return true;
+        }
+    }
+    return false;
+}
+
+void finder(string W, string* file_names, int file_number) {
+    int cache[101][101];
+    for(int i = 0; i <= 100; i++)
+        for(int j = 0; j <= 100; j++)
+            cache[i][j] = -1;
+    string* answer = new string[file_number];
+    int answer_num = 0;
+
+    for(int i = 0; i < file_number; i++) {
+        if(match(W, file_names[i])) answer[answer_num++] = file_names[i];
+        //if(matchMemoized(W, file_names[i], 0, 0, cache)) answer[answer_num++] = file_names[i];
+    }
+
+    sort(answer, answer+answer_num, comp);
+    for(int i = 0; i < answer_num; i++) {
+        cout << answer[i] << endl;
+    }
+}
+
+
+int main() {
+    cin >> C;
+    W = new string[C];
+    files = new string*[C];
+    int* files_number = new int[C];
+    for(int i = 0; i < C; i++) {
+        cin >> W[i];
+        int n;
+        cin >> n;
+        files[i] = new string[n];
+        files_number[i] = n;
+        for(int j = 0; j < n; j++) {
+            cin >> files[i][j];
+        }
+    }
+
+    for(int i = 0; i < C; i++) {
+        finder(W[i], files[i], files_number[i]);
+    }
+}
\ No newline at end of file
diff --git a/2. DC & DP/BJ_10830_sungchan/matmul.cpp b/2. DC & DP/BJ_10830_sungchan/matmul.cpp
new file mode 100644
index 0000000..0ca2b83
--- /dev/null
+++ b/2. DC & DP/BJ_10830_sungchan/matmul.cpp	
@@ -0,0 +1,57 @@
+#include <iostream>
+using namespace std;
+int N;
+long long B;
+int** I;
+
+int** product(int** A, int** D) {
+    int** C = new int*[N];
+    for(int i = 0; i < N; i++) {
+        C[i] = new int[N];
+        for(int j = 0; j < N; j++) {
+            C[i][j] = 0;
+            for(int k = 0; k < N; k++) {
+                C[i][j] += (A[i][k] * D[k][j]);
+            }
+            C[i][j] %= 1000;
+        }
+    }
+    return C;
+}
+
+int main() {
+    ios_base::sync_with_stdio(0);
+    cin.tie(0), cout.tie(0);
+
+    cin >> N >> B;
+    int** matrix = new int*[N];
+    for(int i = 0; i < N; i++) {
+        matrix[i] = new int[N];
+        for(int j = 0; j < N; j++) {
+            cin >> matrix[i][j];
+        }
+    }
+
+    I = new int*[N];
+    for(int i = 0; i < N; i++) {
+        I[i] = new int[N];
+        I[i][i] = 1;
+    }
+
+    while(B) {
+        if(B % 2 == 1) {
+            I = product(I, matrix);
+        }
+        matrix = product(matrix, matrix);
+        B /= 2;
+    }
+
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++) {
+            cout << I[i][j] << " ";
+        }
+        cout << endl;
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/2. DC & DP/BJ_1102_sungchan/powerplant.cpp b/2. DC & DP/BJ_1102_sungchan/powerplant.cpp
new file mode 100644
index 0000000..f263347
--- /dev/null
+++ b/2. DC & DP/BJ_1102_sungchan/powerplant.cpp	
@@ -0,0 +1,77 @@
+#include <iostream>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+int N, P;
+int cost[16][16];
+int on[16];
+int off[16];
+int ret[65536];
+
+void memoize(int c, int minimum) {
+    int index = 0;
+    for(int i = 0; i < c; i++) {
+        index += (int) pow(2, on[i]);
+    }
+    ret[index] = minimum;
+}
+
+int memoization(int c) {
+    int index = 0;
+    for(int i = 0; i < c; i++) {
+        index += (int) pow(2, on[i]);
+    }
+    return ret[index];
+}
+
+int answer(int C) {
+    if(C == 0) {
+        if(P == 0) return 0;
+        else return -1;
+    }
+    if(P <= C) return 0;
+    if(memoization(C) != -1) return memoization(C);
+
+    int minimum = (P - C) * 36;
+    for(int j = 0; j < N - C; j++) {
+        int select = 36;
+        for(int i = 0; i < C; i++) {
+            if(cost[on[i]][off[j]] < select) {
+                select = cost[on[i]][off[j]];
+            }
+        }
+        on[C] = off[j];
+        for(int i = j + 1; i < N - C; i++) {
+            off[i-1] = off[i];
+        }
+        int count = select + answer(C+1);
+        minimum = min(minimum, count);
+        for(int i = N - C - 1; i > j; i--) {
+            off[i] = off[i-1];
+        }
+        off[j] = on[C];
+    }
+    memoize(C, minimum);
+    return minimum;
+}
+
+int main() {
+    for(int i = 0; i < 65536; i++) ret[i] = -1;
+
+    cin >> N;
+    for(int i = 0; i < N; i++) {
+        for(int j = 0; j < N; j++)
+            cin >> cost[i][j];
+    }
+
+    char s;
+    int C = 0;
+    for(int i = 0; i < N; i++) {
+        cin >> s;
+        if(s == 'Y') on[C++] = i;
+        else off[i-C] = i;
+    }
+    cin >> P;
+
+    cout << answer(C);
+}
\ No newline at end of file
diff --git a/2. DC & DP/BJ_1324_sungchan/jenjang.cpp b/2. DC & DP/BJ_1324_sungchan/jenjang.cpp
new file mode 100644
index 0000000..b885bff
--- /dev/null
+++ b/2. DC & DP/BJ_1324_sungchan/jenjang.cpp	
@@ -0,0 +1,48 @@
+#include <iostream>
+using namespace std;
+int N;
+int *day1, *day2;
+int ret[1000][1000];
+
+int counter(int start1, int start2) {
+    if(start1 >= N || start2 >= N) return 0;
+    if(ret[start1][start2] != -1) return ret[start1][start2];
+
+    int startnum = day1[start1];
+    int index2 = -1;
+    for(int i = start2; i < N; i++) {
+        if(day2[i] == startnum) {
+            index2 = i;
+            break;
+        }
+    }
+    if(index2 == -1) return ret[start1][start2] = counter(start1+1, start2);
+    else {
+        int max = 1;
+        for(int i = start1 + 1; i < N; i++) {
+            if(day1[i] > startnum) {
+                int count = 1 + counter(i, index2+1);
+                if(count > max) max = count;
+            }
+        }
+        for(int i = start1 + 1; i < N; i++) {
+            if(counter(i, start2) > max) max = counter(i, start2);
+        }
+
+        return ret[start1][start2] = max;
+    }
+}
+
+int main() {
+    for(int i = 0; i < 1000; i++)
+        for(int j = 0; j < 1000; j++)
+            ret[i][j] = -1;
+
+    cin >> N;
+    day1 = new int[N];
+    day2 = new int[N];
+    for(int i = 0; i < N; i++) cin >> day1[i];
+    for(int i = 0; i < N; i++) cin >> day2[i];
+    int answer = counter(0, 0);
+    cout << answer;
+}
\ No newline at end of file
diff --git a/2. DC & DP/BJ_14567_sungchan/prerequisite.cpp b/2. DC & DP/BJ_14567_sungchan/prerequisite.cpp
new file mode 100644
index 0000000..3e862e5
--- /dev/null
+++ b/2. DC & DP/BJ_14567_sungchan/prerequisite.cpp	
@@ -0,0 +1,31 @@
+#include <iostream>
+using namespace std;
+int N, M;
+
+int* counter(bool** course) {
+    int* answer = new int[N];
+    for(int i = 0; i < N; i++) answer[i] = 1;
+    for(int i = 0; i < N; i++) {
+        for(int j = i+1; j < N; j++) {
+            if(course[i][j]) answer[j] = max(answer[i] + 1, answer[j]);
+        }
+    }
+    return answer;
+}
+
+int main() {
+    cin >> N >> M;
+    bool** course = new bool*[N];
+    for(int i = 0; i < N; i++) course[i] = new bool[N];
+
+    for(int i = 0; i < M; i++) {
+        int A, B;
+        cin >> A >> B;
+        course[A-1][B-1] = true;
+    }
+
+    int* answer = counter(course);
+    for(int i = 0; i < N; i++) {
+        cout << answer[i] << " ";
+    }
+}
\ No newline at end of file
diff --git a/2. DC & DP/BJ_2339_sungchan/stoneboard.cpp b/2. DC & DP/BJ_2339_sungchan/stoneboard.cpp
new file mode 100644
index 0000000..d51e05b
--- /dev/null
+++ b/2. DC & DP/BJ_2339_sungchan/stoneboard.cpp	
@@ -0,0 +1,80 @@
+#include <iostream>
+using namespace std;
+int N;
+int** stone;
+
+int counter(int startrow, int startcol, int endrow, int endcol, bool rowwise) {
+    if(startrow > endrow || startcol > endcol) return 0;
+
+    int gem = 0;
+    int impurity = 0;
+    int* gem_row = new int[15];
+    int* gem_col = new int[15];
+    int* impurity_row = new int[15];
+    int* impurity_col = new int[15];
+    for(int i = startrow; i <= endrow; i++) {
+        for(int j = startcol; j <= endcol; j++) {
+            if(stone[i][j] == 2) {
+                gem_row[gem] = i;
+                gem_col[gem] = j;
+                gem++;
+            } else if(stone[i][j] == 1) {
+                impurity_row[impurity] = i;
+                impurity_col[impurity] = j;
+                impurity++;
+            }
+        }
+    }
+    if(gem == 0) return 0;
+    else if(gem == 1) {
+        if(impurity == 0) return 1;
+        else return 0;
+    } else if(impurity == 0) return 0;
+
+    if(rowwise) { // same row
+        int count = 0;
+        for(int i = 0; i < impurity; i++) {
+            bool possible = true;
+            for(int j = 0; j < gem; j++) {
+                if(gem_row[j] == impurity_row[i]) {
+                    possible = false;
+                    break;
+                }
+            }
+            if(possible) {
+                count += counter(startrow, startcol, impurity_row[i]-1, endcol, false) * counter(impurity_row[i]+1, startcol, endrow, endcol, false);
+            }
+        }
+        return count;
+    } else { // same col
+        int count = 0;
+        for(int j = 0; j < impurity; j++) {
+            bool possible = true;
+            for(int i = 0; i < gem; i++) {
+                if(gem_col[i] == impurity_col[j]) {
+                    possible = false;
+                    break;
+                }
+            }
+            if(possible) {
+                count += counter(startrow, startcol, endrow, impurity_col[j]-1, true) * counter(startrow, impurity_col[j]+1, endrow, endcol, true);
+            }
+        }
+        return count;
+    }
+}
+
+int main() {
+    cin >> N;
+    stone = new int*[N];
+    for(int i = 0; i < N; i++) {
+        stone[i] = new int[N];
+        for(int j = 0; j < N; j++) {
+            cin >> stone[i][j];
+        }
+    }
+
+    int answer = counter(0,0,N-1,N-1, true) + counter(0,0,N-1,N-1, false);
+    if(answer == 0) cout << -1;
+    else cout << answer;
+}
\ No newline at end of file
diff --git a/3. DP/BJ_11066_sungchan/merging.cpp b/3. DP/BJ_11066_sungchan/merging.cpp
new file mode 100644
index 0000000..6da9ab0
--- /dev/null
+++ b/3. DP/BJ_11066_sungchan/merging.cpp	
@@ -0,0 +1,59 @@
+#include <iostream>
+#include <algorithm>
+using namespace std;
+int T, *K, **file, **cumulated;
+int cache[501][501];
+
+int cost(int index, int start, int end) {
+    if(start == end) return 0;
+
+    int& ret = cache[start][end];
+    if(ret != -1) return ret;
+
+    if(start + 1 == end) {
+        return ret = file[index][start] + file[index][end];
+    }
+    if(start + 2 == end) {
+        int sum = cumulated[index][start+2];
+        if(start > 0) sum -= cumulated[index][start-1];
+        return ret = 2 * sum - max(file[index][start], file[index][start+2]);
+    }
+
+    int answer = cumulated[index][end];
+    if(start > 0) answer -= cumulated[index][start-1];
+
+    int minimum = INT32_MAX;
+    for(int i = start; i < end; i++) {
+        int cand = cost(index, start, i) + cost(index, i+1, end);
+        if(cand < minimum) minimum = cand;
+    }
+
+    return ret = answer + minimum;
+}
+
+int main() {
+    cin >> T;
+    K = new int[T];
+    file = new int*[T];
+    cumulated = new int*[T];
+    for(int i = 0; i < T; i++) {
+        cin >> K[i];
+        file[i] = new int[K[i]];
+        cumulated[i] = new int[K[i]];
+        cin >> file[i][0];
+        cumulated[i][0] = file[i][0];
+        for(int j = 1; j < K[i]; j++) {
+            cin >> file[i][j];
+            cumulated[i][j] = cumulated[i][j-1] + file[i][j];
+        }
+    }
+
+
+    for(int i = 0; i < T; i++) {
+        for(int j = 0; j <= 500; j++)
+            for(int k = 0; k <= 500; k++)
+                cache[j][k] = -1;
+
+        cout << cost(i, 0, K[i]-1) << endl;
+    }
+}
\ No newline at end of file
diff --git a/3. DP/BJ_1328_sungchan/building.cpp b/3. DP/BJ_1328_sungchan/building.cpp
new file mode 100644
index 0000000..e6ee685
--- /dev/null
+++ b/3. DP/BJ_1328_sungchan/building.cpp	
@@ -0,0 +1,70 @@
+#include <iostream>
+#include <algorithm>
+using namespace std;
+typedef long long ll;
+const ll MOD = 1000000007;
+ll com[100][100];
+ll fact[100];
+ll cache[100][100];
+
+void combination(int num) {
+    if(num > 1) combination(num - 1);
+    else {
+        com[1][0] = com[1][1] = 1;
+        return;
+    }
+    com[num][0] = 1;
+    for(int i = 1; i <= num; i++) {
+        com[num][i] = (com[num-1][i] + com[num-1][i-1]) % MOD;
+    }
+}
+
+void factorial(int num) {
+    if(num > 0) factorial(num - 1);
+    else {
+        fact[0] = 1;
+        return;
+    }
+    fact[num] = (fact[num-1] * num) % MOD;
+}
+
+ll counter(int a, int b) {
+    ll& ret = cache[a][b];
+    if(ret != -1) return ret;
+
+    if(b == 1) return ret = fact[a-1];
+    if(a == b) return ret = 1;
+
+    ll ans = 0;
+    for(int i = b-1; i < a; i++) {
+        ans += (com[a-1][i] * (counter(i, b-1) * fact[a-i-1] % MOD)) % MOD;
+    }
+    return ret = ans % MOD;
+}
+
+ll count(int n, int l, int r) {
+    if(l + r > n + 1) return 0;
+    if(n == 1) return 1;
+    if(l == 1 && r == 1) return 0;
+
+    combination(n-1);
+    factorial(n-1);
+
+    for(int i = 1; i < n; i++)
+        for(int j = 1; j < n; j++)
+            cache[i][j] = -1;
+
+    if(l == 1 || r == 1) return counter(n-1, max(l, r)-1);
+
+    ll ans = 0;
+    for(int i = l - 1; i <= n - r; i++) {
+        ans += (com[n-1][i] * (counter(i, l-1) * counter(n-i-1, r-1) % MOD)) % MOD;
+    }
+    return ans % MOD;
+}
+
+int main() {
+    int N, L, R;
+    cin >> N >> L >> R;
+    cout << count(N, L, R) << endl;
+}
\ No newline at end of file
diff --git a/3. DP/BJ_3933_sungchan/lagrange.cpp b/3. DP/BJ_3933_sungchan/lagrange.cpp
new file mode 100644
index 0000000..a88f9d5
--- /dev/null
+++ b/3. DP/BJ_3933_sungchan/lagrange.cpp	
@@ -0,0 +1,63 @@
+#include <iostream>
+using namespace std;
+int square[183];
+bool cache[32768][2];
+
+int count(int num, int part) {
+    if(part == 1) {
+        if(cache[num][0]) return 0;
+        if(cache[num][1]) return 1;
+    }
+
+    int ans = 0;
+
+    if(part == 1) {
+        for(int i = 1; i <= 182; i++) {
+            if(square[i] == num) return cache[num][1] = 1;
+            if(square[i] > num) {
+                cache[num][0] = 1;
+                return 0;
+            }
+        }
+    } else if(part == 2) {
+        for(int i = 1; i <= 182; i++) {
+            if(square[i] > num/2) break;
+            ans += count(num - square[i], 1);
+        }
+    } else if(part == 3) {
+        for(int i = 1; i <= 182; i++) {
+            if(square[i] > num/3) break;
+            for(int j = i; j <= 182; j++) {
+                if(square[j] > (num - square[i])/2) break;
+                ans += count(num - square[i] - square[j], 1);
+            }
+        }
+    } else if(part == 4) {
+        for(int i = 1; i <= 182; i++) {
+            if(square[i] > num/4) break;
+            for(int j = i; j <= 182; j++) {
+                if(square[j] > (num - square[i])/3) break;
+                for(int k = j; k <= 182; k++) {
+                    if(square[k] > (num - square[i] - square[j])/2) break;
+                    ans += count(num - square[i] - square[j] - square[k], 1);
+                }
+            }
+        }
+    }
+    return ans;
+}
+
+int main() {
+    for(int i = 0; i <= 182; i++) square[i] = i * i;
+    int* N = new int[255];
+    int number = 0;
+    for(int i = 0; i < 255; i++) {
+        cin >> N[i];
+        if(N[i] == 0) break;
+        else number++;
+    }
+
+    for(int i = 0; i < number; i++) {
+        cout << count(N[i], 1) + count(N[i], 2) + count(N[i], 3) + count(N[i], 4) << endl;
+    }
+}
\ No newline at end of file
diff --git a/4. Greedy/BJ_1041_sungchan/dice.cpp b/4. Greedy/BJ_1041_sungchan/dice.cpp
new file mode 100644
index 0000000..6176a68
--- /dev/null
+++ b/4. Greedy/BJ_1041_sungchan/dice.cpp	
@@ -0,0 +1,52 @@
+#include <iostream>
+using namespace std;
+int dice[6];
+typedef long long ll;
+ll N;
+
+int main() {
+    cin >> N;
+
+    int min1 = 50;
+    for(int i = 0; i < 6; i++) {
+        cin >> dice[i];
+        if(dice[i] < min1) min1 = dice[i];
+    }
+
+    if(N == 1) {
+        int max = 0;
+        int sum = 0;
+        for(int i = 0; i < 6; i++) {
+            if(dice[i] > max) max = dice[i];
+            sum += dice[i];
+        }
+        cout << sum - max;
+        return 0;
+    }
+
+    int min2 = 100;
+    for(int i = 0; i < 5; i++) {
+        for(int j = i+1; j < 6; j++) {
+            if(i+j != 5) {
+                if(dice[i] + dice[j] < min2) min2 = dice[i] + dice[j];
+            }
+        }
+    }
+
+    int min3 = 150;
+    for(int i = 1; i < 4; i++) {
+        for(int j = i+1; j < 5; j++) {
+            if(i+j != 5) {
+                if(dice[0] + dice[i] + dice[j] < min3) min3 = dice[0] + dice[i] + dice[j];
+                if(dice[5] + dice[i] + dice[j] < min3) min3 = dice[5] + dice[i] + dice[j];
+            }
+        }
+    }
+
+
+    ll one = (5*N*N - 16*N + 12) * (min1);
+    ll two = (8*N - 12) * (min2);
+    ll three = 4 * (min3);
+
+    cout << one + two + three;
+}
\ No newline at end of file
diff --git a/4. Greedy/BJ_1045_sungchan/road.cpp b/4. Greedy/BJ_1045_sungchan/road.cpp
new file mode 100644
index 0000000..1000e2a
--- /dev/null
+++ b/4. Greedy/BJ_1045_sungchan/road.cpp	
@@ -0,0 +1,105 @@
+#include <iostream>
+#include <algorithm>
+#include <queue>
+#include <vector>
+using namespace std;
+int N, M;
+
+int main() {
+    cin >> N >> M;
+    int cnt = 0;
+    char c;
+    bool **connected = new bool*[N];
+    bool impossible = false;
+    for(int i = 0; i < N; i++) {
+        bool impossible1 = true;
+        connected[i] = new bool[N];
+        for(int j = 0; j < N; j++) {
+            cin >> c;
+            if(c == 'Y') {
+                connected[i][j] = true;
+                cnt++;
+                impossible1 = false;
+            }
+        }
+        if(impossible1) impossible = true;
+    }
+    cnt /= 2;
+
+    if(N == 1 && M == 0) {
+        cout << 0;
+        return 0;
+    }
+    if(cnt < M || impossible) {
+        cout << -1;
+        return 0;
+    }
+
+    bool *connect = new bool[N];
+    int *road = new int[N];
+    int total = 0;
+
+    priority_queue<int, vector<int>, greater<>> cost;
+    for(int i = 1; i < N; i++) {
+        if(connected[0][i]) {
+            connect[i] = true;
+            road[0]++;
+            road[i]++;
+            total++;
+            for(int j = 1; j < N; j++) {
+                if(connected[i][j] && !connect[j]) {
+                    cost.push(N*min(i, j)+max(i, j));
+                }
+            }
+        }
+    }
+
+    while(!cost.empty() && total < N-1) {
+        int a = cost.top();
+        cost.pop();
+        int b = a / N;
+        int bb = a % N;
+        if(!connect[b] || !connect[bb]) {
+            road[b]++;
+            road[bb]++;
+            total++;
+            connected[b][bb] = false;
+            if(!connect[b]) {
+                for(int i = 1; i < N; i++) {
+                    if(connected[b][i] && !connect[i]) {
+                        cost.push(N*min(b,i)+max(b,i));
+                    }
+                }
+            } else { // !connect[bb]
+                for(int i = 1; i < N; i++) {
+                    if(connected[bb][i] && !connect[i]) {
+                        cost.push(N*min(bb,i)+max(bb,i));
+                    }
+                }
+            }
+            connect[b] = connect[bb] = true;
+        }
+    }
+
+
+    if(total < N-1) {
+        cout << -1;
+        return 0;
+    }
+
+    for(int i = 1; i < N-1; i++) {
+        if(total == M) break;
+        for(int j = i+1; j < N; j++) {
+            if(total == M) break;
+            if(connected[i][j]) {
+                road[i]++;
+                road[j]++;
+                total++;
+            }
+        }
+    }
+
+    for(int i = 0; i < N; i++) {
+        cout << road[i] << " ";
+    }
+}
\ No newline at end of file
diff --git a/4. Greedy/BJ_1092_sungchan/ship.cpp b/4. Greedy/BJ_1092_sungchan/ship.cpp
new file mode 100644
index 0000000..e0340a9
--- /dev/null
+++ b/4. Greedy/BJ_1092_sungchan/ship.cpp	
@@ -0,0 +1,59 @@
+#include <iostream>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+int N, M;
+int *crane, *box;
+
+int main() {
+    cin >> N;
+    crane = new int[N];
+    for(int i = 0; i < N; i++) {
+        cin >> crane[i];
+    }
+    sort(crane, crane+N);
+
+    cin >> M;
+    box = new int[M];
+    for(int i = 0; i < M; i++) {
+        cin >> box[i];
+    }
+    sort(box, box+M);
+
+    if(crane[N-1] < box[M-1]) {
+        cout << -1;
+        return 0;
+    }
+
+    if(N == 1) {
+        cout << M;
+        return 0;
+    }
+
+    int *loadable = new int[M];
+    int start = N-2;
+    for(int i = M-1; i >= 0; i--) {
+        bool done = false;
+        for(int j = start; j >= 0; j--) {
+            if(box[i] > crane[j]) {
+                loadable[i] = N - j - 1;
+                start = j;
+                done = true;
+                break;
+            }
+        }
+        if(!done) {
+            for(int j = i; j >= 0; j--) {
+                loadable[j] = N;
+            }
+            break;
+        }
+    }
+
+    int ans = 1;
+    for(int i = 2; i <= M; i++) {
+        int tmp = i/loadable[M-i] + (i % loadable[M-i] != 0);
+        if(tmp > ans) ans = tmp;
+    }
+    cout << ans;
+}
\ No newline at end of file
diff --git a/4. Greedy/BJ_14698_sungchan/slime.cpp b/4. Greedy/BJ_14698_sungchan/slime.cpp
new file mode 100644
index 0000000..fee910d
--- /dev/null
+++ b/4. Greedy/BJ_14698_sungchan/slime.cpp	
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <algorithm>
+#include <queue>
+#include <vector>
+using namespace std;
+int T, *N;
+typedef unsigned long long ll;
+ll MOD = 1e9+7;
+
+int main() {
+    ios_base::sync_with_stdio(false);
+    cin.tie(0);
+
+    cin >> T;
+    N = new int[T];
+    ll *product = new ll[T];
+    for(int i = 0; i < T; i++) {
+        cin >> N[i];
+        ll ener;
+        priority_queue<ll, vector<ll>, greater<>> energy;
+        for(int j = 0; j < N[i]; j++) {
+            cin >> ener;
+            energy.push(ener);
+        }
+
+        product[i] = 1;
+        while(energy.size() > 1) {
+            ll num1 = energy.top();
+            energy.pop();
+            ll num2 = energy.top();
+            energy.pop();
+            energy.push(num1 * num2);
+            product[i] *= ((num1 % MOD) * (num2 % MOD)) % MOD;
+            product[i] %= MOD;
+        }
+    }
+    for(int i = 0; i < T; i++) {
+        cout << product[i] << "\n";
+    }
+}
\ No newline at end of file
diff --git a/4. Greedy/BJ_1715_sungchan/card.cpp b/4. Greedy/BJ_1715_sungchan/card.cpp
new file mode 100644
index 0000000..e312179
--- /dev/null
+++ b/4. Greedy/BJ_1715_sungchan/card.cpp	
@@ -0,0 +1,27 @@
+#include <iostream>
+#include <algorithm>
+#include <queue>
+#include <vector>
+using namespace std;
+int N;
+
+int main() {
+    cin >> N;
+    priority_queue<int, vector<int>, greater<>> numbers;
+    int number;
+    for(int i = 0; i < N; i++) {
+        cin >> number;
+        numbers.push(number);
+    }
+
+    int ans = 0;
+    while(numbers.size() > 1) {
+        int num1 = numbers.top();
+        numbers.pop();
+        int num2 = numbers.top();
+        numbers.pop();
+        numbers.push(num1 + num2);
+        ans += (num1 + num2);
+    }
+    cout << ans;
+}
\ No newline at end of file
diff --git "a/5. \341\204\213\341\205\265\341\204\207\341\205\256\341\206\253\341\204\220\341\205\241\341\206\267\341\204\211\341\205\242\341\206\250/BJ_1477_sungchan/restarea.cpp" "b/5. \341\204\213\341\205\265\341\204\207\341\205\256\341\206\253\341\204\220\341\205\241\341\206\267\341\204\211\341\205\242\341\206\250/BJ_1477_sungchan/restarea.cpp"
new file mode 100644
index 0000000..18e7244
--- /dev/null
+++ "b/5. \341\204\213\341\205\265\341\204\207\341\205\256\341\206\253\341\204\220\341\205\241\341\206\267\341\204\211\341\205\242\341\206\250/BJ_1477_sungchan/restarea.cpp"	
@@ -0,0 +1,47 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <cmath>
+
+using namespace std;
+int N, M, L;
+
+int main() {
+    cin >> N >> M >> L;
+    int* rest = new int[N];
+    for(int i = 0; i < N; i++) {
+        cin >> rest[i];
+    }
+    sort(rest, rest+N);
+
+    int* gap = new int[N+1];
+    gap[0] = rest[0];
+    for(int i = 1; i < N; i++) {
+        gap[i] = rest[i] - rest[i-1];
+    }
+    gap[N] = L - rest[N-1];
+    sort(gap, gap+(N+1), greater<>());
+    int* index = new int[N+1];
+    for(int i = 0; i <= N; i++) index[i] = 1;
+
+    for(int i = 0; i < M; i++) {
+        bool done = false;
+        int max = ceil((double) gap[0] / (double) index[0]);
+        for(int i = 1; i <= N; i++) {
+            if(ceil((double) gap[i] / (double) index[i]) > max) {
+                index[i]++;
+                done = true;
+                break;
+            }
+        }
+        if(!done) index[0]++;
+    }
+
+    int ans = ceil((double) gap[0] / (double) index[0]);
+    for(int i = 1; i <= N; i++) {
+        int cand = ceil((double) gap[i] / (double) index[i]);
+        if(cand > ans) ans = cand;
+    }
+
+    cout << ans;
+}
\ No newline at end of file
diff --git "a/5. \341\204\213\341\205\265\341\204\207\341\205\256\341\206\253\341\204\220\341\205\241\341\206\267\341\204\211\341\205\242\341\206\250/BJ_1561_sungchan/amusement.cpp" "b/5. \341\204\213\341\205\265\341\204\207\341\205\256\341\206\253\341\204\220\341\205\241\341\206\267\341\204\211\341\205\242\341\206\250/BJ_1561_sungchan/amusement.cpp"
new file mode 100644
index 0000000..5779c64
--- /dev/null
+++ "b/5. \341\204\213\341\205\265\341\204\207\341\205\256\341\206\253\341\204\220\341\205\241\341\206\267\341\204\211\341\205\242\341\206\250/BJ_1561_sungchan/amusement.cpp"	
@@ -0,0 +1,56 @@
+#include <iostream>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+typedef long long ll;
+int N, M;
+
+int main() {
+    cin >> N >> M;
+    int* time = new int[M];
+    for(int i = 0; i < M; i++) {
+        cin >> time[i];
+    }
+
+    if(N <= M) {
+        cout << N;
+        return 0;
+    }
+
+    ll low = 0;
+    ll high = 30 * (ll)(ceil((double) N / (double) M));
+    ll mid = (low+high)/2;
+
+    while(true) {
+        ll cnt = M;
+        for(int i = 0; i < M; i++) {
+            cnt += mid / time[i];
+            if(cnt >= N) break;
+        }
+        if(cnt >= N) high = mid;
+        else if(cnt < N) low = mid;
+        mid = (low+high)/2;
+        if(low+1 == high && cnt < N) {
+            mid = high;
+            break;
+        }
+    }
+
+    int cnt = M;
+    for(int i = 0; i < M; i++) {
+        cnt += (mid-1)/ time[i];
+    }
+    int num = N-cnt;
+    int ans = -1;
+    for(int i = 0; i < M; i++) {
+        if(mid % time[i] == 0) {
+            num--;
+        }
+        if(num == 0) {
+            ans = i+1;
+            break;
+        }
+    }
+
+    cout << ans;
+}
\ No newline at end of file
diff --git "a/5. \341\204\213\341\205\265\341\204\207\341\205\256\341\206\253\341\204\220\341\205\241\341\206\267\341\204\211\341\205\242\341\206\250/BJ_1939_sungchan/weightlimit.cpp" "b/5. \341\204\213\341\205\265\341\204\207\341\205\256\341\206\253\341\204\220\341\205\241\341\206\267\341\204\211\341\205\242\341\206\250/BJ_1939_sungchan/weightlimit.cpp"
new file mode 100644
index 0000000..12cc49a
--- /dev/null
+++ "b/5. \341\204\213\341\205\265\341\204\207\341\205\256\341\206\253\341\204\220\341\205\241\341\206\267\341\204\211\341\205\242\341\206\250/BJ_1939_sungchan/weightlimit.cpp"	
@@ -0,0 +1,71 @@
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <map>
+
+using namespace std;
+int N, M;
+
+int main() {
+    cin >> N >> M;
+    vector<map<int, int>> bridge(N+1);
+
+    int A, B, C;
+    for(int i = 0; i < M; i++) {
+        cin >> A >> B >> C;
+        if(bridge[A].find(B) == bridge[A].end()) {
+            bridge[A][B] = C;
+            bridge[B][A] = C;
+        } else if(C > bridge[A][B]) {
+            bridge[A][B] = C;
+            bridge[B][A] = C;
+        }
+    }
+
+    int src, dest;
+    cin >> src >> dest;
+
+    bool* connected = new bool[N+1];
+    int* limit = new int[N+1];
+    int* neighbor = new int[N+1];
+    connected[src] = true;
+    for(int i = 1; i <= N; i++) {
+        if(i == src) continue;
+        if(bridge[i].find(src) != bridge[i].end()) {
+            limit[i] = bridge[i].at(src);
+            neighbor[i] = src;
+        } else {
+            limit[i] = -1;
+        }
+    }
+
+    while(!connected[dest]) {
+        int maximum = -1;
+        int max_index = -1;
+        for(int i = 1; i <= N; i++) {
+            if(!connected[i] && limit[i] != -1) {
+                if(limit[i] > maximum) {
+                    maximum = limit[i];
+                    max_index = i;
+                }
+            }
+        }
+        connected[max_index] = true;
+        for(int i = 1; i <= N; i++) {
+            if(!connected[i] && bridge[max_index].find(i) != bridge[max_index].end()) {
+                if(bridge[max_index].at(i) > limit[i]) {
+                    limit[i] = bridge[max_index].at(i);
+                    neighbor[i] = max_index;
+                }
+            }
+        }
+    }
+
+    int index = dest;
+    int minimum = INT32_MAX;
+    while(index != src) {
+        minimum = min(minimum, limit[index]);
+        index = neighbor[index];
+    }
+    cout << minimum;
+}
\ No newline at end of file
diff --git "a/5. \341\204\213\341\205\265\341\204\207\341\205\256\341\206\253\341\204\220\341\205\241\341\206\267\341\204\211\341\205\242\341\206\250/BJ_2470_sungchan/solution.cpp" "b/5. \341\204\213\341\205\265\341\204\207\341\205\256\341\206\253\341\204\220\341\205\241\341\206\267\341\204\211\341\205\242\341\206\250/BJ_2470_sungchan/solution.cpp"
new file mode 100644
index 0000000..bce07c7
--- /dev/null
+++ "b/5. \341\204\213\341\205\265\341\204\207\341\205\256\341\206\253\341\204\220\341\205\241\341\206\267\341\204\211\341\205\242\341\206\250/BJ_2470_sungchan/solution.cpp"	
@@ -0,0 +1,85 @@
+#include <iostream>
+#include <algorithm>
+#include <cmath>
+using namespace std;
+int N;
+
+int main() {
+    cin >> N;
+    int* acid = new int[N];
+    for(int i = 0; i < N; i++) {
+        cin >> acid[i];
+    }
+    sort(acid, acid+N);
+
+    int acid_index = -1;
+    for(int i = 0; i < N; i++) {
+        if(acid[i] > 0) {
+            acid_index = i;
+            break;
+        }
+    }
+    if(acid_index == -1) {
+        cout << acid[N-2] << " " << acid[N-1];
+        return 0;
+    }
+    if(acid_index == 0) {
+        cout << acid[0] << " " << acid[1];
+        return 0;
+    }
+
+    int minimum = INT32_MAX;
+    pair<int, int> index;
+    int limit = N-1;
+    for(int i = 0; i < acid_index; i++) {
+        bool done = false;
+        for(int j = acid_index; j <= limit; j++) {
+            int cand = acid[i]+acid[j];
+            if(cand > 0) {
+                if(cand < minimum) {
+                    minimum = cand;
+                    index.first = i;
+                    index.second = j;
+                    limit = j;
+                }
+                if(j > acid_index) {
+                    int cand2 = -(acid[i]+acid[j-1]);
+                    if(cand2 < minimum) {
+                        minimum = cand2;
+                        index.first = i;
+                        index.second = j-1;
+                    }
+                }
+                done = true;
+                break;
+            } else if(cand == 0) {
+                cout << acid[i] << " " << acid[j];
+                return 0;
+            }
+        }
+        if(!done) {
+            int cand3 = -(acid[i] + acid[limit]);
+            if(cand3 < minimum) {
+                minimum = cand3;
+                index.first = i;
+                index.second = limit;
+            }
+        }
+    }
+
+    if(acid_index > 1) {
+        if(acid[acid_index-2] + acid[acid_index-1] > -minimum) {
+            minimum = -(acid[acid_index-2] + acid[acid_index-1]);
+            index.first = acid_index-2;
+            index.second = acid_index-1;
+        }
+    }
+    if(N-acid_index > 1) {
+        if(acid[acid_index] + acid[acid_index+1] < minimum) {
+            index.first = acid_index;
+            index.second = acid_index+1;
+        }
+    }
+
+    cout << acid[index.first] << " " << acid[index.second];
+}
\ No newline at end of file
diff --git a/6. DFS & BFS/BJ_10891_sungchan/cactus.cpp b/6. DFS & BFS/BJ_10891_sungchan/cactus.cpp
new file mode 100644
index 0000000..c58dddc
--- /dev/null
+++ b/6. DFS & BFS/BJ_10891_sungchan/cactus.cpp	
@@ -0,0 +1,78 @@
+#include <iostream>
+#include <vector>
+#include <stack>
+#include <utility>
+#include <algorithm>
+#include <set>
+using namespace std;
+const int MAX = 100001;
+typedef pair<int, int> P;
+
+int N, M, dcnt, dfsn[MAX];
+vector<int> adj[MAX];
+stack<P> S;
+vector<vector<P>> bcc;
+
+int DFS(int curr, int prev = -1) {
+    int result = dfsn[curr] = ++dcnt;
+
+    for(int next: adj[curr]) {
+        if(next == prev) continue;
+        if(dfsn[curr] > dfsn[next]) S.push(P(curr, next));
+        if(dfsn[next] > 0) result = min(result, dfsn[next]);
+        else {
+            int temp = DFS(next, curr);
+            result = min(result, temp);
+            if(temp >= dfsn[curr]) {
+                vector<P> currBCC;
+                while(!S.empty() && S.top() != P(curr, next)) {
+                    currBCC.push_back(S.top());
+                    S.pop();
+                }
+                currBCC.push_back(S.top());
+                S.pop();
+                bcc.push_back(currBCC);
+            }
+        }
+    }
+
+    return result;
+}
+
+int main() {
+    cin >> N >> M;
+    int x, y;
+    for(int i = 0; i < M; i++) {
+        cin >> x >> y;
+        adj[x].push_back(y);
+        adj[y].push_back(x);
+    }
+
+    for(int i = 0; i < N; i++) {
+        if(dfsn[i] == 0) DFS(i);
+    }
+
+    bool cactus = true;
+    if(bcc.size() == 1) {
+        if(M > N) cactus = false;
+    }
+    vector<bool> checked(N);
+    for(auto &c: bcc) {
+        if(c.size() == 1) continue;
+        set<int> nodes;
+        for(auto &p: c) {
+            nodes.insert(p.first);
+            nodes.insert(p.second);
+        }
+        for(int node: nodes) {
+            if(checked[node]) cactus = false;
+            checked[node] = true;
+        }
+        int n = nodes.size();
+        int m = c.size();
+        if(m > n) cactus = false;
+    }
+
+    if(cactus) cout << "Cactus";
+    else cout << "Not cactus";
+}
\ No newline at end of file
diff --git a/6. DFS & BFS/BJ_2021_sungchan/transfer.cpp b/6. DFS & BFS/BJ_2021_sungchan/transfer.cpp
new file mode 100644
index 0000000..166b730
--- /dev/null
+++ b/6. DFS & BFS/BJ_2021_sungchan/transfer.cpp	
@@ -0,0 +1,73 @@
+#include <iostream>
+#include <vector>
+#include <set>
+using namespace std;
+int N, L;
+int station, src, dest;
+
+int main() {
+    cin >> N >> L;
+    vector<vector<int>> line(L+1);
+    for(int i = 1; i <= L; i++) {
+        cin >> station;
+        while(station != -1) {
+            line[i].push_back(station);
+            cin >> station;
+        }
+    }
+
+    vector<vector<int>> link(N+1);
+    for(int i = 1; i <= L; i++) {
+        for(int j: line[i]) {
+            link[j].push_back(i);
+        }
+    }
+    cin >> src >> dest;
+    if(src == dest) {
+        cout << 0;
+        return 0;
+    }
+
+    if(link[src].empty()) {
+        cout << -1;
+        return 0;
+    }
+
+    vector<bool> visited_line(L+1, false); // 방문한 호선
+    vector<bool> visited_station(N+1, false); // 방문한 역
+    set<int> tovisit; // 방문할 호선
+
+    for(int i: link[src]) {
+        tovisit.insert(i); // src와 연결된 호선 추가
+    }
+
+    visited_station[src] = true; // src 방문 체크
+
+    int ans = 0;
+    while(!tovisit.empty()) { // 방문할 호선이 있을 때 반복
+        for(int i: tovisit) {
+            visited_line[i] = true; // 호선 방문 체크
+        }
+        set<int> temp(tovisit);
+        for(int i : tovisit) { // ans번 환승하여 방문할 호선들
+            for(int j: line[i]) { // 각 호선에 연결된 역들
+                if(visited_station[j]) continue;
+                visited_station[j] = true;
+                if(j == dest) {
+                    cout << ans;
+                    return 0;
+                }
+                for(int k: link[j]) {
+                    if(!visited_line[k]) {
+                        temp.insert(k);
+                    }
+                }
+            }
+            temp.erase(i);
+        }
+        tovisit = temp;
+        ans++;
+    }
+
+    cout << -1; // 불가능한 경우
+}
\ No newline at end of file
diff --git a/6. DFS & BFS/BJ_3584_sungchan/dinosaur.cpp b/6. DFS & BFS/BJ_3584_sungchan/dinosaur.cpp
new file mode 100644
index 0000000..5d66aba
--- /dev/null
+++ b/6. DFS & BFS/BJ_3584_sungchan/dinosaur.cpp	
@@ -0,0 +1,41 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+int T, N;
+
+int main() {
+    cin >> T;
+    while(T--) {
+        int ans = 0;
+        cin >> N;
+        vector<int> parent(N+1, 0);
+        int A, B;
+        for(int i = 0; i < N-1; i++) {
+            cin >> A >> B;
+            parent[B] = A;
+        }
+        cin >> A >> B;
+        if(A == B || parent[A] == 0) ans = A;
+        else if(parent[B] == 0) ans = B;
+        else {
+            vector<int> parents;
+            parents.push_back(A);
+            while(parent[A] != 0) {
+                A = parent[A];
+                parents.push_back(A);
+            }
+            bool done = false;
+            while(!done) {
+                for(int i : parents) {
+                    if(B == i) {
+                        ans = B;
+                        done = true;
+                        break;
+                    }
+                }
+                B = parent[B];
+            }
+        }
+        cout << ans << endl;
+    }
+}
\ No newline at end of file
diff --git a/6. DFS & BFS/BJ_4196_sungchan/domino.cpp b/6. DFS & BFS/BJ_4196_sungchan/domino.cpp
new file mode 100644
index 0000000..e137340
--- /dev/null
+++ b/6. DFS & BFS/BJ_4196_sungchan/domino.cpp	
@@ -0,0 +1,71 @@
+#include <iostream>
+#include <vector>
+#include <stack>
+#include <algorithm>
+using namespace std;
+const int MAX = 100001;
+int T, N, M;
+int cnt, dfsn[MAX], SN, sn[MAX];
+vector<int> adj[MAX];
+bool finished[MAX];
+stack<int> S;
+
+int DFS(int curr) {
+    dfsn[curr] = ++cnt;
+    S.push(curr);
+
+    int result = dfsn[curr];
+    for(int next : adj[curr]) {
+        if(dfsn[next] == 0) result = min(result, DFS(next));
+        else if(!finished[next]) result = min(result, dfsn[next]);
+    }
+
+    if(result == dfsn[curr]) {
+        while(true) {
+            int t = S.top();
+            S.pop();
+            finished[t] = true;
+            sn[t] = SN;
+            if(t == curr) break;
+        }
+        SN++;
+    }
+    return result;
+}
+
+int main() {
+    cin >> T;
+    while(T--) {
+        cin >> N >> M;
+        cnt = SN = 0;
+        for(int i = 1; i <= N; i++) {
+            dfsn[i] = sn[i] = 0;
+            adj[i].clear();
+            finished[i] = false;
+        }
+
+        int x, y;
+        for(int i = 0; i < M; i++) {
+            cin >> x >> y;
+            adj[x].push_back(y);
+        }
+        for(int i = 1; i <= N; i++) {
+            if(dfsn[i] == 0) DFS(i);
+        }
+
+        vector<int> indegree(SN, 0);
+        for(int i = 1; i <= N; i++) {
+            for(int j: adj[i]) {
+                if(sn[i] != sn[j]) {
+                    indegree[sn[j]]++;
+                }
+            }
+        }
+
+        int ans = 0;
+        for(int i = 0; i < SN; i++) {
+            if(indegree[i] == 0) ans++;
+        }
+        cout << ans << endl;
+    }
+}
\ No newline at end of file