Floyd算法

/*
* date : 2020 .7.9
* theme : floyd算法
(1) 弗洛伊德算法的最外层k保证顺序即可

（2） 弗洛伊德算法是基本的动态规划思想，所作的是不断的更新i j 之间的距离 ，所有的节点都要被修改，最后才是正确的，因此如果是计算
一个特定的点的话，并不推荐 时间复杂度在o(n三次方)， 可以考虑结合vector一起使用。 
*/
#include <iostream>
#define N 10
#define INF 100
int p[N][N];
int p1[N][N];
//定义距离
void floyd(int n)
{
    for (int k = 0; k < n; k++)
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (i != k && k != j && i != j)
                {
                    if (p[i][j] > p[i][k] + p[k][j])
                    {
                        p[i][j] = p[i][k] + p[k][j];
                    }
                }
            }
        }
    }
}
void floyd2(int n)
{
    for (int k = n - 1; k >= 0; k--)
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (i != k && k != j && i != j)
                {
                    if (p1[i][j] > p1[i][k] + p1[k][j])
                    {
                        p1[i][j] = p1[i][k] + p1[k][j];
                    }
                }
            }
        }
    }
}
void print(int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = i+1; j < n; j++)
        {
                std::cout << "p[" << i << "][" << j << "] is " << p[i][j] << std::endl;
            
        }
    }
}

void print2(int n){
    for (int i = 0; i < n; i++)
    {
        for (int j = i+1; j < n; j++)
        {
                std::cout << "p1[" << i << "][" << j << "] is " << p1[i][j] << std::endl;
            
        }
    }
}
int main()
{
    int number, edge;
    std::cin >> number >> edge;
    //输入节点的个数
    int weight;
    int node1, node2;
    for (int i = 0; i < number; i++)
    {
        for (int j = 0; j < number; j++)
        {
            p[i][j] = INF;
            p1[i][j] = INF;
        }
    }
    for (int i = 0; i < edge; i++)
    {
        std::cin >> node1 >> node2 >> weight;
        p[node1][node2] = p[node2][node1] = weight;
        p1[node1][node2] = p1[node2][node1] = weight;
    }
    floyed(number);
    std::cout<<"p is "<<std::endl;
    print(number);
    floyed2(number);
    std::cout<<"p1 is "<<std::endl;
    print2(number);
}

$其实也可以将k这个循环认为是可以通过的过渡节点，这个文章是为了比较k$$升序与降序的不同之处，结果应该是相同的$