.

Author: nodove-0209

code/templates/algorithm-architect/github-pages-docs/.pw-runtime/package-lock.json

@@ -0,0 +1,7 @@
+{
+  "dependencies": {
+    "marked": "^17.0.3",
+    "mermaid": "^11.12.3",
+    "playwright": "^1.58.2"
+  }
+}

code/templates/algorithm-architect/github-pages-docs/.pw-runtime/package.json

@@ -0,0 +1,88 @@
+# BFS (너비 우선 탐색) - GitHub Pages 해설
+
+## 문서 목적
+- 원본 템플릿 `01-graph/01-bfs.md` 의 내부 동작을 GitHub Markdown에서 바로 읽을 수 있게 설명합니다.
+- 코드 레이어(초기화/루프/조건/갱신/종료)를 분해하고, Mermaid로 제어 흐름을 시각화합니다.
+- 실전 문제에 붙일 때 반드시 수정해야 하는 지점을 체크리스트로 제공합니다.
+
+## 원본 템플릿
+- Source: [01-graph/01-bfs.md](../../01-graph/01-bfs.md)
+
+## 내부 메커니즘 (Flow)
+```mermaid
+flowchart TD
+    A[Start Node enqueue] --> B[Queue pop left]
+    B --> C{Target found}
+    C -- Yes --> D[Return result]
+    C -- No --> E[Visit neighbors]
+    E --> F{Unvisited}
+    F -- Yes --> G[Mark visited and enqueue]
+    F -- No --> H[Skip]
+    G --> I{Queue empty}
+    H --> I
+    I -- No --> B
+    I -- Yes --> J[End not found]
+```
+
+## 내부 상호작용 (Sequence)
+```mermaid
+sequenceDiagram
+    participant Q as Queue
+    participant V as Visited
+    participant G as Graph
+    Q->>Q: push start
+    loop while queue not empty
+        Q->>Q: pop
+        Q->>G: get neighbors
+        G-->>Q: neighbor list
+        Q->>V: check visited
+        V-->>Q: true false
+        Q->>Q: push unvisited
+    end
+```
+
+## 핵심 코드
+```python
+# [BFS 템플릿: 아키텍트 버전]
+# Use Case: 최단 거리, 최소 이동 횟수, 레벨별 탐색
+# Components: Queue (FIFO), Visited Set
+# Constraint: 큐에 넣을 때 방문 처리 필수 (중복 방지)
+
+def bfs(start_node, graph, target=None):
+    # 1. 초기화 (Initialization Layer)
+    #    - 큐 생성, 시작점 삽입, 방문 처리
+    queue = [start_node]
+    visited = {start_node}
+    
+    # 2. 메인 루프 (Process Loop)
+    #    - 큐가 빌 때까지 반복
+    while queue:
+        current = queue.pop(0)
+        
+        # 3. 비즈니스 로직 (Core Logic)
+        #    - (필요하다면) 여기서 정답 체크 혹은 데이터 가공
+        if target and current == target:
+            return current
+        
+        # 4. 확장 로직 (Expansion Layer)
+        #    - 연결된 노드 탐색 및 조건 필터링
+        for neighbor in graph[current]:
+            if neighbor not in visited:
+                visited.add(neighbor)
+                queue.append(neighbor)
+    
+    return None  # 탐색 실패
+```
+
+## 코드 레이어 해설
+- **Initialization**: 상태 테이블/포인터/큐/스택/부모 배열 등 탐색의 기준 상태를 만든다.
+- **Process Loop / Recursion**: 입력 공간을 순회하며 상태 전이를 반복한다.
+- **Decision Rule**: 분기 조건(완화 가능 여부, 유효 선택 여부, 종료 조건)을 적용한다.
+- **State Update**: 거리/DP/집합/결과 배열을 갱신하고 다음 단계로 전달한다.
+- **Termination**: 목표 도달, 범위 소진, 큐/스택 고갈, 사이클 검출 등으로 종료한다.
+
+## 실전 적용 체크리스트
+- 입력 자료구조 형식(인접 리스트, 간선 리스트, 정렬 여부, 1-index/0-index)을 먼저 고정한다.
+- 시간 복잡도 한계에 맞게 자료구조를 교체한다 (`list.pop(0)` -> `deque.popleft` 등).
+- 실패/예외 경로를 명시한다 (도달 불가, 음수 사이클, 빈 결과, 사이클 존재).
+- 테스트는 최소 3개: 정상 케이스, 경계 케이스, 반례 케이스를 포함한다.

