Quartz sync: Jun 9, 2025, 10:10 PM

Author: codeyoma

content/Computer Science/1 Foundations & Theory/Algorithms/0-1 BFS.md

@@ -3,21 +3,20 @@ created: 2025/5/07 14:26:48
 modified: 2025/5/07 14:28:34
 ---
 - bfs임으로 먼저 방문한 것이 최단 거리
-```cpp
-deque<int> dq;
-dist[start] = 0;
-dq.push_front(start);
-
-while (!dq.empty()) {
-    int u = dq.front(); dq.pop_front();
-    for (auto [v, w] : adj[u]) {
-        if (dist[v] > dist[u] + w) {
-            dist[v] = dist[u] + w;
-            if (w == 0) dq.push_front(v);
-            else dq.push_back(v);
-        }
-    }
-}
-```
+- ```cpp
+	deque<int> dq;
+	dist[start] = 0;
+	dq.push_front(start);
+	
+	while (!dq.empty()) {
+	    int u = dq.front(); dq.pop_front();
+	    for (auto [v, w] : adj[u]) {
+	        if (dist[v] > dist[u] + w) {
+	            dist[v] = dist[u] + w;
+	            if (w == 0) dq.push_front(v);
+	            else dq.push_back(v);
+	        }
+	    }
+	}
 - 거리 비교가 필요 없을 경우, 그냥 넘기기(이미 그 거리가 최적이므로)
 - `(dist[x][y] != -1) continue;`

content/Computer Science/1 Foundations & Theory/Algorithms/Binary Search.md

@@ -9,67 +9,63 @@ modified: 2025/5/01 11:16:57
 		- 가능하면 -> 더 좋은 값으로 이동
 		- 불가능하면 -> 가능한 값으로 이동
 - 값 찾기
-```cpp
-int binary_search(int[] nums, int target){
-	int left = 0;
-	int right = nums.length - 1;
-	while (left <= right){
-		int mid = left + (right - left) / 2;
-		if (nums[mid] == target){
-			return mid;
-		} else if (nums[mid] < target){
-			left = mid + 1;
-		} else if (nums[mid] > target){
-			right = mid - 1;
+	-  ```cpp
+		int binary_search(int[] nums, int target){
+			int left = 0;
+			int right = nums.length - 1;
+			while (left <= right){
+				int mid = left + (right - left) / 2;
+				if (nums[mid] == target){
+					return mid;
+				} else if (nums[mid] < target){
+					left = mid + 1;
+				} else if (nums[mid] > target){
+					right = mid - 1;
+				}
+			}
+			return -1;
 		}
-	}
-	return -1;
-}
 
-```
 - 왼쪽 가장자리 값 찾기
-```cpp
-int left_bound(int[] nums, int target){
-	int left = 0;
-	int right = nums.length - 1;
-	while (left <= right){
-		int mid = left + (right - left) / 2;
-		if (nums[mid] == target){
-			// 반환 안하고 오른쪽 가장자리를 축소하여 왼쪽 가장자리 확정
-			right = mid - 1;
-		} else if (nums[mid] < target){
-			left = mid + 1;
-		} else if (nums[mid] > target){
-			right = mid - 1;
+	- ```cpp
+		int left_bound(int[] nums, int target){
+			int left = 0;
+			int right = nums.length - 1;
+			while (left <= right){
+				int mid = left + (right - left) / 2;
+				if (nums[mid] == target){
+					// 반환 안하고 오른쪽 가장자리를 축소하여 왼쪽 가장자리 확정
+					right = mid - 1;
+				} else if (nums[mid] < target){
+					left = mid + 1;
+				} else if (nums[mid] > target){
+					right = mid - 1;
+				}
+			}
+			// left 경계확인
+			if (left > nums.length || nums[left] != target)
+				return -1;
+			return left;
 		}
-	}
-	// left 경계확인
-	if (left > nums.length || nums[left] != target)
-		return -1;
-	return left;
-}
 
-```
 - 오른쪽 가장자리 값 찾기
-```cpp
-int right_bound(int[] nums, int target){
-	int left = 0;
-	int right = nums.length - 1;
-	while (left <= right){
-		int mid = left + (right - left) / 2;
-		if (nums[mid] == target){
-			// 반환 안하고 왼쪽 가장자리를 축소하여 오른쪽 가장자리 확정
-			left = mid + 1;
-		} else if (nums[mid] < target){
-			left = mid + 1;
-		} else if (nums[mid] > target){
-			right = mid - 1;
+	- ```cpp
+		int right_bound(int[] nums, int target){
+			int left = 0;
+			int right = nums.length - 1;
+			while (left <= right){
+				int mid = left + (right - left) / 2;
+				if (nums[mid] == target){
+					// 반환 안하고 왼쪽 가장자리를 축소하여 오른쪽 가장자리 확정
+					left = mid + 1;
+				} else if (nums[mid] < target){
+					left = mid + 1;
+				} else if (nums[mid] > target){
+					right = mid - 1;
+				}
+			}
+			// right 경계확인
+			if (right < 0 || nums[right] != target)
+				return -1;
+			return right;
 		}
-	}
-	// right 경계확인
-	if (right < 0 || nums[right] != target)
-		return -1;
-	return right;
-}
-
-```

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

@@ -1,22 +1,20 @@
 - 부분집합으로 많이 사용
 	- 비트마스크 `1 << i` (i -> $2^{n}$ 까지)
 	- 각 마스크(한 조합)별 순회 
-	```cpp
-	int total = 1 << n; // 부분집합 개수: 2^n
-	for (int mask = 0; mask < total; mask++) {
-		for (int i = 0; i < n; i++) {
-			if (mask & (1 << i)) {
+	- ```cpp
+		int total = 1 << n; // 부분집합 개수: 2^n
+		for (int mask = 0; mask < total; mask++) {
+			for (int i = 0; i < n; i++) {
+				if (mask & (1 << i)) {
+				}
 			}
 		}
-	}
-	```
 - 부분집합 순회 테크닉
 	- `mask`를 제외한 남은 집합 계산용으로 효율적
-```cpp
-int mask = 7;
-int FULL = 1 << 8;
-int rest = ~mask & (FULL - 1);
-for (int subset = rest; subset > 0; subset = (subset - 1) & rest){
-    cout << static_cast<bitset<8>>(subset) << endl;
-}
-```
+	- ```cpp
+		int mask = 7;
+		int FULL = 1 << 8;
+		int rest = ~mask & (FULL - 1);
+		for (int subset = rest; subset > 0; subset = (subset - 1) & rest){
+		    cout << static_cast<bitset<8>>(subset) << endl;
+		}

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

@@ -2,7 +2,7 @@
 description:
 aliases:
 created: 2025-05-18
-modified: 2025-06-02
+modified: 2025-06-09
 tags:
   - review
 ---
@@ -16,9 +16,7 @@ tags:
 			-  (for문은 항상 `depth`부터)
 			- 재귀 호출시 `depth + 1`
 - prev_permutation
-	- code
-	- 
-		```cpp
+	- ```cpp
 		    int n = 4; // 전체 개수
 		    int r = 2; // 조합 개수
 		    
@@ -35,7 +33,6 @@ tags:
 		        }
 		        cout << endl;
 		    } while (prev_permutation(v.begin(), v.end()));
-		```
 - recursive
 	- logic
 		- 소스 배열
@@ -45,8 +42,7 @@ tags:
 		- 종료 조건
 			- 타겟 조합 크기에 도달
 			- 깊이가 source_arr의 길이보다 큰 경우 (마지막)
-	- 
-		```cpp
+	- ```cpp
 		#include <iostream>
 		#include <vector>
 		using namespace std;
@@ -72,5 +68,4 @@ tags:
 		
 			combine(arr, current, 0, k);
 			return 0;
-		}
-		```
+		}

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

