动态规划：洛谷P1077 [NOIP2012 普及组] 摆花 一题多解 :DFS，记忆化搜索，二维DP，01背包问题，滚动数组优化，前缀和优化

P1077 [NOIP2012 普及组] 摆花

 

 

 

　　对于这题，有DFS，记忆化搜索，二维DP，01背包问题，滚动数组优化，前缀和优化多种解法，下面我来一一列出每种代码，叙述我的解题过程，这些题解方法也是我在学习了洛谷评论区各位大佬学习出来的经验。

 

一、DFS：

　　一开始我的思路是直接暴搜求解问题，我的代码为

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int mod = 1e6 + 7;
int a[105];
int n, m;
int sum = 0;
void dfs(int num,int x)
{
    if (num == 0)
    {
        sum++;
        sum %= mod;
        return;
    }
    for (int i = x; i <= n; ++i)
    {
        if (a[i] != 0)
        {
            a[i]--;
            dfs(num - 1, i);
            a[i]++;
        }
            
    }
}
int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; ++i)
        cin >> a[i];
    dfs(m,1);
    cout << sum;
    return 0;
}

提交答案：

 

 只过了四个点，还有六个点T了，我们看数据范围：

 

 最多有100种，每种有100个，就是100*100=一万朵花里挑出100朵，可能太多了，显然暴搜会超时，于是就改进成为记忆化搜索。

 

二、记忆化搜索：

但是再原来的DFS上不太好改成记忆化，我们就稍微改一下，写出一个新的DFS，其中x代表的是现在搜索到的第几种，sum代表的是现在多少朵花了

代码：

#include<iostream>
using namespace std;
const int mod = 1e6 + 7;
const int N = 105;
int a[105];
int n, m;
int dfs(int x, int sum)
{
    if (sum > m)
        return 0;
    if (sum == m)//这个一定要放在  判断x是不是等于n+1的前面  因为x等于n+1的时候，sum要是刚好等于m 也是一种可能，因为此时说明n+1种花一个都不要 然后刚好凑到m朵花
        return 1;
    if (x == n + 1)
        return 0;
    int ans = 0;
    for (int i = 0; i <= a[x]; ++i)
    {
        ans = (ans + dfs(x + 1, sum + i)) % mod;
    }
    return ans;
}
int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; ++i)
        cin >> a[i];
    cout << dfs(1, 0);
    return 0;
}

然后我们加入一个数组，DP[i][j],i代表当前枚举到第i种，j代表已经有多少花了，DP[i][j]代表从这个情况出发 可以有多少种可能到达M朵花。所以最后的ans就是DP[1][0]，每次算出来就用DP数组存一下，如果搜索时候发现DP[][]！=0，直接返回里面的值。大大减少时间复杂度，也可以叫做剪枝，减去冗杂的枝条。

上代码：

#include<iostream>
using namespace std;
const int mod = 1e6 + 7;
const int N = 105;
int a[105];
int b[105][105];//这个数组表示 从第x组，已经有y盆花开始，还能有几种方案到m盆
int n, m;
int dfs(int x, int sum)
{
    if (sum > m)
        return 0;
    if (sum == m)//这个一定要放在判断x是不是等于n+1的前面
        return 1;
    if (x == n + 1)//如果x==n+1那么此时一定sum<m 不可能摆的成功 一定要注意这个顺序
        return 0;
   
    if (b[x][sum])
        return b[x][sum];
    int ans = 0;
    for (int i = 0; i <= a[x]; ++i)
    {
        ans = (ans + dfs(x + 1, sum + i)) % mod;
    }
    b[x][sum] = ans;
    return ans;
}
int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; ++i)
        cin >> a[i];
    cout << dfs(1, 0);
    return 0;
}

 

提交：

 

 大大降低时间复杂度，成功通过！

 

三、DP

