第13届蓝桥杯Java A组做题记录

A题 裁刀纸

package JAVA13蓝桥杯组;
// 剪裁的过程可以看作是一个二叉树树
// 因为无论多大的纸裁一次会出现两张纸所以裁几次则有几个n2且度为1的点不存在
// 则有n0 = n2 + 1;
// 答案为n2 + 4 = n0 + 3
public class 裁纸刀 {
   public static void main(String[] args) {
	   System.out.print(443);
	
	}
}

B题 寻找整数

package JAVA13蓝桥杯组;
// 两个数a,b合并过程a每次加a和a之前合并所有数的最小公倍数c
// 如果a % b = d,则合并下一个
// 函数merge（a,b,c,d) 返回 a的数，c在循环中维护
// b = i, d = A[i] a = merge（a,b,c,d) c = c * b/gcd(c,b)
public class 寻找整数 {
	static long gcd(long a,long b)
	{
		if(b == 0) return a;
		else return gcd(b,a % b);
	}
	static long merge(long a,long b,long c,long d)
	{
		for(;a % b!= d ;a +=c);
		return a;
	}
	public static void main(String[] args)
	{
		long[] A = {0,0,1,2,1,4,5,4,1,2,9,0,5,10,
				11,14,9,0,11,18,9,11,11,15,17,9,
				23,20,25,16,29,27,25,11,17,4,29,22,
				37,23,9,1,11,11,33,29,15,5,41,46
		};
		long a = 1,b = 3,c = 2;
		for(;b < 50; b++)
		{
			a = merge(a, b, c, A[(int)b]);
			c = c /gcd(c, b) * b;
		}
		System.out.print(a);
	}
}

试题C 求和

package JAVA13蓝桥杯组;
import java.util.Scanner;
//前缀和
public class 求和{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N;
        long sum = 0, S = 0; // sum储存数组中所有元素和，S储存最终结果。
        N = sc.nextInt();
        int[] arr = new int[N];
        for (int i = 0; i < N; i++) {
            arr[i] = sc.nextInt();
            sum += arr[i];
        }
        for (int i = 0; i < N; i++) {
            S += arr[i] * (sum - arr[i]);
            sum -= arr[i];
        }
        System.out.println(S);
        sc.close();
    }
}

试题D GCD

package JAVA13蓝桥杯组;
//令c = gcd(a + k,b + k)
// k1 * c = a + k;k2 * c = b + k
//(a - b) = c(k1 - k2)
// 当k1 - k2 为1时c最大
// 现在求 a + k = 0(mod c)
// k = - a （mod c)
// k(min) = c - a %c
import java.util.Scanner;

public class gcd {
 public static void main(String[] args) {
     Scanner scan = new Scanner(System.in);
     long a = scan.nextLong();
     long b = scan.nextLong();
     long c = Math.abs(a-b); //先通过差值求最大公约数
     System.out.print(c - a % c);//通过最大公约数求出k
     scan.close();
 }
}

试题E 蜂巢!

试题F 全排列的价值

package JAVA13蓝桥杯组;
//找规律题，找规律题就写点数找找关系
//1 2 3 4 ：6    4 3 2 1 ：0
//1 3 2 4 ：5    4 2 3 1 : 1
// 有n！/2对相加和为n(n - 1)/2 (其实就是逆序对）
//n(n - 1)/4 * n!;
import java.util.*;

public class 全排列价值 {
	public static void main(String[] args)
	{
		Scanner scanner = new Scanner(System.in);
		long  n = scanner.nextLong(),  mod = 998244353;
		long res = n * (n - 1) / 2 % mod;
		for(long i = 3;i <= n;i ++)
			res = res * i % mod;
		
		System.out.print(res);
	}
}

试题G 青蛙过河

package JAVA13蓝桥杯组;
//这道题可以看出二分，将求最值问题化为判定问题
//因为我们可以枚举跳跃能力m检验是否可以跳过去2x次
//二分常常伴随着贪心

//任意长为y区间的和大于等于2 * x，青蛙才能跳过去
//因为当某个区间和k小于2 * x青蛙不可能跳过去，因为任意长为y区间都会被跳2 * x次
//，如果k < 2*x 当跳k+1次到这个区间时已经没落脚点了
//如果任意区间大于等于2 * x青蛙可以跳过去
// 每次跳只需青蛙选择在[1,y]中选个i，满足i +y 有石头即可
// 为啥一定存在这个i，反证法如果不存在这个y则[y + 1,2 *y]高度和为0
// 重复2 * x次这种策略，即可完成
import java.util.Scanner;

public class 青蛙过河 {
    static final int N = 100010;
    static int[] s = new int[N];
    static long n, x;

    static boolean check(int m) {
        for (int i = 1; i + m <= n; i++) {
            if (s[i + m - 1] - s[i - 1] < 2 * x)
                return false;
        }
        return true;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextLong();
        x = scanner.nextLong();
        for (int i = 1; i < n; i++) {
            int a = scanner.nextInt();
            s[i] = s[i - 1] + a;
        }
        int l = 1, r = (int) n;
        while (l < r) {
            int mid = (l + r) >> 1;
            if (check(mid))
                r = mid;
            else
                l = mid + 1;
        }
        System.out.println(l);
    }
}

试题 H 因数平方和

package JAVA13蓝桥杯组;
import java.util.*;
//1~n中数有 n/i个因子是i的倍数，因此因i的贡献是n/i次
//g（n)+= (n/i)*i*i;
// 然后n /i 是一个特殊的块状分布：同样的值聚集在连续的块中
//枚举每个块计算即可，如何枚举每个块？
//在满足n / j = n /i， j = max（ n/k ） 
// j = n/（n/i）
//注意可能会爆long
public class 因数平方和 {
	static long mod = (long) 1e9 + 7;
	
	static long qmi(long a)
	{
		long k = mod - 2, res = 1;
		while(k > 0)
		{
			if(k % 2 == 1) res = res * a %mod;
			a = a * a %mod;
			k >>= 1;
		}
		return res;
	}
	
	public static long square_sum(long i){
        return ((i * (i + 1) % mod) % mod * ((2 * i + 1) % mod) % mod * qmi(6) % mod);
    }
	
	public static void main(String[] args)
	{
		Scanner scanner = new Scanner(System.in);
		long n = scanner.nextLong(),ans = 0L;
		for(long l = 1L,r;l <= n;l = r + 1)
		{
			r = n/ (n/ l);
			ans +=(square_sum(r) - square_sum(l - 1) + mod) * (n / l) %mod;
		}
		System.out.print(ans % mod);
		scanner.close();
		
	}
}

试题I 最佳清零方案

package JAVA13蓝桥杯组;
//
import java.util.Scanner;

public class 最佳清零方案 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int K = scanner.nextInt();
        long[] A = new long[n + 2];
        for (int i = 0; i < n; i++) {
            A[i] = scanner.nextLong();
        }

        long sum = 0;
        for (int i = 0; i <= n - K; i++) {
            boolean flag = false;
            for (int j = i; j < i + K; j++) {
                if (A[j] == 0) {
                    flag = true;
                    break;
                }
            }
            if (!flag) {
                long min1 = Long.MAX_VALUE;
                for (int j = i; j < i + K; j++) {
                    min1 = Math.min(min1, A[j]);
                }
                if (min1 > 0) {
                    for (int j = i; j < i + K; j++) {
                        A[j] -= min1;
                    }
                    sum += min1;
                }
            }
        }
        for (int i = 0; i < n; i++) {
            if (A[i] > 0) {
                sum += A[i];
            }
        }
        System.out.println(sum);
    }
}