C - TT 的美梦（Bellman-ford算法以及SPFA算法优化）

C - TT 的美梦

• 题意：
  这一晚，TT 做了个美梦！
  在梦中，TT 的愿望成真了，他成为了喵星的统领！喵星上有 N 个商业城市，编号 1 ～ N，其中 1 号城市是 TT 所在的城市，即首都。
  喵星上共有 M 条有向道路供商业城市相互往来。但是随着喵星商业的日渐繁荣，有些道路变得非常拥挤。正在 TT 为之苦恼之时，他的魔法小猫咪提出了一个解决方案！TT 欣然接受并针对该方案颁布了一项新的政策。
  具体政策如下：对每一个商业城市标记一个正整数，表示其繁荣程度，当每一只喵沿道路从一个商业城市走到另一个商业城市时，TT 都会收取它们（目的地繁荣程度 - 出发地繁荣程度）^ 3 的税。
  TT 打算测试一下这项政策是否合理，因此他想知道从首都出发，走到其他城市至少要交多少的税，如果总金额小于 3 或者无法到达请悄咪咪地打出 ‘?’。

• 输入输出：
  Input
  第一行输入 T，表明共有 T 组数据。（1 <= T <= 50）
  对于每一组数据，第一行输入 N，表示点的个数。（1 <= N <= 200）
  第二行输入 N 个整数，表示 1 ～ N 点的权值 a[i]。（0 <= a[i] <= 20）
  第三行输入 M，表示有向道路的条数。（0 <= M <= 100000）
  接下来 M 行，每行有两个整数 A B，表示存在一条 A 到 B 的有向道路。
  接下来给出一个整数 Q，表示询问个数。（0 <= Q <= 100000）
  每一次询问给出一个 P，表示求 1 号点到 P 号点的最少税费。
  Output
  每个询问输出一行，如果不可达或税费小于 3 则输出 ‘?’。
  

• 解题思路：
  本题需要求出有含有环的单源最短路，故dijkstra算法不再适用。需要使用Bellman−Ford算法。这里使用队列优化的SPFA算法。

  依然使用链式前向星存图，不再赘述。vis数组标记点是否在队列中，dis记录距离，num记录松弛次数，sq记录是否受负环影响。

  先将起点到所有点的距离初始化为inf并将起点入队，当队列不为空时，每次取队首元素，将其pop出队并将vis值修改为0，同dijkstra一样开始对邻接点进行从松弛操作，松弛成功的点num+1，其邻接点如果不在队列中将它加入队列。因为题中可能存在负环，而不存在环的条件是边数一定少于点数。这里可以使用num来存每个点的松弛次数，当num[i]>n时则说明存在负环。因为与负环连通的所有点都会受负环影响，故可以从i点开始进行dfs，标记能到达的点。

  最后输出需要判**断到达不了即dis值为inf的点，dis值小于3的点以及受负环影响sq被标记为1的点，**若满足以上条件输出“？”，其他情况输出该点的dis值。

• 代码实现：

#include<iostream>
#include<queue>
#include<cstring>
#include<cmath>
#include<cstdio>
using namespace std;
const int MAXM=100010;
const int inf=200000000;
int n,m,t,tot,num[MAXM],a[MAXM],dis[MAXM],head[MAXM];
queue<int> q;
bool vis[MAXM],sq[MAXM];

struct node
{
	int to;
	int weight;
	int next;
}edge[MAXM];

void add_edge(int u,int v,int w)
{
	edge[tot].next=head[u];
	edge[tot].to=v;
	edge[tot].weight=w;
	head[u]=tot++;
}

void dfs(int u)
{
	for(int i=head[u];i;i=edge[i].next)
	if(!sq[edge[i].to])
	{
		sq[edge[i].to]=1;
		dfs(edge[i].to);
	}
}

