Complessità spaziale di DFS Iterative Deepening

7

Leggiamo su Wikipedia > Ricerca approfondita approfondita per prima profondità che

The space complexity of IDDFS is O(bd), where b is the branching factor and d is the depth of shallowest goal.

Wikipedia fornisce anche qualche pseudocodice decente per IDDFS; L'ho pit pitificato:

def IDDFS(root, goal):
  depth = 0
  solution = None
  while not solution:
    solution = DLS(root, goal, depth)
    depth = depth + 1
  return solution

def DLS(node, goal, depth):
  print("DLS: node=%d, goal=%d, depth=%d" % (node, goal, depth))
  if depth >= 0:
    if node == goal:
      return node

    for child in expand(node):
      s = DLS(child, goal, depth-1)
      if s:
        return s

  return None

Quindi la mia domanda è: in che modo la complessità dello spazio include il fattore di ramificazione? Questo presuppone che expand(node) occupa O(b) spazio? Cosa succede se expand utilizza un generatore che richiede solo uno spazio costante? In tal caso, la complessità dello spazio sarebbe ancora una funzione del fattore di ramificazione? Ci sono situazioni in cui è anche possibile che expand sia un generatore di spazio costante?

    
posta Dan Burton 10.09.2011 - 20:56
fonte

2 risposte

5

Hai ragione. Wikipedia è sbagliato! Qualcuno ha il libro referenziato su Wikipedia per scoprire cosa significano (forse stanno parlando di un'ottimizzazione di qualche tipo)?

Controlla link e link

    
risposta data 15.09.2011 - 23:42
fonte
0

Sto studiando questo mentre parliamo, quindi permettimi di provare a rispondere a questa domanda (molto tardi, lo so) nella speranza di capire meglio me stesso IDDFS.

Il costo O (bd) è derivato da un'implementazione che utilizza una coda per memorizzare nodi inesplorati, piuttosto che ricorsione. Se ci pensi in questo modo, puoi immaginare di espandere il nodo radice e aggiungere b figli alla coda (da espandere in seguito), quindi selezioniamo un figlio (nodi b-1 rimasti in coda), espandi esso e aggiunge i suoi b figli (nodi b + (b-1) nella coda) e ripete questo processo fino a raggiungere il nodo obiettivo alla profondità d. A questo punto, abbiamo esteso i nodi d, sì? E ogni nodo che porta al nodo obiettivo ha contribuito con i nodi b-1 alla coda. Quindi, abbiamo O ((d-1) (b-1)) = O (bd).

Ritornando alla tua implementazione, sì, penso che tu abbia ragione sul fatto che il termine O (b) sia contenuto nella funzione di espansione, poiché expand restituirà b children e expand sarà chiamato d-1 times. Se espandere usa un generatore che richiede uno spazio costante, certo, penso che ridurrebbe il costo a O (d), ma non vedo come l'espansione possa fare qualsiasi cosa se non in scala con la dimensione di b.

    
risposta data 07.10.2014 - 23:53
fonte

Leggi altre domande sui tag