“蓝桥杯”练习系统 基础练习

已于 2022-01-18 20:03:22 修改
阅读量3.1k 收藏 9
点赞数 3
文章标签： 蓝桥杯 java
于 2021-12-22 22:57:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43449564/article/details/122096163
版权

BASIC Problemset

  OJ 传送门

  想不出什么漂亮话，

  希望大家能精益求精把。

  可能会 J a v a \mathrm{Java} Java、 C \mathrm{C} C++ 混写，

  差别不大。

  以蓝桥的总和难度而言，

  基础练习入个门，然后历届真题一刷就能冲击国家一等奖，

  题库后面的那些题个人综合来看，

  建议是转其他平台刷，

  虽然我在哪多少都刷了点就是的了。

BASIC 1  闰年判断

  OJ：蓝桥

  感觉应该分类为 B E G I N \mathrm{BEGIN} BEGIN，而非 B A S I C \mathrm{BASIC} BASIC。

  因为，可以说你的程序就算执行效率再高，与自然语言描述的闰年判断差距也不大，

  如：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int year = in.nextInt();
        if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
            System.out.println("yes");
        else
            System.out.println("no");
    }
}

  但其实还是有不小的优化空间，

  如合并判断分支，使得至多判断两个布尔表达式的值就能得到结果。

boolean isLeapYear(int year) { return year % 100 == 0 ? year % 400 == 0 : year % 4 == 0; }

  小压一个行。

  还有就是，对于 n \mathrm{n} n 进制数 N \mathrm{N} N， n > 1 \mathrm{n} >1 n>1，

  在其最低位后拼接 k \mathrm{k} k 个 0 0 0，

  得到的数值为 N × n k \mathrm{N} × \mathrm{n^{k}} N×nk。

  我们自然可以知道， 4 4 4 的倍数在二进制下，最低两位一定是 00 00 00。

  将 y e a r \mathrm{year} year 与 0 b 11 0\mathrm{b}11 0b11 做与运算，结果为 0 0 0 则代表 y e a r \mathrm{year} year 为 4 4 4 的倍数。

  运算速度稍微会快于取余。

boolean isLeapYear(int year) { return year % 100 == 0 ? year % 400 == 0 : (year & 0b11) == 0; }

  还有就是 J a v a   8 \mathrm{Java\ 8} Java 8 提供了新的工具类 IsoChronology，

  直接调用 INSTANCE 成员的 isLeapYear 方法，就能达到判断闰年的效果。

		IsoChronology.INSTANCE.isLeapYear(year);

BASIC 2  01字串

  OJ：蓝桥

  这个题很适合做复杂度下界一个分类的讨论，

  一个程序从零个或多个输入经由有限个步骤到一个或多个输出，

  通常我们在计算复杂度时，只去关系中间执行的有限步骤与那些输入有光，而忽略了输入输出的规模。

  这个题就是让我们顺序输出所有长度为 n \mathrm{n} n 的 01 01 01，无论你中间经由几步，最后都要输出 O ( n log ⁡ n ) O(n \log n) O(nlogn) 个字符。

  也就是说，解决这个问题的程序最后都会首受限于输出的复杂程度，从而导致整个程序的复杂度不可能低于 O ( n log ⁡ n ) O(n \log n) O(nlogn)。

  因此没有什么花里胡哨，建议直接摆烂。

  拼接式：

public class Main {

    public static void main(String[] args) {
        for (int i = 0; i < 2; i++)
            for (int j = 0; j < 2; j++)
                for (int l = 0; l < 2; l++)
                    for (int x = 0; x < 2; x++)
                        for (int y = 0; y < 2; y++) System.out.println(i + "" + j + "" + l + "" + x + "" + y);

    }
}

  十到二进制横跳：

public class Main {

    public static void main(String[] args) {
        for (int i = 0; i < 0x20; i++)
            System.out.printf("%05d%n", Integer.parseInt(Integer.toBinaryString(i)));
    }
}

  手动进制转换：

public class Main {

    public static void main(String[] args) {
        for (int i = 0; i < 0x20; i++) {
            for (int j = 4; j >= 0; j--)
                System.out.print(i >> j & 1);
            System.out.print('\n');
        }
    }
}

BASIC 3  字母图形

  OJ：蓝桥

  开始后悔整理基础练习了，都是摆烂题。

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        byte[] buff = {90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90};
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), m = in.nextInt();
        int offset = 26;
        while(n-- > 0) {
            System.out.write(buff, --offset, m);
            System.out.println();
        }
    }
}

