Quartz sync: Aug 19, 2025, 5:11 PM

Author: codeyoma

content/Computer Science/1 Foundations & Theory/Algorithms/Greedy.md

@@ -1,8 +1,17 @@
-- 부분 최적
-- 현재 가장 최상인 경우 선택
-	- 미래의 경우를 생각 안하고
-	- 이 경우 항상 최적해 보장 못함
-- 단, 미래의 경우에 영향일 미치지 않는다면, 항상 최적해 보장
+---
+description:
+aliases:
+created: 2025-03-22
+modified: 2025-08-19
+---
+
+- 최적 부분 구조
+- 탐욕적 선택 속성
+	- 현재 가장 최상인 경우 선택
+		- 미래의 경우를 생각 안하고
+		- 이 경우 항상 최적해 보장 못함
+	- 단, 미래의 경우에 영향일 미치지 않는다면, 항상 최적해 보장
+		- 지금 당장의 최적이 전체의 최적해를 보장한다면
 - 거스름돈 최적화
 	- 1, 5, 10, 50원 의 경우 '65원' 최적해 보장
 		- 50, 10, 5

content/Computer Science/1 Foundations & Theory/Algorithms/Quick Sort.md

@@ -7,66 +7,71 @@ tags:
 references:
   - https://www.youtube.com/watch?v=PgBzjlCcFvc
 ---
-
--  가장 쉬운 버전
-	- 피벗은 가장 왼쪽 값
-	- 피벗 보다 작으면 왼쪽 임시 리스트에 추가
-	- 크거나 같으면 오른쪽 임시 리스트에 추가
-	- return `quicksort(left) + [pivot] + quicksort(right)`
-	- ```python
-		def qsort(data):
-			if len(data) <= 1:
-				return data
-				
-			pivot = data[0]
+# Choice of Pivot
+- 처음, 마지막 요소 피벗
+- 랜덤 요소 피벗
+- 중앙값 피벗
+# Partition Algorithm
+##  Naive Partition
+- 피벗은 가장 왼쪽 값(혹은 마지막)
+- 피벗 보다 작으면 왼쪽 임시 리스트에 추가
+- 크거나 같으면 오른쪽 임시 리스트에 추가
+- return `quicksort(left) + [pivot] + quicksort(right)`
+- ```python
+	def qsort(data):
+		if len(data) <= 1:
+			return data
 
-			left, right = list(), list()
-			for index in range(1, len(data)):
-				if pivot > data[index]:
-					left.append(data[index])
-				else:
-					right.append(data[index])
-					
-			#left = [ item for item in data[1:] if pivot > item]
-			#right = [ item for item in data[1:] if pivot <= item]
+		pivot = data[0]
 
-			return qsort(left) + [pivot] + qsort(right)
-- 최적 버전
-	- 최초 조건
-		- left_index = -1 (pivot 보다 같거나 작은 값 )
-		- right_index = 0 (looping 용 index) 
-	- left_index < right_index
-	- 맨 오른쪽 요소를 pivot으로 삼는다
+		left, right = list(), list()
+		for index in range(1, len(data)):
+			if pivot > data[index]:
+				left.append(data[index])
+			else:
+				right.append(data[index])
+				
+		#left = [ item for item in data[1:] if pivot > item]
+		#right = [ item for item in data[1:] if pivot <= item]
+	
+		return qsort(left) + [pivot] + qsort(right)
+
+## Lomuto Partition
+- 최초 조건
+	- left_index = -1 (pivot 보다 같거나 작은 값 )
+	- right_index = 0 (looping 용 index) 
+- left_index < right_index
+- 맨 오른쪽 요소를 pivot으로 삼는다
+- loop
 	- right_index 요소와 pivot 비교
 		- 같거나 작으면 `left_index++` + `swap(arr[left_index], arr[right_index])`
 		- 크면 pass
 	- `right_index++`
