最短路径（Dijkstra和Floyd）

Floyd算法（有点类似dp的思想）Floyd（弗洛伊德）算法的基本思想是：对一个顶点个数为n的有向网（或无向网），设置一个n×n的方阵A，其中除对角线的矩阵元素都等于外，其他元素A(k)[i][j] (i≠j)表示从顶点vi到顶点vj的有向路径长度.（时间复杂度为O（n^3））

int edge[M][M];//邻接矩阵    同时可以记录从i到j最短路径

for(i=1;i<=n;i++)//矩阵初始化
        {
            for(j=1;j<=n;j++)
            {

                 if(i==j)
                {
                    edge[i][j]=0;
                    continue;
                }
               edge[i][j]=INF;
            }
        }

for(k=1;k<=n;k++)//  k为借助的中间点 
        {
            for(i=1;i<=n;i++)
            {
                for(j=1;j<=n;j++)
                {
                    if(k==i||k==j)
                        continue;
                    edge[i][j]=Min(edge[i][j],edge[i][k]+edge[k][j]);    //这块自己感觉就是dp，edge[i][j]存储的为从i到j的最短路径，从A到C最短路径取edge[i][j]（直达）和

                                                                                                       //edge[i][k]+edge[k][j](借助中间点k   非直达)的最小值
                }
            }
        }

Dijkstra算法(记录的是从源点v0到其他各个顶点的最短路径，而Floyd算法的edge数组记录的从i到j的最短路径。（时间复杂度（O（n^2）））

int edge[MAXN][MAXN];//邻接矩阵
int dis[MAXN];//记录当前找到的从源点v0到终点vi的最短路径的长度，初始时，dist[i]为Edge[v0][i]，即邻接矩阵的第v0行。
int S[MAXN];//标记有没找到最短路径  如找到s[i]=1,else s[i]=0;   初始时，S[v0]为1，其余为0，表示最初集合S中只有顶点v
int max;
void Dijkstra(int v0)//求顶点v0到其他顶点的最短路径
{
    int i,j,k;
    for(i=1;i<=max;i++)
    {
        S[i]=0;
        dis[i]=edge[v0][i];
    }
    S[v0]=1;
    dis[v0]=0;
    for(i=1;i<=max-1;i++)//从顶点v0确定n-1条最短路径   所以只用循环max-1次
    {
        int min=INF;
        int u=v0;        //u为最小的还未找到最短路径的点

         //选择当前集合T中具有最短路径的顶点u
        for(j=1;j<=max;j++)
        {
            if(!S[j]&&dis[j]<min)
            {
                u=j;min=dis[j];
            }
        }
        S[u]=1;     //表示u点的最短路径已经找到

        //不断修改dis数组值    每次k循环完都是当前这个i循环下的最优解

        for(k=1;k<=max;k++)
        {
            if(!S[k]&&edge[u][k]<INF&&(dis[u]+edge[u][k]<dis[k]))  
            {
                dis[k]=dis[u]+edge[u][k];
            }
        }
    }
}

该数组初始化和Floyd算法一样

for(i=0;i<=MAXN;i++)
        {
            for(j=0;j<=MAXN;j++)
            {
                if(i==j)
                {
                    edge[i][j]=0;
                    continue;
                }
              edge[i][j]=INF;
            }
        }