title: How do I interpret this backtracking code?
body: <p>I'm having a hard time understanding backtracking code. In particular, I know we always explore and backtrack when we don't find a solution, but I don't understand the logic behind the <code>path.pop()</code> line. </p>
  
  <p>I know we must pop elements after exploration, but how does this pop off the right element? </p>
  
  <p>Before that, we may recurse all the way down to the children nodes</p>
  
  <p><code># If current vertex is not destination 
              #Recur for all the vertices adjacent to this vertex 
              for i in self.graph[u]: 
                  if visited[i]==False: 
                      self.printAllPathsUtil(i, d, visited, path)
  </code>
   so how do we guarantee <code>path.pop()</code> removes <code>u</code> and not some other node? It makes sense when I draw out a recursion tree but is there an easier way to understand this?</p>
  
  <pre><code>   '''A recursive function to print all paths from 'u' to 'd'. 
      visited[] keeps track of vertices in current path. 
      path[] stores actual vertices and path_index is current 
      index in path[]'''
      def printAllPathsUtil(self, u, d, visited, path): 
  
          # Mark the current node as visited and store in path 
          visited[u]= True
          path.append(u) 
  
          # If current vertex is same as destination, then print 
          # current path[] 
          if u ==d: 
              print path 
          else: 
              # If current vertex is not destination 
              #Recur for all the vertices adjacent to this vertex 
              for i in self.graph[u]: 
                  if visited[i]==False: 
                      self.printAllPathsUtil(i, d, visited, path) 
  
          # Remove current vertex from path[] and mark it as unvisited 
          path.pop() 
          visited[u]= False
  
  
      # Prints all paths from 's' to 'd' 
      def printAllPaths(self,s, d): 
  
          # Mark all the vertices as not visited 
          visited =[False]*(self.V) 
  
          # Create an array to store paths 
          path = [] 
  
          # Call the recursive helper function to print all paths 
          self.printAllPathsUtil(s, d,visited, path) 
  </code></pre>