Algorithm 查找从一个图形节点到另一个图形节点的所有路径的逻辑

我有一个棘手的逻辑问题，我正试图创建一个算法来解决它，但我正在努力让我的头围绕它

考虑以下数据：

A to B
A to C
A to D
A to E
B to C
B to D
B to E
C to D
C to E
D to E

如您所见，这有效地生成了这样一个模型：

a-B-C-D-E

你只能往一个方向走，（从左到右），我想写的是一个算法，可以计算出两点之间所有可能的组合，即

如果我想从

A

到

E

所有可能的组合如下：

A - E 
A - D - E
A - C - E
A - B - E
A - C - D - E
A - B - D - E
A - B - C - E
A - B - C - D - E

我想就这些

---

有人能帮我用逻辑来解决这个问题吗？

我想逻辑可以如下：

 char[] chars = {'A','B', 'C', 'D','E'};
 List<Character> charList = new ArrayList<Character>();
 for (int begin=0; begin <chars.length; begin++){
   for (int index=begin; index <chars.length; index++){
     charList.add(chars[begin]);
     for (int indx1=chars.length-index; indx1 <chars.length-begin; indx1++){
        charList.add(chars[indx1+begin]);
     }
     System.out.println(charList);
     charList.clear();
   }
 }

维护字符列表/数组，例如

  char[] chars = {'A','B', 'C', 'D','E'};

创建3个索引变量，begin=0，end=chars.length-1，index=0

为每个打印范围执行2个嵌套for循环，

  for begin =0 to end
      collect chars[beign]
      for indx end -begin to end
          collect chars[indx]                  

我想这就行了

一个示例逻辑可以如下所示：

 char[] chars = {'A','B', 'C', 'D','E'};
 List<Character> charList = new ArrayList<Character>();
 for (int begin=0; begin <chars.length; begin++){
   for (int index=begin; index <chars.length; index++){
     charList.add(chars[begin]);
     for (int indx1=chars.length-index; indx1 <chars.length-begin; indx1++){
        charList.add(chars[indx1+begin]);
     }
     System.out.println(charList);
     charList.clear();
   }
 }

---

我认为逻辑如下：

 char[] chars = {'A','B', 'C', 'D','E'};
 List<Character> charList = new ArrayList<Character>();
 for (int begin=0; begin <chars.length; begin++){
   for (int index=begin; index <chars.length; index++){
     charList.add(chars[begin]);
     for (int indx1=chars.length-index; indx1 <chars.length-begin; indx1++){
        charList.add(chars[indx1+begin]);
     }
     System.out.println(charList);
     charList.clear();
   }
 }

维护字符列表/数组，例如

  char[] chars = {'A','B', 'C', 'D','E'};

创建3个索引变量，begin=0，end=chars.length-1，index=0

为每个打印范围执行2个嵌套for循环，

  for begin =0 to end
      collect chars[beign]
      for indx end -begin to end
          collect chars[indx]                  

我想这就行了

一个示例逻辑可以如下所示：

 char[] chars = {'A','B', 'C', 'D','E'};
 List<Character> charList = new ArrayList<Character>();
 for (int begin=0; begin <chars.length; begin++){
   for (int index=begin; index <chars.length; index++){
     charList.add(chars[begin]);
     for (int indx1=chars.length-index; indx1 <chars.length-begin; indx1++){
        charList.add(chars[indx1+begin]);
     }
     System.out.println(charList);
     charList.clear();
   }
 }

---

首先，考虑如何表示单个“跃点”：每个节点都需要其相邻节点的列表。首先构建这些节点

您还需要一种从节点池中查找节点的方法（按名称？）。也许把它们放在地图上

蛮力算法是从请求的节点开始，递归地跟踪所有跳，观察循环，直到到达请求端，传递一个列表——将其用作下推堆栈，以记录路径。每次到达请求端时，将列表的内容保存到路径集合中。如果遇到死胡同（没有指向请求端的链接），请在递归中备份并继续

根据您对速度的需求，您可以扩展数据结构以保存一些预先计算的路径

---

试着用伪代码和Java来解决这个问题。

首先，考虑如何表示单个“跃点”：每个节点都需要一个相邻节点的列表。首先构建这些节点

您还需要一种从节点池中查找节点的方法（按名称？）。也许把它们放在地图上

蛮力算法是从请求的节点开始，递归地跟踪所有跳，观察循环，直到到达请求端，传递一个列表——将其用作下推堆栈，以记录路径。每次到达请求端时，将列表的内容保存到路径集合中。如果遇到死胡同（没有指向请求端的链接），请在递归中备份并继续

根据您对速度的需求，您可以扩展数据结构以保存一些预先计算的路径

---

试着用伪代码然后用Java解决这个问题。

你的问题最好表述为：“对于给定的有向图，列出从某个节点到另一个节点的所有可能路径。”请参阅

您可以使用递归来解决它：

路径（NodeSequence start、Node finish、listofnodesquences result）

将节点序列的空白列表作为第三个参数，如果

n

是

finish

，则可以通过一个跃点从

start

到达每个

节点n

，将

start

添加到

结果

，否则调用

path

，并将

start+n

作为第一个参数

递归可能不一定是解决这个问题的最节省资源的方法，但是编写代码并不需要很多工作。上面的结果假设您将初始化一个空的结果变量，它将由递归函数修改而不是返回，因此这有点奇怪，但是我给出的版本应该花费最少的精力

不完整的解决方案（省略不相关的实施细节）：

公共类节点{
公共字符串名称；
公共布尔等于（节点其他）{
抛出新的NotImplementedException（）；
}
};
公共类节点序列{
私有ArrayList节点；
公共节点序列（）{
节点=新的ArrayList（）；
}
公共节点序列Plus（节点n）{
//返回此NodeSequence，结尾追加n
抛出新的NotImplementedException（）；
}
公共节点Last（）{
抛出新的NotImplementedException（）；
}
}
公共无效路径（节点序列开始、节点完成、ArrayList结果）{
Node startNode=NodeSequence.Last（）；
ArrayList nextStops；
//使用startNode之后的每个节点填充nextStops
//递归块
用于（节点n:nextStops）{
如果（n等于（完成））
结果。添加（开始加（n））；
其他的
路径（开始加（n）、结束、结果）；
}
}
ArrayList FindAllPath（节点开始、节点完成）{
ArrayList AllPath=新的ArrayList（）；
//这条线需要一段时间
路径（开始、结束、所有路径）；
返回所有路径；
}

---

findAllPaths

将给出结果。

您的问题最好表述为：“对于给定的有向图，列出从某个节点到另一个节点的所有可能路径。”请参阅

您可以使用递归来解决它：

路径（NodeSequence start、Node finish、listofnodesquences result）

将节点序列的空白列表作为第三个参数，如果

n

是

finish

，则可以通过一个跃点从

start

到达每个

节点n

，将

start

添加到

结果

，否则调用

path

，并将

start+n

作为第一个参数

递归不一定是最有效的资源