区间dp

数字三角形

题目：给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。

        7
      3   8
    8   1   0
  2   7   4   4
4   5   2   6   5

代码：

#include <iostream>
#include <algorithm>

using namespace std;
const int N = 510, INF = 0x3f3f3f3f;
int f[N], a[N][N]; // f[i][j]: 三角形顶点到第i行第j个点的最大距离，此处采取滚动数组降低一维。

int main()
{
    int n;
    cin >> n;
    
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= i ; j++)
            cin >> a[i][j];
    
    for(int i = 0; i <= n + 1; i++) //  0和n+1虽无实际意义，但递推会用到
            f[i] = -INF;
            
    f[1] = a[1][1];
            
    for(int i = 2; i <= n; i++)
        for(int j = i; j >= 1 ; j--)
            f[j] = a[i][j] + max(f[j], f[j-1]); 
    
    int ans = -INF;
    for(int i = 1; i <= n; i++) ans = max(ans, f[i]);
    cout << ans;
    
    return 0;
}

 

最长上升子序列

题目：
给定一个长度为N的数列，求数值严格单调递增的子序列的长度最长是多少。

输入：
7
3 1 2 1 8 5 6

输出：
4

代码：

#include <iostream>

using namespace std;
const int N = 1010;
int f[N], a[N]; // f[i]: 以第i个数(即a[i])结尾的最长子序列长度

int main()
{
    int n;
    cin >> n;
    
    for (int i = 1; i <= n; i++) cin >> a[i];
        
    for (int i = 1; i <= n; i++)
    {
        f[i] = 1; // 至少存在结尾a[i]使其长度为1
        for(int j = 1; j < i; j++)
            if(a[j] < a[i]) f[i] = max(f[i], f[j] + 1);
    }
            
    int ans = 0;
    for (int i = 1; i <= n; i++) ans = max(ans, f[i]);
    cout << ans;
    
    return 0;

}

 

最长公共子序列

题目：
给定两个长度分别为N和M的字符串A和B，求既是A的子序列又是B的子序列的字符串长度最长是多少。

输入：
4 5
acbd
abedc

输出：
3

代码：

#include <iostream>
#include <algorithm>

using namespace std;
const int N = 1010;
int f[N][N]; // f[i][j]：a串前i端与b串前j段的最长公共子序列长度
char a[N], b[N];

int main()
{
    int n, m;
    cin >> n >> m;
    cin >> (a + 1);
    cin >> (b + 1);
    
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
        {
            f[i][j] = max(f[i-1][j], f[i][j-1]);
            if(a[i] == b[j]) f[i][j] = f[i-1][j-1] + 1;
        }
    cout << f[n][m];
    return 0;
}

 

石子合并

题目：
设有N堆石子排成一排，其编号为1，2，3，…，N。
每堆石子有一定的质量，可以用一个整数来描述，现在要将这N堆石子合并成为一堆。
每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并后与这两堆石子相邻的石子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同。

输入：
4
1 3 5 2

输出：
22

代码：

#include <iostream>
#include <algorithm>

using namespace std;
const int N = 310, INF = 0x3f3f3f3f;
int f[N][N], s[N]; // f[i][j]: 合并区间[i,j]所需最小代价
int main()
{
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> s[i];
    
    for (int i = 1; i <= n; i++) s[i] += s[i-1];  // 前缀和数组
    
    for(int len = 2; len <= n; len ++)  // 区间长度
        for (int l = 1; l + len - 1 <= n ; l++) // 区间左端点的位置
        {
            int r = len + l - 1;
            f[l][r] = INF; // 当l=r时， 无需合并，已默认初始化为0
            for(int k = l; k < r; k ++) // 需找区间分界点
                f[l][r] = min(f[l][r], f[l][k] + f[k+1][r] + s[r] - s[l-1]);
        }
        
    cout << f[1][n];
    
    return 0;
}