在FlowChart图中找到所有的方法？

Question

我在Java上做了一个FlowChart图表编辑器。它会绘制流程图并将它们连接起来，并创建两个数组。其中一个显示连接节点和线路，另一个显示相互连接的元素。从第二开始我就得找到所有的方法。例如，如果我有一些菱形来做决定，我有两种不同的方式，..I想要得到我必须使用的所有ways..Which算法？

编辑3:再次解决了嗨，我解决了我的问题，我的self..Here，我的代码。))

 public void search(){
  //  System.out.print(map.length);

for(i=0;i<map.length;i++)

    visit[i]=0;

    visit[0]=1;

    find(0,map.length-1,1);
}



  public void  find(int i,int d,int step){

for(int j=0;j<map.length;j++){
 System.out.println(">>"+i+"->"+j);
    if(visit[j]!=0 || map[i][j]==0)

        continue;

    if(j==d){
        visit[j]=step;
        OutputCycle();
      visit[j]=0;
        return;

    }
System.out.println(""+i+" to "+j);
    visit[j]=step;
    find(j,d,step+1);
    visit[j]=0;




}


  }
public void OutputCycle(){
    System.out.println("OUTPUT");

    for(k=0;k<visit.length;k++){

         for(int i=0;i<visit.length;i++){
             if(visit[i]==k+1){
                 System.out.print(i);
             }
         }
    }
    System.out.println();
}

编辑1:当我在我的问题上，我解决了一部分，不，也有错误.这里我的问题更深层次的描述:我有一个数组来描述元素之间的连接。

          j

       A  B  C  D  E 

    A  0  1  0  0  0 

    B  1  0  1  1  0 

i   C  0  1  0  0  1

    D  0  1  0  0  1

    E  0  0  1  1  0     

这是我的连接数组..I试图找到从启动A到E的所有方法

有两条路

A->B->C->E

A->B->D->E

我能找到第一条从左到右搜索数组的方法。如果我看到1，我取J的walu e到I中的J‘to元素行，使该元素2从i，j+1开始搜索，如果到达E，则发送结果。

但在这里，我的问题是，在第一行的秒搜索中，它不会看到1，并且会转到第二行，并且有第一个元素1，但它指的是第一行，它将是循环的。

此外，我尝试使用DFS与使用回溯，但它并不是指显示所有的路径，只有一个路径。

我试着把下面的所有列都变成0，如果我支持1并开始搜索i，j，但是在第二行它不会看到任何东西，而我的arry表就会变成一个空表)。

我知道我错过了一件事，但我想不出来。

编辑2:

现在我已经接近解决问题了，但也有一些问题。我使用这个代码从矩阵中计算路径。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
*
* @author Meko
*/
public class Main {

List visited = new ArrayList();
List allObjects = new ArrayList();
int map[][] = {{3, 1, 0, 0, 0},
    {1, 0, 1, 1, 0},
    {0, 1, 0, 0, 3},
    {0, 1, 0, 0, 3},
    {0, 0, 1, 1, 0}};
int i, j, k;

public Main() {

    ShowArray();
    System.out.println();
    find(0, 0);
    System.out.println();
    result();
    System.out.println();
    afterFind();
    System.out.println();
}

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    // TODO code application logic here

    new Main();

}

public void ShowArray() {

    for (int i = 0; i < map.length; i++) {
        for (int j = 0; j < map.length; j++) {

            System.out.print(" " + map[i][j]);
        }
        System.out.println("");
    }


}

public void find(int sRow, int sCol) {


    for (i = sRow; i < map.length; i++) {
        for (j = sCol; j < map.length; j++) {


            if (map[i][j] == 1) {
                map[i][j] = 2;
                visited.add(" " + i + " " + j);
                for (k = i; k < map.length; k++) {
                    map[k][i] = 0;

                }
                find(j, i);
            } else if (map[i][j] == 3) {
                visited.add(" " + i + " " + j);
              for (k = i; k < map.length; k++) {
                    map[k][i] = 0;

                }
                System.out.println("Founded");
                map[i][j] = 2;
                find(0, 0);
            }
        }

    }
}

public void result() {
    System.out.println(visited);
}

public void afterFind() {

    for (int i = 0; i < map.length; i++) {
        for (int j = 0; j < map.length; j++) {

            System.out.print(" " + map[i][j]);
        }
        System.out.println("");
    }

}

}

它的输出是

3 1 0 0 0
1 0 1 1 0
0 1 0 0 3
0 1 0 0 3
0 0 1 1 0

创建创建创建

0 0，0 1，1 2，2 4，1 3，3 4

0 2 0 0 0
0 0 2 2 0
0 0 0 0 2
0 0 0 0 2
0 0 0 0 0

2指的是访问和更改。问题在于，当您在访问列表中使用时，它会添加

00，01，12，24这是第一条路径，但是只有13,34 .this是因为我将数组的其余部分更改为0，而不是搜索。我怎么才能解决这个问题？它必须是00,01,12,24和00,01或10，13，34。知道吗？？我不认为这是DFS还是BFS？或者别的什么？？

Answer 1

您正在考虑的是非常接近编译器优化器使用的分析。这些优化器使用汇编语言指令的“基本块”，而不是流程图图标。“基本块”，就像流程图图标一样，是由流程控制边缘定义的，它划定了基本块和流程图图标的边界。

因此，我建议您查看编译器文献，了解如何操作流程图。特别是，您将希望阅读“数据流分析”，如"def-use“和”达成定义“问题。

在回答您的问题时，您可以实现如下有向图遍历算法：

/* Marks all flowchart icons as "unvisited." */
for (int i = 0; i < nodes.Count(); i++):
   node[i].visited = false

/* Schedule the Start node for processing. */
node_queue.push(nodes.start_node())

/* Traverse the graph. */
while (node_queue.not_empty()):
    current_node = node_queue.pop_front()

    calculations_on_node(current_node)

    current_node.visited = true

    for (int i = 0; i < current_node.outgoing_edges.Count(); i++):
        edge  = current_node.outgoing_edges[i]
        if (!edge.destination_node.visited):
            node_queue.push_back(edge.destination_node)

您可以实现calculations_on_node来执行您想要的每个节点的工作。

Steven的高级编译器的设计与实现是一本关于编译器优化的优秀教材，我建议您研究它。

Answer 2

弗洛伊德-沃尔算法将计算所有顶点之间的最短路径。如果您不是在寻找最短路径，而是所有路径，您可以通过在两个节点之间进行彻底的深度优先搜索来实现这一点。

我强烈建议查看图算法的维基百科网页。