4 views

Uploaded by aiace00

- Big Oh
- Analysis of Algorithms I
- Cap.8 EvaTardos
- 6-3
- Algo Mod5 Recurrences
- programming in engineering
- openqc
- lec1
- 1. Comparison of Algorithms
- Applied Data Structures Chapter 1 Algorithm
- Algorithm Complexity lalit bansal
- Fundamentals of Algorithms-2
- np1
- The Theory of Computation
- CS.7.Performance
- Experiments
- Vasudevan10 Nd Ton Tr
- slides9-8
- Word Game Lab
- Data Structures and Algorithms MCQ -2

You are on page 1of 19

• A new part of the course – will cover the more • Formal Definition:

theoretical aspects required in later lectures – A graph G is a finite nonempty set V together with an

[irreflexive], symmetric relation E on V

– Graphs, cliques, and colouring

• The relation E relates vertices to other vertices and is known

– Algorithms and intractability as the edge relation, or “edge set”

– Linear programming and integer linear programming • If relation E is symmetric, it means that

– Shortest and longest path algorithms • (a,b)∈E ⇒ (b,a)∈E

• This lecture covers • an edge has no concept of “direction”

• In mathematics, an edge relation is usually considered

– Definition of graph (revision), clique, and clique number

irreflexive:

– Graph colouring, chromatic number • ¬∃a : (a,a)∈E

– Interval graphs – engineers often relax this constraint (hence the brackets)

• Formal definition: • A complete graph is a special type of graph where

all possible edges are in the edge set

– A directed graph G is a finite nonempty set V

together with an [irreflexive] relation E on V

– This time the concept of direction is implicit, as K3

K1 K2

we could have (a,b)∈E and (b,a)∉E

• A subgraph G’(V’,E’) of a graph G(V,E) is a graph

• You may see directed graphs referred to as whose vertex and edge sets obey

“digraphs” • V’ ⊆ V, E’ ⊆ E

v1 v2 v4

v2 v4

v3 G(V,E) G’(V’,E’)

1/15/2007 Lecture5 gac1 3 1/15/2007 Lecture5 gac1 4

Cliques Clique Number

• A clique is a complete subgraph • The clique number ω(G) of a graph G is the size of

the node set of its largest clique

v1 v2 v4

v1 v2 v4

v2 v4

v3 G(V,E) G’(V’,E’)

v3 G(V,E)

v2 v4

• This graph has cliques with the following node

v3 G’’(V,E) subsets:

– {v1}, {v2}, {v3}, {v4}, {v1,v2}, {v1,v3}, {v2,v3}, {v2,v4},

• G’ is a clique. G’’ is not a clique (but it is a {v1,v2,v3}

subgraph of G) • Its clique number is 3

1/15/2007 Lecture5 gac1 5 1/15/2007 Lecture5 gac1 6

• Graph colouring is the process of labelling each • A simple algorithm for colouring a graph is given below

node of a graph such that no two connected nodes Colour_Graph( G(V,E) )

share the same label begin

foreach v ∈ V {

v1 v2 v4 c = 1;

while ∃(v,v’) ∈ E : v’ has colour c

v3 G(V,E) c = c + 1;

label v with colour c }

• The graph above is coloured with three different end

colours

• This will always correctly colour a graph, but the number of

• Graph colouring can model many problems distinct colours used depends on the order in which the

• e.g. colouring a conflict graph (Lecture 2) will nodes are visited

result in a resource binding

1/15/2007 Lecture5 gac1 7 1/15/2007 Lecture5 gac1 8

Chromatic Number Interval Graphs

• The smallest number of colours with which it is possible to • Luckily, not all graphs are “hard” to colour. One type of

colour a graph G is called its chromatic number χ(G) graph which is easy to colour with the minimum number of

colours is an “interval graph”

• For a general graph, finding χ(G) is a “hard” problem

• An interval graph is a graph whose vertices can be put in

– the algorithm presented does not guarantee a colouring one-to-one correspondence with a set of intervals, such that

with χ(G) colours two vertices are connected by an edge iff the corresponding

– we’ll be discussing “hard” problems next lecture intervals intersect

• In resource binding, the chromatic number tells us the v1 v2

minimum number of distinct resources required v1 v2

v1 v2 v3??

