2022“杭电杯”中国大学生算法设计超级联赛（8）

http://acm.hdu.edu.cn/contest/problems?cid=1051

---

Orgrimmar（树形DP）

题意
给定一棵树，问在满足下面条件的前提下，最多能拿多少节点？

• 所拿的节点中，如果保留树中这些节点之间的边，要保证每个点只会有一个连边。

换句话说，所拿的点在树中不能有超过 2 个点连续。

$1\le T\le 10,n\le 5\ast 10^5$

思路
树形DP
不能有超过 2 个点连续，那么对于以当前节点 x 为根的子树中，如果当前节点拿了，那么其子节点可以不拿，也可以只拿一个。如果当前节点没拿，那么其子节点可以不拿，可以拿一个，也可以往下连续拿两个。所以此时，用当前点拿不拿这两个状态已经不能表示了，需要多加一个状态，表示拿了几个。

状态定义 f[i, 0] 表示，当前节点不拿，以该节点为根的子树中可拿的最大节点数。
f[i, 1] 表示，当前节点拿了并且其子节点还拿，…。
f[i, 2] 表示，只拿当前节点，…。

对于以节点 x 为根的子树来说：

• 如果当前节点不拿，那么其子节点可以拿一个，可以拿连续两个，即 f[x][0] += max(f[tx, 0], f[tx, 1], f[tx, 2])；
• 如果当前节点拿了并且子节点还要拿一个，那么所有的子节点中挑一个拿，而其余子节点都不拿，找所有情况中的最大值来转移，即 maxa = max(maxa, f[tx, 2] + sum - f[tx, 0]); f[x, 1] += maxa，sum为 f[tx, 0] 之和；
• 如果只拿当前节点，那么其子节点都不可拿，即 f[x, 2] += f[tx, 0]；

所以转移方程为：

void dfs(int x, int fa)
{
	f[x][1] = f[x][2] = 1;
	
	int sum = 0;
	for(int tx : e[x])
	{
		if(tx == fa) continue;
		dfs(tx, x);
		f[x][0] += max(f[tx][0], max(f[tx][1], f[tx][2]));
		f[x][2] += f[tx][0];
		sum += f[tx][0];
	}
	int maxa = 0;
	for(int tx : e[x])
	{
		if(tx == fa) continue;
		maxa = max(maxa, f[tx][2] + sum - f[tx][0]);
	}
	f[x][1] += maxa;
}

Code

#include<bits/stdc++.h>
using namespace std;

const int N = 500010, mod = 1e9+7;
int T, n, m;
int f[N][3];
vector<int> e[N];

void dfs(int x, int fa)
{
	f[x][1] = f[x][2] = 1;
	
	int sum = 0;
	for(int tx : e[x])
	{
		if(tx == fa) continue;
		dfs(tx, x);
		f[x][0] += max(f[tx][0], max(f[tx][1], f[tx][2]));
		f[x][2] += f[tx][0];
		sum += f[tx][0];
	}
	int maxa = 0;
	for(int tx : e[x])
	{
		if(tx == fa) continue;
		maxa = max(maxa, f[tx][2] + sum - f[tx][0]);
	}
	f[x][1] += maxa;
}

signed main(){
	int size(512<<20);  // 512M
    __asm__ ( "movq %0, %%rsp\n"::"r"((char*)malloc(size)+size));
	
	scanf("%lld", &T);
	while(T--)
	{
		scanf("%lld", &n);
		
		for(int i=1;i<=n;i++){
			e[i].clear();
			f[i][0] = f[i][1] = f[i][2] = 0;
		}
		
		for(int i=1;i<n;i++)
		{
			int x, y; scanf("%lld%lld", &x, &y);
			e[x].push_back(y);
			e[y].push_back(x);
		}
		
		dfs(1, 0);
		
		printf("%lld\n", max(f[1][0], max(f[1][1], f[1][2])));
	}
	
	exit(0);
	return 0;
}

一开始没想清楚就直接上去写了，状态 f[i, 2] 想错了，觉得这个是连续两个中后面一个，上面一定有一个，就完全忽略了独立存在一个点的情况。

---

Stormwind（枚举）

题意
给定 n*m 的棋盘，每次可以沿着线切一刀。
问，在满足切出的矩形面积不小于 k 的条件下，最多能切多少刀？

$1\le T\le 100,1\le n,m,k\le 10^5$

思路
枚举切过之后，每一块的列宽。m/列宽 - 1 即为列方向上切的数量。
对于当前列宽，求出满足的最小行宽。n/行宽 - 1 即为行方向上切的数量。

用 k / 列宽 上取整求行宽再求行数，不能用一开始想的，用 n*列宽 / k 下取整求行数。

Code

#include<bits/stdc++.h>
using namespace std;

#define Ios ios::sync_with_stdio(false),cin.tie(0)

const int N = 200010, mod = 1e9+7;
int T, n, m;
int a[N];

signed main(){
	Ios;
	cin >> T;
	while(T--)
	{
		int k; cin >> n >> m >> k;
		
		int ans = 0;
		for(int i=1;i<=m;i++)
		{
			int lieshu = i;
			int liekuan = m / lieshu;
			if(liekuan == 0) continue;
			int hangkuan = (k+liekuan-1)/liekuan;
			if(hangkuan == 0) continue;
			int hangshu = n/hangkuan;
			if(hangshu == 0) continue;
			ans = max(ans, lieshu + hangshu - 2);
		}
		cout << ans << endl;
	}
	
	return 0;
}

---

Theramore（思维，奇偶）

题意
给定长度为 n 的 01 串，每次可以翻转长度为奇数的子串。
输出翻转若干次后，能够得到字典序最小的串。

思路
如果两个位置之间隔了奇数个位置的话，这两个位置可以直接换。（翻转过之后，除去两个端点再翻转回来）

所以为了使得字典序最小，从前往后，对于一个为 1 的位置，可以和后面与其奇偶性相同的最后一个 0 相交换。维护两个队列，每次取队尾即可。

Code

#include<bits/stdc++.h>
using namespace std;

#define Ios ios::sync_with_stdio(false),cin.tie(0)

const int N = 200010, mod = 1e9+7;
int T, n, m;
char a[N];

signed main(){
	Ios;
	cin >> T;
	while(T--)
	{
		cin >> a + 1;
		n = strlen(a+1);
		
		deque<int> que1, que2;
		for(int i=1;i<=n;i++)
		{
			if(a[i] == '1') continue;
			if(i % 2) que1.push_back(i);
			else que2.push_back(i);
		}
		
		for(int i=1;i<=n;i++)
		{
			if(a[i] == '0') continue;
			if(i % 2)
			{
				if(que1.size() && que1.back() > i){
					int t = que1.back();
					swap(a[i], a[t]);
					que1.pop_back();
				}
			}
			else
			{
				if(que2.size() && que2.back() > i){
					int t = que2.back();
					swap(a[i], a[t]);
					que2.pop_back();
				}
			}
		}
		for(int i=1;i<=n;i++) cout << a[i];
		cout << endl;
	}
	
	return 0;
}