HDU - 3594 Cactus (强连通缩点+STL)

题目链接

题意:T组测试样例,每组样例给出一个N,表示(编号为0~N-1)的点有向图,随后给出这个有向图的边,每行是一个u和v,当u==0且v==0时边的输入结束.当每组两个条件时,输出YES,否则输出NO.

         条件一:该图是一个强连通图;

         条件二:该图中每条边都只属于一个环,即不能被多个环遍历到;

题解:对于这个题目,我们首先需要使用强连通图的Tarjan算法跑一遍强连通分量,判断该图的强连通分量是否只有一个,在是的情况下再对这个图跑所有环,将每次路过的路径边都存储在map<edge,int>中,int是指该边访问次数,最后遍历map中的所有边,若是访问次数都是1次,不存在被访问次数大于1的边,那么就可以输出YES,否则其他所有情况都是输出NO.

代码如下:

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<string>
#include<cstring>
#include<map>
#include<vector>
using namespace std;
#define ll long long
const int maxn = 20005;
struct Tarjan {
	int n;                                      //点的个数

	vector<int>e[maxn];                         //邻接表存图
	int DFN[maxn], LOW[maxn];
	int index;                                  //编辑计数器

	int stk[maxn];                              //栈
	bool ins[maxn];                             //记录点是否在栈中
	int top;

	vector<vector<int> >ans; 
								               
	void init(int N) {                          //初始化
		n = N;

		ans.clear();
		for (int i = 1; i <= n; i++)
			e[i].clear();
		top = 0;
		index = 0;

		memset(DFN, -1, sizeof(DFN));
		memset(ins, 0, sizeof(ins));
	}

	void add_edge(int u, int v) {                //添加边
		e[u].push_back(v);
	}

	void dfs(int u) {                            //从u点开始搜索
		DFN[u] = LOW[u] = ++index;
		stk[top++] = u;                          //为了记录这个连通分量中的节点
		ins[u] = true;

		for (int i = 0; i < e[u].size(); i++) {
			int v = e[u][i];
			if (DFN[v] == -1) {
				dfs(v);
				LOW[u] = min(LOW[u], LOW[v]);
			}
			else if (ins[v])
				LOW[u] = min(LOW[u], DFN[v]);
		}

		if (DFN[u] == LOW[u]) {                   //当DFN==LOW时说明stk中点可以形成一个强连通分量
			vector<int>q;
			int v = stk[top - 1];

			while (u != v) {
				q.push_back(v);
				ins[v] = false;
				top--;
				v = stk[top - 1];
			}
			q.push_back(u);
			ins[u] = false;
			top--;

			ans.push_back(q);
		}
	}

	void solve() {                                //运行该函数后产生答案
		for (int i = 1; i <= n; i++)
			if (DFN[i] == -1) dfs(i);
	}
}T;
struct Check {
	struct edge {
		int u, v;
		edge(){}
		edge(int uu,int vv):u(uu),v(vv){}
		bool operator < (const edge &a)const {
			if (u != a.u) return u < a.u;
			return v < a.v;
		}
	}stk[50005];                                  //用于存储路径

	int n;
	int top;
	bool vis[maxn];
	map<edge, int>mp;                             //用于记录每条边的使用次数

	void init(int nn) {                           //初始化
		n = nn;
		top = 0;
		mp.clear();
		memset(vis, 0, sizeof(vis));
	}

	void dfs(int u) {                              //dfs将该强连通图的所有环都跑一遍
		vis[u] = true;
		for (int i = 0; i < T.e[u].size(); i++) {
			int v = T.e[u][i];
			stk[top++] = edge(u, v);
			if (!vis[v]) dfs(v);
			else {
				int j;
				for (j = top - 1; stk[j].u != v; j--)
					mp[stk[j]]++;
				mp[stk[j]]++;
			}
		}
		vis[u] = false;                           //注意需要刷新掉,不然下次无法访问
	}

	bool check() {                                //dfs后,若是存在某条路径被走过大于一次为false
		dfs(1);
		for (map<edge, int>::iterator it = mp.begin(); it != mp.end(); it++)
			if ((*it).second > 1)return false;
		return true;
	}
}C;
int main() {
	int t, n;
	scanf("%d", &t);
	while (t--) {
		scanf("%d", &n);
		int u, v;
		T.init(n);                                //Tarjan初始化
		while (~scanf("%d%d",&u,&v)&&(u||v))      //建有向图
			T.add_edge(u+1, v+1);        

		T.solve();                                //获得该有向图的所有强连通分量

		bool key;
		if (T.ans.size() == 1) {
			C.init(n);                            //判断结构体初始化
			key = C.check();                      //调用判断结构体函数
		}
		else key = false;

		if (key) printf("YES\n");
		else printf("NO\n");	
	}
	return 0;
}