AcWing 479. 加分二叉树（ 区间DP + 区间DP输出方案）

一、问题

二、思路

我们首先需要明白的是什么是中序遍历。

对于一棵二叉树而言，树的遍历分为三种，前序遍历，中序遍历，后续遍历。

而这道题表面上考察的是二叉树的知识，而事实上其实考察的是区间DP。

状态表示

$f[l][r]$表示，在区间$[l,r]$的区间内，将其构成一棵树时，我们能获得的最大加分。

状态转移

根据题目的要求，区间表示的是中序遍历。那么关键在于我们需要找一个点当作我们的根节点，那么这个节点的左侧序列就构成了左子树的中序遍历。这个节点的右侧就是当前根节点的右子树的中序遍历。

这个区间内每个点其实都有可能是根节点，因此我们可以枚举所有可能的根节点，然后选出一个最大值。

那么根据题目中的要求，我们其实需要分三类情况进行讨论：

第一种情况：有两个子树
第二种情况：只有一个子树
第三种情况：没有子树

上面三种情况对应的加分是不同的。

对于第一种情况而言，我们的加分是：左子树加分*右子树加分 + 根节点分数

$$f[l][r]=f[l][k-1]\ast f[k+1][r]+a[k];$$

对于第二种情况而言，我们的加分是：一个子树的分数 + 根节点的分数
$$f[l][r]=a[r]+f[l][r-1];$$
或者
$$f[l][r]=a[l]+f[l+1][r];$$

对于第三种情况而言，我们的加分是：根节点的分数
$$f[l][r]=a[l]$$

因此，我们只需要在枚举根节点的过程中，对上面的情况分类讨论即可。

循环设计

最外层枚举区间长度，第二层枚举区间左端点。

第三层就是去枚举根节点。

初末状态

初始化为0即可。

方案输出

方案输出的话，其实思路和背包问题中的方案输出逻辑是一样的。

我们求答案是从小规模到大规模，输出方案的话，则是从大方案到小方案。

如果不知道背包问题如何输出方案的话，可以去看作者之前的文章：

AcWing 1013. 机器分配（分组背包问题与方案记录）

当然由于是一棵树，所以需要将for循环写成写成DFS。

如果这种方法不懂得话，可以直接开个数组记录一下，也是可以的。

三、代码

这里写的比较麻烦，大家如果感兴趣的话，有些讨论或许可以合并从而简化代码，作者这里就不简化了。

#include<bits/stdc++.h>
using namespace std;
const int N = 50;
int f[N][N];
int a[N];
int n;

void dfs(int l, int r)
{
	if(l == r)
	{
		cout << l << " ";
		return;
	}
	if(r - l == 1)
	{
		cout << l << " " << r <<" ";
		return;
	}
	for(int k = l; k <= r; k ++ )
	{
		if(k == l)
		{
			if(f[l][r] == a[l] + f[l + 1][r])
			{
				cout << k <<" ";
				dfs(l + 1, r);
				break;  
			}
		}
		else if(k == r)
		{
			if(f[l][r] == a[r] + f[l][r - 1])
			{
				cout << r << " ";
				dfs(l, r - 1);
				break;
			}
		}
		else
		{
			if(f[l][r] == f[l][k - 1] * f[k + 1][r] + a[k])
			{
				cout << k << " ";
				dfs(l, k - 1);
				dfs(k + 1, r);
				break;
			}	
		}

	}
	return;
}

int main()
{
	cin >> n;
	for(int i = 1; i <= n; i ++ )
		cin >> a[i];
	for(int len = 1; len <= n; len ++ )
	{
		for(int l = 1; l + len - 1 <= n; l ++ )
		{
			int r = l + len - 1;
			if(len == 1)
				f[l][r] = a[l];
			else
			{
				for(int k = l; k <= r; k ++ )
				{
					if(k == l)
					{
						f[l][r] = max(f[l][r], a[l] + f[l + 1][r]);
					}
					else if(k == r)
					{
						f[l][r] = max(f[l][r], a[r] + f[l][r - 1]);
					}
					else
						f[l][r] = max(f[l][k - 1] * f[k + 1][r] + a[k], f[l][r]);
				}
			}
		}
	}
	cout << f[1][n] << endl;
	dfs(1, n);
	return 0;
}