{"componentChunkName":"component---src-templates-blog-post-js","path":"/algorithm/고급-알고리즘-완전정복-세그먼트-트리부터-위상정렬까지/","result":{"data":{"site":{"siteMetadata":{"title":"Bottlehs Tech Blog","description":"웹·앱·AI 개발자 전병훈(bottlehs)의 기술 블로그. AI·LLM, JavaScript·Vue, Spring Boot, 알고리즘, 블록체인 실무 가이드를 다룹니다","siteUrl":"https://www.bottlehs.dev","author":{"name":"Jeon Byung Hun","summary":"개발을 즐기는 bottlehs - Engineer, MS, AI, FE, BE, OS, IOT, Blockchain, 설계, 테스트"},"social":{"github":"bottlehs","codepen":"bottlehs"}}},"markdownRemark":{"id":"198dd7cc-d8e9-571a-b487-fd2b9429c6bd","excerpt":"고급 알고리즘 완전정복 - 세그먼트 트리부터 위상정렬까지 기본적인 정렬과 탐색 알고리즘을 넘어서, 코딩 테스트와 실무에서 자주 사용되는 고급 알고리즘들을 다룬다. 각 알고리즘의 원리, 구현 방법, 시간 복잡도, 활용 사례를 실전 예제와 함께 설명한다. 1. 세그먼트 트리 (Segment…","html":"

고급 알고리즘 완전정복 - 세그먼트 트리부터 위상정렬까지

\n

기본적인 정렬과 탐색 알고리즘을 넘어서, 코딩 테스트와 실무에서 자주 사용되는 고급 알고리즘들을 다룬다. 각 알고리즘의 원리, 구현 방법, 시간 복잡도, 활용 사례를 실전 예제와 함께 설명한다.

\n

1. 세그먼트 트리 (Segment Tree)

\n

1-1. 개념과 활용

\n

세그먼트 트리는 구간 쿼리와 업데이트를 O(log N) 시간에 처리할 수 있는 자료구조다.

\n

활용 사례:

\n\n

1-2. 기본 구현 (구간 합)

\n
class SegmentTree {\n  constructor(arr) {\n    this.n = arr.length;\n    this.size = 1;\n    while (this.size < this.n) this.size *= 2;\n    this.tree = new Array(this.size * 2).fill(0);\n    \n    // 리프 노드에 초기값 저장\n    for (let i = 0; i < this.n; i++) {\n      this.tree[this.size + i] = arr[i];\n    }\n    \n    // 내부 노드 계산\n    for (let i = this.size - 1; i > 0; i--) {\n      this.tree[i] = this.tree[i * 2] + this.tree[i * 2 + 1];\n    }\n  }\n  \n  // 구간 [l, r)의 합 구하기\n  query(l, r) {\n    l += this.size;\n    r += this.size;\n    let sum = 0;\n    \n    while (l < r) {\n      if (l % 2 === 1) {\n        sum += this.tree[l];\n        l++;\n      }\n      if (r % 2 === 1) {\n        r--;\n        sum += this.tree[r];\n      }\n      l = Math.floor(l / 2);\n      r = Math.floor(r / 2);\n    }\n    \n    return sum;\n  }\n  \n  // 인덱스 pos의 값을 val로 업데이트\n  update(pos, val) {\n    pos += this.size;\n    this.tree[pos] = val;\n    \n    while (pos > 1) {\n      pos = Math.floor(pos / 2);\n      this.tree[pos] = this.tree[pos * 2] + this.tree[pos * 2 + 1];\n    }\n  }\n  \n  // 구간 [l, r)에 val 더하기 (Lazy Propagation)\n  rangeUpdate(l, r, val) {\n    this._lazyUpdate(l, r, val, 0, this.size, 1);\n  }\n  \n  _lazyUpdate(l, r, val, segL, segR, node) {\n    // Lazy Propagation 구현\n    // 실제 구현은 복잡하므로 생략\n  }\n}\n\n// 사용 예시\nconst arr = [1, 3, 5, 7, 9, 11];\nconst segTree = new SegmentTree(arr);\n\nconsole.log(segTree.query(1, 4)); // 3 + 5 + 7 = 15\nsegTree.update(2, 10);\nconsole.log(segTree.query(1, 4)); // 3 + 10 + 7 = 20
\n

1-3. 구간 최솟값 쿼리

\n
class MinSegmentTree {\n  constructor(arr) {\n    this.n = arr.length;\n    this.size = 1;\n    while (this.size < this.n) this.size *= 2;\n    this.tree = new Array(this.size * 2).fill(Infinity);\n    \n    for (let i = 0; i < this.n; i++) {\n      this.tree[this.size + i] = arr[i];\n    }\n    \n    for (let i = this.size - 1; i > 0; i--) {\n      this.tree[i] = Math.min(this.tree[i * 2], this.tree[i * 2 + 1]);\n    }\n  }\n  \n  query(l, r) {\n    l += this.size;\n    r += this.size;\n    let minVal = Infinity;\n    \n    while (l < r) {\n      if (l % 2 === 1) {\n        minVal = Math.min(minVal, this.tree[l]);\n        l++;\n      }\n      if (r % 2 === 1) {\n        r--;\n        minVal = Math.min(minVal, this.tree[r]);\n      }\n      l = Math.floor(l / 2);\n      r = Math.floor(r / 2);\n    }\n    \n    return minVal;\n  }\n  \n  update(pos, val) {\n    pos += this.size;\n    this.tree[pos] = val;\n    \n    while (pos > 1) {\n      pos = Math.floor(pos / 2);\n      this.tree[pos] = Math.min(this.tree[pos * 2], this.tree[pos * 2 + 1]);\n    }\n  }\n}
\n

2. 펜윅 트리 (Fenwick Tree / Binary Indexed Tree)

\n

2-1. 개념

\n

펜윅 트리는 세그먼트 트리보다 메모리를 적게 사용하며, 구현이 간단하다. 주로 구간 합 쿼리에 사용된다.

\n

2-2. 구현

\n
class FenwickTree {\n  constructor(size) {\n    this.n = size;\n    this.tree = new Array(this.n + 1).fill(0);\n  }\n  \n  // 인덱스 i에 val 더하기\n  update(i, val) {\n    i++;\n    while (i <= this.n) {\n      this.tree[i] += val;\n      i += i & -i; // 마지막 비트 더하기\n    }\n  }\n  \n  // [0, i] 구간의 합\n  query(i) {\n    i++;\n    let sum = 0;\n    while (i > 0) {\n      sum += this.tree[i];\n      i -= i & -i; // 마지막 비트 제거\n    }\n    return sum;\n  }\n  \n  // [l, r] 구간의 합\n  rangeQuery(l, r) {\n    return this.query(r) - this.query(l - 1);\n  }\n}\n\n// 사용 예시\nconst arr = [1, 3, 5, 7, 9, 11];\nconst fenwick = new FenwickTree(arr.length);\n\n// 초기화\nfor (let i = 0; i < arr.length; i++) {\n  fenwick.update(i, arr[i]);\n}\n\nconsole.log(fenwick.rangeQuery(1, 3)); // 3 + 5 + 7 = 15\nfenwick.update(2, 5); // 인덱스 2에 5 더하기\nconsole.log(fenwick.rangeQuery(1, 3)); // 3 + 10 + 7 = 20
\n

3. 유니온 파인드 (Union-Find / Disjoint Set)

\n

3-1. 개념

\n

유니온 파인드는 두 원소가 같은 집합에 속하는지 확인하고, 두 집합을 합치는 연산을 효율적으로 수행한다.

\n

3-2. 기본 구현

\n
class UnionFind {\n  constructor(n) {\n    this.parent = new Array(n);\n    this.rank = new Array(n).fill(0);\n    for (let i = 0; i < n; i++) {\n      this.parent[i] = i;\n    }\n  }\n  \n  // 경로 압축을 사용한 Find\n  find(x) {\n    if (this.parent[x] !== x) {\n      this.parent[x] = this.find(this.parent[x]); // 경로 압축\n    }\n    return this.parent[x];\n  }\n  \n  // Union by Rank\n  union(x, y) {\n    const rootX = this.find(x);\n    const rootY = this.find(y);\n    \n    if (rootX === rootY) return false; // 이미 같은 집합\n    \n    // Rank가 작은 것을 큰 것에 붙이기\n    if (this.rank[rootX] < this.rank[rootY]) {\n      this.parent[rootX] = rootY;\n    } else if (this.rank[rootX] > this.rank[rootY]) {\n      this.parent[rootY] = rootX;\n    } else {\n      this.parent[rootY] = rootX;\n      this.rank[rootX]++;\n    }\n    \n    return true;\n  }\n  \n  // 같은 집합에 속하는지 확인\n  connected(x, y) {\n    return this.find(x) === this.find(y);\n  }\n}\n\n// 사용 예시\nconst uf = new UnionFind(5);\n\nuf.union(0, 1);\nuf.union(2, 3);\nconsole.log(uf.connected(0, 1)); // true\nconsole.log(uf.connected(0, 2)); // false\nuf.union(1, 2);\nconsole.log(uf.connected(0, 3)); // true
\n

3-3. 실전 문제: 섬의 개수

\n
function numIslands(grid) {\n  const m = grid.length;\n  const n = grid[0].length;\n  const uf = new UnionFind(m * n);\n  \n  const directions = [[0, 1], [1, 0], [0, -1], [-1, 0]];\n  \n  for (let i = 0; i < m; i++) {\n    for (let j = 0; j < n; j++) {\n      if (grid[i][j] === '1') {\n        for (const [dx, dy] of directions) {\n          const ni = i + dx;\n          const nj = j + dy;\n          if (ni >= 0 && ni < m && nj >= 0 && nj < n && grid[ni][nj] === '1') {\n            uf.union(i * n + j, ni * n + nj);\n          }\n        }\n      }\n    }\n  }\n  \n  const islands = new Set();\n  for (let i = 0; i < m; i++) {\n    for (let j = 0; j < n; j++) {\n      if (grid[i][j] === '1') {\n        islands.add(uf.find(i * n + j));\n      }\n    }\n  }\n  \n  return islands.size;\n}
\n

4. 최소 공통 조상 (LCA - Lowest Common Ancestor)

\n

4-1. 개념

\n

트리에서 두 노드의 공통 조상 중 가장 가까운 조상을 찾는 문제다.

\n

4-2. 이진 리프팅을 사용한 구현

\n
class LCA {\n  constructor(n, root, edges) {\n    this.n = n;\n    this.log = Math.ceil(Math.log2(n)) + 1;\n    this.depth = new Array(n).fill(0);\n    this.parent = Array(n).fill(null).map(() => new Array(this.log).fill(-1));\n    this.adj = Array(n).fill(null).map(() => []);\n    \n    // 인접 리스트 구성\n    for (const [u, v] of edges) {\n      this.adj[u].push(v);\n      this.adj[v].push(u);\n    }\n    \n    // DFS로 depth와 parent[0] 계산\n    this.dfs(root, -1, 0);\n    \n    // 이진 리프팅 테이블 구성\n    for (let j = 1; j < this.log; j++) {\n      for (let i = 0; i < n; i++) {\n        if (this.parent[i][j - 1] !== -1) {\n          this.parent[i][j] = this.parent[this.parent[i][j - 1]][j - 1];\n        }\n      }\n    }\n  }\n  \n  dfs(u, p, d) {\n    this.depth[u] = d;\n    this.parent[u][0] = p;\n    \n    for (const v of this.adj[u]) {\n      if (v !== p) {\n        this.dfs(v, u, d + 1);\n      }\n    }\n  }\n  \n  lca(u, v) {\n    // u가 더 깊게\n    if (this.depth[u] < this.depth[v]) {\n      [u, v] = [v, u];\n    }\n    \n    // 같은 depth로 맞추기\n    for (let i = this.log - 1; i >= 0; i--) {\n      if (this.depth[u] - (1 << i) >= this.depth[v]) {\n        u = this.parent[u][i];\n      }\n    }\n    \n    if (u === v) return u;\n    \n    // LCA 찾기\n    for (let i = this.log - 1; i >= 0; i--) {\n      if (this.parent[u][i] !== this.parent[v][i]) {\n        u = this.parent[u][i];\n        v = this.parent[v][i];\n      }\n    }\n    \n    return this.parent[u][0];\n  }\n}\n\n// 사용 예시\nconst n = 7;\nconst edges = [\n  [0, 1], [0, 2],\n  [1, 3], [1, 4],\n  [2, 5], [2, 6]\n];\nconst lca = new LCA(n, 0, edges);\n\nconsole.log(lca.lca(3, 4)); // 1\nconsole.log(lca.lca(3, 6)); // 0
\n

5. 강한 연결 요소 (SCC - Strongly Connected Components)

\n

5-1. 개념

\n

유향 그래프에서 서로 도달 가능한 노드들의 집합을 강한 연결 요소라고 한다.

\n

5-2. Kosaraju 알고리즘

\n
class SCC {\n  constructor(n, edges) {\n    this.n = n;\n    this.adj = Array(n).fill(null).map(() => []);\n    this.revAdj = Array(n).fill(null).map(() => []);\n    \n    for (const [u, v] of edges) {\n      this.adj[u].push(v);\n      this.revAdj[v].push(u);\n    }\n  }\n  \n  kosaraju() {\n    const visited = new Array(this.n).fill(false);\n    const order = [];\n    \n    // 1. 첫 번째 DFS (순서 결정)\n    for (let i = 0; i < this.n; i++) {\n      if (!visited[i]) {\n        this.dfs1(i, visited, order);\n      }\n    }\n    \n    // 2. 역방향 그래프에서 DFS\n    visited.fill(false);\n    const sccs = [];\n    \n    for (let i = order.length - 1; i >= 0; i--) {\n      const node = order[i];\n      if (!visited[node]) {\n        const component = [];\n        this.dfs2(node, visited, component);\n        sccs.push(component);\n      }\n    }\n    \n    return sccs;\n  }\n  \n  dfs1(u, visited, order) {\n    visited[u] = true;\n    for (const v of this.adj[u]) {\n      if (!visited[v]) {\n        this.dfs1(v, visited, order);\n      }\n    }\n    order.push(u);\n  }\n  \n  dfs2(u, visited, component) {\n    visited[u] = true;\n    component.push(u);\n    for (const v of this.revAdj[u]) {\n      if (!visited[v]) {\n        this.dfs2(v, visited, component);\n      }\n    }\n  }\n}\n\n// 사용 예시\nconst n = 5;\nconst edges = [\n  [0, 1], [1, 2], [2, 0],\n  [1, 3], [3, 4]\n];\nconst scc = new SCC(n, edges);\nconsole.log(scc.kosaraju()); // [[0, 2, 1], [3], [4]]
\n

6. 위상 정렬 (Topological Sort)

\n

6-1. 개념

\n

유향 비순환 그래프(DAG)에서 노드들을 선후 관계에 따라 정렬하는 알고리즘이다.

\n

6-2. Kahn 알고리즘 (위상 정렬)

\n
function topologicalSort(n, edges) {\n  const adj = Array(n).fill(null).map(() => []);\n  const inDegree = new Array(n).fill(0);\n  \n  // 그래프 구성 및 진입 차수 계산\n  for (const [u, v] of edges) {\n    adj[u].push(v);\n    inDegree[v]++;\n  }\n  \n  // 진입 차수가 0인 노드들을 큐에 추가\n  const queue = [];\n  for (let i = 0; i < n; i++) {\n    if (inDegree[i] === 0) {\n      queue.push(i);\n    }\n  }\n  \n  const result = [];\n  \n  while (queue.length > 0) {\n    const u = queue.shift();\n    result.push(u);\n    \n    // 인접 노드들의 진입 차수 감소\n    for (const v of adj[u]) {\n      inDegree[v]--;\n      if (inDegree[v] === 0) {\n        queue.push(v);\n      }\n    }\n  }\n  \n  // 사이클이 있으면 빈 배열 반환\n  if (result.length !== n) {\n    return []; // 사이클 존재\n  }\n  \n  return result;\n}\n\n// 사용 예시\nconst n = 6;\nconst edges = [\n  [5, 2], [5, 0],\n  [4, 0], [4, 1],\n  [2, 3], [3, 1]\n];\nconsole.log(topologicalSort(n, edges)); // [4, 5, 0, 2, 3, 1]
\n

6-3. DFS를 사용한 위상 정렬

\n
function topologicalSortDFS(n, edges) {\n  const adj = Array(n).fill(null).map(() => []);\n  const visited = new Array(n).fill(false);\n  const result = [];\n  \n  for (const [u, v] of edges) {\n    adj[u].push(v);\n  }\n  \n  function dfs(u) {\n    visited[u] = true;\n    for (const v of adj[u]) {\n      if (!visited[v]) {\n        dfs(v);\n      }\n    }\n    result.push(u); // 역순으로 추가\n  }\n  \n  for (let i = 0; i < n; i++) {\n    if (!visited[i]) {\n      dfs(i);\n    }\n  }\n  \n  return result.reverse();\n}
\n

7. 최소 신장 트리 (MST - Minimum Spanning Tree)

\n

7-1. Kruskal 알고리즘

\n
class KruskalMST {\n  constructor(n, edges) {\n    this.n = n;\n    this.edges = edges.sort((a, b) => a[2] - b[2]); // 가중치 오름차순\n    this.uf = new UnionFind(n);\n  }\n  \n  findMST() {\n    const mst = [];\n    let totalWeight = 0;\n    \n    for (const [u, v, weight] of this.edges) {\n      if (this.uf.union(u, v)) {\n        mst.push([u, v, weight]);\n        totalWeight += weight;\n      }\n    }\n    \n    return { mst, totalWeight };\n  }\n}\n\n// 사용 예시\nconst n = 4;\nconst edges = [\n  [0, 1, 10],\n  [0, 2, 6],\n  [0, 3, 5],\n  [1, 3, 15],\n  [2, 3, 4]\n];\n\nconst kruskal = new KruskalMST(n, edges);\nconst { mst, totalWeight } = kruskal.findMST();\nconsole.log(\"MST:\", mst); // [[2, 3, 4], [0, 3, 5], [0, 1, 10]]\nconsole.log(\"Total Weight:\", totalWeight); // 19
\n

7-2. Prim 알고리즘

\n
class PrimMST {\n  constructor(n, edges) {\n    this.n = n;\n    this.adj = Array(n).fill(null).map(() => []);\n    \n    for (const [u, v, weight] of edges) {\n      this.adj[u].push([v, weight]);\n      this.adj[v].push([u, weight]);\n    }\n  }\n  \n  findMST(start = 0) {\n    const visited = new Array(this.n).fill(false);\n    const minHeap = [[0, start, -1]]; // [weight, node, parent]\n    const mst = [];\n    let totalWeight = 0;\n    \n    while (minHeap.length > 0) {\n      minHeap.sort((a, b) => a[0] - b[0]);\n      const [weight, u, parent] = minHeap.shift();\n      \n      if (visited[u]) continue;\n      visited[u] = true;\n      \n      if (parent !== -1) {\n        mst.push([parent, u, weight]);\n        totalWeight += weight;\n      }\n      \n      for (const [v, w] of this.adj[u]) {\n        if (!visited[v]) {\n          minHeap.push([w, v, u]);\n        }\n      }\n    }\n    \n    return { mst, totalWeight };\n  }\n}\n\n// 사용 예시\nconst prim = new PrimMST(n, edges);\nconst { mst: primMST, totalWeight: primWeight } = prim.findMST();\nconsole.log(\"Prim MST:\", primMST);\nconsole.log(\"Total Weight:\", primWeight);
\n

8. 최대 유량 (Max Flow)

\n

8-1. Ford-Fulkerson 알고리즘 (DFS)

\n
class MaxFlow {\n  constructor(n, source, sink) {\n    this.n = n;\n    this.source = source;\n    this.sink = sink;\n    this.capacity = Array(n).fill(null).map(() => new Array(n).fill(0));\n    this.adj = Array(n).fill(null).map(() => []);\n  }\n  \n  addEdge(u, v, cap) {\n    this.capacity[u][v] = cap;\n    this.adj[u].push(v);\n    this.adj[v].push(u); // 역방향 간선\n  }\n  \n  fordFulkerson() {\n    let maxFlow = 0;\n    const parent = new Array(this.n).fill(-1);\n    \n    while (this.bfs(parent)) {\n      let pathFlow = Infinity;\n      \n      // 경로의 최소 용량 찾기\n      for (let v = this.sink; v !== this.source; v = parent[v]) {\n        const u = parent[v];\n        pathFlow = Math.min(pathFlow, this.capacity[u][v]);\n      }\n      \n      // 유량 업데이트\n      for (let v = this.sink; v !== this.source; v = parent[v]) {\n        const u = parent[v];\n        this.capacity[u][v] -= pathFlow;\n        this.capacity[v][u] += pathFlow; // 역방향 간선\n      }\n      \n      maxFlow += pathFlow;\n    }\n    \n    return maxFlow;\n  }\n  \n  bfs(parent) {\n    const visited = new Array(this.n).fill(false);\n    const queue = [this.source];\n    visited[this.source] = true;\n    \n    while (queue.length > 0) {\n      const u = queue.shift();\n      \n      for (const v of this.adj[u]) {\n        if (!visited[v] && this.capacity[u][v] > 0) {\n          visited[v] = true;\n          parent[v] = u;\n          queue.push(v);\n          \n          if (v === this.sink) {\n            return true;\n          }\n        }\n      }\n    }\n    \n    return false;\n  }\n}\n\n// 사용 예시\nconst n = 6;\nconst maxFlow = new MaxFlow(n, 0, 5);\n\nmaxFlow.addEdge(0, 1, 16);\nmaxFlow.addEdge(0, 2, 13);\nmaxFlow.addEdge(1, 2, 10);\nmaxFlow.addEdge(1, 3, 12);\nmaxFlow.addEdge(2, 1, 4);\nmaxFlow.addEdge(2, 4, 14);\nmaxFlow.addEdge(3, 2, 9);\nmaxFlow.addEdge(3, 5, 20);\nmaxFlow.addEdge(4, 3, 7);\nmaxFlow.addEdge(4, 5, 4);\n\nconsole.log(\"Max Flow:\", maxFlow.fordFulkerson()); // 23
\n

9. 실전 문제 풀이

\n

9-1. 구간 최솟값 쿼리 (세그먼트 트리)

\n
// 문제: 배열에서 구간 [l, r]의 최솟값을 여러 번 구하기\nfunction solveRangeMinQuery(arr, queries) {\n  const segTree = new MinSegmentTree(arr);\n  const results = [];\n  \n  for (const [l, r] of queries) {\n    results.push(segTree.query(l, r + 1));\n  }\n  \n  return results;\n}\n\nconst arr = [1, 3, 2, 7, 9, 11, 5, 8];\nconst queries = [[0, 3], [2, 5], [1, 4]];\nconsole.log(solveRangeMinQuery(arr, queries)); // [1, 2, 2]
\n

9-2. 친구 네트워크 (유니온 파인드)

\n
// 문제: 친구 관계를 입력받아 네트워크 크기 구하기\nfunction friendNetwork(n, friendships) {\n  const uf = new UnionFind(n);\n  const size = new Array(n).fill(1);\n  \n  for (const [a, b] of friendships) {\n    const rootA = uf.find(a);\n    const rootB = uf.find(b);\n    \n    if (rootA !== rootB) {\n      uf.union(a, b);\n      const newRoot = uf.find(a);\n      size[newRoot] = size[rootA] + size[rootB];\n    }\n    \n    console.log(`Network size: ${size[uf.find(a)]}`);\n  }\n}
\n

9-3. 코스 스케줄 (위상 정렬)

\n
// 문제: 선수 과목 관계가 주어질 때, 모든 과목을 수강할 수 있는지 확인\nfunction canFinish(numCourses, prerequisites) {\n  const adj = Array(numCourses).fill(null).map(() => []);\n  const inDegree = new Array(numCourses).fill(0);\n  \n  for (const [course, prereq] of prerequisites) {\n    adj[prereq].push(course);\n    inDegree[course]++;\n  }\n  \n  const queue = [];\n  for (let i = 0; i < numCourses; i++) {\n    if (inDegree[i] === 0) {\n      queue.push(i);\n    }\n  }\n  \n  let count = 0;\n  while (queue.length > 0) {\n    const u = queue.shift();\n    count++;\n    \n    for (const v of adj[u]) {\n      inDegree[v]--;\n      if (inDegree[v] === 0) {\n        queue.push(v);\n      }\n    }\n  }\n  \n  return count === numCourses;\n}\n\nconsole.log(canFinish(2, [[1, 0]])); // true\nconsole.log(canFinish(2, [[1, 0], [0, 1]])); // false (사이클)
\n

10. 시간 복잡도 비교

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
알고리즘시간 복잡도공간 복잡도
세그먼트 트리 (구간 쿼리)O(log N)O(N)
펜윅 트리 (구간 합)O(log N)O(N)
유니온 파인드O(α(N)) (거의 상수)O(N)
LCA (이진 리프팅)O(log N)O(N log N)
SCC (Kosaraju)O(V + E)O(V + E)
위상 정렬O(V + E)O(V + E)
MST (Kruskal)O(E log E)O(V)
MST (Prim)O(E log V)O(V + E)
최대 유량 (Ford-Fulkerson)O(E × max_flow)O(V + E)
\n

11. 결론

\n

고급 알고리즘은 복잡한 문제를 효율적으로 해결하는 핵심 도구다. 이 글에서 다룬 내용:

\n
    \n
  1. 세그먼트 트리: 구간 쿼리와 업데이트를 빠르게 처리
    2. \n
  2. 펜윅 트리: 메모리 효율적인 구간 합 쿼리
    3. \n
  3. 유니온 파인드: 집합 연산을 효율적으로 처리
    4. \n
  4. LCA: 트리에서 공통 조상 찾기
    5. \n
  5. SCC: 유향 그래프의 강한 연결 요소
    6. \n
  6. 위상 정렬: DAG의 선후 관계 정렬
    7. \n
  7. MST: 최소 신장 트리 구하기
    8. \n
  8. 최대 유량: 네트워크 유량 최대화
    9. \n
\n

이러한 알고리즘들을 숙지하면 코딩 테스트와 실무 문제를 더 효율적으로 해결할 수 있다.

\n

참고 자료

\n","tableOfContents":"","wordCount":{"words":340},"fields":{"slug":"/algorithm/고급-알고리즘-완전정복-세그먼트-트리부터-위상정렬까지/","image":null,"faq":[]},"frontmatter":{"title":"고급 알고리즘 완전정복 - 세그먼트 트리부터 위상정렬까지","date":"2025년 11월 15일","dateISO":"2025-11-15T00:00:00.000Z","updatedISO":null,"category":"algorithm","description":"코딩 테스트와 실무에서 자주 사용되는 고급 알고리즘을 완벽 정리. 세그먼트 트리, 펜윅 트리, 유니온 파인드, 최소 공통 조상(LCA), 강한 연결 요소(SCC), 위상 정렬, 최소 신장 트리(MST), 최대 유량 등 실전 문제 해결에 필요한 모든 알고리즘을 JavaScript로 구현합니다.","tags":["알고리즘","Algorithm","세그먼트 트리","Segment Tree","유니온 파인드","Union-Find","위상 정렬","Topological Sort","최소 신장 트리","MST","최대 유량","Max Flow","코딩 테스트","JavaScript"]}}},"pageContext":{"slug":"/algorithm/고급-알고리즘-완전정복-세그먼트-트리부터-위상정렬까지/","previous":{"fields":{"slug":"/javascript/React-Next.js-완전정복-현대적-프론트엔드-개발-가이드/"},"frontmatter":{"title":"React와 Next.js 완전정복 - 현대적 프론트엔드 개발 실전 가이드","tags":["React","Next.js","React Hooks","Server Components","React Query","프론트엔드","웹 개발","JavaScript","TypeScript","상태 관리"]}},"next":{"fields":{"slug":"/ai/Responsible-AI-Operations-Part-3-사고-대응과-지속-개선/"},"frontmatter":{"title":"Responsible AI Operations Part 3 사고 대응과 지속 개선","tags":["Responsible AI","인시던트 대응","Runbook","감사","거버넌스","지속 개선"]}}}},"staticQueryHashes":["213619243","3262363727"]}