摆花解题报告

---

（一）题目大意

题目传送门

简化一下题意：

有 \(n\) 个数（\(x_1,x_2,...,x_n\)）， \(0\leqslant x_i\leqslant a_i\),求有多少种方案数使\(\sum\limits_{i=1}^nx_i = m\)。

（二）解题思路

乍一看，似乎题目有些复杂，一时找不到思路，肿么办!!!

方法一：搜索

没有思路当然就搜索啦 废话。如何搜索呢？

从 1 到 \(n\) 考虑每个 \(x_i\) 的值，和当前前 \(i\) 个数的总和 \(k\)，然后枚举当前 \(x_i\) 所有可能的值，再递归求解。

时间复杂度 \(O(a_1\times a_2...\times a_n)\)，明显超时，但可以拿部分分（30）嘛...

代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=105, mod = 1000007;
int n, m, a[maxn];
int dfs(int x,int k)
{
    if(k > m) return 0;
    if(k == 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, k+i))%mod;
    return ans;
}
int main()
{
    cin>>n>>m;
    for(int i=1; i<=n; i++) cin>>a[i];
    cout<<dfs(1,0)<<endl;
    return 0;
}

搜索超时怎么办!!! 别着急...

方法二（搜索优化法宝）：记忆化

所谓记忆化，其实就是用一个数组将搜索过的值存起来，避免重复搜索，从而提高效率。（有必要可以上网搜一下，会搜索的应该很容易理解记忆化吧）

时间复杂度大概是：\(O(nm\times a_i)\) 吧，100%的数据稳过。

代码（其实只是改动了一点点）：

#include<bits/stdc++.h>
using namespace std;
const int maxn=105, mod = 1000007;
int n, m, a[maxn], rmb[maxn][maxn];
int dfs(int x,int k)
{
    if(k > m) return 0;
    if(k == m) return 1;
    if(x == n+1) return 0;
    if(rmb[x][k]) return rmb[x][k]; //搜过了就返回
    int ans = 0;
    for(int i=0; i<=a[x]; i++) ans = (ans + dfs(x+1, k+i))%mod;
    rmb[x][k] = ans; //记录当前状态的结果
    return ans;
}
int main()
{
    cin>>n>>m;
    for(int i=1; i<=n; i++) cin>>a[i];
    cout<<dfs(1,0)<<endl;
    return 0;
}

但是搜索的时间有些不稳定，想要更稳定的算法有木有...

方法三：动态规划

记忆化搜索都可以转成动态规划，但是动态规划却不一定能转成记忆化搜索 ——\(by\) \(clg\)

定义状态：\(f(i, j)\) 表示前 \(i\) 个数总和为 \(j\) 的方案数。

那么，易得状态转移方程：\(f(i, j) = \sum\limits_{k=0}^{a_{i}}f(i-1,j-k)\)

其中, \(k\)是枚举当前第 \(i\) 个数的取值。

时间复杂度：\(O(nm\times a_i)\)，稳得一批。

空间复杂度：\(O(nm)\)

代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=105, mod = 1000007;
int n, m, a[maxn], f[maxn][maxn];
int main()
{
    cin>>n>>m;
    for(int i=1; i<=n; i++) cin>>a[i];
    f[0][0] = 1;
    for(int i=1; i<=n; i++)
       for(int j=0; j<=m; j++)
           for(int k=0; k<=min(j, a[i]); k++)
              f[i][j] = (f[i][j] + f[i-1][j-k])%mod;
    cout<<f[n][m]<<endl;
    return 0;
}

仔细观察上述代码，有木有发现什么...

方法四(dp优化法宝)：滚动数组

因为我们发现，状态转移方程中，当前状态 \(f(i, j)\)只跟 \(f(i-1, j)\) 有关系，与 \(i-2,i-3...\)无关。于是，我们可以利用滚动数组优化dp。

所谓滚动数组，其实就是只保留两个状态（当前状态和前一个状态），算完当前状态后，将当前状态变为前一个状态，再去算下一个状态，看上去就像二维数组的两层不断地迭代。

时间复杂度：\(O(nm\times a_i)\)

空间复杂度：\(O(2m)\)

代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=105, mod = 1000007;
int n, m, a[maxn], f[2][maxn], t;
int main()
{
    cin>>n>>m;
    for(int i=1; i<=n; i++) cin>>a[i];
    f[0][0] = 1;
    for(int i=1; i<=n; i++)
    {
        t = 1-t; //滚动
        for(int j=0; j<=m; j++)
        {
            f[t][j] = 0; //注意初始化
            for(int k=0; k<=min(j, a[i]); k++)
              f[t][j] = (f[t][j] + f[1-t][j-k])%mod;
        }
    }
    cout<<f[t][m]<<endl;
    return 0;
}

看到上述dp代码，有木有感觉很熟悉...

这熟悉的优化方法... 这TM不就是个背包吗!!!

方法五(背包大法好)：一维动态规划

通过观察上面的代码，二维数组，数组滚动优化空间......还有那熟悉的格式...

猛然发现这怎么可能不是背包呢（01背包）？

既然是背包，那么就可以为所欲为啦... [邪恶.jpg]

直接压成一维的01背包，跑一波，搞掂!!!

时间复杂度：\(O(nm\times a_i)\)

空间复杂度：\(O(m)\)

代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=105, mod = 1000007;
int n, m, a[maxn], f[maxn];
int main()
{
    cin>>n>>m;
    for(int i=1; i<=n; i++) cin>>a[i];
    f[0] = 1;
    for(int i=1; i<=n; i++)
        for(int j=m; j>=0; j--) //注意，是01背包
            for(int k=1; k<=min(a[i], j); k++)
              f[j] = (f[j] + f[j-k])%mod;
    cout<<f[m]<<endl;
    return 0;
}

讲到这里，我也没有什么优化的方法了（可能是我太弱了），希望以上的解题思路和优化方法能对你有帮助。

(三)总结

总的来说，这道题适合 搜索/动态规划 的初学者练习。

有一点点的思维难度（起码不是那种无脑搜索、无脑dp的题）。

尤其是推到最后发现其实这道题是一道背包，将特殊问题的特殊模型转化成为了经典模型（01背包），这对于 OI 的学习是很有帮助的。

因为一道题真正有价值的解法，不是那些只适用当前问题的解法/模型，而是那些转化问题，变为一般数学模型的解法。

转载于:https://www.cnblogs.com/GDOI2018/p/10219410.html