Arrow Research search

Author name cluster

Kunsoo Park

Possible papers associated with this exact author name in Arrow. This page groups case-insensitive exact name matches and is not a full identity disambiguation profile.

27 papers
2 author rows

Possible papers

27

AAAI Conference 2026 Conference Paper

ProgRAG: Hallucination-Resistant Progressive Retrieval and Reasoning over Knowledge Graphs

  • Minbae Park
  • Hyemin Yang
  • Jeonghyun Kim
  • Kunsoo Park
  • Hyunjoon Kim

Large Language Models (LLMs) demonstrate strong reasoning capabilities but still struggle with hallucinations and limited transparency. Recently, KG-enhanced LLMs that integrate knowledge graphs (KGs) have been shown to improve reasoning performance, particularly for complex, knowledge-intensive tasks. However, these methods still face significant challenges, including inaccurate retrieval and reasoning failures, often exacerbated by long input contexts that obscure relevant information. Furthermore, many of these approaches rely on LLMs to directly retrieve evidence from KGs, and to self-assess the sufficiency of this evidence, which often results in premature or incorrect reasoning. To address the retrieval and reasoning failures, we propose ProgRAG, a multi-hop knowledge graph question answering (KGQA) framework that decomposes complex questions into sub-questions, and progressively extends partial reasoning paths by answering each sub-question. At each step, external retrievers gather candidate evidence, which is then refined through uncertainty-aware pruning by the LLM. Finally, the context for LLM reasoning is optimized by organizing and rearranging the partial reasoning paths obtained from the sub-question answers. Experiments on two well-known datasets, WebQSP and CWQ, demonstrate that ProgRAG outperforms existing baselines in multi-hop KGQA, offering improved reliability and reasoning quality.

TCS Journal 2021 Journal Article

Fast algorithms for single and multiple pattern Cartesian tree matching

  • Siwoo Song
  • Geonmo Gu
  • Cheol Ryu
  • Simone Faro
  • Thierry Lecroq
  • Kunsoo Park

Cartesian tree matching is the problem of finding every substring of a given text which has the same Cartesian tree as that of a given pattern. In this paper we propose fast algorithms for single and multiple pattern Cartesian tree matching by introducing new representations and encodings. For single pattern Cartesian tree matching, we present the framework of a binary filtration method and an efficient verification technique. Any exact string matching algorithm can be used as a filtration for Cartesian tree matching in our framework. For multiple pattern Cartesian tree matching, we present two fingerprinting methods, i. e. , the parent-distance encoding and the binary encoding. By combining an efficient fingerprinting method and a conventional multiple string matching algorithm, we can efficiently solve multiple pattern Cartesian tree matching. By experiments we show that our matching algorithms provide good performances for both single and multiple pattern Cartesian tree matching.

TCS Journal 2020 Journal Article

Fast string matching for DNA sequences

  • Cheol Ryu
  • Thierry Lecroq
  • Kunsoo Park

In this paper we propose the Maximal Average Shift (MAS) algorithm that finds a pattern scan order that maximizes the average shift length. We also present two extensions of MAS: one improves the scan speed of MAS by using the scan result of the previous window, and the other improves the running time of MAS by using q-grams. These algorithms show better average performances in scan speed than previous string matching algorithms for DNA sequences.

TCS Journal 2020 Journal Article

Finding patterns and periods in Cartesian tree matching

  • Sung Gwan Park
  • Magsarjav Bataa
  • Amihood Amir
  • Gad M. Landau
  • Kunsoo Park

We introduce a new metric of match, called Cartesian tree matching, which means that two strings match if they have the same Cartesian trees. Based on Cartesian tree matching, we define single pattern matching, multiple pattern matching, and indexing problems. We propose a linear time algorithm for single pattern matching, and randomized linear time algorithms for multiple pattern matching and indexing. We also define three types of periods, called full period, initial period, and general period. We propose O ( n ) time, O ( n log ⁡ log ⁡ n ) time, and O ( n log ⁡ n ) time algorithms for finding all the full periods, initial periods, and general periods of a string of length n, respectively. Our efficient algorithms use a representation of the Cartesian tree, called parent-distance representation.

TCS Journal 2018 Journal Article

FM-index of alignment with gaps

  • Joong Chae Na
  • Hyunjoon Kim
  • Seunghwan Min
  • Heejin Park
  • Thierry Lecroq
  • Martine Léonard
  • Laurent Mouchard
  • Kunsoo Park

