波动数列-笔记 Java【动态规划、整数分拆】

在参考了各位前辈的答案后，我终于理解了。现在写在这里，希望有帮到大家，看完的难兄难弟们，记得长按点赞三连！！！（咳咳，不好意思走错片场了）
参考的是这位大佬：https://blog.csdn.net/nxjhi/article/details/69389074
问题描述
　　观察这个数列：
　　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。

#抓住核心：“1 个数的限制；2 和的限制；3 后一项是前一项的加a或减b”
用P表示(+a,-b)，设第一项为x，数列 就是 s=x+x+P+x+2P+…x+(n-1)P,化简发现了(s-(n*(n-1)/2)P)/n=x;
(n(n-1)/2)P=ia-jb;里面的i和j满足i+j=n(n-1)/2，也就是知道i就知道j；
(s-ia+jb)/n=x;
x一定是正整数，所以问题等同于(s-ia+jb)%n=0

这个规律怎么解决方案数呢？i的个数确定的时候，不止一种啊
看看我们做的数学表达式s=x+x+P+x+2P+…x+(n-1)P,你会发现一个i和这个表达式就是关键点，假如i=6做例子的时候发现，比如2+4=6，就是2P和4P，所以说这就是一个整数分拆
6；

5+1；

4+2，4+1+1；

3+3，3+2+1，3+1+1+1；

2+2+2，2+2+1+1，2+1+1+1+1；

1+1+1+1+1+1。
怎么实现这个整数分拆，你会发现这其实是个选与不选的01背包问题，用动态规划搞出来，从后面开始搜索，在0时等于1，ok方案数搞定。
看不懂的可以看看https://blog.csdn.net/nxjhi/article/details/69389074
结果70分emmmm，老老实实再回去看大佬的代码，溢出的问题？？，看了看，真相了，s-ia+jb，看-1,000,000,000<=s<=1,000,000,000，1<=a, b<=1,000,000。假如i=0,s+j*b s=10⁹,j=1000*999/2=499500,b=10⁶,
4.996x10¹¹+10⁹,
又看了看long类型取值问题

因为负数对整数如果能被整除在Java就是0
So可以变形一下公式缩小范围s-ia+jb——>(n*(n-1)/2)a-s-0*b 4.996x10¹¹-10⁹,
然后看b的个数，算方案数

import java.util.Scanner;
public class 波动数列 {

    static int MOD=100000007;

    static int cnt[];
    static void DP(int n){
        cnt[0]=1;
        for(int i=1; i<n; i++){
            for(int j=i*(i+1)/2; j>=i; j--){
                cnt[j] = (cnt[j]+cnt[j-i])%MOD;
            }
        }
    }


    public static void main(String[] args){
        Scanner sc =new Scanner(System.in);

        int n=sc.nextInt();
        int s=sc.nextInt();
        int a=sc.nextInt();
        int b=sc.nextInt();


        int M=n*(n-1)/2;
        long result=0;
        cnt=new int[M+1];
        DP(n);
        long t=1l*a*M-s;
        if(t%n==0){
            result++;
        }

        for(int i=1;i<=M;i++){
            //t=s-(i*a-(M-i)*b);
            t=t-a-b;
            if(t%n==0){
                result=(result+cnt[i])%MOD;
            }
        }
        System.out.println(result);

    }
}
//参考https://blog.csdn.net/nxjhi/article/details/69389074