C#的Floyd应用，并输出各有向边被最短路径使用次数

       Floyd作为一种基础的算法，我在做作业时发现其在C#中的应用文章很少，并且较多解释性不强，不易理解，因此有意发布本篇文章，方便之后需要利用C#应用Floyd算法的朋友。本文旨在将代码分享（可直接套用），不对Floyd再做解释，敬请见谅！

       课程内需要对一个有向网图进行求解最短路长度，并输出各有向边被最短路使用的次数。本篇分享代码可实现：

①利用Floyd算法将各点对间的最短路长度以矩阵形式输出
②输出各点对间最短路径
③利用自定义方法求解各边被最短路径使用次数，并以矩阵形式输出       

       关于各有向边被最短路径使用次数，要了解为什么要求这个，本人的理解是：对各有向边被最短路径使用次数了解后，可以获知各边的重要程度。如在交通网中，该路段则可能交通量大，路面易被损坏，需要勤加管理，同时被最短路径使用次数多的边也是最易最先产生交通拥堵。

       在编码之前，我参考了(3条消息) C# 弗洛伊德(Floyd)算法_weixin_30718391的博客-CSDN博客

(3条消息) 基于C#的Floyd最短路径算法_m0_37863265的博客-CSDN博客  两位前辈的文章，但囿于部分字段的解释性不强，输出结果不正确等原因，我以上述两篇为基础编写了本篇代码，并能够顺利通过控制台输出正确结果。如尚存在语言晦涩难懂，解释不够准确，还望评论处指正，谢谢😁！

ps：数组的第0个元素计入了边的信息,如G[0,10]意为V0点到第V10点的有向边。

using System;

namespace 运筹学_弗洛伊德             //图为有向图
{
    class Program
    {
        static double infinite = 1.0 / 0.0;//定义的无穷数
        static int[,] countE = new int[24, 24]; //定义的统计数组，想拿这个来统计各边被最短路径使用过多少次
        struct Dist
        {
            public double length;//包含路径长度信息           
            public int pre;//包含最短路径点的信息                 //定义存储边信息的结构
        }
        class Floyd
        {

            public static Dist[,] GetFloyd(double[,] G)
            {
                int i, j, v;               //for循环语句中的循环数
                int N = G.GetLength(0);    //获取邻接矩阵行数（邻接矩阵为方阵，因此获取的也是列数）
                Dist[,] D = new Dist[N, N];
                for (i = 0; i < N; i++)
                {
                    for (j = 0; j < N; j++)
                    {                      
                        D[i, j].length = G[i, j];       
                        D[i, j].pre = -1;
                    }     
                }
                //以上对D[I,J]进行初始化（D[I,J]为I点到J点的距离，D[i,j].pre用以之后检索最短路径上各点）
                for (v = 0; v < N; v++)
                {
                    for (i = 0; i < N; i++)
                    {
                        for (j = 0; j < N; j++)
                        {
                            if (D[i, j].length > (D[i, v].length + D[v, j].length))
                            {
                                D[i, j].length = D[i, v].length + D[v, j].length;
                                D[i, j].pre = v;          
                            }
                        }    
                    }          
                }
                //以上为弗洛伊德核心步骤，进行迭代，更新各点之间最短距离的三重循环
                return D;
            }
        }
       
        static void Ppath(Dist[,]path ,int i,int j,int[,]count)   // 前向递归查找各点对最短路径上的顶点
        {
            int k;
            k = path[i, j].pre;
            if (k == -1)
            {
                count[i, j]++;            //统计各边被最短路径的使用次数
                return;
            }
          // 找到了起点则返回
            Ppath(path, i, k,count); // 找顶点k的前一个顶点
            Console.Write("->{0}", k);     // 输出路径上的各点
            Ppath(path, k, j,count);     // 找顶点j的前一个顶点
        }
        //关于以上，由于未知循环次数（for语句不便使用），且循环条件不明确（while语句使用不便），因此采用方法内嵌套方法的循环


        static void Main(string[] args)           //主方法
        {
            Console.WriteLine("以下为各点对最短路长度矩阵");
            double[,] g = new double[24, 24] {
        };      //在此处输出邻接矩阵，我在完成作业时得到图为有24个点的有向图，因此为24*24的方阵；在输入邻接矩阵时，注意：第i行第j列为i点到j点的距离，若i=j，相应元素为0，若i到j无边，则写为infinite（在前文中已定义其为无限大）
            var D = Floyd.GetFloyd(g);
            var count = 0;
            foreach (var item in D)
            {
                Console.Write(item.length);
                Console.Write(" ");
                count++;
                if (count % D.GetLength(1) == 0)
                {
                    Console.WriteLine();
                } 
            }                                         
            Console.WriteLine();
            //输出i点到j点的最短路径长度

            for (int i = 0; i <D.GetLength(0); i++)
            {
                int m = i;
                for (int j = 0; j < D.GetLength(1); j++)
                {
                    if (D[i,j].length == infinite)
                    {
                        Console.WriteLine(i + "点到" + j + "点无最短路径");
                    }
                    else if (i != j)   //不输出点与点自身的最短路径
                    {
                        Console.WriteLine(i + "点到" + j + "点的最短路径为");
                        Console.Write(i);
                        Ppath(D,i,j,countE);
                        Console.WriteLine("->"+j);
                        i = m;
                    }
                }
            }
            //以上为输出各点对间最短路径
            for (int i = 0; i <D.GetLength(0); i++)
            {
                for (int j = 0; j < D.GetLength(1); j++)
                { if (i == j)
                        countE[i, j] =0;

                }
            }//令点与自身的边被利用次数为0

            for (int i = 0; i < D.GetLength(0); i++)
            {
                for (int j = 0; j < D.GetLength(1); j++)
                {
                    {
                        Console.Write(countE[i, j] + "  ");
                        if (j ==D.GetLength(1)-1)
                            Console.WriteLine();
                    }
                }
            }
            //以上为输出各边被利用次数矩阵，第i行第j列，表示i点到j点边被最短路径利用次数利用次数

            Console.WriteLine("运行完毕！");
            Console.ReadKey();
        }
    }
}