2019 第十届蓝桥杯大赛软件类省赛 Java A组 题解

2019 第十届蓝桥杯大赛软件类省赛 Java A组

试题A

题解

​ 题目最后一句贴心的提示选手应该使用 long (C/C++ 应该使用 long long)。

​ 本题思路很直白，两重循环。外层循环 1 到 2019，内层循环检验是否含有 2、0、1、9 这四个数字。

​ 赛场上还可以将数字转换为字符串，利用 String.contains() 快速写出代码，虽然时间复杂没有改变，但应付填空题足矣。

代码

public static void questionA() {
    long sum = 0;
    for (int i = 1; i <= 2019; i++) {
        String int2str = String.valueOf(i);
        if (int2str.contains("2") || int2str.contains("0") || int2str.contains("1") || int2str.contains("9"))
            sum += i * i;
    }
	System.out.println(sum);
}

答案

2658417853

试题B

题解

​ 递推数列，从第四项开始，每项都是前三项的和。

​ 易得到递推式 (a_n=a_{n-1}+a_{n-2}+a_{n-3})

代码

public static void questionB() {
    int a, b, c, d;
    a = b = c = d = 1;

    for (int i = 4; i <= 20190324; i++) {
        d = (a + b + c) % 10000;
        a = b;
        b = c;
        c = d;
    }

    System.out.println(d);
}

答案

4659

试题C

题解

​ 本题使用广度优先搜索即可。

代码

private static void questionC() throws IOException {
    int n = 30;
    int m = 50;

    FileReader fr = new FileReader(new File("maze.txt"));
    char[][] board = new char[n][m];
    for (int i = 0; i < board.length; i++) {
        fr.read(board[i]);
        // 读取换行符和回车，避免读入到 board 中
        fr.read(); fr.read();
    }

    Queue<Node> queue = new LinkedList<>();
    boolean[][] visited = new boolean[n][m];
    queue.add(new Node(0, 0));
    visited[0][0] = true;

    int[][] way = new int[n][m];	// 记录到达 (i, j) 的方式
    int[][] delta = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    char[] cc = {'D', 'U', 'R', 'L'};
    while (!queue.isEmpty()) {
        Node cur = queue.poll();
        for (int i = 0; i < 4; i++) {
            int x = cur.x + delta[i][0];
            int y = cur.y + delta[i][1];
            if (x >= 0 && x < n && y >= 0 && y < m && board[x][y] != '1' && !visited[x][y]) {
                queue.add(new Node(x, y));
                way[x][y] = i;
                visited[x][y] = true;
            }
        }
    }

    int x = n - 1;
    int y = m - 1;
    StringBuilder sb = new StringBuilder();
    while (x != 0 || y != 0) {
        int i = way[x][y];
        sb.append(cc[i]);
        x -= delta[i][0];
        y -= delta[i][1];
    }

    System.out.println(sb.reverse());
}

static class Node {
    int x;
    int y;

    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

答案

DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRUUURRRRDDDDRDRRRRRURRRDRRDDDRRRRUURUUUUUUUULLLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR

试题D

题解

​ 假设每周的数字从周一到周日递增，每周周四的数字从第一周到第七周递增。

​ 则第四周周四的数字即为降雨量。

​ 又知下面表格中 15 个 ($) 上的数字必大于 (x) 。

​ 故 (x leq 49 - 15 = 34)

