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 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.

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.

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.

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 Obtaining a Proportional Allocation by Deleting Items

Algorithmica ◽  
2021 ◽  
Author(s):  
Britta Dorn ◽  
Ronald de Haan ◽  
Ildikó Schlotter
Keyword(s):  
Control Problem ◽  
Polynomial Time ◽  
Polynomial Time Algorithm ◽  
Time Algorithm ◽  
Upper Bounds ◽  
Fair Allocation ◽  
Indivisible Goods ◽  
Lower And Upper Bounds ◽  
Proportional Allocation ◽  
Minimum Number

AbstractWe consider the following control problem on fair allocation of indivisible goods. Given a set I of items and a set of agents, each having strict linear preferences over the items, we ask for a minimum subset of the items whose deletion guarantees the existence of a proportional allocation in the remaining instance; we call this problem Proportionality by Item Deletion (PID). Our main result is a polynomial-time algorithm that solves PID for three agents. By contrast, we prove that PID is computationally intractable when the number of agents is unbounded, even if the number k of item deletions allowed is small—we show that the problem is $${\mathsf {W}}[3]$$ W [ 3 ] -hard with respect to the parameter k. Additionally, we provide some tight lower and upper bounds on the complexity of PID when regarded as a function of |I| and k. Considering the possibilities for approximation, we prove a strong inapproximability result for PID. Finally, we also study a variant of the problem where we are given an allocation $$\pi $$ π in advance as part of the input, and our aim is to delete a minimum number of items such that $$\pi $$ π is proportional in the remainder; this variant turns out to be $${{\mathsf {N}}}{{\mathsf {P}}}$$ N P -hard for six agents, but polynomial-time solvable for two agents, and we show that it is $$\mathsf {W[2]}$$ W [ 2 ] -hard when parameterized by the number k of

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.

scholarly journals On the Max-Min Fair Stochastic Allocation of Indivisible Goods

2020 ◽  
Vol 34 (02) ◽  
pp. 2070-2078
Author(s):  
Yasushi Kawase ◽  
Hanna Sumita
Keyword(s):  
Approximate Solution ◽  
Approximation Algorithm ◽  
Polynomial Time ◽  
Polynomial Time Algorithm ◽  
Time Algorithm ◽  
Np Hard ◽  
Indivisible Goods ◽  
Additive Utility ◽  
Ex Ante ◽  
Stochastic Setting

We study the problem of fairly allocating a set of indivisible goods to risk-neutral agents in a stochastic setting. We propose an (approximation) algorithm to find a stochastic allocation that maximizes the minimum utility among the agents. The algorithm runs by repeatedly finding an (approximate) allocation to maximize the total virtual utility of the agents. This implies that the problem is solvable in polynomial time when the utilities are gross-substitutes (which is a subclass of submodular). When the utilities are submodular, we can find a (1 − 1/e)-approximate solution for the problem and this is best possible unless P=NP. We also extend the problem where a stochastic allocation must satisfy the (ex ante) envy-freeness. Under this condition, we demonstrate that the problem is NP-hard even when every agent has an additive utility with a matroid constraint (which is a subclass of gross-substitutes). Furthermore, we propose a polynomial-time algorithm for the setting with a restriction that the matroid constraint is common to all agents.

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.

scholarly journals Fairness Towards Groups of Agents in the Allocation of Indivisible Items

2019 ◽  
Author(s):  
Nawal Benabbou ◽  
Mithun Chakraborty ◽  
Edith Elkind ◽  
Yair Zick
Keyword(s):  
Social Welfare ◽  
Polynomial Time ◽  
Utility Maximization ◽  
Marginal Utility ◽  
Polynomial Time Algorithm ◽  
Time Algorithm ◽  
Indivisible Goods ◽  
Allocation Of Indivisible Items

In this paper, we study the problem of matching a set of items to a set of agents partitioned into types so as to balance fairness towards the types against overall utility/efficiency. We extend multiple desirable properties of indivisible goods allocation to our model and investigate the possibility and hardness of achieving combinations of these properties, e.g. we prove that maximizing utilitarian social welfare under constraints of typewise envy-freeness up to one item (TEF1) is computationally intractable. We also define a new concept of waste for this setting, show experimentally that augmenting an existing algorithm with a marginal utility maximization heuristic can produce a TEF1 solution with reduced waste, and also provide a polynomial-time algorithm for computing a non-wasteful TEF1 allocation for binary agent-item utilities.

Sign in / Sign up

Export Citation Format

Share Document