Java 通过扭曲遍历无向、未加权的图：每个节点的最小访问量

我正在尝试编写代码来遍历一个无向的、未加权的图。本质上，该方法将被传递给一个节点（它知道它的所有邻居）。然后，该方法必须通过从一个节点到另一个节点并收集节点之间相互链接的信息，尽可能高效地构建图的模型。最后，该方法将有一个所有节点和连接它们的所有顶点的完整列表

*问题的关键在于“有效”这个词以及我所说的意思。让我把你的注意力放在这个小图表上：

假设我从节点G开始。我可以访问C、B、F、D、H、J或E。我希望最小化我访问一个节点的次数，为了访问一个节点，我必须通过通往该节点的所有节点

示例：假设我决定访问节点C。下一个要访问的节点可以是A、B、F、D、H、J或E。但是，要访问除A之外的任何节点，我必须再次通过G，这被认为是低效的。为了访问A，我必须再次访问G和C，然后通过C和G返回到图的其余部分。所以我决定访问A。这意味着我必须再次通过C到达G。因此，从逻辑的角度来看，最后访问C分支是有意义的

然而，当程序在节点G启动时，它不知道分支C会导致死胡同。在我写这篇文章的时候，我认为这可能是不可能的，但我还是要问：是否存在只使用给定的信息尽可能高效地遍历这张图（正如我之前定义的那样）（即，程序只知道其访问的节点和这些节点发出的边？还是我应该使用Dijkstra算法的变体，以确保我访问每个节点

---

如果有必要的话，这些都将用Java编写。

仅仅是一个带有collect参数的简单递归不就可以了吗

public void traverse(Node n, Set<Node> visisted) {

  visited.add(n);

  for (Node neighbour : n.getNeighbours()) {

    if (!visited.contains(neighbour)) {
      traverse(neighbour, visited);
    }

  }

}

public void遍历（节点n，集合已访问）{
添加（n）；
对于（节点邻居：n.getNeights（））{
如果（！visted.contains（邻居））{
特拉弗斯（邻居、来访者）；
}
}
}

您是想简单地遍历整个图形（不管所采用的路径），并对每个节点执行一些操作，还是想计算从一个节点到任何其他节点的最短路径？（我可能不理解您的目标。）

在第一种情况下，坚持遍历算法，例如，对于另一种情况，您可能需要考虑使用相同的加权边（即＝1）。

---

当您只对一个起始节点感兴趣，并且所有边都具有相同的权重时，您可以将BFS视为Dijkstra的特例。对于不同的成本，您可以使用统一成本搜索。

一个有趣的问题……但从到目前为止的响应来看，仍然不清楚最初的问题/目标是什么

这是对问题的有效重新陈述吗

• 已指定开始节点
• 访问每个节点的成本为“1”
• 目标：访问每个节点
• 目标：规划一条成本最低的路线
• 约束：未指定最终节点（可以是任何节点）
• 在产生任何代价之前，算法对图有充分的了解（搜索每一条可能的路径本身不会产生任何代价）

如果这是一个正确的“读”你的问题，然后考虑这些观察：

• 如果“访问节点”的成本为“1”，这与“遍历任何边的成本”为“1”相同……因为“访问节点”和“遍历边”之间存在一对一的对应关系（除非遍历其内部边，否则无法输入节点）
• 如果两个节点没有直接连接，它们仍然是“传递的” “已连接”，因为您可以简单地遍历中间的节点。 （或者：您似乎没有“您可能没有”的约束 重新访问节点“”）

因此：所有节点都是通过某种“距离”进行“连接”的，您希望访问所有节点，同时最小化所走的“距离”

对吗

如果是这样，我认为你的问题几乎就是经典的“旅行商问题”。我看到的唯一区别是，有时TSP的声明要求“开始节点和结束节点相同”。但是——我认为——你允许开始节点和结束节点不同

---

如果这听起来是对的——而且你真的只是想以一种有效的方式“解决”TSP——那么加入到你前面尝试做同样事情的人群中去吧！也许没有比简单地“尝试所有组合，每个组合打分，取最小值”更好的解决方案了.

这是遍历图的所有节点，并计算遍历的最小成本，希望它能帮助您

package capgemni;
/**
*
* @author amit
*/
public class Graphtraversing {
public static void main(String[] args) {
    int res = 0;
    String[] input1= {"A", "B", "C", "D"};
    int[] input2 = {4, 8, 6, 3, 3, 5};

    res = minimum_cost(input1, input2);
    System.out.println(res);

}
static int minimum_cost(String[] input1,int[] input2)
{
    int d = input1.length;
    int costmatrix[][]=new int[input1.length][input1.length];
    int i=0,j=0,k=0;


    for(i=0;i<input1.length;i++){
    for(j=i;j<input1.length;j++){
        costmatrix[i][j]=0;
    }
    }

    for(i=0;i<input1.length;i++){
    for(j=i;j<input1.length;j++){
        if(i==j){
        costmatrix[i][j] = 0;
        }
else{
        costmatrix[i][j] = input2[k];
        k++;
}

    }
    }

for(i=0;i<input1.length;i++){
for(j=0;j<input1.length;j++){
    costmatrix[j][i] = costmatrix[i][j];
}
}

int cost = 0;
int mcost = 0;
int first = 1;
for(i=0; i<input1.length; i++){

for(j=0; j<input1.length; j++){

    cost = cost + costmatrix[i][j];

}
if(first == 1 ){
mcost = cost;
first = 0;
}
else if(cost < mcost){
mcost = cost;
}
cost = 0;
}


    return mcost;
}
}

capgemni包装；
/**
*
*@作者阿米特
*/
公共类Graphtraversing{
公共静态void main（字符串[]args）{
int res=0；
字符串[]input1={“A”、“B”、“C”、“D”}；
int[]input2={4,8,6,3,3,5}；
res=最低成本（输入1，输入2）；
系统输出打印项次（res）；
}
静态int最小成本（字符串[]input1，int[]input2）
{
int d=input1.length；
int costmatrix[][]=新int[input1.length][input1.length]；
int i=0，j=0，k=0；
对于（i=0；iNo，我不这么认为，因为在这种情况下，遍历的顺序很重要。我的想法是我在物理上访问每一个节点。所以从G到H到G到J与从G到H到J是不同的。你可能是对的，我可能在工作了一整天后会过度思考。你是什么意思“穿越的顺序问题“-您需要什么顺序？访问节点是否有相关成本？访问节点的成本是到达该节点所需的步骤数。因此，通过G到H到G到J访问J的成本为3，但G到H到J的成本为2。但我认为rano给出了我要找的答案。感谢他