• Since every node in a clique must be coloured differently to

every other node in a clique, v3 v2 v4 v3 v1

v4

• ω(G) ≤ χ(G) v3

An interval graph NOT an interval graph

1/15/2007 Lecture5 gac1 9 1/15/2007 Lecture5 gac1 10

• The left-edge algorithm colours interval graphs optimally.

• Some set theory:

• Let us denote by li and ri the left-most and right-most point of

the interval corresponding to vertex vi. – \ represents set subtraction

Left_Edge( G(V,E) ) • X \ Y = { z : z∈X ∧ z∉Y }

begin • The left edge algorithm tries to colour as many

sort nodes in ascending order of left edge – store in L

c := 1; intervals as possible with one colour, before moving

while( not all vertices have been coloured ) { on the the next colour

r := 0;

while( ∃ an element s in L with ls > r ) { • Left Edge was originally introduced to pack wire

vs := first node in L with ls > r; segments tightly on a VLSI layout. It is now used

r: = rs;

label vs with colour c for many other purposes – particularly resource

L := L \ {vs}; } binding.

c := c + 1; }

end

1/15/2007 Lecture5 gac1 11 1/15/2007 Lecture5 gac1 12

Left Edge - Example Left Edge - Example

v1 v1 v6

v1 v2 v3 c=1

v6

v1 v6 v6 v7 v5 c=2

v7 v4 v3

v4

v4 c=3

v7 v4 v3 v7

v2 v5

v2

v2 v5 coloured graph intervals packed into colours

v3 1↔

v5 2↔

3↔

interval graph interval list L

• This lecture has covered • For the graph below, apply the general colouring algorithm

for the following two vertex orders. Compare and contrast

– graphs and digraphs your results. (*)

– cliques and clique number – (a) (v1, v2, v3, v4)

– colouring and chromatic number – (b) (v1, v4, v3, v2)

– interval graphs and the Left Edge algorithm • By applying the left-edge algorithm, or otherwise,

demonstrate that one of the two orders above results in an

• Next lecture will examine the ideas behind optimum colouring (*)

designing “good” algorithms, and what it v1 v2

means for a problem to be “hard”

v3 v4

1/15/2007 Lecture5 gac1 15 1/15/2007 Lecture5 gac1 16

Algorithms and Intractability The Purpose of This Lecture

• Part of our 4-lecture “theory break” • Synthesis is all about writing algorithms to solve

– Graphs, cliques, and colouring problems in digital design

– Algorithms and intractability • This lecture will consider some of the more

– Linear programming and integer linear programming theoretical aspects concerning

– Shortest and longest path algorithms – problems, algorithms, and complexity

• We will formalize what is meant by a “hard”

• This lecture covers

problem

– The definition of an “algorithm”

• You will not be required to prove the hardness of

– Polynomial-time and intractability

any unseen problems as part of this course

– P and NP

• You may be required to describe the ideas of

– Polynomial reduction, NP-completeness and NP- hardness

hardness

1/15/2007 Lecture6 gac1 1 1/15/2007 Lecture6 gac1 2

• We have already discussed several problems and

algorithms. We will now take a few minutes to formalize

these concepts

• A problem is a general question to be answered, usually

possessing several parameters, whose values are left

unspecified

– e.g. Can I schedule a DFG G(V,E) to complete within λ

cycles using at most n multipliers?

• An instance of a problem is obtained by specifying particular

values for all parameters

– e.g. Can I schedule the DFG given in Lecture 1, slide 5,

to complete within 10 cycles using at most 2 multipliers?

[Garey & Johnson 1979]

1/15/2007 Lecture6 gac1 3 1/15/2007 Lecture6 gac1 4

“Hard” Problems “Hard” Problems

1/15/2007 Lecture6 gac1 5 1/15/2007 Lecture6 gac1 6

• An algorithm is a general step-by-step procedure • Usually, we can describe the worst-case

for solving problems performance of an algorithm as a function of the

“size” n of the problem instance

• An algorithm is said to solve a problem Π if the

algorithm can be applied to any instance of Π and • We generally are concerned with the “big picture” of

how performance scales with size (especially for

is guaranteed to always produce a solution for that large sizes), rather than specific execution times

instance

• The Big-Oh notation allows us to express this

