动态规划——划分

乘积最大

给你n数，往里插入K个乘号，使乘积最大

最开始其实想的是，选择一个位置插入乘号，然后两头取最大，后来发现这样做，一个乘号需要把所有不同长度区间的乘积全取出来，时间上不允许，而如果状态表示的是他之前的数插入乘号后取的最大值就好办了，先放一个乘号，然后往后枚举分割点更新此分割点的最大值

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>

using namespace std;
const int maxn = 300;
int n,m,u,j;
long long int num,sum[maxn][maxn],dp[maxn][maxn];
int main(){
    memset(dp,0,sizeof(dp));
    cin>>n>>m>>num;
    for(int i = 1;i <= n;i++){
        sum[i][i] = num % 10;
        num /= 10;
    }
    u = 10;
    for(int l = 2;l <= n;l++){ 
        for(int i = 1;i <= n - l + 1;i++){
            j = i + l - 1;
            sum[i][j] = sum[i][j-1] + u * sum[j][j];
        }
        u *= 10;
    }
    for(int i = 1;i <= n;i++) dp[0][i] = sum[1][i];
    for(int i = 1;i <= m;i++){
        for(int j = i+1;j <= n;j++){
            for(int k = i;k < j;k++){
                dp[i][j] = max(dp[i][j],dp[i-1][k] * sum[k+1][j]);
            }
        }
    }
    cout<<dp[m][n];
    return 0;
} 

山区建小学

大体意思是有n个村庄，村庄之间有一定距离，选一些村庄建小学，使所有村庄到最近小学的距离的和最小

首先预处理出所有区间内建一个小学所取得的距离的最小值，考虑到小学辐射范围是一个连续的区间（数学归纳即可证得），所以可以枚举每个小学，然后往右更新分割点

#include<iostream>
#include<cstdio>
#include<cstring>
#define inf 100000000
int dp[505][505][505],dis[505][505],d[505],sum[505],miv[505];
using namespace std;
int main(){
    
    int n,m,tmpl = 0,tmpr = 0,tmp;
    cin>>m>>n;
    for(int i = 1;i < m;i++){
        cin>>d[i];
        sum[i+1] = sum[i] + d[i];
    }
    for(int i = 1;i <= m;i++){
        tmpl = tmpr = 0;
        for(int l = i;l >= 1;--l,tmpl += sum[i] - sum[l]){
            for(int r = i;r <= m;++r,tmpr += sum[r]-sum[i]){
                if(dp[1][l][r] == 0 || tmpl + tmpr < dp[1][l][r]) dp[1][l][r] = tmpl + tmpr;
            }
            tmpr = 0;
        }
    }
    for(int k = 2;k <= n;k++){
        for(int i = 1;i <= m;i++){
            for(int j = i;j <= m;j++){
                tmp = min(dp[k-1][1][i-1]+dp[1][i][j],dp[k-1][1][i]+dp[1][i+1][j]);
                if(dp[k][1][j] == 0 || dp[k][1][j] > tmp) 
                    dp[k][1][j] = tmp;
            }
        }
    }
    cout<<dp[n][1][m];
    return 0;
}

鸡蛋的硬度

有一个N层高的楼，一个鸡蛋在1~i层仍不会碎，在i+1~n仍会碎，说明鸡蛋硬度i，给定同一硬度的鸡蛋几个，最少扔几次测出硬度（碎了的不能再用）

首先一眼看出是两个状态，扔i个鸡蛋确定0~j的硬度最少用几个蛋，然后考虑转移方程，由于扔蛋的楼层不确定，假设在K层扔掉，如果蛋碎，就确定蛋的硬度在0~K-1之间，可以用i-1个蛋，如果蛋不碎，蛋的硬度在k+1~j之间，可以用i个蛋，然后就可以了，一遍A掉

#include<iostream>
#include<cstdio>
#define inf 100000000
using namespace std;
int n,m,dp[105][105];
int main(){
    
    for(int i = 1;i <= 10;i++){
        for(int j = 1;j <= 100;j++){
            dp[i][j] = inf;
        }
    }
    for(int i = 1;i <= 100;i++) dp[1][i] = i;
    for(int i = 2;i <= 10;i++){
        for(int j = 1;j <= 100;j++){
                for(int k = 1;k <= j;k++){
                    dp[i][j] = min(dp[i][j],max(dp[i-1][k-1],dp[i][j-k]) + 1);
                }
            
        }
    }
    while(cin>>n>>m){
    cout<<dp[m][n]<<endl;}
    return 0;
}

