Quartz sync: Jun 2, 2025, 3:59 PM

Author: codeyoma

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

@@ -1,6 +1,8 @@
 ---
-created: 2025/3/19 16:38:39
-modified: 2025/4/04 11:42:10
+description:
+aliases:
+created: 2025-05-18
+modified: 2025-06-02
 tags:
   - review
 ---
@@ -14,96 +16,61 @@ tags:
 			-  (for문은 항상 `depth`부터)
 			- 재귀 호출시 `depth + 1`
 - prev_permutation
-```cpp
-    int n = 4; // 전체 개수
-    int r = 2; // 조합 개수
-    
-    vector<bool> v(n);
-    fill(v.begin(), v.begin() + r, true);  // 처음 r개를 true로 설정
-
-    cout << endl; 
-    
-    do {
-        for (int i = 0; i < n; ++i) {
-            if (v[i]) {
-                cout << i << " ";
-            }
-        }
-        cout << endl;
-    } while (prev_permutation(v.begin(), v.end()));
-```
-
-- 조합 속 순열
-```cpp
-#include <iostream>
-#include <algorithm>
-#include <vector>
-
-using namespace std;
-
-int main() {
-    // Write C++ code here
-    int n = 4; // 전체 개수
-    int r = 4; // 조합 개수
- 
-    // 조합속 순열    
-    vector<char> set = {'A', 'B', 'C', 'D'};
-    vector<bool> vv(set.size());
-    fill(vv.begin(), vv.begin() + r, true);
-    
-    do {
-        vector<char> temp;
-        for (int i = 0; i < set.size(); i++){
-            if(vv[i])
-            {
-                temp.push_back(set[i]);
-            }
-        }
-        
-        do {
-            for (char t: temp){
-                cout << t << ' ' ;
-            }
-            cout << endl;
-        }while (next_permutation(temp.begin(), temp.end()));
-        
-    } while (prev_permutation(vv.begin(), vv.end())); 
-    return 0;
-}
-```
+	- code
+	- 
+		```cpp
+		    int n = 4; // 전체 개수
+		    int r = 2; // 조합 개수
+		    
+		    vector<bool> v(n);
+		    fill(v.begin(), v.begin() + r, true);  // 처음 r개를 true로 설정
+		
+		    cout << endl; 
+		    
+		    do {
+		        for (int i = 0; i < n; ++i) {
+		            if (v[i]) {
+		                cout << i << " ";
+		            }
+		        }
+		        cout << endl;
+		    } while (prev_permutation(v.begin(), v.end()));
+		```
 - recursive
-	- 소스 배열
-	- 현재 배열
-	- 타겟 조합 크기
-	- 깊이
-	- 종료 조건
-		- 타겟 조합 크기에 도달
-		- 깊이가 source_arr의 길이보다 큰 경우 (마지막)
-```cpp
-#include <iostream>
-#include <vector>
-using namespace std;
-
-void combine(vector<int>& arr, vector<int>& current, int depth, int k) {
-    if (current.size() == k) {
-        for (int num : current) cout << num << " ";
-        cout << "\n";
-        return;
-    }
-
-    for (int i = depth; i < arr.size(); i++) {
-        current.push_back(arr[i]);
-        combine(arr, current, i + 1, k);
-        current.pop_back();
-    }
-}
-
-int main() {
-    vector<int> arr = {1, 2, 3, 4};
-    int k = 2;
-    vector<int> current;
-
-    combine(arr, current, 0, k);
-    return 0;
-}
-```
+	- logic
+		- 소스 배열
+		- 현재 배열
+		- 타겟 조합 크기
+		- 깊이
+		- 종료 조건
+			- 타겟 조합 크기에 도달
+			- 깊이가 source_arr의 길이보다 큰 경우 (마지막)
+	- 
+		```cpp
+		#include <iostream>
+		#include <vector>
+		using namespace std;
+		
+		void combine(vector<int>& arr, vector<int>& current, int depth, int k) {
+			if (current.size() == k) {
+				for (int num : current) cout << num << " ";
+				cout << "\n";
+				return;
+			}
+		
+			for (int i = depth; i < arr.size(); i++) {
+				current.push_back(arr[i]);
+				combine(arr, current, i + 1, k);
+				current.pop_back();
+			}
+		}
+		
+		int main() {
+			vector<int> arr = {1, 2, 3, 4};
+			int k = 2;
+			vector<int> current;
+		
+			combine(arr, current, 0, k);
+			return 0;
+		}
+		```

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