Recently a compressed index for similar strings, called the FM-index of alignment (FMA), has been proposed with the functionalities of pattern search and random access. The FMA is quite efficient in space requirement and pattern search time, but it is applicable only for an alignment of strings without gaps. In this paper we propose the FM-index of alignment with gaps, a realistic index for similar strings, which allows gaps in their alignment. For this, we design a new version of the suffix array of alignment by using an alignment transformation and a new definition of the alignment-suffix. The new suffix array of alignment enables us to support the LF-mapping and backward search, the key functionalities of the FM-index, regardless of gap existence in the alignment. We experimentally compared our index with RLCSA due to Mäkinen et al. and related indexes GCSA due to Sirén et al. and GCSA2 due to Sirén on genome sequences from the 1000 Genomes Project. The index size of our index is smaller than those of other indexes.

TCS Journal 2017 Journal Article

A fast algorithm for the all-pairs suffix–prefix problem

  • Jihyuk Lim
  • Kunsoo Park

The all-pairs suffix–prefix problem occurs as a subproblem of DNA sequence assembly where it is the most time-consuming part of the whole assembly. Although there are algorithms for the all-pairs suffix–prefix problem which are optimal in the asymptotic time complexity, they are slower than SOF and Readjoiner which are state-of-the-art algorithms used in practice. In this paper we present an algorithm for the all-pairs suffix–prefix problem that uses a simple data structure for storing input strings and advanced algorithmic techniques for matching, which together lead to fast running time in practice. Our algorithm is 14 times faster than SOF and 18 times faster than Readjoiner on average in real datasets and random datasets.

TCS Journal 2016 Journal Article

FM-index of alignment: A compressed index for similar strings

  • Joong Chae Na
  • Hyunjoon Kim
  • Heejin Park
  • Thierry Lecroq
  • Martine Léonard
  • Laurent Mouchard
  • Kunsoo Park

In this paper we propose the FM-index of alignment, a compressed index for similar strings with the functionalities of pattern search and random access. For this, we first design a new and improved version of the suffix array of alignment. The FM-index of alignment is an FM-index of this suffix array of alignment. The FM-index of alignment supports the LF-mapping and backward search, the key functionalities of the FM-index, but the LF-mapping and backward search of our index is significantly more involved than the original FM-index. We implemented the FM-index of alignment and did experiments on 100 genome sequences from the 1000 Genomes Project. The index size of the FM-index of alignment is about a half of that of RLCSA due to Mäkinen et al.

TCS Journal 2014 Journal Article

Extending alignments with k -mismatches and ℓ -gaps

  • Carl Barton
  • Costas S. Iliopoulos
  • Inbok Lee
  • Laurent Mouchard
  • Kunsoo Park
  • Solon P. Pissis

Recently, the problem of extending an alignment with k-mismatches and a single gap for pairwise sequence alignment was introduced (Flouri et al. , 2011). The authors considered the problem of extending an alignment under the Hamming distance model by also allowing the insertion of a single gap; and presented a Θ ( m β ) -time algorithm to solve it, where m is the length of the shortest sequence to be extended, and β is the maximum allowed length of the single gap. Very recently, it was shown (Flouri et al. , 2012) that this problem is strongly and directly motivated by the next-generation re-sequencing application: aligning tens of millions of short DNA sequences against a reference genome. In this article, we consider an extension of this problem: extending an alignment with k-mismatches and two gaps; and present a Θ ( m β ) -time algorithm to solve it. This extension is proved to be fundamental in the next-generation re-sequencing application (Alachiotis et al. , 2012). In addition, we present a generalisation of our solution to solve the problem of extending an alignment with k-mismatches and ℓ-gaps in time Θ ( m β ℓ ). The presented solutions work provided that all gaps in the alignment must occur in one of the two sequences.

TCS Journal 2014 Journal Article

Order-preserving matching

  • Jinil Kim
  • Peter Eades
  • Rudolf Fleischer
  • Seok-Hee Hong
  • Costas S. Iliopoulos
  • Kunsoo Park
  • Simon J. Puglisi
  • Takeshi Tokuyama

We introduce a new string matching problem called order-preserving matching on numeric strings, where a pattern matches a text if the text contains a substring of values whose relative orders coincide with those of the pattern. Order-preserving matching is applicable to many scenarios such as stock price analysis and musical melody matching in which the order relations should be matched instead of the strings themselves. Solving order-preserving matching is closely related to the representation of order relations of a numeric string. We define the prefix representation and the nearest neighbor representation of the pattern, both of which lead to efficient algorithms for order-preserving matching. We present efficient algorithms for single and multiple pattern cases. For the single pattern case, we give an O ( n log m ) time algorithm and optimize it further to obtain O ( n + m log m ) time. For the multiple pattern case, we give an O ( n log m ) time algorithm.