• An efficient algorithm is one that solves the problem behaviour

“quickly” – O(n), O(n2), O(en)

– there are other factors such as memory usage, but we • An algorithm is O( f(n) ) if its worst case

will ignore these performance is bounded by k f(n) for large n

Complexity Polynomial vs Exponential Time

• Example: A (good) algorithm to add n • A polynomial-time algorithm is one which has

O( p(n) ) for some polynomial p(⋅).

numbers will be O(n)

• An exponential-time algorithm is any algorithm

• Example: An algorithm to sort n numbers in which is not polynomial-time.

order. You may be familiar with • Clearly for large n, exponential-time algorithms take

– quicksort: O(n2) much longer than polynomial-time algorithms

– the main distinction is thus: “is this algorithm exponential

– heapsort: O(n log n) (bad) or polynomial (good)?”

• Example: An algorithm which considers all – the order of the polynomial is of secondary concern

possible k-colourings that a graph could have • All problems which can be solved by polynomial

would be O(kn) algorithms are said to belong to the class P

• To complicate matters, computer scientists have • The problem “does P = NP?” is unsolved

come up with another class, NP (nondeterministic

polynomial). • If you solve it you will

• A problem is in NP if a solution to the problem can – be famous

be checked in polynomial time – win $2,000,000 from www.claymath.org

– this doesn’t mean it has to be solvable in polynomial time

• …but don’t let it distract you from your

• Example:

– scheduling G(V,E) in time λ given resource constraints degree!

may or may not be solvable in polynomial time

– it is clear that given a schedule, we could check in

polynomial time that it is a valid schedule and it

completes within λ cycles

1/15/2007 Lecture6 gac1 11 1/15/2007 Lecture6 gac1 12

Polynomial Reduction NP-completeness & NP-hardness

• Many interesting and difficult problems (like • There are some problems which are in NP and

scheduling) are in NP but we don’t know whether which are known to be at least as hard as any other

they’re in P problem in NP.

• Since it is generally hard to prove that a given – these are called NP-complete

problem is not in P, we instead concentrate on

proving that its “at least as hard” as a known hard • NP-complete problems are of particular interest, as

problem if a solution to any NP-complete problem can be

• If we can transform any instance of a hard problem found in polynomial time then P = NP

ΠH into an instance of our problem Π, and that • A problem which is at least as hard as an NP-

transformation can be done in polynomial time, complete problem is called NP-hard

then – this is our formal definition: for “hard problem” read “NP-

– if we can solve Π, we can solve ΠH ⇒ Π is also hard! hard problem”

1/15/2007 Lecture6 gac1 13 1/15/2007 Lecture6 gac1 14

• Assuming P ≠ NP, this is how our “world of • Proving NP-hardness requires two stages

problems” looks – pick a known NP-hard problem

– demonstrate a transformation from this problem to your

problem

NP NP-hard • There are some NP-complete problems which form the

basis of many proofs. We will look at one: Partition

NP- • Partition: Given a finite set A and a measure s(a) ∈ Z+ for

complete each a ∈ A, is there a subset A’ ⊆ A such that the following

P equation holds?

∑ s(a) = ∑ s(a)

a∈ A ' a∈ A− A '

1/15/2007 Lecture6 gac1 15 1/15/2007 Lecture6 gac1 16

Proving Hardness Example: Scheduling is NP-hard

• An example instance of “partition”: • To finish off, we’ll prove the NP-hardness of an

example problem (a simple form of scheduling)

– A = {v1, v2, v3} with s(v1) = 1, s(v2) = 2, • Our simple scheduling problem has no data

s(v3) = 1 dependencies and only one type of operation

– for this instance, the answer is clearly “yes”:

• A’ = {v2} or A’ = {v1, v3} • Remember that you won’t be asked to do such a

proof for an unseen problem, but this proof has

been included

– for completeness

– to give a more “practical” end to a highly theoretical

lecture

– to justify past and future comments about scheduling

being a “hard” task to perform

1/15/2007 Lecture6 gac1 17 1/15/2007 Lecture6 gac1 18

• Let’s start by defining our problem: • Let us rephrase the question:

– given a finite set A of operations, a latency – is there a partition A = A1 ∪ A2 ∪ … ∪ Am of A