	周一	周二	周三	周四	周五	周六	周日
第一周
第二周
第三周
第四周				(x)	$	$	$
第五周				$	$	$	$
第六周				$	$	$	$
第七周				$	$	$	$

答案

34

试题F

题解

​ 完全二叉树除最后一层外，第 n 层的节点数为 (2^n)。

​ 我们完全可以利用这个特性，在输入数据时按层统计。

代码

public static void questionF() {
    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();

    int n = 1;
    int ans = 0;
    int depth = 1;
    long maxSum = Long.MIN_VALUE;
    while (N > 0) {
        long sum = 0;
        for (int i = 0; i < n && N > 0; i++) {
            sum += sc.nextInt();
            N--;
        }
        if (sum > maxSum) {
            maxSum = sum;
            ans = depth;
        }
        n <<= 1;
        depth++;
    }

    System.out.println(ans);
}

试题G

题解

​ 每一个店铺相互独立，可以存储每个店铺的订单时间，判断店铺是否在优先缓存中。

​ 需要注意 T 时刻的优先级判断。

​ 若 T 时刻，优先级 priority > 5，显然位于优先缓存中。

​ 若 T 时刻，优先级 priority == 5，且 T 时刻有一订单，则 T - 1时刻，优先级 priority 为 3，不在优先缓存中。

​ 若 T 时刻，优先级 priority == 4，且 T - 1、T - 2 时刻无订单，则在优先缓存中。

代码

public static void questionG() {
    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();
    int M = sc.nextInt();
    int T = sc.nextInt();
    ArrayList<Integer>[] store = new ArrayList[N + 1];
    while(M-- > 0) {
        int ts = sc.nextInt();
        int id = sc.nextInt();
        if (store[id] == null)
            store[id] = new ArrayList<Integer>();
        store[id].add(ts);
    }

    int ans = 0;
    for (int id = 1; id <= N; id++) {
        if (store[id] == null) continue;
        Collections.sort(store[id]);
        int lastTime = 0;
        int priority = 0;
        for (int order = 0; order < store[id].size(); order++) {
            int ts = store[id].get(order);
            if (ts - lastTime >= 1)
                priority -= ts - lastTime - 1;
            priority = Math.max(priority, 0);
            priority += 2;
            lastTime = ts;
        }
        priority -= T - lastTime;
        if (priority > 5 
                || (priority == 5 && lastTime != T) 
                || (priority == 4 && lastTime < T - 1)
            ) ans++;
    }

    System.out.println(ans);
}

试题H

题解

​ 本题可以使用使用并查集可以快速的得到需要修改的数值。

​ 首先对并查集初始化，然后依次读入数字 a。

​ 利用 visited 数组判断该数字 a 是否使用过：若使用过，则利用并查集寻找数字 a 的最大祖先，最大祖先加一即为需要修改的值。若未使用过，则不需要改动。

​ 由此可知，我们的并查集需要单向从小到大。要注意路径压缩。

代码

private static int[] parent = new int[100005];
private static boolean[] visited = new boolean[100005];

public static int find(int x) {
    if (x != parent[x])
        parent[x] = find(parent[x]); // 路径压缩
    return parent[x];
}

public static void questionH() {
    // 并查集初始化
    for (int i = 1; i < parent.length; i++)
        parent[i] = i;

    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();

    while (N-- > 0) {
        int a = sc.nextInt();
        a = visited[a] ? find(a) + 1 : a;
        visited[a] = true;
        if (a != 1 && visited[a - 1])
            parent[a - 1] = a;
        if (visited[a + 1])
            parent[a] = a + 1;
        System.out.print(a + " ");
    }
}

试题I

题解

​ 本题为状态压缩动态规划。

​ 因为数据量小，可以使用二进制中的一位表示某袋是否含有糖果。如某一袋糖果为[2 , 3, 5] 可用二进制表示为 0010 0110 （低位在右，高位在左）。

​ 首先定义 dp 数组的含义为 dp[j] 为状态 j 的糖果组合所需要的最小袋数。

​ base case 为 dp[0] = 0

​ 状态转移方程为 dp[j | candies[i]] = Math.min(dp[j | candies[i]], dp[j] + 1)。

代码

public static void questionI() {
    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();
    int M = sc.nextInt();
    int K = sc.nextInt();
    int[] candies = new int[N];
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < K; j++) {
            int candy = sc.nextInt();
            candies[i] |= 1 << candy - 1;
        }
    }

    int MAXN = 105;
    int[] dp = new int[1 << M];
    Arrays.fill(dp, MAXN);
    dp[0] = 0;

    for (int i = 0; i < N; i++) {
        for (int j = 0; j < 1 << M; j++) {
            if (dp[j] > MAXN)
                continue;
            dp[j | candies[i]] = Math.min(dp[j | candies[i]], dp[j] + 1);
        }
    }

    if (dp[(1 << M) - 1] < MAXN)
        System.out.println(dp[(1 << M) - 1]);
    else 
        System.out.println(-1);
}