Journal of Combinatorial Optimization最新文献

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 and a single sink node is given a demand. 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 high-order 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 the current best algorithms when an input network is restricted such that the sink has a small in-degree and every edge has the same capacity.

Let G be some simple graph and k be any positive integer. Take (h: V(G)rightarrow {0,1,ldots ,k+1}) and (v in V(G)), let (AN_{h}(v)) denote the set of vertices (win N_{G}(v)) with (h(w)ge 1). Let (AN_{h}[v] = AN_{h}(v)cup {v}). The function h is a [k]-Roman dominating function of G if (h(AN_{h}[v]) ge |AN_{h}(v)| + k) holds for any (v in V(G)). The minimum weight of such a function is called the k-th Roman Domination number of G, which is denoted by (gamma _{kR}(G)). In 2020, Banerjee et al. presented linear time algorithms to compute the double Roman domination number on proper interval graphs and block graphs. They posed the open question that whether there is some polynomial time algorithm to solve the double Roman domination problem on interval graphs. It is argued that the interval graph is a nontrivial graph class. In this article, we design a simple dynamic polynomial time algorithm to solve the k-th Roman domination problem on interval graphs for each fixed integer (k>1).

In the Vertex Triangle 2-Club problem, we are given an undirected graph G and aim to find a maximum-vertex subgraph of G that has diameter at most 2 and in which every vertex is contained in at least (ell ) triangles in the subgraph. So far, the only algorithm for solving Vertex Triangle 2-Club relies on an ILP formulation (Almeida and Brás in Comput Oper Res 111:258–270, 2019). In this work, we develop a combinatorial branch-and-bound algorithm that, coupled with a set of data reduction rules, outperforms the existing implementation and is able to find optimal solutions on sparse real-world graphs with more than 100,000 vertices in a few minutes. We also extend our algorithm to the Edge Triangle 2-Club problem where the triangle constraint is imposed on all edges of the subgraph.

This paper addresses the minmax regret 1-sink location problem on a dynamic flow path network with parametric weights. A dynamic flow path network consists 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 where all the people evacuate quickly. In our model, each weight is represented by a linear function of a common parameter t, and the decision maker who determines the sink location does not know the value of t. We formulate the problem under such uncertainty as the minmax regret problem. Given t and sink location x, the cost 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 this cost and the optimal cost under t. The problem is to find the sink location minimizing the maximum regret over all t. For the problem, we propose an (O(n^4 2^{alpha (n)} alpha (n)^2 log n)) time algorithm, where n is the number of vertices in the network and (alpha (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^{alpha (n)} alpha (n) log n)).

Gromov–Hausdorff distances measure shape difference between the objects representable as compact metric spaces, e.g. point clouds, manifolds, or graphs. Computing any Gromov–Hausdorff distance is equivalent to solving an NP-hard optimization problem, deeming the notion impractical for applications. In this paper we propose a polynomial algorithm for estimating the so-called modified Gromov–Hausdorff (mGH) distance, a relaxation of the standard Gromov–Hausdorff (GH) distance with similar topological properties. We implement the algorithm for the case of compact metric spaces induced by unweighted graphs as part of Python library scikit-tda, and demonstrate its performance on real-world and synthetic networks. The algorithm finds the mGH distances exactly on most graphs with the scale-free property. We use the computed mGH distances to successfully detect outliers in real-world social and computer networks.

Software vulnerabilities are flaws that may be exploited to cause loss or harm. Various automated machine-learning techniques have been developed in preceding studies to detect software vulnerabilities. This work tries to develop a technique for securing the software on the basis of their vulnerabilities that are already known, by developing a hybrid deep learning model to detect those vulnerabilities. Moreover, certain countermeasures are suggested based on the types of vulnerability to prevent the attack further. For different software projects taken as the dataset, feature fusion is done by utilizing canonical correlation analysis together with Deep Residual Network (DRN). A hybrid deep learning technique trained using AdamW-Rat Swarm Optimizer (AdamW-RSO) is designed to detect software vulnerability. Hybrid deep learning makes use of the Deep Belief Network (DBN) and Generative Adversarial Network (GAN). For every vulnerability, its location of occurrence within the software development procedures and techniques of alleviation via implementation level or design level activities are described. Thus, it helps in understanding the appearance of vulnerabilities, suggesting the use of various countermeasures during the initial phases of software design, and therefore, assures software security. Evaluating the performance of vulnerability detection by the proposed technique regarding recall, precision, and f-measure, it is found to be more effective than the existing methods.

This study investigates the prize-collecting single machine scheduling with bounds and penalties (PC-SMS-BP). In this problem, a set of n jobs and a single machine are considered, where each job (J_j) has a processing time (p_{j}), a profit (pi _{j}) and a rejection penalty (w_{j}). The upper bound on the processing number is U. The objective of this study is to find a feasible schedule that minimizes the makespan of the accepted jobs and the total rejection penalty of the rejected jobs under the condition that the number of the accepted jobs does not exceed a given threshold U while the total profit of the accepted jobs does not fall below a specified profit bound (varPi ). We first demonstrate that this problem is NP-hard. Then, a pseudo-polynomial time dynamic programming algorithm and a fully polynomial time approximation scheme (FPTAS) are proposed. Finally, numerical experiments are conducted to compare the effectiveness of the two proposed algorithms.

Low-Acy-Matching asks to find a maximal matching M in a given graph G of minimum cardinality such that the set of M-saturated vertices induces an acyclic subgraph in G. The decision version of Low-Acy-Matching is known to be ({textsf{NP}})-complete. In this paper, we strengthen this result by proving that the decision version of Low-Acy-Matching remains ({textsf{NP}})-complete for bipartite graphs with maximum degree 6 and planar perfect elimination bipartite graphs. We also show the hardness difference between Low-Acy-Matching and Max-Acy-Matching. Furthermore, we prove that, even for bipartite graphs, Low-Acy-Matching cannot be approximated within a ratio of (n^{1-epsilon }) for any (epsilon >0) unless ({textsf{P}}={textsf{NP}}). Finally, we establish that Low-Acy-Matching exhibits (textsf{APX})-hardness when restricted to 4-regular graphs.

Let G be a connected graph and (t ge 1) a (rational) constant. A t-spanner of G is a spanning subgraph of G in which the distance between any pair of vertices is at most t times its distance in G. We address two problems on spanners. The first one, known as the minimum t-spanner problem (MinS (_t)), seeks in a connected graph a t-spanner with the smallest possible number of edges. In the second one, called minimum cost tree t-spanner problem (MCTS (_t)), the input graph has costs assigned to its edges and seeks a t-spanner that is a tree with minimum cost. It is an optimization version of the tree t-spanner problem (TreeS (_t)), a decision problem concerning the existence of a t-spanner that is a tree. MinS (_t) is known to be ({textsc {NP}})-hard for every (t ge 2). On the other hand, TreeS (_t) admits a polynomial-time algorithm for (t le 2) and is ({textsc {NP}})-complete for (t ge 4); but its complexity for (t=3) remains open. We focus on the class of subcubic graphs. First, we show that for such graphs MinS (_3) can be solved in polynomial time. These results yield a practical polynomial algorithm for TreeS (_3) that is of a combinatorial nature. We also show that MCTS (_2) can be solved in polynomial time. To obtain this last result, we prove a complete linear characterization of the polytope defined by the incidence vectors of the tree 2-spanners of a subcubic graph. A recent result showing that MinS (_3) on graphs with maximum degree at most 5 is NP-hard, together with the current result on subcubic graphs, leaves open only the complexity of MinS (_3) on graphs with maximum degree 4.