SIROCCO 2016 - Daniel Graf

SIROCCO 2016
Collaborative Delivery with
Energy-Constrained Mobile Robots
1
Bärtschi ,
Andreas
Jérémie
Shantanu
Yann
1
1
2
4
Barbara Geissmann , Daniel Graf , Arnaud Labourel , Matúš Mihalák
1
2
3
4
2
Chalopin ,
ETH Zürich
LIF, CNRS et Aix-Marseille Université
Technische Universität Berlin
Maastricht University
2
Das ,
3
Disser
23rd International Colloquium on
Structural Information and
Communication Complexity
19–21 July 2016 · Helsinki, Finland
Introduction
Motivation
Collaborative delivery with mobile agents
Image Sources: BLADE Nano QX RTF Quadcopter, http://paralebin.hol.es/robot/, http://www.generationrobots.com
Introduction
Motivation
Collaborative delivery with mobile agents
Image Sources: BLADE Nano QX RTF Quadcopter, http://paralebin.hol.es/robot/, http://www.generationrobots.com
Introduction
Motivation
Collaborative delivery with mobile agents
Image Sources: BLADE Nano QX RTF Quadcopter, http://paralebin.hol.es/robot/, http://www.generationrobots.com
Introduction
Motivation
Collaborative delivery with mobile agents
Image Sources: BLADE Nano QX RTF Quadcopter, http://paralebin.hol.es/robot/, http://www.generationrobots.com
Introduction
Motivation
Collaborative delivery with mobile agents
Image Sources: BLADE Nano QX RTF Quadcopter, http://paralebin.hol.es/robot/, http://www.generationrobots.com
Introduction
Motivation
Collaborative delivery with mobile agents
Image Sources: BLADE Nano QX RTF Quadcopter, http://paralebin.hol.es/robot/, http://www.generationrobots.com
Introduction
Model
Setting
• undirected, edge-weighted
graph with n=|V|, m=|E|
• single message from s to t
• anyone can use any edge
Agents
• k agents each with
• starting vertex pi
• battery capacity Bi
• agents have to return
Assumptions
• global coordination
• handovers anywhere
Task
Decide feasibility!
If yes, compute a schedule.
Introduction
Example
B1=7
p1
2
1
s
3
t
Introduction
Example
p1
B1=5 2
1
s
3
t
Introduction
Example
p1
B1=5
2
1
s
3
t
Introduction
Example
p1
2
B1=2
1
s
3
t
Introduction
Example
p1
2
1 B =2
1
s
3
t
Introduction
Example
B1=1
p1
2
1
s
3
t
Introduction
Example
B3=8
B1=7
4
3
p1
2
p3
3
1
2
s
3
4
2
1
p2
B2=9
1
2
t
Introduction
Example
B3=8
B1=7
4
3
p1
2
p3
3
1
2
s
3
4
2
1
p2
B2=9
1
2
t
Introduction
Outline
Observations
• No agent picks up the message twice
• Path of an agent specified by two points
u
pi
v
w
Introduction
Outline
Observations
• No agent picks up the message twice
• Path of an agent specified by two points
Overview of the talk
v
u
• For trees?
• For all graphs?
• What can we do with bigger batteries?
pi
w
On Trees
Reduction to Paths
p3
p1
s
p2
.
t
On Trees
Reduction to Paths
Move the agents to the s-t-path and adapt the budgets.
p3
p1
s
p2
.
t
On Trees
Reduction to Paths
Move the agents to the s-t-path and adapt the budgets.
p1
s
p3
.
p2
t
On Trees
Reduction to Paths
Move the agents to the s-t-path and adapt the budgets.
.
s
t
On Trees
Greedy Scheduling
Solving the Path Case
interval covering problem
• length Bi/2 containing pi
s
p1
t
On Trees
Greedy Scheduling
Solving the Path Case
interval covering problem
• length Bi/2 containing pi
• range: from li = pi - Bi/2
to ri = pi + Bi/2
s
p1
t
On Trees
Greedy Scheduling
Solving the Path Case
interval covering problem
• length Bi/2 containing pi
• range: from li = pi - Bi/2
to ri = pi + Bi/2
s
p1 p2
p3
p4
p5
t
On Trees
Greedy Scheduling
Solving the Path Case
interval covering problem
• length Bi/2 containing pi
• range: from li = pi - Bi/2
to ri = pi + Bi/2
s
p1 p2
Greedy Algorithm
• already covered up to s
• pick interval to minimize ri
among all with li ≤ s < ri
• Set s‘ = min(ri, s + Bi/2)
p3
p4
p5
t
On Trees
Greedy Scheduling
Solving the Path Case
interval covering problem
• length Bi/2 containing pi
• range: from li = pi - Bi/2
to ri = pi + Bi/2
s
p1 p2
Greedy Algorithm
• already covered up to s
• pick interval to minimize ri
among all with li ≤ s < ri
• Set s‘ = min(ri, s + Bi/2)
p3
p4
p5
t
On Trees
Greedy Scheduling
Solving the Path Case
interval covering problem
• length Bi/2 containing pi
• range: from li = pi - Bi/2
to ri = pi + Bi/2
p1 p2
s
Greedy Algorithm
• already covered up to s
• pick interval to minimize ri
among all with li ≤ s < ri
• Set s‘ = min(ri, s + Bi/2)
p3
p4
p5
t
On Trees
Greedy Scheduling
Solving the Path Case
interval covering problem
• length Bi/2 containing pi
• range: from li = pi - Bi/2
to ri = pi + Bi/2
p1 p2
s
Greedy Algorithm
• already covered up to s
• pick interval to minimize ri
among all with li ≤ s < ri
• Set s‘ = min(ri, s + Bi/2)
p3
p4
p5
t
On Trees
Greedy Scheduling
Solving the Path Case
interval covering problem
• length Bi/2 containing pi
• range: from li = pi - Bi/2
to ri = pi + Bi/2
p1 p2
s
Greedy Algorithm
• already covered up to s
• pick interval to minimize ri
among all with li ≤ s < ri
• Set s‘ = min(ri, s + Bi/2)
p3
p4
p5
t
On Trees
Greedy Scheduling
Solving the Path Case
interval covering problem
• length Bi/2 containing pi
• range: from li = pi - Bi/2
to ri = pi + Bi/2
p1 p2
Greedy Algorithm
• already covered up to s
• pick interval to minimize ri
among all with li ≤ s < ri
• Set s‘ = min(ri, s + Bi/2)
p3
p4
s
p5
t
On Trees
Greedy Scheduling
Solving the Path Case
interval covering problem
• length Bi/2 containing pi
• range: from li = pi - Bi/2
to ri = pi + Bi/2
p1 p2
Greedy Algorithm
• already covered up to s
• pick interval to minimize ri
among all with li ≤ s < ri
• Set s‘ = min(ri, s + Bi/2)
p3
p4
s
p5
t
On Trees
Greedy Scheduling
Solving the Path Case
interval covering problem
• length Bi/2 containing pi
• range: from li = pi - Bi/2
to ri = pi + Bi/2
p1 p2
Greedy Algorithm
• already covered up to s
• pick interval to minimize ri
among all with li ≤ s < ri
• Set s‘ = min(ri, s + Bi/2)
p3
p4
p5
s t
On Trees
Greedy Scheduling
Solving the Path Case
interval covering problem
• length Bi/2 containing pi
• range: from li = pi - Bi/2
to ri = pi + Bi/2
Greedy Algorithm
• already covered up to s
• pick interval to minimize ri
among all with li ≤ s < ri
• Set s‘ = min(ri, s + Bi/2)
Proof: exchange argument
p1 p2
p3
p4
p5
s t
On Trees
Greedy Scheduling
Theorem: There is a O(n·k + k·logk) algorithm for trees.
.
s
Surprising as non-returning setting is weakly NP-hard.
[Chalopin, Jacob, Mihalák, Widmayer, 2014]
Chalopin, Jacob, Mihalák, Widmayer: Data delivery by energy-constrained mobile agnets on a line, ICALP 2014.
t
Arbitrary Graphs
Fixed Order
Theorem: If agents are restricted to carry the message in a
fixed order, we can decide in time O(k(n+m)(n·logn + m)).
Proof: Dynamic Programming with Dijkstra‘s SSSP
p1
s
p2
p3
t
Arbitrary Graphs
Fixed Order
Theorem: If agents are restricted to carry the message in a
fixed order, we can decide in time O(k(n+m)(n·logn + m)).
Proof: Dynamic Programming with Dijkstra‘s SSSP
p1
s
p2
p3
t
Arbitrary Graphs
Fixed Order
Theorem: If agents are restricted to carry the message in a
fixed order, we can decide in time O(k(n+m)(n·logn + m)).
Proof: Dynamic Programming with Dijkstra‘s SSSP
p1
s
p2
p3
t
Arbitrary Graphs
Fixed Order
Theorem: If agents are restricted to carry the message in a
fixed order, we can decide in time O(k(n+m)(n·logn + m)).
Proof: Dynamic Programming with Dijkstra‘s SSSP
p1
s
p2
p3
t
Arbitrary Graphs
Fixed Order
Theorem: If agents are restricted to carry the message in a
fixed order, we can decide in time O(k(n+m)(n·logn + m)).
Proof: Dynamic Programming with Dijkstra‘s SSSP
p1
s
p2
p3
t
Arbitrary Graphs
Fixed Order
Theorem: If agents are restricted to carry the message in a
fixed order, we can decide in time O(k(n+m)(n·logn + m)).
Proof: Dynamic Programming with Dijkstra‘s SSSP
p1
s
p2
p3
t
Arbitrary Graphs
Fixed Order
Theorem: If agents are restricted to carry the message in a
fixed order, we can decide in time O(k(n+m)(n·logn + m)).
Proof: Dynamic Programming with Dijkstra‘s SSSP
p1
s
p2
p3
t
Arbitrary Graphs
Fixed Order
Theorem: If agents are restricted to carry the message in a
fixed order, we can decide in time O(k(n+m)(n·logn + m)).
Proof: Dynamic Programming with Dijkstra‘s SSSP
Arbitrary Graphs
Fixed Order
Theorem: If agents are restricted to carry the message in a
fixed order, we can decide in time O(k(n+m)(n·logn + m)).
Proof: Dynamic Programming with Dijkstra‘s SSSP
Corollary: For constantly many agents, we can do it in
poly(n,m) by brute forcing the order of the agents.
Arbitrary Graphs
Fixed Order
Theorem: If agents are restricted to carry the message in a
fixed order, we can decide in time O(k(n+m)(n·logn + m)).
Proof: Dynamic Programming with Dijkstra‘s SSSP
Corollary: For constantly many agents, we can do it in
poly(n,m) by brute forcing the order of the agents.
Question: What about many agents?
Arbitrary Graphs
NP-hardness
Theorem: Our problem is strongly NP-hard even on
planar graphs.
Proof Sketch: Reduction from Planar-3SAT.
Arbitrary Graphs
NP-hardness
Proof Sketch: Reduction from Planar-3SAT.
Arbitrary Graphs
NP-hardness
Proof Sketch: Reduction from Planar-3SAT.
v1
v2
v3
v4
Arbitrary Graphs
NP-hardness
Proof Sketch: Reduction from Planar-3SAT.
v1 ∨ v2
v1
v2 ∨ v3 ∨ v4
v2
v1 ∨ v2 ∨ v4
v3
v2 ∨ v3 ∨ v4
v4
v4
Arbitrary Graphs
NP-hardness
Proof Sketch: Reduction from Planar-3SAT.
v1 ∨ v2
vs1
v2 ∨ v3 ∨ v4
v2
v1 ∨ v2 ∨ v4
v3
v2 ∨ v3 ∨ v4
v4
v4
t
Arbitrary Graphs
NP-hardness
Proof Sketch: Reduction from Planar-3SAT.
v1 ∨ v2
vs1
v2 ∨ v3 ∨ v4
v2
v1 ∨ v2 ∨ v4
v3
v2 ∨ v3 ∨ v4
v4
v4
t
decide
assignment
Arbitrary Graphs
NP-hardness
Proof Sketch: Reduction from Planar-3SAT.
v1 ∨ v2
vs1
v2 ∨ v3 ∨ v4
v2
v1 ∨ v2 ∨ v4
v3
v2 ∨ v3 ∨ v4
v4
v4
cover for
unsatisfied
literals
t
decide
assignment
Arbitrary Graphs
NP-hardness
Proof Sketch: Reduction from Planar-3SAT.
v1 ∨ v2
vs1
v1
v1
v1 ∨ v2 ∨ v4
v2 ∨ v3 ∨ v4
v2
v2
v2
v3
v4
v3
v3
v2 ∨ v3 ∨ v4
v4
v4
v4
t
Arbitrary Graphs
NP-hardness
Proof Sketch: Reduction from Planar-3SAT.
v1 ∨ v2
vs1
v1
v1
v1 ∨ v2 ∨ v4
v2 ∨ v3 ∨ v4
v2
v2
v2
v3
v4
v3
v3
v2 ∨ v3 ∨ v4
v4
v4
v4
t
Arbitrary Graphs
NP-hardness
Proof Sketch: Reduction from Planar-3SAT.
v1 ∨ v2
vs1
v1
v1
v1 ∨ v2 ∨ v4
v2 ∨ v3 ∨ v4
v2
v2
v2
v3
v3
v3
v2 ∨ v3 ∨ v4
v4
v4
v4
t
Arbitrary Graphs
NP-hardness
Proof Sketch: Reduction from Planar-3SAT.
v1 ∨ v2
vs1
v1
v1
v1 ∨ v2 ∨ v4
v2 ∨ v3 ∨ v4
v2
v2
v2
v3
v3
v3
v2 ∨ v3 ∨ v4
v4
v4
v4
t
Arbitrary Graphs
NP-hardness
Proof Sketch: Reduction from Planar-3SAT.
v1 ∨ v2
vs1
v1
v1
v1 ∨ v2 ∨ v4
v2 ∨ v3 ∨ v4
v2
v2
v2
v3
v3
v3
v2 ∨ v3 ∨ v4
v4
v4
v4
t
Arbitrary Graphs
NP-hardness
Proof Sketch: Reduction from Planar-3SAT.
v1 ∨ v2
vs1
v1
v1
v1 ∨ v2 ∨ v4
v2 ∨ v3 ∨ v4
v2
v2
v2
v3
v3
v3
v2 ∨ v3 ∨ v4
v4
v4
v4
t
Arbitrary Graphs
NP-hardness
Proof Sketch: Reduction from Planar-3SAT.
vs1
v1
v1
v2
v2
v2
v3
v3
v3
v4
v4
v4
t
Arbitrary Graphs
NP-hardness
Proof Sketch: Reduction from Planar-3SAT.
vs1
v1
v1
v2
v2
v2
v3
v3
v3
v4
v4
v4
t
Resource Augmentation
Definition
Resource Augmentation
Definition
What is a 2-resource-augmented algorithm?
Resource Augmentation
Definition
What is a 2-resource-augmented algorithm?
Given:
s
t
Resource Augmentation
Definition
What is a 2-resource-augmented algorithm?
Given:
s
Algorithm:
t
s
t
Resource Augmentation
Definition
What is a 2-resource-augmented algorithm?
Given:
Algorithm:
s
t
s
t
s
t
Resource Augmentation
Definition
What is a 2-resource-augmented algorithm?
Given:
Algorithm:
s
t
s
s
t
s
t
?
t
Resource Augmentation
B3=8
B1=7
4
p3
3
1
2
s
3
4
3
p1
2
Example
2
1
p2
B2=9
1
2
t
Resource Augmentation
B3=16
B1=14
4
p3
3
1
2
s
3
4
3
p1
2
Example
2
1
p2
B2=18
1
2
t
Resource Augmentation
Factor 2
Theorem: We can do it if we are allowed to use at
most twice the battery power necessary.
Resource Augmentation
Factor 2
Theorem: We can do it if we are allowed to use at
most twice the battery power necessary.
Proof Sketch: Balls of radius Bi/2.
Resource Augmentation
Factor 2
Theorem: We can do it if we are allowed to use at
most twice the battery power necessary.
Proof Sketch: Balls of radius Bi/2.
p2
s
p1
p3
t
Resource Augmentation
Factor 2
Theorem: We can do it if we are allowed to use at
most twice the battery power necessary.
Proof Sketch: Balls of radius Bi/2.
p2
s
p1
p3
t
Resource Augmentation
Factor 2
Theorem: We can do it if we are allowed to use at
most twice the battery power necessary.
Proof Sketch: Balls of radius Bi/2.
B1/2
s
p1
p2
p3
t
Resource Augmentation
Factor 2
Theorem: We can do it if we are allowed to use at
most twice the battery power necessary.
Proof Sketch: Balls of radius Bi/2.
p2
s
p1
p3
t
Resource Augmentation
Factor 2
Theorem: We can do it if we are allowed to use at
most twice the battery power necessary.
Proof Sketch: Balls of radius Bi/2.
p2
s
p1
p3
t
Resource Augmentation
Factor 2
Theorem: We can do it if we are allowed to use at
most twice the battery power necessary.
Proof Sketch: Balls of radius Bi/2.
p2
s
p1
p3
t
Resource Augmentation
Hardness
Theorem: Unless P=NP, there is no polynomial-time
(2-ε)-resource augmented algorithm.
Resource Augmentation
Hardness
Theorem: Unless P=NP, there is no polynomial-time
(2-ε)-resource augmented algorithm.
Proof Sketch:
vs1
v1
v1
v2
v2
v2
v3
v3
v3
v4
v4
v4
t
Resource Augmentation
Hardness
Theorem: Unless P=NP, there is no polynomial-time
(2-ε)-resource augmented algorithm.
...
Proof Sketch:
vs1
v1
v1
v2
v2
v2
v3
v3
v3
v4
v4
v4
t
...
Resource Augmentation
Hardness
Theorem: Unless P=NP, there is no polynomial-time
(2-ε)-resource augmented algorithm.
...
Proof Sketch:
vs1
v1
v1
v2
v2
v2
v3
v3
v3
v4
v4
v4
t
...
Resource Augmentation
Hardness
Theorem: Unless P=NP, there is no polynomial-time
(2-ε)-resource augmented algorithm.
...
Proof Sketch:
vs1
v1
v1
v2
v2
v2
v3
v3
v3
v4
v4
v4
t
...
Resource Augmentation
Equality
Theorem: If all agents have equal budget, there is an
(2-2/k)-resource augmented polynomial-time algorithm.
Resource Augmentation
Equality
Theorem: If all agents have equal budget, there is an
(2-2/k)-resource augmented polynomial-time algorithm.
Proof Sketch: Guess first and last agent.
Redistribute remaining budget evenly.
s
t
Resource Augmentation
Equality
Theorem: If all agents have equal budget, there is an
(2-2/k)-resource augmented polynomial-time algorithm.
Proof Sketch: Guess first and last agent.
Redistribute remaining budget evenly.
s
t
Resource Augmentation
Equality
Theorem: If all agents have equal budget, there is an
(2-2/k)-resource augmented polynomial-time algorithm.
Proof Sketch: Guess first and last agent.
Redistribute remaining budget evenly.
s
t
Resource Augmentation
Equality
Theorem: If all agents have equal budget, there is an
(2-2/k)-resource augmented polynomial-time algorithm.
Proof Sketch: Guess first and last agent.
Redistribute remaining budget evenly.
s
t
Resource Augmentation
Equality
Theorem: If all agents have equal budget, there is an
(2-2/k)-resource augmented polynomial-time algorithm.
Proof Sketch: Guess first and last agent.
Redistribute remaining budget evenly.
s
t
Resource Augmentation
Equality
Theorem: If all agents have equal budget, there is an
(2-2/k)-resource augmented polynomial-time algorithm.
Proof Sketch: Guess first and last agent.
Redistribute remaining budget evenly.
s
t
Resource Augmentation
Equality
Theorem: If all agents have equal budget, there is an
(2-2/k)-resource augmented polynomial-time algorithm.
Proof Sketch: Guess first and last agent.
Redistribute remaining budget evenly.
s
t
Resource Augmentation
Equality
Theorem: If all agents have equal budget, there is an
(2-2/k)-resource augmented polynomial-time algorithm.
Proof Sketch: Guess first and last agent.
Redistribute remaining budget evenly.
s
t
Resource Augmentation
Equality
Theorem: If all agents have equal budget, there is an
(2-2/k)-resource augmented polynomial-time algorithm.
Proof Sketch: Guess first and last agent.
Redistribute remaining budget evenly.
s
t
Resource Augmentation
Equality
Theorem: If all agents have equal budget, there is an
(2-2/k)-resource augmented polynomial-time algorithm.
Proof Sketch: Guess first and last agent.
Redistribute remaining budget evenly.
s
t
Conclusion
Summary
Contributions
• fast, greedy algorithm
for paths and trees
• strong NP-hardness
for planar graphs
• 2-resource-augmentation
algorithm and it is tight
• more for non-returning case
Future Work
• multiple messages
• on a line, or
• with fixed agent order
Thank you!