【leetcode刷题第43天】2016.增量元素之间的最大差值、1361.验证二叉树、1601.最多可达成的换楼请求的数目

第四十三天

2016 增量元素之间的最大差值

给你一个下标从 0 开始的整数数组 nums ，该数组的大小为 n ，请你计算nums[j] - nums[i] 能求得的 最大差值 ，其中 0 <= i < j < n 且 nums[i] < nums[j] 。

返回 最大差值 。如果不存在满足要求的 i 和 j ，返回 -1 。

示例 1：

输入：nums = [7,1,5,4]
输出：4
解释：
最大差值出现在 i = 1 且 j = 2 时，nums[j] - nums[i] = 5 - 1 = 4 。
注意，尽管 i = 1 且 j = 0 时 ，nums[j] - nums[i] = 7 - 1 = 6 > 4 ，但 i > j 不满足题面要求，所以 6 不是有效的答案。

方法

记录前缀最小值，然后遍历每一个元素，得到差值，取最大的差值即可。

class Solution {
    public int maximumDifference(int[] nums) {
        int res = -1;
        int[] min = new int[nums.length + 1];
        min[0] = Integer.MAX_VALUE;
        for (int i = 1; i <= nums.length; ++i) {
            if (nums[i - 1] < min[i - 1]) min[i] = nums[i - 1];
            else min[i] = min[i - 1];
            res = Math.max(res, nums[i - 1] - min[i - 1] > 0 ? nums[i - 1] - min[i - 1] : -1);
        }
        return res;
    }
}

1361 验证二叉树

二叉树上有 n 个节点，按从 0 到 n - 1 编号，其中节点 i 的两个子节点分别是 leftChild[i] 和 rightChild[i]。

只有 所有 节点能够形成且 只 形成 一颗 有效的二叉树时，返回 true；否则返回 false。

如果节点 i 没有左子节点，那么 leftChild[i] 就等于 -1。右子节点也符合该规则。

注意：节点没有值，本问题中仅仅使用节点编号。

方法

首先我们遍历一遍所有节点的左右孩子，找出其中最顶层的父节点，最顶层的父节点满足：它不是任何一个节点的子节点。因此对于最顶层的父节点，当我们遍历所有节点的左右孩子的时候，将这些孩子标记为已访问，最后我们检验一遍所有已经被访问的节点的数量是否为n-1，同时找出那个唯一没有被标记的节点就是最顶层的父节点。

当我们找到了这个父节点之后，我们使用广度有限搜索遍历所有节点的孩子节点，同时将遍历过的节点标记为已访问，最后我们校验所有的节点是否都被访问过，并且只被访问了一次，如果存在没有被访问的节点或者存在一个节点被访问了一次以上，那么就返回false。否则返回true。

class Solution {
    public boolean validateBinaryTreeNodes(int n, int[] leftChild, int[] rightChild) {
        boolean[] isVisited = new boolean[n];
        Queue<Integer> queue =new LinkedList<>();
        int cnt = 0;
        for (int i = 0; i < n; ++i) {
            if (leftChild[i] != -1) {
                if (isVisited[leftChild[i]]) return false;
                isVisited[leftChild[i]] = true;
                cnt++;
            }
            if (rightChild[i] != -1) {
                if (isVisited[rightChild[i]]) return false;
                isVisited[rightChild[i]] = true;
                cnt++;
            }
        }
        if (cnt != n - 1) return false;
        for (int i = 0; i < n; ++i) {
            if (isVisited[i])  isVisited[i] = false;
            else {
                queue.offer(i);
                isVisited[i] = true;
            }
        }

        while (!queue.isEmpty()) {
            int index = queue.poll();
            if (leftChild[index] != -1) {
                if (isVisited[leftChild[index]]) return false;
                queue.offer(leftChild[index]);
                isVisited[leftChild[index]] = true;
            }
            if (rightChild[index] != -1) {
                if (isVisited[rightChild[index]]) return false;
                queue.offer(rightChild[index]);
                isVisited[rightChild[index]] = true;
            }
        }
        for (boolean flag : isVisited) if (!flag) return false;
        return true;
    }
}

1601 最多可达成的换楼请求数目

我们有 n 栋楼，编号从 0 到 n - 1 。每栋楼有若干员工。由于现在是换楼的季节，部分员工想要换一栋楼居住。

给你一个数组 requests ，其中 requests[i] = [fromi, toi] ，表示一个员工请求从编号为 fromi 的楼搬到编号为 toi 的楼。

一开始 所有楼都是满的，所以从请求列表中选出的若干个请求是可行的需要满足 每栋楼员工净变化为 0 。意思是每栋楼 离开 的员工数目 等于 该楼搬入 的员工数数目。比方说 n = 3 且两个员工要离开楼 0 ，一个员工要离开楼 1 ，一个员工要离开楼 2 ，如果该请求列表可行，应该要有两个员工搬入楼 0 ，一个员工搬入楼 1 ，一个员工搬入楼 2 。

请你从原请求列表中选出若干个请求，使得它们是一个可行的请求列表，并返回所有可行列表中最大请求数目。

输入：n = 5, requests = [[0,1],[1,0],[0,1],[1,2],[2,0],[3,4]]
输出：5

方法

我们使用二进制数来枚举所有可能满足的换楼请求，然后检查这些换楼请求是否合法。

由于换楼请求的数量最多只有16个，我们可以使用一个32位整数的后16位来完成所有情况的枚举。

对于检查函数，出楼会让人数--，进楼会让人数++，保证每一栋楼的净变化人数为0即可。

class Solution {
    public int maximumRequests(int n, int[][] requests) {
        int res = 0;
        for (int choose = (1 << requests.length) - 1; choose > 0; --choose) {
            if (check(n, choose, requests)) res = Math.max(res, getLength(choose));
        }
        return res;
    }

    public boolean check(int n,int choose, int[][] requests) {
        int[] status = new int[n];
        int index = 0;
        while (choose > 0) {
            if ((choose & 1) == 1) {
                status[requests[index][0]]--;
                status[requests[index][1]]++;
            }
            index++;
            choose >>= 1;
        }
        for (int i : status) if (i != 0) return false;
        return true;
    }

    public int getLength(int check){
        int res = 0;
        while (check > 0) { if ((check & 1) == 1) res++; check >>= 1;}
        return res;
    }
}