hdu5521 spfa+超图转换+最短路+邻接表建图

题目大意：给你一个图，一个人在第一个节点，一个人在最后一个节点，问两人能不能相遇，相遇时的最短距离是多少。输入边的时候是以集合形式输入，每个集合内的两两节点可达，距离给定。

2015沈阳现场赛题目，当时被建图坑了，没有想清楚就敲，最后没过，暴力建边，边数会达到1e12，肯定超时，后来学习了 别人的解法，给每一个点集S加一个入点和一个出点，则点数和别树就在可以接受的范围内。不说了，直接贴代码

#include <cstdio>
#include <string>
#include <cstring>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <iomanip>

using namespace std;
#define maxn 1000003
#define MOD 1000000007
#define mem(a , b) memset(a , b , sizeof(a))
#define LL __int64

struct edge
{
    int u , v , w;
    int next;
    edge(int u , int v , int w)
    {
        this -> u = u;
        this -> v = v;
        this -> w = w;
    }
    edge(){}
};
int id; //当前边数
int head[maxn]; //记录头
edge E[maxn*3]; //邻接表存边
int n , m , out; //out为增加的点
int dis1[maxn] , dis2[maxn];  //最短路
bool vis[maxn]; //标记数组
int c[maxn];  //记录是否出现负环
int ok;

int spfa(int s , int d[])
{
    queue<int>q;
    for(int i = 0 ; i <= out ; i ++) d[i] = 99999999;
    d[s] = 0;
    mem(c , 0);
    mem(vis , 0);
    q.push(s);
    while(!q.empty())
    {
        int tmp = q.front();
        q.pop();
        vis[tmp] = 0;
        for(int i = head[tmp] ; i > 0 ; i = E[i].next)  //从当前节点开始找到所有能遍历的点
        {
            edge e = E[i];
            if(d[tmp] + e.w < d[e.v])      //松弛,若s由tmp 到 v节点的距离小于s到v的距离
            {
                d[e.v] = d[tmp] + e.w;
                if(!vis[e.v])  //若v未被访问 ，入队列
                {
                    vis[e.v] = 1;
                    c[e.v]++;
                    if(c[e.v] >= out) return ok = 1;  ///判断负环是否存在
                    q.push(e.v);
                }
            }
        }
    }
    return ok;
}

void add(int u , int v , int w)    //这里画个图，走一遍就知道了
{
    id++;
    E[id] = edge(u , v , w);  //第id条边的源点，目标点，权值。
    E[id].next = head[u];  //ID条边的下一条边是源点的头节点
    head[u] = id;  //源点的头就是更新为当前边
}

int main()
{
    int t;
    scanf("%d" , &t);
    int k = 0;
    while(t--)
    {
        scanf("%d %d" , &n , &m);
        int dis , num , tmp;
        out = n;
        id = 0;
        mem(head , -1);
        ok = 0;
        for(int i = 1 ; i <= m ; i ++)
        {
            scanf("%d %d" , &dis , &num);
            out++;
            for(int j = 1 ; j <= num ; j ++)
            {
                scanf("%d" , &tmp);
                add(out , tmp , 0);
                add(tmp , out , dis);
            }
        }
        printf("Case #%d: " , ++k);
        spfa(1 , dis1);
        spfa(n , dis2);
        int minn = 99999999;
        for(int i = 1 ; i <= n ; i ++)
        {
            //if(max(dis1[i] , dis[2]) !=  99999999) flag = 1;
            if(minn > max(dis1[i] , dis2[i])) minn = max(dis1[i] , dis2[i]);
        }
        if(minn == 99999999)
        {
            printf("Evil John\n");
            continue;
        }
        printf("%d\n" , minn);
        vector<int>ans;
        ans.clear();
        for(int i = 1 ; i <= n ; i ++)
        {
            if(minn == max(dis1[i] , dis2[i])) ans.push_back(i);
        }
        int up = ans.size();
        for(int i = 0 ; i < up ; i ++)
        {
            printf("%d" , ans[i]);
            if(i != up - 1) printf(" ");
        }
        printf("\n");
    }
    return 0;
}

spfa算法学习：

SPFA(Shortest Path Faster Algorithm)是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。

算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素，并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。 直到队列为空时算法结束。

这个算法，简单的说就是队列优化的bellman-ford,利用了每个点不会更新次数太多的特点发明的此算法

SPFA——Shortest Path Faster Algorithm，它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。SPFA的实现甚至比Dijkstra或者Bellman_Ford还要简单：

设Dist代表S到I点的当前最短距离，Fa代表S到I的当前最短路径中I点之前的一个点的编号。开始时Dist全部为+∞，只有Dist[S]=0，Fa全部为0。

维护一个队列，里面存放所有需要进行迭代的点。初始时队列中只有一个点S。用一个布尔数组记录每个点是否处在队列中。

每次迭代，取出队头的点v，依次枚举从v出发的边v->u，设边的长度为len，判断Dist[v]+len是否小于Dist[u]，若小于则改进Dist[u]，将Fa[u]记为v，并且由于S到u的最短距离变小了，有可能u可以改进其它的点，所以若u不在队列中，就将它放入队尾。这样一直迭代下去直到队列变空，也就是S到所有的最短距离都确定下来，结束算法。若一个点入队次数超过n，则有负权环。

