2023/11/4

每日一题(bit杯题3)+java学习

斐波那契 (悬而未决,用数学推导出了公式，但是公式有相除，且除数和被除数可能极大，但是结果却正常

问题介绍：

小明最近在数学课上研究了一个类似于斐波那契数列的数列，但他忘记了这个数列的前两个数是什么，所以小明想请作为数学高手的你来帮他找出答案。

小明只记得数列是一个单调不下降非负序列，且和斐波那契数列类似的是，对任意，都有。此外，他还记得这个数列的第个数为。

显然，只有这些条件并不足以恢复出小明研究的原数列，所以小明想请你算出有多少种可能的数列满足这些条件。

当然，作为数学爱好者的小明知道这对于数学高手的你来说并不困难，所以他一次性向你提出了组询问，来让你更好的证明自己的数学水平。

输入格式：

第一行输入整数（），表示一共有组询问。

在接下来的行中，每行为两个整数，代表在小明本次询问你的数列中，第个数为。

输出格式：

输出共行。第行为第次询问中所有可能满足要求的数列的数量。

注意：本题的测试数据共20个样例。

在前8个样例中，保证 。

在所有20个样例中，保证****。

输入示例****：

22 4

1 3

69 1434

11557 5

17031 11

42181 24

输出示例：

770

泛型有点难懂啊

package java_learning;

import java_basic.Boy;

import java.util.ArrayList;
import java.util.Arrays;


public class generics {
    public static void main(String[] args) {
        ArrayList<Integer> arr1 =new ArrayList<Integer>(); //ArrayList是泛型的一种，什么是泛型？可以理解成cpp的“模板”，就是在<>中传入一种类型得到一种适配定义
        //注意ArrayList使用Object数组实现存储的，因此必须是！！类！！而不能是基本数据类型(整数得用Integer而不是int)
        arr1.add(2); //自动包装类转化
        arr1.add(Integer.valueOf(2));
        arr1.add(5);
        for (int i:arr1){
            System.out.println(i);
        }
        String[] s1=new String[]{"z","hel,","world!"};
        Arrays.sort(s1); //Arrays工具类中有sort方法，对实现了 comparable<T>接口泛型的类可以自动排序
        System.out.println(Arrays.toString(s1));  //Arrays的toString方法可以 ！对每个元素！自动！调用toString()方法
        Boy[] b1=new Boy[]{new Boy("大水桶",21),new Boy("小水桶",12),new Boy("老水桶",30)};
        Arrays.sort(b1);
        System.out.println(Arrays.toString(b1));  //我将Boy类实现了Comparable<Boy>接口，即在内部定义compareTo方法，并把年龄作为比较的关键，成功得到排序后结
        generics g1=new generics();
        //！！！类必须依附于实例，而类中类则必须依附于实例的实例,否则会报错xxx变量是非静态的！不能用于静态上下文
        generics.pair<String,Integer> boy_pair=g1.new pair<String, Integer>("水桶王",21);
        boy_pair.shout();
        //pair<String,Integer> boy_pair=new pair<String, Integer>("水桶王",21);

        //泛型的本质:java是采用擦拭法来实现泛型机制的，在编写代码和执行代码时，编译器和JVM实际上会自动把 <T> 视为 Object类型 去执行代码
        //上述擦拭法有4个缺陷:
        // 1、不能用<T>来表示 基本数据类型(如int，上面讨论过)
        // 2、无法直接对T类型进行实例化  如 public T p_t=new T(); 是不被允许的,但你可仍然可以通过 Class<T> 来传入“形参实例”进行间接实例化,为什么要这样？因为:借助class.newInstance()创建实例时编译器要求强制处理可能出现的异常，相当于做了兼容。直接new的话如果泛型类型为"抽象类"，则不能实例化，则会出错。
        // 3、无法对T类型进行类型判断(如 instanceof)，因为是作为Object类型
        // 4、无法获得带泛型的Class，因为视为object,Pair<T>中 p1.getClass()只会获得Pair.class
        // 5、覆写：编译器会阻止一个实际上会变成“覆写”的泛型方法定义
        num<Double> f1=new num<>(0.12);
        num<Integer> a=new num<>(1);
        f1.show(a);
    }
    public class pair<T,K>{
        Class<T> a;// =new Class<T>();为私有方法
        public T p_t; //=a.newInstance(); 会有Exception
        public K p_k;

        public pair(){

        }

        public pair(T p_t, K p_k) {
            this.p_t = p_t;
            this.p_k = p_k;
        }



        public T getP_t() {
            System.out.println(p_t);
            return p_t;
        }

        public K getP_k() {
            System.out.println(p_k);
            return p_k;
        }

        //public static<T,K> pair<T,K> shout(){}  默认是不能将模板类型用于static变量的(因为一般需要在外部实例化模板)，但是你可以在static后面加一个<T,K>来强制使用
        public void shout(){
            System.out.println("%s,%d".formatted(this.p_t,this.p_k)); //格式化字符串必须用规定的 %s 占位符，不能用自定义的！泛型编程虽然编译器暂时无法识别泛型类型，但可以只用能够被格式化输出的类型
        }
//        public boolean equal(T t1){
//
//        }

    }

    public class people extends pair<String,Integer>{  //可以创建继承了父类模板并指明具体类型的子类，这样可以实例化，也可以getClass了，但感觉没卵用?

    }

    public static class num<T extends Number>{ //通配符也能限定类的实例化-->本质是 擦拭成Number进行处理！！！ 但是对于机器来说们仍然是参数仍然是不确定的类型，编译器必须阻止这种不确定
        T a;
        public num(T a){
            this.a=a;
        }
        static void show(num<? extends Number> a){  //类型通配符，通常用在static方法中(因为静态往往没有实例化确定T类型，需要适配多种类型)
            System.out.println(a);
        }
    }
}

LOADING

每日一题(bit杯题3)+java学习

斐波那契 (悬而未决,用数学推导出了公式，但是公式有相除，且除数和被除数可能极大，但是结果却正常