BASIC 4  数列特征

  OJ：蓝桥

  啊对对对，摆就完了。

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), a, max = -10000, min = 10000, sum = 0;
        while (n-- > 0) {
            sum+= a = in.nextInt();
            if (a > max) max = a;
            if (a < min) min = a;
        }
        System.out.printf("%d\n%d\n%d", max, min, sum);
    }
}

BASIC 5  查找整数

  OJ：蓝桥

  粗糙的讲，

  算法竞赛中的题型大体分为传统(黑盒测试)形、结果提交形、 G r a d e r \mathrm{Grader} Grader 交互形。

  也可以粗糙的理解成蓝桥编程、蓝桥填空、力扣刷的题。

  有点跑题，

  简单的描述一下传统形和交互形，忽略 I O \mathrm{IO} IO 细节就是做阅读理解先看问题还是后看问题的区别。

  在这个问题上，如果我们预先知道整数 a a a，那么我们不需要额外的内存，直接对输入流或集合对象中的序列一一比对即可，空间复杂度在 O ( 0 ) O(0) O(0)，

  可惜并不是，因此对于序列上的这种询问，通常我们有两种处理方式。

  预先处理出所有可能的询问的结果，空间复杂度在 O ( ∣ [ a n s ] ∣ ) O(\mid [ans]\mid) O(∣[ans]∣)：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), a, b;
        int[] idx = new int[10001];
        for (int i = 1; i <= n; i++) {
            b = in.nextInt();
            if (idx[b] == 0) idx[b] = i;
        }
        a = in.nextInt();
        System.out.println(idx[a] == 0 ? -1 : idx[a]);
    }
}

  保存序列，待取到 a a a 后进行第二遍的遍历，空间复杂度在 O ( n ) O(n) O(n)：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), a, idx = -1;
        int[] A = new int[n + 1];
        for (int i = 1; i <= n; i++)
            A[i] = in.nextInt();
        a = in.nextInt();
        for (int i = 1; i <= n; i++)
            if (a == A[i]) {
                idx = i;
                break;
            }
        System.out.println(idx);
    }
}

BASIC 6  杨辉三角形

  OJ：蓝桥

  用组合数的性质 C n + 1 m = C n m + C n m − 1 C_{n+1}^{m} = C_{n}^{m} + C_{n}^{m-1} Cn+1m​=Cnm​+Cnm−1​，咔咔咔就出来了。

  值得注意的是，给定的 n \mathrm{n} n 最大为 34 34 34，这意味着三角中最大的数字为 C 33 16 = 1166803110 C_{33}^{16} = 1166803110 C3316​=1166803110。

  使用 i n t \mathrm{int} int 表示、运算是完全可行的。

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        int n = new Scanner(System.in).nextInt();
        int[][] pascal = new int[n + 1][n + 2];
        pascal[0][0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                pascal[i][j] = pascal[i - 1][j] + pascal[i - 1][j - 1];
                System.out.print(pascal[i][j]);
                System.out.write(' ');
            }
            System.out.println();
        }
    }
}

  直接在 n × n \mathrm{n × n} n×n 的二维数组中，递推这个过程，会接近一半的内存被浪费掉。

  一种朴素的解决方式就是，动态开第二维的数组，

  不过这里换一种做法，

  显然可以发现，如果按横排的方式编号， C n + 1 m C_{n+1}^{m} Cn+1m​ 到 C n m − 1 C_{n}^{m-1} Cnm−1​ 中间隔着 n n n 个数字，而 C n m C_{n}^{m} Cnm​ 到 C n m − 1 C_{n}^{m-1} Cnm−1​ 中只隔着一个数字，我们可以根据这个性质在线性表中计算和表示一个杨辉三角。

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        int N = new Scanner(System.in).nextInt();
        int[] pascal = new int[N * (N + 1) / 2];
        for (int n = 1, i = 0; n <= N; n++) {
            for (int m = 1; m <= n; m++, i++) {
                if (m == 1 || n == m) pascal[i] = 1;
                else pascal[i] = pascal[i - n] + pascal[i - n + 1];
                System.out.print(pascal[i]);
                System.out.write(' ');
            }
            System.out.println();
        }
    }
}

  又或直接使用组合数计算公式

   C n m = A n m A m = n ! m ! ( n − m ) ! C_{n}^{m}=\cfrac{A_{n}^{m}}{A_{m}} = \cfrac{n!}{m!(n - m)!} Cnm​=Am​Anm​​=m!(n−m)!n!​

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        int N = new Scanner(System.in).nextInt();
        for (int n = 0; n < N; n++) {
            for (int m = 0; m <= n; m++) {
                System.out.print(C(n, m));
                System.out.write(' ');
            }
            System.out.println();
        }
    }

    static int C(int n, int m) {
        if (m == 0 || n == m) return 1;
        long C = 1;
        for (int i = 1; i <= m; i++)
            C = C * (n - i + 1) / i;
        return (int)C;
    }
}

  但这么做的复杂度几乎在 O ( n 4 ) O(n^{4}) O(n4)，不过常数极小。