TCS Journal 2013 Journal Article

Finding consensus and optimal alignment of circular strings

  • Taehyung Lee
  • Joong Chae Na
  • Heejin Park
  • Kunsoo Park
  • Jeong Seop Sim

Circular strings are different from linear strings in that the last symbol is considered to precede the first symbol. Even though circular strings are biologically important, only a few efforts have been made to solve computational problems on circular strings. In this paper, we introduce consensus problems for circular strings of length n and present the first non-trivial algorithms to find a consensus and an optimal alignment for circular strings by the Hamming distance. They are O ( n 2 log n ) -time algorithms for three circular strings and an O ( n 3 log n ) -time algorithm for four circular strings. Our algorithms are O ( n / log n ) times faster than the naïve algorithms directly using the solutions for the linear consensus problems, which take O ( n 3 ) time for three circular strings and O ( n 4 ) time for four circular strings. This speedup was achieved by reducing the problems into correlations and by formulating and solving systems of linear equations. Moreover, our algorithms use only O ( n ) space.

TCS Journal 2011 Journal Article

Efficient algorithms for consensus string problems minimizing both distance sum and radius

  • Amihood Amir
  • Gad M. Landau
  • Joong Chae Na
  • Heejin Park
  • Kunsoo Park
  • Jeong Seop Sim

The consensus (string) problem is finding a representative string, called a consensus, of a given set S of strings. In this paper we deal with consensus problems considering both distance sum and radius, where the distance sum is the sum of (Hamming) distances from the strings in S to the consensus and the radius is the longest (Hamming) distance from the strings in S to the consensus. Although there have been results considering either distance sum or radius, there have been no results considering both, to the best of our knowledge. We present the first algorithms for two consensus problems considering both distance sum and radius for three strings: one problem is to find an optimal consensus minimizing both distance sum and radius. The other problem is to find a bounded consensus such that the distance sum is at most s and the radius is at most r for given constants s and r. Our algorithms are based on characterization of the lower bounds of distance sum and radius, and thus they solve the problems efficiently. Both algorithms run in linear time.

TCS Journal 2009 Journal Article

Dynamic rank/select structures with applications to run-length encoded texts

  • Sunho Lee
  • Kunsoo Park

Given an n -length text over a σ -size alphabet, we propose a framework for dynamic rank/select structures on the text and some of its applications. For a small alphabet with σ ≤ log n, we propose a two-level structure consisting of a counting scheme and a storing scheme that supports O ( log n ) worst-case time r a n k / s e l e c t operations and O ( log n ) amortized time i n s e r t / d e l e t e operations. For a large alphabet with log n < σ ≤ n, we extend it to obtain O ( ( 1 + log σ log log n ) log n ) worst-case time r a n k / s e l e c t and O ( ( 1 + log σ log log n ) log n ) amortized time i n s e r t / d e l e t e. Our structure provides a simple representation of an index for a collection of texts. In addition, we present rank/select structures on run-length encoding (RLE) of a text. For the n ′ -length RLE of an n -length text, our static version provides O ( 1 ) time s e l e c t and O ( log log σ ) time r a n k using n ′ log σ + O ( n ) bits and our dynamic version gives O ( ( 1 + log σ log log n ) log n ) time operations in n ′ log σ + o ( n ′ log σ ) + O ( n ) bits.

TCS Journal 2008 Journal Article

Computing similarity of run-length encoded strings with affine gap penalty

  • Jin Wook Kim
  • Amihood Amir
  • Gad M. Landau
  • Kunsoo Park

The problem of computing the similarity of two run-length encoded strings has been studied for various scoring metrics. Many algorithms have been developed for the longest common subsequence metric and some algorithms for the Levenshtein distance metric and the weighted edit distance metric. In this paper we consider similarity based on the affine gap penalty metric which is a more general and rather complicated scoring metric than the weighted edit distance. To compute the similarity in this model efficiently, we convert the problem into a path problem on a directed acyclic graph and use some properties of maximum paths in this graph. We present an O ( n m ′ + n ′ m ) time algorithm for computing the similarity of two run-length encoded strings in the affine gap penalty model, where n and m are the lengths of given two strings whose run-length encoded lengths are n ′ and m ′, respectively.

TCS Journal 2007 Journal Article

Alphabet-independent linear-time construction of compressed suffix arrays using o ( n log n ) -bit working space

  • Joong Chae Na
  • Kunsoo Park