这题也非常的特殊，是我没怎么见到过的求和的DP，也就是他的状态转移方程是求和的形式，并不是很多的 max min形式。

建立状态转移方程：创建DP[i][j]数组，i代表循环到第i种，j代表现在的花朵数，dp[i][j]代表能凑成到第i种，一共有j朵花的种类数，所以我们得出状态转移方程：

int k=0,k<=a[i]；k就是i种花能提供出来凑成j的花朵数。dp[i][j]=求和 【k从0到min(a[i],j)】

注意点：必须把DP[0][0]初始化为1，可以看做边界条件，否则，算DP[1][0] DP[1][1] ....算出来的答案都是0 具体可以举例试一下也就是说： DP[0][0]来初始化dp[1],dp[1]用于初始化dp[2]...

这里用到了三层循环 第一层枚举种类，第二层枚举总和，第三层就是求和计算的循环。

//P1077 [NOIP2012 普及组] 摆花
#include<iostream>
#include<cmath>
using namespace std;
const int maxn = 105, mod = 1000007;
int n, m, a[maxn], dp[maxn][maxn];
int main()
{
    cin >> n >> m;
    dp[0][0] = 1;//重点 ：一定要初始化为1 我们可以枚举第一种出来试一下，必须初始化DP[0][0]=1;下面的循环才能正常计算
    //比如说第一种dp[1][1]=dp[0][0]+dp[0][1]=1；dp[1][2]=1等等 必须初始化DP[0][0]=1，才能把第一种的数组初始化
    for (int i = 1; i <= n; ++i)cin >> a[i];
    for (int i = 1; i <= n; ++i)
        for (int j = 0; j <= m; ++j)
            for (int k = 0; k <= min(j, a[i]); ++k)
            {
                dp[i][j] = (dp[i - 1][j - k] + dp[i][j]) % mod;//注意取余
            }
    cout << dp[n][m];
    return 0;
}

 

 四、滚动数组：

优化DP：观察三种，标红的这句话 DP[0][0]来初始化dp[1],dp[1]用于初始化dp[2]...,我们发现，每次也只用这个数组的当层和上一层，所以可以用滚动数组优化内存空间。

创建一个数组temp 用来复制，每次算出来的DP用memcpy存入temp，这样每次就只用数组的两层，也可以用一个只有两层的二维数组DP来，都可以。

上代码：

//P1077 [NOIP2012 普及组] 摆花
#include<iostream>
#include<cmath>
using namespace std;
const int maxn = 105, mod = 1000007;
int n, m, a[maxn], dp[maxn][maxn];
int main()
{
    cin >> n >> m;
    dp[0][0] = 1;//重点 ：一定要初始化为1 我们可以枚举第一种出来试一下，必须初始化DP[0][0]=1;下面的循环才能正常计算
    //比如说第一种dp[1][1]=dp[0][0]+dp[0][1]=1；dp[1][2]=1等等 必须初始化DP[0][0]=1，才能把第一种的数组初始化
    for (int i = 1; i <= n; ++i)cin >> a[i];
    for (int i = 1; i <= n; ++i)
        for (int j = 0; j <= m; ++j)
            for (int k = 0; k <= min(j, a[i]); ++k)
            {
                dp[i][j] = (dp[i - 1][j - k] + dp[i][j]) % mod;//注意取余
            }
    cout << dp[n][m];
    return 0;
}

注意每次都要把DP[j]定为0这样计算出的dp[j]才是正确的，否则会被之前算的影响，每次应该是互不影响。dp[j]的答案应该是前面的和，但dp[j]在上一层计算中是有数值的，所以应该定义为0，我在第一次提交时没注意这个问题，WA声一片...

提交数据：

 

 

五、01背包问题

观察发现，这题可以转化成一维的背包问题 每一个花朵数dp[j]都等于dp[j-k]的求和  所以可以三层循环

外层循环i代表种类数，对于每个第i种，都要内层循环一次花朵数j 花朵数要从大往小的循环，防止小的对大花朵数产生影响，做到无后效性。