SPFA 在形式上和宽度优先搜索非常类似，不同的是宽度优先搜索中一个点出了队列就不可能重新进入队列，但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本身被改进，于是再次用来改进其它的点，这样反复迭代下去。设一个点用来作为迭代点对其它点进行改进的平均次数为k，有办法证明对于通常的情况，k在2左右。

SPFA算法（Shortest Path Faster Algorithm），也是求解单源最短路径问题的一种算法，用来解决：给定一个加权有向图G和源点s，对于图G中的任意一点v，求从s到v的最短路径。 SPFA算法是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算，他的基本算法和Bellman-Ford一样，并且用如下的方法改进： 1、第二步，不是枚举所有节点，而是通过队列来进行优化 设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。 2、同时除了通过判断队列是否为空来结束循环，还可以通过下面的方法： 判断有无负环：如果某个点进入队列的次数超过V次则存在负环（SPFA无法处理带负环的图）。

SPFA算法有两个优化算法 SLF 和 LLL： SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j)<dist(i)，则将j插入队首，否则插入队尾。 LLL：Large Label Last 策略，设队首元素为i，队列中所有dist值的平均值为x，若dist(i)>x则将i插入到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i出对进行松弛操作。 SLF 可使速度提高 15 ~ 20%；SLF + LLL 可提高约 50%。 在实际的应用中SPFA的算法时间效率不是很稳定，为了避免最坏情况的出现，通常使用效率更加稳定的Dijkstra算法。

是一种求单源最短路的算法

算法中需要用到的主要变量

int n;  //表示n个点，从1到n标号

int s,t;  //s为源点，t为终点

int d[N];  //d[i]表示源点s到点i的最短路

int p[N];  //记录路径（或者说记录前驱）

queue <int> q;  //一个队列，用STL实现，当然可有手打队列，无所谓

bool vis[N];   //vis[i]=1表示点i在队列中 vis[i]=0表示不在队列中

 

几乎所有的最短路算法其步骤都可以分为两步

1.初始化

2.松弛操作

 

初始化： d数组全部赋值为INF（无穷大）；p数组全部赋值为s（即源点），或者赋值为-1，表示还没有知道前驱

             然后d[s]=0;  表示源点不用求最短路径，或者说最短路就是0。将源点入队；

　　　　（另外记住在整个算法中有顶点入队了要记得标记vis数组，有顶点出队了记得消除那个标记）

队列+松弛操作

读取队头顶点u，并将队头顶点u出队（记得消除标记）；将与点u相连的所有点v进行松弛操作，如果能更新估计值（即令d[v]变小），那么就更新，另外，如果点v没有在队列中，那么要将点v入队（记得标记），如果已经在队列中了，那么就不用入队

以此循环，直到队空为止就完成了单源最短路的求解

 

SPFA可以处理负权边

定理: 只要最短路径存在，上述SPFA算法必定能求出最小值。

证明：

　　每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。（证毕）

期望的时间复杂度O(ke)， 其中k为所有顶点进队的平均次数，可以证明k一般小于等于2。

 

判断有无负环：

　　如果某个点进入队列的次数超过N次则存在负环（SPFA无法处理带负环的图）

 

 

 

SPFA的两种写法，bfs和dfs，bfs判别负环不稳定，相当于限深度搜索，但是设置得好的话还是没问题的，dfs的话判断负环很快

粘贴两个模板：

int spfa_bfs(int s)
{
    queue <int> q;
    memset(d,0x3f,sizeof(d));
    d[s]=0;
    memset(c,0,sizeof(c));
    memset(vis,0,sizeof(vis));

    q.push(s);  vis[s]=1; c[s]=1;
    //顶点入队vis要做标记，另外要统计顶点的入队次数
    int OK=1;
    while(!q.empty())
    {
        int x;
        x=q.front(); q.pop();  vis[x]=0;
        //队头元素出队，并且消除标记
        for(int k=f[x]; k!=0; k=nnext[k]) //遍历顶点x的邻接表
        {
            int y=v[k];
            if( d[x]+w[k] < d[y])
            {
                d[y]=d[x]+w[k];  //松弛
                if(!vis[y])  //顶点y不在队内
                {
                    vis[y]=1;    //标记
                    c[y]++;      //统计次数
                    q.push(y);   //入队
                    if(c[y]>NN)  //超过入队次数上限，说明有负环
                        return OK=0;
                }
            }
        }
    }

    return OK;

}

int spfa_dfs(int u)
{
    vis[u]=1;
    for(int k=f[u]; k!=0; k=e[k].next)
    {
        int v=e[k].v,w=e[k].w;
        if( d[u]+w < d[v] )
        {
            d[v]=d[u]+w;
            if(!vis[v])
            {
                if(spfa_dfs(v))
                    return 1;
            }
            else
                return 1;
        }
    }
    vis[u]=0;
    return 0;
}