小彩笔的刷题痛苦之旅 —— 将数组分成和相等的三个部分、二维网格迁移、找到小镇法官

• 1、题目：给你一个整数数组 A，只有可以将其划分为三个和相等的非空部分时才返回 true，否则返回 false。形式上，如果可以找出索引i+1 < j且满足A[0] + A[1] + ... + A[i] == A[i+1] + A[i+2] + ... + A[j-1] == A[j] + A[j-1] + ... + A[A.length - 1]就可以将数组三等分。否则返回 false。力扣（LeetCode）

示例 1：
输入：[0,2,1,-6,6,-7,9,1,2,0,1]
输出：true
解释：0 + 2 + 1 = -6 + 6 - 7 + 9 + 1 = 2 + 0 + 1
示例 2：
输入：[0,2,1,-6,6,7,9,-1,2,0,1]
输出：false
示例 3：
输入：[3,3,6,5,-2,2,5,1,-9,4]
输出：true
解释：3 + 3 = 6 = 5 - 2 + 2 + 5 + 1 - 9 + 4
提示：
3 <= A.length <= 50000
-10^4 <= A[i] <= 10^4

// 暴力破解法
    public static boolean canThreePartsEqualSum(int[] A){
        int sum = 0;
        for (int i = 0; i < A.length; i++) {
            sum += A[i];
        }
        if(sum % 3 == 0){
            int left = 0;
            int right = A.length - 1;
            int tmp = 0;
            int mid = sum / 3;
            while(left < right){
                // 先从左往右遍历找到和等于 sum/3的
                tmp += A[left++];
                if(tmp == mid){
                    tmp = 0;
                    break;
                }
            }
            while(left < right) {
                // 从右往左找到和等于 sum/3的
                tmp += A[right--];
                if(tmp == mid){
                    tmp = 0;
                    break;
                }
            }
            if(left == right){ //说明分了两个组，第三组是一个单独的数
                return A[left] == mid; // 判断这个数的值是否符合要求
            }

            return left < right && tmp == 0; //判断左组和右组是否各自和都为 sum/3
        }else{
            return  false;
        }
    }

• 2、给你一个 m 行 n 列的二维网格 grid 和一个整数 k。你需要将 grid 迁移 k 次。
  每次「迁移」操作将会引发下述活动：
  位于 grid[i][j] 的元素将会移动到 grid[i][j + 1]。
  位于 grid[i][n - 1] 的元素将会移动到 grid[i + 1][0]。
  位于 grid[m - 1][n - 1] 的元素将会移动到 grid[0][0]。
  请你返回 k 次迁移操作后最终得到的 二维网格。
  力扣（LeetCode）
  

class Solution{
    public List<List<Integer>> shiftGrid(int[][] grid, int k){
        // 总共转换了k次，外层循环
        while(; k > 0; k--){
            // 定义一个新的二维数组来保存转换后的数据
            int[][] newGrid = new int[grid.length][grid[0].length];
            // 第一步：位于 grid[i][j] 的元素将会移动到 grid[i][j + 1]
            //         即 将除了最后一列的元素以外的所有元素都向后移动一列
            for(int row = 0; row< grid.length; row++){
                for(int col = 0; col < grid[0].lengtg - 1; col++){
                     newGrid[row][col + 1] = grid[row][col];
                }
            }
            // 第二步：位于 grid[i][n - 1] 的元素将会移动到 grid[i + 1][0]
            //           大小为m×n的网格，下标是[0,m-1]
            //         即 将除了最后一行以外的最后一列全部移动到grid[i + 1][0]（行下标全部＋1）
            for(int row = 0; row < grid.length - 1; row++){
                newGrid[row + 1][col] = grid[row][grid[0].length - 1];
            }
            // 第三步：位于 grid[m - 1][n - 1] 的元素将会移动到 grid[0][0]。
            //         即，最后下角的一个元素移动
            newGrid[0][0] = grid[grid.length - 1][grid[0].length];
            // 每次转换一次，就替换一次
            grid = newGrid;
        }
        // 将返回的这个二维数组，按照规定的样式进行返回
        // 返回是一个嵌套的列表
        List<List<Integer>> result = new ArrayList<>();  //创建一个存放数组类型元素的数组
        for(int[] row : grid){
            List<Integer> listRow = new ArrayList<>(); // 为list中的每一个元素创建一个数组，形成一个二维数组
            result.add(listRow);   // 逐行将一维数组添加进去for (int v : row){     //
            listRow.add(v);    // 为每一行的一维数组填值
        }
        return result;
    }
}

• 3、找到小镇的法官
  在一个小镇里，按从1到N标记了N个人，传言称，这些人中有一个是小镇上的秘密法官。
  如果小镇的法官真的存在，那么：
  1、小镇的法官不相信任何人。
  2、每个人（出法官外）都相信小镇的法官。
  3、只有一个人同时满足属性1和属性2。
  给定数组trust，该数组由信任对``truse[i]= [a, b]组成，表示标记为a的人信任标记为b的人。
  如果小镇存在秘密法官并且可以确定他的身份，请返回该法官的标记。否则返回-1。
  力扣（LeetCode)

示例 1：
输入：N = 2, trust = [[1,2]]
输出：2
示例 2：
输入：N = 3, trust = [[1,3],[2,3]]
输出：3
示例 3：
输入：N = 3, trust = [[1,3],[2,3],[3,1]]
输出：-1
示例 4：
输入：N = 3, trust = [[1,2],[2,3]]
输出：-1
示例 5：
输入：N = 4, trust = [[1,3],[1,4],[2,3],[2,4],[4,3]]
输出：3

class Soultion{
   public int findJudge(int N, int[][] truest){
       int[] in = new int[N+1]; // 用来存放投票数的数组
       List<List<Interger>> list = new ArrayList<>(); //创建一个存放数组类型元素的数组
       for(int i = 0; i <= N; i++){
           list.add(new ArrayList<>()); // 为list中的每一个元素创建一个数组，形成一个二维数组
       }
       for(int[] p : trust) {
            in[p[0]]++;//法官不相信任何人
            list.get(p[1]).add(p[0]);//法官被所有人相信
        }
        for(int i = 1; i <= N; i++) {
            if(in[i] == 0 && list.get(i).size() == N - 1) {
                return i;
            }
        }
        return -1;
    }
}