LeetCode Weekly Contest 198

5464. 换酒问题

题目难度Easy
小区便利店正在促销，用 numExchange 个空酒瓶可以兑换一瓶新酒。你购入了 numBottles 瓶酒。

如果喝掉了酒瓶中的酒，那么酒瓶就会变成空的。

请你计算 最多 能喝到多少瓶酒。

示例 1：

输入：numBottles = 9, numExchange = 3
输出：13
解释：你可以用 3 个空酒瓶兑换 1 瓶酒。
所以最多能喝到 9 + 3 + 1 = 13 瓶酒。
示例 2：

输入：numBottles = 15, numExchange = 4
输出：19
解释：你可以用 4 个空酒瓶兑换 1 瓶酒。
所以最多能喝到 15 + 3 + 1 = 19 瓶酒。
示例 3：

输入：numBottles = 5, numExchange = 5
输出：6
示例 4：

输入：numBottles = 2, numExchange = 3
输出：2

提示：

1 <= numBottles <= 100
2 <= numExchange <= 100

思路

每次维护更新有酒的瓶子数量和没有酒的瓶子的数量两个变量，模拟换酒过程

代码

class Solution {
    public int numWaterBottles(int numBottles, int numExchange) {
        int ans = 0, numFull = numBottles, numEmpty = 0;
        while (numFull > 0) {
            ans += numFull;
            int total = numFull + numEmpty;
            numFull = total / numExchange;
            numEmpty = total % numExchange;
        }
        return ans;
    }
}

5465. 子树中标签相同的节点数

题目难度Medium
给你一棵树（即，一个连通的无环无向图），这棵树由编号从 0 到 n - 1 的 n 个节点组成，且恰好有 n - 1 条 edges 。树的根节点为节点 0 ，树上的每一个节点都有一个标签，也就是字符串 labels 中的一个小写字符（编号为 i 的 节点的标签就是 labels[i] ）

边数组 edges 以 edges[i] = [ai, bi] 的形式给出，该格式表示节点 ai 和 bi 之间存在一条边。

返回一个大小为 n 的数组，其中 ans[i] 表示第 i 个节点的子树中与节点 i 标签相同的节点数。

树 T 中的子树是由 T 中的某个节点及其所有后代节点组成的树。

示例 1：

输入：n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], labels = “abaedcd”
输出：[2,1,1,1,1,1,1]
解释：节点 0 的标签为 ‘a’ ，以 ‘a’ 为根节点的子树中，节点 2 的标签也是 ‘a’ ，因此答案为 2 。注意树中的每个节点都是这棵子树的一部分。
节点 1 的标签为 ‘b’ ，节点 1 的子树包含节点 1、4 和 5，但是节点 4、5 的标签与节点 1 不同，故而答案为 1（即，该节点本身）。
示例 2：

输入：n = 4, edges = [[0,1],[1,2],[0,3]], labels = “bbbb”
输出：[4,2,1,1]
解释：节点 2 的子树中只有节点 2 ，所以答案为 1 。
节点 3 的子树中只有节点 3 ，所以答案为 1 。
节点 1 的子树中包含节点 1 和 2 ，标签都是 ‘b’ ，因此答案为 2 。
节点 0 的子树中包含节点 0、1、2 和 3，标签都是 ‘b’，因此答案为 4 。
示例 3：

输入：n = 5, edges = [[0,1],[0,2],[1,3],[0,4]], labels = “aabab”
输出：[3,2,1,1,1]
示例 4：

输入：n = 6, edges = [[0,1],[0,2],[1,3],[3,4],[4,5]], labels = “cbabaa”
输出：[1,2,1,1,2,1]
示例 5：

输入：n = 7, edges = [[0,1],[1,2],[2,3],[3,4],[4,5],[5,6]], labels = “aaabaaa”
输出：[6,5,4,1,3,2,1]

提示：

1 <= n <= 10^5
edges.length == n - 1
edges[i].length == 2
0 <= ai, bi < n
ai != bi
labels.length == n
labels 仅由小写英文字母组成

思路

DFS. 自底向上计算每个子树包含的各个字符的个数

代码