吃糖果

一个人有N块糖，每一天可以选择吃一块或两块，求方案数

每天可以吃1到2块，吃n块的方案数就是吃N-1和N-2块的方案数之和（这其实就是一个斐波那契数列）

#include<iostream>
#include<cstdio>
using namespace std;
int dp[100];
int main(){
    int n;
    cin>>n;
    dp[1] = 1;
    dp[2] = 2;
    for(int i = 3;i <= n;i++) dp[i] = dp[i-2] + dp[i-1];
    cout<<dp[n];
    return 0;
}

Wikioi 1315 摆花

题目描述 Description

小明的花店新开张，为了吸引顾客，他想在花店的门口摆上一排花，共m盆。通过调查顾客的喜好，小明列出了顾客最喜欢的n种花，从1到n标号。为了在门口展出更多种花，规定第i种花不能超过ai盆，摆花时同一种花放在一起，且不同种类的花需按标号的从小到大的顺序依次摆列。

试编程计算，一共有多少种不同的摆花方案。

输入描述 Input Description

输入共2行。

第一行包含两个正整数n和m，中间用一个空格隔开。

第二行有n个整数，每两个整数之间用一个空格隔开，依次表示a1、a2、……an。

输出描述 Output Description

输出只有一行，一个整数，表示有多少种方案。注意：因为方案数可能很多，请输出方案数对1000007取模的结果。

样例输入 Sample Input

2 4

3 2

样例输出 Sample Output

2

数据范围及提示 Data Size & Hint

【输入输出样例说明】

有2种摆花的方案，分别是(1，1，1，2)，(1，1，2，2)。括号里的1和2表示两种花，比如第一个方案是前三个位置摆第一种花，第四个位置摆第二种花。

【数据范围】

对于20%数据，有0<n≤8，0<m≤8，0≤ai≤8；

对于50%数据，有0<n≤20，0<m≤20，0≤ai≤20；

对于100%数据，有0<n≤100，0<m≤100，0≤ai≤100。

思路：

以花的种类为阶段，设置摆了多少种花n以及摆了多少盆花m为状态，然后对m进行划分

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>

using namespace std;
const int maxn = 200,maxnum = 100000000;
int n,m,value[maxn],dp[maxn][maxn],vis[maxn][maxn];
int main(){
    cin>>n>>m;
    for(int i = 1;i <= n;i++){
        cin>>value[i];
    }
    memset(dp,-1,sizeof(dp));
    memset(vis,0,sizeof(vis));
    for(int i = 1;i <= value[1];i++) dp[1][i] = 1;
    for(int i = 1;i <= n;i++) dp[i][0] = 1;
    for(int i = 2;i <= n;i++){
        for(int j = 1;j <= m;j++){
            int ans = 0;
            for(int k = 0; k <= value[i];k++){
                if(j - k >= 0 && dp[i-1][j-k] != -1) {
                ans += dp[i-1][j-k];
                
            }
            dp[i][j] = max(dp[i][j],ans) % 1000007;
         }
        }
    }
    cout<<dp[n][m];
    return 0;
}

 Wikioi 1039 数的划分

题目描述 Description

将整数n分成k份，且每份不能为空，任意两种划分方案不能相同(不考虑顺序)。
例如：n=7，k=3，下面三种划分方案被认为是相同的。
1 1 5

1 5 1

5 1 1
问有多少种不同的分法。

输入描述 Input Description

输入：n，k (6<n<=200，2<=k<=6)

输出描述 Output Description

输出：一个整数，即不同的分法。

样例输入 Sample Input

 7 3

样例输出 Sample Output

4

数据范围及提示 Data Size & Hint

 {四种分法为：1，1，5;1，2，4;1，3，3;2，2，3;}

 

思路：

状态为数i和划分数量j，对于一个数来说，如果划分出来没有1的方案可以由每一个分的数-1的状态推出，有一的方案可以由没有一但是划分数量少一的状态推出

其实也可以用dfs做，时间慢

代码：

#include<iostream>

#include<algorithm>

using namespace std;

int n,m,dp[500][500];

int main(){

     cin>>n>>m;

     for(int i=1;i<=n;i++)

     for(int j=1;j<=i;j++){

     dp[i][j]=dp[i-j][j]+dp[i-1][j-1];

     if(i==1&&j==1) dp[i][j]=1;

     } 

     cout<<dp[n][m];

}