d(a) ∈ Z+ for each a ∈ A, a number m ∈ Z+ of into m disjoint subsets such that

resources, and a deadline λ ∈ Z+

⎧ ⎫

– is there a schedule such that all operations max ⎨ ∑ d (a )⎬ ≤ λ

1≤i ≤ m

complete within the deadline and no more than ⎩a∈Ai ⎭

m resources are used?

– Ai represents the set of operations assigned to

processor i, and no two operations can be

executed at the same time on a single resource

Scheduling is NP-hard Scheduling is NP-hard

• Let’s consider a special case of our problem, for • Rewriting, we require

m=2 and 1

λ= ∑ d (a)

2 a∈A

1 ⎧ ⎫

max ⎨ ∑ d (a ) − ∑ d (a ), ∑ d (a ) − ∑ d (a )⎬ ≤ 0

• Then the problem reduces to: 2 ⎩a∈A' a∈ A− A ' a∈ A− A ' a∈ A ' ⎭

– given a finite set A, and a value d(a) ∈ Z+ for each a ∈ A

• But for any k, max(k,-k) ≤ 0 ⇒ k = 0, so we require

– is there a partition into 2 disjoint subsets A’ and A – A’

such that

⎧ ⎫ 1

∑ d (a) = ∑ d (a)

max ⎨ ∑ d (a ), ∑ d (a )⎬ ≤ ∑ d (a )

a∈ A ' a∈ A− A '

⎩a∈A' a∈ A− A ' ⎭ 2 a∈A • But this is the “partition” problem. So “partition” is a special

case of our problem and hence our problem is NP-hard

1/15/2007 Lecture6 gac1 21 1/15/2007 Lecture6 gac1 22

Summary

• This lecture has covered

– The definition of an “algorithm”

– Polynomial-time and intractability

– P and NP

– Polynomial reduction, NP-completeness and NP-

hardness

• Next lecture we will look at the (NP-hard!) problem

of Integer Linear Programming (ILP) and how we

can use ILP solving software to help us optimize

our hardware

1/15/2007 Lecture6 gac1 23

[Integer] Linear Programming Mathematical Programming

• Part of our 4-lecture “theory break” • Mathematical “programming” is the name given to

– Graphs, cliques, and colouring

the branch of mathematics that considers the

following optimization problem:

– Algorithms and intractability

– Linear programming and integer linear programming max f ( x), x ∈ S ⊆ R n

– Shortest and longest path algorithms

• Here Rn represents the set of n-dimensional

• This lecture covers

vectors of real numbers, and f is a real-valued

– Mathematical programming, integer / mixed-integer function defined on S. S is the constraint set and f

programming, and linear programming is the objective function.

– Slack variables

• By choosing f and S appropriately, we can model a

– Application example: Capital budgeting wide variety of real-life problems in this way.

• Any x ∈ S is called a feasible solution • An integer programming problem is one where S is

restricted to have only integer values

• If the there is an xo ∈ S such that

f(x) ≤ f(xo) for all x ∈ S S ⊆ Z n ⊆ Rn

then xo is called an optimal solution • A mixed integer programming problem is one where some

elements of S are restricted to integers

• Integer programming problems are typically harder than the

• The aim is to find an optimal solution for a given f equivalent real problem. You can gain an intuition why by

and S considering the following problems

– find the value of x minimizing cos(x/5)

• 5π

– find the integer value of x minimizing cos(x/5)

• round( 5π ) ? round ( 5π + 10π ) ? …

1/15/2007 Lecture7 gac1 3 1/15/2007 Lecture7 gac1 4

Linear Programming Why Are We Interested?

• Problems where f and S are restricted to linear form • We are interested in expressing problems as

are of particular interest integer or mixed integer linear programs because

f(x) = cTx, S = { x | Ax = b, x ≥ 0 } – it provides a way to formalize the problem

– c is an n x 1 vector, A is an m x n matrix and b is an – we can apply known general techniques to solve

m x 1 vector

the problem

• Imposing the linearity constraints restricts the

– lots of software exists to solve MILPs (e.g.

domain of problems, but allows us to use known

lp_solve, available free from the web)

solution techniques

• For general x, these problems can be solved

exactly (e.g. Simplex technique). For integer x, the – I will be introducing ILP formulations for

