dpfls0922

WEEK3-B/dpfls0922/README.md

@@ -0,0 +1,102 @@
+> # WEEK3-자료구조
+#### 1. 스택
+#### 2. 큐
+#### 3. 리스트
+</br>
+
+# 1️⃣ 스택
+* LIFO(Last-in First-out) 후입선출 규칙을 따르는 자료구조
+* 새로운 원소는 스택의 맨 위(top)에 추가되고 원소를 뺄 때는 맨 위(top)에 원소가 나오는 것
+* 즉, 입구와 출구가 하나인 경우
+* #include <stack>을 하여 c++ stl 라이브러리를 사용함
+
+## 연산
+* push(x)
+  </br>
+  x라는 항목을 스택 맨 위에 삽입 
+* pop() 
+  </br>
+  스택 맨 위에 있는 항목을 삭제 
+* empty() 
+  </br>
+  스택이 비어있는지를 확인 후 true,false 값을 반환 
+* size()
+  </br> 
+  스택에 들어있는 원소의 개수를 반환 
+* top() 
+  </br>
+  스택 맨 위에 있는 항목을 리턴
+
+# 2️⃣ 큐
+*  FIFO(First-in First-out) 선입선출 규칙을 따르는 자료구조
+* 원소를 꺼낼 때는 맨 위에서 꺼내고 원소를 넣을 때는 맨 밑부터 넣는 것
+* 즉. 입구와 출구가 각각 있는 것
+* #include <queue>을 하여 c++ stl라이브러리를 사용함
+
+## 연산
+* push(x) 
+   </br>
+   x라는 항목을 큐의 맨 끝에 삽입
+* pop()
+  </br>
+  큐의 맨 앞에 있는 항목을 삭제 
+* front()
+  </br>
+  큐의 맨 앞에 있는 항목을 리턴 
+* back()
+  </br>
+  큐의 맨 뒤에 있는 항목을 리턴 
+* empty(),size()
+  </br>
+  큐가 비어있는지 검사, 큐에 들어있는 원소의 개수 반환
+
+# 3️⃣ 리스트
+* 시퀀스 컨테이너 (sequence container)의 일종으로 순서를 유지하는 자료구조
+* #include <list> 하여 c++ stl라이브러리를 사용함
+
+## 관련 함수
+#### 반복자
+* begin()
+  </br>
+  beginning iterator 반환
+* end()
+  </br>
+  end iterator 반환
+#### 삽입
+* push_front(element)
+  </br>
+  리스트 맨 앞에 원소 추가
+* push_back(element)
+  </br>
+  리스트 맨 뒤에 원소 추가
+* insert(iterator, element)
+  </br>
+  iterator가 가리키는 부분의 앞에 원소 추가
+#### 삭제
+* pop_front()
+  </br>
+  리스트 맨 앞의 원소 삭제
+* pop_back()
+  </br>
+  리스트 맨 뒤의 원소 삭제
+* erase(iterator)
+  </br>
+  iterator가 가리키는 부분의 원소 삭제
+#### 조회
+* ( * )iterator
+  </br>
+  iterator가 가리키는 원소에 접근
+* front()
+  </br>
+  첫번째 원소 반환
+* back()
+  </br>
+  마지막 원소 반환
+
+#### 기타
+* empty()
+  </br>
+  리스트가 비어있는지 여부
+* size()
+  </br>
+  리스트 사이즈 반환

WEEK3-B/dpfls0922/boj11723.cpp

@@ -0,0 +1,42 @@
+#include <bits/stdc++.h>
+#include <vector>
+using namespace std;
+
+int main(){
+    int tc, x;
+    string func;
+    int alp[21] = {0, };
+    string function[6] = {"add", "remove", "check", "toggle", "all", "empty"};
+    cin >> tc;
+    for(int i=0; i<tc; i++){
+        cin >> func;
+        for(int j=0; j<6; j++){
+            int idx = (func == function[i]);
+            switch(idx){
+                case 1:  // add
+                cin >> x;
+                alp[x] = 1;
+                break;
+                // x ������ continue
+                case 2:  // remove
+                cin >> x;
+                alp[x] = 0;
+                break;////
+                case 3: // check
+                cin >> x;
+                int state = alp[x]==1 ? 1 : 0;
+                cout << state << '\n';
+                case 4: // toggle
+                cin >> x;
+                alp[x]==1 ? alp[x]=0 : alp[x]=1;
+                case 5: // all
+                for(int i=0; i<21; i++)
+                    alp[i]=1;
+                case 6: //empty
+                for(int i=0; i<21; i++)
+                    alp[i]=1;
+            }
+        }
+    }
+    return 0;
+}

