[Update] folder name change

Author: rkdehdgns1230

Binary_search/BinarySearch.cpp

@@ -0,0 +1,24 @@
+#include <iostream>
+#define NUMBER 12
+
+using namespace std;
+
+int a[] = { 1, 3, 5, 7, 9, 11, 14, 15, 18, 19, 25, 28 };
+int search_num = 7;
+
+int search(int start, int end, int target) {
+	if (start > end) return -1;
+
+	int mid = (start + end) / 2;
+
+	if (a[mid] == target) return mid;
+	else if (a[mid] > target) return search(start, mid - 1, target);
+	else return search(mid + 1, end, target);
+}
+
+int main() {
+	int result = search(0, NUMBER - 1, search_num);
+	if (result != -1)
+		cout << result + 1 << "¹ø°¿¡¼­ ã¾Ò½À´Ï´Ù.";
+	return 0;
+}

Binary_search/LinearSearch.cpp

@@ -0,0 +1,16 @@
+#include <iostream>
+#define NUMBER 10
+
+using namespace std;
+
+int a[] = { 8, 3, 4, 5, 1, 9, 6, 7, 2, 0 };
+int search = 7;
+
+int main(void) {
+	for (int i = 0; i < NUMBER; i++) {
+		if (a[i] == search) {
+			cout << i + 1 << "¹ø°¿¡¼­ ã¾Ò½À´Ï´Ù.";
+		}
+	}
+	return 0;
+}

Brute_force/Brute_Force_LCS.cpp

@@ -0,0 +1,151 @@
+#include <iostream>
+#include <vector>
+#include <string>
+
+using namespace std;
+
+// length of strX(m), strY(n)
+int n, m;
+// save the status of array
+int ch[10];
+// sequence X, Y
+string strX, strY;
+// get the subset of sequence (X or Y)
+vector<string> subSet;
+
+/*
+	function name : DFS
+	brief : This function makes subset of sequence X
+	if X's length is m, this function makes 2^m subsets
+	argument : 
+	idx means the index of string
+	XorY true = X, false = Y
+	verbose true = print the subset string, false = print x
+	return : void
+*/
+void DFS(int idx, bool XorY, bool verbose=false) {
+	if (XorY) {
+		// X is shorter than Y
+		if (idx == m) {
+			string str;
+			for (int i = 0; i < m; i++) {
+				if (ch[i] == 1)
+					str += strX[i];
+			}
+			// push subset to subSet vector
+			subSet.push_back(str);
+			if(verbose)
+				cout << str << endl;
+			return;
+		}
+		else {
+			// case1: ch[idx] = 1
+			ch[idx] = 1;
+			DFS(idx + 1, XorY);
+			// case2: ch[idx] = 0
+			ch[idx] = 0;
+			DFS(idx + 1, XorY);
+			return;
+		}
+	}
+	else {
+		// Y is shorter than X
+		if (idx == n) {
+			string str;
+			for (int i = 0; i < n; i++) {
+				if (ch[i] == 1)
+					str += strY[i];
+			}
+			// push subset to subSet vector
+			subSet.push_back(str);
+			cout << str << endl;
+			return;
+		}
+		else {
+			// case1: ch[idx] = 1
+			ch[idx] = 1;
+			DFS(idx + 1, XorY);
+			// case2: ch[idx] = 0
+			ch[idx] = 0;
+			DFS(idx + 1, XorY);
+			return;
+		}
+	}
+}
+/*
+	function name : getLCS
+	brief : This function find the LCS of two sequences (X and Y)
+	first calculate the maxLength(length of LCS) and
+	find the LCS with maxLength and finally print the result(LCSs)
+	return : void
+*/
+void getLCS(bool XorY, bool verbose=true) {
+	int maxLength = 0;
+	vector<string> result;
+	string sequence;
+	// select the string
+	if (XorY) sequence = strY;
+	else sequence = strX;
+
+	// get the length of LCS
+	for (int i = 0; i < subSet.size(); i++) {
+		string str = subSet[i];
+		int idx = 0;
+		// compare ith subset with strY (sequence Y)
+		for (int j = 0; j < sequence.size(); j++) {
+			if (sequence[j] == str[idx])
+				idx++;
+		}
+		if (idx == str.length() && str.length() > maxLength) {
+			maxLength = idx;
+		}
+	}
+	// find the LCS with maxLength(length of LCS)
+	for (int i = 0; i < subSet.size(); i++) {
+		// skip the other case (not the LCS)
+		if (subSet[i].length() != maxLength) continue;
+		string str = subSet[i];
+		int idx = 0;
+		for (int j = 0; j < sequence.size(); j++) {
+			if (sequence[j] == str[idx])
+				idx++;
+		}
+		if (idx == str.length()) {
+			result.push_back(str);
+		}
+	}
+
+	if (verbose) {
+		cout << "LCS length : " << maxLength << endl;
+		cout << "LCS : \n";
+		for (int i = 0; i < result.size(); i++) {
+			cout << result[i] << "\n";
+		}
+	}
+
+	return;
+}
+
+int main() {
+	bool XorY;
+	cin >> strX >> strY;
+	// get the length of strX and strY
+	m = strX.length();
+	n = strY.length();
+
+	// set the XorY(select the sequence to find subset)
+	if (m > n) 
+		XorY = false; // we will find the subset of Y
+	else 
+		XorY = true; // we will find the subset of X
+
+	// print the result
+	cout << "### subset of X ###" << endl;
+	// call DFS (get the subset of sequence)
+	DFS(0, XorY);
+	cout << "number of subset : " << subSet.size() << endl;
+	// call getLCS (get the LSC of two sequences) and print LCSs
+	getLCS(XorY);
+	cout << "### end of program ###" << endl;
+	return 0;
+}

