LeetCode.[997]找到小镇的法官、[690]员工的重要性、[1260]二维网格迁移

997.在一个小镇里，按从 1 到 N 标记了 N 个人。传言称，这些人中有一个是小镇上的秘密法官。

如果小镇的法官真的存在，那么：

• 小镇的法官不相信任何人。
• 每个人（除了小镇法官外）都信任小镇的法官。
• 只有一个人同时满足属性 1 和属性 2 。

给定数组 trust，该数组由信任对 trust[i] = [a, b] 组成，表示标记为 a 的人信任标记为 b 的人。

如果小镇存在秘密法官并且可以确定他的身份，请返回该法官的标记。否则，返回 -1。

示例 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 Solution {
    //因为小镇的法官不相信任何人，每个人（除了小镇法官外）都信任小镇的法官。
    //所有，谁得到了N-1人的支持，谁就是法官
    public int findJudge(int N, int[][] trust) {
        //N个人，编号从1开始，所以数组大小N+1
        int[] score = new int[N+1];
        for (int[] tem:trust) {
            //遍历信任对数组，如果他给别人投票，也就是出现在0位置，票数-1
            score[tem[0]]--;
            //如果别人给他投票，也就是出现在1位置。票数+1
            score[tem[1]]++;
        }
        //默认法官不存在。找到票数为N-1的人，则他就是法官。没有的话法官就不存在
        int judge = -1;
        for(int i = 1;i < N + 1;i++){
            if (score[i] == N-1){
                judge = i;
                break;
            }
        }
        return judge;
    }
}

---

690.给定一个保存员工信息的数据结构，它包含了员工唯一的id，重要度 和 直系下属的id。

比如，员工1是员工2的领导，员工2是员工3的领导。他们相应的重要度为15, 10, 5。那么员工1的数据结构是[1, 15, [2]]，员工2的数据结构是[2, 10, [3]]，员工3的数据结构是[3, 5, []]。注意虽然员工3也是员工1的一个下属，但是由于并不是直系下属，因此没有体现在员工1的数据结构中。

现在输入一个公司的所有员工信息，以及单个员工id，返回这个员工和他所有下属的重要度之和。

示例 1:

输入: [[1, 5, [2, 3]], [2, 3, []], [3, 3, []]], 1
输出: 11
解释:员工1自身的重要度是5，他有两个直系下属2和3，而且2和3的重要度均为3。因此员工1的总重要度是 5 + 3 + 3 = 11。

/*
class Employee {
    public int id;
    public int importance;
    public List<Integer> subordinates;
};
*/


class Solution {
    public int getImportance(List<Employee> employees, int id) {
        Employee root = null;
        //找root节点
        for (Employee em:employees) {
            if(em.id  == id){
                root = em;
                break;
            }
        }
        int sumImportance = root.importance;
        //累加子树的importance
        for (int i:root.subordinates) {
            sumImportance += getImportance(employees, i);;
        }
        return sumImportance;
    }
}

---

class Solution {
    public List<List<Integer>> shiftGrid(int[][] grid, int k) {
        List<List<Integer>> result = new ArrayList<>();

        //迁移K次
        while(k > 0){
            //用新的二维数组存储迁移中的数据
            int[][] newgrid = new int[grid.length][grid[0].length];
            for(int row = 0; row < grid.length;row++){
                //除最后一列，将其他元素迁移
                for(int col = 0;col < grid[0].length - 1;col++){
                    //系统移动方式1
                    newgrid[row][col + 1] = grid[row][col];
                }
            }
            //除最后一列，最后一个元素，其他的元素迁移。 按移动方式2
            for (int row = 0; row < grid.length - 1; row++) {
                newgrid[row + 1][0] = grid[row][grid[0].length - 1];
            }
            //将最后一列最后一个元素迁移。 按移动方式3
            newgrid[0][0] = grid[grid.length - 1][grid[0].length - 1];
            k--;
            //原数组更新
            grid = newgrid;
        }
        //将二维数组拷贝到列表
        for (int[] row : grid) {
            List<Integer> listRow = new ArrayList<>();
            result.add(listRow);
            for (int data : row) {
                listRow.add(data);
            }
        }
        return result;
    }
}