WEEK3-B/dpfls0922/boj15953.cpp

@@ -0,0 +1,31 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main(){
+    int tc, x, y, money1, money2, rank;
+    int ct1_reward[6] = {500, 300, 200, 50, 30, 10};
+    int ct2_reward[5] = {512, 256, 128, 64, 32};
+
+    cin >> tc;
+    for(int i=0; i<tc; i++){
+        rank = 0, money1=0, money2=0;
+        cin >> x >> y;
+        for(int j=1; j<7; j++){
+            rank += j;
+            if( x <= rank){
+                money1 = ct1_reward[j-1];
+                break;
+            }
+        }
+        rank = 0;
+        for(int j=1; j<6; j++){
+            rank += pow(2, j-1);
+            if( y <= rank){
+                money2 = ct2_reward[j-1];
+                break;
+            }
+        }    
+        cout << (money1+money2)*10000<<'\n';
+    }
+    return 0;
+}

WEEK3-B/dpfls0922/boj2941.cpp

@@ -0,0 +1,17 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() {
+    string str;
+    cin >> str;
+    string croatia[8] = {"c=", "c--", "dz=", "d=", "lj", "nj", "s=", "z="};
+    for (int i = 0; i < 8; i++) {
+        while(true){
+            int idx = str.find(croatia[i]);
+            if (idx == string::npos)break;
+            str.replace(idx, croatia[i].length(), "a");
+        }
+    }
+    cout << str.length();
+    return 0;
+}

WEEK3-B/dpfls0922/boj5086.cpp

@@ -0,0 +1,14 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main(){
+    int x, y;
+    while(1){
+        cin >> x >> y;
+        if(x==0 && y==0) break;
+        if(x%y==0) cout << "multiple" << '\n';
+        else if(y%x==0) cout << "factor" << '\n';
+        else cout << "neither" << '\n';
+        }
+    return 0;
+}

WEEK4-B/boj13706.py

@@ -0,0 +1,13 @@
+def binary_search(s, e):
+    target = e
+    while True:
+        mid = (s + e) // 2
+        if (mid ** 2) == target:
+            return mid
+        if mid ** 2 > target:
+            e = mid
+        elif mid ** 2 < target:
+            s = mid
+
+N = int(input())
+print(binary_search(1, N))

WEEK4-B/dpfls0922/README.md

