arXiv subjects

Junichi Teruyama

Publications and source records attributed to Junichi Teruyama.

12 recordsLinked to original sources

arXiv2026

The Complexity of Boolean Connectivity Problem of $k$-Horn Formulas

The Boolean connectivity problem asks whether the set of satisfying assignments of a given Boolean formula forms a connected subgraph in the $n$-dimensional hypercube. This problem is known to be $\mathsf{coNP}$-complete, even when restricted to $k$-Horn formulas for $k \geq 3$, as shown by Makino, Tamaki, and Yamamoto. In this paper, we further investigate the computational complexity of {\sc Conn $k$-Horn}, the Boolean connectivity problem for $k$-Horn formulas. We provide algorithmic and hardness results for {\sc Conn $k$-Horn}. On the algorithmic side, we first present an exact exponential-time algorithm for arbitrary $k$ without any structural restrictions. Our algorithm builds on the deterministic PPZ algorithm proposed by Paturi, Pudlák, and Zane. It runs in $O^*(2^{(1 - 1/2k)n})$ time and polynomial space, achieving an exponential improvement over the previously known algorithm for the Boolean connectivity problem of $k$-CNF formulas, shown by Makino, Tamaki, and Yamamoto. We next give two polynomial-time algorithms for arbitrary $k$ under the following two restrictions: (i) each variable appears at most twice, and (ii) each clause has length exactly $k$ and each variable appears at most $k$ times. On the hardness side, we prove that {\sc Conn $3$-Horn} remains $\mathsf{coNP}$-complete even when each variable appears exactly three times.

cs.CC↗

arXiv2026

Required-edge Cycle Cover Problem: an ASP-Completeness Framework for Graph Problems and Puzzles

Proving the NP-completeness of pencil-and-paper puzzles typically relies on reductions from combinatorial problems such as the satisfiability problem (SAT). Although the properties of these problems are well studied, their purely combinatorial nature often does not align well with the geometric constraints of puzzles. In this paper, we introduce the Required-edge Cycle Cover Problem (RCCP) -- a variant of the Cycle Cover Problem (CCP) on mixed graphs. CCP on mixed graphs was studied by Seta (2002) to establish the ASP-completeness (i.e., NP-completeness under parsimonious reductions) of the puzzle Kakuro (a.k.a. Cross Sum), and is known to be ASP-complete under certain conditions. We prove the ASP-completeness of RCCP under certain conditions, and strengthen known ASP-completeness results of CCP on mixed graphs as a corollary. Using these results, we resolve the ASP-completeness of Constraint Graph Satisfiability (CGS) in a certain case, addressing an open problem posed by the MIT Hardness Group (2024). We also show that Kakuro remains ASP-complete even when the available digit set is $\{1, 2, 3\}$, consequently completing its complexity classification regarding the maximum available digit and the maximum lengths of contiguous blank cells. It strengthens previously known results of Seta (2002) and Ruepp and Holzer (2010). Furthermore, we introduce a flow model equivalent to the constrained RCCP; this model allows gadgets to be tiled densely on a rectangular grid, which enables us to reduce RCCP to various pencil-and-paper puzzles in a parsimonious manner. By applying this framework, we prove the ASP-completeness of several puzzles, including Chocona, Four Cells, Hinge, and Shimaguni, and strengthen existing NP-completeness results for Choco Banana and Five Cells to ASP-completeness.

cs.CC↗

arXiv2023

Sink Location Problems in Dynamic Flow Grid Networks

A dynamic flow network consists of a directed graph, where nodes called sources represent locations of evacuees, and nodes called sinks represent locations of evacuation facilities. Each source and each sink are given supply representing the number of evacuees and demand representing the maximum number of acceptable evacuees, respectively. Each edge is given capacity and transit time. Here, the capacity of an edge bounds the rate at which evacuees can enter the edge per unit time, and the transit time represents the time which evacuees take to travel across the edge. The evacuation completion time is the minimum time at which each evacuees can arrive at one of the evacuation facilities. Given a dynamic flow network without sinks, once sinks are located on some nodes or edges, the evacuation completion time for this sink location is determined. We then consider the problem of locating sinks to minimize the evacuation completion time, called the sink location problem. The problems have been given polynomial-time algorithms only for limited networks such as paths, cycles, and trees, but no polynomial-time algorithms are known for more complex network classes. In this paper, we prove that the 1-sink location problem can be solved in polynomial-time when an input network is a grid with uniform edge capacity and transit time.

cs.DS↗

arXiv2023

Faster Algorithms for Evacuation Problems in Networks with the Single Sink of Small Degree

In this paper, we propose new algorithms for evacuation problems defined on dynamic flow networks. A dynamic flow network is a directed graph in which source nodes are given supplies (i.e., the number of evacuees) and a single sink node is given a demand (i.e., the maximum number of acceptable evacuees). The evacuation problem seeks a dynamic flow that sends all supplies from sources to the sink such that its demand is satisfied in the minimum feasible time horizon. For this problem, the current best algorithms are developed by Schlöter (2018) and Kamiyama (2019), which run in strongly polynomial time but with highorder polynomial time complexity because they use submodular function minimization as a subroutine. In this paper, we propose new algorithms that do not explicitly execute submodular function minimization, and we prove that they are faster than those by Schlöter (2018) and Kamiyama (2019) when an input network is restricted such that the sink has a small in-degree and every edge has the same capacity.

