边双连通分量

如果还未学习强连通分量,建议先学习强连通分量的tarjan算法强连通分量(tarjan算法)

1,定义

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

割边(桥):删去一条边,会增加图中的强连通分量(即可以使原来连通的部分变成两半(不连通))

割点 :同理割边,不过是删边

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

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

边双连通分量_第1张图片

 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;
}

你可能感兴趣的:(图论,算法,图论)