problem is NP-complete. scheduling and resource binding in later lectures

1/15/2007 Lecture7 gac1 5 1/15/2007 Lecture7 gac1 6

• At first glance, linear constraints may seem very • Inequality constraints can easily be introduced by adding an

restrictive – this is not necessarily the case, if you extra variable

build your model carefully. • For example, consider the program:

• Here are three types of constraint that could be max 2x1 + 3x2 subject to x1 + x2 ≤ 10

useful in synthesis This is the same as

– inequalities (e.g. x1 + x2 ≤ b1, rather than x1 + x2 = b1) max 2x1 + 3x2 subject to x1 + x2 + x3 = 10

– dichotomy (e.g. x1 + x2 ≤ b1 OR x3 + x4 ≤ b2) • For “≥”, we would insert (-x3) into the constraint

– conditionals (e.g. x1 + x2 ≤ b1 ⇒ x3 + x4 ≤ b2) • The extra variable is called a slack variable – it does not

appear in the objective function

• We will only be considering the first in this brief • Because this is so straight-forward, many ILP solving

introduction. If you wish to use the others, programs allow you to express constraints with inequality

– R.S. Garfinkel and G.L. Nemhauser, “Integer directly. From now on, we will use inequalities freely without

Programming”, Wiley and Sons, 1972 considering slack variables explicitly

1/15/2007 Lecture7 gac1 7 1/15/2007 Lecture7 gac1 8

Example: Capital Budgeting Example: Capital Budgeting

• From Garfinkel and Nemhauser (1972): • Let’s introduce a set of variables xj, which we

– A firm has n projects that it would like to interpret as:

undertake, but due to budget limitations, not all – xj = 1 ⇒ project j is selected

can be selected. In particular, project j has a – xj = 0 ⇒ project j is not selected

value of cj, and requires an investment of aij in • Then the objective function can be formulated as

the time period i, i =1,…,m. The capital available n

in time period i is bi. ∑c x

j =1

j j

– Problem: Maximize the total value, subject to

budget constraints • The constraints are

n

∑a x

j =1

ij j ≤ bi , i = 1,..., m; x j ≤ 1, j = 1,..., n

1/15/2007 Lecture7 gac1 9 1/15/2007 Lecture7 gac1 10

Summary

• This lecture has covered

– Mathematical programming, integer / mixed-

integer programming, and linear programming

– Slack variables

– Application example: Capital budgeting

• Next lecture (the last in our “theory break”),

looks at finding the shortest and longest path

through a graph

Path Problems and Algorithms Edge Weighted Graphs

• Part of our 4-lecture “theory break” • An edge-weighted graph is a graph G(V,E) together

– Graphs, cliques, and colouring with a weighting function w: E → R

– Algorithms and intractability • We can represent this graphically by annotating

– Linear programming and integer linear programming each edge e ∈ E with its weight w(e)

– Shortest and longest path algorithms

0 0

• This lecture covers 0 v1

0 3 1

– Edge-weighted graphs, shortest and longest path 1 2 3

-1 1

problems 2 1 2 v0 -6 v3

4 5

– Longest path through a DAG

2 1 1 4

– Longest path through a general graph: Liao-Wong 6 v2

– Longest path as a LP An edge weighted DAG An edge-weighted graph with cycles

1/15/2007 Lecture8 gac1 1 1/15/2007 Lecture8 gac1 2

• A path through a graph is an alternating sequence • The longest path problem is to find a path of

of vertices and edges maximum total weight between a given “source”

vertex and any other vertex in the graph

v1

3 1 – the shortest path problem is defined similarly

-1 1 – we will consider only longest path problems – shortest

v0 -6 v3 path can then be achieved by inverting all weights

1 4 w’(e) = – w(e)

v2

• Bellman’s equations define the total weight of any

• A path between vertices v0 and v3, with total edge vertex v

weight 3+1 = 4 has been highlighted sv = max ( su + w(u , v))

( u ,v )∈E

1/15/2007 Lecture8 gac1 3 1/15/2007 Lecture8 gac1 4

Longest Path Through a DAG DAG Algorithm

• The longest path through a DAG is an easier problem than • Below is one possible algorithm (apologies to the recursion-

the equivalent for a general graph phobics)

