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;
}