codeforce_exercise_r36

P1119 灾后重建 ：

问题描述

题目简述

B地区在地震过后，所有村庄都造成了一定的损毁，而这场地震却没对公路造成什么影响。但是在村庄重建好之前，所有与未重建完成的村庄的公路均无法通车。换句话说，只有连接着两个重建完成的村庄的公路才能通车，只能到达重建完成的村庄。

给出B地区的村庄数N，村庄编号从0到N−1，和所有M条公路的长度，公路是双向的。并给出第iii个村庄重建完成的时间ti，你可以认为是同时开始重建并在第ti天重建完成，并且在当天即可通车。若ti为0则说明地震未对此地区造成损坏，一开始就可以通车。之后有Q个询问(x,y,t)，对于每个询问你要回答在第t天，从村庄x到村庄y的最短路径长度为多少。如果无法找到从x村庄到y村庄的路径，经过若干个已重建完成的村庄，或者村庄x或村庄y在第t天仍未重建完成 ，则需要返回−1。

输入/输出格式

输入格式：
第一行包含两个正整数N,M表示了村庄的数目与公路的数量。

第二行包含N个非负整数t0,t1,…,tN−1，表示了每个村庄重建完成的时间，数据保证了t0≤t1≤…≤tN−1。

接下来M行，每行3个非负整数i,j,w，w为不超过10000的正整数，表示了有一条连接村庄i与村庄j的道路，长度为w，保证i≠j，且对于任意一对村庄只会存在一条道路。

接下来一行也就是M+3行包含一个正整数Q，表示Q个询问。

接下来Q行，每行3个非负整数x,y,t，询问在第t天，从村庄x到村庄y的最短路径长度为多少，数据保证了t是不下降的。

输出格式：
共Q行，对每一个询问(x,y,t)输出对应的答案，即在第ttt天，从村庄x到村庄y的最短路径长度为多少。如果在第t天无法找到从x村庄到y村庄的路径，经过若干个已重建完成的村庄，或者村庄x或村庄y在第t天仍未修复完成，则输出−1。

样例

输入样例：
4 5
1 2 3 4
0 2 1
2 3 1
3 1 2
2 1 4
0 3 5
4
2 0 2
0 1 2
0 1 3
0 1 4
输出样例：
-1
-1
5
4

问题分析

解题思路

思路其实很简单，图随着天数而变化，所以不同的天数分别进行最短路算法的查询即可。不再过多赘述了。这个题的重点还是卡复杂度。
这题数据范围最大到了q=50000,N=200,M=N*(N-1)/2。然后用dijkstra复杂度为qMlogN基本是1e9的数量级。想着差不多能过，结果超时了。也是，1e8的复杂度就很危险了。总之，堆优化的dij不太行。正解是floyd加剪枝，就是在floyd动态规划的过程中判断当前点是否修完了，如果没修完，则直接跳过后续动态规划的过程。最后结果是比dij快的。

参考代码

第一个是我自己的dij，第二个是我对着题解抄的floyd算法。另外貌似dij剪枝也能过。。
code1：80pts

#include <iostream>
#include <queue>
#include <cstring>
#include <vector>

using namespace std;

const int inf=0x3f3f3f3f;

class edge
{
public:
	int from;
	int to;
	int weight;
	int open_time;
	edge(int u,int v,int w,int t)
	{
		from=u;
		to=v;
		weight=w;
		open_time=t;
	}
};

class heapnode
{
public:
	int index;
	int dist;
	heapnode(int id,int d)
	{
		index=id;
		dist=d;
	}
	bool operator <(const heapnode& hn) const
	{
		return dist>hn.dist;
	}
};

vector<edge> edges;
vector<int> points[220];
priority_queue<heapnode> pq;
int t[220];
int vis[220];
int dist[220];
int n,m,q;

void init()
{
	memset(t,0,sizeof(t));
	for(int i=0;i<220;i++)
	{
		points[i].clear();
	}
	edges.clear();
}

void addedge(int u,int v,int w)
{
	int op_time=max(t[u],t[v]);
	edge e1(u,v,w,op_time);
	edges.push_back(e1);
	points[u].push_back(edges.size()-1);
	edge e2(v,u,w,op_time);
	edges.push_back(e2);
	points[v].push_back(edges.size()-1);
}

int dijkstra(int start,int ed,int at)
{
	//printf("quray: (%d->%d time:%d)\n",start,ed,at);
	dist[start]=0;
	heapnode hn(start,0);
	pq.push(hn);
	while(!pq.empty())
	{
		heapnode tp=pq.top();
		//printf("get index:%d\n",tp.index);
		pq.pop();
		if(vis[tp.index]==1) continue;
		vis[tp.index]=1;
		if(tp.index==ed) return dist[ed];
		for(int i=0;i<points[tp.index].size();i++)
		{
			edge te=edges[points[tp.index][i]];
			//printf("get edge (%d %d %d %d)\n",te.from,te.to,te.weight,te.open_time);
			if(te.open_time>at) continue;
			if(dist[te.to]>dist[tp.index]+te.weight)
			{
				dist[te.to]=dist[tp.index]+te.weight;
				heapnode np(te.to,dist[te.to]);
				pq.push(np);
			}
		}
	}
	return -1;
}

int main()
{
	init();
	scanf("%d %d",&n,&m);
	for(int i=0;i<n;i++)
	{
		int tmp;
		scanf("%d",&tmp);
		t[i]=tmp; 
	}
	for(int i=1;i<=m;i++)
	{
		int u,v,w;
		scanf("%d %d %d",&u,&v,&w);
		addedge(u,v,w);
	}
	scanf("%d",&q);
	for(int i=1;i<=q;i++)
	{
		int from,to,start;
		scanf("%d %d %d",&from,&to,&start);
		memset(vis,0,sizeof(vis));
		for(int j=0;j<220;j++)
		{
			dist[j]=inf;
		}
		while(!pq.empty()) pq.pop();
		printf("%d\n",dijkstra(from,to,start));
	}
	return 0;
}

code2：100pts

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;
const int inf=0x3f3f3f3f;
const int N=210;
const int M=20010;
int f[N][N],vis[N];
int n,m,Q,t[N];
int main()
{
//	freopen("testdata.in","r",stdin);
//	freopen("test.out","w",stdout);
	memset(f,inf,sizeof(f));
	scanf("%d%d",&n,&m);
	for(int i=0;i<n;i++) scanf("%d",&t[i]),f[i][i]=0;;
	int u,v,w;
	for(int i=1;i<=m;i++) scanf("%d%d%d",&u,&v,&w),f[u][v]=f[v][u]=w;
	scanf("%d",&Q);
	while(Q--)
	{
		scanf("%d%d%d",&u,&v,&w);
		for(int k=0;k<n;k++)
		{
			if(t[k]<=w&&!vis[k])
			{
				vis[k]=1;
				for(int i=0;i<n;i++)
					for(int j=0;j<n;j++)
						if(f[i][j]>f[i][k]+f[k][j])
							f[i][j]=f[i][k]+f[k][j];
			}
		}
		if (t[u]<=w&&t[v]<=w&&f[u][v]<inf) printf("%d\n",f[u][v]);
        else printf("-1\n");
	}
	return 0;
}

心得体会

其实这题，我从一开始就排除了floyd算法，觉得这个算法要用的话还不如dij快（实际上不剪枝的话确实如此）。但是dij到堆优化之后就很难再优化了，floyd却可以。这让我想到之前做的传递闭包的时候也是需要一点优化才能过，直接莽就过不了。以后做题的时候还是要多想。