depth-first-search

问题 I am working or understanding how to create a simple java 2d maze that should look like this: int [][] maze = { {1,1,1,1,1,1,1,1,1,1,1,1,1}, {1,0,1,0,1,0,1,0,0,0,0,0,1}, {1,0,1,0,0,0,1,0,1,1,1,0,1}, {1,0,0,0,1,1,1,0,0,0,0,0,1}, {1,0,1,0,0,0,0,0,1,1,1,0,1}, {1,0,1,0,1,1,1,0,1,0,0,0,1}, {1,0,1,0,1,0,0,0,1,1,1,0,1}, {1,0,1,0,1,1,1,0,1,0,1,0,1}, {1,0,0,0,0,0,0,0,0,0,1,0,1}, {1,1,1,1,1,1,1,1,1,1,1,1,1} }; Ones this has been created the idea is to set a starting point and goal point and by using

问题 Can anyone provide either code, pseudocode, or even provide good links to implementing DFS and BFS in plain JavaScript (No JQuery, or any helper libraries)? I've been trying to understand how to implement either traversal, but I can't seem to really distinguish the difference of a BFS and DFS implementation. If we want a concrete problem as an example: I want to traverse down the DOM at a given node, and get all the class names. (The only way I can think to traverse is to go through each

问题 Well, I have spent lots of time on this issue. However, I only can find solutions with non-recursive methods for a tree: Non recursive for tree, or recursive method for the graph, Recursive for graph. And lots of tutorials(I don't provide those links here) don't provide the approaches as well. Or the tutorial is totally incorrect. Please help me. Updated: It's really hard to describe: If I have a undirected graph: 1 / | \ 4 | 2 3 / 1-- 2-- 3 --1 is a cycle. At the step: push the neighbors of

问题 In a given graph G=(V,E) each edge has a cost c(e) . We have a starting node s and a target node t. How can we find the most expensive path from s to t using following DFS algorithm? DFS(G,s): foreach v in V do color[v] <- white; parent[v] <- nil DFS-Visit(s) DFS-Visit(u) color[u] <- grey foreach v in Adj[u] do if color[v] = white then parent[v] = u; DFS-Visit(v) color[u] <- black What I have tried: So first we create an array to maintain the cost to each node: DFS(G,s,t): foreach v in V do

问题 I have a list of over 10000 items and using recursion i want to iterate over all the possible combinations of their selection starting from 1st item for both its selection and not selection ( 2 branches ) then deciding on 2nd item for each branch and so on till last item in DFS way. I am using this code for optimization and most of the branches are not iterated over but atleast 1 leaf will be reached as to find the best the problem is I made a recursion code in python and it works fine for

问题 I'm having trouble randomizing the visit from a node to its neighbors, rarely is the whole graph (a MxN array, in this test 4x4) visited, I don't get what I'm doing wrong here. import java.util.ArrayList; class IJ { int i; int j; IJ (int i,int j){ i = this.i; j= this.j; } } class Graph { int M; int N; int adjacencyMatrix[][]; ArrayList <IJ> orderOfVisits; Graph(int M,int N){ this.M=M; this.N=N; adjacencyMatrix=new int[M][N]; for (int i=0; i<M; i++) for (int j=0;j<N;j++){ adjacencyMatrix[i][j]

问题 Currently trying to build a program that can implement both DFS and BFS in Java by taking in an adjacency matrix from a file and printing out the following info: order that vertices are first encountered, order that vertices become dead ends, number of components, and the tree edges. Here is my code: import java.io.File; import java.io.FileNotFoundException; import java.util.ArrayList; import java.util.Scanner; public class ProjectDriver { public static int count; public static void main

问题 I am solving Word Search question on LeetCode.com: Given a 2D board and a word, find if the word exists in the grid. The word can be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once. The solution which I wrote with online help is as follows: class Solution { public: //compare this with Max Area of Island: //they 'look' similar, but this one uses a backtracking

问题 I came around one of those questions in my exams: Topologocial sorting using Kahn's Algorithm requires the graph to be DAG (Directed Acyclic Graph). How can we determine if a graph contains no cycles without using DFS/BFS first? I am trying to answer that for too long now and I am baffled. Can anyone point out to me an algorithm that determines that a graph has no cycles that DOESN'T use DFS or should I go rampaging to my instructor? 回答1: If and only if, at some point during kahn's algorithm

问题 (This question is followed up in more detail here: python-search-algorithm-from-implied-graphs) Suppose I have a function that takes an input ($x_i$) and then goes through a loop and yields a series of outputs ($x_{i, j}$). Then each output can be an input again to the same function yielding further outputs ($x_{i, j, k}$). And I'm trying to find a set of steps via this function to a particular end state. This is a general problem, and my question is what is a good code structure within