BASIC 7  特殊的数字

  OJ：蓝桥

  水仙花数，不谈，

  硬说点什么的话，不建议在这类数字的性质上投入探索研究的时间，

  因为大概率是无果的。

  不过我们可以在这类自幂数上，看到为什么我们在设计通用计算机上的程序时要尽量避免取余运算。

  以计算六合数为例，在 洛谷在线 IDE 提交的结果：

548834
13ms
548834
16ms

  提交的程序：

public class Main {

    public static void main(String[] args) {
        long start, end;
        int[] six = new int[10];
        for (int i = 1; i < 10; i++)
            six[i] = i * i * i * i * i * i;
        start = System.currentTimeMillis();
        for (int n = 100000, a = 1; a < 10; a++)
            for (int b = 0; b < 10; b++)
                for (int c = 0; c < 10; c++)
                    for (int d = 0; d < 10; d++)
                        for (int e = 0; e < 10; e++)
                            for (int f = 0; f < 10; f++, n++)
                                if (six[a] + six[b] + six[c] + six[d] + six[e] + six[f] == n)
                                    System.out.println(n);
        end = System.currentTimeMillis();
        System.out.println(end - start + "ms");
        start = System.currentTimeMillis();
        for (int n = 100000; n < 1000000; n++)
            if (six[n / 100000] + six[n / 10000 % 10] + six[n / 1000 % 10] + six[n / 100 % 10] + six[n / 10 % 10] + six[n % 10] == n)
                System.out.println(n);
        end = System.currentTimeMillis();
        System.out.println(end - start + "ms");
    }
}

  可以看到，即使是这种地步的 f o r \mathrm{for} for 嵌套，性能也比得过频繁的取余运算。

  多得就没能力讨论了，撤。

public class Main {

    public static void main(String[] args) {
        int[] cube = new int[10];
        for (int i = 1; i < 10; i++) cube[i] = i * i * i;
        for (int i = 1, j, l, num = 100; i < 10; i++)
            for (j = 0; j < 10; j++)
                for (l = 0; l < 10; l++, num++)
                    if (cube[i] + cube[j] + cube[l] == num) System.out.println(num);
    }
}

BASIC 8  回文数

  OJ：蓝桥

  能讨论的同上，且使用按位组合的方式复杂度与值域中的回文数的个数相关。

public class Main {

    public static void main(String[] args) {
        char[] four = new char[4];
        for (char i = '1'; i <= '9'; i++) {
            four[0] = four[3] = i;
            for (char j = '0'; j <= '9'; j++) {
                four[1] = four[2] = j;
                System.out.println(four);
            }
        }
    }
}

BASIC 9  特殊回文数

  OJ：蓝桥、PythonTip

  同上同上。

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        int N = new Scanner(System.in).nextInt();
        for (char i = '1', l; i <= '9'; i++)
            for (char j = '0'; j <= '9'; j++) {
                l = (char)(N - i * 2 - j * 2 + 0xF0);
                if (l >= '0' && l <= '9')
                    System.out.printf("%c%c%c%c%c\n", i, j, l, j, i);
            }
        if (N % 2 == 0) {
            N >>= 1;
            for (char i = '1', l; i <= '9'; i++)
                for (char j = '0'; j <= '9'; j++) {
                    l = (char)(N - i - j + 0x90);
                    if (l >= '0' && l <= '9')
                        System.out.printf("%c%c%c%c%c%c\n", i, j, l, l, j, i);
                }
            }
    }
}

  最好还是对编码有一定的了解，

  一般的我们在算法竞赛中，提交的答案都是以 A S C I I \mathrm{ASCII} ASCII 码的形式组织。

  其中0x0A表示换行、0x0D表示回车

  0x20表示空格

  0x30-0x39表示0-9

  0x61-0x7A表示a-z

  0x41-0x5A表示A-Z

  再加上0x28、0x29表示左右括号，

  基本上了解这么多就行了。

  除了使用它的编码来带入表达式中计算出某个字符的编码外，

  还可以对像0x28、0x29做异或1运算，来达到左右括号互换的作用。

  就像 J 括号序列 这道题，

  在熟悉的人眼里，我想是能达到简化代码，增加可读性的作用，

  过。