code/templates/algorithm-architect/github-pages-docs/01-graph/01-bfs.md

@@ -0,0 +1,84 @@
+# DFS (깊이 우선 탐색) - GitHub Pages 해설
+
+## 문서 목적
+- 원본 템플릿 `01-graph/02-dfs.md` 의 내부 동작을 GitHub Markdown에서 바로 읽을 수 있게 설명합니다.
+- 코드 레이어(초기화/루프/조건/갱신/종료)를 분해하고, Mermaid로 제어 흐름을 시각화합니다.
+- 실전 문제에 붙일 때 반드시 수정해야 하는 지점을 체크리스트로 제공합니다.
+
+## 원본 템플릿
+- Source: [01-graph/02-dfs.md](../../01-graph/02-dfs.md)
+
+## 내부 메커니즘 (Flow)
+```mermaid
+flowchart TD
+    A[Enter node] --> B[Mark visited]
+    B --> C{Target}
+    C -- Yes --> D[Return success]
+    C -- No --> E[Iterate neighbors]
+    E --> F{Neighbor unvisited}
+    F -- Yes --> G[Recursive call push stack]
+    F -- No --> H[Continue]
+    G --> I{Need backtrack}
+    I -- Yes --> J[Unchoose state]
+    I -- No --> E
+    J --> E
+    H --> E
+```
+
+## 내부 상호작용 (Sequence)
+```mermaid
+sequenceDiagram
+    participant Caller
+    participant DFS
+    participant Stack
+    Caller->>DFS: dfs start
+    DFS->>DFS: visit node
+    DFS->>Stack: explore neighbor
+    Stack->>DFS: return to parent
+    DFS-->>Caller: found not found
+```
+
+## 핵심 코드
+```python
+# [DFS 템플릿: 아키텍트 버전]
+# Use Case: 경로 탐색, 사이클 검출, 연결 요소 찾기
+# Components: Stack (LIFO) 또는 재귀
+# Constraint: 백트래킹 시 방문 해제 필요한 경우 있음
+
+# [DFS 재귀 버전]
+def dfs_recursive(node, graph, visited=None, target=None):
+    # 1. 초기화 (Initialization Layer)
+    #    - 방문 집합 생성 (최초 호출 시)
+    if visited is None:
+        visited = set()
+    
+    # 2. 방문 처리 (Visit Layer)
+    visited.add(node)
+    
+    # 3. 비즈니스 로직 (Core Logic)
+    #    - 목표 발견 시 조기 종료
+    if target and node == target:
+        return True
+    
+    # 4. 재귀 확장 (Recursive Expansion)
+    #    - 인접 노드로 깊이 우선 탐색
+    for neighbor in graph[node]:
+        if neighbor not in visited:
+            if dfs_recursive(neighbor, graph, visited, target):
+                return True
+    
+    return False
+```
+
+## 코드 레이어 해설
+- **Initialization**: 상태 테이블/포인터/큐/스택/부모 배열 등 탐색의 기준 상태를 만든다.
+- **Process Loop / Recursion**: 입력 공간을 순회하며 상태 전이를 반복한다.
+- **Decision Rule**: 분기 조건(완화 가능 여부, 유효 선택 여부, 종료 조건)을 적용한다.
+- **State Update**: 거리/DP/집합/결과 배열을 갱신하고 다음 단계로 전달한다.
+- **Termination**: 목표 도달, 범위 소진, 큐/스택 고갈, 사이클 검출 등으로 종료한다.
+
+## 실전 적용 체크리스트
+- 입력 자료구조 형식(인접 리스트, 간선 리스트, 정렬 여부, 1-index/0-index)을 먼저 고정한다.
+- 시간 복잡도 한계에 맞게 자료구조를 교체한다 (`list.pop(0)` -> `deque.popleft` 등).
+- 실패/예외 경로를 명시한다 (도달 불가, 음수 사이클, 빈 결과, 사이클 존재).
+- 테스트는 최소 3개: 정상 케이스, 경계 케이스, 반례 케이스를 포함한다.