-	- right_index가 pivot 위치 전까지 오면 `swap(arr[left_index + 1], arr[pivot])`
-		- pivot은 제자리에 가게됨
-	- left_side, right_side 재귀로 quick_sort 호출 
-	- ```cpp
-		void quickSort(int arr[], int low, int high){
-			if (low < high){
-				int pivot_index = partition(arr, low, high);
-		
-				quickSort(arr, low, pivot_index - 1);
-				quickSort(arr, pivot_index + 1, high)
-			}
+- right_index가 pivot 위치 전까지 오면 `swap(arr[left_index + 1], arr[pivot])`
+	- pivot은 제자리에 가게됨
+- left_side, right_side 재귀로 quick_sort 호출 
+- ```cpp
+	void quickSort(int arr[], int low, int high){
+		if (low < high){
+			int pivot_index = partition(arr, low, high);
+	
+			quickSort(arr, low, pivot_index - 1);
+			quickSort(arr, pivot_index + 1, high)
 		}
+	}
+	
+	int partition(int arr[], int low, int high){
+		int pivot = arr[high];
+		int left_index = (low - 1);
 
-		int partition(int arr[], int low, int high){
-			int pivot = arr[high];
-			int left_index = (low - 1);
-			
-			for (right_index = low; right_index <= high - 1; right_index++){
-				if (arr[right_index] <= pivot){
-					left_index++;
-					swap(&arr[left_index], &arr[right_index]);	
-				}
+		for (right_index = low; right_index <= high - 1; right_index++){
+			if (arr[right_index] <= pivot){
+				left_index++;
+				swap(&arr[left_index], &arr[right_index]);	
 			}
-			swap(&arr[left_index + 1], &arr[high]);
-			return (left_index + 1);
 		}
-		
-	- [ ] 버전 1의 퀵소트의 동작 방법 더 간략히 정리 #context
+		swap(&arr[left_index + 1], &arr[high]);
+		return (left_index + 1);
+	}
+	
 

content/Computer Science/1 Foundations & Theory/Algorithms/ps/boj/10162/10162.md

@@ -0,0 +1,60 @@
+---
+tags: ["ps/boj/bronze/3", "ps/boj/bronze", "cs/algorithms/mathematics/ps","cs/algorithms/implementation/ps","cs/algorithms/greedy/ps"]
+---
+
+# Problem
+- [https://www.acmicpc.net/problem/10162](https://www.acmicpc.net/problem/10162)
+
+# Logic
+##### 문제 유형 파악
+
+##### 제약 조건 파악
+
+##### 수도 코드 작성
+
+##### 구현
+
+##### 최적화 및 테스트
+
+##### 개선 가능점
+
+# My Code
+
+## cpp
+
+```cpp title="boj/10162.cpp"
+
+#include <vector>
+void solution() {
+    vector<int> timer = { 300, 60, 10 };
+    vector<int> push_count(3, 0);
+
+    int t;
+    cin >> t;
+
+    for (size_t i = 0; i < timer.size(); ++i) {
+        push_count[i] = t / timer[i];
+        t %= timer[i];
+    }
+
+    if (t) {
+        cout << -1;
+    } else {
+        cout << push_count[0] << " " << push_count[1] << " " << push_count[2];
+    }
+}
+
+
+```
+
+## python
+
+```python title="boj/10162.py"
+
+
+
+def solve():
+    return
+
+
+```

content/Computer Science/1 Foundations & Theory/Algorithms/ps/boj/10870/10870.md

@@ -0,0 +1,70 @@
+---
+tags: ["ps/boj/bronze/2", "ps/boj/bronze", "cs/algorithms/mathematics/ps","cs/algorithms/implementation/ps"]
+---
+
+# Problem
+- [https://www.acmicpc.net/problem/10870](https://www.acmicpc.net/problem/10870)
+
+# Logic
+##### 문제 유형 파악
+
+##### 제약 조건 파악
+
+##### 수도 코드 작성
+
+##### 구현
+
+##### 최적화 및 테스트
+
+##### 개선 가능점
+
+# My Code
+
+## cpp
+
+```cpp title="boj/10870.cpp"
+
+#include <vector>
+int fibo(int n) {
+    if (n <= 2) {
+        return 1;
+    }
+    return fibo(n - 1) + fibo(n - 2);
+}
+
+int dp(int n) {
+    int before = 1;
+    int after  = 1;
+
+    for (int i = 3; i <= n; ++i) {
+        int temp = before;
+        before   = after;
+        after    = temp + before;
+    }
+
+    return after;
+}
+
+void solution() {
+    int n;
+    cin >> n;
+    // dp
+    cout << dp(n);
+    // recursive
+    // cout << fibo(n);
+}
+
+
+```
+
+## python
+
+```python title="boj/10870.py"
+
+
+
+def solve():
+    return
+
+
+```

content/Computer Science/1 Foundations & Theory/Algorithms/ps/boj/10872/10872.md

@@ -0,0 +1,54 @@
+---
+tags: ["ps/boj/bronze/3", "ps/boj/bronze", "cs/algorithms/mathematics/ps","cs/algorithms/implementation/ps"]
+---
+
+# Problem
+- [https://www.acmicpc.net/problem/10872](https://www.acmicpc.net/problem/10872)
+
+# Logic
+##### 문제 유형 파악
+
+##### 제약 조건 파악
+
+##### 수도 코드 작성
+
+##### 구현
+
+##### 최적화 및 테스트
+
+##### 개선 가능점
+
+# My Code
+
+## cpp
+
+```cpp title="boj/10872.cpp"
+
+#include <vector>
+
+int fac(int n) {
+    if (n <= 1) {
+        return 1;
+    }
+    return n * fac(n - 1);
+}
+void solution() {
+    int n;
+    cin >> n;
+    cout << fac(n);
+}
+
+
+```
+
+## python
+
+```python title="boj/10872.py"
+
+
+
+def solve():
+    return
+
+
+```