【动态规划 记忆化搜索】JZOJ_6287 扭动的树

题意

给出$n$个节点$<key,val>$，其中键值为$key$，权值为$val$，用它们建一颗$BST$，且保证任意一条边的两个节点的$gcd$不为$1$。

定义某个节点的$sum$为其子树中所有$val$的和。

最大化$sum$，不存在这颗树输出-$1$。

思路

对于$BST$，根据其性质把$key$排序，那就为这颗树的中序遍历了。

枚举一个点作为根，在中序遍历中把区间分成两部分，左边代表左儿子，右边代表右儿子，再从中选出一个节点与根连接，判断是否可行$（gcd$不为$1）$，更新答案。

利用递归处理，并记忆化剪枝。时间复杂度$O(n^3)$

代码

#include<cstdio>
#include<algorithm>
#define file(x) freopen(#x".in", "r", stdin), freopen(#x".out", "w", stdout)

struct node {
	long long key, val;
}p[301];

int n;
long long ans;
int pre[301], gcd[302][302];
long long f[302][302][2];

bool operator <(const node &a, const node &b) {
	return a.key < b.key;
}

void dp(int l, int r, int s) {
	if (l > r || f[l][r][s]) return;
	int root = s ? l - 1 : r + 1;
	for (int i = l; i <= r; i++) {
		if (gcd[root][i] == 1) continue;
		dp(l, i - 1, 0);
		dp(i + 1, r, 1);
		if (f[l][i - 1][0] < 0 || f[i + 1][r][1] < 0) continue;
		f[l][r][s] = std::max(f[l][r][s], f[l][i - 1][0] + f[i + 1][r][1] + pre[r] - pre[l - 1]);
	}
	if (!f[l][r][s]) f[l][r][s] = -1;
}

int main() {
	file(tree);
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
		scanf("%lld %d", &p[i].key, &p[i].val);
	std::sort(p + 1, p + n + 1);
	for (int i = 1; i <= n; i++) {
		pre[i] = pre[i - 1] + p[i].val;
		for (int j = i + 1; j <= n; j++)
			gcd[i][j] = gcd[j][i] = std::__gcd(p[i].key, p[j].key);		
	}
	ans = -1;
	for (int i = 1; i <= n; i++) {
		dp(1, i - 1, 0);
		dp(i + 1, n, 1);
		if (f[1][i - 1][0] < 0 || f[i + 1][n][1] < 0) continue;
		ans = std::max(ans, f[1][i - 1][0] + f[i + 1][n][1] + pre[n]);
	}
	printf("%lld", ans);
}