区间DP经典模型

标签：content   std   otto   表示   状态转移方程   const   ios   family   psu   

http://blog.csdn.net/y990041769/article/details/24238547

先附上一个链接 后面有引用的代码

概述

区间 DP：是指在一段区间上进行的一系列动态规划。

对于区间 DP 这一类问题，我们需要计算区间 [1,n] 的答案，通常用一个二维数组 dp 表示，其中 dp[x][y] 表示区间 [x,y]。

有些题目，dp[l][r] 由 dp[l][r-1] 与 dp[l+1][r] 推得;

也有些题目，我们需要枚举区间 [l,r]内的中间点，由两个子问题合并得到，也可以说 dp[l][r] 由 dp[l][k] 与 dp[k+1][r] 推得，其中 l≤k<r。

对于长度为 n 的区间 DP，我们可以先计算 [1,1],[2,2]…[n,n] 的答案，再计算 [1,2],[2,3]…[n?1,n]，以此类推，直到得到原问题的答案。

例 1：石子归并问题

题目描述

当前有 N 堆石子，他们并列在一排上，每堆石子都有一定的数量。

我们需要把这些石子合并成为一堆，每次合并都只能把相邻 的两堆合并到一起，

每一次合并的代价都是这两堆石子的数量之和，经过 N-1次合并后成为一堆。求把这些石子合并成一堆所需的最小代价。

解析

根据动态规划的思想，我们只要求出每两堆石子合并的最小代价，然后再求出每三堆石子合并的最小代价，

并以此类推就能最终求出 n 堆石子合并的最小代价。

我们把 dp[i][j] 定义为合并第 i 堆石子到第 j 堆石子所需的最小代价。

很容易就能得到 dp[i][j] = min(dp[i][k] + dp[k+1][j])。

显然通过这个式子，我们可以按代价从小到大的顺序进行枚举来不断让石子进行合并，最终就能获得合并成一堆石子的最小代价。

时间复杂度是 O(n?3??)。

memset(dp, 0, sizeof(dp));
for (int l = 2; l <= n; ++l) {
    for (int i = 0, j; i <= n - l; ++i) {
        j = i + l - 1;
        dp[i][j] = inf;
        for (int k = i; k < j; ++k) {
            dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);
        }
    }
}

dp[i][j] = judge(i,j) ? dp[i+1][j-1] + 2 : dp[i + 1][j - 1]; //judge()函数功能为判断第i个括号与第j个括号是否匹配,若匹配返回 `true` ，否则返回 `false`。

#include <iostream>  
#include <cstring>  
#include <algorithm>  
#include <string>  
using namespace std;  
const int  N = 120;  
int dp[N][N];  
int main()  
{  
    string s;  
    while(cin>>s)  
    {  
        if(s=="end")  
            break;  
        memset(dp,0,sizeof(dp));  
        for(int i=1;i<s.size();i++)  
        {  
            for(int j=0,k=i;k<s.size();j++,k++)  
            {  
                if(s[j]==‘(‘&&s[k]==‘)‘ || s[j]==‘[‘&&s[k]==‘]‘)  
                    dp[j][k]=dp[j+1][k-1]+2;  
                for(int f=j;f<k;f++)  
                    dp[j][k]=max(dp[j][k],dp[j][f]+dp[f+1][k]);  
            }  
        }  
        cout<<dp[0][s.size()-1]<<endl;  
    }  
    return 0;  
}  

memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; n++) {
    dp[i][1] = a[1][i];
}
for (int j = 2; j <= m; j++) {
    for (int i = j; i < n; i++) {
        dp[i][j] = a[i][i];
        for (int k = 1; k < i; k ++) {
            dp[i][j] = max(dp[i][j], dp[k][j - 1] * a[k + 1][i]);
        }
    }
}
printf("%lld\n", dp[n - 1][m]);

区间DP经典模型

标签：content   std   otto   表示   状态转移方程   const   ios   family   psu   

原文地址：http://www.cnblogs.com/wangkaipeng/p/6759588.html