cs.DS↗

arXiv2022

ZDD-Based Algorithmic Framework for Solving Shortest Reconfiguration Problems

This paper proposes an algorithmic framework for various reconfiguration problems using zero-suppressed binary decision diagrams (ZDDs), a data structure for families of sets. In general, a reconfiguration problem checks if there is a step-by-step transformation between two given feasible solutions (e.g., independent sets of an input graph) of a fixed search problem such that all intermediate results are also feasible and each step obeys a fixed reconfiguration rule (e.g., adding/removing a single vertex to/from an independent set). The solution space formed by all feasible solutions can be exponential in the input size, and indeed many reconfiguration problems are known to be PSPACE-complete. This paper shows that an algorithm in the proposed framework efficiently conducts the breadth-first search by compressing the solution space using ZDDs, and finds a shortest transformation between two given feasible solutions if exists. Moreover, the proposed framework provides rich information on the solution space, such as the connectivity of the solution space and all feasible solutions reachable from a specified one. We demonstrate that the proposed framework can be applied to various reconfiguration problems, and experimentally evaluate their performances.

cs.DS↗

arXiv2020

Minmax Regret 1-Sink Location Problems on Dynamic Flow Path Networks with Parametric Weights

This paper addresses the minmax regret 1-sink location problem on dynamic flow path networks with parametric weights. We are given a dynamic flow network consisting of an undirected path with positive edge lengths, positive edge capacities, and nonnegative vertex weights. A path can be considered as a road, an edge length as the distance along the road and a vertex weight as the number of people at the site. An edge capacity limits the number of people that can enter the edge per unit time. We consider the problem of locating a sink in the network, to which all the people evacuate from the vertices as quickly as possible. In our model, each weight is represented by a linear function in a common parameter $t$, and the decision maker who determines the location of a sink does not know the value of $t$. We formulate the sink location problem under such uncertainty as the minmax regret problem. Given $t$ and a sink location $x$, the cost of $x$ under $t$ is the sum of arrival times at $x$ for all the people determined by $t$. The regret for $x$ under $t$ is the gap between the cost of $x$ under $t$ and the optimal cost under $t$. The task of the problem is formulated as the one to find a sink location that minimizes the maximum regret over all $t$. For the problem, we propose an $O(n^4 2^{α(n)} α(n) \log n)$ time algorithm where $n$ is the number of vertices in the network and $α(\cdot)$ is the inverse Ackermann function. Also for the special case in which every edge has the same capacity, we show that the complexity can be reduced to $O(n^3 2^{α(n)} α(n) \log n)$.

cs.DS↗

arXiv2020

Almost Linear Time Algorithms for Minsum $k$-Sink Problems on Dynamic Flow Path Networks

We address the facility location problems on dynamic flow path networks. A dynamic flow path network consists of an undirected path with positive edge lengths, positive edge capacities, and positive vertex weights. A path can be considered as a road, an edge length as the distance along the road and a vertex weight as the number of people at the site. An edge capacity limits the number of people that can enter the edge per unit time. In the dynamic flow network, given particular points on edges or vertices, called sinks, all the people evacuate from the vertices to the sinks as quickly as possible. The problem is to find the location of sinks on a dynamic flow path network in such a way that the aggregate evacuation time (i.e., the sum of evacuation times for all the people) to sinks is minimized. We consider two models of the problem: the confluent flow model and the non-confluent flow model. In the former model, the way of evacuation is restricted so that all the people at a vertex have to evacuate to the same sink, and in the latter model, there is no such restriction. In this paper, for both the models, we develop algorithms which run in almost linear time regardless of the number of sinks. It should be stressed that for the confluent flow model, our algorithm improves upon the previous result by Benkoczi et al. [Theoretical Computer Science, 2020], and one for the non-confluent flow model is the first polynomial time algorithm.

cs.DS↗

arXiv2020

On Computing a Center Persistence Diagram

Throughout this paper, a persistence diagram ${\cal P}$ is composed of a set $P$ of planar points (each corresponding to a topological feature) above the line $Y=X$, as well as the line $Y=X$ itself, i.e., ${\cal P}=P\cup\{(x,y)|y=x\}$. Given a set of persistence diagrams ${\cal P}_1,...,{\cal P}_m$, for the data reduction purpose, one way to summarize their topological features is to compute the {\em center} ${\cal C}$ of them first under the bottleneck distance. We consider two discrete versions and one continuous version. For technical reasons, we first focus on the case when $|P_i|$'s are all the same (i.e., all have the same size $n$), and the problem is to compute a center point set $C$ under the bottleneck matching distance. We show, by a non-trivial reduction from the Planar 3D-Matching problem, that this problem is NP-hard even when $m=3$ diagrams are given. This implies that the general center problem for persistence diagrams under the bottleneck distance, when $P_i$'s possibly have different sizes, is also NP-hard when $m\geq 3$. On the positive side, we show that this problem is polynomially solvable when $m=2$ and admits a factor-2 approximation for $m\geq 3$. These positive results hold for any $L_p$ metric when $P_i$'s are point sets of the same size, and also hold for the case when $P_i$'s have different sizes in the $L_\infty$ metric (i.e., for the Center Persistence Diagram problem). This is the best possible in polynomial time for the Center Persistence Diagram under the bottleneck distance unless P = NP. All these results hold for both of the discrete versions as well as the continuous version; in fact, the NP-hardness and approximation results also hold under the Wasserstein distance for the continuous version.

