scholarly journals Polynomial Time Instances for the IKHO Problem

2012 ◽  
Vol 2012 ◽  
pp. 1-10
Author(s):  
Romeo Rizzi ◽  
Luca Nardin
Keyword(s):  
Dynamic Programming ◽  
Polynomial Time ◽  
Broad Class ◽  
Structural Parameters ◽  
Polynomial Time Algorithm ◽  
Time Algorithm ◽  
The Other ◽  
Heuristic Optimization ◽  
Negative Fact

The Interactive Knapsacks Heuristic Optimization (IKHO) problem is a particular knapsacks model in which, given an array of knapsacks, every insertion in a knapsack affects also the other knapsacks, in terms of weight and profit. The IKHO model was introduced by Isto Aho to model instances of the load clipping problem. The IKHO problem is known to be APX-hard and, motivated by this negative fact, Aho exhibited a few classes of polynomial instances for the IKHO problem. These instances were obtained by limiting the ranges of two structural parameters, c and u, which describe the extent to which an insertion in a knapsack in uences the nearby knapsacks. We identify a new and broad class of instances allowing for a polynomial time algorithm. More precisely, we show that the restriction of IKHO to instances where is bounded by a constant can be solved in polynomial time, using dynamic programming.

Efficient Processing of XML Tree Pattern Queries

2006 ◽  
Vol 10 (5) ◽  
pp. 738-743 ◽  
Author(s):  
Yangjun Chen ◽  
◽  
Dunren Che ◽  
Keyword(s):  
Dynamic Programming ◽  
Polynomial Time ◽  
Main Idea ◽  
Polynomial Time Algorithm ◽  
Time Algorithm ◽  
The Other ◽  
Tree Pattern ◽  
Efficient Processing

In this paper, we present a polynomial-time algorithm for TPQ (tree pattern queries) minimization without XML constraints involved. The main idea of the algorithm is a dynamic programming strategy to find all the matching subtrees within a TPQ. A matching subtree implies a redundancy and should be removed in such a way that the semantics of the original TPQ is not damaged. Our algorithm consists of two parts: one for subtree recognization and the other for subtree deletion. Both of them needs only O(<I>n</I>2) time, where <I>n</I> is the number of nodes in a TPQ.

scholarly journals Maximin-Aware Allocations of Indivisible Goods

2019 ◽  
Author(s):  
Hau Chan ◽  
Jing Chen ◽  
Bo Li ◽  
Xiaowei Wu
Keyword(s):  
Polynomial Time ◽  
Polynomial Time Algorithm ◽  
Time Algorithm ◽  
The Other ◽  
Indivisible Goods ◽  
Know How

We study envy-free allocations of indivisible goods to agents in settings where each agent is unaware of the goods allocated to other agents. In particular, we propose the maximin aware (MMA) fairness measure, which guarantees that every agent, given the bundle allocated to her, is aware that she does not envy at least one other agent, even if she does not know how the other goods are distributed among other agents. We also introduce two of its relaxations, and discuss their egalitarian guarantee and existence. Finally, we present a polynomial-time algorithm, which computes an allocation that approximately satisfies MMA or its relaxations. Interestingly, the returned allocation is also 1/2-approximate EFX when all agents have sub- additive valuations, which improves the algorithm in [Plaut and Roughgarden, 2018].

scholarly journals Complexity of Strong Approximation on the Sphere

2019 ◽  
Author(s):  
Naser T Sardari
Keyword(s):  
Polynomial Time ◽  
Strong Approximation ◽  
Polynomial Time Algorithm ◽  
Time Algorithm ◽  
The Other ◽  
Ramanujan Graphs ◽  
Other Hand ◽  
Np Complete

Abstract By assuming some widely believed arithmetic conjectures, we show that the task of accepting a number that is representable as a sum of $d\geq 2$ squares subjected to given congruence conditions is NP-complete. On the other hand, we develop and implement a deterministic polynomial-time algorithm that represents a number as a sum of four squares with some restricted congruence conditions, by assuming a polynomial-time algorithm for factoring integers and Conjecture 1.1. As an application, we develop and implement a deterministic polynomial-time algorithm for navigating Lubotzky, Phillips, Sarnak (LPS) Ramanujan graphs, under the same assumptions.

A POLYNOMIAL-TIME ALGORITHM FOR COMPUTING THE RESILIENCE OF ARRANGEMENTS OF RAY SENSORS

2014 ◽  
Vol 24 (03) ◽  
pp. 225-236 ◽  
Author(s):  
DAVID KIRKPATRICK ◽  
BOTING YANG ◽  
SANDRA ZILLES
Keyword(s):  
Polynomial Time ◽  
Linear Time ◽  
Polynomial Time Algorithm ◽  
Time Algorithm ◽  
The Other ◽  
Np Hard ◽  
Sensor Coverage ◽  
Entire Plane ◽  
Line Segments ◽  
Minimum Number

