CSCE 580 Artificial Intelligence Dijkstra

1
CSCE 580Artificial IntelligenceDijkstras
Algorithm Notes to Complement and Reinforce the
Graduate Student Presentation

• Fall 2008
• Marco Valtorta
• mgv_at_cse.sc.edu

2
Example Romania
3
Single-State Problem Formulation

• A problem is defined by four items
• initial state e.g., "at Arad"
• actions or successor function S(x) set of
  actionstate pairs
• e.g., S(Arad) ltArad ? Zerind, Zerindgt,
• ltArad ? Timisoara, Timisoaragt,
• goal test, can be
• explicit, e.g., x "at Bucharest"
• implicit, e.g., Checkmate(x)
• path cost (additive)
• e.g., sum of distances, number of actions
  executed, etc.
• c(x,a,y) is the step cost, assumed to be 0
• A solution is a sequence of actions leading from
  the initial state to a goal state
• An optimal solution is a solution of lowest cost

4
Uniform-Cost (Dijkstra) for Graphs

• Original Reference Dijkstra, E. W. "A Note on
  Two Problems in Connexion with Graphs.
  Numerische Matematik, 1 (1959), 269-271
• 1. Put the start node s in OPEN. Set g(s) to 0
• 2. If OPEN is empty, exit with failure
• 3. Remove from OPEN and place in CLOSED a node n
  for which g(n) is minimum in case of ties, favor
  a goal node
• 4. If n is a goal node, exit with the solution
  obtained by tracing back pointers from n to s
• 5. Expand n, generating all of its successors.
  For each successor n' of n
• a. compute g'(n')g(n)c(n,n')
• b. if n' is already on OPEN, and g'(n')ltg(n'),
  let g(n')g'(n) and redirect the pointer from n'
  to n
• c. if n' is neither on OPEN or on CLOSED, let
  g(n')g'(n'), attach a pointer from n' to n, and
  place n' on OPEN
• 6. Go to 2

5
Properties of Dijkstras Algorithm

• g(n) is the distance (cost) of some path from the
  start node to node n
• f(n) is the minimum of g(n) over all possible
  paths from the start node to node n
• f(k) is the distance of the goal node from the
  start node---assume a single goal node, k, for
  simplicity
• A search algorithm is admissible if it returns
  the shortest path
• 1. When node n is closed in step 3, g(n)f(n)
• 2. When node n is closed at step 3, g(n) is at
  least as high as the g value of all already
  closed nodes and all nodes with lower g values
  than g(n) have already been closed
• 3. Only nodes for which g(n)ltf(k) are expanded
  in step 5 (if there is a path from the start node
  to the goal node)
• 4. Dijkstra's algorithm never expands the same
  node twice
• 5. Dijkstra's algorithm expands the least number
  of nodes among all admissible blind,
  unidirectional search algorithms

6
Property 1 of Dijkstras Algorithm

• When node n is closed in step 3, g(n)f(n)
• The proof is by induction on the number of closed
  nodes. For the base case, g(s) f(s) 0.
• Let n1,,nq be the nodes in OPEN. Let n ni
• Consider the path to n through nodes in CLOSED
  that establishes that n is to be closed in step 3
• Assume that there is a shorter path to n than the
  one chosen by Dijkstras algorithm. Let np be
  the first node in OPEN on that path. Since path
  s?np?ni is shorter than g(n), then path s?np is
  shorter than path s?ni. This means that when
  executing step 3, g(np) lt g(ni), and therefore np
  would be closed in step 3 instead of ni
  contradiction!

7
Property 2 of Dijkstras Algorithm

• When node n is closed at step 3, g(n) is at
  least as high as the g value of all already
  closed nodes and all nodes with lower g values
  than g(n) have already been closed
• This can also be proven by induction. For the
  induction step, note that the node that is closed
  at step 3 has g(n) value that is at least as high
  than that of all previously closed
  nodes---otherwise it would have been closed
  before!
• Also note that this proof depends crucially on
  having non-negative edge costs

8
Property 3 and 4 of Dijkstras Algorithm

• Only nodes for which g(n)ltf(k) are expanded in
  step 5 (if there is a path from the start node to
  the goal node)
• Since nodes are expanded in non-decreasing order
  of shortest-path distance from the start node,
  only nodes for which g(n) lt f(k) are expanded
• To get the result with a strict inequality, note
  that ties are broken in favor of the goal node
• Dijkstra's algorithm never expands the same node
  twice
• Nodes are expanded only when they are moved from
  OPEN to CLOSED in step 3. Since CLOSED nodes
  cannot be re-OPENed, no node can be expanded
  twice.

9
Property 5 of Dijkstras Algorithm

• Dijkstra's algorithm expands the least number of
  nodes among all admissible blind, unidirectional
  search algorithms
• Adversary argument
• I claim there is an algorithm (say, B) that does
  not expand node m, for which g(m) lt f(k) on some
  graph search problem (say, G) and is admissible
• Let f(k)-g(m) e
• Consider an instance of graph search problem
  identical to G except for the additional edge m?k
  of cost e/2
• Since B does not expand node m, it will not
  return the shortest path of length f(k)-(e/2)
• Therefore, B is not admissible

10
Lower Bound

• Assumptions and notation
• decision-tree model (count comparisons of edge
  costs)
• blind unidirectional algorithms
• n is the number of nodes and m is the number of
  edges in the (implicit) graph been searched
• Property 5 implies ?(m)
• ?(n log(n)) follows from a transformation of
  sorting to finding the shortest path spanning
  tree and a sequence of all the n nodes ordered in
  increasing distance from the start node
• Overall ?(m n log(n))
• The Fibonacci tree implementation of Dijkstras
  algorithm matches the lower bound and is
  therefore optimal
• See reference in notes

11
Bidirectional Uniform-Cost Algorithm

• (Assume that there is only one goal node, k.)
• 1. Put the start node s in OPEN1 and the goal
  node k in OPEN2. Set g(s) and h(k) to 0
• 2'. If OPEN1 is empty, exit with failure
• 3'. Remove from OPEN1 and place in CLOSED1 a node
  n for which g(n) is minimum
• 4'. If n is in CLOSED2, exit with the solution
  obtained by tracing backpointers from n to s and
  forward pointers from n to k
• 5'. Expand n, generating all of its successors.
  For each successor n' of n
• a. compute g'(n')g(n)c(n,n')
• b. if n' is already on OPEN1, and g'(n')ltg(n'),
  let g(n')g'(n) and redirect the pointer from n'
  to n
• c. if n' is neither on OPEN1 or on CLOSED1, let
  g(n')g'(n'), attach a pointer from n' to n, and
  place n' on OPEN1
• 2". If OPEN2 is empty, exit with failure
• 3". Remove from OPEN2 and place in CLOSED2 a node
  n for which h(n) is minimum
• 4". If n is in CLOSED1, exit with the solution
  obtained by tracing forwards pointers from n to k
  and backpointers from s to n
• 5". Expand n, generating all of its predecessors.
  For each predecessor n' of n
• a. compute h'(n')h(n)c(n',n)
• b. if n' is already on OPEN2, and h'(n')lth(n'),
  let h(n')h'(n) and redirect the pointer from n'
  to n
• c. if n' is neither on OPEN2 or on CLOSED2, let
  n(n')n'(n'), attach a pointer from n' to n, and
  place n' on OPEN2
• 6. Go to 2'.