求最短路径——DFS+Floyd算法

1），深度或广度优先搜索算法（解决单源最短路径）
从起始结点开始访问所有的深度遍历路径或广度优先路径，则到达终点结点的路径有多条，取其中路径权值最短的一条则为最短路径。
2），弗洛伊德算法（解决多源最短路径）：时间复杂度O(n^{3),空间复杂度O(n}2)
基本思想：最开始只允许经过1号顶点进行中转，接下来只允许经过1号和2号顶点进行中转…允许经过1~n号所有顶点进行中转，来不断动态更新任意两点之间的最短路程。即求从i号顶点到j号顶点只经过前k号点的最短路程。

分析如下：1，首先构建邻接矩阵Floyd[n+1][n+1]，假如现在只允许经过1号结点，求任意两点间的最短路程，很显然Floyd[i][j] = min{Floyd[i][j], Floyd[i][1]+Floyd[1][j]}
2，接下来继续求在只允许经过1和2号两个顶点的情况下任意两点之间的最短距离，在已经实现了从i号顶点到j号顶点只经过前1号点的最短路程的前提下，现在再插入第2号结点，来看看能不能更新更短路径，故只需在步骤1求得的Floyd[n+1][n+1]基础上，进行Floyd[i][j] = min{Floyd[i][j], Floyd[i][2]+Floyd[2][j]}；…
3，很显然，需要n次这样的更新，表示依次插入了1号，2号…n号结点，最后求得的Floyd[n+1][n+1]是从i号顶点到j号顶点只经过前n号点的最短路程

#include<bits/stdc++.h>
#define nmax 1000
#define INF 99999999
using namespace std;
//邻接矩阵存储
int n,m,minPath, edge[nmax][nmax];//边数，节点数，最短路径，邻接矩阵
int mark[nmax];//节点访问标记

void dfs(int cur,int dis)//深搜找最短路径,cur是节点数，dis是距离
{
    if(minPath<dis)
        return;//当前走过路径大于之前最短路径，没必要再走下去
    if(cur==n){//节点数到达最大（临界条件）
        if(minPath>dis)
            minPath=dis;//最后更新最短路径
        return;//返回结束
    }
    else{
        for(int i=1;i<=n;i++){
            if(edge[cur][i]!=INF && edge[cur][i]!=0 && mark[i]==0 )//如果两点之间有路径且该点没被访问过
            {
                mark[i]=1;//标记访问过；
                dfs(i,dis+edge[cur][i]);
                mark[i]=0;//最重要的一步！回溯完要重新标记
            }
        }
        return;
    }
}

int Floyd()//弗洛伊德算法
{
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(edge[i][k]<INF && edge[k][j]<INF && edge[i][j]>edge[i][k]+edge[k][j])
                    //两点到任意一点有距离，且经过中间点的距离小于两点之间直接的距离
                    edge[i][j]=edge[i][k]+edge[k][j];//更新
            }
        }
    }

    return edge[1][n];
}

int main()
{
    while(cin >> n >> m && n != 0){
        //初始化邻接矩阵
        int i, j;
        for(i = 1; i <= n; i++){
            for(j = 1; j <= n; j++){
                edge[i][j] = INF;
            }
            edge[i][i] = 0;
        }
        int a, b;
        while(m--){
            cin >> a >> b;
            cin >> edge[a][b];
        }
        //以dnf(1)为起点开始递归遍历
        memset(mark, 0, sizeof(mark));
        minPath = INF;
        mark[1] = 1;
        dfs(1, 0);
        cout << minPath << endl;
    }
}