一篇菜鸡的笔记——Floyd算法简介

Floyd算法介绍

Floyd算法又称为插点法，是一种利用动态规划 的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名

引言

之前讲过Djkstra算法，我们都知道在处理最短路径问题的时候，如果是给定源点的问题，利用Djkstra算法可以很好的解决问题。那如果现在要你知道任意两点之间的最短路径是多少呢？？

举个烂栗子o(●’◡’●)┛

镇长造楼

假设你是一个镇的刚上任的镇长，你们镇有5个村子，分别标号1-5，村子之间有公路，并且任意两个村子之间都是可达的。现在你打算造你豪华的镇政府，由于经常要到每个村子去开会，你想要让你的镇镇府办公楼处在整个镇子的核心位置，所以要在这5个村子里找出一个”中心村"，这个村子到其他任何一个村子的最短路径中，最长的那条路，是最短的。现在问那个村子才有资格成为”中心村“呢？

先来分析一下，什么叫最短路径中最长的那条是最短？听起来很绕口，其实意思很简单，任何两个村子之间都有最短路径，这些最短的路里面总有一条最长的，而你要找的那个村子，它的这条最长路比别的村子都要短，说白了，就是不能太过于偏远，是一个中心村。

那么镇长你才识过人，你要选择哪个村子呢？

首先我们想的是，这是一个最短路问题，我们可不可以用Dijkstra算法呢？答案是一定的！DIjkstra算法能够把一个源点到其他所有点的最短路径算出来，那我们完全可以加一个循环，每个点都算一次Dijkstra不就好了嘛~

可是这个时候有一个人按耐不住自己的小情绪了（小声嘀咕：难道是那位大人？？？咳——跑错片场了），这个人就是我们今天的主角——Floyd。他说：你们也太low了，一个矩阵能解决的问题搞那么复杂干嘛？

我们先来康康一个矩阵能够蕴含多少信息？

因为这里是无向图，所以邻接矩阵是一个对称矩阵，下三角我偷懒就不画粗来了(●’◡’●)

先想想这个矩阵里这些元素代表着什么？瓜众：你把我们当白痴？对！我们现在就把自己当作白痴。
我们都知道，矩阵当前这些元素代表两点之间的距离，（0表示到自身，∞表示不可直达），距离？？？那我问你，再确切一点是什么？？？

直达距离

这个矩阵当前存放的是直接相邻的那些点之间的距离，换而言之，就是两点之间不借助任何其他点 就能到达的最短距离，我们把它称之为 经0可达（我们当前村子编号是从1到5，也就是没有0号村子存在，因此经0可达含义就是直达)。

举一反三，那么既然有经0可达，那有没有经1可达？经2可达？——奖励你一朵小红花 ^o^/

以此类推，经1可达的意思是不是就是经过了1号村子可达的最短距离？
这个时候我们再来看一眼这个矩阵，既然现在我说了，矩阵要求放宽啦~不用直达那么严格，你们可以抱一下1号村子的腿，经过1号村子的路经也可以啦.好的！那我们把目光放到第二行,我们现在要考虑的是2号村子可不可以经过1号村子，产生到达其他村子的更短路？

如图，由于现在是经1可达而1号到2号距离是3，1号到3号距离是1，那么2号是不是可以经过1号，有一条到达3号的长度为4的路径？而当前G【2】【3】（即2到3的已知最短路）是∞，那么就可以很愉快地更新G【2】【3】的值为4了。
同样的，G【2】【5】是不是也在经1可达的环境下，得到了一个更短的路径？

再同样的，第三行，第四行，是不是都可以通过经1可达，更新最短路径了？（当然第一行不用，我经我自己，emmmm,听起来怪怪的，没有任何意义）

好的，到此为止我们把原本的经0可达矩阵升了1级进化成为了更加优秀一点的经1可达矩阵，最短路径都有那么几个被更新了，我们离成功更近了1步。但是只是1步，我们还有几步呢?
猜也能猜出来，这道问题我们需要5步，因为我们有5个点可以经过啊 ，也就是我们可以经1可达，经2可达…最多到经5可达，可以升级5次！等级升级5次之后，我们也就达到了最高等级，这个问题也就解决辽O(∩_∩)O~~

最后得到的矩阵：

（题目数据出的不好，经1可达已经是最优了( ╯□╰ )）

一开始我们拿到的矩阵潜在的信息有很多，通过我们对它地一层层、一步步的分析、挖掘，来更新、演进已有的信息。就像我们玩游戏，一开始的时候，我们好多技能都是隐藏的，但是等到我们等级上去了，技能也就一个个被解锁了。这是一个动态的思想，它体现出来的便是一个循序渐进的过程，我们不可能一步登天，但是我们可以一步步登天，我们不可能一下子就完美地解决问题，我们可以一层层分析处理问题。

呦吼！这不就是动态规划吗

这就是Floyd算法的基本思想，一个小小的矩阵，经过若干次演变，就可以把原先很复杂的循环Dijkstra完美地解决。

所以最后聪(you)明(qian)的镇长将会选择在1、2号村中的一个建造他的豪华办公大楼。

接下来附上Floyd算法的实现代码：

bool Floyd( MGraph Graph, WeightType D[][MaxVertexNum], Vertex path[][MaxVertexNum] )
{
    Vertex i, j, n;
 
    /* 初始化 */
    for ( i=1; i<=Graph->Nv; i++ )
        for( j=1; j<=Graph->Nv; j++ ) {
            D[i][j] = Graph->G[i][j];
            path[i][j] = -1;
        }
 
    for( n=1; n<=Graph->Nv;n++ )/*经n可达*/
        for( i=1; i<=Graph->Nv; i++ )
            for( j=1; j<=Graph->Nv; j++ )
                if( D[i][n] + D[n][j] < D[n][j] ) {
                    D[i][n] = D[i][n] + D[n][j];
                    if ( i==j && D[i][j]<0 ) /* 若发现负值圈 */
                        return false; /* 不能正确解决，返回错误标记 */
                    path[i][j] = n;
                }
    return true; /* 算法执行完毕，返回正确标记 */
}