void SPFA()
{
	for(int i=1;i<=n;i++)
	dis[i]=inf;
	dis[1]=0;
	q.push(1);
	vis[1]=1;
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		vis[u]=0;
		for(int i=head[u];i;i=edge[i].next)
		if(dis[edge[i].to]>dis[u]+edge[i].weight)
		{
			num[edge[i].to]++;
			dis[edge[i].to]=dis[u]+edge[i].weight;
			if(num[edge[i].to]>n) 
			{
				dfs(edge[i].to);
				continue ;
			}
			if(!vis[edge[i].to])
			{
				q.push(edge[i].to);
				vis[edge[i].to]=1;
			}
		}
	}
}

int main()
{
	int N,x,y,z;
	cin>>N;
	for(int nn=1;nn<=N;nn++)
	{
		tot=1;
		for (int i=0;i<MAXM;i++)
		{
			head[i]=0;
			num[i]=0;
			vis[i]=0;
			sq[i]=0;
		}
		cin>>n;
		for(int i=1;i<=n;i++)
		cin>>a[i];
		cin>>m;
		for(int i=1;i<=m;i++)
		{
			cin>>x>>y;
			add_edge(x,y,pow(a[y]-a[x],3));
		}
		SPFA();
		printf("Case %d:\n",nn);
		cin>>t;
		for(int i=1;i<=t;i++)
		{
			cin>>n;
			if(dis[n]<3||sq[n]||dis[n]==inf)
				cout<<"?"<<endl;
			else 
				cout<<dis[n]<<endl;
		}
	}
	return 0;
}

• 关于Bellman—Ford和SPFA的补充：

  Floyed算法适用于求多源最短路经，时间复杂度为O(n3)，dijkstra算法适用于求没有负权边的单源最短路，Bellman—Ford算法可以用于解决有负权边的单源最短路径。

  Bellman—Ford算法的基本思想是每次更新所有的边的距离，从而确定一个点的最短距离。当存在负环时最短路径是不存在的，判断负环是否存在可以判断是否存在边被松弛的次数大于n-1，因为如果没有负环n个点更新n-1次即可更新完毕，
  下面为核心代码：

//对图中每一条边进行松弛操作，松弛n-1轮。
for(int i=1; i<=n; ++i)
{
	dis[i]=inf;
	pre[i]=0;
}
dis[s]=0;
for(int k=1; k<n; ++k)
	for(int i=1; i<=m; ++i)
		if(dis[v[i]] > dis[u[i]] + w[i])
		{
			dis[v[i]]=dis[u[i] + w[i];
			pre[v[i]] = u[i];
		}
//判断是否存在负环
for(int i=1; i<=m; ++i)
{
	if(dis[v[i]] > dis[u[i]] +w[i]  //n-1轮松弛后依然存在能松弛的边
	{//存在负环}
}

显然该算法的时间复杂度为O(nm)，m为边数。由于每一次松弛都要更新所有的边，使答案逐渐接近于最短路径，而实际上有许多松弛操作是多余的，因为只有在前一条边更新完成后下一条边的更新才是有效的，否则会造成有的边更新多次无效值，从而造成浪费。

为了解决这一问题引入了SPFA算法，基本思想是使用队列，将松弛成功的边加入队列，再去更新与这些边相邻的边的值。SPFA算法的平均时间复杂度为O(m)，但极端情况下有可能和Bellman—Ford算法一样为O(nm)。 SPFA判断负环的方法为判断一个点的更新次数和点总数n的大小，可以放宽到比较入队次数和n的大小，如果入队次数大于n则一定存在负环。
核心代码如下：

for （int i=1; i<=n; ++i)
{
	dis[i] = inf;//距离
	pre[i] = 0;//前驱节点
	inq[i] = 0;//标记是否在队列内
	cnt[i] = 0;//入队次数
}
dis[s] = 0;
inq[s] = 1;
q.push(s);
while(!q.empty())
{
	int u = q.front(); q.pop();
	inq[u] = 0;
	for(edge e:G[u])
	{
		int v = e.to;
		if(dis[v] > dis[u] + e.w;
		{
			cnt[v] = cnt[u] + 1; 
			if(cnt[v] >= n)   //松弛次数大于n
			{ //存在负环 }
			dis[v] = dis[u] + e.w;   //松弛成功
			pre[v] = u;
			if(!inq[v])
			{
				q.push(v);
				inq[v] = 1;
			}
		}
	}
}