class Solution:
    def dfs(self, root, adj, labels, ans, vis):
        vis[root] = True
        cntDict = dict()
        for child in adj[root]:
            if not vis[child]:
                tmpDict = self.dfs(child, adj, labels, ans, vis)
                for k, v in tmpDict.items():
                    cntDict[k] = cntDict.setdefault(k, 0) + v
        ans[root] = cntDict.setdefault(labels[root], 0) + 1
        cntDict[labels[root]] = ans[root]
        return cntDict
    
    def countSubTrees(self, n: int, edges: List[List[int]], labels: str) -> List[int]:
        adj = [list() for _ in range(n)]
        vis = [False for _ in range(n)]
        for edge in edges:
            adj[edge[0]].append(edge[1])
            adj[edge[1]].append(edge[0])
        ans = [0 for _ in range(n)]
        self.dfs(0, adj, labels, ans, vis)
        return ans

5466. 最多的不重叠子字符串

题目难度Medium
给你一个只包含小写字母的字符串 s ，你需要找到 s 中最多数目的非空子字符串，满足如下条件：

1. 这些字符串之间互不重叠，也就是说对于任意两个子字符串 s[i..j] 和 s[k..l] ，要么 j < k 要么 i > l 。
2. 如果一个子字符串包含字符 c ，那么 s 中所有 c 字符都应该在这个子字符串中。

请你找到满足上述条件的最多子字符串数目。如果有多个解法有相同的子字符串数目，请返回这些子字符串总长度最小的一个解。可以证明最小总长度解是唯一的。

请注意，你可以以 任意 顺序返回最优解的子字符串。

示例 1：

输入：s = “adefaddaccc”
输出：[“e”,“f”,“ccc”]
解释：下面为所有满足第二个条件的子字符串：
[
“adefaddaccc”
“adefadda”,
“ef”,
“e”,
“f”,
“ccc”,
]
如果我们选择第一个字符串，那么我们无法再选择其他任何字符串，所以答案为 1 。如果我们选择 “adefadda” ，剩下子字符串中我们只可以选择 “ccc” ，它是唯一不重叠的子字符串，所以答案为 2 。同时我们可以发现，选择 “ef” 不是最优的，因为它可以被拆分成 2 个子字符串。所以最优解是选择 [“e”,“f”,“ccc”] ，答案为 3 。不存在别的相同数目子字符串解。
示例 2：

输入：s = “abbaccd”
输出：[“d”,“bb”,“cc”]
解释：注意到解 [“d”,“abba”,“cc”] 答案也为 3 ，但它不是最优解，因为它的总长度更长。

提示：

1 <= s.length <= 10^5
s 只包含小写英文字母。

思路

核心思想是求所有满足条件2的最小区间，再计算这些区间的最大不相交个数

1. 计算每个字符c出现的最左位置lc和最右位置rc
2. 对于每个字符c，初始化R = rc，遍历[lc, R]之间的字符x，如果x的最左位置lx小于lc，说明该区间在计算字符x对应区间的时候会被计算，此处不必计算，舍去；如果x的最右位置rx大于rc，则令R = rx. 将所有未被舍去的区间放入一个列表中
3. 将列表按区间按区间右端升序排列，按照贪心的原则每次取列表里后方第一个与上一次取的区间不想交的区间即可得到最大不相交区间

代码

class Solution {
    class Interval implements Comparable<Interval> {
        public int left, right;
        
        public Interval(int _left, int _right) {
            left = _left;
            right = _right;
        }
        
        @Override
        public int compareTo(Interval other) {
            return right - other.right;
        }
    }
    
    public List<String> maxNumOfSubstrings(String s) {
        int n = s.length();
        int[] lefts = new int[26], rights = new int[26];
        Arrays.fill(lefts, -1);
        Arrays.fill(rights, -1);
        int i = 0, j = 0;
        for (char ch: s.toCharArray()) {
            int idx = ch - 'a';
            if (lefts[idx] == -1) {
                lefts[idx] = i;
                ++j;
            }
            rights[idx] = i;
            ++i;
        }
        List<Interval> itvl = new ArrayList<Interval>();
        for (i=0; i<26; ++i) {
            if (lefts[i] == -1) {
                continue;
            }
            boolean flag = true;
            int curRight = rights[i];
            for (j=lefts[i]; j<=curRight; ++j) {
                int idx = s.charAt(j) - 'a';
                if (idx == i) {
                    continue;
                }
                if (lefts[idx] < lefts[i]) {
                    flag = false;
                    break;
                }
                curRight = Math.max(curRight, rights[idx]);
            }
            if (flag) {
                itvl.add(new Interval(lefts[i], curRight));
            }
        }
        Collections.sort(itvl);
        List<String> ans = new ArrayList<String>();
        i = 0;
        int m = itvl.size();
        int curRight = itvl.get(0).right;
        ans.add(s.substring(itvl.get(0).left, itvl.get(0).right + 1));
        while (true) {
            for (j=i+1; j<m; ++j) {
                if (itvl.get(j).left > curRight) {
                    i = j;
                    curRight = itvl.get(i).right;
                    ans.add(s.substring(itvl.get(i).left, itvl.get(i).right + 1));
                    break;
                }
            }
            if (j == m) {
                break;
            }
        }
        return ans;
    }
}

