波动数列 神奇的dp

问题描述

　　观察这个数列：
　　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。

--------------------------------------------------------------------------------------------------------------------------

我算是摸透了，蓝桥杯最后两题如果数据大，肯定不是dfs，多半是DP

这个题是如何变出一个DP的递推公式呢，贼神奇

把a,b归结为一个状态p，第i个数要么是加a，要么是加b

对于n个数而言，a和b的总次数是 从1累加到(n-1)

我们暂且不论x是什么数，我们研究的是a出现的次数

对于第i个数来说 要么是a出现，要么是a不出现b出现，这两种状态

网上的思路大概是这样，dp[i-1][j]表示的是第i个数不取a

我想了很久，为什么dp[i-1][j-i]是表示第i个数取a，其他人对j有两种解释

1. dp（i，j）表示序列的前 i 项中 a 的次数为 j 时的方案种数。

2.dp[i][j]，表示前i个元素组成和为j的序列的方案数，这里的和j表示的是所有的a的和.

但是j的范围是

我是这么理解的 i表示前i项，而j是a出现次数的和，不是a一共出现了多少次，而是从1累加到出现的次数。

比如对于前两项而言，a只能出现1次或者2次，那么j的最大值就是1+2 = 3

　　对于前三项而言，a只能出现1，2，3次，那么j的最大值就是1+2+3 = 6

我之前在这里想了好久好久，抱住萌萌的自己。

dp[0][0] = 1

dp[1][0] = dp[0][0] = 1 || dp[1][1] = dp[0][1]+dp[0][0] = 1

dp[2][0] = dp[1][0] = 1 || dp[2][1] = dp[1][1] =1 || dp[2][2] = dp[1][2] + dp[1][0] = 1 || dp[2][3] = dp[1][3] + dp[1][1] = 1

dp用滚动数组节省空间，最后判断x是不是整数。

 #include<iostream>
 using namespace std;
 #define MOD 100000007
 #define MAXN 1100
 long long  n,s,a,b;
 long long all;
 long long Bo[2][MAXN*MAXN];//作为滚动数组
 int p=0;
 //p为滚动数组标识，表示当前操作数组的第几行，（例如当前计算第i行，p指向操作Bo数组第0行，逻辑上i-1行是Bo数组第1行）
 void fun_dp()
 {
     long long i,j;
     //动态规划前初始化,只有一个体积为0的物品，可以装入容量为0的背包，容量大于0的背包方案数为0
     Bo[p][0]=1;
     for(i=1;i<n;i++)//有体积为1到n-1的n-1种物品
     {
         p=1-p;//p如果是0变换成1，如果是1变换成0
         for(j=0;j<=i*(i+1)/2;j++)//背包容量从0到 i*(i-1)/2
         {
             if(i<j || i==j)
             {
                 Bo[p][j] = (Bo[1-p][j] + Bo[1-p][j-i]) % MOD;
             }else{
                 Bo[p][j] = Bo[1-p][j];
             }
         }
     }
 }
 int fun_sum()
 {
     long long count=0,i;
     long long temp;
     for(i=0;i<=all;i++)
     {
         temp = s - i*a + (all - i)*b;
         if(temp%n == 0)
         {
             count = (count+Bo[p][i])%MOD;
         }
     }
     return count;
 }
 int main()
 {
     long long count;
     cin >> n >> s >> a >> b;
     all = n*(n-1)/2; //最多可以增加多少个a（背包容量最大值）
     fun_dp();//进行动态规划的函数
     count = fun_sum();//统计总数
     cout << count;
     return 0;
 }