Given an arrangement A of n sensors and two points s and t in the plane, the barrier resilience of A with respect to s and t is the minimum number of sensors whose removal permits a path from s to t such that the path does not intersect the coverage region of any sensor in A. When the surveillance domain is the entire plane and sensor coverage regions are unit line segments, even with restricted orientations, the problem of determining the barrier resilience is known to be NP-hard. On the other hand, if sensor coverage regions are arbitrary lines, the problem has a trivial linear time solution. In this paper, we study the case where each sensor coverage region is an arbitrary ray, and give an O(n2m) time algorithm for computing the barrier resilience when there are m ⩾ 1 sensor intersections.

scholarly journals POLYNOMIAL-TIME COMPLEXITY FOR INSTANCES OF THE ENDOMORPHISM PROBLEM IN FREE GROUPS

2007 ◽  
Vol 17 (02) ◽  
pp. 289-328 ◽  
Author(s):  
LAURA CIOBANU
Keyword(s):  
Free Group ◽  
Polynomial Time ◽  
Efficient Algorithm ◽  
Time Complexity ◽  
Free Groups ◽  
Polynomial Time Algorithm ◽  
Time Algorithm ◽  
The Other ◽  
Polynomial Time Complexity

We say the endomorphism problem is solvable for an element W in a free group F if it can be decided effectively whether, given U in F, there is an endomorphism ϕ of F sending W to U. This work analyzes an approach due to Edmunds and improved by Sims. Here we prove that the approach provides an efficient algorithm for solving the endomorphism problem when W is a two-generator word. We show that when W is a two-generator word this algorithm solves the problem in time polynomial in the length of U. This result gives a polynomial-time algorithm for solving, in free groups, two-variable equations in which all the variables occur on one side of the equality and all the constants on the other side.

Benchmark of Bitrate Adaptation in Video Streaming

2021 ◽  
Vol 13 (4) ◽  
pp. 1-24
Author(s):  
Jessica Chen ◽  
Henry Milner ◽  
Ion Stoica ◽  
Jibin Zhan
Keyword(s):  
Dynamic Programming ◽  
Polynomial Time ◽  
Computation Time ◽  
Polynomial Time Algorithm ◽  
Time Algorithm ◽  
Perceptual Quality ◽  
Programming Approach ◽  
Np Hard ◽  
Http Adaptive Streaming ◽  
The Future

The HTTP adaptive streaming technique opened the door to cope with the fluctuating network conditions during the streaming process by dynamically adjusting the volume of the future chunks to be downloaded. The bitrate selection in this adjustment inevitably involves the task of predicting the future throughput of a video session, owing to which various heuristic solutions have been explored. The ultimate goal of the present work is to explore the theoretical upper bounds of the QoE that any ABR algorithm can possibly reach, therefore providing an essential step to benchmarking the performance evaluation of ABR algorithms. In our setting, the QoE is defined in terms of a linear combination of the average perceptual quality and the buffering ratio. The optimization problem is proven to be NP-hard when the perceptual quality is defined by chunk size and conditions are given under which the problem becomes polynomially solvable. Enriched by a global lower bound, a pseudo-polynomial time algorithm along the dynamic programming approach is presented. When the minimum buffering is given higher priority over higher perceptual quality, the problem is shown to be also NP-hard, and the above algorithm is simplified and enhanced by a sequence of lower bounds on the completion time of chunk downloading, which, according to our experiment, brings a 36.0% performance improvement in terms of computation time. To handle large amounts of data more efficiently, a polynomial-time algorithm is also introduced to approximate the optimal values when minimum buffering is prioritized. Besides its performance guarantee, this algorithm is shown to reach 99.938% close to the optimal results, while taking only 0.024% of the computation time compared to the exact algorithm in dynamic programming.

Scheduling with Discretely Compressible Processing Times to Minimize Makespan

2014 ◽  
Vol 575 ◽  
pp. 926-930
Author(s):  
Shu Xia Zhang ◽  
Yu Zhong Zhang
Keyword(s):  
Dynamic Programming ◽  
Polynomial Time ◽  
Processing Time ◽  
Parallel Machines ◽  
Polynomial Time Algorithm ◽  
Time Algorithm ◽  
Identical Parallel Machines ◽  
Processing Times ◽  
Release Times ◽  
Scheduling Model

In this paper, we address the scheduling model with discretely compressible processing times, where processing any job with a compressed processing time incurs a corresponding compression cost. We consider the following problem: scheduling with discretely compressible processing times to minimize makespan with the constraint of total compression cost on identical parallel machines. Jobs may have simultaneous release times. We design a pseudo-polynomial time algorithm by approach of dynamic programming and an FPTAS.

