// recursive path-checking dfs. Private, because it has the extra // parameters needed for recursion. private List<UUSearchNode> dfsrpc( UUSearchNode currentNode, HashSet<UUSearchNode> currentPath, int depth, int maxDepth) { // you write this method currentPath.add(currentNode); // keep track of stats; these calls charge for the current node updateMemory(currentPath.size()); int i; // count for the successors List<UUSearchNode> path = new ArrayList<UUSearchProblem.UUSearchNode>(); // base case if (currentNode.goalTest() == true) { path.add(currentNode); return path; } // recursive case else { ArrayList<UUSearchNode> successors = new ArrayList<UUSearchNode>(); successors = currentNode.getSuccessors(); for (i = 0; i < successors.size(); i++) { incrementNodeCount(); if (successors.get(i).getDepth() <= maxDepth // depth must smaller than maxDepth && currentPath.contains(successors.get(i)) == false) // the state cannot be visited { // go ahead to search the successor(i) List<UUSearchNode> suc_path = new ArrayList<UUSearchNode>(); suc_path = dfsrpc(successors.get(i), currentPath, successors.get(i).getDepth(), maxDepth); if (!suc_path.isEmpty()) { // currentPath.clear(); path.add(currentNode); path.addAll(suc_path); // the path to goal return path; } else currentPath.remove( successors.get( i)); // becareful to the change of the currentpath, I add current node in every // begin point of a fuction nomatter whether it has sub_path } } return path; } }
// recursive memoizing dfs. Private, because it has the extra // parameters needed for recursion. private List<UUSearchNode> dfsrm( UUSearchNode currentNode, HashMap<UUSearchNode, Integer> visited, int depth, int maxDepth) { List<UUSearchNode> current_path = new ArrayList<UUSearchNode>(); // keep track of stats; these calls charge for the current node updateMemory(visited.size()); int i; // count for the successors // you write this method. Comments *must* clearly show the // "base case" and "recursive case" that any recursive function has. // base case if (currentNode.goalTest() == true) { current_path.add(currentNode); return current_path; } // recursive case else { ArrayList<UUSearchNode> successors = new ArrayList<UUSearchNode>(); successors = currentNode.getSuccessors(); for (i = 0; i < successors.size(); i++) { incrementNodeCount(); if (successors.get(i).getDepth() <= maxDepth // depth must smaller than maxDepth && (visited.containsKey(successors.get(i)) == false // the state cannot be visited || successors.get(i).getDepth() < visited.get( successors.get(i)))) // or if the depth is smaller than the visited one { // go ahead to search the successor(i) visited.put(successors.get(i), successors.get(i).getDepth()); List<UUSearchNode> suc_path = new ArrayList<UUSearchNode>(); suc_path = dfsrm(successors.get(i), visited, successors.get(i).getDepth(), maxDepth); if (!suc_path.isEmpty()) { current_path.clear(); current_path.add(currentNode); current_path.addAll(suc_path); // the path to goal return current_path; } } } return current_path; } }
public List<UUSearchNode> breadthFirstSearch() { resetStats(); // You will write this method int i; HashMap<UUSearchNode, UUSearchNode> explored = new HashMap<UUSearchNode, UUSearchNode>(); // explored:tracking the explored nodes List<UUSearchNode> path = new ArrayList<UUSearchNode>(); // the path to goal Queue<UUSearchNode> queue = new LinkedList<UUSearchProblem.UUSearchNode>(); queue.add(this.startNode); // initializing, add start node in queue explored.put(startNode, null); incrementNodeCount(); // update the node it explored updateMemory(explored.size()); while (!queue.isEmpty()) { // dequeue the head of queue to be the current node UUSearchNode current_node = (UUSearchNode) queue.remove(); if (current_node.goalTest() == true) { path = backchain(current_node, explored); } else { // add unexplored successors to fringe ArrayList<UUSearchNode> successors = new ArrayList<UUSearchNode>(); successors = current_node.getSuccessors(); for (i = 0; i < successors.size(); i++) { incrementNodeCount(); // update the node it explored before check for explored ones if (explored.containsKey(successors.get(i)) == false) { explored.put(successors.get(i), current_node); queue.add(successors.get(i)); updateMemory(explored.size()); } } } } return path; }