@@ -19,39 +19,33 @@ tags: []
 # pre-order DFS
 - 방문 자체가 목적일 때
 	- 백트래킹 (경로 탐색, 조합, 순열)
-	- 
-		```cpp
+	- ```cpp
 		void dfs(Node* node) {
 			if (!node) return;
 			visit(node);
 			dfs(node->left);
 			dfs(node->right);
 		}
-		``` 
 - 간선 만 주어진 경우의 부모 찾기
 	- ![[Tree#^129bd4]]
-	- 
-		```python
+	- ```python
 		def dfs(u):
 			visit[u] = true
 			
 			for v in adj[u]:
 				if not visit[v]:
 					parent[v] = u
 					dfs(v)
-		```
 # in-order DFS
 - BST나 중위 수식 등, 정렬 성질 사용
 	- BST 순회 (오름차순 정렬된 값 추출)
-	- 
-		```cpp
+	- ```cpp
 		void dfs(Node* node) {
 			if (!node) return;
 			dfs(node->left);
 			visit(node);
 			dfs(node->right);
 		}
-		```
 
 # post-order DFS
 - 결과를 누적하거나 처리할 때
@@ -60,12 +54,10 @@ tags: []
 		- 용량 계산 (하위 폴더 다 처리 후, 부모 처리)
 	- 트리 DP
 	- [[Hierholzer's algorithm]] ([[Eulerian Path|오일러 경로]])
-	- 
-		```cpp
+	- ```cpp
 		void dfs(Node* node) {
 			if (!node) return;
 			dfs(node->left);
 			dfs(node->right);
 			visit(node);
 		}
-		```

