区间DP

参考链接

二叉加分树：注意，从i到n的最大值应该由后面到部分区间构造出来，即i应该倒序枚举，一开始想到是用记忆化搜索，枚举断点k值，也是犯了枚举起点到错误，导致根本构造不出答案，已经是不会做啦，直接就看题解啦，代码其实和参考的完全一样：算是抄啦吧------不过感觉dp还是不能这样，这个真的要思维，以后必须想，避免依赖题解，实际上我从这个题学到到东西很少啊

1 #include<iostream>
 2 #include<cstdio>
 3 #include<vector>
 4 #include<string>
 5 #include<queue>
 6 #include<algorithm>
 7 
 8 
 9 using namespace std;
10 
11 const int maxn = 100;
12 int tree[maxn];
13 long long int f[50][50];
14 long long int g[50][50];
15 void print(int l,int r)
16 {
17   if(l > r) return;
18   int k = g[l][r];
19   cout<<k<<" ";
20   print(l,k-1);
21   print(k+1,r);
22 }
23 
24 int main()
25 {
26   int n;
27   scanf("%d",&n);
28   for(int i = 1;i <= n;i++)
29     {
30       scanf("%d",&tree[i]);
31       f[i][i] = tree[i];
32       g[i][i] = i;
33     }
34   for(int i = n;i > 0;i--)
35     {
36       for(int j = i+1;j <= n;j++)
37     {
38       for(int k = i;k <= j;k++)
39         {
40           int x = f[i][k-1];
41           int y = f[k+1][j];
42           if(x == 0) x = 1;
43           if(y == 0) y = 1;
44           if(f[i][j]<(x*y+tree[k])){
45         f[i][j] = x*y+tree[k];
46         g[i][j] = k;
47           }
48         }
49     }
50     }
51   cout<<f[1][n]<<endl;
52   print(1,n);
53   cout<<endl;
54   return 0;
55 }

昨天回教室路上想啦下，觉得记忆化还是可以滴，体育课码之。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>


using namespace std;
int n;
const int maxn = 200;
long long int f[maxn][maxn];
int g[maxn][maxn];
int tree[maxn];
int dp(int l,int r)
{
  if(l > r) return 0;
  long long int& ans = f[l][r];
  if(ans > 0) return ans;
  ans = 1;
  for(int i = l;i <= r;i++)
    {
      int x = dp(l,i-1);
      int y = dp(i+1,r);
      if(x==0) x = 1;
      if(y==0) y = 1;
      if(x*y+tree[i] > ans)
    {
      ans = x*y+tree[i];
      g[l][r] = i; 
    }
    }
  return ans;
}
void print(int l,int r)
{
  if(l > r) return;
  int k = g[l][r];
  printf("%d ",k);
  print(l,k-1);
  print(k+1,r);

}

int main()
{
  scanf("%d",&n);
  for(int i = 1;i <= n;i++)
    {
      scanf("%d",&tree[i]);
      f[i][i] = tree[i];
      g[i][i] = i;
    }
  int ans = dp(1,n);
  cout<<ans<<endl;
  print(1,n);
  cout<<endl;
  return 0;
}

 

最优矩阵链乘；

f(l,r) = min(f(l,k)+f(k,r)+N[l]*N[k]*N[r],f[l][r]) l < k < r;

码一下就好；

思路，长区间的最优可以由短区间的最优构造，边界是两个矩阵相乘，对应在程序里就是三个数相乘，枚举区间出度，递推即可。

经验，DP不要看别人的状态转移方程，否则，你自己想的永远都不会写对的。虽然你自己想的是对的。

代码如下：

#include<iostream>
#include<cstring>
#include<vector>
#include<cstdio>
using namespace std;
const int maxn = 1010;
int N[maxn];
int f[maxn][maxn];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i = 1;i<= n;i++) scanf("%d",&N[i]);

    for(int i = 2;i <= n;i++)
        for(int j = 1;j <= n-i;j++)
        {
            int l = j,r = j+i;
            f[l][r] = 1e8;
            for(int k = l+1;k < r;k++)            
                f[l][r] = min(f[l][k]+f[k][r]+N[l]*N[k]*N[r],f[l][r]);
        }
    printf("%d",f[1][n]);
    return 0;
}

 

划分回文串：

一个字符串，划分成最少的回文串。fastcar = 7;aaadbccb = 3;racecar = 1;

同样，短区间可以构造出长区间的最优解，f(i) = min{f(j)+1|s[j+1~i] 是回文串};

可以枚举长度，再枚举起点，再枚举判断是否回文，状态(n²)个，转移花费(n)总计O(n³);

优化，直接预处理串是否为回文串，复杂度实现O(1)转移。

代码如下

#include<iostream>
#include<cstring>
#include<vector>
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 1010;
char s1[maxn];
int f[maxn];
bool Is_hw[maxn][maxn];

void init()
{
    memset(Is_hw,false,sizeof(Is_hw));
    for(int M = 0;M < strlen(s1);M++){
        Is_hw[M][M] = true;
        for(int i = 1;i <= M;i++){
            if(s1[M-i] == s1[M+i]) Is_hw[M-i][M+i] = true;
            else break;    
        }
        for(int i = 1;i <= M;i++){
            if(s1[M-i] == s1[M+i-1]) Is_hw[M-i][M+i-1] = true;
            else break;
        }
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%s",s1);
        init();
        for(int i = 0;i < strlen(s1);i++) f[i] = 1e9;
        f[0] = 1;
        for(int i = 1;i < strlen(s1);i++){
            f[i] = f[i-1]+1;
            for(int j = 0;j <= i;j++){
                if(Is_hw[j][i])
                {
                    if(j == 0) f[i] = 1;
                    else f[i] = min(f[j-1]+1,f[i]);
                }
            }
        }
        printf("%d\n",f[strlen(s1)-1]);
        
    }
    return 0;
}