蓝桥杯练习十四——3.18

1.二叉树的层次遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7] 输出：[[3],[9,20],[15,7]]

思路：参考了该博主的思路力扣

代码实现：

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> lis=new ArrayList<>();
        Queue<TreeNode> queue=new ArrayDeque<>();//Queue是队列，Deque是双端队列
        if(root!=null){//若根节点不为空，将root加入队列
            queue.add(root);//add向队列尾部添加元素
        }
        while(!queue.isEmpty()){
            List<Integer> rest=new ArrayList<>();
            int len=queue.size();
            for (int i = 0; i < len; i++) { 
            TreeNode node = queue.poll();//poll（）从队列头部删除元素
            rest.add(node.val);
            if (node.left != null) {
                queue.add(node.left);
            }
            if (node.right != null) {
                queue.add(node.right);
            }
        }
        lis.add(rest);
        }
        return lis;
    }
}

 运行结果：

 2.腐烂的橘子

在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：

• 值 0 代表空单元格；
• 值 1 代表新鲜橘子；
• 值 2 代表腐烂的橘子。

每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。

返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1 。

示例：

输入：grid = [[2,1,1],[1,1,0],[0,1,1]]
输出：4

思路：

二叉树广度优先遍历，这题看完解题后依旧不太懂，先粘一下其他博主的思路和算法。

一开始，我们找出所有腐烂的橘子，将它们放入队列，作为第 0 层的结点。
然后进行 BFS 遍历，每个结点的相邻结点可能是上、下、左、右四个方向的结点，注意判断结点位于网格边界的特殊情况。
由于可能存在无法被污染的橘子，我们需要记录新鲜橘子的数量。在 BFS 中，每遍历到一个橘子（污染了一个橘子），就将新鲜橘子的数量减一。如果 BFS 结束后这个数量仍未减为零，说明存在无法被污染的橘子。

代码：

class Solution {
    public int orangesRotting(int[][] grid) {


    // 边界 长宽
    int M = grid.length;
    int N = grid[0].length;
    Queue<int[]> queue = new LinkedList<>();

    // count 表示新鲜橘子的数量
    int count = 0; 

    // 遍历二维数组 找出所有的新鲜橘子和腐烂的橘子
    for (int r = 0; r < M; r++) {
        for (int c = 0; c < N; c++) {
            // 新鲜橘子计数
            if (grid[r][c] == 1) {
                count++;
                // 腐烂的橘子就放进队列
            } else if (grid[r][c] == 2) {
                // 缓存腐烂橘子的坐标
                queue.add(new int[]{r, c});
            }
        }
    }

    // round 表示腐烂的轮数，或者分钟数
    int round = 0; 

    // 如果有新鲜橘子 并且 队列不为空
    // 直到上下左右都触及边界 或者 被感染的橘子已经遍历完
    while (count > 0 && !queue.isEmpty()) {

        // BFS 层级 + 1
        round++;

        // 拿到当前层级的腐烂橘子数量， 因为每个层级会更新队列
        int n = queue.size();

        // 遍历当前层级的队列
        for (int i = 0; i < n; i++) {

            // 踢出队列（拿出一个腐烂的橘子）
            int[] orange = queue.poll();

            // 恢复橘子坐标
            int r = orange[0];
            int c = orange[1];

            // ↑ 上邻点 判断是否边界 并且 上方是否是健康的橘子
            if (r-1 >= 0 && grid[r-1][c] == 1) {
                // 感染它 
                grid[r-1][c] = 2;
                // 好橘子 -1 
                count--;
                // 把被感染的橘子放进队列 并缓存
                queue.add(new int[]{r-1, c});
            }
            // ↓ 下邻点 同上
            if (r+1 < M && grid[r+1][c] == 1) {
                grid[r+1][c] = 2;
                count--;
                queue.add(new int[]{r+1, c});
            }
            // ← 左邻点 同上
            if (c-1 >= 0 && grid[r][c-1] == 1) {
                grid[r][c-1] = 2;
                count--;
                queue.add(new int[]{r, c-1});
            }
            // → 右邻点 同上
            if (c+1 < N && grid[r][c+1] == 1) {
                grid[r][c+1] = 2;
                count--;
                queue.add(new int[]{r, c+1});
            }
        }
    }

    // 如果此时还有健康的橘子
    // 返回 -1
    // 否则 返回层级
    if (count > 0) {
        return -1;
    } else {
        return round;
    }
    }
}

3.分数

11​+21​+41​+81​+⋯

每项是前一项的一半，如果一共有 2020 项,求这个和是多少，结果用分数表示出来。

类似：3223​，当然，这只是加了前 22 项而已。分子分母要求互质。

代码：

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int sum=1;
        int temp=1;//分子
        for(int i=1;i<20;i++){
          temp*=2;//因为要通分所以分子分母都要变成二倍才能相加
          sum+=temp;
        }
        int x=(int)Math.pow(2,19);//分母大小
        System.out.println(sum+"/"+x);
        scan.close();
    }
}

结果：