AT2046「AGC004F」Namori

最新推荐文章于 2022-02-19 09:32:13 发布

Log_x

最新推荐文章于 2022-02-19 09:32:13 发布

阅读量205

点赞数 1

分类专栏： AtCoder 文章标签：分类讨论动态规划树形结构

本文链接：https://blog.csdn.net/bzjr_Log_x/article/details/105059458

版权

AtCoder 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Address

AT2046

Algorithm 1

针对 $M = N - 1$ 的数据，原图是一棵树。

因为树是二分图，考虑对原图进行二分图染色，每次操作一定是选择二分图两侧的点。

考虑把问题进行转化，初始时令二分图某一侧的点上有棋子，每次可以移动任意一个棋子到相邻的没有棋子的点上，询问将所有棋子移到二分图另一侧的点上的最少操作次数。

显然有解的必要条件是二分图两侧的点数相同，我们需要证明其充分性。

考虑怎样构造操作次数最少的方案，令二分图某一侧的点的权值为 $- 1$ ，另一侧的点的权值为 $1$ 。任选一个点为树根，记 $sum_x$ 表示点 $x$ 所在子树所有结点的权值和，不难发现点 $x$ 连向它父结点的那条边的操作次数有一个下界 $sum_x|$ 。

尝试证明这个下界一定能够达到，那么对于根结点 $r o o t$ ，只要 $sum_{root} = 0$ 就一定能构造出方案，充分性得证。

对于叶子结点，该结论显然成立。考虑归纳，即已知所有子结点所在子树的方案，我们将所有盈余棋子和缺少棋子的子树的方案相接，一定能够两两抵消，最后盈余或缺少的棋子数就为 $sum_x|$ ，显然一定要通过操作 $x$ 连向它父结点的那条边来得到。

于是最后的答案就为 $\sum \limits_{i = 1}^{n}|sum_i|$ ，直接统计即可。

时间复杂度 $\mathcal O(n)$ 。

Algorithm 2

针对 $M = N$ 的数据，原图是一棵基环树。

注意到环的长度的奇偶性会影响原图是否是二分图，因此对环的长度进行讨论。

环的长度为偶数

原图仍然是一个二分图，考虑环对操作次数的影响。

先求出环上每个点下挂着的子树的权值和，记环长为 $m$ ，环上第 $i$ 个点所在子树的权值和为 $A_i$ ， $\sum \limits_{i = 1}^{m}A_i$ 。

同样地，若 $\neq 0$ 无解。

类似树中下界的证明，环上某一条边棋子的移动方向在一种方案中是固定的。

设环上第 $i$ 条边的经过的棋子量为 $x_i$ （其绝对值表示经过的棋子的数目，正负号表示棋子移动的方向）。

可以得到如下的方程组：
$\begin{cases}x_1 - x_2 &= A_1 \\x_2 - x_3 &= A_2 \\x_3 - x_4 &= A_3 \\&... \\x_{m - 1} - x_{m} &= A_{m - 1} \\x_m - x_1 &= A_m \\ \end{cases}$
尝试把所有 $x_i$ 都用 $x_1$ 的表达式写出来，我们需要最小化 $\sum \limits_{i = 1}^{m}|x_i|$ ：
$\begin{cases}x_1 &= x_1 - 0 \\x_2 &= x_1 - A_1 \\x_3 &= x_1 - (A_1 + A_2) \\&...\\x_{m - 1} &= x_1 - \sum \limits_{i = 1}^{m - 2}A_i\\x_m &= x_1 - \sum \limits_{i = 1}^{m - 1}A_i\end{cases}$
考虑把 $y_i = \sum \limits_{j = 1}^{i - 1}A_i(1 \le i \le m)$ 看做数轴上的点，我们需要最小化的即为：
$\begin{aligned}\sum \limits_{i = 1}^{m} |x_1 - y_i|\end{aligned}$
这是一个经典问题， $x_1$ 取 $y_i$ 的中位数即可。

环的长度为奇数

原图不再是一个二分图。

考虑先把环上的某一条边删掉，同样任选一个点为树根进行二分图染色。

那么多出来的这一条边在转化后的模型中就相当于在边的两个端点同时增加或减少一个棋子。

因此若 $sum_{root}$ 为奇数无解，且这条边的操作次数固定，为 $\dfrac{|sum_{root}|}{2}$ 。

因此我们在边的两个端点加上或减去对应数量的棋子后按照树的方式处理即可。

总的时间复杂度 $\mathcal O(n)$ 。