• This is because we can find an order of nodes to visit such Algorithm DAG_Longest_Path( G(V,E), source )

that the right-hand side of each Bellman’s equation is known Set ssource = 0;

• For our example DAG, let’s choose vertex 0 as our source. foreach v ∈ V

Find_DAG_Path( G(V,E), v );

Then s0 = 0. If we now proceed to apply Bellman’s end DAG_Longest_Path

equations in the order (s1, s2, s3, s4, s5, s6), we can

determine the total weight for each node Algorithm Find_DAG_Path( G(V,E), v )

– s1 = 0, s2 = 0, s3 = 0, s4 = 2, s5 = 2, s6 = 4 if already know sv

return;

• Note that this would not work with an arbitrary order. We else

must calculate sv before su for all (v,u) ∈ E foreach (u,v) ∈ E

• For a graph with cycles, it is not possible to find such an Find_DAG_Path( G(V,E), u )

order Apply Bellman’s equation to find sv

end Find_DAG_Path

1/15/2007 Lecture8 gac1 5 1/15/2007 Lecture8 gac1 6

0 0

DAG example DAG Example

0 0 2. Find_DAG_Path( G(V,E), 1 )

• Let’s assume the vertices are stored in V

1 2 3 in an arbitrary order – say (4,1,2,3,5,0,6) 3. Find_DAG_Path( G(V,E), 2 )

1 2 4. Find_DAG_Path( G(V,E), 3 )

2

4 • A call to DAG_Longest_Path( G(V,E), 0 )

5

will set s0 = 0, and then follow the following 1. Find_DAG_Path( G(V,E), 0)

2 1 execution profile 2. Calculate s3 = 0

6

5. Find_DAG_Path( G(V,E), 5 )

1. Find_DAG_Path( G(V,E), 4 ) 1. Find_DAG_Path( G(V,E), 3)

1. Find_DAG_Path( G(V,E), 1 ) 2. Calculate s5 = 2

1. Find_DAG_Path( G(V,E), 0 ) 6. Find_DAG_Path( G(V,E), 0 )

2. Calculate s1 = 0 7. Find_DAG_Path( G(V,E), 6 )

2. Find_DAG_Path( G(V,E), 2 ) 1. Find_DAG_Path( G(V,E), 4)

1. Find_DAG_Path( G(V,E), 0 ) 2. Find_DAG_Path( G(V,E), 5)

2. Calculate s2 = 0 3. Calculate s6 = 4

3. Calculate s4 = 2

1/15/2007 Lecture8 gac1 7 1/15/2007 Lecture8 gac1 8

General Longest Path Example Edge Set Partition

• Many algorithms to find the longest path of general • Consider our example graph. If we remove the

graphs have been proposed in the literature edges labelled “-1” and “-6”, we obtain a DAG

• We will consider Liao and Wong’s algorithm as it is v1 v1

very efficient for cases where the graph edge set 3 1 3 1

-1 1 1

E ∪ F can be partitioned into a “forward” edge set E v0 -6 v3 v0 v3

and a feedback edge set F where G(V,E) is a DAG

and |E| >> |F| 1 4 1 4

v2 v2

– this is often the case with graphs arising in synthesis –

we will consider some of these in future lectures • The remaining edges form the set E, whereas the

two we removed form the set F

Algorithm Liao_Wong( G(V,E ∪ F), source ) • Liao Wong first applies the DAG algorithm on the forward

for j = 1 to | F | + 1 {

DAG_Longest_Path( G(V,E), source); edges only. If no feedback edge provides a longer path

flag = TRUE; alternative, the algorithm terminates

foreach (u,v) in F {

if sv < su + w(u,v) { • If a longer path alternative is found, the algorithm models

flag = FALSE; this as an extra forward edge directly from the source

E = E ∪ { (source, v) }; • This process is repeated, until no more changes to the edge

w(source,v) = su + w(u,v);

} set are necessary

} • It is provable that if the graph contains no cycles where the

if( flag ) return;

} sum of weights around the cycle is positive, the outer loop

end Liao_Wong need only be executed at most |F|+1 times.

General Example General Example

• Let us examine our example graph • We now examine each of the feedback edges

in turn

3

v1

1 3

v1