BASIC 10 十进制转十六进制

BASIC 11 十六进制转十进制

  OJ：蓝桥、蓝桥

  程序就懒得挂了，直接来看 J a v a \mathrm{Java} Java 提供的Scanner在面对任意进制的输入以及输入，提供了那些操作。

   J a v a   8 \mathrm{Java}\ 8 Java 8：

    private int defaultRadix = 10;

	public int nextInt() { return nextInt(defaultRadix); }
    
    public int nextInt(int radix) {
        if ((typeCache != null) && (typeCache instanceof Integer)
            && this.radix == radix) {
            int val = ((Integer)typeCache).intValue();
            useTypeCache();
            return val;
        }
        setRadix(radix);
        clearCaches();
        try {
            String s = next(integerPattern());
            if (matcher.group(SIMPLE_GROUP_INDEX) == null)
                s = processIntegerToken(s);
            return Integer.parseInt(s, radix);
        } catch (NumberFormatException nfe) {
            position = matcher.start(); // don't skip bad token
            throw new InputMismatchException(nfe.getMessage());
        }
    }

  可以看到，在调用int nextInt()后，Scanner会继续调用int nextInt(int radix)方法，

  在nextInt(int radix)方法体中，首先检查了缓存里是否有类型相同的数据(因为流是严格单向的，在调用如boolean hasNext()的方法后，需要先将has的这一段取出，因此需要暂存起来)，

  随后就是一系列的判断检错，中间最核心的，也就是实在用到radix这个参数的，只有

  return Integer.parseInt(s, radix)

  这句，可以粗糙的去理解，那就是对于任意输入，Scanner总是使用对应类型的工具类中的转换方法，然后传入一个next()进行转换。

  好像应该单独开一篇博客，Integer.parseInt先按住不表。

  算了我摆烂了，转换可以用String toString(int i, int radix)方法。

  过过过过。

慢慢更

BEGIN 1  A+B问题

  考察基本语法，

  引出平台的输入输出规范。

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt(), b = in.nextInt();
        System.out.println(a + b);
    }
}

BEGIN 2  序列求和

  考察对输出范围的敏感度。

  当 n = 1 E 9 \mathrm{n} = 1E9 n=1E9 时，结果显然超出 i n t \mathrm{int} int 表示范围。

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextInt();
        System.out.println((n + 1) * n / 2);
    }
}

BEGIN 3  圆的面积

  考察是否为数盲。

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int r = in.nextInt();
        System.out.printf("%.7f", r * r * Math.PI);
    }
}

BEGIN 4  Fibonacci数列

  先挂二种最基本的写法，

  迭代式：

import java.util.Scanner;

public class Main {

    static int MOD = 10007;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] fib = new int[n + 1];
        fib[1] = 1;
        for (int i = 2; i <= n; i++)
            fib[i] = (fib[i - 1] + fib[i - 2]) % MOD;
        System.out.println(fib[n]);
    }
}

  迭代式内存优化：

import java.util.Scanner;

public class Main {

    static int MOD = 10007;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int fib = 1, fib1 = 1, fib2 = 0;
        while (n-- > 1) {
            fib = (fib1 + fib2) % MOD;
            fib2 = fib1;
            fib1 = fib;
        }
        System.out.println(fib);
    }
}

  还可以压行：

		fib1 =  fib = (fib2 + (fib2 = fib1)) % MOD;

  递归式：

import java.util.Scanner;

public class Main {

