C++区间DP

区间DP代码框架见下 对应蓝桥云课 石子合并 代码见下

#include <iostream>
using namespace std;

#define type int
#define maxn 210
//dp[i][j]就代表了区间[i,j]的元素最优值
type dp[maxn][maxn];
int a[maxn], sum[maxn];
int n;

type IntervalDP_Opt(type a, type b){
  return min(a, b);
}

type IntervalDP_ValueInf(){
  return 1000000000;
}

type IntervalDP_ValueInit(){
  return 0;
}

type IntervalDP_CalcState(int l, int r){
  type ans = IntervalDP_ValueInf();
  for(int k = l; k < r; ++k){
    type v = dp[l][k] + dp[k+1][r] + (sum[r] - sum[l-1]);
    ans = IntervalDP_Opt(ans, v);
  }
  return ans;
}

type IntervalDP_Solve(int maxlen, int maxr){
  type ans = IntervalDP_ValueInf();
  // 1 枚举区间长度
  for(int i=1; i <= maxlen; ++i){
    // 2 枚举区间起点
    for(int j=1; j+i-1 <= maxr; ++j){
      int l = j;
      int r = j + i - 1;
      if(i == 1){
        dp[l][r] = IntervalDP_ValueInit();
      }else{
        dp[l][r] = IntervalDP_CalcState(l, r);
      }
      if(i == maxlen){
      ans = IntervalDP_Opt(ans, dp[l][r]);
      }
    }

  }
  return ans;
}

int main()
{
  cin >> n;
  for(int i=1; i <= n; ++i){
    cin >> a[i];
    sum[i] = sum[i-1] + a[i];
  }
  cout << IntervalDP_Solve(n, n) << endl;
  // 请在此输入您的代码
  return 0;
}

代码练习 1，对应蓝桥云课 小蓝吃苹果 代码见下

#include <iostream>
using namespace std;

#define type int
#define maxn 510
//dp[i][j]就代表了区间[i,j]的元素最优值
type dp[maxn][maxn];
int a[maxn], sum[maxn];
int n;

type IntervalDP_Opt(type a, type b) {
    return min(a, b);
}

type IntervalDP_ValueInf() {
    return 1000000000;
}

type IntervalDP_ValueInit() {
    return 1;
}

type IntervalDP_CalcState(int l, int r) {
    type ans = IntervalDP_ValueInf();
    for (int k = l; k < r; ++k) {
        ans = IntervalDP_Opt(ans, dp[l][k] + dp[k + 1][r]);
    }
    if (a[l] == a[r]) {
        ans = IntervalDP_Opt(ans, dp[l + 1][r - 1] + (l + 1 == r));
    }
    return ans;
}

type IntervalDP_Solve(int maxlen, int maxr) {
    type ans = IntervalDP_ValueInf();
    // 1 枚举区间长度
    for (int i = 1; i <= maxlen; ++i) {
        // 2 枚举区间起点
        for (int j = 1; j + i - 1 <= maxr; ++j) {
            int l = j;
            int r = j + i - 1;
            if (i == 1) {
                dp[l][r] = IntervalDP_ValueInit();
            }
            else {
                dp[l][r] = IntervalDP_CalcState(l, r);
            }
            if (i == maxlen) {
                ans = IntervalDP_Opt(ans, dp[l][r]);
            }
        }

    }
    return ans;
}

int main()
{
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    cout << IntervalDP_Solve(n, n) << endl;
    // 请在此输入您的代码
    return 0;
}

代码练习2 对应蓝桥云课 课上小游戏 代码见下

#include <iostream>
using namespace std;

#define type int
#define maxn 210
//dp[i][j]就代表了区间[i,j]的元素最优值
type dp[maxn][maxn];
int a[maxn], mul[maxn][maxn];
int n;

type IntervalDP_Opt(type a, type b){
  return max(a, b);
}

type IntervalDP_ValueInf(){
  return -1000000000;
}

type IntervalDP_ValueInit(){
  return 0;
}

type IntervalDP_CalcState(int l, int r){
  type ans = IntervalDP_ValueInf();
  for(int k=l; k<r; ++k){
    type a = mul[l][k];
    type b = mul[k+1][r];
    type v = dp[l][k] + dp[k+1][r] + a*b/10;
    ans = IntervalDP_Opt(ans, v);
  }
  return ans;
}

type IntervalDP_Solve(int maxlen, int maxr){
  type ans = IntervalDP_ValueInf();
  // 1 枚举区间长度
  for(int i=1; i <= maxlen; ++i){
    // 2 枚举区间起点
    for(int j=1; j+i-1 <= maxr; ++j){
      int l = j;
      int r = j + i - 1;
      if(i == 1){
        dp[l][r] = IntervalDP_ValueInit();
      }else{
        dp[l][r] = IntervalDP_CalcState(l, r);
      }
      if(i == maxlen){
      ans = IntervalDP_Opt(ans, dp[l][r]);
      }
    }

  }
  return ans;
}

int main()
{
  cin >> n;
  int n2 = n*2;
  for(int i=1; i<=n; ++i){
    cin >> a[i];
    a[n+i] = a[i];
  }
  for(int i=1; i<=n2; ++i){
    mul[i][i-1] = 1;
    for(int j=i; j<=n2; ++j){
      mul[i][j] = mul[i][j-1] * a[j] % 10;
    }
  }
  cout << IntervalDP_Solve(n, n2) << endl;
  // 请在此输入您的代码
  return 0;
}

代码练习3 对应蓝桥云课 涂色 代码见下

#include <iostream>
#include <cstring>
using namespace std;

#define type int
#define maxn 55
//dp[i][j]就代表了区间[i,j]的元素最优值
type dp[maxn][maxn];
char a[maxn];
int n;

type IntervalDP_Opt(type a, type b){
  return min(a, b);
}

type IntervalDP_ValueInf(){
  return 1000000000;
}
//当区间长度为1的时候，该状态下的DP值
type IntervalDP_ValueInit(){
  return 1;
}

type IntervalDP_CalcState(int l, int r){
  type ans = IntervalDP_ValueInf();
  for(int k = l; k < r; ++k){
    ans = IntervalDP_Opt(ans, dp[l][k]+dp[k+1][r]);
  }
  if(a[l] == a[r]){
    ans = IntervalDP_Opt(ans, dp[l+1][r]);
    ans = IntervalDP_Opt(ans, dp[l][r-1]);
  }
  return ans;
}

type IntervalDP_Solve(int maxlen, int maxr){
  type ans = IntervalDP_ValueInf();
  // 1 枚举区间长度
  for(int i=1; i <= maxlen; ++i){
    // 2 枚举区间起点
    for(int j=1; j+i-1 <= maxr; ++j){
      int l = j;
      int r = j + i - 1;
      if(i == 1){
        dp[l][r] = IntervalDP_ValueInit();
      }else{
        dp[l][r] = IntervalDP_CalcState(l, r);
      }
      if(i == maxlen){
      ans = IntervalDP_Opt(ans, dp[l][r]);
      }
    }

  }
  return ans;
}

int main()
{
  cin >> &(a[1]);
  n = strlen(&a[1]);
  cout << IntervalDP_Solve(n, n) << endl;
  // 请在此输入您的代码
  return 0;
}