Brute_force/problem solving/[1436]_영화감독 슘.cpp

@@ -0,0 +1,57 @@
+/*
+	Date: 2022/02/19
+	Brief:
+	simple brute force problem
+	Reference:
+*/
+#include <iostream>
+#define MAX 10001
+
+using namespace std;
+
+int arr[MAX];
+
+bool check(int x) {
+	int cnt = 0;
+	int num;
+	while (1) {
+		num = x % 10;
+		x /= 10;
+		if (num == 6) {
+			cnt++;
+			if (cnt == 3) {
+				return true;
+			}
+		}
+		else {
+			cnt = 0;
+		}
+		if (x == 0) break;
+	}
+
+	return false;
+}
+
+int main() {
+	int n, cnt = 0;
+	cin.tie(NULL);
+
+	cin >> n;
+
+	for (int i = 1; ; i++) {
+		if (check(i)) {
+			arr[cnt++] = i;
+		}
+		if (cnt == 10000) break;
+	}
+	cout << arr[n - 1] << "\n";
+
+	return 0;
+}
+
+/*
+	규칙이 뒤죽박죽이여서 그냥
+	가장 작은 수부터 확인하면서 666에 대한
+	pattern matching이 가능한 프로그램을 구현해야
+	될 것 같다는 생각이 듬. (brute force 방식으로)
+*/

Brute_force/problem solving/[14500]_테트로미노.cpp

@@ -0,0 +1,116 @@
+/*
+	Date: 2022/02/20
+	Brief:
+	simple brute-force problem
+	Reference:
+	https://velog.io/@skyepodium/%EB%B0%B1%EC%A4%80-14500-%ED%85%8C%ED%8A%B8%EB%A1%9C%EB%AF%B8%EB%85%B8
+*/
+#include <iostream>
+#define MAX 501
+
+using namespace std;
+
+int map[MAX][MAX];
+bool visited[MAX][MAX];
+int arrX[4] = { 0, 0, 1, -1 };
+int arrY[4] = { 1, -1, 0, 0 };
+int cur[5];
+int maxDistance = 0;
+
+int n, m;
+
+bool inRange(int x, int y) {
+	if (x <= 0 || x > n || y <= 0 || y > m)
+		return false;
+	else
+		return true;
+}
+
+void checkingTetromino(int x, int y, int sum, int num) {
+	if (num == 4) {
+		// if current combination is bigger than current maxDistance
+		if (sum > maxDistance) {
+			maxDistance = sum;
+		}
+		return;
+	}
+
+	for (int i = 0; i < 4; i++) {
+		int nextX = x + arrX[i];
+		int nextY = y + arrY[i];
+
+		if (!inRange(nextX, nextY))
+			continue;
+		
+		if (visited[nextX][nextY]) {
+			continue;
+		}
+		else {
+			visited[nextX][nextY] = true;
+			checkingTetromino(nextX, nextY, sum + map[nextX][nextY], num + 1);
+			visited[nextX][nextY] = false;
+		}
+	}
+	return;
+}
+
+void checkingParticular(int x, int y) {
+	int sum = 0;
+	// 1. ㅜ
+	if (inRange(x, y + 1) && inRange(x, y + 2) && inRange(x + 1, y + 1)) {
+		sum = (map[x][y] + map[x][y + 1] + map[x][y + 2] + map[x + 1][y + 1]);
+		maxDistance = maxDistance > sum ? maxDistance : sum;
+	}
+	// 2. ㅏ
+	if (inRange(x + 1, y) && inRange(x + 2, y) && inRange(x + 1, y + 1)) {
+		sum = (map[x][y] + map[x + 1][y] + map[x + 2][y] + map[x + 1][y + 1]);
+		maxDistance = maxDistance > sum ? maxDistance : sum;
+	}
+	// 3. ㅗ
+	if (inRange(x, y + 1) && inRange(x - 1, y + 1) && inRange(x, y + 2)) {
+		sum = (map[x][y] + map[x][y + 1] + map[x - 1][y + 1] + map[x][y + 2]);
+		maxDistance = maxDistance > sum ? maxDistance : sum;
+	}
+	// 4. ㅓ
+	if (inRange(x, y + 1) && inRange(x - 1, y + 1) && inRange(x + 1, y + 1)) {
+		sum = (map[x][y] + map[x][y + 1] + map[x - 1][y + 1] + map[x + 1][y + 1]);
+		maxDistance = maxDistance > sum ? maxDistance : sum;
+	}
+	return;
+}
+
+int main() {
+	int i, j;
+	cin.tie(NULL);
+
+	cin >> n >> m;
+
+	for (i = 1; i <= n; i++) {
+		for (j = 1; j <= m; j++) {
+			cin >> map[i][j];
+		}
+	}
+
+	for (i = 1; i <= n; i++) {
+		for (j = 1; j <= m; j++) {
+			visited[i][j] = true;
+			checkingTetromino(i, j, map[i][j], 1);
+			visited[i][j] = false;
+			checkingParticular(i, j);
+		}
+	}
+
+	cout << maxDistance << "\n";
+
+
+	return 0;
+}
+
+/*
+	4개의 정사각형이 이어져있는 경우 -> 테트로미노라고 부른다.
+
+	주어진 맵에서 테트로미노 하나 놓았을 때, 최고점이 되는 경우의
+	점수를 return하면 된다.
+
+	reference 참고해서 ㅗ, ㅜ, ㅓ, ㅏ case를 따로 살펴야 함을 알았다.
+*/