BZOJ2730或洛谷3225 [HNOI2012]矿场搭建

BZOJ原题链接

洛谷原题链接

显然在一个点双连通分量里，无论是哪一个挖煤点倒塌，其余挖煤点就可以互相到达，而对于一个点双连通分量来说，与外界的联系全看割点，所以我们先用(tarjan)求出点双连通分量，再对每个点双进行讨论。

1. 若该点双不含割点，那么这个点双是与外面隔绝的，至少要设置两个出口。
2. 若该点双只含一个割点，那么这个点双只有经过割点才能到达外面，若割点倒塌，则与外面隔绝，所以需要设置一个出口。
3. 若该点双含两个及以上的割点，那么无论哪一个点倒塌，这个点双依旧能到达外面，所以不需要设置出口。

最后根据乘法原理，将每个点双需要建立的出口个数乘起来即是总方案数。

#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
const int N = 510;
const int M = 1010;
int fi[N], di[M], ne[M], dfn[N], low[N], sta[N], l, tp, ti, r, DCC;
bool ct[N];
vector<int>po[N];
inline int re()
{
	int x = 0;
	char c = getchar();
	bool p = 0;
	for (; c < '0' || c > '9'; c = getchar())
		p |= c == '-';
	for (; c >= '0' && c <= '9'; c = getchar())
		x = x * 10 + c - '0';
	return p ? -x : x;
}
inline void add(int x, int y)
{
	di[++l] = y;
	ne[l] = fi[x];
	fi[x] = l;
}
inline int minn(int x, int y)
{
	return x < y ? x : y;
}
inline int maxn(int x, int y)
{
	return x > y ? x : y;
}
void tarjan(int x)
{
	int i, y, g = 0, z;
	dfn[x] = low[x] = ++ti;
	sta[++tp] = x;
	for (i = fi[x]; i; i = ne[i])
		if (!dfn[y = di[i]])
		{
			tarjan(y);
			low[x] = minn(low[x], low[y]);
			if (dfn[x] <= low[y])
			{
				g++;
				if (x ^ r || g > 1)
					ct[x] = 1;
				DCC++;
				po[DCC].clear();
				do
				{
					z = sta[tp--];
					po[DCC].push_back(z);
				} while (z ^ y);
				po[DCC].push_back(x);
			}
		}
		else
			low[x] = minn(low[x], dfn[y]);
}
int main()
{
	int i, j, n, m, x, y, o, k, t = 0;
	long long s_1, s_2;
	while (1)
	{
		t++;
		m = re();
		if (!m)
			return 0;
		n = l = ti = DCC = s_1 = 0;
		s_2 = 1;
		memset(fi, 0, sizeof(fi));
		memset(dfn, 0, sizeof(dfn));
		memset(low, 0, sizeof(low));
		memset(ct, 0, sizeof(ct));
		for (i = 1; i <= m; i++)
		{
			x = re();
			y = re();
			add(x, y);
			add(y, x);
			n = maxn(n, maxn(x, y));
		}
		for (i = 1; i <= n; i++)
			if (!dfn[i])
			{
				if (!fi[i])
				{
					po[++DCC].push_back(i);
					continue;
				}
				tarjan(r = i);
			}
		for (i = 1; i <= DCC; i++)
		{
			for (j = 0, k = 0, o = po[i].size(); j < o; j++)
				if (ct[po[i][j]])
					k++;
			if (!k)
			{
				s_1 += 2;
				s_2 *= 1LL * o * (o - 1) >> 1;
			}
			else
				if (k && k < 2)
				{
					s_1++;
					s_2 *= (o - k);
				}
		}
		printf("Case %d: %lld %lld
", t, s_1, s_2);
	}
	return 0;
}