最短路

//orz...高中的时候苦练最短路，然而那年noip没有考。再次写起来倍感亲切啊。

//先整理一波最短路的知识。

一、存图方式

1.邻接矩阵

顾名思义，就是以矩阵的方式来存图啦。有n个点，那么图就是map[n][n]啦。

2.邻接表

       和邻接矩阵不同。邻接表是用两点之间的关系来存图的。比如有一条路是x-->y，那么就是在下标为x的数组里插入y，表示存在一条路是x-->y。第一次cpp的邻接表学到了一波新操作。

//代码来源：hdoj2722
//建立邻接表
struct point{
    int v,num;
    point(int a,int b){num=a;v=b;}
};
vector<point> S[maxn*maxn];

ps.第一次用cpp的vector有点点激动。真鸡儿好用啊orz

3.边集数组+链式前向星

（留坑，有点忘了）

二、最短路算法

1.单源最短路—dijkstra

求一个图中两个点之间最短距离的最快的一种方法，要求路径的花费不能有负的。
时间复杂度：O(ElogE)

（大佬们的代码姿势学不来，继续我P式代码风格）

//dijk+邻接矩阵
void dijk(int st){
    memset(V,0,sizeof(V));
    V[st]=1;
    for (int i=1;i<=n;i++) F[i]=A[st][i];
    F[st]=Inf;
    for (int i=1;i<=n;i++){
        int k=st;
        for (int j=1;j<=n;j++){
            if (!V[j] && F[j]<F[k]) k=j;
        }
        V[k]=1;
        for (int j=1;j<=n;j++){
            if (F[j]>F[k]+A[k][j] && !V[j]) F[j]=F[k]+A[k][j]; 
        }
    }
}

2.单源最短路—spfa

代码量较小，速度又不错，经常与其他算法组合出现，可以用来判断负环。（突然想起来没练判负环的题）

//spfa+邻接矩阵
void spfa(int st){
    queue<int> Q;
    memset(V,0,sizeof(V));
    V[st]=1;F[st]=0;T[st]=0;
    Q.push(st);
    while (!Q.empty()){
        int pos=Q.front();
        Q.pop();
        V[pos]=0;
        for (int i=1;i<=n;i++){
            int temp=F[pos]+A[pos][i];
            if (temp<F[i]){
                F[i]=temp;
                T[i]=T[pos]+B[pos][i];
                if (!V[i]){
                    Q.push(i);
                    V[i]=1;
                }
            }
            else if(temp==F[i] && T[i]>T[pos]+B[pos][i]){
                T[i]=T[pos]+B[pos][i];
                if (!V[i]){
                    Q.push(i);
                    V[i]=1;
                }
            }
        }
    }
}

//spfa+邻接表
void spfa(){
    queue<int> Q;
    for (int i=1;i<=(n+1)*(m+1);i++) F[i]=Inf;
    memset(V,0,sizeof(V));
    F[1]=0;
    V[1]=1;
    Q.push(1);
    while (!Q.empty()){
        int pos=Q.front();
        Q.pop();
        V[pos]=0;
        for (int i=0;i<S[pos].size();i++){
            int temp=F[pos]+S[pos][i].v;
            int yy=S[pos][i].num;
            if (temp<F[yy]){
                F[yy]=temp;
                if (!V[yy]){
                    Q.push(yy);
                    V[yy]=1;
                }
            }
        }
    }
}

（留坑，spfa+链式前向星）

3.多元最短路—floyd

经常做预处理用，能处理出来图中任意两个点之间的最短距离，时间复杂度O(n^3) 。

//floyd+邻接矩阵
void floyd(){
    for (int k=1;k<=n;k++){
        for (int i=1;i<k;i++){
            for (int j=k+1;j<=n;j++){
                if (A[i][j]<A[i][k]+A[k][j]){
                    A[i][j]=A[i][k]+A[k][j];
                    path[i][j]=path[i][k];
                }
            }
        }
    }
}

4.bell-man

 

bool bellman_ford(int s){
    queue<int> Q;
    memset(inq,0,sizeof(0));
    memset(cnt,0,sizeof(cnt));
    for (int i=0;i<n;i++) d[i]=inf;
    d[s]=0;
    inq[s]=1;
    Q.push(s);
    while (!Q.empty()){
        int u=Q.front();
        Q.pop();
        inq[u]=0;
        for (int i=0;i<G[u].size();i++){
            Edge &e=edges[G[u][i]];
            if (d[u]<inf && d[e.to]>d[u]+e.dist){
                d[e.to]=d[u]+e.dist;
                p[e.to]=G[u][i];
                if (!inq[e.to]){
                    Q.push(e.to);
                    inq[e.to]=1;
                    if (++cnt[e.to]>n) return 0;
                }
            }
        }
    }
}