蓝桥杯 历届试题 波动数列 DP 01背包 滚动数组

问题描述

　　观察这个数列：
　　1 3 0 2 -1 1 -2 ...

　　这个数列中后一项总是比前一项增加2或者减少3。

　　栋栋对这种数列很好奇，他想知道长度为 n 和为 s 而且后一项总是比前一项增加a或者减少b的整数数列可能有多少种呢？

输入格式

　　输入的第一行包含四个整数 n s a b，含义如前面说述。

输出格式

　　输出一行，包含一个整数，表示满足条件的方案数。由于这个数很大，请输出方案数除以100000007的余数。

样例输入

4 10 2 3

样例输出

2

样例说明

　　这两个数列分别是2 4 1 3和7 4 1 -2。

数据规模和约定

　　对于10%的数据，1<=n<=5，0<=s<=5，1<=a,b<=5；
　　对于30%的数据，1<=n<=30，0<=s<=30，1<=a,b<=30；
　　对于50%的数据，1<=n<=50，0<=s<=50，1<=a,b<=50；
　　对于70%的数据，1<=n<=100，0<=s<=500，1<=a, b<=50；
　　对于100%的数据，1<=n<=1000，-1,000,000,000<=s<=1,000,000,000，1<=a, b<=1,000,000。

再次更新！！！重大更新！！！经过三次修改，这道题终于最终出来了

抱歉让大家看了那么久的错误代码和错误的思路。

首先要说，这道题是一道DP。

虽然之前也注意到数据范围很大，但因为一开始就想的是搜索，所以就各种搜索剪枝，实际上都是徒劳。

像这种简单的DP题目一般都有两个特点：

1.长得和搜索题很像，甚至就能用搜索做

2.有一个大的吓人的数据

看清这两点，明确了思路，下面开始进入分析阶段：

1.按照题目要求，最终得到的序列的长度为n，和为s，并且后一项是前一项加a或减b，我们不妨将这个操作封装在一起，记作P操作，即P=(a,-b)。

2.设首项为x，可以得到一个等式x+(x+P)+(x+2P)+...+(x+(n-1)P)=s，将这个式子整理一下，就是 nx+P+2P+...+(n-1)P=s，即(s-(P+2P+...+(n-1)P))/n=x。

3.由题意，x肯定是一个整数，并且由于每一个P代表一个a或者一个-b，所以a和b的总数为n*(n-1)/2，也就是说只要确定了a的个数，那么b的个数也就确定了。

4.关键问题是对于一个确定的a的个数，方案不只有一种，而且a的个数肯定是由（1,2,3,...,n-1）这其中的若干项组成的，，我们把这些项看作元素，第i个元素的权值为i于是，下面就开始构造递推方程

5.首先，定义一个数组dp[i][j]，表示前i个元素组成和为j的序列的方案数，这里的和j表示的是所有的a的和，很明显当i!=0时dp[i][0]=1,当j!=0时dp[0][j]=0，然后我们要分两种情况讨论

(1)、i>j时，因为每一个元素i权值都是i，所以当元素的个数大于和的时候，第i个元素的权值已经超过了和，所以第i个元素绝对不能使用，即dp[i][j]=dp[i-1][j]。

(2)、i<=j时，第i个元素的权值是小于等于和的，所以可以用，也可以不用，如果不用，那么就是dp[i-1][j]，如果用，就是dp[i-1][j-i]，这个有点类似于01背包，所以

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

OK，通过上面的分析，我们得到了递推方程，但还有一个问题，就是空间的问题，题目给出的i的最大值达到1000，相应的j也就是1000^2，我们是不可能开出这么大的数组的，观察递推方程，我们可以看出下一个状态只和前一个状态有关，而且我们实际上只需要最后一个状态即，dp[n][j]，于是可以使用滚动数组。

先简单说明一下什么叫滚动数组，因为DP的过程就是一个递推的过程，在推导的过程中，数组中的每一个元素或者是前一个状态，或者是后一个状态，但是，当我们并不需要中间状态得到保留的时候，可以使下一个状态覆盖之前的一个状态，这样就可以极大的压缩空间。

回到本题，我们定义dp[2][MAX*MAX]，也就是说，后面的状态会把前面的状态覆盖掉。

下面上正确的代码

#include <iostream>
#include <memory.h>
#define MAXN 1100
#define MOD 100000007
using namespace std;

int F[2][MAXN*MAXN];        
int e = 0;
long long n,s,a,b;
int cnt = 0;

void DP(int elem)
{
    int i,j;
    memset(F,0,sizeof(F));
    F[e][0]=1;
    for(i=1;i<n;i++)
    {
        e=1-e;
        for(j=0;j<=i*(i+1)/2;j++)
        {
            if(i>j)
                F[e][j]=F[1-e][j];
            else
                F[e][j]=(F[1-e][j]+F[1-e][j-i])%MOD;
        }
    }
}

