动态规划刷题记录（3）

1、涂色

区间dp问题属于动态规划的一种，当我们需要从左右边界问题入手划分区间时，就需要考虑区间dp 。区间dp最麻烦的地方就在于他的暴力思路很难想，等你想出来之后估计都知道dp怎么做了。

那么这道题目状态划分：f（i ，j）表示使得区间i到j变为同色所需要的最小操作数。那么我们状态划分就可以分为两大类：1、i处的颜色 == j处的颜色，这时候f(i ,j) = f(i + 1 ,j - 1)。2、i处的颜色 ！=j处的颜色，那么我们就看看f(i + 1 ,j) 和 f(i ,j - 1)哪一种状态更优。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>

using namespace std;

#define N 6000

int f[N][N] ,n ,c[N];

int main()
{
    cin >> n;
    for (int i = 1 ;i <= n ;i ++)
    {
        cin >> c[i];
        if (i && c[i] == c[i - 1]) i -- ,n --;//这是一个细节可以注意一下，如果相邻的颜色块已经相同，为了加快运算速度，我们就把
        //初始就相同的连通块看成一个单位
    }
    
    for (int len = 2 ;len <= n ;len ++)
    {
        for (int l = 1 ;l + len - 1 <= n ;l ++)//l + len - 1 <= n表示右端点不能超过n
        {
            int r = l + len - 1;
            
            if (c[l] == c[r]) f[l][r] = f[l + 1][r - 1] + 1;
            else
            {
                f[l][r] = min(f[l][r - 1] ,f[l + 1][r]) + 1;
            }
        }
    }
    
    cout << f[1][n];
    
    return 0;
}

2、

 这个题目说了这么多，其实关键信息就那么多。给你一串珠子（头尾相连），两个珠子合并可以释放能量，释放的能量是m * r * n，问你怎么合并可以得到的能量最多。典型的区间dp问题，其核心就是由小区间逐步推导大区间。就好比我们现在有一串珠子是123，我们先求出12合并能量，再求出23合并的能量，再求出13合并的能量，然后我们就可以看看哪两种先合并可以让这三个珠子合并的结果能量最大。这个题目还有一个问题需要解决，那就是我们怎么把环形转化为线性，我们对于珠子1234可以开一个二倍数组储存：12341234，这样你可以发现，我们从中任意截取任何一段长为4的线段就可以枚举所有结果了。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>

using namespace std;

#define N 300

struct node{
    int head ,end;
}q[N];

int f[N][N] ,n;

int main()
{
    cin >> n;
    for (int i = 1 ;i <= n ;i ++)
    {
        cin >> q[i].head;
        
        q[i + n].head = q[i].head;
        if (i > 1) q[i - 1].end = q[i].head ,q[i - 1 + n].end = q[i].head;
        if (i == n) q[i].end = q[1].head ,q[i + n].end = q[1].head;
    }

    for (int len = 2 ;len <= n ;len ++)
    {
        for (int l = 1 ;l + len - 1 <= n * 2 ;l ++)
        {
            int r = l + len - 1;
            
            if (len == 2) f[l][r] = q[l].head * q[l].end * q[r].end;
            else
            {
                for (int k = l ;k < r ;k ++) f[l][r] = max(f[l][r] ,f[l][k] + f[k + 1][r] + q[l].head * q[k].end * q[r].end);
            }
        }
    }
    
    int res = 0;
    for (int i = 1 ;i <= n ;i ++) res = max(res ,f[i][i + n - 1]);
    
    cout << res;
    return 0;
}

3、加分二叉树

 

区间dp的应用。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

#define N 50

int f[N][N] ,g[N] ,n ,w[N][N];//w集合用来存l到r的最优方案方案的根节点

void dfs(int l ,int r)//输出二叉树的前序遍历
{
    if (l > r) return;
    
    int root = w[l][r];
    cout << root << ' ';
    dfs(l ,root - 1);
    dfs(root + 1 ,r);
}

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