举个不烂的栗子o(●’◡’●)┛

哈利·波特的考试

作者: 陈越
单位: 浙江大学
时间限制: 400 ms
内存限制: 64 MB
代码长度限制: 16 KB

哈利·波特要考试了，他需要你的帮助。这门课学的是用魔咒将一种动物变成另一种动物的本事。例如将猫变成老鼠的魔咒是haha，将老鼠变成鱼的魔咒是hehe等等。反方向变化的魔咒就是简单地将原来的魔咒倒过来念，例如ahah可以将老鼠变成猫。另外，如果想把猫变成鱼，可以通过念一个直接魔咒lalala，也可以将猫变老鼠、老鼠变鱼的魔咒连起来念：hahahehe。

现在哈利·波特的手里有一本教材，里面列出了所有的变形魔咒和能变的动物。老师允许他自己带一只动物去考场，要考察他把这只动物变成任意一只指定动物的本事。于是他来问你：带什么动物去可以让最难变的那种动物（即该动物变为哈利·波特自己带去的动物所需要的魔咒最长）需要的魔咒最短？例如：如果只有猫、鼠、鱼，则显然哈利·波特应该带鼠去，因为鼠变成另外两种动物都只需要念4个字符；而如果带猫去，则至少需要念6个字符才能把猫变成鱼；同理，带鱼去也不是最好的选择。

输入格式:

输入说明：输入第1行给出两个正整数N (≤100)和M，其中N是考试涉及的动物总数，M是用于直接变形的魔咒条数。为简单起见，我们将动物按1~N编号。随后M行，每行给出了3个正整数，分别是两种动物的编号、以及它们之间变形需要的魔咒的长度(≤100)，数字之间用空格分隔。

输出格式:

输出哈利·波特应该带去考场的动物的编号、以及最长的变形魔咒的长度，中间以空格分隔。如果只带1只动物是不可能完成所有变形要求的，则输出0。如果有若干只动物都可以备选，则输出编号最小的那只。

输入样例:

6 11
3 4 70
1 2 1
5 4 50
2 6 50
5 6 60
1 3 70
4 6 60
3 6 80
5 1 100
2 4 60
5 2 80

输出样例:

4 70

姥姥出的题，看着就是有意思。很明显的一个多源无权图最短路的问题。最后问的是要带哪只动物，意思就是找出一只变成其他动物的最短咒语中最长的那条是最短的的动物，这和我上面举的那个”中心村“的（烂）栗子意思是一样的，还是要先算出任意两点的最短路，也就是那个经n矩阵。如果一只动物是不可能完成考试，意思就是有孤立点，也就是图不连通嘛。

由于本文为博主的作业题，发文时还处于查重阶段，博主又比较菜，不会改代码，所以仅附上伪代码和思路，后续会更，请见谅~只想帮助其他为题目集困扰的童鞋，顺便加深自己对与题目的理解 ( ^_)。
附上题目伪代码：

#include <stdio.h>
#include <stdlib.h>

#define INFINITY 1000000
#define MaxVertexNum 101  /* maximum number of vertices */
typedef int Vertex;      /* vertices are numbered from 0 to MaxVertexNum-1 */
typedef int WeightType;
typedef enum {false, true} bool;
typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;
    int Ne;
    WeightType G[MaxVertexNum][MaxVertexNum];
};
typedef PtrToGNode MGraph;

bool Floyd( MGraph Graph, WeightType D[][MaxVertexNum], Vertex path[][MaxVertexNum] )
{
    Vertex i, j, n;
 
    /* 初始化 */
    for ( i=1; i<=Graph->Nv; i++ )
        for( j=1; j<=Graph->Nv; j++ ) {
            D[i][j] = Graph->G[i][j];
            path[i][j] = -1;
        }
 
    for( n=1; n<=Graph->Nv;n++ )/*经n可达*/
        for( i=1; i<=Graph->Nv; i++ )
            for( j=1; j<=Graph->Nv; j++ )
                if( D[i][n] + D[n][j] < D[n][j] ) {
                    D[i][n] = D[i][n] + D[n][j];
                    if ( i==j && D[i][j]<0 ) /* 若发现负值圈 */
                        return false; /* 不能正确解决，返回错误标记 */
                    path[i][j] = n;
                }
    return true; /* 算法执行完毕，返回正确标记 */
}
MGraph ReadG(void)
{
    MGraph G=(MGraph)malloc(sizeof(struct GNode));
    scanf("%d%d",&G->Nv,&G->Ne);
    int i,j;
    for(i=1;i<=G->Nv;i++)
    {
        //初始化 
    }
    for(i=0;i<G->Ne;i++)
    {
        scanf("%d%d%d",&a,&b,&x);
       //边录入 
    }

    return G;
}
int main()
{
    MGraph G=ReadG();
    WeightType **D;
    Vertex  **path;
   	int f=Floyd(G,D,path);
    
    if(f)
    {
        int max[MaxVertexNum]={0};
        // 存储每只动物最短路径中最长的那条 
        for(所有其他点)
        {
           更新max; 
        }
        int min;
		//最小的那只动物的标号 
        for(所有动物)
        {
            更新min 
        }
        printf("%d %d\n",min,max[min]);
    }
    else
    printf("0\0");
    
    
    return 0;
}