C# 如何计算两个顶点之间的所有最短路径？

因此，如果我在一个图中有两个顶点，它们通过多条边连接，而它们之间有相同的最短路径（即，如果我有节点a和节点B，它们直接通过三条边连接（它们之间有3条最短路径，每条路径的距离为1），那么计数应返回3）我如何修改BFS算法来实现这一点？这是我的代码，它只计算两个节点之间的最短路径，而不计算这些最短路径的数目

public void BFSDegree(Graph g, string s, string p)
    {
        Queue<string> q = new Queue<string>();
        dist.Add(s, 0);       
        q.Enqueue(s);

        while (q.Count() != 0)
        {
            string j = q.Dequeue();
            foreach (string h in g.adjacentTo(j))
            {
                if (!dist.ContainsKey(h))
                {
                    q.Enqueue(h);
                    dist.Add(h, 1 + dist[j]);
                }

                if (j == p)
                {
                    Console.WriteLine("               " + dist[j]);
                    return;
                }
            }
        }
    }

public void BFSDegree（图g、字符串s、字符串p）
{
队列q=新队列（）；
添加区（s，0）；
q、 排队;；
而（q.Count（）！=0）
{
字符串j=q.Dequeue（）；
foreach（g中的字符串h与（j）相邻）
{
如果（！dist.ContainsKey（h））
{
q、 排队（h）；
dist.Add（h，1+dist[j]）；
}
如果（j==p）
{
Console.WriteLine（“+dist[j]）；
返回；
}
}
}
}

在

foreach

之前，初始化一个变量

int-pathCount=0

然后，代替
返回增量
路径计数

在执行
foreach
之后，检查是否
pathCount>0
，如果是，则返回它。当然，您必须将返回类型更改为
int
如果节点u具有x条最短路径，则通过它发现的相邻节点v将具有x乘以y条最短路径，其中y是从u到v的边数。此外，如果v可通过其他相邻节点（具有相同的路径长度）到达，则其最短路径的计数将是为每个父节点计算的所有xy因子的总和

因此，该算法将与您的原型完全不同。我建议使用一个主循环，在每次迭代中增加当前长度，然后通过查看队列中节点的所有未访问的相邻节点来处理队列，计算每个相邻节点的xy因子之和，然后清除队列并搜索所有相邻节点（并将其标记为已访问）用于下一次迭代。在第一次迭代中，路径长度为0，队列仅包含源节点

public void BFSDegree(Graph g, string s, string p)
{
    Queue<string> q = new Queue<string>();
    HashMap<string, int> path_counts = new HashMap<string, int>();
    path_counts.put(s, 1);       
    q.Enqueue(s);

    while (q.size()>0)
    {
        HashMap<string, int> adj_nodes = new HashMap<string, int>();
        foreach (string j in q) 
        {
            foreach (string h in g.adjacentTo(j))
            {
                if (!path_counts.ContainsKey(h))
                {
                    int count = 0;
                    if (adj_nodes.containsKey(h))
                        count=adj_nodes.get(h);
                    count += path_counts.get(j);
                    adj_nodes.put(h, count);
                }
            }
        }
        if (adj_nodes.containsKey(p))
        {
            Console.WriteLine("               " + adj_nodes.get(p));
            return;
        }
        path_counts.putAll(adj_nodes);
        q.clear();
        q.addAll(adj_nodes.keySet());
    }
}

public void BFSDegree（图g、字符串s、字符串p）
{
队列q=新队列（）；
HashMap path_counts=新HashMap（）；
路径_计数put（s，1）；
q、 排队;；
而（q.size（）>0）
{
HashMap adj_节点=新HashMap（）；
foreach（q中的字符串j）
{
foreach（g中的字符串h与（j）相邻）
{
如果（！path_counts.ContainsKey（h））
{
整数计数=0；
if（调整节点.容器（h））
count=adj_nodes.get（h）；
计数+=路径计数。获取（j）；
adj_节点put（h，count）；
}
}
}
if（adj_nodes.containsKey（p））
{
Console.WriteLine（“+adj_nodes.get（p））；
返回；
}
path_counts.putAll（adj_节点）；
q、 清除（）；
q、 addAll（adj_nodes.keySet（））；
}
}
似乎在您当前执行
返回操作的地方，您可以增加一个计数器，在
之前设置为零，然后在
之后使用该计数器值进行返回，如果计数器大于零。哟，请参见下面的“我的答案”查看下面的“我的答案”谢谢！我有一个问题，虽然我不熟悉c#中的HashMaps，也不确定c#中是否存在HashMap类，但我认为这段代码是用java编写的？但是我知道它可以在c#中翻译为类字典，我可以翻译除putAll函数和addAll函数之外的所有函数，就像字典类中有它们的等价物吗？是的，我在我给出的代码片段中使用了Java集合，但是你可以很容易地转换为c#-参见这里：对于队列，您也可以做同样的事情（使用foreach循环将来自adj_节点的所有键排队）。如果你觉得这个答案有用，请投赞成票