The suffix array is a fundamental index data structure in string algorithms and bioinformatics, and the compressed suffix array (CSA) and the FM-index are its compressed versions. Many algorithms for constructing these index data structures have been developed. Recently, Hon et al. [W. K. Hon, K. Sadakane, W. K. Sung, Breaking a time-and-space barrier in constructing full-text indices, in: Proceedings of the 44th Annual IEEE Symposium on Foundations of Computer Science, 2003, pp. 251–260] proposed a construction algorithm using O ( n log log | Σ | ) time and O ( n log | Σ | ) -bit working space, which is the fastest algorithm using O ( n log | Σ | ) -bit working space. In this paper we give an efficient algorithm to construct the index data structures. Our algorithm constructs the suffix array, the CSA, the FM-index, and Burrows–Wheeler transform using alphabet-independent O ( n ) time and O ( n log | Σ | log | Σ | α n ) -bit working space, where α = log 3 2. Our algorithm takes less time and more space than Hon et al. ’s algorithm. Our algorithm uses least working space among alphabet-independent linear-time algorithms.

TCS Journal 2007 Journal Article

An efficient alignment algorithm for masked sequences

  • Jin Wook Kim
  • Kunsoo Park

We consider the alignment problem where sequences may have masked regions. The bases in masked regions are either unspecified or unknown, and they will be denoted by N. We present an efficient algorithm that finds an optimal local alignment by skipping such masked regions of sequences. Our algorithm works for both the affine gap penalty model and the linear gap penalty model. The time complexity of our algorithm is O ( ( n − T ) ( m − S ) + v m + w n ) time, where n and m are the lengths of given sequences A and B, T and S are the numbers of base N in A and B, and v and w are the numbers of masked regions in A and B, respectively.

I&C Journal 2004 Journal Article

Parallel two dimensional witness computation

  • Richard Cole
  • Zvi Galil
  • Ramesh Hariharan
  • S. Muthukrishnan
  • Kunsoo Park

An optimal parallel CRCW-PRAM algorithm to compute witnesses for all non-period vectors of an m 1×m 2 pattern is given. The algorithm takes O(loglogm) time and does O(m 1×m 2) work, where m=max{m 1, m 2}. This yields a work optimal algorithm for 2D pattern matching which takes O(loglogm) preprocessing time and O(1) text processing time.

TCS Journal 2003 Journal Article

Generalizations of suffix arrays to multi-dimensional matrices

  • Dong Kyue Kim
  • Yoo Ah Kim
  • Kunsoo Park

We propose multi-dimensional index data structures that generalize suffix arrays to square matrices and cubic matrices. Giancarlo proposed a two-dimensional index data structure, the Lsuffix tree, that generalizes suffix trees to square matrices. However, the construction algorithm for Lsuffix trees maintains complicated data structures and uses a large amount of space. We present simple construction algorithms for multi-dimensional suffix arrays by applying a new partitioning technique to lexicographic sorting. Our contributions are the first efficient algorithms for constructing two-dimensional and three-dimensional suffix arrays directly.

TCS Journal 2003 Journal Article

Generalizations of suffix arrays to multi-dimensional matrices

  • Dong Kyue Kim
  • Yoo Ah Kim
  • Kunsoo Park

We propose multi-dimensional index data structures that generalize suffix arrays to square matrices and cubic matrices. Giancarlo proposed a two-dimensional index data structure, the Lsuffix tree, that generalizes suffix trees to square matrices. However, the construction algorithm for Lsuffix trees maintains complicated data structures and uses a large amount of space. We present simple construction algorithms for multi-dimensional suffix arrays by applying a new partitioning technique to lexicographic sorting. Our contributions are the first efficient algorithms for constructing two-dimensional and three-dimensional suffix arrays directly.

TCS Journal 2003 Journal Article

Truncated suffix trees and their application to data compression

  • Joong Chae Na
  • Alberto Apostolico
  • Costas S. Iliopoulos
  • Kunsoo Park

The suffix tree is a fundamental data structure in the area of string algorithms and it has been used in many applications including data compression. In this paper we propose a data structure called the truncated suffix tree, which is a truncated version of the suffix tree. We also present two linear-time construction algorithms for truncated suffix trees and two algorithms that delete suffixes from truncated suffix trees. The truncated suffix tree is particularly a useful data structure for LZ77 that compresses using a sliding window of a fixed size. Our algorithms lead to two implementations of LZ77 that maintain sliding windows by truncated suffix trees. We also present a technique of finding the longest match in a sliding window, which is a crucial step in LZ77.

TCS Journal 2001 Journal Article

Approximate periods of strings

  • Jeong Seop Sim
  • Costas S. Iliopoulos
  • Kunsoo Park
  • W.F. Smyth