scholarly journals Connected Subgraph Defense Games

Algorithmica ◽  
2021 ◽  
Author(s):  
Eleni C. Akrida ◽  
Argyrios Deligkas ◽  
Themistoklis Melissourgos ◽  
Paul G. Spirakis
Keyword(s):  
Polynomial Time ◽  
Nash Equilibria ◽  
Polynomial Time Algorithm ◽  
Time Algorithm ◽  
The Other ◽  
Connected Subgraph ◽  
Expected Number ◽  
Worst Case ◽  
Induced Subgraph ◽  
Other Hand

AbstractWe study a security game over a network played between a defender and kattackers. Every attacker chooses, probabilistically, a node of the network to damage. The defender chooses, probabilistically as well, a connected induced subgraph of the network of $$\lambda $$ λ nodes to scan and clean. Each attacker wishes to maximize the probability of escaping her cleaning by the defender. On the other hand, the goal of the defender is to maximize the expected number of attackers that she catches. This game is a generalization of the model from the seminal paper of Mavronicolas et al. Mavronicolas et al. (in: International symposium on mathematical foundations of computer science, MFCS, pp 717–728, 2006). We are interested in Nash equilibria of this game, as well as in characterizing defense-optimal networks which allow for the best equilibrium defense ratio; this is the ratio of k over the expected number of attackers that the defender catches in equilibrium. We provide a characterization of the Nash equilibria of this game and defense-optimal networks. The equilibrium characterizations allow us to show that even if the attackers are centrally controlled the equilibria of the game remain the same. In addition, we give an algorithm for computing Nash equilibria. Our algorithm requires exponential time in the worst case, but it is polynomial-time for $$\lambda $$ λ constantly close to 1 or n. For the special case of tree-networks, we further refine our characterization which allows us to derive a polynomial-time algorithm for deciding whether a tree is defense-optimal and if this is the case it computes a defense-optimal Nash equilibrium. On the other hand, we prove that it is $${\mathtt {NP}}$$ NP -hard to find a best-defense strategy if the tree is not defense-optimal. We complement this negative result with a polynomial-time constant-approximation algorithm that computes solutions that are close to optimal ones for general graphs. Finally, we provide asymptotically (almost) tight bounds for the Price of Defense for any $$\lambda $$ λ ; this is the worst equilibrium defense ratio over all graphs.

A Polynomial Time Algorithm That Learns Two Hidden Unit Nets

1990 ◽  
Vol 2 (4) ◽  
pp. 510-522 ◽  
Author(s):  
Eric B. Baum
Keyword(s):  
Polynomial Time ◽  
Polynomial Time Algorithm ◽  
Time Algorithm ◽  
The Other ◽  
Output Unit ◽  
Membership Queries ◽  
Linear Threshold ◽  
N Input ◽  
Accuracy Parameter ◽  
Class Of Functions

Let N be the class of functions realizable by feedforward linear threshold nets with n input units, two hidden units each of zero threshold, and an output unit. This class is also essentially equivalent to the class of intersections of two open half spaces that are bounded by planes through the origin. We give an algorithm that probably almost correctly (PAC) learns this class from examples and membership queries. The algorithm runs in time polynomial in n, ∊ (the accuracy parameter), and δ (the confidence parameter). If only examples are allowed, but not membership queries, we give an algorithm that learns N in polynomial time provided that the probability distribution D from which examples are chosen satisfies D(x) = D(−x) ∀x. The algorithm yields a hypothesis net with two hidden units, one linear threshold and the other quadratic threshold.

PROVABLY SECURE KEY-UPDATING SCHEMES IN IDENTITY-BASED SYSTEMS

1991 ◽  
Vol 01 (03) ◽  
pp. 257-272
Author(s):  
SHINJI SHINOZAKI ◽  
ATSUSHI FUJIOKA ◽  
SHIGEO TSUJII ◽  
TOSHIYA ITOH
Keyword(s):  
Polynomial Time ◽  
Polynomial Time Algorithm ◽  
Time Algorithm ◽  
The Other ◽  
Secret Key ◽  
Identity Based ◽  
Provably Secure

In this paper, we present Key-Updating Schemes in identity-based (identification or signature) systems, and consider the security of the schemes. We propose two kinds of key-updating schemes, i.e., one is sequential and the other is parallel, and show that both schemes are equivalent to each other in a polynomial time sense, i.e., there exists a deterministic polynomial time algorithm that transforms the sequential key-updating scheme to the parallel one, and vice versa. We also show that even if any polynomially many entities conspire to find a secret-key of any other entities, both key-updating schemes are provably secure against polynomially many times key-updating if decrypting RSA is hard.

Sign in / Sign up

Export Citation Format

Share Document