    static int MOD = 10007;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        System.out.println(fib(n));
    }

    static int fib(int n) {
        if (n == 0) return 0;
        if (n == 1) return 1;
        return (fib(n - 1) + fib(n - 2)) % MOD;
    }
}

  前面两种时间复杂度都在 O ( n ) O(n) O(n)，

  后面这个就厉害了，足足有 O ( 2 n ) O(2^{n}) O(2n)，

  不过线性复杂度在真正的大数据下，

  也还是显得捉襟见肘，

  而我们熟知的比内公式 F n = 1 5 [ ( 1 + 5 2 ) n − ( 1 − 5 2 ) n ] F_n = \cfrac{1}{\sqrt{5}}\begin{bmatrix}\left(\frac{1 + \sqrt{5}}{2}\right)^n - \left(\frac{1 - \sqrt{5}}{2}\right)^n\end{bmatrix} Fn​=5 ​1​[(21+5 ​​)n−(21−5 ​​)n​]  不论是高频的浮点数计算，还是需要额外实现分步骤取余，

  都是我们在设计计算机程序时，需要尽量避免的，

  因此这里介绍两种信息学中常见的快速斐波那契数计算方法，

  矩阵表示法：

  斐波那契数的递推可以用矩阵的乘法来表示，如：

     F n + 1 = F n + F n − 1 \:F_{n + 1} = F_{n} + F_{n - 1} Fn+1​=Fn​+Fn−1​， n > 0 n > 0 n>0， F 0 = 0 F_{0} = 0 F0​=0， F 1 = 1 F_{1} = 1 F1​=1

   [ F n − 1 F n ] = [ F n − 2 F n − 1 ] [ 0 1 1 1 ] \begin{bmatrix}F_{n - 1}&F_{n}\end{bmatrix} = \begin{bmatrix}F_{n - 2}&F_{n - 1}\end{bmatrix}\begin{bmatrix}0 &1\\1&1\end{bmatrix} [Fn−1​​Fn​​]=[Fn−2​​Fn−1​​][01​11​]

  综上我们可以得到：

   [ F n F n + 1 ] = [ 0 1 ] [ 0 1 1 1 ] n \begin{bmatrix}F_{n}&F_{n+1}\end{bmatrix} = \begin{bmatrix}0&1\end{bmatrix}\begin{bmatrix}0 &1\\1&1\end{bmatrix}^{_n} [Fn​​Fn+1​​]=[0​1​][01​11​]n​

  进一步得知，

   ( a i , j ) = [ 0 1 1 1 ] n (a_{i,j}) = \begin{bmatrix}0 &1\\1&1\end{bmatrix}^{_n} (ai,j​)=[01​11​]n​， F n = a 2 , 1 F_{n} = a_{2,1} Fn​=a2,1​

  利用快速幂的技巧，可以实现 O ( log ⁡ n ) O(\log n) O(logn) 意义下的斐波那契数计算。

import java.util.Scanner;

public class Main {

    public static void main(String[] args) { new Main().run(); }

    int MOD = 10007;

    void run() {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[][] P = Apow(n);
        System.out.println(P[1][0]);
    }

    int[][] A = {{0, 1}, {1, 1}};
    int[][] E = {{1, 0}, {0, 1}};

    int[][] Apow(int n) {
        if (n == 0) return E;
        if (n == 1) return A;
        int[][] AP = Apow(n >> 1);
        int[][] res = mul(AP, AP);
        if ((n & 1) == 1)
            res = mul(res, A);
        return res;
    }