The study of approximately periodic strings is relevant to diverse applications such as molecular biology, data compression, and computer-assisted music analysis. Here we study different forms of approximate periodicity under a variety of distance functions. We consider three related problems, for two of which we derive polynomial-time algorithms; we then show that the third problem is NP-complete.

TCS Journal 2001 Journal Article

Parallel algorithms for red–black trees

  • Heejin Park
  • Kunsoo Park

We present parallel algorithms for the following four operations on red–black trees: construction, search, insertion, and deletion. Our parallel algorithm for constructing a red–black tree from a sorted list of n items runs in O(1) time with n processors on the CRCW PRAM and runs in O(loglog n) time with n/loglog n processors on the EREW PRAM. Our construction algorithm does not require the assumptions that previous construction algorithms used. Each of our parallel algorithms for search, insertion, and deletion in red–black trees runs in O(log n+log k) time with k processors on the EREW PRAM, where k is the number of unsorted items to search for, insert, or delete and n is the number of nodes in a red–black tree.

TCS Journal 1996 Journal Article

A work-time optimal algorithm for computing all string covers

  • Costas S. Iliopoulos
  • Kunsoo Park

In recent study of repetitive structures of strings, generalized notions of periods have been introduced. A typical regularity, the period u of a given string x, grasps the repetitiveness of x since x is a prefix of a string constructed by concatenations of u. A substring w of x is called a cover of x if x can be constructed by concatenations and superpositions of w. The notion “cover” is a generalization of periods in the sense that superpositions as well as concatenations are considered to define it, whereas only concatenations are considered for periods. We consider the all-covers problem, i. e. , that of computing all the covers of a given string of length n. We present an optimal O(log log n)-time CRCW PRAM algorithm for the all-covers problem. Since there is an Ω(log log n) lower bound on the time complexity of the all-covers problem, our algorithm is work-time optimal.

FOCS Conference 1993 Conference Paper

Optimally fast parallel algorithms for preprocessing and pattern matching in one and two dimensions

  • Richard Cole 0001
  • Maxime Crochemore
  • Zvi Galil
  • Leszek Gasieniec
  • Ramesh Hariharan
  • S. Muthukrishnan 0001
  • Kunsoo Park
  • Wojciech Rytter

All algorithms below are optimal alphabet-independent parallel CRCW PRAM algorithms. In one dimension: Given a pattern string of length m for the string-matching problem, we design an algorithm that computes a deterministic sample of a sufficiently long substring in constant time. This problem used to be a bottleneck in the pattern preprocessing for one- and two-dimensional pattern matching. The best previous time bound was O(log/sup 2/ m/log log m). We use this algorithm to obtain the following results. 1. Improving the preprocessing of the constant-time text search algorithm from O(log/sup 2/ m/log log m) to n(log log m), which is now best possible. 2. A constant-time deterministic string-matching algorithm in the case that the text length n satisfies n=/spl Omega/(m/sup 1+/spl epsiv//) for a constant /spl epsiv/>0. 3. A simple probabilistic string-matching algorithm that has constant time with high probability for random input. 4. A constant expected time Las-Vegas algorithm for computing the period of the pattern and all witnesses and thus string matching itself, solving the main open problem remaining in string matching. >

TCS Journal 1992 Journal Article

Dynamic programming with convexity, concavity and sparsity

  • Zvi Galil
  • Kunsoo Park

Dynamic programming is a general problem-solving technique that has been widely used in various fields such as control theory, operations research, biology and computer science. In many applications dynamic programming problems satisfy additional conditions of convexity, concavity and sparsity. This paper presents a classification of dynamic programming problems and surveys efficient algorithms based on the three conditions.

FOCS Conference 1992 Conference Paper

Truly Alphabet-Independent Two-Dimensional Pattern Matching

  • Zvi Galil
  • Kunsoo Park

A. Amir, G. Benson and M. Farach (see Proc. 24th STOC, p. 59-68 (1992)) gave an algorithm for two-dimensional pattern matching (ABF for short) whose text processing is independent of the alphabet and takes O(n/sup 2/) time, but whose pattern processing is dependent on the alphabet and takes O(m/sup 2/log mod Sigma mod ) time. The authors present an algorithm that is truly independent of the alphabet and takes linear O(m/sup 2/+n/sup 2/) time. As in the Knuth-Morris-Pratt algorithm, the only operation on the alphabet is the equality test of two symbols. All previous algorithms except the ABF algorithm reduce the two-dimensional problem into one-dimensional string matching, and use known techniques in string matching. The ABF algorithm uses two-dimensional periodicity for text processing, but their pattern processing resorts to one-dimensional techniques. The authors present a two-dimensional technique for both pattern processing and text processing. >

v2026.09.13