content/Computer Science/1 Foundations & Theory/Algorithms/DP with Bitmask.md

@@ -8,29 +8,27 @@ modified: 2025-05-18
 - 마스크만으로 결정할 수 없는 추가 매개변수 여부에 따라 차원 추가해야한다
 	- TSP → 지금 마지막에 머물러 있는 도시 `last`
 - 전이(transition) 공식
-```cpp
-for each bit i not in mask:
-   if (조건(mask, last, extra, i)) {
-     newMask = mask | (1<<i);
-     newLast = i;           // 필요하면
-     newExtra = update(...);// 필요하면
-     dp[newMask][newLast][newExtra] = max/min(
-         dp[newMask][newLast][newExtra],
-         dp[mask][last][extra] + delta
-     );
-   }
-```
+	- ```cpp
+		for each bit i not in mask:
+		   if (조건(mask, last, extra, i)) {
+		     newMask = mask | (1<<i);
+		     newLast = i;           // 필요하면
+		     newExtra = update(...);// 필요하면
+		     dp[newMask][newLast][newExtra] = max/min(
+		         dp[newMask][newLast][newExtra],
+		         dp[mask][last][extra] + delta
+		     );
+		   }
 - Bitmask DP for Assignment
-```cpp
-for(int mask = 0; mask < FULL; ++mask){
-	// 지금까지 배정된 사람 수 = popcount(mask)
-	int k = __builtin_popcount(mask);
-	// 다음 사람 k 에게 할당할 일 j 탐색
-	for(int j = 0; j < N; ++j){
-		if( (mask & (1 << j)) == 0 ){ 
-			int next = mask | (1 << j);
-			dp[next] = min(dp[next], dp[mask] + cost[k][j]);
+	- ```cpp
+		for(int mask = 0; mask < FULL; ++mask){
+			// 지금까지 배정된 사람 수 = popcount(mask)
+			int k = __builtin_popcount(mask);
+			// 다음 사람 k 에게 할당할 일 j 탐색
+			for(int j = 0; j < N; ++j){
+				if( (mask & (1 << j)) == 0 ){ 
+					int next = mask | (1 << j);
+					dp[next] = min(dp[next], dp[mask] + cost[k][j]);
+				}
+			}
 		}
-	}
-}
-```

content/Computer Science/1 Foundations & Theory/Algorithms/DP 유형.md

@@ -39,8 +39,7 @@ modified: 2025/5/05 21:04:32
 - $[i, j]$ 범위에 최적 해 존재
 - 사칙연산 괄호, 행렬 곱, 문자열 나누기
 - DP 테이블의 상삼각 영역만 주로 사용 (i <= j)
-- 
-	```cpp
+- ```cpp
 	for (int len = 2; len <= n; ++len) {
 		for (int i = 0; i <= n - len; ++i) {
 			int j = i + len - 1;
@@ -50,7 +49,6 @@ modified: 2025/5/05 21:04:32
 			}
 		}
 	}
-	```
 
 # 케이스-분할 (분기형) DP (Case-Split DP)
 - 점화식이 여러개인 경우