Code

#include <bits/stdc++.h>

template <class T>
inline void read(T &res)
{
	char ch;
	while (ch = getchar(), !isdigit(ch));
	res = ch ^ 48;
	while (ch = getchar(), isdigit(ch))
		res = res * 10 + ch - 48;
}

using std::vector;
typedef long long ll;
const int N = 1e5 + 5;

vector<int> e[N];
bool in_cir[N], vis[N], flag;
int sum[N], b[N];
int col[N], fa[N], sze[N], cir[N];
int n, m, rt, cm, bm;

template <class T>
inline T Abs(T x) {return x < 0 ? -x : x;}

inline void dfs(int x, int Fa)
{
	sum[x] = col[x] == 0 ? 1 : -1;
	for (int i = 0, im = e[x].size(); i < im; ++i)
	{
		int y = e[x][i];
		if (y == Fa)
			continue ;
		col[y] = col[x] ^ 1;
		dfs(y, x);
		sum[x] += sum[y];
	}
}

inline void work1()
{
	for (int i = 1, u, v; i < n; ++i)
	{
		read(u); read(v);
		e[u].push_back(v);
		e[v].push_back(u);
	}
	col[1] = 1;
	dfs(1, 0);
	if (sum[1] != 0)
		puts("-1");
	else
	{
		ll ans = 0;
		for (int i = 1; i <= n; ++i)
			ans += Abs(sum[i]);
		std::cout << ans << std::endl;
	}
}

inline int ufs_find(int x)
{
	if (fa[x] != x)
		return fa[x] = ufs_find(fa[x]);
	return x;
}

inline void ufs_merge(int x, int y)
{
	int tx = ufs_find(x),
		ty = ufs_find(y);
	if (tx != ty)
	{
		if (sze[tx] > sze[ty])
			std::swap(tx, ty);
		fa[tx] = ty;
		sze[ty] += sze[tx];
	}
}

inline void find_circle(int x, int Fa, int des)
{
	cir[++cm] = x;
	if (x == des)
	{
		flag = true; 
		return ;
	}
	for (int i = 0, im = e[x].size(); i < im; ++i)
	{
		int y = e[x][i];
		if (y == Fa)
			continue ;
		find_circle(y, x, des);
		if (flag)
			return ;
	}
	--cm;
} 

inline void work2()
{
	for (int i = 1; i <= n; ++i)
		fa[i] = i, sze[i] = 1;
	for (int i = 1, u, v; i <= n; ++i)
	{
		read(u); read(v);
		if (ufs_find(u) == ufs_find(v))
		{
			rt = u;
			find_circle(u, 0, v);
		}
		else
		{
			ufs_merge(u, v);
			e[u].push_back(v);
			e[v].push_back(u);
		}
	}
	dfs(rt, 0);
	if (cm & 1)
	{
		if (Abs(sum[rt]) & 1)
			puts("-1");
		else
		{
			ll tmp = sum[rt] / 2, ans = 0;
			ans += Abs(tmp);
			for (int i = 1; i <= cm; ++i)
				sum[cir[i]] -= tmp;
			sum[rt] -= tmp;
			for (int i = 1; i <= n; ++i)
				ans += Abs(sum[i]);
			std::cout << ans << std::endl;
		}
	}
	else
	{
		if (sum[rt] != 0)
			puts("-1");
		else
		{
			ll ans = 0;
			for (int i = 1; i <= cm; ++i)
				b[++bm] = sum[cir[i]];
			std::sort(b + 1, b + bm);
			for (int i = 1; i <= cm; ++i)
				sum[cir[i]] = b[bm >> 1] - sum[cir[i]];
			for (int i = 1; i <= n; ++i)
				ans += Abs(sum[i]);
			std::cout << ans << std::endl;
		}
	}
}

int main()
{
	read(n); read(m);
	if (m == n - 1)
		work1();
	else
		work2();
	return 0;
}

Log_x

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
AT2046「AGC004F」Namori

AddressAT2046Algorithm 1针对 M=N−1M = N - 1M=N−1 的数据，原图是一棵树。因为树是二分图，考虑对原图进行二分图染色，每次操作一定是选择二分图两侧的点。考虑把问题进行转化，初始时令二分图某一侧的点上有棋子，每次可以移动任意一个棋子到相邻的没有棋子的点上，询问将所有棋子移到二分图另一侧的点上的最少操作次数。显然有解的必要条件是二分图两侧的点数相同，...
复制链接

扫一扫

专栏目录