    int[][] mul(int[][] A, int[][] B) {
        int[][] C = new int[2][2];
        for (int i = 0; i < 2; i++)
            for (int j = 0; j < 2; j++)
                for (int k = 0; k < 2; k++)
                    C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % MOD;
        return C;
    }
}

  快速倍增法：

  引用一下斐波那契数列的 附加性质 (費氏數列的性質整理)

  三、(性質 2)費氏數列中，第(m+n)項等於第 m 項乘上第(n-1)項後再加上第(m+1)項乘上第 n 項之和，即 f m + n = f m f n − 1 + f m + 1 f n ， m , n ≥ 1 f_{m+n}=f_{m}f_{n-1} + f_{m+1}f_{n}，m,n\ge1 fm+n​=fm​fn−1​+fm+1​fn​，m,n≥1  湾湾人高一捣鼓的东西，🐮🍺。

  不像我，连个高中都没考上。

  这里简单归纳一下，

   f N = f 1 f N − 2 + f 2 f N − 1 = f 1 f N − 2 + f 2 f N − 2 + f 2 f N − 3 = f 3 f N − 2 + f 2 f N − 3 = f 4 f N − 3 + f 3 f N − 4 ⋯ ⋯ = f m + 1 f n + f m f n − 1 \begin{array}{r l} f_{N}& = f_{1}f_{N-2} + f_{2}f_{N-1}\\ & = f_{1}f_{N-2} + f_{2}f_{N-2} + f_{2}f_{N-3}\\ & = f_{3}f_{N-2} + f_{2}f_{N-3}\\ & = f_{4}f_{N-3} + f_{3}f_{N-4}\\ &\cdots\cdots\\ & = f_{m+1}f_{n}+f_{m}f_{n-1}\\ \end{array} fN​​=f1​fN−2​+f2​fN−1​=f1​fN−2​+f2​fN−2​+f2​fN−3​=f3​fN−2​+f2​fN−3​=f4​fN−3​+f3​fN−4​⋯⋯=fm+1​fn​+fm​fn−1​​

  设 k = n k=n k=n、 m = k ∣ k + 1 m = k \mid k+1 m=k∣k+1 可以得到两个特殊的等式。

   F 2 k = F k ( 2 F k + 1 − F k ) F_{2k} = F_{k}(2F_{k+1} - F_{k}) F2k​=Fk​(2Fk+1​−Fk​)

   F 2 k + 1 = F k + 1 2 + F k 2 F_{2k+1} = F_{k+1}^{2} + F_{k}^{2} F2k+1​=Fk+12​+Fk2​

  通过这个公式，我们可以快速确定两个相邻的斐波那契数。

import java.util.Scanner;

public class Main {

    public static void main(String[] args) { new Main().run(); }

    int MOD = 10007;

    void run() {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        System.out.println(fib(n)[0]);
    }

