algorithms

This paper investigates how dynamic programming (DP) degenerates into classical greedy algorithms under specific structural constraints. Focusing on three canonical problems—unit-weight interval scheduling, unit-value knapsack, and shortest paths with nonnegative edge weights—it proposes a systematic DP-to-greedy transformation framework. The method involves expanding the Bellman equation and leveraging monotonicity of the objective function together with optimal substructure to rigorously identify and eliminate redundant state transitions, thereby deriving the greedy-choice property. This approach unifies the theoretical justification for well-known greedy rules (e.g., “earliest finishing time”) and exposes an intrinsic continuity between DP and greedy paradigms within the algorithm design spectrum. The resulting derivation paradigm provides a transferable methodology for proving greedy correctness, offering both theoretical insight and pedagogical utility in algorithm design and analysis. (149 words)

This paper systematically investigates the computational complexity of three fundamental problems in Hierarchical Task Network (HTN) planning: plan verification, executability checking, and state reachability. Using structured graph-theoretic modeling, parameterized algorithm design, and tight lower-bound constructions, it establishes the first complete W[1]/FPT classification of these problems under standard parameters. It introduces the first meta-theorem that lifts polynomial-time solvability from primitive task networks to general task networks, and proves the tightness of its preconditions. Furthermore, for natural classes of primitive networks, it derives new polynomial-time algorithms for all three problems and provides matching conditional lower bounds. These results constitute a systematic breakthrough in HTN complexity theory, enabling principled complexity transfer across HTN formalisms and unifying previously fragmented analyses.

This work addresses automatic runtime and variable-size bound analysis for integer programs, focusing on the decidable subclass of periodic rational-solvable loops (PRS-loops). The proposed method introduces a modular analysis framework: it first derives local bounds for PRS-loops, then lifts them to global bounds via program transformation and inductive reasoning. Crucially, it extends the decidability of PRS-loop analysis to arbitrary integer programs by designing a synergistic synthesis mechanism combining abstract interpretation with rational linear algebra. The approach is fully automated in the tool KoAT, supporting precise derivation of polynomial and exponential complexity bounds as well as variable growth bounds. Experimental evaluation demonstrates effectiveness on diverse nontrivial integer programs, significantly improving the completeness, precision, and practicality of automated complexity analysis.

This paper addresses the long-standing efficiency bottleneck in rule-based graph programming: achieving time complexity comparable to classical imperative algorithms—without assumptions on node degrees or graph connectivity. We propose a compiler-enhanced graph data structure for the GP 2 language, integrating rooted rewriting rules, static analysis, and formal asymptotic complexity proofs. Our approach is the first to achieve, within a purely rule-based framework: (i) linear-time O(n + m) algorithms for connectivity and acyclicity testing; (ii) an O(nm) single-source shortest paths algorithm matching Bellman–Ford’s complexity; and (iii) full formal verification of both functional correctness and asymptotic time complexity for all algorithms. Experimental evaluation across diverse graph families confirms consistency between theoretical bounds and empirical performance.

Graph transformation algorithms in rule-based graph programming often fail to achieve linear-time complexity on arbitrary input graphs, typically requiring restrictive assumptions such as bounded node degree or graph connectivity. Method: This paper proposes a linear-time graph program construction method that imposes no prior assumptions on input graphs. It enhances the GP 2 compiler’s in-memory graph representation to support non-destructive rewriting, introduces a root-based rewriting mechanism to eliminate costly global graph matching, and establishes an empirical performance analysis framework. Results: The approach guarantees strict O(|V| + |E|) time complexity for three canonical tasks—cycle detection, connected component labeling, and breadth-first search—on arbitrary graphs, including disconnected, high-degree, and low-degree instances. Experimental validation confirms theoretical efficiency across diverse graph topologies.

This work proposes a formalization of algorithms within an intensional computability framework and clarifies their relationship to implementations in computational models. Treating computational models as monoid actions on configuration spaces, programs are modeled as dynamical systems constrained by such actions. Algorithms are defined as finite directed graphs of partial maps over edge-labeled abstract data structures, explicitly separating control flow from data operations. By leveraging tools from category theory, dynamical systems theory, and graph theory, the approach constructs a rigorous semantic framework that, for the first time, treats algorithms as abstract specifications of computational behavior and precisely characterizes the structure-preserving implementation relation between programs and algorithms, thereby deepening our understanding of the nature of computation.

Modular complexity analysis of integer programs remains challenging for non-tail-recursive and general function-call structures, as existing frameworks lack systematic support for recursion. Method: We introduce Recursive Ranking Functions (RRFs), a novel formalism enabling modular automatic resource analysis for arbitrary recursive integer programs. Our approach integrates RRFs with instruction-level complexity analysis and implements an end-to-end automated analyzer within the KoAT tool. Contribution/Results: Our method precisely infers polynomial and exponential time complexities—outperforming prior modular techniques in both precision and scalability. It overcomes a fundamental limitation of existing modular analysis frameworks, which were restricted to non-recursive programs. Experimental evaluation demonstrates significant improvements in analytical accuracy and applicability to realistic recursive code patterns, establishing the first fully modular, automated complexity analyzer supporting general recursion in integer programs.

This work addresses the challenge of verifying graph-theoretic properties on graph classes with bounded treewidth or pathwidth by proposing a unified framework that integrates tree-decomposition-based dynamic programming with formal reductions of graph properties. The framework enables automatic verification of atomic properties and their Boolean combinations, achieving for the first time a modular composition of dynamic programming algorithms coupled with parameterized automated theorem proving in treewidth. The developed TreeWidzard engine automatically checks whether all graphs of treewidth at most \(k\) satisfy a given Boolean expression \(P\) over graph properties, significantly enhancing the scalability and automation of complex graph property verification.

This work proposes “grid programs,” a two-dimensional computational model grounded in an integer lattice, which overcomes limitations of traditional models constrained by linear instruction sequences, named variables, and explicit memory addresses. In this paradigm, computation proceeds as an instruction pointer traverses the grid in four cardinal directions, while program state is maintained through a data stack, an address stack, and a three-pointer cyclic doubly linked list. The model enforces no variable names or syntactic constraints, relying instead on purely spatial control flow. It constitutes the first Turing-complete computational framework that is entirely free of named variables and defined solely by spatial layout. Formal operational semantics demonstrate its ability to simulate any register machine, and practical implementations—including factorial computation and string reversal—highlight its expressiveness. The approach shows promising applications in visual programming, cellular-automaton-inspired hardware, and code obfuscation resistance.

This study addresses the strongly NP-hard parallel machine scheduling problem $P2|r_j|C_{\max}$, which is notoriously difficult to scale due to the exponential time complexity $O(T^n)$ of conventional approaches. To overcome this limitation, the authors propose a bucket calculus framework that adaptively discretizes the time horizon, reducing complexity to $O(B^n)$ with $B \ll T$. Key innovations include bucket-indexed MILP modeling, precision-aware partial discretization, fractional bucket operators, and a quantum-inspired temporal constraint mechanism enabling multi-resolution precision allocation. Experimental results demonstrate a 94.4% reduction in decision variables and a theoretical speedup of up to $2.75 \times 10^{37}$. On instances with 20–400 tasks, the method achieves 97.6% resource utilization, excellent load balancing (σ/μ = 0.006), and an optimality gap below 5.1%.