floyd算法模板HDU1869and求最小环HDU1599

作用：求出图中任意两节点间的最短路径。

时间复杂度：o（n^3);

空间复杂度：o（n^2); mp[i][j]代表从i到j的最短路

算法思想：动态规划

　　　　　　从i到j  经过k节点或者不经过k节点

　　　　　　若经过k  则 mp[i][j]=mp[i][k]+mp[k][j];

　　　　　　else  　　　mp[i][j]保持不变

floyd的模板

void floyd()
{
    for(int k=0;k<n;k++)
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                mp[i][j]=min(mp[i][j],mp[i][k]+mp[k][j]);
}

　　floyd算法的优点：简单好写

　　缺点：空间时间复杂度太高，用邻接矩阵很好写，用链式前向星就不太好写了。

以下为HDU1869代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=105,INF=10000000;
int mp[maxn][maxn];
int n,m,a,b;
void input()
{
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            mp[i][j]=INF;

    while(m--)
    {
        cin>>a>>b;
        mp[a][b]=mp[b][a]=1;
    }
}

void floyd()
{
    for(int k=0;k<n;k++)
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                mp[i][j]=min(mp[i][j],mp[i][k]+mp[k][j]);
}

int main()
{
    while(cin>>n>>m)
    {
        bool flag = 0;
        input();
        floyd();
        for(int i=0;i<n&&!flag;i++)
            for(int j=0;j<n&&!flag;j++)
                if(mp[i][j]>7){
                    cout<<"No"<<endl;
                    flag=1;
                    break;
                }
        if(!flag) cout<<"Yes"<<endl;
    }


    return 0;
}

！！ 求最小环

环 即从 i 点经过若干点后回到 i 点

经过   j  点和  k点  回到i点的方程是    dis[i][j]+mp[j][k]+mp[k][i];

以下是floyd求最小环的代码

void floyd()
{
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<k;i++)
            for(int j=i+1;j<k;j++)          //成环的序列一定有大小顺序 只要保证i j k 不同就行了
                minn=min(minn,dis[i][j]+mp[j][k]+mp[k][i]);//经过j和k点回到起点的最小值
        for(int i=1;i<=n;i++)              //普通floyd求两点最短路
            for(int j=1;j<=n;j++)               //在一个循环里  经过k点的dis被更新，下一个循环才会被求最小环使用
                dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
    }
}

/***
    *floyd求最小环
    *mi =min(mi,dis[i][j]+mp[j][k]+mp[k][i]);
    *mi 遍历所有边
******/
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105,INF=100000000;
int n,m,a,b,c,minn,mp[maxn][maxn],dis[maxn][maxn];

void input()
{
    minn=INF;
    for(int i=0;i<=n;i++)
        for(int j=0;j<=n;j++)
            mp[i][j]=dis[i][j]= INF;
    while(m--)
    {
        scanf("%d%d%d",&a,&b,&c);
        if(c<mp[a][b]){
            mp[a][b]=mp[b][a]=dis[a][b]=dis[b][a]=c;
        }
    }
}

void floyd()
{
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<k;i++)
            for(int j=i+1;j<k;j++)          //成环的序列一定有大小顺序 只要保证i j k 不同就行了
                minn=min(minn,dis[i][j]+mp[j][k]+mp[k][i]);//经过j和k点回到起点的最小值
        for(int i=1;i<=n;i++)              //普通floyd求两点最短路
            for(int j=1;j<=n;j++)               //在一个循环里  经过k点的dis被更新，下一个循环才会被求最小环使用
                dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
    }
}

int main()
{
    while(cin>>n>>m)
    {
        input();
        floyd();
        if(minn==INF)cout<<"It's impossible."<<endl;
        else cout<<minn<<endl;
    }
}