边双连通分量

如果还未学习强连通分量，建议先学习强连通分量的tarjan算法强连通分量（tarjan算法）

1，定义

相对于在单向图的强连通分量，双连通分量是在无向图中，无向图有一个特点，可以以任何一个点为根节点建dfs树

割边（桥）：删去一条边，会增加图中的强连通分量（即可以使原来连通的部分变成两半（不连通））

割点 ：同理割边，不过是删边

如果删去一条边，仍然无法使不连通，说明是边双连通，点就是点双连通

边，点写法几乎一致，此处介绍边双连通

 2，算法思路

其实与强连通分量的tarjan算法几乎没差

1，dfs树不断遍历点，不需要出栈，只入栈，不需要instack【】数组

2,因此我们如果遇到一个已经遍历过的点，毫无疑问，他是当前子树的祖先

3，因为是无向图，如果u与v之间有两条边（或以上）（就是说他们双连通），那么实际我们建边是建了4条，因为我们建的有向边*2，所以对于第二条边，我们需要flag来判定是否属于重边

4，因为dfs建树，需要判定父节点操作，多了个fa变量

void tarjan(int u, int fa)
{
	dfn[u] = low[u] = ++dfncnt;
	sta[++top] = u;
	bool flag = 1;//判断重边
	for (int i = head[u]; i; i = edge[i].next)
		{
			int v = edge[i].to;
			if (v == fa && flag)//第一次v是父节点，只是因为无向边建边原因，直接跳过
				{
					flag = 0;
					continue;
				}//后面再遇到父节点，说明u与v确实不止一条无向边
			
			if (!dfn[v])//没访问过，操作还是那样
				{
					tarjan(v, u);
					low[u] = min(low[v], low[u]);
				}
			else low[u] = min(low[u], dfn[v]);//访问过，那绝对是找到祖先了，非树边——，找到一个强连通分量（环）了
		}
	if (low[u] == dfn[u])
		{
			++cnt;
			sum[cnt] = 0;
			while (1)
				{
					int v = sta[top--];
					bcc[v] = cnt;
					sum[cnt] += a[v];
					if (u == v)break;
				}
		}
}

3，练习：考研路茫茫——空调教室

思路：

就是把无向图缩点变成只有割边的图，然后变量树，走树状dp

#include 
using namespace std;
#define ll     long long
typedef unsigned long long ull;
typedef pair pll;
const int INF = 0x3f3f3f3f;         //int型的INF
const ll llINF = 0x3f3f3f3f3f3f3f3f;//ll型的llINF
const int N = 1e4 + 10;

int dfn[N], low[N], sta[N], bcc[N], head[N], hd[N], a[N];
ll sum[N], dp[N], ans, summ;
int num, num1, dfncnt, cnt, top;
struct node
{
	int to, next;
} edge[N << 2], eg[N << 2]; //双向边要两倍的（N*2），所以N<<2

void init()
{
	num = num1 = top = cnt = dfncnt = summ = 0;
	ans = llINF;
	memset(head, 0, sizeof(head));
	memset(hd, 0, sizeof(hd));
	memset(dfn, 0, sizeof(dfn));
}

void add(int u, int v)
{
	edge[++num].next = head[u];
	edge[num].to = v;
	head[u] = num;
}

void add1(int u, int v)
{
	eg[++num1].next = hd[u];
	eg[num1].to = v;
	hd[u] = num1;
}

void tarjan(int u, int fa)
{
	dfn[u] = low[u] = ++dfncnt;
	sta[++top] = u;
	bool flag = 1;//判断重边
	for (int i = head[u]; i; i = edge[i].next)
		{
			int v = edge[i].to;
			if (v == fa && flag)//第一次v是父节点，只是因为无向边建边原因，直接跳过
				{
					flag = 0;
					continue;
				}//后面再遇到父节点，说明u与v确实不止一条无向边
			
			if (!dfn[v])//没访问过，操作还是那样
				{
					tarjan(v, u);
					low[u] = min(low[v], low[u]);
				}
			else low[u] = min(low[u], dfn[v]);//访问过，那绝对是找到祖先了，非树边——，找到一个强连通分量（环）了
		}
	if (low[u] == dfn[u])
		{
			++cnt;
			sum[cnt] = 0;//sum存储这个环的总人数
			while (1)
				{
					int v = sta[top--];
					bcc[v] = cnt;
					sum[cnt] += a[v];
					if (u == v)break;
				}
		}
}

void dfs(int u, int fa)//我们如果割去一条边，对于摘掉一颗子树，所以每次取次必须是整个子树的值
{
	dp[u] = sum[u];//dp先取子树根节点的值，区别sum与dp，dp是整颗树人数和，sum只是这个点的人数
	for (int i = hd[u]; i; i = eg[i].next)//求这颗树的值，对于这颗树的顶点值加这子树的子树值的和（继续深入）
		{
			int v = eg[i].to;
			if (v != fa)//深入，不能返祖
				{
					dfs(v, u);
					dp[u] += dp[v];
				}
		}
	ans = min(ans, abs(summ - 2 * dp[u]));//求完整个树才来比较，最优解，就是（总人数-2*当前分开人数）的最小
}

int main()
{	std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int n, m, x, y;
	while (cin >> n >> m)
		{
			init();
			for (int i = 1; i <= n; ++i)cin >> a[i], summ += a[i];//summ存整个图总人数
			for (int i = 1; i <= m; ++i)cin >> x >> y, add(x + 1, y + 1), add(y + 1, x + 1);//双向边
			for (int i = 1; i <= n; ++i)if (!dfn[i])tarjan(i, 0);
			if (cnt == 1)
				{
					cout << "impossible" << endl;
				}
			else
				{
					for (int i = 1; i <= n; ++i)//缩点后重新建边
						{
							int u = bcc[i];
							for (int j = head[i]; j; j = edge[j].next)
								{
									int v = bcc[edge[j].to];
									if (u != v)add1(u, v);//不用特意建（v,u），后面遍历会有的
								}
						}
					dfs(1, 0);//遍历dfs树
					cout << ans << endl;
				}

		}
	return 0;
}