Deterministic Longest Common Subsequence Approximation in Near-Linear Time

2025-07-30

AI Summary

This paper addresses the Longest Common Subsequence (LCS) problem for two length-$n$ sequences and presents the first deterministic near-linear-time approximation algorithm. The method employs a block-alignment strategy, deterministic string matching, and dynamic programming pruning—avoiding any reliance on randomization assumptions. It runs in $O(n log n)$ time and outputs an $O(n^{3/4} log n)$-approximate solution: the computed LCS length is at least the optimal length divided by $O(n^{3/4} log n)$. This is the first deterministic LCS approximation algorithm achieving both a sublinear approximation ratio and near-linear runtime, breaking the prior dominance of randomized approaches. The result significantly advances the state of deterministic approximation algorithms for LCS, offering improved efficiency and stronger theoretical guarantees.

Technology Category

• Planning, Routing, and Scheduling: Deterministic Planning
• Search and Optimization: Learning to Search
• Constraint Satisfaction and Optimization: Distributed CSP/Optimization

Application Category

• Graph Algorithms and Modeling for the Web: Algorithms and analysis for incomplete, noisy, or partially observed Web-related graphs
• Search and Retrieval-Augmented AI: Web learning to rank, online learning, and counterfactual learning for ranking
• Economics, Online Markets and Human Computation: Cost models of using LLMs in production systems

Abstract

We provide a deterministic algorithm that outputs an $O(n^{3/4} log n)$-approximation for the Longest Common Subsequence (LCS) of two input sequences of length $n$ in near-linear time. This is the first deterministic approximation algorithm for LCS that achieves a sub-linear approximation ratio in near-linear time.

Problem

• Deterministic algorithm for LCS approximation
• Achieves sub-linear ratio in near-linear time
• First such algorithm with O(n^(3/4) log n) approximation

Innovation

• Deterministic algorithm for LCS approximation
• Achieves O(n^{3/4} log n) approximation ratio
• Runs in near-linear time complexity