区间动态规划

        区间动态规划，又称合并类动态规划，顾名思义，区间动态规划的题目一般来说是在操作每一个区间，（例如将两堆石子合并在一起，获得的价值是两堆石子的总价值）并获得相应的价值。当然，与线形动态规划有所不同的是，它要操作的子区间是要选择最优的。这时，我们就不能套用类似于线形动态规划的方程了，于是，便引出了区间动态规划。

区间动态规划有属于自己的一类方程：

for(int t = 1; t <= n; t++){//区间长度
    for(int i = 1; i <= n - t; i++){//枚举区间起始位置(l) 
		int j = i + t;//该区间所能走到的最远点(r) 
		f2[i][j] = 0x3f3f3f3f;
		f1[i][j] = 0;
		for(int k = i; k <= j - 1; k++){//枚举区间中间点
			f1[i][j] = max(f[i][j], f[i][k] + f[k+1][j] + val[i-j]);
			f2[i][j] = min(m[i][j], m[i][k] + m[k+1][j] + val[i-j]);
            //区间[i,j]由两个区间[i,k] 和 [k + 1,j]的值再加上合并这两个区间的附加值加和而成 
		}   
	}	
}

  1. 状态转移方程字面意义：寻找区间dp[i,j]的一种合并方式dp[i,k] + dp[k+1,j]，使得其值最大或最小。
  2. 区间长度t必须要放到第一层循环，来保证方程中状态dp[i,k]、dp[k+1,j]值在dp[i,j]之前就已计算出来。
  3. 其中val[i-j]可以不要，也可以灵活多变，指的是合并区间时产生的附加值。

那么，我们很容易看出这类方程的含义：将目前阶段f[i][j]分成两个子阶段f[i][k] 与 f[k+1][j]，选择他们两个的和于目前的状态的最优解。

简单的说一下，区间动态规划相当于将一个大的区间分成两个小的子区间，一般可以用循环或者搜索解决。几乎任何一个动态规划方程都需要最初的决策啊。因为要把多阶段过程转化为一系列单阶段问题，利用各阶段之间的关系，逐个求解。那么，我们一般要预处理我们的最初的决策（不同题目不同的最初的决策）

下面看一道裸的区间dp题

石子合并

直接上代码：

#include<iostream>
#include<cstdio>
using namespace std;
const int MAX_N = 105;
int a[MAX_N << 1],sum[MAX_N << 1],f[MAX_N << 1][MAX_N << 1],m[MAX_N << 1][MAX_N << 1];
int main(){
    int n,ans = 0, ans2 = 0x3f3f3f3f;
    cin >> n;
    for(int i = 1; i <= n; i++){
        scanf("%d",&a[i]);
        a[i + n] = a[i];
    }
    for(int i = 1; i <= 2 * n; i++){
        sum[i] = sum[i-1] + a[i];//前缀和 
        m[i][i] = 0;
        f[i][i] = 0;
    }
    for(int t = 1; t <= n; t++){//需要的区间长度 
        for(int i = 1; i <= 2 * n - t; i++){//枚举区间起始位置(l) 
            int j = i + t;//该区间所能走到的最远点(r) 
            m[i][j] = 0x3f3f3f3f;
            f[i][j] = 0;
            for(int k = i; k <= j - 1; k++){//枚举区间中间点 
                f[i][j] = max(f[i][j], f[i][k] + f[k+1][j] + sum[j] - sum[i-1]);
                m[i][j] = min(m[i][j], m[i][k] + m[k+1][j] + sum[j] - sum[i-1]);
                //区间[i,j]由两个区间[i,k] 和 [k + 1,j]的值再加上合并这两个区间的附加值加和而成 
            }
        }
    }
    for(int i = 1; i <= n; i++) {//区间dp完成后，枚举长度为n的区间的最值 
        ans = max(ans, f[i][i + n - 1]);
        ans2 = min(ans2,m[i][i + n - 1]);
    }
    cout << ans2 << endl << ans; 
    return 0; 
}

还有一题：

能量项链

直接上代码：

#include<iostream>
#include<cstdio>
using namespace std;
const int MAX_N = 105;
int head[MAX_N << 1],tail[MAX_N << 1],f[MAX_N << 1][MAX_N << 1];
int main(){
    int n,ans = 0;
    cin >> n;
    for(int i = 1; i <= n; i++){
        scanf("%d",&head[i]);
        head[i + n] = head[i];
    }
    for(int i = 1; i <= 2 * n - 1; i++){
        tail[i] = head[i+1];
    }
    tail[2 * n] = head[1];
    tail[n] = head[1];
    for(int t = 1; t <= n; t++){//需要的区间长度
        for(int i = 1;i <= 2 * n - t; i++){//枚举区间起始位置(l) 
            int j = i + t;//该区间所能走到的最远点(r) 
            //cout << i << " " << j << endl; 
            for(int k = i; k <= j - 1; k++){//枚举区间中间点 
                f[i][j] = max(f[i][j], f[i][k] + f[k+1][j] + head[i] * tail[k] * tail[j]);
                //区间[i,j]由两个区间[i,k] 和 [k + 1,j]的值再加上合并这两个区间的能量加和而成 
                ans = max(ans,f[i][j]);//找出枚举的区间最大值（最大值一定是1~n全选了） 
            }
        }
    }
    cout << ans << endl; 
    return 0; 
}