def depth_first_search(self): """ Depht-first search. @rtype: tuple @return: tupple containing a dictionary and two lists: 1. Generated spanning tree 2. Graph's preordering 3. Graph's postordering """ return searching.depth_first_search(self)
def depth_first_search(self): """ Depht-first search. @rtype: tuple @return: A tupple containing tree lists: 1. Generated spanning tree 2. Graph's preordering 3. Graph's postordering """ return searching.depth_first_search(self)
def main(): st = time.perf_counter() #Start a time counter. if len(sys.argv) == 4: #If the length of the keyword arguments is four... method = sys.argv[ 1] #The second argument is the method/algorithm used to find a solution. input_file = sys.argv[ 2] #The third argument is a .txt file containing the initial and final state of the problem. output_file = sys.argv[ 3] #The fourth argument is a .txt file containing the solution of the problem. initial_state, goal_state = read_input_file( filename=input_file ) #Read the input file and return two state objects. if method == 'breadth': #Check which method is selected and solve the problem accordingly. solution = breadth_first_search(current_state=initial_state, goal_state=goal_state, timeout=300) elif method == 'depth': solution = depth_first_search(current_state=initial_state, goal_state=goal_state, timeout=300) elif method == 'best': solution = heuristic_search(current_state=initial_state, goal_state=goal_state, method='best', timeout=300) elif method == 'astar': solution = heuristic_search(current_state=initial_state, goal_state=goal_state, method='astar', timeout=300) else: #If the method argument is none of the above, print a usage message. solution = None print( 'Usage: python bw.py <method> <input filename> <output filename>' ) if solution == goal_state: #If the solution is equal to the goal state... number_of_moves = write_output_file( solution=solution, filename=output_file ) #Write the solution file and return the number of moves. print('Solution found!') print('Number of blocks:', len(initial_state.layout.keys())) print('Method:', method) print('Number of moves:', number_of_moves) print('Execution time:', str(round(time.perf_counter() - st, 4))) else: #Else, if the length of the keyword arguments is not equal to four, print a usage message. print( 'Usage: python bw.py <method> <input filename> <output filename>')
def depth_first_search(self, root=None): """ Depht-first search. @type root: node @param root: Optional root node (will explore only root's connected component) @rtype: tuple @return: tupple containing a dictionary and two lists: 1. Generated spanning tree 2. Graph's preordering 3. Graph's postordering """ return searching.depth_first_search(self, root)
def find_path(self): filt = find("t") st, _, _ = depth_first_search(self.graph, "s", filter=filt) if "t" not in st: return None else: path = [] sink = "t" # build up path from spanning tree returned from dfs while sink != "s": src = st[sink] new_edge = (src, sink, self.graph.edge_weight((src, sink))) path.insert(0, new_edge) sink = src return path
def find_path(graph, source): filt = find("t") st, po, _ = depth_first_search(graph, source, filter=filt) # no path from s -> source -> t exists if "t" not in st or not graph.has_edge(("s", source)): return None else: # construct path from st (spanning tree) path = [] sink = "t" while sink != source: src = st[sink] new_edge = (src, sink, graph.edge_weight((src, sink))) path.insert(0, new_edge) sink = src source_edge = ("s", source, graph.edge_weight(("s", source))) path.insert(0, source_edge) return path
def run(in_graph_file): # converts a graph in an acceptable form into a representation # that is usable in MapReduce mr_file_name = "mr_max_flow.txt" original_graph = file_to_graph(in_graph_file) mr_graph = mr_graph_convert(original_graph) dict_to_graph_file(mr_graph, mr_file_name) augmented_edges = {} # counters to keep track of convergence of MapReduce jobs converge_count = 5 previous_count = -1 while converge_count != 0: infile = open(mr_file_name, "r") # uncomment to run on emr # mr_job = max_flow.MRFlow(args=['-r', 'emr']) mr_job = max_flow.MRFlow() mr_job.stdin = infile with mr_job.make_runner() as runner: # perform iteration of MapReduce runner.run() # process map reduce output out_buffer = [] for line in runner.stream_output(): # print str(counter) + ": " + line key, value = extract_key_value(line) if key == "A_p": A_p = value merge_edge_flow(augmented_edges, A_p) else: out_buffer.append(line) # write map reduce output to file for next iteration outfile = open(mr_file_name, "w") for line in out_buffer: key, value = extract_key_value(line) value.append(A_p) # value.append(1) new_line = json.dumps(key) + "\t" + json.dumps(value) + "\n" outfile.write(new_line) # check for convergence move_counts = runner.counters()[0]["move"] if move_counts["source"] == previous_count: converge_count -= 1 else: converge_count = 5 previous_count = move_counts["source"] infile.close() outfile.close() # augment graph based on max flow # original_graph = dict_graph_to_python_graph(original_graph_dict) augmented_graph = augment_graph(original_graph, augmented_edges) # find cut spanning_tree, preordering, postordering = depth_first_search( augmented_graph, "s") min_cut = find_max_flow(original_graph, preordering) return min_cut, preordering
def run(in_graph_file): # converts a graph in an acceptable form into a representation # that is usable in MapReduce mr_file_name = "mr_max_flow.txt" original_graph = file_to_graph(in_graph_file) mr_graph = mr_graph_convert(original_graph) dict_to_graph_file(mr_graph, mr_file_name) augmented_edges = {} # counters to keep track of convergence of MapReduce jobs converge_count = 5 previous_count = -1 while converge_count != 0: infile = open(mr_file_name, "r") # uncomment to run on emr # mr_job = max_flow.MRFlow(args=['-r', 'emr']) mr_job = max_flow.MRFlow() mr_job.stdin = infile with mr_job.make_runner() as runner: # perform iteration of MapReduce runner.run() # process map reduce output out_buffer = [] for line in runner.stream_output(): # print str(counter) + ": " + line key, value = extract_key_value(line) if key == "A_p": A_p = value merge_edge_flow(augmented_edges, A_p) else: out_buffer.append(line) # write map reduce output to file for next iteration outfile = open(mr_file_name, "w") for line in out_buffer: key, value = extract_key_value(line) value.append(A_p) # value.append(1) new_line = json.dumps(key) + "\t" + json.dumps(value) + "\n" outfile.write(new_line) # check for convergence move_counts = runner.counters()[0]["move"] if move_counts["source"] == previous_count: converge_count -= 1 else: converge_count = 5 previous_count = move_counts["source"] infile.close() outfile.close() # augment graph based on max flow # original_graph = dict_graph_to_python_graph(original_graph_dict) augmented_graph = augment_graph(original_graph, augmented_edges) # find cut spanning_tree, preordering, postordering = depth_first_search(augmented_graph, "s") min_cut = find_max_flow(original_graph, preordering) return min_cut, preordering