1 – for edge (v3,v0), sv0 ≥ sv3 – 6 (0 ≥ -1), so no change

needs to be made

-1 1 1

v0 -6 v3 v0 v3 – for edge (v1,v2), sv2 < sv1 – 1 (1 < 2), so we must insert a

new forward edge (v0,v2) with weight 2 [in this example,

1 4 1 4 (v0,v2) is already in E, so we just modify the weight]

v2 v2

v1 v1

3 1 3 1

• Performing our initial DAG longest path, with v0 as

1 1

the source, leads to v0 v3 v0 v3

– sv0 = 0, sv1 = 3, sv2 = 1, sv3 = 5

1 4 2 4

v2 v2

1/15/2007 Lecture8 gac1 13 1/15/2007 Lecture8 gac1 14

• Calculating the longest path on the modified DAG • To keep up our interest in LP, let’s formulate the

leads to longest path problem as a LP

– sv0 = 0, sv1 = 3, sv2 = 2, sv3 = 6 • Let’s revisit Bellman’s equations:

• Examining each feedback edge in turn

– for edge (v3,v0), sv0 ≥ sv3 – 6 (0 ≥ 0), so no change

sv = max ( su + w(u , v))

( u ,v )∈E

needs to be made • A necessary condition for satisfaction is:

– for edge (v1,v2), sv2 ≥ sv1 – 1 (2 ≥ 2), so no change needs

to be made ∀(u , v) ∈ E , sv ≥ su + w(u , v) (*)

• At this point, the algorithm terminates as no • The minimum values of sv that satisfy (*) are the

changes are necessary solutions to Bellman’s equations

Longest Path as a LP LP Example

• We can write this as: • For our general graph example, the LP objective

minimize ∑ sv subject to: function and constraints are given below

v∈V

v1• minimize s0 + s1 + s2 + s3

sv ≥ su + w(u , v) for all (u,v) ∈ E 3 1

-1 1 subject to:

and ssource = 0 v0 -6 v3

s1 ≥ s0 + 3; s1 ≥ s2 + 1

1

v2

4 s2 ≥ s0 + 1; s2 ≥ s1 – 1

• This is a standard LP formulation (c.f. lecture 7), s3 ≥ s1 + 1; s3 ≥ s2 + 4

which can easily be cast in matrix notation Ax ≥ b if

s0 ≥ s3 – 6; s0 = 0

required

• Longest and shortest path problems have • Consider the edge-weighted graph shown below

many real-life applications, including v1 v2

– Circuits: Determining the critical path in a circuit, 3

1 2

and hence the performance of that circuit

v3 v4

– Transport: Finding the (shortest/cheapest/least 1

fuel) route between two places • (a) determine the longest path from v1 to all other

– Networking and Comms: Shortest path through a vertices in the graph

network • (b) if an edge (v2,v3) with weight w(v2,v3) = -4

were added, how would this affect the longest

paths?

1/15/2007 Lecture8 gac1 19 1/15/2007 Lecture8 gac1 20

Worked Example Summary

(a) It should be easy to see that sv1 = 0, sv2 = 5, • This lecture has covered