5467. 找到最接近目标值的函数值

题目难度Hard

Winston 构造了一个如上所示的函数 func 。他有一个整数数组 arr 和一个整数 target ，他想找到让 |func(arr, l, r) - target| 最小的 l 和 r 。

请你返回 |func(arr, l, r) - target| 的最小值。

请注意， func 的输入参数 l 和 r 需要满足 0 <= l, r < arr.length 。

示例 1：

输入：arr = [9,12,3,7,15], target = 5
输出：2
解释：所有可能的 [l,r] 数对包括 [[0,0],[1,1],[2,2],[3,3],[4,4],[0,1],[1,2],[2,3],[3,4],[0,2],[1,3],[2,4],[0,3],[1,4],[0,4]]， Winston 得到的相应结果为 [9,12,3,7,15,8,0,3,7,0,0,3,0,0,0] 。最接近 5 的值是 7 和 3，所以最小差值为 2 。
示例 2：

输入：arr = [1000000,1000000,1000000], target = 1
输出：999999
解释：Winston 输入函数的所有可能 [l,r] 数对得到的函数值都为 1000000 ，所以最小差值为 999999 。
示例 3：

输入：arr = [1,2,4,8,16], target = 0
输出：0

提示：

1 <= arr.length <= 10^5
1 <= arr[i] <= 10^6
0 <= target <= 10^7

思路

令n = arr.length.
区间最值问题，且具有单调性（元素越与越多结果越小），考虑滑动窗口（每个元素至多入窗n次，出窗n次）。为了维护窗口内元素想与的结果，使用线段树（单次查询O(logn)）。总时间复杂度O(nlogn). 具体来说，将滑动窗口初始化为最左边元素，在循环过程中，如果target大于等于滑动窗口的值，则窗口向右侧扩展，否则窗口向左侧收缩。
注意线段树的tree数组的长度要开到原数组arr的长度的4倍。

代码

class Solution {
    class SegTree {
        int[] val;
        int[] tree;
        
        public SegTree(int[] arr) {
            int n = arr.length;
            val = Arrays.copyOf(arr, n);
            tree = new int[4*n];
            build(0, 0, n-1);
        }
        
        private void build(int root, int vl, int vr) {
            if (vl == vr) {
                tree[root] = val[vl];
                return;
            }
            int mid = (vl + vr) / 2;
            build(2*root + 1, vl, mid);
            build(2*root + 2, mid + 1, vr);
            tree[root] = tree[2*root+1] & tree[2*root+2];
        }
        
        public int query(int root, int vl, int vr, int tl, int tr) {
            if (tl >= vl && tr <= vr) {
                return tree[root];
            }
            int mid = (tl + tr) / 2;
            if (mid >= vr) {
                return query(2*root+1, vl, vr, tl, mid);
            }
            if (mid < vl) {
                return query(2*root+2, vl, vr, mid+1, tr);
            }
            return query(2*root+1, vl, vr, tl, mid) & query(2*root+2, vl, vr, mid+1, tr);
        }
    }
    
    public int closestToTarget(int[] arr, int target) {
        int left = 0, right = 0, n = arr.length, ans = Integer.MAX_VALUE;
        SegTree segTree = new SegTree(arr);
        while (right < n) {
            int val = segTree.query(0, left, right, 0, n-1);
            if (val >= target) {
                ++right;
            } else {
                right = Math.max(++left, right);
            }
            ans = Math.min(ans, Math.abs(target - val));
        }
        return ans;
    }
}