    int[] fib(int n) {
        if (n == 0) return new int[]{0, 1};
        int[] fd2 = fib(n >> 1);
        int fib1 = fd2[0] * (2 * fd2[1] - fd2[0] + MOD);
        int fib2 = fd2[0] * fd2[0] + fd2[1] * fd2[1];
        if ((n & 1) == 1) return new int[]{fib2 % MOD, (fib1 + fib2) % MOD};
        else return new int[]{fib1 % MOD, fib2 % MOD};
    }
}
肖有量
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
蓝桥杯练习系统题目汇总
03-24
历年蓝桥杯比赛练习系统题目汇总，代码 C C++ Java Fibonacci数列  基础练习 闰年判断
如何开启刷题，蓝桥杯练习系统
m0_67118803的博客
02-17 4576
蓝桥杯刷题网站在这里
蓝桥杯练习系统（算法训练）ALGO-977 P0805大数乘法
m0_73801775的博客
03-11 781
当两个比较大的整数相乘时，可能会出现数据溢出的情形。为避免溢出，可以采用字符串的方法来实现两个大数之间的乘法。具体来说，首先以字符串的形式输入两个整数，每个整数的长度不会超过10位，然后把它们相乘的结果存储在另一个字符串当中（长度不会超过20位），最后把这个字符串打印出来。例如，假设用户输入为：62773417和12345678，则输出结果为：774980393241726.例如：计算12345678×9，显然是被乘数中的最低位8和乘数9相乘。由于计算乘法时，先计算低位，因此a[0]存储大数的低位。
蓝桥杯官网练习系统 基础练习 经典(java)
10-15
蓝桥杯官网练习系统 基础练习 经典(java)，本人通过搜集资料，整理出来的！
蓝桥杯练习系统-基础题全解C++
03-06
蓝桥杯练习系统-基础题全解C++
蓝桥杯练习系统题目汇总（含参考答案）
09-02
蓝桥杯练习系统题目汇总（含参考答案） pdf版本，代码可复制
“蓝桥杯”练习系统（基础篇）
GeekTony的博客
02-28 930
蓝桥杯训练系统基础篇题解
【算法练习】蓝桥杯日常练习系统（礼物、数的潜能、娜神平衡、粘木棍、车的放置、最大分解、Substrings、线性筛、乘积最大、递增三元组、倍数问题、结账问题、无聊的逗）
Mxeron的博客
03-15 1463
一、礼物（前缀和 + 二分答案） 对石子个数进行二分，然后去check当前石子数是否满足要求，一直逼近石子的最大值即可，关键在于要处理好前缀和的下标关系。例如，现在从 i 的位置开始划分，取k个石子，前面k个石子的重量 = preSum[i] - preSum[i - k]，后面k个石子的重量 = preSum[i + k] - preSum[i]。 另外就是用BufferReader加快读取速度。 import java.io.BufferedReader; import java.io.IOExcep
蓝桥杯 算法训练 素数之和 Java
syidtcoyttc的博客
10-24 117
public class 素数之和 {
“蓝桥杯”软件大赛入门训练4道题
weixin_33757609的博客
01-03 1204
问题描述 Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。 当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。 输入格式 输入包含一个整数n。 输出格式 输出一行，包含一个整数，表示Fn除以10007的余数。 说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要...
蓝桥杯练习系统 基础练习：BASIC-2 01字串
12-21
蓝桥杯练习系统 基础练习：BASIC-2 01字串 题目 题目信息 问题描述  对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是： 00000 00001 00010 00011 00100 请按从小到大的顺序输出这32种01串。 输入格式  本试题没有输入。 输出格式  输出32行，按从小到大的顺序每行一个长度为5的01串。 样例输出 00000 00001 00010 00011 思路 看见这个很明显就想到了递归，把这个想成一颗二叉树，中序遍历。可以保证先进入当前位为0的状态，并且其子状态 全部输出，再输出右树，右树恒比左树最后一个输出大1，归纳可证有
蓝桥杯练习系统基础练习30题java版参考程序（满分通过）
03-18
LQB练习系统基础练习30题java版参考程序（满分通过） FJ的字符串 Huffuman树 n2皇后问题 阶乘计算 回形取数 数列排序 芯片测.......
蓝桥杯练习题库-2基础练习之VIP题
03-24
蓝桥杯练习题库-2基础练习之VIP题基础练习 2n皇后问题
生日蜡烛（蓝桥杯）
比起日出，我更喜欢日落。我的意思是比起遇见你，我更喜欢与你终老
04-23 864
假设他开始过生日的年龄数是x，根据常识 x>=1且x<=100 x+(x+1)+(x+2)+…+(x+n)=236，n>=1且x+n<=100。某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。现在算起来，他一吹熄了236根蜡烛。请问，他从多少岁开始过生日party的？
2024年第十五届蓝桥杯江苏省赛回顾
最新发布
wrj1472583690的博客
04-29 719
希望提升自己的小伙伴可以参照我往期的博客，相信下一个是你。
[iOS]使用CocoaPods发布公开库
Gamin
04-27 1186
在 podspec 文件中使用标签，通常意味着你指定了一个稳定的、用于发布的版本。这是最常见的用法，因为这确保了项目的依赖是固定且可预测的。这通常用于开发阶段，当你想要使用最新的尚未发布的代码时。标签是静态的，指向特定的提交，不会随着更多的提交而变化。选择库名时，尽量选择具有描述性并且独特的名字，这不仅可以避免命名冲突，还可以帮助用户更好地理解库的用途和功能。文件，在编辑器中进行修改，以符合你的库的具体情况。将你的项目推送到一个 Git 仓库（如 GitHub），确保为发布的版本创建相应的分支或者标签。
打不动的蓝桥杯
成长之路
04-13 3588
今天的蓝桥杯打得很烂，8题写了4题，100分可能有20来分吧。我写了的题好像都很简单，没什么竞争力。又觉得我知道的东西不止这么点，没能发挥。
完全日期（蓝桥杯）
m0_73841621的博客
04-21 634
例如：2021 年 6 月 5 日的各位数字之和为 2 + 0 + 2 + 1 + 6 + 5 = 162+0+2+1+6+5=16，而 16 是一个完全平方数，它是 44 的平方。例如：2021年 6 月 23 日的各位数字之和为 2 + 0 + 2 + 1 + 6 + 2 + 3 = 162+0+2+1+6+2+3=16，是一个完全平方数。请问，从 2001 年 1月 1日到 2021年 12 月 31日中，一共有多少个完全日期？如果一个日期中年月日的各位数字之和是完全平方数，则称为一个完全日期。
蓝桥杯练习系统习题解答大全(c/c++
06-26
蓝桥杯练习系统习题解答大全是一个收录了蓝桥杯竞赛练习...总之，蓝桥杯练习系统习题解答大全是一个非常实用的学习资源，无论是初学者还是有一定编程基础的程序员都可以在这个网站上找到适合自己的题目进行练习和学习。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值