sv3 = 1, sv4 = 3 (verify by applying Bellman’s – Edge-weighted graphs, shortest and longest

equations in the order (v1, v3, v4, v2) path problems

(b) This edge would close a cycle {v3, v4, v2}. We – Longest path through a DAG

therefore use Liao-Wong to determine whether – Longest path through a general graph: Liao-

any change has occurred to the longest paths Wong

Examining the feedback edge (v2,v3), we see – Longest path as a LP

that sv3 ≥ sv2 – 4 (1 ≥ 5 – 4) and therefore the • This brings us to the end of our “theory

extra edge has not affected the longest paths break”. Next lecture will look at scheduling

digital circuits.

1/15/2007 Lecture8 gac1 21 1/15/2007 Lecture8 gac1 22

Suggested Problems

• Find the shortest path through the DAG used as an

example in this lecture (*)

• Try to apply the Liao-Wong algorithm to find the

shortest path through the cyclic graph example.

Does it work? If not, why not? (***)

• In the cyclic example, change the weight of edge

(v3,v0) to –4. Now apply Liao-Wong to the shortest

path problem. (*)

- Big OhUploaded byZede Cliff
- Analysis of Algorithms IUploaded byFahri Firdausillah
- Cap.8 EvaTardosUploaded byBruno Vitiello
- 6-3Uploaded bybawklau
- Algo Mod5 RecurrencesUploaded byISSAM HAMAD
- programming in engineeringUploaded byVictor Miclovich
- openqcUploaded bySrikar Varadaraj
- lec1Uploaded bynk2612
- 1. Comparison of AlgorithmsUploaded bySalif Ndiaye
- Applied Data Structures Chapter 1 AlgorithmUploaded byshaneshane
- Algorithm Complexity lalit bansalUploaded byLalit Bansal
- Fundamentals of Algorithms-2Uploaded byMilan Antony
- np1Uploaded byWill Smith Smith
- The Theory of ComputationUploaded byAriadne Pythia
- CS.7.PerformanceUploaded byAnthony Dlc
- ExperimentsUploaded byAnonymous WsxFYzWYsj
- Vasudevan10 Nd Ton TrUploaded byFederico Gonzalez
- slides9-8Uploaded byEartha
- Word Game LabUploaded byNeel Jani
- Data Structures and Algorithms MCQ -2Uploaded byKuldeep Singh
- Scimakelatex.4800.Dsfs.wfUploaded byOne TWo
- lecture1[1]Uploaded byLoveleen Bhalla
- Herbert S. Wilf - Algorithms and ComplexityUploaded by_chalex_
- 2.4. an Anagram Detection Example — Problem Solving With Algorithms and Data StructuresUploaded byErr33
- Algorithm ComplexityUploaded byKaran Roy
- IJCAI09-290Uploaded byManjari Maran
- 1-Analysis and Design f AlgorithmsUploaded byKartik Verma
- Sceitific Theory AssignmentUploaded bySyed Bukhari
- L-02 Complexity Analysis.pptUploaded bycatarac19
- A 3_2 Algorithm for Two-Machine - A 3-2 Algorithm for Two-MachineUploaded byAngel Cotera

- Mata23 Final 2014wUploaded byexamkiller
- Klaus Sutner- De Bruijn Graphs and Linear Cellular AutomataUploaded byIrokk
- gl TransformationsUploaded byBenny Xavier
- Calculus Cheat Sheet Part 1Uploaded byDave Cloud
- Elzaki Transform and a Bulge Function on Volterra Integral Equations of the Second KindUploaded byIOSRjournal
- Graph Implementation Using Linked ListUploaded byshameedp
- 4 3 extra practiceUploaded byapi-253892365
- UVa Problem List [Catagorized Algorithmic Problem]Uploaded bymr1r
- TriangulationUploaded byVBLG
- Topic 11 - MatricesUploaded byCollinsWriters
- 30. Improper Integrals 2 (Rigorous)Uploaded byArsalan Jumani
- ps7Uploaded byEhsan Spencer
- Iterative Methods System of EquationsUploaded byAsim Aziz
- xcxcxUploaded byRaúl Araque
- aisiitUploaded byB.s. Jnyaneshwar
- Cs6702 Graph Theory and Applications Lesson PlanUploaded byappasami
- Chapter2.pdfUploaded byHassan Zmour
- Integración - 1Uploaded byFelipe López Garduza
- [IJCST-V4I6P20]:Siddu P. Algur, Rashmi H. Patil, Prashant BhatUploaded byEighthSenseGroup
- wyjkm,Uploaded byShairuz Caesar Briones Dugay
- 5-3_Polynomial_Functions[1].pdfUploaded byEnas Basheer
- Hyperbolic FunctionsUploaded byNelsonMoseM
- 14508 18 Shortest Paths IIUploaded byTanmay Baranwal
- bpc5_ch09-05Uploaded byMuhammad Asad Ali
- Grafos - ClusterizaçãoUploaded byItalo Gomes Santana
- Revisi BIPMUploaded byWulan Siti Qodariah
- BM 503 Basic Mathematics for Biomedical Science W5Uploaded byYasin Cotur
- Gate Cs Solved Paper by Nodia 2Uploaded byKrishnendu Rarhi
- Propiedades Extremas de Valores Propios TropicalesUploaded byWendy Villogas Espinoza
- Davis - Mathematics of Matrices.pdfUploaded byRafael Garcia