[NOIP2012 普及组] 摆花

ny_jerry

于 2023-03-30 19:00:50 发布

阅读量375

点赞数

分类专栏： dp 模拟文章标签：算法 c++

本文链接：https://blog.csdn.net/2301_76869282/article/details/129864194

版权

模拟同时被 2 个专栏收录

22 篇文章 0 订阅

订阅专栏

20 篇文章 0 订阅

订阅专栏

题目描述

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

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

输入格式

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

第二行有 nn 个整数，每两个整数之间用一个空格隔开，依次表示 a_1,a_2, \cdots ,a_na1,a2,⋯,an。

输出格式

一个整数，表示有多少种方案。注意：因为方案数可能很多，请输出方案数对 10^6+7106+7 取模的结果。

输入输出样例

输入 #1复制

2 4
3 2

输出 #1复制

说明/提示

【数据范围】

对于 20\%20% 数据，有 0<n \le 8,0<m \le 8,0 \le a_i \le 80<n≤8,0<m≤8,0≤ai≤8。

对于 50\%50% 数据，有 0<n \le 20,0<m \le 20,0 \le a_i \le 200<n≤20,0<m≤20,0≤ai≤20。

对于 100\%100% 数据，有 0<n \le 100,0<m \le 100,0 \le a_i \le 1000<n≤100,0<m≤100,0≤ai≤100。

NOIP 2012 普及组第三题

（〇）数学符号注释

本文中的某些符号体系并不标准，一些读者会在其他书中学习类似的内容。这里列出了他们可能不熟悉的符号。

符号	名称	等价形式
\sum\limits_{i=1}^na_ii=1∑nai	求和（和式）	a_1+a_2+\cdots+a_{n-1}+a_na1+a2+⋯+an−1+an
\prod\limits_{i=1}^na_ii=1∏nai	求积	a_1\times a_2\times\cdots\times a_{n-1}\times a_na1×a2×⋯×an−1×an
[m=n][m=n]	如果m=nm=n值为11;否则为00	\begin{cases}1&m=n\\ 0& m\not=n\end{cases}{10m=nm=n

（一）题目大意

简化一下题意：

有 nn 个数（c_1,c_2,...,c_nc1,c2,...,cn）， 0\leqslant c_i\leqslant a_i0⩽ci⩽ai,求有多少种方案数使\sum\limits_{i=1}^nc_i = mi=1∑nci=m。

（二）解题思路

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

方法一：搜索

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

从 1 到 nn 考虑每个 c_ici 的值，和当前前 ii 个数的总和 kk，然后枚举当前 x_ixi 所有可能的值，再递归求解。

时间复杂度 O(\prod\limits_{i=1}^na_i)O(i=1∏nai)，明显超时，~~但可以拿部分分（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(nma_i)O(nmai) 吧，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;
}

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

方法三：动态规划

记忆化搜索都可以转成动态规划，但是动态规划却不一定能转成记忆化搜索 ——byby clgclg

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

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

其中, kk是枚举当前第 ii 个数的取值。

时间复杂度：O(nma_i)O(nmai)，稳得一批。

空间复杂度：O(nm)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,j)只跟 f(i-1, j)f(i−1,j) 有关系，与 i-2,i-3...i−2,i−3...无关。于是，我们可以利用滚动数组优化dp。

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

时间复杂度：O(nma_i)O(nmai)

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

代码：

#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(nma_i)O(nmai)

空间复杂度：O(m)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;
}

方法六：前缀和优化

继续观察方法五的代码，时间复杂度是\Theta(n^3)Θ(n3)级别的。与背包有一些差别的是这一句：

for(int k=1; k<=min(a[i], j); k++)
    f[j] = (f[j] + f[j-k])%mod;

然而，这一句的作用只不过是将连续的一段f[j-a[i]]f[j−a[i]]到f[j-1]f[j−1]累加起来而已。因此，可以用前缀和将这个操作优化（众所周知，前缀和的作用就是\Theta(1)Θ(1)求一段区间的和）。

时间复杂度：\Theta(nm)Θ(nm)

顺便卡到了次优解。

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

提示：上面的程序在计算f[j]f[j]的时候有可能会出现数组越界的情况，但为了代码美观容易理解，没有特判。这一点需要注意，考场上不慎就会抱灵。

下面是加上了特判的代码：

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