dp之区间dp

区间dp：
当发现，解决这个问题的最后一步是关于区间的操作的时候，可以使用区间dp

acwing 环形石子合并
将 n 堆石子绕圆形操场排放，现要将石子有序地合并成一堆。

规定每次只能选相邻的两堆合并成新的一堆，并将新的一堆的石子数记做该次合并的得分。

请编写一个程序，读入堆数 n 及每堆的石子数，并进行如下计算：

选择一种合并石子的方案，使得做 n−1 次合并得分总和最大。
选择一种合并石子的方案，使得做 n−1 次合并得分总和最小。
输入格式
第一行包含整数 n，表示共有 n 堆石子。

第二行包含 n 个整数，分别表示每堆石子的数量。

输出格式
输出共两行：

第一行为合并得分总和最小值，

第二行为合并得分总和最大值。

思路：
dp问题进行思考的时候，一般是考虑这个问题，他解决方法的最后一步是什么

首先通过一个技巧，解决环的问题
一般环的问题，就把它拉成链来考虑

也就是把1 ~ n复制一遍从n + 1开始放

然后看
2n个石子进行合并，并且合并区间最长是n

那么需要解决的也就是合并n个石子，怎么计算出最值

首先考虑合并n个石子，它的最后一步是什么

题中指明了是相邻的，那么当到最后一步的时候，一定是合并2个相邻的堆，使他们成为一堆

那么这2个相邻的堆看成是2个区间，所以如果要算n个石子合并的最值，就只需要枚举一下所有区间的分割点，然后推出当前区间的最值

设置
f[i ,j]表示i~j这个区间的最值，k为分割点

f[i, j] = max or min (f[i, j],f[i, k] + f[k + 1],j + sum(i ~ j))

还要注意初始化当求最大值的时候，初始化为0，最小值的时候初始化为正无穷

最后的答案，就枚举一下所有长度为n的区间取最值

#include <iostream>
#include <cstring>

using namespace std;

const int N = 410;
int a[N];
int f[N][N],f2[N][N];
int n;

int main()
{
    cin >> n;
    for(int i = 1;i <= n;i ++)
    {
        cin >> a[i];
        a[i + n] = a[i];
    }
    
    for(int i = 1;i <= 2 * n;i ++) a[i] += a[i - 1];
    
    for(int len = 2;len <= n;len ++)
        for(int i = 1;i + len - 1 <= 2 * n;i ++)
        {
            int j = i + len - 1;
            f2[i][j] = 0x3f3f3f3f;
            for(int k = i;k < j;k ++) 
            {
                f[i][j] = max(f[i][j],f[i][k] + f[k + 1][j] + a[j] - a[i - 1]);
                f2[i][j] = min(f2[i][j],f2[i][k] + f2[k + 1][j] + a[j] - a[i - 1]);
            }
        }
        
    int res1 = 0,res2 = 0x3f3f3f3f;
    for(int i = 1;i <= n;i ++)
    {
        res1 = max(res1,f[i][i + n - 1]);
        res2 = min(res2,f2[i][i + n - 1]);
    }
    
    cout << res2 << endl << res1 << endl;
    
    return 0;
}

acwing 加分二叉树
设一个 n 个节点的二叉树 tree 的中序遍历为（1,2,3,…,n），其中数字 1,2,3,…,n 为节点编号。

每个节点都有一个分数（均为正整数），记第 i 个节点的分数为 di，tree 及它的每个子树都有一个加分，任一棵子树 subtree（也包含 tree 本身）的加分计算方法如下：

subtree的左子树的加分 × subtree的右子树的加分 ＋ subtree的根的分数

若某个子树为空，规定其加分为 1。

叶子的加分就是叶节点本身的分数，不考虑它的空子树。

试求一棵符合中序遍历为（1,2,3,…,n）且加分最高的二叉树 tree。

要求输出：

（1）tree的最高加分

（2）tree的前序遍历

输入格式
第 1 行：一个整数 n，为节点个数。

第 2 行：n 个用空格隔开的整数，为每个节点的分数（0<分数<100）。

输出格式
第 1 行：一个整数，为最高加分（结果不会超过int范围）。

第 2 行：n 个用空格隔开的整数，为该树的前序遍历。如果存在多种方案，则输出字典序最小的方案。

思路：
中序遍历
父节点在中，左儿子在左，右儿子在右

所以当枚举所有父节点的时候，可以把序列分成2个区间。左边是左儿子，右边是右儿子

那么就可以用区间dp做

设
f[i,j] 为i ~ j这个区间最值，k为父节点
所以
f[i,j] = max(f[i,j],f[i,k -1],f[k + 1,j])

然后考虑特殊情况
1.当是叶节点的时候，也就是区间长度为1的时候，值对应的就是本身
2.当子节点是空的时候，也就是说当我们枚举父节点的时,k为i和j的时候，子节点值为1

然后输出先序遍历的话，可以在dp的过程中记录一下，最值的时候，父节点是那个，然后递归输出

#include <iostream>

using namespace std;

const int N = 40;
int f[N][N];
int g[N][N];
int n,a[N];

void dfs(int l,int r)
{
    if(l > r) return;
    cout << g[l][r] << " ";
    dfs(l,g[l][r] - 1);
    dfs(g[l][r] + 1,r);
}

int main()
{
    cin >> n;
    for(int i = 1;i <= n;i ++) cin >> a[i];
    
    for(int len = 1;len <= n;len ++)
        for(int i = 1;i + len - 1 <= n;i ++)
        {
            int j = i + len - 1;
            if(len == 1) f[i][j] = a[i],g[i][j] = i;
            else 
            {
                for(int k = i;k <= j;k ++)
                {
                    int left = k == i? 1 : f[i][k - 1];
                    int right = k == j ? 1 : f[k + 1][j];
                    if(f[i][j] < left * right + a[k])
                    {
                        f[i][j] = left * right + a[k];
                        g[i][j] = k;
                    }
                }
            }
        }
        
    cout << f[1][n] << endl;
    dfs(1,n);
    cout << endl;
    
    return 0;
}