最短路的一些理解

dij是单源的，只是从一个顶点出发到其它点的最短距离，并且它的全值都是正的，不能够有负值；

Bellman-ford 也是单源的，但是他能够完成负权值的图，这是dij无法达到的，并且能够判断是否存在负环，经过修改可以求最长路；
SPFA是在Bellman-ford上优化的，所以跟快；

floyd算法可以求出任意两点的最短路，索然dij对每个点一次for也能求出，但是复杂度O(n^3)或O(n^2+ne),一次floyd也是O(n^3),
但是floyd更加易懂，简洁；floyd允许带负值的边，但不能有回路（环）；floyd很灵活，可以多种变换；

（个人的理解 不是很深，只懂一点）

poj3268
很多牛，要到x这个点，来回多少时间；
正向，反向2次SPFA，2个值相加，然后取最大；
#include<STDIO.H>
#include<string.h>
#include<queue>
#define INF 999999999
using namespace std;
struct node
{
    int v;
    int val;
    int next;
}edge1[100003],edge2[100003];
int head1[1003],dis1[1003],head2[1003],dis2[1003];
int n,m,t,index1,index2;
void add1(int x,int y,int z)
{
    int i,j;
    edge1[index1].v=y;
    edge1[index1].val=z;
    edge1[index1].next=head1[x];
    head1[x]=index1++;
}
void add2(int x,int y,int z)
{
    int i,j;
    edge2[index2].v=y;
    edge2[index2].val=z;
    edge2[index2].next=head2[x];
    head2[x]=index2++;
}
void SPFA1(int u)
{
    int vis[1003],i,j;
    memset(vis,0,sizeof(vis));
    queue<int>q;
    for(i=1;i<=n;i++)
        dis1[i]=INF;
    dis1[u]=0;
    vis[u]=1;
    q.push(u);
    while(!q.empty())
    {
        int v=q.front();
        q.pop();
        vis[v]=0;
        for(i=head1[v];i!=-1;i=edge1[i].next)
        {
            int tmp=edge1[i].v;
            if(dis1[tmp]>dis1[v]+edge1[i].val)
            {
                dis1[tmp]=dis1[v]+edge1[i].val;
                if(!vis[tmp])
                {
                    q.push(tmp);
                    vis[tmp]=1;
                }
            }
        }
    }
}
void SPFA2(int u)
{
    int vis[1003],i,j;
    memset(vis,0,sizeof(vis));
    queue<int>q;
    for(i=1;i<=n;i++)
        dis2[i]=INF;
    dis2[u]=0;
    vis[u]=1;
    q.push(u);
    while(!q.empty())
    {
        int v=q.front();
        q.pop();
        vis[v]=0;
        for(i=head2[v];i!=-1;i=edge2[i].next)
        {
            int tmp=edge2[i].v;
            if(dis2[tmp]>dis2[v]+edge2[i].val)
            {
                dis2[tmp]=dis2[v]+edge2[i].val;
                if(!vis[tmp])
                {
                    q.push(tmp);
                    vis[tmp]=1;
                }
            }
        }
    }
}
int main()
{
    int i,j;
    while(scanf("%d%d%d",&n,&m,&t)!=EOF)
    {
        index1=index2=1;
        memset(dis1,0,sizeof(dis1));
        memset(head1,-1,sizeof(head1));
        memset(dis2,0,sizeof(dis2));
        memset(head2,-1,sizeof(head2));
        for(i=0;i<m;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            add1(x,y,z);
            add2(y,x,z);
        }

        SPFA1(t);

        /*for(i=1;i<=n;i++)
        printf("%d ",dis1[i]);
        printf("\n");*/

        SPFA2(t);

        /*for(i=1;i<=n;i++)
        printf("%d ",dis2[i]);printf("\n");*/

        int max=0;
        for(i=1;i<=n;i++)
        {
            if(max<dis2[i]+dis1[i])
                max=dis2[i]+dis1[i];
        }
        printf("%d\n",max);
    }
}

 

/*poj2570
floyd算法来找到所有可能的路径；
用二进制26位表示路径；
0000000000.......111，这个表示abc;
floyd时 map[i][j]|=map[i][k]&map[k][j];
|表示有新的路径 那么就合并路径，&表示存在这个路；
最后遍历26个字母即可；*/
//poj2570
#include<stdio.h>
#include<string.h>
int map[203][203];
int n;
int main()
{
    int i,j,l,x,y;
    while(scanf("%d",&n)!=EOF)
    {
        if(!n)break;
        memset(map,0,sizeof(map));
        char s[50];
        while(1)
        {
            x,y;
            scanf("%d %d",&x,&y);
            if(x==0&&y==0)
                break;
            scanf("%s",s);
            l=strlen(s);
            for(i=0;i<l;i++)
            {
                map[x][y]|=1<<(s[i]-'a');
            }
        }
        //floyd
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
                for(int k=1;k<=n;k++)
                {
                    map[j][k]|=(map[j][i] & map[i][k]);
                }
        char ii;
        while(1)
        {
            scanf("%d %d",&x,&y);
            if(x==0&&y==0)break;
            for(ii='a';ii<='z';ii++)
            {
                if(map[x][y] & (1<<(ii-'a')))
                {
                    printf("%c",ii);
                }
                
            }
            if(!map[x][y])
            {
                printf("-");
            }
            putchar('\n');
        }
        putchar('\n');
    }
}



//poj2263
/*floyd来求解最大能够载重；
应为A->C可以有2种情况 A->B,B->C或者A->C,要得到A->C这条道路最大的载重量，由于A,B,C这三条路的载重不同，
所以要找出A->B,B->C的最小载重，因为如果取大的，另外一条就不能了，然后再取直接到和间接到的最大值，
此时可以用floyd来解决问题;*/
#include<stdio.h>
#include<string.h>
#define INF 99999999
int map[205][205];
int num;//统计city
int n,m;
char s[20],e[20];
char in1[30],in2[30];
char city[205][50];
int max(int x,int y)
{
    return x>y?x:y;
}
int min(int x,int y)
{
    return x<y?x:y;
}
int inset(char a[])
{
    int i,j;
    for(i=0;i<num;i++)
    {
        if(strcmp(city[i],a)==0)
        {
            return i;
        }
    }
    num++;
    strcpy(city[i],a);
    return i;
}
int floyd()
{
    int i,j,k;
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
            for(k=0;k<n;k++)
            {
                map[j][k]=max(map[j][k],min(map[j][i],map[i][k]));
            }
    int x,y;
    x=inset(s);
    y=inset(e);
    return map[x][y];
}
int main()
{
    int i,j;
    int ff=0;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(!n&&!m)break;
        memset(map,0,sizeof(map));
        num=0;
        for(i=0;i<=n;i++)
            map[i][i]=INF;
        for(i=0;i<m;i++)
        {
            int z;
            scanf("%s %s %d",in1,in2,&z);
            int x,y;
            x=inset(in1);
            y=inset(in2);
            map[x][y]=map[y][x]=z;
        }
        scanf("%s %s",s,e);
        int ans=floyd();
        printf("Scenario #%d\n",++ff);
        printf("%d tons\n",ans);
        printf("\n");
    }
}