@euler-edu/constant 0.0.0-stage → 7.0.1-beta1

package/lib/oj-explore/algorithms.js

@@ -0,0 +1,716 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.algorithmCategories = void 0;
+exports.algorithmCategories = {
+    basic: '기초',
+    search: '탐색',
+    sorting: '정렬',
+    greedy: '그리디',
+    recursion: '재귀',
+    dp: '동적 계획법',
+    graph: '그래프',
+    tree: '트리',
+    'data-structure': '자료구조',
+    math: '수학',
+    geometry: '기하학',
+    string: '문자열',
+    bit: '비트 연산',
+};
+exports.default = [
+    {
+        key: 'basic',
+        name: { kr: '기초 (Basic)', en: 'Basic' },
+        description: {
+            kr: '가장 쉬운 기초 문제들만 모았습니다.',
+            en: 'The easiest basic problems only',
+        },
+        keywords: ['basic', '기초', '입문', 'beginner'],
+        categories: ['basic'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'sorting',
+        name: { kr: '정렬 (Sort)', en: 'Sort' },
+        description: {
+            kr: '배열을 정해진 순서대로 나열하는 알고리즘입니다.',
+            en: 'Algorithms to arrange arrays in a specific order.',
+        },
+        keywords: [
+            'sort',
+            '정렬',
+            'bubble sort',
+            'merge sort',
+            'quick sort',
+            'counting sort',
+        ],
+        categories: ['sorting'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'directionCheck',
+        name: { kr: '방향 확인 (Direction Check)', en: 'Direction Check' },
+        description: {
+            kr: '2차원 이상의 배열에서 방향 확인이 필요한 문제들을 모았습니다.',
+            en: 'Problems that require direction checking in 2D or higher arrays',
+        },
+        keywords: ['direction', '방향', '상하좌우', 'dx dy'],
+        categories: ['basic', 'search'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'recursion',
+        name: { kr: '재귀호출 (Recursion)', en: 'Recursion' },
+        description: {
+            kr: '자기 자신을 다시 호출하는 함수 구현이 필요한 문제들을 모았습니다.',
+            en: 'Problems that require implementing functions that call themselves',
+        },
+        keywords: ['recursion', '재귀', 'recursive'],
+        categories: ['recursion'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'divideAndConquer',
+        name: { kr: '분할 정복 (Divide and Conquer)', en: 'Divide and Conquer' },
+        description: {
+            kr: '문제를 작은 부분으로 나누어 해결하는 알고리즘입니다.',
+            en: 'Algorithms to solve a problem by dividing it into smaller parts',
+        },
+        keywords: ['divide and conquer', '분할정복'],
+        categories: ['recursion'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'backTracking',
+        name: { kr: 'Backtracking (퇴각 검색)', en: 'Backtracking' },
+        description: {
+            kr: '모든 가능한 경우를 탐색하되, 조건에 맞지 않으면 되돌아가는 알고리즘입니다.',
+            en: 'An algorithm that explores all possible cases and backtracks when a condition is not met.',
+        },
+        keywords: [
+            'backtracking',
+            '백트래킹',
+            '퇴각검색',
+            '순열',
+            '조합',
+            'n-queens',
+        ],
+        categories: ['search', 'recursion'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'stack',
+        name: { kr: '스택 (Stack)', en: 'Stack' },
+        description: {
+            kr: '데이터를 순차적으로 쌓는 선형 자료구조로, 후입선출(LIFO, Last-In-First-Out) 알고리즘입니다.',
+            en: 'A linear data structure that stacks data sequentially, characterized by a Last-In-First-Out (LIFO) principle.',
+        },
+        keywords: ['stack', '스택', 'lifo', '후입선출', '괄호', 'monotonic stack'],
+        categories: ['data-structure'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'queue',
+        name: { kr: '큐 (Queue)', en: 'Queue' },
+        description: {
+            kr: '데이터를 순서대로 처리하기 위해 사용하는 선형 자료구조로, 선입선출(FIFO, First-In-First-Out) 알고리즘입니다.',
+            en: 'A linear data structure used to process data in order, characterized by a First-In-First-Out (FIFO) principle.',
+        },
+        keywords: ['queue', '큐', 'fifo', '선입선출', 'deque', '덱'],
+        categories: ['data-structure'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'dfs',
+        name: { kr: 'DFS (깊이 우선 탐색)', en: 'DFS (Depth-First Search)' },
+        description: {
+            kr: '어떤 노드에서 시작해 가능한 깊이까지 탐색한 후, 다시 돌아와서 다른 방향을 탐색하는 알고리즘입니다.',
+            en: 'An algorithm that explores as deeply as possible from a starting node before returning and exploring other directions.',
+        },
+        keywords: ['dfs', '깊이우선탐색', 'depth first search', '그래프 탐색'],
+        categories: ['search', 'graph'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'bfs',
+        name: { kr: 'BFS (너비 우선 탐색)', en: 'BFS (Breadth-First Search)' },
+        description: {
+            kr: '시작 노드에서 가까운 노드부터 단계적으로 탐색하는 알고리즘입니다.',
+            en: 'An algorithm that explores nodes level by level, starting from the nearest node.',
+        },
+        keywords: ['bfs', '너비우선탐색', 'breadth first search', '그래프 탐색'],
+        categories: ['search', 'graph'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'bfsShortsPath',
+        name: { kr: 'BFS (최단 경로)', en: 'Shortest Path with BFS' },
+        description: {
+            kr: 'BFS를 활용하여 가중치가 없는 그래프에서 최단 경로를 구하는 알고리즘입니다.',
+            en: 'An algorithm using BFS to find the shortest path in an unweighted graph.',
+        },
+        keywords: ['bfs', '최단경로', '최단거리', 'shortest path'],
+        categories: ['search', 'graph'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'floodFill',
+        name: { kr: '플러드 필 (Flood Fill)', en: 'Flood Fill' },
+        description: {
+            kr: '연결된 영역을 찾아 같은 값으로 채우는 알고리즘으로, 그림판의 채우기 기능과 같은 원리입니다.',
+            en: 'An algorithm that finds connected regions and fills them with the same value, similar to the fill tool in paint programs.',
+        },
+        keywords: ['flood fill', '플러드필', '연결요소', '색칠'],
+        categories: ['search', 'graph'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'greedy',
+        name: { kr: '탐욕 알고리즘 (Greedy)', en: 'Greedy' },
+        description: {
+            kr: '각 단계에서 현재 가장 최선의 선택을 하는 방식으로 문제를 해결하는 알고리즘입니다.',
+            en: 'An algorithm that solves problems by making the locally optimal choice at each step.',
+        },
+        keywords: ['greedy', '그리디', '탐욕법'],
+        categories: ['greedy'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'scanning',
+        name: { kr: 'Scanning', en: 'Scanning' },
+        description: {
+            kr: '배열이나 문자열을 순차적으로 훑으며 조건을 만족하는 구간을 찾는 알고리즘입니다.',
+            en: 'An algorithm that sequentially scans arrays or strings to find intervals satisfying a condition.',
+        },
+        keywords: [
+            'scanning',
+            'sliding window',
+            '슬라이딩 윈도우',
+            '투포인터',
+            'two pointer',
+        ],
+        categories: ['search', 'string'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'binarySearch',
+        name: { kr: '이진 검색 (Binary Search)', en: 'Binary Search' },
+        description: {
+            kr: '정렬된 배열에서 탐색 범위를 절반씩 줄여가며 원하는 값을 찾는 알고리즘입니다.',
+            en: 'An algorithm that finds a target value in a sorted array by halving the search range each step.',
+        },
+        keywords: [
+            'binary search',
+            '이진탐색',
+            '이분탐색',
+            'lower bound',
+            'upper bound',
+        ],
+        categories: ['search'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'parametricSearch',
+        name: {
+            kr: '파라메트릭 서치 (Parametric Search)',
+            en: 'Parametric Search',
+        },
+        description: {
+            kr: '최적화 문제를 결정 문제로 변환하여 이진 탐색으로 해결하는 알고리즘입니다.',
+            en: 'An algorithm that converts an optimization problem into a decision problem and solves it with binary search.',
+        },
+        keywords: ['parametric search', '파라메트릭 서치', '이진탐색', '최적화'],
+        categories: ['search'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'math',
+        name: { kr: '수학 (Math)', en: 'Math' },
+        description: {
+            kr: '수학적 공식이나 원리를 활용하여 문제를 해결하는 알고리즘입니다.',
+            en: 'Algorithms that solve problems using mathematical formulas or principles.',
+        },
+        keywords: ['math', '수학', '수식', '공식'],
+        categories: ['math'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'bruteForce',
+        name: { kr: '브루트 포스 (Brute Force)', en: 'Brute Force' },
+        description: {
+            kr: '모든 경우의 수를 직접 탐색하여 답을 구하는 알고리즘입니다.',
+            en: 'An algorithm that finds the answer by directly exploring all possible cases.',
+        },
+        keywords: ['brute force', '브루트포스', '완전탐색'],
+        categories: ['search'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'rotation',
+        name: { kr: '회전 (Rotation)', en: 'Rotation' },
+        description: {
+            kr: '배열이나 좌표를 일정 각도로 회전시키는 연산이 필요한 문제들을 모았습니다.',
+            en: 'Problems that require rotating arrays or coordinates by a given angle.',
+        },
+        keywords: ['rotation', '회전', '배열 회전', '좌표 회전'],
+        categories: ['basic', 'geometry'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'eulerTour',
+        name: {
+            kr: '오일러 경로 (한붓그리기, Eulerian Path)',
+            en: 'Eulerian Path',
+        },
+        description: {
+            kr: '그래프의 모든 간선을 정확히 한 번씩 지나는 경로를 찾는 알고리즘입니다.',
+            en: 'An algorithm that finds a path traversing every edge of a graph exactly once.',
+        },
+        keywords: ['eulerian path', '오일러경로', '한붓그리기', 'eulerian circuit'],
+        categories: ['graph'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'tsp',
+        name: {
+            kr: 'TSP (외판원 순회 문제)',
+            en: 'TSP (Traveling Salesman Problem)',
+        },
+        description: {
+            kr: '모든 도시를 한 번씩 방문하고 출발지로 돌아오는 최단 경로를 구하는 문제입니다.',
+            en: 'A problem that finds the shortest route visiting every city exactly once and returning to the starting point.',
+        },
+        keywords: ['tsp', 'traveling salesman', '외판원 순회', 'hamiltonian path'],
+        categories: ['graph', 'dp'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'carlender',
+        name: { kr: '날짜 계산 (Carlender)', en: 'Carlender' },
+        description: {
+            kr: '날짜, 요일, 기간 등 달력과 관련된 계산이 필요한 문제들을 모았습니다.',
+            en: 'Problems that require calendar-related calculations such as dates, days of the week, and durations.',
+        },
+        keywords: ['calendar', '날짜', '요일', '날짜 계산'],
+        categories: ['basic', 'math'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'lis',
+        name: {
+            kr: 'LIS (최장 증가 부분 수열)',
+            en: 'LIS (Longest Increasing Subsequence)',
+        },
+        description: {
+            kr: '수열에서 순서를 유지하면서 값이 단조 증가하는 가장 긴 부분 수열을 구하는 알고리즘입니다.',
+            en: 'An algorithm that finds the longest subsequence in which values are strictly increasing while maintaining order.',
+        },
+        keywords: ['lis', 'longest increasing subsequence', '최장증가부분수열'],
+        categories: ['dp'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'knapsack',
+        name: { kr: '배낭 문제 (Knapsack)', en: 'Knapsack' },
+        description: {
+            kr: '무게 제한이 있는 배낭에 가치의 합이 최대가 되도록 물건을 선택하는 최적화 문제입니다.',
+            en: 'An optimization problem that selects items to maximize total value within a weight-limited knapsack.',
+        },
+        keywords: ['knapsack', '배낭문제', '0-1 knapsack', 'dp'],
+        categories: ['dp'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'mincoin',
+        name: { kr: '최소 동전 개수 (Min Coin)', en: 'Min Coin' },
+        description: {
+            kr: '주어진 동전 종류로 특정 금액을 만들 때 필요한 최소 동전 개수를 구하는 문제입니다.',
+            en: 'A problem that finds the minimum number of coins needed to make a specific amount with given coin denominations.',
+        },
+        keywords: ['coin change', '최소동전', '거스름돈', 'dp'],
+        categories: ['dp'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'lcs',
+        name: {
+            kr: 'LCS (최장 공통 부분 수열)',
+            en: 'LCS (Longest Common Subsequence)',
+        },
+        description: {
+            kr: '두 수열에서 공통으로 나타나는 가장 긴 부분 수열을 구하는 알고리즘입니다.',
+            en: 'An algorithm that finds the longest subsequence common to two sequences.',
+        },
+        keywords: ['lcs', 'longest common subsequence', '최장공통부분수열'],
+        categories: ['dp'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'dijkstra',
+        name: { kr: '다익스트라 (Dijkstra)', en: 'Dijkstra' },
+        description: {
+            kr: '가중치가 있는 그래프에서 단일 출발점으로부터 모든 노드까지의 최단 경로를 구하는 알고리즘입니다.',
+            en: 'An algorithm that finds the shortest path from a single source to all nodes in a weighted graph.',
+        },
+        keywords: ['dijkstra', '다익스트라', '최단경로', 'shortest path'],
+        categories: ['graph'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'floydWarshall',
+        name: { kr: '플로이드-워셜 (Floyd-Warshall)', en: 'Floyd-Warshall' },
+        description: {
+            kr: '그래프의 모든 노드 쌍 사이의 최단 경로를 구하는 알고리즘입니다.',
+            en: 'An algorithm that finds the shortest paths between all pairs of nodes in a graph.',
+        },
+        keywords: [
+            'floyd-warshall',
+            '플로이드워셜',
+            'all pairs shortest path',
+            '전체쌍 최단경로',
+        ],
+        categories: ['graph'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'prim',
+        name: { kr: 'MST (최소 신장 트리)', en: 'MST (Minimum Spanning Tree)' },
+        description: {
+            kr: '그래프의 모든 노드를 연결하면서 간선의 가중치 합이 최소인 트리를 구하는 알고리즘입니다.',
+            en: 'An algorithm that finds a tree connecting all nodes in a graph with the minimum total edge weight.',
+        },
+        keywords: [
+            'mst',
+            'minimum spanning tree',
+            '최소신장트리',
+            'prim',
+            'kruskal',
+            '크루스칼',
+        ],
+        categories: ['graph', 'tree'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'topologicalSort',
+        name: {
+            kr: '위상 정렬 (Topological Sort)',
+            en: 'Topological Sort',
+        },
+        description: {
+            kr: '방향 비순환 그래프(DAG)에서 선후 관계를 지키며 노드를 순서대로 나열하는 알고리즘입니다.',
+            en: 'An algorithm that orders nodes in a directed acyclic graph (DAG) while respecting dependency order.',
+        },
+        keywords: ['topological sort', '위상정렬', 'dag', '의존성'],
+        categories: ['graph', 'sorting'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'unionFind',
+        name: { kr: '합집합 찾기 (Union-Find)', en: 'Union-Find' },
+        description: {
+            kr: '여러 노드의 집합 관계를 효율적으로 관리하고, 두 노드가 같은 집합에 속하는지 판별하는 자료구조입니다.',
+            en: 'A data structure that efficiently manages set membership and determines whether two nodes belong to the same set.',
+        },
+        keywords: ['union find', '유니온파인드', 'disjoint set', '서로소집합'],
+        categories: ['graph', 'data-structure'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'Dynamic',
+        name: {
+            kr: '동적 계획법 (Dynamic Programming)',
+            en: 'Dynamic Programming',
+        },
+        description: {
+            kr: '복잡한 문제를 작은 하위 문제로 나누고, 중복 계산을 방지하여 효율적으로 해결하는 알고리즘입니다.',
+            en: 'An algorithm that breaks complex problems into smaller subproblems and solves them efficiently by avoiding redundant calculations.',
+        },
+        keywords: [
+            'dp',
+            'dynamic programming',
+            '동적계획법',
+            'memoization',
+            '메모이제이션',
+            '점화식',
+        ],
+        categories: ['dp'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'numberOfTheory',
+        name: { kr: '정수론 (Number Theory)', en: 'Number Theory' },
+        description: {
+            kr: '소수, 약수, 최대공약수 등 정수의 성질을 다루는 수학적 알고리즘입니다.',
+            en: 'Mathematical algorithms dealing with properties of integers such as primes, divisors, and GCD.',
+        },
+        keywords: [
+            'number theory',
+            '정수론',
+            '소수',
+            'prime',
+            'gcd',
+            'lcm',
+            'sieve',
+            '에라토스테네스',
+        ],
+        categories: ['math'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'priorityQueue',
+        name: { kr: '우선순위 큐 (Priority Queue)', en: 'Priority Queue' },
+        description: {
+            kr: '각 원소에 우선순위를 부여하여 높은 우선순위의 원소가 먼저 처리되는 자료구조입니다.',
+            en: 'A data structure where each element has a priority and higher-priority elements are processed first.',
+        },
+        keywords: ['priority queue', '우선순위큐', 'heap', '힙'],
+        categories: ['data-structure'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'segmentTree',
+        name: { kr: '세그먼트 트리 (Segment Tree)', en: 'Segment Tree' },
+        description: {
+            kr: '배열의 구간 합, 최솟값, 최댓값 등을 효율적으로 처리하는 트리 기반 자료구조입니다.',
+            en: 'A tree-based data structure that efficiently handles range queries such as sum, min, and max over arrays.',
+        },
+        keywords: [
+            'segment tree',
+            '세그먼트 트리',
+            'range query',
+            '구간쿼리',
+            'fenwick tree',
+            'bit',
+        ],
+        categories: ['data-structure', 'tree'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'networkFlow',
+        name: { kr: '네트워크 플로우 (Network Flow)', en: 'Network Flow' },
+        description: {
+            kr: '소스에서 싱크까지 네트워크를 통해 흘릴 수 있는 최대 유량을 구하는 알고리즘입니다.',
+            en: 'An algorithm that finds the maximum flow that can be sent through a network from source to sink.',
+        },
+        keywords: [
+            'network flow',
+            '네트워크플로우',
+            'max flow',
+            '최대유량',
+            'bipartite matching',
+            '이분매칭',
+        ],
+        categories: ['graph'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'bitMask',
+        name: { kr: '비트 마스크 (BitMask)', en: 'BitMask' },
+        description: {
+            kr: '비트 연산을 활용하여 집합, 상태 등을 효율적으로 표현하고 조작하는 기법입니다.',
+            en: 'A technique that uses bitwise operations to efficiently represent and manipulate sets and states.',
+        },
+        keywords: [
+            'bitmask',
+            '비트마스크',
+            'bitwise',
+            '비트연산',
+            '부분집합',
+            '상태압축',
+        ],
+        categories: ['math', 'dp', 'bit'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'geometry',
+        name: { kr: '기하 (Geometry)', en: 'Geometry' },
+        description: {
+            kr: '점, 선, 다각형 등 기하학적 객체들의 관계와 성질을 다루는 알고리즘입니다.',
+            en: 'Algorithms dealing with the relationships and properties of geometric objects such as points, lines, and polygons.',
+        },
+        keywords: ['geometry', '기하', '좌표', 'ccw', '교차 판별'],
+        categories: ['geometry'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'convexHull',
+        name: { kr: '볼록 껍질 (Convex Hull)', en: 'Convex Hull' },
+        description: {
+            kr: '주어진 점들을 모두 포함하는 가장 작은 볼록 다각형을 구하는 알고리즘입니다.',
+            en: 'An algorithm that finds the smallest convex polygon enclosing all given points.',
+        },
+        keywords: ['convex hull', '볼록껍질', 'graham scan', '그라함 스캔'],
+        categories: ['geometry'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'bigNumber',
+        name: { kr: '큰 수 (Big Number)', en: 'Big Number' },
+        description: {
+            kr: '일반 정수 자료형으로 표현할 수 없는 매우 큰 수를 다루는 알고리즘입니다.',
+            en: 'Algorithms for handling very large numbers that cannot be represented by standard integer types.',
+        },
+        keywords: ['big number', '큰 수', 'arbitrary precision', '임의 정밀도'],
+        categories: ['math'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'bellmanFord',
+        name: { kr: '벨만-포드 (Bellman-Ford)', en: 'Bellman-Ford' },
+        description: {
+            kr: '음수 가중치가 있는 그래프에서도 단일 출발점으로부터 최단 경로를 구할 수 있는 알고리즘입니다.',
+            en: 'An algorithm that finds the shortest path from a single source even in graphs with negative edge weights.',
+        },
+        keywords: [
+            'bellman-ford',
+            '벨만포드',
+            '음수 간선',
+            'negative edge',
+            '최단경로',
+        ],
+        categories: ['graph'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'pattern',
+        name: { kr: '패턴 (Pattern)', en: 'Pattern' },
+        description: {
+            kr: '수열, 도형 등에서 규칙적인 패턴을 발견하고 활용하여 문제를 해결하는 알고리즘입니다.',
+            en: 'Algorithms that solve problems by discovering and leveraging regular patterns in sequences or shapes.',
+        },
+        keywords: ['pattern', '패턴', '규칙', '규칙성'],
+        categories: ['basic', 'string'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'planeSweeping',
+        name: { kr: 'Plane Sweeping', en: 'Plane Sweeping' },
+        description: {
+            kr: '가상의 직선을 이동시키며 기하학적 문제를 효율적으로 처리하는 알고리즘입니다.',
+            en: 'An algorithm that efficiently solves geometric problems by sweeping a virtual line across the plane.',
+        },
+        keywords: ['plane sweeping', '평면스위핑', 'sweep line', '스윕라인'],
+        categories: ['geometry'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'dataStructure',
+        name: { kr: '자료구조 (Data Structure)', en: 'Data Structure' },
+        description: {
+            kr: '데이터를 효율적으로 저장하고 관리하기 위한 구조와 관련된 문제들을 모았습니다.',
+            en: 'Problems related to structures for efficiently storing and managing data.',
+        },
+        keywords: ['data structure', '자료구조', 'linked list', 'tree', 'graph'],
+        categories: ['data-structure'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'string',
+        name: { kr: '문자열 (String)', en: 'String' },
+        description: {
+            kr: '문자열의 탐색, 비교, 변환 등 문자열 처리와 관련된 알고리즘입니다.',
+            en: 'Algorithms related to string processing such as searching, comparing, and transforming strings.',
+        },
+        keywords: ['string', '문자열', 'kmp', '문자열 처리'],
+        categories: ['string'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'gets',
+        name: { kr: 'Gets', en: 'Gets' },
+        description: {
+            kr: '공백이나 개행이 포함된 문자열 입력을 처리하는 문제들을 모았습니다.',
+            en: 'Problems that involve handling string input containing spaces or newlines.',
+        },
+        keywords: ['gets', '입력', '공백 입력', 'readline'],
+        categories: ['basic', 'string'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'shape',
+        name: { kr: '문자 도형 (Shape)', en: 'Shape' },
+        description: {
+            kr: '문자를 이용하여 특정 도형이나 패턴을 출력하는 문제들을 모았습니다.',
+            en: 'Problems that require printing specific shapes or patterns using characters.',
+        },
+        keywords: ['shape', '별찍기', '문자 도형', 'pattern output'],
+        categories: ['basic', 'string'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'set',
+        name: { kr: 'Set', en: 'Set' },
+        description: {
+            kr: '중복 없는 원소들의 집합 자료구조를 활용하는 문제들을 모았습니다.',
+            en: 'Problems that utilize the set data structure containing unique elements.',
+        },
+        keywords: ['set', '집합', '중복제거', 'unique'],
+        categories: ['data-structure'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'regulation',
+        name: { kr: 'Regulation' },
+        description: {
+            kr: '주어진 규칙이나 제약 조건에 따라 문제를 해결하는 알고리즘입니다.',
+            en: 'Algorithms that solve problems according to given rules or constraints.',
+        },
+        keywords: ['regulation', '규칙', '제약조건'],
+        categories: ['basic'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'convexHullTrick',
+        name: {
+            kr: '볼록 껍질 트릭 (Convex Hull Trick)',
+            en: 'Convex Hull Trick',
+        },
+        description: {
+            kr: '동적 계획법 점화식에서 일차 함수의 최솟값·최댓값을 볼록 껍질을 이용해 빠르게 계산하는 최적화 기법입니다.',
+            en: 'A DP optimization technique that uses convex hull to quickly compute the minimum or maximum of linear functions.',
+        },
+        keywords: ['convex hull trick', '볼록껍질 트릭', 'cht', 'dp 최적화'],
+        categories: ['dp', 'geometry'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'DnCOptimization',
+        name: {
+            kr: 'DnC 최적화 (Divide and Conquer Optimization)',
+            en: 'Divide and Conquer Optimization',
+        },
+        description: {
+            kr: '동적 계획법의 점화식에서 최적 분할점이 단조 증가하는 성질을 이용한 최적화 기법입니다.',
+            en: 'A DP optimization technique that exploits the monotonicity of the optimal split point in recurrence relations.',
+        },
+        keywords: [
+            'divide and conquer optimization',
+            'dnc optimization',
+            'dp 최적화',
+        ],
+        categories: ['dp', 'recursion'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'dijkstraHeap',
+        name: { kr: '다익스트라 (Dijkstra + Heap)', en: 'Dijkstra (+ Heap)' },
+        description: {
+            kr: '우선순위 큐(힙)를 활용하여 다익스트라 알고리즘의 시간 복잡도를 개선한 구현입니다.',
+            en: 'An optimized implementation of Dijkstra using a priority queue (heap) to improve time complexity.',
+        },
+        keywords: ['dijkstra', '다익스트라', 'heap', 'priority queue', '최단경로'],
+        categories: ['graph', 'data-structure'],
+        parent: 'algorithms',
+    },
+    {
+        key: 'hash',
+        name: { kr: '해싱 (Hash)', en: 'Hash' },
+        description: {
+            kr: '해시 함수를 이용하여 데이터를 빠르게 저장하고 검색하는 자료구조 기반 알고리즘입니다.',
+            en: 'Algorithms based on hash functions for fast data storage and retrieval.',
+        },
+        keywords: ['hash', '해싱', 'hashmap', '해시맵', 'dictionary'],
+        categories: ['data-structure'],
+        parent: 'algorithms',
+    },
+];
+//# sourceMappingURL=algorithms.js.map