[AtCoder Regular Contest 092 F]Two Faced Edges乱搞题

题目大意：

给定一个有向图，然后询问每一条边将它反转之后整张图的强联通分量是否会发生变化

思路：

如果一条边(u,v)在经过反转之后，强联通分量的数量保持不变的话，考虑两个条件：1.从u不经过这条边能否到达v？2.从v是否可以到达u？如果只有第一个条件成立，显然会形成一个新的强联通分量，如果只有第二个条件成立，那么原本的这个强联通分量就会消失，数量都会发生变化，所以只有两个条件同事成立或者同事不成立的时候，强联通分量的数目才不会发生改变。

第二个显然是可以对于每一个点跑一遍dfs来求得的，第一个的话，我最自然的想法是把每一条边都删掉一遍然后对边的始点跑一遍dfs，但是时间复杂度达到了m^2，所以必须要优化，可以从每一个点来考虑，考虑u直接可以到达的v是否满足第一条性质，只需要考虑从u不经过（u，v）能否到达v，但是访问过的点不可以再次访问，所以按照从链表的begin-end遍历一次，再反过来遍历一次，记录到达v的边的编号，只要正着的遍历和反着的遍历之中有一次到达v的边的编号不是(u,v)，就说明满足性质1。
下面贴上代码:

/*==============================
 * Authot : ylsoi
 * Time : 2018.3.20
 * Problem : ARC92F
 * File : ARC92F.cpp
 * Algorithm : Strange Algorithm
 * ===========================*/
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
using namespace std;
void File(){
	freopen("ARC92F.in","r",stdin);
	freopen("ARC92F.out","w",stdout);
}
#define REP(i,a,b) for(register int i=a;i<=b;++i)
#define DREP(i,a,b) for(register int i=a;i>=b;--i)
#define mem(a) memset(a,0,sizeof(a))
const int maxn=1000+10;
const int maxm=200000+10;
vector<int>E[maxn];
int n,m,beg[maxn],len,num[maxn][maxn];
bool can[maxn][maxn],vis[maxn],can1[maxn][maxn];
int vis1[maxn],vis2[maxn],from[maxm],to[maxm];
void dfs(int u,int rt){
	vis[u]=1;
	can[rt][u]=1;
	int size=E[u].size()-1;
	REP(i,0,size){
		int v=E[u][i];
		if(vis[v])continue;
		dfs(v,rt);
	}
}
void dfs1(int u){
	vis[u]=1;
	int size=E[u].size()-1;
	REP(i,0,size){
		int v=E[u][i];
		if(vis[v])continue;
		vis1[v]=num[u][v];
		dfs1(v);
	}
}
void dfs2(int u){
	vis[u]=1;
	int size=E[u].size()-1;
	DREP(i,size,0){
		int v=E[u][i];
		if(vis[v])continue;
		vis2[v]=num[u][v];
		dfs2(v);
	}
}
int main(){
	//File();
	scanf("%d%d",&n,&m);
	REP(i,1,m){
		int u,v;
		scanf("%d%d",&u,&v);
		E[u].push_back(v);
		num[u][v]=++len;
		from[len]=u;
		to[len]=v;
	}
	REP(i,1,n){
		dfs(i,i);
		mem(vis);
	}
	REP(i,1,n){
		dfs1(i);
		mem(vis);
		dfs2(i);
		mem(vis);
		int size=E[i].size()-1;
		REP(j,0,size){
			int v=E[i][j];
			if(vis1[v]!=num[i][v] || vis2[v]!=num[i][v])
				can1[i][v]=1;
		}
		mem(vis1);
		mem(vis2);
	}
	REP(i,1,m){
		int u=from[i],v=to[i];
		if((can[v][u]^can1[u][v])==0)
			puts("same");
		else puts("diff");
	}
	return 0;
}