cs.CG↗

arXiv2018

Reconstructing Strings from Substrings: Optimal Randomized and Average-Case Algorithms

The problem called "String reconstruction from substrings" is a mathematical model of sequencing by hybridization that plays an important role in DNA sequencing. In this problem, we are given a blackbox oracle holding an unknown string ${\mathcal X}$ and are required to obtain (reconstruct) ${\mathcal X}$ through "substring queries" $Q(S)$. $Q(S)$ is given to the oracle with a string $S$ and the answer of the oracle is Yes if ${\mathcal X}$ includes $S$ as a substring and No otherwise. Our goal is to minimize the number of queries for the reconstruction. In this paper, we deal with only binary strings for ${\mathcal X}$ whose length $n$ is given in advance by using a sequence of good $S$'s. In 1995, Skiena and Sundaram first studied this problem and obtained an algorithm whose query complexity is $n+O(\log n)$. Its information theoretic lower bound is $n$, and they posed an obvious open question; if we can remove the $O(\log n)$ additive term. No progress has been made until now. This paper gives two partially positive answers to this open question. One is a randomized algorithm whose query complexity is $n+O(1)$ with high probability and the other is an average-case algorithm also having a query complexity of $n+O(1)$ on average. The $n$ lower bound is still true for both cases, and hence they are optimal up to an additive constant.

cs.DS↗

arXiv2017

Improved Average Complexity for Comparison-Based Sorting

This paper studies the average complexity on the number of comparisons for sorting algorithms. Its information-theoretic lower bound is $n \lg n - 1.4427n + O(\log n)$. For many efficient algorithms, the first $n\lg n$ term is easy to achieve and our focus is on the (negative) constant factor of the linear term. The current best value is $-1.3999$ for the MergeInsertion sort. Our new value is $-1.4106$, narrowing the gap by some $25\%$. An important building block of our algorithm is "two-element insertion," which inserts two numbers $A$ and $B$, $A<B$, into a sorted sequence $T$. This insertion algorithm is still sufficiently simple for rigorous mathematical analysis and works well for a certain range of the length of $T$ for which the simple binary insertion does not, thus allowing us to take a complementary approach with the binary insertion.

cs.DS↗

arXiv2012

Reconstructing Strings from Substrings with Quantum Queries

This paper investigates the number of quantum queries made to solve the problem of reconstructing an unknown string from its substrings in a certain query model. More concretely, the goal of the problem is to identify an unknown string $S$ by making queries of the following form: "Is $s$ a substring of $S$?", where $s$ is a query string over the given alphabet. The number of queries required to identify the string $S$ is the query complexity of this problem. First we show a quantum algorithm that exactly identifies the string $S$ with at most $3/4N + o(N)$ queries, where $N$ is the length of $S$. This contrasts sharply with the classical query complexity $N$. Our algorithm uses Skiena and Sundaram's classical algorithm and the Grover search as subroutines. To make them effectively work, we develop another subroutine that finds a string appearing only once in $S$, which may have an independent interest. We also prove two lower bounds. The first one is a general lower bound of $Ω(\frac{N}{\log^2{N}})$, which means we cannot achieve a query complexity of $O(N^{1-ε})$ for any constant $ε$. The other one claims that if we cannot use queries of length roughly between $\log N$ and $3 \log N$, then we cannot achieve a query complexity of any sublinear function in $N$.

quant-ph↗

arXiv2010

Quantum Counterfeit Coin Problems

The counterfeit coin problem requires us to find all false coins from a given bunch of coins using a balance scale. We assume that the balance scale gives us only ``balanced'' or ``tilted'' information and that we know the number k of false coins in advance. The balance scale can be modeled by a certain type of oracle and its query complexity is a measure for the cost of weighing algorithms (the number of weighings). In this paper, we study the quantum query complexity for this problem. Let Q(k,N) be the quantum query complexity of finding all k false coins from the N given coins. We show that for any k and N such that k < N/2, Q(k,N)=O(k^{1/4}), contrasting with the classical query complexity, Ω(k\log(N/k)), that depends on N. So our quantum algorithm achieves a quartic speed-up for this problem. We do not have a matching lower bound, but we show some evidence that the upper bound is tight: any algorithm, including our algorithm, that satisfies certain properties needs Ω(k^{1/4}) queries.

quant-ph↗