区间DP学习

其实我的DP本来也没学好，一直不太会找状态转移方程，一步步来吧，今天先整理一下区间DP。
参考： https://blog.csdn.net/my_sunshine26/article/details/77141398?utm_source=app
（发现写的不错）

区间DP，主要思想：在小区间进行DP取得最优解，之后利用各个区间的最优解合并求解最大区间的最优解。

模板（自个写的，当然应用的时候不要生搬硬套）：

 for(int len=0;len<n;len++)//区间长度
    {
        for(i=1;i<=n-len;i++)//枚举起点
        {
            j=i+len;//枚举终点
            dp[i][j]=inf;
            for(int k=i;k<=j;k++)/*枚举分割点，把i到j分割成多个区间，
                                    构造方程*/
            {
                dp[i][j]=min(dp[i][j],dp[i][k-1]+dp[k+1][j]+...);
            }
        }
    }

对于DP数组的初始化，以及“…”的确定就要开动脑筋，因题而异了。

EX1 UPC（混合7）问题A 狼

在某个游戏中，你接受了一个任务。这个任务要求你消灭n只狼。这些狼排成一排，每只狼都有两个攻击力a和b。如果你消灭一只狼，需要的代价是这只狼的a攻击力加上它旁边的狼的b攻击力。每消灭一头狼，它两边的狼（如果有）会并在一起，仍然保持一排。
你需要求出：消灭所有狼的最小代价。
输入
输入第一行为一个正整数n。
输入第二行为n个非负整数，按顺序表示每只狼的a攻击力；第三行为n个非负整数，表示每只狼的b攻击力。
输出
输出一行一个整数，为最小的代价。
样例输入
3
3 5 7
8 2 0
样例输出
17
提示
对于100%的数据，满足1≤n≤400，每只狼的a攻击力和b攻击力均不超过100000。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <math.h>
#include <vector>
#include <queue>
#include <ctime>
#include <ctype.h>
#define ll long long
//#define local
#define inf  0x3f3f3f3f
using namespace std;
const int N = 500;
int a[N];
int b[N];
int dp[N][N];
int n,m,i,j;
int main()
{
#ifdef local
    freopen("input.txt","r",stdin);
#endif // local
    scanf("%d",&n);
    for(i=1;i<=n;i++)
        scanf("%d",&a[i]);
    for(i=1;i<=n;i++)
        scanf("%d",&b[i]);
    memset(dp,0,sizeof(dp));
    for(i=1;i<=n;i++)
    {
        dp[i][i]=a[i]+b[i-1]+b[i+1];//初始化
    }
    for(int len=0;len<n;len++)//区间长度，枚举0到n-1
    {
        for(i=1;i<=n-len;i++)//枚举起点
        {
            j=i+len;//枚举终点
            dp[i][j]=inf;//因为要求最小值
            for(int k=i;k<=j;k++)/*枚举分割点，把i到j分割成多个区间，
                                 构造方程*/
            {
                dp[i][j]=min(dp[i][j],dp[i][k-1]+dp[k+1][j]+a[k]+b[i-1]+b[j+1]);
            }
        }
    }
    printf("%d",dp[1][n]);
    return 0;

}

说实话，个人觉得动态规划就是在枚举的基础上添了些备忘录、去掉重叠子问题等等。
核心

dp[i][j]=min(dp[i][j],dp[i][k-1]+dp[k+1][j]+a[k]+b[i-1]+b[j+1]);

取最小值是必然的，k是分割点，把[i,j]区间分割为两部分，得以构建方程关系，分割之后剩下一个k未被计算，所以后面加上消灭第k匹狼的代价。

希望有所收获，以后遇到啥典题继续更新。

---

更新了！！！

EX2 张老师的旅行

链接：https://ac.nowcoder.com/acm/contest/5477/C
来源：牛客网

题目描述
张老师到了一个王国去旅游，王国有n个景点，张老师到达这个城市所在的车站恰好位于第x个景点，这个王国非常特别，恰好所有著名的景点都在分布在直线上，每个景点在坐标pi上(单位：公里)，张老师身体非常好，每走一公里花费一分钟。每个景点都有一个打卡点，并且必须在不迟于相应的时间（时间从张老师到达王国开始计算）前到达才能打卡成功并且给以一个打卡标记，集齐所这些标记就能获得一个大礼包。由于张老师非常想要大礼包，并且因为张老师还着急去下一个王国旅游，所以张老师希望用的时间尽量少，你能帮帮张老师吗？

输入描述:
输入的第一行，包含一个整数n（1≤n≤1000）。
第二行包含n个整数pi(1≤pi≤100000)，第i个整数pi为第i个景点的坐标（坐标从小到大排列）。
最后一行包含n个整数ti(0≤ti≤10,000,000)，ti表示第i个景点最迟到达的时间，时间为0则表示张老师所在车站的位置且只有一个为0。

输出描述:
输出所需的最少时间，若无解输出-1。
示例1
输入
4
1 2 3 4
0 1 2 3
输出
3

此题也是区间DP的一个典题啊，
观察发现，在最少时间的前提下走过的点必然是连续的区间设为[l,r]，那么唯一的变化就是终点落在l还是人r，这样我们可以通过dp来解决，我们设状态f[l][r][0]表示终点落在l的前提下走完区间[l,最小时间，f[l][r][1]同理终点落在r上，状态转移为：
f[l-1][r][0]=min(f[l-1][r][0],f[l][r][0]+p[l]-p[l-1]);
f[l][r+1][1]=min(f[l][r+1][1],f[l][r][0]+p[r+1]-p[l]);
f[l-1][r][0]=min(f[l-1][r][0],f[l][r][1]+p[r]-p[l-1]);
f[l][r+1][1]=min(f[l][r+1][1],f[l][r][1]+p[r+1]-p[r]);
那么答案就是min（f[1][n][0]，f[1][n][1]）。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <math.h>
#include <vector>
#include <queue>
#include <ctime>
#include <ctype.h>
#define ll long long
//#define local
#define inf 0x3f3f3f3f
using namespace std;
const int N = 1005;
const int mod = 998244353;
int n;
int p[N],t[N];
int dp[N][N][2];
int main()
{
#ifdef local
    freopen("input.txt","r",stdin);
#endif
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
        scanf("%d",&p[i]);
    for(int i=1; i<=n; i++)
        scanf("%d",&t[i]);
    memset(dp,inf,sizeof(dp));
    for(int i=1; i<=n; i++)
    {
        if(t[i]==0)
            dp[i][i][0]=dp[i][i][1]=0;
    }
    for(int k=1; k<n; k++)
    {
        for(int l=1; l<=n-k; l++)
        {
            int r=l+k;;
            int ti=dp[l+1][r][0]+p[l+1]-p[l];
            if(ti<=t[l]&&ti<dp[l][r][0])
                dp[l][r][0]=ti;

            ti=dp[l+1][r][1]+p[r]-p[l];
            if(ti<=t[l]&&ti<dp[l][r][0])
                dp[l][r][0]=ti;

            ti = dp[l][r-1][0] + p[r] - p[l];
            if(ti<=t[r] && ti<dp[l][r][1])
                dp[l][r][1]=ti;

            ti = dp[l][r-1][1] + p[r] - p[r-1];
            if(ti<=t[r] && ti<dp[l][r][1])
                dp[l][r][1]=ti;

        }
    }
    int ans=min(dp[1][n][0],dp[1][n][1]);
    printf("%d",ans==inf?-1:ans);
    return 0;
}