@@ -1,6 +1,8 @@
 ---
-created: 2025/3/19 17:17:09
-modified: 2025/5/06 09:28:12
+description:
+aliases:
+created: 2025-05-18
+modified: 2025-06-02
 tags: []
 ---
 
@@ -17,35 +19,39 @@ tags: []
 # pre-order DFS
 - 방문 자체가 목적일 때
 	- 백트래킹 (경로 탐색, 조합, 순열)
-```cpp
-void dfs(Node* node) {
-	if (!node) return;
-	visit(node);
-	dfs(node->left);
-	dfs(node->right);
-}
-``` 
+	- 
+		```cpp
+		void dfs(Node* node) {
+			if (!node) return;
+			visit(node);
+			dfs(node->left);
+			dfs(node->right);
+		}
+		``` 
 - 간선 만 주어진 경우의 부모 찾기
-	```python
-	def dfs(u):
-		visit[u] = true
-		
-		for v in adj[u]:
-			if not visit[v]:
-				parent[v] = u
-				dfs(v)
-	```
+	- ![[Tree#^129bd4]]
+	- 
+		```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
-void dfs(Node* node) {
-	if (!node) return;
-	dfs(node->left);
-	visit(node);
-	dfs(node->right);
-}
-```
+	- 
+		```cpp
+		void dfs(Node* node) {
+			if (!node) return;
+			dfs(node->left);
+			visit(node);
+			dfs(node->right);
+		}
+		```
 
 # post-order DFS
 - 결과를 누적하거나 처리할 때
@@ -54,11 +60,12 @@ void dfs(Node* node) {
 		- 용량 계산 (하위 폴더 다 처리 후, 부모 처리)
 	- 트리 DP
 	- [[Hierholzer's algorithm]] ([[Eulerian Path|오일러 경로]])
-```cpp
-void dfs(Node* node) {
-	if (!node) return;
-	dfs(node->left);
-	dfs(node->right);
-	visit(node);
-}
-```
+	- 
+		```cpp
+		void dfs(Node* node) {
+			if (!node) return;
+			dfs(node->left);
+			dfs(node->right);
+			visit(node);
+		}
+		```

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

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

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

@@ -1,6 +1,8 @@
 ---
-created: 2025/3/19 17:07:27
-modified: 2025/4/03 16:10:09
+description:
+aliases:
+created: 2025-05-18
+modified: 2025-06-02
 tags: []
 ---
 
@@ -17,17 +19,18 @@ tags: []
 		- 무향 그래프
 			- union-find
 				- 간선 추가시 이미 같은 그룹이라면 사이클
-				```cpp
-				bool unionSet(int a, int b) {
-				    int rootA = find(a);
-				    int rootB = find(b);
-				
-				    if (rootA == rootB) return true; // ❌ 이미 같은 그룹이면 사이클 발생
-				
-				    parent[rootB] = rootA; // 두 집합을 합침
-				    return false;
-				}
-				```
+				- 
+					```cpp
+					bool unionSet(int a, int b) {
+					    int rootA = find(a);
+					    int rootB = find(b);
+					
+					    if (rootA == rootB) return true; // ❌ 이미 같은 그룹이면 사이클 발생
+					
+					    parent[rootB] = rootA; // 두 집합을 합침
+					    return false;
+					}
+					```
 			- dfs
 				- 방문한 노드가 다시 나왔는데, 부모가 아니라면 사이클
 		- 방향 그래프

content/Computer Science/1 Foundations & Theory/Algorithms/Minimum Spanning Tree (MST) - 최소 신장 트리.md

@@ -7,8 +7,8 @@ modified: 2025/5/06 09:24:30
 	- 트리의 속성을 만족하는 그래프 ![[Tree#^13f174]]
 - 최소 신장 트리
 	- 가능한 신장 트리 중에서, 간선의 가중치 합이 최소인 트리
-		- 최소 비용으로 연결된 경로
-			- 통신사에서 네트워크를 전국에 깔 때
-				- 여러 도시를 통신망(케이블, 광섬유 등)으로 연결할 때, 비용을 최소화하면서 모든 도시를 연결
+	- 최소 비용으로 연결된 경로
+	- 통신사에서 네트워크를 전국에 깔 때
+		- 여러 도시를 통신망(케이블, 광섬유 등)으로 연결할 때, 비용을 최소화하면서 모든 도시를 연결
 - ![[Kruskal's Algorithm]]
 - ![[Prim's Algorithm]]