图——所有顶点间的最短路径

floyd算法，求任意两点间最短距离

 

//算法思想：floyd是动态规划算法，cost[i][j],表示i,j间的最短路径，
//对cost不断更新，每次更新是让 i->j 经过k(0,n),
//比如：在k次更新时，即i->j 经过k，如果 i->k->j 比 i>k-1>j(上一次k-1时更新)要小，则设置cost[i][j],表示经过k，有最短路径
//则样不断重复 k=n 次循环，则可算出，cost[i][j] 最短路径，每个经过的点，都是在(0,n)中，选出最小的。
//时间复杂度O(n^3)

void Graph::Floyd()
{
    int MAX_INF=10000;
    int cost[max_vertexs][max_vertexs];        //两点间最短距离代价矩阵
    int path[max_vertexs][max_vertexs];        //最短距离，经过的中间节点

    int n=vertex;
    for (int i=0;i<n;i++)
        for(int j=0;j<n;j++)
        {
             cost[i][j]=(graph[i][j]>0||i==j)?graph[i][j]:MAX_INF;
             path[i][j]=-1;        
        }
    
    for(int k=0;k<n;k++)
    {
        //更细cost，中间经过k节点
        for (int i=0;i<n;i++)
        for (int j=0;j<n;j++)
        {
            //经过k,cost[i][j]更优化
            if(cost[i][k]+cost[k][j]<cost[i][j])
            {
                cost[i][j]=cost[i][k]+cost[k][j];
                path[i][j]=k;
            }
        }
    }

    for (i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
            cout<<cost[i][j]<<' ';
        cout<<endl;
    }

    cout<<"**********************"<<endl;

    for (i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
            cout<<path[i][j]<<' ';
        cout<<endl;
    }

    stack<int> stack;    //依次进栈2次j,i,表示从路径要经过i->j
    Queue<int> queue;    //重i->j 之间要经过的节点

    for (i=0;i<n;i++)
    for (int j=0;j<n;j++)
    {
        //没有路径
        if (i==j)
        {
            continue;
        }
        else if (cost[i][j]>=MAX_INF)
        {
            printf("v%d-->v%d : has no path!\n",i,j);
            continue;
        }
        else
        {
            //寻找i和j间的最短路径
            printf("v%d-->v%d : path is:(",i,j);
            
            //初始化
            stack.push(j);
            stack.push(i);
            queue.push(i);
            
            int from,to;
            while (1)
            {
                if (stack.isEmpty())
                {
                    break;
                }
                
                from=stack.Top();
                stack.pop();
                to=stack.Top();
                stack.pop();
                
                int mid=path[from][to];
                if (mid>0)
                {
                    //from to 有中间结点
                    stack.push(to);
                    stack.push(mid);
                    stack.push(mid);
                    stack.push(from);
                }
                else
                {
                    queue.push(to);
                }
                
            }
            
            //输出从 i->j 的路径
            while(!queue.isEmpty())
            {
                printf("v%d ",queue.Front());
                queue.pop();
            }
            
            printf(") length : %d\n",cost[i][j]);

        }

    }

}