@@ -0,0 +1,134 @@
+> # WEEK4-분할정복
+#### 1. 재귀
+#### 2. 이분 탐색
+#### 3. 큰 수 연산
+</br>
+
+# 1️⃣ 재퀴
+## 정의
+* 재귀(recursion)는 어떤 것을 정의할 때 자기 자신을 참조하는 것을 뜻함
+* 재귀 함수 : 재귀 호출(recursive call)을 사용하는 함수
+* 재귀 호출 : 어떤 함수가 내부에서 자기 자신을 다시 호출하는 것
+* 재귀 호출을 사용할 경우 언제 호출을 그만둘 것인지를 정의해야 함. 그렇지 않으면 무한루프처럼 계속 자기 자신을 호출하게 됨
+
+## 장단점
+* 장점
+* * 일반적인 수학의 점화식을 그대로 표현가능한 능력을 가지고 있어 복잡한 문제를 간단하고 논리적으로 표현할 수 있음 
+* * 변수의 사용을 줄일 수 있음
+* * 프랙탈, 분할 반복 등에서 엄청난 효율을 보여줌
+
+* 단점
+* * 함수의 call이 반복되므로 stack의 메모리를 많이 사용하여 stack overflow의 위험이 큼
+
+
+
+# 2️⃣ 이분 탐색
+## 정의
+* 오름차순으로 정렬된 리스트에서 특정한 값의 위치를 찾는 알고리즘
+* 오름차순으로 정렬된 리스트의 중간 값을 임의의 값으로 선택하여, 찾고자 하는 Key 값과 비교하는 동작을 반복함
+* 순차적으로 탐색하는 일반 탐색 기법과 달리, 이분 탐색은 탐색 대상을 절반씩 없애며 탐색함
+* 데이터의 양이 많아질 수록 이분 탐색이 효율적인 알고리즘이 됨
+
+## 장단점
+* 장점
+* * 검색이 될때마다 선형탐색(Linear Search)와는 비교할 수 없게 빨라짐
+* 단점
+* * 정렬된 리스트에서만 사용할 수 있음
+
+## 시간 복잡도
+* log2n
+* O(log n)
+
+## 이진 탐색의 구현
+1) 반복문
+``` C++
+bool BinarySearch(int *arr, int len, int key){
+    int start = 0;
+    int end = len-1;
+    int mid;
+
+    while(end - start >= 0) {
+        mid = (start + end) / 2; 
+
+        if (arr[mid] == key)
+            return true;
+
+        else if (arr[mid] > key)
+            end = mid - 1;
+
+        else
+            start = mid + 1;
+    }
+    return false;
+}
+```
+2) 재귀
+``` C++
+bool BinarySearch(int *arr, int start, int end, int key) {
+
+    if (start > end) return false;
+
+    int mid = (start + end) / 2;
+
+    if (arr[mid] == key)
+        return true;
+
+    else if (arr[mid] > key)
+        return BinarySearch(arr, start, mid - 1, key);
+
+    else 
+        return BinarySearch(arr, mid + 1, end, key);
+    }
+}
+```
+3) STL
+* <algorithm> 해더 파일안에 있는 binary_search 함수를 이용하면 됨
+``` C++
+template <class ForwardIterator, class T>
+  bool binary_search (ForwardIterator first, ForwardIterator last, const T& val)
+```
+
+# 3️⃣ 큰 수 연산
+  자료형으로 담을 수 있는 범위를 벗어나는 경우
+1) 배열, 벡터 이용
+2) 문자열 string 이용
+  ``` C++
+// 문자열 덧셈
+string add(string& a, string& b) {
+	string c(max(a.size(), b.size()), '0');
+	int  sum = 0;
+	for (int i = 0; i < c.size(); i++) {
+		if (i < a.size()) sum += a[a.size() - i - 1] - '0';
+		if (i < b.size()) sum += b[b.size() - i - 1] - '0';
+		c[c.size() - i - 1] = sum % 10 + '0';
+
+		sum /= 10;
+	}
+	if (sum) c.insert(c.begin(), '1');
+	return c;
+}
+```
+``` C++
+// 문자열 곱셈
+string multiply(string& a, string& b) {
+	string c = "0";
+	for (int i = 0; i < b.size(); i++) {
+		string line(a);
+		int carry = 0;
+		for (int j = a.size()-1; j >= 0; j--) {
+			int sum = carry;
+			carry = 0;
+			sum += (a[j] - '0') * (b[b.size() - i - 1] - '0');
+			if (sum >= 10) {
+				carry = sum / 10;
+				sum %= 10;
+			}
+			line[j] = sum + '0';
+		}
+		if (carry > 0) line.insert(line.begin(), carry + '0');
+		line += string(i, '0');
+		c = add(c, line);
+	}
+	return c;
+}
+```         

WEEK4-B/dpfls0922/boj1074.cpp

@@ -0,0 +1,32 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int n, row, col;
+int ans = 0;
+
+void Z(int r, int c, int size) {
+
+    if (r == row && c == col){
+        cout << ans << '\n';
+        return;
+    }
+
+	if (row >= r && row < r + size && col >= c && col < c + size) {
+		Z(r, c, size / 2);
+		Z(r, c + size / 2, size / 2);
+		Z(r + size / 2, c, size / 2);
+		Z(r + size / 2, c + size / 2, size / 2);
+	}
+	else
+		ans += size * size;
+}
+
+int main() {
+	ios_base::sync_with_stdio(false);
+	cin.tie(NULL);
+
+	cin >> n >> row >> col;
+	Z(0, 0, (1 << n));
+
+	return 0;
+}