常规的01背包dp[j]=max(dp[j-a[i]],dp[j])；  这题的dp[j]=sum k从1->a[i](dp[j-k])  sum可以写成第三层循环 用一个for循环来写。

所以代码就是：

//P1077 [NOIP2012 普及组] 摆花
#include<iostream>
#include<cmath>
using namespace std;
const int maxn = 105, mod = 1000007;
int n, m, a[maxn], dp[maxn];
int main()
{
    cin >> n >> m;
    dp[0] = 1;//01背包问题 一定要初始化边界条件为1 
    for (int i = 1; i <= n; ++i)cin >> a[i];
    for (int i = 1; i <= n; ++i)
        for (int j = m; j >= 0; --j)//01背包问题 从大的往小的算
            for (int k = 0; k <= min(j, a[i]); ++k)
                dp[j] = (dp[j] + dp[j - k]) % mod;
    cout << dp[m];
    return 0;
}

但这样提交上去是错的，分析原因，一步一步调试发现，原来是最内层循环k要从1 开始 不能像前面二维循环一样从1开始写。

原因是如果这一种类，一个都不要，那dp[j]不需要加上dp[j-0]了，直接就是等于dp[j]自己，每层会多算一个dp[j]。而为什么二维dp就可以从0开始，原因可以分析状态转移方程，发现dp[][]是从0开始求和，需要加上一个都不要的情况。

正确代码：

//P1077 [NOIP2012 普及组] 摆花
#include<iostream>
#include<cmath>
using namespace std;
const int maxn = 105, mod = 1000007;
int n, m, a[maxn], dp[maxn];
int main()
{
    cin >> n >> m;
    dp[0] = 1;//01背包问题 一定要初始化边界条件为1 
    for (int i = 1; i <= n; ++i)cin >> a[i];
    for (int i = 1; i <= n; ++i)
        for (int j = m; j >= 0; --j)//01背包问题 从大的往小的算
            for (int k = 1; k <= min(j, a[i]); ++k)
                dp[j] = (dp[j] + dp[j - k])%mod;
    cout << dp[m];
    return 0;
}

 

 

六、前缀和优化

01背包本题的时间复杂度是n的3方。我们可以优化时间复杂度，把发现最内层循环是求和，可以利用前缀和数组优化，注意特判数组是否越界。

上代码：

//P1077 [NOIP2012 普及组] 摆花
#include<iostream>
#include<cmath>
using namespace std;
const int maxn = 105, mod = 1000007;
int n, m, a[maxn], dp[maxn],sum[maxn];//前缀和数组优化
int main()
{
    cin >> n >> m;
    dp[0] = 1;//01背包问题 一定要初始化边界条件为1 
    //因为只有dp[0]=1，其他都是0 所以前缀和数组应该都是1 直接初始化前缀和数组为1
    for (int i = 0; i <= m; ++i)sum[i] = 1;
    for (int i = 1; i <= n; ++i)cin >> a[i];
    for (int i = 1; i <= n; ++i)
    {
        for (int j = m; j >= 1; --j)//01背包问题 从大的往小的算 这里j就到1 因为有j-1 而且dp[0]不需要计算了
        {
            //防止数组越界 特判一下
            int x = j - min(j, a[i]) - 1;
            if (x < 0)//如果数组越界 那越界的就不看 直接加上从0到j-1的前缀和
                dp[j] = (dp[j] + sum[j - 1]) % mod;
            else
                dp[j] = (dp[j] + sum[j - 1] - sum[x]+mod) % mod;
            //细节 必须加上一个mod 不然有可能是负数
        }
        //还要一个循环更新一下sum数组
        for (int j = 1; j <= m; ++j)sum[j] = sum[j - 1] + dp[j];
    }
    cout << dp[m];
    return 0;
}

 

 

完美结束。