sgu 525 Revolutionary Roads

题意：在一个1000个点中的有向图中，现在可以进行的操作就是将一条有向边修改成无向边，那个图中的最大的强连通分量的点数是多少。

分析：很显然的分析就是那么修改的那一条边一定不是强连通分量之内的边，否则那么就是没有效果的，如果能产生效果的一定是修改后可以将多个强连通分量融合起来，那么现在的问题就是如果转变一条边之后，能够连通多少个点，如果每次去算的话会比较麻烦，这个问题可以进行n^2的预处理，预处理出在这个dag当中，每个点可以到达哪些点，同时又有哪些点可以到达这个点，然后如果转变的边可以连通a和b的话，那么就是将，这两个集合取一个交集就可以了。

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <memory.h>
#include <vector>
#include <queue>
#include <stack>

using namespace std;

#define maxn 1010

vector<int> id[maxn], nG[maxn], nid[maxn];

int n ,m;
int num[maxn];

int ret ,sum;
vector<int> vret;

struct SCC
{
	int n,dfs_clock,scc_cnt;
	int dfn[maxn],low[maxn],sccno[maxn];
	vector<int> G[maxn];
	stack<int> S;
	void init(int _n){
		n=_n;
		for(int i=1;i<=n;i++)
			G[i].clear();
	}
	void add(int u,int v){
		G[u].push_back(v);
	}
	void dfs(int u){
		int i,size=G[u].size(),v,x;
		dfn[u]=low[u]=++dfs_clock;
		S.push(u);
		for(i=0;i<size;i++)
		{
			v=G[u][i];
			if(0 == dfn[v])
			{
				dfs(v);
				low[u]=min(low[v],low[u]);
			}
			else if(0 == sccno[v])
				low[u]=min(low[u],dfn[v]);
		}
		if(low[u] == dfn[u])
		{
			scc_cnt++;
			num[scc_cnt] = 0;
			while(1)
			{
				x=S.top();S.pop();
				sccno[x]=scc_cnt;
				num[scc_cnt] ++;
				if(u == x)	break;
			}
		}
	}
	void find_scc(){
		memset(dfn,0,sizeof(dfn));
		memset(sccno,0,sizeof(sccno));
		dfs_clock=scc_cnt=0;
		for(int i=1;i<=n;i++)
			if(0 == dfn[i])
				dfs(i);
	}
	void build() {
		for(int i = 1;i <= n;i++) {
			int size = G[i].size();
			for(int f = 0;f < size;f++) {
				int v = G[i][f];
				if(sccno[i] == sccno[v])
					continue;
				nG[sccno[i]].push_back(sccno[v]);
				nid[sccno[i]].push_back(id[i][f]);
			}
		}
	}
	void teadd(int ret) {
		for(int i = 1;i <= n;i++) {
			if(ret != num[sccno[i]])
				continue;
			int size = G[i].size();
			for(int f = 0 ;f < size;f++)
				vret.push_back(id[i][f]);
		}
	}
}townboy;

vector<int> exist(int a,int b) {
	int size = nG[a].size();
	vector<int> tt;
	for(int i = 0; i < size;i++) {
		int v = nG[a][i];
		if(v == b)
		   tt.push_back(nid[a][i]);	
	}
	return tt;
}

void update(int a,int b,int ans) {
	if(ans < ret)
		return ;
	vector<int> tt = exist(a, b);
	if(0 == tt.size())
		return ;

	if(ans == ret) {
		int size = tt.size();
		for(int i = 0 ;i < size;i++)
			vret.push_back(tt[i]);
	}
	else {
		ret = ans;
		vret = tt;
	}
}

bool to[maxn][maxn] ,from[maxn][maxn];

void fun(int x) {
	queue <int > q;
	q.push(x);
	bool vis[maxn];
	memset(vis, false ,sizeof(vis));
	vis[x] = true;
	while(!q.empty() ) {
		int u = q.front(); q.pop();
		to[x][u] = true;
		from[u][x] = true;
		int size = nG[u].size();
		for(int i = 0;i < size; i++) {
			int v = nG[u][i];
			if(true == vis[v])
				continue;
			vis[v] = true;
			q.push(v);
		}
	}
}

int jiao(int x,int y) {
	int ret = 0;
	for(int i = 1;i <= sum;i ++) 
		if(to[x][i] && from[y][i])
			ret += num[i];
	return ret;
}

void solve() {
	townboy.find_scc();
	townboy.build();
	ret = 0;
	sum = townboy.scc_cnt; 
	memset(to, false, sizeof(to));
	memset(from, false, sizeof(false));
	for(int i = 1;i <= sum; i++)
		fun(i);

	for(int i = 1;i <= sum; i++) {
		int size = nG[i].size();
		for(int f = 0;f < size;f++) {
			int v = nG[i][f];
			int tt = jiao(i ,v);
			if(tt == ret)
				vret.push_back(nid[i][f]);
			else if(tt > ret) {
				ret = tt;
				vret.clear();
				vret.push_back(nid[i][f]);
			}
		}
	}
}

void te() {
	int tt = 0;
	for(int i = 1;i <= sum; i++)
		tt = max(tt, num[i]);
	if(tt == ret)
		townboy.teadd(tt);
	else if(tt > ret) {
		vret.clear();
		ret = tt;
		townboy.teadd(tt);
	}
}

void ans() {
	te();
	cout << ret << endl;
	int size = vret.size();
	cout << size << endl;
	sort(vret.begin(), vret.end());
	for(int i = 0 ;i < size; i++) {
		if(0 != i)
			printf(" ");
		printf("%d", vret[i]);
	}
	cout << endl;
}

int main() {
	cin >> n >> m;
	int u ,v;
	townboy.init(n);
	for(int i = 0 ;i < m;i++) {
		scanf("%d%d", &u, &v);
		townboy.add(u, v);
		id[u].push_back(i + 1);
	}
	solve();
	ans();
	return 0;
}