code/templates/algorithm-architect/github-pages-docs/01-graph/02-dfs.md

@@ -0,0 +1,94 @@
+# 다익스트라 (Dijkstra) - GitHub Pages 해설
+
+## 문서 목적
+- 원본 템플릿 `01-graph/03-dijkstra.md` 의 내부 동작을 GitHub Markdown에서 바로 읽을 수 있게 설명합니다.
+- 코드 레이어(초기화/루프/조건/갱신/종료)를 분해하고, Mermaid로 제어 흐름을 시각화합니다.
+- 실전 문제에 붙일 때 반드시 수정해야 하는 지점을 체크리스트로 제공합니다.
+
+## 원본 템플릿
+- Source: [01-graph/03-dijkstra.md](../../01-graph/03-dijkstra.md)
+
+## 내부 메커니즘 (Flow)
+```mermaid
+flowchart TD
+    A[Init distances INF] --> B[Push start to min heap]
+    B --> C{Heap empty}
+    C -- No --> D[Pop shortest node]
+    D --> E{Stale distance}
+    E -- Yes --> C
+    E -- No --> F[Relax outgoing edges]
+    F --> G{Better distance found}
+    G -- Yes --> H[Update dist and push heap]
+    G -- No --> I[Skip]
+    H --> C
+    I --> C
+    C -- Yes --> J[Return distance table]
+```
+
+## 내부 상호작용 (Sequence)
+```mermaid
+sequenceDiagram
+    participant H as MinHeap
+    participant D as DistTable
+    participant G as Graph
+    H->>H: pop min node
+    H->>G: neighbors node
+    G-->>H: neighbor weight
+    H->>D: compare and relax
+    D-->>H: updated dist
+    H->>H: push updated node
+```
+
+## 핵심 코드
+```python
+# [Dijkstra 템플릿: 아키텍트 버전]
+# Use Case: 가중치 그래프의 최단 경로
+# Components: Priority Queue (Min-Heap), Distance Table
+# Constraint: 음수 가중치 불가
+
+import heapq
+
+def dijkstra(start, graph, n):
+    # 1. 초기화 (Initialization Layer)
+    #    - 거리 테이블 무한대로 초기화
+    #    - 우선순위 큐에 시작점 삽입
+    INF = float('inf')
+    distances = [INF] * (n + 1)
+    distances[start] = 0
+    pq = [(0, start)]  # (거리, 노드)
+    
+    # 2. 메인 루프 (Process Loop)
+    #    - 우선순위 큐가 빌 때까지
+    while pq:
+        current_dist, current_node = heapq.heappop(pq)
+        
+        # 3. 최적화 레이어 (Optimization Layer)
+        #    - 이미 처리된 노드는 스킵
+        if current_dist > distances[current_node]:
+            continue
+        
+        # 4. 확장 로직 (Expansion Layer)
+        #    - 인접 노드의 거리 갱신
+        for neighbor, weight in graph[current_node]:
+            new_dist = current_dist + weight
+            
+            # 5. 갱신 조건 (Update Condition)
+            if new_dist < distances[neighbor]:
+                distances[neighbor] = new_dist
+                heapq.heappush(pq, (new_dist, neighbor))
+    
+    return distances
+```
+
+## 코드 레이어 해설
+- **Initialization**: 상태 테이블/포인터/큐/스택/부모 배열 등 탐색의 기준 상태를 만든다.
+- **Process Loop / Recursion**: 입력 공간을 순회하며 상태 전이를 반복한다.
+- **Decision Rule**: 분기 조건(완화 가능 여부, 유효 선택 여부, 종료 조건)을 적용한다.
+- **State Update**: 거리/DP/집합/결과 배열을 갱신하고 다음 단계로 전달한다.
+- **Termination**: 목표 도달, 범위 소진, 큐/스택 고갈, 사이클 검출 등으로 종료한다.
+
+## 실전 적용 체크리스트
+- 입력 자료구조 형식(인접 리스트, 간선 리스트, 정렬 여부, 1-index/0-index)을 먼저 고정한다.
+- 시간 복잡도 한계에 맞게 자료구조를 교체한다 (`list.pop(0)` -> `deque.popleft` 등).
+- 실패/예외 경로를 명시한다 (도달 불가, 음수 사이클, 빈 결과, 사이클 존재).
+- 테스트는 최소 3개: 정상 케이스, 경계 케이스, 반례 케이스를 포함한다.