int main()
{
    cin>>n>>s>>a>>b;
    long long i,t;
    DP(n*(n-1)/2);
    for(i=0; i<=n*(n-1)/2; i++)
    {
        t = s - i*a + (n*(n-1)/2-i)*b;
        if(t%n==0)
           cnt = (cnt+F[e][i])%MOD;
    }
    printf("%d",cnt);
    return 0;
}

                                                    |

                                                    |

                                                    |

                                                 \  |  /

                                                   \ /

                                下面的思路虽然是错的，但我也不删了哈       

这道题实在让人头疼，就差一点了，却偏偏出不来，就当练习BFS和DFS了。题意很简单，就是一个数列之和为给定的值，而数列的每一个元素又是由前一项加a或减b得来的。DFS的时候，出口当然就是长度达到给定长度并且和为给定值的时候，注意回溯的时候要恢复sum原来的值，而且我还剪了一下枝，思路是这样的：当递归到某一层时，假设此时的数值为sum，len，那么可能出现这样的情况，1.即使以后全都是加a，最终也要比s小；2即使以后全都是减b，最终也要比s大。

针对第一种情况，之后的运算应该是sum+(head+a)+(head+2a)+(head+3a)+……+(head+(n-len)a)<s;

针对第二种情况，之后的运算应该是sum+(head-a)+(head-2a)+(head-3a)+……+(head-(n-len)a)>s;

在排除了这两种情况后，计算的次数明显减少了很多。有点意思的是这个数列的头不是固定的，而是一个范围，即[s-n*b,s+n*a]。!!!!!!!!注意这个红色的范围是错误的，感谢@旻饯之行提醒，当时不知道怎么想的，s是这个数列的前n项和，而我们要求数列的首项，当然是用s减去后n-1项的和，对于最大的首项，是x+(x-b)+(x-2b)+...+(x-(n-1)b)=s中的x，这个值是s/n+(n-1)*b/2，对于最小的首项，是x+(x+a)+(x+2a)+...+(x+(n-1)a)=s中的x，这个值是s/n-(n-1)*a/2，再次提醒红色的不对，绿色的对！！！

#include<iostream>
typedef long long ll;
using namespace std;
ll n,s,a,b,sum;
ll cnt;
void dfs(ll len,ll head)
{
	sum=sum+head;
	//cout<<len<<' '<<head<<' '<<sum<<endl;
	
	
	
	if(s>sum+(n-len)*head+((n-len)*(1+n-len)/2)*a)
	{
		sum=sum-head;
		return;
	 } 
	if(s<sum+(n-len)*head-((n-len)*(1+n-len)/2)*b)
	{
		sum=sum-head;
		return;
	}
	if(len==n&&sum==s)
	{
		cnt++;
		cnt=cnt%100000007;
		sum=sum-head;
		return;
	}
	if(len==n&&sum!=s)
	{
		sum=sum-head;
		return;
	}
	dfs(len+1,head+a);
	dfs(len+1,head-b);
	sum=sum-head;
}



int main()
{
	cnt=0; 
	cin>>n>>s>>a>>b;
	for(ll i=s-n*a;i<=s+n*b;i++)
	{
		sum=0;
		dfs(1,i);
	}
	cout<<cnt<<endl;
	return 0;
}

因为DFS一直超时，机智的我又想起了BFS，然后就用BFS又做了一个，值得注意的是，如果用BFS做，需要两个队列，一个用来存储加a或者减b之后的数，另一个则用来存储从根节点加到某一节点的和，而这个和是需要第一个队列弹出的元素得到的，就像这样

#include<iostream>
#include<queue>
#include<cmath>
typedef long long ll;
using namespace std;
ll n,s,a,b,sum;
ll cnt;

void bfs(ll head)
{
	ll len;
	queue<ll> q;
	queue<ll> S;
	S.push(head);
	q.push(head);
	len=1;
	while(!q.empty()&&len<=pow(2,n)-1)
	{
		ll t=q.front();
		//cout<<t<<' ';
		ll T=S.front();

		//cout<<T<<' ';
		if(len>=pow(2,n-1)&&len<=pow(2,n)-1)
		{
			//cout<<T<<' ';
			if(T==s)
			cnt++;
		}
		q.pop();
		S.pop();
		//if(len<=3)
		//{
			q.push(t+a);
			q.push(t-b);
			S.push(T+t+a);
			S.push(T+t-b);
		//}
		len++;
	}
	
}


int main()
{
	cnt=0; 
	cin>>n>>s>>a>>b;
	for(ll i=s-n*a;i<=s+n*b;i++)
	{
		sum=0;
		bfs(i);
		//cout<<endl;
	}
	cout<<cnt<<endl;
	return 0;
}

虽然最终也实现了计算出结果，但很明显，这个方法速度更慢，所以只得了10分，不过，通过一道题复习两个知识点还是比较划算的，也只能这样安慰自己了。。。