code/templates/algorithm-architect/github-pages-docs/01-graph/03-dijkstra.md

@@ -0,0 +1,81 @@
+# 벨만-포드 (Bellman-Ford) - GitHub Pages 해설
+
+## 문서 목적
+- 원본 템플릿 `01-graph/04-bellman-ford.md` 의 내부 동작을 GitHub Markdown에서 바로 읽을 수 있게 설명합니다.
+- 코드 레이어(초기화/루프/조건/갱신/종료)를 분해하고, Mermaid로 제어 흐름을 시각화합니다.
+- 실전 문제에 붙일 때 반드시 수정해야 하는 지점을 체크리스트로 제공합니다.
+
+## 원본 템플릿
+- Source: [01-graph/04-bellman-ford.md](../../01-graph/04-bellman-ford.md)
+
+## 내부 메커니즘 (Flow)
+```mermaid
+flowchart TD
+    A[Initialize dist array] --> B[Repeat V 1 rounds]
+    B --> C[Scan every edge u v]
+    C --> D{dist u w dist v}
+    D -- Yes --> E[Relax dist v]
+    D -- No --> F[Keep current]
+    E --> G{More edges}
+    F --> G
+    G -- Yes --> C
+    G -- No --> H[One extra scan]
+    H --> I{Still relaxes}
+    I -- Yes --> J[Negative cycle]
+    I -- No --> K[Return distances]
+```
+
+## 내부 상호작용 (Sequence)
+```mermaid
+sequenceDiagram
+    participant Lp as V1Loop
+    participant E as EdgeList
+    participant D as DistTable
+    Lp->>E: iterate edges
+    E->>D: try relax u v w
+    D-->>Lp: changed or not
+    Lp->>E: final cycle check
+```
+
+## 핵심 코드
+```python
+# [Bellman-Ford 템플릿: 아키텍트 버전]
+# Use Case: 음수 가중치 허용, 음수 사이클 탐지
+# Components: Distance Table, Edge List
+# Constraint: O(VE) 시간 복잡도 (느림)
+
+def bellman_ford(start, edges, n):
+    # 1. 초기화 (Initialization Layer)
+    INF = float('inf')
+    distances = [INF] * (n + 1)
+    distances[start] = 0
+    
+    # 2. 완화 반복 (Relaxation Loop)
+    #    - (V-1)번 반복: 최단 경로는 최대 V-1개의 간선
+    for i in range(n - 1):
+        # 3. 간선 순회 (Edge Iteration)
+        for u, v, weight in edges:
+            if distances[u] != INF and distances[u] + weight < distances[v]:
+                distances[v] = distances[u] + weight
+    
+    # 4. 음수 사이클 검출 (Negative Cycle Detection)
+    #    - 한 번 더 완화가 일어나면 음수 사이클 존재
+    for u, v, weight in edges:
+        if distances[u] != INF and distances[u] + weight < distances[v]:
+            return None  # 음수 사이클 존재
+    
+    return distances
+```
+
+## 코드 레이어 해설
+- **Initialization**: 상태 테이블/포인터/큐/스택/부모 배열 등 탐색의 기준 상태를 만든다.
+- **Process Loop / Recursion**: 입력 공간을 순회하며 상태 전이를 반복한다.
+- **Decision Rule**: 분기 조건(완화 가능 여부, 유효 선택 여부, 종료 조건)을 적용한다.
+- **State Update**: 거리/DP/집합/결과 배열을 갱신하고 다음 단계로 전달한다.
+- **Termination**: 목표 도달, 범위 소진, 큐/스택 고갈, 사이클 검출 등으로 종료한다.
+
+## 실전 적용 체크리스트
+- 입력 자료구조 형식(인접 리스트, 간선 리스트, 정렬 여부, 1-index/0-index)을 먼저 고정한다.
+- 시간 복잡도 한계에 맞게 자료구조를 교체한다 (`list.pop(0)` -> `deque.popleft` 등).
+- 실패/예외 경로를 명시한다 (도달 불가, 음수 사이클, 빈 결과, 사이클 존재).
+- 테스트는 최소 3개: 정상 케이스, 경계 케이스, 반례 케이스를 포함한다.