{"file_path": "LeetCode/1-10/1. 两数之和（简单）.md", "url_title": "1. 两数之和", "url": "https://leetcode-cn.com/problems/two-sum/solution/po-su-jie-fa-ha-xi-biao-jie-fa-by-ac_oie-yf7o/", "difficulty": "简单", "tags": ["哈希表", "模拟"], "question": "给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出「和为目标值」的那「两个」整数,并返回它们的数组下标。\n\n你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。\n\n你可以按任意顺序返回答案。\n\n示例 1:\n```\n输入:nums = [2,7,11,15], target = 9\n\n输出:[0,1]\n\n解释:因为 nums[0] + nums[1] == 9 ,返回 [0, 1] 。\n```\n\n示例 2:\n```\n输入:nums = [3,2,4], target = 6\n\n输出:[1,2]\n```\n\n示例 3:\n```\n输入:nums = [3,3], target = 6\n\n输出:[0,1]\n```\n\n提示:\n* $2 <= nums.length <= 10^3$\n* -$10^9 <= nums[i] <= 10^9$\n* -$10^9 <= target <= 10^9$\n* 只会存在一个有效答案", "solution": "### 朴素解法\n\n由于我们每次要从数组中找两个数。\n\n因此一个很简单的思路是:使用两重循环枚举下标 $i$ 和 $j$ ,分别代表要找的两个数。\n\n然后判断 $nums[i] + nums[j] = target$ 是否成立。\n\n另外为了防止得到重复的解,我们需要在第一层循环中让 $i$ 从 $0$ 开始,到 $n - 2$ 结束(确保能取到下一位数作为 j );在第二层循环中让 $j$ 从 $i + 1$ 开始,到 $n - 1$ 结束。\n\n代码:\n\n```Java\nclass Solution {\n    public int[] twoSum(int[] nums, int t) {\n        int n = nums.length;\n        for (int i = 0; i < n - 1; i++) {\n            for (int j = i + 1; j < n; j++) {\n                if (t == nums[i] + nums[j]) return new int[]{i,j};\n            }\n        }\n        return new int[]{};\n    }\n}\n```\n* 时间复杂度:两重循环,以复杂度是 $O(n^2)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 哈希表\n\n首先,任何优化的思路都不外乎「减少重复」。\n\n从朴素解法中可以知道,逻辑上我们是先定下来一个数,然后从数组中往后找另外一个值是否存在。但其实我们在找第二个数的过程中是重复扫描了数组多次。\n\n举个例子,对于 `nums = [2,3,8,4], target = 9` 的样例,我们先确定下来第一个数是 `2`,然后从后扫描到最后一个数,检查是否有 `7`。发现没有,再决策第一个数为 `3` 的情况,这时候我们应该利用前一次扫描的结果来帮助我们快速判断是否存在 `6`,而不是再重新进行一次扫描。\n\n这是直观的优化思路,不难想到可以使用哈希表进行存储。以数值为 `key`,数值的下标为 `value`。\n\n当动手将想法转化为代码时,会发现如果先敲定第一个数,将后面的数加入哈希表,再进行下一位的遍历的时候,还需要将该数值从哈希表中进行删除。\n\n代码:\n```Java\nclass Solution {\n    public int[] twoSum(int[] nums, int t) {\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = 0; i < nums.length; i++) map.put(nums[i], i);\n        for (int i = 0; i < nums.length; i++) {\n            int a = nums[i], b = t - a;\n            if (map.get(a) == i) map.remove(a);\n            if (map.containsKey(b)) return new int[]{i, map.get(b)};\n        }\n        return new int[]{};\n    }\n}\n```\n最坏情况下,每个数会对应一次哈希表的插入和删除。该解法本质是在循环过程中敲定第一个数,在哈希表中找该数后面是否存在第二个数。\n\n这时候不妨将思路转换过来,遍历过程中敲定第二个数,使用哈希表在第二个数的前面去找第一个数。\n\n具体的做法是,边遍历边存入哈希表,遍历过程中使用的下标 i 用作敲定第二个数,再从现有的哈希表中去找另外一个目标数(由于下标 $i$ 前面的数都被加入哈希表了,即在下标 $i$ 前面去找第一个数)。\n\n```Java\nclass Solution {\n    public int[] twoSum(int[] nums, int t) {\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = 0; i < nums.length; i++) {\n            int a = nums[i], b = t - a;\n            if (map.containsKey(b)) return new int[]{map.get(b), i};\n            map.put(a, i);\n        }\n        return new int[]{};\n    }\n}\n```\n从 LeetCode 上的执行时间来看,第一种哈希表做法是 4ms,而第二种哈希表的做法是 0ms(不足 1ms 的意思),快在了我们减少了哈希表的插入和删除操作。\n\n但这只是常数级别上的优化,LeetCode 上的执行时间建议只作普通参考,还是要从算法的时空复杂度来分析快慢。\n\n* 时间复杂度:第一种哈希表的做法会扫描数组两次,复杂度是 $O(n)$(忽略常数);第二种做法只会对数组进行一遍扫描,复杂度是 $O(n)$\n* 空间复杂度:两种做法都使用了哈希表进行记录,复杂度是 $O(n)$\n\n---\n\n### 其他\n\n可以看到,我将原题目的入参 `target` 替换成了 `t`,但并不影响正确性,目的是为了提高编码速度。如果你也经常参与 LeetCode 周赛,就会发现这是一个常用的小技巧。\n\n这个技巧,我希望你在第一题就掌握。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1-10/10. 正则表达式匹配（困难）.md", "url_title": "10. 正则表达式匹配", "url": "https://leetcode-cn.com/problems/regular-expression-matching/solution/shua-chuan-lc-dong-tai-gui-hua-jie-fa-by-zn9w/", "difficulty": "困难", "tags": ["动态规划", "序列 DP"], "question": "给你一个字符串 `s` 和一个字符规律 `p`,请你来实现一个支持 `'.'` 和 `'*'` 的正则表达式匹配。\n\n* `'.'` 匹配任意单个字符\n* `'*'` 匹配零个或多个前面的那一个元素\n\n所谓匹配,是要涵盖整个字符串 `s` 的,而不是部分字符串。\n\n示例 1:\n```\n输入:s = \"aa\" p = \"a\"\n\n输出:false\n\n解释:\"a\" 无法匹配 \"aa\" 整个字符串。\n```\n示例 2:\n```\n输入:s = \"aa\" p = \"a*\"\n\n输出:true\n\n解释:因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此,字符串 \"aa\" 可被视为 'a' 重复了一次。\n```\n示例 3:\n```\n输入:s = \"ab\" p = \".*\"\n\n输出:true\n\n解释:\".*\" 表示可匹配零个或多个('*')任意字符('.')。\n```\n示例 4:\n```\n输入:s = \"aab\" p = \"c*a*b\"\n\n输出:true\n\n解释:因为 '*' 表示零个或多个,这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 \"aab\"。\n```\n示例 5:\n```\n输入:s = \"mississippi\" p = \"mis*is*p*.\"\n\n输出:false\n```\n\n提示:\n* $0 <= s.length <= 20$\n* $0 <= p.length <= 30$\n* `s` 可能为空,且只包含从 `a-z` 的小写字母。\n* `p` 可能为空,且只包含从 `a-z` 的小写字母,以及字符 `.` 和 `*`。\n* 保证每次出现字符 `*` 时,前面都匹配到有效的字符", "solution": "### 动态规划\n\n整理一下题意,对于字符串 `p` 而言,有三种字符:\n\n* 普通字符:需要和 `s` 中同一位置的字符完全匹配\n* `'.'`:能够匹配 `s` 中同一位置的任意字符\n* `'*'`:不能够单独使用 `'*'`,必须和前一个字符同时搭配使用,数据保证了 `'*'` 能够找到前面一个字符。能够匹配 `s` 中同一位置字符任意次。\n\n所以本题关键是分析当出现 `a*` 这种字符时,是匹配 $0$ 个 `a`、还是 $1$ 个 `a`、还是 $2$ 个 `a` ...\n\n本题可以使用动态规划进行求解:\n\n* 状态定义:`f(i,j)` 代表考虑 `s` 中以 `i` 为结尾的子串和 `p` 中的 `j` 为结尾的子串是否匹配。最终我们要求的结果为 `f[n][m]` 。\n\n* 状态转移:也就是我们要考虑 `f(i,j)` 如何求得,前面说到了 `p` 有三种字符,所以这里的状态转移也要分三种情况讨论:\n  \n  1. `p[j]` 为普通字符:匹配的条件是前面的字符匹配,同时 `s` 中的第 `i` 个字符和 `p` 中的第 `j` 位相同。 \n  \n     `f(i,j) = f(i - 1, j - 1) && s[i] == p[j]` 。\n\t\n\t2. `p[j]` 为 `'.'`:匹配的条件是前面的字符匹配, `s` 中的第 `i` 个字符可以是任意字符。\n\t\n     `f(i,j) = f(i - 1, j - 1) && p[j] == '.'`。\n\n  3. `p[j]` 为 `'*'`:读得 `p[j - 1]` 的字符,例如为字符 `a`。 然后根据 `a*` 实际匹配 `s` 中 `a` 的个数是 $0$ 个、$1$ 个、$2$ 个 ...\n\n    3.1. 当匹配为 $0$ 个:`f(i,j) = f(i, j - 2)`\n  \n    3.2. 当匹配为 $1$ 个:`f(i,j) = f(i - 1, j - 2) && (s[i] == p[j - 1] || p[j - 1] == '.')`\n  \n    3.3. 当匹配为 $2$ 个:`f(i,j) = f(i - 2, j - 2) && ((s[i] == p[j - 1] && s[i - 1] == p[j - 1]) || p[j] == '.')`\n\n**我们知道,通过「枚举」来确定 `*` 到底匹配多少个 `a` 这样的做法,算法复杂度是很高的。**\n\n**我们需要挖掘一些「性质」来简化这个过程。**\n\n代码:\n```Java\nclass Solution {\n    public boolean isMatch(String ss, String pp) {\n        // 技巧:往原字符头部插入空格,这样得到 char 数组是从 1 开始,而且可以使得 f[0][0] = true,可以将 true 这个结果滚动下去\n        int n = ss.length(), m = pp.length();\n        ss = \" \" + ss;\n        pp = \" \" + pp;\n        char[] s = ss.toCharArray();\n        char[] p = pp.toCharArray();\n        // f(i,j) 代表考虑 s 中的 1~i 字符和 p 中的 1~j 字符 是否匹配\n        boolean[][] f = new boolean[n + 1][m + 1];\n        f[0][0] = true;\n        for (int i = 0; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                // 如果下一个字符是 '*',则代表当前字符不能被单独使用,跳过\n                if (j + 1 <= m && p[j + 1] == '*' && p[j] != '*') continue;\n                \n                // 对应了 p[j] 为普通字符和 '.' 的两种情况\n                if (i - 1 >= 0 && p[j] != '*') {\n                    f[i][j] = f[i - 1][j - 1] && (s[i] == p[j] || p[j] == '.');\n                } \n                \n                // 对应了 p[j] 为 '*' 的情况\n                else if (p[j] == '*') {\n                    f[i][j] = (j - 2 >= 0 && f[i][j - 2]) || (i - 1 >= 0 && f[i - 1][j] && (s[i] == p[j - 1] || p[j - 1] == '.'));\n                }\n            }\n        }\n        return f[n][m];\n    }\n}\n```\n* 时间复杂度:$n$ 表示 `s` 的长度,$m$ 表示 `p` 的长度,总共 $n \\times m$ 个状态。复杂度为 $O(n \\times m)$\n* 空间复杂度:使用了二维数组记录结果。复杂度为 $O(n \\times m)$\n\n**动态规划本质上是枚举(不重复的暴力枚举),因此其复杂度很好分析,有多少个状态就要被计算多少次,复杂度就为多少。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.10` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1-10/2. 两数相加（中等）.md", "url_title": "2. 两数相加", "url": "https://leetcode-cn.com/problems/add-two-numbers/solution/po-su-jie-fa-shao-bing-ji-qiao-by-ac_oie-etln/", "difficulty": "中等", "tags": ["递归", "链表", "数学", "模拟"], "question": "给你两个 非空 的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。\n\n请你将两个数相加,并以相同形式返回一个表示和的链表。\n\n你可以假设除了数字 $0$ 之外,这两个数都不会以 $0$ 开头。\n\n示例 1:\n\n```\n输入:l1 = [2,4,3], l2 = [5,6,4]\n\n输出:[7,0,8]\n\n解释:342 + 465 = 807.\n```\n示例 2:\n```\n输入:l1 = [0], l2 = [0]\n\n输出:[0]\n```\n示例 3:\n```\n输入:l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]\n\n输出:[8,9,9,9,0,0,0,1]\n```\n\n提示:\n\n* 每个链表中的节点数在范围 $[1, 100]$ 内\n* $0 <= Node.val <= 9$\n* 题目数据保证列表表示的数字不含前导零", "solution": "### 朴素解法(哨兵技巧)\n\n这是道模拟题,模拟人工竖式做加法的过程:\n\n从最低位至最高位,逐位相加,如果和大于等于 $10$,则保留个位数字,同时向前一位进 1 如果最高位有进位,则需在最前面补 $1$。\n\n做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。\n\n代码:\n```Java\nclass Solution {\n    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {\n        ListNode dummy = new ListNode(0);\n        ListNode tmp = dummy;\n        int t = 0;\n        while (l1 != null || l2 != null) {\n            int a = l1 != null ? l1.val : 0;\n            int b = l2 != null ? l2.val : 0;\n            t = a + b + t;\n            tmp.next = new ListNode(t % 10);\n            t /= 10;\n            tmp = tmp.next;\n            if (l1 != null) l1 = l1.next;\n            if (l2 != null) l2 = l2.next;\n        }\n        if (t > 0) tmp.next = new ListNode(t);\n        return dummy.next;\n    }\n}\n```\n* 时间复杂度:$m$ 和 $n$ 分别代表两条链表的长度,则遍历到的最远位置为 $max(m,n)$,复杂度为 $O(max(m,n))$\n* 空间复杂度:创建了 $max(m,n) + 1$ 个节点(含哨兵),复杂度为 $O(max(m,n))$(忽略常数)\n\n**注意:事实上还有可能创建 $max(m + n) + 2$ 个节点,包含哨兵和最后一位的进位。但复杂度仍为 $O(max(m,n))$。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1-10/3. 无重复字符的最长子串（中等）.md", "url_title": "3. 无重复字符的最长子串", "url": "https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/solution/shua-chuan-lc-shuang-zhi-zhen-ha-xi-biao-q08m/", "difficulty": "中等", "tags": ["哈希表", "双指针", "滑动窗口"], "question": "给定一个字符串,请你找出其中不含有重复字符的「最长子串」的长度。\n\n示例 1:\n```\n输入: s = \"abcabcbb\"\n\n输出: 3 \n\n解释: 因为无重复字符的最长子串是 \"abc\",所以其长度为 3。\n```\n示例 2:\n```\n输入: s = \"bbbbb\"\n\n输出: 1\n\n解释: 因为无重复字符的最长子串是 \"b\",所以其长度为 1。\n```\n示例 3:\n```\n输入: s = \"pwwkew\"\n\n输出: 3\n\n解释: 因为无重复字符的最长子串是 \"wke\",所以其长度为 3。\n     请注意,你的答案必须是 子串 的长度,\"pwke\" 是一个子序列,不是子串。\n```\n示例 4:\n```\n输入: s = \"\"\n\n输出: 0\n```\n\n提示:\n\n* $0 <= s.length <= 5 \\times 10^4$\n* `s` 由英文字母、数字、符号和空格组成", "solution": "### 滑动窗口\n\n定义两个指针 `start` 和 `end`, `[start:end]` 表示当前处理到的子串。\n\n子串 `[start:end]` 始终满足要求:无重复字符。\n\n从前往后进行扫描 `s`,用哈希表记录 `[start:end]` 中每字符的出现次数。\n\n遍历过程中,`end` 不断自增,将第 `end` 个字符在哈希表中出现的次数加一。\n\n令 `right` 为下标 `end` 对应的字符,当满足 `map.get(right) > 1` 时,代表此前出现过第 `end` 位对应的字符。\n\n此时更新 `start` 的位置(使其右移),直到不满足 `map.get(right) > 1` (代表 `[start:end]` 恢复满足无重复字符的条件),再用 `[start:end]` 长度更新答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int lengthOfLongestSubstring(String s) {\n        Map<Character, Integer> map = new HashMap<>();\n        int ans = 0;\n        for (int start = 0, end = 0; end < s.length(); end++) {\n            char right = s.charAt(end);\n            map.put(right, map.getOrDefault(right, 0) + 1);\n            while (map.get(right) > 1) {\n                char left = s.charAt(start);\n                map.put(left, map.get(left) - 1);\n                start++;\n            }\n            ans = Math.max(ans, end - start + 1);\n        }\n        return ans;\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def lengthOfLongestSubstring(self, s: str) -> int:\n        map = {}\n        ans = 0\n        start = 0\n        for end in range(len(s)):\n            right = s[end]\n            map[right] = map.get(right, 0) + 1\n            while map[right] > 1:\n                left = s[start]\n                map[left] = map[left] - 1\n                start += 1\n            ans = max(ans, end - start + 1)\n        return ans\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int lengthOfLongestSubstring(string s) {\n        unordered_map<char, int> map;\n        int ans = 0;\n        for (int start = 0, end = 0; end < s.length(); end++) {\n            char right = s[end];\n            map[right] = map[right] + 1;\n            while (map[right] > 1) {\n                char left = s[start];\n                map[left] = map[left] - 1;\n                start++;\n            }\n            ans = max(ans, end - start + 1);\n        }\n        return ans;\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nfunction lengthOfLongestSubstring(s: string): number {\n  const map: { [key: string]: number } = {};\n  let ans = 0;\n  let start = 0;\n  for (let end = 0; end < s.length; end++) {\n      const right = s.charAt(end);\n      map[right] = (map[right] || 0) + 1;\n      while (map[right] > 1) {\n          const left = s.charAt(start);\n          map[left] = (map[left] || 0) - 1;\n          start++;\n      }\n      ans = Math.max(ans, end - start + 1);\n  }\n  return ans;\n};\n```\n* 时间复杂度:虽然有两层循环,但每个字符在哈希表中最多只会被插入和删除一次,复杂度为 $O(n)$\n* 空间复杂度:使用了哈希表进行字符记录,复杂度为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.3` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1-10/4. 寻找两个正序数组的中位数（困难）.md", "url_title": "4. 寻找两个正序数组的中位数", "url": "https://leetcode-cn.com/problems/median-of-two-sorted-arrays/solution/shua-chuan-lc-po-su-jie-fa-fen-zhi-jie-f-wtu2/", "difficulty": "困难", "tags": ["二分", "分治"], "question": "给定两个大小分别为 $m$ 和 $n$ 的正序(从小到大)数组 `nums1` 和 `nums2`。\n\n请你找出并返回这两个正序数组的「中位数」。\n\n示例 1:\n```\n输入:nums1 = [1,3], nums2 = [2]\n\n输出:2.00000\n\n解释:合并数组 = [1,2,3] ,中位数 2\n```\n示例 2:\n```\n输入:nums1 = [1,2], nums2 = [3,4]\n\n输出:2.50000\n\n解释:合并数组 = [1,2,3,4] ,中位数 (2 + 3) / 2 = 2.5\n```\n示例 3:\n```\n输入:nums1 = [0,0], nums2 = [0,0]\n\n输出:0.00000\n```\n示例 4:\n```\n输入:nums1 = [], nums2 = [1]\n\n输出:1.00000\n```\n示例 5:\n```\n输入:nums1 = [2], nums2 = []\n\n输出:2.00000\n```\n\n提示:\n* $nums1.length == m$\n* $nums2.length == n$\n* $0 <= m <= 1000$\n* $0 <= n <= 1000$\n* $1 <= m + n <= 2000$\n* $-10^6 <= nums1[i], nums2[i] <= 10^6$\n\n进阶:你能设计一个时间复杂度为 $O(\\log (m+n))$ 的算法解决此问题吗?", "solution": "### 朴素解法\n\n如果忽略进阶的 $O(\\log{(m + n)})$ 要求,这道题就非常简单。\n\n一个比较直观的做法:将两个数组合并,排序,然后分别取得 `total / 2` 和 `(total - 1) / 2` 两个位置的数,取两者平均值。\n\n这样做的目的是为了避免分情况讨论:合并后的数组长度是奇数还是偶数。\n\n```Java\nclass Solution {\n    public double findMedianSortedArrays(int[] nums1, int[] nums2) {\n        int n = nums1.length, m = nums2.length;\n        int[] arr = new int[n + m];\n        int idx = 0;\n        for (int i : nums1) arr[idx++] = i;\n        for (int i : nums2) arr[idx++] = i;\n        Arrays.sort(arr);\n        int l = arr[(n + m) / 2], r = arr[(n + m - 1) / 2];\n        return (l + r) / 2.0;\n    }\n```\n* 时间复杂度:合并两个数组的复杂度是 $O(m + n)$,对合并数组进行排序的复杂度是 $O((m + n)\\log{(m + n)})$。整体复杂度是 $O((m + n)\\log{(m + n)})$\n* 空间复杂度:$O(1)$\n\n**注意:`Arrays.sort()` 不只有双轴快排实现,这里的复杂度分析是假定其使用双轴快排。**\n\n---\n\n### 分治解法\n\n首先可以将原问题等效为:从两个有序数组中找第 k 小的数。\n\n分两种情况讨论:\n\n1. 总个数为偶数:找到 `第 (total / 2) 个小的数` 和 `第 (total / 2 + 1) 个小的数`,结果为两者的平均值。\n\n2. 总个数为奇数:结果为 `第 (total / 2 + 1) 个小的数` 。\n\n具体思路为:\n\n* 默认第一个数组比第二个数组的有效长度短,如果不满足,则调换两个数组(这也是一个常用技巧,目的是减少边界处理工作:原本需要对两个数组做越界检查,现在只需要对短的数组做越界检查)\n\n* 第一个数组的有效长度从 `i` 开始,第二个数组的有效长度从 `j` 开始,其中 `[i,si - 1]` 是第一个数组的前 `k / 2` 个元素,`[j,sj - 1]` 是第二个数组的前 `k - k / 2` 个元素(为了确保 k 为奇数的时候正确)\n\n* 当 `nums1[si - 1] > nums2[sj - 1]`:则表示第 `k` 小一定不在 `[j,sj - 1]` 中,即在 `[i,n]` 或 `[sj,m]` 中\n\n* 当 `nums1[si - 1] <= nums2[sj - 1]`:则表示第 `k` 小一定不在 `[i,si - 1]` 中,即在 `[si,n]` 或 `[j,m]` 中\n\n```Java\nclass Solution {\n    public double findMedianSortedArrays(int[] nums1, int[] nums2) {\n        int tot = nums1.length + nums2.length;\n        if (tot % 2 == 0) {\n            int left = find(nums1, 0, nums2, 0, tot / 2);\n            int right = find(nums1, 0, nums2, 0, tot / 2 + 1);\n            return (left + right) / 2.0;\n        } else {\n            return find(nums1, 0, nums2, 0, tot / 2 + 1);\n        }\n    }\n    int find(int[] n1, int i, int[] n2, int j, int k) {\n        if (n1.length - i > n2.length - j) return find(n2, j, n1, i, k);\n        if (i >= n1.length) return n2[j + k - 1];\n        if (k == 1) {\n            return Math.min(n1[i], n2[j]);\n        } else {\n            int si = Math.min(i + (k / 2), n1.length), sj = j + k - (k / 2);\n            if (n1[si - 1] > n2[sj - 1]) {\n                return find(n1, i, n2, sj, k - (sj - j));\n            } else {\n                return find(n1, si, n2, j, k - (si - i));\n            }\n        }\n    }\n}\n```\n* 时间复杂度:每次递归 k 的规模都减少一半,复杂度为 $O(\\log{(m + n)})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 总结\n\n今天这道题,我给你介绍了两种技巧:\n\n1. 在机试或者竞赛中,目的是尽可能快的 AC,所以 Java 可以直接不写 `private` 的修饰符(不写代表使用默认的包权限),这没有问题,不用纠结\n2. 在机试或者竞赛中,遇到一些是从文字上限制我们的题目,例如本题限制我们使用 $O(\\log{(m+n)})$ 算法。可以分析是否能够不按照限制要求来做,具体分析思路为:\n   1. 先有一个很容易实现的算法思路。例如本题很容易就想到直接使用双指针找第 k 个小的数,复杂度为 $O(n)$。\n   2. 看题目的数据规模 1 是否支撑我们使用限制以外的算法。例如本题数据规模只有 1000 + 1000 = 2000。\n   3. 根据数据规模,判断我们的朴素算法计算机是否可以在 1s 内处理完 2 ,即判断运算次数是否在 $10^7$ 以内 3 。例如本题使用双指针算法,指针移动和判断大小算一次运行,由于数据只有 2000,距离 $10^7$ 还很远,所以完全足够了\n\n说明 1:正规的算法题目都会提供数据规模,LeetCode 上一些旧题目没有提供,是因为当时出的时候不太规范,LeetCode 新题、其他 OJ 平台题目,算法竞赛题目都会有。\n\n说明 2:即使是最严格的 OJ 中最简单的题目,也会提供 1s 的运行时间,超过这个时间才算超时。\n\n说明 3:计算器 1s 内极限的处理速度是 $10^8$ ,但为了尽可能不出现错误提交,使用技巧时尽量和 $10^7$ 进行比较。\n\n**注意:这两个技巧,我只推荐在机试或者竞赛(尽可能快 AC 的场景)中使用。平时练习或者和面试的时候必须老实按照题目要求来。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.4` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1-10/5. 最长回文子串（中等）.md", "url_title": "5. 最长回文子串", "url": "https://leetcode-cn.com/problems/longest-palindromic-substring/solution/shua-chuan-lc-po-su-jie-fa-manacher-suan-i2px/", "difficulty": "中等", "tags": ["模拟", "回文串"], "question": "给你一个字符串 `s`,找到 `s` 中最长的回文子串。\n\n示例 1:\n```\n输入:s = \"babad\"\n输出:\"bab\"\n解释:\"aba\" 同样是符合题意的答案。\n```\n示例 2:\n```\n输入:s = \"cbbd\"\n输出:\"bb\"\n```\n示例 3:\n```\n输入:s = \"a\"\n输出:\"a\"\n```\n示例 4:\n```\n输入:s = \"ac\"\n输出:\"a\"\n```\n\n提示:\n\n* $1 <= s.length <= 1000$\n* `s` 仅由数字和英文字母(大写和/或小写)组成", "solution": "### 朴素解法\n\n这道题有一个很容易就能想到的简单做法:枚举字符串 `s` 中的每一位,作为回文串的中心点,左右进行扩展,直到达到边界或者不满足回文串定义为止。\n\n这样做的思路必然是正确的。\n\n但很显然这是一个朴素(暴力)做法,那么我们如何确定这一做法是否可行呢?\n\n还记得我们上一节的分析思路吗?当我们有了一个简单的实现方法之后,需要从**题目的数据规模**、**计算机的处理速度**和**实现方法的计算量**出发,判断这样的做法是否不会超时。\n\n由于字符串长度最多只有 1000,而我们的实现方法是 $O(n^2)$,因此我们算法的计算量应该在 $10^6$ 以内,是在计算机每秒的处理范围内的。\n\n首先枚举回文串的中心 i,然后分两种情况向两边扩展边界,直到达到边界或者不满足回文串定义为止:\n\n* 回文串长度是奇数,则依次判断 `s[i − k] == s[i + k], k = 1,2,3...`\n\n* 回文串长度是偶数,则依次判断 `s[i − k] == s[i + k − 1], k = 1,2,3...`\n\n代码:\n```Java\nclass Solution {\n    public String longestPalindrome(String s) {\n        String ans = \"\";\n        for (int i = 0; i < s.length(); i++) {\n            // 回文串为奇数\n            int l = i - 1, r = i + 1;\n            String sub = getString(s, l, r);\n            if (sub.length() > ans.length()) ans = sub;\n\n            // 回文串为偶数\n            l = i - 1;\n            r = i + 1 - 1;\n            sub = getString(s, l, r);\n            if (sub.length() > ans.length()) ans = sub;\n        }\n        return ans;\n    }\n    String getString(String s, int l, int r) {\n        while (l >= 0 && r < s.length() && s.charAt(l) == s.charAt(r)) {\n            l--;\n            r++;\n        }\n        return s.substring(l + 1, r);\n    }\n}\n```\n* 时间复杂度:先枚举了 `s` 中的每个字符作为回文串的中心点,再从中心点出发左右扩展,最多扩展到边界。复杂度是 $O(n^2)$\n* 空间复杂度:$O(1)$\n\n---\n### Manacher 算法\n\n这是一个比较冷门的算法,使用范围也比较单一,只能用于解决「回文串」问题。\n\nManacher 确实是「回文串」问题的最优解。\n\n但事实上我还没有见过必须使用 Manacher 算法才能过的回文串题。\n\n因此我这里直接给解决方案(可以直接当做模板来使用),而不再讨论算法的具体实现原理。\n\nManacher 算法较长,为了避免回文串长度奇偶问题的分情况讨论,我会对原字符进行处理,在边界和字符之间插入占位符。\n\n使用了这样的技巧之后,**当非占位字符作为回文串的中心时,对应了回文串长度为奇数的情况;当占位字符作为回文串的中心时,对应了回文串长度为偶数的情况。**。\n\n举个例子:\n\n> 原字符:\"babad\",转换后:\"\\*b\\*a\\*b\\*a\\*d\\*\",得到的回文串:\"\\*b\\*a\\*b\\*\",然后再去除占位符输出:\"bab\"。\n\n*解释:\"aba\" 同样是符合题意的答案。*\n\n代码:\n```Java\nclass Solution {\n    public String longestPalindrome(String s) {\n        if (s.length() == 1) return s;\n\n        char[] chars = manacherString(s);\n        int n = chars.length;\n        int[] pArr = new int[n];\n        int C = -1, R = -1, pos = -1;\n        int max = Integer.MIN_VALUE;\n        for (int i = 0; i < n; i++) {\n            pArr[i] = i < R ? Math.min(pArr[C * 2 - i], R - i) : 1;\n            while (i + pArr[i] < n && i - pArr[i] > -1) {\n                if (chars[i + pArr[i]] == chars[i - pArr[i]]) {\n                    pArr[i]++;\n                } else {\n                    break;\n                }\n            }\n            if (i + pArr[i] > R) {\n                R = i + pArr[i];\n                C = i;\n            }\n            if (pArr[i] > max) {\n                max = pArr[i];\n                pos = i;\n            }\n        }\n        int offset = pArr[pos];\n        StringBuilder sb = new StringBuilder();\n        for (int i = pos - offset + 1; i <= pos + offset - 1; i++) {\n            if (chars[i] != '#') sb.append(chars[i]);\n        }\n        return sb.toString();\n    }\n    char[] manacherString(String s) {\n        char[] chars = new char[s.length() * 2 + 1];\n        for (int i = 0, idx = 0; i < chars.length; i++) {\n            chars[i] = (i & 1) == 0 ? '#' : s.charAt(idx++);\n        }\n        return chars;\n    }\n}\n```\n* 时间复杂度:只对字符串进行了一次扫描。复杂度为 $O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 总结\n\n今天这道题目,三叶除了提供常规的、时间复杂度为 $O(n^2)$ 的朴素解法以外,还给你提供了关于「回文串」的最优解 Manacher 算法模板,建议有余力的同学可以背过。\n\n背过这样的算法的意义在于:相当于大脑里有了一个时间复杂度为 $O(n)$ 的 api 可以使用,这个 api 传入一个字符串,返回该字符串的最大回文子串。\n\n同时借助 Manacher 算法,还给大家介绍了如何避免回文串长度的分情况讨论,这个技巧只要涉及「回文串」问题都适用(无论是否使用 Manacher 算法)。\n\n对于想要背过 Manacher 算法的同学,建议先敲 3 遍,默写 2 遍,然后过了 24 小时,再默写 2 遍,一周后,再进行重复,直到熟练。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.5` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1-10/6. Z 字形变换（中等）.md", "url_title": "6. Z 字形变换", "url": "https://leetcode-cn.com/problems/zigzag-conversion/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-naz6/", "difficulty": "中等", "tags": ["模拟", "数学"], "question": "将一个给定字符串 `s` 根据给定的行数 `numRows` ,以从上往下、从左到右进行 `Z` 字形排列。\n\n比如输入字符串为 `\"PAYPALISHIRING\"` 行数为 $3$ 时,排列如下:\n```\nP   A   H   N\nA P L S I I G\nY   I   R\n```\n之后,你的输出需要从左往右逐行读取,产生出一个新的字符串,比如 `\"PAHNAPLSIIGYIR\"` 。\n\n请你实现这个将字符串进行指定行数变换的函数:`string convert(string s, int numRows);`\n\n示例 1:\n```\n输入:s = \"PAYPALISHIRING\", numRows = 3\n\n输出:\"PAHNAPLSIIGYIR\"\n```\n示例 2:\n```\n输入:s = \"PAYPALISHIRING\", numRows = 4\n\n输出:\"PINALSIGYAHRPI\"\n\n解释:\nP     I    N\nA   L S  I G\nY A   H R\nP     I\n```\n示例 3:\n```\n输入:s = \"A\", numRows = 1\n\n输出:\"A\"\n```\n\n提示:\n* $1 <= s.length <= 1000$\n* `s` 由英文字母(小写和大写)、`','` 和 `'.'` 组成\n* $1 <= numRows <= 1000$", "solution": "### 模拟\n\n由于最终是要我们对 `Z` 型矩阵进行从上往下、从左往右的构建输出。\n\n因此可以构建一个矩阵 `g` 存储 `Z` 型中的每行字符(忽略 `Z` 中的空格间隙),同时使用 `idxs` 存储 `Z` 型中每行用到的下标。\n\n目标 `Z` 型 和 矩阵 `g` 以及 `idxs` 三者关系:\n```\nP     I    N             PIN                3\nA   L S  I G    =>       ALSIG     =>       5\nY A   H R                YAHR               4\nP     I                  PI                 2   \n```\n\n代码:\n```Java\nclass Solution {\n    static int N = 1010;\n    static char[][] g = new char[N][N];\n    static int[] idxs = new int[N];\n    public String convert(String s, int m) {\n        if (m == 1) return s;\n        int n = s.length();\n        Arrays.fill(idxs, 0);\n        for (int i = 0, j = 0, k = 1; i < n; i++) {\n            g[j][idxs[j]++] = s.charAt(i);\n            j += k;\n            if (j < 0) {\n                j += 2; k = 1;\n            } else if (j == m) {\n                j -= 2; k = -1;\n            }\n        }\n        StringBuilder sb = new StringBuilder();\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < idxs[i]; j++) {\n                sb.append(g[i][j]);\n            }\n        }\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:创建数组的工作只会发生一次,清空 `idxs` 数组操作会发生在每个样例中,复杂度为 $O(m)$;将 `s` 的每个字符填入矩阵的复杂度为 $O(n)$;从矩阵中取出字符构建答案复杂度为 $O(n)$。整体复杂度为 $O(m + n)$\n* 空间复杂度:$O(n \\times m)$\n\n---\n\n### 数学规律\n\n对于本题,我们可以不失一般性的将规律推导为「首项」和「公差公式」。\n\n这通常能够有效减少一些判断。\n\n分情况讨论:\n\n* 对于第一行和最后一行:公差为 `2 * (n − 1)` 的等差数列,首项是 `i` \n* 对于其他行:两个公差为 `2 * (n − 1)` 的等差数列交替排列,首项分别是 `i` 和 `2 * n − i − 2`\n\n代码:\n```Java\nclass Solution {\n    public String convert(String s, int r) {\n        int n = s.length();\n        if (n == 1 || r == 1) return s;\n        StringBuilder sb = new StringBuilder();\n        for (int i = 0; i < r; i++) {\n            if (i == 0 || i == r - 1) {\n                int pos = i, offset = 2 * (r - 1);\n                while (pos < n) {\n                    sb.append(s.charAt(pos));\n                    pos += offset;\n                }\n            } else {\n                int pos1 = i, pos2 = 2 * r - i - 2;\n                int offset = 2 * (r - 1);\n                while (pos1 < n || pos2 < n) {\n                    if (pos1 < n) {\n                        sb.append(s.charAt(pos1));\n                        pos1 += offset;\n                    }\n                    if (pos2 < n) {\n                        sb.append(s.charAt(pos2));\n                        pos2 += offset;\n                    }\n                }\n            }\n        }\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.6` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1-10/7. 整数反转（简单）.md", "url_title": "7. 整数反转", "url": "https://leetcode-cn.com/problems/reverse-integer/solution/shua-chuan-lc-bu-wan-mei-jie-fa-wan-mei-919rd/", "difficulty": "简单", "tags": ["数学", "模拟"], "question": "给你一个 $32$ 位的有符号整数 `x` ,返回将 `x` 中的数字部分反转后的结果。\n\n如果反转后整数超过 $32$ 位的有符号整数的范围 $[−2^{31}, 2^{31} − 1]$ ,就返回 $0$。\n\n假设环境不允许存储 $64$ 位整数(有符号或无符号)。\n\n示例 1:\n```\n输入:x = 123\n\n输出:321\n```\n示例 2:\n```\n输入:x = -123\n\n输出:-321\n```\n示例 3:\n```\n输入:x = 120\n\n输出:21\n```\n示例 4:\n```\n输入:x = 0\n\n输出:0\n```\n\n提示:\n* -$2^{31} <= x <= 2^{31}$ - 1", "solution": "### 不完美解法\n\n在机试或者周赛这种需要快速 AC 的场景中,遇到这种从文字上进行限制的题目,可以选择性的忽略限制。\n\n对于本题,题目从文字上限制我们只能使用 $32$ 位的数据结构(`int`)。\n\n但由于数据范围过大,使用 `int` 会有溢出的风险,所以我们使用 `long` 来进行计算,在返回再转换为 `int`。\n\n代码:\n```Java\nclass Solution {\n    public int reverse(int x) {\n        long ans = 0;\n        while (x != 0) {\n            ans = ans * 10 + x % 10;\n            x = x / 10;\n        }\n        return (int)ans == ans ? (int)ans : 0;\n    }\n}\n```\n* 时间复杂度:数字 $x$ 的位数,数字大约有 $\\log{x}$ 位。复杂度为 $O(\\log{x})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 完美解法\n\n在「不完美解法」中,我们使用了不符合文字限制的 `long` 数据结构。\n\n接下来我们看看,不使用 `long` 该如何求解。\n\n从上述解法来看,我们在循环的 `ans = ans * 10 + x % 10` 这一步会有溢出的风险,因此我们需要边遍历边判断是否溢出:\n\n* 对于正数而言:溢出意味着 `ans * 10 + x % 10 > Integer.MAX_VALUE`,对等式进行变化后可得 `ans > (Integer.MAX_VALUE - x % 10) / 10)`。所以我们可以根据此变形公式进行预判断\n\n* 对于负数而言:溢出意味着 `ans * 10 + x % 10 < Integer.MIN_VALUE`,对等式进行变化后可得 `ans < (Integer.MIN_VALUE - x % 10) / 10)`。所以我们可以根据此变形公式进行预判断\n\n代码:\n```Java\nclass Solution {\n    public int reverse(int x) {\n        int ans = 0;\n        while (x != 0) {\n            if (x > 0 && ans > (Integer.MAX_VALUE - x % 10) / 10) return 0;\n            if (x < 0 && ans < (Integer.MIN_VALUE - x % 10) / 10) return 0;\n            ans = ans * 10 + x % 10;\n            x /= 10;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:数字 $x$ 的位数,数字大约有 $\\log{x}$ 位。复杂度为 $O(\\log{x})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.7` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1-10/8. 字符串转换整数 (atoi)（中等）.md", "url_title": "8. 字符串转换整数 (atoi)", "url": "https://leetcode-cn.com/problems/string-to-integer-atoi/solution/shua-chuan-lc-jian-ji-jie-fa-by-ac_oier-69tp/", "difficulty": "中等", "tags": ["模拟"], "question": "请你来实现一个 `myAtoi(string s)` 函数,使其能将字符串转换成一个 32 位有符号整数(类似 C/C++ 中的 atoi 函数)。\n\n函数 `myAtoi(string s)` 的算法如下:\n\n* 读入字符串并丢弃无用的前导空格\n* 检查下一个字符(假设还未到字符末尾)为正还是负号,读取该字符(如果有)。 确定最终结果是负数还是正数。 如果两者都不存在,则假定结果为正。\n* 读入下一个字符,直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。\n* 将前面步骤读入的这些数字转换为整数(即,`\"123\" -> 123`, `\"0032\" -> 32`)。如果没有读入数字,则整数为 $0$ 。必要时更改符号(从步骤 $2$ 开始)。\n* 如果整数数超过 $32$ 位有符号整数范围 [−$2^{31}$,  $2^{31}$ − 1] ,需要截断这个整数,使其保持在这个范围内。具体来说,小于 −$2^{31}$ 的整数应该被固定为 −$2^{31}$ ,大于 $2^{31}$ − 1 的整数应该被固定为 $2^{31}$ − 1 。\n* 返回整数作为最终结果。\n\n注意:\n\n* 本题中的空白字符只包括空格字符 `' '` 。\n* 除前导空格或数字后的其余字符串外,请勿忽略 任何其他字符。\n\n示例 1:\n\n```\n输入:s = \"42\"\n\n输出:42\n\n解释:加粗的字符串为已经读入的字符,插入符号是当前读取的字符。\n\n第 1 步:\"42\"(当前没有读入字符,因为没有前导空格)\n         ^\n第 2 步:\"42\"(当前没有读入字符,因为这里不存在 '-' 或者 '+')\n         ^\n第 3 步:\"42\"(读入 \"42\")\n           ^\n解析得到整数 42 。\n由于 \"42\" 在范围 [-231, 231 - 1] 内,最终结果为 42 。\n```\n示例 2:\n```\n输入:s = \"   -42\"\n\n输出:-42\n\n解释:\n第 1 步:\"   -42\"(读入前导空格,但忽视掉)\n            ^\n第 2 步:\"   -42\"(读入 '-' 字符,所以结果应该是负数)\n             ^\n第 3 步:\"   -42\"(读入 \"42\")\n               ^\n解析得到整数 -42 。\n由于 \"-42\" 在范围 [-231, 231 - 1] 内,最终结果为 -42 。\n```\n示例 3:\n```\n输入:s = \"4193 with words\"\n输出:4193\n解释:\n第 1 步:\"4193 with words\"(当前没有读入字符,因为没有前导空格)\n         ^\n第 2 步:\"4193 with words\"(当前没有读入字符,因为这里不存在 '-' 或者 '+')\n         ^\n第 3 步:\"4193 with words\"(读入 \"4193\";由于下一个字符不是一个数字,所以读入停止)\n             ^\n解析得到整数 4193 。\n由于 \"4193\" 在范围 [-231, 231 - 1] 内,最终结果为 4193 。\n```\n示例 4:\n```\n输入:s = \"words and 987\"\n\n输出:0\n\n解释:\n第 1 步:\"words and 987\"(当前没有读入字符,因为没有前导空格)\n         ^\n第 2 步:\"words and 987\"(当前没有读入字符,因为这里不存在 '-' 或者 '+')\n         ^\n第 3 步:\"words and 987\"(由于当前字符 'w' 不是一个数字,所以读入停止)\n         ^\n解析得到整数 0 ,因为没有读入任何数字。\n由于 0 在范围 [-231, 231 - 1] 内,最终结果为 0 。\n```\n示例 5:\n```\n输入:s = \"-91283472332\"\n\n输出:-2147483648\n\n解释:\n第 1 步:\"-91283472332\"(当前没有读入字符,因为没有前导空格)\n         ^\n第 2 步:\"-91283472332\"(读入 '-' 字符,所以结果应该是负数)\n          ^\n第 3 步:\"-91283472332\"(读入 \"91283472332\")\n                     ^\n解析得到整数 -91283472332 。\n由于 -91283472332 小于范围 [-231, 231 - 1] 的下界,最终结果被截断为 -231 = -2147483648 。\n```\n\n提示:\n* $0 <= s.length <= 200$\n* `s` 由英文字母(大写和小写)、数字(`0-9`)、`' '`、`'+'`、`'-'` 和 `'.'` 组成", "solution": "### 朴素解法\n\n这是道模拟题。\n\n一看这题目描述,多少有点做工程项目各种判断的意思了。\n\n但对于这类题目,切忌一上来直接写代码,很容易会陷入各种边界判断。\n\n这时候一个比较推荐的做法是先对要求进行提炼整理:\n\n1. 忽略前导空格\n2. 首字符只能是 正号/负号/数字,否则不合法(返回 0)\n3. 继续往后匹配字符,直到结尾或不为数字为止(匹配过程中如果出现溢出,根据正负直接返回 `Integer.MAX_VALUE` 或 `Integer.MIN_VALUE`)。\n\n当整理出来具体的逻辑之后,记得再次检查是否有遗漏掉某些边界情况。\n\n确定逻辑之后,代码就好写了。\n\n代码:\n```Java\nclass Solution {\n    public int myAtoi(String s) {\n        int n = s.length();\n        char[] chars = s.toCharArray();\n        int idx = 0;       \n        \n        // 去除前导空格,如果去完前导空格后无字符了,返回 0\n        while (idx < n && chars[idx] == ' ') idx++;\n        if (idx == n) return 0;\n\n        // 检查第一个字符:可以为正负号/数字\n        boolean isNeg = false;\n        if (chars[idx] == '-') {\n            idx++;\n            isNeg = true;\n        } else if (chars[idx] == '+') {\n            idx++;\n        } else if (!Character.isDigit(chars[idx])) {\n            return 0;\n        } \n\n        int ans = 0;\n        while (idx < n && Character.isDigit(chars[idx])) {\n            int cur = chars[idx++] - '0';\n            // 和上一题的“【刷穿 LeetCode】7. 整数反转”一样,防止 ans = ans * 10 + cur 溢出\n            // 等价变形为 ans > (Integer.MAX_VALUE - cur) / 10 进行预判断\n            if (ans > (Integer.MAX_VALUE - cur) / 10) {\n                return isNeg ? Integer.MIN_VALUE : Integer.MAX_VALUE;\n            }\n            ans = ans * 10 + cur;\n        }\n        return isNeg ? -ans : ans;\n    }\n}\n```\n* 时间复杂度:会对整个字符串 `s` 扫描一遍。复杂度为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.8` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1-10/9. 回文数（简单）.md", "url_title": "9. 回文数", "url": "https://leetcode-cn.com/problems/palindrome-number/solution/shua-chuan-lc-zi-fu-chuan-fei-zi-fu-chua-e8l0/", "difficulty": "简单", "tags": ["数学", "回文串"], "question": "给你一个整数 `x` ,如果 `x` 是一个回文整数,返回 `true` ;否则,返回 `false` 。\n\n回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。\n\n例如,$121$ 是回文,而 $123$ 不是。\n\n示例 1:\n```\n输入:x = 121\n\n输出:true\n```\n示例 2:\n```\n输入:x = -121\n\n输出:false\n\n解释:从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。\n```\n示例 3:\n```\n输入:x = 10\n\n输出:false\n\n解释:从右向左读, 为 01 。因此它不是一个回文数。\n```\n示例 4:\n```\n输入:x = -101\n\n输出:false\n```\n\n提示:\n* -$2^{31} <= x <= 2^{31}$ - 1\n\n进阶:你能不将整数转为字符串来解决这个问题吗?", "solution": "### 字符串解法\n\n虽然进阶里提到了不能用字符串来解决,但还是提供一下吧。\n\n代码:\n```Java\nclass Solution {\n    public boolean isPalindrome(int x) {\n        String s = String.valueOf(x);\n        StringBuilder sb = new StringBuilder(s);\n        sb.reverse();\n        return sb.toString().equals(s);\n    }\n}\n```\n* 时间复杂度:数字 $n$ 的位数,数字大约有 $\\log_{10}^n$ 位,翻转操作要执行循环。复杂度为 $O(\\log_{10}^n)$\n* 空间复杂度:使用了字符串作为存储。复杂度为 $O(\\log_{10}^n)$\n\n---\n### 非字符串解法(完全翻转)\n\n原数值 `x` 的不超过 int 的表示范围,但翻转后的值会有溢出的风险,所以这里使用 `long` 进行接收,最后对比两者是否相等。\n\n代码:\n```Java\nclass Solution {\n    public boolean isPalindrome(int x) {\n        if (x < 0) return false;\n        long ans = 0;\n        int t = x;\n        while (x > 0) {\n            ans = ans * 10 + x % 10;\n            x /= 10;\n        }\n        return ans - t == 0;\n    }\n}\n```\n* 时间复杂度:数字 $n$ 的位数,数字大约有 $\\log_{10}^n$ 位。复杂度为 $O(\\log_{10}^n)$\n* 空间复杂度:$O(1)$\n\n---\n### 非字符串解法(部分翻转)\n\n如果在进阶中增加一个我们熟悉的要求:环境中只能存储得下 $32$ 位的有符号整数。\n\n那么我们就连 `long` 也不能用了,这时候要充分利用「回文」的特性:前半部分和后半部分(翻转)相等。\n\n这里的前半部分和后半部分(翻转)需要分情况讨论:\n\n* 回文长度为奇数:回文中心是一个独立的数,即 `忽略回文中心后,前半部分 == 后半部分(翻转)`。如 1234321 回文串\n\n* 回文长度为偶数:回文中心在中间两个数中间,即 `前半部分 == 后半部分(翻转)`。如 123321\n\n代码:\n```Java\nclass Solution {\n    public boolean isPalindrome(int x) {\n        // 对于 负数 和 x0、x00、x000 格式的数,直接返回 flase\n        if (x < 0 || (x % 10 == 0 && x != 0)) return false;\n        int t = 0;\n        while (x > t) {\n            t = t * 10 + x % 10;\n            x /= 10;\n        }\n        // 回文长度的两种情况:直接比较 & 忽略中心点(t 的最后一位)进行比较\n        return x == t || x == t / 10;\n    }\n}\n```\n* 时间复杂度:数字 $n$ 的位数,数字大约有 $\\log_{10}^n$ 位。复杂度为 $O(\\log_{10}^n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.9` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1001-1010/1001. 网格照明（困难）.md", "url_title": "1001. 网格照明", "url": "https://leetcode-cn.com/problems/grid-illumination/solution/gong-shui-san-xie-ha-xi-biao-xian-ying-s-s48d/", "difficulty": "困难", "tags": ["模拟", "哈希表"], "question": "在大小为 `n x n` 的网格 `grid` 上,每个单元格都有一盏灯,最初灯都处于 关闭 状态。\n\n给你一个由灯的位置组成的二维数组 `lamps`,其中 $lamps[i] = [row_i, col_i]$ 表示 打开 位于 `grid[rowi][coli]` 的灯。即便同一盏灯可能在 `lamps` 中多次列出,不会影响这盏灯处于 打开 状态。\n\n当一盏灯处于打开状态,它将会照亮 自身所在单元格 以及同一 行 、同一 列 和两条 对角线 上的 所有其他单元格 。\n\n另给你一个二维数组 `queries`,其中 $queries[j] = [row_j, col_j]$ 。对于第 $j$ 个查询,如果单元格 $[row_j, col_j]$ 是被照亮的,则查询结果为 $1$ ,否则为 $0$ 。\n\n在第 `j` 次查询之后 [按照查询的顺序] ,关闭 位于单元格 $grid[row_j][col_j]$ 上及相邻 $8$ 个方向上(与单元格 $grid[row_i][col_i]$ 共享角或边)的任何灯。\n\n返回一个整数数组 `ans` 作为答案, `ans[j]` 应等于第 `j` 次查询 `queries[j]` 的结果,$1$ 表示照亮,$0$ 表示未照亮。\n\n示例 1:\n\n```\n输入:n = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,0]]\n\n输出:[1,0]\n```\n\n```\n解释:最初所有灯都是关闭的。在执行查询之前,打开位于 [0, 0] 和 [4, 4] 的灯。第 0 次查询检查 grid[1][1] 是否被照亮(蓝色方框)。该单元格被照亮,所以 ans[0] = 1 。然后,关闭红色方框中的所有灯。\n```\n\n```\n第 1 次查询检查 grid[1][0] 是否被照亮(蓝色方框)。该单元格没有被照亮,所以 ans[1] = 0 。然后,关闭红色矩形中的所有灯。\n```\n示例 2:\n```\n输入:n = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,1]]\n\n输出:[1,1]\n```\n示例 3:\n```\n输入:n = 5, lamps = [[0,0],[0,4]], queries = [[0,4],[0,1],[1,4]]\n\n输出:[1,1,0]\n```\n\n提示:\n* $1 <= n <= 10^9$\n* $0 <= lamps.length <= 20000$\n* $0 <= queries.length <= 20000$\n* $lamps[i].length == 2$\n* $0 <= row_i, col_i < n$\n* $queries[j].length == 2$\n* $0 <= row_j, col_j < n$", "solution": "### 哈希表 + 线映射\n\n棋盘大小的数据范围为 $n = 10^9$,硬模拟「亮灯」的操作必然会 `TLE`,而 `lamps` 和 `queries` 数据范围为 $20000$ 是一个较为常见的突破口。\n\n由于点亮每一盏灯,可以使得当前 **行、列 和 对角线** 的位置被照亮,行列可直接使用棋盘坐标的 $(x, y)$ 来代指,而对角线则可以使用「截距」来进行代指,即使用 $x + y$ 和 $x - y$ 进行代指。\n\n分别使用四个「哈希表」`row`、`col`、`left` 和 `right` 来记录 **行、列 和 对角线** 的点亮情况(`key` 为线编号,`value` 为点亮次数)。\n\n这样我们可以在 $O(1)$ 的复杂度处理掉所有的 $lamps[i]$,某个位置被照亮的充要条件为:**「当前位置所在行被点亮」或「当前位置所在列被点亮」或「当前位置所处的对角线被点亮」。**\n\n同时,由于每次查询后要进行「灭灯」操作(注意:灭灯只能灭有灯的位置,而不是灭有光的位置 🤣),因此我们还需要另外记录每个灯的位置,可以使用利用「二维转一维」的技巧进行编号:$idx = x * n + y$,并使用 `HashSet` 进行记录(忽略重复的 $lamps[i]$)。\n\n由于询问次数最多为 $20000$,因此直接在查询完成后模拟「灭灯」即可(访问自身及相邻格子,共 $9$ 个),计算量为 $2 * 10^5$ 以内,可以接受。若某个位置存在灯,将其从 `HashSet` 中移除,并更新对应线的点亮情况。\n\n代码:\n```Java\nclass Solution {\n    int[][] dirs = new int[][]{{0,0},{0,-1},{0,1},{-1,0},{-1,-1},{-1,1},{1,0},{1,-1},{1,1}};\n    public int[] gridIllumination(int n, int[][] lamps, int[][] queries) {\n        long N = n;\n        Map<Integer, Integer> row = new HashMap<>(), col = new HashMap<>();\n        Map<Integer, Integer> left = new HashMap<>(), right = new HashMap<>();\n        Set<Long> set = new HashSet<>();\n        for (int[] l : lamps) {\n            int x = l[0], y = l[1];\n            int a = x + y, b = x - y;\n            if (set.contains(x * N + y)) continue;\n            increment(row, x); increment(col, y);\n            increment(left, a); increment(right, b);\n            set.add(x * N + y);\n        }\n        int m = queries.length;\n        int[] ans = new int[m];\n        for (int i = 0; i < m; i++) {\n            int[] q = queries[i];\n            int x = q[0], y = q[1];\n            int a = x + y, b = x - y;\n            if (row.containsKey(x) || col.containsKey(y) || left.containsKey(a) || right.containsKey(b)) ans[i] = 1;\n\n            for (int[] d : dirs) {\n                int nx = x + d[0], ny = y + d[1];\n                int na = nx + ny, nb = nx - ny;\n                if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;\n                if (set.contains(nx * N + ny)) {\n                    set.remove(nx * N + ny);\n                    decrement(row, nx); decrement(col, ny);\n                    decrement(left, na); decrement(right, nb);\n                }\n            }\n        }\n        return ans;\n    }\n    void increment(Map<Integer, Integer> map, int key) {\n        map.put(key, map.getOrDefault(key, 0) + 1);\n    }\n    void decrement(Map<Integer, Integer> map, int key) {\n        if (map.get(key) == 1) map.remove(key);\n        else map.put(key, map.get(key) - 1);\n    }\n}\n```\n* 时间复杂度:令 $lamps$ 长度为 $a$,$queries$ 长度为 $b$,处理所有的 $lamp[i]$ 复杂度为 $O(a)$,处理所有的 $queries[j]$ 复杂度为 $O(C * b)$,其中 $C$ 为模拟灭灯时所联通的格子数量,固定为 $9$。整体复杂度为 $O(a + C * b)$\n* 空间复杂度:$O(a)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1001` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1001-1010/1004. 最大连续1的个数 III（中等）.md", "url_title": "1004. 最大连续1的个数 III", "url": "https://leetcode-cn.com/problems/max-consecutive-ones-iii/solution/san-chong-jie-fa-cong-dong-tai-gui-hua-d-gxks/", "difficulty": "中等", "tags": ["双指针", "滑动窗口", "二分", "前缀和"], "question": "给定一个由若干 $0$ 和 $1$ 组成的数组 `A`,我们最多可以将 $K$ 个值从 $0$ 变成 $1$ 。\n\n返回仅包含 $1$ 的最长(连续)子数组的长度。\n\n示例 1:\n```\n输入:A = [1,1,1,0,0,0,1,1,1,1,0], K = 2\n输出:6\n解释: \n[1,1,1,0,0,1,1,1,1,1,1]\n粗体数字从 0 翻转到 1,最长的子数组长度为 6。\n```\n示例 2:\n```\n输入:A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3\n输出:10\n解释:\n[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]\n粗体数字从 0 翻转到 1,最长的子数组长度为 10。\n```\n\n提示:\n* $1 <= A.length <= 20000$\n* $0 <= K <= A.length$\n* $A[i]$ 为 $0$ 或 $1$", "solution": "### 动态规划(TLE)\n\n看到本题,其实首先想到的是 DP,但是 DP 是 $O(nk)$ 算法。\n\n看到了数据范围是 $10^4$,那么时空复杂度应该都是 $10^8$。\n\n空间可以通过「滚动数组」优化到 $10^4$,但时间无法优化,会超时。\n\n**PS. 什么时候我们会用 DP 来解本题?通过如果 K 的数量级不超过 1000 的话,DP 应该是最常规的做法。**\n\n定义 $f[i,j]$ 代表考虑前 $i$ 个数(并以 $A[i]$ 为结尾的),最大翻转次数为 $j$ 时,连续 $1$ 的最大长度。\n\n* 如果 $A[i]$ 本身就为 1 的话,无须消耗翻转次数,$f[i][j] = f[i - 1][j] + 1$。\n* 如果 $A[i]$ 本身不为 1 的话,由于定义是必须以 $A[i]$ 为结尾,因此必须要选择翻转该位置,$f[i][j] = f[i - 1][j - 1] + 1$。\n\n代码:\n```Java\nclass Solution {\n    public int longestOnes(int[] nums, int k) {\n        int n = nums.length;\n        int[][] f = new int[2][k + 1]; \n        int ans = 0;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 0; j <= k; j++) {\n                if (nums[i - 1] == 1) {\n                    f[i & 1][j] = f[(i - 1) & 1][j] + 1;\n                } else {\n                    f[i & 1][j] = j == 0 ? 0 : f[(i - 1) & 1][j - 1] + 1;\n                }\n                ans = Math.max(ans, f[i & 1][j]);\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(nk)$\n* 空间复杂度:$O(k)$\n\n---\n\n### 前缀和 + 二分 \n\n从数据范围上分析,**平方级别**的算法过不了,往下优化就应该是**对数级别**的算法。\n\n因此,很容易我们就会想到「二分」。\n\n当然还需要我们对问题做一下等价变形。\n\n**最大替换次数不超过 `k` 次,可以将问题转换为找出连续一段区间 `[l,r]`,使得区间中出现 0 的次数不超过 `k` 次。**\n\n我们可以枚举区间 左端点/右端点 ,然后找到其满足「出现 0 的次数不超过 `k` 次」的最远右端点/最远左端点。\n\n为了快速判断 `[l,r]` 之间出现 0 的个数,我们需要用到前缀和。\n\n假设 `[l,r]` 的区间长度为 `len`,区间和为 `tot`,那么出现 0 的格式为 `len - tol`,再与 `k` 进行比较。\n\n由于数组中不会出现负权值,因此前缀和数组具有「单调性」,那么必然满足「其中一段满足 $len - tol <= k$,另外一段不满足 $len - tol <= k$」。\n\n**因此,对于某个确定的「左端点/右端点」而言,以「其最远右端点/最远左端点」为分割点的前缀和数轴,具有「二段性」。可以通过二分来找分割点。**\n\n代码:\n```Java\nclass Solution {\n    public int longestOnes(int[] nums, int k) {\n        int n = nums.length;\n        int ans = 0;\n        int[] sum = new int[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n        for (int i = 0; i < n; i++) {\n            int l = 0, r = i;\n            while (l < r) {\n                int mid = l + r >> 1;\n                if (check(sum, mid, i, k)) {\n                    r = mid;\n                } else {\n                    l = mid + 1;\n                }\n            }\n            if (check(sum, r, i, k)) ans = Math.max(ans, i - r + 1);\n        }\n        return ans;\n    }\n    boolean check(int[] sum, int l, int r, int k) {\n        int tol = sum[r + 1] - sum[l], len = r - l + 1;\n        return len - tol <= k;\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n**关于二分结束后再次 `check` 的说明:由于「二分」本质是找满足某个性质的分割点,通常我们的某个性质会是「非等值条件」,不一定会取得 `=`。**\n\n**例如我们很熟悉的:从某个非递减数组中找目标值,找到返回下标,否则返回 -1。**\n\n**当目标值不存在,「二分」找到的应该是数组内比目标值小或比目标值大的最接近的数。因此二分结束后先进行 `check` 再使用是一个好习惯。**\n\n---\n\n### 双指针\n\n由于我们总是比较 `len`、`tot` 和 `k` 三者的关系。\n\n因此我们可以使用「滑动窗口」的思路,动态维护一个左右区间 `[j, i]` 和维护窗口内和 `tot`。\n\n右端点一直右移,左端点在窗口不满足「`len - tol <= k`」的时候进行右移,即可做到线程扫描的复杂度。\n\n代码:\n```Java\nclass Solution {\n    public int longestOnes(int[] nums, int k) {\n        int n = nums.length;\n        int ans = 0;\n        for (int i = 0, j = 0, tot = 0; i < n; i++) {\n            tot += nums[i];\n            while ((i - j + 1) - tot > k) tot -= nums[j++];\n            ans = Math.max(ans, i - j + 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 总结\n\n**除了掌握本题解法以外,我还希望你能理解这几种解法是如何被想到的(特别是如何从「动态规划」想到「二分」)。**\n\n**根据数据范围(复杂度)调整自己所使用的算法的分析能力,比解决该题本身更加重要。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1004` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1001-1010/1005. K 次取反后最大化的数组和（简单）.md", "url_title": "1005. K 次取反后最大化的数组和", "url": "https://leetcode-cn.com/problems/maximize-sum-of-array-after-k-negations/solution/gong-shui-san-xie-jian-dan-fen-qing-kuan-6qwu/", "difficulty": "简单", "tags": ["优先队列(堆)", "模拟", "贪心"], "question": "给你一个整数数组 `nums` 和一个整数 `k` ,按以下方法修改该数组:\n\n* 选择某个下标 `i` 并将 `nums[i]` 替换为 `-nums[i]` 。\n\n重复这个过程恰好 `k` 次。可以多次选择同一个下标 `i` 。\n\n以这种方式修改数组后,返回数组 可能的最大和 。 \n\n示例 1:\n```\n输入:nums = [4,2,3], k = 1\n\n输出:5\n\n解释:选择下标 1 ,nums 变为 [4,-2,3] 。\n```\n示例 2:\n```\n输入:nums = [3,-1,0,2], k = 3\n\n输出:6\n\n解释:选择下标 (1, 2, 2) ,nums 变为 [3,1,0,2] 。\n```\n示例 3:\n```\n输入:nums = [2,-3,-1,5,-4], k = 2\n\n输出:13\n\n解释:选择下标 (1, 4) ,nums 变为 [2,3,-1,5,4] 。\n```\n\n提示:\n* $1 <= nums.length <= 10^4$\n* $-100 <= nums[i] <= 100$\n* $1 <= k <= 10^4$", "solution": "### 贪心 + 分情况讨论 + 模拟\n\n假设取反前的总和为 $sum$,取反一个任意值 $x$ 后,对 $sum$ 的影响为 $- 2 * x$。\n\n即取反一个负数会使得结果变大,取反正数会使结果变小,取反 $0$ 值对结果没有影响。\n\n因此,为了让取反后的结果尽可能的大,我们应当取反 $-2*x$ 尽可能大的数值。即按照「负数从小到大的顺序进行取反」。\n\n对取反次数 $k$ 和 负数个数 $cnt$ 进行分情况讨论:\n\n* $k <= cnt$:按照负数从小到大的顺序进行取反即可;\n* $k > cnt$:按照负数从小到大的顺序进行取反后,根据「是否存在 $0$ 值」和「剩余取反次数的奇偶性」进行分情况讨论:\n    * 存在 $0$ 值 或 剩余取反次数为偶数:直接返回当前取反数组的总和( $0$ 值可抵消任意次数的取反操作,将偶数次的取反操作应用在同一数值上,结果不变);\n    * 不存在 $0$ 值且剩余取反次数为奇数:此时从当前数值中取一个绝对值最小值(使用 $idx$ 记录该值下标)进行取反,得到最终的取反数组。\n\n最后对取反数组进行求和操作即可。\n\n代码:\n```Java\nclass Solution {\n    public int largestSumAfterKNegations(int[] nums, int k) {\n        int n = nums.length, idx = 0;\n        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->nums[a]-nums[b]);\n        boolean zero = false;\n        for (int i = 0; i < n; i++) {\n            if (nums[i] < 0) q.add(i);\n            if (nums[i] == 0) zero = true;\n            if (Math.abs(nums[i]) < Math.abs(nums[idx])) idx = i;\n        }\n        if (k <= q.size()) {\n            while (k-- > 0) nums[q.peek()] = -nums[q.poll()];\n        } else {\n            while (!q.isEmpty() && k-- > 0) nums[q.peek()] = -nums[q.poll()];\n            if (!zero && k % 2 != 0) nums[idx] = -nums[idx];\n        }\n        int ans = 0;\n        for (int i : nums) ans += i;\n        return ans;\n    }\n}\n```\n* 时间复杂度:对 $nums$ 进行遍历,得到 $idx$ 以及优先队列的复杂度为 $O(n\\log{n})$;从优先队列中取出元素进行取反操作的复杂度为 $O(k\\log{n})$;对取反数组进行求和复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 优化优先队列\n\n由于 $nums$ 长度范围为 $10000$,但值域范围在 $[-100, 100]$,因此我们可以使用计数数组 $cnt$ 来替代优先队列的作用。\n\n注意由于 $nums[i]$ 存在负数,因此需要增 $100$ 的偏移量。同时对于翻转操作,仅需要修改相应计数即可。\n\n代码:\n```Java\nclass Solution {\n    public int largestSumAfterKNegations(int[] nums, int k) {\n        int[] cnts = new int[210];\n        for (int i : nums) cnts[i + 100]++;\n        for (int i = -100; i < 0 && k > 0; i++) {\n            while (cnts[i + 100] != 0 && k-- > 0) {\n                cnts[i + 100]--; cnts[-i + 100]++;\n            }\n        }\n        if (cnts[0 + 100] == 0 && k > 0 && k % 2 != 0) {\n            int val = 1;\n            while (cnts[val + 100] == 0) val++;\n            cnts[val + 100]--; cnts[-val + 100]++;\n        }\n        int ans = 0;\n        for (int i = -100; i <= 100; i++) ans += i * cnts[i + 100];\n        return ans;\n    }\n}\n```\n* 时间复杂度:需要对 $nums$ 以及大小为 $C = 210$ 的计数数组进行常数次扫描,复杂度为 $O(n + C)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1005` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1001-1010/1006. 笨阶乘（中等）.md", "url_title": "1006. 笨阶乘", "url": "https://leetcode-cn.com/problems/clumsy-factorial/solution/gong-shui-san-xie-tong-yong-biao-da-shi-nngfp/", "difficulty": "中等", "tags": ["数学", "栈"], "question": "通常,正整数 n 的阶乘是所有小于或等于 n 的正整数的乘积。\n\n例如,factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1。\n\n相反,我们设计了一个笨阶乘 clumsy:在整数的递减序列中,我们以一个固定顺序的操作符序列来依次替换原有的乘法操作符:乘法(*),除法(/),加法(+)和减法(-)。\n\n例如,clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1。然而,这些运算仍然使用通常的算术运算顺序:我们在任何加、减步骤之前执行所有的乘法和除法步骤,并且按从左到右处理乘法和除法步骤。\n\n另外,我们使用的除法是地板除法(floor division),所以 10 * 9 / 8 等于 11。这保证结果是一个整数。\n\n实现上面定义的笨函数:给定一个整数 N,它返回 N 的笨阶乘。\n\n \n\n示例 1:\n```\n输入:4\n\n输出:7\n\n解释:7 = 4 * 3 / 2 + 1\n```\n示例 2:\n```\n输入:10\n\n输出:12\n\n解释:12 = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1\n```\n\n提示:\n\n* 1 <= N <= 10000\n* -$2^{31}$ <= answer <= $2^{31}$ - 1  (答案保证符合 32 位整数)", "solution": "### 通用表达式解法\n\n第一种解法是我们的老朋友解法了,使用「双栈」来解决通用表达式问题。\n\n**事实上,我提供这套解决方案不仅仅能解决只有 `+ - ( )`([224. 基本计算器](https://leetcode-cn.com/problems/basic-calculator/)) 或者 `+ - * /`([227. 基本计算器 II](https://leetcode-cn.com/problems/basic-calculator-ii/solution/)) 的表达式问题,还能能解决 `+ - * / ^ % ( )` 的完全表达式问题。**\n\n甚至支持自定义运算符,只要在运算优先级上进行维护即可。\n\n**对于「表达式计算」这一类问题,你都可以使用这套思路进行解决。我十分建议你加强理解这套处理逻辑。**\n\n对于「任何表达式」而言,我们都使用两个栈 `nums` 和 `ops`:\n* `nums` : 存放所有的数字\n* `ops` :存放所有的数字以外的操作\n\n然后从前往后做,对遍历到的字符做分情况讨论:\n* 空格 : 跳过\n* `(` : 直接加入 `ops` 中,等待与之匹配的 `)`\n* `)` : 使用现有的 `nums` 和 `ops` 进行计算,直到遇到左边最近的一个左括号为止,计算结果放到 `nums`\n* 数字 : 从当前位置开始继续往后取,将整一个连续数字整体取出,加入 `nums`\n* `+ - * / ^ %` : 需要将操作放入 `ops` 中。**在放入之前先把栈内可以算的都算掉(只有「栈内运算符」比「当前运算符」优先级高/同等,才进行运算)**,使用现有的 `nums` 和 `ops` 进行计算,直到没有操作或者遇到左括号,计算结果放到 `nums`\n\n我们可以通过 🌰 来理解 **只有「栈内运算符」比「当前运算符」优先级高/同等,才进行运算** 是什么意思:\n\n因为我们是从前往后做的,假设我们当前已经扫描到 `2 + 1` 了(此时栈内的操作为 `+` )。\n\n1. 如果后面出现的 `+ 2` 或者 `- 1` 的话,满足「栈内运算符」比「当前运算符」优先级高/同等,可以将 `2 + 1` 算掉,把结果放到 `nums` 中;\n2. 如果后面出现的是 `* 2` 或者 `/ 1` 的话,不满足「栈内运算符」比「当前运算符」优先级高/同等,这时候不能计算 `2 + 1`。\n\n更为详细的讲解可以看这篇题解 :[使用「双栈」解决「究极表达式计算」问题](https://leetcode-cn.com/problems/basic-calculator-ii/solution/shi-yong-shuang-zhan-jie-jue-jiu-ji-biao-c65k/)\n\n代码:\n\n```Java\nclass Solution {\n    public int clumsy(int n) {\n        Deque<Integer> nums = new ArrayDeque<>();\n        Deque<Character> ops = new ArrayDeque<>();\n        // 维护运算符优先级\n        Map<Character, Integer> map = new HashMap<>(){{\n            put('*', 2);\n            put('/', 2);\n            put('+', 1);\n            put('-', 1);\n        }};\n        char[] cs = new char[]{'*', '/', '+', '-'};\n        for (int i = n, j = 0; i > 0; i--, j++) {\n            char op = cs[j % 4];\n            nums.addLast(i);\n            // 如果「当前运算符优先级」不高于「栈顶运算符优先级」,说明栈内的可以算\n            while (!ops.isEmpty() && map.get(ops.peekLast()) >= map.get(op)) {\n                calc(nums, ops);\n            }\n            if (i != 1) ops.add(op);\n        }\n        // 如果栈内还有元素没有算完,继续算\n        while (!ops.isEmpty()) calc(nums, ops);\n        return nums.peekLast();\n    }\n    void calc(Deque<Integer> nums, Deque<Character> ops) {\n        int b = nums.pollLast(), a = nums.pollLast();\n        int op = ops.pollLast();\n        int ans = 0;\n        if (op == '+') ans = a + b;\n        else if (op == '-') ans = a - b;\n        else if (op == '*') ans = a * b;\n        else if (op == '/') ans = a / b;\n        nums.addLast(ans);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 数学解法(打表技巧分析)\n\n这次在讲【证明】之前,顺便给大家讲讲找规律的题目该怎么做。\n\n由于是按照特定顺序替换运算符,因此应该是有一些特性可以被我们利用的。\n\n通常我们需要先实现一个**可打表的算法(例如上述的解法一,这是为什么掌握「通用表达式」解法具有重要意义)**,将连续数字的答案打印输出,来找找规律:\n\n```Java\n    Solution solution = new Solution();\n    for (int i = 1; i <= 10000; i++) {\n        int res = solution.clumsy(i);\n        System.out.println(i + \" : \" + res);\n    }\n```\n\n似乎 $n$ 与 答案比较接近,我们考虑将两者的差值输出:\n\n```Java\n    Solution solution = new Solution();\n    for (int i = 1; i <= 10000; i++) {\n        int res = solution.clumsy(i);\n        System.out.println(i + \" : \" + res + \" : \" + (res - i));\n    }\n```\n\n咦,好像发现了什么不得了的东西。似乎每四个数,差值都是  [1, 2, 2, -1]\n\n再修改我们的打表逻辑,来验证一下(只输出与我们猜想不一样的数字):\n\n```Java\n    Solution solution = new Solution();\n    int[] diff = new int[]{1,2,2,-1};\n    for (int i = 1; i <= 10000; i++) {\n        int res = solution.clumsy(i);\n        int t = res - i;\n        if (t != diff[i % 4]) {\n            System.out.println(i + \" : \" + res);\n        }\n    }\n```\n\n只有前四个数字被输出,其他数字都是符合我们的猜想规律的。\n\n**到这里我们已经知道代码怎么写可以 AC 了,十分简单。**\n\n代码:\n\n```java\nclass Solution {\n    public int clumsy(int n) {\n        int[] special = new int[]{1,2,6,7};\n        int[] diff = new int[]{1,2,2,-1};\n        if (n <= 4) return special[(n - 1) % 4];\n        return n + diff[n % 4];\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$\n\n***\n\n### 证明\n\n讲完我们的【实战技巧】之后,再讲讲如何证明。\n\n**上述的做法比较适合于笔试或者比赛,但是面试,通常还需要证明做法为什么是正确的。**\n\n我们不失一般性的分析某个 `n`,当然这个 `n` 必须是大于 4,不属于我们的特判值。\n\n然后对 `n` 进行讨论(**根据我们的打表猜想去证明规律是否可推广**):\n\n1. `n % 4 == 0` : $f(n) = n * (n - 1) / (n - 2) + ... + 5 - 4 * 3 / 2 + 1 = n + 1$,即 `diff = 1`\n\n2. `n % 4 == 1` : $f(n) = n * (n - 1) / (n - 2) + ... + 6 - 5 * 4 / 3 + 2 - 1 = n + 2$,即 `diff = 2`\n\n3. `n % 4 == 2` : $f(n) = n * (n - 1) / (n - 2) + ... + 7 - 6 * 5 / 4 + 3 - 2 * 1 = n + 2$,即 `diff = 2`\n\n4. `n % 4 == 3` : $f(n) = n * (n - 1) / (n - 2) + ... + 8 - 7 * 6 / 5 + 4 - 3 * 2 / 1 = n - 1$,即 `diff = -1`\n\n**上述的表达式展开过程属于小学数学内容,省略号部分的项式的和为 0,因此你只需要关注我写出来的那部分。**\n\n**至此,我们证明了我们的打表猜想具有「可推广」的特性。**\n\n**甚至我们应该学到:证明可以是基于猜想去证明,而不必从零开始进行推导。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1006` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/101-110/108. 将有序数组转换为二叉搜索树（简单）.md", "url_title": "108. 将有序数组转换为二叉搜索树", "url": "https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/solutions/2436639/gong-shui-san-xie-jian-dan-di-gui-fen-zh-nzqx/", "difficulty": "简单", "tags": ["二叉树", "树的搜索", "分治"], "question": "给你一个整数数组 `nums`,其中元素已经按 升序 排列,请你将其转换为一棵 高度平衡 二叉搜索树。\n\n高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 $1$ 」的二叉树。\n\n示例 1:\n\n```\n输入:nums = [-10,-3,0,5,9]\n\n输出:[0,-3,9,-10,null,5]\n\n解释:[0,-10,5,null,-3,null,9] 也将被视为正确答案:\n```\n示例 2:\n\n```\n输入:nums = [1,3]\n\n输出:[3,1]\n\n解释:[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。\n```\n\n提示:\n* $1 <= nums.length <= 10^4$\n* $-10^4 <= nums[i] <= 10^4$\n* `nums` 按严格递增顺序排列", "solution": "### 递归分治\n\n题目给定的 `nums` 严格有序,为满足构造出来的 `BST` 整体平衡,我们需要保证每个子树的构造也是平衡的。\n\n一个容易想到的思路:使用 `nums` 中最靠近中心的位置作为整棵 `BST` 的根节点,例如下标 $mid = \\left \\lfloor \\frac{l + r}{2} \\right \\rfloor$ 的位置,确保左右子树节点数量平衡。随后递归构造 `nums` 中下标范围为 $[0, mid - 1]$ 作为左子树,递归构造 `nums` 中下标范围为 $[mid + 1, n - 1]$ 作为右子树。\n\nJava 代码:\n\n```Java\nclass Solution {\n    public TreeNode sortedArrayToBST(int[] nums) {\n        return build(nums, 0, nums.length - 1);\n    }\n    TreeNode build(int[] nums, int l, int r) {\n        if (l > r) return null;\n        int mid = l + r >> 1;\n        TreeNode ans = new TreeNode(nums[mid]);\n        ans.left = build(nums, l, mid - 1);\n        ans.right = build(nums, mid + 1, r);\n        return ans;\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:\n        return self.build(nums, 0, len(nums) - 1)\n\n    def build(self, nums, l, r):\n        if l > r:\n            return None\n        mid = l + r >> 1\n        ans = TreeNode(nums[mid])\n        ans.left = self.build(nums, l, mid - 1)\n        ans.right = self.build(nums, mid + 1, r)\n        return ans\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    TreeNode* sortedArrayToBST(vector<int>& nums) {\n        return build(nums, 0, nums.size() - 1);\n    }\n    TreeNode* build(vector<int>& nums, int l, int r) {\n        if (l > r) return nullptr;\n        int mid = l + r >> 1;\n        TreeNode* ans = new TreeNode(nums[mid]);\n        ans->left = build(nums, l, mid - 1);\n        ans->right = build(nums, mid + 1, r);\n        return ans;\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nfunction sortedArrayToBST(nums: number[]): TreeNode | null {\n    const build = function (nums: number[], l: number, r: number): TreeNode | null {\n        if (l > r) return null;\n        const mid = l + r >> 1;\n        const ans = new TreeNode(nums[mid]);\n        ans.left = build(nums, l, mid - 1);\n        ans.right = build(nums, mid + 1, r);\n        return ans;\n    }\n    return build(nums, 0, nums.length - 1);\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.108` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/101-110/109. 有序链表转换二叉搜索树（中等）.md", "url_title": "109. 有序链表转换二叉搜索树", "url": "https://leetcode.cn/problems/convert-sorted-list-to-binary-search-tree/solutions/2436644/gong-shui-san-xie-jian-dan-di-gui-fen-zh-6t1x/", "difficulty": "中等", "tags": ["二叉树", "树的搜索", "分治", "中序遍历"], "question": "给定一个单链表的头节点  `head`,其中的元素 按升序排序 ,将其转换为高度平衡的二叉搜索树。\n\n本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差不超过 $1$。\n\n示例 1:\n\n```\n输入: head = [-10,-3,0,5,9]\n\n输出: [0,-3,9,-10,null,5]\n\n解释: 一个可能的答案是[0,-3,9,-10,null,5],它表示所示的高度平衡的二叉搜索树。\n```\n示例 2:\n```\n输入: head = []\n\n输出: []\n```\n\n提示:\n* `head` 中的节点数在 $[0, 2 \\times 10^4]$ 范围内\n* $-10^5 <= Node.val <= 10^5$", "solution": "### 递归分治\n\n与上一题 [108. 将有序数组转换为二叉搜索树](https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/solutions/2436639/gong-shui-san-xie-jian-dan-di-gui-fen-zh-nzqx/) 类似,但链表相对于数组,无法 $O(1)$ 找到构建当前 `BST` 根节点的“中点”下标。\n\n一个仍可确保 $O(n)$ 时间复杂度(瓶颈在于需要创建 $n$ 个节点),但需要 $O(n)$ 空间复杂度的做法是:对链表进行一次遍历,转成数组后套用上一题的做法。\n\n一个不使用 $O(n)$ 空间复杂度的做法,需要每次遍历来找“中点”下标:起始我们先对 `head` 进行一次遍历,得到链表长度 $n$,随后仍然利用递归分治的思路进行构造,每次对入参的左右端点找“中点”,先通过直接结算的方式定位到偏移量 $t = l + \\left \\lfloor \\frac{l + r}{2} \\right \\rfloor$,然后再通过从入参节点 `head` 出发往前走 $t$ 的做法找到“中点”节点。\n\n该做法每个节点的访问次数为在递归过程中被 $[l, r]$ 所覆盖的次数,我们知道一个节点数量为 $n$ 的平衡 `BST`  树高为 $\\log{n}$,因此整体复杂度为 $O(n\\log{n})$。\n\nJava 代码:\n```Java\nclass Solution {\n    public TreeNode sortedListToBST(ListNode head) {\n        int n = 0;\n        ListNode cur = head;\n        while (cur != null && ++n >= 0) cur = cur.next;\n        return build(head, 0, n - 1);\n    }\n    TreeNode build(ListNode head, int l, int r) {\n        if (l > r) return null;\n        int mid = l + r >> 1, t = mid - l;\n        ListNode cur = head;\n        while (t-- > 0) cur = cur.next;\n        TreeNode ans = new TreeNode(cur.val);\n        ans.left = build(head, l, mid - 1);\n        ans.right = build(cur.next, mid + 1, r);\n        return ans;\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def sortedListToBST(self, head: Optional[ListNode]) -> Optional[TreeNode]:\n        n = 0\n        cur = head\n        while cur:\n            n += 1\n            cur = cur.next\n        return self.build(head, 0, n - 1)\n        \n    def build(self, head: ListNode, l: int, r: int) -> TreeNode:\n        if l > r:\n            return None\n        mid = l + r >> 1\n        t = mid - l\n        cur = head\n        while t > 0:\n            cur = cur.next\n            t -= 1\n        ans = TreeNode(cur.val)\n        ans.left = self.build(head, l, mid - 1)\n        ans.right = self.build(cur.next, mid + 1, r)\n        return ans\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    TreeNode* sortedListToBST(ListNode* head) {\n        int n = 0;\n        ListNode* cur = head;\n        while (cur && ++n >= 0) cur = cur->next;\n        return build(head, 0, n - 1);\n    }\n    TreeNode* build(ListNode* head, int l, int r) {\n        if (l > r) return nullptr;\n        int mid = l + r >> 1, t = mid - l;\n        ListNode* cur = head;\n        while (t-- > 0) cur = cur->next;\n        TreeNode* ans = new TreeNode(cur->val);\n        ans->left = build(head, l, mid - 1);\n        ans->right = build(cur->next, mid + 1, r);\n        return ans;\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nfunction sortedListToBST(head: ListNode | null): TreeNode | null {\n    const build = function (head: ListNode | null, l: number, r: number): TreeNode | null {\n        if (l > r) return null;\n        let mid = l + r >> 1, t = mid - l;\n        let cur = head;\n        while (t-- > 0) cur = cur.next;\n        const ans = new TreeNode(cur!.val);\n        ans.left = build(head, l, mid - 1);\n        ans.right = build(cur!.next, mid + 1, r);\n        return ans;\n    }\n    let n = 0;\n    let cur = head;\n    while (cur != null && ++n >= 0) cur = cur.next;       \n    return build(head, 0, n - 1);\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 递归分治 - 中序遍历\n\n由于给定的 `nums` 本身严格有序,而 `BST`  的中序遍历亦是有序。因此我们可以一边遍历链表,一边对 `BST`  进行构造。\n\n具体的,我们仍然先对链表进行遍历,拿到链表长度 `n`。递归构造过程中传入左右端点 `l` 和 `r`,含义为使用链表中 $[l, r]$ 部分节点,但不再在每次递归中传入当前头结点,而是使用全局变量 `head` 来记录。\n\n递归构造过程中,计算“中点”位置 $mid  = \\left \\lfloor \\frac{l + r}{2} \\right \\rfloor$,并根据如下流程进行构造:\n\n1. 使用 $[l, mid - 1]$ 构建左子树,使用变量 `left` 保存当前左子树的根节点\n2. 构建完左子树后,全局变量 `head` 必然来到了“中点”位置,用其构建根节点 `ans`,并将根节点与此前构造的 `left` 关联。同时让链表节点 `head` 后移\n3. 使用 $[mid + 1, r]$ 构建右子树,并将其挂载到根节点 `ans` 中\n\n如此一来,即可确保「链表遍历」和「`BST`  构造」的同步性。\n\nJava 代码:\n```Java\nclass Solution {\n    ListNode head;\n    public TreeNode sortedListToBST(ListNode _head) {\n        head = _head;\n        int n = 0;\n        ListNode cur = head;\n        while (cur != null && ++n >= 0) cur = cur.next;\n        return build(0, n - 1);\n    }\n    TreeNode build(int l, int r) {\n        if (l > r) return null;\n        int mid = l + r >> 1;\n        TreeNode left = build(l, mid - 1); \n        TreeNode ans = new TreeNode(head.val);\n        head = head.next;\n        ans.left = left;\n        ans.right = build(mid + 1, r);\n        return ans;\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def sortedListToBST(self, head: Optional[ListNode]) -> Optional[TreeNode]:\n        self.head = head\n        n = 0\n        cur = self.head\n        while cur is not None:\n            n += 1\n            cur = cur.next\n        return self.build(0, n - 1)\n\n    def build(self, l: int, r: int) -> TreeNode:\n        if l > r:\n            return None\n        mid = l + r >> 1\n        left = self.build(l, mid - 1)\n        ans = TreeNode(self.head.val)\n        ans.left = left\n        self.head = self.head.next\n        ans.right = self.build(mid + 1, r)\n        return ans\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    ListNode* head;\n    TreeNode* sortedListToBST(ListNode* _head) {\n        head = _head;\n        int n = 0;\n        ListNode* cur = head;\n        while (cur && n++ >= 0) cur = cur->next;\n        return build(0, n - 1);\n    }\n    TreeNode* build(int l, int r) {\n        if (l > r) return nullptr;\n        int mid = l + r >> 1;\n        TreeNode* left = build(l, mid - 1);\n        TreeNode* ans = new TreeNode(head->val);\n        ans->left = left;\n        head = head->next;\n        ans->right = build(mid + 1, r);\n        return ans;\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nfunction sortedListToBST(_head: ListNode | null): TreeNode | null {\n    const build =function(l: number, r: number): TreeNode | null {\n        if (l > r) return null;\n        const mid = l + r >> 1;\n        const left = build(l, mid - 1);\n        const ans = new TreeNode(head.val);\n        ans.left = left;\n        head = head.next;\n        ans.right = build(mid + 1, r);\n        return ans;\n    }\n    let head = _head;\n    let n = 0, cur = head;\n    while (cur && n++ >= 0) cur = cur.next;\n    return build(0, n - 1);\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.109` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1011-1020/1011. 在 D 天内送达包裹的能力（中等）.md", "url_title": "1011. 在 D 天内送达包裹的能力", "url": "https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-95zj/", "difficulty": "中等", "tags": ["二分"], "question": "传送带上的包裹必须在 `D` 天内从一个港口运送到另一个港口。\n\n传送带上的第 `i` 个包裹的重量为 $weights[i]$。\n\n每一天,我们都会按给出重量的顺序往传送带上装载包裹。\n\n我们装载的重量不会超过船的最大运载重量。\n\n返回能在 `D` 天内将传送带上的所有包裹送达的船的最低运载能力。\n\n示例 1:\n```\n输入:weights = [1,2,3,4,5,6,7,8,9,10], D = 5\n\n输出:15\n\n解释:\n船舶最低载重 15 就能够在 5 天内送达所有包裹,如下所示:\n第 1 天:1, 2, 3, 4, 5\n第 2 天:6, 7\n第 3 天:8\n第 4 天:9\n第 5 天:10\n\n请注意,货物必须按照给定的顺序装运,因此使用载重能力为 14 的船舶并将包装分成 (2, 3, 4, 5), (1, 6, 7), (8), (9), (10) 是不允许的。 \n```\n示例 2:\n```\n输入:weights = [3,2,2,4,1,4], D = 3\n\n输出:6\n\n解释:\n船舶最低载重 6 就能够在 3 天内送达所有包裹,如下所示:\n第 1 天:3, 2\n第 2 天:2, 4\n第 3 天:1, 4\n```\n示例 3:\n```\n输入:weights = [1,2,3,1,1], D = 4\n\n输出:3\n\n解释:\n第 1 天:1\n第 2 天:2\n第 3 天:3\n第 4 天:1, 1\n```\n\n提示:\n* $1 <= D <= weights.length <= 5 \\times 10^4$\n* $1 <= weights[i] <= 500$", "solution": "### 二分解法(精确边界)\n\n假定「`D` 天内运送完所有包裹的最低运力」为 `ans`,那么在以 `ans` 为分割点的数轴上具有「二段性」:\n* 数值范围在 $(-\\infty, ans)$ 的运力必然「不满足」 `D` 天内运送完所有包裹的要求\n* 数值范围在 $[ans, +\\infty)$ 的运力必然「满足」 `D`天内运送完所有包裹的要求\n\n**我们可以通过「二分」来找到恰好满足 `D`天内运送完所有包裹的分割点 `ans`。**\n\n接下来我们要确定二分的范围,由于不存在包裹拆分的情况,考虑如下两种边界情况:\n* 理论最低运力:只确保所有包裹能够被运送,自然也包括重量最大的包裹,此时理论最低运力为 `max`,`max` 为数组 `weights` 中的最大值\n* 理论最高运力:使得所有包裹在最短时间(一天)内运送完成,此时理论最高运力为 `sum`,`sum` 为数组 `weights` 的总和\n\n**由此,我们可以确定二分的范围为 $[max, sum]$。**\n\nJava 代码:\n```Java\nclass Solution {\n    public int shipWithinDays(int[] weights, int days) {\n        int max = 0, sum = 0;\n        for (int w : weights) {\n            max = Math.max(max, w);\n            sum += w;\n        }\n        int l = max, r = sum;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (check(weights, mid, days)) r = mid;\n            else l = mid + 1;\n        }\n        return r;\n    }\n    boolean check(int[] weights, int t, int days) {\n        int n = weights.length, cnt = 1;\n        for (int i = 1, sum = weights[0]; i < n; sum = 0, cnt++) {\n            while (i < n && sum + weights[i] <= t) sum += weights[i++];\n        }\n        return cnt - 1 <= days;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int shipWithinDays(vector<int>& weights, int days) {\n        int maxv = 0, sum = 0;\n        for (int w : weights) {\n            maxv = max(maxv, w);\n            sum += w;\n        }\n        int l = maxv, r = sum;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (check(weights, mid, days)) r = mid;    \n            else l = mid + 1;\n        }\n        return r;\n    }\n    bool check(vector<int>& weights, int t, int days) {\n        int n = weights.size(), cnt = 1;\n        for (int i = 1, sum = weights[0]; i < n; sum = 0, cnt++) {\n            while (i < n && sum + weights[i] <= t) sum += weights[i++];\n        }\n        return cnt - 1 <= days;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def shipWithinDays(self, weights: List[int], days: int) -> int:\n        def check(weights: List[int], t: int, days: int) -> bool:\n            n, cnt = len(weights), 1\n            i, sumv = 1, weights[0]\n            while i < n:\n                while i < n and sumv + weights[i] <= t:\n                    sumv += weights[i]\n                    i += 1\n                cnt += 1\n                sumv = 0\n            return cnt - 1 <= days\n\n        maxv, sumv = max(weights), sum(weights)\n        l, r = maxv, sumv\n        while l < r:\n            mid = l + r >> 1\n            if check(weights, mid, days):\n                r = mid\n            else:\n                l = mid + 1\n        return r\n```\nTypeScript 代码:\n```TypeScript\nfunction shipWithinDays(weights: number[], days: number): number {\n    const check = function(weights: number[], t: number, days: number): boolean {\n        let n = weights.length, cnt = 1;\n        for (let i = 1, sum = weights[0]; i < n; sum = 0, cnt++) {\n            while (i < n && sum + weights[i] <= t) sum += weights[i++];\n        }\n        return cnt - 1 <= days;\n    }\n    let maxv = 0, sumv = 0;\n    for (const w of weights) {\n        maxv = Math.max(maxv, w);\n        sumv += w;\n    }\n    let l = maxv, r = sumv;\n    while (l < r) {\n        const mid = l + r >> 1;\n        if (check(weights, mid, days)) r = mid;\n        else l = mid + 1;\n    }\n    return r;\n};\n```\n* 时间复杂度:二分范围为 $[max, sum]$,`check` 函数的复杂度为 $O(n)$。整体复杂度为 $O(n\\log({\\sum_{i= 0}^{n - 1}ws[i]}))$\n* 空间复杂度:$O(1)$ \n\n---\n\n### 二分解法(粗略边界)\n\n当然,一个合格的「二分范围」只需要确保包含分割点 `ans` 即可。因此我们可以利用数据范围来确立粗略的二分范围(从而少写一些代码):\n\n* 利用运力必然是正整数,从而确定左边界为 $1$\n* 根据 $1 \\leqslant D \\leqslant weights.length \\leqslant 50000$ 和 $1 \\leqslant weights[i] \\leqslant 500$,从而确定右边界为 $1e8$\n\n*PS. 由于二分查找具有折半效率,因此「确立粗略二分范围」不会比「通过循环取得精确二分范围」效率低。*\n\nJava 代码:\n```Java\nclass Solution {\n    public int shipWithinDays(int[] weights, int days) {\n        int l = 1, r = (int)1e8;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (check(weights, mid, days)) r = mid;    \n            else l = mid + 1;\n        }\n        return r;\n    }\n    boolean check(int[] weights, int t, int days) {\n        if (weights[0] > t) return false;\n        int n = weights.length, cnt = 1;\n        for (int i = 1, sum = weights[0]; i < n; sum = 0, cnt++) {\n            if (weights[i] > t) return false;\n            while (i < n && sum + weights[i] <= t) sum += weights[i++];\n        }\n        return cnt - 1 <= days;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int shipWithinDays(vector<int>& weights, int days) {\n        int l = 1, r = 1e8;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (check(weights, mid, days)) r = mid;    \n            else l = mid + 1;\n        }\n        return r;\n    }\n    bool check(vector<int>& weights, int t, int days) {\n        if (weights[0] > t) return false;\n        int n = weights.size(), cnt = 1;\n        for (int i = 1, sum = weights[0]; i < n; sum = 0, cnt++) {\n            if (weights[i] > t) return false;\n            while (i < n && sum + weights[i] <= t) sum += weights[i++];\n        }\n        return cnt - 1 <= days;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def shipWithinDays(self, weights: List[int], days: int) -> int:\n        def check(weights: List[int], t: int, days: int) -> bool:\n            if weights[0] > t: return False\n            n, cnt = len(weights), 1\n            i, sumv = 1, weights[0]\n            while i < n:\n                if weights[i] > t: return False\n                while i < n and sumv + weights[i] <= t:\n                    sumv += weights[i]\n                    i += 1\n                cnt += 1\n                sumv = 0\n            return cnt - 1 <= days\n\n        l, r = 1, 10**8\n        while l < r:\n            mid = l + r >> 1\n            if check(weights, mid, days):\n                r = mid\n            else:\n                l = mid + 1\n        return r\n```\nTypeScript 代码:\n```TypeScript\nfunction shipWithinDays(weights: number[], days: number): number {\n    const check = function(weights: number[], t: number, days: number): boolean {\n        if (weights[0] > t) return false;\n        let n = weights.length, cnt = 1;\n        for (let i = 1, sum = weights[0]; i < n; sum = 0, cnt++) {\n            if (weights[i] > t) return false;\n            while (i < n && sum + weights[i] <= t) sum += weights[i++];\n        }\n        return cnt - 1 <= days;\n    }\n    let l = 0, r = 1e8;\n    while (l < r) {\n        const mid = l + r >> 1;\n        if (check(weights, mid, days)) r = mid;\n        else l = mid + 1;\n    }\n    return r;\n};\n```\n* 时间复杂度:二分范围为 $[1, 1e8]$,`check` 函数的复杂度为 $O(n)$。整体复杂度为 $O(n\\log{1e8})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1011` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1011-1020/1012. 至少有 1 位重复的数字（困难）.md", "url_title": "1012. 至少有 1 位重复的数字", "url": "https://leetcode-cn.com/problems/numbers-with-repeated-digits/solution/by-ac_oier-2szj/", "difficulty": "困难", "tags": ["动态规划", "数位 DP", "容斥原理"], "question": "给定正整数 $n$,返回在 $[1, n]$ 范围内具有 至少 1 位 重复数字的正整数的个数。\n\n示例 1:\n```\n输入:n = 20\n\n输出:1\n\n解释:具有至少 1 位重复数字的正数(<= 20)只有 11 。\n```\n示例 2:\n```\n输入:n = 100\n\n输出:10\n\n解释:具有至少 1 位重复数字的正数(<= 100)有 11,22,33,44,55,66,77,88,99 和 100 。\n```\n示例 3:\n```\n输入:n = 1000\n\n输出:262\n```\n\n提示:\n* $1 <= n <= 10^9$", "solution": "### 数位 DP\n\n**首先 $[1, n]$ 共有 $n$ 个数,而求解 $[1, n]$ 范围内有多少个「至少有 $1$ 位重复数字」的数的个数,等价于「总数 $n$」减去「没有重复数的数的个数」。**\n\n于是问题转换为:**如何求解「没有重复数」的数的个数,同时为了更具一般性,我们将求解 $[1, n]$ 范围内「没有重复数」的数的个数,修改为求解 $[0, n]$ 范围内「没有重复数」的数的个数**。\n\n>即将问题转换为 [(题解) 357. 统计各位数字都不同的数字个数](https://leetcode-cn.com/problems/count-numbers-with-unique-digits/solution/by-ac_oier-6tfl/) 中的进阶部分。\n\n假定我们存在函数 `int dp(int x)` 函数,能够返回区间 $[0, x]$ 内合法数的个数,那么配合「容斥原理」我们便能够回答任意区间合法数的查询:\n\n$$\nans_{(l, r)} = dp(r) - dp(l - 1)\n$$\n\n然后考虑如何实现 `int dp(int x)` 函数,我们将组成 $[0, x]$ 的合法数分成三类:\n* 位数和 $x$ 相同,且最高位比 $x$ 最高位要小的,这部分统计为 `res1`;\n* 位数和 $x$ 相同,且最高位与 $x$ 最高位相同的,这部分统计为 `res2`;\n* 位数比 $x$ 少,这部分统计为 `res3`。\n\n其中 `res1` 和 `res3` 求解相对简单,重点落在如何求解 `res2` 上。\n\n**对 $x$ 进行「从高到低」的处理(假定 $x$ 数位为 $n$),对于第 $k$ 位而言($k$ 不为最高位),假设在 $x$ 中第 $k$ 位为 $cur$,那么为了满足「大小限制」关系,我们只能在 $[0, cur - 1]$ 范围内取数,同时为了满足「相同数字只能使用一次」的限制,我们需要使用一个 `int` 变量 $s$ 来记录使用情况(用 $s$ 的低十位来代指数字 $[0, 9]$ 是否被使用),统计 $[0, cur - 1]$ 范围内同时符合两个限制条件的数的个数,记为 $cnt$。**\n\n**当第 $k$ 位有 $cnt$ 种合法选择之后,后面的位数可以在满足「相同数字只能使用一次」的限制条件下任意选择(因为大小关系已经由第 $k$ 位保证),为了快速知道剩下的 $n - k$ 位有多少种方案,我们还需要预处理乘积数组,其中 $f[l][r]$ 代表 $l * (l + 1) * ... * (j - 1) * j$ 的乘积之和。**\n\n> 上述讲解若是觉得抽象,我们可以举个 🌰,假设 $x = 678$,我们该如何求解 `res2`:由于限定了 `res2` 为「位数和 $x$ 相同,且最高位与 $x$ 最高位相同的」的合法数个数,因此最高位没有选,只能是 $6$,然后考虑处理次高位,次高位在 $x$ 中为 $7$,为了满足大小关系,我们只能在 $[0, 6]$ 范围内做限制,同时由于 $6$ 已用过,因此次高位实际只有 $[0, 5]$,共 $6$ 种选择,当确定次高位后,后面的位数任意取,由于前面已经填充了 $p = 2$ 位(即消耗了 $p$ 个不同数字),因此从后面的位数开始应该是 $a = 10 - p$ 开始往后自减累乘到 $b = (10 - p) - (n - p) + 1$ 为止,即此时方案数为 $cnt * f[b][a]$(当前位不是最低位)或者 $cnt$(当前位是最低位)。按照此逻辑循环处理所有位数即可,直到遇到重复数值或正常结束。\n\n需要说明的是,上述的举例部分只是为方便大家理解过程,看懂了举例部分不代表理解了数位 DP 做法成立的内在条件,阅读的重点还是要放在前面加粗字体部分,只会使用样例理解算法永远不是科学的做法。\n\n其他细节:乘积数组的预处理与样例无关,我们可以使用 `static` 进行打表优化,同时可以将 `res1` 和 `res2` 两种情况进行合并。\n\n代码:\n```Java\nclass Solution {\n    // f[l][r] 代表 i * (i + 1) * ... * (j - 1) * j\n    static int[][] f = new int[10][10];\n    static {\n        for (int i = 1; i < 10; i++) {\n            for (int j = i; j < 10; j++) {\n                int cur = 1;\n                for (int k = i; k <= j; k++) cur *= k;\n                f[i][j] = cur;\n            }\n        }\n    }\n    int dp(int x) {\n        int t = x;\n        List<Integer> nums = new ArrayList<>();\n        while (t != 0) {\n            nums.add(t % 10);\n            t /= 10;\n        }\n        int n = nums.size();\n        if (n <= 1) return x + 1; // [0, 9]\n        // 位数和 x 相同(res1 + res2)\n        int ans = 0;\n        for (int i = n - 1, p = 1, s = 0; i >= 0; i--, p++) {\n            int cur = nums.get(i), cnt = 0;\n            for (int j = cur - 1; j >= 0; j--) {\n                if (i == n - 1 && j == 0) continue;\n                if (((s >> j) & 1) == 0) cnt++;\n            }\n            int a = 10 - p, b = a - (n - p) + 1;\n            ans += b <= a ? cnt * f[b][a] : cnt;\n            if (((s >> cur) & 1) == 1) break;\n            s |= (1 << cur);\n            if (i == 0) ans++;\n        }\n        // 位数比 x 少(res3)\n        ans += 10;\n        for (int i = 2, last = 9; i < n; i++) {\n            int cur = last * (10 - i + 1);\n            ans += cur; last = cur;\n        }\n        return ans;\n    }\n    public int numDupDigitsAtMostN(int n) {\n        return (n + 1) - dp(n);\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1012` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1011-1020/1020. 飞地的数量（中等）.md", "url_title": "1020. 飞地的数量", "url": "https://assets.leetcode.com/uploads/2021/02/18/enclaves1.jpg", "difficulty": "中等", "tags": ["DFS", "并查集"], "question": "给你一个大小为 $m x n$ 的二进制矩阵 $grid$ ,其中 $0$ 表示一个海洋单元格、$1$ 表示一个陆地单元格。\n\n一次 移动 是指从一个陆地单元格走到另一个相邻(上、下、左、右)的陆地单元格或跨过 $grid$ 的边界。\n\n返回网格中 无法 在任意次数的移动中离开网格边界的陆地单元格的数量。\n\n示例 1:\n\n```\n输入:grid = [[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]\n\n输出:3\n\n解释:有三个 1 被 0 包围。一个 1 没有被包围,因为它在边界上。\n```\n示例 2:\n\n```\n输入:grid = [[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]\n\n输出:0\n\n解释:所有 1 都在边界上或可以到达边界。\n```\n\n提示:\n* $m == grid.length$\n* $n == grid[i].length$\n* $1 <= m, n <= 500$\n* $grid[i][j]$ 的值为 $0$ 或 $1$", "solution": "### 并查集 + DFS\n\n根据题目定义,我们知道需要统计所有不和「边缘陆地」相连通的「普通陆地」数量。\n\n我们可以用「并查集」来维护连通块,使用 `DFS` 对所有「边缘陆地连通块」进行标记(设定编号为 $0$ 的超级源点,对于所有的「边缘陆地连通块」,将其与超级源点联通)。\n\n具体的,我们按照如下流程进行处理:\n\n* 初始化并查集:起始让每个单元格独立作为一个连通块;\n* 使用 `DFS`  标记所有「边缘陆地连通块」:从位于边缘的「边缘陆地」进行出发,将其所在连通块与超级源点 $0$ 进行联通标记(同时为了确保复杂度,我们在进行 `DFS` 前需要先检查当前陆地与超级源点的联通关系,如果已联通,说明当前陆地隶属于之前的某个连通块,已被整体标记过,进行跳过即可);\n* 统计答案:遍历整个棋盘,统计所有不与超级源点 $0$ 联通的陆地数量。\n\n> 一些细节:由于我们人为规定了超级源点编号为 $0$,同时棋盘下标从 $0$ 开始,因此对某个点 $(x, y)$ 的编号,我们需要增加一个偏移量,例如 $idx = x * n + y + 1$。\n\n代码:\n```Java\nclass Solution {\n    int N = 550;\n    int[] p = new int[N * N];\n    int m, n;\n    int[][] g;\n    int find(int x) {\n        if (p[x] != x) p[x] = find(p[x]);\n        return p[x];\n    }\n    boolean query(int a, int b) {\n        return find(a) == find(b);\n    }\n    void union(int a, int b) {\n        p[find(a)] = find(b);\n    }\n    public int numEnclaves(int[][] grid) {\n        g = grid;\n        m = g.length; n = g[0].length;\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                p[getIdx(i, j)] = getIdx(i, j);\n            }\n        }\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (i == 0 || j == 0 || i == m - 1 || j == n - 1) {\n                    if (g[i][j] != 1 || query(getIdx(i, j), 0)) continue;\n                    dfs(i, j);\n                }\n            }\n        }\n        int ans = 0;\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (g[i][j] == 1 && !query(getIdx(i, j), 0)) ans++;\n            }\n        }\n        return ans;\n    }\n    int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n    void dfs(int x, int y) {\n        union(getIdx(x, y), 0);\n        for (int[] d : dirs) {\n            int nx = x + d[0], ny = y + d[1];\n            if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;\n            if (g[nx][ny] != 1 || query(getIdx(nx, ny), 0)) continue;\n            dfs(nx, ny);\n        }\n    }\n    int getIdx(int x, int y) {\n        return x * n + y + 1;\n    }\n}\n```\n* 时间复杂度:初始化并查集复杂度为 $O(m * n)$;使用 `DFS` 对边缘陆地连通块进行标记复杂度为 $O(m * n)$;统计答案复杂度为 $O(m * n)$。整体复杂度为 $O(m * n)$\n* 空间复杂度:$O(m * n)$\n\n---\n\n### 多源 BFS\n\n也可以使用「多源 `BFS`」进行求解。\n\n将所有「边缘陆地」看做与超级源点相连,起始将所有「边缘陆地」进行入队(等价于只将超级源点入队,然后取出超级源点并进行拓展)。\n\n然后是常规的 `BFS` 过程,所有能够出队/入队的陆地格子,都代表与「边缘陆地」联通,都不属于「飞地」,对其进行标记。\n\n最后遍历整个棋盘,统计所有未被标记的「陆地」格子数量即是答案。\n\n不熟悉「多源 `BFS`」的同学可以看前置 🧀 :[多源 BFS 入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487179&idx=1&sn=e30a662c03fba3861254dbcf3fb9d6f2&chksm=fd9ca5d4caeb2cc205804fd17a2ce86b25d0408adc3417e73154f59d37e7cb17e02374f5122c&token=1222269277&lang=zh_CN#rd)。\n\n代码:\n```Java\nclass Solution {\n    public int numEnclaves(int[][] g) {\n        int m = g.length, n = g[0].length;\n        boolean[][] vis = new boolean[m][n];\n        Deque<int[]> d = new ArrayDeque<>();\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (i == 0 || j == 0 || i == m - 1 || j == n - 1) {\n                    if (g[i][j] == 0) continue;\n                    vis[i][j] = true;\n                    d.addLast(new int[]{i, j});\n                }\n            }\n        }\n        int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n        while (!d.isEmpty()) {\n            int[] poll = d.pollFirst();\n            int x = poll[0], y = poll[1];\n            for (int[] di : dirs) {\n                int nx = x + di[0], ny = y + di[1];\n                if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;\n                if (g[nx][ny] != 1) continue;\n                if (vis[nx][ny]) continue;\n                vis[nx][ny] = true;\n                d.addLast(new int[]{nx, ny});\n            }\n        }\n        int ans = 0;\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (g[i][j] == 1 && !vis[i][j]) ans++;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(m * n)$\n* 空间复杂度:$O(m * n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1011` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1021-1030/1021. 删除最外层的括号（简单）.md", "url_title": "1021. 删除最外层的括号", "url": "https://leetcode.cn/problems/remove-outermost-parentheses/solution/by-ac_oier-jmxi/", "difficulty": "简单", "tags": ["模拟", "双指针"], "question": "有效括号字符串为空 `\"\"`、`\"(\" + A + \")\"` 或 `A + B` ,其中 `A` 和 `B` 都是有效的括号字符串,`+` 代表字符串的连接。\n\n例如,`\"\"`,`\"()\"`,`\"(())()\"` 和 `\"(()(()))\"` 都是有效的括号字符串。\n\n如果有效字符串 `s` 非空,且不存在将其拆分为 `s = A + B` 的方法,我们称其为原语(`primitive`),其中 `A` 和 `B` 都是非空有效括号字符串。\n\n给出一个非空有效字符串 `s`,考虑将其进行原语化分解,使得:`s = P_1 + P_2 + ... + P_k`,其中 `P_i` 是有效括号字符串原语。\n\n对 `s` 进行原语化分解,删除分解中每个原语字符串的最外层括号,返回 s 。\n\n示例 1:\n```\n输入:s = \"(()())(())\"\n\n输出:\"()()()\"\n\n解释:\n输入字符串为 \"(()())(())\",原语化分解得到 \"(()())\" + \"(())\",\n删除每个部分中的最外层括号后得到 \"()()\" + \"()\" = \"()()()\"。\n```\n示例 2:\n```\n输入:s = \"(()())(())(()(()))\"\n\n输出:\"()()()()(())\"\n\n解释:\n输入字符串为 \"(()())(())(()(()))\",原语化分解得到 \"(()())\" + \"(())\" + \"(()(()))\",\n删除每个部分中的最外层括号后得到 \"()()\" + \"()\" + \"()(())\" = \"()()()()(())\"。\n```\n示例 3:\n```\n输入:s = \"()()\"\n\n输出:\"\"\n\n解释:\n输入字符串为 \"()()\",原语化分解得到 \"()\" + \"()\",\n删除每个部分中的最外层括号后得到 \"\" + \"\" = \"\"。\n```\n\n提示:\n* $1 <= s.length <= 10^5$\n* `s[i]` 为 `'('` 或 `')'`\n* `s` 是一个有效括号字符串", "solution": "### 双指针模拟\n\n和其他「有效括号」问题一样,我们将 `(` 记为 $1$ 分,将 `)` 记为 $-1$。\n\n由于 `s` 本身为有效字符串,因此我们可以从前往后进行处理,每一次找到符合 $socre = 0$ 的连续段 $[i, j)$,然后再结合题意,删掉外层括号,即将 $[i + 1, j - 1)$ 加入答案。\n\n代码:\n```Java \nclass Solution {\n    public String removeOuterParentheses(String s) {\n        char[] cs = s.toCharArray();\n        int n = cs.length;\n        StringBuilder sb = new StringBuilder();\n        for (int i = 0, score = 0; i < n; ) {\n            int j = i;\n            while (i == j || score != 0) score += cs[j++] == '(' ? 1 : -1;\n            sb.append(s.substring(i + 1, j - 1));\n            i = j;\n            score = 0;\n        }\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1021` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1021-1030/1022. 从根到叶的二进制数之和（简单）.md", "url_title": "1022. 从根到叶的二进制数之和", "url": "https://leetcode.cn/problems/sum-of-root-to-leaf-binary-numbers/solution/by-ac_oier-1905/", "difficulty": "简单", "tags": ["DFS", "BFS", "二叉树", "树的遍历"], "question": "给出一棵二叉树,其上每个结点的值都是 $0$ 或 $1$ 。每一条从根到叶的路径都代表一个从最高有效位开始的二进制数。\n\n例如,如果路径为 `0 -> 1 -> 1 -> 0 -> 1`,那么它表示二进制数 `01101`,也就是 $13$ 。\n对树上的每一片叶子,我们都要找出从根到该叶子的路径所表示的数字。\n\n返回这些数字之和。题目数据保证答案是一个 $32$ 位 整数。\n\n示例 1:\n\n```\n输入:root = [1,0,1,0,1,0,1]\n\n输出:22\n\n解释:(100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22\n```\n示例 2:\n```\n输入:root = [0]\n\n输出:0\n```\n\n提示:\n* 树中的节点数在 $[1, 1000]$ 范围内\n* `Node.val` 仅为 $0$ 或 $1$", "solution": "### 递归\n\n容易想到「递归」进行求解,在 `DFS` 过程中记录下当前的值为多少,假设遍历到当前节点 $x$ 前,记录的值为 $cur$,那么根据题意,我们需要先将 $cur$ 进行整体左移(腾出最后一位),然后将节点 $x$ 的值放置最低位来得到新的值,并继续进行递归。\n\n递归有使用「函数返回值」和「全局变量」两种实现方式。\n\n代码:\n```Java\nclass Solution {\n    public int sumRootToLeaf(TreeNode root) {\n        return dfs(root, 0);\n    }\n    int dfs(TreeNode root, int cur) {\n        int ans = 0, ncur = (cur << 1) + root.val;\n        if (root.left != null) ans += dfs(root.left, ncur);\n        if (root.right != null) ans += dfs(root.right, ncur);\n        return root.left == null && root.right == null ? ncur : ans;\n    }\n}\n```\n\n-\n\n```Java\nclass Solution {\n    int ans = 0;\n    public int sumRootToLeaf(TreeNode root) {\n        dfs(root, 0);\n        return ans;\n    }\n    void dfs(TreeNode root, int cur) {\n        int ncur = (cur << 1) + root.val;\n        if (root.left != null) dfs(root.left, ncur);\n        if (root.right != null) dfs(root.right, ncur);\n        if (root.left == null && root.right == null) ans += ncur;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$\n\n---\n\n### 迭代\n\n自然也可以使用「迭代」进行求解。\n\n为了不引入除「队列」以外的其他数据结构,当我们可以把某个节点 $x$ 放出队列时,先将其的值修改为当前遍历路径对应的二进制数。\n\n代码:\n```Java\nclass Solution {\n    public int sumRootToLeaf(TreeNode root) {\n        int ans = 0;\n        Deque<TreeNode> d = new ArrayDeque<>();\n        d.addLast(root);\n        while (!d.isEmpty()) {\n            TreeNode poll = d.pollFirst();\n            if (poll.left != null) {\n                poll.left.val = (poll.val << 1) + poll.left.val;\n                d.addLast(poll.left);\n            }\n            if (poll.right != null) {\n                poll.right.val = (poll.val << 1) + poll.right.val;\n                d.addLast(poll.right);\n            }\n            if (poll.left == null && poll.right == null) ans += poll.val;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1022` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1031-1040/1032. 字符流（困难）.md", "url_title": "1032. 字符流", "url": "https://leetcode.cn/problems/stream-of-characters/solution/by-ac_oier-ihd4/", "difficulty": "困难", "tags": ["字典树", "枚举", "剪枝"], "question": "设计一个算法:接收一个字符流,并检查这些字符的后缀是否是字符串数组 `words` 中的一个字符串。\n\n例如,`words = [\"abc\", \"xyz\"]` 且字符流中逐个依次加入 $4$ 个字符 `'a'`、`'x'`、`'y'` 和 `'z'` ,你所设计的算法应当可以检测到 `\"axyz\"` 的后缀 `\"xyz\"` 与 `words` 中的字符串 `\"xyz\"` 匹配。\n\n按下述要求实现 `StreamChecker` 类:\n\n* `StreamChecker(String[] words)` :构造函数,用字符串数组 `words` 初始化数据结构。\n* `boolean query(char letter)`:从字符流中接收一个新字符,如果字符流中的任一非空后缀能匹配 `words` 中的某一字符串,返回 `true`;否则,返回 `false`。\n\n示例:\n```\n输入:\n[\"StreamChecker\", \"query\", \"query\", \"query\", \"query\", \"query\", \"query\", \"query\", \"query\", \"query\", \"query\", \"query\", \"query\"]\n[[[\"cd\", \"f\", \"kl\"]], [\"a\"], [\"b\"], [\"c\"], [\"d\"], [\"e\"], [\"f\"], [\"g\"], [\"h\"], [\"i\"], [\"j\"], [\"k\"], [\"l\"]]\n\n输出:\n[null, false, false, false, true, false, true, false, false, false, false, false, true]\n\n解释:\nStreamChecker streamChecker = new StreamChecker([\"cd\", \"f\", \"kl\"]);\nstreamChecker.query(\"a\"); // 返回 False\nstreamChecker.query(\"b\"); // 返回 False\nstreamChecker.query(\"c\"); // 返回n False\nstreamChecker.query(\"d\"); // 返回 True ,因为 'cd' 在 words 中\nstreamChecker.query(\"e\"); // 返回 False\nstreamChecker.query(\"f\"); // 返回 True ,因为 'f' 在 words 中\nstreamChecker.query(\"g\"); // 返回 False\nstreamChecker.query(\"h\"); // 返回 False\nstreamChecker.query(\"i\"); // 返回 False\nstreamChecker.query(\"j\"); // 返回 False\nstreamChecker.query(\"k\"); // 返回 False\nstreamChecker.query(\"l\"); // 返回 True ,因为 'kl' 在 words 中\n```\n\n提示:\n* $1 <= words.length <= 2000$\n* $1 <= words[i].length <= 200$\n* `words[i]` 由小写英文字母组成\n* `letter` 是一个小写英文字母\n* 最多调用查询 $4 \\times 10^4$ 次", "solution": "### Trie + 枚举\n\n先考虑最为简单的做法:将给定的所有 $words[i]$ 顺序插入字典树,根据数据范围可知这一步计算量为 $2000 \\times 200$,其中最大的 $words[i]$ 长度只有 $200$。\n\n然后利用$words[i]$ 长度只有 $200$ 这一条件,直接使用「枚举」的方式来实现 `query`。\n\n具体的,我们可以先使用一个字符串 `s` 来记录 `query` 操作产生的数据流,然后实现一个 `boolean query(int start, int end)` 方法,该方法会检查字典树中是否存在 $s[i...j]$ 子串。\n\n由于 $words[i]$ 长度只有 $200$(假设当前 `s` 的长度为 $n$),因此我们只需要枚举「$\\max(0, n - 200)$ 作为子串左端点,$n - 1$ 作为子串右端点」是否存在字典树中(是否存在 $words[i]$ 中)即可,最坏情况下,单次 `query` 操作计算量为 $200 \\times 200$。\n\n> 一些细节:为了避免每个样例都 `new` 大数组,我们可以使用 `static` 优化。\n\nJava 代码:\n```Java\nclass StreamChecker {\n    static int N = 2010 * 200, idx = 0;\n    static int[][] tr = new int[N][26];\n    static boolean[] isEnd = new boolean[N * 26];\n    StringBuilder sb = new StringBuilder();\n    void add(String s) {\n        int p = 0;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (tr[p][u] == 0) tr[p][u] = ++idx;\n            p = tr[p][u];\n        }\n        isEnd[p] = true;\n    }\n    boolean query(int start, int end) {\n        int p = 0;\n        for (int i = start; i <= end; i++) {\n            int u = sb.charAt(i) - 'a';\n            if (tr[p][u] == 0) return false;\n            p = tr[p][u];\n        }\n        return isEnd[p];\n    }\n    public StreamChecker(String[] words) {\n        for (int i = 0; i <= idx; i++) {\n            Arrays.fill(tr[i], 0);\n            isEnd[i] = false;\n        }\n        idx = 0;\n        for (String s : words) add(s);\n    }\n    public boolean query(char c) {\n        sb.append(c);\n        int n = sb.length(), min = Math.max(0, n - 200);\n        for (int i = n - 1; i >= min; i--) {\n            if (query(i, n - 1)) return true;\n        }\n        return false;\n    }\n}\n```\nC++ 代码:\n```C++\nclass StreamChecker {\npublic:\n    static const int N = 2010 * 200;\n    int tr[N][26];\n    bool isEnd[N];\n    string sb;\n    int idx = 0;\n    void add(const string &s) {\n        int p = 0;\n        for (char c : s) {\n            int u = c - 'a';\n            if (tr[p][u] == 0) tr[p][u] = ++idx;\n            p = tr[p][u];\n        }\n        isEnd[p] = true;\n    }\n    bool query(int start, int end) {\n        int p = 0;\n        for (int i = start; i <= end; i++) {\n            int u = sb[i] - 'a';\n            if (tr[p][u] == 0) return false;\n            p = tr[p][u];\n        }\n        return isEnd[p];\n    }\n    StreamChecker(const vector<string>& words) {\n        memset(tr, 0, sizeof(tr));\n        memset(isEnd, 0, sizeof(isEnd));\n        for (const string &s : words) add(s);\n    }\n    bool query(char c) {\n        sb.push_back(c);\n        int n = sb.length(), min = max(0, n - 200);\n        for (int i = n - 1; i >= min; i--) {\n            if (query(i, n - 1)) return true;\n        }\n        return false;\n    }\n};\n```\n* 时间复杂度:`StreamChecker` 初始化复杂度为 $O(n)$,其中 $n$ 为 `words` 字符总数;`query` 操作复杂度为 $O(m^2)$,其中 $m = 200$ 为最大 `words[i]` 长度\n* 空间复杂度:$O(n \\times C)$,其中 $n$ 为 `words` 字符总数,$C = 26$ 为字符集大小\n\n---\n\n### Trie(优化)\n\n初始化将所有的 $words[i]$ 存入 `Trie` 是必然的,我们只能考虑如何优化 `query` 操作。\n\n在解法一中,我们需要对新数据流对应的字符串的每个后缀进行搜索,同时每次搜索是相互独立的,即本次匹配不会对下一次匹配产生贡献。\n\n**实际上,我们可以通过「倒序建 `Trie`」的方式,将「枚举检查多个后缀」的操作变为「匹配一次后缀」操作。**\n\n具体的,我们可以在初始化 `StreamChecker` 时,将每个 $words[i]$ 翻转(倒序)加入 `Trie` 中;然后在 `query` 操作时(假设当前数据流对应的字符串为 `s`,长度为 $n$),从 `s` 的尾部开始在 `Trie` 中进行检索(即从 $s[n - 1]$ 开始往回找)。\n\n若在某个位置 `idx` 时匹配成功,意味着 $s[idx ... (n-1)]$ 的翻转子串在字典树中,同时我们又是将每个 `words[i]` 进行倒序插入,即意味着 $s[idx ... (n - 1)]$ 的正向子串在 `words` 中,即满足 `s` 的某个后缀出现在 `words` 中。\n\n同理,我们可以利用最大的 `words[i]` 长度为 $200$ 来控制从 $s[n - 1]$ 开始往回找的最远距离,同时利用当某个短后缀不在 `Trie` 中,则其余长度更大的后缀必然不在 `Trie` 中进行剪枝操作。\n\nJava 代码:\n```Java \nclass StreamChecker {\n    static int N = 2010 * 200, idx = 0;\n    static int[][] tr = new int[N][26];\n    static boolean[] isEnd = new boolean[N * 26];\n    StringBuilder sb = new StringBuilder();\n    void add(String s) {\n        int p = 0;\n        for (int i = s.length() - 1; i >= 0; i--) {\n            int u = s.charAt(i) - 'a';\n            if (tr[p][u] == 0) tr[p][u] = ++idx;\n            p = tr[p][u];\n        }\n        isEnd[p] = true;\n    }\n    public StreamChecker(String[] words) {\n        for (int i = 0; i <= idx; i++) {\n            Arrays.fill(tr[i], 0);\n            isEnd[i] = false;\n        }\n        idx = 0;\n        for (String s : words) add(s);\n    }\n    public boolean query(char c) {\n        sb.append(c);\n        int n = sb.length(), min = Math.max(0, n - 200), p = 0;\n        for (int i = n - 1; i >= min; i--) {\n            if (isEnd[p]) return true;\n            int u = sb.charAt(i) - 'a';\n            if (tr[p][u] == 0) return false;\n            p = tr[p][u];\n        }\n        return isEnd[p];\n    }\n}\n```\nC++ 代码:\n```C++\nclass StreamChecker {\npublic:\n    static const int N = 2010 * 200;\n    static const int ALPHABET_SIZE = 26;\n    vector<vector<int>> tr;\n    vector<bool> isEnd;\n    string sb;\n    int idx = 0;\n    void add(const string &s) {\n        int p = 0;\n        for (int i = s.length() - 1; i >= 0; i--) {\n            int u = s[i] - 'a';\n            if (tr[p].size() <= u) tr[p].resize(u + 1, 0);\n            if (tr[p][u] == 0) tr[p][u] = ++idx;\n            p = tr[p][u];\n        }\n        isEnd[p] = true;\n    }\n    StreamChecker(const vector<string>& words) {\n        tr.resize(N);\n        isEnd.resize(N);\n        fill(isEnd.begin(), isEnd.end(), false);\n        for (const auto &s : words) {\n            add(s);\n        }\n    }\n    bool query(char c) {\n        sb.push_back(c);\n        int n = sb.length(), min = max(0, n - 200), p = 0;\n        for (int i = n - 1; i >= min; i--) {\n            if (isEnd[p]) return true;\n            int u = sb[i] - 'a';\n            if (tr[p].size() <= u || tr[p][u] == 0) return false;\n            p = tr[p][u];\n        }\n        return isEnd[p];\n    }\n};\n```\n* 时间复杂度:`StreamChecker` 初始化复杂度为 $O(n)$,其中 $n$ 为 `words` 字符总数;`query` 操作复杂度为 $O(m)$,其中 $m = 200$ 为最大 `words[i]` 长度\n* 空间复杂度:$O(n \\times C)$,其中 $n$ 为 `words` 字符总数,$C = 26$ 为字符集大小", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1032` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1031-1040/1034. 边界着色（中等）.md", "url_title": "1034. 边界着色", "url": "https://leetcode-cn.com/problems/coloring-a-border/solution/gong-shui-san-xie-tu-lun-sou-suo-zhuan-t-snvw/", "difficulty": "中等", "tags": ["图论 DFS", "图论 BFS"], "question": "给你一个大小为 `m x n` 的整数矩阵 `grid`,表示一个网格。另给你三个整数 `row`、`col` 和 `color` 。网格中的每个值表示该位置处的网格块的颜色。\n\n当两个网格块的颜色相同,而且在四个方向中任意一个方向上相邻时,它们属于同一 连通分量 。\n\n连通分量的边界 是指连通分量中的所有与不在分量中的网格块相邻(四个方向上)的所有网格块,或者在网格的边界上(第一行/列或最后一行/列)的所有网格块。\n\n请你使用指定颜色 `color` 为所有包含网格块 `grid[row][col]` 的 连通分量的边界 进行着色,并返回最终的网格 `grid` 。\n\n示例 1:\n```\n输入:grid = [[1,1],[1,2]], row = 0, col = 0, color = 3\n\n输出:[[3,3],[3,2]]\n```\n示例 2:\n```\n输入:grid = [[1,2,2],[2,3,2]], row = 0, col = 1, color = 3\n\n输出:[[1,3,3],[2,3,3]]\n```\n示例 3:\n```\n输入:grid = [[1,1,1],[1,1,1],[1,1,1]], row = 1, col = 1, color = 2\n\n输出:[[2,2,2],[2,1,2],[2,2,2]]\n```\n\n提示:\n* $m == grid.length$\n* $n == grid[i].length$\n* $1 <= m, n <= 50$\n* $1 <= grid[i][j], color <= 1000$\n* $0 <= row < m$\n* $0 <= col < n$", "solution": "### 基本分析\n\n这是一道结合「阅读理解」的常规图论搜索题。\n\n基本题意为:从题目给定的 $(row, col)$ 进行出发,如果遍历到「**连通分量的边界**」格子,则使用 $color$ 进行上色。\n\n同一「连通分量」的「非边界」格子满足:**当前格子的四联通方向均存在相邻格子,且当前格子与四联通相邻格子颜色一致。**\n\n也就是说,我们从 $(row, col)$ 进行出发,遍历 $(row, col)$ 所在的「连通分量」,如果遍历到的「连通分量」格子不满足上述条件(边界格子),则进行上色。\n\n---\n\n### BFS\n\n具体的,我们可以使用 `BFS` 进行求解:\n\n* 构造 $ans$ 矩阵作为答案,同时 $ans$ 也作为判重数组使用(通过判断 $ans[i][j]$ 是否为 $0$ 来得知是否被处理);\n\n* 起始时,将 $(row, col)$ 位置进行入队,每次从队列中取出元素进行「四联通拓展」:\n  \n    * 拓展格子必须与起点格子处于同一「连通分量」,即满足两者起始颜色相同;\n    \n    * 进行「四联通拓展」的同时,记录当前出队是否为边界格子。若为边界格子,则使用 $color$ 进行上色;\n\n* 跑完 `BFS` 后,对 $ans$ 进行遍历,将未上色($ans[i][j] = 0$)的位置使用原始色($grid[i][j]$)进行上色。\n\n代码:\n```Java\nclass Solution {\n    public int[][] colorBorder(int[][] grid, int row, int col, int color) {\n        int m = grid.length, n = grid[0].length;\n        int[][] ans = new int[m][n];\n        int[][] dirs = new int[][]{{1,0}, {-1,0}, {0,1}, {0,-1}};\n        Deque<int[]> d = new ArrayDeque<>();\n        d.addLast(new int[]{row, col});\n        while (!d.isEmpty()) {\n            int[] poll = d.pollFirst();\n            int x = poll[0], y = poll[1], cnt = 0;\n            for (int[] di : dirs) {\n                int nx = x + di[0], ny = y + di[1];\n                if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;\n                if (grid[x][y] != grid[nx][ny]) continue;\n                else cnt++;\n                if (ans[nx][ny] != 0) continue;\n                d.addLast(new int[]{nx, ny});\n            }\n            ans[x][y] = cnt == 4 ? grid[x][y] : color;\n        }\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (ans[i][j] == 0) ans[i][j] = grid[i][j];\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(m * n)$\n* 空间复杂度:$O(m * n)$\n\n---\n\n### DFS\n\n同理,可以使用 `DFS` 进行求解。\n\n由于使用 `DFS`  搜索时,我们使用「栈帧压栈/弹栈」作为拓展联通节点的容器,且仅在出队时进行上色。为防止「重复入队」问题,我们需要先在对节点 $(nx, ny)$ 入队时,先设置将 $ans[nx][ny]$ 设置为 $-1$ 标识位,以作为判重依据。\n\n代码:\n```Java\nclass Solution {\n    int m, n, c;\n    int[][] grid, ans;\n    int[][] dirs = new int[][]{{1,0}, {-1,0}, {0,1}, {0,-1}};\n    public int[][] colorBorder(int[][] _grid, int row, int col, int color) {\n        grid = _grid; c = color;\n        m = grid.length; n = grid[0].length;\n        ans = new int[m][n];\n        dfs(row, col);\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (ans[i][j] == 0) ans[i][j] = grid[i][j];\n            }\n        }\n        return ans;\n    }\n    void dfs(int x, int y) {\n        int cnt = 0;\n        for (int[] di : dirs) {\n            int nx = x + di[0], ny = y + di[1];\n            if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;\n            if (grid[x][y] != grid[nx][ny]) continue;\n            else cnt++;\n            if (ans[nx][ny] != 0) continue;\n            ans[nx][ny] = -1;\n            dfs(nx, ny);\n        }\n        ans[x][y] = cnt == 4 ? grid[x][y] : c;\n    }\n}\n```\n* 时间复杂度:$O(m * n)$\n* 空间复杂度:$O(m * n)$\n\n---\n\n### 其他「图论搜索」相关内容\n\n题太简单?不如来学习热乎的 [常规 BFS 搜索题(二维转一维)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489621&idx=1&sn=5d43fb97bc167a50a7aeb4ae2068571c&chksm=fd9cb34acaeb3a5c7e1e2e2a88d460ae2418a3cef615e1abf017b5d58aa1e7f490856d67f800&token=2136593799&lang=zh_CN#rd)\n\n* [常规 BFS 搜索题(二维转一维)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489621&idx=1&sn=5d43fb97bc167a50a7aeb4ae2068571c&chksm=fd9cb34acaeb3a5c7e1e2e2a88d460ae2418a3cef615e1abf017b5d58aa1e7f490856d67f800&token=2136593799&lang=zh_CN#rd)\n* [多源 BFS](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487179&idx=1&sn=e30a662c03fba3861254dbcf3fb9d6f2&chksm=fd9ca5d4caeb2cc205804fd17a2ce86b25d0408adc3417e73154f59d37e7cb17e02374f5122c&scene=178&cur_album_id=1917113998693449732#rd)\n* [双向 BFS](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489502&idx=1&sn=dc863d4bc71c4739a4799b9a4558bd01&chksm=fd9cbcc1caeb35d749d0d72f485485527482c27b608c8f4062c29a997ede97a09ce598b58c7f&scene=178&cur_album_id=1917113998693449732#rd)\n* [双向 BFS II](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&scene=178&cur_album_id=1917113998693449732#rd)\n*  [灵活运用多种搜索方式(含启发式搜索)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489560&idx=2&sn=bb966d868c18d656620a20d31a425b23&chksm=fd9cb307caeb3a11424428f0a88e7f0cb86bb53b3e5a2b9e28683a24bcb3ac151655d2b6419e&scene=178&cur_album_id=1917113998693449732#rd)\n*  [灵活运用多种搜索方式 II(含启发式搜索)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489588&idx=1&sn=479e4c0627247ab7e20af7909f2a8b64&chksm=fd9cb32bcaeb3a3d4f0bd73f023a92a165edabf212af1db9672a55bed1af7d4e32e8af9964c3&scene=178&cur_album_id=1917113998693449732#rd)", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1034` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1031-1040/1035. 不相交的线（中等）.md", "url_title": "1035. 不相交的线", "url": "https://leetcode-cn.com/problems/uncrossed-lines/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-bkaas/", "difficulty": "中等", "tags": ["最长公共子序列", "序列 DP", "LCS"], "question": "在两条独立的水平线上按给定的顺序写下 `s1` 和 `s2` 中的整数。\n\n现在,可以绘制一些连接两个数字 $s1[i]$ 和 $s2[j]$ 的直线,这些直线需要同时满足满足:\n\n*  $s1[i] = s2[j]$\n* 且绘制的直线不与任何其他连线(非水平线)相交。\n\n请注意,连线即使在端点也不能相交:每个数字只能属于一条连线。\n\n以这种方法绘制线条,并返回可以绘制的最大连线数。\n\n \n\n示例 1:\n\n<img src=\"https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/04/28/142.png\" style=\"zoom:18%;\" />\n\n```\n输入:s1 = [1,4,2], s2 = [1,2,4]\n\n输出:2\n\n解释:可以画出两条不交叉的线,如上图所示。 \n但无法画出第三条不相交的直线,因为从 s1[1]=4 到 s2[2]=4 的直线将与从 s1[2]=2 到 s2[1]=2 的直线相交。\n```\n示例 2:\n```\n输入:s1 = [2,5,1,2,5], s2 = [10,5,2,1,5,2]\n\n输出:3\n```\n示例 3:\n```\n输入:s1 = [1,3,7,1,7,5], s2 = [1,9,2,5,1]\n\n输出:2\n```\n\n提示:\n* $1 <= s1.length <= 500$\n* $1 <= s2.length <= 500$\n* $1 <= s1[i], s2[i] <= 2000$", "solution": "### 动态规划\n\n这是一道「[最长公共子序列(LCS)](https://leetcode-cn.com/problems/longest-common-subsequence/solution/gong-shui-san-xie-zui-chang-gong-gong-zi-xq0h/)」的轻度变形题。\n\n对于这类题都使用如下「状态定义」即可:\n\n**$f[i][j]$ 代表考虑 $s1$ 的前 $i$ 个字符、考虑 $s2$ 的前 $j$ 的字符,形成的最长公共子序列长度。**\n\n然后不失一般性的考虑 $f[i][j]$ 如何转移。\n\n**由于我们的「状态定义」只是说「考虑前 $i$ 个和考虑前 $j$ 个字符」,并没有说「一定要包含第 $i$ 个或者第 $j$ 个字符」(这也是「最长公共子序列 LCS」与「最长上升子序列 LIS」状态定义上的最大不同)。**\n\n我们需要考虑「不包含 $s1[i]$,不包含 $s2[j]$」、「不包含 $s1[i]$,包含 $s2[j]$」「包含 $s1[i]$,不包含 $s2[j]$」、「包含 $s1[i]$,包含 $s2[j]$」四种情况:\n\n * 不包含 $s1[i]$,不包含 $s2[j]$:结合状态定义,可以使用 $f[i - 1][j - 1]$ 进行精确表示。\n * 包含 $s1[i]$,包含 $s2[j]$:前提是 $s1[i] = s2[j]$,可以使用 $f[i - 1][j - 1] + 1$ 进行精确表示。\n * 不包含 $s1[i]$,包含 $s2[j]$:结合状态定义,我们无法直接将该情况表示出来。\n    **注意 $f[i - 1][j]$ 只是表示「必然不包含 $s1[i]$,但可能包含$s2[j]$」的情况,也就是说 $f[i - 1][j]$ 其实是该情况与情况 $1$ 的合集**。\n    但是由于我们求的是「最大值」,只需要确保「不漏」即可保证答案的正确(某些情况被重复参与比较不影响正确性),因此这里直接使用 $f[i - 1][j]$ 进行表示没有问题。\n* 包含 $s1[i]$,不包含 $s2[j]$:与情况 $3$ 同理,直接使用 $f[i][j - 1]$ 表示没有问题。\n\n$f[i][j]$ 就是在上述所有情况中取 $max$ 而来,由于情况 $1$ 被 情况 $3$ 和 情况 $4$ 所包含,因此我们只需要考虑 $f[i - 1][j]$、$f[i][j -1]$ 和 $f[i - 1][j - 1] + 1$ 三种状态即可,其中最后一种状态需要满足 $s1[i] = s2[j]$ 前提条件。\n\n因此我们最后的状态转移方程为:\n\n$$\nf[i][j]=\\begin{cases}\n\\max(f[i - 1][j], f[i][j - 1], f[i - 1][j - 1] + 1) & s1[i] = s2[j] \\\\\n\\max(f[i - 1][j], f[i][j - 1]) & s1[i] \\neq s2[j] \\\\\n\\end{cases}\n$$\n\n上述分析过程建议加深理解,估计很多同学能 AC 但其实并不知道 LCS 问题的状态转移是包含了「重复状态比较」的。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxUncrossedLines(int[] s1, int[] s2) {\n        int n = s1.length, m = s2.length;\n        int[][] f = new int[n + 1][m + 1];\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);\n                if (s1[i - 1] == s2[j - 1]) {\n                    f[i][j] = Math.max(f[i][j], f[i - 1][j - 1] + 1);\n                }\n            }\n        }\n        return f[n][m];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxUncrossedLines(vector<int>& s1, vector<int>& s2) {\n        int n = s1.size(), m = s2.size();\n        vector<vector<int>> f(n + 1, vector<int>(m + 1, 0));\n        for (int i = 1; i <= n; ++i) {\n            for (int j = 1; j <= m; ++j) {\n                f[i][j] = max(f[i - 1][j], f[i][j - 1]);\n                if (s1[i - 1] == s2[j - 1]) {\n                    f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1);\n                }\n            }\n        }\n        return f[n][m];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxUncrossedLines(self, s1: List[int], s2: List[int]) -> int:\n        n, m = len(s1), len(s2)\n        f = [[0] * (m + 1) for _ in range(n + 1)]\n        for i in range(1, n + 1):\n            for j in range(1, m + 1):\n                f[i][j] = max(f[i - 1][j], f[i][j - 1])\n                if s1[i - 1] == s2[j - 1]:\n                    f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1)\n        return f[n][m]\n```\nTypeScript 代码:\n```TypeScript\nfunction maxUncrossedLines(s1: number[], s2: number[]): number {\n    const n = s1.length, m = s2.length;\n    const f = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));\n    for (let i = 1; i <= n; ++i) {\n        for (let j = 1; j <= m; ++j) {\n            f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);\n            if (s1[i - 1] === s2[j - 1]) {\n                f[i][j] = Math.max(f[i][j], f[i - 1][j - 1] + 1);\n            }\n        }\n    }\n    return f[n][m];\n};\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n \\times m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1035` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1031-1040/1036. 逃离大迷宫（困难）.md", "url_title": "1036. 逃离大迷宫", "url": "https://leetcode-cn.com/problems/escape-a-large-maze/solution/gong-shui-san-xie-bfs-gei-ding-zhang-ai-8w63o/", "difficulty": "困难", "tags": ["几何", "BFS"], "question": "在一个 $10^6 \\times 10^6$ 的网格中,每个网格上方格的坐标为 $(x, y)$ 。\n\n现在从源方格 $source = [s_x, s_y]$ 开始出发,意图赶往目标方格 $target = [t_x, t_y]$ 。\n\n数组 $blocked$ 是封锁的方格列表,其中每个 $blocked[i] = [x_i, y_i]$ 表示坐标为 $(x_i, y_i)$ 的方格是禁止通行的。\n\n每次移动,都可以走到网格中在四个方向上相邻的方格,只要该方格 不 在给出的封锁列表 $blocked$ 上。同时,不允许走出网格。\n\n只有在可以通过一系列的移动从源方格 $source$ 到达目标方格 $target$ 时才返回 $true$。否则,返回 $false$。\n\n示例 1:\n```\n输入:blocked = [[0,1],[1,0]], source = [0,0], target = [0,2]\n\n输出:false\n\n解释:\n从源方格无法到达目标方格,因为我们无法在网格中移动。\n无法向北或者向东移动是因为方格禁止通行。\n无法向南或者向西移动是因为不能走出网格。\n```\n示例 2:\n```\n输入:blocked = [], source = [0,0], target = [999999,999999]\n\n输出:true\n\n解释:\n因为没有方格被封锁,所以一定可以到达目标方格。\n```\n\n提示:\n* $0 <= blocked.length <= 200$\n* $blocked[i].length == 2$\n* $0 <= xi, yi < 10^6$\n* $source.length == target.length == 2$\n* $0 <= sx, sy, tx, ty < 10^6$\n* $source != target$\n* 题目数据保证 $source$ 和 $target$ 不在封锁列表内", "solution": "### BFS + 给定障碍物所能围成的最大面积\n\n为了方便,我们用 $s$ 代指 $source$,用 $t$ 代指 $target$,用 $n$ 来代指 $blocked$ 大小。\n\n整理题意为:在一个足够大的空间里,有少数的障碍物,问两点是否连通。\n\n当两点相隔较远时,常规的 `BFS` 做法可能会搜完整个棋盘,而棋盘大小为 $10^6 \\times 10^6$,会 `TLE`。\n\n考虑什么情况下两点会不连通?\n\n当两个点中的任意一点被障碍物围住时,两点将无法连通。\n\n一个很容易想到的思路是:**从 $s$ 跑一遍 `BFS`,然后从 $t$ 跑一遍 `BFS`,同时设定一个最大访问点数量 `MAX`,若从两者出发能够访问的点数量都能超过 `MAX`,说明两点均没有被围住,最终必然会联通。**\n\n考虑如何敲定 `MAX`  的取值范围?直观感受,`MAX` 应该是一个与 $blocked$ 大小相关的数。\n\n但第一反应还是想从单秒计算量上界进行反推,两边 `BFS`  的复杂度均为 $O(\\max)$,因此直接设定 `MAX = 1e5` 应该是比较合适的。\n\n更小的 `MAX` 需要证明:**在给定数量障碍物的前提下,障碍物所能围成的最大面积为多少。**\n\n首先,容易想到:**任何一条封闭图形的直边都可以通过调整为斜边来围成更大的面积:**\n\n**即组成封闭图形的边不可能有直边,同时由于是封闭图形,因此斜边直接必然是单点衔接,而不可能是平行(无法封闭)。**\n\n同时,**想要达到最大面积,应当尽可能利用边界作为围成图形的某些边。**\n\n利用边界所能围成的最大封面图形 **可以是**「由边界提供两边,障碍物提供一边的三角形」。\n\n如果不是该形状,则可以通过调整障碍物的直边为一条完整的斜边,来组成封闭三角形,围成面积不会变小:\n\n即给定 $n$ 的情况下,根据「等差数列求和」可知,最大所能围成的面积为 $1 + 2 + ... + n - 1 = \\frac{n \\times (n - 1)}{2}$。\n\n因此如果从 $s$ 和 $t$ 出发,能够访问的点数超过 $\\frac{n \\times (n - 1)}{2}$ 个,那么两点并没有被围住,必然联通。\n\n最后,为了在 `BFS` 过程中记录某些点被访问过,可以通过计算某个位置哈希值(数值)来实现。\n\n**代码(感谢 [@🍭可乐可乐吗QAQ](/u/littletime_cc/) 和 [@Benhao](/u/himymben/) 同学提供的其他语言版本):**\n```Java\nclass Solution {\n    int EDGE = (int)1e6, MAX = (int)1e5;\n    long BASE = 131L;\n    Set<Long> set = new HashSet<>();\n    int[][] dir = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n    public boolean isEscapePossible(int[][] blocked, int[] s, int[] t) {\n        for (int[] p : blocked) set.add(p[0] * BASE + p[1]);\n        int n = blocked.length;\n        MAX = n * (n - 1) / 2; // 可直接使用 1e5\n        return check(s, t) && check(t, s);\n    }\n    boolean check(int[] a, int[] b) {\n        Set<Long> vis = new HashSet<>();\n        Deque<int[]> d = new ArrayDeque<>();\n        d.addLast(a);\n        vis.add(a[0] * BASE + a[1]);\n        while (!d.isEmpty() && vis.size() <= MAX) {\n            int[] poll = d.pollFirst();\n            int x = poll[0], y = poll[1];\n            if (x == b[0] && y == b[1]) return true;\n            for (int[] di : dir) {\n                int nx = x + di[0], ny = y + di[1];\n                if (nx < 0 || nx >= EDGE || ny < 0 || ny >= EDGE) continue;\n                long hash = nx * BASE + ny;\n                if (set.contains(hash)) continue;\n                if (vis.contains(hash)) continue;\n                d.addLast(new int[]{nx, ny});\n                vis.add(hash);\n            }\n        }\n        return vis.size() > MAX;\n    }\n}\n```\n\n-\n\n```C++\nclass Solution {\npublic:\n    int EDGE = 1e6, MAX = 1e5;\n    long long BASE = 13331;\n    unordered_set<long long> set;\n    int dir[4][2] = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };\n    bool isEscapePossible(vector<vector<int>>& blocked, vector<int>& s, vector<int>& t) {\n        for(auto& p : blocked) set.insert(p[0] * BASE + p[1]);\n        int n = blocked.size();\n        MAX = n * (n - 1) / 2; // 可直接使用 1e5\n        return check(s, t) and check(t, s);\n    }\n    bool check(vector<int>& a, vector<int>& b){\n        unordered_set<long long> vis;\n        queue< pair<int,int> > q;\n        q.push( {a[0], a[1]});\n        vis.insert(a[0] * BASE + a[1]);\n        while(q.size() and vis.size() <= MAX){\n            auto t = q.front();\n            q.pop();\n            int x = t.first, y = t.second;\n            if(x == b[0] and y == b[1]) return true;\n            for(int i = 0; i < 4; i++){\n                int nx = x + dir[i][0], ny = y + dir[i][1];\n                if(nx < 0 or nx >= EDGE or ny < 0 or ny >= EDGE) continue;\n                if(set.count(nx * BASE + ny)) continue;\n                if(vis.count(nx * BASE + ny)) continue;\n                q.push( {nx, ny} );\n                vis.insert(nx * BASE + ny);\n            }\n        }\n        return vis.size() > MAX;\n    }\n};\n```\n\n-\n\n```Python\nEDGE, MAX, BASE, DIR = int(1e6), int(1e5), 131, [(1, 0), (-1, 0), (0, 1), (0, -1)]\nclass Solution:\n    def isEscapePossible(self, blocked: List[List[int]], source: List[int], target: List[int]) -> bool:\n        block = {p[0] * BASE + p[1] for p in blocked}\n        n = len(blocked)\n        MAX = n * (n-1)//2 # 可直接使用 1e5\n        def check(a, b):\n            vis = {a[0] * BASE + a[1]}\n            d = deque([a])\n            while len(d) and len(vis) <= MAX:\n                x, y = d.popleft()\n                if x == b[0] and y == b[1]:\n                    return True\n                for dx, dy in DIR:\n                    nx, ny = x + dx, y + dy\n                    if nx < 0 or nx >= EDGE or ny < 0 or ny >= EDGE:\n                        continue\n                    h = nx * BASE + ny\n                    if h in block or h in vis:\n                        continue\n                    d.append((nx, ny))\n                    vis.add(h)\n            return len(vis) > MAX\n        return check(source, target) and check(target, source)\n```\n* 时间复杂度:令 $n$ 为 $blocked$ 大小,两次 `BFS` 的最大访问点数为 $\\frac{n \\times (n - 1)}{2}$。整体复杂度为 $O(n^2)$\n* 空间复杂度:两次 `BFS` 的最大访问点数为 $\\frac{n \\times (n - 1)}{2}$。整体复杂度为 $O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1036` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1031-1040/1037. 有效的回旋镖（简单）.md", "url_title": "1037. 有效的回旋镖", "url": "https://leetcode.cn/problems/valid-boomerang/solution/by-ac_oier-eory/", "difficulty": "简单", "tags": ["计算几何", "数学"], "question": "给定一个数组 `points`,其中 $points[i] = [x_i, y_i]$ 表示 `X-Y` 平面上的一个点,如果这些点构成一个 回旋镖 则返回 `true`。\n\n回旋镖 定义为一组三个点,这些点 各不相同 且 不在一条直线上 。\n\n示例 1:\n```\n输入:points = [[1,1],[2,3],[3,2]]\n\n输出:true\n```\n示例 2:\n```\n输入:points = [[1,1],[2,2],[3,3]]\n\n输出:false\n```\n\n提示:\n* $points.length == 3$\n* $points[i].length == 2$\n* $0 <= x_i, y_i <= 100$", "solution": "### 计算几何\n\n共三个点,分别使用两个点计算向量,随后判断向量叉积是否为 $0$。\n\n代码:\n```Java\nclass Solution {\n    public boolean isBoomerang(int[][] ps) {\n        return (ps[1][0] - ps[0][0]) * (ps[2][1] - ps[0][1]) != (ps[2][0] - ps[0][0]) * (ps[1][1] - ps[0][1]);\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1037` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1031-1040/1038. 从二叉搜索树到更大和树（中等）.md", "url_title": "1038. 从二叉搜索树到更大和树", "url": "https://leetcode.cn/problems/binary-search-tree-to-greater-sum-tree/solutions/2552959/gong-shui-san-xie-bst-de-zhong-xu-bian-l-vtu1/", "difficulty": "中等", "tags": ["BST", "中序遍历"], "question": "给定一个二叉搜索树 `root` (BST),请将它的每个节点的值替换成树中大于或者等于该节点值的所有节点值之和。\n\n提醒一下, 二叉搜索树满足下列约束条件:\n\n* 节点的左子树仅包含键小于节点键的节点。\n* 节点的右子树仅包含键大于节点键的节点。\n* 左右子树也必须是二叉搜索树。\n\n示例 1:\n\n```\n输入:[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]\n\n输出:[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]\n```\n示例 2:\n```\n输入:root = [0,null,1]\n\n输出:[1,null,1]\n```\n\n提示:\n* 树中的节点数在 $[1, 100]$ 范围内。\n* $0 <= Node.val <= 100$\n* 树中的所有值均不重复 。", "solution": "### 中序遍历\n\n利用 **`BST` 的中序遍历是有序** 的特性,我们可以通过两次遍历 `BST` 来求解问题。\n\n首先,通过一次遍历,计算出整棵树的节点总和 `tot`,然后在中序遍历过程中,不断对 `tot` 进行更新,将其作为当前未遍历到的节点的总和,用于给当前节点赋值。\n\n假设当前遍历到的节点为 `x`(起始节点值为 `t`),那么将节点更新为当前节点 `tot` 后,更新 `tot = tot - t`。\n\n这是常规的中序遍历做法,更进一步,如果将其中序遍历的顺序进行翻转(从「左中右」调整为「右中左」),则可实现一次遍历。\n\nJava 代码:\n```Java\nclass Solution {\n    int tot = 0;\n    public TreeNode bstToGst(TreeNode root) {\n        dfs(root);\n        return root;\n    }\n    void dfs(TreeNode root) {\n        if (root == null) return ;\n        dfs(root.right);\n        tot += root.val;\n        root.val = tot;\n        dfs(root.left);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int tot = 0;\n    TreeNode* bstToGst(TreeNode* root) {\n        dfs(root);\n        return root;\n    }\n    void dfs(TreeNode* root) {\n        if (root == nullptr) return;\n        dfs(root->right);\n        tot += root->val;\n        root->val = tot;\n        dfs(root->left);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def bstToGst(self, root: TreeNode) -> TreeNode:\n        tot = 0\n        def dfs(root):\n            nonlocal tot\n            if not root: return\n            dfs(root.right)\n            tot += root.val\n            root.val = tot\n            dfs(root.left)\n        dfs(root)\n        return root\n```\nTypeScript 代码:\n```TypeScript\nfunction bstToGst(root: TreeNode | null): TreeNode | null {\n    let tot = 0;\n    const dfs = function(root: TreeNode | null): void {\n        if (!root) return ;\n        dfs(root.right);\n        tot += root.val;\n        root.val = tot;\n        dfs(root.left);\n    }\n    dfs(root);\n    return root;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1038` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1041-1050/1041. 困于环中的机器人（中等）.md", "url_title": "1041. 困于环中的机器人", "url": "https://leetcode.cn/problems/robot-bounded-in-circle/solution/gong-shui-san-xie-chang-gui-mo-ni-ti-by-hgdtp/", "difficulty": "中等", "tags": ["模拟", "脑筋急转弯"], "question": "在无限的平面上,机器人最初位于 $(0, 0)$ 处,面朝北方。注意:\n\n* 北方向 是 `y` 轴的正方向。\n* 南方向 是 `y` 轴的负方向。\n* 东方向 是 `x` 轴的正方向。\n* 西方向 是 `x` 轴的负方向。\n\n机器人可以接受下列三条指令之一:\n\n* `\"G\"`:直走 $1$ 个单位\n* `\"L\"`:左转 $90$ 度\n* `\"R\"`:右转 $90$ 度\n\n机器人按顺序执行指令 `instructions`,并一直重复它们。\n\n只有在平面中存在环使得机器人永远无法离开时,返回 `true`。否则,返回 `false`。\n\n示例 1:\n```\n输入:instructions = \"GGLLGG\"\n\n输出:true\n\n解释:机器人最初在(0,0)处,面向北方。\n“G”:移动一步。位置:(0,1)方向:北。\n“G”:移动一步。位置:(0,2).方向:北。\n“L”:逆时针旋转90度。位置:(0,2).方向:西。\n“L”:逆时针旋转90度。位置:(0,2)方向:南。\n“G”:移动一步。位置:(0,1)方向:南。\n“G”:移动一步。位置:(0,0)方向:南。\n重复指令,机器人进入循环:(0,0)——>(0,1)——>(0,2)——>(0,1)——>(0,0)。\n在此基础上,我们返回true。\n```\n示例 2:\n```\n输入:instructions = \"GG\"\n\n输出:false\n\n解释:机器人最初在(0,0)处,面向北方。\n“G”:移动一步。位置:(0,1)方向:北。\n“G”:移动一步。位置:(0,2).方向:北。\n重复这些指示,继续朝北前进,不会进入循环。\n在此基础上,返回false。\n```\n示例 3:\n```\n输入:instructions = \"GL\"\n\n输出:true\n\n解释:机器人最初在(0,0)处,面向北方。\n“G”:移动一步。位置:(0,1)方向:北。\n“L”:逆时针旋转90度。位置:(0,1).方向:西。\n“G”:移动一步。位置:(- 1,1)方向:西。\n“L”:逆时针旋转90度。位置:(- 1,1)方向:南。\n“G”:移动一步。位置:(- 1,0)方向:南。\n“L”:逆时针旋转90度。位置:(- 1,0)方向:东方。\n“G”:移动一步。位置:(0,0)方向:东方。\n“L”:逆时针旋转90度。位置:(0,0)方向:北。\n重复指令,机器人进入循环:(0,0)——>(0,1)——>(- 1,1)——>(- 1,0)——>(0,0)。\n在此基础上,我们返回true。\n```\n\n提示:\n* $1 <= instructions.length <= 100$\n* `instructions[i]` 仅包含 `'G'`, `'L'`, `'R'`", "solution": "### 模拟\n\n为了方便,将 `instructions` 记为 `s`,“北西南东”四个方向分别记为“上左下右”四个逆时针方向。\n\n起始位置在 $(0,0)$,方向为上,我们可以将「位置 + 方向」统称为「状态」。\n\n所谓“循环”,则是指执行若干次的 `s` 后,会回到相同的状态。\n\n我们可以按 `s` 执行一遍,假设执行完所在位置为 $(x, y)$,所在位置为 $k$,先根据 **位置** 分情况讨论:\n\n1. $(x, y)$ 为 $(0, 0)$,此时无论执行一遍后的方向为何值,必然能在若干次执行后回到起始状态。\n\n   即只需要确保 `(n * k) % 4` 为 $0$ 即可,机器人会陷入循环;\n\n2. $(x, y)$ 不为 $(0, 0)$,再根据 **方向** 进一步分情况讨论:\n\n   * 方向为上:每执行一遍 `s` 指令,位置变化为 $(x, y)$,方向不变。\n\n     那么执行 $n$ 遍后位置为 $(n \\times x, n \\times y)$,其中 $n$ 为正整数,并且 $x$ 和 $y$ 不同时为 $0$,因此随着执行次数增加,位置会离 $(0, 0)$ 越来越远,机器人不会陷入循环;\n\n   * 方向为下:每执行一遍 `s` 指令,位置变化为 $(x, y)$,方向翻转。\n\n     如果再执行一遍,由于再次执行时的方向与起始方向相反,因此位置变化为 $(-x, -y)$,同时方向再次翻转(与起始方向一致)。即执行偶数次后,会回到起始状态,机器人会陷入循环;\n\n   * 方向为左:每执行一遍 `s` 指令,位置变化为 $(x, y)$,方向为逆时针 $90$ 度。\n\n     如果执行第二次,位置变化为 $(-y, x)$,方向再逆时针 $90$ 度(与起始方向相反);执行第三次,位置变化为 $(-x, -y)$,方向再逆时针 $90$ 度(与起始方向呈顺时针 $90$ 度),该次变化会和首次执行相互抵消;执行第四次,位置变化为 $(y, -x)$,方向再逆时针 $90$ 度(与起始方向相同),该次变化与第二次执行相互抵消。总的位置变化为 $(0, 0)$,同时方向与起始方向一致,机器人会陷入循环;\n\n   * 方向为右:与「方向为左」同理,机器人会陷入循环。\n\n综上,只要执行一遍 `s` 后所在位置为 $(0, 0)$ 或方向不为上,均可确保循环发生。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean isRobotBounded(String s) {\n        int x = 0, y = 0, d = 0;\n        int[][] dirs = new int[][]{{0,1}, {-1,0}, {0,-1}, {1,0}};\n        for (char c : s.toCharArray()) {\n            if (c == 'G') {\n                x += dirs[d][0]; y += dirs[d][1];\n            } else if (c == 'L') {\n                d = (d + 1) % 4;\n            } else {\n                d = ((d - 1) % 4 + 4) % 4;\n            }\n        }\n        return (x == 0 && y == 0) || d != 0;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool isRobotBounded(string s) {\n        int x = 0, y = 0, d = 0;\n        int dirs[4][2] = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}};\n        for (char c : s) {\n            if (c == 'G') {\n                x += dirs[d][0]; y += dirs[d][1];\n            } else if (c == 'L') {\n                d = (d + 1) % 4;\n            } else {\n                d = ((d - 1) % 4 + 4) % 4;\n            }\n        }\n        return (x == 0 && y == 0) || d != 0;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def isRobotBounded(self, s: str) -> bool:\n        x, y, d = 0, 0, 0\n        dirs = [[0, 1], [-1, 0], [0, -1], [1, 0]]\n        for c in s:\n            if c == 'G':\n                x += dirs[d][0]\n                y += dirs[d][1]\n            elif c == 'L':\n                d = (d + 1) % 4\n            else:\n                d = ((d - 1) % 4 + 4) % 4\n        return (x == 0 and y == 0) or d != 0\n```\nGo 代码:\n```Go\nfunc isRobotBounded(s string) bool {\n    x, y, d := 0, 0, 0\n    dirs := [][]int{{0, 1}, {-1, 0}, {0, -1}, {1, 0}}\n    for _, c := range s {\n        if c == 'G' {\n            x += dirs[d][0]\n            y += dirs[d][1]\n        } else if c == 'L' {\n            d = (d + 1) % 4\n        } else {\n            d = ((d - 1) % 4 + 4) % 4\n        }\n    }\n    return (x == 0 && y == 0) || d != 0\n}\n```\nTypeScript 代码:\n```TypeScript \nfunction isRobotBounded(s: string): boolean {\n    let x = 0, y = 0, d = 0;\n    const dirs: number[][] = [[0, 1], [-1, 0], [0, -1], [1, 0]];\n    for (const c of s) {\n        if (c === 'G') {\n            x += dirs[d][0];\n            y += dirs[d][1];\n        } else if (c === 'L') {\n            d = (d + 1) % 4;\n        } else {\n            d = ((d - 1) % 4 + 4) % 4;\n        }\n    }\n    return (x === 0 && y === 0) || d !== 0;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1041` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1041-1050/1044. 最长重复子串（困难）.md", "url_title": "1044. 最长重复子串", "url": "https://leetcode-cn.com/problems/longest-duplicate-substring/solution/gong-shui-san-xie-zi-fu-chuan-ha-xi-ying-hae9/", "difficulty": "困难", "tags": ["字符串哈希", "二分", "后缀数组"], "question": "给你一个字符串 `s` ,考虑其所有 重复子串 :即 `s` 的连续子串,在 `s` 中出现 $2$ 次或更多次。这些出现之间可能存在重叠。\n\n返回 任意一个 可能具有最长长度的重复子串。如果 `s` 不含重复子串,那么答案为 `\"\"` 。 \n\n示例 1:\n```\n输入:s = \"banana\"\n\n输出:\"ana\"\n```\n示例 2:\n```\n输入:s = \"abcd\"\n\n输出:\"\"\n```\n\n提示:\n* $2 <= s.length <= 3 * 10^4$\n* `s` 由小写英文字母组成", "solution": "### 字符串哈希 + 二分\n\n题目要求得「能取得最大长度的任一方案」,首先以「最大长度」为分割点的数轴具有「二段性」:\n\n* 小于等于最大长度方案均存在(考虑在最大长度方案上做删减);\n* 大于最大长度的方案不存在。\n\n二分范围为 $[0, n]$,关键在于如何 `check` 函数,即实现「检查某个长度 $len$ 作为最大长度,是否存在合法方案」。\n\n对于常规做法而言,可枚举每个位置作为起点,得到长度为 $len$ 的子串,同时使用 `Set<String>` 容器记录已被处理过子串有哪些,当容器中出现过当前子串,说明存在合法方案。\n\n但是该做法实现的 `check` 并非线性,子串的生成和存入容器的时执行的哈希函数执行均和子串长度相关,复杂度是 $O(n * len)$。\n\n我们可以通过「字符串哈希」进行优化,对「字符串哈希」不熟悉的同学可以看前置 🧀 [字符串哈希入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489813&idx=1&sn=7f3bc18ca390d85b17655f7164d8e660&chksm=fd9cb20acaeb3b1cc78abf05d6fea6d093098998ce877f799ac478247604bd267fbee6fcd989&token=1342991619&lang=zh_CN#rd)。\n\n具体的,在二分前先通过 $O(n)$ 的复杂度预处理出哈希数组,从而确保能够在 `check` 时能够 $O(1)$ 得到某个子串的哈希值,最终将 `check` 的复杂度降为 $O(n)$。\n\n代码:\n```Java\nclass Solution {\n    long[] h, p;\n    public String longestDupSubstring(String s) {\n        int P = 1313131, n = s.length();\n        h = new long[n + 10]; p = new long[n + 10];\n        p[0] = 1;\n        for (int i = 0; i < n; i++) {\n            p[i + 1] = p[i] * P;\n            h[i + 1] = h[i] * P + s.charAt(i);\n        }\n        String ans = \"\";\n        int l = 0, r = n;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            String t = check(s, mid);\n            if (t.length() != 0) l = mid;\n            else r = mid - 1;\n            ans = t.length() > ans.length() ? t : ans;\n        }\n        return ans;\n    }\n    String check(String s, int len) {\n        int n = s.length();\n        Set<Long> set = new HashSet<>();\n        for (int i = 1; i + len - 1 <= n; i++) {\n            int j = i + len - 1;\n            long cur = h[j] - h[i - 1] * p[j - i + 1];\n            if (set.contains(cur)) return s.substring(i - 1, j);\n            set.add(cur);\n        }\n        return \"\";\n    }\n}\n```\n* 时间复杂度:令 $n$ 为字符串 `s` 的长度,预处理出哈希数组的复杂度为 $O(n)$;二分最大长度的复杂度为 $O(n\\log{n})$;整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 后缀数组 \n\n另外一个较为进阶的做法是使用「后缀数组」,后缀数组有基于基数排序的倍增实现,复杂度为 $O(n\\log{n})$,也有基于 `DC3` 的 $O(n)$ 做法。\n\n`DC3` 的做法已经写不出来了,写一个基于「基数排序」的倍增做法。\n\n后缀数组包含几个核心数组:\n\n* `sa` 数组:字典序排名为 $i$ 的后缀是第几个;\n* `rk` 数组:第 $i$ 个后缀的排名是多少(不难发现 `rk` 与 `sa` 满足 $sa[rk[i]] = rk[sa[i]] = i$);\n* `height` 数组:存储 $sa[i]$ 与 $sa[i - 1]$ 的 `LCP(最长公共前缀)` 为何值。\n\n代码:\n```Java\nclass Solution {\n    int N = 30010;\n    int[] x = new int[N], y = new int[N], c = new int[N];\n    int[] sa = new int[N], rk = new int[N], height = new int[N];\n    void swap(int[] a, int[] b) {\n        int n = a.length;\n        int[] c = a.clone();\n        for (int i = 0; i < n; i++) a[i] = b[i];\n        for (int i = 0; i < n; i++) b[i] = c[i];\n    }\n    public String longestDupSubstring(String s) {\n        int n = s.length(), m = 128;\n        s = \" \" + s;\n        char[] cs = s.toCharArray();\n        // sa:两遍基数排序,板子背不下来也可以直接使用 sort,复杂度退化到 n \\log^2 n\n        for (int i = 1; i <= n; i++) {\n            x[i] = cs[i]; c[x[i]]++;\n        }\n        for (int i = 2; i <= m; i++) c[i] += c[i - 1];\n        for (int i = n; i > 0; i--) sa[c[x[i]]--] = i;\n        for (int k = 1; k <= n; k <<= 1) {\n            int cur = 0;\n            for (int i = n - k + 1; i <= n; i++) y[++cur] = i;\n            for (int i = 1; i <= n; i ++) {\n                if (sa[i] > k) y[++cur] = sa[i] - k;\n            }\n            for (int i = 1; i <= m; i++) c[i] = 0;\n            for (int i = 1; i <= n; i++) c[x[i]]++;\n            for (int i = 2; i <= m; i++) c[i] += c[i - 1];\n            for (int i = n; i > 0; i--) {\n                sa[c[x[y[i]]]--] = y[i];\n                y[i] = 0;\n            }\n            swap(x, y);\n            x[sa[1]] = cur = 1;\n            for (int i = 2; i <= n; i++) {\n                if (y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k]) x[sa[i]] = cur;\n                else x[sa[i]] = ++cur;\n            }\n            if (cur == n) break;\n            m = cur;\n        }\n        // height\n        int k = 0;\n        for (int i = 1; i <= n; i ++) rk[sa[i]] = i;\n        for (int i = 1; i <= n; i++) {\n            if (rk[i] == 1) continue;\n            int j = sa[rk[i] - 1];\n            k = k > 0 ? k - 1 : k;\n            while (i + k <= n && j + k <= n && cs[i + k] == cs[j + k]) k++;\n            height[rk[i]] = k;\n        }\n        int idx = -1, max = 0;\n        for (int i = 1; i <= n; i++) {\n            if (height[i] > max) {\n                max = height[i];\n                idx = sa[i];\n            }\n        }\n        return max == 0 ? \"\" : s.substring(idx, idx + max);\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1044` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1041-1050/1047. 删除字符串中的所有相邻重复项（简单）.md", "url_title": "1047. 删除字符串中的所有相邻重复项", "url": "https://leetcode-cn.com/problems/remove-all-adjacent-duplicates-in-string/solution/cong-30-dao-100wu-chong-shi-xian-jie-jue-vkah/", "difficulty": "简单", "tags": ["队列", "模拟"], "question": "给出由小写字母组成的字符串 S,重复项删除操作会选择两个相邻且相同的字母,并删除它们。\n\n在 S 上反复执行重复项删除操作,直到无法继续删除。\n\n在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。\n\n示例:\n```\n输入:\"abbaca\"\n输出:\"ca\"\n解释:\n例如,在 \"abbaca\" 中,我们可以删除 \"bb\" 由于两字母相邻且相同,这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 \"aaca\",其中又只有 \"aa\" 可以执行重复项删除操作,所以最后的字符串为 \"ca\"。\n```\n\n提示:\n* 1 <= S.length <= 20000\n* S 仅由小写英文字母组成。", "solution": "### (自带) 栈解法\n\n```java\nclass Solution {\n    public String removeDuplicates(String s) {\n        char[] cs = s.toCharArray();\n        Deque<Character> d = new ArrayDeque<>();\n        for (char c : cs) {\n            if (!d.isEmpty() && d.peekLast().equals(c)) {\n                d.pollLast();\n            } else {\n                d.addLast(c);\n            }\n        }\n        StringBuilder sb = new StringBuilder();\n        while (!d.isEmpty()) sb.append(d.pollLast());\n        sb.reverse();\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### (数组模拟) 栈解法\n\n```java\nclass Solution {\n    public String removeDuplicates(String s) {\n        char[] cs = s.toCharArray();\n        char[] d = new char[s.length()];\n        int hh = 0, tt = -1;\n        for (char c : cs) {\n            if (hh <= tt && d[tt] == c) {\n                tt--;\n            } else {\n                d[++tt] = c;\n            }\n        }  \n        StringBuilder sb = new StringBuilder();\n        while (hh <= tt) sb.append(d[tt--]);\n        sb.reverse();\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### (自带) 双端队列解法\n\n```java\nclass Solution {\n    public String removeDuplicates(String s) {\n        char[] cs = s.toCharArray();\n        Deque<Character> d = new ArrayDeque<>();\n        for (char c : cs) {\n            if (!d.isEmpty() && d.peekLast().equals(c)) {\n                d.pollLast();\n            } else {\n                d.addLast(c);\n            }\n        }\n        StringBuilder sb = new StringBuilder();\n        while (!d.isEmpty()) sb.append(d.pollFirst());\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### (数组模拟) 双端队列解法\n\n```java\nclass Solution {\n    public String removeDuplicates(String s) {\n        char[] cs = s.toCharArray();\n        char[] d = new char[s.length()];\n        int hh = 0, tt = -1;\n        for (char c : cs) {\n            if (hh <= tt && d[tt] == c) {\n                tt--;\n            } else {\n                d[++tt] = c;\n            }\n        }  \n        StringBuilder sb = new StringBuilder();\n        while (hh <= tt) sb.append(d[hh++]);\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 纯数组解法\n\n```java\nclass Solution {\n    public String removeDuplicates(String s) {\n        char[] cs = s.toCharArray();\n        char[] d = new char[s.length()];\n        int hh = 0, tt = -1;\n        for (char c : cs) {\n            if (hh <= tt && d[tt] == c) {\n                tt--;\n            } else {\n                d[++tt] = c;\n            }\n        }  \n        return new String(d, 0, tt + 1);\n    }\n} \n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1047` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1041-1050/1049. 最后一块石头的重量 II（中等）.md", "url_title": "1049. 最后一块石头的重量 II", "url": "https://leetcode-cn.com/problems/last-stone-weight-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-neng-jgxik/", "difficulty": "中等", "tags": ["动态规划", "背包问题", "01 背包", "数学"], "question": "有一堆石头,用整数数组 `stones` 表示。\n\n其中 `stones[i]` 表示第 `i` 块石头的重量。\n\n每一回合,从中选出任意两块石头,然后将它们一起粉碎。假设石头的重量分别为 `x` 和 `y`,且 `x <= y`。那么粉碎的可能结果如下:\n* 如果 `x == y`,那么两块石头都会被完全粉碎;\n* 如果 `x != y`,那么重量为 `x` 的石头将会完全粉碎,而重量为 `y` 的石头新重量为 `y-x`。\n\n最后,最多只会剩下一块 石头。返回此石头最小的可能重量 。\n\n如果没有石头剩下,就返回 `0`。\n\n示例 1:\n```\n输入:stones = [2,7,4,1,8,1]\n输出:1\n解释:\n组合 2 和 4,得到 2,所以数组转化为 [2,7,1,8,1],\n组合 7 和 8,得到 1,所以数组转化为 [2,1,1,1],\n组合 2 和 1,得到 1,所以数组转化为 [1,1,1],\n组合 1 和 1,得到 0,所以数组转化为 [1],这就是最优值。\n```\n示例 2:\n```\n输入:stones = [31,26,33,21,40]\n输出:5\n```\n示例 3:\n```\n输入:stones = [1,2]\n输出:1\n```\n\n提示:\n* $1 <= stones.length <= 30$\n* $1 <= stones[i] <= 100$", "solution": "### 基本分析\n\n看到标题,心里咯噔了一下 🤣\n\n一般性的石子合并问题通常是只能操作相邻的两个石子,要么是「区间 DP」要么是「四边形不等式」,怎么到 LeetCode 就成了中等难度的题目(也太卷了 🤣\n\n仔细看了一下题目,可对任意石子进行操作,重放回的重量也不是操作石子的总和,而是操作石子的差值。\n\n哦,那没事了 ~ 🤣\n\n也是基于此启发,我们可以这样进行分析。\n\n假设想要得到最优解,我们需要按照如下顺序操作石子:$[(sa, sb), (sc, sd), ... ,(si, sj), (sp, sq)]$。\n\n其中 $abcdijpq$ 代表了石子编号,**字母顺序不代表编号的大小关系**。\n\n**如果不考虑「有放回」的操作的话,我们可以划分为两个石子堆(正号堆/负号堆):**\n\n* **将每次操作中「重量较大」的石子放到「正号堆」,代表在这次操作中该石子重量在「最终运算结果」中应用 $+$ 运算符**\n* **将每次操作中「重量较少/相等」的石子放到「负号堆」,代表在这次操作中该石子重量在「最终运算结果」中应用 $-$ 运算符**\n\n**这意味我们最终得到的结果,可以为原来 $stones$ 数组中的数字添加 $+/-$ 符号,所形成的「计算表达式」所表示。**\n\n那有放回的石子重量如何考虑?\n\n**其实所谓的「有放回」操作,只是触发调整「某个原有石子」所在「哪个堆」中,并不会真正意义上的产生「新的石子重量」。**\n\n什么意思呢?\n\n假设有起始石子 $a$ 和 $b$,且两者重量关系为 $a \\geq b$,那么首先会将 $a$ 放入「正号堆」,将 $b$ 放入「负号堆」。重放回操作可以看作产生一个新的重量为 $a - b$ 的“虚拟石子”,将来这个“虚拟石子”也会参与某次合并操作,也会被添加 $+/-$ 符号:\n\n* 当对“虚拟石子”添加 $+$ 符号,即可 $+(a - b)$,展开后为 $a - b$,即起始石子 $a$ 和 $b$ 所在「石子堆」不变\n* 当对“虚拟石子”添加 $-$ 符号,即可 $-(a - b)$,展开后为 $b - a$,即起始石子 $a$ 和 $b$ 所在「石子堆」交换\n\n**因此所谓不断「合并」&「重放」,本质只是在构造一个折叠的计算表达式,最终都能展开扁平化为非折叠的计算表达式。**\n\n**综上,即使是包含「有放回」操作,最终的结果仍然可以使用「为原来 $stones$ 数组中的数字添加 $+/-$ 符号,形成的“计算表达式”」所表示。**\n\n---\n\n### 动态规划\n\n有了上述分析后,问题转换为:**为 $stones$ 中的每个数字添加 $+/-$,使得形成的「计算表达式」结果绝对值最小。**\n\n与[(题解)494. 目标和](https://leetcode-cn.com/problems/target-sum/solution/gong-shui-san-xie-yi-ti-si-jie-dfs-ji-yi-et5b/) 类似,需要考虑正负号两边时,其实只需要考虑一边就可以了,使用总和 $sum$ 减去决策出来的结果,就能得到另外一边的结果。\n\n同时,由于想要「计算表达式」结果绝对值,因此我们需要将石子划分为差值最小的两个堆。\n\n其实就是对「计算表达式」中带 $-$ 的数值提取公因数 $-1$,进一步转换为两堆石子相减总和,绝对值最小。\n\n这就将问题彻底切换为 01 背包问题:**从 $stones$ 数组中选择,凑成总和不超过 $\\frac{sum}{2}$ 的最大价值。**\n\n其中「成本」&「价值」均为数值本身。\n\n整理一下:\n\n定义 $f[i][j]$ 代表考虑前 $i$ 个物品(数值),凑成总和不超过 $j$ 的最大价值。\n\n每个物品都有「选」和「不选」两种决策,转移方程为:\n\n$$f[i][j] = \\max(f[i - 1][j], f[i - 1][j - stones[i - 1]] + stones[i - 1])$$\n\n与完全背包不同,01 背包的几种空间优化是不存在时间复杂度上的优化,因此写成 朴素二维、滚动数组、一维优化 都可以。\n\n建议直接上手写「一维空间优化」版本,是其他背包问题的基础。\n\n代码:\n```Java\nclass Solution {\n    public int lastStoneWeightII(int[] ss) {\n        int n = ss.length;\n        int sum = 0;\n        for (int i : ss) sum += i;\n        int t = sum / 2;\n        int[][] f = new int[n + 1][t + 1];\n        for (int i = 1; i <= n; i++) {\n            int x = ss[i - 1];\n            for (int j = 0; j <= t; j++) {\n                f[i][j] = f[i - 1][j];\n                if (j >= x) f[i][j] = Math.max(f[i][j], f[i - 1][j - x] + x);\n            }\n        }\n        return Math.abs(sum - f[n][t] - f[n][t]);\n    }\n}\n```\n```Java\nclass Solution {\n    public int lastStoneWeightII(int[] ss) {\n        int n = ss.length;\n        int sum = 0;\n        for (int i : ss) sum += i;\n        int t = sum / 2;\n        int[][] f = new int[2][t + 1];\n        for (int i = 1; i <= n; i++) {\n            int x = ss[i - 1];\n            int a = i & 1, b = (i - 1) & 1;\n            for (int j = 0; j <= t; j++) {\n                f[a][j] = f[b][j];\n                if (j >= x) f[a][j] = Math.max(f[a][j], f[b][j - x] + x);\n            }\n        }\n        return Math.abs(sum - f[n&1][t] - f[n&1][t]);\n    }\n}\n```\n```Java\nclass Solution {\n    public int lastStoneWeightII(int[] ss) {\n        int n = ss.length;\n        int sum = 0;\n        for (int i : ss) sum += i;\n        int t = sum / 2;\n        int[] f = new int[t + 1];\n        for (int i = 1; i <= n; i++) {\n            int x = ss[i - 1];\n            for (int j = t; j >= x; j--) {\n                f[j] = Math.max(f[j], f[j - x] + x);\n            }\n        }\n        return Math.abs(sum - f[t] - f[t]);\n    }\n}\n```\n* 时间复杂度:$O(n \\times \\sum_{i = 0}^{n - 1} stones[i])$\n* 空间复杂度:$O(n \\times \\sum_{i = 0}^{n - 1} stones[i])$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1049` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1051-1060/1051. 高度检查器（简单）.md", "url_title": "1051. 高度检查器", "url": "https://leetcode.cn/problems/height-checker/solution/by-ac_oier-8xoj/", "difficulty": "简单", "tags": ["排序", "模拟"], "question": "学校打算为全体学生拍一张年度纪念照。根据要求,学生需要按照 非递减 的高度顺序排成一行。\n\n排序后的高度情况用整数数组 `expected` 表示,其中 `expected[i]` 是预计排在这一行中第 `i` 位的学生的高度(下标从 $0$ 开始)。\n\n给你一个整数数组 `heights`,表示 当前学生站位 的高度情况。`heights[i]` 是这一行中第 `i` 位学生的高度(下标从 $0$ 开始)。\n\n返回满足 `heights[i] != expected[i]` 的 下标数量 。\n\n示例:\n```\n输入:heights = [1,1,4,2,1,3]\n\n输出:3 \n\n解释:\n高度:[1,1,4,2,1,3]\n预期:[1,1,1,2,3,4]\n下标 2 、4 、5 处的学生高度不匹配。\n```\n示例 2:\n```\n输入:heights = [5,1,2,3,4]\n\n输出:5\n\n解释:\n高度:[5,1,2,3,4]\n预期:[1,2,3,4,5]\n所有下标的对应学生高度都不匹配。\n```\n示例 3:\n```\n输入:heights = [1,2,3,4,5]\n\n输出:0\n\n解释:\n高度:[1,2,3,4,5]\n预期:[1,2,3,4,5]\n所有下标的对应学生高度都匹配。\n```\n\n提示:\n* $1 <= heights.length <= 100$\n* $1 <= heights[i] <= 100$", "solution": "### 排序\n\n先排序得到目标序列,再将目标序列和原序列进行逐一对比,得到答案。\n\n排序部分,可以使用复杂度为 $O(n\\log{n})$ 的双轴快排,也可以利用数据范围为 $100$,利用计数排序思想来构建目标序列,复杂度为 $O(C + n)$。\n\n代码(快排 $P1$,计数排序 $P2$):\n```Java\nclass Solution {\n    public int heightChecker(int[] heights) {\n        int[] t = heights.clone();\n        Arrays.sort(t);\n        int n = heights.length, ans = 0;\n        for (int i = 0; i < n; i++) {\n            if (t[i] != heights[i]) ans++;\n        }\n        return ans;\n    }\n}\n```\n\n-\n\n```Java\nclass Solution {\n    public int heightChecker(int[] heights) {\n        int[] cnts = new int[110];\n        for (int i : heights) cnts[i]++;\n        int n = heights.length, ans = 0;\n        int[] t = new int[n];\n        for (int i = 0, j = 0; i < 110; i++) {\n            while (cnts[i]-- > 0) t[j++] = i;\n        }\n        for (int i = 0; i < n; i++) {\n            if (t[i] != heights[i]) ans++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$(快排)或者为 $O(C + n)$(计数排序),统计答案复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$(快排)或 $O(C + n)$(计数排序)\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1051` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1051-1060/1052. 爱生气的书店老板（中等）.md", "url_title": "1052. 爱生气的书店老板", "url": "https://leetcode-cn.com/problems/grumpy-bookstore-owner/solution/hua-dong-chuang-kou-luo-ti-by-ac_oier-nunu/", "difficulty": "中等", "tags": ["滑动窗口", "双指针"], "question": "今天,书店老板有一家店打算试营业 $customers.length$ 分钟。每分钟都有一些顾客($customers[i]$)会进入书店,所有这些顾客都会在那一分钟结束后离开。\n\n在某些时候,书店老板会生气。 如果书店老板在第 $i$ 分钟生气,那么 $grumpy[i] = 1$,否则 $grumpy[i] = 0$。 当书店老板生气时,那一分钟的顾客就会不满意,不生气则他们是满意的。\n\n书店老板知道一个秘密技巧,能抑制自己的情绪,可以让自己连续 $X$ 分钟不生气,但却只能使用一次。\n\n请你返回这一天营业下来,最多有多少客户能够感到满意的数量。\n\n示例:\n```\n输入:customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,0,1,0,1], X = 3\n\n输出:16\n\n解释:\n书店老板在最后 3 分钟保持冷静。\n感到满意的最大客户数量 = 1 + 1 + 1 + 1 + 7 + 5 = 16.\n```\n\n提示:\n* $1 <= X <= customers.length == grumpy.length <= 20000$\n* $0 <= customers[i] <= 1000$\n* $0 <= grumpy[i] <= 1$", "solution": "### 滑动窗口\n\n由于「技巧」只会将情绪将「生气」变为「不生气」,不生气仍然是不生气。\n\n1. 我们可以先将原本就满意的客户加入答案,同时将对应的 $customers[i]$ 变为 $0$。\n\n2. 之后的问题转化为:在 $customers$ 中找到连续一段长度为 $minutes$ 的子数组,使得其总和最大。这部分就是我们应用技巧所得到的客户。\n\n代码:\n```Java\nclass Solution {\n    public int maxSatisfied(int[] customers, int[] grumpy, int minutes) {\n        int n = customers.length, ans = 0;\n        for (int i = 0; i < n; i++) {\n            if (grumpy[i] == 0) {\n                ans += customers[i];\n                customers[i] = 0;\n            }\n        }\n        int cur = 0, max = 0;\n        for (int i = 0; i < n; i++) {\n            cur += customers[i];\n            if (i >= minutes) cur -= customers[i - minutes];\n            max = Math.max(max, cur);\n        }\n        return ans + max;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1052` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1071-1080/1074. 元素和为目标值的子矩阵数量（困难）.md", "url_title": "1074. 元素和为目标值的子矩阵数量", "url": "https://leetcode-cn.com/problems/number-of-submatrices-that-sum-to-target/solution/gong-shui-san-xie-you-hua-mei-ju-de-ji-b-uttw/", "difficulty": "困难", "tags": ["前缀和", "哈希表"], "question": "给出矩阵 matrix 和目标值 target,返回元素总和等于目标值的非空子矩阵的数量。\n\n子矩阵 x1, y1, x2, y2 是满足 x1 <= x <= x2 且 y1 <= y <= y2 的所有单元 matrix[x][y] 的集合。\n\n如果 (x1, y1, x2, y2) 和 (x1', y1', x2', y2') 两个子矩阵中部分坐标不同(如:x1 != x1'),那么这两个子矩阵也不同。\n\n \n\n示例 1:\n\n```\n输入:matrix = [[0,1,0],[1,1,1],[0,1,0]], target = 0\n输出:4\n解释:四个只含 0 的 1x1 子矩阵。\n```\n示例 2:\n```\n输入:matrix = [[1,-1],[-1,1]], target = 0\n输出:5\n解释:两个 1x2 子矩阵,加上两个 2x1 子矩阵,再加上一个 2x2 子矩阵。\n```\n示例 3:\n```\n输入:matrix = [[904]], target = 0\n输出:0\n```\n\n提示:\n* 1 <= matrix.length <= 100\n* 1 <= matrix[0].length <= 100\n* -1000 <= matrix[i] <= 1000\n* -$10^8$ <= target <= $10^8$", "solution": "### 朴素二维前缀和\n\n从题面来看显然是一道「二维前缀和」的题目,如果你还不了解「二维前缀和」,可以看看 [(题解)304. 二维区域和检索 - 矩阵不可变](https://leetcode-cn.com/problems/range-sum-query-2d-immutable/solution/xia-ci-ru-he-zai-30-miao-nei-zuo-chu-lai-ptlo/)。本题预处理前缀和的复杂度为 $O(m * n)$。\n\n搜索所有子矩阵需要枚举「矩形左上角」和「矩形右下角」,复杂度是 $O(m^2 * n^2)$。\n\n因此,如果把本题当做二维前缀和模板题来做的话,整体复杂度是 $O(m^2 * n^2)$。\n\n数据范围是 $10^2$,对应的计算量是 $10^8$,处于超时边缘,但当我们枚举「矩阵右下角」$(i,j)$ 的时候,我们只需要搜索位于 $(i,j)$ 的左上方的点 $(p,q)$ 作为「矩阵左上角」,所以其实我们是取不满 $m^2 * n^2$ 的,但仍然具有超时风险(2021/05/29 Java 测试可通过)。\n\n代码:\n```Java\nclass Solution {\n    public int numSubmatrixSumTarget(int[][] mat, int t) {\n        int n = mat.length, m = mat[0].length;\n        int[][] sum = new int[n + 1][m + 1];\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + mat[i - 1][j - 1];\n            }\n        }\n        int ans = 0;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                for (int p = 1; p <= i; p++) {\n                    for (int q = 1; q <= j; q++) {\n                        if (sum[i][j] - sum[p - 1][j] - sum[i][q - 1] + sum[p - 1][q - 1] == t) ans++;\n                    }\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(m^2 * n^2)$\n* 空间复杂度:$O(m * n)$\n\n---\n\n### 优化枚举 + 哈希表\n\n上述分析是从「点」上来确定一个子矩阵,在 $n$ 和 $m$ 同阶的情况下,复杂度是 $O(n^4)$ 的。\n\n事实上,我们能从「边」的角度来确定一个子矩阵,通过枚举三条边,然后加速找第四条边的过程,这样可以将复杂度降到 $O(n^3)$。\n\n**这个分析思路在 [(题解)363. 矩形区域不超过 K 的最大数值和](https://leetcode-cn.com/problems/max-sum-of-rectangle-no-larger-than-k/solution/gong-shui-san-xie-you-hua-mei-ju-de-ji-b-dh8s/) 详细讲过,没有印象的同学可以翻翻。这道题一定程度上是那道题的简化版,在本题我们只需要找到矩阵和为 $target$ 的值,因此只需要使用「哈希表」来记录出现过的值即可,而在 [(原题)363. 矩形区域不超过 K 的最大数值和](https://leetcode-cn.com/problems/max-sum-of-rectangle-no-larger-than-k/) 中,我们需要找到和不超过 $k$ 的最大子矩阵,因此还涉及「有序集合 + 二分」。**\n\n具体的,我们仍然需要先预处理出一个二维前缀和。**然后通过枚举确定「子矩阵的上下边界」,在将「子矩阵右边界」不断右移的过程中,把「子矩阵右边界」到「原矩阵左边界」行程的矩阵和存入哈希表(因为要统计数量,存储格式为 {\"面积”:\"出现次数\"} ),然后通过容斥原理来找到目标的「子矩阵左边界」。**\n\n假设当前我们「子矩阵的上下边界」已经固定,当枚举到某个「子矩阵右边界」时,我们先通过二维前缀和计算出「子矩阵右边界」和「原矩阵左边界」形成的矩阵和 $cur$,由于我们希望找到矩阵和为 $target$ 的子矩阵,即希望找到一个「子矩阵左边界」使得矩阵和满足要求,这等价于从「哈希表」中找到一个 $x$,使得 $cur - x = target$,这是一个 $O(1)$ 操作。\n\n代码:\n```Java\nclass Solution {\n    public int numSubmatrixSumTarget(int[][] mat, int t) {\n        int n = mat.length, m = mat[0].length;\n        int[][] sum = new int[n + 1][m + 1];\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + mat[i - 1][j - 1];\n            }\n        }\n        int ans = 0;\n        for (int top = 1; top <= n; top++) {\n            for (int bot = top; bot <= n; bot++) {\n                int cur = 0;\n                Map<Integer, Integer> map = new HashMap<>();\n                for (int r = 1; r <= m; r++) {\n                    cur = sum[bot][r] - sum[top - 1][r];\n                    if (cur == t) ans++;\n                    if (map.containsKey(cur - t)) ans += map.get(cur - t);\n                    map.put(cur, map.getOrDefault(cur, 0) + 1);\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(m * n^2)$\n* 空间复杂度:$O(m * n)$\n\n---\n\n### 进阶\n\n1. 【时间复杂度】在上述解法中,我们采用的是**固定上下边界,移动右边界,通过哈希表找左边界**的做法,复杂度为 $O(m * n^2)$;自然也能改为**固定左右边界,移动下边界,通过哈希表找上边界**做法,复杂度为 $O(m^2 * n)$。那么我们要如何调整代码,才能最大化「哈希表」带来的优化效果呢?此时的复杂度又是多少?\n\n2. 【空间复杂度】我们空间复杂度的瓶颈在「二维前缀和」上,但注意到无论我们采取「固定上下边界」还是「固定左右边界」的做法,扫描原矩阵的方向都是固定的,那么是否可以不预处理「二维前缀和」呢?从而将空间复杂度降低到 $O(\\max(n, m))$ 呢?\n\n上述两问,你都可以在 [(题解)363. 矩形区域不超过 K 的最大数值和](https://leetcode-cn.com/problems/max-sum-of-rectangle-no-larger-than-k/solution/gong-shui-san-xie-you-hua-mei-ju-de-ji-b-dh8s/) 中找到答案。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1074` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1071-1080/1078. Bigram 分词（简单）.md", "url_title": "1078. Bigram 分词", "url": "https://leetcode-cn.com/problems/occurrences-after-bigram/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-qyki/", "difficulty": "简单", "tags": ["模拟"], "question": "给出第一个词 `first` 和第二个词 `second`,考虑在某些文本 `text` 中可能以 `\"first second third\"` 形式出现的情况,其中 `second` 紧随 `first` 出现,`third` 紧随 `second` 出现。\n\n对于每种这样的情况,将第三个词 `\"third\"` 添加到答案中,并返回答案。\n\n示例 1:\n```\n输入:text = \"alice is a good girl she is a good student\", first = \"a\", second = \"good\"\n\n输出:[\"girl\",\"student\"]\n```\n示例 2:\n```\n输入:text = \"we will we will rock you\", first = \"we\", second = \"will\"\n\n输出:[\"we\",\"rock\"]\n```\n\n提示:\n* $1 <= text.length <= 1000$\n* `text` 由小写英文字母和空格组成\n* `text` 中的所有单词之间都由 单个空格字符 分隔\n* $1 <= first.length, second.length <= 10$\n* `first` 和 `second` 由小写英文字母组成", "solution": "### 模拟\n\n好像每次起晚都是简单题?🤣 \n\n根据题意进行模拟。\n\n代码:\n```Java\nclass Solution {\n    public String[] findOcurrences(String text, String a, String b) {\n        String[] ss = text.split(\" \");\n        int n = ss.length;\n        List<String> list = new ArrayList<>();\n        for (int i = 0; i + 2 < n; i++) {\n            if (ss[i].equals(a) && ss[i + 1].equals(b)) list.add(ss[i + 2]);\n        }\n        return list.toArray(new String[list.size()]);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1078` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1081-1090/1089. 复写零（简单）.md", "url_title": "1089. 复写零", "url": "https://leetcode.cn/problems/duplicate-zeros/solution/by-ac_oier-zivq/", "difficulty": "简单", "tags": ["双指针"], "question": "给你一个长度固定的整数数组 `arr`,请你将该数组中出现的每个零都复写一遍,并将其余的元素向右平移。\n\n注意:请不要在超过该数组长度的位置写入元素。\n\n要求:请对输入的数组 就地 进行上述修改,不要从函数返回任何东西。\n\n示例 1:\n```\n输入:[1,0,2,3,0,4,5,0]\n\n输出:null\n\n解释:调用函数后,输入的数组将被修改为:[1,0,0,2,3,0,0,4]\n```\n示例 2:\n```\n输入:[1,2,3]\n\n输出:null\n\n解释:调用函数后,输入的数组将被修改为:[1,2,3]\n```\n\n提示:\n* $1 <= arr.length <= 10000$\n* $0 <= arr[i] <= 9$", "solution": "### 双指针\n\n这道题挺有意思的,建议大家在看文字的同时,在纸上推导一遍。\n\n我们可以假设已经通过原数组 `arr` 处理出最终的目标数组 `ans`,起始使用指针 $i$ 指向原数组的开头位置,使用指针 $j$ 指向目标数组的开头位置。\n\n然后开始同时从前往后处理,默认情况下,两个指针每次往后移动一位,当在原数组中出现 $arr[i] = 0$ 时,根据题意,我们需要在目标数组 $ans[j]$ 后面复写多一位,因此此时让 $j$ 多走一位。\n\n当 $j$ 走到的位置已超出数组长度,此时 $i$ 也停在了该被截断的位置的下一位。\n\n此时我们先将 $i$ 和 $j$ 同时往回走一步,确保 $i$ 落在真正的截断后的位置,但需要注意,由于 $j$ 在之前的往前走逻辑中可能会走两步,因此 $j$ 在往回走一步后仍可能在数组以外的位置。\n\n然后考虑如何在 $i$ 和 $j$ 所在位置开始「往回」赋值:每次将 $arr[i]$ 赋值给 $arr[j]$(需要确保 $j$ 下标合法),由于 $i$ 必然不会出现在 $j$ 的后面(即不会出现 $j < i$),因此不会出现值被提前覆盖的问题。因此通常情况下,我们可以不断的同时减少 $i$ 和 $j$,并将 $arr[i]$ 赋值给 $arr[j]$。当出现 $arr[i] = 0$ 时,我们需要额外让 $j$ 往前多走一步,并将该位置置为 $0$,来实现目标数组「复写零」的效果。\n\n当 $i$ 指针越过开头的位置,说明已完成从 `arr` 到 `ans` 的转换。\n\n> 这个往回赋值的过程,十分建议大家在纸上推导一遍。\n\n代码:\n```Java\nclass Solution {\n    public void duplicateZeros(int[] arr) {\n        int n = arr.length, i = 0, j = 0;\n        while (j < n) {\n            if (arr[i] == 0) j++;\n            i++; j++;\n        }\n        i--; j--;\n        while (i >= 0) {\n            if (j < n) arr[j] = arr[i];\n            if (arr[i] == 0 && --j >= 0) arr[j] = 0;\n            i--; j--;\n        }\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1089` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1091-1100/1092. 最短公共超序列（困难）.md", "url_title": "1092. 最短公共超序列", "url": "https://leetcode.cn/problems/shortest-common-supersequence/solution/by-ac_oier-s346/", "difficulty": "困难", "tags": ["序列 DP", "LCS", "最长公共子序列", "动态规划", "构造", "双指针"], "question": "给出两个字符串 `str1` 和 `str2`,返回同时以 `str1` 和 `str2` 作为子序列的最短字符串。如果答案不止一个,则可以返回满足条件的任意一个答案。\n\n(如果从字符串 `T` 中删除一些字符(也可能不删除,并且选出的这些字符可以位于 `T` 中的 任意位置),可以得到字符串 `S`,那么 `S` 就是 `T` 的子序列)\n\n示例:\n```\n输入:str1 = \"abac\", str2 = \"cab\"\n\n输出:\"cabac\"\n\n解释:\nstr1 = \"abac\" 是 \"cabac\" 的一个子串,因为我们可以删去 \"cabac\" 的第一个 \"c\"得到 \"abac\"。 \nstr2 = \"cab\" 是 \"cabac\" 的一个子串,因为我们可以删去 \"cabac\" 末尾的 \"ac\" 得到 \"cab\"。\n最终我们给出的答案是满足上述属性的最短字符串。\n```\n\n提示:\n* $1 <= str1.length, str2.length <= 1000$\n* `str1` 和 `str2` 都由小写英文字母组成。", "solution": "### LCS 求具体方案 + 构造\n\n为了方便,我们令 `str1` 为 `s1`,`str2` 为 `s2`,并将两者长度记为 $n$ 和 $m$。\n\n容易想到最终的方案必然是由三部分组成:两字符串的公共子序列(且必然是最长公共子序列)+ 两者特有的字符部分。\n\n基于此,我们可以先使用对两者求 `LCS`,并在求具体方案时遵循:属于最长公共子序列的字符只添加一次,而特有于 `s1` 或 `s2` 的字符则独自添加一次。\n\n求解 `LCS` 部分我们定义 **$f[i][j]$ 代表考虑 $s1$ 的前 $i$ 个字符、考虑 $s2$ 的前 $j$ 的字符,形成的最长公共子序列长度(为了方便,令下标从 $1$ 开始)。**\n\n当有了「状态定义」之后,基本上「转移方程」就是呼之欲出:\n\n* `s1[i]==s2[j]` : $f[i][j]=f[i-1][j-1]+1$。代表**必然使用 $s1[i]$ 与 $s2[j]$ 时** `LCS` 的长度。\n* `s1[i]!=s2[j]` : $f[i][j]=max(f[i-1][j], f[i][j-1])$。代表**必然不使用 $s1[i]$(但可能使用$s2[j]$)时** 和 **必然不使用 $s2[j]$(但可能使用$s1[i]$)时** `LCS` 的长度。\n\n> **不了解 LCS 的同学可以看前置 🧀 : [LCS 模板题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492097&idx=1&sn=f51f29d86df809d8ac43a40a1369b3d6)**\n\n当预处理出动规数组 `f` 之后,我们使用「双指针」和「通用 `DP` 求具体方案」的做法进行构造:使用 `i` 变量指向 `s1` 的尾部(即起始有 $i = n$),使用 `j` 变量指向 `s2` 的尾部(即起始有 $j = m$),根据 `i` 和 `j` 当前所在位置以及 $f[i][j]$ 从何值转移而来:\n\n1. 若 `i` 或 `j` 其一走完(`i = 0` 或 `j = 0`),将剩余字符追加到答案中;\n2. 当 $f[i][j] = f[i - 1][j - 1] + 1$ 且 $s1[i] = s2[j]$ 时(可简化为 $s1[i] = s2[j]$ 判断),此时 `i` 指向的字符和 `j` 指向的字符为相同,且为 `LCS` 中的字符,将其追加到具体方案,并让 `i` 和 `j` 同时后移;\n3. 当 $f[i][j] = f[i - 1][j]$,将 `s1[i]` 追加到答案中,令 `i` 后移;\n4. 当 $f[i][j] = f[i][j - 1]$,将 `s2[j]` 追加到答案中,令 `j` 后移。\n\n当条件 `3` 和 `4` 同时满足时,由于只需要输出任一具体方案,我们任取其一即可。\n\n最后,由于我们是从后往前进行构造,在返回时需要再进行一次翻转。\n\nJava 代码:\n```Java\nclass Solution {\n    public String shortestCommonSupersequence(String str1, String str2) {\n        int n = str1.length(), m = str2.length();\n        str1 = \" \" + str1; str2 = \" \" + str2;\n        char[] s1 = str1.toCharArray(), s2 = str2.toCharArray();\n        int[][] f = new int[n + 10][m + 10];\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                if (s1[i] == s2[j]) f[i][j] = f[i - 1][j - 1] + 1;\n                else f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);\n            }\n        }\n        StringBuilder sb = new StringBuilder();\n        int i = n, j = m;\n        while (i > 0 || j > 0) {\n            if (i == 0) sb.append(s2[j--]);\n            else if (j == 0) sb.append(s1[i--]);\n            else {\n                if (s1[i] == s2[j]) {\n                    sb.append(s1[i]);\n                    i--; j--;\n                } else if (f[i][j] == f[i - 1][j]) {\n                    sb.append(s1[i--]);\n                } else {\n                    sb.append(s2[j--]);\n                }\n            }\n        }\n        return sb.reverse().toString();\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    string shortestCommonSupersequence(string str1, string str2) {\n        int n = str1.size(), m = str2.size();\n        str1 = \" \" + str1; str2 = \" \" + str2;\n        vector<vector<int>> f(n + 10, vector<int>(m + 10));\n        for (int i = 1; i <= n; ++i) {\n            for (int j = 1; j <= m; ++j) {\n                if (str1[i] == str2[j])\n                    f[i][j] = f[i - 1][j - 1] + 1;\n                else \n                    f[i][j] = max(f[i - 1][j], f[i][j - 1]);\n            }\n        }\n        string res;\n        int i = n, j = m;\n        while (i > 0 || j > 0) {\n            if (i == 0) res += str2[j--];\n            else if (j == 0) res += str1[i--];\n            else {\n                if (str1[i] == str2[j]) {\n                    res += str1[i];\n                    i--; j--;\n                }\n                else if (f[i][j] == f[i - 1][j]) res += str1[i--];\n                else res += str2[j--];\n            }\n        }\n        reverse(res.begin(), res.end());\n        return res;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def shortestCommonSupersequence(self, s1: str, s2: str) -> str:\n        n, m = len(s1), len(s2)\n        s1 = \" \" + s1\n        s2 = \" \" + s2\n        f = [[0] * (m + 10) for _ in range(n + 10)]\n        for i in range(1, n + 1):\n            for j in range(1, m + 1):\n                f[i][j] = f[i - 1][j - 1] + 1 if s1[i] == s2[j] else max(f[i - 1][j], f[i][j - 1])\n        ans = \"\"\n        i, j = n, m\n        while i > 0 or j > 0:\n            if i == 0:\n                ans += s2[j]\n                j -= 1\n            elif j == 0:\n                ans += s1[i]\n                i -= 1\n            else:\n                if s1[i] == s2[j]:\n                    ans += s1[i]\n                    i -= 1\n                    j -= 1\n                elif f[i][j] == f[i - 1][j]:\n                    ans += s1[i]\n                    i -= 1\n                else:\n                    ans += s2[j]\n                    j -= 1\n        return ans[::-1]\n```\nTypeScript 代码:\n```TypeScript\nfunction shortestCommonSupersequence(s1: string, s2: string): string {\n    const n = s1.length, m = s2.length\n    s1 = \" \" + s1; s2 = \" \" + s2\n    const f = new Array<Array<number>>()\n    for (let i = 0; i < n + 10; i++) f.push(new Array<number>(m + 10).fill(0))\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= m; j++) {\n            if (s1[i] == s2[j]) f[i][j] = f[i - 1][j - 1] + 1\n            else f[i][j] = Math.max(f[i - 1][j], f[i][j - 1])\n        }\n    }\n    let ans = \"\"\n    let i = n, j = m\n    while (i > 0 || j > 0) {\n        if (i == 0) ans += s2[j--]\n        else if (j == 0) ans += s1[i--]\n        else {\n            if (s1[i] == s2[j]) {\n                ans += s1[i]\n                i--; j--\n            } else if (f[i][j] == f[i - 1][j]) {\n                ans += s1[i--]\n            } else {\n                ans += s2[j--]\n            }\n        }\n    }\n    return ans.split('').reverse().join('')\n};\n```\n* 时间复杂度:`LCS` 复杂度为 $O(n \\times m)$;构造答案复杂度为 $O(n \\times m)$。整体复杂度为 $O(n \\times m)$\n* 空间复杂度:$O(n \\times m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1092` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1091-1100/1094. 拼车（中等）.md", "url_title": "1094. 拼车", "url": "https://leetcode.cn/problems/car-pooling/solutions/2550276/gong-shui-san-xie-tu-jie-chai-fen-ru-men-opii/", "difficulty": "中等", "tags": ["差分", "前缀和"], "question": "车上最初有 `capacity` 个空座位,车只能向一个方向行驶(不允许掉头或改变方向)。\n\n给定整数 `capacity` 和一个数组 `trips`,  $trip[i] = [numPassengers_{i}, from_{i}, to_{i}]$ 表示第 `i` 次旅行有 $numPassengers_{i}$ 乘客,接他们和放他们的位置分别是 $from_{i}$ 和 $to_{i}$ 。\n\n这些位置是从汽车的初始位置向东的公里数。\n\n当且仅当你可以在所有给定的行程中接送所有乘客时,返回 `true`,否则请返回 `false`。\n\n示例 1:\n```\n输入:trips = [[2,1,5],[3,3,7]], capacity = 4\n\n输出:false\n```\n示例 2:\n```\n输入:trips = [[2,1,5],[3,3,7]], capacity = 5\n\n输出:true\n```\n\n提示:\n* $1 <= trips.length <= 1000$\n* $trips[i].length = 3$\n* $1 <= numPassengers_{i} <= 100$\n* $0 <= from_{i} < to_{i} <= 1000$\n* $1 <= capacity <= 10^5$", "solution": "### 差分\n\n从朴素的想法开始:创建一个数组 `cnt`,用于存储从某个站点出发时,车上的乘客数量。\n\n例如 $cnt[x] = c$ 含义为在站点 $x$ 出发时(在该站点的下车和上车均完成),车上乘客数为 $c$ 个。\n\n对于每个 $trips[i] = (c, a, b)$,我们需要对 $[a, b)$ 范围内的 $cnt[j]$ 进行加 $c$ 操作。\n\n处理完 `trips` 后,检查所有站点的乘客人数,根据是否满足 `capacity` 限制返回答案。\n\n因此,这是一个关于「区间修改,单点查询」的经典问题,可使用「差分」求解。\n\n所谓“差分”,是指 **原数组中每个元素与前一元素之差所形成的数组**,与之相对应的是“前缀和”。\n\n我们知道,对原数组进行诸位累加(前缀计算操作),所得到的数组为前缀和数组。差分数组,则是对其执行前缀计算后,能够得到原数组的那个数组 🤣 。\n\n关于「差分数组 - 原数组 - 前缀和数组」三者关系如图所示:\n\n前缀和数组的主要作用,是利用「容斥原理」快速求解某段之和。例如要查询原数组 `nums` 中下标范围 $[l, r]$ 的和,可通过 $sum[r] - sum[l - 1]$ 快速求解。\n\n差分数组的主要作用,是帮助快速修改某段区间。\n\n由于差分数组执行「前缀计算」后得到的是原数组,因此在差分数组上修改某个值,会对原数组某段后缀产生相同的影响。\n\n因此,**当我们想要对原数组的 $[l, r]$ 进行整体修改时,只需要对差分数组的 $l$ 和 $r + 1$ 位置执行相应操作即可**。\n\n举个 🌰,假设想对原数组 `nums` 的 $[l, r]$ 进行整体“加一”操作,那么可转换为对差分数组 `c[l]` 的加一操作(等价对原数组的 $[l, n - 1]$ 进行加一),以及对差分数组 `c[r + 1]` 的减一操作(等价于对原数组的 $[r + 1, n - 1]$ 进行减一,最终只有 $[l, r]$ 有加一效果)。\n\n至此,我们完成了对「差分」的基本学习:**将原数组的区间修改等价为差分数组的特定位置修改**。\n\n回到本题,起始先用 `nums` 来作为差分数组,对于 $trips[i] = (c, a, b)$,有 $c$ 个乘客在 $a$ 点上车,在 $b$ 点下车,因此对 $[a, b)$ 进行整体加 $c$ 操作,对应差分数组操作 `nums[a] += c; nums[b] -= c`。\n\n处理完 `trips` 后,对差分数组 `nums` 进行前缀计算(可直接复用 `nums`,进行原地计算),便可得到各个站点的乘客数量,与 `capacity` 比较得出答案。\n\n一些细节:为了方便,人为规定站点编号从 $1$ 开始。\n\nJava 代码:\n\n```Java\nclass Solution {\n    public boolean carPooling(int[][] trips, int capacity) {\n        int[] nums = new int[1010];\n        for (int[] t : trips) {\n            int c = t[0], a = t[1], b = t[2];\n            nums[a + 1] += c; nums[b + 1] -= c;\n        }\n        for (int i = 1; i <= 1000; i++) {\n            nums[i] += nums[i - 1];\n            if (nums[i] > capacity) return false;\n        }\n        return true;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool carPooling(vector<vector<int>>& trips, int capacity) {\n        vector<int> nums(1010, 0);\n        for (const auto& t : trips) {\n            int c = t[0], a = t[1], b = t[2];\n            nums[a + 1] += c; nums[b + 1] -= c;\n        }\n        for (int i = 1; i <= 1000; i++) {\n            nums[i] += nums[i - 1];\n            if (nums[i] > capacity) return false;\n        }\n        return true;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def carPooling(self, trips: List[List[int]], capacity: int) -> bool:\n        nums = [0] * 1010\n        for t in trips:\n            c, a, b = t[0], t[1], t[2]\n            nums[a + 1] += c\n            nums[b + 1] -= c\n        for i in range(1, 1001):\n            nums[i] += nums[i - 1]\n            if nums[i] > capacity: return False\n        return True\n```\nTypeScript 代码:\n```TypeScript\nfunction carPooling(trips: number[][], capacity: number): boolean {\n    const nums = new Array(1010).fill(0);\n    for (const t of trips) {\n        const c = t[0], a = t[1], b = t[2];\n        nums[a + 1] += c; nums[b + 1] -= c;\n    }\n    for (let i = 1; i <= 1000; i++) {\n        nums[i] += nums[i - 1];\n        if (nums[i] > capacity) return false;\n    }\n    return true;\n};\n```\n* 时间复杂度:$O(n + m)$,其中 $n$ 为数组 `trips` 大小;$m = 1000$ 为位置值域大小\n* 空间复杂度:$O(m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1094` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/11-20/11. 盛最多水的容器（中等）.md", "url_title": "11. 盛最多水的容器", "url": "https://leetcode-cn.com/problems/container-with-most-water/solution/shua-chuan-lc-shuang-zhi-zhen-tan-xin-ji-52gf/", "difficulty": "中等", "tags": ["双指针", "贪心"], "question": "给你 $n$ 个非负整数 $a_1$,$a_2$,...,$a_n$,每个数代表坐标中的一个点 $(i, a_i)$ 。\n\n在坐标内画 n 条垂直线,垂直线 i 的两个端点分别为 $(i, a_i)$ 和 $(i, 0)$ 。\n\n找出其中的两条线,使得它们与 `x` 轴共同构成的容器可以容纳最多的水。\n\n说明:你不能倾斜容器。\n\n示例 1:\n\n```\n输入:[1,8,6,2,5,4,8,3,7]\n\n输出:49 \n\n解释:图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下,容器能够容纳水(表示为蓝色部分)的最大值为 49。\n```\n示例 2:\n```\n输入:height = [1,1]\n\n输出:1\n```\n示例 3:\n```\n输入:height = [4,3,2,1,4]\n\n输出:16\n```\n示例 4:\n```\n输入:height = [1,2,1]\n\n输出:2\n```\n\n提示:\n* $n = height.length$\n* $2 <= n <= 3 \\times 10^4$\n* $0 <= height[i] <= 3 \\times 10^4$", "solution": "### 双指针 + 贪心\n\n先用两个指针 `i` 和 `j` 指向左右边界,然后考虑指针应该怎么移动。\n\n由于构成矩形的面积,取决于 `i` 和 `j` 之间的距离(记为 `w`) 和 `i` 和 `j` 下标对应的高度的最小值(记为 `h`)。\n\n首先无论是 `i` 指针往右移动还是 `j` 指针往左移动都会导致 `w` 变小,所以想要能够枚举到更大的面积,我们应该让 `h` 在指针移动后变大。\n\n不妨假设当前情况是 `height[i] < heigth[j]`(此时矩形的高度为 `height[i]`),然后分情况讨论:\n\n* 让 `i` 和 `j` 两者高度小的指针移动,即 `i` 往右移动:\n  * 移动后,i 指针对应的高度变小,即 `height[i] > height[i + 1]`:`w` 和 `h` 都变小了,面积一定变小\n  * 移动后,i 指针对应的高度不变,即 `height[i] = height[i + 1]`:`w` 变小,`h` 不变,面积一定变小\n  * 移动后,i 指针对应的高度变大,即 `height[i] < height[i + 1]`:`w` 变小,`h` 变大,面积可能会变大\n\n* 让 `i` 和 `j` 两者高度大的指针移动,即 `j` 往左移动:\n   * 移动后,j 指针对应的高度变小,即 `height[j] > height[j - 1]`:`w` 变小,`h` 可能不变或者变小(当 `height[j - 1] >= height[i]` 时,`h` 不变;当 `height[j - 1] < height[i]` 时,`h` 变小),面积一定变小\n    * 移动后,j 指针对应的高度不变,即 `height[j] = height[j - 1]`:`w` 变小,`h` 不变,面积一定变小\n    * 移动后,j 指针对应的高度变大,即 `height[j] < height[j - 1]`:`w` 变小,`h` 不变,面积一定变小\n\n综上所述,我们只有将高度小的指针往内移动,才会枚举到更大的面积:\n\n代码:\n```Java\nclass Solution {\n    public int maxArea(int[] height) {\n        int n = height.length, ans = 0;\n        int i = 0, j = n - 1;\n        while (i < j) {\n            ans = Math.max(ans, (j - i) * Math.min(height[i], height[j]));\n            if (height[i] < height[j]) i++;\n            else j--;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:会对整个数组扫描一遍。复杂度为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.11` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/11-20/12. 整数转罗马数字（中等）.md", "url_title": "12. 整数转罗马数字", "url": "https://leetcode-cn.com/problems/integer-to-roman/solution/shua-chuan-lc-tan-xin-jie-fa-by-ac_oier-5kbw/", "difficulty": "中等", "tags": ["模拟"], "question": "罗马数字包含以下七种字符: I, V, X, L,C,D 和 M。\n```\n字符          数值\nI             1\nV             5\nX             10\nL             50\nC             100\nD             500\nM             1000\n```\n例如, 罗马数字 2 写做 II ,即为两个并列的 1。12 写做 XII ,即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。\n\n通常情况下,罗马数字中小的数字在大的数字的右边。但也存在特例,例如 4 不写做 IIII,而是 IV。数字 1 在数字 5 的左边,所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地,数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况:\n\n* I 可以放在 V (5) 和 X (10) 的左边,来表示 4 和 9。\n* X 可以放在 L (50) 和 C (100) 的左边,来表示 40 和 90。 \n* C 可以放在 D (500) 和 M (1000) 的左边,来表示 400 和 900。\n\n给定一个整数,将其转为罗马数字。输入确保在 1 到 3999 的范围内。\n\n示例 1:\n```\n输入: 3\n输出: \"III\"\n```\n示例 2:\n```\n输入: 4\n输出: \"IV\"\n```\n示例 3:\n```\n输入: 9\n输出: \"IX\"\n```\n示例 4:\n```\n输入: 58\n输出: \"LVIII\"\n解释: L = 50, V = 5, III = 3.\n```\n示例 5:\n```\n输入: 1994\n输出: \"MCMXCIV\"\n解释: M = 1000, CM = 900, XC = 90, IV = 4.\n```\n\n提示:\n* $1 <= num <= 3999$", "solution": "### 模拟\n\n现实中每一个「阿拉伯数字」固定对应一个「罗马数字」,不存在说一个「阿拉伯数字」能够对应出一个较长或者较短的「罗马数字」。\n\n因此这是一个按照固定规则进行转换的「模拟」过程。\n\n根据题意,我们可以列举出有限个罗马字符和其对应的数值。\n\n然后从左到右构建罗马数字,优先构建数值高的罗马字符(如果有足够的分值,尽量尝试构建 \"M\",直到分值不够,再尽量尝试构建 \"CM\" ... )\n\n代码:\n```Java\nclass Solution {\n    int[] val = new int[]{1000,900,500,400,100,90,50,40,10,9,5,4,1};\n    String[] str = new String[]{\"M\",\"CM\",\"D\",\"CD\",\"C\",\"XC\",\"L\",\"XL\",\"X\",\"IX\",\"V\",\"IV\",\"I\"};\n    public String intToRoman(int x) {\n        StringBuilder sb = new StringBuilder();\n        for (int i = 0; i < val.length && x > 0; i++) {\n            int cv = val[i];\n            String cs = str[i];\n            while (x >= cv) {\n                sb.append(cs);\n                x -= cv;\n            }\n        }\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:通过映射对应关系,我们发现一位「阿拉伯数字」(数值 0-9)最多用 4 个字母表示(8 = VIII),因此「罗马数字」的长度最多不超过「阿拉伯数字」长度的 $4$ 倍(同一数量级内)。对应输入值 $n$ 而言,长度约为 $\\log{n}$,因此「罗马数字」的长度不超过 $4 * \\log{n}$。复杂度为 $O(\\log{n})$\n* 空间复杂度:虽然使用了两个数组记录罗马字符和数值,但消耗的空间固定,不随着样本大小而变化。复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.12` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/11-20/13. 罗马数字转整数（简单）.md", "url_title": "13. 罗马数字转整数", "url": "https://leetcode-cn.com/problems/roman-to-integer/solution/shua-chuan-lc-ha-xi-biao-by-ac_oier-mooy/", "difficulty": "简单", "tags": ["模拟", "哈希表"], "question": "罗马数字包含以下七种字符: I, V, X, L,C,D 和 M。\n```\n字符          数值\nI             1\nV             5\nX             10\nL             50\nC             100\nD             500\nM             1000\n```\n例如, 罗马数字 2 写做 II ,即为两个并列的 1。12 写做 XII ,即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。\n\n通常情况下,罗马数字中小的数字在大的数字的右边。但也存在特例,例如 4 不写做 IIII,而是 IV。数字 1 在数字 5 的左边,所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地,数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况:\n\n* I 可以放在 V (5) 和 X (10) 的左边,来表示 4 和 9。\n* X 可以放在 L (50) 和 C (100) 的左边,来表示 40 和 90。 \n* C 可以放在 D (500) 和 M (1000) 的左边,来表示 400 和 900。\n\n给定一个罗马数字,将其转换成整数。输入确保在 1 到 3999 的范围内。\n\n示例 1:\n```\n输入: \"III\"\n输出: 3\n```\n示例 2:\n```\n输入: \"IV\"\n输出: 4\n```\n示例 3:\n```\n输入: \"IX\"\n输出: 9\n```\n示例 4:\n```\n输入: \"LVIII\"\n输出: 58\n解释: L = 50, V= 5, III = 3.\n```\n示例 5:\n```\n输入: \"MCMXCIV\"\n输出: 1994\n解释: M = 1000, CM = 900, XC = 90, IV = 4.\n```\n\n提示:\n* $1 <= s.length <= 15$\n* `s` 仅含字符 ('I', 'V', 'X', 'L', 'C', 'D', 'M')\n* 题目数据保证 s 是一个有效的罗马数字,且表示整数在范围 [1, 3999] 内\n* 题目所给测试用例皆符合罗马数字书写规则,不会出现跨位等情况。\n* IL 和 IM 这样的例子并不符合题目要求,49 应该写作 XLIX,999 应该写作 CMXCIX 。", "solution": "### 模拟\n\n与 [12. 整数转罗马数字](https://leetcode-cn.com/problems/integer-to-roman/solution/gong-shui-san-xie-12-zheng-shu-zhuan-luo-b9kw/) 类似,现实中每一个「罗马数字」固定对应一个「阿拉伯数字」。\n\n因此这是一个按照固定规则进行转换的「模拟」过程。\n\n根据题意,我们可以列举出有限个罗马字符和其对应的数值。\n\n然后从左到右匹配罗马数字,优先匹配数值高的罗马字符即可。\n\n代码:\n```Java\nclass Solution {\n    int[] val = new int[]{1000,900,500,400,100,90,50,40,10,9,5,4,1};\n    String[] str = new String[]{\"M\",\"CM\",\"D\",\"CD\",\"C\",\"XC\",\"L\",\"XL\",\"X\",\"IX\",\"V\",\"IV\",\"I\"};\n    public int romanToInt(String s) {\n        int n = s.length();\n        int ans = 0;\n        for (int i = 0, j = 0; i < str.length && j < n; i++) {\n            int cv = val[i];\n            String cs = str[i];\n            int size = cs.length();\n            while (j + size <= n && s.substring(j, j + size).equals(cs)) {\n                ans += cv;\n                j += size;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:通过映射对应关系,我们发现每一位「罗马数字字符」都对应特定的数值,将对应数值添加到答案的复杂度为 $O(1)$。复杂度为 $O(n)$\n* 空间复杂度:虽然使用了两个数组记录罗马字符和数值,但消耗的空间固定,不随着样本大小而变化。复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.13` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/11-20/14. 最长公共前缀（简单）.md", "url_title": "14. 最长公共前缀", "url": "https://leetcode-cn.com/problems/longest-common-prefix/solution/shua-chuan-lc-die-dai-mo-ni-by-ac_oier-8t4q/", "difficulty": "简单", "tags": ["模拟"], "question": "编写一个函数来查找字符串数组中的最长公共前缀。\n\n如果不存在公共前缀,返回空字符串 `\"\"`。\n\n示例 1:\n```\n输入:strs = [\"flower\",\"flow\",\"flight\"]\n输出:\"fl\"\n```\n示例 2:\n```\n输入:strs = [\"dog\",\"racecar\",\"car\"]\n输出:\"\"\n解释:输入不存在公共前缀。\n```\n\n提示:\n* $0 <= strs.length <= 200$\n* $0 <= strs[i].length <= 200$\n* `strs[i]` 仅由小写英文字母组成", "solution": "### 朴素解法\n\n对每个字符串进行逐位检查,直到不满足公共前缀。\n\n代码:\n```Java\nclass Solution {\n    public String longestCommonPrefix(String[] ss) {\n        String ans = \"\";\n        if (ss.length == 0) return ans;\n        for (int i = 0; i < Integer.MAX_VALUE; i++) {\n            String s = ss[0];\n            if (i >= s.length()) return ans;\n            char c = ss[0].charAt(i);\n            for (String item : ss) {\n                if (i >= item.length() || item.charAt(i) != c) return ans;\n            }\n            ans += String.valueOf(c);\n        }\n        return ans;\n    }\n}\n```\n说明:判断条件不一定要写成 `i < Integer.MAX_VALUE`,题目给出了范围是 200 以内,写成 `i <= 200` 也可以。不影响执行效率。\n* 时间复杂度:对于 $n$ 个字符串,都需要遍历到公共前缀长度 m。复杂度为 $O(n \\times m)$\n* 空间复杂度:需要存储公共前缀作为答案返回。复杂度为 $O(m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.14` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/11-20/15. 三数之和（中等）.md", "url_title": "15. 三数之和", "url": "https://leetcode-cn.com/problems/3sum/solution/shua-chuan-lc-pai-xu-shuang-zhi-zhen-jie-cd8r/", "difficulty": "中等", "tags": ["双指针", "排序", "n 数之和"], "question": "给你一个包含 $n$ 个整数的数组 `nums`,判断 `nums` 中是否存在三个元素 `a`,`b`,`c` ,使得 `a + b + c = 0` ?\n\n请你找出所有和为 $0$ 且不重复的三元组。\n\n注意:答案中不可以包含重复的三元组。\n\n示例 1:\n```\n输入:nums = [-1,0,1,2,-1,-4]\n\n输出:[[-1,-1,2],[-1,0,1]]\n```\n示例 2:\n```\n输入:nums = []\n\n输出:[]\n```\n示例 3:\n```\n输入:nums = [0]\n\n输出:[]\n```\n\n提示:\n* $0 <= nums.length <= 3000$\n* $-10^5 <= nums[i] <= 10^5$", "solution": "### 排序 + 双指针\n\n对数组进行排序,使用三个指针 `i`、`j` 和 `k` 分别代表要找的三个数。\n\n1. 通过枚举 `i` 确定第一个数,另外两个指针 `j`,`k` 分别从左边 `i + 1` 和右边 `n - 1` 往中间移动,找到满足 `nums[i] + nums[j] + nums[k] == 0` 的所有组合。\n\n2. `j` 和 `k` 指针的移动逻辑,分情况讨论 `sum = nums[i] + nums[j] + nums[k]` :\n    * `sum` > 0:`k` 左移,使 `sum` 变小\n    * `sum` < 0:`j` 右移,使 `sum` 变大\n    * `sum` = 0:找到符合要求的答案,存起来\n\n由于题目要求答案不能包含重复的三元组,所以在确定第一个数和第二个数的时候,要跳过数值一样的下标(在三数之和确定的情况下,确保第一个数和第二个数不会重复,即可保证三元组不重复)。\n\nJava 代码:\n```Java\nclass Solution {\n    public List<List<Integer>> threeSum(int[] nums) {\n        Arrays.sort(nums);\n        int n = nums.length;\n        List<List<Integer>> ans = new ArrayList<>();\n        for (int i = 0; i < n; i++) {\n            if (i > 0 && nums[i] == nums[i - 1]) continue;\n            int j = i + 1, k = n - 1;\n            while (j < k) {\n                while (j > i + 1 && j < n && nums[j] == nums[j - 1]) j++;\n                if (j >= k) break;\n                int sum = nums[i] + nums[j] + nums[k];\n                if (sum == 0) {\n                    ans.add(Arrays.asList(nums[i], nums[j], nums[k]));\n                    j++;\n                } else if (sum > 0) {\n                    k--;\n                } else if (sum < 0) {\n                    j++;\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<vector<int>> threeSum(vector<int>& nums) {\n        sort(nums.begin(), nums.end());\n        int n = nums.size();\n        vector<vector<int>> ans;\n        for (int i = 0; i < n; i++) {\n            if (i > 0 && nums[i] == nums[i - 1]) continue;\n            int j = i + 1, k = n - 1;\n            while (j < k) {\n                while (j > i + 1 && j < n && nums[j] == nums[j - 1]) j++;\n                if (j >= k) break;\n                int sum = nums[i] + nums[j] + nums[k];\n                if (sum == 0) {\n                    ans.push_back({nums[i], nums[j], nums[k]});\n                    j++;\n                } else if (sum > 0) {\n                    k--;\n                } else if (sum < 0) {\n                    j++;\n                }\n            }\n        }\n        return ans;   \n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def threeSum(self, nums: List[int]) -> List[List[int]]:\n        nums.sort()\n        n = len(nums)\n        ans = []\n        for i in range(n):\n            if i > 0 and nums[i] == nums[i - 1]: continue\n            j, k = i + 1, n - 1\n            while j < k:\n                while j > i + 1 and j < n and nums[j] == nums[j - 1]:\n                    j += 1\n                if j >= k: break\n                _sum = nums[i] + nums[j] + nums[k]\n                if _sum == 0:\n                    ans.append([nums[i], nums[j], nums[k]])\n                    j += 1\n                elif _sum > 0:\n                    k -= 1\n                elif _sum < 0:\n                    j += 1\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction threeSum(nums: number[]): number[][] {\n    nums.sort((a, b) => a - b);\n    const n = nums.length;\n    const ans = [];\n    for (let i = 0; i < n; i++) {\n        if (i > 0 && nums[i] === nums[i - 1]) continue;\n        let j = i + 1, k = n - 1;\n        while (j < k) {\n            while (j > i + 1 && j < n && nums[j] === nums[j - 1]) j++;\n            if (j >= k) break;\n            const sum = nums[i] + nums[j] + nums[k];\n            if (sum === 0) {\n                ans.push([nums[i], nums[j], nums[k]]);\n                j++;\n            } else if (sum > 0) {\n                k--;\n            } else if (sum < 0) {\n                j++;\n            }\n        }\n    }\n    return ans;\n};\n```\n* 时间复杂度:排序的复杂度为 $O(n\\log{n})$,对于每个 `i` 而言,最坏的情况 `j` 和 `k` 都要扫描一遍数组的剩余部分,复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.15` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/11-20/16. 最接近的三数之和（中等）.md", "url_title": "16. 最接近的三数之和", "url": "https://leetcode-cn.com/problems/3sum-closest/solution/shua-chuan-lc-pai-xu-shuang-zhi-zhen-jie-p2ou/", "difficulty": "中等", "tags": ["双指针", "排序", "n 数之和"], "question": "给定一个包括 $n$ 个整数的数组 `nums` 和 一个目标值 `target`。\n\n找出 `nums` 中的三个整数,使得它们的和与 `target` 最接近。\n\n返回这三个数的和。\n\n每组输入只存在唯一答案。\n\n示例:\n```\n输入:nums = [-1,2,1,-4], target = 1\n\n输出:2\n\n解释:与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。\n```\n\n提示:\n* $3 <= nums.length <= 10^3$\n* $-10^3 <= nums[i] <= 10^3$\n* $-10^4 <= target <= 10^4$", "solution": "### 排序 + 双指针\n\n对数组进行排序,使用三个指针 `i`、`j` 和 `k` 分别代表要找的三个数。\n\n1. 通过枚举 `i` 确定第一个数,另外两个指针 `j`,`k` 分别从左边 `i + 1` 和右边 `n - 1` 往中间移动,找到满足 `nums[i] + nums[j] + nums[k]` 最接近 `target` 的唯一解。\n\n2. `j` 和 `k` 指针的移动逻辑,分情况讨论 `sum = nums[i] + nums[j] + nums[k]` :\n    * `sum` > `target`:`k` 左移,使 `sum` 变小\n    * `sum` < `target`:`j` 右移,使 `sum` 变大\n    * `sum` = `target`:找到最符合要求的答案,直接返回\n\n为了更快找到答案,对于相同的 `i`,可以直接跳过下标。\n\nJava 代码:\n```Java\nclass Solution {\n    public int threeSumClosest(int[] nums, int target) {\n        Arrays.sort(nums);\n        int n = nums.length, ans = nums[0] + nums[1] + nums[2];\n        for (int i = 0; i < n; i++) {\n            if (i > 0 && nums[i] == nums[i - 1]) continue;\n            int j = i + 1, k = n - 1;\n            while (j < k) {\n                int sum = nums[i] + nums[j] + nums[k];\n                if (Math.abs(sum - target) < Math.abs(ans - target)) ans = sum;\n                if (ans == target) {\n                    return target;\n                } else if (sum > target) {\n                    k--;\n                } else if (sum < target) {\n                    j++;\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int threeSumClosest(vector<int>& nums, int target) {\n        sort(nums.begin(), nums.end());\n        int n = nums.size(), ans = nums[0] + nums[1] + nums[2];\n        for (int i = 0; i < n; i++) {\n            if (i > 0 && nums[i] == nums[i - 1]) continue;\n            int j = i + 1, k = n - 1;\n            while (j < k) {\n                int sum = nums[i] + nums[j] + nums[k];\n                if (abs(sum - target) < abs(ans - target)) ans = sum;\n                if (ans == target) {\n                    return target;\n                } else if (sum > target) {\n                    k--;\n                } else if (sum < target) {\n                    j++;\n                }\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def threeSumClosest(self, nums: List[int], target: int) -> int:\n        nums.sort()\n        n, ans = len(nums), nums[0] + nums[1] + nums[2]\n        for i in range(n):\n            if i > 0 and nums[i] == nums[i - 1]: \n                continue\n            j, k = i + 1, n - 1\n            while j < k:\n                s = nums[i] + nums[j] + nums[k]\n                if abs(s - target) < abs(ans - target):\n                    ans = s\n                if ans == target:\n                    return target\n                elif s > target:\n                    k -= 1\n                elif s < target:\n                    j += 1\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction threeSumClosest(nums: number[], target: number): number {\n    nums.sort((a, b) => a - b);\n    let n = nums.length, ans = nums[0] + nums[1] + nums[2];\n    for (let i = 0; i < n; i++) {\n        if (i > 0 && nums[i] == nums[i - 1]) continue;\n        let j = i + 1, k = n - 1;\n        while (j < k) {\n            const sum = nums[i] + nums[j] + nums[k];\n            if (Math.abs(sum - target) < Math.abs(ans - target)) ans = sum;\n            if (ans == target) {\n                return target;\n            } else if (sum > target) {\n                k--;\n            } else if (sum < target) {\n                j++;\n            }\n        }\n    }\n    return ans;\n};\n```\n* 时间复杂度:排序的复杂度为 $O(n\\log{n})$,对于每个 `i` 而言,最坏的情况 `j` 和 `k` 都要扫描一遍数组的剩余部分,复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(n ^ 2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.16` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/11-20/17. 电话号码的字母组合（中等）.md", "url_title": "17. 电话号码的字母组合", "url": "https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/solution/shua-chuan-lc-dfs-hui-su-jie-fa-by-ac_oi-qa02/", "difficulty": "中等", "tags": ["DFS", "回溯算法"], "question": "给定一个仅包含数字 `2-9` 的字符串,返回所有它能表示的字母组合。\n\n答案可以按「任意顺序」返回。\n\n给出数字到字母的映射如下(与电话按键相同)。注意 $1$ 不对应任何字母。\n\n示例 1:\n\n```\n输入:digits = \"23\"\n\n输出:[\"ad\",\"ae\",\"af\",\"bd\",\"be\",\"bf\",\"cd\",\"ce\",\"cf\"]\n```\n示例 2:\n```\n输入:digits = \"\"\n\n输出:[]\n```\n示例 3:\n```\n输入:digits = \"2\"\n\n输出:[\"a\",\"b\",\"c\"]\n```\n\n提示:\n* $0 <= digits.length <= 4$\n* $digits[i]$ 是范围 `['2','9']` 的一个数字。", "solution": "### 回溯算法\n\n对于字符串 `ds` 中的每一位数字,都有其对应的字母映射数组。\n\n在 DFS 中决策每一位数字应该对应哪一个字母,当决策的位数 `i == n`,代表整个 `ds` 字符串都被决策完毕,将决策结果添加到结果集:\n\n代码:\n```Java\nclass Solution {\n    Map<String, String[]> map = new HashMap<>(){{\n        put(\"2\", new String[]{\"a\", \"b\", \"c\"});\n        put(\"3\", new String[]{\"d\", \"e\", \"f\"});\n        put(\"4\", new String[]{\"g\", \"h\", \"i\"});\n        put(\"5\", new String[]{\"j\", \"k\", \"l\"});\n        put(\"6\", new String[]{\"m\", \"n\", \"o\"});\n        put(\"7\", new String[]{\"p\", \"q\", \"r\", \"s\"});\n        put(\"8\", new String[]{\"t\", \"u\", \"v\"});\n        put(\"9\", new String[]{\"w\", \"x\", \"y\", \"z\"});\n    }};\n    public List<String> letterCombinations(String ds) {\n        int n = ds.length();\n        List<String> ans = new ArrayList<>();\n        if (n == 0) return ans;\n        StringBuilder sb = new StringBuilder();\n        dfs(ds, 0, n, sb, ans);\n        return ans;\n    }\n    void dfs(String ds, int i, int n, StringBuilder sb, List<String> ans) {\n        if (i == n) {\n            ans.add(sb.toString());\n            return;\n        } \n        String key = ds.substring(i, i + 1);\n        String[] all = map.get(key);\n        for (String item : all) {\n            sb.append(item);\n            dfs(ds, i + 1, n, sb, ans);\n            sb.deleteCharAt(sb.length() - 1);\n        }\n    }\n}\n```\n* 时间复杂度:`n` 代表字符串 `ds` 的长度,一个数字最多对应 4 个字符(7 对应 “pqrs\"),即每个数字最多有 4 个字母需要被决策。复杂度为 $O(4^n)$\n* 空间复杂度:有多少种方案,就需要多少空间来存放答案。复杂度为 $O(4^n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.17` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/11-20/18. 四数之和（中等）.md", "url_title": "18. 四数之和", "url": "https://leetcode-cn.com/problems/4sum/solution/shua-chuan-lc-pai-xu-shuang-zhi-zhen-jie-dqx7/", "difficulty": "中等", "tags": ["双指针", "排序", "n 数之和"], "question": "给定一个包含 $n$ 个整数的数组 `nums` 和一个目标值 `t`,判断 `nums` 中是否存在四个元素 `a`,`b`,`c` 和 `d` ,使得 `a + b + c + d` 的值与 `t` 相等?\n\n找出所有满足条件且不重复的四元组。\n\n注意:答案中不可以包含重复的四元组。\n\n示例 1:\n```\n输入:nums = [1,0,-1,0,-2,2], t = 0\n\n输出:[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]\n```\n示例 2:\n```\n输入:nums = [], t = 0\n\n输出:[]\n```\n\n提示:\n* $0 <= nums.length <= 200$\n* $-10^9 <= nums[i] <= 10^9$\n* $-10^9 <= t<= 10^9$", "solution": "### 排序 + 双指针\n\n对数组进行排序,使用四个指针 `i`、`j` 、`k` 和 `p` 分别代表要找的四个数。\n\n1. 通过枚举 `i` 确定第一个数,枚举 `j` 确定第二个数,另外两个指针 `k` 和 `p` 分别从左边 `j + 1` 和右边 `n - 1` 往中间移动,找到满足 `nums[i] + nums[j] + nums[k] + nums[p] == t` 的所有组合。\n\n2. `k` 和 `p` 指针的移动逻辑,分情况讨论 `sum = nums[i] + nums[j] + nums[k] + nums[p]` :\n    * `sum` > `t`:`p` 左移,使 `sum` 变小\n    * `sum` < `t`:`k` 右移,使 `sum` 变大\n    * `sum` = `t`:将组合加入结果集,`k` 右移继续进行检查\n\n题目要求不能包含重复元素,所以我们要对 `i`、`j` 和 `k` 进行去重,去重逻辑是对于相同的数,只使用第一个。\n\nJava 代码:\n```Java\nclass Solution {\n    public List<List<Integer>> fourSum(int[] nums, int t) {\n        Arrays.sort(nums);\n        int n = nums.length;\n        List<List<Integer>> ans = new ArrayList<>();\n        for (int i = 0; i < n; i++) { // 确定第一个数\n            if (i > 0 && nums[i] == nums[i - 1]) continue; // 对第一个数进行去重(相同的数只取第一个)\n            for (int j = i + 1; j < n; j++) { // 确定第二个数\n                if (j > i + 1 && nums[j] == nums[j - 1]) continue; // 对第二个数进行去重(相同的数只取第一个)\n                // 确定第三个数和第四个数\n                int k = j + 1, p = n - 1;\n                while (k < p) {\n                \n                    // 对第三个数进行去重(相同的数只取第一个)\n                    while (k > j + 1 && k < n && nums[k] == nums[k - 1]) k++; \n                    // 如果 k 跳过相同元素之后的位置超过了 p,本次循环结束\n                    if (k >= p) break;\n                    \n                    long sum = 0L + nums[i] + nums[j] + nums[k] + nums[p];\n                    if (sum == t) {\n                        ans.add(Arrays.asList(nums[i], nums[j], nums[k], nums[p]));\n                        k++;\n                    } else if (sum > t) {\n                        p--;\n                    } else if (sum < t) {\n                        k++;\n                    }\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<vector<int>> fourSum(vector<int>& nums, int t) {\n        sort(nums.begin(), nums.end());\n        int n = nums.size();\n        vector<vector<int>> ans;\n        for (int i = 0; i < n; i++) {\n            if (i > 0 && nums[i] == nums[i - 1]) continue;\n            for (int j = i + 1; j < n; j++) {\n                if (j > i + 1 && nums[j] == nums[j - 1]) continue;\n                int k = j + 1, p = n - 1;\n                while (k < p) {\n                    while (k > j + 1 && k < n && nums[k] == nums[k - 1]) k++;\n                    if (k >= p) break;\n                    long sum = 0L + nums[i] + nums[j] + nums[k] + nums[p];\n                    if (sum == t) {\n                        ans.push_back({nums[i], nums[j], nums[k], nums[p]});\n                        k++;\n                    } else if (sum > t) {\n                        p--;\n                    } else if (sum < t) {\n                        k++;\n                    }\n                }\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def fourSum(self, nums: List[int], t: int) -> List[List[int]]:\n        nums.sort()\n        n = len(nums)\n        ans = []\n\n        for i in range(n):\n            if i > 0 and nums[i] == nums[i - 1]: continue\n            for j in range(i + 1, n):\n                if j > i + 1 and nums[j] == nums[j - 1]: continue\n                k, p = j + 1, n - 1\n                while k < p:\n                    while k > j + 1 and k < n and nums[k] == nums[k - 1]:\n                        k += 1\n                    if k >= p: break\n\n                    _sum = nums[i] + nums[j] + nums[k] + nums[p]\n                    if _sum == t:\n                        ans.append([nums[i], nums[j], nums[k], nums[p]])\n                        k += 1\n                    elif _sum > t:\n                        p -= 1\n                    elif _sum < t:\n                        k += 1\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction fourSum(nums: number[], t: number): number[][] {\n    nums.sort((a, b) => a - b);\n    const n = nums.length;\n    const ans = [];\n    for (let i = 0; i < n; i++) {\n        if (i > 0 && nums[i] === nums[i - 1]) continue;\n        for (let j = i + 1; j < n; j++) {\n            if (j > i + 1 && nums[j] === nums[j - 1]) continue;\n            let k = j + 1, p = n - 1;\n            while (k < p) {\n                while (k > j + 1 && k < n && nums[k] === nums[k - 1]) k++;\n                if (k >= p) break;\n                const sum = nums[i] + nums[j] + nums[k] + nums[p];\n                if (sum === t) {\n                    ans.push([nums[i], nums[j], nums[k], nums[p]]);\n                    k++;\n                } else if (sum > t) {\n                    p--;\n                } else if (sum < t) {\n                    k++;\n                }\n            }\n        }\n    }\n    return ans;\n};\n```\n* 时间复杂度:`i` 和 `j` 是直接枚举确定,复杂度为 $O(n^2)$,当确定下来 `i` 和 `j` 之后,通过双指针确定 `k` 和 `p` ,也就是对于每一组 `i` 和 `j` 而言复杂度为 $O(n)$。总的复杂度为 $O(n^3)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.18` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/11-20/19. 删除链表的倒数第 N 个结点（中等）.md", "url_title": "19. 删除链表的倒数第 N 个结点", "url": "https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/solution/shua-chuan-lc-lian-biao-kuai-man-zhi-zhe-1gs1/", "difficulty": "中等", "tags": ["链表", "快慢指针", "双指针"], "question": "给你一个链表,删除链表的倒数第 `n` 个结点,并且返回链表的头结点。\n\n进阶:你能尝试使用一趟扫描实现吗?\n\n示例 1:\n\n```\n输入:head = [1,2,3,4,5], n = 2\n\n输出:[1,2,3,5]\n```\n示例 2:\n```\n输入:head = [1], n = 1\n\n输出:[]\n```\n示例 3:\n```\n输入:head = [1,2], n = 1\n\n输出:[1]\n```\n\n提示:\n* 链表中结点的数目为 `sz`\n* $1 <= sz <= 30$\n* $0 <= Node.val <= 100$\n* $1 <= n <= sz$", "solution": "### 快慢指针\n\n删除链表的倒数第 `n` 个结点,首先要确定倒数第 `n` 个节点的位置。\n\n我们可以设定两个指针,分别为 `slow` 和 `fast`,刚开始都指向 head。\n\n然后先让 `fast` 往前走 `n` 步,`slow` 指针不动,这时候两个指针的距离为 `n`。\n\n再让 `slow` 和 `fast` 同时往前走(保持两者距离不变),直到 `fast` 指针到达结尾的位置。\n\n这时候 `slow` 会停在待删除节点的前一个位置,让 `slow.next = slow.next.next` 即可。\n\n但这里有一个需要注意的边界情况是:如果链表的长度是 `L`,而我们恰好要删除的是倒数第 `L` 个节点(删除头节点),这时候 `fast` 往前走 `n` 步之后会变为 null,此时我们只需要让 `head = slow.next` 即可删除。\n\n代码:\n```Java\nclass Solution {\n    public ListNode removeNthFromEnd(ListNode head, int n) {\n        if (head.next == null) return null;\n        ListNode slow = head, fast = head;\n        while (n-- > 0) fast = fast.next;\n        if (fast == null) {\n            head = slow.next;\n        } else {\n            while (fast.next != null) {\n                slow = slow.next; fast = fast.next;\n            }\n            slow.next = slow.next.next;\n        }\n        return head;\n    }\n}\n```\n* 时间复杂度:需要扫描的长度为链表的长度。复杂度为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.19` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/11-20/20. 有效的括号（简单）.md", "url_title": "20. 有效的括号", "url": "https://leetcode-cn.com/problems/valid-parentheses/solution/shua-chuan-lc-zhan-ascii-chai-zhi-jie-fa-00zo/", "difficulty": "简单", "tags": ["栈", "有效括号"], "question": "给定一个只包括 `'(',')','{','}','[',']'` 的字符串 `s` ,判断字符串是否有效。\n\n有效字符串需满足:\n\n1. 左括号必须用相同类型的右括号闭合。\n\n2. 左括号必须以正确的顺序闭合。\n\n示例 1:\n```\n输入:s = \"()\"\n\n输出:true\n```\n示例 2:\n```\n输入:s = \"()[]{}\"\n\n输出:true\n```\n示例 3:\n```\n输入:s = \"(]\"\n\n输出:false\n```\n示例 4:\n```\n输入:s = \"([)]\"\n\n输出:false\n```\n示例 5:\n```\n输入:s = \"{[]}\"\n\n输出:true\n```\n\n提示:\n* $1 <= s.length <= 10^4$\n* `s` 仅由括号 `'()[]{}'` 组成", "solution": "### 栈 + 哈希表\n\n这是道模拟题,同一类型的括号,一个右括号要对应一个左括号。\n\n不难发现可以直接使用 `栈` 来解决:\n\n代码:\n```Java\nclass Solution {\n    HashMap<Character, Character> map = new HashMap<Character, Character>(){{\n        put(']', '[');\n        put('}', '{');\n        put(')', '(');\n    }};\n    public boolean isValid(String s) {\n        Deque<Character> d = new ArrayDeque<>();\n        for (int i = 0; i < s.length(); i++) {\n            char c = s.charAt(i);\n            if (c == '(' || c == '{' || c == '[') {\n                d.addLast(c);\n            } else {\n                if (!d.isEmpty() && d.peekLast() == map.get(c)) {\n                    d.pollLast();\n                } else {\n                    return false;\n                }\n            }\n        }\n        return d.isEmpty();\n    }\n}\n```\n* 时间复杂度:对字符串 `s` 扫描一遍。复杂度为 $O(n)$\n* 空间复杂度:使用的哈希表空间固定,不随着样本数量变大而变大。复杂度为 $O(1)$\n\n**注意:三叶使用了 `Deque` 双端队列来充当栈,而不是 `Stack`,这也是 JDK 推荐的做法。建议所有的 Java 同学都采用 `Deque` 作为栈。**\n\n**不使用 `Stack` 的原因是 `Stack` 继承自 `Vector`,拥有了动态数组的所有公共 API,并不安全,而且 `Stack` 还犯了面向对象设计的错误:将组合关系当成了继承关系。**\n\n---\n\n### 栈 + ASCII 差值\n\n我们也可以利用 `\"()\"`、`\"{}\"` 和 `\"[]\"` 的左右部分在 ASCII 值上比较接近的事实。\n\n`(` 和 `)` 分别对应 -7 和 -8;`[` 和 `]` 分别对应 43 和 45;`{` 和 `}` 分别对应 75 和 77。\n\n也就是同类型的左右括号,相差不超过 2 ,同时不同类型的左右括号,相差大于 2。\n\n利用此特性,我们可以节省一个哈希表:\n\n代码:\n```Java\nclass Solution {\n    public boolean isValid(String s) {\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < s.length(); i++) {\n            char c = s.charAt(i);\n            int u = c - '0';\n            if (c == '(' || c == '{' || c == '[') {\n                d.addLast(u);\n            } else {\n                if (!d.isEmpty() && Math.abs(d.peekLast() - u) <= 2) {\n                    d.pollLast();\n                } else {\n                    return false;\n                }\n            }\n        }\n        return d.isEmpty();\n    }\n}\n```\n* 时间复杂度:对字符串 `s` 扫描一遍。复杂度为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.20` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1101-1110/1104. 二叉树寻路（中等）.md", "url_title": "1104. 二叉树寻路", "url": "https://leetcode-cn.com/problems/path-in-zigzag-labelled-binary-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-rw2d/", "difficulty": "中等", "tags": ["二叉树", "模拟", "数学"], "question": "在一棵无限的二叉树上,每个节点都有两个子节点,树中的节点 逐行 依次按 “之” 字形进行标记。\n\n如下图所示,在奇数行(即,第一行、第三行、第五行......)中,按从左到右的顺序进行标记;\n\n而偶数行(即,第二行、第四行、第六行......)中,按从右到左的顺序进行标记。\n\n给你树上某一个节点的标号 label,请你返回从根节点到该标号为 label 节点的路径,该路径是由途经的节点标号所组成的。 \n\n示例 1:\n```\n输入:label = 14\n\n输出:[1,3,4,14]\n```\n示例 2:\n```\n输入:label = 26\n\n输出:[1,2,6,10,26]\n```\n\n提示:\n* 1 <= label <= $10^6$", "solution": "### 模拟\n\n一个朴素的做法是根据题意进行模拟。\n\n利用从根节点到任意一层都是满二叉树,我们可以先确定 `label` 所在的层级 `level`,然后计算出当前层起始节点值(最小值)和结束节点值(最大值)。\n\n再利用「每层节点数量翻倍」&「隔层奇偶性翻转」,寻址出上一层的节点下标(令每层下标均「从左往右」计算,并从 $1$ 开始),直到构造出答案(寻址到根节点)。\n\n代码:\n```Java\nclass Solution {\n    // 第 level 层的起始节点值\n    int getStart(int level) {\n        return (int)Math.pow(2, level - 1);\n    }\n    // 第 level 层的结束节点值\n    int getEnd(int level) {\n        int a = getStart(level);\n        return a + a - 1;\n    }\n    public List<Integer> pathInZigZagTree(int n) {\n        // 计算 n 所在层级\n        int level = 1;\n        while (getEnd(level) < n) level++;\n\n        int[] ans = new int[level];\n        int idx = level - 1, cur = n;\n        while (idx >= 0) {\n            ans[idx--] = cur;\n            int tot = (int)Math.pow(2, level - 1);\n            int start = getStart(level), end = getEnd(level);\n            if (level % 2 == 0) {\n                // 当前层为偶数层,则当前层节点「从右往左」数值递增,相应计算上一层下标也应该「从右往左」\n                int j = tot / 2;\n                for (int i = start; i <= end; i += 2, j--) {\n                    if (i == cur || (i + 1) == cur) break;\n                }\n                int prevStart = getStart(level - 1);\n                while (j-- > 1) prevStart++;\n                cur = prevStart;\n            } else {\n                // 当前层为奇数层,则当前层节点「从左往右」数值递增,相应计算上一层下标也应该「从左往右」\n                int j = 1;\n                for (int i = start; i <= end; i += 2, j++) {\n                    if (i == cur || (i + 1) == cur) break;\n                }\n                int prevEnd = getEnd(level - 1);\n                while (j-- > 1) prevEnd--;\n                cur = prevEnd;\n            }\n            level--;\n        }\n        List<Integer> list = new ArrayList<>();\n        for (int i : ans) list.add(i);\n        return list;\n    }\n}\n```\n* 时间复杂度:确定 $n$ 所在层级复杂度为 $O(\\log{n})$;构造答案最坏情况下每个节点会被遍历一次,复杂度为 $O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 数学\n\n上述解法复杂度上界取决于「由当前行节点位置确定上层位置」的线性遍历。\n\n如果二叉树本身不具有奇偶性翻转的话,显然某个节点 $x$ 的父节点为 $\\left \\lfloor x / 2 \\right \\rfloor$,但事实上存在奇偶性翻转,而在解法一中我们已经可以 $O(1)$ 计算某一层的起始值和结束值,有了「起始值 & 结算值」和「当前节点所在层的相对位置」,只需要利用“对称性”找到父节点在上层的相应位置,然后根据相应位置算出父节点值即可。\n\n代码:\n```Java\nclass Solution {\n    int getStart(int level) {\n        return (int)Math.pow(2, level - 1);\n    }\n    int getEnd(int level) {\n        int a = getStart(level);\n        return a + a - 1;\n    }\n    public List<Integer> pathInZigZagTree(int n) {\n        int level = 1;\n        while (getEnd(level) < n) level++;\n        int[] ans = new int[level];\n        int idx = level - 1, cur = n;\n        while (idx >= 0) {\n            ans[idx--] = cur;\n            int loc = ((1 << (level)) - 1 - cur) >> 1;\n            cur = (1 << (level - 2)) + loc;\n            level--;\n        }\n        List<Integer> list = new ArrayList<>();\n        for (int i : ans) list.add(i);\n        return list;\n    }\n}\n```\n* 时间复杂度:复杂度上界取决于确定 $n$ 所在层级。复杂度为 $O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1104` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1101-1110/1106. 解析布尔表达式（困难）.md", "url_title": "1106. 解析布尔表达式", "url": "https://leetcode.cn/problems/parsing-a-boolean-expression/solution/by-ac_oier-jr29/", "difficulty": "困难", "tags": ["栈", "表达式计算"], "question": "给你一个以字符串形式表述的 布尔表达式 `(boolean) expression`,返回该式的运算结果。\n\n有效的表达式需遵循以下约定:\n\n* `\"t\"`,运算结果为 `True`\n* `\"f\"`,运算结果为 `False`\n* `\"!(expr)\"`,运算过程为对内部表达式 `expr` 进行逻辑 非的运算(`NOT`)\n* `\"&(expr1,expr2,...)\"`,运算过程为对 `2` 个或以上内部表达式 `expr1, expr2, ...` 进行逻辑 与的运算(`AND`)\n* `\"|(expr1,expr2,...)\"`,运算过程为对 `2` 个或以上内部表达式 `expr1, expr2, ...` 进行逻辑 或的运算(`OR`)\n\n示例 1:\n```\n输入:expression = \"!(f)\"\n\n输出:true\n```\n示例 2:\n```\n输入:expression = \"|(f,t)\"\n\n输出:true\n```\n示例 3:\n```\n输入:expression = \"&(t,f)\"\n\n输出:false\n```\n示例 4:\n```\n输入:expression = \"|(&(t,f,t),!(t))\"\n\n输出:false\n```\n\n提示:\n* $1 <= expression.length <= 20000$\n* `expression[i]` 由 `{'(', ')', '&', '|', '!', 't', 'f', ','}` 中的字符组成。\n* `expression` 是以上述形式给出的有效表达式,表示一个布尔值。", "solution": "### 双栈\n\n为了方便,我们令 `expression` 为 `s`。\n\n我们可以将 `t` 和 `f` 看做操作数,而 `|`、`&` 和 `!` 看做操作符,创建两个栈 `nums` 和 `ops` 分别对其进行存储。\n\n剩余的 `()` 和 `,` 则只是优先级和分隔符,无须额外关注。\n\n从前往后处理 `s`,根据当前处理的字符为何值进行分情况讨论:\n\n* `,`:分隔符,直接跳过;\n* `t` 或 `f`:操作数,添加到 `nums` 栈中;\n* `|`、`&` 或 `!`:操作符,添加到 `ops` 栈中;\n* `(`:子表达式的左端点,为了在我们从「双栈」中取出数值和符号计算时,可以知道某个子表达式计算完成,需要记录一下。往 `nums` 追加一个占位符号 `-` 来代指;\n* `)`:子表达式的右端点,代表一个子表达式的结束。可从「双栈」中取出符号和数组进行计算(在 `ops` 中仅取栈顶元素,代表当前子表达式的操作符;而在 `nums` 中则取到代表左端点的占位元素 `-` 为止),并将结果重新放入 `nums` 中。\n\n最后考虑如何计算最简表达式,考虑实现一个 `char calc(char a, char b, char op)` 函数,代表对操作数 `a` 和 `b` 执行 `op` 操作并进行结果返回。\n\n实际上,在 `calc` 函数我们只区分 `|` 操作和其他操作即可。也就是说 `&` 和 `!` 均当做 `&` 来做,`!` 操作在计算完整个表达式后再翻转。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean parseBoolExpr(String s) {\n        Deque<Character> nums = new ArrayDeque<>(), ops = new ArrayDeque<>();\n        for (char c : s.toCharArray()) {\n            if (c == ',') continue;\n            if (c == 't' || c == 'f') nums.addLast(c);\n            if (c == '|' || c == '&' || c == '!') ops.addLast(c);\n            if (c == '(') nums.addLast('-');\n            if (c == ')') {\n                char op = ops.pollLast(), cur = ' ';\n                while (!nums.isEmpty() && nums.peekLast() != '-') {\n                    char top = nums.pollLast();\n                    cur = cur == ' ' ? top : calc(top, cur, op);\n                }\n                if (op == '!') cur = cur == 't' ? 'f' : 't';\n                nums.pollLast(); nums.addLast(cur);\n            }\n        }\n        return nums.peekLast() == 't';\n    }\n    char calc(char a, char b, char op) {\n        boolean x = a == 't', y = b == 't';\n        boolean ans = op == '|' ? x | y : x & y;\n        return ans ? 't' : 'f';\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool parseBoolExpr(string s) {\n        deque<char> nums, ops;\n        for (char c : s) {\n            if (c == ',') continue;\n            if (c == 't' || c == 'f') nums.push_back(c);\n            if (c == '|' || c == '&' || c == '!') ops.push_back(c);\n            if (c == '(') nums.push_back('-');\n            if (c == ')') {\n                char op = ops.back(); ops.pop_back();\n                char cur = ' ';\n                while (!nums.empty() && nums.back() != '-') {\n                    char top = nums.back(); nums.pop_back();\n                    cur = cur == ' ' ? top : calc(top, cur, op);\n                }\n                if (op == '!') cur = cur == 't' ? 'f' : 't';\n                nums.pop_back(); nums.push_back(cur);\n            }\n        }\n        return nums.back() == 't';\n    }\n    char calc(char a, char b, char op) {\n        bool x = a == 't', y = b == 't';\n        bool ans = op == '|' ? x | y : x & y;\n        return ans ? 't' : 'f';\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def parseBoolExpr(self, s: str) -> bool:\n        def calc(a, b, op):\n            x, y = a == 't', b == 't'\n            ans = x | y if op == '|' else x & y\n            return 't' if ans else 'f'\n        nums, ops = [], []\n        for c in s:\n            if c == ',':\n                continue\n            if c == 't' or c == 'f':\n                nums.append(c)\n            if c == '|' or c == '&' or c == '!':\n                ops.append(c)\n            if c == '(':\n                nums.append('-')\n            if c == ')':\n                op, cur = ops.pop(), ' '\n                while nums and nums[-1] != '-':\n                    top = nums.pop()\n                    cur = top if cur == ' ' else calc(cur, top, op)\n                if op == '!':\n                    cur = 't' if cur == 'f' else 'f'\n                nums.pop()\n                nums.append(cur)\n        return nums[-1] == 't'\n```\nTypeScript 代码:\n```TypeScript\nfunction parseBoolExpr(s: string): boolean {\n    function calc(a: string, b: string, op: string): string {\n        const x = a == 't', y = b == 't'\n        const ans = op == '|' ? x || y : x && y\n        return ans ? 't' : 'f'\n    }\n    const nums = new Array<string>(s.length).fill(''), ops = new Array<string>(s.length).fill('')\n    let idx1 = 0, idx2 = 0\n    for (const c of s) {\n        if (c == ',') continue\n        if (c == 't' || c == 'f') nums[idx1++] = c\n        if (c == '|' || c == '&' || c == '!') ops[idx2++] = c\n        if (c == '(') nums[idx1++] = '-'\n        if (c == ')') {\n            let op = ops[--idx2], cur = ' '\n            while (idx1 > 0 && nums[idx1 - 1] != '-') {\n                const top = nums[--idx1]\n                cur = cur == ' ' ? top : calc(top, cur, op)\n            }\n            if (op == '!') cur = cur == 't' ? 'f' : 't'\n            idx1--; nums[idx1++] = cur\n        }\n    }\n    return nums[idx1 - 1] == 't'\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1106` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1101-1110/1108. IP 地址无效化（简单）.md", "url_title": "1108. IP 地址无效化", "url": "https://leetcode.cn/problems/defanging-an-ip-address/solution/by-ac_oier-cndi/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个有效的 `IPv4` 地址 `address`,返回这个 `IP` 地址的无效化版本。\n\n所谓无效化 `IP` 地址,其实就是用 `\"[.]\"` 代替了每个 `\".\"`。\n\n示例 1:\n```\n输入:address = \"1.1.1.1\"\n\n输出:\"1[.]1[.]1[.]1\"\n```\n示例 2:\n```\n输入:address = \"255.100.50.0\"\n\n输出:\"255[.]100[.]50[.]0\"\n```\n\n提示:\n* 给出的 `address` 是一个有效的 `IPv4` 地址", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n代码:\n```Java\nclass Solution {\n    public String defangIPaddr(String s) {\n        StringBuilder sb = new StringBuilder();\n        int n = s.length(), idx = -1;\n        while (++idx < n) {\n            char c = s.charAt(idx);\n            if (c == '.') sb.append('[');\n            sb.append(c);\n            if (c == '.') sb.append(']');\n        }\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1108` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1101-1110/1109. 航班预订统计（中等）.md", "url_title": "1109. 航班预订统计", "url": "https://leetcode-cn.com/problems/corporate-flight-bookings/solution/gong-shui-san-xie-yi-ti-shuang-jie-chai-fm1ef/", "difficulty": "中等", "tags": ["区间求和问题", "差分", "线段树"], "question": "这里有 $n$ 个航班,它们分别从 $1$ 到 $n$ 进行编号。\n\n有一份航班预订表 `bookings`,表中第 $i$ 条预订记录 $bookings[i] = [first_i, last_i, seats_i]$ 意味着在从 $first_i$ 到 $last_i$ (包含 $first_i$ 和 $last_i$ )的 每个航班 上预订了 $seats_i$ 个座位。\n\n请你返回一个长度为 $n$ 的数组 `answer`,其中 $answer[i]$ 是航班 $i$ 上预订的座位总数。\n\n示例 1:\n```\n输入:bookings = [[1,2,10],[2,3,20],[2,5,25]], n = 5\n\n输出:[10,55,45,25,25]\n\n解释:\n航班编号        1   2   3   4   5\n预订记录 1 :   10  10\n预订记录 2 :       20  20\n预订记录 3 :       25  25  25  25\n总座位数:      10  55  45  25  25\n因此,answer = [10,55,45,25,25]\n```\n示例 2:\n```\n输入:bookings = [[1,2,10],[2,2,15]], n = 2\n\n输出:[10,25]\n\n解释:\n航班编号        1   2\n预订记录 1 :   10  10\n预订记录 2 :       15\n总座位数:      10  25\n因此,answer = [10,25]\n```\n提示:\n* $1 <= n <= 2 * 10^4$\n* $1 <= bookings.length <= 2 * 10^4$\n* $bookings[i].length == 3$\n* $1 <= first_i <= last_i <= n$\n* $1 <= seats_i <= 10^4$", "solution": "### 基本分析\n\n本题只涉及「区间修改 + 单点查询」,属于「区间求和」问题中的入门难度。\n\n对于各类「区间求和」问题,该用什么方式进行求解,之前在 [这里](https://leetcode-cn.com/problems/range-sum-query-mutable/solution/guan-yu-ge-lei-qu-jian-he-wen-ti-ru-he-x-41hv/) 提到过。\n\n此处可以再总结一下(加粗字体为最佳方案):\n\n* 数组不变,区间查询:**前缀和**、树状数组、线段树;\n* 数组单点修改,区间查询:**树状数组**、线段树;\n* 数组区间修改,单点查询:**差分**、线段树;\n* 数组区间修改,区间查询:**线段树**。\n\n> 注意:上述总结是对于一般性而言的(能直接解决的),对标的是模板问题。\n但存在经过一些经过“额外”操作,对问题进行转化,从而使用别的解决方案求解的情况。\n例如某些问题,我们可以先对原数组进行差分,然后使用树状数组,也能解决区间修改问题。\n或者使用多个树状数组来维护多个指标,从而实现类似线段树的持久化标记操作。\n但这些不属于一般性,所以就不添加到题解了。\n\n---\n\n### 差分\n\n本题只涉及「区间修改 + 单点查询」,因此是一道「差分」的模板题。\n\n「差分」可以看做是求「前缀和」的逆向过程。\n\n对于一个「将区间 $[l, r]$ 整体增加一个值 $v$」操作,我们可以对差分数组 $c$ 的影响看成两部分:\n\n* 对 $c[l] += v$:由于差分是前缀和的逆向过程,这个操作对于将来的查询而言,带来的影响是对于所有的下标大于等于 $l$ 的位置都增加了值 $v$;\n* 对 $c[r + 1] -= v$:由于我们期望只对 $[l, r]$ 产生影响,因此需要对下标大于 $r$ 的位置进行减值操作,从而抵消“影响”。\n\n对于最后的构造答案,可看做是对每个下标做“单点查询”操作,只需要对差分数组求前缀和即可。\n\n代码:\n```Java\nclass Solution {\n    public int[] corpFlightBookings(int[][] bs, int n) {\n        int[] c = new int[n + 1];\n        for (int[] bo : bs) {\n            int l = bo[0] - 1, r = bo[1] - 1, v = bo[2];\n            c[l] += v;\n            c[r + 1] -= v;\n        }\n        int[] ans = new int[n];\n        ans[0] = c[0];\n        for (int i = 1; i < n; i++) {\n            ans[i] = ans[i - 1] + c[i];\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 `bs` 长度为 $m$,预处理差分数组的复杂度为 $O(m)$;构造答案复杂度为 $O(n)$。整体复杂度为 $O(m + n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 线段树\n\n在「基本分析」中,我们发现几乎所有的「区间求和」问题都可以使用线段树解决。\n\n那么是否无脑写线段树呢?答案并不是,恰好相反。\n\n线段树代码很长,且常数很大,实际表现不算很好。只有不得不写「线段树」的时候,我们才考虑线段树。\n\n回到本题,由于涉及「区间修改」操作,因此我们需要对线段树进行持久化标记(懒标记),从而确保操作仍为 $\\log$ 级别的复杂度。\n\n代码:\n```Java\nclass Solution {\n    class Node {\n        int l, r, v, add;\n        Node(int _l, int _r) {\n            l = _l; r = _r;\n        }\n    }\n    int N = 20009;\n    Node[] tr = new Node[N * 4];\n    void pushup(int u) {\n        tr[u].v = tr[u << 1].v + tr[u << 1 | 1].v;\n    }\n    void pushdown(int u) {\n        int add = tr[u].add;\n        tr[u << 1].v += add;\n        tr[u << 1].add += add;\n        tr[u << 1 | 1].v += add;\n        tr[u << 1 | 1].add += add;\n        tr[u].add = 0;\n    }\n    void build(int u, int l, int r) {\n        tr[u] = new Node(l, r);\n        if (l != r) {\n            int mid = l + r >> 1;\n            build(u << 1, l, mid);\n            build(u << 1 | 1, mid + 1, r);\n        }\n    }\n    void update(int u, int l, int r, int v) {\n        if (l <= tr[u].l && tr[u].r <= r) {\n            tr[u].v += v;\n            tr[u].add += v;\n        } else {\n            pushdown(u);\n            int mid = tr[u].l + tr[u].r >> 1;\n            if (l <= mid) update(u << 1, l, r, v);\n            if (r > mid) update(u << 1 | 1, l, r, v);\n            pushup(u);\n        }\n    }\n    int query(int u, int l, int r) {\n        if (l <= tr[u].l && tr[u].r <= r) {\n            return tr[u].v;\n        } else {\n            pushdown(u);\n            int mid = tr[u].l + tr[u].r >> 1;\n            int ans = 0;\n            if (l <= mid) ans += query(u << 1, l, r);\n            if (r > mid) ans += query(u << 1 | 1, l, r);\n            return ans;\n        }\n    }\n    public int[] corpFlightBookings(int[][] bs, int n) {\n        build(1, 1, n);\n        for (int[] bo : bs) {\n            update(1, bo[0], bo[1], bo[2]);\n        }\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) {\n            ans[i] = query(1, i + 1, i + 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:线段树建树复杂度为 $O(n)$,其余操作复杂度为 $O(\\log{n})$。对于本题,令 `bs` 长度为 $m$,整体复杂度为 $O(m\\log{n} + n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1109` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/111-120/113. 路径总和 II（中等）.md", "url_title": "113. 路径总和 II", "url": "https://acoier.com/2022/12/10/113.%20%E8%B7%AF%E5%BE%84%E6%80%BB%E5%92%8C%20II%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/", "difficulty": "中等", "tags": ["DFS", "二叉树"], "question": "给你二叉树的根节点 `root` 和一个整数目标和 `targetSum`,找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。\n\n叶子节点 是指没有子节点的节点。\n\n示例 1:\n\n```\n输入:root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22\n\n输出:[[5,4,11,2],[5,8,4,5]]\n```\n示例 2:\n\n```\n输入:root = [1,2,3], targetSum = 5\n\n输出:[]\n```\n示例 3:\n```\n输入:root = [1,2], targetSum = 0\n\n输出:[]\n```\n\n提示:\n* 树中节点总数在范围 $[0, 5000]$ 内\n* $-1000 <= Node.val <= 1000$\n* $-1000 <= targetSum <= 1000$", "solution": "### 树的遍历 - DFS\n\n定义 `DFS` 函数 `void dfs(TreeNode root, int cur, int t, List<Integer> path)` 。\n\n其中 `root` 为当前遍历到的节点;`cur` 为当前路径总和;`t` 为目标总和;`path` 为当前路径方案。\n\n剩下的为常规的树的遍历,当 `root` 为叶子节点(既没有左子树,也没有右子树)时,根据 `cur` 是否与 `t` 相等,决定是否要把 `path` 添加到答案中。\n\n代码:\n```Java \nclass Solution {\n    List<List<Integer>> ans = new ArrayList<>();\n    public List<List<Integer>> pathSum(TreeNode root, int t) {\n        if (root != null) dfs(root, root.val, t, new ArrayList<>(){{add(root.val);}});\n        return ans;\n    }\n    void dfs(TreeNode root, int cur, int t, List<Integer> path) {\n        if (root.left == null && root.right == null) {\n            if (cur == t) ans.add(new ArrayList<>(path));\n            return ;\n        }\n        List<TreeNode> list = new ArrayList<>();\n        if (root.left != null) list.add(root.left);\n        if (root.right != null) list.add(root.right);\n        for (TreeNode child : list) {\n            path.add(child.val);\n            dfs(child, cur + child.val, t, path);\n            path.remove(path.size() - 1);\n        }\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.113` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/111-120/115. 不同的子序列（困难）.md", "url_title": "115. 不同的子序列", "url": "https://leetcode.cn/problems/distinct-subsequences/solution/xiang-jie-zi-fu-chuan-pi-pei-wen-ti-de-t-wdtk/", "difficulty": "困难", "tags": ["线性 DP"], "question": "给定一个字符串 `s` 和一个字符串 `t` ,计算在 `s` 的子序列中 `t` 出现的个数。\n\n字符串的一个 子序列 是指,通过删除一些(也可以不删除)字符且不干扰剩余字符相对位置所组成的新字符串。(例如,`\"ACE\"` 是 `\"ABCDE\"` 的一个子序列,而 `\"AEC\"` 不是)\n\n题目数据保证答案符合 `32` 位带符号整数范围。\n\n示例 1:\n```\n输入:s = \"rabbbit\", t = \"rabbit\"\n\n输出:3\n\n解释:\n如下图所示, 有 3 种可以从 s 中得到 \"rabbit\" 的方案。\n(上箭头符号 ^ 表示选取的字母)\nrabbbit\n^^^^ ^^\nrabbbit\n^^ ^^^^\nrabbbit\n^^^ ^^^\n```\n示例 2:\n```\n输入:s = \"babgbag\", t = \"bag\"\n\n输出:5\n\n解释:\n如下图所示, 有 5 种可以从 s 中得到 \"bag\" 的方案。 \n(上箭头符号 ^ 表示选取的字母)\nbabgbag\n^^ ^\nbabgbag\n^^    ^\nbabgbag\n^    ^^\nbabgbag\n  ^  ^^\nbabgbag\n    ^^^\n```\n\n提示:\n* $0 <= s.length, t.length <= 1000$\n* `s` 和 `t` 由英文字母组成", "solution": "### 基本思路\n\n有两个字符串 `s` 和 `t`,长度数量级都为 $10^3$。\n\n一个朴素的想法是,找出所有 `s` 的子序列,与 `t` 进行比较,找所有子序列的复杂度是 $O(2^n)$,肯定会超时。\n\n因此,我们放弃这种朴素思路。\n\n字符串匹配也不具有二段性质,不可能有 $log$ 级别的算法,那么复杂度再往下优化就是 $O(n * m)$ 的递推 DP 做法了。\n\n***\n\n### 动态规划\n\nDP 的状态定义猜测通常是一门经验学科。\n\n**但是,对于两个字符串匹配,一个非常通用的状态定义如下:**\n\n**定义 $f[i][j]$ 为考虑 `s` 中 $[0,i]$ 个字符,`t` 中 $[0,j]$ 个字符的匹配个数。**\n\n那么显然对于某个 $f[i][j]$ 而言,从「最后一步」的匹配进行分析,包含两类决策:\n\n* 不让 `s[i]` 参与匹配,也就是需要让 `s` 中 $[0,i-1]$ 个字符去匹配 `t` 中的 $[0,j]$ 字符。此时匹配值为 $f[i-1][j]$\n* 让 `s[i]` 参与匹配,这时候只需要让 `s` 中 $[0,i-1]$ 个字符去匹配 `t` 中的 $[0,j-1]$ 字符即可,同时满足 `s[i]=t[j]`。此时匹配值为 $f[i-1][j-1]$\n\n最终 $f[i][j]$ 就是两者之和。\n\n代码:\n```java []\nclass Solution {\n    public int numDistinct(String s, String t) {\n        // 技巧:往原字符头部插入空格,这样得到 char 数组是从 1 开始\n        // 同时由于往头部插入相同的(不存在的)字符,不会对结果造成影响,而且可以使得 f[i][0] = 1,可以将 1 这个结果滚动下去\n        int n = s.length(), m = t.length();\n        s = \" \" + s;\n        t = \" \" + t;\n        char[] cs = s.toCharArray(), ct = t.toCharArray();\n        // f(i,j) 代表考虑「s 中的下标为 0~i 字符」和「t 中下标为 0~j 字符」是否匹配\n        int[][] f = new int[n + 1][m + 1];\n        // 原字符只有小写字符,当往两个字符插入空格之后,f[i][0] = 1 是一个显而易见的初始化条件\n        for (int i = 0; i <= n; i++) f[i][0] = 1;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                // 包含两种决策:\n                // 不使用 cs[i] 进行匹配,则有 f[i][j] = f[i - 1][j]\n                f[i][j] = f[i - 1][j];\n                // 使用 cs[i] 进行匹配,则要求 cs[i] == ct[j],然后有  f[i][j] += f[i - 1][j - 1]\n                if (cs[i] == ct[j]) {\n                    f[i][j] += f[i - 1][j - 1];\n                } \n            }\n        }\n        return f[n][m];\n    }\n}\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n \\times m)$\n\n*PS. 需要说明的是,由于中间结果会溢出,CPP 中必须使用 long long,而 Java 不用。由于 Java 中 int 的存储机制,只要在运算过程中只要不涉及取 min、取 max 或者其他比较操作的话,中间结果溢出不会影响最终结果。*\n\n***\n\n### 总结\n\n1. 关于字符串匹配,通常有两种(你也可以理解为一种)通用的状态定义:\n\n* $f[i][j]$ 表示「第一个字符 `s` 中 $[0,i]$ 个字符」与「第二个字符 `t` 中 $[0,j]$ 个字符」的匹配结果\n* $f[i][j]$ 表示「第一个字符 `s` 中 $[0,i]$ 个字符」与「第二个字符 `t` 中 $[0,j]$ 个字符」且 「最后一个字符为 `t[j]`」的匹配结果\n\n2. 往两个字符串的头部追加「不存在」的字符,目的是为了能够构造出可以滚动(被累加)下去的初始化值\n\n***\n\n### 进阶\n\n事实上,关于字符串匹配问题,还有一道稍稍不同的变形的题目。\n\n也是利用了类似的「通用思路」(状态定义) &「技巧」,然后对匹配过程中的字符进行分情况讨论,学有余力的同学可以看看:\n\n[10. 正则表达式匹配](https://leetcode-cn.com/problems/regular-expression-matching/) : [如何利用的「等差」性质降低「正则字符串匹配」算法复杂度 ...](https://leetcode-cn.com/problems/regular-expression-matching/solution/shua-chuan-lc-dong-tai-gui-hua-jie-fa-by-zn9w/)", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.115` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/111-120/117. 填充每个节点的下一个右侧节点指针 II（中等）.md", "url_title": "117. 填充每个节点的下一个右侧节点指针 II", "url": "https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/solutions/2510505/gong-shui-san-xie-xiang-xi-tu-jie-o1-kon-d6vg/", "difficulty": "中等", "tags": ["BFS", "链表"], "question": "给定一个二叉树:\n\n```\nstruct Node {\n  int val;\n  Node *left;\n  Node *right;\n  Node *next;\n}\n```\n\n填充它的每个 `next` 指针,让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点,则将 `next` 指针设置为 `NULL`。\n\n初始状态下,所有 `next` 指针都被设置为 `NULL`。\n\n示例 1:\n\n```\n输入:root = [1,2,3,4,5,null,7]\n\n输出:[1,#,2,3,#,4,5,7,#]\n\n解释:给定二叉树如图 A 所示,你的函数应该填充它的每个 next 指针,以指向其下一个右侧节点,如图 B 所示。序列化输出按层序遍历顺序(由 next 指针连接),'#' 表示每层的末尾。\n```\n示例 2:\n```\n输入:root = []\n\n输出:[]\n```\n\n提示:\n* 树中的节点数在范围 $[0, 6000]$ 内\n* $-100 <= Node.val <= 100$\n\n进阶:\n* 你只能使用常量级额外空间。\n* 使用递归解题也符合要求,本题中递归程序的隐式栈空间不计入额外空间复杂度。", "solution": "### BFS - 层序遍历\n\n一个最直观的做法,是利用 `BFS`  对树进行「层序遍历」。\n\n每个 `BFS`  回合中,对整层节点进行处理。\n\n首先通过 `pop` 拿到当前节点,同时通过 `peek` 拿到当前层的下一节点,并建立 `next` 关系,注意需要跳过每层的最后一个节点。\n\nJava 代码:\n\n```Java\nclass Solution {\n    public Node connect(Node root) {\n        Node ans = root;\n        if (root == null) return ans;\n        Deque<Node> d = new ArrayDeque<>();\n        d.addLast(root);\n        while (!d.isEmpty()) {\n            int sz = d.size();\n            while (sz-- > 0) {\n                Node a = d.pollFirst();\n                if (sz != 0) a.next = d.peekFirst();\n                if (a.left != null) d.addLast(a.left);\n                if (a.right != null) d.addLast(a.right);\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    Node* connect(Node* root) {\n        Node* ans = root;\n        if (root == nullptr) return ans;\n        deque<Node*> d;\n        d.push_back(root);\n        while (!d.empty()) {\n            int sz = d.size();\n            while (sz-- > 0) {\n                Node* a = d.front();\n                d.pop_front();\n                if (sz != 0) a->next = d.front();\n                if (a->left) d.push_back(a->left);\n                if (a->right) d.push_back(a->right);\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def connect(self, root: 'Node') -> 'Node':\n        ans = root\n        if root is None:\n            return ans\n        d = [root]\n        while d:\n            sz = len(d)\n            for i in range(sz):\n                a = d.pop(0)\n                if i != sz - 1:\n                    a.next = d[0]\n                if a.left:\n                    d.append(a.left)\n                if a.right:\n                    d.append(a.right)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction connect(root: Node | null): Node | null {\n    let ans = root;\n    if (root == null) return ans;\n    const d = [root];\n    while (d.length > 0) {\n        let sz = d.length;\n        while (sz-- > 0) {\n            const a = d.shift() as Node;\n            if (sz != 0) a.next = d[0];\n            if (a.left) d.push(a.left);\n            if (a.right) d.push(a.right);\n        }\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### BFS - 逐层构建\n\n上述解法中,每一层节点的 `next` 关系的构建都是独立的。我们构建第 $k$ 层的 `next` 关系时,并没有利用已建好的到第 $k - 1$ 层的 `next` 关系。\n\n实际上,每一层构建好的 `next` 关系都可看做「链表」,可参与到下一层 `next` 关系的构建,同时由于所有节点的起始 `next` 指向都是 `null`,相当于首层的 `next` 关系已经默认建好了。\n\n我们使用图解方式,来感受逐层构建过程:\n\nJava 代码:\n```Java\nclass Solution {\n    public Node connect(Node root) {\n        Node ans = root;\n        if (root == null) return ans;\n        Node cur = root;\n        while (cur != null) {\n            Node head = new Node(-1), tail = head;\n            for (Node i = cur; i != null; i = i.next) {\n                if (i.left != null) tail = tail.next = i.left;\n                if (i.right != null) tail = tail.next = i.right;\n            }\n            cur = head.next;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    Node* connect(Node* root) {\n        auto ans = root;\n        if (root == nullptr) return ans;\n        auto cur = root;\n        while (cur) {\n            auto head = new Node(-1), tail = head;\n            for (auto i = cur; i != nullptr; i = i->next) {\n                if (i->left) tail = tail->next = i->left;\n                if (i->right) tail = tail->next = i->right;\n            }\n            cur = head->next;\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def connect(self, root: 'Node') -> 'Node':\n        ans = root\n        if not root:\n            return ans\n        cur = root\n        while cur:\n            head = Node(-1)\n            tail = head\n            i = cur\n            while i:\n                if i.left:\n                    tail.next = i.left\n                    tail = tail.next\n                if i.right:\n                    tail.next = i.right\n                    tail = tail.next\n                i = i.next\n            cur = head.next\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction connect(root: Node | null): Node | null {\n    let ans = root;\n    if (root == null) return ans;\n    let cur = root;\n    while (cur != null) {\n        let head = new Node(-1), tail = head;\n        for (let i = cur; i != null; i = i.next) {\n            if (i.left) tail = tail.next = i.left;\n            if (i.right) tail = tail.next = i.right;\n        }\n        cur = head.next;\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.117` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/111-120/119. 杨辉三角 II（简单）.md", "url_title": "119. 杨辉三角 II", "url": "https://leetcode-cn.com/problems/pascals-triangle-ii/solution/dong-tai-gui-hua-luo-ti-chang-jian-de-ko-n2xj/", "difficulty": "简单", "tags": ["数学", "线性 DP"], "question": "给定一个非负索引 k,其中 k ≤ 33,返回杨辉三角的第 k 行。\n\n在杨辉三角中,每个数是它左上方和右上方的数的和。\n\n示例:\n```\n输入: 3\n输出: [1,3,3,1]\n```\n进阶:\n* 你可以优化你的算法到 O(k) 空间复杂度吗?", "solution": "### 动态规划\n\n```java\nclass Solution {\n    public List<Integer> getRow(int idx) {\n        int[][] f = new int[idx + 1][idx + 1];\n        f[0][0] = 1;\n        for (int i = 1; i < idx + 1; i++) {\n            for (int j = 0; j < i + 1; j++) {\n                f[i][j] = f[i - 1][j];\n                if (j - 1 >= 0) f[i][j] += f[i - 1][j - 1];\n                if (f[i][j] == 0) f[i][j] = 1;\n            }\n        }\n        List<Integer> ans = new ArrayList<>();\n        for (int i = 0; i < idx + 1; i++) ans.add(f[idx][i]);\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$\n\n***\n\n### 滚动数组\n\n滚动数组优化十分机械,直接将滚动的维度从 `i` 改造为 `i % 2` 或 `i & 1` 即可。\n\n`i & 1` 相比于 `i % 2` 在不同架构的机器上,效率会更稳定些 ~ \n\n```java\nclass Solution {\n    public List<Integer> getRow(int idx) {\n        int[][] f = new int[2][idx + 1];\n        f[0][0] = 1;\n        for (int i = 1; i < idx + 1; i++) {\n            for (int j = 0; j < i + 1; j++) {\n                f[i & 1][j] = f[(i - 1) & 1][j];\n                if (j - 1 >= 0) f[i & 1][j] += f[(i - 1) & 1][j - 1];\n                if (f[i & 1][j] == 0) f[i & 1][j] = 1;\n            }\n        }\n        List<Integer> ans = new ArrayList<>();\n        for (int i = 0; i < idx + 1; i++) ans.add(f[idx & 1][i]);\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 一维优化\n\n只有第 `i` 行的更新只依赖于 `i - 1` 行,因此可以直接消除行的维度:\n\n```java\nclass Solution {\n    public List<Integer> getRow(int idx) {\n        int[] f = new int[idx + 1];\n        f[0] = 1;\n        for (int i = 1; i < idx + 1; i++) {\n            for (int j = i; j >= 0; j--) {\n                if (j - 1 >= 0) f[j] += f[j - 1];\n                if (f[j] == 0) f[j] = 1;\n            }\n        }\n        List<Integer> ans = new ArrayList<>();\n        for (int i = 0; i < idx + 1; i++) ans.add(f[i]);\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.119` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1131-1140/1137. 第 N 个泰波那契数（简单）.md", "url_title": "1137. 第 N 个泰波那契数", "url": "https://leetcode-cn.com/problems/n-th-tribonacci-number/solution/gong-shui-san-xie-yi-ti-si-jie-die-dai-d-m1ie/", "difficulty": "简单", "tags": ["动态规划", "递归", "递推", "矩阵快速幂", "打表"], "question": "泰波那契序列 $T_{n}$ 定义如下: \n\n$T_{0} = 0$, $T_{1} = 1$, $T_{2} = 1$, 且在 $n >= 0$ 的条件下 $T_{n+3} = T_{n} + T_{n+1} + T_{n+2}$\n\n给你整数 $n$,请返回第 $n$ 个泰波那契数 $T_n$ 的值。\n\n示例 1:\n```\n输入:n = 4\n\n输出:4\n\n解释:\nT_3 = 0 + 1 + 1 = 2\nT_4 = 1 + 1 + 2 = 4\n```\n示例 2:\n```\n输入:n = 25\n\n输出:1389537\n```\n\n提示:\n* $0 <= n <= 37$\n* 答案保证是一个 $32$ 位整数,即 $answer <= 2^{31} - 1$。", "solution": "### 动态规划(迭代)\n\n都直接给出状态转移方程了,其实就是道模拟题。\n\n使用三个变量,从前往后算一遍即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public int tribonacci(int n) {\n        if (n == 0) return 0;\n        if (n == 1 || n == 2) return 1;\n        int a = 0, b = 1, c = 1;\n        for (int i = 3; i <= n; i++) {\n            int d = a + b + c;\n            a = b; b = c; c = d;\n        }\n        return c;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int tribonacci(int n) {\n        if (n == 0) return 0;\n        if (n == 1 || n == 2) return 1;\n        int a = 0, b = 1, c = 1;\n        for (int i = 3; i <= n; i++) {\n            int d = a + b + c;\n            a = b; b = c; c = d;\n        }\n        return c;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def tribonacci(self, n: int) -> int:\n        if n == 0: return 0\n        if n == 1 or n == 2: return 1\n        a, b, c = 0, 1, 1\n        for i in range(3, n + 1):\n            d = a + b + c\n            a, b, c = b, c, d\n        return c\n```\nTypeScript 代码:\n```TypeScript\nfunction tribonacci(n: number): number {\n    if (n === 0) return 0;\n    if (n === 1 || n === 2) return 1;\n    let a = 0, b = 1, c = 1;\n    for (let i = 3; i <= n; i++) {\n        const d = a + b + c;\n        a = b; b = c; c = d;\n    }\n    return c;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 动态规划(递归)\n\n也就是记忆化搜索,创建一个 `cache` 数组用于防止重复计算。\n\nJava 代码:\n```Java\nclass Solution {\n    int[] cache = new int[40];\n    public int tribonacci(int n) {\n        if (n == 0) return 0;\n        if (n == 1 || n == 2) return 1;\n        if (cache[n] != 0) return cache[n];\n        cache[n] = tribonacci(n - 1) + tribonacci(n - 2) + tribonacci(n - 3); \n        return cache[n];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> cache = vector<int>(40, 0);\n    int tribonacci(int n) {\n        if (n == 0) return 0;\n        if (n == 1 || n == 2) return 1;\n        if (cache[n] != 0) return cache[n];\n        cache[n] = tribonacci(n - 1) + tribonacci(n - 2) + tribonacci(n - 3); \n        return cache[n];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def __init__(self):\n        self.cache = [0] * 40\n    def tribonacci(self, n: int) -> int:\n        if n == 0: return 0\n        if n == 1 or n == 2: return 1\n        if self.cache[n] != 0: return self.cache[n]\n        self.cache[n] = self.tribonacci(n - 1) + self.tribonacci(n - 2) + self.tribonacci(n - 3)\n        return self.cache[n]\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 矩阵快速幂\n\n这还是一道「矩阵快速幂」的板子题。\n\n首先你要对「快速幂」和「矩阵乘法」概念有所了解。\n\n矩阵快速幂用于求解一般性问题:给定大小为 $n \\times n$ 的矩阵 $M$,求答案矩阵 $M^k$,并对答案矩阵中的每位元素对 $P$ 取模。\n\n在上述两种解法中,当我们要求解 $f[i]$ 时,需要将 $f[0]$ 到 $f[n - 1]$ 都算一遍,因此需要线性的复杂度。\n\n对于此类的「数列递推」问题,我们可以使用「矩阵快速幂」来进行加速(比如要递归一个长度为 $1e9$ 的数列,线性复杂度会被卡)。\n\n使用矩阵快速幂,我们只需要 $O(\\log{n})$ 的复杂度。\n\n根据题目的递推关系($i >= 3$):\n\n$$\nf(i) = f(i - 1) + f(i - 2) + f(i - 3)\n$$\n\n我们发现要求解 $f(i)$,其依赖的是 $f(i - 1)$、$f(i - 2)$ 和 $f(i - 3)$。\n\n我们可以将其存成一个列向量:\n\n$$\n\\begin{bmatrix}\nf(i - 1)\\\\ \nf(i - 2)\\\\ \nf(i - 3)\n\\end{bmatrix}\n$$\n\n当我们整理出依赖的列向量之后,不难发现,我们想求的 $f(i)$ 所在的列向量是这样的:\n\n$$\n\\begin{bmatrix}\nf(i)\\\\ \nf(i - 1)\\\\ \nf(i - 2)\n\\end{bmatrix}\n$$\n\n利用题目给定的依赖关系,对目标矩阵元素进行展开:\n\n$$\n\\begin{bmatrix}\nf(i)\\\\ \nf(i - 1)\\\\ \nf(i - 2)\n\\end{bmatrix} = \\begin{bmatrix}\nf(i - 1) * 1 + f(i - 2) * 1 + f(i - 3) * 1\\\\ \nf(i - 1) * 1 + f(i - 2) * 0 + f(i - 3) * 0\\\\ \nf(i - 1) * 0 + f(i - 2) * 1 + f(i - 3) * 0\n\\end{bmatrix}\n$$\n\n那么根据矩阵乘法,即有:\n\n$$\n\\begin{bmatrix}\nf(i)\\\\ \nf(i - 1)\\\\ \nf(i - 2)\n\\end{bmatrix} = \\begin{bmatrix}\n1 &1 &1 \\\\ \n1 &0 &0 \\\\ \n0 &1 &0 \n\\end{bmatrix} * \\begin{bmatrix}\nf(i - 1)\\\\ \nf(i - 2)\\\\ \nf(i - 3)\n\\end{bmatrix} \n$$\n\n我们令\n\n$$\nMat = \\begin{bmatrix}\n1 &1 &1 \\\\ \n1 &0 &0 \\\\ \n0 &1 &0 \n\\end{bmatrix}\n$$\n\n然后发现,利用 $Mat$ 我们也能实现数列递推(公式太难敲了,随便列两项吧):\n\n$$\nMat * \\begin{bmatrix}\nf(i - 1)\\\\ \nf(i - 2)\\\\ \nf(i - 3)\n\\end{bmatrix} = \\begin{bmatrix}\nf(i)\\\\ \nf(i - 1)\\\\ \nf(i - 2)\n\\end{bmatrix} \n$$\n\n$$\nMat * \\begin{bmatrix}\nf(i )\\\\ \nf(i - 1)\\\\ \nf(i - 2)\n\\end{bmatrix} = \\begin{bmatrix}\nf(i + 1)\\\\ \nf(i)\\\\ \nf(i - 1)\n\\end{bmatrix} \n$$\n\n再根据矩阵运算的结合律,最终有:\n\n$$\n\\begin{bmatrix}\nf(n)\\\\ \nf(n - 1)\\\\ \nf(n - 2)\n\\end{bmatrix} = Mat^{n - 2} * \\begin{bmatrix}\nf(2)\\\\ \nf(1)\\\\ \nf(0)\n\\end{bmatrix}\n$$\n\n从而将问题转化为求解 $Mat^{n - 2}$ ,这时候可以套用「矩阵快速幂」解决方案。\n\nJava 代码:\n```Java\nclass Solution {\n    int N = 3;\n    int[][] mul(int[][] a, int[][] b) {\n        int[][] c = new int[N][N];\n        for (int i = 0; i < N; i++) {\n            for (int j = 0; j < N; j++) {\n                c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j] + a[i][2] * b[2][j];\n            }\n        }\n        return c;\n    }\n    public int tribonacci(int n) {\n        if (n == 0) return 0;\n        if (n == 1 || n == 2) return 1;\n        int[][] ans = new int[][]{\n            {1,0,0},\n            {0,1,0},\n            {0,0,1}\n        };\n        int[][] mat = new int[][]{\n            {1,1,1},\n            {1,0,0},\n            {0,1,0}\n        };\n        int k = n - 2;\n        while (k != 0) {\n            if ((k & 1) != 0) ans = mul(ans, mat);\n            mat = mul(mat, mat);\n            k >>= 1;\n        }\n        return ans[0][0] + ans[0][1];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int N = 3;\n    vector<vector<long long>> mul(vector<vector<long long>>& a, vector<vector<long long>>& b) {\n        vector<vector<long long>> c(N, vector<long long>(N, 0));\n        for (int i = 0; i < N; i++) {\n            for (int j = 0; j < N; j++) {\n                c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j] + a[i][2] * b[2][j];\n            }\n        }\n        return c;\n    }\n    int tribonacci(int n) {\n        if (n == 0) return 0;\n        if (n == 1 || n == 2) return 1;\n        vector<vector<long long>> ans = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};\n        vector<vector<long long>> mat = {{1, 1, 1}, {1, 0, 0}, {0, 1, 0}};\n        int k = n - 2;\n        while (k != 0) {\n            if ((k & 1) != 0) ans = mul(ans, mat);\n            mat = mul(mat, mat);\n            k >>= 1;\n        }\n        return ans[0][0] + ans[0][1];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def __init__(self):\n        self.N = 3\n\n    def mul(self, a, b):\n        c = [[0] * self.N for _ in range(self.N)]\n        for i in range(self.N):\n            for j in range(self.N):\n                c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j] + a[i][2] * b[2][j]\n        return c\n\n    def tribonacci(self, n: int) -> int:\n        if n == 0: return 0\n        if n == 1 or n == 2: return 1\n        ans = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]\n        mat = [[1, 1, 1], [1, 0, 0], [0, 1, 0]]\n        k = n - 2\n        while k != 0:\n            if k & 1: ans = self.mul(ans, mat)\n            mat = self.mul(mat, mat)\n            k >>= 1\n        return ans[0][0] + ans[0][1]\n```\nTypeScript 代码:\n```TypeScript\nfunction tribonacci(n: number): number {\n    const N = 3;\n    const mul = function(a: number[][], b: number[][]): number[][] {\n        const c = Array.from({ length: N }, () => Array(N).fill(0));\n        for (let i = 0; i < N; i++) {\n            for (let j = 0; j < N; j++) {\n                c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j] + a[i][2] * b[2][j];\n            }\n        }\n        return c;\n    };\n    if (n === 0) return 0;\n    if (n === 1 || n === 2) return 1;\n    let ans = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];\n    let mat = [[1, 1, 1], [1, 0, 0], [0, 1, 0]];\n    let k = n - 2;\n    while (k !== 0) {\n        if (k & 1) ans = mul(ans, mat);\n        mat = mul(mat, mat);\n        k >>= 1;\n    }\n    return ans[0][0] + ans[0][1];\n};\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 打表\n\n当然,我们也可以将数据范围内的所有答案进行打表预处理,然后在询问时直接查表返回。\n\n但对这种题目进行打表带来的收益没有平常打表题的大,因为打表内容不是作为算法必须的一个环节,而直接是作为该询问的答案,但测试样例是不会相同的,即不会有两个测试数据都是 $n = 37$。\n\n这时候打表节省的计算量是不同测试数据之间的相同前缀计算量,例如 $n = 36$ 和 $n = 37$,其 $35$ 之前的计算量只会被计算一次。\n\n因此直接为「解法二」的 `cache` 添加 `static` 修饰其实是更好的方式:代码更短,同时也能起到同样的节省运算量的效果。\n\nJava 代码:\n```Java\nclass Solution {\n    static int[] cache = new int[40];\n    static {\n        cache[0] = 0; cache[1] = 1; cache[2] = 1;\n        for (int i = 3; i < cache.length; i++) {\n            cache[i] = cache[i - 1] + cache[i - 2] + cache[i - 3];\n        }\n    }\n    public int tribonacci(int n) {\n        return cache[n];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    static vector<long long> cache;\n    Solution() {\n        cache.resize(40);\n        cache[0] = 0; cache[1] = 1; cache[2] = 1;\n        for (int i = 3; i < 40; ++i) {\n            cache[i] = cache[i - 1] + cache[i - 2] + cache[i - 3];\n        }\n    }\n    int tribonacci(int n) {\n        return static_cast<int>(cache[n]);\n    }\n};\nvector<long long> Solution::cache;\n```\nPython 代码:\n```Python\nclass Solution:\n    cache = [0, 1, 1] + [0] * 37\n    for i in range(3, 40):\n        cache[i] = cache[i - 1] + cache[i - 2] + cache[i - 3]\n\n    def tribonacci(self, n: int) -> int:\n        return self.cache[n]\n```\n* 时间复杂度:将打表逻辑交给 $OJ$,复杂度为 $O(C)$,$C$ 固定为 $40$。将打表逻辑放到本地进行,复杂度为 $O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1137` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1141-1150/1143. 最长公共子序列（中等）.md", "url_title": "1143. 最长公共子序列", "url": "https://leetcode-cn.com/problems/longest-common-subsequence/solution/gong-shui-san-xie-zui-chang-gong-gong-zi-xq0h/", "difficulty": "中等", "tags": ["最长公共子序列", "LCS", "序列 DP"], "question": "给定两个字符串 `s1` 和 `s2`,返回这两个字符串的最长公共子序列的长度。\n\n如果不存在公共子序列,返回 $0$ 。\n\n一个字符串的子序列是指这样一个新的字符串:它是由原字符串在不改变字符的相对顺序的情况下删除某些字符(也可以不删除任何字符)后组成的新字符串。\n\n* 例如,`\"ace\"` 是 `\"abcde\"` 的子序列,但 `\"aec\"` 不是 `\"abcde\"` 的子序列。\n\n两个字符串的公共子序列是这两个字符串所共同拥有的子序列。\n\n示例 1:\n```\n输入:s1 = \"abcde\", s2 = \"ace\" \n\n输出:3  \n\n解释:最长公共子序列是 \"ace\" ,它的长度为 3 。\n```\n示例 2:\n```\n输入:s1 = \"abc\", s2 = \"abc\"\n\n输出:3\n\n解释:最长公共子序列是 \"abc\" ,它的长度为 3 。\n```\n示例 3:\n```\n输入:s1 = \"abc\", s2 = \"def\"\n\n输出:0\n\n解释:两个字符串没有公共子序列,返回 0 。\n```\n\n提示:\n* $1 <= s1.length, s2.length <= 1000$\n* `s1` 和 `s2` 仅由小写英文字符组成。", "solution": "### 动态规划(空格技巧)\n\n这是一道「最长公共子序列(LCS)」的裸题。\n\n对于这类题的都使用如下「状态定义」即可:\n\n**$f[i][j]$ 代表考虑 $s1$ 的前 $i$ 个字符、考虑 $s2$ 的前 $j$ 的字符,形成的最长公共子序列长度。**\n\n当有了「状态定义」之后,基本上「转移方程」就是呼之欲出:\n\n* `s1[i]==s2[j]` : $f[i][j]=f[i-1][j-1]+1$。代表**必然使用 $s1[i]$ 与 $s2[j]$ 时** LCS 的长度。\n* `s1[i]!=s2[j]` : $f[i][j]=max(f[i-1][j], f[i][j-1])$。代表**必然不使用 $s1[i]$(但可能使用$s2[j]$)时** 和 **必然不使用 $s2[j]$(但可能使用$s1[i]$)时** LCS 的长度。\n\n一些编码细节:\n\n通常我会习惯性往字符串头部追加一个空格,以减少边界判断(使下标从 1 开始,并很容易构造出可滚动的「有效值」)。\n\nJava 代码:\n```Java\nclass Solution {\n    public int longestCommonSubsequence(String s1, String s2) {\n        int n = s1.length(), m = s2.length();\n        s1 = \" \" + s1; s2 = \" \" + s2;\n        char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray();\n        int[][] f = new int[n + 1][m + 1]; \n\n        // 因为有了追加的空格,我们有了显然的初始化值(以下两种初始化方式均可)\n        // for (int i = 0; i <= n; i++) Arrays.fill(f[i], 1);\n        for (int i = 0; i <= n; i++) f[i][0] = 1;\n        for (int j = 0; j <= m; j++) f[0][j] = 1;\n\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                if (cs1[i] == cs2[j]) f[i][j] = f[i -1][j - 1] + 1;    \n                else f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);\n            }\n        }\n        // 减去最开始追加的空格\n        return f[n][m] - 1;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int longestCommonSubsequence(string s1, string s2) {\n        int n = s1.size(), m = s2.size();\n        s1 = \" \" + s1, s2 = \" \" + s2;\n        int f[n+1][m+1];\n        memset(f, 0, sizeof(f));\n\n        for(int i = 0; i <= n; i++) f[i][0] = 1;\n        for(int j = 0; j <= m; j++) f[0][j] = 1;\n\n        for(int i = 1; i <= n; i++) {\n            for(int j = 1; j <= m; j++) {\n                if(s1[i] == s2[j]) f[i][j] = max(f[i-1][j-1] + 1, max(f[i-1][j], f[i][j-1]));\n                else f[i][j] = max(f[i-1][j], f[i][j-1]);\n            }\n        }\n        return f[n][m] - 1;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def longestCommonSubsequence(self, s1: str, s2: str) -> int:\n        n, m = len(s1), len(s2)\n        s1, s2 = \" \" + s1, \" \" + s2\n        f = [[0] * (m + 1) for _ in range(n + 1)]\n\n        for i in range(n + 1): f[i][0] = 1\n        for j in range(m + 1): f[0][j] = 1\n\n        for i in range(1, n + 1):\n            for j in range(1, m + 1):\n                if s1[i] == s2[j]:\n                    f[i][j] = f[i - 1][j - 1] + 1\n                else:\n                    f[i][j] = max(f[i - 1][j], f[i][j - 1])\n\n        return f[n][m] - 1\n```\nTypeScript 代码:\n```TypeScript\nfunction longestCommonSubsequence(s1: string, s2: string): number {\n    const n = s1.length, m = s2.length;\n    s1 = \" \" + s1; s2 = \" \" + s2;\n    const f = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));\n\n    for (let i = 0; i <= n; i++) f[i][0] = 1;\n    for (let j = 0; j <= m; j++) f[0][j] = 1;\n\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= m; j++) {\n            if (s1[i] == s2[j]) f[i][j] = f[i - 1][j - 1] + 1;    \n            else f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);\n        }\n    }\n\n    return f[n][m] - 1;\n};\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n \\times m)$\n\n---\n\n### 动态规划(利用偏移)\n\n上述「追加空格」的做法只是个人比较习惯的做法。\n\n事实上,我们也可以通过修改「状态定义」来实现递推:\n\n**$f[i][j]$ 代表考虑 $s1$ 的前 $i - 1$ 个字符、考虑 $s2$ 的前 $j - 1$ 的字符,形成的最长公共子序列长度。**\n\n那么最终的 $f[n][m]$ 就是我们的答案,$f[0][0]$ 当做无效值,不处理即可。\n\n* `s1[i-1]==s2[j-1]` : $f[i][j]=f[i-1][j-1]+1$。代表使用 $s1[i-1]$ 与 $s2[j-1]$形成最长公共子序列的长度。\n* `s1[i-1]!=s2[j-1]` : $f[i][j]=max(f[i-1][j], f[i][j-1])$。代表不使用 $s1[i-1]$ 形成最长公共子序列的长度、不使用 $s2[j-1]$ 形成最长公共子序列的长度。这两种情况中的最大值。\n\nJava 代码:\n```Java\nclass Solution {\n    public int longestCommonSubsequence(String s1, String s2) {\n        int n = s1.length(), m = s2.length();\n        char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray();\n        int[][] f = new int[n + 1][m + 1]; \n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                if (cs1[i - 1] == cs2[j - 1]) f[i][j] = f[i - 1][j - 1] + 1;\n                else f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]); \n            }\n        }\n        return f[n][m];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int longestCommonSubsequence(string s1, string s2) {\n        int m = s1.size(), n = s2.size();\n        vector<vector<int>> f(m + 1,vector<int>(n + 1,0));\n        for(int i = 1; i <= m; i++){\n            for(int j = 1; j <= n; j++){\n                if(s1[i - 1] == s2[j - 1]) f[i][j] = f[i - 1][j - 1] + 1;\n                else f[i][j] = max(f[i - 1][j],f[i][j - 1]);\n            }\n        }\n        return f[m][n];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def longestCommonSubsequence(self, s1: str, s2: str) -> int:\n        m, n = len(s1), len(s2)\n        f = [[0] * (n + 1) for _ in range(m + 1)]\n        for i in range(1, m + 1):\n            for j in range(1, n + 1):\n                if s1[i - 1] == s2[j - 1]:\n                    f[i][j] = f[i - 1][j - 1] + 1\n                else:\n                    f[i][j] = max(f[i - 1][j],f[i][j - 1])\n        return f[m][n]\n```\nTypeScript 代码:\n```TypeScript\nfunction longestCommonSubsequence(s1: string, s2: string): number {\n    const n = s1.length, m = s2.length;\n    const cs1 = s1.split(''), cs2 = s2.split('');\n    const f: number[][] = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= m; j++) {\n            if (cs1[i - 1] == cs2[j - 1]) f[i][j] = f[i - 1][j - 1] + 1;\n            else f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);\n        }\n    }\n    return f[n][m];\n};\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n \\times m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1143` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1151-1160/1154. 一年中的第几天（简单）.md", "url_title": "1154. 一年中的第几天", "url": "https://leetcode-cn.com/problems/day-of-the-year/solution/gong-shui-san-xie-jian-dan-qian-zhui-he-lwo2g/", "difficulty": "简单", "tags": ["前缀和", "模拟"], "question": "给你一个字符串 `date`,按 `YYYY-MM-DD` 格式表示一个 现行公元纪年法 日期。\n\n请你计算并返回该日期是当年的第几天。\n\n通常情况下,我们认为 `1` 月 `1` 日是每年的第 `1` 天,`1` 月 `2` 日是每年的第 `2` 天,依此类推。每个月的天数与现行公元纪年法(格里高利历)一致。\n\n示例 1:\n```\n输入:date = \"2019-01-09\"\n\n输出:9\n```\n示例 2:\n```\n输入:date = \"2019-02-10\"\n\n输出:41\n```\n示例 3:\n```\n输入:date = \"2003-03-01\"\n\n输出:60\n```\n示例 4:\n```\n输入:date = \"2004-03-01\"\n\n输出:61\n```\n\n提示:\n* `date.length == 10`\n* `date[4] == date[7] == '-'`,其他的 `date[i]` 都是数字\n* `date` 表示的范围从 `1900` 年 `1` 月 `1` 日至 `2019` 年 `12` 月 `31` 日", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n由于每年月份的天数都相对固定(仅有闰年 $2$ 月份不同),因此我们可以使用 `static` 进行打表预处理。\n\n使用 `nums` 构建一个平年的月份数组,再通过「前缀和」得到平年的每个月的天数总和。\n\n最后将 `date` 按照 `-` 分割为年月日,分别进行计数。\n\n注意,当年份为闰年且当前月份超过了 $2$ 月份,要追加一天。\n\n代码:\n```Java\nclass Solution {\n    static int[] nums = new int[]{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};\n    static int[] f = new int[13];\n    static {\n        for (int i = 1; i <= 12; i++) f[i] = f[i - 1] + nums[i - 1];\n    }\n    public int dayOfYear(String date) {\n        String[] ss = date.split(\"-\");\n        int y = Integer.parseInt(ss[0]), m = Integer.parseInt(ss[1]), d = Integer.parseInt(ss[2]);\n        boolean isLeap = (y % 4 == 0 && y % 100 != 0) || y % 400 == 0;\n        int ans = m > 2 && isLeap ? f[m - 1] + 1 : f[m - 1];\n        return ans + d;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1154` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1151-1160/1155. 掷骰子的N种方法（中等）.md", "url_title": "1155. 掷骰子的N种方法", "url": "https://leetcode-cn.com/problems/number-of-dice-rolls-with-target-sum/solution/dong-tai-gui-hua-bei-bao-wen-ti-yun-yong-axtf/", "difficulty": "中等", "tags": ["背包问题", "动态规划", "分组背包"], "question": "这里有 d 个一样的骰子,每个骰子上都有 f 个面,分别标号为 `1,2,...,f`。\n\n我们约定:掷骰子的得到总点数为各骰子面朝上的数字的总和。\n\n如果需要掷出的总点数为 target,请你计算出有多少种不同的组合情况(所有的组合情况总共有 $f^d$ 种),模 $10^9 + 7$ 后返回。\n\n示例 1:\n```\n输入:d = 1, f = 6, target = 3\n\n输出:1\n```\n示例 2:\n```\n输入:d = 2, f = 6, target = 7\n\n输出:6\n```\n示例 3:\n```\n输入:d = 2, f = 5, target = 10\n\n输出:1\n```\n示例 4:\n```\n输入:d = 1, f = 2, target = 3\n\n输出:0\n```\n示例 5:\n```\n输入:d = 30, f = 30, target = 500\n\n输出:222616187\n```\n\n提示:\n\n* 1 <= d, f <= 30\n* 1 <= target <= 1000", "solution": "### 分组背包\n\n在 [分组背包问题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487504&idx=1&sn=9ac523ec0ac14c8634a229f8c3f919d7&chksm=fd9cbb0fcaeb32196b80a40e4408f6a7e2651167e0b9e31aa6d7c6109fbc2117340a59db12a1&token=1936267333&lang=zh_CN#rd) 中我们提到,分组背包不仅仅有「组内物品最多选择一个」的情况,还存在「组内物品必须选择一个」的情况。\n\n对于本题,可以将每个骰子看作一个物品组,且每次 **必须** 从物品组中选择一个物品(所掷得的数值大小视作具体物品)。\n\n这样就把问题转换为:**用 $d$ 个骰子(物品组)进行掷,掷出总和(取得的总价值)为 $t$ 的方案数。**\n\n虽然,我们还没专门讲过「背包问题求方案数」,但基本分析与「背包问题求最大价值」并无本质区别。\n\n我们可以套用「分组背包求最大价值」的状态定义来微调:**$f[i][j]$ 表示考虑前 $i$ 个物品组,凑成价值为 $j$ 的方案数。**\n\n为了方便,我们令物品组的编号从 $1$ 开始,因此有显而易见的初始化条件 $f[0][0] = 1$。\n\n代表在不考虑任何物品组的情况下,只有凑成总价值为 $0$ 的方案数为 $1$,凑成其他总价值的方案不存在。\n\n**不失一般性考虑 $f[i][j]$ 该如何转移,也就是考虑第 $i$ 个物品组有哪些决策。**\n\n根据题意,对于第 $i$ 个物品组而言,可能决策的方案有:\n\n* 第 $i$ 个骰子的结果为 $1$,有 $f[i][j] = f[i - 1][j - 1]$\n\n* 第 $i$ 个骰子的结果为 $2$,有 $f[i][j] = f[i - 1][j - 2]$\n\n  ...\n\n* 第 $i$ 个骰子的结果为 $m$,有 $f[i][j] = f[i - 1][j - m]$\n\n$f[i][j]$ 则是上述所有可能方案的方案数总和,即有:\n\n$$\nf[i][j] = \\sum_{k = 1}^{m}f[i - 1][j - k], j >= k\n$$\n\n#### 朴素二维\n\n代码:\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int numRollsToTarget(int n, int m, int t) {\n        int[][] f = new int[n + 1][t + 1];\n        f[0][0] = 1;\n        // 枚举物品组(每个骰子)\n        for (int i = 1; i <= n; i++) {\n            // 枚举背包容量(所掷得的总点数)\n            for (int j = 0; j <= t; j++) {\n                // 枚举决策(当前骰子所掷得的点数)\n                for (int k = 1; k <= m; k++) {\n                    if (j >= k) {\n                        f[i][j] = (f[i][j] + f[i-1][j-k]) % mod;\n                    }\n                }\n            }\n        } \n        return f[n][t];\n    }\n}\n```\n* 时间复杂度:$O(n * m * t)$\n* 空间复杂度:$O(n * t)$\n\n#### 滚动数组\n\n根据状态转移方程,我们发现 $f[i][j]$ 明确只依赖于 $f[i - 1][x]$,且 $x < j$。\n\n因此我们可以使用之前学过的「滚动数组」,用很机械的方式将空间从 $O(n * t)$ 优化至 $O(t)$。\n\n需要注意的是,由于我们直接是在 $f[i][j]$ 格子的基础上进行方案数累加,因此在计算 $f[i][j]$ 记得手动置零。\n\n代码:\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int numRollsToTarget(int n, int m, int t) {\n        int[][] f = new int[2][t + 1];\n        f[0][0] = 1;\n        for (int i = 1; i <= n; i++) {\n            int a = i & 1, b = (i - 1) & 1;\n            for (int j = 0; j <= t; j++) {\n                f[a][j] = 0; // 先手动置零\n                for (int k = 1; k <= m; k++) {\n                    if (j >= k) {\n                        f[a][j] = (f[a][j] + f[b][j-k]) % mod;\n                    }\n                }\n            }\n        } \n        return f[n&1][t];\n    }\n}\n```\n* 时间复杂度:$O(n * m * t)$\n* 空间复杂度:$O(t)$\n\n#### 一维空间优化\n\n更进一步,利用「$f[i][j]$ 明确只依赖于 $f[i - 1][x]$,且 $x < j$ 」,我们能通过「[01 背包](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247485638&idx=1&sn=d7468955c5b121664031fd5c1b5a6f10&chksm=fd9ca3d9caeb2acf2dd4e9f512b2d4dc820107489a094749ffe7cae646f0cc60de06f2d18898&token=800772286&lang=zh_CN#rd)」一维空间优化方式:**将物品维度取消,调整容量维度遍历顺序为「从大到小」。**\n\n代码:\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int numRollsToTarget(int n, int m, int t) {\n        int[] f = new int[t + 1];\n        f[0] = 1;\n        for (int i = 1; i <= n; i++) {\n            for (int j = t; j >= 0; j--) {\n                f[j] = 0;\n                for (int k = 1; k <= m; k++) {\n                    if (j >= k) {\n                        f[j] = (f[j] + f[j-k]) % mod;\n                    }\n                }\n            }\n        } \n        return f[t];\n    }\n}\n```\n* 时间复杂度:$O(n * m * t)$\n* 空间复杂度:$O(t)$\n\n---\n\n### 总结\n\n不难发现,不管是「组内物品最多选一件」还是「组内物品必须选一件」。\n\n我们都是直接套用分组背包基本思路 *「枚举物品组-枚举容量-枚举决策」* 进行求解。\n\n**分组背包的空间优化并不会降低时间复杂度,所以对于分组背包问题,我们可以直接写方便调试的朴素多维版本(在空间可接受的情况下),如果遇到卡空间,再通过机械的方式改为「滚动数组」形式。**\n\n另外今天我们使用「分组背包问题求方案数」来作为「分组背包问题求最大价值」的练习题。\n\n可以发现,两者其实并无本质区别,都是套用「背包问题求最大价值」的状态定义来微调。\n\n更多的关于「背包问题求方案数」相关内容,在后面也会继续细讲。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1155` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1161-1170/1161. 最大层内元素和（中等）.md", "url_title": "1161. 最大层内元素和", "url": "https://leetcode.cn/problems/maximum-level-sum-of-a-binary-tree/solution/by-ac_oier-aemz/", "difficulty": "中等", "tags": ["层序遍历", "BFS"], "question": "给你一个二叉树的根节点 `root`。设根节点位于二叉树的第 $1$ 层,而根节点的子节点位于第 $2$ 层,依此类推。\n\n请返回层内元素之和 最大 的那几层(可能只有一层)的层号,并返回其中 最小 的那个。\n\n示例 1:\n\n```\n输入:root = [1,7,0,7,-8,null,null]\n\n输出:2\n\n解释:\n第 1 层各元素之和为 1,\n第 2 层各元素之和为 7 + 0 = 7,\n第 3 层各元素之和为 7 + -8 = -1,\n所以我们返回第 2 层的层号,它的层内元素之和最大。\n```\n示例 2:\n```\n输入:root = [989,null,10250,98693,-89388,null,null,null,-32127]\n\n输出:2\n```\n\n提示:\n* 树中的节点数在 $[1, 10^4]$范围内\n* $-10^5 <= Node.val <= 10^5$", "solution": "### 层序遍历\n\n根据题意,使用 `BFS` 进行层序遍历即可。\n\n每次以「层」为单位进行拓展,统计该层的元素和,维护处理过程中的最大值层数和,以及层深度。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxLevelSum(TreeNode root) {\n        Deque<TreeNode> d = new ArrayDeque<>();\n        int max = -0x3f3f3f3f, depth = 1, ans = 0;\n        d.addLast(root);\n        while (!d.isEmpty()) {\n            int sz = d.size(), cur = 0;\n            while (sz-- > 0) {\n                TreeNode t = d.pollFirst();\n                if (t.left != null) d.addLast(t.left);\n                if (t.right != null) d.addLast(t.right);\n                cur += t.val;\n            }\n            if (cur > max) {\n                max = cur; ans = depth;\n            }\n            depth++;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction maxLevelSum(root: TreeNode | null): number {\n    const d: TreeNode[] = new Array<TreeNode>()\n    let he = 0, ta = 0\n    d[ta++] = root\n    let max = -0x3f3f3f3f, depth = 1, ans = 0\n    while (he < ta) {\n        let sz = ta - he, cur = 0\n        while (sz-- > 0) {\n            const t = d[he++]\n            if (t.left != null) d[ta++] = t.left\n            if (t.right != null) d[ta++] = t.right\n            cur += t.val\n        }\n        if (cur > max) {\n            max = cur; ans = depth\n        }\n        depth++\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1161` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1161-1170/1162. 地图分析（中等）.md", "url_title": "1162. 地图分析", "url": "https://leetcode-cn.com/problems/as-far-from-land-as-possible/solution/gong-shui-san-xie-ru-he-shi-yong-duo-yua-vlea/", "difficulty": "中等", "tags": ["图论 BFS", "多源 BFS"], "question": "你现在手里有一份大小为 $N \\times N$ 的 网格 $grid$,上面的每个 单元格 都用 $0$ 和 $1$ 标记好了。\n\n其中 $0$ 代表海洋,$1$ 代表陆地,请你找出一个海洋单元格,这个海洋单元格到离它最近的陆地单元格的距离是最大的。\n\n我们这里说的距离是「曼哈顿距离」:$(x_0, y_0)$ 和 $(x_1, y_1)$ 这两个单元格之间的距离是 $|x_0 - x_1| + |y_0 - y_1|$。\n\n如果网格上只有陆地或者海洋,请返回 $-1$。\n\n示例 1:\n\n```\n输入:[[1,0,1],[0,0,0],[1,0,1]]\n\n输出:2\n\n解释:海洋单元格 (1, 1) 和所有陆地单元格之间的距离都达到最大,最大距离为 2。\n```\n示例 2:\n\n```\n输入:[[1,0,0],[0,0,0],[0,0,0]]\n\n输出:4\n\n解释:海洋单元格 (2, 2) 和所有陆地单元格之间的距离都达到最大,最大距离为 4。\n```\n\n提示:\n* 1 <= grid.length == grid[0].length <= 100\n* `grid[i][j]` 不是 $0$ 就是 $1$", "solution": "### 单源 BFS\n\n通常我们使用 BFS 求最短路,都是针对如下场景:从特定的起点出发,求解到达特定终点的最短距离。\n\n**这是一类特殊的「单源最短路」问题:本质是在一个边权为 $1$ 的图上,求从特定「源点」出发到达特定「汇点」的最短路径。**\n\n对于本题,如果套用「单源最短路」做法,我们需要对每个「海洋」位置做一次 BFS:求得每个「海洋」的最近陆地距离,然后在所有的距离中取 $max$ 作为答案。\n\n单次 BFS 的最坏情况需要扫描完整个矩阵,复杂度为 $O(n^2)$。\n\n同时,最多有 $n^2$ 个海洋区域需要做 BFS,因此这样的做法复杂度为 $O(n^4)$,并且 $O(n^4)$ 可直接取满。\n\nPS. 数据范围为 $10^2$,理论上是一定会超时,但本题数据较弱,Java 2021/06/28 可过。\n\n一些细节:为了方便,我们在使用哈希表记录距离时,将二维坐标 $(x, y)$ 转化为对应的一维下标 $idx = x \\times n + y$ 作为 key 进行存储。\n\n代码:\n```Java\nclass Solution {\n    int n;\n    int[][] grid;\n    public int maxDistance(int[][] _grid) {\n        grid = _grid;\n        n = grid.length;\n        int ans = -1;\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                if (grid[i][j] == 0) {\n                    ans = Math.max(ans, bfs(i, j));\n                }\n            }\n        }\n        return ans;\n    }\n    // 单次 BFS:求解海洋位置 (x,y) 最近的陆地距离\n    int bfs(int x, int y) {\n        int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n        Deque<int[]> d = new ArrayDeque<>();\n        Map<Integer, Integer> map = new HashMap<>();\n        d.addLast(new int[]{x, y});\n        map.put(x * n + y, 0);\n        while (!d.isEmpty()) {\n            int[] poll = d.pollFirst();\n            int dx = poll[0], dy = poll[1];\n            int step = map.get(dx * n + dy);\n            if (grid[dx][dy] == 1) return step;\n            for (int[] di : dirs) {\n                int nx = dx + di[0], ny = dy + di[1];\n                if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;\n                int key = nx * n + ny;\n                if (map.containsKey(key)) continue;\n                d.addLast(new int[]{nx, ny});\n                map.put(key, step + 1);\n            }\n        }\n        return -1;\n    } \n}\n```\n* 时间复杂度:$O(n^4)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 多源 BFS\n\n这其实还是道「多源 BFS」入门题。\n\n**与「单源最短路」不同,「多源最短路」问题是求从「多个源点」到达「一个/多个汇点」的最短路径。**\n\n在实现上,最核心的搜索部分,「多源 BFS」与「单源 BFS」并无区别。\n\n**并且通过建立「虚拟源点」的方式,我们可以「多源 BFS」转换回「单源 BFS」问题。**\n\n什么意思?\n\n以本题为例,题面要我们求每个「海洋」区域到最近的「陆地」区域的最大值。\n\n我们可以将「源点/起点」和「汇点/终点」进行反转:**从每个「陆地」区域出发,多个「陆地」区域每次同时向往扩散一圈,每个「海洋」区域被首次覆盖时所对应的圈数,就是「海洋」区域距离最近的「陆地」区域的距离。**\n\n不过,这是如何与「单源 BFS」联系起来的呢?\n\n我们可以想象存在一个「虚拟源点」,其与所有「真实源点」(陆地)存在等权的边,那么任意「海洋」区域与「最近的陆地」区域的最短路等价于与「虚拟源点」的最短路:\n\n**实现上,我们并不需要真的将这个虚拟源点建立出来,只需要将所有的「真实源点」进行入队即可。**\n\n这个过程相当于从队列中弹出「虚拟源点」,并把它所能到点(真实源点)进行入队,然后再进行常规的 BFS 即可。\n\n一些细节:实现上为了方便,在进行常规 BFS 时,如果一个「海洋」区域被访问到,说明其被离它「最近的陆地」覆盖到了,修改值为最小距离。这样我们只需要考虑那些值仍然为 $0$ 的「海洋」区域即可(代表尚未被更新)。\n\n代码:\n```Java\nclass Solution {\n    public int maxDistance(int[][] grid) {\n        int n = grid.length;\n        Deque<int[]> d = new ArrayDeque<>();\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                if (grid[i][j] == 1) {\n                    d.add(new int[]{i, j});\n                    map.put(i * n + j, 0);\n                }\n            }\n        }\n        int ans = -1;\n        int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n        while (!d.isEmpty()) {\n            int[] poll = d.poll();\n            int dx = poll[0], dy = poll[1];\n            int step = map.get(dx * n + dy);\n            for (int[] di : dirs) {\n                int nx = dx + di[0], ny = dy + di[1];\n                if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;\n                if (grid[nx][ny] != 0) continue;\n                grid[nx][ny] = step + 1;\n                d.add(new int[]{nx, ny});\n                map.put(nx * n + ny, step + 1);\n                ans = Math.max(ans, step + 1);\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 总结\n\n今天我们介绍了「多源 BFS」,通过建立「虚拟源点」,我们可以将其转化回「单源 BFS」问题。\n\n实现上我们只需要将所有的「真实源点」进行入队,然后再进行 BFS 即可。\n\n看起来两者区别不大,但其本质是通过源点/汇点转换,应用常规的 Flood Fill 将多次朴素 BFS 转化为一次 BFS,可以有效降低我们算法的时间复杂度。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1162` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1171-1180/1175. 质数排列（简单）.md", "url_title": "1175. 质数排列", "url": "https://leetcode.cn/problems/prime-arrangements/solution/by-ac_oier-t3lk/", "difficulty": "简单", "tags": ["数学", "组合数", "二分", "打表"], "question": "请你帮忙给从 $1$ 到 $n$ 的数设计排列方案,使得所有的「质数」都应该被放在「质数索引」(索引从 $1$ 开始)上;你需要返回可能的方案总数。\n\n让我们一起来回顾一下「质数」:质数一定是大于 $1$ 的,并且不能用两个小于它的正整数的乘积来表示。\n\n由于答案可能会很大,所以请你返回答案 模 `mod` $10^9 + 7$ 之后的结果即可。\n\n示例 1:\n```\n输入:n = 5\n\n输出:12\n解释:举个例子,[1,2,5,4,3] 是一个有效的排列,但 [5,2,3,4,1] 不是,因为在第二种情况里质数 5 被错误地放在索引为 1 的位置上。\n```\n示例 2:\n```\n输入:n = 100\n\n输出:682289015\n```\n\n提示:\n* $1 <= n <= 100$", "solution": "### 打表 + 二分 + 数学\n\n根据题意,可将问题转换为求 $n$ 以内的质数个数,记为 $a$,同时可得非质数个数为 $b = n - a$。\n\n质数的放置方案数为 $a!$,而非质数的放置方案数为 $b!$,根据「乘法原理」总的放置方案数为 $a! \\times b!$。\n\n我们可以通过「打表」的方式将 $100$ 以内的质数预处理到数组 `list` 中,对于每个 $n$ 而言,我们找到第一个满足「值小于等于 $n$」的位置,从而得知 $n$ 范围以内的质数个数。\n\n代码:\n```Java\nclass Solution {\n    static int MOD = (int)1e9+7;\n    static List<Integer> list = new ArrayList<>();\n    static {\n        for (int i = 2; i <= 100; i++) {\n            boolean ok = true;\n            for (int j = 2; j * j <= i; j++) {\n                if (i % j == 0) ok = false;\n            }\n            if (ok) list.add(i);\n        }\n    }\n    public int numPrimeArrangements(int n) {\n        int l = 0, r = list.size() - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (list.get(mid) <= n) l = mid;\n            else r = mid - 1;\n        }\n        int a = r + 1, b = n - a;\n        long ans = 1;\n        for (int i = b; i > 1; i--) ans = ans * i % MOD ;\n        for (int i = a; i > 1; i--) ans = ans * i % MOD ;\n        return (int)ans;\n    }\n}\n```\n* 时间复杂度:二分的复杂度为 $O(\\log{C})$,其中 $C = 25$ 为 $100$ 以内的质数个数;计算方案数的复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(C)$,其中 $C = 25$ 为 $100$ 以内的质数个数\n\n---\n\n### 打表 + 数学\n\n更进一步,对于特定的 $n$ 而言,我们在预处理 $100$ 以内的质数时,已经可以确定在 $[1, n]$ 内有多少个质数,从而省掉二分操作。\n\n使用数组 `cnts` 记录下不超过当前值范围内质数的个数,$cnts[i] = x$ 含义为在 $[1, i]$ 范围内质数数量为 $x$。\n\n代码:\n```Java\nclass Solution {\n    static int MOD = (int)1e9+7;\n    static int[] cnts = new int[110];\n    static {\n        List<Integer> list = new ArrayList<>();\n        for (int i = 2; i <= 100; i++) {\n            boolean ok = true;\n            for (int j = 2; j * j <= i; j++) {\n                if (i % j == 0) ok = false;\n            }\n            if (ok) list.add(i);\n            cnts[i] = list.size();\n        }\n    }\n    public int numPrimeArrangements(int n) {\n        int a = cnts[n], b = n - a;\n        long ans = 1;\n        for (int i = b; i > 1; i--) ans = ans * i % MOD ;\n        for (int i = a; i > 1; i--) ans = ans * i % MOD ;\n        return (int)ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(C)$,其中 $C = 100$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1175` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1171-1180/1178. 猜字谜（困难）.md", "url_title": "1178. 猜字谜", "url": "https://leetcode-cn.com/problems/number-of-valid-words-for-each-puzzle/solution/xiang-jin-zhu-shi-xiang-jie-po-su-wei-yu-3cr2/", "difficulty": "困难", "tags": ["状态压缩", "位运算", "哈希表"], "question": "外国友人仿照中国字谜设计了一个英文版猜字谜小游戏,请你来猜猜看吧。\n\n字谜的迷面 puzzle 按字符串形式给出,如果一个单词 word 符合下面两个条件,那么它就可以算作谜底:\n* 单词 word 中包含谜面 puzzle 的第一个字母。\n* 单词 word 中的每一个字母都可以在谜面 puzzle 中找到。\n  例如,如果字谜的谜面是 \"abcdefg\",那么可以作为谜底的单词有 \"faced\", \"cabbage\", 和 \"baggage\";而 \"beefed\"(不含字母 \"a\")以及 \"based\"(其中的 \"s\" 没有出现在谜面中)都不能作为谜底。\n\n返回一个答案数组 answer,数组中的每个元素 answer[i] 是在给出的单词列表 words 中可以作为字谜迷面 puzzles[i] 所对应的谜底的单词数目。\n\n示例:\n```\n输入:\nwords = [\"aaaa\",\"asas\",\"able\",\"ability\",\"actt\",\"actor\",\"access\"], \npuzzles = [\"aboveyz\",\"abrodyz\",\"abslute\",\"absoryz\",\"actresz\",\"gaswxyz\"]\n输出:[1,1,3,2,4,0]\n解释:\n1 个单词可以作为 \"aboveyz\" 的谜底 : \"aaaa\" \n1 个单词可以作为 \"abrodyz\" 的谜底 : \"aaaa\"\n3 个单词可以作为 \"abslute\" 的谜底 : \"aaaa\", \"asas\", \"able\"\n2 个单词可以作为 \"absoryz\" 的谜底 : \"aaaa\", \"asas\"\n4 个单词可以作为 \"actresz\" 的谜底 : \"aaaa\", \"asas\", \"actt\", \"access\"\n没有单词可以作为 \"gaswxyz\" 的谜底,因为列表中的单词都不含字母 'g'。\n```\n\n提示:\n* 1 <= words.length <= $10^5$\n* 4 <= words[i].length <= 50\n* 1 <= puzzles.length <= $10^4$\n* puzzles[i].length == 7\n* words[i][j], puzzles[i][j] 都是小写英文字母。\n* 每个 puzzles[i] 所包含的字符都不重复。", "solution": "### 朴素位运算解法(TLE)\n\n根据「谜底」和「谜面」的对应条件:\n* 单词 `word` 中包含谜面 `puzzle` 的第一个字母。\n* 单词 `word` 中的每一个字母都可以在谜面 `puzzle` 中找到\n\n`puzzle` 本身长度只有 7 位,而且不重复;我们可以发现对应条件与 `word` 的重复字母无关。\n\n因此我们可以使用「二进制」数来表示每一个 `word` 和 `puzzle`:\n\n一个长度为 26 的二进制数来表示(直接使用长度为 32 的 int 即可,使用低 26 位),假如有 `str = \"abz\"` 则对应了 `100...011`(共 26 位,从右往左是 a - z)。\n\n至此我们可以已经可以得出一个朴素解法的思路了:\n\n1. 预处理除所有的 `word` 对应的二进制数字。计算量为 50 * $10^5$,数量级为 $10^6$\n2. 对每个 `puzzle` 进行条件判定(每一个 `puzzle` 都需要遍历所有的 `word` 进行检查)。计算量为 $10^5$ * $10^4$,数量级为 $10^9$\n\n计算机单秒的计算量为 $10^7$ 左右(OJ 测评器通常在 $10^6$ ~ $10^7$ 之间),哪怕忽略常数后,我们的总运算也超过了上限,铁定超时。\n\n代码:\n```java \nclass Solution {\n    public List<Integer> findNumOfValidWords(String[] ws, String[] ps) {\n        // 预处理出所有的 word 所对应的二进制数值\n        List<Integer> list = new ArrayList<>();\n        for (String w : ws) list.add(getBin(w));\n        // 判定每个 puzzles 有多少个谜底\n        List<Integer> ans = new ArrayList<>();\n        for (String p : ps) ans.add(getCnt(list, p));\n        return ans;\n    }\n    // 判定某个 puzzles 有多少个谜底\n    int getCnt(List<Integer> ws, String str) {\n        int ans = 0;\n        // 获取当前 puzzles 对应的二进制数字\n        int t = getBin(str);\n        // 当前 puzzles 的首个字符在二进制数值中的位置\n        int first = str.charAt(0) - 'a';\n        for (int w : ws) {\n            // check 条件一:单词 word 中包含谜面 puzzle 的第一个字母\n            if ((w >> first & 1) == 0) continue;\n            // check 条件二:单词 word 中的每一个字母都可以在谜面 puzzle 中找到\n            if ((w & t) == w) ans++;\n        }\n        return ans;\n    }\n    // 将 str 所包含的字母用二进制标识\n    // 如果 str = abz 则对应的二进制为 100...011 (共 26 位,从右往左是 a - z)\n    int getBin(String str) {\n        int t = 0;\n        char[] cs = str.toCharArray();\n        for (char c : cs) {\n            // 每一位字符所对应二进制数字中哪一位\n            int u = c - 'a';\n            // 如果当前位置为 0,代表还没记录过,则进行记录 (不重复记录)\n            if ((t >> u & 1) == 0) t += 1 << u;\n        }\n        return t;\n    }\n}\n```\n* 时间复杂度:$O(words.length * (words[i].length + puzzles.length))$\n* 空间复杂度:每个 `word` 对应了一个 int,每个 `puzzle` 对应了一个答案。复杂度为 $O(words.length + puzzles.length)$\n\n***\n\n### 哈希表 & 位运算解法\n\n因此我们需要优化上述步骤 1 或者步骤 2 。显然超时的主要原因是步骤 2 计算量太多了。\n\n一个很显眼的突破口是利用 `puzzles[i].length == 7`,同时判定条件 1 对 `puzzle` 的首字母进行了限定。\n\n**对于一个确定的 `puzzle` 而言,我们要找它有多少个「谜底」。可以通过枚举它所有可能的「谜底」,再去 `words` 里面找每一个「谜底」出现了多少次。**\n\n**结合题意的话,就是固定住 `puzzle` 的首位,去枚举其余后面的 6 位的所有的可能性(每一位都有保留和不保留两种选择),即枚举子集的过程。**\n\n你可能还是无法理解,其实就是一个通过 `puzzle` 反推 `word` 的过程:\n\n举个🌰吧,假如我们有 `puzzle` 是 `gabc`(假定现在的 `puzzle` 长度只有 4) ,那么可能的 `word` 有哪些?\n\n1. 首先要满足条件一,也就是 `word` 必然包含首字母 `g`;\n2. 然后是条件二,`word` 中的每一位都在 `puzzle` 出现过,因此可能的 `word` 包括 `g`、`ga`、`gb`、`gc`、`gab`、`gac`、`gbc`、`gabc`。\n\n使用 1 和 0 代表 `puzzle` 每一位选择与否的话,其实就是对应了 1000、1100、1010、1001、1110、1101、1011、1111。\n\n搞明白了这个过程之后,我们需要对 `words` 进行词频统计,我们可以使用「哈希表」记录相同含义的 `word` 出现了多少次(相同含义的意思是包含字母类型一样的 `word`,因为答案和 `word` 的重复字符无关)\n\n这样做的复杂度/计算量是多少呢?\n\n1. 统计所有 `word` 的词频。计算量为 50 * $10^5$,数量级为 $10^6$\n2. 对应每个 `puzzle` 而言,由于其长度确定为 7,因此所有枚举所有可能「谜底」的数量不为 $2^6$=64 个,可以看做是 $O(1)$ 的,检查每个可能的「谜底」在 `words` 出现次数是通过哈希表,也是近似 $O(1)$ 的。因此在确定一个 `puzzle` 的答案时,与 `words` 的长度无关。计算量为 $10^4$,数量级为 $10^4$\n\n计算机单秒的计算量为 $10^7$ 左右(OJ 测评器通常在 $10^6$ ~ $10^7$ 之间),因此可以过。\n\n代码:\n```java\nclass Solution {\n    public List<Integer> findNumOfValidWords(String[] ws, String[] ps) {\n        // 转用 「哈希表」来统计出所有的 word 所对应的二进制数值\n        Map<Integer, Integer> map = new HashMap<>();\n        for (String w : ws) {\n            int t = getBin(w);\n            map.put(t, map.getOrDefault(t, 0) + 1);\n        }\n        // 判定每个 puzzle 有多少个谜底\n        List<Integer> ans = new ArrayList<>();\n        for (String p : ps) ans.add(getCnt(map, p));\n        return ans;\n    }\n    int getCnt(Map<Integer, Integer> map, String str) {\n        int ans = 0;\n        int m = str.length();\n        char[] cs = str.toCharArray();\n        // 当前 puzzle 的首个字符在二进制数值中的位置\n        int first = cs[0] - 'a';\n        // 枚举「保留首个字母」的所有子集\n        // 即我们需要先固定 puzzle 的首位字母,然后枚举剩余的 6 位是否保留\n        // 由于是二进制,每一位共有 0 和 1 两种选择,因此共有 2^6 种可能性,也就是 2^6 = 1 << (7 - 1) = 64 种\n        // i 代表了所有「保留首个字母」的子集的「后六位」的二进制表示\n        for (int i = 0; i < (1 << (m - 1)); i++) {\n            // u 代表了当前可能的谜底。先将首字母提取出来\n            int u = 1 << first;\n            // 枚举「首个字母」之后的每一位\n            for (int j = 1; j < m; j++) {\n                // 如果当前位为 1,代表该位置要保留,将该位置的字母追加到谜底 u 中\n                if (((i >> (j - 1)) & 1) != 0) u += 1 << (cs[j] - 'a');\n            }\n            // 查询这样的字符是否出现在 `words` 中,出现了多少次\n            if (map.containsKey(u)) ans += map.get(u);\n        }\n        return ans;\n    }\n    // 将 str 所包含的字母用二进制标识\n    // 如果 str = abz 则对应的二进制为 100...011 (共 26 位,从右往左是 a - z)\n    int getBin(String str) {\n        int t = 0;\n        char[] cs = str.toCharArray();\n        for (char c : cs) {\n            // 每一位字符所对应二进制数字中哪一位\n            int u = c - 'a';\n            // 如果当前位置为 0,代表还没记录过,则进行记录 (不重复记录)\n            if ((t >> u & 1) == 0) t += 1 << u;\n        }\n        return t;\n    }\n}\n```\n* 时间复杂度:$O(words.length * words[i].length + puzzles.length)$\n* 空间复杂度:`word` 和 `puzzle` 分别具有最大长度和固定长度,使用空间主要取决于量数组的长度。复杂度为 $O(words.length + puzzles.length)$\n\n***\n\n### 位运算说明\n\na >> b & 1 代表检查 a 的第 b 位是否为 1,有两种可能性 0 或者 1\n\na += 1 << b 代表将 a 的第 b 位设置为 1 (当第 b 位为 0 的时候适用)\n\n如不想写对第 b 位为 0 的前置判断,a += 1 << b 也可以改成 a |= 1 << b\n\n*PS. 1 的二进制就是最低位为 1,其他位为 0 哦*\n\n以上两个操作在位运算中出现频率超高,建议每位同学都加深理解。\n\n***\n\n### 点评\n\n这道题解发到 LeetCode 之后,很多同学反映还是看不懂,还是不理解。\n\n于是我重新的思考了这道题的每一个环节。\n\n这道题之所是 Hard,是因为考察的都是违反人性”直觉”的东西:\n\n1. 状态压缩:对一个单词出现过哪些字母,不能采用我们直观中的 map/set 进行记录,而要利用一个长度为 26 的二进制数来记录,对于某个字母需要计算在二进制数中的哪一位,如果出现过用 1 表示,没出现过用 0 表示\n2. 正难则反:不能从 `words` 数组出发,去检查有哪些 `word` 符合要求;而要反过来从 `puzzle` 出发,去枚举当前 `puzzle` 所有合法的 `word`,再去确定这些合法的 `word` 在真实的 `words` 数组中出现了多少次\n\n大家要尽量去理解这种思路的合理性,当这种思路也形成意识的时候,这种题也就不难了。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1178` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1181-1190/1184. 公交站间的距离（简单）.md", "url_title": "1184. 公交站间的距离", "url": "https://leetcode.cn/problems/distance-between-bus-stops/solution/by-ac_oier-fow3/", "difficulty": "简单", "tags": ["模拟"], "question": "环形公交路线上有 $n$ 个站,按次序从 $0$ 到 $n - 1$ 进行编号。我们已知每一对相邻公交站之间的距离,$distance[i]$ 表示编号为 $i$ 的车站和编号为 `(i + 1) % n` 的车站之间的距离。\n\n环线上的公交车都可以按顺时针和逆时针的方向行驶。\n\n返回乘客从出发点 `start` 到目的地 `destination` 之间的最短距离。\n\n示例 1:\n\n```\n输入:distance = [1,2,3,4], start = 0, destination = 1\n\n输出:1\n\n解释:公交站 0 和 1 之间的距离是 1 或 9,最小值是 1。\n```\n示例 2:\n\n```\n输入:distance = [1,2,3,4], start = 0, destination = 2\n\n输出:3\n\n解释:公交站 0 和 2 之间的距离是 3 或 7,最小值是 3。\n```\n示例 3:\n\n```\n输入:distance = [1,2,3,4], start = 0, destination = 3\n\n输出:4\n\n解释:公交站 0 和 3 之间的距离是 6 或 4,最小值是 4。\n```\n\n提示:\n* $1 <= n <= 10^4$\n* $distance.length == n$\n* $0 <= start, destination < n$\n* $0 <= distance[i] <= 10^4$", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n用 `i` 和 `j` 分别代表往前和往后走的指针,`a` 和 `b` 分别统计两种走法的总成本。\n\nJava 代码:\n```Java\nclass Solution {\n    public int distanceBetweenBusStops(int[] dist, int s, int t) {\n        int n = dist.length, i = s, j = s, a = 0, b = 0;\n        while (i != t) {\n            a += dist[i];\n            if (++i == n) i = 0;\n        }\n        while (j != t) {\n            if (--j < 0) j = n - 1; \n            b += dist[j];\n        }\n        return Math.min(a, b);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction distanceBetweenBusStops(dist: number[], s: number, t: number): number {\n    let n = dist.length, i = s, j = s, a = 0, b = 0\n    while (i != t) {\n        a += dist[i]\n        if (++i == n) i = 0\n    }\n    while (j != t) {\n        if (--j < 0) j = n - 1\n        b += dist[j]\n    }\n    return Math.min(a, b)\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1184` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1181-1190/1185. 一周中的第几天（简单）.md", "url_title": "1185. 一周中的第几天", "url": "https://leetcode-cn.com/problems/day-of-the-week/solution/gong-shui-san-xie-jian-dan-ri-qi-tong-ji-czt6/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个日期,请你设计一个算法来判断它是对应一周中的哪一天。\n\n输入为三个整数:`day`、`month` 和 `year`,分别表示日、月、年。\n\n您返回的结果必须是这几个值中的一个 `{\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"}`。\n\n示例 1:\n```\n输入:day = 31, month = 8, year = 2019\n\n输出:\"Saturday\"\n```\n示例 2:\n```\n输入:day = 18, month = 7, year = 1999\n\n输出:\"Sunday\"\n```\n示例 3:\n```\n输入:day = 15, month = 8, year = 1993\n\n输出:\"Sunday\"\n```\n\n提示:\n给出的日期一定是在 `1971` 到 `2100` 年之间的有效日期。", "solution": "### 模拟\n\n题目保证日期是在 `1971` 到 `2100` 之间,我们可以计算给定日期距离 `1970` 的最后一天(星期四)间隔了多少天,从而得知给定日期是周几。\n\n具体的,可以先通过循环处理计算年份在 $[1971, year - 1]$ 时间段,经过了多少天(注意平年为 $365$,闰年为 $366$);然后再处理当前年 $year$ 的月份在 $[1, month - 1]$ 时间段 ,经过了多少天(注意当天年是否为闰年,特殊处理 $2$ 月份),最后计算当前月 $month$ 经过了多少天,即再增加 $day$ 天。\n\n得到距离 `1970` 的最后一天(星期四)的天数后进行取模,即可映射回答案。\n\n代码:\n```Java\nclass Solution {\n    static String[] ss = new String[]{\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"};\n    static int[] nums = new int[]{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};\n    public String dayOfTheWeek(int day, int month, int year) {\n        int ans = 4;\n        for (int i = 1971; i < year; i++) {\n            boolean isLeap = (i % 4 == 0 && i % 100 != 0) || i % 400 == 0;\n            ans += isLeap ? 366 : 365;\n        }\n        for (int i = 1; i < month; i++) {\n            ans += nums[i - 1];\n            if (i == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)) ans++;\n        }\n        ans += day;\n        return ss[ans % 7];\n    }\n}\n```\n* 时间复杂度:令当前时间 `2100-12-xx`,此时达到数据范围对应的计算量上界,设为 $C$。整体复杂度为 $O(C)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1185` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1181-1190/1189. “气球” 的最大数量（简单）.md", "url_title": "1189. “气球” 的最大数量", "url": "https://leetcode-cn.com/problems/maximum-number-of-balloons/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-9px4/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个字符串 `text`,你需要使用 `text` 中的字母来拼凑尽可能多的单词 `\"balloon\"`(气球)。\n\n字符串 `text` 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 `\"balloon\"`。\n\n示例 1:\n\n```\n输入:text = \"nlaebolko\"\n\n输出:1\n```\n示例 2:\n\n```\n输入:text = \"loonbalxballpoon\"\n\n输出:2\n```\n示例 3:\n```\n输入:text = \"leetcode\"\n\n输出:0\n```\n\n提示:\n* $1 <= text.length <= 10^4$\n* `text` 全部由小写英文字母组成", "solution": "### 模拟\n\n根据题意模拟即可。\n\n先统计 `text` 中与单词 $balloon$ 相关的字符数量,由于一个单词需要消耗两个 `l` 和 `o` 字符,对其统计数量进行除 $2$ 下取整,然后所有字符的最小出现次数即是能够凑成 $balloon$ 的最大数量。\n\n代码:\n```Java\nclass Solution {\n    public int maxNumberOfBalloons(String text) {\n        int[] cnts = new int[5];\n        for (int i = 0; i < text.length(); i++) {\n            char c = text.charAt(i);\n            if (c == 'b') cnts[0]++;\n            else if (c == 'a') cnts[1]++;\n            else if (c == 'l') cnts[2]++;\n            else if (c == 'o') cnts[3]++;\n            else if (c == 'n') cnts[4]++;\n        }\n        cnts[2] /= 2; cnts[3] /= 2;\n        int ans = cnts[0];\n        for (int i = 0; i < 5; i++) ans = Math.min(ans, cnts[i]);\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $C$ 为目标字符串的字符种类数量,本题 $C = 5$,统计 `text` 的词频复杂度为 $O(n)$,计算答案复杂度为 $O(C)$。整体复杂度为 $O(n + C)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1189` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1181-1190/1190. 反转每对括号间的子串（中等）.md", "url_title": "1190. 反转每对括号间的子串", "url": "https://leetcode-cn.com/problems/reverse-substrings-between-each-pair-of-parentheses/solution/gong-shui-san-xie-shi-yong-shuang-duan-d-r35q/", "difficulty": "中等", "tags": ["双端队列", "栈"], "question": "给出一个字符串 `s`(仅含有小写英文字母和括号)。\n\n请你按照从括号内到外的顺序,逐层反转每对匹配括号中的字符串,并返回最终的结果。\n\n注意,您的结果中 不应 包含任何括号。\n\n示例 1:\n```\n输入:s = \"(abcd)\"\n\n输出:\"dcba\"\n```\n示例 2:\n```\n输入:s = \"(u(love)i)\"\n\n输出:\"iloveu\"\n```\n示例 3:\n```\n输入:s = \"(ed(et(oc))el)\"\n\n输出:\"leetcode\"\n```\n示例 4:\n```\n输入:s = \"a(bcdefghijkl(mno)p)q\"\n\n输出:\"apmnolkjihgfedcbq\"\n```\n\n提示:\n* $0 <= s.length <= 2000$\n* `s` 中只有小写英文字母和括号\n* 我们确保所有括号都是成对出现的", "solution": "### 双端队列\n\n根据题意,我们可以设计如下处理流程:\n\n* 从前往后遍历字符串,将不是 `)` 的字符串从「尾部」放入队列中\n* 当遇到 `)` 时,从队列「尾部」取出字符串,直到遇到 `(` 为止,并对取出字符串进行翻转\n* 将翻转完成后字符串重新从「尾部」放入队列\n* 循环上述过程,直到原字符串全部出来完成\n* 从队列「头部」开始取字符,得到最终的答案\n\n可以发现,上述过程需要用到双端队列(或者栈,使用栈的话,需要在最后一步对取出字符串再进行一次翻转)。\n\n在 `Java` 中,双端队列可以使用自带的 `ArrayDeque`, 也可以直接使用数组进行模拟。\n\n代码(使用 `ArrayDeque` ):\n```Java\nclass Solution {\n    public String reverseParentheses(String s) {\n        int n = s.length();\n        char[] cs = s.toCharArray();\n        Deque<Character> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            char c = cs[i];\n            if (c == ')') {\n                StringBuilder path = new StringBuilder();\n                while (!d.isEmpty()) {\n                    if (d.peekLast() != '(') {\n                        path.append(d.pollLast());\n                    } else {\n                        d.pollLast();\n                        for (int j = 0; j < path.length(); j++) d.addLast(path.charAt(j));\n                        break;\n                    }\n                }\n            } else {\n                d.addLast(c);\n            }\n        }\n        StringBuilder sb = new StringBuilder();\n        while (!d.isEmpty()) sb.append(d.pollFirst());\n        return sb.toString();\n    }\n}\n```\n代码(数组模拟双端队列):\n```Java\nclass Solution {\n    int N = 2010, he = 0, ta = 0;\n    char[] d = new char[N], path = new char[N];\n    public String reverseParentheses(String s) {\n        int n = s.length();\n        char[] cs = s.toCharArray();\n        for (int i = 0; i < n; i++) {\n            char c = cs[i];\n            if (c == ')') {\n                int idx = 0;\n                while (he < ta) {\n                    if (d[ta - 1] == '(' && --ta >= 0) {\n                        for (int j = 0; j < idx; j++) d[ta++] = path[j];\n                        break;\n                    } else {\n                        path[idx++] = d[--ta];\n                    }\n                }\n            } else {\n                d[ta++] = c;\n            }\n        }\n        StringBuilder sb = new StringBuilder();\n        while (he < ta) sb.append(d[he++]);\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:每个 `(` 字符只会进出队列一次;`)` 字符串都不会进出队列,也只会被扫描一次;分析的重点在于普通字符,可以发现每个普通字符进出队列的次数取决于其右边的 `)` 的个数,最坏情况下每个字符右边全是右括号,因此复杂度可以当做 $O(n^2)$,但实际计算量必然取不满 $n^2$,将普通字符的重复弹出均摊到整个字符串处理过程,可以看作是每个字符串都被遍历常数次,复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1190` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1201-1210/1206. 设计跳表（困难）.md", "url_title": "1206. 设计跳表", "url": "https://leetcode.cn/problems/design-skiplist/solution/by-ac_oier-38rd/", "difficulty": "困难", "tags": ["链表", "数据结构"], "question": "不使用任何库函数,设计一个 跳表 。\n\n跳表 是在 $O(log{n})$ 时间内完成增加、删除、搜索操作的数据结构。跳表相比于树堆与红黑树,其功能与性能相当,并且跳表的代码长度相较下更短,其设计思想与链表相似。\n\n例如,一个跳表包含 `[30, 40, 50, 60, 70, 90]`,然后增加 `80`、`45` 到跳表中,以下图的方式操作:\n\n跳表中有很多层,每一层是一个短的链表。在第一层的作用下,增加、删除和搜索操作的时间复杂度不超过 $O(n)$。跳表的每一个操作的平均时间复杂度是 $O(\\log{n})$,空间复杂度是 $O(n)$。\n\n在本题中,你的设计应该要包含这些函数:\n\n* `bool search(int target)`: 返回 `target` 是否存在于跳表中。\n* `void add(int num)`: 插入一个元素到跳表。\n* `bool erase(int num)`: 在跳表中删除一个值,如果 `num` 不存在,直接返回 `false`. 如果存在多个 `num` ,删除其中任意一个即可。\n\n注意,跳表中可能存在多个相同的值,你的代码需要处理这种情况。\n\n示例 1:\n```\n输入\n[\"Skiplist\", \"add\", \"add\", \"add\", \"search\", \"add\", \"search\", \"erase\", \"erase\", \"search\"]\n[[], [1], [2], [3], [0], [4], [1], [0], [1], [1]]\n\n输出\n[null, null, null, null, false, null, true, false, true, false]\n\n解释\nSkiplist skiplist = new Skiplist();\nskiplist.add(1);\nskiplist.add(2);\nskiplist.add(3);\nskiplist.search(0);   // 返回 false\nskiplist.add(4);\nskiplist.search(1);   // 返回 true\nskiplist.erase(0);    // 返回 false,0 不在跳表中\nskiplist.erase(1);    // 返回 true\nskiplist.search(1);   // 返回 false,1 已被擦除\n```\n\n提示:\n* $0 <= num, target <= 2 \\times 10^4$\n* 调用 `search`, `add`,  `erase` 操作次数不大于 $5 \\times 10^44$", "solution": "### 数据结构\n\n对于单链表而言,所有的操作(增删改查)都遵循「先查找,再操作」的步骤,这导致在单链表上所有操作复杂度均为 $O(n)$(瓶颈在于查找过程)。\n\n跳表相对于单链表,则是通过引入「多层」链表来优化查找过程,其中每层链表均是「有序」链表:\n\n* 对于单链表的 `Node` 设计而言,我们只需存储对应的节点值 `val`,以及当前节点的下一节点的指针 `ne` 即可(`ne` 为一指针变量)\n\n* 对于跳表来说,除了存储对应的节点值 `val` 以外,我们需要存储当前节点在「每一层」的下一节点指针 `ne`(`ne` 为指针数组)\n\n跳表的 `level` 编号从下往上递增,最下层的链表为元素最全的有序单链表,而查找过程则是按照 `level` 从上往下进行。\n\n操作次数的数据范围为 $n = 5 \\times 10^4$,因此设计最大的 `level` 为 $\\log{n}$ 即可确保复杂度,但由于操作次数 $n = 5 \\times 10^4$ 不可能全是 `add` 操作,因此这里直接取 `level` 为 $10$。\n\n同时为了简化,建立一个哨兵节点 `he`,哨兵值的值应当足够小(根据数据范围,设定为 $-1$ 即可),所有的操作(假设当前操作的传入值为 `t`),先进行统一化的查找:**查找出每一层比 `t` 严格小的最后一个节点,将其存成 `ns` 数组。即 $ns[i]$ 为 $level = i$ 层严格比 $t$ 小的最后一个节点。**\n\n再根据不同的操作进行下一步动作:\n\n* `search` 操作:由于最后一层必然是元素最全的单链表,因此可以直接访问 `ns[0].ne[0]` 即是所有元素中满足大于等于 `t` 的第一个元素,通过判断其值与传入值 `t` 的大小关系来决定结果;\n* `add` 操作:由于最后一层必然是元素最全的单链表,因此我们「从下往上」进行插入,最底下一层必然要插入,然后以一半的概率往上传递;\n* `erase` 操作:与 `add` 操作互逆,按照「从下往上」的顺序进行删除。需要注意的是,由于相同的值在跳表中可能存在多个,因此我们在「从下往上」删除过程中需要判断待删除的元素与 `ns[0].ne[0]` 是否为同一元素(即要判断地址是否相同,而不是值相同)。\n\nJava 代码:\n```Java\nclass Skiplist {\n    int level = 10;\n    class Node {\n        int val;\n        Node[] ne = new Node[level];\n        Node (int _val) {\n            val = _val;\n        }\n    }\n    Random random = new Random();\n    Node he = new Node(-1);\n    void find(int t, Node[] ns) {\n        Node cur = he;\n        for (int i = level - 1; i >= 0; i--) {\n            while (cur.ne[i] != null && cur.ne[i].val < t) cur = cur.ne[i];\n            ns[i] = cur;\n        }\n    }\n    public boolean search(int t) {\n        Node[] ns = new Node[level];\n        find(t, ns);\n        return ns[0].ne[0] != null && ns[0].ne[0].val == t;\n    }\n    public void add(int t) {\n        Node[] ns = new Node[level];\n        find(t, ns);\n        Node node = new Node(t);\n        for (int i = 0; i < level; i++) {\n            node.ne[i] = ns[i].ne[i];\n            ns[i].ne[i] = node;\n            if (random.nextInt(2) == 0) break;\n        }\n    }\n    public boolean erase(int t) {\n        Node[] ns = new Node[level];\n        find(t, ns);\n        Node node = ns[0].ne[0];\n        if (node == null || node.val != t) return false;\n        for (int i = 0; i < level && ns[i].ne[i] == node; i++) ns[i].ne[i] = ns[i].ne[i].ne[i];\n        return true;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nconst level: number = 10\nclass TNode {\n    val: number\n    ne: TNode[] = new Array<TNode>(level)\n    constructor(_val: number) {\n        this.val = _val\n    } \n}\nclass Skiplist {\n    he: TNode = new TNode(-1)\n    find(t: number, ns: TNode[]): void {\n        let cur = this.he\n        for (let i = level - 1; i >= 0; i--) {\n            while (cur.ne[i] != null && cur.ne[i].val < t) cur = cur.ne[i]\n            ns[i] = cur\n        }\n    }\n    search(t: number): boolean {\n        let ns: TNode[] = new Array<TNode>(level)\n        this.find(t, ns)\n        return ns[0].ne[0] != null && ns[0].ne[0].val == t\n    }\n    add(t: number): void {\n        let ns: TNode[] = new Array<TNode>(level)\n        this.find(t, ns)\n        const node = new TNode(t)\n        for (let i = 0; i < level; i++) {\n            node.ne[i] = ns[i].ne[i]\n            ns[i].ne[i] = node\n            if (Math.round(Math.random()) == 0) break\n        }\n    }\n    erase(t: number): boolean {\n        let ns: TNode[] = new Array<TNode>(level)\n        this.find(t, ns)\n        const node = ns[0].ne[0]\n        if (node == null || node.val != t) return false\n        for (let i = 0; i < level && ns[i].ne[i] == node; i++) ns[i].ne[i] = ns[i].ne[i].ne[i]\n        return true\n    }\n}\n```\n* 时间复杂度:所有操作的复杂度瓶颈在于 `find` 查找,`find` 查找期望复杂度为 $O(\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1206` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1201-1210/1208. 尽可能使字符串相等（中等）.md", "url_title": "1208. 尽可能使字符串相等", "url": "https://leetcode-cn.com/problems/get-equal-substrings-within-budget/solution/ni-bu-ke-neng-kan-bu-dong-de-qian-zhui-h-u4l1/", "difficulty": "中等", "tags": ["前缀和", "二分", "滑动窗口"], "question": "给你两个长度相同的字符串,s 和 t。\n\n将 s 中的第 i 个字符变到 t 中的第 i 个字符需要 |s[i] - t[i]| 的开销(开销可能为 0),也就是两个字符的 ASCII 码值的差的绝对值。\n\n用于变更字符串的最大预算是 maxCost。在转化字符串时,总开销应当小于等于该预算,这也意味着字符串的转化可能是不完全的。\n\n如果你可以将 s 的子字符串转化为它在 t 中对应的子字符串,则返回可以转化的最大长度。\n\n如果 s 中没有子字符串可以转化成 t 中对应的子字符串,则返回 0。\n\n \n\n示例 1:\n```\n输入:s = \"abcd\", t = \"bcdf\", maxCost = 3\n\n输出:3\n\n解释:s 中的 \"abc\" 可以变为 \"bcd\"。开销为 3,所以最大长度为 3。\n```\n示例 2:\n```\n输入:s = \"abcd\", t = \"cdef\", maxCost = 3\n\n输出:1\n\n解释:s 中的任一字符要想变成 t 中对应的字符,其开销都是 2。因此,最大长度为 1。\n```\n示例 3:\n```\n输入:s = \"abcd\", t = \"acde\", maxCost = 0\n\n输出:1\n\n解释:a -> a, cost = 0,字符串未发生变化,所以最大长度为 1。\n```\n\n提示:\n* 1 <= s.length, t.length <= $10^5$\n* 0 <= maxCost <= $10^6$\n* s 和 t 都只含小写英文字母。", "solution": "### 前缀和 + 二分 + 滑动窗口\n\n给定了长度相同的 `s` 和 `t`,那么对于每一位而言,修改的成本都是相互独立而确定的。\n\n我们可以先预处理出修改成本的前缀和数组 `sum`。\n\n当有了前缀和数组之后,对于任意区间 `[i,j]` 的修改成本,便可以通过 `sum[j] - sum[i - 1]` 得出。\n\n那么接下来我们只需要找出成本不超过 `maxCost` 的最大长度区间,这个长度区间其实就是滑动窗口长度,滑动窗口长度的范围为 `[1, n]` (n 为字符串的长度)。\n\n通过枚举来找答案可以吗?\n\n我们可以通过数据范围大概分析一下哈,共有 `n` 个滑动窗口长度要枚举,复杂度为 $O(n)$,对于每个滑动窗口长度,需要对整个前缀和数组进行滑动检查,复杂度为 $O(n)$。也就是整体复杂度是 $O(n^2)$ 的。\n\n数据范围是 $10^5$,那么单个样本的计算量是 $10^{10}$,计算机单秒肯定算不完,会超时 ~\n\n所以我们直接放弃通过枚举的朴素做法。\n\n那么如何优化呢?其实有了对于朴素解法的分析之后,无非就是两个方向:\n\n1. 优化第一个 $O(n)$:减少需要枚举的滑动窗口长度\n2. 优化第二个 $O(n)$:实现不完全滑动前缀和数组,也能确定滑动窗口长度是否合法\n\n事实上第 2 点是无法实现的,我们只能「减少需要枚举的滑动窗口长度」。\n\n一个 $O(n)$ 的操作往下优化,通常就是优化成 $O(\\log{n})$,$O(\\log{n})$ 基本上我们可以先猜一个「二分」查找。\n\n然后我们再来分析是否可以二分:假设我们有满足要求的长度 `ans`,那么在以 `ans` 为分割点的数轴上(数轴的范围是滑动窗口长度的范围:`[1, n]`):\n\n1. 所有满足 `<= ans` 的点的修改成本必然满足 `<= maxCost`\n2. 所有满足 `> ans` 的点的修改成本必然满足 `> maxCost` (否则 `ans` 就不会是答案)\n\n因此 `ans` 在数轴 `[1, n]` 上具有二段性,我们可以使用「二分」找 `ans`。得证「二分」的合理性。\n\n**可见二分的本质是二段性,而非单调性。**\n\n##### 编码细节:\n\n1. 为了方便的预处理前缀和和减少边界处理,我会往字符串头部添加一个空格,使之后的数组下标从 1 开始\n2. 二分出来滑动窗口长度,需要在返回时再次检查,因为可能没有符合条件的有效滑动窗口长度\n\n代码:\n```Java\nclass Solution {\n    public int equalSubstring(String ss, String tt, int max) {\n        int n = ss.length();\n        ss = \" \" + ss;\n        tt = \" \" + tt;\n        char[] s = ss.toCharArray();\n        char[] t = tt.toCharArray();\n        int[] sum = new int[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + Math.abs(s[i] - t[i]);\n        int l = 1, r = n;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (check(sum, mid, max)) {\n                l = mid;\n            } else {\n                r = mid - 1;\n            }\n        }\n        return check(sum, r, max) ? r : 0;\n    }\n    boolean check(int[] nums, int mid, int max) {\n        for (int i = mid; i < nums.length; i++) {\n            int tot = nums[i] - nums[i - mid];\n            if (tot <= max) return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:预处理出前缀和的复杂度为 $O(n)$;二分出「滑动窗口长度」的复杂度为 $O(\\log{n})$,对于每个窗口长度,需要扫描一遍数组进行检查,复杂度为 $O(n)$,因此二分的复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:使用了前缀和数组。复杂度为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1208` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1201-1210/1210. 穿过迷宫的最少移动次数（困难）.md", "url_title": "1210. 穿过迷宫的最少移动次数", "url": null, "difficulty": "困难", "tags": ["BFS"], "question": "你还记得那条风靡全球的贪吃蛇吗?\n\n我们在一个 `n*n` 的网格上构建了新的迷宫地图,蛇的长度为 `2`,也就是说它会占去两个单元格。蛇会从左上角(`(0, 0)` 和 `(0, 1)`)开始移动。我们用 `0` 表示空单元格,用 `1` 表示障碍物。\n\n蛇需要移动到迷宫的右下角(`(n-1, n-2)` 和 `(n-1, n-1)`)。\n\n每次移动,蛇可以这样走:\n\n* 如果没有障碍,则向右移动一个单元格。并仍然保持身体的水平/竖直状态。\n* 如果没有障碍,则向下移动一个单元格。并仍然保持身体的水平/竖直状态。\n* 如果它处于水平状态并且其下面的两个单元都是空的,就顺时针旋转 `90` 度。蛇从(`(r, c)`、`(r, c+1)`)移动到 (`(r, c)`、`(r+1, c)`)。\n\t\n* 如果它处于竖直状态并且其右面的两个单元都是空的,就逆时针旋转 `90` 度。蛇从(`(r, c)`、`(r+1, c)`)移动到(`(r, c)`、`(r, c+1)`)。\n\t\n\n返回蛇抵达目的地所需的最少移动次数。\n\n如果无法到达目的地,请返回 `-1`。\n\n示例 1:\n\n```\n输入:grid = [[0,0,0,0,0,1],\n               [1,1,0,0,1,0],\n               [0,0,0,0,1,1],\n               [0,0,1,0,1,0],\n               [0,1,1,0,0,0],\n               [0,1,1,0,0,0]]\n\n输出:11\n\n解释:\n一种可能的解决方案是 [右, 右, 顺时针旋转, 右, 下, 下, 下, 下, 逆时针旋转, 右, 下]。\n```\n示例 2:\n```\n输入:grid = [[0,0,1,1,1,1],\n               [0,0,0,0,1,1],\n               [1,1,0,0,0,1],\n               [1,1,1,0,0,1],\n               [1,1,1,0,0,1],\n               [1,1,1,0,0,0]]\n\n输出:9\n```\n\n提示:\n* $2 <= n <= 100$\n* $0 <= grid[i][j] <= 1$\n* 蛇保证从空单元格开始出发。", "solution": "### BFS\n\n题目要我们求从特定起点到特定终点的最少步数,由于我们蛇的长度固定为 $2$,因此我们可用三元组 $(x, y, cd)$ 来代表蛇的实际位置。其中 $(x, y)$ 代表蛇尾位置,$cd$ 代表当前蛇的方向状态,$0$ 代表水平状态,$1$ 代表竖直状态。\n\n蛇尾加上方向状态可确定其蛇头位置 :`tx = cd == 0 ? nx : nx + 1`、`ty = cd == 0 ? ny + 1 : ny`。\n\n对四种移动规则所导致三元组变化进行分情况讨论:\n\n1. 往右移动:对于蛇尾而言,只有维度 $y$ 进行加一,其余维度不变。三元组变化总结为 $(0, 1, 0)$\n2. 往下移动:对于蛇尾而言,只有维度 $x$ 进行加一,其余维度不变。三元组变化总结为 $(1, 0, 0)$\n3. 旋转:对于蛇尾,只有 $cd$ 维度对进行翻转,其余维度不变。三元组变化总结定为 $(0, 0, 1)$\n\n综上,所有移动规则可总结为 `int[][] dirs = new int[][]{{1,0,0},{0,1,0},{0,0,1}}`。\n\n在进行 `BFS` 时,通过遍历 `dirs` 来得到新的三元组:原位置 `(x, y, cd)` 转换到新位置 `(x + dir[0], y + dir[1], cd ^ dir[2])`。\n\n在得到新蛇尾位置 $(nx, ny)$ 之后,计算新蛇头的位置 $(tx, ty)$。需要确保整条蛇没有越界,没有碰到障碍物,并且旋转转移时,额外检查 $(x + 1, y + 1)$ 位置是否合法。\n\nJava 代码:\n```Java\nclass Solution {\n    int[][] dirs = new int[][]{{1,0,0},{0,1,0},{0,0,1}};\n    public int minimumMoves(int[][] g) {\n        int n = g.length;\n        Deque<int[]> d = new ArrayDeque<>();\n        d.addLast(new int[]{0,0,0,0});\n        boolean[][][] vis = new boolean[n][n][2];\n        vis[0][0][0] = true;\n        while (!d.isEmpty()) {\n            int[] info = d.pollFirst();\n            int x = info[0], y = info[1], cd = info[2], step = info[3];\n            for (int[] dir : dirs) {\n                int nx = x + dir[0], ny = y + dir[1], nd = cd ^ dir[2]; // 新蛇尾位置和方向\n                int tx = nd == 0 ? nx : nx + 1, ty = nd == 0 ? ny + 1 : ny; // 新蛇头\n                if (nx >= n || ny >= n || tx >= n || ty >= n) continue; // 整条蛇不越界\n                if (g[nx][ny] == 1 || g[tx][ty] == 1) continue; // 没有触及障碍物\n                if (vis[nx][ny][nd]) continue;\n                if (cd != nd && g[x + 1][y + 1] == 1) continue; // 旋转时,额外检查多一个位置\n                if (nx == n - 1 && ny == n - 2 && nd == 0) return step + 1;\n                d.addLast(new int[]{nx, ny, nd, step + 1});\n                vis[nx][ny][nd] = true;\n            }\n        }\n        return -1;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int minimumMoves(vector<vector<int>>& g) {\n        vector<vector<int>> dirs = {{1,0,0}, {0,1,0}, {0,0,1}};\n        int n = g.size();\n        queue<vector<int>> d;\n        d.push({0, 0, 0, 0});\n        vector<vector<vector<bool>>> vis(n, vector<vector<bool>>(n, vector<bool>(2, false)));\n        vis[0][0][0] = true;\n        while (!d.empty()) {\n            vector<int> info = d.front();\n            d.pop();\n            int x = info[0], y = info[1], cd = info[2], step = info[3];\n            for (vector<int>& dir : dirs) {\n                int nx = x + dir[0], ny = y + dir[1], nd = cd ^ dir[2]; \n                int tx = nd == 0 ? nx : nx + 1, ty = nd == 0 ? ny + 1 : ny; \n                if (nx >= n || ny >= n || tx >= n || ty >= n) continue;\n                if (g[nx][ny] == 1 || g[tx][ty] == 1) continue;   \n                if (vis[nx][ny][nd]) continue;\n                if (cd != nd && g[x + 1][y + 1] == 1) continue; \n                if (nx == n - 1 && ny == n - 2 && nd == 0) return step + 1;\n                d.push({nx, ny, nd, step + 1});\n                vis[nx][ny][nd] = true;\n            }\n        }\n        return -1;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minimumMoves(self, g: List[List[int]]) -> int:\n        dirs = [(1, 0, 0), (0, 1, 0), (0, 0, 1)]\n        n = len(g)\n        d = deque([(0,0,0,0)])\n        vis = [[[0]*2 for _ in range(n)] for _ in range(n)]\n        vis[0][0][0] = 1\n        while d:\n            x, y, cd, step = d.popleft()\n            for dir in dirs:\n                nx, ny, nd = x + dir[0], y + dir[1], cd ^ dir[2]\n                tx, ty = nx + (nd == 1), ny + (nd == 0)\n                if nx >= n or ny >= n or tx >= n or ty >= n: continue\n                if g[nx][ny] == 1 or g[tx][ty] == 1: continue\n                if vis[nx][ny][nd]: continue\n                if cd != nd and g[x + 1][y + 1] == 1: continue\n                if nx == n - 1 and ny == n - 2 and nd == 0: return step + 1\n                d.append((nx, ny, nd, step + 1))\n                vis[nx][ny][nd] = 1\n        return -1\n```\nTypeScript 代码:\n```TypeScript\nfunction minimumMoves(g: number[][]): number {\n    const n = g.length;\n    const d: [number, number, number, number][] = [[0,0,0,0]];\n    const vis: boolean[][][] = Array.from({ length: n }, () => Array.from({ length: n }, () => [false, false]));\n    vis[0][0][0] = true;\n    const dirs: [number, number, number][] = [[1,0,0], [0,1,0], [0,0,1]];\n    while (d.length > 0) {\n        const [x, y, cd, step] = d.shift()!;\n        for (const dir of dirs) {\n            const nx = x + dir[0], ny = y + dir[1], nd = cd ^ dir[2];\n            const tx = nd === 0 ? nx : nx + 1, ty = nd === 0 ? ny + 1 : ny;\n            if (nx >= n || ny >= n || tx >= n || ty >= n) continue;\n            if (g[nx][ny] === 1 || g[tx][ty] === 1) continue\n            if (vis[nx][ny][nd]) continue;\n            if (cd !== nd && g[x + 1][y + 1] === 1) continue;\n            if (nx === n - 1 && ny === n - 2 && nd === 0) return step + 1;\n            d.push([nx, ny, nd, step + 1]);\n            vis[nx][ny][nd] = true;\n        }\n    }\n    return -1;\n};\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2 \\times C)$,其中 $C = 2$ 代表蛇可变状态方向", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1210` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/121-130/124. 二叉树中的最大路径和（困难）.md", "url_title": "124. 二叉树中的最大路径和", "url": "https://leetcode.cn/problems/binary-tree-maximum-path-sum/solutions/2451624/gong-shui-san-xie-jian-dan-di-gui-shu-xi-nlci/", "difficulty": "困难", "tags": ["递归", "二叉树", "DFS", "树形 DP", "动态规划"], "question": "二叉树中的 路径 被定义为一条节点序列,序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点,且不一定经过根节点。\n\n路径和 是路径中各节点值的总和。\n\n给你一个二叉树的根节点 `root`,返回其 最大路径和 。\n\n示例 1:\n\n```\n输入:root = [1,2,3]\n\n输出:6\n\n解释:最优路径是 2 -> 1 -> 3 ,路径和为 2 + 1 + 3 = 6\n```\n示例 2:\n\n```\n输入:root = [-10,9,20,null,null,15,7]\n\n输出:42\n\n解释:最优路径是 15 -> 20 -> 7 ,路径和为 15 + 20 + 7 = 42\n```\n\n提示:\n* 树中节点数目范围是 $[1, 3 \\times 10^4]$\n* $-1000 <= Node.val <= 1000$", "solution": "### 递归 \n\n一个简单的做法是直接递归来做:设计 `DFS`  函数,传入当前节点 `cur`,返回以该节点“往下”延伸所能取得的最大路径和。\n\n即在 **仅使用当前节点**、**使用当前节点和左子树路径** 和 **使用当前节点和右子树路径** 三者中取最大值进行返回。\n\n同时在 `DFS`  过程中,我们计算「以当前节点 `cur` 为路径最高点」时的最大路径和,并用此来更新全局变量 `ans`。\n\n具体的,在以节点 `cur` 为路径最高点时的最大路径和,首先包含当前节点本身(`cur.val`),以及可选的左右节点路径和(`dfs(cur.left)` 和 `dfs(cur.right)`)。当左右节点路径和不为负数时,说明能够对当前路径起到正向贡献作用,将其添加到路径中。\n\nJava 代码:\n```Java\nclass Solution {\n    int ans = Integer.MIN_VALUE;\n    public int maxPathSum(TreeNode root) {\n        dfs(root);\n        return ans;\n    }\n    int dfs(TreeNode root) {\n        if (root == null) return 0;\n        int left = dfs(root.left), right = dfs(root.right);\n        int t = root.val;\n        if (left >= 0) t += left;\n        if (right >= 0) t += right;\n        ans = Math.max(ans, t);\n        return Math.max(root.val, Math.max(left, right) + root.val);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int ans = INT_MIN;\n    int maxPathSum(TreeNode* root) {\n        dfs(root);\n        return ans;\n    }\n    int dfs(TreeNode* root) {\n        if (root == nullptr) return 0;\n        int left = dfs(root->left), right = dfs(root->right);\n        int t = root->val;\n        if (left >= 0) t += left;\n        if (right >= 0) t += right;\n        ans = max(ans, t);\n        return max(root->val, max(left, right) + root->val);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxPathSum(self, root: Optional[TreeNode]) -> int:\n        ans = float('-inf')\n        def dfs(root):\n            nonlocal ans\n            if not root: return 0\n            l, r = dfs(root.left), dfs(root.right)\n            t = root.val\n            if l >= 0: t += l\n            if r >= 0: t += r\n            ans = max(ans, t)\n            return max(root.val, max(l, r) + root.val)\n        dfs(root)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction maxPathSum(root: TreeNode | null): number {\n    let ans = -0x3f3f3f3f;\n    const dfs = function(root: TreeNode | null): number {\n        if (root == null) return 0;\n        const l = dfs(root.left), r = dfs(root.right);\n        let t = root.val;\n        if (l >= 0) t += l;\n        if (r >= 0) t += r;\n        ans = Math.max(ans, t);\n        return Math.max(root.val, Math.max(l, r) + root.val);\n    };\n    dfs(root);\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 树形 DP\n\n另一个做法是使用「树形 DP」思路来做。\n\n将某个节点所在最佳路径根据方向进行拆分:**往左子节点进行延伸**、**往右子节点进行延伸** 和 **往父节点进行延伸**。\n\n若能分别求解出三个方向的最大路径和,从中选择路径和最大(路径和非零)的两个方向进行累加,便是当前节点的最大路径和。\n\n具体的,创建哈希表记录某个节点三个方向的路径和情况:节点对象作为哈希表的键,三个方向路径和情况作为值。\n\n即键值对格式:`节点对象: [父节点方向最大路径和, 左子节点方向最大路径和, 右子节点方向最大路径和]`。\n\n然后是常规的树形 DP 求解思路:第一次 `DFS`  先求解两个“方向往下”的最大路径和。第二次 `DFS`  根据 **首次 `DFS` 已算好的“方向往下”的路径和情况** 以及 **本轮 `DFS`  已递归处理好的当前节点“方向往上”的路径和情况**,来求解 当前节点子节点 的“方向往上”路径和情况。\n\n> 对「树形 DP」接触不深的同学,可以看 [前置 🧀](https://leetcode-cn.com/problems/minimum-height-trees/solution/by-ac_oier-7xio/)\n\nJava 代码:\n```Java\nclass Solution {\n    Map<TreeNode, int[]> map = new HashMap<>(); // 节点: [父, 左, 右]\n    public int maxPathSum(TreeNode root) {\n        dfs1(root, null);\n        dfs2(root, null);\n        int ans = Integer.MIN_VALUE;\n        for (TreeNode cur : map.keySet()) {\n            int t = cur.val;\n            int[] info = map.get(cur);\n            Arrays.sort(info);\n            if (info[2] >= 0) t += info[2];\n            if (info[1] >= 0) t += info[1];\n            ans = Math.max(ans, t);\n        }\n        return ans;\n    }\n    int dfs1(TreeNode cur, TreeNode fa) {\n        if (cur == null) return 0;\n        int left = dfs1(cur.left, cur), right = dfs1(cur.right, cur);\n        int[] info = map.getOrDefault(cur, new int[3]);\n        info[1] = left; info[2] = right;\n        map.put(cur, info);\n        return Math.max(cur.val, cur.val + Math.max(left, right));\n    }\n    void dfs2(TreeNode cur, TreeNode fa) {\n        if (cur == null) return ;\n        int[] curInfo = map.get(cur);\n        if (cur.left != null) {\n            int[] leftInfo = map.get(cur.left);\n            leftInfo[0] = Math.max(cur.val, cur.val + Math.max(curInfo[0], curInfo[2]));\n        }\n        if (cur.right != null) {\n            int[] rightInfo = map.get(cur.right);\n            rightInfo[0] = Math.max(cur.val, cur.val + Math.max(curInfo[0], curInfo[1]));\n        }\n        dfs2(cur.left, cur);\n        dfs2(cur.right, cur);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.124` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/121-130/127. 单词接龙（困难）.md", "url_title": "127. 单词接龙", "url": "https://leetcode-cn.com/problems/word-ladder/solution/gong-shui-san-xie-ru-he-shi-yong-shuang-magjd/", "difficulty": "困难", "tags": ["双向 BFS", "启发式搜索", "AStar 算法"], "question": "字典 `wordList` 中从单词 `beginWord `和 `endWord` 的 转换序列 是一个按下述规格形成的序列:\n\n* 序列中第一个单词是 `beginWord` 。\n* 序列中最后一个单词是 `endWord` 。\n* 每次转换只能改变一个字母。\n* 转换过程中的中间单词必须是字典 `wordList` 中的单词。\n\n给你两个单词 `beginWord `和 `endWord `和一个字典 `wordList `,找到从 `beginWord `到 `endWord `的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列,返回 $0$。\n\n示例 1:\n```\n输入:beginWord = \"hit\", endWord = \"cog\", wordList = [\"hot\",\"dot\",\"dog\",\"lot\",\"log\",\"cog\"]\n\n输出:5\n\n解释:一个最短转换序列是 \"hit\" -> \"hot\" -> \"dot\" -> \"dog\" -> \"cog\", 返回它的长度 5。\n```\n示例 2:\n```\n输入:beginWord = \"hit\", endWord = \"cog\", wordList = [\"hot\",\"dot\",\"dog\",\"lot\",\"log\"]\n\n输出:0\n\n解释:endWord \"cog\" 不在字典中,所以无法进行转换。\n```\n\n提示:\n* $1 <= beginWord.length <= 10$\n* $endWord.length == beginWord.length$\n* $1 <= wordList.length <= 5000$\n* $wordList[i].length == beginWord.length$\n* `beginWord`、`endWord` 和 `wordList[i]` 由小写英文字母组成\n* `beginWord != endWord`\n* `wordList` 中的所有字符串 互不相同", "solution": "### 基本分析\n\n根据题意,每次只能替换一个字符,且每次产生的新单词必须在 `wordList` 出现过。\n\n一个朴素的实现方法是,使用 BFS 的方式求解。\n\n从 `beginWord` 出发,枚举所有替换一个字符的方案,如果方案存在于 `wordList` 中,则加入队列中,这样队列中就存在所有替换次数为 $1$ 的单词。然后从队列中取出元素,继续这个过程,直到遇到 `endWord` 或者队列为空为止。\n\n同时为了「防止重复枚举到某个中间结果」和「记录每个中间结果是经过多少次转换而来」,我们需要建立一个「哈希表」进行记录。\n\n哈希表的 KV 形式为 `{ 单词 : 由多少次转换得到 }`。\n\n当枚举到新单词 `str` 时,需要先检查是否已经存在与「哈希表」中,如果不存在则更新「哈希表」并将新单词放入队列中。\n\n**这样的做法可以确保「枚举到所有由 `beginWord` 到 `endWord` 的转换路径」,并且由 `beginWord` 到 `endWord` 的「最短转换路径」必然会最先被枚举到。**\n\n---\n\n### 双向 BFS\n\n经过分析,BFS 确实可以做,但本题的数据范围较大:`1 <= beginWord.length <= 10`\n\n朴素的 BFS 可能会带来「搜索空间爆炸」的情况。\n\n想象一下,如果我们的 `wordList` 足够丰富(包含了所有单词),对于一个长度为 $10$ 的 `beginWord` 替换一次字符可以产生 $10 \\times 25$ 个新单词(每个替换点可以替换另外 $25$ 个小写字母),第一层就会产生 $250$ 个单词;第二层会产生超过 $6 \\times 10^4$ 个新单词 ...\n\n**随着层数的加深,这个数字的增速越快,这就是「搜索空间爆炸」问题。**\n\n**在朴素的 BFS 实现中,空间的瓶颈主要取决于搜索空间中的最大宽度。**\n\n那么有没有办法让我们不使用这么宽的搜索空间,同时又能保证搜索到目标结果呢?\n\n「双向 BFS」 可以很好的解决这个问题:\n\n**同时从两个方向开始搜索,一旦搜索到相同的值,意味着找到了一条联通起点和终点的最短路径。**\n\n「双向 BFS」的基本实现思路如下:\n\n1. 创建「两个队列」分别用于两个方向的搜索;\n2. 创建「两个哈希表」用于「解决相同节点重复搜索」和「记录转换次数」;\n3. 为了尽可能让两个搜索方向“平均”,每次从队列中取值进行扩展时,先判断哪个队列容量较少;\n4. 如果在搜索过程中「搜索到对方搜索过的节点」,说明找到了最短路径。\n\n「双向 BFS」基本思路对应的伪代码大致如下:\n\n```Java\nd1、d2 为两个方向的队列\nm1、m2 为两个方向的哈希表,记录每个节点距离起点的\n    \n// 只有两个队列都不空,才有必要继续往下搜索\n// 如果其中一个队列空了,说明从某个方向搜到底都搜不到该方向的目标节点\nwhile(!d1.isEmpty() && !d2.isEmpty()) {\n    if (d1.size() < d2.size()) {\n        update(d1, m1, m2);\n    } else {\n        update(d2, m2, m1);\n    }\n}\n\n// update 为将当前队列 d 中包含的元素取出,进行「一次完整扩展」的逻辑(按层拓展)\nvoid update(Deque d, Map cur, Map other) {}\n```\n\n回到本题,我们看看如何使用「双向 BFS」进行求解。\n\n估计不少同学是第一次接触「双向 BFS」,因此这次我写了大量注释。\n\n建议大家带着对「双向 BFS」的基本理解去阅读。\n\nJava 代码:\n```Java\nclass Solution {\n    String s, e;\n    Set<String> set = new HashSet<>();\n    public int ladderLength(String beginWord, String endWord, List<String> wordList) {\n        s = beginWord; e = endWord;\n        // 将所有 word 存入 set,如果目标单词不在 set 中,说明无解\n        for (String w : wordList) set.add(w);\n        if (!set.contains(e)) return 0;\n        int ans = bfs();\n        return ans == -1 ? 0 : ans + 1;\n    }\n\n    int bfs() {\n        // d1 代表从起点 beginWord 开始搜索(正向)\n        // d2 代表从结尾 endWord 开始搜索(反向)\n        Deque<String> d1 = new ArrayDeque<>(), d2 = new ArrayDeque(); \n        \n        /*\n         * m1 和 m2 分别记录两个方向出现的单词是经过多少次转换而来\n         * e.g. \n         * m1 = {\"abc\":1} 代表 abc 由 beginWord 替换 1 次字符而来\n         * m2 = {\"xyz\":3} 代表 xyz 由 endWord 替换 3 次字符而来\n         */\n        Map<String, Integer> m1 = new HashMap<>(), m2 = new HashMap<>();\n        d1.add(s);\n        m1.put(s, 0);\n        d2.add(e);\n        m2.put(e, 0);\n        \n        /*\n         * 只有两个队列都不空,才有必要继续往下搜索\n         * 如果其中一个队列空了,说明从某个方向搜到底都搜不到该方向的目标节点\n         * e.g. \n         * 例如,如果 d1 为空了,说明从 beginWord 搜索到底都搜索不到 endWord,反向搜索也没必要进行了\n         */\n        while (!d1.isEmpty() && !d2.isEmpty()) {\n            int t = -1;\n            // 为了让两个方向的搜索尽可能平均,优先拓展队列内元素少的方向\n            if (d1.size() <= d2.size()) {\n                t = update(d1, m1, m2);\n            } else {\n                t = update(d2, m2, m1);\n            }\n            if (t != -1) return t;\n        }\n        return -1;\n    }\n\n    // update 代表从 deque 中取出一个单词进行扩展,\n    // cur 为当前方向的距离字典;other 为另外一个方向的距离字典\n    int update(Deque<String> deque, Map<String, Integer> cur, Map<String, Integer> other) {\n        int m = deque.size();\n        while (m-- > 0) {\n            // 获取当前需要扩展的原字符串\n            String poll = deque.pollFirst();\n            int n = poll.length();\n\n            // 枚举替换原字符串的哪个字符 i\n            for (int i = 0; i < n; i++) {\n                // 枚举将 i 替换成哪个小写字母\n                for (int j = 0; j < 26; j++) {\n                    // 替换后的字符串\n                    String sub = poll.substring(0, i) + String.valueOf((char)('a' + j)) + poll.substring(i + 1);\n                    if (set.contains(sub)) {\n                        // 如果该字符串在「当前方向」被记录过(拓展过),跳过即可\n                        if (cur.containsKey(sub) && cur.get(sub) <= cur.get(poll) + 1) continue;\n\n                        // 如果该字符串在「另一方向」出现过,说明找到了联通两个方向的最短路\n                        if (other.containsKey(sub)) {\n                            return cur.get(poll) + 1 + other.get(sub);\n                        } else {\n                            // 否则加入 deque 队列\n                            deque.addLast(sub);\n                            cur.put(sub, cur.get(poll) + 1);\n                        }\n                    }\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    string s, e;\n    unordered_set<string> wordSet;\n    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {\n        s = beginWord; e = endWord;\n        for (string w : wordList) wordSet.insert(w);\n        if (wordSet.find(e) == wordSet.end()) return 0;\n        int ans = bfs();\n        return ans == -1 ? 0 : ans + 1;\n    }\n    int bfs() {\n        deque<string> dq1, dq2;\n        unordered_map<string, int> m1, m2;\n        dq1.push_back(s);\n        m1[s] = 0;\n        dq2.push_back(e);\n        m2[e] = 0;\n        while (!dq1.empty() && !dq2.empty()) {\n            int t = -1;\n            if (dq1.size() <= dq2.size()) t = update(dq1, m1, m2);\n            else t = update(dq2, m2, m1);\n            if (t != -1) return t;\n        }\n        return -1;\n    }\n    int update(deque<string>& dq, unordered_map<string, int>& cur, unordered_map<string, int>& other) {\n        int m = dq.size();\n        while (m-- > 0) {\n            string poll = dq.front();\n            dq.pop_front();\n            int n = poll.length();\n            for (int i = 0; i < n; i++) {\n                for (int j = 0; j < 26; j++) {\n                    string sub = poll.substr(0, i) + static_cast<char>('a' + j) + poll.substr(i + 1);\n                    if (wordSet.find(sub) != wordSet.end()) {\n                        if (cur.find(sub) != cur.end() && cur[sub] <= cur[poll] + 1) continue;\n                        if (other.find(sub) != other.end()) {\n                            return cur[poll] + 1 + other[sub];\n                        } else {\n                            dq.push_back(sub);\n                            cur[sub] = cur[poll] + 1;\n                        }\n                    }\n                }\n            }\n        }\n        return -1;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:\n        def bfs():\n            dq1, dq2 = deque(), deque()\n            m1, m2 = {}, {}\n            dq1.append(s)\n            m1[s] = 0\n            dq2.append(e)\n            m2[e] = 0\n            while dq1 and dq2:\n                t = update(dq1, m1, m2) if len(dq1) <= len(dq2) else update(dq2, m2, m1)\n                if t != -1: return t\n            return -1\n\n        def update(dq, cur, other):\n            m = len(dq)\n            for _ in range(m):\n                poll = dq.popleft()\n                n = len(poll)\n                for i in range(n):\n                    for j in range(26):\n                        sub = poll[:i] + chr(ord('a') + j) + poll[i+1:]\n                        if sub in wordSet:\n                            if sub in cur and cur[sub] <= cur[poll] + 1: continue\n                            if sub in other:\n                                return cur[poll] + 1 + other[sub]\n                            else:\n                                dq.append(sub)\n                                cur[sub] = cur[poll] + 1\n            return -1\n\n        s, e = beginWord, endWord\n        wordSet = set(wordList)\n        if e not in wordSet: return 0\n        ans = bfs()\n        return 0 if ans == -1 else ans + 1\n```\n* 时间复杂度:令 `wordList` 长度为 $n$,`beginWord` 字符串长度为 $m$。由于所有的搜索结果必须都在 `wordList` 出现过,因此算上起点最多有 $n + 1$ 节点,最坏情况下,所有节点都联通,搜索完整张图复杂度为 $O(n^2)$ ;从 `beginWord` 出发进行字符替换,替换时进行逐字符检查,复杂度为 $O(m)$。整体复杂度为 $O(m \\times n^2)$\n* 空间复杂度:同等空间大小。$O(m \\times n^2)$\n\n---\n\n### 总结\n\n**这本质其实是一个「所有边权均为 `1`」最短路问题:将 `beginWord` 和所有在 `wordList` 出现过的字符串看做是一个点。每一次转换操作看作产生边权为 `1` 的边。问题求以 `beginWord` 为源点,以 `endWord` 为汇点的最短路径。**\n\n借助这个题,我向你介绍了「双向 BFS」,「双向 BFS」可以有效解决「搜索空间爆炸」问题。\n\n**对于那些搜索节点随着层数增加呈倍数或指数增长的搜索问题,可以使用「双向 BFS」进行求解。**\n\n---\n\n### 启发式搜索 `AStar`\n\n可以直接根据本题规则来设计 AStar 的「启发式函数」。\n\n比如对于两个字符串 `a` `b` 直接使用它们不同字符的数量来充当估值距离,我觉得是合适的。\n\n因为不同字符数量的差值可以确保不会超过真实距离(是一个理论最小替换次数)。\n\n注意:本题数据比较弱,用 AStar  过了,但通常我们需要「确保有解」,AStar  的启发搜索才会发挥真正价值。而本题,除非 `endWord` 本身就不在 `wordList` 中,其余情况我们无法很好提前判断「是否有解」。这时候 AStar  将不能带来「搜索空间的优化」,效果不如「双向 BFS」。\n\nJava 代码:\n```Java\nclass Solution {\n    class Node {\n        String str;\n        int val;\n        Node (String _str, int _val) {\n            str = _str;\n            val = _val;\n        }\n    }\n    String s, e;\n    int INF = 0x3f3f3f3f;\n    Set<String> set = new HashSet<>();\n    public int ladderLength(String beginWord, String endWord, List<String> wordList) {\n        s = beginWord; e = endWord;\n        for (String w : wordList) set.add(w);\n        if (!set.contains(e)) return 0;\n        int ans = astar();\n        return ans == -1 ? 0 : ans + 1;\n    }\n    int astar() {\n        PriorityQueue<Node> q = new PriorityQueue<>((a,b)->a.val-b.val);\n        Map<String, Integer> dist = new HashMap<>();\n        dist.put(s, 0);\n        q.add(new Node(s, f(s)));\n        \n        while (!q.isEmpty()) {\n            Node poll = q.poll();\n            String str = poll.str;\n            int distance = dist.get(str);\n            if (str.equals(e)) {\n                break;\n            }\n            int n = str.length();\n            for (int i = 0; i < n; i++) {\n                for (int j = 0; j < 26; j++) {\n                    String sub = str.substring(0, i) + String.valueOf((char)('a' + j)) + str.substring(i + 1);\n                    if (!set.contains(sub)) continue;\n                    if (!dist.containsKey(sub) || dist.get(sub) > distance + 1) {\n                        dist.put(sub, distance + 1);\n                        q.add(new Node(sub, dist.get(sub) + f(sub)));\n                    }\n                }\n            }\n        }\n        return dist.containsKey(e) ? dist.get(e) : -1;\n    }\n    int f(String str) {\n        if (str.length() != e.length()) return INF;\n        int n = str.length();\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            ans += str.charAt(i) == e.charAt(i) ? 0 : 1;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    struct Node {\n        string str;\n        int val;\n        Node(string _str, int _val) : str(_str), val(_val) {}\n    };\n\n    string s, e;\n    const int INF = 0x3f3f3f3f;\n    unordered_set<string> set;\n\n    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {\n        s = beginWord; e = endWord;\n        for (const string& w : wordList) set.insert(w);\n        if (set.find(e) == set.end()) return 0;\n        int ans = astar();\n        return ans == -1 ? 0 : ans + 1;\n    }\n    int astar() {\n        priority_queue<Node, vector<Node>, function<bool(Node, Node)>> q([](Node a, Node b) {\n            return a.val > b.val;\n        });\n        unordered_map<string, int> dist;\n        dist[s] = 0;\n        q.push(Node(s, f(s)));\n        while (!q.empty()) {\n            Node poll = q.top();\n            q.pop();\n            string str = poll.str;\n            int distance = dist[str];\n            if (str == e) break;\n            int n = str.length();\n            for (int i = 0; i < n; i++) {\n                for (int j = 0; j < 26; j++) {\n                    string sub = str.substr(0, i) + char('a' + j) + str.substr(i + 1);\n                    if (set.find(sub) == set.end()) continue;\n                    if (dist.find(sub) == dist.end() || dist[sub] > distance + 1) {\n                        dist[sub] = distance + 1;\n                        q.push(Node(sub, dist[sub] + f(sub)));\n                    }\n                }\n            }\n        }\n        return dist.find(e) != dist.end() ? dist[e] : -1;\n    }\n    int f(string str) {\n        if (str.length() != e.length()) return INF;\n        int n = str.length(), ans = 0;\n        for (int i = 0; i < n; i++) ans += str[i] == e[i] ? 0 : 1;\n        return ans;\n    }\n};\n```\n* 时间复杂度:启发式搜索分析时空复杂度意义不大\n* 空间复杂度:启发式搜索分析时空复杂度意义不大", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.127` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1211-1220/1217. 玩筹码（简单）.md", "url_title": "1217. 玩筹码", "url": "https://leetcode.cn/problems/minimum-cost-to-move-chips-to-the-same-position/solution/by-ac_oier-j6js/", "difficulty": "简单", "tags": ["贪心", "枚举"], "question": "有 `n` 个筹码。第 $i$ 个筹码的位置是 `position[i]`。\n\n我们需要把所有筹码移到同一个位置。在一步中,我们可以将第 $i$ 个筹码的位置从 $position[i]$ 改变为:\n\n* `position[i] + 2 或 position[i] - 2`,此时 `cost = 0`\n* `position[i] + 1 或 position[i] - 1`,此时 `cost = 1`\n\n返回将所有筹码移动到同一位置上所需要的 最小代价 。\n\n示例 1:\n\n```\n输入:position = [1,2,3]\n\n输出:1\n\n解释:第一步:将位置3的筹码移动到位置1,成本为0。\n第二步:将位置2的筹码移动到位置1,成本= 1。\n总成本是1。\n```\n示例 2:\n\n```\n输入:position = [2,2,2,3,3]\n\n输出:2\n\n解释:我们可以把位置3的两个筹码移到位置2。每一步的成本为1。总成本= 2。\n```\n示例 3:\n```\n输入:position = [1,1000000000]\n\n输出:1\n```\n\n提示:\n* $1 <= chips.length <= 100$\n* $1 <= chips[i] <= 10^9$", "solution": "### 贪心 + 枚举目标位置\n\n假设移动的目标位置是 $a$,当前所在位置是 $b$,将小球从 $b$ 移动到 $a$ 的成本取决于两位置距离的「奇偶性」,距离为偶数时成本固定为 $0$,距离为奇数时成本固定为 $1$。\n\n同时我们可以通过「分情况讨论」来证明,所有小球移动到一个全新位置(起始没有小球的位置),结果不会变好,假设所选择的最终(全新)位置为 $t$:\n\n* 假设选择的位置 $t$ 导致所有数到位置 $t$ 距离均为偶数,此时总成本为 $0$,同时可知所有数的位置奇偶性相同,此时选择所有数中的任意一个的位置,同样可得总成本为 $0$ 的结果,因此选全新的位置不会让结果变好;\n* 假设选择的位置 $t$ 导致所有数到位置 $t$ 距离均为奇数,此时总成本为 $n$,同时可知所有数的位置奇偶性相同,此时选择所有数中的任意一个的位置,可得总成本为 $0$ 的结果,因此选全新的位置会让结果变差;\n* 假设选择的位置 $t$ 导致所有数到位置 $t$ 距离奇数结果为 $c1$,偶数结果为 $c2$,可知 $n = c1 + c2$,同时我们通过调整 $t$ 的奇偶性来确保 $c1 <= c2$。此时总的成本为 $c1$,同时可知所有与 $t$ 距离为奇数的数所在位置奇偶性相同,所有与 $t$ 距离为偶数的数所在位置奇偶性也相同,此时将 $t$ 调整为与 $t$ 奇偶性相同的原有数的位置,同样能够得到总成本为 $c1$ 的结果,因此选全新的位置不会让结果变好。\n\n综上,我们可以枚举所有已有的位置为目标位置,并通过奇偶性统计其余位置到目标位置的成本,在所有已有位置中取最小的总成本即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int minCostToMoveChips(int[] ps) {\n        int n = ps.length, ans = Integer.MAX_VALUE;\n        for (int i = 0; i < n; i++) {\n            int a = ps[i], cur = 0;\n            for (int j = 0; j < n; j++) {\n                int b = ps[j];\n                cur += Math.abs(a - b) % 2;\n            }\n            ans = Math.min(ans, cur);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 贪心 + 统计奇偶性\n\n更进一步,我们可以发现要使得「总的移动成本最优」的目标位置有无数个,只要目标位置的奇偶性不变,即可确保总成本不变。\n\n因此我们可以省去枚举具体位置的操作,转而统计原有数的奇偶位置个数,假设偶数位置有 $a$ 个,奇数位置有 $b$ 个,最终目标位置选为偶数的成本为 $b$,最终目标位置选为奇数的成本为 $a$,即两者中的最小值即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int minCostToMoveChips(int[] ps) {\n        int n = ps.length, a = 0;\n        for (int i : ps) a += i % 2;\n        return Math.min(a, n - a);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1217` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1211-1220/1218. 最长定差子序列（中等）.md", "url_title": "1218. 最长定差子序列", "url": "https://leetcode-cn.com/problems/longest-arithmetic-subsequence-of-given-difference/solution/gong-shui-san-xie-jie-he-tan-xin-de-zhua-dj1k/", "difficulty": "中等", "tags": ["贪心", "序列 DP", "状态机 DP", "哈希表"], "question": "给你一个整数数组 `arr` 和一个整数 `difference`,请你找出并返回 `arr` 中最长等差子序列的长度,该子序列中相邻元素之间的差等于 `difference` 。\n\n子序列 是指在不改变其余元素顺序的情况下,通过删除一些元素或不删除任何元素而从 `arr` 派生出来的序列。\n\n示例 1:\n```\n输入:arr = [1,2,3,4], difference = 1\n\n输出:4\n\n解释:最长的等差子序列是 [1,2,3,4]。\n```\n示例 2:\n```\n输入:arr = [1,3,5,7], difference = 1\n\n输出:1\n\n解释:最长的等差子序列是任意单个元素。\n```\n示例 3:\n```\n输入:arr = [1,5,7,8,5,3,4,2,1], difference = -2\n\n输出:4\n\n解释:最长的等差子序列是 [7,5,3,1]。\n```\n\n提示:\n* $1 <= arr.length <= 10^5$\n* $-10^4 <= arr[i], difference <= 10^4$", "solution": "### 状态机序列 DP + 哈希表\n\n**定义 $f[i][j]$($j$ 非 $0$ 即 $1$) 为代表考虑前 $i$ 个数,且第 $i$ 个数的选择情况为 $j$ 时,得到的最长定差子序列长度。**\n\n最终答案为 $\\max(f[n - 1][0], f[n - 1][1])$,同时我们有显然的初始化条件 $f[0][0] = 0$ 和 $f[0][1] = 1$。\n\n不失一般性考虑 $f[i][j]$ 如何转移:\n\n* $f[i][0]$:明确了第 $i$ 个不选,那么此时最大长度为前一个位置的结果。即有:\n\n$$\nf[i][0] = \\max(f[i - 1][0], f[i - 1][1])\n$$\n\n* $f[i][1]$:明确了第 $i$ 个要选,此时进行分情况讨论:\n  \n    * $arr[i]$ 独立成为一个子序列,此时有:$f[i][1] = 1$;\n    * $arr[i]$ 接在某一个数的后面,由于给定了差值 $difference$,可直接算得上一位的值为 $prev = arr[i] - difference$,此时应当找到值为 $prev$,下标最大(下标小于 $i$)的位置,然后从该位置转移过来,即有:$f[i][1] = f[hash[prev]][1] + 1$;\n    \n    > 容易证明:如果存在多个位置的值为 $prev$,从中选择一个下标最大的位置(下标小于 $i$)进行转移,结果相比于最优位置不会变差。因此我们「贪心」选择下标最大的位置(下标小于 $i$)即可,这引导我们在转移过程中使用「哈希表」记录处理过的位置的值信息。\n\n    综上,我们有:\n\n$$\nf[i][1] = \\begin{cases}\n1 & hash[arr[i] - difference] = -1 \\\\\nf[hash[prev]][1] + 1 & hash[arr[i] - difference] \\neq -1\n\\end{cases}\n$$\n\n代码(使用数组充当哈希表的代码在 $P2$):\n```Java\nclass Solution {\n    public int longestSubsequence(int[] arr, int d) {\n        int n = arr.length;\n        Map<Integer, Integer> map = new HashMap<>();\n        int[][] f = new int[n][2];\n        f[0][1] = 1;\n        map.put(arr[0], 0);\n        for (int i = 1; i < n; i++) {\n            f[i][0] = Math.max(f[i - 1][0], f[i - 1][1]);\n            f[i][1] = 1;\n            int prev = arr[i] - d;\n            if (map.containsKey(prev)) f[i][1] = Math.max(f[i][1], f[map.get(prev)][1] + 1);\n            map.put(arr[i], i);\n        }\n        return Math.max(f[n - 1][0], f[n - 1][1]);\n    }\n}\n```\n\n```Java\nclass Solution {\n    int N = 40009, M = N / 2;\n    public int longestSubsequence(int[] arr, int d) {\n        int n = arr.length;\n        int[] hash = new int[N];\n        Arrays.fill(hash, -1);\n        int[][] f = new int[n][2];\n        f[0][1] = 1;\n        hash[arr[0] + M] = 0;\n        for (int i = 1; i < n; i++) {\n            f[i][0] = Math.max(f[i - 1][0], f[i - 1][1]);\n            f[i][1] = 1;\n            int prev = arr[i] - d;\n            if (hash[prev + M] != -1) f[i][1] = Math.max(f[i][1], f[hash[prev + M]][1] + 1);\n            hash[arr[i] + M] = i;\n        }\n        return Math.max(f[n - 1][0], f[n - 1][1]);\n    }\n}\n```\n* 时间复杂度:令 $n$ 为数组长度,共有 $n * 2$ 个状态需要被计算,每个状态转移的复杂度为 $O(1)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 优化状态定义\n\n不难发现,我们多定义一维状态来区分某个位置的值是否被选择,目的是为了正确转移出第 $i$ 位被选择的情况。\n\n事实上,利用哈希表本身我们就能轻松做到这一点。\n\n我们调整状态定义为:**$f[i]$ 为考虑前 $i$ 个数(第 $i$ 个数必选)时,得到的最长定差子序列长度。**\n\n不失一般性考虑 $f[i]$ 该如何转移,分情况讨论:\n\n* $arr[i]$ 独立成为一个子序列,此时有:$f[i] = 1$;\n* $arr[i]$ 接在某一个数的后面,由于给定了差值 $difference$,可直接算得上一位的值为 $prev = arr[i] - difference$,此时应当找到 $arr[j]$ 为 $prev$ 的最新位置(下标最大,同时满足 $j < i$)当时的转移结果,在此基础上加一即可,即有:$f[i] = hash[prev] + 1$;\n  \n\n综上,我们有($hash$ 初始化为 $0$):\n\n$$\nf[i] = hash[prev] + 1\n$$\n\n代码(使用数组充当哈希表的代码在 $P2$):\n```Java\nclass Solution {\n    public int longestSubsequence(int[] arr, int d) {\n        int ans = 1;\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i : arr) {\n            map.put(i, map.getOrDefault(i - d, 0) + 1);\n            ans = Math.max(ans, map.get(i));\n        }\n        return ans;\n    }\n}\n```\n\n```Java\nclass Solution {\n    int N = 40009, M = N / 2;\n    public int longestSubsequence(int[] arr, int d) {\n        int ans = 1;\n        int[] hash = new int[N];\n        for (int i : arr) {\n            hash[i + M] = hash[i - d + M] + 1;\n            ans = Math.max(ans, hash[i + M]);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为数组长度,共有 $n$ 个状态需要被计算,每个状态转移的复杂度为 $O(1)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1218` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1211-1220/1219. 黄金矿工（中等）.md", "url_title": "1219. 黄金矿工", "url": "https://leetcode-cn.com/problems/path-with-maximum-gold/solution/gong-shui-san-xie-hui-su-suan-fa-yun-yon-scxo/", "difficulty": "中等", "tags": ["图论搜索", "DFS", "回溯算法"], "question": "你要开发一座金矿,地质勘测学家已经探明了这座金矿中的资源分布,并用大小为 `m * n` 的网格 $grid$ 进行了标注。每个单元格中的整数就表示这一单元格中的黄金数量;如果该单元格是空的,那么就是 $0$。\n\n为了使收益最大化,矿工需要按以下规则来开采黄金:\n\n* 每当矿工进入一个单元,就会收集该单元格中的所有黄金。\n* 矿工每次可以从当前位置向上下左右四个方向走。\n* 每个单元格只能被开采(进入)一次。\n* 不得开采(进入)黄金数目为 $0$ 的单元格。\n* 矿工可以从网格中 **任意一个** 有黄金的单元格出发或者是停止。\n\n示例 1:\n```\n输入:grid = [[0,6,0],[5,8,7],[0,9,0]]\n\n输出:24\n\n解释:\n[[0,6,0],\n [5,8,7],\n [0,9,0]]\n一种收集最多黄金的路线是:9 -> 8 -> 7。\n```\n示例 2:\n```\n输入:grid = [[1,0,7],[2,0,6],[3,4,5],[0,3,0],[9,0,20]]\n\n输出:28\n\n解释:\n[[1,0,7],\n [2,0,6],\n [3,4,5],\n [0,3,0],\n [9,0,20]]\n一种收集最多黄金的路线是:1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7。\n```\n\n提示:\n* $1 <= grid.length, grid[i].length <= 15$\n* $0 <= grid[i][j] <= 100$\n* 最多 $254 个单元格中有黄金。", "solution": "### 回溯算法\n\n根据题意,我们可以枚举每个黄金点作为起点,然后使用 `DFS` 回溯搜索以该点作为起点所能得到的最大收益。\n\n代码:\n```Java\nclass Solution {\n    int[][] g;\n    boolean[][] vis;\n    int m, n;\n    int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n    public int getMaximumGold(int[][] grid) {\n        g = grid;\n        m = g.length; n = g[0].length;\n        vis = new boolean[m][n];\n        int ans = 0;\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (g[i][j] != 0) {\n                    vis[i][j] = true;\n                    ans = Math.max(ans, dfs(i, j));\n                    vis[i][j] = false;\n                }\n            }\n        }\n        return ans;\n    }\n    int dfs(int x, int y) {\n        int ans = g[x][y];\n        for (int[] d : dirs) {\n            int nx = x + d[0], ny = y + d[1];\n            if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;\n            if (g[nx][ny] == 0) continue;\n            if (vis[nx][ny]) continue;\n            vis[nx][ny] = true;\n            ans = Math.max(ans, g[x][y] + dfs(nx, ny));\n            vis[nx][ny] = false;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:爆搜复杂度为指数级别,分析时空复杂度意义不大\n* 空间复杂度:爆搜复杂度为指数级别,分析时空复杂度意义不大", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1219` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1211-1220/1220. 统计元音字母序列的数目（困难）.md", "url_title": "1220. 统计元音字母序列的数目", "url": "https://leetcode-cn.com/problems/count-vowels-permutation/solution/gong-shui-san-xie-yi-ti-shuang-jie-xian-n8f4o/", "difficulty": "困难", "tags": ["线性 DP", "矩阵快速幂"], "question": "给你一个整数 `n`,请你帮忙统计一下我们可以按下述规则形成多少个长度为 `n` 的字符串:\n\n字符串中的每个字符都应当是小写元音字母('a', 'e', 'i', 'o', 'u')\n* 每个元音 `'a'` 后面都只能跟着 `'e'`\n* 每个元音 `'e'` 后面只能跟着 `'a'` 或者是 `'i'`\n* 每个元音 `'i'` 后面 不能 再跟着另一个 `'i'`\n* 每个元音 `'o'` 后面只能跟着 `'i'` 或者是 `'u'`\n* 每个元音 `'u'` 后面只能跟着 `'a'`\n\n由于答案可能会很大,所以请你返回 模 $10^9 + 7$ 之后的结果。\n\n示例 1:\n```\n输入:n = 1\n\n输出:5\n\n解释:所有可能的字符串分别是:\"a\", \"e\", \"i\" , \"o\" 和 \"u\"。\n```\n示例 2:\n```\n输入:n = 2\n\n输出:10\n\n解释:所有可能的字符串分别是:\"ae\", \"ea\", \"ei\", \"ia\", \"ie\", \"io\", \"iu\", \"oi\", \"ou\" 和 \"ua\"。\n```\n示例 3:\n```\n输入:n = 5\n\n输出:68\n```\n\n提示:\n* $1 <= n <= 2 * 10^4$", "solution": "### 线性 DP\n\n**定义 $f[i][j]$ 为考虑长度为 $i + 1$ 的字符串,且结尾元素为 $j$ 的方案数(其中 $j$ 代表数组 `['a', 'e', 'i', 'o', 'u']` 下标)。**\n\n不失一般性考虑 $f[i][j]$ 该如何计算。\n\n**我们可以从题意给定的规则进行出发,从 $f[i]$ 出发往前更新 $f[i + 1]$,也可以直接利用对称性进行反向分析。**\n\n为了方便大家理解,还是将常规的「从 $f[i]$ 出发往前更新 $f[i + 1]$」作为主要分析方法吧。\n\n根据条件可以容易写出转移方程:\n\n* 每个元音 `'a'` 后面都只能跟着 `'e'` :$f[i + 1][1] += f[i][0]$;\n* 每个元音 `'e'` 后面只能跟着 `'a'` 或者是 `'i'` :$f[i + 1][0] += f[i][1]$、$f[i + 1][2] += f[i][1]$;\n* 每个元音 `'i'` 后面 不能 再跟着另一个 `'i'` :$f[i + 1][j] += f[i][2], (j 不能为 2)$;\n* 每个元音 `'o'` 后面只能跟着 `'i'` 或者是 `'u'` :$f[i + 1][2] += f[i][3]$、$f[i + 1][4] += f[i][3]$;\n* 每个元音 `'u'` 后面只能跟着 `'a'` :$f[i + 1][0] += f[i][4]$。\n\n**代码(利用对称性统计方案数代码见 $P2$,感谢 [@Benhao](/u/himymben/) 和 [@5cm/s 🌸](/u/megurine/) 提供的、我根本看不懂的、试图把困难题也做成「全鱼宴」题解的代码 🤣 ):**\n```Java \nclass Solution {\n    int MOD = (int)1e9+7;\n    public int countVowelPermutation(int n) {\n        long[][] f = new long[n][5];\n        Arrays.fill(f[0], 1);\n        for (int i = 0; i < n - 1; i++) {\n            // 每个元音 'a' 后面都只能跟着 'e'\n            f[i + 1][1] += f[i][0]; \n            // 每个元音 'e' 后面只能跟着 'a' 或者是 'i'\n            f[i + 1][0] += f[i][1];\n            f[i + 1][2] += f[i][1];\n            // 每个元音 'i' 后面 不能 再跟着另一个 'i'\n            f[i + 1][0] += f[i][2];\n            f[i + 1][1] += f[i][2];\n            f[i + 1][3] += f[i][2];\n            f[i + 1][4] += f[i][2];\n            // 每个元音 'o' 后面只能跟着 'i' 或者是 'u'\n            f[i + 1][2] += f[i][3];\n            f[i + 1][4] += f[i][3];\n            // 每个元音 'u' 后面只能跟着 'a'\n            f[i + 1][0] += f[i][4];\n            for (int j = 0; j < 5; j++) f[i + 1][j] %= MOD;\n        }\n        long ans = 0;\n        for (int i = 0; i < 5; i++) ans += f[n - 1][i];\n        return (int)(ans % MOD);\n    }\n}\n```\n-\n```Java\nclass Solution {\n    int MOD = (int)1e9+7;\n    public int countVowelPermutation(int n) {\n        long[][] f = new long[n][5];\n        Arrays.fill(f[0], 1);\n        for (int i = 1; i < n; i++) {\n            f[i][0] = f[i - 1][1];\n            f[i][1] = f[i - 1][0] + f[i - 1][2];\n            f[i][2] = f[i - 1][0] + f[i - 1][1] + f[i - 1][3] + f[i - 1][4];\n            f[i][3] = f[i - 1][2] + f[i - 1][4];\n            f[i][4] = f[i - 1][0];\n            for (int j = 0; j < 5; j++) f[i][j] %= MOD;\n        }\n        long ans = 0;\n        for (int i = 0; i < 5; i++) ans += f[n - 1][i];\n        return (int)(ans % MOD);\n    }\n}\n```\n-\n\n```Python\nMOD = int(1e9) + 7\nclass Solution:\n    def countVowelPermutation(self, n: int) -> int:\n        f = [[1] * 5] + [[0] * 5 for _ in range(n - 1)]\n        for i in range(1, n):\n            f[i][0] = f[i-1][1]\n            f[i][1] = (f[i-1][0] + f[i-1][2]) % MOD\n            f[i][2] = ((((f[i-1][0] + f[i-1][1]) % MOD + f[i-1][3]) % MOD) + f[i-1][4]) % MOD\n            f[i][3] = (f[i-1][2] + f[i-1][4]) % MOD\n            f[i][4] = f[i-1][0]\n        return (((((f[-1][0] + f[-1][1]) % MOD + f[-1][2]) % MOD + f[-1][3]) % MOD) + f[-1][4]) % MOD\n```\n-\n\n```Go\nconst MOD int = 1e9 + 7\nfunc countVowelPermutation(n int) int {\n    f := make([][]int, n)\n    f[0] = []int{1, 1, 1, 1, 1}\n    for i := 1; i < n; i++ {\n        f[i] = make([]int, 5) \n        f[i][0] = f[i-1][1]\n        f[i][1] = (f[i-1][0] + f[i-1][2]) % MOD\n        f[i][2] = (((f[i-1][0] + f[i-1][1]) % MOD + f[i-1][3]) % MOD + f[i-1][4]) % MOD\n        f[i][3] = (f[i-1][2] + f[i-1][4]) % MOD\n        f[i][4] = f[i-1][0]\n    }\n    return ((((f[n-1][0] + f[n-1][1]) % MOD + f[n-1][2]) % MOD + f[n-1][3]) % MOD + f[n-1][4]) % MOD\n}\n```\n-\n```Elixir\ndefmodule Solution do\n  @spec count_vowel_permutation(n :: integer) :: integer\n  def count_vowel_permutation(n) do\n    solve(n, 1, 1, 1, 1, 1)\n  end\n  def solve(1, a, e, i, o, u) do\n    rem((a + e + i + o + u), 1000000007)\n  end\n  def solve(n, a, e, i, o, u) do\n    solve(n - 1, add(e, i, u), add(a, i), add(e, o), i, add(i, o))\n  end\n  def add(n1, n2) do\n    add(n1, n2, 0)\n  end\n  def add(n1, n2, n3) do\n    rem(n1 + n2 + n3, 1000000007)\n  end\nend\n```\n-\n```Erlang\n-spec count_vowel_permutation(N :: integer()) -> integer().\ncount_vowel_permutation(N) ->\n  solve(N, 1, 1, 1, 1, 1).\n\nsolve(1, A, E, I, O, U) ->\n  (A + E + I + O + U) rem 1000000007;\nsolve(N, A, E, I, O, U) ->\n  solve(N - 1, add(E, I, U), add(A, I), add(E, O), I, add(I, O)).\nadd(N1, N2) ->\n  add(N1, N2, 0).\nadd(N1, N2, N3) ->\n  (N1 + N2 + N3) rem 1000000007.\n```\n-\n```Racket\n(define/contract (count-vowel-permutation n)\n  (-> exact-integer? exact-integer?)\n    (define MOD 1000000007)\n    (define (ad nums [tot 0])\n      (cond\n        [(empty? nums) (remainder tot MOD)]\n        [else (ad (cdr nums) (+ tot (car nums)))]\n      )\n    )\n    (let loop([n n] [a 1] [e 1] [i 1] [o 1] [u 1])\n      (cond\n        [(= n 1) (ad (list a e i o u))]\n        [else (loop (- n 1) (ad (list e i u)) (ad (list a i)) (ad (list e o)) i (ad (list i o)))]\n      )\n    )\n    )\n```\n-\n```JS\nconst MOD = 10 ** 9 + 7;\nconst add = (...nums) => nums.reduce((a, b) => a + b) % MOD\nvar countVowelPermutation = function(n,a=1,e=1,i=1,o=1,u=1) {\n    return n === 1 \n        ? add(a, e, i, o, u)\n        : countVowelPermutation(n - 1, add(e, i, u), add(a, i), add(e, o), i, add(i, o))\n};\n```\n-\n```JS\nconst MOD = 10 ** 9 + 7;\nconst add = (...nums) => nums.reduce((a, b) => a + b) % MOD\nvar countVowelPermutation = function(n) {\n    let [a, e, i, o, u] = [1, 1, 1, 1, 1]\n    while(--n)\n        ([a, e, i, o, u] = [add(e, i, u), add(a + i), add(e + o), i, add(i, o)])\n    return add(a, e, i, o, u)\n};\n```\n* 时间复杂度:令 $C$ 为字符集大小,本题 $C$ 固定为 $5$。整体复杂度为 $O(n * C)$\n* 空间复杂度:$O(n * C)$\n\n---\n\n### 矩阵快速幂\n\n**通常考虑递推能否使用「矩阵快速幂」来加速,主要依据为该递推过程是否为存在「结合律」线性递推过程。**\n\n如果是存在「结合律」的线性数列递推,诸如「斐波那契数列」等,都能使用「矩阵快速幂」来加速数列递推。\n\n对「矩阵快速幂」不了解的同学,可以先看「矩阵快速幂の三部曲」(学过三部曲的同学做这道题应该是降维打击):\n\n1. [简单题学「矩阵快速幂」](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488198&idx=1&sn=8272ca6b0ef6530413da4a270abb68bc&chksm=fd9cb9d9caeb30cf6c2defab0f5204adc158969d64418916e306f6bf50ae0c38518d4e4ba146&token=684485087&lang=zh_CN#rd)\n2. [简单题学「矩阵快速幂」II](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488373&idx=1&sn=2845f7d6966658f1bb82e1dfb086dfad&chksm=fd9cb86acaeb317c3cba3aea9e63ae728749b74482494448151643bedb783d6597d7c640774b&token=684485087&lang=zh_CN#rd) \n3. [矩阵快速幂的运用 :从「状态机 DP」到「矩阵快速幂」](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488607&idx=1&sn=060d3e6c34344e05218f81878651fe02&chksm=fd9cbf40caeb3656f9308ea0190fac700801838356e63196c3b1b3459a5f01c646e7e9abe2fd&token=684485087&lang=zh_CN#rd) \n\n我们最终需要求的是 $\\sum_{i = 0}^{4} f[n - 1][i]$,将需要求得的部分列成列向量:\n\n$$\nans = \\begin{bmatrix}\nf[n - 1][0]\\\\ \nf[n - 1][1]\\\\\nf[n - 1][2]\\\\\nf[n - 1][3]\\\\\nf[n - 1][4]\n\\end{bmatrix}\n$$\n\n同时我们有起始的矩阵(每个元音字母独立成为一个字符):\n\n$$\nori = \n\\begin{bmatrix}\nf[0][0]\\\\ \nf[0][1]\\\\\nf[0][2]\\\\\nf[0][3]\\\\\nf[0][4]\n\\end{bmatrix} = \\begin{bmatrix}\n1\\\\ \n1\\\\\n1\\\\\n1\\\\\n1\n\\end{bmatrix}\n$$\n\n我们知道 $f[i][X]$ 依赖于 $f[i - 1][X]$,同时在「解法一」中明确了各个 $f[i][j]$ 与 $f[i - 1][X]$ 的关系。\n\n根据「矩阵乘法」,不难发现:\n\n$$\n\\begin{bmatrix}\nf[i][0]\\\\ \nf[i][1]\\\\\nf[i][2]\\\\\nf[i][3]\\\\\nf[i][4]\n\\end{bmatrix} = \n\\begin{bmatrix}\n0& 1& 0& 0& 0\\\\ \n1& 0& 1& 0& 0\\\\\n1& 1& 0& 1& 1\\\\\n0& 0& 1& 0& 1\\\\\n1& 0& 0& 0& 0\n\\end{bmatrix}\n*\n\\begin{bmatrix}\nf[i - 1][0]\\\\ \nf[i - 1][1]\\\\\nf[i - 1][2]\\\\\nf[i - 1][3]\\\\\nf[i - 1][4]\n\\end{bmatrix}\n$$\n\n我们令:\n$$\nmat = \\begin{bmatrix}\n0& 1& 0& 0& 0\\\\ \n1& 0& 1& 0& 0\\\\\n1& 1& 0& 1& 1\\\\\n0& 0& 1& 0& 1\\\\\n1& 0& 0& 0& 0\n\\end{bmatrix}\n$$\n\n根据递推关系,可得:\n\n$$\nans = mat * mat * ... * mat * ori\n$$\n\n再根据矩阵乘法具有「结合律」,最终可得:\n\n$$\nans = mat^{n - 1} * ori\n$$\n\n**代码(感谢 [@Benhao](/u/himymben/) 同学提供的「行向量」写法):**\n```Java\nclass Solution {\n    int MOD = (int)1e9+7;\n    long[][] mul(long[][] a, long[][] b) {\n        int r = a.length, c = b[0].length, z = b.length;\n        long[][] ans = new long[r][c];\n        for (int i = 0; i < r; i++) {\n            for (int j = 0; j < c; j++) {\n                for (int k = 0; k < z; k++) {\n                    ans[i][j] += a[i][k] * b[k][j];\n                    ans[i][j] %= MOD;\n                }\n            }\n        }\n        return ans;\n    }\n    public int countVowelPermutation(int n) {\n        long[][] ans = new long[][]{\n            {1}, {1}, {1}, {1}, {1}\n        };\n        long[][] mat = new long[][]{\n            {0, 1, 0, 0, 0},\n            {1, 0, 1, 0, 0},\n            {1, 1, 0, 1, 1},\n            {0, 0, 1, 0, 1},\n            {1, 0, 0, 0, 0},\n        };\n        int x = n - 1;\n        while (x != 0) {\n            if ((x & 1) != 0) ans = mul(mat, ans);\n            mat = mul(mat, mat);\n            x >>= 1;\n        }\n        long sum = 0;\n        for (int i = 0; i < 5; i++) sum += ans[i][0];\n        return (int)(sum % MOD);\n    }\n}\n```\n-\n```python\nimport numpy as np\nMOD = 10 ** 9 + 7\ndtype = np.dtype('uint64')\nclass Solution:\n    def countVowelPermutation(self, n: int) -> int:\n        ans, mat = np.ones(5, dtype=dtype), np.array([[0, 1, 1, 0, 1], [1, 0, 1, 0, 0], [0, 1, 0, 1, 0], [0, 0, 1, 0, 0], [0, 0, 1, 1, 0]],dtype=dtype)\n        n -= 1\n        while n:\n            if n & 1:\n                ans = ans @ mat % MOD\n            mat = mat @ mat % MOD\n            n >>= 1\n        return int(ans.sum()) % MOD\n```\n-\n```Go\nconst MOD int = 1e9 + 7\n\nfunc countVowelPermutation(n int) (res int) {\n    mul := func(X, Y [][]int) [][]int{\n        res := make([][]int, len(X))\n        for i := 0;i < len(res);i++{res[i] = make([]int, len(Y[0]))}\n        for i := 0;i < len(res);i++{\n            for j := 0;j < len(res[0]);j++{\n                for k := 0;k < len(Y);k++{\n                    res[i][j] = (res[i][j] + X[i][k] * Y[k][j] % MOD) % MOD\n                }\n            }\n        }\n        return res\n    }\n\n    ans, mat := [][]int{{1, 1, 1, 1, 1}}, [][]int{{0, 1, 1, 0, 1}, {1, 0, 1, 0, 0}, {0, 1, 0, 1, 0}, {0, 0, 1, 0, 0}, {0, 0, 1, 1, 0}}\n    n--\n    for n > 0 {\n        if(n & 1 != 0){\n            tmp := mul(ans, mat)\n            ans = tmp\n        }\n        tmpMat := mul(mat, mat)\n        mat = tmpMat\n        n >>= 1\n    }\n    for _, row := range ans {\n        for _, cell := range row{\n            res = (res + cell) % MOD\n        }\n    }\n    return\n}\n```\n* 时间复杂度:共需要执行 $\\log{n}$ 次矩阵操作,运算量最大的矩阵操作为 $mat * mat$,复杂度为 $C^3$。整体复杂度为 $O(\\log{n} * C^3)$\n* 空间复杂度:复杂度上界为 $mat$ 大小,复杂度为 $O(C^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1220` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1221-1230/1129. 颜色交替的最短路径（中等）.md", "url_title": "1129. 颜色交替的最短路径", "url": null, "difficulty": "中等", "tags": ["BFS", "最短路"], "question": "在一个有向图中,节点分别标记为 `0, 1, ..., n-1`。\n\n图中每条边为红色或者蓝色,且存在自环或平行边。\n\n`red_edges` 中的每一个 `[i, j]` 对表示从节点 `i` 到节点 `j` 的红色有向边。\n\n类似地,`blue_edges` 中的每一个 `[i, j]` 对表示从节点 `i` 到节点 `j` 的蓝色有向边。\n\n返回长度为 `n` 的数组 `answer`,其中 `answer[X]` 是从节点 `0` 到节点 `X` 的红色边和蓝色边交替出现的最短路径的长度。\n\n如果不存在这样的路径,那么 `answer[x] = -1`。\n\n示例 1:\n```\n输入:n = 3, red_edges = [[0,1],[1,2]], blue_edges = []\n\n输出:[0,1,-1]\n```\n示例 2:\n```\n输入:n = 3, red_edges = [[0,1]], blue_edges = [[2,1]]\n\n输出:[0,1,-1]\n```\n示例 3:\n```\n输入:n = 3, red_edges = [[1,0]], blue_edges = [[2,1]]\n\n输出:[0,-1,-1]\n```\n示例 4:\n```\n输入:n = 3, red_edges = [[0,1]], blue_edges = [[1,2]]\n\n输出:[0,1,2]\n```\n示例 5:\n```\n输入:n = 3, red_edges = [[0,1],[0,2]], blue_edges = [[1,0]]\n\n输出:[0,1,1]\n```\n\n提示:\n* `1 <= n <= 100`\n* `red_edges.length <= 400`\n* `blue_edges.length <= 400`\n* `red_edges[i].length = blue_edges[i].length = 2`\n* `0 <= red_edges[i][j], blue_edges[i][j] < n`", "solution": "### 朴素 BFS\n\n为了方便,将 `redEdges` 记为 `rs`,将 `blueEdges` 记为 `bs`。\n\n使用两数组进行建图,利用点数和边数关系(稀疏图),使用「邻接表」方式进行建图。\n\n将所有红色有向边权值记为 `1`,将所有蓝色有向边权值记为 `-1`。注意这里的权重仅表示该边的颜色,并非代表经过该边的真实成本。\n\n也正是经过所有边的成本均相同,对于原问题「从 `0` 号节点进行出发,求到所有点的颜色交替的最短路径」,我们容易想到使用 `BFS`  进行求解。\n\n`BFS`  过程中将三元组 $(point, last, step)$ 进行入队:\n\n* `point` 代表当前所在点编号\n* `last` 代表到达 `point` 所使用的边的颜色,默认为 `0` 代表不需要经过任何边到达起点\n* `step` 代表到达 `point` 所使用的步数\n\n利用数据范围不大(点数为 $100$,边数为 $800$),可以直接对每个点进行一次独立的 `BFS`  来求最短路。由于图存在重边和自环,因此在求解最短路的过程需要对边进行去重。\n\nJava 代码:\n```Java\nclass Solution {\n    static int N = 110, M = 810, idx = 0;\n    static int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        w[idx] = c;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    public int[] shortestAlternatingPaths(int n, int[][] rs, int[][] bs) {\n        idx = 0;\n        Arrays.fill(he, -1);\n        for (int[] e : rs) add(e[0], e[1], 1);\n        for (int[] e : bs) add(e[0], e[1], -1);\n        int[] ans = new int[n];\n        boolean[] vis = new boolean[rs.length + bs.length];\n        out:for (int k = 1; k < n; k++) {\n            ans[k] = -1;\n            Arrays.fill(vis, false);\n            Deque<int[]> d = new ArrayDeque<>();\n            d.addLast(new int[]{0, 0, 0}); // point, last, step\n            while (!d.isEmpty()) {\n                int[] info = d.pollFirst();\n                int p = info[0], last = info[1], step = info[2];\n                for (int i = he[p]; i != -1; i = ne[i]) {\n                    int j = e[i], c = w[i];\n                    if (vis[i]) continue;\n                    if (c + last == 0 || last == 0) {\n                        if (j == k) {\n                            ans[k] = step + 1;\n                            continue out;\n                        } else {\n                            d.addLast(new int[]{j, c, step + 1});\n                            vis[i] = true;\n                        }\n                    }\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int he[110], e[810], ne[810], w[810], idx = 0;\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        w[idx] = c;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& rs, vector<vector<int>>& bs) {\n        idx = 0;\n        fill(he, he + n, -1);\n        for (auto& e : rs) add(e[0], e[1], 1);\n        for (auto& e : bs) add(e[0], e[1], -1);\n        vector<int> ans(n);\n        vector<bool> vis(rs.size() + bs.size());\n        for (int k = 1; k < n; k++) {\n            ans[k] = -1;\n            fill(vis.begin(), vis.end(), false);\n            queue<vector<int>> q;\n            q.push({ 0, 0, 0 }); // point, last, step\n            bool out = false;\n            while (!q.empty()) {\n                if (out) break;\n                vector<int> info = q.front(); q.pop();\n                int p = info[0], last = info[1], step = info[2];\n                for (int i = he[p]; i != -1; i = ne[i]) {\n                    int j = e[i], c = w[i];\n                    if (vis[i]) continue;\n                    if (c + last == 0 || last == 0) {\n                        if (j == k) {\n                            ans[k] = step + 1;\n                            out = true;\n                            break;\n                        } else {\n                            q.push({ j, c, step + 1 });\n                            vis[i] = true;\n                        }\n                    }\n                }\n            }\n        }\n        return ans;\n    }\n};\n```\n* 时间复杂度:将点数记为 `n` ,边数记为 `m`。建图复杂度为 $O(m)$;构造答案复杂度为 $O(n \\times (n + m))$。整体复杂度为 $O(n \\times (n + m))$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### 优化\n\n实际上,我们并没有对每个点进行独立 `BFS`  的必要。\n\n为了获取所有从节点 `0` 出发的最短路,可直接从节点 `0` 进行出发(对边进行去重),所有能够从节点 `0` 沿交替路径到达的节点必然都会被访问到,且节点首次被访问到时必然是最短路径。\n\n因此我们只需要初始化所有的 `ans[i] = -1`,并从节点 `0` 开始进行一次 `BFS`  即可。\n\nJava 代码:\n```Java\nclass Solution {\n    static int N = 110, M = 810, idx = 0;\n    static int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        w[idx] = c;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    public int[] shortestAlternatingPaths(int n, int[][] rs, int[][] bs) {\n        idx = 0;\n        Arrays.fill(he, -1);\n        for (int[] e : rs) add(e[0], e[1], 1);\n        for (int[] e : bs) add(e[0], e[1], -1);\n        int[] ans = new int[n];\n        Arrays.fill(ans, -1);\n        ans[0] = 0;\n        boolean[] vis = new boolean[rs.length + bs.length];\n        Arrays.fill(vis, false);\n        Deque<int[]> d = new ArrayDeque<>();\n        d.addLast(new int[]{0, 0, 0}); // point, last, step\n        while (!d.isEmpty()) {\n            int[] info = d.pollFirst();\n            int p = info[0], last = info[1], step = info[2];\n            for (int i = he[p]; i != -1; i = ne[i]) {\n                if (vis[i]) continue;\n                int j = e[i], c = w[i];\n                if (c + last == 0 || last == 0) {\n                    ans[j] = ans[j] == -1 ? step + 1 : Math.min(ans[j], step + 1);\n                    d.addLast(new int[]{j, c, step + 1});\n                    vis[i] = true;\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int he[110], e[810], ne[810], w[810], idx = 0;\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        w[idx] = c;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& rs, vector<vector<int>>& bs) {\n        idx = 0;\n        fill(he, he + n, -1);\n        for (auto& e : rs) add(e[0], e[1], 1);\n        for (auto& e : bs) add(e[0], e[1], -1);\n        vector<int> ans(n, -1);\n        ans[0] = 0;\n        vector<bool> vis(rs.size() + bs.size(), false);\n        deque<vector<int>> d;\n        d.push_back({0, 0, 0}); // point, last, step\n        while (!d.empty()) {\n            vector<int> info = d.front();\n            d.pop_front();\n            int p = info[0], last = info[1], step = info[2];\n            for (int i = he[p]; i != -1; i = ne[i]) {\n                if (vis[i]) continue;\n                int j = e[i], c = w[i];\n                if (c + last == 0 || last == 0) {\n                    ans[j] = ans[j] == -1 ? step + 1 : min(ans[j], step + 1);\n                    d.push_back({j, c, step + 1});\n                    vis[i] = true;\n                }\n            }\n        }\n        return ans;\n    }\n};\n```\n* 时间复杂度:将点数记为 `n` ,边数记为 `m`。建图复杂度为 $O(m)$;构造答案复杂度为 $O(n + m)$。整体复杂度为 $O(n + m)$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1129` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1221-1230/1221. 分割平衡字符串（简单）.md", "url_title": "1221. 分割平衡字符串", "url": "https://leetcode-cn.com/problems/split-a-string-in-balanced-strings/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-wumnk/", "difficulty": "简单", "tags": ["贪心", "双指针"], "question": "在一个 平衡字符串 中,'L' 和 'R' 字符的数量是相同的。\n\n给你一个平衡字符串 s,请你将它分割成尽可能多的平衡字符串。\n\n注意:分割得到的每个字符串都必须是平衡字符串。\n\n返回可以通过分割得到的平衡字符串的 最大数量 。\n\n示例 1:\n```\n输入:s = \"RLRRLLRLRL\"\n\n输出:4\n\n解释:s 可以分割为 \"RL\"、\"RRLL\"、\"RL\"、\"RL\" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。\n```\n示例 2:\n```\n输入:s = \"RLLLLRRRLR\"\n\n输出:3\n\n解释:s 可以分割为 \"RL\"、\"LLLRRR\"、\"LR\" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。\n```\n示例 3:\n```\n输入:s = \"LLLLRRRR\"\n\n输出:1\n\n解释:s 只能保持原样 \"LLLLRRRR\".\n```\n示例 4:\n```\n输入:s = \"RLRRRLLRLL\"\n\n输出:2\n\n解释:s 可以分割为 \"RL\"、\"RRRLLRLL\" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。\n```\n\n提示:\n* 1 <= s.length <= 1000\n* s[i] = 'L' 或 'R'\n* s 是一个 平衡 字符串", "solution": "### 基本分析\n\n题目确保了 `s` 为一个平衡字符串,即必然能分割成若干个 `LR` 子串。\n\n一个合法的 `LR` 子串满足 `L` 字符和 `R` 字符数量相等,常规检查一个字符串是否为合格的 `LR` 子串可以使用 $O(n)$ 的遍历方式,可以使用记录前缀信息的数据结构,而对于成对结构的元素统计,更好的方式是转换为数学判定,使用 `1` 来代指 `L` 得分,使用 `-1` 来代指 `R` 得分。\n\n那么一个子串为合格 `LR` 子串的充要条件为 **整个 `LR` 子串的总得分为 $0$**。\n\n这种方式最早应该在 [(题解) 301. 删除无效的括号](https://leetcode-cn.com/problems/remove-invalid-parentheses/solution/yi-fen-zhong-nei-kan-dong-jiang-gua-hao-aya6k/) 详细讲过,可延伸到任意的成对结构元素统计题目里去。\n\n---\n\n### 贪心\n\n回到本题,题目要求分割的 `LR` 子串尽可能多,直观上应该是尽可能让每个分割串尽可能短。\n\n**我们使用「归纳法」来证明该猜想的正确性。**\n\n首先题目数据保证给定的 `s` 本身是合法的 `LR` 子串,假设从 $[0...a]$ 可以从 `s` 中分割出 **长度最小** 的 `LR` 子串,而从 $[0...b]$ 能够分割出 **长度更大** 的 `LR` 子串(即 `a <= b` )。\n\n**我们来证明起始时(第一次分割)「将从 `b` 分割点将 `s` 断开」调整为「从 `a` 分割点将 `s` 断开」结果不会变差:**\n\n1. 从 `b` 点首次分割调整为从 `a` 点首次分割,两种分割形式分割点两端仍为合法 `LR` 子串,因此不会从“有解”变成“无解”;\n\n2. 从 `b` 分割后的剩余部分长度小于从 `a` 分割后的剩余部分,同时由 `b` 分割后的剩余部分会被由 `a` 分割后的剩余部分所严格覆盖,因此「对 `a` 分割的剩余部分再分割所得的子串数量」**至少** 与「从 `b` 点分割的剩余部分再分割所得的子串数量」相等(不会变少)。\n\n**至此,我们证明了对于首次分割,将任意合格分割点调整为最小分割点,结果不会变得更差(当 `a < b` 时还会更好)。**\n\n**同时,由于首次分割后的剩余部分仍为合格的 `LR` 子串,因此归纳分析所依赖的结构没有发生改变,可以将上述的推理分析推广到每一个决策的回合(新边界)中。**\n\n**至此,我们证明了只要每一次都从最小分割点进行分割,就可以得到最优解。**\n\n代码:\n```Java\nclass Solution {\n    public int balancedStringSplit(String s) {\n        char[] cs = s.toCharArray();\n        int n = cs.length;\n        int ans = 0;\n        for (int i = 0; i < n; ) {\n            int j = i + 1, score = cs[i] == 'L' ? 1 : -1;\n            while (j < n && score != 0) score += cs[j++] == 'L' ? 1 : -1;\n            i = j;\n            ans++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:调用 `toCharArray` 会拷贝新数组进行返回(为遵循 `String` 的不可变原则),因此使用 `toCharArray` 复杂度为 $O(n)$,使用 `charAt` 复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1221` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1221-1230/1222. 可以攻击国王的皇后（中等）.md", "url_title": "1222. 可以攻击国王的皇后", "url": "https://leetcode.cn/problems/queens-that-can-attack-the-king/solution/gong-shui-san-xie-chang-gui-mo-ni-ti-by-hlgkx/", "difficulty": "中等", "tags": ["模拟", "BFS"], "question": "在一个 `8x8` 的棋盘上,放置着若干「黑皇后」和一个「白国王」。\n\n给定一个由整数坐标组成的数组 `queens`,表示黑皇后的位置;以及一对坐标 `king`,表示白国王的位置,返回所有可以攻击国王的皇后的坐标(任意顺序)。\n\n示例 1:\n\n```\n输入:queens = [[0,1],[1,0],[4,0],[0,4],[3,3],[2,4]], king = [0,0]\n\n输出:[[0,1],[1,0],[3,3]]\n\n解释: \n[0,1] 的皇后可以攻击到国王,因为他们在同一行上。 \n[1,0] 的皇后可以攻击到国王,因为他们在同一列上。 \n[3,3] 的皇后可以攻击到国王,因为他们在同一条对角线上。 \n[0,4] 的皇后无法攻击到国王,因为她被位于 [0,1] 的皇后挡住了。 \n[4,0] 的皇后无法攻击到国王,因为她被位于 [1,0] 的皇后挡住了。 \n[2,4] 的皇后无法攻击到国王,因为她和国王不在同一行/列/对角线上。\n```\n示例 2:\n\n```\n输入:queens = [[0,0],[1,1],[2,2],[3,4],[3,5],[4,4],[4,5]], king = [3,3]\n\n输出:[[2,2],[3,4],[4,4]]\n```\n示例 3:\n\n```\n输入:queens = [[5,6],[7,7],[2,1],[0,7],[1,6],[5,1],[3,7],[0,3],[4,0],[1,2],[6,3],[5,0],[0,4],[2,2],[1,1],[6,4],[5,4],[0,0],[2,6],[4,5],[5,2],[1,4],[7,5],[2,3],[0,5],[4,2],[1,0],[2,7],[0,1],[4,6],[6,1],[0,6],[4,3],[1,7]], king = [3,4]\n\n输出:[[2,3],[1,4],[1,6],[3,7],[4,3],[5,4],[4,5]]\n```\n\n提示:\n* $1 <= queens.length <= 63$\n* $queens[i].length = 2$\n* $0 <= queens[i][j] < 8$\n* $king.length = 2$\n* $0 <= king[0], king[1] < 8$\n* 一个棋盘格上最多只能放置一枚棋子。", "solution": "### 模拟\n\n创建一个二维数组 `dirs` 来表示八个方向的坐标偏移,同时使用变量 `step` 来表示从国王位置出发的步数。\n\n在每个方向 `i` 上,通过 `step` 步可以到达的坐标为 $(x + dirs[i][0] \\times step, y + dirs[i][1] \\times step)$。\n\n模拟过程中,我们可使用布尔数组 `checked` 来记录已处理的方向,当我们遇到皇后或越过棋盘时,可标记该方向已处理。\n\nJava 代码:\n```Java \nclass Solution {\n    int[][] dirs = new int[][]{{1,0},{0,1},{0,-1},{-1,0},{1,1},{-1,-1},{1,-1},{-1,1}};\n    public List<List<Integer>> queensAttacktheKing(int[][] qs, int[] k) {\n        boolean[][] vis = new boolean[10][10];\n        for (int[] q : qs) vis[q[0]][q[1]] = true;\n        int x = k[0], y = k[1], step = 1;\n        List<List<Integer>> ans = new ArrayList<>();\n        boolean[] checked = new boolean[8];\n        while (step <= 8) {\n            for (int i = 0; i < 8; i++) {\n                if (checked[i]) continue;\n                int nx = x + dirs[i][0] * step, ny = y + dirs[i][1] * step;\n                if (nx < 0 || nx >= 8 || ny < 0 || ny >= 8) {\n                    checked[i] = true;\n                } else {\n                    if (!vis[nx][ny]) continue;\n                    List<Integer> list = new ArrayList<>();\n                    list.add(nx); list.add(ny);\n                    ans.add(list);\n                    checked[i] = true;\n                }\n            }\n            step++;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<vector<int>> queensAttacktheKing(vector<vector<int>>& queens, vector<int>& king) {\n        vector<vector<int>> dirs {{1,0},{0,1},{0,-1},{-1,0},{1,1},{-1,-1},{1,-1},{-1,1}};\n        vector<vector<int>> ans;\n        vector<vector<bool>> vis(8, vector<bool>(8, false));\n        for (auto& queen : queens) vis[queen[0]][queen[1]] = true;\n        int x = king[0], y = king[1], step = 1;\n        vector<bool> checked(8, false);\n        while (step <= 8) {\n            for (int i = 0; i < 8; i++) {\n                if (checked[i]) continue;\n                int nx = x + step * dirs[i][0];\n                int ny = y + step * dirs[i][1];\n                if (nx < 0 || nx >= 8 || ny < 0 || ny >= 8) {\n                    checked[i] = true;\n                } else {\n                    if (!vis[nx][ny]) continue;\n                    ans.push_back({nx, ny});\n                    checked[i] = true;\n                }\n            }\n            step++;\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def queensAttacktheKing(self, queens: List[List[int]], king: List[int]) -> List[List[int]]:\n        dirs = [[1,0],[0,1],[0,-1],[-1,0],[1,1],[-1,-1],[1,-1],[-1,1]]\n        vis = [[False] * 8 for _ in range(8)]\n        for q in queens:\n            vis[q[0]][q[1]] = True\n        x, y = king\n        ans = []\n        checked = [False] * 8\n        step = 1\n        while step <= 8:\n            for i in range(8):\n                if checked[i]: continue\n                nx, ny = x + dirs[i][0] * step, y + dirs[i][1] * step\n                if nx < 0 or nx >= 8 or ny < 0 or ny >= 8:\n                    checked[i] = True\n                else:\n                    if not vis[nx][ny]: continue\n                    ans.append([nx, ny])\n                    checked[i] = True\n            step += 1\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction queensAttacktheKing(queens: number[][], king: number[]): number[][] {\n    let dirs = [[1,0],[0,1],[0,-1],[-1,0],[1,1],[-1,-1],[1,-1],[-1,1]];\n    let vis: boolean[][] = Array.from({length:8},()=>Array(8).fill(false));\n    for (let q of queens) vis[q[0]][q[1]] = true;\n    let x = king[0], y = king[1], step = 1;\n    let ans: number[][] = [];\n    let checked: boolean[] = Array(8).fill(false);\n    while (step <= 8) {\n        for (let i = 0; i < 8; i++) {\n            if (checked[i]) continue;\n            let nx = x + dirs[i][0] * step, ny = y + dirs[i][1] * step;\n            if (nx < 0 || nx >= 8 || ny < 0 || ny >= 8) {\n                checked[i] = true;\n            } else {\n                if (!vis[nx][ny]) continue;\n                ans.push([nx, ny]);\n                checked[i] = true;\n            }\n        }\n        step++;\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(C)$,其中 $C = 8 \\times 8$ 为棋盘总大小\n* 空间复杂度:$O(C)$,其中 $C = 8 \\times 8$ 为棋盘总大小\n\n---\n\n### BFS\n\n上述模拟过程也可以使用 `BFS`  方式进行。\n\n相比于直接模拟,`BFS`  无须使用额外变量记录处理过的方向以及当前位置与国王的距离。\n\nJava 代码:\n```Java\nclass Solution {\n    int[][] dirs = new int[][]{{1,0},{0,1},{0,-1},{-1,0},{1,1},{-1,-1},{1,-1},{-1,1}};\n    public List<List<Integer>> queensAttacktheKing(int[][] qs, int[] k) {\n        boolean[][] vis = new boolean[10][10];\n        for (int[] q : qs) vis[q[0]][q[1]] = true;\n        Deque<int[]> d = new ArrayDeque<>();\n        for (int i = 0; i < 8; i++) {\n            int x = k[0] + dirs[i][0], y = k[1] + dirs[i][1];\n            if (x < 0 || x >= 8 || y < 0 || y >= 8) continue;\n            d.addLast(new int[]{x, y, i});\n        }\n        List<List<Integer>> ans = new ArrayList<>();\n        while (!d.isEmpty()) {\n            int[] info = d.pollFirst();\n            int x = info[0], y = info[1], p = info[2];\n            if (vis[x][y]) {\n                List<Integer> list = new ArrayList<>();\n                list.add(x); list.add(y);\n                ans.add(list);\n            } else {\n                int nx = x + dirs[p][0], ny = y + dirs[p][1];\n                if (nx < 0 || nx >= 8 || ny < 0 || ny >= 8) continue;\n                d.addLast(new int[]{nx, ny, p});\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<vector<int>> queensAttacktheKing(vector<vector<int>>& queens, vector<int>& king) {\n        vector<vector<int>> dirs = {{1,0},{0,1},{0,-1},{-1,0},{1,1},{-1,-1},{1,-1},{-1,1}};\n        vector<vector<bool>> vis(8, vector<bool>(8, false));\n        for (vector<int>& queen : queens) vis[queen[0]][queen[1]] = true;\n        deque<vector<int>> d;\n        for (int i = 0; i < 8; i++) {\n            int x = king[0] + dirs[i][0], y = king[1] + dirs[i][1];\n            if (x < 0 || x >= 8 || y < 0 || y >= 8) continue;\n            d.push_back({x, y, i});\n        }\n        vector<vector<int>> res;\n        while (!d.empty()) {\n            vector<int> cur = d.front();\n            d.pop_front();\n            if (vis[cur[0]][cur[1]]) {\n                res.push_back({cur[0], cur[1]});\n            } else {\n                int nx = cur[0] + dirs[cur[2]][0], ny = cur[1] + dirs[cur[2]][1];\n                if (nx < 0 || nx >= 8 || ny < 0 || ny >= 8) continue;\n                d.push_back({nx, ny, cur[2]});\n            }\n        }\n        return res;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def queensAttacktheKing(self, queens, king):\n        dirs = [[1,0],[0,1],[0,-1],[-1,0],[1,1],[-1,-1],[1,-1],[-1,1]]\n        vis = [[False]*8 for _ in range(8)]\n        for q in queens: vis[q[0]][q[1]] = True\n        d = deque()\n        for i in range(8):\n            x = king[0] + dirs[i][0]\n            y = king[1] + dirs[i][1]\n            if x < 0 or x >= 8 or y < 0 or y >= 8: continue\n            d.append([x, y, i])\n        ans = []\n        while d:\n            cur = d.popleft()\n            if vis[cur[0]][cur[1]]:\n                ans.append([cur[0], cur[1]])\n            else:\n                x = cur[0] + dirs[cur[2]][0]\n                y = cur[1] + dirs[cur[2]][1]\n                if x < 0 or x >= 8 or y < 0 or y >= 8: continue\n                d.append([x, y, cur[2]])\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction queensAttacktheKing(queens: number[][], king: number[]): number[][] {\n    let dirs = [[1,0],[0,1],[0,-1],[-1,0],[1,1],[-1,-1],[1,-1],[-1,1]];\n    let vis: boolean[][] = Array(8).fill(false).map(() => Array(8).fill(false));\n    queens.forEach(q => vis[q[0]][q[1]] = true);\n    let d: number[][] = [];\n    for (let i = 0; i < 8; i++) {\n        let x = king[0] + dirs[i][0], y = king[1] + dirs[i][1];\n        if (x < 0 || x >= 8 || y < 0 || y >= 8) continue;\n        d.push([x, y, i]);\n    }\n    let res = [];\n    while (d.length !== 0) {\n        let cur = d.shift();\n        if (vis[cur[0]][cur[1]]) {\n            res.push([cur[0], cur[1]]);\n        } else {\n            let x = cur[0] + dirs[cur[2]][0], y = cur[1] + dirs[cur[2]][1];\n            if (x < 0 || x >= 8 || y < 0 || y >= 8) continue;\n            d.push([x, y, cur[2]]);\n        }\n    }\n    return res;\n};\n```\n* 时间复杂度:$O(C)$,其中 $C = 4 \\times 8$ 为四条线的总步数\n* 空间复杂度:$O(C)$,其中 $C = 8 \\times 8$ 为棋盘总大小", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1222` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1221-1230/1224. 最大相等频率（困难）.md", "url_title": "1224. 最大相等频率", "url": "https://leetcode.cn/problems/maximum-equal-frequency/solution/by-ac_oier-fviv/", "difficulty": "困难", "tags": ["模拟", "哈希表", "计数"], "question": "给你一个正整数数组 `nums`,请你帮忙从该数组中找出能满足下面要求的最长前缀,并返回该前缀的长度:\n\n* 从前缀中 恰好删除一个 元素后,剩下每个数字的出现次数都相同。\n\n如果删除这个元素后没有剩余元素存在,仍可认为每个数字都具有相同的出现次数(也就是 $0$ 次)。\n\n示例 1:\n```\n输入:nums = [2,2,1,1,5,3,3,5]\n\n输出:7\n\n解释:对于长度为 7 的子数组 [2,2,1,1,5,3,3],如果我们从中删去 nums[4] = 5,就可以得到 [2,2,1,1,3,3],里面每个数字都出现了两次。\n```\n示例 2:\n```\n输入:nums = [1,1,1,2,2,2,3,3,3,4,4,4,5]\n\n输出:13\n```\n\n提示:\n* $2 <= nums.length <= 10^5$\n* $1 <= nums[i] <= 10^5$", "solution": "### 模拟(计数 + 分情况讨论)\n\n我们使用 `cnt` 数组记录每个数的出现次数(即 `cnt[i] = x` 含义为数值 $i$ 的出现次数为 $x$ 次),以及使用 `sum` 来记录出现次数为某个值的数有多少个(即 `sum[i] = x` 含义为出现次数为 $i$ 的数值共有 $x$ 个),同时使用 `max` 来记录最大出现次数 $cnt[i]$。\n\n从前往后处理 `nums`,假设当前处理到的数值为 $t = nums[i]$(前缀所含数量为 $len = i + 1$)有如下几种情况,我们可以更新最大长度 `ans`:\n\n* $max = 1$:说明当前处理到的所有 $nums[i]$ 均只出现了一次,此时任意删除一个均满足要求;\n* $max \\times sum[max] + 1 = len$:说明有一个数值单独出现了一次(其余出现次数为 `max` 的数值 + 被删除的一个数 = 总数量 $len$),删除后即满足要求;\n* $(max - 1) \\times (sum[max - 1] + 1) + 1 = len$:说明出现次数为 `max` 的数值只有一个,其余出现次数均为 `max - 1`,对其删除一次后即满足要求(删除该出现次数为 `max` 的数值后,会导致出现次数为 `max - 1` 的数值多一个,此时有「出现次数为 `max - 1` 的数值 + 被删除的一个数 = 总数量 $len$」)。\n\nJava 代码:\n```Java\nclass Solution {\n    static int[] cnt = new int[100010], sum = new int[100010];\n    public int maxEqualFreq(int[] nums) {\n        Arrays.fill(cnt, 0); Arrays.fill(sum, 0);\n        int n = nums.length, max = 0, ans = 0;\n        for (int i = 0; i < n; i++) {\n            int t = nums[i], cur = ++cnt[t], len = i + 1;\n            sum[cur]++; sum[cur - 1]--;\n            max = Math.max(max, cur);\n            if (max == 1) ans = len;\n            if (max * sum[max] + 1 == len) ans = len;\n            if ((max - 1) * (sum[max - 1] + 1) + 1 == len) ans = len;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction maxEqualFreq(nums: number[]): number {\n    let n = nums.length, max = 0, ans = 0\n    const cnt = new Array<number>(100010).fill(0), sum = new Array<number>(100010).fill(0)\n    for (let i = 0; i < n; i++) {\n        let t = nums[i], len = i + 1, cur = ++cnt[t]\n        sum[cur]++; sum[cur - 1]--;\n        max = Math.max(max, cur)\n        if (max == 1) ans = len\n        if (max * sum[max] + 1 == len) ans = len\n        if ((max - 1) * (sum[max - 1] + 1) + 1 == len) ans = len\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1224` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1221-1230/1233. 删除子文件夹（中等）.md", "url_title": "1233. 删除子文件夹", "url": null, "difficulty": "中等", "tags": ["字典树"], "question": "你是一位系统管理员,手里有一份文件夹列表 `folder`,你的任务是要删除该列表中的所有 子文件夹,并以 任意顺序 返回剩下的文件夹。\n\n如果文件夹 `folder[i]` 位于另一个文件夹 `folder[j]` 下,那么 `folder[i]` 就是 `folder[j]` 的 子文件夹 。\n\n文件夹的「路径」是由一个或多个按以下格式串联形成的字符串:`'/'` 后跟一个或者多个小写英文字母。\n\n例如,`\"/leetcode\"` 和 `\"/leetcode/problems\"` 都是有效的路径,而空字符串和 \"/\" 不是。\n\n示例 1:\n```\n输入:folder = [\"/a\",\"/a/b\",\"/c/d\",\"/c/d/e\",\"/c/f\"]\n\n输出:[\"/a\",\"/c/d\",\"/c/f\"]\n\n解释:\"/a/b\" 是 \"/a\" 的子文件夹,而 \"/c/d/e\" 是 \"/c/d\" 的子文件夹。\n```\n示例 2:\n```\n输入:folder = [\"/a\",\"/a/b/c\",\"/a/b/d\"]\n\n输出:[\"/a\"]\n\n解释:文件夹 \"/a/b/c\" 和 \"/a/b/d\" 都会被删除,因为它们都是 \"/a\" 的子文件夹。\n```\n示例 3:\n```\n输入: folder = [\"/a/b/c\",\"/a/b/ca\",\"/a/b/d\"]\n\n输出: [\"/a/b/c\",\"/a/b/ca\",\"/a/b/d\"]\n```\n\n提示:\n* $1 <= folder.length <= 4 \\times 10^4$\n* $2 <= folder[i].length <= 100$\n* `folder[i]` 只包含小写字母和 `'/'`\n* `folder[i]` 总是以字符 `'/'` 起始\n* 每个文件夹名都是 唯一 的", "solution": "### 字典树\n\n一道字典树裸题,不熟悉字典树的同学可以看前置 🧀 : [【设计数据结构】实现 Trie (前缀树)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089)。\n\n定义类 `Trie` 代表字典树节点,对应物理含义为某个文件夹。该节点含有属性 `s`、`isEnd` 和 `stries`,分别代表「当前节点所代表文件夹名」、「是否为当前路径的最终文件夹」以及「当前文件夹下的子文件夹集合」。\n\n并且由于每个文件夹名的长度不定,我们使用 `Map<String, Trie>` 结构来构建 `stries`。\n\n起始先将所有的 $folder[i]$ 加入字典树,随后查询每个 $folder[i]$ 是否为子文件夹,将所有非子文件夹加入答案。\n\n代码:\n```Java\nclass Solution {\n    class Trie {\n        String s;\n        boolean isEnd = false;\n        Map<String, Trie> stries = new HashMap<>();\n        Trie (String _s) {\n            s = _s;\n        }\n    }\n    void add(String f) {\n        String[] ss = f.split(\"/\");\n        Trie p = root;\n        for (int i = 1; i < ss.length; i++) {\n            String s = ss[i];\n            if (!p.stries.containsKey(s)) p.stries.put(s, new Trie(s));\n            p = p.stries.get(s);\n        }\n        p.isEnd = true;\n    }\n    boolean isSubFolder(String f) {\n        String[] ss = f.split(\"/\");\n        Trie p = root;\n        for (int i = 1; i < ss.length - 1; i++) {\n            String s = ss[i];\n            if (p.stries.get(s).isEnd) return true;\n            p = p.stries.get(s);\n        }\n        return false;\n    }\n    Trie root = new Trie(\"\");\n    public List<String> removeSubfolders(String[] folder) {\n        for (String f : folder) add(f);\n        List<String> ans = new ArrayList<>();\n        for (String f : folder) {\n            if (!isSubFolder(f)) ans.add(f);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(\\sum_{i = 0}^{n - 1} folder[i].length)$\n* 空间复杂度:$O(\\sum_{i = 0}^{n - 1} folder[i].length)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1223` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1231-1240/1235. 规划兼职工作（困难）.md", "url_title": "1235. 规划兼职工作", "url": "https://leetcode.cn/problems/maximum-profit-in-job-scheduling/solution/by-ac_oier-rgup/", "difficulty": "困难", "tags": ["序列 DP", "二分", "排序"], "question": "你打算利用空闲时间来做兼职工作赚些零花钱。\n\n这里有 `n` 份兼职工作,每份工作预计从 `startTime[i]` 开始到 `endTime[i]` 结束,报酬为 `profit[i]`。\n\n给你一份兼职工作表,包含开始时间 `startTime`,结束时间 `endTime` 和预计报酬 `profit` 三个数组,请你计算并返回可以获得的最大报酬。\n\n注意,时间上出现重叠的 `2` 份工作不能同时进行。\n\n如果你选择的工作在时间 `X` 结束,那么你可以立刻进行在时间 `X` 开始的下一份工作。\n\n示例 1:\n\n```\n输入:startTime = [1,2,3,3], endTime = [3,4,5,6], profit = [50,10,40,70]\n\n输出:120\n\n解释:\n我们选出第 1 份和第 4 份工作, \n时间范围是 [1-3]+[3-6],共获得报酬 120 = 50 + 70。\n```\n示例 2:\n\n```\n输入:startTime = [1,2,3,4,6], endTime = [3,5,10,6,9], profit = [20,20,100,70,60]\n\n输出:150\n\n解释:\n我们选择第 1,4,5 份工作。 \n共获得报酬 150 = 20 + 70 + 60。\n```\n示例 3:\n\n```\n输入:startTime = [1,1,1], endTime = [2,3,4], profit = [5,6,4]\n\n输出:6\n```\n\n提示:\n* $1 <= startTime.length == endTime.length == profit.length <= 5 \\times 10^4$\n* $1 <= startTime[i] < endTime[i] <= 10^9$\n* $1 <= profit[i] <= 10^4$", "solution": "### 序列 DP + 二分\n\n为了方便,我们令 `startTime` 为 `st`,`endTime` 为 `endTime`,`profit` 为 `ps`,同时定义三元组 $job[i] = (st[i], et[i], ps[i])$ 来代指某份工作。\n\n我们知道,在理想情况下,若能将所有工作排成不重叠的直线,我们便能通过完成所有工作来取得最大收益。\n\n归结到每个工作,我们总有「选择完成该工作」和「选择不完成该工作」两种决策。\n\n**定义 $f[i]$ 为考虑前 $i$ 个工作,所能取得的最大收益(注意 $job[i]$ 不一定被选择完成),为了方便,我们令下标从 $1$ 开始:**\n\n* 当不选择该工作时:由于 $job[i]$ 明确不会产生价值,可知 $f[i] = f[i - 1]$;\n* 当选择该工作时:可分为「仅选择完成该工作」或「选择 **考虑** 将该工作接在某个工作后面完成」两种情况:\n    * 当「仅选择完成该工作」时,我们有 $f[i] = job[i][2]$;\n    * 当「选择 **考虑** 将该工作接在某个工作后面完成」时,我们需要在所有满足「$job[j][1] <= job[i][0]$」中选择最适合的 $job[j]$ 接在 $job[i]$ 的前面。\n      即在所有能够在 $job[i]$ 开始前顺利结束的 $job[j]$ 中取最大的 $f[j]$,此时有 $f[i] = f[j] + job[i][2]$\n        > 需要注意:这里的“接在”是指将 $job[j]$ 纳入考虑,但具体方案中,并不一定选择 $job[j]$ 来执行(好好想想我们的 $f[i]$ 状态定义)\n\n最终 $f[i]$ 为上述三种方案中的最大值,并且最终的 $f[n]$ 即是我们的答案。\n\n**当我们处理到 $job[i]$ 时,为了能够「将所有所能拼接在 $job[i]$ 前面的 $job[j]$ 归结到一边」并且「所能更新 $f[i]$ 的 $f[j]$ 均被计算」,我们可以通过对所有的 $job[i]$ 进行右端点(结束时间)进行排升序,并按照从小到大的方式处理每个 $job[i]$。**\n\n此处排序的意义有两点:\n\n* 由于我们是根据右端点排序,当我们处理到某个 $job[i]$ 时,由于有 $job[X][0] < job[X][1]$,因此所能接在 $job[i]$ 前面(结束时间小于等于 $job[i]$ 开始时间)的 $job[j]$ 必然位于 $[0, i)$ 之间;\n* 由于我们对 $f[i]$ 的定义并不限定了必须选 $job[i]$,因此在 $[0, i)$ 范围内以 $job[j]$ 为分割点的数组的具有「二段性」:坐标范围小于等于 $j$ 的 $job[X]$ 均可“接在” $job[i]$ 前面。因此我们可通过「二分」来找所能接在 $job[i]$ 前面的坐标最大的 $job[j]$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int jobScheduling(int[] st, int[] et, int[] ps) {\n        int n = st.length;\n        List<int[]> list = new ArrayList<>();\n        for (int i = 0; i < n; i++) list.add(new int[]{st[i], et[i], ps[i]});\n        Collections.sort(list, (a, b)->a[1] - b[1]);\n        int[] f = new int[n + 10];\n        for (int i = 1; i <= n; i++) {\n            int[] info = list.get(i - 1);\n            int a = info[0], b = info[1], c = info[2];\n            f[i] = Math.max(f[i - 1], c);\n            int l = 0, r = i - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (list.get(mid)[1] <= a) l = mid;\n                else r = mid - 1;\n            }\n            if (list.get(r)[1] <= a) f[i] = Math.max(f[i], f[r + 1] + c);\n        }\n        return f[n];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int jobScheduling(vector<int>& startTime, vector<int>& endTime, vector<int>& profit) {\n        int n = startTime.size();\n        vector<vector<int>> list(n);\n        for (int i = 0; i < n; i++) list[i] = {startTime[i], endTime[i], profit[i]};\n        sort(list.begin(), list.end(), [](vector<int> a, vector<int> b)->bool{return a[1] < b[1];});\n        vector<int> f(n + 10, 0);\n        for(int i = 1; i <= n; i++) {\n            int a = list[i - 1][0], b = list[i - 1][1], c = list[i - 1][2];\n            f[i] = max(f[i - 1], c);\n            int l = 0, r = i - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (list[mid][1] <= a) l = mid;\n                else r = mid - 1;\n            }\n            if (list[r][1] <= a) f[i] = max(f[i], f[r + 1] + c);\n        }\n        return f[n];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def jobScheduling(self, st: List[int], et: List[int], ps: List[int]) -> int:\n        n = len(st)\n        jobs = [(st[i], et[i], ps[i]) for i in range(n)]\n        jobs.sort(key=lambda x: x[1])\n        f = [0] * (n + 10)\n        for i in range(1, n + 1):\n            a, b, c = jobs[i - 1]\n            f[i] = max(f[i - 1], c)\n            l, r = 0, i - 1\n            while l < r:\n                mid = l + r + 1 >> 1\n                if jobs[mid][1] <= a:\n                    l = mid\n                else:\n                    r = mid - 1\n            if jobs[r][1] <= a:\n                f[i] = max(f[i], f[r + 1] + c)\n        return f[n]\n```\nTypeScript 代码:\n```TypeScript\nfunction jobScheduling(st: number[], et: number[], ps: number[]): number {\n    const n = st.length\n    const list = new Array<Array<number>>()\n    for (let i = 0; i < n; i++) list.push([st[i], et[i], ps[i]])\n    list.sort((a,b)=>a[1]-b[1])\n    const f = new Array<number>(n + 10).fill(0)\n    for (let i = 1; i <= n; i++) {\n        const info = list[i - 1]\n        const a = info[0], b = info[1], c = info[2]\n        f[i] = Math.max(f[i - 1], c)\n        let l = 0, r = i - 1\n        while (l < r) {\n            const mid = l + r + 1 >> 1\n            if (list[mid][1] <= a) l = mid\n            else r = mid - 1\n        }\n        if (list[r][1] <= a) f[i] = Math.max(f[i], f[r + 1] + c)\n    }\n    return f[n]\n}\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$;`DP` 过程共有 $n$ 个状态需要转移,每次转移需要进行二分,单次复杂度为 $O(\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1235` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1231-1240/1239. 串联字符串的最大长度（中等）.md", "url_title": "1239. 串联字符串的最大长度", "url": "https://leetcode-cn.com/problems/maximum-length-of-a-concatenated-string-with-unique-characters/solution/gong-shui-san-xie-yi-ti-san-jie-jian-zhi-nfeb/", "difficulty": "中等", "tags": ["DFS", "二进制枚举", "模拟退火", "随机化", "启发式搜索"], "question": "给定一个字符串数组 `arr`,字符串 `s` 是将 `arr` 某一子序列字符串连接所得的字符串,如果 `s` 中的每一个字符都只出现过一次,那么它就是一个可行解。\n\n请返回所有可行解 `s` 中最长长度。\n\n示例 1:\n```\n输入:arr = [\"un\",\"iq\",\"ue\"]\n\n输出:4\n\n解释:所有可能的串联组合是 \"\",\"un\",\"iq\",\"ue\",\"uniq\" 和 \"ique\",最大长度为 4。\n```\n示例 2:\n```\n输入:arr = [\"cha\",\"r\",\"act\",\"ers\"]\n\n输出:6\n\n解释:可能的解答有 \"chaers\" 和 \"acters\"。\n```\n示例 3:\n```\n输入:arr = [\"abcdefghijklmnopqrstuvwxyz\"]\n\n输出:26\n```\n\n提示:\n* $1 <= arr.length <= 16$\n* $1 <= arr[i].length <= 26$\n* `arr[i]` 中只含有小写英文字母", "solution": "### 基本分析\n\n根据题意,可以将本题看做一类特殊的「数独问题」:在给定的 `arr` 字符数组中选择,尽可能多的覆盖一个 $1 \\times 26$ 的矩阵。\n\n对于此类「精确覆盖」问题,换个角度也可以看做「组合问题」。\n\n通常有几种做法:`DFS`、剪枝 `DFS`、二进制枚举、模拟退火、`DLX`。\n\n其中一头一尾解法过于简单和困难,有兴趣的同学自行了解与实现。\n\n---\n\n### 剪枝 DFS\n\n根据题意,可以有如下的剪枝策略:\n\n1. 预处理掉「本身具有重复字符」的无效字符串,并去重;\n2. 由于只关心某个字符是否出现,而不关心某个字符在原字符串的位置,因此可以将字符串使用 `int` 进行表示;\n3. 由于使用 `int` 进行表示,因而可以使用「位运算」来判断某个字符是否可以被追加到当前状态中;\n4. `DFS` 过程中维护一个 `total`,代表后续未经处理的字符串所剩余的“最大价值”是多少,从而实现剪枝;\n5. 使用 `lowbit` 计算某个状态对应的字符长度是多少;\n6. 使用「全局哈希表」记录某个状态对应的字符长度是多少(使用 `static` 修饰,确保某个状态在所有测试数据中只会被计算一次);\n7. 【未应用】由于存在第 $4$ 点这样的「更优性剪枝」,理论上我们可以根据「字符串所包含字符数量」进行从大到小排序,然后再进行 `DFS` 这样效果理论上会更好。想象一下如果存在一个包含所有字母的字符串,先选择该字符串,后续所有字符串将不能被添加,那么由它出发的分支数量为 $0$;而如果一个字符串只包含单个字母,先决策选择该字符串,那么由它出发的分支数量必然大于 $0$。但该策略实测效果不好,没有添加到代码中。\n\n代码:\n```Java\nclass Solution {\n    // 本来想使用如下逻辑将「所有可能用到的状态」打表,实现 O(1) 查询某个状态有多少个字符,但是被卡了\n    // static int N = 26, M = (1 << N);\n    // static int[] cnt = new int[M];\n    // static {\n    //     for (int i = 0; i < M; i++) {\n    //         for (int j = 0; j < 26; j++) {\n    //             if (((i >> j) & 1) == 1) cnt[i]++;\n    //         }\n    //     }\n    // }\n\n    static Map<Integer, Integer> map = new HashMap<>();\n    int get(int cur) {\n        if (map.containsKey(cur)) {\n            return map.get(cur);\n        }\n        int ans = 0;\n        for (int i = cur; i > 0; i -= lowbit(i)) ans++;\n        map.put(cur, ans);\n        return ans;\n    }\n    int lowbit(int x) {\n        return x & -x;\n    }\n\n    int n;\n    int ans = Integer.MIN_VALUE;\n    int[] hash;\n    public int maxLength(List<String> _ws) {\n        n = _ws.size();\n        HashSet<Integer> set = new HashSet<>();\n        for (String s : _ws) {\n            int val = 0;\n            for (char c : s.toCharArray()) {\n                int t = (int)(c - 'a');\n                if (((val >> t) & 1) != 0) {\n                    val = -1;\n                    break;\n                } \n                val |= (1 << t);\n            }\n            if (val != -1) set.add(val);\n        }\n\n        n = set.size();\n        if (n == 0) return 0;\n        hash = new int[n];\n\n        int idx = 0;\n        int total = 0;\n        for (Integer i : set) {\n            hash[idx++] = i;\n            total |= i;\n        }\n        dfs(0, 0, total);\n        return ans;\n    }\n    void dfs(int u, int cur, int total) {\n        if (get(cur | total) <= ans) return;\n        if (u == n) {\n            ans = Math.max(ans, get(cur));\n            return;\n        }\n        // 在原有基础上,选择该数字(如果可以)\n        if ((hash[u] & cur) == 0) {\n            dfs(u + 1, hash[u] | cur, total - (total & hash[u]));\n        }\n        // 不选择该数字\n        dfs(u + 1, cur, total);\n    }\n}\n```\n\n---\n\n### 二进制枚举\n\n首先还是对所有字符串进行预处理。\n\n然后使用「二进制枚举」的方式,枚举某个字符串是否被选择。\n\n举个🌰,$(110)_{2}$ 代表选择前两个字符串,$(011)_{2}$ 代表选择后两个字符串,这样我们便可以枚举出所有组合方案。\n\n代码:\n```Java\nclass Solution {\n    static Map<Integer, Integer> map = new HashMap<>();\n    int get(int cur) {\n        if (map.containsKey(cur)) {\n            return map.get(cur);\n        }\n        int ans = 0;\n        for (int i = cur; i > 0; i -= lowbit(i)) ans++;\n        map.put(cur, ans);\n        return ans;\n    }\n    int lowbit(int x) {\n        return x & -x;\n    }\n\n    int n;\n    int ans = Integer.MIN_VALUE;\n    Integer[] hash;\n    public int maxLength(List<String> _ws) {\n        n = _ws.size();\n        HashSet<Integer> set = new HashSet<>();\n        for (String s : _ws) {\n            int val = 0;\n            for (char c : s.toCharArray()) {\n                int t = (int)(c - 'a');\n                if (((val >> t) & 1) != 0) {\n                    val = -1;\n                    break;\n                } \n                val |= (1 << t);\n            }\n            if (val != -1) set.add(val);\n        }\n\n        n = set.size();\n        if (n == 0) return 0;\n        hash = new Integer[n];\n        int idx = 0;\n        for (Integer i : set) hash[idx++] = i;\n\n        for (int i = 0; i < (1 << n); i++) {\n            int cur = 0, val = 0;\n            for (int j = 0; j < n; j++) {\n                if (((i >> j) & 1) == 1) {\n                    if ((cur & hash[j]) == 0) {\n                        cur |= hash[j];\n                        val += get(hash[j]);\n                    } else {\n                        cur = -1;\n                        break;\n                    }\n                }\n            }\n            if (cur != -1) ans = Math.max(ans, val);\n        }\n        return ans;\n    }\n}\n```\n\n---\n\n### 模拟退火\n\n事实上,可以将原问题看作求「最优前缀序列」问题,从而使用「模拟退火」进行求解。\n\n具体的,我们可以定义「最优前缀序列」为 **组成最优解所用到的字符串均出现在排列的前面。**\n\n举个🌰,假如构成最优解使用到的字符串集合为 `[a,b,c]`,那么对应 `[a,b,c,...]`、`[a,c,b,...]` 均称为「最优前缀序列」。\n\n不难发现,答案与最优前缀序列是一对多关系,这指导我们可以将「参数」调得宽松一些。\n\n**具有「一对多」关系的问题十分适合使用「模拟退火」,使用「模拟退火」可以轻松将本题 `arr.length` 数据范围上升到 $60$ 甚至以上。**\n\n调整成比较宽松的参数可以跑赢「二进制枚举」,但为了以后增加数据不容易被 hack,还是使用 `N=400` & `fa=0.90` 的搭配。\n\n「模拟退火」的几个参数的作用在 [这里](https://leetcode-cn.com/problems/find-minimum-time-to-finish-all-jobs/solution/gong-shui-san-xie-yi-ti-shuang-jie-jian-4epdd/) 说过了,不再赘述。\n\n代码:\n```Java\nclass Solution {\n    static Map<Integer, Integer> map = new HashMap<>();\n    int get(int cur) {\n        if (map.containsKey(cur)) {\n            return map.get(cur);\n        }\n        int ans = 0;\n        for (int i = cur; i > 0; i -= lowbit(i)) ans++;\n        map.put(cur, ans);\n        return ans;\n    }\n    int lowbit(int x) {\n        return x & -x;\n    }\n\n    int n;\n    int ans = Integer.MIN_VALUE;    \n    Random random = new Random(20210619);\n    double hi = 1e4, lo = 1e-4, fa = 0.90; \n    int N = 400; \n    int calc() {\n        int mix = 0, cur = 0;\n        for (int i = 0; i < n; i++) {\n            int hash = ws[i];\n            if ((mix & hash) == 0) {\n                mix |= hash;\n                cur += get(hash);\n            } else {\n                break;\n            }\n        }\n        ans = Math.max(ans, cur);\n        return cur;\n    }\n    void shuffle(int[] nums) {\n        for (int i = n; i > 0; i--) {\n            int idx = random.nextInt(i);\n            swap(nums, idx, i - 1);\n        }\n    }\n    void swap(int[] nums, int a, int b) {\n        int c = nums[a];\n        nums[a] = nums[b];\n        nums[b] = c;\n    }\n    void sa() {\n        shuffle(ws);\n        for (double t = hi; t > lo; t *= fa) {\n            int a = random.nextInt(n), b = random.nextInt(n);\n            int prev = calc(); \n            swap(ws, a, b);\n            int cur = calc(); \n            int diff = cur - prev;\n            if (Math.log(-diff / t) > random.nextDouble()) swap(ws, a, b);\n        }\n    }\n    int[] ws;\n    public int maxLength(List<String> _ws) {\n        // 预处理字符串:去重,剔除无效字符\n        // 结果这一步后:N 可以下降到 100;fa 可以下降到 0.70,耗时约为 78 ms\n        // 为了预留将来添加测试数据,题解还是保持 N = 400 & fa = 0.90 的配置\n        n = _ws.size();\n        HashSet<Integer> set = new HashSet<>();\n        for (String s : _ws) {\n            int val = 0;\n            for (char c : s.toCharArray()) {\n                int t = (int)(c - 'a');\n                if (((val >> t) & 1) != 0) {\n                    val = -1;\n                    break;\n                } \n                val |= (1 << t);\n            }\n            if (val != -1) set.add(val);\n        }\n\n        n = set.size();\n        if (n == 0) return 0;\n        ws = new int[n];\n        int idx = 0;\n        for (Integer i : set) ws[idx++] = i;\n\n        while (N-- > 0) sa();\n        return ans;\n    }\n}\n```", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1239` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1251-1260/1252. 奇数值单元格的数目（简单）.md", "url_title": "1252. 奇数值单元格的数目", "url": "https://leetcode.cn/problems/cells-with-odd-values-in-a-matrix/solution/by-ac_oier-p0za/", "difficulty": "简单", "tags": ["模拟", "位运算", "计数"], "question": "给你一个 $m \\times n$ 的矩阵,最开始的时候,每个单元格中的值都是 $0$。\n\n另有一个二维索引数组 `indices`,$indices[i] = [r_i, c_i]$ 指向矩阵中的某个位置,其中 $r_i$ 和 $c_i$ 分别表示指定的行和列(从 $0$ 开始编号)。\n\n对 $indices[i]$ 所指向的每个位置,应同时执行下述增量操作:\n* $r_i$ 行上的所有单元格,加 $1$ 。\n* $c_i$ 列上的所有单元格,加 $1$ 。\n\n给你 $m$、$n$ 和 $indices$ 。请你在执行完所有 $indices$ 指定的增量操作后,返回矩阵中 奇数值单元格 的数目。\n\n示例 1:\n\n```\n输入:m = 2, n = 3, indices = [[0,1],[1,1]]\n\n输出:6\n\n解释:最开始的矩阵是 [[0,0,0],[0,0,0]]。\n第一次增量操作后得到 [[1,2,1],[0,1,0]]。\n最后的矩阵是 [[1,3,1],[1,3,1]],里面有 6 个奇数。\n```\n示例 2:\n\n```\n输入:m = 2, n = 2, indices = [[1,1],[0,0]]\n\n输出:0\n\n解释:最后的矩阵是 [[2,2],[2,2]],里面没有奇数。\n```\n\n提示:\n* $1 <= m, n <= 50$\n* $1 <= indices.length <= 100$\n* $0 <= r_i < m$\n* $0 <= c_i < n$\n\n进阶:你可以设计一个时间复杂度为 $O(n + m + indices.length)$ 且仅用 $O(n + m)$ 额外空间的算法来解决此问题吗?", "solution": "### 基本分析 \n\n容易想到时间复杂度为 $O(l + m \\times n)$,空间复杂度为 $O(m + n)$ 的做法,在此不再赘述。\n\n对于某个位置最终累加值为奇数的充要条件为「所在行被累加次数的奇偶性」与「所在列被累加次数的奇偶性」不同。\n\n因此我们可以统计累加次数为奇数的行数 $a$(累加次数为偶数的行数为 $m - a$),累加次数为奇数的列数 $b$(累加次数为偶数的列数为 $n - b$),根据乘法原理,最终答案为 $a \\times (n - b) + (m - a) \\times b$。\n\n---\n\n### 计数模拟\n\n由于我们只需关系某个位置的奇偶性,而不关心具体的累加值,我们可以创建两个数组 `r` 和 `c`,统计每行和每列的累加值的奇偶性。\n\n当 $r[idx]$ 为 `True` 含义为第 $idx$ 行的累加值为奇数,否则为偶数。列数组 `c` 的统计规则同理。\n\nJava 代码:\n```Java\nclass Solution {\n    public int oddCells(int m, int n, int[][] ins) {\n        boolean[] r = new boolean[m], c = new boolean[n];\n        int a = 0, b = 0;\n        for (int[] info : ins) {\n            a += (r[info[0]] = !r[info[0]]) ? 1 : -1;\n            b += (c[info[1]] = !c[info[1]]) ? 1 : -1;\n        }\n        return a * (n - b) + (m - a) * b;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction oddCells(m: number, n: number, ins: number[][]): number {\n    const r = new Array<boolean>(m).fill(false), c = new Array<boolean>(n).fill(false)\n    let a = 0, b = 0\n    for (const [i, j] of ins) {\n        a += (r[i] = !r[i]) ? 1 : -1\n        b += (c[j] = !c[j]) ? 1 : -1\n    }\n    return a * (n - b) + (m - a) * b\n};\n```\nPython 代码:\n```Python3\nclass Solution:\n    def oddCells(self, m: int, n: int, ins: List[List[int]]) -> int:\n        r, c = [False] * m, [False] * n\n        for i, j in ins:\n            r[i] ^= 1\n            c[j] ^= 1\n        a, b = sum(r), sum(c)\n        return a * (n - b) + (m - a) * b\n```\n* 时间复杂度:构建计数数组的复杂度为 $O(m + n)$,统计奇数行和奇数列复杂度为 $O(l)$,其中 $l$ 为数组 `ins` 的长度,复杂度为 $O(m + n + l)$\n* 空间复杂度:$O(m + n)$\n\n---\n\n### 位运算\n\n更进一步,我们可以使用两个 `long` 变量 $c1$ 和 $c2$ 来分别充当行和列的计数数组,当 $c1$ 的第 $k$ 位为 $1$,代表第 $k$ 行累加值为奇数,当 $c1$ 的第 $k$ 位为 $0$,代表第 $k$ 行累加值为偶数;$c2$ 的计数规则同理。而翻转二进制中的某一位可使用「异或」操作。\n\n当处理完所有的 `ins` 之后,可通过「遍历 $c1$ 的低 $m$ 位 + 遍历 $c2$ 的低 $n$ 位」来得到行数中奇数个数 $a$,列数中奇数个数 $b$,复杂度为 $O(m + n)$;也可以使用 `bitCount` 统计 `long` 二进制数中 $1$ 的个数(本质是分治操作),复杂度为 $O(\\log{64})$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int oddCells(int m, int n, int[][] ins) {\n        long c1 = 0, c2 = 0;\n        for (int[] info : ins) {\n            c1 ^= 1L << info[0];\n            c2 ^= 1L << info[1];\n        }\n        int a = 0, b = 0;\n        for (int i = 0; i < m; i++) a += ((c1 >> i) & 1);\n        for (int i = 0; i < n; i++) b += ((c2 >> i) & 1);\n        return a * (n - b) + (m - a) * b;\n    }\n}\n```\nJava 代码:\n```Java\nclass Solution {\n    public int oddCells(int m, int n, int[][] ins) {\n        long c1 = 0, c2 = 0;\n        for (int[] info : ins) {\n            c1 ^= 1L << info[0];\n            c2 ^= 1L << info[1];\n        }\n        int a = Long.bitCount(c1), b = Long.bitCount(c2);\n        return a * (n - b) + (m - a) * b;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction oddCells(m: number, n: number, ins: number[][]): number {\n    const c1 = [0, 0], c2 = [0, 0]\n    for (const [i, j] of ins) {\n        c1[Math.ceil(i / 32)] ^= (1 << (i % 32))\n        c2[Math.ceil(j / 32)] ^= (1 << (j % 32))\n    }\n    let a = 0, b = 0\n    for (let i = 0; i < m; i++) a += (c1[Math.ceil(i / 32)] >> (i % 32) & 1)\n    for (let i = 0; i < n; i++) b += (c2[Math.ceil(i / 32)] >> (i % 32) & 1)\n    return a * (n - b) + (m - a) * b\n};\n```\nPython 代码:\n```Python3\nclass Solution:\n    def oddCells(self, m: int, n: int, ins: List[List[int]]) -> int:\n        c1, c2 = 0, 0\n        for i, j in ins:\n            c1 ^= (1 << i)\n            c2 ^= (1 << j)\n        a, b = 0, 0\n        for i in range(m):\n            a += (c1 >> i) & 1\n        for i in range(n):\n            b += (c2 >> i) & 1\n        return a * (n - b) + (m - a) * b\n```\n* 时间复杂度:处理所有的 `ins` 复杂度为 $O(l)$,其中 $l$ 为数组 `ins` 的长度;使用遍历方式统计奇数行和奇数列个数复杂度为 $O(m + n)$;使用 `bitCount` 操作统计二进制中 $1$ 个数,复杂度为 $O(\\log{C})$,其中 $C = 64$ 为 `long` 二进制数长度,整体复杂度为 $O(l + m + n)$ 或 $O(l + \\log{C})$ \n* 空间复杂度:$O(1)$\n\n---\n\n### 答疑\n\n评论区有同学提到 `bitCount` 的复杂度问题,如下是 `Long.bitCount` 操作的源码:\n\n```Java\npublic static int bitCount(long i) {\n    // HD, Figure 5-14\n    i = i - ((i >>> 1) & 0x5555555555555555L);\n    i = (i & 0x3333333333333333L) + ((i >>> 2) & 0x3333333333333333L);\n    i = (i + (i >>> 4)) & 0x0f0f0f0f0f0f0f0fL;\n    i = i + (i >>> 8);\n    i = i + (i >>> 16);\n    i = i + (i >>> 32);\n    return (int)i & 0x7f;\n}\n```\n\n这自然不是通过遍历统计位数的 $O(n)$ 做法,普遍会认为是 $O(1)$。\n\n但上述操作目的是进行成组统计(分治),而能够这样写是因为默认了 `long` 是 $64$ 长度,因此严格意义来说这段代码复杂度是 $O(\\log{64})$ 的。\n\n作为对比,可以把 `Integer.bitCount`  的源码看一下:\n\n```Java\npublic static int bitCount(int i) {\n    // HD, Figure 5-2\n    i = i - ((i >>> 1) & 0x55555555);\n    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);\n    i = (i + (i >>> 4)) & 0x0f0f0f0f;\n    i = i + (i >>> 8);\n    i = i + (i >>> 16);\n    return i & 0x3f;\n}\n```\n\n统计原理如出一辙,而能够这样统计,是因为默认了 `int` 长度为 $32$,其分组统计所需要的操作次数也与二进制数的长度相关,因此复杂度为 $O(\\log{32})$。\n\n将上述两个 `bitCount` 视为 $O(1)$ 都是不对的。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1252` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1251-1260/1253. 重构 2 行二进制矩阵（中等）.md", "url_title": "1253. 重构 2 行二进制矩阵", "url": null, "difficulty": "中等", "tags": ["模拟", "贪心", "构造"], "question": "给你一个 `2` 行 `n` 列的二进制数组:\n\n* 矩阵是一个二进制矩阵,这意味着矩阵中的每个元素不是 0 就是 1。\n* 第 `0` 行的元素之和为 `upper`。\n* 第 `1` 行的元素之和为 `lower`。\n* 第 `i` 列(从 `0` 开始编号)的元素之和为 `colsum[i]`,`colsum` 是一个长度为 `n` 的整数数组。\n\n你需要利用 `upper`,`lower` 和 `colsum` 来重构这个矩阵,并以二维整数数组的形式返回它。\n\n如果有多个不同的答案,那么任意一个都可以通过本题。\n\n如果不存在符合要求的答案,就请返回一个空的二维数组。\n\n示例 1:\n```\n输入:upper = 2, lower = 1, colsum = [1,1,1]\n\n输出:[[1,1,0],[0,0,1]]\n\n解释:[[1,0,1],[0,1,0]] 和 [[0,1,1],[1,0,0]] 也是正确答案。\n```\n示例 2:\n```\n输入:upper = 2, lower = 3, colsum = [2,2,1,1]\n\n输出:[]\n```\n示例 3:\n```\n输入:upper = 5, lower = 5, colsum = [2,1,2,0,1,0,1,2,0,1]\n\n输出:[[1,1,1,0,1,0,0,1,0,0],[1,0,1,0,0,0,1,1,0,1]]\n```\n\n提示:\n* $1 <= colsum.length <= 10^5$\n* $0 <= upper, lower <= colsum.length$\n* $0 <= colsum[i] <= 2$", "solution": "### 贪心 + 构造 \n\n创建数组 `a` 和 `b` 分别代表目标二进制矩阵的第 `0` 行和第 `1` 行。\n\n从前往后处理 `colsum`,复用 `upper` 和 `lower` 分别代表两行剩余 $1$ 的个数。\n\n根据当前的 $colsum[i]$ 进行分情况讨论:\n\n* 若 $colsum[i] = 0$,只有一种情况,当前位置两行均为 $0$\n* 若 $colsum[i] = 2$,只有一种情况,当前位置两行均为 $1$\n* 若 $colsum[i] = 1$,选剩余 `1` 个数较大的行,填入 $1$,另外行则填入 $0$\n\n若处理完 `colsum` 后,两行剩余 $1$ 个数恰好均为 $0$,说明构造出了合法方案。\n\n容易证明:**不存在某个决策回合中,必须先填入剩余个数少的一方,才能顺利构造。**\n\n可用反证法进行证明,若存在某个回合必须填入剩余个数少的一方(假设该回合上填 `1` 下填 `0`),必然能够找到同为 $colsum[j] = 1$ 的回合进行交换,同时不影响合法性(上下行的总和不变,同时 $colsum[i] = colsum[j] = 1$)。\n\nJava 代码:\n```Java\nclass Solution {\n    public List<List<Integer>> reconstructMatrix(int upper, int lower, int[] colsum) {\n        int n = colsum.length;\n        List<List<Integer>> ans = new ArrayList<>();\n        List<Integer> a = new ArrayList<>(), b = new ArrayList<>();\n        for (int i = 0; i < n; i++) {\n            int m = colsum[i];\n            if (m == 0) {\n                a.add(0); b.add(0);\n            } else if (m == 2) {\n                upper--; lower--;\n                a.add(1); b.add(1);\n            } else {\n                if (upper >= lower) {\n                    upper--;\n                    a.add(1); b.add(0);\n                } else {\n                    lower--;\n                    a.add(0); b.add(1);\n                }\n            }\n        }\n        if (upper == 0 && lower == 0) {\n            ans.add(a); ans.add(b);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<vector<int>> reconstructMatrix(int upper, int lower, vector<int>& colsum) {\n        int n = colsum.size();\n        vector<vector<int>> ans;\n        vector<int> a, b;\n        for (int i = 0; i < n; i++) {\n            int m = colsum[i];\n            if (m == 0) {\n                a.push_back(0); b.push_back(0);\n            } else if (m == 2) {\n                upper--; lower--;\n                a.push_back(1); b.push_back(1);\n            } else {\n                if (upper >= lower) {\n                    upper--;\n                    a.push_back(1); b.push_back(0);\n                } else {\n                    lower--;\n                    a.push_back(0); b.push_back(1);\n                }\n            }\n        }\n        if (upper == 0 && lower == 0) {\n            ans.push_back(a); ans.push_back(b);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def reconstructMatrix(self, upper: int, lower: int, colsum: List[int]) -> List[List[int]]:\n        n = len(colsum)\n        ans = []\n        a, b = [], []\n        for i in range(n):\n            m = colsum[i]\n            if m == 0:\n                a.append(0)\n                b.append(0)\n            elif m == 2:\n                upper, lower = upper - 1, lower - 1\n                a.append(1)\n                b.append(1)\n            else:\n                a.append(1 if upper >= lower else 0)\n                b.append(0 if upper >= lower else 1)\n                if upper >= lower: upper -= 1\n                else: lower -= 1\n        if upper == lower == 0:\n            ans.append(a)\n            ans.append(b)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction reconstructMatrix(upper: number, lower: number, colsum: number[]): number[][] {\n    const n = colsum.length;\n    let ans: number[][] = [];\n    let a: number[] = [], b: number[] = [];\n    for (let i = 0; i < n; i++) {\n        const m = colsum[i];\n        if (m === 0) {\n            a.push(0); b.push(0);\n        } else if (m === 2) {\n            upper--; lower--;\n            a.push(1); b.push(1);\n        } else {\n            if (upper >= lower) {\n                upper--;\n                a.push(1); b.push(0);\n            } else {\n                lower--;\n                a.push(0); b.push(1);\n            }\n        }\n    }\n    if (upper === 0 && lower === 0) {\n        ans.push(a); ans.push(b);\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(C \\times n)$,其中 $C = 2$  代表行数\n* 空间复杂度:$O(C \\times n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1253` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1251-1260/1260. 二维网格迁移（简单）.md", "url_title": "1260. 二维网格迁移", "url": "https://leetcode.cn/problems/shift-2d-grid/solution/by-ac_oier-1blt/", "difficulty": "简单", "tags": ["模拟", "构造"], "question": "给你一个 `m` 行 `n` 列的二维网格 `grid` 和一个整数 `k`。\n\n你需要将 `grid` 迁移 `k` 次。\n\n每次「迁移」操作将会引发下述活动:\n\n* 位于 `grid[i][j]` 的元素将会移动到 `grid[i][j + 1]`\n* 位于 `grid[i][n - 1]` 的元素将会移动到 `grid[i + 1][0]`\n* 位于 `grid[m - 1][n - 1]` 的元素将会移动到 `grid[0][0]`\n* 请你返回 `k` 次迁移操作后最终得到的 二维网格\n\n示例 1:\n\n```\n输入:grid = [[1,2,3],[4,5,6],[7,8,9]], k = 1\n\n输出:[[9,1,2],[3,4,5],[6,7,8]]\n```\n示例 2:\n\n```\n输入:grid = [[3,8,1,9],[19,7,2,5],[4,6,11,10],[12,0,21,13]], k = 4\n\n输出:[[12,0,21,13],[3,8,1,9],[19,7,2,5],[4,6,11,10]]\n```\n示例 3:\n```\n输入:grid = [[1,2,3],[4,5,6],[7,8,9]], k = 9\n\n输出:[[1,2,3],[4,5,6],[7,8,9]]\n```\n\n提示:\n* $m == grid.length$\n* $n == grid[i].length$\n* $1 <= m <= 50$\n* $1 <= n <= 50$\n* $-1000 <= grid[i][j] <= 1000$\n* $0 <= k <= 100$", "solution": "### 模拟\n\n为了方便,我们令 `grid` 为 `g`,令 `n` 和 `m` 分别为 `g` 的行数和列数。\n\n由于迁移过程存在明显规律性,因此我们可以直接 $O(1)$ 算得**每一列最终所在的列下标** `tcol = (i + k) % m`(其中 `i` 为原本的列下标),同时 $O(1)$ 算得**当前列的首行元素在新列中的行下标** `trow = ((i + k) / m) % n`,之后就是简单的遍历赋值操作。\n\nJava 代码:\n```Java\nclass Solution {\n    public List<List<Integer>> shiftGrid(int[][] g, int k) {\n        int n = g.length, m = g[0].length;\n        int[][] mat = new int[n][m];\n        for (int i = 0; i < m; i++) {\n            int tcol = (i + k) % m, trow = ((i + k) / m) % n, idx = 0;\n            while (idx != n) {\n                mat[trow++][tcol] = g[idx++][i];\n                if (trow == n) trow = 0;\n            }\n        }\n        List<List<Integer>> ans = new ArrayList<>();\n        for (int i = 0; i < n; i++) {\n            List<Integer> alist = new ArrayList<>();\n            for (int j = 0; j < m; j++) alist.add(mat[i][j]);\n            ans.add(alist);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<vector<int>> shiftGrid(vector<vector<int>>& g, int k) {\n        int n = g.size(), m = g[0].size();\n        vector<vector<int>> mat(n, vector<int>(m));\n        for(int i = 0; i < m; ++i) {\n            int tcol = (i + k) % m, trow = ((i + k) / m) % n, idx = 0;\n            while(idx != n) {\n                mat[trow++][tcol] = g[idx++][i];\n                if(trow == n) trow = 0;\n            }\n        }\n        return mat;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def shiftGrid(self, g: List[List[int]], k: int) -> List[List[int]]:\n        n, m = len(g), len(g[0])\n        mat = [[0]*m for _ in range(n)]\n        for i in range(m):\n            tcol = (i + k) % m\n            trow = ((i + k) // m) % n\n            idx = 0\n            while idx != n:\n                mat[trow][tcol] = g[idx][i]\n                trow, idx = (trow + 1) % n, idx + 1\n        return mat\n```\nTypeScript 代码:\n```TypeScript\nfunction shiftGrid(g: number[][], k: number): number[][] {\n    const n = g.length, m = g[0].length\n    const ans: number[][] = new Array<Array<number>>()\n    for (let i = 0; i < n; i++) ans[i] = new Array<number>(m).fill(0)\n    for (let i = 0; i < m; i++) {\n        let tcol = (i + k) % m, trow = Math.floor(((i + k) / m)) % n, idx = 0\n        while (idx != n) {\n            ans[trow++][tcol] = g[idx++][i]\n            if (trow == n) trow = 0\n        }\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n \\times m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1260` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1261-1270/1268. 搜索推荐系统（中等）.md", "url_title": "1268. 搜索推荐系统", "url": "https://leetcode.cn/problems/search-suggestions-system/solution/gong-shui-san-xie-yi-ti-shuang-jie-pai-x-gnmu/", "difficulty": "中等", "tags": ["排序", "字典树", "哈希表", "二分"], "question": "给你一个产品数组 `products` 和一个字符串 `searchWord`,`products` 数组中每个产品都是一个字符串。\n\n请你设计一个推荐系统,在依次输入单词 `searchWord` 的每一个字母后,推荐 `products` 数组中前缀与 `searchWord` 相同的最多三个产品。如果前缀相同的可推荐产品超过三个,请按字典序返回最小的三个。\n\n请你以二维列表的形式,返回在输入 `searchWord` 每个字母后相应的推荐产品的列表。\n\n示例 1:\n```\n输入:products = [\"mobile\",\"mouse\",\"moneypot\",\"monitor\",\"mousepad\"], searchWord = \"mouse\"\n输出:[\n[\"mobile\",\"moneypot\",\"monitor\"],\n[\"mobile\",\"moneypot\",\"monitor\"],\n[\"mouse\",\"mousepad\"],\n[\"mouse\",\"mousepad\"],\n[\"mouse\",\"mousepad\"]\n]\n\n解释:按字典序排序后的产品列表是 [\"mobile\",\"moneypot\",\"monitor\",\"mouse\",\"mousepad\"]\n输入 m 和 mo,由于所有产品的前缀都相同,所以系统返回字典序最小的三个产品 [\"mobile\",\"moneypot\",\"monitor\"]\n输入 mou, mous 和 mouse 后系统都返回 [\"mouse\",\"mousepad\"]\n```\n示例 2:\n```\n输入:products = [\"havana\"], searchWord = \"havana\"\n\n输出:[[\"havana\"],[\"havana\"],[\"havana\"],[\"havana\"],[\"havana\"],[\"havana\"]]\n```\n示例 3:\n```\n输入:products = [\"bags\",\"baggage\",\"banner\",\"box\",\"cloths\"], searchWord = \"bags\"\n\n输出:[[\"baggage\",\"bags\",\"banner\"],[\"baggage\",\"bags\",\"banner\"],[\"baggage\",\"bags\"],[\"bags\"]]\n```\n示例 4:\n```\n输入:products = [\"havana\"], searchWord = \"tatiana\"\n\n输出:[[],[],[],[],[],[],[]]\n```\n\n提示:\n* $1 <= products.length <= 1000$\n* $1 <= Σ products[i].length <= 2 \\times 10^4$\n* `products[i]` 中所有的字符都是小写英文字母。\n* $1 <= searchWord.length <= 1000$\n* `searchWord` 中所有字符都是小写英文字母。", "solution": "### 排序 + 字典树 + 哈希表\n\n为了方便,将 `products` 记为 `ps`,将 `searchWord` 记为 `w`。\n\n这是一个 `\"Suggestion string\"` 问题,容易想到字典树进行求解,不了解字典树的同学,可看 [前置 🧀](https://mp.weixin.qq.com/s/DBTQyNYsEgmN0Vb5fbolUg)。\n\n由于题目要求「若有超过三个的产品可推荐,返回字典序最小的三个」,我们不妨先对 `ps` 进行排序,使 `ps` 从前往后满足字典序从小到大。\n\n**将所有 `ps[i]` 按顺序添加到字典树 `tr` 中,添加过程中,使用两个哈希表 `minMap` 和 `maxMap` 分别记录经过某个 `tr[i][j]` 时的最小 `ps` 下标和最大 `ps` 下标**。即哈希表的 `key` 为具体的 `tr[i][j]`,对应 `value` 为经过该节点的最小或最大下标。\n\n构建答案时,**根据当前 `w` 子串到字典树 `tr` 中查询,定位到该子串对应的 `tr[i][j]` 为何值,再从哈希表中获取建议字符串在 `ps` 中的左右端点 `l` 和 `r`**,并根据在 `ps[l:r]` (可能为空集)中最多取三个的原则来构建答案。\n\n考虑实现字典树的两个关键方法,**添加** 和 **查询**:\n\n* 添加函数 `void add(String s, int num)` :其中 `s` 为待添加到字典树的字符串,`num` 则是该字符串在 `ps` 中的下标编号。\n\n  往字典树添加过程中,按照首次访问字典树节点 `tr[i][j]` 的下标存入 `minMap`,最后一次访问字典树节点 `tr[i][j]` 的下标存入 `maxMap` 的规则来更新哈希表。\n\n* 查询函数 `int[] query(String s)`:其中 `s` 为某个 `w` 子串,通过查询该子串(最后字符)在字典树的节点值,来得知建议列表对应 `ps` 的左右端点下标为何值,从而构建答案。\n\nJava 代码:\n```Java\nclass Solution {\n    int[][] tr = new int[20010][26];\n    int idx = 0;\n    Map<Integer, Integer> min = new HashMap<>(), max = new HashMap<>();\n    void add(String s, int num) {\n        int p = 0;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (tr[p][u] == 0) {\n                tr[p][u] = ++idx;\n                min.put(tr[p][u], num);\n            }\n            max.put(tr[p][u], num);\n            p = tr[p][u];\n        }\n    }\n    int[] query(String s) {\n        int a = -1, b = -1, p = 0;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (tr[p][u] == 0) return new int[]{-1, -1};\n            a = min.get(tr[p][u]); b = max.get(tr[p][u]);\n            p = tr[p][u];\n        }\n        return new int[]{a, b};\n    }\n    public List<List<String>> suggestedProducts(String[] ps, String w) {\n        Arrays.sort(ps);\n        List<List<String>> ans = new ArrayList<>();\n        for (int i = 0; i < ps.length; i++) add(ps[i], i);\n        for (int i = 0; i < w.length(); i++) {\n            List<String> list = new ArrayList<>();\n            int[] info = query(w.substring(0, i + 1));\n            int l = info[0], r = info[1];\n            for (int j = l; j <= Math.min(l + 2, r) && l != -1; j++) list.add(ps[j]);\n            ans.add(list);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int tr[20010][26] = {0};\n    int idx = 0;\n    unordered_map<int, int> minMap, maxMap;\n    void add(string s, int num) {\n        int p = 0;\n        for (char c : s) {\n            int u = c - 'a';\n            if (tr[p][u] == 0) {\n                tr[p][u] = ++idx;\n                minMap[tr[p][u]] = num;\n            }\n            maxMap[tr[p][u]] = num;\n            p = tr[p][u];\n        }\n    }\n    pair<int, int> query(string s) {\n        int a = -1, b = -1, p = 0;\n        for (char c : s) {\n            int u = c - 'a';\n            if (tr[p][u] == 0) return {-1, -1};\n            a = minMap[tr[p][u]];\n            b = maxMap[tr[p][u]];\n            p = tr[p][u];\n        }\n        return {a, b};\n    }\n    vector<vector<string>> suggestedProducts(vector<string>& ps, string w) {\n        sort(ps.begin(), ps.end());\n        vector<vector<string>> ans;\n        for (int i = 0; i < ps.size(); i++) add(ps[i], i);\n        for (int i = 0; i < w.length(); i++) {\n            vector<string> list;\n            pair<int, int> info = query(w.substr(0, i + 1));\n            int l = info.first, r = info.second;\n            for (int j = l; j <= min(l + 2, r) && l != -1; j++) list.push_back(ps[j]);\n            ans.push_back(list);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def suggestedProducts(self, ps: List[str], w: str) -> List[List[str]]:\n        tr = defaultdict(lambda: defaultdict(int))\n        idx = 0\n        minMap, maxMap = {}, {}\n        def add(s, num):\n            nonlocal idx\n            p = 0\n            for c in s:\n                u = ord(c) - ord('a')\n                if tr[p][u] == 0:\n                    idx += 1\n                    tr[p][u] = idx\n                    minMap[tr[p][u]] = num\n                maxMap[tr[p][u]] = num\n                p = tr[p][u]\n        def query(s):\n            a, b, p = -1, -1, 0\n            for c in s:\n                u = ord(c) - ord('a')\n                if tr[p][u] == 0:\n                    return (-1, -1)\n                a = minMap[tr[p][u]]\n                b = maxMap[tr[p][u]]\n                p = tr[p][u]\n            return (a, b)\n        ps.sort()\n        ans = []\n        for i in range(len(ps)):\n            add(ps[i], i)\n        for i in range(len(w)):\n            l, r = query(w[:i + 1])\n            lst = [ps[j] for j in range(l, min(l + 3, r + 1)) if l != -1]\n            ans.append(lst)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nlet tr: number[][];\nlet idx: number;\nlet minMap: Map<number, number>, maxMap: Map<number, number>;\nfunction add(s: string, num: number): void {\n    let p = 0;\n    for (let i = 0; i < s.length; i++) {\n        const u = s.charCodeAt(i) - 'a'.charCodeAt(0);\n        if (tr[p][u] === 0) {\n            idx++;\n            tr[p][u] = idx;\n            minMap.set(tr[p][u], num);\n        }\n        maxMap.set(tr[p][u], num);\n        p = tr[p][u];\n    }\n}\nfunction query(s: string): number[] {\n    let a = -1, b = -1, p = 0;\n    for (let i = 0; i < s.length; i++) {\n        const u = s.charCodeAt(i) - 'a'.charCodeAt(0);\n        if (tr[p][u] === 0) return [-1, -1];\n        a = minMap.get(tr[p][u])!;\n        b = maxMap.get(tr[p][u])!;\n        p = tr[p][u];\n    }\n    return [a, b];\n}\nfunction suggestedProducts(ps: string[], w: string): string[][] {\n    tr = new Array(20010).fill(0).map(() => new Array(26).fill(0));\n    idx = 0;\n    minMap = new Map(), maxMap = new Map();\n    ps.sort();\n    const ans = [];\n    for (let i = 0; i < ps.length; i++) add(ps[i], i);\n    for (let i = 0; i < w.length; i++) {\n        const list = [];\n        const [l, r] = query(w.substring(0, i + 1));\n        for (let j = l; j <= Math.min(l + 2, r) && l !== -1; j++) list.push(ps[j]);\n        ans.push(list);\n    }\n    return ans;\n};\n```\n* 时间复杂度:将 `ps` 长度记为 `n`,`w` 长度记为 `m`。对 `ps` 进行排序复杂度为 $O(n\\log{n})$;构建字典树复杂度为 $O(\\sum_{i = 0}^{n - 1}ps[i].length)$;根据 `w` 构建答案复杂度为 $O(m^2)$;整体复杂度为 $O(\\sum_{i = 0}^{n - 1}ps[i].length + m^2)$\n* 空间复杂度:$O(\\sum_{i = 0}^{n - 1}ps[i].length \\times C)$,其中 $C = 26$ 为字符集大小\n\n---\n\n### 排序 + 二分\n\n由于每个 `w` 子串只会对应最多三个的建议字符串,同时又可以先通过排序来确保 `ps` 的有序性。\n\n因此对于每个 `w` 子串而言,可以 **先找到满足要求的,字典序最小的建议字符串 `ps[i]`,接着往后逐个检查,组成最终的建议字符串列表(最多检查三个)**。\n\n这个「在 `ps` 中找符合要求,字典序最小的建议字符串」操作,除了能够利用上述解法来做(省掉一个 `maxMap`)以外,还能利用字符串本身的有序性进行「二分」,因为该操作本质上,是在**找第一个满足 `ps[i]` 大于等于当前子串的位置**。\n\nJava 代码:\n\n```Java\nclass Solution {\n    public List<List<String>> suggestedProducts(String[] ps, String w) {\n        Arrays.sort(ps);\n        int n = ps.length;\n        List<List<String>> ans = new ArrayList<>();\n        for (int i = 0; i < w.length(); i++) {\n            String cur = w.substring(0, i + 1);\n            int l = 0, r = n - 1;\n            while (l < r) {\n                int mid = l + r >> 1;\n                if (ps[mid].compareTo(cur) >= 0) r = mid;\n                else l = mid + 1;\n            }\n            List<String> list = new ArrayList<>();\n            if (ps[r].compareTo(cur) >= 0) {\n                for (int j = r; j <= Math.min(n - 1, r + 2); j++) {\n                    if (ps[j].length() < cur.length()) break;\n                    if (!ps[j].substring(0, i + 1).equals(cur)) break;\n                    list.add(ps[j]);\n                }\n            }\n            ans.add(list);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<vector<string>> suggestedProducts(vector<string>& ps, string w) {\n        sort(ps.begin(), ps.end());\n        int n = ps.size();\n        vector<vector<string>> ans;\n        for (int i = 0; i < w.length(); i++) {\n            string cur = w.substr(0, i + 1);\n            int l = 0, r = n - 1;\n            while (l < r) {\n                int mid = (l + r) >> 1;\n                if (ps[mid].compare(cur) >= 0) r = mid;\n                else l = mid + 1;\n            }\n            vector<string> list;\n            if (ps[r].compare(cur) >= 0) {\n                for (int j = r; j <= min(n - 1, r + 2); j++) {\n                    if (ps[j].length() < cur.length()) break;\n                    if (ps[j].substr(0, i + 1) != cur) break;\n                    list.push_back(ps[j]);\n                }\n            }\n            ans.push_back(list);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def suggestedProducts(self, ps: List[str], w: str) -> List[List[str]]:\n        ps.sort()\n        n = len(ps)\n        ans = []\n        for i in range(len(w)):\n            cur = w[:i + 1]\n            l, r = 0, n - 1\n            while l < r:\n                mid = (l + r) // 2\n                if ps[mid] >= cur:\n                    r = mid\n                else:\n                    l = mid + 1\n            lst = []\n            if ps[r] >= cur:\n                for j in range(r, min(n - 1, r + 2) + 1):\n                    if len(ps[j]) < len(cur) or ps[j][:i + 1] != cur:\n                        break\n                    lst.append(ps[j])\n            ans.append(lst)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction suggestedProducts(ps: string[], w: string): string[][] {\n    ps.sort();\n    const n = ps.length;\n    const ans = [];\n    for (let i = 0; i < w.length; i++) {\n        const cur = w.substring(0, i + 1);\n        let l = 0, r = n - 1;\n        while (l < r) {\n            const mid = (l + r) >> 1;\n            if (ps[mid].localeCompare(cur) >= 0) r = mid;    \n            else l = mid + 1;\n        }\n        const list: string[] = [];\n        if (ps[r].localeCompare(cur) >= 0) {\n            for (let j = r; j <= Math.min(n - 1, r + 2); j++) {\n                if (ps[j].length < cur.length || !ps[j].startsWith(cur)) break;\n                list.push(ps[j]);\n            }\n        }\n        ans.push(list);\n    }\n    return ans;\n};\n```\n* 时间复杂度:将 `ps` 长度记为 `n`,`w` 长度记为 `m`。对 `ps` 进行排序复杂度为 $O(n\\log{n})$;每次二分需要进行字符串比较,复杂度为 $O(m\\log{n})$;二分到左端点后需要往后检查最多三个字符串,复杂度为 $O(m)$。整体复杂度为 $O(n\\log{n} + m\\log{n})$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1268` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1261-1270/1269. 停在原地的方案数（困难）.md", "url_title": "1269. 停在原地的方案数", "url": "https://leetcode-cn.com/problems/number-of-ways-to-stay-in-the-same-place-after-some-steps/solution/gong-shui-san-xie-xiang-jie-xian-xing-dp-m9q9/", "difficulty": "困难", "tags": ["线性 DP"], "question": "有一个长度为 arrLen 的数组,开始有一个指针在索引 0 处。\n\n每一步操作中,你可以将指针向左或向右移动 1 步,或者停在原地(指针不能被移动到数组范围外)。\n\n给你两个整数 steps 和 arrLen ,请你计算并返回:在恰好执行 steps 次操作以后,指针仍然指向索引 0 处的方案数。\n\n由于答案可能会很大,请返回方案数 模 $10^9$ + 7 后的结果。\n\n示例 1:\n```\n输入:steps = 3, arrLen = 2\n\n输出:4\n\n解释:3 步后,总共有 4 种不同的方法可以停在索引 0 处。\n向右,向左,不动\n不动,向右,向左\n向右,不动,向左\n不动,不动,不动\n```\n示例  2:\n```\n输入:steps = 2, arrLen = 4\n\n输出:2\n\n解释:2 步后,总共有 2 种不同的方法可以停在索引 0 处。\n向右,向左\n不动,不动\n```\n示例 3:\n```\n输入:steps = 4, arrLen = 2\n\n输出:8\n```\n\n提示:\n* 1 <= steps <= 500\n* 1 <= arrLen <= $10^6$", "solution": "### 动态规划\n\n这道题的可变维度分析不算复杂,因此这次就不从 `DFS` 开始给大家分析了。\n\n**定义 $f[i][j]$ 代表当前剩余操作数为 $i$,所在位置为 $j$ 的所有方案数。** \n\n起始位置为 $0$,操作次数为 $step$,即有初始化条件 $f[step][0] = 1$,$f[0][0]$ 则是我们的最终答案。\n\n不失一般性的考虑 $f[i][j]$ 可以由哪些状态转移而来:\n\n* 由「原地」操作到达当前状态,消耗一次操作,此时由状态 $f[i + 1][j]$ 转移而来\n* 由「向左」操作到达当前状态,消耗一次操作,此时由状态 $f[i + 1][j + 1]$ 转移而来\n* 由「向右」操作到达当前状态,消耗一次操作,此时由状态 $f[i + 1][j - 1]$ 转移而来\n\n求的是方案数,即最终的 $f[i][j]$ 为三者累加值。\n\n同时我们发现 $f[i][x]$ 依赖于 $f[i + 1][y]$,因此我们需要按照「$step$ 从大到小」的顺序进行转移。\n\n同时我们根据「最终回到下标 $0$ 位置」可以推断出,最远到达的位置为 $step / 2$(再远就回不来了)。将最远到达位置与数组最大下标取 $min$ 即可确定维度 $step$ 的范围。\n\n代码:\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int numWays(int steps, int len) {\n        int max = Math.min(steps / 2, len - 1);\n        int[][] f = new int[steps + 1][max + 1]; \n        f[steps][0] = 1;\n        for (int i = steps - 1; i >= 0; i--) {\n            for (int j = 0; j <= max; j++) {\n                f[i][j] = (f[i][j] + f[i + 1][j]) % mod;\n                if (j - 1 >= 0) f[i][j] = (f[i][j] + f[i + 1][j - 1]) % mod;\n                if (j + 1 <= max) f[i][j] = (f[i][j] + f[i + 1][j + 1]) % mod;\n            }\n        }\n        return f[0][0];\n    }\n}\n```\n* 时间复杂度:共有数量级为 $step * max$ 个的状态需要被转移。复杂度为 $O(step * max)$\n* 空间复杂度:$O(step * max)$\n\n---\n\n### 优化\n\n**1. 对时间复杂度进行「常数级别的优化」**\n\n$f[0][0]$ 并不依赖于操作次数同为 $0$ 的其他位置的状态,而只依赖于操作次数为 $1$ 的特定位置的状态。同理其他状态也是。\n\n因此我们会发现**随着「可操作次数」的减少,「可达到的最远位置」下标也会逐步缩小。从目标状态 $f[0][0]$ 进行倒推的话,会发现「可达到的最远位置」等于「可操作次数」。**\n\n**所以其实可以从两者取一个 $min$ 就能够有效减少「无效状态」的计算。数据量越大,这个性质带来的剪枝效果越好。**\n\n*PS. 为了方便你看到优化前后的差别,我增加了打印注释,使用测试数据 (500, 100000) 并打开注释,可以看到少计算了多少「无效状态」。*\n\n代码:\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int numWays(int steps, int len) {\n        int max = Math.min(steps / 2, len - 1);\n        int[][] f = new int[steps + 1][max + 1]; \n        f[steps][0] = 1;\n        for (int i = steps - 1; i >= 0; i--) {\n            int edge = Math.min(i, max);\n            // if (edge != max) System.out.println(edge + \" \" + max);\n            for (int j = 0; j <= edge; j++) {\n                f[i][j] = (f[i][j] + f[i + 1][j]) % mod;\n                if (j - 1 >= 0) f[i][j] = (f[i][j] + f[i + 1][j - 1]) % mod;\n                if (j + 1 <= max) f[i][j] = (f[i][j] + f[i + 1][j + 1]) % mod;\n            }\n        }\n        return f[0][0];\n    }\n}\n```\n* 时间复杂度:共有数量级为 $step * max$ 个的状态需要被转移。复杂度为 $O(step * max)$\n* 空间复杂度:$O(step * max)$\n\n**2. 对空间复杂度进行「维度级别的优化」**\n\n这个优化思维难度就要低很多了,利用 $f[i][x]$ 依赖于 $f[i + 1][y]$,使用「滚动数组」方式进行优化即可。\n\n代码:\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int numWays(int steps, int len) {\n        int max = Math.min(steps / 2, len - 1);\n        int[][] f = new int[2][max + 1]; \n        f[steps&1][0] = 1;\n        for (int i = steps - 1; i >= 0; i--) {\n            int edge = Math.min(i, max);\n            int a = i & 1, b = (i + 1) & 1;\n            for (int j = 0; j <= edge; j++) {\n                f[a][j] = 0;\n                f[a][j] = (f[a][j] + f[b][j]) % mod;\n                if (j - 1 >= 0) f[a][j] = (f[a][j] + f[b][j - 1]) % mod;\n                if (j + 1 <= max) f[a][j] = (f[a][j] + f[b][j + 1]) % mod;\n            }\n        }\n        return f[0][0];\n    }\n}\n```\n* 时间复杂度:共有数量级为 $step * max$ 个的状态需要被转移。复杂度为 $O(step * max)$\n* 空间复杂度:$O(max)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1269` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1281-1290/1282. 用户分组（中等）.md", "url_title": "1282. 用户分组", "url": "https://leetcode.cn/problems/group-the-people-given-the-group-size-they-belong-to/solution/by-ac_oier-z1bg/", "difficulty": "中等", "tags": ["哈希表", "模拟"], "question": "有 `n` 个人被分成数量未知的组。每个人都被标记为一个从 $0$ 到 $n - 1$ 的唯一`ID` 。\n\n给定一个整数数组 `groupSizes`,其中 `groupSizes[i]` 是第 $i$ 个人所在的组的大小。例如,如果 `groupSizes[1] = 3`,则第 $1$ 个人必须位于大小为  $3$  的组中。\n\n返回一个组列表,使每个人 $i$ 都在一个大小为 `groupSizes[i]` 的组中。\n\n每个人应该恰好只出现在 一个组中,并且每个人必须在一个组中。如果有多个答案,返回其中任何一个。可以保证给定输入至少有一个有效的解。\n\n示例 1:\n```\n输入:groupSizes = [3,3,3,3,3,1,3]\n\n输出:[[5],[0,1,2],[3,4,6]]\n\n解释:\n第一组是 [5],大小为 1,groupSizes[5] = 1。\n第二组是 [0,1,2],大小为 3,groupSizes[0] = groupSizes[1] = groupSizes[2] = 3。\n第三组是 [3,4,6],大小为 3,groupSizes[3] = groupSizes[4] = groupSizes[6] = 3。 \n其他可能的解决方案有 [[2,1,6],[5],[0,4,3]] 和 [[5],[0,6,2],[4,3,1]]。\n```\n示例 2:\n```\n输入:groupSizes = [2,1,3,3,3,2]\n\n输出:[[1],[0,5],[2,3,4]]\n```\n\n提示:\n* $groupSizes.length == n$\n* $1 <= n <= 500$\n* $1 <= groupSizes[i] <= n$", "solution": "### 哈希表 + 模拟\n\n我们可以使用「哈希表」将所属组大小相同的下标放到一起。假设组大小为 $k$ 的元素有 $m$ 个,然后我们再将这 $m$ 个元素按照 $k$ 个一组进行划分即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public List<List<Integer>> groupThePeople(int[] gs) {\n        Map<Integer, List<Integer>> map = new HashMap<>();\n        for (int i = 0; i < gs.length; i++) {\n            List<Integer> list = map.getOrDefault(gs[i], new ArrayList<>());\n            list.add(i);\n            map.put(gs[i], list);\n        }\n        List<List<Integer>> ans = new ArrayList<>();\n        for (int k : map.keySet()) {\n            List<Integer> list = map.get(k), cur = new ArrayList<>();\n            for (int i = 0; i < list.size(); i++) {\n                cur.add(list.get(i));\n                if (cur.size() == k) {\n                    ans.add(cur);\n                    cur = new ArrayList<>();\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\nTypescript 代码:\n```Typescript\nfunction groupThePeople(gs: number[]): number[][] {\n    const map = new Map<number, Array<number>>()\n    for (let i = 0; i < gs.length; i++) {\n        if (!map.has(gs[i])) map.set(gs[i], new Array<number>())\n        map.get(gs[i]).push(i)\n    }\n    const ans = new Array<Array<number>>()\n    for (let k of map.keys()) {\n        let list = map.get(k), cur = new Array<number>()\n        for (let i = 0; i < list.length; i++) {\n            cur.push(list[i])\n            if (cur.length == k) {\n                ans.push(cur)\n                cur = new Array<number>()\n            }\n        }\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1282` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1301-1310/1302. 层数最深叶子节点的和（中等）.md", "url_title": "1302. 层数最深叶子节点的和", "url": "https://leetcode.cn/problems/deepest-leaves-sum/solution/by-ac_oier-srst/", "difficulty": "中等", "tags": ["DFS", "BFS", "树的遍历"], "question": "给你一棵二叉树的根节点 `root`,请你返回 层数最深的叶子节点的和 。\n\n示例 1:\n\n```\n输入:root = [1,2,3,4,5,null,6,7,null,null,null,null,8]\n\n输出:15\n```\n示例 2:\n```\n输入:root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5]\n\n输出:19\n```\n\n提示:\n* 树中节点数目在范围 $[1, 10^4]$ 之间。\n* $1 <= Node.val <= 100$", "solution": "### BFS\n\n使用 `BFS` 进行树的遍历,处理过程中记录最大深度 `depth` 以及使用哈希表记录每层元素和。\n\nJava 代码:\n```Java\nclass Solution {\n    public int deepestLeavesSum(TreeNode root) {\n        Map<Integer, Integer> map = new HashMap<>();\n        Deque<TreeNode> d = new ArrayDeque<>();\n        d.addLast(root);\n        int depth = 0;\n        while (!d.isEmpty()) {\n            int sz = d.size();\n            while (sz-- > 0) {\n                TreeNode node = d.pollFirst();\n                map.put(depth, map.getOrDefault(depth, 0) + node.val);\n                if (node.left != null) d.addLast(node.left);\n                if (node.right != null) d.addLast(node.right);\n            }\n            depth++;\n        }\n        return map.get(depth - 1);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction deepestLeavesSum(root: TreeNode | null): number {\n    const map: Map<number, number> = new Map<number, number>()\n    const stk: TreeNode[] = new Array<TreeNode>(10010)\n    let he = 0, ta = 0, depth = 0\n    stk[ta++] = root\n    while (he < ta) {\n        let sz = ta - he\n        while (sz-- > 0) {\n            const node = stk[he++]\n            if (!map.has(depth)) map.set(depth, 0)\n            map.set(depth, map.get(depth) + node.val)\n            if (node.left != null) stk[ta++] = node.left\n            if (node.right != null) stk[ta++] = node.right\n        }\n        depth++\n    }\n    return map.get(depth - 1)\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### DFS\n\n使用 `DFS` 进行树的遍历,处理过程中记录最大深度 `depth` 以及使用哈希表记录每层元素和。\n\nJava 代码:\n```Java\nclass Solution {\n    Map<Integer, Integer> map = new HashMap<>();\n    int max;\n    public int deepestLeavesSum(TreeNode root) {\n        dfs(root, 0);\n        return map.get(max);\n    }\n    void dfs(TreeNode root, int depth) {\n        if (root == null) return ;\n        max = Math.max(max, depth);\n        map.put(depth, map.getOrDefault(depth, 0) + root.val);\n        dfs(root.left, depth + 1);\n        dfs(root.right, depth + 1);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nconst map: Map<number, number> = new Map<number, number>()\nlet max: number\nfunction deepestLeavesSum(root: TreeNode | null): number {\n    map.clear()\n    max = 0\n    dfs(root, 0)\n    return map.get(max)\n};\nfunction dfs(root: TreeNode | null, depth: number): void {\n    if (root == null) return \n    max = Math.max(max, depth)\n    if (!map.has(depth)) map.set(depth, 0)\n    map.set(depth, map.get(depth) + root.val)\n    dfs(root.left, depth + 1)\n    dfs(root.right, depth + 1)\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1302` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1301-1310/1305. 两棵二叉搜索树中的所有元素（中等）.md", "url_title": "1305. 两棵二叉搜索树中的所有元素", "url": "https://leetcode-cn.com/problems/all-elements-in-two-binary-search-trees/solution/by-ac_oier-c8fv/", "difficulty": "中等", "tags": ["中序遍历", "归并排序"], "question": "给你 `root1` 和` root2` 这两棵二叉搜索树。请你返回一个列表,其中包含 两棵树 中的所有整数并按 升序 排序。.\n\n示例 1:\n\n```\n输入:root1 = [2,1,4], root2 = [1,0,3]\n\n输出:[0,1,1,2,3,4]\n```\n示例 2:\n\n```\n输入:root1 = [1,null,8], root2 = [8,1]\n\n输出:[1,1,8,8]\n```\n\n提示:\n* 每棵树的节点数在 $[0, 5000]$ 范围内\n* $-10^5 <= Node.val <= 10^5$", "solution": "### 中序遍历 + 归并排序\n\n利用 `BST` 中序遍历的有序性质,我们可以先对两棵树进行中序遍历,从而将树的结构转换为线性结构。\n\n将两个有序序列合并成一个有序序列则是利用了经典的「归并排序」。 \n\n代码:\n```Java\nclass Solution {\n    int INF = 0x3f3f3f3f;\n    public List<Integer> getAllElements(TreeNode root1, TreeNode root2) {\n        List<Integer> ans = new ArrayList<>();\n        List<Integer> l1 = new ArrayList<>(), l2 = new ArrayList<>();\n        dfs(root1, l1); dfs(root2, l2);\n        int n = l1.size(), m = l2.size(), i = 0, j = 0;\n        while (i < n || j < m) {\n            int a = i < n ? l1.get(i) : INF, b = j < m ? l2.get(j) : INF;\n            if (a <= b) {\n                ans.add(a); i++;\n            } else {\n                ans.add(b); j++;\n            }\n        }\n        return ans;\n    }\n    void dfs(TreeNode root, List<Integer> list) {\n        if (root == null) return ;\n        dfs(root.left, list);\n        list.add(root.val);\n        dfs(root.right, list);\n    }\n}\n```\n* 时间复杂度:令 $n$ 和 $m$ 分别为两棵树的节点数量,跑中序遍历的复杂度为 $O(n + m)$,构建答案复杂度为 $O(\\max(m, n))$。整体复杂度为 $O(n + m)$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1310` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1301-1310/1310. 子数组异或查询（中等）.md", "url_title": "1310. 子数组异或查询", "url": "https://leetcode-cn.com/problems/xor-queries-of-a-subarray/solution/gong-shui-san-xie-yi-ti-shuang-jie-shu-z-rcgu/", "difficulty": "中等", "tags": ["数学", "树状数组", "前缀和"], "question": "有一个正整数数组 arr,现给你一个对应的查询数组 queries,其中 queries[i] = [Li, Ri]。\n\n对于每个查询 i,请你计算从 Li 到 Ri 的 XOR 值(即 arr[Li] xor arr[Li+1] xor ... xor arr[Ri])作为本次查询的结果。\n\n并返回一个包含给定查询 queries 所有结果的数组。\n\n示例 1:\n```\n输入:arr = [1,3,4,8], queries = [[0,1],[1,2],[0,3],[3,3]]\n\n输出:[2,7,14,8] \n\n解释:\n数组中元素的二进制表示形式是:\n1 = 0001 \n3 = 0011 \n4 = 0100 \n8 = 1000 \n查询的 XOR 值为:\n[0,1] = 1 xor 3 = 2 \n[1,2] = 3 xor 4 = 7 \n[0,3] = 1 xor 3 xor 4 xor 8 = 14 \n[3,3] = 8\n```\n示例 2:\n```\n输入:arr = [4,8,2,10], queries = [[2,3],[1,3],[0,0],[0,3]]\n\n输出:[8,0,4,4]\n```\n\n提示:\n* 1 <= arr.length <= 3 * $10^4$\n* 1 <= arr[i] <= $10^9$\n* 1 <= queries.length <= 3 * $10^4$\n* queries[i].length == 2\n* 0 <= queries[i][0] <= queries[i][1] < arr.length", "solution": "### 基本分析\n\n令数组 `arr` 和数组 `queries` 的长度分别为 `n` 和 `m`。\n\n`n` 和 `m` 的数据范围均为 $10^4$,因此 $O(m * n)$ 的暴力做法我们不用考虑了。\n\n数据范围要求我们做到「对数复杂度」或「线性复杂度」。\n\n**本题主要利用异或运算中的「相同数值进行运算结果为 $0$」的特性。**\n\n对于特定数组 $[a1, a2, a3, ... , an]$,要求得任意区间 $[l, r]$ 的异或结果,可以通过 $[1, r]$ 和 $[1, l - 1]$ 的异或结果得出:\n\n$$\nxor(l, r) = xor(1, r) ⊕ xor(1, l - 1)\n$$\n\n**本质上还是利用集合(区间结果)的容斥原理。只不过前缀和需要利用「减法(逆运算)」做容斥,而前缀异或是利用「相同数值进行异或结果为 $0$(偶数次的异或结果为 $0$)」的特性实现容斥。**\n\n对于「区间求值」问题,之前在 [【题解】307. 区域和检索 - 数组可修改](https://leetcode-cn.com/problems/range-sum-query-mutable/solution/guan-yu-ge-lei-qu-jian-he-wen-ti-ru-he-x-41hv/) 也做过总结。\n\n针对不同的题目,有不同的方案可以选择(假设有一个数组):\n\n1. 数组不变,求区间和:「前缀和」、「树状数组」、「线段树」\n2. 多次修改某个数,求区间和:「树状数组」、「线段树」\n3. 多次整体修改某个区间,求区间和:「线段树」、「树状数组」(看修改区间的数据范围)\n4. 多次将某个区间变成同一个数,求区间和:「线段树」、「树状数组」(看修改区间的数据范围)\n\n虽然「线段树」能解决的问题最多,但「线段树」代码很长,且常数很大,实际表现不算好。我们只有在不得不用的情况下才考虑「线段树」。\n\n本题我们使用「树状数组」和「前缀和」来求解。\n\n---\n\n### 树状数组\n\n使用「树状数组」分段记录我们某些区间的「异或结果」,再根据 `queries` 中的询问将分段「异或结果」汇总(执行异或运算),得出最终答案。\n\n代码:\n```Java\nclass Solution {\n    int n;\n    int[] c = new int[100009];\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void add(int x, int u) {\n        for (int i = x; i <= n; i += lowbit(i)) c[i] ^= u;\n    }\n    int query(int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans ^= c[i];\n        return ans;\n    }\n    public int[] xorQueries(int[] arr, int[][] qs) {\n        n = arr.length;\n        int m = qs.length;\n        for (int i = 1; i <= n; i++) add(i, arr[i - 1]);\n        int[] ans = new int[m];\n        for (int i = 0; i < m; i++) {\n            int l = qs[i][0] + 1, r = qs[i][1] + 1;\n            ans[i] = query(r) ^ query(l - 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 `arr` 数组长度为 `n`,`qs` 数组的长度为 `m`。创建树状数组复杂度为 $O(n\\log{n})$;查询的复杂度为 $O(m\\log{n})$。整体复杂度为 $O((n + m) \\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 前缀异或\n\n「树状数组」的查询复杂度为 $O(\\log{n})$,而本题其实不涉及「修改操作」,我们可以使用「前缀异或」来代替「树状数组」。\n\n虽说「树状数组」也有 $O(n)$ 的创建方式,但这里使用「前缀异或」主要是为了降低查询的复杂度。\n\n代码:\n```Java\nclass Solution {\n    public int[] xorQueries(int[] arr, int[][] qs) {\n        int n = arr.length, m = qs.length;\n        int[] sum = new int[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] ^ arr[i - 1];\n        int[] ans = new int[m];\n        for (int i = 0; i < m; i++) {\n            int l = qs[i][0] + 1, r = qs[i][1] + 1;\n            ans[i] = sum[r] ^ sum[l - 1];\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 `arr` 数组长度为 `n`,`qs` 数组的长度为 `m`。预处理前缀和数组复杂度为 $O(n)$;查询的复杂度为 $O(m)$。整体复杂度为 $O(n + m)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1310` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/131-140/131. 分割回文串（中等）.md", "url_title": "131. 分割回文串", "url": "https://leetcode-cn.com/problems/palindrome-partitioning/solution/wei-sha-yao-zhe-yang-bao-sou-ya-shi-ru-h-41gf/", "difficulty": "中等", "tags": ["回文串", "回溯算法", "动态规划"], "question": "给你一个字符串 `s`,请你将 `s` 分割成一些子串,使每个子串都是回文串。\n\n返回 `s` 所有可能的分割方案。\n\n回文串是正着读和反着读都一样的字符串。\n\n示例 1:\n```\n输入:s = \"aab\"\n输出:[[\"a\",\"a\",\"b\"],[\"aa\",\"b\"]]\n```\n示例 2:\n```\n输入:s = \"a\"\n输出:[[\"a\"]]\n```\n\n提示:\n* $1 <= s.length <= 16$\n* `s` 仅由小写英文字母组成", "solution": "### 动态规划 + 回溯算法\n\n求所有的分割方案,凡是求所有方案的题基本上都没有什么优化方案,就是「爆搜」。\n\n问题在于,爆搜什么?显然我们可以爆搜每个回文串的起点。如果有连续的一段是回文串,我们再对剩下连续的一段继续爆搜。\n\n为什么能够直接接着剩下一段继续爆搜?\n\n因为任意的子串最终必然能够分割成若干的回文串(最坏的情况下,每个回文串都是一个字母)。\n\n所以我们每次往下爆搜时,只需要保证自身连续一段是回文串即可。\n\n举个🌰 来感受下我们的爆搜过程,假设有样例 `abababa`,刚开始我们从起点第一个 a 进行爆搜:\n\n1. 发现 `a` 是回文串,先将 `a` 分割出来,再对剩下的 `bababa` 进行爆搜\n2. 发现 `aba` 是回文串,先将 `aba` 分割出来,再对剩下的 `baba` 进行爆搜\n3. 发现 `ababa` 是回文串,先将 `ababa` 分割出来,再对剩下的 `ba` 进行爆搜\n4. 发现 `abababa` 是回文串,先将 `abababa` 分割出来,再对剩下的 `` 进行爆搜\n\n...\n\n然后再对下一个起点(下个字符) `b` 进行爆搜?\n\n不需要。\n\n因为单个字符本身构成了回文串,所以以 `b` 为起点,`b` 之前构成回文串的方案,必然覆盖在我们以第一个字符为起点所展开的爆搜方案内(在这里就是对应了上述的第一步所展开的爆搜方案中)。\n\n**因此我们只需要以首个字符为起点,枚举以其开头所有的回文串方案,加入集合,然后对剩下的字符串部分继续爆搜。就能做到以任意字符作为回文串起点进行分割的效果了。**\n\n一定要好好理解上面那句话 ~ \n\n剩下的问题是,我们如何快速判断连续一段 `[i, j]` 是否为回文串,因为爆搜的过程每个位置都可以作为分割点,复杂度为 $O(2^n)$ 的。\n\n因此我们不可能每次都使用双指针去线性扫描一遍 `[i, j]` 判断是否回文。\n\n一个直观的做法是,我们先预处理除所有的 `f[i][j]`,`f[i][j]` 代表 `[i, j]` 这一段是否为回文串。\n\n预处理 `f[i][j]` 的过程可以用递推去做。\n\n要想 `f[i][j] == true` ,必须满足以下两个条件:\n\n1. `f[i + 1][j - 1] == true`\n2. `s[i] == s[j]`\n\n由于状态 `f[i][j]` 依赖于状态 `f[i + 1][j - 1]`,因此需要我们左端点 `i` 是**从大到小**进行遍历;而右端点 `j` 是**从小到大**进行遍历。\n\n因此,我们的遍历过程可以整理为:**右端点 `j` 一直往右移动(从小到大),在 `j` 固定情况下,左端点 `i` 在 `j` 在左边开始,一直往左移动(从大到小)**\n\nJava 代码:\n```Java\nclass Solution {\n    public List<List<String>> partition(String s) {\n        int n = s.length();\n        char[] cs = s.toCharArray();\n        // f[i][j] 代表 [i, j] 这一段是否为回文串\n        boolean[][] f = new boolean[n][n];\n        for (int j = 0; j < n; j++) {\n            for (int i = j; i >= 0; i--) {\n                // 当 [i, j] 只有一个字符时,必然是回文串\n                if (i == j) {\n                    f[i][j] = true;\n                } else {\n                    // 当 [i, j] 长度为 2 时,满足 cs[i] == cs[j] 即回文串\n                    if (j - i + 1 == 2) {\n                        f[i][j] = cs[i] == cs[j];\n\n                    // 当 [i, j] 长度大于 2 时,满足 (cs[i] == cs[j] && f[i + 1][j - 1]) 即回文串\n                    } else {\n                        f[i][j] = cs[i] == cs[j] && f[i + 1][j - 1];\n                    }\n                }\n            }\n        }\n        List<List<String>> ans = new ArrayList<>();\n        List<String> cur = new ArrayList<>();\n        dfs(s, 0, ans, cur, f);\n        return ans;\n    }\n    /**\n     * s: 要搜索的字符串\n     * u: 以 s 中的那一位作为回文串分割起点\n     * ans: 最终结果集\n     * cur: 当前结果集\n     * f: 快速判断 [i,j] 是否为回文串\n     */\n    void dfs(String s, int u, List<List<String>> ans, List<String> cur, boolean[][] f) {\n        int n = s.length();\n        if (u == n) ans.add(new ArrayList<>(cur));\n        for (int i = u; i < n; i++) {\n            if (f[u][i]) {\n                cur.add(s.substring(u, i + 1));\n                dfs(s, i + 1, ans, cur, f);\n                cur.remove(cur.size() - 1);\n            }\n        }\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<vector<string>> partition(string s) {\n        int n = s.length();\n        vector<vector<string>> ans;\n        vector<string> cur;\n        vector<vector<bool>> f(n, vector<bool>(n, false));\n        for (int j = 0; j < n; j++) {\n            for (int i = j; i >= 0; i--) {\n                if (i == j) {\n                    f[i][j] = true;\n                } else if (j - i + 1 == 2) {\n                    f[i][j] = s[i] == s[j];\n                } else {\n                    f[i][j] = s[i] == s[j] && f[i + 1][j - 1];\n                }\n            }\n        }\n        dfs(s, 0, ans, cur, f);\n        return ans;\n    }\n    void dfs(string& s, int u, vector<vector<string>>& ans, vector<string>& cur, vector<vector<bool>>& f) {\n        int n = s.length();\n        if (u == n) ans.push_back(cur);\n        for (int i = u; i < n; i++) {\n            if (f[u][i]) {\n                cur.push_back(s.substr(u, i - u + 1));\n                dfs(s, i + 1, ans, cur, f);\n                cur.pop_back();\n            }\n        }\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def partition(self, s: str) -> List[List[str]]:\n        def dfs(s: str, u: int, ans: List[List[str]], cur: List[str], f: List[List[bool]]):\n            n = len(s)\n            if u == n:\n                ans.append(cur[:])\n            for i in range(u, n):\n                if f[u][i]:\n                    cur.append(s[u:i + 1])\n                    dfs(s, i + 1, ans, cur, f)\n                    cur.pop()\n\n        n = len(s)\n        ans, cur = [], []\n        f = [[False] * n for _ in range(n)]\n        for j in range(n):\n            for i in range(j, -1, -1):\n                if i == j:\n                    f[i][j] = True\n                elif j - i + 1 == 2:\n                    f[i][j] = s[i] == s[j]\n                else:\n                    f[i][j] = s[i] == s[j] and f[i + 1][j - 1]\n        dfs(s, 0, ans, cur, f)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction partition(s: string): string[][] {\n    const dfs = function(s: string, u: number, ans: string[][], cur: string[], f: boolean[][]): void {\n        const n = s.length;\n        if (u == n) ans.push([...cur]);\n        for (let i = u; i < n; i++) {\n            if (f[u][i]) {\n                cur.push(s.substring(u, i + 1));\n                dfs(s, i + 1, ans, cur, f);\n                cur.pop();\n            }\n        }\n    };\n    const n = s.length;\n    const ans = [], cur = [];\n    const f = Array.from({ length: n }, () => Array(n).fill(false));\n    for (let j = 0; j < n; j++) {\n        for (let i = j; i >= 0; i--) {\n            if (i == j) {\n                f[i][j] = true;\n            } else if (j - i + 1 === 2) {\n                f[i][j] = s[i] == s[j];\n            } else {\n                f[i][j] = s[i] == s[j] && f[i + 1][j - 1];\n            }\n        }\n    }\n    dfs(s, 0, ans, cur, f);\n    return ans;\n};\n```\n* 时间复杂度:动态规划预处理的复杂度为 $O(n^2)$;爆搜过程中每个字符都可以作为分割点,并且有分割与不分割两种选择,方案数量为 $2^{n - 1}$,每个字符都需要往后检查剩余字符的分割情况,复杂度为 $O(n)$。整体复杂度为 $O(n \\times 2^n)$\n* 空间复杂度:动态规划部分的复杂度为 $O(n^2)$;方案数量最多为 $2^{n - 1}$,每个方案都是完整字符串 `s` 的分割,复杂度为 $O(n)$,整体复杂度为 $O(n \\times 2^n)$\n\n---\n\n### 总结\n\n对于此类要枚举所有方案的题目,我们都应该先想到「回溯算法」。\n\n「回溯算法」从算法定义上来说,不一定要用 DFS 实现,但通常结合 DFS 来做,难度是最低的。\n\n「回溯算法」根据当前决策有多少种选择,对应了两套模板。\n\n每一次独立的决策只对应 选择 和 不选 两种情况:\n\n1. 确定结束回溯过程的 base case\n\n2. 遍历每个位置,对每个位置进行决策(做选择 -> 递归 -> 撤销选择)\n\n```java\nvoid dfs(当前位置, 路径(当前结果), 结果集) {\n    if (当前位置 == 结束位置) {\n        结果集.add(路径);\n        return;\n    }\n        \n    选择当前位置;    \n    dfs(下一位置, 路径(当前结果), 结果集);\n    撤销选择当前位置;\n    dfs(下一位置, 路径(当前结果), 结果集);\n}\n```\n\n每一次独立的决策都对应了多种选择(通常对应了每次决策能选择什么,或者每次决策能选择多少个 ...):\n\n1. 确定结束回溯过程的 base case\n\n2. 遍历所有的「选择」\n\n3. 对选择进行决策 (做选择 -> 递归 -> 撤销选择)\n\n```java\nvoid dfs(选择列表, 路径(当前结果), 结果集) {\n    if (满足结束条件) {\n        结果集.add(路径);\n        return;\n    }\n        \n    for (选择 in 选择列表) {\n        做选择;\n        dfs(路径’, 选择列表, 结果集);\n        撤销选择;\n    }\n}\n```", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.131` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/131-140/132. 分割回文串 II（困难）.md", "url_title": "132. 分割回文串 II", "url": "https://leetcode-cn.com/problems/palindrome-partitioning-ii/solution/xiang-jie-liang-bian-dong-tai-gui-hua-ji-s5xr/", "difficulty": "困难", "tags": ["回文串", "线性 DP"], "question": "给你一个字符串 `s`,请你将 `s` 分割成一些子串,使每个子串都是回文。\n\n返回符合要求的 最少分割次数 。\n\n示例 1:\n```\n输入:s = \"aab\"\n输出:1\n解释:只需一次分割就可将 s 分割成 [\"aa\",\"b\"] 这样两个回文子串。\n```\n示例 2:\n```\n输入:s = \"a\"\n输出:0\n```\n示例 3:\n```\n输入:s = \"ab\"\n输出:1\n```\n\n提示:\n* $1 <= s.length <= 2000$\n* `s` 仅由小写英文字母组成", "solution": "### 动态规划\n\n如果在 [131. 分割回文串](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487047&idx=1&sn=117c48f20778868442fce44e100d2ea8&chksm=fd9ca558caeb2c4eb1bff4f0878ff796feabe523657c2aafea0b2d1c7026e1c0572ab1e6d205&token=635532356&lang=zh_CN#rd) 你有使用到 DP 进行预处理的话。\n\n这道题就很简单了,就是一道常规的动态规划题。\n\n为了方便,我们约定所有下标从 $1$ 开始。\n\n即对于长度为 $n$ 的字符串,我们使用 $[1,n]$ 进行表示。估计不少看过三叶题解的同学都知道,这样做的目的是为了减少边界情况判断,这本身也是对于「哨兵」思想的运用。\n\n* **递推「最小分割次数」思路**\n\n我们定义 $f[r]$ 为将 $[1,r]$ 这一段字符分割为若干回文串的最小分割次数,那么最终答案为 $f[n]$。\n\n不失一般性的考虑 $f[r]$ 如何转移:\n\n1. 从「起点字符」到「第 $r$ 个字符」能形成回文串。那么最小分割次数为 0,此时有 $f[r] = 0$\n2. 从「起点字符」到「第 $r$ 个字符」不能形成回文串。此时我们需要枚举左端点 $l$,如果 $[l,r]$ 这一段是回文串的话,那么有 $f[r] = f[l - 1] + 1$\n\n在 $2$ 中满足回文要求的左端点位置 $l$ 可能有很多个,我们在所有方案中取一个 $\\min$ 即可。\n\n* **快速判断「任意一段子串是否回文」思路**\n\n剩下的问题是,我们如何快速判断连续一段 $[l, r]$ 是否为回文串,做法和昨天的 [131. 分割回文串](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487047&idx=1&sn=117c48f20778868442fce44e100d2ea8&chksm=fd9ca558caeb2c4eb1bff4f0878ff796feabe523657c2aafea0b2d1c7026e1c0572ab1e6d205&token=635532356&lang=zh_CN#rd)  一模一样。\n\n*PS. 在 [131. 分割回文串](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487047&idx=1&sn=117c48f20778868442fce44e100d2ea8&chksm=fd9ca558caeb2c4eb1bff4f0878ff796feabe523657c2aafea0b2d1c7026e1c0572ab1e6d205&token=635532356&lang=zh_CN#rd),数据范围只有 $16$,因此我们可以不使用 DP 进行预处理,而是使用双指针来判断是否回文也能过。但是该题数据范围为 $2000$(数量级为 $10^3$),使用朴素做法判断是否回文的话,复杂度会去到 $O(n^3)$(计算量为 $10^9$),必然超时。*\n\n因此我们不可能每次都使用双指针去线性扫描一遍 $[l, r]$ 判断是否回文。\n\n一个合理的做法是,我们先预处理出所有的 $g[l][r]$,$g[l][r]$ 代表 $[l,r]$ 这一段是否为回文串。\n\n预处理  $g[l][r]$ 的过程可以用递推去做。\n\n要想  $g[l][r] = true$ ,必须满足以下两个条件:\n\n1. $g[l + 1][r - 1] = true$\n2. $s[i] = s[j]$\n\n由于状态 $f[l][r]$ 依赖于状态 $f[l + 1][r - 1]$,因此需要我们左端点 $l$ 是「从大到小」进行遍历;而右端点 $r$ 是「从小到大」进行遍历。\n\n因此最终的遍历过程可以整理为:**右端点 $r$ 一直往右移动(从小到大),在 $r$  固定情况下,左端点 $l$ 在 $r$ 在左边开始,一直往左移动(从大到小)**\n\n代码:\n```Java\nclass Solution {\n    public int minCut(String s) {\n        int n = s.length();\n        char[] cs = s.toCharArray();\n\n        // g[l][r] 代表 [l,r] 这一段是否为回文串\n        boolean[][] g = new boolean[n + 1][n + 1];\n        for (int r = 1; r <= n; r++) {\n            for (int l = r; l >= 1; l--) {\n                // 如果只有一个字符,则[l,r]属于回文\n                if (l == r) {\n                    g[l][r] = true;\n                } else {\n                    // 在 l 和 r 字符相同的前提下\n                    if (cs[l - 1] == cs[r - 1]) {\n                        // 如果 l 和 r 长度只有 2;或者 [l+1,r-1] 这一段满足回文,则[l,r]属于回文\n                        if (r - l == 1 || g[l + 1][r - 1]) {\n                            g[l][r] = true;\n                        }\n                    }\n                }\n            }\n        }\n\n        // f[r] 代表将 [1,r] 这一段分割成若干回文子串所需要的最小分割次数\n        int[] f = new int[n + 1];\n        for (int r = 1; r <= n; r++) {\n            // 如果 [1,r] 满足回文,不需要分割\n            if (g[1][r]) {\n                f[r] = 0;\n            } else {\n                // 先设定一个最大分割次数(r 个字符最多消耗 r - 1 次分割)\n                f[r] = r - 1;\n                // 在所有符合 [l,r] 回文的方案中取最小值\n                for (int l = 1; l <= r; l++) {\n                    if (g[l][r]) f[r] = Math.min(f[r], f[l - 1] + 1);\n                }   \n            }\n        }\n\n        return f[n];\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 关于「如何确定 DP 状态定义」的分享\n\n有同学会对「如何确定 DP 的状态定义」有疑问,觉得自己总是定不下 DP 的状态定义。\n\n首先,十分正常,不用担心。\n\nDP 的状态定义,基本上是考经验的(猜的),猜对了 DP 的状态定义,基本上「状态转移方程」就是呼之欲出。\n\n虽然大多数情况都是猜的,但也不是毫无规律,相当一部分是定义是与「结尾」和「答案」有所关联的。\n\n**例如本题定义 $f[i]$ 为以下标为 $i$ 的字符作为结尾(结尾)的最小分割次数(答案)。**\n\n因此对于那些你没见过的 DP 模型题,可以从这两方面去「猜」。\n\n---\n\n### Manacher 算法(非重要补充)\n\n如果你还学有余力的话,可以看看下面这篇题解。\n\n提供了「回文串」问题的究极答案:Manacher 算法。\n\n由于 Manacher 算法较为局限,只能解决「回文串」问题,远不如 KMP 算法使用广泛,**不建议大家深究原理,而是直接当做「模板」背过。**\n\n背过这样的算法的意义在于:相当于大脑里有了一个时间复杂度为 $O(n)$ 的 api 可以使用,这个 api 传入一个字符串,返回该字符串的最大回文子串。\n\n[回文串问题的究极答案:Manacher 算法](https://leetcode-cn.com/problems/longest-palindromic-substring/solution/shua-chuan-lc-po-su-jie-fa-manacher-suan-i2px/)\n\n**如果觉得自己背不下来,也没有问题。事实上我还没有见过必须使用 Manacher 算法才能过的回文串题。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.132` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/131-140/134. 加油站（中等）.md", "url_title": "134. 加油站", "url": "https://leetcode-cn.com/problems/gas-station/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-zsgqp/", "difficulty": "中等", "tags": ["DFA", "KMP"], "question": "在一条环路上有 `N` 个加油站,其中第 `i` 个加油站有汽油 `gas[i]` 升。\n\n你有一辆油箱容量无限的的汽车,从第 `i` 个加油站开往第 `i+1` 个加油站需要消耗汽油 `cost[i]` 升。你从其中的一个加油站出发,开始时油箱为空。\n\n如果你可以绕环路行驶一周,则返回出发时加油站的编号,否则返回 `-1`。\n\n说明: \n* 如果题目有解,该答案即为唯一答案。\n* 输入数组均为非空数组,且长度相同。\n* 输入数组中的元素均为非负数。\n\n示例 1:\n\n```\n输入: \ngas  = [1,2,3,4,5]\ncost = [3,4,5,1,2]\n\n输出: 3\n\n解释:\n从 3 号加油站(索引为 3 处)出发,可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油\n开往 4 号加油站,此时油箱有 4 - 1 + 5 = 8 升汽油\n开往 0 号加油站,此时油箱有 8 - 2 + 1 = 7 升汽油\n开往 1 号加油站,此时油箱有 7 - 3 + 2 = 6 升汽油\n开往 2 号加油站,此时油箱有 6 - 4 + 3 = 5 升汽油\n开往 3 号加油站,你需要消耗 5 升汽油,正好足够你返回到 3 号加油站。\n因此,3 可为起始索引。\n```\n示例 2:\n```\n输入: \ngas  = [2,3,4]\ncost = [3,4,3]\n\n输出: -1\n\n解释:\n你不能从 0 号或 1 号加油站出发,因为没有足够的汽油可以让你行驶到下一个加油站。\n我们从 2 号加油站出发,可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油\n开往 0 号加油站,此时油箱有 4 - 3 + 2 = 3 升汽油\n开往 1 号加油站,此时油箱有 3 - 3 + 3 = 3 升汽油\n你无法返回 2 号加油站,因为返程需要消耗 4 升汽油,但是你的油箱只有 3 升汽油。\n因此,无论怎样,你都不可能绕环路行驶一周。\n```", "solution": "### 基本分析/朴素解法\n\n这是一道比较经典的题目。\n\n估计在 LeetCode 也是有一段时间了,所以连数据范围都没有。\n\n我这里直接规定一下数据范围为 $10^5$,这意味着我们不能使用 $O(n^2)$ 做法了。\n\n但朴素做法往往是优化的出发点,所以我们还是先分析一下,朴素的做法是怎么样的:\n\n* 题目要求「合法起点」的下标,因此我们可以枚举所有的「起点」\n\n* 然后按照「油量 & 成本」模拟一遍,看是否能走完一圈\n\n共有 $n$ 个「起点」,检查某个「起点」合法性的复杂度是 $O(n)$ 的。因此整体复杂度为 $O(n^2)$ 的。\n\n代码:\n\n```java\nclass Solution {\n    public int canCompleteCircuit(int[] gas, int[] cost) {\n        int n = gas.length;\n        for (int start = 0; start < n; start++) {\n            // 直接跳过第一步都不满足的起点\n            if (gas[start] < cost[start]) continue;\n            // 剩余油量\n            int cur = gas[start] - cost[start];\n            // 所在位置\n            int idx = (start + 1) % n;\n            while (idx != start) {\n                cur += gas[idx] - cost[idx];\n                // 如果剩余油量为负数,说明无法离开当前位置,走到下一位置\n                if (cur < 0) break;\n                idx = (idx + 1) % n;\n            }\n            if (idx == start) return start;\n        }\n        return -1;\n    }\n}\n```\n\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(1)$\n\nPS. 在 LeetCode 上提交了一下,是可以过的 🤣\n\n---\n\n### KMP \n\n不考虑我们跳过那些第一步就不满足的起点的话,将上述解法中的两个主要逻辑“单独”拎出来看,都是无法优化的:\n\n* 在没做任何操作之前,我们无法知道哪些起点是不合法的\n* 没有比 $O(n)$ 更低的复杂度可以验证一个起点的合法性\n\n因此只能使用 $O(n^2)$ 解法?\n\n并不是。单独看无法优化,合在一起则可以:**随着某个起点「合法性验证」失败,我们可以否决掉一些「必然不合法」的方案。**\n\n什么意思呢?\n\n在朴素解法中,当我们验证了某个起点 $i$ 失败(无法走完一圈)之后,我们接下来会去尝试验证起点 $i + 1$。\n\n**这时候验证 $i$ 失败过程中产生的“信息”,其实并没有贡献到之后的算法中。**\n\n事实上,起点 $i$ 验证失败,其实是意味存在某个位置 $k$ 使得「当前油量」为负数。而这个位置 $k$ 就是验证起点 $i$ 这过程中产生的“信息”。\n\n它可以产生的价值是:**在位置 $i$ 和位置 $k$ 之间的所有位置,都不可能是一个合法起点。也就是说,随着起点 $i$ 验证失败,我们可以否决掉方案不仅仅是位置 $i$,而是 $[i, k]$ 这些位置。**\n\n我们可以证明为什么会有这样的性质:\n\n首先,可以明确的是:**因为 `gas` 数组和 `cost` 数组是给定的,因此每个位置的「净消耗」是固定的,与从哪个「起点」出发无关。**\n\n净消耗是指该位置提供的「油量」和「到达下一位置的油耗」,也就是 `gas[i]` 和 `cast[i]` 之间的差值。\n\n证明过程如图:\n\n因此,当有了这个优化之后,我们每个位置其实只会被遍历常数次:**当位置 $i$ 作为「起点」验证失败后,验证过程中遍历过的位置就不需要再作为「起点」被验证了。**\n\n代码:\n\n```Java \nclass Solution {\n    public int canCompleteCircuit(int[] gas, int[] cost) {\n        int n = gas.length;\n        for (int start = 0; start < n; ) {\n            if (gas[start] < cost[start]) {\n                start++;\n            } else {\n                int cur = gas[start] - cost[start];\n                int idx = start + 1;\n                while (idx % n != start) {\n                    cur += gas[idx % n] - cost[idx % n];\n                    if (cur < 0) break;\n                    idx++;\n                }\n                if (idx % n == start) return start;\n                else start = idx;\n            }\n        }\n        return -1;\n    }\n}\n```\n\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 总结\n\n看到这里,你可以已经理解了 $O(n)$ 解法是怎么来的了。\n\n但可能还不清楚这个优化思路的本质是什么,其实这个优化的本质与 KMP 为什么可以做到线性匹配如出一辙。\n\n**本质都是利用某次匹配(验证)过程产生的“信息”,来加速之后的匹配(验证)过程(否决掉一些必然合法的方案)。**\n\n在我写过的 [KMP](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486317&idx=1&sn=9c2ff2fa5db427133cce9c875064e7a4&chksm=fd9ca072caeb29642bf1f5c151e4d5aaff4dc10ba408b23222ea1672cfc41204a584fede5c05&token=1279910339&lang=zh_CN#rd) 题解里,有这么一句原话:\n\n> 当我们的原串指针从 `i` 位置后移到 `j` 位置,不仅仅代表着「原串」下标范围为 $[i,j)$ 的字符与「匹配串」匹配或者不匹配,更是在否决那些以「原串」下标范围为 $[i,j)$ 为「匹配发起点」的子集。\n\n所以,从更本质的角度出发,这道题其实是一道「KMP」思想应用题,或者说广泛性的「DFA」题。\n\n---\n\n### 其他\n\n在写「总结」部分的时候,我还特意去看了一下题解区,没有人提到过「KMP」和「DFA」,几乎所有题解都停留在题目标签「贪心算法」的角度去思考。\n\n这是不对的,题目标签的拟定很大程度取决于「写这个标签的人的水平」和「ta 当时看这道题的思考角度」,是一个主观的结果。\n\n**学习算法和数据结构,应该是去理解每个算法和数据结构的“某个操作”为什么能够带来优化效果,并将该优化效果的“底层思想”挖掘出来,应用到我们没见过的问题中,这才是真正的“学习”。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.134` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/131-140/137. 只出现一次的数字 II（中等）.md", "url_title": "137. 只出现一次的数字 II", "url": "https://leetcode-cn.com/problems/single-number-ii/solution/gong-shui-san-xie-yi-ti-san-jie-ha-xi-bi-fku8/", "difficulty": "中等", "tags": ["哈希表", "位运算"], "question": "给你一个整数数组 `nums`,除某个元素仅出现一次外,其余每个元素都恰出现三次。请你找出并返回那个只出现了一次的元素。\n\n示例 1:\n```\n输入:nums = [2,2,3,2]\n\n输出:3\n```\n示例 2:\n```\n输入:nums = [0,1,0,1,0,1,99]\n\n输出:99\n```\n\n提示:\n* $1 <= nums.length <= 3 \\times 10^4$\n* $-2^{31} <= nums[i] <= 2^{31} - 1$\n* `nums` 中,除某个元素仅出现 一次 外,其余每个元素都恰出现 三次\n\n进阶:你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗?", "solution": "### 哈希表\n\n一个朴素的做法是使用「哈希表」进行计数,然后将计数为 $1$ 的数字进行输出。\n\n哈希表以「数值 : 数值出现次数」形式进行存储。\n\n代码:\n```Java\nclass Solution {\n    public int singleNumber(int[] nums) {\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int x : nums) {\n            map.put(x, map.getOrDefault(x, 0) + 1);\n        }\n        for (int x : map.keySet()) {\n            if (map.get(x) == 1) return x;\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 位数统计 \n\n哈希表解法的空间复杂度是 $O(n)$ 的,而题目的【进阶】部分提到应当使用常数空间来做。\n\n其中一个比较容易想到的做法,是利用 $int$ 类型固定为 $32$ 位。\n\n**使用一个长度为 $32$ 的数组 $cnt[]$ 记录下所有数值的每一位共出现了多少次 $1$,再对 $cnt[]$ 数组的每一位进行 $mod$ $3$ 操作,重新拼凑出只出现一次的数值。**\n\n举个 🌰,考虑样例 `[1,1,1,3]`,$1$ 和 $3$ 对应的二进制表示分别是 `00..001` 和 `00..011`,存入 $cnt[]$ 数组后得到 `[0,0,...,0,1,4]`。进行 $mod$ $3$ 操作后得到 `[0,0,...,0,1,1]`,再转为十进制数字即可得「只出现一次」的答案 $3$。\n\n代码:\n```Java\nclass Solution {\n    public int singleNumber(int[] nums) {\n        int[] cnt = new int[32];\n        for (int x : nums) {\n            for (int i = 0; i < 32; i++) {\n                if (((x >> i) & 1) == 1) {\n                    cnt[i]++;\n                }\n            }\n        }\n        int ans = 0;\n        for (int i = 0; i < 32; i++) {\n            if ((cnt[i] % 3 & 1) == 1) {\n                ans += (1 << i);\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### DFA\n\n如果我们考虑「除了某个元素只出现一次以外,其余每个元素均出现两次」的情况,那么可以使用「异或」运算。\n\n利用相同数异或为 0 的性质,可以帮助我们很好实现状态切换:\n\n本题是考虑「除了某个元素只出现一次以外,其余每个元素均出现三次」的情况,那么对应了「出现 0 次」、「出现 1 次」和「出现 2 次」三种状态,意味着至少需要两位进行记录,且状态转换关系为:\n\n那么如何将上述 DFA 用表达式表示出来呢?有以下几种方法:\n\n1. 用「真值表」写出「逻辑函数表达式」可参考 [这里](https://wenku.baidu.com/view/e9460ad96729647d27284b73f242336c1eb930f0.html),化简过程可以参考 [卡诺图化简法](https://baike.baidu.com/item/%E5%8D%A1%E8%AF%BA%E5%9B%BE%E5%8C%96%E7%AE%80%E6%B3%95) 。\n\n2. 把结论记住(这是一道经典的 DFA 入门题)。\n\n3. 硬做,位运算也就那几种,不会「数字电路」也记不住「结论」,砸时间看着真值表不断调逻辑也是可以写出来的。\n\n代码:\n```Java\nclass Solution {\n    public int singleNumber(int[] nums) {\n        int one = 0, two = 0;\n        for(int x : nums){\n            one = one ^ x & ~two;\n            two = two ^ x & ~one;\n        }\n        return one;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.137` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/131-140/138. 复制带随机指针的链表（中等）.md", "url_title": "138. 复制带随机指针的链表", "url": "https://leetcode-cn.com/problems/copy-list-with-random-pointer/solution/gong-shui-san-xie-yi-ti-shuang-jie-ha-xi-pqek/", "difficulty": "中等", "tags": ["哈希表", "链表"], "question": "给你一个长度为 `n` 的链表,每个节点包含一个额外增加的随机指针 `random`,该指针可以指向链表中的任何节点或空节点。\n\n构造这个链表的 深拷贝。 深拷贝应该正好由 `n` 个 全新 节点组成,其中每个新节点的值都设为其对应的原节点的值。新节点的 `next` 指针和 `random` 指针也都应指向复制链表中的新节点,并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。\n\n例如,如果原链表中有 `X` 和 `Y` 两个节点,其中 `X.random --> Y` 。那么在复制链表中对应的两个节点 `x` 和 `y` ,同样有 `x.random --> y` 。\n\n返回复制链表的头节点。\n\n用一个由 `n` 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 `[val, random_index]` 表示:\n\n* `val`:一个表示 `Node.val` 的整数。\n* `random_index`:随机指针指向的节点索引(范围从 $0$ 到 $n-1$);如果不指向任何节点,则为  `null` 。\n\n你的代码 只 接受原链表的头节点 `head` 作为传入参数。\n\n \n\n示例 1:\n\n```\n输入:head = [[7,null],[13,0],[11,4],[10,2],[1,0]]\n\n输出:[[7,null],[13,0],[11,4],[10,2],[1,0]]\n```\n示例 2:\n\n```\n输入:head = [[1,1],[2,1]]\n\n输出:[[1,1],[2,1]]\n```\n示例 3:\n\n```\n输入:head = [[3,null],[3,0],[3,null]]\n\n输出:[[3,null],[3,0],[3,null]]\n```\n示例 4:\n```\n输入:head = []\n\n输出:[]\n\n解释:给定的链表为空(空指针),因此返回 null。\n```\n\n提示:\n* $0 <= n <= 1000$\n* $-10000 <= Node.val <= 10000$", "solution": "### 模拟 + 哈希表\n\n如果不考虑 `random` 指针的话,对一条链表进行拷贝,我们只需要使用两个指针:一个用于遍历原链表,一个用于构造新链表(始终指向新链表的尾部)即可。这一步操作可看做是「创建节点 + 构建 `next` 指针关系」。\n\n现在在此基础上增加一个 `random` 指针,我们可以将 `next` 指针和 `random` 指针关系的构建拆开进行:\n\n1. 先不考虑 `random` 指针,和原本的链表复制一样,创建新新节点,并构造 `next` 指针关系,同时使用「哈希表」记录原节点和新节点的映射关系;\n2. 对原链表和新链表进行同时遍历,对于原链表的每个节点上的 `random` 都通过「哈希表」找到对应的新 `random` 节点,并在新链表上构造 `random` 关系。\n\n代码:\n```Java\nclass Solution {\n    public Node copyRandomList(Node head) {\n        Node t = head;\n        Node dummy = new Node(-10010), cur = dummy;\n        Map<Node, Node> map = new HashMap<>();\n        while (head != null) {\n            Node node = new Node(head.val);\n            map.put(head, node);\n            cur.next = node;\n            cur = cur.next; head = head.next;\n        }\n        cur = dummy.next; head = t;\n        while (head != null) {\n            cur.random = map.get(head.random);\n            cur = cur.next; head = head.next;\n        }\n        return dummy.next;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 模拟(原地算法)\n\n显然时间复杂度上无法优化,考虑如何降低空间(不使用「哈希表」)。\n\n我们使用「哈希表」的目的为了实现原节点和新节点的映射关系,更进一步的是为了快速找到某个节点 `random` 在新链表的位置。\n\n那么我们可以利用原链表的 `next` 做一个临时中转,从而实现映射。\n\n具体的,我们可以按照如下流程进行:\n\n1. 对原链表的每个节点节点进行复制,并追加到原节点的后面;\n2. 完成 $1$ 操作之后,链表的奇数位置代表了原链表节点,链表的偶数位置代表了新链表节点,且每个原节点的 `next` 指针执行了对应的新节点。这时候,我们需要构造新链表的 `random` 指针关系,可以利用 `link[i + 1].random = link[i].random.next`,$i$ 为奇数下标,含义为 **新链表节点的 `random` 指针指向旧链表对应节点的 `random` 指针的下一个值**;\n3. 对链表进行拆分操作。\n\n代码:\n```Java\nclass Solution {\n    public Node copyRandomList(Node head) {\n        if (head == null) return head;\n        Node t = head;\n        while (head != null) {\n            Node node = new Node(head.val);\n            node.next = head.next;\n            head.next = node;\n            head = node.next;\n        }\n        head = t;\n        while (head != null) {\n            if (head.random != null) head.next.random = head.random.next;\n            head = head.next.next;\n        }\n        head = t;\n        Node ans = head.next;\n        while (head != null) {\n            Node ne = head.next;\n            if (ne != null) head.next = ne.next;\n            head = ne;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.138` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/131-140/139. 单词拆分（中等）.md", "url_title": "139. 单词拆分", "url": "https://leetcode.cn/problems/word-break/solution/by-ac_oier-gh00/", "difficulty": "中等", "tags": ["动态规划", "哈希表", "序列 DP"], "question": "给你一个字符串 `s` 和一个字符串列表 `wordDict` 作为字典。请你判断是否可以利用字典中出现的单词拼接出 `s` 。\n\n注意:不要求字典中出现的单词全部都使用,并且字典中的单词可以重复使用。\n\n示例 1:\n```\n输入: s = \"leetcode\", wordDict = [\"leet\", \"code\"]\n\n输出: true\n\n解释: 返回 true 因为 \"leetcode\" 可以由 \"leet\" 和 \"code\" 拼接成。\n```\n示例 2:\n```\n输入: s = \"applepenapple\", wordDict = [\"apple\", \"pen\"]\n\n输出: true\n\n解释: 返回 true 因为 \"applepenapple\" 可以由 \"apple\" \"pen\" \"apple\" 拼接成。\n     注意,你可以重复使用字典中的单词。\n```\n示例 3:\n```\n输入: s = \"catsandog\", wordDict = [\"cats\", \"dog\", \"sand\", \"and\", \"cat\"]\n\n输出: false\n```\n\n提示:\n* $1 <= s.length <= 300$\n* $1 <= wordDict.length <= 1000$\n* $1 <= wordDict[i].length <= 20$\n* `s` 和 `wordDict[i]` 仅有小写英文字母组成\n* `wordDict` 中的所有字符串 互不相同", "solution": "### 序列 DP\n\n将字符串 `s` 长度记为 $n$,`wordDict` 长度记为 $m$。为了方便,我们调整字符串 `s` 以及将要用到的动规数组的下标从 $1$ 开始。\n\n定义 $f[i]$ 为考虑前 $i$ 个字符,能否使用 `wordDict` 拼凑出来:当 $f[i] = true$ 代表 $s[1...i]$ 能够使用 `wordDict` 所拼凑,反之则不能。\n\n不失一般性考虑 $f[i]$ 该如何转移:由于 $f[i]$ 需要考虑 $s[1...i]$ 范围内的字符,若 $f[i]$ 为 `True` 说明整个 $s[1...i]$ 都能够使用 `wordDict` 拼凑,自然也包括最后一个字符 $s[i]$ 所在字符串 `sub`。\n\n**我们可以枚举最后一个字符所在字符串的左端点 $j$,若 $sub = s[j...i]$ 在 `wordDict` 中出现过,并且 $f[j - 1] = True$,说明 $s[0...(j - 1)]$ 能够被拼凑,并且子串 `sub` 也在 `wordDict`,可得 `f[i] = True`。**\n\n为了快速判断某个字符是否在 `wordDict` 中出现,我们可以使用 `Set` 结构对 $wordDict[i]$ 进行转存。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean wordBreak(String s, List<String> wordDict) {\n        Set<String> set = new HashSet<>();\n        for (String word : wordDict) set.add(word);\n        int n = s.length();\n        boolean[] f = new boolean[n + 10];\n        f[0] = true;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= i && !f[i]; j++) {\n                String sub = s.substring(j - 1, i);\n                if (set.contains(sub)) f[i] = f[j - 1]; \n            }\n        }\n        return f[n];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool wordBreak(string s, vector<string>& wordDict) {\n        unordered_set<string> set;\n        for (const string& word : wordDict) {\n            set.insert(word);\n        }\n        int n = s.length();\n        vector<bool> f(n + 10, false);\n        f[0] = true;\n        for (int i = 1; i <= n; ++i) {\n            for (int j = 1; j <= i && !f[i]; ++j) {\n                string sub = s.substr(j - 1, i - j + 1);\n                if (set.find(sub) != set.end()) f[i] = f[j - 1] || f[i];\n            }\n        }\n        return f[n];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def wordBreak(self, s: str, wordDict: List[str]) -> bool:\n        ss = set(wordDict)\n        n = len(s)\n        f = [False] * (n + 10)\n        f[0] = True\n        for i in range(1, n + 1):\n            j = i\n            while j >= 1 and not f[i]:\n                sub = s[j - 1:i]\n                if sub in ss:\n                    f[i] = f[j - 1]\n                j -= 1\n        return f[n]\n```\nTypeScript 代码:\n```TypeScript\nfunction wordBreak(s: string, wordDict: string[]): boolean {\n    const ss = new Set<string>(wordDict)\n    const n = s.length\n    const f = new Array<boolean>(n + 10).fill(false)\n    f[0] = true\n    for (let i = 1; i <= n; i++) {\n        for (let j = i; j >= 1 && !f[i]; j--) {\n            const sub = s.substring(j - 1, i)\n            if (ss.has(sub)) f[i] = f[j - 1]\n        }\n    }\n    return f[n]\n}\n```\n* 时间复杂度:将 `wordDict` 转存在 `Set` 复杂度为 $O(m)$;`DP` 过程复忽裁剪子串和查询 `Set` 结构的常数,复杂度为 $O(n^2)$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### 总结\n\n这里简单说下「线性 DP」和「序列 DP」的区别。\n\n线性 DP 通常强调「状态转移所依赖的前驱状态」是由给定数组所提供的,即拓扑序是由原数组直接给出。更大白话来说就是通常有 $f[i][...]$ 依赖于 $f[i - 1][...]$。\n\n这就限定了线性 DP 的复杂度是简单由「状态数量(或者说是维度数)」所决定。\n\n序列 DP 通常需要结合题意来寻找前驱状态,即需要自身寻找拓扑序关系(例如本题,需要自己通过枚举的方式来找左端点,从而找到可转移的前驱状态 $f[j - 1]$)。\n\n这就限定了序列 DP 的复杂度是由「状态数 + 找前驱」的复杂度所共同决定。也直接导致了序列 DP 有很多玩法,往往能够结合其他知识点出题,来优化找前驱这一操作,通常是利用某些性质,或是利用数据结构进行优化。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.139` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1331-1340/1331. 数组序号转换（简单）.md", "url_title": "1331. 数组序号转换", "url": "https://leetcode.cn/problems/rank-transform-of-an-array/solution/by-ac_oier-j70n/", "difficulty": "简单", "tags": ["模拟", "哈希表", "排序"], "question": "给你一个整数数组 `arr`,请你将数组中的每个元素替换为它们排序后的序号。\n\n序号代表了一个元素有多大。序号编号的规则如下:\n\n* 序号从 $1$ 开始编号。\n* 一个元素越大,那么序号越大。如果两个元素相等,那么它们的序号相同。\n* 每个数字的序号都应该尽可能地小。\n\n示例 1:\n```\n输入:arr = [40,10,20,30]\n\n输出:[4,1,2,3]\n\n解释:40 是最大的元素。 10 是最小的元素。 20 是第二小的数字。 30 是第三小的数字。\n```\n示例 2:\n```\n输入:arr = [100,100,100]\n\n输出:[1,1,1]\n\n解释:所有元素有相同的序号。\n```\n示例 3:\n```\n输入:arr = [37,12,28,9,100,56,80,5,12]\n\n输出:[5,3,4,2,8,6,7,1,3]\n```\n\n提示:\n* $0 <= arr.length <= 10^5$\n* $-10^9 <= arr[i] <= 10^9$", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n对 `arr` 进行拷贝操作得到新数组 `clone`,对 `clone` 数组进行排序,再使用哈希表记录元素与序号的映射关系,最后根据映射关系构造答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] arrayRankTransform(int[] arr) {\n        int[] clone = arr.clone();\n        Arrays.sort(clone);\n        Map<Integer, Integer> map = new HashMap<>();\n        int n = arr.length, idx = 0;\n        for (int i : clone) {\n            if (!map.containsKey(i)) map.put(i, ++idx);\n        }\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) ans[i] = map.get(arr[i]);\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction arrayRankTransform(arr: number[]): number[] {\n    let clone = new Array<number>()\n    for (const i of arr) clone.push(i)\n    clone.sort((a,b)=>a-b)\n    let n = arr.length, idx = 0\n    let map = new Map<number, number>()\n    for (const i of clone) {\n        if (!map.has(i)) map.set(i, ++idx)\n    }\n    let ans = new Array<number>()\n    for (let i = 0; i < n; i++) ans.push(map.get(arr[i]))\n    return ans\n};\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1331` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1331-1340/1332. 删除回文子序列（简单）.md", "url_title": "1332. 删除回文子序列", "url": "https://leetcode-cn.com/problems/the-k-weakest-rows-in-a-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-po-su-7okx/", "difficulty": "简单", "tags": ["双指针", "模拟"], "question": "给你一个字符串 `s`,它仅由字母 `'a'` 和 `'b'` 组成。每一次删除操作都可以从 `s` 中删除一个回文 **子序列**。\n\n返回删除给定字符串中所有字符(字符串为空)的最小删除次数。\n\n「子序列」定义:如果一个字符串可以通过删除原字符串某些字符而不改变原字符顺序得到,那么这个字符串就是原字符串的一个子序列。\n\n「回文」定义:如果一个字符串向后和向前读是一致的,那么这个字符串就是一个回文。\n\n示例 1:\n```\n输入:s = \"ababa\"\n\n输出:1\n\n解释:字符串本身就是回文序列,只需要删除一次。\n```\n示例 2:\n```\n输入:s = \"abb\"\n\n输出:2\n\n解释:\"abb\" -> \"bb\" -> \"\". \n先删除回文子序列 \"a\",然后再删除 \"bb\"。\n```\n示例 3:\n```\n输入:s = \"baabb\"\n\n输出:2\n\n解释:\"baabb\" -> \"b\" -> \"\". \n先删除回文子序列 \"baab\",然后再删除 \"b\"。\n```\n\n提示:\n* $1 <= s.length <= 1000$\n* `s` 仅包含字母 `'a'`  和 `'b'`", "solution": "### 双指针\n\n由于 `s` 只有字母 `a` 和 `b`,并且删除的是「子序列」,因此最大的删除次数为 $2$(先删除所有的 `a`,再删除所有的 `b`)。\n\n同时 `s` 本身不为空串(不存在删除次数为 $0$ 的情况),因此如果我们不能一次删除的话(`s` 本身为回文),只能通过 $2$ 次进行删除。\n\n代码:\n```Java\nclass Solution {\n    public int removePalindromeSub(String s) {\n        int n = s.length();\n        int i = 0, j = n - 1;\n        while (i < j) {\n            if (s.charAt(i) != s.charAt(j)) return 2;\n            i++; j--;\n        }\n        return 1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1332` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1331-1340/1334. 阈值距离内邻居最少的城市（中等）.md", "url_title": "1334. 阈值距离内邻居最少的城市", "url": "https://leetcode.cn/problems/find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance/solutions/2526052/gong-shui-san-xie-han-gai-suo-you-cun-tu-svq7/", "difficulty": "中等", "tags": ["最短路", "图"], "question": "有 $n$ 个城市,按从 $0$ 到 $n-1$ 编号。\n\n给你一个边数组 `edges`,其中 $edges[i] = [from_{i}, to_{i}, weight_{i}]$ 代表 $from_{i}$ 和 $to_{i}$ 两个城市之间的双向加权边,距离阈值是一个整数 `distanceThreshold`。\n\n返回能通过某些路径到达其他城市数目最少、且路径距离最大为 `distanceThreshold` 的城市。如果有多个这样的城市,则返回编号最大的城市。\n\n注意,连接城市 $i$ 和 $j$ 的路径的距离等于沿该路径的所有边的权重之和。\n\n示例 1:\n\n```\n输入:n = 4, edges = [[0,1,3],[1,2,1],[1,3,4],[2,3,1]], distanceThreshold = 4\n\n输出:3\n\n解释:城市分布图如上。\n每个城市阈值距离 distanceThreshold = 4 内的邻居城市分别是:\n城市 0 -> [城市 1, 城市 2] \n城市 1 -> [城市 0, 城市 2, 城市 3] \n城市 2 -> [城市 0, 城市 1, 城市 3] \n城市 3 -> [城市 1, 城市 2] \n城市 0 和 3 在阈值距离 4 以内都有 2 个邻居城市,但是我们必须返回城市 3,因为它的编号最大。\n```\n示例 2:\n\n```\n输入:n = 5, edges = [[0,1,2],[0,4,8],[1,2,3],[1,4,2],[2,3,1],[3,4,1]], distanceThreshold = 2\n\n输出:0\n\n解释:城市分布图如上。 \n每个城市阈值距离 distanceThreshold = 2 内的邻居城市分别是:\n城市 0 -> [城市 1] \n城市 1 -> [城市 0, 城市 4] \n城市 2 -> [城市 3, 城市 4] \n城市 3 -> [城市 2, 城市 4]\n城市 4 -> [城市 1, 城市 2, 城市 3] \n城市 0 在阈值距离 2 以内只有 1 个邻居城市。\n```\n\n提示:\n* $2 <= n <= 100$\n* $1 <= edges.length <= \\frac{n \\times (n - 1)}{2}$\n* $edges[i].length = 3$\n* $0 <= from_{i} < to_{i} < n$\n* $1 <= weight_{i}, distanceThreshold <= 10^4$\n* 所有 $(from_{i}, to_{i})$ 都是不同的。", "solution": "### 基本分析\n\n若能预处理图中任意两点 $i$ 和 $j$ 的最短距离 `dist`,那么统计每个点 $i$ 在图中有多少满足 $dist[j] \\leq distanceThreshold$ 的点 $j$ 即为答案。\n\n于是问题转换为:**如何求解给定图中,任意两点的最短距离**。\n\n---\n\n### 存图\n\n在学习最短路之前,我们先搞懂众多图论问题的前置 🧀 :存图。\n\n为了方便,我们约定 $n$ 为点数,$m$ 为边数。\n\n根据点和边的数量级关系,可以将图分成如下两类:\n\n* 稠密图:边数较多,边数接近于点数的平方,即 $m \\approx n^2$\n* 稀疏图:边数较少,边数接近于点数,即 $m \\approx n$\n\n同时,根据「稠密图」还是「稀疏图」,我们有如下几种存图方式:\n\n##### 1. 邻接矩阵(稠密图)\n\n这是一种使用二维矩阵来进行存图的方式。\n\n```Java\n// w[a][b] = c 代表从 a 到 b 有权重为 c 的边\nint[][] g = new int[N][N];\n\n// 加边操作\nvoid add(int a, int b, int c) {\n    g[a][b] = c;\n}\n```\n\n##### 2. 邻接表(稀疏图)\n\n邻接表又叫**链式前向星**,是另一种常见的存图方式,实现代码与「使用数组存储单链表」一致(头插法)。\n\n```Java\nint[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];\n\n// 加边操作\nvoid add(int a, int b, int c) {\n    e[idx] = b;\n    ne[idx] = he[a];\n    w[idx] = c;\n    he[a] = idx++;\n}\n```\n\n首先 `idx` 是用来对边进行编号的,然后对存图用到的几个数组作简单解释:\n* `he` 数组:存储是某个节点所对应的边的集合(链表)的头结点;\n* `e`  数组:由于访问某一条边指向的节点;\n* `ne` 数组:由于是以链表的形式进行存边,该数组就是用于找到下一条边;\n* `w`  数组:用于记录某条边的权重为多少。\n\n当我们想要遍历所有由 `a` 点发出的边时,可以使用如下方式:\n\n```Java\nfor (int i = he[a]; i != -1; i = ne[i]) {\n    int b = e[i], c = w[i]; // 存在由 a 指向 b 的边,权重为 c\n}\n```\n\n##### 3. 类\n\n这是最简单,但使用频率最低的存图方式。\n\n只有当我们需要确保某个操作复杂度为严格 $O(m)$ 时,才会考虑使用。\n\n具体的,建立一个类来记录有向边信息:\n\n```Java\nclass Edge {\n    // 代表从 a 到 b 有一条权重为 c 的边\n    int a, b, c;\n    Edge(int _a, int _b, int _c) {\n        a = _a; b = _b; c = _c;\n    }\n}\n```\n\n随后,使用诸如 `List` 的容器,存起所有边对象。在需要遍历所有边时,对容器进行进行遍历:\n\n```Java\nList<Edge> es = new ArrayList<>();\n\n...\n\nfor (Edge e : es) {\n    ...\n}\n```\n\n综上,第  $3$ 种方式,往往是 `OJ` 给我们边信息的方式,我们自己几乎不会用这种方式建图。\n\n实际运用中,熟练掌握「如何根据点和边的数量级关系,来决定使用邻接矩阵(稠密图)还是邻接表(稀疏图)」即可。\n\n---\n\n### Floyd(邻接矩阵)\n\n`Floyd` 算法作为「多源汇最短路」算法,对于本题尤其适合。\n\n`Floyd` 算法基于「动态规划」,其原始三维状态定义为 $dist[p][i][j]$,表示「所有从点 $i$ 到点 $j$,且允许经过点集 $(1, ... , p)$ 的路径」中的最短距离。\n\n状态转移方程:\n$$\ndist[p][i][j] = \\min(dist[p - 1][i][j], dist[p - 1][i][p] + dist[p - 1][p][j])\n$$\n$dist[p - 1][i][j]$ 代表从 $i$ 到 $j$ 但必然不经过点 $p$ 的路径,$dist[p - 1][i][p] + dist[p - 1][p][j]$ 代表必然经过点 $p$ 的路径,两者中取较小值更新 $dist[p][i][j]$。\n\n不难发现任意的 $dist[p][X][Y]$ 依赖于 $dist[p - 1][X][Y]$,可采用「滚动数组」的方式进行优化。\n\n将 `dist` 声明为二维数组,$dist[i][j]$ 代表从点 $i$ 到点 $j$ 的最短距离,并采取 [枚举中转点 - 枚举起点 - 枚举终点] 三层循环的方式更新 $dist[i][j]$。\n\n如此一来,跑一遍 `Floyd` 算法便可得出任意两点的最短距离。\n\n通过上述推导,不难发现,我们并没提及边权的正负问题,因此 `Floyd` 算法对边权的正负没有限制要求(可处理正负权边的图),且能利用 `Floyd` 算法可能够对图中负环进行判定。\n\nJava 代码:\n\n```Java\nclass Solution {\n    public int findTheCity(int n, int[][] edges, int distanceThreshold) {\n        int[][] g = new int[n][n];\n        // 初始化邻接矩阵\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                g[i][j] = i == j ? 0 : 0x3f3f3f3f;\n            }\n        }\n        // 存图\n        for (int[] e : edges) {\n            int a = e[0], b = e[1], c = e[2];\n            g[a][b] = g[b][a] = Math.min(g[a][b], c);\n        }\n        // 最短路\n        floyd(g);\n        // 统计答案\n        int ans = -1, cnt = n + 10;\n        for (int i = 0; i < n; i++) {\n            int cur = 0;\n            for (int j = 0; j < n; j++) {\n                if (i != j && g[i][j] <= distanceThreshold) cur++;\n            }\n            if (cur <= cnt) {\n                cnt = cur; ans = i;\n            }\n        }\n        return ans;\n    }\n    void floyd(int[][] g) {\n        int n = g.length;\n        // floyd 基本流程为三层循环: [枚举中转点 - 枚举起点 - 枚举终点] => 松弛操作  \n        for (int p = 0; p < n; p++) {\n            for (int i = 0; i < n; i++) {\n                for (int j = 0; j < n; j++) {\n                    g[i][j] = Math.min(g[i][j], g[i][p] + g[p][j]);\n                }\n            }\n        }\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int findTheCity(int n, vector<vector<int>>& edges, int distanceThreshold) {\n        vector<vector<int>> g(n, vector<int>(n, 0x3f3f3f3f));\n        // 初始化邻接矩阵\n        for (int i = 0; i < n; i++) g[i][i] = 0;\n        // 存图\n        for (const auto& e : edges) {\n            int a = e[0], b = e[1], c = e[2];\n            g[a][b] = g[b][a] = min(g[a][b], c);\n        }\n        // 最短路\n        floyd(g);\n        // 统计答案\n        int ans = -1, cnt = n + 10;\n        for (int i = 0; i < n; i++) {\n            int cur = 0;\n            for (int j = 0; j < n; j++) {\n                if (i != j && g[i][j] <= distanceThreshold) cur++;\n            }\n            if (cur <= cnt) {\n                cnt = cur; ans = i;\n            }\n        }\n        return ans;\n    }\n    void floyd(vector<vector<int>>& g) {\n        int n = g.size();\n        // floyd 基本流程为三层循环: [枚举中转点 - 枚举起点 - 枚举终点] => 松弛操作  \n        for (int p = 0; p < n; p++) {\n            for (int i = 0; i < n; i++) {\n                for (int j = 0; j < n; j++) {\n                    g[i][j] = min(g[i][j], g[i][p] + g[p][j]);\n                }\n            }\n        }\n    }\n};\n\n```\nPython 代码:\n```Python\nclass Solution:\n    def findTheCity(self, n: int, edges: List[List[int]], distanceThreshold: int) -> int:\n        def floyd(g: List[List[int]]) -> None:\n            n = len(g)\n            # floyd 基本流程为三层循环: [枚举中转点 - 枚举起点 - 枚举终点] => 松弛操作\n            for p in range(n):\n                for i in range(n):\n                    for j in range(n):\n                        g[i][j] = min(g[i][j], g[i][p] + g[p][j])\n\n        g = [[float('inf')] * n for _ in range(n)]\n        # 初始化邻接矩阵\n        for i in range(n):\n            g[i][i] = 0\n        # 存图\n        for a, b, c in edges:\n            g[a][b] = g[b][a] = min(g[a][b], c)\n        # 最短路\n        floyd(g)\n        # 统计答案\n        ans, cnt = -1, n + 10\n        for i in range(n):\n            cur = sum(1 for j in range(n) if i != j and g[i][j] <= distanceThreshold)\n            if cur <= cnt:\n                cnt, ans = cur, i\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction findTheCity(n: number, edges: number[][], distanceThreshold: number): number {\n    const floyd = function (g: number[][]): void {\n        const n = g.length;\n        // floyd 基本流程为三层循环: [枚举中转点 - 枚举起点 - 枚举终点] => 松弛操作\n        for (let p = 0; p < n; p++) {\n            for (let i = 0; i < n; i++) {\n                for (let j = 0; j < n; j++) {\n                    g[i][j] = Math.min(g[i][j], g[i][p] + g[p][j]);\n                }\n            }\n        }\n    }\n\n    const g = Array.from({ length: n }, () => Array(n).fill(0x3f3f3f3f));\n    // 初始化邻接矩阵\n    for (let i = 0; i < n; i++) g[i][i] = 0;\n    // 存图\n    for (const [a, b, c] of edges) g[a][b] = g[b][a] = Math.min(g[a][b], c);\n    // 最短路\n    floyd(g);\n    // 统计答案\n    let ans = -1, cnt = n + 10;\n    for (let i = 0; i < n; i++) {\n        let cur = 0;\n        for (let j = 0; j < n; j++) {\n            if (i !== j && g[i][j] <= distanceThreshold) cur++;\n        }\n        if (cur <= cnt) {\n            cnt = cur; ans = i;\n        }\n    }\n    return ans;\n};\n```\n* 时间复杂度:初始化邻接矩阵和建图复杂度为 $O(n^2 + m)$;`floyd` 算法复杂度为 $O(n^3)$;统计答案复杂度为 $O(n^2)$;整体复杂度为 $O(n^3 + m)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 朴素 Dijkstra(邻接矩阵)\n\n最为经典的「单源最短路」算法,通常搭配「邻接矩阵」使用,应用在边数较多的“稠密图”上。\n\n朴素 `Dijkstra` 算法基于「贪心」,通过维护一维的距离数组 `dist` 实现,$dist[i]$ 表示从源点出发到点 $i$ 的最短距离。\n\n朴素 `Dijkstra` 算法在每一次迭代中,都选择 `dist` 中值最小的点进行松弛操作,逐渐扩展最短路径范围。\n\nJava 代码:\n\n```Java\nclass Solution {\n    public int findTheCity(int n, int[][] edges, int distanceThreshold) {\n        int[][] g = new int[n][n];\n        // 初始化邻接矩阵\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                g[i][j] = i == j ? 0 : 0x3f3f3f3f;\n            }\n        }\n        // 存图\n        for (int[] e : edges) {\n            int a = e[0], b = e[1], c = e[2];\n            g[a][b] = g[b][a] = Math.min(g[a][b], c);\n        }\n        int ans = -1, cnt = n + 10;\n        for (int i = 0; i < n; i++) {\n            // 单源最短路\n            int[] dist = dijkstra(g, i);\n            int cur = 0;\n            for (int j = 0; j < n; j++) {\n                if (i != j && dist[j] <= distanceThreshold) cur++;\n            }\n            if (cur <= cnt) {\n                cnt = cur; ans = i;\n            }\n        }\n        return ans;\n    }\n    int[] dijkstra(int[][] g, int x) {\n        int n = g.length;\n        // 起始先将所有的点标记为「未更新」和「距离为正无穷」\n        boolean[] vis = new boolean[n];\n        int[] dist = new int[n];\n        Arrays.fill(dist, 0x3f3f3f3f);\n        // 只有起点最短距离为 0\n        dist[x] = 0;\n        // 有多少个点就迭代多少次\n        for (int k = 0; k < n; k++) {\n            // 每次找到「最短距离最小」且「未被更新」的点 t\n            int t = -1;\n            for (int i = 0; i < n; i++) {\n                if (!vis[i] && (t == -1 || dist[i] < dist[t])) t = i;\n            }\n            // 标记点 t 为已更新\n            vis[t] = true;\n            // 用点 t 的「最小距离」更新其他点\n            for (int i = 0; i < n; i++) dist[i] = Math.min(dist[i], dist[t] + g[t][i]);\n        }\n        return dist;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int findTheCity(int n, vector<vector<int>>& edges, int distanceThreshold) {\n        vector<vector<int>> g(n, vector<int>(n, 0x3f3f3f3f));\n        // 初始化邻接矩阵\n        for (int i = 0; i < n; i++) g[i][i] = 0;\n        // 存图\n        for (const auto& e : edges) {\n            int a = e[0], b = e[1], c = e[2];\n            g[a][b] = g[b][a] = min(g[a][b], c);\n        }\n        int ans = -1, cnt = n + 10;\n        for (int i = 0; i < n; i++) {\n            // 单源最短路\n            vector<int> dist = dijkstra(g, i);\n            int cur = count_if(dist.begin(), dist.end(), [distanceThreshold](int d) { return d <= distanceThreshold; });\n            if (cur <= cnt) {\n                cnt = cur; ans = i;\n            }\n        }\n        return ans;\n    }\n    vector<int> dijkstra(const vector<vector<int>>& g, int x) {\n        int n = g.size();\n        vector<bool> vis(n, false);\n        vector<int> dist(n, 0x3f3f3f3f);\n        // 只有起点最短距离为 0\n        dist[x] = 0;\n        // 有多少个点就迭代多少次\n        for (int k = 0; k < n; k++) {\n            // 每次找到「最短距离最小」且「未被更新」的点 t\n            int t = -1;\n            for (int i = 0; i < n; i++) {\n                if (!vis[i] && (t == -1 || dist[i] < dist[t])) t = i;\n            }\n            // 标记点 t 为已更新\n            vis[t] = true;\n            // 用点 t 的「最小距离」更新其他点\n            for (int i = 0; i < n; i++) dist[i] = min(dist[i], dist[t] + g[t][i]);\n        }\n        return dist;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def findTheCity(self, n: int, edges: List[List[int]], distanceThreshold: int) -> int:\n        def dijkstra(g, x):\n            n = len(g)\n            vis = [False] * n\n            dist = [float('inf')] * n\n            # 只有起点最短距离为 0\n            dist[x] = 0\n            # 有多少个点就迭代多少次\n            for k in range(n):\n                # 每次找到「最短距离最小」且「未被更新」的点 t\n                t = min((i for i in range(n) if not vis[i]), key=lambda i: dist[i])\n                # 标记点 t 为已更新\n                vis[t] = True\n                # 用点 t 的「最小距离」更新其他点\n                for i in range(n):\n                    dist[i] = min(dist[i], dist[t] + g[t][i])\n            return dist\n\n        g = [[float('inf')] * n for _ in range(n)]\n        # 初始化邻接矩阵\n        for i in range(n):\n            g[i][i] = 0\n        # 存图\n        for a, b, c in edges:\n            g[a][b] = g[b][a] = min(g[a][b], c)\n        ans, cnt = -1, n + 10\n        for i in range(n):\n            # 单源最短路\n            dist = dijkstra(g, i)\n            cur = sum(1 for j in range(n) if i != j and dist[j] <= distanceThreshold)\n            if cur <= cnt:\n                cnt, ans = cur, i\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction findTheCity(n: number, edges: number[][], distanceThreshold: number): number {\n    const dijkstra = function (g: number[][], x: number): number[]  {\n        const n = g.length;\n        const vis = Array(n).fill(false), dist = Array(n).fill(0x3f3f3f3f);\n        // 只有起点最短距离为 0\n        dist[x] = 0;\n        // 有多少个点就迭代多少次\n        for (let k = 0; k < n; k++) {\n            // 每次找到「最短距离最小」且「未被更新」的点 t\n            let t = -1;\n            for (let i = 0; i < n; i++) {\n                if (!vis[i] && (t === -1 || dist[i] < dist[t])) t = i;\n            }\n            // 标记点 t 为已更新\n            vis[t] = true;\n            // 用点 t 的「最小距离」更新其他点\n            for (let i = 0; i < n; i++) dist[i] = Math.min(dist[i], dist[t] + g[t][i]);\n        }\n        return dist;\n    }\n    \n    const g = Array.from({ length: n }, () => Array(n).fill(0x3f3f3f3f));\n    // 初始化邻接矩阵\n    for (let i = 0; i < n; i++) g[i][i] = 0;\n    // 存图\n    for (const [a, b, c] of edges) g[a][b] = g[b][a] = Math.min(g[a][b], c);\n    let ans = -1, cnt = n + 10;\n    for (let i = 0; i < n; i++) {\n        // 单源最短路\n        const dist = dijkstra(g, i);\n        const cur = dist.filter(d => d <= distanceThreshold).length;\n        if (cur <= cnt) {\n            cnt = cur; ans = i;\n        }\n    }\n    return ans;\n};\n```\n* 时间复杂度:初始化邻接矩阵和建图复杂度为 $O(n^2 + m)$;统计答案时,共执行 $n$ 次朴素 `dijkstra` 算法,朴素 `dijkstra` 复杂度为 $O(n^2)$,总复杂度为 $O(n^3)$。整体复杂度为 $O(n^3 + m)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 堆优化 Dijkstra(邻接表)\n\n堆优化 `Dijkstra` 算法与朴素 `Dijkstra` 算法都是「单源最短路」算法。\n\n堆优化 `Dijkstra` 算法通过数据结构「优先队列(堆)」来优化朴素 `Dijkstra` 中的“找 `dist` 中值最小的点”的过程。\n\n相比于复杂度与边数无关的 $O(n^2)$ 朴素 `Dijkstra` 算法,复杂度与边数相关的 $O(m\\log{n})$ 堆优化 `Dijkstra` 算法更适合边较少的“稀疏图”。\n\nJava 代码:\n\n```Java\nclass Solution {\n    int N = 110, M = N * N, INF = 0x3f3f3f3f, idx, n;\n    int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        w[idx] = c;\n        he[a] = idx++;\n    }\n    public int findTheCity(int _n, int[][] edges, int distanceThreshold) {\n        n = _n;\n        // 初始化链表头\n        Arrays.fill(he, -1);\n        // 存图\n        for (int[] e : edges) {\n            int a = e[0], b = e[1], c = e[2];\n            add(a, b, c); add(b, a, c);\n        }\n        // 统计答案\n        int ans = -1, cnt = n + 10;\n        for (int i = 0; i < n; i++) {\n            // 单源最短路\n            int[] dist = dijkstra(i);\n            int cur = 0;\n            for (int j = 0; j < n; j++) {\n                if (i != j && dist[j] <= distanceThreshold) cur++;\n            }\n            if (cur <= cnt) {\n                cnt = cur; ans = i;\n            }\n        }\n        return ans;\n    }\n    int[] dijkstra(int x) {\n        // 起始先将所有的点标记为「未更新」和「距离为正无穷」\n        int[] dist = new int[n];\n        Arrays.fill(dist, 0x3f3f3f3f);\n        boolean[] vis = new boolean[n];\n        dist[x] = 0;\n        // 使用「优先队列」存储所有可用于更新的点\n        // 以 (点编号, 到起点的距离) 进行存储,优先弹出「最短距离」较小的点\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[1]-b[1]);\n        q.add(new int[]{x, 0});\n        while (!q.isEmpty()) {\n            // 每次从「优先队列」中弹出\n            int[] poll = q.poll();\n            int u = poll[0], step = poll[1];\n            // 如果弹出的点被标记「已更新」,则跳过\n            if (vis[u]) continue;\n            // 标记该点「已更新」,并使用该点更新其他点的「最短距离」\n            vis[u] = true;\n            for (int i = he[u]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (dist[j] <= dist[u] + w[i]) continue;\n                dist[j] = dist[u] + w[i];\n                q.add(new int[]{j, dist[j]});\n            }\n        }\n        return dist;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    static const int N = 110, M = N * N;\n    int he[N], e[M], ne[M], w[M], idx, n, INF = 0x3f3f3f3f;\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        w[idx] = c;\n        he[a] = idx++;\n    }\n    int findTheCity(int _n, vector<vector<int>>& edges, int distanceThreshold) {\n        n = _n;\n        // 初始化链表头\n        fill(he, he + n, -1);\n        // 存图\n        for (const auto& e : edges) {\n            int a = e[0], b = e[1], c = e[2];\n            add(a, b, c); add(b, a, c);\n        }\n        // 统计答案\n        int ans = -1, cnt = n + 10;\n        for (int i = 0; i < n; i++) {\n            // 单源最短路\n            vector<int> dist = dijkstra(i);\n            int cur = count_if(dist.begin(), dist.end(), [distanceThreshold](int d) { return d <= distanceThreshold; });\n            if (cur <= cnt) {\n                cnt = cur; ans = i;\n            }\n        }\n        return ans;\n    }\n    vector<int> dijkstra(int x) {\n        // 起始先将所有的点标记为「未更新」和「距离为正无穷」\n        vector<int> dist(n, INF);\n        vector<bool> vis(n, false);\n        dist[x] = 0;\n        // 使用「优先队列」存储所有可用于更新的点\n        // 以 (到起点的距离, 点编号) 进行存储,优先弹出「最短距离」较小的点\n        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;\n        q.push({0, x});\n        while (!q.empty()) {\n            // 每次从「优先队列」中弹出\n            auto [step, u] = q.top();\n            q.pop();\n            // 如果弹出的点被标记「已更新」,则跳过\n            if (vis[u]) continue;\n            // 标记该点「已更新」,并使用该点更新其他点的「最短距离」\n            vis[u] = true;\n            for (int i = he[u]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (dist[j] <= dist[u] + w[i]) continue;\n                dist[j] = dist[u] + w[i];\n                q.push({dist[j], j});\n            }\n        }\n        return dist;\n    }\n};\n```\nPython 代码:\n```Python\nimport heapq\n\nclass Solution:\n    def findTheCity(self, n: int, edges: List[List[int]], distanceThreshold: int) -> int:\n        N, M, INF, idx = 110, 110 * 110, float('inf'), 0\n        he, e, ne, w = [-1] * N, [0] * M, [0] * M, [0] * M\n\n        def add(a, b, c):\n            nonlocal idx\n            e[idx] = b\n            ne[idx] = he[a]\n            w[idx] = c\n            he[a] = idx\n            idx += 1\n\n        def dijkstra(x):\n            # 起始先将所有的点标记为「未更新」和「距离为正无穷」\n            dist = [float('inf')] * n\n            vis = [False] * n\n            dist[x] = 0\n            # 使用「优先队列」存储所有可用于更新的点\n            # 以 (点编号, 到起点的距离) 进行存储,优先弹出「最短距离」较小的点\n            q = [(0, x)]\n            heapq.heapify(q)\n            while q:\n                # 每次从「优先队列」中弹出\n                step, u = heapq.heappop(q)\n                # 如果弹出的点被标记「已更新」,则跳过\n                if vis[u]: continue\n                # 标记该点「已更新」,并使用该点更新其他点的「最短距离」\n                vis[u] = True\n                i = he[u]\n                while i != -1:\n                    j, c = e[i], w[i]\n                    i = ne[i]\n                    if dist[j] <= dist[u] + c: continue\n                    dist[j] = dist[u] + c\n                    heapq.heappush(q, (dist[j], j))\n            return dist\n\n        # 初始化链表头\n        he = [-1] * N\n        # 存图\n        for a, b, c in edges:\n            add(a, b, c)\n            add(b, a, c)\n        # 统计答案\n        ans, cnt = -1, n + 10\n        for i in range(n):\n            # 单源最短路\n            dist = dijkstra(i)\n            cur = sum(1 for j in range(n) if i != j and dist[j] <= distanceThreshold)\n            if cur <= cnt:\n                cnt, ans = cur, i\n        return ans\n```\n* 时间复杂度:初始化邻接表和建图复杂度为 $O(n + m)$;统计答案时,共执行 $n$ 次堆优化 `dijkstra` 算法,堆优化 `dijkstra` 复杂度为 $O(m\\log{n})$,总复杂度为 $O(nm\\log{n})$。整体复杂度为 $O(nm\\log{n})$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### Bellman Ford(类)\n\n虽然题目规定了不存在「负权边」,但我们仍然可以使用可以在「负权图中求最短路」的 `Bellman Ford` 进行求解,该算法也是「单源最短路」算法,复杂度为 $O(n \\times m)$。\n\n通常为了确保 $O(n \\times m)$,可以单独建一个类代表边,将所有边存入集合中,在 $n$ 次松弛操作中直接对边集合进行遍历。\n\n由于本题边数量级为 $n^2$,共对 $n$ 个点执行 `Bellman Ford` 算法,因此整体会去到 $O(n^4)$,有 `TLE` 风险。\n\nJava 代码:\n\n```Java\nclass Solution {\n    int n;\n    public int findTheCity(int _n, int[][] edges, int distanceThreshold) {\n        n = _n;\n        int ans = -1, cnt = n + 10;\n        for (int i = 0; i < n; i++) {\n            int[] dist = bf(edges, i);\n            int cur = 0;\n            for (int j = 0; j < n; j++) {\n                if (i != j && dist[j] <= distanceThreshold) cur++;\n            }\n            if (cur <= cnt) {\n                cnt = cur; ans = i;\n            }\n        }\n        return ans;\n    }\n    int[] bf(int[][] edges, int x) {\n        int[] dist = new int[n];\n        // 起始先将所有的点标记为「距离为正无穷」, 只有起点最短距离为 0\n        Arrays.fill(dist, 0x3f3f3f3f);\n        dist[x] = 0;\n        // 有多少个点就迭代多少次\n        for (int k = 0; k < n; k++) {\n            // 每次都使用上一次迭代的结果,执行松弛操作\n            int[] prev = dist.clone();\n            for (int[] e : edges) {\n                int a = e[0], b = e[1], c = e[2];\n                dist[b] = Math.min(dist[b], prev[a] + c);\n                dist[a] = Math.min(dist[a], prev[b] + c);\n            }\n        }\n        return dist;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int findTheCity(int n, vector<vector<int>>& edges, int distanceThreshold) {\n        int ans = -1, cnt = n + 10;\n        for (int i = 0; i < n; i++) {\n            vector<int> dist = bf(edges, i, n);\n            int cur = 0;\n            for (int j = 0; j < n; j++) {\n                if (i != j && dist[j] <= distanceThreshold) cur++;\n            }\n            if (cur <= cnt) {\n                cnt = cur; ans = i;\n            }\n        }\n        return ans;\n    }\n    vector<int> bf(vector<vector<int>>& edges, int x, int n) {\n        // 起始先将所有的点标记为「距离为正无穷」, 只有起点最短距离为 0\n        vector<int> dist(n, 0x3f3f3f3f);\n        dist[x] = 0;\n        // 有多少个点就迭代多少次\n        for (int k = 0; k < n; k++) {\n            // 每次都使用上一次迭代的结果,执行松弛操作\n            vector<int> prev = dist;\n            for (const auto& e : edges) {\n                int a = e[0], b = e[1], c = e[2];\n                dist[b] = min(dist[b], prev[a] + c);\n                dist[a] = min(dist[a], prev[b] + c);\n            }\n        }\n        return dist;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def findTheCity(self, n: int, edges: List[List[int]], distanceThreshold: int) -> int:\n        def bf(edges: List[List[int]], x: int, n: int) -> List[int]:\n            # 起始先将所有的点标记为「距离为正无穷」, 只有起点最短距离为 0\n            dist = [float('inf')] * n\n            dist[x] = 0\n            # 有多少个点就迭代多少次\n            for k in range(n):\n                # 每次都使用上一次迭代的结果,执行松弛操作\n                prev = dist.copy()\n                for a, b, c in edges:\n                    dist[b] = min(dist[b], prev[a] + c)\n                    dist[a] = min(dist[a], prev[b] + c)\n            return dist\n\n        ans, cnt = -1, n + 10\n        for i in range(n):\n            dist = bf(edges, i, n)\n            cur = sum(1 for j in range(n) if i != j and dist[j] <= distanceThreshold)\n            if cur <= cnt:\n                cnt, ans = cur, i\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction findTheCity(n: number, edges: number[][], distanceThreshold: number): number {\n    const bf = function(x: number): number[] {\n        // 起始先将所有的点标记为「距离为正无穷」, 只有起点最短距离为 0\n        const dist = new Array(n).fill(0x3f3f3f3f);\n        dist[x] = 0;\n        // 有多少个点就迭代多少次\n        for (let k = 0; k < n; k++) {\n            // 每次都使用上一次迭代的结果,执行松弛操作\n            const prev = dist.slice();\n            for (const e of edges) {\n                const a = e[0], b = e[1], c = e[2];\n                dist[b] = Math.min(dist[b], prev[a] + c);\n                dist[a] = Math.min(dist[a], prev[b] + c);\n            }\n        }\n        return dist;\n    }\n\n    let ans = -1, cnt = n + 10;\n    for (let i = 0; i < n; i++) {\n        const dist = bf(i);\n        let cur = 0;\n        for (let j = 0; j < n; j++) {\n            if (i !== j && dist[j] <= distanceThreshold) cur++;\n        }\n        if (cur <= cnt) {\n            cnt = cur; ans = i;\n        }\n    }\n    return ans;\n};\n```\n* 时间复杂度:统计答案时,共执行 $n$ 次 `Bellman Ford` 算法, `Bellman Ford` 复杂度为 $O(nm)$,总复杂度为 $O(n^2 \\times m)$。整体复杂度为 $O(n^2 \\times m)$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### SPFA(邻接表)\n\n`SPFA` 也是一类能够处理「负权边」的单源最短路算法。\n\n最坏情况下,复杂度为 $O(n \\times m)$,在特定情况下,其效率优于 `Dijkstra` 算法,近似 $O(m)$。\n\n基本执行流程如下:\n\n1. 用双端队列来维护待更新节点,初始将源点放入队列\n2. 每次从队列头中取出一个节点,对其所有相邻节点执行松弛操作\n   1. 若某个相邻节点的最短距离发生了更新,且该节点不在队列中,将它加入队列中\n\n3. 重复以上步骤,直到队列为空\n\nJava 代码:\n```Java\nclass Solution {\n    int N = 110, M = N * N, INF = 0x3f3f3f3f, idx, n;\n    int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        w[idx] = c;\n        he[a] = idx++;\n    }\n    public int findTheCity(int _n, int[][] edges, int distanceThreshold) {\n        n = _n;\n        // 初始化链表头\n        Arrays.fill(he, -1);\n        // 存图\n        for (int[] e : edges) {\n            int a = e[0], b = e[1], c = e[2];\n            add(a, b, c); add(b, a, c);\n        }\n        // 统计答案\n        int ans = -1, cnt = n + 10;\n        for (int i = 0; i < n; i++) {\n            // 单源最短路\n            int[] dist = spfa(i);\n            int cur = 0;\n            for (int j = 0; j < n; j++) {\n                if (i != j && dist[j] <= distanceThreshold) cur++;\n            }\n            if (cur <= cnt) {\n                cnt = cur; ans = i;\n            }\n        }\n        return ans;\n    }\n    int[] spfa(int x) {\n        int[] dist = new int[n];\n        boolean[] vis = new boolean[n];\n        // 起始先将所有的点标记为「未入队」和「距离为正无穷」\n        Arrays.fill(dist, INF);\n        // 只有起点最短距离为 0\n        dist[x] = 0;\n        // 使用「双端队列」存储,存储的是点编号\n        Deque<Integer> d = new ArrayDeque<>();\n        // 将「源点/起点」进行入队,并标记「已入队」\n        d.addLast(x);\n        vis[x] = true;\n        while (!d.isEmpty()) {\n            // 每次从「双端队列」中取出,并标记「未入队」\n            int u = d.pollFirst();\n            vis[u] = false;\n            // 尝试使用该点,更新其他点的最短距离\n            // 如果更新的点,本身「未入队」则加入队列中,并标记「已入队」\n            for (int i = he[u]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (dist[j] <= dist[u] + w[i]) continue;\n                dist[j] = dist[u] + w[i];\n                if (vis[j]) continue;\n                d.addLast(j);\n                vis[j] = true;\n            }\n        }\n        return dist;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    static const int N = 110, M = N * N;\n    int he[N], e[M], ne[M], w[M], idx, n, INF = 0x3f3f3f3f;\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        w[idx] = c;\n        he[a] = idx++;\n    }\n    int findTheCity(int _n, vector<vector<int>>& edges, int distanceThreshold) {\n        n = _n;\n        fill(he, he + N, -1);\n        for (const auto& e : edges) {\n            int a = e[0], b = e[1], c = e[2];\n            add(a, b, c); add(b, a, c);\n        }\n        int ans = -1, cnt = n + 10;\n        for (int i = 0; i < n; i++) {\n            vector<int> dist = spfa(i);\n            int cur = count_if(dist.begin(), dist.end(), [&](int d) { return d != INF && d <= distanceThreshold; });\n            if (cur <= cnt) {\n                cnt = cur; ans = i;\n            }\n        }\n        return ans;\n    }\n    vector<int> spfa(int x) {\n        // 起始先将所有的点标记为「未入队」和「距离为正无穷」\n        vector<int> dist(n, INF);\n        vector<bool> vis(n, false);\n        // 只有起点最短距离为 0\n        dist[x] = 0;\n        // 使用「双端队列」存储,存储的是点编号\n        deque<int> d;\n        // 将「源点/起点」进行入队,并标记「已入队」\n        d.push_back(x);\n        vis[x] = true;\n        while (!d.empty()) {\n            // 每次从「双端队列」中取出,并标记「未入队」\n            int u = d.front();\n            d.pop_front();\n            vis[u] = false;\n            // 尝试使用该点,更新其他点的最短距离\n            // 如果更新的点,本身「未入队」则加入队列中,并标记「已入队」\n            for (int i = he[u]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (dist[j] <= dist[u] + w[i]) continue;\n                dist[j] = dist[u] + w[i];\n                if (vis[j]) continue;\n                d.push_back(j);\n                vis[j] = true;\n            }\n        }\n        return dist;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def findTheCity(self, n: int, edges: List[List[int]], distanceThreshold: int) -> int:\n        m, INF, idx = n * n, 0x3f3f3f3f, 0\n        he, e, ne, w = [-1] * n, [0] * m, [0] * m, [0] * m\n\n        def add(a: int, b: int, c: int):\n            nonlocal idx\n            e[idx] = b\n            ne[idx] = he[a]\n            w[idx] = c\n            he[a] = idx\n            idx += 1\n\n        def spfa(x: int) -> List[int]:\n            # 起始先将所有的点标记为「未入队」和「距离为正无穷」\n            dist = [INF] * n\n            vis = [False] * n\n            # 只有起点最短距离为 0\n            dist[x] = 0\n            # 使用「双端队列」存储,存储的是点编号\n            d = deque()\n            # 将「源点/起点」进行入队,并标记「已入队」\n            d.append(x)\n            vis[x] = True\n            while d:\n                # 每次从「双端队列」中取出,并标记「未入队」\n                u = d.popleft()\n                vis[u] = False\n                i = he[u]\n                # 尝试使用该点,更新其他点的最短距离\n                # 如果更新的点,本身「未入队」则加入队列中,并标记「已入队」\n                while i != -1:\n                    j, c = e[i], w[i]\n                    i = ne[i]\n                    if dist[j] <= dist[u] + c: continue\n                    dist[j] = dist[u] + c\n                    if vis[j]: continue\n                    d.append(j)\n                    vis[j] = True\n            return dist\n\n        for a, b, c in edges:\n            add(a, b, c)\n            add(b, a, c)\n\n        ans, cnt = -1, n + 10\n        for i in range(n):\n            dist = spfa(i)\n            cur = sum(1 for d in dist if d != INF and d <= distanceThreshold)\n            if cur <= cnt:\n                cnt, ans = cur, i\n        return ans\n```\n* 时间复杂度:统计答案时,共执行 $n$ 次 `spfa` 算法, `spfa` 复杂度为 $O(nm)$,总复杂度为 $O(n^2 \\times m)$。整体复杂度为 $O(n^2 \\times m)$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1334` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1331-1340/1337. 矩阵中战斗力最弱的 K 行（简单）.md", "url_title": "1337. 矩阵中战斗力最弱的 K 行", "url": "https://leetcode-cn.com/problems/the-k-weakest-rows-in-a-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-po-su-7okx/", "difficulty": "简单", "tags": ["优先队列(堆)", "二分"], "question": "给你一个大小为 $m * n$ 的矩阵 $mat$,矩阵由若干军人和平民组成,分别用 $1$ 和 $0$ 表示。\n\n请你返回矩阵中战斗力最弱的 $k$ 行的索引,按从最弱到最强排序。\n\n如果第 $i$ 行的军人数量少于第 $j$ 行,或者两行军人数量相同但 $i$ 小于 $j$,那么我们认为第 $i$ 行的战斗力比第 $j$ 行弱。\n\n军人 总是 排在一行中的靠前位置,也就是说 $1$ 总是出现在 $0$ 之前。\n\n示例 1:\n```\n输入:mat = \n[[1,1,0,0,0],\n [1,1,1,1,0],\n [1,0,0,0,0],\n [1,1,0,0,0],\n [1,1,1,1,1]], \nk = 3\n\n输出:[2,0,3]\n\n解释:\n每行中的军人数目:\n行 0 -> 2 \n行 1 -> 4 \n行 2 -> 1 \n行 3 -> 2 \n行 4 -> 5 \n从最弱到最强对这些行排序后得到 [2,0,3,1,4]\n```\n示例 2:\n```\n输入:mat = \n[[1,0,0,0],\n [1,1,1,1],\n [1,0,0,0],\n [1,0,0,0]], \nk = 2\n\n输出:[0,2]\n\n解释: \n每行中的军人数目:\n行 0 -> 1 \n行 1 -> 4 \n行 2 -> 1 \n行 3 -> 1 \n从最弱到最强对这些行排序后得到 [0,2,3,1]\n```\n\n提示:\n* m == mat.length\n* n == mat[i].length\n* 2 <= n, m <= 100\n* 1 <= k <= m\n* matrix[i][j] 不是 0 就是 1", "solution": "### 朴素解法\n\n一个朴素的做法是对矩阵进行遍历,统计每一行的军人数量,并以二元组 $(cnt_i, idx_i)$ 的形式进行存储。\n\n然后对所有行的战力进行排序,选出战力最小的 $k$ 个下标即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int[] kWeakestRows(int[][] mat, int k) {\n        int m = mat.length, n = mat[0].length;\n        int[][] all = new int[m][1];\n        for (int i = 0; i < m; i++) {\n            int cur = 0;\n            for (int j = 0; j < n; j++) cur += mat[i][j];\n            all[i] = new int[]{cur, i};\n        }\n        Arrays.sort(all, (a, b)->{\n            if (a[0] != b[0]) return a[0] - b[0];\n            return a[1] - b[1];\n        });\n        int[] ans = new int[k];\n        for (int i = 0; i < k; i++) ans[i] = all[i][1];\n        return ans;\n    }\n}\n```\n* 时间复杂度:遍历矩阵的复杂度为 $O(m * n)$;排序复杂度为 $O(m\\log{m})$;构造答案复杂度为 $O(k)$。整体复杂度为 $O(\\max(m * n, m\\log{m}))$\n* 空间复杂度:$O(m)$ 空间用于存储所有的行战力;$O(\\log{m})$ 空间用于排序。整体复杂度为 $O(m + \\log{m})$\n\n---\n\n### 二分 + 优先队列(堆)\n\n根据「军人总是排在靠前位置」的特性,我们可以通过「二分」找到每一行最后一个军人的位置,从而在 $O(\\log{n})$ 的复杂度内统计出每行的军人数量(战力情况)。\n\n同时由于我们只需要「战力最弱」的 $k$ 行数据,这引导我们可以建立一个「战力大根堆」来做,「战力大根堆」存放着数量最多为 $k$ 的战力二元组 $(cnt_i, idx_i)$,堆顶元素为战力最大的数对。\n\n每次通过「二分」得到当前行的战力值后,判断当前战力值与堆顶元素的战力大小关系:\n\n* 如果当前战力值比堆顶的元素要大:直接丢弃当前战力值(不可能属于在第 $k$ 小的集合中);\n* 如果当前战力值比堆顶的元素要小:将堆顶元素弹出,将当前行放入堆中。\n\n> 一些细节:每次写二分都有同学会问,`check` 函数怎么写,可以重点看看 [34 题题解](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/gong-shui-san-xie-kao-cha-dui-er-fen-de-86bk0/)。由于考虑某行没有军人的情况,我们需要二分完检查一下分割点是否符合 `check` 来决定军人数量。\n另外,从堆弹出和往堆存入,需要与当前堆元素的数量有所关联。\n\n代码:\n```Java\nclass Solution {\n    public int[] kWeakestRows(int[][] mat, int k) {\n        int m = mat.length, n = mat[0].length;\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->{\n            if (a[0] != b[0]) return b[0] - a[0];\n            return b[1] - a[1];\n        });\n        for (int i = 0; i < m; i++) {\n            int l = 0, r = n - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (mat[i][mid] >= 1) l = mid;\n                else r = mid - 1;\n            }\n            int cur = mat[i][r] >= 1 ? r + 1 : r;\n            if (q.size() == k && q.peek()[0] > cur) q.poll();\n            if (q.size() < k) q.add(new int[]{cur, i});\n        }\n        int[] ans = new int[k];\n        int idx = k - 1;\n        while (!q.isEmpty()) ans[idx--] = q.poll()[1];\n        return ans;\n    }\n}\n```\n* 时间复杂度:二分得到每行的战力情况,复杂度为 $O(m\\log{n})$;堆中最多有 $k$ 个元素,将行信息存入堆中复杂度为 $O(m\\log{k});$构造答案复杂度为 $O(k\\log{k})$。整体复杂度为 $O(m * (\\log{n} + \\log{k}))$\n* 空间复杂度:$O(k)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1337` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1341-1350/1342. 将数字变成 0 的操作次数（简单）.md", "url_title": "1342. 将数字变成 0 的操作次数", "url": "https://leetcode-cn.com/problems/number-of-steps-to-reduce-a-number-to-zero/solution/gong-shui-san-xie-note-bie-pian-yi-ti-sh-85fb/", "difficulty": "简单", "tags": ["模拟", "数学"], "question": "给你一个非负整数 `num` ,请你返回将它变成 $0$ 所需要的步数。 如果当前数字是偶数,你需要把它除以 $2$ ;否则,减去 $1$ 。\n\n示例 1:\n```\n输入:num = 14\n\n输出:6\n\n解释:\n步骤 1) 14 是偶数,除以 2 得到 7 。\n步骤 2) 7 是奇数,减 1 得到 6 。\n步骤 3) 6 是偶数,除以 2 得到 3 。\n步骤 4) 3 是奇数,减 1 得到 2 。\n步骤 5) 2 是偶数,除以 2 得到 1 。\n步骤 6) 1 是奇数,减 1 得到 0 。\n```\n示例 2:\n```\n输入:num = 8\n\n输出:4\n\n解释:\n步骤 1) 8 是偶数,除以 2 得到 4 。\n步骤 2) 4 是偶数,除以 2 得到 2 。\n步骤 3) 2 是偶数,除以 2 得到 1 。\n步骤 4) 1 是奇数,减 1 得到 0 。\n```\n示例 3:\n```\n输入:num = 123\n\n输出:12\n```\n\n提示:\n* $0 <= num <= 10^6$", "solution": "### 模拟\n\n根据题意进行模拟:**根据当前 $num$ 的奇偶性进行对应操作,直到 $num$ 为 $0$,返回操作次数。**\n\n代码:\n```Java\nclass Solution {\n    public int numberOfSteps(int num) {\n        int ans = 0;\n        while (num != 0 && ++ans >= 0) num = num % 2 == 0 ? num / 2 : num - 1;\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(\\log{num})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 数学(二进制性质)\n\n目的是使得最终结果的二进制表示均为 $0$,两种操作对二进制数的影响分别为「整体右移」和「消减最低位的 $1$」。\n\n因此整个模拟过程其实是:**如果当前的 $num$ 最低位不为 $1$(偶数),则不断进行右移,直到最低位为 $1$(奇数),然后再对最低位的 $1$ 进行消减,直到二进制表示中的所有 $1$ 均被消减完(结果为 $0$),模拟过程结束。**\n\n换句话说,总的操作次数为 = 右移次数 + 消减次数 :\n\n* 右移次数:$num$ 中最高位 $1$ 的所在的位置;\n* 消减次数:$num$ 中 $1$ 的个数。\n\n代码:\n```Java\nclass Solution {\n    public int numberOfSteps(int num) {\n        return Math.max(getLoc(num) + getCnt(num) - 1, 0);\n    }\n    int getLoc(int x) {\n        for (int i = 31; i >= 0; i--) {\n            if (((x >> i) & 1) == 1) return i + 1;\n        }\n        return -1; // never\n    }\n    int getCnt(int x) {\n        int ans = 0;\n        for (int i = 31; i >= 0; i--) {\n            if (((x >> i) & 1) == 1) ans++;\n        }\n        return ans;\n    }\n}\n```\n-\n```Java\nclass Solution {\n    public int numberOfSteps(int num) {\n        return Math.max(getLoc(num) + getCnt(num) - 1, 0);\n    }\n    int getLoc(int x) {\n        for (int i = 31; i >= 0; i--) {\n            if (((x >> i) & 1) == 1) return i + 1;\n        }\n        return -1; // never\n    }\n    int getCnt(int x) {\n        int ans = 0;\n        while (x != 0 && ++ans >= 0) x -= (x & -x); // lowbit\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $C$ 为 $int$ 二进制表示中的最大长度,复杂度为 $O(C)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1342` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1341-1350/1345. 跳跃游戏 IV（困难）.md", "url_title": "1345. 跳跃游戏 IV", "url": "https://leetcode-cn.com/problems/jump-game-iv/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-q9tb1/", "difficulty": "困难", "tags": ["图论 BFS", "双向 BFS"], "question": "给你一个整数数组 `arr` ,你一开始在数组的第一个元素处(下标为 `0`)。\n\n每一步,你可以从下标 i 跳到下标:\n* `i + 1` 满足:`i + 1 < arr.length`\n* `i - 1` 满足:`i - 1 >= 0`\n* `j` 满足:`arr[i] == arr[j]` 且 `i != j`\n\n请你返回到达数组最后一个元素的下标处所需的 **最少操作次数** 。\n\n注意:任何时候你都不能跳到数组外面。\n\n示例 1:\n```\n输入:arr = [100,-23,-23,404,100,23,23,23,3,404]\n\n输出:3\n\n解释:那你需要跳跃 3 次,下标依次为 0 --> 4 --> 3 --> 9 。下标 9 为数组的最后一个元素的下标。\n```\n示例 2:\n```\n输入:arr = [7]\n\n输出:0\n\n解释:一开始就在最后一个元素处,所以你不需要跳跃。\n```\n示例 3:\n```\n输入:arr = [7,6,9,6,9,6,9,7]\n\n输出:1\n\n解释:你可以直接从下标 0 处跳到下标 7 处,也就是数组的最后一个元素处。\n```\n示例 4:\n```\n输入:arr = [6,1,9]\n\n输出:2\n```\n示例 5:\n```\n输入:arr = [11,22,7,7,7,7,7,7,7,22,13]\n\n输出:3\n```\n\n提示:\n* $1 <= arr.length <= 5 * 10^4$\n* $-10^8 <= arr[i] <= 10^8$", "solution": "### 单向 BFS\n\n根据跳跃规则,我们能够进行「前后跳」和「等值跳」,问题为到达结尾位置的最少步数,容易想到 `BFS`。\n\n为了方便进行「等值跳」,我们可以先使用「哈希表」记录某个值有哪些下标。\n\n在进行 `BFS` 时,假如当前走到的位置为 $t$,我们尝试将 $t - 1$、$t + 1$ 和与 $arr[t]$ 等值的位置进行入队,为了防止重复同队,我们可以使用 $dist$ 数组记录到达某个位置的最小步数(初始化为 `INF`),只有 $dist[ne]$ 为 `INF` 时,该点没有被遍历过,可以入队并更新最小步数。\n\n但光使用 $dist$ 还不能确保复杂度为 $O(n)$,因为每次都需要遍历与 $arr[t]$ 等值的下标,为确保等值下标的遍历只会发生一次,我们需要在将等值下标添加到队列后,将 $arr[t]$ 从哈希表中移除。\n\n容易证明每次将于 $arr[t]$ 的等值元素添加到队列后,将 $arr[t]$ 从哈希表中移除的正确性:\n\n首次检索到 $arr[t]$ 值时,必然是最小步数,记为 $step$,此时 `BFS` 做法将其他等值下标距离更新为 $step + 1$:\n\n* 若 $arr[t]$ 与结尾元素值相等,且 $t$ 为 $n - 1$,此时 $step$ 即是答案;\n* 若 $arr[t]$ 与结尾元素值相等,但 $t$ 不为 $n - 1$,此时会再跳一步到达结尾位置,即 $step + 1$ 为答案。那么是否可能存在使用比 $step + 1$ 更小的步数,也能到达结尾的位置呢?\n    答案是:**可能存在,但如果最后是通过「等值跳」到达结尾位置的话,不可能存在比 $step + 1$ 更小的步数。**\n    由于我们每次加入等值时都会进行哈希表的移除,因此到达 $t$ 的方式不可能是「等值跳」,而只能是「前后跳」。\n    \n    * 假设是通过前跳到达位置 $t$,即点分布如图,步数满足等于 $step + 1$:\n\n    \n\n    * 假设是通过后跳到达位置 $t$,即点分布如图,步数满足「如果是等值跳到达结尾,步数为 $step + 1$」:\n    \n    \n\n    **综上,如果 $n - 1$ 是经过「等值跳」加入队列的话,起所能达到的最小步数必然为发起点 $t$ 的最小步数 $+1$。**\n    \n    **也就是说,即使首次等值跳,加入队列后会将其从哈希表中进行移除,正确性也是可以保证的。**\n\n基于此,我们可以额外增加一个 trick,就是在构建哈希表的时候,使用「倒序」的形式构建等值下标列表,这样可以确保如果最后位置是通过「等值跳」而来是,能够优先出队。\n\n**代码(感谢 [@Benhao](/u/himymben/) 和 [@🍭可乐可乐吗](/u/littletime_cc/) 同学提供的其他语言版本):**\n```Java\nclass Solution {\n    int INF = 0x3f3f3f3f;\n    public int minJumps(int[] arr) {\n        int n = arr.length;\n        Map<Integer, List<Integer>> map = new HashMap<>();\n        // 倒序插入 list,相当于给 deque 增加一个同层「下标越大,优先出队」的作用\n        for (int i = n - 1; i >= 0; i--) { \n            List<Integer> list = map.getOrDefault(arr[i], new ArrayList<>());\n            list.add(i);\n            map.put(arr[i], list);\n        }\n        int[] dist = new int[n];\n        Arrays.fill(dist, INF);\n        Deque<Integer> d = new ArrayDeque<>();\n        d.addLast(0);\n        dist[0] = 0;\n        while (!d.isEmpty()) {\n            int t = d.pollFirst(), step = dist[t];\n            if (t == n - 1) return step;\n            if (t + 1 < n && dist[t + 1] == INF) {\n                d.addLast(t + 1);\n                dist[t + 1] = step + 1;\n            }\n            if (t - 1 >= 0 && dist[t - 1] == INF) {\n                d.addLast(t - 1);\n                dist[t - 1] = step + 1;\n            }\n            List<Integer> list = map.getOrDefault(arr[t], new ArrayList<>());\n            for (int ne : list) {\n                if (dist[ne] == INF) {\n                    d.addLast(ne);\n                    dist[ne] = step + 1;\n                }\n            }\n            map.remove(arr[t]);\n        }\n        return -1; // never\n    }\n}\n```\n-\n```C++\nclass Solution {\npublic:\n    int minJumps(vector<int>& arr) {\n        const int inf = 0x3f3f3f3f;\n        int n = arr.size();\n        unordered_map<int, vector<int>> map;\n        for(int i = n - 1; ~i; i--) {\n            map[arr[i]].push_back(i);\n        }\n        vector<int> dist(n, inf);\n        queue<int> q;\n        q.push(0);\n        dist[0] = 0;\n        while(q.size()) {\n            auto t = q.front(), step = dist[t];\n            q.pop();\n            if(t == n - 1) return step;\n            if(t + 1 < n and dist[t + 1] == inf) {\n                q.push(t + 1);\n                dist[t + 1] = step + 1;\n            }\n            if(t - 1 >= 0 and dist[t - 1] == inf) {\n                q.push(t - 1);\n                dist[t - 1] = step + 1;\n            }\n            const auto& list = map[arr[t]];\n            for(auto ne :list) {\n                if(dist[ne] == inf) {\n                    q.push(ne);\n                    dist[ne] = step + 1;\n                }\n            }\n            map[arr[t]].clear(); //or map.erase(arr[t]);\n        }\n        return -1;\n    }\n};\n```\n-\n```python\nclass Solution:\n    def minJumps(self, arr: List[int]) -> int:\n        n = len(arr)\n        mp = defaultdict(list)\n        for i, num in enumerate(arr):\n            mp[num].append(i)\n        dist = [inf] * n\n        d = deque([0])\n        dist[0] = 0\n        while len(d) > 0:\n            t = d.popleft()\n            step = dist[t]\n            if t == n - 1:\n                return step\n            for ne in mp[arr[t]]:\n                if dist[ne] == inf:\n                    d.append(ne)\n                    dist[ne] = step + 1\n            mp.pop(arr[t])\n            if dist[t + 1] == inf:\n                d.append(t + 1)\n                dist[t + 1] = step + 1\n            if t and dist[t - 1] == inf:\n                d.append(t - 1)\n                dist[t - 1] = step + 1\n        return -1\n```\n-\n```Go\nconst INF int = 0x3f3f3f3f\nfunc minJumps(arr []int) int {\n    n := len(arr)\n    mp := map[int][]int{}\n    dist := make([]int, len(arr))\n    for i := 0; i < n; i++{\n        list := mp[arr[i]]\n        list = append(list, i)\n        mp[arr[i]] = list\n        dist[i] = INF\n    }\n    d := []int{0}\n    dist[0] = 0\n    for len(d) > 0{\n        t := d[0]\n        step := dist[t]\n        if t == n - 1{\n            return step\n        }\n        d = d[1:]\n        list := mp[arr[t]]\n        delete(mp, arr[t])\n        list = append(list, t + 1)\n        if t > 0 {\n            list = append(list, t - 1)\n        }\n        for _, ne := range list {\n            if dist[ne] == INF {\n                dist[ne] = step + 1\n                d = append(d, ne)\n            }\n        }\n    }\n    return -1\n}\n```\n* 时间复杂度:预处理出 `map` 的复杂度为 $O(n)$;跑一遍 `BFS` 得到答案复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 双向 BFS\n\n自然也能够使用「双向 `BFS`」进行求解。\n\n不了解「双向 `BFS`」的同学,可以先看前置🧀:[【图论搜索专题】如何使用「双向 BFS」解决搜索空间爆炸问题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&token=1446568490&lang=zh_CN#rd) & [【图论搜索专题】双向 BFS 模板题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489502&idx=1&sn=dc863d4bc71c4739a4799b9a4558bd01&chksm=fd9cbcc1caeb35d749d0d72f485485527482c27b608c8f4062c29a997ede97a09ce598b58c7f&token=1446568490&lang=zh_CN#rd) 。\n\n双向 `BFS` 能够有效解决搜索空间爆炸问题,本题使用双向 `BFS` 的话,可以不进行哈希表的 `remove` 操作。\n\n代码:\n```Java\nclass Solution {\n    int[] arr;\n    int INF = 0x3f3f3f3f;\n    int n;\n    Map<Integer, List<Integer>> map = new HashMap<>();\n    public int minJumps(int[] _arr) {\n        arr = _arr;\n        n = arr.length;\n        if (n == 1) return 0;\n        for (int i = n - 1; i >= 0; i--) {\n            List<Integer> list = map.getOrDefault(arr[i], new ArrayList<>());\n            list.add(i);\n            map.put(arr[i], list);\n        }\n        Deque<Integer> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();\n        int[] dist1 = new int[n], dist2 = new int[n];\n        Arrays.fill(dist1, INF);\n        Arrays.fill(dist2, INF);\n        d1.addLast(0);\n        dist1[0] = 0;\n        d2.addLast(n - 1);\n        dist2[n - 1] = 0;\n        while (!d1.isEmpty() && !d2.isEmpty()) {\n            int t = -1;\n            if (d1.size() < d2.size()) t = update(d1, d2, dist1, dist2);\n            else t = update(d2, d1, dist2, dist1);\n            if (t != -1) return t;\n        }\n        return -1; // never\n    }\n    int update(Deque<Integer> d1, Deque<Integer> d2, int[] dist1, int[] dist2) {\n        int m = d1.size();\n        while (m-- > 0) {\n            int t = d1.pollFirst(), step = dist1[t];\n            if (t + 1 < n) {\n                if (dist2[t + 1] != INF) return step + 1 + dist2[t + 1];\n                if (dist1[t + 1] == INF) {\n                    d1.addLast(t + 1);\n                    dist1[t + 1] = step + 1;\n                }\n            }\n            if (t - 1 >= 0) {\n                if (dist2[t - 1] != INF) return step + 1 + dist2[t - 1];\n                if (dist1[t - 1] == INF) {\n                    d1.addLast(t - 1);\n                    dist1[t - 1] = step + 1;\n                }\n            }\n            List<Integer> list = map.getOrDefault(arr[t], new ArrayList<>());\n            for (int ne : list) {\n                if (dist2[ne] != INF) return step + 1 + dist2[ne];\n                if (dist1[ne] == INF) {\n                    d1.addLast(ne);\n                    dist1[ne] = step + 1;\n                }\n            }\n            map.remove(arr[t]);\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 其他「图论搜索 / 模拟」内容\n\n题太简单?不如来学习热乎的 [简单图论搜索题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247490011&idx=1&sn=4c8cbd5ad858f571291d47fcef75e75b&chksm=fd9cb2c4caeb3bd2ac442b2d4d1417e8eb6d65b1feca8399179951ebfa132e8a97a3935e7498&token=252055586&lang=zh_CN#rd) 🍭🍭🍭\n\n* [常规 BFS(二维转一维)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489621&idx=1&sn=5d43fb97bc167a50a7aeb4ae2068571c&chksm=fd9cb34acaeb3a5c7e1e2e2a88d460ae2418a3cef615e1abf017b5d58aa1e7f490856d67f800&token=2136593799&lang=zh_CN#rd)\n* [常规 BFS/迭代加深(结合二叉树)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489746&idx=2&sn=9e80b33c12e96369c7a770382a97adbb&chksm=fd9cb3cdcaeb3adb35c708e548851e419b00e41801c98cae146ba29f5bdc49370a43cddf668d&token=252055586&lang=zh_CN#rd)\n* [多源 BFS](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487179&idx=1&sn=e30a662c03fba3861254dbcf3fb9d6f2&chksm=fd9ca5d4caeb2cc205804fd17a2ce86b25d0408adc3417e73154f59d37e7cb17e02374f5122c&scene=178&cur_album_id=1917113998693449732#rd)\n* [双向 BFS](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489502&idx=1&sn=dc863d4bc71c4739a4799b9a4558bd01&chksm=fd9cbcc1caeb35d749d0d72f485485527482c27b608c8f4062c29a997ede97a09ce598b58c7f&scene=178&cur_album_id=1917113998693449732#rd)\n* [双向 BFS II](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&scene=178&cur_album_id=1917113998693449732#rd)\n* [双向 BFS III(结合并查集)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489671&idx=1&sn=c0f64de1a5e4613675f73d2ae43d0708&chksm=fd9cb398caeb3a8eae334c89dee17711fca43a00d93cf63a623792f3aac0c8bf586b4be9cc47&token=2074150457&lang=zh_CN#rd)\n* [灵活运用多种搜索方式(启发式)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489560&idx=2&sn=bb966d868c18d656620a20d31a425b23&chksm=fd9cb307caeb3a11424428f0a88e7f0cb86bb53b3e5a2b9e28683a24bcb3ac151655d2b6419e&scene=178&cur_album_id=1917113998693449732#rd)\n* [灵活运用多种搜索方式 II(启发式)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489588&idx=1&sn=479e4c0627247ab7e20af7909f2a8b64&chksm=fd9cb32bcaeb3a3d4f0bd73f023a92a165edabf212af1db9672a55bed1af7d4e32e8af9964c3&scene=178&cur_album_id=1917113998693449732#rd)\n* [灵活运用多种搜索方式 III(启发式 结合状态压缩)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489985&idx=1&sn=e503ce6ece048062f1d9ebee2572838a&chksm=fd9cb2decaeb3bc8c635c4a6cf0e78d5973723bb6c89a64875828435dc5b90ef07874ef7a6ae&token=252055586&lang=zh_CN#rd)", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1345` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1371-1380/1374. 生成每种字符都是奇数个的字符串（简单）.md", "url_title": "1374. 生成每种字符都是奇数个的字符串", "url": "https://leetcode.cn/problems/generate-a-string-with-characters-that-have-odd-counts/solution/by-ac_oier-i74n/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个整数 `n`,请你返回一个含 `n` 个字符的字符串,其中每种字符在该字符串中都恰好出现 奇数次 。\n\n返回的字符串必须只含小写英文字母。如果存在多个满足题目要求的字符串,则返回其中任意一个即可。\n\n示例 1:\n```\n输入:n = 4\n\n输出:\"pppz\"\n\n解释:\"pppz\" 是一个满足题目要求的字符串,因为 'p' 出现 3 次,且 'z' 出现 1 次。当然,还有很多其他字符串也满足题目要求,比如:\"ohhh\" 和 \"love\"。\n```\n示例 2:\n```\n输入:n = 2\n\n输出:\"xy\"\n\n解释:\"xy\" 是一个满足题目要求的字符串,因为 'x' 和 'y' 各出现 1 次。当然,还有很多其他字符串也满足题目要求,比如:\"ag\" 和 \"ur\"。\n```\n示例 3:\n```\n输入:n = 7\n\n输出:\"holasss\"\n```\n\n提示:\n* $1 <= n <= 500$", "solution": "### 模拟\n\n题目仅规定所用到的字符出现次数均为奇数,并无规定单个字符的最大使用次数。\n\n因此直接根据 $n$ 的奇偶性来做即可,若 $n$ 为奇数,则构造出由 $n$ 个 `b` 拼接的字符串;若 $n$ 为偶数,则构造出由 $1$ 个 `a` 和 $n - 1$ 个 `b` 的拼接字符串。 \n\nJava 代码:\n```Java\nclass Solution {\n    public String generateTheString(int n) {\n        StringBuilder sb = new StringBuilder();\n        if (n % 2 == 0 && --n >= 0) sb.append('a');\n        while (n-- > 0) sb.append('b');\n        return sb.toString();\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction generateTheString(n: number): string {\n    let ans = \"\"\n    if (n % 2 == 0 && --n >= 0) ans += \"a\"\n    while (n-- > 0) ans += \"b\"\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1374` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1371-1380/1380. 矩阵中的幸运数（简单）.md", "url_title": "1380. 矩阵中的幸运数", "url": "https://leetcode-cn.com/problems/lucky-numbers-in-a-matrix/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-9xwg/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个 $m * n$ 的矩阵,矩阵中的数字 **各不相同** 。请你按 **任意** 顺序返回矩阵中的所有幸运数。\n\n幸运数是指矩阵中满足同时下列两个条件的元素:\n\n* 在同一行的所有元素中最小\n* 在同一列的所有元素中最大\n\n示例 1:\n```\n输入:matrix = [[3,7,8],[9,11,13],[15,16,17]]\n\n输出:[15]\n\n解释:15 是唯一的幸运数,因为它是其所在行中的最小值,也是所在列中的最大值。\n```\n示例 2:\n```\n输入:matrix = [[1,10,4,2],[9,3,8,7],[15,16,17,12]]\n\n输出:[12]\n\n解释:12 是唯一的幸运数,因为它是其所在行中的最小值,也是所在列中的最大值。\n```\n示例 3:\n```\n输入:matrix = [[7,8],[1,2]]\n\n输出:[7]\n```\n\n提示:\n* $m == mat.length$\n* $n == mat[i].length$\n* $1 <= n, m <= 50$\n* $1 <= matrix[i][j] <= 10^5$\n* 矩阵中的所有元素都是不同的", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n具体的,创建两个数组 `row` 和 `col` 用于进行预处理,$row[x]$ 含义为第 $x$ 行的最小值,$col[y]$ 为第 $y$ 列的最大值。\n\n然后扫描棋盘取得符合条件的幸运值即可。\n\n代码:\n```Java\nclass Solution {\n    int N = 55;\n    int[] row = new int[N], col = new int[N];\n    public List<Integer> luckyNumbers (int[][] mat) {\n        int n = mat.length, m = mat[0].length;\n        for (int i = 0; i < n; i++) {\n            row[i] = 100001;\n            for (int j = 0; j < m; j++) {\n                row[i] = Math.min(row[i], mat[i][j]);\n                col[j] = Math.max(col[j], mat[i][j]);\n            }\n        }\n        List<Integer> ans = new ArrayList<>();\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                int t = mat[i][j];\n                if (t == row[i] && t == col[j]) ans.add(t);\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n * m)$\n* 空间复杂度:$O(n * m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1380` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1391-1400/1395. 统计作战单位数（中等）.md", "url_title": "1395. 统计作战单位数", "url": "https://leetcode.cn/problems/count-number-of-teams/solution/by-ac_oier-qm3a/", "difficulty": "中等", "tags": ["树状数组", "容斥原理"], "question": "`n` 名士兵站成一排。每个士兵都有一个 独一无二 的评分 `rating` 。\n\n每 $3$ 个士兵可以组成一个作战单位,分组规则如下:\n\n* 从队伍中选出下标分别为 `i`、`j`、`k` 的 $3$ 名士兵,他们的评分分别为 $rating[i]$、$rating[j]$、$rating[k]$\n\n* 作战单位需满足: $rating[i] < rating[j] < rating[k]$ 或者 $rating[i] > rating[j] > rating[k]$ ,其中  $0 <= i < j < k < n$\n\n请你返回按上述条件可以组建的作战单位数量。每个士兵都可以是多个作战单位的一部分。\n\n示例 1:\n```\n输入:rating = [2,5,3,4,1]\n\n输出:3\n\n解释:我们可以组建三个作战单位 (2,3,4)、(5,4,1)、(5,3,1) 。\n```\n示例 2:\n```\n输入:rating = [2,1,3]\n\n输出:0\n\n解释:根据题目条件,我们无法组建作战单位。\n```\n示例 3:\n```\n输入:rating = [1,2,3,4]\n\n输出:4\n```\n\n提示:\n* $n == rating.length$\n* $3 <= n <= 1000$\n* $1 <= rating[i] <= 10^5$\n* `rating` 中的元素都是唯一的", "solution": "### 基本分析\n\n为了方便,我们记 `rating` 为 `rs`。\n\n题目本质是要我们统计所有满足「递增」或「递减」的三元组。换句话说,对于每个 $t = rs[i]$ 而言,我们需要统计比其 $t$ 大或比 $t$ 小的数的个数。\n\n问题涉及「单点修改(更新数值 $t$ 的出现次数)」以及「区间查询(查询某段范围内数的个数)」,使用「树状数组」求解较为合适。\n\n---\n\n### 树状数组 - 枚举两端\n\n一个朴素的想法是,对于三元组 $(i, j, k)$,我们枚举其两端 $i$ 和 $k$,根据 $rs[i]$ 和 $rs[k]$ 的大小关系,查询范围 $[i + 1, k - 1]$ 之间合法的数的个数。\n\n在确定左端点 $i$ 时,我们从 $i + 1$ 开始「从小到大」枚举右端点 $k$,并将遍历过程中经过的 $rs[k]$ 添加到树状数组进行计数。\n\n处理过程中根据 $a = rs[i]$ 和 $b = rs[k]$ 的大小关系进行分情况讨论:\n\n* 当 $a < b$ 时,我们需要在范围 $[i + 1, k - 1]$ 中找「大于 $a$」同时「小于 $b$」的数的个数,即 `query(b - 1) - query(a)`\n* 当 $a > b$ 时,我们需要在范围 $[i + 1, k - 1]$ 中找「小于 $a$」同时「大于 $b$」的数的个数,即 `query(a - 1) - query(b)`\n\n一些细节:显然我们需要在枚举每个左端点 $i$ 时清空树状数组,但注意不能使用诸如 `Arrays.fill(tr, 0)` 的方式进行清空。\n\n因为在没有离散化的情况下,树状数组的大小为 $m = 1e5$,即执行 `Arrays.fill` 操作的复杂度为 $O(m)$,这会导致我们计算量为至少为 $n \\times m = 1e8$,会有 `TLE`  风险。\n\n因此一个合适做法是:在 $[i + 1, n - 1]$ 范围内枚举完 $k$ 后(进行的是 `+1` 计数),再枚举一次 $[i + 1, n - 1]$ 进行一次 `-1` 的计数进行抵消。\n\n代码:\n```Java\nclass Solution {\n    static int N = (int)1e5 + 10;\n    static int[] tr = new int[N];\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void update(int x, int v) {\n        for (int i = x; i < N; i += lowbit(i)) tr[i] += v;\n    }\n    int query(int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];\n        return ans;\n    }\n    public int numTeams(int[] rs) {\n        int n = rs.length, ans = 0;\n        for (int i = 0; i < n; i++) {\n            int a = rs[i];\n            for (int j = i + 1; j < n; j++) {\n                int b = rs[j];\n                if (a < b) ans += query(b - 1) - query(a);\n                else ans += query(a - 1) - query(b);\n                update(b, 1);\n            }\n            for (int j = i + 1; j < n; j++) update(rs[j], -1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $m = 1e5$ 为值域大小,整体复杂度为 $O(n^2\\log{m})$\n* 空间复杂度:$O(m)$\n\n---\n\n### 双树状数组优化 - 枚举中点\n\n我们考虑将 $n$ 的数据范围提升到 $1e4$ 该如何做。\n\n上述解法的瓶颈在于我们枚举三元组中的左右端点,复杂度为 $O(n^2)$,而实际上利用三元组必然递增或递减的特性,我们可以调整为枚举终点 $j$,从而将「枚举点对」调整为「枚举中点」,复杂度为 $O(n)$。\n\n假设当前枚举到的点为 $rs[i]$,问题转换为在 $[0, i - 1]$ 有多少比 $rs[i]$ 小/大 的数,在 $[i + 1, n - 1]$ 有多少比 $rs[i]$ 大/小 的数,然后集合「乘法」原理即可知道 $rs[i]$ 作为三元组中点的合法方案数。\n\n统计 $rs[i]$ 左边的比 $rs[i]$ 大/小 的数很好做,只需要在「从小到大」枚举 $i$ 的过程中,将 $rs[i]$ 添加到树状数组 `tr1` 即可。\n\n对于统计 $rs[i]$ 右边比 $rs[i]$ 小/大 的数,则需要通过「抵消计数」来做,起始我们先将所有 $rs[idx]$ 加入到另外一个树状数组 `tr2` 中(进行 `+1` 计数),然后在从前往后处理每个 $rs[i]$ 的时候,在 `tr2` 中进行 `-1` 抵消,从而确保我们处理每个 $rs[i]$ 时,`tr1` 存储左边的数,`tr2` 存储右边的数。\n\n代码:\n```Java\nclass Solution {\n    static int N = (int)1e5 + 10;\n    static int[] tr1 = new int[N], tr2 = new int[N];\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void update(int[] tr, int x, int v) {\n        for (int i = x; i < N; i += lowbit(i)) tr[i] += v;\n    }\n    int query(int[] tr, int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];\n        return ans;\n    }\n    public int numTeams(int[] rs) {\n        int n = rs.length, ans = 0;\n        Arrays.fill(tr1, 0);\n        Arrays.fill(tr2, 0);\n        for (int i : rs) update(tr2, i, 1);\n        for (int i = 0; i < n; i++) {\n            int t = rs[i];\n            update(tr2, t, -1);\n            ans += query(tr1, t - 1) * (query(tr2, N - 1) - query(tr2, t));\n            ans += (query(tr1, N - 1) - query(tr1, t)) * query(tr2, t - 1);\n            update(tr1, t, 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $m = 1e5$ 为值域大小,整体复杂度为 $O(n\\log{m})$\n* 空间复杂度:$O(m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1395` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1401-1410/1403. 非递增顺序的最小子序列（简单）.md", "url_title": "1403. 非递增顺序的最小子序列", "url": "https://leetcode.cn/problems/minimum-subsequence-in-non-increasing-order/solution/by-ac_oier-766t/", "difficulty": "简单", "tags": ["贪心"], "question": "给你一个数组 `nums`,请你从中抽取一个子序列,满足该子序列的元素之和严格大于未包含在该子序列中的各元素之和。\n\n如果存在多个解决方案,只需返回长度最小的子序列。如果仍然有多个解决方案,则返回元素之和最大的子序列。\n\n与子数组不同的地方在于,「数组的子序列」不强调元素在原数组中的连续性,也就是说,它可以通过从数组中分离一些(也可能不分离)元素得到。\n\n注意,题目数据保证满足所有约束条件的解决方案是唯一的。同时,返回的答案应当按非递增顺序排列。\n\n示例 1:\n```\n输入:nums = [4,3,10,9,8]\n\n输出:[10,9] \n\n解释:子序列 [10,9] 和 [10,8] 是最小的、满足元素之和大于其他各元素之和的子序列。但是 [10,9] 的元素之和最大。 \n```\n示例 2:\n```\n输入:nums = [4,4,7,6,7]\n\n输出:[7,7,6] \n\n解释:子序列 [7,7] 的和为 14 ,不严格大于剩下的其他元素之和(14 = 4 + 4 + 6)。因此,[7,6,7] 是满足题意的最小子序列。注意,元素按非递增顺序返回。  \n```\n示例 3:\n```\n输入:nums = [6]\n\n输出:[6]\n```\n\n提示:\n* $1 <= nums.length <= 500$\n* $1 <= nums[i] <= 100$", "solution": "### 贪心\n\n根据题意,我们可以先对 `nums` 进行排序(升序),然后从后往前开始选择,当首次满足「选择元素之和 严格大于 未选择元素之和」时,必然满足所选元素个数最少,若存在其他同样个数的合法方案,也满足所选方案为元素和最大方案,同时满足答案输出按照非升序要求。\n\nJava 代码:\n```Java\nclass Solution {\n    public List<Integer> minSubsequence(int[] nums) {\n        Arrays.sort(nums);\n        int sum = 0, cur = 0, idx = nums.length - 1;\n        for (int i : nums) sum += i;\n        List<Integer> ans = new ArrayList<>();\n        while (cur <= sum) {\n            sum -= nums[idx];\n            cur += nums[idx];\n            ans.add(nums[idx--]);\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction minSubsequence(nums: number[]): number[] {\n    nums = nums.sort((a,b)=>a-b)\n    let sum = 0, cur = 0, idx = nums.length - 1\n    for (const i of nums) sum += i\n    const ans = new Array<number>()\n    while (cur <= sum) {\n        sum -= nums[idx]\n        cur += nums[idx]\n        ans.push(nums[idx--])\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1403` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1401-1410/1405. 最长快乐字符串（中等）.md", "url_title": "1405. 最长快乐字符串", "url": "https://leetcode-cn.com/problems/longest-happy-string/solution/gong-shui-san-xie-jie-he-you-xian-dui-li-q6fd/", "difficulty": "中等", "tags": ["优先队列(堆)", "贪心"], "question": "如果字符串中不含有任何 `'aaa'`,`'bbb'` 或 `'ccc'` 这样的字符串作为子串,那么该字符串就是一个「快乐字符串」。\n\n给你三个整数 `a`,`b` ,`c`,请你返回 任意一个 满足下列全部条件的字符串 `s`:\n\n* `s` 是一个尽可能长的快乐字符串。\n* `s` 中 最多 有 `a` 个字母 `'a'`、`b` 个字母 `'b'`、`c` 个字母 `'c'` 。\n* `s` 中只含有 `'a'`、`'b'` 、`'c'` 三种字母。\n\n如果不存在这样的字符串 `s` ,请返回一个空字符串 `\"\"`。\n\n示例 1:\n```\n输入:a = 1, b = 1, c = 7\n\n输出:\"ccaccbcc\"\n\n解释:\"ccbccacc\" 也是一种正确答案。\n```\n示例 2:\n```\n输入:a = 2, b = 2, c = 1\n\n输出:\"aabbc\"\n```\n示例 3:\n```\n输入:a = 7, b = 1, c = 0\n\n输出:\"aabaa\"\n\n解释:这是该测试用例的唯一正确答案。\n```\n\n提示:\n* $0 <= a, b, c <= 100$\n* $a + b + c > 0$", "solution": "### 贪心\n\n容易想到:**每次都取当前剩余次数最多的字符来进行构造(前提是满足「不出现形如 `aaa` 字符串」的要求)**。\n\n具体的,可以使用「优先队列(堆)」来实现上述过程,以 `(字符编号, 字符剩余数量)` 的二元组形式进行存储,构建以 `字符剩余数量` 排倒序的「大根堆」:\n\n1. 起始先将 $(0, a)$、$(1, b)$ 和 $(2, c)$ 进行入堆(其中 $123$ 为字符编号,代指 `abc`,同时规定只有剩余数量大于 $0$ 才能入堆);\n2. 每次取出堆顶元素(剩余数量最多的字符),尝试参与答案的构造:\n    1. 不违反连续三个字符相同:则说明当前字符能够追加到当前答案尾部,若追加后还有字符剩余,则更新剩余数量重新入堆;\n    2. 违反连续三个字符相同:说明该字符无法追加到当前答案尾部,此时尝试从堆中取出剩余次数次大的字符(若当前堆为空,说明没有任何合法字符能够追加,直接 break),若次大字符追加后还有字符剩余,则更新剩余数量重新入堆,同时将此前取的最大字符元祖也重新入堆;\n3. 重复步骤 $2$,直到所有字符均被消耗,或循环提前结束。\n\n该做法的正确性:**当 $a = b = c$ 时能够确保所有字符轮流参与构建,得到长度最大的快乐字符串,而该贪心策略(每次尽可能地进行大数消减)可以确保能够尽可能的凑成 $a = b = c$ 的局面,并且凑成该局面过程中不会从有解变为无解。**\n\n代码:\n```Java\nclass Solution {\n    public String longestDiverseString(int a, int b, int c) {\n        StringBuilder sb = new StringBuilder();\n        PriorityQueue<int[]> q = new PriorityQueue<>((x,y)->y[1]-x[1]);\n        if (a > 0) q.add(new int[]{0, a});\n        if (b > 0) q.add(new int[]{1, b});\n        if (c > 0) q.add(new int[]{2, c});\n        while (!q.isEmpty()) {\n            int[] cur = q.poll();\n            int n = sb.length();\n            if (n >= 2 && sb.charAt(n - 1) - 'a' == cur[0] && sb.charAt(n - 2) - 'a' == cur[0]) {\n                if (q.isEmpty()) break;\n                int[] next = q.poll();\n                sb.append((char)(next[0] + 'a'));\n                next[1]--;\n                if (next[1] != 0) q.add(next);\n                q.add(cur);\n            } else {\n                sb.append((char)(cur[0] + 'a'));\n                cur[1]--;\n                if (cur[1] != 0) q.add(cur);\n            }\n        }\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:令答案最大长度为 $n = a + b + c$,优先队列中最多有 $C = 3$ 个元素,复杂度为 $O(n * k * \\log{C})$,其中 $k$ 为构造答案字符串中每个字符所需要的平均「出队 + 入队」次数,$k$ 为一个范围在 $[2,4]$ 的数字\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1405` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1401-1410/1408. 数组中的字符串匹配（简单）.md", "url_title": "1408. 数组中的字符串匹配", "url": "https://leetcode.cn/problems/string-matching-in-an-array/solution/by-ac_oier-k03v/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个字符串数组 `words`,数组中的每个字符串都可以看作是一个单词。\n\n请你按任意顺序返回 `words` 中是其他单词的子字符串的所有单词。\n\n如果你可以删除 `words[j]` 最左侧和/或最右侧的若干字符得到 `word[i]`,那么字符串 `words[i]` 就是 `words[j]` 的一个子字符串。\n\n示例 1:\n```\n输入:words = [\"mass\",\"as\",\"hero\",\"superhero\"]\n\n输出:[\"as\",\"hero\"]\n\n解释:\"as\" 是 \"mass\" 的子字符串,\"hero\" 是 \"superhero\" 的子字符串。\n[\"hero\",\"as\"] 也是有效的答案。\n```\n示例 2:\n```\n输入:words = [\"leetcode\",\"et\",\"code\"]\n\n输出:[\"et\",\"code\"]\n\n解释:\"et\" 和 \"code\" 都是 \"leetcode\" 的子字符串。\n```\n示例 3:\n```\n输入:words = [\"blue\",\"green\",\"bu\"]\n\n输出:[]\n```\n\n提示:\n* $1 <= words.length <= 100$\n* $1 <= words[i].length <= 30$\n* `words[i]` 仅包含小写英文字母。\n* 题目数据保证每个 `words[i]` 都是独一无二的。", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public List<String> stringMatching(String[] ss) {\n        List<String> ans = new ArrayList<>();\n        int n = ss.length;\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                if (i == j) continue;\n                if (ss[j].indexOf(ss[i]) >= 0) {\n                    ans.add(ss[i]);\n                    break;\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction stringMatching(ss: string[]): string[] {\n    const ans = new Array<string>()\n    const n = ss.length\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++) {\n            if (i == j) continue\n            if (ss[j].indexOf(ss[i]) >= 0) {\n                ans.push(ss[i])\n                break\n            }\n        }\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n^2 \\times m^2)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1408` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1401-1410/1410. HTML 实体解析器（中等）.md", "url_title": "1410. HTML 实体解析器", "url": "https://leetcode.cn/problems/html-entity-parser/solutions/2538217/gong-shui-san-xie-jing-dian-zi-fu-chuan-rvdh3/", "difficulty": "中等", "tags": ["模拟", "哈希表"], "question": "「HTML 实体解析器」 是一种特殊的解析器,它将 HTML 代码作为输入,并用字符本身替换掉所有这些特殊的字符实体。\n\nHTML 里这些特殊字符和它们对应的字符实体包括:\n\n* 双引号:字符实体为 `&quot;`,对应的字符是 `\"`。\n* 单引号:字符实体为 `&apos;`,对应的字符是 `'` 。\n* 与符号:字符实体为 `&amp;`,对应对的字符是 `&` 。\n* 大于号:字符实体为 `&gt;`,对应的字符是 `>`。\n* 小于号:字符实体为 `&lt;`,对应的字符是 `<`。\n* 斜线号:字符实体为 `&frasl;`,对应的字符是 `/`。\n\n给你输入字符串 `text`,请你实现一个 HTML 实体解析器,返回解析器解析后的结果。\n\n示例 1:\n```\n输入:text = \"&amp; is an HTML entity but &ambassador; is not.\"\n\n输出:\"& is an HTML entity but &ambassador; is not.\"\n\n解释:解析器把字符实体 &amp; 用 & 替换\n```\n示例 2:\n```\n输入:text = \"and I quote: &quot;...&quot;\"\n\n输出:\"and I quote: \\\"...\\\"\"\n```\n示例 3:\n```\n输入:text = \"Stay home! Practice on Leetcode :)\"\n\n输出:\"Stay home! Practice on Leetcode :)\"\n```\n示例 4:\n```\n输入:text = \"x &gt; y &amp;&amp; x &lt; y is always false\"\n\n输出:\"x > y && x < y is always false\"\n```\n示例 5:\n```\n输入:text = \"leetcode.com&frasl;problemset&frasl;all\"\n\n输出:\"leetcode.com/problemset/all\"\n```\n\n提示:\n* $1 <= text.length <= 10^5$\n* 字符串可能包含 $256$ 个`ASCII` 字符中的任意字符。", "solution": "### 模拟\n\n每个特殊字符均以 `&` 开头,最长一个特殊字符为 `&frasl;`。\n\n从前往后处理 `text`,若遇到 `&` 则往后读取最多 $6$ 个字符(中途遇到结束字符 `;` 则终止),若读取子串为特殊字符,将使用替换字符进行拼接,否则使用原字符进行拼接。\n\nJava 代码:\n```Java\nclass Solution {\n    public String entityParser(String text) {\n        Map<String, String> map = new HashMap<>(){{\n            put(\"&quot;\", \"\\\"\");\n            put(\"&apos;\", \"'\");\n            put(\"&amp;\", \"&\");\n            put(\"&gt;\", \">\");\n            put(\"&lt;\", \"<\");\n            put(\"&frasl;\", \"/\");\n        }};\n        int n = text.length();\n        StringBuilder sb = new StringBuilder();\n        for (int i = 0; i < n; ) {\n            if (text.charAt(i) == '&') {\n                int j = i + 1;\n                while (j < n && j - i < 6 && text.charAt(j) != ';') j++;\n                String sub = text.substring(i, Math.min(j + 1, n));\n                if (map.containsKey(sub)) {\n                    sb.append(map.get(sub));\n                    i = j + 1;\n                    continue;\n                }\n            }\n            sb.append(text.charAt(i++));\n        }\n        return sb.toString();\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    string entityParser(string text) {\n        unordered_map<string, string> entityMap = {\n            {\"&quot;\", \"\\\"\"},\n            {\"&apos;\", \"'\"},\n            {\"&amp;\", \"&\"},\n            {\"&gt;\", \">\"},\n            {\"&lt;\", \"<\"},\n            {\"&frasl;\", \"/\"}\n        };\n        int n = text.length();\n        string ans = \"\";\n        for (int i = 0; i < n; ) {\n            if (text[i] == '&') {\n                int j = i + 1;\n                while (j < n && j - i < 6 && text[j] != ';') j++;\n                string sub = text.substr(i, min(j + 1, n) - i);\n                if (entityMap.find(sub) != entityMap.end()) {\n                    ans += entityMap[sub];\n                    i = j + 1;\n                    continue;\n                }\n            }\n            ans += text[i++];\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def entityParser(self, text: str) -> str:\n        entity_map = {\n            \"&quot;\": \"\\\"\",\n            \"&apos;\": \"'\",\n            \"&amp;\": \"&\",\n            \"&gt;\": \">\",\n            \"&lt;\": \"<\",\n            \"&frasl;\": \"/\"\n        }\n        i, n = 0, len(text)\n        ans = \"\"\n        while i < n:\n            if text[i] == '&':\n                j = i + 1\n                while j < n and j - i < 6 and text[j] != ';':\n                    j += 1\n                sub = text[i:min(j + 1, n)]\n                if sub in entity_map:\n                    ans += entity_map[sub]\n                    i = j + 1\n                    continue\n            ans += text[i]\n            i += 1\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction entityParser(text: string): string {\n    const entityMap: { [key: string]: string } = {\n        \"&quot;\": \"\\\"\",\n        \"&apos;\": \"'\",\n        \"&amp;\": \"&\",\n        \"&gt;\": \">\",\n        \"&lt;\": \"<\",\n        \"&frasl;\": \"/\"\n    };\n    const n = text.length;\n    let ans = \"\";\n    for (let i = 0; i < n; ) {\n        if (text[i] == '&') {\n            let j = i + 1;\n            while (j < n && j - i < 6 && text[j] != ';') j++;\n            const sub = text.substring(i, Math.min(j + 1, n));\n            if (entityMap[sub]) {\n                ans += entityMap[sub];\n                i = j + 1;\n                continue;\n            }\n        }\n        ans += text[i++];\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n \\times K)$,其中 $K = 6$ 为最大特殊字符长度\n* 空间复杂度:$O(C)$,一个固定大小的哈希表", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1410` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/141-150/141. 环形链表（简单）.md", "url_title": "141. 环形链表", "url": "https://leetcode.cn/problems/linked-list-cycle/solution/by-ac_oier-lfgr/", "difficulty": "简单", "tags": ["链表", "快慢指针", "双指针"], "question": "给你一个链表的头节点 `head`,判断链表中是否有环。\n\n如果链表中有某个节点,可以通过连续跟踪 `next` 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 `pos` 来表示链表尾连接到链表中的位置(索引从 $0$ 开始)。注意:`pos` 不作为参数进行传递 。仅仅是为了标识链表的实际情况。\n\n如果链表中存在环 ,则返回 true 。 否则,返回 false 。\n\n示例 1:\n\n```\n输入:head = [3,2,0,-4], pos = 1\n\n输出:true\n\n解释:链表中有一个环,其尾部连接到第二个节点。\n```\n示例 2:\n\n```\n输入:head = [1,2], pos = 0\n\n输出:true\n\n解释:链表中有一个环,其尾部连接到第一个节点。\n```\n示例 3:\n\n```\n输入:head = [1], pos = -1\n\n输出:false\n\n解释:链表中没有环。\n```\n\n提示:\n* 链表中节点的数目范围是 $[0, 10^4]$\n* $-10^5 <= Node.val <= 10^5$\n* `pos` 为 `-1` 或者链表中的一个 有效索引 。\n\n进阶:你能用 $O(1)$(即,常量)内存解决此问题吗?", "solution": "### 快慢指针\n\n这是一道「快慢指针」的模板题。\n\n使用两变量 `slow` 和 `fast` 分别代表快慢指针,`slow` 每次往后走一步,而 `fast` 每次往后两步,两者初始化均为 `head`。\n\n若链表无环,则 `fast` 必然会先走到结尾,算法正常结束;若链表有环,当 `slow` 来到环入口时,`fast` 必然已经在环中的某个位置,此时再继续进行,由于存在速度差,发生相遇必不可能是 `slow` 追上 `fast`,而只能是 `fast` 从后方追上 `slow`,由于速度差为 $1$,因此最多会消耗不超过环节点个数的回合,两者即会相遇。\n\n代码:\n```Java\npublic class Solution {\n    public boolean hasCycle(ListNode head) {\n        ListNode slow = head, fast = head;\n        while (fast != null && fast.next != null) {\n            slow = slow.next; fast = fast.next.next;\n            if (slow == fast) return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.141` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/141-150/142. 环形链表 II（中等）.md", "url_title": "142. 环形链表 II", "url": "https://leetcode.cn/problems/linked-list-cycle-ii/solution/by-ac_oier-xw16/", "difficulty": "中等", "tags": ["链表", "快慢指针", "双指针"], "question": "给定一个链表的头节点  `head`,返回链表开始入环的第一个节点。 如果链表无环,则返回 `null`。\n\n如果链表中有某个节点,可以通过连续跟踪 `next` 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 `pos` 来表示链表尾连接到链表中的位置(索引从 `0` 开始)。如果 `pos` 是 `-1`,则在该链表中没有环。\n\n注意:`pos` 不作为参数进行传递,仅仅是为了标识链表的实际情况。\n\n不允许修改 链表。\n\n示例 1:\n\n```\n输入:head = [3,2,0,-4], pos = 1\n\n输出:返回索引为 1 的链表节点\n\n解释:链表中有一个环,其尾部连接到第二个节点。\n```\n示例 2:\n\n```\n输入:head = [1,2], pos = 0\n\n输出:返回索引为 0 的链表节点\n\n解释:链表中有一个环,其尾部连接到第一个节点。\n```\n示例 3:\n\n```\n输入:head = [1], pos = -1\n\n输出:返回 null\n\n解释:链表中没有环。\n```\n\n提示:\n* 链表中节点的数目范围在范围 $[0, 10^4]$ 内\n* $-10^5 <= Node.val <= 10^5$\n* `pos` 的值为 `-1` 或者链表中的一个有效索引\n\n进阶:你是否可以使用 $O(1)$ 空间解决此题?", "solution": "### 快慢指针\n\n起始使用 `slow` 和 `fast` 作为慢快指针(`slow` 每次走一步,`fast` 每次走两步),起始均为 `head`。\n\n若 `fast` 顺利走到结尾,说明链表无环,直接返回 `null`;\n\n若两者成功相遇,说明链表有环。我们定义链表起点到环入口距离为 `x`,环内节点数量为 `y`。那么从链表起点到环入口的任意路径都能归纳成 $x + k \\times y$(其中 $k$ 为大于等于 $0$ 的任意值)。\n\n当两者首次相遇时,假设 `slow` 走的距离为 `d1`,而 `fast` 走的距离为 `d2`,根据速度差定义可知 $d2 = d1 \\times 2$。同时根据 [141. 环形链表](https://leetcode.cn/problems/linked-list-cycle/solution/by-ac_oier-lfgr/) 结论,两者必然在环中相遇,且必然是 `fast` 在环内从后面追上 `slow`,因此 `d2` 相比于 `d1` 必然是多了 `y` 的整数倍,即有 $d2 = d1 + m \\times y$(其中 $m$ 为圈数),即可推导出 $d1 = m \\times y$。\n\n同时根据链表起点到环入口的任意路径均表示为 $x + k \\times y$,我们知道如果 `slow` 再走 `x` 步会到达环入口,同时链表起点到环入口也是 `x` 步,因此我们可以复用 `fast`,将其复位到链表起点,和 `slow` 一起每次往前一步,当两者再次相遇,必然是同时位于环入口。\n\n同时该做法容易拓展成求 `x` 和求 `y` 等问题。\n\n代码:\n```Java\npublic class Solution {\n    public ListNode detectCycle(ListNode head) {\n        ListNode base = head;\n        ListNode slow = head, fast = head;\n        boolean ok = false;\n        while (!ok && fast != null && fast.next != null) {\n            slow = slow.next; fast = fast.next.next;\n            if (slow == fast) ok = true;\n        }\n        if (!ok) return null;\n        fast = head;\n        while (slow != fast) {\n            slow = slow.next; fast = fast.next;\n        }\n        return slow;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.142` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/141-150/146. LRU 缓存机制（中等）.md", "url_title": "146. LRU 缓存机制", "url": "https://leetcode-cn.com/problems/lru-cache/solution/gong-shui-san-xie-she-ji-shu-ju-jie-gou-68hv2/", "difficulty": "中等", "tags": ["设计", "链表", "哈希表"], "question": "运用你所掌握的数据结构,设计和实现一个  `LRU` (最近最少使用) 缓存机制 。\n实现 `LRUCache` 类:\n\n* `LRUCache(int capacity)` 以正整数作为容量 `capacity` 初始化 `LRU` 缓存\n* `int get(int key)` 如果关键字 `key` 存在于缓存中,则返回关键字的值,否则返回 $-1$ \n* `void put(int key, int value)` 如果关键字已经存在,则变更其数据值;如果关键字不存在,则插入该组「关键字-值」。当缓存容量达到上限时,它应该在写入新数据之前删除最久未使用的数据值,从而为新的数据值留出空间。\n\n进阶:你是否可以在 $O(1)$ 时间复杂度内完成这两种操作?\n\n示例:\n```\n输入\n[\"LRUCache\", \"put\", \"put\", \"get\", \"put\", \"get\", \"put\", \"get\", \"get\", \"get\"]\n[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]\n输出\n[null, null, null, 1, null, -1, null, -1, 3, 4]\n\n解释\nLRUCache lRUCache = new LRUCache(2);\nlRUCache.put(1, 1); // 缓存是 {1=1}\nlRUCache.put(2, 2); // 缓存是 {1=1, 2=2}\nlRUCache.get(1);    // 返回 1\nlRUCache.put(3, 3); // 该操作会使得关键字 2 作废,缓存是 {1=1, 3=3}\nlRUCache.get(2);    // 返回 -1 (未找到)\nlRUCache.put(4, 4); // 该操作会使得关键字 1 作废,缓存是 {4=4, 3=3}\nlRUCache.get(1);    // 返回 -1 (未找到)\nlRUCache.get(3);    // 返回 3\nlRUCache.get(4);    // 返回 4\n```\n\n提示:\n* $1 <= capacity <= 3000$\n* $0 <= key <= 3000$\n* $0 <= value <= 10^4$\n* 最多调用 $3 * 10^4$ 次 `get` 和 `put`", "solution": "### 基本分析\n\nLRU 是一种十分常见的页面置换算法。\n\n将 LRU 翻译成大白话就是:**当不得不淘汰某些数据时(通常是容量已满),选择最久未被使用的数据进行淘汰。**\n\n**题目让我们实现一个容量固定的 `LRUCache` 。如果插入数据时,发现容器已满时,则先按照 LRU 规则淘汰一个数据,再将新数据插入,其中「插入」和「查询」都算作一次“使用”。**\n\n可以通过 🌰 来理解,假设我们有容量为 $2$ 的 `LRUCache` 和 测试键值对 `[1-1,2-2,3-3]` ,将其按照顺序进行插入 & 查询:\n* 插入 `1-1`,此时最新的使用数据为 `1-1`\n* 插入 `2-2`,此时最新使用数据变为 `2-2`\n* 查询 `1-1`,此时最新使用数据为 `1-1`\n* 插入 `3-3`,由于容器已经达到容量,需要先淘汰已有数据才能插入,这时候会淘汰 `2-2`,`3-3` 成为最新使用数据\n\n键值对存储方面,我们可以使用「哈希表」来确保插入和查询的复杂度为 $O(1)$。\n\n另外我们还需要额外维护一个「使用顺序」序列。\n\n我们期望当「新数据被插入」或「发生键值对查询」时,能够将当前键值对放到序列头部,这样当触发 LRU 淘汰时,只需要从序列尾部进行数据删除即可。\n\n**期望在 $O(1)$ 复杂度内调整某个节点在序列中的位置,很自然想到双向链表。**\n\n----\n\n### 双向链表\n\n具体的,我们使用哈希表来存储「键值对」,键值对的键作为哈希表的 Key,而哈希表的 Value 则使用我们自己封装的 `Node` 类,`Node` 同时作为双向链表的节点。\n\n* 插入:检查当前键值对是否已经存在于哈希表:\n\t\n\t* 如果存在,则更新键值对,并将当前键值对所对应的 `Node` 节点调整到链表头部(`refresh` 操作)\n\t\n\t* 如果不存在,则检查哈希表容量是否已经达到容量:\n\t\t* 没达到容量:插入哈希表,并将当前键值对所对应的 `Node` 节点调整到链表头部(`refresh` 操作)\n\t\t* 已达到容量:先从链表尾部找到待删除元素进行删除(`delete` 操作),然后再插入哈希表,并将当前键值对所对应的 `Node` 节点调整到链表头部(`refresh` 操作)\n\n* 查询:如果没在哈希表中找到该 Key,直接返回 $-1$;如果存在该 Key,则将对应的值返回,并将当前键值对所对应的 `Node` 节点调整到链表头部(`refresh` 操作)\n\n一些细节: 为了减少双向链表左右节点的「判空」操作,我们预先建立两个「哨兵」节点 `head` 和 `tail`。\n\n代码:\n```Java\nclass LRUCache {\n    class Node {\n        int k, v;\n        Node l, r;\n        Node(int _k, int _v) {\n            k = _k;\n            v = _v;\n        }\n    }\n    int n;\n    Node head, tail;\n    Map<Integer, Node> map;\n    public LRUCache(int capacity) {\n        n = capacity;\n        map = new HashMap<>();\n        head = new Node(-1, -1);\n        tail = new Node(-1, -1);\n        head.r = tail;\n        tail.l = head;\n    }\n    \n    public int get(int key) {\n        if (map.containsKey(key)) {\n            Node node = map.get(key);\n            refresh(node);\n            return node.v;\n        } \n        return -1;\n    }\n    \n    public void put(int key, int value) {\n        Node node = null;\n        if (map.containsKey(key)) {\n            node = map.get(key);\n            node.v = value;\n        } else {\n            if (map.size() == n) {\n                Node del = tail.l;\n                map.remove(del.k);\n                delete(del);\n            }\n            node = new Node(key, value);\n            map.put(key, node);\n        }\n        refresh(node);\n    }\n\t\n    // refresh 操作分两步:\n    // 1. 先将当前节点从双向链表中删除(如果该节点本身存在于双向链表中的话)\n    // 2. 将当前节点添加到双向链表头部\n    void refresh(Node node) {\n        delete(node);\n        node.r = head.r;\n        node.l = head;\n        head.r.l = node;\n        head.r = node;\n    }\n\t\n    // delete 操作:将当前节点从双向链表中移除\n    // 由于我们预先建立 head 和 tail 两位哨兵,因此如果 node.l 不为空,则代表了 node 本身存在于双向链表(不是新节点)\n    void delete(Node node) {\n        if (node.l != null) {\n            Node left = node.l;\n            left.r = node.r;\n            node.r.l = left;\n        }\n    }\n}\n```\n* 时间复杂度:各操作均为 $O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.146` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/141-150/149. 直线上最多的点数（困难）.md", "url_title": "149. 直线上最多的点数", "url": "https://leetcode-cn.com/problems/max-points-on-a-line/solution/gong-shui-san-xie-liang-chong-mei-ju-zhi-u44s/", "difficulty": "困难", "tags": ["数学", "枚举", "哈希表"], "question": "给你一个数组 `points`,其中 $points[i] = [x_i, y_i]$ 表示 `X-Y` 平面上的一个点。求最多有多少个点在同一条直线上。\n\n示例 1:\n\n```\n输入:points = [[1,1],[2,2],[3,3]]\n\n输出:3\n```\n示例 2:\n\n```\n输入:points = [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]\n\n输出:4\n```\n\n提示:\n* $1 <= points.length <= 300$\n* $points[i].length == 2$\n* $-10^4 <= x_i, y_i <= 10^4$\n* `points` 中的所有点 互不相同", "solution": "### 枚举直线 + 枚举统计\n\n我们知道,两点可以确定一条线。\n\n一个朴素的做法是先枚举两点(确定一条线),然后检查其余点是否落在该线中。\n\n为避免除法精度问题,当我们枚举两个点 $x$ 和 $y$ 时,不直接计算其对应直线的 `斜率`和 `截距`。\n\n而是通过判断 $x$ 和 $y$ 与第三个点 $p$ 形成的两条直线斜率是否相等,来得知点 $p$ 是否落在该直线上。\n\n斜率相等的两条直线要么平行,要么重合。\n\n平行需要 $4$ 个点来唯一确定,我们只有 $3$ 个点,因此直接判定两条直线是否重合即可。\n\n详细说,当给定两个点 $(x_1, y_1)$ 和 $(x_2, y_2)$ 时,对应斜率 $\\frac{y_2 - y_1}{x_2 - x_1}$。\n\n为避免计算机除法的精度问题,我们将「判定 $\\frac{a_y - b_y}{a_x - b_x} = \\frac{b_y - c_y}{b_x - c_x}$ 是否成立」改为「判定 $(a_y - b_y) \\times (b_x - c_x) = (a_x - b_x) \\times (b_y - c_y)$ 是否成立」。\n\n将存在精度问题的「除法判定」巧妙转为「乘法判定」。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxPoints(int[][] points) {\n        int n = points.length, ans = 1;\n        for (int i = 0; i < n; i++) {\n            int[] x = points[i];\n            for (int j = i + 1; j < n; j++) {\n                int[] y = points[j];\n                // 枚举点对 (i,j) 并统计有多少点在该线上, 起始 cnt = 2 代表只有 i 和 j 两个点在此线上\n                int cnt = 2;\n                for (int k = j + 1; k < n; k++) {\n                    int[] p = points[k];\n                    int s1 = (y[1] - x[1]) * (p[0] - y[0]);\n                    int s2 = (p[1] - y[1]) * (y[0] - x[0]);\n                    if (s1 == s2) cnt++;\n                }\n                ans = Math.max(ans, cnt);\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxPoints(vector<vector<int>>& points) {\n        int n = points.size(), ans = 1;\n        for (int i = 0; i < n; i++) {\n            vector<int> x = points[i];\n            for (int j = i + 1; j < n; j++) {\n                vector<int> y = points[j];\n                // 枚举点对 (i,j) 并统计有多少点在该线上, 起始 cnt = 2 代表只有 i 和 j 两个点在此线上\n                int cnt = 2;\n                for (int k = j + 1; k < n; k++) {\n                    vector<int> p = points[k];\n                    int s1 = (y[1] - x[1]) * (p[0] - y[0]);\n                    int s2 = (p[1] - y[1]) * (y[0] - x[0]);\n                    if (s1 == s2) cnt++;\n                }\n                ans = max(ans, cnt);\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxPoints(self, points: List[List[int]]) -> int:\n        n, ans = len(points), 1\n        for i, x in enumerate(points):\n            for j in range(i + 1, n):\n                y = points[j]\n                # 枚举点对 (i,j) 并统计有多少点在该线上, 起始 cnt = 2 代表只有 i 和 j 两个点在此线上\n                cnt = 2\n                for k in range(j + 1, n):\n                    p = points[k]\n                    s1 = (y[1] - x[1]) * (p[0] - y[0])\n                    s2 = (p[1] - y[1]) * (y[0] - x[0])\n                    if s1 == s2: cnt += 1\n                ans = max(ans, cnt)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction maxPoints(points: number[][]): number {\n    let n = points.length, ans = 1;\n    for (let i = 0; i < n; i++) {\n        let x = points[i];\n        for (let j = i + 1; j < n; j++) {\n            // 枚举点对 (i,j) 并统计有多少点在该线上, 起始 cnt = 2 代表只有 i 和 j 两个点在此线上\n            let y = points[j], cnt = 2;\n            for (let k = j + 1; k < n; k++) {\n                let p = points[k];\n                let s1 = (y[1] - x[1]) * (p[0] - y[0]);\n                let s2 = (p[1] - y[1]) * (y[0] - x[0]);\n                if (s1 == s2) cnt++;\n            }\n            ans = Math.max(ans, cnt);\n        }\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n^3)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 枚举直线 + 哈希表统计\n\n根据「朴素解法」的思路,枚举所有直线的过程不可避免,但统计点数的过程可以优化。\n\n具体的,我们可以先枚举所有可能出现的 `直线斜率`(根据两点确定一条直线,即枚举所有的「点对」),使用「哈希表」统计所有 `斜率` 对应的点的数量,在所有值中取个 $max$ 即是答案。\n\n一些细节:在使用「哈希表」进行保存时,为了避免精度问题,我们直接使用字符串进行保存,同时需要将 `斜率` 约干净。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxPoints(int[][] points) {\n        int n = points.length, ans = 1;\n        for (int i = 0; i < n; i++) {\n            Map<String, Integer> map = new HashMap<>();\n            // 由当前点 i 发出的直线所经过的最多点数量\n            int max = 0;\n            for (int j = i + 1; j < n; j++) {\n                int x1 = points[i][0], y1 = points[i][1], x2 = points[j][0], y2 = points[j][1];\n                int a = x1 - x2, b = y1 - y2;\n                int k = gcd(a, b);\n                String key = (a / k) + \"_\" + (b / k);\n                map.put(key, map.getOrDefault(key, 0) + 1);\n                max = Math.max(max, map.get(key));\n            }\n            ans = Math.max(ans, max + 1);\n        }\n        return ans;\n    }\n    int gcd(int a, int b) {\n        return b == 0 ? a : gcd(b, a % b);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxPoints(vector<vector<int>>& points) {\n        int n = points.size(), ans = 1;\n        for (int i = 0; i < n; i++) {\n            map<string, int> map;\n            int maxv = 0;\n            for (int j = i + 1; j < n; j++) {\n                int x1 = points[i][0], y1 = points[i][1], x2 = points[j][0], y2 = points[j][1];\n                int a = x1 - x2, b = y1 - y2;\n                int k = gcd(a, b);\n                string key = to_string(a / k) + \"_\" + to_string(b / k);\n                map[key]++;\n                maxv = max(maxv, map[key]);\n            }\n            ans = max(ans, maxv + 1);\n        }\n        return ans;\n    }\n    int gcd(int a, int b) {\n        return b == 0 ? a : gcd(b, a % b);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxPoints(self, points):\n        def gcd(a, b):\n            return a if b == 0 else gcd(b, a % b)\n        \n        n, ans = len(points), 1\n        for i in range(n):\n            mapping = {}\n            maxv = 0\n            for j in range(i + 1, n):\n                x1, y1 = points[i]\n                x2, y2 = points[j]\n                a, b = x1 - x2, y1 - y2\n                k = gcd(a, b)\n                key = str(a // k) + \"_\" + str(b // k)\n                mapping[key] = mapping.get(key, 0) + 1\n                maxv = max(maxv, mapping[key])\n            ans = max(ans, maxv + 1)    \n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction maxPoints(points: number[][]): number {\n    const gcd = function(a: number, b: number): number {\n        return b == 0 ? a : gcd(b, a % b);\n    }\n    let n = points.length, ans = 1;\n    for (let i = 0; i < n; i++) {\n        let mapping = {}, maxv = 0;\n        for (let j = i + 1; j < n; j++) {\n            let x1 = points[i][0], y1 = points[i][1], x2 = points[j][0], y2 = points[j][1];\n            let a = x1 - x2, b = y1 - y2;\n            let k = gcd(a, b);\n            let key = `${a / k}_${b / k}`;\n            mapping[key] = mapping[key] ? mapping[key] + 1 : 1;\n            maxv = Math.max(maxv, mapping[key]);\n        }\n        ans = Math.max(ans, maxv + 1);\n    }\n    return ans;\n};\n```\n* 时间复杂度:枚举所有直线的复杂度为 $O(n^2)$;令坐标值的最大差值为 $m$,`gcd` 复杂度为 $O(\\log{m})$。整体复杂度为 $O(n^2 \\times \\log{m})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.149` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/141-150/150. 逆波兰表达式求值（中等）.md", "url_title": "150. 逆波兰表达式求值", "url": "https://leetcode-cn.com/problems/evaluate-reverse-polish-notation/solution/yi-ti-shuang-jie-xi-tong-zhan-shu-zu-mo-i1eq3/", "difficulty": "中等", "tags": ["表达式计算"], "question": "根据 逆波兰表示法,求表达式的值。\n\n有效的算符包括 +、-、*、/ 。每个运算对象可以是整数,也可以是另一个逆波兰表达式。\n\n说明:\n* 整数除法只保留整数部分。\n* 给定逆波兰表达式总是有效的。换句话说,表达式总会得出有效数值且不存在除数为 0 的情况。\n\n示例 1:\n```\n输入:tokens = [\"2\",\"1\",\"+\",\"3\",\"*\"]\n输出:9\n解释:该算式转化为常见的中缀算术表达式为:((2 + 1) * 3) = 9\n```\n示例 2:\n```\n输入:tokens = [\"4\",\"13\",\"5\",\"/\",\"+\"]\n输出:6\n解释:该算式转化为常见的中缀算术表达式为:(4 + (13 / 5)) = 6\n```\n示例 3:\n```\n输入:tokens = [\"10\",\"6\",\"9\",\"3\",\"+\",\"-11\",\"*\",\"/\",\"*\",\"17\",\"+\",\"5\",\"+\"]\n输出:22\n解释:\n该算式转化为常见的中缀算术表达式为:\n  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5\n= ((10 * (6 / (12 * -11))) + 17) + 5\n= ((10 * (6 / -132)) + 17) + 5\n= ((10 * 0) + 17) + 5\n= (0 + 17) + 5\n= 17 + 5\n= 22\n```\n\n提示:\n* 1 <= tokens.length <= $10^4$\n* tokens[i] 要么是一个算符(\"+\"、\"-\"、\"*\" 或 \"/\"),要么是一个在范围 [-200, 200] 内的整数\n\n逆波兰表达式:\n\n逆波兰表达式是一种后缀表达式,所谓后缀就是指算符写在后面。\n\n* 平常使用的算式则是一种中缀表达式,如 ( 1 + 2 ) * ( 3 + 4 ) 。\n* 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。\n\n逆波兰表达式主要有以下两个优点:\n\n* 去掉括号后表达式无歧义,上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。\n* 适合用栈操作运算:遇到数字则入栈;遇到算符则取出栈顶两个数字进行计算,并将结果压入栈中。", "solution": "### 基本思路\n\n这是一道关于「表达式计算」的题目。\n\n所有的「表达式计算」问题都离不开「栈」。\n\n对于本题,我们可以建立一个「数字栈」,存放所有的数字,当遇到运算符时,从栈中取出两个数进行运算,并将结果放回栈内,整个过程结束后,栈顶元素就是最终结果。\n\n而栈的实现通常有两种:使用数组继续模拟 & 使用系统自带的栈结构\n\n***\n\n### 数组模拟栈解法\n\n代码:\n\n```java []\nclass Solution {\n    public int evalRPN(String[] ts) {\n        int[] d = new int[ts.length];\n        int hh = 0, tt = -1;\n        for (String s : ts) {\n            if (\"+-*/\".contains(s)) {\n                int b = d[tt--], a = d[tt--];\n                d[++tt] = calc(a, b, s);\n            } else {\n                d[++tt] = Integer.parseInt(s);\n            }\n        }\n        return d[tt];\n    }\n    int calc(int a, int b, String op) {\n        if (op.equals(\"+\")) return a + b;\n        else if (op.equals(\"-\")) return a - b;\n        else if (op.equals(\"*\")) return a * b;\n        else if (op.equals(\"/\")) return a / b;\n        else return -1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 自带栈解法\n\n代码:\n```java\nclass Solution {\n    public int evalRPN(String[] ts) {\n        Deque<Integer> d = new ArrayDeque<>();\n        for (String s : ts) {\n            if (\"+-*/\".contains(s)) {\n                int b = d.pollLast(), a = d.pollLast();\n                d.addLast(calc(a, b, s));\n            }  else {\n                d.addLast(Integer.parseInt(s));\n            }\n        }\n        return d.pollLast();\n    }\n    int calc(int a, int b, String op) {\n        if (op.equals(\"+\")) return a + b;\n        else if (op.equals(\"-\")) return a - b;\n        else if (op.equals(\"*\")) return a * b;\n        else if (op.equals(\"/\")) return a / b;\n        else return -1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 其他\n\n关于「表达式计算」,类似的题目在上周的「每日一题」也出现过:\n\n* [224. 基本计算器](https://leetcode-cn.com/problems/basic-calculator/solution/shuang-zhan-jie-jue-tong-yong-biao-da-sh-olym/):包含符号 `+ - ( )`\n\n* [227. 基本计算器 II](https://leetcode-cn.com/problems/basic-calculator-ii/solution/shi-yong-shuang-zhan-jie-jue-jiu-ji-biao-c65k/) :包含符号 `+ - * /`\n\n* [772. 基本计算器 III](https://leetcode-cn.com/problems/basic-calculator-iii/) :有锁题,包含符号 `+ - * / ( )`\n\n* [770. 基本计算器 IV](https://leetcode-cn.com/problems/basic-calculator-iv/) : 包含自定义函数符号", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.150` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1411-1420/1413. 逐步求和得到正数的最小值（简单）.md", "url_title": "1413. 逐步求和得到正数的最小值", "url": "https://leetcode.cn/problems/minimum-value-to-get-positive-step-by-step-sum/solution/by-ac_oier-qo4e/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个整数数组 `nums`。你可以选定任意的正数 `startValue` 作为初始值。\n\n你需要从左到右遍历 `nums` 数组,并将 `startValue` 依次累加上 `nums` 数组中的值。\n\n请你在确保累加和始终大于等于 $1$ 的前提下,选出一个最小的 正数 作为 `startValue`。\n\n示例 1:\n```\n输入:nums = [-3,2,-3,4,2]\n\n输出:5\n\n解释:如果你选择 startValue = 4,在第三次累加时,和小于 1 。\n                累加求和\n                startValue = 4 | startValue = 5 | nums\n                  (4 -3 ) = 1  | (5 -3 ) = 2    |  -3\n                  (1 +2 ) = 3  | (2 +2 ) = 4    |   2\n                  (3 -3 ) = 0  | (4 -3 ) = 1    |  -3\n                  (0 +4 ) = 4  | (1 +4 ) = 5    |   4\n                  (4 +2 ) = 6  | (5 +2 ) = 7    |   2\n```\n示例 2:\n```\n输入:nums = [1,2]\n\n输出:1\n\n解释:最小的 startValue 需要是正数。\n```\n示例 3:\n```\n输入:nums = [1,-2,-3]\n\n输出:5\n```\n\n提示:\n* $1 <= nums.length <= 100$\n* $-100 <= nums[i] <= 100$", "solution": "### 模拟\n\n由于 `startValue` 可设定的最小值为 $1$,我们可以先统计当 `startValue = 1` 时,累加过程中的最小值 `min`。\n\n根据 `min` 是否符合规定(大于等于 $1$)来决定如何调整:\n\n* 若 `min` 满足大于等于 $1$,则 `startValue` 可取最小值 $1$;\n* 若 `min` 不满足大于等于 $1$,计算将 `min` 调整到 $1$ 所需要的值(即 `1 - min`),将其累加到起始值上,即得答案 `2 - min`。\n\nJava 代码:\n```Java\nclass Solution {\n    public int minStartValue(int[] nums) {\n        int n = nums.length, min = 0x3f3f3f3f;\n        for (int i = 0, j = 1; i < n; i++) {\n            j = j + nums[i];\n            min = Math.min(min, j);\n        }\n        return min < 1 ? 2 - min : 1;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction minStartValue(nums: number[]): number {\n    let n = nums.length, min = 0x3f3f3f3f\n    for (let i = 0, j = 1; i < n; i++) {\n        j = j + nums[i]\n        min = Math.min(min, j)\n    }\n    return min < 1 ? 2 - min : 1\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1413` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1411-1420/1414. 和为 K 的最少斐波那契数字数目（中等）.md", "url_title": "1414. 和为 K 的最少斐波那契数字数目", "url": "https://leetcode-cn.com/problems/find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-rgty8/", "difficulty": "中等", "tags": ["数学", "二分", "贪心"], "question": "给你数字 `k` ,请你返回和为 `k` 的斐波那契数字的最少数目,其中,每个斐波那契数字都可以被使用多次。\n\n斐波那契数字定义为:\n\n* F1 = 1\n* F2 = 1\n* Fn = Fn-1 + Fn-2 , 其中 n > 2 。\n\n数据保证对于给定的 `k` ,一定能找到可行解。\n\n示例 1:\n```\n输入:k = 7\n\n输出:2 \n\n解释:斐波那契数字为:1,1,2,3,5,8,13,......\n对于 k = 7 ,我们可以得到 2 + 5 = 7 。\n```\n示例 2:\n```\n输入:k = 10\n\n输出:2 \n\n解释:对于 k = 10 ,我们可以得到 2 + 8 = 10 。\n```\n示例 3:\n```\n输入:k = 19\n\n输出:3 \n\n解释:对于 k = 19 ,我们可以得到 1 + 5 + 13 = 19 。\n```\n\n提示:\n* $1 <= k <= 10^9$", "solution": "### 打表 + 贪心 + 二分\n\n利用 `k` 的数据范围为 $1 <= k <= 10^9$,可以先使用 `static` 进行打表,预处理出值不超过 $10^9$ 的斐波那契数,存入数组 `list` 中。\n\n然后考虑如何使用 `list` 中的数字(可重复)凑成 `k`。\n\n一个直观的想法是:**每次从 `list` 中找到不超过 `k` 的最大数,用于进行对 `k` 的消减,直到 `k` 被消减到 $0$ 为止,消减的次数即是答案。**\n\n而「从 `list` 中找到不超过 `k` 的最大数」这一操作,可使用「二分」。\n\n下面证明该做法的正确性:\n\n假定该做法所得到的可行解序列为 `A`(序列长度为 $ans$),真实最优解序列为 `B`(序列长度为 $min$)。\n\n假设两者长度不等(只能是 $ans > min$),这意味着我们将 `A` 和 `B` 之间的相同的元素去掉后,剩余元素序列有如下结论:\n\n* 「`A` 序列剩余元素之和」等于「`B` 序列剩余元素之和」;\n* 「`A` 序列剩余元素个数」大于「`B` 序列剩余元素个数」。\n\n`A'` 为 `A` 的剩余元素序列,`B'` 为 `B` 的剩余元素序列。\n\n我们知道 `A'` 中的最大数必然大于 `B'` 中的最大数。不可能是等于关系(相等元素均被去掉),也不可能是小于关系,否则在构造 `A` 序列的时候就会按照生成 `B` 序列的方向进行构造。\n\n**但要只靠该性质,要证明不存在满足上述结论的斐波那契数组合仍是困难。**\n\n**我们可以从「斐波那契数」性质出发,挖掘可行解 `A` 的某些性质,然后证明不存在不满足该性质的方案比 `A` 更优即可。**\n\n对于可行解 `A` 而言,由于我们「每次都选择不超过当前 `k` 的最大数」,因此必然**可行解中必然不存在两项相邻的斐波那契数**,否则会在选择 $f_i$ 和 $f_{i+1}$ 之前先因为「每次都选择不超过当前 `k` 的最大数」而先选择 $f_{i+2}$。\n\n同时,由于 $f_i=f_{i-1}+f_{i-2}$、$f_{i+1}=f_{i}+f_{i-1}$ 和 $f_{i+2}=f_{i+1}+f_{i}$ 可得 $2 * f_{i}=f_{i+1}+f_{i-2}$。\n\n也就是说**可行解 `A` 中必然不会出现相同值**,否则会在选择 $f_i$ 之前先因为「每次都选择不超过当前 `k` 的最大数」而先选择 $f_{i+1}$。\n\n该推理对于边界特殊值 $1$ 同样成立,如果可行解 `A` 中存在多个 $1$,则必然会先因为「每次都选择不超过当前 `k` 的最大数」选择 $f_3=2$。\n\n**再根据「斐波那契数奇偶数项求和」可知:$a_1 + a_3 + ... + a_{2n - 1} = a_{2n}$ 和 $a_2 + a_4 + ... + a_{2n} = a_{2n+1} - 1$。**\n\n**综上,可以证明不存在比可行解 `A` 更短的最优解。**\n\n代码:\n```Java\nclass Solution {\n    static List<Integer> list = new ArrayList<>();\n    static {\n        list.add(1);\n        int a = 1, b = 1;\n        while (b <= (int)1e9) {\n            int c = a + b;\n            a = b; b = c;\n            list.add(c);\n        }\n    }\n    public int findMinFibonacciNumbers(int k) {\n        int ans = 0;\n        while (k != 0) {\n            int l = 0, r = list.size() - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (list.get(mid) <= k) l = mid;\n                else r = mid - 1;\n            }\n            k -= list.get(r);\n            ans++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令值不超过 $10^9$ 的斐波那契数的数量为 `C`,复杂度为 $O(\\log{k} * \\log{C})$\n* 空间复杂度:$O(C)$\n\n---\n\n### 贪心\n\n上述做法,由于预处理了所有值不超过 $10^9$ 的斐波那契数,导致无法直接取得「值不超过 `k` 的最大数」,需要再套一层「二分」。\n\n不采用预处理的方式,利用斐波那契数列的递推性质,以及凑成 `k` 的最优解中不包含重复数字的结论,我们可以做到 $O(\\log{k})$ 时间复杂度和 $O(1)$ 空间复杂度。\n\n代码:\n```Java\nclass Solution {\n    public int findMinFibonacciNumbers(int k) {\n        int a = 1, b = 1;\n        while (b <= k) {\n            int c = a + b;\n            a = b; b = c;\n        }\n        int ans = 0;\n        while (k != 0) {\n            if (k >= b) {\n                k -= b; ans++;\n            }\n            int c = b - a;\n            b = a; a = c;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(\\log{k})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1414` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1411-1420/1417. 重新格式化字符串（简单）.md", "url_title": "1417. 重新格式化字符串", "url": "https://leetcode.cn/problems/reformat-the-string/solution/by-ac_oier-uk8z/", "difficulty": "简单", "tags": ["模拟", "双指针"], "question": "给你一个混合了数字和字母的字符串 `s`,其中的字母均为小写英文字母。\n\n请你将该字符串重新格式化,使得任意两个相邻字符的类型都不同。也就是说,字母后面应该跟着数字,而数字后面应该跟着字母。\n\n请你返回重新格式化后的字符串;如果无法按要求重新格式化,则返回一个空字符串。\n\n示例 1:\n```\n输入:s = \"a0b1c2\"\n\n输出:\"0a1b2c\"\n\n解释:\"0a1b2c\" 中任意两个相邻字符的类型都不同。 \"a0b1c2\", \"0a1b2c\", \"0c2a1b\" 也是满足题目要求的答案。\n```\n示例 2:\n```\n输入:s = \"leetcode\"\n\n输出:\"\"\n\n解释:\"leetcode\" 中只有字母,所以无法满足重新格式化的条件。\n```\n示例 3:\n```\n输入:s = \"1229857369\"\n\n输出:\"\"\n\n解释:\"1229857369\" 中只有数字,所以无法满足重新格式化的条件。\n```\n示例 4:\n```\n输入:s = \"covid2019\"\n\n输出:\"c2o0v1i9d\"\n```\n示例 5:\n```\n输入:s = \"ab123\"\n\n输出:\"1a2b3\"\n```\n\n提示:\n* $1 <= s.length <= 500$\n* `s` 仅由小写英文字母和/或数字组成。", "solution": "### 模拟\n\n起始先对字符串 `s` 进行遍历,将其分成字母串和数字串,若两者长度差值超过 $1$,说明无法构造成间隔字符串(返回空串),否则对两字符串使用双指针算法进行构造。\n\nJava 代码:\n```Java\nclass Solution {\n    public String reformat(String s) {\n        StringBuilder a = new StringBuilder(), b = new StringBuilder();\n        for (char c : s.toCharArray()) {\n            if (c >= 'a') a.append(c);\n            else b.append(c);\n        }\n        int n = a.length(), m = b.length(), tot = n + m;\n        if (Math.abs(n - m) > 1) return \"\";\n        StringBuilder sb = new StringBuilder();\n        while (sb.length() != tot) {\n            if (n > m) sb.append(a.charAt(--n));\n            else if (n < m) sb.append(b.charAt(--m));\n            else {\n                if (!sb.isEmpty() && sb.charAt(sb.length() - 1) >= 'a') sb.append(b.charAt(--m));\n                else sb.append(a.charAt(--n));\n            }\n        }\n        return sb.toString();\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction reformat(s: string): string {\n    let a = \"\", b = \"\"\n    for (let i = 0; i < s.length; i++) {\n        if (s[i] >= 'a') a += s[i]\n        else b += s[i]\n    }\n    let n = a.length, m = b.length, tot = n + m\n    if (Math.abs(n - m) > 1) return \"\"\n    let ans = \"\"\n    while (ans.length < tot) {\n        if (n < m) ans += b[--m]\n        else if (n > m) ans += a[--n]\n        else {\n            if (ans.length != 0 && ans[ans.length - 1] >= 'a') ans += b[--m]\n            else ans += a[--n]\n        }\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1417` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1411-1420/1418. 点菜展示表（中等）.md", "url_title": "1418. 点菜展示表", "url": "https://leetcode-cn.com/problems/display-table-of-food-orders-in-a-restaurant/solution/gong-shui-san-xie-ha-xi-biao-yu-hong-hei-jmli/", "difficulty": "中等", "tags": ["数据结构", "哈希表", "红黑树"], "question": "给你一个数组 orders,表示客户在餐厅中完成的订单,确切地说, `orders[i]=[customerNamei,tableNumberi,foodItemi] `,其中 `customerNamei `是客户的姓名,`tableNumberi `是客户所在餐桌的桌号,而 `foodItemi `是客户点的餐品名称。\n\n请你返回该餐厅的 点菜展示表 。在这张表中,表中第一行为标题,其第一列为餐桌桌号 “Table” ,后面每一列都是按字母顺序排列的餐品名称。接下来每一行中的项则表示每张餐桌订购的相应餐品数量,第一列应当填对应的桌号,后面依次填写下单的餐品数量。\n\n注意:客户姓名不是点菜展示表的一部分。此外,表中的数据行应该按餐桌桌号升序排列。\n\n示例 1:\n```\n输入:orders = [[\"David\",\"3\",\"Ceviche\"],[\"Corina\",\"10\",\"Beef Burrito\"],[\"David\",\"3\",\"Fried Chicken\"],[\"Carla\",\"5\",\"Water\"],[\"Carla\",\"5\",\"Ceviche\"],[\"Rous\",\"3\",\"Ceviche\"]]\n\n输出:[[\"Table\",\"Beef Burrito\",\"Ceviche\",\"Fried Chicken\",\"Water\"],[\"3\",\"0\",\"2\",\"1\",\"0\"],[\"5\",\"0\",\"1\",\"0\",\"1\"],[\"10\",\"1\",\"0\",\"0\",\"0\"]] \n\n解释:\n点菜展示表如下所示:\nTable,Beef Burrito,Ceviche,Fried Chicken,Water\n3    ,0           ,2      ,1            ,0\n5    ,0           ,1      ,0            ,1\n10   ,1           ,0      ,0            ,0\n对于餐桌 3:David 点了 \"Ceviche\" 和 \"Fried Chicken\",而 Rous 点了 \"Ceviche\"\n而餐桌 5:Carla 点了 \"Water\" 和 \"Ceviche\"\n餐桌 10:Corina 点了 \"Beef Burrito\" \n```\n示例 2:\n```\n输入:orders = [[\"James\",\"12\",\"Fried Chicken\"],[\"Ratesh\",\"12\",\"Fried Chicken\"],[\"Amadeus\",\"12\",\"Fried Chicken\"],[\"Adam\",\"1\",\"Canadian Waffles\"],[\"Brianna\",\"1\",\"Canadian Waffles\"]]\n\n输出:[[\"Table\",\"Canadian Waffles\",\"Fried Chicken\"],[\"1\",\"2\",\"0\"],[\"12\",\"0\",\"3\"]] \n\n解释:\n对于餐桌 1:Adam 和 Brianna 都点了 \"Canadian Waffles\"\n而餐桌 12:James, Ratesh 和 Amadeus 都点了 \"Fried Chicken\"\n```\n示例 3:\n```\n输入:orders = [[\"Laura\",\"2\",\"Bean Burrito\"],[\"Jhon\",\"2\",\"Beef Burrito\"],[\"Melissa\",\"2\",\"Soda\"]]\n\n输出:[[\"Table\",\"Bean Burrito\",\"Beef Burrito\",\"Soda\"],[\"2\",\"1\",\"1\",\"1\"]]\n```\n\n提示:\n* 1 <= orders.length <= 5 * $10^4$\n* orders[i].length == 3\n* 1 <= customerNamei.length, foodItemi.length <= 20\n* customerNamei 和 foodItemi 由大小写英文字母及空格字符 ' ' 组成。\n* tableNumberi 是 1 到 500 范围内的整数。", "solution": "### 基本分析\n\n这是一道考虑「数据结构运用」与「简单设计」的模拟题。\n\n我们可以根据最终的 “结果” 反推数据结构存储格式。\n\n最终 “结果” 包含两部分:\n\n1. `title` : 由 **\"Table\" + 排序去重的餐品** 组成\n2. 内容 : 由 **桌号 + 每件餐品对应的数量** 组成\n\n基于此,不难设计出使用 `Set` 存储 `title` 相关内容,使用 `Map` 存储内容相关部分。\n\n去重 `Map` 的部分 `Key` 为桌号,同时为了快速索引当前桌号「某个餐品的数量」,需要再套一层 `Map`。即最终存储格式为 `桌号 : {餐品 : 个数}`。\n\n---\n\n### HashSet & HashMap\n\n有了基本分析,我们可以使用最常规的 `HashSet` 和 `HashMap` 进行实现。\n\n由于 `HashSet` 是基于 `HashMap`,而 `HashMap` 的底层数据结构实现是 **哈希表**,因此我们需要在构造答案时手动排个序。\n\n代码:\n```Java\nclass Solution {\n    public List<List<String>> displayTable(List<List<String>> os) {\n        List<List<String>> ans = new ArrayList<>();\n        // 桌号 : {餐品 : 个数}(用于构造内容)\n        Map<Integer, Map<String, Integer>> tm = new HashMap<>(); \n        // 餐品(用于构造 title)\n        Set<String> ts = new HashSet<>(); \n        for (List<String> o : os) {\n            String c = o.get(0), t = o.get(1), f = o.get(2);\n            Integer tidx = Integer.parseInt(t);\n            ts.add(f);\n            Map<String, Integer> map = tm.getOrDefault(tidx, new HashMap<>());\n            map.put(f, map.getOrDefault(f, 0) + 1);\n            tm.put(tidx, map);\n        }\n        int n = tm.size() + 1, m = ts.size() + 1;\n        // 构造 title & 手动排序\n        List<String> foods = new ArrayList<>(ts);\n        Collections.sort(foods); \n        List<String> title = new ArrayList<>();\n        title.add(\"Table\");\n        title.addAll(foods);\n        ans.add(title);\n        // 构造内容 & 手动排序\n        List<Integer> tables = new ArrayList<>(tm.keySet());\n        Collections.sort(tables); \n        for (int tidx : tables) {\n            Map<String, Integer> map = tm.get(tidx);\n            List<String> cur = new ArrayList<>();\n            cur.add(tidx + \"\");\n            for (String food : foods) {\n                cur.add(map.getOrDefault(food, 0) + \"\");\n            }\n            ans.add(cur);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:`HashSet` 和 `HashMap` 的基本操作都是 $O(1)$。预处理所有的订单复杂度为 $O(n)$;去重后的桌数为 $r$,餐品数量为 $c$,对两者排序的复杂度分别为 $O(r\\log{r})$ 和 $O(c\\log{c})$;构造答案复杂度为 $O(r * c)$;最终复杂度为 $O(\\max(n, r\\log{r}, c\\log{c}, r * c))$\n* 空间复杂度:$O(r + c + r * c)$\n\n---\n\n### TreeSet & TreeMap\n\n与 `HashSet` 和 `HashMap` 的关系类似,`TreeSet` 是基于 `TreeMap` 实现的,而 `TreeMap` 底层数据结构实现是 **红黑树**。\n\n**得益于 Java 的「面向接口编程(IOP)」设计,我们可以毫不费力的将解法一中的 `HashSet` 替换成 `TreeSet`、将 `HashMap` 替换成 `TreeMap`,并删除手动排序相关代码,得到我们的解法二。**\n\n利用 `TreeMap` 的默认排序规则(数值升序、非数值字典序升序)来简化我们的实现。\n\n但需要注意的是,利用 `TreeMap` 的内部有序特性,调整操作可能会发生在每一次插入操作中,而解法一则是利用 `Collections.sort` 进行一次性的排序,对于非自定义类 `Collections.sort` 是基于 `Arrays.sort` 实现的,会根据「数组大小」、「数组本身是否大致有序」等因素综合决定最终的排序方案,在数据完全随机的情况下,执行效率很大程度要优于 `TreeMap` 的多次调整,但两者复杂度都是 $O(n\\log{n})$。\n\n因此在所有数据都提前给定的「离线」情况下,其实更推荐使用解法一。\n\n代码:\n```Java\nclass Solution {\n    public List<List<String>> displayTable(List<List<String>> os) {\n        List<List<String>> ans = new ArrayList<>();\n        // 桌号 : {餐品 : 个数}(用于构造内容)\n        Map<Integer, Map<String, Integer>> tm = new TreeMap<>(); \n        // 餐品(用于构造 title)\n        Set<String> ts = new TreeSet<>(); \n        for (List<String> o : os) {\n            String c = o.get(0), t = o.get(1), f = o.get(2);\n            Integer tidx = Integer.parseInt(t);\n            ts.add(f);\n            Map<String, Integer> map = tm.getOrDefault(tidx, new HashMap<>());\n            map.put(f, map.getOrDefault(f, 0) + 1);\n            tm.put(tidx, map);\n        }\n        int n = tm.size() + 1, m = ts.size() + 1;\n        // 构造 title\n        List<String> title = new ArrayList<>();\n        title.add(\"Table\");\n        title.addAll(ts);\n        ans.add(title);\n        // 构造内容\n        for (int tidx : tm.keySet()) {\n            Map<String, Integer> map = tm.get(tidx);\n            List<String> cur = new ArrayList<>();\n            cur.add(tidx + \"\");\n            for (String food : ts) {\n                cur.add(map.getOrDefault(food, 0) + \"\");\n            }\n            ans.add(cur);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:`TreeSet` 和 `TreeMap` 的基本操作都是 $O(log{k})$。预处理所有的订单复杂度为 $O(n\\log{n})$;去重后的桌数为 $r$,餐品数量为 $c$,构造答案复杂度为 $O(r\\log{r} * c\\log{c})$;最终复杂度为 $O(\\max(n\\log{n}, r\\log{r} * c\\log{c}))$\n* 空间复杂度:$O(r + c + r * c)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1418` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1421-1430/1422. 分割字符串的最大得分（简单）.md", "url_title": "1422. 分割字符串的最大得分", "url": "https://leetcode.cn/problems/maximum-score-after-splitting-a-string/solution/by-ac_oier-3wua/", "difficulty": "简单", "tags": ["前缀和", "模拟"], "question": "给你一个由若干 `0` 和 `1` 组成的字符串 `s` ,请你计算并返回将该字符串分割成两个非空子字符串(即左子字符串和右子字符串)所能获得的最大得分。\n\n「分割字符串的得分」为左子字符串中 `0` 的数量加上右子字符串中 `1` 的数量。\n\n示例 1:\n```\n输入:s = \"011101\"\n\n输出:5 \n\n解释:\n将字符串 s 划分为两个非空子字符串的可行方案有:\n左子字符串 = \"0\" 且 右子字符串 = \"11101\",得分 = 1 + 4 = 5 \n左子字符串 = \"01\" 且 右子字符串 = \"1101\",得分 = 1 + 3 = 4 \n左子字符串 = \"011\" 且 右子字符串 = \"101\",得分 = 1 + 2 = 3 \n左子字符串 = \"0111\" 且 右子字符串 = \"01\",得分 = 1 + 1 = 2 \n左子字符串 = \"01110\" 且 右子字符串 = \"1\",得分 = 2 + 1 = 3\n```\n示例 2:\n```\n输入:s = \"00111\"\n\n输出:5\n\n解释:当 左子字符串 = \"00\" 且 右子字符串 = \"111\" 时,我们得到最大得分 = 2 + 3 = 5\n```\n示例 3:\n```\n输入:s = \"1111\"\n\n输出:3\n```\n\n提示:\n* $2 <= s.length <= 500$\n* 字符串 `s` 仅由字符 `'0'` 和 `'1'` 组成。", "solution": "### 前缀和\n\n构建前缀和数组来记录每个前缀中 $1$ 个个数,复杂度为 $O(n)$,枚举每个分割点,搭配前缀和数组计算左串中 $0$ 的数量和右串中 $1$ 的数量,取所有得分的最大值即是答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxScore(String s) {\n        int n = s.length(), ans = 0;\n        int[] sum = new int[n + 10];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (s.charAt(i - 1) - '0');\n        for (int i = 1; i <= n - 1; i++) {\n            int a = i - sum[i], b = sum[n] - sum[i];\n            ans = Math.max(ans, a + b);\n        }\n        return ans;\n    }\n}\n```\nTypescript 代码:\n```Typescript\nfunction maxScore(s: string): number {\n    let n = s.length, ans = 0\n    const sum = new Array<number>(n + 10).fill(0)\n    for (let i = 1; i <= n; i++) sum[i] = sum[i - 1] + (s[i - 1] == '1' ? 1 : 0)\n    for (let i = 1; i <= n - 1; i++) {\n        const a = i - sum[i], b = sum[n] - sum[i]\n        ans = Math.max(ans, a + b)\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 模拟\n\n更进一步,利用 `s` 中有只有 $0$ 和 $1$,我们可以遍遍历 `s` 边计算得分(而无须预处理前缀和数组),起始分割点为 `s[0]`,此时得分为 `s[0]` 中 $0$ 的个数加上 `s[1...(n-1)]` 中 $1$ 的个数。\n\n然后继续往后处理 `s`,当 $s[i] = 0$,说明有一个 $0$ 从右串中移到了左串,并且 $0$ 在右串中不得分,在左串中得分,因此总得分加一;而当 $s[i] = 1$,说明有一个 $1$ 从右串中移到了左串,而 $1$ 在右串中得分,在左串中不得分,因此总得分减一。在所有得分中取最大值即是答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxScore(String s) {\n        int n = s.length(), cur = s.charAt(0) == '0' ? 1 : 0;\n        for (int i = 1; i < n; i++) cur += s.charAt(i) - '0';\n        int ans = cur;\n        for (int i = 1; i < n - 1; i++) {\n            cur += s.charAt(i) == '0' ? 1 : -1;\n            ans = Math.max(ans, cur);\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction maxScore(s: string): number {\n    let n = s.length, cur = s[0] == '0' ? 1 : 0\n    for (let i = 1; i < n; i++) cur += s[i] == '1' ? 1 : 0\n    let ans = cur\n    for (let i = 1; i < n - 1; i++) {\n        cur += s[i] == '0' ? 1 : -1\n        ans = Math.max(ans, cur)\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1422` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1421-1430/1423. 可获得的最大点数（中等）.md", "url_title": "1423. 可获得的最大点数", "url": "https://leetcode.cn/problems/maximum-points-you-can-obtain-from-cards/solutions/2551466/gong-shui-san-xie-zhuan-huan-wei-gu-ding-pbvd/", "difficulty": "中等", "tags": ["滑动窗口"], "question": "几张卡牌排成一行,每张卡牌都有一个对应的点数,点数由整数数组 `cardPoints` 给出。\n\n每次行动,你可以从行的开头或者末尾拿一张卡牌,最终你必须正好拿 `k` 张卡牌。\n\n你的点数就是你拿到手中的所有卡牌的点数之和。\n\n给你一个整数数组 `cardPoints` 和整数 `k`,请你返回可以获得的最大点数。\n\n示例 1:\n```\n输入:cardPoints = [1,2,3,4,5,6,1], k = 3\n\n输出:12\n\n解释:第一次行动,不管拿哪张牌,你的点数总是 1 。但是,先拿最右边的卡牌将会最大化你的可获得点数。最优策略是拿右边的三张牌,最终点数为 1 + 6 + 5 = 12 。\n```\n示例 2:\n```\n输入:cardPoints = [2,2,2], k = 2\n\n输出:4\n\n解释:无论你拿起哪两张卡牌,可获得的点数总是 4 。\n```\n示例 3:\n```\n输入:cardPoints = [9,7,7,9,7,7,9], k = 7\n\n输出:55\n\n解释:你必须拿起所有卡牌,可以获得的点数为所有卡牌的点数之和。\n```\n示例 4:\n```\n输入:cardPoints = [1,1000,1], k = 1\n\n输出:1\n\n解释:你无法拿到中间那张卡牌,所以可以获得的最大点数为 1 。 \n```\n示例 5:\n```\n输入:cardPoints = [1,79,80,1,1,1,200,1], k = 3\n\n输出:202\n```\n\n提示:\n* $1 <= cardPoints.length <= 10^5$\n* $1 <= cardPoints[i] <= 10^4$\n* $1 <= k <= cardPoints.length$", "solution": "### 滑动窗口\n\n从两边选卡片,选 `k` 张,卡片总数量为 `n` 张,即有 `n - k` 张不被选择。\n\n所有卡片总和 `sum` 固定,要使选择的 `k` 张的总和最大,反过来就是要让不被选择的 `n - k` 张总和最小。\n\n原问题等价为:**从 `cardPoints` 中找长度为 `n - k` 的连续段,使其总和最小。**\n\n具体的,用变量 `sum` 代指 `cardPoints` 总和,`cur` 代表长度固定为 `n - k` 的当前窗口总和,`minv` 代表所有长度为 `n - k` 的窗口中总和最小的值。\n\n起始先将滑动窗口压满,取得第一个滑动窗口的目标值 `cur`(同时更新为 `minv`),随后往后继续处理 `cardPoints`,每往前滑动一位,需要删除一个和添加一个元素,并不断更新 `minv`,最终 `sum - minv` 即是答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxScore(int[] cardPoints, int k) {\n        int n = cardPoints.length, len = n - k;\n        int sum = 0, cur = 0;\n        for (int i = 0; i < n; i++) sum += cardPoints[i];\n        for (int i = 0; i < len; i++) cur += cardPoints[i]; \n        int minv = cur;\n        for (int i = len; i < n; i++) { \n            cur = cur + cardPoints[i] - cardPoints[i - len]; \n            minv = Math.min(minv, cur);\n        }\n        return sum - minv;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxScore(vector<int>& cardPoints, int k) {\n        int n = cardPoints.size(), len = n - k;\n        int sum = 0, cur = 0;\n        for (int i = 0; i < n; i++) sum += cardPoints[i];\n        for (int i = 0; i < len; i++) cur += cardPoints[i]; \n        int minv = cur;\n        for (int i = len; i < n; i++) { \n            cur = cur + cardPoints[i] - cardPoints[i - len]; \n            minv = min(minv, cur);\n        }\n        return sum - minv;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxScore(self, cardPoints: List[int], k: int) -> int:\n        n, m = len(cardPoints), len(cardPoints) - k\n        total, cur = sum(cardPoints), sum(cardPoints[:m])\n        minv = cur\n        for i in range(m, n):\n            cur = cur + cardPoints[i] - cardPoints[i - m]\n            minv = min(minv, cur)\n        return total - minv\n```\nTypeScript 代码:\n```TypeScript\nfunction maxScore(cardPoints: number[], k: number): number {\n    const n = cardPoints.length, m = n - k;\n    let tot = 0, cur = 0;\n    for (let i = 0; i < n; i++) tot += cardPoints[i];\n    for (let i = 0; i < m; i++) cur += cardPoints[i];\n    let minv = cur;\n    for (let i = m; i < n; i++) {\n        cur = cur + cardPoints[i] - cardPoints[i - m];\n        minv = Math.min(minv, cur);\n    }\n    return tot - minv;\n};\n```\n* 时间复杂度:每个元素最多滑入和滑出窗口一次,复杂度为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1423` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1431-1440/1436. 旅行终点站（简单）.md", "url_title": "1436. 旅行终点站", "url": "https://leetcode-cn.com/problems/destination-city/solution/gong-shui-san-xie-jian-dan-fang-jia-mo-n-y47c/", "difficulty": "简单", "tags": ["哈希表", "模拟"], "question": "给你一份旅游线路图,该线路图中的旅行线路用数组 paths 表示,其中 paths[i] = [cityAi, cityBi] 表示该线路将会从 cityAi 直接前往 cityBi 。请你找出这次旅行的终点站,即没有任何可以通往其他城市的线路的城市。\n\n题目数据保证线路图会形成一条不存在循环的线路,因此恰有一个旅行终点站。\n\n示例 1:\n```\n输入:paths = [[\"London\",\"New York\"],[\"New York\",\"Lima\"],[\"Lima\",\"Sao Paulo\"]]\n\n输出:\"Sao Paulo\" \n\n解释:从 \"London\" 出发,最后抵达终点站 \"Sao Paulo\" 。本次旅行的路线是 \"London\" -> \"New York\" -> \"Lima\" -> \"Sao Paulo\" 。\n```\n示例 2:\n```\n输入:paths = [[\"B\",\"C\"],[\"D\",\"B\"],[\"C\",\"A\"]]\n\n输出:\"A\"\n\n解释:所有可能的线路是:\n\"D\" -> \"B\" -> \"C\" -> \"A\". \n\"B\" -> \"C\" -> \"A\". \n\"C\" -> \"A\". \n\"A\". \n显然,旅行终点站是 \"A\" 。\n```\n示例 3:\n```\n输入:paths = [[\"A\",\"Z\"]]\n\n输出:\"Z\"\n``` \n\n提示:\n* 1 <= paths.length <= 100\n* paths[i].length == 2\n* 1 <= cityAi.length, cityBi.length <= 10\n* cityAi != cityBi\n* 所有字符串均由大小写英文字母和空格字符组成。", "solution": "### 模拟 + 哈希表\n\n根据题意,我们可以取一个任意城市作为起点,然后使用 $paths$ 中的路线信息开始搜索,直到当前城市无法到达下一个城市,即是答案。\n\n实现上,为了可以快速找到某个城市所能到达的城市,可以先使用哈希表对 $paths$ 中的路线信息进行预处理。\n\n代码:\n```Java\nclass Solution {\n    public String destCity(List<List<String>> ps) {\n        Map<String, String> map = new HashMap<>();\n        for (List<String> p : ps) map.put(p.get(0), p.get(1));\n        String ans = ps.get(0).get(0);\n        while (map.containsKey(ans)) ans = map.get(ans);\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1436` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1431-1440/1438. 绝对差不超过限制的最长连续子数组（中等）.md", "url_title": "1438. 绝对差不超过限制的最长连续子数组", "url": "https://leetcode-cn.com/problems/longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit/solution/xiang-jie-er-fen-hua-dong-chuang-kou-dan-41g1/", "difficulty": "中等", "tags": ["滑动窗口", "单调队列", "二分"], "question": "给你一个整数数组 nums ,和一个表示限制的整数 limit,请你返回最长连续子数组的长度,该子数组中的任意两个元素之间的绝对差必须小于或者等于 limit 。\n\n如果不存在满足条件的子数组,则返回 0 。\n\n \n\n示例 1:\n```\n输入:nums = [8,2,4,7], limit = 4\n输出:2 \n解释:所有子数组如下:\n[8] 最大绝对差 |8-8| = 0 <= 4.\n[8,2] 最大绝对差 |8-2| = 6 > 4. \n[8,2,4] 最大绝对差 |8-2| = 6 > 4.\n[8,2,4,7] 最大绝对差 |8-2| = 6 > 4.\n[2] 最大绝对差 |2-2| = 0 <= 4.\n[2,4] 最大绝对差 |2-4| = 2 <= 4.\n[2,4,7] 最大绝对差 |2-7| = 5 > 4.\n[4] 最大绝对差 |4-4| = 0 <= 4.\n[4,7] 最大绝对差 |4-7| = 3 <= 4.\n[7] 最大绝对差 |7-7| = 0 <= 4. \n因此,满足题意的最长子数组的长度为 2 。\n```\n示例 2:\n```\n输入:nums = [10,1,2,4,7,2], limit = 5\n输出:4 \n解释:满足题意的最长子数组是 [2,4,7,2],其最大绝对差 |2-7| = 5 <= 5 。\n```\n示例 3:\n```\n输入:nums = [4,2,2,2,4,4,2,2], limit = 0\n输出:3\n```\n\n提示:\n* 1 <= nums.length <= $10^5$\n* 1 <= nums[i] <= $10^9$\n* 0 <= limit <= $10^9$", "solution": "### 二分 + 滑动窗口\n\n数据范围是 $10^5$,因此只能考虑「对数解法」和「线性解法」。\n\n对数解法很容易想到「二分」。\n\n在给定 `limit` 的情况下,倘若有「恰好」满足条件的区间长度为 `len`,必然存在满足条件且长度小于等于 `len` 的区间,同时必然不存在长度大于 `len` 且满足条件的区间。\n\n因此长度 `len` 在数轴中具有「二段性」。\n\n**问题转化为「如何判断 `nums` 中是否有长度 `len` 的区间满足绝对值不超过 `limit`」**\n\n我们可以枚举区间的右端点 `r`,那么对应的左端点为 `r - len + 1`,然后使用「单调队列」来保存区间的最大值和最小值。\n\n```java\nclass Solution {\n    public int longestSubarray(int[] nums, int limit) {\n        int n = nums.length;\n        int l = 1, r = n;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (check(nums, mid, limit)) {\n                l = mid;\n            } else {\n                r = mid - 1;\n            }\n        }\n        return r;\n    }\n    boolean check(int[] nums, int len, int limit) {\n        int n = nums.length;\n        Deque<Integer> max = new ArrayDeque<>(), min = new ArrayDeque<>();\n        for (int r = 0, l = r - len + 1; r < n; r++, l = r - len + 1) {\n            if (!max.isEmpty() && max.peekFirst() < l) max.pollFirst();\n            while (!max.isEmpty() && nums[r] >= nums[max.peekLast()]) max.pollLast();\n            max.addLast(r);\n            if (!min.isEmpty() && min.peekFirst() < l) min.pollFirst();\n            while (!min.isEmpty() && nums[r] <= nums[min.peekLast()]) min.pollLast();\n            min.addLast(r);\n            if (l >= 0 && Math.abs(nums[max.peekFirst()] - nums[min.peekFirst()]) <= limit) return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:枚举长度的复杂度为 $O(\\log{n})$,对于每次 `check` 而言,每个元素最多入队和出队常数次,复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n***\n\n### 双指针\n\n上述解法我们是在对 `len` 进行二分,而事实上我们可以直接使用「双指针」解法找到最大值。\n\n始终让右端点 `r` 右移,当不满足条件时让 `l` 进行右移。\n\n同时,还是使用「单调队列」保存我们的区间最值,这样我们只需要对数组进行一次扫描即可得到答案。\n\n```Java\nclass Solution {\n    public int longestSubarray(int[] nums, int limit) {\n        int n = nums.length;\n        int ans = 0;\n        Deque<Integer> max = new ArrayDeque<>(), min = new ArrayDeque<>();\n        for (int r = 0, l = 0; r < n; r++) {\n            while (!max.isEmpty() && nums[r] >= nums[max.peekLast()]) max.pollLast();\n            while (!min.isEmpty() && nums[r] <= nums[min.peekLast()]) min.pollLast();\n            max.addLast(r);\n            min.addLast(r);\n            while (Math.abs(nums[max.peekFirst()] - nums[min.peekFirst()]) > limit) {\n                l++;\n                if (max.peekFirst() < l) max.pollFirst();\n                if (min.peekFirst() < l) min.pollFirst();\n            }\n            ans = Math.max(ans, r - l + 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:每个元素最多入队和出队常数次,复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1438` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1441-1450/1441. 用栈操作构建数组（中等）.md", "url_title": "1441. 用栈操作构建数组", "url": "https://leetcode.cn/problems/build-an-array-with-stack-operations/solution/by-ac_oier-q37s/", "difficulty": "中等", "tags": ["模拟", "构造"], "question": "给你一个数组 `target` 和一个整数 `n`。\n\n每次迭代,需要从  `list = { 1 , 2 , 3 ..., n }` 中依次读取一个数字。\n\n请使用下述操作来构建目标数组 `target` :\n\n* `\"Push\"`:从 `list` 中读取一个新元素, 并将其推入数组中。\n* `\"Pop\"`:删除数组中的最后一个元素。\n\n如果目标数组构建完成,就停止读取更多元素。\n\n题目数据保证目标数组严格递增,并且只包含 `1` 到 `n` 之间的数字。\n\n请返回构建目标数组所用的操作序列。如果存在多个可行方案,返回任一即可。\n\n示例 1:\n```\n输入:target = [1,3], n = 3\n\n输出:[\"Push\",\"Push\",\"Pop\",\"Push\"]\n\n解释: \n读取 1 并自动推入数组 -> [1]\n读取 2 并自动推入数组,然后删除它 -> [1]\n读取 3 并自动推入数组 -> [1,3]\n```\n示例 2:\n```\n输入:target = [1,2,3], n = 3\n\n输出:[\"Push\",\"Push\",\"Push\"]\n```\n示例 3:\n```\n输入:target = [1,2], n = 4\n\n输出:[\"Push\",\"Push\"]\n\n解释:只需要读取前 2 个数字就可以停止。\n```\n\n提示:\n* $1 <= target.length <= 100$\n* $1 <= n <= 100$\n* $1 <= target[i] <= n$\n* `target` 严格递增", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n每次我们将当前处理到 `i` 压入栈中(往答案添加一个 `Push`),然后判断当前处理到的 `i` 是否最新的栈顶元素 $target[j]$ 是否相同。\n\n若不相同则丢弃元素(往答案添加一个 `Pop`),若存在则将指针 `j` 后移,直到构建出目标答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public List<String> buildArray(int[] target, int n) {\n        List<String> ans = new ArrayList<>();\n        int m = target.length;\n        for (int i = 1, j = 0; i <= n && j < m; i++) {\n            ans.add(\"Push\");\n            if (target[j] != i) ans.add(\"Pop\");\n            else j++;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<string> buildArray(vector<int>& target, int n) {\n        int m = target.size();\n        vector<string> ans;\n        for (int i = 1, j = 0; i <= n && j < m; i++) {\n            ans.push_back(\"Push\");\n            if (target[j] != i) ans.push_back(\"Pop\");\n            else j++;\n        }\n        return ans;   \n    }\n};\n```\nPython3 代码:\n```Python\nclass Solution:\n    def buildArray(self, target: List[int], n: int) -> List[str]:\n        ans = []\n        m, i, j = len(target), 1, 0\n        while i <= n and j < m:\n            ans.append(\"Push\")\n            if target[j] != i:\n                ans.append(\"Pop\")\n            else:\n                j += 1\n            i += 1\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction buildArray(target: number[], n: number): string[] {\n    const ans = new Array<string>()\n    const m = target.length\n    for (let i = 1, j = 0; i <= n && j < m; i++) {\n        ans.push(\"Push\")\n        if (target[j] != i) ans.push(\"Pop\")\n        else j++\n    }\n    return ans\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1441` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1441-1450/1442. 形成两个异或相等数组的三元组数目（中等）.md", "url_title": "1442. 形成两个异或相等数组的三元组数目", "url": "https://leetcode-cn.com/problems/count-triplets-that-can-form-two-arrays-of-equal-xor/solution/gong-shui-san-xie-xiang-jie-shi-yong-qia-7gzm/", "difficulty": "中等", "tags": ["数学", "前缀和"], "question": "给你一个整数数组 arr 。\n\n现需要从数组中取三个下标 i、j 和 k ,其中 (0 <= i < j <= k < arr.length) 。\n\na 和 b 定义如下:\n* a = arr[i] ^ arr[i + 1] ^ ... ^ arr[j - 1]\n* b = arr[j] ^ arr[j + 1] ^ ... ^ arr[k]\n注意:^ 表示 按位异或 操作。\n\n请返回能够令 a == b 成立的三元组 (i, j , k) 的数目。\n\n示例 1:\n```\n输入:arr = [2,3,1,6,7]\n\n输出:4\n\n解释:满足题意的三元组分别是 (0,1,2), (0,2,2), (2,3,4) 以及 (2,4,4)\n```\n示例 2:\n```\n输入:arr = [1,1,1,1,1]\n\n输出:10\n```\n示例 3:\n```\n输入:arr = [2,3]\n\n输出:0\n```\n示例 4:\n```\n输入:arr = [1,3,5,7,9]\n\n输出:3\n```\n示例 5:\n```\n输入:arr = [7,11,12,9,5,2,7,17,22]\n\n输出:8\n```\n\n提示:\n* 1 <= arr.length <= 300\n* 1 <= arr[i] <= $10^8$", "solution": "### 基本分析\n\n数据范围是 $10^2$,三元组包含 $i$、$j$ 和 $k$ 三个下标,因此通过「枚举下标」并「每次循环计算异或结果」的 $O(n^4)$ 朴素做法不用考虑了。\n\n相信做过 [1310. 子数组异或查询](https://leetcode-cn.com/problems/xor-queries-of-a-subarray/solution/gong-shui-san-xie-yi-ti-shuang-jie-shu-z-rcgu/) 的同学不难想到可以使用「树状数组」或者「前缀异或」来优化我们「每次循环计算异或结果」的过程。\n\n由于不涉及修改操作,我们优先使用「前缀异或」。经过这样优化之后的复杂度是 $O(n^3)$,可以过。\n\n---\n\n### 前缀异或\n\n预处理出「前缀异或」数组,并枚举三元组的下标。\n\n**本质上是利用集合(区间结果)的容斥原理。只不过前缀和需要利用「减法(逆运算)」做容斥,而前缀异或是利用「相同数值进行异或结果为 $0$(偶数次的异或结果为 $0$)」的特性实现容斥。**\n\n代码:\n```Java\nclass Solution {\n    public int countTriplets(int[] arr) {\n        int n = arr.length;\n        int[] sum = new int[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] ^ arr[i - 1];\n        int ans = 0;\n        for (int i = 1; i <= n; i++) {\n            for (int j = i + 1; j <= n; j++) {\n                for (int k = j; k <= n; k++) {\n                    int a = sum[j - 1] ^ sum[i - 1];\n                    int b = sum[k] ^ sum[j - 1];\n                    if (a == b) ans++;\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^3)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 前缀异或 & 哈希表\n\n我们重新审视一下这道题。\n\n题目其实是要我们 **取得连续的一段区间 $[i, k]$,并在这一段中找到分割点 $j$,使得区间内分割点左边的异或结果为 $a$,分割点右边的异或结果为 $b$。并最终让 $a$ 和 $b$ 相等。**\n\n由 $a$ 与 $b$ 相等,我们可以推导出 $a ⊕ b = 0$,再结合 $a$ 和 $b$ 的由来,**可以推导出 $[i, k]$ 连续一段的异或结果为  $0$**。\n\n再结合我们预处理的「前缀异或」数组,可得:\n\n$$Xor(i, k) = sum[k] ⊕ sum[i - 1] = 0$$\n\n根据公式和「相同数值异或结果为 $0$」特性,我们可以知道 $sum[k]$ 和 $sum[i - 1]$ 数值相等,因此我们可以使用「哈希表」记录每个出现过的异或结果对应的下标集合,从而实现在确定 $k$ 的情况下,通过 $O(1)$ 的复杂度找到所有符合条件的 $i$。\n\n需要注意的是,因为我们「前缀异或」数组的下标是从 $1$ 开始,所以我们需要先往「哈希表」存入一个哨兵 $0$ 作为边界,当然这一步不需要特殊操作,只需要让 $k$ 从 $0$ 开始执行循环即可(利用「前缀异或」数组中下标 $0$ 的值本身为 $0$)。\n\n代码:\n```Java\nclass Solution {\n    public int countTriplets(int[] arr) {\n        int n = arr.length;\n        // 预处理前缀异或数组\n        int[] sum = new int[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] ^ arr[i - 1];\n        int ans = 0;\n        // 记录出现过的异或结果,存储格式:{ 异或结果 : [下标1, 下标2 ...] }\n        Map<Integer, List<Integer>> map = new HashMap<>();\n        for (int k = 0; k <= n; k++) {\n            List<Integer> list = map.getOrDefault(sum[k], new ArrayList<>());\n            for (int idx : list) {\n                int i = idx + 1;\n                ans += k - i;\n            }\n            list.add(k);\n            map.put(sum[k], list);\n        }\n        return ans;\n    }\n}\n```\n```Java\nclass Solution {\n    public int countTriplets(int[] arr) {\n        int n = arr.length;\n        // 事实上,甚至可以不预处理「前缀异或数组」,使用一个变量 xor 边遍历边计算即可\n        int xor = 0, ans = 0;\n        Map<Integer, List<Integer>> map = new HashMap<>();\n        for (int k = 0; k <= n; k++) {\n            if (k >= 1) xor ^= arr[k - 1];\n            List<Integer> list = map.getOrDefault(xor, new ArrayList<>());\n            for (int idx : list) {\n                int i = idx + 1;\n                ans += k - i;\n            }\n            list.add(k);\n            map.put(xor, list);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1442` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1441-1450/1446. 连续字符（简单）.md", "url_title": "1446. 连续字符", "url": "https://leetcode-cn.com/problems/consecutive-characters/solution/gong-shui-san-xie-jian-dan-shuang-zhi-zh-xtv6/", "difficulty": "简单", "tags": ["双指针", "模拟"], "question": "给你一个字符串 `s` ,字符串的「能量」定义为:只包含一种字符的最长非空子字符串的长度。\n\n请你返回字符串的能量。\n\n示例 1:\n```\n输入:s = \"leetcode\"\n\n输出:2\n\n解释:子字符串 \"ee\" 长度为 2 ,只包含字符 'e' 。\n```\n示例 2:\n```\n输入:s = \"abbcccddddeeeeedcba\"\n\n输出:5\n\n解释:子字符串 \"eeeee\" 长度为 5 ,只包含字符 'e' 。\n```\n示例 3:\n```\n输入:s = \"triplepillooooow\"\n\n输出:5\n```\n示例 4:\n```\n输入:s = \"hooraaaaaaaaaaay\"\n\n输出:11\n```\n示例 5:\n```\n输入:s = \"tourist\"\n\n输出:1\n```\n\n提示:\n* $1 <= s.length <= 500$\n* $s$ 只包含小写英文字母。", "solution": "### 双指针\n\n根据题意,使用「双指针」进行扫描计数即可。\n\n代码:\n```Java\nclass Solution {\n    public int maxPower(String s) {\n        int n = s.length(), ans = 1;\n        for (int i = 0; i < n; ) {\n            int j = i;\n            while (j < n && s.charAt(j) == s.charAt(i)) j++;\n            ans = Math.max(ans, j - i);\n            i = j;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1446` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1441-1450/1447. 最简分数（中等）.md", "url_title": "1447. 最简分数", "url": "https://leetcode-cn.com/problems/simplified-fractions/solution/gong-shui-san-xie-jian-dan-shu-lun-yun-y-wma5/", "difficulty": "中等", "tags": ["数学", "最大公约数"], "question": "给你一个整数 `n` ,请你返回所有 $0$ 到 $1$ 之间(不包括 $0$ 和 $1$)满足分母小于等于  `n` 的 最简 分数 。分数可以以 **任意** 顺序返回。\n\n示例 1:\n```\n输入:n = 2\n\n输出:[\"1/2\"]\n\n解释:\"1/2\" 是唯一一个分母小于等于 2 的最简分数。\n```\n示例 2:\n```\n输入:n = 3\n\n输出:[\"1/2\",\"1/3\",\"2/3\"]\n```\n示例 3:\n```\n输入:n = 4\n\n输出:[\"1/2\",\"1/3\",\"1/4\",\"2/3\",\"3/4\"]\n\n解释:\"2/4\" 不是最简分数,因为它可以化简为 \"1/2\" 。\n```\n示例 4:\n```\n输入:n = 1\n\n输出:[]\n```\n\n提示:\n* $1 <= n <= 100$", "solution": "### 数论\n\n数据范围为 $100$ 且数值大小在 $(0, 1)$ 之间,因此枚举「分子 + 分母」的 $O(n^2)$ 做法是可接受的。\n\n于是问题转化为:**如何快速判断两个数组成的分数是否为最简(即判断两个数的最大公约数是否为 $1$)。**\n\n快速求得 $a$ 和 $b$ 的最大公约数的主要方式有两种 :「更相减损法」和「欧几里得算法」,其中「欧几里得算法」的递归实现最为好写,复杂度为 $O(\\log{(a + b)})$,在绝大多数的情况下适用,只有在需要实现高精度时,才会考虑使用「更相减损法」。\n\n而 stein 算法则是没有必要掌握的。\n\n代码:\n```Java\nclass Solution {\n    int gcd(int a, int b) { // 欧几里得算法\n        return b == 0 ? a : gcd(b, a % b);\n    }\n    public List<String> simplifiedFractions(int n) {\n        List<String> ans = new ArrayList<>();\n        for (int i = 1; i < n; i++) {\n            for (int j = i + 1; j <= n; j++) {\n                if (gcd(i, j) == 1) ans.add(i + \"/\" + j);\n            }\n        }\n        return ans;\n    }\n}\n```\n-\n```Java\nclass Solution {\n    int gcd(int a, int b) { // 更相减损法\n        while (true) {\n            if (a > b) a -= b;\n            else if (a < b) b -= a;\n            else return a;\n        }\n    }\n    public List<String> simplifiedFractions(int n) {\n        List<String> ans = new ArrayList<>();\n        for (int i = 1; i < n; i++) {\n            for (int j = i + 1; j <= n; j++) {\n                if (gcd(i, j) == 1) ans.add(i + \"/\" + j);\n            }\n        }\n        return ans;\n    }\n}\n```\n-\n```Java\nclass Solution {\n    int gcd(int a, int b) { // stein\n        if (a == 0 || b == 0) return Math.max(a, b);\n        if (a % 2 == 0 && b % 2 == 0) return 2 * gcd(a >> 1, b >> 1);\n        else if (a % 2 == 0) return gcd(a >> 1, b);\n        else if (b % 2 == 0) return gcd(a, b >> 1);\n        else return gcd(Math.abs(a - b), Math.min(a, b));\n    }\n    public List<String> simplifiedFractions(int n) {\n        List<String> ans = new ArrayList<>();\n        for (int i = 1; i < n; i++) {\n            for (int j = i + 1; j <= n; j++) {\n                if (gcd(i, j) == 1) ans.add(i + \"/\" + j);\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:枚举分子分母的复杂度为 $O(n^2)$;判断两数是否能凑成最简分数复杂度为 $O(\\log{n})$。整体复杂度为 $O(n^2 * \\log{n})$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1447` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1441-1450/1449. 数位成本和为目标值的最大数字（困难）.md", "url_title": "1449. 数位成本和为目标值的最大数字", "url": "https://leetcode-cn.com/problems/form-largest-integer-with-digits-that-add-up-to-target/solution/gong-shui-san-xie-fen-liang-bu-kao-lu-we-uy4y/", "difficulty": "困难", "tags": ["完全背包", "背包问题", "动态规划"], "question": "给你一个整数数组 cost 和一个整数 target 。请你返回满足如下规则可以得到的 最大 整数:\n\n给当前结果添加一个数位(i + 1)的成本为 cost[i] (cost 数组下标从 0 开始)。\n总成本必须恰好等于 target 。\n添加的数位中没有数字 0 。\n由于答案可能会很大,请你以字符串形式返回。\n\n如果按照上述要求无法得到任何整数,请你返回 \"0\" 。\n\n示例 1:\n```\n输入:cost = [4,3,2,5,6,7,2,5,5], target = 9\n输出:\"7772\"\n解释:添加数位 '7' 的成本为 2 ,添加数位 '2' 的成本为 3 。所以 \"7772\" 的代价为 2*3+ 3*1 = 9 。 \"977\" 也是满足要求的数字,但 \"7772\" 是较大的数字。\n 数字     成本\n  1  ->   4\n  2  ->   3\n  3  ->   2\n  4  ->   5\n  5  ->   6\n  6  ->   7\n  7  ->   2\n  8  ->   5\n  9  ->   5\n```\n示例 2:\n```\n输入:cost = [7,6,5,5,5,6,8,7,8], target = 12\n输出:\"85\"\n解释:添加数位 '8' 的成本是 7 ,添加数位 '5' 的成本是 5 。\"85\" 的成本为 7 + 5 = 12 。\n```\n示例 3:\n```\n输入:cost = [2,4,6,2,4,6,4,4,4], target = 5\n输出:\"0\"\n解释:总成本是 target 的条件下,无法生成任何整数。\n```\n示例 4:\n```\n输入:cost = [6,10,15,40,40,40,40,40,40], target = 47\n输出:\"32211\"\n```\n\n提示:\n* cost.length == 9\n* 1 <= cost[i] <= 5000\n* 1 <= target <= 5000", "solution": "### 基本分析\n\n根据题意:给定 $1$~$9$ 几个数字,每个数字都有选择成本,求给定费用情况下,凑成的最大数字是多少。\n\n通常我们会如何比较两数大小关系?\n\n首先我们 **根据长度进行比较,长度较长数字较大**;再者,对于长度相等的数值,**从高度往低位进行比较,找到第一位不同,不同位值大的数值较大。**\n\n其中规则一的比较优先级要高于规则二。\n\n基于此,我们可以将构造分两步进行。\n\n---\n\n### 动态规划 + 贪心\n\n具体的,先考虑「数值长度」问题,每个数字有相应选择成本,所能提供的长度均为 $1$。\n\n问题转换为:**有若干物品,求给定费用的前提下,花光所有费用所能选择的最大价值(物品个数)为多少。**\n\n每个数字可以被选择多次,属于完全背包模型。\n\n当求得最大「数值长度」后,考虑如何构造答案。\n\n根据规则二,**应该尽可能让高位的数值越大越好**,因此我们可以从数值 $9$ 开始往数值 $1$ 遍历,如果状态能够由该数值转移而来,则选择该数值。\n\n*PS. 写了几天两维版本了,大家应该都掌握了叭,今天赶着出门,直接写一维。*\n\n代码:\n```Java\nclass Solution {\n    public String largestNumber(int[] cost, int t) {\n        int[] f = new int[t + 1];\n        Arrays.fill(f, Integer.MIN_VALUE);\n        f[0] = 0;\n        for (int i = 1; i <= 9; i++) {\n            int u = cost[i - 1];\n            for (int j = u; j <= t; j++) {\n                f[j] = Math.max(f[j], f[j - u] + 1);\n            }\n        }\n        if (f[t] < 0) return \"0\";\n        String ans = \"\";\n        for (int i = 9, j = t; i >= 1; i--) {\n            int u = cost[i - 1];\n            while (j >= u && f[j] == f[j - u] + 1) {\n                ans += String.valueOf(i);\n                j -= u;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n * t)$\n* 空间复杂度:$O(t)$\n\n---\n\n### 思考 & 进阶\n\n懂得分两步考虑的话,这道题还是挺简单。虽然是「DP」+「贪心」,但两部分都不难。\n\n其实这道题改改条件/思路,也能衍生出几个版本:\n\n0. **【思考】如何彻底转化为「01 背包」或者「多重背包」来处理?**\n\n    完全背包经过一维优化后时间复杂度为 $O(N * C)$。是否可以在不超过此复杂度的前提下,通过预处理物品将问题转换为另外两种传统背包?\n\n    * 对于「多重背包」答案是可以的。由于给定的最终费用 $t$,我们可以明确算出每个物品最多被选择的次数,可以在 $O(N)$ 的复杂度内预处理额外的 $s[]$ 数组。然后配合「单调队列优化」,做到 $O(N * C)$ 复杂度,整体复杂度不会因此变得更差。\n        但转换增加了「预处理」的计算量。为了让转换变成“更有意义”,我们可以在「预处理」时顺便做一个小优化:**对于相同成本的数字,只保留数值大的数字**。不难证明,当成本相同时,选择更大的数字不会让结果变差。\n\n    * 对于「01 背包」答案是不可以。原因与「多重背包」单纯转换为「01 背包」不会降低复杂度一致。因此本题转换成「01 背包」会使得 $N$ 发生非常数级别的增大。\n\n1. **【进阶】不再是给定数值 $1$~$9$(取消 $cost$ 数组),转为给定 $nums$ 数组(代表所能选择的数字,不包含 $0$),和相应 $price$ 数组(长度与 $nums$ 一致,代表选择 $nums[i]$ 所消耗的成本为 $price[i]$)。现有做法是否会失效?**\n\n    此时 $nums$ 中不再是只有长度为 $1$ 的数值了。但我们「判断数值大小」的两条规则不变。因此「第一步」不需要做出调整,但在进行「第二步」开始前,我们要先对物品进行「自定义规则」的排序,确保「贪心」构造答案过程是正确的。规则与证明都不难请自行思考。\n\n2. **【进阶】在进阶 $1$ 的前提下,允许 $nums$ 出现 $0$,且确保答案有解(不会返回答案 $0$),该如何求解?**\n\n    增加数值 $0$ 其实只会对最高位数字的决策产生影响。\n\n    我们可以**通过预处理转换为「分组 & 树形」背包问题**:将 $nums$ 中的非 $0$ 作为一组「主件」(分组背包部分:必须选择一个主件),所有数值作为「附属件」(树形背包部分:能选择若干个,选择附属件必须同时选择主件)。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1449` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1441-1450/1450. 在既定时间做作业的学生人数（简单）.md", "url_title": "1450. 在既定时间做作业的学生人数", "url": "https://leetcode.cn/problems/number-of-students-doing-homework-at-a-given-time/solution/by-ac_oier-4ftz/", "difficulty": "简单", "tags": ["区间求和问题", "差分"], "question": "给你两个整数数组 `startTime`(开始时间)和 `endTime`(结束时间),并指定一个整数 `queryTime` 作为查询时间。\n\n已知,第 `i` 名学生在 `startTime[i]` 时开始写作业并于 `endTime[i]` 时完成作业。\n\n请返回在查询时间 `queryTime` 时正在做作业的学生人数。形式上,返回能够使 `queryTime` 处于区间 `[startTime[i], endTime[i]]`(含)的学生人数。\n\n示例 1:\n```\n输入:startTime = [1,2,3], endTime = [3,2,7], queryTime = 4\n\n输出:1\n\n解释:一共有 3 名学生。\n第一名学生在时间 1 开始写作业,并于时间 3 完成作业,在时间 4 没有处于做作业的状态。\n第二名学生在时间 2 开始写作业,并于时间 2 完成作业,在时间 4 没有处于做作业的状态。\n第三名学生在时间 3 开始写作业,预计于时间 7 完成作业,这是是唯一一名在时间 4 时正在做作业的学生。\n```\n示例 2:\n```\n输入:startTime = [4], endTime = [4], queryTime = 4\n\n输出:1\n\n解释:在查询时间只有一名学生在做作业。\n```\n示例 3:\n```\n输入:startTime = [4], endTime = [4], queryTime = 5\n\n输出:0\n```\n示例 4:\n```\n输入:startTime = [1,1,1,1], endTime = [1,3,2,4], queryTime = 7\n\n输出:0\n```\n示例 5:\n```\n输入:startTime = [9,8,7,6,5,4,3,2,1], endTime = [10,10,10,10,10,10,10,10,10], queryTime = 5\n\n输出:5\n```\n\n提示:\n* $startTime.length == endTime.length$\n* $1 <= startTime.length <= 100$\n* $1 <= startTime[i] <= endTime[i] <= 1000$\n* $1 <= queryTime <= 1000$", "solution": "### 差分\n\n为了方便,我们令 `startTime` 为 `st`,令 `endTime` 为 `et`,令 `queryTime` 为 `t`。\n\n问题涉及「区间修改」+「单点查询」,是一道关于「差分」的模板题。\n\n> **对差分不熟悉的同学,可以查看前置  🧀 : [差分入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247490329&idx=1&sn=6d448a53cd722bbd990fda82bd262857)**\n\n利用时间点数据范围为 $1e3$,我们建立一个 $1e3$ 大小的差分数组 `c`,对于时间段 $[st[i], et[i]]$ 而言,我们只需在差分数组 $c[st[i]]$ 上进行自增,在 $c[et[i] + 1]$ 进行自减,即可实现 $O(1)$ 复杂度对范围 $[st[i], et[i]]$ 的标记。\n\n当处理完后,只需要对 `c` 执行「前缀和」操作,即可查询每个时间点被标记的次数(由于我们只需要求时间点 `t` 的覆盖次数,因此我们只需求 $[0, t]$ 范围的前缀和即可)。\n\nJava 代码:\n```Java\nclass Solution {\n    public int busyStudent(int[] st, int[] et, int t) {\n        int[] c = new int[1010];\n        for (int i = 0; i < st.length; i++) {\n            c[st[i]]++; c[et[i] + 1]--;\n        }\n        for (int i = 1; i <= t; i++) c[i] += c[i - 1];\n        return c[t];\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction busyStudent(st: number[], et: number[], t: number): number {\n    const c = new Array<number>(1010).fill(0)\n    for (let i = 0; i < st.length; i++) {\n        c[st[i]]++; c[et[i] + 1]--;\n    }\n    for (let i = 1; i <= t; i++) c[i] += c[i - 1];\n    return c[t]\n};\n```\n* 时间复杂度:创建差分数组复杂度为 $O(C)$,其中 $C = 1e3$ 为值域大小,随后使用差分数组进行区间标记,复杂度为 $O(n)$,构建前缀和数组用于查询复杂度为 $O(t)$,整体复杂度为 $O(C)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1450` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1451-1460/1455. 检查单词是否为句中其他单词的前缀（简单）.md", "url_title": "1455. 检查单词是否为句中其他单词的前缀", "url": "https://leetcode.cn/problems/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence/solution/by-ac_oier-cfsi/", "difficulty": "简单", "tags": ["模拟", "双指针"], "question": "给你一个字符串 `sentence` 作为句子并指定检索词为 `searchWord`,其中句子由若干用 单个空格 分隔的单词组成。请你检查检索词 `searchWord` 是否为句子 `sentence` 中任意单词的前缀。\n\n如果 `searchWord` 是某一个单词的前缀,则返回句子 `sentence` 中该单词所对应的下标(下标从 $1$ 开始)。如果 `searchWord` 是多个单词的前缀,则返回匹配的第一个单词的下标(最小下标)。如果 `searchWord` 不是任何单词的前缀,则返回 $-1$ 。\n\n字符串 `s` 的前缀是 `s` 的任何前导连续子字符串。\n\n示例 1:\n```\n输入:sentence = \"i love eating burger\", searchWord = \"burg\"\n\n输出:4\n\n解释:\"burg\" 是 \"burger\" 的前缀,而 \"burger\" 是句子中第 4 个单词。\n```\n示例 2:\n```\n输入:sentence = \"this problem is an easy problem\", searchWord = \"pro\"\n\n输出:2\n\n解释:\"pro\" 是 \"problem\" 的前缀,而 \"problem\" 是句子中第 2 个也是第 6 个单词,但是应该返回最小下标 2 。\n```\n示例 3:\n```\n输入:sentence = \"i am tired\", searchWord = \"you\"\n\n输出:-1\n\n解释:\"you\" 不是句子中任何单词的前缀。\n```\n\n提示:\n* $1 <= sentence.length <= 100$\n* $1 <= searchWord.length <= 10$\n* `sentence` 由小写英文字母和空格组成。\n* `searchWord` 由小写英文字母组成。", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public int isPrefixOfWord(String s, String t) {\n        String[] ss = s.split(\" \");\n        int n = ss.length, m = t.length();\n        for (int i = 0; i < n; i++) {\n            if (ss[i].length() < m) continue;\n            boolean ok = true;\n            for (int j = 0; j < m && ok; j++) {\n                if (ss[i].charAt(j) != t.charAt(j)) ok = false;\n            }\n            if (ok) return i + 1;\n        }\n        return -1;\n    }\n}\n```\nTypescript 代码:\n```Typescript\nfunction isPrefixOfWord(s: string, t: string): number {\n    const ss = s.split(\" \")\n    const n = ss.length, m = t.length\n    for (let i = 0; i < n; i++) {\n        if (ss[i].length < m) continue\n        let ok = true\n        for (let j = 0; j < m && ok; j++) {\n            if (ss[i][j] != t[j]) ok = false\n        }\n        if (ok) return i + 1\n    }\n    return -1\n};\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1455` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1451-1460/1457. 二叉树中的伪回文路径（中等）.md", "url_title": "1457. 二叉树中的伪回文路径", "url": "https://leetcode.cn/problems/pseudo-palindromic-paths-in-a-binary-tree/solutions/2540912/gong-shui-san-xie-gao-xiao-ji-jian-de-we-f2gb/", "difficulty": "中等", "tags": ["DFS", "位运算"], "question": "给你一棵二叉树,每个节点的值为 `1` 到 `9` 。\n\n我们称二叉树中的一条路径是 「伪回文」的,当它满足:路径经过的所有节点值的排列中,存在一个回文序列。\n\n请你返回从根到叶子节点的所有路径中伪回文路径的数目。\n\n示例 1:\n\n```\n输入:root = [2,3,1,3,1,null,1]\n\n输出:2 \n\n解释:上图为给定的二叉树。总共有 3 条从根到叶子的路径:红色路径 [2,3,3] ,绿色路径 [2,1,1] 和路径 [2,3,1] 。\n     在这些路径中,只有红色和绿色的路径是伪回文路径,因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ,绿色路径 [2,1,1] 存在回文排列 [1,2,1] 。\n```\n示例 2:\n\n```\n输入:root = [2,1,1,1,3,null,null,null,null,null,1]\n\n输出:1 \n\n解释:上图为给定二叉树。总共有 3 条从根到叶子的路径:绿色路径 [2,1,1] ,路径 [2,1,3,1] 和路径 [2,1] 。\n     这些路径中只有绿色路径是伪回文路径,因为 [2,1,1] 存在回文排列 [1,2,1] 。\n```\n示例 3:\n```\n输入:root = [9]\n\n输出:1\n```\n\n提示:\n* 给定二叉树的节点数目在范围 $[1, 10^5]$ 内\n* $1 <= Node.val <= 9$", "solution": "### DFS + 位运算\n\n“伪回文”是指能够通过重新排列变成“真回文”,真正的回文串只有两种情况:\n\n* 长度为偶数,即出现次数为奇数的字符个数为 $0$ 个\n* 长度为奇数,即出现次数为奇数的字符个数为 $1$ 个(位于中间)\n\n因此,**我们只关心路径中各个字符(数字 `0-9`)出现次数的奇偶性,若路径中所有字符出现次数均为偶数,或仅有一个字符出现次数为奇数,那么该路径满足要求**。\n\n节点值范围为 $[1, 9]$,除了使用固定大小的数组进行词频统计以外,还可以使用一个 `int` 类型的变量 `cnt` 来统计各数值的出现次数奇偶性:若 $cnt$ 的第 $k$ 位为 $1$,说明数值 $k$ 的出现次数为奇数,否则说明数值 $k$ 出现次数为偶数或没出现过,两者是等价的。\n\n例如 $cnt = (0001010)_2$ 代表数值 $1$ 和数值 $3$ 出现次数为奇数次,其余数值没出现过或出现次数为偶数次。\n\n翻转一个二进制数字中的某一位可使用「异或」操作,具体操作位 `cnt ^= 1 << k`。\n\n判断是否最多只有一个字符出现奇数次的操作,也就是判断一个二进制数字是为全为 $0$ 或仅有一位 $1$,可配合 `lowbit` 来做,若 `cnt` 与 `lowbit(cnt) = cnt & -cnt` 相等,说明满足要求。\n\n考虑到对 `lowbit(x) = x & -x` 不熟悉的同学,这里再做简单介绍:*`lowbit(x)` 表示 `x` 的二进制表示中最低位的 $1$ 所在的位置对应的值*,即仅保留从最低位起的第一个 $1$,其余位均以 $0$ 填充:\n* `x = 6`,其二进制表示为 $(110)_2$,那么 $lowbit(6) = (010)_2 = 2$\n* `x = 12`,其二进制表示为 $(1100)_2$,那么 $lowbit(12) = (100)_2 = 4$\n\nJava 代码:\n\n```Java\nclass Solution {\n    int ans = 0;\n    public int pseudoPalindromicPaths (TreeNode root) {\n        dfs(root, 0);\n        return ans;\n    }\n    void dfs(TreeNode root, int cnt) {\n        if (root.left == null && root.right == null) {\n            cnt ^= 1 << root.val;\n            if (cnt == (cnt & -cnt)) ans++;\n            return ;\n        }\n        if (root.left != null) dfs(root.left, cnt ^ (1 << root.val));\n        if (root.right != null) dfs(root.right, cnt ^ (1 << root.val));\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int ans;\n    int pseudoPalindromicPaths(TreeNode* root) {\n        dfs(root, 0);\n        return ans;\n    }\n    void dfs(TreeNode* root, int cnt) {\n        if (!root->left && !root->right) {\n            cnt ^= 1 << root->val;\n            if (cnt == (cnt & -cnt)) ans++;\n            return;\n        }\n        if (root->left) dfs(root->left, cnt ^ (1 << root->val));\n        if (root->right) dfs(root->right, cnt ^ (1 << root->val));\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def pseudoPalindromicPaths (self, root: Optional[TreeNode]) -> int:\n        ans = 0\n        def dfs(root, cnt):\n            nonlocal ans\n            if not root.left and not root.right:\n                cnt ^= 1 << root.val\n                ans += 1 if cnt == (cnt & -cnt) else 0\n                return \n            if root.left:\n                dfs(root.left, cnt ^ (1 << root.val))\n            if root.right:\n                dfs(root.right, cnt ^ (1 << root.val))\n        dfs(root, 0)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction pseudoPalindromicPaths (root: TreeNode | null): number {\n    let ans = 0;\n    const dfs = function (root: TreeNode, cnt: number): void {\n        if (root.left == null && root.right == null) {\n            cnt ^= 1 << root.val;\n            if (cnt == (cnt & -cnt)) ans++;\n            return ;\n        }\n        if (root.left) dfs(root.left, cnt ^ (1 << root.val));\n        if (root.right) dfs(root.right, cnt ^ (1 << root.val));\n    }\n    dfs(root, 0);\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1457` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1451-1460/1460. 通过翻转子数组使两个数组相等（简单）.md", "url_title": "1460. 通过翻转子数组使两个数组相等", "url": "https://leetcode.cn/problems/make-two-arrays-equal-by-reversing-sub-arrays/solution/by-ac_oier-pv38/", "difficulty": "简单", "tags": ["模拟", "计数"], "question": "给你两个长度相同的整数数组 `target` 和 `arr` 。每一步中,你可以选择 `arr` 的任意 非空子数组 并将它翻转。你可以执行此过程任意次。\n\n如果你能让 `arr` 变得与 `target` 相同,返回 `True`;否则,返回 `False` 。\n\n示例 1:\n```\n输入:target = [1,2,3,4], arr = [2,4,1,3]\n\n输出:true\n\n解释:你可以按照如下步骤使 arr 变成 target:\n1- 翻转子数组 [2,4,1] ,arr 变成 [1,4,2,3]\n2- 翻转子数组 [4,2] ,arr 变成 [1,2,4,3]\n3- 翻转子数组 [4,3] ,arr 变成 [1,2,3,4]\n上述方法并不是唯一的,还存在多种将 arr 变成 target 的方法。\n```\n示例 2:\n```\n输入:target = [7], arr = [7]\n\n输出:true\n\n解释:arr 不需要做任何翻转已经与 target 相等。\n```\n示例 3:\n```\n输入:target = [3,7,9], arr = [3,7,11]\n\n输出:false\n\n解释:arr 没有数字 9 ,所以无论如何也无法变成 target 。\n```\n\n提示:\n* $target.length = arr.length$\n* $1 <= target.length <= 1000$\n* $1 <= target[i] <= 1000$\n* $1 <= arr[i] <= 1000$", "solution": "### 模拟\n\n当两数组词频相同,且翻转次数不受限制时,我们至少能通过「逐个调整」将一数组变为另一数组(以当前需要调整的位置作为待翻转子数组的左端点,目标数值所在位置作为右端点)。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean canBeEqual(int[] target, int[] arr) {\n        int n = arr.length, tot = 0;\n        int[] cnt = new int[1010]; \n        for (int i = 0; i < n; i++) {\n            if (++cnt[target[i]] == 1) tot++;\n            if (--cnt[arr[i]] == 0) tot--;\n        }\n        return tot == 0;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction canBeEqual(target: number[], arr: number[]): boolean {\n    let n = target.length, tot = 0\n    const cnt = new Array<number>(1010).fill(0)\n    for (let i = 0; i < n; i++) {\n        if (++cnt[target[i]] == 1) tot++\n        if (--cnt[arr[i]] == 0) tot--\n    }\n    return tot == 0\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(C)$,其中 $C = 1010$ 为值域大小", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1460` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1461-1470/1464. 数组中两元素的最大乘积（简单）.md", "url_title": "1464. 数组中两元素的最大乘积", "url": "https://leetcode.cn/problems/maximum-product-of-two-elements-in-an-array/solution/by-ac_oier-t5p3/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个整数数组 `nums`,请你选择数组的两个不同下标 `i` 和 `j`,使 `(nums[i]-1)*(nums[j]-1)` 取得最大值。\n\n请你计算并返回该式的最大值。\n\n示例 1:\n```\n输入:nums = [3,4,5,2]\n\n输出:12 \n\n解释:如果选择下标 i=1 和 j=2(下标从 0 开始),则可以获得最大值,(nums[1]-1)*(nums[2]-1) = (4-1)*(5-1) = 3*4 = 12 。 \n```\n示例 2:\n```\n输入:nums = [1,5,4,5]\n\n输出:16\n\n解释:选择下标 i=1 和 j=3(下标从 0 开始),则可以获得最大值 (5-1)*(5-1) = 16 。\n```\n示例 3:\n```\n输入:nums = [3,7]\n\n输出:12\n```\n\n提示:\n* $2 <= nums.length <= 500$\n* $1 <= nums[i] <= 10^3$", "solution": "### 模拟\n\n根据题意,使用两个变量 `a` 和 `b` 记录最大值和次大值。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxProduct(int[] nums) {\n        int a = -1, b = -1;\n        for (int x : nums) {\n            if (x > a) {\n                b = a; a = x;\n            } else if (x > b) {\n                b = x;\n            }\n        }\n        return (a - 1) * (b - 1);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction maxProduct(nums: number[]): number {\n    let a = -1, b = -1\n    for (const x of nums) {\n        if (x > a) {\n            b = a; a = x\n        } else if (x > b) {\n            b = x\n        }\n    }\n    return (a - 1) * (b - 1)\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1464` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1461-1470/1465. 切割后面积最大的蛋糕（中等）.md", "url_title": "1465. 切割后面积最大的蛋糕", "url": "https://leetcode.cn/problems/maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/solutions/2500353/gong-shui-san-xie-noxiang-xin-ke-xue-xi-ecnvl/", "difficulty": "中等", "tags": ["贪心", "模拟"], "question": "矩形蛋糕的高度为 `h` 且宽度为 `w`,给你两个整数数组 `hs` 和 `vs`,其中:\n\n* `hs[i]` 是从矩形蛋糕顶部到第  `i` 个水平切口的距离\n* `vs[j]` 是从矩形蛋糕的左侧到第 `j` 个竖直切口的距离\n\n请你按数组 `hs` 和 `vs` 中提供的水平和竖直位置切割后,请你找出**面积最大**的那份蛋糕,并返回其**面积**。\n\n由于答案可能是一个很大的数字,因此需要将结果 对 $10^9 + 7$ 取余 后返回。\n\n示例 1:\n\n```\n输入:h = 5, w = 4, hs = [1,2,4], vs = [1,3]\n\n输出:4 \n\n解释:上图所示的矩阵蛋糕中,红色线表示水平和竖直方向上的切口。切割蛋糕后,绿色的那份蛋糕面积最大。\n```\n示例 2:\n\n```\n输入:h = 5, w = 4, hs = [3,1], vs = [1]\n\n输出:6\n\n解释:上图所示的矩阵蛋糕中,红色线表示水平和竖直方向上的切口。切割蛋糕后,绿色和黄色的两份蛋糕面积最大。\n```\n示例 3:\n```\n输入:h = 5, w = 4, hs = [3], vs = [3]\n\n输出:9\n```\n\n提示:\n* $2 <= h, w <= 10^9$\n* $1 <= hs.length <= \\min(h - 1, 10^5)$\n* $1 <= vs.length <= \\min(w - 1, 10^5)$\n* $1 <= hs[i] < h$\n* $1 <= vs[i] < w$\n* 题目数据保证 `hs` 中的所有元素各不相同\n* 题目数据保证 `vs` 中的所有元素各不相同", "solution": "### 贪心 \n\n由于求是“最大”蛋糕面积,**水平/垂直方向的连续段必然由「同方向且相邻」的切割位置(或是蛋糕边界)所构成**。\n\n这点可通过反证法证明:如果最终蛋糕的(左右或上下)边缘不是由「相邻」的切割位置(或是蛋糕边界)决定,而是由跨越某些切割点的位置所决定的话,那么这个蛋糕必不是“完整”一块。\n\n用题面的示例 $1$ 来举个 🌰,我们仅分析水平方向(`hs = [1, 2, 4]`):\n\n最终蛋糕的在该方向的连续段大小,只能是 `[上边缘, 切割点 1]`、`[切割点 1, 切割点 2]`、`[切割点 2, 切割点 4]` 和 `[切割点 4, 下边缘]` 四个之一,而不可能由非相邻切割点所组成,例如 `[切割点 1, 切割点 4]`(会被 `切割点 2` 所一分为二,不再完整)。\n\n因此,我们可先对 `hs` 和 `vs` 进行排序,从而确保我们在遍历 `hs` 和 `vs` 过程中,处理到的均为「同反向且相邻」的切割位置。\n\n随后,利用俩方向相互独立,分别求出俩方向连续段的最大长度,两者乘积即是答案。\n\nJava 代码:\n\n```Java\nclass Solution {\n    int MOD = (int)1e9+7;\n    public int maxArea(int h, int w, int[] hs, int[] vs) {\n        Arrays.sort(hs);\n        Arrays.sort(vs);\n        int n = hs.length, m = vs.length;\n        int mh = Math.max(hs[0], h - hs[n - 1]), mv = Math.max(vs[0], w - vs[m - 1]);\n        for (int i = 1; i < n; i++) mh = Math.max(mh, hs[i] - hs[i - 1]);\n        for (int i = 1; i < m; i++) mv = Math.max(mv, vs[i] - vs[i - 1]);\n        return (int)((mh * 1L * mv) % MOD);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxArea(int h, int w, vector<int>& hs, vector<int>& vs) {\n        int MOD = 1e9+7;\n        sort(hs.begin(), hs.end());\n        sort(vs.begin(), vs.end());\n        int n = hs.size(), m = vs.size();\n        int mh = max(hs[0], h - hs[n - 1]), mv = max(vs[0], w - vs[m - 1]);\n        for (int i = 1; i < n; i++) mh = max(mh, hs[i] - hs[i - 1]);\n        for (int i = 1; i < m; i++) mv = max(mv, vs[i] - vs[i - 1]);\n        return (mh * 1L * mv) % MOD;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxArea(self, h: int, w: int, hs: List[int], vs: List[int]) -> int:\n        MOD = 10 ** 9 + 7\n        hs.sort()\n        vs.sort()\n        n, m = len(hs), len(vs)\n        mh, mv = max(hs[0], h - hs[n - 1]), max(vs[0], w - vs[m - 1])\n        for i in range(1, n):\n            mh = max(mh, hs[i] - hs[i - 1])\n        for i in range(1, m):\n            mv = max(mv, vs[i] - vs[i - 1])\n        return (mh * mv) % MOD\n```\nTypeScript 代码:\n```TypeScript\nfunction maxArea(h: number, w: number, hs: number[], vs: number[]): number {\n    const MOD = BigInt(1e9 + 7);\n    hs.sort((a,b)=>a-b);\n    vs.sort((a,b)=>a-b);\n    const n = hs.length, m = vs.length;\n    let mh = Math.max(hs[0], h - hs[n - 1]), mv = Math.max(vs[0], w - vs[m - 1]);\n    for (let i = 1; i < n; i++) mh = Math.max(mh, hs[i] - hs[i - 1]);\n    for (let i = 1; i < m; i++) mv = Math.max(mv, vs[i] - vs[i - 1]);\n    return Number((BigInt(mh) * BigInt(mv)) % MOD);\n};\n```\n* 时间复杂度:$O(m\\log{m} + n\\log{n})$\n* 空间复杂度:$O(\\max(\\log{m}, \\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1465` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1461-1470/1466. 重新规划路线（中等）.md", "url_title": "1466. 重新规划路线", "url": null, "difficulty": "中等", "tags": ["图", "DFS"], "question": "`n` 座城市,从 `0` 到 `n-1` 编号,其间共有 `n-1` 条路线。\n\n因此,要想在两座不同城市之间旅行只有唯一一条路线可供选择(路线网形成一颗树)。\n\n去年,交通运输部决定重新规划路线,以改变交通拥堵的状况。\n\n路线用 `connections` 表示,其中 $connections[i] = [a, b]$ 表示从城市 `a` 到 `b` 的一条有向路线。\n\n今年,城市 `0` 将会举办一场大型比赛,很多游客都想前往城市 `0` 。\n\n请你帮助重新规划路线方向,使每个城市都可以访问城市 `0`。返回需要变更方向的最小路线数。\n\n题目数据保证每个城市在重新规划路线方向后都能到达城市 `0` 。\n\n示例 1:\n\n```\n输入:n = 6, connections = [[0,1],[1,3],[2,3],[4,0],[4,5]]\n\n输出:3\n\n解释:更改以红色显示的路线的方向,使每个城市都可以到达城市 0 。\n```\n示例 2:\n\n```\n输入:n = 5, connections = [[1,0],[1,2],[3,2],[3,4]]\n\n输出:2\n\n解释:更改以红色显示的路线的方向,使每个城市都可以到达城市 0 。\n```\n示例 3:\n```\n输入:n = 3, connections = [[1,0],[2,0]]\n\n输出:0\n```\n\n提示:\n* $2 <= n <= 5 \\times 10^4$\n* $connections.length = n-1$\n* $connections[i].length = 2$\n* $0 <= connections[i][0], connections[i][1] <= n-1$\n* $connections[i][0]$ `!=` $connections[i][1]$", "solution": "### DFS\n\n核心等价:原图上从所有点能够访问到 `0`,等价于反图中从 `0` 出发能到任何点。\n\n因此,可用 `connections` 创建双向图(原边权重为 $1$,反向边权重为 $0$),然后从 `0` 出发访问整张图,统计访问过程中的权重之和,即是原图中需要反向的边的数量。\n\nJava 代码:\n```Java\nclass Solution {\n    int N = 50010, M = N * 2, idx = 0;\n    int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        w[idx] = c;\n        he[a] = idx++;\n    }\n    public int minReorder(int n, int[][] connections) {\n        Arrays.fill(he, -1);\n        for (int[] info : connections) {\n            int a = info[0], b = info[1];\n            add(a, b, 1); add(b, a, 0);\n        }\n        return dfs(0, -1);\n    }\n    int dfs(int u, int fa) {\n        int ans = 0;\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (j == fa) continue;\n            ans += w[i] + dfs(j, u);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int N = 50010, M = N * 2, idx = 0;\n    int he[50010], e[100020], ne[100020], w[100020];\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        w[idx] = c;\n        he[a] = idx++;\n    }\n    int minReorder(int n, vector<vector<int>>& connections) {\n        memset(he, -1, sizeof(he));\n        for (auto& info : connections) {\n            int a = info[0], b = info[1];\n            add(a, b, 1); add(b, a, 0);\n        }\n        return dfs(0, -1);\n    }\n    int dfs(int u, int fa) {\n        int ans = 0;\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (j == fa) continue;\n            ans += w[i] + dfs(j, u);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minReorder(self, n: int, connections: List[List[int]]) -> int:\n        N, M, idx = n + 10, (n + 10) * 2, 0\n        he, e, ne, w = [-1] * N, [0] * M, [0] * M, [0] * M\n\n        def add(a, b, c):\n            nonlocal idx\n            e[idx], ne[idx], w[idx], he[a] = b, he[a], c, idx\n            idx += 1\n\n        def dfs(u, fa):\n            ans = 0\n            i = he[u]\n            while i != -1:\n                j, c = e[i], w[i]\n                i = ne[i]\n                if j == fa: continue    \n                ans += c + dfs(j, u)\n            return ans\n\n        for a, b in connections:\n            add(a, b, 1)\n            add(b, a, 0)\n        return dfs(0, -1)\n```\nTypeScript 代码:\n```TypeScript\nfunction minReorder(n: number, connections: number[][]): number {\n    let N = n + 10, M = N * 2, idx = 0;\n    const he = Array(N).fill(-1), e = Array(M).fill(0), ne = Array(M).fill(0), w = Array(M).fill(0);\n    const add = function(a: number, b: number, c: number): void {\n        e[idx] = b;\n        ne[idx] = he[a];\n        w[idx] = c;\n        he[a] = idx++;\n    };\n    const dfs = function(u: number, fa: number): number {\n        let ans = 0;\n        for (let i = he[u]; i != -1; i = ne[i]) {\n            const j = e[i];\n            if (j == fa) continue;\n            ans += w[i] + dfs(j, u);\n        }\n        return ans;\n    };\n    for (let [a, b] of connections) {\n        add(a, b, 1); add(b, a, 0);\n    }\n    return dfs(0, -1);\n};\n```\n* 时间复杂度:建图复杂度为 $O(n)$;从 `0` 点开始遍历,访问所有点并统计权重之和的复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1466` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1461-1470/1470. 重新排列数组（简单）.md", "url_title": "1470. 重新排列数组", "url": "https://leetcode.cn/problems/shuffle-the-array/solution/by-ac_oier-3lck/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个数组 `nums`,数组中有 `2n` 个元素,按 $[x_1,x_2,...,x_n,y_1,y_2,...,y_n]$ 的格式排列。\n\n请你将数组按 $[x_1,y_1,x_2,y_2,...,x_n,y_n]$ 格式重新排列,返回重排后的数组。\n\n示例 1:\n```\n输入:nums = [2,5,1,3,4,7], n = 3\n\n输出:[2,3,5,4,1,7] \n\n解释:由于 x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 ,所以答案为 [2,3,5,4,1,7]\n```\n示例 2:\n```\n输入:nums = [1,2,3,4,4,3,2,1], n = 4\n\n输出:[1,4,2,3,3,2,4,1]\n```\n示例 3:\n```\n输入:nums = [1,1,2,2], n = 2\n\n输出:[1,2,1,2]\n```\n\n提示:\n* $1 <= n <= 500$\n* $nums.length = 2 \\times n$\n* $1 <= nums[i] <= 10^3$", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] shuffle(int[] nums, int n) {\n        int[] ans = new int[2 * n];\n        for (int i = 0, j = n, k = 0; k < 2 * n; k++) {\n            ans[k] = k % 2 == 0 ? nums[i++] : nums[j++];\n        }\n        return ans;\n    }\n}\n```\nTypescript 代码:\n```Typescript\nfunction shuffle(nums: number[], n: number): number[] {\n    const ans = new Array<number>()\n    for (let i = 0, j = n, k = 0; k < 2 * n; k++) {\n        ans.push(k % 2 == 0 ? nums[i++] : nums[j++])\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 加餐\n\n**加餐一道其他题目 [关于 RMQ 的若干解法](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247493262&idx=1&sn=2d8e192a5767b49b9a13a6192ab3b833) 🎉🎉**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1470` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1471-1480/1473. 粉刷房子 III（困难）.md", "url_title": "1473. 粉刷房子 III", "url": "https://leetcode-cn.com/problems/paint-house-iii/solution/gong-shui-san-xie-san-wei-dong-tai-gui-h-ud7m/", "difficulty": "困难", "tags": ["动态规划", "序列 DP"], "question": "在一个小城市里,有 `m` 个房子排成一排,你需要给每个房子涂上 `n` 种颜色之一(颜色编号为 `1` 到 `n` )。\n\n有的房子去年夏天已经涂过颜色了,所以这些房子不可以被重新涂色。\n\n我们将连续相同颜色尽可能多的房子称为一个街区。\n\n(比方说 `houses = [1,2,2,3,3,2,1,1]`,它包含 5 个街区  `[{1}, {2,2}, {3,3}, {2}, {1,1}]` 。)\n\n给你一个数组 `houses`,一个 `m * n` 的矩阵 `cost` 和一个整数 `target`,其中:\n\n* `houses[i]`:是第 `i` 个房子的颜色,`0` 表示这个房子还没有被涂色。\n* `cost[i][j]`:是将第 `i` 个房子涂成颜色 `j + 1` 的花费。\n\n请你返回房子涂色方案的最小总花费,使得每个房子都被涂色后,恰好组成 `target` 个街区。\n\n如果没有可用的涂色方案,请返回 `-1` 。\n\n示例 1:\n```\n输入:houses = [0,0,0,0,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3\n\n输出:9\n\n解释:房子涂色方案为 [1,2,2,1,1]\n此方案包含 target = 3 个街区,分别是 [{1}, {2,2}, {1,1}]。\n涂色的总花费为 (1 + 1 + 1 + 1 + 5) = 9。\n```\n示例 2:\n```\n输入:houses = [0,2,1,2,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3\n\n输出:11\n\n解释:有的房子已经被涂色了,在此基础上涂色方案为 [2,2,1,2,2]\n此方案包含 target = 3 个街区,分别是 [{2,2}, {1}, {2,2}]。\n给第一个和最后一个房子涂色的花费为 (10 + 1) = 11。\n```\n示例 3:\n```\n输入:houses = [0,0,0,0,0], cost = [[1,10],[10,1],[1,10],[10,1],[1,10]], m = 5, n = 2, target = 5\n\n输出:5\n```\n示例 4:\n```\n输入:houses = [3,1,2,3], cost = [[1,1,1],[1,1,1],[1,1,1],[1,1,1]], m = 4, n = 3, target = 3\n\n输出:-1\n\n解释:房子已经被涂色并组成了 4 个街区,分别是 [{3},{1},{2},{3}] ,无法形成 target = 3 个街区。\n```\n\n提示:\n* $m = houses.length = cost.length$\n* $n = cost[i].length$\n* $1 <= m <= 100$\n* $1 <= n <= 20$\n* $1 <= target <= m$\n* $0 <= houses[i] <= n$\n* $1 <= cost[i][j] <= 10^4$", "solution": "### 动态规划\n\n**定义 $f[i][j][k]$ 为考虑前 $i$ 间房子,且第 $i$ 间房子的颜色编号为 $j$,前 $i$ 间房子形成的分区数量为 $k$ 的所有方案中的「最小上色成本」。**\n\n我们不失一般性的考虑 $f[i][j][k]$ 该如何转移,由于某些房子本身就已经上色,上色的房子是不允许被粉刷的。\n\n我们可以根据第 $i$ 间房子是否已经被上色,进行分情况讨论:\n\n* 第 $i$ 间房子已经被上色,即 $houses[i] != 0$,此时只有满足 $j == houses[i]$ 的状态才是有意义的,其余状态均为 `INF`。\n    同时根据「第 $i$ 间房子的颜色 $j$」与「第 $i - 1$ 间房子的颜色 $p$」是否相同,会决定第 $i$ 间房子是否形成一个新的分区。这同样需要进行分情况讨论。\n    整理后的转移方程为:\n    \n    $$\n    f[i][j][k]=\\begin{cases}\n    min(f[i - 1][j][k], f[i - 1][p][k - 1]) &j == houses[i], p != j\\\\\n    INF & j != houses[i]\n    \\end{cases}\n    $$\n    \n* 第 $i$ 间房子尚未被上色,即 $houses[i] == 0$,此时房子可以被粉刷成任意颜色。不会有无效状态的情况。\n  同样,根据「第 $i$ 间房子的颜色 $j$」与「第 $i - 1$ 间房子的颜色 $p$」是否相同,会决定第 $i$ 间房子是否形成一个新的分区。\n    转移方程为:\n\n  $$\n  f[i][j][k] = min(f[i - 1][j][k], f[i - 1][p][k - 1]) + cost[i][j - 1], p != j\n  $$\n\n一些编码细节:\n\n* 下标转换:这是个人习惯,无论做什么题,我都喜欢将下标转换为从 $1$ 开始,目的是为了「节省负值下标的分情况讨论」、「将无效状态限制在 $0$ 下标内」或者「充当哨兵」等等。\n* 将 `0x3f3f3f3f` 作为 `INF`:因为目标是求最小值,我们应当使用一个较大值充当正无穷,来关联无效状态。同时为了确保不会出现「在正无穷基础上累加导致丢失正无穷含义」的歧义情况,我们可以使用一个有「累加空间」的值作为「正无穷」(这个问题刚好最近在 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486435&idx=1&sn=2464b01e9c0fb8d81fcea6dd4ed0ec92&chksm=fd9ca0fccaeb29ea9947456290099143c5bc9bdea0ccfb2408f5fd63f5e0fc13fcd8060d4251&token=515378286&lang=zh_CN#rd) 专门讲过)。\n\nJava 代码:\n```Java\nclass Solution {\n    int INF = 0x3f3f3f3f;\n    public int minCost(int[] hs, int[][] cost, int m, int n, int t) {\n        int[][][] f = new int[m + 1][n + 1][t + 1];\n\n        // 不存在分区数量为 0 的状态\n        for (int i = 0; i <= m; i++) {\n            for (int j = 0; j <= n; j++) {\n                f[i][j][0] = INF;\n            }\n        }\n\n        for (int i = 1; i <= m; i++) {\n            int color = hs[i - 1];\n            for (int j = 1; j <= n; j++) {\n                for (int k = 1; k <= t; k++) {\n                    // 形成分区数量大于房子数量,状态无效\n                    if (k > i) {\n                        f[i][j][k] = INF;\n                        continue;\n                    }\n\n                    // 第 i 间房间已经上色\n                    if (color != 0) {\n                        if (j == color) { // 只有与「本来的颜色」相同的状态才允许被转移\n                            int tmp = INF;\n                            // 先从所有「第 i 间房形成新分区」方案中选最优(即与上一房间颜色不同)\n                            for (int p = 1; p <= n; p++) {\n                                if (p != j) {\n                                    tmp = Math.min(tmp, f[i - 1][p][k - 1]);\n                                }\n                            }\n                            // 再结合「第 i 间房不形成新分区」方案中选最优(即与上一房间颜色相同)\n                            f[i][j][k] = Math.min(f[i - 1][j][k], tmp);\n                        \n                        } else { // 其余状态无效  \n                            f[i][j][k] = INF;\n                        }\n\n                    // 第 i 间房间尚未上色\n                    } else {\n                        int u = cost[i - 1][j - 1]; \n                        int tmp = INF;\n                        // 先从所有「第 i 间房形成新分区」方案中选最优(即与上一房间颜色不同)\n                        for (int p = 1; p <= n; p++) {\n                            if (p != j) {\n                                tmp = Math.min(tmp, f[i - 1][p][k - 1]);\n                            }\n                        }\n                        // 再结合「第 i 间房不形成新分区」方案中选最优(即与上一房间颜色相同)\n                        // 并将「上色成本」添加进去\n                        f[i][j][k] = Math.min(tmp, f[i - 1][j][k]) + u;\n                    }\n                }\n            }\n        }\n\n        // 从「考虑所有房间,并且形成分区数量为 t」的所有方案中找答案\n        int ans = INF;\n        for (int i = 1; i <= n; i++) {\n            ans = Math.min(ans, f[m][i][t]);\n        }\n        return ans == INF ? -1 : ans;\n    }\n}\n```\n* 时间复杂度:共有 $m \\times n \\times t$ 个状态需要被转移,每次转移需要枚举「所依赖的状态」的颜色,复杂度为 $O(n)$。整体复杂度为 $O(m \\times n^2 \\times t)$\n* 空间复杂度:$O(m \\times n \\times t)$\n\n---\n\n### 状态定义的由来\n\n对于有一定 DP 刷题量的同学来说,上述的「状态定义」应该很好理解。\n\n**根据经验,我们可以很容易确定「房间编号维度 $i$」和「分区数量维度 $k$」需要纳入考虑,同时为了在转移过程中,我们能够清楚知道从哪些状态转移过来需要增加「分区数量」,哪些状态转移过来不需要增加,因此需要多引入「最后一间房间颜色 $j$」维度。**\n\n至于对 DP 不熟悉的同学,可以从写「爆搜」开始入手。\n\n**这里的“写”不一定真的要动手去实现一个完整的「爆搜」方案,只需要合理设计出来 `DFS` 函数签名即可。**\n\n但为了更好理解,我写了一个完整版的供你参考。\n\n代码:\n```Java\nclass Solution {\n    int INF = 0x3f3f3f3f;\n    int ans = INF;\n    int[] hs;\n    int[][] cost;\n    int m, n, t;\n    public int minCost(int[] _hs, int[][] _cost, int _m, int _n, int _t) {\n        m = _m; n = _n; t = _t;\n        hs = _hs;\n        cost = _cost;\n        dfs(0, -1, 0, 0);\n        return ans == INF ? -1 : ans;\n    }\n    // u : 当前处理到的房间编号\n    // last : 当前处理的房间颜色\n    // cnt : 当前形成的分区数量\n    // sum : 当前的上色成本\n    void dfs(int u, int last, int cnt, int sum) {\n        if (sum >= ans || cnt > t) return;\n        if (u == m) {\n            if (cnt == t) {\n                ans = Math.min(ans, sum);\n            }\n            return;\n        }\n        int color = hs[u];\n        if (color == 0) {\n            for (int i = 1; i <= n; i++) {\n                int nCnt = u - 1 < 0 ? 1 : last == i ? cnt : cnt + 1; \n                dfs(u + 1, i, nCnt, sum + cost[u][i - 1]);\n            }\n        } else {\n            int nCnt = u - 1 < 0 ? 1 : last == color ? cnt : cnt + 1; \n            dfs(u + 1, color, nCnt, sum);\n        }\n    }\n}\n```\n* 时间复杂度:`n` 为颜色数量,`m` 为房间数量。不考虑剪枝效果,每个房间都可以粉刷 `n` 种颜色,复杂度为指数级别的 $O(n^m)$\n* 空间复杂度:忽略递归带来的额外空间开销。复杂度为 $O(1)$\n\n可以发现,`DFS` 的可变参数有四个,其中 `sum` 是用于更新最终答案 `ans` 的,其应该作为动规值,其余三个参数,作为动规数组的三个维度。\n\n至此,我们可以确定动态规划的「状态定义」,关于如何利用这种「技巧」来得到一个可靠的「状态定义」最早在 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247485319&idx=1&sn=95a3dc9c97ca57185de792ca70924afe&chksm=fd9cac98caeb258ebea466f59378670a90af1cb3015ae70922e1d04ac711a5b8d8d853ac5e7d&token=515378286&lang=zh_CN#rd) 讲过。\n\n---\n\n### 记忆化搜索\n\n看到评论区有同学贴了「记忆化搜索」的版本,那么就作为补充增加到题解吧 ~ \n\n注意记忆化容器应当与我们的「动规数组」结构保存一致。\n\n代码:\n```Java\nclass Solution {\n    int INF = 0x3f3f3f3f;\n    int m, n, t;\n    int[] hs;\n    int[][] cost;\n    boolean[][][] vis;\n    int[][][] cache;\n    public int minCost(int[] _hs, int[][] _cost, int _m, int _n, int _t) {\n        m = _m; n = _n; t = _t;\n        hs = _hs;\n        cost = _cost;\n        vis = new boolean[m + 1][n + 1][t + 1];\n        cache = new int[m + 1][n + 1][t + 1];\n        int ans = dfs(0, 0, 0, 0);\n        return ans == INF ? -1 : ans;\n    }\n    int dfs(int u, int last, int cnt, int sum){\n        if(cnt > t) return INF;\n        if(vis[u][last][cnt]) return cache[u][last][cnt];\n        if (u == m) return cnt == t ? 0 : INF;\n        int ans = INF;\n        int color = hs[u];\n        if(color == 0){\n            for(int i = 1; i <= n; i++){\n                int nCnt = u == 0 ? 1 : last == i ? cnt : cnt + 1;\n                int cur = dfs(u + 1, i, nCnt, sum + cost[u][i - 1]);\n                ans = Math.min(ans, cur + cost[u][i - 1]);\n            }\n        } else{\n            int nCnt = u == 0 ? 1 : last == color ? cnt : cnt + 1;\n            int cur = dfs(u + 1, color, nCnt, sum);\n            ans = Math.min(ans, cur);\n        }\n        vis[u][last][cnt] = true;\n        cache[u][last][cnt] = ans;\n        return ans;\n    }\n}\n```\n* 时间复杂度:共有 $m \\times n \\times t$ 个状态需要被转移,每次转移需要枚举「所依赖的状态」的颜色,复杂度为 $O(n)$。整体复杂度为 $O(m \\times n^2 \\times t)$\n* 空间复杂度:$O(m \\times n \\times t)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1473` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1471-1480/1475. 商品折扣后的最终价格（简单）.md", "url_title": "1475. 商品折扣后的最终价格", "url": "https://leetcode.cn/problems/final-prices-with-a-special-discount-in-a-shop/solution/by-ac_oier-hw5b/", "difficulty": "简单", "tags": ["模拟", "单调栈"], "question": "给你一个数组 `prices`,其中 `prices[i]` 是商店里第 `i` 件商品的价格。\n\n商店里正在进行促销活动,如果你要买第 `i` 件商品,那么你可以得到与 `prices[j]` 相等的折扣,其中 `j` 是满足 `j > i` 且 `prices[j] <= prices[i]` 的 最小下标 ,如果没有满足条件的 `j` ,你将没有任何折扣。\n\n请你返回一个数组,数组中第 `i` 个元素是折扣后你购买商品 `i` 最终需要支付的价格。\n\n示例 1:\n```\n输入:prices = [8,4,6,2,3]\n\n输出:[4,2,4,2,3]\n\n解释:\n商品 0 的价格为 price[0]=8 ,你将得到 prices[1]=4 的折扣,所以最终价格为 8 - 4 = 4 。\n商品 1 的价格为 price[1]=4 ,你将得到 prices[3]=2 的折扣,所以最终价格为 4 - 2 = 2 。\n商品 2 的价格为 price[2]=6 ,你将得到 prices[3]=2 的折扣,所以最终价格为 6 - 2 = 4 。\n商品 3 和 4 都没有折扣。\n```\n示例 2:\n```\n输入:prices = [1,2,3,4,5]\n\n输出:[1,2,3,4,5]\n\n解释:在这个例子中,所有商品都没有折扣。\n```\n示例 3:\n```\n输入:prices = [10,1,1,6]\n\n输出:[9,0,1,6]\n```\n\n提示:\n* $1 <= prices.length <= 500$\n* $1 <= prices[i] <= 10^3$", "solution": "### 模拟\n\n数据范围为 $10^3$,可直接模拟。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] finalPrices(int[] ps) {\n        int n = ps.length;\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) {\n            int k = 0;\n            for (int j = i + 1; j < n && k == 0; j++) {\n                if (ps[j] <= ps[i]) k = ps[j];\n            }\n            ans[i] = ps[i] - k;\n        }\n        return ans;\n    }\n}\n```\nTypescript 代码:\n```Typescript\nfunction finalPrices(ps: number[]): number[] {\n    const n = ps.length\n    const ans = new Array<number>(n).fill(0)\n    for (let i = 0; i < n; i++) {\n        let k = 0\n        for (let j = i + 1; j < n && k == 0; j++) {\n            if (ps[j] <= ps[i]) k = ps[j]\n        }\n        ans[i] = ps[i] - k\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 单调栈\n\n根据题意,我们知道若 $nums[i]$ 存在折扣,必然是被其右边最近一个满足「$nums[j] <= nums[i]$」的 $nums[j]$ 所更新。反过来说,给定一个 $nums[j]$,其所能更新的是其左边最近一个满足「$nums[i] >= nums[j]$」的 $nums[i]$。\n\n因此我们可以使用「单调栈」来进行求解。\n\n当然,我们也能不依靠经验,而从问题的本身出发,逐步分析出该做法。\n\n具体的,我们可以从前往后处理所有的 $nums[i]$,使用某类容器装载我们所有的「待打折」的商品下标。假设当前处理到的是 $nums[i]$:\n* 若其比容器内的任意商品价格要高,其必然不能更新任何一个待打折商品的价格,将其也加入容器尾部(此时我们发现,若有一个新的商品加入容器,其必然是当前所有待打折商品中的价格最高的,即容器内的商品价格单调递增);\n* 若其价格不高于容器内的商品价格,其能够更新容器内待打折的商品价格,并且由于我们容器满足单调递增特性,我们必然能够从尾部开始取出待打折商品来进行更新,直到处理完成或遇到第一个无法更新价格的商品。\n\n由于我们需要往尾部添加和取出元素,因此容器可使用「栈」。\n\n**至此,我们分析了单调栈做法的两大重点:为何单调 & 为何用栈。若对「单调栈」仍不了解的同学,可以看前置 🧀 : [关于 RMQ 的若干解法](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247493262&idx=1&sn=2d8e192a5767b49b9a13a6192ab3b833) 中的第四种解法 🎉🎉🎉。**\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] finalPrices(int[] ps) {\n        int n = ps.length;\n        int[] ans = new int[n];\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            while (!d.isEmpty() && ps[d.peekLast()] >= ps[i]) {\n                int idx = d.pollLast();\n                ans[idx] = ps[idx] - ps[i];\n            }\n            d.addLast(i); ans[i] = ps[i];\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction finalPrices(ps: number[]): number[] {\n    let n = ps.length, he = 0, ta = 0\n    const ans = new Array<number>(n).fill(0)\n    const stk = new Array<number>(n).fill(0)\n    for (let i = 0; i < n; i++) {\n        while (he < ta && ps[stk[ta - 1]] >= ps[i]) {\n            const idx = stk[--ta]\n            ans[idx] = ps[idx] - ps[i]\n        }\n        stk[ta++] = i; ans[i] = ps[i]\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1475` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1471-1480/1480. 一维数组的动态和（简单）.md", "url_title": "1480. 一维数组的动态和", "url": "https://leetcode-cn.com/problems/running-sum-of-1d-array/solution/gong-shui-san-xie-yi-wei-qian-zhui-he-mo-g8hn/", "difficulty": "简单", "tags": ["模拟", "前缀和"], "question": "给你一个数组 nums 。数组「动态和」的计算公式为:runningSum[i] = sum(nums[0]...nums[i]) 。\n\n请返回 nums 的动态和。\n\n示例 1:\n```\n输入:nums = [1,2,3,4]\n\n输出:[1,3,6,10]\n\n解释:动态和计算过程为 [1, 1+2, 1+2+3, 1+2+3+4] 。\n```\n示例 2:\n```\n输入:nums = [1,1,1,1,1]\n\n输出:[1,2,3,4,5]\n\n解释:动态和计算过程为 [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1] 。\n```\n示例 3:\n```\n输入:nums = [3,1,2,10,1]\n\n输出:[3,4,6,16,17]\n```\n\n提示:\n* 1 <= nums.length <= 1000\n* -$10^6$ <= nums[i] <= $10^6$", "solution": "### 一维前缀和\n\n根据题意,创建答案数组,从头到尾模拟一遍,每次都将当前的前缀之和赋值给 $ans[i]$ 即可。\n\n代码:\n```Java\nclass Solution {\n    public int[] runningSum(int[] nums) {\n        int n = nums.length;\n        int[] ans = new int[n];\n        for (int i = 0, s = 0; i < n; i++) {\n            ans[i] = s = s + nums[i];\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1480` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1481-1490/1482. 制作 m 束花所需的最少天数（中等）.md", "url_title": "1482. 制作 m 束花所需的最少天数", "url": "https://leetcode-cn.com/problems/minimum-number-of-days-to-make-m-bouquets/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-ysv4/", "difficulty": "中等", "tags": ["二分"], "question": "给你一个整数数组 bloomDay,以及两个整数 m 和 k 。\n\n现需要制作 m 束花。制作花束时,需要使用花园中 相邻的 k 朵花 。\n\n花园中有 n 朵花,第 i 朵花会在 bloomDay[i] 时盛开,恰好 可以用于 一束 花中。\n\n请你返回从花园中摘 m 束花需要等待的最少的天数。如果不能摘到 m 束花则返回 -1 。\n\n \n\n示例 1:\n```\n输入:bloomDay = [1,10,3,10,2], m = 3, k = 1\n\n输出:3\n\n解释:让我们一起观察这三天的花开过程,x 表示花开,而 _ 表示花还未开。\n现在需要制作 3 束花,每束只需要 1 朵。\n1 天后:[x, _, _, _, _]   // 只能制作 1 束花\n2 天后:[x, _, _, _, x]   // 只能制作 2 束花\n3 天后:[x, _, x, _, x]   // 可以制作 3 束花,答案为 3\n```\n示例 2:\n```\n输入:bloomDay = [1,10,3,10,2], m = 3, k = 2\n\n输出:-1\n\n解释:要制作 3 束花,每束需要 2 朵花,也就是一共需要 6 朵花。而花园中只有 5 朵花,无法满足制作要求,返回 -1 。\n```\n示例 3:\n```\n输入:bloomDay = [7,7,7,7,12,7,7], m = 2, k = 3\n\n输出:12\n\n解释:要制作 2 束花,每束需要 3 朵。\n花园在 7 天后和 12 天后的情况如下:\n7 天后:[x, x, x, x, _, x, x]\n可以用前 3 朵盛开的花制作第一束花。但不能使用后 3 朵盛开的花,因为它们不相邻。\n12 天后:[x, x, x, x, x, x, x]\n显然,我们可以用不同的方式制作两束花。\n```\n示例 4:\n```\n输入:bloomDay = [1000000000,1000000000], m = 1, k = 1\n\n输出:1000000000\n\n解释:需要等 1000000000 天才能采到花来制作花束\n```\n示例 5:\n```\n输入:bloomDay = [1,10,2,9,3,8,4,7,5,6], m = 4, k = 2\n\n输出:9\n```\n\n提示:\n* bloomDay.length == n\n* 1 <= n <= $10^5$\n* 1 <= bloomDay[i] <= $10^9$\n* 1 <= m <= $10^6$\n* 1 <= k <= n", "solution": "### 二分查找\n\n题目需要求得「所需的最少天数」。\n\n假设「所需的最少天数」为 `ans` ,那么以 `ans` 为分割点的数轴具有「二段性」:\n\n* 天数范围落在 $[0, ans)$ 无法制作完成\n* 天数范围在 $[ans, +∞)$ 可以制作完成\n\n因此可以通过「二分」来找到分割点 `ans`。\n\n接下来我们需要确定「二分范围」,一个及格的「二分范围」只需要确保答案落在范围即可。\n\n显然范围的左边界为 $0$(代表尚未有花绽放),范围的右边界为 $max(bloomDay[i])$(最后一朵花的开放时间,代表所有花都开完)。\n\n我们既可以通过遍历 $bloomDay[]$ 数组来取得「精确右边界」,也可以直接根据数据范围 `1 <= bloomDay[i] <= 10^9` 来确定「粗略右边界」。\n\n由于二分查找本身具有“折半”效率,因此两者不会有太大效率差距,我这里采用「粗略右边界」的方式。\n\n代码:\n```Java\nclass Solution {\n    int n, m, k;\n    boolean[] fl;\n    public int minDays(int[] nums, int _m, int _k) {\n        n = nums.length;\n        m = _m; k = _k;\n\n        if (n < m * k) return -1;\n        \n        fl = new boolean[n];\n        \n        int l = 0, r = (int)1e9;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (check(nums, mid)) {\n                r = mid;\n            } else {\n                l = mid + 1;\n            }\n        }\n        return check(nums, r) ? r : -1;\n    }\n    boolean check(int[] nums, int mid) {\n        for (int i = 0; i < n; i++) {\n            fl[i] = nums[i] <= mid;\n        }\n        int cnt = 0;\n        for (int i = 0; i < n && cnt < m; ) {\n            if (fl[i]) {\n                int cur = 1, j = i;\n                while (cur < k && j + 1 < n && fl[j + 1]) {\n                    j++;\n                    cur++;\n                }\n                if (cur == k) cnt++;\n                i = j + 1;\n            } else {\n                i++;\n            }\n        }\n        return cnt >= m;\n    }\n}\n```\n* 时间复杂度:`check` 函数的复杂度为 $O(n)$。整体复杂度为 $O(n\\log{1e9})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 优化 check 函数\n\n不难发现,上述 `check` 函数每次都先将所有已开的花预处理出来。复杂度是严格 $O(n)$。\n\n其实这个过程也能下放到统计逻辑去做,这样能够让 `check` 函数的复杂度从严格 $O(n)$ 变为最坏情况 $O(n)$,同时省去 $fl[]$ 数组,将空间优化至 $O(1)$。\n\n代码:\n```Java\nclass Solution {\n    int n, m, k;\n    public int minDays(int[] nums, int _m, int _k) {\n        n = nums.length;\n        m = _m; k = _k;\n\n        if (n < m * k) return -1;\n                \n        int l = 0, r = (int)1e9;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (check(nums, mid)) {\n                r = mid;\n            } else {\n                l = mid + 1;\n            }\n        }\n        return check(nums, r) ? r : -1;\n    }\n    boolean check(int[] nums, int mid) {\n        int cnt = 0;\n        for (int i = 0; i < n && cnt < m; ) {\n            int cur = nums[i] <= mid ? 1 : 0, j = i;\n            if (cur > 0) {\n                while (cur < k && j + 1 < n && nums[j + 1] <= mid) {\n                    j++;\n                    cur++;\n                }\n                if (cur == k) cnt++;\n                i = j + 1;\n            } else {\n                i++;\n            }\n        }\n        return cnt >= m;\n    }\n}\n```\n* 时间复杂度:`check` 函数的复杂度为 $O(n)$。整体复杂度为 $O(n\\log{1e9})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1482` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1481-1490/1486. 数组异或操作（简单）.md", "url_title": "1486. 数组异或操作", "url": "https://leetcode-cn.com/problems/xor-operation-in-an-array/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-dggg/", "difficulty": "简单", "tags": ["数学", "模拟"], "question": "给你两个整数,n 和 start 。\n\n数组 nums 定义为:nums[i] = start + 2*i(下标从 0 开始)且 n == nums.length 。\n\n请返回 nums 中所有元素按位异或(XOR)后得到的结果。\n\n示例 1:\n```\n输入:n = 5, start = 0\n\n输出:8\n\n解释:数组 nums 为 [0, 2, 4, 6, 8],其中 (0 ^ 2 ^ 4 ^ 6 ^ 8) = 8 。\n     \"^\" 为按位异或 XOR 运算符。\n```\n示例 2:\n```\n输入:n = 4, start = 3\n\n输出:8\n\n解释:数组 nums 为 [3, 5, 7, 9],其中 (3 ^ 5 ^ 7 ^ 9) = 8.\n```\n示例 3:\n```\n输入:n = 1, start = 7\n\n输出:7\n```\n示例 4:\n```\n输入:n = 10, start = 5\n\n输出:2\n```\n\n提示:\n* 1 <= n <= 1000\n* 0 <= start <= 1000\n* n == nums.length", "solution": "### 模拟\n\n数据范围只有 $10^3$,按照题目要求从头模拟一遍即可。\n\n代码:\n```Java\nclass Solution {\n    public int xorOperation(int n, int start) {\n        int ans = start;\n        for (int i = 1; i < n; i++) {\n            int x = start + 2 * i;\n            ans ^= x;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 数学\n\n上述解法数据范围出到 $10^8$ 大概率会发生 TLE。\n\n如果数据范围出到 $10^8$ 的话,本题难度应该会归为「中等」或「困难」。\n\n事实上,本题存在「数学规律」解法。\n\n原式子为 $start ⊕ (start + 2) ⊕ (start + 4) ⊕ ... ⊕ (start + 2 * (n - 1))$ 。\n\n我们发现原式子中只有数值 $2$ 是固定系数(由题目给定),考虑将其进行提出。\n\n得到新式子 $s ⊕ (s + 1) ⊕ (s + 2) ⊕ ... ⊕ (s + (n - 1)) * 2$,其中 $s = start / 2$。\n\n之所以进行这样的转换操作,是因为我们想要利用 $1 ⊕ 2 ⊕ 3 = 0$ 的异或性质。\n\n**但是转换到了这一步,我们发现「新式子」与「原式子」其实并不相等。**\n\n我们需要考虑两者之间的差值关系:\n\n**不难发现,将「原式」转化成「新式」的集体除以 $2$ 的操作相当于将每个 $item$ 的进行「右移一位」,同时「异或运算」是每位独立计算的,因此「右移一位」不会影响移动部分的计算结果。**\n\n**本质上,「原式」转化成「新式」是将最终答案 `ans` 进了「右移」一位的操作。因此如果要重新得到 `ans`,我们需要将其重新「左移」一位,将最后一位异或结果补回。**\n\n即 `原式结果 = 新式结果 << 1 | e`,$e$ 为最后一位异或结果(只能是 $0$ 或者 $1$,其余高位为 $0$)。\n\n我们重新观察「原式」发现式子中每个 $item$ 奇偶性相同,这意味着其二进制的最低位相同。\n\n根据 `n` 和 `start` 的奇偶数搭配,不难得最后一位 `e = n & start & 1`。\n\n剩下的问题在于如何在不遍历的情况下计算「新式」结果,前面说到转化的目的是为了利用 $1 ⊕ 2 ⊕ 3 = 0$ 异或特性。\n\n事实上,这个式子存在一般性的推广结论:$4i ⊕ (4i + 1) ⊕ (4i + 2) ⊕ (4i + 3) = 0$。\n\n因此只需要对最后一项进行 `%4` 讨论即可,这部分属于「结论」,详见代码的 `calc` 部分。\n\n**总结一下,假设我们最终的答案为 `ans`。整个处理过程其实就是把原式中的每个 $item$ 右移一位(除以 $2$),计算 `ans` 中除了最低一位以外的结果;然后再将 `ans` 进行一位左移(重新乘以 $2$),将原本丢失的最后一位结果重新补上。补上则是利用了 `n` 和 `start` 的「奇偶性」的讨论。**\n\n代码:\n```Java\nclass Solution {\n    int calc(int x) {\n        if (x % 4 == 0) return x;\n        else if (x % 4 == 1) return 1;\n        else if (x % 4 == 2) return x + 1;\n        else return 0;\n    }\n    public int xorOperation(int n, int start) {\n        // 整体除以 2,利用 %4 结论计算 ans 中除「最低一位」的结果\n        int s = start >> 1;\n        int prefix = calc(s - 1) ^ calc(s + n - 1);\n        // 利用「奇偶性」计算 ans 中的「最低一位」结果\n        int last = n & start & 1;\n        int ans = prefix << 1 | last;\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1486` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1501-1510/1503. 所有蚂蚁掉下来前的最后一刻（中等）.md", "url_title": "1503. 所有蚂蚁掉下来前的最后一刻", "url": "https://leetcode.cn/problems/last-moment-before-all-ants-fall-out-of-a-plank/solution/gong-shui-san-xie-chang-gui-mo-ni-ti-by-u77hy/", "difficulty": "中等", "tags": ["模拟", "脑筋急转弯"], "question": "有一块木板,长度为 `n` 个 单位 。一些蚂蚁在木板上移动,每只蚂蚁都以每秒一个单位的速度移动。其中,一部分蚂蚁向左移动,其他蚂蚁向右移动。\n\n当两只向 不同 方向移动的蚂蚁在某个点相遇时,它们会同时改变移动方向并继续移动。假设更改方向不会花费任何额外时间。\n\n而当蚂蚁在某一时刻 `t` 到达木板的一端时,它立即从木板上掉下来。\n\n给你一个整数 `n` 和两个整数数组 `left` 以及 `right`。两个数组分别标识向左或者向右移动的蚂蚁在 `t = 0` 时的位置。请你返回最后一只蚂蚁从木板上掉下来的时刻。\n\n示例 1:\n\n```\n输入:n = 4, left = [4,3], right = [0,1]\n\n输出:4\n\n解释:如上图所示:\n-下标 0 处的蚂蚁命名为 A 并向右移动。\n-下标 1 处的蚂蚁命名为 B 并向右移动。\n-下标 3 处的蚂蚁命名为 C 并向左移动。\n-下标 4 处的蚂蚁命名为 D 并向左移动。\n请注意,蚂蚁在木板上的最后时刻是 t = 4 秒,之后蚂蚁立即从木板上掉下来。(也就是说在 t = 4.0000000001 时,木板上没有蚂蚁)。\n```\n示例 2:\n\n```\n输入:n = 7, left = [], right = [0,1,2,3,4,5,6,7]\n\n输出:7\n\n解释:所有蚂蚁都向右移动,下标为 0 的蚂蚁需要 7 秒才能从木板上掉落。\n```\n示例 3:\n\n```\n输入:n = 7, left = [0,1,2,3,4,5,6,7], right = []\n\n输出:7\n\n解释:所有蚂蚁都向左移动,下标为 7 的蚂蚁需要 7 秒才能从木板上掉落。\n```\n\n提示:\n* $1 <= n <= 10^4$\n* $0 <= left.length <= n + 1$\n* $0 <= left[i] <= n$\n* $0 <= right.length <= n + 1$\n* $0 <= right[i] <= n$\n* $1 <= left.length + right.length <= n + 1$\n* `left` 和 `right` 中的所有值都是唯一的,并且每个值 只能出现在二者之一 中。", "solution": "### 模拟\n\n当一只蚂蚁起始位置为 `x`,方向往左,且往左移动过程不受其他影响时,其到达左边界所需时间为 `x`;若方向往右,且往右移动过程不受其他影响时,其到达右边界所需时间为 `n - x`。\n\n蚂蚁之间的相互影响实际上并不会影响它们到达木板边缘的时间。\n\n两只相遇的蚂蚁只是简单地交换了彼此的移动方向,并没有影响到它们的移动步数,即两只蚂蚁相遇可视为身份互换。\n\n因此,我们只需要分别计算每只蚂蚁单独掉落到木板边缘所需的时间,然后取最大值即可得到所有蚂蚁掉落的最后时刻。\n\nJava 代码:\n```Java\nclass Solution {\n    public int getLastMoment(int n, int[] left, int[] right) {\n        int ans = 0;\n        for (int x : left) ans = Math.max(ans, x);\n        for (int x : right) ans = Math.max(ans, n - x);\n        return ans;\n    }\n}\n```\nC++  代码:\n```C++\nclass Solution {\npublic:\n    int getLastMoment(int n, vector<int>& left, vector<int>& right) {\n        int ans = 0;\n        for (int x : left) ans = max(ans, x);\n        for (int x : right) ans = max(ans, n - x);\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def getLastMoment(self, n: int, left: List[int], right: List[int]) -> int:\n        return max(left + [n - x for x in right])\n```\nTypeScript 代码:\n```TypeScript\nfunction getLastMoment(n: number, left: number[], right: number[]): number {\n    let ans = 0;\n    for (const x of left) ans = Math.max(ans, x);\n    for (const x of right) ans = Math.max(ans, n - x);\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1503` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/151-160/153. 寻找旋转排序数组中的最小值（中等）.md", "url_title": "153. 寻找旋转排序数组中的最小值", "url": "https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/", "difficulty": "中等", "tags": ["二分"], "question": "已知一个长度为 n 的数组,预先按照升序排列,经由 1 到 n 次 旋转 后,得到输入数组。\n\n例如,原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到:\n\n* 若旋转 4 次,则可以得到 [4,5,6,7,0,1,2]\n* 若旋转 7 次,则可以得到 [0,1,2,4,5,6,7]\n\n注意,数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。\n\n给你一个元素值 互不相同 的数组 nums ,它原来是一个升序排列的数组,并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。\n\n示例 1:\n```\n输入:nums = [3,4,5,1,2]\n\n输出:1\n\n解释:原数组为 [1,2,3,4,5] ,旋转 3 次得到输入数组。\n```\n示例 2:\n```\n输入:nums = [4,5,6,7,0,1,2]\n\n输出:0\n\n解释:原数组为 [0,1,2,4,5,6,7] ,旋转 4 次得到输入数组。\n```\n示例 3:\n```\n输入:nums = [11,13,15,17]\n\n输出:11\n\n解释:原数组为 [11,13,15,17] ,旋转 4 次得到输入数组。\n```\n\n提示:\n* n == nums.length\n* 1 <= n <= 5000\n* -5000 <= nums[i] <= 5000\n* nums 中的所有整数 互不相同\n* nums 原来是一个升序排序的数组,并进行了 1 至 n 次旋转", "solution": "### 二分查找\n\n今天这道题和昨天的 [81. 搜索旋转排序数组 II](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/) 相比,有了限制条件「所有整数互不相同」。\n\n因此我们不需要进行「恢复二段性」的预处理,是可以做到严格 $O(log{n})$ 的复杂度。\n\n我们仍然从「二分」的本质「二段性」进行出发分析:\n\n经过旋转的数组,显然前半段满足 `>= nums[0]`,而后半段不满足 `>= nums[0]`。我们可以以此作为依据,通过「二分」找到旋转点。然后通过旋转点找到全局最小值即可。\n\n代码:\n```java []\nclass Solution {\n    public int findMin(int[] nums) {\n        int n = nums.length;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (nums[mid] >= nums[0]) {\n                l = mid;\n            } else {\n                r = mid - 1;\n            }\n        }\n        return r + 1 < n ? nums[r + 1] : nums[0];\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n***\n\n### 其他「二分」相关题解\n\n* 二分模板\n    [29. 两数相除](https://leetcode-cn.com/problems/divide-two-integers/) : [二分 + 倍增乘法解法(含模板)](https://leetcode-cn.com/problems/divide-two-integers/solution/shua-chuan-lc-er-fen-bei-zeng-cheng-fa-j-m73b/)\n\n* 二分本质 & 恢复二段性处理\n\n    [33. 搜索旋转排序数组(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/)\n\n    [81. 搜索旋转排序数组 II(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-xtam4/)\n\n    [153. 寻找旋转排序数组中的最小值(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/)\n\n    [154. 寻找旋转排序数组中的最小值 II(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-7xbty/)\n\n* 二分 check 函数如何确定\n    [34. 在排序数组中查找元素的第一个和最后一个位置](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/) : [考察对「二分」的理解,以及 check 函数的「大于 小于」怎么写](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/gong-shui-san-xie-kao-cha-dui-er-fen-de-86bk0/)\n\n* 二分答案的题目\n    [1482. 制作 m 束花所需的最少天数](https://leetcode-cn.com/problems/minimum-number-of-days-to-make-m-bouquets/) : [利用「二段性」找分割点,以及优化 check 函数](https://leetcode-cn.com/problems/minimum-number-of-days-to-make-m-bouquets/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-ysv4/)\n    [1011. 在 D 天内送达包裹的能力](https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/) : [利用「二段性」找分割点,以及如何确定「二分范围」](https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-95zj/)", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.153` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/151-160/154. 寻找旋转排序数组中的最小值 II（困难）.md", "url_title": "154. 寻找旋转排序数组中的最小值 II", "url": "https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-7xbty/", "difficulty": "困难", "tags": ["二分"], "question": "已知一个长度为 `n` 的数组,预先按照升序排列,经由 $1$ 到 $n$ 次 旋转 后,得到输入数组。\n\n例如,原数组 `nums = [0,1,4,4,5,6,7]` 在变化后可能得到:\n\n* 若旋转 $4$ 次,则可以得到 `[4,5,6,7,0,1,4]`\n* 若旋转 $74 次,则可以得到 `[0,1,4,4,5,6,7]`\n\n注意,数组 `[a[0], a[1], a[2], ..., a[n-1]]` 旋转一次 的结果为数组 `[a[n-1], a[0], a[1], a[2], ..., a[n-2]]` 。\n\n给你一个可能存在「重复」元素值的数组 `nums` ,它原来是一个升序排列的数组,并按上述情形进行了多次旋转。\n\n请你找出并返回数组中的「最小元素」。\n\n示例 1:\n```\n输入:nums = [1,3,5]\n\n输出:1\n```\n示例 2:\n```\n输入:nums = [2,2,2,0,1]\n\n输出:0\n```\n\n提示:\n* $n == nums.length$\n* $1 <= n <= 5000$\n* $-5000 <= nums[i] <= 5000$\n* `nums` 原来是一个升序排序的数组,并进行了 $1$ 至 $n$ 次旋转\n\n进阶:\n* 这道题是 寻找旋转排序数组中的最小值 的延伸题目。\n* 允许重复会影响算法的时间复杂度吗?会如何影响,为什么?", "solution": "### 二分\n\n根据题意,我们知道,所谓的旋转其实就是「将某个下标前面的所有数整体移到后面,使得数组从整体有序变为分段有序」。\n\n但和 [153. 寻找旋转排序数组中的最小值](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/) 不同的是,本题元素并不唯一。\n\n**这意味着我们无法直接根据与** $nums[0]$ **的大小关系,将数组划分为两段,即无法通过「二分」来找到旋转点。**\n\n**因为「二分」的本质是二段性,并非单调性。只要一段满足某个性质,另外一段不满足某个性质,就可以用「二分」。**\n\n如果你有看过我 [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/) 这篇题解,你应该很容易就理解上句话的意思。如果没有也没关系,我们可以先解决本题,在理解后你再去做 [153. 寻找旋转排序数组中的最小值](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/),我认为这两题都是一样的,不存在先后关系。\n\n举个🌰,我们使用数据 [0,1,2,2,2,3,4,5] 来理解为什么不同的旋转点会导致「二段性丢失」:\n\nJava 代码:\n```java\nclass Solution {\n    public int minArray(int[] nums) {\n        int n = nums.length;\n        int l = 0, r = n - 1;\n        while (l < r && nums[0] == nums[r]) r--;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (nums[mid] >= nums[0]) l = mid;                \n            else r = mid - 1;\n        }\n        return r + 1 < n ? nums[r + 1] : nums[0];\n    }\n}\n```\nTypeScript 代码:\n```TypeScript \nfunction minArray(nums: number[]): number {\n    const n = nums.length\n    let l = 0, r = n - 1\n    while (l < r && nums[0] == nums[r]) r--\n    while (l < r) {\n        const mid = l + r + 1 >> 1\n        if (nums[mid] >= nums[0]) l = mid\n        else r = mid - 1\n    }\n    return r + 1 < n ? nums[r + 1] : nums[0]\n};\n```\n* 时间复杂度:恢复二段性处理中,最坏的情况下(考虑整个数组都是同一个数)复杂度是 $O(n)$,而之后的找旋转点是「二分」,复杂度为 $O(\\log{n})$。整体复杂度为 $O(n)$ \n* 空间复杂度:$O(1)$\n\n---\n\n### 进阶\n\n如果真正理解「二分」的话,本题和 [153. 寻找旋转排序数组中的最小值](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/) 区别不大。\n\n建议大家在完成两题的基础上试试 [面试题 10.03. 搜索旋转数组](https://leetcode-cn.com/problems/search-rotate-array-lcci/) 。\n\n---\n\n### 其他「二分」相关题解\n\n* 二分模板\n    [29. 两数相除](https://leetcode-cn.com/problems/divide-two-integers/) : [二分 + 倍增乘法解法(含模板)](https://leetcode-cn.com/problems/divide-two-integers/solution/shua-chuan-lc-er-fen-bei-zeng-cheng-fa-j-m73b/)\n\n* 二分本质 & 恢复二段性处理\n\n    [33. 搜索旋转排序数组(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/)\n\n    [81. 搜索旋转排序数组 II(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-xtam4/)\n\n    [153. 寻找旋转排序数组中的最小值(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/)\n\n    [154. 寻找旋转排序数组中的最小值 II(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-7xbty/)\n\n* 二分 check 函数如何确定\n    [34. 在排序数组中查找元素的第一个和最后一个位置](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/) : [考察对「二分」的理解,以及 check 函数的「大于 小于」怎么写](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/gong-shui-san-xie-kao-cha-dui-er-fen-de-86bk0/)\n\n* 二分答案的题目\n    [1482. 制作 m 束花所需的最少天数](https://leetcode-cn.com/problems/minimum-number-of-days-to-make-m-bouquets/) : [利用「二段性」找分割点,以及优化 check 函数](https://leetcode-cn.com/problems/minimum-number-of-days-to-make-m-bouquets/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-ysv4/)\n    [1011. 在 D 天内送达包裹的能力](https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/) : [利用「二段性」找分割点,以及如何确定「二分范围」](https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-95zj/)", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.154` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/151-160/155. 最小栈（简单）.md", "url_title": "155. 最小栈", "url": "https://leetcode-cn.com/problems/min-stack/solution/tu-li-zhan-shi-shuang-zhan-shi-xian-zui-fcwj5/", "difficulty": "简单", "tags": ["栈"], "question": "设计一个支持 push ,pop ,top 操作,并能在常数时间内检索到最小元素的栈。\n* push(x) —— 将元素 x 推入栈中。\n* pop() —— 删除栈顶的元素。\n* top() —— 获取栈顶元素。\n* getMin() —— 检索栈中的最小元素。\n\n示例:\n```\n输入:\n[\"MinStack\",\"push\",\"push\",\"push\",\"getMin\",\"pop\",\"top\",\"getMin\"]\n[[],[-2],[0],[-3],[],[],[],[]]\n```\n输出:\n```\n[null,null,null,null,-3,null,0,-2]\n\n解释:\nMinStack minStack = new MinStack();\nminStack.push(-2);\nminStack.push(0);\nminStack.push(-3);\nminStack.getMin();   --> 返回 -3.\nminStack.pop();\nminStack.top();      --> 返回 0.\nminStack.getMin();   --> 返回 -2.\n```\n\n提示:\n* pop、top 和 getMin 操作总是在 非空栈 上调用。", "solution": "### 双栈解法\n\n为了快速找到栈中最小的元素,我们可以使用一个辅助栈 help。\n\n通过控制 help 的压栈逻辑来实现:*help 栈顶中始终存放着栈内元素的最小值。*\n\n代码:\n```java\nclass MinStack {\n    Deque<Integer> data = new ArrayDeque<>();\n    Deque<Integer> help = new ArrayDeque<>();\n\n    public void push(int val) {\n        data.addLast(val);\n        if (help.isEmpty() || help.peekLast() >= val) {\n            help.addLast(val);\n        } else {\n            help.addLast(help.peekLast());\n        }\n    }\n    \n    public void pop() {\n        data.pollLast();\n        help.pollLast();\n    }\n    \n    public int top() {\n        return data.peekLast();\n    }\n    \n    public int getMin() {\n        return help.peekLast();\n    }\n}\n```\n* 时间复杂度:所有的操作均为 $O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.155` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/151-160/160. 相交链表（简单）.md", "url_title": "160. 相交链表", "url": "https://leetcode-cn.com/problems/intersection-of-two-linked-lists/solution/gong-shui-san-xie-zhao-liang-tiao-lian-b-h3bd/", "difficulty": "简单", "tags": ["链表", "栈"], "question": "给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null 。\n\n图示两个链表在节点 c1 开始相交:\n\n<img src=\"https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_statement.png\" style=\"zoom:50%;\" />\n\n题目数据 保证 整个链式结构中不存在环。\n\n注意,函数返回结果后,链表必须 保持其原始结构 。\n\n示例 1:\n<img src=\"https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_example_1.png\" style=\"zoom:50%;\" />\n\n```\n输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3\n输出:Intersected at '8'\n解释:相交节点的值为 8 (注意,如果两个链表相交则不能为 0)。\n从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,0,1,8,4,5]。\n在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。\n```\n示例 2:\n<img src=\"https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_example_2.png\" style=\"zoom: 67%;\" />\n\n```\n输入:intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1\n输出:Intersected at '2'\n解释:相交节点的值为 2 (注意,如果两个链表相交则不能为 0)。\n从各自的表头开始算起,链表 A 为 [0,9,1,2,4],链表 B 为 [3,2,4]。\n在 A 中,相交节点前有 3 个节点;在 B 中,相交节点前有 1 个节点。\n```\n示例 3:\n\n```\n输入:intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2\n输出:null\n解释:从各自的表头开始算起,链表 A 为 [2,6,4],链表 B 为 [1,5]。\n由于这两个链表不相交,所以 intersectVal 必须为 0,而 skipA 和 skipB 可以是任意值。\n这两个链表不相交,因此返回 null 。\n```\n\n提示:\n* listA 中节点数目为 m\n* listB 中节点数目为 n\n* 0 <= m, n <= 3 * $10^4$\n* 1 <= Node.val <= $10^5$\n* 0 <= skipA <= m\n* 0 <= skipB <= n\n* 如果 listA 和 listB 没有交点,intersectVal 为 0\n* 如果 listA 和 listB 有交点,intersectVal == listA[skipA + 1] == listB[skipB + 1]\n\n进阶:你能否设计一个时间复杂度 $O(n)$ 、仅用 $O(1)$ 内存的解决方案?", "solution": "### 朴素解法\n\n一个朴素的做法是两层循环:当遇到第一个相同的节点时说明找到了;全都走完了还没遇到相同,说明不存在交点。\n\n代码:\n```Java\npublic class Solution {\n    public ListNode getIntersectionNode(ListNode a, ListNode b) {\n        for (ListNode h1 = a; h1 != null ; h1 = h1.next) {\n            for (ListNode h2 = b; h2 != null ; h2 = h2.next) {\n                if (h1.equals(h2)) return h1;\n            }\n        }\n        return null;\n    }\n}\n```\n* 时间复杂度:$O(n * m)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 栈解法\n\n将两条链表分别压入两个栈中,然后循环比较两个栈的栈顶元素,同时记录上一位栈顶元素。\n\n当遇到第一个不同的节点时,结束循环,上一位栈顶元素即是答案。\n\n代码:\n```Java\npublic class Solution {\n    public ListNode getIntersectionNode(ListNode a, ListNode b) {\n        Deque<ListNode> d1 = new ArrayDeque(), d2 = new ArrayDeque();\n        while (a != null) {\n            d1.addLast(a);\n            a = a.next;\n        } \n        while (b != null) {\n            d2.addLast(b);\n            b = b.next;\n        }\n        ListNode ans = null;\n        while (!d1.isEmpty() && !d2.isEmpty() && d1.peekLast().equals(d2.peekLast())) {\n            ListNode c1 = d1.pollLast(), c2 = d2.pollLast();\n            ans = c1;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### 差值解法\n\n先对两条链表扫描一遍,取得两者长度,然后让长的链表先走「两者的长度差值」,然后再同时走,遇到第一个节点即是答案。\n\n代码:\n```Java\npublic class Solution {\n    public ListNode getIntersectionNode(ListNode a, ListNode b) {\n        int c1 = 0, c2 = 0;\n        ListNode t1 = a, t2 = b;\n        while (t1 != null && ++c1 > 0) t1 = t1.next;\n        while (t2 != null && ++c2 > 0) t2 = t2.next;\n        int t = Math.abs(c1 - c2);\n        while (t-- > 0) {\n            if (c1 > c2) a = a.next;\n            else b = b.next;\n        }\n        while (a != null && b != null) {\n            if (a.equals(b)) {\n                return a;\n            } else {\n                a = a.next;\n                b = b.next;\n            }\n        }\n        return null;\n    }\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.160` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1511-1520/1518. 换酒问题（简单）.md", "url_title": "1518. 换酒问题", "url": "https://leetcode-cn.com/problems/water-bottles/solution/gong-shui-san-xie-yi-ti-shuang-jie-ji-sh-7yyo/", "difficulty": "简单", "tags": ["模拟", "数学"], "question": "小区便利店正在促销,用 `numExchange` 个空酒瓶可以兑换一瓶新酒。你购入了 `numBottles` 瓶酒。\n\n如果喝掉了酒瓶中的酒,那么酒瓶就会变成空的。\n\n请你计算**最多**能喝到多少瓶酒。\n\n示例 1:\n\n```\n输入:numBottles = 9, numExchange = 3\n\n输出:13\n\n解释:你可以用 3 个空酒瓶兑换 1 瓶酒。\n所以最多能喝到 9 + 3 + 1 = 13 瓶酒。\n```\n示例 2:\n\n```\n输入:numBottles = 15, numExchange = 4\n\n输出:19\n\n解释:你可以用 4 个空酒瓶兑换 1 瓶酒。\n所以最多能喝到 15 + 3 + 1 = 19 瓶酒。\n```\n示例 3:\n```\n输入:numBottles = 5, numExchange = 5\n\n输出:6\n```\n示例 4:\n```\n输入:numBottles = 2, numExchange = 3\n\n输出:2\n```\n\n提示:\n* $1 <= numBottles <= 100$\n* $2 <= numExchange <= 100$", "solution": "### 模拟\n\n根据题意进行模拟即可,使用 $ans$ 统计答案,$n$ 为空瓶子个数。\n\n起始有 $n$ 瓶酒,因此 $ans = n$,此时空瓶子个数为 $n$,当且仅当空瓶子个数 $n$ 大于等于兑换个数 $m$ 时,可以继续喝到酒(能够更新 $ans$),兑换后得到酒的个数为 $a = \\left \\lfloor \\frac{n}{m} \\right \\rfloor$,剩余空瓶子个数等于「兑换酒的个数 $a$」和「兑换后剩余的酒瓶子个数 $b = n \\pmod m$」之和。\n\n代码:\n```Java\nclass Solution {\n    public int numWaterBottles(int n, int m) {\n        int ans = n;\n        while (n >= m) {\n            int a = n / m, b = n % m;\n            ans += a;\n            n = a + b;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:循环次数「不超过」能换新酒的数量,能够新酒的数量最多为 $\\left \\lfloor \\frac{n}{m - 1}\\right \\rfloor$ 瓶。复杂度为 $O(\\left \\lfloor \\frac{n}{m - 1}\\right \\rfloor)$。进一步,当 $m = 2$ 时,兑换酒的数量最多,此时复杂度为 $O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 数学\n\n起始有 $n$ 瓶酒,使用 $m$ 个空酒瓶能够换得一瓶新酒(饮用数量加一,且新瓶子数量加一)。即对于每次交换而言,会损失掉 $m - 1$ 个瓶子。\n\n利用每个回合损失的瓶子个数 $m - 1$ 为定值,可直接算出最大交换次数(额外饮用次数)$cnt = \\left \\lfloor \\frac{n}{m - 1}\\right \\rfloor$,加上起始酒的个数即是答案。\n\n注意边界条件:当 $n$ 为 $m - 1$ 的倍数时,最后一个回合不满足兑换条件。\n\n代码:\n```Java\nclass Solution {\n    public int numWaterBottles(int n, int m) {\n        int cnt = n / (m  - 1);\n        return n % (m - 1) == 0 ? n + cnt - 1 : n + cnt;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1518` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1531-1540/1537. 最大得分（困难）.md", "url_title": "1537. 最大得分", "url": "https://leetcode.cn/problems/get-the-maximum-score/solution/by-ac_oier-ht78/", "difficulty": "困难", "tags": ["前缀和", "构造", "双指针", "序列 DP", "动态规划"], "question": "你有两个 有序 且数组内元素互不相同的数组 `nums1` 和 `nums2` 。\n\n一条 合法路径 定义如下:\n\n* 选择数组 `nums1` 或者 `nums2` 开始遍历(从下标 $0$ 处开始)。\n* 从左到右遍历当前数组。\n* 如果你遇到了 `nums1` 和 `nums2` 中都存在的值,那么你可以切换路径到另一个数组对应数字处继续遍历(但在合法路径中重复数字只会被统计一次)。\n\n得分定义为合法路径中不同数字的和。\n\n请你返回所有可能合法路径中的最大得分。\n\n由于答案可能很大,请你将它对 $10^9 + 7$ 取余后返回。\n\n示例 1:\n\n```\n输入:nums1 = [2,4,5,8,10], nums2 = [4,6,8,9]\n\n输出:30\n\n解释:合法路径包括:\n[2,4,5,8,10], [2,4,5,8,9], [2,4,6,8,9], [2,4,6,8,10],(从 nums1 开始遍历)\n[4,6,8,9], [4,5,8,10], [4,5,8,9], [4,6,8,10]  (从 nums2 开始遍历)\n最大得分为上图中的绿色路径 [2,4,6,8,10] 。\n```\n示例 2:\n```\n输入:nums1 = [1,3,5,7,9], nums2 = [3,5,100]\n\n输出:109\n\n解释:最大得分由路径 [1,3,5,100] 得到。\n```\n示例 3:\n```\n输入:nums1 = [1,2,3,4,5], nums2 = [6,7,8,9,10]\n\n输出:40\n\n解释:nums1 和 nums2 之间无相同数字。\n最大得分由路径 [6,7,8,9,10] 得到。\n```\n示例 4:\n```\n输入:nums1 = [1,4,5,8,9,11,19], nums2 = [2,3,4,11,12]\n\n输出:61\n```\n\n提示:\n* $1 <= nums1.length <= 10^5$\n* $1 <= nums2.length <= 10^5$\n* $1 <= nums1[i], nums2[i] <= 10^7$\n* `nums1` 和 `nums2` 都是严格递增的数组。", "solution": "### 前缀和 + 构造(分段计算)\n\n一个简单且正确的做法,是我们构造一种决策方案,使得能够直接计算出最大得分。\n\n首先,在最佳路径中所有的公共点都必然会经过,因此我们可以将值相等的点进行合并,即看作同一个点。\n\n利用两个数组均满足「单调递增」,我们可以通过 $O(n + m)$ 的复杂度统计出那些公共点,以二元组 $(i, j)$ 的形式存储到 `list` 数组(二元组含义为 $nums1[i] = nums2[j]$)。\n\n对于 `list` 中的每对相邻元素(相邻公共点),假设为 $(a_i, b_i)$ 和 $(c_i, d_i)$,我们可以通过「前缀和」计算出 $nums1[a_i ... c_i]$ 以及 $nums2[b_i ... d_i]$ 的和,从而决策出在 $nums1[a_i]$(或者说是 $nums2[b_i]$,这两个是同一个点)时,我们应当走哪一段。\n\n当计算完所有公共点之间的得分后,对于最佳路线的首位两端,也是结合「前缀和」做同样的逻辑处理即可。\n\n代码:\n```Java\nclass Solution {\n    int MOD = (int)1e9 + 7;\n    public int maxSum(int[] nums1, int[] nums2) {\n        int n = nums1.length, m = nums2.length;\n        long[] s1 = new long[n + 10], s2 = new long[m + 10];\n        for (int i = 1; i <= n; i++) s1[i] = s1[i - 1] + nums1[i - 1];\n        for (int i = 1; i <= m; i++) s2[i] = s2[i - 1] + nums2[i - 1];\n        List<int[]> list = new ArrayList<>();\n        for (int i = 0, j = 0; i < n && j < m; ) {\n            if (nums1[i] == nums2[j]) list.add(new int[]{i, j});\n            if (nums1[i] < nums2[j]) i++;\n            else j++;\n        }\n        long ans = 0;\n        for (int i = 0, p1 = -1, p2 = -1; i <= list.size(); i++) {\n            int idx1 = 0, idx2 = 0;\n            if (i < list.size()) {\n                int[] info = list.get(i);\n                idx1 = info[0]; idx2 = info[1];\n            } else {\n                idx1 = n - 1; idx2 = m - 1;\n            }\n            long t1 = s1[idx1 + 1] - s1[p1 + 1], t2 = s2[idx2 + 1] - s2[p2 + 1];\n            ans += Math.max(t1, t2);\n            p1 = idx1; p2 = idx2;\n        }\n        return (int)(ans % MOD);\n    }\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### 序列 DP\n\n另外一个较为常见的做法是「序列 DP」做法。\n\n定义 $f[i]$ 代表在 `nums1` 上进行移动,到达 $nums1[i]$ 的最大得分;定义 $g[j]$ 代表在 `nums2` 上进行移动,到达 $nums[j]$ 的最大得分。\n\n由于两者的分析是类似的,我们以 $f[i]$ 为例进行分析即可。\n\n不失一般性考虑 $f[i]$ 如何转移,假设当前处理到的是 $nums1[i]$,根据 $nums1[i]$ 是否为公共点,进行分情况讨论:\n\n* $nums1[i]$ 不为公共点,此时只能由 $nums[i - 1]$ 转移而来,即有 $f[i] = f[i - 1] + nums[i]$;\n* $nums1[i]$ 为公共点(假设与 $nums2[j]$ 公共),此时能够从 $nums1[i - 1]$ 或 $nums2[j - 1]$ 转移而来,我们需要取 $f[i - 1]$ 和 $g[j - 1]$ 的最大值,即有 $f[i] = g[j] = \\max(f[i - 1], g[j - 1]) + nums1[i]$。\n\n更重要的是,我们需要确保计算 $f[i]$ 时,$g[j - 1]$ 已被计算完成。\n\n由于最佳路线必然满足「单调递增」,因此我们可以使用「双指针」来对 $f[i]$ 和 $g[j]$ 同时进行转移,每次取值小的进行更新,从而确保更新过程也是单调的,即当需要计算 $f[i]$ 时,比 $nums1[i]$ 小的 $f[X]$ 和 $g[X]$ 均被转移完成。\n\n代码:\n```Java\nclass Solution {\n    int MOD = (int)1e9 + 7;\n    public int maxSum(int[] nums1, int[] nums2) {\n        int n = nums1.length, m = nums2.length;\n        long[] f = new long[n + 1], g = new long[m + 1];\n        int i = 1, j = 1;\n        while (i <= n || j <= m) {\n            if (i <= n && j <= m) {\n                if (nums1[i - 1] < nums2[j - 1]) {\n                    f[i] = f[i - 1] + nums1[i - 1];\n                    i++;\n                } else if (nums2[j - 1] < nums1[i - 1]) {\n                    g[j] = g[j - 1] + nums2[j - 1];\n                    j++;\n                } else {\n                    f[i] = g[j] = Math.max(f[i - 1], g[j - 1]) + nums1[i - 1];\n                    i++; j++;\n                }\n            } else if (i <= n) {\n                f[i] = f[i - 1] + nums1[i - 1];\n                i++;\n            } else {\n                g[j] = g[j - 1] + nums2[j - 1];\n                j++;\n            }\n        }\n        return (int) (Math.max(f[n], g[m]) % MOD);\n    }\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1537` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1571-1580/1576. 替换所有的问号（简单）.md", "url_title": "1576. 替换所有的问号", "url": "https://leetcode-cn.com/problems/replace-all-s-to-avoid-consecutive-repeating-characters/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-fa1u/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个仅包含小写英文字母和 `'?'` 字符的字符串 `s`,请你将所有的 `'?'` 转换为若干小写字母,使最终的字符串不包含任何 **连续重复** 的字符。\n\n注意:你 不能 修改非 `'?'` 字符。\n\n题目测试用例保证 除 `'?'` 字符 之外,不存在连续重复的字符。\n\n在完成所有转换(可能无需转换)后返回最终的字符串。如果有多个解决方案,请返回其中任何一个。可以证明,在给定的约束条件下,答案总是存在的。\n\n示例 1:\n```\n输入:s = \"?zs\"\n\n输出:\"azs\"\n\n解释:该示例共有 25 种解决方案,从 \"azs\" 到 \"yzs\" 都是符合题目要求的。只有 \"z\" 是无效的修改,因为字符串 \"zzs\" 中有连续重复的两个 'z' 。\n```\n示例 2:\n```\n输入:s = \"ubv?w\"\n\n输出:\"ubvaw\"\n\n解释:该示例共有 24 种解决方案,只有替换成 \"v\" 和 \"w\" 不符合题目要求。因为 \"ubvvw\" 和 \"ubvww\" 都包含连续重复的字符。\n```\n示例 3:\n```\n输入:s = \"j?qg??b\"\n\n输出:\"jaqgacb\"\n```\n示例 4:\n```\n输入:s = \"??yw?ipkj?\"\n\n输出:\"acywaipkja\"\n```\n\n提示:\n* $1 <= s.length <= 100$\n* `s` 仅包含小写英文字母和 `'?'` 字符", "solution": "### 模拟\n\n根据题意进行模拟,尝试对每个 $s[i]$ 进行替换,能够替换的前提是 $s[i]$ 为 `?`,且替换字符与前后字符(若存在)不同,由于只需要确保与前后字符不同,因此必然最多在 $3$ 个字符内找到可替换的值。\n\n代码:\n```Java\nclass Solution {\n    public String modifyString(String s) {\n        char[] cs = s.toCharArray();\n        int n = cs.length;\n        for (int i = 0; i < n; i++) {\n            for (int c = 0; c < 3 && cs[i] == '?'; c++) {\n                boolean ok = true;\n                if (i - 1 >= 0 && cs[i - 1] == c + 'a') ok = false;\n                if (i + 1 < n && cs[i + 1] == c + 'a') ok = false;\n                if (ok) cs[i] = (char)(c + 'a');\n            }\n        }\n        return String.valueOf(cs);\n    }\n}\n```\n* 时间复杂度:会处理 `s` 中的所有字符,若当前字符为 `?` 时,会检查与前后字符的关系,最多在 $3$ 个字符内找到可替换的字符,复杂度为 $O(n * C)$,其中 $C = 3$ \n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1576` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1581-1590/1582. 二进制矩阵中的特殊位置（简单）.md", "url_title": "1582. 二进制矩阵中的特殊位置", "url": "https://leetcode.cn/problems/special-positions-in-a-binary-matrix/solution/by-ac_oier-61w0/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个大小为 `rows x cols` 的矩阵 `mat`,其中 `mat[i][j]` 是 `0` 或 `1`,请返回 矩阵 `mat` 中特殊位置的数目 。\n\n特殊位置 定义:如果 `mat[i][j] = 1` 并且第 `i` 行和第 `j` 列中的所有其他元素均为 `0`(行和列的下标均 从 `0` 开始 ),则位置 `(i, j)` 被称为特殊位置。\n\n示例 1:\n```\n输入:mat = [[1,0,0],\n            [0,0,1],\n            [1,0,0]]\n\n输出:1\n\n解释:(1,2) 是一个特殊位置,因为 mat[1][2] == 1 且所处的行和列上所有其他元素都是 0\n```\n示例 2:\n```\n输入:mat = [[1,0,0],\n            [0,1,0],\n            [0,0,1]]\n\n输出:3\n\n解释:(0,0), (1,1) 和 (2,2) 都是特殊位置\n```\n示例 3:\n```\n输入:mat = [[0,0,0,1],\n            [1,0,0,0],\n            [0,1,1,0],\n            [0,0,0,0]]\n\n输出:2\n```\n示例 4:\n```\n输入:mat = [[0,0,0,0,0],\n            [1,0,0,0,0],\n            [0,1,0,0,0],\n            [0,0,1,0,0],\n            [0,0,0,1,1]]\n\n输出:3\n```\n\n提示:\n* $rows = mat.length$\n* $cols = mat[i].length$\n* $1 <= rows, cols <= 100$\n* $mat[i][j]$ 是 `0` 或 `1`", "solution": "### 模拟\n\n根据题意,使用数组 `r` 和 `c` 分别预处理除每行和每列所含 $1$ 的个数,复杂度为 $O(m \\times n)$。\n\n随后分别统计特殊位置的个数:满足 $mat[i][j] = 1$ 且 $r[i] = c[j] = 1$ 的位置。\n\nJava 代码:\n```Java\nclass Solution {\n    public int numSpecial(int[][] mat) {\n        int n = mat.length, m = mat[0].length, ans = 0;\n        int[] r = new int[n], c = new int[m];\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                r[i] += mat[i][j]; c[j] += mat[i][j];\n            }\n        }\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                if (mat[i][j] == 1 && r[i] == 1 && c[j] == 1) ans++;\n            }\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction numSpecial(mat: number[][]): number {\n    let n = mat.length, m = mat[0].length, ans = 0\n    const r = new Array<number>(n).fill(0), c = new Array<number>(m).fill(0)\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < m; j++) {\n            r[i] += mat[i][j]; c[j] += mat[i][j]\n        }\n    }\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < m; j++) {\n            if (mat[i][j] == 1 && r[i] == 1 && c[j] == 1) ans++\n        }\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(m \\times n)$\n* 空间复杂度:$O(m + n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1582` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1581-1590/1583. 统计不开心的朋友（中等）.md", "url_title": "1583. 统计不开心的朋友", "url": "https://leetcode-cn.com/problems/count-unhappy-friends/solution/gong-shui-san-xie-ha-xi-biao-mo-ni-ti-by-2qy0/", "difficulty": "中等", "tags": ["哈希表", "模拟"], "question": "给你一份 `n` 位朋友的亲近程度列表,其中 `n` 总是**偶数** 。\n\n对每位朋友 `i`,`preferences[i]` 包含一份 按亲近程度从高到低排列 的朋友列表。\n\n换句话说,排在列表前面的朋友与 `i` 的亲近程度比排在列表后面的朋友更高。每个列表中的朋友均以 `0` 到 `n-1` 之间的整数表示。\n\n所有的朋友被分成几对,配对情况以列表 `pairs` 给出,其中 `pairs[i] = [xi, yi]` 表示 `xi` 与 `yi` 配对,且 `yi` 与 `xi` 配对。\n\n但是,这样的配对情况可能会是其中部分朋友感到不开心。在 `x` 与 `y` 配对且 `u` 与 `v` 配对的情况下,如果同时满足下述两个条件,`x` 就会不开心:\n\n* `x` 与 `u` 的亲近程度胜过 `x` 与 `y`,且\n* `u` 与 `x` 的亲近程度胜过 `u` 与 `v`\n\n返回 不开心的朋友的数目 。\n\n示例 1:\n```\n输入:n = 4, preferences = [[1, 2, 3], [3, 2, 0], [3, 1, 0], [1, 2, 0]], pairs = [[0, 1], [2, 3]]\n\n输出:2\n\n解释:\n朋友 1 不开心,因为:\n- 1 与 0 配对,但 1 与 3 的亲近程度比 1 与 0 高,且\n- 3 与 1 的亲近程度比 3 与 2 高。\n朋友 3 不开心,因为:\n- 3 与 2 配对,但 3 与 1 的亲近程度比 3 与 2 高,且\n- 1 与 3 的亲近程度比 1 与 0 高。\n朋友 0 和 2 都是开心的。\n```\n示例 2:\n```\n输入:n = 2, preferences = [[1], [0]], pairs = [[1, 0]]\n\n输出:0\n\n解释:朋友 0 和 1 都开心。\n```\n示例 3:\n```\n输入:n = 4, preferences = [[1, 3, 2], [2, 3, 0], [1, 3, 0], [0, 2, 1]], pairs = [[1, 3], [0, 2]]\n\n输出:4\n```\n\n提示:\n* 2 <= n <= 500\n* n 是偶数\n* preferences.length == n\n* preferences[i].length == n - 1\n* 0 <= preferences[i][j] <= n - 1\n* preferences[i] 不包含 i\n* preferences[i] 中的所有值都是独一无二的\n* pairs.length == n/2\n* pairs[i].length == 2\n* xi != yi\n* 0 <= xi, yi <= n - 1\n* 每位朋友都 恰好 被包含在一对中", "solution": "### 模拟\n\n模拟题,先将所有的 $preferences$ 使用「哈希表套哈希表」的形式进行存储,存储格式为 `{x : {y : score1}, {z : score12}, ... }`。\n\n如果 $x$ 和 $y$ 的亲密度要比 $x$ 和 $z$ 的亲密度要高,则有 $score1 > score2$。利用原本 $preferences[i]$ 就是按照亲密度进行排序,我们可以对下标进行转换作为亲密数得分即可。\n\n然后对所有的 $pairs$ 进行遍历,统计所有的答案,注意一个小朋友只能被统计一次。\n\n> 当然利用 $n$ 的数据范围,直接使用二维数组充当哈希表也是可以的(见 $P2$)\n\n代码:\n```Java\nclass Solution {\n    Map<Integer, Map<Integer, Integer>> map = new HashMap<>();\n    public int unhappyFriends(int n, int[][] preferences, int[][] pairs) {\n        int m = pairs.length;\n        for (int i = 0; i < n; i++) {\n            int[] p = preferences[i];\n            Map<Integer, Integer> cur = new HashMap<>();\n            for (int j = 0; j < n - 1; j++) cur.put(p[j], n - j);\n            map.put(i, cur);\n        }\n        int ans = 0;\n        for (int i = 0; i < m; i++) {\n            int x = pairs[i][0], y = pairs[i][1];\n            boolean xok = false, yok = false;\n            for (int j = 0; j < m; j++) {\n                if (i == j) continue;\n                int u = pairs[j][0], v = pairs[j][1];\n                if (!xok && check(x, y, u, v)) xok = true;\n                if (!yok && check(y, x, u, v)) yok = true;\n                if (xok && yok) break;\n            }\n            if (xok) ans++;\n            if (yok) ans++;\n        }\n        return ans;\n    }\n    boolean check(int x, int y, int u, int v) {\n        Map<Integer, Integer> xmap = map.get(x), ymap = map.get(y);\n        Map<Integer, Integer> umap = map.get(u), vmap = map.get(v);\n        if (xmap.get(u) > xmap.get(y) && umap.get(x) > umap.get(v)) return true;\n        if (xmap.get(v) > xmap.get(y) && vmap.get(x) > vmap.get(u)) return true;\n        return false;\n    }\n}\n```\n\n代码:\n```Java\nclass Solution {\n    int N = 510;\n    int[][] map = new int[N][N];\n    public int unhappyFriends(int n, int[][] preferences, int[][] pairs) {\n        int m = pairs.length;\n        for (int i = 0; i < n; i++) {\n            int[] p = preferences[i];\n            for (int j = 0; j < n - 1; j++) map[i][p[j]] = n - j;\n        }\n        int ans = 0;\n        for (int i = 0; i < m; i++) {\n            int x = pairs[i][0], y = pairs[i][1];\n            boolean xok = false, yok = false;\n            for (int j = 0; j < m; j++) {\n                if (i == j) continue;\n                int u = pairs[j][0], v = pairs[j][1];\n                if (!xok && check(x, y, u, v)) xok = true;\n                if (!yok && check(y, x, u, v)) yok = true;\n                if (xok && yok) break;\n            }\n            if (xok) ans++;\n            if (yok) ans++;\n        }\n        return ans;\n    }\n    boolean check(int x, int y, int u, int v) {\n        if (map[x][u] > map[x][y] && map[u][x] > map[u][v]) return true;\n        if (map[x][v] > map[x][y] && map[v][x] > map[v][u]) return true;\n        return false;\n    }\n}\n```\n* 时间复杂度:预处理出 `map` 的复杂度为 $O(n^2)$;遍历统计答案的复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1583` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1581-1590/1588. 所有奇数长度子数组的和（简单）.md", "url_title": "1588. 所有奇数长度子数组的和", "url": "https://leetcode-cn.com/problems/sum-of-all-odd-length-subarrays/solution/gong-shui-san-xie-yi-ti-shuang-jie-qian-18jq3/", "difficulty": "简单", "tags": ["前缀和", "数学"], "question": "给你一个正整数数组 `arr` ,请你计算所有可能的奇数长度子数组的和。\n\n子数组 定义为原数组中的一个连续子序列。\n\n请你返回 `arr` 中 所有奇数长度子数组的和 。\n\n示例 1:\n```\n输入:arr = [1,4,2,5,3]\n\n输出:58\n\n解释:所有奇数长度子数组和它们的和为:\n[1] = 1\n[4] = 4\n[2] = 2\n[5] = 5\n[3] = 3\n[1,4,2] = 7\n[4,2,5] = 11\n[2,5,3] = 10\n[1,4,2,5,3] = 15\n我们将所有值求和得到 1 + 4 + 2 + 5 + 3 + 7 + 11 + 10 + 15 = 58\n```\n示例 2:\n```\n输入:arr = [1,2]\n\n输出:3\n\n解释:总共只有 2 个长度为奇数的子数组,[1] 和 [2]。它们的和为 3 。\n```\n示例 3:\n```\n输入:arr = [10,11,12]\n\n输出:66\n```\n\n提示:\n* 1 <= arr.length <= 100\n* 1 <= arr[i] <= 1000", "solution": "### 前缀和 \n\n枚举所有长度为奇数的子数组,我们可以通过「枚举长度 - 枚举左端点,并计算右端点」的两层循环来做。\n\n而对于区间 $[l, r]$ 的和问题,可以直接再加一层循环来做,这样复杂度来到了 $O(n^3)$,但本题数据范围只有 $100$,也是可以过的。\n\n对于此类区间求和问题,我们应当想到使用「前缀和」进行优化:使用 $O(n)$ 的复杂度预处理出前缀和数组,每次查询 $[l, r]$ 区间和可以在 $O(1)$ 返回。\n\n代码:\n```Java\nclass Solution {\n    public int sumOddLengthSubarrays(int[] arr) {\n        int n = arr.length;\n        int[] sum = new int[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + arr[i - 1];\n        int ans = 0;\n        for (int len = 1; len <= n; len += 2) {\n            for (int l = 0; l + len - 1 < n; l++) {\n                int r = l + len - 1;\n                ans += sum[r + 1] - sum[l];\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n)$\n\n----\n\n### 数学\n\n事实上,我们可以统计任意值 $arr[i]$ 在奇数子数组的出现次数。\n\n对于原数组的任意位置 $i$ 而言,其左边共有 $i$ 个数,右边共有 $n - i - 1$ 个数。\n\n**$arr[i]$ 作为某个奇数子数组的成员的充要条件为:其所在奇数子数组左右两边元素个数奇偶性相同。**\n\n于是问题转换为如何求得「$arr[i]$ 在原数组中两边连续一段元素个为奇数的方案数」和「$arr[i]$ 在原数组两边连续一段元素个数为偶数的方案数」。\n\n由于我们已经知道 $arr[i]$ 左边共有 $i$ 个数,右边共有 $n - i - 1$ 个数,因此可以算得组合数:\n\n* 位置 $i$ 左边奇数个数的方案数为 $(i + 1) / 2$,右边奇数个数的方案数为 $(n - i) / 2$;\n* 位置 $i$ 左边偶数(非零)个数的方案数为 $i / 2$,右边偶数(非零)个数的方案数为 $(n - i - 1) / 2$;\n    * 考虑左右两边不选也属于合法的偶数个数方案数,因此在上述分析基础上对偶数方案数自增 $1$。\n\n至此,我们得到了位置 $i$ 左右奇数和偶数的方案数个数,根据「如果 $arr[i]$ 位于奇数子数组中,其左右两边元素个数奇偶性相同」以及「乘法原理」,我们知道 $arr[i]$ 同出现在多少个奇数子数组中,再乘上 $arr[i]$ 即是 $arr[i]$ 对答案的贡献。\n\n代码:\n```Java\nclass Solution {\n    public int sumOddLengthSubarrays(int[] arr) {\n        int n = arr.length;\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            int l1 = (i + 1) / 2, r1 = (n - i) / 2; // 奇数\n            int l2 = i / 2, r2 = (n - i - 1) / 2; // 偶数\n            l2++; r2++;\n            ans += (l1 * r1 + l2 * r2) * arr[i];\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1588` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1591-1600/1592. 重新排列单词间的空格（简单）.md", "url_title": "1592. 重新排列单词间的空格", "url": "https://leetcode.cn/problems/rearrange-spaces-between-words/solution/by-ac_oier-0f5h/", "difficulty": "简单", "tags": ["模拟", "双指针"], "question": "给你一个字符串 `text`,该字符串由若干被空格包围的单词组成。每个单词由一个或者多个小写英文字母组成,并且两个单词之间至少存在一个空格。题目测试用例保证 `text` 至少包含一个单词 。\n\n请你重新排列空格,使每对相邻单词之间的空格数目都 相等 ,并尽可能 最大化 该数目。如果不能重新平均分配所有空格,请 将多余的空格放置在字符串末尾 ,这也意味着返回的字符串应当与原 `text` 字符串的长度相等。\n\n返回 重新排列空格后的字符串 。\n\n示例 1:\n```\n输入:text = \"  this   is  a sentence \"\n\n输出:\"this   is   a   sentence\"\n\n解释:总共有 9 个空格和 4 个单词。可以将 9 个空格平均分配到相邻单词之间,相邻单词间空格数为:9 / (4-1) = 3 个。\n```\n示例 2:\n```\n输入:text = \" practice   makes   perfect\"\n\n输出:\"practice   makes   perfect \"\n\n解释:总共有 7 个空格和 3 个单词。7 / (3-1) = 3 个空格加上 1 个多余的空格。多余的空格需要放在字符串的末尾。\n```\n示例 3:\n```\n输入:text = \"hello   world\"\n\n输出:\"hello   world\"\n```\n示例 4:\n```\n输入:text = \"  walks  udp package   into  bar a\"\n\n输出:\"walks  udp  package  into  bar  a \"\n```\n示例 5:\n```\n输入:text = \"a\"\n\n输出:\"a\"\n```\n\n提示:\n* $1 <= text.length <= 100$\n* `text` 由小写英文字母和 `' '` 组成\n* `text` 中至少包含一个单词", "solution": "### 模拟\n\n根据题意模拟即可:使用「双指针」统计空格数量和分割出所有单词。\n\nJava 代码:\n```Java\nclass Solution {\n    public String reorderSpaces(String s) {\n        int n = s.length(), cnt = 0;\n        List<String> list = new ArrayList<>();\n        for (int i = 0; i < n; ) {\n            if (s.charAt(i) == ' ' && ++i >= 0 && ++cnt >= 0) continue;\n            int j = i;\n            while (j < n && s.charAt(j) != ' ') j++;\n            list.add(s.substring(i, j));\n            i = j;\n        }\n        StringBuilder sb = new StringBuilder();\n        int m = list.size(), t = cnt / Math.max(m - 1, 1);\n        String k = \"\";\n        while (t-- > 0) k += \" \";\n        for (int i = 0; i < m; i++) {\n            sb.append(list.get(i));\n            if (i != m - 1) sb.append(k);\n        }\n        while (sb.length() != n) sb.append(\" \");\n        return sb.toString();\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction reorderSpaces(s: string): string {\n    let n = s.length, cnt = 0\n    const list = new Array<string>()\n    for (let i = 0; i < n; ) {\n        if (s[i] == ' ' && ++i >= 0 && ++cnt >= 0) continue\n        let j = i + 1\n        while (j < n && s[j] != ' ') j++\n        list.push(s.substring(i, j))\n        i = j\n    }\n    let ans = '', k = ''\n    let m = list.length, t = Math.floor(cnt / Math.max(m - 1, 1))\n    while (t-- > 0) k += ' '\n    for (let i = 0; i < m; i++) {\n        ans += list[i]\n        if (i != m - 1) ans += k\n    }\n    while (ans.length != n) ans += ' '\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1592` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1591-1600/1598. 文件夹操作日志搜集器（简单）.md", "url_title": "1598. 文件夹操作日志搜集器", "url": "https://leetcode.cn/problems/crawler-log-folder/solution/by-ac_oier-24xb/", "difficulty": "简单", "tags": ["模拟", "计数", "栈"], "question": "每当用户执行变更文件夹操作时,LeetCode 文件系统都会保存一条日志记录。\n\n下面给出对变更操作的说明:\n\n* `\"../\"` :移动到当前文件夹的父文件夹。如果已经在主文件夹下,则 继续停留在当前文件夹 。\n* `\"./\"` :继续停留在当前文件夹。\n* `\"x/\"` :移动到名为 `x` 的子文件夹中。题目数据 保证总是存在文件夹 x 。\n\n给你一个字符串列表 `logs` ,其中 `logs[i]` 是用户在 `ith` 步执行的操作。\n\n文件系统启动时位于主文件夹,然后执行 `logs` 中的操作。\n\n执行完所有变更文件夹操作后,请你找出 返回主文件夹所需的最小步数 。\n\n示例 1:\n\n```\n输入:logs = [\"d1/\",\"d2/\",\"../\",\"d21/\",\"./\"]\n\n输出:2\n\n解释:执行 \"../\" 操作变更文件夹 2 次,即可回到主文件夹\n```\n示例 2:\n\n```\n输入:logs = [\"d1/\",\"d2/\",\"./\",\"d3/\",\"../\",\"d31/\"]\n\n输出:3\n```\n示例 3:\n```\n输入:logs = [\"d1/\",\"../\",\"../\",\"../\"]\n\n输出:0\n```\n\n提示:\n* $1 <= logs.length <= 10^3$\n* $2 <= logs[i].length <= 10$\n* `logs[i]` 包含小写英文字母,数字,`'.'` 和 `'/'`\n* `logs[i]` 符合语句中描述的格式\n* 文件夹名称由小写英文字母和数字组成", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public int minOperations(String[] logs) {\n        int depth = 0;\n        for (String s : logs) {\n            if (s.equals(\"../\")) depth = Math.max(0, depth - 1);\n            else if (!s.equals(\"./\")) depth++;\n        }\n        return depth;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction minOperations(logs: string[]): number {\n    let depth = 0\n    for (const s of logs) {\n        if (s == \"../\") depth = Math.max(0, depth - 1)\n        else if (s != \"./\") depth++\n    }\n    return depth\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1598` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1591-1600/1600. 皇位继承顺序（中等）.md", "url_title": "1600. 皇位继承顺序", "url": "https://leetcode-cn.com/problems/throne-inheritance/solution/gong-shui-san-xie-shi-yong-dan-xiang-lia-7t65/", "difficulty": "中等", "tags": ["单链表", "哈希表"], "question": "一个王国里住着国王、他的孩子们、他的孙子们等等。每一个时间点,这个家庭里有人出生也有人死亡。\n\n这个王国有一个明确规定的皇位继承顺序,第一继承人总是国王自己。我们定义递归函数 Successor(x, curOrder) ,给定一个人 x 和当前的继承顺序,该函数返回 x 的下一继承人。\n```\nSuccessor(x, curOrder):\n    如果 x 没有孩子或者所有 x 的孩子都在 curOrder 中:\n        如果 x 是国王,那么返回 null\n        否则,返回 Successor(x 的父亲, curOrder)\n    否则,返回 x 不在 curOrder 中最年长的孩子\n```\n比方说,假设王国由国王,他的孩子 Alice 和 Bob (Alice 比 Bob 年长)和 Alice 的孩子 Jack 组成。\n\n1. 一开始, curOrder 为 [\"king\"].\n2. 调用 Successor(king, curOrder) ,返回 Alice ,所以我们将 Alice 放入 curOrder 中,得到 [\"king\", \"Alice\"] 。\n3. 调用 Successor(Alice, curOrder) ,返回 Jack ,所以我们将 Jack 放入 curOrder 中,得到 [\"king\", \"Alice\", \"Jack\"] 。\n4. 调用 Successor(Jack, curOrder) ,返回 Bob ,所以我们将 Bob 放入 curOrder 中,得到 [\"king\", \"Alice\", \"Jack\", \"Bob\"] 。\n5. 调用 Successor(Bob, curOrder) ,返回 null 。最终得到继承顺序为 [\"king\", \"Alice\", \"Jack\", \"Bob\"] 。\n通过以上的函数,我们总是能得到一个唯一的继承顺序。\n\n请你实现 ThroneInheritance 类:\n\n* ThroneInheritance(string kingName) 初始化一个 ThroneInheritance 类的对象。国王的名字作为构造函数的参数传入。\n* void birth(string parentName, string childName) 表示 parentName 新拥有了一个名为 childName 的孩子。\n* void death(string name) 表示名为 name 的人死亡。一个人的死亡不会影响 Successor 函数,也不会影响当前的继承顺序。你可以只将这个人标记为死亡状态。\n* string[] getInheritanceOrder() 返回 除去 死亡人员的当前继承顺序列表。\n\n示例:\n```\n输入:\n[\"ThroneInheritance\", \"birth\", \"birth\", \"birth\", \"birth\", \"birth\", \"birth\", \"getInheritanceOrder\", \"death\", \"getInheritanceOrder\"]\n[[\"king\"], [\"king\", \"andy\"], [\"king\", \"bob\"], [\"king\", \"catherine\"], [\"andy\", \"matthew\"], [\"bob\", \"alex\"], [\"bob\", \"asha\"], [null], [\"bob\"], [null]]\n\n输出:\n[null, null, null, null, null, null, null, [\"king\", \"andy\", \"matthew\", \"bob\", \"alex\", \"asha\", \"catherine\"], null, [\"king\", \"andy\", \"matthew\", \"alex\", \"asha\", \"catherine\"]]\n\n解释:\nThroneInheritance t= new ThroneInheritance(\"king\"); // 继承顺序:king\nt.birth(\"king\", \"andy\"); // 继承顺序:king > andy\nt.birth(\"king\", \"bob\"); // 继承顺序:king > andy > bob\nt.birth(\"king\", \"catherine\"); // 继承顺序:king > andy > bob > catherine\nt.birth(\"andy\", \"matthew\"); // 继承顺序:king > andy > matthew > bob > catherine\nt.birth(\"bob\", \"alex\"); // 继承顺序:king > andy > matthew > bob > alex > catherine\nt.birth(\"bob\", \"asha\"); // 继承顺序:king > andy > matthew > bob > alex > asha > catherine\nt.getInheritanceOrder(); // 返回 [\"king\", \"andy\", \"matthew\", \"bob\", \"alex\", \"asha\", \"catherine\"]\nt.death(\"bob\"); // 继承顺序:king > andy > matthew > bob(已经去世)> alex > asha > catherine\nt.getInheritanceOrder(); // 返回 [\"king\", \"andy\", \"matthew\", \"alex\", \"asha\", \"catherine\"]\n```\n\n提示:\n* 1 <= kingName.length, parentName.length, childName.length, name.length <= 15\n* kingName,parentName, childName 和 name 仅包含小写英文字母。\n* 所有的参数 childName 和 kingName 互不相同。\n* 所有 death 函数中的死亡名字 name 要么是国王,要么是已经出生了的人员名字。\n* 每次调用 birth(parentName, childName) 时,测试用例都保证 parentName 对应的人员是活着的。\n* 最多调用 $10^5$ 次birth 和 death 。\n* 最多调用 10 次 getInheritanceOrder 。", "solution": "### 单向链表 & 标记删除\n\n根据题意,我们需要将「新儿子」插入到「父亲」的「最后一个儿子」的「儿子们」的后面(**注意这是个递归过程**);如果该「父亲」还没有任何儿子,则直接插到「父亲」后面。\n\n因此,我们需要在节点 `Node` 中使用一个 `last` 记录该节点的「最后一个儿子」,同时因为删除的时候,我们无法在 $O(1)$ 的复杂度内更新 `last` 信息,所以只能使用「标记删除」的方式。\n\n代码:\n```Java\nclass ThroneInheritance {\n    class Node {\n        String name;\n        Node next;\n        Node last; // 记录最后一个儿子\n        boolean isDeleted = false;\n        Node (String _name) {\n            name = _name;\n        }\n    }\n    Map<String, Node> map = new HashMap<>();\n    Node head = new Node(\"\"), tail = new Node(\"\");\n    public ThroneInheritance(String name) {\n        Node root = new Node(name);\n        root.next = tail;\n        head.next = root;\n        map.put(name, root);\n    }\n    \n    public void birth(String pname, String cname) {\n        Node node = new Node(cname);\n        map.put(cname, node);\n        Node p = map.get(pname);\n        Node tmp = p;\n        while (tmp.last != null) tmp = tmp.last;\n        node.next = tmp.next;\n        tmp.next = node;\n        p.last = node;\n    }\n    \n    public void death(String name) {\n        Node node = map.get(name);\n        node.isDeleted = true;\n    }\n    \n    public List<String> getInheritanceOrder() {\n        List<String> ans = new ArrayList<>();\n        Node tmp = head.next;\n        while (tmp.next != null) {\n            if (!tmp.isDeleted) ans.add(tmp.name);\n            tmp = tmp.next;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:`birth` 和 `getInheritanceOrder` 操作为 $O(n)$;其余操作为 $O(1)$\n* 时间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1600` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1601-1610/1601. 最多可达成的换楼请求数目（困难）.md", "url_title": "1601. 最多可达成的换楼请求数目", "url": "https://leetcode-cn.com/problems/maximum-number-of-achievable-transfer-requests/solution/gong-shui-san-xie-er-jin-zhi-mei-ju-by-a-enef/", "difficulty": "困难", "tags": ["二进制枚举"], "question": "我们有 `n` 栋楼,编号从 `0` 到 `n - 1` 。每栋楼有若干员工。由于现在是换楼的季节,部分员工想要换一栋楼居住。\n\n给你一个数组 $requests$ ,其中 $requests[i] = [from_i, to_i]$ ,表示一个员工请求从编号为 $from_i$ 的楼搬到编号为 $to_i$ 的楼。\n\n一开始 所有楼都是满的,所以从请求列表中选出的若干个请求是可行的需要满足 每栋楼员工净变化为 $0$ 。意思是每栋楼 离开 的员工数目 等于 该楼 搬入 的员工数数目。比方说 $n = 3$ 且两个员工要离开楼 $0$ ,一个员工要离开楼 $1$ ,一个员工要离开楼 $2$ ,如果该请求列表可行,应该要有两个员工搬入楼 $0$ ,一个员工搬入楼 $1$ ,一个员工搬入楼 $2$ 。\n\n请你从原请求列表中选出若干个请求,使得它们是一个可行的请求列表,并返回所有可行列表中最大请求数目。\n\n示例 1:\n\n```\n输入:n = 5, requests = [[0,1],[1,0],[0,1],[1,2],[2,0],[3,4]]\n\n输出:5\n解释:请求列表如下:\n从楼 0 离开的员工为 x 和 y ,且他们都想要搬到楼 1 。\n从楼 1 离开的员工为 a 和 b ,且他们分别想要搬到楼 2 和 0 。\n从楼 2 离开的员工为 z ,且他想要搬到楼 0 。\n从楼 3 离开的员工为 c ,且他想要搬到楼 4 。\n没有员工从楼 4 离开。\n我们可以让 x 和 b 交换他们的楼,以满足他们的请求。\n我们可以让 y,a 和 z 三人在三栋楼间交换位置,满足他们的要求。\n所以最多可以满足 5 个请求。\n```\n示例 2:\n\n```\n输入:n = 3, requests = [[0,0],[1,2],[2,1]]\n\n输出:3\n\n解释:请求列表如下:\n从楼 0 离开的员工为 x ,且他想要回到原来的楼 0 。\n从楼 1 离开的员工为 y ,且他想要搬到楼 2 。\n从楼 2 离开的员工为 z ,且他想要搬到楼 1 。\n我们可以满足所有的请求。\n```\n示例 3:\n```\n输入:n = 4, requests = [[0,3],[3,1],[1,2],[2,0]]\n\n输出:4\n```\n\n提示:\n* $1 <= n <= 20$\n* $1 <= requests.length <= 16$\n* $requests[i].length == 2$\n* $0 <= fromi, toi < n$", "solution": "### 二进制枚举\n\n为了方便,我们令 $requests$ 的长度为 $m$。\n\n数据范围很小,$n$ 的范围为 $20$,而 $m$ 的范围为 $16$。\n\n根据每个 $requests[i]$ 是否选择与否,共有 $2^m$ 种状态(不超过 $70000$ 种状态)。我们可以采用「二进制枚举」的思路来求解,使用二进制数 $state$ 来表示对 $requests[i]$ 的选择情况,当 $state$ 的第 $k$ 位为 $1$,代表 $requests[k]$ 被选择。\n\n我们枚举所有的 $state$ 并进行合法性检查,从中选择出包含请求数的最多(二进制表示中包含 $1$ 个数最多)的合法 $state$,其包含的请求数量即是答案。\n\n其中统计 $state$ 中 $1$ 的个数可以使用 `lowbit`,复杂度为 $O(m)$,判断合法性则直接模拟即可(统计每座建筑的进出数量,最后判定进出数不相等的建筑数量是为 $0$),复杂度为 $O(m)$,整体计算量为不超过 $2 \\times  10^6$,可以过。\n\n代码:\n```Java\nclass Solution {\n    int[][] rs;\n    public int maximumRequests(int n, int[][] requests) {\n        rs = requests;\n        int m = rs.length, ans = 0;\n        for (int i = 0; i < (1 << m); i++) {\n            int cnt = getCnt(i);\n            if (cnt <= ans) continue;\n            if (check(i)) ans = cnt;\n        }\n        return ans;\n    }\n    boolean check(int s) {\n        int[] cnt = new int[20];\n        int sum = 0;\n        for (int i = 0; i < 16; i++) {\n            if (((s >> i) & 1) == 1) {\n                int a = rs[i][0], b = rs[i][1];\n                if (++cnt[a] == 1) sum++;\n                if (--cnt[b] == 0) sum--;\n            }\n        }\n        return sum == 0;\n    }\n    int getCnt(int s) {\n        int ans = 0;\n        for (int i = s; i > 0; i -= (i & -i)) ans++;\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $m$ 为 $requests$ 长度,共有 $2^m$ 种选择状态,计算每个状态的所包含的问题数量复杂度为 $O(m)$,计算某个状态是否合法复杂度为 $O(m)$;整体复杂度为 $O(2^m \\times m)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1601` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1601-1610/1603. 设计停车系统（简单）.md", "url_title": "1603. 设计停车系统", "url": "https://leetcode-cn.com/problems/design-parking-system/solution/yi-ti-san-jie-jian-dan-bian-liang-ha-xi-0gs72/", "difficulty": "简单", "tags": ["位运算", "哈希表"], "question": "请你给一个停车场设计一个停车系统。停车场总共有三种不同大小的车位:大,中和小,每种尺寸分别有固定数目的车位。\n\n请你实现 ParkingSystem 类:\n\n* ParkingSystem(int big, int medium, int small) 初始化 ParkingSystem 类,三个参数分别对应每种停车位的数目。\n* bool addCar(int carType) 检查是否有 carType 对应的停车位。 carType 有三种类型:大,中,小,分别用数字 1, 2 和 3 表示。一辆车只能停在  carType 对应尺寸的停车位中。如果没有空车位,请返回 false ,否则将该车停入车位并返回 true 。\n\n示例 1:\n```\n输入:\n[\"ParkingSystem\", \"addCar\", \"addCar\", \"addCar\", \"addCar\"]\n[[1, 1, 0], [1], [2], [3], [1]]\n输出:\n[null, true, true, false, false]\n\n解释:\nParkingSystem parkingSystem = new ParkingSystem(1, 1, 0);\nparkingSystem.addCar(1); // 返回 true ,因为有 1 个空的大车位\nparkingSystem.addCar(2); // 返回 true ,因为有 1 个空的中车位\nparkingSystem.addCar(3); // 返回 false ,因为没有空的小车位\nparkingSystem.addCar(1); // 返回 false ,因为没有空的大车位,唯一一个大车位已经被占据了\n```\n\n提示:\n* 0 <= big, medium, small <= 1000\n* carType 取值为 1, 2 或 3\n* 最多会调用 addCar 函数 1000 次", "solution": "### 简单变量\n\n一个简单的做法是,直接使用几个成员变量来记录。\n\n```Java\nclass ParkingSystem {\n    int big, medium, small;\n    public ParkingSystem(int _big, int _medium, int _small) {\n        big = _big; \n        medium = _medium; \n        small = _small;\n    }\n    \n    public boolean addCar(int ct) {\n        if (ct == 1 && big > 0) return big-- > 0;\n        else if (ct == 2 && medium > 0) return medium-- > 0;\n        else if (ct == 3 && small > 0) return small-- > 0;\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$\n\n***\n\n### 哈希表\n\n另外一个更好拓展的方法,使用哈希表来进行记录。\n\n这样做的好处是,当增加车类型,只需要重载一个构造方法即可。\n\n```Java\nclass ParkingSystem {\n    Map<Integer, Integer> map = new HashMap<>();\n    public ParkingSystem(int _big, int _medium, int _small) {\n        map.put(1, _big);\n        map.put(2, _medium);\n        map.put(3, _small);\n    }\n    \n    public boolean addCar(int ct) {\n        if (map.get(ct) > 0) {\n            map.put(ct, map.get(ct) - 1);\n            return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$\n\n***\n\n### 二进制分段\n\n事实上,由于 $1000$ 的二进制表示只有 $10$ 位,而 $int$ 有 $32$ 位。\n\n我们可以使用一个 $int$ 配合「位运算」来分段做。\n\n使用 $[0,10)$ 代表 big,$[10,20)$ 表示 medium,$[20,30)$ 表示 small\n\n*PS. 这样 $int$ 分段的做法,在工程源码上也有体现:`JDK` 中的 `ThreadPoolExecutor` 使用了一个 $ctl$ 变量 ($int$ 类型) 的前 $3$ 位记录线程池的状态,后 $29$ 位记录程池中线程个数。*\n\n**这样的「二进制分段压缩存储」的主要目的,不是为了减少使用一个 $int$,而是为了让「非原子性操作」变为「原子性操作」。**\n\n我们可以分析下为什么 `ThreadPoolExecutor` 要这么做。\n\n当线程数量变化为某个特定值时,要修改的就不仅仅是「线程数量」,还需要修改「线程池的状态」。\n\n由于并发环境下,如果要做到「原子性」地同时需要修改两个 $int$ 的话。只能上「重量级锁」,「重量级锁」就会涉及到「内核态」的系统调用,通常是耗时是「用户态」的上百倍。\n\n但是如果我们将「线程数量」和「线程池的状态」合二为一之后,我们只需要修改一个 $int$,这时候只需要使用 CAS 做法(用户态)即可保证线程安全与原子性。\n\n那么对应到该题,如果我们允许同时停入不同类型的车,在不引入重量级锁的前提下,想要真正做到「同时」修改两种类型的车的车位的话,只能采用这样的「二进制分段」做法 ~ \n\n```Java\nclass ParkingSystem {\n    int cnt; // [small medium big]\n    public ParkingSystem(int _big, int _medium, int _small) {\n        for (int i = 0; i < 30; i++) {\n            int cur = 0;\n            if (i < 10) {\n                cur = (_big >> i) & 1;\n            } else if (i < 20) {\n                cur = (_medium >> (i - 10)) & 1;\n            } else if (i < 30) {\n                cur = (_small >> (i - 20)) & 1;\n            }\n            cnt += cur == 1 ? (1 << i) : 0;\n        }\n    }\n\n    public boolean addCar(int ct) {\n        int cur = countOfType(ct);\n        if (cur > 0) {\n            setCount(ct, cur - 1);\n            return true;\n        }\n        return false;\n    }\n\n    int countOfType(int ct) {\n        int ans = 0;\n        int start = --ct * 10, end = start + 10;\n        for (int i = start; i < end; i++) {\n            if (((cnt >> i) & 1) == 1) {\n                ans += (1 << (i - start));\n            }\n        }\n        return ans;\n    }\n\n    void setCount(int ct, int pc) {\n        int start = --ct * 10, end = start + 10;\n        for (int i = start; i < end; i++) {\n            if (((pc >> (i - start)) & 1) == 1) {\n                cnt |= (1 << i);\n            } else {\n                cnt &= ~(1 << i);\n            }\n        }\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1603` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1601-1610/1606. 找到处理最多请求的服务器（困难）.md", "url_title": "1606. 找到处理最多请求的服务器", "url": "https://leetcode-cn.com/problems/find-servers-that-handled-most-number-of-requests/solution/by-ac_oier-zgm6/", "difficulty": "困难", "tags": ["数据结构", "优先队列(堆)", "红黑树", "二分"], "question": "你有 $k$ 个服务器,编号为 $0$ 到 $k-1$ ,它们可以同时处理多个请求组。\n\n每个服务器有无穷的计算能力但是不能同时处理超过一个请求。\n\n请求分配到服务器的规则如下:\n* 第 $i$(序号从 $0$ 开始)个请求到达。\n* 如果所有服务器都已被占据,那么该请求被舍弃(完全不处理)。\n* 如果第 ( `i % k` ) 个服务器空闲,那么对应服务器会处理该请求。\n* 否则,将请求安排给下一个空闲的服务器(服务器构成一个环,必要的话可能从第 $0$ 个服务器开始继续找下一个空闲的服务器)。比方说,如果第 $i$ 个服务器在忙,那么会查看第 ( $i+1$ ) 个服务器,第 ( $i+2$ ) 个服务器等等。\n* 给你一个严格递增的正整数数组 `arrival`,表示第 $i$ 个任务的到达时间,和另一个数组 `load` ,其中 $load[i]$ 表示第 $i$ 个请求的工作量(也就是服务器完成它所需要的时间)。你的任务是找到 最繁忙的服务器 。最繁忙定义为一个服务器处理的请求数是所有服务器里最多的。\n\n请你返回包含所有最繁忙服务器序号的列表,你可以以任意顺序返回这个列表。\n\n示例 1:\n\n```\n输入:k = 3, arrival = [1,2,3,4,5], load = [5,2,3,3,3] \n\n输出:[1] \n\n解释:\n所有服务器一开始都是空闲的。\n前 3 个请求分别由前 3 台服务器依次处理。\n请求 3 进来的时候,服务器 0 被占据,所以它呗安排到下一台空闲的服务器,也就是服务器 1 。\n请求 4 进来的时候,由于所有服务器都被占据,该请求被舍弃。\n服务器 0 和 2 分别都处理了一个请求,服务器 1 处理了两个请求。所以服务器 1 是最忙的服务器。\n```\n示例 2:\n```\n输入:k = 3, arrival = [1,2,3,4], load = [1,2,1,2]\n\n输出:[0]\n\n解释:\n前 3 个请求分别被前 3 个服务器处理。\n请求 3 进来,由于服务器 0 空闲,它被服务器 0 处理。\n服务器 0 处理了两个请求,服务器 1 和 2 分别处理了一个请求。所以服务器 0 是最忙的服务器。\n```\n示例 3:\n```\n输入:k = 3, arrival = [1,2,3], load = [10,12,11]\n\n输出:[0,1,2]\n\n解释:每个服务器分别处理了一个请求,所以它们都是最忙的服务器。\n```\n示例 4:\n```\n输入:k = 3, arrival = [1,2,3,4,8,9,10], load = [5,2,10,3,1,2,2]\n\n输出:[1]\n```\n示例 5:\n```\n输入:k = 1, arrival = [1], load = [1]\n\n输出:[0]\n```\n\n提示:\n* $1 <= k <= 10^5$\n* $1 <= arrival.length, load.length <= 10^5$\n* $arrival.length == load.length$\n* $1 <= arrival[i], load[i] <= 10^9$\n* `arrival` 保证严格递增。", "solution": "### 数据结构\n\n题目要统计处理任务数最多的机器,首先容易想到使用「哈希表」统计每个机台处理的任务数,利用机台数量 $k$ 最多不超过 $10^5$,我们可以开一个静态数组 `cnts` 来充当哈希表,同时维护一个当前处理的最大任务数量 `max`,最终所有满足 $cnst[i] = \\max$ 的机台集合即是答案。\n\n再根据「每个任务有对应的开始时间和持续时间」以及「任务分配规则」,容易想到使用优先队列(堆)和有序集合(红黑树)来进行维护。\n\n具体的,利用「每个任务有对应的开始时间和持续时间」,我们使用优先队列(堆)维护二元组 $(idx, endTime)$,其中 $idx$ 为机器编号,$endTime$ 为当前机台所处理任务的结束时间(也就是该机台最早能够接受新任务的时刻),对于每个 $arrival[i]$ 而言(新任务),我们先从优先队列中取出所有 $endTime \\leqslant arrival[i]$ 的机台 $idx$,加入「空闲池」,然后再按照「任务分配规则」从空闲池子中取机台,若取不到,则丢弃该任务。\n\n由于「任务分配规则」是优先取大于等于 `i % k` 的最小值,若取不到,再取大于等于 $0$ 的最小值。因此我们的「空闲池」最好是支持「二分」的有序集合,容易想到基于「红黑树」的 `TreeSet` 结构。\n\nJava 代码:\n```Java\nclass Solution {\n    static int N = 100010;\n    static int[] cnts = new int[N];\n    public List<Integer> busiestServers(int k, int[] arrival, int[] load) {\n        Arrays.fill(cnts, 0);\n        int n = arrival.length, max = 0;\n        PriorityQueue<int[]> busy = new PriorityQueue<>((a,b)->a[1]-b[1]);\n        TreeSet<Integer> free = new TreeSet<>();\n        for (int i = 0; i < k; i++) free.add(i);\n        for (int i = 0; i < n; i++) {\n            int start = arrival[i], end = start + load[i];\n            while (!busy.isEmpty() && busy.peek()[1] <= start) free.add(busy.poll()[0]);\n            Integer u = free.ceiling(i % k);\n            if (u == null) u = free.ceiling(0);\n            if (u == null) continue;\n            free.remove(u);\n            busy.add(new int[]{u, end});\n            max = Math.max(max, ++cnts[u]);\n        }\n        List<Integer> ans = new ArrayList<>();\n        for (int i = 0; i < k; i++) {\n            if (cnts[i] == max) ans.add(i);\n        }\n        return ans;\n    }\n}\n```\nPython 代码:\n```Python\nfrom sortedcontainers import SortedList\n\nclass Solution:\n    def busiestServers(self, k: int, arrival: List[int], load: List[int]) -> List[int]:\n        cnts = [0] * k\n        n, m = len(arrival), 0\n        busy, free = [], SortedList(range(k))\n        for i in range(n):\n            start, end = arrival[i], arrival[i] + load[i]\n            while busy and busy[0][0] <= start:\n                free.add(busy[0][1])\n                heappop(busy)\n            if (idx := free.bisect_left(i % k)) == len(free) == (idx := free.bisect_left(0)):\n                continue\n            u = free[idx]\n            free.remove(u)\n            heappush(busy, (end, u))\n            cnts[u] += 1\n            m = max(m, cnts[u])\n        return [i for i in range(k) if cnts[i] == m]\n```\n* 时间复杂度:令任务数量为 $n$,机台数量为 $k$,起始将所有机台存入 `TreeSet`,复杂度为 $O(k\\log{k})$;每次处理新的 $arrival[i]$ 时,先从优先队列取出可接受新任务的机台,存入 `TreeSet`,然后从 `TreeSet` 中取出最多一个的机台来完成任务,其中从 `TreeSet` 中取出机台最多调用两次的 `ceiling` 操作,复杂度为 $O(\\log{k})$,这部分的整体复杂度为 $O(n\\log{k})$;统计处理任务数达到 `max` 的机台集合复杂度为 $O(k)$;整体复杂度为 $O((k + n)\\log{k})$\n* 空间复杂度:$O(k)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1606` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1601-1610/1608. 特殊数组的特征值（简单）.md", "url_title": "1608. 特殊数组的特征值", "url": "https://leetcode.cn/problems/special-array-with-x-elements-greater-than-or-equal-x/solution/by-ac_oier-z525/", "difficulty": "简单", "tags": ["排序", "二分", "枚举", "模拟", "计数"], "question": "给你一个非负整数数组 `nums`。如果存在一个数 `x` ,使得 `nums` 中恰好有 `x` 个元素 大于或者等于 `x` ,那么就称 `nums` 是一个 特殊数组 ,而 `x` 是该数组的 特征值 。\n\n注意: `x` 不必 是 `nums` 的中的元素。\n\n如果数组 `nums` 是一个 特殊数组 ,请返回它的特征值 `x` 。否则,返回 `-1` 。可以证明的是,如果 `nums` 是特殊数组,那么其特征值 `x` 是 唯一的 。\n\n示例 1:\n```\n输入:nums = [3,5]\n\n输出:2\n\n解释:有 2 个元素(3 和 5)大于或等于 2 。\n```\n示例 2:\n```\n输入:nums = [0,0]\n\n输出:-1\n\n解释:没有满足题目要求的特殊数组,故而也不存在特征值 x 。\n如果 x = 0,应该有 0 个元素 >= x,但实际有 2 个。\n如果 x = 1,应该有 1 个元素 >= x,但实际有 0 个。\n如果 x = 2,应该有 2 个元素 >= x,但实际有 0 个。\nx 不能取更大的值,因为 nums 中只有两个元素。\n```\n示例 3:\n```\n输入:nums = [0,4,3,0,4]\n\n输出:3\n\n解释:有 3 个元素大于或等于 3 。\n```\n示例 4:\n```\n输入:nums = [3,6,7,7,0]\n\n输出:-1\n```\n\n提示:\n* $1 <= nums.length <= 100$\n* $0 <= nums[i] <= 1000$", "solution": "### 排序 + 枚举 + 二分\n\n根据题意并结合 $nums[i]$ 的数据范围为 $1e3$,我们可以通过「枚举」的方式找到 `x`,而对于每个 `x` 的合法性检查,我们需要快速知道 `nums` 中比 `x` 大的数的个数,这可以通过「排序 + 二分」来做。\n\nJava 代码:\n```Java\nclass Solution {\n    public int specialArray(int[] nums) {\n        Arrays.sort(nums);\n        int n = nums.length;\n        for (int x = 0; x < 1010; x++) {\n            int l = 0, r = n - 1;\n            while (l < r) {\n                int mid = l + r >> 1;\n                if (nums[mid] >= x) r = mid;\n                else l = mid + 1;\n            }\n            if (nums[r] >= x && x == n - r) return x;\n        }\n        return -1;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction specialArray(nums: number[]): number {\n    const n = nums.length\n    nums.sort((a,b)=>a-b)\n    for (let x = 0; x < 1010; x++) {\n        let l = 0, r = n - 1\n        while (l < r) {\n            const mid = l + r >> 1\n            if (nums[mid] >= x) r = mid\n            else l = mid + 1\n        }\n        if (nums[r] >= x && x == n - r) return x\n    }\n    return -1\n};\n```\n* 时间复杂度:排序的复杂度为 $O(n\\log{n})$;枚举找 `x` 的复杂度为 $O(C\\log{n})$,其中 $C = 1e3$ 为 $nums[i]$ 的值域大小\n* 空间复杂度:$O(\\log{n})$\n\n---\n\n### 排序 + 二分 \n\n若不利用 $nums[i]$ 的值域偏小(即值域放大到 $1e9$),我们可以通过「排序 + 两次二分」的操作来做:第一次二分找分割点 `x`(二分范围为 $[0, 1e9]$);第二次则是在 `getCnt` 函数内部中使用二分来对 `x` 进行合法性检查。\n\n我们知道若真实的特殊值为 `x`,那么在以 `x` 为分割点的数轴上具有「二段性」,假设当前值为 `k`:\n* 小于真实特殊值 `x` 的 `k` 值满足「`nums` 中大于等于 `k` 的元素个数超过 `k` 个」\n* 大于等于真实特殊值 `x` 的 `k` 值满足「`nums` 中大于等于 `k` 的元素个数不超过 `k` 个」\n\n因此可以通过「二分」来找真实特殊值为 `x`,至于 `x` 的合法检查则和解法一相同,先通过排序确保数组有序,再通过二分的方式来统计大于等于 `x` 的数的个数。\n\nJava 代码:\n```Java\nclass Solution {\n    int[] nums;\n    public int specialArray(int[] _nums) {\n        nums = _nums;\n        Arrays.sort(nums);\n        int l = 0, r = (int) 1e9;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (getCnt(mid) <= mid) r = mid;\n            else l = mid + 1;\n        }\n        return getCnt(r) == r ? r : -1;\n    }\n    int getCnt(int x) {\n        int n = nums.length, l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (nums[mid] >= x) r = mid;\n            else l = mid + 1;\n        }\n        return nums[r] >= x ? n - r : 0;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nlet nums: number[]\nfunction specialArray(_nums: number[]): number {\n    nums = _nums\n    nums.sort((a,b)=>a-b)\n    let l = 0, r = 1e9\n    while (l < r) {\n        const mid = l + r >> 1\n        if (getCnt(mid) <= mid) r = mid\n        else l = mid + 1\n    }\n    return getCnt(r) == r ? r : -1\n};\nfunction getCnt(x: number): number {\n    let n = nums.length, l = 0, r = n - 1\n    while (l < r) {\n        const mid = l + r >> 1\n        if (nums[mid] >= x) r = mid\n        else l = mid + 1\n    }\n    return nums[r] >= x ? n - r : 0\n}\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$,二分找答案复杂度为 $O(\\log{C} \\times \\log{n})$\n* 空间复杂度:$O(\\log{n})$\n\n---\n\n### 模拟(计数 + 枚举)\n\n另外一种除非过大缩放 $nums$ 的长度 $n$,否则仅有代码量优势的做法是使用「计数 + 枚举」的模拟做法。\n\n先使用静态数组对 $nums$ 进行词频统计,随后通过逆序枚举的方式找特殊值 `x`,同时使用 `tot` 统计遍历过的桶的总元素个数,当满足 `tot = x` 时,返回结果。\n\nJava 代码:\n```Java\nclass Solution {\n    public int specialArray(int[] nums) {\n        int[] cnts = new int[1010];\n        for (int x : nums) cnts[x]++;\n        for (int i = 1009, tot = 0; i >= 0; i--) {\n            tot += cnts[i];\n            if (i == tot) return i;\n        }\n        return -1;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction specialArray(nums: number[]): number {\n    const cnts = new Array<number>(1010).fill(0)\n    for (let x of nums) cnts[x]++\n    for (let i = 1009, tot = 0; i >= 0; i--) {\n        tot += cnts[i]\n        if (tot == i) return i\n    }\n    return -1\n};\n```\n* 时间复杂度:$O(n + C)$,其中 $C = 1e3$ 为 $nums[i]$ 的值域大小\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1608` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1601-1610/1609. 奇偶树（中等）.md", "url_title": "1609. 奇偶树", "url": "https://leetcode-cn.com/problems/even-odd-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-bfs-d-kuyi/", "difficulty": "中等", "tags": ["层序遍历", "BFS", "DFS"], "question": "如果一棵二叉树满足下述几个条件,则可以称为 **奇偶树** :\n\n二叉树根节点所在层下标为 $0$ ,根的子节点所在层下标为 $1$ ,根的孙节点所在层下标为 $2$ ,依此类推。\n\n* **偶数下标** 层上的所有节点的值都是 **奇** 整数,从左到右按顺序 **严格递增**\n* **奇数下标** 层上的所有节点的值都是 **偶** 整数,从左到右按顺序 **严格递减**\n\n给你二叉树的根节点,如果二叉树为 奇偶树 ,则返回 `true` ,否则返回 `false` 。\n\n示例 1:\n\n```\n输入:root = [1,10,4,3,null,7,9,12,8,6,null,null,2]\n\n输出:true\n\n解释:每一层的节点值分别是:\n0 层:[1]\n1 层:[10,4]\n2 层:[3,7,9]\n3 层:[12,8,6,2]\n由于 0 层和 2 层上的节点值都是奇数且严格递增,而 1 层和 3 层上的节点值都是偶数且严格递减,因此这是一棵奇偶树。\n```\n示例 2:\n\n```\n输入:root = [5,4,2,3,3,7]\n\n输出:false\n\n解释:每一层的节点值分别是:\n0 层:[5]\n1 层:[4,2]\n2 层:[3,3,7]\n2 层上的节点值不满足严格递增的条件,所以这不是一棵奇偶树。\n```\n示例 3:\n\n```\n输入:root = [5,9,1,3,5,7]\n\n输出:false\n\n解释:1 层上的节点值应为偶数。\n```\n示例 4:\n```\n输入:root = [1]\n\n输出:true\n```\n示例 5:\n```\n输入:root = [11,8,6,1,3,9,11,30,20,18,16,12,10,4,2,17]\n\n输出:true\n```\n\n提示:\n* 树中节点数在范围 $[1, 10^5]$ 内\n* $1 <= Node.val <= 10^6$", "solution": "### BFS\n\n考察「层序遍历」,在遍历过程中需要记录层下标,并根据层下标检查进行「节点值的奇偶性」和「是否满足递增/递减」。\n\n额外使用一个布尔变量 `flag` 记录层序是否为偶数(判断节点值的奇偶性),使用 `prev` 记录当前层的上一节点的值(判断是否满足递增/递减)即可,`prev` 起始值可根据数据范围设置为哨兵值。\n\n代码:\n```Java\nclass Solution {\n    public boolean isEvenOddTree(TreeNode root) {\n        Deque<TreeNode> d = new ArrayDeque<>();\n        boolean flag = true;\n        d.addLast(root);\n        while (!d.isEmpty()) {\n            int size = d.size(), prev = flag ? 0 : 0x3f3f3f3f;\n            while (size-- > 0) {\n                TreeNode node = d.pollFirst();\n                int cur = node.val;\n                if (flag && (cur % 2 == 0 || cur <= prev)) return false;\n                if (!flag && (cur % 2 != 0 || cur >= prev)) return false;\n                prev = cur;\n                if (node.left != null) d.addLast(node.left);\n                if (node.right != null) d.addLast(node.right);\n            }\n            flag = !flag;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### DFS\n\n同样的思路,自然也能够使用 `DFS` 进行求解。\n\n由于 `DFS`  是深度优先,因此我们在 `DFS` 过程中除了要记录当前层编号(判断节点值的奇偶性),还要记录每层最后上一次遍历到的节点值为多少(判断是否满足递增/递减)。\n\n代码:\n```Java\nclass Solution {\n    Map<Integer, Integer> map = new HashMap<>();\n    public boolean isEvenOddTree(TreeNode root) {\n        return dfs(root, 0);\n    }\n    boolean dfs(TreeNode root, int idx) {\n        boolean flag = idx % 2 == 0;\n        int prev = map.getOrDefault(idx, flag ? 0 : 0x3f3f3f3f), cur = root.val;\n        if (flag && (cur % 2 == 0 || cur <= prev)) return false;\n        if (!flag && (cur % 2 != 0 || cur >= prev)) return false;\n        map.put(idx, root.val);\n        if (root.left != null && !dfs(root.left, idx + 1)) return false;\n        if (root.right != null && !dfs(root.right, idx + 1)) return false;\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1609` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1601-1610/1610. 可见点的最大数目（困难）.md", "url_title": "1610. 可见点的最大数目", "url": "https://leetcode-cn.com/problems/maximum-number-of-visible-points/solution/gong-shui-san-xie-qiu-ji-jiao-ji-he-ti-b-0bid/", "difficulty": "困难", "tags": ["数学", "几何", "排序", "双指针", "滑动窗口"], "question": "给你一个点数组 `points` 和一个表示角度的整数 `angle` ,你的位置是 `location`,其中 $location = [pos_x, pos_y]$ 且 $points[i] = [x_i, y_i]$ 都表示 `X-Y` 平面上的整数坐标。\n\n最开始,你面向东方进行观测。你 不能 进行移动改变位置,但可以通过 自转 调整观测角度。换句话说,$pos_x$ 和 $pos_y$ 不能改变。你的视野范围的角度用 `angle` 表示, 这决定了你观测任意方向时可以多宽。设 d 为你逆时针自转旋转的度数,那么你的视野就是角度范围 $[d - angle/2, d + angle/2]$ 所指示的那片区域。\n\n对于每个点,如果由该点、你的位置以及从你的位置直接向东的方向形成的角度 位于你的视野中 ,那么你就可以看到它。\n\n同一个坐标上可以有多个点。你所在的位置也可能存在一些点,但不管你的怎么旋转,总是可以看到这些点。同时,点不会阻碍你看到其他点。\n\n返回你能看到的点的最大数目。\n\n示例 1:\n\n```\n输入:points = [[2,1],[2,2],[3,3]], angle = 90, location = [1,1]\n\n输出:3\n\n解释:阴影区域代表你的视野。在你的视野中,所有的点都清晰可见,尽管 [2,2] 和 [3,3]在同一条直线上,你仍然可以看到 [3,3] 。\n```\n示例 2:\n```\n输入:points = [[2,1],[2,2],[3,4],[1,1]], angle = 90, location = [1,1]\n\n输出:4\n\n解释:在你的视野中,所有的点都清晰可见,包括你所在位置的那个点。\n```\n示例 3:\n\n```\n输入:points = [[1,0],[2,1]], angle = 13, location = [1,1]\n\n输出:1\n\n解释:如图所示,你只能看到两点之一。\n```\n\n提示:\n* $1 <= points.length <= 10^5$\n* $points[i].length == 2$\n* $location.length == 2$\n* $0 <= angle < 360$\n* $0 <= posx, posy, xi, yi <= 100$", "solution": "### 数学\n\n这是一道思维难度不大,但细节繁多的题目。\n\n题目要我们旋转出一个角度为 $angle$ 的、可无限延伸的覆盖面,使得该覆盖面所能覆盖 $points$ 中的点最多。\n\n我们所在的位置为 $location = (x,y)$,我们可以将 $(x,y)$ 作为「极点」,求所有 $points[i]$ 的「极角」。\n\n令 $points[i] =(a,b)$,与极点关系 $dx = a - x;dy = b - y$。\n\n求极角的方式有两种:\n\n1. 使用 $atan(\\frac{dy}{dx})$:值域范围为 [-90&deg;,90&deg;],需要对 $dx$ 与 $dy$ 进行象限讨论,从而将值域范围转化为我们希望的 [0&deg;,360&deg;],同时需要注意 $dx = 0$ 的边界情况;\n    \n2. 使用 $atan2(dy, dx)$:值域范围为 [-180&deg;,180&deg;],与我们期望的 [0&deg;,360&deg;] 相差一个固定的值,可进行统一转换,也可以直接使用。\n\n得到夹角数组 $list$ 后,对其进行排序,问题初步转换为:在夹角数组中找到连续一段 $[i, j]$,使得 $list[i]$ 和 $list[j]$ 的角度差不超过 $angle$。\n\n但直接在原数组 $list$ 操作,会漏掉夹角横跨一四象限的情况:\n\n因此,另外一个细节是,在求连续段长度时,先对夹角数组进行拷贝拼接,并对拼接部分增加偏移量(确保数组仍具有单调性)。\n\n具体的,设夹角数组长度为 $n$,此时令 $list[n + i] = list[i] + 2 * PI$,从而将问题彻底转换为求连续段问题。\n\n求解最长合法连续段 $[i,j]$ 可用「双指针」实现「滑动窗口」来做。\n\n一些细节:题目规定了与 $location$ 重合的点在任意角度都能看到,因此我们需要对这些点进行特殊处理,\n\n代码:\n```Java\nclass Solution {\n    public int visiblePoints(List<List<Integer>> points, int angle, List<Integer> location) {\n        int x = location.get(0), y = location.get(1);\n        List<Double> list = new ArrayList<>();\n        int cnt = 0;\n        double pi = Math.PI, t = angle * pi / 180;\n        for (List<Integer> p : points) {\n            int a = p.get(0), b = p.get(1);\n            if (a == x && b == y && ++cnt >= 0) continue;\n            list.add(Math.atan2(b - y, a - x) + pi);\n        }\n        Collections.sort(list);\n        int n = list.size(), max = 0;\n        for (int i = 0; i < n; i++) list.add(list.get(i) + 2 * pi);\n        for (int i = 0, j = 0; j < 2 * n; j++) {\n            while (i < j && list.get(j) - list.get(i) > t) i++;\n            max = Math.max(max, j - i + 1);\n        }\n        return cnt + max;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为 `points` 数组的长度,预处理出 `points` 的所有角度复杂度为 $O(n)$;对所有角度进行排序的复杂度为 $O(n\\log{n})$;使用双指针实现滑动窗口得出最大合法子数组的复杂度为 $O(n)$;整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1610` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/161-170/162. 寻找峰值（中等）.md", "url_title": "162. 寻找峰值", "url": "https://leetcode-cn.com/problems/find-peak-element/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-qva7v/", "difficulty": "中等", "tags": ["二分"], "question": "峰值元素是指其值严格大于左右相邻值的元素。\n\n给你一个整数数组 `nums`,找到峰值元素并返回其索引。数组可能包含多个峰值,在这种情况下,返回 任何一个峰值 所在位置即可。\n\n你可以假设 `nums[-1] = nums[n] = -∞` 。\n\n你必须实现时间复杂度为 $O(\\log{n})$ 的算法来解决此问题。\n\n示例 1:\n```\n输入:nums = [1,2,3,1]\n\n输出:2\n\n解释:3 是峰值元素,你的函数应该返回其索引 2。\n```\n示例 2:\n```\n输入:nums = [1,2,1,3,5,6,4]\n\n输出:1 或 5 \n\n解释:你的函数可以返回索引 1,其峰值元素为 2;\n     或者返回索引 5, 其峰值元素为 6。\n```\n\n提示:\n* $1 <= nums.length <= 1000$\n* $-2^{31} <= nums[i] <= 2^{31} - 1$\n* 对于所有有效的 `i` 都有 `nums[i] != nums[i + 1]`", "solution": "### 模拟\n\n由于数据范围只有 $1000$,使用线性扫描找峰值的模拟做法也是没有问题。\n\n代码:\n```Java\nclass Solution {\n    public int findPeakElement(int[] nums) {\n        int n = nums.length;\n        for (int i = 0; i < n; i++) {\n            boolean ok = true;\n            if (i - 1 >= 0) {\n                if (nums[i - 1] >= nums[i]) ok = false;\n            }\n            if (i + 1 < n) {\n                if (nums[i + 1] >= nums[i]) ok = false;\n            }\n            if (ok) return i;\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 二分\n\n题目让我们实现一个 $O(\\log{n})$ 算法,这是对使用「二分」的强烈暗示。\n\n和往常的题目一样,**我们应当从是否具有「二段性」来考虑是否可以进行「二分」**。\n\n不难发现,**如果** 在确保有解的情况下,我们可以根据当前的分割点 $mid$ 与左右元素的大小关系来指导 $l$ 或者 $r$ 的移动。\n\n假设当前分割点 $mid$ 满足关系 $num[mid] > nums[mid + 1]$ 的话,一个很简单的想法是 $num[mid]$ 可能为峰值,而 $nums[mid + 1]$ 必然不为峰值,于是让 $r = mid$,从左半部分继续找峰值。\n\n估计不少同学靠这个思路 AC 了,只能说做法对了,分析没对。\n\n上述做法正确的前提有两个:\n\n1. 对于任意数组而言,一定存在峰值(一定有解);\n2. 二分不会错过峰值。\n\n我们分别证明一下。\n\n**证明 $1$ :对于任意数组而言,一定存在峰值(一定有解)**\n\n根据题意,我们有「数据长度至少为 $1$」、「越过数组两边看做负无穷」和「相邻元素不相等」的起始条件。\n\n我们可以根据数组长度是否为 $1$ 进行分情况讨论:\n\n1. 数组长度为 $1$,由于边界看做负无穷,此时峰值为该唯一元素的下标;\n\n2. 数组长度大于 $1$,从最左边的元素 $nums[0]$ 开始出发考虑:\n    * 如果 $nums[0] > nums[1]$,那么最左边元素 $nums[0]$ 就是峰值(结合左边界为负无穷);\n    * 如果 $nums[0] < nums[1]$,由于已经存在明确的 $nums[0]$ 和 $nums[1]$ 大小关系,我们将 $nums[0]$ 看做边界, $nums[1]$ 看做新的最左侧元素,继续往右进行分析:\n        * 如果在到达数组最右侧前,出现 $nums[i] > nums[i + 1]$,说明存在峰值位置 $i$(当我们考虑到 $nums[i]$,必然满足 $nums[i]$ 大于前一元素的前提条件,当然前一元素可能是原始左边界);\n        * 到达数组最右侧,还没出现 $nums[i] > nums[i + 1]$,说明数组严格递增。此时结合右边界可以看做负无穷,可判定 $nums[n - 1]$ 为峰值。\n\n**综上,我们证明了无论何种情况,数组必然存在峰值。**\n\n**证明 $2$ :二分不会错过峰值**\n\n其实基于「证明 $1$」,我们很容易就可以推理出「证明 $2$」的正确性。\n\n整理一下由「证明 $1$」得出的推理:**如果当前位置大于其左边界或者右边界,那么在当前位置的右边或左边必然存在峰值。**\n\n**换句话说,对于一个满足 $nums[x] > nums[x - 1]$ 的位置,$x$ 的右边一定存在峰值;或对于一个满足 $nums[x] > nums[x + 1]$ 的位置,$x$ 的左边一定存在峰值。**\n\n因此这里的「二段性」其实是指:**在以 $mid$ 为分割点的数组上,根据 $nums[mid]$ 与 $nums[mid \\pm 1]$ 的大小关系,可以确定其中一段满足「必然有解」,另外一段不满足「必然有解」(可能有解,可能无解)。**\n\n> 如果不理解为什么「证明 $2$」的正确性可以由「证明 $1$」推导而出的话,可以重点看看「证明 $1$」的第 $2$ 点的证明。\n\n**至此,我们证明了始终选择大于边界一端进行二分,可以确保选择的区间一定存在峰值,并随着二分过程不断逼近峰值位置。**\n\n另外,为了照顾还在纠结使用什么“模板”的同学,特意写了两个版本。但其实只要搞清楚我们「二分」什么内容,根本不会存在说用哪种方式才能写过的情况。\n\n代码:\n```Java\nclass Solution {\n    public int findPeakElement(int[] nums) {\n        int n = nums.length;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (nums[mid] > nums[mid + 1]) r = mid;\n            else l = mid + 1;\n        }\n        return r;\n    }\n}\n```\n\n```Java\nclass Solution {\n    public int findPeakElement(int[] nums) {\n        int n = nums.length;\n        if (n == 1) return 0;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (nums[mid] > nums[mid - 1]) l = mid;\n            else r = mid - 1;\n        }\n        return r;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 总结\n\n**通过本题,我们可以对「二分」有进一步的认识。**\n\n**最早在 [33. 搜索旋转排序数组](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247485864&idx=1&sn=e5482b2cf55962cd0c5384698d4d0fde&chksm=fd9ca2b7caeb2ba152ef1b900dce805ccfc73cf2a1595fa62eba8a6c5c5212d2d5b3e9f752ba&token=1232059512&lang=zh_CN#rd) 中,我们强调,二分的本质是「二段性」而非「单调性」,而经过本题,我们进一步发现「二段性」还能继续细分,不仅仅只有满足 $01$ 特性(满足/不满足)的「二段性」可以使用二分,满足 $1?$ 特性(一定满足/不一定满足)也可以二分。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.162` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/161-170/165. 比较版本号（中等）.md", "url_title": "165. 比较版本号", "url": "https://leetcode-cn.com/problems/compare-version-numbers/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-xsod/", "difficulty": "中等", "tags": ["模拟"], "question": "给你两个版本号 version1 和 version2 ,请你比较它们。\n\n版本号由一个或多个修订号组成,各修订号由一个 '.' 连接。每个修订号由 多位数字 组成,可能包含 前导零 。每个版本号至少包含一个字符。修订号从左到右编号,下标从 0 开始,最左边的修订号下标为 0 ,下一个修订号下标为 1 ,以此类推。例如,2.5.33 和 0.1 都是有效的版本号。\n\n比较版本号时,请按从左到右的顺序依次比较它们的修订号。比较修订号时,只需比较 忽略任何前导零后的整数值 。也就是说,修订号 1 和修订号 001 相等 。如果版本号没有指定某个下标处的修订号,则该修订号视为 0 。例如,版本 1.0 小于版本 1.1 ,因为它们下标为 0 的修订号相同,而下标为 1 的修订号分别为 0 和 1 ,0 < 1 。\n\n返回规则如下:\n* 如果 version1 > version2 返回 1,\n* 如果 version1 < version2 返回 -1,\n* 除此之外返回 0。\n\n示例 1:\n```\n输入:version1 = \"1.01\", version2 = \"1.001\"\n\n输出:0\n\n解释:忽略前导零,\"01\" 和 \"001\" 都表示相同的整数 \"1\"\n```\n示例 2:\n```\n输入:version1 = \"1.0\", version2 = \"1.0.0\"\n\n输出:0\n\n解释:version1 没有指定下标为 2 的修订号,即视为 \"0\"\n```\n示例 3:\n```\n输入:version1 = \"0.1\", version2 = \"1.1\"\n\n输出:-1\n\n解释:version1 中下标为 0 的修订号是 \"0\",version2 中下标为 0 的修订号是 \"1\" 。0 < 1,所以 version1 < version2\n```\n示例 4:\n```\n输入:version1 = \"1.0.1\", version2 = \"1\"\n\n输出:1\n```\n示例 5:\n```\n输入:version1 = \"7.5.2.4\", version2 = \"7.5.3\"\n\n输出:-1\n```\n\n提示:\n* 1 <= version1.length, version2.length <= 500\n* version1 和 version2 仅包含数字和 '.'\n* version1 和 version2 都是 有效版本号\n* version1 和 version2 的所有修订号都可以存储在 32 位整数 中", "solution": "### 模拟\n\n根据题意,对字符串进行分割,诸位比较「修订号」大小即可。\n\n对于缺省的修订号位置,使用 $0$ 进行代指。\n\n代码:\n```Java\nclass Solution {\n    public int compareVersion(String v1, String v2) {\n        String[] ss1 = v1.split(\"\\\\.\"), ss2 = v2.split(\"\\\\.\");\n        int n = ss1.length, m = ss2.length;\n        int i = 0, j = 0;\n        while (i < n || j < m) {\n            int a = 0, b = 0;\n            if (i < n) a = Integer.parseInt(ss1[i++]);\n            if (j < m) b = Integer.parseInt(ss2[j++]);\n            if (a != b) return a > b ? 1 : -1;\n        }\n        return 0;\n    }\n}\n```\n* 时间复杂度:令 `v1` 长度为 $n$,`v2` 长度为 $m$。整体复杂度为 $O(\\max(n, m))$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.165` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/161-170/166. 分数到小数（中等）.md", "url_title": "166. 分数到小数", "url": "https://leetcode-cn.com/problems/fraction-to-recurring-decimal/solution/gong-shui-san-xie-mo-ni-shu-shi-ji-suan-kq8c4/", "difficulty": "中等", "tags": ["数学", "模拟", "哈希表"], "question": "给定两个整数,分别表示分数的分子 `numerator` 和分母 `denominator`,以**字符串形式返回小数**。\n\n如果小数部分为循环小数,则将循环的部分括在括号内。\n\n如果存在多个答案,只需返回 **任意一个**。\n\n对于所有给定的输入,保证答案字符串的长度小于 $10^4$ 。\n\n示例 1:\n```\n输入:numerator = 1, denominator = 2\n\n输出:\"0.5\"\n```\n示例 2:\n```\n输入:numerator = 2, denominator = 1\n\n输出:\"2\"\n```\n示例 3:\n```\n输入:numerator = 2, denominator = 3\n\n输出:\"0.(6)\"\n```\n示例 4:\n```\n输入:numerator = 4, denominator = 333\n\n输出:\"0.(012)\"\n```\n示例 5:\n```\n输入:numerator = 1, denominator = 5\n\n输出:\"0.2\"\n```\n\n提示:\n* $-2^{31}$ <= numerator, denominator <= $2^{31} - 1$\n* denominator != 0", "solution": "### 模拟\n\n这是一道模拟 [竖式计算(除法)](https://baike.baidu.com/item/%E7%AB%96%E5%BC%8F%E8%AE%A1%E7%AE%97)的题目。\n\n首先可以明确,两个数相除要么是「有限位小数」,要么是「无限循环小数」,而不可能是「无限不循环小数」。\n\n然后考虑人工计算两数相除是如何进行:\n\n这引导我们可以在模拟竖式计算(除法)过程中,使用「哈希表」记录某个余数最早在什么位置出现过,一旦出现相同余数,则将「出现位置」到「当前结尾」之间的字符串抠出来,即是「循环小数」部分。\n\n> PS. 到这里,从人工模拟除法运算的过程,我们就可以知道「为什么不会出现“无限不循环小数”」,因为始终是对余数进行补零操作,再往下进行运算,而余数个数具有明确的上限(有限集)。所以一直往下计算,最终结果要么是「出现相同余数」,要么是「余数为 $0$,运算结束」。\n\n一些细节:\n\n* 一个显然的条件是,如果本身两数能够整除,直接返回即可;\n* 如果两个数有一个为“负数”,则最终答案为“负数”,因此可以起始先判断两数相乘是否小于 $0$,如果是,先往答案头部追加一个负号 `-`;\n* 两者范围为 `int`,但计算结果可以会超过 `int` 范围,考虑 $numerator = -2^{31}$ 和 $denominator = -1$ 的情况,其结果为 $2^{31}$,超出 `int` 的范围 $[-2^{31}, 2^{31} - 1]$。因此起始需要先使用 `long` 对两个入参类型转换一下。\n\n代码:\n```Java\nclass Solution {\n    public String fractionToDecimal(int numerator, int denominator) {\n        // 转 long 计算,防止溢出\n        long a = numerator, b = denominator;\n        // 如果本身能够整除,直接返回计算结果\n        if (a % b == 0) return String.valueOf(a / b);\n        StringBuilder sb = new StringBuilder();\n        // 如果其一为负数,先追加负号\n        if (a * b < 0) sb.append('-');\n        a = Math.abs(a); b = Math.abs(b);\n        // 计算小数点前的部分,并将余数赋值给 a\n        sb.append(String.valueOf(a / b) + \".\");\n        a %= b;\n        Map<Long, Integer> map = new HashMap<>();\n        while (a != 0) {\n            // 记录当前余数所在答案的位置,并继续模拟除法运算\n            map.put(a, sb.length());\n            a *= 10;\n            sb.append(a / b);\n            a %= b;\n            // 如果当前余数之前出现过,则将 [出现位置 到 当前位置] 的部分抠出来(循环小数部分)\n            if (map.containsKey(a)) {\n                int u = map.get(a);\n                return String.format(\"%s(%s)\", sb.substring(0, u), sb.substring(u));\n            }\n        }\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:复杂度取决于最终答案的长度,题目规定了最大长度不会超过 $10^4$,整体复杂度为 $O(M)$\n* 空间复杂度:复杂度取决于最终答案的长度,题目规定了最大长度不会超过 $10^4$,整体复杂度为 $O(M)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.166` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/161-170/168. Excel表列名称（简单）.md", "url_title": "168. Excel表列名称", "url": "https://leetcode-cn.com/problems/excel-sheet-column-title/solution/gong-shui-san-xie-cong-1-kai-shi-de-26-j-g2ur/", "difficulty": "简单", "tags": ["模拟"], "question": "给定一个正整数,返回它在 Excel 表中相对应的列名称。\n\n例如,\n```\n1 -> A\n2 -> B\n3 -> C\n...\n26 -> Z\n27 -> AA\n28 -> AB \n...\n```\n示例 1:\n```\n输入: 1\n输出: \"A\"\n```\n示例 2:\n```\n输入: 28\n输出: \"AB\"\n```\n示例 3:\n```\n输入: 701\n输出: \"ZY\"\n```", "solution": "### 模拟\n\n这是一道从 $1$ 开始的的 $26$ 进制转换题。\n\n对于一般性的进制转换题目,只需要不断地对 $columnNumber$ 进行 `%` 运算取得最后一位,然后对 $columnNumber$ 进行 `/` 运算,将已经取得的位数去掉,直到 $columnNumber$ 为 $0$ 即可。\n\n一般性的进制转换题目无须进行额外操作,是因为我们是在「每一位数值范围在 $[0,x)$」的前提下进行「逢 $x$ 进一」。\n\n但本题需要我们将从 $1$ 开始,因此在执行「进制转换」操作前,我们需要先对 $columnNumber$ 执行减一操作,从而实现整体偏移。\n\nJava 代码:\n```Java\nclass Solution {\n    public String convertToTitle(int columnNumber) {\n        StringBuilder sb = new StringBuilder();\n        while (columnNumber > 0) {\n            columnNumber--;\n            sb.append((char)(columnNumber % 26 + 'A'));\n            columnNumber /= 26;\n        }\n        sb.reverse();\n        return sb.toString();\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    string convertToTitle(int columnNumber) {\n        string sb;\n        while (columnNumber > 0) {\n            columnNumber--;\n            sb.push_back((char)(columnNumber % 26 + 'A'));\n            columnNumber /= 26;\n        }\n        reverse(sb.begin(), sb.end());\n        return sb;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def convertToTitle(self, columnNumber: int) -> str:\n        sb = \"\"\n        while columnNumber > 0:\n            columnNumber -= 1\n            sb += chr((columnNumber % 26) + ord('A'))\n            columnNumber //= 26\n        return sb[::-1]\n```\n* 时间复杂度:$O(\\log_{26}{cn})$\n* 空间复杂度:不算构造答案所消耗的空间,复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.168` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1611-1620/1614. 括号的最大嵌套深度（简单）.md", "url_title": "1614. 括号的最大嵌套深度", "url": "https://leetcode-cn.com/problems/maximum-nesting-depth-of-the-parentheses/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-pf5d/", "difficulty": "简单", "tags": ["模拟"], "question": "如果字符串满足以下条件之一,则可以称之为 有效括号字符串(valid parentheses string,可以简写为 VPS):\n\n* 字符串是一个空字符串 `\"\"`,或者是一个不为 `\"(\"` 或 `\")\"` 的单字符。\n* 字符串可以写为 `AB`(`A` 与 `B` 字符串连接),其中 `A` 和 `B` 都是 有效括号字符串 。\n* 字符串可以写为 `(A)`,其中 `A` 是一个 有效括号字符串 。\n\n类似地,可以定义任何有效括号字符串 `S` 的 嵌套深度 `depth(S)`:\n\n* `depth(\"\") = 0`\n* `depth(C) = 0`,其中 `C` 是单个字符的字符串,且该字符不是 `\"(\"` 或者 `\")\"`\n* `depth(A + B) = max(depth(A), depth(B))`,其中 `A` 和 `B` 都是 有效括号字符串\n* `depth(\"(\" + A + \")\") = 1 + depth(A)`,其中 `A` 是一个 有效括号字符串\n\n例如:`\"\"`、`\"()()\"`、`\"()(()())\"` 都是 有效括号字符串(嵌套深度分别为 0、1、2),而 `\")(\"` 、`\"(()\"` 都不是 有效括号字符串 。\n\n给你一个 有效括号字符串 `s`,返回该字符串的 `s` 嵌套深度 。\n\n示例 1:\n```\n输入:s = \"(1+(2*3)+((8)/4))+1\"\n\n输出:3\n\n解释:数字 8 在嵌套的 3 层括号中。\n```\n示例 2:\n```\n输入:s = \"(1)+((2))+(((3)))\"\n\n输出:3\n```\n示例 3:\n```\n输入:s = \"1+(2*3)/(2-1)\"\n输出:1\n```\n示例 4:\n```\n输入:s = \"1\"\n\n输出:0\n```\n\n提示:\n* $1 <= s.length <= 100$\n* `s` 由数字 `0-9` 和字符 `'+'`、`'-'`、`'*'`、`'/'`、`'('`、`')'` 组成\n* 题目数据保证括号表达式 `s` 是 有效的括号表达式", "solution": "### 模拟\n\n根据题意,其实就是求最大的连续左括号的数量(跳过普通字符,且与 `)` 抵消后),只需要边遍历边统计即可。\n\n代码:\n```Java\nclass Solution {\n    public int maxDepth(String s) {\n        int n = s.length(), ans = 0;\n        for (int i = 0, cnt = 0; i < n; i++) {\n            if (s.charAt(i) == '(') cnt++;\n            else if (s.charAt(i) == ')') cnt--;\n            ans = Math.max(ans, cnt);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1614` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1611-1620/1619. 删除某些元素后的数组均值（简单）.md", "url_title": "1619. 删除某些元素后的数组均值", "url": "https://leetcode.cn/problems/mean-of-array-after-removing-some-elements/solution/by-ac_oier-73w7/", "difficulty": "简单", "tags": ["模拟", "排序"], "question": "给你一个整数数组 `arr`,请你删除最小 `5%` 的数字和最大 `5%` 的数字后,剩余数字的平均值。\n\n与 标准答案 误差在 $10^{-5}$ 的结果都被视为正确结果。\n\n示例 1:\n```\n输入:arr = [1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3]\n\n输出:2.00000\n\n解释:删除数组中最大和最小的元素后,所有元素都等于 2,所以平均值为 2 。\n```\n示例 2:\n```\n输入:arr = [6,2,7,5,1,2,0,3,10,2,5,0,5,5,0,8,7,6,8,0]\n\n输出:4.00000\n```\n示例 3:\n```\n输入:arr = [6,0,7,0,7,5,7,8,3,4,0,7,8,1,6,8,1,1,2,4,8,1,9,5,4,3,8,5,10,8,6,6,1,0,6,10,8,2,3,4]\n\n输出:4.77778\n```\n示例 4:\n```\n输入:arr = [9,7,8,7,7,8,4,4,6,8,8,7,6,8,8,9,2,6,0,0,1,10,8,6,3,3,5,1,10,9,0,7,10,0,10,4,1,10,6,9,3,6,0,0,2,7,0,6,7,2,9,7,7,3,0,1,6,1,10,3]\n\n输出:5.27778\n```\n示例 5:\n```\n输入:arr = [4,8,4,10,0,7,1,3,7,8,8,3,4,1,6,2,1,1,8,0,9,8,0,3,9,10,3,10,1,10,7,3,2,1,4,9,10,7,6,4,0,8,5,1,2,1,6,2,5,0,7,10,9,10,3,7,10,5,8,5,7,6,7,6,10,9,5,10,5,5,7,2,10,7,7,8,2,0,1,1]\n\n输出:5.29167\n```\n\n提示:\n* $20 <= arr.length <= 1000$\n* `arr.length` 是 `20` 的 倍数 \n* $0 <= arr[i] <= 10^5$", "solution": "### 模拟\n\n根据题意进行模拟即可:先对 `arr` 进行排序,再计算出待统计的左右端点(端点以外的数值为 `5%` 最值),最后计算出相应均值。\n\nJava 代码:\n```Java\nclass Solution {\n    public double trimMean(int[] arr) {\n        Arrays.sort(arr);\n        int n = arr.length, tot = 0;\n        for (int i = n / 20; i < n - n / 20; i++) tot += arr[i];\n        return tot * 1.0 / (n * 0.9);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction trimMean(arr: number[]): number {\n    arr.sort((a,b)=>a-b)\n    let n = arr.length, tot = 0\n    for (let i = n / 20; i < n - n / 20; i++) tot += arr[i]\n    return tot / (n * 0.9)\n};\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1619` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1611-1620/1620. 网络信号最好的坐标（中等）.md", "url_title": "1620. 网络信号最好的坐标", "url": "https://leetcode.cn/problems/coordinate-with-maximum-network-quality/solution/by-ac_oier-xtx3/", "difficulty": "中等", "tags": ["模拟", "枚举"], "question": "给你一个数组 `towers` 和一个整数 `radius` 。\n\n数组  `towers`  中包含一些网络信号塔,其中 $towers[i] = [x_{i}, y_{i}, q_{i}]$ 表示第 `i` 个网络信号塔的坐标是 $(x_{i}, y_{i})$ 且信号强度参数为 $q_{i}$ 。所有坐标都是在  `X-Y` 坐标系内的 **整数** 坐标。两个坐标之间的距离用 **欧几里得距离** 计算。\n\n整数 `radius` 表示一个塔 能到达 的 最远距离 。如果一个坐标跟塔的距离在 `radius` 以内,那么该塔的信号可以到达该坐标。在这个范围以外信号会很微弱,所以 `radius` 以外的距离该塔是 不能到达的 。\n\n如果第 `i` 个塔能到达 $(x, y)$ ,那么该塔在此处的信号为 `⌊q / (1 + d)⌋` ,其中 `d` 是塔跟此坐标的距离。一个坐标的 信号强度 是所有 能到达 该坐标的塔的信号强度之和。\n\n请你返回数组 $[c_{x}, c_{y}]$ ,表示 信号强度 最大的 整数 坐标点 $(c_{x}, c_{y})$ 。如果有多个坐标网络信号一样大,请你返回字典序最小的 **非负** 坐标。\n\n注意:\n\n* 坐标 `(x1, y1)` 字典序比另一个坐标 `(x2, y2)` 小,需满足以下条件之一:\n\t* 要么 `x1 < x2` ,\n\t* 要么 `x1 == x2` 且 `y1 < y2` 。\n* `⌊val⌋` 表示小于等于 `val` 的最大整数(向下取整函数)。\n\n示例 1:\n\n```\n输入:towers = [[1,2,5],[2,1,7],[3,1,9]], radius = 2\n\n输出:[2,1]\n\n解释:\n坐标 (2, 1) 信号强度之和为 13\n- 塔 (2, 1) 强度参数为 7 ,在该点强度为 ⌊7 / (1 + sqrt(0)⌋ = ⌊7⌋ = 7\n- 塔 (1, 2) 强度参数为 5 ,在该点强度为 ⌊5 / (1 + sqrt(2)⌋ = ⌊2.07⌋ = 2\n- 塔 (3, 1) 强度参数为 9 ,在该点强度为 ⌊9 / (1 + sqrt(1)⌋ = ⌊4.5⌋ = 4\n没有别的坐标有更大的信号强度。\n```\n示例 2:\n```\n输入:towers = [[23,11,21]], radius = 9\n\n输出:[23,11]\n\n解释:由于仅存在一座信号塔,所以塔的位置信号强度最大。\n```\n示例 3:\n```\n输入:towers = [[1,2,13],[2,1,7],[0,1,9]], radius = 2\n\n输出:[1,2]\n\n解释:坐标 (1, 2) 的信号强度最大。\n```\n\n提示:\n* $1 <= towers.length <= 50$\n* $towers[i].length = 3$\n* $0 <= x_{i}, y_{i}, q_{i} <= 50$\n* $1 <= radius <= 50$", "solution": "### 模拟\n\n观察数据范围:无论是 `towers` 数组大小、坐标 $(x, y)$ 的值域大小,还是最远距离 `k = radius`,取值均不超过 $50$。\n\n因此我们可以直接采用「模拟」的方式进行求解,而不会面临 `TLE` 或 `MLE` 的风险。\n\n具体的,我们建立一个大小为 $110 \\times 110$ 的棋盘 `g`,用于记录每个坐标点的信号值,即 $g[i][j] = x$ 代表坐标 $(i, j)$ 的信号值为 $x$。\n\n> 其中 $110$ 的大小是利用了「任意坐标 $(x, y)$ 的取值范围不超过 $50$」,同时「最远距离 $k$ 不超过 $50$」并且「最终答案为非负坐标」而定。\n\n随后,我们可以枚举所有 $towers[i] = (a, b, q)$,并检查以该塔为中心点,大小为 $(k + k)^2$ 的矩阵中的所有点(该塔所能贡献信号的所有坐标均落在矩阵中),枚举过程中使用变量 `val` 记录最大信号值,使用 `x` 和 `y` 记录答案坐标。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] bestCoordinate(int[][] towers, int k) {\n        int[][] g = new int[110][110];\n        int x = 0, y = 0, val = 0;\n        for (int[] t : towers) {\n            int a = t[0], b = t[1], q = t[2];\n            for (int i = Math.max(0, a - k); i <= a + k; i++) {\n                for (int j = Math.max(0, b - k); j <= b + k; j++) {\n                    double d = Math.sqrt((a - i) * (a - i) + (b - j) * (b - j));\n                    if (d > k) continue;\n                    g[i][j] += Math.floor(q / (1 + d));\n                    if (g[i][j] > val) {\n                        x = i; y = j; val = g[i][j];\n                    } else if (g[i][j] == val && (i < x || (i == x && j < y))) {\n                        x = i; y = j;\n                    }\n                }\n            }\n        }\n        return new int[]{x, y};\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> bestCoordinate(vector<vector<int>>& towers, int k) {\n        const int n = 110;\n        vector<vector<int>> g(n, vector<int>(n, 0));\n        int x = 0, y = 0, val = 0;\n        for (const auto& t : towers) {\n            int a = t[0], b = t[1], q = t[2];\n            for (int i = max(0, a - k); i <= a + k; ++i) {\n                for (int j = max(0, b - k); j <= b + k; ++j) {\n                    double d = sqrt((a - i) * (a - i) + (b - j) * (b - j));\n                    if (d > k) continue;\n                    g[i][j] += floor(q / (1.0 + d));\n                    if (g[i][j] > val) {\n                        x = i; y = j; val = g[i][j];\n                    } else if (g[i][j] == val && (i < x || (i == x && j < y))) {\n                        x = i; y = j;\n                    }\n                }\n            }\n        }\n        return vector<int>{x, y};\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def bestCoordinate(self, towers: List[List[int]], k: int) -> List[int]:\n        g = [[0] * 110 for _ in range(110)]\n        x, y, val = 0, 0, 0\n        for (a, b, q) in towers:\n            for i in range(max(0, a - k), a + k + 1):\n                for j in range(max(0, b - k), b + k + 1):\n                    d = math.sqrt((a - i) * (a - i) + (b - j) * (b - j))\n                    if d > k:\n                        continue\n                    g[i][j] += int(q / (1 + d))\n                    if g[i][j] > val:\n                        val, x, y = g[i][j], i, j\n                    elif g[i][j] == val and ((i < x or (i == x and j < y))):\n                        x, y = i, j\n        return [x, y]\n```\nTypeScript 代码:\n```TypeScript\nfunction bestCoordinate(towers: number[][], k: number): number[] {\n    const g = new Array<Array<number>>(110)\n    for (let i = 0; i < 110; i++) g[i] = new Array<number>(110).fill(0)\n    let x = 0, y = 0, val = 0\n    for (const t of towers) {\n        const a = t[0], b = t[1], q = t[2]\n        for (let i = Math.max(0, a - k); i <= a + k; i++) {\n            for (let j = Math.max(0, b - k); j <= b + k; j++) {\n                const d = Math.sqrt((a - i) * (a - i) + (b - j) * (b - j))\n                if (d > k) continue\n                g[i][j] += Math.floor(q / (1 + d))\n                if (g[i][j] > val) {\n                    x = i; y = j; val = g[i][j]\n                } else if (g[i][j] == val && ((i < x) || (i == x && j < y))) {\n                    x = i; y = j\n                }\n            }\n        }\n    }\n    return [x, y]\n}\n```\n* 时间复杂度:需要 $O(n)$ 的复杂度枚举所有的塔 $towers[i]$;对于每座塔,我们需要枚举以该塔为中心点,大小为 $(k + k)^2$ 的矩阵中的所有坐标。整体复杂度为 $O(n \\times k^2)$\n* 空间复杂度:$O(M^2)$,其中 $M = 110$ 为棋盘大小", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1620` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1621-1630/1622. 奇妙序列（困难）.md", "url_title": "1622. 奇妙序列", "url": null, "difficulty": "困难", "tags": ["线段树"], "question": "请你实现三个 API `append`,`addAll` 和 `multAll` 来实现奇妙序列。\n\n请实现 `Fancy` 类 :\n\n* `Fancy()` 初始化一个空序列对象。\n* `void append(val)` 将整数 `val` 添加在序列末尾。\n* `void addAll(inc)` 将所有序列中的现有数值都增加 `inc` 。\n* `void multAll(m)` 将序列中的所有现有数值都乘以整数 `m` 。\n* `int getIndex(idx)` 得到下标为 `idx` 处的数值(下标从 $0$ 开始),并将结果对 $10^9 + 7$ 取余。如果下标大于等于序列的长度,请返回 $-1$ 。\n\n示例:\n```\n输入:\n[\"Fancy\", \"append\", \"addAll\", \"append\", \"multAll\", \"getIndex\", \"addAll\", \"append\", \"multAll\", \"getIndex\", \"getIndex\", \"getIndex\"]\n[[], [2], [3], [7], [2], [0], [3], [10], [2], [0], [1], [2]]\n\n输出:\n[null, null, null, null, null, 10, null, null, null, 26, 34, 20]\n\n解释:\nFancy fancy = new Fancy();\nfancy.append(2);   // 奇妙序列:[2]\nfancy.addAll(3);   // 奇妙序列:[2+3] -> [5]\nfancy.append(7);   // 奇妙序列:[5, 7]\nfancy.multAll(2);  // 奇妙序列:[5*2, 7*2] -> [10, 14]\nfancy.getIndex(0); // 返回 10\nfancy.addAll(3);   // 奇妙序列:[10+3, 14+3] -> [13, 17]\nfancy.append(10);  // 奇妙序列:[13, 17, 10]\nfancy.multAll(2);  // 奇妙序列:[13*2, 17*2, 10*2] -> [26, 34, 20]\nfancy.getIndex(0); // 返回 26\nfancy.getIndex(1); // 返回 34\nfancy.getIndex(2); // 返回 20\n```\n\n提示:\n* $1 <= val, inc, m <= 100$\n* $0 <= idx <= 10^5$\n* 总共最多会有 $10^5$ 次对 `append`,`addAll`,`multAll` 和 `getIndex` 的调用。", "solution": "### 线段树(多个懒标记)\n\n使用多个懒标记来解决 `add` 和 `mul` 问题。\n\n代码:\n```Java\nclass Fancy {\n    class Node {\n        int ls, rs;\n        long val, add, mul = 1;\n    }\n    int N = (int) 1e8 + 10, M = 1000010, loc = 1, cnt = 0, mod = (int)1e9+7;\n    Node[] tr = new Node[M];\n    void add(int u, int lc, int rc, int l, int r, int v) {\n        int len = rc - lc + 1;\n        if (l <= lc && rc <= r) {\n            tr[u].val += len * v; tr[u].val %= mod;\n            tr[u].add += v; tr[u].add %= mod;\n            return ;\n        }\n        pushdown(u, len);\n        int mid = lc + rc >> 1;\n        if (l <= mid) add(tr[u].ls, lc, mid, l, r, v);\n        if (r > mid) add(tr[u].rs, mid + 1, rc, l, r, v);\n        pushup(u);\n    }\n    void mul(int u, int lc, int rc, int l, int r, int v) {\n        if (l <= lc && rc <= r) {\n            tr[u].val *= v; tr[u].val %= mod;\n            tr[u].mul *= v; tr[u].mul %= mod;\n            tr[u].add *= v; tr[u].add %= mod;\n            return ;\n        }\n        pushdown(u, rc - lc + 1);\n        int mid = lc + rc >> 1;\n        if (l <= mid) mul(tr[u].ls, lc, mid, l, r, v);\n        if (r > mid) mul(tr[u].rs, mid + 1, rc, l, r, v);\n        pushup(u);\n    }\n    long query(int u, int lc, int rc, int l, int r) {\n        if (l <= lc && rc <= r) return tr[u].val;\n        pushdown(u, rc - lc + 1);\n        int mid = lc + rc >> 1;\n        long ans = 0;\n        if (l <= mid) ans = query(tr[u].ls, lc, mid, l, r);\n        if (r > mid) ans += query(tr[u].rs, mid + 1, rc, l, r);\n        return ans;\n    }\n    void pushdown(int u, int len) {\n        if (tr[u] == null) tr[u] = new Node();\n        if (tr[u].ls == 0) {\n            tr[u].ls = ++loc;\n            tr[tr[u].ls] = new Node();\n        }\n        if (tr[u].rs == 0) {\n            tr[u].rs = ++loc;\n            tr[tr[u].rs] = new Node();\n        }\n        long mul = tr[u].mul, add = tr[u].add;\n        tr[tr[u].ls].val = tr[tr[u].ls].val * mul + (len / 2) * add; tr[tr[u].rs].val = tr[tr[u].rs].val * mul + (len / 2) * add;\n        tr[tr[u].ls].mul *= mul; tr[tr[u].rs].mul *= mul;\n        tr[tr[u].ls].add = tr[tr[u].ls].add * mul + add; tr[tr[u].rs].add = tr[tr[u].rs].add * mul + add;\n        tr[tr[u].ls].val %= mod; tr[tr[u].rs].val %= mod;\n        tr[tr[u].ls].mul %= mod; tr[tr[u].rs].mul %= mod;\n        tr[tr[u].ls].add %= mod; tr[tr[u].rs].add %= mod;\n        tr[u].add = 0; tr[u].mul = 1;\n    }\n    void pushup(int u) {\n        tr[u].val = tr[tr[u].ls].val + tr[tr[u].rs].val;\n        tr[u].val %= mod;\n    }\n    public void append(int val) {\n        cnt++;\n        add(1, 1, N, cnt, cnt, val);\n    }\n    public void addAll(int inc) {\n        if (cnt == 0) return ;\n        add(1, 1, N, 1, cnt, inc);\n    }\n    public void multAll(int m) {\n        if (cnt == 0) return ;\n        mul(1, 1, N, 1, cnt, m);\n    }\n    public int getIndex(int idx) {\n        return idx + 1 > cnt ? -1 : (int)(query(1, 1, N, idx + 1, idx + 1) % mod);\n    }\n}\n```\n* 时间复杂度:查询次数为 $m$,值域大小为 $n$,插入和查询复杂度均为 $O(\\log{n})$\n* 空间复杂度:$O(m \\times \\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1622` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1621-1630/1624. 两个相同字符之间的最长子字符串（简单）.md", "url_title": "1624. 两个相同字符之间的最长子字符串", "url": "https://leetcode.cn/problems/largest-substring-between-two-equal-characters/solution/by-ac_oier-ki3t/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个字符串 `s`,请你返回 两个相同字符之间的最长子字符串的长度 ,计算长度时不含这两个字符。如果不存在这样的子字符串,返回 `-1` 。\n\n子字符串 是字符串中的一个连续字符序列。\n\n示例 1:\n```\n输入:s = \"aa\"\n\n输出:0\n\n解释:最优的子字符串是两个 'a' 之间的空子字符串。\n```\n示例 2:\n```\n输入:s = \"abca\"\n\n输出:2\n\n解释:最优的子字符串是 \"bc\" 。\n```\n示例 3:\n```\n输入:s = \"cbzxy\"\n\n输出:-1\n\n解释:s 中不存在出现出现两次的字符,所以返回 -1 。\n```\n示例 4:\n```\n输入:s = \"cabbac\"\n\n输出:4\n\n解释:最优的子字符串是 \"abba\" ,其他的非最优解包括 \"bb\" 和 \"\" 。\n```\n\n提示:\n* $1 <= s.length <= 300$\n* `s` 只含小写英文字母", "solution": "### 模拟\n\n根据题意继续模拟即可:使用数组 `idxs` 记录下每个字符最开始出现的下标即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxLengthBetweenEqualCharacters(String s) {\n        int[] idxs = new int[26];\n        Arrays.fill(idxs, 310);\n        int n = s.length(), ans = -1;\n        for (int i = 0; i < n; i++) {\n            int u = s.charAt(i) - 'a';\n            idxs[u] = Math.min(idxs[u], i);\n            ans = Math.max(ans, i - idxs[u] - 1);\n        }\n        return ans;\n    }\n}\n```\nTypescript 代码:\n```Typescript\nfunction maxLengthBetweenEqualCharacters(s: string): number {\n    const idxs = new Array<number>(26).fill(310)\n    let n = s.length, ans = -1\n    for (let i = 0; i < n; i++) {\n        const u = s.charCodeAt(i) - 'a'.charCodeAt(0)\n        idxs[u] = Math.min(idxs[u], i)\n        ans = Math.max(ans, i - idxs[u] - 1)\n    }\n    return ans\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxLengthBetweenEqualCharacters(self, s: str) -> int:\n        idxs = {}\n        ans = -1\n        for i, c in enumerate(s):\n            idxs[c] = idxs[c] if c in idxs else i\n            ans = max(ans, i - idxs[c] - 1)\n        return ans\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(C)$,其中 $C = 26$ 为字符集大小", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1624` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1621-1630/1629. 按键持续时间最长的键（简单）.md", "url_title": "1629. 按键持续时间最长的键", "url": "https://leetcode-cn.com/problems/slowest-key/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-zjwb/", "difficulty": "简单", "tags": ["模拟"], "question": "LeetCode 设计了一款新式键盘,正在测试其可用性。测试人员将会点击一系列键(总计 `n` 个),每次一个。\n\n给你一个长度为 `n` 的字符串 `keysPressed` ,其中 `keysPressed[i]` 表示测试序列中第 i 个被按下的键。`releaseTimes` 是一个升序排列的列表,其中 `releaseTimes[i]` 表示松开第 `i` 个键的时间。字符串和数组的 下标都从 `0` 开始 。第 `0` 个键在时间为 `0` 时被按下,接下来每个键都 恰好 在前一个键松开时被按下。\n\n测试人员想要找出按键 持续时间最长 的键。第 `i` 次按键的持续时间为 `releaseTimes[i] - releaseTimes[i - 1]` ,第 `0` 次按键的持续时间为 `releaseTimes[0]` 。\n\n注意,测试期间,同一个键可以在不同时刻被多次按下,而每次的持续时间都可能不同。\n\n请返回按键 持续时间最长 的键,如果有多个这样的键,则返回 按字母顺序排列最大 的那个键。\n\n示例 1:\n```\n输入:releaseTimes = [9,29,49,50], keysPressed = \"cbcd\"\n\n输出:\"c\"\n\n解释:按键顺序和持续时间如下:\n按下 'c' ,持续时间 9(时间 0 按下,时间 9 松开)\n按下 'b' ,持续时间 29 - 9 = 20(松开上一个键的时间 9 按下,时间 29 松开)\n按下 'c' ,持续时间 49 - 29 = 20(松开上一个键的时间 29 按下,时间 49 松开)\n按下 'd' ,持续时间 50 - 49 = 1(松开上一个键的时间 49 按下,时间 50 松开)\n按键持续时间最长的键是 'b' 和 'c'(第二次按下时),持续时间都是 20\n'c' 按字母顺序排列比 'b' 大,所以答案是 'c'\n```\n示例 2:\n```\n输入:releaseTimes = [12,23,36,46,62], keysPressed = \"spuda\"\n\n输出:\"a\"\n\n解释:按键顺序和持续时间如下:\n按下 's' ,持续时间 12\n按下 'p' ,持续时间 23 - 12 = 11\n按下 'u' ,持续时间 36 - 23 = 13\n按下 'd' ,持续时间 46 - 36 = 10\n按下 'a' ,持续时间 62 - 46 = 16\n按键持续时间最长的键是 'a' ,持续时间 16\n```\n\n提示:\n* `releaseTimes.length == n`\n* `keysPressed.length == n`\n* `2 <= n <= 1000`\n* `1 <= releaseTimes[i] <= 10^9`\n* `releaseTimes[i] < releaseTimes[i+1]`\n* `keysPressed` 仅由小写英文字母组成", "solution": "### 模拟\n\n为了方便,我们用 $rt$ 来代指 $releaseTimes$,用 $kp$ 来代指 $keysPressed$。\n\n根据题意,从先往后处理每个 $kp[i]$,计算每次的持续时间(当前结束时间与上次时间的差值)$rt[i] - rt[i - 1]$,遍历过程中维护最大持续时间和对应的字符下标。\n\n代码:\n```Java\nclass Solution {\n    public char slowestKey(int[] rt, String kp) {\n        int n = rt.length, idx = 0, max = rt[0];\n        for (int i = 1; i < n; i++) {\n            int cur = rt[i] - rt[i - 1];\n            if (cur > max) {\n                idx = i; max = cur;\n            } else if (cur == max && kp.charAt(i) > kp.charAt(idx)) {\n                idx = i;\n            }\n        }\n        return kp.charAt(idx);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1629` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1631-1640/1631. 最小体力消耗路径（中等）.md", "url_title": "1631. 最小体力消耗路径", "url": "https://leetcode-cn.com/problems/path-with-minimum-effort/solution/fan-zheng-fa-zheng-ming-si-lu-de-he-fa-x-ohby/", "difficulty": "中等", "tags": ["最小生成树", "并查集", "Kruskal"], "question": "你准备参加一场远足活动。\n\n给你一个二维 `rows x columns` 的地图 heights ,其中 `heights[row][col]` 表示格子 `(row, col)` 的高度。\n\n一开始你在最左上角的格子 `(0, 0`) ,且你希望去最右下角的格子 `(rows-1, columns-1)` (注意下标从 0 开始编号)。\n\n你每次可以往 上,下,左,右 四个方向之一移动,你想要找到耗费 体力 最小的一条路径。\n\n一条路径耗费的「体力值」是路径上相邻格子之间「高度差绝对值」的「最大值」决定的。\n\n请你返回从左上角走到右下角的最小 体力消耗值 。\n\n \n\n示例 1:\n\n```\n输入:heights = [[1,2,2],[3,8,2],[5,3,5]]\n\n输出:2\n\n解释:路径 [1,3,5,3,5] 连续格子的差值绝对值最大为 2 。\n这条路径比路径 [1,2,2,2,5] 更优,因为另一条路径差值最大值为 3 。\n```\n示例 2:\n```\n输入:heights = [[1,2,3],[3,8,4],[5,3,5]]\n\n输出:1\n\n解释:路径 [1,2,3,4,5] 的相邻格子差值绝对值最大为 1 ,比路径 [1,3,5,3,5] 更优。\n```\n示例 3:\n```\n输入:heights = [[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]]\n\n输出:0\n\n解释:上图所示路径不需要消耗任何体力。\n```\n\n提示:\n* rows == heights.length\n* columns == heights[i].length\n* 1 <= rows, columns <= 100\n* 1 <= heights[i][j] <= $10^6$", "solution": "### 基本分析\n\n对于这道题,可能会有同学想这是不是应该用 DP 呀?\n\n特别是接触过[「路径问题」](https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MzU4NDE3MTEyMA==&action=getalbum&album_id=1773144264147812354&scene=173&from_msgid=2247485319&from_itemidx=1&count=3#wechat_redirect)但又还没系统学完的同学。\n\n**事实上,当题目允许往任意方向移动时,考察的往往就不是 DP 了,而是图论。**\n\n**从本质上说,DP 问题是一类特殊的图论问题。**\n\n**那为什么有一些 DP 题目简单修改条件后,就只能彻底转化为图论问题来解决了呢?**\n\n**这是因为修改条件后,导致我们 DP 状态展开不再是一个拓扑序列,也就是我们的图不再是一个拓扑图。**\n\n**换句话说,DP 题虽然都属于图论范畴。**\n\n**但对于不是拓扑图的图论问题,我们无法使用 DP 求解。**\n\n**而此类看似 DP,实则图论的问题,通常是最小生成树或者最短路问题。**\n\n---\n\n### Kruskal\n\n**当一道题我们决定往「图论」方向思考时,我们的重点应该放在「如何建图」上。**\n\n因为解决某个特定的图论问题(最短路/最小生成树/二分图匹配),我们都是使用特定的算法。\n\n由于使用到的算法都有固定模板,因此编码难度很低,而「如何建图」的思维难度则很高。\n\n对于本题,我们可以按照如下分析进行建图:\n\n因为在任意格子可以往「任意方向」移动,所以相邻的格子之间存在一条无向边。\n\n题目要我们求的就是**从起点到终点的最短路径中,边权最大的值**。\n\n我们可以先遍历所有的格子,将所有的边加入集合。\n\n存储的格式为数组 $[a, b, w]$ ,代表编号为 $a$ 的点和编号为 $b$ 的点之间的权重为 $w$。\n\n按照题意,$w$ 为两者的高度差的绝对值。\n\n对集合进行排序,按照 $w$ 进行从小到大排序(Kruskal 部分)。\n\n当我们有了所有排好序的候选边集合之后,我们可以对边进行从前往后处理,每次加入一条边之后,使用并查集来查询「起点」和「终点」是否连通(并查集部分)。\n\n**当第一次判断「起点」和「终点」联通时,说明我们「最短路径」的所有边都已经应用到并查集上了,而且由于我们的边是按照「从小到大」进行排序,因此最后一条添加的边就是「最短路径」上权重最大的边。**\n\n代码:\n```Java\nclass Solution {\n    int N = 10009;\n    int[] p = new int[N];\n    int row, col;\n    void union(int a, int b) {\n        p[find(a)] = p[find(b)];\n    }\n    boolean query(int a, int b) {\n        return p[find(a)] == p[find(b)];\n    }\n    int find(int x) {\n        if (p[x] != x) p[x] = find(p[x]);\n        return p[x];\n    }\n    public int minimumEffortPath(int[][] heights) {\n        row = heights.length;\n        col = heights[0].length;\n\n        // 初始化并查集\n        for (int i = 0; i < row * col; i++) p[i] = i;\n\n        // 预处理出所有的边\n        // edge 存的是 [a, b, w]:代表从 a 到 b 的体力值为 w\n        // 虽然我们可以往四个方向移动,但是只要对于每个点都添加「向右」和「向下」两条边的话,其实就已经覆盖了所有边了\n        List<int[]> edges = new ArrayList<>();\n        for (int i = 0; i < row; i++) {\n            for (int j = 0; j < col; j++) {\n                int idx = getIndex(i, j);\n                if (i + 1 < row) {\n                    int a = idx, b = getIndex(i + 1, j);\n                    int w = Math.abs(heights[i][j] - heights[i + 1][j]);\n                    edges.add(new int[]{a, b, w});\n                }\n                if (j + 1 < col) {\n                    int a = idx, b = getIndex(i, j + 1);\n                    int w = Math.abs(heights[i][j] - heights[i][j + 1]);\n                    edges.add(new int[]{a, b, w});\n                }\n            }\n        }\n\n        // 根据权值 w 降序\n        Collections.sort(edges, (a,b)->a[2]-b[2]);\n\n        // 从「小边」开始添加,当某一条边别应用之后,恰好使用得「起点」和「结点」联通\n        // 那么代表找到了「最短路径」中的「权重最大的边」\n        int start = getIndex(0, 0), end = getIndex(row - 1, col - 1);\n        for (int[] edge : edges) {\n            int a = edge[0], b = edge[1], w = edge[2];\n            union(a, b);\n            if (query(start, end)) {\n                return w;\n            }\n        }\n        return 0; \n    }\n    int getIndex(int x, int y) {\n        return x * col  + y;\n    }\n}\n```\n\n令行数为 $r$,列数为 $c$,那么节点的数量为 $r * c$,无向边的数量严格为 $r * (c - 1) + c * (r - 1)$,数量级上为 $r * c$。\n\n* 时间复杂度:获取所有的边复杂度为 $O(r * c)$,排序复杂度为 $O((r * c)\\log{(r * c)})$,遍历得到最终解复杂度为 $O(r * c)$。整体复杂度为 $O((r * c)\\log{(r * c)})$。\n* 空间复杂度:使用了并查集数组。复杂度为 $O(r * c)$。\n\n---\n\n### 证明\n\n**我们之所以能够这么做,是因为「跳出循环前所遍历的最后一条边必然是最优路径上的边,而且是 $w$ 最大的边」。**\n\n我们可以用「反证法」来证明这个结论为什么是正确的。\n\n我们先假设「跳出循环前所遍历的最后一条边必然是最优路径上的边,而且是 $w$ 最大的边」不成立:\n\n我们令循环终止前的最后一条边为 `a`\n\n1. *假设 a 不在最优路径内*:如果 $a$ 并不在最优路径内,即最优路径是由 $a$ 边之前的边构成,那么 $a$ 边不会对左上角和右下角节点的连通性产生影响。也就是在遍历到该边之前,左上角和右下角应该是联通的,逻辑上循环会在遍历到该边前终止。与我们循环的决策逻辑冲突。\n\n2. *$a$ 在最优路径内,但不是 $w$ 最大的边*:我们在遍历之前就已经排好序。与排序逻辑冲突。\n\n因此,我们的结论是正确的。`a` 边必然属于「最短路径」并且是权重最大的边。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1631` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1631-1640/1636. 按照频率将数组升序排序（简单）.md", "url_title": "1636. 按照频率将数组升序排序", "url": "https://leetcode.cn/problems/sort-array-by-increasing-frequency/solution/by-ac_oier-c3xc/", "difficulty": "简单", "tags": ["哈希表", "排序", "模拟"], "question": "给你一个整数数组 `nums`,请你将数组按照每个值的频率 升序 排序。如果有多个值的频率相同,请你按照数值本身将它们 降序 排序。 \n\n请你返回排序后的数组。\n\n示例 1:\n```\n输入:nums = [1,1,2,2,2,3]\n\n输出:[3,1,1,2,2,2]\n\n解释:'3' 频率为 1,'1' 频率为 2,'2' 频率为 3 。\n```\n示例 2:\n```\n输入:nums = [2,3,1,3,2]\n\n输出:[1,3,3,2,2]\n\n解释:'2' 和 '3' 频率都为 2 ,所以它们之间按照数值本身降序排序。\n```\n示例 3:\n```\n输入:nums = [-1,1,-6,4,5,-6,1,4,1]\n\n输出:[5,-1,4,4,-6,-6,1,1,1]\n```\n\n提示:\n* $1 <= nums.length <= 100$\n* $-100 <= nums[i] <= 100$", "solution": "### 哈希表 + 排序 + 模拟\n\n根据题意,先使用哈希表进行词频统计,再以二元组 $(x, cnt)$ 的形式转存到数组 `list` 中(其中 $x$ 为对应的 $nums$ 中的数值,$cnt$ 为数值 $x$ 在 `nums` 中的出现次数),再根据题目给定对 `list` 进行排序,最后再构造出答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] frequencySort(int[] nums) {\n        int n = nums.length;\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = 0; i < n; i++) map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);\n        List<int[]> list = new ArrayList<>();\n        for (int key : map.keySet()) list.add(new int[]{key, map.get(key)});\n        Collections.sort(list, (a, b)->{\n            return a[1] != b[1] ? a[1] - b[1] : b[0] - a[0];\n        });\n        int[] ans = new int[n];\n        int idx = 0;\n        for (int[] info : list) {\n            int a = info[0], b = info[1];\n            while (b-- > 0) ans[idx++] = a;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction frequencySort(nums: number[]): number[] {\n    const map = new Map<number, number>()\n    for (const x of nums) {\n        if (!map.has(x)) map.set(x, 0)\n        map.set(x, map.get(x) + 1)\n    }\n    nums.sort((a,b)=>{\n        return map.get(a) != map.get(b) ? map.get(a) - map.get(b) : b - a\n    })\n    return nums\n};\n```\n* 时间复杂度:使用哈希表进行统计复杂度为 $O(n)$;根据规则进行排序复杂度为 $O(n\\log{n})$;构造答案复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1636` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1631-1640/1640. 能否连接形成数组（简单）.md", "url_title": "1640. 能否连接形成数组", "url": "https://leetcode.cn/problems/check-array-formation-through-concatenation/solution/by-ac_oier-3jqf/", "difficulty": "简单", "tags": ["排序", "二分", "哈希表", "模拟"], "question": "给你一个整数数组 `arr` ,数组中的每个整数 互不相同 。\n\n另有一个由整数数组构成的数组 `pieces`,其中的整数也互不相同。\n\n请你以任意顺序连接 `pieces` 中的数组以形成 `arr` 。\n\n但是,不允许对每个数组 `pieces[i]` 中的整数重新排序。\n\n如果可以连接 `pieces` 中的数组形成 `arr` ,返回 `true` ;否则,返回 `false` 。\n\n示例 1:\n```\n输入:arr = [15,88], pieces = [[88],[15]]\n\n输出:true\n\n解释:依次连接 [15] 和 [88]\n```\n示例 2:\n```\n输入:arr = [49,18,16], pieces = [[16,18,49]]\n\n输出:false\n\n解释:即便数字相符,也不能重新排列 pieces[0]\n```\n示例 3:\n```\n输入:arr = [91,4,64,78], pieces = [[78],[4,64],[91]]\n\n输出:true\n\n解释:依次连接 [91]、[4,64] 和 [78]\n```\n\n提示:\n* $1 <= pieces.length <= arr.length <= 100$\n* `sum(pieces[i].length) = arr.length`\n* $1 <= pieces[i].length <= arr.length$\n* $1 <= arr[i], pieces[i][j] <= 100$\n* `arr` 中的整数 互不相同\n* `pieces` 中的整数 互不相同(也就是说,如果将 `pieces` 扁平化成一维数组,数组中的所有整数互不相同)", "solution": "### 排序 + 二分\n\n偷懒直接看示例做了,于是漏掉「两数组元素各不相同」且「两数组总元素个数相等」等条件,写了一个「排序 + 二分 + 贪心」的解法。\n\n**但实际上该做法也仅能解决「两数组元素各不相同」的问题,若允许元素重复,并不存在多项式解法。**\n\n回归到元素互不相同的条件,可以退化出「排序 + 二分」解法。\n\n记 `arr` 数组长度为 $n$,`pieces` 数组长度为 $m$。\n\n起始对 `pieces` 进行排序(根据 $pieces[i]$ 的首位元素排升序),从前往后处理每个 `arr[i]` 尝试匹配,先通过二分找到合适的 $pieces[j]$(即满足首位元素与 `arr[i]` 相同的 $pieces[j]$),并进行连续段的匹配,若匹配失败直接返回 `false`。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean canFormArray(int[] arr, int[][] pieces) {\n        int n = arr.length, m = pieces.length;\n        Arrays.sort(pieces, (a,b)->a[0]-b[0]);\n        for (int i = 0; i < n; ) {\n            int l = 0, r = m - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (pieces[mid][0] <= arr[i]) l = mid;\n                else r = mid - 1;\n            }\n            int len = pieces[r].length, idx = 0;\n            while (idx < len && pieces[r][idx] == arr[i + idx]) idx++;\n            if (idx == len) i += len;\n            else return false;\n        }\n        return true;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool canFormArray(vector<int>& arr, vector<vector<int>>& pieces) {\n        int n = arr.size(), m = pieces.size();\n        sort(pieces.begin(), pieces.end());\n        for (int i = 0; i < n; ) {\n            int l = 0, r = m - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (pieces[mid][0] <= arr[i]) l = mid;\n                else r = mid - 1;\n            }\n            int len = pieces[r].size(), idx = 0;\n            while (idx < len && pieces[r][idx] == arr[i + idx]) idx++;\n            if (idx == len) i += len;\n            else return false;\n        }\n        return true;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def canFormArray(self, arr: List[int], pieces: List[List[int]]) -> bool:\n        n, m = len(arr), len(pieces)\n        pieces.sort(key=lambda x: x[0])\n        i = 0\n        while i < n:\n            l, r = 0, m - 1\n            while l < r:\n                mid = l + r + 1 >> 1\n                if pieces[mid][0] <= arr[i]:\n                    l = mid\n                else:\n                    r = mid - 1\n            sz, idx = len(pieces[r]), 0\n            while idx < sz and pieces[r][idx] == arr[i + idx]:\n                idx += 1\n            if idx == sz:\n                i += sz\n            else:\n                return False\n        return True\n```\nTypeScript 代码:\n```TypeScript\nfunction canFormArray(arr: number[], pieces: number[][]): boolean {\n    const n = arr.length, m = pieces.length\n    pieces.sort((a,b)=>a[0]-b[0])\n    for (let i = 0; i < n; ) {\n        let l = 0, r = m - 1\n        while (l < r) {\n            const mid = l + r + 1 >> 1\n            if (pieces[mid][0] <= arr[i]) l = mid\n            else r = mid - 1\n        }\n        let len = pieces[r].length, idx = 0\n        while (idx < len && pieces[r][idx] == arr[i + idx]) idx++\n        if (idx == len) i += len\n        else return false\n    }\n    return true\n};\n```\n* 时间复杂度:排序复杂度为 $O(m\\log{m})$;构造的复杂度为 $O(n\\log{m})$。整体复杂度为 $O(m\\log{m} + n\\log{m})$\n* 空间复杂度:$O(\\log{m})$\n\n---\n\n### 哈希表\n\n利用元素各不相同,使用哈希表进行预处理即可:$hash[x] = idx$ 含义为 $pieces[idx]$ 的首位元素为 $x$。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean canFormArray(int[] arr, int[][] pieces) {\n        int n = arr.length, m = pieces.length;\n        int[] hash = new int[110];\n        for (int i = 0; i < m; i++) hash[pieces[i][0]] = i;\n        for (int i = 0; i < n; ) {\n            int[] cur = pieces[hash[arr[i]]];\n            int len = cur.length, idx = 0;\n            while (idx < len && cur[idx] == arr[i + idx]) idx++;\n            if (idx == len) i += len;\n            else return false;\n        }\n        return true;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool canFormArray(vector<int>& arr, vector<vector<int>>& pieces) {\n        int n = arr.size(), m = pieces.size();\n        vector<int> hash(110);\n        for (int i = 0; i < m; i++) hash[pieces[i][0]] = i;\n        for (int i = 0; i < n; ) {\n            vector<int> cur = pieces[hash[arr[i]]];\n            int len = cur.size(), idx = 0;\n            while (idx < len && cur[idx] == arr[i + idx]) idx++;\n            if (idx == len) i += len;\n            else return false;\n        }\n        return true;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def canFormArray(self, arr: List[int], pieces: List[List[int]]) -> bool:\n        n, m = len(arr), len(pieces)\n        hash = [0] * 110\n        for i in range(m):\n            hash[pieces[i][0]] = i\n        i = 0\n        while i < n:\n            cur = pieces[hash[arr[i]]]\n            sz, idx = len(cur), 0\n            while idx < sz and cur[idx] == arr[i + idx]:\n                idx += 1\n            if idx == sz:\n                i += sz\n            else:\n                return False\n        return True\n```\nTypeScript 代码:\n```TypeScript\nfunction canFormArray(arr: number[], pieces: number[][]): boolean {\n    const n = arr.length, m = pieces.length\n    const hash = new Array<number>(110).fill(0)\n    for (let i = 0; i < m; i++) hash[pieces[i][0]] = i\n    for (let i = 0; i < n; ) {\n        let cur = pieces[hash[arr[i]]], sz = cur.length, idx = 0\n        while (idx < sz && cur[idx] == arr[i + idx]) idx++\n        if (idx == sz) i += sz\n        else return false\n    }\n    return true\n};\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(C)$,其中 $C = 110$ 为两数组的值域大小", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1640` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1641-1650/1646. 获取生成数组中的最大值（简单）.md", "url_title": "1646. 获取生成数组中的最大值", "url": "https://leetcode-cn.com/problems/get-maximum-in-generated-array/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-sj53/", "difficulty": "简单", "tags": ["模拟", "打表"], "question": "给你一个整数 n 。按下述规则生成一个长度为 n + 1 的数组 nums :\n\n* nums[0] = 0\n* nums[1] = 1\n* 当 2 <= 2 * i <= n 时,nums[2 * i] = nums[i]\n* 当 2 <= 2 * i + 1 <= n 时,nums[2 * i + 1] = nums[i] + nums[i + 1]\n\n返回生成数组 nums 中的 最大 值。\n\n示例 1:\n```\n输入:n = 7\n\n输出:3\n\n解释:根据规则:\n  nums[0] = 0\n  nums[1] = 1\n  nums[(1 * 2) = 2] = nums[1] = 1\n  nums[(1 * 2) + 1 = 3] = nums[1] + nums[2] = 1 + 1 = 2\n  nums[(2 * 2) = 4] = nums[2] = 1\n  nums[(2 * 2) + 1 = 5] = nums[2] + nums[3] = 1 + 2 = 3\n  nums[(3 * 2) = 6] = nums[3] = 2\n  nums[(3 * 2) + 1 = 7] = nums[3] + nums[4] = 2 + 1 = 3\n因此,nums = [0,1,1,2,1,3,2,3],最大值 3\n```\n示例 2:\n```\n输入:n = 2\n\n输出:1\n\n解释:根据规则,nums[0]、nums[1] 和 nums[2] 之中的最大值是 1\n```\n示例 3:\n```\n输入:n = 3\n\n输出:2\n\n解释:根据规则,nums[0]、nums[1]、nums[2] 和 nums[3] 之中的最大值是 2\n```\n\n提示:\n* 0 <= n <= 100", "solution": "### 模拟\n\n按照题意模拟一遍,得到数列 $nums$,再从 $nums$ 中找出最大值即可。\n\n代码:\n```Java\nclass Solution {\n    public int getMaximumGenerated(int n) {\n        if (n == 0) return 0;\n        int[] nums = new int[n + 1];\n        nums[0] = 0;\n        nums[1] = 1;\n        for (int i = 0; i < n; i++) {\n            if (2 * i <= n) nums[2 * i] = nums[i];\n            if (2 * i + 1 <= n) nums[2 * i + 1] = nums[i] + nums[i + 1];\n        }\n        int ans = 0;\n        for (int i : nums) ans = Math.max(ans, i);\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 打表 \n\n利用数据范围,可以直接使用 `static` 进行打表构造。\n\n代码:\n```Java\nclass Solution {\n    static int N = 110;\n    static int[] nums = new int[N];\n    static {\n        nums[0] = 0;\n        nums[1] = 1;\n        for (int i = 0; i < N; i++) {\n            if (2 * i < N) nums[2 * i] = nums[i];\n            if (2 * i + 1 < N) nums[2 * i + 1] = nums[i] + nums[i + 1];\n        }\n        for (int i = 0, max = 0; i < N; i++) {\n            nums[i] = max = Math.max(max, nums[i]);\n        }\n    }\n    public int getMaximumGenerated(int n) {\n        return nums[n];       \n    }\n}\n```\n* 时间复杂度:将打表逻辑放到本地进行,复杂度为 $O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1646` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1651-1660/1652. 拆炸弹（简单）.md", "url_title": "1652. 拆炸弹", "url": "https://leetcode.cn/problems/defuse-the-bomb/solution/by-ac_oier-osbg/", "difficulty": "简单", "tags": ["模拟", "前缀和"], "question": "你有一个炸弹需要拆除,时间紧迫!\n\n你的情报员会给你一个长度为 `n` 的 循环 数组 `code` 以及一个密钥 `k` 。\n\n为了获得正确的密码,你需要替换掉每一个数字。所有数字会 同时 被替换。\n\n* 如果 $k > 0$,将第 `i` 个数字用 接下来 `k` 个数字之和替换。\n* 如果 $k < 0$,将第 `i` 个数字用 之前 `k` 个数字之和替换。\n* 如果 $k = 0$,将第 `i` 个数字用 `0` 替换。\n\n由于 `code` 是循环的, `code[n-1]` 下一个元素是 `code[0]` ,且 `code[0]` 前一个元素是 `code[n-1]` 。\n\n给你 循环 数组 `code` 和整数密钥 `k` ,请你返回解密后的结果来拆除炸弹!\n\n示例 1:\n```\n输入:code = [5,7,1,4], k = 3\n\n输出:[12,10,16,13]\n\n解释:每个数字都被接下来 3 个数字之和替换。解密后的密码为 [7+1+4, 1+4+5, 4+5+7, 5+7+1]。注意到数组是循环连接的。\n```\n示例 2:\n```\n输入:code = [1,2,3,4], k = 0\n\n输出:[0,0,0,0]\n\n解释:当 k 为 0 时,所有数字都被 0 替换。\n```\n示例 3:\n```\n输入:code = [2,4,9,3], k = -2\n\n输出:[12,5,6,13]\n\n解释:解密后的密码为 [3+9, 2+3, 4+2, 9+4] 。注意到数组是循环连接的。如果 k 是负数,那么和为 之前 的数字。\n```\n\n提示:\n* $n = code.length$\n* $1 <= n <= 100$\n* $1 <= code[i] <= 100$\n* $-(n - 1) <= k <= n - 1$", "solution": "### 前缀和\n\n根据题意 `code` 为循环数组,我们可以建立一个长度为 $2 \\times n$ 的前缀和数组(为了方便,我们令前缀和数组下标从 $1$ 开始),利用前缀和数组来构建答案。\n\n对于每一位 $ans[i - 1]$ 而言(其中 $i$ 的取值范围为 $[1, n]$),我们根据 `k` 值的正负情况来决定取自前缀和数组中的哪一段:\n\n* 若有 $k < 0$:需要取位置 $i$ 前的 $-k$ 个数,为防止下越界标,先将位置 $i$ 往后进行 $n$ 个偏移(即位置 $i + n$),随后可知对应区间 $[i + n + k, i + n - 1]$,对应区间和为 $sum[i + n - 1] - sum[i + n + k - 1]$\n\n* 若有 $k > 0$:需要取位置 $i$ 后的 $k$ 个数,对应前缀和数组下标 $[i + 1, i + k]$,对应区间和为 $sum[i + k] - sum[i]$\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] decrypt(int[] code, int k) {\n        int n = code.length;\n        int[] ans = new int[n];\n        if (k == 0) return ans;\n        int[] sum = new int[n * 2 + 10];\n        for (int i = 1; i <= 2 * n; i++) sum[i] += sum[i - 1] + code[(i - 1) % n];\n        for (int i = 1; i <= n; i++) {\n            if (k < 0) ans[i - 1] = sum[i + n - 1] - sum[i + n + k - 1];\n            else ans[i - 1] = sum[i + k] - sum[i];\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> decrypt(vector<int>& code, int k) {\n        int n = code.size();\n        vector<int> ans(n);\n        if (k == 0) return ans;\n        vector<long long> sum((n + 1) * 2, 0);\n        for (int i = 1; i <= 2 * n; ++i) sum[i] = sum[i - 1] + code[(i - 1) % n];\n        for (int i = 1; i <= n; ++i) {\n            if (k < 0) ans[i - 1] = sum[i + n - 1] - sum[i + n + k - 1];\n            else ans[i - 1] = sum[i + k] - sum[i]; \n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def decrypt(self, code: List[int], k: int) -> List[int]:\n        n = len(code)\n        ans = [0] * n\n        if k == 0:\n            return ans\n        sum = [0] * (2 * n + 10)\n        for i in range(1, 2 * n + 1):\n            sum[i] = sum[i - 1] + code[(i - 1) % n]\n        for i in range(1, n + 1):\n            if k < 0:\n                ans[i - 1] = sum[i + n - 1] - sum[i + n + k - 1]\n            else:\n                ans[i - 1] = sum[i + k] - sum[i]\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction decrypt(code: number[], k: number): number[] {\n    const n = code.length\n    const ans = new Array<number>(n).fill(0)\n    if (k == 0) return ans\n    const sum = new Array<number>(2 * n + 10).fill(0)\n    for (let i = 1; i <= 2 * n; i++) sum[i] = sum[i - 1] + code[(i - 1) % n]\n    for (let i = 1; i <= n; i++) {\n        if (k < 0) ans[i - 1] = sum[i + n - 1] - sum[i + n + k - 1]\n        else ans[i - 1] = sum[i + k] - sum[i]\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1652` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1651-1660/1656. 设计有序流（简单）.md", "url_title": "1656. 设计有序流", "url": "https://leetcode.cn/problems/design-an-ordered-stream/solution/by-ac_oier-5pe8/", "difficulty": "简单", "tags": ["模拟"], "question": "有 `n` 个 `(id, value)` 对,其中 `id` 是 `1` 到 `n` 之间的一个整数,`value` 是一个字符串。不存在 `id` 相同的两个 `(id, value)` 对。\n\n设计一个流,以任意顺序获取 `n` 个 `(id, value)` 对,并在多次调用时按 `id` 递增的顺序返回一些值。\n\n实现 `OrderedStream` 类:\n\n* `OrderedStream(int n)` 构造一个能接收 `n` 个值的流,并将当前指针 `ptr` 设为 `1` 。\n* `String[] insert(int id, String value)` 向流中存储新的 `(id, value)` 对。存储后:\n\t* 如果流存储有 `id = ptr` 的 `(id, value)` 对,则找出从 `id = ptr` 开始的 最长 `id` 连续递增序列 ,并 按顺序 返回与这些 `id` 关联的值的列表。然后,将 `ptr` 更新为最后那个  `id + 1` 。\n\t* 否则,返回一个空列表。\n\n示例:\n\n```\n输入\n[\"OrderedStream\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\"]\n[[5], [3, \"ccccc\"], [1, \"aaaaa\"], [2, \"bbbbb\"], [5, \"eeeee\"], [4, \"ddddd\"]]\n\n输出\n[null, [], [\"aaaaa\"], [\"bbbbb\", \"ccccc\"], [], [\"ddddd\", \"eeeee\"]]\n\n解释\nOrderedStream os= new OrderedStream(5);\nos.insert(3, \"ccccc\"); // 插入 (3, \"ccccc\"),返回 []\nos.insert(1, \"aaaaa\"); // 插入 (1, \"aaaaa\"),返回 [\"aaaaa\"]\nos.insert(2, \"bbbbb\"); // 插入 (2, \"bbbbb\"),返回 [\"bbbbb\", \"ccccc\"]\nos.insert(5, \"eeeee\"); // 插入 (5, \"eeeee\"),返回 []\nos.insert(4, \"ddddd\"); // 插入 (4, \"ddddd\"),返回 [\"ddddd\", \"eeeee\"]\n```\n\n提示:\n* $1 <= n <= 1000$\n* $1 <= id <= n$\n* $value.length = 5$\n* `value` 仅由小写字母组成\n* 每次调用 `insert` 都会使用一个唯一的 `id`\n* 恰好调用 `n` 次 `insert`", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\nJava 代码:\n```Java\nclass OrderedStream {\n    String[] ss = new String[1010];\n    int idx, n;\n    public OrderedStream(int _n) {\n        Arrays.fill(ss, \"\");\n        idx = 1; n = _n;\n    }\n    public List<String> insert(int key, String value) {\n        ss[key] = value;\n        List<String> ans = new ArrayList<>();\n        while (ss[idx].length() == 5) ans.add(ss[idx++]);\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nclass OrderedStream {\n    ss: string[]\n    idx: number; n: number;\n    constructor(_n: number) {\n        this.idx = 1; this.n = _n;\n        this.ss = new Array<string>(1010).fill(\"\")\n    }\n    insert(key: number, value: string): string[] {\n        this.ss[key] = value\n        const ans = new Array<string>()\n        while (this.ss[this.idx].length == 5) ans.push(this.ss[this.idx++])\n        return ans\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 加餐\n\n**加餐一道近期笔试题 : [近期面试原题(简单计算几何运用)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492965&idx=1&sn=d0f2b13578e8b61891fbd7f9d1693695)🎉 🎉**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1656` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1651-1660/1657. 确定两个字符串是否接近（中等）.md", "url_title": "1657. 确定两个字符串是否接近", "url": "https://leetcode.cn/problems/determine-if-two-strings-are-close/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-feae/", "difficulty": "中等", "tags": ["模拟"], "question": "如果可以使用以下操作从一个字符串得到另一个字符串,则认为两个字符串 接近 :\n\n* 操作 1:交换任意两个 现有 字符。\n\t* 例如,`abcde -> aecdb`\n\n* 操作 2:将一个 现有 字符的每次出现转换为另一个 现有 字符,并对另一个字符执行相同的操作。\n\t* 例如,`aacabb -> bbcbaa`(所有 `a` 转化为 `b` ,而所有的 `b` 转换为 `a`)\n\n你可以根据需要对任意一个字符串多次使用这两种操作。\n\n给你两个字符串,`word1` 和 `word2`。如果 `word1` 和 `word2` 接近 ,就返回 `true`;否则,返回 `false`。\n\n示例 1:\n```\n输入:word1 = \"abc\", word2 = \"bca\"\n\n输出:true\n\n解释:2 次操作从 word1 获得 word2 。\n执行操作 1:\"abc\" -> \"acb\"\n执行操作 1:\"acb\" -> \"bca\"\n```\n示例 2:\n```\n输入:word1 = \"a\", word2 = \"aa\"\n\n输出:false\n\n解释:不管执行多少次操作,都无法从 word1 得到 word2 ,反之亦然。\n```\n示例 3:\n```\n输入:word1 = \"cabbba\", word2 = \"abbccc\"\n\n输出:true\n\n解释:3 次操作从 word1 获得 word2 。\n执行操作 1:\"cabbba\" -> \"caabbb\"\n执行操作 2:\"caabbb\" -> \"baaccc\"\n执行操作 2:\"baaccc\" -> \"abbccc\"\n```\n示例 4:\n```\n输入:word1 = \"cabbba\", word2 = \"aabbss\"\n\n输出:false\n\n解释:不管执行多少次操作,都无法从 word1 得到 word2 ,反之亦然。\n```\n\n提示:\n* $1 <= word1.length, word2.length <= 10^5$\n* `word1` 和 `word2` 仅包含小写英文字母", "solution": "### 模拟\n\n两类操作都不会凭空产生或删除字符,而仅仅是对字符进行互换。\n\n由于操作 `1` 和 `2` 都不限次数,因此我们只需检查「字符种类是否相同」和「字符频次是否相等」,即可得出两字符串是否接近的结论。\n\n具体的,由于 `s1` 和 `s2` 都仅包含小写字母,因此可以创建两个大小为 `26` 的数组 `c1` 和 `c2` 分别对两字符串进行词频统计。\n\n随后进行合法性检查:\n\n1. 字符种类是否相同:若存在某个字符仅在 `s1` 或 `s2` 中出现过,两字符串必不接近,返回 `False`\n2. 字符频次是否相等:对 `c1` 和 `c2` 进行排序,并逐项检查,若存在 `c1[i] != c2[i]`,说明存在词频为 `c1[i]` 的字符种类数在 `s1` 和 `s2` 间并不相等,返回 `False`\n\n若上述两项检查无误,说明两字符串接近,返回 `True`。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean closeStrings(String s1, String s2) {\n        int[] c1 = new int[26], c2 = new int[26];\n        for (char c : s1.toCharArray()) c1[c - 'a']++;\n        for (char c : s2.toCharArray()) c2[c - 'a']++;\n        for (int i = 0; i < 26; i++) {\n            if (c1[i] + c2[i] == 0) continue;\n            if (c1[i] == 0 || c2[i] == 0) return false;\n        }\n        Arrays.sort(c1); Arrays.sort(c2);\n        for (int i = 0; i < 26; i++) {\n            if (c1[i] != c2[i]) return false;\n        }\n        return true;\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def closeStrings(self, s1: str, s2: str) -> bool:\n        c1, c2 = [0] * 26, [0] * 26\n        for c in s1:\n            c1[ord(c) - ord('a')] += 1\n        for c in s2:\n            c2[ord(c) - ord('a')] += 1\n        for i in range(26):\n            if c1[i] + c2[i] == 0:\n                continue\n            if c1[i] == 0 or c2[i] == 0:\n                return False\n        c1.sort()\n        c2.sort()\n        for i in range(26):\n            if c1[i] != c2[i]:\n                return False\n        return True\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool closeStrings(string s1, string s2) {\n        vector<int> c1(26, 0), c2(26, 0);\n        for (char c : s1) c1[c - 'a']++;\n        for (char c : s2) c2[c - 'a']++;\n        for (int i = 0; i < 26; i++) {\n            if (c1[i] + c2[i] == 0) continue;\n            if (c1[i] == 0 || c2[i] == 0) return false;\n        }\n        sort(c1.begin(), c1.end());\n        sort(c2.begin(), c2.end());\n        for (int i = 0; i < 26; i++) {\n            if (c1[i] != c2[i]) return false;\n        }\n        return true;\n    }\n};\n```\nTypeScirpt 代码:\n```TypeScript\nfunction closeStrings(s1: string, s2: string): boolean {\n    const c1: number[] = Array(26).fill(0);\n    const c2: number[] = Array(26).fill(0);\n    for (const c of s1) c1[c.charCodeAt(0) - 'a'.charCodeAt(0)]++;\n    for (const c of s2) c2[c.charCodeAt(0) - 'a'.charCodeAt(0)]++;\n    for (let i = 0; i < 26; i++) {\n        if (c1[i] + c2[i] === 0) continue;\n        if (c1[i] === 0 || c2[i] === 0) return false;\n    }\n    c1.sort((a, b) => a - b);\n    c2.sort((a, b) => a - b);\n    for (let i = 0; i < 26; i++) {\n        if (c1[i] !== c2[i]) return false;\n    }\n    return true;\n};\n```\n* 时间复杂度:统计词频复杂度为 $O(n + m)$;排序复杂度为 $O(C\\log{C})$,其中 $C = 26$ 为字符集大小,进行合法性检查复杂度为 $O(C)$。整体复杂度为 $O(n + m + C\\log{C})$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1657` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1661-1670/1662. 检查两个字符串数组是否相等（简单）.md", "url_title": "1662. 检查两个字符串数组是否相等", "url": "https://leetcode.cn/problems/check-if-two-string-arrays-are-equivalent/solution/by-ac_oier-h0l6/", "difficulty": "简单", "tags": ["模拟", "双指针"], "question": "给你两个字符串数组 `word1` 和 `word2`。如果两个数组表示的字符串相同,返回 `true` ;否则,返回 `false` 。\n\n数组表示的字符串 是由数组中的所有元素 按顺序 连接形成的字符串。\n\n示例 1:\n```\n输入:word1 = [\"ab\", \"c\"], word2 = [\"a\", \"bc\"]\n\n输出:true\n\n解释:\nword1 表示的字符串为 \"ab\" + \"c\" -> \"abc\"\nword2 表示的字符串为 \"a\" + \"bc\" -> \"abc\"\n两个字符串相同,返回 true\n```\n示例 2:\n```\n输入:word1 = [\"a\", \"cb\"], word2 = [\"ab\", \"c\"]\n\n输出:false\n```\n示例 3:\n```\n输入:word1  = [\"abc\", \"d\", \"defg\"], word2 = [\"abcddefg\"]\n\n输出:true\n```\n\n提示:\n* $1 <= word1.length, word2.length <= 10^3$\n* $1 <= word1[i].length, word2[i].length <= 10^3$\n* $1 <= sum(word1[i].length), sum(word2[i].length) <= 10^3$\n* `word1[i]` 和 `word2[i]` 由小写字母组成", "solution": "### 双指针\n\n将 `word1` 和 `word2` 的长度记为 $n$ 和 $m$。\n\n题目本质是要我们比较两个数组扁平化后的字符串是否相同。\n\n使用变量 `i` 和 `j` 代表当前处理到哪个 $word1[i]$ 和 $word2[j]$,使用变量 `p` 和 `q` 代表当前比较到 $word1[i]$ 和 $word2[j]$ 的哪一位。\n\n最后根据是否能顺利比较完返回相应答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean arrayStringsAreEqual(String[] word1, String[] word2) {\n        int n = word1.length, m = word2.length;\n        int i = 0, j = 0, p = 0, q = 0;\n        while (i < n && j < m) {\n            if (word1[i].charAt(p++) != word2[j].charAt(q++)) return false;\n            if (p == word1[i].length()) {\n                i++; p = 0;\n            }\n            if (q == word2[j].length()) {\n                j++; q = 0;\n            }\n        }\n        return i == n && j == m;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction arrayStringsAreEqual(word1: string[], word2: string[]): boolean {\n    const n = word1.length, m = word2.length\n    let i = 0, j = 0, p = 0, q = 0\n    while (i < n && j < m) {\n        if (word1[i][p++] != word2[j][q++]) return false\n        if (p == word1[i].length) {\n            i++; p = 0\n        }\n        if (q == word2[j].length) {\n            j++; q = 0\n        }\n    }\n    return i == n && j == m\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def arrayStringsAreEqual(self, word1: List[str], word2: List[str]) -> bool:\n        n, m = len(word1), len(word2)\n        i, j, p, q = 0, 0, 0, 0\n        while i < n and j < m:\n            if word1[i][p] != word2[j][q]:\n                return False\n            p, q = p + 1, q + 1\n            if p == len(word1[i]):\n                i, p = i + 1, 0\n            if q == len(word2[j]):\n                j, q = j + 1, 0\n        return i == n and j == m\n```\n* 时间复杂度:$O(\\sum_{i = 0}^{n - 1}word1[i].length + \\sum_{j = 0}^{m - 1}word2[j].length)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1662` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1661-1670/1668. 最大重复子字符串（简单）.md", "url_title": "1668. 最大重复子字符串", "url": "https://leetcode.cn/problems/maximum-repeating-substring/solution/by-ac_oier-xjhn/", "difficulty": "简单", "tags": ["动态规划", "序列 DP", "字符串哈希"], "question": "给你一个字符串 `sequence`,如果字符串 `word` 连续重复 `k` 次形成的字符串是 `sequence` 的一个子字符串,那么单词 `word` 的 重复值为 `k` 。\n\n单词 `word` 的 最大重复值 是单词 `word` 在 `sequence` 中最大的重复值。如果 `word` 不是 `sequence` 的子串,那么重复值 `k` 为 `0` 。\n\n给你一个字符串 `sequence` 和 `word` ,请你返回 最大重复值 `k` 。\n\n示例 1:\n```\n输入:sequence = \"ababc\", word = \"ab\"\n\n输出:2\n\n解释:\"abab\" 是 \"ababc\" 的子字符串。\n```\n示例 2:\n```\n输入:sequence = \"ababc\", word = \"ba\"\n\n输出:1\n\n解释:\"ba\" 是 \"ababc\" 的子字符串,但 \"baba\" 不是 \"ababc\" 的子字符串。\n```\n示例 3:\n```\n输入:sequence = \"ababc\", word = \"ac\"\n\n输出:0\n\n解释:\"ac\" 不是 \"ababc\" 的子字符串。\n```\n\n提示:\n* $1 <= sequence.length <= 100$\n* $1 <= word.length <= 100$\n* `sequence` 和 `word` 都只包含小写英文字母。", "solution": "### 序列 DP\n\n为了方便,我们记 `sequence` 为 `ss`,记 `word` 为 `pp`,将两者长度分别记为 `n` 和 `m`。\n\n同时我们调整「字符串」以及「将要用到的动规数组」的下标从 $1$ 开始。\n\n这是一道入门级的「序列 DP」运用题,容易想到 **定义 $f[i]$ 为了考虑以 `ss[i]` 结尾时的最大重复值**。\n\n不失一般性考虑 $f[i]$ 该如何转移:由于 `pp` 的长度已知,每次转移 $f[i]$ 时我们可以从 `ss` 中截取 **以 $ss[i]$ 为结尾,长度为 $m$ 的后缀字符串** `sub` 并与 `pp` 匹配,若两者相等,说明 `sub` 贡献了大小为 $1$ 的重复度,同时该重复度可累加在 $f[i - m]$ 上(好好回想我们的状态定义),即有状态转移方程:$f[i] = f[i - m] + 1$。\n\n最终所有 $f[i]$ 的最大值即为答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxRepeating(String ss, String pp) {\n        int n = ss.length(), m = pp.length(), ans = 0;\n        int[] f = new int[n + 10];\n        for (int i = 1; i <= n; i++) {\n            if (i - m < 0) continue;\n            if (ss.substring(i - m, i).equals(pp)) f[i] = f[i - m] + 1;\n            ans = Math.max(ans, f[i]);\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction maxRepeating(ss: string, pp: string): number {\n    let n = ss.length, m = pp.length, ans = 0\n    const f = new Array<number>(n + 10).fill(0)\n    for (let i = 1; i <= n; i++) {\n        if (i - m < 0) continue\n        if (ss.substr(i - m, i) == pp) f[i] = f[i - m] + 1\n        ans = Math.max(ans, f[i])\n    }\n    return ans\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxRepeating(self, ss: str, pp: str) -> int:\n        n, m, ans = len(ss), len(pp), 0\n        f = [0] * (n + 10)\n        for i in range(1, n + 1):\n            if i - m < 0:\n                continue\n            if ss[i - m:i] == pp:\n                f[i] = f[i - m] + 1\n            ans = max(ans, f[i])\n        return ans\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 字符串哈希\n\n解法一的转移瓶颈在于:每次需要花费 $O(m)$ 的复杂度来生成子串,并进行字符串比较。\n\n该过程可用「字符串哈希」进行优化:将 `ss` 和 `pp` 进行拼接得到完整字符串,并计算完整字符串的哈希数组和次方数组。随后从前往后检查 `ss`,若「某个以 $ss[i]$ 结尾长度为 `m` 的后缀字符串哈希值」与「 `pp` 字符串的哈希值」相等,说明找到了前驱状态值 $f[i - m]$,可进行转移。\n\n我们通过 $O(n + m)$ 复杂度预处理了字符串哈希,将转移过程中「复杂度为 $O(m)$ 的子串截取与字符串比较」替换成了「复杂度为 $O(1)$ 的数值对比」,整体复杂度从 $O(n \\times m)$ 下降到 $O(n + m)$。\n\n> **不了解「字符串哈希」的同学可见前置 🧀 : [字符串哈希入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489813&idx=1&sn=7f3bc18ca390d85b17655f7164d8e660)。里面详解字符串哈希基本原理以及哈希冲突简单处理方式**\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxRepeating(String ss, String pp) {\n        int n = ss.length(), m = pp.length(), ans = 0;\n        int[] f = new int[n + 10];\n\n        String s = ss + pp;\n        int P = 1313131, N = s.length();\n        long[] h = new long[N + 10], p = new long[N + 10];\n        p[0] = 1;\n        for (int i = 1; i <= N; i++) {\n            h[i] = h[i - 1] * P + s.charAt(i - 1);\n            p[i] = p[i - 1] * P;\n        }\n        long phash = h[N] - h[N - m] * p[m];\n        \n        for (int i = 1; i <= n; i++) {\n            if (i - m < 0) continue;\n            long cur = h[i] - h[i - m] * p[m];\n            if (cur == phash) f[i] = f[i - m] + 1;\n            ans = Math.max(ans, f[i]);\n        }\n        return ans;\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxRepeating(self, ss: str, pp: str) -> int:\n        n, m, ans = len(ss), len(pp), 0\n        f = [0] * (n + 10)\n\n        s = ss + pp\n        P, N, MOD = 131, len(s), 987654321\n        h, p = [0] * (N + 10), [0] * (N + 10)\n        p[0] = 1\n        for i in range(1, N + 1):\n            h[i] = (h[i - 1] * P + ord(s[i - 1])) % MOD\n            p[i] = (p[i - 1] * P) % MOD\n        phash = (h[N] - h[N - m] * p[m]) % MOD\n\n        for i in range(1, n + 1):\n            if i - m < 0:\n                continue\n            cur = (h[i] - h[i - m] * p[m]) % MOD\n            if cur == phash:\n                f[i] = f[i - m] + 1\n            ans = max(ans, f[i])\n        return ans\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### 总结\n\n这里简单说下「线性 DP」和「序列 DP」的区别。\n\n线性 DP 通常强调「状态转移所依赖的前驱状态」是由给定数组所提供的,即拓扑序是由原数组直接给出。更大白话来说就是通常有 $f[i][...]$ 依赖于 $f[i - 1][...]$。\n\n这就限定了线性 DP 的复杂度是简单由「状态数量(或者说是维度数)」所决定。\n\n序列 DP 通常需要结合题意来寻找前驱状态,即需要自身寻找拓扑序关系(例如本题,需要自己结合题意来找到可转移的前驱状态 $f[i - m]$)。\n\n这就限定了序列 DP 的复杂度是由「状态数 + 找前驱」的复杂度所共同决定。也直接导致了序列 DP 有很多玩法,往往能够结合其他知识点出题,来优化找前驱这一操作,通常是利用某些性质,或是利用数据结构进行优化。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1668` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1661-1670/1669. 合并两个链表（中等）.md", "url_title": "1669. 合并两个链表", "url": "https://leetcode.cn/problems/merge-in-between-linked-lists/solutions/2538688/gong-shui-san-xie-jian-dan-lian-biao-ti-4k20i/", "difficulty": "中等", "tags": ["链表"], "question": "给你两个链表 `list1` 和 `list2`,它们包含的元素分别为 `n` 个和 `m` 个。\n\n请你将 `list1` 中下标从 `a` 到 `b` 的全部节点都删除,并将 `list2` 接在被删除节点的位置。\n\n下图中蓝色边和节点展示了操作后的结果:\n\n请你返回结果链表的头指针。\n\n示例 1:\n\n```\n输入:list1 = [0,1,2,3,4,5], a = 3, b = 4, list2 = [1000000,1000001,1000002]\n\n输出:[0,1,2,1000000,1000001,1000002,5]\n\n解释:我们删除 list1 中下标为 3 和 4 的两个节点,并将 list2 接在该位置。上图中蓝色的边和节点为答案链表。\n```\n示例 2:\n\n```\n输入:list1 = [0,1,2,3,4,5,6], a = 2, b = 5, list2 = [1000000,1000001,1000002,1000003,1000004]\n\n输出:[0,1,1000000,1000001,1000002,1000003,1000004,6]\n\n解释:上图中蓝色的边和节点为答案链表。\n```\n\n提示:\n* $3 <= list1.length <= 10^4$\n* $1 <= a <= b < list1.length - 1$\n* $1 <= list2.length <= 10^4$", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n使用两个变量 `A` 和 `B` 分别指向 `list1` 中两个断联的位置,分别将 `A`  指向 `list2` 的开头,将 `list2` 的 `next` 指针指向 `B`。\n\nJava 代码:\n```Java \nclass Solution {\n    public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {\n        ListNode ans = list1;\n        ListNode A = null, B = null;\n        while (--a > 0 && --b > 0) list1 = list1.next;\n        A = list1;\n        while (b-- > 0) list1 = list1.next;\n        B = list1;\n        A.next = list2;\n        while (list2.next != null) list2 = list2.next;\n        list2.next = B.next;\n        return ans;\n    }\n} \n```\nTypeScript 代码:\n```TypeScript \nfunction mergeInBetween(list1: ListNode | null, a: number, b: number, list2: ListNode | null): ListNode | null {\n    const ans = list1\n    let A = null, B = null\n    while (--a > 0 && --b > 0) list1 = list1.next\n    A = list1\n    while (b-- > 0) list1 = list1.next\n    B = list1\n    A.next = list2\n    while (list2.next != null) list2 = list2.next\n    list2.next = B.next\n    return ans\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1699` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1661-1670/1670. 设计前中后队列（中等）.md", "url_title": "1670. 设计前中后队列", "url": "https://leetcode.cn/problems/design-front-middle-back-queue/solutions/2544779/gong-shui-san-xie-qing-xi-gao-xiao-de-qu-o0eq/", "difficulty": "中等", "tags": ["数据结构", "双端队列", "队列", "链表"], "question": "请你设计一个队列,支持在前,中,后三个位置的 `push` 和 `pop` 操作。\n\n请你完成 `FrontMiddleBack` 类:\n\n* `FrontMiddleBack()` 初始化队列。\n* `void pushFront(int val)` 将 `val` 添加到队列的 最前面 。\n* `void pushMiddle(int val)` 将 `val` 添加到队列的 正中间 。\n* `void pushBack(int val)` 将 `val` 添加到队里的 最后面 。\n* `int popFront()` 将最前面的元素从队列中删除并返回值,如果删除之前队列为空,那么返回 `-1`。\n* `int popMiddle()` 将正中间的元素从队列中删除并返回值,如果删除之前队列为空,那么返回 `-1`。\n* `int popBack()` 将 最后面 的元素从队列中删除并返回值,如果删除之前队列为空,那么返回 `-1`。\n\n请注意当有 两个 中间位置的时候,选择靠前面的位置进行操作。比方说:\n\n* 将 `6` 添加到 `[1, 2, 3, 4, 5]` 的中间位置,结果数组为 `[1, 2, 6, 3, 4, 5]`。\n* 从 `[1, 2, 3, 4, 5, 6]` 的中间位置弹出元素,返回 `3`,数组变为 `[1, 2, 4, 5, 6]`。\n\n示例 1:\n```\n输入:\n[\"FrontMiddleBackQueue\", \"pushFront\", \"pushBack\", \"pushMiddle\", \"pushMiddle\", \"popFront\", \"popMiddle\", \"popMiddle\", \"popBack\", \"popFront\"]\n[[], [1], [2], [3], [4], [], [], [], [], []]\n\n输出:\n[null, null, null, null, null, 1, 3, 4, 2, -1]\n\n解释:\nFrontMiddleBackQueue q = new FrontMiddleBackQueue();\nq.pushFront(1);   // [1]\nq.pushBack(2);    // [1, 2]\nq.pushMiddle(3);  // [1, 3, 2]\nq.pushMiddle(4);  // [1, 4, 3, 2]\nq.popFront();     // 返回 1 -> [4, 3, 2]\nq.popMiddle();    // 返回 3 -> [4, 2]\nq.popMiddle();    // 返回 4 -> [2]\nq.popBack();      // 返回 2 -> []\nq.popFront();     // 返回 -1 -> [] (队列为空)\n```\n\n提示:\n* $1 <= val <= 10^9$\n* 最多调用 $1000$ 次 `pushFront`, `pushMiddle`, `pushBack`, `popFront`, `popMiddle` 和 `popBack`。", "solution": "### 双端队列\n\n只要求在头部或尾部高效插入/弹出元素的话,容易联想到双端队列。\n\n还需要考虑往中间插入/弹出元素的话,会想到使用两个双端队列。\n\n将两个双端队列分别称为 `l` 和 `r`,把 `l` 和 `r` 拼接起来就是完整元素列表:\n\n由于双端队列本身支持 $O(1)$ 首尾操作,问题的关键在于如何确保涉及 `Middle` 操作的高效性。\n\n我们可以设计一个 `update` 方法,用于确保两队列的相对平衡:\n\n* 当元素总个数为偶数时,确保两队列元素相等\n* 当元素总个数为奇数时,确保 `r` 队列比 `l` 队列元素多一个\n\n如此一来,当我们需要往 `Middle` 插入元素时,始终往 `l` 的尾部插入即可;而当需要读取 `Middle` 位置元素时,根据两队列的元素个数关系决定是从 `l` 的尾部还是从 `r` 的头部取元素。\n\n以下是对上述代码中几个操作的简短实现说明:\n\n* `pushFront`:将元素添加到 `l` 队列的头部,调用 `update` 保持队列平衡\n* `pushMiddle`:将元素添加到 `l` 队列的尾部,调用 `update` 保持队列平衡\n* `pushBack`:将元素添加到 `r` 队列的尾部,调用 `update` 保持队列平衡\n* `popFront`:若 `l` 队列不为空,从 `l` 队列的头部弹出一个元素;否则,从 `r` 队列的头部弹出一个元素(当且仅当元素个数为 $1$ 时,队列 `l` 为空,唯一元素在队列 `r` 中),调用 `update` 保持队列平衡\n* `popMiddle`:若 `l` 队列和 `r` 队列的大小相等,则从 `l` 队列的尾部弹出一个元素;否则,从 `r` 队列的头部弹出一个元素。调用 `update` 保持队列平衡\n* `popBack`:从 `r` 队列的尾部弹出一个元素,调用 `update` 保持队列平衡\n\n双端队列的实现,可通过「数组 + 首尾坐标指针」来实现。为方便大家理清脉络,先使用语言自带的 `Deque` 实现一版。\n\nJava 代码(`Deque` 版):\n```Java\nclass FrontMiddleBackQueue {\n    Deque<Integer> l = new ArrayDeque<>(1010), r = new ArrayDeque<>(1010);\n    public void pushFront(int val) {\n        l.addFirst(val);\n        update();\n    }\n    public void pushMiddle(int val) {\n        l.addLast(val);\n        update();\n    }\n    public void pushBack(int val) {\n        r.addLast(val);\n        update();\n    }\n    public int popFront() {\n        if (l.size() + r.size() == 0) return -1;\n        int ans = l.size() != 0 ? l.pollFirst() : r.pollFirst();\n        update();\n        return ans;\n    }\n    public int popMiddle() {\n        if (l.size() + r.size() == 0) return -1;\n        int ans = l.size() == r.size() ? l.pollLast() : r.pollFirst();\n        update();\n        return ans;\n    }\n    public int popBack() {\n        if (l.size() + r.size() == 0) return -1;\n        int ans = r.pollLast();\n        update();\n        return ans;\n    }\n    void update() {\n        while (l.size() > r.size()) r.addFirst(l.pollLast());\n        while (r.size() - l.size() > 1) l.addLast(r.pollFirst());\n    }\n}\n```\n\n看过 `Deque` 实现版本,考虑如何使用数组实现。\n\n各类操作的总调用次数最多为 $1000$ 次,我们可创建大小为 $2010$ 的数组,并从下标  $1010$(接近中间位置)开始进行存储,这样无论是从前还是往后存数都不会越界。\n\n使用 `lhe` 和 `lta` 代表队列 `l` 的头部和尾部坐标,使用 `rhe` 和 `rta` 代表队列 `r` 的头部和尾部坐标,所有坐标初始值均为 $1100$。\n\n需要注意的是,`ta`(无论是 `lta` 还是 `rta`)是严格指向尾部,因此如果要往尾部插数的话,需要先对指针自增(移到下一个空闲位置),再赋值;而 `he`(无论是 `lhe` 还是 `rhe`)是指向实际队列头部的前一位置,需要先赋值再前移。当 `he = ta` 代表队列为空。\n\nJava 代码(纯数组版):\n\n```Java\nclass FrontMiddleBackQueue {\n    int[] l = new int[2010], r = new int[2010];\n    int lhe = 1010, lta = 1010, rhe = 1010, rta = 1010;\n    public void pushFront(int val) {\n        l[lhe--] = val;\n        update();\n    }\n    public void pushMiddle(int val) {\n        l[++lta] = val;\n        update();\n    }\n    public void pushBack(int val) {\n        r[++rta] = val;\n        update();\n    }\n    public int popFront() {\n        if (getSize(lhe, lta) == 0 && getSize(rhe, rta) == 0) return -1;\n        int ans = getSize(lhe, lta) != 0 ? l[++lhe] : r[++rhe];\n        update();\n        return ans;\n    }\n    public int popMiddle() {\n        if (getSize(lhe, lta) + getSize(rhe, rta) == 0) return -1;\n        int ans = getSize(lhe, lta) == getSize(rhe, rta) ? l[lta--] : r[++rhe];\n        update();\n        return ans;\n    }\n    public int popBack() {\n        if (getSize(lhe, lta) == 0 && getSize(rhe, rta) == 0) return -1;\n        int ans = r[rta--];\n        update();\n        return ans;\n    }\n    int getSize(int he, int ta) {\n        return ta - he;\n    }\n    void update() {\n        while (getSize(lhe, lta) > getSize(rhe, rta)) r[rhe--] = l[lta--];\n        while (getSize(rhe, rta) - getSize(lhe, lta) > 1) l[++lta] = r[++rhe];\n    }\n}\n```\nC++ 代码:\n```C++\nclass FrontMiddleBackQueue {\npublic:\n    int l[2010], r[2010], lhe = 1010, lta = 1010, rhe = 1010, rta = 1010;\n    void pushFront(int val) {\n        l[lhe--] = val;\n        update();\n    }\n    void pushMiddle(int val) {\n        l[++lta] = val;\n        update();\n    }\n    void pushBack(int val) {\n        r[++rta] = val;\n        update();\n    }\n    int popFront() {\n        if (getSize(lhe, lta) == 0 && getSize(rhe, rta) == 0) return -1;\n        int ans = getSize(lhe, lta) != 0 ? l[++lhe] : r[++rhe];\n        update();\n        return ans;\n    }\n    int popMiddle() {\n        if (getSize(lhe, lta) == 0 && getSize(rhe, rta) == 0) return -1;\n        int ans = getSize(lhe, lta) == getSize(rhe, rta) ? l[lta--] : r[++rhe];\n        update();\n        return ans;\n    }\n    int popBack() {\n        if (getSize(lhe, lta) == 0 && getSize(rhe, rta) == 0) return -1;\n        int ans = r[rta--];\n        update();\n        return ans;\n    }\n    int getSize(int he, int ta) {\n        return ta - he;\n    }\n    void update() {\n        while (getSize(lhe, lta) > getSize(rhe, rta)) r[rhe--] = l[lta--];\n        while (getSize(rhe, rta) - getSize(lhe, lta) > 1) l[++lta] = r[++rhe];\n    }\n};\n```\nPython 代码:\n```Python\nclass FrontMiddleBackQueue:\n    def __init__(self):\n        self.l, self.r = [0] * 2010, [0] * 2010\n        self.r = [0] * 2010\n        self.lhe, self.lta, self.rhe, self.rta = 1010, 1010, 1010, 1010\n\n    def pushFront(self, val: int) -> None:\n        self.l[self.lhe] = val\n        self.lhe -= 1\n        self.update()\n\n    def pushMiddle(self, val: int) -> None:\n        self.lta += 1\n        self.l[self.lta] = val\n        self.update()\n\n    def pushBack(self, val: int) -> None:\n        self.rta += 1\n        self.r[self.rta] = val\n        self.update()\n\n    def popFront(self) -> int:\n        if self.getSize(self.lhe, self.lta) + self.getSize(self.rhe, self.rta) == 0:\n            return -1\n        if self.getSize(self.lhe, self.lta) != 0:\n            self.lhe += 1\n            ans = self.l[self.lhe]\n        else:\n            self.rhe += 1\n            ans = self.r[self.rhe]\n        self.update()\n        return ans\n\n    def popMiddle(self) -> int:\n        if self.getSize(self.lhe, self.lta) + self.getSize(self.rhe, self.rta) == 0:\n            return -1\n        if self.getSize(self.lhe, self.lta) == self.getSize(self.rhe, self.rta):\n            ans = self.l[self.lta]\n            self.lta -= 1\n        else:\n            self.rhe += 1\n            ans = self.r[self.rhe]\n        self.update()\n        return ans\n\n    def popBack(self) -> int:\n        if self.getSize(self.lhe, self.lta) + self.getSize(self.rhe, self.rta) == 0:\n            return -1\n        ans = self.r[self.rta]\n        self.rta -= 1\n        self.update()\n        return ans\n\n    def getSize(self, he: int, ta: int) -> int:\n        return ta - he\n\n    def update(self) -> None:\n        while self.getSize(self.lhe, self.lta) > self.getSize(self.rhe, self.rta):\n            self.r[self.rhe] = self.l[self.lta]\n            self.rhe -= 1\n            self.lta -= 1\n        while self.getSize(self.rhe, self.rta) - self.getSize(self.lhe, self.lta) > 1:\n            self.lta += 1\n            self.rhe += 1\n            self.l[self.lta] = self.r[self.rhe]\n```\nTypeScript 代码:\n```TypeScript\nclass FrontMiddleBackQueue {\n    private l: number[];\n    private r: number[];\n    private lhe: number;\n    private lta: number;\n    private rhe: number;\n    private rta: number;\n    constructor() {\n        this.l = Array(2010).fill(0), this.r = Array(2010).fill(0);\n        this.lhe = 1010, this.lta = 1010, this.rhe = 1010, this.rta = 1010;\n    }\n    pushFront(val: number): void {\n        this.l[this.lhe--] = val;\n        this.update();\n    }\n    pushMiddle(val: number): void {\n        this.l[++this.lta] = val;\n        this.update();\n    }\n    pushBack(val: number): void {\n        this.r[++this.rta] = val;\n        this.update();\n    }\n    popFront(): number {\n        if (this.getSize(this.lhe, this.lta) + this.getSize(this.rhe, this.rta) == 0) return -1;\n        const ans = this.getSize(this.lhe, this.lta) != 0 ? this.l[++this.lhe] : this.r[++this.rhe];\n        this.update();\n        return ans;\n    }\n    popMiddle(): number {\n        if (this.getSize(this.lhe, this.lta) + this.getSize(this.rhe, this.rta) == 0) return -1;\n        const ans = this.getSize(this.lhe, this.lta) == this.getSize(this.rhe, this.rta) ? this.l[this.lta--] : this.r[++this.rhe];\n        this.update();\n        return ans;\n    }\n    popBack(): number {\n        if (this.getSize(this.lhe, this.lta) + this.getSize(this.rhe, this.rta) == 0) return -1;\n        const ans = this.r[this.rta--];\n        this.update();\n        return ans;\n    }\n    private getSize(he: number, ta: number): number {\n        return ta - he;\n    }\n    private update(): void {\n        while (this.getSize(this.lhe, this.lta) > this.getSize(this.rhe, this.rta)) this.r[this.rhe--] = this.l[this.lta--];\n        while (this.getSize(this.rhe, this.rta) - this.getSize(this.lhe, this.lta) > 1) this.l[++this.lta] = this.r[++this.rhe];\n    }\n}\n```\n* 时间复杂度:所有操作复杂度均为 $O(1)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 进阶\n\n更进一步,使用双向链表并与实现 `update` 类似效果,维护 `Middle` 位置的元素节点,同样可实现 $O(1)$ 各项操作,你能完成吗?\n\n与纯数组版相比,使用链表好处在于可严格按需创建。\n\n```Java\nclass Node {\n    Node prev, next;\n    int val;\n    Node (int _val) {\n        val = _val;\n    }\n}\nclass FrontMiddleBackQueue {\n    Node he, ta, mid;\n    int lsz, rsz;\n    public FrontMiddleBackQueue() {\n        he = new Node(-1); ta = new Node(-1);\n        he.next = ta; ta.prev = he;\n        mid = ta;\n        lsz = rsz = 0;\n    }\n    public void pushFront(int val) {\n        Node cur = new Node(val);\n        cur.next = he.next;\n        cur.prev = he;\n        he.next.prev = cur;\n        he.next = cur;\n        lsz++;\n        update();\n    }\n    public void pushMiddle(int val) {\n        Node cur = new Node(val);\n        cur.next = mid;\n        cur.prev = mid.prev;\n        mid.prev.next = cur;\n        mid.prev = cur;\n        lsz++;\n        update();\n    }\n    public void pushBack(int val) {\n        Node cur = new Node(val);\n        cur.next = ta;\n        cur.prev = ta.prev;\n        ta.prev.next = cur;\n        ta.prev = cur;\n        rsz++;\n        update();\n    }\n    public int popFront() {\n        if (lsz + rsz == 0) return -1;\n        int ans = he.next.val;\n        he.next.next.prev = he;\n        he.next = he.next.next;\n        lsz--;\n        update();\n        return ans;\n    }\n    public int popMiddle() {\n        if (lsz + rsz == 0) return -1;\n        Node realMid = null;\n        if (lsz == rsz) {\n            realMid = mid.prev;\n            lsz--;\n        } else {\n            realMid = mid;\n            mid = mid.next;\n            rsz--;\n        }\n        int ans = realMid.val;\n        realMid.prev.next = realMid.next;\n        realMid.next.prev = realMid.prev;\n        realMid = realMid.next;\n        update();\n        return ans;\n    }\n    public int popBack() {\n        if (lsz + rsz == 0) return -1;\n        int ans = ta.prev.val;\n        ta.prev.prev.next = ta;\n        ta.prev = ta.prev.prev;\n        rsz--;\n        update();\n        return ans;\n    }\n    void update() {\n        while (lsz > rsz) {\n            mid = mid.prev;\n            lsz--; rsz++;\n        }\n        while (rsz - lsz > 1) {\n            mid = mid.next;\n            lsz++; rsz--;\n        }\n        if (lsz + rsz == 1) mid = ta.prev;\n        if (lsz + rsz == 0) mid = ta;\n    }\n}\n```", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1670` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1671-1680/1672. 最富有客户的资产总量（简单）.md", "url_title": "1672. 最富有客户的资产总量", "url": "https://leetcode-cn.com/problems/richest-customer-wealth/solution/by-ac_oier-ai19/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个 $m * n$ 的整数网格 `accounts`,其中 $accounts[i][j]$ 是第 $i$ 位客户在第 $j$ 家银行托管的资产数量。返回最富有客户所拥有的 资产总量 。\n\n客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。\n\n示例 1:\n```\n输入:accounts = [[1,2,3],[3,2,1]]\n\n输出:6\n\n解释:\n第 1 位客户的资产总量 = 1 + 2 + 3 = 6\n第 2 位客户的资产总量 = 3 + 2 + 1 = 6\n两位客户都是最富有的,资产总量都是 6 ,所以返回 6 。\n```\n示例 2:\n```\n输入:accounts = [[1,5],[7,3],[3,5]]\n\n输出:10\n\n解释:\n第 1 位客户的资产总量 = 6\n第 2 位客户的资产总量 = 10 \n第 3 位客户的资产总量 = 8\n第 2 位客户是最富有的,资产总量是 10\n```\n示例 3:\n```\n输入:accounts = [[2,8,7],[7,1,3],[1,9,5]]\n\n输出:17\n```\n\n提示:\n* $m == accounts.length$\n* $n == accounts[i].length$\n* $1 <= m, n <= 50$\n* $1 <= accounts[i][j] <= 100$", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n```Java\nclass Solution {\n    public int maximumWealth(int[][] accounts) {\n        int m = accounts.length, n = accounts[0].length, ans = 0;\n        for (int i = 0; i < m; i++) {\n            int cur = 0;\n            for (int j = 0; j < n; j++) cur += accounts[i][j];\n            ans = Math.max(ans, cur);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(m * n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1672` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1671-1680/1678. 设计 Goal 解析器（简单）.md", "url_title": "1678. 设计 Goal 解析器", "url": "https://leetcode.cn/problems/goal-parser-interpretation/solution/by-ac_oier-a00y/", "difficulty": "简单", "tags": ["模拟"], "question": "请你设计一个可以解释字符串 `command` 的 `Goal` 解析器 。\n\n`command` 由 `\"G\"`、`\"()\"` 或 `\"(al)\"` 按某种顺序组成。`Goal` 解析器会将 `\"G\"` 解释为字符串 `\"G\"`、`\"()\"` 解释为字符串 `\"o\"` ,`\"(al)\"` 解释为字符串 `\"al\"` 。\n\n然后,按原顺序将经解释得到的字符串连接成一个字符串。\n\n给你字符串 `command`,返回 `Goal` 解析器 对 `command` 的解释结果。\n\n示例 1:\n```\n输入:command = \"G()(al)\"\n\n输出:\"Goal\"\n\n解释:Goal 解析器解释命令的步骤如下所示:\nG -> G\n() -> o\n(al) -> al\n最后连接得到的结果是 \"Goal\"\n```\n示例 2:\n```\n输入:command = \"G()()()()(al)\"\n\n输出:\"Gooooal\"\n```\n示例 3:\n```\n输入:command = \"(al)G(al)()()G\"\n\n输出:\"alGalooG\"\n```\n\n提示:\n* $1 <= command.length <= 100$\n* `command` 由 `\"G\"`、`\"()\"` 或 `\"(al)\"` 按某种顺序组成", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public String interpret(String s) {\n        StringBuilder sb = new StringBuilder();\n        int n = s.length();\n        for (int i = 0; i < n; ) {\n            if (s.charAt(i) == 'G') {\n                sb.append('G'); i++;\n            } else if (i + 1 < n && s.charAt(i + 1) == ')') {\n                sb.append('o'); i += 2;\n            } else {\n                sb.append(\"al\"); i += 4;\n            }\n        }\n        return sb.toString();\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction interpret(s: string): string {\n    const n = s.length\n    let ans = ''\n    for (let i = 0; i < n; ) {\n        if (s[i] == 'G') {\n            ans += 'G'; i++\n        } else if (i + 1 < n && s[i + 1] == ')') {\n            ans += 'o'; i += 2\n        } else {\n            ans += 'al'; i += 4\n        }\n    }\n    return ans\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def interpret(self, s: str) -> str:\n        ans = ''\n        n, i = len(s), 0\n        while i < n:\n            if s[i] == 'G':\n                ans, i = ans + s[i], i + 1\n            elif i + 1 < n and s[i + 1] == ')':\n                ans, i = ans + 'o', i + 2\n            else:\n                ans, i = ans + 'al', i + 4\n        return ans\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1678` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1681-1690/1684. 统计一致字符串的数目（简单）.md", "url_title": "1684. 统计一致字符串的数目", "url": "https://leetcode.cn/problems/count-the-number-of-consistent-strings/solution/by-ac_oier-j2kj/", "difficulty": "简单", "tags": ["模拟", "位运算"], "question": "给你一个由不同字符组成的字符串 `allowed` 和一个字符串数组 `words`。如果一个字符串的每一个字符都在 `allowed` 中,就称这个字符串是 一致字符串 。\n\n请你返回 `words` 数组中 一致字符串 的数目。\n\n示例 1:\n```\n输入:allowed = \"ab\", words = [\"ad\",\"bd\",\"aaab\",\"baa\",\"badab\"]\n\n输出:2\n\n解释:字符串 \"aaab\" 和 \"baa\" 都是一致字符串,因为它们只包含字符 'a' 和 'b' 。\n```\n示例 2:\n```\n输入:allowed = \"abc\", words = [\"a\",\"b\",\"c\",\"ab\",\"ac\",\"bc\",\"abc\"]\n\n输出:7\n\n解释:所有字符串都是一致的。\n```\n示例 3:\n```\n输入:allowed = \"cad\", words = [\"cc\",\"acd\",\"b\",\"ba\",\"bac\",\"bad\",\"ac\",\"d\"]\n\n输出:4\n\n解释:字符串 \"cc\",\"acd\",\"ac\" 和 \"d\" 是一致字符串。\n```\n\n提示:\n* $1 <= words.length <= 10^4$\n* $1 <= allowed.length <= 26$\n* $1 <= words[i].length <= 10$\n* `allowed` 中的字符 互不相同 。\n* `words[i]` 和 `allowed` 只包含小写英文字母。", "solution": "### 模拟\n\n根据题意模拟即可:为了快速判断某个字符是否在 `allowed` 出现过,我们可以使用 `Set` 结构、定长数组或是一个 `int` 变量(搭配位运算)来对 `allowed` 中出现的字符进行转存。\n\n随后遍历所有的 $words[i]$,统计符合要求的字符串个数。\n\nJava 代码:\n```Java\nclass Solution {\n    public int countConsistentStrings(String allowed, String[] words) {\n        boolean[] hash = new boolean[26];\n        for (char c : allowed.toCharArray()) hash[c - 'a'] = true;\n        int ans = 0;\n        out:for (String s : words) {\n            for (char c : s.toCharArray()) {\n                if (!hash[c - 'a']) continue out;\n            }\n            ans++;\n        }\n        return ans;\n    }\n}\n```\nJava 代码:\n```Java\nclass Solution {\n    public int countConsistentStrings(String allowed, String[] words) {\n        int hash = 0, ans = 0;\n        for (char c : allowed.toCharArray()) hash |= (1 << (c - 'a'));\n        out:for (String s : words) {\n            for (char c : s.toCharArray()) {\n                if (((hash >> (c - 'a')) & 1) == 0) continue out;\n            }\n            ans++;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction countConsistentStrings(allowed: string, words: string[]): number {\n    const sset = new Set<string>()\n    for (const c of allowed) sset.add(c)\n    let ans = 0\n    out:for (const s of words) {\n        for (const c of s) {\n            if (!sset.has(c)) continue out\n        }\n        ans++\n    }\n    return ans\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction countConsistentStrings(allowed: string, words: string[]): number {\n    let hash = 0, ans = 0\n    for (const c of allowed) hash |= (1 << (c.charCodeAt(0) - 'a'.charCodeAt(0)))\n    out:for (const s of words) {\n        for (const c of s) {\n            if (((hash >> (c.charCodeAt(0) - 'a'.charCodeAt(0))) & 1) == 0) continue out\n        }\n        ans++\n    }\n    return ans\n}\n```\nPython3 代码:\n```Python3\nclass Solution:\n    def countConsistentStrings(self, allowed: str, words: List[str]) -> int:\n        sset = set([c for c in allowed])\n        ans = 0\n        for s in words:\n            ok = True\n            for c in s:\n                if c not in sset:\n                    ok = False\n                    break\n            ans += 1 if ok else 0\n        return ans\n```\nPython3 代码:\n```Python3\nclass Solution:\n    def countConsistentStrings(self, allowed: str, words: List[str]) -> int:\n        num, ans = 0, 0\n        for c in allowed:\n            num |= (1 << (ord(c) - ord('a')))\n        for s in words:\n            ok = True\n            for c in s:\n                if not (num >> (ord(c) - ord('a')) & 1):\n                    ok = False\n                    break\n            ans += 1 if ok else 0\n        return ans\n```\n* 时间复杂度:$O(m + \\sum_{i = 0}^{n - 1}words[i].length)$,其中 $m$ 为 `allowed` 长度,$n$ 为 `words` 长度\n* 空间复杂度:$O(m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1684` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1681-1690/1688. 比赛中的配对次数（简单）.md", "url_title": "1688. 比赛中的配对次数", "url": "https://leetcode-cn.com/problems/count-of-matches-in-tournament/solution/gong-shui-san-xie-jian-dan-nao-jin-ji-zh-cx7a/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个整数 `n` ,表示比赛中的队伍数。比赛遵循一种独特的赛制:\n\n* 如果当前队伍数是 偶数 ,那么每支队伍都会与另一支队伍配对。总共进行 `n / 2` 场比赛,且产生 `n / 2` 支队伍进入下一轮。\n* 如果当前队伍数为 奇数 ,那么将会随机轮空并晋级一支队伍,其余的队伍配对。总共进行 `(n - 1) / 2` 场比赛,且产生 `(n - 1) / 2 + 1` 支队伍进入下一轮。\n\n返回在比赛中进行的配对次数,直到决出获胜队伍为止。\n\n示例 1:\n```\n输入:n = 7\n\n输出:6\n\n解释:比赛详情:\n- 第 1 轮:队伍数 = 7 ,配对次数 = 3 ,4 支队伍晋级。\n- 第 2 轮:队伍数 = 4 ,配对次数 = 2 ,2 支队伍晋级。\n- 第 3 轮:队伍数 = 2 ,配对次数 = 1 ,决出 1 支获胜队伍。\n总配对次数 = 3 + 2 + 1 = 6\n```\n示例 2:\n```\n输入:n = 14\n\n输出:13\n\n解释:比赛详情:\n- 第 1 轮:队伍数 = 14 ,配对次数 = 7 ,7 支队伍晋级。\n- 第 2 轮:队伍数 = 7 ,配对次数 = 3 ,4 支队伍晋级。 \n- 第 3 轮:队伍数 = 4 ,配对次数 = 2 ,2 支队伍晋级。\n- 第 4 轮:队伍数 = 2 ,配对次数 = 1 ,决出 1 支获胜队伍。\n总配对次数 = 7 + 3 + 2 + 1 = 13\n```\n\n提示:\n* 1 <= n <= 200", "solution": "### 脑筋急转弯\n\n这个题不能浪费了,吃个鱼啥的吧 🤣 \n\n* [全鱼宴 I](https://leetcode-cn.com/problems/largest-number-at-least-twice-of-others/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-8179/)\n* [全鱼宴 II](https://leetcode-cn.com/problems/calculate-money-in-leetcode-bank/solution/quan-yu-yan-di-er-can-jian-dan-de-shu-xu-zux4/)\n\n共有 $n$ 支队伍,每场比赛淘汰一支,最终剩下一支冠军队,即有 $n - 1$ 支队伍需要通过 $n - 1$ 场比赛来被淘汰。\n\n**代码(感谢 [@5cm/s 🌸](/u/megurine/) 烟花总提供的所有语言版本 🤣 🤣 ):**\n```Java\nclass Solution {\n    public int numberOfMatches(int n) {\n        return n - 1;\n    }\n}\n```\n-\n```C++\nclass Solution {\npublic:\n    int numberOfMatches(int n) {\n        return n - 1;\n    }\n};\n```\n-\n```Python\nclass Solution(object):\n    def numberOfMatches(self, n):\n        return n - 1\n```\n-\n```Python3\nclass Solution:\n    def numberOfMatches(self, n: int) -> int:\n        return n - 1\n```\n-\n```C\nint numberOfMatches(int n){\n    return n - 1;\n}\n```\n-\n```C#\npublic class Solution {\n    public int NumberOfMatches(int n) {\n        return n - 1;\n    }\n}\n```\n-\n```JS\nvar numberOfMatches = function(n) {\n    return n - 1\n};\n```\n-\n```TS\nfunction numberOfMatches(n: number): number {\n    return n - 1\n};\n```\n-\n```Ruby\ndef number_of_matches(n)\n    n - 1\nend\n```\n-\n```Swift\nclass Solution {\n    func numberOfMatches(_ n: Int) -> Int {\n        return n - 1\n    }\n}\n```\n-\n```Go\nfunc numberOfMatches(n int) int {\n    return n - 1\n}\n```\n-\n```Scala\nobject Solution {\n    def numberOfMatches(n: Int): Int = {\n        return n - 1\n    }\n}\n```\n-\n```Kotlin\nclass Solution {\n    fun numberOfMatches(n: Int): Int {\n        return n - 1\n    }\n}\n```\n-\n```Rust\nimpl Solution {\n    pub fn number_of_matches(n: i32) -> i32 {\n        n - 1\n    }\n}\n```\n-\n```PHP\nclass Solution {\n    function numberOfMatches($n) {\n        return $n - 1;\n    }\n}\n```\n-\n```Racket\n(define/contract (number-of-matches n)\n  (-> exact-integer? exact-integer?)\n    (- n 1)\n  )\n```\n-\n```Erlang\n-spec number_of_matches(N :: integer()) -> integer().\nnumber_of_matches(N) ->\n  N - 1.\n```\n-\n```Elixir\ndefmodule Solution do\n  @spec number_of_matches(n :: integer) :: integer\n  def number_of_matches(n) do\n    n - 1\n  end\nend\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1688` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1691-1700/1691. 堆叠长方体的最大高度（困难）.md", "url_title": "1691. 堆叠长方体的最大高度", "url": "https://acoier.com/2022/12/10/1691.%20%E5%A0%86%E5%8F%A0%E9%95%BF%E6%96%B9%E4%BD%93%E7%9A%84%E6%9C%80%E5%A4%A7%E9%AB%98%E5%BA%A6%EF%BC%88%E5%9B%B0%E9%9A%BE%EF%BC%89/", "difficulty": "困难", "tags": ["排序", "序列 DP", "动态规划"], "question": "给你 `n` 个长方体 `cuboids`,其中第 `i` 个长方体的长宽高表示为 $cuboids[i] = [width_i, length_i, height_i]$(下标从 `0` 开始)。\n\n请你从 `cuboids` 选出一个「子集」,并将它们堆叠起来。\n\n如果 $width_{i} <= width_{j}$ 且 $length_{i} <= length_{j}$ 且 $height_{i} <= height_{j}$ ,你就可以将长方体 `i` 堆叠在长方体 `j` 上。你可以通过旋转把长方体的长宽高重新排列,以将它放在另一个长方体上。\n\n返回 堆叠长方体 `cuboids` 可以得到的 最大高度 。\n\n示例 1:\n\n```\n输入:cuboids = [[50,45,20],[95,37,53],[45,23,12]]\n\n输出:190\n\n解释:\n第 1 个长方体放在底部,53x37 的一面朝下,高度为 95 。\n第 0 个长方体放在中间,45x20 的一面朝下,高度为 50 。\n第 2 个长方体放在上面,23x12 的一面朝下,高度为 45 。\n总高度是 95 + 50 + 45 = 190 。\n```\n示例 2:\n```\n输入:cuboids = [[38,25,45],[76,35,3]]\n\n输出:76\n\n解释:\n无法将任何长方体放在另一个上面。\n选择第 1 个长方体然后旋转它,使 35x3 的一面朝下,其高度为 76 。\n```\n示例 3:\n```\n输入:cuboids = [[7,11,17],[7,17,11],[11,7,17],[11,17,7],[17,7,11],[17,11,7]]\n\n输出:102\n\n解释:\n重新排列长方体后,可以看到所有长方体的尺寸都相同。\n你可以把 11x7 的一面朝下,这样它们的高度就是 17 。\n堆叠长方体的最大高度为 6 * 17 = 102 。\n```\n\n提示:\n* $n = cuboids.length$\n* $1 <= n <= 100$\n* $1 <= width_{i}, length_{i}, height_{i} <= 100$", "solution": "### 排序 + 序列 DP\n\n定义 $f[i]$ 为考虑前 $i$ 个箱子,且必须使用到第 $i$ 个箱子的最大高度。\n\n不难发现,$f[i]$ 至少为当前箱子中的最大边长,而所有 $f[i]$ 的最大值即是答案。\n\n由于题目规定了只有三边都不超过盒子 `j` 的盒子 `i` 才能放置在上面,因此我们可以先对三边总和进行「降序」排序。\n\n这样当我们处理到盒子 `i` 时,所有能够位于盒子 `i` 底部的盒子 `j` 均位于 `i` 左侧,我们可以通过枚举 $j \\in [0, i - 1]$ 的盒子,用满足条件的盒子 `j` 来更新 $f[i]$,即有 $f[i] = \\max(f[j] + height_i)$。\n\n实现上,当我们在判定某个盒子 `j` 是否能够位于盒子 `i` 的底部时,并不需要枚举两盒子的旋转情况,可以在进行 DP 之前先对所有盒子进行排序预处理(按照升序排序)。\n\nJava 代码:\n```Java \nclass Solution {\n    public int maxHeight(int[][] cs) {\n        int n = cs.length;\n        for (int i = 0; i < n; i++) Arrays.sort(cs[i]);\n        Arrays.sort(cs, (a, b)->(b[0]+b[1]+b[2])-(a[0]+a[1]+a[2]));   \n        int ans = 0;\n        int[] f = new int[n + 10];\n        for (int i = 0; i < n; i++) {\n            f[i] = cs[i][2];\n            for (int j = 0; j < i; j++) {\n                if (cs[j][0] >= cs[i][0] && cs[j][1] >= cs[i][1] && cs[j][2] >= cs[i][2]) {\n                    f[i] = Math.max(f[i], f[j] + cs[i][2]);\n                }\n            }\n            ans = Math.max(ans, f[i]);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxHeight(vector<vector<int>>& cs) {\n        int n = cs.size();\n        for(int i = 0; i < n; i++) sort(cs[i].begin(), cs[i].end());\n        sort(cs.begin(), cs.end(), [](vector<int>& a, vector<int>& b){\n            return a[0] + a[1] + a[2] > b[0] + b[1] + b[2];\n        });\n        vector<int> f(n + 10, 0);\n        int ans = 0;\n        for(int i = 0; i < n; i++) {\n            f[i] = cs[i][2];\n            for(int j = 0; j < i; j++) {\n                if(cs[j][0] >= cs[i][0] && cs[j][1] >= cs[i][1] && cs[j][2] >= cs[i][2]) {\n                    f[i] = max(f[i], f[j] + cs[i][2]);\n                }\n            }\n            ans = max(ans, f[i]);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxHeight(self, cs):\n        n = len(cs)\n        for i in range(n):\n            cs[i].sort()\n        cs.sort(key=lambda x: -(x[0]+x[1]+x[2]))\n        f, ans = [0] * (n+10), 0\n        for i in range(n):\n            f[i] = cs[i][2]\n            for j in range(i):\n                if cs[j][0] >= cs[i][0] and cs[j][1] >= cs[i][1] and cs[j][2] >= cs[i][2]:\n                    f[i] = max(f[i], f[j] + cs[i][2])\n            ans = max(ans, f[i])\n        return ans\n```\nTypeScript 代码:\n```TypeScript \nfunction maxHeight(cs: number[][]): number {\n    const n = cs.length;\n    for (let i = 0; i < n; i++) cs[i].sort((a, b) => a-b);\n    cs.sort((a, b) => (b[0] + b[1] + b[2]) - (a[0] + a[1] + a[2]));\n    const f: number[] = new Array(n + 10).fill(0);\n    let ans = 0;\n    for (let i = 0; i < n; i++) {\n        f[i] = cs[i][2];\n        for (let j = 0; j < i; j++) {\n            if (cs[j][0] >= cs[i][0] && cs[j][1] >= cs[i][1] && cs[j][2] >= cs[i][2]) {\n                f[i] = Math.max(f[i], f[j] + cs[i][2]);\n            }\n        }\n        ans = Math.max(ans, f[i]);\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1691` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1691-1700/1694. 重新格式化电话号码（简单）.md", "url_title": "1694. 重新格式化电话号码", "url": "https://leetcode.cn/problems/reformat-phone-number/solution/by-ac_oier-82xq/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个字符串形式的电话号码 `number`。`number` 由数字、空格 `' '`、和破折号 `'-'` 组成。\n\n请你按下述方式重新格式化电话号码。\n\n首先,删除 所有的空格和破折号。\n\n其次,将数组从左到右 每 `3` 个一组 分块,直到 剩下 `4` 个或更少数字。剩下的数字将按下述规定再分块:\n* `2` 个数字:单个含 `2` 个数字的块。\n* `3` 个数字:单个含 `3` 个数字的块。\n* `4` 个数字:两个分别含 `2` 个数字的块。\n\n最后用破折号将这些块连接起来。注意,重新格式化过程中 不应该 生成仅含 `1` 个数字的块,并且 最多 生成两个含 `2` 个数字的块。\n\n返回格式化后的电话号码。\n\n示例 1:\n```\n输入:number = \"1-23-45 6\"\n\n输出:\"123-456\"\n\n解释:数字是 \"123456\"\n步骤 1:共有超过 4 个数字,所以先取 3 个数字分为一组。第 1 个块是 \"123\" 。\n步骤 2:剩下 3 个数字,将它们放入单个含 3 个数字的块。第 2 个块是 \"456\" 。\n连接这些块后得到 \"123-456\" 。\n```\n示例 2:\n```\n输入:number = \"123 4-567\"\n\n输出:\"123-45-67\"\n\n解释:数字是 \"1234567\".\n步骤 1:共有超过 4 个数字,所以先取 3 个数字分为一组。第 1 个块是 \"123\" 。\n步骤 2:剩下 4 个数字,所以将它们分成两个含 2 个数字的块。这 2 块分别是 \"45\" 和 \"67\" 。\n连接这些块后得到 \"123-45-67\" 。\n```\n示例 3:\n```\n输入:number = \"123 4-5678\"\n\n输出:\"123-456-78\"\n\n解释:数字是 \"12345678\" 。\n步骤 1:第 1 个块 \"123\" 。\n步骤 2:第 2 个块 \"456\" 。\n步骤 3:剩下 2 个数字,将它们放入单个含 2 个数字的块。第 3 个块是 \"78\" 。\n连接这些块后得到 \"123-456-78\" 。\n```\n示例 4:\n```\n输入:number = \"12\"\n\n输出:\"12\"\n```\n示例 5:\n```\n输入:number = \"--17-5 229 35-39475 \"\n\n输出:\"175-229-353-94-75\"\n```\n\n提示:\n* $2 <= number.length <= 100$\n* `number` 由数字和字符 `'-'` 及 `' '` 组成。\n* `number` 中至少含 `2` 个数字。", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public String reformatNumber(String number) {\n        String s = number.replace(\" \", \"\").replace(\"-\", \"\");\n        int n = s.length();\n        StringBuilder sb = new StringBuilder();\n        for (int i = 0; i < n; i += 3) {\n            if (sb.length() != 0) sb.append(\"-\");\n            if (i + 5 > n) {\n                if (i + 3 >= n) sb.append(s.substring(i));\n                else sb.append(s.substring(i, i + 2)).append(\"-\").append(s.substring(i + 2));\n                break;\n            }\n            sb.append(s.substring(i, i + 3));\n        }\n        return sb.toString();\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def reformatNumber(self, number: str) -> str:\n        s = number.replace(\" \", \"\").replace(\"-\", \"\")\n        n, idx = len(s), 0\n        ans = \"\"\n        while idx < n:\n            if ans:\n                ans += \"-\"\n            if idx + 5 > n:\n                ans += s[idx:] if idx + 3 >= n else f\"{s[idx:idx+2]}-{s[idx+2:]}\"\n                break\n            ans += s[idx:idx+3]\n            idx += 3\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction reformatNumber(number: string): string {\n    let s = \"\"\n    for (let c of number) {\n        if (c != \" \" && c != \"-\") s += c\n    }\n    const n = s.length\n    let ans = \"\"\n    for (let i = 0; i < n; i += 3) {\n        if (ans.length != 0) ans += \"-\"\n        if (i + 5 > n) {\n            if (i + 3 >= n) ans += s.substring(i)\n            else ans += s.substring(i, i + 2) + \"-\" + s.substring(i + 2)\n            break\n        }\n        ans += s.substring(i, i + 3)\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1694` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1691-1700/1697. 检查边长度限制的路径是否存在（困难）.md", "url_title": "1697. 检查边长度限制的路径是否存在", "url": "https://acoier.com/2022/12/14/1697.%20%E6%A3%80%E6%9F%A5%E8%BE%B9%E9%95%BF%E5%BA%A6%E9%99%90%E5%88%B6%E7%9A%84%E8%B7%AF%E5%BE%84%E6%98%AF%E5%90%A6%E5%AD%98%E5%9C%A8%EF%BC%88%E5%9B%B0%E9%9A%BE%EF%BC%89/", "difficulty": "困难", "tags": ["并查集", "排序", "双指针"], "question": "给你一个 `n` 个点组成的无向图边集 `edgeList`,其中 $edgeList[i] = [u_i, v_i, dis_i]$ 表示点 $u_i$ 和点 $v_i$ 之间有一条长度为 $dis_i$ 的边。请注意,两个点之间可能有 超过一条边 。\n\n给你一个查询数组 `queries`,其中 $queries[j] = [p_j, q_j, limit_j]$ ,你的任务是对于每个查询 $queries[j]$ ,判断是否存在从 $p_j$ 到 $q_j$ 的路径,且这条路径上的每一条边都 严格小于 $limit_j$ 。\n\n请你返回一个 布尔数组 `answer`,其中 `answer.length == queries.length`,当 $queries[j]$ 的查询结果为 `true` 时, `answer` 第 `j` 个值为 `true` ,否则为 `false` 。\n\n示例 1:\n\n```\n输入:n = 3, edgeList = [[0,1,2],[1,2,4],[2,0,8],[1,0,16]], queries = [[0,1,2],[0,2,5]]\n\n输出:[false,true]\n\n解释:上图为给定的输入数据。注意到 0 和 1 之间有两条重边,分别为 2 和 16 。\n对于第一个查询,0 和 1 之间没有小于 2 的边,所以我们返回 false 。\n对于第二个查询,有一条路径(0 -> 1 -> 2)两条边都小于 5 ,所以这个查询我们返回 true 。\n```\n示例 2:\n\n```\n输入:n = 5, edgeList = [[0,1,10],[1,2,5],[2,3,9],[3,4,13]], queries = [[0,4,14],[1,4,13]]\n\n输出:[true,false]\n\n解释:上图为给定数据。\n```\n\n提示:\n* $2 <= n <= 10^5$\n* $1 <= edgeList.length, queries.length <= 10^5$\n* $edgeList[i].length == 3$\n* $queries[j].length == 3$\n* $0 <= u_i, v_i, p_j, q_j <= n - 1$\n* $u_i != v_i$\n* $p_j != q_j$\n* $1 <= dis_i, limit_j <= 10^9$\n* 两个点之间可能有多条边。", "solution": "### 排序 + 并查集 + 双指针\n\n为了方便,我们将点数记为 `n`,边数记为 `m`,询问数量记为 `k`,将 `edgeList` 简化为 `es`,将 `queries` 简化为 `qs`。\n\n对于点边数量都在 $10^5$,同时询问次数也在 $10^5$ 的问题,不可能对于每个询问执行最短路算法,尤其还需考虑边权限制。\n\n**对于一个询问 $(a, b, limit)$ 而言,等价于问我们使用所有边权小于 `limit` 的边,能否使得 `a` 和 `b` 两点联通。**\n\n关于回答连通性问题,容易想到并查集。同时我们可以通过「调整回答询问的顺序」来降低复杂度(避免重复重置并查集和添加某些边),即转换为离线问题来处理。\n\n> 何为离线问题?预先知道所有询问,能够通过调整回答询问的顺序,来降低算法复杂度。同时不同询问相互独立,不会因为调整询问顺序,对每个询问的结果造成影响。例如莫队算法。\n\n具体的,我们可以对边集 `es` 和所有询问 `qs` 分别按照「边权」以及「限制」排升序。为了排序后,仍能知道当前询问的原编号,我们要将所有的 `qs[i]` 转换为四元组。\n\n随后从前往后处理每个询问 `qs[i] = (a, b, t, idx)`,同时使用变量 `j` 来记录当前处理到的边。在查询 `a` 和 `b` 是否连通前,先将边集 `es` 中所有所有边权小于 `t` 的边应用到并查集上,从而实现每次 `ans[idx] = query(a, b)` 查询到的是原图中所有边权小于限制值 `t` 的子图。\n\nJava 代码:\n```Java \nclass Solution {\n    static int N = 100010;\n    static int[] p = new int[N];\n    int find(int x) {\n        if (p[x] != x) p[x] = find(p[x]);\n        return p[x];\n    }\n    void union(int a, int b) {\n        p[find(a)] = p[find(b)];\n    }\n    boolean query(int a, int b) {\n        return find(a) == find(b);\n    }\n    public boolean[] distanceLimitedPathsExist(int n, int[][] es, int[][] _qs) {\n        for (int i = 0; i < n; i++) p[i] = i;\n        int m = es.length, k = _qs.length;\n        int[][] qs = new int[k][4];\n        for (int i = 0; i < k; i++) qs[i] = new int[]{_qs[i][0], _qs[i][1], _qs[i][2], i};\n        Arrays.sort(qs, (a,b)->a[2]-b[2]);\n        Arrays.sort(es, (a,b)->a[2]-b[2]);\n        boolean[] ans = new boolean[k];\n        for (int i = 0, j = 0; i < k; i++) {\n            int a = qs[i][0], b = qs[i][1], t = qs[i][2], idx = qs[i][3];\n            while (j < m && es[j][2] < t) {\n                union(es[j][0], es[j][1]);\n                j++;\n            }\n            ans[idx] = query(a, b);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int p[100010];\n    int find(int x) {\n        if (p[x] != x) p[x] = find(p[x]);\n        return p[x];\n    }\n    void unite(int a, int b) {\n        p[find(a)] = find(b);\n    }\n    bool query(int a, int b) {\n        return find(a) == find(b);\n    }\n    vector<bool> distanceLimitedPathsExist(int n, vector<vector<int>>& es, vector<vector<int>>& qs) {\n        for (int i = 0; i < n; i++) p[i] = i;\n        int m = es.size(), k = qs.size();\n        vector<vector<int>> qss(k, vector<int>(4, 0));\n        for (int i = 0; i < k; i++) qss[i] = {qs[i][0], qs[i][1], qs[i][2], i};\n        sort(qss.begin(), qss.end(), [](const vector<int>& a, const vector<int>& b) {\n            return a[2] < b[2];\n        });\n        sort(es.begin(), es.end(), [](const vector<int>& a, const vector<int>& b) {\n            return a[2] < b[2];\n        });\n        vector<bool> ans(k, false);\n        for (int i = 0, j = 0; i < k; i++) {\n            int a = qss[i][0], b = qss[i][1], t = qss[i][2], idx = qss[i][3];\n            while (j < m && es[j][2] < t) {\n                unite(es[j][0], es[j][1]);\n                j++;\n            }\n            ans[idx] = query(a, b);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def distanceLimitedPathsExist(self, n: int, es: List[List[int]], _qs: List[List[int]]) -> List[bool]:\n        p = [i for i in range(n)]\n        def find(x):\n            if p[x] != x:\n                p[x] = find(p[x])\n            return p[x]\n        def union(a, b):\n            p[find(a)] = p[find(b)]\n        def query(a, b):\n            return find(a) == find(b)\n        m, k = len(es), len(_qs)\n        qs = [(a, b, c, i) for i, (a, b, c) in enumerate(_qs)]\n        es.sort(key=lambda x: x[2])\n        qs.sort(key=lambda x: x[2])\n        j = 0\n        ans = [False] * k\n        for i in range(k):\n            a, b, t, idx = qs[i]\n            while j < m and es[j][2] < t:\n                union(es[j][0], es[j][1])\n                j += 1\n            ans[idx] = query(a, b)\n        return ans\n```\nTypeScript 代码:\n```TypeScript \nfunction distanceLimitedPathsExist(n: number, es: number[][], _qs: number[][]): boolean[] {\n    const p = new Array<number>(n).fill(0)\n    for (let i = 0; i < n; i++) p[i] = i;\n    function find(x: number): number {\n        if (p[x] != x) p[x] = find(p[x])\n        return p[x]\n    }\n    function union(a: number, b: number): void {\n        p[find(a)] = p[find(b)]\n    }\n    function query(a: number, b: number): boolean {\n        return find(a) == find(b)\n    }\n    const m = es.length, k = _qs.length\n    const qs = []\n    for (let i = 0; i < k; i++) qs.push([_qs[i][0], _qs[i][1], _qs[i][2], i])\n    qs.sort((a, b)=>a[2]-b[2])\n    es.sort((a, b)=>a[2]-b[2])\n    const ans = new Array<boolean>(k).fill(false)\n    for (let i = 0, j = 0; i < k; i++) {\n        const a = qs[i][0], b = qs[i][1], t = qs[i][2], idx = qs[i][3]\n        while (j < m && es[j][2] < t) {\n            union(es[j][0], es[j][1])\n            j++\n        }\n        ans[idx] = query(a, b)\n    }\n    return ans\n}\n```\n* 时间复杂度:初始化并查集的复杂度为 $O(n)$;对所有边进行排序复杂度为 $O(m\\log{m})$;对所有询问进行排序复杂度为 $O(k\\log{k})$;统计答案时使用双指针的方式将所有边运用到并查集上,整体复杂度为 $O(k + m)$。整体复杂度为 $O(n + m\\log{m} + k\\log{k})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1697` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1691-1700/1700. 无法吃午餐的学生数量（简单）.md", "url_title": "1700. 无法吃午餐的学生数量", "url": "https://leetcode.cn/problems/number-of-students-unable-to-eat-lunch/solution/by-ac_oier-rvc3/", "difficulty": "简单", "tags": ["模拟", "计数", "哈希表"], "question": "学校的自助午餐提供圆形和方形的三明治,分别用数字 $0$ 和 $1$ 表示。所有学生站在一个队列里,每个学生要么喜欢圆形的要么喜欢方形的。\n\n餐厅里三明治的数量与学生的数量相同。所有三明治都放在一个 栈 里,每一轮:\n\n* 如果队列最前面的学生 喜欢 栈顶的三明治,那么会 拿走它 并离开队列。\n* 否则,这名学生会 放弃这个三明治 并回到队列的尾部。\n\n这个过程会一直持续到队列里所有学生都不喜欢栈顶的三明治为止。\n\n给你两个整数数组 `students` 和 `sandwiches`,其中 `sandwiches[i]` 是栈里面第 `i` 个三明治的类型(`i = 0` 是栈的顶部), `students[j]` 是初始队列里第 `j` 名学生对三明治的喜好(`j = 0` 是队列的最开始位置)。请你返回无法吃午餐的学生数量。\n\n示例 1:\n```\n输入:students = [1,1,0,0], sandwiches = [0,1,0,1]\n\n输出:0 \n\n解释:\n- 最前面的学生放弃最顶上的三明治,并回到队列的末尾,学生队列变为 students = [1,0,0,1]。\n- 最前面的学生放弃最顶上的三明治,并回到队列的末尾,学生队列变为 students = [0,0,1,1]。\n- 最前面的学生拿走最顶上的三明治,剩余学生队列为 students = [0,1,1],三明治栈为 sandwiches = [1,0,1]。\n- 最前面的学生放弃最顶上的三明治,并回到队列的末尾,学生队列变为 students = [1,1,0]。\n- 最前面的学生拿走最顶上的三明治,剩余学生队列为 students = [1,0],三明治栈为 sandwiches = [0,1]。\n- 最前面的学生放弃最顶上的三明治,并回到队列的末尾,学生队列变为 students = [0,1]。\n- 最前面的学生拿走最顶上的三明治,剩余学生队列为 students = [1],三明治栈为 sandwiches = [1]。\n- 最前面的学生拿走最顶上的三明治,剩余学生队列为 students = [],三明治栈为 sandwiches = []。\n所以所有学生都有三明治吃。\n```\n示例 2:\n```\n输入:students = [1,1,1,0,0,1], sandwiches = [1,0,0,0,1,1]\n\n输出:3\n```\n\n提示:\n* $1 <= students.length, sandwiches.length <= 100$\n* $students.length == sandwiches.length$\n* `sandwiches[i]` 要么是 $0$ ,要么是 $1$ 。\n* `students[i]` 要么是 $0$ ,要么是 $1$ 。", "solution": "### 模拟\n\n根据题意进行模拟即可 : 当学生遇到喜欢的种类会进行匹配,否则会轮到队列尾部,而面包则是一直停在栈顶位置等待匹配。\n\n因此当且仅当栈顶的面包种类没有待匹配的学生种类与之相对应时,整个匹配过程结束。\n\nJava 代码:\n```Java\nclass Solution {\n    public int countStudents(int[] a, int[] b) {\n        int[] cnts = new int[2];\n        for (int x : a) cnts[x]++;\n        for (int i = 0; i < b.length; i++) {\n            if (--cnts[b[i]] == -1) return b.length - i;\n        }\n        return 0;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction countStudents(a: number[], b: number[]): number {\n    const cnts = new Array<number>(2).fill(0)\n    for (const x of a) cnts[x]++\n    for (let i = 0; i < b.length; i++) {\n        if (--cnts[b[i]] == -1) return b.length - i\n    }\n    return 0\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def countStudents(self, a: List[int], b: List[int]) -> int:\n        cnts = Counter(a)\n        for i, x in enumerate(b):\n            if cnts[x] == 0:\n                return len(b) - i\n            cnts[x] -= 1\n        return 0\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(C)$,其中 $C = 2$ 为种类数", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1700` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1701-1710/1704. 判断字符串的两半是否相似（简单）.md", "url_title": "1704. 判断字符串的两半是否相似", "url": "https://leetcode.cn/problems/determine-if-string-halves-are-alike/solution/by-ac_oier-u26p/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个偶数长度的字符串 `s` 。将其拆分成长度相同的两半,前一半为 `a` ,后一半为 `b` 。\n\n两个字符串 相似 的前提是它们都含有相同数目的元音`('a','e','i','o','u','A','E','I','O','U')`。注意,`s` 可能同时含有大写和小写字母。\n\n如果 `a` 和 `b` 相似,返回 `true`;否则,返回 `false` 。\n\n示例 1:\n```\n输入:s = \"book\"\n\n输出:true\n\n解释:a = \"bo\" 且 b = \"ok\" 。a 中有 1 个元音,b 也有 1 个元音。所以,a 和 b 相似。\n```\n示例 2:\n```\n输入:s = \"textbook\"\n\n输出:false\n\n解释:a = \"text\" 且 b = \"book\" 。a 中有 1 个元音,b 中有 2 个元音。因此,a 和 b 不相似。\n注意,元音 o 在 b 中出现两次,记为 2 个。\n```\n\n提示:\n* $2 <= s.length <= 1000$\n* `s.length` 是偶数\n* `s` 由 大写和小写 字母组成", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n为了快速判断某个字符是否为元音字母,起始先对所有元音字母进行转存。\n\n随后对 `s` 进行遍历,使用单个变量 `cnt` 记录元音字母数量。若当前遍历到的 `c` 所在下标属于前半部分,对 `cnt` 进行自增操作,若属于后半部分,对 `cnt` 进行自减操作。\n\n当处理完整个 `s` 后满足 `cnt = 0` 说明前半部分元音字母和后半部分元音字母数量相同。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean halvesAreAlike(String s) {\n        Set<Character> set = new HashSet<>();\n        for (char c : \"aeiouAEIOU\".toCharArray()) set.add(c);\n        int n = s.length(), cnt = 0;\n        for (int i = 0; i < n; i++) {\n            if (!set.contains(s.charAt(i))) continue;\n            cnt += i < n / 2 ? 1 : -1;\n        }\n        return cnt == 0;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction halvesAreAlike(s: string): boolean {\n    let n = s.length, cnt = 0\n    const set = new Set<String>()\n    for (const c of \"aeiouAEIOU\") set.add(c)\n    for (let i = 0; i < n; i++) {\n        if (!set.has(s[i])) continue\n        cnt += i < n / 2 ? 1 : -1\n    }\n    return cnt == 0\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def halvesAreAlike(self, s: str) -> bool:\n        cnt = 0\n        ss = set('aeiouAEIOU')\n        for idx, c in enumerate(s):\n            if c not in ss:\n                continue\n            cnt += 1 if idx < len(s) / 2 else -1\n        return cnt == 0\n```\n* 时间复杂度:$O(C + n)$,其中 $C$ 为元音字母数量\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1704` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1701-1710/1705. 吃苹果的最大数目（中等）.md", "url_title": "1705. 吃苹果的最大数目", "url": "https://leetcode-cn.com/problems/maximum-number-of-eaten-apples/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-hfdy0/", "difficulty": "中等", "tags": ["贪心", "优先队列(堆)"], "question": "有一棵特殊的苹果树,一连 `n` 天,每天都可以长出若干个苹果。\n\n在第 `i` 天,树上会长出 `apples[i]` 个苹果,这些苹果将会在 `days[i]` 天后(也就是说,第 `i + days[i]` 天时)腐烂,变得无法食用。\n\n也可能有那么几天,树上不会长出新的苹果,此时用 `apples[i] == 0` 且 `days[i] == 0` 表示。\n\n你打算每天 最多 吃一个苹果来保证营养均衡。注意,你可以在这 n 天之后继续吃苹果。\n\n给你两个长度为 `n` 的整数数组 `days` 和 `apples` ,返回你可以吃掉的苹果的最大数目。\n\n示例 1:\n```\n输入:apples = [1,2,3,5,2], days = [3,2,1,4,2]\n\n输出:7\n\n解释:你可以吃掉 7 个苹果:\n- 第一天,你吃掉第一天长出来的苹果。\n- 第二天,你吃掉一个第二天长出来的苹果。\n- 第三天,你吃掉一个第二天长出来的苹果。过了这一天,第三天长出来的苹果就已经腐烂了。\n- 第四天到第七天,你吃的都是第四天长出来的苹果。\n```\n示例 2:\n```\n输入:apples = [3,0,0,0,0,2], days = [3,0,0,0,0,2]\n\n输出:5\n\n解释:你可以吃掉 5 个苹果:\n- 第一天到第三天,你吃的都是第一天长出来的苹果。\n- 第四天和第五天不吃苹果。\n- 第六天和第七天,你吃的都是第六天长出来的苹果。\n```\n\n提示:\n* $apples.length == n$\n* $days.length == n$\n* $1 <= n <= 2 * 10^4$\n* $0 <= apples[i], days[i] <= 2 * 10^4$\n* 只有在 `apples[i] = 0` 时,`days[i] = 0` 才成立", "solution": "### 贪心 + 优先队列(堆)\n\n这题是一道经典的结合优先队列(堆)的贪心题,与结合排序的贪心题一样,属于最为常见的贪心题型。\n\n**直觉上,我们会觉得「优先吃掉最快过期的苹果」会是最优,而这个维护苹果过期的过程,可以使用「小根堆」来实现。**\n\n苹果数量很大,但产生苹果的天数最多为 $2 * 10^4$,因此我们以二元组 `(最后食用日期, 当日产生苹果数量)` 的形式存入「小根堆」进行维护。\n\n具体的,我们可以按照如下逻辑进行模拟(令 $n$ 为数组长度,$time$ 为当前时间,$ans$ 为吃到的苹果数量):\n\n* 首先,如果「$time < n$」或者「堆不为空」,说明「还有苹果未被生成」或者「未必吃掉」,继续模拟;\n* 在当日模拟中,如果「$time < n$」,说明当天有苹果生成,先将苹果 **以二元组 $(time + days[time] - 1, apples[time])$ 形式加入小根堆中**;\n  \n    > 其中二元组表示 $(最后食用日期, 当日产生苹果数量)$,同时需要过滤 $apples[time] = 0$ 的情况。\n* 然后尝试从堆中取出「最后食用日期」最早「可食用」的苹果 `cur`,如果堆顶元素已过期,则抛弃;\n* 如果吃掉 `cur` 一个苹果后,仍有剩余,并且最后时间大于当前时间(尚未过期),将 `cur` 重新入堆;\n* 循环上述逻辑,直到所有苹果出堆。\n\n**直观感受往往会骗人,我们使用「归纳法 + 反证法」证明上述猜想的正确性**\n\n假设使用上述吃法得到的苹果序列为 $(a_1, a_2, ... ,a_n)$,而真实最优解对应序列为 $(b_1, b_2, ..., b_m)$。\n\n我们目的是证明 $n = m$,即吃掉苹果数量一致(贪心解是最优解的具体方案之一)。\n\n起始,我们先证明边界成立,即 $b_1$ 可以为 $a_1$。\n\n首先该替换操作必然不会使最优序列变长,否则就违背了最优解是长度最长的合法序列这一前提。\n\n由于贪心解中每次总是取「过期时间最早的」苹果来吃,因此有 $a_1$ 过期时间小于等于 $b_1$ 过期时间,需要证明如果将最优解中的 $b_1$ 替换为 $a_1$,并不会影响整个序列的长度。\n\n重点在与该操作是否会使得最优序列长度变短,这需要分情况讨论:\n\n* $a_1$ 不存在与 $(b_2, b_3, ..., b_m)$ 当中,此时直接用 $a_1$ 替换 $b_1$ 自然不会对后面的序列产生影响,也就是说替换后,最优序列合法性仍有保证,同时长度不变,结果不会变差;\n\n* $a_1$ 为 $(b_2, b_3, ..., b_m)$ 中的某个,假设为 $b_i = a_1$,由于 $b_i/a_1$ 在贪心解中的先出堆(过期时间最早),因此必然也有 $b_i/a_1$ 过期时间早于等于 $b_1$ 的过期时间,此时将 $b_1$ 放到 $b_i$ 的位置仍是合法(过期时间比 $b_i/a_1$ 要晚),即将 $b_1$ 和 $b_i/a_1$ 交换位置,最优序列合法性仍有保证,同时长度不变,结果不会变差。\n\n当贪心解和最优解的首个位置决策相同(吃掉的苹果一样),下一位置决策所面临的条件完全相同,归纳推理所依赖的结构没有发生改变,上述分析同样成立。\n\n也就是说,上述推理可以推广到最优解序列中的任意位置。\n\n**至此,我们证明出了最优解可以调整为我们的贪心序列,同时长度不变,即贪心解为最优解的具体方案之一。**\n\n代码:\n```Java\nclass Solution {\n    public int eatenApples(int[] apples, int[] days) {\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[0]-b[0]);\n        int n = apples.length, time = 0, ans = 0;\n        while (time < n || !q.isEmpty()) {\n            if (time < n && apples[time] > 0) q.add(new int[]{time + days[time] - 1, apples[time]});\n            while (!q.isEmpty() && q.peek()[0] < time) q.poll();\n            if (!q.isEmpty()) {\n                int[] cur = q.poll();\n                if (--cur[1] > 0 && cur[0] > time) q.add(cur);\n                ans++;\n            }\n            time++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为数组长度,最多有 $n$ 组苹果入堆/出堆。复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1705` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1701-1710/1706. 球会落何处（中等）.md", "url_title": "1706. 球会落何处", "url": "https://leetcode-cn.com/problems/where-will-the-ball-fall/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-jz6f/", "difficulty": "中等", "tags": ["模拟"], "question": "用一个大小为 `m x n` 的二维网格 $grid$ 表示一个箱子。你有 $n$ 颗球。箱子的顶部和底部都是开着的。\n\n箱子中的每个单元格都有一个对角线挡板,跨过单元格的两个角,可以将球导向左侧或者右侧。\n\n* 将球导向右侧的挡板跨过左上角和右下角,在网格中用 $1$ 表示。\n* 将球导向左侧的挡板跨过右上角和左下角,在网格中用 $-1$ 表示。\n\n在箱子每一列的顶端各放一颗球。每颗球都可能卡在箱子里或从底部掉出来。如果球恰好卡在两块挡板之间的 `\"V\"` 形图案,或者被一块挡导向到箱子的任意一侧边上,就会卡住。\n\n返回一个大小为 $n$ 的数组 $answer$ ,其中 $answer[i]$ 是球放在顶部的第 $i$ 列后从底部掉出来的那一列对应的下标,如果球卡在盒子里,则返回 $-1$ 。\n\n示例 1:\n\n```\n输入:grid = [[1,1,1,-1,-1],[1,1,1,-1,-1],[-1,-1,-1,1,1],[1,1,1,1,-1],[-1,-1,-1,-1,-1]]\n\n输出:[1,-1,-1,-1,-1]\n\n解释:示例如图:\nb0 球开始放在第 0 列上,最终从箱子底部第 1 列掉出。\nb1 球开始放在第 1 列上,会卡在第 2、3 列和第 1 行之间的 \"V\" 形里。\nb2 球开始放在第 2 列上,会卡在第 2、3 列和第 0 行之间的 \"V\" 形里。\nb3 球开始放在第 3 列上,会卡在第 2、3 列和第 0 行之间的 \"V\" 形里。\nb4 球开始放在第 4 列上,会卡在第 2、3 列和第 1 行之间的 \"V\" 形里。\n```\n示例 2:\n```\n输入:grid = [[-1]]\n\n输出:[-1]\n\n解释:球被卡在箱子左侧边上。\n```\n示例 3:\n```\n输入:grid = [[1,1,1,1,1,1],[-1,-1,-1,-1,-1,-1],[1,1,1,1,1,1],[-1,-1,-1,-1,-1,-1]]\n\n输出:[0,1,2,3,4,-1]\n```\n\n提示:\n* $m == grid.length$\n* $n == grid[i].length$\n* $1 <= m, n <= 100$\n* $grid[i][j]$ 为 $1$ 或 $-1$", "solution": "### 模拟\n\n数据范围只有 $100$,直接模拟每个球从顶部的某列出发,最终到底底部哪列即可(如果可以到达的话)。\n\n我们使用 `r` 和 `c` 表示小球当前所处的位置,受重力影响,在不被卡住的情况下,`r` 会持续自增,直到到达底部,而 `c` 的变化,则是取决于当前挡板 `grid[r][c]` 的方向,若 `grid[r][c]` 为 $1$,则小球的下一个位置为 $(r + 1, c + 1)$;若 `grid[r][c]` 为 $-1$,则下一位置为 $(r + 1, c - 1)$,即可以统一表示为 $(r + 1, c + grid[r][c])$。当且仅当小球在本次移动过程中没被卡住,才能继续移动。即只有 $c + grid[r][c]$ 没有超过矩阵的左右边界(没有被边界卡住),或者 $grid[r][c]$ 和 $grid[r][c + grid[r][c]]$ 同向(不形成夹角),小球方能继续移动。\n\n代码:\n```Java\nclass Solution {\n    int m, n;\n    int[][] g;\n    public int[] findBall(int[][] grid) {\n        g = grid;\n        m = g.length; n = g[0].length;\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) ans[i] = getVal(i);\n        return ans;\n    }\n    int getVal(int x) {\n        int r = 0, c = x;\n        while (r < m) {\n            int ne = c + g[r][c];\n            if (ne < 0 || ne >= n) return -1;\n            if (g[r][c] != g[r][ne]) return -1;\n            r++; c = ne;\n        }\n        return c;\n    }\n}\n```\n* 时间复杂度:$O(m * n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1706` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1701-1710/1707. 与数组中元素的最大异或值（困难）.md", "url_title": "1707. 与数组中元素的最大异或值", "url": "https://leetcode-cn.com/problems/maximum-xor-with-an-element-from-array/solution/gong-shui-san-xie-jie-zhe-ge-wen-ti-lai-lypqr/", "difficulty": "困难", "tags": ["字典树", "二分"], "question": "给你一个由非负整数组成的数组 $nums$ 。另有一个查询数组 $queries$,其中 $queries[i] = [xi, mi]$ 。\n\n第 $i$ 个查询的答案是 $x_i$ 和任何 $nums$ 数组中不超过 $m_i$ 的元素按位异或(XOR)得到的最大值。\n\n换句话说,答案是 `max(nums[j] \\{XOR} x_i)` ,其中所有 $j$ 均满足 $nums[j] <= m_i$ 。如果 $nums$ 中的所有元素都大于 $m_i$,最终答案就是 $-1$ 。\n\n返回一个整数数组 $answer$ 作为查询的答案,其中 $answer.length == queries.length$ 且 $answer[i]$ 是第 $i$ 个查询的答案。\n\n示例 1:\n```\n输入:nums = [0,1,2,3,4], queries = [[3,1],[1,3],[5,6]]\n\n输出:[3,3,7]\n\n解释:\n1) 0 和 1 是仅有的两个不超过 1 的整数。0 XOR 3 = 3 而 1 XOR 3 = 2 。二者中的更大值是 3 。\n2) 1 XOR 2 = 3.\n3) 5 XOR 2 = 7.\n```\n示例 2:\n```\n输入:nums = [5,2,4,6,6,3], queries = [[12,4],[8,1],[6,3]]\n\n输出:[15,-1,5]\n```\n\n提示:\n* 1 <= nums.length, queries.length <= $10^5$\n* queries[i].length == 2\n* 0 <= nums[j], xi, mi <= $10^9$", "solution": "### 基本分析\n\n**在做本题之前,请先确保已经完成 [421. 数组中两个数的最大异或值](https://leetcode-cn.com/problems/maximum-xor-of-two-numbers-in-an-array/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-bmjdg/)。**\n\n这种提前给定了所有询问的题目,我们可以运用离线思想(调整询问的回答顺序)进行求解。\n\n对于本题有两种离线方式可以进行求解。\n\n---\n\n### 普通 Trie\n\n第一种方法基本思路是:**不一次性地放入所有数,而是每次将需要参与筛选的数字放入 $Trie$,再进行与 [421. 数组中两个数的最大异或值](https://leetcode-cn.com/problems/maximum-xor-of-two-numbers-in-an-array/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-bmjdg/) 类似的贪心查找逻辑。**\n\n具体的,我们可以按照下面的逻辑进行处理:\n\n1. 对 `nums` 进行「从小到大」进行排序,对 `queries` 的第二维进行「从小到大」排序(排序前先将询问原本的下标映射关系存下来)。\n2. 按照排序顺序处理所有的 `queries[i]`:\n    1. 在回答每个询问前,将小于等于 `queries[i][1]` 的数值存入 $Trie$。由于我们已经事先对 `nums` 进行排序,因此这个过程只需要维护一个在 `nums` 上有往右移动的指针即可。\n    2. 然后利用贪心思路,查询每个 `queries[i][0]` 所能找到的最大值是多少,计算异或和(此过程与 [421. 数组中两个数的最大异或值](https://leetcode-cn.com/problems/maximum-xor-of-two-numbers-in-an-array/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-bmjdg/) 一致)。\n    3. 找到当前询问在原询问序列的下标,将答案存入。\n\n代码:\n```Java\nclass Solution {\n    static int N = (int)1e5 * 32;\n    static int[][] trie = new int[N][2];\n    static int idx = 0;\n    public Solution() {\n        for (int i = 0; i <= idx; i++) {\n            Arrays.fill(trie[i], 0);\n        }\n        idx = 0;\n    }\n    void add(int x) {\n        int p = 0;\n        for (int i = 31; i >= 0; i--) {\n            int u = (x >> i) & 1;\n            if (trie[p][u] == 0) trie[p][u] = ++idx;\n            p = trie[p][u];\n        }\n    }\n    int getVal(int x) {\n        int ans = 0;\n        int p = 0;\n        for (int i = 31; i >= 0; i--) {\n            int a = (x >> i) & 1, b = 1 - a;\n            if (trie[p][b] != 0) {\n                p = trie[p][b];\n                ans = ans | (b << i);\n            } else {\n                p = trie[p][a];\n                ans = ans | (a << i);\n            } \n        }\n        return ans ^ x;\n    }\n    public int[] maximizeXor(int[] nums, int[][] qs) {\n        int m = nums.length, n = qs.length;\n\n        // 使用哈希表将原本的顺序保存下来\n        Map<int[], Integer> map = new HashMap<>();\n        for (int i = 0; i < n; i++) map.put(qs[i], i);\n\n        // 将 nums 与 queries[x][1] 进行「从小到大」进行排序\n        Arrays.sort(nums);\n        Arrays.sort(qs, (a, b)->a[1]-b[1]);\n\n        int[] ans = new int[n];\n        int loc = 0; // 记录 nums 中哪些位置之前的数已经放入 Trie\n        for (int[] q : qs) {\n            int x = q[0], limit = q[1];\n            // 将小于等于 limit 的数存入 Trie\n            while (loc < m && nums[loc] <= limit) add(nums[loc++]);\n            if (loc == 0) {\n                ans[map.get(q)] = -1;    \n            } else {\n                ans[map.get(q)] = getVal(x);    \n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 `nums` 的长度为 `m`,`qs` 的长度为 `n`。两者排序的复杂度为 $O(m\\log{m})$ 和 $O(n\\log{n})$;将所有数插入 $Trie$ 和从 $Trie$ 中查找的复杂度均为 $O(Len)$,$Len$ 为 $32$。\n整体复杂度为 $O(m\\log{m} + n\\log{n} + (m + n) * Len)$ = $O(m * \\max(\\log{m}, Len) + n * \\max(\\log{n}, Len))$。\n* 空间复杂度:$O(C)$。其中 $C$ 为常数,固定为 $1e5 * 32 * 2$。\n\n---\n\n### 计数 Trie & 二分\n\n另外一个比较「增加难度」的做法是,将整个过程翻转过来:**一次性存入所有的 $Trie$ 中,然后每次将不再参与的数从 $Trie$ 中移除。相比于解法一,这就要求我们为 $Trie$ 增加一个「删除/计数」功能,并且需要实现二分来找到移除元素的上界下标是多少。**\n\n具体的,我们可以按照下面的逻辑进行处理:\n\n1. 对 `nums` 进行「从大到小」进行排序,对 `queries` 的第二维进行「从大到小」排序(排序前先将询问原本的下标映射关系存下来)。\n2. 按照排序顺序处理所有的 `queries[i]`:\n    1. 在回答每个询问前,通过「二分」找到在 `nums` 中第一个满足「小于等于 `queries[i][1]` 的下标在哪」,然后将该下标之前的数从 $Trie$ 中移除。同理,这个过程我们需要使用一个指针来记录上一次删除的下标位置,避免重复删除。\n    2. 然后利用贪心思路,查询每个 `queries[i][0]` 所能找到的最大值是多少。注意这是要判断当前节点是否有被计数,如果没有则返回 $-1$。\n    3. 找到当前询问在原询问序列的下标,将答案存入。\n\n代码:\n```Java\nclass Solution {\n    static int N = (int)1e5 * 32;\n    static int[][] trie = new int[N][2];\n    static int[] cnt = new int[N];\n    static int idx = 0;\n    public Solution() {\n        for (int i = 0; i <= idx; i++) {\n            Arrays.fill(trie[i], 0);\n            cnt[i] = 0;\n        }\n        idx = 0;\n    }\n    // 往 Trie 存入(v = 1)/删除(v = -1) 某个数 x\n    void add(int x, int v) {\n        int p = 0;\n        for (int i = 31; i >= 0; i--) {\n            int u = (x >> i) & 1;\n            if (trie[p][u] == 0) trie[p][u] = ++idx;\n            p = trie[p][u];\n            cnt[p] += v;\n        }\n    }\n    int getVal(int x) {\n        int ans = 0;\n        int p = 0;\n        for (int i = 31; i >= 0; i--) {\n            int a = (x >> i) & 1, b = 1 - a;\n            if (cnt[trie[p][b]] != 0) {\n                p = trie[p][b];\n                ans = ans | (b << i);\n            } else if (cnt[trie[p][a]] != 0) {\n                p = trie[p][a];\n                ans = ans | (a << i);\n            } else {\n                return -1;\n            }\n        }\n        return ans ^ x;\n    }\n    public int[] maximizeXor(int[] nums, int[][] qs) {\n        int n = qs.length;\n        \n        // 使用哈希表将原本的顺序保存下来\n        Map<int[], Integer> map = new HashMap<>();\n        for (int i = 0; i < n; i++) map.put(qs[i], i);\n\n        // 对两者排降序\n        sort(nums);\n        Arrays.sort(qs, (a, b)->b[1]-a[1]);\n\n        // 将所有数存入 Trie\n        for (int i : nums) add(i, 1);\n\n        int[] ans = new int[n];\n        int left = -1; // 在 nums 中下标「小于等于」left 的值都已经从 Trie 中移除\n        for (int[] q : qs) {\n            int x = q[0], limit = q[1];\n            // 二分查找到待删除元素的右边界,将其右边界之前的所有值从 Trie 中移除。\n            int right = getRight(nums, limit);            \n            for (int i = left + 1; i < right; i++) add(nums[i], -1);\n            left = right - 1;\n            ans[map.get(q)] = getVal(x);\n        }\n        return ans;\n    }\n    // 二分找到待删除的右边界\n    int getRight(int[] nums, int limit) {\n        int l = 0, r = nums.length - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (nums[mid] <= limit) {\n                r = mid;\n            } else {\n                l = mid + 1;\n            }\n        }\n        return nums[r] <= limit ? r : r + 1;\n    }\n    // 对 nums 进行降序排序(Java 没有 Api 直接支持对基本类型 int 排倒序,其他语言可忽略)\n    void sort(int[] nums) {\n        Arrays.sort(nums);\n        int l = 0, r = nums.length - 1;\n        while (l < r) {\n            int c = nums[r];\n            nums[r--] = nums[l];\n            nums[l++] = c;\n        }\n    }\n}\n```\n* 时间复杂度:令 `nums` 的长度为 `m`,`qs` 的长度为 `n`,常数 $Len = 32$。两者排序的复杂度为 $O(m\\log{m})$ 和 $O(n\\log{n})$;将所有数插入 $Trie$ 的复杂度为 $O(m * Len)$;每个查询都需要经过「二分」找边界,复杂度为 $O(n\\log{m})$;最坏情况下所有数都会从 $Trie$ 中被标记删除,复杂度为 $O(m * Len)$。\n整体复杂度为 $O(m\\log{m} + n\\log{n} + n\\log{m} + mLen)$ = $O(m * \\max(\\log{m}, Len) + n * \\max(\\log{m}, \\log{n}))$。\n* 空间复杂度:$O(C)$。其中 $C$ 为常数,固定为 $1e5 * 32 * 3$。\n\n---\n\n### 说明\n\n这两种方法我都是采取「数组实现」,而且由于数据范围较大,都使用了 `static` 来优化大数组创建,具体的「优化原因」与「类实现 Trie 方式」可以在题解 [421. 数组中两个数的最大异或值](https://leetcode-cn.com/problems/maximum-xor-of-two-numbers-in-an-array/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-bmjdg/) 查看,这里不再赘述。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1707` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1701-1710/1710. 卡车上的最大单元数（简单）.md", "url_title": "1710. 卡车上的最大单元数", "url": "https://leetcode.cn/problems/maximum-units-on-a-truck/solution/by-ac_oier-5wlo/", "difficulty": "简单", "tags": ["贪心", "排序", "模拟"], "question": "请你将一些箱子装在 一辆卡车 上。给你一个二维数组 `boxTypes`,其中 $boxTypes[i] = [numberOfBoxes_i, numberOfUnitsPerBox_i]$ :\n\n* $numberOfBoxes_i$ 是类型 `i` 的箱子的数量。\n* $numberOfUnitsPerBox_i$ 是类型 `i` 每个箱子可以装载的单元数量。\n\n整数 `truckSize` 表示卡车上可以装载 箱子 的 最大数量 。只要箱子数量不超过 `truckSize`,你就可以选择任意箱子装到卡车上。\n\n返回卡车可以装载 单元 的 最大 总数。\n\n示例 1:\n```\n输入:boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4\n\n输出:8\n\n解释:箱子的情况如下:\n- 1 个第一类的箱子,里面含 3 个单元。\n- 2 个第二类的箱子,每个里面含 2 个单元。\n- 3 个第三类的箱子,每个里面含 1 个单元。\n可以选择第一类和第二类的所有箱子,以及第三类的一个箱子。\n单元总数 = (1 * 3) + (2 * 2) + (1 * 1) = 8\n```\n示例 2:\n```\n输入:boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10\n\n输出:91\n```\n\n提示:\n* $1 <= boxTypes.length <= 1000$\n* $1 <= numberOfBoxes_i, numberOfUnitsPerBox_i <= 1000$\n* $1 <= truckSize <= 10^6$", "solution": "### 贪心\n\n为了方便,我们令 `boxTypes` 为 `bs`,令 `truckSize` 为 `k`。\n\n由于每个箱子成本相同(均占用一个箱子位置),因此在 `k` 给定的情况下,我们应当尽可能选择装载单元数量大的箱子。\n\n这引导我们可以将 `bs` 根据「装载单元数量」排倒序,然后从前往后 `pick` 箱子,直到没有空闲位置。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maximumUnits(int[][] bs, int k) {\n        int n = bs.length, ans = 0;\n        Arrays.sort(bs, (a,b)->b[1]-a[1]);\n        for (int i = 0, cnt = 0; i < n && cnt < k; i++) {\n            int a = bs[i][0], b = bs[i][1], c = Math.min(a, k - cnt);\n            cnt += c; ans += c * b;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction maximumUnits(bs: number[][], k: number): number {\n    let n = bs.length, ans = 0\n    bs.sort((a,b)=>b[1]-a[1])\n    for (let i = 0, cnt = 0; i < n && cnt < k; i++) {\n        const a = bs[i][0], b = bs[i][1], c = Math.min(a, k - cnt)\n        cnt += c; ans += c * b\n    }\n    return ans\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def maximumUnits(self, bs: List[List[int]], k: int) -> int:\n        bs.sort(key=lambda x: -x[1])\n        n, ans = len(bs), 0\n        idx, cnt = 0, 0\n        while idx < n and cnt < k:\n            a, b, c = bs[idx][0], bs[idx][1], min(bs[idx][0], k - cnt)\n            cnt, ans = cnt + c, ans + b * c\n            idx += 1\n        return ans\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$,同时答案复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1710` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/171-180/171. Excel表列序号（简单）.md", "url_title": "171. Excel表列序号", "url": "https://leetcode-cn.com/problems/excel-sheet-column-number/solution/gong-shui-san-xie-tong-yong-jin-zhi-zhua-y5fm/", "difficulty": "简单", "tags": ["模拟", "进制转换"], "question": "给你一个字符串 columnTitle ,表示 Excel 表格中的列名称。返回该列名称对应的列序号。 \n\n例如,\n```\nA -> 1\nB -> 2\nC -> 3\n...\nZ -> 26\nAA -> 27\nAB -> 28 \n...\n```\n示例 1:\n```\n输入: columnTitle = \"A\"\n\n输出: 1\n```\n示例 2:\n```\n输入: columnTitle = \"AB\"\n\n输出: 28\n```\n示例 3:\n```\n输入: columnTitle = \"ZY\"\n\n输出: 701\n```\n示例 4:\n```\n输入: columnTitle = \"FXSHRXW\"\n\n输出: 2147483647\n```\n\n提示:\n* 1 <= columnTitle.length <= 7\n* columnTitle 仅由大写英文组成\n* columnTitle 在范围 [\"A\", \"FXSHRXW\"] 内", "solution": "### 进制转换\n\n也许你没专门做过「进制转换」类的题目,但相信你确实在 $10$ 进制中使用过如下的「进制转换」手段。\n\n如果题目是 $10$ 进制转换,那么你会很容易想到如下转换过程:**从高位向低位处理,起始让 $ans$ 为 $0$,每次使用当前位数值更新 $ans$,更新规则为 $ans = ans * 10 + val_i$。**\n\n举个🌰,假设存在某个十进制数字,编码为 $ABCD$(字母与数字的映射关系与本题相同),转换过程如下:\n\n> $ans$ = 0\n$ans = ans * 10 + 1$ => A\n$ans = ans * 10 + 2$ => B\n$ans = ans * 10 + 3$ => C\n$ans = ans * 10 + 4$ => D\n\n同理,本题只是将 $10$ 进制换成 $26$ 进制。\n\n代码:\n```Java\nclass Solution {\n    public int titleToNumber(String s) {\n        char[] cs = s.toCharArray();\n        int n = cs.length;\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            ans = ans * 26 + (cs[i] - 'A' + 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:因为 `toCharArray` 会创建与 `s` 等长的数组,因此使用 `charAt` 代替 `toCharArray` 的话为 $O(1)$,否则为 $O(n)$\n\n---\n\n### 拓展\n\n与本题互逆的题目,你可以一同复习一下 ~ \n\n* [168. Excel表列名称](https://leetcode-cn.com/problems/excel-sheet-column-title/) : [题解](https://leetcode-cn.com/problems/excel-sheet-column-title/solution/gong-shui-san-xie-cong-1-kai-shi-de-26-j-g2ur/)", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.171` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/171-180/172. 阶乘后的零（中等）.md", "url_title": "172. 阶乘后的零", "url": "https://leetcode-cn.com/problems/factorial-trailing-zeroes/solution/by-ac_oier-1y6w/", "difficulty": "中等", "tags": ["数学"], "question": "给定一个整数 $n$ ,返回 $n!$ 结果中尾随零的数量。\n\n提示 `n! = n * (n - 1) * (n - 2) * ... * 3 * 2 * 1`\n\n示例 1:\n```\n输入:n = 3\n\n输出:0\n\n解释:3! = 6 ,不含尾随 0\n```\n示例 2:\n```\n输入:n = 5\n\n输出:1\n\n解释:5! = 120 ,有一个尾随 0\n```\n示例 3:\n```\n输入:n = 0\n\n输出:0\n```\n\n提示:\n* $0 <= n <= 10^4$\n\n进阶:你可以设计并实现对数时间复杂度的算法来解决此问题吗?", "solution": "### 数学\n\n对于任意一个 $n!$ 而言,其尾随零的个数取决于展开式中 $10$ 的个数,而 $10$ 可由质因数 $2 * 5$ 而来,因此 $n!$ 的尾随零个数为展开式中各项分解质因数后 $2$ 的数量和 $5$ 的数量中的较小值。\n\n即问题转换为对 $[1, n]$ 中的各项进行分解质因数,能够分解出来的 $2$ 的个数和 $5$ 的个数分别为多少。\n\n为了更具一般性,我们分析对 $[1, n]$ 中各数进行分解质因数,能够分解出质因数 $p$ 的个数为多少。根据每个数能够分解出 $p$ 的个数进行分情况讨论:\n\n* 能够分解出至少一个 $p$ 的个数为 $p$ 的倍数,在 $[1, n]$ 范围内此类数的个数为 $c_1 = \\left \\lfloor \\frac{n}{p} \\right \\rfloor$\n* 能够分解出至少两个 $p$ 的个数为 $p^2$ 的倍数,在 $[1, n]$ 范围内此类数的个数为 $c_2 = \\left \\lfloor \\frac{n}{p^2} \\right \\rfloor$\n* ...\n* 能够分解出至少 $k$ 个 $p$ 的个数为 $p^k$ 的倍数,在 $[1, n]$ 范围内此类数的个数为 $c_k = \\left \\lfloor \\frac{n}{p^k} \\right \\rfloor$\n\n**我们定义一个合法的 $k$ 需要满足 $p^k \\leqslant n$,上述的每一类数均是前一类数的「子集」(一个数如果是 $p^k$ 的倍数,必然是 $p^{k-1}$ 的倍数),因此如果一个数是 $p^k$ 的倍数,其出现在的集合数量为 $k$,与其最终贡献的 $p$  的数量相等。**\n\n回到本题,$n!$ 中质因数 $2$ 的数量为 :\n$$\n\\sum_{i = 1}^{k_1}\\left \\lfloor \\frac{n}{2^i} \\right \\rfloor = \\left \\lfloor \\frac{n}{2} \\right \\rfloor + \\left \\lfloor \\frac{n}{2^2} \\right \\rfloor + ... + \\left \\lfloor \\frac{n}{2^{k_1}} \\right \\rfloor\n$$\n\n$n!$ 中质因数 $5$ 的数量为 :\n$$\n\\sum_{i = 1}^{k_2}\\left \\lfloor \\frac{n}{5^i} \\right \\rfloor = \\left \\lfloor \\frac{n}{5} \\right \\rfloor + \\left \\lfloor \\frac{n}{5^2} \\right \\rfloor + ... + \\left \\lfloor \\frac{n}{5^{k_2}} \\right \\rfloor\n$$\n\n由 $2 < 5$,可知 $k_2 \\leqslant k_1$,同时 $i$  相同的每一项满足 $\\left \\lfloor \\frac{n}{5^i} \\right \\rfloor \\leqslant \\left \\lfloor \\frac{n}{2^i} \\right \\rfloor$,可知最终 $\\sum_{i = 1}^{k_2}\\left \\lfloor \\frac{n}{5^i} \\right \\rfloor \\leqslant \\sum_{i = 1}^{k_1}\\left \\lfloor \\frac{n}{2^i} \\right \\rfloor$,即质因数 $5$ 的个数必然不会超过质因数 $2$ 的个数。我们只需要统计质因数 $5$ 的个数即可。\n\n代码:\n```Java\nclass Solution {\n    public int trailingZeroes(int n) {\n        return n == 0 ? 0 : n / 5 + trailingZeroes(n / 5);\n    }\n}\n```\n\n```Python\nclass Solution:\n    def trailingZeroes(self, n: int) -> int:\n        return n // 5 + self.trailingZeroes(n // 5) if n else 0\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.172` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/171-180/173. 二叉搜索树迭代器（中等）.md", "url_title": "173. 二叉搜索树迭代器", "url": "https://leetcode-cn.com/problems/binary-search-tree-iterator/solution/xiang-jie-ru-he-dui-die-dai-ban-de-zhong-4rxj/", "difficulty": "中等", "tags": ["树的搜索", "中序遍历"], "question": "实现一个二叉搜索树迭代器类 `BSTIterator`,表示一个按中序遍历二叉搜索树(`BST`)的迭代器:\n* `BSTIterator(TreeNode root)` 初始化 `BSTIterator` 类的一个对象。`BST` 的根节点 `root` 会作为构造函数的一部分给出。指针应初始化为一个不存在于 `BST` 中的数字,且该数字小于 `BST` 中的任何元素。\n* `boolean hasNext()` 如果向指针右侧遍历存在数字,则返回 `true`;否则返回 `false`。\n* `int next()` 将指针向右移动,然后返回指针处的数字。\n\n注意,指针初始化为一个不存在于 `BST` 中的数字,所以对 `next()` 的首次调用将返回 `BST` 中的最小元素。\n\n你可以假设 `next()` 调用总是有效的,也就是说,当调用 `next()` 时,`BST` 的中序遍历中至少存在一个下一个数字。\n\n示例:\n\n```\n输入\n[\"BSTIterator\", \"next\", \"next\", \"hasNext\", \"next\", \"hasNext\", \"next\", \"hasNext\", \"next\", \"hasNext\"]\n[[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]\n输出\n[null, 3, 7, true, 9, true, 15, true, 20, false]\n\n解释\nBSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);\nbSTIterator.next();    // 返回 3\nbSTIterator.next();    // 返回 7\nbSTIterator.hasNext(); // 返回 True\nbSTIterator.next();    // 返回 9\nbSTIterator.hasNext(); // 返回 True\nbSTIterator.next();    // 返回 15\nbSTIterator.hasNext(); // 返回 True\nbSTIterator.next();    // 返回 20\nbSTIterator.hasNext(); // 返回 False\n```\n\n提示:\n* 树中节点的数目在范围 [1, $10^5$] 内\n* $0 <= Node.val <= 10^6$\n* 最多调用 $10^5$ 次 `hasNext` 和 `next` 操作\n\n进阶:\n* 你可以设计一个满足下述条件的解决方案吗?`next()` 和 `hasNext()` 操作均摊时间复杂度为 $O(1)$ ,并使用 $O(h)$ 内存。其中 `h` 是树的高度。", "solution": "### 基本思路\n\n**这道题本质上考的是「将迭代版的中序遍历代码」做等价拆分。**\n\n我们知道,中序遍历的基本逻辑是:处理左子树 -> 处理当前节点 -> 处理右子树。\n\n其中迭代做法是利用「栈」进行处理:\n\n1. 先将当前节点的所有左子树压入栈,压到没有为止\n2. 将最后一个压入的节点弹出(栈顶元素),加入答案\n3. 将当前弹出的节点作为当前节点,重复步骤一\n\n相应的裸题在这里:[94. 二叉树的中序遍历](https://leetcode-cn.com/problems/binary-tree-inorder-traversal/)\n\n中序遍历的迭代代码:\n```java\nclass Solution {\n    List<Integer> ans = new ArrayList<>();\n    Deque<TreeNode> d = new ArrayDeque<>();\n    public List<Integer> inorderTraversal(TreeNode root) {\n        while (root != null || !d.isEmpty()) {\n            // 步骤 1\n            while (root != null) {\n                d.addLast(root);\n                root = root.left;\n            }\n\n            // 步骤 2\n            root = d.pollLast();\n            ans.add(root.val);\n\n            // 步骤 3\n            root = root.right;\n        }\n        return ans;\n    }\n}\n```\n\n总的来说是这么一个迭代过程:步骤 1 -> 步骤 2 -> 步骤 3 -> 步骤 1 ...\n\n***\n\n### 「中序遍历」代码的「等价拆分」\n\n首先因为 `next()` 方法中我们需要输出一个值,执行的的是「步骤 2」的逻辑,同时我们需要在其前后添加「步骤 1」和「步骤 3」。\n\n另外,我们还有一个 `hasNext()` 要处理,显然 `hasNext()` 应该对应我们的栈是否为空。\n\n为此,我们**需要确保每次输出之后「步骤 1」被及时执行。**\n\n综上,我们应该在初始化时,走一遍「步骤 1」,然后在 `next()` 方法中走「步骤 2」、「步骤 3」和「步骤 1」。\n\n代码:\n```java []\nclass BSTIterator {\n    Deque<TreeNode> d = new ArrayDeque<>();\n    public BSTIterator(TreeNode root) {\n        // 步骤 1\n        dfsLeft(root);\n    }\n    \n    public int next() {\n        // 步骤 2\n        TreeNode root = d.pollLast();\n        int ans = root.val;\n        // 步骤 3\n        root = root.right;\n        // 步骤 1\n        dfsLeft(root);\n        return ans;\n    }\n\n    void dfsLeft(TreeNode root) {\n        while (root != null) {\n            d.addLast(root);\n            root = root.left;\n        }\n    }\n    \n    public boolean hasNext() {\n        return !d.isEmpty();\n    }\n}\n```\n* 时间复杂度:由于每个元素都是严格「进栈」和「出栈」一次,复杂度为均摊 $O(1)$\n* 空间复杂度:栈内最多保存与深度一致的节点数量,复杂度为 $O(h)$\n\n***\n\n### 进阶\n\n事实上,我们空间复杂度也能做到 $O(1)$,该如何做呢?", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.173` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/171-180/179. 最大数（中等）.md", "url_title": "179. 最大数", "url": "https://leetcode-cn.com/problems/largest-number/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-vn86e/", "difficulty": "中等", "tags": ["贪心"], "question": "给定一组非负整数 `nums`,重新排列每个数的顺序(每个数不可拆分)使之组成一个最大的整数。\n\n注意:输出结果可能非常大,所以你需要返回一个字符串而不是整数。\n\n示例 1:\n```\n输入:nums = [10,2]\n\n输出:\"210\"\n```\n示例 2:\n```\n输入:nums = [3,30,34,5,9]\n\n输出:\"9534330\"\n```\n示例 3:\n```\n输入:nums = [1]\n\n输出:\"1\"\n```\n示例 4:\n```\n输入:nums = [10]\n\n输出:\"10\"\n```\n\n提示:\n* $1 <= nums.length <= 100$\n* $0 <= nums[i] <= 10^9$", "solution": "### 贪心\n\n对于 $nums$ 中的任意两个值 $a$ 和 $b$,我们无法直接从常规角度上确定其大小/先后关系。\n\n但我们可以根据「结果」来决定 $a$ 和 $b$ 的排序关系:\n\n如果拼接结果 $ab$ 要比 $ba$ 好,那么我们会认为 $a$ 应该放在 $b$ 前面。\n\n另外,注意我们需要处理前导零(最多保留一位)。\n\nJava 代码:\n```java\nclass Solution {\n    public String largestNumber(int[] nums) {\n        int n = nums.length;\n        String[] ss = new String[n];\n        for (int i = 0; i < n; i++) ss[i] = \"\" + nums[i];\n        Arrays.sort(ss, (a, b) -> {\n            String sa = a + b, sb = b + a ;\n            return sb.compareTo(sa);\n        });\n        StringBuilder sb = new StringBuilder();\n        for (String s : ss) sb.append(s);\n        int len = sb.length();\n        int k = 0;\n        while (k < len - 1 && sb.charAt(k) == '0') k++;\n        return sb.substring(k);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    string largestNumber(vector<int>& nums) {\n        int n = nums.size();\n        vector<string> ss(n);\n        for (int i = 0; i < n; i++) ss[i] = to_string(nums[i]);\n        sort(ss.begin(), ss.end(), [](const string& a, const string& b) {\n            return a + b > b + a;\n        });\n        string result;\n        for (const string& s : ss) result += s;\n        int len = result.length(), k = 0;\n        while (k < len - 1 && result[k] == '0') k++;\n        return result.substr(k);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def largestNumber(self, nums: List[int]) -> str:\n        nums = list(map(str, nums))\n        nums.sort(key=lambda x: x * 10, reverse=True)\n        result = ''.join(nums)\n        k = 0\n        while k < len(result) - 1 and result[k] == '0': \n            k += 1\n        return result[k:]\n```\nTypeScript 代码:\n```TypeScript\nfunction largestNumber(nums: number[]): string {\n    const ss = nums.map(num => num.toString());\n    ss.sort((a, b) => (b + a).localeCompare(a + b));\n    let result = '';\n    for (const s of ss) result += s;\n    let k = 0;\n    while (k < result.length - 1 && result[k] === '0') k++;\n    return result.substring(k);\n};\n```\n* 时间复杂度:由于是对 $String$ 进行排序,当排序对象不是 $Java$ 中的基本数据类型时,不会使用快排(考虑排序稳定性问题)。`Java` 中的 `Arrays.sort()` 的底层实现会「元素数量/元素是否大致有序」决定是使用插入排序还是归并排序。这里直接假定使用的是「插入排序」。复杂度为 $O(n^2)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 证明\n\n上述解法,我们需要证明两个内容:\n\n* 该贪心策略能取到全局最优解。\n* 这样的「排序比较逻辑」应用在集合 $nums$ 上具有[「全序关系」](https://baike.baidu.com/item/%E5%85%A8%E5%BA%8F%E5%85%B3%E7%B3%BB)。\n\n#### 1. 该贪心策略能取到全局最优解\n\n令我们经过这样的贪心操作得到的贪心解为 $ans$,真实最优解为 $max$。\n\n由于真实最优解为全局最大值,而我们的贪心解至少是一个合法解(一个数),因此天然有 $ans \\leqslant max$。\n\n**接下来我们只需要证明 $ans \\geqslant max$,即可得 $ans = max$(贪心解即为最优解)。**\n\n我们使用「反证法」来证明 $ans \\geqslant max$ 成立:\n\n假设 $ans \\geqslant max$ 不成立,即有 $ans < max$。\n\n$ans$ 和 $max$ 都是由同样一批数字凑成的,如果有 $ans < max$。\n\n这意味着我们可以将 $ans$ 中的某些低位数字和高位数字互换,使得 $ans$ 更大(调整为 $max$),这与我们根据「结果」进行排序的逻辑冲突。\n\n因此 $ans < max$ 必然不成立,得证 $ans \\geqslant max$ 成立,结合 $ans \\leqslant max$ 可得贪心解为最优。\n\n举个🌰,如果有 $ans < max$,那么意味着在 $ans$ 中至少有一对数字互换可以使得 $ans$ 变大,\n\n那么在排序逻辑中 $x$ 所在的整体(可能不只有 $x$ 一个数)应该被排在 $y$ 所在的整体(可能不只有 $y$ 一个数)前面。\n\n#### 2. 全序关系\n\n我们使用符号 $@$ 来代指我们的「排序」逻辑:\n\n* 如果 $a$ 必须排在 $b$ 的前面,我们记作 $a @ b$;\n* 如果 $a$ 必须排在 $b$ 的后面,我们记作 $b @ a$;\n* 如果 $a$ 既可以排在 $b$ 的前面,也可以排在 $b$ 的后面,我们记作 $a\\#b$;\n\n**2.1 完全性**\n\n**具有完全性是指从集合 $nums$ 中任意取出两个元素 $a$ 和 $b$,必然满足 $a @ b$、$b @ a$ 和 $a\\#b$ 三者之一。**\n\n**这点其实不需要额外证明,因为由 $a$ 和 $b$ 拼接的字符串 $ab$ 和 $ba$ 所在「字典序大小关系中」要么完全相等,要么具有明确的字典序大小关系,导致 $a$ 必须排在前面或者后面。**\n\n**2.2 反对称性**\n\n**具有反对称性是指由 $a@b$ 和 $b@a$ 能够推导出 $a\\#b$。**\n\n$a@b$ 说明字符串 $ab$ 的字典序大小数值要比字符串 $ba$ 字典序大小数值大。\n\n$b@a$ 说明字符串 $ab$ 的字典序大小数值要比字符串 $ba$ 字典序大小数值小。\n\n**这样,基于「字典序本身满足全序关系」和「数学上的 $a \\geqslant b$ 和 $a \\leqslant b$ 可推导出 $a = b$」。**\n\n**得证 $a@b$ 和 $b@a$ 能够推导出 $a\\#b$。**\n\n**2.3 传递性**\n\n**具有传递性是指由 $a@b$ 和 $b@c$ 能够推导出 $a@c$。**\n\n这里的「传递性」其实也可以使用与 [官方题解](https://leetcode-cn.com/problems/largest-number/solution/zui-da-shu-by-leetcode-solution-sid5/) 类似的手法来证明。\n\n**我们可以利用「两个等长的拼接字符串,字典序大小关系与数值大小关系一致」这一性质来证明,因为字符串 $ac$ 和 $ca$ 必然是等长的。**\n\n接下来,让我们从「自定义排序逻辑」出发,换个思路来证明 $a@c$:\n\n**然后我们只需要证明在不同的 $i$ $j$ 关系之间(共三种情况),$a@c$ 恒成立即可:**\n\n1. 当 $i == j$ 的时候:\n\n2. 当 $i > j$ 的时候:\n\n3. 当 $i < j$ 的时候:\n\n**综上,我们证明了无论在何种情况下,只要有 $a@b$ 和 $b@c$ 的话,那么 $a@c$ 恒成立。**\n\n**我们之所以能这样证明「传递性」,本质是利用了自定义排序逻辑中「对于确定任意元素 $a$ 和 $b$ 之间的排序关系只依赖于 $a$ 和 $b$ 的第一个不同元素之间的大小关系」这一性质。**\n\n---\n\n### 找 $i$ 的越界问题\n\n考虑\n\n(1) a = 304 b = 30\n(2) a = 301 b = 30\n\n两种情况。\n\n显然,(1)下我们会得到 $a@b$,而(2)下我们会得到 $b@a$\n\n但是,在这种情况下 $i$ 实际上位于 $b$ 界外,那我们还能不能找 $i$ 呢?$b[i]$ 是多少呢?\n\n实际上是可以的,我们在比较 $a$ 和 $b$ 的时候,实际上是在比较 $ab$ 和 $ba$ 两个字符串,所以实际上我们是在用 $a[0]$, $a[1]$, $a[2]$ ... 去填补 $b$ 本体结束后的空缺。换而言之(1)和(2)里的 b 实际上被填补为 `303` (填进来 $a[0]$)\n\n再比如\n\n(3)a = 3131248 b = 3131 ,比较的时候实际上是用 $a$ 开头的 `4` 位去填补上 $b$ 的空缺,所以 $b$ 实际上相当于 `31313131`", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.179` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1711-1720/1711. 大餐计数（中等）.md", "url_title": "1711. 大餐计数", "url": "https://leetcode-cn.com/problems/count-good-meals/solution/gong-shui-san-xie-xiang-jie-san-chong-gu-nn4f/", "difficulty": "中等", "tags": ["哈希表", "位运算"], "question": "大餐 是指 恰好包含两道不同餐品 的一餐,其美味程度之和等于 2 的幂。\n\n你可以搭配 任意 两道餐品做一顿大餐。\n\n给你一个整数数组 deliciousness ,其中 deliciousness[i] 是第 i 道餐品的美味程度,返回你可以用数组中的餐品做出的不同 大餐 的数量。结果需要对 $10^9$ + 7 取余。\n\n注意,只要餐品下标不同,就可以认为是不同的餐品,即便它们的美味程度相同。 \n\n示例 1:\n\n```\n输入:deliciousness = [1,3,5,7,9]\n\n输出:4\n\n解释:大餐的美味程度组合为 (1,3) 、(1,7) 、(3,5) 和 (7,9) 。\n它们各自的美味程度之和分别为 4 、8 、8 和 16 ,都是 2 的幂。\n```\n示例 2:\n```\n输入:deliciousness = [1,1,1,3,3,3,7]\n\n输出:15\n\n解释:大餐的美味程度组合为 3 种 (1,1) ,9 种 (1,3) ,和 3 种 (1,7) 。\n```\n\n提示:\n* 1 <= deliciousness.length <= $10^5$\n* 0 <= deliciousness[i] <= $2^{20}$", "solution": "### 枚举前一个数(TLE)\n\n一个朴素的想法是,从前往后遍历 $deliciousness$ 中的所有数,当遍历到下标 $i$ 的时候,回头检查下标小于 $i$ 的数是否能够与 $deliciousness[i]$ 相加形成 $2$ 的幂。\n\n这样的做法是 $O(n^2)$ 的,防止同样的数值被重复计算,我们可以使用「哈希表」记录某个数出现了多少次,但这并不改变算法仍然是 $O(n^2)$ 的。\n\n而且我们需要一个 `check` 方法来判断某个数是否为 $2$ 的幂:\n\n* 朴素的做法是对 $x$ 应用试除法,当然因为精度问题,我们需要使用乘法实现试除;\n* 另一个比较优秀的做法是利用位运算找到符合「大于等于 $x$」的最近的 $2$ 的幂,然后判断是否与 $x$ 相同。\n\n两种做法差距有多大呢?方法一的复杂度为 $O(\\log{n})$,方法二为 $O(1)$。\n\n根据数据范围 $0 <= deliciousness[i] <= 2^{20}$,方法一最多也就是执行不超过 $22$ 次循环。\n\n显然,采用何种判断 $2$ 的幂的做法不是关键,在 OJ 判定上也只是分别卡在 $60/70$ 和 $62/70$ 的 TLE 上。\n\n**但通过这样的分析,我们可以发现「枚举前一个数」的做法是与 $n$ 相关的,而枚举「可能出现的 $2$ 的幂」则是有明确的范围,这引导出我们的解法二。**\n\n代码:\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int countPairs(int[] ds) {\n        int n = ds.length;\n        long ans = 0;\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = 0; i < n; i++) {\n            int x = ds[i];\n            for (int other : map.keySet()) {\n                if (check(other + x)) ans += map.get(other);\n            }\n            map.put(x, map.getOrDefault(x, 0) + 1);\n        }\n        return (int)(ans % mod);\n    }\n    boolean check(long x) {\n        // 方法一\n        // long cur = 1;\n        // while (cur < x) {\n        //     cur = cur * 2;\n        // }\n        // return cur == x;\n        \n        // 方法二\n        return getVal(x) == x;\n    }\n    long getVal(long x) {\n        long n = x - 1;\n        n |= n >>> 1;\n        n |= n >>> 2;\n        n |= n >>> 4;\n        n |= n >>> 8;\n        n |= n >>> 16;\n        return n < 0 ? 1 : n + 1;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 枚举 2 的幂(容斥原理)\n\n根据对朴素解法的分析,我们可以先使用「哈希表」对所有在 $deliciousness$ 出现过的数进行统计。\n\n然后对于每个数 $x$,检查所有可能出现的 $2$ 的幂 $i$,再从「哈希表」中反查 $t = i - x$ 是否存在,并实现计数。\n\n一些细节:如果哈希表中存在 $t = i - x$,并且 $t = x$,这时候方案数应该是 $(cnts[x] - 1) * cnts[x]$;其余一般情况则是 $cnts[t] * cnts[x]$。\n\n同时,这样的计数方式,我们对于二元组 $(x, t)$ 会分别计数两次(遍历 $x$ 和 遍历 $t$),因此最后要利用容斥原理,对重复计数的进行减半操作。\n\n代码:\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    int max = 1 << 22;\n    public int countPairs(int[] ds) {\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int d : ds) map.put(d, map.getOrDefault(d, 0) + 1);\n        long ans = 0;\n        for (int x : map.keySet()) {\n            for (int i = 1; i < max; i <<= 1) {\n                int t = i - x;\n                if (map.containsKey(t)) {\n                    if (t == x) ans += (map.get(x) - 1) * 1L * map.get(x);\n                    else ans += map.get(x) * 1L * map.get(t);\n                }\n            }\n        }\n        ans >>= 1;\n        return (int)(ans % mod);\n    }\n}\n```\n* 时间复杂度:根据数据范围,令 $C$ 为 $2^{21}$。复杂度为 $O(n * \\log{C})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 枚举 2 的幂(边遍历边统计)\n\n当然,我们也可以采取「一边遍历一边统计」的方式,这样取余操作就可以放在遍历逻辑中去做,也就顺便实现了不使用 $long$ 来计数(以及不使用 `%` 实现取余)。\n\n代码:\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    int max = 1 << 22;\n    public int countPairs(int[] ds) {\n        Map<Integer, Integer> map = new HashMap<>();\n        int ans = 0;\n        for (int x : ds) {\n            for (int i = 1; i < max; i <<= 1) {\n                int t = i - x;\n                if (map.containsKey(t)) {\n                    ans += map.get(t);\n                    if (ans >= mod) ans -= mod;\n                }\n            }\n            map.put(x, map.getOrDefault(x, 0) + 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:根据数据范围,令 $C$ 为 $2^{21}$。复杂度为 $O(n * \\log{C})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1711` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1711-1720/1713. 得到子序列的最少操作次数（困难）.md", "url_title": "1713. 得到子序列的最少操作次数", "url": "https://leetcode-cn.com/problems/minimum-operations-to-make-a-subsequence/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-oj7yu/", "difficulty": "困难", "tags": ["最长公共子序列", "最长上升子序列", "贪心", "二分"], "question": "给你一个数组 target ,包含若干 互不相同 的整数,以及另一个整数数组 arr ,arr 可能 包含重复元素。\n\n每一次操作中,你可以在 arr 的任意位置插入任一整数。比方说,如果 arr = [1,4,1,2] ,那么你可以在中间添加 3 得到 [1,4,3,1,2] 。你可以在数组最开始或最后面添加整数。\n\n请你返回 最少 操作次数,使得 target 成为 arr 的一个子序列。\n\n一个数组的 子序列 指的是删除原数组的某些元素(可能一个元素都不删除),同时不改变其余元素的相对顺序得到的数组。比方说,[2,7,4] 是 [4,2,3,7,2,1,4] 的子序列(加粗元素),但 [2,4,2] 不是子序列。\n\n示例 1:\n```\n输入:target = [5,1,3], arr = [9,4,2,3,4]\n\n输出:2\n\n解释:你可以添加 5 和 1 ,使得 arr 变为 [5,9,4,1,2,3,4] ,target 为 arr 的子序列。\n```\n示例 2:\n```\n输入:target = [6,4,8,1,3,2], arr = [4,7,6,2,3,8,6,1]\n\n输出:3\n```\n\n提示:\n* 1 <= target.length, arr.length <= $10^5$\n* 1 <= target[i], arr[i] <= $10^9$\n* target 不包含任何重复元素。", "solution": "### 基本分析\n\n为了方便,我们令 $target$ 长度为 $n$,$arr$ 长度为 $m$,$target$ 和 $arr$ 的最长公共子序列长度为 $max$,不难发现最终答案为 $n - max$。\n\n因此从题面来说,这是一道最长公共子序列问题(LCS)。\n\n但朴素求解 LCS 问题复杂度为 $O(n * m)$,使用状态定义「**$f[i][j]$ 为考虑 `a` 数组的前 $i$ 个元素和 `b` 数组的前 $j$ 个元素的最长公共子序列长度为多少**」进行求解。\n\n而本题的数据范围为 $10^5$,使用朴素求解 LCS 的做法必然超时。\n\n一个很显眼的切入点是 $target$ 数组元素各不相同,当 LCS 问题增加某些条件限制之后,会存在一些很有趣的性质。\n\n其中一个经典的性质就是:**当其中一个数组元素各不相同时,最长公共子序列问题(LCS)可以转换为最长上升子序列问题(LIS)进行求解。同时最长上升子序列问题(LIS)存在使用「维护单调序列 + 二分」的贪心解法,复杂度为 $O(n\\log{n})$。**\n\n**因此本题可以通过「抽象成 LCS 问题」->「利用 $target$ 数组元素各不相同,转换为 LIS 问题」->「使用 LIS 的贪心解法」,做到 $O(n\\log{n})$ 的复杂度。**\n\n基本方向确定后,我们证明一下第 $2$ 步和第 $3$ 步的合理性与正确性。\n\n---\n\n### 证明\n\n#### 1. 为何其中一个数组元素各不相同,LCS 问题可以转换为 LIS 问题?\n\n**本质是利用「当其中一个数组元素各不相同时,这时候每一个“公共子序列”都对应一个不重复元素数组的下标数组“上升子序列”,反之亦然」。**\n\n我们可以使用题目给定的两个数组($target$ 和 $arr$)理解上面的话。\n\n由于 $target$ 元素各不相同,那么首先 $target$ 元素和其对应下标,具有唯一的映射关系。\n\n然后我们可以**将重点放在两者的公共元素上(忽略非公共元素),每一个“公共子序列”自然对应了一个下标数组“上升子序列”,反之亦然**。\n\n注意:下图只画出了两个数组的某个片段,不要错误理解为两数组等长。\n\n如果存在某个“公共子序列”,根据“子序列”的定义,那么对应下标序列必然递增,也就是对应了一个“上升子序列”。\n\n反过来,对于下标数组的某个“上升子序列”,首先意味着元素在 $target$ 出现过,并且出现顺序递增,符合“公共子序列”定义,即对应了一个“公共子序列”。\n\n至此,我们将原问题 LCS 转换为了 LIS 问题。\n\n#### 2. 贪心求解 LIS 问题的正确性证明?\n\n朴素的 LIS 问题求解,我们需要定义一个 $f[i]$ 数组代表以 $nums[i]$ 为结尾的最长上升子序列的长度为多少。\n\n对于某个 $f[i]$ 而言,我们需要往回检查 $[0, i - 1]$ 区间内,所有可以将 $nums[i]$ 接到后面的位置 $j$,在所有的 $f[j] + 1$ 中取最大值更新 $f[i]$。因此朴素的 LIS 问题复杂度是 $O(n^2)$ 的。\n\n**LIS 的贪心解法则是维护一个额外 $g$ 数组,$g[len] = x$ 代表上升子序列长度为 $len$ 的上升子序列的「最小结尾元素」为 $x$。**\n\n整理一下,我们总共有两个数组:\n* $f$ 动规数组:与朴素 LIS 解法的动规数组含义一致。$f[i]$ 代表以 $nums[i]$ 为结尾的上升子序列的最大长度;\n* $g$ 贪心数组:$g[len] = x$ 代表上升子序列长度为 $len$ 的上升子序列的「最小结尾元素」为 $x$。\n\n由于我们计算 $f[i]$ 时,需要找到满足 $nums[j] < nums[i]$,同时取得最大 $f[j]$ 的位置 $j$。\n\n我们期望通过 $g$ 数组代替线性遍历。\n\n显然,如果 $g$ 数组具有「单调递增」特性的话,我们可以通过「二分」找到符合 $g[idx] < nums[i]$ 分割点 $idx$(下标最大),即利用 $O(\\log{n})$ 复杂度找到最佳转移位置。\n\n我们可以很容易 **通过反证法结合 $g$ 数组的定义来证明 $g$ 数组具有「单调递增」特性。**\n\n假设存在某个位置 $i$ 和 $j$,且 $i < j$,不满足「单调递增」,即如下两种可能:\n\n* $g[i] = g[j] = x$:这意味着某个值 $x$ 既能作为长度 $i$ 的上升子序列的最后一位,也能作为长度为 $j$ 的上升子序列的最后一位。\n    根据我们对 $g$ 数组的定义,$g[i] = x$ 意味在所有长度为 $i$ 上升子序列中「最小结尾元素」为 $x$,但同时由于 $g[j] = x$,而且「上升子序列」必然是「严格单调」,因此我们可以通过删除长度为 $j$ 的子序列后面的元素(调整出一个长度为 $i$ 的子序列)来找到一个比 $g[i]$ 小的合法值。\n    也就是我们找到了一个长度为 $i$ 的上升子序列,且最后一位元素必然严格小于 $x$。因此 $g[i] = g[j] = x$ 恒不成立;\n\n* $g[i] > g[j] = x$:同理,如果存在一个长度为 $j$ 的合法上升子序列的「最小结尾元素」为 $x$ 的话,那么必然能够找到一个比 $x$ 小的值来更新 $g[i]$。即 $g[i] > g[j]$ 恒不成立。\n\n根据全序关系,在证明 $g[i] = g[j]$ 和 $g[i] > g[j]$ 恒不成立后,可得 $g[i] < g[j]$ 恒成立。\n\n至此,我们证明了 $g$ 数组具有单调性,从而证明了每一个 $f[i]$ 均与朴素 LIS 解法得到的值相同,即贪心解是正确的。\n\n---\n\n### 动态规划 + 贪心 + 二分\n\n根据「基本分析 & 证明」,通过维护一个贪心数组 $g$,来更新动规数组 $f$,在求得「最长上升子序列」长度之后,利用「“公共子序列”和“上升子序列”」的一一对应关系,可以得出“最长公共子序列”长度,从而求解出答案。\n\n代码:\n```Java\nclass Solution {\n    public int minOperations(int[] t, int[] arr) {\n        int n = t.length, m = arr.length;\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = 0; i < n; i++) {\n            map.put(t[i], i);\n        }\n        List<Integer> list = new ArrayList<>();\n        for (int i = 0; i < m; i++) {\n            int x = arr[i];\n            if (map.containsKey(x)) list.add(map.get(x));\n        }\n        int len = list.size();\n        int[] f = new int[len], g = new int[len + 1];\n        Arrays.fill(g, Integer.MAX_VALUE);\n        int max = 0;\n        for (int i = 0; i < len; i++) {\n            int l = 0, r = len;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (g[mid] < list.get(i)) l = mid;\n                else r = mid - 1;\n            }\n            int clen = r + 1;\n            f[i] = clen;\n            g[clen] = Math.min(g[clen], list.get(i));\n            max = Math.max(max, clen);\n        }\n        return n - max;\n    }\n}\n```\n* 时间复杂度:通过 $O(n)$ 复杂度得到 $target$ 的下标映射关系;通过 $O(m)$ 复杂度得到映射数组 $list$;贪心求解 LIS 的复杂度为 $O(m\\log{m})$。整体复杂度为 $O(n + m\\log{m})$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1713` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1711-1720/1716. 计算力扣银行的钱（简单）.md", "url_title": "1716. 计算力扣银行的钱", "url": "https://leetcode-cn.com/problems/calculate-money-in-leetcode-bank/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-ifit/", "difficulty": "简单", "tags": ["数学", "模拟"], "question": "Hercy 想要为购买第一辆车存钱。他 **每天** 都往力扣银行里存钱。\n\n最开始,他在周一的时候存入 `1` 块钱。从周二到周日,他每天都比前一天多存入 `1` 块钱。在接下来每一个周一,他都会比 前一个周一 多存入 `1` 块钱。\n\n给你 `n` ,请你返回在第 `n` 天结束的时候他在力扣银行总共存了多少块钱。\n\n示例 1:\n```\n输入:n = 4\n\n输出:10\n\n解释:第 4 天后,总额为 1 + 2 + 3 + 4 = 10 。\n```\n示例 2:\n```\n输入:n = 10\n\n输出:37\n\n解释:第 10 天后,总额为 (1 + 2 + 3 + 4 + 5 + 6 + 7) + (2 + 3 + 4) = 37 。注意到第二个星期一,Hercy 存入 2 块钱。\n```\n示例 3:\n```\n输入:n = 20\n\n输出:96\n\n解释:第 20 天后,总额为 (1 + 2 + 3 + 4 + 5 + 6 + 7) + (2 + 3 + 4 + 5 + 6 + 7 + 8) + (3 + 4 + 5 + 6 + 7 + 8) = 96 。\n```\n\n提示:\n* $1 <= n <= 1000$", "solution": "### 模拟\n\n根据题意进行模拟即可,分两步进行计算。\n\n先计算完整周:共 $a = \\left \\lfloor \\frac{n}{7} \\right \\rfloor$ 周,第一周起始日金额为 $1$,每周的起始日的金额递增 $1$,周内金额可使用「等差数列求和」公式直接求解。\n\n然后再计算最后一周(若有)的金额:共 $b = n \\pmod 7$ 天,使用紧接的起始日金额继续进行累加即可。\n\n代码:\n```Java\nclass Solution {\n    public int totalMoney(int n) {\n        int a = n / 7, b = n % 7;\n        int ans = 0, k = 1;\n        while (a-- > 0) {\n            ans += (k + (k + 6)) * 7 / 2;\n            k++;\n        }\n        while (b-- > 0) ans += k++;\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(a + b)$\n* 空间复杂度:$O(1)$\n\n---\n\n### (优化)模拟\n\n更进一步,每个完整周的起始日金额相比上周起始日金额多 $1$,同时周内每日金额递增 $1$,因此相邻完整周的金额之和也满足「等差」性质,可直接使用「等差数列求和」公式 $O(1)$ 求解完整周部分的金额之和;最后一周(若有)的金额也是同理。\n\n代码:\n```Java\nclass Solution {\n    public int totalMoney(int n) {\n        int a = n / 7, b = n % 7;\n        int a1 = (1 + 7) * 7 / 2, an = (a + (a + 6)) * 7 / 2;\n        int s1 = (a1 + an) * a / 2;\n        a++;\n        int s2 = (a + (a + b - 1)) * b / 2;\n        return s1 + s2;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1716` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1711-1720/1719. 重构一棵树的方案数（困难）.md", "url_title": "1719. 重构一棵树的方案数", "url": "https://leetcode-cn.com/problems/number-of-ways-to-reconstruct-a-tree/solution/gong-shui-san-xie-gou-zao-yan-zheng-he-f-q6fc/", "difficulty": "困难", "tags": ["树"], "question": "给你一个数组 `pairs`,其中 $pairs[i] = [x_i, y_i]$ ,并且满足:\n\n* `pairs` 中没有重复元素\n* $x_i < y_i$\n\n令 ways 为满足下面条件的有根树的方案数:\n\n* 树所包含的所有节点值都在 `pairs` 中。\n* 一个数对 $[x_i, y_i]$ 出现在 `pairs` 中 当且仅当 $x_i$ 是 $y_i$ 的祖先或者 $y_i$ 是 $x_i$ 的祖先。\n* 注意:构造出来的树不一定是二叉树。\n\n两棵树被视为不同的方案当存在至少一个节点在两棵树中有不同的父节点。\n\n请你返回:\n\n* 如果 ways == 0 ,返回 0 。\n* 如果 ways == 1 ,返回 1 。\n* 如果 ways > 1 ,返回 2 。\n\n一棵 有根树 指的是只有一个根节点的树,所有边都是从根往外的方向。\n\n我们称从根到一个节点路径上的任意一个节点(除去节点本身)都是该节点的 祖先 。根节点没有祖先。\n\n示例 1:\n\n```\n输入:pairs = [[1,2],[2,3]]\n\n输出:1\n\n解释:如上图所示,有且只有一个符合规定的有根树。\n```\n示例 2:\n\n```\n输入:pairs = [[1,2],[2,3],[1,3]]\n\n输出:2\n\n解释:有多个符合规定的有根树,其中三个如上图所示。\n```\n示例 3:\n```\n输入:pairs = [[1,2],[2,3],[2,4],[1,5]]\n\n输出:0\n\n解释:没有符合规定的有根树。\n```\n\n提示:\n* $1 <= pairs.length <= 10^5$\n* $1 <= xi < yi <= 500$\n* `pairs` 中的元素互不相同。", "solution": "### 构造 + 验证(合法性 + 非唯一性)\n\n这道题是名副其实的困难题,我最早的提交时间是去年 $3$ 月,起初只能想到 $O(n * m)$ 的做法,对于一颗多叉树来说显然会 `TLE`,虽然到现在印象不深了,但如果不是之前做过,今天大概率会很晚才能发布题解。\n\n该题突破口在于如何利用 `pairs` 构造出一种具体方案,然后辨别方案的合法性(是否返回 $0$)和方案中的某些点是否可相互替换(返回 $1$ 还是 $2$)。\n\n给定 `pairs` 数组为父子关系,对于 $pairs[i] = (a,b)$ 而言,既可以是 $a$ 为 $b$ 祖宗节点,也可以是 $b$ 为 $a$ 祖宗节点。\n\n题目的「当且仅当」含义为所有的 `pairs` 在具体方案中均有体现,因此先考虑如何使用 `pairs` 构造出具体方案。\n\n如果使用一棵合法树而言:**每个子树的根节点在 `pairs` 中的出现数量满足大于等于其子节点在 `pairs` 中出现的数量(当某个根节点只有一个子节点时可取等号)。**\n\n利用此性质,**虽然我们无法得知某个 $pairs[i]$ 真实的父子关系,但统计每个点的「度数」可以作为决策根节点的依据**。\n\n具体的,遍历 `pairs` 并统计所有点的度数,同时为了后续构造可以快速查询某两个点是否为父子关系,使用邻接矩阵 $g$ 存储关系,并使用 `Set` 统计点集。\n\n之后将点按照「度数」降序,从前往后处理每个点,尝试构建具体方案(第一个点作为具体方案的根节点)。\n\n对于每个非根节点 $a$ 而言,按道理我们可以将其添加到任意一个「度数不小于 $cnt[i]$」且「与其存在父子关系的」$b$ 中,但这样构造方式,只能确保能够得到「合法性」的结果,会为对于后续的「非唯一性」验证带来巨大困难。\n\n因此这里尝试构造的关键点在于:**我们为 $a$ 找 $b$ 的时候,应当找符合条件的、度数与 $a$ 相近的点。由于我们已经提前根据「度数」进行降序,这个找最优点的操作可从 $a$ 所在位置开始进行往回找,找到第一个满足「与 $a$ 存在父子关系」的点 $b$ 作为具体方案中 $a$ 的根节点。**\n\n这样的构造逻辑为后续的「非唯一性」验证带来的好处是:**如果存在多个点能够相互交换位置的话,其在具体方案中必然为直接的父子关系,即我们能够通过判断 $cnts[i]$ 和 $cnts[fa[i]]$ 是否相等,来得知在具体方案中点 $i$ 和 $fa[i]$ 能够交换,并且如果能够交换,具体方案的合法性不会发生改变。**\n\n> 一些细节:`pairs` 的数据范围为 $10^4$,而后续的尝试构造,最坏情况下点数也在这个数量级上,为了防止在复杂度为 $O(n^2)$ 的尝试构造上耗费大量时间,可以增加 $m < n - 1$ 的判断,在点数为 $n$ 的情况下,父子关系的最小值为 $n - 1$,当且仅当有一个根节点,其余均为叶子节点时取得,因此如果父子关系数量小于 $n - 1$,必然不为单棵子树,而是森林。\n\n代码:\n```Java\nclass Solution {\n    int N = 510;\n    int[] cnts = new int[N], fa = new int[N];\n    boolean[][] g = new boolean[N][N];\n    public int checkWays(int[][] pairs) {\n        int m = pairs.length;\n        Set<Integer> set = new HashSet<>();\n        for (int[] p : pairs) {\n            int a = p[0], b = p[1];\n            g[a][b] = g[b][a] = true;\n            cnts[a]++; cnts[b]++;\n            set.add(a); set.add(b);\n        }\n        List<Integer> list = new ArrayList<>(set);\n        Collections.sort(list, (a,b)->cnts[b]-cnts[a]);\n        int n = list.size(), root = list.get(0);\n        if (m < n - 1) return 0; // 森林\n        fa[root] = -1;\n        for (int i = 1; i < n; i++) {\n            int a = list.get(i);\n            boolean ok = false;\n            for (int j = i - 1; j >= 0 && !ok; j--) {\n                int b = list.get(j);\n                if (g[a][b]) {\n                    fa[a] = b;\n                    ok = true;\n                }\n            }\n            if (!ok) return 0;\n        }\n        int c = 0, ans = 1;\n        for (int i : set) {\n            int j = i;\n            while (fa[j] != -1) {\n                if (!g[i][fa[j]]) return 0;\n                if (cnts[i] == cnts[fa[j]]) ans = 2;\n                c++;\n                j = fa[j];\n            }\n        }\n        return c < m ? 0 : ans;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为 `pairs` 的长度,统计度数和点集复杂度为 $O(n)$;最多有 $2 * n$ 个点,将点根据度数进行排序复杂度为 $O(n\\log{n})$;尝试根据度数构造树的复杂度为 $O(n^2)$;检验树的合法性复杂度为 $O(n + m)$,其中 $m$ 是构造树的边数,数量级上与 $n$ 相等。整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1719` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1711-1720/1720. 解码异或后的数组（简单）.md", "url_title": "1720. 解码异或后的数组", "url": "https://leetcode-cn.com/problems/decode-xored-array/solution/gong-shui-san-xie-li-yong-yi-huo-xing-zh-p1bi/", "difficulty": "简单", "tags": ["数学", "模拟", "位运算"], "question": "未知 整数数组 arr 由 n 个非负整数组成。\n\n经编码后变为长度为 n - 1 的另一个整数数组 encoded ,其中 encoded[i] = arr[i] XOR arr[i + 1] 。\n\n例如,arr = [1,0,2,1] 经编码后得到 encoded = [1,2,3] 。\n\n给你编码后的数组 encoded 和原数组 arr 的第一个元素 first(arr[0])。\n\n请解码返回原数组 arr 。\n\n可以证明答案存在并且是唯一的。\n\n示例 1:\n```\n输入:encoded = [1,2,3], first = 1\n\n输出:[1,0,2,1]\n\n解释:若 arr = [1,0,2,1] ,那么 first = 1 且 encoded = [1 XOR 0, 0 XOR 2, 2 XOR 1] = [1,2,3]\n```\n示例 2:\n```\n输入:encoded = [6,2,7,3], first = 4\n\n输出:[4,2,0,7,4]\n```\n\n提示:\n* 2 <= n <= $10^4$\n* encoded.length == n - 1\n* 0 <= encoded[i] <= $10^5$\n* 0 <= first <= $10^5$", "solution": "### 模拟\n\n这是道模拟(重拳出击)题。\n\n根据题目给定的规则,利用如下异或性质从头做一遍即可:\n\n1. 相同数值异或,结果为 $0$\n2. 任意数值与 $0$ 进行异或,结果为数值本身\n3. 异或本身满足交换律\n\n已知 `encoded[i-1] = arr[i-1] XOR arr[i]`,将等式两边同时「异或」上 `arr[i-1]`。可得:\n\n1. `encoded[i-1] XOR arr[i-1] = arr[i-1] XOR arr[i] XOR arr[i-1]`\n2. 结合「性质三」和「性质一」,可化简「右式」得 `encoded[i-1] XOR arr[i-1] = arr[i] XOR 0`\n3. 结合「性质二」,可化简「右式」得 `encoded[i-1] XOR arr[i-1] = arr[i]`\n\n代码:\n```Java\nclass Solution {\n    public int[] decode(int[] encoded, int first) {\n        int n = encoded.length + 1;\n        int[] ans = new int[n];\n        ans[0] = first;\n        for (int i = 1; i < n; i++) {\n            ans[i] = ans[i - 1] ^ encoded[i - 1];\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:构建与 `encoded` 同等规模的答案。复杂度为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1720` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1721-1730/1723. 完成所有工作的最短时间（困难）.md", "url_title": "1723. 完成所有工作的最短时间", "url": "https://leetcode-cn.com/problems/find-minimum-time-to-finish-all-jobs/solution/gong-shui-san-xie-yi-ti-shuang-jie-jian-4epdd/", "difficulty": "困难", "tags": ["DFS", "模拟退火", "启发式搜索", "随机化"], "question": "给你一个整数数组 `jobs` ,其中 $jobs[i]$ 是完成第 $i$ 项工作要花费的时间。\n\n请你将这些工作分配给 $k$ 位工人。所有工作都应该分配给工人,且每项工作只能分配给一位工人。\n\n工人的 工作时间 是完成分配给他们的所有工作花费时间的总和。\n\n请你设计一套最佳的工作分配方案,使工人的 最大工作时间 得以 最小化 。\n\n返回分配方案中尽可能「最小」的 最大工作时间 。\n\n示例 1:\n```\n输入:jobs = [3,2,3], k = 3\n\n输出:3\n\n解释:给每位工人分配一项工作,最大工作时间是 3 。\n```\n示例 2:\n```\n输入:jobs = [1,2,4,7,8], k = 2\n\n输出:11\n\n解释:按下述方式分配工作:\n1 号工人:1、2、8(工作时间 = 1 + 2 + 8 = 11)\n2 号工人:4、7(工作时间 = 4 + 7 = 11)\n最大工作时间是 11 。\n```\n\n提示:\n* $1 <= k <= jobs.length <= 12$\n* $1 <= jobs[i] <= 10^7$", "solution": "### DFS(TLE)\n\n一看数据范围只有 $12$,我猜不少同学上来就想 `DFS`,但是注意 `n` 和 `k` 同等规模的,爆搜(`DFS`)的复杂度是 $O(k^n)$ 的。\n\n那么极限数据下的计算量为 $12^{12}$,远超运算量 $10^7$。\n\n抱着侥幸的心理一运行,很顺利的卡在了 $43/60$ 个数据:\n\n```Java\n[254,256,256,254,251,256,254,253,255,251,251,255] // n = 12\n10 // k = 10\n```\n\n代码:\n```Java\nclass Solution {\n    int[] jobs;\n    int n, k;\n    int ans = 0x3f3f3f3f;\n    public int minimumTimeRequired(int[] _jobs, int _k) {\n        jobs = _jobs;\n        n = jobs.length;\n        k = _k;\n        int[] sum = new int[k];\n        dfs(0, sum, 0);\n        return ans;\n    }\n    /**\n     * u   : 当前处理到那个 job\n     * sum : 工人的分配情况          例如:sum[0] = x 代表 0 号工人工作量为 x\n     * max : 当前的「最大工作时间」\n     */\n    void dfs(int u, int[] sum, int max) {\n        if (max >= ans) return;\n        if (u == n) {\n            ans = max;\n            return;\n        }\n        for (int i = 0; i < k; i++) {\n            sum[i] += jobs[u];\n            dfs(u + 1, sum, Math.max(sum[i], max));\n            sum[i] -= jobs[u];\n        }\n    }\n}\n```\n* 时间复杂度:$O(k^n)$\n* 空间复杂度:$O(k)$\n\n---\n\n### 优先分配「空闲工人」的 DFS\n\n那么 `DFS` 就没法过了吗?\n\n除了 `max >= ans` 以外,我们还要做些别的剪枝吗?\n\n我们可以重新审视一下这道题。\n\n**题目其实是让我们将 $n$ 个数分为 $k$ 份,并且尽可能让 $k$ 份平均。这样的「最大工作时间」才是最小的。**\n\n但在朴素的 `DFS` 中,我们是将每个任务依次分给每个工人,并递归此过程。\n\n**对应的递归树其实是一颗高度为 $n$ 的 $k$ 阶树。**\n\n所以其实我们第一次更新的 `ans` 其实是「最差」的答案(所有的任务都会分配给 $0$ 号工人),最差的 `ans` 为所有的 `job` 的总和(带编号的方块代表工人):\n\n因此我们朴素版的 `DFS` 其实是弱化了 `max >= ans` 剪枝效果的。\n\n那么想要最大化剪枝效果,并且尽量让 $k$ 份平均的话,我们应当调整我们对于「递归树」的搜索方向:将任务优先分配给「空闲工人」(带编号的方块代表工人):\n\n树还是那棵树,但是搜索调整分配优先级后,我们可以在首次取得一个「较好」的答案,来增强我们的  `max >= ans` 剪枝效益。\n\n事实上,当做完这个调整,我们能实现从 TLE 到 99% 的提升 🤣 🤣\n\n代码:\n```Java\nclass Solution {\n    int[] jobs;\n    int n, k;\n    int ans = 0x3f3f3f3f;\n    public int minimumTimeRequired(int[] _jobs, int _k) {\n        jobs = _jobs;\n        n = jobs.length;\n        k = _k;\n        int[] sum = new int[k];\n        dfs(0, 0, sum, 0);\n        return ans;\n    }\n    /**\n     * 【补充说明】不理解可以看看下面的「我猜你问」的 Q5 哦 ~\n     * \n     * u     : 当前处理到那个 job\n     * used  : 当前分配给了多少个工人了\n     * sum   : 工人的分配情况          例如:sum[0] = x 代表 0 号工人工作量为 x\n     * max   : 当前的「最大工作时间」\n     */\n    void dfs(int u, int used, int[] sum, int max) {\n        if (max >= ans) return;\n        if (u == n) {\n            ans = max;\n            return;\n        }\n        // 优先分配给「空闲工人」\n        if (used < k) {\n            sum[used] = jobs[u];\n            dfs(u + 1, used + 1, sum, Math.max(sum[used], max));\n            sum[used] = 0;\n        }\n        for (int i = 0; i < used; i++) {\n            sum[i] += jobs[u];\n            dfs(u + 1, used, sum, Math.max(sum[i], max));\n            sum[i] -= jobs[u];\n        }\n    }\n}\n```\n* 时间复杂度:$O(k^n)$\n* 空间复杂度:$O(k)$\n\n---\n\n### 模拟退火\n\n事实上,这道题还能使用「模拟退火」进行求解。\n\n**因为将 $n$ 个数划分为 $k$ 份,等效于用 $n$ 个数构造出一个「特定排列」,然后对「特定排列」进行固定模式的任务分配逻辑,就能实现「答案」与「最优排列」的对应关系。**\n\n基于此,我们可以使用「模拟退火」进行求解。\n\n单次迭代的基本流程:\n\n1. 随机选择两个下标,计算「交换下标元素前对应序列的得分」&「交换下标元素后对应序列的得分」\n2. 如果温度下降(交换后的序列更优),进入下一次迭代\n3. 如果温度上升(交换前的序列更优),以「一定的概率」恢复现场(再交换回来)\n\n> 对于一个能够运用模拟退火求解的问题,最核心的是如何实现 `calc` 方法(即如何定义一个具体方案的得分),其余均为模板内容。\n\n代码:\n```Java\nclass Solution {\n    int[] jobs;\n    int[] works = new int[20];\n    int n, k;\n    int ans = 0x3f3f3f3f;    \n    Random random = new Random(20210508);\n    // 最高温/最低温/变化速率(以什么速度进行退火,系数越低退火越快,迭代次数越少,落入「局部最优」(WA)的概率越高;系数越高 TLE 风险越大)\n    double hi = 1e8, lo = 1e-4, fa = 0.90; \n    // 迭代次数,与变化速率同理\n    int N = 400;\n\n    // 计算当前 jobs 序列对应的最小「最大工作时间」是多少\n    int calc() {\n        Arrays.fill(works, 0);\n        for (int i = 0; i < n; i++) {\n            // [固定模式分配逻辑] : 每次都找最小的 worker 去分配\n            int idx = 0, cur = works[idx];\n            for (int j = 0; j < k; j++) {\n                if (works[j] < cur) {\n                    cur = works[j];\n                    idx = j;\n                }\n            }\n            works[idx] += jobs[i];\n        }\n        int cur = 0;\n        for (int i = 0; i < k; i++) cur = Math.max(cur, works[i]);\n        ans = Math.min(ans, cur);\n        return cur;\n    }\n    void shuffle(int[] nums) {\n        for (int i = n; i > 0; i--) {\n            int idx = random.nextInt(i);\n            swap(nums, idx, i - 1);\n        }\n    }\n    void swap(int[] arr, int i, int j) {\n        int c = arr[i];\n        arr[i] = arr[j];\n        arr[j] = c;\n    }\n    void sa() {\n        shuffle(jobs);\n        for (double t = hi; t > lo; t *= fa) {\n            int a = random.nextInt(n), b = random.nextInt(n);\n            int prev = calc(); // 退火前\n            swap(jobs, a, b);\n            int cur = calc(); // 退火后\n            int diff = cur - prev;\n            // 退火为负收益(温度上升),以一定概率回退现场\n            if (Math.log(diff / t) > random.nextDouble()) swap(jobs, a, b);\n        }\n    }\n    public int minimumTimeRequired(int[] _jobs, int _k) {\n        jobs = _jobs;\n        n = jobs.length;\n        k = _k;\n        while (N-- > 0) sa();\n        return ans;\n    }\n}\n```\n* 时间复杂度:启发式搜索不讨论时空复杂度\n* 空间复杂度:启发式搜索不讨论时空复杂度\n\n---\n\n### 我猜你问\n\n**Q0. 模拟退火有何风险?**\n\n随机算法,会面临 `WA` 和 `TLE` 风险。\n\n**Q1. 模拟退火中的参数如何敲定的?**\n\n根据经验猜的,然后提交。根据结果是 `WA` 还是 `TLE` 来决定之后的调参方向。如果是 `WA` 说明部分数据落到了「局部最优」或者尚未达到「全局最优」。\n\n**Q2. 参数如何调整?**\n\n如果是 `WA` 了,一般我是优先调大 fa 参数,使降温变慢,来变相增加迭代次数;如果是 `TLE` 了,一般是优先调小 fa 参数,使降温变快,减小迭代次数。总迭代参数 `N` 也是同理。\n\n可以简单理解调大 fa 代表将「大步」改为「baby step」,防止越过全局最优,同时增加总执行步数。\n\n可以结合我不同的 fa 参数的提交结果来感受下:\n\n**Q3. 关于「模拟退火」正确性?**\n\n随机种子不变,测试数据不变,迭代参数不变,那么退火的过程就是恒定的,必然都能找到这些测试样例的「全局最优」。\n\n**Q4. 需要掌握「模拟退火」吗?**\n\n还是那句话,特别特别特别有兴趣的可以去了解一下。\n\n但绝对是在你已经彻底理解「剪枝 DFS」和我没写的「状态压缩 DP」之后再去了解。\n\n**Q5. 在「剪枝 DFS」中为什么「优先分配空闲工人」的做法是对的?**\n\n首先要明确,递归树还是那棵递归树。\n\n**所谓的「优先分配空闲工人」它并不是「贪心模拟」思路,而只是一个「调整搜索顺序」的做法。**\n\n「优先分配空闲工人」不代表不会将任务分配给有工作的工人,仅仅代表我们先去搜索那些「优先分配空闲工人」的方案。\n\n然后将得到的「合法解」配合 `max >= ans` 去剪枝掉那些「必然不是最优解」的方案。\n\n**本质上,我们并没有主动的否决某些方案(也就是我们并没有改动递归树),我们只是调整了搜索顺序来剪枝掉了一些「必然不是最优」的搜索路径。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1723` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1721-1730/1725. 可以形成最大正方形的矩形数目（简单）.md", "url_title": "1725. 可以形成最大正方形的矩形数目", "url": "https://leetcode-cn.com/problems/number-of-rectangles-that-can-form-the-largest-square/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-7756/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个数组 `rectangles`,其中 $rectangles[i] = [l_i, w_i]$ 表示第 $i$ 个矩形的长度为 $l_i$ 、宽度为 $w_i$ 。\n\n如果存在 `k` 同时满足 $k <= l_i$ 和 $k <= w_i$ ,就可以将第 `i` 个矩形切成边长为 `k` 的正方形。例如,矩形 $[4,6]$ 可以切成边长最大为 $4$ 的正方形。\n\n设 `maxLen` 为可以从矩形数组 `rectangles` 切分得到的 最大正方形 的边长。\n\n请你统计有多少个矩形能够切出边长为 `maxLen` 的正方形,并返回矩形 数目 。\n\n示例 1:\n```\n输入:rectangles = [[5,8],[3,9],[5,12],[16,5]]\n\n输出:3\n\n解释:能从每个矩形中切出的最大正方形边长分别是 [5,3,5,5] 。\n最大正方形的边长为 5 ,可以由 3 个矩形切分得到。\n```\n示例 2:\n```\n输入:rectangles = [[2,3],[3,7],[4,3],[3,7]]\n\n输出:3\n```\n\n提示:\n* $1 <= rectangles.length <= 1000$\n* $rectangles[i].length == 2$\n* $1 <= li, wi <= 10^9$\n* $li != wi$", "solution": "### 模拟\n\n根据题意,对于任意一个矩形 $rectangles[i]$ 而言,其能分割出的最大方形边长为 $\\min(rectangles[i][0], rectangles[i][1])$。\n\n我们在遍历过程中使用变量 `max` 维护最大边长,同时使用 `ans` 记录能够分割出最大边长 `max` 的矩形数量。\n\n代码:\n```Java\nclass Solution {\n    public int countGoodRectangles(int[][] rectangles) {\n        int max = 0, ans = 0;\n        for (int[] r : rectangles) {\n            int cur = Math.min(r[0], r[1]);\n            if (cur == max) ans++;\n            else if (cur > max) {\n                max = cur; ans = 1;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1725` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1721-1730/1728. 猫和老鼠 II（困难）.md", "url_title": "1728. 猫和老鼠 II", "url": "https://leetcode.cn/problems/cat-and-mouse-ii/solution/by-ac_oier-gse8/", "difficulty": "困难", "tags": ["博弈论", "动态规划", "记忆化搜索"], "question": "一只猫和一只老鼠在玩一个叫做猫和老鼠的游戏。\n\n它们所处的环境设定是一个 `rows x cols` 的方格 `grid` ,其中每个格子可能是一堵墙、一块地板、一位玩家(猫或者老鼠)或者食物。\n\n* 玩家由字符 `'C'` (代表猫)和 `'M'` (代表老鼠)表示。\n* 地板由字符 `'.'` 表示,玩家可以通过这个格子。\n* 墙用字符 `'#'` 表示,玩家不能通过这个格子。\n* 食物用字符 `'F'` 表示,玩家可以通过这个格子。\n* 字符 `'C'` , `'M'` 和 `'F'` 在 `grid` 中都只会出现一次。\n\n猫和老鼠按照如下规则移动:\n\n* 老鼠 先移动 ,然后两名玩家轮流移动。\n* 每一次操作时,猫和老鼠可以跳到上下左右四个方向之一的格子,他们不能跳过墙也不能跳出 grid 。\n* `catJump` 和 `mouseJump` 是猫和老鼠分别跳一次能到达的最远距离,它们也可以跳小于最大距离的长度。\n* 它们可以停留在原地。\n* 老鼠可以跳跃过猫的位置。\n\n游戏有 $4$ 种方式会结束:\n\n* 如果猫跟老鼠处在相同的位置,那么猫获胜。\n* 如果猫先到达食物,那么猫获胜。\n* 如果老鼠先到达食物,那么老鼠获胜。\n* 如果老鼠不能在 $1000$ 次操作以内到达食物,那么猫获胜。\n\n给你 `rows x cols` 的矩阵 `grid` 和两个整数 `catJump` 和 `mouseJump`,双方都采取最优策略,如果老鼠获胜,那么请你返回 `true`,否则返回 `false`。\n\n示例 1:\n\n```\n输入:grid = [\"####F\",\"#C...\",\"M....\"], catJump = 1, mouseJump = 2\n\n输出:true\n\n解释:猫无法抓到老鼠,也没法比老鼠先到达食物。\n```\n示例 2:\n\n```\n输入:grid = [\"M.C...F\"], catJump = 1, mouseJump = 4\n\n输出:true\n```\n示例 3:\n```\n输入:grid = [\"M.C...F\"], catJump = 1, mouseJump = 3\n\n输出:false\n```\n示例 4:\n```\n输入:grid = [\"C...#\",\"...#F\",\"....#\",\"M....\"], catJump = 2, mouseJump = 5\n\n输出:false\n```\n示例 5:\n```\n输入:grid = [\".M...\",\"..#..\",\"#..#.\",\"C#.#.\",\"...#F\"], catJump = 3, mouseJump = 1\n\n输出:true\n```\n\n提示:\n* $rows == grid.length$\n* $cols = grid[i].length$\n* $1 <= rows, cols <= 8$\n* $grid[i][j]$ 只包含字符 `'C'` ,`'M'` ,`'F'` ,`'.'` 和 `'#'` 。\n* `grid` 中只包含一个 `'C'` ,`'M'` 和 `'F'` 。\n* $1 <= catJump, mouseJump <= 8$", "solution": "### 博弈论 DP\n\n当时在 [(题解) 913. 猫和老鼠](https://leetcode.cn/problems/cat-and-mouse/solution/gong-shui-san-xie-dong-tai-gui-hua-yun-y-0bx1/) 没能证出来更小 $K$ 值(回合数)的正确性,用的 $2n^2$ 做的 ,其余题解说 $2 n$ 合法,后来也被证实是错误的。\n\n对于本题如果用相同的分析思路,状态数多达 $8 \\times 8 \\times 8 \\times 8 \\times 2 = 8192$ 种,题目很贴心调整了规则为 $1000$ 步以内为猫获胜,但证明 $K$ 的理论上界仍是困难(上次分析不出来,这次压根不想分析\n\n如果忽略 $K$ 值分析,代码还是很好写的:定义函数 `int dfs(int x, int y, int p, int q, int k)` 并配合记忆化搜索,其中鼠位于 $(x, y)$,猫位于 $(p, q)$,当前轮数为 $k$(由 $k$ 的奇偶性可知是谁的回合)。\n\n对边界情况进行讨论,移动过程中按照规则进行(四联通,移动最大距离为 `mouseJump` 和 `catJump`),注意一旦遇到边界或者墙就要截断。\n\nJava 使用静态数组,用一个 `int` 代表双方所在位置,最大回合数 $K = 1000$,`2022-05-10` 可以过。这道题给的时间上限很高,我调整为 $K = 1500$ 跑成 $2.5s$ 也可以过。本来想要加个卡常,每 $200$ 轮检查一下运行总时长,尽量将时间压在 $850ms$ 以内,现在看来好像用不到。\n\n代码:\n```Java\nimport java.time.Clock;\nclass Solution {\n    static int S = 8 * 8 * 8 * 8, K = 1000;\n    static int[][] f = new int[S][K]; // mouse : 0 / cat : 1\n    String[] g;\n    int n, m, a, b, tx, ty;\n    int[][] dirs = new int[][]{{1,0}, {-1,0}, {0,1}, {0,-1}};\n    // mouse : (x, y) / cat : (p, q)\n    int dfs(int x, int y, int p, int q, int k) {\n        int state = (x << 9) | (y << 6) | (p << 3) | q;\n        if (k == K - 1) return f[state][k] = 1;\n        if (x == p && y == q) return f[state][k] = 1;\n        if (x == tx && y == ty) return f[state][k] = 0;\n        if (p == tx && q == ty) return f[state][k] = 1;\n        if (f[state][k] != -1) return f[state][k];\n        if (k % 2 == 0) { // mouse\n            for (int[] di : dirs) {\n                for (int i = 0; i <= b; i++) {\n                    int nx = x + di[0] * i, ny = y + di[1] * i;\n                    if (nx < 0 || nx >= n || ny < 0 || ny >= m) break;\n                    if (g[nx].charAt(ny) == '#') break;\n                    if (dfs(nx, ny, p, q, k + 1) == 0) return f[state][k] = 0;\n                }\n            }\n            return f[state][k] = 1;\n        } else { // cat\n            for (int[] di : dirs) {\n                for (int i = 0; i <= a; i++) {\n                    int np = p + di[0] * i, nq = q + di[1] * i;\n                    if (np < 0 || np >= n || nq < 0 || nq >= m) break;\n                    if (g[np].charAt(nq) == '#') break;\n                    if (dfs(x, y, np, nq, k + 1) == 1) return f[state][k] = 1;\n                }\n            }\n            return f[state][k] = 0;\n        }\n    }\n    public boolean canMouseWin(String[] grid, int catJump, int mouseJump) {\n        g = grid;\n        n = g.length; m = g[0].length(); a = catJump; b = mouseJump;\n        for (int i = 0; i < S; i++) Arrays.fill(f[i], -1);\n        int x = 0, y = 0, p = 0, q = 0;\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                if (g[i].charAt(j) == 'M') {\n                    x = i; y = j;\n                } else if (g[i].charAt(j) == 'C') {\n                    p = i; q = j;\n                } else if (g[i].charAt(j) == 'F') {\n                    tx = i; ty = j;\n                }\n            }\n        }\n        return dfs(x, y, p, q, 0) == 0;\n    }\n}\n```\n* 时间复杂度:令 $n$ 和 $m$ 分别为矩阵的长宽,最长移动距离为 $L$,复杂度为 $O(n^2 \\times m^2 \\times 1000 \\times 4 \\times L)$\n* 空间复杂度:$O(n^2 \\times m^2 \\times 1000)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1728` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1731-1740/1732. 找到最高海拔（简单）.md", "url_title": "1732. 找到最高海拔", "url": "https://leetcode.cn/problems/find-the-highest-altitude/solution/by-ac_oier-a0j8/", "difficulty": "简单", "tags": ["模拟"], "question": "有一个自行车手打算进行一场公路骑行,这条路线总共由 $n + 1$ 个不同海拔的点组成。自行车手从海拔为 `0` 的点 `0` 开始骑行。\n\n给你一个长度为 `n` 的整数数组 `gain`,其中 `gain[i]` 是点 `i` 和点 `i + 1` 的 净海拔高度差($0 <= i < n$)。请你返回 最高点的海拔 。\n\n示例 1:\n```\n输入:gain = [-5,1,5,0,-7]\n\n输出:1\n\n解释:海拔高度依次为 [0,-5,-4,1,1,-6] 。最高海拔为 1 。\n```\n示例 2:\n```\n输入:gain = [-4,-3,-2,-1,4,3,2]\n\n输出:0\n\n解释:海拔高度依次为 [0,-4,-7,-9,-10,-6,-3,-1] 。最高海拔为 0 。\n```\n\n提示:\n* $n = gain.length$\n* $1 <= n <= 100$\n* $-100 <= gain[i] <= 100$", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public int largestAltitude(int[] g) {\n        int cur = 0, ans = 0;\n        for (int x : g) {\n            cur += x;\n            ans = Math.max(ans, cur);\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction largestAltitude(g: number[]): number {\n    let cur = 0, ans = 0\n    for (let x of g) {\n        cur += x\n        ans = Math.max(ans, cur)\n    }\n    return ans\n}\n```\nPython3 代码:\n```Python\nclass Solution:\n    def largestAltitude(self, g: List[int]) -> int:\n        cur, ans = 0, 0\n        for x in g:\n            cur += x\n            ans = max(ans, cur)\n        return ans\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1732` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1731-1740/1734. 解码异或后的排列（中等）.md", "url_title": "1734. 解码异或后的排列", "url": "https://leetcode-cn.com/problems/decode-xored-permutation/solution/gong-shui-san-xie-note-bie-pian-li-yong-zeh6o/", "difficulty": "中等", "tags": ["数学", "异或"], "question": "给你一个整数数组 perm ,它是前 n 个正整数的排列,且 n 是个 奇数 。\n\n它被加密成另一个长度为 n - 1 的整数数组 encoded ,满足 encoded[i] = perm[i] XOR perm[i + 1] 。比方说,如果 perm = [1,3,2] ,那么 encoded = [2,1] 。\n\n给你 encoded 数组,请你返回原始数组 perm 。题目保证答案存在且唯一。\n\n示例 1:\n```\n输入:encoded = [3,1]\n\n输出:[1,2,3]\n\n解释:如果 perm = [1,2,3] ,那么 encoded = [1 XOR 2,2 XOR 3] = [3,1]\n```\n示例 2:\n```\n输入:encoded = [6,5,4,6]\n\n输出:[2,4,1,5,3]\n```\n\n提示:\n* 3 <= n < $10^5$\n* n 是奇数。\n* encoded.length == n - 1", "solution": "### 基本分析\n\n我们知道异或运算有如下性质:\n1. 相同数值异或,结果为 $0$\n2. 任意数值与 $0$ 进行异或,结果为数值本身\n3. 异或本身满足交换律\n\n本题与  [1720. 解码异或后的数组](https://leetcode-cn.com/problems/decode-xored-array/solution/gong-shui-san-xie-li-yong-yi-huo-xing-zh-p1bi/) 的主要区别是没有给出首位元素。\n\n因此,求得答案数组的「首位元素」或者「结尾元素」可作为本题切入点。\n\n---\n\n### 数学 & 模拟\n\n我们定义答案数组为 `ans[]`,`ans[]` 数组的长度为 `n`,且 `n` 为奇数。\n\n即有 $[ans[0], ans[1], ans[2], ... , ans[n - 1]]$。\n\n给定的数组 `encoded[]` 其实是 $[ans[0] ⊕ ans[1], ans[1] ⊕ ans[2], ... , ans[n - 3] ⊕ ans[n - 2], ans[n - 2] ⊕ ans[n - 1]]$,长度为 `n - 1`。\n\n由于每相邻一位会出现相同的数组成员 `ans[x]`,考虑“每隔一位”进行异或:\n\n1. **从 `encoded[]` 的第 $0$ 位开始,每隔一位进行异或:可得 $ans[0] ⊕ ans[1] ⊕ ... ⊕ ans[n - 2]$,即除了 `ans[]` 数组中的 $ans[n - 1]$ 以外的所有异或结果。**\n\n2. **利用 `ans[]` 数组是 `n` 个正整数的排列,我们可得 $ans[0] ⊕ ans[1] ⊕ ... ⊕ ans[n - 2] ⊕ ans[n - 1]$,即 `ans[]` 数组中所有元素的异或结果。**\n\n将两式进行「异或」,可得 $ans[n - 1]$。\n\n有了结尾元素后,问题变为与 [1720. 解码异或后的数组](https://leetcode-cn.com/problems/decode-xored-array/solution/gong-shui-san-xie-li-yong-yi-huo-xing-zh-p1bi/) 类似的模拟题。\n\n代码:\n```Java\nclass Solution {\n    public int[] decode(int[] encoded) {\n        int n = encoded.length + 1;\n        int[] ans = new int[n];\n        // 求得除了 ans[n - 1] 的所有异或结果\n        int a = 0;\n        for (int i = 0; i < n - 1; i += 2) a ^= encoded[i];\n        // 求得 ans 的所有异或结果\n        int b = 0;\n        for (int i = 1; i <= n; i++) b ^= i;\n        // 求得 ans[n - 1] 后,从后往前做\n        ans[n - 1] = a ^ b;\n        for (int i = n - 2; i >= 0; i--) {\n            ans[i] = encoded[i] ^ ans[i + 1];\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:构建同等数量级的答案数组。复杂度为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1734` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1731-1740/1736. 替换隐藏数字得到的最晚时间（简单）.md", "url_title": "1736. 替换隐藏数字得到的最晚时间", "url": "https://leetcode-cn.com/problems/latest-time-by-replacing-hidden-digits/solution/gong-shui-san-xie-ti-huan-yin-cang-shu-z-2l1h/", "difficulty": "简单", "tags": ["贪心"], "question": "给你一个字符串 `time`,格式为 `hh:mm`(小时:分钟),其中某几位数字被隐藏(用 `?` 表示)。\n\n有效的时间为 `00:00` 到 `23:59` 之间的所有时间,包括 `00:00` 和 `23:59` 。\n\n替换 `time` 中隐藏的数字,返回你可以得到的最晚有效时间。\n\n示例 1:\n```\n输入:time = \"2?:?0\"\n\n输出:\"23:50\"\n\n解释:以数字 '2' 开头的最晚一小时是 23 ,以 '0' 结尾的最晚一分钟是 50 。\n```\n示例 2:\n```\n输入:time = \"0?:3?\"\n\n输出:\"09:39\"\n```\n示例 3:\n```\n输入:time = \"1?:22\"\n\n输出:\"19:22\"\n```\n\n提示:\n* `time` 的格式为 `hh:mm`\n* 题目数据保证你可以由输入的字符串生成有效的时间", "solution": "### 贪心 + 模拟\n\n规则十分简单,对每一位进行分情况讨论即可:\n\n* 第一位:如果需要被替换,优先替换为 `2`,当然前提是第二位不能超过 `4`。否则会出现 `24:xx`、`25:xx` 等;\n* 第二位:如果需要被替换,根据第一位是什么,决定替换为 `9` 还是 `3`;\n* 第三位:固定为 `:`;\n* 第四位:如果需要被替换,替换为 `5`;\n* 第五位:如果需要被替换,替换为 `9`。\n\n代码:\n```Java\nclass Solution {\n    public String maximumTime(String time) {\n        StringBuilder sb = new StringBuilder();\n        sb.append(time.charAt(0) == '?' ? (time.charAt(1) == '?' || time.charAt(1) < '4') ? '2' : '1' : time.charAt(0));\n        sb.append(time.charAt(1) == '?' ? sb.charAt(0) == '2' ? '3' : '9' : time.charAt(1));\n        sb.append(':');\n        sb.append(time.charAt(3) == '?' ? '5' : time.charAt(3));\n        sb.append(time.charAt(4) == '?' ? '9' : time.charAt(4));\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1736` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1731-1740/1737. 满足三条件之一需改变的最少字符数（中等）.md", "url_title": "1737. 满足三条件之一需改变的最少字符数", "url": "https://leetcode.cn/problems/change-minimum-characters-to-satisfy-one-of-three-conditions/solution/by-ac_oier-vs5u/", "difficulty": "中等", "tags": ["枚举", "计数", "模拟"], "question": "给你两个字符串 `a` 和 `b` ,二者均由小写字母组成。\n\n一步操作中,你可以将 `a` 或 `b` 中的 任一字符 改变为 任一小写字母 。\n\n操作的最终目标是满足下列三个条件 之一 :\n* `a` 中的 每个字母 在字母表中 **严格小于**  `b` 中的 每个字母 。\n* `b` 中的 每个字母 在字母表中 **严格小于**  `a` 中的 每个字母 。\n* `a` 和 `b` 都 由 同一个 字母组成。\n\n返回达成目标所需的 最少 操作数。\n\n示例 1:\n``` \n输入:a = \"aba\", b = \"caa\"\n\n输出:2\n\n解释:满足每个条件的最佳方案分别是:\n1) 将 b 变为 \"ccc\",2 次操作,满足 a 中的每个字母都小于 b 中的每个字母;\n2) 将 a 变为 \"bbb\" 并将 b 变为 \"aaa\",3 次操作,满足 b 中的每个字母都小于 a 中的每个字母;\n3) 将 a 变为 \"aaa\" 并将 b 变为 \"aaa\",2 次操作,满足 a 和 b 由同一个字母组成。\n最佳的方案只需要 2 次操作(满足条件 1 或者条件 3)。\n```\n示例 2:\n``` \n输入:a = \"dabadd\", b = \"cda\"\n\n输出:3\n\n解释:满足条件 1 的最佳方案是将 b 变为 \"eee\" 。\n```\n\n提示:\n* $1 <= a.length, b.length <= 10^5$\n* `a` 和 `b` 只由小写字母组成", "solution": "### 计数 + 枚举\n\n使用 `c1` 和 `c2` 对字符串 `a` 和 `b` 分别进行词频统计,记字符串 `a` 和 `b` 的长度为 $n$ 和 $m$。\n\n然后枚举字符 $i$,分别对三种情况的修改次数进行统计:\n\n1. 对应条件 $1$:目的是要将字符串 `a` 中所有的字符变得「严格小于」字符 $i$,将字符串 `b` 中的所有字符变成「不小于/大于等于」字符 $i$。\n    这可以分别统计 `a` 中大小满足「大于等于」字符 $i$ 的字符数量,以及 `b` 中大小满足「小于」字符 $i$ 数量,两者之和即是满足该条件的最小修改次数。\n    注意,当 $i = 0$(含义为枚举到小写字母 $a$)时,需要跳过,因为不存在值大小「严格小于」字母 $a$ 的字符,即无法做到将某个字符串替换成所有字符都「严格小于」字母 $a$;\n2. 对应条件 $2$:与条件 $1$ 同理;\n3. 对应条件 $3$:如果要将两字符的所有字符都变成 $i$,其中字符串 `a` 要修改的字符数为 $ca = n - c1[i]$,字符串 `b` 要修改的字符数为 $cb = m - c2[i]$,总修改次数为 $ca + cb$。\n\n枚举完所有的字符 $i$ 后,统计到的所有修改次数的最小值即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int minCharacters(String a, String b) {\n        int n = a.length(), m = b.length(), ans = 0x3f3f3f3f;\n        int[] c1 = new int[26], c2 = new int[26];\n        for (char c : a.toCharArray()) c1[c - 'a']++;\n        for (char c : b.toCharArray()) c2[c - 'a']++;\n        for (int i = 0; i < 26 && ans != 0; i++) {\n            // 3\n            int ca = n - c1[i], cb = m - c2[i];\n            ans = Math.min(ans, ca + cb);\n            if (i == 0) continue;\n            int r1 = 0, r2 = 0;\n            // 1\n            for (int j = i; j < 26; j++) r1 += c1[j];\n            for (int j = 0; j < i; j++) r1 += c2[j];\n            // 2\n            for (int j = i; j < 26; j++) r2 += c2[j];\n            for (int j = 0; j < i; j++) r2 += c1[j];\n            ans = Math.min(ans, Math.min(r1, r2));\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:统计词频的复杂度为 $O(n + m)$,统计答案的复杂度为 $O(C^2)$,其中 $C = 26$ 为字符集大小\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1737` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1731-1740/1738. 找出第 K 大的异或坐标值（中等）.md", "url_title": "1738. 找出第 K 大的异或坐标值", "url": "https://leetcode-cn.com/problems/find-kth-largest-xor-coordinate-value/solution/gong-shui-san-xie-xiang-jie-li-yong-er-w-ai0d/", "difficulty": "中等", "tags": ["Top K", "数学", "前缀和"], "question": "给你一个二维矩阵 matrix 和一个整数 k ,矩阵大小为 m x n 由非负整数组成。\n\n矩阵中坐标 (a, b) 的 值 可由对所有满足 0 <= i <= a < m 且 0 <= j <= b < n 的元素 matrix[i][j](下标从 0 开始计数)执行异或运算得到。\n\n请你找出 matrix 的所有坐标中第 k 大的值(k 的值从 1 开始计数)。\n\n示例 1:\n```\n输入:matrix = [[5,2],[1,6]], k = 1\n\n输出:7\n\n解释:坐标 (0,1) 的值是 5 XOR 2 = 7 ,为最大的值。\n```\n示例 2:\n```\n输入:matrix = [[5,2],[1,6]], k = 2\n\n输出:5\n\n解释:坐标 (0,0) 的值是 5 = 5 ,为第 2 大的值。\n```\n示例 3:\n```\n输入:matrix = [[5,2],[1,6]], k = 3\n\n输出:4\n\n解释:坐标 (1,0) 的值是 5 XOR 1 = 4 ,为第 3 大的值。\n```\n示例 4:\n```\n输入:matrix = [[5,2],[1,6]], k = 4\n\n输出:0\n\n解释:坐标 (1,1) 的值是 5 XOR 2 XOR 1 XOR 6 = 0 ,为第 4 大的值。\n```\n\n提示:\n\n* m == matrix.length\n* n == matrix[i].length\n* 1 <= m, n <= 1000\n* 0 <= `matrix[i][j]` <= $10^6$\n* 1 <= k <= m * n", "solution": "### 基本分析\n\n根据题意,我们知道其实就是求「所有子矩阵中第 $k$ 大的异或和」,同时规定所有子矩阵的左上角端点为 $(0, 0)$。\n\n数据范围为 $10^3$,因此「枚举所有右下角」并「每次计算子矩阵异或和」的朴素做法 $O(m^2 * n^2)$ 不用考虑。\n\n要在全局中找最优,「枚举所有右下角」过程不可避免,我们可以优化「每次计算子矩阵异或和」的过程。\n\n这个分析过程与 [1310. 子数组异或查询](https://leetcode-cn.com/problems/xor-queries-of-a-subarray/solution/gong-shui-san-xie-yi-ti-shuang-jie-shu-z-rcgu/) 类似。\n\n**异或作为不进位加法,可以利用「偶数次异或结果为 $0$」的特性实现类似「前缀和」的容斥。这使得我们可以在 $O(1)$ 的复杂度内计算「某个子矩阵的异或和」。**\n\n---\n\n### 二维前缀异或 & 优先队列(堆)\n\n创建二维数组 $sum[][]$,令 $sum[i][j]$ 为以 $(i, j)$ 为右下角的子矩阵的异或和,我们可以得出计算公式:\n\n$$\nsum[i][j] = sum[i - 1][j] ⊕ sum[i][j - 1] ⊕ sum[i - 1][j - 1] ⊕ matrix[i - 1][j - 1]\n$$\n\n剩下的问题是,如果从所有的「子矩阵异或和」找到第 $k$ 大的值。\n\n变成了 [Top K](https://leetcode-cn.com/problems/kth-largest-element-in-a-stream/solution/jian-da-ti-de-duo-chong-jie-fa-mou-pao-p-d1qi/) 问题,可以使用「排序」或「堆」进行求解。\n\n具体的,我们可以建立一个大小为 $k$ 的小根堆,在计算二维前缀异或时,判断当前「子矩阵异或和」是否大于堆顶元素:\n\n* 大于堆顶元素:当前子矩阵异或和可能是第 $k$ 大的值,堆顶元素不可能为第 $k$ 大的值。将堆顶元素弹出,并将当前子矩阵和加入堆中\n* 小于堆顶元素:不会是第 $k$ 大的值,直接丢弃。\n* 等于堆顶元素:有相同元素在堆中,直接丢弃。\n\n最终的堆顶元素即为答案。\n\n代码:\n```Java\nclass Solution {\n    public int kthLargestValue(int[][] mat, int k) {\n        int m = mat.length, n = mat[0].length;\n        int[][] sum = new int[m + 1][n + 1];\n        PriorityQueue<Integer> q = new PriorityQueue<>(k, (a, b)->a - b);\n        for (int i = 1; i <= m; i++) {\n            for (int j = 1; j <= n; j++) {\n                sum[i][j] = sum[i - 1][j] ^ sum[i][j - 1] ^ sum[i - 1][j - 1] ^ mat[i - 1][j - 1];\n                if (q.size() < k) {\n                    q.add(sum[i][j]);\n                } else {\n                    if (sum[i][j] > q.peek()) {\n                        q.poll();\n                        q.add(sum[i][j]);\n                    }\n                }\n            }\n        }\n        return q.peek();\n    }\n}\n```\n* 时间复杂度:$O(m * n * \\log{k})$\n* 空间复杂度:$O(m * n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1738` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1741-1750/1742. 盒子中小球的最大数量（简单）.md", "url_title": "1742. 盒子中小球的最大数量", "url": "https://leetcode.cn/problems/maximum-number-of-balls-in-a-box/solution/by-ac_oier-3mxf/", "difficulty": "简单", "tags": ["哈希表", "模拟"], "question": "你在一家生产小球的玩具厂工作,有 `n` 个小球,编号从 `lowLimit` 开始,到 `highLimit` 结束(包括 `lowLimit` 和 `highLimit` ,即 `n == highLimit - lowLimit + 1`)。另有无限数量的盒子,编号从 `1` 到 `infinity` 。\n\n你的工作是将每个小球放入盒子中,其中盒子的编号应当等于小球编号上每位数字的和。例如,编号 `321` 的小球应当放入编号 `3 + 2 + 1 = 6` 的盒子,而编号 `10` 的小球应当放入编号 `1 + 0 = 1` 的盒子。\n\n给你两个整数 `lowLimit` 和 `highLimit` ,返回放有最多小球的盒子中的小球数量。如果有多个盒子都满足放有最多小球,只需返回其中任一盒子的小球数量。\n\n示例 1:\n```\n输入:lowLimit = 1, highLimit = 10\n输出:2\n\n解释:\n盒子编号:1 2 3 4 5 6 7 8 9 10 11 ...\n小球数量:2 1 1 1 1 1 1 1 1 0  0  ...\n编号 1 的盒子放有最多小球,小球数量为 2 。\n```\n示例 2:\n```\n输入:lowLimit = 5, highLimit = 15\n\n输出:2\n\n解释:\n盒子编号:1 2 3 4 5 6 7 8 9 10 11 ...\n小球数量:1 1 1 1 2 2 1 1 1 0  0  ...\n编号 5 和 6 的盒子放有最多小球,每个盒子中的小球数量都是 2 。\n```\n示例 3:\n```\n输入:lowLimit = 19, highLimit = 28\n\n输出:2\n\n解释:\n盒子编号:1 2 3 4 5 6 7 8 9 10 11 12 ...\n小球数量:0 1 1 1 1 1 1 1 1 2  0  0  ...\n编号 10 的盒子放有最多小球,小球数量为 2 。\n```\n\n提示:\n* $1 <= lowLimit <= highLimit <= 10^5$", "solution": "### 模拟\n\n数据范围 $n = 1e5$,因此最大盒子编号 `99999 = 5 * 9 = 45`,我们可以用一个大小为 $50$ 的数组 `cnts` 来统计每个编号盒子中小球的数量,$cnts[idx] = x$ 含义为编号为 $idx$ 的盒子有 $x$ 个小球。\n\nJava 代码:\n```Java\nclass Solution {\n    public int countBalls(int l, int r) {\n        int ans = 0;\n        int[] cnts = new int[50];\n        for (int i = l; i <= r; i++) {\n            int j = i, cur = 0;\n            while (j != 0) {\n                cur += j % 10; j /= 10;\n            }\n            if (++cnts[cur] > ans) ans = cnts[cur];\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction countBalls(l: number, r: number): number {\n    let ans = 0\n    const cnts = new Array<number>(50).fill(0)\n    for (let i = l; i <= r; i++) {\n        let j = i, cur = 0\n        while (j != 0) {\n            cur += j % 10\n            j = Math.floor(j / 10)\n        }\n        if (++cnts[cur] > ans) ans = cnts[cur]\n    }\n    return ans\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def countBalls(self, l: int, r: int) -> int:\n        ans = 0\n        cnts = [0] * 50\n        for i in range(l, r + 1):\n            j, cur = i, 0\n            while j != 0:\n                j, cur = j // 10, cur + j % 10\n            cnts[cur] += 1\n            if cnts[cur] > ans:\n                ans = cnts[cur]\n        return ans\n```\n* 时间复杂度:$O(n\\log{r})$\n* 空间复杂度:$O(C)$,其中 $C = 50$ 为最大盒子编号", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1742` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1741-1750/1743. 从相邻元素对还原数组（中等）.md", "url_title": "1743. 从相邻元素对还原数组", "url": "https://leetcode-cn.com/problems/restore-the-array-from-adjacent-pairs/solution/gong-shui-san-xie-yi-ti-shuang-jie-dan-x-elpx/", "difficulty": "中等", "tags": ["哈希表", "双指针", "模拟"], "question": "存在一个由 `n` 个不同元素组成的整数数组 `nums` ,但你已经记不清具体内容,好在你还记得 `nums` 中的每一对相邻元素。\n\n给你一个二维整数数组 `adjacentPairs` ,大小为 `n - 1` ,其中每个 $adjacentPairs[i] = [u_i, v_i]$ 表示元素 $u_i$ 和 $v_i$ 在 `nums` 中相邻。\n\n题目数据保证所有由元素 `nums[i]` 和 `nums[i+1]` 组成的相邻元素对都存在于 `adjacentPairs` 中,存在形式可能是 `[nums[i], nums[i+1]]` ,也可能是 `[nums[i+1], nums[i]]` 。这些相邻元素对可以「按任意顺序」出现。\n\n返回原始数组 `nums` 。如果存在多种解答,返回其中任意一个即可。\n\n示例 1:\n```\n输入:adjacentPairs = [[2,1],[3,4],[3,2]]\n\n输出:[1,2,3,4]\n\n解释:数组的所有相邻元素对都在 adjacentPairs 中。\n特别要注意的是,adjacentPairs[i] 只表示两个元素相邻,并不保证其 左-右 顺序。\n```\n示例 2:\n```\n输入:adjacentPairs = [[4,-2],[1,4],[-3,1]]\n\n输出:[-2,4,1,-3]\n\n解释:数组中可能存在负数。\n另一种解答是 [-3,1,4,-2] ,也会被视作正确答案。\n```\n示例 3:\n```\n输入:adjacentPairs = [[100000,-100000]]\n\n输出:[100000,-100000]\n```\n\n提示:\n* $nums.length == n$\n* $adjacentPairs.length == n - 1$\n* $adjacentPairs[i].length == 2$\n* $2 <= n <= 10^5$\n* $-10^5 <= nums[i], u_i, v_i <= 10^5$\n* 题目数据保证存在一些以 `adjacentPairs` 作为元素对的数组", "solution": "### 单向构造(哈希表计数)\n\n根据题意,由于所有的相邻关系都会出现在 $nums$ 中,假设其中一个合法数组为 $ans$,长度为 $n$。\n\n那么显然 $ans[0]$ 和 $ans[n - 1]$ 在 $nums$ 中只存在一对相邻关系,而其他 $ans[i]$ 则存在两对相邻关系。\n\n因此我们可以使用「哈希表」对 $nums$ 中出现的数值进行计数,找到“出现一次”的数值作为 $ans$ 数值的首位,然后根据给定的相邻关系进行「单向构造」,为了方便找到某个数其相邻的数是哪些,我们还需要再开一个「哈希表」记录相邻关系。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] restoreArray(int[][] adjacentPairs) {\n        int m = adjacentPairs.length, n = m + 1;\n        Map<Integer, Integer> cnts = new HashMap<>();\n        Map<Integer, List<Integer>> map = new HashMap<>();\n        for (int[] ap : adjacentPairs) {\n            int a = ap[0], b = ap[1];\n            cnts.put(a, cnts.getOrDefault(a, 0) + 1);\n            cnts.put(b, cnts.getOrDefault(b, 0) + 1);\n            List<Integer> alist = map.getOrDefault(a, new ArrayList<>());\n            alist.add(b);\n            map.put(a, alist);\n            List<Integer> blist = map.getOrDefault(b, new ArrayList<>());\n            blist.add(a);\n            map.put(b, blist);\n        }\n        int start = -1;\n        for (int i : cnts.keySet()) {\n            if (cnts.get(i) == 1) {\n                start = i;\n                break;\n            }\n        }\n        int[] ans = new int[n];\n        ans[0] = start;\n        ans[1] = map.get(start).get(0);\n        for (int i = 2; i < n; i++) {\n            int x = ans[i - 1];\n            List<Integer> list = map.get(x);\n            for (int j : list) {\n                if (j != ans[i - 2]) ans[i] = j;\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> restoreArray(vector<vector<int>>& adjacentPairs) {\n        unordered_map<int, int> cnts;\n        unordered_map<int, vector<int>> map;\n        for(auto& pair : adjacentPairs){\n            int a = pair[0], b = pair[1];\n            cnts[a]++, cnts[b]++;\n            map[a].push_back(b);\n            map[b].push_back(a);\n        }\n        int start;\n        for(auto& i : cnts) {\n            if(i.second == 1){\n                start = i.first;\n                break;\n            }\n        }\n        int n = adjacentPairs.size() + 1;\n        vector<int> ans(n);\n        ans[0] = start;\n        ans[1] = map[start][0];\n        for(int i = 2; i < n; i++){\n            int x = ans[i - 1];\n            for(int j : map[x])\n                if(j != ans[i-2]) ans[i] = j;\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def restoreArray(self, adjacentPairs: List[List[int]]) -> List[int]:\n        cnts = defaultdict(int)\n        map = defaultdict(list)\n        for ap in adjacentPairs:\n            a, b = ap[0], ap[1]\n            cnts[a] += 1 \n            cnts[b] += 1\n            map[a].append(b)\n            map[b].append(a)\n        start = next(i for i in cnts if cnts[i] == 1)\n        n = len(adjacentPairs) + 1\n        ans = [0] * n\n        ans[0] = start\n        ans[1] = map[start][0]\n        for i in range(2, n):\n            x = ans[i - 1]\n            for j in map[x]:\n                if j != ans[i - 2]: \n                    ans[i] = j\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction restoreArray(adjacentPairs: number[][]): number[] {\n    const cnts: {[key: number]: number} = {};\n    const map: {[key: number]: number[]} = {};\n    for(let pair of adjacentPairs){\n        let a: number = pair[0], b: number = pair[1];\n        cnts[a] = !cnts[a] ? 1 : cnts[a] + 1;\n        cnts[b] = !cnts[b] ? 1 : cnts[b] + 1;\n        if(!map[a]) map[a] = [];\n        if(!map[b]) map[b] = [];\n        map[a].push(b);\n        map[b].push(a);\n    }\n    let start: number;\n    for(let key in cnts){\n        if(cnts[key] == 1){\n            start = Number(key);\n            break;\n        }\n    }\n    const n: number = adjacentPairs.length + 1;\n    const ans: number[] = Array(n).fill(0);\n    ans[0] = start;\n    ans[1] = map[start][0];\n    for(let i = 2; i<n; i++){\n        let x: number = ans[i-1];\n        for(let j of map[x]){\n            if(j !== ans[i-2]) ans[i] = j;\n        }\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 双向构造(双指针)\n\n在解法一中,我们通过「哈希表」计数得到 $ans$ 首位元素作为起点,进行「单向构造」。\n\n那么是否存在使用任意数值作为起点进行的双向构造呢?\n\n答案是显然的,我们可以利用 $ans$ 的长度为 $2 <= n <= 10^5$,构造一个长度 $10^6$ 的数组 $q$(这里可以使用 `static` 进行加速,让多个测试用例共享一个大数组)。\n\n> 这里 $q$ 数组不一定要开成 $1e6$ 大小,只要我们 $q$ 大小大于 $ans$ 的两倍,就不会存在越界问题。\n\n从 $q$ 数组的 **中间位置** 开始,先随便将其中一个元素添加到中间位置,使用「双指针」分别往「两边拓展」(`l` 和 `r` 分别指向左右待插入的位置)。\n\n当 `l` 指针和 `r` 指针之间已经有 $n$ 个数值,说明整个 $ans$ 构造完成,我们将 $[l + 1, r - 1]$ 范围内的数值输出作为答案即可。\n\nJava 代码:\n```Java\nclass Solution {\n    static int N = (int)1e6+10;\n    static int[] q = new int[N];\n    public int[] restoreArray(int[][] adjacentPairs) {\n        int m = adjacentPairs.length, n = m + 1;\n        Map<Integer, List<Integer>> map = new HashMap<>();\n        for (int[] ap : adjacentPairs) {\n            int a = ap[0], b = ap[1];\n            List<Integer> alist =  map.getOrDefault(a, new ArrayList<>());\n            alist.add(b);\n            map.put(a, alist);\n            List<Integer> blist = map.getOrDefault(b, new ArrayList<>());\n            blist.add(a);\n            map.put(b, blist);\n        }\n        int l = N / 2, r = l + 1;\n        int std = adjacentPairs[0][0];\n        List<Integer> list = map.get(std);\n        q[l--] = std;\n        q[r++] = list.get(0);\n        if (list.size() > 1) q[l--] = list.get(1);\n        while ((r - 1) - (l + 1) + 1 < n) {\n            List<Integer> alist = map.get(q[l + 1]);\n            int j = l;\n            for (int i : alist) {\n                if (i != q[l + 2]) q[j--] = i;\n            }\n            l = j;\n\n            List<Integer> blist = map.get(q[r - 1]);\n            j = r;\n            for (int i : blist) {\n                if (i != q[r - 2]) q[j++] = i;\n            }\n            r = j;\n        }\n        int[] ans = new int[n];\n        for (int i = l + 1, idx = 0; idx < n; i++, idx++) {\n            ans[idx] = q[i];\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\n#define N 1000010\nclass Solution {\npublic:\n    vector<int> restoreArray(vector<vector<int>>& adjacentPairs) {\n        int m = adjacentPairs.size(), n = m + 1;\n        unordered_map<int, vector<int>> map;\n        for(auto& pair : adjacentPairs){\n            int a = pair[0], b = pair[1];\n            map[a].push_back(b);\n            map[b].push_back(a);\n        }\n        int l = N / 2, r = l + 1;\n        int s = adjacentPairs[0][0];\n        vector<int> q(N, 0);\n        q[l--] = s;\n        q[r++] = map[s][0];\n        if (map[s].size() > 1) q[l--] = map[s][1];\n        while ((r - 1) - (l + 1) + 1 < n){\n            vector<int> list = map[q[l + 1]];\n            int j = l;\n            for(auto& i : list){\n                if(i != q[l + 2]) q[j--] = i;\n            }\n            l = j;\n\n            list = map[q[r - 1]];\n            j = r;\n            for(auto& i : list){\n                if(i != q[r - 2]) q[j++] = i;\n            }\n            r = j;\n        }\n        vector<int> ans(n);\n        for(int i = l + 1, idx = 0; idx < n; ++i, ++idx){\n            ans[idx] = q[i];\n        }\n        return ans;\n    }\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1743` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1741-1750/1744. 你能在你最喜欢的那天吃到你最喜欢的糖果吗？（中等）.md", "url_title": "1744. 你能在你最喜欢的那天吃到你最喜欢的糖果吗?", "url": "https://leetcode-cn.com/problems/can-you-eat-your-favorite-candy-on-your-favorite-day/solution/gong-shui-san-xie-qian-zhui-he-qiu-jie-c-b38y/", "difficulty": "中等", "tags": ["前缀和"], "question": "给你一个下标从 `0` 开始的正整数数组 `candiesCount`,其中 `candiesCount[i]` 表示你拥有的第 `i` 类糖果的数目。\n\n同时给你一个二维数组 `queries` ,其中 $queries[i] = [favoriteType_{i}, favoriteDay_{i}, dailyCap_{i}]$ 。\n\n你按照如下规则进行一场游戏:\n\n* 你从第 `0` 天开始吃糖果。\n* 你在吃完 所有 第 `i - 1` 类糖果之前,不能 吃任何一颗第 `i` 类糖果。\n* 在吃完所有糖果之前,你必须每天 至少 吃 一颗 糖果。\n\n请你构建一个布尔型数组 `answer`,满足 `answer.length == queries.length`。`answer[i]` 为 `true` 的条件是:在每天吃 不超过 $dailyCap_i$ 颗糖果的前提下,你可以在第 $favoriteDay_i$ 天吃到第 $favoriteType_i$ 类糖果;否则 `answer[i]` 为 `false`。注意,只要满足上面 `3` 条规则中的第二条规则,你就可以在同一天吃不同类型的糖果。\n\n请你返回得到的数组 `answer` 。\n\n示例 1:\n```\n输入:candiesCount = [7,4,5,3,8], queries = [[0,2,2],[4,2,4],[2,13,1000000000]]\n\n输出:[true,false,true]\n\n提示:\n1- 在第 0 天吃 2 颗糖果(类型 0),第 1 天吃 2 颗糖果(类型 0),第 2 天你可以吃到类型 0 的糖果。\n2- 每天你最多吃 4 颗糖果。即使第 0 天吃 4 颗糖果(类型 0),第 1 天吃 4 颗糖果(类型 0 和类型 1),你也没办法在第 2 天吃到类型 4 的糖果。换言之,你没法在每天吃 4 颗糖果的限制下在第 2 天吃到第 4 类糖果。\n3- 如果你每天吃 1 颗糖果,你可以在第 13 天吃到类型 2 的糖果。\n```\n示例 2:\n```\n输入:candiesCount = [5,2,6,4,1], queries = [[3,1,2],[4,10,3],[3,10,100],[4,100,30],[1,3,1]]\n\n输出:[false,true,true,false,false]\n```\n\n提示:\n* $1 <= candiesCount.length <= 10^5$\n* $1 <= candiesCount[i] <= 10^5$\n* $1 <= queries.length <= 10^5$\n* $queries[i].length == 3$\n* $0 <= favoriteType_{i} < candiesCount.length$\n* $0 <= favoriteDay_{i} <= 10^9$\n* $1 <= dailyCap_{i} <= 10^9$", "solution": "### 基本分析\n\n根据题意,在处理某个询问时,每天的吃糖数量为 $[1, queries[i][2]]$,因此我们可以计算出「最早/最晚」吃到第 $queries[i][0]$ 类糖果的时间,然后判断 $queries[i][1]$ 是否落在范围内,若落在范围内返回则有 $ans[i]$ 为 `True`,否则为 `False`。\n\n---\n\n### 前缀和\n\n问题转换为如何快速求得「最早/最晚」吃到第 $queries[i][0]$ 类糖果的时间。\n\n我们需要先预处理出 $candiesCount$ 的前缀和数组 $sum$(下标从 $1$ 开始),方便快速求得第 $i$ 类糖果之前有多少糖果。\n\n为了方便,在处理某个询问时,我们令 $t = queries[i][0],d = queries[i][1] + 1,c = queries[i][2]$。其中 $d = queries[i][1] + 1$ 是因为题目天数是从 $0$ 开始计算,而我们的计算是从 $1$ 开始。\n\n然后计算「最早/最晚」吃到第 $t$ 类糖果的时间:\n\n* 最早时间(第一颗 $t$ 类糖的最早时间):当以最大速率 $c$ 吃糖时,可以在最早时间内吃到糖。时间为吃掉第 $t$ 类糖果 **前面** 的所有糖果的时间(下取整)加 $1$ :\n\n$$\n\\left \\lfloor \\frac{sum[t]}{c} \\right \\rfloor + 1\n$$\n\n* 最晚时间(最后一颗 $t$ 类糖的最晚时间):当以最小速率 $1$ 吃糖时,可以计算出最晚吃糖时间。时间为吃掉所有 $t$ 类糖的时间:\n\n$$\nsum[t + 1]\n$$\n\n代码:\n```Java\nclass Solution {\n    public boolean[] canEat(int[] cs, int[][] qs) {\n        int n = qs.length, m = cs.length;\n        boolean[] ans = new boolean[n];\n        long[] sum = new long[m + 1];\n        for (int i = 1; i <= m; i++) sum[i] = sum[i - 1] + cs[i - 1];\n        for (int i = 0; i < n; i++) {\n            int t = qs[i][0], d = qs[i][1] + 1, c = qs[i][2];\n            long a = sum[t] / c + 1, b = sum[t + 1];\n            ans[i] = a <= d && d <= b;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:`cs` 数组的长度为 `n`,`qs` 数组的长度为 `m`。预处理前缀和的复杂度为 $O(n)$;处理每个询问的复杂度为 $O(1)$,共有 $m$ 个询问,复杂度为 $O(m)$。整体复杂度为 $O(\\max(n, m))$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1744` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1741-1750/1748. 唯一元素的和（简单）.md", "url_title": "1748. 唯一元素的和", "url": "https://leetcode-cn.com/problems/sum-of-unique-elements/solution/gong-shui-san-xie-yi-ti-shuang-jie-pai-x-atnd/", "difficulty": "简单", "tags": ["模拟", "哈希表", "双指针", "排序"], "question": "给你一个整数数组 nums 。数组中唯一元素是那些只出现「恰好一次」的元素。\n\n请你返回 nums 中唯一元素的和 。\n\n示例 1:\n```\n输入:nums = [1,2,3,2]\n\n输出:4\n\n解释:唯一元素为 [1,3] ,和为 4 。\n```\n示例 2:\n```\n输入:nums = [1,1,1,1,1]\n\n输出:0\n\n解释:没有唯一元素,和为 0 。\n```\n示例 3 :\n```\n输入:nums = [1,2,3,4,5]\n\n输出:15\n\n解释:唯一元素为 [1,2,3,4,5] ,和为 15 。\n```\n\n提示:\n* 1 <= nums.length <= 100\n* 1 <= nums[i] <= 100", "solution": "### 排序 + 双指针\n\n根据题意,其中一个做法是先对 `nums` 进行排序,使用双指针找到值相同的连续段 $[i, j)$,若连续段长度为 $1$,则将该值累加到答案。\n\n代码:\n```Java\nclass Solution {\n    public int sumOfUnique(int[] nums) {\n        Arrays.sort(nums);\n        int n = nums.length, ans = 0;\n        for (int i = 0; i < n; ) {\n            int j = i;\n            while (j < n && nums[j] == nums[i]) j++;\n            if (j - i == 1) ans += nums[i];\n            i = j;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$;统计答案复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$\n\n---\n\n### 哈希表\n\n另外容易想到使用「哈希表」统计某个数的出现次数,又根据 $nums[i]$ 的范围为 $[1, 100]$,可直接使用数组充当哈希表。\n\n代码:\n```Java\nclass Solution {\n    int[] cnt = new int[110];\n    public int sumOfUnique(int[] nums) {\n        for (int i : nums) cnt[i]++;\n        int ans = 0;\n        for (int i = 1; i <= 100; i++) {\n            if (cnt[i] == 1) ans += i;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $C$ 为 $nums[i]$ 的值域大小,本题固定为 $110$。整体复杂度为 $O(n + C)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1748` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1741-1750/1749. 任意子数组和的绝对值的最大值（中等）.md", "url_title": "1749. 任意子数组和的绝对值的最大值", "url": "https://leetcode-cn.com/problems/maximum-absolute-sum-of-any-subarray/solution/xiang-jie-qian-zhui-he-jie-fa-fen-xi-si-yibby/", "difficulty": "中等", "tags": ["前缀和"], "question": "给你一个整数数组 nums 。\n\n一个子数组 `[numsl, numsl+1, ..., numsr-1, numsr]` 的「和的绝对值」为 `abs(numsl + numsl+1 + ... + numsr-1 + numsr) `。\n\n请你找出 nums 中 和的绝对值 最大的任意子数组(可能为空),并返回该 最大值 。\n\nabs(x) 定义如下:\n\n* 如果 x 是负整数,那么 abs(x) = -x 。\n\n* 如果 x 是非负整数,那么 abs(x) = x 。\n\n  \n\n示例 1:\n```\n输入:nums = [1,-3,2,3,-4]\n\n输出:5\n\n解释:子数组 [2,3] 和的绝对值最大,为 abs(2+3) = abs(5) = 5 。\n```\n示例 2:\n```\n输入:nums = [2,-5,1,-4,3,-2]\n\n输出:8\n\n解释:子数组 [-5,1,-4] 和的绝对值最大,为 abs(-5+1-4) = abs(-8) = 8 。\n```\n\n提示:\n* 1 <= nums.length <= $10^5$\n* -$10^4$ <= nums[i] <= $10^4$", "solution": "### 前缀和\n\n题目要我们求连续一段的子数组的和,很自然就能想到前缀和。\n\n当我们有了前缀和数组 `sum`  之后,需要求任意一段子数组 `[i,j]` 的和可以直接通过 `sum[j] - sum[i - 1]` 得出。\n\n要使得 `abs(sum[j] - sum[i - 1])` 最大,其实有这么几种情况:\n\n* 找到前缀和数组中的最大值减去最小值,得到一个最大正数(前提是最大值出现在最小值的后面,并且最小值是个负数,否则应该直接取最大值作为答案)\n* 找到前缀和的最小值减去最大值,得到一个最小负数(前提是最小值出现在最大值的后面,而且最大值是一个正数,否则直接取最小值作为答案)。\n\n也就是说最终答案只与前缀和数组中的最大值和最小值相关,而且最大值可能会出现在最小值前面或者后面。\n\n因此我们可以边循环边做更新答案。\n\n代码:\n```Java\nclass Solution {\n    public int maxAbsoluteSum(int[] nums) {\n        int n = nums.length;\n        int[] sum = new int[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n        int ans = 0;\n        for (int i = 1, min = 0, max = 0; i <= n; i++) {\n            ans = Math.max(ans, Math.abs(sum[i] - min));\n            ans = Math.max(ans, Math.abs(sum[i] - max));\n            max = Math.max(max, sum[i]);\n            min = Math.min(min, sum[i]);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1749` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1751-1760/1751. 最多可以参加的会议数目 II（困难）.md", "url_title": "1751. 最多可以参加的会议数目 II", "url": "https://leetcode-cn.com/problems/maximum-number-of-events-that-can-be-attended-ii/solution/po-su-dp-er-fen-dp-jie-fa-by-ac_oier-88du/", "difficulty": "困难", "tags": ["二分", "序列 DP"], "question": "给你一个 `events` 数组,其中 $events[i] = [startDay_i, endDay_i, value_i]$ ,表示第 $i$ 个会议在 $startDay_i$ 天开始,第 $endDay_i$ 天结束,如果你参加这个会议,你能得到价值 $value_i$ 。\n\n同时给你一个整数 $k$ 表示你能参加的最多会议数目。\n\n你同一时间只能参加一个会议。如果你选择参加某个会议,那么你必须完整地参加完这个会议。\n\n会议结束日期是包含在会议内的,也就是说你不能同时参加一个开始日期与另一个结束日期相同的两个会议。\n\n请你返回能得到的会议价值最大和。\n\n示例 1:\n\n```\n输入:events = [[1,2,4],[3,4,3],[2,3,1]], k = 2\n\n输出:7\n\n解释:选择绿色的活动会议 0 和 1,得到总价值和为 4 + 3 = 7 。\n```\n示例 2:\n\n```\n输入:events = [[1,2,4],[3,4,3],[2,3,10]], k = 2\n\n输出:10\n\n解释:参加会议 2 ,得到价值和为 10 。\n你没法再参加别的会议了,因为跟会议 2 有重叠。你 不 需要参加满 k 个会议。\n```\n示例 3:\n\n```\n输入:events = [[1,1,1],[2,2,2],[3,3,3],[4,4,4]], k = 3\n\n输出:9\n\n解释:尽管会议互不重叠,你只能参加 3 个会议,所以选择价值最大的 3 个会议。\n```\n\n提示:\n* $1 <= k <= events.length$\n* $1 <= k * events.length <= 10^6$\n* $1 <= startDay_i <= endDay_i <= 10^9$\n* $1 <= value_i <= 10^6$", "solution": "### 基本思路\n\n**定义 $f[i][j]$ 为考虑前 $i$ 个事件,选择不超过 $j$ 的最大价值**\n\n对于每个事件,都有选择与不选两种选择:\n\n* 不选: $f[i][j] = f[i - 1][j]$\n* 选:找到第 $i$ 件事件之前,与第 $i$ 件事件不冲突的事件,记为 `last`,则有 $f[i][j] = f[last][j - 1] + value_i$\n\n两者取 $max$,则是 $f[i][j]$ 的值。\n\n分析到这里,因为我们要找 `last`,我们需要先对 `events` 的结束时间排序,然后找从右往左找,找到第一个满足 `结束时间 小于 当前事件的开始时间` 的事件,就是 `last`\n\n而找 `last` 的过程,可以直接循环找,也可以通过二分来找,都能过。\n\n---\n\n### 动态规划\n\n不通过「二分」来找 `last` 的 DP 解法。\n\n代码:\n```Java\nclass Solution {\n    public int maxValue(int[][] es, int k) {\n        int n = es.length;\n        Arrays.sort(es, (a, b)->a[1]-b[1]);\n        // f[i][j] 代表考虑前 i 个事件,选择不超过 j 的最大价值\n        int[][] f = new int[n + 1][k + 1];\n        for (int i = 1; i <= n; i++) {\n            int[] ev = es[i - 1];\n            int s = ev[0], e = ev[1], v = ev[2];\n            \n            // 找到第 i 件事件之前,与第 i 件事件不冲突的事件\n            // 对于当前事件而言,冲突与否,与 j 无关\n            int last = 0;\n            for (int p = i - 1; p >= 1; p--) {\n                int[] prev = es[p - 1];\n                if (prev[1] < s) {\n                    last = p;\n                    break;\n                }\n            }\n            \n            for (int j = 1; j <= k; j++) {\n                f[i][j] = Math.max(f[i - 1][j], f[last][j - 1] + v);    \n            }\n        }\n        return f[n][k];\n    }\n}\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$,循环 `n` 个事件,每次循环需要往回找一个事件,复杂度为 $O(n)$,并更新 `k` 个状态,复杂度为 $O(k)$,因此转移的复杂度为 $O(n \\times (n + k))$;总的复杂度为 $O(n \\times (n + k + \\log{n}))$\n* 空间复杂度:$O(n \\times k)$\n\n---\n\n### 二分 + 动态规划\n\n通过「二分」来找 `last` 的 DP 解法。\n\n代码:\n```Java\nclass Solution {\n    public int maxValue(int[][] es, int k) {\n        int n = es.length;\n        Arrays.sort(es, (a, b)->a[1]-b[1]);\n        // f[i][j] 代表考虑前 i 个事件,选择不超过 j 的最大价值\n        int[][] f = new int[n + 1][k + 1];\n        for (int i = 1; i <= n; i++) {\n            int[] ev = es[i - 1];\n            int s = ev[0], e = ev[1], v = ev[2];\n            \n            // 通过「二分」,找到第 i 件事件之前,与第 i 件事件不冲突的事件\n            // 对于当前事件而言,冲突与否,与 j 无关\n            int l = 1, r = i - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                int[] prev = es[mid - 1];\n                if (prev[1] < s) l = mid;    \n                else r = mid - 1;\n            }\n            int last = (r > 0 && es[r - 1][1] < s) ? r : 0;\n            \n            for (int j = 1; j <= k; j++) {\n                f[i][j] = Math.max(f[i - 1][j], f[last][j - 1] + v);    \n            }\n        }\n        return f[n][k];\n    }\n}\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$,循环 `n` 个事件,每次循环需要往回找一个事件,复杂度为 $O(\\log{n})$,并更新 `k` 个状态,复杂度为 $O(k)$,因此转移的复杂度为 $O(n \\times (\\log{n} + k))$;总的复杂度为 $O(n \\times (k + \\log{n}))$\n* 空间复杂度:$O(n \\times k)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1751` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1751-1760/1758. 生成交替二进制字符串的最少操作数（简单）.md", "url_title": "1758. 生成交替二进制字符串的最少操作数", "url": "https://leetcode.cn/problems/minimum-changes-to-make-alternating-binary-string/solution/by-ac_oier-gclh/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个仅由字符 `'0'` 和 `'1'` 组成的字符串 `s` 。一步操作中,你可以将任一 `'0'` 变成 `'1'` ,或者将 `'1'` 变成 `'0'` 。\n\n交替字符串 定义为:如果字符串中不存在相邻两个字符相等的情况,那么该字符串就是交替字符串。例如,字符串 `\"010\"` 是交替字符串,而字符串 `\"0100\"` 不是。\n\n返回使 `s` 变成 交替字符串 所需的 最少 操作数。\n\n示例 1:\n```\n输入:s = \"0100\"\n\n输出:1\n\n解释:如果将最后一个字符变为 '1' ,s 就变成 \"0101\" ,即符合交替字符串定义。\n```\n示例 2:\n```\n输入:s = \"10\"\n\n输出:0\n\n解释:s 已经是交替字符串。\n```\n示例 3:\n```\n输入:s = \"1111\"\n\n输出:2\n\n解释:需要 2 步操作得到 \"0101\" 或 \"1010\" 。\n```\n\n提示:\n* $1 <= s.length <= 10^4$\n* `s[i]` 是 `'0'` 或 `'1'`", "solution": "### 模拟\n\n最终结果只有「从 `0` 开始的交替串」和「从 `1` 开始的交替串」两种。\n\n对于一个长度为 `n` 的未知序列 `A` 而言,假设我们需要花费 `cnt` 次操作将其变为「从 `0` 开始的交替串」,那么我们想要将其变为「从 `1` 开始的交替串」则需要 `n - cnt` 次操作:原本操作的 `cnt` 个位置不能动,而原本没操作的位置则都需要翻转,从而确保两种交替串对应位均相反。\n\nJava 代码:\n```Java\nclass Solution {\n    public int minOperations(String s) {\n        int n = s.length(), cnt = 0;\n        for (int i = 0; i < n; i++) cnt += (s.charAt(i) - '0') ^ (i & 1);\n        return Math.min(cnt, n - cnt);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction minOperations(s: string): number {\n    let n = s.length, cnt = 0\n    for (let i = 0; i < n; i++) cnt += (s.charCodeAt(i) - '0'.charCodeAt(0)) ^ (i & 1)\n    return Math.min(cnt, n - cnt)\n}\n```\nPython3 代码:\n```Python3\nclass Solution:\n    def minOperations(self, s: str) -> int:\n        n, cnt = len(s), 0\n        for i, c in enumerate(s):\n            cnt += (ord(c) - ord('0')) ^ (i & 1)\n        return min(cnt, n - cnt)\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1758` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1751-1760/1759. 统计同构子字符串的数目（中等）.md", "url_title": "1759. 统计同构子字符串的数目", "url": "https://acoier.com/2022/12/26/1759.%20%E7%BB%9F%E8%AE%A1%E5%90%8C%E6%9E%84%E5%AD%90%E5%AD%97%E7%AC%A6%E4%B8%B2%E7%9A%84%E6%95%B0%E7%9B%AE%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/", "difficulty": "中等", "tags": ["双指针", "数学"], "question": "给你一个字符串 `s`,返回 `s` 中 同构子字符串 的数目。\n\n由于答案可能很大,只需返回对 $10^9 + 7$ 取余 后的结果。\n\n同构字符串的定义为:如果一个字符串中的所有字符都相同,那么该字符串就是同构字符串。\n\n子字符串是字符串中的一个连续字符序列。\n\n示例 1:\n```\n输入:s = \"abbcccaa\"\n\n输出:13\n\n解释:同构子字符串如下所列:\n\"a\"   出现 3 次。\n\"aa\"  出现 1 次。\n\"b\"   出现 2 次。\n\"bb\"  出现 1 次。\n\"c\"   出现 3 次。\n\"cc\"  出现 2 次。\n\"ccc\" 出现 1 次。\n3 + 1 + 2 + 1 + 3 + 2 + 1 = 13\n```\n示例 2:\n```\n输入:s = \"xy\"\n\n输出:2\n\n解释:同构子字符串是 \"x\" 和 \"y\" 。\n```\n示例 3:\n```\n输入:s = \"zzzzz\"\n\n输出:15\n```\n\n提示:\n* $1 <= s.length <= 10^5$\n* `s` 由小写字符串组成", "solution": "### 双指针 + 数学\n\n根据题意,我们需要找出 `s` 中所有字符相同的连续段。\n\n假设 $s[i...(j - 1)]$ 为某个连续段,长度为 $m$,根据「等差数列求和」可知该连续段所能提供的同构字符串数量为 $\\frac{(1 + m) \\times m}{2}$。\n\n具体的,我们可以从前往后扫描 `s`,假设当前处理到的位置为 `i`,将其看作连续段的左端点,然后从 `i` 出发找到当前最长连续段的右端点 `j - 1`,统计 $s[i...(j - 1)]$ 所能贡献同构字符串数量,并调整下个发起点为 $i = j$ 以扫描下一个连续段。\n\nJava 代码:\n```Java\nclass Solution {\n    public int countHomogenous(String s) {\n        int n = s.length(), MOD = (int)1e9+7;\n        long ans = 0;\n        for (int i = 0; i < n; ) {\n            int j = i;\n            while (j < n && s.charAt(j) == s.charAt(i)) j++;\n            long cnt = j - i;\n            ans += (1 + cnt) * cnt / 2;\n            ans %= MOD;\n            i = j;\n        }\n        return (int) ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int countHomogenous(string s) {\n        int n = s.size(), MOD = 1e9+7;\n        long ans = 0;\n        for (int i = 0; i < n; ) {\n            int j = i;\n            while (j < n && s[j] == s[i]) j++; \n            long cnt = j - i;\n            ans += (1 + cnt) * cnt / 2;\n            ans %= MOD;\n            i = j;\n        }\n        return (int) ans;\n    }\n};\n```\nPython3 代码:\n```Python\nclass Solution:\n    def countHomogenous(self, s: str) -> int:\n        n, mod, i, ans = len(s), 1e9+7, 0, 0\n        while i < n:\n            j = i\n            while j < n and s[j] == s[i]:\n                j += 1\n            cnt = j - i\n            ans += (cnt + 1) * cnt / 2\n            ans %= mod\n            i = j\n        return int(ans)\n```\nTypeScript 代码:\n```TypeScript\nfunction countHomogenous(s: string): number {\n    let n = s.length, mod = 1e9+7, ans = 0\n    for (let i = 0; i < n; ) {\n        let j = i\n        while (j < n && s.charAt(j) == s.charAt(i)) j++\n        const cnt = j - i\n        ans += (1 + cnt) * cnt / 2\n        ans %= mod\n        i = j\n    }\n    return ans\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1759` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1751-1760/1760. 袋子里最少数目的球（中等）.md", "url_title": "1760. 袋子里最少数目的球", "url": "https://leetcode.cn/problems/minimum-limit-of-balls-in-a-bag/solutions/2519994/gong-shui-san-xie-jing-dian-er-fen-yun-y-pj6r/", "difficulty": "中等", "tags": ["二分"], "question": "给你一个整数数组 `nums`,其中 `nums[i]` 表示第 `i` 个袋子里球的数目。同时给你一个整数 `maxOperations`。\n\n你可以进行如下操作至多 `maxOperations` 次:\n\n* 选择任意一个袋子,并将袋子里的球分到 `2` 个新的袋子中,每个袋子里都有 正整数 个球。\n\t* 比方说,一个袋子里有 `5` 个球,你可以把它们分到两个新袋子里,分别有 `1` 个和 `4` 个球,或者分别有 `2` 个和 `3` 个球。\n\t你的开销是单个袋子里球数目的 最大值 ,你想要 最小化 开销。\n\n请你返回进行上述操作后的最小开销。\n\n示例 1:\n```\n输入:nums = [9], maxOperations = 2\n\n输出:3\n\n解释:\n- 将装有 9 个球的袋子分成装有 6 个和 3 个球的袋子。[9] -> [6,3] 。\n- 将装有 6 个球的袋子分成装有 3 个和 3 个球的袋子。[6,3] -> [3,3,3] 。\n装有最多球的袋子里装有 3 个球,所以开销为 3 并返回 3 。\n```\n示例 2:\n```\n输入:nums = [2,4,8,2], maxOperations = 4\n\n输出:2\n\n解释:\n- 将装有 8 个球的袋子分成装有 4 个和 4 个球的袋子。[2,4,8,2] -> [2,4,4,4,2] 。\n- 将装有 4 个球的袋子分成装有 2 个和 2 个球的袋子。[2,4,4,4,2] -> [2,2,2,4,4,2] 。\n- 将装有 4 个球的袋子分成装有 2 个和 2 个球的袋子。[2,2,2,4,4,2] -> [2,2,2,2,2,4,2] 。\n- 将装有 4 个球的袋子分成装有 2 个和 2 个球的袋子。[2,2,2,2,2,4,2] -> [2,2,2,2,2,2,2,2] 。\n装有最多球的袋子里装有 2 个球,所以开销为 2 并返回 2 。\n```\n示例 3:\n```\n输入:nums = [7,17], maxOperations = 2\n\n输出:7\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $1 <= maxOperations, nums[i] <= 10^9$", "solution": "### 二分\n\n最小化不超过 `max` 次划分操作后的单个袋子最大值,我们将其称为「划分值」。\n\n**答案具有二段性:若使用 $k \\leq \\max$ 次划分操作后可达到最小划分值,此时减少划分操作次数,会使得划分值非单调上升。**\n\n因此我们可以二分答案,从而将问题进行等价转换:\n\n**假设当前二分到的值为 $limit$,我们需要实现一个线性复杂度为 `check` 函数,判断能否使用不超过 $\\max$ 次划分次数,来使得划分值不超过 $limit$**:\n\n* 若能满足,说明 $[limit, +\\infty]$ 范围的划分值,均能使用不超过 $\\max$ 次的实现,此时让 $r = limit$\n* 若不能满足,比 $limit$ 更小的划分值,则更无法在 $\\max$ 次操作中满足,说明 $[1, limit]$ 范围划分值均不是答案,此时让 $l = limit + 1$\n\n考虑如何实现 `check` 函数,从前往后处理每个 $nums[i]$,根据 $nums[i]$ 与当前限制 $limit$ 的大小关系进行分情况讨论:\n\n* 若 $nums[i] \\leq limit$:说明当前袋子不会成为瓶颈,无须消耗划分次数\n* 若 $nums[i] > limit$:此时需要对当前袋子进行划分,直到满足单个袋子球的数量不超过 $limit$ 为止,由于每次划分相当于增加一个袋子,而将 $nums[i]$ 划分成若干个不超过 $limit$ 个球的袋子,需要 $\\left \\lceil \\frac{nums[i]}{limit} \\right \\rceil$ 个袋子,减去原本的一个,共需要增加 $\\left \\lceil \\frac{nums[i]}{limit} \\right \\rceil$ 个新袋子,即划分 $\\left \\lceil \\frac{nums[i]}{limit} \\right \\rceil$ 次\n\nJava 代码:\n```Java\nclass Solution {\n    public int minimumSize(int[] nums, int max) {\n        int l = 1, r = 0x3f3f3f3f;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (check(nums, mid, max)) r = mid;\n            else l = mid + 1;\n        }\n        return r;\n    }\n    boolean check(int[] nums, int limit, int max) {\n        int cnt = 0;\n        for (int x : nums) cnt += Math.ceil(x * 1.0 / limit) - 1;\n        return cnt <= max;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int minimumSize(vector<int>& nums, int maxv) {\n        int l = 1, r = 0x3f3f3f3f;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (check(nums, mid, maxv)) r = mid;    \n            else l = mid + 1;\n        }\n        return r;\n    }\n    bool check(vector<int>& nums, int limit, int maxv) {\n        int cnt = 0;\n        for (int x : nums) cnt += ceil(x * 1.0 / limit) - 1;\n        return cnt <= maxv;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minimumSize(self, nums: List[int], maxv: int) -> int:\n        def check(nums, limit, maxv):\n            return sum([(x + limit - 1) // limit - 1 for x in nums]) <= maxv\n        l, r = 1, 0x3f3f3f3f\n        while l < r:\n            mid = l + r >> 1\n            if check(nums, mid, maxv):\n                r = mid\n            else:\n                l = mid + 1\n        return r\n```\nTypeScript 代码:\n```TypeScript\nfunction minimumSize(nums: number[], max: number): number {\n    function check(nums: number[], limit: number, max: number): boolean {\n        let cnt = 0\n        for (const x of nums) cnt += Math.ceil(x / limit) - 1\n        return cnt <= max\n    }\n    let l = 1, r = 0x3f3f3f3f\n    while (l < r) {\n        const mid = l + r >> 1\n        if (check(nums, mid, max)) r = mid\n        else l = mid + 1\n    }\n    return r\n}\n```\n* 时间复杂度:$O(n \\log{M})$,其中 $M = 1e9$ 为值域大小\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1758` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1761-1770/1763. 最长的美好子字符串（简单）.md", "url_title": "1763. 最长的美好子字符串", "url": "https://leetcode-cn.com/problems/longest-nice-substring/solution/gong-shui-san-xie-yi-ti-san-jie-po-su-ji-oflj/", "difficulty": "简单", "tags": ["模拟", "前缀和", "位运算"], "question": "当一个字符串 `s` 包含的每一种字母的大写和小写形式 同时 出现在 `s` 中,就称这个字符串 `s` 是 美好 字符串。\n\n比方说,`\"abABB\"` 是美好字符串,因为 `'A'` 和 `'a'` 同时出现了,且 `'B'` 和 `'b'` 也同时出现了。然而,`\"abA\"` 不是美好字符串因为 `'b'` 出现了,而 `'B'` 没有出现。\n\n给你一个字符串 `s` ,请你返回 `s` 最长的 美好子字符串 。如果有多个答案,请你返回 最早 出现的一个。如果不存在美好子字符串,请你返回一个空字符串。\n\n示例 1:\n```\n输入:s = \"YazaAay\"\n\n输出:\"aAa\"\n\n解释:\"aAa\" 是一个美好字符串,因为这个子串中仅含一种字母,其小写形式 'a' 和大写形式 'A' 也同时出现了。\n\"aAa\" 是最长的美好子字符串。\n```\n示例 2:\n```\n输入:s = \"Bb\"\n\n输出:\"Bb\"\n\n解释:\"Bb\" 是美好字符串,因为 'B' 和 'b' 都出现了。整个字符串也是原字符串的子字符串。\n```\n示例 3:\n```\n输入:s = \"c\"\n\n输出:\"\"\n\n解释:没有美好子字符串。\n```\n示例 4:\n```\n输入:s = \"dDzeE\"\n\n输出:\"dD\"\n\n解释:\"dD\" 和 \"eE\" 都是最长美好子字符串。\n由于有多个美好子字符串,返回 \"dD\" ,因为它出现得最早。\n```\n\n提示:\n* $1 <= s.length <= 100$\n* `s` 只包含大写和小写英文字母。", "solution": "### 朴素解法\n\n数据范围只有 $100$,最为简单的做法是枚举所有的子串( 复杂度为 $O(n^2)$ ),然后对子串进行合法性检查( 复杂度为 $O(n)$ ),整体复杂度为 $O(n^3)$,可以过。\n\n代码:\n```Java\nclass Solution {\n    public String longestNiceSubstring(String s) {\n        int n = s.length();\n        String ans = \"\";\n        for (int i = 0; i < n; i++) {\n            for (int j = i + 1; j < n; j++) {\n                if (j - i + 1 > ans.length() && check(s.substring(i, j + 1))) ans = s.substring(i, j + 1);\n            }\n        }\n        return ans;\n    }\n    boolean check(String s) {\n        Set<Character> set = new HashSet<>();\n        for (char c : s.toCharArray()) set.add(c);\n        for (char c : s.toCharArray()) {\n            char a = Character.toLowerCase(c), b = Character.toUpperCase(c);\n            if (!set.contains(a) || !set.contains(b)) return false;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n^3)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 前缀和优化\n\n在 `check` 中,我们不可避免的遍历整个子串,复杂度为 $O(n)$。\n\n该过程可以使用前缀和思想进行优化:**构建二维数组 $cnt$ 来记录子串的词频,$cnt[i]$ 为一个长度为 $128$ 的数组,用于记录字符串 `s` 中下标范围为 $[0, i - 1]$ 的词频。即 $cnt[i + 1][j]$ 所代表的含义为在子串 $s[0...i]$ 中字符 $j$ 的出现次数。**\n\n那么利用「容斥原理」,对于 `s` 的任意连续段 $[l, r]$ 所代表的子串中的任意字符 $i$ 的词频,我们可以作差算得:\n\n$$\nres[i] = cnt[r + 1][i] - cnt[l][i]\n$$\n\n这样我们在 `check` 实现中,只要检查 $26$ 个字母对应的大小写词频(ASCII 相差 $32$),是否同时为 $0$ 或者同时不为 $0$ 即可,复杂度为 $O(C)$。\n\n代码:\n```Java\nclass Solution {\n    public String longestNiceSubstring(String s) {\n        int n = s.length();\n        int[][] cnt = new int[n + 1][128];\n        for (int i = 1; i <= n; i++) {\n            char c = s.charAt(i - 1);\n            cnt[i] = cnt[i - 1].clone();\n            cnt[i][c - 'A']++;\n        }\n        int idx = -1, len = 0;\n        for (int i = 0; i < n; i++) {\n            for (int j = i + 1; j < n; j++) {\n                if (j - i + 1 <= len) continue;\n                int[] a = cnt[i], b = cnt[j + 1];\n                if (check(a, b)) {\n                    idx = i; len = j - i + 1;\n                }\n            }\n        }\n        return idx == -1 ? \"\" : s.substring(idx, idx + len);\n    }\n    boolean check(int[] a, int[] b) {\n        for (int i = 0; i < 26; i++) {\n            int low = b[i] - a[i], up = b[i + 32] - a[i + 32]; // 'A' = 65、'a' = 97\n            if (low != 0 && up == 0) return false;\n            if (low == 0 && up != 0) return false;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:令 $C$ 为字符集大小,本题固定为 $26$,构建 $cnt$ 的复杂度为 $O(n * 128)$;枚举所有子串复杂度为 $O(n^2)$;`check` 的复杂度为 $O(C)$。整体复杂度为 $O(n^2 * C)$\n* 空间复杂度:$O(n * 128)$\n\n---\n\n### 二进制优化\n\n更进一步,对于某个子串而言,我们只关心大小写是否同时出现,而不关心出现次数。\n\n因此我们无须使用二维数组来记录具体的词频,可以在枚举子串时,使用两个 `int` 的低 $26$ 位分别记录大小写字母的出现情况,利用枚举子串时右端点后移,维护两变量,当且仅当两变量相等时,满足 $26$ 个字母的大小写同时出现或同时不出现。\n\n代码:\n```Java\nclass Solution {\n    public String longestNiceSubstring(String s) {\n        int n = s.length();\n        int idx = -1, len = 0;\n        for (int i = 0; i < n; i++) {\n            int a = 0, b = 0;\n            for (int j = i; j < n; j++) {\n                char c = s.charAt(j);\n                if (c >= 'a' && c <= 'z') a |= (1 << (c - 'a'));\n                else b |= (1 << (c - 'A'));\n                if (a == b && j - i + 1 > len) {\n                    idx = i; len = j - i + 1;\n                }\n            }\n        }\n        return idx == -1 ? \"\" : s.substring(idx, idx + len);\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1763` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1761-1770/1764. 通过连接另一个数组的子数组得到一个数组（中等）.md", "url_title": "1764. 通过连接另一个数组的子数组得到一个数组", "url": "https://leetcode-cn.com/problems/form-array-by-concatenating-subarrays-of-another-array/solution/clean-solutionni-jue-dui-neng-kan-dong-d-l4ts/", "difficulty": "中等", "tags": ["双指针"], "question": "给你一个长度为 `n` 的二维整数数组 `groups` ,同时给你一个整数数组 `nums` 。\n\n你是否可以从 `nums` 中选出 `n` 个 不相交 的子数组,使得第 `i` 个子数组与 `groups[i]` (下标从 `0` 开始)完全相同,且如果 `i > 0` ,那么第 (`i-1`) 个子数组在 `nums` 中出现的位置在第 `i` 个子数组前面。(也就是说,这些子数组在 `nums` 中出现的顺序需要与 `groups` 顺序相同)\n\n如果你可以找出这样的 `n` 个子数组,请你返回 `true` ,否则返回 `false`。\n\n如果不存在下标为 `k` 的元素 `nums[k]` 属于不止一个子数组,就称这些子数组是 不相交 的。子数组指的是原数组中连续元素组成的一个序列。\n\n示例 1:\n```\n输入:groups = [[1,-1,-1],[3,-2,0]], nums = [1,-1,0,1,-1,-1,3,-2,0]\n\n输出:true\n\n解释:你可以分别在 nums 中选出第 0 个子数组 [1,-1,0,1,-1,-1,3,-2,0] 和第 1 个子数组 [1,-1,0,1,-1,-1,3,-2,0] 。\n这两个子数组是不相交的,因为它们没有任何共同的元素。\n```\n示例 2:\n```\n输入:groups = [[10,-2],[1,2,3,4]], nums = [1,2,3,4,10,-2]\n\n输出:false\n\n解释:选择子数组 [1,2,3,4,10,-2] 和 [1,2,3,4,10,-2] 是不正确的,因为它们出现的顺序与 groups 中顺序不同。\n[10,-2] 必须出现在 [1,2,3,4] 之前。\n```\n示例 3:\n```\n输入:groups = [[1,2,3],[3,4]], nums = [7,7,1,2,3,4,7,7]\n\n输出:false\n\n解释:选择子数组 [7,7,1,2,3,4,7,7] 和 [7,7,1,2,3,4,7,7] 是不正确的,因为它们不是不相交子数组。\n它们有一个共同的元素 nums[4] (下标从 0 开始)。\n```\n\n提示:\n* $groups.length == n$\n* $1 <= n <= 10^3$\n* $1 <= groups[i].length, sum(groups[i].length) <= 10^3$\n* $1 <= nums.length <= 10^3$\n* $-10^7 <= groups[i][j], nums[k] <= 10^7$", "solution": "### 双指针\n\n为了方便,将 `groups` 记为 `gs`。\n\n从前往后处理每个 $gs[i]$,使用 `idx` 记录当前使用到 `nums` 中的哪一位(即 $[0, ... (idx - 1)]$ 的 $nums[i]$ 已经用于匹配 $gs[0, ... (i - 1)]$。\n\n每次尝试从 `idx` 出发匹配 `gs[i]`,若能匹配成功,则整段更新 $idx = idx + gs[i].length$;否则将 `idx` 后移一位,继续尝试匹配 `gs[i]`。\n\n代码:\n```Java\nclass Solution {\n    public boolean canChoose(int[][] gs, int[] nums) {\n        int m = nums.length, idx = 0;\n        out:for (int[] info : gs) {\n            for (int j = idx; j + info.length <= m; j++) {\n                boolean ok = true;\n                for (int k = 0; k < info.length && ok; k++) {\n                    if (nums[j + k] != info[k]) ok = false;\n                }\n                if (ok) {\n                    idx = j + info.length;\n                    continue out;\n                }\n            }\n            return false;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1764` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1761-1770/1765. 地图中的最高点（中等）.md", "url_title": "1765. 地图中的最高点", "url": "https://leetcode-cn.com/problems/map-of-highest-peak/solution/gong-shui-san-xie-duo-yuan-bfs-yun-yong-8sw0f/", "difficulty": "中等", "tags": ["图论搜索", "多源 BFS"], "question": "给你一个大小为 `m x n` 的整数矩阵 `isWater` ,它代表了一个由 陆地 和 水域 单元格组成的地图。\n\n* 如果 `isWater[i][j] == 0` ,格子 `(i, j)` 是一个 陆地 格子。\n* 如果 `isWater[i][j] == 1` ,格子 `(i, j)` 是一个 水域 格子。\n\n你需要按照如下规则给每个单元格安排高度:\n\n* 每个格子的高度都必须是非负的。\n* 如果一个格子是是 **水域** ,那么它的高度必须为 $0$ 。\n* 任意相邻的格子高度差 至多 为 `1` 。当两个格子在正东、南、西、北方向上相互紧挨着,就称它们为相邻的格子。(也就是说它们有一条公共边)\n\n找到一种安排高度的方案,使得矩阵中的最高高度值 最大 。\n\n请你返回一个大小为 `m x n` 的整数矩阵 `height` ,其中 `height[i][j]` 是格子 `(i, j)` 的高度。如果有多种解法,请返回 任意一个 。\n\n示例 1:\n\n```\n输入:isWater = [[0,1],[0,0]]\n\n输出:[[1,0],[2,1]]\n\n解释:上图展示了给各个格子安排的高度。\n蓝色格子是水域格,绿色格子是陆地格。\n```\n示例 2:\n\n```\n输入:isWater = [[0,0,1],[1,0,0],[0,0,0]]\n\n输出:[[1,1,0],[0,1,1],[1,2,2]]\n\n解释:所有安排方案中,最高可行高度为 2 。\n任意安排方案中,只要最高高度为 2 且符合上述规则的,都为可行方案。\n```\n\n提示:\n* $m == isWater.length$\n* $n == isWater[i].length$\n* $1 <= m, n <= 1000$\n* `isWater[i][j]` 要么是 $0$ ,要么是 $1$ 。\n* 至少有 $1$ 个水域格子。", "solution": "### 多源 BFS\n\n这是一道「多源 `BFS`」板子题,对「多源 `BFS`」不熟悉的同学,可以看看前置 🧀:[多源 BFS 入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487179&idx=1&sn=e30a662c03fba3861254dbcf3fb9d6f2&chksm=fd9ca5d4caeb2cc205804fd17a2ce86b25d0408adc3417e73154f59d37e7cb17e02374f5122c&scene=178&cur_album_id=1917113998693449732#rd)。\n\n里面详解了「多源 `BFS`」与「单源 `BFS`」板子上的区别,强调了可以通过建立「虚拟源点」的方式,将「多源 `BFS`」转换回「单源 `BFS`」问题。\n\n回到本题,题目规定了水域区域的高度为 $0$,然后相邻格子之间的高度差至多为 $1$,\n\n我们可以将所有水域(高度为 $0$)区域进行入队,然后跑一遍 `BFS` 即可。\n\n将所有水域(高度为 $0$)区域进行入队的操作可看作是将与「虚拟源点」链接的节点进行入队(也等价于起始只将虚拟源点入队):\n\n容易证明这样做法的正确性:**对于一个「陆地」区域(高度可变)而言,其所能填入的高度,取决于其距离其他「水域」区域的距离,而我们最终要让整个答案矩阵合法,因此每个「陆地」区域应该取其所能填入的高度的「下界」,即只由「距离它最近的水域」区域所更新,这符合 `BFS`  的性质。**\n\n**代码(感谢 [@Benhao](/u/himymben/) 和 [@5cm/s 🌸](/u/megurine/) 同学提供的其他语言版本):**\n```Java\nclass Solution {\n    public int[][] highestPeak(int[][] g) {\n        int m = g.length, n = g[0].length;\n        int[][] ans = new int[m][n];\n        Deque<int[]> d = new ArrayDeque<>();\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (g[i][j] == 1) d.addLast(new int[]{i, j});\n                ans[i][j] = g[i][j] == 1 ? 0 : -1;\n            }\n        }\n        int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n        while (!d.isEmpty()) {\n            int[] info = d.pollFirst();\n            int x = info[0], y = info[1];\n            for (int[] di : dirs) {\n                int nx = x + di[0], ny = y + di[1];\n                if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;\n                if (ans[nx][ny] != -1) continue;\n                ans[nx][ny] = ans[x][y] + 1;\n                d.addLast(new int[]{nx, ny});\n            }\n        }\n        return ans;\n    }\n}\n```\n-\n```Python3\nclass Solution:\n    def highestPeak(self, isWater: List[List[int]]) -> List[List[int]]:\n        m, n = len(isWater), len(isWater[0])\n        ans = [[0] * n for _ in range(m)]\n        d = deque()\n        for i in range(m):\n            for j in range(n):\n                if isWater[i][j]:\n                    d.append((i, j))\n                ans[i][j] = 0 if isWater[i][j] else -1\n\n        dirs = [(1, 0), (-1, 0), (0, 1), (0, -1)]\n        h = 1\n        while d:\n            size = len(d)\n            for _ in range(size):\n                x, y = d.popleft()\n                for di in dirs:\n                    nx, ny = x + di[0], y + di[1]\n                    if 0 <= nx < m and 0 <= ny < n and ans[nx][ny] == -1:\n                        ans[nx][ny] = h\n                        d.append((nx, ny))\n            h += 1\n        return ans\n```\n-\n```Go\nfunc highestPeak(isWater [][]int) [][]int {\n    m, n := len(isWater), len(isWater[0])\n    ans, d := make([][]int, m), [][]int{}\n    for i := 0; i < m; i++ {\n        ans[i] = make([]int, n)\n        for j := 0; j < n; j++ {\n            if isWater[i][j] == 1 {\n                d = append(d, []int{i, j})\n                ans[i][j] = 0\n            } else {\n                ans[i][j] = -1\n            }\n        }\n    }\n    dirs := [][]int{{1,0}, {-1,0}, {0,1}, {0,-1}}\n    for h := 1; len(d) > 0; h++ {\n        for size := len(d); size > 0; size--{\n            info := d[0]\n            d = d[1:]\n            x, y := info[0], info[1]\n            for _, di := range dirs {\n                nx, ny := x + di[0], y + di[1]\n                if nx >= 0 && nx < m && ny >= 0 && ny < n && ans[nx][ny] == -1 {\n                    ans[nx][ny] = h\n                    d = append(d, []int{nx, ny})\n                }\n            }\n        }\n    }\n    return ans\n}\n```\n-\n```C++\nconst int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};\nclass Solution {\npublic:\n    vector<vector<int>> highestPeak(vector<vector<int>>& g) {\n        int n = g.size(), m = g[0].size();\n        queue<pair<int, int>> q;\n        vector<vector<int>> ans(n, vector<int>(m, 0));\n        for (int i = 0; i < n; ++i) {\n            for (int j = 0; j < m; ++j) {\n                if (g[i][j] == 1) {\n                    q.emplace(i, j);\n                } else {\n                    ans[i][j] = -1;\n                }\n            }\n        }\n        while (!q.empty()) {\n            auto [x, y] = q.front(); q.pop();\n            for (int i = 0; i < 4; ++i) {\n                int a = x + dx[i], b = y + dy[i];\n                if (a < 0 || a == n || b < 0 || b == m) continue;\n                if (ans[a][b] >= 0) continue;\n                ans[a][b] = ans[x][y] + 1;\n                q.emplace(a, b);\n            }\n        }\n        return ans;\n    }\n};\n```\n* 时间复杂度:$O(m * n)$\n* 空间复杂度:$O(m * n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1765` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1761-1770/1766. 互质树（困难）.md", "url_title": "1766. 互质树", "url": "https://leetcode-cn.com/problems/tree-of-coprimes/solution/bu-tai-yi-yang-de-dfs-ji-lu-suo-you-zui-d3xeu/", "difficulty": "困难", "tags": ["DFS"], "question": "给你一个 `n` 个节点的树(也就是一个无环连通无向图),节点编号从 `0` 到 `n - 1`,且恰好有 `n - 1` 条边,每个节点有一个值,树的根节点为 `0` 号点。\n\n给你一个整数数组 `nums` 和一个二维数组 `edges` 来表示这棵树。\n\n`nums[i]` 表示第 `i` 个点的值,$edges[j] = [u_{j}, v_{j}]$ 表示节点 $u_{j}$ 和节点 $v_{j}$ 在树中有一条边。\n\n当 `gcd(x, y) == 1`,我们称两个数 `x` 和 `y` 是 互质的 ,其中 `gcd(x, y)` 是 `x` 和 `y` 的最大公约数。\n\n从节点 `i` 到根最短路径上的点都是节点 `i` 的祖先节点,一个节点不是它自己的祖先节点。\n\n请你返回一个大小为 `n` 的数组 `ans`,其中 `ans[i]` 是离节点 `i` 最近的祖先节点且满足 `nums[i]` 和 `nums[ans[i]]` 是互质的,如果不存在这样的祖先节点,`ans[i]` 为 `-1`。\n\n示例 1:\n\n```\n输入:nums = [2,3,3,2], edges = [[0,1],[1,2],[1,3]]\n\n输出:[-1,0,0,1]\n\n解释:上图中,每个节点的值在括号中表示。\n- 节点 0 没有互质祖先。\n- 节点 1 只有一个祖先节点 0 。它们的值是互质的(gcd(2,3) == 1)。\n- 节点 2 有两个祖先节点,分别是节点 1 和节点 0 。节点 1 的值与它的值不是互质的(gcd(3,3) == 3)但节点 0 的值是互质的(gcd(2,3) == 1),所以节点 0 是最近的符合要求的祖先节点。\n- 节点 3 有两个祖先节点,分别是节点 1 和节点 0 。它与节点 1 互质(gcd(3,2) == 1),所以节点 1 是离它最近的符合要求的祖先节点。\n```\n\n示例 2:\n\n```\n输入:nums = [5,6,10,2,3,6,15], edges = [[0,1],[0,2],[1,3],[1,4],[2,5],[2,6]]\n\n输出:[-1,0,-1,0,0,0,-1]\n```\n\n提示:\n* $nums.length = n$\n* $1 <= nums[i] <= 50$\n* $1 <= n <= 10^5$\n* $edges.length = n - 1$\n* $edges[j].length = 2$\n* $0 <= u_{j}, v_{j} < n$\n* $u_{j} \\neq v_{j}$", "solution": "### DFS \n\n题目描述很长,但其实就是说每个节点从下往上找,找到最近的「与其互质」的节点。\n\n数据范围是 $10^5$,如果每个节点都直接往上找最近「互质」祖宗节点的话,当树为线性时,复杂度是 $O(n^2)$ ,会超时。\n\n因此我们要利用 $nums[i]$ 范围只有 $50$ 的特性。\n\n我们可以先预处理除 $[1, 50]$ 范围内的每个数,求出他们互质的数有哪些,存到一个字典里。\n\n那么对于某个节点而言,假设节点的值为 `x` ,所在层数为 `y`。\n\n那么问题转化为求与 `x` 互质的数有哪些,最近的在哪一层。\n\n用 `dep[x]` 表示距离值为 `x` 的节点最近的层是多少;`pos[x]` 代表具体的节点编号。\n\n代码:\n```java\nclass Solution {\n    int[] ans;\n    Map<Integer, List<Integer>> map = new HashMap<>(); // 边映射\n    Map<Integer, List<Integer>> val = new HashMap<>(); // 互质数字典\n    int[] dep;\n    int[] pos = new int[52];\n    public int[] getCoprimes(int[] nums, int[][] edges) {\n        int n = nums.length;\n        ans = new int[n];\n        dep = new int[n];\n        Arrays.fill(ans, - 1);\n        Arrays.fill(pos, -1);\n\n        for (int[] edge : edges) {\n            int a = edge[0], b = edge[1];\n            List<Integer> alist = map.getOrDefault(a, new ArrayList<>());\n            alist.add(b);\n            map.put(a, alist);\n            List<Integer> blist = map.getOrDefault(b, new ArrayList<>());\n            blist.add(a);\n            map.put(b, blist);\n        }\n\n        for (int i = 1; i <= 50; i++) {\n            for (int j = 1; j <= 50; j++) {\n                if (gcd(i, j) == 1) {\n                    List<Integer> list = val.getOrDefault(i, new ArrayList<>());\n                    list.add(j);\n                    val.put(i, list);\n                }\n            }\n        }\n\n        dfs(nums, 0, -1);\n        return ans;\n    }\n    void dfs(int[] nums, int u, int form) {\n        int t = nums[u];\n        for (int v : val.get(t)) {\n            if (pos[v] == -1) continue;\n            if (ans[u] == -1 || dep[ans[u]] < dep[pos[v]]) ans[u] = pos[v];\n        }\n        int p = pos[t];\n        pos[t] = u;\n\n        for (int i : map.get(u)) {\n            if (i == form) continue;\n            dep[i] = dep[u] + 1;\n            dfs(nums, i, u);\n        }\n        pos[t] = p;\n    }\n    int gcd(int a, int b) {\n        if (b == 0) return a;\n        if (a == 0) return b;\n        return gcd(b, a % b);\n    }\n}\n```\n* 时间复杂度:对于每个节点而言,会检查与其数值互质的数有哪些,在哪层。最坏情况下会检查 50 个互质数(当前数值为 1)。复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1766` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1761-1770/1768. 交替合并字符串（简单）.md", "url_title": "1768. 交替合并字符串", "url": "https://leetcode.cn/problems/merge-strings-alternately/solution/by-ac_oier-rjve/", "difficulty": "简单", "tags": ["模拟"], "question": "给你两个字符串 `word1` 和 `word2`。请你从 `word1` 开始,通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长,就将多出来的字母追加到合并后字符串的末尾。\n\n返回 合并后的字符串 。\n\n示例 1:\n```\n输入:word1 = \"abc\", word2 = \"pqr\"\n\n输出:\"apbqcr\"\n\n解释:字符串合并情况如下所示:\nword1:  a   b   c\nword2:    p   q   r\n合并后:  a p b q c r\n```\n示例 2:\n```\n输入:word1 = \"ab\", word2 = \"pqrs\"\n\n输出:\"apbqrs\"\n\n解释:注意,word2 比 word1 长,\"rs\" 需要追加到合并后字符串的末尾。\nword1:  a   b \nword2:    p   q   r   s\n合并后:  a p b q   r   s\n```\n示例 3:\n```\n输入:word1 = \"abcd\", word2 = \"pq\"\n\n输出:\"apbqcd\"\n\n解释:注意,word1 比 word2 长,\"cd\" 需要追加到合并后字符串的末尾。\nword1:  a   b   c   d\nword2:    p   q \n合并后:  a p b q c   d\n```\n\n提示:\n* $1 <= word1.length, word2.length <= 100$\n* `word1` 和 `word2` 由小写英文字母组成", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public String mergeAlternately(String s1, String s2) {\n        int n = s1.length(), m = s2.length(), i = 0, j = 0;\n        StringBuilder sb = new StringBuilder();\n        while (i < n || j < m) {\n            if (i < n) sb.append(s1.charAt(i++));\n            if (j < m) sb.append(s2.charAt(j++));\n        }\n        return sb.toString();\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction mergeAlternately(s1: string, s2: string): string {\n    let n = s1.length, m = s2.length, i = 0, j = 0\n    let ans = \"\"\n    while (i < n || j < m) {\n        if (i < n) ans += s1[i++]\n        if (j < m) ans += s2[j++]\n    }\n    return ans\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def mergeAlternately(self, s1: str, s2: str) -> str:\n        n, m, i, j = len(s1), len(s2), 0, 0\n        ans = \"\"\n        while i < n or j < m:\n            if i < n:\n                ans += s1[i]\n                i += 1\n            if j < m:\n                ans += s2[j]\n                j += 1\n        return ans   \n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1768` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1761-1770/1769. 移动所有球到每个盒子所需的最小操作数（中等）.md", "url_title": "1769. 移动所有球到每个盒子所需的最小操作数", "url": null, "difficulty": "中等", "tags": ["模拟"], "question": "有 `n` 个盒子。给你一个长度为 `n` 的二进制字符串 `boxes`,其中 `boxes[i]` 的值为 `'0'` 表示第 `i` 个盒子是 空 的,而 `boxes[i]` 的值为 `'1'` 表示盒子里有 一个 小球。\n\n在一步操作中,你可以将 一个 小球从某个盒子移动到一个与之相邻的盒子中。第 `i` 个盒子和第 `j` 个盒子相邻需满足 `abs(i - j) == 1`。注意,操作执行后,某些盒子中可能会存在不止一个小球。\n\n返回一个长度为 `n` 的数组 `answer`,其中 `answer[i]` 是将所有小球移动到第 `i` 个盒子所需的 最小 操作数。\n\n每个 `answer[i]` 都需要根据盒子的 初始状态 进行计算。\n\n示例 1:\n```\n输入:boxes = \"110\"\n\n输出:[1,1,3]\n\n解释:每个盒子对应的最小操作数如下:\n1) 第 1 个盒子:将一个小球从第 2 个盒子移动到第 1 个盒子,需要 1 步操作。\n2) 第 2 个盒子:将一个小球从第 1 个盒子移动到第 2 个盒子,需要 1 步操作。\n3) 第 3 个盒子:将一个小球从第 1 个盒子移动到第 3 个盒子,需要 2 步操作。将一个小球从第 2 个盒子移动到第 3 个盒子,需要 1 步操作。共计 3 步操作。\n```\n示例 2:\n```\n输入:boxes = \"001011\"\n\n输出:[11,8,5,4,3,4]\n```\n\n提示:\n* $n = boxes.length$\n* $1 <= n <= 2000$\n* `boxes[i]` 为 `'0'` 或 `'1'`", "solution": "### 模拟\n\n预处理两个与 `boxes` 等长的数组 `l` 和 `r`:$l[i]$ 和 $r[i]$ 分别代表「将 $[0, i]$ 的小球移动到位置 $i$」以及「将 $[i, n - 1]$ 的小球移动到位置 $i$」所需要的步数。\n\n所求的答案数组 `ans` 与数组 `l` 和 `r` 的关系为:$ans[i] = l[i] + r[i]$。\n\n预处理两数组是简单的:分别从两个方向遍历 `boxes`,使用变量 `cur` 代表当前处理到的前缀/后缀的小球总个数,变量 `step` 代表将当前所有前缀/后缀小球移动到位置 $i$ 所需要的步数。\n\nJava 代码:\n```Java \nclass Solution {\n    public int[] minOperations(String boxes) {\n        int n = boxes.length();\n        int[] l = new int[n + 10], r = new int[n + 10];\n        for (int i = 0, cur = 0, step = 0; i < n; i++) {\n            step += cur; cur += boxes.charAt(i) - '0'; l[i] = step;\n        }\n        for (int i = n - 1, cur = 0, step = 0; i >= 0; i--) {\n            step += cur; cur += boxes.charAt(i) - '0'; r[i] = step;\n        }\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) ans[i] = l[i] + r[i];\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction minOperations(boxes: string): number[] {\n    const n = boxes.length\n    const l = new Array<number>(n + 10).fill(0), r = new Array<number>(n + 10).fill(0)\n    for (let i = 0, cur = 0, step = 0; i < n; i++) {\n        step += cur; cur += boxes[i] == '1' ? 1 : 0; l[i] = step;\n    }\n    for (let i = n - 1, cur = 0, step = 0; i >= 0; i--) {\n        step += cur; cur += boxes[i] == '1' ? 1 : 0; r[i] = step;\n    }\n    const ans = new Array<number>(n).fill(0)\n    for (let i = 0; i < n; i++) ans[i] = l[i] + r[i]\n    return ans\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def minOperations(self, boxes: str) -> List[int]:\n        n = len(boxes)\n        l, r = [0] * n, [0] * n\n        step, cur = 0, 0\n        for i in range(n):\n            step, cur = step + cur, cur + 1 if boxes[i] == '1' else cur\n            l[i] = step\n        step, cur = 0, 0\n        for i in range(n - 1, -1, -1):\n            step, cur = step + cur, cur + 1 if boxes[i] == '1' else cur\n            r[i] = step\n        return [l[i] + r[i] for i in range(n)]\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1769` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1771-1780/1773. 统计匹配检索规则的物品数量（简单）.md", "url_title": "1773. 统计匹配检索规则的物品数量", "url": "https://leetcode.cn/problems/count-items-matching-a-rule/solution/by-ac_oier-qyd6/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个数组 `items` ,其中 $items[i] = [type_{i}, color_{i}, name_{i}]$ ,描述第 `i` 件物品的类型、颜色以及名称。\n\n另给你一条由两个字符串 `ruleKey` 和 `ruleValue` 表示的检索规则。\n\n如果第 `i` 件物品能满足下述条件之一,则认为该物品与给定的检索规则 匹配 :\n\n* `ruleKey = \"type\"` 且 $ruleValue = type_{i}$ 。\n* `ruleKey = \"color\"` 且 $ruleValue = color_{i}$。\n* `ruleKey = \"name\"` 且 $ruleValue = name{i}$。\n\n统计并返回 匹配检索规则的物品数量 。\n\n示例 1:\n```\n输入:items = [[\"phone\",\"blue\",\"pixel\"],[\"computer\",\"silver\",\"lenovo\"],[\"phone\",\"gold\",\"iphone\"]], ruleKey = \"color\", ruleValue = \"silver\"\n\n输出:1\n\n解释:只有一件物品匹配检索规则,这件物品是 [\"computer\",\"silver\",\"lenovo\"] 。\n```\n示例 2:\n```\n输入:items = [[\"phone\",\"blue\",\"pixel\"],[\"computer\",\"silver\",\"phone\"],[\"phone\",\"gold\",\"iphone\"]], ruleKey = \"type\", ruleValue = \"phone\"\n\n输出:2\n\n解释:只有两件物品匹配检索规则,这两件物品分别是 [\"phone\",\"blue\",\"pixel\"] 和 [\"phone\",\"gold\",\"iphone\"] 。注意,[\"computer\",\"silver\",\"phone\"] 未匹配检索规则。\n```\n\n提示:\n* $1 <= items.length <= 10^4$\n* $1 <= type_{i}.length, color_{i}.length, name_{i}.length, ruleValue.length <= 10$\n* `ruleKey` 等于 `\"type\"`、`\"color\"` 或 `\"name\"`\n* 所有字符串仅由小写字母组成", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public int countMatches(List<List<String>> items, String k, String v) {\n        int ans = 0, idx = k.charAt(0) == 't' ? 0 : k.charAt(0) == 'c' ? 1 : 2;\n        for (List<String> item : items) {\n            if (item.get(idx).equals(v)) ans++;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction countMatches(items: string[][], k: string, v: string): number {\n    let ans = 0, idx = k[0] == 't' ? 0 : k[0] == 'c' ? 1 : 2\n    for (const item of items) {\n        if (item[idx] == v) ans++\n    }\n    return ans\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def countMatches(self, items: List[List[str]], k: str, v: str) -> int:\n        ans, idx = 0, 0 if k[0] == 't' else 1 if k[0] == 'c' else 2\n        for item in items:\n            if item[idx] == v:\n                ans += 1\n        return ans\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1773` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1771-1780/1775. 通过最少操作次数使数组的和相等（中等）.md", "url_title": "1775. 通过最少操作次数使数组的和相等量", "url": "https://leetcode.cn/problems/equal-sum-arrays-with-minimum-number-of-operations/solutions/2582561/gong-shui-san-xie-fen-qing-kuang-tao-lun-saa1/", "difficulty": "中等", "tags": ["枚举", "贪心", "数学"], "question": "给你两个长度可能不等的整数数组 `nums1` 和 `nums2` 。两个数组中的所有值都在 `1` 到 `6` 之间(包含 `1` 和 `6`)。\n\n每次操作中,你可以选择 任意 数组中的任意一个整数,将它变成 `1` 到 `6` 之间 任意 的值(包含 `1` 和 `6`)。\n\n请你返回使 `nums1` 中所有数的和与 `nums2` 中所有数的和相等的最少操作次数。如果无法使两个数组的和相等,请返回 `-1` 。\n\n示例 1:\n```\n输入:nums1 = [1,2,3,4,5,6], nums2 = [1,1,2,2,2,2]\n\n输出:3\n\n解释:你可以通过 3 次操作使 nums1 中所有数的和与 nums2 中所有数的和相等。以下数组下标都从 0 开始。\n- 将 nums2[0] 变为 6 。 nums1 = [1,2,3,4,5,6], nums2 = [6,1,2,2,2,2] 。\n- 将 nums1[5] 变为 1 。 nums1 = [1,2,3,4,5,1], nums2 = [6,1,2,2,2,2] 。\n- 将 nums1[2] 变为 2 。 nums1 = [1,2,2,4,5,1], nums2 = [6,1,2,2,2,2] 。\n```\n示例 2:\n```\n输入:nums1 = [1,1,1,1,1,1,1], nums2 = [6]\n\n输出:-1\n\n解释:没有办法减少 nums1 的和或者增加 nums2 的和使二者相等。\n```\n示例 3:\n```\n输入:nums1 = [6,6], nums2 = [1]\n\n输出:3\n\n解释:你可以通过 3 次操作使 nums1 中所有数的和与 nums2 中所有数的和相等。以下数组下标都从 0 开始。\n- 将 nums1[0] 变为 2 。 nums1 = [2,6], nums2 = [1] 。\n- 将 nums1[1] 变为 2 。 nums1 = [2,2], nums2 = [1] 。\n- 将 nums2[0] 变为 4 。 nums1 = [2,2], nums2 = [4] 。\n```\n\n提示:\n* $1 <= nums1.length, nums2.length <= 10^5$\n* $1 <= nums1[i], nums2[i] <= 6$", "solution": "### 枚举 + 贪心 + 数学\n\n令 `nums1` 的长度为 `n`,`nums2` 的长度为 `m`,根据题意两数组的值域分别为 $[n, 6n]$ 和 $[m, 6m]$,可分别视为数轴上的两条线段。\n\n为了方便,我们人为固定 $n\\leq m$,若不满足则交换两数组,返回 `minOperations(nums2, nums1)` 即可。\n\n先来考虑无解的情况:当  $6n < m$ 时,说明两线段不重合,必然无法通过变换使得总和相等,直接返回 `-1`。\n\n由于 $\\max(n, m)$ 的范围为 $1e5$,且 $nums[i]$ 的值域大小 $C = 6$,因此我们可以通过枚举最终目标和 `x`(两线段的重合部分)来做,枚举范围不超过 $6 \\times 1e5$。\n\n于是问题转换为:**对于一个原总和为 `sum` 的数组 `nums` 而言,按照题目的变换规则,至少经过多少次变换,才能将其总和变为 `x`**。\n\n根据原总和 `sum` 和目标结果 `x` 的大小关系进行分情况讨论(将两者差值绝对值记为 `d`):\n\n* 当 $sum < x$ 时,对于原数为 $nums[i]$ 的数而言,其能变为不超过 $nums[i] - 1$ 的任意数。\n\n  例如 $6$ 能够变化为 $[1, 5]$ 中的任意数,即单个数值 $6$ 最多能够抵消 $6 - 1$ 个差值,不失一般性的可概括为原数为 $nums[i]$ 所能抵消的差值为 $nums[i] - 1$。\n\n  因此,我们贪心的使用较大数进行变换(从 $6$ 往 $2$ 枚举 `i`),对于每个数值 `i` 而言,其所能提供的个数为 $\\min(\\left \\lceil \\frac{d}{i - 1} \\right \\rceil, cnst[i])$。\n\n* 当 $sum > x$ 时,同理,原数为 $nums[i]$ 所能提供的最大抵消数为 $6 - nums[i]$,因此我们贪心使用较小数进行变换(从 $1$ 往 $5$ 枚举 `i`),对于每个数值 `i` 而言,其所能提供的个数为 $\\min(\\left \\lceil \\frac{d}{6 - i} \\right \\rceil, cnst[i])$。\n\n如此一来,我们通过枚举两线段重合点 `x`,复杂度为 $O(C \\times \\max(n, m))$,并通过复杂度为 $O(C)$ 的数学方法来得知将两原数组总和变为 `x` 所需要的操作次数 `cnt`,在所有的 `cnt` 取最小值即是答案。整体计算量为 $3.6 \\times 10^6$,可以过。\n\nJava 代码:\n```Java\nclass Solution {\n    int[] c1 = new int[10], c2 = new int[10];\n    int s1, s2;\n    public int minOperations(int[] nums1, int[] nums2) {\n        int n = nums1.length, m = nums2.length;\n        if (n > m) return minOperations(nums2, nums1);\n        if (m > 6 * n) return -1;\n        for (int x : nums1) {\n            c1[x]++; s1 += x;\n        }\n        for (int x : nums2) {\n            c2[x]++; s2 += x;\n        }\n        int ans = n + m;\n        for (int i = m; i <= 6 * n; i++) ans = Math.min(ans, getCnt(c1, s1, i) + getCnt(c2, s2, i));\n        return ans;\n    }\n    int getCnt(int[] cnts, int sum, int x) {\n        int ans = 0;\n        if (sum > x) {\n            for (int i = 6, d = sum - x; i >= 2 && d > 0; i--) {\n                int c = Math.min((int) Math.ceil(d * 1.0 / (i - 1)), cnts[i]);\n                ans += c; d -= c * (i - 1);\n            }\n        } else if (sum < x) {\n            for (int i = 1, d = x - sum; i <= 5 && d > 0; i++) {\n                int c = Math.min((int) Math.ceil(d * 1.0 / (6 - i)), cnts[i]);\n                ans += c; d -= c * (6 - i);\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int c1[10], c2[10];\n    int s1, s2;\n    int minOperations(vector<int>& nums1, vector<int>& nums2) {\n        int n = nums1.size(), m = nums2.size();\n        if (n > m) return minOperations(nums2, nums1);\n        if (m > 6 * n) return -1;\n        for (int x : nums1) {\n            c1[x]++; s1 += x;\n        }\n        for (int x : nums2) {\n            c2[x]++; s2 += x;\n        }\n        int ans = n + m;\n        for (int i = m; i <= 6 * n; i++) {\n            ans = min(ans, getCnt(c1, s1, i) + getCnt(c2, s2, i));\n        }\n        return ans;\n    }\n    int getCnt(int cnts[], int sum, int x) {\n        int ans = 0;\n        if (sum > x) {\n            for (int i = 6, d = sum - x; i >= 2 && d > 0; i--) {\n                int c = min((int) ceil(d * 1.0 / (i - 1)), cnts[i]);\n                ans += c; d -= c * (i - 1);\n            }\n        } else if (sum < x) {\n            for (int i = 1, d = x - sum; i <= 5 && d > 0; i++) {\n                int c = min((int) ceil(d * 1.0 / (6 - i)), cnts[i]);\n                ans += c; d -= c * (6 - i);\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python \nclass Solution:\n    def minOperations(self, nums1: List[int], nums2: List[int]) -> int:\n        n, m = len(nums1), len(nums2)\n        if n > m:\n            return self.minOperations(nums2, nums1)\n        if m > 6 * n:\n            return -1\n        c1, c2 = Counter(nums1), Counter(nums2)\n        s1, s2 = sum(nums1), sum(nums2)\n        def getCnt(cnts, tot, x):\n            ans = 0\n            if tot > x:\n                d = tot - x\n                for i in range(6, 1, -1):\n                    if d <= 0:\n                        break\n                    c = min(math.ceil(d / (i - 1)), cnts[i])\n                    ans, d = ans + c, d - c * (i - 1)\n            elif tot < x:\n                d = x - tot\n                for i in range(1, 6):\n                    if d <= 0:\n                        break\n                    c = min(math.ceil(d / (6 - i)), cnts[i])\n                    ans, d = ans + c, d - c * (6 - i)\n            return ans\n        ans = n + m\n        for i in range(m, 6 * n + 1):\n            ans = min(ans, getCnt(c1, s1, i) + getCnt(c2, s2, i))\n        return ans\n```\n* 时间复杂度:$O(C \\times \\max(n, m) \\times C)$,其中 $C = 6$ 为 $nums[i]$ 的值域大小\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1775` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1771-1780/1780. 判断一个数字是否可以表示成三的幂的和（中等）.md", "url_title": "1780. 判断一个数字是否可以表示成三的幂的和", "url": "https://acoier.com/2022/12/12/1780.%20%E5%88%A4%E6%96%AD%E4%B8%80%E4%B8%AA%E6%95%B0%E5%AD%97%E6%98%AF%E5%90%A6%E5%8F%AF%E4%BB%A5%E8%A1%A8%E7%A4%BA%E6%88%90%E4%B8%89%E7%9A%84%E5%B9%82%E7%9A%84%E5%92%8C%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/", "difficulty": "中等", "tags": ["数学"], "question": "给你一个整数 `n`,如果你可以将 `n` 表示成若干个不同的三的幂之和,请你返回 `true`,否则请返回 `false`。\n\n对于一个整数 `y`,如果存在整数 `x` 满足 $y = 3^x$,我们称这个整数 `y` 是三的幂。\n\n示例 1:\n```\n输入:n = 12\n\n输出:true\n\n解释:12 = 31 + 32\n```\n示例 2:\n```\n输入:n = 91\n\n输出:true\n\n解释:91 = 30 + 32 + 34\n```\n示例 3:\n```\n输入:n = 21\n\n输出:false\n```\n\n提示:\n* $1 <= n <= 10^7$", "solution": "### 数学\n\n这是一道考察「进制转换」基本认识的题目。\n\n将 `n` 看作一个三进制数,例如对于 $(210)_{3}$ 而言,其代表的是 $2 \\times 3^2 + 1 \\times 3^1 + 0 \\times 3^0$ 十进制数。\n\n由于题目规定组成和的三的幂需要满足「不同」的条件,因此 `n` 所代表的三进制表示中的系数只能是 $1$ 或 $0$,而不是能是 $2$。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean checkPowersOfThree(int n) {\n        while (n != 0) {\n            if (n % 3 == 2) return false;\n            n /= 3;\n        }\n        return true;\n    }\n}\n```\nC++ 代码\n```C++\nclass Solution {\npublic:\n    bool checkPowersOfThree(int n) {\n        while (n != 0) {\n            if (n % 3 == 2) return false;\n            n /= 3;\n        }\n        return true;\n    }\n};\n```\nPython 代码\n```Python\nclass Solution:\n    def checkPowersOfThree(self, n: int) -> bool:\n        while n != 0:\n            if n % 3 == 2:\n                return False\n            n //= 3\n        return True\n```\nTypeScript  代码:\n```TypeScript \nfunction checkPowersOfThree(n: number): boolean {\n    while (n != 0) {\n        if (n % 3 == 2) return false\n        n = Math.floor(n / 3)\n    }\n    return true\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1780` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1781-1790/1781. 所有子字符串美丽值之和（中等）.md", "url_title": "1781. 所有子字符串美丽值之和", "url": null, "difficulty": "中等", "tags": ["模拟", "哈希表"], "question": "一个字符串的 美丽值 定义为:出现频率最高字符与出现频率最低字符的出现次数之差。\n\n比方说,`\"abaacc\"` 的美丽值为 `3 - 1 = 2`。\n\n给你一个字符串 `s` ,请你返回它所有子字符串的 美丽值 之和。\n\n示例 1:\n```\n输入:s = \"aabcb\"\n\n输出:5\n\n解释:美丽值不为零的字符串包括 [\"aab\",\"aabc\",\"aabcb\",\"abcb\",\"bcb\"] ,每一个字符串的美丽值都为 1 。\n```\n示例 2:\n```\n输入:s = \"aabcbaa\"\n\n输出:17\n```\n\n提示:\n* $1 <= s.length <= 500$\n* `s` 只包含小写英文字母。", "solution": "### 模拟 + 哈希表\n\n数据范围只有 $500$,我们可以通过两层循环的方式枚举所有子串,当枚举子串左端点 `i` 的时候,可以同步开一个大小为 $C = 26$ 的数组来记录每个字母的出现次数,随后通过遍历该数组来得知最大和最小频次,将当前子串对应的美丽值累加到答案。\n\n该做法复杂度为 $O(n^2 \\times C)$,计算量约为 $500 \\times 500 \\times 26 = 6.5 \\times 10^6$,可以过。\n\n在确定了子串的左端点 `i`,枚举右端点 `j` 的过程中,维护最大频次是简单的,关键在于如果知晓最小频次,我们可以额外起一个哈希表 `map` 来记录出现频次为 `x` 的字符有多少个,`map[x] = cnt` 含义为频次为 `x` 的字符类型有 `cnt` 种。\n\n假设当前我们处理的字符为 `c`,根据字符 `c` 原来的频次进行分情况讨论(使用 `max` 和 `min` 分别记录当前最大最小频次):\n\n* 若字符 `c` 为首次出现,即原频次为 $0$,此时有最小频次 `min = 1`\n* 当字符 `c` 为并非首次出现,假设原频次数为 `x`,此时频次为 `x` 的字符数量减一;频次为 `x + 1` 的字符数量加一,若频次为 `x` 的字符数量在减一后 $map[min] \\leq 0$,说明没有频次为 `min` 的字符了,此时最小频次为 `min + 1`\n\nJava 代码:\n```Java \nclass Solution {\n    public int beautySum(String s) {\n        int n = s.length(), ans = 0;\n        for (int i = 0; i < n; i++) {\n            int[] cnts = new int[26];\n            Map<Integer, Integer> map = new HashMap<>();\n            int min = -1, max = -1;\n            for (int j = i; j < n; j++) {\n                int c = s.charAt(j) - 'a';\n                map.put(cnts[c], map.getOrDefault(cnts[c], 0) - 1);\n                map.put(cnts[c] + 1, map.getOrDefault(cnts[c] + 1, 0) + 1);\n                cnts[c]++;\n                if (cnts[c] == 1) min = 1;\n                else if (map.get(min) <= 0) min++;\n                max = Math.max(max, cnts[c]);\n                ans += max - min;\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic: \n    int beautySum(string s) {\n        int n = s.size(), cnts[26], ans = 0;\n        unordered_map<int, int> map;\n        for(int i = 0; i < n; ++i) {\n            memset(cnts, 0, sizeof(cnts));\n            map.clear();\n            int min = -1, maxv = -1;\n            for(int j = i; j < n; ++j) {\n                int c = s[j] - 'a';\n                map[cnts[c]]--; map[cnts[c] + 1]++;\n                cnts[c]++;\n                if(cnts[c] == 1) min = 1;    \n                else if(map[min] <= 0) min++;\n                maxv = max(maxv, cnts[c]);\n                ans += maxv - min;\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python \nclass Solution:\n    def beautySum(self, s: str) -> int:\n        n, ans = len(s), 0\n        for i in range(n):\n            cnts = [0] * 26\n            dmap = defaultdict(int)\n            maxv, minv = -1, -1\n            for j in range(i, n):\n                c = ord(s[j]) - ord('a')\n                dmap[cnts[c]] -= 1\n                dmap[cnts[c] + 1] += 1\n                cnts[c] += 1\n                if cnts[c] == 1:\n                    minv = 1\n                elif dmap[minv] <= 0:\n                    minv += 1\n                maxv = max(maxv, cnts[c])\n                ans += maxv - minv\n        return ans\n```\nTypeScript 代码:\n```TypeScript \nfunction beautySum(s: string): number {\n    let n = s.length, ans = 0\n    for (let i = 0; i < n; i++) {\n        const cnts = new Array<number>(26).fill(0)\n        const map = new Map()\n        let min = 0, max = 0\n        for (let j = i; j < n; j++) {\n            const c = s.charCodeAt(j) - 'a'.charCodeAt(0)\n            if (!map.has(cnts[c])) map.set(cnts[c], 0)\n            map.set(cnts[c], map.get(cnts[c]) - 1)\n            if (!map.has(cnts[c] + 1)) map.set(cnts[c] + 1, 0)\n            map.set(cnts[c] + 1, map.get(cnts[c] + 1) + 1)\n            cnts[c]++\n            if (cnts[c] == 1) min = 1\n            else if (map.get(min) <= 0) min++\n            max = Math.max(max, cnts[c])\n            ans += max - min\n        }\n    }\n    return ans\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(C)$,其中 $C = 26$ 为字符集大小", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1781` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1781-1790/1784. 检查二进制字符串字段（简单）.md", "url_title": "1784. 检查二进制字符串字段", "url": "https://leetcode.cn/problems/check-if-binary-string-has-at-most-one-segment-of-ones/solution/by-ac_oier-kiu6/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个二进制字符串 `s` ,该字符串 不含前导零 。\n\n如果 `s` 包含 零个或一个由连续的 `'1'` 组成的字段 ,返回 `true`。否则,返回 `false`。\n\n如果 `s` 中 由连续若干个 `'1'` 组成的字段 数量不超过 `1`,返回 `true`。否则,返回 `false`。\n\n示例 1:\n```\n输入:s = \"1001\"\n\n输出:false\n\n解释:由连续若干个 '1' 组成的字段数量为 2,返回 false\n```\n示例 2:\n```\n输入:s = \"110\"\n\n输出:true\n```\n\n提示:\n* $1 <= s.length <= 100$\n* `s[i]` 为 `'0'` 或 `'1'`\n* `s[0]` 为 `'1'`", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean checkOnesSegment(String s) {\n        int n = s.length(), cnt = 0, idx = 0;\n        while (idx < n && cnt <= 1) {\n            while (idx < n && s.charAt(idx) == '0') idx++;\n            if (idx < n) {\n                while (idx < n && s.charAt(idx) == '1') idx++;\n                cnt++;\n            }\n        }\n        return cnt <= 1;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction checkOnesSegment(s: string): boolean {\n    let n = s.length, cnt = 0, idx = 0\n    while (idx < n && cnt <= 1) {\n        while (idx < n && s[idx] == '0') idx++\n        if (idx < n) {\n            while (idx < n && s[idx] == '1') idx++\n            cnt++\n        }\n    }\n    return cnt <= 1\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def checkOnesSegment(self, s: str) -> bool:\n        n, cnt, idx = len(s), 0, 0\n        while idx < n and cnt <= 1:\n            while idx < n and s[idx] == '0':\n                idx += 1\n            if idx < n:\n                while idx < n and s[idx] == '1':\n                    idx += 1\n                cnt += 1\n        return cnt <= 1\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1784` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1781-1790/1785. 构成特定和需要添加的最少元素（中等）.md", "url_title": "1785. 构成特定和需要添加的最少元素", "url": "https://acoier.com/2022/12/16/1785.%20%E6%9E%84%E6%88%90%E7%89%B9%E5%AE%9A%E5%92%8C%E9%9C%80%E8%A6%81%E6%B7%BB%E5%8A%A0%E7%9A%84%E6%9C%80%E5%B0%91%E5%85%83%E7%B4%A0%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/", "difficulty": "中等", "tags": ["贪心", "模拟"], "question": "给你一个整数数组 `nums`,和两个整数 `limit` 与 `goal`。\n\n数组 `nums` 有一条重要属性:`abs(nums[i]) <= limit`。\n\n返回使数组元素总和等于 `goal` 所需要向数组中添加的 最少元素数量 ,添加元素 不应改变 数组中 `abs(nums[i]) <= limit` 这一属性。\n\n注意,如果 `x >= 0`,那么 `abs(x)` 等于 `x` ;否则,等于 `-x`。\n\n示例 1:\n```\n输入:nums = [1,-1,1], limit = 3, goal = -4\n\n输出:2\n\n解释:可以将 -2 和 -3 添加到数组中,数组的元素总和变为 1 - 1 + 1 - 2 - 3 = -4 。\n```\n示例 2:\n```\n输入:nums = [1,-10,9,1], limit = 100, goal = 0\n\n输出:1\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $1 <= limit <= 10^6$\n* $-limit <= nums[i] <= limit$\n* $-10^9 <= goal <= 10^9$", "solution": "### 贪心 \n\n对于 `nums` 而言,我们可以先通过 $O(n)$ 的遍历求得其原总和 `sum` 为何值。\n\n若 `sum` 与 `goal` 不等,我们可以按照「贪心」的方式里添加元素。\n\n由于添加的元素需要满足 `abs(x) <= limit` 要求,因此我们添加数的范围在 $[-limit, limit]$ 之间。\n\n为确保添加的元素最小,我们应当优先添加能够有效抵消两者差值的数值(添加 $limit$ 或 $-limit$),添加个数为 $\\left \\lceil \\frac{\\left | sum - goal \\right |}{limit} \\right \\rceil$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int minElements(int[] nums, int limit, int goal) {\n        long sum = 0;\n        for (int x : nums) sum += x;\n        return (int) ((Math.abs(sum - goal) + limit - 1) / limit);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction minElements(nums: number[], limit: number, goal: number): number {\n    let sum = 0\n    for (const x of nums) sum += x\n    return Math.ceil(Math.abs(sum - goal) / limit)\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def minElements(self, nums: List[int], limit: int, goal: int) -> int:\n        sumv = sum(nums)\n        return (abs(sumv - goal) + limit - 1) // limit\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1785` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1781-1790/1786. 从第一个节点出发到最后一个节点的受限路径数（中等）.md", "url_title": "1786. 从第一个节点出发到最后一个节点的受限路径数", "url": "https://leetcode-cn.com/problems/number-of-restricted-paths-from-first-to-last-node/solution/xiang-jie-dui-you-hua-dijkstra-dong-tai-i6j0d/", "difficulty": "中等", "tags": ["最短路", "线性 DP"], "question": "现有一个加权无向连通图。给你一个正整数 `n` ,表示图中有 `n` 个节点,并按从 `1` 到 `n` 给节点编号;另给你一个数组 `edges`,其中每个 $edges[i] = [u_{i}, v_{i}, weight_{i}]$ 表示存在一条位于节点 $u_{i}$ 和 $v_{i}$ 之间的边,这条边的权重为 $weight_{i}$ 。\n\n从节点 start 出发到节点 `end` 的路径是一个形如 $[z_{0}, z_{1}, z_{2}, ..., z_{k}]$ 的节点序列,满足 $z_{0} = start$ 、$z_{k} = end$ 且在所有符合 $0 <= i <= k-1$ 的节点 $z_{i}$ 和 $z_{i}+1$ 之间存在一条边。\n\n路径的距离定义为这条路径上所有边的权重总和。用 `distanceToLastNode(x)` 表示节点 `n` 和 `x` 之间路径的最短距离。受限路径 为满足 $distanceToLastNode(z_{i}) > distanceToLastNode(z_{i}+1)$ 的一条路径,其中 $0 <= i <= k-1$ 。\n\n返回从节点 `1` 出发到节点 `n` 的 受限路径数 。由于数字可能很大,请返回对 $10^9 + 7$ 取余 的结果。\n\n示例 1:\n\n```\n输入:n = 5, edges = [[1,2,3],[1,3,3],[2,3,1],[1,4,2],[5,2,2],[3,5,1],[5,4,10]]\n输出:3\n解释:每个圆包含黑色的节点编号和蓝色的 distanceToLastNode 值。三条受限路径分别是:\n1) 1 --> 2 --> 5\n2) 1 --> 2 --> 3 --> 5\n3) 1 --> 3 --> 5\n```\n示例 2:\n\n```\n输入:n = 7, edges = [[1,3,1],[4,1,2],[7,3,4],[2,5,3],[5,6,1],[6,7,2],[7,5,3],[2,6,4]]\n输出:1\n解释:每个圆包含黑色的节点编号和蓝色的 distanceToLastNode 值。唯一一条受限路径是:1 --> 3 --> 7 。\n```\n\n提示:\n* $1 <= n <= 2 \\times 10^4$\n* $n - 1 <= edges.length <= 4 \\times 10^4$\n* $edges[i].length == 3$\n* $1 <= ui, vi <= n$\n* $u_i != v_i$\n* $1 <= weighti <= 10^5$\n* 任意两个节点之间至多存在一条边\n* 任意两个节点之间至少存在一条路径", "solution": "### 堆优化 Dijkstra + 动态规划\n\n`n` 为点的数量,`m` 为边的数量。\n\n为了方便理解,我们将第 `n` 个点称为「起点」,第 `1` 个点称为「结尾」。\n\n按照题意,我们需要先求每个点到结尾的「最短路」,求最短路的算法有很多,通常根据「有无负权边」& 「稠密图还是稀疏图」进行选择。\n\n该题只有正权变,而且“边”和“点”的数量在一个数量级上,属于稀疏图。\n\n因此我们可以采用「最短路」算法:堆优化的 Dijkstra,复杂度为 $O(m\\log{n})$。\n\n> PS. 通常会优先选择 SPFA,SPFA 通常情况下复杂度为 $O(m)$,但最坏情况下复杂度为 $O(n \\times m)$。从数据上来说 SPFA 也会超,而且本题还结合了 DP,因此可能会卡掉图论部分的 SPFA。出于这些考虑,我直接使用堆优化 Dijkstra。\n\n当我们求得了每个点到结尾的「最短路」之后,接下来我们需要求得从「起点」到「结尾」的**受限路径数量**。\n\n这显然可以用 DP 来做。\n\n我们定义 `f(i)` 为从第 `i` 个点到结尾的受限路径数量,`f(1)` 就是我们的答案,而 `f(n) = 1` 是一个显而易见的起始条件。\n\n因为题目的**受限路径数**的定义,我们需要找的路径所包含的点,必须是其距离结尾的最短路越来越近的。\n\n举个🌰,对于示例 `1`,其中一条符合要求的路径为 `1 --> 2 --> 3 --> 5`。\n\n这条路径的搜索过程可以看做,从结尾(第 5 个点)出发,逆着走,每次选择一个点(例如 a)之后,再选择下一个点(例如 b)时就必须**满足最短路距离比上一个点(点 a)要远**,如果最终能选到起点(第一个点),说明统计出一条有效路径。\n\n我们的搜索方式决定了需要先按照最短路距离进行从小到大排序。\n\n**不失一般性,当我们要求 `f(i)` 的时候,其实找的是 `i` 点可以到达的点 `j`,并且 `j` 点到结尾的最短路要严格小于 `i` 点到结尾的最短路。**\n\n符合条件的点 `j` 有很多个,将所有的 `f(j)` 累加即是 `f(i)`。\n\n代码:\n```java\nclass Solution {\n    int mod = 1000000007;\n    public int countRestrictedPaths(int n, int[][] es) {\n        // 预处理所有的边权。 a b w -> a : { b : w } + b : { a : w }\n        Map<Integer, Map<Integer, Integer>> map = new HashMap<>(); \n        for (int[] e : es) {\n            int a = e[0], b = e[1], w = e[2];\n            Map<Integer, Integer> am = map.getOrDefault(a, new HashMap<Integer, Integer>());\n            am.put(b, w);\n            map.put(a, am);\n            Map<Integer, Integer> bm = map.getOrDefault(b, new HashMap<Integer, Integer>());\n            bm.put(a, w);\n            map.put(b, bm);\n        }\n\n        // 堆优化 Dijkstra:求 每个点 到 第n个点 的最短路\n        int[] dist = new int[n + 1];\n        boolean[] st = new boolean[n + 1];\n        Arrays.fill(dist, Integer.MAX_VALUE);\n        dist[n] = 0;\n        Queue<int[]> q = new PriorityQueue<int[]>((a, b)->a[1]-b[1]); // 点编号,点距离。根据点距离从小到大\n        q.add(new int[]{n, 0});\n        while (!q.isEmpty()) {\n            int[] e = q.poll();\n            int idx = e[0], cur = e[1];\n            if (st[idx]) continue;\n            st[idx] = true;\n            Map<Integer, Integer> mm = map.get(idx);\n            if (mm == null) continue;\n            for (int i : mm.keySet()) {\n                dist[i] = Math.min(dist[i], dist[idx] + mm.get(i));\n                q.add(new int[]{i, dist[i]});\n            }\n        }\n\n        // dp 过程\n        int[][] arr = new int[n][2];\n        for (int i = 0; i < n; i++) arr[i] = new int[]{i + 1, dist[i + 1]}; // 点编号,点距离\n        Arrays.sort(arr, (a, b)->a[1]-b[1]); // 根据点距离从小到大排序\n\n        // 定义 f(i) 为从第 i 个点到结尾的受限路径数量\n        // 从 f[n] 递推到 f[1]\n        int[] f = new int[n + 1]; \n        f[n] = 1;\n        for (int i = 0; i < n; i++) {\n            int idx = arr[i][0], cur = arr[i][1];\n            Map<Integer, Integer> mm = map.get(idx);\n            if (mm == null) continue;\n            for (int next : mm.keySet()) {\n                if (cur > dist[next]) {\n                    f[idx] += f[next];\n                    f[idx] %= mod;\n                }\n            }\n            // 第 1 个节点不一定是距离第 n 个节点最远的点,但我们只需要 f[1],可以直接跳出循环\n            if (idx == 1) break;\n        }\n        return f[1];\n    }\n}\n```\n* 时间复杂度:求最短路的复杂度为 $O(m\\log{n})$,DP 过程坏情况下要扫完所有的边,复杂度为 $O(m)$。整体复杂度为 $O(m\\log{n})$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1786` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1781-1790/1787. 使所有区间的异或结果为零（困难）.md", "url_title": "1787. 使所有区间的异或结果为零", "url": "https://leetcode-cn.com/problems/make-the-xor-of-all-segments-equal-to-zero/solution/gong-shui-san-xie-chou-xiang-cheng-er-we-ww79/", "difficulty": "困难", "tags": ["线性 DP", "异或", "数学"], "question": "给你一个整数数组 `nums` 和一个整数 `k` 。\n区间 `[left, right]``(left <= right)`的 异或结果 是对下标位于 `left` 和 `right`(包括 `left` 和 `right` )之间所有元素进行 XOR 运算的结果:`nums[left] XOR nums[left+1] XOR ... XOR nums[right]` 。\n\n返回数组中**要更改的最小元素数** ,以使所有长度为 `k` 的区间异或结果等于零。\n\n \n\n示例 1:\n```\n输入:nums = [1,2,0,3,0], k = 1\n\n输出:3\n\n解释:将数组 [1,2,0,3,0] 修改为 [0,0,0,0,0]\n```\n示例 2:\n```\n输入:nums = [3,4,5,2,1,7,3,4,7], k = 3\n\n输出:3\n\n解释:将数组 [3,4,5,2,1,7,3,4,7] 修改为 [3,4,7,3,4,7,3,4,7]\n```\n示例 3:\n```\n输入:nums = [1,2,4,1,2,5,1,2,6], k = 3\n\n输出:3\n\n解释:将数组[1,2,4,1,2,5,1,2,6] 修改为 [1,2,3,1,2,3,1,2,3]\n```\n\n提示:\n\n* 1 <= k <= nums.length <= 2000\n* 0 <= nums[i] < $2^{10}$", "solution": "### 基本分析\n\n题目示例所包含的提示过于明显了,估计很多同学光看三个样例就猜出来了:**答案数组必然是每 $k$ 个一组进行重复的。**\n\n这样的性质是可由「答案数组中所有长度为 $k$ 的区间异或结果为 $0$」推导出来的:\n\n* 假设区间 $[i, j]$ 长度为 $k$,其异或结果为 $0$。即 $nums[i] ⊕ nums[i + 1] ⊕ ... ⊕ nums[j] = 0$\n\n* 长度不变,将区间整体往后移动一位 $[i + 1, j + 1]$,其异或结果为 $0$。即 $nums[i + 1] ⊕ ... ⊕ nums[j] ⊕ nums[j + 1] = 0$\n\n* 两式结合,中间 $[i + 1, j]$ 区间的数值出现两次,抵消掉最终剩下 $nums[i] ⊕ nums[j + 1] = 0$,即推出 $nums[i]$ 必然等于 $num[j + 1]$。\n\n即答案数组必然每 $k$ 个一组进行重复。\n\n也可以从滑动窗口的角度分析:窗口每滑动一格,会新增和删除一个值。对于异或而言,新增和删除都是对值本身做异或,因此新增值和删除值相等(保持窗口内异或值为 $0$)。\n\n因此我们将这个一维的输入看成二维,从而将问题转化为:**使得最终每列相等,同时「首行」的异或值为 $0$ 的最小修改次数。**\n\n当然 $n$ 和 $k$ 未必成倍数关系,这时候最后一行可能为不足 $k$ 个。这也是为什么上面没有说「每行异或结果为 $0$」,而是说「首行异或结果为 $0$」的原因:\n\n***\n\n### 动态规划\n\n定义 $f[i][xor]$ 为考虑前 $i$ 列,且首行前 $i$ 列异或值为 $xor$ 的最小修改次数,最终答案为 $f[k - 1][0]$。\n\n第一维的范围为 $[0, k)$,由输入参数给出;第二维为 $[0, 2^{10})$,根据题目给定的数据范围 `0 <= nums[i] < 2^10` 可得(异或为不进位加法,因此最大异或结果不会超过 $2^{10}$)。\n\n为了方便,我们需要使用哈希表 $map$ 记录每一列的数字分别出现了多少次,使用变量 $cnt$ 统计该列有多少数字(因为最后一行可能不足 $k$ 个)。\n\n不失一般性的考虑 $f[i][xor]$ 如何转移:\n\n* 当前处于第 $0$ 列:由于没有前一列,这时候只需要考虑怎么把该列变成 $xor$ 即可:\n\n$$\nf[0][xor] = cnt - map.get(xor)\n$$\n\n* 当前处于其他列:需要考虑与前面列的关系。\n\n    我们知道最终的 $f[i][xor]$ 由两部分组成:一部分是前 $i - 1$ 列的修改次数,一部分是当前列的修改次数。\n    \n    这时候需要分情况讨论:\n    \n    * **仅修改当列的部分数**:这时候需要从哈希表中遍历已存在的数,在所有方案中取 $min$:\n    $$\n    f[i][xor] = f[i - 1][xor ⊕ cur] + cnt - map.get(cur)\n    $$\n\n    * **对整列进行修改替换**:此时当前列的修改成本固定为 $cnt$,只需要取前 $i - 1$ 列的最小修改次数过来即可:\n    $$\n    f[i][xor] = f[i - 1][xor'] + cnt\n    $$\n\n最终 $f[i][xor]$ 在所有上述方案中取 $min$。为了加速「取前 $i - 1$ 列的最小修改次数」的过程,我们可以多开一个 $g[]$ 数组来记录前一列的最小状态值。\n\n代码:\n```Java\nclass Solution {\n    public int minChanges(int[] nums, int k) {\n        int n = nums.length;\n        int max = 1024; \n        int[][] f = new int[k][max];\n        int[] g = new int[k];\n        for (int i = 0; i < k; i++) {\n            Arrays.fill(f[i], 0x3f3f3f3f);\n            g[i] = 0x3f3f3f3f;\n        }\n        for (int i = 0, cnt = 0; i < k; i++, cnt = 0) {\n            // 使用 map 和 cnt 分别统计当前列的「每个数的出现次数」和「有多少个数」\n            Map<Integer, Integer> map = new HashMap<>();\n            for (int j = i; j < n; j += k) {\n                map.put(nums[j], map.getOrDefault(nums[j], 0) + 1);\n                cnt++;\n            }\n            if (i == 0) { // 第 0 列:只需要考虑如何将该列变为 xor 即可\n                for (int xor = 0; xor < max; xor++) {\n                    f[0][xor] = Math.min(f[0][xor], cnt - map.getOrDefault(xor, 0));\n                    g[0] = Math.min(g[0], f[0][xor]);\n                }\n            } else { // 其他列:考虑与前面列的关系\n                for (int xor = 0; xor < max; xor++) {\n                    f[i][xor] = g[i - 1] + cnt; // 整列替换\n                    for (int cur : map.keySet()) { // 部分替换\n                        f[i][xor] = Math.min(f[i][xor], f[i - 1][xor ^ cur] + cnt - map.get(cur));\n                    }\n                    g[i] = Math.min(g[i], f[i][xor]);\n                }\n            }\n        }\n        return f[k - 1][0];\n    }\n}\n```\n* 时间复杂度:共有 $O(C * k)$ 个状态需要被转移(其中 $C$ 固定为 $2^{10}$),每个状态的转移需要遍历哈希表,最多有 $\\frac{n}{k}$ 个数,复杂度为 $O(\\frac{n}{k})$。整体复杂度为 $O(C * n)$\n* 空间复杂度:$O(C * k)$,其中 $C$ 固定为 $2^{10} + 1$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1787` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1781-1790/1790. 仅执行一次字符串交换能否使两个字符串相等（简单）.md", "url_title": "1790. 仅执行一次字符串交换能否使两个字符串相等", "url": "https://leetcode-cn.com/problems/make-the-xor-of-all-segments-equal-to-zero/solution/gong-shui-san-xie-chou-xiang-cheng-er-we-ww79/", "difficulty": "简单", "tags": ["模拟"], "question": "给你长度相等的两个字符串 `s1` 和 `s2` 。一次 字符串交换 操作的步骤如下:选出某个字符串中的两个下标(不必不同),并交换这两个下标所对应的字符。\n\n如果对 其中一个字符串 执行 最多一次字符串交换 就可以使两个字符串相等,返回 `true` ;否则,返回 `false` 。\n\n示例 1:\n```\n输入:s1 = \"bank\", s2 = \"kanb\"\n\n输出:true\n\n解释:例如,交换 s2 中的第一个和最后一个字符可以得到 \"bank\"\n```\n示例 2:\n```\n输入:s1 = \"attack\", s2 = \"defend\"\n\n输出:false\n\n解释:一次字符串交换无法使两个字符串相等\n```\n示例 3:\n```\n输入:s1 = \"kelb\", s2 = \"kelb\"\n\n输出:true\n\n解释:两个字符串已经相等,所以不需要进行字符串交换\n```\n示例 4:\n```\n输入:s1 = \"abcd\", s2 = \"dcba\"\n\n输出:false\n```\n\n提示:\n* $1 <= s1.length, s2.length <= 100$\n* $s1.length = s2.length$\n* `s1` 和 `s2` 仅由小写英文字母组成", "solution": "### 模拟\n\n根据题意进行模拟即可 : 使用 `a` 和 `b` 记录不同的位置下标,初始值为 `-1`,若「不同位置超过 $2$ 个」或「只有 $1$ 个」直接返回 `false`,若「不存在不同位置」或「不同位置字符相同」,则返回 `true`。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean areAlmostEqual(String s1, String s2) {\n        int n = s1.length(), a = -1, b = -1;\n        for (int i = 0; i < n; i++) {\n            if (s1.charAt(i) == s2.charAt(i)) continue;\n            if (a == -1) a = i;\n            else if (b == -1) b = i;\n            else return false;\n        }\n        if (a == -1) return true;\n        if (b == -1) return false;\n        return s1.charAt(a) == s2.charAt(b) && s1.charAt(b) == s2.charAt(a);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction areAlmostEqual(s1: string, s2: string): boolean {\n    let n = s1.length, a = -1, b = -1\n    for (let i = 0; i < n; i++) {\n        if (s1[i] == s2[i]) continue\n        if (a == -1) a = i\n        else if (b == -1) b = i\n        else return false\n    }\n    if (a == -1) return true\n    if (b == -1) return false\n    return s1[a] == s2[b] && s1[b] == s2[a]\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def areAlmostEqual(self, s1: str, s2: str) -> bool:\n        n, a, b = len(s1), -1, -1\n        for i in range(n):\n            if s1[i] == s2[i]:\n                continue\n            if a == -1:\n                a = i\n            elif b == -1:\n                b = i\n            else:\n                return False\n        if a == -1:\n            return True\n        if b == -1:\n            return False\n        return s1[a] == s2[b] and s1[b] == s2[a]\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1790` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1791-1800/1791. 找出星型图的中心节点（简单）.md", "url_title": "1791. 找出星型图的中心节点", "url": "https://leetcode-cn.com/problems/find-center-of-star-graph/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-qoix/", "difficulty": "简单", "tags": ["模拟"], "question": "有一个无向的 星型 图,由 $n$ 个编号从 $1$ 到 $n$ 的节点组成。星型图有一个 中心 节点,并且恰有 $n - 1$ 条边将中心节点与其他每个节点连接起来。\n\n给你一个二维整数数组 `edges` ,其中 $edges[i] = [u_i, v_i]$ 表示在节点 $u_i$ 和 $v_i$ 之间存在一条边。请你找出并返回 `edges` 所表示星型图的中心节点。\n\n示例 1:\n\n```\n输入:edges = [[1,2],[2,3],[4,2]]\n\n输出:2\n\n解释:如上图所示,节点 2 与其他每个节点都相连,所以节点 2 是中心节点。\n```\n示例 2:\n```\n输入:edges = [[1,2],[5,1],[1,3],[1,4]]\n\n输出:1\n```\n\n提示:\n* $3 <= n <= 10^5$\n* $edges.length == n - 1$\n* $edges[i].length == 2$\n* $1 <= u_i, v_i <= n$\n* $u_i != v_i$\n* 题目数据给出的 `edges` 表示一个有效的星型图", "solution": "### 模拟\n\n根据题意,中心节点必然出现在所有的 $edges[i]$ 中,因此使用前两条边即可确定答案。\n\n起始让 $edges[0][0]$ 和 $edges[0][1]$ 作为答案候选,然后在 $edges[1]$ 关系中检查哪个候选出现过。\n\n代码:\n```Java\nclass Solution {\n    public int findCenter(int[][] edges) {\n        int a = edges[0][0], b = edges[0][1];\n        if (a == edges[1][0] || a == edges[1][1]) return a;\n        else return b;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 进阶\n\n**显然,如果将每个 $edges[i]$ 看做两点之间的「双向边」的话,那么星型图为「欧拉图」,所有点的出度均等于入度。**\n\n容易将题拓展为求欧拉回路的问题:\n\n>**给定星与星之间的距离,从某个星的位置出发,经过所有的边(可重复经过)并回到起点的最短距离,输出能够取得最短距离的路径(无解输出 $-1$)**。\n\n答案就是求「欧拉回路」,其中「可重复经过边」包含了「可重复经过点」的含义。\n\n由于星星图存在中心点,必然有解(但为了题目描述的完整性,出题都会预设一个无解返回值);同时也不会重复经过某条边(仍然是为了题目描述完整性才这样写)。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1791` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1791-1800/1797. 设计一个验证系统（中等）.md", "url_title": "1797. 设计一个验证系统", "url": null, "difficulty": "中等", "tags": ["链表", "哈希表"], "question": "你需要设计一个包含验证码的验证系统。\n\n每一次验证中,用户会收到一个新的验证码,这个验证码在 `ct` 时刻之后 `timeToLive` 秒过期。\n\n如果验证码被更新了,那么它会在 `ct` (可能与之前的 `ct` 不同)时刻延长 `timeToLive` 秒。\n\n请你实现 `AuthenticationManager` 类:\n\n* `AuthenticationManager(int timeToLive)` 构造 `AuthenticationManager` 并设置 `timeToLive` 参数。\n\n* `generate(string id, int ct)` 给定 `id`,在当前时间 `ct` 生成一个新的验证码。\n\n* `renew(string id, int ct)` 将给定 `id` 且未过期的验证码在 `ct` 时刻更新。\n\n  如果给定 `id` 对应的验证码不存在或已过期,请你忽略该操作,不会有任何更新操作发生。\n\n* `countUnexpiredTokens(int ct)` 请返回在给定 `ct` 时刻,未过期的验证码数目。\n\n如果一个验证码在时刻 `t` 过期,且另一个操作恰好在时刻 `t` 发生(`renew` 或者 `countUnexpiredTokens` 操作),过期事件优先于其他操作。\n\n示例 1:\n\n```\n输入:\n[\"AuthenticationManager\", \"renew\", \"generate\", \"countUnexpiredTokens\", \"generate\", \"renew\", \"renew\", \"countUnexpiredTokens\"]\n[[5], [\"aaa\", 1], [\"aaa\", 2], [6], [\"bbb\", 7], [\"aaa\", 8], [\"bbb\", 10], [15]]\n\n输出:\n[null, null, null, 1, null, null, null, 0]\n\n解释:\nAuthenticationManager authenticationManager = new AuthenticationManager(5); // 构造 AuthenticationManager ,设置 timeToLive = 5 秒。\nauthenticationManager.renew(\"aaa\", 1); // 时刻 1 时,没有验证码的 tokenId 为 \"aaa\" ,没有验证码被更新。\nauthenticationManager.generate(\"aaa\", 2); // 时刻 2 时,生成一个 tokenId 为 \"aaa\" 的新验证码。\nauthenticationManager.countUnexpiredTokens(6); // 时刻 6 时,只有 tokenId 为 \"aaa\" 的验证码未过期,所以返回 1 。\nauthenticationManager.generate(\"bbb\", 7); // 时刻 7 时,生成一个 tokenId 为 \"bbb\" 的新验证码。\nauthenticationManager.renew(\"aaa\", 8); // tokenId 为 \"aaa\" 的验证码在时刻 7 过期,且 8 >= 7 ,所以时刻 8 的renew 操作被忽略,没有验证码被更新。\nauthenticationManager.renew(\"bbb\", 10); // tokenId 为 \"bbb\" 的验证码在时刻 10 没有过期,所以 renew 操作会执行,该 token 将在时刻 15 过期。\nauthenticationManager.countUnexpiredTokens(15); // tokenId 为 \"bbb\" 的验证码在时刻 15 过期,tokenId 为 \"aaa\" 的验证码在时刻 7 过期,所有验证码均已过期,所以返回 0 。\n```\n\n提示:\n* $1 <= timeToLive <= 10^8$\n* $1 <= currentTime <= 10^8$\n* $1 <= tokenId.length <= 5$\n* `id` 只包含小写英文字母。\n* 所有 `generate` 函数的调用都会包含独一无二的 `id` 值。\n* 所有函数调用中,`ct` 的值严格递增。\n* 所有函数的调用次数总共不超过 `2000` 次。", "solution": "### 哈希表\n\n数据范围只有 `20`,我们使用哈希表记录每个 `id` 的过期时间 `ct`,在每次查询时遍历整个哈希表来统计未过期的验证码数量。\n\nJava 代码:\n```Java\nclass AuthenticationManager {\n    int d;\n    Map<String, Integer> map = new HashMap<>();\n    public AuthenticationManager(int timeToLive) {\n        d = timeToLive;\n    }\n    public void generate(String id, int ct) {\n        map.put(id, ct + d);\n    }\n    public void renew(String id, int ct) {\n        if (!map.containsKey(id) || map.get(id) <= ct) return ;\n        map.put(id, ct + d);\n    }\n    public int countUnexpiredTokens(int ct) {\n        int ans = 0;\n        for (String id : map.keySet()) {\n            if (map.get(id) > ct) ans++;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass AuthenticationManager {\n    int d;\n    unordered_map<string, int> map;\npublic:\n    AuthenticationManager(int timeToLive) : d(timeToLive){}\n    void generate(string id, int ct) {\n        map[id] = ct + d;\n    }\n    void renew(string id, int ct) {\n        if (!map.count(id) || map[id] <= ct) return;\n        map[id] = ct + d;\n    }\n    int countUnexpiredTokens(int ct) {\n        int ans = 0;\n        for (auto it = map.begin(); it != map.end(); ++it) {\n            if (it->second > ct) ans++;\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass AuthenticationManager:\n    def __init__(self, timeToLive):\n        self.d = timeToLive\n        self.map = {}\n\n    def generate(self, id: str, ct: int) -> None:\n        self.map[id] = ct + self.d\n\n    def renew(self, id: str, ct: int) -> None:\n        if id not in self.map or self.map[id] <= ct:\n            return\n        self.map[id] = ct + self.d\n\n    def countUnexpiredTokens(self, ct: int) -> int:\n        ans = 0\n        for id in self.map:\n            if self.map[id] > ct:\n                ans += 1\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nclass AuthenticationManager {\n    d: number;\n    map: { [id: string]: number } = {};\n\n    constructor(timeToLive: number) {\n        this.d = timeToLive;\n    }\n\n    generate(id: string, ct: number): void {\n        this.map[id] = ct + this.d;\n    }\n\n    renew(id: string, ct: number): void {\n        if (!this.map.hasOwnProperty(id) || this.map[id] <= ct) {\n            return;\n        }\n        this.map[id] = ct + this.d;\n    }\n\n    countUnexpiredTokens(ct: number): number {\n        let ans = 0;\n        for (const id in this.map) {\n            if (this.map[id] > ct) {\n                ans++;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:`generate` 操作和 `renew` 操作的复杂度为 $O(1)$;`countUnexpiredTokens` 操作的复杂度为 $O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 双向链表\n\n在所有函数的调用过程中,`timeToLive` 都在单调递增。\n\n在哈希表的做法里,我们没有清理旧验证码的操作,同时每次执行 `countUnexpiredTokens` 时,需要对整个哈希表进行遍历。\n\n实际上,如果我们引入 **双向链表**,并将哈希表的键值对定义从 `{验证码:过期时间值}` 调整为 `{验证码:链表节点}` 时(链表节点属性仅包含验证码字符串 `id` 及其过期时间 `t`),我们便能实现如下优化:\n\n* **减少统计未过期验证码时的无效遍历**:由于构建的双向链表严格按照 `timeToLive` 递增,因此可以从尾部出发,从后往前利用链表节点的 `prev` 指针进行遍历统计。\n\n  如此一来,有多少未过期的验证码,我们就会遍历多少个链表节点,其余已过期的节点对象并不会被访问;\n\n* **引入清理时机**:由于上述的统计过程,我们会找到最靠前的一个未过期节点。可以将其作为新的双向链表新头结点,从而将整段的过期节点从双向链表中删除\n\n最后,我们像对其他链表题目一样,为了方便,引入 `he` 和 `ta` 的头尾链表哨兵节点以减少边界处理。\n\nJava 代码:\n```Java \nclass AuthenticationManager {\n    class Node {\n        String id;\n        int t;\n        Node prev, next;\n        Node (String _id, int _t) {\n            id = _id; t = _t;\n        }\n    }\n    int d;\n    Node he, ta;\n    Map<String, Node> map = new HashMap<>();\n    public AuthenticationManager(int timeToLive) {\n        he = new Node(\"\", -1); ta = new Node(\"\", (int)1e9);\n        he.next = ta; ta.prev = he;\n        d = timeToLive;\n    }\n    public void generate(String id, int ct) {\n        Node node = new Node(id, ct + d);\n        node.prev = ta.prev;\n        node.next = ta;\n        ta.prev.next = node;\n        ta.prev = node;\n        map.put(id, node);\n    }\n    public void renew(String id, int ct) {\n        if (!map.containsKey(id) || map.get(id).t <= ct) return ;\n        Node node = map.get(id);\n        node.prev.next = node.next;\n        node.next.prev = node.prev;\n        generate(id, ct);\n    }\n    public int countUnexpiredTokens(int ct) {\n        int ans = 0;\n        Node cur = ta.prev;\n        while (cur.t > ct && ++ans >= 0) cur = cur.prev;\n        he.next = cur.next;\n        cur.next.prev = he;\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++ \nclass AuthenticationManager {\n    struct Node {\n        string id;\n        int t;\n        Node *prev, *next;\n        Node (string _id, int _t) : id(_id), t(_t), prev(nullptr), next(nullptr) {}\n    };\n    int d;\n    Node *he, *ta;\n    unordered_map<string, Node*> map;\npublic:\n    AuthenticationManager(int timeToLive) : d(timeToLive) {\n        he = new Node(\"\", -1); \n        ta = new Node(\"\", (int)1e9);\n        he->next = ta; \n        ta->prev = he;\n    }\n    void generate(string id, int ct) {\n        Node* node = new Node(id, ct + d);\n        node->prev = ta->prev;\n        node->next = ta;\n        ta->prev->next = node;\n        ta->prev = node;\n        map[id] = node;\n    }\n    void renew(string id, int ct) {\n        if (!map.count(id) || map[id]->t <= ct) return;\n        Node* node = map[id];\n        node->prev->next = node->next;\n        node->next->prev = node->prev;\n        generate(id, ct);\n    }\n    int countUnexpiredTokens(int ct) {\n        int ans = 0;\n        Node* cur = ta->prev;\n        while (cur->t > ct && ++ans >= 0) cur = cur->prev;\n        he->next = cur->next;\n        cur->next->prev = he;\n        return ans;\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nclass Node {\n    id: string;\n    t: number;\n    prev: Node | null;\n    next: Node | null;\n    constructor(_id: string, _t: number) {\n        this.id = _id;\n        this.t = _t;\n        this.prev = null\n        this.next = null\n    }\n}\nclass AuthenticationManager {\n    d: number;\n    he: Node;\n    ta: Node;\n    map: {[id: string]: Node};\n    constructor(timeToLive: number) {\n        this.d = timeToLive;\n        this.he = new Node(\"\", -1)\n        this.ta = new Node(\"\", 1e9)\n        this.he.next = this.ta\n        this.ta.prev = this.he\n        this.map = {};\n    }\n\n    generate(id: string, ct: number) {\n        let node : Node = new Node(id, ct + this.d) ;\n        node.prev = this.ta.prev;\n        node.next = this.ta;\n        this.ta.prev!.next = node;\n        this.ta.prev = node;\n        this.map[id] = node;\n    }\n\n    renew(id: string, ct: number) {\n        if (!this.map.hasOwnProperty(id) || this.map[id].t <= ct) {\n            return;\n        }\n        var node : Node = this.map[id];\n        node.prev!.next = node.next;\n        node.next!.prev = node.prev;\n        this.generate(id, ct);\n    }\n\n    countUnexpiredTokens(ct: number) {\n        let ans = 0;\n        let cur : Node = this.ta.prev!;\n        while (cur.t > ct && ++ans >= 0) \n            cur = cur.prev!;\n        this.he.next = cur.next;\n        cur.next!.prev = this.he;\n        return ans;\n    }\n}\n```\n* 时间复杂度:`generate` 操作和 `renew` 操作的复杂度为 $O(1)$;`countUnexpiredTokens` 操作的复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1797` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1791-1800/1798. 你能构造出连续值的最大数目（中等）.md", "url_title": "1798. 你能构造出连续值的最大数目", "url": "https://leetcode.cn/problems/maximum-number-of-consecutive-values-you-can-make/solutions/2607482/gong-shui-san-xie-shu-xue-lei-gou-zao-ti-wf47/", "difficulty": "中等", "tags": ["数学", "脑筋急转弯", "排序", "构造"], "question": "给你一个长度为 `n` 的整数数组 `coins`,它代表你拥有的 `n` 个硬币。第 `i` 个硬币的值为 `coins[i]`。如果你从这些硬币中选出一部分硬币,它们的和为 `x` ,那么称,你可以构造出 `x` 。\n\n请返回从 `0` 开始(包括 `0` ),你最多能构造出多少个连续整数。\n\n你可能有多个相同值的硬币。\n\n示例 1:\n```\n输入:coins = [1,3]\n\n输出:2\n\n解释:你可以得到以下这些值:\n- 0:什么都不取 []\n- 1:取 [1]\n从 0 开始,你可以构造出 2 个连续整数。\n```\n示例 2:\n```\n输入:coins = [1,1,1,4]\n\n输出:8\n\n解释:你可以得到以下这些值:\n- 0:什么都不取 []\n- 1:取 [1]\n- 2:取 [1,1]\n- 3:取 [1,1,1]\n- 4:取 [4]\n- 5:取 [4,1]\n- 6:取 [4,1,1]\n- 7:取 [4,1,1,1]\n从 0 开始,你可以构造出 8 个连续整数。\n```\n示例 3:\n```\n输入:nums = [1,4,10,3,1]\n\n输出:20\n```\n\n提示:\n* $coins.length = n$\n* $1 <= n <= 4 \\times 10^4$\n* $1 <= coins[i] <= 4 \\times 10^4$", "solution": "### 数学\n\n`n` 的数据范围为 $4 \\times 10^4$,必然不是考察我们使用 `coins` 来构造单个数值 `x` 的逻辑,因为「遍历 + 逐个构造验证」的做法会超时,**因此只能是考察我们能否推导出整段构造的相关性质**。\n\n假设我们已经用前 `k` 个数值构造出连段 $[0, x]$ 中的任意数,当增加第 $k + 1$ 个数值时,还能否进行连续构造:\n\n* 若不能,则连续构造中断,答案为 $[0, x]$,共 $x + 1$ 个\n* 若能,则再考虑连续构造的右边界会到哪个地方\n\n由于题目允许我们任意使用 `coins` 中的数,同时整段构造又是不断扩大 $[0, x]$ 中右边界的过程(从小到大),为了方便,我们可以先对 `coins` 进行排序。\n\n不失一般性,假设我们已经使用 `coins` 中的前  `k` 个数构造出了范围 $[0, x]$ 中的任意数。当考虑增加一个 $coins[k]$ 后,我们可在每一个原有构造方案中增加 $coins[k]$,这样由 $coins[k]$ 所拓展出的构造范围便是 $[coins[k], coins[k] + x]$。\n\n原来的连续数是 $[0, x]$,若要保证连续,我们需要保证 $coins[k] <= x + 1$,此时构造连续段也从 $[0, x]$ 变为 $[0, coins[k] + x]$。\n\n即 $coins[k] > k + 1$ 是中断构造必要条件,再结合我们实现对 `coins` 进行了排序,容易证明如果 $coins[k]$ 都不能满足 $coins[k] <= x + 1$,排在 $coins[k]$ 后面比其大的数均不能满足要求。\n\n一些细节:起始时,我们可以不选 `coins` 中的任何数,即此时连续构造范围为 $[0, 0]$,随后从小到大遍历 `coins`,检查当前 $coins[i]$ 是否会中断构造。\n\nJava 代码:\n```Java\nclass Solution {\n    public int getMaximumConsecutive(int[] coins) {\n        Arrays.sort(coins);\n        int ans = 0;\n        for (int c : coins) {\n            if (c > ans + 1) break;\n            ans += c;\n        }\n        return ans + 1;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int getMaximumConsecutive(vector<int>& coins) {\n        sort(coins.begin(), coins.end());\n        int ans = 0;\n        for (int c : coins) {\n            if (c > ans + 1) break;\n            ans += c;\n        }\n        return ans + 1;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def getMaximumConsecutive(self, coins: List[int]) -> int:\n        coins.sort()\n        ans = 0\n        for c in coins:\n            if c > ans + 1: break\n            ans += c\n        return ans + 1\n```\nTypeScript 代码:\n```TypeScript\nfunction getMaximumConsecutive(coins: number[]): number {\n    coins.sort((a,b)=>a-b)\n    let ans = 0\n    for (const c of coins) {\n        if (c > ans + 1) break\n        ans += c\n    }\n    return ans + 1\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1798` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1801-1810/1801. 积压订单中的订单总数（中等）.md", "url_title": "1801. 积压订单中的订单总数", "url": "https://leetcode-cn.com/problems/number-of-orders-in-the-backlog/solution/gss-by-ac_oier-4pqk/", "difficulty": "中等", "tags": ["数据结构", "模拟", "优先队列(堆)"], "question": "给你一个二维整数数组 $orders$ ,其中每个 $orders[i] = [price_i, amount_i, orderType_i]$ 表示有 $amount_i$ 笔类型为 $orderType_i$、价格为 $price_i$ 的订单。\n\n订单类型 $orderType_i$ 可以分为两种:\n\n* $0$ 表示这是一批采购订单 `buy`\n* $1$ 表示这是一批销售订单 `sell`\n\n注意,$orders[i]$ 表示一批共计 $amount_i$ 笔的独立订单,这些订单的价格和类型相同。\n\n对于所有有效的 $i$ ,由 $orders[i]$ 表示的所有订单提交时间均早于 $orders[i+1]$ 表示的所有订单。\n\n存在由未执行订单组成的积压订单。积压订单最初是空的。\n\n提交订单时,会发生以下情况:\n\n* 如果该订单是一采购订单 `buy`,则可以查看积压订单中价格 **最低** 的销售订单 `sell`。如果该销售订单 `sell` 的价格 **低于或等于** 当前采购订单 `buy` 的价格,则匹配并执行这两笔订单,并将销售订单 `sell` 从积压订单中删除。否则,采购订单 `buy` 将会添加到积压订单中。\n* 反之亦然,如果该订单是一笔销售订单 `sell`,则可以查看积压订单中价格 **最高** 的采购订单 `buy`。如果该采购订单 `buy` 的价格 **高于或等于** 当前销售订单 `sell` 的价格,则匹配并执行这两笔订单,并将采购订单 `buy` 从积压订单中删除。否则,销售订单 `sell` 将会添加到积压订单中。\n\n输入所有订单后,返回积压订单中的订单总数。\n\n由于数字可能很大,所以需要返回对 $10^9 + 7$ 取余的结果。\n\n示例 1:\n\n```\n输入:orders = [[10,5,0],[15,2,1],[25,1,1],[30,4,0]]\n\n输出:6\n\n解释:输入订单后会发生下述情况:\n- 提交 5 笔采购订单,价格为 10 。没有销售订单,所以这 5 笔订单添加到积压订单中。\n- 提交 2 笔销售订单,价格为 15 。没有采购订单的价格大于或等于 15 ,所以这 2 笔订单添加到积压订单中。\n- 提交 1 笔销售订单,价格为 25 。没有采购订单的价格大于或等于 25 ,所以这 1 笔订单添加到积压订单中。\n- 提交 4 笔采购订单,价格为 30 。前 2 笔采购订单与价格最低(价格为 15)的 2 笔销售订单匹配,从积压订单中删除这 2 笔销售订单。第 3 笔采购订单与价格最低的 1 笔销售订单匹配,销售订单价格为 25 ,从积压订单中删除这 1 笔销售订单。积压订单中不存在更多销售订单,所以第 4 笔采购订单需要添加到积压订单中。\n最终,积压订单中有 5 笔价格为 10 的采购订单,和 1 笔价格为 30 的采购订单。所以积压订单中的订单总数为 6 。\n```\n示例 2:\n\n```\n输入:orders = [[7,1000000000,1],[15,3,0],[5,999999995,0],[5,1,1]]\n\n输出:999999984\n\n解释:输入订单后会发生下述情况:\n- 提交 109 笔销售订单,价格为 7 。没有采购订单,所以这 109 笔订单添加到积压订单中。\n- 提交 3 笔采购订单,价格为 15 。这些采购订单与价格最低(价格为 7 )的 3 笔销售订单匹配,从积压订单中删除这 3 笔销售订单。\n- 提交 999999995 笔采购订单,价格为 5 。销售订单的最低价为 7 ,所以这 999999995 笔订单添加到积压订单中。\n- 提交 1 笔销售订单,价格为 5 。这笔销售订单与价格最高(价格为 5 )的 1 笔采购订单匹配,从积压订单中删除这 1 笔采购订单。\n最终,积压订单中有 (1000000000-3) 笔价格为 7 的销售订单,和 (999999995-1) 笔价格为 5 的采购订单。所以积压订单中的订单总数为 1999999991 ,等于 999999984 % (109 + 7) 。\n```\n\n提示:\n* $1 <= orders.length <= 10^5$\n* $orders[i].length == 3$\n* $1 <= pricei, amounti <= 10^9$\n* `orderTypei` 为 $0$ 或 $1$", "solution": "### 模拟 + 数据结构\n\n整理题意:从前往后处理所有的 $orders[i]$,对于 `buy` 类型的订单,从积压订单中找价格低于等于当前价格的 `sell` 订单进行抵消;同理,对于 `sell` 类型的订单,从积压订单中找价格高于等于当前价格的 `buy` 订单进行抵消。问最终有多少积压订单。\n\n这个找「最低/最高」价格的操作可以利用优先队列(堆)来做,对于积压的 `buy` 类型订单,我们总是要找价格高的,使用大根堆维护;对于积压的 `sell` 类型订单,我们总是要找价格低的,使用小根堆维护。\n\n两个优先队列(堆)均维护形如 $(price_i, amount_i)$ 的二元组信息,代表价格为 $price_i$ 的订单积压了 $amount_i$ 单。\n\n当处理(尝试匹配)了所有的 $orders[i]$ 之后,统计两个优先队列(堆)中订单数量即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int getNumberOfBacklogOrders(int[][] orders) {\n        PriorityQueue<int[]> buy = new PriorityQueue<>((a,b)->b[0]-a[0]), sell = new PriorityQueue<>((a,b)->a[0]-b[0]);\n        PriorityQueue<int[]> from = null, to = null;\n        boolean fromIsSell = false;\n        for (int[] order : orders) {\n            int p = order[0], a = order[1], t = order[2];\n            if (t == 0) {\n                from = sell; to = buy; fromIsSell = true;\n            } else {\n                from = buy; to = sell; fromIsSell = false;\n            }\n            while (a > 0 && !from.isEmpty() && (fromIsSell ? from.peek()[0] <= p : from.peek()[0] >= p)) {\n                int[] cur = from.poll();\n                int cnt = Math.min(cur[1], a);\n                cur[1] -= cnt; a -= cnt;\n                if (cur[1] > 0) from.add(cur);\n            }\n            if (a > 0) to.add(new int[]{p, a});\n        }\n        int ans = 0;\n        for (PriorityQueue<int[]> q : new PriorityQueue[]{buy, sell}) {\n            while (!q.isEmpty()) {\n                ans += q.poll()[1];\n                ans %= (int)1e9+7;\n            }\n        }\n        return ans;\n    }\n}\n```\n\n-\n\n```Python\nclass Solution:\n    def getNumberOfBacklogOrders(self, orders: List[List[int]]) -> int:\n        buy, sell = [], []\n        for p, a, t in orders:\n            if t == 0:\n                from_heap, to_heap, from_is_sell = sell, buy, True\n            else:\n                from_heap, to_heap, from_is_sell = buy, sell, False\n            while a and from_heap and (from_heap[0][0] <= p if from_is_sell else -from_heap[0][0] >= p):\n                cur = heapq.heappop(from_heap)\n                if cur[1] > a:\n                    heapq.heappush(from_heap, (cur[0], cur[1] - a))\n                    a = 0\n                else:\n                    a -= cur[1]\n            if a:\n                heapq.heappush(to_heap, (-p if from_is_sell else p, a))\n        ans, mod = 0, int(1e9)+7\n        for _, a in buy + sell:\n            ans += a\n        return ans % mod\n\n```\n* 时间复杂度:令$n$ 为数组 `orders` 的长度,复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1801` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1801-1810/1802. 有界数组中指定下标处的最大值（中等）.md", "url_title": "1802. 有界数组中指定下标处的最大值", "url": "https://leetcode.cn/problems/maximum-value-at-a-given-index-in-a-bounded-array/solutions/2363016/gong-shui-san-xie-chang-gui-zong-he-ti-b-ohvx/", "difficulty": "中等", "tags": ["二分", "数学", "构造", "贪心", "模拟"], "question": "给你三个正整数 `n`、`index` 和 `maxSum`。\n\n你需要构造一个同时满足下述所有条件的数组 `nums`(下标 从 `0` 开始 计数):\n\n* `nums.length == n`\n* `nums[i]` 是 正整数 ,其中 `0 <= i < n`\n* `abs(nums[i] - nums[i+1]) <= 1` ,其中 `0 <= i < n-1`\n* `nums` 中所有元素之和不超过 `maxSum`\n* `nums[index]` 的值被 最大化\n* 返回你所构造的数组中的 `nums[index]`\n\n注意:`abs(x)` 等于 `x` 的前提是 `x >= 0`;否则,`abs(x)` 等于 `-x`。\n\n示例 1:\n```\n输入:n = 4, index = 2,  maxSum = 6\n\n输出:2\n\n解释:数组 [1,1,2,1] 和 [1,2,2,1] 满足所有条件。不存在其他在指定下标处具有更大值的有效数组。\n```\n示例 2:\n```\n输入:n = 6, index = 1,  maxSum = 10\n\n输出:3\n```\n\n提示:\n* $1 <= n <= maxSum <= 10^9$\n* $0 <= index < n$", "solution": "### 二分 + 贪心 + 数学\n\n根据题意,容易想到以 `ans` 为分割点的正整数数组具有二段性,其中 `ans` 为最大的 $nums[idx]$。\n\n小于等于 `ans` 的值均能通过直接调整 $nums[idx]$ 来构造,不会违反总和不超过 `max` 的限制;大于 `ans` 的值则无法满足 `max` 限制。基于此我们可通过「二分」的方式来找分割点。\n\n假设当前二分到的值为 `x`,考虑如何实现一个 `check` 函数,该函数用于判断 `x` 能否作为 $nums[idx]$:\n\n为了令 $nums[idx] = x$ 时,数组总和 `sum` 不超过 `max` 限制,我们应当贪心构造 $nums$ 的剩余元素:从 $idx$ 开始往两侧构造,按照递减的方式进行逐个构造,若递减到 $1$ 则维持不变。\n\n这样可确保构造出来的 $nums$ 既满足 $nums[idx] = x$ 同时元素总和最小。\n\n位置 `idx` 的值为 `x`,其左边有 `idx` 个元素,其右边有 `n - idx - 1` 个元素。\n\n利用「等差数列求和」公式分别从 `x - 1` 开始构造(注意:这里说的构造仅是计算 $nums$ 总和),若总和不超过 `max` 说明 $nums[idx] = x$ 满足要求,我们令 $l = mid$,否则令 $r = mid - 1$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxValue(int n, int index, int max) {\n        long l = 1, r = max;\n        while (l < r) {\n            long mid = l + r + 1 >> 1;\n            if (check(n, mid, index, max)) l = mid;\n            else r = mid - 1;\n        }\n        return (int) r;\n    }\n    boolean check(int n, long x, int idx, int max) {\n        long sum = x;\n        if (idx > x - 1) {\n            long an = x - 1, a1 = 1, cnt = x - 1;\n            sum += cnt * (a1 + an) / 2;\n            sum += idx - cnt;\n        } else {\n            long cnt = idx, an = x - 1, a1 = an - cnt + 1;\n            sum += cnt * (a1 + an) / 2;\n        }\n        if (n - idx - 1 > x - 1) {\n            long an = x - 1, a1 = 1, cnt = x - 1;\n            sum += cnt * (a1 + an) / 2;\n            sum += n - idx - 1 - cnt;\n        } else {\n            long cnt = n - idx - 1, an = x - 1, a1 = an - cnt + 1;\n            sum += cnt * (a1 + an) / 2;\n        }\n        return sum <= max;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxValue(int n, int index, int maxSum) {\n        long l = 1, r = maxSum;\n        while (l < r) {\n            long mid = (l + r + 1) >> 1;\n            if (check(n, mid, index, maxSum)) l = mid;\n            else r = mid - 1;\n        }\n        return (int) r;\n    }\n    bool check(int n, long x, int idx, int maxSum) {\n        long sum = x;\n        if (idx > x - 1) {\n            long an = x - 1, a1 = 1, cnt = x - 1;\n            sum += cnt * (a1 + an) / 2;\n            sum += idx - cnt;\n        } else {\n            long cnt = idx, an = x - 1, a1 = an - cnt + 1;\n            sum += cnt * (a1 + an) / 2;\n        }\n        if (n - idx - 1 > x - 1) {\n            long an = x - 1, a1 = 1, cnt = x - 1;\n            sum += cnt * (a1 + an) / 2;\n            sum += n - idx - 1 - cnt;\n        } else {\n            long cnt = n - idx - 1, an = x - 1, a1 = an - cnt + 1;\n            sum += cnt * (a1 + an) / 2;\n        }\n        return sum <= maxSum;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxValue(self, n: int, index: int, maxSum: int) -> int:\n        l, r = 1, maxSum\n        while l < r:\n            mid = (l + r + 1) >> 1\n            if self.check(n, mid, index, maxSum): \n                l = mid\n            else: \n                r = mid - 1\n        return int(r)\n\n    def check(self, n, x, idx, maxSum):\n        sumv = x\n        if idx > x - 1:\n            an, a1, cnt = x - 1, 1, x - 1\n            sumv += cnt * (a1 + an) // 2\n            sumv += idx - cnt\n        else:\n            cnt, an, a1 = idx, x - 1, x - idx\n            sumv += cnt * (a1 + an) // 2\n        if n - idx - 1 > x - 1:\n            an, a1, cnt = x - 1, 1, x - 1\n            sumv += cnt * (a1 + an) // 2\n            sumv += n - idx - 1 - cnt\n        else:\n            cnt, an, a1 = n - idx - 1, x - 1, x - n + idx + 1\n            sumv += cnt * (a1 + an) // 2\n        return sumv <= maxSum\n```\nTypeScript 代码:\n```TypeScript\nfunction maxValue(n: number, index: number, maxSum: number): number {\n    const check = function(n: number, x: number, idx: number, maxSum: number): boolean {\n        let sum = x;\n        if (idx > x - 1) {\n            let an = x - 1, a1 = 1, cnt = x - 1;\n            sum += cnt * (a1 + an) / 2;\n            sum += idx - cnt;\n        } else {\n            let cnt = idx, an = x - 1, a1 = an - cnt + 1;\n            sum += cnt * (a1 + an) / 2;\n        }\n        if (n - idx - 1 > x - 1) {\n            let an = x - 1, a1 = 1, cnt = x - 1;\n            sum += cnt * (a1 + an) / 2;\n            sum += n - idx - 1 - cnt;\n        } else {\n            let cnt = n - idx - 1, an = x - 1, a1 = an - cnt + 1;\n            sum += cnt * (a1 + an) / 2;\n        }\n        return sum <= maxSum;\n    };\n    let l = 1, r = maxSum;\n    while (l < r) {\n        let mid = (l + r + 1) >> 1;\n        if (check(n, mid, index, maxSum)) l = mid;\n        else r = mid - 1;\n    }\n    return r;\n};\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1802` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/181-190/187. 重复的DNA序列（中等）.md", "url_title": "187. 重复的DNA序列", "url": "https://leetcode-cn.com/problems/repeated-dna-sequences/solution/gong-shui-san-xie-yi-ti-shuang-jie-hua-d-30pg/", "difficulty": "中等", "tags": ["滑动窗口", "哈希表", "字符串哈希", "前缀和"], "question": "所有 DNA 都由一系列缩写为 `'A'`,`'C'`,`'G'` 和 `'T'` 的核苷酸组成,例如:`\"ACGAATTCCG\"`。在研究 DNA 时,识别 DNA 中的重复序列有时会对研究非常有帮助。\n\n编写一个函数来找出所有目标子串,目标子串的长度为 $10$,且在 DNA 字符串 `s` 中出现次数超过一次。\n\n示例 1:\n```\n输入:s = \"AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT\"\n\n输出:[\"AAAAACCCCC\",\"CCCCCAAAAA\"]\n```\n示例 2:\n```\n输入:s = \"AAAAAAAAAAAAA\"\n\n输出:[\"AAAAAAAAAA\"]\n```\n\n提示:\n* 0 <= s.length <= $10^5$\n* `s[i]` 为 `'A'`、`'C'`、`'G'` 或 `'T'`", "solution": "### 滑动窗口 + 哈希表\n\n数据范围只有 $10^5$,一个朴素的想法是:从左到右处理字符串 $s$,使用滑动窗口得到每个以 $s[i]$ 为结尾且长度为 $10$ 的子串,同时使用哈希表记录每个子串的出现次数,如果该子串出现次数超过一次,则加入答案。\n\n为了防止相同的子串被重复添加到答案,而又不使用常数较大的 `Set` 结构。我们可以规定:当且仅当该子串在之前出现过一次(加上本次,当前出现次数为两次)时,将子串加入答案。\n\n代码:\n```Java\nclass Solution {\n    public List<String> findRepeatedDnaSequences(String s) {\n        List<String> ans = new ArrayList<>();\n        int n = s.length();\n        Map<String, Integer> map = new HashMap<>();\n        for (int i = 0; i + 10 <= n; i++) {\n            String cur = s.substring(i, i + 10);\n            int cnt = map.getOrDefault(cur, 0);\n            if (cnt == 1) ans.add(cur);\n            map.put(cur, cnt + 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:每次检查以 $s[i]$ 为结尾的子串,需要构造出新的且长度为 $10$ 的字符串。令 $C = 10$,复杂度为 $O(n * C)$\n* 空间复杂度:长度固定的子串数量不会超过 $n$ 个。复杂度为 $O(n)$\n\n---\n\n### 字符串哈希 + 前缀和\n\n子串长度为 $10$,因此上述解法的计算量为 $10^6$。\n\n若题目给定的子串长度大于 $100$ 时,加上生成子串和哈希表本身常数操作,那么计算量将超过 $10^7$,会 TLE。\n\n因此一个能够做到严格 $O(n)$ 的做法是使用「字符串哈希 + 前缀和」。\n\n具体做法为,我们使用一个与字符串 $s$ 等长的哈希数组 $h[]$,以及次方数组 $p[]$。\n\n由字符串预处理得到这样的哈希数组和次方数组复杂度为 $O(n)$。当我们需要计算子串 $s[i...j]$ 的哈希值,只需要利用前缀和思想 $h[j] - h[i - 1] * p[j - i + 1]$ 即可在 $O(1)$ 时间内得出哈希值(与子串长度无关)。\n\n**到这里,还有一个小小的细节需要注意:如果我们期望做到严格 $O(n)$,进行计数的「哈希表」就不能是以 `String` 作为 `key`,只能使用 `Integer`(也就是 hash 结果本身)作为 `key`。因为 Java 中的 `String` 的 `hashCode` 实现是会对字符串进行遍历的,这样哈希计数过程仍与长度有关,而 `Integer` 的 `hashCode` 就是该值本身,这是与长度无关的。**\n\n代码:\n```Java\nclass Solution {\n    int N = (int)1e5+10, P = 131313;\n    int[] h = new int[N], p = new int[N];\n    public List<String> findRepeatedDnaSequences(String s) {\n        int n = s.length();\n        List<String> ans = new ArrayList<>();\n        p[0] = 1;\n        for (int i = 1; i <= n; i++) {\n            h[i] = h[i - 1] * P + s.charAt(i - 1);\n            p[i] = p[i - 1] * P;\n        }\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = 1; i + 10 - 1 <= n; i++) {\n            int j = i + 10 - 1;\n            int hash = h[j] - h[i - 1] * p[j - i + 1];\n            int cnt = map.getOrDefault(hash, 0);\n            if (cnt == 1) ans.add(s.substring(i - 1, i + 10 - 1));\n            map.put(hash, cnt + 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 我猜你问\n\n1. 字符串哈希的「构造 $p$ 数组」和「计算哈希」的过程,不会溢出吗?\n\n会溢出,溢出就会变为负数,当且仅当两个哈希值溢出程度与 `Integer.MAX_VALUE` 呈不同的倍数关系时,会产生错误结果(哈希冲突),此时考虑修改 $P$ 或者采用表示范围更大的 `long` 来代替 `int`。\n\n2. $P = 131313$ 这个数字是怎么来的?\n\nWA 出来的,刚开始使用的 $P = 131$,被卡在了 $30/31$ 个样例。\n\n字符串哈希本身存在哈希冲突的可能,一般会在尝试 $131$ 之后尝试使用 $13131$,然后再尝试使用比 $13131$ 更大的质数。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.187` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。\n\n```\n\n```"}
{"file_path": "LeetCode/181-190/190. 颠倒二进制位（简单）.md", "url_title": "190. 颠倒二进制位", "url": "https://leetcode-cn.com/problems/reverse-bits/solution/yi-ti-san-jie-dui-cheng-wei-zhu-wei-fen-ub1hi/", "difficulty": "简单", "tags": ["位运算", "模拟"], "question": "颠倒给定的 32 位无符号整数的二进制位。\n\n提示:\n\n* 请注意,在某些语言(如 Java)中,没有无符号整数类型。在这种情况下,输入和输出都将被指定为有符号整数类型,并且不应影响您的实现,因为无论整数是有符号的还是无符号的,其内部的二进制表示形式都是相同的。\n* 在 Java 中,编译器使用二进制补码记法来表示有符号整数。因此,在上面的 示例 2 中,输入表示有符号整数 -3,输出表示有符号整数 -1073741825。\n\n进阶:\n* 如果多次调用这个函数,你将如何优化你的算法?\n\n示例 1:\n```\n输入: 00000010100101000001111010011100\n\n输出: 00111001011110000010100101000000\n\n解释: 输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596,\n     因此返回 964176192,其二进制表示形式为 00111001011110000010100101000000。\n```\n示例 2:\n```\n输入:11111111111111111111111111111101\n输出:10111111111111111111111111111111\n解释:输入的二进制串 11111111111111111111111111111101 表示无符号整数 4294967293,\n     因此返回 3221225471 其二进制表示形式为 10111111111111111111111111111111 。\n```\n\n提示:\n* 输入是一个长度为 32 的二进制字符串", "solution": "### 「对称位」构造\n\n一个简单的做法是对输入的 $n$ 做诸位检查。\n\n**如果某一位是 1 的话,则将答案相应的对称位置修改为 1。**\n\n代码:\n```Java\npublic class Solution {\n    public int reverseBits(int n) {\n        int ans = 0;\n        for (int i = 0; i < 32; i++) {\n            int t = (n >> i) & 1;\n            if (t == 1) {\n                ans |= (1 << (31 - i));\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$int$ 固定 32 位,循环次数不随输入样本发生改变。复杂度为 $O(1)$\n* 空间复杂度:$O(1)$\n\n***\n\n### 「逐位分离」构造\n\n另外一种做法是,每次都使用 $n$ 的最低一位,使用 $n$ 的最低一位去更新答案的最低一位,使用完将 $n$ 进行右移一位,将答案左移一位。\n\n**相当于每次都用 $n$ 的最低一位更新成 $ans$ 的最低一位。**\n\n代码:\n```Java\npublic class Solution {\n    public int reverseBits(int n) {\n        int ans = 0;\n        int cnt = 32;\n        while (cnt-- > 0) {\n            ans <<= 1;\n            ans += (n & 1);\n            n >>= 1;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$int$ 固定 32 位,循环次数不随输入样本发生改变。复杂度为 $O(1)$\n* 空间复杂度:$O(1)$\n\n***\n\n### 「分组互换」\n\n事实上,可以对于长度固定的 $int$ 类型,我们可以使用「分组构造」的方式进行。\n\n**两位互换 -> 四位互换 -> 八位互换 -> 十六位互换。**\n\n代码:\n```Java\npublic class Solution {\n    public int reverseBits(int n) {\n        n = ((n & 0xAAAAAAAA) >>> 1)  | ((n & 0x55555555) << 1);\n        n = ((n & 0xCCCCCCCC) >>> 2)  | ((n & 0x33333333) << 2);\n        n = ((n & 0xF0F0F0F0) >>> 4)  | ((n & 0x0F0F0F0F) << 4);\n        n = ((n & 0xFF00FF00) >>> 8)  | ((n & 0x00FF00FF) << 8);\n        n = ((n & 0xFFFF0000) >>> 16) | ((n & 0x0000FFFF) << 16);\n        return n;\n    }\n}\n```\n* 时间复杂度:如何进行互换操作取决于 $int$ 长度。复杂度为 $O(1)$\n* 空间复杂度:$O(1)$\n\n**PS. 类似的做法我在 [191. 位1的个数](https://leetcode-cn.com/problems/number-of-1-bits/solution/yi-ti-san-jie-wei-shu-jian-cha-you-yi-to-av1r/) 也介绍过。如果大家学有余力的话,建议大家在纸上模拟一下这个过程。如果不想深入,也可以当成模板背过(写法非常固定)。**\n**但请不要认为「方法三」一定就比「方法一」等直接采用循环的方式更快。此类做法的最大作用,不是处理 int,而是处理更大位数的情况,在长度只有 32 位的 int 的情况下,该做法不一定就比循环要快(该做法会产生多个的中间结果,导致赋值发生多次,而且由于指令之间存在对 n 数值依赖,可能不会被优化为并行指令),这个道理和对于排序元素少的情况下,我们会选择「冒泡排序」而不是「归并排序」是一样的,因为「冒泡排序」常数更小。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.190` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。\n\n```\n\n```"}
{"file_path": "LeetCode/1811-1820/1816. 截断句子（简单）.md", "url_title": "1816. 截断句子", "url": "https://leetcode-cn.com/problems/truncate-sentence/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-l7gu/", "difficulty": "简单", "tags": ["模拟"], "question": "句子 是一个单词列表,列表中的单词之间用单个空格隔开,且不存在前导或尾随空格。\n\n每个单词仅由大小写英文字母组成(不含标点符号)。\n\n例如,`\"Hello World\"`、`\"HELLO\"` 和 `\"hello world hello world\"` 都是句子。\n给你一个句子 `s` 和一个整数 `k` ,请你将 `s` 截断 ,使截断后的句子仅含 前 `k` 个单词。返回 截断 `s` 后得到的句子。\n\n示例 1:\n```\n输入:s = \"Hello how are you Contestant\", k = 4\n\n输出:\"Hello how are you\"\n\n解释:\ns 中的单词为 [\"Hello\", \"how\" \"are\", \"you\", \"Contestant\"]\n前 4 个单词为 [\"Hello\", \"how\", \"are\", \"you\"]\n因此,应当返回 \"Hello how are you\"\n```\n示例 2:\n```\n输入:s = \"What is the solution to this problem\", k = 4\n\n输出:\"What is the solution\"\n\n解释:\ns 中的单词为 [\"What\", \"is\" \"the\", \"solution\", \"to\", \"this\", \"problem\"]\n前 4 个单词为 [\"What\", \"is\", \"the\", \"solution\"]\n因此,应当返回 \"What is the solution\"\n```\n示例 3:\n```\n输入:s = \"chopper is not a tanuki\", k = 5\n\n输出:\"chopper is not a tanuki\"\n```\n\n提示:\n* `1 <= s.length <= 500`\n* `k` 的取值范围是 `[1,  s 中单词的数目]`\n* `s` 仅由大小写英文字母和空格组成\n* `s` 中的单词之间由单个空格隔开\n* 不存在前导或尾随空格", "solution": "### 模拟\n\n根据题意进行模拟,在拼接答案时对「空格」进行计数即可。\n\n可通过 `StringBuilder` 实现拼接,也可以使用变量 `idx` 记录答案的结尾位置。\n\n代码:\n```Java\nclass Solution {\n    public String truncateSentence(String s, int k) {\n        StringBuilder sb = new StringBuilder();\n        int n = s.length();\n        for (int i = 0, cnt = 0; i < n && cnt < k; i++) {\n            char c = s.charAt(i);\n            if (c == ' ') cnt++;\n            if (cnt < k) sb.append(c);\n        }\n        return sb.toString();\n    }\n}\n```\n\n```Java\nclass Solution {\n    public String truncateSentence(String s, int k) {\n        int n = s.length(), idx = 0;\n        while (idx < n) {\n            if (s.charAt(idx) == ' ' && --k == 0) break;\n            idx++;\n        }\n        return s.substring(0, idx);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1816` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1811-1820/1818. 绝对差值和（中等）.md", "url_title": "1818. 绝对差值和", "url": "https://leetcode-cn.com/problems/minimum-absolute-sum-difference/solution/gong-shui-san-xie-tong-guo-er-fen-zhao-z-vrmq/", "difficulty": "中等", "tags": ["二分"], "question": "给你两个正整数数组 `nums1` 和 `nums2` ,数组的长度都是 `n` 。\n\n数组 `nums1` 和 `nums2` 的 **绝对差值和** 定义为所有 `|nums1[i] - nums2[i]|(0 <= i < n)`的 总和(下标从 $0$ 开始)。\n\n你可以选用 `nums1` 中的 **任意一个** 元素来替换 `nums1` 中的 **至多** 一个元素,以 **最小化** 绝对差值和。\n\n在替换数组 `nums1` 中最多一个元素 之后 ,返回最小绝对差值和。因为答案可能很大,所以需要对 $10^9 + 7$ 取余 后返回。\n\n`|x|` 定义为:\n\n* 如果 $x >= 0$,值为 `x` ,或者\n* 如果 $x <= 0$,值为 `-x`\n\n示例 1:\n\n```\n输入:nums1 = [1,7,5], nums2 = [2,3,5]\n\n输出:3\n\n解释:有两种可能的最优方案:\n- 将第二个元素替换为第一个元素:[1,7,5] => [1,1,5] ,或者\n- 将第二个元素替换为第三个元素:[1,7,5] => [1,5,5]\n两种方案的绝对差值和都是 |1-2| + (|1-3| 或者 |5-3|) + |5-5| = 3\n```\n示例 2:\n```\n输入:nums1 = [2,4,6,8,10], nums2 = [2,4,6,8,10]\n\n输出:0\n\n解释:nums1 和 nums2 相等,所以不用替换元素。绝对差值和为 0\n```\n示例 3:\n```\n输入:nums1 = [1,10,4,4,2,7], nums2 = [9,3,5,1,7,4]\n\n输出:20\n\n解释:将第一个元素替换为第二个元素:[1,10,4,4,2,7] => [10,10,4,4,2,7]\n绝对差值和为 |10-9| + |10-3| + |4-5| + |4-1| + |2-7| + |7-4| = 20\n```\n\n提示:\n* $n == nums1.length$\n* $n == nums2.length$\n* $1 <= n <= 10^5$\n* $1 <= nums1[i], nums2[i] <= $10^5$", "solution": "### 二分\n\n这是一道二分陈题,具体做法如下:\n\n我们在进行处理前,先对 $nums1$ 进行拷贝并排序,得到 $sorted$ 数组。\n\n然后 **在遍历 $nums1$ 和 $nums2$ 计算总的差值 $sum$ 时,通过对 $sorted$ 进行二分查找,找到最合适替换 $nums[i]$ 的值**。\n\n具体的,当我们处理到第 $i$ 位时,假设该位的原差值为 $x = abs(nums1[i] - nums2[i])$,然后从 $sorted$ 数组中通过二分找到最接近 $nums2[i]$ 的值,计算一个新的差值 $nd$(注意要检查分割点与分割点的下一位),如果满足 $nd < x$ 说明存在一个替换方案使得差值变小,我们使用变量 $max$ 记下来这个替换方案所带来的变化,并不断更新 $max$。\n\n当整个数组被处理完,$max$ 存储着最优方案对应的差值变化,此时 $sum - max$ 即是答案。\n\n代码:\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int minAbsoluteSumDiff(int[] nums1, int[] nums2) {\n        int n = nums1.length;\n        int[] sorted = nums1.clone();\n        Arrays.sort(sorted);\n        long sum = 0, max = 0;\n        for (int i = 0; i < n; i++) {\n            int a = nums1[i], b = nums2[i];\n            if (a == b) continue;\n            int x = Math.abs(a - b);\n            sum += x;\n            int l = 0, r = n - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (sorted[mid] <= b) l = mid;\n                else r = mid - 1;\n            }\n            int nd = Math.abs(sorted[r] - b);\n            if (r + 1 < n) nd = Math.min(nd, Math.abs(sorted[r + 1] - b));\n            if (nd < x) max = Math.max(max, x - nd);\n        }\n        return (int)((sum - max) % mod);\n    }\n}\n```\n* 时间复杂度:对 `sorted` 进行拷贝并排序的复杂度为 $O(n\\log{n})$;遍历处理数组时会一边统计,一边尝试二分,找最合适的替换数值,复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:使用 `sorted` 数组需要 $O(n)$ 的空间复杂度,同时排序过程中会使用 $O(\\log{n})$ 的空间复杂度;整体复杂度为 $O(n + \\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1818` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1821-1830/1822. 数组元素积的符号（简单）.md", "url_title": "1822. 数组元素积的符号", "url": "https://leetcode.cn/problems/sign-of-the-product-of-an-array/solution/by-ac_oier-qy0n/", "difficulty": "简单", "tags": ["模拟"], "question": "已知函数 `signFunc(x)` 将会根据 `x` 的正负返回特定值:\n\n* 如果 `x` 是正数,返回 `1` 。\n* 如果 `x` 是负数,返回 `-1` 。\n* 如果 `x` 是等于 `0` ,返回 `0` 。\n\n给你一个整数数组 `nums`。令 `product` 为数组 `nums` 中所有元素值的乘积。\n\n返回 `signFunc(product)` 。\n\n示例 1:\n```\n输入:nums = [-1,-2,-3,-4,3,2,1]\n\n输出:1\n\n解释:数组中所有值的乘积是 144 ,且 signFunc(144) = 1\n```\n示例 2:\n```\n输入:nums = [1,5,0,2,-3]\n\n输出:0\n\n解释:数组中所有值的乘积是 0 ,且 signFunc(0) = 0\n```\n示例 3:\n```\n输入:nums = [-1,1,-1,1,-1]\n\n输出:-1\n\n解释:数组中所有值的乘积是 -1 ,且 signFunc(-1) = -1\n```\n\n提示:\n* $1 <= nums.length <= 1000$\n* $-100 <= nums[i] <= 100$", "solution": "### 模拟\n\n根据题意进行模拟。\n\nJava 代码:\n```Java\nclass Solution {\n    public int arraySign(int[] nums) {\n        int ans = 1;\n        for (int x : nums) {\n            if (x == 0) return 0;\n            if (x < 0) ans *= -1;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction arraySign(nums: number[]): number {\n    let ans = 0\n    for (const x of nums) {\n        if (x == 0) return 0\n        if (x < 0) ans *= -1\n    }\n    return ans\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def arraySign(self, nums: List[int]) -> int:\n        ans = 1\n        for x in nums:\n            if x == 0:\n                return 0\n            if x < 0:\n                ans *= -1\n        return ans\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1822s` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1821-1830/1823. 找出游戏的获胜者（中等）.md", "url_title": "1823. 找出游戏的获胜者", "url": "https://leetcode-cn.com/problems/find-the-winner-of-the-circular-game/solution/by-ac_oier-qsuq/", "difficulty": "中等", "tags": ["模拟", "约瑟夫环"], "question": "共有 $n$ 名小伙伴一起做游戏。小伙伴们围成一圈,按 顺时针顺序 从 $1$ 到 $n$ 编号。确切地说,从第 $i$ 名小伙伴顺时针移动一位会到达第 ($i+1$) 名小伙伴的位置,其中 $1 <= i < n$ ,从第 $n$ 名小伙伴顺时针移动一位会回到第 $1$ 名小伙伴的位置。\n\n游戏遵循如下规则:\n\n1. 从第 $1$ 名小伙伴所在位置 开始 。\n2. 沿着顺时针方向数 $k$ 名小伙伴,计数时需要 包含 起始时的那位小伙伴。逐个绕圈进行计数,一些小伙伴可能会被数过不止一次。\n3. 你数到的最后一名小伙伴需要离开圈子,并视作输掉游戏。\n4. 如果圈子中仍然有不止一名小伙伴,从刚刚输掉的小伙伴的 顺时针下一位 小伙伴 开始,回到步骤 2 继续执行。\n5. 否则,圈子中最后一名小伙伴赢得游戏。\n\n给你参与游戏的小伙伴总数 $n$ ,和一个整数 $k$ ,返回游戏的获胜者。\n\n示例 1:\n\n```\n输入:n = 5, k = 2\n\n输出:3\n\n解释:游戏运行步骤如下:\n1) 从小伙伴 1 开始。\n2) 顺时针数 2 名小伙伴,也就是小伙伴 1 和 2 。\n3) 小伙伴 2 离开圈子。下一次从小伙伴 3 开始。\n4) 顺时针数 2 名小伙伴,也就是小伙伴 3 和 4 。\n5) 小伙伴 4 离开圈子。下一次从小伙伴 5 开始。\n6) 顺时针数 2 名小伙伴,也就是小伙伴 5 和 1 。\n7) 小伙伴 1 离开圈子。下一次从小伙伴 3 开始。\n8) 顺时针数 2 名小伙伴,也就是小伙伴 3 和 5 。\n9) 小伙伴 5 离开圈子。只剩下小伙伴 3 。所以小伙伴 3 是游戏的获胜者。\n```\n示例 2:\n```\n输入:n = 6, k = 5\n\n输出:1\n\n解释:小伙伴离开圈子的顺序:5、4、6、2、3 。小伙伴 1 是游戏的获胜者。\n```\n\n提示:\n* $1 <= k <= n <= 500$", "solution": "### 模拟\n\n利用数据范围 $1 <= k <= n <= 500$,我们可以直接根据规则进行模拟。\n\n创建一个标记数组 $vis$,若有 $vis[idx] = true$ 则代表点编号为 $idx$ 已被淘汰,每次我们都从当前位置 $cur$ 开始,找到第 $k$ 个尚未淘汰的点($vis[idx] = false$),并将其进行标记($vis[idx] = true$),共有 $n - 1$ 个点需要被淘汰。\n\n一些细节,为了方便取模,我们调整点编号从 $1$ 开始,在返回答案时再重新调整为从 $1$ 开始。\n\n代码:\n```Java\nclass Solution {\n    public int findTheWinner(int n, int k) {\n        boolean[] vis = new boolean[n + 10];\n        int cnt = 0, cur = 0;\n        while (cnt != n - 1) {\n            for (int j = 0; j < k - 1; j++) {\n                cur++;\n                while (vis[cur % n]) cur++;\n            }\n            vis[cur % n] = true;\n            cnt++; cur++;\n            while (vis[cur % n]) cur++;\n        }\n        return (cur % n) + 1;\n    }\n}\n```\n* 时间复杂度:要消除(被标记)的点数量为 $n - 1$,每次找到要消除的点编号,最多遍历 $n$ 个点,复杂度为 $O(n^2)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 约瑟夫环\n\n这还是一道约瑟夫环经典题。\n\n> 另外一道同款题在 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247490948&idx=1&sn=a71c4ec3529277ad119702d7dacf510e&chksm=fd9cb69bcaeb3f8d5461518a15d969b45a13558a4c5810100f40200a12aac66f1876f2ef6de7&token=831443013&lang=zh_CN#rd) 🎉🎉\n\n每次往同一方向,以固定步长 $k$ 进行消数。由于下一次操作的发起点为消除位置的下一个点(即前后两次操作发起点在原序列下标中相差 $k$),同时问题规模会从 $n$ 变为 $n - 1$,因此原问题答案等价于 `findTheWinner(n - 1, k) + k`。\n\n一些细节,由于编号从 $1$ 开始,在返回答案时我们需要将结果为 $0$ 的值映射回编号 $n$。\n\n代码:\n```Java\nclass Solution {\n    public int findTheWinner(int n, int k) {\n        if (n <= 1) return n;\n        int ans = (findTheWinner(n - 1, k) + k) % n;\n        return ans == 0 ? n : ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1823` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1831-1840/1833. 雪糕的最大数量（中等）.md", "url_title": "1833. 雪糕的最大数量", "url": "https://leetcode-cn.com/problems/maximum-ice-cream-bars/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-yrhjx/", "difficulty": "中等", "tags": ["贪心", "排序"], "question": "夏日炎炎,小男孩 Tony 想买一些雪糕消消暑。\n\n商店中新到 `n` 支雪糕,用长度为 n 的数组 `costs` 表示雪糕的定价,其中 `costs[i]` 表示第 `i` 支雪糕的现金价格。\n\nTony 一共有 `coins` 现金可以用于消费,他想要买尽可能多的雪糕。\n\n给你价格数组 `costs` 和现金量 `coins`,请你计算并返回 Tony 用 `coins` 现金能够买到的雪糕的 最大数量 。\n\n注意:Tony 可以按任意顺序购买雪糕。\n\n示例 1:\n```\n输入:costs = [1,3,2,4,1], coins = 7\n\n输出:4\n\n解释:Tony 可以买下标为 0、1、2、4 的雪糕,总价为 1 + 3 + 2 + 1 = 7\n```\n示例 2:\n```\n输入:costs = [10,6,8,7,7,8], coins = 5\n\n输出:0\n\n解释:Tony 没有足够的钱买任何一支雪糕。\n```\n```\n示例 3:\n\n输入:costs = [1,6,3,1,2,5], \n\n输出:6\n\n解释:Tony 可以买下所有的雪糕,总价为 1 + 6 + 3 + 1 + 2 + 5 = 18 。\n```\n\n提示:\n* $costs.length = n$\n* $1 <= n <= 10^5$\n* $1 <= costs[i] <= 10^5$\n* $1 <= coins <= 10^8$", "solution": "### 基本分析\n\n从题面看,是一道「01 背包」问题,每个物品的成本为 $cost[i]$,价值为 $1$。\n\n但「01 背包」的复杂度为 $O(N\\times C)$,其中 $N$ 为物品数量(数量级为 $10^5$),$C$ 为背包容量(数量级为 $10^8$)。显然会 `TLE`。\n\n换个思路发现,每个被选择的物品对答案的贡献都是 $1$,优先选择价格小的物品会使得我们剩余金额尽可能的多,将来能够做的决策方案也就相应变多。\n\n因此一个直观的做法是,对物品数组进行「从小到大」排序,然后「从前往后」开始决策购买。\n\n---\n\n### 证明\n\n直观上,这样的贪心思路可以使得最终选择的物品数量最多。\n\n接下来证明一下该思路的正确性。\n\n假定贪心思路取得的序列为 $[a1,a2,a3,...,an]$(长度为 $n$),真实最优解所取得的序列为 $[b1,b2,b3,..,bm]$(长度为 $m$)。\n\n两个序列均为「单调递增序列」。\n\n其中最优解所对应具体方案不唯一,即存在多种选择方案使得物品数量相同。\n\n因此,**我们只需要证明两个序列长度一致即可**。\n\n按照贪心逻辑,最终选择的方案总成本不会超过 $coins$,因此至少是一个合法的选择方案,天然有 $n \\leq m$,只需要证明 $n \\geq m$ 成立,即可得证 $n = m$。\n\n通过反证法证明 $n \\geq m$ 成立,假设 $n \\geq m$ 不成立,即有 $n < m$。\n\n根据贪心决策,**我们选择的物品序列在「排序好的 $cost$ 数组」里,必然是一段连续的前缀。并且再选择下一物品将会超过总费用 $coins$;而真实最优解的选择方案在「排序好的 $cost$ 数组」里分布不定。**\n\n这时候我们可以利用「**每个物品对答案的贡献均为 $1$,将最优解中的分布靠后的物品,替换为分布较前的物品,不会使得费用增加,同时答案不会变差**」。\n\n从而将真实最优解也调整为某段连续的前缀。\n\n**综上,通过反证法得证 $n \\geq m$ 成立,结合 $n \\leq m$,可推出 $n = m$。**\n\n**即贪心解必然能够取得与最优解一样的长度。**\n\n---\n\n### 贪心\n\n排序,从前往后决策,直到不能决策为止。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxIceCream(int[] costs, int coins) {\n        int n = costs.length;\n        Arrays.sort(costs);\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            if (coins >= costs[i]) {\n                ans++; coins -= costs[i];\n            }\n        }\n        return ans;\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxIceCream(self, costs: List[int], coins: int) -> int:\n        costs.sort()\n        ans = 0\n        for i in range(len(costs)):\n            if coins >= costs[i]:\n                ans += 1\n                coins -= costs[i]\n        return ans\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxIceCream(vector<int>& costs, int coins) {\n        int n = costs.size();\n        sort(costs.begin(), costs.end());\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            if (coins >= costs[i]) {\n                ans++; coins -= costs[i];\n            }\n        }\n        return ans;\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nfunction maxIceCream(costs: number[], coins: number): number {\n    costs.sort((a, b) => a - b);\n    let ans = 0;\n    for (let i = 0; i < costs.length; i++) {\n        if (coins >= costs[i]) {\n            ans++; coins -= costs[i];\n        }\n    }\n    return ans;\n};\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$;获取答案的复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:排序复杂度为 $O(\\log{n})$。整体复杂度为 $O(\\log{n})$\n\nPS. 这里假定 `Arrays.sort` 使用的是「双轴排序」的实现。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1833` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1831-1840/1834. 单线程 CPU（中等）.md", "url_title": "1834. 单线程 CPU", "url": "https://leetcode-cn.com/problems/single-threaded-cpu/solution/gong-shui-san-xie-shu-ju-jie-gou-yun-yon-1qk0/", "difficulty": "中等", "tags": ["模拟", "排序", "优先队列(堆)"], "question": "给你一个二维数组 $tasks$,用于表示 $n$ 项从 $0$ 到 $n - 1$ 编号的任务。\n\n其中 $tasks[i] = [enqueueTime_i, processingTime_i]$ 意味着第 $i$ 项任务将会于 $enqueueTime_i$ 时进入任务队列,需要 $processingTime_i$ 的时长完成执行。\n\n现有一个单线程 CPU ,同一时间只能执行**最多一项**任务,该 CPU 将会按照下述方式运行:\n* 如果 CPU 空闲,且任务队列中没有需要执行的任务,则 CPU 保持空闲状态。\n* 如果 CPU 空闲,但任务队列中有需要执行的任务,则 CPU 将会选择 执行时间最短 的任务开始执行。如果多个任务具有同样的最短执行时间,则选择下标最小的任务开始执行。\n* 一旦某项任务开始执行,CPU 在 执行完整个任务 前都不会停止。\n* CPU 可以在完成一项任务后,立即开始执行一项新任务。\n\n返回 CPU 处理任务的顺序。\n\n示例 1:\n\n```\n输入:tasks = [[1,2],[2,4],[3,2],[4,1]]\n\n输出:[0,2,3,1]\n\n解释:事件按下述流程运行: \n- time = 1 ,任务 0 进入任务队列,可执行任务项 = {0}\n- 同样在 time = 1 ,空闲状态的 CPU 开始执行任务 0 ,可执行任务项 = {}\n- time = 2 ,任务 1 进入任务队列,可执行任务项 = {1}\n- time = 3 ,任务 2 进入任务队列,可执行任务项 = {1, 2}\n- 同样在 time = 3 ,CPU 完成任务 0 并开始执行队列中用时最短的任务 2 ,可执行任务项 = {1}\n- time = 4 ,任务 3 进入任务队列,可执行任务项 = {1, 3}\n- time = 5 ,CPU 完成任务 2 并开始执行队列中用时最短的任务 3 ,可执行任务项 = {1}\n- time = 6 ,CPU 完成任务 3 并开始执行任务 1 ,可执行任务项 = {}\n- time = 10 ,CPU 完成任务 1 并进入空闲状态\n```\n示例 2:\n```\n输入:tasks = [[7,10],[7,12],[7,5],[7,4],[7,2]]\n\n输出:[4,3,2,0,1]\n\n解释:事件按下述流程运行: \n- time = 7 ,所有任务同时进入任务队列,可执行任务项  = {0,1,2,3,4}\n- 同样在 time = 7 ,空闲状态的 CPU 开始执行任务 4 ,可执行任务项 = {0,1,2,3}\n- time = 9 ,CPU 完成任务 4 并开始执行任务 3 ,可执行任务项 = {0,1,2}\n- time = 13 ,CPU 完成任务 3 并开始执行任务 2 ,可执行任务项 = {0,1}\n- time = 18 ,CPU 完成任务 2 并开始执行任务 0 ,可执行任务项 = {1}\n- time = 28 ,CPU 完成任务 0 并开始执行任务 1 ,可执行任务项 = {}\n- time = 40 ,CPU 完成任务 1 并进入空闲状态\n```\n\n提示:\n* tasks.length == n\n* 1 <= n <= $10^5$\n* 1 <= $enqueueTime_i$, $processingTime_i$ <= $10^9$", "solution": "### 模拟 + 数据结构\n\n先将 $tasks$ 按照「入队时间」进行升序排序,同时为了防止任务编号丢失,排序前需要先将二元组的 $tasks$ 转存为三元组,新增记录的是原任务编号。\n\n然后可以按照「时间线」进行模拟:\n\n1. 起始令 $time$ 从 $1$ 开始进行递增,每次将到达「入队时间」的任务进行入队;\n\n2. 判断当前队列是否有可以执行的任务:\n   1. 如果没有,说明还没到达下一个入队任务的入队时间,直接将 $times$ 快进到下一个入队任务的入队时间;\n   2. 如果有,从队列中取出任务执行,同时由于是单线程执行,在该任务结束前,不会有新任务被执行,将 $times$ 快进到该任务的结束时间。\n\n代码:\n```Java\nclass Solution {\n    public int[] getOrder(int[][] ts) {\n        int n = ts.length;\n        // 将 ts 转存成 nts,保留任务编号\n        int[][] nts = new int[n][3];\n        for (int i = 0; i < n; i++) nts[i] = new int[]{ts[i][0], ts[i][1], i};\n        // 根据任务入队时间进行排序\n        Arrays.sort(nts, (a,b)->a[0]-b[0]);\n        // 根据题意,先按照「持续时间」排序,再根据「任务编号」排序\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->{\n            if (a[1] != b[1]) return a[1] - b[1];\n            return a[2] - b[2];\n        });\n        int[] ans = new int[n];\n        for (int time = 1, j = 0, idx = 0; idx < n; ) {\n        \t// 如果当前任务可以添加到「队列」中(满足入队时间)则进行入队\n            while (j < n && nts[j][0] <= time) q.add(nts[j++]);\n            if (q.isEmpty()) {\n\t            // 如果当前「队列」没有任务,直接跳到下个任务的入队时间\n                time = nts[j][0];\n            } else {\n            \t// 如果有可执行任务的话,根据优先级将任务出队(记录下标),并跳到该任务完成时间点\n                int[] cur = q.poll();\n                ans[idx++] = cur[2];\n                time += cur[1];\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:将 $ts$ 转存成 $nts$ 的复杂度为 $O(n)$;对 $nts$ 排序复杂度为 $O(n\\log{n})$;模拟时间线,将任务进行入队出队操作,并构造最终答案复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1834` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1831-1840/1838. 最高频元素的频数（中等）.md", "url_title": "1838. 最高频元素的频数", "url": "https://leetcode-cn.com/problems/frequency-of-the-most-frequent-element/solution/gong-shui-san-xie-cong-mei-ju-dao-pai-xu-kxnk/", "difficulty": "中等", "tags": ["枚举", "哈希表", "排序", "前缀和", "二分", "滑动窗口", "双指针"], "question": "元素的**频数**是该元素在一个数组中出现的次数。\n\n给你一个整数数组 $nums$ 和一个整数 $k$ 。\n\n在一步操作中,你可以选择 $nums$ 的一个下标,并将该下标对应元素的值增加 $1$ 。\n\n执行最多 $k$ 次操作后,返回数组中最高频元素的**最大可能频数**。\n\n示例 1:\n```\n输入:nums = [1,2,4], k = 5\n\n输出:3\n\n解释:对第一个元素执行 3 次递增操作,对第二个元素执 2 次递增操作,此时 nums = [4,4,4] 。\n4 是数组中最高频元素,频数是 3 。\n```\n示例 2:\n```\n输入:nums = [1,4,8,13], k = 5\n\n输出:2\n\n解释:存在多种最优解决方案:\n- 对第一个元素执行 3 次递增操作,此时 nums = [4,4,8,13] 。4 是数组中最高频元素,频数是 2 。\n- 对第二个元素执行 4 次递增操作,此时 nums = [1,8,8,13] 。8 是数组中最高频元素,频数是 2 。\n- 对第三个元素执行 5 次递增操作,此时 nums = [1,4,13,13] 。13 是数组中最高频元素,频数是 2 。\n```\n示例 3:\n```\n输入:nums = [3,9,6], k = 2\n\n输出:1\n```\n\n提示:\n* 1 <= nums.length <= $10^5$\n* 1 <= nums[i] <= $10^5$\n* 1 <= k <= $10^5$", "solution": "### 枚举\n\n一个朴素的做法是,先对原数组 $nums$ 进行排序,然后枚举最终「频数对应值」是哪个。\n\n利用每次操作只能对数进行加一,我们可以从「频数对应值」开始往回检查,从而得出在操作次数不超过 $k$ 的前提下,以某个值作为「频数对应值」最多能够凑成多少个。\n\n算法整体复杂度为 $O(n^2)$,Java 2021/07/19 可过。\n\n代码:\n```Java\nclass Solution {\n    public int maxFrequency(int[] nums, int k) {\n        int n = nums.length;\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i : nums) map.put(i, map.getOrDefault(i, 0) + 1);\n        List<Integer> list = new ArrayList<>(map.keySet());\n        Collections.sort(list);\n        int ans = 1;\n        for (int i = 0; i < list.size(); i++) {\n            int x = list.get(i), cnt = map.get(x);\n            if (i > 0) {\n                int p = k;\n                for (int j = i - 1; j >= 0; j--) {\n                    int y = list.get(j);\n                    int diff = x - y;\n                    if (p >= diff) {\n                        int add = p / diff;\n                        int min = Math.min(map.get(y), add);\n                        p -= min * diff;\n                        cnt += min;\n                    } else {\n                        break;\n                    }\n                }\n            }\n            ans = Math.max(ans, cnt);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:得到去重后的频数后选集合复杂度为 $O(n)$;最坏情况下去重后仍有 $n$ 个频数,且判断 $k$ 次操作内某个频数最多凑成多少复杂度为 $O(n)$。整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 排序 + 前缀和 + 二分 + 滑动窗口\n\n**先对原数组 $nums$ 进行从小到大排序,如果存在真实最优解 $len$,意味着至少存在一个大小为 $len$ 的区间 $[l, r]$,使得在操作次数不超过 $k$ 的前提下,区间 $[l, r]$ 的任意值 $nums[i]$ 的值调整为 $nums[r]$。**\n\n这引导我们利用「数组有序」&「前缀和」快速判断「某个区间 $[l, r]$ 是否可以在 $k$ 次操作内将所有值变为 $nums[r]$」:\n\n具体的,我们可以二分答案 $len$ 作为窗口长度,利用前缀和我们可以在 $O(1)$ 复杂度内计算任意区间的和,同时由于每次操作只能对数进行加一,即窗口内的所有数最终变为 $nums[r]$ ,最终目标区间和为 $nums[r] * len$,通过比较目标区间和和真实区间和的差值,我们可以知道 $k$ 次操作是否能将当前区间变为 $nums[r]$。\n\n上述判断某个值 $len$ 是否可行的 `check` 操作复杂度为 $O(n)$,因此算法复杂度为 $O(n\\log{n})$。\n\n代码:\n```Java\nclass Solution {\n    int[] nums, sum;\n    int n, k;\n    public int maxFrequency(int[] _nums, int _k) {\n        nums = _nums;\n        k = _k;\n        n = nums.length;\n        Arrays.sort(nums);\n        sum = new int[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n        int l = 0, r = n;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (check(mid)) l = mid;\n            else r = mid - 1;\n        }\n        return r;\n    }\n    boolean check(int len) {\n        for (int l = 0; l + len - 1 < n; l++) {\n            int r = l + len - 1;\n            int cur = sum[r + 1] - sum[l];\n            int t = nums[r] * len;\n            if (t - cur <= k) return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:排序的复杂度为 $O(n\\log{n})$;计算前缀和数组复杂度为 $O(n)$;`check` 函数的复杂度为 $O(n)$,因此二分复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1838` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1841-1850/1846. 减小和重新排列数组后的最大元素（中等）.md", "url_title": "1846. 减小和重新排列数组后的最大元素", "url": "https://leetcode-cn.com/problems/maximum-element-after-decreasing-and-rearranging/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-yh9qt/", "difficulty": "中等", "tags": ["贪心"], "question": "给你一个正整数数组 `arr`。请你对 `arr` 执行一些操作(也可以不进行任何操作),使得数组满足以下条件:\n* `arr` 中 第一个 元素必须为 $1$ 。\n* 任意相邻两个元素的差的绝对值 小于等于 $1$ ,也就是说,对于任意的 $1 <= i < arr.length$ (数组下标从 $0$ 开始),都满足 `abs(arr[i] - arr[i - 1]) <= 1`。`abs(x)` 为 `x` 的绝对值。\n\n你可以执行以下 $2$ 种操作任意次:\n* 减小 `arr` 中任意元素的值,使其变为一个 更小的正整数 。\n* 重新排列 `arr` 中的元素,你可以以任意顺序重新排列。\n\n请你返回执行以上操作后,在满足前文所述的条件下,`arr` 中可能的 最大值 。\n\n示例 1:\n```\n输入:arr = [2,2,1,2,1]\n\n输出:2\n\n解释:\n我们可以重新排列 arr 得到 [1,2,2,2,1] ,该数组满足所有条件。\narr 中最大元素为 2 。\n```\n示例 2:\n```\n输入:arr = [100,1,1000]\n\n输出:3\n\n解释:\n一个可行的方案如下:\n1. 重新排列 arr 得到 [1,100,1000] 。\n2. 将第二个元素减小为 2 。\n3. 将第三个元素减小为 3 。\n现在 arr = [1,2,3] ,满足所有条件。\narr 中最大元素为 3 。\n```\n示例 3:\n```\n输入:arr = [1,2,3,4,5]\n\n输出:5\n\n解释:数组已经满足所有条件,最大元素为 5 。\n```\n\n提示:\n* $1 <= arr.length <= 10^5$\n* $1 <= arr[i] <= 10^9$", "solution": "### 基本分析 & 证明\n\n根据题意,数组的第一位必须是 $1$,且每个数只能 **减小** 或 **不变**,数值位置可以任意调整。\n\n求解经过调整后,符合要求的数组中的最大值是多少。\n\n首先符合条件的数组相邻位差值绝对值不超过 $1$,这限定了数组的必然是如下三种分布之一:\n\n* (非严格)单调递减\n* 存在波段\n* (非严格)单调递增\n\n**证明一:取得最优解对应的数组「必然是」或者「可调整为」(非严格)单调递增的形式。**\n\n我们使用反证法来证明另外两种分布不能取得最优解:\n\n* (非严格)单调递减:题目限定了数的范围为正整数,且第一位为 $1$,这种情况不用讨论了,跳过;\n* 存在波段:我们始终可以将波峰的右侧出现的值,纳入到波峰的左侧,从而消掉这个波峰,最终将整个分布调整为「(非严格)单调递增」的形式,结果不会变差:\n\n多个波段的情况也是同理,可以自己在纸上画画。\n\n都是利用 **波峰右侧的点可以调整成波峰左侧的点,从而使分布变为(非严格)单调递增。**\n\n**至此,我们证明了最优解对应的数组必然符合(非严格)单调递增。**\n\n这启发我们可以先对原数组排个序,在此基础上进行分析。\n\n对原数组排序得到的有序数组,不一定是符合「相邻位差值绝对值不超过 $1$」的,同时由于每个数值可以选择 **减小** 或 **不变**。\n\n**证明二:当必须要对当前位进行调整的时,优先选择调整为「与前一值差值为 $1$ 的较大数」不会比调整为「与前一差值为 $0$ 的较小数」更差。**\n\n这可以使用归纳推理,假设采取「优先调整为与前一值差值为 $1$ 的较大数」得到的序列为 `a`,采用「优先调整与前一差值为 $0$ 的较小数」得到的序列为 `b`。\n\n**根据「$a[0] = b[0] = 1$」、「`a` 和 `b` 长度一致」、「`a` 和 `b` 均为(非严格)单调递增」以及「`a` 和 `b` 均满足相邻位差值不超过 $1$」,可推导出 $sum(a) >= sum(b)$,和任意位置 $a[i] >= b[i]$,从而推导出 `a` 序列的最后一位必然大于等于 `b` 的最后一位。**\n\n即 `b` 不会比 `a` 更优。\n\n**证明三:调整大小的操作不会改变数组元素之间的相对位置关系。**\n\n在证明二的分析中,我们会对某些元素进行“减小”操作,使得整个数组最终满足「相邻位差值绝对值不超过 $1$」。\n\n但该证明成立的还有一个很重要的前提条件,就是调整操作不会出发元素的位置重排。\n\n那么该前提条件是否必然成立呢?答案是必然成立。\n\n假设原排序数组中存在需要调整的点 $i$ 和点 $j$,且 $nums[i] <= nums[j]$。\n\n为了让数组满足条件,它们都进行了“减少”操作的调整,分别变为了 $p$ 和 $q$,如果触发位置重排的话,必然有 $nums[p] >= nums[q]$。\n\n此时,我们能够通过调整它们的变化关系:点 $i$ 变为点 $q$、点 $j$ 变成点 $p$ 来确保同样满足条件,且不触发元素在有序数组中的位置重排。\n\n---\n\n### 贪心\n\n排序,限定第一位值为 $1$,从前往后处理,根据每一位是否「必须修改(与上一位差值是否大于 $1$)」做决策,如果必须被修改,则修改为与前一值差值为 $1$ 的较大数。\n\n代码:\n```Java\nclass Solution {\n    public int maximumElementAfterDecrementingAndRearranging(int[] arr) {\n        int n = arr.length;\n        Arrays.sort(arr);\n        arr[0] = 1;\n        for (int i = 1; i < n; i++) {\n            if (arr[i] - arr[i - 1] > 1) {\n                arr[i] = arr[i - 1] + 1;\n            }\n        }\n        return arr[n - 1];\n    }\n}\n```\n* 时间复杂度:假定 `Arrays.sort` 使用的是双轴快排实现。复杂度为 $O(n\\log{n})$\n* 空间复杂度:假定 `Arrays.sort` 使用的是双轴快排实现。复杂度为 $O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1846` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1871-1880/1877. 数组中最大数对和的最小值（中等）.md", "url_title": "1877. 数组中最大数对和的最小值", "url": "https://leetcode-cn.com/problems/minimize-maximum-pair-sum-in-array/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-ru29y/", "difficulty": "中等", "tags": ["贪心"], "question": "一个数对 (a,b) 的 数对和 等于 a + b 。最大数对和 是一个数对数组中最大的 数对和 。\n\n比方说,如果我们有数对 (1,5) ,(2,3) 和 (4,4),最大数对和 为 max(1+5, 2+3, 4+4) = max(6, 5, 8) = 8 。\n给你一个长度为 偶数 n 的数组 nums ,请你将 nums 中的元素分成 n / 2 个数对,使得:\n\n* nums 中每个元素 恰好 在 一个 数对中,且\n* 最大数对和 的值 最小 。\n\n请你在最优数对划分的方案下,返回最小的 最大数对和 。\n\n示例 1:\n```\n输入:nums = [3,5,2,3]\n\n输出:7\n\n解释:数组中的元素可以分为数对 (3,3) 和 (5,2) 。\n最大数对和为 max(3+3, 5+2) = max(6, 7) = 7 。\n```\n示例 2:\n```\n输入:nums = [3,5,4,2,4,6]\n\n输出:8\n\n解释:数组中的元素可以分为数对 (3,5),(4,4) 和 (6,2) 。\n最大数对和为 max(3+5, 4+4, 6+2) = max(8, 8, 8) = 8 。\n```\n\n提示:\n* n == nums.length\n* 2 <= n <= $10^5$\n* n 是 偶数 。\n* 1 <= nums[i] <= $10^5$", "solution": "### 基本分析 & 证明\n\n直觉上,我们会认为「**尽量让“较小数”和“较大数”组成数对,可以有效避免出现“较大数成对”的现象**」。\n\n我们来证明一下该猜想是否成立。\n\n假定 $nums$ 本身有序,由于我们要将 $nums$ 拆分成 $n / 2$ 个数对,根据猜想,我们得到的数对序列为:\n$$\n(nums[0], nums[n - 1]), (nums[1], nums[n - 2]), ... , (nums[(n / 2) - 1], nums[n / 2])\n$$\n\n**换句话说,构成答案的数对必然是较小数取自有序序列的左边,较大数取自有序序列的右边,且与数组中心对称**。\n\n假设最大数对是 $(nums[i], nums[j])$,其中 $i < j$,记两者之和为 $ans = nums[i] + nums[j]$。\n\n反证法证明,不存在别的数对组合会比 $(nums[i], nums[j])$ 更优:\n\n假设存在数对 $(nums[p], nums[q])$ 与 $(nums[i], nums[j])$ 进行调整使答案更优。\n\n接下来分情况讨论:\n\n* 调整为 $(nums[i], nums[p])$ 和 $(nums[q], nums[j])$:此时最大数对答案为 $nums[q] + nums[j]$,显然 $nums[q] + nums[j] >= nums[i] + nums[j] = ans$。我们要最小化最大数对和,因此该调整方案不会让答案更好;\n* 调整为 $(nums[i], nums[q])$ 和 $(nums[p], nums[j])$:此时最大数对答案为 $\\max(nums[i] + nums[q], nums[p] + nums[j]) = nums[p] + nums[j] >= nums[i] + nums[j] = ans$。我们要最小化最大数对和,因此该调整方案不会让答案更好;\n\n**上述分析可以归纳推理到每一个“非对称”的数对配对中。**\n\n至此我们得证,将原本对称的数对调整为不对称的数对,不会使得答案更优,即贪心解可取得最优解。\n\n---\n\n### 贪心\n\n对原数组 $nums$ 进行排序,然后从一头一尾开始往中间组「数对」,取所有数对中的最大值即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int minPairSum(int[] nums) {\n        Arrays.sort(nums);\n        int n = nums.length;\n        int ans = nums[0] + nums[n - 1];\n        for (int i = 0, j = n - 1; i < j; i++, j--) {\n            ans = Math.max(ans, nums[i] + nums[j]);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$\n\n---\n\n### 答疑\n\n关于「证明」部分,不少小伙伴有一些疑问,觉得挺有代表性的,特意加到题解内。\n\nQ1. 「证明」部分是不是缺少了“非对称”得最优的情况?\n\nA1. 并没有,证明的基本思路如下:\n\n1. 猜想对称组数对的方式,会得到最优解;\n\n2. 证明非对称数组不会被对称数对方式更优。\n\n然后我们证明了“非对称方式”不会比“对称方式”更优,因此“对称方式”可以取得最优解。\n\n**至于非对称和非对称之间怎么调整,会更优还是更差,我不关心,也不需要证明,因为已经证明了非对称不会比对称更优。**\n\nQ2. 证明部分的图 $p$、$q$ 是在 $i$、$j$ 内部,那么其他 $p$、$q$、$i$、$j$ 大小关系的情况呢?\n\nA2. 有这个疑问,说明没有重点理解「证明」中的加粗部分(原话):\n\n> **上述分析可以归纳推理到每一个“非对称”的数对配对中。**\n\n也就是说,上述的分析是可以推广到每一步都成立的,包括第一步,当 $i$ 为排序数组的第一位原始,$j$ 为排序数组中最后一位时,任意 $p$ 和 $q$ 都是在 $i$、$j$ 内部的。\n\n**因此,「证明」对边界情况成立,同时对任意不成“对称”关系的数对也成立(其实也就是「证明」部分中的原话)。**\n\n**更大白话一点是:对于任意“非对称”的数对组合,将其调整为“对称”数对组合,结果不会变差。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1877` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1871-1880/1879. 两个数组最小的异或值之和（困难）.md", "url_title": "1879. 两个数组最小的异或值之和", "url": "https://leetcode.cn/problems/minimum-xor-sum-of-two-arrays/solutions/2402125/gong-shui-san-xie-yi-ti-shuang-jie-zhuan-iusv/", "difficulty": "困难", "tags": ["状压 DP", "动态规划", "启发式搜索"], "question": "给你两个整数数组 `nums1` 和 `nums2`,它们长度都为 `n`。\n\n两个数组的 异或值之和 为 `(nums1[0] XOR nums2[0]) + (nums1[1] XOR nums2[1]) + ... + (nums1[n - 1] XOR nums2[n - 1])` (下标从 `0` 开始)。\n\n比方说,`[1,2,3]` 和 `[3,2,1]` 的 异或值之和 等于 `(1 XOR 3) + (2 XOR 2) + (3 XOR 1) = 2 + 0 + 2 = 4`。\n\n请你将 `nums2` 中的元素重新排列,使得异或值之和最小 。\n\n请你返回重新排列之后的 异或值之和 。\n\n示例 1:\n```\n输入:nums1 = [1,2], nums2 = [2,3]\n\n输出:2\n\n解释:将 nums2 重新排列得到 [3,2] 。\n异或值之和为 (1 XOR 3) + (2 XOR 2) = 2 + 0 = 2 。\n```\n示例 2:\n```\n输入:nums1 = [1,0,3], nums2 = [5,3,4]\n\n输出:8\n\n解释:将 nums2 重新排列得到 [5,4,3] 。\n异或值之和为 (1 XOR 5) + (0 XOR 4) + (3 XOR 3) = 4 + 4 + 0 = 8 。\n```\n\n提示:\n* $n = nums1.length$\n* $n == nums2.length$\n* $1 <= n <= 14$\n* $0 <= nums1[i], nums2[i] <= 10^7$", "solution": "### 状压 DP\n\n这是一道「状压 DP」模板题。\n\n为了方便,我们令下标从 $1$ 开始。\n\n**定义 $f[i][s]$ 为考虑前 $i$ 个元素,且对 `nums2` 的使用情况为 $s$ 时的最小异或值**。其中 $s$ 是一个长度为 $n$ 的二进制数:若 $s$ 中的第 $k$ 位为 $1$,说明 `nums2[k]` 已被使用;若 $s$ 中的第 $k$ 位为 $0$,说明 `nums2[k]` 未被使用。\n\n起始时,只有 $f[0][0] = 0$,其余均为无穷大 `INF`。$f[0][0]$ 含义为在不考虑任何数,对 `nums2` 没有任何占用情况时,最小异或值为 $0$。最终 $f[n][2^n - 1]$ 即为答案。\n\n不失一般性考虑 $f[i][s]$ 该如何转移,可以以 `nums1[i]` 是与哪个 `nums2[j]` 进行配对作为切入点:\n\n* 由于总共考虑了前 $i$ 个成员,因此 $s$ 中 $1$ 的数量必然为 $i$,否则 $f[i][s]$ 就不是一个合法状态,跳过转移\n\n* 枚举 `nums1[i]` 是与哪一个 `nums2[j]` 进行配对的,且枚举的 $j$ 需满足在 $s$ 中的第 $j$ 位值为 $1$,若满足则有 \n\n$$\nf[i][s] = \\min(f[i][s], f[i - 1][prev] + nums1[i] ⊕ nums2[j])\n$$\n\n  其中 `prev` 为将 $s$ 中的第 $j$ 位进行置零后的二进制数,即 `prev = s ^ (1 << j)`,符号 ⊕ 代表异或操作。\n\nJava 代码:\n```Java\nclass Solution {\n    public int minimumXORSum(int[] nums1, int[] nums2) {\n        int n = nums1.length, mask = 1 << n, INF = 0x3f3f3f3f;\n        int[][] f = new int[n + 10][mask];\n        for (int i = 0; i <= n; i++) Arrays.fill(f[i], INF);\n        f[0][0] = 0;\n        for (int i = 1; i <= n; i++) {\n            for (int s = 0; s < mask; s++) {\n                if (getCnt(s, n) != i) continue;\n                for (int j = 1; j <= n; j++) {\n                    if (((s >> (j - 1)) & 1) == 0) continue;\n                    f[i][s] = Math.min(f[i][s], f[i - 1][s ^ (1 << (j - 1))] + (nums1[i - 1] ^ nums2[j - 1]));\n                }\n            }\n        }\n        return f[n][mask - 1];\n    }\n    int getCnt(int s, int n) {\n        int ans = 0;\n        for (int i = 0; i < n; i++) ans += (s >> i) & 1;\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int minimumXORSum(vector<int>& nums1, vector<int>& nums2) {\n        int n = nums1.size(), mask = 1 << n, INF = 0x3f3f3f3f;\n        vector<vector<int>> f(n + 10, vector<int>(mask, INF));\n        f[0][0] = 0;\n        auto getCnt = [&](int s, int n) {\n            int ans = 0;\n            for (int i = 0; i < n; i++) ans += (s >> i) & 1;\n            return ans;\n        };\n        for (int i = 1; i <= n; i++) {\n            for (int s = 0; s < mask; s++) {\n                if (getCnt(s, n) != i) continue;\n                for (int j = 1; j <= n; j++) {\n                    if (((s >> (j - 1)) & 1) == 0) continue;\n                    f[i][s] = min(f[i][s], f[i - 1][s ^ (1 << (j - 1))] + (nums1[i - 1] ^ nums2[j - 1]));\n                }\n            }\n        }\n        return f[n][mask - 1];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minimumXORSum(self, nums1: List[int], nums2: List[int]) -> int:\n        n, mask, INF = len(nums1), 1 << len(nums1), 0x3f3f3f3f\n        f = [[INF] * mask for _ in range(n + 10)]\n        f[0][0] = 0\n        for i in range(1, n + 1):\n            for s in range(mask):\n                if sum([1 for i in range(n) if (s >> i) & 1]) != i:\n                    continue\n                for j in range(1, n + 1):\n                    if ((s >> (j - 1)) & 1) == 0:\n                        continue\n                    f[i][s] = min(f[i][s], f[i - 1][s ^ (1 << (j - 1))] + (nums1[i - 1] ^ nums2[j - 1]))\n        return f[n][mask - 1]\n```\nTypeScript 代码:\n```TypeScript\nfunction minimumXORSum(nums1: number[], nums2: number[]): number {\n    const n = nums1.length, mask = 1 << n, INF = 0x3f3f3f3f;\n    const f: number[][] = new Array(n + 10).fill([]).map(() => new Array(mask).fill(INF));\n    f[0][0] = 0;\n    const getCnt = (s: number, n: number): number => {\n        let ans = 0;\n        for (let i = 0; i < n; i++) ans += (s >> i) & 1;\n        return ans;\n    };\n    for (let i = 1; i <= n; i++) {\n        for (let s = 0; s < mask; s++) {\n            if (getCnt(s, n) !== i) continue;\n            for (let j = 1; j <= n; j++) {\n                if (((s >> (j - 1)) & 1) === 0) continue;\n                f[i][s] = Math.min(f[i][s], f[i - 1][s ^ (1 << (j - 1))] + (nums1[i - 1] ^ nums2[j - 1]));\n            }\n        }\n    }\n    return f[n][mask - 1];\n};\n```\n* 时间复杂度:$O(n^2 \\times 2^n)$\n* 空间复杂度:$O(n \\times 2^n)$\n\n---\n\n### 模拟退火 \n\n事实上,这道题还能使用「模拟退火」进行求解。\n\n由于我们可以无限次对 `nums2` 进行打乱互换,先来思考如何衡量一个 `nums2` 排列的“好坏”。\n\n一个简单的方式:固定计算 `(nums1[0] XOR nums2[0]) + (nums1[1] XOR nums2[1]) + ... + (nums1[n - 1] XOR nums2[n - 1])` 作为衡量当前 `nums2` 的得分,得分越小,当前的 `nums2` 排列越好。\n\n迭代开始前先对 `nums2` 进行一次随机打乱,随后每个回合随机选择 `nums2` 的两个成员进行互换,并比较互换前后的得分情况,若互换后变好,那么保留该互换操作;若变差,则以一定概率进行重置(重新换回来)。\n\n重复迭代多次,使用一个全局变量 `ans` 保存下最小异或值之和。\n\n即「模拟退火」的单次迭代基本流程:\n\n1. 随机选择两个下标,计算「交换下标元素前对应序列的得分」&「交换下标元素后对应序列的得分」\n2. 如果温度下降(交换后的序列更优),进入下一次迭代\n3. 如果温度上升(交换前的序列更优),以「一定的概率」恢复现场(再交换回来)\n\n> 对于一个能够运用模拟退火求解的问题,最核心的是如何实现 `calc` 方法(即如何定义一个具体方案的得分),其余均为模板内容。\n\nJava 代码(2024/04/29 可过):\n```Java\nclass Solution {\n    int N = 400;\n    double hi = 1e5, lo = 1e-5, fa = 0.90;\n    Random random = new Random(20230823);\n    void swap(int[] n, int a, int b) {\n        int c = n[a];\n        n[a] = n[b];\n        n[b] = c;\n    }\n    int calc() {\n        int res = 0;\n        for (int i = 0; i < n; i++) res += n1[i] ^ n2[i];\n        ans = Math.min(ans, res);\n        return res;\n    }\n    void shuffle(int[] nums) {\n        for (int i = n; i > 0; i--) swap(nums, random.nextInt(i), i - 1);\n    }\n    void sa() {\n        shuffle(n2);\n        for (double t = hi; t > lo; t *= fa) {\n            int a = random.nextInt(n), b = random.nextInt(n);\n            int prev = calc();\n            swap(n2, a, b);\n            int cur = calc(); \n            int diff = cur - prev; \n            if (Math.log(diff / t) >= random.nextDouble()) swap(n2, a, b);\n        }\n    }\n    int[] n1, n2;\n    int n;\n    int ans = Integer.MAX_VALUE;\n    public int minimumXORSum(int[] nums1, int[] nums2) {\n        n1 = nums1; n2 = nums2;\n        n = n1.length;\n        while (N-- > 0) sa();\n        return ans;\n    }\n}\n```\n* 时间复杂度:启发式搜索不讨论时空复杂度\n* 空间复杂度:启发式搜索不讨论时空复杂度", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1879` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1891-1900/1893. 检查是否区域内所有整数都被覆盖（简单）.md", "url_title": "1893. 检查是否区域内所有整数都被覆盖", "url": "https://leetcode-cn.com/problems/check-if-all-the-integers-in-a-range-are-covered/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-j83x/", "difficulty": "简单", "tags": ["模拟", "树状数组", "线段树"], "question": "给你一个二维整数数组 `ranges` 和两个整数 `left` 和 `right`。每个 $ranges[i] = [start_i, end_i]$ 表示一个从 $start_i$ 到 $end_i$ 的 闭区间 。\n\n如果闭区间 $[left, right]$ 内每个整数都被 `ranges` 中 至少一个 区间覆盖,那么请你返回 `true`,否则返回 `false`。\n\n已知区间 $ranges[i] = [start_i, end_i]$,如果整数 `x` 满足 $start_i <= x <= end_i$,那么我们称整数 `x` 被覆盖了。\n\n示例 1:\n```\n输入:ranges = [[1,2],[3,4],[5,6]], left = 2, right = 5\n\n输出:true\n\n解释:2 到 5 的每个整数都被覆盖了:\n- 2 被第一个区间覆盖。\n- 3 和 4 被第二个区间覆盖。\n- 5 被第三个区间覆盖。\n```\n示例 2:\n```\n输入:ranges = [[1,10],[10,20]], left = 21, right = 21\n\n输出:false\n\n解释:21 没有被任何一个区间覆盖。\n```\n\n提示:\n* $1 <= ranges.length <= 50$\n* $1 <= start_i <= end_i <= 50$\n* $1 <= left <= right <= 50$", "solution": "### 模拟\n\n一个简单的想法是根据题意进行模拟,检查 $[left, right]$ 中的每个整数,如果检查过程中发现某个整数没被 $ranges$ 中的闭区间所覆盖,那么直接返回 `False`,所有数值通过检查则返回 `True`。\n\n代码:\n```Java\nclass Solution {\n    public boolean isCovered(int[][] rs, int l, int r) {\n        for (int i = l; i <= r; i++) {\n            boolean ok = false;\n            for (int[] cur : rs) {\n                int a = cur[0], b = cur[1];\n                if (a <= i && i <= b) {\n                    ok = true;\n                    break;\n                }\n            }\n            if (!ok) return false;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:令 $[left, right]$ 之间整数数量为 $n$,$ranges$ 长度为 $m$。整体复杂度为 $O(n * m)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 树状数组\n\n**针对此题,可以有一个很有意思的拓展,将本题难度提升到【中等】甚至是【困难】。**\n\n将查询 $[left, right]$ 修改为「四元查询数组」$querys$,每个 $querys[i]$ 包含四个指标 $(a,b,l,r)$:代表询问 $[l, r]$ 中的每个数是否在 $range$ 中 $[a, b]$ 的闭区间所覆盖过。\n\n**如果进行这样的拓展的话,那么我们需要使用「持久化树状数组」或者「主席树」来配合「容斥原理」来做。**\n\n基本思想都是使用 $range[0,b]$ 的计数情况减去 $range[0, a-1]$ 的计数情况来得出 $[a, b]$ 的计数情况。\n\n回到本题,由于数据范围很小,只有 $50$,我们可以使用「树状数组」进行求解:\n\n* `void add(int x, int u)`:对于数值 $x$ 出现次数进行 $+u$ 操作;\n* `int query(int x)`:查询某个满足 $<= x$ 的数值的个数。\n\n那么显然,如果我们需要查询一个数值 $x$ 是否出现过,可以通过查询 $cnt = query(x) - query(x - 1)$ 来得知。\n\n代码:\n```Java\nclass Solution {\n    int n = 55;\n    int[] tr = new int[n];\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void add(int x, int u) {\n        for (int i = x; i <= n; i += lowbit(i)) tr[i] += u;\n    }\n    int query(int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];\n        return ans;\n    }\n    public boolean isCovered(int[][] rs, int l, int r) {\n        for (int[] cur : rs) {\n            int a = cur[0], b = cur[1];\n            for (int i = a; i <= b; i++) {\n                add(i, 1);\n            }\n        }\n        for (int i = l; i <= r; i++) {\n            int cnt = query(i) - query(i - 1);\n            if (cnt == 0) return false;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:令 $[left, right]$ 之间整数数量为 $n$,$\\sum_{i = 0}^{range.legth - 1}ranges[i].length$ 为 $sum$,常数 $C$ 固定为 $55$。建树复杂度为 $O(sum\\log C)$,查询查询复杂度为 $O(n\\log{C})$。整体复杂度为 $O(sum\\log{C} + n\\log{C})$\n* 空间复杂度:$O(C)$\n\n---\n\n### 树状数组(去重优化)\n\n在朴素的「树状数组」解法中,我们无法直接查询 $[l, r]$ 区间中被覆盖过的个数的根本原因是「某个值可能会被重复添加到树状数组中」。\n\n因此,一种更加优秀的做法:**在往树状数组中添数的时候进行去重,然后通过 $cnt = query(r) - query(l - 1)$ 直接得出 $[l, r]$ 范围内有多少个数被添加过。**\n\n这样的 `Set` 去重操作可以使得我们查询的复杂度从 $O(n\\log{C})$ 下降到 $O(\\log{C})$。\n\n> 由于数值范围很小,自然也能够使用数组来代替 `Set` 进行标记(见 P2)\n\n代码:\n```Java\nclass Solution {\n    int n = 55;\n    int[] tr = new int[n];\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void add(int x, int u) {\n        for (int i = x; i <= n; i += lowbit(i)) tr[i] += u;\n    }\n    int query(int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];\n        return ans;\n    }\n    public boolean isCovered(int[][] rs, int l, int r) {\n        Set<Integer> set = new HashSet<>();\n        for (int[] cur : rs) {\n            int a = cur[0], b = cur[1];\n            for (int i = a; i <= b; i++) {\n                if (!set.contains(i)) {\n                    add(i, 1);\n                    set.add(i);\n                }\n            }\n        }\n        int tot = r - l + 1, cnt = query(r) - query(l - 1);\n        return tot == cnt;\n    }\n}\n```\n```Java\nclass Solution {\n    int n = 55;\n    int[] tr = new int[n];\n    boolean[] vis = new boolean[n];\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void add(int x, int u) {\n        for (int i = x; i <= n; i += lowbit(i)) tr[i] += u;\n    }\n    int query(int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];\n        return ans;\n    }\n    public boolean isCovered(int[][] rs, int l, int r) {\n        for (int[] cur : rs) {\n            int a = cur[0], b = cur[1];\n            for (int i = a; i <= b; i++) {\n                if (!vis[i]) {\n                    add(i, 1);\n                    vis[i] = true;\n                }\n            }\n        }\n        int tot = r - l + 1, cnt = query(r) - query(l - 1);\n        return tot == cnt;\n    }\n}\n```\n* 时间复杂度:令 $[left, right]$ 之间整数数量为 $n$,$\\sum_{i = 0}^{range.legth - 1}ranges[i].length$ 为 $sum$,常数 $C$ 固定为 $55$。建树复杂度为 $O(sum\\log C)$,查询查询复杂度为 $O(\\log{C})$。整体复杂度为 $O(sum\\log{C} + \\log{C})$\n* 空间复杂度:$O(C + \\sum_{i = 0}^{range.legth - 1}ranges[i].length)$\n\n---\n\n### 线段树(不含“懒标记”)\n\n更加进阶的做法是使用「线段树」来做,与「树状数组(优化)」解法一样,线段树配合持久化也可以用于求解「在线」问题。\n\n**与主要解决「单点修改 & 区间查询」的树状数组不同,线段树能够解决绝大多数「区间修改(区间修改/单点修改)& 区间查询」问题。**\n\n对于本题,由于数据范围只有 $55$,因此我们可以使用与「树状数组(优化)」解法相同的思路,实现一个不包含“懒标记”的线段树来做(仅支持单点修改 & 区间查询)。\n\n代码:\n```Java\nclass Solution {\n    // 代表 [l, r] 区间有 cnt 个数被覆盖\n    class Node {\n        int l, r, cnt;\n        Node (int _l, int _r, int _cnt) {\n            l = _l; r = _r; cnt = _cnt;\n        }\n    }\n    int N = 55;\n    Node[] tr = new Node[N * 4];\n    void pushup(int u) {\n        tr[u].cnt = tr[u << 1].cnt + tr[u << 1 | 1].cnt;\n    }\n    void build(int u, int l, int r) {\n        if (l == r) {\n            tr[u] = new Node(l, r, 0);\n        } else {\n            tr[u] = new Node(l, r, 0);\n            int mid = l + r >> 1;\n            build(u << 1, l, mid);\n            build(u << 1 | 1, mid + 1, r);\n            pushup(u);\n        }\n    }\n    // 从 tr 数组的下标 u 开始,在数值 x 的位置进行标记\n    void update(int u, int x) {\n        if (tr[u].l == x && tr[u].r == x) {\n            tr[u].cnt = 1;\n        } else {\n            int mid = tr[u].l + tr[u].r >> 1;\n            if (x <= mid) update(u << 1, x);\n            else update(u << 1 | 1, x);\n            pushup(u);\n        }\n    }\n    // 从 tr 数组的下标 u 开始,查询 [l,r] 范围内有多少个数值被标记\n    int query(int u, int l, int r) {\n        if (l <= tr[u].l && tr[u].r <= r) return tr[u].cnt;\n        int mid = tr[u].l + tr[u].r >> 1;\n        int ans = 0;\n        if (l <= mid) ans += query(u << 1, l, r);\n        if (r > mid) ans += query(u << 1 | 1, l, r);\n        return ans;\n    }\n    public boolean isCovered(int[][] rs, int l, int r) {\n        build(1, 1, N);\n        for (int[] cur : rs) {\n            int a = cur[0], b = cur[1];\n            for (int i = a; i <= b; i++) {\n                update(1, i);\n            }\n        }\n        int tot = r - l + 1 , cnt = query(1, l, r);\n        return tot == cnt;\n    }\n}\n```\n* 时间复杂度:令 $[left, right]$ 之间整数数量为 $n$,$\\sum_{i = 0}^{range.legth - 1}ranges[i].length$ 为 $sum$,常数 $C$ 固定为 $55$。建树复杂度为 $O(sum\\log C)$,查询查询复杂度为 $O(\\log{C})$。整体复杂度为 $O(sum\\log{C} + \\log{C})$\n* 空间复杂度:$O(C * 4)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1893` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1891-1900/1894. 找到需要补充粉笔的学生编号（中等）.md", "url_title": "1894. 找到需要补充粉笔的学生编号", "url": "https://leetcode-cn.com/problems/find-the-student-that-will-replace-the-chalk/solution/gong-shui-san-xie-yi-ti-shuang-jie-qian-kpqsk/", "difficulty": "中等", "tags": ["前缀和", "二分", "模拟"], "question": "一个班级里有 n 个学生,编号为 0 到 n - 1 。每个学生会依次回答问题,编号为 0 的学生先回答,然后是编号为 1 的学生,以此类推,直到编号为 n - 1 的学生,然后老师会重复这个过程,重新从编号为 0 的学生开始回答问题。\n\n给你一个长度为 n 且下标从 0 开始的整数数组 chalk 和一个整数 k 。一开始粉笔盒里总共有 k 支粉笔。当编号为 i 的学生回答问题时,他会消耗 chalk[i] 支粉笔。如果剩余粉笔数量 严格小于 chalk[i] ,那么学生 i 需要 补充 粉笔。\n\n请你返回需要 **补充** 粉笔的学生 **编号** 。\n\n示例 1:\n```\n输入:chalk = [5,1,5], k = 22\n\n输出:0\n\n解释:学生消耗粉笔情况如下:\n- 编号为 0 的学生使用 5 支粉笔,然后 k = 17 。\n- 编号为 1 的学生使用 1 支粉笔,然后 k = 16 。\n- 编号为 2 的学生使用 5 支粉笔,然后 k = 11 。\n- 编号为 0 的学生使用 5 支粉笔,然后 k = 6 。\n- 编号为 1 的学生使用 1 支粉笔,然后 k = 5 。\n- 编号为 2 的学生使用 5 支粉笔,然后 k = 0 。\n编号为 0 的学生没有足够的粉笔,所以他需要补充粉笔。\n```\n示例 2:\n```\n输入:chalk = [3,4,1,2], k = 25\n\n输出:1\n\n解释:学生消耗粉笔情况如下:\n- 编号为 0 的学生使用 3 支粉笔,然后 k = 22 。\n- 编号为 1 的学生使用 4 支粉笔,然后 k = 18 。\n- 编号为 2 的学生使用 1 支粉笔,然后 k = 17 。\n- 编号为 3 的学生使用 2 支粉笔,然后 k = 15 。\n- 编号为 0 的学生使用 3 支粉笔,然后 k = 12 。\n- 编号为 1 的学生使用 4 支粉笔,然后 k = 8 。\n- 编号为 2 的学生使用 1 支粉笔,然后 k = 7 。\n- 编号为 3 的学生使用 2 支粉笔,然后 k = 5 。\n- 编号为 0 的学生使用 3 支粉笔,然后 k = 2 。\n编号为 1 的学生没有足够的粉笔,所以他需要补充粉笔。\n```\n\n提示:\n* chalk.length == n\n* 1 <= n <= $10^5$\n* 1 <= chalk[i] <= $10^5$\n* 1 <= k <= $10^9$", "solution": "### 前缀和 + 二分\n\n根据题意,每个学生消耗的粉笔为定值,所有粉笔最终会像老师的教导一样孜孜不倦地循环投入在所有的学生身上。\n\n因此我们可以预处理出前缀和数组 $sum$,将 $k$ 对所有学生一次循环所消耗总粉笔数($sum[n]$)进行取模,得到最后一轮开始前的粉笔数量。\n\n然后对前缀和数组进行二分,找到最后一位满足粉笔要求的学生,其往后一位的同学编号即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int chalkReplacer(int[] chalk, int k) {\n        int n = chalk.length;\n        long[] sum = new long[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + chalk[i - 1];\n        k = (int)(k % sum[n]);\n        int l = 1, r = n;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (sum[mid] <= k) l = mid;\n            else r = mid - 1;\n        }\n        return sum[r] <= k ? r : r - 1;\n    }\n}\n```\n* 时间复杂度:预处理前缀和的复杂度为 $O(n)$;二分求答案的复杂度为 $O(\\log{n})$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 模拟\n\n通过解法一,我们发现复杂度的上界为预处理前缀和的复杂度 $O(n)$,同时「对单次循环消耗的总粉笔数取模操作」确保了剩余的粉笔数必然会在单次遍历中消耗完成。\n\n因此 $O(\\log{n})$ 的二分其实是没有必要的,只需要再对 `chalk` 进行最后一轮的遍历模拟即可。\n\n代码:\n```Java\nclass Solution {\n    public int chalkReplacer(int[] chalk, int k) {\n        int n = chalk.length;\n        long max = 0;\n        for (int i : chalk) max += i;\n        k = (int)(k % max);\n        for (int i = 0; i < n; i++) {\n            k -= chalk[i];\n            if (k < 0) return i;\n        }\n        return -1; // never\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1894` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/191-200/191. 位1的个数（简单）.md", "url_title": "191. 位1的个数", "url": "https://leetcode-cn.com/problems/number-of-1-bits/solution/yi-ti-san-jie-wei-shu-jian-cha-you-yi-to-av1r/", "difficulty": "简单", "tags": ["位运算"], "question": "编写一个函数,输入是一个无符号整数(以二进制串的形式),返回其二进制表达式中数字位数为 '1' 的个数(也被称为汉明重量)。\n\n提示:\n\n* 请注意,在某些语言(如 Java)中,没有无符号整数类型。在这种情况下,输入和输出都将被指定为有符号整数类型,并且不应影响您的实现,因为无论整数是有符号的还是无符号的,其内部的二进制表示形式都是相同的。\n* 在 Java 中,编译器使用二进制补码记法来表示有符号整数。因此,在上面的 示例 3 中,输入表示有符号整数 -3。\n\n示例 1:\n```\n输入:00000000000000000000000000001011\n输出:3\n解释:输入的二进制串 00000000000000000000000000001011 中,共有三位为 '1'。\n```\n示例 2:\n```\n输入:00000000000000000000000010000000\n输出:1\n解释:输入的二进制串 00000000000000000000000010000000 中,共有一位为 '1'。\n```\n示例 3:\n```\n输入:11111111111111111111111111111101\n输出:31\n解释:输入的二进制串 11111111111111111111111111111101 中,共有 31 位为 '1'。\n```\n\n提示:\n* 输入必须是长度为 32 的 二进制串 。\n\n进阶:\n* 如果多次调用这个函数,你将如何优化你的算法?", "solution": "### 「位数检查」解法\n\n一个朴素的做法是,对 `int` 的每一位进行检查,并统计 $1$ 的个数。\n\n代码:\n```Java\npublic class Solution {\n    public int hammingWeight(int n) {\n        int ans = 0;\n        for (int i = 0; i < 32; i++) {\n            ans += ((n >> i) & 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(k)$,$k$ 为 `int` 的位数,固定为 $32$ 位\n* 空间复杂度:$O(1)$\n\n***\n\n### 「右移统计」解法\n\n对于方法一,即使 $n$ 的高位均为是 $0$,我们也会对此进行循环检查。\n\n因此另外一个做法是:通过 `n & 1` 来统计当前 $n$ 的最低位是否为 $1$,同时每次直接对 $n$ 进行右移并高位补 0。\n\n当 $n = 0$ 代表,我们已经将所有的 $1$ 统计完成。\n\n这样的做法,可以确保只会循环到最高位的 $1$。\n\n代码:\n```Java\npublic class Solution {\n    public int hammingWeight(int n) {\n        int ans = 0;\n        while (n != 0) {\n            ans += (n & 1);\n            n >>>= 1;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(k)$,$k$ 为 `int` 的位数,固定为 $32$ 位,最坏情况 $n$ 的二进制表示全是 $1$\n* 空间复杂度:$O(1)$\n\n---\n\n### 「lowbit」解法\n\n对于方法二,如果最高位 $1$ 和 最低位 $1$ 之间全是 $0$,我们仍然会诸次右移,直到处理到最高位的 $1$ 为止。\n\n那么是否有办法,只对位数为 $1$ 的二进制位进行处理呢?\n\n使用 `lowbit` 即可做到,`lowbit` 会在 $O(1)$ 复杂度内返回二进制表示中最低位 $1$ 所表示的数值。\n\n例如 $(0000...111100)_2$ 传入 `lowbit` 返回 $(0000...000100)_2$;$(0000...00011)_2$ 传入 `lowbit` 返回 $(0000...00001)_2$ ...\n\n代码:\n```Java\npublic class Solution {\n    public int hammingWeight(int n) {\n        int ans = 0;\n        for (int i = n; i != 0; i -= lowbit(i)) ans++;\n        return ans;\n    }\n    int lowbit(int x) {\n        return x & -x;\n    }\n}\n```\n* 时间复杂度:$O(k)$,$k$ 为 `int` 的位数,固定为 $32$ 位,最坏情况 $n$ 的二进制表示全是 $1$\n* 空间复杂度:$O(1)$\n\n---\n\n### 「分组统计」解法\n\n以上三种解法都是 $O(k)$ 的,事实上我们可以通过分组统计的方式,做到比 $O(k)$ 更低的复杂度。\n\n代码:\n```Java\npublic class Solution {\n    public int hammingWeight(int n) {\n        n = (n & 0x55555555) + ((n >>> 1)  & 0x55555555);\n        n = (n & 0x33333333) + ((n >>> 2)  & 0x33333333);\n        n = (n & 0x0f0f0f0f) + ((n >>> 4)  & 0x0f0f0f0f);\n        n = (n & 0x00ff00ff) + ((n >>> 8)  & 0x00ff00ff);\n        n = (n & 0x0000ffff) + ((n >>> 16) & 0x0000ffff);\n        return n;\n    }\n}\n```\n* 时间复杂度:$O(\\log{k})$,$k$ 为 `int` 的位数,固定为 $32$ 位\n* 空间复杂度:$O(1)$\n\nPS. 对于该解法,如果大家学有余力的话,还是建议大家在纸上模拟一下这个过程。如果不想深入,也可以当成模板背过(写法非常固定),但通常如果不是写底层框架,你几乎不会遇到需要一个 $O(\\log{k})$ 解法的情况。\n\n而且这个做法的最大作用,不是处理 `int`,而是处理更大位数的情况,在长度只有 $32$ 位的 `int` 的情况下,该做法不一定就比循环要快(该做法会产生多个的中间结果,导致赋值发生多次,而且由于指令之间存在对 $n$ 数值依赖,可能不会被优化为并行指令),这个道理和对于排序元素少的情况下,我们会选择「选择排序」而不是「归并排序」是一样的。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.191` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/191-200/198. 打家劫舍（中等）.md", "url_title": "198. 打家劫舍", "url": "https://leetcode.cn/problems/house-robber/solution/by-ac_oier-7v1g/", "difficulty": "中等", "tags": ["线性 DP", "状态机 DP", "动态规划"], "question": "你是一个专业的小偷,计划偷窃沿街的房屋。每间房内都藏有一定的现金,影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统,如果两间相邻的房屋在同一晚上被小偷闯入,系统会自动报警。\n\n给定一个代表每个房屋存放金额的非负整数数组,计算你 不触动警报装置的情况下 ,一夜之内能够偷窃到的最高金额。\n\n示例 1:\n```\n输入:[1,2,3,1]\n\n输出:4\n\n解释:偷窃 1 号房屋 (金额 = 1) ,然后偷窃 3 号房屋 (金额 = 3)。\n     偷窃到的最高金额 = 1 + 3 = 4 。\n```\n示例 2:\n```\n输入:[2,7,9,3,1]\n\n输出:12\n\n解释:偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9),接着偷窃 5 号房屋 (金额 = 1)。\n     偷窃到的最高金额 = 2 + 9 + 1 = 12 。\n```\n\n提示:\n* $1 <= nums.length <= 100$\n* $0 <= nums[i] <= 400$", "solution": "### 状态机 DP\n\n这是一道入门级的状态机线性 DP 题。\n\n定义 $f[i][j]$ 为考虑前 $i$ 间房子,且第 $i$ 间房子的状态为 $j$ 时所能取得的最大价值(其中 $j = 0$ 代表不偷该房子,$j = 1$ 代表偷该房子)。\n\n再结合题意,因为相邻房子不能同时被偷,可推导出状态转移方程为:\n\n* 当前房子不偷,则对前一间房子的状态无要求,状态值为前一状态的较大值:$f[i][0] = \\max(f[i - 1][0], f[i - 1][1])$\n* 当前房子偷,此时限定了前一间只能不偷,状态值为前一间房子不偷时的最大价值,加上当前房子的价值: $f[i][1] = f[i - 1][0] + nums[i - 1]$\n\n最终 $\\max(f[n][0], f[n][1])$ 即是答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int rob(int[] nums) {\n        int n = nums.length;\n        int[][] f = new int[n + 10][2];\n        for (int i = 1; i <= n; i++) {\n            f[i][0] = Math.max(f[i - 1][0], f[i - 1][1]);\n            f[i][1] = f[i - 1][0] + nums[i - 1];\n        }\n        return Math.max(f[n][0], f[n][1]);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int rob(vector<int>& nums) {\n        int n = nums.size();\n        int f[n + 10][2];\n        f[0][0] = f[0][1] = 0;\n        for (int i = 1; i <= n; i++) {\n            f[i][0] = max(f[i - 1][0], f[i - 1][1]);\n            f[i][1] = f[i - 1][0] + nums[i - 1];\n        }\n        return max(f[n][0], f[n][1]);\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nfunction rob(nums: number[]): number {\n    const n = nums.length\n    const f = new Array<Array<number>>(n + 10)\n    f[0] = new Array<number>(2).fill(0)\n    for (let i = 1; i <= n; i++) {\n        f[i] = new Array<number>(2).fill(0)\n        f[i][0] = Math.max(f[i - 1][0], f[i - 1][1])\n        f[i][1] = f[i - 1][0] + nums[i - 1]\n    }\n    return Math.max(f[n][0], f[n][1])\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def rob(self, nums: List[int]) -> int:\n        n = len(nums)\n        f = [[0] * 2 for _ in range(n + 10)]\n        for i in range(1, n + 1):\n            f[i][0] = max(f[i - 1][0], f[i - 1][1])\n            f[i][1] = f[i - 1][0] + nums[i - 1]\n        return max(f[n][0], f[n][1])\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 优化\n\n利用 $f[i][X]$ 仅依赖于 $f[i - 1][X]$,我们可以通过「滚动数组」的方式将空间优化至 $O(1)$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int rob(int[] nums) {\n        int n = nums.length;\n        int[][] f = new int[][]{{0, 0}, {0, 0}};\n        for (int i = 1; i <= n; i++) {\n            int a = (i - 1) & 1, b = i & 1;\n            f[b][0] = Math.max(f[a][0], f[a][1]);\n            f[b][1] = f[a][0] + nums[i - 1];\n        }\n        return Math.max(f[n & 1][0], f[n & 1][1]);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int rob(vector<int>& nums) {\n        int n = nums.size();\n        int f[][2] = {{0, 0}, {0, 0}};\n        for (int i = 1; i <= n; i++) {\n            int a = (i - 1) & 1, b = i & 1;\n            f[b][0] = max(f[a][0], f[a][1]);\n            f[b][1] = f[a][0] + nums[i - 1];\n        }\n        return max(f[n & 1][0], f[n & 1][1]);\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nfunction rob(nums: number[]): number {\n    const n = nums.length\n    const f = [[0, 0], [0, 0]]\n    for (let i = 1; i <= n; i++) {\n        const a = (i - 1) & 1, b = i & 1\n        f[b][0] = Math.max(f[a][0], f[a][1])\n        f[b][1] = f[a][0] + nums[i - 1]\n    }\n    return Math.max(f[n & 1][0], f[n & 1][1])\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def rob(self, nums: List[int]) -> int:\n        n = len(nums)\n        f = [[0, 0], [0, 0]]\n        for i in range(1, n + 1):\n            a, b = (i - 1) & 1, i & 1\n            f[b][0] = max(f[a][0], f[a][1])\n            f[b][1] = f[a][0] + nums[i - 1]\n        return max(f[n & 1][0], f[n & 1][1])\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.198` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/191-200/199. 二叉树的右视图（中等）.md", "url_title": "199. 二叉树的右视图", "url": null, "difficulty": "中等", "tags": ["二叉树", "BFS", "DFS", "层序遍历"], "question": "给定一个二叉树的 根节点 `root`,想象自己站在它的右侧,按照从顶部到底部的顺序,返回从右侧所能看到的节点值。\n\n示例 1:\n\n```\n输入: [1,2,3,null,5,null,4]\n\n输出: [1,3,4]\n```\n示例 2:\n```\n输入: [1,null,3]\n\n输出: [1,3]\n```\n示例 3:\n```\n输入: []\n\n输出: []\n```\n\n提示:\n* 二叉树的节点个数的范围是 $[0,100]$\n* $-100 <= Node.val <= 100$", "solution": "### BFS\n\n本质就是找层序遍历过程中,每层的最后一个节点。\n\nJava 代码:\n\n```Java\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n *     int val;\n *     TreeNode left;\n *     TreeNode right;\n *     TreeNode() {}\n *     TreeNode(int val) { this.val = val; }\n *     TreeNode(int val, TreeNode left, TreeNode right) {\n *         this.val = val;\n *         this.left = left;\n *         this.right = right;\n *     }\n * }\n */\nclass Solution {\n    public List<Integer> rightSideView(TreeNode root) {\n        List<Integer> ans = new ArrayList<>();\n        if (root == null) return ans;\n        Deque<TreeNode> d = new ArrayDeque<>();\n        d.addLast(root);\n        while (!d.isEmpty()) {\n            int sz = d.size();\n            while (sz-- > 0) {\n                TreeNode node = d.pollFirst();\n                if (node.left != null) d.addLast(node.left);\n                if (node.right != null) d.addLast(node.right);\n                if (sz == 0) ans.add(node.val);\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\n/**\n * Definition for a binary tree node.\n * struct TreeNode {\n *     int val;\n *     TreeNode *left;\n *     TreeNode *right;\n *     TreeNode() : val(0), left(nullptr), right(nullptr) {}\n *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}\n * };\n */\nclass Solution {\npublic:\n    vector<int> rightSideView(TreeNode* root) {\n        vector<int> ans;\n        if (!root) return ans;\n        queue<TreeNode*> d;\n        d.push(root);\n        while (!d.empty()) {\n            int sz = d.size();\n            while (sz-- > 0) {\n                TreeNode* node = d.front();\n                d.pop();\n                if (node->left) d.push(node->left);\n                if (node->right) d.push(node->right);\n                if (sz == 0) ans.push_back(node->val);\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\n# Definition for a binary tree node.\n# class TreeNode:\n#     def __init__(self, val=0, left=None, right=None):\n#         self.val = val\n#         self.left = left\n#         self.right = right\nclass Solution:\n    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:\n        ans = []\n        if not root:\n            return ans\n        d = deque()\n        d.append(root)\n        while d:\n            sz = len(d)\n            while sz > 0:\n                node = d.popleft()\n                if node.left:\n                    d.append(node.left)\n                if node.right:\n                    d.append(node.right)\n                if sz == 1:\n                    ans.append(node.val)\n                sz -= 1\n        return ans\n```\nTypeScript 代码:\n```TypeScript\n/**\n * Definition for a binary tree node.\n * class TreeNode {\n *     val: number\n *     left: TreeNode | null\n *     right: TreeNode | null\n *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {\n *         this.val = (val===undefined ? 0 : val)\n *         this.left = (left===undefined ? null : left)\n *         this.right = (right===undefined ? null : right)\n *     }\n * }\n */\nfunction rightSideView(root: TreeNode | null): number[] {\n    const ans = [];\n    if (!root) return ans;\n    const d = [];\n    d.push(root);\n    while (d.length > 0) {\n        let sz = d.length;\n        while (sz-- > 0) {\n            const node = d.shift()!;\n            if (node.left) d.push(node.left);\n            if (node.right) d.push(node.right);\n            if (sz === 0) ans.push(node.val);\n        }\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### DFS\n\n`DFS` 解法同理,规定好节点的遍历顺序(例如 `中-右-左`),并在 `DFS`  过程中传递当前层参数 `level`(根节点为第 `0` 层),同时使用一个 `Set` 数据结构记录处理过的层编号,从而实现只将当前层的首个节点添加到答案中。\n\nJava 代码:\n```Java\n/**\n * Definition for a binary tree node.\n * public class TreeNode {\n *     int val;\n *     TreeNode left;\n *     TreeNode right;\n *     TreeNode() {}\n *     TreeNode(int val) { this.val = val; }\n *     TreeNode(int val, TreeNode left, TreeNode right) {\n *         this.val = val;\n *         this.left = left;\n *         this.right = right;\n *     }\n * }\n */\nclass Solution {\n    List<Integer> ans = new ArrayList<>();\n    Set<Integer> set = new HashSet<>();\n    public List<Integer> rightSideView(TreeNode root) {\n        dfs(root, 0);\n        return ans;\n    }\n    void dfs(TreeNode node, int level) {\n        if (node == null) return ;\n        if (!set.contains(level)) {\n            ans.add(node.val);\n            set.add(level);\n        }\n        dfs(node.right, level + 1);\n        dfs(node.left, level + 1);\n    }\n}\n```\nC++ 代码:\n```C++\n/**\n * Definition for a binary tree node.\n * struct TreeNode {\n *     int val;\n *     TreeNode *left;\n *     TreeNode *right;\n *     TreeNode() : val(0), left(nullptr), right(nullptr) {}\n *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}\n * };\n */\nclass Solution {\npublic:\n    vector<int> ans;\n    unordered_set<int> levels;\n    vector<int> rightSideView(TreeNode* root) {\n        dfs(root, 0);\n        return ans;\n    }\n    void dfs(TreeNode* node, int level) {\n        if (!node) return;\n        if (levels.find(level) == levels.end()) {\n            ans.push_back(node->val);\n            levels.insert(level);\n        }\n        dfs(node->right, level + 1);\n        dfs(node->left, level + 1);\n    }\n};\n```\nPython 代码:\n```Python\n# Definition for a binary tree node.\n# class TreeNode:\n#     def __init__(self, val=0, left=None, right=None):\n#         self.val = val\n#         self.left = left\n#         self.right = right\nclass Solution:\n    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:        \n        def dfs(node, level):\n            if not node:\n                return\n            if level not in levels:\n                ans.append(node.val)\n                levels.add(level)\n            dfs(node.right, level + 1)\n            dfs(node.left, level + 1)\n        ans = []\n        levels = set()\n        dfs(root, 0)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\n/**\n * Definition for a binary tree node.\n * class TreeNode {\n *     val: number\n *     left: TreeNode | null\n *     right: TreeNode | null\n *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {\n *         this.val = (val===undefined ? 0 : val)\n *         this.left = (left===undefined ? null : left)\n *         this.right = (right===undefined ? null : right)\n *     }\n * }\n */\nfunction rightSideView(root: TreeNode | null): number[] {\n    const ans = [];\n    const levels = new Set();\n    function dfs(node: TreeNode | null, level: number) {\n        if (!node) return;\n        if (!levels.has(level)) {\n            ans.push(node.val);\n            levels.add(level);\n        }\n        dfs(node.right, level + 1);\n        dfs(node.left, level + 1);\n    }\n    dfs(root, 0);\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.198` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1971-1980/1976. 到达目的地的方案数（中等）.md", "url_title": "1976. 到达目的地的方案数", "url": "https://leetcode.cn/problems/number-of-ways-to-arrive-at-destination/solution/by-ac_oier-4ule/", "difficulty": "中等", "tags": ["最短路", "拓扑排序", "动态规划"], "question": "你在一个城市里,城市由 $n$ 个路口组成,路口编号为 $0$ 到 $n - 1$ ,某些路口之间有 双向 道路。输入保证你可以从任意路口出发到达其他任意路口,且任意两个路口之间最多有一条路。\n\n给你一个整数 `n` 和二维整数数组 `roads`,其中 $roads[i] = [u_i, v_i, time_i]$ 表示在路口 $u_i$ 和 $v_i$ 之间有一条需要花费 $time_i$ 时间才能通过的道路。你想知道花费 最少时间 从路口 $0$ 出发到达路口 $n - 1$ 的方案数。\n\n请返回花费 最少时间 到达目的地的 路径数目 。由于答案可能很大,将结果对 $10^9 + 7$ 取余 后返回。\n\n示例 1:\n\n```\n输入:n = 7, roads = [[0,6,7],[0,1,2],[1,2,3],[1,3,3],[6,3,3],[3,5,1],[6,5,1],[2,5,1],[0,4,5],[4,6,2]]\n\n输出:4\n\n解释:从路口 0 出发到路口 6 花费的最少时间是 7 分钟。\n四条花费 7 分钟的路径分别为:\n- 0 ➝ 6\n- 0 ➝ 4 ➝ 6\n- 0 ➝ 1 ➝ 2 ➝ 5 ➝ 6\n- 0 ➝ 1 ➝ 3 ➝ 5 ➝ 6\n```\n示例 2:\n```\n输入:n = 2, roads = [[1,0,10]]\n\n输出:1\n\n解释:只有一条从路口 0 到路口 1 的路,花费 10 分钟。\n```\n\n提示:\n* $1 <= n <= 200$\n* $n - 1 <= roads.length <= \\frac{n \\times (n - 1)}{2}$\n* $roads[i].length == 3$\n* $0 <= u_i, v_i <= n - 1$\n* $1 <= time_i <= 10^9$\n* $u_i != v_i$\n* 任意两个路口之间至多有一条路。\n* 从任意路口出发,你能够到达其他任意路口。", "solution": "### Dijkstra + 拓扑排序 + DP\n\n为了方便,我们记 `roads` 为 `rs`,令点数为 `n`,边数为 `m`。\n\n边数与点数不在一个数量级上($m \\approx n^2$),属于「稠密图」,我们可以使用「邻接矩阵」进行存图,同时使用朴素 `Dijkstra` 求解从 $0$ 号点到其他点的最短路,记为 `dist` 数组,$dist[i] = x$ 代表以 $0$ 号点为起点到到 $i$ 点的最短路径为 $x$。\n\n当我们预处理出 $0$ 点到其他点的最短距离后,考虑如何统计从 $0$ 点到 $n - 1$ 点,且路径和为 $dist[n - 1]$ 的方案数。\n\n一个容易想到的性质:**在任意的合法方案中,途径的该路径中的每个点时,都是以最短路径的方式到达的。**\n\n使用「反证法」证明该性质的正确性:假设其中一条合法路径为 `a -> ... -> k -> ... -> z`(其中 `a` 为 $0$ 号点,`z` 为 $n - 1$ 号点),其为合法路径,意味着从 `a` 到 `z` 的路径和为 $dist[n - 1]$。若我们在经过某个途经点,假设为 `k` 时,所途径的路径总和 $x$ 不是 $dist[k]$ 的话,意味着我们可以调整从 `a` 到 `k` 的路径,使其变为 $dist[k]$,而后续路径不变(从 `k` 到 `z` 的路径不变)来得到一条路径和比 $dist[n - 1]$ 要小的从 `a` 到 `z` 的路径,这与 $dist[n - 1]$ 为从 `a` 到 `z` 的最短路冲突。\n\n至此,我们证明了「**在任意的合法方案中,途径的该路径中的每个点时,都是以最短路径的方式到达的**」这一性质。\n\n利用该性质,我们可以对图进行「重建」,对于原图中点 $a$ 与点 $b$ 权重为 $c$ 的无向边,我们根据 $dist[a]$、$dist[b]$ 和 $c$ 三者关系建立有向边,并统计入度:\n\n* 若有 $dist[b] = dist[a] + c$,在新图上增加从 $a$ 到 $b$ 的权重为 $c$ 的有向边,同时 $b$ 入度加一;\n* 若有 $dist[a] = dist[b] + c$,在新图上增加从 $b$ 到 $a$ 的权重为 $c$ 的有向边,同时 $a$ 入度加一。\n\n构建新图的目的是能够在跑「拓扑排序」过程中进行 `DP`,统计方案数。\n\n**定义 $f[i]$ 为从 $0$ 到达 $i$ 点的方案数,$f[n - 1]$ 为答案,同时我们有显而易见的初始化条件 $f[0] = 1$。**\n\n不失一般性考虑 $f[i]$ 如何计算,若我们存在一条从 $i$ 到 $j$ 的出边,并且 $f[i]$ 已确定更新完成(通过判断 $i$ 的入度是为 $0$ 得知,入度为 $0$ 意味着已经没有其他状态可以更新 $f[i]$),我们可以用 $f[i]$ 来更新 $f[j]$,即有 $f[j] = f[j] + f[i]$,含义将到达 $i$ 的路径数累加到到达 $j$ 的路径数中,同时更新 $j$ 的入度。\n\n代码:\n```Java\nclass Solution {\n    int N = 210, MOD = (int)1e9+7;\n    long INF = (long)1e12;\n    int[][] g = new int[N][N];\n    int[] in = new int[N];\n    long[] dist = new long[N];\n    boolean[] vis = new boolean[N];\n    int n;\n    public int countPaths(int _n, int[][] rs) {\n        n = _n;\n        for (int[] info : rs) {\n            int a = info[0], b = info[1], c = info[2];\n            g[a][b] = g[b][a] = c;\n        }\n        // 朴素 Dijkstra 求解从 0 点到其他点的最短路\n        dijkstra();\n        // 利用最短路重新建图,并统计入度\n        for (int[] info : rs) {\n            int a = info[0], b = info[1], c = info[2];\n            g[a][b] = g[b][a] = 0;\n            if (dist[a] + c == dist[b]) {\n                g[a][b] = c; in[b]++;\n            } else if (dist[b] + c == dist[a]) {\n                g[b][a] = c; in[a]++;\n            }\n        }\n        // 跑拓扑排序统计方案数\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            if (in[i] == 0) d.addLast(i);\n        }\n        int[] f = new int[n];\n        f[0] = 1;\n        while (!d.isEmpty()) {\n            int x = d.pollFirst();\n            for (int i = 0; i < n; i++) {\n                if (g[x][i] == 0) continue;\n                f[i] += f[x];\n                f[i] %= MOD;\n                if (--in[i] == 0) d.addLast(i);\n            }\n        }\n        return f[n - 1];\n    }\n    void dijkstra() {\n        Arrays.fill(dist, INF);\n        dist[0] = 0;\n        for (int i = 0; i < n; i++) {\n            int t = -1;\n            for (int j = 0; j < n; j++) {\n                if (!vis[j] && (t == -1 || dist[j] < dist[t])) t = j;\n            }\n            vis[t] = true;\n            for (int j = 0; j < n; j++) {\n                if (g[t][j] == 0) continue;\n                dist[j] = Math.min(dist[j], dist[t] + g[t][j]);\n            }\n        }\n    }\n}\n```\n* 时间复杂度:首次建图复杂度为 $O(m)$;Dijkstra 求最短路复杂度为 $O(n^2)$;再次建图复杂度为 $O(m)$,跑拓扑排序统计方案数复杂度为 $O(n + m)$。整体复杂度为 $O(n^2 + m)$\n* 空间复杂度:$O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1976` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1981-1990/1984. 学生分数的最小差值（简单）.md", "url_title": "1984. 学生分数的最小差值", "url": "https://leetcode-cn.com/problems/minimum-difference-between-highest-and-lowest-of-k-scores/solution/gong-shui-san-xie-pai-xu-hua-dong-chuang-ru6e/", "difficulty": "简单", "tags": ["二分", "滑动窗口"], "question": "给你一个 下标从 $0$ 开始 的整数数组 $nums$ ,其中 $nums[i]$ 表示第 $i$ 名学生的分数。另给你一个整数 $k$ 。\n\n从数组中选出任意 $k$ 名学生的分数,使这 $k$ 个分数间 **最高分** 和 **最低分** 的 差值 达到 最小化 。\n\n返回可能的 **最小差值** 。\n\n示例 1:\n```\n输入:nums = [90], k = 1\n\n输出:0\n\n解释:选出 1 名学生的分数,仅有 1 种方法:\n- [90] 最高分和最低分之间的差值是 90 - 90 = 0\n可能的最小差值是 0\n```\n示例 2:\n```\n输入:nums = [9,4,1,7], k = 2\n\n输出:2\n\n解释:选出 2 名学生的分数,有 6 种方法:\n- [9,4,1,7] 最高分和最低分之间的差值是 9 - 4 = 5\n- [9,4,1,7] 最高分和最低分之间的差值是 9 - 1 = 8\n- [9,4,1,7] 最高分和最低分之间的差值是 9 - 7 = 2\n- [9,4,1,7] 最高分和最低分之间的差值是 4 - 1 = 3\n- [9,4,1,7] 最高分和最低分之间的差值是 7 - 4 = 3\n- [9,4,1,7] 最高分和最低分之间的差值是 7 - 1 = 6\n可能的最小差值是 2\n```\n\n提示:\n* $1 <= k <= nums.length <= 1000$\n* $0 <= nums[i] <= 10^5$", "solution": "### 排序 + 滑动窗口\n\n从 $n$ 个元素里找 $k$ 个,使得 $k$ 个元素最大差值最小。\n\n**最大值最小化问题容易想到「二分」,利用答案本身具有「二段性」,来将原本的求解问题转化为判断定问题。**\n\n回到本题,容易证明,这 $k$ 个元素必然是有序数组中(排序后)的连续段。反证法,若最佳 $k$ 个选择不是连续段,能够调整为连续段,结果不会变差。\n\n因此我们可以先对 $nums$ 进行排序,然后扫描所有大小为 $k$ 的窗口,直接找到答案,而无须使用「二分」。\n\n代码(二分答案代码见 $P2$):\n```Java\nclass Solution {\n    public int minimumDifference(int[] nums, int k) {\n        Arrays.sort(nums);\n        int n = nums.length, ans = nums[k - 1] - nums[0];\n        for (int i = k; i < n; i++) {\n            ans = Math.min(ans, nums[i] - nums[i - k + 1]);\n        }\n        return ans;\n    }\n}\n```\n-\n```Java\nclass Solution {\n    int[] nums; int k;\n    public int minimumDifference(int[] _nums, int _k) {\n        nums = _nums; k = _k;\n        Arrays.sort(nums);\n        int l = 0, r = 100010;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (check(mid)) r = mid;\n            else l = mid + 1;\n        }\n        return r;\n    }\n    boolean check(int x) {\n        int n = nums.length, ans = nums[k - 1] - nums[0];\n        for (int i = k; i < n && ans > x; i++) {\n            ans = Math.min(ans, nums[i] - nums[i - k + 1]);\n        }\n        return ans <= x;\n    }\n}\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$;遍历得到答案复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1894` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1991-2000/1994. 好子集的数目（困难）.md", "url_title": "1994. 好子集的数目", "url": "https://leetcode-cn.com/problems/the-number-of-good-subsets/solution/gong-shui-san-xie-zhuang-ya-dp-yun-yong-gz4w5/", "difficulty": "困难", "tags": ["状压 DP"], "question": "给你一个整数数组 `nums`。如果 `nums` 的一个子集中,所有元素的乘积可以表示为一个或多个 互不相同的质数 的乘积,那么我们称它为 好子集 。\n\n* 比方说,如果 `nums = [1, 2, 3, 4]` :\n\t* `[2, 3]` ,`[1, 2, 3]` 和 `[1, 3]` 是 好 子集,乘积分别为 `6 = 2*3` ,`6 = 2*3` 和 `3 = 3` 。\n\t* `[1, 4]` 和 `[4]` 不是 好 子集,因为乘积分别为 `4 = 2*2` 和 `4 = 2*2` 。\n\t请你返回 `nums` 中不同的 好 子集的数目对 $10^9 + 7$ 取余 的结果。\n\n`nums` 中的 子集 是通过删除 `nums` 中一些(可能一个都不删除,也可能全部都删除)元素后剩余元素组成的数组。如果两个子集删除的下标不同,那么它们被视为不同的子集。\n\n示例 1:\n```\n输入:nums = [1,2,3,4]\n\n输出:6\n\n解释:好子集为:\n- [1,2]:乘积为 2 ,可以表示为质数 2 的乘积。\n- [1,2,3]:乘积为 6 ,可以表示为互不相同的质数 2 和 3 的乘积。\n- [1,3]:乘积为 3 ,可以表示为质数 3 的乘积。\n- [2]:乘积为 2 ,可以表示为质数 2 的乘积。\n- [2,3]:乘积为 6 ,可以表示为互不相同的质数 2 和 3 的乘积。\n- [3]:乘积为 3 ,可以表示为质数 3 的乘积。\n```\n示例 2:\n```\n输入:nums = [4,2,3,15]\n\n输出:5\n\n解释:好子集为:\n- [2]:乘积为 2 ,可以表示为质数 2 的乘积。\n- [2,3]:乘积为 6 ,可以表示为互不相同质数 2 和 3 的乘积。\n- [2,15]:乘积为 30 ,可以表示为互不相同质数 2,3 和 5 的乘积。\n- [3]:乘积为 3 ,可以表示为质数 3 的乘积。\n- [15]:乘积为 15 ,可以表示为互不相同质数 3 和 5 的乘积。\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $1 <= nums[i] <= 30$", "solution": "### 状压 DP\n\n该问题属于 NP 完全问题,注定不存在多项式解决方案,只能通过「爆搜 + 剪枝」或「状压 DP」来求解。\n\n对子集的乘积进行质数分解,等价于对子集每一位数进行质数分解。\n\n一个显然的突破口是 $1 <= nums[i] <= 30$,再加上题目对于「好子集」的定义,我们可以进一步缩减可选数的数量,不超过 $30$ 的质数个数包括 $[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]$(共 $10$ 个),将其记作 $p$,在一个好子集中,每个 $p[i]$ 最多出现一次。\n\n同时,题目规定数值相同,下标不同均视为不同方案,因此我们可以先使用数组 $cnts$ 统计在 $nums$ 中每个数的出现次数,$cnts[val] = x$ 含义为数值 $val$ 在 $nums$ 中的出现次数为 $x$ 次。\n\n使用的数有限(共 $10$ 个),并且使用到的数最多出现一次,容易想到使用「状压 DP」来求解:我们使用一个二进制数来表示好子集乘积最终能拆解成哪些质数,如果拆解结果中包含 $p[i]$,对应的二进制表示中的第 $i$ 位则为 $1$,否则为 $0$。\n\n**定义 $f[state]$ 为当前子集乘积拆解结果的用到的质数为 $state$ 时的方案数,$state$ 为一个长度 $10$ 的二进制数,若 $state$ 中的第 $k$ 位二进制表示为 $1$,代表数值 $p[k]$ 在拆解结果中出现过;若第 $k$ 位二进制表示为 $0$ 代表 $p[k]$ 在拆解结果中没出现过。**\n\n我们有起始化条件:空集,即 $f[0] = 1$。\n\n不失一般性考虑 $f[s]$ 该如何计算:从前往后考虑每个数值(范围 $[2, 30]$ 的数,$1$ 添加与否不对好子集产生影响,最后讨论)是否可以加入到子集中,一个数值 $t$ 能够添加到子集中的充要条件为题目给定的条件:**该数不会被相同的质数相乘表示**。\n\n如果一个数值 $t$ 能够添加到好子集中,我们通过「试除法」将其分解为 $p$ 中的多个质数,并使用二进制数 $cur$ 来表示用到了 $p$ 中的哪些质数,然后需要判断 $t$ 能够添加到那些子集中,其实就是枚举与 $cur$ 无交集的状态 $prev$,最终的 $f[s]$ 为「所有合法的 $prev$ 的状态数 $f[prev]$」与「数值 $t$ 的出现次数 $cnts[t]$ 」的乘积之和。\n\n需要注意的是,由于我们是从范围 $[2, 30]$ 范围内从前往后考虑每个 $t$,因此**在枚举 $prev$ 时需要进行倒序遍历,确保计算 $f[s]$ 所依赖的 $f[prev]$ 为不考虑当前数值 $t$ 时的方案数**。\n\n由「质数 $p$ 组成的好子集方案数」为 $ans = \\sum_{state' = 1}^{{1024}} f[state']$,其中 $state'$ 对应一个合法的好子集方案。\n\n在此基础上,再考虑数值 $1$ 对答案的影响:**在每个合法的 $state'$ 前提下,增加若干个 $1$ 并不影响子集乘积(即好子集增加 $1$ 后仍为好子集),因此每个合法子集 $state'$ 可以对应出 $2^{cnts[1]}$ 个具体方案(代表每个 $1$ 即可以选,也可以不选)**。\n\n代码:\n```Java\nclass Solution {\n    int MOD = (int)1e9+7;\n    int[] p = new int[]{2, 3, 5, 7, 11, 13, 17, 19, 23, 29};\n    int[] cnts = new int[35];\n    public int numberOfGoodSubsets(int[] nums) {\n        int n = nums.length;\n        for (int i : nums) cnts[i]++;\n        int mask = 1 << 10;\n        long[] f = new long[mask];\n        f[0] = 1;\n        for (int i = 2; i <= 30; i++) {\n            if (cnts[i] == 0) continue;\n            // 对 i 进行试除\n            int cur = 0, x = i;\n            boolean ok = true;\n            for (int j = 0; j < 10 && ok; j++) {\n                int t = p[j], c = 0;\n                while (x % t == 0) {\n                    cur |= (1 << j);\n                    x /= t; c++;\n                }\n                // 如果 i 能够被同一质数试除多次,说明 i 不能加到子集,跳过\n                if (c > 1) ok = false;\n            }\n            if (!ok) continue;\n            // 枚举前一状态 prev\n            //(确保考虑一个新数值 i 时,依赖的子集 prev 存储的为尚未考虑 i 的方案数)\n            for (int prev = mask - 1; prev >= 0; prev--) {\n                // 只有当前选择数与前一状态不冲突,则能够进行转移,将方案数进行累加\n                if ((prev & cur) != 0) continue;\n                f[prev | cur] = (f[prev | cur] + f[prev] * cnts[i]) % MOD;\n            }\n        }\n        long ans = 0;\n        // 统计所有非空集的方案数\n        for (int i = 1; i < mask; i++) ans = (ans + f[i]) % MOD;\n        // 在此基础上,考虑每个 1 选择与否对答案的影响\n        for (int i = 0; i < cnts[1]; i++) ans = ans * 2 % MOD;\n        return (int) ans;\n    }\n}\n```\n* 时间复杂度:预处理每个数值的出现次数复杂度为 $O(n)$;令数值范围 $C = 30$,状态数为 $M = 1024$,DP 部分复杂度为 $O(C \\times M)$。整体复杂度为 $O(n + C \\times M)$\n* 空间复杂度:$O(C + M)$\n\n---\n\n### 关于「倒序遍历」状态的答疑\n\n上述的分析推理基于我们进行了「一维空间优化」。\n\n原始的状态定义应该是 **$f[i][state]$ 为考虑范围在 $[1,30]$ 的前 $i$ 个数,并且好子集拆解结果的用到的质数为 $state$ 时的方案数。**\n\n我们有显然的初始化条件:$f[1][0] = 1$,代表当只有数值 $1$ 的话,只有空集为合法方案。\n\n不失一般性的考虑 $f[i][s]$ 该如何计算,根据使用数值 $i$ 来进行分情况讨论:\n\n* 不考虑数值 $i$(或是数值 $i$ 在 $nums$ 中没有出现,无法考虑),则有 $f[i][s] = f[i - 1][s]$;\n* 考虑数值 $i$,分析方法同「一维空间优化」,对数值 $i$ 应用「试除法」拆解成对应的质数状态 $cur$,然后找到可以转移的前一状态 $prev$ 来尝试转移,则有 $f[i][cur | prev] = f[i][cur | prev] + f[i - 1][prev]$。\n\n基于对「原始状态定义」的分析,我们发现 $f[i][cur | prev]$ 的更新(累加)依赖于 $f[i][prev]$,同时 $prev$ 是 $cur | prev$ 的子集,因此在进行「一维空间优化」,我们需要确保所依赖的状态没有被覆盖更新,即采用「倒序遍历」。\n\n代码:\n```Java\nclass Solution {\n    int MOD = (int)1e9+7;\n    int[] p = new int[]{2, 3, 5, 7, 11, 13, 17, 19, 23, 29};\n    int[] cnts = new int[35];\n    public int numberOfGoodSubsets(int[] nums) {\n        for (int i : nums) cnts[i]++;\n        int mask = 1 << 10;\n        long[][] f = new long[35][mask];\n        f[1][0] = 1;\n        for (int i = 2; i <= 30; i++) {\n            for (int s = 0; s < mask; s++) f[i][s] = f[i - 1][s];\n            if (cnts[i] == 0) continue;\n            int cur = 0, x = i;\n            boolean ok = true;\n            for (int j = 0; j < 10 && ok; j++) {\n                int t = p[j], c = 0;\n                while (x % t == 0) {\n                    cur |= (1 << j);\n                    x /= t; c++;\n                }\n                if (c > 1) ok = false;\n            }\n            if (!ok) continue;\n            for (int prev = 0; prev < mask; prev++) {\n                if ((prev & cur) != 0) continue;\n                f[i][prev | cur] = (f[i][prev | cur] + f[i - 1][prev] * cnts[i]) % MOD;\n            }\n        }\n        long ans = 0;\n        for (int i = 1; i < mask; i++) ans = (ans + f[30][i]) % MOD;\n        for (int i = 0; i < cnts[1]; i++) ans = ans * 2 % MOD;\n        return (int) ans;\n    }\n}\n```\n* 时间复杂度:预处理每个数值的出现次数复杂度为 $O(n)$;令数值范围 $C = 30$,状态数为 $M = 1024$,DP 部分复杂度为 $O(C \\times M)$。整体复杂度为 $O(n + C \\times M)$\n* 空间复杂度:$O(C \\times M)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1994` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1991-2000/1995. 统计特殊四元组（简单）.md", "url_title": "1995. 统计特殊四元组", "url": "https://leetcode-cn.com/problems/count-special-quadruplets/solution/gong-shui-san-xie-yi-ti-si-jie-mei-ju-ha-gmhv/", "difficulty": "简单", "tags": ["枚举", "哈希表", "背包 DP"], "question": "给你一个 下标从 `0` 开始 的整数数组 `nums`,返回满足下述条件的**不同**四元组 `(a, b, c, d)` 的 数目 :\n\n`nums[a] + nums[b] + nums[c] == nums[d]`,且 `a < b < c < d`。\n\n示例 1:\n```\n输入:nums = [1,2,3,6]\n\n输出:1\n\n解释:满足要求的唯一一个四元组是 (0, 1, 2, 3) 因为 1 + 2 + 3 == 6 。\n```\n示例 2:\n```\n输入:nums = [3,3,6,4,5]\n\n输出:0\n\n解释:[3,3,6,4,5] 中不存在满足要求的四元组。\n```\n示例 3:\n```\n输入:nums = [1,1,1,3,5]\n\n输出:4\n\n解释:满足要求的 4 个四元组如下:\n- (0, 1, 2, 3): 1 + 1 + 1 == 3\n- (0, 1, 3, 4): 1 + 1 + 3 == 5\n- (0, 2, 3, 4): 1 + 1 + 3 == 5\n- (1, 2, 3, 4): 1 + 1 + 3 == 5\n```\n\n提示:\n* $4 <= nums.length <= 50$\n* $1 <= nums[i] <= 100$", "solution": "### 朴素解法\n\n利用数据范围只有 $50$,可直接根据题意进行模拟。\n\n代码:\n```Java\nclass Solution {\n    public int countQuadruplets(int[] nums) {\n        int n = nums.length, ans = 0;\n        for (int a = 0; a < n; a++) {\n            for (int b = a + 1; b < n; b++) {\n                for (int c = b + 1; c < n; c++) {\n                    for (int d = c + 1; d < n; d++) {\n                        if (nums[a] + nums[b] + nums[c] == nums[d]) ans++;\n                    }\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^4)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 哈希表\n\n利用等式关系 $nums[a] + nums[b] + nums[c] = nums[d]$,可以调整枚举 $c$ 的顺序为「逆序」,每次 $c$ 往左移动一个单位,$d$ 的可取下标范围增加一个(即 $c + 1$ 位置),使用数组代替哈希表对 $nums[d]$ 的个数进行统计,可使复杂度下降到 $O(n^3)$。\n\n代码:\n```Java\nclass Solution {\n    public int countQuadruplets(int[] nums) {\n        int n = nums.length, ans = 0;\n        int[] cnt = new int[10010];\n        for (int c = n - 2; c >= 2; c--) {\n            cnt[nums[c + 1]]++;\n            for (int a = 0; a < n; a++) {\n                for (int b = a + 1; b < c; b++) {\n                    ans += cnt[nums[a] + nums[b] + nums[c]];\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^3)$\n* 空间复杂度:$O(C)$\n\n---\n\n### 哈希表\n\n更进一步,根据等式关系进行移项可得:$nums[a] + nums[b] = nums[d] - nums[c]$,其中各下标满足 $a < b < c < d$。\n\n我们可在「逆序」枚举 $b$ 时,将新产生的 $c$(即 $b + 1$ 位置)所能产生的新 $nums[d] - nums[c]$ 的值存入哈希表(即 从 $[b + 2, n)$ 范围内枚举 $d$),最后通过枚举 $a$ 来统计答案。\n\n> 一些细节:由于 $nums[d] - nums[c]$ 可能为负,在使用数组代替哈希表时,可利用 $1 <= nums[i] <= 100$ 做一个值偏移。\n\n代码:\n```Java\nclass Solution {\n    public int countQuadruplets(int[] nums) {\n        int n = nums.length, ans = 0;\n        int[] cnt = new int[10010];\n        for (int b = n - 3; b >= 1; b--) {\n            for (int d = b + 2; d < n; d++) cnt[nums[d] - nums[b + 1] + 200]++;\n            for (int a = 0; a < b; a++) ans += cnt[nums[a] + nums[b] + 200];\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(C)$\n\n---\n\n### 多维背包\n\n利用等式关系 $nums[a] + nums[b] + nums[c] = nums[d]$,具有明确的「数值」和「个数」关系,可将问题抽象为组合优化问题求方案数。\n\n限制组合个数的维度有两个,均为「恰好」限制,转换为「二维费用背包问题求方案数」问题。\n\n**定义 $f[i][j][k]$ 为考虑前 $i$ 个物品(下标从 $1$ 开始),凑成数值恰好 $j$,使用个数恰好为 $k$ 的方案数。**\n\n最终答案为 $\\sum_{i = 3}^{n - 1}(f[i][nums[i]][3])$,起始状态 $f[0][0][0] = 1$ 代表不考虑任何物品时,所用个数为 $0$,凑成数值为 $0$ 的方案数为 $1$。\n\n不失一般性考虑 $f[i][j][k]$ 该如何转移,根据 $nums[i - 1]$ 是否参与组合进行分情况讨论:\n\n* $nums[i - 1]$ 不参与组成,此时有:$f[i - 1][j][k]$;\n* $nums[i - 1]$ 参与组成,此时有:$f[i - 1][j - t][k - 1]$;\n\n最终 $f[i][j][k]$ 为上述两种情况之和,最终统计 $\\sum_{i = 3}^{n - 1}(f[i][nums[i]][3])$ 即是答案。\n\n> 利用 $f[i][j][k]$ 仅依赖于 $f[i - 1][j][k]$ 和 `j` `k` 维度值更小的 $f[i - 1][X][X]$,可进行维度优化,并在转移过程中统计答案。\n\n代码(维度优化见 $P2$):\n```Java\nclass Solution {\n    public int countQuadruplets(int[] nums) {\n        int n = nums.length;\n        int[][][] f = new int[n + 1][110][4];\n        f[0][0][0] = 1;\n        for (int i = 1; i <= n; i++) {\n            int t = nums[i - 1];\n            for (int j = 0; j < 110; j++) {\n                for (int k = 0; k < 4; k++) {\n                    f[i][j][k] += f[i - 1][j][k];\n                    if (j - t >= 0 && k - 1 >= 0) f[i][j][k] += f[i - 1][j - t][k - 1];\n                }\n            }\n        }\n        int ans = 0;\n        for (int i = 3; i < n; i++) ans += f[i][nums[i]][3];\n        return ans;\n    }\n}\n```\n\n```Java\nclass Solution {\n    public int countQuadruplets(int[] nums) {\n        int n = nums.length, ans = 0;\n        int[][] f = new int[110][4];\n        f[0][0] = 1;\n        for (int i = 1; i <= n; i++) {\n            int t = nums[i - 1];\n            ans += f[t][3];\n            for (int j = 109; j >= 0; j--) {\n                for (int k = 3; k >= 0; k--) {\n                    if (j - t >= 0 && k - 1 >= 0) f[j][k] += f[j - t][k - 1];\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n * 110 * 4)$\n* 空间复杂度:$O(n * 110 * 4)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1995` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1991-2000/1996. 游戏中弱角色的数量（中等）.md", "url_title": "1996. 游戏中弱角色的数量", "url": "https://leetcode-cn.com/problems/the-number-of-weak-characters-in-the-game/solution/gong-shui-san-xie-tan-xin-yun-yong-ti-by-5ok6/", "difficulty": "中等", "tags": ["贪心"], "question": "你正在参加一个多角色游戏,每个角色都有两个主要属性:攻击 和 防御 。\n\n给你一个二维整数数组 `properties`,其中 $properties[i] = [attack_i, defense_i]$ 表示游戏中第 $i$ 个角色的属性。\n\n如果存在一个其他角色的攻击和防御等级 都严格高于 该角色的攻击和防御等级,则认为该角色为 弱角色 。\n\n更正式地,如果认为角色 `i` 弱于 存在的另一个角色 `j` ,那么 $attack_j > attack_i$ 且 $defense_j > defense_i$ 。\n\n返回 **弱角色** 的数量。\n\n示例 1:\n```\n输入:properties = [[5,5],[6,3],[3,6]]\n\n输出:0\n\n解释:不存在攻击和防御都严格高于其他角色的角色。\n```\n示例 2:\n```\n输入:properties = [[2,2],[3,3]]\n\n输出:1\n\n解释:第一个角色是弱角色,因为第二个角色的攻击和防御严格大于该角色。\n```\n示例 3:\n```\n输入:properties = [[1,5],[10,4],[4,3]]\n\n输出:1\n\n解释:第三个角色是弱角色,因为第二个角色的攻击和防御严格大于该角色。\n```\n\n提示:\n* $2 <= properties.length <= 10^5$\n* $properties[i].length == 2$\n* $1 <= attacki, defensei <= 10^5$", "solution": "### 排序 + 贪心 + 计数\n\n为了方便,我们使用 `ps` 来代指 `properties`。\n\n决定角色「强弱」的维度有两个,同时由于我们只关心某个角色是否为弱角色,而不关心有多少比其(严格)强的角色有多少个。\n\n因此我们先对 `ps` 进行排序:**优先根据第一维度(攻击力)排序,在第一维度(攻击力)相同时,根据第二维度(防御力)进行排序**。\n\n由于我们统计的是「严格弱角色」,因此在从前往后处理 `ps` 过程中,要将第一维度(攻击力)相同的作为一组进行处理,假设 $[i, j)$ 为第一维度(攻击力)相同的连续段,假设当前处理到连续段 $[i, j)$ 中的第 $k$ 个角色 $ps[k]$,那么 $ps[k]$ 为弱角色的充要条件为:\n\n1. **存在比 $ps[k][0]$ 攻击力高的角色,由于我们先按照了攻击力进行排序,同时又是按照攻击相同为一组进行处理,因此这等价于当前连续段 $[i, j)$ 不是第一组,即 $i \\neq 0$;**\n2. **在满足 $1$ 的前提下,存在防御力比 $ps[k][1]$ 高的角色,由于要求弱角色为「严格」,因此我们只能在之前的组(攻击力比 $ps[k][0]$ 大的相同连续段)去找。这意味着我们在遍历过程中需要贪心地维护一个防御力的最大值 $\\max$,并在处理完相同连续段后尝试对其进行更新。**\n\n代码:\n```Java\nclass Solution {\n    public int numberOfWeakCharacters(int[][] ps) {\n        int n = ps.length, ans = 0;\n        Arrays.sort(ps, (a, b)->{\n            if (a[0] != b[0]) return b[0] - a[0];\n            return b[1] - a[1];\n        });\n        for (int i = 0, max = ps[0][1]; i < n; ) {\n            int j = i, cur = max;\n            while (j < n && ps[j][0] == ps[i][0]) {\n                if (i != 0 && ps[j][1] < max) ans++;\n                cur = Math.max(cur, ps[j][1]);\n                j++;\n            }\n            i = j; max = cur;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序的复杂度为 $O(n\\log{n})$;统计答案复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.1996` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/1991-2000/2000. 反转单词前缀（简单）.md", "url_title": "2000. 反转单词前缀", "url": "https://leetcode-cn.com/problems/reverse-prefix-of-word/solution/gong-shui-san-xie-jian-dan-shuang-zhi-zh-dp9u/", "difficulty": "简单", "tags": ["模拟", "双指针"], "question": "给你一个下标从 $0$ 开始的字符串 `word` 和一个字符 `ch` 。找出 `ch` 第一次出现的下标 `i` ,反转 `word` 中从下标 $0$ 开始、直到下标 `i` 结束(含下标 `i` )的那段字符。如果 `word` 中不存在字符 `ch` ,则无需进行任何操作。\n\n* 例如,如果 `word = \"abcdefd\"` 且 `ch = \"d\"` ,那么你应该 反转 从下标 $0$ 开始、直到下标 `3` 结束(含下标 `3` )。结果字符串将会是 `\"dcbaefd\"` 。\n\n返回 结果字符串 。\n\n示例 1:\n```\n输入:word = \"abcdefd\", ch = \"d\"\n\n输出:\"dcbaefd\"\n\n解释:\"d\" 第一次出现在下标 3 。 \n反转从下标 0 到下标 3(含下标 3)的这段字符,结果字符串是 \"dcbaefd\" 。\n```\n示例 2:\n```\n输入:word = \"xyxzxe\", ch = \"z\"\n\n输出:\"zxyxxe\"\n\n解释:\"z\" 第一次也是唯一一次出现是在下标 3 。\n反转从下标 0 到下标 3(含下标 3)的这段字符,结果字符串是 \"zxyxxe\" 。\n```\n示例 3:\n```\n输入:word = \"abcd\", ch = \"z\"\n\n输出:\"abcd\"\n\n解释:\"z\" 不存在于 word 中。\n无需执行反转操作,结果字符串是 \"abcd\" 。\n```\n\n提示:\n* $1 <= word.length <= 250$\n* `word` 由小写英文字母组成\n* `ch` 是一个小写英文字母", "solution": "### 模拟\n\n先从前往后遍历,找到第一个 `ch` 的下标 $idx$(初始值为 $-1$),然后对 $[0, idx]$ 应用双指针进行翻转(若没有 `ch` 字符,则 $idx = -1$,则 $[0, idx]$ 为不合法区间,翻转过程被跳过)。\n\n代码:\n```Java\nclass Solution {\n    public String reversePrefix(String word, char ch) {\n        char[] cs = word.toCharArray();\n        int n = cs.length, idx = -1;\n        for (int i = 0; i < n && idx == -1; i++) {\n            if (cs[i] == ch) idx = i;\n        }\n        int l = 0, r = idx;\n        while (l < r) {\n            char c = cs[l];\n            cs[l++] = cs[r];\n            cs[r--] = c;\n        }\n        return String.valueOf(cs);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:`toCharArray` 会产生新数组,复杂度为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2000` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2001-2010/2003. 每棵子树内缺失的最小基因值（困难）.md", "url_title": "2003. 每棵子树内缺失的最小基因值", "url": "https://leetcode.cn/problems/smallest-missing-genetic-value-in-each-subtree/solutions/2505877/gong-shui-san-xie-tu-jie-san-da-jie-lun-mxjrn/", "difficulty": "困难", "tags": ["DFS", "图", "脑筋急转弯"], "question": "有一棵根节点为 `0` 的 家族树 ,总共包含 `n` 个节点,节点编号为 `0` 到 `n - 1`。\n\n给你一个下标从 `0` 开始的整数数组 `parents`,其中 $parents[i]$ 是节点 `i` 的父节点。由于节点 `0` 是根 ,所以 $parents[0] = -1$。\n\n总共有 $10^5$ 个基因值,每个基因值都用 闭区间 $[1, 10^5]$ 中的一个整数表示。\n\n给你一个下标从 `0` 开始的整数数组 `nums`,其中 $nums[i]$ 是节点 `i` 的基因值,且基因值 互不相同 。\n\n请你返回一个数组 `ans`,长度为 `n`,其中 $ans[i]$ 是以节点 `i` 为根的子树内缺失的最小基因值。\n\n节点 `x` 为根的子树包含节点 `x` 和它所有的后代节点。\n\n示例 1:\n\n```\n输入:parents = [-1,0,0,2], nums = [1,2,3,4]\n\n输出:[5,1,1,1]\n\n解释:每个子树答案计算结果如下:\n- 0:子树包含节点 [0,1,2,3] ,基因值分别为 [1,2,3,4] 。5 是缺失的最小基因值。\n- 1:子树只包含节点 1 ,基因值为 2 。1 是缺失的最小基因值。\n- 2:子树包含节点 [2,3] ,基因值分别为 [3,4] 。1 是缺失的最小基因值。\n- 3:子树只包含节点 3 ,基因值为 4 。1是缺失的最小基因值。\n```\n示例 2:\n\n```\n输入:parents = [-1,0,1,0,3,3], nums = [5,4,6,2,1,3]\n\n输出:[7,1,1,4,2,1]\n\n解释:每个子树答案计算结果如下:\n- 0:子树内包含节点 [0,1,2,3,4,5] ,基因值分别为 [5,4,6,2,1,3] 。7 是缺失的最小基因值。\n- 1:子树内包含节点 [1,2] ,基因值分别为 [4,6] 。 1 是缺失的最小基因值。\n- 2:子树内只包含节点 2 ,基因值为 6 。1 是缺失的最小基因值。\n- 3:子树内包含节点 [3,4,5] ,基因值分别为 [2,1,3] 。4 是缺失的最小基因值。\n- 4:子树内只包含节点 4 ,基因值为 1 。2 是缺失的最小基因值。\n- 5:子树内只包含节点 5 ,基因值为 3 。1 是缺失的最小基因值。\n```\n示例 3:\n```\n输入:parents = [-1,2,3,0,2,4,1], nums = [2,3,4,5,6,7,8]\n\n输出:[1,1,1,1,1,1,1]\n\n解释:所有子树都缺失基因值 1 。\n```\n\n提示:\n* $n = parents.length = nums.length$\n* $2 <= n <= 10^5$\n* 对于 `i != 0`,满足 $0 <= parents[i] <= n - 1$\n* $parents[0] = -1$\n* `parents` 表示一棵合法的树。\n* $1 <= nums[i] <= 10^5$\n* `nums[i]` 互不相同。", "solution": "### DFS\n\n#### 破题\n\n先用几句话破题。\n\n共由 $n$ 个节点组成一棵树(节点编号从 $0$ 到 $n - 1$),`parents` 描述了该树的形态,同时每个节点有一个基因值 $nums[i]$。\n\n题目要我们求:**以每个节点为根的子树中,权重集合在 $[1, n + 1]$ 范围内缺失的最小数**。\n\n> 需要重点注意:是权重集合在 $[1, n + 1]$ 范围内缺失的最小数,而不是在 `nums` 中缺失的最小数。\n\n举个 🌰,假设由 $4$ 个节点组成树,基因值 `nums = [2,3,4,5]`,那么对应的 `ans = [1,1,1,1]`。\n\n再次强调:我们求的是每个节点为根的子树中,权重集合在 $[1, n + 1]$ 范围内的最小缺失值,而非在 `nums` 中的缺失值。\n\n#### 结论一:当`nums` 中没有 $1$,所有节点答案为 $1$\n\n由于我们是求 $[1, n + 1]$ 范围内的最小缺失值,当 `nums` 中不存在 $1$ 时,所有节点缺失的最小值为 $1$。\n\n#### 结论二:`nums` 有 $1$,所有该节点的“非祖先”节点,答案为 $1$\n\n基因值互不相同,同时统计的是,以每个节点为“根”时,子树的权值情况,因此节点 $1$ 只会对其“祖先”产生影响。\n\n#### 结论三:从「$1$ 节点」到「根节点」的路径中,答案必然满足“非递减”性质\n\n这个结论不明显,但不难理解。\n\n先假设存在某个节点 `X`,其最小缺失值为 $k$:\n\n再通过节点 `X` 的最小缺失值,推理出父节点 `Fa` 的情况:\n\n综上,我们只需要考虑「节点 $1$」到「根节点」这一节点答案即可。\n\n并且由于从下往上,答案非递减,我们采取「先算子节点,再算父节点」的方式。\n\n具体的,用变量 `cur` 代指当前节点,使用 `ne` 代指当前节点的子节点,`vis` 数组记录在子树中出现过的基因值,`val` 代表当前的节点的最小缺失值。\n\n一些细节:由于题目只说了 $1 \\leq nums[i] \\leq 1e5$,没说 $nums[i]$ 与 $n$ 的关系,因此我们开辟 `vis` 数组时需要开到 $100010$,或是干脆使用 `Set` 充当 `vis`。\n\nJava 代码:\n\n```Java\nclass Solution {\n    // 考虑到有不懂「链式前向星」的同学, 这里使用最简单的存图方式 {1: [2, 3]} 代表节点一有两个子节点 2 和 3\n    Map<Integer, List<Integer>> g = new HashMap<>();\n    public int[] smallestMissingValueSubtree(int[] parents, int[] nums) {\n        int n = nums.length, cur = -1;\n        int[] ans = new int[n];\n        Arrays.fill(ans, 1);\n        // 找节点 1, 建图\n        for (int i = 0; i < n; i++) {\n            if (nums[i] == 1) cur = i;\n            List<Integer> list = g.getOrDefault(parents[i], new ArrayList<>());\n            list.add(i);\n            g.put(parents[i], list);\n        }\n\n        // 若 nums 中没 1, 对应结论一\n        if (cur == -1) return ans;\n\n        boolean[] vis = new boolean[100010];\n        // 从节点 1 开始往根找(从深到浅), idx 代表当前节点, ne 代表 cur 在该链路下的子节点\n        int ne = cur, val = 1;\n        while (cur != -1) {\n            // 每次对当前节点所在子树的进行标记\n            dfs(cur, ne, nums, vis);\n            // 在 [val, n+1] 范围内找第一个未被标记基因值\n            for (int i = val; i <= n + 1; i++) {\n                if (vis[i]) continue;\n                ans[cur] = val = i;\n                break;\n            }\n            ne = cur; cur = parents[cur]; // 指针上移\n        }\n        return ans;\n    }\n    void dfs(int idx, int block, int[] nums, boolean[] vis) {\n        vis[nums[idx]] = true;\n        List<Integer> list = g.getOrDefault(idx, new ArrayList<>());\n        for (int x : list) {\n            if (x == block) continue;\n            dfs(x, block, nums, vis);\n        }\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    // 考虑到有不懂「链式前向星」的同学, 这里使用最简单的存图方式 {1: [2, 3]} 代表节点一有两个子节点 2 和 3\n    unordered_map<int, vector<int>> g;\n    vector<int> smallestMissingValueSubtree(std::vector<int>& parents, std::vector<int>& nums) {\n        int n = nums.size(), cur = -1;\n        vector<int> ans(n, 1);\n        // 找节点 1, 建图\n        for (int i = 0; i < n; i++) {\n            if (nums[i] == 1) cur = i;\n            g[parents[i]].push_back(i);\n        }\n        \n        // 若 nums 中没 1, 对应结论一\n        if (cur == -1) return ans;\n        \n        unordered_set<int> vis;\n        // 从节点 1 开始往根找(从深到浅), idx 代表当前节点, ne 代表 cur 在该链路下的子节点\n        int ne = cur, val = 1;\n        while (cur != -1) {\n            // 每次对当前节点所在子树的进行标记\n            dfs(cur, ne, nums, vis);\n            // 在 [val, n+1] 范围内找第一个未被标记基因值\n            for (int i = val; i <= n + 1; i++) {\n                if (vis.count(i)) continue;\n                ans[cur] = val = i;\n                break;\n            }\n            ne = cur; cur = parents[cur]; // 指针上移\n        }\n        return ans;\n    }\n    void dfs(int idx, int block, vector<int>& nums, unordered_set<int>& vis) {\n        vis.insert(nums[idx]);\n        for (int x : g[idx]) {\n            if (x == block) continue;\n            dfs(x, block, nums, vis);\n        }\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def smallestMissingValueSubtree(self, parents: List[int], nums: List[int]) -> List[int]:\n        # 虑到有不懂「链式前向星」的同学, 这里使用最简单的存图方式 {1: [2, 3]} 代表节点 1 有两个子节点 2 和 3\n        g = defaultdict(list)\n\n        def dfs(idx, block):\n            nonlocal val\n            vis.add(nums[idx])\n            for x in g[idx]:\n                if x == block:\n                    continue\n                dfs(x, block)\n        \n        n, cur = len(nums), -1\n        ans = [1] * n\n        # 找节点 1, 建图\n        for i in range(n):\n            if nums[i] == 1:\n                cur = i\n            g[parents[i]].append(i)\n        \n        # 若 nums 中没 1, 对应结论一\n        if cur == -1:\n            return ans\n        \n        vis = set()\n        # 从节点 1 开始往根找(从深到浅), idx 代表当前节点, ne 代表 cur 在该链路下的子节点\n        ne, val = cur, 1\n        while cur != -1:\n            # 每次对当前节点所在子树的进行标记\n            dfs(cur, ne)\n            # 在 [val, n+1] 范围内找第一个未被标记基因值\n            for i in range(val, n + 2):\n                if i in vis:\n                    continue\n                ans[cur] = val = i\n                break\n            ne, cur = cur, parents[cur]  # 指针上移\n\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction smallestMissingValueSubtree(parents: number[], nums: number[]): number[] {\n    // 考虑到有不懂「链式前向星」的同学, 这里使用最简单的存图方式 {1: [2, 3]} 代表节点 1 有两个子节点 2 和 3\n    const g = {};\n\n    const dfs = function (g: { [key: number]: number[] }, idx: number, block: number, nums: number[], vis: Set<number>): void {\n        vis.add(nums[idx]);\n        if (Array.isArray(g[idx])) {\n            for (let x of g[idx]) {\n                if (x == block) continue;\n                dfs(g, x, block, nums, vis);\n            }\n        }\n    }\n\n    let n = nums.length, cur = -1;\n    const ans = new Array(n).fill(1);\n    \n    // 找节点 1, 建图\n    for (let i = 0; i < n; i++) {\n        if (nums[i] === 1) cur = i;\n        if (!g[parents[i]]) g[parents[i]] = [];\n        g[parents[i]].push(i);\n    }\n    \n    // 若 nums 中没 1, 对应结论一\n    if (cur == -1) return ans;\n    \n    const vis = new Set<number>();\n    // 从节点 1 开始往根找(从深到浅), idx 代表当前节点, ne 代表 cur 在该链路下的子节点\n    let ne = cur, val = 1;    \n    while (cur !== -1) {\n        // 每次对当前节点所在子树的进行标记\n        dfs(g, cur, ne, nums, vis);\n        // 在 [val, n+1] 范围内找第一个未被标记基因值\n        for (let i = val; i <= n + 1; i++) {\n            if (vis.has(i)) continue;\n            ans[cur] = val = i;\n            break;\n        }\n        ne = cur; cur = parents[cur];  // 指针上移\n    }\n    \n    return ans;\n}\n```\nJava 代码(链式向前星,使用 `Set` 充当 `vis`):\n```Java\nclass Solution {\n    int N = 100010, M = N, idx = 1;\n    int[] he = new int[N], e = new int[M], ne = new int[M];\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    public int[] smallestMissingValueSubtree(int[] parents, int[] nums) {\n        Arrays.fill(he, -1);\n        int n = parents.length, cur = -1, val = 1;\n        int[] ans = new int[n];\n        Arrays.fill(ans, 1);\n        for (int i = 0; i < n; i++) {\n            if (i >= 1) add(parents[i], i);\n            if (nums[i] == 1) cur = i;\n        }\n        if (cur == -1) return ans;\n        Set<Integer> vis = new HashSet();\n        while (cur != -1) {\n            dfs(cur, vis, nums);\n            for (int i = val; i <= n + 1; i++) {\n                if (vis.contains(i)) continue;\n                ans[cur] = val = i;\n                break;\n            }\n            cur = parents[cur];\n        }\n        return ans;\n    }\n    void dfs(int u, Set<Integer> vis, int[] nums) {\n        vis.add(nums[u]);\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (vis.contains(nums[j])) continue;\n            dfs(j, vis, nums);\n        }\n    }\n}\n```\n* 时间复杂度:找 $1$ 和建图的复杂度为 $O(n)$;构造从根节点到 $1$节点的链条答案时,会对子树节点进行标记,同时每个节点的答案会从 $[val, n + 1]$ 范围内找缺失值,复杂度为 $O(n)$。 整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2003` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2001-2010/2006. 差的绝对值为 K 的数对数目（简单）.md", "url_title": "2006. 差的绝对值为 K 的数对数目", "url": "https://leetcode-cn.com/problems/count-number-of-pairs-with-absolute-difference-k/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-1jel/", "difficulty": "简单", "tags": ["模拟", "哈希表"], "question": "给你一个整数数组 `nums` 和一个整数 `k` ,请你返回数对 $(i, j)$ 的数目,满足 $i < j$ 且`|nums[i] - nums[j]| == k`。\n\n`|x|` 的值定义为:\n\n* 如果 $x >= 0$ ,那么值为 $x$ 。\n* 如果 $x < 0$ ,那么值为 $-x$ 。\n\n示例 1:\n```\n输入:nums = [1,2,2,1], k = 1\n\n输出:4\n\n解释:差的绝对值为 1 的数对为:\n- [1,2,2,1]\n- [1,2,2,1]\n- [1,2,2,1]\n- [1,2,2,1]\n```\n示例 2:\n```\n输入:nums = [1,3], k = 3\n\n输出:0\n\n解释:没有任何数对差的绝对值为 3 。\n```\n示例 3:\n```\n输入:nums = [3,2,1,5,4], k = 2\n\n输出:3\n\n解释:差的绝对值为 2 的数对为:\n- [3,2,1,5,4]\n- [3,2,1,5,4]\n- [3,2,1,5,4]\n```\n\n提示:\n* $1 <= nums.length <= 200$\n* $1 <= nums[i] <= 100$\n* $1 <= k <= 99$", "solution": "### 朴素解法\n\n数据范围很小,直接根据题意模拟即可。\n\n代码:\n```Java\nclass Solution {\n    public int countKDifference(int[] nums, int k) {\n        int n = nums.length, ans = 0;\n        for (int i = 0; i < n; i++) {\n            for (int j = i + 1; j < n; j++) {\n                if (Math.abs(nums[i] - nums[j]) == k) ans++;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 哈希表\n\n对于每个 $t = nums[j]$ 而言,是要找与其相对差值为 $k$ 且下标比其小的数(即 $t - k$ 和 $t + k$),可以采取边遍历边记录某个数出现次数,从而将复杂度优化到 $O(n)$。\n\n再利用数据范围 $1 <= nums[i] <= k$,可以直接使用数组充当哈希表。\n\n代码:\n```Java\nclass Solution {\n    public int countKDifference(int[] nums, int k) {\n        int[] cnts = new int[110];\n        int n = nums.length, ans = 0;\n        for (int i = 0; i < n; i++) {\n            int t = nums[i];\n            if (t - k >= 1) ans += cnts[t - k];\n            if (t + k <= 100) ans += cnts[t + k];\n            cnts[t]++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2006` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/201-210/203. 移除链表元素（简单）.md", "url_title": "203. 移除链表元素", "url": "https://leetcode-cn.com/problems/remove-linked-list-elements/solution/gong-shui-san-xie-yi-chu-lian-biao-yuan-ca6fu/", "difficulty": "简单", "tags": ["链表"], "question": "给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。\n\n示例 1:\n\n```\n输入:head = [1,2,6,3,4,5,6], val = 6\n输出:[1,2,3,4,5]\n```\n示例 2:\n```\n输入:head = [], val = 1\n输出:[]\n```\n示例 3:\n```\n输入:head = [7,7,7,7], val = 7\n输出:[]\n```\n\n提示:\n* 列表中的节点在范围 [0, $10^4$] 内\n* 1 <= Node.val <= 50\n* 0 <= k <= 50", "solution": "### 递归\n\n一个直观的做法是:写一个递归函数来将某个值为 `val` 的节点从链表中移除。\n\n由于是单链表,无法通过某个节点直接找到「前一个节点」,因此为了方便,我们可以为递归函数多设置一个入参,代表「前一个节点」。\n\n代码:\n```Java\nclass Solution {\n    public ListNode removeElements(ListNode head, int val) {\n        ListNode dummy = new ListNode(-1);\n        dummy.next = head;\n        dfs(dummy, dummy.next, val);\n        return dummy.next;\n    }\n    void dfs(ListNode prev, ListNode root, int val) {\n        if (root == null) return ;\n        if (root.val == val) {\n            prev.next = root.next;\n        } else {\n            prev = root;\n        }\n        dfs(prev, prev.next, val);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:忽略递归带来的额外空间开销。复杂度为 $O(1)$\n\n---\n\n### 迭代\n\n同理,我们可以使用「迭代」方式来实现,而迭代有 `while` 和 `for` 两种写法。\n\n代码:\n```Java\nclass Solution {\n    public ListNode removeElements(ListNode head, int val) {\n        ListNode dummy = new ListNode(-1);\n        dummy.next = head;\n        for (ListNode tmp = dummy.next, prev = dummy; tmp != null; tmp = tmp.next) {\n            if (tmp.val == val) {\n                prev.next = tmp.next;\n            } else {\n                prev = tmp;\n            }\n        }\n        return dummy.next;\n    }\n}\n```\n```Java\nclass Solution {\n    public ListNode removeElements(ListNode head, int val) {\n        ListNode dummy = new ListNode(-1);\n        dummy.next = head;\n        ListNode tmp = dummy.next, prev = dummy;\n        while (tmp != null) {\n            if (tmp.val == val) {\n                prev.next = tmp.next;\n            } else {\n                prev = tmp;\n            }\n            tmp = tmp.next;\n        }\n        return dummy.next;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.203` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/201-210/207. 课程表（中等）.md", "url_title": "207. 课程表", "url": "https://leetcode.cn/problems/course-schedule/solution/by-ac_oier-byxo/", "difficulty": "中等", "tags": ["图论", "拓扑排序"], "question": "你这个学期必须选修 `numCourses` 门课程,记为 $0$ 到 $numCourses - 1$ 。\n\n在选修某些课程之前需要一些先修课程。 先修课程按数组 `prerequisites` 给出,其中 $prerequisites[i] = [a_i, b_i]$ ,表示如果要学习课程 $a_i$ 则 必须 先学习课程  $b_i$ 。\n\n* 例如,先修课程对 $[0, 1$] 表示:想要学习课程 $0$ ,你需要先完成课程 $1$ 。\n\n请你判断是否可能完成所有课程的学习?如果可以,返回 `true`;否则,返回 `false`。\n\n示例 1:\n```\n输入:numCourses = 2, prerequisites = [[1,0]]\n\n输出:true\n\n解释:总共有 2 门课程。学习课程 1 之前,你需要完成课程 0 。这是可能的。\n```\n示例 2:\n```\n输入:numCourses = 2, prerequisites = [[1,0],[0,1]]\n\n输出:false\n\n解释:总共有 2 门课程。学习课程 1 之前,你需要先完成​课程 0 ;并且学习课程 0 之前,你还应先完成课程 1 。这是不可能的。\n```\n\n提示:\n* $1 <= numCourses <= 10^5$\n* $0 <= prerequisites.length <= 5000$\n* $prerequisites[i].length == 2$\n* $0 <= a_i, b_i < numCourses$\n* `prerequisites[i]` 中的所有课程对 互不相同", "solution": "### 拓扑排序\n\n为了方便,我们记 `numCourses` 为 `n`,`prerequisites` 为 `g`。\n\n若课程 `a` 存在前置课程 `b` 的话,我们添加一条从 `b` 到 `a` 的有向边,同时统计所有点的入度。\n\n当处理完所有的 $g[i]$ 后,将所有的入度为 $0$ 的课程(含义为没有前置课程要求的科目)进行入队操作,跑一遍「拓扑排序」,若所有课程都能顺利出队,说明所有课程都能使完成。\n\n代码:\n```Java\nclass Solution {\n    int N = 100010, M = 5010;\n    int[] in = new int[N], he = new int[N], e = new int[M], ne = new int[M];\n    int idx;\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n        in[b]++;\n    }\n    public boolean canFinish(int n, int[][] g) {\n        Arrays.fill(he, -1);\n        for (int[] info : g) add(info[1], info[0]);\n        int ans = 0;\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            if (in[i] == 0) d.addLast(i);\n        }\n        while (!d.isEmpty()) {\n            int t = d.pollFirst();\n            ans++;\n            for (int i = he[t]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (--in[j] == 0) d.addLast(j);\n            }\n        }\n        return ans == n;\n    }\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.207` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/201-210/208. 实现 Trie (前缀树)（中等）.md", "url_title": "208. 实现 Trie (前缀树)", "url": "https://leetcode-cn.com/problems/implement-trie-prefix-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-we-esm9/", "difficulty": "中等", "tags": ["字典树"], "question": "Trie(发音类似 \"try\")或者说 前缀树 是一种树形数据结构,用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景,例如自动补完和拼写检查。\n\n请你实现 Trie 类:\n\n* Trie() 初始化前缀树对象。\n* void insert(String word) 向前缀树中插入字符串 word 。\n* boolean search(String word) 如果字符串 word 在前缀树中,返回 true(即,在检索之前已经插入);否则,返回 false 。\n* boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ,返回 true ;否则,返回 false 。\n\n示例:\n```\n输入\n[\"Trie\", \"insert\", \"search\", \"search\", \"startsWith\", \"insert\", \"search\"]\n[[], [\"apple\"], [\"apple\"], [\"app\"], [\"app\"], [\"app\"], [\"app\"]]\n\n输出\n[null, null, true, false, true, null, true]\n\n解释\nTrie trie = new Trie();\ntrie.insert(\"apple\");\ntrie.search(\"apple\");   // 返回 True\ntrie.search(\"app\");     // 返回 False\ntrie.startsWith(\"app\"); // 返回 True\ntrie.insert(\"app\");\ntrie.search(\"app\");     // 返回 True\n```\n\n提示:\n* 1 <= word.length, prefix.length <= 2000\n* word 和 prefix 仅由小写英文字母组成\n* insert、search 和 startsWith 调用次数 总计 不超过 3 * $10^4$ 次", "solution": "### Trie 树\n\n$Trie$ 树(又叫「前缀树」或「字典树」)是一种用于快速查询「某个字符串/字符前缀」是否存在的数据结构。\n\n其核心是使用「边」来代表有无字符,使用「点」来记录是否为「单词结尾」以及「其后续字符串的字符是什么」。\n\n---\n\n### 二维数组\n\n一个朴素的想法是直接使用「二维数组」来实现 $Trie$ 树。\n\n* 使用二维数组 $trie[]$ 来存储我们所有的单词字符。\n* 使用 $index$ 来自增记录我们到底用了多少个格子(相当于给被用到格子进行编号)。\n* 使用 $count[]$ 数组记录某个格子被「被标记为结尾的次数」(当 $idx$ 编号的格子被标记了 $n$ 次,则有 $cnt[idx] = n$)。\n\n代码 :\n```java []\nclass Trie {\n    int N = 100009; // 直接设置为十万级\n    int[][] trie;\n    int[] count;\n    int index;\n\n    public Trie() {\n        trie = new int[N][26];\n        count = new int[N];\n        index = 0;\n    }\n    \n    public void insert(String s) {\n        int p = 0;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (trie[p][u] == 0) trie[p][u] = ++index;\n            p = trie[p][u];\n        }\n        count[p]++;\n    }\n    \n    public boolean search(String s) {\n        int p = 0;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (trie[p][u] == 0) return false;\n            p = trie[p][u];\n        }\n        return count[p] != 0;\n    }\n    \n    public boolean startsWith(String s) {\n        int p = 0;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (trie[p][u] == 0) return false;\n            p = trie[p][u];\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$Trie$ 树的每次调用时间复杂度取决于入参字符串的长度。复杂度为 $O(Len)$。\n* 空间复杂度:二维数组的高度为 $n$,字符集大小为 $k$。复杂度为 $O(nk)$。\n\n---\n\n### TrieNode\n\n相比二维数组,更加常规的做法是建立 $TrieNode$ 结构节点。\n\n随着数据的不断插入,根据需要不断创建 $TrieNode$ 节点。\n\n代码:\n```java []\nclass Trie {\n    class TrieNode {\n        boolean end;\n        TrieNode[] tns = new TrieNode[26];\n    }\n\n    TrieNode root;\n    public Trie() {\n        root = new TrieNode();\n    }\n\n    public void insert(String s) {\n        TrieNode p = root;\n        for(int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (p.tns[u] == null) p.tns[u] = new TrieNode();\n            p = p.tns[u]; \n        }\n        p.end = true;\n    }\n\n    public boolean search(String s) {\n        TrieNode p = root;\n        for(int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (p.tns[u] == null) return false;\n            p = p.tns[u]; \n        }\n        return p.end;\n    }\n\n    public boolean startsWith(String s) {\n        TrieNode p = root;\n        for(int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (p.tns[u] == null) return false;\n            p = p.tns[u]; \n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$Trie$ 树的每次调用时间复杂度取决于入参字符串的长度。复杂度为 $O(Len)$。\n* 空间复杂度:结点数量为 $n$,字符集大小为 $k$。复杂度为 $O(nk)$。\n\n---\n\n### 两种方式的对比\n\n使用「二维数组」的好处是写起来飞快,同时没有频繁 $new$ 对象的开销。但是需要根据数据结构范围估算我们的「二维数组」应该开多少行。\n\n坏处是使用的空间通常是「$TrieNode$」方式的数倍,而且由于通常对行的估算会很大,导致使用的二维数组开得很大,如果这时候每次创建 $Trie$ 对象时都去创建数组的话,会比较慢,而且当样例多的时候甚至会触发 $GC$(因为 $OJ$ 每测试一个样例会创建一个 $Trie$ 对象)。\n\n因此还有一个小技巧是将使用到的数组转为静态,然后利用 $index$ 自增的特性在初始化 $Trie$ 时执行清理工作 & 重置逻辑。\n\n这样的做法能够使评测时间降低一半,运气好的话可以得到一个与「$TrieNode$」方式差不多的时间。\n\n```java []\nclass Trie {\n    // 以下 static 成员独一份,被创建的多个 Trie 共用\n    static int N = 100009; // 直接设置为十万级\n    static int[][] trie = new int[N][26];\n    static int[] count = new int[N];\n    static int index = 0;\n\n    // 在构造方法中完成重置 static 成员数组的操作\n    // 这样做的目的是为减少 new 操作(无论有多少测试数据,上述 static 成员只会被 new 一次)\n    public Trie() {\n        for (int row = index; row >= 0; row--) {\n            Arrays.fill(trie[row], 0);\n        }\n        Arrays.fill(count, 0);\n        index = 0;\n    }\n    \n    public void insert(String s) {\n        int p = 0;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (trie[p][u] == 0) trie[p][u] = ++index;\n            p = trie[p][u];\n        }\n        count[p]++;\n    }\n    \n    public boolean search(String s) {\n        int p = 0;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (trie[p][u] == 0) return false;\n            p = trie[p][u];\n        }\n        return count[p] != 0;\n    }\n    \n    public boolean startsWith(String s) {\n        int p = 0;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (trie[p][u] == 0) return false;\n            p = trie[p][u];\n        }\n        return true;\n    }\n}\n\n```\n\n---\n\n### 关于「二维数组」是如何工作 & 1e5 大小的估算\n\n要搞懂为什么行数估算是 1e5,首先要搞清楚「二维数组」是如何工作的。\n\n在「二维数组」中,我们是通过 $index$ 自增来控制使用了多少行的。\n\n当我们有一个新的字符需要记录,我们会将 $index$ 自增(代表用到了新的一行),然后将这新行的下标记录到当前某个前缀的格子中。\n\n举个🌰,假设我们先插入字符串 `abc` 这时候,前面三行会被占掉。\n\n* 第 0 行 `a` 所对应的下标有值,值为 1,代表前缀 `a` 后面接的字符串会被记录在下标为 1 的行内\n\n* 第 1 行 `b` 所对应的下标有值,值为 2,代表前缀 `ab` 后面接的字符串会被记录在下标为 2 的行内\n\n* 第 2 行 `c` 所对应的下标有值,值为 3,代表前缀 `abc` 后面接的字符串会被记录在下标为 3 的行内\n\n当再插入 `abcl` 的时候,这时候会先定位到 `abl` 的前缀行(第 3 行),将 `l` 的下标更新为 4,代表 `abcl` 被加入前缀树,并且前缀 `abcl` 接下来会用到第 4 行进行记录。\n\n但当插入 `abl` 的时候,则会定位到 `ab` 的前缀行(第 2 行),然后将 `l` 的下标更新为 5,代表 `abl` 被加入前缀树,并且前缀 `abl` 接下来会使用第 5 行进行记录。\n\n当搞清楚了「二维数组」是如何工作之后,我们就能开始估算会用到多少行了,调用次数为 $10^4$,传入的字符串长度为 $10^3$,假设每一次的调用都是 $insert$,并且每一次调用都会使用到新的 $10^3$ 行。那么我们的行数需要开到 $10^7$。\n\n**但由于我们的字符集大小只有 26,因此不太可能在 $10^4$ 次调用中都用到新的 $10^3$ 行。**\n\n**而且正常的测试数据应该是 $search$ 和 $startsWith$ 调用次数大于 $insert$ 才有意义的,一个只有 $insert$ 调用的测试数据,任何实现方案都能 AC。**\n\n**因此我设定了 $10^5$ 为行数估算,当然直接开到 $10^6$ 也没有问题。**\n\n---\n\n### 关于 Trie 的应用面\n\n首先,在纯算法领域,前缀树算是一种较为常用的数据结构。\n\n不过如果在工程中,不考虑前缀匹配的话,基本上使用 hash 就能满足。\n\n如果考虑前缀匹配的话,工程也不会使用 Trie 。\n\n一方面是字符集大小不好确定(题目只考虑 26 个字母,字符集大小限制在较小的 26 内)因此可以使用 Trie,但是工程一般兼容各种字符集,一旦字符集大小很大的话,Trie 将会带来很大的空间浪费。\n\n另外,对于个别的超长字符 Trie 会进一步变深。\n\n这时候如果 Trie 是存储在硬盘中,Trie 结构过深带来的影响是多次随机 IO,随机 IO 是成本很高的操作。\n\n同时 Trie 的特殊结构,也会为分布式存储将会带来困难。\n\n因此在工程领域中 Trie 的应用面不广。\n\n至于一些诸如「联想输入」、「模糊匹配」、「全文检索」的典型场景在工程主要是通过 ES (ElasticSearch) 解决的。\n\n而 ES 的实现则主要是依靠「倒排索引」", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.208` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/201-210/209. 长度最小的子数组（中等）.md", "url_title": "209. 长度最小的子数组", "url": "https://leetcode-cn.com/problems/implement-trie-prefix-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-we-esm9/", "difficulty": "中等", "tags": ["前缀和", "二分", "滑动窗口"], "question": "给定一个含有 `n` 个正整数的数组和一个正整数 `target`。\n\n找出该数组中满足其和 `≥ target` 的长度最小的 连续子数组 $[nums_l, nums_{l+1}, ..., nums_{r-1}, nums_r]$ ,并返回其长度。如果不存在符合条件的子数组,返回 $0$ 。\n\n示例 1:\n```\n输入:target = 7, nums = [2,3,1,2,4,3]\n\n输出:2\n\n解释:子数组 [4,3] 是该条件下的长度最小的子数组。\n```\n示例 2:\n```\n输入:target = 4, nums = [1,4,4]\n\n输出:1\n```\n示例 3:\n```\n输入:target = 11, nums = [1,1,1,1,1,1,1,1]\n\n输出:0\n```\n\n提示:\n* $1 <= target <= 10^9$\n* $1 <= nums.length <= 10^5$\n* $1 <= nums[i] <= 10^5$", "solution": "### 前缀和 + 二分\n\n利用 $nums[i]$ 的数据范围为 $[1, 10^5]$,可知前缀和数组满足「单调递增」。\n\n我们先预处理出前缀和数组 `sum`(前缀和数组下标默认从 $1$ 开始),对于每个 $nums[i]$ 而言,假设其对应的前缀和值为 $s = sum[i + 1]$,我们将 $nums[i]$ 视为子数组的右端点,问题转换为:在前缀和数组下标 $[0, i]$ 范围内找到满足「**值小于等于 $s - t$**」的最大下标,充当子数组左端点的前一个值。\n\n利用前缀和数组的「单调递增」(即具有二段性),该操作可使用「二分」来做。\n\nJava 代码:\n```Java\nclass Solution {\n    public int minSubArrayLen(int t, int[] nums) {\n        int n = nums.length, ans = n + 10;\n        int[] sum = new int[n + 10];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n        for (int i = 1; i <= n; i++) {\n            int d = sum[i] - t;\n            int l = 0, r = i;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (sum[mid] <= d) l = mid;\n                else r = mid - 1;\n            }\n            if (sum[r] <= d) ans = Math.min(ans, i - r);\n        }\n        return ans == n + 10 ? 0 : ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int minSubArrayLen(int t, vector<int>& nums) {\n        int n = nums.size(), ans = n + 10;\n        vector<int> sum(n + 10, 0);\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];      \n        for (int i = 1; i <= n; i++) {\n            int d = sum[i] - t;\n            int l = 0, r = i;\n            while (l < r) {\n                int mid = (l + r + 1) >> 1;\n                if (sum[mid] <= d) l = mid;\n                else r = mid - 1;\n            }\n            if (sum[r] <= d) ans = min(ans, i - r);\n        }\n        return ans == n + 10 ? 0 : ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minSubArrayLen(self, t: int, nums: List[int]) -> int:\n        n, ans = len(nums), len(nums) + 10\n        s = [0] * (n + 10)\n        for i in range(1, n + 1):\n            s[i] = s[i - 1] + nums[i - 1]\n        for i in range(1, n + 1):\n            d = s[i] - t\n            l, r = 0, i\n            while l < r:\n                mid = (l + r + 1) // 2\n                if s[mid] <= d:\n                    l = mid\n                else:\n                    r = mid - 1\n            if s[r] <= d: \n                ans = min(ans, i - r)\n        return 0 if ans == n + 10 else ans\n```\nTypeScript 代码:\n```TypeScript\nfunction minSubArrayLen(t: number, nums: number[]): number {\n    let n = nums.length, ans = n + 10;\n    const sum = new Array(n + 10).fill(0);\n    for (let i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n    for (let i = 1; i <= n; i++) {\n        const d = sum[i] - t;\n        let l = 0, r = i;\n        while (l < r) {\n            const mid = l + r + 1 >> 1;\n            if (sum[mid] <= d) l = mid;    \n            else r = mid - 1;\n        }\n        if (sum[r] <= d) ans = Math.min(ans, i - r);\n    }\n    return ans == n + 10 ? 0 : ans;\n};\n```\n* 时间复杂度:预处理前缀和数组的复杂度为 $O(n)$,遍历前缀和数组统计答案复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 滑动窗口\n\n另外一个,复杂度比 $O(n\\log{n})$ 更低的做法,是滑动窗口。\n\n在一次遍历过程中,使用 `j` 和 `i` 分别代表窗口的左右端点,变量 `c` 用于记录窗口内的数值总和。\n\n遍历过程其实就是右端点 `i` 不断右移的过程,每次将当前右端点 `i` 的值累加到 `c` 上,若累加后,左端点右移仍能满足「总和大于等于 `t`」的要求,那么我们则让左端点 `j` 右移。\n\n如此一来,我们便得到了每个右端点 `i` 固定时,下标最大的合法左端点 `j`(若有)。所有合法窗口长度的最小值即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int minSubArrayLen(int t, int[] nums) {\n        int n = nums.length, ans = n + 10;\n        for (int i = 0, j = 0, c = 0; i < n; i++) {\n            c += nums[i];\n            while (j < i && c - nums[j] >= t) c -= nums[j++];\n            if (c >= t) ans = Math.min(ans, i - j + 1);\n        }\n        return ans > n ? 0 : ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.209` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2011-2020/2013. 检测正方形（中等）.md", "url_title": "2013. 检测正方形", "url": "https://leetcode-cn.com/problems/detect-squares/solution/gong-shui-san-xie-jian-dan-ha-xi-biao-yu-748e/", "difficulty": "中等", "tags": ["哈希表"], "question": "给你一个在 X-Y 平面上的点构成的数据流。设计一个满足下述要求的算法:\n\n* 添加 一个在数据流中的新点到某个数据结构中。可以添加 重复 的点,并会视作不同的点进行处理。\n* 给你一个查询点,请你从数据结构中选出三个点,使这三个点和查询点一同构成一个 面积为正 的 轴对齐正方形 ,统计 满足该要求的方案数目。\n\n轴对齐正方形 是一个正方形,除四条边长度相同外,还满足每条边都与 x-轴 或 y-轴 平行或垂直。\n\n实现 `DetectSquares` 类:\n* `DetectSquares()` 使用空数据结构初始化对象\n* `void add(int[] point)` 向数据结构添加一个新的点 `point = [x, y]`\n* `int count(int[] point)` 统计按上述方式与点 `point = [x, y]` 共同构造 轴对齐正方形 的方案数。\n\n示例:\n\n```\n输入:\n[\"DetectSquares\", \"add\", \"add\", \"add\", \"count\", \"count\", \"add\", \"count\"]\n[[], [[3, 10]], [[11, 2]], [[3, 2]], [[11, 10]], [[14, 8]], [[11, 2]], [[11, 10]]]\n输出:\n[null, null, null, null, 1, 0, null, 2]\n\n解释:\nDetectSquares detectSquares = new DetectSquares();\ndetectSquares.add([3, 10]);\ndetectSquares.add([11, 2]);\ndetectSquares.add([3, 2]);\ndetectSquares.count([11, 10]); // 返回 1 。你可以选择:\n                               //   - 第一个,第二个,和第三个点\ndetectSquares.count([14, 8]);  // 返回 0 。查询点无法与数据结构中的这些点构成正方形。\ndetectSquares.add([11, 2]);    // 允许添加重复的点。\ndetectSquares.count([11, 10]); // 返回 2 。你可以选择:\n                               //   - 第一个,第二个,和第三个点\n                               //   - 第一个,第三个,和第四个点\n```\n\n提示:\n* $point.length == 2$\n* $0 <= x, y <= 1000$\n* 调用 `add` 和 `count` 的 总次数 最多为 $5000$", "solution": "### 哈希表\n\n对于 `add` 操作,我们可以使用「哈希表 套 哈希表」的方式,以 `{x, {y : 点 (x,y) 数量}}` 的形式对传入点进行存储。\n\n对于 `count` 查询而言,假定传入的点为 $(x, y)$,我们可以先查询 $x$ 行都有哪些列,枚举这些列( 即枚举点 $(x, ny)$ ),由 $y$ 和 $ny$ 可得正方形边长 $len$,此时再检查唯一确定的两点 $(x \\pm len, y)$ 和 $(x \\pm len, ny)$ 的出现次数,应用乘法原理,即可知道该正方形的方案数,统计所有合法方案数即是该询问的答案。\n\n利用题目范围给定的 `x` 和 `y` 具有明确的范围 `0 <= x, y <= 1000`,我们可以使用数组充当哈希表,但是为了拓展性和减少边界判断,即支持将平面拓展到任意大小,最好还是直接使用哈希表。\n\n代码(数组充当哈希表代码见 $P2$):\n```Java\nclass DetectSquares {\n    Map<Integer, Map<Integer, Integer>> row2Col = new HashMap<>();\n    \n    public void add(int[] point) {\n        int x = point[0], y = point[1];\n        Map<Integer, Integer> col2Cnt = row2Col.getOrDefault(x, new HashMap<>());\n        col2Cnt.put(y, col2Cnt.getOrDefault(y, 0) + 1);\n        row2Col.put(x, col2Cnt);\n    }\n    \n    public int count(int[] point) {\n        int x = point[0], y = point[1];\n        int ans = 0;\n        Map<Integer, Integer> col2Cnt = row2Col.getOrDefault(x, new HashMap<>());\n        for (int ny : col2Cnt.keySet()) {\n            if (ny == y) continue;\n            int c1 = col2Cnt.get(ny);\n            int len = y - ny;\n            int[] nums = new int[]{x + len, x - len};\n            for (int nx : nums) {\n                Map<Integer, Integer> temp = row2Col.getOrDefault(nx, new HashMap<>());\n                int c2 = temp.getOrDefault(y, 0), c3 = temp.getOrDefault(ny, 0);\n                ans += c1 * c2 * c3;\n            }\n        }\n        return ans;\n    }\n}\n```\n-\n```Java\nclass DetectSquares {\n    int N  = 1010;\n    int[][] cnts = new int[N][N];\n\n    public void add(int[] point) {\n        int x = point[0], y = point[1];\n        cnts[x][y]++;\n    }\n    \n    public int count(int[] point) {\n        int x = point[0], y = point[1];\n        int ans = 0;\n        for (int ny = 0; ny < N; ny++) {\n            if (y == ny) continue;\n            int c1 = cnts[x][ny];\n            if (c1 == 0) continue;\n            int len = y - ny;\n            int[] nums = new int[]{x + len, x - len};\n            for (int nx : nums) {\n                if (nx < 0 || nx >= N) continue;\n                int c2 = cnts[nx][y], c3 = cnts[nx][ny];\n                ans += c1 * c2 * c3;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:`add` 操作的复杂度为 $O(1)$,`count` 最坏情况会扫描完所有此前加入的点,复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2013` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2011-2020/2016. 增量元素之间的最大差值（简单）.md", "url_title": "2016. 增量元素之间的最大差值", "url": "https://leetcode-cn.com/problems/maximum-difference-between-increasing-elements/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-gisg/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个下标从 $0$ 开始的整数数组 $nums$ ,该数组的大小为 $n$ ,请你计算 $nums[j] - nums[i]$ 能求得的 最大差值 ,其中 $0 <= i < j < n$ 且 $nums[i] < nums[j]$ 。\n\n返回 最大差值 。如果不存在满足要求的 $i$ 和 $j$ ,返回 $-1$ 。\n\n示例 1:\n```\n输入:nums = [7,1,5,4]\n\n输出:4\n\n解释:\n最大差值出现在 i = 1 且 j = 2 时,nums[j] - nums[i] = 5 - 1 = 4 。\n注意,尽管 i = 1 且 j = 0 时 ,nums[j] - nums[i] = 7 - 1 = 6 > 4 ,但 i > j 不满足题面要求,所以 6 不是有效的答案。\n```\n示例 2:\n```\n输入:nums = [9,4,3,2]\n\n输出:-1\n解释:\n不存在同时满足 i < j 和 nums[i] < nums[j] 这两个条件的 i, j 组合。\n```\n示例 3:\n```\n输入:nums = [1,5,2,10]\n\n输出:9\n\n解释:\n最大差值出现在 i = 0 且 j = 3 时,nums[j] - nums[i] = 10 - 1 = 9 。\n```\n\n提示:\n* $n == nums.length$\n* $2 <= n <= 1000$\n* $1 <= nums[i] <= 10^9$", "solution": "### 模拟\n\n一个显然的做法是两层循环找合适的 `i` 和 `j`,这样的做法是 $O(n^2)$ 的。\n\n利用我们目的是找到能够取得最大差值的数对,对于每个数对中的 $nums[i]$ 而言,对应的 $nums[j]$ 必然第是坐标 $i$ 左侧的最小值,因此可以通过边遍历边维护最小值 $min$ 的做法,从而将复杂度降到 $O(n)$。\n\n代码:\n```Java\nclass Solution {\n    public int maximumDifference(int[] nums) {\n        int n = nums.length, ans = -1;\n        for (int i = 0, min = nums[0]; i < n; i++) {\n            if (nums[i] > min) ans = Math.max(ans, nums[i] - min);\n            min = Math.min(min, nums[i]);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2016` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2021-2030/2022. 将一维数组转变成二维数组（简单）.md", "url_title": "2022. 将一维数组转变成二维数组", "url": "https://leetcode-cn.com/problems/convert-1d-array-into-2d-array/solution/gong-shui-san-xie-jiang-2021-de-1-gai-ch-qc1a/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个下标从 $0$ 开始的一维整数数组 `original` 和两个整数 `m` 和  `n` 。\n\n你需要使用 `original` 中 所有 元素创建一个 `m` 行 `n` 列的二维数组。\n\n`original` 中下标从 `0` 到 `n - 1` (都 包含 )的元素构成二维数组的第一行,下标从 `n` 到 `2 * n - 1` (都 包含 )的元素构成二维数组的第二行,依此类推。\n\n请你根据上述过程返回一个 `m x n` 的二维数组。如果无法构成这样的二维数组,请你返回一个空的二维数组。\n\n示例 1:\n\n```\n输入:original = [1,2,3,4], m = 2, n = 2\n\n输出:[[1,2],[3,4]]\n\n解释:\n构造出的二维数组应该包含 2 行 2 列。\noriginal 中第一个 n=2 的部分为 [1,2] ,构成二维数组的第一行。\noriginal 中第二个 n=2 的部分为 [3,4] ,构成二维数组的第二行。\n```\n示例 2:\n```\n输入:original = [1,2,3], m = 1, n = 3\n\n输出:[[1,2,3]]\n\n解释:\n构造出的二维数组应该包含 1 行 3 列。\n将 original 中所有三个元素放入第一行中,构成要求的二维数组。\n```\n示例 3:\n```\n输入:original = [1,2], m = 1, n = 1\n\n输出:[]\n\n解释:\noriginal 中有 2 个元素。\n无法将 2 个元素放入到一个 1x1 的二维数组中,所以返回一个空的二维数组。\n```\n示例 4:\n```\n输入:original = [3], m = 1, n = 2\n\n输出:[]\n\n解释:\noriginal 中只有 1 个元素。\n无法将 1 个元素放满一个 1x2 的二维数组,所以返回一个空的二维数组。\n```\n\n提示:\n* $1 <= original.length <= 5 * 10^4$\n* $1 <= original[i] <= 10^5$\n* $1 <= m, n <= 4 * 10^4$", "solution": "### 模拟\n\n**新年快乐,祝大家身体健康,各种上岸 🎉 🎉(带着 $2021$ 年的一切美好品质继续前行**\n\n构造 $m * n$ 的新二维矩阵 `year2022`,并使用 $idx$ 对旧矩阵 `year2021` 进行遍历即可。\n\n代码:\n```Java\nclass Solution {\n    public int[][] construct2DArray(int[] year2021, int m, int n) {\n        if (year2021.length != m * n) return new int[0][0];\n        int[][] year2022 = new int[m][n];\n        for (int i = 0, idx = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                year2022[i][j] = year2021[idx++];\n            }\n        }\n        return year2022;\n    }\n}\n```\n* 时间复杂度:$O(m * n)$\n* 空间复杂度:$O(m * n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2021` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2021-2030/2024. 考试的最大困扰度（中等）.md", "url_title": "2024. 考试的最大困扰度", "url": "https://leetcode-cn.com/problems/maximize-the-confusion-of-an-exam/solution/by-ac_oier-2rii/", "difficulty": "中等", "tags": ["滑动窗口", "双指针"], "question": "一位老师正在出一场由 $n$ 道判断题构成的考试,每道题的答案为 `true` (用 `'T'` 表示)或者 `false` (用 `'F'` 表示)。老师想增加学生对自己做出答案的不确定性,方法是最大化有连续相同结果的题数。(也就是连续出现 `true` 或者连续出现 `false`)。\n\n给你一个字符串 $answerKey$ ,其中 $answerKey[i]$ 是第 $i$ 个问题的正确结果。除此以外,还给你一个整数 $k$,表示你能进行以下操作的最多次数:\n\n每次操作中,将问题的正确答案改为 `'T'` 或者 `'F'` (也就是将 $answerKey[i]$ 改为 `'T'` 或者 `'F'` )。\n请你返回在不超过 $k$ 次操作的情况下,最大 连续 `'T'` 或者 `'F'` 的数目。\n\n示例 1:\n```\n输入:answerKey = \"TTFF\", k = 2\n\n输出:4\n\n解释:我们可以将两个 'F' 都变为 'T' ,得到 answerKey = \"TTTT\" 。\n总共有四个连续的 'T' 。\n```\n示例 2:\n```\n输入:answerKey = \"TFFT\", k = 1\n\n输出:3\n\n解释:我们可以将最前面的 'T' 换成 'F' ,得到 answerKey = \"FFFT\" 。\n或者,我们可以将第二个 'T' 换成 'F' ,得到 answerKey = \"TFFF\" 。\n两种情况下,都有三个连续的 'F' 。\n```\n示例 3:\n```\n输入:answerKey = \"TTFTTFTT\", k = 1\n\n输出:5\n\n解释:我们可以将第一个 'F' 换成 'T' ,得到 answerKey = \"TTTTTFTT\" 。\n或者我们可以将第二个 'F' 换成 'T' ,得到 answerKey = \"TTFTTTTT\" 。\n两种情况下,都有五个连续的 'T' 。\n```\n\n提示:\n* $n == answerKey.length$\n* $1 <= n <= 5 \\times 10^4$\n* $answerKey[i]$ 要么是 `'T'` ,要么是 `'F'`\n* $1 <= k <= n$", "solution": "### 滑动窗口\n\n题目求修改次数不超过 $k$ 的前提下,连续段 `'T'` 或 `'F'` 的最大长度。\n\n等价于求一个包含 `'F'` 或者 `'T'` 的个数不超过 $k$ 的最大长度窗口。\n\n假定存在一个 `int getCnt(char c)` 函数,返回包含字符 `c` 数量不超过 $k$ 的最大窗口长度,那么最终 `max(getCnt('T'), getCnt('F'))` 即是答案。\n\n其中 `getCnt` 函数的实现可以使用「滑动窗口」:使用 $j$ 和 $i$ 分别代表窗口的左右端点,$cnt$ 为区间 $[j, i]$ 中的字符 `c` 的数量,每次右端点 $i$ 移动时,若满足 $s[i] = c$,让 $cnt$ 自增,当 $cnt > k$ 时,使左端点 $j$ 往右移动,同时更新 $cnt$,直到 $[j, i]$ 区间恢复合法性(包含字符 `c` 的数量 $cnt$ 不超过 $k$ 个)。\n\n代码:\n```Java\nclass Solution {\n    String s;\n    int n, k;\n    public int maxConsecutiveAnswers(String answerKey, int _k) {\n        s = answerKey;\n        n = s.length(); k = _k;\n        return Math.max(getCnt('T'), getCnt('F'));\n    }\n    int getCnt(char c) {\n        int ans = 0;\n        for (int i = 0, j = 0, cnt = 0; i < n; i++) {\n            if (s.charAt(i) == c) cnt++;\n            while (cnt > k) {\n                if (s.charAt(j) == c) cnt--;\n                j++;\n            }\n            ans = Math.max(ans, i - j + 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2024` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2021-2030/2028. 找出缺失的观测数据（中等）.md", "url_title": "2028. 找出缺失的观测数据", "url": "https://leetcode-cn.com/problems/find-missing-observations/solution/by-ac_oier-x22k/", "difficulty": "中等", "tags": ["模拟", "构造"], "question": "现有一份 $n + m$ 次投掷单个「六面」骰子的观测数据,骰子的每个面从 $1$ 到 $6$ 编号。观测数据中缺失了 $n$ 份,你手上只拿到剩余 $m$ 次投掷的数据。幸好你有之前计算过的这 $n + m$ 次投掷数据的平均值。\n\n给你一个长度为 $m$ 的整数数组 `rolls` ,其中 $rolls[i]$ 是第 $i$ 次观测的值。同时给你两个整数 $mean$ 和 $n$ 。\n\n返回一个长度为 $n$ 的数组,包含所有缺失的观测数据,且满足这 $n + m$ 次投掷的平均值是 $mean$。\n\n如果存在多组符合要求的答案,只需要返回其中任意一组即可。如果不存在答案,返回一个空数组。\n\n$k$ 个数字的 平均值 为这些数字求和后再除以 $k$ 。\n\n注意 $mean$ 是一个整数,所以 $n + m$ 次投掷的总和需要被 $n + m$ 整除。\n\n示例 1:\n```\n输入:rolls = [3,2,4,3], mean = 4, n = 2\n\n输出:[6,6]\n\n解释:所有 n + m 次投掷的平均值是 (3 + 2 + 4 + 3 + 6 + 6) / 6 = 4 。\n```\n示例 2:\n```\n输入:rolls = [1,5,6], mean = 3, n = 4\n\n输出:[2,3,2,2]\n\n解释:所有 n + m 次投掷的平均值是 (1 + 5 + 6 + 2 + 3 + 2 + 2) / 7 = 3 。\n```\n示例 3:\n```\n输入:rolls = [1,2,3,4], mean = 6, n = 4\n\n输出:[]\n\n解释:无论丢失的 4 次数据是什么,平均值都不可能是 6 。\n```\n示例 4:\n```\n输入:rolls = [1], mean = 3, n = 1\n\n输出:[5]\n\n解释:所有 n + m 次投掷的平均值是 (1 + 5) / 2 = 3 。\n```\n\n提示:\n* $m == rolls.length$\n* $1 <= n, m <= 10^5$\n* $1 <= rolls[i], mean <= 6$", "solution": "### 构造\n\n根据题意,我们需要构造长度为 $n$ 的序列 $ans$,使得 $ans$ 和 $rolls$ 并集的平均值为 $mean$。\n\n由于最终的平均值 $mean$ 已知,我们可以直接算得两序列之和为 $t = (m + n) \\times mean$。\n\n使用 $t$ 减去 $$\\sum_{i = 0}^{m}rolls[i]$$ 可得 $$\\sum_{i = 0}^{n}ans[i]$$。我们知道一个长度为 $n$ 的有效序列的元素和范围为 $[n, 6 \\times n]$(骰子编号为 $[1, 6]$),根据 $\\sum_{i = 0}^{m}rolls[i]$ 与 $[n, 6 \\times n]$ 关系进行分情况讨论:\n\n* 如果 $$\\sum_{i = 0}^{n}ans[i]$$ 不落在 $[n, 6  \\times n]$ 范围内,无解,直接返回空数组;\n\n* 如果 $$\\sum_{i = 0}^{m} rool[i]$$ 落在 $[n, 6 \\times n]$ 范围内,有解,此时尝试构造一个合法的 $ans$ : 起始使用 $$\\left \\lfloor \\frac{\\sum_{i = 0}^{n}ans[i]}{n} \\right \\rfloor$$ 填充 $ans$,若 $$\\left \\lfloor \\frac{\\sum_{i = 0}^{n}ans[i]}{n} \\right \\rfloor \\times n < \\sum_{i = 0}^{n}ans[i]$$,计算两者差异值 $d$,并尝试将 $d$ 分摊到前 $d$ 个 $ans[i]$ 上(该过程一定可以顺利进行)。\n\n代码:\n```Java\nclass Solution {\n    public int[] missingRolls(int[] rolls, int mean, int n) {\n        int m = rolls.length, cnt = m + n;\n        int t = mean * cnt;\n        for (int i : rolls) t -= i;\n        if (t < n || t > 6 * n) return new int[0];\n        int[] ans = new int[n];\n        Arrays.fill(ans, t / n);\n        if (t / n * n < t) {\n            int d = t - (t / n * n), idx = 0;\n            while (d-- > 0) ans[idx++]++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(m + n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2028` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2021-2030/2029. 石子游戏 IX（中等）.md", "url_title": "2029. 石子游戏 IX", "url": "https://leetcode-cn.com/problems/stone-game-ix/solution/gong-shui-san-xie-fen-qing-kuang-tao-lun-h1oa/", "difficulty": "中等", "tags": ["博弈论"], "question": "`Alice` 和 `Bob` 轮流进行自己的回合,`Alice` 先手。每一回合,玩家需要从 `stones` 中移除任一石子。\n\n如果玩家移除石子后,导致 所有已移除石子 的价值 总和 可以被 $3$ 整除,那么该玩家就 输掉游戏 。\n如果不满足上一条,且移除后没有任何剩余的石子,那么 `Bob` 将会直接获胜(即便是在 `Alice` 的回合)。\n假设两位玩家均采用 最佳 决策。如果 `Alice` 获胜,返回 `true` ;如果 `Bob` 获胜,返回 `false` 。\n\n示例 1:\n```\n输入:stones = [2,1]\n\n输出:true\n\n解释:游戏进行如下:\n- 回合 1:Alice 可以移除任意一个石子。\n- 回合 2:Bob 移除剩下的石子。 \n已移除的石子的值总和为 1 + 2 = 3 且可以被 3 整除。因此,Bob 输,Alice 获胜。\n```\n示例 2:\n```\n输入:stones = [2]\n\n输出:false\n\n解释:Alice 会移除唯一一个石子,已移除石子的值总和为 2 。 \n由于所有石子都已移除,且值总和无法被 3 整除,Bob 获胜。\n```\n示例 3:\n```\n输入:stones = [5,1,2,4,3]\n\n输出:false\n\n解释:Bob 总会获胜。其中一种可能的游戏进行方式如下:\n- 回合 1:Alice 可以移除值为 1 的第 2 个石子。已移除石子值总和为 1 。\n- 回合 2:Bob 可以移除值为 3 的第 5 个石子。已移除石子值总和为 = 1 + 3 = 4 。\n- 回合 3:Alices 可以移除值为 4 的第 4 个石子。已移除石子值总和为 = 1 + 3 + 4 = 8 。\n- 回合 4:Bob 可以移除值为 2 的第 3 个石子。已移除石子值总和为 = 1 + 3 + 4 + 2 = 10.\n- 回合 5:Alice 可以移除值为 5 的第 1 个石子。已移除石子值总和为 = 1 + 3 + 4 + 2 + 5 = 15.\nAlice 输掉游戏,因为已移除石子值总和(15)可以被 3 整除,Bob 获胜。\n```\n\n提示:\n* $1 <= stones.length <= 10^5$\n* $1 <= stones[i] <= 10^4$", "solution": "### 分情况讨论博弈\n\n为了方便,我们用 `A` 来代指 `Alice`,用 `B` 带代指 `Bob`。\n\n`A` 只有一种获胜方式,是使得 `B` 在选石子时凑成 $3$ 的倍数;而 `B` 除了能够通过让 `A` 凑成 $3$ 的倍数以外,还能通过让游戏常规结束来获胜。\n\n因此整个游戏过程,我们只需要关心「已被移除的石子总和」和「剩余石子个数/价值情况」即可。\n\n更进一步的,我们只需关心已被移除的石子总和是否为 $3$ 的倍数,以及剩余石子的价值与已移除石子总和相加是否凑成 $3$ 的倍数即可。 \n\n所以我们可以按照石子价值除以 $3$ 的余数分成三类,并统计相应数量。\n\n不失一般性考虑,某个回合开始前,已移除的石子总和状态为 $x$(共三种,分别为除以 $3$ 余数为 $0$、$1$ 和 $2$,其中当状态为 $0$,且非首个回合时,说明凑成 $3$ 的倍数,游戏结束),剩余石子价值除以 $3$ 的余数 $s$ 分别为 $0$、$1$ 和 $2$。\n\n**首先如果当前 $x = 1$ 时,不能选择 $s = 2$ 的石子,否则会导致凑成总和为 $3$ 的倍数而失败;同理 $x = 2$ 时,不能选择 $s = 1$ 的石子;而选择 $s = 0$ 的数字,不会改变 $x$ 的状态,可看做换手操作。**\n\n**同时成对的 $s = 0$ 的等价于没有 $s = 0$ 的石子(双方只需要轮流选完这些 $s = 0$ 的石子,最终会回到先手最开始的局面);而选择与 $x$ 相同的 $s$ 会导致 $x$ 改变(即 $x = 1$ 时,选择 $s = 1$ 的石子,会导致 $x = 2$;而 $x = 2$ 时,选 $s = 2$ 的石子,会导致 $x = 1$)。**\n\n明确规则后,是分情况讨论的过程:\n\n* **$s = 0$ 的石子数量为偶数**:此时等价于没有 $s = 0$ 的石子,我们只需要关心 $s = 1$ 和 $s = 2$ 即可:\n  \n    * **$s = 1$ 的石子数量为 $0$**: 这意味着 `A` 开始选择的只能是 $s = 2$,此时交给 `B` 的局面为「$x = 2$、剩余石子只有 $s = 2$」,此时 `B` 只能选 $s = 2$ 的石子,由于 $x = 2$ 且选择的石子 $s = 2$,因此交由回 `A` 的局面为「$x = 1$,剩余是在只有 $s = 2$」,因此游戏继续的话 `A` 必败,同时如果在该过程的任何时刻石子被取完,也是 `B` 直接获胜,即 **`A` 仍为必败**;\n    \n    * **$s = 2$ 的石子数量为 $0$**:分析同理,`A` 只能选 $s = 1$,此时交给 `B` 的局面为「$x = 1$、剩余石子只有 $s = 1$」,此时 `B` 只能选 $s = 1$ 的石子,由于 $x = 1$ 且选择的石子 $s = 1$,因此交由回 `A` 的局面为「$x = 2$,剩余是在只有 $s = 1$」,因此游戏继续的话 `A` 必败,同时如果在该过程的任何时刻石子被取完,也是 `B` 直接获胜,即 **`A` 仍为必败**;\n\n    * **$s = 1$ 和 $s = 2$ 的石子数量均不为 $0$**:`A` 选数量不是最多的一类石子,`B` 下一回合只能选择相同类型的石子(或是无从选择导致失败),然后游戏继续,最终 `B` 会先进入「只能凑成 $3$ 的倍数」的局面导致失败,即 **`A` 必胜。**\n\n* **$s = 0$ 的石子数量为奇数**:此时等价于有一次换手机会,该换手机会必然应用在「对必败局面进行转移」才有意义,因此只有 $s = 1$ 和 $s = 2$ 的石子数量差大于 $2$,`A` 的先手优势不会因为存在换手机会而被转移:\n  \n    * **两者数量差不超过 $2$**:此时 `B` 可以利用「对方凑成 $3$ 的倍数必败」规则和「优先使用 $s = 0$ 石子」权利来进入确保自己为必胜态:\n      \n        * 举个 🌰,当 $s = 1$ 和 $s = 2$ 的石子数量相等,虽然有 $s = 0$ 的石子,`A` 先手,但是 `A` 的首个回合必然不能选 $s = 0$,否则马上失败结束,因此 `A` 只能选 $s = 1$ 或 $s = 2$,此时 `B`直接选择 $s = 0$ 的石子,交由给 `A` 的局面 $x$ 没有发生改变,`A` 只能选择与首个回合相同的 $s$ 游戏才能继续,因此局面会变为「`B` 先手、$s = 1$ 和 $s = 2$ 的石子数量差为 $2$」,游戏继续,最终 `A` 会先遇到「只能凑成 $3$ 的倍数」的局面,即 **`B` 必胜**。\n        \n        * 两者数量不等,但数量差不超过 $2$:此时无论 `A` 选择数量较少或较多的 `s`,`B` 都在第二回合马上使用 $s = 0$ 的石子进行换手,`A` 只能继续选与第一回合相同类型的的石子,游戏才能进行,最终 `A` 会先遇到「只能凑成 $3$ 的倍数」或「石子被取完」的局面,即 **`B` 必胜**。\n\n    * **两者数量差超过 $2$** :此时即使 `A` 只要确保第一次选择数量较多的 $s$,不管 `B` 是否使用「优先使用 $s = 0$」的石子,`A` 都有足够次数数量多 $s$ 来抵消换手(或是在 `B` 放弃使用 $s = 0$ 之后马上使用),最终都是 `B` 最先遇到「只能凑成 $3$ 的倍数」的局面,即 **`A` 获胜**。\n\n代码:\n```Java\nclass Solution {\n    public boolean stoneGameIX(int[] stones) {\n        int[] cnts = new int[3];\n        for (int i : stones) cnts[i % 3]++;\n        return cnts[0] % 2 == 0 ? !(cnts[1] == 0 || cnts[2] == 0) : Math.abs(cnts[1] - cnts[2]) > 2;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2029` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2031-2040/2031. 1 比 0 多的子数组个数（中等）.md", "url_title": "2031. 1 比 0 多的子数组个数", "url": null, "difficulty": "中等", "tags": ["树状数组", "前缀和"], "question": "给你一个只包含 $0$ 和 $1$ 的数组 $nums$,请返回 $1$ 的数量 大于 $04 的数量的子数组的个数。\n\n由于答案可能很大,请返回答案对 $10^9 + 7$ 取余 的结果。\n\n一个 子数组 指的是原数组中连续的一个子序列。\n\n示例 1:\n```\n输入: nums = [0,1,1,0,1]\n\n输出: 9\n\n解释:\n长度为 1 的、1 的数量大于 0 的数量的子数组有: [1], [1], [1]\n长度为 2 的、1 的数量大于 0 的数量的子数组有: [1,1]\n长度为 3 的、1 的数量大于 0 的数量的子数组有: [0,1,1], [1,1,0], [1,0,1]\n长度为 4 的、1 的数量大于 0 的数量的子数组有: [1,1,0,1]\n长度为 5 的、1 的数量大于 0 的数量的子数组有: [0,1,1,0,1]\n```\n示例 2:\n```\n输入: nums = [0]\n\n输出: 0\n\n解释:\n没有子数组的 1 的数量大于 0 的数量。\n```\n示例 3:\n```\n输入: nums = [1]\n\n输出: 1\n\n解释:\n长度为 1 的、1 的数量大于 0 的数量的子数组有: [1]\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $0 <= nums[i] <= 1$", "solution": "### 树状数组 \n\n为了方便,我们调整数组 $nums$ 下标从 $1$ 开始。同时将 $nums[i] = 0$ 的值看作 $nums[i] = -1$,并预处理出前缀和数组 $sum$。对于任意 $sum[i]$ 而言,其值域范围为 $[-n, n]$,我们可以通过对 $sum[i]$ 做整体 $n + 1$ 的偏移,将值域映射到 $[1, 2 * n + 1]$。\n\n对于任意一个子数组 $i...j$ 而言,如果满足 $1$ 的数量大于 $0$,则必然有 $sum[j] - sum[i - 1] > 0$。\n\n因此在求解以 $nums[j]$ 为右端点的「满足 $1$ 数量大于 $0$ 数量」的子数组个数时,等价于在问 $[0, j - 1]$ 范围内有多少个下标 $i$ 满足 $sum[i] < sum[j]$(即有多少个下标可以作为左端点)。\n\n求解比 $x$ 小的数有多少个,可以使用「树状数组」来做。\n\n具体的,我们可以遍历每个位置,假设当前处理到的位置是 $i$,其前缀和值 $t = sum[i]$,我们可以通过查询小于等于 $t - 1$ 的值数量来得知以 $i$ 为右端点的合法子数组数量,统计后,我们需要对数值为 $t$ 出现次数进行加一。\n\n代码:\n```Java\nclass Solution {\n    int N = 200010, MOD = (int)1e9+7;\n    int[] tr = new int[N];\n    int n;\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void add(int x, int v) {\n        for (int i = x; i <= 2 * n + 1; i += lowbit(i)) tr[i] += v;\n    }\n    int query(int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];\n        return ans;\n    }\n    public int subarraysWithMoreZerosThanOnes(int[] nums) {\n        n = nums.length;\n        int ans = 0;\n        int[] sum = new int[n + 10];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (nums[i - 1] == 0 ? -1 : 1);\n        for (int i = 0; i <= n; i++) {\n            int t = sum[i] + n + 1;\n            ans = (ans + query(t - 1)) % MOD;\n            add(t, 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:预处理前缀和数组的复杂度为 $O(n)$;查询和插入的复杂度均为 $O(\\log{n})$,整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2031` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2031-2040/2034. 股票价格波动（中等）.md", "url_title": "2034. 股票价格波动", "url": "https://leetcode-cn.com/problems/stock-price-fluctuation/solution/gong-shui-san-xie-shu-ju-jie-gou-mo-ni-t-u6f4/", "difficulty": "中等", "tags": ["数据结构"], "question": "给你一支股票价格的数据流。数据流中每一条记录包含一个 时间戳 和该时间点股票对应的 价格 。\n\n不巧的是,由于股票市场内在的波动性,股票价格记录可能不是按时间顺序到来的。某些情况下,有的记录可能是错的。如果两个有相同时间戳的记录出现在数据流中,前一条记录视为错误记录,后出现的记录 更正 前一条错误的记录。\n\n请你设计一个算法,实现:\n* 更新 股票在某一时间戳的股票价格,如果有之前同一时间戳的价格,这一操作将 更正 之前的错误价格。\n* 找到当前记录里 最新股票价格 。最新股票价格 定义为时间戳最晚的股票价格。\n* 找到当前记录里股票的 最高价格 。\n* 找到当前记录里股票的 最低价格 。\n\n请你实现 `StockPrice` 类:\n* `StockPrice()` 初始化对象,当前无股票价格记录。\n* `void update(int timestamp, int price)` 在时间点 `timestamp` 更新股票价格为 `price`。\n* `int current()` 返回股票 最新价格 。\n* `int maximum()` 返回股票 最高价格 。\n* `int minimum()` 返回股票 最低价格 。\n\n示例 1:\n```\n输入:\n[\"StockPrice\", \"update\", \"update\", \"current\", \"maximum\", \"update\", \"maximum\", \"update\", \"minimum\"]\n[[], [1, 10], [2, 5], [], [], [1, 3], [], [4, 2], []]\n输出:\n[null, null, null, 5, 10, null, 5, null, 2]\n\n解释:\nStockPrice stockPrice = new StockPrice();\nstockPrice.update(1, 10); // 时间戳为 [1] ,对应的股票价格为 [10] 。\nstockPrice.update(2, 5);  // 时间戳为 [1,2] ,对应的股票价格为 [10,5] 。\nstockPrice.current();     // 返回 5 ,最新时间戳为 2 ,对应价格为 5 。\nstockPrice.maximum();     // 返回 10 ,最高价格的时间戳为 1 ,价格为 10 。\nstockPrice.update(1, 3);  // 之前时间戳为 1 的价格错误,价格更新为 3 。\n                          // 时间戳为 [1,2] ,对应股票价格为 [3,5] 。\nstockPrice.maximum();     // 返回 5 ,更正后最高价格为 5 。\nstockPrice.update(4, 2);  // 时间戳为 [1,2,4] ,对应价格为 [3,5,2] 。\nstockPrice.minimum();     // 返回 2 ,最低价格时间戳为 4 ,价格为 2 。\n```\n\n提示:\n* $1 <= timestamp, price <= 10^9$\n* `update`,`current`,`maximum` 和 `minimum` **总** 调用次数不超过 $10^5$ \n* `current`,`maximum` 和 `minimum` 被调用时,`update` 操作 **至少** 已经被调用过 一次 。", "solution": "### 模拟 + 数据结构\n\n容易想到我们需要使用「哈希表」来记录 `{时间:价格}` 的映射关系。\n\n**关于 `current` 操作,我们可以维护一个最大的时间戳 `cur`,在调用 `current` 的时候直接 $O(1)$ 查得结果。**\n\n然后考虑解决 `update` 操作中对相同时间点的更新问题,我们可以使用 `TreeMap`(红黑树)来解决该问题。以 `{价格:该价格对应的时间点数量}` 的 `KV` 形式进行存储,`key` 按照「升序」进行排序。\n\n然后对传入的 `timestamp` 是否已经被记录(是否已经存在哈希表中)进行分情况讨论:\n\n* 传入的 `timestamp` 未被记录,直接更新哈希表和 `TreeMap`;\n* 传入的 `timestamp` 已被记录,此时需要先从哈希表取出旧价格 `old`,然后用旧价格对 `TreeMap` 进行修改(如果该价格只有一个时间点,将该价格直接从 `TreeMap` 中移除;若有多个时间点,则对该价格对应的时间点数量进行减一操作),然后再使用传入的新价格 `price` 更新哈希表和 `TreeMap`。\n\n**`minimum` 和 `maximum` 操作则只需要取得 `TreeMap` 的首尾 `Key` 即可。**\n\n代码:\n```Java\nclass StockPrice {\n    int cur;\n    Map<Integer, Integer> map = new HashMap<>();\n    TreeMap<Integer, Integer> ts = new TreeMap<>();\n    public void update(int timestamp, int price) {\n        cur = Math.max(cur, timestamp);\n        if (map.containsKey(timestamp)) {\n            int old = map.get(timestamp);\n            int cnt = ts.get(old);\n            if (cnt == 1) ts.remove(old);\n            else ts.put(old, cnt - 1);\n        }\n        map.put(timestamp, price);\n        ts.put(price, ts.getOrDefault(price, 0) + 1);\n    }\n    \n    public int current() {\n        return map.get(cur);\n    }\n    \n    public int maximum() {\n        return ts.lastKey();\n    }\n    \n    public int minimum() {\n        return ts.firstKey();\n    }\n}\n```\n* 时间复杂度:令 $n$ 为最大调用次数,`update` 复杂度为 $O(\\log{n})$;`current`、`maximum` 和 `minimum` 操作复杂度为 $O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2034` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2031-2040/2038. 如果相邻两个颜色均相同则删除当前颜色（中等）.md", "url_title": "2038. 如果相邻两个颜色均相同则删除当前颜色", "url": "https://leetcode-cn.com/problems/remove-colored-pieces-if-both-neighbors-are-the-same-color/solution/gong-shui-san-xie-nao-jin-ji-zhuan-wan-y-a8xm/", "difficulty": "中等", "tags": ["脑筋急转弯", "模拟"], "question": "总共有 $n$ 个颜色片段排成一列,每个颜色片段要么是 `'A'` 要么是 `'B'` 。\n\n给你一个长度为 $n$ 的字符串 `colors` ,其中 $colors[i]$ 表示第 $i$ 个颜色片段的颜色。\n\nAlice 和 Bob 在玩一个游戏,他们轮流从这个字符串中删除颜色。Alice 先手 。\n\n* 如果一个颜色片段为 `'A'` 且相邻两个颜色都是颜色 `'A'` ,那么 Alice 可以删除该颜色片段。Alice 不可以删除任何颜色 `'B'` 片段。\n* 如果一个颜色片段为 `'B'` 且相邻两个颜色都是颜色 `'B'` ,那么 Bob 可以删除该颜色片段。Bob 不可以删除任何颜色 `'A'` 片段。\n* Alice 和 Bob 不能从字符串两端删除颜色片段。\n* 如果其中一人无法继续操作,则该玩家输掉游戏且另一玩家获胜。\n\n假设 Alice 和 Bob 都采用最优策略,如果 Alice 获胜,请返回 true,否则 Bob 获胜,返回 false。\n\n示例 1:\n```\n输入:colors = \"AAABABB\"\n\n输出:true\n\n解释:\nAAABABB -> AABABB\nAlice 先操作。\n她删除从左数第二个 'A' ,这也是唯一一个相邻颜色片段都是 'A' 的 'A' 。\n\n现在轮到 Bob 操作。\nBob 无法执行任何操作,因为没有相邻位置都是 'B' 的颜色片段 'B' 。\n因此,Alice 获胜,返回 true 。\n```\n示例 2:\n```\n输入:colors = \"AA\"\n\n输出:false\n\n解释:\nAlice 先操作。\n只有 2 个 'A' 且它们都在字符串的两端,所以她无法执行任何操作。\n因此,Bob 获胜,返回 false 。\n```\n示例 3:\n```\n输入:colors = \"ABBBBBBBAAA\"\n\n输出:false\n\n解释:\nABBBBBBBAAA -> ABBBBBBBAA\nAlice 先操作。\n她唯一的选择是删除从右数起第二个 'A' 。\n\nABBBBBBBAA -> ABBBBBBAA\n接下来轮到 Bob 操作。\n他有许多选择,他可以选择任何一个 'B' 删除。\n\n然后轮到 Alice 操作,她无法删除任何片段。\n所以 Bob 获胜,返回 false 。\n```\n\n提示:\n* $1 <= colors.length <= 10^5$\n* `colors` 只包含字母 `'A'` 和 `'B'`", "solution": "### 脑筋急转弯\n\n根据删除规则,删除任意一个 `A` 不会影响可被删删除的 `B` 的数量,反之亦然。\n\n因此直接统计「可删除的 `A` 的数量」和「可删除的 `B` 的数量」,分别记为 $a$ 和 $b$,比较 $a$ 和 $b$ 的大小即可得到答案(只有 $a > b$ 时,先手获胜)。\n\n代码:\n```Java\nclass Solution {\n    public boolean winnerOfGame(String colors) {\n        char[] cs = colors.toCharArray();\n        int n = cs.length;\n        int a = 0, b = 0;\n        for (int i = 1; i < n - 1; i++) {\n            if (cs[i] == 'A' && cs[i - 1] == 'A' && cs[i + 1] == 'A') a++;\n            if (cs[i] == 'B' && cs[i - 1] == 'B' && cs[i + 1] == 'B') b++;\n        }\n        return a > b;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:使用 `toCharArray` 操作会产生新数组,复杂度为 $O(n)$,而使用 `charAt` 代替的话复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2038` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2031-2040/2039. 网络空闲的时刻（中等）.md", "url_title": "2039. 网络空闲的时刻", "url": "https://leetcode-cn.com/problems/the-time-when-the-network-becomes-idle/solution/by-ac_oier-5txs/", "difficulty": "中等", "tags": ["BFS"], "question": "给你一个有 $n$ 个服务器的计算机网络,服务器编号为 $0$ 到 $n - 1$ 。同时给你一个二维整数数组 `edges` ,其中 $edges[i] = [u_i, v_i]$ 表示服务器 $u_i$ 和 $v_i$ 之间有一条信息线路,在一秒内它们之间可以传输任意数目的信息。再给你一个长度为 $n$ 且下标从 $0$ 开始的整数数组 `patience` 。\n\n题目保证所有服务器都是相通的,也就是说一个信息从任意服务器出发,都可以通过这些信息线路直接或间接地到达任何其他服务器。\n\n编号为 $0$ 的服务器是主服务器,其他服务器为数据服务器。每个数据服务器都要向主服务器发送信息,并等待回复。信息在服务器之间按最优线路传输,也就是说每个信息都会以最少时间到达主服务器。主服务器会处理所有新到达的信息并立即按照每条信息来时的路线反方向发送回复信息。\n\n在 $0$ 秒的开始,所有数据服务器都会发送各自需要处理的信息。从第 $1$ 秒开始,每一秒最开始时,每个数据服务器都会检查它是否收到了主服务器的回复信息(包括新发出信息的回复信息):\n\n* 如果还没收到任何回复信息,那么该服务器会周期性重发信息。数据服务器 $i$ 每 $patience[i]$ 秒都会重发一条信息,也就是说,数据服务器 $i$ 在上一次发送信息给主服务器后的 $patience[i]$ 秒 后 会重发一条信息给主服务器。\n* 否则,该数据服务器不会重发信息。\n\n当没有任何信息在线路上传输或者到达某服务器时,该计算机网络变为空闲状态。\n\n请返回计算机网络变为空闲状态的最早秒数。\n\n示例 1:\n\n```\n输入:edges = [[0,1],[1,2]], patience = [0,2,1]\n\n输出:8\n\n解释:\n0 秒最开始时,\n- 数据服务器 1 给主服务器发出信息(用 1A 表示)。\n- 数据服务器 2 给主服务器发出信息(用 2A 表示)。\n\n1 秒时,\n- 信息 1A 到达主服务器,主服务器立刻处理信息 1A 并发出 1A 的回复信息。\n- 数据服务器 1 还没收到任何回复。距离上次发出信息过去了 1 秒(1 < patience[1] = 2),所以不会重发信息。\n- 数据服务器 2 还没收到任何回复。距离上次发出信息过去了 1 秒(1 == patience[2] = 1),所以它重发一条信息(用 2B 表示)。\n\n2 秒时,\n- 回复信息 1A 到达服务器 1 ,服务器 1 不会再重发信息。\n- 信息 2A 到达主服务器,主服务器立刻处理信息 2A 并发出 2A 的回复信息。\n- 服务器 2 重发一条信息(用 2C 表示)。\n...\n4 秒时,\n- 回复信息 2A 到达服务器 2 ,服务器 2 不会再重发信息。\n...\n7 秒时,回复信息 2D 到达服务器 2 。\n\n从第 8 秒开始,不再有任何信息在服务器之间传输,也不再有信息到达服务器。\n所以第 8 秒是网络变空闲的最早时刻。\n```\n示例 2:\n\n```\n输入:edges = [[0,1],[0,2],[1,2]], patience = [0,10,10]\n\n输出:3\n\n解释:数据服务器 1 和 2 第 2 秒初收到回复信息。\n从第 3 秒开始,网络变空闲。\n```\n\n提示:\n* $n == patience.length$\n* $2 <= n <= 10^5$\n* $patience[0] == 0$\n* 对于 $1 <= i < n$ ,满足 $1 <= patience[i] <= 10^5$\n* $1 <= edges.length <= \\min(105, n * (n - 1) / 2)$\n* $edges[i].length == 2$\n* $0 <= ui, vi < n$\n* $ui != vi$\n* 不会有重边。\n* 每个服务器都直接或间接与别的服务器相连。", "solution": "### 建图 + BFS\n\n根据题目可知这是一个边权为 $1$ 的无向连通图,我们可以采用「邻接表建图 + BFS」的方式预处理出 $dist$ 数组,$dist[i]$ 含义为节点 $i$ 到 $0$ 号点的最短距离。\n\n一个数据服务器 $i$ 往主服务器发送消息所消耗的时间为两节点之间的最短路径 $dist[i]$,而从发送消息到收到回复所需的时间为 $di = 2 * dist[i]$。\n\n同时每个数据服务器还存在时间间隔为 $t = patience[i]$ 的重发动作,并且动作只有在第一次收到主服务的回复后才会停止。\n\n因此如果 $di <= t$,那么数据服务器不会发生重发动作,该节点活动停止时间点为 $di$;当 $di > t$,数据服务器将会发生重发动作,且最后一个数据包的发送时间为 $(di - 1) / t * t$,只有当最后一个数据包收到回复,该节点的所有活动才算停止,停止时间点为 $(di - 1) / t * t + di$。所有节点的活动停止时间点的最大值即是答案。\n\n> 一些细节:老规矩,为了避免每个样例都 `new` 大数组,我们使用 `static` 优化。使用 `static` 优化后,你甚至会收获一个稳定 $100$% 的结果 🤣\n\n代码:\n```Java\nclass Solution {\n    static int N = 100010, M = N * 2, INF = 0x3f3f3f3f;\n    static int[] he = new int[N], e = new int[M], ne = new int[M];\n    static int[] dist = new int[N];\n    int idx;\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    public int networkBecomesIdle(int[][] edges, int[] patience) {\n        Arrays.fill(he, -1);\n        Arrays.fill(dist, INF);\n        int n = patience.length;\n        for (int[] e : edges) {\n            add(e[0], e[1]);\n            add(e[1], e[0]);\n        }\n        Deque<Integer> d = new ArrayDeque<>();\n        d.addLast(0);\n        dist[0] = 0;\n        while (!d.isEmpty()) {\n            int t = d.pollFirst();\n            for (int i = he[t]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (dist[j] != INF) continue;\n                dist[j] = dist[t] + 1;\n                d.addLast(j);\n            }\n        }\n        int ans = 0;\n        for (int i = 1; i < n; i++) {\n            int di = dist[i] * 2, t = patience[i];\n            int cur = di <= t ? di : (di - 1) / t * t + di;\n            if (cur > ans) ans = cur;\n        }\n        return ans + 1;\n    }\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2039` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2041-2050/2043. 简易银行系统（中等）.md", "url_title": "2043. 简易银行系统", "url": "https://leetcode-cn.com/problems/simple-bank-system/solution/by-ac_oier-9pqi/", "difficulty": "中等", "tags": ["模拟"], "question": "你的任务是为一个很受欢迎的银行设计一款程序,以自动化执行所有传入的交易(转账,存款和取款)。\n\n银行共有 $n$ 个账户,编号从 $1$ 到 $n$ 。每个账号的初始余额存储在一个下标从 $0$ 开始的整数数组 `balance` 中,其中第 $(i + 1)$ 个账户的初始余额是 $balance[i]$ 。\n\n请你执行所有 **有效的** 交易。如果满足下面全部条件,则交易有效 :\n* 指定的账户数量在 $1$ 和 $n$ 之间,且\n* 取款或者转账需要的钱的总数 小于或者等于 账户余额。\n\n实现 `Bank` 类:\n* `Bank(long[] balance)` 使用下标从 $0$ 开始的整数数组 `balance` 初始化该对象。\n* `boolean transfer(int account1, int account2, long money)` 从编号为 `account1` 的账户向编号为 `account2` 的账户转帐 `money` 美元。如果交易成功,返回 `true` ,否则,返回 `false` 。\n* `boolean deposit(int account, long money)` 向编号为 `account` 的账户存款 `money` 美元。如果交易成功,返回 `true` ;否则,返回 `false` 。\n* `boolean withdraw(int account, long money)` 从编号为 `account` 的账户取款 `money` 美元。如果交易成功,返回 `true` ;否则,返回 `false` 。\n\n示例:\n```\n输入:\n[\"Bank\", \"withdraw\", \"transfer\", \"deposit\", \"transfer\", \"withdraw\"]\n[[[10, 100, 20, 50, 30]], [3, 10], [5, 1, 20], [5, 20], [3, 4, 15], [10, 50]]\n\n输出:\n[null, true, true, true, false, false]\n\n解释:\nBank bank = new Bank([10, 100, 20, 50, 30]);\nbank.withdraw(3, 10);    // 返回 true ,账户 3 的余额是 $20 ,所以可以取款 $10 。\n                         // 账户 3 余额为 $20 - $10 = $10 。\nbank.transfer(5, 1, 20); // 返回 true ,账户 5 的余额是 $30 ,所以可以转账 $20 。\n                         // 账户 5 的余额为 $30 - $20 = $10 ,账户 1 的余额为 $10 + $20 = $30 。\nbank.deposit(5, 20);     // 返回 true ,可以向账户 5 存款 $20 。\n                         // 账户 5 的余额为 $10 + $20 = $30 。\nbank.transfer(3, 4, 15); // 返回 false ,账户 3 的当前余额是 $10 。\n                         // 所以无法转账 $15 。\nbank.withdraw(10, 50);   // 返回 false ,交易无效,因为账户 10 并不存在。\n```\n\n提示:\n* $n == balance.length$\n* $1 <= n, account, account_1, account_2 <= 10^5$\n* $0 <= balance[i], money <= 10^{12}$\n* `transfer`, `deposit`, `withdraw` 三个函数,每个 最多调用 $10^4$ 次", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n代码:\n```Java\nclass Bank {\n    long[] val;\n    public Bank(long[] balance) {\n        val = balance;\n    }\n\n    boolean check(int account) {\n        return 1 <= account && account <= val.length;\n    }\n    \n    public boolean transfer(int a, int b, long c) {\n        if (!check(a) || !check(b)) return false;\n        if (val[a - 1] >= c) {\n            val[a - 1] -= c; val[b - 1] += c;\n            return true;\n        } \n        return false;\n    }\n    \n    public boolean deposit(int a, long c) {\n        if (!check(a)) return false;\n        val[a - 1] += c;\n        return true;\n    }\n    \n    public boolean withdraw(int a, long c) {\n        if (!check(a)) return false;\n        if (val[a - 1] >= c) {\n            val[a - 1] -= c;\n            return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2043` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2041-2050/2044. 统计按位或能得到最大值的子集数目（中等）.md", "url_title": "2044. 统计按位或能得到最大值的子集数目", "url": "https://leetcode-cn.com/problems/count-number-of-maximum-bitwise-or-subsets/solution/by-ac_oier-dos6/", "difficulty": "中等", "tags": ["二进制枚举", "位运算", "DFS", "状压 DP"], "question": "给你一个整数数组 $nums$ ,请你找出 $nums$ 子集 **按位或** 可能得到的 **最大值** ,并返回按位或能得到最大值的 **不同非空子集的数目** 。\n\n如果数组 $a$ 可以由数组 $b$ 删除一些元素(或不删除)得到,则认为数组 $a$ 是数组 $b$ 的一个 子集 。如果选中的元素下标位置不一样,则认为两个子集 不同 。\n\n对数组 $a$ 执行 **按位或** ,结果等于 $a[0]$ `OR` $a[1]$ `OR` `...` `OR` $a[a.length - 1]$(下标从 $0$ 开始)。\n\n示例 1:\n```\n输入:nums = [3,1]\n\n输出:2\n\n解释:子集按位或能得到的最大值是 3 。有 2 个子集按位或可以得到 3 :\n- [3]\n- [3,1]\n```\n示例 2:\n```\n输入:nums = [2,2,2]\n\n输出:7\n\n解释:[2,2,2] 的所有非空子集的按位或都可以得到 2 。总共有 23 - 1 = 7 个子集。\n```\n示例 3:\n```\n输入:nums = [3,2,1,5]\n\n输出:6\n\n解释:子集按位或可能的最大值是 7 。有 6 个子集按位或可以得到 7 :\n- [3,5]\n- [3,1,5]\n- [3,2,5]\n- [3,2,1,5]\n- [2,5]\n- [2,1,5]\n```\n\n提示:\n* $1 <= nums.length <= 16$\n* $1 <= nums[i] <= 10^5$", "solution": "### 二进制枚举 \n\n令 $n$ 为 $nums$ 的长度,利用 $n$ 不超过 $16$,我们可以使用一个 `int` 数值来代指 $nums$ 的使用情况(子集状态)。\n\n假设当前子集状态为 $state$,$state$ 为一个仅考虑低 $n$ 位的二进制数,当第 $k$ 位为 $1$,代表 $nums[k]$ 参与到当前的按位或运算,当第 $k$ 位为 $0$,代表 $nums[i]$ 不参与到当前的按位或运算。\n\n在枚举这 $2^n$ 个状态过程中,我们使用变量 `max` 记录最大的按位或得分,使用 `ans` 记录能够取得最大得分的状态数量。\n\n代码:\n```Java\nclass Solution {\n    public int countMaxOrSubsets(int[] nums) {\n        int n = nums.length, mask = 1 << n;\n        int max = 0, ans = 0;\n        for (int s = 0; s < mask; s++) {\n            int cur = 0;\n            for (int i = 0; i < n; i++) {\n                if (((s >> i) & 1) == 1) cur |= nums[i];\n            }\n            if (cur > max) {\n                max = cur; ans = 1;\n            } else if (cur == max) {\n                ans++;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $nums$ 长度为 $n$,共有 $2^n$ 个子集状态,计算每个状态的按位或得分的复杂度为 $O(n)$。整体复杂度为 $O(2^n * n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 状压 DP\n\n为了优化解法一中「每次都要计算某个子集的得分」这一操作,我们可以将所有状态的得分记下来,采用「动态规划」思想进行优化。\n\n需要找到当前状态 $state$ 可由哪些状态转移而来:假设当前 $state$ 中处于最低位的 $1$ 位于第 $idx$ 位,首先我们可以使用 `lowbit` 操作得到「仅保留第 $idx$ 的 $1$ 所对应的数值」,记为 $lowbit$,那么显然对应的状态方程为:\n\n$$\nf[state] = f[state - lowbit] \\wedge nums[idx]\n$$\n\n再配合我们从小到大枚举所有的 $state$ 即可确保计算 $f[state]$ 时所依赖的 $f[state - lowbit]$ 已被计算。\n\n最后为了快速知道数值 $lowbit$ 最低位 $1$ 所处于第几位(也就是 $idx$ 为何值),我们可以利用 $nums$ 长度最多不超过 $16$ 来进行「打表」预处理。\n\n代码:\n```Java\nclass Solution {\n    static Map<Integer, Integer> map = new HashMap<>();\n    static {\n        for (int i = 0; i < 20; i++) map.put((1 << i), i);\n    }\n    public int countMaxOrSubsets(int[] nums) {\n        int n = nums.length, mask = 1 << n;\n        int[] f = new int[mask];\n        int max = 0, ans = 0;\n        for (int s = 1; s < mask; s++) {\n            int lowbit = (s & -s);\n            int prev = s - lowbit, idx = map.get(lowbit);\n            f[s] = f[prev] | nums[idx];\n            if (f[s] > max) {\n                max = f[s]; ans = 1;\n            } else if (f[s] == max) {\n                ans++;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(2^n)$\n* 空间复杂度:$O(2^n)$\n\n---\n\n### DFS\n\n解法一将「枚举子集/状态」&「计算状态对应的得分」两个过程分开进行,导致了复杂度上界为 $O(2^n * n)$。\n\n事实上,我们可以在「枚举子集」的同时「计算相应得分」,设计 `void dfs(int u, int val)` 的 `DFS`  函数来实现「爆搜」,其中 $u$ 为当前的搜索到 $nums$ 的第几位,$val$ 为当前的得分情况。\n\n对于任意一位 $x$ 而言,都有「选」和「不选」两种选择,分别对应了 `dfs(u + 1, val | nums[x])` 和 `dfs(u + 1, val)` 两条搜索路径,在搜索所有状态过程中,使用全局变量 `max` 和 `ans` 来记录「最大得分」以及「取得最大得分的状态数量」。\n\n该做法将多条「具有相同前缀」的搜索路径的公共计算部分进行了复用,从而将算法复杂度下降为 $O(2^n)$。\n\n代码:\n```Java\nclass Solution {\n    int[] nums;\n    int max = 0, ans = 0;\n    public int countMaxOrSubsets(int[] _nums) {\n        nums = _nums;\n        dfs(0, 0);\n        return ans;\n    }\n    void dfs(int u, int val) {\n        if (u == nums.length) {\n            if (val > max) {\n                max = val; ans = 1;\n            } else if (val == max) {\n                ans++;\n            }\n            return ;\n        }\n        dfs(u + 1, val);\n        dfs(u + 1, val | nums[u]);\n    }\n}\n```\n* 时间复杂度:令 $nums$ 长度为 $n$,共有 $2^n$ 个子集状态。整体复杂度为 $O(2^n)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2044` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2041-2050/2045. 到达目的地的第二短时间（困难）.md", "url_title": "2045. 到达目的地的第二短时间", "url": "https://leetcode-cn.com/problems/second-minimum-time-to-reach-destination/solution/gong-shui-san-xie-yi-ti-shuang-jie-dui-y-88np/", "difficulty": "困难", "tags": ["最短路", "BFS", "堆优化 Dijkstra", "AStar 算法", "启发式搜索"], "question": "城市用一个 双向连通 图表示,图中有 $n$ 个节点,从 $1$ 到 $n$ 编号(包含 $1$ 和 $n$)。图中的边用一个二维整数数组 $edges$ 表示,其中每个 $edges[i] = [u_i, v_i]$ 表示一条节点 $u_i$ 和节点 $v_i$ 之间的双向连通边。每组节点对由 最多一条 边连通,顶点不存在连接到自身的边。穿过任意一条边的时间是 $time$ 分钟。\n\n每个节点都有一个交通信号灯,每 $change$ 分钟改变一次,从绿色变成红色,再由红色变成绿色,循环往复。所有信号灯都 同时 改变。你可以在 任何时候 进入某个节点,但是 只能 在节点 信号灯是绿色时 才能离开。如果信号灯是  绿色 ,你 不能 在节点等待,必须离开。\n\n第二小的值 是 严格大于 最小值的所有值中最小的值。\n\n* 例如,`[2, 3, 4]` 中第二小的值是 $3$ ,而 `[2, 2, 4]` 中第二小的值是 $4$ 。\n给你 $n$、$edges$、$time$ 和 $change$ ,返回从节点 $1$ 到节点 $n$ 需要的 第二短时间 。\n\n注意:\n\n* 你可以 任意次 穿过任意顶点,包括 1 和 n 。\n* 你可以假设在 启程时 ,所有信号灯刚刚变成 绿色 。\n\n示例 1:\n\n```\n输入:n = 5, edges = [[1,2],[1,3],[1,4],[3,4],[4,5]], time = 3, change = 5\n\n输出:13\n\n解释:\n上面的左图展现了给出的城市交通图。\n右图中的蓝色路径是最短时间路径。\n花费的时间是:\n- 从节点 1 开始,总花费时间=0\n- 1 -> 4:3 分钟,总花费时间=3\n- 4 -> 5:3 分钟,总花费时间=6\n因此需要的最小时间是 6 分钟。\n\n右图中的红色路径是第二短时间路径。\n- 从节点 1 开始,总花费时间=0\n- 1 -> 3:3 分钟,总花费时间=3\n- 3 -> 4:3 分钟,总花费时间=6\n- 在节点 4 等待 4 分钟,总花费时间=10\n- 4 -> 5:3 分钟,总花费时间=13\n因此第二短时间是 13 分钟。    \n```\n\n示例 2:\n\n```\n输入:n = 2, edges = [[1,2]], time = 3, change = 2\n\n输出:11\n\n解释:\n最短时间路径是 1 -> 2 ,总花费时间 = 3 分钟\n最短时间路径是 1 -> 2 -> 1 -> 2 ,总花费时间 = 11 分钟\n```\n\n提示:\n* $2 <= n <= 10^4$\n* $n - 1 <= edges.length <= min(2 * 10^4, n * (n - 1) / 2)$\n* $edges[i].length == 2$\n* $1 <= u_i, v_i <= n$\n* $u_i != v_i$\n* 不含重复边\n* 每个节点都可以从其他节点直接或者间接到达\n* $1 <= time, change <= 10^3$", "solution": "### 堆优化 Dijkstra\n\n整体题意:在一张正权无向图上求严格次短路,该图无重边与自环。\n\n同时根据提示 $edges.length <= \\min(2 * 10^4, n * (n - 1) / 2)$ 可知,该图为「稀疏图」,容易想到「堆优化 Dijkstra」做法。\n\n对「堆优化 Dijkstra」或者「其他最短路算法」不熟悉的同学,可以看前置 🧀 :[【最短路/必背模板】涵盖所有的「存图方式」与「最短路算法(详尽注释)」](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488007&idx=1&sn=9d0dcfdf475168d26a5a4bd6fcd3505d&chksm=fd9cb918caeb300e1c8844583db5c5318a89e60d8d552747ff8c2256910d32acd9013c93058f&token=211780171&lang=zh_CN#rd)。内容如题,首次接触的话,建议每个模板先敲十遍。\n\n回到本题,与常规的「求最短路」不同,本题需要求得「严格次短路」,我们可以在原来的最短路算法基础上($dist1[]$ 数组用于记录最短路)多引入一个 $dist2[]$ 数组,$dist2[x]$ 用于记录从节点 $1$ 到节点 $x$ 的严格次短路。\n\n维护次短路是容易的,基本思路为:\n\n* 若当前距离 $dist$ 小于 $dist1[x]$,原本的最短路 $dist1[x]$ 沦为次短路 $dist2[x]$,即先用 $dist1[x]$ 更新 $dist2[x]$ 后,再用 $dist$ 更新 $dist1[x]$;\n* 若当前距离 $dist$ 等于 $dist1[x]$,不符合「严格次短路」,忽略;\n* 若当前距离 $dist$ 大于 $dist1[x]$,且 $dist$ 小于 $dist2[x]$,则使用 $dist$ 更新 $dist2[x]$。\n\n同时,由于处理「严格次短路包含重复边」的情况,我们无须使用 $vis[]$ 数组记录处理过的点,而要确保每次「最短路」或者「次短路」被更新时,都进行入堆操作。\n\n然后考虑「红绿灯」切换问题,这本质是引入动态边权,假设我们当前经过 $step$ 步到达节点 $i$,根据其与 $change$ 的关系分情况讨论即可:\n\n* $\\left \\lfloor \\frac{step}{change} \\right \\rfloor$ 为偶数:当前处于绿灯,动态边权为 $0$;\n* $\\left \\lfloor \\frac{step}{change} \\right \\rfloor$ 为奇数:当前处于红灯,需要增加动态边权(等待时间),增加的动态边权为 `change - (step % change)`。\n\n最后,为了避免每个样例都 `new` 大数组,我们可以使用 `static` 修饰需要用到的数组,并在执行逻辑前进行重置工作。\n\n代码:\n```Java\nclass Solution {\n    static int N = 10010, M = 4 * N, INF = 0x3f3f3f3f, idx = 0;\n    static int[] he = new int[N], e = new int[M], ne = new int[M];\n    static int[] dist1 = new int[N], dist2 = new int[N];\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx;\n        idx++;\n    }\n    public int secondMinimum(int n, int[][] edges, int time, int change) {\n        Arrays.fill(dist1, INF);\n        Arrays.fill(dist2, INF);\n        Arrays.fill(he, -1);\n        idx = 0;\n        for (int[] e : edges) {\n            int u = e[0], v = e[1];\n            add(u, v); add(v, u);\n        }\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[1]-b[1]);\n        q.add(new int[]{1, 0});\n        dist1[1] = 0;\n        while (!q.isEmpty()) {\n            int[] poll = q.poll();\n            int u = poll[0], step = poll[1];\n            for (int i = he[u]; i != -1; i = ne[i]) {\n                int j = e[i];\n                int a = step / change, b = step % change;\n                int wait = a % 2 == 0 ? 0 : change - b;\n                int dist = step + time + wait;\n                if (dist1[j] > dist) {\n                    dist2[j] = dist1[j];\n                    dist1[j] = dist;\n                    q.add(new int[]{j, dist1[j]});\n                    q.add(new int[]{j, dist2[j]});\n                } else if (dist1[j] < dist && dist < dist2[j]) {\n                    dist2[j] = dist;\n                    q.add(new int[]{j, dist2[j]});\n                }\n            }\n        }\n        return dist2[n];\n    }\n}\n```\n* 时间复杂度:令 $n$ 为点数,$m$ 为边数,堆优化 Dijkstra 的复杂度为 $O(m\\log{n})$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### BFS\n\n更进一步,原图边权虽然由「固定部分 $time$」和「动态部分 $change$ 相关」所组成,但在路径固定的前提下,其实边权之和完全确定。\n\n因此我们可以先将原图等价为边权为 $1$ 的新图,通过 `BFS` 求出最短路 $dist1[x]$ 和严格次短路 $dist2[x]$,然后利用此时的 $dist2[n]$ 其实是严格次短路的边数,计算原图上的边权之和。\n\n代码:\n```Java\nclass Solution {\n    static int N = 10010, M = 4 * N, INF = 0x3f3f3f3f, idx = 0;\n    static int[] he = new int[N], e = new int[M], ne = new int[M];\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx;\n        idx++;\n    }\n    public int secondMinimum(int n, int[][] edges, int time, int change) {\n        Arrays.fill(he, -1);\n        idx = 0;\n        for (int[] e : edges) {\n            int u = e[0], v = e[1];\n            add(u, v); add(v, u);\n        }\n        Deque<int[]> d = new ArrayDeque<>();\n        int[] dist1 = new int[n + 10], dist2 = new int[n + 10];\n        Arrays.fill(dist1, INF);\n        Arrays.fill(dist2, INF);\n        d.addLast(new int[]{1, 0});\n        dist1[1] = 0;\n        while (!d.isEmpty()) {\n            int[] poll = d.pollFirst();\n            int u = poll[0], dist = poll[1];\n            for (int i = he[u]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (dist1[j] > dist + 1) {\n                    dist2[j] = dist1[j];\n                    dist1[j] = dist + 1;\n                    d.addLast(new int[]{j, dist1[j]});\n                    d.addLast(new int[]{j, dist2[j]});\n                } else if (dist1[j] < dist + 1 && dist + 1 < dist2[j]) {\n                    dist2[j] = dist + 1;\n                    d.addLast(new int[]{j, dist2[j]});\n                }\n            }\n        }\n        int ans = 0;\n        for (int i = 0; i < dist2[n]; i++) {\n            int a = ans / change, b = ans % change;\n            int wait = a % 2 == 0 ? 0 : change - b;\n            ans += time + wait;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为点数,$m$ 为边数,BFS 的复杂度为 $O(n + m)$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### AStar 算法\n\n在 `BFS` 的基础上再进一步,我们可以将问题拓展为「使用 AStar 算法来找第 `K` 短路」(修改代码的 `K` 即可),利用终点的第 $k$ 次出队必然是第 $k$ 短路(注意要求的是严格的第 $k$ 短路)。\n\n代码:\n```Java\nclass Solution {\n    static int N = 10010, M = 4 * N, INF = 0x3f3f3f3f, K = 2, idx = 0, n = 0;\n    static int[] he = new int[N], e = new int[M], ne = new int[M];\n    static int[] dist = new int[N];\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx;\n        idx++;\n    }\n    void bfs() {\n        Arrays.fill(dist, INF);\n        Deque<Integer> d = new ArrayDeque<>();\n        d.addLast(n);\n        dist[n] = 0;\n        while (!d.isEmpty()) {\n            int x = d.pollFirst(), step = dist[x];\n            for (int i = he[x]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (dist[j] != INF) continue;\n                dist[j] = step + 1;\n                d.addLast(j);\n            }\n        }\n    }\n    int astar() {\n        int k = K, min = -1;\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[2]-b[2]);\n        q.add(new int[]{1, 0, dist[1]});\n        while (!q.isEmpty()) {\n            int[] poll = q.poll();\n            int x = poll[0], step = poll[1];\n            if (x == n && min != step) {\n                min = step;\n                if (--k == 0) return min; \n            }\n            for (int i = he[x]; i != -1; i = ne[i]) {\n                int j = e[i];\n                q.add(new int[]{j, step + 1, step + 1 + dist[j]});\n            }\n        }\n        return -1; // never\n    }\n    public int secondMinimum(int _n, int[][] edges, int time, int change) {\n        n = _n; idx = 0;\n        Arrays.fill(he, -1);\n        for (int[] e : edges) {\n            int u = e[0], v = e[1];\n            add(u, v); add(v, u);\n        }\n        bfs();\n        int cnt = astar(), ans = 0;\n        for (int i = 0; i < cnt; i++) {\n            int a = ans / change, b = ans % change;\n            int wait = a % 2 == 0 ? 0 : change - b;\n            ans += time + wait;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:启发式搜索不讨论时空复杂度\n* 空间复杂度:启发式搜索不讨论时空复杂度", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2045` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2041-2050/2047. 句子中的有效单词数（简单）.md", "url_title": "2047. 句子中的有效单词数", "url": "https://leetcode-cn.com/problems/number-of-valid-words-in-a-sentence/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-5pcz/", "difficulty": "简单", "tags": ["模拟", "双指针"], "question": "句子仅由小写字母(`'a'` 到 `'z'`)、数字('0' 到 '9')、连字符(`'-'`)、标点符号(`'!'`、`'.'` 和 `','`)以及空格(`' '`)组成。每个句子可以根据空格分解成 一个或者多个 `token` ,这些 `token` 之间由一个或者多个空格 `' '` 分隔。\n\n如果一个 `token` 同时满足下述条件,则认为这个 `token` 是一个有效单词:\n\n* 仅由小写字母、连字符和/或标点(不含数字)。\n* 至多一个 连字符 `'-'` 。如果存在,连字符两侧应当都存在小写字母(`\"a-b\"` 是一个有效单词,但 `\"-ab\"` 和 `\"ab-\"` 不是有效单词)。\n* 至多一个 标点符号。如果存在,标点符号应当位于 `token` 的 末尾 。\n这里给出几个有效单词的例子:`\"a-b.\"`、`\"afad\"`、`\"ba-c\"`、`\"a!\"` 和 `\"!\"` 。\n\n给你一个字符串 `sentence` ,请你找出并返回 `sentence` 中 有效单词的数目 。\n\n示例 1:\n```\n输入:sentence = \"cat and  dog\"\n\n输出:3\n\n解释:句子中的有效单词是 \"cat\"、\"and\" 和 \"dog\"\n```\n示例 2:\n```\n输入:sentence = \"!this  1-s b8d!\"\n\n输出:0\n\n解释:句子中没有有效单词\n\"!this\" 不是有效单词,因为它以一个标点开头\n\"1-s\" 和 \"b8d\" 也不是有效单词,因为它们都包含数字\n```\n示例 3:\n```\n输入:sentence = \"alice and  bob are playing stone-game10\"\n\n输出:5\n\n解释:句子中的有效单词是 \"alice\"、\"and\"、\"bob\"、\"are\" 和 \"playing\"\n\"stone-game10\" 不是有效单词,因为它含有数字\n```\n示例 4:\n```\n输入:sentence = \"he bought 2 pencils, 3 erasers, and 1  pencil-sharpener.\"\n\n输出:6\n\n解释:句子中的有效单词是 \"he\"、\"bought\"、\"pencils,\"、\"erasers,\"、\"and\" 和 \"pencil-sharpener.\"\n```\n\n提示:\n* $1 <= sentence.length <= 1000$\n* `sentence` 由小写英文字母、数字(`0-9`)、以及字符(`' '`、`'-'`、`'!'`、`'.'` 和 ',')组成\n* 句子中至少有 $1$ 个 `token`", "solution": "### 模拟\n\n根据题意进行模拟即可,先将 `sentence` 按照空格进行分割,得到多个 `item`,再对每个 `item` 进行合法性检查,最后统计合法的 `item` 个数即为答案。\n\n在对 `item` 进行合法性检查时,分别使用 $c1$ 和 $c2$ 代表「连字符」和「标点符号」的出现次数。\n\n> 特别说明:Java 的 `split` 操作基于正则,复杂度为线性,其他语言可能需要使用「双指针」手写 `split` 操作\n\n代码( 双指针实现 `split` 的代码见 $P2$ ):\n```Java\nclass Solution {\n    public int countValidWords(String sentence) {\n        String[] ss = sentence.split(\" \");\n        int ans = 0;\n        for (String s : ss) if (check(s)) ans++;\n        return ans;\n    }\n    boolean check(String s) {\n        int n = s.length();\n        if (n == 0) return false;\n        for (int i = 0, c1 = 0, c2 = 0; i < n; i++) {\n            char c = s.charAt(i);\n            if (Character.isDigit(c)) return false;\n            if (c == ' ') return false;\n            if (c == '-' && ++c1 >= 0) {\n                if (c1 > 1 || (i == 0 || i == n - 1)) return false;\n                if (!Character.isLetter(s.charAt(i - 1)) || !Character.isLetter(s.charAt(i + 1))) return false;\n            }\n            if ((c == '!' || c == '.' || c == ',') && ++c2 >= 0) {\n                if (c2 > 1 || (i != n - 1)) return false;\n            }\n        }\n        return true;\n    }\n}\n```\n-\n```Java\nclass Solution {\n    public int countValidWords(String sentence) {\n        int n = sentence.length(), ans = 0;\n        for (int i = 0; i < n; ) {\n            if (sentence.charAt(i) == ' ' && ++i >= 0) continue;\n            int j = i;\n            while (j < n && sentence.charAt(j) != ' ') j++;\n            if (check(sentence.substring(i, j))) ans++;\n            i = j + 1;\n        }\n        return ans;\n    }\n    boolean check(String s) {\n        int n = s.length();\n        if (n == 0) return false;\n        for (int i = 0, c1 = 0, c2 = 0; i < n; i++) {\n            char c = s.charAt(i);\n            if (Character.isDigit(c)) return false;\n            if (c == ' ') return false;\n            if (c == '-' && ++c1 >= 0) {\n                if (c1 > 1 || (i == 0 || i == n - 1)) return false;\n                if (!Character.isLetter(s.charAt(i - 1)) || !Character.isLetter(s.charAt(i + 1))) return false;\n            }\n            if ((c == '!' || c == '.' || c == ',') && ++c2 >= 0) {\n                if (c2 > 1 || (i != n - 1)) return false;\n            }\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:执行过程会产生若干子串,子串总长度与 `s` 相同。复杂度为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2047` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2041-2050/2049. 统计最高分的节点数目（中等）.md", "url_title": "2049. 统计最高分的节点数目", "url": "https://leetcode-cn.com/problems/count-nodes-with-the-highest-score/solution/gong-shui-san-xie-jian-tu-dfs-by-ac_oier-ujfo/", "difficulty": "中等", "tags": ["图论", "线性 DP"], "question": "给你一棵根节点为 $0$ 的 二叉树 ,它总共有 $n$ 个节点,节点编号为 $0$ 到 $n - 1$ 。\n\n同时给你一个下标从 $0$ 开始的整数数组 $parents$ 表示这棵树,其中 $parents[i]$ 是节点 $i$ 的父节点。由于节点 $0$ 是根,所以 $parents[0] == -1$ 。\n\n一个子树的 **大小** 为这个子树内节点的数目。每个节点都有一个与之关联的 **分数** 。求出某个节点分数的方法是,将这个节点和与它相连的边全部 **删除** ,剩余部分是若干个 **非空** 子树,这个节点的 **分数** 为所有这些子树 大小的乘积 。\n\n请你返回有 **最高得分** 节点的 数目 。\n\n示例 1:\n\n```\n输入:parents = [-1,2,0,2,0]\n\n输出:3\n\n解释:\n- 节点 0 的分数为:3 * 1 = 3\n- 节点 1 的分数为:4 = 4\n- 节点 2 的分数为:1 * 1 * 2 = 2\n- 节点 3 的分数为:4 = 4\n- 节点 4 的分数为:4 = 4\n最高得分为 4 ,有三个节点得分为 4 (分别是节点 1,3 和 4 )。\n```\n示例 2:\n\n```\n输入:parents = [-1,2,0]\n\n输出:2\n\n解释:\n- 节点 0 的分数为:2 = 2\n- 节点 1 的分数为:2 = 2\n- 节点 2 的分数为:1 * 1 = 1\n最高分数为 2 ,有两个节点分数为 2 (分别为节点 0 和 1 )。\n```\n\n提示:\n* $n == parents.length$\n* $2 <= n <= 10^5$\n* $parents[0] == -1$\n* 对于 $i != 0$ ,有 $0 <= parents[i] <= n - 1$\n* $parents$ 表示一棵二叉树。", "solution": "### 建图 + DFS + 统计答案\n\n为了更具有一般性,我们假定该树为多叉树。\n\n由于题目给定的 `parents` 数组仅支持我们快速查找某个节点的父节点,为了方便遍历整棵树,我们先使用「邻接表」将图(树)建起来。\n\n还不熟悉「邻接表」存图方式的同学可以看看前置 🧀 : [涵盖所有的「存图方式」模板](https%3A//mp.weixin.qq.com/s?__biz%3DMzU4NDE3MTEyMA%3D%3D%26mid%3D2247488007%26idx%3D1%26sn%3D9d0dcfdf475168d26a5a4bd6fcd3505d%26chksm%3Dfd9cb918caeb300e1c8844583db5c5318a89e60d8d552747ff8c2256910d32acd9013c93058f%26mpshare%3D1%26scene%3D23%26srcid%3D0311tjKy74JijYzXhHo8Qob7%26sharer_sharetime%3D1646964421353%26sharer_shareid%3D1221771780968b30ef07c3f22cd356ed%2523rd)。\n\n然后使用 `DFS` 预处理出 `f` 数组,其中 $f[i]$ 代表以节点 $i$ 为根节点的子树所包含的节点数量。\n\n考虑如何计算「删除某个节点 $x$ 后,剩余连通块的数量,以及每个连通块的节点数量」,根据节点 $x$ 是否为根节点进行分情况讨论:\n\n* 若 $x$ 为根节点,删除后的连通块的数量为「$x$ 的出边数量」,假定共有 $k$ 条出边,根据题目定义,对应的 **大小** 为各个连通块的节点数量乘积:\n$$\nf[u_1] \\times f[u_2] \\times ... \\times f[u_k]\n$$\n\n* 若 $x$ 不是根节点,删除后的连通块的数量为「$x$ 的出边数量 + $1$」,其中 $1$ 代指「以 $x$ 节点的父节点所在的整体连通块」。\n\n    假定节点 $x$ 共有 $k$ 条出边,根据题目定义,对应的 **大小** 为「(各个连通块的节点数量乘积) $\\times$ ($x$ 节点的父节点所在的整体连通块大小)」,而「$x$ 节点的父节点所在的整体连通块大小」,利用容斥原理可知为 $f[root] - f[u] = n - f[u]$,含义为「从原树中减掉以节点 $x$ 为根节点的子树」的部分,即最终 **大小** 为:\n$$\n(f[u_1] \\times f[u_2] \\times ... \\times f[u_k]) \\times (n - f[x])\n$$\n\n代码:\n```Java\nclass Solution {\n    static int N = 100010, M = N * 2;\n    static int[] he = new int[N], e = new int[M], ne = new int[M];\n    static int[] f = new int[N];\n    int idx;\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    public int countHighestScoreNodes(int[] parents) {\n        Arrays.fill(he, -1);\n        int n = parents.length;\n        for (int i = 1; i < n; i++) add(parents[i], i);\n        dfs(0);\n        long max = 0;\n        int ans = 0;\n        for (int x = 0; x < n; x++) {\n            long cur = 1;\n            for (int i = he[x]; i != -1; i = ne[i]) cur *= f[e[i]];\n            if (x != 0) cur *= n - f[x];\n            if (cur > max) {\n                max = cur; ans = 1;\n            } else if (cur == max) {\n                ans++;\n            }\n        }\n        return ans;\n    }\n    int dfs(int u) {\n        int ans = 1;\n        for (int i = he[u]; i != -1; i = ne[i]) ans += dfs(e[i]);\n        f[u] = ans;\n        return ans;\n    }\n}\n```\n* 时间复杂度:建图复杂度为 $O(n)$;通过 `DFS` 预处理 `f` 数组复杂度为 $O(n + m)$,其中 $m$ 为边数,对于本题(二叉树)而言,点边数量级相等,因此 `DFS` 预处理的复杂度为 $O(n)$;模拟删除任意点并统计答案的复杂度为 $O(n + m)$,对于本题(二叉树)而言,数量级为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 拓扑排序 + 统计答案\n\n通过对「待删除节点是否为根节点」的分情况讨论可知:若要算得删除某个节点后的得分,重点需要知道「当前节点的左右子树(如果有)所包含的节点数量」以及「当前节点的父节点所在连通块的节点数量」。\n\n我们解法 $1$ 的建图目的就是为了得到某个节点的子树情况,`DFS` 预处理 `f` 数组的目的就是知道以某个节点为根的子树所包含的总节点数量。\n\n而这个「建图 + `DFS`」过程可由「拓扑排序」所代替。\n\n具体的,我们可以先对 `parents`进行遍历, 统计所有节点的出度 $out[i]$,然后将所有出度为 $0$ 的节点(叶子节点)进行入队。跑一遍求拓扑排序的 `BFS`,每次某个节点 $t$ 出队,我们就对节点 $t$ 的父节点 $fa = parents[t]$ 进行出度减一操作(若出度减至 $0$,则将 $fa$ 进行入队,注意 $fa$ 不能为根节点,因为 $fa$ 入队没有意义,其入队不能更新其他点的出度),并在求拓扑序的过程中预处理出 `l` 和 `r` 数组,$l[i]$ 和 $r[i]$ 分别代表节点 $i$ 的左子树的节点数和右节点的节点数。\n\n跑完拓扑排序后,我们得到的 `l` 和 `r` 数组就足够我们统计答案,仍然是对删除节点 $x$ 是否为根节点的分情况讨论:\n\n* 若 $x$ 不是根节点,得分为 $\\max(l[x], 1) \\times \\max( r[x], 1)$\n* 若 $x$ 为根节点,得分为 $\\max(l[x], 1) \\times \\max( r[x], 1) \\times (n - (l[x] + r[x] + 1)$\n\n代码:\n```Java\nclass Solution {\n    public int countHighestScoreNodes(int[] parents) {\n        int n = parents.length;\n        int[] out = new int[n];\n        for (int i = 1; i < n; i++) out[parents[i]]++;\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            if (out[i] == 0) d.addLast(i);\n        }\n        // l[i] 和 r[i] 分别代表节点 i 的左子树的节点数和右节点的节点数\n        int[] l = new int[n], r = new int[n];\n        while (!d.isEmpty()) {\n            int t = d.pollFirst(), fa = parents[t];\n            out[fa]--;\n            if (l[fa] == 0) l[fa] = l[t] + r[t] + 1;\n            else r[fa] = l[t] + r[t] + 1;\n            if (out[fa] == 0 && fa != 0) d.addLast(fa);\n        }\n        long max = 0;\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            long cur = Math.max(l[i], 1) * Math.max(r[i], 1);\n            if (i != 0) cur *= n - (l[i] + r[i] + 1);\n            if (cur > max) {\n                max = cur; ans = 1;\n            } else if (cur == max) {\n                ans++;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2049` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2051-2060/2055. 蜡烛之间的盘子（中等）.md", "url_title": "2055. 蜡烛之间的盘子", "url": "https://leetcode-cn.com/problems/plates-between-candles/solution/gong-shui-san-xie-er-fen-qian-zhui-he-yu-0qt0/", "difficulty": "中等", "tags": ["前缀和", "二分"], "question": "给你一个长桌子,桌子上盘子和蜡烛排成一列。给你一个下标从 $0$ 开始的字符串 `s` ,它只包含字符 `'*'` 和 `'|'` ,其中 `'*'` 表示一个 盘子 ,`'|'` 表示一支 蜡烛 。\n\n同时给你一个下标从 $0$ 开始的二维整数数组 `queries` ,其中 $queries[i] = [lefti, righti]$ 表示 子字符串 $s[left_i...right_i]$ (包含左右端点的字符)。对于每个查询,你需要找到 子字符串中 在 两支蜡烛之间 的盘子的 数目 。如果一个盘子在 子字符串中 左边和右边 都 至少有一支蜡烛,那么这个盘子满足在 两支蜡烛之间 。\n\n比方说,`s = \"||**||**|*\"` ,查询 $[3, 8]$ ,表示的是子字符串 `\"*||**|\"` 。子字符串中在两支蜡烛之间的盘子数目为 $2$ ,子字符串中右边两个盘子在它们左边和右边 都 至少有一支蜡烛。\n请你返回一个整数数组 $answer$ ,其中 $answer[i]$ 是第 $i$ 个查询的答案。\n\n示例 1:\n\n```\n输入:s = \"**|**|***|\", queries = [[2,5],[5,9]]\n\n输出:[2,3]\n\n解释:\n- queries[0] 有两个盘子在蜡烛之间。\n- queries[1] 有三个盘子在蜡烛之间。\n```\n示例 2:\n\n```\n输入:s = \"***|**|*****|**||**|*\", queries = [[1,17],[4,5],[14,17],[5,11],[15,16]]\n\n输出:[9,0,0,0,0]\n\n解释:\n- queries[0] 有 9 个盘子在蜡烛之间。\n- 另一个查询没有盘子在蜡烛之间。\n```\n\n提示:\n* $3 <= s.length <= 10^5$\n* `s` 只包含字符 `'*'` 和 `'|'` 。\n* $1 <= queries.length <= 10^5$\n* $queries[i].length == 2$\n* $0 <= lefti <= righti < s.length$", "solution": "### 二分 + 前缀和\n\n对于任意一个查询 $[a, b]$ 而言,我们需要统计所有左边和右边能够找到蜡烛的盘子数量。\n\n一个自然的想法是:**找到区间 $[a, b]$ 两边缘的蜡烛,分别记为 $c$ 和 $d$,显然区间 $[c, d]$ 内的盘子都是需要被统计的。**\n\n因此,我们可以对字符串 `s` 进行从前往后的扫描,将所有的蜡烛下标添加到数组(数组严格递增),并预处理出盘子的「前缀和」数组。\n\n然后处理询问时的「找区间 $[a, b]$ 边缘蜡烛」操作可通过对数组「二分」来做,而「查询区间 $[c, d]$ 内的盘子数量」操作可直接查询「前缀和」数组。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] platesBetweenCandles(String s, int[][] qs) {\n        char[] cs = s.toCharArray();\n        int n = cs.length, m = qs.length;\n        int[] ans = new int[m], sum = new int[n + 1];\n        List<Integer> list = new ArrayList<>();\n        for (int i = 0; i < n; i++) {\n            if (cs[i] == '|') list.add(i);\n            sum[i + 1] = sum[i] + (cs[i] == '*' ? 1 : 0);\n        }\n        if (list.size() == 0) return ans;\n        for (int i = 0; i < m; i++) {\n            int a = qs[i][0], b = qs[i][1];\n            int c = -1, d = -1;\n            // 找到 a 右边最近的蜡烛\n            int l = 0, r = list.size() - 1;\n            while (l < r) {\n                int mid = l + r >> 1;\n                if (list.get(mid) >= a) r = mid;\n                else l = mid + 1;\n            }\n            if (list.get(r) >= a) c = list.get(r);\n            else continue;\n            // 找到 b 左边最近的蜡烛\n            l = 0; r = list.size() - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (list.get(mid) <= b) l = mid;\n                else r = mid - 1;\n            }\n            if (list.get(r) <= b) d = list.get(r);\n            else continue;\n            if (c <= d) ans[i] = sum[d + 1] - sum[c];\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> platesBetweenCandles(string s, vector<vector<int>>& qs) {\n        vector<int> ans(qs.size(), 0);\n        vector<int> sum(s.length() + 1, 0);\n        vector<int> list;\n        for (int i = 0; i < s.length(); i++) {\n            if (s[i] == '|') list.push_back(i);\n            sum[i + 1] = sum[i] + (s[i] == '*' ? 1 : 0);\n        }\n        if (list.empty()) return ans;\n        for (int i = 0; i < qs.size(); i++) {\n            int a = qs[i][0], b = qs[i][1];\n            int c = -1, d = -1;\n            // 找到 a 右边最近的蜡烛\n            int l = 0, r = list.size() - 1;\n            while (l < r) {\n                int mid = l + r >> 1;\n                if (list[mid] >= a) r = mid;\n                else l = mid + 1;\n            }\n            if (list[r] >= a) c = list[r];\n            else continue;\n            // 找到 b 左边最近的蜡烛\n            l = 0; r = list.size() - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (list[mid] <= b) l = mid;\n                else r = mid - 1;\n            }\n            if (list[r] <= b) d = list[r];\n            else continue;\n            if (c <= d) ans[i] = sum[d + 1] - sum[c];\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def platesBetweenCandles(self, s: str, qs: List[List[int]]) -> List[int]:\n        ans = [0] * len(qs)\n        sum_val = [0] * (len(s) + 1)\n        candle_positions = [i for i, char in enumerate(s) if char == '|']\n        for i in range(len(s)):\n            sum_val[i + 1] = sum_val[i] + (s[i] == '*')\n        if not candle_positions:\n            return ans\n        for i in range(len(qs)):\n            a, b = qs[i]\n            c, d = -1, -1\n            # 找到 a 右边最近的蜡烛\n            l, r = 0, len(candle_positions) - 1\n            while l < r:\n                mid = l + r >> 1\n                if candle_positions[mid] >= a:\n                    r = mid\n                else:\n                    l = mid + 1\n            if candle_positions[r] >= a:\n                c = candle_positions[r]\n            else:\n                continue\n            # 找到 b 左边最近的蜡烛\n            l, r = 0, len(candle_positions) - 1\n            while l < r:\n                mid = l + r + 1 >> 1\n                if candle_positions[mid] <= b:\n                    l = mid\n                else:\n                    r = mid - 1\n            if candle_positions[r] <= b:\n                d = candle_positions[r]\n            else:\n                continue\n            if c <= d:\n                ans[i] = sum_val[d + 1] - sum_val[c]\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction platesBetweenCandles(s: string, qs: number[][]): number[] {\n    const ans = new Array(qs.length).fill(0);\n    const sum = new Array(s.length + 1).fill(0);\n    const list = [];\n    for (let i = 0; i < s.length; i++) {\n        if (s[i] == '|') list.push(i);\n        sum[i + 1] = sum[i] + (s[i] === '*' ? 1 : 0);\n    }\n    if (list.length == 0) return ans;\n    for (let i = 0; i < qs.length; i++) {\n        const a = qs[i][0], b = qs[i][1];\n        let c = -1, d = -1;\n        // 找到 a 右边最近的蜡烛\n        let l = 0, r = list.length - 1;\n        while (l < r) {\n            const mid = l + r >> 1;\n            if (list[mid] >= a) r = mid;\n            else l = mid + 1;\n        }\n        if (list[r] >= a) c = list[r];\n        else continue;\n        // 找到 b 左边最近的蜡烛\n        l = 0; r = list.length - 1;\n        while (l < r) {\n            const mid = l + r + 1 >> 1;\n            if (list[mid] <= b) l = mid;\n            else r = mid - 1;\n        }\n        if (list[r] <= b) d = list[r];\n        else continue;\n        if (c <= d) ans[i] = sum[d + 1] - sum[c];\n    }\n    return ans; \n};\n```\n* 时间复杂度:令 `s` 的长度为 $n$,`qs` 长度为 $m$。统计所有的蜡烛并存入 `list` 的复杂度为 $O(n)$;预处理前缀和数组复杂度为 $O(n)$;处理单个询问需要进行两次二分(蜡烛数量最多为 $n$),复杂度为 $O(\\log{n})$,共有 $m$ 个询问需要处理,复杂度为 $O(m \\times \\log{n})$。整体复杂度为 $O(n + m\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 前缀和 \n\n更进一步,在给定 `s` 的前提下,每个位置其左边和右边最近的蜡烛唯一确定。\n\n我们可以在预处理前缀和的同时,预处理每个位置左右最近的蜡烛下标,从而省去每次二分。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] platesBetweenCandles(String s, int[][] qs) {\n        char[] cs = s.toCharArray();\n        int n = cs.length, m = qs.length;\n        int[] l = new int[n], r = new int[n];\n        int[] sum = new int[n + 1];\n        for (int i = 0, j = n - 1, p = -1, q = -1; i < n; i++, j--) {\n            if (cs[i] == '|') p = i;\n            if (cs[j] == '|') q = j;\n            l[i] = p; r[j] = q;\n            sum[i + 1] = sum[i] + (cs[i] == '*' ? 1 : 0);\n        }\n        int[] ans = new int[m];\n        for (int i = 0; i < m; i++) {\n            int a = qs[i][0], b = qs[i][1];\n            int c = r[a], d = l[b];\n            if (c != -1 && c <= d) ans[i] = sum[d + 1] - sum[c];\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> platesBetweenCandles(string s, vector<vector<int>>& qs) {\n        vector<int> l(s.length(), 0), r(s.length(), 0);\n        vector<int> sum(s.length() + 1, 0);\n        for (int i = 0, j = s.length() - 1, p = -1, q = -1; i < s.length(); i++, j--) {\n            if (s[i] == '|') p = i;\n            if (s[j] == '|') q = j;\n            l[i] = p; r[j] = q;\n            sum[i + 1] = sum[i] + (s[i] == '*' ? 1 : 0);\n        }\n        vector<int> ans(qs.size(), 0);\n        for (int i = 0; i < qs.size(); i++) {\n            int a = qs[i][0], b = qs[i][1];\n            int c = r[a], d = l[b];\n            if (c != -1 && c <= d) ans[i] = sum[d + 1] - sum[c];\n        }\n        return ans;\n    }\n};\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2055` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2051-2060/2059. 转化数字的最小运算数（中等）.md", "url_title": "2059. 转化数字的最小运算数", "url": "https://leetcode-cn.com/problems/minimum-operations-to-convert-number/solution/gong-shui-san-xie-shuang-xiang-bfs-mo-ba-uckg/", "difficulty": "中等", "tags": ["图论 BFS", "双向 BFS"], "question": "给你一个下标从 `0` 开始的整数数组 `nums`,该数组由 互不相同 的数字组成。\n\n另给你两个整数 `start` 和 `goal` 。\n\n整数 `x` 的值最开始设为 `start` ,你打算执行一些运算使 `x` 转化为 `goal` 。\n\n你可以对数字 `x` 重复执行下述运算:\n\n如果 `0 <= x <= 1000`,那么,对于数组中的任一下标 `i` `(0 <= i < nums.length)`,可以将 `x` 设为下述任一值:\n* `x + nums[i]`\n* `x - nums[i]`\n* `x ^ nums[i](按位异或 XOR)`\n\n注意,你可以按任意顺序使用每个 `nums[i]` 任意次。使 `x` 越过 `0 <= x <= 1000` 范围的运算同样可以生效,但该该运算执行后将不能执行其他运算。\n\n返回将 `x = start` 转化为 `goal` 的最小操作数;如果无法完成转化,则返回 `-1` 。\n\n示例 1:\n```\n输入:nums = [1,3], start = 6, goal = 4\n\n输出:2\n\n解释:\n可以按 6 → 7 → 4 的转化路径进行,只需执行下述 2 次运算:\n- 6 ^ 1 = 7\n- 7 ^ 3 = 4\n```\n示例 2:\n```\n输入:nums = [2,4,12], start = 2, goal = 12\n\n输出:2\n\n解释:\n可以按 2 → 14 → 12 的转化路径进行,只需执行下述 2 次运算:\n- 2 + 12 = 14\n- 14 - 2 = 12\n```\n示例 3:\n```\n输入:nums = [3,5,7], start = 0, goal = -4\n\n输出:2\n\n解释:\n可以按 0 → 3 → -4 的转化路径进行,只需执行下述 2 次运算:\n- 0 + 3 = 3\n- 3 - 7 = -4\n注意,最后一步运算使 x 超过范围 0 <= x <= 1000 ,但该运算仍然可以生效。\n```\n示例 4:\n```\n输入:nums = [2,8,16], start = 0, goal = 1\n\n输出:-1\n\n解释:\n无法将 0 转化为 1\n```\n示例 5:\n```\n输入:nums = [1], start = 0, goal = 3\n\n输出:3\n\n解释:\n可以按 0 → 1 → 2 → 3 的转化路径进行,只需执行下述 3 次运算:\n- 0 + 1 = 1 \n- 1 + 1 = 2\n- 2 + 1 = 3\n```\n\n提示:\n* $1 <= nums.length <= 1000$\n* $-10^9 <= nums[i], goal <= 10^9$\n* $0 <= start <= 1000$\n* start != goal\n* $nums$ 中的所有整数互不相同", "solution": "### 常规 BFS\n\n题目给定了从当前值 $x$ 到 $x'$ 的转换规则,同时只有满足 $0 <= x <= 1000$ 的数值才能继续进行转换,因此配合去重,转换次数具有明确上界,使用常规的 `BFS`  即可求解。\n\n需要注意的是,为了避免 TLE,我们应当将「满足 $0 <= x <= 1000$ 才能进行下一步转换」这一规则应用到「限制入队」,而不是简单的应用在「限制拓展」。\n\n即如果由 $x$ 拓展出来的 $x'$,既不与 $goal$ 相等,也不满足 $0 <= x' <= 1000$ 条件,那么 $x'$ 并无入队必要。\n\n代码:\n```Java\nclass Solution {\n    public int minimumOperations(int[] nums, int s, int t) {\n        Deque<Integer> d = new ArrayDeque<>();\n        Map<Integer, Integer> map = new HashMap<>();\n        d.addLast(s);\n        map.put(s, 0);\n        while (!d.isEmpty()) {\n            int cur = d.pollFirst();\n            int step = map.get(cur);\n            for (int i : nums) {\n                int[] result = new int[]{cur + i, cur - i, cur ^ i};\n                for (int next : result) {\n                    if (next == t) return step + 1;\n                    if (next < 0 || next > 1000) continue;\n                    if (map.containsKey(next)) continue;\n                    map.put(next, step + 1);\n                    d.addLast(next);\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为 $nums$ 的长度,常数 $C$ 为队列内元素的值域大小(本题值域范围为 $[0, 1000]$ )。整体复杂度为 $O(C * n)$\n* 空间复杂度:$O(C)$\n\n---\n\n### 双向 BFS\n\n这还是一道很好的双向 `BFS` 模板题。\n\n之前我没有找到这样的模板题,不得已使用了 LeetCode 难度标记为「困难」的 [127. 单词接龙](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&token=1901895674&lang=zh_CN#rd) 来作为双向 `BFS`  的入门题。\n\n> PS. 事实上,那道题也不难,如果你还没做过 [127. 单词接龙](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&token=1901895674&lang=zh_CN#rd),在学习完本题解后,可以尝试做一下。\n\n回到本题,我们可以同时从两个方向进行搜索:\n\n1. 正向搜索:使用队列 `d1` 实现从 $start$ 到 $goal$ 的通路搜索,为满足「$0 <= x <= 1000$」的条件限制,我们需要进行「出队检查」,只有满足「$0 <= x <= 1000$」的出队元素,才进行下一步的拓展;\n2. 反向搜索:使用队列 `d2` 实现从 $goal$ 到 $start$ 的通路搜索,为满足「$0 <= x <= 1000$」的条件限制,我们需要进行「入队检查」,只有下一个拓展元素 $next$ 满足「$0 <= x <= 1000$」才能进行入队。\n\n同时,我们使用两个「哈希表」分别记录两个搜索方向中出现过的结果。\n\n一旦在某条搜索通路中搜到了另一条搜索通路中出现过的结果,说明找到了一条合法的搜索通路,返回该通路长度。\n\n代码:\n```Java\nclass Solution {\n    int[] nums;\n    public int minimumOperations(int[] _nums, int s, int t) {\n        nums = _nums;\n        Deque<Long> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();\n        Map<Long, Integer> m1 = new HashMap<>(), m2 = new HashMap<>();\n        d1.addLast(s * 1L);\n        d2.addLast(t * 1L);\n        m1.put(s * 1L, 0);\n        m2.put(t * 1L, 0);\n        while (!d1.isEmpty() && !d2.isEmpty()) {\n            if (d1.size() < d2.size()) {\n                int ans = update(d1, m1, d2, m2, true);\n                if (ans != -1) return ans;\n            } else {\n                int ans = update(d2, m2, d1, m1, false);\n                if (ans != -1) return ans;\n            }\n        }\n        return -1;\n    }\n    int update(Deque<Long> d1, Map<Long, Integer> m1, Deque<Long> d2, Map<Long, Integer> m2, boolean flag) {\n        int m = d1.size();\n        while (m-- > 0) {\n            long cur = d1.pollFirst();\n            int step = m1.get(cur);\n            for (int i : nums) {\n                if (flag) {\n                    // 正向搜索:进行出队检查,只有出队元素符合条件,才能使用出队元素往下拓展\n                    if (0 <= cur && cur <= 1000) {\n                        long[] result = new long[]{cur + i, cur - i, cur ^ i};\n                        for (long next : result) {\n                            if (m2.containsKey(next)) return step + 1 + m2.get(next);\n                            if (!m1.containsKey(next)) {\n                                d1.addLast(next);\n                                m1.put(next, step + 1);\n                            }\n                        }\n                    }\n                } else {\n                    // 反向搜索:进行入队检查,只有拓展元素符合条件,才能将拓展元素入队\n                    long[] result = new long[]{cur + i, cur - i, cur ^ i};\n                    for (long next : result) {\n                        if (0 <= next && next <= 1000) {\n                            if (m2.containsKey(next)) return step + 1 + m2.get(next);\n                            if (!m1.containsKey(next)) {\n                                d1.addLast(next);\n                                m1.put(next, step + 1);\n                            }   \n                        }\n                    }\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为 $nums$ 的长度,常数 $C$ 为队列内元素的值域大小(本题值域范围为 $[0, 1000]$ )。整体复杂度为 $O(C * n)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2059` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2061-2070/2069. 模拟行走机器人 II（中等）.md", "url_title": "2069. 模拟行走机器人 II", "url": "https://leetcode-cn.com/problems/walking-robot-simulation-ii/solution/by-ac_oier-6zib/", "difficulty": "中等", "tags": ["模拟", "脑筋急转弯"], "question": "给你一个在 `XY` 平面上的 `width x height` 的网格图,左下角 的格子为 $(0, 0)$,右上角的格子为 $(width - 1, height - 1)$ 。网格图中相邻格子为四个基本方向之一(`\"North\"`,`\"East\"`,`\"South\"` 和 `\"West\"`)。一个机器人初始在格子 $(0, 0)$ ,方向为 `\"East\"`。\n\n机器人可以根据指令移动指定的步数。每一步,它可以执行以下操作。\n\n1. 沿着当前方向尝试往前一步 。\n2. 如果机器人下一步将到达的格子超出了边界,机器人会逆时针转 90 度,然后再尝试往前一步。\n\n如果机器人完成了指令要求的移动步数,它将停止移动并等待下一个指令。\n\n请你实现 `Robot` 类:\n* `Robot(int width, int height)` 初始化一个 `width x height` 的网格图,机器人初始在 $(0, 0)$,方向朝 `\"East\"`。\n* `void move(int num)` 给机器人下达前进 `num` 步的指令。\n* `int[] getPos()` 返回机器人当前所处的格子位置,用一个长度为 $2$ 的数组 $[x, y]$ 表示。\n* `String getDir()` 返回当前机器人的朝向,为 `\"North\"`,`\"East\"`,`\"South\"` 或者 `\"West\"`。\n\n示例 1:\n\n```\n输入:\n[\"Robot\", \"move\", \"move\", \"getPos\", \"getDir\", \"move\", \"move\", \"move\", \"getPos\", \"getDir\"]\n[[6, 3], [2], [2], [], [], [2], [1], [4], [], []]\n\n输出:\n[null, null, null, [4, 0], \"East\", null, null, null, [1, 2], \"West\"]\n\n解释:\nRobot robot = new Robot(6, 3); // 初始化网格图,机器人在 (0, 0) ,朝东。\nrobot.move(2);  // 机器人朝东移动 2 步,到达 (2, 0) ,并朝东。\nrobot.move(2);  // 机器人朝东移动 2 步,到达 (4, 0) ,并朝东。\nrobot.getPos(); // 返回 [4, 0]\nrobot.getDir(); // 返回 \"East\"\nrobot.move(2);  // 朝东移动 1 步到达 (5, 0) ,并朝东。\n                // 下一步继续往东移动将出界,所以逆时针转变方向朝北。\n                // 然后,往北移动 1 步到达 (5, 1) ,并朝北。\nrobot.move(1);  // 朝北移动 1 步到达 (5, 2) ,并朝 北 (不是朝西)。\nrobot.move(4);  // 下一步继续往北移动将出界,所以逆时针转变方向朝西。\n                // 然后,移动 4 步到 (1, 2) ,并朝西。\nrobot.getPos(); // 返回 [1, 2]\nrobot.getDir(); // 返回 \"West\"\n```\n\n提示:\n* $2 <= width, height <= 100$\n* $1 <= num <= 10^5$\n* `move`,`getPos` 和 `getDir` 总共调用次数不超过 $10^4$ 次。", "solution": "### 模拟\n\n根据题目给定的移动规则可知,机器人总是在外圈移动(共上下左右四条),而移动方向分为四类:\n\n当行走步数为 $mod = 2 * (w - 1) + 2 * (h - 1)$ 的整数倍时,会回到起始位置,因此我们可以通过维护一个变量 `loc` 来记录行走的总步数,并且每次将 `loc` 对 `mod` 进行取模来得到有效步数。\n\n在回答 `getPos` 和 `getDir` 询问时,根据当前 `loc` 进行分情况讨论(见注释)。\n\n另外还有一个小细节:根据题意,如果当前处于 $(0, 0)$ 位置,并且没有移动过,方向为 `East`,若移动过,方向则为 `South`,这可以通过一个变量 `moved` 来进行特判处理。\n\n代码:\n```Java\nclass Robot {\n    String[] ss = new String[]{\"East\", \"North\", \"West\", \"South\"};\n    int w, h, loc; // loc: 有效(取模后)移动步数\n    boolean moved; // 记录是否经过移动,用于特判 (0,0) 的方向\n    public Robot(int width, int height) {\n        w = width; h = height;\n    }\n    public void step(int num) {\n        moved = true;\n        loc += num;\n        loc %= 2 * (w - 1) + 2 * (h - 1);\n    }\n    public int[] getPos() {\n        int[] info = move();\n        return new int[]{info[0], info[1]};\n    }\n    public String getDir() {\n        int[] info = move();\n        int x = info[0], y = info[1], dir = info[2];\n        // 特殊处理当前在 (0,0) 的情况,当未移动过方向为 East,移动过方向为 South\n        if (x == 0 && y == 0) return moved ? ss[3] : ss[0];\n        return ss[dir];\n    }\n    int[] move() {\n        if (loc <= w - 1) {\n            // 当移动步数范围在 [0,w-1] 时,所在位置为外圈的下方,方向为 East\n            return new int[]{loc, 0, 0};\n        } else if (loc <= (w - 1) + (h - 1)) {\n            // 当移动步数范围在 [w,(w-1)+(h-1)] 时,所在位置为外圈的右方,方向为 North\n            return new int[]{w - 1, loc - (w - 1), 1};\n        } else if (loc <= 2 * (w - 1) + (h - 1)) {\n            // 当移动步数范围在 [(w-1)+(h-1)+1,2*(w-1)+(h-1)] 时,所在位置为外圈的上方,方向为 West\n            return new int[]{(w - 1) - (loc - ((w - 1) + (h - 1))), h - 1, 2};\n        } else {\n            // 当移动步数范围在 [2*(w-1)+(h-1)+1,2*(w-1)+2*(h-1)] 时,所在位置为外圈的左方,方向为 South\n            return new int[]{0, (h - 1) - (loc - (2 * (w - 1) + (h - 1))), 3};\n        }\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2069` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2091-2100/2100. 适合打劫银行的日子（中等）.md", "url_title": "2100. 适合打劫银行的日子", "url": "https://leetcode-cn.com/problems/find-good-days-to-rob-the-bank/solution/gong-shui-san-xie-qian-zhui-he-yun-yong-gf604/", "difficulty": "中等", "tags": ["前缀和"], "question": "你和一群强盗准备打劫银行。给你一个下标从 $0$ 开始的整数数组 $security$ ,其中 $security[i]$ 是第 $i$ 天执勤警卫的数量。日子从 $0$ 开始编号。同时给你一个整数 $time$ 。\n\n如果第 $i$ 天满足以下所有条件,我们称它为一个适合打劫银行的日子:\n\n* 第 $i$ 天前和后都分别至少有 $time$ 天。\n* 第 $i$ 天前连续 $time$ 天警卫数目都是非递增的。\n* 第 $i$ 天后连续 $time$ 天警卫数目都是非递减的。\n\n更正式的,第 $i$ 天是一个合适打劫银行的日子当且仅当:\n\n$security[i - time] >= security[i - time + 1] >= ... >= security[i] <= ... <= security[i + time - 1] <= security[i + time]$\n\n请你返回一个数组,包含 所有 适合打劫银行的日子(下标从 $0$ 开始)。返回的日子可以 **任意** 顺序排列。\n\n示例 1:\n```\n输入:security = [5,3,3,3,5,6,2], time = 2\n\n输出:[2,3]\n\n解释:\n第 2 天,我们有 security[0] >= security[1] >= security[2] <= security[3] <= security[4] 。\n第 3 天,我们有 security[1] >= security[2] >= security[3] <= security[4] <= security[5] 。\n没有其他日子符合这个条件,所以日子 2 和 3 是适合打劫银行的日子。\n```\n示例 2:\n```\n输入:security = [1,1,1,1,1], time = 0\n\n输出:[0,1,2,3,4]\n\n解释:\n因为 time 等于 0 ,所以每一天都是适合打劫银行的日子,所以返回每一天。\n```\n示例 3:\n```\n输入:security = [1,2,3,4,5,6], time = 2\n\n输出:[]\n\n解释:\n没有任何一天的前 2 天警卫数目是非递增的。\n所以没有适合打劫银行的日子,返回空数组。\n```\n示例 4:\n```\n输入:security = [1], time = 5\n\n输出:[]\n\n解释:\n没有日子前面和后面有 5 天时间。\n所以没有适合打劫银行的日子,返回空数组。\n```\n\n提示:\n* $1 <= security.length <= 10^5$\n* $0 <= security[i], time <= 10^5$", "solution": "### 前缀和\n\n为了方便,我们令 $n$ 为 $security$ 长度。\n\n根据题目对「适合打劫银行的日子」的定义,首先我们可以确定答案落在 $[time, n - time]$ 范围内,另外规定了「适合打劫银行的日子」左右侧需要满足「非递增」和「非递减」的性质。\n\n首先我们可以预处理 `g` 数组,$g[i]$ 代表当前时间 $security[i]$ 与前一时间 $security[i - 1]$ 的大小关系,当 $security[i] > security[i - 1]$ 时有 $g[i] = 1$,当 $security[i] < security[i - 1]$ 时有 $g[i] = -1$,否则 $g[i] = 0$,另外我们特别的有 $g[0] = 0$ 的边界情况。\n\n然后我们对 `g` 应用「前缀和」思想:使用 `a` 数组记录前缀 $1$ 的数量,使用 `b` 数组记录前缀 $-1$ 的数量。\n\n最终,如果 $i$ 为「适合打劫银行的日子」,那么满足 $time <= i <= n - time$,且满足 $(i - time, i]$ 范围前缀 $1$ 数量为 $0$,$(i, i + time]$ 范围前缀 $-1$ 数量为 $0$。\n\n代码:\n```Java\nclass Solution {\n    public List<Integer> goodDaysToRobBank(int[] security, int time) {\n        int n = security.length;\n        int[] g = new int[n];\n        for (int i = 1; i < n; i++) {\n            if (security[i] == security[i - 1]) continue;\n            g[i] = security[i] > security[i - 1] ? 1 : -1;\n        }\n        int[] a = new int[n + 1], b = new int[n + 1];\n        for (int i = 1; i <= n; i++) a[i] = a[i - 1] + (g[i - 1] == 1 ? 1 : 0);\n        for (int i = 1; i <= n; i++) b[i] = b[i - 1] + (g[i - 1] == -1 ? 1 : 0);\n        List<Integer> ans = new ArrayList<>();\n        for (int i = time; i < n - time; i++) {\n            int c1 = a[i + 1] - a[i + 1 - time], c2 = b[i + 1 + time] - b[i + 1];\n            if (c1 == 0 && c2 == 0) ans.add(i);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2100` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/21-30/21. 合并两个有序链表（简单）.md", "url_title": "21. 合并两个有序链表", "url": "https://leetcode-cn.com/problems/merge-two-sorted-lists/solution/shua-chuan-lc-shuang-zhi-zhen-jie-fa-sha-b22z/", "difficulty": "简单", "tags": ["多路归并", "链表"], "question": "将两个升序链表合并为一个新的 升序 链表并返回。\n\n新链表是通过拼接给定的两个链表的所有节点组成的。 \n\n示例 1:\n\n```\n输入:l1 = [1,2,4], l2 = [1,3,4]\n\n输出:[1,1,2,3,4,4]\n```\n示例 2:\n```\n输入:l1 = [], l2 = []\n\n输出:[]\n```\n示例 3:\n```\n输入:l1 = [], l2 = [0]\n\n输出:[0]\n```\n\n提示:\n* 两个链表的节点数目范围是 $[0, 50]$\n* $-100 <= Node.val <= 100$\n* `l1` 和 `l2` 均按 非递减顺序 排列", "solution": "### 多路归并(哨兵技巧)\n\n哨兵技巧我们之前在「2. 两数相加」讲过啦,让三叶来帮你回忆一下:\n\n**做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。**\n\n由于两条链表本身就是有序的,只需要在遍历过程中进行比较即可:\n\n代码:\n```Java\nclass Solution {\n    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {\n        if (l1 == null) return l2;    \n        if (l2 == null) return l1;\n                \n        ListNode dummy = new ListNode(0);\n        ListNode cur = dummy;\n        while (l1 != null && l2 != null) {\n            if (l1.val < l2.val) {\n                cur.next = l1;\n                cur = cur.next;\n                l1 = l1.next;\n            } else {\n                cur.next = l2;\n                cur = cur.next;\n                l2 = l2.next;\n            } \n        }\n        \n        while (l1 != null) {\n            cur.next = l1;\n            cur = cur.next;\n            l1 = l1.next;\n        }\n        while (l2 != null) {\n            cur.next = l2;\n            cur = cur.next;\n            l2 = l2.next;\n        }\n        \n        return dummy.next;\n    }\n}\n```\n* 时间复杂度:对两条链表扫描一遍。复杂度为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.21` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/21-30/22. 括号生成（中等）.md", "url_title": "22. 括号生成", "url": "https://leetcode-cn.com/problems/generate-parentheses/solution/shua-chuan-lc-dfs-jie-fa-by-ac_oier-nknl/", "difficulty": "中等", "tags": ["DFS", "回溯算法"], "question": "数字 $n$ 代表生成括号的对数,请你设计一个函数,用于能够生成所有可能的并且 有效的 括号组合。\n\n示例 1:\n```\n输入:n = 3\n\n输出:[\"((()))\",\"(()())\",\"(())()\",\"()(())\",\"()()()\"]\n```\n示例 2:\n```\n输入:n = 1\n\n输出:[\"()\"]\n```\n\n提示:\n* $1 <= n <= 8$", "solution": "### DFS\n\n既然题目是求所有的方案,那只能爆搜了,爆搜可以使用 `DFS` 来做。\n\n从数据范围 `1 <= n <= 8` 来说,`DFS` 应该是稳稳的 AC。\n\n这题的关键是我们要从题目中发掘一些性质:\n\n1. 括号数为 `n`,那么一个合法的括号组合,应该包含 `n` 个左括号和 `n` 个右括号,组合总长度为 `2n`\n\n2. 一对合法的括号,应该是先出现左括号,再出现右括号。那么意味着**任意一个右括号的左边,至少有一个左括号**\n\n其中性质 2 是比较难想到的,我们可以用反证法来证明性质 2 总是成立:\n\n假设某个右括号不满足「其左边至少有一个左括号」,即其左边没有左括号,那么这个右括号就找不到一个与之对应的左括号进行匹配。\n\n这样的组合必然不是有效的括号组合。\n\n使用我们「20. 有效的括号(简单)」的思路(栈)去验证的话,必然验证不通过。\n\n掌握了这两个性质之后,我们可以设定一个初始值为 0 的得分值,令往组合添加一个 `(` 得分值 + 1,往组合添加一个 `)` 得分值 -1。\n\n这样就有:\n\n1. 一个合法的括号组合,最终得分必然为 0 (左括号和右括号的数量相等,对应了性质 1)\n\n2. 整个 `DFS` 过程中,得分值范围在 `[0, n]`(得分不可能超过 `n` 意味着不可能添加数量超过 `n` 的左括号,对应了性质 1;得分不可能为负数,意味着每一个右括号必然有一个左括号进行匹配,对应性质 2)\n\n代码:\n```Java\nclass Solution {\n    public List<String> generateParenthesis(int n) {\n        List<String> ans = new ArrayList<>();\n        dfs(0, n * 2, 0, n, \"\", ans);\n        return ans;\n    }\n\n    /**\n    * i: 当前遍历到位置\n    * n: 字符总长度\n    * score: 当前得分,令 '(' 为 1, ')' 为 -1\n    * max: 最大得分值\n    * path: 当前的拼接结果\n    * ans: 最终结果集\n    */\n    void dfs(int i, int n, int score, int max, String path, List<String> ans) {\n        if (i == n) {\n            if (score == 0) ans.add(path);\n        } else {\n            if (score + 1 <= max) dfs(i + 1, n, score + 1, max, path + \"(\", ans);\n            if (score - 1 >= 0) dfs(i + 1, n, score - 1, max, path + \")\", ans);\n        }\n    }\n}\n```\n* 时间复杂度:放置的左括号数量为 `n`,右括号的个数总是小于等于左括号的个数,典型的卡特兰数问题。复杂度为 $O(C_{2n}^n)$ \n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.22` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/21-30/23. 合并K个升序链表（困难）.md", "url_title": "23. 合并K个升序链表", "url": "https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/shua-chuan-lc-you-xian-dui-lie-jie-fa-sh-3flb/", "difficulty": "困难", "tags": ["优先队列(堆)", "链表", "多路归并"], "question": "给你一个链表数组,每个链表都已经按升序排列。\n\n请你将所有链表合并到一个升序链表中,返回合并后的链表。\n\n示例 1:\n```\n输入:lists = [[1,4,5],[1,3,4],[2,6]]\n\n输出:[1,1,2,3,4,4,5,6]\n\n解释:链表数组如下:\n[\n  1->4->5,\n  1->3->4,\n  2->6\n]\n将它们合并到一个有序链表中得到。\n1->1->2->3->4->4->5->6\n```\n示例 2:\n```\n输入:lists = []\n\n输出:[]\n```\n示例 3:\n```\n输入:lists = [[]]\n\n输出:[]\n```\n\n提示:\n* $k == lists.length$\n* $0 <= k <= 10^4$\n* $0 <= lists[i].length <= 500$\n* $-10^4 <= lists[i][j] <= 10^4$\n* $lists[i]$ 按 升序 排列\n* $lists[i].length$ 的总和不超过 $10^4$", "solution": "### 多路归并 + 优先队列\n\n**做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。**\n\n由于所有链表本身满足「升序」,一个直观的做法是,我们比较每条链表的头结点,选取值最小的节点,添加到结果中,然后更新该链表的的头结点为该节点的 next 指针。循环比较,直到所有的节点都被加入结果中。\n\n对应到代码的话,相当于我们需要准备一个「集合」,将所有链表的头结点放入「集合」,然后每次都从「集合」中挑出最小值,并将最小值的下一个节点添加进「集合」(如果有的话),循环这个过程,直到「集合」为空(说明所有节点都处理完,进过集合又从集合中出来)。\n\n优先队列(堆)则是满足这样要求的数据结构,而整个过程其实就是「多路归并」过程。\n\n代码:\n```Java\nclass Solution {\n    public ListNode mergeKLists(ListNode[] lists) {\n        ListNode dummy = new ListNode(-1), tail = dummy;\n        PriorityQueue<ListNode> q = new PriorityQueue<>((a,b)->a.val-b.val);\n        for (ListNode node : lists) {\n            if (node != null) q.add(node);\n        }\n        while (!q.isEmpty()) {\n            ListNode poll = q.poll();\n            tail.next = poll;\n            tail = tail.next;\n            if (poll.next != null) q.add(poll.next);\n        }\n        return dummy.next;\n    }\n}\n```\n* 时间复杂度:假设共有 $k$ 条建表,共 $n$ 个节点,复杂度为 $O(n\\log{k})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.23` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/21-30/24. 两两交换链表中的节点（中等）.md", "url_title": "24. 两两交换链表中的节点", "url": "https://leetcode-cn.com/problems/swap-nodes-in-pairs/solution/shua-chuan-lc-di-gui-die-dai-jie-fa-shao-70t3/", "difficulty": "中等", "tags": ["递归", "链表"], "question": "给定一个链表,两两交换其中相邻的节点,并返回交换后的链表。\n\n你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。\n\n示例 1:\n\n```\n输入:head = [1,2,3,4]\n\n输出:[2,1,4,3]\n```\n示例 2:\n```\n输入:head = []\n\n输出:[]\n```\n示例 3:\n```\n输入:head = [1]\n\n输出:[1]\n```\n\n提示:\n* 链表中节点的数目在范围 $[0, 100]$ 内\n* $0 <= Node.val <= 100$\n\n进阶:你能在不修改链表节点值的情况下解决这个问题吗?(也就是说,仅修改节点本身。)", "solution": "### 递归解法(哨兵技巧)\n\n哨兵技巧我们之前在前面的多道链表题讲过,让三叶来帮你回忆一下:\n\n**做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。**\n\n链表和树的题目天然适合使用递归来做。\n\n我们可以设计一个递归函数,接受一个 `ListNode` 节点 root 作为参数,函数的作用是将 root 后面的两个节点进行交换,交换完成后再将下一个节点传入 ... \n\n交换的前提条件:节点 root 后面至少有两个节点。同时别忘了应用我们的「哨兵技巧」。\n\n代码:\n```Java\nclass Solution {\n    public ListNode swapPairs(ListNode head) {\n        ListNode dummy = new ListNode(-1);\n        dummy.next = head;\n        recursive(dummy);\n        return dummy.next;\n    }\n    void recursive(ListNode root) {\n        if (root.next != null && root.next.next != null) {\n            ListNode a = root.next, b = a.next;\n            root.next = b;\n            a.next = b.next;\n            b.next = a;\n            recursive(a);\n        }\n    }\n}\n```\n* 时间复杂度:会将每个节点处理一遍。复杂度为 $O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 迭代解法(哨兵技巧)\n\n所有的递归都能转化为迭代。\n\n代码:\n```Java\nclass Solution {\n    public ListNode swapPairs(ListNode head) {\n        ListNode dummy = new ListNode(-1);\n        dummy.next = head;\n        for (ListNode cur = dummy; cur.next != null && cur.next.next != null;) {\n            ListNode a = cur.next, b = a.next;\n            cur.next = b;\n            a.next = b.next;\n            b.next = a;\n            cur = a;\n        }\n        return dummy.next;\n    }\n}\n```\n* 时间复杂度:会将每个节点处理一遍。复杂度为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.22` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/21-30/25. K 个一组翻转链表（困难）.md", "url_title": "25. K 个一组翻转链表", "url": "https://leetcode-cn.com/problems/reverse-nodes-in-k-group/solution/shua-chuan-lc-duo-tu-jiang-jie-di-gui-gu-6wr0/", "difficulty": "困难", "tags": ["递归", "迭代", "链表"], "question": "给你一个链表,每 `k` 个节点一组进行翻转,请你返回翻转后的链表。\n\n`k` 是一个正整数,它的值小于或等于链表的长度。\n\n如果节点总数不是 `k` 的整数倍,那么请将最后剩余的节点保持原有顺序。\n\n进阶:\n\n* 你可以设计一个只使用常数额外空间的算法来解决此问题吗?\n* 你不能只是单纯的改变节点内部的值,而是需要实际进行节点交换。\n\n示例 1:\n\n```\n输入:head = [1,2,3,4,5], k = 2\n\n输出:[2,1,4,3,5]\n```\n示例 2:\n\n```\n输入:head = [1,2,3,4,5], k = 3\n\n输出:[3,2,1,4,5]\n```\n示例 3:\n```\n输入:head = [1,2,3,4,5], k = 1\n\n输出:[1,2,3,4,5]\n```\n示例 4:\n```\n输入:head = [1], k = 1\n\n输出:[1]\n```\n提示:\n* 列表中节点的数量在范围 `sz` 内\n* $1 <= sz <= 5000$\n* $0 <= Node.val <= 1000$\n* $1 <= k <= sz$", "solution": "### 迭代(哨兵技巧)\n\n哨兵技巧我们在前面的多道链表题讲过,让三叶来帮你回忆一下:\n\n**做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。**\n\n链表和树的题目天然适合使用递归来做。\n\n但这次我们先将简单的「递归版本」放一放,先搞清楚迭代版本该如何实现。\n\n我们可以设计一个翻转函数 `reverse` :\n\n**传入节点 `root` 作为参数,函数的作用是将以 `root` 为起点的 $k$ 个节点进行翻转。**\n\n**当以 `root` 为起点的长度为 $k$ 的一段翻转完成后,再将下一个起始节点传入,直到整条链表都被处理完成。**\n\n**当然,在 `reverse` 函数真正执行翻转前,需要先确保节点 `root` 后面至少有 $k$ 个节点。**\n\n我们可以结合图解再来体会一下这个过程:\n\n假设当前样例为 `1->2->3->4->5->6->7` 和 `k = 3` :\n\n然后我们调用 `reverse(cur, k)`,在 `reverse()` 方法内部,几个指针的指向如图所示,会通过先判断 `cur` 是否为空,从而确定是否有足够的节点进行翻转:\n\n然后先通过 `while` 循环,将中间的数量为 `k - 1` 的 next 指针进行翻转:\n.png)\n\n最后再处理一下局部的头结点和尾结点,这样一次 `reverse(cur, k)` 执行就结束了:\n.png)\n\n回到主方法,将 `cur` 往前移动 `k` 步,再调用 `reverse(cur, k)` 实现 `k` 个一组翻转:\n.png)\n\nJava 代码:\n```Java\nclass Solution {\n    public ListNode reverseKGroup(ListNode head, int k) {\n        ListNode dummy = new ListNode(-1);\n        dummy.next = head;\n        ListNode cur = dummy;\n        while (cur != null) {\n            reverse(cur, k);\n            int u = k;    \n            while (u-- > 0 && cur != null) cur = cur.next;\n        }\n        return dummy.next;\n    }\n    // reverse 的作用是将 root 后面的 k 个节点进行翻转\n    void reverse(ListNode root, int k) {\n        // 检查 root 后面是否有 k 个节点\n        int u = k;\n        ListNode cur = root;\n        while (u-- > 0 && cur != null) cur = cur.next;\n        if (cur == null) return;\n        // 进行翻转\n        ListNode tail = cur.next;\n        ListNode a = root.next, b = a.next;\n        // 当需要翻转 k 个节点时,中间有 k - 1 个 next 指针需要翻转\n        while (k-- > 1) {\n            ListNode c = b.next;\n            b.next = a;\n            a = b;\n            b = c;\n        }\n        root.next.next = tail;\n        root.next = a;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    ListNode* reverseKGroup(ListNode* head, int k) {\n        ListNode* dummy = new ListNode(-1);\n        dummy->next = head;\n        ListNode* cur = dummy;\n        while (cur != NULL) {\n            reverse(cur, k);\n            int u = k;\n            while (u-- > 0 && cur != NULL) cur = cur->next;\n        }\n        return dummy->next;\n    }\n    // reverse 的作用是将 root 后面的 k 个节点进行翻转\n    void reverse(ListNode* root, int k) {\n        // 检查 root 后面是否有 k 个节点\n        int u = k;\n        ListNode* cur = root;\n        while (u-- > 0 && cur != NULL) cur = cur->next;\n        if (cur == NULL) return;\n        // 进行翻转\n        ListNode* tail = cur->next;\n        ListNode* a = root->next, *b = a->next;\n        // 当需要翻转 k 个节点时,中间有 k - 1 个 next 指针需要翻转\n        while (k-- > 1) {\n            ListNode* c = b->next;\n            b->next = a;\n            a = b;\n            b = c;\n        }\n        root->next->next = tail;\n        root->next = a;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:\n        # reverse 的作用是将 root 后面的 k 个节点进行翻转\n        def reverse(root, k):\n            # 检查 root 后面是否有 k 个节点\n            u, cur = k, root\n            while u > 0 and cur:\n                cur = cur.next\n                u -= 1\n            if not cur: return\n            # 进行翻转\n            tail = cur.next\n            a, b = root.next, root.next.next\n            # 当需要翻转 k 个节点时,中间有 k - 1 个 next 指针需要翻转\n            while k > 1:\n                c, b.next = b.next, a\n                a, b = b, c\n                k -= 1\n            root.next.next = tail\n            root.next = a\n\n        dummy = ListNode(-1)\n        dummy.next = head\n        cur = dummy\n        while cur:\n            reverse(cur, k)\n            u = k\n            while u > 0 and cur:\n                cur = cur.next\n                u -= 1\n        return dummy.next\n```\nTypeScript 代码:\n```TypeScript\nfunction reverseKGroup(head: ListNode | null, k: number): ListNode | null {\n    // reverse 的作用是将 root 后面的 k 个节点进行翻转\n    const reverse = function(root: ListNode | null, k: number): void {\n        // 检查 root 后面是否有 k 个节点\n        let u = k, cur = root;\n        while (u-- > 0 && cur != null) cur = cur.next;\n        if (cur == null) return;\n        // 进行翻转\n        let tail = cur.next, a = root.next, b = a.next;\n        // 当需要翻转 k 个节点时,中间有 k - 1 个 next 指针需要翻转\n        while (k-- > 1) {\n            let c = b.next;\n            b.next = a;\n            a = b;\n            b = c;\n        }\n        root.next.next = tail;\n        root.next = a;\n    };\n    let dummy = new ListNode(-1);\n    dummy.next = head;\n    let cur = dummy;\n    while (cur != null) {\n        reverse(cur, k);\n        let u = k;\n        while (u-- > 0 && cur != null) cur = cur.next;\n    }\n    return dummy.next;\n};\n```\n* 时间复杂度:会将每个节点处理一遍。复杂度为 $O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 递归\n\n搞懂了较难的「迭代哨兵」版本之后,常规的「递归无哨兵」版本写起来应该更加容易了。\n\n需要注意的是,当我们不使用「哨兵」时,检查是否足够 $k$ 位,只需要检查是否有 $k - 1$ 个 $next$ 指针即可。\n\n代码:\n```Java\nclass Solution {\n    public ListNode reverseKGroup(ListNode head, int k) {\n        int u = k;\n        ListNode p = head;\n        while (p != null && u-- > 1) p = p.next;\n        if (p == null) return head;\n        ListNode tail = head;\n        ListNode prev = head, cur = prev.next;\n        u = k;\n        while (u-- > 1) {\n            ListNode tmp = cur.next;\n            cur.next = prev;\n            prev = cur;\n            cur = tmp;\n        }\n        tail.next = reverseKGroup(cur, k);\n        return prev;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    ListNode* reverseKGroup(ListNode* head, int k) {\n        int u = k;\n        ListNode* p = head;\n        while (p != NULL && u-- > 1) p = p->next;\n        if (p == NULL) return head;\n        ListNode* tail = head;\n        ListNode* prev = head, *cur = prev->next;\n        u = k;\n        while (u-- > 1) {\n            ListNode* tmp = cur->next;\n            cur->next = prev;\n            prev = cur;\n            cur = tmp;\n        }\n        tail->next = reverseKGroup(cur, k);\n        return prev;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:\n        u = k\n        p = head\n        while p and u > 1:\n            p = p.next\n            u -= 1\n        if not p: return head\n\n        tail = prev = head\n        cur = prev.next\n        u = k\n        while u > 1:\n            tmp = cur.next\n            cur.next = prev\n            prev, cur = cur, tmp\n            u -= 1\n        tail.next = self.reverseKGroup(cur, k)\n        return prev\n```\nTypeScript 代码:\n```TypeScript\nfunction reverseKGroup(head: ListNode | null, k: number): ListNode | null {\n    let u = k;\n    let p = head;\n    while (p != null && u-- > 1) p = p.next;\n    if (p == null) return head;\n    let tail = head, prev = head, cur = prev.next;\n    u = k;\n    while (u-- > 1) {\n        let tmp = cur.next;\n        cur.next = prev;\n        prev = cur;\n        cur = tmp;\n    }\n    tail.next = reverseKGroup(cur, k);\n    return prev;\n};\n```\n* 时间复杂度:会将每个节点处理一遍。复杂度为 $O(n)$\n* 空间复杂度:只有忽略递归带来的空间开销才是 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.25` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/21-30/26. 删除有序数组中的重复项（简单）.md", "url_title": "26. 删除有序数组中的重复项", "url": "https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shua-chuan-lc-jian-ji-shuang-zhi-zhen-ji-2eg8/", "difficulty": "简单", "tags": ["数组", "双指针", "数组移除元素问题"], "question": "给你一个有序数组 `nums` ,请你 原地 删除重复出现的元素,使每个元素 只出现一次 ,返回删除后数组的新长度。\n\n不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 $O(1)$ 额外空间的条件下完成。\n\n说明:\n\n为什么返回数值是整数,但输出的答案是数组呢?\n\n请注意,输入数组是以「引用」方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。\n\n你可以想象内部操作如下:\n```\n// nums 是以“引用”方式传递的。也就是说,不对实参做任何拷贝\nint len = removeDuplicates(nums);\n\n// 在函数里修改输入数组对于调用者是可见的。\n// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。\nfor (int i = 0; i < len; i++) {\n    print(nums[i]);\n}\n```\n\n示例 1:\n```\n输入:nums = [1,1,2]\n\n输出:2, nums = [1,2]\n\n解释:函数应该返回新的长度 2 ,并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。\n```\n示例 2:\n```\n输入:nums = [0,0,1,1,1,2,2,3,3,4]\n\n输出:5, nums = [0,1,2,3,4]\n\n解释:函数应该返回新的长度 5 , 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。\n```\n\n提示:\n* $0 <= nums.length <= 3 \\times 10^4$\n* $-10^4 <= nums[i] <= 10^4$\n* `nums` 已按升序排列", "solution": "### 双指针\n\n一个指针 `i` 进行数组遍历,另外一个指针 `j` 指向有效数组的最后一个位置。\n\n只有当 `i` 所指向的值和 `j` 不一致(不重复),才将 `i` 的值添加到 `j` 的下一位置。\n\n代码:\n```Java\nclass Solution {\n    public int removeDuplicates(int[] nums) {\n        int n = nums.length;\n        int j = 0;\n        for (int i = 0; i < n; i++) {\n            if (nums[i] != nums[j]) {\n                nums[++j] = nums[i];\n            }\n        }\n        return j + 1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 通用解法\n\n为了让解法更具有一般性,我们将原问题的「最多保留 1 位」修改为「最多保留 k 位」。\n\n对于此类问题,我们应该进行如下考虑:\n\n* 由于是保留 `k` 个相同数字,**对于前 `k` 个数字,我们可以直接保留。**\n* 对于后面的任意数字,能够保留的前提是:**与当前写入的位置前面的第 `k` 个元素进行比较,不相同则保留。**\n\n举个🌰,我们令 `k=1`,假设有样例:`[3,3,3,3,4,4,4,5,5,5]`\n\n0. 设定变量 `idx`,指向待插入位置。`idx` 初始值为 `0`,目标数组为 `[]`\n\n1. 首先我们先让第 `1` 位直接保留(性质 1)。`idx` 变为 `1`,目标数组为 `[3]`\n\n2. 继续往后遍历,能够保留的前提是与 `idx` 的前面 `1` 位元素不同(性质 2),因此我们会跳过剩余的 `3`,将第一个 `4` 追加进去。`idx` 变为 `2`,目标数组为 `[3,4]`\n\n3. 继续这个过程,跳过剩余的 `4`,将第一个 `5` 追加进去。`idx` 变为 `3`,目标数组为 `[3,4,5]`\n\n4. 当整个数组被扫描完,最终我们得到了目标数组 `[3,4,5]` 和 答案 `idx` 为 `3`。\n\n代码:\n```Java\nclass Solution {\n    public int removeDuplicates(int[] nums) {   \n        return process(nums, 1);\n    }\n    int process(int[] nums, int k) {\n        int idx = 0; \n        for (int x : nums) {\n            if (idx < k || nums[idx - k] != x) nums[idx++] = x;\n        }\n        return idx;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n基于上述解法我们还能做一点小剪枝:**利用目标数组的最后一个元素必然与原数组的最后一个元素相同进行剪枝,从而确保当数组有超过 `k` 个最大值时,数组不会被完整扫描。**\n\n**但需要注意这种「剪枝」同时会让我们单次循环的常数变大,所以仅作为简单拓展。**\n\n代码: \n```Java\nclass Solution {\n    public int removeDuplicates(int[] nums) {\n        int n = nums.length;\n        if (n <= 1) return n;   \n        return process(nums, 1, nums[n - 1]);\n    }\n    int process(int[] nums, int k, int max) {\n        int idx = 0; \n        for (int x : nums) {\n            if (idx < k || nums[idx - k] != x) nums[idx++] = x;\n            if (idx - k >= 0 && nums[idx - k] == max) break;\n        }\n        return idx;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.26` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/21-30/27. 移除元素（简单）.md", "url_title": "27. 移除元素", "url": "https://leetcode-cn.com/problems/remove-element/solution/shua-chuan-lc-shuang-bai-shuang-zhi-zhen-mzt8/", "difficulty": "简单", "tags": ["数组", "双指针", "数组移除元素问题"], "question": "给你一个数组 `nums` 和一个值 `val`,你需要「原地」移除所有数值等于 `val` 的元素,并返回移除后数组的新长度。\n\n不要使用额外的数组空间,你必须仅使用 $O(1)$ 额外空间并「原地」修改输入数组。\n\n元素的顺序可以改变。\n\n你不需要考虑数组中超出新长度后面的元素。\n\n \n\n**说明**:\n\n为什么返回数值是整数,但输出的答案是数组呢?\n\n请注意,输入数组是以「引用」方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。\n\n你可以想象内部操作如下:\n\n```\n// nums 是以“引用”方式传递的。也就是说,不对实参作任何拷贝\nint len = removeElement(nums, val);\n\n// 在函数里修改输入数组对于调用者是可见的。\n// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。\nfor (int i = 0; i < len; i++) {\n    print(nums[i]);\n}\n```\n\n示例 1:\n\n```\n输入:nums = [3,2,2,3], val = 3\n\n输出:2, nums = [2,2]\n\n解释:函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如,函数返回的新长度为 2 ,而 nums = [2,2,3,3] 或 nums = [2,2,0,0],也会被视作正确答案。\n```\n示例 2:\n```\n输入:nums = [0,1,2,2,3,0,4,2], val = 2\n\n输出:5, nums = [0,1,4,0,3]\n\n解释:函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。\n```\n\n提示:\n* $0 <= nums.length <= 100$\n* $0 <= nums[i] <= 50$\n* $0 <= val <= 100$", "solution": "### 双指针\n\n本解法的思路与 [【题解】26. 删除排序数组中的重复项](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shua-chuan-lc-jian-ji-shuang-zhi-zhen-ji-2eg8/) 中的「双指针解法」类似。\n\n根据题意,我们可以将数组分成「前后」两段:\n\n* 前半段是有效部分,存储的是不等于 `val` 的元素。\n* 后半段是无效部分,存储的是等于 `val` 的元素。\n\n最终答案返回有效部分的结尾下标。\n\n代码:\n```Java\nclass Solution {\n    public int removeElement(int[] nums, int val) {\n        int j = nums.length - 1;\n        for (int i = 0; i <= j; i++) {\n            if (nums[i] == val) {\n                swap(nums, i--, j--);\n            }\n        }\n        return j + 1;\n    }\n    void swap(int[] nums, int i, int j) {\n        int tmp = nums[i];\n        nums[i] = nums[j];\n        nums[j] = tmp;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 通用解法\n\n本解法的思路与 [【题解】26. 删除排序数组中的重复项](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shua-chuan-lc-jian-ji-shuang-zhi-zhen-ji-2eg8/) 中的「通用解法」类似。\n\n先设定变量 `idx`,指向待插入位置。`idx` 初始值为 0\n\n**然后从题目的「要求/保留逻辑」出发,来决定当遍历到任意元素 `x` 时,应该做何种决策:**\n* 如果当前元素 `x` 与移除元素 `val` 相同,那么跳过该元素。\n* 如果当前元素 `x` 与移除元素 `val` 不同,那么我们将其放到下标 `idx` 的位置,并让 `idx` 自增右移。\n\n最终得到的 `idx` 即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int removeElement(int[] nums, int val) {\n        int idx = 0;\n        for (int x : nums) {\n            if (x != val) nums[idx++] = x;\n        }\n        return idx;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 总结\n\n**对于诸如「相同元素最多保留 `k` 位元素」或者「移除特定元素」的问题,更好的做法是从题目本身性质出发,利用题目给定的要求提炼出具体的「保留逻辑」,将「保留逻辑」应用到我们的遍历到的每一个位置。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.27` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/21-30/28. 实现 strStr()（简单）.md", "url_title": "28. 实现 strStr()", "url": "https://leetcode-cn.com/problems/implement-strstr/solution/shua-chuan-lc-shuang-bai-po-su-jie-fa-km-tb86/", "difficulty": "简单", "tags": ["子串匹配", "KMP"], "question": "实现 `strStr()` 函数。\n\n给你两个字符串 `haystack` 和 `needle` ,请你在 `haystack` 字符串中找出 `needle` 字符串出现的第一个位置(下标从 $0$ 开始)。\n\n如果不存在,则返回  $-1$ 。 \n\n说明:\n* 当 `needle` 是空字符串时,我们应当返回什么值呢?这是一个在面试中很好的问题。\n\n* 对于本题而言,当 `needle` 是空字符串时我们应当返回 $0$ 。这与 C 语言的 `strstr()` 以及 Java 的 `indexOf()` 定义相符。\n\n示例 1:\n```\n输入:haystack = \"hello\", needle = \"ll\"\n\n输出:2\n```\n示例 2:\n```\n输入:haystack = \"aaaaa\", needle = \"bba\"\n\n输出:-1\n```\n示例 3:\n```\n输入:haystack = \"\", needle = \"\"\n\n输出:0\n```\n\n提示:\n* $0 <= haystack.length, needle.length <= 5 \\times 10^4$\n* `haystack` 和 `needle` 仅由小写英文字符组成", "solution": "### 朴素解法\n\n直观的解法的是:枚举原串 `ss` 中的每个字符作为「发起点」,每次从原串的「发起点」和匹配串的「首位」开始尝试匹配:\n\n* 匹配成功:返回本次匹配的原串「发起点」。\n* 匹配失败:枚举原串的下一个「发起点」,重新尝试匹配。\n\n代码:\n```Java\nclass Solution {\n    public int strStr(String ss, String pp) {\n        int n = ss.length(), m = pp.length();\n        char[] s = ss.toCharArray(), p = pp.toCharArray();\n        // 枚举原串的「发起点」\n        for (int i = 0; i <= n - m; i++) {\n            // 从原串的「发起点」和匹配串的「首位」开始,尝试匹配\n            int a = i, b = 0;\n            while (b < m && s[a] == p[b]) {\n                a++;\n                b++;\n            }\n            // 如果能够完全匹配,返回原串的「发起点」下标\n            if (b == m) return i;\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:`n` 为原串的长度,`m` 为匹配串的长度。其中枚举的复杂度为 $O(n - m)$,构造和比较字符串的复杂度为 $O(m)$。整体复杂度为 $O((n - m) \\times m)$。\n\n* 空间复杂度:$O(1)$。\n\n---\n\n### KMP 解法\n\nKMP 算法是一个快速查找匹配串的算法,它的作用其实就是本题问题:**如何快速在「原字符串」中找到「匹配字符串」。**\n\n上述的朴素解法,不考虑剪枝的话复杂度是 $O(m \\times n)$ 的,而 KMP 算法的复杂度为 $O(m + n)$。\n\n**KMP 之所以能够在 $O(m + n)$ 复杂度内完成查找,是因为其能在「非完全匹配」的过程中提取到有效信息进行复用,以减少「重复匹配」的消耗。**\n\n你可能不太理解,没关系,我们可以通过举 🌰 来理解 KMP。\n\n#### 1. 匹配过程\n\n在模拟 KMP 匹配过程之前,我们先建立两个概念:\n\n* 前缀:对于字符串 `abcxxxxefg`,我们称 `abc` 属于 `abcxxxxefg` 的某个前缀。\n* 后缀:对于字符串 `abcxxxxefg`,我们称 `efg` 属于 `abcxxxxefg` 的某个后缀。\n\n然后我们假设原串为 `abeababeabf`,匹配串为 `abeabf`:\n\n我们可以先看看如果不使用 KMP,会如何进行匹配(不使用 `substring` 函数的情况下)。\n\n首先在「原串」和「匹配串」分别各自有一个指针指向当前匹配的位置。\n\n首次匹配的「发起点」是第一个字符 `a`。显然,后面的 `abeab` 都是匹配的,两个指针会同时往右移动(黑标)。\n\n在都能匹配上 `abeab` 的部分,「朴素匹配」和「KMP」并无不同。\n\n直到出现第一个不同的位置(红标):\n\n**接下来,正是「朴素匹配」和「KMP」出现不同的地方:**\n\n* **先看下「朴素匹配」逻辑:**\n\n**1. 将原串的指针移动至本次「发起点」的下一个位置(`b` 字符处);匹配串的指针移动至起始位置。**\n\n**2. 尝试匹配,发现对不上,原串的指针会一直往后移动,直到能够与匹配串对上位置。**\n\n如图:\n\n也就是说,对于「朴素匹配」而言,一旦匹配失败,将会将原串指针调整至下一个「发起点」,匹配串的指针调整至起始位置,然后重新尝试匹配。\n\n这也就不难理解为什么「朴素匹配」的复杂度是 $O(m \\times n)$ 了。\n\n* **然后我们再看看「KMP 匹配」过程:**\n\n**首先匹配串会检查之前已经匹配成功的部分中里是否存在相同的「前缀」和「后缀」。如果存在,则跳转到「前缀」的下一个位置继续往下匹配:**\n\n**跳转到下一匹配位置后,尝试匹配,发现两个指针的字符对不上,并且此时匹配串指针前面不存在相同的「前缀」和「后缀」,这时候只能回到匹配串的起始位置重新开始:**\n\n**到这里,你应该清楚 KMP 为什么相比于朴素解法更快:**\n\n* **因为 KMP 利用已匹配部分中相同的「前缀」和「后缀」来加速下一次的匹配。**\n\n* **因为 KMP 的原串指针不会进行回溯(没有朴素匹配中回到下一个「发起点」的过程)。**\n\n第一点很直观,也很好理解。\n\n我们可以把重点放在第二点上,原串不回溯至「发起点」意味着什么?\n\n**其实是意味着:随着匹配过程的进行,原串指针的不断右移,我们本质上是在不断地在否决一些「不可能」的方案。**\n\n**当我们的原串指针从 `i` 位置后移到 `j` 位置,不仅仅代表着「原串」下标范围为 $[i,j)$ 的字符与「匹配串」匹配或者不匹配,更是在否决那些以「原串」下标范围为 $[i,j)$ 为「匹配发起点」的子集。**\n\n#### 2. 分析实现\n\n到这里,就结束了吗?要开始动手实现上述匹配过程了吗?\n\n我们可以先分析一下复杂度。如果严格按照上述解法的话,最坏情况下我们需要扫描整个原串,复杂度为 $O(n)$。同时在每一次匹配失败时,去检查已匹配部分的相同「前缀」和「后缀」,跳转到相应的位置,如果不匹配则再检查前面部分是否有相同「前缀」和「后缀」,再跳转到相应的位置 ... 这部分的复杂度是 $O(m^2)$ ,因此整体的复杂度是 $O(n \\times m^2)$,而我们的朴素解法是 $O(m \\times n)$ 的。\n\n说明还有一些性质我们没有利用到。\n\n显然,扫描完整原串操作这一操作是不可避免的,我们可以优化的只能是「**检查已匹配部分的相同前缀和后缀**」这一过程。\n\n再进一步,我们检查「前缀」和「后缀」的目的其实是「为了确定匹配串中的下一段开始匹配的位置」。\n\n**同时我们发现,对于匹配串的任意一个位置而言,由该位置发起的下一个匹配点位置其实与原串无关。**\n\n举个 🌰,对于匹配串 `abcabd` 的字符 `d` 而言,由它发起的下一个匹配点跳转必然是字符 `c` 的位置。因为字符 `d` 位置的相同「前缀」和「后缀」字符 `ab` 的下一位置就是字符 `c`。\n\n**可见从匹配串某个位置跳转下一个匹配位置这一过程是与原串无关的,我们将这一过程称为找 `next` 点。**\n\n**显然我们可以预处理出 `next` 数组,数组中每个位置的值就是该下标应该跳转的目标位置( `next` 点)。**\n\n当我们进行了这一步优化之后,复杂度是多少呢?\n\n预处理 `next` 数组的复杂度未知,匹配过程最多扫描完整个原串,复杂度为 $O(n)$。\n\n因此如果我们希望整个 KMP 过程是 $O(m + n)$ 的话,那么我们需要在 $O(m)$ 的复杂度内预处理出 `next`数组。\n\n**所以我们的重点在于如何在 $O(m)$ 复杂度内处理处 `next` 数组。**\n\n#### 3. `next` 数组的构建\n\n接下来,我们看看 `next` 数组是如何在 $O(m)$ 的复杂度内被预处理出来的。\n\n假设有匹配串 `aaabbab`,我们来看看对应的 `next` 是如何被构建出来的。\n\n这就是整个 `next` 数组的构建过程,时空复杂度均为 $O(m)$。\n\n至此整个 KMP 匹配过程复杂度是 $O(m + n)$ 的。\n\n#### 4. 代码实现\n\n在实际编码时,通常我会往原串和匹配串头部追加一个空格(哨兵)。\n\n目的是让 `j` 下标从 `0` 开始,省去 `j` 从 `-1` 开始的麻烦。\n\n整个过程与上述分析完全一致,一些相关的注释我已经写到代码里。\n\n代码:\n```Java\nclass Solution {\n    // KMP 算法\n    // ss: 原串(string)  pp: 匹配串(pattern)\n    public int strStr(String ss, String pp) {\n        if (pp.isEmpty()) return 0;\n        \n        // 分别读取原串和匹配串的长度\n        int n = ss.length(), m = pp.length();\n        // 原串和匹配串前面都加空格,使其下标从 1 开始\n        ss = \" \" + ss;\n        pp = \" \" + pp;\n\n        char[] s = ss.toCharArray();\n        char[] p = pp.toCharArray();\n\n        // 构建 next 数组,数组长度为匹配串的长度(next 数组是和匹配串相关的)\n        int[] next = new int[m + 1];\n        // 构造过程 i = 2,j = 0 开始,i 小于等于匹配串长度 【构造 i 从 2 开始】\n        for (int i = 2, j = 0; i <= m; i++) {\n            // 匹配不成功的话,j = next(j)\n            while (j > 0 && p[i] != p[j + 1]) j = next[j];\n            // 匹配成功的话,先让 j++\n            if (p[i] == p[j + 1]) j++;\n            // 更新 next[i],结束本次循环,i++\n            next[i] = j;\n        }\n\n        // 匹配过程,i = 1,j = 0 开始,i 小于等于原串长度 【匹配 i 从 1 开始】\n        for (int i = 1, j = 0; i <= n; i++) {\n            // 匹配不成功 j = next(j)\n            while (j > 0 && s[i] != p[j + 1]) j = next[j];\n            // 匹配成功的话,先让 j++,结束本次循环后 i++\n            if (s[i] == p[j + 1]) j++;\n            // 整一段匹配成功,直接返回下标\n            if (j == m) return i - m;\n        }\n\n        return -1;\n    }\n}\n```\n* 时间复杂度:`n` 为原串的长度,`m` 为匹配串的长度。复杂度为 $O(m + n)$。\n* 空间复杂度:构建了 `next` 数组。复杂度为 $O(m)$。\n\n---\n\n### 总结\n\n**KMP 算法的应用范围要比 Manacher 算法广,Manacher 算法只能应用于「回文串」问题,相对比较局限,而「子串匹配」问题还是十分常见的。**\n\n**背过这样的算法的意义在于:相当于大脑里有了一个时间复杂度为 $O(n)$ 的 api 可以使用,这个 api 传入一个原串和匹配串,返回匹配串在原串的位置。**\n\n因此,三叶十分建议大家在「理解 KMP」的基础上,对模板进行背过 ~", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.28` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/21-30/29. 两数相除（中等）.md", "url_title": "29. 两数相除", "url": "https://leetcode-cn.com/problems/divide-two-integers/solution/gong-shui-san-xie-dui-xian-zhi-tiao-jian-utb9/", "difficulty": "中等", "tags": ["数学", "二分"], "question": "给定两个整数,被除数 `dividend` 和除数 `divisor`。\n\n将两数相除,要求不使用乘法、除法和 `mod` 运算符。\n\n返回被除数 `dividend` 除以除数 `divisor` 得到的商。\n\n整数除法的结果应当截去(`truncate`)其小数部分,例如:`truncate(8.345) = 8` 以及 `truncate(-2.7335) = -2` \n\n示例 1:\n```\n输入: dividend = 10, divisor = 3\n\n输出: 3\n\n解释: 10/3 = truncate(3.33333..) = truncate(3) = 3\n```\n示例 2:\n```\n输入: dividend = 7, divisor = -3\n\n输出: -2\n\n解释: 7/-3 = truncate(-2.33333..) = -2\n```\n\n提示:\n* 被除数和除数均为 $32$ 位有符号整数。\n* 除数不为 $0$。\n* 假设我们的环境只能存储 32 位有符号整数,其数值范围是 [−$2^{31}$,  $2^{31}$ − 1]。本题中,如果除法结果溢出,则返回 $2^{31}$ − 1。", "solution": "### 基本分析\n\n主要的歧义在于第三点限制「假设我们的环境只能存储 $32$ 位有符号整数,其数值范围是 $[−2^{31}, 2^{31} − 1]$。本题中,如果除法结果溢出,则返回 $2^{31} − 1$」的理解。\n\n该限制有两种理解方式:\n\n1. 不限制算法使用 `long`,只是解释为什么在溢出时,返回 $2^{31} − 1$;\n2. 限制算法使用 `long`。\n\n原始题解在 [这里](https://leetcode-cn.com/problems/divide-two-integers/solution/shua-chuan-lc-er-fen-bei-zeng-cheng-fa-j-m73b/) 。\n\n---\n\n### 理解一(不限制 `long`)\n\n当不限制使用 `long` 时,基本思路为:\n\n* 首先,`dividend` 和 `divisor` 均有「正数」和「负数」两种可能,当且仅当其中一者为负数时,结果为负,为了方便,我们可以先记录最终结果的正负号,然后将 `dividend` 和 `divisor` 都当成正数来处理;\n* 现在两者都满足 $x >= 0$,然后利用 `dividend` 和 `divisor` 均为 `int`,可以确定答案的绝对值落在 $[0, dividend]$ 范围内(当且仅当 `divisor` 是范围在 $[0, 1]$ 的浮点数时,答案会大于 `dividend`);\n* 假设答案为 $x$,那么在以 $x$ 为分割点的整数数轴上,具有「二段性」,因此我们可以二分找到该分割点:\n    * 大于 $x$ 的数 $y$ 满足 $y * b > a$;\n    * 小于等于 $x$ 的数 $y$ 满足 $y * b <= a$;\n* 根据「二段性」分析,我们发现二分的 `check` 实现需要用到乘法,因此我们需要实现一个「不用乘法符号」的乘法实现(这可以使用倍增思想来实现 `mul` 操作)。\n\n代码:\n```Java\nclass Solution {\n    int INF = Integer.MAX_VALUE;\n    public int divide(int _a, int _b) {\n        long a = _a, b = _b;\n        boolean flag = false;\n        if ((a < 0 && b > 0) || (a > 0 && b < 0)) flag = true;\n        if (a < 0) a = -a;\n        if (b < 0) b = -b;\n        long l = 0, r = a;\n        while (l < r) {\n            long mid = l + r + 1 >> 1;\n            if (mul(mid, b) <= a) l = mid;\n            else r = mid - 1;\n        }\n        r = flag ? -r : r;\n        if (r > INF || r < -INF - 1) return INF;\n        return (int)r;\n    }\n    long mul(long a, long k) {\n        long ans = 0;\n        while (k > 0) {\n            if ((k & 1) == 1) ans += a;\n            k >>= 1;\n            a += a;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:在 $[0, a]$ 范围内二分操作,复杂度为$O(\\log{a})$;倍增乘法的与操作数的二进制长度相关,复杂度为 $O(\\log{b})$。整体复杂度为 $O(\\log{a} \\times \\log{b})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 理解二(限制 `long`)\n\n对于全程不使用 `long` 的做法,我们需要将所有数映射到负数进行处理(以 $0$ 为分割点,负数所能表示的范围更大)。\n\n基本思路为:\n\n* 起始先对边界情况进行特判;\n* 记录最终结果的符号,并将两数都映射为负数;\n* 可以预处理出倍增数组,或采取逐步增大 `dividend` 来逼近 `divisor` 的方式。\n\n> 由于操作数都是负数,因此自倍增过程中,如果操作数小于 `INT_MIN` 的一半(`-1073741824`),则代表发生溢出。\n\n代码:\n```Java\nclass Solution {\n    int MIN = Integer.MIN_VALUE, MAX = Integer.MAX_VALUE;\n    int LIMIT = -1073741824; // MIN 的一半\n    public int divide(int a, int b) {\n        if (a == MIN && b == -1) return MAX;\n        boolean flag = false;\n        if ((a > 0 && b < 0) || (a < 0 && b > 0)) flag = true;\n        if (a > 0) a = -a;\n        if (b > 0) b = -b;\n        int ans = 0;\n        while (a <= b){\n            int c = b, d = -1;\n            while (c >= LIMIT && d >= LIMIT && c >= a - c){\n                c += c; d += d;\n            }\n            a -= c;\n            ans += d;\n        }\n        return flag ? ans : -ans;\n    }\n}\n```\n* 时间复杂度:$O(\\log{a} \\times \\log{b})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.29` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/21-30/30. 串联所有单词的子串（困难）.md", "url_title": "30. 串联所有单词的子串", "url": "https://leetcode.cn/problems/substring-with-concatenation-of-all-words/solution/by-ac_oier-enjd/", "difficulty": "困难", "tags": ["哈希表", "滑动窗口", "枚举"], "question": "给定一个字符串 `s` 和一些长度相同的单词 `words`。\n\n找出 `s` 中恰好可以由 `words` 中所有单词串联形成的子串的起始位置。\n\n注意子串要与 `words` 中的单词完全匹配,中间不能有其他字符,但不需要考虑 `words` 中单词串联的顺序。\n\n示例 1:\n```\n输入:\ns = \"barfoothefoobarman\",\nwords = [\"foo\",\"bar\"]\n  \n输出:[0,9]\n\n解释:\n从索引 0 和 9 开始的子串分别是 \"barfoo\" 和 \"foobar\" 。\n输出的顺序不重要, [9,0] 也是有效答案。\n```\n示例 2:\n```\n输入:\ns = \"wordgoodgoodgoodbestword\",\nwords = [\"word\",\"good\",\"best\",\"word\"]\n  \n输出:[]\n```\n\n提示:\n* $1 <= s.length <= 10^4$\n* `s` 由小写英文字母组成\n* $1 <= words.length <= 5000$\n* $1 <= words[i].length <= 30$\n* `words[i]` 由小写英文字母组成", "solution": "### 朴素哈希表\n\n令 `n` 为字符串 `s` 的长度,`m` 为数组 `words` 的长度(单词的个数),`w` 为单个单词的长度。\n\n由于 `words` 里面每个单词长度固定,而我们要找的字符串只能恰好包含所有的单词,因此我们要找的目标子串的长度为 $m \\times w$。\n\n那么一个直观的思路是:\n\n1. 使用哈希表 `map` 记录 `words` 中每个单词的出现次数\n2. 枚举 `s` 中的每个字符作为起点,往后取得长度为 $m \\times w$ 的子串 `sub`\n3. 使用哈希表 `cur ` 统计 `sub` 每个单词的出现次数(每隔 `w` 长度作为一个单词)\n4. 比较 `cur` 和 `map` 是否相同\n\n注意:在步骤 $3$ 中,如果发现 `sub` 中包含了 `words` 没有出现的单词,可以直接剪枝。\n\n剪枝处使用了带标签的 `continue` 语句直接回到外层循环进行。\n\n代码:\n```Java\nclass Solution {\n    public List<Integer> findSubstring(String s, String[] words) {\n        int n = s.length(), m = words.length, w = words[0].length();\n        Map<String, Integer> map = new HashMap<>();\n        for (String word : words) map.put(word, map.getOrDefault(word, 0) + 1);\n        List<Integer> ans = new ArrayList<>();\n        out:for (int i = 0; i + m * w <= n; i++) {\n            Map<String, Integer> cur = new HashMap<>();\n            String sub = s.substring(i, i + m * w);\n            for (int j = 0; j < sub.length(); j += w) {\n                String item = sub.substring(j, j + w);\n                if (!map.containsKey(item)) continue out;\n                cur.put(item, cur.getOrDefault(item, 0) + 1);\n            }\n            if (cur.equals(map)) ans.add(i);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:将 `words` 中的单词存入哈希表,复杂度为 $O(m)$(由于字符串长度固定且不超过 $30$,假定所有哈希操作均为 $O(1)$ 的);然后第一层循环枚举 `s` 中的每个字符作为起点,复杂度为 $O(n)$;在循环中将 `sub` 划分为 `m` 个单词进行统计,枚举了 `m - 1` 个下标,复杂度为 $O(m)$;每个字符串的长度为 `w`。整体复杂度为 $O(n \\times m \\times w)$\n* 空间复杂度:$O(m \\times w)$\n\n---\n\n### 滑动窗口 + 哈希表\n\n事实上,我们可以**优化这个枚举起点的过程**。\n\n我们可以将起点根据 **当前下标与单词长度的取余结果** 进行分类,这样我们就不用频繁的建立新的哈希表和进行单词统计。\n\n代码:\n```Java\nclass Solution {\n    public List<Integer> findSubstring(String s, String[] words) {\n        int n = s.length(), m = words.length, w = words[0].length();\n        // 统计 words 中「每个目标单词」的出现次数\n        Map<String, Integer> map = new HashMap<>();\n        for (String word : words) map.put(word, map.getOrDefault(word, 0) + 1);\n        List<Integer> ans = new ArrayList<>();\n        for (int i = 0; i < w; i++) {\n            // 构建一个当前子串对应 map,统计当前子串中「每个目标单词」的出现次数\n            Map<String, Integer> curMap = new HashMap<>();\n            // 滑动窗口的大小固定是 m * w,每次将下一个单词添加进 curMap,上一个单词移出 curMap\n            for (int j = i; j + w <= n; j += w) {   \n                String cur = s.substring(j, j + w);\n                curMap.put(cur, curMap.getOrDefault(cur, 0) + 1);\n                if (j >= i + (m * w)) {\n                    int idx = j - m * w;\n                    String prev = s.substring(idx, idx + w);\n                    if (curMap.get(prev) == 1) curMap.remove(prev);\n                    else curMap.put(prev, curMap.get(prev) - 1);\n                    if (!curMap.getOrDefault(prev, 0).equals(map.getOrDefault(prev, 0))) continue;\n                }\n                if (!curMap.getOrDefault(cur, 0).equals(map.getOrDefault(cur, 0))) continue;\n                // 上面两个 continue 可以减少 map 之间的 equals 操作\n                if (curMap.equals(map)) ans.add(j - (m - 1) * w);\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:将 `words` 中的单词存入哈希表,复杂度为 $O(m)$(由于字符串长度固定且不超过 $30$,假定所有哈希操作均为 $O(1)$ 的);然后枚举了取余的结果,复杂度为 $O(w)$;每次循环最多处理 `n` 长度的字符串,复杂度为 $O(n)$。整体复杂度为 $O(m + w \\times n)$\n* 空间复杂度:$O(m \\times w)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.30` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2101-2110/2103. 环和杆（简单）.md", "url_title": "2103. 环和杆", "url": "https://leetcode.cn/problems/rings-and-rods/solutions/2509056/gong-shui-san-xie-liang-ge-jiao-du-jin-x-r1v1/", "difficulty": "简单", "tags": ["模拟", "位运算"], "question": "总计有 `n` 个环,环的颜色可以是红、绿、蓝中的一种。\n\n这些环分别穿在 $10$ 根编号为 $0$ 到 $9$ 的杆上。\n\n给你一个长度为 `2n` 的字符串 `rings`,表示这 `n` 个环在杆上的分布。\n\n`rings` 中每两个字符形成一个 颜色位置对 ,用于描述每个环:\n\n* 第 `i` 对中的 第一个 字符表示第 `i` 个环的 颜色(`'R'`、`'G'`、`'B'`)。\n* 第 `i` 对中的 第二个 字符表示第 `i` 个环的 位置,也就是位于哪根杆上(`'0'` 到 `'9'`)。\n\n例如,`\"R3G2B1\"` 表示:共有 $n = 3$ 个环,红色的环在编号为 $3$ 的杆上,绿色的环在编号为 $2$ 的杆上,蓝色的环在编号为 $1$ 的杆上。\n\n找出所有集齐 全部三种颜色 环的杆,并返回这种杆的数量。\n\n示例 1:\n\n```\n输入:rings = \"B0B6G0R6R0R6G9\"\n\n输出:1\n\n解释:\n- 编号 0 的杆上有 3 个环,集齐全部颜色:红、绿、蓝。\n- 编号 6 的杆上有 3 个环,但只有红、蓝两种颜色。\n- 编号 9 的杆上只有 1 个绿色环。\n因此,集齐全部三种颜色环的杆的数目为 1 。\n```\n示例 2:\n\n```\n输入:rings = \"B0R0G0R9R0B0G0\"\n\n输出:1\n\n解释:\n- 编号 0 的杆上有 6 个环,集齐全部颜色:红、绿、蓝。\n- 编号 9 的杆上只有 1 个红色环。\n因此,集齐全部三种颜色环的杆的数目为 1 。\n```\n示例 3:\n```\n输入:rings = \"G4\"\n\n输出:0\n\n解释:\n只给了一个环,因此,不存在集齐全部三种颜色环的杆。\n```\n\n提示:\n* $rings.length = 2 \\times n$\n* $1 <= n <= 100$\n* 如 `i` 是 偶数 ,则 `rings[i]` 的值可以取 `'R'`、`'G'` 或 `'B'`(下标从 `0` 开始计数)\n* 如 `i` 是 奇数 ,则 `rings[i]` 的值可以取 `'0'` 到 `'9'` 中的一个数字(下标从 `0` 开始计数)", "solution": "### 位运算 - 统计环\n\n环的数量不定,但杆的数量就 $10$ 根。\n\n我们可以从「环」的角度出发,进行统计。\n\n用一个 `int` 来代表环的统计情况,根据题意,共有 `RGB`  三种颜色的环,共需要 $3$ 个 `int` 数(为了方便,代码直接开了大小为 $128$ 的数组)。\n\n对于一个代表环的数值 $x$ 而言,从低位往高位数,若第 $k$ 位为 $1$,代表编号为 $k$ 的杆包含该颜色的环。\n\n用示例 $1$ 来举个 🌰,`rings = \"B0B6G0R6R0R6G9\"`\n\n* 红色:在 `0` 和 `6` 中出现过,对应数值 $x = (0001000001)_2$\n* 蓝色:在 `0` 和 `6` 中出现过,对应数值 $x = (0001000001)_2$\n* 绿色:在 `9` 中出现过,对应数值 $x = (100000000)_2$\n\n在代表三种颜色的数值中,相同位均为 $1$,假设为第 $k$ 位,则代表三种颜色均在第 $k$ 杆中出现过。\n\n最后,统计 $10$ 根杆中有多少满足要求即可。\n\nJava 代码:\n\n```Java\nclass Solution {\n    public int countPoints(String s) {\n        int n = s.length(), ans = 0;\n        int[] map = new int[128];\n        for (int i = 0; i < n; i += 2) map[s.charAt(i) - 'B'] |= 1 << (s.charAt(i + 1) - '0');\n        for (int i = 0; i < 10; i++) {\n            int tot = 0;\n            for (char c : new char[]{'R', 'G', 'B'}) tot += (map[c - 'B'] >> i) & 1;\n            if (tot == 3) ans++;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int countPoints(string s) {\n        int n = s.size(), ans = 0;\n        vector<int> map(128, 0);\n        for (int i = 0; i < n; i += 2) map[s[i] - 'B'] |= 1 << (s[i + 1] - '0');\n        for (int i = 0; i < 10; i++) {\n            int tot = 0;\n            for (char c : {'R', 'G', 'B'}) tot += (map[c - 'B'] >> i) & 1;\n            if (tot == 3) ans++;\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def countPoints(self, s: str) -> int:\n        n, ans = len(s), 0\n        map = [0] * 128\n        for i in range(0, n, 2):\n            map[ord(s[i]) - ord('B')] |= 1 << (int(s[i + 1]) - int('0'))\n        for i in range(10):\n            tot = 0\n            for c in ['R', 'G', 'B']:\n                tot += (map[ord(c) - ord('B')] >> i) & 1\n            ans += 1 if tot == 3 else 0\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction countPoints(s: string): number {\n    let n = s.length, ans = 0;\n    const map = new Array(128).fill(0);\n    for (let i = 0; i < n; i += 2) {\n        map[s.charCodeAt(i) - 'B'.charCodeAt(0)] |= 1 << (s.charCodeAt(i + 1) - '0'.charCodeAt(0));\n    }\n    for (let i = 0; i < 10; i++) {\n        let tot = 0;\n        for (const c of ['R', 'G', 'B']) tot += ((map[c.charCodeAt(0) - 'B'.charCodeAt(0)]) >> i) & 1;\n        if (tot == 3) ans++;\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n + C \\times K)$,其中 $n$ 为字符串长度,$C = 10$ 为杆的数量,$K = 3$ 为环类型\n* 空间复杂度:$O(K)$\n\n---\n\n### 位运算 - 统计杆\n\n虽然环的数量不定,但我们只关心其在某根杆上是否出现过,而不关心其出现次数。\n\n因此,我们也可以从「杆」的角度出发,进行统计。\n\n创建一个大小为 $10$ 的整型数组 `cnt`,其中 $cnt[k] = x$ 代表第 $k$ 根杆的统计情况为 $x$。\n\n从低位到高位,我们对三种颜色 `RGB` 的出现与否进行统计,使用 `0` 和 `1` 分别代表「没出现」和「出现」两种情况。\n\n用示例 $1$ 来举个 🌰,`rings = \"B0B6G0R6R0R6G9\"`\n\n* 编号为 $0$ 的杆:三种颜色均出现过,其数值为 $cnt[0] = (...111)_2$,从低位到高位,分别代表 `RGB`\n* 编号为 $6$ 的杆:`R`  和 `B` 出现过,其数值为 $cnt[6] = (...101)_2$\n* 编号为 $9$ 的杆:`G` 出现过,其数值为 $cnt[9] = (...010)_2$\n* 其他编号的杆:没有任何颜色出现过,其数值为 $cnt[i] = 0$\n\nJava 代码:\n\n```Java\nclass Solution {\n    public int countPoints(String s) {\n        int n = s.length(), ans = 0;\n        int[] cnt = new int[10];\n        for (int i = 0; i < n; i += 2) {\n            char c = s.charAt(i);\n            int idx = -1, t = s.charAt(i + 1) - '0';\n            if (c == 'R') idx = 0;\n            else if (c == 'G') idx = 1;\n            else idx = 2;\n            cnt[t] |= 1 << idx;\n        }\n        for (int i = 0; i < 10; i++) {\n            if (cnt[i] == (1 << 3) - 1) ans++;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int countPoints(string s) {\n        int n = s.size(), ans = 0;\n        vector<int> cnt(10, 0);\n        for (int i = 0; i < n; i += 2) {\n            int idx = -1, t = s[i + 1] - '0';\n            if (s[i] == 'R') idx = 0;    \n            else if (s[i] == 'G') idx = 1;\n            else idx = 2;\n            cnt[t] |= 1 << idx;\n        }\n        for (int i = 0; i < 10; i++) {\n            if (cnt[i] == (1 << 3) - 1) ans++;\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def countPoints(self, s: str) -> int:\n        n, ans = len(s), 0\n        cnt = [0] * 10\n        for i in range(0, n, 2):\n            idx, t = -1, int(s[i + 1])\n            if s[i] == 'R':\n                idx = 0\n            elif s[i] == 'G':\n                idx = 1\n            else:\n                idx = 2\n            cnt[t] |= 1 << idx\n        for i in range(10):\n            ans += 1 if cnt[i] == (1 << 3) - 1 else 0\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction countPoints(s: string): number {\n    let n = s.length, ans = 0;\n    const cnt = new Array(10).fill(0);\n    for (let i = 0; i < n; i += 2) {\n        let idx = -1, t = parseInt(s[i + 1]);\n        if (s[i] == 'R') idx = 0;\n        else if (s[i] == 'G') idx = 1;\n        else idx = 2;\n        cnt[t] |= 1 << idx;\n    }\n    for (let i = 0; i < 10; i++) {\n        if (cnt[i] == (1 << 3) - 1) ans++;\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n \\times K + C)$,其中 $n$ 为字符串长度,$C = 10$ 为杆的数量,$K = 3$ 为环类型。\n注:这里为什么不是 $O(n + C)$,在首个循环中,环的类型决定了分支数量,因此首个循环复杂度为 $O(n \\times K)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2103` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2101-2110/2104. 子数组范围和（中等）.md", "url_title": "2104. 子数组范围和", "url": "https://leetcode-cn.com/problems/sum-of-subarray-ranges/solution/gong-shui-san-xie-yi-ti-san-jie-qu-jian-wn84z/", "difficulty": "中等", "tags": ["区间 DP", "单调栈"], "question": "给你一个整数数组 `nums` 。`nums` 中,子数组的 **范围** 是子数组中最大元素和最小元素的差值。\n\n返回 `nums` 中 **所有** 子数组范围的 **和** 。\n\n子数组是数组中一个连续 **非空** 的元素序列。\n\n示例 1:\n```\n输入:nums = [1,2,3]\n\n输出:4\n\n解释:nums 的 6 个子数组如下所示:\n[1],范围 = 最大 - 最小 = 1 - 1 = 0 \n[2],范围 = 2 - 2 = 0\n[3],范围 = 3 - 3 = 0\n[1,2],范围 = 2 - 1 = 1\n[2,3],范围 = 3 - 2 = 1\n[1,2,3],范围 = 3 - 1 = 2\n所有范围的和是 0 + 0 + 0 + 1 + 1 + 2 = 4\n```\n示例 2:\n```\n输入:nums = [1,3,3]\n\n输出:4\n\n解释:nums 的 6 个子数组如下所示:\n[1],范围 = 最大 - 最小 = 1 - 1 = 0\n[3],范围 = 3 - 3 = 0\n[3],范围 = 3 - 3 = 0\n[1,3],范围 = 3 - 1 = 2\n[3,3],范围 = 3 - 3 = 0\n[1,3,3],范围 = 3 - 1 = 2\n所有范围的和是 0 + 0 + 0 + 2 + 0 + 2 = 4\n```\n示例 3:\n```\n输入:nums = [4,-2,-3,4,1]\n\n输出:59\n\n解释:nums 中所有子数组范围的和是 59\n```\n\n提示:\n* 1 <= nums.length <= 1000\n* $-10^9 <= nums[i] <= 10^9$\n\n进阶:你可以设计一种时间复杂度为 $O(n)$ 的解决方案吗?", "solution": "### 区间 DP(预处理)\n\n数据范围为 $10^3$,最为朴素的三层循环为:枚举区间(左右端点)+ 扫描区间统计最值,并累加到答案中。该做法复杂度为 $O(n^3)$,会 `TLE`。\n\n考虑在此基础上优化,枚举所有区间的操作不好避免,考虑通过「预处理」手段来优化「扫描区间统计最值」操作,通常会将其优化为 $O(1)$ 查表。\n\n定义 $f[l][r][k]$ 为区间 $[l, r]$ 范围内的最值情况,其中 $k$ 非 $0$ 即 $1$:$f[l][r][0]$ 代表区间 $[l, r]$ 内的最小值,$f[l][r][1]$ 代表区间 $[l, r]$ 内的最大值。\n\n不失一般性考虑 $f[l][r][0]$ 和 $f[l][r][1]$ 该如何计算:$[l, r]$ 区间的最值可由 $[l, r - 1]$ 与 $nums[r]$ 更新而来:\n\n$$\nf[l][r][0] = \\min(f[l][r - 1][0], nums[r])\n$$\n\n$$\nf[l][r][1] = \\max(f[l][r - 1][1], nums[r])\n$$\n\n最后再枚举所有区间统计答案即可。\n\n代码:\n```Java\nclass Solution {\n    public long subArrayRanges(int[] nums) {\n        int n = nums.length;\n        int[][][] f = new int[n][n][2];\n        for (int i = 0; i < n; i++) f[i][i][0] = f[i][i][1] = nums[i];\n        for (int len = 2; len <= n; len++) {\n            for (int l = 0; l + len - 1 < n; l++) {\n                int r = l + len - 1;\n                f[l][r][0] = Math.min(nums[r], f[l][r - 1][0]);\n                f[l][r][1] = Math.max(nums[r], f[l][r - 1][1]);\n            }\n        }\n        long ans = 0;\n        for (int i = 0; i < n; i++) {\n            for (int j = i + 1; j < n; j++) {\n                ans += f[i][j][1] - f[i][j][0];\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:区间 DP 复杂度为 $O(n^2)$;统计范围和的复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 枚举\n\n更进一步,我们发现在转移计算 $[l, r]$ 的最值情况时,仅依赖于 $[l, r - 1]$(小区间),因此我们可以使用两变量代替动规数组,边遍历边维护并统计答案。\n\n代码:\n```Java\nclass Solution {\n    public long subArrayRanges(int[] nums) {\n        int n = nums.length;\n        long ans = 0;\n        for (int i = 0; i < n; i++) {\n            int min = nums[i], max = nums[i];\n            for (int j = i + 1; j < n; j++) {\n                min = Math.min(min, nums[j]);\n                max = Math.max(max, nums[j]);\n                ans += max - min;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 单调栈\n\n假设有 $m$ 个区间,最终的表达式为 $m$ 个等式 $\\max - \\min$ 之和。\n\n若某个 $nums[i]$,如果在这 $k_1$ 个区间中充当最大值,则在最终等式中以 $\\max$ 的形式出现 $k_1$ 次,如果在 $k_2$ 个区间中充当最小值,则在最终等式中以 $\\min$ 形式出现 $k_2$ 次。\n\n因此我们可以统计每个 $nums[i]$ 成为区间最大值的次数 $k_1$ 和成为区间最小值的次数 $k_2$,$(k_1 - k_2) * nums[i]$ 为 $nums[i]$ 对于最终答案的贡献。\n\n考虑如何统计每个 $nums[i]$ 成为区间最值的次数:\n\n* $nums[i]$ 作为区间最大值的次数:找到 $nums[i]$ 左右最近一个不满足「小于等于 $nums[i]$」的位置,记其为 $p$ 和 $q$。此时区间左端点共有 $i - p$ 个选择,区间右端点共有 $q - i$ 个选择,根据乘法原理,区间个数为 $(i - p) * (q - i)$ 个;\n* $nums[i]$ 作为区间最小值的次数:同理,找到 $nums[i]$ 左右最近一个不满足「大于等于 $nums[i]$」的位置,记其为 $p$ 和 $q$,区间个数为 $(i - p) * (q - i)$ 个。\n\n即问题切换为:**使用「单调栈」找到某个 $nums[i]$ 的左边/右边的最近一个符合某种性质的位置,从而知道 $nums[i]$ 作为区间最值时,左右端点的可选择个数,再结合乘法原理知道 $nums[i]$ 能够作为区间最值的区间个数,从而知道 $nums[i]$ 对答案的贡献。**\n\n值得注意的是,由于 $nums[i]$ 存在相同元素,因此上述两边均取等号的做法会导致某些区间被重复计算,因此我们可以令最近右端点的部分不取等号,确保区间统计不重不漏。\n\n代码:\n```Java\nclass Solution {\n    int n;\n    public long subArrayRanges(int[] nums) {\n        n = nums.length;\n        // min[i] 为 nums[i] 作为区间最小值的次数;max[i] 为 nums[i] 作为区间最大值的次数\n        long[] min = getCnt(nums, true), max = getCnt(nums, false);\n        long ans = 0;\n        for (int i = 0; i < n; i++) ans += (max[i] - min[i]) * nums[i];\n        return ans;\n    }\n    long[] getCnt(int[] nums, boolean isMin) {\n        int[] a = new int[n], b = new int[n];\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            while (!d.isEmpty() && (isMin ? nums[d.peekLast()] >= nums[i] : nums[d.peekLast()] <= nums[i])) d.pollLast();\n            a[i] = d.isEmpty() ? -1 : d.peekLast();\n            d.addLast(i);\n        }\n        d.clear();\n        for (int i = n - 1; i >= 0; i--) {\n            while (!d.isEmpty() && (isMin ? nums[d.peekLast()] > nums[i] : nums[d.peekLast()] < nums[i])) d.pollLast();\n            b[i] = d.isEmpty() ? n : d.peekLast();\n            d.addLast(i);\n        }\n        long[] ans = new long[n];\n        for (int i = 0; i < n; i++) ans[i] = (i - a[i]) * 1L * (b[i] - i);\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2104` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/211-220/211. 添加与搜索单词 - 数据结构设计（中等）.md", "url_title": "211. 添加与搜索单词 - 数据结构设计", "url": "https://leetcode-cn.com/problems/design-add-and-search-words-data-structure/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-we-un94/", "difficulty": "中等", "tags": ["DFS", "字典树"], "question": "请你设计一个数据结构,支持 添加新单词 和 查找字符串是否与任何先前添加的字符串匹配 。\n\n实现词典类 `WordDictionary` :\n* `WordDictionary()` 初始化词典对象\n* `void addWord(word)` 将 `word` 添加到数据结构中,之后可以对它进行匹配\n* `bool search(word)` 如果数据结构中存在字符串与 `word` 匹配,则返回 `true` ;否则,返回  `false` \n* `word` 中可能包含一些 `'.'` ,每个 `.` 都可以表示任何一个字母。\n\n示例:\n```\n输入:\n[\"WordDictionary\",\"addWord\",\"addWord\",\"addWord\",\"search\",\"search\",\"search\",\"search\"]\n[[],[\"bad\"],[\"dad\"],[\"mad\"],[\"pad\"],[\"bad\"],[\".ad\"],[\"b..\"]]\n\n输出:\n[null,null,null,null,false,true,true,true]\n\n解释:\nWordDictionary wordDictionary = new WordDictionary();\nwordDictionary.addWord(\"bad\");\nwordDictionary.addWord(\"dad\");\nwordDictionary.addWord(\"mad\");\nwordDictionary.search(\"pad\"); // return False\nwordDictionary.search(\"bad\"); // return True\nwordDictionary.search(\".ad\"); // return True\nwordDictionary.search(\"b..\"); // return True\n```\n\n提示:\n* $1 <= word.length <= 500$\n* `addWord` 中的 `word` 由小写英文字母组成\n* `search` 中的 `word` 由 `'.'` 或小写英文字母组成\n* 最多调用 $50000$ 次 `addWord` 和 `search`", "solution": "### 基本分析\n\n一道 $Trie$ 的轻度变形模板题,还不熟悉 $Trie$ 的同学可以看 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089&chksm=fd9cb8f5caeb31e3f7f67dba981d8d01a24e26c93ead5491edb521c988adc0798d8acb6f9e9d&token=1006889101&lang=zh_CN#rd),里面详细介绍了实现 $Trie$ 的两种方式、注意事项以及 $Trie$ 应用面等等,是解决本题的前置芝士 🧀。\n\n简单回顾一下:\n\n$Trie$ 树(又叫「前缀树」或「字典树」)是一种用于快速查询「某个字符串/字符前缀」是否存在的数据结构。\n\n其核心是使用「边」来代表有无字符,使用「点」来记录是否为「单词结尾」以及「其后续字符串的字符是什么」。\n\n回到本题,**首先 `addWord` 操作不会带 `.` 符号,因此我们采用原有的 $Trie$ 插入方式即可;而在 `search` 操作中会有 `.` 符号,我们需要枚举某个 `.` 所代指的字母是什么,这需要结合 `DFS` 来做。**\n\n---\n\n### 二维数组\n\n使用数组实现,需要预先估算数组大小。\n\n通常估算值会很大,直接使用估算值会 MLE。利用 $Trie$  会有很多位置被共用,以及合格的测试用例,应该至少做到「查询」调用次数和「插入」调用次数相当,我们可以使用比估算值小的数(往下调整一个数量级),更详细的估算逻辑在 [前置芝士](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089&chksm=fd9cb8f5caeb31e3f7f67dba981d8d01a24e26c93ead5491edb521c988adc0798d8acb6f9e9d&token=1006889101&lang=zh_CN#rd) 讲过,不再赘述。\n\n使用数组实现,还有一个可优化的地方是使用 `static` 修饰所有用到的数组,然后在初始化 `Solution` 的时候做清理工作,这样可以有效避免跑每个样例都创建大数组。\n\n实际测试使用 `static` 与否执行时间会相差超过一半。\n\n代码($P1$ 带 `static` 优化):\n```Java\nclass WordDictionary {\n    static int N = 250000;\n    static int[][] tr = new int[N][26];\n    static boolean[] isWord = new boolean[N];\n    static int idx;\n    public WordDictionary() {\n        for (int i = 0; i < idx; i++) {\n            Arrays.fill(tr[i], 0);\n        }\n        Arrays.fill(isWord, false);\n        idx = 0;\n    }\n    public void addWord(String s) {\n        int p = 0;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (tr[p][u] == 0) tr[p][u] = ++idx;\n            p = tr[p][u];\n        }\n        isWord[p] = true;\n    }\n    public boolean search(String s) {\n        return dfs(s, 0, 0);\n    }\n    boolean dfs(String s, int trIdx, int sIdx) {\n        int n = s.length();\n        if (n == sIdx) return isWord[trIdx];\n        char c = s.charAt(sIdx);\n        if (c == '.') {\n            for (int j = 0; j < 26; j++) {\n                if (tr[trIdx][j] != 0 && dfs(s, tr[trIdx][j], sIdx + 1)) return true;\n            }\n            return false;\n        } else {\n            int u = c - 'a';\n            if (tr[trIdx][u] == 0) return false;\n            return dfs(s, tr[trIdx][u], sIdx + 1);\n        }\n    }\n}\n```\n\n```Java\nclass WordDictionary {\n    int N = 250000;\n    int[][] tr = new int[N][26];\n    boolean[] isWord = new boolean[N];\n    int idx;\n    public void addWord(String s) {\n        int p = 0;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (tr[p][u] == 0) tr[p][u] = ++idx;\n            p = tr[p][u];\n        }\n        isWord[p] = true;\n    }\n    public boolean search(String s) {\n        return dfs(s, 0, 0);\n    }\n    boolean dfs(String s, int trIdx, int sIdx) {\n        int n = s.length();\n        if (sIdx == n) return isWord[trIdx];\n        char c = s.charAt(sIdx);\n        if (c == '.') {\n            for (int j = 0; j < 26; j++) {\n                if (tr[trIdx][j] != 0 && dfs(s, tr[trIdx][j], sIdx + 1)) return true;\n            }\n            return false;\n        } else {\n            int u = c - 'a';\n            if (tr[trIdx][u] == 0) return false;\n            return dfs(s, tr[trIdx][u], sIdx + 1);\n        }\n    }\n}\n```\n* 时间复杂度:$L$ 为字符串的最大长度,`addWord` 操作的复杂度为 $O(L)$;`search` 操作的复杂度为 $O(C * L)$,其中 $C$ 为字符集大小,固定为 $26$\n* 空间复杂度:静态数组大小固定,复杂度为 $O(1e7)$\n\n---\n\n### TrieNode\n\n同理,我们也能够使用 $TrieNode$ 的方式实现。\n\n好处是不需要进行数组大小估算,但是不可避免需要在一个样例中执行多次 $new$ 动作。\n\n代码:\n```Java\nclass WordDictionary {\n    class Node {\n        Node[] tns = new Node[26];\n        boolean isWord;\n    }\n    Node root = new Node();\n    public void addWord(String s) {\n        Node p = root;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (p.tns[u] == null) p.tns[u] = new Node();\n            p = p.tns[u];\n        }\n        p.isWord = true;\n    }\n    public boolean search(String s) {\n        return dfs(s, root, 0);\n    }\n    boolean dfs(String s, Node p, int sIdx) {\n        int n = s.length();\n        if (n == sIdx) return p.isWord;\n        char c = s.charAt(sIdx);\n        if (c == '.') {\n            for (int j = 0; j < 26; j++) {\n                if (p.tns[j] != null && dfs(s, p.tns[j], sIdx + 1)) return true;\n            }\n            return false;\n        } else {\n            int u = c - 'a';\n            if (p.tns[u] == null) return false;\n            return dfs(s, p.tns[u], sIdx + 1);\n        }\n    }\n}\n```\n* 时间复杂度:`addWord` 操作的复杂度为 $O(L)$;`search` 操作的复杂度为 $O(C * L)$,其中 $C$ 为字符集大小,固定为 $26$\n* 空间复杂度:令 `n` 为插入字符串数量,$L$ 为字符串的最大长度,复杂度为 $O(n * L)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.211` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/211-220/212. 单词搜索 II（困难）.md", "url_title": "212. 单词搜索 II", "url": "https://leetcode-cn.com/problems/word-search-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-hui-s-am8f/", "difficulty": "困难", "tags": ["回溯算法", "DFS", "字典树"], "question": "给定一个 $m x n$ 二维字符网格 $board$ 和一个单词(字符串)列表 $words$,找出所有同时在二维网格和字典中出现的单词。\n\n单词必须按照字母顺序,通过 相邻的单元格 内的字母构成,其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。\n\n示例 1:\n\n```\n输入:board = [[\"o\",\"a\",\"a\",\"n\"],[\"e\",\"t\",\"a\",\"e\"],[\"i\",\"h\",\"k\",\"r\"],[\"i\",\"f\",\"l\",\"v\"]], words = [\"oath\",\"pea\",\"eat\",\"rain\"]\n\n输出:[\"eat\",\"oath\"]\n```\n示例 2:\n\n```\n输入:board = [[\"a\",\"b\"],[\"c\",\"d\"]], words = [\"abcb\"]\n\n输出:[]\n```\n\n提示:\n* m == board.length\n* n == board[i].length\n* 1 <= m, n <= 12\n* board[i][j] 是一个小写英文字母\n* 1 <= words.length <= 3 * $10^4$\n* 1 <= words[i].length <= 10\n* words[i] 由小写英文字母组成\n* words 中的所有字符串互不相同", "solution": "### 回溯算法\n\n**数据范围只有 $12$,且 `words` 中出现的单词长度不会超过 $10$,可以考虑使用「回溯算法」。**\n\n起始先将所有 `words` 出现的单词放到 `Set` 结构中,然后以 `board` 中的每个点作为起点进行爆搜(由于题目规定在一个单词中每个格子只能被使用一次,因此还需要一个 `vis` 数组来记录访问过的位置):\n\n1. 如果当前爆搜到的字符串长度超过 $10$,直接剪枝;\n2. 如果当前搜索到的字符串在 `Set` 中,则添加到答案(同时了防止下一次再搜索到该字符串,需要将该字符串从 `Set` 中移除)。\n\n代码:\n```Java\nclass Solution {\n    Set<String> set = new HashSet<>();\n    List<String> ans = new ArrayList<>();\n    char[][] board;\n    int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n    int n, m;\n    boolean[][] vis = new boolean[15][15];\n    public List<String> findWords(char[][] _board, String[] words) {\n        board = _board;\n        m = board.length; n = board[0].length;\n        for (String w : words) set.add(w);\n        StringBuilder sb = new StringBuilder();\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                vis[i][j] = true;\n                sb.append(board[i][j]);\n                dfs(i, j, sb);\n                vis[i][j] = false;\n                sb.deleteCharAt(sb.length() - 1);\n            }\n        }\n        return ans;\n    }\n    void dfs(int i, int j, StringBuilder sb) {\n        if (sb.length() > 10) return ;\n        if (set.contains(sb.toString())) {\n            ans.add(sb.toString());\n            set.remove(sb.toString());\n        }\n        for (int[] d : dirs) {\n            int dx = i + d[0], dy = j + d[1];\n            if (dx < 0 || dx >= m || dy < 0 || dy >= n) continue;\n            if (vis[dx][dy]) continue;\n            vis[dx][dy] = true;\n            sb.append(board[dx][dy]);\n            dfs(dx, dy, sb);\n            vis[dx][dy] = false;\n            sb.deleteCharAt(sb.length() - 1);\n        }\n    }\n}\n```\n* 时间复杂度:共有 $m * n$ 个起点,每次能往 $4$ 个方向搜索(不考虑重复搜索问题),且搜索的长度不会超过 $10$。整体复杂度为 $O(m * n * 4^{10})$\n* 空间复杂度:$O(\\sum_{i=0}^{words.length - 1} words[i].length)$\n\n---\n\n### Trie \n\n**在「解法一」中,对于任意一个当前位置 $(i, j)$,我们都不可避免的搜索了四联通的全部方向,这导致了那些无效搜索路径最终只有长度达到 $10$ 才会被剪枝。**\n\n**要进一步优化我们的搜索过程,需要考虑如何在每一步的搜索中进行剪枝。**\n\n我们可以使用 $Trie$ 结构进行建树,对于任意一个当前位置 $(i, j)$ 而言,只有在 $Trie$ 中存在往从字符 $a$ 到 $b$ 的边时,我们才在棋盘上搜索从 $a$ 到 $b$ 的相邻路径。\n\n不了解 $Trie$ 的同学,可以看看这篇题解 [(题解) 208. 实现 Trie (前缀树)](https://leetcode-cn.com/problems/implement-trie-prefix-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-we-esm9/),里面写了两种实现 $Trie$ 的方式。\n\n对于本题,我们可以使用「TrieNode」的方式进行建 $Trie$。\n\n因为 `words` 里最多有 $10^4$ 个单词,每个单词长度最多为 $10$,如果开成静态数组的话,不考虑共用行的问题,我们需要开一个大小为 $10^5 * 26$ 的大数组,可能会有 TLE 或 MLE 的风险。\n\n与此同时,我们需要将平时建 $TrieNode$ 中的 `isEnd` 标记属性直接换成记录当前字符 `s`,这样我们在 `DFS` 的过程中则无须额外记录当前搜索字符串。\n\n代码:\n```Java\nclass Solution {\n    class TrieNode {\n        String s;\n        TrieNode[] tns = new TrieNode[26];\n    }\n    void insert(String s) {\n        TrieNode p = root;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (p.tns[u] == null) p.tns[u] = new TrieNode();\n            p = p.tns[u];\n        }\n        p.s = s;\n    }\n    Set<String> set = new HashSet<>();\n    char[][] board;\n    int n, m;\n    TrieNode root = new TrieNode();\n    int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n    boolean[][] vis = new boolean[15][15];\n    public List<String> findWords(char[][] _board, String[] words) {\n        board = _board;\n        m = board.length; n = board[0].length;\n        for (String w : words) insert(w);\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                int u = board[i][j] - 'a';\n                if (root.tns[u] != null) {\n                    vis[i][j] = true;\n                    dfs(i, j, root.tns[u]);\n                    vis[i][j] = false;\n                }\n            }\n        }\n        List<String> ans = new ArrayList<>();\n        for (String s : set) ans.add(s);\n        return ans;\n    }\n    void dfs(int i, int j, TrieNode node) {\n        if (node.s != null) set.add(node.s);\n        for (int[] d : dirs) {\n            int dx = i + d[0], dy = j + d[1];\n            if (dx < 0 || dx >= m || dy < 0 || dy >= n) continue;\n            if (vis[dx][dy]) continue;\n            int u = board[dx][dy] - 'a';\n            if (node.tns[u] != null) {\n                vis[dx][dy] = true;\n                dfs(dx, dy, node.tns[u]);\n                vis[dx][dy] = false;\n            }\n        }\n    }\n}\n```\n* 时间复杂度:共有 $m * n$ 个起点,每次能往 $4$ 个方向搜索(不考虑重复搜索问题),且搜索的长度不会超过 $10$。整体复杂度为 $O(m * n * 4^{10})$\n* 空间复杂度:$O(\\sum_{i=0}^{words.length - 1} words[i].length * C)$,$C$ 为字符集大小,固定为 $26$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.212` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/211-220/213. 打家劫舍 II（中等）.md", "url_title": "213. 打家劫舍 II", "url": "https://leetcode-cn.com/problems/house-robber-ii/solution/gong-shui-san-xie-ru-he-jiang-xin-xian-z-zf0w/", "difficulty": "中等", "tags": ["线性 DP"], "question": "你是一个专业的小偷,计划偷窃沿街的房屋,每间房内都藏有一定的现金。\n\n这个地方所有的房屋都 围成一圈 ,这意味着第一个房屋和最后一个房屋是紧挨着的。\n\n同时,相邻的房屋装有相互连通的防盗系统,如果两间相邻的房屋在同一晚上被小偷闯入,系统会自动报警 。\n\n给定一个代表每个房屋存放金额的非负整数数组,计算你 在不触动警报装置的情况下 ,今晚能够偷窃到的最高金额。\n\n示例 1:\n```\n输入:nums = [2,3,2]\n\n输出:3\n\n解释:你不能先偷窃 1 号房屋(金额 = 2),然后偷窃 3 号房屋(金额 = 2), 因为他们是相邻的。\n```\n示例 2:\n```\n输入:nums = [1,2,3,1]\n\n输出:4\n\n解释:你可以先偷窃 1 号房屋(金额 = 1),然后偷窃 3 号房屋(金额 = 3)。\n     偷窃到的最高金额 = 1 + 3 = 4 。\n```\n示例 3:\n```\n输入:nums = [0]\n\n输出:0\n```\n\n提示:\n* 1 <= nums.length <= 100\n* 0 <= nums[i] <= 1000", "solution": "### 动态规划\n\n在 [198. 打家劫舍](https://leetcode-cn.com/problems/house-robber/) 中,并没有「第一间」和「最后一间」不能同时选择的限制,因此我们从头到尾做一遍 DP 即可。\n\n在 [198. 打家劫舍](https://leetcode-cn.com/problems/house-robber/) 中,我们可以将状态定义为两维:\n\n**$f[i][j]$ 代表考虑前 $i$ 个房间,当前 $i$ 房间的现在状态为 $j$ 的最大价值。**\n\n* $f[i][0]$ 代表考虑前 $i$ 个房间,并且「不选」第 $i$ 个房间的最大价值。由于已经明确了第 $i$ 个房间不选,因此 $f[i][0]$ 可以直接由 $max(f[i - 1][0], f[i - 1][1])$ 转移而来。\n\n* $f[i][1]$ 代表考虑前 $i$ 个房间,并且「选」第 $i$ 个房间的最大价值。由于已经明确了第 $i$ 个房间被选,因此 $f[i][1]$ 直接由 $f[i - 1][0] + nums[i]$ 转移过来。\n\n到这里,你已经解决了 [198. 打家劫舍](https://leetcode-cn.com/problems/house-robber/) 了。\n\n对于本题,由于只是增加了「第一间」和「最后一间」不能同时选择的限制。\n\n**通常,对于一些明显不是「增加维度」的新限制条件,我们应当考虑直接将其拎出讨论,而不是多增加一维进行状态记录。**\n\n我们可以把「第一间」&「最后一间」单独拎出来讨论:\n\n* 明确「不选」第一间:\n    1. 初始化 $f[0][0]$ 和 $f[0][1]$,均为 $0$。\n    2. 先从「第二间」开始递推到「倒数第二间」的最大价值。\n    3. 再处理「最后一间」的情况:由于明确了「不选第一间」,则最后的最大价值为 $max(f[n - 2][1], f[n - 2][0] + nums[n - 1])$。\n\n* 允许「选」第一间:\n    1. 初始化 $f[0][0]$ 和 $f[0][1]$,分别为 $0$ 和 $nums[0]$。\n    2. 先从「第二间」开始递推到「倒数第二间」的最大价值。\n    3. 再处理「最后一间」的情况:由于明确了「选第一间」,则最后的最大价值为 $max(f[n - 2][0], f[n - 2][1])$。\n\n走完两遍 DP 后,再从两种情况的最大价值中再取一个 $max$ 即是答案。\n\n代码:\n```java []\nclass Solution {\n    public int rob(int[] nums) {\n        int n = nums.length;\n        if (n == 0) return 0;\n        if (n == 1) return nums[0];\n\n        // 第一间「必然不选」的情况\n        int[][] f = new int[n][2];\n        for (int i = 1; i < n - 1; i++) {\n            f[i][0] = Math.max(f[i - 1][0], f[i - 1][1]);\n            f[i][1] = f[i - 1][0] + nums[i];\n        }\n        int a = Math.max(f[n - 2][1], f[n - 2][0] + nums[n - 1]);\n        \n        // 第一间「允许选」的情况\n        f[0][0] = 0; f[0][1] = nums[0];\n        for (int i = 1; i < n - 1; i++) {\n            f[i][0] = Math.max(f[i - 1][0], f[i - 1][1]);\n            f[i][1] = f[i - 1][0] + nums[i];\n        }\n        int b = Math.max(f[n - 2][0], f[n - 2][1]);\n        \n        return Math.max(a, b);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 空间优化\n\n不难发现,我们状态转移最多依赖到前面的 1 行,因此可以通过很机械的「滚动数组」方式将空间修改到 $O(1)$。\n\n代码:\n```java []\nclass Solution {\n    public int rob(int[] nums) {\n        int n = nums.length;\n        if (n == 0) return 0;\n        if (n == 1) return nums[0];\n\n        // 第一间「必然不选」的情况\n        int[][] f = new int[2][2];\n        for (int i = 1; i < n - 1; i++) {\n            f[i%2][0] = Math.max(f[(i - 1)%2][0], f[(i - 1)%2][1]);\n            f[i%2][1] = f[(i - 1)%2][0] + nums[i];\n        }\n        int a = Math.max(f[(n - 2)%2][1], f[(n - 2)%2][0] + nums[n - 1]);\n        \n        // 第一间「允许选」的情况\n        f[0][0] = 0; f[0][1] = nums[0];\n        for (int i = 1; i < n - 1; i++) {\n            f[i%2][0] = Math.max(f[(i - 1)%2][0], f[(i - 1)%2][1]);\n            f[i%2][1] = f[(i - 1)%2][0] + nums[i];\n        }\n        int b = Math.max(f[(n - 2)%2][0], f[(n - 2)%2][1]);\n        \n        return Math.max(a, b);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.213` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/211-220/215. 数组中的第K个最大元素（中等）.md", "url_title": "215. 数组中的第K个最大元素", "url": "https://leetcode.cn/problems/kth-largest-element-in-an-array/solution/by-ac_oier-x9h4/", "difficulty": "中等", "tags": ["树状数组", "二分", "优先队列(堆)", "快速选择"], "question": "给定整数数组 `nums` 和整数 `k`,请返回数组中第 `k` 个最大的元素。\n\n请注意,你需要找的是数组排序后的第 `k` 个最大的元素,而不是第 `k` 个不同的元素。\n\n你必须设计并实现时间复杂度为 $O(n)$ 的算法解决此问题。\n\n示例 1:\n```\n输入: [3,2,1,5,6,4], k = 2\n\n输出: 5\n```\n示例 2:\n```\n输入: [3,2,3,1,2,4,5,5,6], k = 4\n\n输出: 4\n```\n\n提示:\n* $1 <= k <= nums.length <= 10^5$\n* $-10^4 <= nums[i] <= 10^4$", "solution": "### 值域映射 + 树状数组 + 二分\n\n除了直接对数组进行排序,取第 $k$ 位的 $O(n\\log{n})$ 做法以外。\n\n对于值域大小 小于 数组长度本身时,我们还能使用「树状数组 + 二分」的 $O(n\\log{m})$ 做法,其中 $m$ 为值域大小。\n\n首先值域大小为 $[-10^4, 10^4]$,为了方便,我们为每个 $nums[i]$ 增加大小为 $1e4 + 10$ 的偏移量,将值域映射到 $[10, 2 \\times 10^4 + 10]$ 的空间。\n\n将每个增加偏移量后的 $nums[i]$ 存入树状数组,考虑在 $[0, m)$ 范围内进行二分,假设我们真实第 $k$ 大的值为 $t$,那么在以 $t$ 为分割点的数轴上,具有二段性质:\n\n* 在 $[0, t]$ 范围内的数 $cur$ 满足「树状数组中大于等于 $cur$ 的数不低于 $k$ 个」\n* 在 $(t, m)$ 范围内的数 $cur$ 不满足「树状数组中大于等于 $cur$ 的数不低于 $k$ 个」\n\n二分出结果后再减去刚开始添加的偏移量即是答案。\n\nJava 代码:\n```Java\nclass Solution {\n    int M = 100010, N = 2 * M;\n    int[] tr = new int[N];\n    int lowbit(int x) {\n        return x & -x;\n    }\n    int query(int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];\n        return ans;\n    }\n    void add(int x) {\n        for (int i = x; i < N; i += lowbit(i)) tr[i]++;\n    }\n    public int findKthLargest(int[] nums, int k) {\n        for (int x : nums) add(x + M);\n        int l = 0, r = N - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (query(N - 1) - query(mid - 1) >= k) l = mid;\n            else r = mid - 1;\n        }\n        return r - M;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int N = 200010, M = 100010, tr[200010];\n    int lowbit(int x) {\n        return x & -x;\n    }\n    int query(int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];\n        return ans;\n    }\n    void add(int x) {\n        for (int i = x; i < N; i += lowbit(i)) tr[i]++;\n    }\n    int findKthLargest(vector<int>& nums, int k) {\n        for (int x : nums) add(x + M);\n        int l = 0, r = N - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (query(N - 1) - query(mid - 1) >= k) l = mid;\n            else r = mid - 1;\n        }\n        return r - M;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def findKthLargest(self, nums: List[int], k: int) -> int:\n        N, M = 200010, 100010\n        tr = [0] * N\n        def lowbit(x):\n            return x & -x\n        def query(x):\n            ans = 0\n            i = x\n            while i > 0:\n                ans += tr[i]\n                i -= lowbit(i)\n            return ans\n        def add(x):\n            i = x\n            while i < N:\n                tr[i] += 1\n                i += lowbit(i)\n        for x in nums:\n            add(x + M)\n        l, r = 0, N - 1\n        while l < r:\n            mid = l + r + 1 >> 1\n            if query(N - 1) - query(mid - 1) >= k: l = mid\n            else: r = mid - 1\n        return r - M\n```\nTypeScript 代码:\n```TypeScript\nfunction findKthLargest(nums: number[], k: number): number {\n    const N = 200010, M = 100010;\n    const tr = new Array(N).fill(0);\n    const lowbit = function(x: number): number {\n        return x & -x;\n    };\n    const add = function(x: number): void {\n        for (let i = x; i < N; i += lowbit(i)) tr[i]++;\n    };\n    const query = function(x: number): number {\n        let ans = 0;\n        for (let i = x; i > 0; i -= lowbit(i)) ans += tr[i];\n        return ans;\n    };\n    for (const x of nums) add(x + M);\n    let l = 0, r = N - 1;\n    while (l < r) {\n        const mid = l + r + 1 >> 1;\n        if (query(N - 1) - query(mid - 1) >= k) l = mid;\n        else r = mid - 1;\n    }\n    return r - M;\n};\n```\n* 时间复杂度:将所有数字放入树状数组复杂度为 $O(n\\log{m})$;二分出答案复杂度为 $O(\\log^2{m})$,其中 $m = 2 \\times 10^4$ 为值域大小。整体复杂度为 $O(n\\log{m})$\n* 空间复杂度:$O(m)$\n\n---\n\n### 优先队列(堆)\n\n另外一个容易想到的想法是利用优先队列(堆),由于题目要我们求的是第 $k$ 大的元素,因此我们建立一个小根堆。\n\n根据当前队列元素个数或当前元素与栈顶元素的大小关系进行分情况讨论:\n\n* 当优先队列元素不足 $k$ 个,可将当前元素直接放入队列中;\n* 当优先队列元素达到 $k$ 个,并且当前元素大于栈顶元素(栈顶元素必然不是答案),可将当前元素放入队列中。\n\nJava 代码:\n```Java\nclass Solution {\n    public int findKthLargest(int[] nums, int k) {\n        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->a-b);\n        for (int x : nums) {\n            if (q.size() < k || q.peek() < x) q.add(x);\n            if (q.size() > k) q.poll();\n        }\n        return q.peek();\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int findKthLargest(vector<int>& nums, int k) {\n        priority_queue<int, vector<int>, greater<int>> q;\n        for (int x : nums) {\n            if (q.size() < k || q.top() < x) q.push(x);\n            if (q.size() > k) q.pop();\n        }\n        return q.top();\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def findKthLargest(self, nums: List[int], k: int) -> int:\n        q = []\n        for x in nums:\n            if len(q) < k or q[0] < x:\n                heapq.heappush(q, x)\n            if len(q) > k:\n                heapq.heappop(q)\n        return q[0]\n```\n* 时间复杂度:$O(n\\log{k})$\n* 空间复杂度:$O(k)$\n\n---\n\n### 快速选择\n\n对于给定数组,求解第 $k$ 大元素,且要求线性复杂度,正解为使用「快速选择」做法。\n\n基本思路与「快速排序」一致,每次敲定一个基准值 `x`,根据当前与 `x` 的大小关系,将范围在 $[l, r]$ 的 $nums[i]$ 划分为到两边。\n\n同时利用,利用题目只要求输出第 $k$ 大的值,而不需要对数组进行整体排序,我们只需要根据划分两边后,第 $k$ 大数会落在哪一边,来决定对哪边进行递归处理即可。\n\n> 快速排序模板为面试向重点内容,需要重要掌握。\n\nJava 代码:\n```Java\nclass Solution {\n    int[] nums;\n    int qselect(int l, int r, int k) {\n        if (l == r) return nums[k];\n        int x = nums[l], i = l - 1, j = r + 1;\n        while (i < j) {\n            do i++; while (nums[i] < x);\n            do j--; while (nums[j] > x);\n            if (i < j) swap(i, j);\n        }\n        if (k <= j) return qselect(l, j, k);\n        else return qselect(j + 1, r, k);\n    }\n    void swap(int i, int j) {\n        int c = nums[i];\n        nums[i] = nums[j];\n        nums[j] = c;\n    }\n    public int findKthLargest(int[] _nums, int k) {\n        nums = _nums;\n        int n = nums.length;\n        return qselect(0, n - 1, n - k);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> nums;\n    int qselect(int l, int r, int k) {\n        if (l == r) return nums[k];\n        int x = nums[l], i = l - 1, j = r + 1;\n        while (i < j) {\n            do i++; while (nums[i] < x);\n            do j--; while (nums[j] > x);\n            if (i < j) swap(nums[i], nums[j]);\n        }\n        if (k <= j) return qselect(l, j, k);\n        else return qselect(j + 1, r, k);\n    }\n    int findKthLargest(vector<int>& _nums, int k) {\n        nums = _nums;\n        int n = nums.size();\n        return qselect(0, n - 1, n - k);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def findKthLargest(self, nums: List[int], k: int) -> int:\n        def qselect(l, r, k):\n            if l == r:\n                return nums[k]\n            x, i, j = nums[l], l - 1, r + 1\n            while i < j:\n                i += 1\n                while nums[i] < x:\n                    i += 1\n                j -= 1\n                while nums[j] > x:\n                    j -= 1\n                if i < j:\n                    nums[i], nums[j] = nums[j], nums[i]\n            if k <= j:\n                return qselect(l, j, k)\n            else:\n                return qselect(j + 1, r, k)\n\n        n = len(nums)\n        return qselect(0, n - 1, n - k)\n```\nTypeScript 代码:\n```TypeScript\nfunction findKthLargest(nums: number[], k: number): number {\n    const qselect = function(l: number, r: number, k: number): number {\n        if (l === r) return nums[k];\n        const x = nums[l];\n        let i = l - 1, j = r + 1;\n        while (i < j) {\n            i++;\n            while (nums[i] < x) i++;\n            j--;\n            while (nums[j] > x) j--;\n            if (i < j) [nums[i], nums[j]] = [nums[j], nums[i]];\n        }\n        if (k <= j) return qselect(l, j, k);\n        else return qselect(j + 1, r, k);\n    };\n    const n = nums.length;\n    return qselect(0, n - 1, n - k);\n};\n```\n* 时间复杂度:期望 $O(n)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.215` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/211-220/218. 天际线问题（困难）.md", "url_title": "218. 天际线问题", "url": "https://leetcode-cn.com/problems/the-skyline-problem/solution/gong-shui-san-xie-sao-miao-xian-suan-fa-0z6xc/", "difficulty": "困难", "tags": ["扫描线问题", "优先队列(堆)"], "question": "城市的天际线是从远处观看该城市中所有建筑物形成的轮廓的外部轮廓。\n\n给你所有建筑物的位置和高度,请返回由这些建筑物形成的 天际线 。\n\n每个建筑物的几何信息由数组 `buildings` 表示,其中三元组 `buildings[i] = [lefti, righti, heighti]` 表示:\n\n* `left[i]` 是第 `i` 座建筑物左边缘的 `x` 坐标。\n* `right[i]` 是第 `i` 座建筑物右边缘的 `x` 坐标。\n* `height[i]` 是第 `i` 座建筑物的高度。\n\n天际线 应该表示为由 “关键点” 组成的列表,格式 `[[x1,y1],[x2,y2],...]`,并按 `x` 坐标 进行 排序 。\n\n关键点是水平线段的左端点。列表中最后一个点是最右侧建筑物的终点,`y` 坐标始终为 $0$ ,仅用于标记天际线的终点。\n\n此外,任何两个相邻建筑物之间的地面都应被视为天际线轮廓的一部分。\n\n注意:输出天际线中不得有连续的相同高度的水平线。例如  `[...[2 3], [4 5], [7 5], [11 5], [12 7]...]` 是不正确的答案;三条高度为 $5$ 的线应该在最终输出中合并为一个:`[...[2 3], [4 5], [12 7], ...]`\n\n示例 1:\n\n```\n输入:buildings = [[2,9,10],[3,7,15],[5,12,12],[15,20,10],[19,24,8]]\n\n输出:[[2,10],[3,15],[7,12],[12,0],[15,10],[20,8],[24,0]]\n\n解释:\n图 A 显示输入的所有建筑物的位置和高度,\n图 B 显示由这些建筑物形成的天际线。图 B 中的红点表示输出列表中的关键点。\n```\n示例 2:\n```\n输入:buildings = [[0,2,3],[2,5,3]]\n\n输出:[[0,3],[5,0]]\n```\n\n提示:\n* $1 <= buildings.length <= 10^4$\n* $0 <= lefti < righti <= 2^{31} - 1$\n* $1 <= heighti <= 2^{31} - 1$\n* `buildings` 按 $left_i$ 非递减排序", "solution": "### 基本分析\n\n这是一题特别的扫描线问题 🤣🤣🤣\n\n既不是求周长,也不是求面积,是求轮廓中的所有的水平线的左端点 🤣🤣🤣\n\n所以这不是一道必须用「线段树」来解决的扫描线问题(因为不需要考虑区间查询问题)。\n\n扫描线的核心在于 **将不规则的形状按照水平或者垂直的方式,划分成若干个规则的矩形。**\n\n---\n\n### 扫描线\n\n对于本题,对应的扫描线分割形状如图:\n\n不难发现,由相邻两个横坐标以及最大高度,可以确定一个矩形。\n\n题目要我们 **输出每个矩形的“上边”的左端点,同时跳过可由前一矩形“上边”延展而来的那些边。**\n\n因此我们需要实时维护一个最大高度,可以使用优先队列(堆)。\n\n实现时,我们可以先记录下 $buildings$ 中所有的左右端点横坐标及高度,并根据端点横坐标进行从小到大排序。\n\n在从前往后遍历处理时(遍历每个矩形),根据当前遍历到的点进行分情况讨论:\n\n* 左端点:因为是左端点,必然存在一条从右延展的边,但不一定是需要被记录的边,因为在同一矩形中,我们只需要记录最上边的边。这时候可以将高度进行入队;\n\n* 右端点:此时意味着之前某一条往右延展的线结束了,这时候需要将高度出队(代表这结束的线不被考虑)。\n\n然后从优先队列中取出当前的最大高度,为了防止当前的线与前一矩形“上边”延展而来的线重合,我们需要使用一个变量 `prev` 记录上一个记录的高度。\n\n代码:\n```Java\nclass Solution {\n    public List<List<Integer>> getSkyline(int[][] bs) {\n        List<List<Integer>> ans = new ArrayList<>();\n        \n        // 预处理所有的点,为了方便排序,对于左端点,令高度为负;对于右端点令高度为正\n        List<int[]> ps = new ArrayList<>();\n        for (int[] b : bs) {\n            int l = b[0], r = b[1], h = b[2];\n            ps.add(new int[]{l, -h});\n            ps.add(new int[]{r, h});\n        }\n\n        // 先按照横坐标进行排序\n        // 如果横坐标相同,则按照左端点排序\n        // 如果相同的左/右端点,则按照高度进行排序\n        Collections.sort(ps, (a, b)->{\n            if (a[0] != b[0]) return a[0] - b[0];\n            return a[1] - b[1];\n        });\n        \n        // 大根堆\n        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);\n        int prev = 0;\n        q.add(prev);\n        for (int[] p : ps) {\n            int point = p[0], height = p[1];\n            if (height < 0) {\n                // 如果是左端点,说明存在一条往右延伸的可记录的边,将高度存入优先队列\n                q.add(-height);\n            } else {\n                // 如果是右端点,说明这条边结束了,将当前高度从队列中移除\n                q.remove(height);\n            }\n\n            // 取出最高高度,如果当前不与前一矩形“上边”延展而来的那些边重合,则可以被记录\n            int cur = q.peek();\n            if (cur != prev) {\n                List<Integer> list = new ArrayList<>();\n                list.add(point);\n                list.add(cur);\n                ans.add(list);\n                prev = cur;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:需要处理的矩阵数量与 $n$ 正比,每个矩阵需要使用优先队列维护高度,其中 `remove` 操作需要先花费 $O(n)$ 复杂度进行查找,然后通过 $O(\\log{n})$ 复杂度进行移除,复杂度为 $O(n)$。整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 答疑\n\n**1. 将左端点的高度存成负数再进行排序是什么意思?**\n\n这里只是为了方便,所以采取了这样的做法,当然也能够多使用一位来代指「左右」。\n\n只要最终可以达到如下的排序规则即可:\n\n1. 先严格按照横坐标进行「从小到大」排序\n2. 对于某个横坐标而言,可能会同时出现多个点,应当按照如下规则进行处理:\n    1. 优先处理左端点,再处理右端点\n    2. 如果同样都是左端点,则按照高度「从大到小」进行处理(将高度增加到优先队列中)\n    3. 如果同样都是右端点,则按照高度「从小到大」进行处理(将高度从优先队列中删掉)\n\n代码:\n```Java\nclass Solution {\n    public List<List<Integer>> getSkyline(int[][] bs) {\n        List<List<Integer>> ans = new ArrayList<>();\n        List<int[]> ps = new ArrayList<>();\n        for (int[] b : bs) {\n            int l = b[0], r = b[1], h = b[2];\n            ps.add(new int[]{l, h, -1});\n            ps.add(new int[]{r, h, 1});\n        }\n        /**\n         * 先严格按照横坐标进行「从小到大」排序\n         * 对于某个横坐标而言,可能会同时出现多个点,应当按照如下规则进行处理:\n         * 1. 优先处理左端点,再处理右端点\n         * 2. 如果同样都是左端点,则按照高度「从大到小」进行处理(将高度增加到优先队列中)\n         * 3. 如果同样都是右端点,则按照高度「从小到大」进行处理(将高度从优先队列中删掉)\n         */\n        Collections.sort(ps, (a, b)->{\n            if (a[0] != b[0]) return a[0] - b[0];\n            if (a[2] != b[2]) return a[2] - b[2];\n            if (a[2] == -1) {\n                return b[1] - a[1];\n            } else {\n                return a[1] - b[1];\n            }\n        });\n        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);\n        int prev = 0;\n        q.add(prev);\n        for (int[] p : ps) {\n            int point = p[0], height = p[1], flag = p[2];\n            if (flag == -1) {\n                q.add(height);\n            } else {\n                q.remove(height);\n            }\n\n            int cur = q.peek();\n            if (cur != prev) {\n                List<Integer> list = new ArrayList<>();\n                list.add(point);\n                list.add(cur);\n                ans.add(list);\n                prev = cur;\n            }\n        }\n        return ans;\n    }\n}\n```\n\n**2. 为什么在处理前,先往「优先队列」添加一个 $0$ ?**\n\n因为题目本身要求我们把一个完整轮廓的「右下角」那个点也取到,所以需要先添加一个 $0$。\n\n也就是下图被圈出来的那些点:\n\n**3. 优先队列的 `remove` 操作成为了瓶颈,如何优化?**\n\n由于优先队列的 `remove` 操作需要先经过 $O(n)$ 的复杂度进行查找,再通过 $O(\\log{n})$ 的复杂度进行删除。因此整个 `remove` 操作的复杂度是 $O(n)$ 的,这导致了我们算法整体复杂度为 $O(n^2)$。\n\n优化方式包括:使用基于红黑树的 `TreeMap` 代替优先队列;或是使用「哈希表」记录「执行了删除操作的高度」及「删除次数」,在每次使用前先检查堆顶高度是否已经被标记删除,如果是则进行 `poll` 操作,并更新删除次数,直到遇到一个没被删除的堆顶高度。\n\n代码:\n```Java\nclass Solution {\n    public List<List<Integer>> getSkyline(int[][] bs) {\n        List<List<Integer>> ans = new ArrayList<>();\n        List<int[]> ps = new ArrayList<>();\n        for (int[] b : bs) {\n            int l = b[0], r = b[1], h = b[2];\n            ps.add(new int[]{l, h, -1});\n            ps.add(new int[]{r, h, 1});\n        }\n        /**\n         * 先严格按照横坐标进行「从小到大」排序\n         * 对于某个横坐标而言,可能会同时出现多个点,应当按照如下规则进行处理:\n         * 1. 优先处理左端点,再处理右端点\n         * 2. 如果同样都是左端点,则按照高度「从大到小」进行处理(将高度增加到优先队列中)\n         * 3. 如果同样都是右端点,则按照高度「从小到大」进行处理(将高度从优先队列中删掉)\n         */\n        Collections.sort(ps, (a, b)->{\n            if (a[0] != b[0]) return a[0] - b[0];\n            if (a[2] != b[2]) return a[2] - b[2];\n            if (a[2] == -1) {\n                return b[1] - a[1];\n            } else {\n                return a[1] - b[1];\n            }\n        });\n        // 记录进行了删除操作的高度,以及删除次数\n        Map<Integer, Integer> map = new HashMap<>();\n        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);\n        int prev = 0;\n        q.add(prev);\n        for (int[] p : ps) {\n            int point = p[0], height = p[1], flag = p[2];\n            if (flag == -1) {\n                q.add(height);\n            } else {\n                map.put(height, map.getOrDefault(height, 0) + 1);\n            }\n\n            while (!q.isEmpty()) {\n                int peek = q.peek();\n                if (map.containsKey(peek)) {\n                    if (map.get(peek) == 1) map.remove(peek);\n                    else map.put(peek, map.get(peek) - 1);\n                    q.poll();\n                } else {\n                    break;\n                }\n            }\n\n            int cur = q.peek();\n            if (cur != prev) {\n                List<Integer> list = new ArrayList<>();\n                list.add(point);\n                list.add(cur);\n                ans.add(list);\n                prev = cur;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.218` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/211-220/219. 存在重复元素 II（简单）.md", "url_title": "219. 存在重复元素 II", "url": "https://leetcode-cn.com/problems/contains-duplicate-ii/solution/gong-shui-san-xie-hua-dong-chuang-kou-yu-q02i/", "difficulty": "简单", "tags": ["滑动窗口", "哈希表"], "question": "给你一个整数数组 `nums` 和一个整数 `k` ,判断数组中是否存在两个 不同的索引 `i` 和 `j` ,满足 `nums[i] == nums[j]` 且 `abs(i - j) <= k` 。如果存在,返回 `true` ;否则,返回 `false` 。\n\n示例 1:\n```\n输入:nums = [1,2,3,1], k = 3\n\n输出:true\n```\n示例 2:\n```\n输入:nums = [1,0,1,1], k = 1\n\n输出:true\n```\n示例 3:\n```\n输入:nums = [1,2,3,1,2,3], k = 2\n\n输出:false\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $-10^9 <= nums[i] <= 10^9$\n* $0 <= k <= 10^5$", "solution": "### 滑动窗口 + 哈希表\n\n整理题意:是否存在长度不超过的 $k + 1$ 窗口,窗口内有相同元素。\n\n我们可以从前往后遍历 $nums$,同时使用 `Set` 记录遍历当前滑窗内出现过的元素。\n\n假设当前遍历的元素为 $nums[i]$:\n\n* 下标小于等于 $k$(起始滑窗长度还不足 $k + 1$):直接往滑窗加数,即将当前元素加入 `Set` 中;\n* 下标大于 $k$:将上一滑窗的左端点元素 $nums[i - k - 1]$ 移除,判断当前滑窗的右端点元素 $nums[i]$ 是否存在 `Set` 中,若存在,返回 `True`,否则将当前元素 $nums[i]$ 加入 `Set` 中。\n\n重复上述过程,若整个 $nums$ 处理完后仍未找到,返回 `False`。\n\n**代码(感谢 [@Benhao](/u/himymben/) 同学提供的其他语言版本):**\n```Java\nclass Solution {\n    public boolean containsNearbyDuplicate(int[] nums, int k) {\n        int n = nums.length;\n        Set<Integer> set = new HashSet<>();\n        for (int i = 0; i < n; i++) {\n            if (i > k) set.remove(nums[i - k - 1]);\n            if (set.contains(nums[i])) return true;\n            set.add(nums[i]);\n        }\n        return false;\n    }\n}\n```\n-\n```Python3\nclass Solution:\n    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:\n        n = len(nums)\n        s = set()\n        for i in range(n):\n            if i > k:\n                s.remove(nums[i - k - 1])\n            if nums[i] in s:\n                return True\n            s.add(nums[i])\n        return False\n````\n-\n```Go\nfunc containsNearbyDuplicate(nums []int, k int) bool {\n    n := len(nums)\n    set := map[int]bool{}\n    for i := 0; i < n; i++ {\n        if i > k {\n            set[nums[i - k - 1]] = false\n        }\n        if set[nums[i]] {\n            return true\n        }\n        set[nums[i]] = true\n    }\n    return false\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(k)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.219` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/211-220/220. 存在重复元素 III（中等）.md", "url_title": "220. 存在重复元素 III", "url": "https://leetcode-cn.com/problems/contains-duplicate-iii/solution/gong-shui-san-xie-yi-ti-shuang-jie-hua-d-dlnv/", "difficulty": "中等", "tags": ["滑动窗口", "二分", "桶排序"], "question": "给你一个整数数组 nums 和两个整数 k 和 t 。\n\n请你判断是否存在 两个不同下标 i 和 j,使得 abs(nums[i] - nums[j]) <= t ,同时又满足 abs(i - j) <= k 。\n\n如果存在则返回 true,不存在返回 false。\n\n示例 1:\n```\n输入:nums = [1,2,3,1], k = 3, t = 0\n\n输出:true\n```\n示例 2:\n```\n输入:nums = [1,0,1,1], k = 1, t = 2\n\n输出:true\n```\n示例 3:\n```\n输入:nums = [1,5,9,1,5,9], k = 2, t = 3\n\n输出:false\n```\n\n提示:\n* 0 <= nums.length <= 2 * $10^4$\n* -$2^{31}$ <= nums[i] <= $2^{31}$ - 1\n* 0 <= k <= $10^4$\n* 0 <= t <= $2^{31}$ - 1", "solution": "### 滑动窗口 & 二分\n\n**根据题意,对于任意一个位置 `i`(假设其值为 `u`),我们其实是希望在下标范围为 $[max(0, i - k), i)$ 内找到值范围在 $[u - t, u + t]$ 的数。**\n\n一个朴素的想法是每次遍历到任意位置 `i` 的时候,往后检查 `k` 个元素,但这样做的复杂度是 $O(nk)$ 的,会超时。\n\n显然我们需要优化「检查后面 `k` 个元素」这一过程。\n\n**我们希望使用一个「有序集合」去维护长度为 `k` 的滑动窗口内的数,该数据结构最好支持高效「查询」与「插入/删除」操作:**\n\n* **查询:能够在「有序集合」中应用「二分查找」,快速找到「小于等于 $u$ 的最大值」和「大于等于 `u` 的最小值」(即「有序集合」中的最接近 `u` 的数)。**\n* **插入/删除:在往「有序集合」添加或删除元素时,能够在低于线性的复杂度内完成(维持有序特性)。**\n\n或许你会想到近似 $O(1)$ 操作的 `HashMap`,但注意这里我们需要找的是符合 $abs(nums[i], nums[j]) \\leqslant t$ 的两个值,`nums[i]` 与 `nums[j]` 并不一定相等,而 `HashMap` 无法很好的支持「范围查询」操作。  \n\n我们还会想到「树」结构。\n\n例如 AVL,能够让我们在最坏为 $O(\\log{k})$ 的复杂度内取得到最接近 `u` 的值是多少,但本题除了「查询」以外,还涉及频繁的「插入/删除」操作(随着我们遍历 `nums` 的元素,滑动窗口不断右移,我们需要不断的往「有序集合」中删除和添加元素)。\n\n简单采用 AVL 树,会导致每次的插入删除操作都触发 AVL 的平衡调整,一次平衡调整会伴随着若干次的旋转。\n\n而红黑树则很好解决了上述问题:将平衡调整引发的旋转的次数从「若干次」限制到「最多三次」。\n\n**因此,当「查询」动作和「插入/删除」动作频率相当时,更好的选择是使用「红黑树」。**\n\n也就是对应到 Java 中的 `TreeSet` 数据结构(基于红黑树,查找和插入都具有折半的效率)。\n\n其他细节:由于 `nums` 中的数较大,会存在 `int` 溢出问题,我们需要使用 `long` 来存储。\n\n代码:\n```Java\nclass Solution {\n    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {\n        int n = nums.length;\n        TreeSet<Long> ts = new TreeSet<>();\n        for (int i = 0; i < n; i++) {\n            Long u = nums[i] * 1L;\n            // 从 ts 中找到小于等于 u 的最大值(小于等于 u 的最接近 u 的数)\n            Long l = ts.floor(u); \n            // 从 ts 中找到大于等于 u 的最小值(大于等于 u 的最接近 u 的数)\n            Long r = ts.ceiling(u); \n            if(l != null && u - l <= t) return true;\n            if(r != null && r - u <= t) return true;\n            // 将当前数加到 ts 中,并移除下标范围不在 [max(0, i - k), i) 的数(维持滑动窗口大小为 k)\n            ts.add(u);\n            if (i >= k) ts.remove(nums[i - k] * 1L);\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:`TreeSet` 基于红黑树,查找和插入都是 $O(\\log{k})$ 复杂度。整体复杂度为 $O(n\\log{k})$\n* 空间复杂度:$O(k)$\n\n---\n\n### 桶排序\n\n**上述解法无法做到线性的原因是:我们需要在大小为 `k` 的滑动窗口所在的「有序集合」中找到与 `u` 接近的数。**\n\n**如果我们能够将 `k` 个数字分到 $k$ 个桶的话,那么我们就能 $O(1)$ 的复杂度确定是否有 $[u - t, u + t]$ 的数字(检查目标桶是否有元素)。**\n\n具体的做法为:令桶的大小为 $size = t + 1$,根据 `u` 计算所在桶编号:\n\n* 如果已经存在该桶,说明前面已有 $[u - t, u + t]$ 范围的数字,返回 `true`\n* 如果不存在该桶,则检查相邻两个桶的元素是有 $[u - t, u + t]$ 范围的数字,如有 返回 `true`\n* 建立目标桶,并删除下标范围不在 $[max(0, i - k), i)$ 内的桶\n\n代码:\n```Java\nclass Solution {\n    long size;\n    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {\n        int n = nums.length;\n        Map<Long, Long> map = new HashMap<>();\n        size = t + 1L;\n        for (int i = 0; i < n; i++) {\n            long u = nums[i] * 1L;\n            long idx = getIdx(u);\n            // 目标桶已存在(桶不为空),说明前面已有 [u - t, u + t] 范围的数字\n            if (map.containsKey(idx)) return true;\n            // 检查相邻的桶\n            long l = idx - 1, r = idx + 1;\n            if (map.containsKey(l) && u - map.get(l) <= t) return true;\n            if (map.containsKey(r) && map.get(r) - u <= t) return true;\n            // 建立目标桶\n            map.put(idx, u);\n            // 移除下标范围不在 [max(0, i - k), i) 内的桶\n            if (i >= k) map.remove(getIdx(nums[i - k] * 1L));\n        }\n        return false;\n    }\n    long getIdx(long u) {\n        return u >= 0 ? u / size : ((u + 1) / size) - 1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(k)$\n\n---\n\n### 【重点】如何理解 `getIdx()` 的逻辑\n\n1. 为什么 `size` 需要对 `t` 进行 `+1` 操作?\n\n**目的是为了确保差值小于等于 `t` 的数能够落到一个桶中。**\n\n举个 🌰,假设 `[0,1,2,3]`,`t = 3`,显然四个数都应该落在同一个桶。\n\n如果不对 `t` 进行 `+1` 操作的话,那么 `[0,1,2]` 和 `[3]` 会被落到不同的桶中,那么为了解决这种错误,我们需要对 `t` 进行 `+1` 作为 `size` 。\n\n这样我们的数轴就能被分割成:\n\n`0 1 2 3 | 4 5 6 7 | 8 9 10 11 | 12 13 14 15 | ...`\n\n**总结一下,令 `size = t + 1` 的本质是因为差值为 `t` 两个数在数轴上相隔距离为 `t + 1`,它们需要被落到同一个桶中。**\n\n**当明确了 `size` 的大小之后,对于正数部分我们则有 `idx = nums[i] / size`。**\n\n2. 如何理解负数部分的逻辑?\n\n由于我们处理正数的时候,处理了数值 `0`,因此我们负数部分是从 `-1` 开始的。\n\n还是我们上述 🌰,此时我们有 `t = 3` 和 `size = t + 1 = 4`。\n\n考虑 `[-4,-3,-2,-1]` 的情况,它们应该落在一个桶中。\n\n如果直接复用 `idx = nums[i] / size` 的话,`[-4]` 和 `[-3,-2,-1]` 会被分到不同的桶中。\n\n**根本原因是我们处理整数的时候,已经分掉了数值 `0`。**\n\n**这时候我们需要先对 `nums[i]` 进行 `+1` 操作(即将负数部分在数轴上进行整体右移),即得到 `(nums[i] + 1) / size`。**\n\n**这样一来负数部分与正数部分一样,可以被正常分割了。**\n\n**但由于 0 号桶已经被使用了,我们还需要在此基础上进行 `-1`,相当于将负数部分的桶下标(`idx`)往左移,即得到 `((nums[i] + 1) / size) - 1`。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.220` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2121-2130/2127. 参加会议的最多员工数（困难）.md", "url_title": "2127. 参加会议的最多员工数", "url": "https://leetcode.cn/problems/maximum-employees-to-be-invited-to-a-meeting/solutions/2507559/gong-shui-san-xie-sha-shi-nei-xiang-wai-4ig79/", "difficulty": "困难", "tags": ["基环森林", "内向基环树", "拓扑排序", "图"], "question": "一个公司准备组织一场会议,邀请名单上有 `n` 位员工。\n\n公司准备了一张圆形的桌子,可以坐下任意数目的员工。\n\n员工编号为 $0$ 到 $n - 1$。每位员工都有一位喜欢的员工,每位员工当且仅当他被安排在喜欢员工的旁边,他才会参加会议,每位员工喜欢的员工不会是他自己。\n\n给你一个下标从 $0$ 开始的整数数组 `favorite`,其中 $favorite[i]$ 表示第 $i$ 位员工喜欢的员工。请你返回参加会议的最多员工数目。\n\n示例 1:\n\n```\n输入:favorite = [2,2,1,2]\n\n输出:3\n\n解释:\n上图展示了公司邀请员工 0,1 和 2 参加会议以及他们在圆桌上的座位。\n没办法邀请所有员工参与会议,因为员工 2 没办法同时坐在 0,1 和 3 员工的旁边。\n注意,公司也可以邀请员工 1,2 和 3 参加会议。\n所以最多参加会议的员工数目为 3 。\n```\n示例 2:\n```\n输入:favorite = [1,2,0]\n\n输出:3\n\n解释:\n每个员工都至少是另一个员工喜欢的员工。所以公司邀请他们所有人参加会议的前提是所有人都参加了会议。\n座位安排同图 1 所示:\n- 员工 0 坐在员工 2 和 1 之间。\n- 员工 1 坐在员工 0 和 2 之间。\n- 员工 2 坐在员工 1 和 0 之间。\n参与会议的最多员工数目为 3 。\n```\n示例 3:\n\n```\n输入:favorite = [3,0,1,4,1]\n\n输出:4\n\n解释:\n上图展示了公司可以邀请员工 0,1,3 和 4 参加会议以及他们在圆桌上的座位。\n员工 2 无法参加,因为他喜欢的员工 0 旁边的座位已经被占领了。\n所以公司只能不邀请员工 2 。\n参加会议的最多员工数目为 4 。\n```\n\n提示:\n* $n = favorite.length$\n* $2 <= n <= 10^5$\n* $0 <= favorite[i] <= n - 1$\n* $favorite[i] != i$", "solution": "### 内向基环森林 + 拓扑排序\n\n根据题意,圆形桌上 $x$ 左右两边只要有一位是 $x$ 所喜欢即可。\n\n我们可从 $i$ 向 $favorite[i]$ 添加有向边,从而得到一张包含多个「内向基环树」的图。\n\n内向基环树,是指其满足基环树定义,且内向 ~~bushi~~。\n\n基环树是指其具有 $n$ 个点 $n$ 条边的联通块,而「内向」是指树中任意节点有且只有一条出边,对应的「外向」是指树中任意节点有且只有一条入边。\n\n例如,左图内向,右图外向:\n\n根据题意,**圆桌最多放置一个长度大于 $2$ 的环(内向环,只有一条出边,即只有一个喜欢的人,安插其他非环成员,会破坏留下参加会议的必要条件),但可放置多个长度为 $2$ 的环,且多个环可延伸出最长链(利用左右两侧只需有一个喜欢的人即满足)。**\n\n在「取长度大于 $2$ 的最大环」及「多个长度为 $2$ 的环及其最长链之和」两者中取最大长度即是答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maximumInvitations(int[] favorite) {\n        int n = favorite.length;\n        // in 统计每个节点的入度情况, max 统计节最长链\n        int[] in = new int[n], max = new int[n];\n        for (int x : favorite) in[x]++;\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            if (in[i] == 0) d.addLast(i);\n        }\n        // 拓扑排序: 求基环外的最长链\n        while (!d.isEmpty()) {\n            int cur = d.pollFirst(), ne = favorite[cur];\n            max[ne] = Math.max(max[ne], max[cur] + 1);\n            if (--in[ne] == 0) d.addLast(ne);\n        }\n        // 圆桌最多放置一个大于 2 的环(ans1 统计最大值)\n        // 圆桌可放置多个等于 2 的环(ans2 累加该长度)\n        int ans1 = 0, ans2 = 0;\n        for (int i = 0; i < n; i++) {\n            if (in[i] == 0) continue;\n            int j = favorite[i], cur = 1;\n            while (j != i) {\n                // 一个环只需被处理一次, 这里将环中其他节点入度置 0, 下次遍历到这些点就会被跳过\n                in[j] = 0;\n                j = favorite[j];\n                cur++;\n            }\n            if (cur == 2) ans2 += 2 + max[i] + max[favorite[i]];\n            else ans1 = Math.max(ans1, cur);\n        }\n        return Math.max(ans1, ans2);\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def maximumInvitations(self, favorite: List[int]) -> int:\n        n = len(favorite)\n        # in_degree 统计每个节点的入度情况, max_length 统计节最长链\n        in_degree, max_length = [0] * n, [0] * n\n        for x in favorite:\n            in_degree[x] += 1\n        d = deque()\n        for i in range(n):\n            if in_degree[i] == 0:\n                d.append(i)\n       # 拓扑排序: 求基环外的最长链\n        while d:\n            cur = d.popleft()\n            ne = favorite[cur]\n            max_length[ne] = max(max_length[ne], max_length[cur] + 1)\n            in_degree[ne] -= 1\n            if in_degree[ne] == 0:\n                d.append(ne)\n        # 圆桌最多放置一个大于 2 的环(ans1 统计最大值)\n        # 圆桌可放置多个等于 2 的环(ans2 累加该长度)\n        ans1, ans2 = 0, 0\n        for i in range(n):\n            if in_degree[i] == 0:\n                continue\n            j, cur = favorite[i], 1\n            while j != i:\n                # 一个环只需被处理一次, 这里将环中其他节点入度置 0, 下次遍历到这些点就会被跳过\n                in_degree[j] = 0\n                j = favorite[j]\n                cur += 1\n            if cur == 2:\n                ans2 += 2 + max_length[i] + max_length[favorite[i]]\n            else:\n                ans1 = max(ans1, cur)\n        return max(ans1, ans2)\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maximumInvitations(vector<int>& favorite) {\n        int n = favorite.size();\n        // in 统计每个节点的入度情况, max_length 统计节最长链\n        vector<int> in(n, 0);\n        vector<int> max_length(n, 0);\n        for (int x : favorite) in[x]++;\n        deque<int> d;\n        for (int i = 0; i < n; i++) {\n            if (in[i] == 0) d.push_back(i);\n        }\n        // 拓扑排序: 求基环外的最长链\n        while (!d.empty()) {\n            int cur = d.front();\n            d.pop_front();\n            int ne = favorite[cur];\n            max_length[ne] = max(max_length[ne], max_length[cur] + 1);\n            if (--in[ne] == 0) d.push_back(ne);\n        }\n        // 圆桌最多放置一个大于 2 的环(ans1 统计最大值)\n        // 圆桌可放置多个等于 2 的环(ans2 累加该长度)\n        int ans1 = 0, ans2 = 0;\n        for (int i = 0; i < n; i++) {\n            if (in[i] == 0) continue;\n            int j = favorite[i], cur = 1;\n            while (j != i) {\n                // 一个环只需被处理一次, 这里将环中其他节点入度置 0, 下次遍历到这些点就会被跳过\n                in[j] = 0;\n                j = favorite[j];\n                cur++;\n            }\n            if (cur == 2) ans2 += 2 + max_length[i] + max_length[favorite[i]];    \n            else ans1 = max(ans1, cur);\n        }\n        return max(ans1, ans2);\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nfunction maximumInvitations(favorite: number[]): number {\n    const n = favorite.length;\n    // in_degree 统计每个节点的入度情况, max_length 统计节最长链\n    const in_degree = Array(n).fill(0), max_length = Array(n).fill(0);\n    for (const x of favorite) in_degree[x]++;\n    const d = [];\n    for (let i = 0; i < n; i++) {\n        if (in_degree[i] === 0) d.push(i);\n    }\n    // 拓扑排序: 求基环外的最长链\n    while (d.length > 0) {\n        const cur = d.shift() as number;\n        const ne = favorite[cur];\n        max_length[ne] = Math.max(max_length[ne], max_length[cur] + 1);\n        if (--in_degree[ne] === 0) d.push(ne);\n    }\n    // 圆桌最多放置一个大于 2 的环(ans1 统计最大值)\n    // 圆桌可放置多个等于 2 的环(ans2 累加该长度)\n    let ans1 = 0, ans2 = 0;\n    for (let i = 0; i < n; i++) {\n        if (in_degree[i] === 0) continue;\n        let j = favorite[i], cur = 1;\n        while (j !== i) {\n            // 一个环只需被处理一次, 这里将环中其他节点入度置 0, 下次遍历到这些点就会被跳过\n            in_degree[j] = 0;\n            j = favorite[j];\n            cur++;\n        }\n        if (cur == 2) ans2 += 2 + max_length[i] + max_length[favorite[i]];    \n        else ans1 = Math.max(ans1, cur);\n    }\n    return Math.max(ans1, ans2);\n};\n```\n* 时间复杂度:统计入度的复杂度为 $O(n)$;拓扑排序求最长链复杂度为 $O(n)$;计算答案过程中,每个点最多被访问两次(环内节点),复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2217` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2161-2170/2170. 使数组变成交替数组的最少操作数（中等）.md", "url_title": "2170. 使数组变成交替数组的最少操作数", "url": "https://leetcode-cn.com/problems/minimum-operations-to-make-the-array-alternating/solution/gong-shui-san-xie-jian-dan-ji-shu-lei-ta-0eo4/", "difficulty": "中等", "tags": ["贪心"], "question": "给你一个下标从 $0$ 开始的数组 $nums$ ,该数组由 $n$ 个正整数组成。\n\n如果满足下述条件,则数组 $nums$ 是一个 交替数组 :\n\n* $nums[i - 2] == nums[i]$ ,其中 $2 <= i <= n - 1$ 。\n* $nums[i - 1] != nums[i]$ ,其中 $1 <= i <= n - 1$ 。\n\n在一步 操作 中,你可以选择下标 $i$ 并将 $nums[i]$ 更改 为 任一 正整数。\n\n返回使数组变成交替数组的 最少操作数 。\n\n示例 1:\n```\n输入:nums = [3,1,3,2,4,3]\n\n输出:3\n\n解释:\n使数组变成交替数组的方法之一是将该数组转换为 [3,1,3,1,3,1] 。\n在这种情况下,操作数为 3 。\n可以证明,操作数少于 3 的情况下,无法使数组变成交替数组。\n```\n示例 2:\n```\n输入:nums = [1,2,2,2,2]\n\n输出:2\n\n解释:\n使数组变成交替数组的方法之一是将该数组转换为 [1,2,1,2,1].\n在这种情况下,操作数为 2 。\n注意,数组不能转换成 [2,2,2,2,2] 。因为在这种情况下,nums[0] == nums[1],不满足交替数组的条件。\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $1 <= nums[i] <= 10^5$", "solution": "### 贪心\n\n根据「交替数组」的定义,我们可以将数组根据下标奇偶性分成两个序列,最终目的是:**使用最少的修改次数,使得「两个序列均成为公差为 $0$ 等差数列」,同时「两序列的首项不相等」。**\n\n要用最少次数将一个序列修改为公差为 $0$ 等差数列,等价于修改最少的数字,等价于保留最多的数字,容易想到将序列中的其他「非众数」修改为「众数」(若有多个众数,取任一)。\n\n而单纯对两个序列执行上述逻辑,并不能确保最终得到的是「交替数组」,即未必满足「两序列的首项不相等」的要求。\n\n因此我们可以对 $nums$ 进行扫描,分别统计「偶数下标序列」和「奇数下标序列」的最大值(众数)和次大值(**注意是非严格的次大值,即为「其他众数」或者「出现次数比众数小的数」**),使用 `a` 和 `b` 代指「偶数下标序列」的最大值和次大值,使用 `c` 和 `d` 代指「奇数下标序列」的最大值和次大值。同时使用 `m1` 和 `m2` 分别统计「偶数下标序列」和「奇数下标序列」中某个数的出现次数。\n\n根据两序列的最大值是否冲突进行分情况讨论:\n\n* 若两序列的最大值不冲突($a\\neq c$):那么两序列都可以取得最小修改次数(保留最大值),整体的最小修改次数为 $n - m1[a] - m2[c]$ ;\n* 若两序列的最大值冲突($a\\ = c$):那么仅一序列可以取得最小修改次数(保留最大值),另一序列只能取得“次小”的修改次数(保留次大值),此时整体的最小修改次数为 $n - \\max(m1[a] + m2[d], m1[b] + m2[c])$。\n\n代码:\n```Java\nclass Solution {\n    static int N = 100010;\n    static int[] m1 = new int[N], m2 = new int[N];\n    public int minimumOperations(int[] nums) {\n        int n = nums.length;\n        Arrays.fill(m1, 0);\n        Arrays.fill(m2, 0);\n        int a = 0, b = 0, c = 0, d = 0;\n        for (int i = 0; i < n; i++) {\n            int t = nums[i];\n            if (i % 2 == 0) {\n                m1[t]++;\n                if (a == 0 || m1[t] > m1[a]) {\n                    b = a; a = t;\n                } else if (t != a && (b == 0 || m1[t] > m1[b])) {\n                    b = t;\n                }\n            } else {\n                m2[t]++;\n                if (c == 0 || m2[t] > m2[c]) {\n                    d = c; c = t;\n                } else if (t != c && (d == 0 || m2[t] > m2[d])) {\n                    d = t;\n                }\n            }\n        }\n        if (a != c) return n - m1[a] - m2[c];\n        else return n - Math.max(m1[a] + m2[d], m1[b] + m2[c]);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2170` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/221-230/223. 矩形面积（中等）.md", "url_title": "223. 矩形面积", "url": "https://leetcode-cn.com/problems/rectangle-area/solution/gong-shui-san-xie-yun-yong-rong-chi-yuan-hzit/", "difficulty": "中等", "tags": ["容斥原理"], "question": "给你 **二维** 平面上两个 **由直线构成的** 矩形,请你计算并返回两个矩形覆盖的总面积。\n\n每个矩形由其 左下 顶点和 右上 顶点坐标表示:\n\n* 第一个矩形由其左下顶点 (ax1, ay1) 和右上顶点 (ax2, ay2) 定义。\n* 第二个矩形由其左下顶点 (bx1, by1) 和右上顶点 (bx2, by2) 定义。\n\n示例 1:\n\n```\n输入:ax1 = -3, ay1 = 0, ax2 = 3, ay2 = 4, bx1 = 0, by1 = -1, bx2 = 9, by2 = 2\n\n输出:45\n```\n示例 2:\n```\n输入:ax1 = -2, ay1 = -2, ax2 = 2, ay2 = 2, bx1 = -2, by1 = -2, bx2 = 2, by2 = 2\n\n输出:16\n```\n\n提示:\n* -$10^4 <= ax1, ay1, ax2, ay2, bx1, by1, bx2, by2 <= 10^4$", "solution": "### 容斥原理\n\n首先在给定左下顶点和右上顶点的情况下,计算矩形面积为 $(x2 - x1) * (y2 - y1)$。\n\n因此,起始时我们可以先直接算得给定的两个矩形的面积 $A$ 和 $B$,并进行累加。\n\n剩下的,我们需要求得两矩形的交集面积,利用「容斥原理」,减去交集面积,即是答案。\n\n**求交集矩形面积,可以转换为求两矩形在坐标轴上的重合长度,若两矩形在 $X$ 轴上的重合长度为 $x$,在 $Y$ 轴上的重合长度为 $y$,则有重合面积为 $C = x * y$。同时考虑两矩形在任一坐标轴上没有重合长度,则不存在重合面积,因此需要将重合长度与 $0$ 取 $\\max$。**\n\n最终答案为 $A + B - C$ 。\n\n代码;\n```Java\nclass Solution {\n    public int computeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {\n        int x = Math.max(0, Math.min(ax2, bx2) - Math.max(ax1, bx1));\n        int y = Math.max(0, Math.min(ay2, by2) - Math.max(ay1, by1));\n        return (ax2 - ax1) * (ay2 - ay1) + (bx2 - bx1) * (by2 - by1) - (x * y);\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.223` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/221-230/224. 基本计算器（困难）.md", "url_title": "224. 基本计算器", "url": "https://leetcode-cn.com/problems/basic-calculator/solution/shuang-zhan-jie-jue-tong-yong-biao-da-sh-olym/", "difficulty": "困难", "tags": ["表达式计算", "栈"], "question": "给你一个字符串表达式 `s` ,请你实现一个基本计算器来计算并返回它的值。\n\n示例 1:\n```\n输入:s = \"1 + 1\"\n\n输出:2\n```\n示例 2:\n```\n输入:s = \" 2-1 + 2 \"\n\n输出:3\n```\n示例 3:\n```\n输入:s = \"(1+(4+5+2)-3)+(6+8)\"\n\n输出:23\n```\n\n提示:\n* $1 <= s.length <= 3 \\times 10^5$\n* `s` 由`数字`、`'+'`、`'-'`、`'('`、`')'`、和 `' '` 组成\n* `s` 表示一个有效的表达式", "solution": "### 双栈解法\n\n我们可以使用两个栈 `nums` 和 `ops` 。\n* `nums` : 存放所有的数字\n* `ops` :存放所有的数字以外的操作,`+/-` 也看做是一种操作\n\n然后从前往后做,对遍历到的字符做分情况讨论:\n* 空格 : 跳过\n* `(` : 直接加入 `ops` 中,等待与之匹配的 `)`\n* `)` : 使用现有的 `nums` 和 `ops` 进行计算,直到遇到左边最近的一个左括号为止,计算结果放到 `nums`\n* 数字 : 从当前位置开始继续往后取,将整一个连续数字整体取出,加入 `nums`\n* `+/-` : 需要将操作放入 `ops` 中。**在放入之前先把栈内可以算的都算掉**,使用现有的 `nums` 和 `ops` 进行计算,直到没有操作或者遇到左括号,计算结果放到 `nums`\n\n一些细节:\n\n* 由于第一个数可能是负数,为了减少边界判断。一个小技巧是先往 `nums` 添加一个 0\n* 为防止 () 内出现的首个字符为运算符,将所有的空格去掉,并将 `(-` 替换为 `(0-`,`(+` 替换为 `(0+`(当然也可以不进行这样的预处理,将这个处理逻辑放到循环里去做)\n\nJava 代码:\n```Java\nclass Solution {\n    public int calculate(String s) {\n        // 存放所有的数字\n        Deque<Integer> nums = new ArrayDeque<>();\n        // 为了防止第一个数为负数,先往 nums 加个 0\n        nums.addLast(0);\n        // 将所有的空格去掉\n        s = s.replaceAll(\" \", \"\");\n        // 存放所有的操作,包括 +/-\n        Deque<Character> ops = new ArrayDeque<>();\n        int n = s.length();\n        char[] cs = s.toCharArray();\n        for (int i = 0; i < n; i++) {\n            char c = cs[i];\n            if (c == '(') {\n                ops.addLast(c);\n            } else if (c == ')') {\n                // 计算到最近一个左括号为止\n                while (!ops.isEmpty()) {\n                    char op = ops.peekLast();\n                    if (op != '(') {\n                        calc(nums, ops);\n                    } else {\n                        ops.pollLast();\n                        break;\n                    }\n                }\n            } else {\n                if (isNum(c)) {\n                    int u = 0, j = i;\n                    // 将从 i 位置开始后面的连续数字整体取出,加入 nums\n                    while (j < n && isNum(cs[j])) u = u * 10 + (int)(cs[j++] - '0');\n                    nums.addLast(u);\n                    i = j - 1;\n                } else {\n                    if (i > 0 && (cs[i - 1] == '(' || cs[i - 1] == '+' || cs[i - 1] == '-')) {\n                        nums.addLast(0);\n                    }\n                    // 有一个新操作要入栈时,先把栈内可以算的都算了\n                    while (!ops.isEmpty() && ops.peekLast() != '(') calc(nums, ops);\n                    ops.addLast(c);\n                }\n            }\n        }\n        while (!ops.isEmpty()) calc(nums, ops);\n        return nums.peekLast();\n    }\n    void calc(Deque<Integer> nums, Deque<Character> ops) {\n        if (nums.isEmpty() || nums.size() < 2) return;\n        if (ops.isEmpty()) return;\n        int b = nums.pollLast(), a = nums.pollLast();\n        char op = ops.pollLast();\n        nums.addLast(op == '+' ? a + b : a - b);\n    }\n    boolean isNum(char c) {\n        return Character.isDigit(c);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    void replace(string& s){\n        int pos = s.find(\" \");\n        while (pos != -1) {\n            s.replace(pos, 1, \"\");\n            pos = s.find(\" \");\n        }\n    }\n    int calculate(string s) {\n        // 存放所有的数字\n        stack<int> nums;\n        // 为了防止第一个数为负数,先往 nums 加个 0\n        nums.push(0);\n        // 将所有的空格去掉\n        replace(s);\n        // 存放所有的操作,包括 +/-\n        stack<char> ops;\n        int n = s.size();\n        for(int i = 0; i < n; i++) {\n            char c = s[i];\n            if(c == '(')\n                ops.push(c);\n            else if(c == ')') {\n                // 计算到最近一个左括号为止\n                while(!ops.empty()) {\n                    char op = ops.top();\n                    if(op != '(')\n                        calc(nums, ops);\n                    else {\n                        ops.pop();\n                        break;\n                    }\n                }\n            }\n            else {\n                if(isdigit(c)) {\n                    int cur_num = 0, j = i;\n                    // 将从 i 位置开始后面的连续数字整体取出,加入 nums\n                    while(j <n && isdigit(s[j]))\n                        cur_num = cur_num*10 + (s[j++] - '0');\n                    // 注意上面的计算一定要有括号,否则有可能会溢出\n                    nums.push(cur_num);\n                    i = j - 1;\n                }\n                else {\n                    if (i > 0 && (s[i - 1] == '(' || s[i - 1] == '+' || s[i - 1] == '-')) {\n                        nums.push(0);\n                    }\n                    // 有一个新操作要入栈时,先把栈内可以算的都算了\n                    while(!ops.empty() && ops.top() != '(')\n                        calc(nums, ops);\n                    ops.push(c);\n                }\n            }\n        }\n        while(!ops.empty())\n            calc(nums, ops);\n        return nums.top();\n    }\n    void calc(stack<int> &nums, stack<char> &ops) {\n        if(nums.size() < 2 || ops.empty())\n            return;\n        int b = nums.top(); nums.pop();\n        int a = nums.top(); nums.pop();\n        char op = ops.top(); ops.pop();\n        nums.push(op == '+' ? a+b : a-b);\n    }\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 进阶\n\n1. 如果在此基础上,再考虑 `*` 和 `/`,需要增加什么考虑?如何维护运算符的优先级?\n2. 在 $1$ 的基础上,如果考虑支持自定义符号,例如 `a / func(a, b) * (c + d)`,需要做出什么调整?\n\n---\n\n### 补充\n\n1. 对应进阶 1 的补充。\n\n一个支持 `+ - * / ^ %` 的「计算器」,基本逻辑是一样的,使用字典维护一个符号优先级:\n\n```Java\nclass Solution {\n    Map<Character, Integer> map = new HashMap<>(){{\n        put('-', 1);\n        put('+', 1);\n        put('*', 2);\n        put('/', 2);\n        put('%', 2);\n        put('^', 3);\n    }};\n    public int calculate(String s) {\n        s = s.replaceAll(\" \", \"\");\n        char[] cs = s.toCharArray();\n        int n = s.length();\n        Deque<Integer> nums = new ArrayDeque<>();\n        nums.addLast(0);\n        Deque<Character> ops = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            char c = cs[i];\n            if (c == '(') {\n                ops.addLast(c);\n            } else if (c == ')') {\n                while (!ops.isEmpty()) {\n                    if (ops.peekLast() != '(') {\n                        calc(nums, ops);\n                    } else {\n                        ops.pollLast();\n                        break;\n                    }\n                }\n            } else {\n                if (isNumber(c)) {\n                    int u = 0;\n                    int j = i;\n                    while (j < n && isNumber(cs[j])) u = u * 10 + (cs[j++] - '0');\n                    nums.addLast(u);\n                    i = j - 1;\n                } else {\n                    if (i > 0 && (cs[i - 1] == '(' || cs[i - 1] == '+' || cs[i - 1] == '-')) {\n                        nums.addLast(0);\n                    }\n                    while (!ops.isEmpty() && ops.peekLast() != '(') {\n                        char prev = ops.peekLast();\n                        if (map.get(prev) >= map.get(c)) {\n                            calc(nums, ops);\n                        } else {\n                            break;\n                        }\n                    }\n                    ops.addLast(c);\n                }\n            }\n        }\n        while (!ops.isEmpty() && ops.peekLast() != '(') calc(nums, ops);\n        return nums.peekLast();\n    }\n    void calc(Deque<Integer> nums, Deque<Character> ops) {\n        if (nums.isEmpty() || nums.size() < 2) return;\n        if (ops.isEmpty()) return;\n        int b = nums.pollLast(), a = nums.pollLast();\n        char op = ops.pollLast();\n        int ans = 0;\n        if (op == '+') {\n            ans = a + b;\n        } else if (op == '-') {\n            ans = a - b;\n        } else if (op == '*') {\n            ans = a * b;\n        } else if (op == '/') {\n            ans = a / b;\n        } else if (op == '^') {\n            ans = (int)Math.pow(a, b);\n        } else if (op == '%') {\n            ans = a % b;\n        }\n        nums.addLast(ans);\n    }\n    boolean isNumber(char c) {\n        return Character.isDigit(c);\n    }\n}\n```\n\n2. 关于进阶 $2$,其实和进阶 $1$ 一样,重点在于维护优先级。但还有一些编码细节:\n\n对于非单个字符的运算符(例如 函数名`function`),可以在处理前先将所有非单字符的运算符进行替换(将 `function` 替换为 `@#` 等)\n\n然后对特殊运算符做特判,确保遍历过程中识别到特殊运算符之后,往后整体读入(如 `function(a,b)` -> `@(a, b)`,`@(a, b)` 作为整体处理)", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.224` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/221-230/227. 基本计算器 II（中等）.md", "url_title": "227. 基本计算器 II", "url": "https://leetcode-cn.com/problems/basic-calculator-ii/solution/shi-yong-shuang-zhan-jie-jue-jiu-ji-biao-c65k/", "difficulty": "中等", "tags": ["表达式计算"], "question": "给你一个字符串表达式 `s` ,请你实现一个基本计算器来计算并返回它的值。\n\n整数除法仅保留整数部分。\n\n示例 1:\n```\n输入:s = \"3+2*2\"\n\n输出:7\n```\n示例 2:\n```\n输入:s = \" 3/2 \"\n\n输出:1\n```\n示例 3:\n```\n输入:s = \" 3+5 / 2 \"\n\n输出:5\n```\n\n提示:\n* $1 <= s.length <= 3 \\times 10^5$\n* `s` 由整数和算符 (`'+'`, `'-'`, `'*'`, `'/'`) 组成,中间由一些空格隔开\n* `s` 表示一个 有效表达式\n* 表达式中的所有整数都是非负整数,且在范围 $[0, 2^{31} - 1]$ 内\n* 题目数据保证答案是一个 `32-bit` 整数", "solution": "### 双栈\n\n如果你有看这篇 [224. 基本计算器](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492602&idx=1&sn=135fd5b530189f13e0395414a6b47893) 的话,今天这道题就是道练习题。\n\n帮你巩固 **双栈解决「通用表达式」问题的通用解法** 。\n\n**事实上,我提供这套解决方案不仅仅能解决只有 `+ - ( )`的 [[224. 基本计算器]](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492602&idx=1&sn=135fd5b530189f13e0395414a6b47893) 或者 `+ - * /` [227. 基本计算器 II(本题)] 的表达式问题,还能解决 `+ - * / ^ % ( )` 的完全表达式问题。**\n\n甚至支持自定义运算符,只要在运算优先级上进行维护即可。\n\n**对于「表达式计算」这一类问题,你都可以使用这套思路进行解决。我十分建议你加强理解这套处理逻辑。**\n\n对于「任何表达式」而言,我们都使用两个栈 `nums` 和 `ops`:\n* `nums` : 存放所有的数字\n* `ops` :存放所有的数字以外的操作\n\n然后从前往后做,对遍历到的字符做分情况讨论:\n* 空格 : 跳过\n* `(` : 直接加入 `ops` 中,等待与之匹配的 `)`\n* `)` : 使用现有的 `nums` 和 `ops` 进行计算,直到遇到左边最近的一个左括号为止,计算结果放到 `nums`\n* 数字 : 从当前位置开始继续往后取,将整一个连续数字整体取出,加入 `nums`\n* `+ - * / ^ %` : 需要将操作放入 `ops` 中。**在放入之前先把栈内可以算的都算掉(只有「栈内运算符」比「当前运算符」优先级高/同等,才进行运算)**,使用现有的 `nums` 和 `ops` 进行计算,直到没有操作或者遇到左括号,计算结果放到 `nums`\n\n我们可以通过 🌰 来理解 **只有「栈内运算符」比「当前运算符」优先级高/同等,才进行运算** 是什么意思:\n\n因为我们是从前往后做的,假设我们当前已经扫描到 `2 + 1` 了(此时栈内的操作为 `+` )。\n\n1. 如果后面出现的 `+ 2` 或者 `- 1` 的话,满足「栈内运算符」比「当前运算符」优先级高/同等,可以将 `2 + 1` 算掉,把结果放到 `nums` 中;\n2. 如果后面出现的是 `* 2` 或者 `/ 1` 的话,不满足「栈内运算符」比「当前运算符」优先级高/同等,这时候不能计算 `2 + 1`。\n\n一些细节:\n\n* 由于第一个数可能是负数,为了减少边界判断。一个小技巧是先往 `nums` 添加一个 0\n* 为防止 () 内出现的首个字符为运算符,将所有的空格去掉,并将 `(-` 替换为 `(0-`,`(+` 替换为 `(0+`(当然也可以不进行这样的预处理,将这个处理逻辑放到循环里去做)\n* 从理论上分析,`nums` 最好存放的是 `long`,而不是 `int`。因为可能存在 `大数 + 大数 + 大数 + ... - 大数 - 大数` 的表达式导致中间结果溢出,最终答案不溢出的情况\n\n代码:\n\n```Java\nclass Solution {\n    // 使用 map 维护一个运算符优先级\n    // 这里的优先级划分按照「数学」进行划分即可\n    Map<Character, Integer> map = new HashMap<>(){{\n        put('-', 1);\n        put('+', 1);\n        put('*', 2);\n        put('/', 2);\n        put('%', 2);\n        put('^', 3);\n    }};\n    public int calculate(String s) {\n        // 将所有的空格去掉\n        s = s.replaceAll(\" \", \"\");\n        char[] cs = s.toCharArray();\n        int n = s.length();\n        // 存放所有的数字\n        Deque<Integer> nums = new ArrayDeque<>();\n        // 为了防止第一个数为负数,先往 nums 加个 0\n        nums.addLast(0);\n        // 存放所有「非数字以外」的操作\n        Deque<Character> ops = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            char c = cs[i];\n            if (c == '(') {\n                ops.addLast(c);\n            } else if (c == ')') {\n                // 计算到最近一个左括号为止\n                while (!ops.isEmpty()) {\n                    if (ops.peekLast() != '(') {\n                        calc(nums, ops);\n                    } else {\n                        ops.pollLast();\n                        break;\n                    }\n                }\n            } else {\n                if (isNumber(c)) {\n                    int u = 0;\n                    int j = i;\n                    // 将从 i 位置开始后面的连续数字整体取出,加入 nums\n                    while (j < n && isNumber(cs[j])) u = u * 10 + (cs[j++] - '0');\n                    nums.addLast(u);\n                    i = j - 1;\n                } else {\n                    if (i > 0 && (cs[i - 1] == '(' || cs[i - 1] == '+' || cs[i - 1] == '-')) {\n                        nums.addLast(0);\n                    }\n                    // 有一个新操作要入栈时,先把栈内可以算的都算了 \n                    // 只有满足「栈内运算符」比「当前运算符」优先级高/同等,才进行运算\n                    while (!ops.isEmpty() && ops.peekLast() != '(') {\n                        char prev = ops.peekLast();\n                        if (map.get(prev) >= map.get(c)) {\n                            calc(nums, ops);\n                        } else {\n                            break;\n                        }\n                    }\n                    ops.addLast(c);\n                }\n            }\n        }\n        // 将剩余的计算完\n        while (!ops.isEmpty()) calc(nums, ops);\n        return nums.peekLast();\n    }\n    void calc(Deque<Integer> nums, Deque<Character> ops) {\n        if (nums.isEmpty() || nums.size() < 2) return;\n        if (ops.isEmpty()) return;\n        int b = nums.pollLast(), a = nums.pollLast();\n        char op = ops.pollLast();\n        int ans = 0;\n        if (op == '+') ans = a + b;\n        else if (op == '-') ans = a - b;\n        else if (op == '*') ans = a * b;\n        else if (op == '/')  ans = a / b;\n        else if (op == '^') ans = (int)Math.pow(a, b);\n        else if (op == '%') ans = a % b;\n        nums.addLast(ans);\n    }\n    boolean isNumber(char c) {\n        return Character.isDigit(c);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 总结\n\n还记得我在 [题解](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492602&idx=1&sn=135fd5b530189f13e0395414a6b47893) 留的「进阶」内容?\n\n1. 如果 `+ -` 基础上,再考虑 `*` 和 `/`,需要增加什么考虑?如何维护运算符的优先级?\n\n这个进阶问题就对应了 LeetCode 上的两道题:\n\n* [227. 基本计算器 II](https://leetcode-cn.com/problems/basic-calculator-ii/) :本题,包含符号 `+ - * /`\n* [772. 基本计算器 III](https://leetcode-cn.com/problems/basic-calculator-iii/) :有锁题,包含符号 `+ - * / ( )`\n\n2. 在「问题1」的基础上,如果考虑支持自定义符号,例如 a / func(a, b) * (c + d),需要做出什么调整?\n\n这个进阶问题,在 LeetCode 上也有类似的题目:\n\n* [770. 基本计算器 IV](https://leetcode-cn.com/problems/basic-calculator-iv/) : 包含自定义函数符号\n\n**综上,使用三叶提供的这套「双栈通用解决方案」,可以解决所有的「表达式计算」问题。因为这套「表达式计算」处理逻辑,本质上模拟了人脑的处理逻辑:根据下一位的运算符优先级决定当前运算符是否可以马上计算。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.227` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/221-230/229. 求众数 II（中等）.md", "url_title": "229. 求众数 II", "url": "https://leetcode-cn.com/problems/majority-element-ii/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-ws0rj/", "difficulty": "中等", "tags": ["摩尔投票", "哈希表"], "question": "给定一个大小为 `n` 的整数数组,找出其中所有出现超过 `⌊ n/3 ⌋` 次的元素。\n\n 示例 1:\n```\n输入:[3,2,3]\n\n输出:[3]\n```\n示例 2:\n```\n输入:nums = [1]\n\n输出:[1]\n```\n示例 3:\n```\n输入:[1,1,1,3,3,2,2,2]\n\n输出:[1,2]\n```\n\n提示:\n* $1 <= nums.length <= 5 * 10^4$\n* $-10^9 <= nums[i] <= 10^9$\n\n进阶:尝试设计时间复杂度为 $O(n)$、空间复杂度为 $O(1)$ 的算法解决此问题。", "solution": "### 哈希表计数\n\n一个朴素的做法是使用「哈希表」进行计数,在计数完成后将所有出现次数超过 $n / 3$ 的元素加入答案。\n\n代码:\n```Java\nclass Solution {\n    public List<Integer> majorityElement(int[] nums) {\n        int n = nums.length;\n        Map<Integer, Integer> map = new HashMap<>();    \n        for (int i : nums) map.put(i, map.getOrDefault(i, 0) + 1);\n        List<Integer> ans = new ArrayList<>();\n        for (int i : map.keySet()) {\n            if (map.get(i) > n / 3) ans.add(i);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 摩尔投票\n\n在前置 🧀 [简单题学投票算法](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488987&idx=1&sn=6087b1909fea1d24f15353515eee8d93&chksm=fd9cbec4caeb37d235ccad8d59724177784036a60525fa5e7b738267e9a84a572b1545528391&token=1288276346&lang=zh_CN#rd) 中,我们使用「摩尔投票」在 $O(1)$ 空间复杂度内找到了出现次数超过一半的元素,即出现次数大于 $n / 2$ 的数。\n\n对于本题,我们需要统计出现次数超过 $n / 3$ 的数。\n\n**我们可以不失一般性的将其拓展为「统计出现次数超过 $n / k$ 的数」。**\n\n**可以证明,出现次数超过 $n / k$ 的数最多只有 $k - 1$ 个。否则必然违背「数总共只有 $n$ 个」或者「当前统计的是出现次数超过 $n / k$ 的数」的前提条件。**\n\n当明确了符合要求的数的数量之后,我们可以使用有限变量来代表这 $k - 1$ 个候选数及其出现次数。\n\n然后使用「摩尔投票」的标准做法,在建立数组时同时 `check` 这 $k - 1$ 个数,假设当前遍历到的元素为 $x$:\n\n* 如果 $x$ 本身是候选者的话,则对其出现次数加一;\n* 如果 $x$ 本身不是候选者,检查是否有候选者的出现次数为 $0$:\n    * 若有,则让 $x$ 代替其成为候选者,并记录出现次数为 $1$;\n    * 若无,则让所有候选者的出现次数减一。\n\n当处理完整个数组后,这 $k - 1$ 个数可能会被填满,但不一定都是符合出现次数超过 $n / k$ 要求的。\n\n需要进行二次遍历,来确定候选者是否符合要求,将符合要求的数加到答案。\n\n**上述做法正确性的关键是:若存在出现次数超过 $n / k$ 的数,最后必然会成为这 $k - 1$ 个候选者之一。**\n\n我们可以通过「反证法」来进行证明:若出现次数超过 $n / k$ 的数 $x$ 最终没有成为候选者。\n\n有两种可能会导致这个结果:\n\n1. 数值 $x$ 从来没成为过候选者:\n  \n   如果 $x$ 从来没成为过候选者,那么在遍历 $x$ 的过程中,必然有 $k - 1$ 个候选者被减了超过 $n / k$ 次,假设当前 $x$ 出现次数为 $C$,已知 $C > n / k$,此时总个数为\n   \n   $$\n    (k - 1) * C + C = C * k\n   $$\n\n    再根据 $C > n / k$,可知 $C * k > n$,而我们总共就只有 $n$ 个数,因此该情况恒不成立。\n\n2. 数值 $x$ 成为过候选者,但被逐出替换了:\n  \n    同理,被逐出替换,说明发生了对 $x$ 出现次数减一的动作(减到 $0$),每次的减一操作,意味着有其余的 $k - 2$ 个候选者的出现次数也发生了减一动作,加上本身被遍历到的当前数 $num[i]$,共有 $k - 1$ 个数字的和 $x$ 被一同统计。\n    因此,根据我们摩尔投票的处理过程,如果 $x$ 成为过候选者,并被逐出替换,那么同样能够推导出我们存在超过 $n$ 个数。\n\n综上,如果存在出现次数超过 $n / k$ 的数,其必然会成为 $k - 1$ 个候选者之一。\n\n代码:\n```Java\nclass Solution {\n    public List<Integer> majorityElement(int[] nums) {\n        int n = nums.length;\n        int a = 0, b = 0;\n        int c1 = 0, c2 = 0;\n        for (int i : nums) {\n            if (c1 != 0 && a == i) c1++;\n            else if (c2 != 0 && b == i) c2++;\n            else if (c1 == 0 && ++c1 >= 0) a = i;\n            else if (c2 == 0 && ++c2 >= 0) b = i;\n            else {\n                c1--; c2--;\n            }\n        }\n        c1 = 0; c2 = 0;\n        for (int i : nums) {\n            if (a == i) c1++;\n            else if (b == i) c2++;\n        }\n        List<Integer> ans = new ArrayList<>();\n        if (c1 > n / 3) ans.add(a);\n        if (c2 > n / 3) ans.add(b);\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.229` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/221-230/230. 二叉搜索树中第K小的元素（中等）.md", "url_title": "230. 二叉搜索树中第K小的元素", "url": "https://leetcode-cn.com/problems/kth-smallest-element-in-a-bst/solution/gong-shui-san-xie-yi-ti-san-jie-pai-xu-y-8uah/", "difficulty": "中等", "tags": ["二叉树", "中序遍历", "树的搜索"], "question": "给定一个二叉搜索树的根节点 `root`,和一个整数 `k` ,请你设计一个算法查找其中第 `k` 个最小元素(从 $1$ 开始计数)。\n\n示例 1:\n\n```\n输入:root = [3,1,4,null,2], k = 1\n\n输出:1\n```\n\n示例 2:\n\n```\n输入:root = [5,3,6,2,4,null,null,1], k = 3\n\n输出:3\n```\n\n提示:\n* 树中的节点数为 n 。\n* $1 <= k <= n <= 10^4$\n* $0 <= Node.val <= 10^4$", "solution": "### 树的遍历 + 排序\n\n朴素的做法是先对二叉树进行一次完整遍历,将所有节点存入列表中,最后对列表排序后返回目标值。\n\n树的遍历可以使用 `DFS` 或 `BFS`。\n\n代码:\n```Java\nclass Solution {\n    List<Integer> list = new ArrayList<>();\n    public int kthSmallest(TreeNode root, int k) {\n        dfs(root);\n        Collections.sort(list);\n        return list.get(k - 1);\n    }\n    void dfs(TreeNode root) {\n        if (root == null) return ;\n        list.add(root.val);\n        dfs(root.left);\n        dfs(root.right);\n    }\n}\n```\n* 时间复杂度:树的遍历时间复杂度为 $O(n)$;排序的复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 树的遍历 + 优先队列(堆)\n\n相比于先直接拿到所有节点再排序的解法一,另外一种做法是使用「优先队列(堆)」来做。\n\n由于我们返回的是第 $k$ 小的数,因此我们可以构建一个容量为 $k$ 的大根堆。\n\n根据大根堆的元素个数和当前节点与堆顶元素的关系来分情况讨论:\n\n* 大根堆元素不足 $k$ 个:直接将当前节点值放入大根堆;\n* 大根堆元素为 $k$ 个,根据堆顶元素和当前节点值的大小关系进一步分情况讨论:\n    * 如果当前节点值元素大于堆顶元素,说明当前节点值不可能在第 $k$ 小的范围内,直接丢弃;\n    * 如果当前节点值元素小于堆顶元素,说明当前节点值可能在第 $k$ 小的范围内,先 `poll` 一个再 `add` 进去。\n\n树的遍历可以使用 `DFS` 或 `BFS`。\n\n代码:\n```Java\nclass Solution {\n    public int kthSmallest(TreeNode root, int k) {\n        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);\n        Deque<TreeNode> d = new ArrayDeque<>();\n        d.addLast(root);\n        while (!d.isEmpty()) {\n            TreeNode node = d.pollFirst();\n            if (q.size() < k) {\n                q.add(node.val);\n            } else if (q.peek() > node.val) {\n                q.poll();\n                q.add(node.val);\n            }\n            if (node.left != null) d.addLast(node.left);\n            if (node.right != null) d.addLast(node.right);\n        }\n        return q.peek();\n    }\n}\n```\n* 时间复杂度:树的遍历时间复杂度为 $O(n)$;使用优先队列(堆)复杂度为 $O(n\\log{k})$。整体复杂度为 $O(n\\log{k})$\n* 空间复杂度:空间多少取决于 `d` 和 `q` 使用的容量,`q` 最多不超过 $k$ 个元素,复杂度为 $O(k)$,`d` 最多不超过二叉树的一层,复杂度为 $O(n)$。整体复杂度为 $O(n + k)$\n\n---\n\n### 中序遍历\n\n上述两种节点,都没有利用该树为二叉搜索树的特性。\n\n而我们知道,二叉搜索树的中序遍历是有序的,因此我们只需要对二叉搜索树执行中序遍历,并返回第 $k$ 小的值即可。\n\n不熟悉二叉树的中序遍历的同学,可以看看 [(题解)783. 二叉搜索树节点最小距离](https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/solution/gong-shui-san-xie-yi-ti-san-jie-shu-de-s-7r17/)。\n\n中序遍历有「迭代」和「递归」两种写法。\n\n代码:\n```Java\nclass Solution {\n    public int kthSmallest(TreeNode root, int k) {\n        Deque<TreeNode> d = new ArrayDeque<>();\n        while (root != null || !d.isEmpty()) {\n            while (root != null) {\n                d.addLast(root);\n                root = root.left;\n            }\n            root = d.pollLast();\n            if (--k == 0) return root.val;\n            root = root.right;\n        }\n        return -1; // never\n    }\n}\n```\n\n```Java\nclass Solution {\n    int k, ans;\n    public int kthSmallest(TreeNode root, int _k) {\n        k = _k;\n        dfs(root);\n        return ans;\n    }\n    void dfs(TreeNode root) {\n        if (root == null || k <= 0) return ;\n        dfs(root.left);\n        if (--k == 0) ans = root.val;\n        dfs(root.right);\n    }\n}\n```\n* 时间复杂度:由于存在对 $k$ 大小的剪枝,因此整个遍历顺序是从小到大进行遍历,搜索到目标值即结束。复杂度为 $O(k)$\n* 空间复杂度:令 $h$ 为树高,复杂度为 $O(h)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.230` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2211-2220/2213. 由单个字符重复的最长子字符串（困难）.md", "url_title": "2213. 由单个字符重复的最长子字符串", "url": "https://leetcode-cn.com/problems/longest-substring-of-one-repeating-character/solution/by-ac_oier-0lso/", "difficulty": "困难", "tags": ["区间求和", "线段树"], "question": "给你一个下标从 $0$ 开始的字符串 `s` 。另给你一个下标从 $0$ 开始、长度为 $k$ 的字符串 `queryCharacters`,一个下标从 $0$ 开始、长度也是 $k$ 的整数 下标 数组 `queryIndices`,这两个都用来描述 $k$ 个查询。\n\n第 $i$ 个查询会将 `s` 中位于下标 $queryIndices[i]$ 的字符更新为 $queryCharacters[i]$。\n\n返回一个长度为 $k$ 的数组 `lengths`,其中 $lengths[i]$ 是在执行第 $i$ 个查询之后 `s` 中仅由单个字符重复组成的 最长子字符串的长度 。\n\n示例 1:\n```\n输入:s = \"babacc\", queryCharacters = \"bcb\", queryIndices = [1,3,3]\n\n输出:[3,3,4]\n\n解释:\n- 第 1 次查询更新后 s = \"bbbacc\" 。由单个字符重复组成的最长子字符串是 \"bbb\" ,长度为 3 。\n- 第 2 次查询更新后 s = \"bbbccc\" 。由单个字符重复组成的最长子字符串是 \"bbb\" 或 \"ccc\",长度为 3 。\n- 第 3 次查询更新后 s = \"bbbbcc\" 。由单个字符重复组成的最长子字符串是 \"bbbb\" ,长度为 4 。\n因此,返回 [3,3,4] 。\n```\n示例 2:\n```\n输入:s = \"abyzz\", queryCharacters = \"aa\", queryIndices = [2,1]\n\n输出:[2,3]\n\n解释:\n- 第 1 次查询更新后 s = \"abazz\" 。由单个字符重复组成的最长子字符串是 \"zz\" ,长度为 2 。\n- 第 2 次查询更新后 s = \"aaazz\" 。由单个字符重复组成的最长子字符串是 \"aaa\" ,长度为 3 。\n因此,返回 [2,3] 。\n```\n\n提示:\n* $1 <= s.length <= 10^5$\n* `s` 由小写英文字母组成\n* $k == queryCharacters.length == queryIndices.length$\n* $1 <= k <= 10^5$\n* `queryCharacters` 由小写英文字母组成\n* $0 <= queryIndices[i] < s.length$", "solution": "### 线段树\n\n这是一道经典的线段树应用题。\n\n根据题意,涉及的操作 “似乎” 是「单点修改」和「区间查询」,那么根据 [(题解) 307. 区域和检索 - 数组可修改](https://leetcode-cn.com/problems/range-sum-query-mutable/solution/guan-yu-ge-lei-qu-jian-he-wen-ti-ru-he-x-41hv/) 的总结,我们应该使用的是「树状数组」吗?\n\n其实并不是(或者说不能直接是),原因在于我们查询的是「修改过后 `s` 中相同字符连续段的最大长度」,而当我们进行所谓的「单点修改」时,会导致原本的连续段被破坏,或者形成新的连续段。也就是此处的修改对于结果而言,并不是单点的。\n\n使用线段树求解,我们唯一需要考虑的是:在 `Node` 中维护些什么信息?\n\n对于线段树的节点信息设计,通常会包含基本的左右端点 `l`、`r` 以及查询目标值 `val` ,然后再考虑维护 `val` 还需要一些什么辅助信息。\n\n对于本题,我们还需要额外维护 `prefix` 和 `suffix`,分别代表「当前区间 $[l, r]$ 内前缀相同字符连续段的最大长度」和「当前区间 $[l, r]$ 内后缀相同字符连续段的最大长度」。\n\n然后考虑每次修改,如何使用子节点信息更新父节点(`pushup` 操作):\n\n* 对于一般性的合并(当前节点的两个子节点的衔接点不是相同字符)而言:\n\n\t* `tr[u].prefix = tr[u << 1].prefix`:当前父节点(区间)的前缀最大长度等于左子节点(区间)的前缀最大长度;\n\t* `tr[u].suffix = tr[u << 1 | 1].suffix`:当前父节点(区间)的后缀最大长度等于右子节点(区间)的后缀最大长度;\n\t* `tr[u].val = max(left.val, right.val)`:当前父节点(区间)的最大长度为两子节点(区间)的最大长度。\n* 对于非一般性的合并(当前节点的两个子节点的衔接点为相同字符):\n  * `tr[u].val = max(tr[u].val, left.suffix + right.prefix)`:首先可以确定的是「左区间的后缀」和「右区间的前缀」可以拼接在一起,因此可以使用拼接长度来尝试更新当前节点的最大值;\n  * `tr[u].suffix = bLen + left.suffix`:其中 `bLen` 为右节点(区间)的长度。当且仅当右节点(区间)整一段都是相同字符时(即满足 `right.prefix = right.suffix = bLen`),可以使用 `bLen + left.suffix` 来更新 `tr[u].suffix`;\n  * `tr[u].prefix = aLen + right.prefix`:其中 `aLen` 为左节点(区间)的长度。当且仅当左节点(区间)整一段都是相同字符时(即满足 `left.prefix = left.prefix = aLen`),可以使用 `aLen + right.prefix` 来更新 `tr[u].prefix `。\n\n代码:\n```Java\nclass Solution {\n    class Node {\n        int l, r, prefix, suffix, val;\n        Node(int _l, int _r) {\n            l = _l; r = _r;\n            prefix = suffix = val = 1;\n        }\n    }\n    char[] cs;\n    Node[] tr;\n    void build(int u, int l, int r) {\n        tr[u] = new Node(l, r);\n        if (l == r) return ;\n        int mid = l + r >> 1;\n        build(u << 1, l, mid);\n        build(u << 1 | 1, mid + 1, r);\n    }\n    void update(int u, int x, char c) {\n        if (tr[u].l == x && tr[u].r == x) {\n            cs[x - 1] = c;\n            return ;\n        }\n        int mid = tr[u].l + tr[u].r >> 1;\n        if (x <= mid) update(u << 1, x, c);\n        else update(u << 1 | 1, x, c);\n        pushup(u);\n    }\n    int query(int u, int l, int r) {\n        if (l <= tr[u].l && tr[u].r <= r) return tr[u].val;\n        int ans = 0;\n        int mid = tr[u].l + tr[u].r >> 1;\n        if (l <= mid) ans = query(u << 1, l, r);\n        if (r > mid) ans = Math.max(ans, query(u << 1 | 1, l, r));\n        return ans;\n    }\n    void pushup(int u) {\n        Node left = tr[u << 1], right = tr[u << 1 | 1];\n        int aLen = left.r - left.l + 1, bLen = right.r - right.l + 1;\n        char ac = cs[left.r - 1], bc = cs[right.l - 1];\n        tr[u].prefix = left.prefix; tr[u].suffix = right.suffix;\n        tr[u].val = Math.max(left.val, right.val);\n        if (ac == bc) {\n            if (left.prefix == aLen) tr[u].prefix = aLen + right.prefix;\n            if (right.prefix == bLen) tr[u].suffix = bLen + left.suffix;\n            tr[u].val = Math.max(tr[u].val, left.suffix + right.prefix);\n        } \n    }\n    public int[] longestRepeating(String s, String queryCharacters, int[] queryIndices) {\n        cs = s.toCharArray();\n        int n = cs.length, m = queryCharacters.length();\n        tr = new Node[n * 4];\n        build(1, 1, n);\n        for (int i = 0; i < n; i++) update(1, i + 1, cs[i]);\n        int[] ans = new int[m];\n        for (int i = 0; i < m; i++) {\n            update(1, queryIndices[i] + 1, queryCharacters.charAt(i));\n            ans[i] = query(1, 1, n);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(m\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2213` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2211-2220/2216. 美化数组的最少删除数（中等）.md", "url_title": "2216. 美化数组的最少删除数", "url": "https://leetcode.cn/problems/minimum-deletions-to-make-array-beautiful/solutions/2535327/gong-shui-san-xie-zhi-ji-ben-zhi-de-ji-j-dk05/", "difficulty": "中等", "tags": ["模拟"], "question": "给你一个下标从 `0` 开始的整数数组 `nums`,如果满足下述条件,则认为数组 `nums` 是一个 美丽数组 :\n\n* `nums.length` 为偶数\n* 对所有满足 `i % 2 == 0` 的下标 `i`,`nums[i] != nums[i + 1]` 均成立\n\n注意,空数组同样认为是美丽数组。\n\n你可以从 `nums` 中删除任意数量的元素。当你删除一个元素时,被删除元素右侧的所有元素将会向左移动一个单位以填补空缺,而左侧的元素将会保持 不变 。\n\n返回使 `nums` 变为美丽数组所需删除的最少元素数目。\n\n示例 1:\n```\n输入:nums = [1,1,2,3,5]\n\n输出:1\n\n解释:可以删除 nums[0] 或 nums[1] ,这样得到的 nums = [1,2,3,5] 是一个美丽数组。可以证明,要想使 nums 变为美丽数组,至少需要删除 1 个元素。\n```\n示例 2:\n```\n输入:nums = [1,1,2,2,3,3]\n\n输出:2\n\n解释:可以删除 nums[0] 和 nums[5] ,这样得到的 nums = [1,2,2,3] 是一个美丽数组。可以证明,要想使 nums 变为美丽数组,至少需要删除 2 个元素。\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $0 <= nums[i] <= 10^5$", "solution": "### 模拟\n\n使用变量 `cnt` 代表已删除的元素个数,由于每次删除元素,剩余元素都会往前移动,因此遍历过程中,当前下标为 $i - cnt$。\n\n若当前下标为偶数,且与下一位置元素相同,那么当前元素需被删除,令 `cnt` 自增。\n\n最终数组长度为 $n - cnt$,若长度为奇数,需要再额外删除结尾元素(`cnt` 再加一),否则 `cnt` 即为答案。\n\nJava 代码:\n\n```Java\nclass Solution {\n    public int minDeletion(int[] nums) {\n        int n = nums.length, cnt = 0;\n        for (int i = 0; i < n; i++) {\n            if ((i - cnt) % 2 == 0 && i + 1 < n && nums[i] == nums[i + 1]) cnt++;\n        }\n        return (n - cnt) % 2 != 0 ? cnt + 1 : cnt;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int minDeletion(vector<int>& nums) {\n        int n = nums.size(), cnt = 0;\n        for (int i = 0; i < n; i++) {\n            if ((i - cnt) % 2 == 0 && i + 1 < n && nums[i] == nums[i + 1]) cnt++;\n        }\n        return (n - cnt) % 2 != 0 ? cnt + 1 : cnt;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minDeletion(self, nums: List[int]) -> int:\n        n, cnt = len(nums), 0\n        for i in range(n):\n            if (i - cnt) % 2 == 0 and i + 1 < n and nums[i] == nums[i + 1]:\n                cnt += 1\n        return cnt + 1 if (n - cnt) % 2 != 0 else cnt\n```\nTypeScript 代码:\n```TypeScript\nfunction minDeletion(nums: number[]): number {\n    let n = nums.length, cnt = 0;\n    for (let i = 0; i < n; i++) {\n        if ((i - cnt) % 2 == 0 && i + 1 < n && nums[i] == nums[i + 1]) cnt++;\n    }\n    return (n - cnt) % 2 != 0 ? cnt + 1 : cnt;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2216` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2241-2250/2246. 相邻字符不同的最长路径（困难）.md", "url_title": "2246. 相邻字符不同的最长路径", "url": "https://leetcode.cn/problems/longest-path-with-different-adjacent-characters/solutions/2453857/gong-shui-san-xie-shu-xing-dp-ding-gen-d-eh5i/", "difficulty": "困难", "tags": ["树", "DFS", "树形 DP", "动态规划"], "question": "给你一棵 树(即一个连通、无向、无环图),根节点是节点 `0`,这棵树由编号从 `0` 到 `n - 1` 的 `n` 个节点组成。\n\n用下标从 `0` 开始、长度为 `n` 的数组 `parent` 来表示这棵树,其中 `parent[i]` 是节点 `i` 的父节点,由于节点 `0` 是根节点,所以 `parent[0] = -1`。\n\n另给你一个字符串 `s`,长度也是 `n`,其中 `s[i]` 表示分配给节点 `i` 的字符。\n\n请你找出路径上任意一对相邻节点都没有分配到相同字符的 最长路径 ,并返回该路径的长度。\n\n示例 1:\n\n```\n输入:parent = [-1,0,0,1,1,2], s = \"abacbe\"\n\n输出:3\n\n解释:任意一对相邻节点字符都不同的最长路径是:0 -> 1 -> 3 。该路径的长度是 3 ,所以返回 3 。\n可以证明不存在满足上述条件且比 3 更长的路径。 \n```\n\n示例 2:\n\n```\n输入:parent = [-1,0,0,0], s = \"aabc\"\n\n输出:3\n\n解释:任意一对相邻节点字符都不同的最长路径是:2 -> 0 -> 3 。该路径的长度为 3 ,所以返回 3 。\n```\n\n提示:\n* $n = parent.length = s.length$\n* $1 <= n <= 10^5$\n* 对所有 `i >= 1`,`0 <= parent[i] <= n - 1` 均成立\n* $parent[0] = -1$\n* `parent` 表示一棵有效的树\n* `s` 仅由小写英文字母组成", "solution": "### DFS\n\n起始先用 `parent` 进行建图,随后设计 `DFS` 函数来求解每个节点“往下”的最长路径:将当前节点 `cur` 作为传入参数,返回以节点“往下”的最长路径。\n\n这是一个由子节点最长路径推导父节点最长路径的「自下而上」的推导过程。\n\n> 先来关注该 `DFS`  的功能本身:\n\n假设当前处理到的节点为 `u`,将要访问到的节点为 `j`。递归调用 `DFS` 函数拿到以节点 `j` 为根节点时的“往下”最大路径 `t`,并执行如下处理流程:\n\n* 若节点 `j` 和节点 `u` 对应字符相同,说明将节点 `j` 拼接在节点 `u` 后面并非合法路径,跳过处理\n* 否则使用 `t` 来更新以当前节点 `u` 为根时,最大的“往下”子路径 `res`(该值初始值为 `0`)\n\n当处理完节点 `u` 的所有子节点,我们 `res + 1` 即是函数返回值(含义为在合法的最长路径本身拼接节点 `u`)。\n\n> 再来关注 `DFS`  过程中,如何计算问题答案:\n\n在 `DFS` 函数中,我们递归处理了所有节点,而**在真实最长路径在原树中的最高点**,自然也是被处理到的。\n\n这引导我们可以在单次递归,处理当前节点时,使用变量 `l1` 和 `l2` 分别记录当前节点的「最大子路径」和「次大子路径」。\n\n在处理完当前节点后,`1 + l1 + l2` 即是以当前节点作为路径最高点时的最大路径长度(含义为在合法「最大子路径」和「次大子路径」基础上拼接当前节点),用其更新全局变量 `ans`。\n\n代码:\n```Java\nclass Solution {\n    int N = 100010, M = N, idx = 0, ans = 1;\n    int[] he = new int[N], e = new int[M], ne = new int[M];\n    char[] cs;\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    public int longestPath(int[] parent, String s) {\n        Arrays.fill(he, -1);\n        for (int i = 1; i < parent.length; i++) add(parent[i], i);\n        cs = s.toCharArray();\n        dfs(0);\n        return ans;\n    }\n    int dfs(int u) {\n        int res = 0;\n        int l1 = 0, l2 = 0;\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            int t = dfs(j);\n            if (cs[u] == cs[j]) continue;\n            if (t > l1) {\n                l2 = l1; l1 = t;\n            } else if (t > l2) {\n                l2 = t;\n            }\n            res = Math.max(res, t);\n            ans = Math.max(ans, 1 + l1 + l2);\n        }\n        return res + 1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 树形 DP\n\n自然也是能够使用「树形 DP」思路来做。\n\n只不过对于「定根树形 DP」来说,往往一遍 `DFS`  就能实现 $O(n)$ 做法。例如 [124. 二叉树中的最大路径和](https://leetcode.cn/problems/binary-tree-maximum-path-sum/solutions/2451624/gong-shui-san-xie-jian-dan-di-gui-shu-xi-nlci/)。\n\n而「换根树形 DP」则只能通过对“方向”的拆分,用两遍 `DFS`  来进行求解。例如 [310. 最小高度树](https://leetcode.cn/problems/minimum-height-trees/solutions/1397905/by-ac_oier-7xio/) 和 [834. 树中距离之和](https://leetcode.cn/problems/sum-of-distances-in-tree/solutions/2449965/gong-shui-san-xie-shu-xing-dp-chang-gui-1v7ud/)。\n\n在「定根树形 DP」题目中采用「换根树形 DP」做法,无论是从执行流程还是编码来说,都稍显“多余”(毕竟一次 `DFS`  就能以「最佳路径的最高点必然能够被处理」来得证答案的正确性),但在验证大家是否真正掌握「树形 DP」精髓来说,却有极大意义。\n\n代码:\n\n```Java\nclass Solution {\n    int N = 100010, M = N, idx = 0;\n    int[] he = new int[N], e = new int[M], ne = new int[M];\n    char[] cs;\n    int[] f1 = new int[N], f2 = new int[N], g = new int[N], p = new int[N];\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    public int longestPath(int[] parent, String s) {\n        Arrays.fill(he, -1);\n        for (int i = 1; i < parent.length; i++) add(parent[i], i);\n        cs = s.toCharArray();\n        dfs1(0);\n        dfs2(0);\n        int ans = 1;\n        int[] temp = new int[3];\n        for (int i = 0; i < parent.length; i++) {\n            temp[0] = f1[i]; temp[1] = f2[i]; temp[2] = g[i];\n            Arrays.sort(temp);\n            ans = Math.max(ans, 1 + temp[1] + temp[2]);\n        }\n        return ans;\n    }\n    int dfs1(int u) {\n        int ans = 0;\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            int t = dfs1(j);\n            if (cs[u] == cs[j]) continue;\n            if (t > f1[u]) {\n                f2[u] = f1[u]; f1[u] = t;\n                p[u] = j;\n            } else if (t > f2[u]) {\n                f2[u] = t;\n            }\n            ans = Math.max(ans, t);\n        }\n        return ans + 1;\n    }\n    void dfs2(int u) {\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (cs[u] != cs[j]) {\n                // 往上再往上\n                g[j] = g[u] + 1;\n                // 往上再往下(根据 u 的往下最大路径是否由 j 参与决定使用 最大值 还是 次大值)\n                if (p[u] != j) g[j] = Math.max(g[j], 1 + f1[u]);\n                else g[j] = Math.max(g[j], 1 + f2[u]);\n            }\n            dfs2(j);\n        }\n    }\n}\n```\n* 时间复杂度:常数较大的 $O(n)$。相比于一次 `DFS`  的做法来说,额外多了一次 `DFS`,以及构建答案时对定长数组的排序操作\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2346` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2251-2260/2258. 逃离火灾（困难）.md", "url_title": "2258. 逃离火灾", "url": "https://leetcode.cn/problems/escape-the-spreading-fire/solutions/2518985/gong-shui-san-xie-xiang-jie-ru-he-cong-e-458x/", "difficulty": "困难", "tags": ["多源 BFS", "二分", "预处理"], "question": "给你一个下标从 `0` 开始大小为 `m x n` 的二维整数数组 `grid`,它表示一个网格图。\n\n每个格子为下面 $3$ 个值之一:\n\n* `0` 表示草地。\n* `1` 表示着火的格子。\n* `2` 表示一座墙,你跟火都不能通过这个格子。\n\n一开始你在最左上角的格子 $(0, 0)$ ,你想要到达最右下角的安全屋格子 $(m - 1, n - 1)$ 。\n\n每一分钟,你可以移动到相邻的草地格子。\n\n每次你移动之后 ,着火的格子会扩散到所有不是墙的相邻格子。\n\n请你返回你在初始位置可以停留的最多分钟数,且停留完这段时间后你还能安全到达安全屋。\n\n如果无法实现,请你返回 $-1$。如果不管你在初始位置停留多久,你总是能到达安全屋,请你返回 $10^9$ 。\n\n注意,如果你到达安全屋后,火马上到了安全屋,这视为你能够安全到达安全屋。\n\n如果两个格子有共同边,那么它们为相邻格子。\n\n示例 1:\n\n```\n输入:grid = [[0,2,0,0,0,0,0],[0,0,0,2,2,1,0],[0,2,0,0,1,2,0],[0,0,2,2,2,0,2],[0,0,0,0,0,0,0]]\n\n输出:3\n\n解释:上图展示了你在初始位置停留 3 分钟后的情形。\n你仍然可以安全到达安全屋。\n停留超过 3 分钟会让你无法安全到达安全屋。\n```\n示例 2:\n\n```\n输入:grid = [[0,0,0,0],[0,1,2,0],[0,2,0,0]]\n\n输出:-1\n\n解释:上图展示了你马上开始朝安全屋移动的情形。\n火会蔓延到你可以移动的所有格子,所以无法安全到达安全屋。\n所以返回 -1 。\n```\n示例 3:\n\n```\n输入:grid = [[0,0,0],[2,2,0],[1,2,0]]\n\n输出:1000000000\n\n解释:上图展示了初始网格图。\n注意,由于火被墙围了起来,所以无论如何你都能安全到达安全屋。\n所以返回 109 。\n```\n\n提示:\n* $m = grid.length$\n* $n = grid[i].length$\n* $2 <= m, n <= 300$\n* $4 <= m \\times n <= 2 \\times 10^4$\n* `grid[i][j]` 是 `0`,`1` 或者 `2`。\n* $grid[0][0] = grid[m - 1][n - 1] = 0$", "solution": "### 二分 + BFS\n\n火势蔓延是一个固定的过程,只有人员移动需要决策。\n\n假设人员最晚在 $t$ 秒后出发,仍能到达安全屋,说明人员对逃走路线的访问,要比火势更快。那么人员在更早的时间点($[0, t - 1]$ 秒后)出发,必然仍能按照原定路线到达安全屋(火势对路径的影响不变)。\n\n因此,在以 $t$ 为分割点的(正整数)数轴上,具有二段性,可运用「二分」求分割点。\n\n假设存在某个判定函数 `check`,用于检查人员在 $x$ 秒后出发能否到达安全屋,那么可知:\n\n* 当实际延迟出发的秒数,小于等于 $t$ 秒,必然能安全到达\n* 当实际延迟出发的描述,超过 $t$ 秒,必然不能安全到达\n\n在人员移动路线中,“回头路”是没有意义的,因此人员对每个点的访问次数最多为一次。同时,不考虑墙的阻拦,火势也最多在不超过棋盘大小的时间内完全蔓延。\n\n这指导我们最大延迟出发时间不会超过 $n \\times m$,可在 $[0, n \\times m]$ 值域内进行二分。\n\n接下来,考虑如何实现 `check` 函数,函数入参为延迟出发秒数  $t$,返回值为延迟出发后能否到达安全屋。\n\n首先,对于普通位置,如果火势和人员同时到达,是不允许的,而安全屋 $(n - 1, m - 1)$ 位置的同时到达,是允许的。\n\n因此,我们需要使用两个二维数组 `fg` 和 `pg` 分别记录「火势」和「人员」到达某个位置的最早时间。\n\n1. 创建用于模拟火势蔓延的队列 `fire`,遍历网格,将火源位置进行入队,更新火源位置 $fg[i][j] = 1$,表示火势在第一秒时最早出现在此处;\n\n2. 运用 `BFS`,模拟 $t$ 秒的火势蔓延,火势在这 $t$ 秒内所蔓延到的新位置,均看作为起始火源,即有 $fg[i][j] = 1$。\n\n   若执行完 $t$ 秒后,火势已蔓延到人员起始位置 $(0, 0)$,那么延迟 $t$ 秒出发不可行,直接返回 `False`;\n\n3. 创建用于模拟人员移动的队列 `people`,将起始位置 $(0, 0)$ 进行入队,更新 $pg[0][0] = 1$。\n\n   运用 `BFS`,按照「先火后人」的方式,同步模拟「火势蔓延」和「人员移动」过程。普通位置,只要火势蔓延到,那么人将无法移动到此处;安全屋位置,需要判断是否与火势同一时刻到达。\n\n为了方便,将「火势蔓延」和「人员移动」统一成 `update` 操作,入参包括当前队列 `d`,标识位 `isFire`,以及移动偏移量 `offset`。\n\n在进行 $t$ 秒的火势蔓延时,调用 $t$ 次的 `update(fire, true, 0)`。在火势和人员同步模拟时,分别调用 `update(fire, true, 1)` 和 `update(people, false, 1)`。\n\n使用示例 $1$ 来举个 🌰:\n\nJava 代码:\n\n```Java\nclass Solution {\n    int[][] dirs = new int[][]{{0,1}, {0,-1}, {1,0}, {-1,0}};\n    int n, m;\n    boolean ok;\n    int[][] g, fg, pg;\n    public int maximumMinutes(int[][] grid) {\n        g = grid;\n        n = g.length; m = g[0].length;\n        fg = new int[n][m]; pg = new int[n][m];\n        if (!check(0)) return -1;\n        int l = 0, r = n * m;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (check(mid)) l = mid;\n            else r = mid - 1;\n        }\n        return r == m * n ? (int)1e9 : r;\n    }\n    boolean check(int t) {\n        ok = false;\n        Deque<int[]> frie = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                fg[i][j] = pg[i][j] = 0;\n                if (g[i][j] == 1) {\n                    fg[i][j] = 1;\n                    frie.addLast(new int[]{i, j});\n                }\n            }\n        }\n        while(t-- > 0) update(frie, true, 0);  // 先执行 t 秒的火势蔓延\n        if (fg[0][0] != 0) return false;\n        Deque<int[]> people = new ArrayDeque<>();\n        pg[0][0] = 1;\n        people.addLast(new int[]{0, 0});\n        while (!people.isEmpty()) {\n            // 先火后人, 同步进行\n            update(frie, true, 1);\n            update(people, false, 1);\n            if (ok) return true;\n        }\n        return false;\n    }\n    void update(Deque<int[]> deque, boolean isFire, int offset) {\n        int sz = deque.size();\n        while (sz-- > 0) {\n            int[] info = deque.pollFirst();\n            int x = info[0], y = info[1];\n            for (int[] dir : dirs) {\n                int nx = x + dir[0], ny = y + dir[1];\n                if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;\n                if (g[nx][ny] == 2) continue;\n                if (isFire) {\n                    if (fg[nx][ny] != 0) continue;\n                    fg[nx][ny] = fg[x][y] + offset;\n                } else {\n                    if (nx == n - 1 && ny == m - 1 && (fg[nx][ny] == 0 || fg[nx][ny] == pg[x][y] + offset)) ok = true;  // 火尚未到达 或 同时到达\n                    if (fg[nx][ny] != 0 || pg[nx][ny] != 0) continue;\n                    pg[nx][ny] = pg[x][y] + offset;\n                }\n                deque.addLast(new int[]{nx, ny});\n            }\n        }\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<vector<int>> dirs = {{0,1}, {0,-1}, {1,0}, {-1,0}};\n    int n, m;\n    bool ok;\n    vector<vector<int>> g, fg, pg;\n    int maximumMinutes(vector<vector<int>>& grid) {\n        g = grid;\n        n = g.size(); m = g[0].size();\n        fg = vector<vector<int>>(n, vector<int>(m, 0)), pg = vector<vector<int>>(n, vector<int>(m, 0));\n        if (!check(0)) return -1;\n        int l = 0, r = n * m;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (check(mid)) l = mid;\n            else r = mid - 1;\n        }\n        return r == n * m ? (int)1e9 : r;\n    }\n    bool check(int t) {\n        ok = false;\n        deque<vector<int>> frie;   \n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                fg[i][j] = pg[i][j] = 0;\n                if (g[i][j] == 1) {\n                    fg[i][j] = 1;\n                    frie.push_back({i, j});\n                }\n            }\n        }\n        while (t-- > 0) update(frie, true, 0);\n        if (fg[0][0] != 0) return false;\n        deque<vector<int>> people;\n        pg[0][0] = 1;\n        people.push_back({0, 0});\n        while (!people.empty()) {\n            update(frie, true, 1);\n            update(people, false, 1);\n            if (ok) return true;\n        }\n        return false;\n    }\n    void update(deque<vector<int>>& deque, bool isFire, int offset) {\n        int sz = deque.size();\n        while (sz-- > 0) {\n            vector<int> info = deque.front();\n            deque.pop_front();\n            int x = info[0], y = info[1];\n            for (vector<int> dir : dirs) {\n                int nx = x + dir[0], ny = y + dir[1];\n                if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;\n                if (g[nx][ny] == 2) continue;\n                if (isFire) {\n                    if (fg[nx][ny] != 0) continue;                    \n                    fg[nx][ny] = fg[x][y] + offset;\n                } else {\n                    if (nx == n - 1 && ny == m - 1 && (fg[nx][ny] == 0 || fg[nx][ny] == pg[x][y] + offset)) ok = true;\n                    if (fg[nx][ny] != 0 || pg[nx][ny] != 0) continue;\n                    pg[nx][ny] = pg[x][y] + offset;\n                }\n                deque.push_back({nx, ny});\n            }\n        }\n    }\n};\n```\nPython 代码:\n```Python\nfrom collections import deque\n\nclass Solution:\n    def maximumMinutes(self, grid: List[List[int]]) -> int:\n        dirs = [(0,1),(0,-1),(1,0),(-1,0)]\n        g = grid\n        n, m = len(g), len(g[0])\n        fg, pg, ok = None, None, False\n\n        def update(d, isFire, offset):\n            nonlocal ok\n            for _ in range(len(d)):\n                x, y = d.popleft()\n                for dx, dy in dirs:\n                    nx, ny = x + dx, y + dy\n                    if nx < 0 or nx >= n or ny < 0 or ny >= m: continue\n                    if g[nx][ny] == 2: continue\n                    if isFire:\n                        if fg[nx][ny] != 0: continue\n                        fg[nx][ny] = fg[x][y] + offset\n                    else:\n                        if nx == n - 1 and ny == m - 1 and (fg[nx][ny] == 0 or fg[nx][ny] == pg[x][y] + offset): ok = True\n                        if fg[nx][ny] != 0 or pg[nx][ny] != 0: continue\n                        pg[nx][ny] = pg[x][y] + offset\n                    d.append((nx, ny))\n\n        def check(t):\n            nonlocal pg, fg, ok\n            ok = False\n            pg = [[0] * m for _ in range(n)]\n            fg = [[g[i][j] == 1 for j in range(m)] for i in range(n)]\n            fire = deque([(i, j) for i, j in product(range(n), range(m)) if g[i][j] == 1])\n            for _ in range(t): update(fire, True, 0)\n            if fg[0][0] != 0: return False\n            people = deque()\n            pg[0][0] = 1\n            people.append((0, 0))\n            while people:\n                update(fire, True, 1)\n                update(people, False, 1)\n                if ok: return True\n            return False\n\n        if not check(0): return -1\n        l, r = 0, n * m\n        while l < r:\n            mid = l + r + 1 >> 1\n            if check(mid): l = mid\n            else: r = mid - 1\n        return int(1e9) if r == n * m else r\n```\nTypeScript 代码:\n```TypeScript\nfunction maximumMinutes(grid: number[][]): number {\n    const dirs = [[0,1],[0,-1],[1,0],[-1,0]];\n    const g = grid;\n    const n = g.length, m = g[0].length;\n    const fg = Array.from({length: n}, () => Array(m).fill(0)), pg = Array.from({length: n}, () => Array(m).fill(0));\n    let ok = false;\n    const update = function(d: number[][], isFire: boolean, offset: number) {\n        let sz = d.length;\n        while (sz-- > 0) {\n            const info = d.shift();\n            const x = info[0], y = info[1];\n            for (let di of dirs) {\n                const nx = x + di[0], ny = y + di[1];\n                if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;\n                if (g[nx][ny] == 2) continue;\n                if (isFire) {\n                    if (fg[nx][ny] != 0) continue;\n                    fg[nx][ny] = fg[x][y] + offset;\n                } else {\n                    if (nx == n - 1 && ny == m - 1 && (fg[nx][ny] == 0 || fg[nx][ny] == pg[x][y] + offset)) ok = true;\n                    if (fg[nx][ny] != 0 || pg[nx][ny] != 0) continue;\n                    pg[nx][ny] = pg[x][y] + offset;\n                }\n                d.push([nx, ny]);\n            }\n        }\n    }\n    const check = function(t: number): boolean {\n        ok = false\n        const fire = new Array()\n        for (let i = 0; i < n; i++) {\n            for (let j = 0; j < m; j++) {\n                fg[i][j] = pg[i][j] = 0;\n                if (g[i][j] == 1) {\n                    fg[i][j] = 1;\n                    fire.push([i, j]);\n                }\n            }\n        }\n        while (t-- > 0) update(fire, true, 0);\n        if (fg[0][0] != 0) return false;\n        const people = new Array();\n        pg[0][0] = 1;\n        people.push([0, 0]);\n        while (people.length != 0) {\n            update(fire, true, 1);\n            update(people, false, 1);\n            if (ok) return true;\n        }\n        return false;\n    }\n    if (!check(0)) return -1;\n    let l = 0, r = n * m;\n    while (l < r) {\n        const mid = l + r + 1 >> 1;\n        if (check(mid)) l = mid;\n        else r = mid - 1;\n    }\n    return r == n * m ? 1e9 : r;\n};\n```\n* 时间复杂度:在值域 $[0, n \\times m]$ 范围内进行二分,二分 `check` 的 `BFS`  实现复杂度为 $O(n \\times m)$。整体复杂度为 $O(nm \\log{nm})$\n* 空间复杂度:$O(n \\times m)$\n\n---\n\n### BFS + 分类讨论\n\n经过上述解法,我们发现存在大量重复计算:例如每次唯一确定的“火势蔓延”过程,以及每次根据最新起始火势(由延迟出发时间 $t$ 所决定)进行的“人员移动”过程,都是不必要的,可通过比较双方到达时间来求解。\n\n具体的,还是用 `fg` 和 `pg`,分别预处理出「火势」和「人员」到达每个网格的最早时间。其中火势蔓延唯一确定,而人员的预处理是在不考虑火势的情况下进行。\n\n根据 $f = fg[n-1][m-1]$ 和 $p = pg[n-1][m-1]$ 进行分情况讨论:\n\n* 若 $p = 0$:人与安全屋不连通,返回 $-1$;\n\n* 若 $f = 0$:火与安全屋不连通,同时上述条件不满足($p \\neq 0$),即人与安全屋是联通 ,返回 $1e9$;\n\n* 若 $f < p$:火和人都能到达安全屋。即使不考虑人员中途被火影响(人员可能无法按照最佳路线前往安全屋)的情况下,火也比人要更早到达安全屋,返回 $-1$;\n\n* 若 $f \\geqslant p$:理想情况下,人比火更早到达安全屋,但存在「人火同时到达」、「人员中途被烧」或「通路被火拦截」等问题,需要进一步分情况讨论:\n\n  不难发现,由于安全屋的位于 $(n - 1, m - 1)$,人员只能从 $(n - 1, m - 2)$ 或 $(n - 2, m - 1)$ 两个位置之一到达安全屋(这两个属于普通位置,不允许人和火同时到达),因此可以将「对特殊位置安全屋」的讨论转为「对普通位置」的讨论:\n\n  * 若 $pg[n - 1][m - 2] \\neq 0$,人与该位置联通,且 $f - p + pg[n - 1][m - 2] < fg[n - 1][m - 2]$,人比火更早到达该位置,返回 $f - p$;\n  * 若 $pg[n - 2][m - 1] \\neq 0$,人与该位置联通,且 $f - p + pg[n - 2][m - 1] < fg[n - 2][m - 1]$,人比火更早到达该位置,返回 $f - p$;\n  * 否则,说明延迟 $f - p$ 秒出发,唯二的通路会被火提前拦截,需要早一秒出发,返回 $f - p - 1$;\n\nJava 代码:\n```Java\nclass Solution {\n    int[][] dirs = new int[][]{{0,1}, {0,-1}, {1,0}, {-1,0}};\n    int[][] g;\n    int n, m;\n    public int maximumMinutes(int[][] grid) {\n        g = grid;\n        n = g.length; m = g[0].length;\n        int[][] fg = new int[n][m], pg = new int[n][m];\n        Deque<int[]> fire = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                if (g[i][j] == 1) {\n                    fg[i][j] = 1;\n                    fire.addLast(new int[]{i, j});\n                }\n            }\n        }\n        bfs(fire, fg);\n        Deque<int[]> people = new ArrayDeque<>();\n        people.addLast(new int[]{0, 0});\n        pg[0][0] = 1;\n        bfs(people, pg);\n        int p = pg[n - 1][m - 1], f = fg[n - 1][m - 1], ans = f - p;\n        if (p == 0) return -1;\n        if (f == 0) return (int)1e9;\n        if (p > f) return -1;\n        if (pg[n - 1][m - 2] != 0 && ans + pg[n - 1][m - 2] < fg[n - 1][m - 2]) return ans;\n        if (pg[n - 2][m - 1] != 0 && ans + pg[n - 2][m - 1] < fg[n - 2][m - 1]) return ans;\n        return ans - 1;\n    }\n    void bfs(Deque<int[]> d, int[][] time) {\n        while (!d.isEmpty()) {\n            int[] info = d.pollFirst();\n            int x = info[0], y = info[1];\n            for (int[] dir : dirs) {\n                int nx = x + dir[0], ny = y + dir[1];\n                if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;\n                if (g[nx][ny] == 2) continue;\n                if (time[nx][ny] != 0) continue;\n                time[nx][ny] = time[x][y] + 1;\n                d.addLast(new int[]{nx, ny});\n            }\n        }\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<vector<int>> dirs = {{0,1}, {0,-1}, {1,0}, {-1,0}};\n    vector<vector<int>> g;\n    int n, m;\n    int maximumMinutes(vector<vector<int>>& grid) {\n        g = grid;\n        n = g.size(); m = g[0].size();\n        vector<vector<int>> fg = vector<vector<int>>(n, vector<int>(m, 0)), pg = vector<vector<int>>(n, vector<int>(m, 0));\n        deque<pair<int, int>> fire;\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                if (g[i][j] == 1) {\n                    fg[i][j] = 1;\n                    fire.push_back({i, j});\n                }\n            }\n        }\n        bfs(fire, fg);\n        deque<pair<int, int>> people;\n        people.push_back({0, 0});\n        pg[0][0] = 1;\n        bfs(people, pg);\n        int p = pg[n - 1][m - 1], f = fg[n - 1][m - 1], ans = f - p;\n        if (p == 0) return -1;\n        if (f == 0) return (int)1e9;\n        if (p > f) return -1;\n        if (pg[n - 1][m - 2] != 0 && ans + pg[n - 1][m - 2] < fg[n - 1][m - 2]) return ans;\n        if (pg[n - 2][m - 1] != 0 && ans + pg[n - 2][m - 1] < fg[n - 2][m - 1]) return ans;\n        return ans - 1;\n    }\n    void bfs(deque<pair<int, int>>& d, vector<vector<int>>& time) {\n        while (!d.empty()) {\n            pair<int, int> info = d.front();\n            d.pop_front();\n            int x = info.first, y = info.second;\n            for (vector<int> dir : dirs) {\n                int nx = x + dir[0], ny = y + dir[1];\n                if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;\n                if (g[nx][ny] == 2) continue;\n                if (time[nx][ny] != 0) continue;\n                time[nx][ny] = time[x][y] + 1;\n                d.push_back({nx, ny});\n            }\n        }\n    }\n};\n```\nPython 代码:\n```Python\nfrom collections import deque\n\nclass Solution:\n    def maximumMinutes(self, grid: List[List[int]]) -> int:\n        dirs = [(0,1), (0,-1), (1,0), (-1,0)]\n        g = grid\n        n, m = len(g), len(g[0])\n\n        def bfs(d, tn):\n            while d:\n                x, y = d.popleft()\n                for dx, dy in dirs:\n                    nx, ny = x + dx, y + dy\n                    if nx < 0 or nx >= n or ny < 0 or ny >= m: continue\n                    if g[nx][ny] == 2 or tn[nx][ny]: continue\n                    tn[nx][ny] = tn[x][y] + 1\n                    d.append((nx, ny))\n\n        fg = [[g[i][j] == 1 for j in range(m)] for i in range(n)]\n        fire = deque([(i, j) for i, j in product(range(n), range(m)) if g[i][j] == 1])\n        bfs(fire, fg)\n        pg = [[0] * m for _ in range(n)]\n        pg[0][0] = 1\n        people = deque([(0, 0)])\n        bfs(people, pg)\n\n        p, f = pg[-1][-1], fg[-1][-1]\n        ans = f - p\n        if p == 0: return -1\n        if f == 0: return int(1e9)\n        if p > f: return -1\n        if pg[-1][-2] != 0 and ans + pg[-1][-2] < fg[-1][-2]: return ans\n        if pg[-2][-1] != 0 and ans + pg[-2][-1] < fg[-2][-1]: return ans\n        return ans - 1\n```\nTypeScript 代码:\n```TypeScript\nfunction maximumMinutes(grid: number[][]): number {\n    const g = grid;\n    const n = g.length, m = g[0].length;\n    const dirs = [[0, 1], [0, -1], [1, 0], [-1, 0]];\n    const bfs = function (d: number[][], time: number[][]): void {\n        while (d.length > 0) {\n            const info = d.shift() as number[];\n            const x = info[0], y = info[1];\n            for (const dir of dirs) {\n                const nx = x + dir[0], ny = y + dir[1];\n                if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;\n                if (g[nx][ny] == 2) continue;\n                if (time[nx][ny] != 0) continue;\n                time[nx][ny] = time[x][y] + 1;\n                d.push([nx, ny]);\n            }\n        }\n    }\n    const fg = Array.from({ length: n }, () => Array(m).fill(0));\n    const pg = Array.from({ length: n }, () => Array(m).fill(0));\n    const fire = [];\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < m; j++) {\n            if (g[i][j] == 1) {\n                fg[i][j] = 1;\n                fire.push([i, j]);\n            }\n        }\n    }\n    bfs(fire, fg);\n    const people = [];\n    people.push([0, 0]);\n    pg[0][0] = 1;\n    bfs(people, pg);\n    const p = pg[n - 1][m - 1], f = fg[n - 1][m - 1], ans = f - p;\n    if (p == 0) return -1;\n    if (f == 0) return 1e9;\n    if (p > f) return -1;\n    if (pg[n - 1][m - 2] != 0 && ans + pg[n - 1][m - 2] < fg[n - 1][m - 2]) return ans;\n    if (pg[n - 2][m - 1] != 0 && ans + pg[n - 2][m - 1] < fg[n - 2][m - 1]) return ans;\n    return ans - 1;\n};\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n \\times m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2258` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2291-2300/2300. 咒语和药水的成功对数（中等）.md", "url_title": "2300. 咒语和药水的成功对数", "url": "https://leetcode.cn/problems/successful-pairs-of-spells-and-potions/solutions/2520333/gong-shui-san-xie-jing-dian-er-fen-yun-y-86y0/", "difficulty": "中等", "tags": ["排序", "二分"], "question": "给你两个正整数数组 `spells` 和 `potions`,长度分别为 `n` 和 `m`,其中 `spells[i]` 表示第 `i` 个咒语的能量强度,`potions[j]` 表示第 `j` 瓶药水的能量强度。\n\n同时给你一个整数 `success`。一个咒语和药水的能量强度相乘如果大于等于 `success`,那么它们视为一对成功的组合。\n\n请你返回一个长度为 `n` 的整数数组 `pairs`,其中 `pairs[i]` 是能跟第 `i` 个咒语成功组合的 药水 数目。\n\n示例 1:\n```\n输入:spells = [5,1,3], potions = [1,2,3,4,5], success = 7\n\n输出:[4,0,3]\n\n解释:\n- 第 0 个咒语:5 * [1,2,3,4,5] = [5,10,15,20,25] 。总共 4 个成功组合。\n- 第 1 个咒语:1 * [1,2,3,4,5] = [1,2,3,4,5] 。总共 0 个成功组合。\n- 第 2 个咒语:3 * [1,2,3,4,5] = [3,6,9,12,15] 。总共 3 个成功组合。\n所以返回 [4,0,3] 。\n```\n示例 2:\n```\n输入:spells = [3,1,2], potions = [8,5,8], success = 16\n\n输出:[2,0,2]\n\n解释:\n- 第 0 个咒语:3 * [8,5,8] = [24,15,24] 。总共 2 个成功组合。\n- 第 1 个咒语:1 * [8,5,8] = [8,5,8] 。总共 0 个成功组合。\n- 第 2 个咒语:2 * [8,5,8] = [16,10,16] 。总共 2 个成功组合。\n所以返回 [2,0,2] 。\n```\n\n提示:\n* $n = spells.length$\n* $m = potions.length$\n* $1 <= n, m <= 10^5$\n* $1 <= spells[i], potions[i] <= 10^5$\n* $1 <= success <= 1010$", "solution": "### 排序 + 二分\n\n为了方便,我们将 `spells` 记为 `a`,将 `potions` 记为 `b`,将 `success` 记为 `t`。\n\n对于每个 $a[i]$,有多少个 $b[j]$ 满足 $a[i] \\times b[j] \\geqslant t$,等价于问数组 `b` 中值大于等于 $\\frac{t}{a[i]}$ 的个数,这容易让我们想到先对数组 `b` 排升序,再通过二分找到满足该条件的最小下标,从该下标到数组结尾,均为满足条件的 $b[j]$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] successfulPairs(int[] a, int[] b, long t) {\n        int n = a.length, m = b.length;\n        int[] ans = new int[n];\n        Arrays.sort(b);\n        for (int i = 0; i < n; i++) {\n            double cur = t * 1.0 / a[i];\n            int l = 0, r = m - 1;\n            while (l < r) {\n                int mid = l + r >> 1;\n                if (b[mid] >= cur) r = mid;\n                else l = mid + 1;\n            }\n            if (b[r] * 1L * a[i] >= t) ans[i] = m - r;\n        }\n        return ans;\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def successfulPairs(self, a: List[int], b: List[int], t: int) -> List[int]:\n        # n, m = len(a), len(b)\n        # b.sort()\n        # ans = [0] * n\n        # for i in range(n):\n        #     cur = t / a[i]\n        #     l, r = 0, m - 1\n        #     while l < r:\n        #         mid = l + r >> 1\n        #         if b[mid] >= cur: r = mid\n        #         else: l = mid + 1\n        #     ans[i] = m - r if b[r] * a[i] >= t else 0\n        # return ans\n        b.sort()\n        return [len(b) - bisect_left(b, t / x) for x in a]\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> successfulPairs(vector<int>& a, vector<int>& b, long long t) {\n        // int n = a.size(), m = b.size();\n        // vector<int> ans(n);\n        // sort(b.begin(), b.end());\n        // for (int i = 0; i < n; i++) {\n        //     double cur = t * 1.0 / a[i];\n        //     int l = 0, r = m - 1;\n        //     while (l < r) {\n        //         int mid = l + r >> 1;\n        //         if (b[mid] >= cur) r = mid;\n        //         else l = mid + 1;\n        //     }\n        //     if (b[r] * 1L * a[i] >= t) ans[i] = m - r;\n        // }\n        // return ans;\n        int n = a.size(), m = b.size();\n        vector<int> ans(n);\n        sort(b.begin(), b.end());\n        for (int i = 0; i < n; i++) ans[i] = b.end() - lower_bound(b.begin(), b.end(), t * 1.0 / a[i]);\n        return ans;\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nfunction successfulPairs(a: number[], b: number[], t: number): number[] {\n    const n = a.length, m = b.length;\n    const ans = new Array(n).fill(0);\n    b.sort((a,b)=>a-b);\n    for (let i = 0; i < n; i++) {\n        const cur = t * 1.0 / a[i];\n        let l = 0, r = m - 1;\n        while (l < r) {\n            const mid = l + r >> 1;\n            if (b[mid] >= cur) r = mid;\n            else l = mid + 1;\n        }\n        if (b[r] * a[i] >= t) ans[i] = m - r;\n    }\n    return ans;\n};\n```\n* 时间复杂度:对数组 `b` 排序的复杂度为 $O(m\\log{m})$;构建答案时,每次在值域 $[0, m - 1]$ 范围内进行二分,复杂度为 $O(n\\log{m})$。整体复杂度为 $O(m\\log{m} + n\\log{m})$\n* 空间复杂度:$O(\\log{m} + n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2300` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2301-2310/2304. 网格中的最小路径代价（中等）.md", "url_title": "2304. 网格中的最小路径代价", "url": "https://leetcode.cn/problems/minimum-path-cost-in-a-grid/solutions/2536854/gong-shui-san-xie-cong-tu-lun-zui-duan-l-emxv/", "difficulty": "中等", "tags": ["最短路", "图", "模拟", "序列 DP", "动态规划"], "question": "给你一个下标从 `0` 开始的整数矩阵 `grid`,矩阵大小为 `m x n`,由从 `0` 到 $m \\times n - 1$ 的不同整数组成。\n\n你可以在此矩阵中,从一个单元格移动到下一行的任何其他单元格。\n\n如果你位于单元格 $(x, y)$ ,且满足 $x < m - 1$,你可以移动到 $(x + 1, 0)$, $(x + 1, 1)$, ..., $(x + 1, n - 1)$ 中的任何一个单元格。注意: 在最后一行中的单元格不能触发移动。\n\n每次可能的移动都需要付出对应的代价,代价用一个下标从 `0` 开始的二维数组 `moveCost` 表示,该数组大小为 $(m \\times n) \\times n$ ,其中 `moveCost[i][j]` 是从值为 `i` 的单元格移动到下一行第 `j` 列单元格的代价。从 `grid` 最后一行的单元格移动的代价可以忽略。\n\n`grid` 一条路径的代价是:所有路径经过的单元格的值之和加上所有移动的代价之和 。从第一行任意单元格出发,返回到达最后一行任意单元格的最小路径代价。\n\n示例 1:\n\n```\n输入:grid = [[5,3],[4,0],[2,1]], moveCost = [[9,8],[1,5],[10,12],[18,6],[2,4],[14,3]]\n\n输出:17\n\n解释:最小代价的路径是 5 -> 0 -> 1 。\n- 路径途经单元格值之和 5 + 0 + 1 = 6 。\n- 从 5 移动到 0 的代价为 3 。\n- 从 0 移动到 1 的代价为 8 。\n路径总代价为 6 + 3 + 8 = 17 。\n```\n示例 2:\n```\n输入:grid = [[5,1,2],[4,0,3]], moveCost = [[12,10,15],[20,23,8],[21,7,1],[8,1,13],[9,10,25],[5,3,2]]\n\n输出:6\n\n解释:\n最小代价的路径是 2 -> 3 。 \n- 路径途经单元格值之和 2 + 3 = 5 。 \n- 从 2 移动到 3 的代价为 1 。 \n路径总代价为 5 + 1 = 6 。\n```\n\n提示:\n* $m = grid.length$\n* $n = grid[i].length$\n* $2 <= m, n <= 50$\n* `grid` 由从 `0` 到 `m * n - 1` 的不同整数组成\n* $moveCost.length = m \\times n$\n* $moveCost[i].length = n$\n* $1 <= moveCost[i][j] <= 100$", "solution": "### 建新图 + 建虚拟点 + 堆优化 Dijkstra\n\n> 注意:可以直接使用解法二的方法,但先认真看完本做法,再去看解法二,会有相当丝滑的体验。\n\n每次移动,**实际路径权值 = 经过边的权值 + 目的地的权值**。\n\n利用原图,构建新图:**每个单元格视为一个点,除最后一行外,每个点对下一行的所有点连一条有向边,边权 = 原图中该边的权值 + 原图中该目的地的权值**。\n\n分析新图中的点边数量:\n\n* 点:共 $m \\times n$ 个点,数量为 $2.5 \\times 10^3$\n* 边:不算最后一行,共 $(m - 1) \\times n$ 个点,这些点与下一行的每个点均有一条有向边,合计 $(m - 1) \\times n^2$ 条边,数量为 $1.25 \\times 10^5$\n\n原问题转换为:求点 $i$ 到 $j$ 的最短路,其中点 $i$ 所在位置为第 $0$ 行,点 $j$ 所在位置为第 $m - 1$ 行。\n\n这似乎是一个「多源汇最短路」问题?但求解多源汇最短路的 `Floyd` 算法是 $O(n^3)$ 的,会超时。\n\n实际上,我们也并不真的关心图中任意点之间的最短路,仅仅关心第一行到最后一行的最短路。\n\n因此,**我们可通过建立“虚拟源点”和“虚拟汇点”的方式,来将“多源汇最短路”问题转换为“单源最短路”问题。**\n\n具体的,我们创建一个“虚拟源点”,该点向所有第一行的点连权值为 $grid[0][i]$ 的有向边;同时创建一个“虚拟汇点”,最后一行的所有点向该点连权值为 $0$ 的有向边。\n\n问题进一步转化为:求“虚拟源点”到“虚拟汇点”的最短路。\n\n至此,我们通过 **建新图 -> 创建虚拟源汇点(转换为单源最短路)-> 套用单源最短路算法** 解决本题。\n\n将新图中点的数量记为 $n$,边数记为 $m$,朴素 `Dijkstra` 复杂度为 $O(n^2)$,堆优化的 `Dijkstra` 的复杂度为 $O(m\\log{n})$,当 $m < n^2$ (相对稀疏)时,优先使用堆优化 `Dijkstra`。\n\nJava 代码:\n```Java\nclass Solution {\n    int N = 50 * 50 + 2, M = 50 * 50 * 50, idx = 0, n;\n    int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        w[idx] = c;\n        he[a] = idx++;\n    }\n    public int minPathCost(int[][] grid, int[][] moveCost) {\n        int N = grid.length, M = grid[0].length;\n        int S = N * M, T = S + 1;\n        n = N * M + 2;\n        Arrays.fill(he, -1);\n        //「虚拟源点」向「第一行」进行连边\n        for (int i = 0; i < M; i++) add(S, grid[0][i], grid[0][i]);\n        // 转换原图\n        for (int i = 0; i < N - 1; i++) {\n            for (int j = 0; j < M; j++) {\n                int a = grid[i][j];\n                for (int k = 0; k < M; k++) {\n                    int b = grid[i + 1][k];\n                    add(a, b, moveCost[a][k] + b);\n                }\n            }\n        }\n        //「最后一行」向「虚拟汇点」进行连边\n        for (int i = 0; i < M; i++) add(grid[N - 1][i], T, 0);\n        // 最短路\n        int[] dist = dijkstra(S);\n        return dist[T];\n    }\n    int[] dijkstra(int x) {\n        // 起始先将所有的点标记为「未更新」和「距离为正无穷」\n        int[] dist = new int[n];\n        Arrays.fill(dist, 0x3f3f3f3f);\n        boolean[] vis = new boolean[n];\n        dist[x] = 0;\n        // 使用「优先队列」存储所有可用于更新的点\n        // 以 (点编号, 到起点的距离) 进行存储,优先弹出「最短距离」较小的点\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[1]-b[1]);\n        q.add(new int[]{x, 0});\n        while (!q.isEmpty()) {\n            // 每次从「优先队列」中弹出\n            int[] poll = q.poll();\n            int u = poll[0], step = poll[1];\n            // 如果弹出的点被标记「已更新」,则跳过\n            if (vis[u]) continue;\n            // 标记该点「已更新」,并使用该点更新其他点的「最短距离」\n            vis[u] = true;\n            for (int i = he[u]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (dist[j] <= dist[u] + w[i]) continue;\n                dist[j] = dist[u] + w[i];\n                q.add(new int[]{j, dist[j]});\n            }\n        }\n        return dist;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    static const int N = 50 * 50 + 2, M = 50 * 50 * 50;\n    int he[N], e[M], ne[M], w[M], idx, n, INF = 0x3f3f3f3f;\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        w[idx] = c;\n        he[a] = idx++;\n    }\n    int minPathCost(vector<vector<int>>& grid, vector<vector<int>>& moveCost) {\n        int N = grid.size(), M = grid[0].size();\n        int S = N * M, T = S + 1;\n        n = N * M + 2;\n        fill(he, he + n, -1);\n        //「虚拟源点」向「第一行」进行连边\n        for (int i = 0; i < M; i++) add(S, grid[0][i], grid[0][i]);\n        // 转换原图\n        for (int i = 0; i < N - 1; i++) {\n            for (int j = 0; j < M; j++) {\n                int a = grid[i][j];\n                for (int k = 0; k < M; k++) {\n                    int b = grid[i + 1][k];\n                    add(a, b, moveCost[a][k] + b);\n                }\n            }\n        }\n        //「最后一行」向「虚拟汇点」进行连边\n        for (int i = 0; i < M; i++) add(grid[N - 1][i], T, 0);\n        // 最短路\n        vector<int> dist = dijkstra(S);\n        return dist[T];\n    }\n    vector<int> dijkstra(int x) {\n        vector<int> dist(n, 0x3f3f3f3f);\n        vector<bool> vis(n, false);\n        dist[x] = 0;\n        // 使用「优先队列」存储所有可用于更新的点\n        // 以 (到起点的距离, 点编号) 进行存储,优先弹出「最短距离」较小的点\n        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;\n        q.push({0, x});\n        while (!q.empty()) {\n            // 每次从「优先队列」中弹出\n            auto [step, u] = q.top();\n            q.pop();\n            // 如果弹出的点被标记「已更新」,则跳过\n            if (vis[u]) continue;\n            // 标记该点「已更新」,并使用该点更新其他点的「最短距离」\n            vis[u] = true;\n            for (int i = he[u]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (dist[j] <= dist[u] + w[i]) continue;\n                dist[j] = dist[u] + w[i];\n                q.push({dist[j], j});\n            }\n        }\n        return dist;\n    }\n};\n```\nPython 代码:\n```Python\nimport heapq\n\nclass Solution:\n    def minPathCost(self, grid, moveCost):\n        N, M = len(grid), len(grid[0])\n        S, T = N * M, N * M + 1\n        n = N * M + 2\n        he = [-1] * n\n        e, ne, w = [-1] * (50 * 50 * 50), [-1] * (50 * 50 * 50), [-1] * (50 * 50 * 50)\n        idx = 0\n\n        def add(a, b, c):\n            nonlocal idx\n            e[idx] = b\n            ne[idx] = he[a]\n            w[idx] = c\n            he[a] = idx\n            idx += 1\n\n        def dijkstra(x):\n            dist = [float('inf')] * n\n            vis = [False] * n\n            dist[x] = 0\n            # 使用「优先队列」存储所有可用于更新的点\n            # 以 (到起点的距离, 点编号) 进行存储,优先弹出「最短距离」较小的点\n            q = [(0, x)]\n            heapq.heapify(q)\n            while q:\n                # 每次从「优先队列」中弹出\n                step, u = heapq.heappop(q)\n                # 如果弹出的点被标记「已更新」,则跳过\n                if vis[u]: continue\n                # 标记该点「已更新」,并使用该点更新其他点的「最短距离」\n                vis[u] = True\n                i = he[u]\n                while i != -1:\n                    j, c = e[i], w[i]\n                    i = ne[i]\n                    if dist[j] <= dist[u] + c: continue\n                    dist[j] = dist[u] + c\n                    heapq.heappush(q, (dist[j], j))\n            return dist\n\n        #「虚拟源点」向「第一行」进行连边\n        for i in range(M):\n            add(S, grid[0][i], grid[0][i])\n        # 转换原图\n        for i in range(N - 1):\n            for j in range(M):\n                a = grid[i][j]\n                for k in range(M):\n                    b = grid[i + 1][k]\n                    add(a, b, moveCost[a][k] + b)\n        #「最后一行」向「虚拟汇点」进行连边\n        for i in range(M):\n            add(grid[N - 1][i], T, 0)\n        # 最短路\n        dist = dijkstra(S)\n        return dist[T]\n```\n* 时间复杂度:$O(m\\log{n})$,其中 $n$ 为新图中的点数 $N \\times M = 2.5 \\times 10^3$,$m$ 为新图中的边数 $(M - 1) \\times N^2 = 1.25 \\times 10^5$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### 堆优化 Dijkstra\n\n什么?你说你实在不想建新图,也不想搞什么虚拟点,就想用你心爱的 `BFS` 来做?!\n\n我懂你意思,但那不叫 `BFS`。\n\n只是将「建新图」和「建虚拟点」的过程省掉,仍需要使用优先队列(堆)来每次取出当前“路径代价最小”的点来进行扩充,执行过程仍为堆优化 `Dijkstra` 的核心操作。\n\n尤其所谓“省掉” 建新图 和 建虚拟点,真就字面上的“省掉”,并非不存在,因为两种做法思路是完全一致的。可简单列举「本解法」与「解法一」的对应关系:\n\n* 起始往队列放入首行元素,对应了解法一的“建立虚拟源点”过程;\n* 从队列中取元素出来扩充时,若当前元素所在行是最后一行时,用当前路径代价来更新答案,对应了解法一的“建立虚拟汇点”过程;\n* 扩充时直接遍历列(即下一行的所有点),对应的解法一的“用原图边建新图”的过程。\n\nJava 代码:\n\n```Java\nclass Solution {\n    public int minPathCost(int[][] grid, int[][] moveCost) {\n        int m = grid.length, n = grid[0].length, INF = 0x3f3f3f3f, ans = INF;\n        int[][] dist = new int[m][n];\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) dist[i][j] = INF;\n        }\n        PriorityQueue<int[]> d = new PriorityQueue<>((a,b)->a[2]-b[2]);\n        for (int i = 0; i < n; i++) {\n            d.add(new int[]{0, i, grid[0][i]});\n            dist[0][i] = grid[0][i];\n        }\n        while (!d.isEmpty()) {\n            int[] info = d.poll();\n            int x = info[0], y = info[1], cur = info[2];\n            if (x == m - 1) {\n                ans = Math.min(ans, cur);\n                continue;\n            }\n            for (int i = 0; i < n; i++) {\n                int step = moveCost[grid[x][y]][i], ne = grid[x + 1][i];\n                int tot = cur + step + ne;\n                if (tot >= ans || dist[x + 1][i] <= tot) continue;\n                dist[x + 1][i] = tot;\n                d.add(new int[]{x + 1, i, tot});\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int minPathCost(vector<vector<int>>& grid, vector<vector<int>>& moveCost) {\n        int m = grid.size(), n = grid[0].size(), INF = 0x3f3f3f3f, ans = INF;\n        vector<vector<int>> dist(m, vector<int>(n, INF));\n        priority_queue<vector<int>, vector<vector<int>>, greater<vector<int>>> pq;\n        for (int i = 0; i < n; i++) {\n            pq.push({0, i, grid[0][i]});\n            dist[0][i] = grid[0][i];\n        }\n        while (!pq.empty()) {\n            vector<int> info = pq.top();\n            pq.pop();\n            int x = info[0], y = info[1], cur = info[2];\n            if (x == m - 1) {\n                ans = min(ans, cur);\n                continue;\n            }\n            for (int i = 0; i < n; i++) {\n                int step = moveCost[grid[x][y]][i], ne = grid[x + 1][i];\n                int tot = cur + step + ne;\n                if (tot >= ans || dist[x + 1][i] <= tot) continue;\n                dist[x + 1][i] = tot;\n                pq.push({x + 1, i, tot});\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minPathCost(self, grid, moveCost):\n        m, n, INF = len(grid), len(grid[0]), float('inf')\n        ans = INF\n        dist = [[INF] * n for _ in range(m)]\n        for i in range(n):\n            dist[0][i] = grid[0][i]\n        pq = [(0, i, grid[0][i]) for i in range(n)]\n        while pq:\n            x, y, cur = heapq.heappop(pq)\n            if x == m - 1:\n                ans = min(ans, cur)\n                continue\n            for i in range(n):\n                step, ne = moveCost[grid[x][y]][i], grid[x + 1][i]\n                tot = cur + step + ne\n                if tot >= ans or dist[x + 1][i] <= tot: continue\n                dist[x + 1][i] = tot\n                heapq.heappush(pq, (x + 1, i, tot))\n        return ans\n```\n* 时间复杂度:$O(m\\log{n})$,其中 $n$ 为新图中的点数 $N \\times M = 2.5 \\times 10^3$,$m$ 为新图中的边数 $(M - 1) \\times N^2 = 1.25 \\times 10^5$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### 原地模拟\n\n什么?你说你连图论的方法都不想用,想就着题意做一遍?\n\n可以。甚至当你调整更新方向,还能利用已有的 `grid`,实现原地模拟。\n\n具体的,我们将“从上往下走”调整为“从下往上走”,这样可以确保当我们使用底下一行 $grid[i + 1][j]$ 来更新当前行 $grid[i][j]$ 时,所用到的 $grid[i + 1][j]$ 不会被覆盖。\n\nJava 代码:\n```Java\nclass Solution {\n    public int minPathCost(int[][] grid, int[][] moveCost) {\n        int m = grid.length, n = grid[0].length, INF = 0x3f3f3f3f, ans = INF;\n        for (int i = m - 2; i >= 0; i--) {\n            for (int j = 0; j < n; j++) {\n                int cur = INF;\n                for (int k = 0; k < n; k++) cur = Math.min(cur, grid[i + 1][k] + moveCost[grid[i][j]][k]);\n                grid[i][j] += cur;\n            }\n        }\n        for (int i = 0; i < n; i++) ans = Math.min(ans, grid[0][i]);\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int minPathCost(vector<vector<int>>& grid, vector<vector<int>>& moveCost) {\n        int m = grid.size(), n = grid[0].size(), INF = INT_MAX, ans = INF;\n        for (int i = m - 2; i >= 0; i--) {\n            for (int j = 0; j < n; j++) {\n                int cur = INF;\n                for (int k = 0; k < n; k++) cur = min(cur, grid[i + 1][k] + moveCost[grid[i][j]][k]);\n                grid[i][j] += cur;\n            }\n        }\n        for (int i = 0; i < n; i++) ans = min(ans, grid[0][i]);\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minPathCost(self, grid, moveCost):\n        m, n = len(grid), len(grid[0])\n        for i in range(m - 2, -1, -1):\n            for j in range(n):\n                grid[i][j] += min([grid[i + 1][k] + moveCost[grid[i][j]][k] for k in range(n)])\n        return min([grid[0][i] for i in range(n)])\n```\nTypeScript 代码:\n```TypeScript\nfunction minPathCost(grid: number[][], moveCost: number[][]): number {\n    let m = grid.length, n = grid[0].length, INF = 0x3f3f3f3f, ans = INF;\n    for (let i = m - 2; i >= 0; i--) {\n        for (let j = 0; j < n; j++) {\n            let cur = INF;\n            for (let k = 0; k < n; k++) cur = Math.min(cur, grid[i + 1][k] + moveCost[grid[i][j]][k]);\n            grid[i][j] += cur;\n        }\n    }\n    for (let i = 0; i < n; i++) ans = Math.min(ans, grid[0][i]);\n    return ans;\n};\n```\n* 时间复杂度:$O(m \\times n^2)$,其中 $m$ 和 $n$ 分别代表给定 `grid` 的长宽\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2304` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2301-2310/2305. 公平分发饼干（中等）.md", "url_title": "2305. 公平分发饼干", "url": "https://leetcode.cn/problems/fair-distribution-of-cookies/solution/gong-shui-san-xie-jian-dan-zhuang-ya-dp-trg25/", "difficulty": "中等", "tags": ["状压 DP", "位运算"], "question": "给你一个整数数组 `cookies`,其中 `cookies[i]` 表示在第 `i` 个零食包中的饼干数量。另给你一个整数 `k` 表示等待分发零食包的孩子数量,所有零食包都需要分发。\n\n在同一个零食包中的所有饼干都必须分发给同一个孩子,不能分开。\n\n分发的不公平程度定义为单个孩子在分发过程中能够获得饼干的最大总数。\n\n返回所有分发的最小不公平程度。\n\n示例 1:\n```\n输入:cookies = [8,15,10,20,8], k = 2\n\n输出:31\n\n解释:一种最优方案是 [8,15,8] 和 [10,20] 。\n- 第 1 个孩子分到 [8,15,8] ,总计 8 + 15 + 8 = 31 块饼干。\n- 第 2 个孩子分到 [10,20] ,总计 10 + 20 = 30 块饼干。\n分发的不公平程度为 max(31,30) = 31 。\n可以证明不存在不公平程度小于 31 的分发方案。\n```\n示例 2:\n```\n输入:cookies = [6,1,3,2,2,4,1,2], k = 3\n\n输出:7\n\n解释:一种最优方案是 [6,1]、[3,2,2] 和 [4,1,2] 。\n- 第 1 个孩子分到 [6,1] ,总计 6 + 1 = 7 块饼干。 \n- 第 2 个孩子分到 [3,2,2] ,总计 3 + 2 + 2 = 7 块饼干。\n- 第 3 个孩子分到 [4,1,2] ,总计 4 + 1 + 2 = 7 块饼干。\n分发的不公平程度为 max(7,7,7) = 7 。\n可以证明不存在不公平程度小于 7 的分发方案。\n```\n\n提示:\n* $2 <= cookies.length <= 8$\n* $1 <= cookies[i] <= 10^5$\n* $2 <= k <= cookies.length$", "solution": "### 状压 DP\n\n为了方便,将 `cookies` 记为 `cs`。\n\n**定义 $f[i][s]$ 为考虑前 $i$ 个人,对 `cs` 的分配情况为 `s` 时的最小不公平程度**。\n\n其中 `s` 为一个二进制数,若 `s` 的第 `i` 位为 `1` 代表 `cs[i]` 已被分配,反之代表未分配。同时我们可以预处理 `g` 数组,`g[s] = t` 含义为选择 `cs` 状态为 `s` 时得到的饼干总和为 `t`。\n\n初始化只有 $f[0][0] = 0$,其余均为正无穷 `0x3f3f3f3f`。\n\n不失一般性考虑 $f[i][s]$ 该如何计算,**通过枚举第 $i$ 个小朋友所分配到的饼干情况 `p`(`s` 的子集)进行转移**:若第 $i$ 个小朋友分配到的饼干情况为 `p`,则此前 $i - 1$ 个小朋友分配到饼干情况为 $s - p$,前 $i - 1$ 个小朋友的最小不公平程度为 $f[i - 1][s - p]$,当前第 $i$ 个小朋友的不公平程度为 $g[p]$,两者中最大值可用于更新 $f[i][s]$。\n\n$$\nf[i][s] = \\min(f[i][s], \\max(f[i - 1][s - p], g[p])), p \\subseteq s\n$$\n\n最终 $f[k][2^n - 1]$ 即是答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int distributeCookies(int[] cs, int k) {\n        int n = cs.length, mask = 1 << n, INF = 0x3f3f3f3f;\n        int[] g = new int[mask];\n        for (int s = 0; s < mask; s++) {\n            int t = 0;\n            for (int i = 0; i < n; i++) t += ((s >> i) & 1) == 1 ? cs[i] : 0;\n            g[s] = t;\n        }\n        int[][] f = new int[k + 10][mask];\n        for (int i = 0; i <= k; i++) Arrays.fill(f[i], INF);\n        f[0][0] = 0;\n        for (int i = 1; i <= k; i++) {\n            for (int s = 0; s < mask; s++) {\n                for (int p = s; p != 0; p = (p - 1) & s) {\n                    f[i][s] = Math.min(f[i][s], Math.max(f[i - 1][s - p], g[p]));\n                }\n            }\n        }\n        return f[k][mask - 1];\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def distributeCookies(self, cs: List[int], k: int) -> int:\n        n, mask, INF = len(cs), 1 << len(cs), 0x3f3f3f3f\n        g = [0] * mask\n        for s in range(mask):\n            t = 0\n            for i in range(n):\n                t += cs[i] if (s >> i) & 1 == 1 else 0\n            g[s] = t\n        f = [[INF] * mask for _ in range(k + 10)]\n        f[0][0] = 0\n        for i in range(1, k + 1):\n            for s in range(mask):\n                p = s\n                while p != 0:\n                    f[i][s] = min(f[i][s], max(f[i - 1][s - p], g[p]))\n                    p = (p - 1) & s\n        return f[k][mask - 1]\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int distributeCookies(vector<int>& cs, int k) {\n        int n = cs.size(), mask = 1 << n, INF = 0x3f3f3f3f;\n        vector<int> g(mask, 0);\n        for (int s = 0; s < mask; s++) {\n            int t = 0;\n            for (int i = 0; i < n; i++) t += ((s >> i) & 1) == 1 ? cs[i] : 0;\n            g[s] = t;\n        }\n        vector<vector<int>> f(k + 10, vector<int>(mask, INF));\n        for (int i = 0; i <= k; i++) fill(f[i].begin(), f[i].end(), INF);\n        f[0][0] = 0;\n        for (int i = 1; i <= k; i++) {\n            for (int s = 0; s < mask; s++) {\n                for (int p = s; p != 0; p = (p - 1) & s) {\n                    f[i][s] = min(f[i][s], max(f[i - 1][s - p], g[p]));\n                }\n            }\n        }\n        return f[k][mask - 1];\n    }\n};\n```\nTypeScirpt 代码:\n```TypeScript\nfunction distributeCookies(cs: number[], k: number): number {\n    const n = cs.length, mask = 1 << n, INF = 0x3f3f3f3f;\n    const g = new Array(mask).fill(0);\n    for (let s = 0; s < mask; s++) {\n        let t = 0;\n        for (let i = 0; i < n; i++) t += ((s >> i) & 1) === 1 ? cs[i] : 0;\n        g[s] = t;\n    }\n    const f = new Array(k + 10).fill(0).map(() => new Array(mask).fill(INF));\n    f[0][0] = 0;\n    for (let i = 1; i <= k; i++) {\n        for (let s = 0; s < mask; s++) {\n            for (let p = s; p != 0; p = (p - 1) & s) {\n                f[i][s] = Math.min(f[i][s], Math.max(f[i - 1][s - p], g[p]));\n            }\n        }\n    }\n    return f[k][mask - 1];\n};\n```\n* 时间复杂度:将 `cs` 长度记为 $n$,状态数量记为 $m = 2^n$,预处理复杂度为 $O(n \\times m)$;`DP` 过程需要枚举二进制长度为 $n$ 的所有子集的子集,复杂度为 $O(3^n)$,`DP` 过程复杂度为 $O(k \\times 3^n)$。整体复杂度为 $O(k \\times 3^n)$\n* 空间复杂度:$O(k \\times m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2305` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/231-240/231. 2 的幂（简单）.md", "url_title": "231. 2 的幂", "url": "https://leetcode-cn.com/problems/power-of-two/solution/gong-shui-san-xie-2-de-mi-by-ac_oier-qm6e/", "difficulty": "简单", "tags": ["数学", "位运算"], "question": "给你一个整数 n,请你判断该整数是否是 2 的幂次方。如果是,返回 true ;否则,返回 false 。\n\n如果存在一个整数 x 使得 n == $2^x$ ,则认为 n 是 2 的幂次方。\n\n示例 1:\n```\n输入:n = 1\n输出:true\n解释:20 = 1\n```\n示例 2:\n```\n输入:n = 16\n输出:true\n解释:24 = 16\n```\n示例 3:\n```\n输入:n = 3\n输出:false\n```\n示例 4:\n```\n输入:n = 4\n输出:true\n```\n示例 5:\n```\n输入:n = 5\n输出:false\n```\n\n提示:\n* -$2^{31}$ <= n <= $2^{31}$ - 1\n\n进阶:你能够不使用循环/递归解决此问题吗?", "solution": "### 朴素做法\n\n首先小于等于 $0$ 的数必然不是,$1$ 必然是。\n\n在处理完这些边界之后,尝试将 $n$ 除干净,如果最后剩余数值为 $1$ 则说明开始是 $2$ 的幂。\n\n代码:\n```Java\nclass Solution {\n    public boolean isPowerOfTwo(int n) {\n        if (n <= 0) return false;\n        while (n % 2 == 0) n /= 2;\n        return n == 1;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### lowbit\n\n熟悉树状数组的同学都知道,`lowbit` 可以快速求得 `x` 二进制表示中最低位  `1` 表示的值。\n\n如果一个数 $n$ 是 $2$ 的幂,那么有 `lowbit(n) = n` 的性质($2$ 的幂的二进制表示中必然是最高位为 $1$,低位为 $0$)。\n\n代码;\n```Java\nclass Solution {\n    public boolean isPowerOfTwo(int n) {\n        return n > 0 && (n & -n) == n;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.231` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/231-240/232. 用栈实现队列（简单）.md", "url_title": "232. 用栈实现队列", "url": "https://leetcode-cn.com/problems/implement-queue-using-stacks/solution/sha-shi-jun-tan-fu-za-du-ya-wo-de-suan-f-gb6d/", "difficulty": "简单", "tags": ["栈", "队列"], "question": "请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作(push、pop、peek、empty):\n\n实现 MyQueue 类:\n\n* void push(int x) 将元素 x 推到队列的末尾\n* int pop() 从队列的开头移除并返回元素\n* int peek() 返回队列开头的元素\n* boolean empty() 如果队列为空,返回 true ;否则,返回 false\n\n说明:\n* 你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。\n* 你所使用的语言也许不支持栈。你可以使用 list 或者 deque(双端队列)来模拟一个栈,只要是标准的栈操作即可。\n\n进阶:\n* 你能否实现每个操作均摊时间复杂度为 O(1) 的队列?换句话说,执行 n 个操作的总时间复杂度为 O(n) ,即使其中一个操作可能花费较长时间。\n\n示例:\n```\n输入:\n[\"MyQueue\", \"push\", \"push\", \"peek\", \"pop\", \"empty\"]\n[[], [1], [2], [], [], []]\n输出:\n[null, null, null, 1, 1, false]\n\n解释:\nMyQueue myQueue = new MyQueue();\nmyQueue.push(1); // queue is: [1]\nmyQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)\nmyQueue.peek(); // return 1\nmyQueue.pop(); // return 1, queue is [2]\nmyQueue.empty(); // return false\n```\n\n提示:\n* 1 <= x <= 9\n* 最多调用 100 次 push、pop、peek 和 empty\n* 假设所有操作都是有效的 (例如,一个空的队列不会调用 pop 或者 peek 操作)", "solution": "### 基本思路\n\n无论「用栈实现队列」还是「用队列实现栈」,思路都是类似的。\n\n都可以通过使用两个栈/队列来解决。\n\n我们创建两个栈,分别为 `out` 和 `in`,用作处理「输出」和「输入」操作。\n\n其实就是两个栈来回「倒腾」。\n\n而对于「何时倒腾」决定了是 **O(n) 解法** 还是 **均摊 O(1) 解法**。\n\n***\n\n### O(n) 解法\n\n我们创建两个栈,分别为 `out` 和 `in`:\n\n* **`in` 用作处理输入操作 `push()`,使用 `in` 时需确保 `out` 为空**\n* **`out` 用作处理输出操作 `pop()` 和 `peek()`,使用 `out` 时需确保 `in` 为空**\n\n```java\nclass MyQueue {\n    Deque<Integer> out, in;\n    public MyQueue() {\n        in = new ArrayDeque<>();\n        out = new ArrayDeque<>();\n    }\n    \n    public void push(int x) {\n        while (!out.isEmpty()) in.addLast(out.pollLast());\n        in.addLast(x);\n    }\n    \n    public int pop() {\n        while (!in.isEmpty()) out.addLast(in.pollLast());\n        return out.pollLast();\n    }\n    \n    public int peek() {\n        while (!in.isEmpty()) out.addLast(in.pollLast());\n        return out.peekLast();\n    }\n    \n    public boolean empty() {\n        return out.isEmpty() && in.isEmpty();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 均摊 O(1) 解法\n\n事实上,我们不需要在每次的「入栈」和「出栈」操作中都进行「倒腾」。\n\n**我们只需要保证,输入的元素总是跟在前面的输入元素的后面,而输出元素总是最早输入的那个元素即可。**\n\n可以通过调整「倒腾」的时机来确保满足上述要求,但又不需要发生在每一次操作中:\n\n* **只有在「输出栈」为空的时候,才发生一次性的「倒腾」**\n\n```java\nclass MyQueue {\n    Deque<Integer> out, in;\n    public MyQueue() {\n        in = new ArrayDeque<>();\n        out = new ArrayDeque<>();\n    }\n    \n    public void push(int x) {\n        in.addLast(x);\n    }\n    \n    public int pop() {\n        if (out.isEmpty()) {\n            while (!in.isEmpty()) out.addLast(in.pollLast());\n        }\n        return out.pollLast();\n    }\n    \n    public int peek() {\n        if (out.isEmpty()) {\n            while (!in.isEmpty()) out.addLast(in.pollLast());\n        }\n        return out.peekLast();\n    }\n    \n    public boolean empty() {\n        return out.isEmpty() && in.isEmpty();\n    }\n}\n```\n* 时间复杂度:`pop()` 和 `peek()` 操作都是均摊 $O(1)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 关于「均摊复杂度」的说明\n\n我们先用另外一个例子来理解「均摊复杂度」,大家都知道「哈希表」底层是通过数组实现的。\n\n正常情况下,计算元素在哈希桶的位置,然后放入哈希桶,复杂度为 $O(1)$,假定是通过简单的“拉链法”搭配「头插法」方式来解决哈希冲突。\n\n但当某次元素插入后,「哈希表」达到扩容阈值,则需要对底层所使用的数组进行扩容,这个复杂度是 $O(n)$\n\n显然「扩容」操作不会发生在每一次的元素插入中,因此扩容的 $O(n)$ 都会伴随着 `n` 次的 $O(1)$,也就是 $O(n)$ 的复杂度会被均摊到每一次插入当中,因此哈希表插入仍然是 $O(1)$ 的。\n\n**同理,我们的「倒腾」不是发生在每一次的「输出操作」中,而是集中发生在一次「输出栈为空」的时候,因此 `pop` 和 `peek` 都是均摊复杂度为 $O(1)$ 的操作。**\n\n由于本题的调用次数只有 100 次,所以铁定是一个人均 100% 的算法(0 ms)🐶 🐶\n\n我们需要对操作进行复杂度分析进行判断,而不是看时间来判断自己是不是均摊 O(1) 哦 ~", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.232` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/231-240/233. 数字 1 的个数（困难）.md", "url_title": "233. 数字 1 的个数", "url": "https://leetcode-cn.com/problems/number-of-digit-one/solution/gong-shui-san-xie-jiang-shu-wei-dp-wen-t-c9oi/", "difficulty": "困难", "tags": ["动态规划", "数位 DP", "模拟"], "question": "给定一个整数 $n$,计算所有小于等于 $n$ 的非负整数中数字 $1$ 出现的个数。\n\n示例 1:\n```\n输入:n = 13\n\n输出:6\n```\n示例 2:\n```\n输入:n = 0\n\n输出:0\n```\n\n提示:\n* 0 <= n <= $2 * 10^9$", "solution": "### 基本分析\n\n这是一道经典的「数位 DP」模板题的简化版,原题在 [这里](https://www.luogu.com.cn/problem/P1980) 。\n\n这几天每日一题出得挺好,「序列 DP」、「区间 DP」、「数位 DP」轮着来 🤣\n\n但由于本题只需求 $1$ 出现的次数,而不需要求解 $0$ 到 $9$ 的出现次数,同时意味着不需要考虑统计 $0$ 次数时的前导零边界问题。\n\n因此,也可以不当作数位 DP 题来做,只当作一道计数类模拟题来求解。\n\n---\n\n### 计数类模拟\n\n回到本题,我们需要计算 $[1, n]$ 范围内所有数中 $1$ 出现的次数。\n\n我们可以统计 $1$ 在每一位出现的次数,将其累加起来即是答案。\n\n举个 🌰,对于一个长度为 $m$ 的数字 $n$,我们可以计算其在「个位(从右起第 $1$ 位)」、「十位(第 $2$ 位)」、「百位(第 $3$ 位)」和「第 $m$ 位」中 $1$ 出现的次数。\n\n假设有 $n = abcde$,即 $m = 5$,假设我们需要统计第 $3$ 位中 $1$ 出现的次数,即可统计满足 $--1--$ 形式,同时满足 $1 <= --1-- <= abcde$ 要求的数有多少个,我们称 $1 <= --1-- <= abcde$ 关系为「大小要求」。\n\n我们只需对 $c$ 前后出现的值进行分情况讨论:\n\n* 当 $c$ 前面的部分 $< ab$,即范围为 $[0, ab)$,此时必然满足「大小要求」,因此后面的部分可以任意取,即范围为 $[0, 99]$。根据「乘法原理」,可得知此时数量为 $ab * 100$;\n* 当 $c$ 前面的部分 $= ab$,这时候「大小关系」主要取决于 $c$:\n    * 当 $c = 0$,必然不满足「大小要求」,数量为 $0$;\n    * 当 $c = 1$,此时「大小关系」取决于后部分,后面的取值范围为 $[0, de]$,数量为 $1 * (de + 1)$;\n    * 当 $c > 1$,必然满足「大小关系」,后面的部分可以任意取,即范围为 $[0, 99]$,数量为 $1 * 100$;\n* 当 $c$ 前面的部分 $> ab$,必然不满足「大小要求」,数量为 $0$。\n\n其他数位的分析同理。\n\n代码:\n```Java\nclass Solution {\n    public int countDigitOne(int n) {\n        String s = String.valueOf(n);\n        int m = s.length();\n        if (m == 1) return n > 0 ? 1 : 0;\n        // 计算第 i 位前缀代表的数值,和后缀代表的数值\n        // 例如 abcde 则有 ps[2] = ab; ss[2] = de\n        int[] ps = new int[m], ss = new int[m];\n        ss[0] = Integer.parseInt(s.substring(1));\n        for (int i = 1; i < m - 1; i++) {\n            ps[i] = Integer.parseInt(s.substring(0, i));\n            ss[i] = Integer.parseInt(s.substring(i + 1));\n        }\n        ps[m - 1] = Integer.parseInt(s.substring(0, m - 1));\n        // 分情况讨论\n        int ans = 0;\n        for (int i = 0; i < m; i++) {\n            // x 为当前位数值,len 为当前位后面长度为多少\n            int x = s.charAt(i) - '0', len = m - i - 1;\n            int prefix = ps[i], suffix = ss[i];\n            int tot = 0;\n            tot += prefix * Math.pow(10, len);\n            if (x == 0) {\n            } else if (x == 1) {\n                tot += suffix + 1;\n            } else {\n                tot += Math.pow(10, len);\n            }\n            ans += tot;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(m)$\n* 空间复杂度:$O(m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.233` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/231-240/235. 二叉搜索树的最近公共祖先（中等）.md", "url_title": "235. 二叉搜索树的最近公共祖先", "url": "https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree/solution/gong-shui-san-xie-yun-yong-dfs-qiu-jie-l-n3jh/", "difficulty": "中等", "tags": ["二叉树", "DFS", "递归"], "question": "给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。\n\n百度百科中最近公共祖先的定义为:“对于有根树 `T` 的两个结点 `p`、`q`,最近公共祖先表示为一个结点 `x`,满足 `x` 是 `p`、`q` 的祖先且 `x` 的深度尽可能大(一个节点也可以是它自己的祖先)。”\n\n例如,给定如下二叉搜索树:  `root = [6,2,8,0,4,7,9,null,null,3,5]`\n\n示例 1:\n\n```\n输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8\n\n输出: 6 \n\n解释: 节点 2 和节点 8 的最近公共祖先是 6。\n```\n示例 2:\n```\n输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4\n\n输出: 2\n\n解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。\n```\n\n说明:\n* 所有节点的值都是唯一的。\n* `p`、`q` 为不同节点且均存在于给定的二叉搜索树中。", "solution": "### DFS\n\n也是常见的 `LCA` 问题,但相比 [236. 二叉树的最近公共祖先](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247500218&idx=1&sn=a6d790dcecfee353be5f3b53c312c3d4&chksm=fd9f6aa5cae8e3b36d85448674b189ed2d35fdce18381ac7676ec90a33d62da05718f85e3103#rd),本题搜索对象为二叉搜索树,利用此特性,我们可以将搜索复杂度从 $O(n)$ 优化至 $O(h)$。\n\n利用原函数作为递归函数,复用 `root` 作为搜索过程中的当前节点,根据 `root` 和两节点关系进行分情况讨论:\n\n* 若 `root` 为 `p` 和 `q` 中的任一节点:由于搜索过程是从上往下,因此 `root` 必然是距离两者垂直距离最远的最近公共祖先,返回 `root`;\n* 否则根据 `root` 和 `p`、`q` 的节点值大小进一步讨论,将 `root` 节点值记为 `a`,两节点值中的较小值记为 `b`,两节点中的较大值记为 `c`:\n  * 若有 $b < a < c$,说明 `p` 和 `q` 中值较小的节点在当前节点 `root` 的左子树内,`p` 和 `q` 中值较大的节点在当前节点 `root` 的右子树内。由于搜索过程是从上往下,因此 `root` 作为首个满足该条件的节点,必然是距离两者垂直距离最远的最近公共祖先,返回 `root`;\n  * 若有 $a < b$,说明两节点均在当前节点 `root` 的右子树内,递归处理 `root.right`;\n  * 若有 $a > c$,说明两节点均在当前节点 `root` 的左子树内,递归处理 `root.left`。\n\nJava 代码:\n```Java\nclass Solution {\n    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {\n        if (root == p || root == q) return root;\n        int a = root.val, b = Math.min(p.val, q.val), c = Math.max(p.val, q.val);\n        if (a > b && a < c) return root;\n        else if (a < b) return lowestCommonAncestor(root.right, p, q);\n        else return lowestCommonAncestor(root.left, p, q);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n        if (root == p || root == q) return root;\n        int a = root->val, b = min(p->val, q->val), c = max(p->val, q->val);\n        if (a > b && a < c) return root;    \n        else if (a < b) return lowestCommonAncestor(root->right, p, q);    \n        else return lowestCommonAncestor(root->left, p, q);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':\n        if root == p or root == q:\n            return root\n        a, b = root.val, min(p.val, q.val)\n        c = max(p.val, q.val)\n        if a > b and a < c:\n            return root\n        elif a < b:\n            return self.lowestCommonAncestor(root.right, p, q)\n        else:\n            return self.lowestCommonAncestor(root.left, p, q)\n```\nTypeScript 代码:\n```TypeScript\nfunction lowestCommonAncestor(root: TreeNode | null, p: TreeNode | null, q: TreeNode | null): TreeNode | null {\n    if (root === p || root === q) return root;\n    const a = root.val, b = Math.min(p.val, q.val), c = Math.max(p.val, q.val);\n    if (a > b && a < c) return root;\n    else if (a < b) return lowestCommonAncestor(root.right, p, q);\n    else return lowestCommonAncestor(root.left, p, q);\n};\n```\n* 时间复杂度:$O(h)$,其中 $h$ 为二叉搜索树的深度\n* 空间复杂度:$O(h)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.235` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/231-240/236. 二叉树的最近公共祖先（中等）.md", "url_title": "236. 二叉树的最近公共祖先", "url": "https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/solutions/2402113/gong-shui-san-xie-yun-yong-dfs-qiu-jie-l-htd9/", "difficulty": "中等", "tags": ["二叉树", "DFS", "递归"], "question": "给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。\n\n百度百科中最近公共祖先的定义为:“对于有根树 T 的两个节点 `p`、`q`,最近公共祖先表示为一个节点 `x`,满足 `x` 是 `p`、`q` 的祖先且 `x` 的深度尽可能大(一个节点也可以是它自己的祖先)。”\n\n示例 1:\n\n```\n输入:root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1\n\n输出:3\n\n解释:节点 5 和节点 1 的最近公共祖先是节点 3 。\n```\n示例 2:\n\n```\n输入:root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4\n\n输出:5\n\n解释:节点 5 和节点 4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。\n```\n示例 3:\n```\n输入:root = [1,2], p = 1, q = 2\n\n输出:1\n```\n\n提示:\n* 树中节点数目在范围 $[2, 10^5]$ 内。\n* $-10^9 <= Node.val <= 10^9$\n* 所有 `Node.val` 互不相同 。\n* $p != q$\n* `p` 和 `q` 均存在于给定的二叉树中。", "solution": "### DFS\n\n常见的 `LCA` 问题。\n\n设计 `DFS` 函数 `boolean dfs(TreeNode cur, TreeNode t, List<TreeNode> path)`:其中 **`cur` 为当前处理到的节点,`t` 为需要找到的目的节点,`path` 为从根节点到当前节点 `cur` 所经过的路径**。若能够以当前节点 `cur` 为根的子树包含目标节点 `t`,函数返回 `true`,否则返回 `false`。z\n\n调用函数分别传入 `p` 和 `q` 作为目标节点,从而得到从根节点到 `p` 和 `q` 的路径列表,遍历路径找到最后一个相同的节点即是答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {\n        List<TreeNode> a = new ArrayList<>(), b = new ArrayList<>();\n        dfs(root, p, a); dfs(root, q, b);\n        TreeNode ans = null;\n        for (int i = 0; i < Math.min(a.size(), b.size()) && a.get(i) == b.get(i); i++) ans = a.get(i);\n        return ans;\n    }\n    boolean dfs(TreeNode cur, TreeNode t, List<TreeNode> path) {\n        if (cur == null) return false;\n        path.add(cur);\n        if (cur == t || dfs(cur.left, t, path) || dfs(cur.right, t, path)) {\n            return true;\n        } else {\n            path.remove(path.size() - 1);\n            return false;\n        }\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {\n        vector<TreeNode*> a, b;\n        dfs(root, p, a); dfs(root, q, b);\n        TreeNode* ans = nullptr;\n        for (int i = 0; i < min(a.size(), b.size()) && a[i] == b[i]; i++) ans = a[i];\n        return ans;\n    }\n    bool dfs(TreeNode* cur, TreeNode* t, vector<TreeNode*>& path) {\n        if (!cur) return false;\n        path.push_back(cur);\n        if (cur == t || dfs(cur->left, t, path) || dfs(cur->right, t, path)) {\n            return true;\n        } else {\n            path.pop_back();\n            return false;\n        }\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':\n        def dfs(cur, t, path):\n            if not cur:\n                return False\n            path.append(cur)\n            if cur == t or dfs(cur.left, t, path) or dfs(cur.right, t, path):\n                return True\n            else:\n                path.pop()\n                return False\n        a, b = [], []\n        dfs(root, p, a)\n        dfs(root, q, b)\n        ans = None\n        for i in range(min(len(a), len(b))):\n            if a[i] == b[i]:\n                ans = a[i]\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction lowestCommonAncestor(root: TreeNode | null, p: TreeNode | null, q: TreeNode | null): TreeNode | null {\n    const a = [], b = [];\n    dfs(root, p, a);\n    dfs(root, q, b);\n    let ans = null;\n    for (let i = 0; i < Math.min(a.length, b.length) && a[i] === b[i]; i++) ans = a[i];\n    return ans;\n}\nfunction dfs(cur: TreeNode | null, t: TreeNode | null, path: TreeNode[]): boolean {\n    if (!cur) return false;\n    path.push(cur);\n    if (cur === t || dfs(cur.left, t, path) || dfs(cur.right, t, path)) {\n        return true;\n    } else {\n        path.pop();\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.236` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/231-240/237. 删除链表中的节点（简单）.md", "url_title": "237. 删除链表中的节点", "url": "https://leetcode-cn.com/problems/delete-node-in-a-linked-list/solution/gong-shui-san-xie-jian-dan-lian-biao-mo-rovcb/", "difficulty": "简单", "tags": ["模拟", "链表", "脑筋急转弯"], "question": "请编写一个函数,用于**删除单链表中某个特定节点 **。\n\n在设计函数时需要注意,你无法访问链表的头节点 head ,只能直接访问**要被删除的节点**。\n\n题目数据保证需要删除的节点 不是末尾节点 。\n\n示例 1:\n\n```\n输入:head = [4,5,1,9], node = 5\n\n输出:[4,1,9]\n\n解释:指定链表中值为 5 的第二个节点,那么在调用了你的函数之后,该链表应变为 4 -> 1 -> 9\n```\n示例 2:\n\n```\n输入:head = [4,5,1,9], node = 1\n\n输出:[4,5,9]\n\n解释:指定链表中值为 1 的第三个节点,那么在调用了你的函数之后,该链表应变为 4 -> 5 -> 9\n```\n示例 3:\n```\n输入:head = [1,2,3,4], node = 3\n\n输出:[1,2,4]\n```\n示例 4:\n```\n输入:head = [0,1], node = 0\n\n输出:[1]\n```\n示例 5:\n```\n输入:head = [-3,5,-99], node = -3\n\n输出:[5,-99]\n```\n\n提示:\n* 链表中节点的数目范围是 [2, 1000]\n* -1000 <= Node.val <= 1000\n* 链表中每个节点的值都是唯一的\n* 需要删除的节点 node 是 链表中的一个有效节点 ,且 不是末尾节点", "solution": "### 模拟\n\n对于一般性的链表删除操作而言,我们需要知道待删除节点的前一节点与后一节点,并对两者建立联系。\n\n对于本题,由于我们只知道待删除节点本身,同时该链表为单链表(无法访问前一节点),因此我们只能先将后一节点的值复制到当前节点,然后将后一节点当作「待删除节点」来进行常规删除。\n\n代码:\n```Java\nclass Solution {\n    public void deleteNode(ListNode node) {\n        node.val = node.next.val;\n        node.next = node.next.next;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.237` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/231-240/238. 除自身以外数组的乘积（中等）.md", "url_title": "238. 除自身以外数组的乘积", "url": "https://leetcode.cn/problems/product-of-array-except-self/solution/by-ac_oier-fqp3/", "difficulty": "中等", "tags": ["前缀和", "容斥原理"], "question": "给你一个整数数组 `nums`,返回 数组 `answer`,其中 $answer[i]$ 等于 `nums` 中除 $nums[i]$ 之外其余各元素的乘积 。\n\n题目数据 保证 数组 `nums` 之中任意元素的全部前缀元素和后缀的乘积都在  $32$ 位 整数范围内。\n\n请不要使用除法,且在 $O(n)$ 时间复杂度内完成此题。\n\n示例 1:\n```\n输入: nums = [1,2,3,4]\n\n输出: [24,12,8,6]\n```\n示例 2:\n```\n输入: nums = [-1,1,0,-3,3]\n\n输出: [0,0,9,0,0]\n```\n\n提示:\n* $2 <= nums.length <= 10^5$\n* $-30 <= nums[i] <= 30$\n* 保证 数组 `nums` 之中任意元素的全部前缀元素和后缀的乘积都在  $32$ 位 整数范围内\n\n进阶:你可以在 $O(1)$ 的额外空间复杂度内完成这个题目吗?( 出于对空间复杂度分析的目的,输出数组不被视为额外空间。)", "solution": "### 前缀和\n\n根据题意,对于每个 $ans[i]$ 均由两部分组成:\n\n$$\n(nums[0] \\times nums[1] \\times ... \\times nums[i - 1]) \\times (nums[i + 1] \\times nums[i + 2] \\times ... \\times nums[n - 1])\n$$\n\n因此我们可以运用「前缀和」思想,使用数组 `s1` 和 `s2` 分别计算范围 $[1, x]$ 的前缀乘 和 范围 $[x, n]$ 的后缀乘法(前缀和数组下标默认从 $1$ 开始),即 $s1[i]$ 代表范围 $[1,i]$ 的前缀乘值,$s2[i]$ 代表范围 $[i, n]$ 的后缀乘值。\n\n预处理完 `s1` 和 `s2` 之后,即可计算每个 $ans[i - 1] = s1[i - 1] \\times s2[i + 1]$(`ans` 数组下标从 $0$ 开始)。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] productExceptSelf(int[] nums) {\n        int n = nums.length;\n        int[] s1 = new int[n + 10], s2 = new int[n + 10];\n        s1[0] = s2[n + 1] = 1;\n        for (int i = 1; i <= n; i++) s1[i] = s1[i - 1] * nums[i - 1];\n        for (int i = n; i >= 1; i--) s2[i] = s2[i + 1] * nums[i - 1];\n        int[] ans = new int[n];\n        for (int i = 1; i <= n; i++) ans[i - 1] = s1[i - 1] * s2[i + 1];\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> productExceptSelf(vector<int>& nums) {\n        int n = nums.size();\n        vector<int> s1(n + 2, 1), s2(n + 2, 1);\n        for (int i = 1; i <= n; i++) s1[i] = s1[i - 1] * nums[i - 1];\n        for (int i = n; i >= 1; i--) s2[i] = s2[i + 1] * nums[i - 1];        \n        vector<int> ans(n);\n        for (int i = 1; i <= n; i++) ans[i - 1] = s1[i - 1] * s2[i + 1];\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def productExceptSelf(self, nums: List[int]) -> List[int]:\n        n = len(nums)\n        s1, s2 = [1] * (n + 2), [1] * (n + 2)\n        for i in range(1, n + 1):\n            s1[i] = s1[i - 1] * nums[i - 1]\n        for i in range(n, 0, -1):\n            s2[i] = s2[i + 1] * nums[i - 1]\n        ans = [s1[i - 1] * s2[i + 1] for i in range(1, n + 1)]\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction productExceptSelf(nums: number[]): number[] {\n    const n = nums.length;\n    const s1 = new Array(n + 2).fill(1), s2 = new Array(n + 2).fill(1);\n    for (let i = 1; i <= n; i++) s1[i] = s1[i - 1] * nums[i - 1];\n    for (let i = n; i >= 1; i--) s2[i] = s2[i + 1] * nums[i - 1];\n    const ans = new Array(n);\n    for (let i = 1; i <= n; i++) ans[i - 1] = s1[i - 1] * s2[i + 1];\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 前缀和(空间优化)\n\n题目的进阶部分要求我们使用 $O(1)$ 空间来做(不算 `ans` 数组)。\n\n这样很好处理,按照我们解法一的思路,将两部分分开算即可:建立 `ans` 数组,先从前往后遍历 `nums`,计算每个 $ans[i]$ 前缀乘值部分,再从后往前遍历 `nums`,计算每个 $ans[i]$ 后缀乘值的部分,两部分相乘即是最终的 $ans[i]$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] productExceptSelf(int[] nums) {\n        int n = nums.length;\n        int[] ans = new int[n];\n        for (int i = 1, j = 1; i <= n; i++) {\n            ans[i - 1] = j; j *= nums[i - 1];\n        }\n        for (int i = n, j = 1; i >= 1; i--) {\n            ans[i - 1] *= j; j *= nums[i - 1];\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> productExceptSelf(vector<int>& nums) {\n        int n = nums.size();\n        vector<int> ans(n, 1);\n        for (int i = 1, j = 1; i <= n; i++) {\n            ans[i - 1] = j; j *= nums[i - 1];\n        }\n        for (int i = n, j = 1; i >= 1; i--) {\n            ans[i - 1] *= j; j *= nums[i - 1];\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def productExceptSelf(self, nums: List[int]) -> List[int]:\n        n = len(nums)\n        ans = [1] * n\n        j = 1\n        for i in range(1, n + 1):\n            ans[i - 1] *= j\n            j *= nums[i - 1]\n        j = 1\n        for i in range(n, 0, -1):\n            ans[i - 1] *= j\n            j *= nums[i - 1]\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction productExceptSelf(nums: number[]): number[] {\n    const n = nums.length;\n    const ans = new Array(n).fill(1);\n    for (let i = 1, j = 1; i <= n; i++) {\n        ans[i - 1] *= j; j *= nums[i - 1];\n    }\n    for (let i = n, j = 1; i >= 1; i--) {\n        ans[i - 1] *= j; j *= nums[i - 1];\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.238` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/231-240/239. 滑动窗口最大值（困难）.md", "url_title": "239. 滑动窗口最大值", "url": "https://leetcode.cn/problems/sliding-window-maximum/solution/by-ac_oier-o89l/", "difficulty": "困难", "tags": ["优先队列(堆)", "线段树", "分块", "单调队列", "RMQ"], "question": "给你一个整数数组 `nums`,有一个大小为 `k` 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 `k` 个数字。滑动窗口每次只向右移动一位。\n\n返回滑动窗口中的最大值 。\n\n示例 1:\n```\n输入:nums = [1,3,-1,-3,5,3,6,7], k = 3\n\n输出:[3,3,5,5,6,7]\n\n解释:\n滑动窗口的位置                最大值\n---------------               -----\n[1  3  -1] -3  5  3  6  7       3\n 1 [3  -1  -3] 5  3  6  7       3\n 1  3 [-1  -3  5] 3  6  7       5\n 1  3  -1 [-3  5  3] 6  7       5\n 1  3  -1  -3 [5  3  6] 7       6\n 1  3  -1  -3  5 [3  6  7]      7\n```\n示例 2:\n```\n输入:nums = [1], k = 1\n\n输出:[1]\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $-10^4 <= nums[i] <= 10^4$\n* $1 <= k <= nums.length$", "solution": "### 优先队列(堆)\n\n根据题意,容易想到优先队列(大根堆),同时为了确保滑动窗口的大小合法性,我们以二元组 $(idx, nums[idx])$ 的形式进行入队。\n\n当下标达到首个滑动窗口的右端点后,每次尝试从优先队列(大根堆)中取出最大值(若堆顶元素的下标小于当前滑动窗口左端点时,则丢弃该元素)。\n\n代码:\n```Java \nclass Solution {\n    public int[] maxSlidingWindow(int[] nums, int k) {\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->b[1]-a[1]);\n        int n = nums.length, m = n - k + 1, idx = 0;\n        int[] ans = new int[m];\n        for (int i = 0; i < n; i++) {\n            q.add(new int[]{i, nums[i]});\n            if (i >= k - 1) {\n                while (q.peek()[0] <= i - k) q.poll();\n                ans[idx++] = q.peek()[1];\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 线段树 \n\n容易将问题转换为「区间求和」问题:使用原始的 `nums` 构建线段树等价于在位置 $i$ 插入 $nums[i]$,即单点操作,而查询每个滑动窗口最大值,则对应的区间查询。\n\n由于只涉及单点修改,无须实现懒标记 `pushdown` 操作,再结合 $n$ 的数据范围为 $10^5$,无须进行动态开点。\n\n直接写 `build` 四倍空间的线段树数组实现即可。\n\n代码:\n```Java \nclass Solution {\n    class Node {\n        int l, r, val;\n        Node (int _l, int _r) {\n            l = _l; r = _r; val = Integer.MIN_VALUE;\n        }\n    }\n    Node[] tr = new Node[100010 * 4];\n    void build(int u, int l, int r) {\n        tr[u] = new Node(l, r);\n        if (l == r) return ;\n        int mid = l + r >> 1;\n        build(u << 1, l, mid);\n        build(u << 1 | 1, mid + 1, r);\n    }\n    void update(int u, int x, int v) {\n        if (tr[u].l == x && tr[u].r == x) {\n            tr[u].val = Math.max(tr[u].val, v);\n            return ;\n        }\n        int mid = tr[u].l + tr[u].r >> 1;\n        if (x <= mid) update(u << 1, x, v);\n        else update(u << 1 | 1, x, v);\n        pushup(u);\n    }\n    int query(int u, int l, int r) {\n        if (l <= tr[u].l && tr[u].r <= r) return tr[u].val;\n        int mid = tr[u].l + tr[u].r >> 1, ans = Integer.MIN_VALUE;\n        if (l <= mid) ans = query(u << 1, l, r);\n        if (r > mid) ans = Math.max(ans, query(u << 1 | 1, l, r));\n        return ans;\n    }\n    void pushup(int u) {\n        tr[u].val = Math.max(tr[u << 1].val, tr[u << 1 | 1].val);\n    }\n    public int[] maxSlidingWindow(int[] nums, int k) {\n        int n = nums.length, m = n - k + 1;\n        int[] ans = new int[m];\n        build(1, 1, n);\n        for (int i = 0; i < n; i++) update(1, i + 1, nums[i]);\n        for (int i = k; i <= n; i++) ans[i - k] = query(1, i - k + 1, i);\n        return ans;\n    }\n}\n```\n* 时间复杂度:建立线段树复杂度为 $O(n\\log{n})$;构建答案复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 分块\n\n另外一个做法是分块,又名「优雅的暴力」,也是莫队算法的基础。\n\n具体的,除了给定的 `nums` 以外,我们构建一个分块数组 `region`,其中 `region[idx] = x` 含义为块编号为 `idx` 的最大值为 `x`,其中一个块对应一个原始区间 $[l, r]$。\n\n如何定义块大小是实现分块算法的关键。\n\n对于本题,本质是求若干个大小为 $k$ 的区间最大值。\n\n我们可以设定块大小为 $\\sqrt{k}$,这样所需创建的分块数组大小为 $\\frac{n}{\\sqrt{k}}$。分块数组的更新操作为 $O(1)$,而查询则为 $\\sqrt{k}$。\n\n容易证明查询操作的复杂度:对于每个长度为 $k$ 的 $[l, r]$ 查询操作而言,最多遍历两个(左右端点对应的块)的块内元素,复杂度为 $O(\\sqrt{k})$,同时最多遍历 $\\sqrt{k}$ 个块,复杂度同为 $O(\\sqrt{k})$。\n\n因此最多两步复杂度为 $O(\\sqrt{k})$ 的块内操作,最多 $\\sqrt{k}$ 步复杂度为 $O(1)$ 的块间操作,整体复杂度为 $O(\\sqrt{k})$。\n\n因此使用分块算法总的计算量为 $n\\times\\sqrt{k} = 10^6$,可以过。\n\n分块算法的几个操作函数:\n\n* `int getIdx(int x)` :计算原始下标对应的块编号;\n* `void add(int x, int v)` :计算原始下标 `x` 对应的下标 `idx`,并将 `region[idx]` 和 `v` 取 `max` 来更新 `region[idx]`;\n* `int query(int l, int r)` :查询 $[l, r]$ 中的最大值,如果 $l$ 和 $r$ 所在块相同,直接遍历 $[l, r]$ 进行取值;若 $l$ 和 $r$ 不同块,则处理 $l$ 和 $r$ 对应的块内元素后,对块编号在 $(getIdx(l), getIdx(r))$ 之间的块进行遍历。\n\n代码:\n```Java \nclass Solution {\n    int n, m, len;\n    int[] nums, region;\n    int getIdx(int x) {\n        return x / len;\n    }\n    void add(int x, int v) {\n        region[getIdx(x)] = Math.max(region[getIdx(x)], v);\n    }\n    int query(int l, int r) {\n        int ans = Integer.MIN_VALUE;\n        if (getIdx(l) == getIdx(r)) {\n            for (int i = l; i <= r; i++) ans = Math.max(ans, nums[i]);\n        } else {\n            int i = l, j = r;\n            while (getIdx(i) == getIdx(l)) ans = Math.max(ans, nums[i++]);\n            while (getIdx(j) == getIdx(r)) ans = Math.max(ans, nums[j--]);\n            for (int k = getIdx(i); k <= getIdx(j); k++) ans = Math.max(ans, region[k]);\n        }\n        return ans;\n    }\n    public int[] maxSlidingWindow(int[] _nums, int k) {\n        nums = _nums;\n        n = nums.length; len = (int) Math.sqrt(k); m = n / len + 10;\n        region = new int[m];\n        Arrays.fill(region, Integer.MIN_VALUE);\n        for (int i = 0; i < n; i++) add(i, nums[i]);\n        int[] ans = new int[n - k + 1];\n        for (int i = 0; i < n - k + 1; i++) ans[i] = query(i, i + k - 1);\n        return ans;\n    }\n}\n```\n* 时间复杂度:数组大小为 $n$,块大小为 $\\sqrt{k}$,分块数组大小为 $\\frac{n}{\\sqrt{k}}$。预处理分块数组复杂度为 $O(n)$(即 `add` 操作复杂度为 $O(1)$ );构造答案复杂度为 $O(n\\times\\sqrt{k})$(即 `query` 操作复杂度为 $O(\\sqrt{k})$,最多有 $n$ 次查询)\n* 空间复杂度:$\\frac{n}{\\sqrt{k}}$\n\n---\n\n### 单调队列\n\n关于 `RMQ` 的另外一个优秀做法通常是使用「单调队列/单调栈」。\n\n当然,我们也能不依靠经验,而从问题的本身出发,逐步分析出该做法。\n\n假设我们当前处理到某个长度为 $k$ 的窗口,此时窗口往后滑动一格,会导致后一个数(新窗口的右端点)添加进来,同时会导致前一个数(旧窗口的左端点)移出窗口。\n\n随着窗口的不断平移,该过程会一直发生。**若同一时刻存在两个数 $nums[j]$ 和 $nums[i]$($j < i$)所在一个窗口内,下标更大的数会被更晚移出窗口,此时如果有 $nums[j] <= nums[i]$ 的话,可以完全确定 $nums[j]$ 将不会成为后续任何一个窗口的最大值,此时可以将必然不会是答案的 $nums[j]$ 从候选中进行移除**。\n\n不难发现,当我们将所有必然不可能作为答案的元素(即所有满足的小于等于 $nums[i]$ )移除后,候选集合满足「单调递减」特性,即集合首位元素为当前窗口中的最大值(为了满足窗口长度为 $k$ 的要求,在从集合头部取答案时需要先将下标小于的等于的 $i - k$ 的元素移除)。\n\n为方便从尾部添加元素,从头部获取答案,我们可使用「双端队列」存储所有候选元素。\n\n代码:\n```Java \nclass Solution {\n    public int[] maxSlidingWindow(int[] nums, int k) {\n        Deque<Integer> d = new ArrayDeque<>();\n        int n = nums.length, m = n - k + 1;\n        int[] ans = new int[m];\n        for (int i = 0; i < n; i++) {\n            while (!d.isEmpty() && nums[d.peekLast()] <= nums[i]) d.pollLast();\n            d.addLast(i);\n            if (i >= k - 1) {\n                while (!d.isEmpty() && d.peekFirst() <= i - k) d.pollFirst();\n                ans[i - k + 1] = nums[d.peekFirst()];\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.239` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/231-240/240. 搜索二维矩阵 II（中等）.md", "url_title": "240. 搜索二维矩阵 II", "url": "https://leetcode-cn.com/problems/search-a-2d-matrix-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-y1ns/", "difficulty": "中等", "tags": ["二分", "二叉搜索树", "模拟"], "question": "编写一个高效的算法来搜索 `m x n` 矩阵 `matrix` 中的一个目标值 `target` 。\n\n该矩阵具有以下特性:\n\n* 每行的元素从左到右升序排列。\n* 每列的元素从上到下升序排列。\n\n示例 1:\n\n```\n输入:matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5\n\n输出:true\n```\n示例 2:\n\n```\n输入:matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 20\n\n输出:false\n```\n\n提示:\n* m == matrix.length\n* n == matrix[i].length\n* 1 <= n, m <= 300\n* $-10^9 <= matrix[i][j] <= 10^9$\n* 每行的所有元素从左到右升序排列\n* 每列的所有元素从上到下升序排列\n* $-10^9 <= target <= 10^9$", "solution": "### 前言\n\n这道题和之前的[(题解)74. 搜索二维矩阵](https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/) 类似,建议你将两题放到一起去做。\n\n---\n\n### 二分\n\n与 [(题解)74. 搜索二维矩阵](https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/) 不同,本题没有确保「每行的第一个整数大于前一行的最后一个整数」,因此我们无法采取「两次二分」的做法。\n\n只能退而求之,遍历行/列,然后再对列/行进行二分。\n\n代码:\n```Java\nclass Solution {\n    public boolean searchMatrix(int[][] matrix, int target) {\n        int m = matrix.length, n = matrix[0].length;\n        for (int i = 0; i < m; i++) {\n            int l = 0, r = n - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (matrix[i][mid] <= target) l = mid;\n                else r = mid - 1;\n            }\n            if (matrix[i][r] == target) return true;\n        }\n        return false;\n    }\n}\n```\n\n```Java\nclass Solution {\n    public boolean searchMatrix(int[][] matrix, int target) {\n        int m = matrix.length, n = matrix[0].length;\n        for (int i = 0; i < n; i++) {\n            int l = 0, r = m - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (matrix[mid][i] <= target) l = mid;\n                else r = mid - 1;\n            }\n            if (matrix[r][i] == target) return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(m\\log{n})$ 或 $O(n\\log{m})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 抽象 BST\n\n该做法则与 [(题解)74. 搜索二维矩阵](https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/) 的「解法二」完全一致。\n\n我们可以将二维矩阵抽象成「以右上角为根的 BST」:\n\n那么我们可以从根(右上角)开始搜索,如果当前的节点不等于目标值,可以按照树的搜索顺序进行:\n\n1. 当前节点「大于」目标值,搜索当前节点的「左子树」,也就是当前矩阵位置的「左方格子」,即 $c$--\n2. 当前节点「小于」目标值,搜索当前节点的「右子树」,也就是当前矩阵位置的「下方格子」,即 $r$++\n\n代码:\n```Java\nclass Solution {\n    public boolean searchMatrix(int[][] matrix, int target) {\n        int m = matrix.length, n = matrix[0].length;\n        int r = 0, c = n - 1;\n        while (r < m && c >= 0) {\n            if (matrix[r][c] < target) r++;\n            else if (matrix[r][c] > target) c--;\n            else return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(m + n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.240` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2331-2340/2335. 装满杯子需要的最短总时长（简单）.md", "url_title": "2335. 装满杯子需要的最短总时长", "url": "https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247495870&idx=1&sn=a15b87852faaa33fc9d976b575ef1099", "difficulty": "简单", "tags": ["排序", "递归", "模拟", "贪心", "数学"], "question": "现有一台饮水机,可以制备冷水、温水和热水。每秒钟,可以装满 `2` 杯 不同 类型的水或者 `1` 杯任意类型的水。\n\n给你一个下标从 `0` 开始、长度为 `3` 的整数数组 `amount`,其中 `amount[0]`、`amount[1]` 和 `amount[2]` 分别表示需要装满冷水、温水和热水的杯子数量。\n\n返回装满所有杯子所需的 **最少** 秒数。\n\n示例 1:\n```\n输入:amount = [1,4,2]\n\n输出:4\n\n解释:下面给出一种方案:\n第 1 秒:装满一杯冷水和一杯温水。\n第 2 秒:装满一杯温水和一杯热水。\n第 3 秒:装满一杯温水和一杯热水。\n第 4 秒:装满一杯温水。\n可以证明最少需要 4 秒才能装满所有杯子。\n```\n示例 2:\n```\n输入:amount = [5,4,4]\n\n输出:7\n\n解释:下面给出一种方案:\n第 1 秒:装满一杯冷水和一杯热水。\n第 2 秒:装满一杯冷水和一杯温水。\n第 3 秒:装满一杯冷水和一杯温水。\n第 4 秒:装满一杯温水和一杯热水。\n第 5 秒:装满一杯冷水和一杯热水。\n第 6 秒:装满一杯冷水和一杯温水。\n第 7 秒:装满一杯热水。\n```\n示例 3:\n```\n输入:amount = [5,0,0]\n\n输出:5\n\n解释:每秒装满一杯冷水。\n```\n\n提示:\n* $amount.length = 3$\n* $0 <= amount[i] <= 100$", "solution": "### 排序 + 递归\n\n水的种类固定为 `3`,且每种水的数据范围只有 $100$,可直接使用递归进行求解。\n\n为了尽可能的凑成多的对数,我们可以每次取剩余数量最多且不为 `0` 的两类水进行成组(因此每次处理前需要先对当前 `amount` 进行排序),直到没有水剩余,或只有一类水的剩余数据量不为 `0`(剩下的水只能独自生成)。\n\nJava 代码:\n```Java\nclass Solution {\n    public int fillCups(int[] amount) {\n        Arrays.sort(amount);\n        if (amount[1] == 0) return amount[2];\n        amount[1]--; amount[2]--;\n        return 1 + fillCups(amount);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int fillCups(vector<int>& amount) {\n        sort(amount.begin(), amount.end());\n        if (amount[1] == 0) return amount[2];\n        amount[1]--; amount[2]--;\n        return 1 + fillCups(amount);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def fillCups(self, amount: List[int]) -> int:\n        amount.sort()\n        if amount[1] == 0:\n            return amount[2]\n        amount[1] -= 1\n        amount[2] -= 1\n        return 1 + self.fillCups(amount)\n```\nTypeScript 代码:\n```TypeScript\nfunction fillCups(amount: number[]): number {\n    amount.sort((a, b) => a - b);\n    if (amount[1] === 0) return amount[2];\n    amount[1] -= 1;\n    amount[2] -= 1;\n    return 1 + fillCups(amount);\n};\n```\n* 时间复杂度:由于 `amount` 的长度固定为 `3`,因此排序消耗可视为常量;每次至少会消耗两杯水,直到递归结束或只剩下一种水。复杂度为 $O(\\sum_{i = 0}^{2} amount[i])$\n* 空间复杂度:忽略递归和排序带来的额外空间开销,复杂度为 $O(1)$\n\n---\n\n### 贪心 + 数学\n\n我们已经知道可以通过「每次取剩余数量最多且不为 `0` 的水成对」来实现最少生成次数。\n\n那么是否存在直接计算最少生成次数的方法,而不是采用逐回合模拟。\n\n考虑对 `amount` 进行排序,分别使用 `a`、`b` 和 `c` 代表剩余次数递增的三种种类。\n\n根据 $a + b$ 和 $c$ 的大小关系进行分情况讨论:\n\n* $a + b \\leq c$,此时每消耗一个 $c$ 都可以顺带消除一个 $a$ 或 $b$,因此最少生成次数为 $c$;\n\n* $a + b > c$,此时考虑其之间的差值 $t = a + b - c$,若能顺利通过 $\\frac{t}{2}$ 次对 $a$ 和 $b$ 的合并,可以将局面转成情况一,最少生成次数为 $\\frac{t}{2} + c$;\n\n\t考虑起始是否能先对 $a$ 和 $b$ 进行 $\\frac{t}{2}$ 个回合,由于我们有 $a \\leq b$,我们只需考虑是否必然有 $a \\geq \\frac{t}{2}$ 即可,可通过反证法证明 $a < \\frac{t}{2}$ 必然不成立,若有 $a < \\frac{t}{2}$,则有 $2a < a + b - c$ => $a < b - c$,由于 $b \\leq c$,则有 $a < 0$,与原条件冲突。\n\t\n\t最后,为了处理 $t$ 的奇偶性问题,先用 $a$ 和 $b$ 进行 $\\left \\lceil \\frac{a + b - c}{2} \\right \\rceil$ 抵消操作,再与 $c$ 进行抵消\n\nJava 代码:\n```Java\nclass Solution {\n    public int fillCups(int[] amount) {\n        Arrays.sort(amount);\n        int a = amount[0], b = amount[1], c = amount[2];\n        if (a + b <= c) return c;        \n        else return (a + b - c + 1) / 2 + c;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int fillCups(vector<int>& amount) {\n        sort(amount.begin(), amount.end());\n        int a = amount[0], b = amount[1], c = amount[2];\n        if (a + b <= c) return c;\n        else return (a + b - c + 1) / 2 + c;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def fillCups(self, amount: List[int]) -> int:\n        amount.sort()\n        a, b, c = amount\n        if a + b <= c:\n            return c\n        else:\n            return (a + b - c + 1) // 2 + c\n```\nTypeScript 代码:\n```TypeScript\nfunction fillCups(amount: number[]): number {\n    amount.sort((a, b) => a - b);\n    const [a, b, c] = amount;\n    if (a + b <= c) return c;    \n    else return Math.floor((a + b - c + 1) / 2) + c; \n};\n```\n* 时间复杂度:由于 `amount` 的长度固定为 `3`,因此排序消耗可视为常量,整体复杂度为 $O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2335` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2331-2340/2336. 无限集中的最小数字（中等）.md", "url_title": "2336. 无限集中的最小数字", "url": "https://leetcode.cn/problems/smallest-number-in-infinite-set/solutions/2546157/gong-shui-san-xie-rong-yi-you-gao-xiao-d-431o/", "difficulty": "中等", "tags": ["优先队列(堆)", "哈希表"], "question": "现有一个包含所有正整数的集合 $[1, 2, 3, 4, 5, ...]$ 。\n\n实现 `SmallestInfiniteSet` 类:\n\n* `SmallestInfiniteSet()` 初始化 `SmallestInfiniteSet` 对象以包含所有正整数。\n* `int popSmallest()` 移除并返回该无限集中的最小整数。\n* `void addBack(int num)` 如果正整数 `num` 不存在于无限集中,则将一个 `num` 添加到该无限集中。\n\n示例:\n```\n输入\n[\"SmallestInfiniteSet\", \"addBack\", \"popSmallest\", \"popSmallest\", \"popSmallest\", \"addBack\", \"popSmallest\", \"popSmallest\", \"popSmallest\"]\n[[], [2], [], [], [], [1], [], [], []]\n\n输出\n[null, null, 1, 2, 3, null, 1, 4, 5]\n\n解释\nSmallestInfiniteSet smallestInfiniteSet = new SmallestInfiniteSet();\nsmallestInfiniteSet.addBack(2);    // 2 已经在集合中,所以不做任何变更。\nsmallestInfiniteSet.popSmallest(); // 返回 1 ,因为 1 是最小的整数,并将其从集合中移除。\nsmallestInfiniteSet.popSmallest(); // 返回 2 ,并将其从集合中移除。\nsmallestInfiniteSet.popSmallest(); // 返回 3 ,并将其从集合中移除。\nsmallestInfiniteSet.addBack(1);    // 将 1 添加到该集合中。\nsmallestInfiniteSet.popSmallest(); // 返回 1 ,因为 1 在上一步中被添加到集合中,\n                                   // 且 1 是最小的整数,并将其从集合中移除。\nsmallestInfiniteSet.popSmallest(); // 返回 4 ,并将其从集合中移除。\nsmallestInfiniteSet.popSmallest(); // 返回 5 ,并将其从集合中移除。\n```\n\n提示:\n* $1 <= num <= 1000$\n* 最多调用 `popSmallest` 和 `addBack` 方法 共计 $1000$ 次", "solution": "### 优先队列(小根堆)+ 哈希表\n\n使用 `idx` 代表顺序弹出的集合左边界,$[idx, +\\infty]$ 范围内的数均为待弹出,起始有 $idx = 1$。\n\n考虑当调用 `addBack` 往集合添加数值 `x` 时,该如何处理:\n\n* $x \\geq idx$:数值本身就存在于集合中,忽略该添加操作;\n* $x = idx - 1$:数值刚好位于边界左侧,更新 $idx = idx - 1$;\n* $x < idx - 1$:考虑将数值添加到某个容器中,该容器支持返回最小值,容易联想到“小根堆”;但小根堆并没有“去重”功能,为防止重复弹出,还需额外使用“哈希表”来记录哪些元素在堆中。\n\n该做法本质上将集合分成两类:一类是从 `idx` 到正无穷的连续段,对此类操作的复杂度为 $O(1)$;一类是比 `idx` 要小的离散类数集,对该类操作复杂度为 $O(\\log{n})$,其中 $n$ 为调用 `addBack` 的最大次数。\n\nJava 代码:\n```Java\nclass SmallestInfiniteSet {\n    boolean[] vis = new boolean[1010];\n    PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->a-b);\n    int idx = 1;\n    public int popSmallest() {\n        int ans = -1;\n        if (!q.isEmpty()) {\n            ans = q.poll();\n            vis[ans] = false;\n        } else {\n            ans = idx++;\n        }\n        return ans;\n    }\n    public void addBack(int x) {\n        if (x >= idx || vis[x]) return ;\n        if (x == idx - 1) {\n            idx--;\n        } else {\n            q.add(x);\n            vis[x] = true;\n        }\n    }\n}\n```\nC++ 代码:\n```C++\nclass SmallestInfiniteSet {\npublic:\n    vector<bool> vis;\n    priority_queue<int, vector<int>, greater<int>> q;\n    int idx;\n    SmallestInfiniteSet() : idx(1) {\n        vis.resize(1010, false);\n    }\n    int popSmallest() {\n        int ans = -1;\n        if (!q.empty()) {\n            ans = q.top();\n            q.pop();\n            vis[ans] = false;\n        } else {\n            ans = idx++;\n        }\n        return ans;\n    }\n    void addBack(int x) {\n        if (x >= idx || vis[x]) return;\n        if (x == idx - 1) {\n            idx--;\n        } else {\n            q.push(x);\n            vis[x] = true;\n        }\n    }\n};\n\n```\nPython 代码:\n```Python\nclass SmallestInfiniteSet:\n    def __init__(self):\n        self.vis = [False] * 1010\n        self.q = []\n        self.idx = 1\n\n    def popSmallest(self):\n        ans = -1\n        if self.q:\n            ans = heapq.heappop(self.q)\n            self.vis[ans] = False\n        else:\n            ans = self.idx\n            self.idx += 1\n        return ans\n\n    def addBack(self, x):\n        if x >= self.idx or self.vis[x]:\n            return\n        if x == self.idx - 1:\n            self.idx -= 1\n        else:\n            heapq.heappush(self.q, x)\n            self.vis[x] = True\n```\nTypeScript 代码:\n```TypeScript\nclass SmallestInfiniteSet {\n    vis: boolean[] = Array(1010).fill(false);\n    q: number[] = [];\n    idx: number = 1;\n    popSmallest(): number {\n        let ans: number = -1;\n        if (this.q.length !== 0) {\n            ans = this.q.sort((a, b) => a - b).shift() as number;\n            this.vis[ans] = false;\n        } else {\n            ans = this.idx++;\n        }\n        return ans;\n    }\n    addBack(x: number): void {\n        if (x >= this.idx || this.vis[x]) return;\n        if (x == this.idx - 1) {\n            this.idx--;\n        } else {\n            this.q.push(x);\n            this.vis[x] = true;\n        }\n    }\n}\n```\n* 时间复杂度:插入和取出的最坏复杂度为 $O(\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2336` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2341-2350/2342. 数位和相等数对的最大和（中等）.md", "url_title": "2342. 数位和相等数对的最大和", "url": "https://leetcode.cn/problems/max-sum-of-a-pair-with-equal-sum-of-digits/solutions/2531511/gong-shui-san-xie-yong-bian-li-guo-cheng-kt3f/", "difficulty": "中等", "tags": ["模拟", "哈希表"], "question": "给你一个下标从 `0` 开始的数组 `nums`,数组中的元素都是正整数。\n\n请你选出两个下标 `i` 和 `j`(`i != j`),且 `nums[i]` 的数位和与  `nums[j]` 的数位和相等。\n\n请你找出所有满足条件的下标 `i` 和 `j`,找出并返回 `nums[i] + nums[j]` 可以得到的最大值。\n\n示例 1:\n```\n输入:nums = [18,43,36,13,7]\n\n输出:54\n\n解释:满足条件的数对 (i, j) 为:\n- (0, 2) ,两个数字的数位和都是 9 ,相加得到 18 + 36 = 54 。\n- (1, 4) ,两个数字的数位和都是 7 ,相加得到 43 + 7 = 50 。\n所以可以获得的最大和是 54 。\n```\n示例 2:\n```\n输入:nums = [10,12,19,14]\n\n输出:-1\n\n解释:不存在满足条件的数对,返回 -1 。\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $1 <= nums[i] <= 10^9$", "solution": "### 模拟\n\n既然每个 $nums[i]$ 都对应一个具体的数位和,统计每个数位和的最大值和次大值,然后在所有数位和的最大值和次大值求和中取 `max` 即是答案。\n\n利用 $1 <= nums[i] <= 10^9$,我们知道数位和不会超过 $9 \\times 9 = 81$,可直接起一个大小为 $100 \\times 2$ 的二维数组进行统计,$val[x][0]$ 代表数位和为 $x$ 的次大值,$val[x][1]$ 代表数位和为 $x$ 的最大值。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maximumSum(int[] nums) {\n        int[][] val = new int[100][2];\n        for (int x : nums) {\n            int t = x, cur = 0;\n            while (t != 0) {\n                cur += t % 10;\n                t /= 10;\n            }\n            if (x >= val[cur][1]) { // 最大沦为次大, 更新最大\n                val[cur][0] = val[cur][1];\n                val[cur][1] = x;\n            } else if (x > val[cur][0]) { // 更新次大\n                val[cur][0] = x;\n            }\n        }\n        int ans = -1;\n        for (int i = 0; i < 100; i++) {\n            if (val[i][0] != 0 && val[i][1] != 0) ans = Math.max(ans, val[i][0] + val[i][1]);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maximumSum(vector<int>& nums) {\n        vector<vector<int>> val(100, vector<int>(2, 0));\n        for (int x : nums) {\n            int t = x, cur = 0;\n            while (t != 0) {\n                cur += t % 10;\n                t /= 10;\n            }\n            if (x >= val[cur][1]) {\n                val[cur][0] = val[cur][1];\n                val[cur][1] = x;\n            } else if (x > val[cur][0]) {\n                val[cur][0] = x;\n            }\n        }\n        int ans = -1;\n        for (int i = 0; i < 100; i++) {\n            if (val[i][0] != 0 && val[i][1] != 0) ans = max(ans, val[i][0] + val[i][1]);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maximumSum(self, nums: List[int]) -> int:\n        val = [[0, 0] for _ in range(100)]\n        for x in nums:\n            t, cur = x, 0\n            while t != 0:\n                cur += t % 10\n                t //= 10\n            if x >= val[cur][1]:\n                val[cur][0], val[cur][1] = val[cur][1], x\n            elif x > val[cur][0]:\n                val[cur][0] = x\n        ans = -1\n        for i in range(100):\n            if val[i][0] != 0 and val[i][1] != 0:\n                ans = max(ans, val[i][0] + val[i][1])\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction maximumSum(nums: number[]): number {\n    const val = Array.from({ length: 100 }, () => [0, 0]);\n    for (const x of nums) {\n        let t = x, cur = 0;\n        while (t !== 0) {\n            cur += t % 10;\n            t = Math.floor(t / 10);\n        }\n        if (x >= val[cur][1]) {\n            val[cur][0] = val[cur][1];\n            val[cur][1] = x;\n        } else if (x > val[cur][0]) {\n            val[cur][0] = x;\n        }\n    }\n    let ans = -1;\n    for (let i = 0; i < 100; i++) {\n        if (val[i][0] !== 0 && val[i][1] !== 0) ans = Math.max(ans, val[i][0] + val[i][1]);\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n\\log{m})$,其中 $n=1e5$ 为 `nums` 长度,$m=1e9$ 为 $nums[i]$ 值域上界\n* 空间复杂度:$O(C)$,其中 $C = 2 \\times 9 \\times \\log{m}$\n\n---\n\n### 模拟\n\n更进一步,我们不需要记录次大值,仅记录某个“数对和”当前的最大值即可。\n\n每次计算出当前 $nums[i]$ 对应的数对 `cur` 后,检查 `cur` 是否已出现过,若出现过用两者之和更新答案,并用 $nums[i]$ 来更新 `cur` 下的最大值。\n\n该做法本质是用「遍历过程」代替「次大维护」。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maximumSum(int[] nums) {\n        int[] val = new int[100];\n        int ans = -1;\n        for (int x : nums) {\n            int t = x, cur = 0;\n            while (t != 0) {\n                cur += t % 10;\n                t /= 10;\n            }\n            if (val[cur] != 0) ans = Math.max(ans, val[cur] + x);\n            val[cur] = Math.max(val[cur], x);\n        }\n        return ans;       \n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maximumSum(vector<int>& nums) {\n        vector<int> val(100, 0);\n        int ans = -1;\n        for (int x : nums) {\n            int t = x, cur = 0;\n            while (t != 0) {\n                cur += t % 10;\n                t /= 10;\n            }\n            if (val[cur] != 0) ans = max(ans, val[cur] + x);\n            val[cur] = max(val[cur], x);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maximumSum(self, nums: List[int]) -> int:\n        val = [0] * 100\n        ans = -1\n        for x in nums:\n            t, cur = x, 0\n            while t != 0:\n                cur += t % 10\n                t //= 10\n            if val[cur] != 0:\n                ans = max(ans, val[cur] + x)\n            val[cur] = max(val[cur], x)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction maximumSum(nums: number[]): number {\n    const val = Array(100).fill(0);\n    let ans = -1;\n    for (const x of nums) {\n        let t = x, cur = 0;\n        while (t !== 0) {\n            cur += t % 10;\n            t = Math.floor(t / 10);\n        }\n        if (val[cur] !== 0) ans = Math.max(ans, val[cur] + x);\n        val[cur] = Math.max(val[cur], x);\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n\\log{m})$,其中 $n=1e5$ 为 `nums` 长度,$m=1e9$ 为 $nums[i]$ 值域上界\n* 空间复杂度:$O(C)$,其中 $C = 9 \\times \\log{m}$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2342` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/241-250/241. 为运算表达式设计优先级（中等）.md", "url_title": "241. 为运算表达式设计优先级", "url": "https://leetcode.cn/problems/different-ways-to-add-parentheses/solution/by-ac_oier-z07i/", "difficulty": "中等", "tags": ["DFS", "爆搜"], "question": "给你一个由数字和运算符组成的字符串 `expression`,按不同优先级组合数字和运算符,计算并返回所有可能组合的结果。你可以 按任意顺序 返回答案。\n\n生成的测试用例满足其对应输出值符合 $32$ 位整数范围,不同结果的数量不超过 $10^4$ 。\n\n示例 1:\n```\n输入:expression = \"2-1-1\"\n\n输出:[0,2]\n\n解释:\n((2-1)-1) = 0 \n(2-(1-1)) = 2\n```\n示例 2:\n```\n输入:expression = \"2*3-4*5\"\n\n输出:[-34,-14,-10,-10,10]\n\n解释:\n(2*(3-(4*5))) = -34 \n((2*3)-(4*5)) = -14 \n((2*(3-4))*5) = -10 \n(2*((3-4)*5)) = -10 \n(((2*3)-4)*5) = 10\n```\n\n提示:\n* $1 <= expression.length <= 20$\n* `expression` 由数字和算符 `'+'`、`'-'` 和 `'*'` 组成。\n* 输入表达式中的所有整数值在范围 $[0, 99]$", "solution": "### DFS\n\n为了方便,我们令 `expression` 为 `s`。\n\n数据范围为 $20$,且要统计所有的计算结果,我们可以运用 `DFS` 爆搜所有方案。\n\n给定的 `s` 只有数字和运算符,我们可以根据运算符将式子分为左右两部分,设计递归函数 `List<Integer> dfs(int l, int r)`,含义为搜索子串 $s[l...r]$ 的所有运算结果。\n\n最终答案为 `dfs(0,n-1)`,其中 $n$ 为入参字符串的长度,同时我们有显而易见的递归出口:当给定的 $s[l...r]$ 不包含任何运算符时,搜索结果为 $s[l...r]$ 所代表的数字本身。\n\n考虑如何对任意 $s[l...r]$ 进行计算:我们可以通过枚举 $s[l...r]$ 范围内的所有的运算符位置来进行爆搜,假设当前枚举到的 $s[i]$ 为运算符,我们可以递归运算符的左边 `dfs(l,i-1)` 拿到左边所有的结果,递归运算符右边 `dfs(i+1,r)` 拿到右边的所有结果,结合「乘法原理」即可知道以当前运算符 $s[i]$ 为分割点的表达式的所有方案。\n\n不难发现,上述过程都是由「小表达式」的结果推导出「大表达式」的结果,因此也可以运用「区间 DP」方式进行求解,复杂度与 `DFS` 一致。\n\nJava 代码:\n```Java\nclass Solution {\n    char[] cs;\n    public List<Integer> diffWaysToCompute(String s) {\n        cs = s.toCharArray();\n        return dfs(0, cs.length - 1);\n    }\n    List<Integer> dfs(int l, int r) {\n        List<Integer> ans = new ArrayList<>();\n        for (int i = l; i <= r; i++) {\n            if (cs[i] >= '0' && cs[i] <= '9') continue;\n            List<Integer> l1 = dfs(l, i - 1), l2 = dfs(i + 1, r);\n            for (int a : l1) {\n                for (int b : l2) {\n                    int cur = 0;\n                    if (cs[i] == '+') cur = a + b;\n                    else if (cs[i] == '-') cur = a - b;\n                    else cur = a * b;\n                    ans.add(cur);\n                }\n            }\n        }\n        if (ans.isEmpty()) {\n            int cur = 0;\n            for (int i = l; i <= r; i++) cur = cur * 10 + (cs[i] - '0');\n            ans.add(cur);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    string cs;\n    vector<int> diffWaysToCompute(string s) {\n        cs = s;\n        return dfs(0, cs.size() - 1);\n    }\n    vector<int> dfs(int l, int r) {\n        vector<int> ans;\n        for (int i = l; i <= r; i++) {\n            if (cs[i] >= '0' && cs[i] <= '9') continue;\n            auto l1 = dfs(l, i - 1), l2 = dfs(i + 1, r);\n            for (int a : l1) {\n                for (int b : l2) {\n                    int cur = 0;\n                    if (cs[i] == '+') cur = a + b;\n                    else if (cs[i] == '-') cur = a - b;\n                    else cur = a * b;\n                    ans.push_back(cur);\n                }\n            }\n        }\n        if (ans.empty()) {\n            int cur = 0;\n            for (int i = l; i <= r; i++) cur = cur * 10 + (cs[i] - '0');\n            ans.push_back(cur);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def diffWaysToCompute(self, cs: str) -> List[int]:        \n        def dfs(l: int, r: int) -> List[int]:\n            ans = []\n            for i in range(l, r + 1):\n                if '0' <= cs[i] <= '9': continue\n                l1, l2 = dfs(l, i - 1), dfs(i + 1, r)\n                for a, b in product(l1, l2):\n                    cur = 0\n                    if cs[i] == '+':\n                        cur = a + b\n                    elif cs[i] == '-':\n                        cur = a - b\n                    else:\n                        cur = a * b\n                    ans.append(cur)\n            if not ans:\n                cur = 0\n                for i in range(l, r + 1):\n                    cur = cur * 10 + (ord(cs[i]) - ord('0'))\n                ans.append(cur)\n            return ans\n        return dfs(0, len(cs) - 1)\n```\nTypeScript 代码:\n```TypeScript\nfunction diffWaysToCompute(cs: string): number[] {\n    const dfs = function(l: number, r: number): number[] {\n        const ans = [];\n        for (let i = l; i <= r; i++) {\n            if (\"0\" <= cs[i] && cs[i] <= \"9\") continue;\n            const l1 = dfs(l, i - 1), l2 = dfs(i + 1, r);\n            for (const a of l1) {\n                for (const b of l2) {\n                    let cur = 0;\n                    if (cs[i] === \"+\") cur = a + b;\n                    else if (cs[i] === \"-\") cur = a - b;\n                    else cur = a * b;\n                    ans.push(cur);\n                }\n            }\n        }\n        if (ans.length == 0) {\n            let cur = 0;\n            for (let i = l; i <= r; i++) cur = cur * 10 + (parseInt(cs[i]) - 0);\n            ans.push(cur);\n        }\n        return ans;\n    }\n    return dfs(0, cs.length - 1);\n};\n```\n* 时间复杂度:复杂度与最终结果数相关,最终结果数为「卡特兰数」,复杂度为 $O(C_{n})$\n* 空间复杂度:复杂度与最终结果数相关,最终结果数为「卡特兰数」,复杂度为 $O(C_{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.241` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2471-2480/2477. 到达首都的最少油耗（中等）.md", "url_title": "2477. 到达首都的最少油耗", "url": "https://leetcode.cn/problems/minimum-fuel-cost-to-report-to-the-capital/solutions/2554316/gong-shui-san-xie-zhu-bu-jiang-jie-zui-d-25qs/", "difficulty": "中等", "tags": ["DFS"], "question": "给你一棵 `n` 个节点的树(一个无向、连通、无环图),每个节点表示一个城市,编号从 `0` 到 `n - 1`,且恰好有 `n - 1` 条路。\n\n`0` 是首都。给你一个二维整数数组 `roads`,其中 $roads[i] = [a_{i}, b_{i}]$ ,表示城市 $a_{i}$ 和 $b_{i}$ 之间有一条 双向路 。\n\n每个城市里有一个代表,他们都要去首都参加一个会议。\n\n每座城市里有一辆车。给你一个整数 `seats` 表示每辆车里面座位的数目。\n\n城市里的代表可以选择乘坐所在城市的车,或者乘坐其他城市的车。相邻城市之间一辆车的油耗是一升汽油。\n\n请你返回到达首都最少需要多少升汽油。\n\n示例 1:\n\n```\n输入:roads = [[0,1],[0,2],[0,3]], seats = 5\n\n输出:3\n\n解释:\n- 代表 1 直接到达首都,消耗 1 升汽油。\n- 代表 2 直接到达首都,消耗 1 升汽油。\n- 代表 3 直接到达首都,消耗 1 升汽油。\n最少消耗 3 升汽油。\n```\n示例 2:\n\n```\n输入:roads = [[3,1],[3,2],[1,0],[0,4],[0,5],[4,6]], seats = 2\n\n输出:7\n\n解释:\n- 代表 2 到达城市 3 ,消耗 1 升汽油。\n- 代表 2 和代表 3 一起到达城市 1 ,消耗 1 升汽油。\n- 代表 2 和代表 3 一起到达首都,消耗 1 升汽油。\n- 代表 1 直接到达首都,消耗 1 升汽油。\n- 代表 5 直接到达首都,消耗 1 升汽油。\n- 代表 6 到达城市 4 ,消耗 1 升汽油。\n- 代表 4 和代表 6 一起到达首都,消耗 1 升汽油。\n最少消耗 7 升汽油。\n```\n示例 3:\n\n```\n输入:roads = [], seats = 1\n\n输出:0\n\n解释:没有代表需要从别的城市到达首都。\n```\n\n提示:\n* $1 <= n <= 105$\n* $roads.length = n - 1$\n* $roads[i].length = 2$\n* $0 <= a_{i}, b_{i} < n$\n* $a_{i} != b_{i}$\n* `roads` 表示一棵合法的树。\n* $1 <= seats <= 10^5$", "solution": "### DFS\n\n将双向图看作是以节点 `0` 为根的有向树,从每个节点出发往 `0` 前行,可看作是自底向上的移动过程。\n\n当 `seats = 1` 时,每个节点前往 `0` 的过程相互独立,总油耗为每节点到 `0` 的最短距离之和。\n\n当 `seats` 不为 `1` 时,考虑组成顺风车,此时总的油耗不该超过 `seats = 1` 的情况。\n\n不难发现,**只有「深度大的节点,在前往 `0` 过程中,搭乘深度小顺风车」可减少油耗**(例如在上图节点 `3` 在经过节点 `1` 时搭乘顺风车,可与节点 `1` 合计使用一份油耗前往到 `0`),否则如果是深度小的节点先往深度大的节点走,再一同前往 `0`,会额外多经过某些边,产生不必要的油耗。\n\n考虑组成顺风车时,总油耗该如何计算。\n\n基于上述分析,无论 `seats` 是否为 $1$(是否组成顺风车),每个节点前往 `0` 的路径总是不变,即经过的边固定不变,必然是自底向上。\n\n因此我们可统计每条边会被多少个节点经过,通过 `DFS` 统计「以每个节点为根时,子树的节点数量」即是经过该节点往上的边。\n\n知道经过某条边的节点数量 `cnt` 后,$\\left \\lceil \\frac{cnt}{seats} \\right \\rceil$ 即是该边对答案的贡献。\n\nJava 代码:\n\n```Java\nclass Solution {\n    int N = 100010, M = 2 * N, idx = 0;\n    int[] he = new int[N], e = new int[M], ne = new int[M];\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    long ans = 0;\n    public long minimumFuelCost(int[][] roads, int seats) {\n        int n = roads.length + 1;\n        Arrays.fill(he, -1);\n        for (int[] r : roads) {\n            int a = r[0], b = r[1];\n            add(a, b); add(b, a);\n        }\n        dfs(0, -1, seats);\n        return ans;\n    }\n    int dfs(int u, int fa, int t) {\n        int cnt = 1;\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (j == fa) continue;\n            cnt += dfs(j, u, t);\n        }\n        if (u != 0) ans += Math.ceil(cnt * 1.0 / t);\n        return cnt;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int N = 100010, M = 2 * N, idx = 0;\n    int he[100010], e[200020], ne[200020];\n    long long ans = 0;\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    long long minimumFuelCost(vector<vector<int>>& roads, int seats) {\n        int n = roads.size() + 1;\n        memset(he, -1, sizeof(he));\n        for (auto& r : roads) {\n            int a = r[0], b = r[1];\n            add(a, b); add(b, a);\n        }\n        dfs(0, -1, seats);\n        return ans;\n    }\n    int dfs(int u, int fa, int t) {\n        int cnt = 1;\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (j == fa) continue;\n            cnt += dfs(j, u, t);\n        }\n        if (u != 0) ans += ceil(cnt * 1.0 / t);\n        return cnt;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:\n        n, m, ans = len(roads) + 1, len(roads) * 2 + 1, 0\n        he, e, ne, idx = [-1] * n, [0] * m, [0] * m, 0\n\n        def add(a, b):\n            nonlocal idx\n            e[idx] = b\n            ne[idx] = he[a]\n            he[a] = idx\n            idx += 1\n\n        def dfs(u, fa, t):\n            nonlocal ans\n            cnt = 1\n            i = he[u]\n            while i != -1:\n                j, i = e[i], ne[i]\n                if j == fa: continue\n                cnt += dfs(j, u, t)\n            if u != 0:\n                ans += math.ceil(cnt * 1.0 / t)\n            return cnt\n\n        for a, b in roads:\n            add(a, b)\n            add(b, a)\n        dfs(0, -1, seats)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction minimumFuelCost(roads: number[][], seats: number): number {\n    const n = roads.length + 1, m = n * 2;\n    const he = Array(n).fill(-1), e = Array(m).fill(0), ne = Array(m).fill(0);\n    let ans = 0, idx = 0;\n    const add = function(a: number, b: number) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    const dfs = function(u: number, fa: number, t: number): number {\n        let cnt = 1;\n        for (let i = he[u]; i != -1; i = ne[i]) {\n            const j = e[i];\n            if (j == fa) continue;\n            cnt += dfs(j, u, t);\n        }\n        if (u != 0) ans += Math.ceil(cnt * 1.0 / t);\n        return cnt;\n    }\n    for (const [a, b] of roads) {\n        add(a, b); add(b, a);\n    }\n    dfs(0, -1, seats);\n    return ans;\n};\n```\n* 时间复杂度:建图复杂度为 $O(n)$;递归统计每个子树节点数量并计算油耗复杂度 $O(n)$;整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2477` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/251-260/258. 各位相加（简单）.md", "url_title": "258. 各位相加", "url": "https://leetcode-cn.com/problems/add-digits/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-zdml/", "difficulty": "简单", "tags": ["模拟", "数学"], "question": "给定一个非负整数 `num`,反复将各个位上的数字相加,直到结果为一位数。返回这个结果。\n\n示例 1:\n```\n输入: num = 38\n\n输出: 2 \n\n解释: 各位相加的过程为:\n38 --> 3 + 8 --> 11\n11 --> 1 + 1 --> 2\n由于 2 是一位数,所以返回 2。\n```\n示例 1:\n```\n输入: num = 0\n\n输出: 0\n```\n\n提示:\n* $0 <= num <= 2^{31} - 1$\n\n进阶:你可以不使用循环或者递归,在 $O(1)$ 时间复杂度内解决这个问题吗?", "solution": "### 模拟\n\n一个直观的做法是根据题意进行模拟,只要 `num` 位数多于 $1$ 位就可以继续做。\n\n代码:\n```Java\nclass Solution {\n    public int addDigits(int num) {\n        while (num > 9) {\n            int t = 0;\n            while (num != 0) {\n                t += num % 10;\n                num /= 10;\n            }\n            num = t;\n        }\n        return num;\n    }\n}\n```\n* 时间复杂度:$O(\\log{num})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 数学\n\n这题还是道对 [同余定理](https://baike.baidu.com/item/%E5%90%8C%E4%BD%99%E5%AE%9A%E7%90%86/1212360) 应用的题目。\n\n对于任意一个正整数而言,我们最终是要求得 $a_0 + a_1 + a_2 + ... + a_{n - 1}$ 对 $9$ 取模的数。\n\n而利用「同余式相加」性质,等价于每个数分别对 $9$ 取模之和,再集合任意的 $10^n$ 对 $9$ 取模恒为 $1$,可得最终答案为原数对 $9$ 取模,剩下只需要对相加结果为 $9$ 的边界情况进行处理即可。\n\n代码:\n```Java\nclass Solution {\n    public int addDigits(int num) {\n        return (num - 1) % 9 + 1;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.258` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/251-260/260. 只出现一次的数字 III（中等）.md", "url_title": "260. 只出现一次的数字 III", "url": "https://leetcode-cn.com/problems/single-number-iii/solution/gong-shui-san-xie-yi-ti-shuang-jie-ha-xi-zgi4/", "difficulty": "中等", "tags": ["模拟", "哈希表", "异或"], "question": "给定一个整数数组 `nums`,其中恰好有两个元素只出现一次,其余所有元素均出现两次。\n\n找出只出现一次的那两个元素,你可以按任意顺序返回答案。\n\n示例 1:\n\n```\n输入:nums = [1,2,1,3,2,5]\n\n输出:[3,5]\n\n解释:[5, 3] 也是有效的答案。\n```\n示例 2:\n```\n输入:nums = [-1,0]\n\n输出:[-1,0]\n```\n示例 3:\n```\n输入:nums = [0,1]\n\n输出:[1,0]\n```\n提示:\n* $2 <= nums.length <= 3 \\times 10^4$\n\n* $-2^{31} <= nums[i] <= 2^{31} - 1$\n\n* 除两个只出现一次的整数外,`nums` 中的其他数字都出现两次\n\n进阶:你的算法应该具有线性时间复杂度,你能否仅使用常数空间复杂度来实现?", "solution": "### 哈希表\n\n朴素的做法是利用哈希表进行统计,最后将统计次数为 $1$ 的元素加入答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] singleNumber(int[] nums) {\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i : nums) map.put(i, map.getOrDefault(i, 0) + 1);\n        int[] ans = new int[2];\n        int idx = 0;\n        for (int i : nums) {\n            if (map.get(i) == 1) ans[idx++] = i;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> singleNumber(vector<int>& nums) {\n        unordered_map<int, int> cmap;\n        for (int num : nums) cmap[num]++;\n        vector<int> ans;\n        for (int num : nums) {\n            if (cmap[num] == 1) ans.push_back(num);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def singleNumber(self, nums: List[int]) -> List[int]:\n        count_map = Counter(nums)\n        return [num for num in nums if count_map[num] == 1]\n```\nTypeScript 代码:\n```TypeScript\nfunction singleNumber(nums: number[]): number[] {\n    const countMap: Map<number, number> = new Map();\n    for (const num of nums) countMap.set(num, (countMap.get(num) || 0) + 1);\n    const ans: number[] = [];\n    for (const num of nums) {\n        if (countMap.get(num) === 1) ans.push(num);\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 异或\n\n利用除答案以外的元素均出现两次,我们可以先对 $nums$ 中的所有元素执行异或操作,得到 $sum$,$sum$ 为两答案的异或值($sum$ 必然不为 $0$)。\n\n然后取 $sum$ 二进制表示中为 $1$ 的任意一位 $k$,$sum$ 中的第 $k$ 位为 $1$ 意味着两答案的第 $k$ 位二进制表示不同。\n\n对 $nums$ 进行遍历,对第 $k$ 位分别为 $0$ 和 $1$ 的元素分别求异或和(两答案必然会被分到不同的组),即为答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] singleNumber(int[] nums) {\n        int sum = 0, k = -1;\n        for (int i : nums) sum ^= i;\n        for (int i = 31; i >= 0 && k == -1; i--) {\n            if (((sum >> i) & 1) == 1) k = i;\n        }\n        int[] ans = new int[2];\n        for (int i : nums) {\n            if (((i >> k) & 1) == 1) ans[1] ^= i;\n            else ans[0] ^= i;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> singleNumber(vector<int>& nums) {\n        int sum = 0, k = -1;\n        for (int num : nums) sum ^= num;\n        for (int i = 31; i >= 0 && k == -1; i--) {\n            if ((sum >> i) & 1) k = i;\n        }\n        vector<int> ans(2, 0);\n        for (int num : nums) {\n            if ((num >> k) & 1) ans[1] ^= num;\n            else ans[0] ^= num;\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def singleNumber(self, nums: List[int]) -> List[int]:\n        sum_val, k = 0, -1\n        for num in nums: sum_val ^= num\n        for i in range(31, -1, -1):\n            if (sum_val >> i) & 1:\n                k = i\n                break\n        ans = [0, 0]\n        for num in nums:\n            if (num >> k) & 1: ans[1] ^= num\n            else: ans[0] ^= num\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction singleNumber(nums: number[]): number[] {\n    let sum = 0, k = -1;\n    for (const num of nums) sum ^= num;\n    for (let i = 31; i >= 0 && k === -1; i--) {\n        if (((sum >> i) & 1) === 1) k = i;\n    }\n    const ans: number[] = [0, 0];\n    for (const num of nums) {\n        if (((num >> k) & 1) === 1) ans[1] ^= num;\n        else ans[0] ^= num;\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.260` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2511-2520/2520. 统计能整除数字的位数（简单）.md", "url_title": "2520. 统计能整除数字的位数", "url": "https://leetcode.cn/problems/count-the-digits-that-divide-a-number/solutions/2498966/gong-shui-san-xie-jian-dan-mo-ni-ti-shi-0ad2c/?envType=daily-question&envId=2023-10-26", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个整数 `num`,返回 `num` 中能整除 `num` 的数位的数目。\n\n如果满足 `nums % val == 0`,则认为整数 `val` 可以整除 `nums`。\n\n示例 1:\n```\n输入:num = 7\n\n输出:1\n\n解释:7 被自己整除,因此答案是 1 。\n```\n示例 2:\n```\n输入:num = 121\n\n输出:2\n\n解释:121 可以被 1 整除,但无法被 2 整除。由于 1 出现两次,所以返回 2 。\n```\n示例 3:\n```\n输入:num = 1248\n\n输出:4\n\n解释:1248 可以被它每一位上的数字整除,因此答案是 4 。\n```\n\n提示:\n* $1 <= num <= 10^9$\n* `num` 的数位中不含 `0`", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n假设起始值为 `num`,符合要求的数位个数为 `ans`,按照「从低到高」的方式循环处理 `num` 中的每个数位:\n\n1. 每次仅对当前数值 `num` 的最低位进行判断(当前数值 `num` 会被不断更新),**通过「模 $10$」的方式来「截取当前数值的最低位」**,并根据要求进行判断,若当前数位符合要求,对 `ans` 进行加一;\n\n2. 判断完当前数组 `num` 的最低位后,**通过「与 $10$ 地板除」的方式来「摒弃当前数值的最低位」**,并以此更新 `num`;\n\n3. 循环步骤 `1` 和步骤 `2`,直到 `num` 所有数位均被处理完,即 `num = 0`。\n\n用题面的示例 3 来举个 🌰,给定 `num = 1248`,完整处理过程如下:\n\n1. 当前数 `num = 1248`,通过 `mod 10` 取最低位 `8`,该数值满足要求,`ans = 1`;\n\n   通过 `// 10` 摒弃已处理的最低位,得到 `num = 124`\n\n2. 当前数 `num = 124`,通过 `mod 10` 取最低位 `4`,该数值满足要求,`ans = 2`;\n\n   通过 `// 10` 摒弃已处理的最低位,得到 `num = 12`\n\n3. 当前数 `num = 12`,通过 `mod 10` 取最低位 `2`,该数值满足要求,`ans = 3`;\n\n   通过 `// 10` 摒弃已处理的最低位,得到 `num = 1`\n\n4. 当前数 `num = 1`,通过 `mod 10` 取最低位 `1`,该数值满足要求,`ans = 4`;\n\n   通过 `// 10` 摒弃已处理的最低位,得到 `num = 0`,循环结束\n\nJava 代码:\n```Java\nclass Solution {\n    public int countDigits(int num) {\n        int n = num, ans = 0;\n        while (num != 0) {\n            ans += n % (num % 10) == 0 ? 1 : 0;\n            num /= 10;\n        }\n        return ans;\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def countDigits(self, num: int) -> int:\n        return sum(num % int(i) == 0 for i in str(num))\n        \n        # n, ans = num, 0\n        # while num != 0:\n        #     ans += n % (num % 10) == 0\n        #     num //= 10\n        # return ans\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int countDigits(int num) {\n        int n = num, ans = 0;\n        while (num != 0) {\n            ans += n % (num % 10) == 0;\n            num /= 10;\n        }\n        return ans;\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nfunction countDigits(num: number): number {\n    let n = num, ans = 0;\n    while (num !== 0) {\n        ans += n % (num % 10) == 0 ? 1 : 0;\n        num = Math.floor(num / 10);\n    }\n    return ans;\n};\n```\nKotlin 代码:\n```Kotlin\nclass Solution {\n    fun countDigits(num: Int): Int {\n        return num.toString().count { x -> num % (x - '0') == 0 }\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2520` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2551-2560/2558. 从数量最多的堆取走礼物（简单）.md", "url_title": "2558. 从数量最多的堆取走礼物", "url": "https://leetcode.cn/problems/take-gifts-from-the-richest-pile/solutions/2501825/gong-shui-san-xie-ke-shi-hua-shou-xie-du-pp3a/", "difficulty": "简单", "tags": ["优先队列(堆)"], "question": "给你一个整数数组 `gifts`,表示各堆礼物的数量。\n\n每一秒,你需要执行以下操作:\n\n* 选择礼物数量最多的那一堆。\n\n* 如果不止一堆都符合礼物数量最多,从中选择任一堆即可。\n\n* 选中的那一堆留下平方根数量的礼物(向下取整),取走其他的礼物。\n\n返回在 `k` 秒后剩下的礼物数量。\n\n示例 1:\n```\n输入:gifts = [25,64,9,4,100], k = 4\n\n输出:29\n\n解释: \n按下述方式取走礼物:\n- 在第一秒,选中最后一堆,剩下 10 个礼物。\n- 接着第二秒选中第二堆礼物,剩下 8 个礼物。\n- 然后选中第一堆礼物,剩下 5 个礼物。\n- 最后,再次选中最后一堆礼物,剩下 3 个礼物。\n最后剩下的礼物数量分别是 [5,8,9,4,3] ,所以,剩下礼物的总数量是 29 。\n```\n示例 2:\n```\n输入:gifts = [1,1,1,1], k = 4\n\n输出:4\n\n解释:\n在本例中,不管选中哪一堆礼物,都必须剩下 1 个礼物。 \n也就是说,你无法获取任一堆中的礼物。 \n所以,剩下礼物的总数量是 4 。\n```\n\n提示:\n* $1 <= gifts.length <= 10^3$\n* $1 <= gifts[i] <= 10^9$\n* $1 <= k <= 10^3$", "solution": "### 基本思想\n\n为了方便,将 `gifts` 记为 `gs`。\n\n从题面看,数组大小和执行次数范围均为 $1e3$,那么暴力做法的复杂度为 $O(n^2)$,计算量为 $1e6$,是可以通过的。\n\n稍有数据结构基础的同学,容易进一步联想:存在一种数据结构,能够快速查得集合最值,使复杂度降低。\n\n该数据结构是「堆」,在某些 `STL`  里面又称为「优先队列」。\n\n---\n\n### 手写堆入门\n\n所有高级数据结构(例如之前讲过的 [字典树 Trie] 或 [并查集],都可以使用数组进行模拟,堆自然也不例外。\n\n**堆本质是数据集合,只不过区别于简单数组而言,其具有 $O(1)$ 查找最值特性。**\n\n既然我们使用数组来实现堆,同时又需要实现 $O(1)$ 查找最值,一个自然而然的想法,是把集合最值放到数组的特定位置,例如数组起始位置。\n\n开始之前,先来了解一下,堆的基本操作:\n\n* `add`:往堆中增加元素\n* `peek`:快速查得最值\n* `pop`:将最值从堆中移除\n\n我们以小根堆为例,进行学习。\n\n> PS. 大根堆亦是同理,如果已经有写好的小根堆模板,那么将数值进行符号翻转,即可实现大根堆;或是翻转模板中的数值比较逻辑,也可将小根堆轻松切换成大根堆。\n\n#### 1. 堆长啥样?\n\n堆是数组实现的,但其形态为「完全二叉树」(最多只有底下一层节点不满),目的是尽量让树平衡,降低树的高度,从而更高效的维护其性质。\n\n虽是「完全二叉树」,但其又和另外一种特殊二叉树,二叉搜索树(`BST`)不同。\n\n在 `BST`  的定义中:任意节点的左子树上的节点值均不大于该节点,任意节点的右子树上的节点值均不小于该节点。\n\n在小根堆对应的「完全二叉树」定义中:任意节点的节点值均不大于其左右子树中的节点值。\n\n因此将小根堆可视化后,也十分形象:小根堆的堆顶元素最小,然后从上往下,元素“依次”增大。\n\n{:width=400}\n\n即对于小根堆而言,每个子树的根节点,都是该子树的最小值。\n\n#### 2. 如何用数组进行「完全二叉树」的存储?\n\n我们只需要将「二叉树的左右子节点关系」和「数组下标」实现某种关联即可。\n\n我们约定,对于某个节点,若其所在数组下标为 $idx$,那么该节点的左子节点的数组下标为 $2 \\times idx$,该节点的右子节点的数组下标为 $2 \\times idx + 1$。\n\n注意:基于此规则,我们需要调整数组下标从 $1$ 开始进行存储。\n\n{:width=400}\n\n#### 3.基本操作如何实现?\n\n所有操作的核心最终都归结到:如何通过有限的调整,重新恢复堆所对应的完全二叉树中的节点定义。\n\n因此可抽象出 `up` 操作和 `down` 操作,俩操作均通过递归实现:\n\n* `up` 操作是将当前节点 `u` 与父节点 `fa = u / 2` 进行比较,若发现父节点更大,则将两者进行互换,并递归处理父节点\n* `down` 操作是将当前节点 `cur` 和左右节点 `l = cur * 2` 和 `r = cur * 2 + 1` 进行比较,若当前节点并非三者最小,则进行互换,并递归处理子节点\n\n通过上述核心 `up` 和 `down` 操作,以及「完全二叉树」在数组的放置规则,我们可以容易拼凑出堆的基本操作。\n\n假定当前使用一维数组 `heap` 实现堆,使用变量 `sz` 记录当前堆的元素个数,同时该变量充当 `heap` 的结尾游标:\n\n* `add`:往堆中增加元素\n  该操作可转换为:往数组尾部增加元素(`heap[sz++] = x`),并从尾部开始重整堆(`up(sz)`)\n* `peek`:快速查得最小值\n  直接范围数组首位元素,注意下标从 $1$ 开始,`heap[1]`\n* `pop`:将最值从堆中移除\n  先通过 `peek` 操作记录下待移除的最小值,然后将数组的结尾元素和首位元素互换,并更新数组长度减一(`heap[1] = heap[sz--]`),随后从头部开始重整堆(`down(1)`)\n\nJava 完整模板:\n```Java\nint[] heap = new int[10010];\nint sz = 0;\nvoid swap(int a, int b) {\n    int c = heap[a];\n    heap[a] = heap[b];\n    heap[b] = c;\n}\nvoid up(int u) {\n    // 将「当前节点 i」与「父节点 i / 2」进行比较, 若父节点值更大, 则进行交换\n    int fa = u / 2;\n    if (fa != 0 && heap[fa] > heap[u]) {\n        swap(fa, u);\n        up(fa);\n    }\n}\nvoid down(int u) {\n    // 将当「前节点 cur」与「左节点 l」及「右节点 r」进行比较, 找出最小值, 若当前节点不是最小值, 则进行交换\n    int cur = u;\n    int l = u * 2, r = u * 2 + 1;\n    if (l <= sz && heap[l] < heap[cur]) cur = l;\n    if (r <= sz && heap[r] < heap[cur]) cur = r;\n    if (cur != u) {\n        swap(cur, u);\n        down(cur);\n    }\n}\nvoid add(int x) {\n    heap[++sz] = x;\n    up(sz);\n}\nint peek() {\n    return heap[1];\n}\nint pop() {\n    int ans = peek();\n    heap[1] = heap[sz--];\n    down(1);\n    return ans;\n}\n```\nC++ 完整模板:\n```C++\nint heap[1010];\nint sz = 0;\nvoid up(int u) {\n    int fa = u / 2;\n    if (fa && heap[fa] >= heap[u]) {\n        swap(heap[fa], heap[u]);\n        up(fa);\n    }\n}\nvoid down(int u) {\n    int cur = u;\n    int l = cur * 2, r = cur * 2 + 1;\n    if (l <= sz && heap[l] < heap[cur]) cur = l;\n    if (r <= sz && heap[r] < heap[cur]) cur = r;\n    if (cur != u) {\n        swap(heap[cur], heap[u]);\n        down(cur);\n    }\n}\nvoid add(int x) {\n    heap[++sz] = x;\n    up(sz);\n}\nint peek() {\n    return heap[1];\n}\nint poll() {\n    int ans = peek();\n    heap[1] = heap[sz--];\n    down(1);\n    return ans;\n}\n```\n\n---\n\n### 模板运用\n\n利用「上述模板」以及「小根堆如何当大根堆」使用,我们可以轻松解决本题。\n\n1. 起始先将逐元素进行符号翻转并入堆\n2. 执行 `k` 次取出并重放操作(注意符号转换)\n3. 统计所有元素之和,由于此时不再需要查询最值,可通过直接扫描数组的方式(注意符号转换)\n\nJava 代码:\n```Java\nclass Solution {\n    int[] heap = new int[10010];\n    int sz = 0;\n    public long pickGifts(int[] gs, int k) {\n        for (int x : gs) add(-x);\n        while (k-- > 0) add(-(int)Math.sqrt(-pop()));\n        long ans = 0;\n        while (sz != 0) ans += -heap[sz--];  // 没必要再维持堆的有序, 直接读取累加\n        return ans;\n    }\n    void swap(int a, int b) {\n        int c = heap[a];\n        heap[a] = heap[b];\n        heap[b] = c;\n    }\n    void up(int u) {\n        // 将「当前节点 i」与「父节点 i / 2」进行比较, 若父节点值更大, 则进行交换\n        int fa = u / 2;\n        if (fa != 0 && heap[fa] > heap[u]) {\n            swap(fa, u);\n            up(fa);\n        }\n    }\n    void down(int u) {\n        // 将当「前节点 cur」与「左节点 l」及「右节点 r」进行比较, 找出最小值, 若当前节点不是最小值, 则进行交换\n        int cur = u;\n        int l = u * 2, r = u * 2 + 1;\n        if (l <= sz && heap[l] < heap[cur]) cur = l;\n        if (r <= sz && heap[r] < heap[cur]) cur = r;\n        if (cur != u) {\n            swap(cur, u);\n            down(cur);\n        }\n    }\n    void add(int x) {\n        heap[++sz] = x;\n        up(sz);\n    }\n    int peek() {\n        return heap[1];\n    }\n    int pop() {\n        int ans = peek();\n        heap[1] = heap[sz--];\n        down(1);\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int heap[1010];\n    int sz = 0;\n    long long pickGifts(vector<int>& gs, int k) {\n        for (int x : gs) add(-x);\n        while (k--) add(-sqrt(-poll()));\n        long ans = 0;\n        while (sz != 0) ans += -heap[sz--];\n        return ans;\n    }\n    void up(int u) {\n        int fa = u / 2;\n        if (fa && heap[fa] >= heap[u]) {\n            swap(heap[fa], heap[u]);\n            up(fa);\n        }\n    }\n    void down(int u) {\n        int cur = u;\n        int l = cur * 2, r = cur * 2 + 1;\n        if (l <= sz && heap[l] < heap[cur]) cur = l;\n        if (r <= sz && heap[r] < heap[cur]) cur = r;\n        if (cur != u) {\n            swap(heap[cur], heap[u]);\n            down(cur);\n        }\n    }\n    void add(int x) {\n        heap[++sz] = x;\n        up(sz);\n    }\n    int peek() {\n        return heap[1];\n    }\n    int poll() {\n        int ans = peek();\n        heap[1] = heap[sz--];\n        down(1);\n        return ans;\n    }\n};\n```\n* 时间复杂度:建堆复杂度为 $O(n\\log{n})$;执行 `k` 次操作复杂度为 $O(k\\log{n})$;构建答案复杂度为 $O(n)$。整体复杂度为 $O((n + k) \\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2558` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2581-2590/2586. 统计范围内的元音字符串数（简单）.md", "url_title": "2586. 统计范围内的元音字符串数", "url": "https://leetcode.cn/problems/count-the-number-of-vowel-strings-in-range/solutions/2515898/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-di1t/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个下标从 $0$ 开始的字符串数组 `words` 和两个整数:`left` 和 `right`。\n\n如果字符串以元音字母开头并以元音字母结尾,那么该字符串就是一个 元音字符串 ,其中元音字母是 `'a'`、`'e'`、`'i'`、`'o'`、`'u'`。\n\n返回 $words[i]$ 是元音字符串的数目,其中 `i` 在闭区间 $[left, right]$ 内。\n\n示例 1:\n```\n输入:words = [\"are\",\"amy\",\"u\"], left = 0, right = 2\n\n输出:2\n\n解释:\n- \"are\" 是一个元音字符串,因为它以 'a' 开头并以 'e' 结尾。\n- \"amy\" 不是元音字符串,因为它没有以元音字母结尾。\n- \"u\" 是一个元音字符串,因为它以 'u' 开头并以 'u' 结尾。\n在上述范围中的元音字符串数目为 2 。\n```\n示例 2:\n```\n输入:words = [\"hey\",\"aeo\",\"mu\",\"ooo\",\"artro\"], left = 1, right = 4\n\n输出:3\n\n解释:\n- \"aeo\" 是一个元音字符串,因为它以 'a' 开头并以 'o' 结尾。\n- \"mu\" 不是元音字符串,因为它没有以元音字母开头。\n- \"ooo\" 是一个元音字符串,因为它以 'o' 开头并以 'o' 结尾。\n- \"artro\" 是一个元音字符串,因为它以 'a' 开头并以 'o' 结尾。\n在上述范围中的元音字符串数目为 3 。\n```\n\n提示:\n* $1 <= words.length <= 1000$\n* $1 <= words[i].length <= 10$\n* $words[i]$ 仅由小写英文字母组成\n* $0 <= left <= right < words.length$", "solution": "### 模拟\n\n检查下标范围在 $[left, right]$ 内的字符串 $words[i]$,若当前 $words[i]$ 首尾字母为 `aeiou` 之一,进行计数。\n\nJava 代码:\n\n```Java\nclass Solution {\n    public int vowelStrings(String[] words, int left, int right) {\n        int ans = 0;\n        for (int i = left; i <= right; i++) {\n            String s = words[i];\n            char a = s.charAt(0), b = s.charAt(s.length() - 1);\n            if (\"aeiou\".indexOf(a) != -1 && \"eaiou\".indexOf(b) != -1) ans++;\n        }\n        return ans;\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def vowelStrings(self, words: List[str], left: int, right: int) -> int:\n        return sum(1 for i in range(left, right + 1) if words[i][0] in \"aeiou\" and words[i][-1] in \"aeiou\")\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int vowelStrings(vector<string>& words, int left, int right) {\n        int ans = 0;\n        for (int i = left; i <= right; i++) {\n            string s = words[i];\n            if (s.find_first_of(\"aeiou\") == 0 && s.find_last_of(\"aeiou\") == s.length() - 1) ans++;\n        }\n        return ans;\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nfunction vowelStrings(words: string[], left: number, right: number): number {\n    let ans = 0;\n    for (let i = left; i <= right; i++) {\n        const s = words[i];\n        if (\"aeiou\".includes(s[0]) && \"aeiou\".includes(s.charAt(s.length - 1))) ans++;\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2586` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2601-2610/2609. 最长平衡子字符串（简单）.md", "url_title": "2609. 最长平衡子字符串", "url": "https://leetcode.cn/problems/find-the-longest-balanced-substring-of-a-binary-string/solutions/2517437/gong-shui-san-xie-on-shi-jian-o1-kong-ji-i8e7/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个仅由 `0` 和 `1` 组成的二进制字符串 `s` 。  \n\n如果子字符串中 所有的 `0` 都在 `1` 之前 且其中 `0` 的数量等于 `1` 的数量,则认为 `s` 的这个子字符串是平衡子字符串。\n\n请注意,空子字符串也视作平衡子字符串。 \n\n返回  `s` 中最长的平衡子字符串长度。\n\n子字符串是字符串中的一个连续字符序列。\n\n示例 1:\n```\n输入:s = \"01000111\"\n\n输出:6\n\n解释:最长的平衡子字符串是 \"000111\" ,长度为 6 。\n```\n示例 2:\n```\n输入:s = \"00111\"\n\n输出:4\n\n解释:最长的平衡子字符串是 \"0011\" ,长度为  4 。\n```\n示例 3:\n```\n输入:s = \"111\"\n\n输出:0\n\n解释:除了空子字符串之外不存在其他平衡子字符串,所以答案为 0 。\n```\n\n提示:\n* $1 <= s.length <= 50$\n* `'0' <= s[i] <= '1'`", "solution": "### 模拟\n\n根据题意,平衡子字符串必然满足 `0...01...1` 格式(前半段全是 `0`,后半段全是 `1`,前后两段长度相同)。\n\n使用变量 `idx` 对 `s` 进行遍历。在每轮处理过程中,按照如下流程进行:\n\n1. 先统计连续段 `0` 的长度,记为 `a`;再统计连续段 `1` 的长度,记为 `b`(此操作满足:子串中 `0` 均在 `1` 前面)\n2. 在 `a` 和 `b` 中取较小值,进行乘 $2$ 操作,作为当前平衡子字符串的长度,用于更新答案(此操作满足:子串中 `0` 和 `1` 数量相同)\n3. 从当前轮的结束位置 `idx`,再进行下轮处理(重复步骤 $1$ 和步骤 $2$),直到 `s` 处理完成\n\nJava 代码:\n\n```Java\nclass Solution {\n    public int findTheLongestBalancedSubstring(String s) {\n        int n = s.length(), idx = 0, ans = 0;\n        while (idx < n) {\n            int a = 0, b = 0;\n            while (idx < n && s.charAt(idx) == '0' && ++a >= 0) idx++;\n            while (idx < n && s.charAt(idx) == '1' && ++b >= 0) idx++;\n            ans = Math.max(ans, Math.min(a, b) * 2);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int findTheLongestBalancedSubstring(string s) {\n        int n = s.size(), idx = 0, ans = 0;\n        while (idx < n) {\n            int a = 0, b = 0;\n            while (idx < n && s[idx] == '0' && ++a >= 0) idx++;\n            while (idx < n && s[idx] == '1' && ++b >= 0) idx++;\n            ans = max(ans, min(a, b) * 2);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def findTheLongestBalancedSubstring(self, s: str) -> int:\n        n, idx, ans = len(s), 0, 0\n        while idx < n:\n            a, b = 0, 0\n            while idx < n and s[idx] == '0':\n                a, idx = a + 1, idx + 1\n            while idx < n and s[idx] == '1':\n                b, idx = b + 1, idx + 1\n            ans = max(ans, min(a, b) * 2)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction findTheLongestBalancedSubstring(s: string): number {\n    let n = s.length, idx = 0, ans = 0;\n    while (idx < n) {\n        let a = 0, b = 0;\n        while (idx < n && s[idx] == '0' && ++a >= 0) idx++;\n        while (idx < n && s[idx] == '1' && ++b >= 0) idx++;\n        ans = Math.max(ans, Math.min(a, b) * 2);\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2609` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/261-270/263. 丑数（简单）.md", "url_title": "263. 丑数", "url": "https://leetcode-cn.com/problems/ugly-number/solution/gong-shui-san-xie-jian-dan-de-fen-qing-k-dlvg/", "difficulty": "简单", "tags": ["数学", "模拟"], "question": "给你一个整数 `n` ,请你判断 n 是否为 丑数 。如果是,返回 `true` ;否则,返回 `false` 。\n\n丑数 就是只包含质因数 `2`、`3` 和 `5` 的正整数。\n\n示例 1:\n```\n输入:n = 6\n\n输出:true\n\n解释:6 = 2 × 3\n```\n示例 2:\n```\n输入:n = 8\n\n输出:true\n\n解释:8 = 2 × 2 × 2\n```\n示例 3:\n```\n输入:n = 14\n\n输出:false\n\n解释:14 不是丑数,因为它包含了另外一个质因数 7 。\n```\n示例 4:\n```\n输入:n = 1\n\n输出:true\n\n解释:1 通常被视为丑数。\n```\n\n提示:\n* $-2^{31} <= n <= 2^{31} - 1$", "solution": "### 朴素解法\n\n输入范围是 $-2^{31} <= n <= 2^{31} - 1$,我们只需要对输入进行分情况讨论即可:\n\n* 如果 $n$ 不是正整数(即小于等于 0):必然不是丑数,直接返回 `false`。\n* 如果 $n$ 是正整数:我们对 $n$ 执行 `2`、 `3`、 `5` 的整除操作即可,直到 $n$ 被除干净,如果 $n$ 最终为 1 说明是丑数,否则不是丑数。\n\n注意,`2` `3` `5` 先除哪一个都是可以的,因为乘法本身具有交换律。\n\n代码:\n```java\nclass Solution {\n    public boolean isUgly(int n) {\n        if (n <= 0) return false;\n        while (n % 2 == 0) n /= 2;\n        while (n % 3 == 0) n /= 3;\n        while (n % 5 == 0) n /= 5;\n        return n == 1;\n    }\n}\n```\n* 时间复杂度:当 $n$ 是以 $2$ 为底的对数时,需要除以 $\\log{n}$ 次。复杂度为 $O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.263` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/261-270/264. 丑数 II（中等）.md", "url_title": "264. 丑数 II", "url": "https://leetcode-cn.com/problems/ugly-number-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-you-x-3nvs/", "difficulty": "中等", "tags": ["多路归并", "优先队列(堆)"], "question": "给你一个整数 `n` ,请你找出并返回第 `n` 个 丑数 。\n\n丑数 就是只包含质因数 `2`、`3` 和 `5` 的正整数。\n\n示例 1:\n```\n输入:n = 10\n\n输出:12\n\n解释:[1, 2, 3, 4, 5, 6, 8, 9, 10, 12] 是由前 10 个丑数组成的序列。\n```\n示例 2:\n```\n输入:n = 1\n\n输出:1\n\n解释:1 通常被视为丑数。\n```\n\n提示:\n* $1 <= n <= 1690$", "solution": "### 基本思路\n\n根据丑数的定义,我们有如下结论:\n\n* $1$ 是最小的丑数。\n* 对于任意一个丑数 $x$,其与任意的质因数($2$、$3$、$5$)相乘,结果($2x$、$3x$、$5x$)仍为丑数。\n\n---\n\n### 优先队列(小根堆)\n\n有了基本的分析思路,一个简单的解法是使用优先队列:\n\n1. 起始先将最小丑数 $1$ 放入队列\n2. 每次从队列取出最小值 $x$,然后将 $x$ 所对应的丑数 $2x$、$3x$ 和 $5x$ 进行入队。\n3. 对步骤 2 循环多次,第 $n$ 次出队的值即是答案。\n\n为了防止同一丑数多次进队,我们需要使用数据结构 $Set$ 来记录入过队列的丑数。\n\nJava 代码:\n```Java\nclass Solution {\n    int[] nums = new int[]{2,3,5};\n    public int nthUglyNumber(int n) {\n        Set<Long> set = new HashSet<>();\n        Queue<Long> pq = new PriorityQueue<>();\n        set.add(1L);\n        pq.add(1L);\n        for (int i = 1; i <= n; i++) {\n            long x = pq.poll();\n            if (i == n) return (int)x;\n            for (int num : nums) {\n                long t = num * x;\n                if (!set.contains(t)) {\n                    set.add(t);\n                    pq.add(t);\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution(object):\n    def nthUglyNumber(self, n):\n        \"\"\"\n        :type n: int\n        :rtype: int\n        \"\"\"\n        nums = [2,3,5]\n        explored = {1}\n        pq = [1]\n        for i in range(1, n+1):\n            x = heapq.heappop(pq)\n            if i == n:\n                return x\n            for num in nums:\n                t = num * x\n                if t not in explored:\n                    explored.add(t)\n                    heapq.heappush(pq,t)\n        return -1\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int nthUglyNumber(int n) {\n        int nums[] = {2, 3, 5};\n        set<long> s;\n        priority_queue<long, vector<long>, greater<long>> q;\n        s.insert(1);\n        q.push(1);\n        for (int i = 1; i <= n; i++)\n        {\n            long x = q.top();\n            q.pop();\n            if (i == n)\n                return (int)x;\n            for (int num = 0; num < 3; num++)\n            {\n                long t = nums[num] * x;\n                if (!s.count(t))\n                {\n                    s.insert(t);\n                    q.push(t);\n                }\n            }\n        }\n        return -1;\n    }\n};\n```\n* 时间复杂度:从优先队列中取最小值为 $O(1)$,往优先队列中添加元素复杂度为 $O(\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 多路归并(多指针)\n\n从解法一中不难发现,我们「往后产生的丑数」都是基于「已有丑数」而来(使用「已有丑数」乘上「质因数」$2$、$3$、$5$)。\n\n因此,如果我们所有丑数的有序序列为 $a1,a2,a3,...,an$ 的话,序列中的每一个数都必然能够被以下三个序列(中的至少一个)覆盖:\n\n* 由丑数 $\\times 2$ 所得的有序序列:$1 \\times 2$、$2 \\times 2$、$3 \\times 2$、$4 \\times 2$、$5 \\times 2$、$6 \\times 2$、$8 \\times 2$ ...\n* 由丑数 $ \\times 3$ 所得的有序序列:$1 \\times 3$、$2 \\times 3$、$3 \\times 3$、$4 \\times 3$、$5 \\times 3$、$6 \\times 3$、$8 \\times 3$ ...\n* 由丑数 $\\times 5$ 所得的有序序列:$1 \\times 5$、$2 \\times 5$、$3 \\times 5$、$4 \\times 5$、$5 \\times 5$、$6 \\times 5$、$8 \\times 5$ ...\n\n举个🌰,假设我们需要求得 $[1, 2, 3, ... , 10, 12]$ 丑数序列 $arr$ 的最后一位,那么该序列可以看作以下三个有序序列归并而来:\n\n* $1 \\times 2, 2 \\times 2, 3 \\times 2, ... , 10 \\times 2, 12 \\times 2$ ,将 $2$ 提出,即 $arr \\times 2$\n* $1 \\times 3, 2 \\times 3, 3 \\times 3, ... , 10 \\times 3, 12 \\times 3$ ,将 $3$ 提出,即 $arr \\times 3$\n* $1 \\times 5, 2 \\times 5, 3 \\times 5, ... , 10 \\times 5, 12 \\times 5$ ,将 $5$ 提出,即 $arr \\times 5$\n\n因此我们可以使用三个指针来指向目标序列 $arr$ 的某个下标(下标 $0$ 作为哨兵不使用,起始都为 $1$),使用 $arr[下标] \\times 质因数$ 代表当前使用到三个有序序列中的哪一位,同时使用 $idx$ 表示当前生成到 $arr$ 哪一位丑数。\n\nJava 代码:\n```Java\nclass Solution {\n    public int nthUglyNumber(int n) {\n        // ans 用作存储已有丑数(从下标 1 开始存储,第一个丑数为 1)\n        int[] ans = new int[n + 1];\n        ans[1] = 1;\n        // 由于三个有序序列都是由「已有丑数」*「质因数」而来\n        // i2、i3 和 i5 分别代表三个有序序列当前使用到哪一位「已有丑数」下标(起始都指向 1)\n        for (int i2 = 1, i3 = 1, i5 = 1, idx = 2; idx <= n; idx++) {\n            // 由 ans[iX] * X 可得当前有序序列指向哪一位\n            int a = ans[i2] * 2, b = ans[i3] * 3, c = ans[i5] * 5;\n            // 将三个有序序列中的最小一位存入「已有丑数」序列,并将其下标后移\n            int min = Math.min(a, Math.min(b, c));\n            // 由于可能不同有序序列之间产生相同丑数,因此只要一样的丑数就跳过(不能使用 else if )\n            if (min == a) i2++; \n            if (min == b) i3++;\n            if (min == c) i5++;\n            ans[idx] = min;\n        }\n        return ans[n];\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution(object):\n    def nthUglyNumber(self, n):\n        \"\"\"\n        :type n: int\n        :rtype: int\n        \"\"\"\n        # ans 用作存储已有丑数(从下标 1 开始存储,第一个丑数为 1)\n        ans = [0] * (n+1)\n        ans[1] = 1\n        # 由于三个有序序列都是由「已有丑数」*「质因数」而来\n        # i2、i3 和 i5 分别代表三个有序序列当前使用到哪一位「已有丑数」下标(起始都指向 1)\n        i2 = i3 = i5 = 1\n        idx = 2\n        while idx <= n:\n            # 由 ans[iX] * X 可得当前有序序列指向哪一位\n            a,b,c = ans[i2] *2,ans[i3]*3,ans[i5]*5\n            # 将三个有序序列中的最小一位存入「已有丑数」序列,并将其下标后移\n            m = min(a,b,c)\n            # 由于可能不同有序序列之间产生相同丑数,因此只要一样的丑数就跳过(不能使用 else if )\n            if m == a:\n                i2 += 1\n            if m == b:\n                i3 += 1\n            if m == c:\n                i5 += 1\n            ans[idx] = m\n            idx += 1\n        return ans[n]\n```\nJavaScript 代码:\n```JavaScript\n/**\n * @param {number} n\n * @return {number}\n */\nvar nthUglyNumber = function(n) {\n    const ans=new Array(n+1);\n    ans[1]=1;\n    for(let i2=1, i3=1, i5=1, idx=2;idx<=n;idx++){\n        let a=ans[i2]*2, b=ans[i3]*3, c=ans[i5]*5;\n        let min=Math.min(a, b, c);\n        if(min===a) i2++;\n        if(min===b) i3++;\n        if(min===c) i5++;\n        ans[idx]=min;\n    }\n    return ans[n];\n};\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int nthUglyNumber(int n) {\n        // 存储丑数\n        int *arr = new int[n + 1];\n        arr[1] = 1;\n        \n        for (int x = 1, y = 1, z = 1, index = 2; index <= n; index++){\n            int a = arr[x] * 2, b = arr[y] * 3, c = arr[z] * 5;\n            int m = min(a, min(b, c));\n            if (m == a)x++;\n            if (m == b)y++;\n            if (m == c)z++;\n            arr[index] = m;\n        }\n        int ans = arr[n];\n        delete[] arr;\n        return ans;\n    }\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.264` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/261-270/268. 丢失的数字（简单）.md", "url_title": "268. 丢失的数字", "url": "https://leetcode-cn.com/problems/missing-number/solution/gong-shui-san-xie-yi-ti-wu-jie-pai-xu-ji-te3s/", "difficulty": "简单", "tags": ["模拟", "哈希表", "位运算", "数学"], "question": "给定一个包含 $[0, n]$ 中 $n$ 个数的数组 $nums$ ,找出 $[0, n]$ 这个范围内没有出现在数组中的那个数。\n\n示例 1:\n```\n输入:nums = [3,0,1]\n\n输出:2\n\n解释:n = 3,因为有 3 个数字,所以所有的数字都在范围 [0,3] 内。2 是丢失的数字,因为它没有出现在 nums 中。\n```\n示例 2:\n```\n输入:nums = [0,1]\n\n输出:2\n\n解释:n = 2,因为有 2 个数字,所以所有的数字都在范围 [0,2] 内。2 是丢失的数字,因为它没有出现在 nums 中。\n```\n示例 3:\n```\n输入:nums = [9,6,4,2,3,5,7,0,1]\n\n输出:8\n\n解释:n = 9,因为有 9 个数字,所以所有的数字都在范围 [0,9] 内。8 是丢失的数字,因为它没有出现在 nums 中。\n```\n示例 4:\n```\n输入:nums = [0]\n\n输出:1\n\n解释:n = 1,因为有 1 个数字,所以所有的数字都在范围 [0,1] 内。1 是丢失的数字,因为它没有出现在 nums 中。\n```\n\n提示:\n* n == nums.length\n* $1 <= n <= 10^4$\n* $0 <= nums[i] <= n$\n* nums 中的所有数字都 独一无二\n\n进阶:你能否实现线性时间复杂度、仅使用额外常数空间的算法解决此问题?", "solution": "### 排序\n\n一个简单的做法是直接对 $nums$ 进行排序,找到符合 $nums[i] \\neq i$ 的位置即是答案,如果不存在 $nums[i] \\neq i$ 的位置,则 $n$ 为答案。\n\n代码;\n```Java\nclass Solution {\n    public int missingNumber(int[] nums) {\n        int n = nums.length;\n        Arrays.sort(nums);\n        for (int i = 0; i < n; i++) {\n            if (nums[i] != i) return i;\n        }\n        return n;\n    }\n}\n```\n* 时间复杂度:假定 `Arrays.sort` 使用的是双轴快排实现。复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$\n\n---\n\n### 数组哈希 \n\n利用 $nums$ 的数值范围为 $[0,n]$,且只有一个值缺失,我们可以直接开一个大小为 $n + 1$ 的数组充当哈希表,进行计数,没被统计到的数值即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int missingNumber(int[] nums) {\n        int n = nums.length;\n        boolean[] hash = new boolean[n + 1];\n        for (int i = 0; i < n; i++) hash[nums[i]] = true;\n        for (int i = 0; i < n; i++) {\n            if (!hash[i]) return i;\n        }\n        return n;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 原地哈希\n\n事实上,我们可以将 $nums$ 本身作为哈希表进行使用,将 $nums[i]$ 放到其应该出现的位置 $i$ 上( $i < n$ ),然后对 $nums$ 进行检查,找到满足 $nums[i] \\neq i$ 的位置即是答案,如果不存在 $nums[i] \\neq i$ 的位置,则 $n$ 为答案。\n\n代码:\n```Java\nclass Solution {\n    public int missingNumber(int[] nums) {\n        int n = nums.length;\n        for (int i = 0; i < n; i++) {\n            if (nums[i] != i && nums[i] < n) swap(nums, nums[i], i--);\n        }\n        for (int i = 0; i < n; i++) {\n            if (nums[i] != i) return i;\n        }\n        return n;\n    }\n    void swap(int[] nums, int i, int j) {\n        int c = nums[i];\n        nums[i] = nums[j];\n        nums[j] = c;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 作差法\n\n利用 $nums$ 的数值范围为 $[1, n]$,我们可以先计算出 $[1, n]$ 的总和 $sum$(利用等差数列求和公式),再计算 $nums$ 的总和 $cur$,两者之间的差值即是 $nums$ 中缺失的数字。\n\n代码:\n```Java\nclass Solution {\n    public int missingNumber(int[] nums) {\n        int n = nums.length;\n        int cur = 0, sum = n * (n + 1) / 2;\n        for (int i : nums) cur += i;\n        return sum - cur;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 异或\n\n找缺失数、找出现一次数都是异或的经典应用。\n\n我们可以先求得 $[1, n]$ 的异或和 $ans$,然后用 $ans$ 对各个 $nums[i]$ 进行异或。\n\n这样最终得到的异或和表达式中,只有缺失元素出现次数为 $1$ 次,其余元素均出现两次($x ⊕x = 0$),即最终答案 $ans$ 为缺失元素。\n\n代码:\n```Java\nclass Solution {\n    public int missingNumber(int[] nums) {\n        int n = nums.length;\n        int ans = 0;\n        for (int i = 0; i <= n; i++) ans ^= i;\n        for (int i : nums) ans ^= i;\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.268` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2641-2650/2646. 最小化旅行的价格总和（困难）.md", "url_title": "2646. 最小化旅行的价格总和", "url": null, "difficulty": "困难", "tags": ["图", "DFS"], "question": "现有一棵无向、无根的树,树中有 `n` 个节点,按从 `0` 到 `n - 1` 编号。\n\n给你一个整数 `n` 和一个长度为 `n - 1` 的二维整数数组 `edges`,其中 $edges[i] = [a_{i}, b_{i}]$ 表示树中节点 $a_{i}$ 和 $b_{i}$ 之间存在一条边。\n\n每个节点都关联一个价格。给你一个整数数组 `price`,其中 `price[i]` 是第 `i` 个节点的价格。\n\n给定路径的价格总和是该路径上所有节点的价格之和。\n\n另给你一个二维整数数组 `trips`,其中 $trips[i] = [start_{i}, end_{i}]$ 表示您从节点 $start_{i}$ 开始第 $i$ 次旅行,并通过任何你喜欢的路径前往节点 $end_{i}$。\n\n在执行第一次旅行之前,你可以选择一些非相邻节点并将价格减半。\n\n返回执行所有旅行的最小价格总和。\n\n示例 1:\n\n```\n输入:n = 4, edges = [[0,1],[1,2],[1,3]], price = [2,2,10,6], trips = [[0,3],[2,1],[2,3]]\n\n输出:23\n\n解释:\n上图表示将节点 2 视为根之后的树结构。第一个图表示初始树,第二个图表示选择节点 0 、2 和 3 并使其价格减半后的树。\n第 1 次旅行,选择路径 [0,1,3] 。路径的价格总和为 1 + 2 + 3 = 6 。\n第 2 次旅行,选择路径 [2,1] 。路径的价格总和为 2 + 5 = 7 。\n第 3 次旅行,选择路径 [2,1,3] 。路径的价格总和为 5 + 2 + 3 = 10 。\n所有旅行的价格总和为 6 + 7 + 10 = 23 。可以证明,23 是可以实现的最小答案。\n```\n示例 2:\n\n```\n输入:n = 2, edges = [[0,1]], price = [2,2], trips = [[0,0]]\n\n输出:1\n\n解释:\n上图表示将节点 0 视为根之后的树结构。第一个图表示初始树,第二个图表示选择节点 0 并使其价格减半后的树。 \n第 1 次旅行,选择路径 [0] 。路径的价格总和为 1 。 \n所有旅行的价格总和为 1 。可以证明,1 是可以实现的最小答案。\n```\n\n提示:\n* $1 <= n <= 50$\n* $edges.length = n - 1$\n* $0 <= a_{i}, b_{i} <= n - 1$\n* `edges` 表示一棵有效的树\n* $price.length = n$\n* $price[i]$ 是一个偶数\n* $1 <= price[i] <= 1000$\n* $1 <= trips.length <= 100$\n* $0 <= start_{i}, end_{i} <= n - 1$", "solution": "### DFS\n\nJava 代码:\n\n```Java\nclass Solution {\n    int N = 55, M = N * 2, idx = 0;\n    int[] he = new int[N], e = new int[M], ne = new int[M];\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    public int minimumTotalPrice(int n, int[][] edges, int[] price, int[][] trips) {\n        Arrays.fill(he, -1);\n        for (int[] info : edges) {\n            add(info[0], info[1]); add(info[1], info[0]);\n        }\n        int[] cnt = new int[n];\n        for (int[] trip : trips) dfs1(trip[0], -1, trip[1], cnt);\n        int[] ans = dfs2(0, -1, price, cnt);\n        return Math.min(ans[0], ans[1]);\n    }\n    int[] dfs2(int u, int fa, int[] price, int[] cnt) {\n        int a = price[u] / 2 * cnt[u], b = price[u] * cnt[u];\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (j == fa) continue;\n            int[] info = dfs2(j, u, price, cnt);\n            int c = info[0], d = info[1];\n            a += d; b += Math.min(c, d);\n        }\n        return new int[]{a, b};\n    }\n    boolean dfs1(int u, int fa, int end, int[] cnt) {\n        if (u == end) {\n            cnt[u]++;\n            return true;\n        }\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (j == fa) continue;\n            if (dfs1(j, u, end, cnt)) {\n                cnt[u]++;\n                return true;\n            }\n        }\n        return false;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int he[55], e[55 * 2], ne[55 * 2], idx = 0;\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    int minimumTotalPrice(int n, vector<vector<int>>& edges, vector<int>& price, vector<vector<int>>& trips) {\n        memset(he, -1, sizeof(he));\n        for (auto& info : edges) {\n            add(info[0], info[1]); add(info[1], info[0]);\n        }\n        vector<int> cnt(n, 0);\n        for (auto& trip : trips) dfs1(trip[0], -1, trip[1], cnt);\n        vector<int> ans = dfs2(0, -1, price, cnt);\n        return min(ans[0], ans[1]);\n    }\n    vector<int> dfs2(int u, int fa, vector<int>& price, vector<int>& cnt) {\n        int a = price[u] / 2 * cnt[u], b = price[u] * cnt[u];\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (j == fa) continue;\n            vector<int> info = dfs2(j, u, price, cnt);\n            int c = info[0], d = info[1];\n            a += d; b += min(c, d);\n        }\n        return {a, b};\n    }\n    bool dfs1(int u, int fa, int end, vector<int>& cnt) {\n        if (u == end) {\n            cnt[u]++;\n            return true;\n        }\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (j == fa) continue;\n            if (dfs1(j, u, end, cnt)) {\n                cnt[u]++;\n                return true;\n            }\n        }\n        return false;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:    \n    def minimumTotalPrice(self, n: int, edges: List[List[int]], price: List[int], trips: List[List[int]]) -> int:\n        idx = 0\n        he, e, ne = [-1] * n, [0] * n * 2, [0] * n * 2\n\n        def add(a, b):\n            nonlocal idx\n            e[idx], ne[idx], he[a] = b, he[a], idx\n            idx += 1\n    \n        def dfs1(u, fa, end):\n            if u == end:\n                cnt[u] += 1\n                return True\n            i = he[u]\n            while i != -1:\n                j, i = e[i], ne[i]\n                if j == fa: continue\n                if dfs1(j, u, end):\n                    cnt[u] += 1\n                    return True\n            return False\n        \n        def dfs2(u, fa):\n            a, b = price[u] // 2 * cnt[u], price[u] * cnt[u]\n            i = he[u]\n            while i != -1:\n                j, i = e[i], ne[i]\n                if j == fa: continue\n                c, d = dfs2(j, u)\n                a += d\n                b += min(c, d)\n            return [a, b]\n\n        for info in edges:\n            add(info[0], info[1])\n            add(info[1], info[0])\n        cnt = [0] * n\n        for trip in trips:\n            dfs1(trip[0], -1, trip[1])\n        ans = dfs2(0, -1)\n        return min(ans[0], ans[1])\n```\nTypeScript 代码:\n```TypeScript\nfunction minimumTotalPrice(n: number, edges: number[][], price: number[], trips: number[][]): number {\n    let N = n + 10, M = N * 2, idx = 0;\n    const he = Array(N).fill(-1), e = Array(N).fill(0), ne = Array(N).fill(0);\n    const add = function(a: number, b: number): void {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    };\n    const dfs1 = function(u: number, fa: number, end: number): boolean {\n        if (u == end) {\n            cnt[u]++;\n            return true;\n        }\n        for (let i = he[u]; i != -1; i = ne[i]) {\n            const j = e[i];\n            if (j == fa) continue;\n            if (dfs1(j, u, end)) {\n                cnt[u]++;\n                return true;\n            }\n        }\n        return false;\n    };\n    const dfs2 = function(u: number, fa: number): number[] {\n        let a = price[u] / 2 * cnt[u], b = price[u] * cnt[u];\n        for (let i = he[u]; i != -1; i = ne[i]) {\n            const j = e[i];\n            if (j == fa) continue;\n            const [c, d] = dfs2(j, u);\n            a += d; b += Math.min(c, d);\n        }\n        return [a, b];\n    }\n    for (const [a, b] of edges) {\n        add(a, b); add(b, a);\n    }\n    const cnt = Array(N).fill(0)\n    for (const [a, b] of trips) dfs1(a, -1, b);\n    const [a, b] = dfs2(0, -1);\n    return Math.min(a, b);\n};\n```\n* 时间复杂度:令 `m` 为 `trips` 的大小,建图复杂度为 $O(n)$;统计完成 `trips` 时,每个点的经过次数 `cnt` 的复杂度为 $O(m \\times n)$;最后统计答案复杂度为 $O(n)$。整体复杂度为 $O(m \\times n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2646` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2651-2660/2656. K 个元素的最大和（简单）.md", "url_title": "2656. K 个元素的最大和", "url": "https://leetcode.cn/problems/maximum-sum-with-exactly-k-elements/solutions/2527384/gong-shui-san-xie-deng-chai-shu-lie-qiu-b2g88/", "difficulty": "简单", "tags": ["数学"], "question": "给你一个下标从 `0` 开始的整数数组 `nums` 和一个整数 `k` 。\n\n你需要执行以下操作恰好 `k` 次,最大化你的得分:\n\n1. 从 `nums` 中选择一个元素 `m` 。\n2. 将选中的元素 `m` 从数组中删除。\n3. 将新元素 `m + 1` 添加到数组中。\n4. 你的得分增加 `m` 。\n\n请你返回执行以上操作恰好 `k` 次后的最大得分。\n\n示例 1:\n```\n输入:nums = [1,2,3,4,5], k = 3\n\n输出:18\n\n解释:我们需要从 nums 中恰好选择 3 个元素并最大化得分。\n第一次选择 5 。和为 5 ,nums = [1,2,3,4,6] 。\n第二次选择 6 。和为 6 ,nums = [1,2,3,4,7] 。\n第三次选择 7 。和为 5 + 6 + 7 = 18 ,nums = [1,2,3,4,8] 。\n所以我们返回 18 。\n18 是可以得到的最大答案。\n```\n示例 2:\n```\n输入:nums = [5,5,5], k = 2\n\n输出:11\n\n解释:我们需要从 nums 中恰好选择 2 个元素并最大化得分。\n第一次选择 5 。和为 5 ,nums = [5,5,6] 。\n第二次选择 6 。和为 6 ,nums = [5,5,7] 。\n所以我们返回 11 。\n11 是可以得到的最大答案。\n```\n\n提示:\n* $1 <= nums.length <= 100$\n* $1 <= nums[i] <= 100$\n* $1 <= k <= 100$", "solution": "### 数学\n\n为了使得分最高,每次应从 `nums` 中选最大值,选完后重放仍为最大值。\n\n假设原始 `nums` 中的最大值为 `max`,那么问题转换为「等差数列」求和:首项为 `max`,末项为 `max + k - 1`,项数为 $k$,公差为 $1$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maximizeSum(int[] nums, int k) {\n        int max = 0;\n        for (int x : nums) max = Math.max(max, x);\n        return k * (max + max + k - 1) / 2;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maximizeSum(vector<int>& nums, int k) {\n        int maxv = 0;\n        for (auto x : nums) maxv = max(maxv, x);\n        return k * (maxv + maxv + k - 1) / 2;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maximizeSum(self, nums: List[int], k: int) -> int:\n        return k * (2 * max(nums) + k - 1) // 2\n```\nTypeScript 代码:\n```TypeScript\nfunction maximizeSum(nums: number[], k: number): number {\n    let max = 0;\n    for (const x of nums) max = Math.max(max, x);\n    return k * (max + max + k - 1) / 2;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2656` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2661-2670/2661. 找出叠涂元素（中等）.md", "url_title": "2661. 找出叠涂元素", "url": "https://leetcode.cn/problems/first-completely-painted-row-or-column/solutions/2549034/gong-shui-san-xie-chang-gui-ha-xi-biao-y-jkxa/", "difficulty": "中等", "tags": ["模拟", "哈希表", "计数"], "question": "给你一个下标从 $0$ 开始的整数数组 `arr` 和一个 $m \\times n$ 的整数矩阵 `mat`。\n\n`arr` 和 `mat` 都包含范围 $[1,m \\times n]$ 内的所有整数。\n\n从下标 $0$ 开始遍历 `arr` 中的每个下标 `i` ,并将包含整数 `arr[i]` 的 `mat` 单元格涂色。\n\n请你找出 `arr` 中在 `mat` 的某一行或某一列上都被涂色且下标最小的元素,并返回其下标 $i$ 。\n\n示例 1:\n\n```\n输入:arr = [1,3,4,2], mat = [[1,4],[2,3]]\n\n输出:2\n\n解释:遍历如上图所示,arr[2] 在矩阵中的第一行或第二列上都被涂色。\n```\n示例 2:\n\n```\nimage explanation for example 2\n\n输入:arr = [2,8,7,4,1,3,5,6,9], mat = [[3,2,5],[1,4,6],[8,7,9]]\n\n输出:3\n\n解释:遍历如上图所示,arr[3] 在矩阵中的第二列上都被涂色。\n```\n\n提示:\n* $m = mat.length$\n* $n = mat[i].length$\n* $arr.length = m \\times n$\n* $1 <= m, n <= 10^5$\n* $1 <= m \\times n <= 105$\n* $1 <= arr[i], mat[r][c] <= m \\times n$\n* `arr` 中的所有整数互不相同\n* `mat` 中的所有整数互不相同", "solution": "### 哈希表\n\n利用 `mat` 的数值各不相同,先使用「哈希表」对 `mat` 进行转存,以 $mat[i][j]$ 为键,$(i, j)$ 为值,方便后续快速查询某个值所在位置。\n\n创建数组 `c1` 和 `c2`,分别记录某行某列有多少单元格被涂色,如 `c1[x] = a` 代表第 $x$ 行被涂色单元格数量为 $a$ 个,`c2[y] = b` 代表第 $y$ 列被涂色单元格数量为 $b$ 个。\n\n遍历所有的 $arr[i]$,查询到 $arr[i]$ 的所在位置 $(x, y)$ 后,更新 `c1` 和 `c2`,若某行或某列被完全涂色,返回当前下标。\n\nJava 代码:\n\n```Java\nclass Solution {\n    public int firstCompleteIndex(int[] arr, int[][] mat) {\n        int n = mat.length, m = mat[0].length;\n        Map<Integer, int[]> map = new HashMap<>();\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                map.put(mat[i][j], new int[]{i, j});\n            }\n        }\n        int[] c1 = new int[n], c2 = new int[m];\n        for (int i = 0; i < n * m; i++) {\n            int[] info = map.get(arr[i]);\n            int x = info[0], y = info[1];\n            if (++c1[x] == m || ++c2[y] == n) return i;\n        }\n        return -1; // never\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int firstCompleteIndex(vector<int>& arr, vector<vector<int>>& mat) {\n        int n = mat.size(), m = mat[0].size();\n        unordered_map<int, pair<int, int>> map;\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                map[mat[i][j]] = make_pair(i, j);\n            }\n        }\n        vector<int> c1(n), c2(m);\n        for (int i = 0; i < n * m; i++) {\n            pair<int, int> info = map[arr[i]];\n            int x = info.first, y = info.second;\n            if (++c1[x] == m || ++c2[y] == n) return i;\n        }\n        return -1; // never\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def firstCompleteIndex(self, arr: List[int], mat: List[List[int]]) -> int:\n        n, m = len(mat), len(mat[0])\n        mapping = {mat[i][j]: (i, j) for i in range(n) for j in range(m)}\n        c1, c2 = [0] * n, [0] * m\n        for i in range(n * m):\n            x, y = mapping[arr[i]]\n            c1[x], c2[y] = c1[x] + 1, c2[y] + 1\n            if c1[x] == m or c2[y] == n: return i\n        return -1  # never\n```\nTypeScript 代码:\n```TypeScript\nfunction firstCompleteIndex(arr: number[], mat: number[][]): number {\n    const n = mat.length, m = mat[0].length;\n    const map: { [key: number]: [number, number] } = {};\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < m; j++) {\n            map[mat[i][j]] = [i, j];\n        }\n    }\n    const c1 = new Array(n).fill(0), c2 = new Array(m).fill(0);\n    for (let i = 0; i < n * m; i++) {\n        const [x, y] = map[arr[i]];\n        if (++c1[x] == m || ++c2[y] === n) return i;\n    }\n    return -1; // never\n};\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n \\times m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2661` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2698-2700/2698. 求一个整数的惩罚数（中等）.md", "url_title": "2698. 求一个整数的惩罚数", "url": "https://leetcode.cn/problems/find-the-punishment-number-of-an-integer/solutions/2497448/gong-shui-san-xie-jian-dan-di-gui-yun-yo-qdxl/", "difficulty": "中等", "tags": ["递归", "模拟", "打表"], "question": "给你一个正整数 $n$,请你返回 $n$ 的 惩罚数 。\n\n$n$ 的 惩罚数 定义为所有满足以下条件 $i$ 的数的平方和:\n\n* $1 <= i <= n$\n\n* $i \\times i$ 的十进制表示的字符串可以分割成若干连续子字符串,且这些子字符串对应的整数值之和等于 $i$ 。\n\n示例 1:\n```\n输入:n = 10\n\n输出:182\n\n解释:总共有 3 个整数 i 满足要求:\n- 1 ,因为 1 * 1 = 1\n- 9 ,因为 9 * 9 = 81 ,且 81 可以分割成 8 + 1 。\n- 10 ,因为 10 * 10 = 100 ,且 100 可以分割成 10 + 0 。\n因此,10 的惩罚数为 1 + 81 + 100 = 182\n```\n示例 2:\n```\n输入:n = 37\n\n输出:1478\n\n解释:总共有 4 个整数 i 满足要求:\n- 1 ,因为 1 * 1 = 1\n- 9 ,因为 9 * 9 = 81 ,且 81 可以分割成 8 + 1 。\n- 10 ,因为 10 * 10 = 100 ,且 100 可以分割成 10 + 0 。\n- 36 ,因为 36 * 36 = 1296 ,且 1296 可以分割成 1 + 29 + 6 。\n因此,37 的惩罚数为 1 + 81 + 100 + 1296 = 1478\n```\n\n提示:\n* $1 <= n <= 1000$", "solution": "### 递归\n\n一个朴素的做法是遍历 $[1, i]$,若当前数值 $i$ 满足要求,则将 $i \\times i$ 累加到答案中。\n\n问题关键转为:如何判定 $i \\times i$ 是否能够分割成多个整数,使其累加值为 $i$。\n\n简单做法是通过递归来做:每次从当前值的低位开始截取,通过「取余」和「地板除」操作,得到截取部分和剩余部分,再继续递归处理。\n\nJava 代码:\n\n```Java\nclass Solution {\n    public int punishmentNumber(int n) {\n        int ans = 0;\n        for (int i = 1; i <= n; i++) {\n            if (check(i * i, i)) ans += i * i;\n        }\n        return ans;\n    }\n    boolean check(int t, int x) {\n        if (t == x) return true;\n        int d = 10;\n        while (t >= d && t % d <= x) {\n            if (check(t / d, x - (t % d))) return true;\n            d *= 10;\n        }\n        return false;\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def punishmentNumber(self, n: int) -> int:\n        def check(t, x):\n            if t == x:\n                return True\n            d = 10\n            while t >= d and t % d <= x:\n                if check(t // d, x - (t % d)):\n                    return True\n                d *= 10\n            return False\n        return sum([i * i if check(i * i, i) else 0 for i in range(1, n + 1)])\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool check(int t, int x) {\n        if (t == x) return true;\n        int d = 10;\n        while (t >= d && t % d <= x) {\n            if (check(t / d, x - (t % d))) return true;\n            d *= 10;\n        }\n        return false;\n    }\n    int punishmentNumber(int n) {\n        int ans = 0;\n        for (int i = 1; i <= n; i++) {\n            if (check(i * i, i)) ans += i * i;\n        }\n        return ans;\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nfunction punishmentNumber(n: number): number {\n    function check(t: number, x: number): boolean {\n        if (t === x) return true;\n        let d = 10;\n        while (t >= d && t % d <= x) {\n            if (check(Math.floor(t / d), x - (t % d))) return true;\n            d *= 10;\n        }\n        return false;\n    }\n    let ans = 0;\n    for (let i = 1; i <= n; i++) {\n        if (check(i * i, i)) ans += i * i;\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n \\log{n^2})$\n* 空间复杂度:$O(\\log{n^2})$\n\n---\n\n### 打表\n\n更进一步,对于 $[1, x]$ 范围内的惩罚数必然包含了 $[1, y]$(其中 $y < x$)中的惩罚数。\n\n即多个样例之间必然存在重复计算,我们可通过「打表」进行预处理:定义 $f[i]$ 为 $n = i$ 时的答案(惩罚数),对于 $f[i]$ 而言,起始为 $f[i - 1]$,若数值 $i$ 本身满足要求,则将 $i \\times i$ 累加到 $f[i]$ 当中。\n\nJava 代码:\n```Java\nclass Solution {\n    static int[] f = new int[1010];\n    static {\n        for (int i = 1; i <= 1000; i++) {\n            f[i] = f[i - 1];\n            if (check(i * i, i)) f[i] += i * i;\n        }\n    }\n    static boolean check(int t, int x) {\n        if (t == x) return true;\n        int d = 10;\n        while (t >= d && t % d <= x) {\n            if (check(t / d, x - (t % d))) return true;\n            d *= 10;\n        }\n        return false;\n    }\n    public int punishmentNumber(int n) {\n        return f[n];\n    }\n}\n```\nPython 代码:\n```Python\ndef check(t, x):\n    if t == x:\n        return True\n    d = 10\n    while t >= d and t % d <= x:\n        if check(t // d, x - (t % d)):\n            return True\n        d *= 10\n    return False\nf = [0] * 1010\nfor i in range(1, 1010):\n    f[i] = f[i - 1] + (i * i if check(i * i, i) else 0)\nclass Solution:\n    def punishmentNumber(self, n: int) -> int:\n        return f[n]\n```\nC++ 代码:\n```C++\ninline bool check(int t, int x) {\n    if (t == x) return true;\n    int d = 10;\n    while (t >= d && t % d <= x) {\n        if (check(t / d, x - (t % d))) return true;\n        d *= 10;\n    }\n    return false;\n}\nint f[1010];\nint _ = []() {\n    for (int i = 1; i < 1010; i++) {\n        f[i] = f[i - 1];\n        if (check(i * i, i)) f[i] += i * i;\n    }\n    return 0;\n}();\nclass Solution {\npublic:\n    int punishmentNumber(int n) {\n        return f[n];\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nfunction check(t: number, x: number): boolean {\n    if (t === x) return true;\n    let d = 10;\n    while (t >= d && t % d <= x) {\n        if (check(Math.floor(t / d), x - (t % d))) return true;\n        d *= 10;\n    }\n    return false;\n}\nconst f = new Array(1010).fill(0);\nfor (let i = 1; i < 1010; i++) {\n    f[i] = f[i - 1];\n    if (check(i * i, i)) f[i] += i * i;\n}\nfunction punishmentNumber(n: number): number {\n    return f[n];\n};\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(C)$,其中 $C = 1000$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2698` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/271-280/273. 整数转换英文表示（困难）.md", "url_title": "273. 整数转换英文表示", "url": "https://leetcode-cn.com/problems/integer-to-english-words/solution/gong-shui-san-xie-zi-fu-chuan-da-mo-ni-b-0my6/", "difficulty": "困难", "tags": ["模拟"], "question": "将非负整数 `num` 转换为其对应的英文表示。\n\n示例 1:\n```\n输入:num = 123\n\n输出:\"One Hundred Twenty Three\"\n```\n示例 2:\n```\n输入:num = 12345\n\n输出:\"Twelve Thousand Three Hundred Forty Five\"\n```\n示例 3:\n```\n输入:num = 1234567\n\n输出:\"One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven\"\n```\n示例 4:\n```\n输入:num = 1234567891\n\n输出:\"One Billion Two Hundred Thirty Four Million Five Hundred Sixty Seven Thousand Eight Hundred Ninety One\"\n```\n\n提示:\n* $0 <= num <= 2^{31} - 1$", "solution": "### 模拟\n\n字符串大模拟,重点之一是考察大家对数字英文单词的熟练程度。🤣\n\n首先,英文好的同学自然知道数字表示是每三位一组进行的,英文不好的可能需要通过样例来找找规律。\n\n由于是每三位一组进行表示,首要考虑实现一个 `num2Str` 函数,将十进制长度小于等于 $3$ 位的数字表示出来,然后在后面配合 `Billion`、`Million` 和 `Thousand` 即可表示出范围不超过 $2^{32}-1$ 的任意数字。\n\n从定义出发 `num2Str` 需要解决 $[0, 999]$ 范围内的所有整数,但由于该函数需要复用到更大的位数来配合 `Billion`、`Million` 和 `Thousand`,而 `Zero Billion` 并不是一个合法的描述,因此我们需要将 $0$ 抠出来特判,让 `num2Str` 对范围在 $[1, 999]$ 的数值进行转换。\n\n考虑如何实现 `num2Str`,假设当前需要转换的数字为 $x$,我们可以对 $x$ 的大小进行分情况讨论:\n\n1. $x >= 100$:此时首先需要表示成 `??? hundred`,表示完后考虑更小的位数;\n2. $x >= 20$:此时需要表示成 `??? XXX-ty` 的形式,表示完后考虑更小的位数;\n3. $x < 20$:直接描述成具体的单词。\n\n实现完 `num2Str` 后,剩下的只需要考虑如何将入参 $num$ 拆分成每三位一组处理即可。\n\n代码:\n```Java\nclass Solution {\n    static String[] num2str_small = {\n        \"Zero\", \n        \"One\", \"Two\", \"Three\", \"Four\", \"Five\", \"Six\", \"Seven\", \"Eight\", \"Nine\", \"Ten\", \n        \"Eleven\", \"Twelve\", \"Thirteen\", \"Fourteen\", \"Fifteen\", \"Sixteen\", \"Seventeen\", \"Eighteen\", \"Nineteen\"\n    };\n    static String[] num2str_medium = {\n        \"\", \"\", \"Twenty\", \"Thirty\", \"Forty\", \"Fifty\", \"Sixty\", \"Seventy\", \"Eighty\", \"Ninety\"\n    };\n    static String[] num2str_large = {\n        \"Billion\", \"Million\", \"Thousand\", \"\",\n    };\n    String num2Str(int x) {\n        String ans = \"\";\n        if (x >= 100) {\n            ans += num2str_small[x / 100] + \" Hundred \";\n            x %= 100;\n        }\n        if (x >= 20) {\n            ans += num2str_medium[x / 10] + \" \";\n            x %= 10;\n        }\n        if (x != 0) ans += num2str_small[x] + \" \";\n        return ans;\n    }\n    public String numberToWords(int num) {\n        if (num == 0) return num2str_small[0];\n        StringBuilder sb = new StringBuilder();\n        for (int i = (int)1e9, j = 0; i >= 1; i /= 1000, j++) {\n            if (num < i) continue;\n            sb.append(num2Str(num / i) + num2str_large[j] + \" \");\n            num %= i;\n        }\n        while (sb.charAt(sb.length() - 1) == ' ') sb.deleteCharAt(sb.length() - 1);\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:令 $n$ 为 $num$ 数值大小,复杂度取决于最终构建的答案的长度,由于是每三位一组进行处理,同时每三位一组所转换的英文描述有明确的长度上界,因此最终答案长度与 $num$ 的十进制长度成线性关系,再根据 $num$ 的长度与 $num$ 数值的关系,可得最终复杂度为 $O(\\log{n})$\n* 空间复杂度:令 $n$ 为 $num$ 数值大小,复杂度取决于最终构建的答案的长度,由于是每三位一组进行处理,同时每三位一组所转换的英文描述有明确的长度上界,因此最终答案长度与 $num$ 的十进制长度成线性关系,再根据 $num$ 的长度与 $num$ 数值的关系,可得最终复杂度为 $O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.273` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/271-280/274. H 指数（中等）.md", "url_title": "274. H 指数", "url": "https://leetcode.cn/problems/h-index/solutions/2502896/gong-shui-san-xie-cong-po-ti-dao-zhu-bu-7sug6/", "difficulty": "中等", "tags": ["二分", "数学"], "question": "给你一个整数数组 `citations`,其中 `citations[i]` 表示研究者的第 `i` 篇论文被引用的次数。计算并返回该研究者的 h 指数。\n\n根据维基百科上 `h` 指数的定义:`h` 代表“高引用次数”,一名科研人员的 h指数是指他(她)的 (`n` 篇论文中)总共有 `h` 篇论文分别被引用了至少 `h` 次。且其余的 `n - h` 篇论文每篇被引用次数 不超过 `h` 次。\n\n如果 `h` 有多种可能的值,`h` 指数是其中最大的那个。\n\n示例 1:\n```\n输入:citations = [3,0,6,1,5]\n\n输出:3 \n\n解释:给定数组表示研究者总共有 5 篇论文,每篇论文相应的被引用了 3, 0, 6, 1, 5 次。\n由于研究者有 3 篇论文每篇 至少 被引用了 3 次,其余两篇论文每篇被引用 不多于 3 次,所以她的 h 指数是 3。\n```\n示例 2:\n```\n输入:citations = [1,3,1]\n\n输出:1\n```\n\n提示:\n* $n == citations.length$\n* $1 <= n <= 5000$\n* $0 <= citations[i] <= 1000$", "solution": "### 基本分析\n\n为了方便,将 `citations` 记为 `cs`。\n\n所谓的 `h` 指数是指一个具体的数值,**该数值为“最大”的满足「至少发表了 `x` 篇论文,且每篇论文至少被引用 `x` 次」定义的合法数,重点是“最大”**。\n\n用题面的实例 $1$ 来举个 🌰,给定所有论文的引用次数情况为 `cs = [3,0,6,1,5]`,可统计满足定义的数值有哪些:\n\n* $h = 0$,含义为「至少发表了 $0$ 篇,且这 $0$ 篇论文至少被引用 $0$ 次」,空集即满足,恒成立;\n\n* $h = 1$,含义为「至少发表了 $1$ 篇,且这 $1$ 篇论文至少被引用 $1$ 次」,可以找到这样的组合,如 `[3]`,成立;\n\n* $h = 2$,含义为「至少发表了 $2$ 篇,且这 $2$ 篇论文至少被引用 $2$ 次」,可以找到这样的组合,如 `[3, 6]`,成立;\n\n* $h = 3$,含义为「至少发表了 $3$ 篇,且这 $3$ 篇论文至少被引用 $3$ 次」,可以找到这样的组合,如 `[3, 6, 5]`,成立;\n\n* $h = 4$,含义为「至少发表了 $4$ 篇,且这 $4$ 篇论文至少被引用 $4$ 次」,找不到这样的组合,不成立;\n\n* ...\n\n实际上,**当遇到第一个无法满足的数时,更大的数值就没必要找了**。一个简单的推导:\n\n至少出现 $k$ 次的论文数不足 $k$ 篇 => 至少出现 $k + 1$ 次的论文必然不足 $k$ 篇 => 至少出现 $k + 1$ 次的论文必然不足 $k + 1$ 篇(即更大的 $h$ 不满足)。\n\n----\n\n### 二分\n\n基于此分析,我们发现对于任意的 `cs`(论文总数量为该数组长度 $n$),都必然对应了一个最大的 `h` 值,且**小于等于该 `h` 值的情况均满足,大于该 `h` 值的均不满足**。\n\n那么,**在以最大 `h` 值为分割点的数轴上具有「二段性」**,可通过「二分」求解该分割点(答案)。\n\n最后考虑在什么值域范围内进行二分?\n\n一个合格的二分范围,仅需确保答案在此范围内即可。\n\n再回看我们关于 `h` 的定义「至少发表了 `x` 篇论文,且每篇论文至少被引用 `x` 次」,满足条件除了引用次数,还有论文数量,而总的论文数量只有 $n$,因此最大的 `h` 只能是 $n$ 本身,而不能是比 $n$ 大的数,否则论文数量就不够了。\n\n综上,我们只需要在 $[0, n]$ 范围进行二分即可。对于任意二分值 `mid`,只需线性扫描 `cs` 即可知道其是否合法。\n\nJava 代码:\n```Java\nclass Solution {\n    public int hIndex(int[] cs) {\n        int n = cs.length;\n        int l = 0, r = n;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (check(cs, mid)) l = mid;\n            else r = mid - 1;\n        }\n        return r;\n    }\n    boolean check(int[] cs, int mid) {\n        int ans = 0;\n        for (int i : cs) if (i >= mid) ans++;\n        return ans >= mid;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int hIndex(vector<int>& cs) {\n        int n = cs.size();\n        int l = 0, r = n;\n        while (l < r) {\n            int mid = (l + r + 1) / 2;\n            if (check(cs, mid)) l = mid;\n            else r = mid - 1;\n        }\n        return r;\n    }\n    bool check(vector<int>& cs, int x) {\n        int cnt = 0;\n        for (int c : cs) {\n            if (c >= x) cnt++;\n        }\n        return cnt >= x;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def hIndex(self, cs: List[int]) -> int:\n        n = len(cs)\n        l, r = 0, n\n        while l < r:\n            mid = (l + r + 1) // 2\n            if sum(c >= mid for c in cs) >= mid:\n                l = mid\n            else:\n                r = mid - 1\n        return r\n```\nTypeScript 代码:\n```TypeScript\nfunction hIndex(cs: number[]): number {\n    const check = function (cs: number[], x: number): boolean {\n        let cnt: number = 0;\n        for (let c of cs) {\n            if (c >= x) cnt++;\n        }\n        return cnt >= x;\n    }\n    const n = cs.length;\n    let l = 0, r = n;\n    while (l < r) {\n        const mid = Math.floor((l + r + 1) / 2);\n        if (check(cs, mid)) l = mid;\n        else r = mid - 1;\n    }\n    return r;\n};\n```\n* 时间复杂度:对 $[0, n]$ 做二分,复杂度为 $O(\\log{n})$;`check` 函数需要对数组进行线性遍历,复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 计数\n\n根据分析,利用最大的 `h` 不超过 $n$,我们可以再进一步,利用空间换时间,将复杂度降低到 $O(n)$。\n\n假设我们预处理出引用次数所对应的论文数量 `cnt`,其中 `cnt[a] = b` 含义为引用次数 **恰好** 为 `a` 的论文数量有 `b` 篇。\n\n那么再利用 `h` 是“最大”的满足定义的合法数,我们从 $n$ 开始往前找,找到的第一个满足条件的数,即是答案。\n\n具体的,创建 `cnt` 数组,对 `cs` 进行计数,由于最大 `h` 不超过 $n$,因此对于引用次数超过 $n$ 的论文,可等价为引用次数为 $n$,即有计数逻辑 `cnt[min(c, n)]++`。\n\n再根据处理好的 `cnt`,从 $n$ 开始倒序找 `h`。\n\n由于我们处理的 `cnt[a]` 含义为引用次数 **恰好** 为 `a`,但题目定义则是 **至少**。同时「至少出现 $k + 1$ 次」的集合必然慢「至少出现 $k$ 次」要求(子集关系),我们可以使用变量 `tot`,对处理过的 `cnt[i]` 进行累加,从而实现从 **恰好** 到 **至少** 的转换。\n\nJava 代码:\n```Java\nclass Solution {\n    public int hIndex(int[] cs) {\n        int n = cs.length;\n        int[] cnt = new int[n + 10];\n        for (int c : cs) cnt[Math.min(c, n)]++;\n        for (int i = n, tot = 0; i >= 0; i--) {\n            tot += cnt[i];\n            if (tot >= i) return i;\n        }\n        return -1; // never\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int hIndex(vector<int>& cs) {\n        int n = cs.size();\n        vector<int> cnt(n + 10, 0);\n        for (int c : cs) cnt[min(c, n)]++;\n        for (int i = n, tot = 0; i >= 0; i--) {\n            tot += cnt[i];\n            if (tot >= i) return i;\n        }\n        return -1; // never\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def hIndex(self, cs: List[int]) -> int:\n        n = len(cs)\n        cnt = [0] * (n + 10)\n        for c in cs:\n            cnt[min(c, n)] += 1\n        tot = 0\n        for i in range(n, -1, -1):\n            tot += cnt[i]\n            if tot >= i:\n                return i\n        return -1  # never\n```\nTypeScript 代码:\n```TypeScript\nfunction hIndex(cs: number[]): number {\n    const n = cs.length;\n    const cnt = new Array(n + 10).fill(0);\n    for (let c of cs) cnt[Math.min(c, n)]++;\n    for (let i = n, tot = 0; i >= 0; i--) {\n        tot += cnt[i];\n        if (tot >= i) return i;\n    }\n    return -1; // never\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.274` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/271-280/275. H 指数 II（中等）.md", "url_title": "275. H 指数 II", "url": "https://leetcode.cn/problems/h-index-ii/solutions/2504414/gong-shui-san-xie-si-hua-guo-du-cong-xia-rs00/", "difficulty": "中等", "tags": ["二分", "数学"], "question": "给你一个整数数组 `citations`,其中 `citations[i]` 表示研究者的第 `i` 篇论文被引用的次数,`citations` 已经按照 **升序排列 **。计算并返回该研究者的 `h` 指数。\n\n`h` 指数的定义:`h` 代表“高引用次数”(high citations),一名科研人员的 `h` 指数是指他(她)的 (`n` 篇论文中)总共有 `h` 篇论文分别被引用了至少 `h` 次。\n\n请你设计并实现对数时间复杂度的算法解决此问题。\n\n示例 1:\n```\n输入:citations = [0,1,3,5,6]\n\n输出:3 \n\n解释:给定数组表示研究者总共有 5 篇论文,每篇论文相应的被引用了 0, 1, 3, 5, 6 次。\n     由于研究者有 3 篇论文每篇 至少 被引用了 3 次,其余两篇论文每篇被引用 不多于 3 次,所以她的 h 指数是 3 。\n```\n示例 2:\n```\n输入:citations = [1,2,100]\n\n输出:2\n```\n\n提示:\n* $n = citations.length$\n* $1 <= n <= 10^5$\n* $0 <= citations[i] <= 1000$\n* `citations` 按升序排列", "solution": "### 与前置题关系\n\n本题与前置题 [274. H 指数](https://leetcode.cn/problems/h-index/) 的不同,主要体现在两个方面:\n\n1. 数据范围不同:在 [274. H 指数](https://leetcode.cn/problems/h-index/) 里 $n$ 的范围为 $5000$,而本题 $n$ 的范围为 $10^5$;\n2. 数组是否有序:在 [274. H 指数](https://leetcode-cn.com/problems/h-index/) 中数组不确保有序,本题则是有序。\n\n增加了数组有序特性,又扩大了数据范围。\n\n容易联想,利用此特性,存在复杂度更低的算法。\n\n---\n\n### 基本分析\n\n为了方便,将 `citations` 记为 `cs`。\n\n所谓的 `h` 指数是指一个具体的数值,**该数值为“最大”的满足「至少发表了 `x` 篇论文,且每篇论文至少被引用 `x` 次」定义的合法数,重点是“最大”**。\n\n用题面的实例 $1$ 来举个 🌰,给定所有论文的引用次数情况为 `cs = [0,1,3,5,6]`,可统计满足定义的数值有哪些:\n\n* $h = 0$,含义为「至少发表了 $0$ 篇,且这 $0$ 篇论文至少被引用 $0$ 次」,空集即满足,恒成立;\n\n* $h = 1$,含义为「至少发表了 $1$ 篇,且这 $1$ 篇论文至少被引用 $1$ 次」,可以找到这样的组合,如 `[1]`,成立;\n\n* $h = 2$,含义为「至少发表了 $2$ 篇,且这 $2$ 篇论文至少被引用 $2$ 次」,可以找到这样的组合,如 `[3, 5]`,成立;\n\n* $h = 3$,含义为「至少发表了 $3$ 篇,且这 $3$ 篇论文至少被引用 $3$ 次」,可以找到这样的组合,如 `[3, 5, 6]`,成立;\n\n* $h = 4$,含义为「至少发表了 $4$ 篇,且这 $4$ 篇论文至少被引用 $4$ 次」,找不到这样的组合,不成立;\n\n* ...\n\n实际上,**当遇到第一个无法满足的数时,更大的数值就没必要找了**。一个简单的推导:\n\n至少出现 $k$ 次的论文数不足 $k$ 篇 => 至少出现 $k + 1$ 次的论文必然不足 $k$ 篇 => 至少出现 $k + 1$ 次的论文必然不足 $k + 1$ 篇(即更大的 $h$ 不满足)。\n\n---\n\n### 计数\n\n首先,**仍能使用「计数」的方式进行求解,该求解为线性复杂度,且不要求数组有序**。\n\n根据分析,最大的 `h` 不超过 $n$。\n\n假设我们预处理出引用次数所对应的论文数量 `cnt`,其中 `cnt[a] = b` 含义为引用次数 **恰好** 为 `a` 的论文数量有 `b` 篇。\n\n那么再利用 `h` 是“最大”的满足定义的合法数,我们从 $n$ 开始往前找,找到的第一个满足条件的数,即是答案。\n\n具体的,创建 `cnt` 数组,对 `cs` 进行计数,由于最大 `h` 不超过 $n$,因此对于引用次数超过 $n$ 的论文,可等价为引用次数为 $n$,即有计数逻辑 `cnt[min(c, n)]++`。\n\n再根据处理好的 `cnt`,从 $n$ 开始倒序找 `h`。\n\n由于我们处理的 `cnt[a]` 含义为引用次数 **恰好** 为 `a`,但题目定义则是 **至少**。同时「至少出现 $k + 1$ 次」的集合必然慢「至少出现 $k$ 次」要求(子集关系),我们可以使用变量 `tot`,对处理过的 `cnt[i]` 进行累加,从而实现从 **恰好** 到 **至少** 的转换。\n\nJava 代码:\n```Java\nclass Solution {\n    public int hIndex(int[] cs) {\n        int n = cs.length;\n        int[] cnt = new int[n + 10];\n        for (int c : cs) cnt[Math.min(c, n)]++;\n        for (int i = n, tot = 0; i >= 0; i--) {\n            tot += cnt[i];\n            if (tot >= i) return i;\n        }\n        return -1; // never\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int hIndex(vector<int>& cs) {\n        int n = cs.size();\n        vector<int> cnt(n + 10, 0);\n        for (int c : cs) cnt[min(c, n)]++;\n        for (int i = n, tot = 0; i >= 0; i--) {\n            tot += cnt[i];\n            if (tot >= i) return i;\n        }\n        return -1; // never\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def hIndex(self, cs: List[int]) -> int:\n        n = len(cs)\n        cnt = [0] * (n + 10)\n        for c in cs:\n            cnt[min(c, n)] += 1\n        tot = 0\n        for i in range(n, -1, -1):\n            tot += cnt[i]\n            if tot >= i:\n                return i\n        return -1  # never\n```\nTypeScript 代码:\n```TypeScript\nfunction hIndex(cs: number[]): number {\n    const n = cs.length;\n    const cnt = new Array(n + 10).fill(0);\n    for (let c of cs) cnt[Math.min(c, n)]++;\n    for (let i = n, tot = 0; i >= 0; i--) {\n        tot += cnt[i];\n        if (tot >= i) return i;\n    }\n    return -1; // never\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 二分答案(线性 `check`)\n\n除了线性复杂度的「计数」做法,我们还容易想到「二分」。\n\n其中**最容易想到的是「二分答案」,该做法复杂度为 $O(n\\log{n})$,同样并不要求数组有序。**\n\n我们发现对于任意的 `cs`(论文总数量为该数组长度 $n$),都必然对应了一个最大的 `h` 值,且小于等于该 `h` 值的情况均满足,大于该 `h` 值的均不满足。\n\n那么,在以最大 `h` 值为分割点的数轴上具有「二段性」,可通过「二分」求解该分割点(答案)。\n\n最后考虑在什么值域范围内进行二分?\n\n一个合格的二分范围,仅需确保答案在此范围内即可。\n\n再回看我们关于 `h` 的定义「至少发表了 `x` 篇论文,且每篇论文至少被引用 `x` 次」,满足条件除了引用次数,还有论文数量,而总的论文数量只有 $n$,因此最大的 `h` 只能是 $n$ 本身,而不能是比 $n$ 大的数,否则论文数量就不够了。\n\n综上,我们只需要在 $[0, n]$ 范围进行二分即可。对于任意二分值 `mid`,只需线性扫描 `cs` 即可知道其是否合法。\n\nJava 代码:\n```Java\nclass Solution {\n    public int hIndex(int[] cs) {\n        int n = cs.length;\n        int l = 0, r = n;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (check(cs, mid)) l = mid;\n            else r = mid - 1;\n        }\n        return r;\n    }\n    boolean check(int[] cs, int mid) {\n        int ans = 0;\n        for (int i : cs) if (i >= mid) ans++;\n        return ans >= mid;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int hIndex(vector<int>& cs) {\n        int n = cs.size();\n        int l = 0, r = n;\n        while (l < r) {\n            int mid = (l + r + 1) / 2;\n            if (check(cs, mid)) l = mid;\n            else r = mid - 1;\n        }\n        return r;\n    }\n    bool check(vector<int>& cs, int x) {\n        int cnt = 0;\n        for (int c : cs) {\n            if (c >= x) cnt++;\n        }\n        return cnt >= x;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def hIndex(self, cs: List[int]) -> int:\n        n = len(cs)\n        l, r = 0, n\n        while l < r:\n            mid = (l + r + 1) // 2\n            if sum(c >= mid for c in cs) >= mid:\n                l = mid\n            else:\n                r = mid - 1\n        return r\n```\nTypeScript 代码:\n```TypeScript\nfunction hIndex(cs: number[]): number {\n    const check = function (cs: number[], x: number): boolean {\n        let cnt: number = 0;\n        for (let c of cs) {\n            if (c >= x) cnt++;\n        }\n        return cnt >= x;\n    }\n    const n = cs.length;\n    let l = 0, r = n;\n    while (l < r) {\n        const mid = Math.floor((l + r + 1) / 2);\n        if (check(cs, mid)) l = mid;\n        else r = mid - 1;\n    }\n    return r;\n};\n```\n* 时间复杂度:对 $[0, n]$ 做二分,复杂度为 $O(\\log{n})$;`check` 函数需要对数组进行线性遍历,复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 二分下标(根据与 $cs[i]$ 关系)\n\n在上述二分中,我们没有利用本题的「数组有序」的特性。\n\n根据对 `h` 定义,若 $cs$ 升序,我们可推导出:\n* 在最大的符合条件的分割点 $x$ 的右边(包含分割点),必然满足 $cs[i] >= x$\n* 在最大的符合条件的分割点 $x$ 的左边,必然不满足 $cs[i] >= x$\n\n因此,我们可以利用 **分割点右边数的个数与分割点 $cs[x]$ 的大小关系进行二分** 。\n\n假设存在真实分割点下标 $x$,其值大小为 $cs[x]$,分割点右边的数值个数为 $n - x$,根据 `H 指数` 的定义,必然有 $cs[x] >= n - x$ 关系:\n\n* 在分割点 $x$ 的右边:$cs[i]$ 非严格单调递增,数的个数严格单调递减,仍然满足 $cs[i] >= n - i$ 关系;\n* 在分割点 $x$ 的左边:$cs[i]$ 非严格单调递减,数的个数严格单调递增,$x$ 作为真实分割点,必然不满足 $cs[i] >= n - i$ 关系。\n\n利用此「二段性」进行二分即可,二分出下标后,再计算出数的个数。\n\nJava 代码:\n```Java\nclass Solution {\n    public int hIndex(int[] cs) {\n        int n = cs.length;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (cs[mid] >= n - mid) r = mid;\n            else l = mid + 1;\n        }\n        return cs[r] >= n - r ? n - r : 0;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int hIndex(vector<int>& cs) {\n        int n = cs.size();\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (cs[mid] >= n - mid) r = mid;    \n            else l = mid + 1;\n        }\n        return cs[r] >= n - r ? n - r : 0;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def hIndex(self, cs: List[int]) -> int:\n        n = len(cs)\n        l, r = 0, n - 1\n        while l < r:\n            mid = l + r >> 1\n            if cs[mid] >= n - mid:\n                r = mid\n            else:\n                l = mid + 1\n        return n - r if cs[r] >= n - r else 0\n```\nTypeScript 代码:\n```TypeScript\nfunction hIndex(cs: number[]): number {\n    const n = cs.length;\n    let l = 0, r = n - 1;\n    while (l < r) {\n        const mid = l + r >> 1;\n        if (cs[mid] >= n - mid) r = mid;\n        else l = mid + 1;\n    }\n    return cs[r] >= n - r ? n - r : 0;\n};\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.275` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/271-280/278. 第一个错误的版本（简单）.md", "url_title": "278. 第一个错误的版本", "url": "https://leetcode-cn.com/problems/first-bad-version/solution/gong-shui-san-xie-shi-yong-jiao-hu-han-s-8hpv/", "difficulty": "简单", "tags": ["二分"], "question": "你是产品经理,目前正在带领一个团队开发新的产品。不幸的是,你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的,所以错误的版本之后的所有版本都是错的。\n\n假设你有 `n` 个版本 `[1, 2, ..., n]`,你想找出导致之后所有版本出错的第一个错误的版本。\n\n你可以通过调用 `bool isBadVersion(version)` 接口来判断版本号 `version` 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 `API` 的次数。\n\n示例:\n```\n给定 n = 5,并且 version = 4 是第一个错误的版本。\n\n调用 isBadVersion(3) -> false\n调用 isBadVersion(5) -> true\n调用 isBadVersion(4) -> true\n\n所以,4 是第一个错误的版本。 \n```", "solution": "### 二分\n\n一道交互题,根据题意可知,是尽可能少调用 `isBadVersion` 方法来找到分割点。\n\n考虑存在「**没有错误版本**」和「**全是错误版本**」的情况,但如果往头部插入一个正确版本,往尾部插入一个错误版本作为哨兵,仍然具有「**二段性**」。\n\n实际上,只需要进行这样的思考即可,不需要真正插入这样的哨兵,把这个哨兵逻辑放到最后返回的时候判断一下即可。\n\n那么只需要将 `isBadVersion` 当做 `check` 函数进行二分即可。\n\n**二分通常有以下两种写法,分别代表「找到最靠近中心的 `True`」 和「找到最靠近中心的 `False`」。**\n\n另外根据数据范围需要注意计算 `mid` 时的爆 `int` 问题,可以通过使用类似 `l + (r - l) / 2` 的做法解决,也可以通过一个临时 `long` 来解决。\n\n代码:\n```Java\npublic class Solution extends VersionControl {\n    public int firstBadVersion(int n) {\n        int l = 1, r = n;\n        while (l < r) {\n            long tmp = (long)l + r >> 1;\n            int mid = (int)tmp;\n            if (isBadVersion(mid)) {\n                r = mid;\n            } else {\n                l = mid + 1;\n            }\n        }\n        return r;\n    }\n}\n```\n```Java\npublic class Solution extends VersionControl {\n    public int firstBadVersion(int n) {\n        int l = 1, r = n;\n        while (l < r) {\n            long tmp = (long)l + r + 1 >> 1;\n            int mid = (int)tmp;\n            if (!isBadVersion(mid)) {\n                l = mid;\n            } else {\n                r = mid - 1;\n            }\n        }\n        return !isBadVersion(r) ? r + 1 : r;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 其他「二分」相关题解\n\n* 二分模板\n    [29. 两数相除](https://leetcode-cn.com/problems/divide-two-integers/) : [二分 + 倍增乘法解法(含模板)](https://leetcode-cn.com/problems/divide-two-integers/solution/shua-chuan-lc-er-fen-bei-zeng-cheng-fa-j-m73b/)\n\n* 二分本质 & 恢复二段性处理\n\n    [33. 搜索旋转排序数组(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/)\n\n    [81. 搜索旋转排序数组 II(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-xtam4/)\n\n    [153. 寻找旋转排序数组中的最小值(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/)\n\n    [154. 寻找旋转排序数组中的最小值 II(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-7xbty/)\n\n* 二分 check 函数如何确定\n    [34. 在排序数组中查找元素的第一个和最后一个位置](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/) : [考察对「二分」的理解,以及 check 函数的「大于 小于」怎么写](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/gong-shui-san-xie-kao-cha-dui-er-fen-de-86bk0/)", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.278` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/271-280/279. 完全平方数（中等）.md", "url_title": "279. 完全平方数", "url": "https://leetcode-cn.com/problems/perfect-squares/solution/gong-shui-san-xie-xiang-jie-wan-quan-bei-nqes/", "difficulty": "中等", "tags": ["完全背包", "动态规划", "背包问题"], "question": "给定正整数 n,找到若干个完全平方数(比如 1, 4, 9, 16, ...)使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。\n\n给你一个整数 n ,返回和为 n 的完全平方数的 最少数量 。\n\n完全平方数 是一个整数,其值等于另一个整数的平方;换句话说,其值等于一个整数自乘的积。例如,1、4、9 和 16 都是完全平方数,而 3 和 11 不是。\n\n示例 1:\n```\n输入:n = 12\n输出:3 \n解释:12 = 4 + 4 + 4\n```\n示例 2:\n```\n输入:n = 13\n输出:2\n解释:13 = 4 + 9\n```\n\n提示:\n* 1 <= n <= $10^4$", "solution": "### 完全背包(朴素解法)\n\n首先「完全平方数」有无限个,但要凑成的数字是给定的。\n\n因此第一步可以将范围在 $[1, n]$ 内的「完全平方数」预处理出来。\n\n这一步其实就是把所有可能用到的「物品」预处理出来。\n\n从而将问题转换为:**给定了若干个数字,每个数字可以被使用无限次,求凑出目标值 $n$ 所需要用到的是最少数字个数是多少。**\n\n由于题目没有限制我们相同的「完全平方数」只能使用一次,属于「完全背包」模型。\n\n目前我们学过的两类背包问题(01 背包 & 完全背包)的原始状态定义都是两维:\n\n* 第一维 $i$ 代表物品编号\n\n* 第二维 $j$ 代表容量\n\n其中第二维 $j$ 又有「不超过容量 $j$」和「容量恰好为 $j$」两种定义,本题要我们求「恰好」凑出 $n$ 所需要的最少个数。\n\n因此我们可以调整我们的「状态定义」:\n\n**$f[i][j]$ 为考虑前 $i$ 个数字,凑出数字总和 $j$ 所需要用到的最少数字数量。**\n\n不失一般性的分析 $f[i][j]$,对于第 $i$ 个数字(假设数值为 $t$),我们有如下选择:\n\n* 选 $0$ 个数字 $i$,此时有 $f[i][j] = f[i - 1][j]$\n* 选 $1$ 个数字 $i$,此时有 $f[i][j] = f[i - 1][j - t] + 1$\n* 选 $2$ 个数字 $i$,此时有 $f[i][j] = f[i - 1][j - 2 * t] + 2$\n    ...\n* 选 $k$ 个数字 $i$,此时有 $f[i][j] = f[i - 1][j - k * t] + k$\n\n因此我们的状态转移方程为:\n\n$$\nf[i][j] = min(f[i-1][j-k*t]+k),0 \\leqslant k * t \\leqslant j\n$$\n\n当然,能够选择 $k$ 个数字 $i$ 的前提是,剩余的数字 $j - k * t$ 也能够被其他「完全平方数」凑出,即 $f[i - 1][j - k * t]$ 为有意义的值。\n\n代码(朴素完全背包问题的复杂度是 $O(n^2 * \\sqrt{n})$ 的,有超时风险,让物品下标从 $0$ 开始,单独处理第一个物品的 $P2$ 代码勉强能过):\n```Java\nclass Solution {\n    int INF = 0x3f3f3f3f;\n    public int numSquares(int n) {\n        // 预处理出所有可能用到的「完全平方数」\n        List<Integer> list = new ArrayList<>();\n        int t = 1;\n        while (t * t <= n) {\n            list.add(t * t);\n            t++;\n        }\n\n        // f[i][j] 代表考虑前 i 个物品,凑出 j 所使用到的最小元素个数\n        int m = list.size();\n        int[][] f = new int[m + 1][n + 1]; \n        \n        // 当没有任何数时,除了 f[0][0] 为 0(花费 0 个数值凑出 0),其他均为无效值\n        Arrays.fill(f[0], INF);\n        f[0][0] = 0; \n\n        // 处理剩余数的情况\n        for (int i = 1; i <= m ; i++) {\n            int x = list.get(i - 1);\n            for (int j = 0; j <= n; j++) {\n                // 对于不选第 i 个数的情况\n                f[i][j] = f[i - 1][j];\n                // 对于选 k 次第 i 个数的情况\n                for (int k = 1; k * x <= j; k++) {\n                    // 能够选择 k 个 x 的前提是剩余的数字 j - k * x 也能被凑出\n                    if (f[i - 1][j - k * x] != INF) {\n                        f[i][j] = Math.min(f[i][j], f[i - 1][j - k * x] + k);\n                    }\n                }\n            }\n        }\n        return f[m][n];\n    }\n}\n```\n```Java\nclass Solution {\n    int INF = -1;\n    public int numSquares(int n) {\n        // 预处理出所有可能用到的「完全平方数」\n        List<Integer> list = new ArrayList<>();\n        int idx = 1;\n        while (idx * idx <= n) {\n            list.add(idx * idx);\n            idx++;\n        }\n\n        // f[i][j] 代表考虑前 i 个物品,凑出 j 所使用到的最小元素个数\n        int len = list.size();\n        int[][] f = new int[len][n + 1]; \n        \n        // 处理第一个数的情况\n        for (int j = 0; j <= n; j++) {\n            int t = list.get(0);\n            int k = j / t;\n            if (k * t == j) { // 只有容量为第一个数的整数倍的才能凑出\n                f[0][j] = k; \n            } else { // 其余则为无效值\n                f[0][j] = INF;\n            }\n        }\n\n        // 处理剩余数的情况\n        for (int i = 1; i < len; i++) {\n            int t = list.get(i);\n            for (int j = 0; j <= n; j++) {\n                // 对于不选第 i 个数的情况\n                f[i][j] = f[i - 1][j];\n                // 对于选 k 次第 i 个数的情况\n                for (int k = 1; k * t <= j; k++) {\n                    // 能够选择 k 个 t 的前提是剩余的数字 j - k * t 也能被凑出\n                    // 使用 0x3f3f3f3f 作为最大值(预留累加空间)可以省去该判断\n                    if (f[i - 1][j - k * t] != INF) {\n                        f[i][j] = Math.min(f[i][j], f[i - 1][j - k * t] + k);\n                    }\n                }\n                \n            }\n        }\n        return f[len - 1][n];\n    }\n}\n```\n* 时间复杂度:预处理出所有可能用到的数字复杂度为 $O(\\sqrt{n})$,共有 $n * \\sqrt{n}$ 个状态需要转移,每个状态转移最多遍历 $n$ 次,因此转移完所有状态复杂度为 $O(n^2 * \\sqrt{n})$。整体复杂度为 $O(n^2 * \\sqrt{n})$。\n* 空间复杂度:$O(n * \\sqrt{n})$。\n\n***\n\n### 完全背包(进阶)\n\n显然朴素版的完全背包进行求解复杂度有点高。\n\n这次我们还是按照同样的思路再进行一次推导,加强对这种「一维空间优化」方式的理解。\n\n从二维的状态转移方程入手进行分析(假设第 $i$ 个数字为 $t$):\n\n至此,我们得到了最终的状态转移方程:\n\n$$\nf[j] = min(f[j], f[j - t] + 1)\n$$\n\n同时,预处理「物品」的逻辑也能直接下放到转移过程去做。\n\n代码:\n```Java\nclass Solution {\n    public int numSquares(int n) {\n        int[] f = new int[n + 1];\n        Arrays.fill(f, 0x3f3f3f3f);\n        f[0] = 0;\n        for (int t = 1; t * t <= n; t++) {\n            int x = t * t;\n            for (int j = x; j <= n; j++) {\n                f[j] = Math.min(f[j], f[j - x] + 1);\n            }\n        }\n        return f[n];\n    }\n}\n```\n* 时间复杂度:共有 $n * \\sqrt{n}$ 个状态需要转移,复杂度为 $O(n * \\sqrt{n})$。\n* 空间复杂度:$O(n)$。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.279` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2731-2740/2736. 最大和查询（困难）.md", "url_title": "2736. 最大和查询", "url": "https://leetcode.cn/problems/maximum-sum-queries/solutions/2530269/gong-shui-san-xie-cong-yi-wei-xian-zhi-d-ww8r/", "difficulty": "困难", "tags": ["排序", "离散化", "树状数组"], "question": "给你两个长度为 `n`、下标从 `0` 开始的整数数组 `nums1` 和 `nums2`,另给你一个下标从 `1` 开始的二维数组 `queries`,其中 $queries[i] = [x_{i}, y_{i}]$ 。\n\n对于第 `i` 个查询,在所有满足 $nums1[j] >= x_{i}$ 且 $nums2[j] >= y_{i}$ 的下标 `j` ($0 <= j < n$) 中,找出 $nums1[j] + nums2[j]$ 的 最大值 ,如果不存在满足条件的 `j` 则返回 $-1$。\n\n返回数组 `answer`,其中 `answer[i]` 是第 `i` 个查询的答案。\n\n示例 1:\n```\n输入:nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]]\n\n输出:[6,10,7]\n\n解释:\n对于第 1 个查询:xi = 4 且 yi = 1 ,可以选择下标 j = 0 ,此时 nums1[j] >= 4 且 nums2[j] >= 1 。nums1[j] + nums2[j] 等于 6 ,可以证明 6 是可以获得的最大值。\n对于第 2 个查询:xi = 1 且 yi = 3 ,可以选择下标 j = 2 ,此时 nums1[j] >= 1 且 nums2[j] >= 3 。nums1[j] + nums2[j] 等于 10 ,可以证明 10 是可以获得的最大值。\n对于第 3 个查询:xi = 2 且 yi = 5 ,可以选择下标 j = 3 ,此时 nums1[j] >= 2 且 nums2[j] >= 5 。nums1[j] + nums2[j] 等于 7 ,可以证明 7 是可以获得的最大值。\n因此,我们返回 [6,10,7] 。\n```\n示例 2:\n```\n输入:nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4],[3,2],[1,1]]\n\n输出:[9,9,9]\n\n解释:对于这个示例,我们可以选择下标 j = 2 ,该下标可以满足每个查询的限制。\n```\n示例 3:\n```\n输入:nums1 = [2,1], nums2 = [2,3], queries = [[3,3]]\n\n输出:[-1]\n\n解释:示例中的查询 xi = 3 且 yi = 3 。对于每个下标 j ,都只满足 nums1[j] < xi 或者 nums2[j] < yi 。因此,不存在答案。 \n```\n\n提示:\n* $nums1.length = nums2.length$\n* $n = nums1.length$\n* $1 <= n <= 10^5$\n* $1 <= nums1[i], nums2[i] <= 10^9$\n* $1 <= queries.length <= 10^5$\n* $queries[i].length = 2$\n* $x_{i} = queries[i][1]$\n* $y_{i} = queries[i][2]$\n* $1 <= x_{i}, y_{i} <= 10^9$", "solution": "### 离散化 + 排序 + 树状数组 \n\n根据题意,两个等长数组 `num1` 和 `nums2`,只能是相同下标的元素凑成一对。\n\n不妨用两个一维数组 `nums1` 和 `nums2` 构建出一个二维数组 `nums`,方便后续处理,其中 $nums[i] = [nums1[i], nums2[i]]$。\n\n同时对 `queries` 进行简单拓展,构建新的二维数组 `nq`,目的是对原有下标信息进行记录,其中 $nq[i] = [queries[i][0], queries[i][1], i]$(此处构建新 `nq` 的作用,下文会说)。\n\n好了,现在我们有两个新的数组 `nums` 和 `nq`,接下来所有讨论都会针对新数组进行。\n\n希望你牢牢记住:**$nums[i] = [nums1[i], nums2[i]]$ 是对 `nums1` 和 `nums2` 的简单合并;而 $nq[i] = [queries[i][0], queries[i][1], i]$ 是对 `queries` 原有下标的拓展记录**。\n\n做完简单的预处理工作后,来思考一个前置问题:\n\n假设其他内容不变,要求从满足「$nums[j][0] \\geq nq[i][0]$ 且 $nums[j][1] \\geq nq[i][1]$」调整为仅需满足「$nums[j][0] \\geq nq[i][0]$」,如何求解?\n\n一个简单的做法:\n\n1. 对 `nums` 中的第一维(即 $nums[i][0] = nums1[i]$)和 `nq` 中第一维(即 $nq[i][0] = queries[i][0] = x_{i}$)排倒序;\n\n2. 从前往后处理每个询问 $nq[i]$,同时使用变量 `idx` 对 `nums` 进行扫描,若满足 $nums[idx][0] \\geq nq[i][0]$ 时,将 `idx` 右移,同时记录已被扫描的数对和 $nums[idx'][0] + nums[idx'][1]$ 。\n\n   当 `idx` 不能再后移时,说明当前所有满足 $nums[idx][0] \\geq nq[i][0]$ 要求的数对已被扫描完,在记录的数对和中取最大值,即是当前询问 $nq[i]$ 的答案 $ans[nq[i][2]]$(此处解释了为什么需要构造新数组 `nq`,因为询问处理是按照排序后进行,但在 `ans` 中需要映射回原有顺序)。\n\n3. 重复步骤 $2$,直到处理完所有询问。\n\n搞懂前置问题后,回到原问题,需要满足「$nums[j][0] \\geq nq[i][0]$ 且 $nums[j][1] \\geq nq[i][1]$」要求。\n\n进一步思考,排序 + 调整询问顺序,只能解决其中一维限制要求,另一维该如何处理?\n\n或更直接的问题:如何在被记录的所有数对和 $nums[idx'][0] + nums[idx'][1]$ 中找出那些满足  $nums[j][1] \\geq nq[i][1]$ 的最大数对和。\n\n不失一般性,假设当前处理到的是 $nums[idx]$,其中 $nums[idx][0]$ 的限制要求,通过前置问题的排序方式解决了。另外的 **$nums[idx][1]$ 我们希望作为“位置信息”,数对和 $sum = nums[idx][0] + nums[idx][1]$ 作为“值信息”进行记录**。\n\n由于条件 $1 \\leq x_{i}, y_{i} \\leq 1e9$,我们需要对将要作为“位置信息”添加到树状数组的 $nums[idx][1]$ 和 $nq[i][1]$ 进行离散化,将其映射到 $[0, m - 1]$ 范围内。\n\n对于每个询问,都需要找到已遍历过的大于 $nq[i][1]$ 的位置上的最大值,把离散化后的值域换成数组坐标,相当于求后缀最大值,后缀最大值可通过相反数,变成求前缀最大值。\n\n能够实现类似的前缀操作,支持“单点修改”和“区间查询”的数据结构是「树状数组」。\n\nJava 代码:\n\n```Java\nclass Solution {\n    int sz;\n    int[] tr;\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void add(int a, int b) {\n        for (int i = a; i <= sz; i += lowbit(i)) tr[i] = Math.max(tr[i], b);\n    }\n    int query(int x) {\n        int ans = -1;\n        for (int i = x; i > 0; i -= lowbit(i)) ans = Math.max(ans, tr[i]);\n        return ans;\n    }\n    public int[] maximumSumQueries(int[] nums1, int[] nums2, int[][] queries) {\n        int n = nums1.length, m = queries.length;\n        // 构建新的 nums 和 nq\n        int[][] nums = new int[n][2];\n        for (int i = 0; i < n; i++) nums[i] = new int[]{nums1[i], nums2[i]};\n        int[][] nq = new int[m][3];\n        for (int i = 0; i < m; i++) nq[i] = new int[]{queries[i][0], queries[i][1], i};\n\n        // 对要添加到树状数组的 nums[i][1] 和 nq[i][1] 进行离散化(构建映射字典, 将原值映射到 [0, m - 1])\n        Set<Integer> set = new HashSet<>();\n        for (int[] x : nums) set.add(x[1]);\n        for (int[] q : nq) set.add(q[1]);\n        List<Integer> list = new ArrayList<>(set);\n        Collections.sort(list);\n        sz = list.size();\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = 0; i < sz; i++) map.put(list.get(i), i);\n\n        // 调整询问顺序, 解决其中一维限制\n        Arrays.sort(nums, (a,b)->b[0]-a[0]);\n        Arrays.sort(nq, (a,b)->b[0]-a[0]);\n\n        tr = new int[sz + 10];\n        Arrays.fill(tr, -1);\n\n        int[] ans = new int[m];\n        int idx = 0; \n        for (int[] q : nq) {\n            int x = q[0], y = q[1], i = q[2];\n            // 扫描所有满足 nums[idx][0] >= x 的数对, 添加到树状数组中(其中离散值作为位置信息, 数对和作为值信息)\n            while (idx < n && nums[idx][0] >= x) {\n                add(sz - map.get(nums[idx][1]), nums[idx][0] + nums[idx][1]);\n                idx++;\n            }\n            ans[i] = query(sz - map.get(y)); // 查询树状数组中的最值\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int sz;\n    vector<int> tr;\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void add(int a, int b) {\n        for (int i = a; i <= sz; i += lowbit(i)) tr[i] = max(tr[i], b);\n    }\n    int query(int x) {\n        int ans = -1;\n        for (int i = x; i > 0; i -= lowbit(i)) ans = max(ans, tr[i]);\n        return ans;\n    }\n    vector<int> maximumSumQueries(vector<int>& nums1, vector<int>& nums2, vector<vector<int>>& queries) {\n        int n = nums1.size(), m = queries.size();\n        // 构建新的 nums 和 nq\n        vector<vector<int>> nums(n, vector<int>(2));\n        vector<vector<int>> nq(m, vector<int>(3));\n        for (int i = 0; i < n; i++) {\n            nums[i][0] = nums1[i]; nums[i][1] = nums2[i];\n        }\n        for (int i = 0; i < m; i++) {\n            nq[i][0] = queries[i][0]; nq[i][1] = queries[i][1]; nq[i][2] = i;\n        }\n        \n        // 对要添加到树状数组的 nums[i][1] 和 nq[i][1] 进行离散化(构建映射字典, 将原值映射到 [0, m - 1])\n        unordered_set<int> set;\n        for (auto& x : nums) set.insert(x[1]);\n        for (auto& q : nq) set.insert(q[1]);\n        vector<int> list(set.begin(), set.end());\n        sort(list.begin(), list.end());\n        sz = list.size();\n        map<int, int> map;\n        for (int i = 0; i < sz; i++) map[list[i]] = i;\n        \n        // 调整询问顺序, 解决其中一维限制\n        sort(nums.begin(), nums.end(), [](const vector<int>& a, const vector<int>& b) {\n            return a[0] > b[0];\n        });\n        sort(nq.begin(), nq.end(), [](const vector<int>& a, const vector<int>& b) {\n            return a[0] > b[0];\n        });\n        \n        tr.resize(sz + 10, -1);\n        \n        vector<int> ans(m);\n        int idx = 0;\n        for (auto& q : nq) {\n            int x = q[0], y = q[1], i = q[2];\n            // 扫描所有满足 nums[idx][0] >= x 的数对, 添加到树状数组中(其中离散值作为位置信息, 数对和作为值信息)\n            while (idx < n && nums[idx][0] >= x) {\n                add(sz - map[nums[idx][1]], nums[idx][0] + nums[idx][1]);\n                idx++;\n            }\n            ans[i] = query(sz - map[y]); // 查询树状数组中的最值\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maximumSumQueries(self, nums1: List[int], nums2: List[int], queries: List[List[int]]) -> List[int]:\n        sz = 0\n        tr = []\n\n        def lowbit(x):\n            return x & -x\n        def add(a, b):\n            i = a\n            while i <= sz:\n                tr[i] = max(tr[i], b)\n                i += lowbit(i)\n        def query(x):\n            ans, i = -1, x\n            while i > 0:\n                ans = max(ans, tr[i])\n                i -= lowbit(i)\n            return ans\n        \n        n, m = len(nums1), len(queries)\n        # 构建新的 nums 和 nq\n        nums = [(nums1[i], nums2[i]) for i in range(n)]\n        nq = [(queries[i][0], queries[i][1], i) for i in range(m)]\n        \n        #  对要添加到树状数组的 nums[i][1] 和 nq[i][1] 进行离散化(构建映射字典, 将原值映射到 [0, m - 1])\n        unique_set = set()\n        for x in nums:\n            unique_set.add(x[1])\n        for q in nq:\n            unique_set.add(q[1])\n        unique_list = list(unique_set)\n        unique_list.sort()\n        sz = len(unique_list)\n        mapping = {val: idx for idx, val in enumerate(unique_list)}\n        \n        # 调整询问顺序, 解决其中一维限制\n        nums.sort(key=lambda x: x[0], reverse=True)\n        nq.sort(key=lambda x: x[0], reverse=True)\n        \n        tr = [-1] * (sz + 10)\n        \n        ans = [0] * m\n        idx = 0\n        for x, y, i in nq:\n            # 扫描所有满足 nums[idx][0] >= x 的数对, 添加到树状数组中(其中离散值作为位置信息, 数对和作为值信息)\n            while idx < n and nums[idx][0] >= x:\n                add(sz - mapping[nums[idx][1]], nums[idx][0] + nums[idx][1])\n                idx += 1\n            ans[i] = query(sz - mapping[y])  # 查询树状数组中的最值\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction maximumSumQueries(nums1: number[], nums2: number[], queries: number[][]): number[] {\n    let sz = 0;\n    let tr = [];\n\n    const lowbit = function(x: number): number {\n        return x & -x;\n    }\n    const add = function(a: number, b: number): void {\n        for (let i = a; i <= sz; i += lowbit(i)) tr[i] = Math.max(tr[i], b);\n    }\n    const query = function(x: number): number {\n        let ans = -1;\n        for (let i = x; i > 0; i -= lowbit(i)) ans = Math.max(ans, tr[i]);\n        return ans;\n    }\n\n    const n = nums1.length, m = queries.length;\n    // 构建新的 nums 和 nq\n    const nums = Array.from({ length: n }, (_, i) => [nums1[i], nums2[i]]);\n    const nq = Array.from({ length: m }, (_, i) => [...queries[i], i]);\n\n    // 对要添加到树状数组的 nums[i][1] 和 nq[i][1] 进行离散化(构建映射字典, 将原值映射到 [0, m - 1])\n    const set: Set<number> = new Set();\n    for (const x of nums) set.add(x[1]);\n    for (const q of nq) set.add(q[1]);\n    const list: number[] = [...set];\n    list.sort((a, b) => a - b);\n    sz = list.length;\n    const mapping = new Map();\n    for (let i = 0; i < sz; i++) mapping.set(list[i], i);\n        \n    // 调整询问顺序, 解决其中一维限制\n    nums.sort((a, b) => b[0] - a[0]);\n    nq.sort((a, b) => b[0] - a[0]);\n\n    tr = Array(sz + 10).fill(-1);\n    const ans = Array(m).fill(0);\n    let idx = 0;\n    for (let [x, y, i] of nq) {\n        // 扫描所有满足 nums[idx][0] >= x 的数对, 添加到树状数组中(其中离散值作为位置信息, 数对和作为值信息)\n        while (idx < n && nums[idx][0] >= x) {\n            add(sz - mapping.get(nums[idx][1])!, nums[idx][0] + nums[idx][1]);\n            idx++;\n        }\n        ans[i] = query(sz - mapping.get(y)!); // 查询树状数组中的最值\n    }\n    return ans;\n};\n```\n* 时间复杂度:令 `nums1` 长度为 $n$,`queries` 长度为 $m$,构建 `nums` 和 `nq` 的复杂度为 $O(n + m)$;离散化复杂度为 $O((n + m) \\log{(n + m)})$;对 `nums` 和 `nq` 的排序复杂度为 $O(n\\log{n} + m\\log{m})$;构建答案复杂度为 $O(m + n\\log{n})$。整体复杂度为 $O((n + m) \\log {(n + m)})$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### 进阶\n\n本题解讲述了「从一维到二维偏序问题」时,可通过「一维排序,一维树状数组」求通解。\n\n那三维偏序问题呢?是否存在通用的解决思路。\n\n答:一维排序,一维归并,一维树状数组。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2736` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2751-2760/2760. 最长奇偶子数组（简单）.md", "url_title": "2698. 求一个整数的惩罚数", "url": "https://leetcode.cn/problems/longest-even-odd-subarray-with-threshold/solutions/2528837/gong-shui-san-xie-chou-si-bo-chong-tu-ji-n9r1/", "difficulty": "简单", "tags": ["双指针", "滑动窗口"], "question": "给你一个下标从 $0$ 开始的整数数组 `nums` 和一个整数 `threshold`。\n\n请你从 `nums` 的子数组中找出以下标 `l` 开头、下标 `r` 结尾 ($0 <= l <= r < nums.length$) 且满足以下条件的 最长子数组 :\n\n* `nums[l] % 2 == 0`\n* 对于范围 $[l, r - 1]$ 内的所有下标 `i`,`nums[i] % 2 != nums[i + 1] % 2`\n* 对于范围 $[l, r]$ 内的所有下标 `i`,`nums[i] <= threshold`\n\n以整数形式返回满足题目要求的最长子数组的长度。\n\n注意:子数组 是数组中的一个连续非空元素序列。\n\n示例 1:\n```\n输入:nums = [3,2,5,4], threshold = 5\n\n输出:3\n\n解释:在这个示例中,我们选择从 l = 1 开始、到 r = 3 结束的子数组 => [2,5,4] ,满足上述条件。\n因此,答案就是这个子数组的长度 3 。可以证明 3 是满足题目要求的最大长度。\n```\n示例 2:\n```\n输入:nums = [1,2], threshold = 2\n\n输出:1\n\n解释:\n在这个示例中,我们选择从 l = 1 开始、到 r = 1 结束的子数组 => [2] 。\n该子数组满足上述全部条件。可以证明 1 是满足题目要求的最大长度。\n```\n示例 3:\n```\n输入:nums = [2,3,4,5], threshold = 4\n\n输出:3\n\n解释:\n在这个示例中,我们选择从 l = 0 开始、到 r = 2 结束的子数组 => [2,3,4] 。 \n该子数组满足上述全部条件。\n因此,答案就是这个子数组的长度 3 。可以证明 3 是满足题目要求的最大长度。\n```\n\n提示:\n* $1 <= nums.length <= 100$ \n* $1 <= nums[i] <= 100$\n* $1 <= threshold <= 100$", "solution": "### 双指针\n\n整体题意:找 `nums` 中的最长的子数组 $[l, r]$,对于任意 $nums[i]$ 不超过 `threshold`,且从 $nums[l]$ 开始按照「先偶后奇」顺序交替。\n\n假设子数组的左端点为 `i`,且“最远的”合法右端点为 `j`,那么在 $[i, j]$ 之间的任意右端点 `k`,即使能够使得 $nums[i...k]$ 合法,对统计答案而言,也是没有意义的,因为我们求的是最长。\n\n基于此,我们容易想到:**找到所有的合法左端点 `i`,并统计该合法左端点的最远右端点 `j`。跳过 $[i, j]$ 之间的点作为左端点的情况,直接从结束位置 `j` 开始找下一个合法左端点。**\n\n该做法可将朴素的 $O(n^2)$ 做法优化至 $O(n)$。\n\n但,这做法为什么是正确的?\n\n我们只考虑了 $[i, j]$ 中间点作为右端点的情况,那作为左端点呢?为什么跳过 $[i, j]$ 之间的 $k$ 作为左端点,正确性也不受影响?我们不是漏到了某些方案吗?\n\n答案:**是漏掉了,但也只是漏掉了那些必不可能是最长子数组的方案**。\n\n具体的,我们重新整理上述的「双指针」做法:\n\n* 从前往后扫描 `nums`,变量 `i` 作为当前子数组左端点,首先确保 `i` 的合法性(跳过不满足 `nums[i] % 2 = 0` 和 `nums[i] <= threshold` 的位置)\n* 随后在固定左端点 `i` 前提下,找最远的(第一个不满足要求的)右端点 `j`(值不超过 `threshold`,且奇偶性与前值交替)\n* 得到当前连续段长度 $[i, j - 1]$,更新 `ans`,从当前结束位置 `j` 开始,重复上述过程,直到处理完 `nums`\n\nJava 代码\n```Java\nclass Solution {\n    public int longestAlternatingSubarray(int[] nums, int threshold) {\n        int n = nums.length, ans = 0, i = 0;\n        while (i < n) {\n            if ((nums[i] % 2 != 0 || nums[i] > threshold) && ++i >= 0) continue;\n            int j = i + 1, cur = nums[i] % 2;\n            while (j < n) {\n                if (nums[j] > threshold || nums[j] % 2 == cur) break;\n                cur = nums[j++] % 2;\n            }\n            ans = Math.max(ans, j - i);\n            i = j;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int longestAlternatingSubarray(vector<int>& nums, int threshold) {\n        int n = nums.size(), ans = 0, i = 0;\n        while (i < n) {\n            if ((nums[i] % 2 != 0 || nums[i] > threshold) && ++i >= 0) continue;\n            int j = i + 1, cur = nums[i] % 2;\n            while (j < n) {\n                if (nums[j] > threshold || nums[j] % 2 == cur) break;\n                cur = nums[j++] % 2;\n            }\n            ans = max(ans, j - i);\n            i = j;\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def longestAlternatingSubarray(self, nums: List[int], threshold: int) -> int:\n        n, ans, i = len(nums), 0, 0\n        while i < n:\n            if nums[i] % 2 != 0 or nums[i] > threshold:\n                i += 1\n                continue\n            j, cur = i + 1, nums[i] % 2\n            while j < n:\n                if nums[j] > threshold or nums[j] % 2 == cur: break\n                cur, j = nums[j] % 2, j + 1\n            ans = max(ans, j - i)\n            i = j\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction longestAlternatingSubarray(nums: number[], threshold: number): number {\n    let n = nums.length, ans = 0, i = 0\n    while (i < n) {\n        if ((nums[i] % 2 != 0 || nums[i] > threshold) && ++i >= 0) continue;\n        let j = i + 1, cur = nums[i] % 2;\n        while (j < n) {\n            if (nums[j] > threshold || nums[j] % 2 == cur) break;\n            cur = nums[j++] % 2;\n        }\n        ans = Math.max(ans, j - i);\n        i = j;\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2760` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/281-290/282. 给表达式添加运算符（困难）.md", "url_title": "282. 给表达式添加运算符", "url": "https://leetcode-cn.com/problems/peeking-iterator/solution/gong-shui-san-xie-die-dai-qi-ji-ben-ren-b77lz/", "difficulty": "困难", "tags": ["DFS", "数学"], "question": "给定一个仅包含数字 `0-9` 的字符串 `num` 和一个目标值整数 `target` ,在 `num` 的数字之间添加 二元 运算符(不是一元)`+`、`-` 或 `*` ,返回所有能够得到目标值的表达式。\n\n示例 1:\n```\n输入: num = \"123\", target = 6\n\n输出: [\"1+2+3\", \"1*2*3\"] \n```\n示例 2:\n```\n输入: num = \"232\", target = 8\n\n输出: [\"2*3+2\", \"2+3*2\"]\n```\n示例 3:\n```\n输入: num = \"105\", target = 5\n\n输出: [\"1*0+5\",\"10-5\"]\n```\n示例 4:\n```\n输入: num = \"00\", target = 0\n\n输出: [\"0+0\", \"0-0\", \"0*0\"]\n```\n示例 5:\n```\n输入: num = \"3456237490\", target = 9191\n\n输出: []\n```\n\n提示:\n* 1 <= num.length <= 10\n* num 仅含数字\n* $-2^{31} <= target <= 2^{31} - 1$", "solution": "### 回溯算法\n\n最开始的想法是先使用 `DFS` 搜出来所有的表达式,然后套用 [(题解)227. 基本计算器 II](https://leetcode-cn.com/problems/basic-calculator-ii/solution/shi-yong-shuang-zhan-jie-jue-jiu-ji-biao-c65k/) 方案,计算所有表达式的结果,并将计算结果为 $target$ 的表达式加到结果集。\n\n假设原字符串 $num$ 的长度为 $n$,由于每个位置之间存在四种插入决策(不插入符号、`+`、`-` 和 `*`),共有 $n - 1$ 个位置需要决策,因此搜索所有表达式的复杂度为 $O(4^{n - 1})$;同时需要对所有的表达式执行计算,复杂度为 $O(n)$,整体复杂度为 $O(n * 4^{n - 1})$。\n\n添加运算符后的表达式长度不会超过 $20$,因此总的计算量应该是在 $10^7$ 以内,但可能是因为常数问题超时了(各种优化双栈操作也还是 TLE,在这上面浪费了好多时间 QWQ)。\n\n**因此,我们需要考虑在搜索过程中进行计算,以避免使用 [(题解)227. 基本计算器 II](https://leetcode-cn.com/problems/basic-calculator-ii/solution/shi-yong-shuang-zhan-jie-jue-jiu-ji-biao-c65k/) 这种常数较大的计算方式。**\n\n我们考虑如果只有 `+` 和 `-` 的话,可以很容易将运算和回溯搜索所有表达进行结合。但当存在 `*` 时,由于存在运算优先级的问题,我们需要记录形如 `a + b * c` 中的乘法部分。\n\n实现上,除了记录当前决策到原串 $num$ 的哪一位 $u$,以及当前的运算结果 $cur$ 以外,还需要额外记录最后一次的计算结果 $prev$,然后在决策表达式中的第 $k$ 个部分时,对本次添加的运算符合做分情况讨论:\n\n* 如果本次添加的 `+` 操作,且第 $k$ 项的值是 $next$:那么直接使用 $cur + next$ 来更新 $cur$,同时 $next$ 作为下一次的 $prev$;\n* 如果本次添加的 `-` 操作,且第 $k$ 项的值是 $next$:同理,那么直接使用 $cur - next$ 来更新 $cur$,同时 $-next$ 作为下一次的 $prev$;\n* 如果本次添加的 `*` 操作,且第 $k$ 项的值是 $next$:此时需要考虑运算符的优先级问题,由于本次的 $next$ 是与上一次的操作数 $prev$ 执行乘法,而 $cur$ 已经累加了 $prev$ 的影响,因此需要先减去 $prev$,再加上 $prev * next$,以此来更新 $cur$,同时 $prev * next$ 也作为下一次的 $prev$。\n\n一些细节:需要注意前导零($0$ 单独作为一位是被允许的,但是多位且首部为 $0$ 是不允许的)以及 `+` 和 `-` 不作为一元运算符(运算符不能出现在表达式的首部)的情况。\n\n代码:\n```Java\nclass Solution {\n    List<String> ans = new ArrayList<>();\n    String s;\n    int n, t;\n    public List<String> addOperators(String num, int target) {\n        s = num;\n        n = s.length();\n        t = target;\n        dfs(0, 0, 0, \"\");\n        return ans;\n    }\n    void dfs(int u, long prev, long cur, String ss) {\n        if (u == n) {\n            if (cur == t) ans.add(ss);\n            return ;\n        }\n        for (int i = u; i < n; i++) {\n            if (i != u && s.charAt(u) == '0') break;\n            long next = Long.parseLong(s.substring(u, i + 1));\n            if (u == 0) {\n                dfs(i + 1, next, next, \"\" + next);\n            } else {\n                dfs(i + 1,  next, cur + next, ss + \"+\" + next);\n                dfs(i + 1, -next, cur - next, ss + \"-\" + next);\n                long x = prev * next;\n                dfs(i + 1, x, cur - prev + x, ss + \"*\" + next);\n            }\n        }\n    }\n}\n```\n* 时间复杂度:$O(4^{n})$\n* 空间复杂度:$O(4^{n})$\n\n---\n\n### 总结\n\n**该做法表面上,只是实现了边搜索边计算的功能,但其本质上是利用了实数集 $S$ 和运算符 `+`(`-` 的本质也是 `+`)和 `*` 能够组成代数系统。**\n\n利用代数系统 $(S, +, *)$,我们可以确保运算过程中的任意一个中间结果,都能使用形如 `a + b * c` 的形式进行表示,因此我们只需要多维护一个后缀串结果即可。\n\n而代数系统的相关知识,以及如何确定能否作为一个代数系统,有兴趣的同学可以尝试去了解一下。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.282` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/281-290/284. 顶端迭代器（中等）.md", "url_title": "284. 顶端迭代器", "url": "https://leetcode-cn.com/problems/peeking-iterator/solution/gong-shui-san-xie-die-dai-qi-ji-ben-ren-b77lz/", "difficulty": "中等", "tags": ["数据结构", "模拟"], "question": "请你设计一个迭代器,除了支持 `hasNext` 和 `next` 操作外,还支持 `peek` 操作。\n\n实现 `PeekingIterator` 类:\n* `PeekingIterator(int[] nums)` 使用指定整数数组 `nums` 初始化迭代器。\n* `int next()` 返回数组中的下一个元素,并将指针移动到下个元素处。\n* `bool hasNext()` 如果数组中存在下一个元素,返回 `true` ;否则,返回 `false`。\n* `int peek()` 返回数组中的下一个元素,但 **不** 移动指针。\n\n示例:\n```\n输入:\n[\"PeekingIterator\", \"next\", \"peek\", \"next\", \"next\", \"hasNext\"]\n[[[1, 2, 3]], [], [], [], [], []]\n\n输出:\n[null, 1, 2, 2, 3, false]\n\n解释:\nPeekingIterator peekingIterator = new PeekingIterator([1, 2, 3]); // [1,2,3]\npeekingIterator.next();    // 返回 1 ,指针移动到下一个元素 [1,2,3]\npeekingIterator.peek();    // 返回 2 ,指针未发生移动 [1,2,3]\npeekingIterator.next();    // 返回 2 ,指针移动到下一个元素 [1,2,3]\npeekingIterator.next();    // 返回 3 ,指针移动到下一个元素 [1,2,3]\npeekingIterator.hasNext(); // 返回 False\n```\n\n提示:\n* $1 <= nums.length <= 1000$\n* $1 <= nums[i] <= 1000$\n* 对 `next` 和 `peek` 的调用均有效\n* `next`、`hasNext` 和 `peek` 最多调用  $1000$ 次\n\n**进阶:你将如何拓展你的设计?使之变得通用化,从而适应所有的类型,而不只是整数型?**", "solution": "### 迭代器基本认识 + 模拟\n\n常规的迭代器的「访问」只支持两种操作:\n\n* `hasNext()` 操作:如果存在下一元素,返回 `True`,否则返回 `False`。实现上,就是判断游标是否到达结尾位置;\n* `next()` 操作:返回下一元素(当不存在下一元素时,返回 `null`)。实现上,就是返回游标指向的元素,并让游标后移。\n\n在本题,还需要我们额外支持 `peek()` 操作,即在移动游标的前提下,返回游标指向的元素。\n\n实现上,我们可以让操作提前一步进行,事先调用一次 `next()` 并使用该变量 $next$ 存起该元素,通过外部调用 `peek()` 还是 `next()` 来决定是否要更新 $next$;同时由于我们事先存起了下一访问位置的元素,我们可以通过判断 $next$ 是否为 `null` 来得知是否到达迭代器结尾(`hasNext()` 实现)。\n\n代码:\n```Java\nclass PeekingIterator implements Iterator<Integer> {\n    Iterator<Integer> iter;\n    Integer next;\n\tpublic PeekingIterator(Iterator<Integer> iterator) {\n        iter = iterator;\n        if (iter.hasNext()) next = iter.next();\n\t}\n\t\n\tpublic Integer peek() {\n        return next;\n\t}\n\t\n\t@Override\n\tpublic Integer next() {\n        Integer ans = next;\n        next = iter.hasNext() ? iter.next() : null;\n\t    return ans;\n\t}\n\t\n\t@Override\n\tpublic boolean hasNext() {\n        return next != null;\n\t}\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 进阶\n\n* 你将如何拓展你的设计?使之变得通用化,从而适应所有的类型,而不只是整数型?\n\n得益于 Java 的「泛型」设计,我们可以很轻松地支持任意类型:只需要将 `Integer` 修改成代指泛型的标识即可,例如 `E`。\n\n代码:\n```Java\nclass PeekingIterator implements Iterator<E> {\n    Iterator<E> iter;\n    E next;\n\tpublic PeekingIterator(Iterator<E> iterator) {\n        iter = iterator;\n        if (iter.hasNext()) next = iter.next();\n\t}\n\t\n\tpublic E peek() {\n        return next;\n\t}\n\t\n\t@Override\n\tpublic E next() {\n        E ans = next;\n        next = iter.hasNext() ? iter.next() : null;\n\t    return ans;\n\t}\n\t\n\t@Override\n\tpublic boolean hasNext() {\n        return next != null;\n\t}\n}\n```\n\nJava 的泛型实现原理是「擦除法」。即实际上,都是以 `Object` 的顶层类型来存储,只不过在编译期,编译器会自动增加强制类型转换的代码,而在增加了强制类型转换的逻辑后,泛型信息也就不再需要,于是在编译过后,泛型信息会被直接擦除,而不会带到运行时。\n\n其他不支持「泛型」的语言,可以采用类似的思路来实现:保存一个数据类型,在实现使用到泛型的接口时,先手动强转一下,再接收进来/返回出去。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.284` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/281-290/287. 寻找重复数（中等）.md", "url_title": "287. 寻找重复数", "url": "https://leetcode.cn/problems/find-the-duplicate-number/solution/by-ac_oier-az8v/", "difficulty": "中等", "tags": ["桶排序", "原地哈希"], "question": "给定一个包含 `n + 1` 个整数的数组 `nums`,其数字都在 $[1, n]$ 范围内(包括 $1$ 和 $n$),可知至少存在一个重复的整数。\n\n假设 `nums` 只有 一个重复的整数 ,返回 这个重复的数 。\n\n你设计的解决方案必须 不修改 数组 `nums` 且只用常量级 $O(1)$ 的额外空间。\n\n示例 1:\n```\n输入:nums = [1,3,4,2,2]\n\n输出:2\n```\n示例 2:\n```\n输入:nums = [3,1,3,4,2]\n\n输出:3\n```\n\n提示:\n* $1 <= n <= 10^5$\n* $nums.length = n + 1$\n* $1 <= nums[i] <= n$\n* `nums` 中 只有一个整数 出现 两次或多次 ,其余整数均只出现 一次\n\n进阶:\n* 如何证明 `nums` 中至少存在一个重复的数字?\n* 你可以设计一个线性级时间复杂度 $O(n)$ 的解决方案吗?", "solution": "### 原地哈希\n\n数组长度为 $n + 1$,同时给定的 $nums[i]$ 都在 $[1, n]$ 范围内,因此我们可以设定哈希规则为 $nums[idx] = idx + 1$,即数值 `x` 会放在下标 $x - 1$ 的位置。\n\n如此一来,对于只出现一次的数值而言,必然能够顺利放在目标位置,而出现多次的数值必然会因为位置冲突而被找出。\n\nJava 代码:\n```Java\nclass Solution {\n    public int findDuplicate(int[] nums) {\n        for (int i = 0; i < nums.length; ) {\n            int t = nums[i], idx = t - 1;\n            if (nums[idx] == t) {\n                if (idx != i) return t;\n                i++;\n            } else {\n                swap(nums, idx, i);\n            }\n        }\n        return -1;\n    }\n    void swap(int[] nums, int i, int j) {\n        int c = nums[i];\n        nums[i] = nums[j];\n        nums[j] = c;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction findDuplicate(nums: number[]): number {\n    for (let i = 0; i < nums.length; ) {\n        const t = nums[i], idx = t - 1\n        if (nums[idx] == t) {\n            if (idx != i) return t\n            i++\n        } else {\n            swap(nums, i, idx)\n        }\n    }\n    return -1\n}\nfunction swap(nums: number[], i: number, j: number): void {\n    const c = nums[i]\n    nums[i] = nums[j]\n    nums[j] = c\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def findDuplicate(self, nums: List[int]) -> int:\n        n, i = len(nums), 0\n        while i < n:\n            t, idx = nums[i], nums[i] - 1\n            if nums[idx] == t:\n                if idx != i:\n                    return t\n                i += 1\n            else:\n                nums[i], nums[idx] = nums[idx], nums[i]\n        return -1\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.287` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2821-2830/2824. 统计和小于目标的下标对数目（简单）.md", "url_title": "2824. 统计和小于目标的下标对数目", "url": "https://leetcode.cn/problems/count-pairs-whose-sum-is-less-than-target/solutions/2539761/gong-shui-san-xie-xiang-jie-zuo-zhao-you-1yji/", "difficulty": "简单", "tags": ["排序", "二分", "双指针"], "question": "给你一个下标从 `0` 开始长度为 `n` 的整数数组 `nums` 和一个整数 `target`,请你返回满足 `0 <= i < j < n` 且 `nums[i] + nums[j] < target` 的下标对 $(i, j)$ 的数目。\n\n示例 1:\n```\n输入:nums = [-1,1,2,3,1], target = 2\n\n输出:3\n\n解释:总共有 3 个下标对满足题目描述:\n- (0, 1) ,0 < 1 且 nums[0] + nums[1] = 0 < target\n- (0, 2) ,0 < 2 且 nums[0] + nums[2] = 1 < target \n- (0, 4) ,0 < 4 且 nums[0] + nums[4] = 0 < target\n注意 (0, 3) 不计入答案因为 nums[0] + nums[3] 不是严格小于 target 。\n```\n示例 2:\n```\n输入:nums = [-6,2,5,-2,-7,-1,3], target = -2\n\n输出:10\n\n解释:总共有 10 个下标对满足题目描述:\n- (0, 1) ,0 < 1 且 nums[0] + nums[1] = -4 < target\n- (0, 3) ,0 < 3 且 nums[0] + nums[3] = -8 < target\n- (0, 4) ,0 < 4 且 nums[0] + nums[4] = -13 < target\n- (0, 5) ,0 < 5 且 nums[0] + nums[5] = -7 < target\n- (0, 6) ,0 < 6 且 nums[0] + nums[6] = -3 < target\n- (1, 4) ,1 < 4 且 nums[1] + nums[4] = -5 < target\n- (3, 4) ,3 < 4 且 nums[3] + nums[4] = -9 < target\n- (3, 5) ,3 < 5 且 nums[3] + nums[5] = -3 < target\n- (4, 5) ,4 < 5 且 nums[4] + nums[5] = -8 < target\n- (4, 6) ,4 < 6 且 nums[4] + nums[6] = -4 < target\n```\n\n提示:\n* $1 <= nums.length = n <= 50$\n* $-50 <= nums[i], target <= 50$", "solution": "### 基本分析\n\n为了方便,先对 `nums` 进行排序。\n\n当 `nums` 有了有序特性后,剩下的便是「遍历右端点,在右端点左侧找最大合法左端点」或「遍历左端点,在左端点右侧找最大合法右端点」过程。\n\n---\n\n### 排序 + 二分\n\n这是一种「遍历右端点,在右端点左侧找最大合法左端点」做法。\n\n遍历右端点 `i`,然后在 $[0, i - 1]$ 范围内进行二分,找到最大的满足 $nums[j] + nums[i] < target$ 的位置 `j`。\n\n若存在这样左端点 `j`,说明以 $nums[i]$ 为右端点时,共有 $j + 1$ 个(范围为 $[0, j]$ )个合法左端点,需要被统计。\n\nJava 代码:\n\n```Java\nclass Solution {\n    public int countPairs(List<Integer> nums, int target) {\n        Collections.sort(nums);\n        int n = nums.size(), ans = 0;\n        for (int i = 1; i < n; i++) {\n            int l = 0, r = i - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (nums.get(mid) + nums.get(i) < target) l = mid;\n                else r = mid - 1;\n            }\n            if (nums.get(r) + nums.get(i) < target) ans += r + 1;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int countPairs(vector<int>& nums, int target) {\n        sort(nums.begin(), nums.end());\n        int n = nums.size(), ans = 0;\n        for (int i = 1; i < n; i++) {\n            int l = 0, r = i - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (nums[mid] + nums[i] < target) l = mid;\n                else r = mid - 1;\n            }\n            if (nums[r] + nums[i] < target) ans += r + 1;\n        }\n        return ans;\n    }\n};\n\n```\nPython 代码:\n```Python\nclass Solution:\n    def countPairs(self, nums: List[int], target: int) -> int:\n        nums.sort()\n        n, ans = len(nums), 0\n        for i in range(1, n):\n            l, r = 0, i - 1\n            while l < r:\n                mid = l + r + 1 >> 1\n                if nums[mid] + nums[i] < target: l = mid\n                else: r = mid - 1\n            if nums[r] + nums[i] < target: ans += r + 1\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction countPairs(nums: number[], target: number): number {\n    nums.sort((a,b)=>a-b);\n    let n = nums.length, ans = 0;\n    for (let i = 1; i < n; i++) {\n        let l = 0, r = i - 1;\n        while (l < r) {\n            const mid = l + r + 1 >> 1;\n            if (nums[mid] + nums[i] < target) l = mid;\n            else r = mid - 1;\n        }\n        if (nums[r] + nums[i] < target) ans += r + 1;\n    }\n    return ans;\n};\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$;构造答案复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$\n\n---\n\n### 排序 + 双指针\n\n这是一种「遍历左端点,在左端点右侧找最大合法右端点」做法。\n\n使用 `l` 和 `r` 分别指向排序好的 `nums` 的首尾。\n\n若当前 $nums[l] + nums[r] \\geq target$,说明此时对于 `l` 来说,`r` 并不合法,对 `r` 自减(左移)。\n\n直到满足 $nums[l] + nums[r] < target$,此时对于 `l` 来说,找到了最右侧的合法右端点 `r`,在 $[l + 1, r]$ 期间的数必然仍满足 $nums[l] + nums[r] < target$,共有 $r - l$ 个(范围为 $[l + 1, r]$ )个合法右端点,需要被统计。\n\nJava 代码:\n```Java\nclass Solution {\n    public int countPairs(List<Integer> nums, int target) {\n        Collections.sort(nums);\n        int n = nums.size(), ans = 0;\n        for (int l = 0, r = n - 1; l < r; l++) {\n            while (r >= 0 && nums.get(l) + nums.get(r) >= target) r--;\n            if (l < r) ans += r - l;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int countPairs(vector<int>& nums, int target) {\n        sort(nums.begin(), nums.end());\n        int n = nums.size(), ans = 0;\n        for (int l = 0, r = n - 1; l < r; l++) {\n            while (r >= 0 && nums[l] + nums[r] >= target) r--;\n            if (l < r) ans += r - l;\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def countPairs(self, nums: List[int], target: int) -> int:\n        nums.sort()\n        n, ans = len(nums), 0\n        l, r = 0, n - 1\n        while l < r:\n            while r >= 0 and nums[l] + nums[r] >= target: r -= 1\n            if l < r: ans += r - l\n            l += 1\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction countPairs(nums: number[], target: number): number {\n    nums.sort((a,b)=>a-b);\n    let n = nums.length, ans = 0;\n    for (let l = 0, r = n - 1; l < r; l++) {\n        while (r >= 0 && nums[l] + nums[r] >= target) r--;\n        if (l < r) ans += r - l;\n    }\n    return ans;\n};\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$;构造答案复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2824` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/2871-2880/2876. 有向图访问计数（困难）.md", "url_title": "2876. 有向图访问计数", "url": "https://leetcode.cn/problems/count-visited-nodes-in-a-directed-graph/solutions/2512278/gong-shui-san-xie-sha-shi-nei-xiang-wai-d3lm9/", "difficulty": "困难", "tags": ["基环森林", "内向基环树", "拓扑排序", "图", "BFS"], "question": "现有一个有向图,其中包含 `n` 个节点,节点编号从 `0` 到 `n - 1`。此外,该图还包含了 `n` 条有向边。\n\n给你一个下标从 `0` 开始的数组 `edges`,其中 `edges[i]` 表示存在一条从节点 `i` 到节点 `edges[i]` 的边。\n\n想象在图上发生以下过程:\n\n你从节点 `x` 开始,通过边访问其他节点,直到你在 此过程 中再次访问到之前已经访问过的节点。\n\n返回数组 `answer` 作为答案,其中 `answer[i]` 表示如果从节点 `i` 开始执行该过程,你可以访问到的不同节点数。\n\n示例 1:\n\n```\n输入:edges = [1,2,0,0]\n\n输出:[3,3,3,4]\n\n解释:从每个节点开始执行该过程,记录如下:\n- 从节点 0 开始,访问节点 0 -> 1 -> 2 -> 0 。访问的不同节点数是 3 。\n- 从节点 1 开始,访问节点 1 -> 2 -> 0 -> 1 。访问的不同节点数是 3 。\n- 从节点 2 开始,访问节点 2 -> 0 -> 1 -> 2 。访问的不同节点数是 3 。\n- 从节点 3 开始,访问节点 3 -> 0 -> 1 -> 2 -> 0 。访问的不同节点数是 4 。\n```\n示例 2:\n\n```\n输入:edges = [1,2,3,4,0]\n\n输出:[5,5,5,5,5]\n\n解释:无论从哪个节点开始,在这个过程中,都可以访问到图中的每一个节点。\n```\n\n提示:\n* $n = edges.length$\n* $2 <= n <= 10^5$\n* $0 <= edges[i] <= n - 1$\n* $edges[i] != i$", "solution": "### 内向基环森林 + 拓扑排序\n\n根据题意,共 `n` 个点,`n` 条边,利用 `edges`,将 `i` 向 `edges[i]` 连有向边,可知每个点有唯一的出边,因此这是一张可能包含多棵「内向基环树」的「基环森林」。\n\n基环树是指其具有 $n$ 个点 $n$ 条边的联通块,而「内向」是指树中任意节点有且只有一条出边,对应的「外向」是指树中任意节点有且只有一条入边。\n\n例如,左图内向,右图外向:\n\n显然,可根据当前节点是否在“环内”进行分情况讨论:\n\n* 对于「环内」节点来说,其答案为环节点个数;\n* 对于「环外」节点来说,直观感受应该是由环上节点转移而来。但由于本题给定的是「内向基环树」,因此我们需要对原图进行“反向”,然后从环内节点开始,进行 `BFS` ,从而更新其余非环节点答案。\n\n具体的,我们使用如下思路进行求解:\n\n1. 创建大小为 `n` 的数组 `in`,进行入度统计;\n2. 根据入度进行「拓扑排序」,剩余满足 $in[i] \\neq 0$ 的点,为「环内」的点。我们可处理出每个点所在环的大小,环的大小为这些点的答案。处理过程中收集这些「环内」的点(将来要从它们出发,更新其他「环外」节点)\n3. 对原图进行“反向”,从收集好的「环内」点进行出发,运用 `BFS` 得出剩余点答案。\n\nJava 代码:\n```Java\nclass Solution {\n    int N = 200010, M = N, idx = 0;\n    int[] he = new int[N], e = new int[M], ne = new int[M];\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    public int[] countVisitedNodes(List<Integer> edges) {\n        int n = edges.size();\n        int[] in = new int[n], ans = new int[n];\n        for (int x : edges) in[x]++;\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            if (in[i] == 0) d.addLast(i);\n        }\n        while (!d.isEmpty()) {\n            int t = edges.get(d.pollFirst());\n            if (--in[t] == 0) d.addLast(t);\n        }\n        // 处理环上的\n        Set<Integer> set = new HashSet<>();\n        for (int i = 0; i < n; i++) {\n            if (in[i] == 0) continue;\n            List<Integer> list = new ArrayList<>();\n            list.add(i);\n            int j = edges.get(i), val = 1;\n            while (j != i) {\n                list.add(j);\n                j = edges.get(j);\n                val++;\n            }\n            for (int x : list) {\n                set.add(x);\n                in[x] = 0;\n                ans[x] = val;\n            }\n        }\n        // 建立反向图, 处理非环上的, 从环内点出发进行往外更新\n        Arrays.fill(he, -1);\n        for (int i = 0; i < n; i++) add(edges.get(i), i);\n        for (int u : set) {\n            int val = ans[u];\n            Deque<Integer> de = new ArrayDeque<>();\n            de.addLast(u);\n            while (!de.isEmpty()) {\n                int sz = de.size();\n                while (sz-- > 0) {\n                    int t = de.pollFirst();\n                    ans[t] = val;\n                    for (int i = he[t]; i != -1; i = ne[i]) {\n                        int j = e[i];\n                        if (ans[j] != 0) continue;\n                        de.addLast(j);\n                    }\n                }\n                val++;\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int he[200010], e[200010], ne[200010], idx;\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    vector<int> countVisitedNodes(vector<int>& edges) {\n        int n = edges.size();\n        vector<int> in(n, 0), ans(n, 0);\n        for (int x : edges) in[x]++;\n        queue<int> d;\n        for (int i = 0; i < n; i++) {\n            if (in[i] == 0) d.push(i);\n        }\n        while (!d.empty()) {\n            int t = edges[d.front()];\n            d.pop();\n            if (--in[t] == 0) d.push(t);\n        }\n        set<int> s;\n        for (int i = 0; i < n; i++) {\n            if (in[i] == 0) continue;\n            vector<int> list;\n            list.push_back(i);\n            int j = edges[i], val = 1;\n            while (j != i) {\n                list.push_back(j);\n                j = edges[j];\n                val++;\n            }\n            for (int x : list) {\n                s.insert(x);\n                in[x] = 0;\n                ans[x] = val;\n            }\n        }\n        memset(he, -1, sizeof(he));\n        for (int i = 0; i < n; i++) add(edges[i], i);\n        for (int u : s) {\n            int val = ans[u];\n            queue<int> de;\n            de.push(u);\n            while (!de.empty()) {\n                int sz = de.size();\n                while (sz-- > 0) {\n                    int t = de.front();\n                    de.pop();\n                    ans[t] = val;\n                    for (int i = he[t]; i != -1; i = ne[i]) {\n                        int j = e[i];\n                        if (ans[j] != 0) continue;\n                        de.push(j);\n                    }\n                }\n                val++;\n            }\n        }\n        return ans;\n    }\n};\n```\n* 时间复杂度:统计入度复杂度为 $O(n)$;拓扑排序复杂度为 $O(n)$;统计「环内」节点答案复杂度为 $O(n)$;统计「环外」答案复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.2876` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/291-300/292. Nim 游戏（简单）.md", "url_title": "292. Nim 游戏", "url": "https://leetcode-cn.com/problems/nim-game/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-wmz2t/", "difficulty": "简单", "tags": ["博弈论"], "question": "你和你的朋友,两个人一起玩 `Nim` 游戏:\n\n* 桌子上有一堆石头。\n* 你们轮流进行自己的回合,你作为先手。\n* 每一回合,轮到的人拿掉 `1-3` 块石头。\n* 拿掉最后一块石头的人就是获胜者。\n\n假设你们每一步都是最优解。请编写一个函数,来判断你是否可以在给定石头数量为 `n` 的情况下赢得游戏。如果可以赢,返回 `true`;否则,返回 `false`。\n\n示例 1:\n```\n输入:n = 4\n\n输出:false \n\n解释:如果堆中有 4 块石头,那么你永远不会赢得比赛;\n     因为无论你拿走 1 块、2 块 还是 3 块石头,最后一块石头总是会被你的朋友拿走。\n```\n示例 2:\n```\n输入:n = 1\n\n输出:true\n```\n示例 3:\n```\n输入:n = 2\n\n输出:true\n```\n\n提示:\n* $1 <= n <= 2^{31} - 1$", "solution": "### 博弈论\n\n这是一道 Nim 游戏的简化版。\n\n**在不知晓博弈论结论前,可以先通过找规律得到猜想,然后再从「何种情况下,先手会处于必胜态」的角度来进行分析。**\n\n根据题意,我们尝试从小范围数据的情况进行讨论:\n\n1. 如果落到先手的局面为「**石子数量为 `1-3`**」的话,那么**先手必胜**;\n2. 如果落到先手的局面为「**石子数量为 `4`**」的话,那么先手决策完(无论何种决策),交到后手的局面为「石子数量为 `1-3`」,即此时后手必胜,对应**先手必败**(到这里我们有一个推论:如果交给先手的局面为 `4` 的话,那么先手必败);\n3. 如果落到先手的局面为「**石子数量为 `5-7`**」的话,那么先手可以通过控制选择石子的数量,来使得后手处于「石子数量为 `4`」的局面(此时后手必败),因此**先手必胜**;\n4. 如果落到先手的局面为「**石子数量为 `8`**」的话,由于每次只能选 `1-3` 个石子,因此交由后手的局面为 `5-7`,根据流程 `3` 我们知道此时**先手必败**;\n...\n\n到这里,我们猜想 **当起始局面石子数量为 `4` 的倍数,则先手必败,否则先手必胜(即 `n % 4 != 0` 时,先手必胜)。**\n\n然后我们通过「归纳法」证明一下该猜想的正确性。\n\n在上面的「找规律」分析中,我们分情况讨论了最后一个决胜回合(我们称「剩余石子数量少于等于 `4` 的局面」为最后回合)的情况:**如果交由先手的石子数量为 `4`,那么先手必败,否则先手必胜。**\n\n而对于「最后回合」前的任意回合(石子数量大于 `4`),我们需要证明 **先手可以通过调整所选石子数量,来维持「`n % 4 != 0`」直到最后回合。**\n\n如果起始对先手而言满足「`n % 4 != 0`」,此时先手可以通过选择石子数量为「`n % 4`」来确保交到后手的局面为 `4` 的倍数。\n\n那么根据推论,此时的原始后手作为下一回合的先手角色,且面临石子数量为 `4` 的倍数的局面,为必败态。\n\n进一步的解释就是,由于原始后手面临石子数量为 `4` 的倍数的局面,且只能选 `1-3` 个石子,因此无论如何选择,重新回到原始先手的仍然满足「`n % 4 != 0`」(非 $4$ 的倍数)。\n\n因此 **原始先手只需要确保每次都选择「`x % 4`」个石子($x$ 为当前石子数量),就可以确保交由自己的局面一直满足「`x % 4 != 0`」,交由对方的局面一直满足「`x % 4 == 0`」,直到最后回合的到来。**\n\n至此,我们证明了 **如果起始石子数量 $n$ 满足「`n % 4 != 0`」条件,那么先手必胜。**\n\n代码:\n```Java\nclass Solution {\n    public boolean canWinNim(int n) {\n        return n % 4 != 0;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.292` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/291-300/295. 数据流的中位数（困难）.md", "url_title": "295. 数据流的中位数", "url": "https://leetcode-cn.com/problems/find-median-from-data-stream/solution/gong-shui-san-xie-jing-dian-shu-ju-jie-g-pqy8/", "difficulty": "困难", "tags": ["优先队列(堆)"], "question": "中位数是有序列表中间的数。如果列表长度是偶数,中位数则是中间两个数的平均值。\n\n例如,\n\n* `[2,3,4]` 的中位数是 $3$\n* `[2,3]` 的中位数是 $(2 + 3) / 2 = 2.5$\n\n设计一个支持以下两种操作的数据结构:\n* `void addNum(int num)` - 从数据流中添加一个整数到数据结构中。\n* `double findMedian()` - 返回目前所有元素的中位数。\n\n示例:\n```\naddNum(1)\naddNum(2)\nfindMedian() -> 1.5\naddNum(3) \nfindMedian() -> 2\n```\n\n进阶:\n* 如果数据流中所有整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法?\n* 如果数据流中 `99%` 的整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法?", "solution": "### 优先队列(堆)\n\n这是一道经典的数据结构运用题。\n\n具体的,**我们可以使用两个优先队列(堆)来维护整个数据流数据,令维护数据流左半边数据的优先队列(堆)为 `l`,维护数据流右半边数据的优先队列(堆)为 `r`**。\n\n显然,**为了可以在 $O(1)$ 的复杂度内取得当前中位数,我们应当令 `l` 为大根堆,`r` 为小根堆,并人为固定 `l` 和 `r` 之前存在如下的大小关系**:\n\n* **当数据流元素数量为偶数:`l` 和 `r` 大小相同,此时动态中位数为两者堆顶元素的平均值;**\n* **当数据流元素数量为奇数:`l` 比 `r` 多一,此时动态中位数为 `l` 的堆顶原数。**\n\n为了满足上述说的奇偶性堆大小关系,在进行 `addNum` 时,我们应当分情况处理:\n\n* 插入前两者大小相同,说明插入前数据流元素个数为偶数,插入后变为奇数。我们期望操作完达到「`l` 的数量为 `r` 多一,同时双堆维持有序」,进一步分情况讨论:\n    * 如果 `r` 为空,说明当前插入的是首个元素,直接添加到 `l` 即可;\n    * 如果 `r` 不为空,且 `num <= r.peek()`,说明 `num` 的插入位置不会在后半部分(不会在 `r` 中),直接加到 `l` 即可;\n    * 如果 `r` 不为空,且 `num > r.peek()`,说明 `num` 的插入位置在后半部分,此时将 `r` 的堆顶元素放到 `l` 中,再把 `num` 放到 `r`(相当于从 `r` 中置换一位出来放到 `l` 中)。\n\n* 插入前两者大小不同,说明前数据流元素个数为奇数,插入后变为偶数。我们期望操作完达到「`l` 和 `r` 数量相等,同时双堆维持有序」,进一步分情况讨论(此时 `l` 必然比 `r` 元素多一):\n    * 如果 `num >= l.peek()`,说明 `num` 的插入位置不会在前半部分(不会在 `l` 中),直接添加到 `r` 即可。\n    * 如果 `num < l.peek()`,说明 `num` 的插入位置在前半部分,此时将 `l` 的堆顶元素放到 `r` 中,再把 `num` 放入 `l` 中(相等于从 `l` 中替换一位出来当到 `r` 中)。\n\n代码:\n```Java\nclass MedianFinder {\n    PriorityQueue<Integer> l = new PriorityQueue<>((a,b)->b-a);\n    PriorityQueue<Integer> r = new PriorityQueue<>((a,b)->a-b);\n    public void addNum(int num) {\n        int s1 = l.size(), s2 = r.size();\n        if (s1 == s2) {\n            if (r.isEmpty() || num <= r.peek()) {\n                l.add(num);\n            } else {\n                l.add(r.poll());\n                r.add(num);\n            }\n        } else {\n            if (l.peek() <= num) {\n                r.add(num);\n            } else {\n                r.add(l.poll());\n                l.add(num);\n            }\n        }\n    }\n    public double findMedian() {\n        int s1 = l.size(), s2 = r.size();\n        if (s1 == s2) {\n            return (l.peek() + r.peek()) / 2.0;\n        } else {\n            return l.peek();\n        }\n    }\n}\n```\n* 时间复杂度:`addNum` 函数的复杂度为 $O(\\log{n})$;`findMedian` 函数的复杂度为 $O(1)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 进阶\n\n* 如果数据流中所有整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法?\n\n可以使用建立长度为 $101$ 的桶,每个桶分别统计每个数的出现次数,同时记录数据流中总的元素数量,每次查找中位数时,先计算出中位数是第几位,从前往后扫描所有的桶得到答案。\n\n**这种做法相比于对顶堆做法,计算量上没有优势,更多的是空间上的优化。**\n\n**对顶堆解法两个操作中耗时操作复杂度为 $O(\\log{n})$,$\\log$ 操作常数不会超过 $3$,在极限数据 $10^7$ 情况下计算量仍然低于耗时操作复杂度为 $O(C)$($C$ 固定为 $101$)桶计数解法。**\n\n* 如果数据流中 `99%` 的整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法?\n\n和上一问解法类似,对于 $1$% 采用哨兵机制进行解决即可,在常规的最小桶和最大桶两侧分别维护一个有序序列,即建立一个代表负无穷和正无穷的桶。\n\n上述两个进阶问题的代码如下,但注意由于真实样例的数据分布不是进阶所描述的那样(不是绝大多数都在 $[0,100]$ 范围内),会 `TLE`。\n\n代码:\n```Java\nclass MedianFinder {\n    TreeMap<Integer, Integer> head = new TreeMap<>(), tail = new TreeMap<>();\n    int[] arr = new int[101];\n    int a, b, c;\n    public void addNum(int num) {\n        if (num >= 0 && num <= 100) {\n            arr[num]++;\n            b++;\n        } else if (num < 0) {\n            head.put(num, head.getOrDefault(num, 0) + 1);\n            a++;\n        } else if (num > 100) {\n            tail.put(num, tail.getOrDefault(num, 0) + 1);\n            c++;\n        }\n    }\n    public double findMedian() {\n        int size = a + b + c;\n        if (size % 2 == 0) return (find(size / 2) + find(size / 2 + 1)) / 2.0;\n        return find(size / 2 + 1);\n    }\n    int find(int n) {\n        if (n <= a) {\n            for (int num : head.keySet()) {\n                n -= head.get(num);\n                if (n <= 0) return num; \n            }\n        } else if (n <= a + b) {\n            n -= a;\n            for (int i = 0; i <= 100; i++) {\n                n -= arr[i];\n                if (n <= 0) return i;\n            }\n        } else {\n            n -= a + b;\n            for (int num : tail.keySet()) {\n                n -= tail.get(num);\n                if (n <= 0) return num;\n            }\n        }\n        return -1; // never\n    }\n}\n```", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.295` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/291-300/297. 二叉树的序列化与反序列化（困难）.md", "url_title": "297. 二叉树的序列化与反序列化", "url": "https://leetcode-cn.com/problems/xu-lie-hua-er-cha-shu-lcof/solution/gong-shui-san-xie-er-cha-shu-de-xu-lie-h-n89a/", "difficulty": "困难", "tags": ["二叉树", "层序遍历"], "question": "序列化是将一个数据结构或者对象转换为连续的比特位的操作,进而可以将转换后的数据存储在一个文件或者内存中,同时也可以通过网络传输到另一个计算机环境,采取相反方式重构得到原数据。\n\n请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑,你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。\n\n提示: 输入输出格式与 LeetCode 目前使用的方式一致,详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式,你也可以采用其他的方法解决这个问题。\n\n示例 1:\n\n```\n输入:root = [1,2,3,null,null,4,5]\n输出:[1,2,3,null,null,4,5]\n```\n示例 2:\n```\n输入:root = []\n输出:[]\n```\n示例 3:\n```\n输入:root = [1]\n输出:[1]\n```\n示例 4:\n```\n输入:root = [1,2]\n输出:[1,2]\n```\n\n提示:\n* 树中结点数在范围 $[0, 10^4]$ 内\n* -1000 <= Node.val <= 1000", "solution": "### 基本思路\n\n无论使用何种「遍历方式」进行二叉树存储,为了方便,我们都需要对空节点有所表示。\n\n其实题目本身的样例就给我们提供了很好的思路:**使用层序遍历的方式进行存储,对于某个叶子节点的空节点进行存储,同时确保不递归存储空节点对应的子节点。**\n\n---\n\n### 层序遍历\n\n根据节点值的数据范围 `-1000 <= Node.val <= 1000`(我是在 [297. 二叉树的序列化与反序列化](https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree/) 看的,你也可以不使用数字,使用某个特殊字符进行表示,只要能在反序列时有所区分即可),我们可以建立占位节点 `emptyNode` 用来代指空节点(`emptyNode.val = INF`)。\n\n序列化:先特判掉空树的情况,之后就是常规的层序遍历逻辑:\n\n1. 起始时,将 `root` 节点入队;\n2. 从队列中取出节点,检查节点是否有左/右节点:\n    * 如果有的话,将值追加序列化字符中(注意使用分隔符),并将节点入队;\n    * 如果没有,检查当前节点是否为 `emptyNode` 节点,如果不是 `emptyNode` 说明是常规的叶子节点,需要将其对应的空节点进行存储,即将 `emptyNode` 入队;\n3. 循环流程 $2$,直到整个队列为空。\n\n反序列:同理,怎么「序列化」就怎么进行「反序列」即可:\n\n1. 起始时,构造出 `root` 并入队;\n2. 每次从队列取出元素时,同时从序列化字符中截取两个值(对应左右节点),检查是否为 `INF`,若不为 `INF` 则构建对应节点;\n3. 循环流程 $2$,直到整个序列化字符串被处理完(注意跳过最后一位分隔符)。\n\n代码:\n```Java\npublic class Codec {\n    int INF = -2000;\n    TreeNode emptyNode = new TreeNode(INF);\n    public String serialize(TreeNode root) {\n        if (root == null) return \"\";\n\n        StringBuilder sb = new StringBuilder();\n        Deque<TreeNode> d = new ArrayDeque<>();\n        d.addLast(root);\n        while (!d.isEmpty()) {\n            TreeNode poll = d.pollFirst();\n            sb.append(poll.val + \"_\");\n            if (!poll.equals(emptyNode)) {\n                d.addLast(poll.left != null ? poll.left : emptyNode);\n                d.addLast(poll.right != null ? poll.right : emptyNode);\n            }\n        }\n        return sb.toString();\n    }\n\n    public TreeNode deserialize(String data) {\n        if (data.equals(\"\")) return null;\n\n        String[] ss = data.split(\"_\");\n        int n = ss.length;\n        TreeNode root = new TreeNode(Integer.parseInt(ss[0]));\n        Deque<TreeNode> d = new ArrayDeque<>();\n        d.addLast(root);\n        for (int i = 1; i < n - 1; i += 2) {\n            TreeNode poll = d.pollFirst();\n            int a = Integer.parseInt(ss[i]), b = Integer.parseInt(ss[i + 1]);\n            if (a != INF) {\n                poll.left = new TreeNode(a);\n                d.addLast(poll.left);\n            }\n            if (b != INF) {\n                poll.right = new TreeNode(b);\n                d.addLast(poll.right);\n            }\n        }\n        return root;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.297` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/291-300/299. 猜数字游戏（中等）.md", "url_title": "299. 猜数字游戏", "url": "https://leetcode-cn.com/problems/bulls-and-cows/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-tdhs/", "difficulty": "中等", "tags": ["模拟"], "question": "你在和朋友一起玩 猜数字(`Bulls and Cows`)游戏,该游戏规则如下:\n\n写出一个秘密数字,并请朋友猜这个数字是多少。朋友每猜测一次,你就会给他一个包含下述信息的提示:\n\n* 猜测数字中有多少位属于数字和确切位置都猜对了(称为 `\"Bulls\"`, 公牛),\n* 有多少位属于数字猜对了但是位置不对(称为 `\"Cows\"`, 奶牛)。也就是说,这次猜测中有多少位非公牛数字可以通过重新排列转换成公牛数字。\n\n给你一个秘密数字 `secret` 和朋友猜测的数字 `guess`,请你返回对朋友这次猜测的提示。\n\n提示的格式为 `\"xAyB\"` ,`x` 是公牛个数, `y` 是奶牛个数,`A` 表示公牛,`B` 表示奶牛。\n\n请注意秘密数字和朋友猜测的数字都可能含有重复数字。\n\n示例 1:\n```\n输入: secret = \"1807\", guess = \"7810\"\n\n输出: \"1A3B\"\n\n解释: 数字和位置都对(公牛)用 '|' 连接,数字猜对位置不对(奶牛)的采用斜体加粗标识。\n\"1807\"\n  |\n\"7810\"\n```\n示例 2:\n```\n输入: secret = \"1123\", guess = \"0111\"\n\n输出: \"1A1B\"\n\n解释: 数字和位置都对(公牛)用 '|' 连接,数字猜对位置不对(奶牛)的采用斜体加粗标识。\n\"1123\"        \"1123\"\n  |      or     |\n\"0111\"        \"0111\"\n注意,两个不匹配的 1 中,只有一个会算作奶牛(数字猜对位置不对)。通过重新排列非公牛数字,其中仅有一个 1 可以成为公牛数字。\n```\n示例 3:\n```\n输入:secret = \"1\", guess = \"0\"\n\n输出:\"0A0B\"\n```\n示例 4:\n```\n输入:secret = \"1\", guess = \"1\"\n\n输出:\"1A0B\"\n```\n\n提示:\n* 1 <= secret.length, guess.length <= 1000\n* secret.length == guess.length\n* secret 和 guess 仅由数字组成", "solution": "### 模拟\n\n根据题意,我们可以对 $secret$ 和 $guess$ 进行诸位比较,统计公牛数量 $a$ 和奶牛数量 $b$。\n\n对于字符相同的位置,我们可以直接对 $a$ 进行自增;对于字符不同的位置,使用「哈希表」进行分别统计 $secret$ 和 $guess$ 的词频,某个数字 $x$ 在两者词频中的较小值,即为该数字对应的奶牛数量,统计所有数字 $[0, 9]$ 的奶牛数量总和即为 $b$。\n\n代码:\n```Java\nclass Solution {\n    public String getHint(String secret, String guess) {\n        int n = secret.length();\n        int a = 0, b = 0;\n        int[] cnt1 = new int[10], cnt2 = new int[10];\n        for (int i = 0; i < n; i++) {\n            int c1 = secret.charAt(i) - '0', c2= guess.charAt(i) - '0';\n            if (c1 == c2) {\n                a++;\n            } else {\n                cnt1[c1]++;\n                cnt2[c2]++;\n            }\n        }\n        for (int i = 0; i < 10; i++) b += Math.min(cnt1[i], cnt2[i]);\n        return a + \"A\" + b + \"B\";\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:令 $C$ 为字符集大小,$C$ 固定为 $10$。复杂度为 $O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.299` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/301-310/301. 删除无效的括号（困难）.md", "url_title": "301. 删除无效的括号", "url": "https://leetcode-cn.com/problems/remove-invalid-parentheses/solution/yi-fen-zhong-nei-kan-dong-jiang-gua-hao-aya6k/", "difficulty": "困难", "tags": ["括号问题", "回溯算法", "DFS"], "question": "给你一个由若干括号和字母组成的字符串 `s`,删除最小数量的无效括号,使得输入的字符串有效。\n\n返回所有可能的结果。答案可以按 任意顺序 返回。\n\n示例 1:\n```\n输入: \"()())()\"\n输出: [\"()()()\", \"(())()\"]\n```\n示例 2:\n```\n输入: \"(a)())()\"\n输出: [\"(a)()()\", \"(a())()\"]\n```\n示例 3:\n```\n输入: \")(\"\n输出: [\"\"]\n```\n\n提示:\n* $1 <= s.length <= 25$\n* `s` 由小写英文字母以及括号 `'('` 和 `')'` 组成\n* `s` 中至多含 `20` 个括号", "solution": "### 搜索 + 剪枝\n\n由于题目要求我们将所有(最长)合法方案输出,因此不可能有别的优化,只能进行「爆搜」。\n\n我们可以使用 `DFS` 实现回溯搜索。\n\n基本思路:\n\n我们知道所有的合法方案,必然有左括号的数量与右括号数量相等。\n\n首先我们令左括号的得分为 $1$;右括号的得分为 $-1$。则会有如下性质:\n\n1. 对于一个合法的方案而言,必然有最终得分为 $0$;\n2. 搜索过程中不会出现得分值为 **负数** 的情况(当且仅当子串中某个前缀中「右括号的数量」大于「左括号的数量」时,会出现负数,此时不是合法方案)。\n\n同时我们可以预处理出「爆搜」过程的最大得分: `max = min(左括号的数量, 右括号的数量)`\n\n**PS.「爆搜」过程的最大得分必然是:合法左括号先全部出现在左边,之后使用最多的合法右括号进行匹配。**\n\n枚举过程中出现字符分三种情况:\n\n* 左括号:如果增加当前 `(` 后,仍为合法子串(即 $score + 1 <= max$) 时,我们可以选择添加该左括号,也能选择不添加;\n* 右括号:如果增加当前 `)` 后,仍为合法子串(即 $score - 1 >= 0$) 时,我们可以选择添加该右括号,也能选择不添加;\n* 普通字符:直接添加。\n\n使用 `Set` 进行方案去重,$len$ 记录「爆搜」过程中的最大子串,然后只保留长度等于 $len$ 的子串。\n\n代码:\n```Java\nclass Solution {\n    Set<String> set = new HashSet<>();\n    int n, max, len;\n    String s;\n    public List<String> removeInvalidParentheses(String _s) {\n        s = _s;\n        n = s.length();\n        int l = 0, r = 0;\n        for (char c : s.toCharArray()) {\n            if (c == '(') l++;\n            else if (c == ')') r++;\n        }\n        max = Math.min(l, r);\n        dfs(0, \"\", 0);\n        return new ArrayList<>(set);\n    }\n    void dfs(int u, String cur, int score) {\n        if (score < 0 || score > max) return ;\n        if (u == n) {\n            if (score == 0 && cur.length() >= len) {\n                if (cur.length() > len) set.clear();\n                len = cur.length();\n                set.add(cur);\n            }\n            return ;\n        }\n        char c = s.charAt(u);\n        if (c == '(') {\n            dfs(u + 1, cur + String.valueOf(c), score + 1);\n            dfs(u + 1, cur, score);\n        } else if (c == ')') {\n            dfs(u + 1, cur + String.valueOf(c), score - 1);\n            dfs(u + 1, cur, score);\n        } else {\n            dfs(u + 1, cur + String.valueOf(c), score);\n        }\n    }\n}\n```\n* 时间复杂度:预处理 $max$ 的复杂度为 $O(n)$;不考虑 $score$ 带来的剪枝效果,最坏情况下,每个位置都有两种选择,搜索所有方案的复杂度为 $O(2^n)$;同时搜索过程中会产生的新字符串(最终递归树中叶子节点的字符串长度最大为 $n$,使用 `StringBuilder` 也是同理),复杂度为 $O(n)$。整体复杂度为 $O(n \\times 2^n)$\n* 空间复杂度:最大合法方案数与字符串长度呈线性关系。复杂度为 $O(n)$\n\n---\n\n### 搜索 + 剪枝\n\n在解法一,我们是在搜索过程中去更新最后的 $len$。\n\n但事实上,我们可以通过预处理,得到最后的「应该删除的左括号数量」和「应该删掉的右括号数量」,来直接得到最终的 $len$。\n\n因此在此基础上,我们可以考虑多增加一层剪枝。\n\n代码:\n```Java\nclass Solution {\n    Set<String> set = new HashSet<>();\n    int n, max, len;\n    String s;\n    public List<String> removeInvalidParentheses(String _s) {\n        s = _s;\n        n = s.length();\n\n        int l = 0, r = 0;\n        for (char c : s.toCharArray()) {\n            if (c == '(') {\n                l++;\n            } else if (c == ')') {\n                if (l != 0) l--;\n                else r++;\n            }\n        }\n        len = n - l - r;\n        \n        int c1 = 0, c2 = 0;\n        for (char c : s.toCharArray()) {\n            if (c == '(') c1++;\n            else if (c == ')') c2++;\n        }\n        max = Math.min(c1, c2);\n\n        dfs(0, \"\", l, r, 0);\n        return new ArrayList<>(set);\n    }\n    void dfs(int u, String cur, int l, int r, int score) {\n        if (l < 0 || r < 0 || score < 0 || score > max) return ;\n        if (l == 0 && r == 0) {\n            if (cur.length() == len) set.add(cur);\n        }\n        if (u == n) return ;\n        char c = s.charAt(u);\n        if (c == '(') {\n            dfs(u + 1, cur + String.valueOf(c), l, r, score + 1);\n            dfs(u + 1, cur, l - 1, r, score);\n        } else if (c == ')') {\n            dfs(u + 1, cur + String.valueOf(c), l, r, score - 1);\n            dfs(u + 1, cur, l, r - 1, score);\n        } else {\n            dfs(u + 1, cur + String.valueOf(c), l, r, score);\n        }\n    }\n}\n```\n* 时间复杂度:预处理 $max$ 和 $len$ 的复杂度为 $O(n)$;不考虑 $score$ 带来的剪枝效果,最坏情况下,每个位置都有两种选择,搜索所有方案的复杂度为 $O(2^n)$;同时搜索过程中会产生的新字符串(最终递归树中叶子节点的字符串长度最大为 $n$,使用 `StringBuilder` 也是同理),复杂度为 $O(n)$。整体复杂度为 $O(n \\times 2^n)$\n* 空间复杂度:最大合法方案数与字符串长度呈线性关系。复杂度为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.301` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/301-310/303. 区域和检索 - 数组不可变（简单）.md", "url_title": "303. 区域和检索 - 数组不可变", "url": "https://leetcode-cn.com/problems/range-sum-query-immutable/solution/sha-shi-qian-zhui-he-ya-tu-jie-qian-zhui-0rla/", "difficulty": "简单", "tags": ["前缀和", "区间求和问题"], "question": "给定一个整数数组 `nums`,求出数组从索引 `i` 到 `j`(`i ≤ j`)范围内元素的总和,包含 `i`、`j` 两点。\n\n实现 `NumArray` 类:\n* `NumArray(int[] nums)` 使用数组 `nums` 初始化对象\n* `int sumRange(int i, int j)` 返回数组 `nums` 从索引 `i` 到 `j`(`i ≤ j`)范围内元素的总和,包含 i、j 两点(也就是 `sum(nums[i], nums[i + 1], ... , nums[j])`)\n\n示例:\n```\n输入:\n[\"NumArray\", \"sumRange\", \"sumRange\", \"sumRange\"]\n[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]\n输出:\n[null, 1, -1, -3]\n\n解释:\nNumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);\nnumArray.sumRange(0, 2); // return 1 ((-2) + 0 + 3)\nnumArray.sumRange(2, 5); // return -1 (3 + (-5) + 2 + (-1)) \nnumArray.sumRange(0, 5); // return -3 ((-2) + 0 + 3 + (-5) + 2 + (-1))\n```\n\n提示:\n* $0 <= nums.length <= 10^4$\n* $-10^5 <= nums[i] <= 10^5$\n* $0 <= i <= j < nums.length$\n* 最多调用 $10^4$ 次 `sumRange` 方法", "solution": "### 前缀和(一维)\n\n这是一道前缀和裸题。\n\n当要我们求「连续段」区域和的时候,要很自然的想到「前缀和」。\n\n所谓前缀和,是指对原数组“累计和”的描述,通常是指一个与原数组等长的数组。\n\n设前缀和数组为 `sum`,**`sum` 的每一位记录的是从「起始位置」到「当前位置」的元素和**。例如 $sum[x]$ 是指原数组中“起始位置”到“位置 `x`”这一连续段的元素和。\n\n有了前缀和数组 `sum`,当我们求连续段 $[i, j]$ 的区域和时,利用「容斥原理」,便可进行快速求解。\n\n通用公式:`ans = sum[j] - sum[i - 1]`。\n\n由于涉及 `-1` 操作,为减少边界处理,我们可让前缀和数组下标从 $1$ 开始。在进行快速求和时,再根据原数组下标是否从 $1$ 开始,决定是否进行相应的下标偏移。\n\nJava 代码:\n```Java\nclass NumArray {\n    int[] sum;\n    public NumArray(int[] nums) {\n        int n = nums.length;\n        // 前缀和数组下标从 1 开始,因此设定长度为 n + 1(模板部分)\n        sum = new int[n + 1];\n        // 预处理除前缀和数组(模板部分)\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n    }\n    public int sumRange(int i, int j) {\n        // 求某一段区域和 [i, j] 的模板是 sum[j] - sum[i - 1](模板部分)\n        // 但由于我们源数组下标从 0 开始,因此要在模板的基础上进行 + 1\n        i++; j++;\n        return sum[j] - sum[i - 1];\n    }\n}\n```\nC++ 代码:\n```C++\nclass NumArray {\npublic:\n    vector<int> sum;\n    NumArray(std::vector<int>& nums) {\n        int n = nums.size();\n        // 前缀和数组下标从 1 开始,因此设定长度为 n + 1(模板部分)\n        sum.resize(n + 1, 0);\n        // 预处理除前缀和数组(模板部分)\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n    }\n    int sumRange(int i, int j) {\n        // 求某一段区域和 [i, j] 的模板是 sum[j] - sum[i - 1](模板部分)\n        // 但由于我们源数组下标从 0 开始,因此要在模板的基础上进行 + 1\n        i++; j++;\n        return sum[j] - sum[i - 1];\n    }\n};\n```\nPython 代码:\n```Python\nclass NumArray:\n    def __init__(self, nums: List[int]):\n        n = len(nums)\n        # 前缀和数组下标从 1 开始,因此设定长度为 n + 1(模板部分)\n        self.sum = [0] * (n + 1)\n        # 预处理除前缀和数组(模板部分)\n        for i in range(1, n + 1):\n            self.sum[i] = self.sum[i - 1] + nums[i - 1]\n\n    def sumRange(self, i: int, j: int) -> int:\n        # 求某一段区域和 [i, j] 的模板是 sum[j] - sum[i - 1](模板部分)\n        # 但由于我们源数组下标从 0 开始,因此要在模板的基础上进行 + 1\n        i, j = i + 1, j + 1\n        return self.sum[j] - self.sum[i - 1]\n```\nTypeScript 代码:\n```TypeScript\nclass NumArray {\n    private sum: number[];\n    constructor(nums: number[]) {\n        const n: number = nums.length;\n        // 前缀和数组下标从 1 开始,因此设定长度为 n + 1(模板部分)\n        this.sum = new Array(n + 1).fill(0);\n        // 预处理除前缀和数组(模板部分)\n        for (let i = 1; i <= n; i++) this.sum[i] = this.sum[i - 1] + nums[i - 1];\n    }\n    sumRange(i: number, j: number): number {\n        // 求某一段区域和 [i, j] 的模板是 sum[j] - sum[i - 1](模板部分)\n        // 但由于我们源数组下标从 0 开始,因此要在模板的基础上进行 + 1\n        i++; j++;\n        return this.sum[j] - this.sum[i - 1];\n    }\n}\n```\n* 时间复杂度:预处理前缀和数组需要对原数组进行线性扫描,复杂度为 $O(n)$,计算结果复杂度为 $O(1)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 一维前缀和模板\n\n我们再来整理下一维「前缀和」的模板代码(`Java` 为例):\n\n```java\n// 预处理前缀和数组\n{    \n    sum = new int[n + 1];\n    for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n}\n\n// 计算 [i, j] 结果\n{\n    i++; j++;\n    ans = sum[j] - sum[i - 1];\n}\n```\n\n---\n\n### 总结\n\n最后我们看看「前缀和」与其他知识点的联系。\n\n为啥「前缀和」能大幅度的降低区间求和的复杂度?其实本质是利用数学进行求值:某一段的区间和 = 起点到区间右端点的和(含右端点)- 起点到区间左端点的和(不含左端点)\n\n而求解前缀和数组的过程,则是基于动态规划思想:由于前缀和的每一位都是求「当前位置到起点位置区间的和」。因此当求解某一位的前缀和时,需要「前一位置的前缀和」和「当前位置的原数组值」(而与前一位置的前缀和是如何计算出来无关)。其过程类似于 dp 入门题 [509. 斐波那契数](https://leetcode-cn.com/problems/fibonacci-number/) 的求解过程。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.303` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/301-310/304. 二维区域和检索 - 矩阵不可变（中等）.md", "url_title": "304. 二维区域和检索 - 矩阵不可变", "url": "https://leetcode-cn.com/problems/range-sum-query-2d-immutable/solution/xia-ci-ru-he-zai-30-miao-nei-zuo-chu-lai-ptlo/", "difficulty": "中等", "tags": ["前缀和", "区间求和问题"], "question": "给定一个二维矩阵,计算其子矩形范围内元素的总和,该子矩阵的左上角为 (row1, col1) ,右下角为 (row2, col2) 。\n\n上图子矩阵左上角 (row1, col1) = (2, 1) ,右下角(row2, col2) = (4, 3),该子矩形内元素的总和为 8。\n\n示例:\n```\n给定 matrix = [\n  [3, 0, 1, 4, 2],\n  [5, 6, 3, 2, 1],\n  [1, 2, 0, 1, 5],\n  [4, 1, 0, 1, 7],\n  [1, 0, 3, 0, 5]\n]\n\nsumRegion(2, 1, 4, 3) -> 8\nsumRegion(1, 1, 2, 2) -> 11\nsumRegion(1, 2, 2, 4) -> 12\n```\n\n提示:\n* 你可以假设矩阵不可变。\n* 会多次调用 sumRegion 方法。\n* 你可以假设 row1 ≤ row2 且 col1 ≤ col2 。", "solution": "### 前缀和解法(二维)\n\n真就是今天的「每日一题」呗 ~ \n\n这是一道「二维前缀和」的裸题。\n\n「二维前缀和」解决的是二维矩阵中的矩形区域求和问题。\n\n**二维前缀和数组中的每一个格子记录的是「以当前位置为区域的右下角(区域左上角恒定为原数组的左上角)的区域和」**\n\n贴一张官解示意图,我觉得很清晰:\n\n**如果觉得不清晰,请将将 f[i][j] 理解成是以 (i, j) 为右下角,(0, 0) 为左上角的区域和。**\n\n因此当我们要求 (x1, y1) 作为左上角,(x2, y2) 作为右下角 的区域和的时候,可以直接利用前缀和数组快速求解:\n\n`sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1]`\n\n再贴官解示意图(画图困难户在学做图了,别骂😢):\n\n(x1, y1) == (row1, col1),(x2, y2) == (row2, col2)\n\n代码:\n```Java\nclass NumMatrix {\n    int[][] sum;\n    public NumMatrix(int[][] matrix) {\n        int n = matrix.length, m = n == 0 ? 0 : matrix[0].length;\n        // 与「一维前缀和」一样,前缀和数组下标从 1 开始,因此设定矩阵形状为 [n + 1][m + 1](模板部分)\n        sum = new int[n + 1][m + 1];\n        // 预处理除前缀和数组(模板部分)\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + matrix[i - 1][j - 1];\n            }\n        }\n    }\n\n    public int sumRegion(int x1, int y1, int x2, int y2) {\n        // 求某一段区域和 [i, j] 的模板是 sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1];(模板部分)\n        // 但由于我们源数组下标从 0 开始,因此要在模板的基础上进行 + 1\n        x1++; y1++; x2++; y2++;\n        return sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1];\n    }\n}\n```\n* 时间复杂度:预处理前缀和数组需要对原数组进行线性扫描,复杂度为 $O(n * m)$,计算结果复杂度为 $O(1)$。整体复杂度为 $O(n * m)$\n* 空间复杂度:$O(n * m)$\n\n***\n\n### 二维前缀和模板【重点】\n\n下面重点分享下前缀和模板该如何记忆,其实很多模板都可以按照类似方式进行记忆。\n\n虽然「二维前缀和」的模板相比「一维前缀和」的模板要长,但是逻辑是清晰的,可以现场推导。\n\n当然也可以**在理解的基础上**,使用以下方式进行记忆:\n\n```Java\n// 预处理前缀和数组\n{\n    sum = new int[n + 1][m + 1];\n    for (int i = 1; i <= n; i++) {\n        for (int j = 1; j <= m; j++) {\n            // 当前格子(和) = 上方的格子(和) + 左边的格子(和) - 左上角的格子(和) + 当前格子(值)【和是指对应的前缀和,值是指原数组中的值】\n            sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + matrix[i - 1][j - 1];\n        }\n    }\n}\n\n// 首先我们要令左上角为 (x1, y1) 右下角为 (x2, y2)\n// 计算 (x1, y1, x2, y2) 的结果\n{\n    // 前缀和是从 1 开始,原数组是从 0 开始,上来先将原数组坐标全部 +1,转换为前缀和坐标\n    x1++; y1++; x2++; y2++;\n    // 记作 22 - 12 - 21 + 11,然后 不减,减第一位,减第二位,减两位\n    // 也可以记作 22 - 12(x - 1) - 21(y - 1) + 11(x y 都 - 1)\n    ans = sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1];\n}\n```", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.304` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/301-310/306. 累加数（中等）.md", "url_title": "306. 累加数", "url": "https://leetcode-cn.com/problems/additive-number/solution/gong-shui-san-xie-hui-su-gao-jing-du-jia-6o6b/", "difficulty": "中等", "tags": ["回溯算法", "高精度"], "question": "累加数 是一个字符串,组成它的数字可以形成累加序列。\n\n一个有效的 累加序列 必须 至少 包含 `3` 个数。除了最开始的两个数以外,字符串中的其他数都等于它之前两个数相加的和。\n\n给你一个只包含数字 `'0'-'9'` 的字符串,编写一个算法来判断给定输入是否是 累加数 。如果是,返回 `true` ;否则,返回 `false` 。\n\n说明:累加序列里的数 不会 以 `0` 开头,所以不会出现 `1`, `2`, `03` 或者 `1`, `02`, `3` 的情况。\n\n示例 1:\n```\n输入:\"112358\"\n\n输出:true \n\n解释:累加序列为: 1, 1, 2, 3, 5, 8 。1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8\n```\n示例 2:\n```\n输入:\"199100199\"\n\n输出:true \n\n解释:累加序列为: 1, 99, 100, 199。1 + 99 = 100, 99 + 100 = 199\n```\n\n提示:\n* $1 <= num.length <= 35$\n* `num` 仅由数字(`0` - `9`)组成\n\n进阶:你计划如何处理由过大的整数输入导致的溢出?", "solution": "### 回溯 + 高精度加法\n\n给定的 $nums$ 的长度只有 $35$,且要求序列的第三个数开始由前两个数相加而来。\n\n容易想到通过 `DFS` 爆搜每个数的分割点,同时利用累加数的特性(第三个数起,每个数均由为前两数之和)进行剪枝。\n\n具体的,我们可以实现一个 `boolean dfs(int u)` 函数,入参为当前决策到 $num$ 的哪一位,返回值为决策结果(序列)是否为累加数序列,爆搜过程中的分割数序列存放到 $list$ 中。\n\n由于是 **从位置 $u$ 作为开始位置决策如何分割出当前数 $x$,我们可以枚举当前数的结束位置,范围为 $[u, n - 1]$,但需要注意分割数不能包含前导零,即如果 $num[u] = 0$,则当前数只能为 $0$**。\n\n同时,一个合法的分割数必然满足「其值大小为前两数之和」,因此当前数 $x$ 能够被添加到 $list$ 的充要条件为:\n\n1. $list$ 长度不足 $2$,即 $x$ 为序列中的前两数,不存在值大小的约束问题,$x$ 可以被直接到 $list$ 并继续爆搜;\n2. $list$ 长度大于等于 $2$,即 $x$ 需要满足「其值大小为前两数之和」要求,以此条件作为剪枝,满足要求的 $x$ 才能追加到 $list$ 中并继续爆搜。\n\n最后,在整个 `DFS` 过程中我们需要监测「当前数」与「前两数之和」是否相等,而分割数长度最大为 $35$,存在溢出风险,我们需要实现「高精度加法」,实现一个 `check` 函数,用于检查 `a + b` 是否为 `c`,其中 `a`、`b` 和 `c` 均为使用「逆序」存储数值的数组(最高位对应个位,举个 🌰,$a = 35$,则有 `[5, 3]`)。\n\n若爆搜过程能顺利结束(得到长度至少为 $3$ 的序列),则说明能够拆分出累加数序列,返回 `True`,否则返回 `False`。\n\n至此,我们解决了本题,并通过引入「高精度」来回答了「进阶」部分的问题。\n\n代码:\n```Java\nclass Solution {\n    String num;\n    int n;\n    List<List<Integer>> list = new ArrayList<>();\n    public boolean isAdditiveNumber(String _num) {\n        num = _num;\n        n = num.length();\n        return dfs(0);\n    }\n    boolean dfs(int u) {\n        int m = list.size();\n        if (u == n) return m >= 3;\n        int max = num.charAt(u) == '0' ? u + 1 : n;\n        List<Integer> cur = new ArrayList<>();\n        for (int i = u; i < max; i++) {\n            cur.add(0, num.charAt(i) - '0');\n            if (m < 2 || check(list.get(m - 2), list.get(m - 1), cur)) {\n                list.add(cur);\n                if (dfs(i + 1)) return true;\n                list.remove(list.size() - 1);\n            }\n        }\n        return false;\n    }\n    boolean check(List<Integer> a, List<Integer> b, List<Integer> c) {\n        List<Integer> ans = new ArrayList<>();\n        int t = 0;\n        for (int i = 0; i < a.size() || i < b.size(); i++) {\n            if (i < a.size()) t += a.get(i);\n            if (i < b.size()) t += b.get(i);\n            ans.add(t % 10);\n            t /= 10;\n        }\n        if (t > 0) ans.add(t);\n        boolean ok = c.size() == ans.size();\n        for (int i = 0; i < c.size() && ok; i++) {\n            if (c.get(i) != ans.get(i)) ok = false;\n        }\n        return ok;\n    }\n}\n```\n* 时间复杂度:爆搜的复杂度为指数级别,且存在剪枝操作,分析时空复杂度意义不大\n* 空间复杂度:爆搜的复杂度为指数级别,且存在剪枝操作,分析时空复杂度意义不大", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.306` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/301-310/307. 区域和检索 - 数组可修改（中等）.md", "url_title": "307. 区域和检索 - 数组可修改", "url": "https://leetcode-cn.com/problems/range-sum-query-mutable/solution/guan-yu-ge-lei-qu-jian-he-wen-ti-ru-he-x-41hv/", "difficulty": "中等", "tags": ["区间和", "树状数组", "线段树"], "question": "给你一个数组 `nums`,请你完成两类查询,其中一类查询要求更新数组下标对应的值,另一类查询要求返回数组中某个范围内元素的总和。\n\n实现 `NumArray` 类:\n* `NumArray(int[] nums)` 用整数数组 `nums` 初始化对象\n* `void update(int index, int val)` 将 `nums[index]` 的值更新为 `val`\n* `int sumRange(int left, int right)` 返回子数组 `nums[left, right]` 的总和(即,`nums[left] + nums[left + 1], ..., nums[right]`)\n\n示例:\n```\n输入:\n[\"NumArray\", \"sumRange\", \"update\", \"sumRange\"]\n[[[1, 3, 5]], [0, 2], [1, 2], [0, 2]]\n\n输出:\n[null, 9, null, 8]\n\n解释:\nNumArray numArray = new NumArray([1, 3, 5]);\nnumArray.sumRange(0, 2); // 返回 9 ,sum([1,3,5]) = 9\nnumArray.update(1, 2);   // nums = [1,2,5]\nnumArray.sumRange(0, 2); // 返回 8 ,sum([1,2,5]) = 8\n```\n\n提示:\n* $1 <= nums.length <= 3 * 10^4$\n* $-100 <= nums[i] <= 100$\n* $0 <= index < nums.length$\n* $-100 <= val <= 100$\n* $0 <= left <= right < nums.length$\n* 最多调用 $3 * 10^4$ 次 `update` 和 `sumRange` 方法", "solution": "### 解题思路\n\n这是一道很经典的题目,通常还能拓展出一大类问题。\n\n针对不同的题目,我们有不同的方案可以选择(假设我们有一个数组):\n\n1. 数组不变,求区间和:「前缀和」、「树状数组」、「线段树」\n2. 多次修改某个数(单点),求区间和:「树状数组」、「线段树」\n3. 多次修改某个区间,输出最终结果:「差分」\n4. 多次修改某个区间,求区间和:「线段树」、「树状数组」(看修改区间范围大小)\n5. 多次将某个区间变成同一个数,求区间和:「线段树」、「树状数组」(看修改区间范围大小)\n\n这样看来,「线段树」能解决的问题是最多的,那我们是不是无论什么情况都写「线段树」呢?\n\n答案并不是,而且恰好相反,只有在我们遇到第 4/5 类问题,不得不写「线段树」的时候,我们才考虑线段树。\n\n因为「线段树」代码很长,而且常数很大,实际表现不算很好。我们只有在不得不用的时候才考虑「线段树」。\n\n总结一下,我们应该按这样的优先级进行考虑:\n\n1. 简单求区间和,用「前缀和」\n2. 多次将某个区间变成同一个数,用「线段树」\n3. 其他情况,用「树状数组」\n\n---\n\n### 树状数组\n\n本题只涉及「单点修改」和「区间求和」,属于「树状数组」的经典应用。\n\n「树状数组」本身是一个很简单的数据结构,但是要搞懂其为什么可以这样「查询」&「更新」还是比较困难的(特别是为什么可以这样更新),往往需要从「二进制分解」进行出发理解。\n\n树状数组涉及的操作有两个,复杂度均为 $O(\\log{n})$:\n\n* `void add(int x, int u)`:含义为在 $x$ 的位置增加 $u$(注意位置下标从 $1$ 开始);\n* `int query(int x)`:含义为查询从 $[1, x]$ 区间的和为多少(配合容斥原理,可实现任意区间查询)。\n\n代码:\n```Java\nclass NumArray {\n    int[] tr;\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void add(int x, int u) {\n        for (int i = x; i <= n; i += lowbit(i)) tr[i] += u;\n    }\n    int query(int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];\n        return ans;\n    }\n\n    int[] nums;\n    int n;\n    public NumArray(int[] _nums) {\n        nums = _nums;\n        n = nums.length;\n        tr = new int[n + 10];\n        for (int i = 0; i < n; i++) add(i + 1, nums[i]);\n    }\n    public void update(int index, int val) {\n        add(index + 1, val - nums[index]);\n        nums[index] = val;\n    }\n    public int sumRange(int left, int right) {\n        return query(right + 1) - query(left);\n    }\n}\n```\n* 时间复杂度:插入和查询复杂度均为 $O(\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 线段树\n\n相比「树状数组」,另外一个更为进阶且通用的做法是使用「线段树」。\n\n线段树的所有操作同样为 $O(\\log{n}),$由于本题不涉及「区间修改」操作,因此我们的线段树只需要实现 `pushup` 操作(子节点往上更新父节点),而不需要实现用于懒标记的 `pushdown` 操作(父节点往下传递「更新」的操作)。\n\n关于线段树设计的几种操作:\n\n* `void build(int u, int l, int r)`:含义为从编号为 $u$ 的节点开始,构造范围为 $[l,r]$ 的树节点;\n* `void update(int u, int x, int v)`:含义为从编号为 $u$ 的节点开始,在 $x$ 位置增加 $v$;\n    * 更具一般性(涉及区间修改)的操作应该为 `void update(int u, int l, int r, int v)`,代表在 $[l, r]$ 范围增加 $v$;\n* `int query(int u, int l, int r)`:含义为从编号为 $u$ 的节点开始,查询 $[l, r]$ 区间和为多少。\n\n> 注意:对于编号为 `u` 的节点而言,其左子节点的编号为 `u << 1`,其右节点的编号为 `u << 1 | 1`。\n\n代码(考虑为线段树增加 `static` 优化的代码见 $P2$,样例个数较少,优化不明显):\n```Java\nclass NumArray {\n    Node[] tr;\n    class Node {\n        int l, r, v;\n        Node(int _l, int _r) {\n            l = _l; r = _r;\n        }\n    }\n    void build(int u, int l, int r) {\n        tr[u] = new Node(l, r);\n        if (l == r) return;\n        int mid = l + r >> 1;\n        build(u << 1, l, mid);\n        build(u << 1 | 1, mid + 1, r);\n    }\n    void update(int u, int x, int v) {\n        if (tr[u].l == x && tr[u].r == x) {\n            tr[u].v += v;\n            return ;\n        }\n        int mid = tr[u].l + tr[u].r >> 1;\n        if (x <= mid) update(u << 1, x, v);\n        else update(u << 1 | 1, x, v);\n        pushup(u);\n    }\n    int query(int u, int l, int r) {\n        if (l <= tr[u].l && tr[u].r <= r) return tr[u].v;\n        int mid = tr[u].l + tr[u].r >> 1;\n        int ans = 0;\n        if (l <= mid) ans += query(u << 1, l, r);\n        if (r > mid) ans += query(u << 1 | 1, l, r);\n        return ans;\n    }\n    void pushup(int u) {\n        tr[u].v = tr[u << 1].v + tr[u << 1 | 1].v;\n    }\n\n    int[] nums;\n    public NumArray(int[] _nums) {\n        nums = _nums;\n        int n = nums.length;\n        tr = new Node[n * 4];\n        build(1, 1, n);\n        for (int i = 0; i < n; i++) update(1, i + 1, nums[i]);\n    }\n    public void update(int index, int val) {\n        update(1, index + 1, val - nums[index]);\n        nums[index] = val;\n    }\n    public int sumRange(int left, int right) {\n        return query(1, left + 1, right + 1);\n    }\n}\n```\n\n-\n\n```Java\nclass NumArray {\n    static int N = 30010;\n    static Node[] tr = new Node[N * 4];\n    class Node {\n        int l, r, v;\n        Node(int _l, int _r) {\n            l = _l; r = _r;\n        }\n    }\n    void build(int u, int l, int r) {\n        if (tr[u] == null) {\n            tr[u] = new Node(l, r);\n        } else {\n            tr[u].l = l; tr[u].r = r; tr[u].v = 0;\n        }\n        if (l == r) return ;\n        int mid = l + r >> 1;\n        build(u << 1, l, mid);\n        build(u << 1 | 1, mid + 1, r);\n    }\n    void update(int u, int x, int v) {\n        if (tr[u].l == x && tr[u].r == x) {\n            tr[u].v += v;\n            return ;\n        }\n        int mid = tr[u].l + tr[u].r >> 1;\n        if (x <= mid) update(u << 1, x, v);\n        else update(u << 1 | 1, x, v);\n        pushup(u);\n    }\n    int query(int u, int l, int r) {\n        if (l <= tr[u].l && tr[u].r <= r) return tr[u].v;\n        int mid = tr[u].l + tr[u].r >> 1;\n        int ans = 0;\n        if (l <= mid) ans += query(u << 1, l, r);\n        if (r > mid) ans += query(u << 1 | 1, l, r);\n        return ans;\n    }\n    void pushup(int u) {\n        tr[u].v = tr[u << 1].v + tr[u << 1 | 1].v;\n    }\n\n    int[] nums;\n    public NumArray(int[] _nums) {\n        nums = _nums;\n        int n = nums.length;\n        build(1, 1, n);\n        for (int i = 0; i < n; i++) update(1, i + 1, nums[i]);\n    }\n    public void update(int index, int val) {\n        update(1, index + 1, val - nums[index]);\n        nums[index] = val;\n    }\n    public int sumRange(int left, int right) {\n        return query(1, left + 1, right + 1);\n    }\n}\n```\n* 时间复杂度:插入和查询复杂度均为 $O(\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.307` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/301-310/310. 最小高度树（中等）.md", "url_title": "310. 最小高度树", "url": "https://leetcode-cn.com/problems/minimum-height-trees/solution/by-ac_oier-7xio/", "difficulty": "中等", "tags": ["树形 DP", "DFS", "动态规划"], "question": "树是一个无向图,其中任何两个顶点只通过一条路径连接。 换句话说,一个任何没有简单环路的连通图都是一棵树。\n\n给你一棵包含 $n$ 个节点的树,标记为 $0$ 到 $n - 1$ 。给定数字 $n$ 和一个有 $n - 1$ 条无向边的 `edges` 列表(每一个边都是一对标签),其中 $edges[i] = [a_i, b_i]$ 表示树中节点 $a_i$ 和 $b_i$ 之间存在一条无向边。\n\n可选择树中任何一个节点作为根。当选择节点 $x$ 作为根节点时,设结果树的高度为 $h$ 。在所有可能的树中,具有最小高度的树(即,`min(h)`)被称为 最小高度树 。\n\n请你找到所有的 **最小高度树** 并按 **任意顺序** 返回它们的根节点标签列表。\n\n树的 **高度** 是指根节点和叶子节点之间最长向下路径上边的数量。\n\n示例 1:\n\n```\n输入:n = 4, edges = [[1,0],[1,2],[1,3]]\n\n输出:[1]\n\n解释:如图所示,当根是标签为 1 的节点时,树的高度是 1 ,这是唯一的最小高度树。\n```\n示例 2:\n\n```\n输入:n = 6, edges = [[3,0],[3,1],[3,2],[3,4],[5,4]]\n\n输出:[3,4]\n```\n\n提示:\n* $1 <= n <= 2 \\times 10^4$\n* $edges.length = n - 1$\n* $0 <= ai, bi < n$\n* $ai != bi$\n* 所有 $(ai, bi)$ 互不相同\n* 给定的输入保证是一棵树,并且不会有重复的边", "solution": "### 树形 DP\n\n这是一道树形 DP 模板题。\n\n当确定以某个点为根节点时,整棵树的形态唯一固定,不妨以编号为 $0$ 的节点作为根节点进行分析。\n\n假设当前处理到的节点为 `u`,其是从父节点 `fa` 遍历而来,且将要遍历的子节点为 `j`。\n\n即树的形态如图所示(一些可能有的出边用虚线表示):\n\n**树形 DP 问题通常将问题根据「方向」进行划分**。\n\n对于当前处理到的节点 `u` 而言,我们根据是否考虑「从 `fa` 到 `u` 的出边」将其分为「往上」和「往下」两个方向。\n\n假设我们可以通过 `DFS` 预处理出 $f$ 数组和 $g$ 数组:\n\n* $f[u]$ 代表在以 $0$ 号点为根节点的树中,以 `u` 节点为子树根节点时,往下的最大高度\n* $g[u]$ 代表在以 $0$ 号点为根节点的树中,以 `u` 节点为子节点时,往上的最大高度\n\n那么最终以 `u` 为根节点的最大高度为 $\\max(f[u], g[u])$。\n\n$f[u]$ 只需要简单的 `DFS` 即可处理出来。对于 $g[u]$ 而言,其同样包含「往上」和「往下」两部分:\n\n* 对于经过 `fa` 后接着往上的部分有 $g[fa] + 1$\n* 对于经过 `fa` 后转而往下的部分,我们需要考虑「`fa` 节点往下的最大值 $f[fa]$」是否由 `u` 节点参与而来进行分情况讨论:\n  * 如果 $f[fa]$ 本身不由 `u` 参与,那么 $g[u]$ 应当是 `fa` 节点往下的最大值 $+1$ 而来($+1$ 代表加上 `fa` 到 `u` 的边)\n  * 如果本身 `fa` 往下的最大值由 `u` 节点参与,此时应当使用 `fa` 往下的次大值 $+1$ 来更新 $g[u]$\n\n因此我们需要对 $f$ 数组进行拆分,拆分为记录「最大值的 $f1$ 数组」和记录「次大值的 $f2$ 数组(注意这里的次大值是非严格的次大值)」,同时使用 $p$ 数组记录下取得 $f1[u]$ 时 `u` 的子节点 `j` 为何值。 \n\n实现上,在处理「往上」方向的 `DFS` 时,为避免对 `fa` 节点为空的处理,我们可以将「用 `fa` 来更新 `u`」调整为「用 `u` 来更新 `j`」。\n\n代码:\n```Java\nclass Solution {\n    int N = 20010, M = N * 2, idx = 0;\n    int[] he = new int[N], e = new int[M], ne = new int[M];\n    int[] f1 = new int[N], f2 = new int[N], g = new int[N], p = new int[N];\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    public List<Integer> findMinHeightTrees(int n, int[][] edges) {\n        Arrays.fill(he, -1);\n        for (int[] e : edges) {\n            int a = e[0], b = e[1];\n            add(a, b); add(b, a);\n        }\n        dfs1(0, -1);\n        dfs2(0, -1);\n        List<Integer> ans = new ArrayList<>();\n        int min = n;\n        for (int i = 0; i < n; i++) {\n            int cur = Math.max(f1[i], g[i]);\n            if (cur < min) {\n                min = cur;\n                ans.clear();\n                ans.add(i);\n            } else if (cur == min) {\n                ans.add(i);\n            }\n        }\n        return ans;\n    }\n    int dfs1(int u, int fa) {\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (j == fa) continue;\n            int sub = dfs1(j, u) + 1;\n            if (sub > f1[u]) {\n                f2[u] = f1[u];\n                f1[u] = sub;\n                p[u] = j;\n            } else if (sub > f2[u]) {\n                f2[u] = sub;\n            }\n        }\n        return f1[u];\n    }\n    void dfs2(int u, int fa) {\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (j == fa) continue;\n            if (p[u] != j) g[j] = Math.max(g[j], f1[u] + 1);\n            else g[j] = Math.max(g[j], f2[u] + 1);\n            g[j] = Math.max(g[j], g[u] + 1);\n            dfs2(j, u);\n        }\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 补充\n\n可能会初次接触「树形 DP」的同学不太理解,这里再补充说明一下。\n\n归根结底,以  `u` 为根节点的最大深度,必然是下面三种情况之一(往下、往上 和 往上再往下)。\n\n其中对 $f$ 数组的拆分(变为 $f1$ 和 $f2$)以及记录取得 $f1$ 对应的子节点 $p[i]$,目的都是为了能够正确统计「往上再往下」的情况(统计该情况时,不能考虑从 `fa` 经过 `u` 的路径,因此需要记录一个非严格的次大值 $f2$)。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.310` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/31-40/31. 下一个排列（中等）.md", "url_title": "31. 下一个排列", "url": "https://leetcode-cn.com/problems/next-permutation/solution/miao-dong-xi-lie-100-cong-xia-yi-ge-pai-gog8j/", "difficulty": "中等", "tags": ["模拟", "数学"], "question": "实现获**下一个排列**的函数,算法需要将给定数字序列重新排列成字典序中下一个更大的排列。\n\n如果不存在下一个更大的排列,则将数字重新排列成最小的排列(即升序排列)。\n\n必须「原地」修改,只允许使用额外常数空间。\n\n示例 1:\n```\n输入:nums = [1,2,3]\n\n输出:[1,3,2]\n```\n示例 2:\n```\n输入:nums = [3,2,1]\n\n输出:[1,2,3]\n```\n示例 3:\n```\n输入:nums = [1,1,5]\n\n输出:[1,5,1]\n```\n示例 4:\n```\n输入:nums = [1]\n\n输出:[1]\n```\n\n提示:\n* $1 <= nums.length <= 100$\n* $0 <= nums[i] <= 100$", "solution": "### 模拟\n\n找下一个排列的数,大家可以先想想大脑来是怎么完成这个找数的过程的。\n\n**我们会尽可能的将低位的数字变大,这样才符合「下一个排列」的定义。**\n\n也就是从低位往高位检查,观察某一位在「下一个排列」中是否可以被更大的数代替。\n\n那么如何判断某一位能够被更大的数代替呢?\n\n**其实就是将 `k` 位到低位的所有数作为候选,判断是否有更大的数可以填入 `k` 位中。**\n\n假设当前我们检查到 `k` 位,要分析第 `k` 位在「下一个排列」中是否能被更大的数代替。\n\n我们会先假定高位到 `k` 位的数不变,在 `k` 位到低位中是否有比 `k` 位上的数更大的数,如果有说明 `k` 在「下一个排列」中变大。\n\n换句话说,我们要找的第 `k` 位其实就是从低位到高位的第一个下降的数。\n\n...\n\n为了更好理解,我们结合样例来分析,假设样例为 `[1,3,5,4,1]`:\n\n1. **从后往前找,找到第一个下降的位置,记为 `k`。注意`k` 以后的位置是降序的。** 在样例中就是找到 3\n\n2. **从 k 往后找,找到最小的比 k 要大的数。** 找到 4\n\n3. **将两者交换。注意此时 `k` 以后的位置仍然是降序的。**\n\n4. **直接将 k 以后的部分翻转(变为升序)。**\n\n注意:如果在步骤 1 中找到头部还没找到,说明该序列已经是字典序最大的排列。按照题意,我们要将数组重新排列成最小的排列。\n\n代码:\n```Java\nclass Solution {\n    public void nextPermutation(int[] nums) {\n        int n = nums.length, k = n - 1;\n        while (k - 1 >= 0 && nums[k - 1] >= nums[k]) k--;\n        if (k == 0) {\n            reverse(nums, 0, n - 1);\n        } else {\n            int u = k;\n            while (u + 1 < n && nums[u + 1] > nums[k - 1]) u++;\n            swap(nums, k - 1, u);\n            reverse(nums, k, n - 1);\n        }\n    }\n    void reverse(int[] nums, int a, int b) {\n        int l = a, r = b;\n        while (l < r) swap(nums, l++, r--);\n    }\n    void swap(int[] nums, int a, int b) {\n        int c = nums[a];\n        nums[a] = nums[b];\n        nums[b] = c;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.31` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/31-40/32. 最长有效括号（困难）.md", "url_title": "32. 最长有效括号", "url": "https://leetcode.cn/problems/longest-valid-parentheses/solutions/577327/shua-chuan-lc-miao-dong-xi-lie-shi-yong-95ezk/", "difficulty": "困难", "tags": ["栈", "括号问题"], "question": "给你一个只包含 `'('` 和 `')'` 的字符串,找出最长有效(格式正确且连续)括号子串的长度。\n\n示例 1:\n```\n输入:s = \"(()\"\n\n输出:2\n\n解释:最长有效括号子串是 \"()\"\n```\n示例 2:\n```\n输入:s = \")()())\"\n\n输出:4\n\n解释:最长有效括号子串是 \"()()\"\n```\n示例 3:\n```\n输入:s = \"\"\n\n输出:0\n```\n\n提示:\n* $0 <= s.length <= 3 \\times 10^4$\n* $s[i]$ 为 `'('` 或 `')'`", "solution": "### 栈\n\n从前往后扫描字符串 `s`。\n\n用 `i` 来记录当前遍历到的位置,用 `j` 来记录最近的最长有效括号的开始位置的「前一个位置」。\n\n只对 `'('` 进行入栈(入栈的是对应的下标),当遍历到 `')'` 的时候,由于栈中只有 `'('`,所以可以直接弹出一个 `'('` 与之匹配(如果有的话)。\n\n再检查栈中是否还有 `'('`,如果有使用栈顶元素的下标来计算长度,否则使用 `j` 下标来计算长度。\n\n该做法的本质:**栈里只存放待匹配的 `(` 符号,虽然这些 `(` 在原字符串中的下标不一定连续,但 `(` 之间一定为有效括号,因此可以使用栈顶元素作为有效括号的左边界计算长度**。\n\n举个 🌰,对于 `s` = `((())((` 的情况,当整个字符串处理完,栈内剩下的不是所有的 `(` 符号(不是 $5$ 个),而是剩余待匹配的 `(` 符号(而是 $3$ 个,即从左往右第 $1$、$4$ 和 $5$ 个 `(`),虽然第 $1$ 和第 $4$ 个 `(` 符号在 `s` 中不连续,但其之间必然是有效括号。\n\nJava 代码:\n```Java\nclass Solution {\n    public int longestValidParentheses(String s) {\n        Deque<Integer> d = new ArrayDeque<>();\n        int n = s.length(), ans = 0;\n        for (int i = 0, j = -1; i < n; i++) {\n            if (s.charAt(i) == '(') {\n                d.addLast(i);\n            } else {\n                if (!d.isEmpty()) {\n                    d.pollLast();\n                    int top = j;\n                    if (!d.isEmpty()) top = d.peekLast();\n                    ans = Math.max(ans, i - top);\n                } else {\n                    j = i;\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int longestValidParentheses(string s) {\n        stack<int> d;\n        int n = s.length(), ans = 0;\n        for (int i = 0, j = -1; i < n; i++) {\n            if (s[i] == '(') {\n                d.push(i);\n            } else {\n                if (!d.empty()) {\n                    d.pop();\n                    int top = j;\n                    if (!d.empty()) top = d.top();\n                    ans = max(ans, i - top);\n                } else {\n                    j = i;\n                }\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nfrom collections import deque\n\nclass Solution:\n    def longestValidParentheses(self, s: str) -> int:\n        d = deque()\n        n, ans, j = len(s), 0, -1\n        for i in range(n):\n            if s[i] == '(':\n                d.append(i)\n            else:\n                if d:\n                    d.pop()\n                    top = j\n                    if d: top = d[-1]\n                    ans = max(ans, i - top)\n                else:\n                    j = i\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction longestValidParentheses(s: string): number {\n    const d: number[] = [];\n    let n = s.length, ans = 0;\n    for (let i = 0, j = -1; i < n; i++) {\n        if (s[i] === '(') {\n            d.push(i);\n        } else {\n            if (d.length) {\n                d.pop();\n                let top = j;\n                if (d.length) top = d[d.length - 1]\n                ans = Math.max(ans, i - top);\n            } else {\n                j = i;\n            }\n        }\n    }\n    return ans;\n};\n```\n* 时间复杂度:每个字符最多进栈和出栈一次,复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.32` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/31-40/33. 搜索旋转排序数组（中等）.md", "url_title": "33. 搜索旋转排序数组", "url": "https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/", "difficulty": "中等", "tags": ["二分"], "question": "整数数组 `nums` 按升序排列,数组中的值互不相同。\n\n在传递给函数之前,`nums` 在预先未知的某个下标 $k$ ($0 <= k < nums.length$)上进行了**旋转**。\n\n使数组变为 `[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]`(下标 从 $0$ 开始计数)。\n\n例如, `[0,1,2,4,5,6,7]` 在下标 $3$ 处经旋转后可能变为 `[4,5,6,7,0,1,2] `。\n\n给你**旋转后**的数组 `nums` 和一个整数 `target` 。\n\n如果 `nums` 中存在这个目标值 `target` ,则返回它的下标,否则返回 `-1` 。\n\n示例 1:\n```\n输入:nums = [4,5,6,7,0,1,2], target = 0\n\n输出:4\n```\n示例 2:\n```\n输入:nums = [4,5,6,7,0,1,2], target = 3\n\n输出:-1\n```\n示例 3:\n```\n输入:nums = [1], target = 0\n\n输出:-1\n```\n\n提示:\n* $1 <= nums.length <= 5000$\n* $-10^4 <= nums[i] <= 10^4$\n* `nums` 中的每个值都 独一无二\n* 题目数据保证 `nums` 在预先未知的某个下标上进行了旋转\n* $-10^4 <= target <= 10^4$\n\n进阶:你可以设计一个时间复杂度为 $O(\\log{n})$ 的解决方案吗?", "solution": "### 先找旋转点后二分\n\n但凡是从有序序列中找某个数,我们第一反应应该是「二分」。\n\n这道题是一个原本有序的数组在某个点上进行了旋转,其实就是将原本一段升序的数组分为了两段。\n\n我们可以先找到旋转点 `idx`,然后对 `idx` 前后进行「二分」。\n\nJava 代码:\n```Java\nclass Solution {\n    public int search(int[] nums, int target) {\n        int n = nums.length, idx = -1;\n        for (int i = 0; i < n - 1 && idx == -1; i++) {\n            if (nums[i] > nums[i + 1]) idx = i;\n        }\n        int ans = find(nums, 0, idx, target);\n        if (ans != -1) return ans;\n        return idx + 1 < n ? find(nums, idx + 1, n - 1, target) : ans;\n    }\n    int find(int[] nums, int l, int r, int target) {\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (nums[mid] >= target) r = mid;    \n            else l = mid + 1;\n        }\n        return nums[l] == target ? l : -1;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int search(vector<int>& nums, int target) {\n        int n = nums.size(), idx = -1;\n        for (int i = 0; i < n - 1 && idx == -1; i++) {\n            if (nums[i] > nums[i + 1]) idx = i;\n        }\n        int ans = find(nums, 0, idx, target);\n        if (ans != -1) return ans;\n        return idx + 1 < n ? find(nums, idx + 1, n - 1, target) : ans;\n    }\n    int find(vector<int>& nums, int l, int r, int target) {\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (nums[mid] >= target) r = mid;    \n            else l = mid + 1;\n        }\n        return nums[l] == target ? l : -1;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def search(self, nums: List[int], target: int) -> int:\n        n, idx = len(nums), -1\n        for i in range(0, n - 1):\n            if nums[i] > nums[i + 1]:\n                idx = i\n                break\n        \n        def find(L, R):\n            l, r = L, R\n            while l < r:\n                mid = l + r >> 1\n                if nums[mid] >= target: r = mid\n                else: l = mid + 1\n            return l if nums[l] == target else -1\n\n        ans = find(0, idx)\n        if ans != -1: return ans\n        return find(idx + 1, n - 1) if idx + 1 < n else ans\n```\nTypeScript 代码:\n```TypeScript\nfunction search(nums: number[], target: number): number {\n    let n = nums.length, idx = -1;\n    for (let i = 0; i < n - 1 && idx == -1; i++) {\n        if (nums[i] > nums[i + 1]) idx = i;\n    }\n    const find = function(l: number, r: number): number {\n        while (l < r) {\n            let mid = l + r >> 1;\n            if (nums[mid] >= target) r = mid;\n            else l = mid + 1;\n        }\n        return nums[l] == target ? l : -1;\n    }\n    let ans = find(0, idx);\n    if (ans!= -1) return ans;\n    return idx + 1 < n ? find(idx + 1, n - 1) : ans;\n};\n```\n* 时间复杂度:先对数组进行一次遍历,找到 `idx`,复杂度为 $O(n)$,对 `idx` 前后进行二分查找,复杂度为 $O(\\log{n})$。整体为 $O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 两次二分\n\n不难发现,虽然在朴素解法中我们应用了「二分」查找。\n\n但理论复杂度为 $O(n)$,实际复杂度也远达不到 $O(\\log{n})$,执行效率取决于旋转点 `idx` 所在数组的下标位置。\n\n那么我们如何实现 $O(\\log{n})$ 的解法呢?\n\n这道题其实是要我们明确「二分」的本质是什么。\n\n「二分」不是单纯指从有序数组中快速找某个数,这只是「二分」的一个应用。\n\n**「二分」的本质是两段性,并非单调性。只要一段满足某个性质,另外一段不满足某个性质,就可以用「二分」。**\n\n经过旋转的数组,显然前半段满足 `>= nums[0]`,而后半段不满足 `>= nums[0]`。我们可以以此作为依据,通过「二分」找到旋转点。\n\n找到旋转点之后,再通过比较 `target` 和 `nums[0]` 的大小,确定 `target` 落在旋转点的左边还是右边。\n\nJava 代码:\n```Java\nclass Solution {\n    public int search(int[] nums, int target) {\n        int n = nums.length;\n\n        // 第一次「二分」:从中间开始找,找到满足 >=nums[0] 的分割点(旋转点)\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (nums[mid] >= nums[0]) l = mid;    \n            else r = mid - 1;\n        }\n\n        // 第二次「二分」:通过和 nums[0] 进行比较,得知 target 是在旋转点的左边还是右边\n        if (target >= nums[0]) {\n            l = 0;\n        } else {\n            l = l + 1; r = n - 1;\n        }\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (nums[mid] >= target) r = mid;    \n            else l = mid + 1;\n        }\n\n        return nums[r] == target ? r : -1;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int search(vector<int>& nums, int target) {\n        int n = nums.size();\n\n        // 第一次「二分」:从中间开始找,找到满足 >=nums[0] 的分割点(旋转点)\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (nums[mid] >= nums[0]) l = mid;    \n            else r = mid - 1;\n        }\n\n        // 第二次「二分」:通过和 nums[0] 进行比较,得知 target 是在旋转点的左边还是右边\n        if (target >= nums[0]) {\n            l = 0;\n        } else {\n            l = l + 1; r = n - 1;\n        }\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (nums[mid] >= target) r = mid;    \n            else l = mid + 1;\n        }\n        \n        return nums[r] == target ? r : -1;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def search(self, nums: List[int], target: int) -> int:\n        n = len(nums)\n        \n        # 第一次「二分」:从中间开始找,找到满足 >=nums[0] 的分割点(旋转点)\n        l, r = 0, n - 1\n        while l < r:\n            mid = l + r + 1 >> 1\n            if nums[mid] >= nums[0]: l = mid\n            else: r = mid - 1\n\n        # 第二次「二分」:通过和 nums[0] 进行比较,得知 target 是在旋转点的左边还是右边\n        if target >= nums[0]:\n            l = 0\n        else:\n            l, r = l + 1, n - 1\n        while l < r:\n            mid = l + r >> 1\n            if nums[mid] >= target: r = mid\n            else: l = mid + 1\n\n        return r if nums[r] == target else -1\n```\nTypeScript 代码:\n```TypeScript\nfunction search(nums: number[], target: number): number {\n    const n = nums.length;\n\n    // 第一次「二分」:从中间开始找,找到满足 >=nums[0] 的分割点(旋转点)\n    let l = 0, r = n - 1;\n    while (l < r) {\n        let mid = l + r + 1 >> 1;\n        if (nums[mid] >= nums[0]) l = mid;\n        else r = mid - 1;\n    }\n\n    // 第二次「二分」:通过和 nums[0] 进行比较,得知 target 是在旋转点的左边还是右边\n    if (target >= nums[0]) {\n        l = 0;\n    } else {\n        l = l + 1; r = n - 1;\n    }\n    while (l < r) {\n        let mid = l + r >> 1;\n        if (nums[mid] >= target) r = mid;\n        else l = mid + 1;\n    }\n\n    return nums[r] == target ? r : -1;\n};\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.33` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/31-40/34. 在排序数组中查找元素的第一个和最后一个位置（中等）.md", "url_title": "34. 在排序数组中查找元素的第一个和最后一个位置", "url": "https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/sha-sha-gao-bu-qing-ru-he-ding-yi-er-fen-rrj1/", "difficulty": "中等", "tags": ["二分"], "question": "给定一个按照升序排列的整数数组 `nums`,和一个目标值 `target`。\n\n找出给定目标值在数组中的开始位置和结束位置。\n\n如果数组中不存在目标值 `target`,返回 $[-1, -1]$。\n\n**进阶:**\n\n* 你可以设计并实现时间复杂度为 $O(\\log{n})$ 的算法解决此问题吗?\n\n示例 1:\n```\n输入:nums = [5,7,7,8,8,10], target = 8\n\n输出:[3,4]\n```\n示例 2:\n```\n输入:nums = [5,7,7,8,8,10], target = 6\n\n输出:[-1,-1]\n```\n示例 3:\n```\n输入:nums = [], target = 0\n\n输出:[-1,-1]\n```\n\n提示:\n* $0 <= nums.length <= 10^5$\n* $-10^9 <= nums[i] <= 10^9$\n* `nums` 是一个非递减数组\n* $-10^9 <= target <= 10^9$", "solution": "### 二分解法\n\n这是一道「二分查找」的裸题。\n\n「二分」有一个比较容易混淆的点是:当需要找目标值第一次出现的下标时,条件应该写成 `nums[mid] >= target` 还是 `nums[mid] <= target`。\n\n其实有一个很好理解的方法:\n\n**由于二分是从中间开始找起的,所以找的必然是条件区间中靠近中心的的边界值。**\n\n文字不好理解,我们结合图片来看:\n\n代码:\n```Java\nclass Solution {\n    public int[] searchRange(int[] nums, int t) {\n        int[] ans = new int[]{-1, -1};\n        int n = nums.length;\n        if (n == 0) return ans;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (nums[mid] >= t) r = mid;\n            else l = mid + 1;   \n        }\n        if (nums[r] != t) return ans;\n        ans[0] = r;\n        l = 0; r = n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (nums[mid] <= t) l = mid;\n            else r = mid - 1;\n        }\n        ans[1] = r;\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.34` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/31-40/35. 搜索插入位置（简单）.md", "url_title": "35. 搜索插入位置", "url": "https://leetcode-cn.com/problems/search-insert-position/solution/shua-chuan-lc-jian-dan-mo-ni-ti-by-ac_oi-7d5t/", "difficulty": "简单", "tags": ["模拟", "二分"], "question": "给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引。\n\n如果目标值不存在于数组中,返回它将会被按顺序插入的位置。\n\n你可以假设数组中无重复元素。\n\n示例 1:\n```\n输入: [1,3,5,6], 5\n\n输出: 2\n```\n示例 2:\n```\n输入: [1,3,5,6], 2\n\n输出: 1\n```\n示例 3:\n```\n输入: [1,3,5,6], 7\n\n输出: 4\n```\n示例 4:\n```\n输入: [1,3,5,6], 0\n\n输出: 0\n```", "solution": "### 朴素做法\n\n一个朴素的做法,从前往后进行处理,直到遇到符合条件的位置。\n\n代码:\n```Java \nclass Solution {\n    public int searchInsert(int[] nums, int t) {\n        for (int i = 0; i < nums.length; i++) {\n            if (nums[i] == t || nums[i] > t) return i;\n        }\n        return nums.length;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 二分解法\n\n利用数组本身有序,我们可以通过二分找插入位置。\n\n具体的,通过二分找到符合 `nums[mid] >= t` 的分割点。注意二分完后需要再次检查是否位置是否符合条件,如果不符合,代表插入元素应该被添加到数组结尾。\n\n代码:\n```Java\nclass Solution {\n    public int searchInsert(int[] nums, int t) {\n        int n = nums.length;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (nums[mid] >= t) {\n                r = mid;\n            } else {\n                l = mid + 1;\n            }\n        }\n        return nums[r] >= t ? r : r + 1;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.35` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/31-40/36. 有效的数独（中等）.md", "url_title": "36. 有效的数独", "url": "https://leetcode-cn.com/problems/valid-sudoku/solution/gong-shui-san-xie-yi-ti-san-jie-ha-xi-bi-ssxp/", "difficulty": "中等", "tags": ["哈希表", "数组", "位运算", "数独问题"], "question": "请你判断一个 `9 x 9` 的数独是否有效。只需要 根据以下规则 ,验证已经填入的数字是否有效即可。\n\n1. 数字 `1-9` 在每一行只能出现一次。\n2. 数字 `1-9` 在每一列只能出现一次。\n3. 数字 `1-9` 在每一个以粗实线分隔的 `3 x 3` 宫内只能出现一次。(请参考示例图)\n\n数独部分空格内已填入了数字,空白格用 `'.'` 表示。\n\n注意:\n* 一个有效的数独(部分已被填充)不一定是可解的。\n* 只需要根据以上规则,验证已经填入的数字是否有效即可。\n\n示例 1:\n```\n输入:board = \n[[\"5\",\"3\",\".\",\".\",\"7\",\".\",\".\",\".\",\".\"]\n,[\"6\",\".\",\".\",\"1\",\"9\",\"5\",\".\",\".\",\".\"]\n,[\".\",\"9\",\"8\",\".\",\".\",\".\",\".\",\"6\",\".\"]\n,[\"8\",\".\",\".\",\".\",\"6\",\".\",\".\",\".\",\"3\"]\n,[\"4\",\".\",\".\",\"8\",\".\",\"3\",\".\",\".\",\"1\"]\n,[\"7\",\".\",\".\",\".\",\"2\",\".\",\".\",\".\",\"6\"]\n,[\".\",\"6\",\".\",\".\",\".\",\".\",\"2\",\"8\",\".\"]\n,[\".\",\".\",\".\",\"4\",\"1\",\"9\",\".\",\".\",\"5\"]\n,[\".\",\".\",\".\",\".\",\"8\",\".\",\".\",\"7\",\"9\"]]\n\n输出:true\n```\n示例 2:\n```\n输入:board = \n[[\"8\",\"3\",\".\",\".\",\"7\",\".\",\".\",\".\",\".\"]\n,[\"6\",\".\",\".\",\"1\",\"9\",\"5\",\".\",\".\",\".\"]\n,[\".\",\"9\",\"8\",\".\",\".\",\".\",\".\",\"6\",\".\"]\n,[\"8\",\".\",\".\",\".\",\"6\",\".\",\".\",\".\",\"3\"]\n,[\"4\",\".\",\".\",\"8\",\".\",\"3\",\".\",\".\",\"1\"]\n,[\"7\",\".\",\".\",\".\",\"2\",\".\",\".\",\".\",\"6\"]\n,[\".\",\"6\",\".\",\".\",\".\",\".\",\"2\",\"8\",\".\"]\n,[\".\",\".\",\".\",\"4\",\"1\",\"9\",\".\",\".\",\"5\"]\n,[\".\",\".\",\".\",\".\",\"8\",\".\",\".\",\"7\",\"9\"]]\n\n输出:false\n\n解释:除了第一行的第一个数字从 5 改为 8 以外,空格内其他数字均与 示例1 相同。 但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。\n```\n\n提示:\n* $board.length == 9$\n* $board[i].length == 9$\n* `board[i][j]` 是一位数字或者 `'.'`", "solution": "### 哈希表\n\n由于只要我们判断是否为有效的数独。\n\n所以我们只需要对 `board` 中出现的数进行判断,如果 `board` 中有数违反了数独的规则,返回 `false`,否则返回 `true`。\n\n直观上,我们很容易想到使用 **哈希表** 来记录某行/某列/某个小方块出现过哪些数字,来帮助我们判断是否符合「有效数独」的定义。\n\n这道题唯一的难点可能是在于如何确定某个数落在哪个小方块中,我们可以去小方块进行编号:\n\n然后推导出小方块编号和行列的关系为: $idx = \\left \\lfloor i / 3 \\right \\rfloor * 3 + \\left \\lfloor j / 3 \\right \\rfloor$。\n\n代码:\n```Java\nclass Solution {\n    public boolean isValidSudoku(char[][] board) {\n        Map<Integer, Set<Integer>> row  = new HashMap<>(), col = new HashMap<>(), area = new HashMap<>();\n        for (int i = 0; i < 9; i++) {\n            row.put(i, new HashSet<>());\n            col.put(i, new HashSet<>());\n            area.put(i, new HashSet<>());\n        }\n        for (int i = 0; i < 9; i++) {\n            for (int j = 0; j < 9; j++) {\n                char c = board[i][j];\n                if (c == '.') continue;\n                int u = c - '0';\n                int idx = i / 3 * 3 + j / 3;\n                if (row.get(i).contains(u) || col.get(j).contains(u) || area.get(idx).contains(u)) return false;\n                row.get(i).add(u);\n                col.get(j).add(u);\n                area.get(idx).add(u);\n            }\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:在固定 $9 \\times 9$ 的问题里,计算量不随数据变化而变化。复杂度为 $O(1)$\n* 空间复杂度:在固定 $9 \\times 9$ 的问题里,存储空间不随数据变化而变化。复杂度为 $O(1)$\n\n---\n\n### 数组\n\n大多数的哈希表计数问题,都能转换为使用数组解决。\n\n虽然时间复杂度一样,但哈希表的更新和查询复杂度为均摊 $O(1)$,而定长数组的的更新和查询复杂度则是严格 $O(1)$。\n\n因此从执行效率上来说,数组要比哈希表快上不少。\n\n代码:\n```Java\nclass Solution {\n    public boolean isValidSudoku(char[][] board) {\n        boolean[][] row = new boolean[10][10], col = new boolean[10][10], area = new boolean[10][10];        \n        for (int i = 0; i < 9; i++) {\n            for (int j = 0; j < 9; j++) {\n                int c = board[i][j];\n                if (c == '.') continue;\n                int u = c - '0';\n                int idx = i / 3 * 3 + j / 3;\n                if (row[i][u] || col[j][u] || area[idx][u]) return false;\n                row[i][u] = col[j][u] = area[idx][u] = true;\n            }\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:在固定 $9*9$ 的问题里,计算量不随数据变化而变化。复杂度为 $O(1)$\n* 空间复杂度:在固定 $9*9$ 的问题里,存储空间不随数据变化而变化。复杂度为 $O(1)$\n\n---\n\n### 位运算\n\n更进一步,我们可以使用一个 $int$ 来记录 某行/某列/某个小方块 的数值填入情况:使用从低位开始的 $[1, 9]$ 位来记录该数值是否已被填入。\n\n例如 $(... 111000111 .)_2$ 代表数值 $[1, 3]$ 和 $[7, 9]$ 均被填入。\n\n代码:\n```Java\nclass Solution {\n    public boolean isValidSudoku(char[][] board) {\n        int[] row = new int[10], col = new int[10], area = new int[10];\n        for (int i = 0; i < 9; i++) {\n            for (int j = 0; j < 9; j++) {\n                char c = board[i][j];\n                if (c == '.') continue;\n                int u = c - '0';\n                int idx = i / 3 * 3 + j / 3;\n                if ((((row[i] >> u) & 1) == 1) || (((col[j] >> u) & 1) == 1) || (((area[idx] >> u) & 1) == 1)) return false;\n                row[i] |= (1 << u);\n                col[j] |= (1 << u);\n                area[idx] |= (1 << u);\n            }\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:在固定 $9 \\times 9$ 的问题里,计算量不随数据变化而变化。复杂度为 $O(1)$\n* 空间复杂度:在固定 $9 \\times 9$ 的问题里,存储空间不随数据变化而变化。复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.36` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/31-40/37. 解数独（困难）.md", "url_title": "37. 解数独", "url": "https://leetcode-cn.com/problems/sudoku-solver/solution/he-n-huang-hou-yi-yang-shi-yi-dao-hui-su-lfpd/", "difficulty": "困难", "tags": ["回溯算法", "DFS", "数独问题"], "question": "编写一个程序,通过填充空格来解决数独问题。\n\n数独的解法需 遵循如下规则:\n1. 数字 `1-9` 在每一行只能出现一次。\n2. 数字 `1-9` 在每一列只能出现一次。\n3. 数字 `1-9` 在每一个以粗实线分隔的 `3 x 3` 宫内只能出现一次。(请参考示例图)\n\n数独部分空格内已填入了数字,空白格用 '.' 表示。\n\n示例:\n\n```\n输入:board = \n[[\"5\",\"3\",\".\",\".\",\"7\",\".\",\".\",\".\",\".\"],\n[\"6\",\".\",\".\",\"1\",\"9\",\"5\",\".\",\".\",\".\"],\n[\".\",\"9\",\"8\",\".\",\".\",\".\",\".\",\"6\",\".\"],\n[\"8\",\".\",\".\",\".\",\"6\",\".\",\".\",\".\",\"3\"],\n[\"4\",\".\",\".\",\"8\",\".\",\"3\",\".\",\".\",\"1\"],\n[\"7\",\".\",\".\",\".\",\"2\",\".\",\".\",\".\",\"6\"],\n[\".\",\"6\",\".\",\".\",\".\",\".\",\"2\",\"8\",\".\"],\n[\".\",\".\",\".\",\"4\",\"1\",\"9\",\".\",\".\",\"5\"],\n[\".\",\".\",\".\",\".\",\"8\",\".\",\".\",\"7\",\"9\"]]\n\n输出:[[\"5\",\"3\",\"4\",\"6\",\"7\",\"8\",\"9\",\"1\",\"2\"],[\"6\",\"7\",\"2\",\"1\",\"9\",\"5\",\"3\",\"4\",\"8\"],\n[\"1\",\"9\",\"8\",\"3\",\"4\",\"2\",\"5\",\"6\",\"7\"],\n[\"8\",\"5\",\"9\",\"7\",\"6\",\"1\",\"4\",\"2\",\"3\"],\n[\"4\",\"2\",\"6\",\"8\",\"5\",\"3\",\"7\",\"9\",\"1\"],\n[\"7\",\"1\",\"3\",\"9\",\"2\",\"4\",\"8\",\"5\",\"6\"],\n[\"9\",\"6\",\"1\",\"5\",\"3\",\"7\",\"2\",\"8\",\"4\"],\n[\"2\",\"8\",\"7\",\"4\",\"1\",\"9\",\"6\",\"3\",\"5\"],\n[\"3\",\"4\",\"5\",\"2\",\"8\",\"6\",\"1\",\"7\",\"9\"]]\n\n解释:输入的数独如上图所示,唯一有效的解决方案如下所示:\n```\n\n提示:\n* $board.length == 9$\n* $board[i].length == 9$\n* `board[i][j]` 是一位数字或者 `'.'`\n* 题目数据 保证 输入数独仅有一个解", "solution": "### 回溯解法\n\n和 N 皇后一样,是一道回溯解法裸题。\n\n上一题「36. 有效的数独(中等)」是让我们判断给定的 `borad` 是否为有效数独。\n\n这题让我们对给定 `board` 求数独,由于 `board` 固定是 `9 * 9` 的大小,我们可以使用回溯算法去做。\n\n这一类题和 N 皇后一样,属于经典的回溯算法裸题。\n\n这类题都有一个明显的特征,就是数据范围不会很大,如该题限制了范围为 `9 * 9`,而 N 皇后的 N 一般不会超过 13。\n\n对每一个需要填入数字的位置进行填入,如果发现填入某个数会导致数独解不下去,则进行回溯。\n\n代码:\n```Java\nclass Solution {\n    boolean[][] row = new boolean[9][9];\n    boolean[][] col = new boolean[9][9];\n    boolean[][][] cell = new boolean[3][3][9];\n    public void solveSudoku(char[][] board) {\n        for (int i = 0; i < 9; i++) {\n            for (int j = 0; j < 9; j++) {\n                if (board[i][j] != '.') {\n                    int t = board[i][j] - '1';\n                    row[i][t] = col[j][t] = cell[i / 3][j / 3][t] = true;\n                }\n            }\n        }\n        dfs(board, 0, 0);\n    }\n    boolean dfs(char[][] board, int x, int y) {\n        if (y == 9) return dfs(board, x + 1, 0);\n        if (x == 9) return true;\n        if (board[x][y] != '.') return dfs(board, x, y + 1);\n        for (int i = 0; i < 9; i++) {\n            if (!row[x][i] && !col[y][i] && !cell[x / 3][y / 3][i]) {\n                board[x][y] = (char)(i + '1');\n                row[x][i] = col[y][i] = cell[x / 3][y / 3][i] = true;\n                if (dfs(board, x, y + 1)) {\n                    break;\n                } else {\n                    board[x][y] = '.';\n                    row[x][i] = col[y][i] = cell[x / 3][y / 3][i] = false;\n                }\n            }\n        }\n        return board[x][y] != '.';\n    }\n}\n```\n* 时间复杂度:在固定 `9*9` 的棋盘里,具有一个枚举方案的最大值(极端情况,假设我们的棋盘刚开始是空的,这时候每一个格子都要枚举,每个格子都有可能从 $1$ 枚举到 $9$,所以枚举次数为 $9 \\times 9 \\times 9 = 729$),即复杂度不随数据变化而变化。复杂度为 $O(1)$\n* 空间复杂度:在固定 `9*9` 的棋盘里,复杂度不随数据变化而变化。复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.37` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/31-40/38. 外观数列（简单）.md", "url_title": "38. 外观数列", "url": "https://leetcode-cn.com/problems/count-and-say/solution/shua-chuan-lc-100-mo-ni-ti-shi-yong-shao-w8jl/", "difficulty": "简单", "tags": ["模拟"], "question": "给定一个正整数 n ,输出外观数列的第 n 项。\n\n「外观数列」是一个整数序列,从数字 1 开始,序列中的每一项都是对前一项的描述。\n\n你可以将其视作是由递归公式定义的数字字符串序列:\n* countAndSay(1) = \"1\"\n* countAndSay(n) 是对 countAndSay(n-1) 的描述,然后转换成另一个数字字符串。\n\n前五项如下:\n```\n1.     1\n2.     11\n3.     21\n4.     1211\n5.     111221\n第一项是数字 1 \n描述前一项,这个数是 1 即 “ 一 个 1 ”,记作 \"11\"\n描述前一项,这个数是 11 即 “ 二 个 1 ” ,记作 \"21\"\n描述前一项,这个数是 21 即 “ 一 个 2 + 一 个 1 ” ,记作 \"1211\"\n描述前一项,这个数是 1211 即 “ 一 个 1 + 一 个 2 + 二 个 1 ” ,记作 \"111221\"\n```\n要**描述**一个数字字符串,首先要将字符串分割为 最小 数量的组,每个组都由连续的最多 相同字符 组成。然后对于每个组,先描述字符的数量,然后描述字符,形成一个描述组。要将描述转换为数字字符串,先将每组中的字符数量用数字替换,再将所有描述组连接起来。\n\n例如,数字字符串 \"3322251\" 的描述如下图:\n\n示例 1:\n```\n输入:n = 1\n\n输出:\"1\"\n\n解释:这是一个基本样例。\n```\n示例 2:\n```\n输入:n = 4\n\n输出:\"1211\"\n\n解释:\ncountAndSay(1) = \"1\"\ncountAndSay(2) = 读 \"1\" = 一 个 1 = \"11\"\ncountAndSay(3) = 读 \"11\" = 二 个 1 = \"21\"\ncountAndSay(4) = 读 \"21\" = 一 个 2 + 一 个 1 = \"12\" + \"11\" = \"1211\"\n```\n\n提示:\n* 1 <= n <= 30", "solution": "### 模拟\n\n一个朴素的想法是:根据题意进行模拟,从起始条件 $k = 1$ 时 `ans = \"1\"` 出发,逐步递推到 $k = n$ 的情况,对于第 $k$ 项而言,其实就是对第 $k - 1$ 项的「连续段」的描述,而求「连续段」长度,可以使用双指针实现。\n\n代码:\n```Java\nclass Solution {\n    public String countAndSay(int n) {\n        String ans = \"1\";\n        for (int i = 2; i <= n; i++) {\n            String cur = \"\";\n            int m = ans.length();\n            for (int j = 0; j < m; ) {\n                int k = j + 1;\n                while (k < m && ans.charAt(j) == ans.charAt(k)) k++;\n                int cnt = k - j;\n                cur += cnt + \"\" + ans.charAt(j);\n                j = k;\n            }\n            ans = cur;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 打表\n\n利用数据范围只有 $30$,我们可以使用 `static` 进行打表操作,从而节省掉不同样例之间的「重复」部分的计算量。\n\n例如对于 $n = 5$ 和 $n = 6$ 都存在先计算前五项的公共部分,打表可以确保这部分只会被计算一次,同时能够应用到后面项中。\n\n代码:\n```Java\nclass Solution {\n    static String[] f = new String[35];\n    static {\n        f[1] = \"1\";\n        for (int i = 2; i < 35; i++) {\n            String prev = f[i - 1], cur = \"\";\n            int m = prev.length();\n            for (int j = 0; j < m; ) {\n                int k = j + 1;\n                while (k < m && prev.charAt(j) == prev.charAt(k)) k++;\n                int cnt = k - j;\n                cur += cnt + \"\" + prev.charAt(j);\n                j = k;\n            }\n            f[i] = cur;\n        }\n    }\n    public String countAndSay(int n) {\n        return f[n];\n    }\n}\n```\n* 时间复杂度:将打表逻辑到放本地执行,复杂度为 $O(1)$;放到 $OJ$ 执行则为 $O(n^2)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.38` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/31-40/39. 组合总和（中等）.md", "url_title": "39. 组合总和", "url": "https://leetcode-cn.com/problems/combination-sum/solution/dfs-hui-su-suan-fa-yi-ji-ru-he-que-ding-wpbo5/", "difficulty": "中等", "tags": ["回溯算法", "DFS", "组合总和问题"], "question": "给定一个无重复元素的数组 `candidates` 和一个目标数 `target` ,找出 `candidates` 中所有可以使数字和为 `target` 的组合。\n\n`candidates` 中的数字可以无限制重复被选取。\n\n说明:\n* 所有数字(包括 `target`)都是正整数。\n* 解集不能包含重复的组合。 \n\n示例 1:\n```\n输入:candidates = [2,3,6,7], target = 7,\n\n所求解集为:\n[\n  [7],\n  [2,2,3]\n]\n```\n示例 2:\n```\n输入:candidates = [2,3,5], target = 8,\n\n所求解集为:\n[\n  [2,2,2,2],\n  [2,3,3],\n  [3,5]\n]\n```\n\n提示:\n* $1 <= candidates.length <= 30$\n* $1 <= candidates[i] <= 200$\n* `candidate` 中的每个元素都是独一无二的。\n* $1 <= target <= 500$", "solution": "### DFS\n\n这道题很明显就是在考察回溯算法。\n\n之前跟你分享过的 [37. 解数独(困难)](https://mp.weixin.qq.com/s/0y4lGAH43U3w5loTgaeyoQ) 里面有提到我们应该如何快速判断一道题是否应该使用 DFS + 回溯算法来爆搜。\n\n总的来说,你可以从两个方面来考虑:\n\n  * **1. 求的是所有的方案,而不是方案数。** 由于求的是所有方案,不可能有什么特别的优化,我们只能进行枚举。这时候可能的解法有动态规划、记忆化搜索、DFS + 回溯算法。\n\n  * **2. 通常数据范围不会太大,只有几十。** 如果是动态规划或是记忆化搜索的题的话,由于它们的特点在于低重复/不重复枚举,所以一般数据范围可以出到 $10^4$ 到 $10^5$,而 DFS + 回溯的话,通常会限制在 $30$ 以内。\n\n这道题数据范围是 $30$ 以内,而且是求所有方案,因此我们使用 DFS + 回溯来求解。\n\n代码:\n```Java\nclass Solution {\n    public List<List<Integer>> combinationSum(int[] cs, int t) {\n        List<List<Integer>> ans = new ArrayList<>();\n        List<Integer> cur = new ArrayList<>();\n        dfs(cs, t, 0, ans, cur);\n        return ans;\n    }\n    /**\n     * cs: 原数组,从该数组进行选数\n     * t: 还剩多少值需要凑成。起始值为 target ,代表还没选择任何数;当 t = 0,代表选择的数凑成了 target\n     * u: 当前决策到 cs[] 中的第几位\n     * ans: 最终结果集\n     * cur: 当前结果集\n     */\n    void dfs(int[] cs, int t, int u, List<List<Integer>> ans, List<Integer> cur) {\n        if (t == 0) {\n            ans.add(new ArrayList<>(cur));\n            return;\n        }\n        if (u == cs.length || t < 0) return;\n\n        // 枚举 cs[u] 的使用次数\n        for (int i = 0; cs[u] * i <= t; i++) {\n            dfs(cs, t - cs[u] * i, u + 1, ans, cur);\n            cur.add(cs[u]);\n        }\n        // 进行回溯。注意回溯总是将数组的最后一位弹出\n        for (int i = 0; cs[u] * i <= t; i++) {\n            cur.remove(cur.size() - 1);\n        }\n    }\n}\n```\n* 时间复杂度:爆搜通常是指数级别的复杂度\n* 空间复杂度:爆搜通常是指数级别的复杂度\n*", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.39` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/31-40/40. 组合总和 II（中等）.md", "url_title": "40. 组合总和 II", "url": "https://leetcode-cn.com/problems/combination-sum-ii/solution/dfs-hui-su-jie-fa-yi-ji-ru-he-pan-duan-s-xlwy/", "difficulty": "中等", "tags": ["回溯算法", "DFS", "组合总和问题"], "question": "给定一个数组 `candidates` 和一个目标数 `target` ,找出 `candidates` 中所有可以使数字和为 `target` 的组合。\n\n`candidates` 中的每个数字在每个组合中只能使用一次。\n\n说明:\n* 所有数字(包括目标数)都是正整数。\n* 解集不能包含重复的组合。 \n\n示例 1:\n\n```\n输入: candidates = [10,1,2,7,6,1,5], target = 8,\n\n所求解集为:\n[\n  [1, 7],\n  [1, 2, 5],\n  [2, 6],\n  [1, 1, 6]\n]\n```\n示例 2:\n```\n输入: candidates = [2,5,2,1,2], target = 5,\n\n所求解集为:\n[\n  [1,2,2],\n  [5]\n]\n```", "solution": "### DFS + 回溯\n\n这道题和「39. 组合总和(中等)」几乎一样。\n\n唯一的不同是这题每个数只能使用一次,而「39. 组合总和(中等)」中可以使用无限次。\n\n我们再来回顾一下应该如何快速判断一道题是否应该使用 DFS + 回溯算法来爆搜。\n\n这个判断方法,最早三叶在 [37. 解数独(困难)](https://mp.weixin.qq.com/s/0y4lGAH43U3w5loTgaeyoQ) 讲过。\n\n总的来说,你可以从两个方面来考虑:\n\n  * **1. 求的是所有的方案,而不是方案数。** 由于求的是所有方案,不可能有什么特别的优化,我们只能进行枚举。这时候可能的解法有动态规划、记忆化搜索、DFS + 回溯算法。\n\n  * **2. 通常数据范围不会太大,只有几十。** 如果是动态规划或是记忆化搜索的题的话,由于它们的特点在于低重复/不重复枚举,所以一般数据范围可以出到 $10^5$ 到 $10^7$,而 DFS + 回溯的话,通常会限制在 30 以内。\n\n这道题数据范围是 30 以内,而且是求所有方案。因此我们使用 DFS + 回溯来求解。\n\n我们可以接着 [39. 组合总和(中等)](https://mp.weixin.qq.com/s/5Ee6jbc3lDlWFEDzTM_LkA) 的思路来修改:\n\n1. 由于每个数字只能使用一次,我们可以直接在 DFS 中决策某个数是用还是不用。\n\n2. 由于不允许重复答案,可以使用 set 来保存所有合法方案,最终再转为 list 进行返回。当然我们需要先对 cs 进行排序,确保得到的合法方案中数值都是从小到大的。这样 set 才能起到去重的作用。对于 `[1,2,1]` 和 `[1,1,2]`,set 不会认为是相同的数组。\n\n代码:\n```Java\nclass Solution {\n    public List<List<Integer>> combinationSum2(int[] cs, int t) {\n        Arrays.sort(cs);\n        Set<List<Integer>> ans = new HashSet<>();\n        List<Integer> cur = new ArrayList<>();\n        dfs(cs, t, 0, ans, cur);\n        return new ArrayList<>(ans);\n    }\n\n    /**\n     * cs: 原数组,从该数组进行选数\n     * t: 还剩多少值需要凑成。起始值为 target ,代表还没选择任何数;当 t = 0,代表选择的数凑成了 target\n     * u: 当前决策到 cs[] 中的第几位\n     * ans: 最终结果集\n     * cur: 当前结果集\n     */\n    void dfs(int[] cs, int t, int u, Set<List<Integer>> ans, List<Integer> cur) {\n        if (t == 0) {\n            ans.add(new ArrayList<>(cur));\n            return;\n        }\n        if (u == cs.length || t < 0) return;\n\n        // 使用 cs[u]\n        cur.add(cs[u]);\n        dfs(cs, t - cs[u], u + 1, ans, cur);\n\n        // 进行回溯\n        cur.remove(cur.size() - 1);\n        // 不使用 cs[u]\n        dfs(cs, t, u + 1, ans, cur);\n    }\n}\n```\n* 时间复杂度: DFS 回溯算法通常是指数级别的复杂度(因此数据范围通常为 30 以内)。这里暂定 $O(n \\times 2^n)$\n* 空间复杂度:同上。复杂度为 $O(n \\times 2^n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.40` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/311-320/312. 戳气球（困难）.md", "url_title": "312. 戳气球", "url": "https://leetcode.cn/problems/burst-balloons/solution/by-ac_oier-9r9c/", "difficulty": "困难", "tags": ["区间 DP", "动态规划"], "question": "有 `n` 个气球,编号为 `0` 到 `n - 1`,每个气球上都标有一个数字,这些数字存在数组 `nums` 中。\n\n现在要求你戳破所有的气球。\n\n戳破第 `i` 个气球,你可以获得 `nums[i - 1] * nums[i] * nums[i + 1]` 枚硬币。 这里的 `i - 1` 和 `i + 1` 代表和 `i` 相邻的两个气球的序号。\n\n如果 `i - 1` 或 `i + 1` 超出了数组的边界,那么就当它是一个数字为 `1` 的气球。\n\n求所能获得硬币的最大数量。\n\n示例 1:\n```\n输入:nums = [3,1,5,8]\n\n输出:167\n\n解释:\nnums = [3,1,5,8] --> [3,5,8] --> [3,8] --> [8] --> []\ncoins =  3*1*5    +   3*5*8   +  1*3*8  + 1*8*1 = 167\n```\n示例 2:\n```\n输入:nums = [1,5]\n\n输出:10\n```\n\n提示:\n* $n = nums.length$\n* $1 <= n <= 300$\n* $0 <= nums[i] <= 100$", "solution": "### 区间 DP\n\n定义 $f[l][r]$ 为考虑将 $(l, r)$ 范围内(不包含 `l` 和 `r` 边界)的气球消耗掉,所能取得的最大价值。\n\n根据题意,我们可以对 `nums` 进行扩充,将其从长度为 $n$ 的 `nums` 变为长度 $n + 2$ 的 `arr`,其中 $arr[1...n]$ 对应了原数组 `nums`,而 $arr[0] = arr[n + 1] = 1$。\n\n此时易知 $f[0][n + 1]$ 即是答案,不失一般性考虑 $f[l][r]$ 该如何转移,假设在 $(l, r)$ 范围内最后剩下的气球的编号为 $k$,此时的 $f[l][r]$ 由「以 $k$ 为分割点的两端所产生的价值」和「消耗 $k$ 本身带来的价值」两部分组成:\n\n$$\nf[l][r] = \\max(f[l][k] + f[k][r] + arr[l] \\times arr[k] \\times arr[r]), k \\in (l, r)\n$$\n\n为了确保转移能够顺利进行,我们需要确保在计算 $f[l][r]$ 的时候,区间长度比其小的 $f[l][k]$ 和 $f[k][r]$ 均被计算。\n\n因此我们可以采用先枚举区间长度 `len`,然后枚举区间左端点 `l`(同时直接算得区间右端点 `r`)的方式来做。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxCoins(int[] nums) {\n        int n = nums.length;\n        int[] arr = new int[n + 2];\n        arr[0] = arr[n + 1] = 1;\n        for (int i = 1; i <= n; i++) arr[i] = nums[i - 1];\n        int[][] f = new int[n + 2][n + 2];\n        for (int len = 3; len <= n + 2; len++) {\n            for (int l = 0; l + len - 1 <= n + 1; l++) {\n                int r = l + len - 1;\n                for (int k = l + 1; k <= r - 1; k++) {\n                    f[l][r] = Math.max(f[l][r], f[l][k] + f[k][r] + arr[l] * arr[k] * arr[r]);\n                }\n            }\n        }\n        return f[0][n + 1];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxCoins(vector<int>& nums) {\n        int n = nums.size();\n        int arr[n + 2];\n        arr[0] = arr[n + 1] = 1;\n        for (int i = 1; i <= n; i++) arr[i] = nums[i - 1];\n        int f[n + 2][n + 2];\n        memset(f, 0, sizeof f);\n        for (int len = 3; len <= n + 2; len++) {\n            for (int l = 0; l + len - 1 <= n + 1; l++) {\n                int r = l + len - 1;\n                for (int k = l + 1; k <= r - 1; k++) {\n                    f[l][r] = max(f[l][r], f[l][k] + f[k][r] + arr[l] * arr[k] * arr[r]);\n                }\n            }\n        }\n        return f[0][n + 1];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxCoins(self, nums: List[int]) -> int:\n        n = len(nums)\n        arr = [1] * (n + 2)\n        arr[0] = arr[n + 1] = 1\n        for i in range(1, n + 1):\n            arr[i] = nums[i - 1]\n        f = [[0] * (n + 2) for _ in range(n + 2)]\n        for clen in range(3, n + 3):\n            for l in range(0, n + 2 - clen + 1):\n                r = l + clen - 1\n                for k in range(l + 1, r):\n                    f[l][r] = max(f[l][r], f[l][k] + f[k][r] + arr[l] * arr[k] * arr[r])\n        return f[0][n + 1]\n```\nTypeScript 代码:\n```TypeScript\nfunction maxCoins(nums: number[]): number {\n    const n = nums.length\n    const arr = new Array<number>(n + 2).fill(1)\n    for (let i = 1; i <= n; i++) arr[i] = nums[i - 1]\n    const f = new Array<Array<number>>(n + 2)\n    for (let i = 0; i < n + 2; i++) f[i] = new Array<number>(n + 2).fill(0)\n    for (let len = 3; len <= n + 2; len++) {\n        for (let l = 0; l + len - 1 <= n + 1; l++) {\n            const r = l + len - 1\n            for (let k = l + 1; k <= r - 1; k++) {\n                f[l][r] = Math.max(f[l][r], f[l][k] + f[k][r] + arr[l] * arr[k] * arr[r])\n            }\n        }\n    }\n    return f[0][n + 1]\n}\n```\n* 时间复杂度:$O(n^3)$\n* 空间复杂度:$O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.312` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/311-320/313. 超级丑数（中等）.md", "url_title": "313. 超级丑数", "url": "https://leetcode-cn.com/problems/super-ugly-number/solution/gong-shui-san-xie-yi-ti-shuang-jie-you-x-jyow/", "difficulty": "中等", "tags": ["优先队列(堆)", "多路归并"], "question": "超级丑数 是一个正整数,并满足其所有质因数都出现在质数数组 primes 中。\n\n给你一个整数 n 和一个整数数组 primes ,返回第 n 个 超级丑数 。\n\n题目数据保证第 n 个 超级丑数 在 32-bit 带符号整数范围内。\n\n示例 1:\n```\n输入:n = 12, primes = [2,7,13,19]\n\n输出:32 \n\n解释:给定长度为 4 的质数数组 primes = [2,7,13,19],前 12 个超级丑数序列为:[1,2,4,7,8,13,14,16,19,26,28,32] 。\n```\n示例 2:\n```\n输入:n = 1, primes = [2,3,5]\n\n输出:1\n\n解释:1 不含质因数,因此它的所有质因数都在质数数组 primes = [2,3,5] 中。\n```\n\n提示:\n* 1 <= n <= $10^6$\n* 1 <= primes.length <= 100\n* 2 <= primes[i] <= 1000\n* 题目数据 保证 primes[i] 是一个质数\n* primes 中的所有值都 互不相同 ,且按 递增顺序 排列", "solution": "### 基本分析\n\n类似的题目在之前的每日一题也出现过。\n\n本题做法与 [264. 丑数 II](https://leetcode-cn.com/problems/ugly-number-ii/) 类似,相关题解在 [这里](https://leetcode-cn.com/problems/ugly-number-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-you-x-3nvs/)。\n\n回到本题,根据丑数的定义,我们有如下结论:\n\n* $1$ 是最小的丑数。\n* 对于任意一个丑数 $x$,其与任意给定的质因数 $primes[i]$ 相乘,结果仍为丑数。\n\n---\n\n### 优先队列(堆)\n\n有了基本的分析思路,一个简单的解法是使用优先队列:\n\n1. 起始先将最小丑数 $1$ 放入队列\n2. 每次从队列取出最小值 $x$,然后将 $x$ 所对应的丑数 $x * primes[i]$ 进行入队。\n3. 对步骤 $2$ 循环多次,第 $n$ 次出队的值即是答案。\n\n为了防止同一丑数多次进队,我们可以使用数据结构 $Set$ 来记录入过队列的丑数,但该做法常数较大,容易被卡。\n\n利用题目规定的答案为 $int$ 范围,以及丑数性质,我们可以直接在入队的时候做控制。\n\n代码:\n```Java\nclass Solution {\n    public int nthSuperUglyNumber(int n, int[] primes) {\n        PriorityQueue<Integer> q = new PriorityQueue<>();\n        q.add(1);\n        while (n-- > 0) {\n            int x = q.poll();\n            if (n == 0) return x;\n            for (int k : primes) {\n                if (k <= Integer.MAX_VALUE / x) q.add(k * x);\n                if (x % k == 0) break;\n            }\n        }\n        return -1; // never\n    }\n}\n```\n* 时间复杂度:令 $primes$ 长度为 $m$,需要从优先队列(堆)中弹出 $n$ 个元素,每次弹出最多需要放入 $m$ 个元素,堆中最多有 $n * m$ 个元素。复杂度为 $O(n * m \\log{(n * m)})$\n* 空间复杂度:$O(n * m)$\n\n---\n\n### 多路归并\n\n从解法一中不难发现,我们「往后产生的丑数」都是基于「已有丑数」而来(使用「已有丑数」乘上「给定质因数」$primes[i]$)。\n\n因此,如果我们所有丑数的有序序列为 $a1,a2,a3,...,an$ 的话,序列中的每一个数都必然能够被以下三个序列(中的至少一个)覆盖(这里假设 $primes = [2,3,5]$):\n\n* 由丑数 * $2$ 所得的有序序列:$1 * 2$、$2 * 2$、$3 * 2$、$4 * 2$、$5 * 2$、$6 * 2$、$8 * 2$ ...\n* 由丑数 * $3$ 所得的有序序列:$1 * 3$、$2 * 3$、$3 * 3$、$4 * 3$、$5 * 3$、$6 * 3$、$8 * 3$ ...\n* 由丑数 * $5$ 所得的有序序列:$1 * 5$、$2 * 5$、$3 * 5$、$4 * 5$、$5 * 5$、$6 * 5$、$8 * 5$ ...\n\n我们令这些有序序列为 $arr$,最终的丑数序列为 $ans$。\n\n如果 $primes$ 的长度为 $m$ 的话,我们可以使用 $m$ 个指针来指向这 $m$ 个有序序列 $arr$ 的当前下标。\n\n显然,我们需要每次取 $m$ 个指针中值最小的一个,然后让指针后移(即将当前序列的下一个值放入堆中),不断重复这个过程,直到我们找到第 $n$ 个丑数。\n\n当然,实现上,我们并不需要构造出这 $m$ 个有序序列。\n\n我们可以构造一个存储三元组的小根堆,三元组信息为 $(val, i, idx)$:\n\n* $val$ :为当前列表指针指向具体值;\n* $i$ :代表这是由 $primes[i]$ 构造出来的有序序列;\n* $idx$:代表丑数下标,存在关系 $val = ans[idx] * primes[i]$。\n\n起始时,我们将所有的 $(primes[i], i, 0)$ 加入优先队列(堆)中,每次从堆中取出最小元素,那么下一个该放入的元素为 $(ans[idx + 1] * primes[i], i, idx + 1)$。\n\n另外,由于我们每个 $arr$ 的指针移动和 $ans$ 的构造,都是单调递增,因此我们可以通过与当前最后一位构造的 $ans[x]$ 进行比较来实现去重,而无须引用常数较大的 `Set` 结构。\n\n代码:\n```Java\nclass Solution {\n    public int nthSuperUglyNumber(int n, int[] primes) {\n        int m = primes.length;\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[0]-b[0]); \n        for (int i = 0; i < m; i++) {\n            q.add(new int[]{primes[i], i, 0});\n        }\n        int[] ans = new int[n];\n        ans[0] = 1;\n        for (int j = 1; j < n; ) {\n            int[] poll = q.poll();\n            int val = poll[0], i = poll[1], idx = poll[2];\n            if (val != ans[j - 1]) ans[j++] = val;\n            q.add(new int[]{ans[idx + 1] * primes[i], i, idx + 1});\n        }\n        return ans[n - 1];\n    }\n}\n```\n* 时间复杂度:需要构造长度为 $n$ 的答案,每次构造需要往堆中取出和放入元素,堆中有 $m$ 个元素,起始时,需要对 $primes$ 进行遍历,复杂度为 $O(m)$。整体复杂度为 $O(\\max(m, n\\log{m}))$\n* 空间复杂度:存储 $n$ 个答案,堆中有 $m$ 个元素,复杂度为 $O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.313` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/311-320/318. 最大单词长度乘积（中等）.md", "url_title": "318. 最大单词长度乘积", "url": "https://leetcode-cn.com/problems/maximum-product-of-word-lengths/solution/gong-shui-san-xie-jian-dan-wei-yun-suan-cqtxq/", "difficulty": "中等", "tags": ["模拟", "位运算", "哈希表"], "question": "给定一个字符串数组 `words`,找到 $length(word[i]) * length(word[j])$ 的最大值,并且这两个单词不含有公共字母。你可以认为每个单词只包含小写字母。如果不存在这样的两个单词,返回 $0$。\n\n 示例 1:\n```\n输入: [\"abcw\",\"baz\",\"foo\",\"bar\",\"xtfn\",\"abcdef\"]\n\n输出: 16 \n\n解释: 这两个单词为 \"abcw\", \"xtfn\"。\n```\n示例 2:\n```\n输入: [\"a\",\"ab\",\"abc\",\"d\",\"cd\",\"bcd\",\"abcd\"]\n\n输出: 4 \n\n解释: 这两个单词为 \"ab\", \"cd\"。\n```\n示例 3:\n```\n输入: [\"a\",\"aa\",\"aaa\",\"aaaa\"]\n\n输出: 0 \n\n解释: 不存在这样的两个单词。\n```\n\n提示:\n* $2 <= words.length <= 1000$\n* $1 <= words[i].length <= 1000$\n* $words[i]$ 仅包含小写字母", "solution": "### 模拟\n\n根据题意进行模拟即可,利用每个 $words[i]$ 只有小写字母,且只需要区分两字符是否有字母重复。\n\n我们可以使用一个 `int` 来代指某个 $word[i]$:低 $26$ 来代指字母 `a-z` 是否出现过。\n\n然后对每个「字符对」所对应的两个 `int` 值执行 `&` 操作(若两字符无重复字符,则结果为 $0$),并得出最终答案。\n\n代码:\n```Java\nclass Solution {\n    public int maxProduct(String[] words) {\n        int n = words.length, idx = 0;\n        int[] masks = new int[n];\n        for (String w : words) {\n            int t = 0;\n            for (int i = 0; i < w.length(); i++) {\n                int u = w.charAt(i) - 'a';\n                t |= (1 << u);\n            }\n            masks[idx++] = t;\n        }\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < i; j++) {\n                if ((masks[i] & masks[j]) == 0) ans = Math.max(ans, words[i].length() * words[j].length());\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为 $words$ 数组的长度,转换出 $masks$ 的复杂度为 $O(\\sum_{i = 0}^{i = n - 1}words[i].length)$;得到答案的复杂度为 $O(n^2)$。整体复杂度为 $O(\\max(\\sum_{i = 0}^{i = n - 1}words[i].length, n^2))$\n* 空间复杂度:$O(n)$\n\n---\n\n### 优化\n\n不难发现,对于词频相同($mask$ 值相等)的两字符,只需要保留字符长度大的即可,因此我们可以使用「哈希表」代替 $masks$ 数组。\n\n代码:\n```Java\nclass Solution {\n    public int maxProduct(String[] words) {\n        Map<Integer, Integer> map = new HashMap<>();\n        for (String w : words) {\n            int t = 0, m = w.length();\n            for (int i = 0; i < m; i++) {\n                int u = w.charAt(i) - 'a';\n                t |= (1 << u);\n            }\n            if (!map.containsKey(t) || map.get(t) < m) map.put(t, m);\n        }\n        int ans = 0;\n        for (int a : map.keySet()) {\n            for (int b : map.keySet()) {\n                if ((a & b) == 0) ans = Math.max(ans, map.get(a) * map.get(b));\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为 $words$ 数组的长度,得到 $map$ 的复杂度为 $O(\\sum_{i = 0}^{i = n - 1}words[i].length)$;得到答案的复杂度为 $O(n^2)$。整体复杂度为 $O(\\max(\\sum_{i = 0}^{i = n - 1}words[i].length, n^2))$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.318` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/311-320/319. 灯泡开关（中等）.md", "url_title": "319. 灯泡开关", "url": "https://leetcode-cn.com/problems/bulb-switcher/solution/gong-shui-san-xie-jing-dian-shu-lun-tui-upnnb/", "difficulty": "中等", "tags": ["数学"], "question": "初始时有 `n` 个灯泡处于关闭状态。第一轮,你将会打开所有灯泡。接下来的第二轮,你将会每两个灯泡关闭一个。\n\n第三轮,你每三个灯泡就切换一个灯泡的开关(即,打开变关闭,关闭变打开)。\n\n第 `i` 轮,你每 `i` 个灯泡就切换一个灯泡的开关。直到第 `n` 轮,你只需要切换最后一个灯泡的开关。\n\n找出并返回 `n` 轮后有多少个亮着的灯泡。\n\n示例 1:\n\n```\n输入:n = 3\n\n输出:1 \n\n解释:\n初始时, 灯泡状态 [关闭, 关闭, 关闭].\n第一轮后, 灯泡状态 [开启, 开启, 开启].\n第二轮后, 灯泡状态 [开启, 关闭, 开启].\n第三轮后, 灯泡状态 [开启, 关闭, 关闭]. \n\n你应该返回 1,因为只有一个灯泡还亮着。\n```\n示例 2:\n```\n输入:n = 0\n\n输出:0\n```\n示例 3:\n```\n输入:n = 1\n\n输出:1\n```\n\n提示:\n* $0 <= n <= 10^9$", "solution": "### 数学\n\n这是一道经典的数论题。\n\n整理一下题意:**第 $i$ 轮改变所有编号为 $i$ 的倍数的灯泡的状态(其中灯泡编号从 $1$ 开始)。**\n\n**一个编号为 $x$ 的灯泡经过 $n$ 轮后处于打开状态的充要条件为「该灯泡被切换状态次数为奇数次」。**\n\n同时,一个灯泡切换状态的次数为其约数的个数(去重)。\n\n于是问题转换为:**在 $[1,n]$ 内有多少个数,其约数的个数为奇数**。这些约数个数为奇数的灯泡就是最后亮着的灯泡。\n\n又根据「约数」的定义,我们知道如果某个数 $k$ 为 $x$ 的约数,那么 $\\frac{x}{k}$ 亦为 $x$ 的约数,即「约数」总是成对出现,那么某个数的约数个数为奇数,意味着某个约数在分解过程中出现了 $2$ 次,且必然重复出现在同一次拆解中,即 $k = \\frac{x}{k}$,即有 $x$ 为完全平方数(反之亦然)。\n\n问题最终转换为:**在 $[1,n]$ 中完全平方数的个数为多少。**\n\n根据数论推论,$[1,n]$ 中完全平方数的个数为 $\\left \\lfloor \\sqrt{n} \\right \\rfloor$,即最后亮着的灯泡数量为 $\\left \\lfloor \\sqrt{n} \\right \\rfloor$。\n\n代码:\n```Java\nclass Solution {\n    public int bulbSwitch(int n) {\n        return (int)Math.sqrt(n);\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.319` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/321-330/322. 零钱兑换（中等）.md", "url_title": "322. 零钱兑换", "url": "https://leetcode-cn.com/problems/coin-change/solution/dong-tai-gui-hua-bei-bao-wen-ti-zhan-zai-3265/", "difficulty": "中等", "tags": ["完全背包", "动态规划", "背包问题"], "question": "给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额,返回 -1。\n\n你可以认为每种硬币的数量是无限的。\n\n示例 1:\n```\n输入:coins = [1, 2, 5], amount = 11\n输出:3 \n解释:11 = 5 + 5 + 1\n```\n示例 2:\n```\n输入:coins = [2], amount = 3\n输出:-1\n```\n示例 3:\n```\n输入:coins = [1], amount = 0\n输出:0\n```\n示例 4:\n```\n输入:coins = [1], amount = 1\n输出:1\n```\n示例 5:\n```\n输入:coins = [1], amount = 2\n输出:2\n```\n\n提示:\n* 1 <= coins.length <= 12\n* 1 <= coins[i] <= $2^{31}$ - 1\n* 0 <= amount <= $10^4$", "solution": "### 完全背包(朴素解法)\n\n硬币相当于我们的物品,每种硬币可以选择「无限次」,我们应该很自然的想到「完全背包」。\n\n如果不能,那么从现在开始就要培养这样的习惯:\n\n**当看到题目是给定一些「物品」,让我们从中进行选择,以达到「最大价值」或者「特定价值」时,我们应该联想到「背包问题」。**\n\n**这本质上其实是一个组合问题:被选物品之间不需要满足特定关系,只需要选择物品,以达到「全局最优」或者「特定状态」即可。**\n\n再根据物品的选择次数限制来判断是何种背包问题。\n\n本题每种硬币可以被选择「无限次」,我们可以直接套用「完全背包」的状态定义进行微调:\n\n**定义 $f[i][j]$ 为考虑前 $i$ 件物品,凑成总和为 $j$ 所需要的最少硬币数量。**\n\n为了方便初始化,我们一般让 $f[0][x]$ 代表不考虑任何物品的情况。\n\n因此我们有显而易见的初始化条件:$f[0][0] = 0$,其余 $f[0][x] = INF$。\n\n代表当没有任何硬币的时候,存在凑成总和为 0 的方案,方案所使用的硬币为 0;凑成其他总和的方案不存在。\n\n由于我们要求的是「最少」硬币数量,因此我们不希望「无效值」参与转移,因此可设 $INF = INT\\_MAX$。\n\n当「状态定义」与「基本初始化」有了之后,我们不失一般性的考虑 $f[i][j]$ 该如何转移。\n\n对于第 $i$ 个硬币我们有两种决策方案:\n\n* 不使用该硬币:\n$$\nf[i - 1][j]\n$$\n\n* 使用该硬币,由于每个硬币可以被选择多次(容量允许的情况下),因此最优解应当是所有方案中的最小值:\n$$\nmin(f[i-1][j-k*coin] + k)\n$$\n\n代码:\n```Java\nclass Solution {\n    int INF = Integer.MAX_VALUE;\n    public int coinChange(int[] cs, int cnt) {\n        int n = cs.length;\n        int[][] f = new int[n + 1][cnt + 1];\n\n        // 初始化(没有任何硬币的情况):只有 f[0][0] = 0;其余情况均为无效值。\n        // 这是由「状态定义」决定的,当不考虑任何硬币的时候,只能凑出总和为 0 的方案,所使用的硬币数量为 0  \n        for (int i = 1; i <= cnt; i++) f[0][i] = INF;\n\n        // 有硬币的情况\n        for (int i = 1; i <= n; i++) {\n            int val = cs[i - 1];\n            for (int j = 0; j <= cnt; j++) {\n                // 不考虑当前硬币的情况\n                f[i][j] = f[i - 1][j];\n\n                // 考虑当前硬币的情况(可选当前硬币个数基于当前容量大小)\n                for (int k = 1; k * val <= j; k++) {\n                    if (f[i - 1][j - k * val] != INF) {\n                        f[i][j] = Math.min(f[i][j], f[i-1][j-k*val] + k);\n                    }\n                }\n            }\n        }\n        return f[n][cnt] == INF ? -1 : f[n][cnt];\n    }\n}\n```\n* 时间复杂度:共有 $n * cnt$ 个状态需要转移,每个状态转移最多遍历 $cnt$ 次。整体复杂度为 $O(n * cnt^2)$。\n* 空间复杂度:$O(n * cnt)$。\n\n***\n\n### 无效状态的定义问题\n\n**借这个问题,刚好说一下,我们初始化时,对于无效状态应该如何定义。**\n\n可以看到上述解法,将 `INF` 定义为 `INT_MAX`。\n\n这是因为我们转移时取的是较小值,我们希望无效值不要被转移,所以将 `INF` 定义为较大的数,以代表数学上的 $+\\infty$ (正无穷)。\n\n这很合理,但是我们需要注意,如果我们在 `INF` 的基础上进行累加的话,常规的语言会将其变成负数最小值。\n\n也就是在正无穷基础上进行累加,会丢失其正无穷的含义,这与数学上的正无穷概念冲突。\n\n因此,我们才有先判断再使用的习惯:\n\n```Java\nif (f[i-1][j] != INF) {\n    f[i][j] = Math.min(f[i][j], f[i-1][j]);\n}\n```\n\n但事实上,如果每次使用都需要有前置检查的话,是很麻烦的。\n\n于是我们有另外一个技巧,不直接使用 `INT_MAX` 作为 `INF`,而是使用一个比 `INT_MAX` 小的较大数来代表 `INF`。\n\n相当于预留了一些「累加空间」给 `INF`。\n\n比如使用 `0x3f3f3f3f` 作为最大值,这样我们使用 `INF` 做状态转移的时候,就不需要先判断再使用了。\n\n代码:\n```Java\nclass Solution {\n    int INF = 0x3f3f3f3f;\n    public int coinChange(int[] cs, int cnt) {\n        int n = cs.length;\n        int[][] f = new int[n + 1][cnt + 1];\n        for (int i = 1; i <= cnt; i++) f[0][i] = INF;\n        for (int i = 1; i <= n; i++) {\n            int val = cs[i - 1];\n            for (int j = 0; j <= cnt; j++) {\n                f[i][j] = f[i-1][j];\n                for (int k = 0; k * val <= j; k++) {\n                        f[i][j] = Math.min(f[i][j], f[i-1][j-k*val] + k);\n                }\n            }\n        }\n        return f[n][cnt] == INF ? -1 : f[n][cnt];\n    }\n}\n```\n\n***\n\n### 完全背包(一维优化)\n\n显然朴素版的完全背包进行求解复杂度有点高。\n\n在[「学习完全背包」](https://mp.weixin.qq.com/s/nke1OjkhKACaONx1opk8AA)和[「上一讲练习」](https://mp.weixin.qq.com/s/zWh9zyIGMd-6fzz-KIQGDw)中,我们从最朴素背包转移方程出发,从数学的角度去推导一维优化是如何来的。\n\n这十分科学,而绝对严谨。\n\n但每次都这样推导是十分耗时的。\n\n因此,我们这次站在一个「更高」的角度去看「完全背包」问题。\n\n我们知道传统的「完全背包」二维状态转移方程是:\n\n$$\nf[i][j] = max(f[i - 1][j], f[i - 1][j - k * w[i]] + k* v[i])\n$$\n\n经过一维空间优化后的状态转移方程是(同时容量维度遍历顺序为「从小到大」):\n\n$$\nf[j] = max(f[j], f[j - w[i]] + v[i])\n$$\n\n这是我们在 [学习完全背包](https://mp.weixin.qq.com/s/nke1OjkhKACaONx1opk8AA) 时推导的,是经过严格证明的,具有一般性的。\n\n然后我们只需要对「成本」&「价值」进行抽象,并结合「换元法」即可得到任意背包问题的一维优化状态转移方程。\n\n拿我们本题的状态转移方程来分析,本题的朴素状态转移方程为:\n\n$$\nf[i][j] = min(f[i - 1][j], f[i-1][j-k*coin] + k)\n$$\n\n我们将硬币的面值抽象为「成本」,硬币的数量抽象「价值」,再对物品维度进行消除,即可得:\n\n$$\nf[j] = min(f[j], f[j-coin] + 1)\n$$\n\n**如果还不理解,可以将上述四个状态转移方程「两两成对」结合来看。**\n\n代码:\n```java []\nclass Solution {\n    int INF = 0x3f3f3f3f;\n    public int coinChange(int[] cs, int cnt) {\n        int n = cs.length;\n        int[] f = new int[cnt + 1];\n        for (int i = 1; i <= cnt; i++) f[i] = INF;\n        for (int i = 1; i <= n; i++) {\n            int val = cs[i - 1];\n            for (int j = val; j <= cnt; j++) {\n                f[j] = Math.min(f[j], f[j - val] + 1);\n            }\n        }\n        return f[cnt] == INF ? -1 : f[cnt];\n    }\n}\n```\n* 时间复杂度:共有 $n * cnt$ 个状态需要转移,整体复杂度为 $O(n * cnt)$。\n* 空间复杂度:$O(cnt)$。\n\n***\n\n### 总结\n\n本节,我们先是从朴素「完全背包」的角度分析并解决了问题。\n\n而在考虑「一维优化」的时候,由于已经有前两节「数学推导优化思路」的基础,我们这次站在了「更高」的角度去看待一维优化。\n\n**从抽象「成本」&「价值」,结合「换元法」的角度去理解一维优化过程。**\n\n这可以大大节省我们分析推导的时间。\n\n建议大家加强理解 ~\n\n下一节练习篇,我们会继续强化这个过程", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.322` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/321-330/324. 摆动排序 II（中等）.md", "url_title": "324. 摆动排序 II", "url": "https://leetcode.cn/problems/wiggle-sort-ii/solution/by-ac_oier-22bq/", "difficulty": "中等", "tags": ["构造", "排序", "快速选择"], "question": "给你一个整数数组 `nums`,将它重新排列成 `nums[0] < nums[1] > nums[2] < nums[3]...` 的顺序。\n\n你可以假设所有输入数组都可以得到满足题目要求的结果。\n\n示例 1:\n```\n输入:nums = [1,5,1,1,6,4]\n\n输出:[1,6,1,5,1,4]\n\n解释:[1,4,1,5,1,6] 同样是符合题目要求的结果,可以被判题程序接受。\n```\n示例 2:\n```\n输入:nums = [1,3,2,2,3,1]\n\n输出:[2,3,1,3,1,2]\n```\n\n提示:\n* $1 <= nums.length <= 5 \\times 10^4$\n* $0 <= nums[i] <= 5000$\n* 题目数据保证,对于给定的输入 `nums`,总能产生满足题目要求的结果\n\n进阶:你能用 $O(n)$ 时间复杂度和 / 或原地 $O(1)$ 额外空间来实现吗?", "solution": "### 构造(快选 + 三数排序)\n\n这道题即使不考虑空间 $O(1)$ 的进阶要求,只要求做到 $O(n)$ 时间的话,在 LC 上也属于难题了。如果大家是第一次做,并且希望在有限时间(不超过 $20$ 分钟)内做出来,可以说是难上加难。\n\n本质上,题目要我们实现一种构造方法,能够将 `nums` 调整为满足「摆动」要求。\n\n具体的构造方法:\n\n1. 找到 `nums` 的中位数,这一步可以通过「快速选择」算法来做,时间复杂度为 $O(n)$,空间复杂度为 $O(\\log{n})$,假设找到的中位数为 `x`;\n\n2. 根据 $nums[i]$ 与 `x` 的大小关系,将 $nums[i]$ 分为三类(小于/等于/大于),划分三类的操作可以采用「三数排序」的做法,复杂度为 $O(n)$。\n\n   这一步做完之后,我们的数组调整为:$[a_1, a_2, a_3, ... , b_1, b_2, b_3, ... , c_1, c_2, c_3]$ ,即分成「小于 `x` / 等于 `x` / 大于 `x`」三段。\n\n3. 构造:先放「奇数」下标,再放「偶数」下标,放置方向都是「从左到右」(即可下标从小到大进行放置),放置的值是则是「从大到小」。\n\n   到这一步之前,我们使用到的空间上界是 $O(\\log{n})$,如果对空间上界没有要求的话,我们可以简单对 `nums` 进行拷贝,然后按照对应逻辑进行放置即可,但这样最终的空间复杂度为 $O(n)$(代码见 $P2$);如果不希望影响到原有的空间上界,我们需要额外通过「找规律/数学」的方式,找到原下标和目标下标的映射关系(函数 `getIdx` 中)。\n\n容易证明该构造过程的正确性(即该构造过程必然能顺利进行):由于我们是按照值「从大到小」进行放置,如果构造出来的方案不合法,必然是相邻的两个值为相等(“应当递增实际递减”或者“应当递减实际递增”的情况已被「从大到小」进行放置所否决),而当相邻位置放置了相同的值,即存在某个奇数下标,以及其相邻的偶数下标都放置了相同的值,这等价于该值出现次数超过总个数的一半,这与「题目本身保证数据能够构造出摆动数组」所冲突。\n\n代码:\n```Java\nclass Solution {\n    int[] nums;\n    int n;\n    int qselect(int l, int r, int k) {\n        if (l == r) return nums[l];\n        int x = nums[l + r >> 1], i = l - 1, j = r + 1;\n        while (i < j) {\n            do i++; while (nums[i] < x);\n            do j--; while (nums[j] > x);\n            if (i < j) swap(i, j);\n        }\n        int cnt = j - l + 1;\n        if (k <= cnt) return qselect(l, j, k);\n        else return qselect(j + 1, r, k - cnt);\n    }\n    void swap(int a, int b) {\n        int c = nums[a];\n        nums[a] = nums[b];\n        nums[b] = c;\n    }\n    int getIdx(int x) {\n        return (2 * x + 1) % (n | 1);\n    }\n    public void wiggleSort(int[] _nums) {\n        nums = _nums;\n        n = nums.length;\n        int x = qselect(0, n - 1, n + 1 >> 1);\n        int l = 0, r = n - 1, loc = 0;\n        while (loc <= r) {\n            if (nums[getIdx(loc)] > x) swap(getIdx(loc++), getIdx(l++));\n            else if (nums[getIdx(loc)] < x) swap(getIdx(loc), getIdx(r--));\n            else loc++;\n        }\n    }\n}\n```\n\n-\n\n```Java\nclass Solution {\n    int[] nums;\n    int n;\n    int qselect(int l, int r, int k) {\n        if (l == r) return nums[l];\n        int x = nums[l + r >> 1], i = l - 1, j = r + 1;\n        while (i < j) {\n            do i++; while (nums[i] < x);\n            do j--; while (nums[j] > x);\n            if (i < j) swap(i, j);\n        }\n        int cnt = j - l + 1;\n        if (k <= cnt) return qselect(l, j, k);\n        else return qselect(j + 1, r, k - cnt);\n    }\n    void swap(int a, int b) {\n        int c = nums[a];\n        nums[a] = nums[b];\n        nums[b] = c;\n    }\n    public void wiggleSort(int[] _nums) {\n        nums = _nums;\n        n = nums.length;\n        int x = qselect(0, n - 1, n + 1 >> 1);\n        int l = 0, r = n - 1, loc = 0;\n        while (loc <= r) {\n            if (nums[loc] < x) swap(loc++, l++);\n            else if (nums[loc] > x) swap(loc, r--);\n            else loc++;\n        }\n        int[] clone = nums.clone();\n        int idx = 1; loc = n - 1;\n        while (idx < n) {\n            nums[idx] = clone[loc--];\n            idx += 2;\n        }\n        idx = 0;\n        while (idx < n) {\n            nums[idx] = clone[loc--];\n            idx += 2;\n        }\n    }\n}\n```\n* 时间复杂度:快选的时间复杂度为 $O(n)$;三数排序复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:我的习惯是不算递归带来的额外空间消耗的,但如果是题目指定 $O(1)$ 空间的话,显然是不能按照习惯来,快选的空间复杂度为 $O(\\log{n})$。整体复杂度为 $O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.324` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/321-330/326. 3的幂（简单）.md", "url_title": "326. 3的幂", "url": "https://leetcode-cn.com/problems/power-of-three/solution/gong-shui-san-xie-yi-ti-san-jie-shu-xue-8oiip/", "difficulty": "简单", "tags": ["数学", "打表"], "question": "给定一个整数,写一个函数来判断它是否是 $3$ 的幂次方。如果是,返回 $true$ ;否则,返回 $false$ 。\n\n整数 $n$ 是 $3$ 的幂次方需满足:存在整数 $x$ 使得 $n == 3^x$\n\n示例 1:\n```\n输入:n = 27\n\n输出:true\n```\n示例 2:\n```\n输入:n = 0\n\n输出:false\n```\n示例 3:\n```\n输入:n = 9\n\n输出:true\n```\n示例 4:\n```\n输入:n = 45\n\n输出:false\n```\n\n提示:\n* -$2^{31}$ <= n <= $2^{31}$ - 1", "solution": "### 数学\n\n一个不能再朴素的做法是将 $n$ 对 $3$ 进行试除,直到 $n$ 不再与 $3$ 呈倍数关系,最后判断 $n$ 是否为 $3^0 = 1$ 即可。\n\n代码:\n```Java\nclass Solution {\n    public boolean isPowerOfThree(int n) {\n        if (n <= 0) return false;\n        while (n % 3 == 0) n /= 3;\n        return n == 1;\n    }\n}\n```\n* 时间复杂度:$O(\\log_{3}n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 倍数 & 约数\n\n题目要求不能使用循环或递归来做,而传参 $n$ 的数据类型为 `int`,这引导我们首先分析出 `int` 范围内的最大 $3$ 次幂是多少,约为 $3^{19} = 1162261467$。\n\n如果 $n$ 为 $3$ 的幂的话,那么必然满足 $n * 3^k = 1162261467$,即 $n$ 与 $1162261467$ 存在倍数关系。\n\n因此,我们只需要判断 $n$ 是否为 $1162261467$ 的约数即可。\n\n> 注意:这并不是快速判断 $x$ 的幂的通用做法,当且仅当 $x$ 为质数可用。\n\n代码:\n```Java\nclass Solution {\n    public boolean isPowerOfThree(int n) {\n        return n > 0 && 1162261467 % n == 0;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 打表\n\n另外一个更容易想到的「不使用循环/递归」的做法是进行打表预处理。\n\n使用 `static` 代码块,预处理出不超过 `int` 数据范围的所有 $3$ 的幂,这样我们在跑测试样例时,就不需要使用「循环/递归」来实现逻辑,可直接 $O(1)$ 查表返回。\n\n代码:\n```Java\nclass Solution {\n    static Set<Integer> set = new HashSet<>();\n    static {\n        int cur = 1;\n        set.add(cur);\n        while (cur <= Integer.MAX_VALUE / 3) {\n            cur *= 3;\n            set.add(cur);\n        }\n    }\n    public boolean isPowerOfThree(int n) {\n        return n > 0 && set.contains(n);\n    }\n}\n```\n* 时间复杂度:将打表逻辑交给 $OJ$ 执行的话,复杂度为 $O(\\log_3{C})$,$C$ 固定为 $2147483647$;将打表逻辑放到本地执行,复杂度为 $O(1)$\n* 空间复杂度:$O(\\log_3{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.326` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/321-330/327. 区间和的个数（困难）.md", "url_title": "327. 区间和的个数", "url": "https://leetcode.cn/problems/count-of-range-sum/solution/by-ac_oier-b36o/", "difficulty": "困难", "tags": ["前缀和", "离散化", "树状数组", "线段树(动态开点)"], "question": "给你一个整数数组 `nums` 以及两个整数 `lower` 和 `upper` 。求数组中,值位于范围 $[lower, upper]$ (包含 `lower` 和 `upper`)之内的 区间和的个数 。\n\n区间和 $S(i, j)$ 表示在 `nums` 中,位置从 $i$ 到 $j$ 的元素之和,包含 $i$ 和 $j$ (`i ≤ j`)。\n\n示例 1:\n```\n输入:nums = [-2,5,-1], lower = -2, upper = 2\n\n输出:3\n\n解释:存在三个区间:[0,0]、[2,2] 和 [0,2] ,对应的区间和分别是:-2 、-1 、2 。\n```\n示例 2:\n```\n输入:nums = [0], lower = 0, upper = 0\n\n输出:1\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $-2^{31} <= nums[i] <= 2^{31} - 1$\n* $-10^5 <= lower <= upper <= 10^5$\n* 题目数据保证答案是一个 $32$ 位 的整数", "solution": "### 树状数组(离散化)\n\n由于区间和的定义是子数组的元素和,容易想到「前缀和」来快速求解。\n\n对于每个 $nums[i]$ 而言,我们需要统计以每个 $nums[i]$ 为右端点的合法子数组个数(合法子数组是指区间和值范围为 $[lower, upper]$ 的子数组)。\n\n我们可以从前往后处理 $nums$,假设当前我们处理到位置 $k$,同时下标 $[0, k]$ 的前缀和为 $s$,那么以 $nums[k]$ 为右端点的合法子数组个数,等价于在下标 $[0, k - 1]$ 中前缀和范围在 $[s - upper, s - lower]$ 的数的个数。\n\n我们需要使用一个数据结构来维护「遍历过程中的前缀和」,每遍历 $nums[i]$ 需要往数据结构加一个数,同时每次需要查询值在某个范围内的数的个数。涉及的操作包括「单点修改」和「区间查询」,容易想到使用树状数组进行求解。\n\n但值域的范围是巨大的(同时还有负数域),我们可以利用 $nums$ 的长度为 $10^5$ 来做离散化。我们需要考虑用到的数组都有哪些:\n\n1. 首先前缀和数组中的每一位 $s$ 都需要被用到(添加到树状数组中);\n2. 同时对于每一位 $nums[i]$(假设对应的前缀和为 $s$),我们都需要查询以其为右端点的合法子数组个数,即查询前缀和范围在 $[s - upper, s - lower]$ 的数的个数。\n\n因此对于前缀和数组中的每一位  $s$,我们用到的数有 $s$、$s - upper$ 和 $s - lower$ 三个数字,共有 $1e5$ 个 $s$,即最多共有 $3 \\times 10^5$ 个不同数字被使用,我们可以对所有用到的数组进行排序编号(离散化),从而将值域大小控制在 $3 \\times 10^5$ 范围内。\n\n 代码:\n```Java\nclass Solution {\n    int m;\n    int[] tr = new int[100010 * 3];\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void add(int x, int v) {\n        for (int i = x; i <= m; i += lowbit(i)) tr[i] += v;\n    }\n    int query(int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];\n        return ans;\n    }\n    public int countRangeSum(int[] nums, int lower, int upper) {\n        Set<Long> set = new HashSet<>();\n        long s = 0;\n        set.add(s);\n        for (int i : nums) {\n            s += i;\n            set.add(s);\n            set.add(s - lower);\n            set.add(s - upper);\n        }\n        List<Long> list = new ArrayList<>(set);\n        Collections.sort(list);\n        Map<Long, Integer> map = new HashMap<>();\n        for (long x : list) map.put(x, ++m);\n        s = 0;\n        int ans = 0;\n        add(map.get(s), 1);\n        for (int i : nums) {\n            s += i;\n            int a = map.get(s - lower), b = map.get(s - upper) - 1;\n            ans += query(a) - query(b);\n            add(map.get(s), 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:去重离散化的复杂度为 $O(n\\log{n})$;统计答案的复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 线段树(动态开点 + STL)\n\n值域范围爆炸,但是数组长度(查询次数)有限,容易想到「线段树(动态开点)」。\n\n但如果按照我们 [729. 我的日程安排表 I](https://sharingsource.github.io/2022/05/04/729.%20%E6%88%91%E7%9A%84%E6%97%A5%E7%A8%8B%E5%AE%89%E6%8E%92%E8%A1%A8%20I%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/)、[731. 我的日程安排表 II](https://sharingsource.github.io/2022/05/04/731.%20%E6%88%91%E7%9A%84%E6%97%A5%E7%A8%8B%E5%AE%89%E6%8E%92%E8%A1%A8%20II%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/) 和 [732. 我的日程安排表 III](https://sharingsource.github.io/2022/05/04/732.%20%E6%88%91%E7%9A%84%E6%97%A5%E7%A8%8B%E5%AE%89%E6%8E%92%E8%A1%A8%20III%EF%BC%88%E5%9B%B0%E9%9A%BE%EF%BC%89/) 系列题解的求解方式「估点 + 静态数组 + 动态 `new`」,仍无法解决 `MLE`  问题。\n\n究其原因,我们在 [日程安排表] 系列中使用到的方式存在「固定双边开点(一旦要对 $u$ 的子节点开点,会同时将左右子节点都开出来)」以及「查询时也会触发开点」的问题,导致我们最多处理值域范围在 $1e9$ 的情况。\n\n对于本题的值域范围远超 $1e9$,我们需要考虑修「静态数组」和「开点方式」来解决 `MLE`  问题:\n\n1. 由于值域太大,采用估点方式来开精挑数组会直接导致 `MLE`,我们使用支持扩容的 `STL` 容器;\n2. 由于同时开点和查询也会触发开点,会导致我们不必要的空间浪费,我们直接将开点操作放在 `update` 实现中,并且只有当需要查询到左子节点才对左子节点进行开点,当查询到右子节点才对右子节点进行开点。\n\n 代码:\n```Java \nclass Solution {\n    class Node {\n        int ls = -1, rs = -1, val = 0;\n    }\n    List<Node> tr = new ArrayList<>();\n    void update(int u, long lc, long rc, long x, int v) {\n        Node node = tr.get(u);\n        node.val += v;\n        if (lc == rc) return ;\n        long mid = lc + rc >> 1;\n        if (x <= mid) {\n            if (node.ls == -1) {\n                tr.add(new Node());\n                node.ls = tr.size() - 1;\n            }\n            update(node.ls, lc, mid, x, v);\n        } else {\n            if (node.rs == -1) {\n                tr.add(new Node());\n                node.rs = tr.size() - 1;\n            }\n            update(node.rs, mid + 1, rc, x, v);\n        }\n    }\n    int query(int u, long lc, long rc, long l, long r) {\n        if (u == -1) return 0;\n        if (r < lc || l > rc) return 0;\n        Node node = tr.get(u);\n        if (l <= lc && rc <= r) return node.val;\n        long mid = lc + rc >> 1;\n        return query(node.ls, lc, mid, l, r) + query(node.rs, mid + 1, rc, l, r);\n    }\n    public int countRangeSum(int[] nums, int lower, int upper) {\n        long L = 0, R = 0, s = 0;\n        for (int i : nums) {\n            s += i;\n            L = Math.min(Math.min(L, s), Math.min(s - lower, s - upper));\n            R = Math.max(Math.max(R, s), Math.max(s - lower, s - upper));\n        }\n        s = 0;\n        int ans = 0;\n        tr.add(new Node());\n        update(0, L, R, 0, 1);\n        for (int i : nums) {\n            s += i;\n            long a = s - upper, b = s - lower;\n            ans += query(0, L, R, a, b);\n            update(0, L, R, s, 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为数组长度,$m$ 为值域大小,复杂度为 $O(n\\log{m})$\n* 空间复杂度:$O(n\\log{m})$\n\n---\n\n### 线段树(动态指针)\n\n更进一步,我们可以连 `STL` 都不使用,直接在 `Node` 的定义时,将左右子节点的引用存放起来。\n\n虽然这样不会带来空间上的优化,但可以有效避免 `STL` 的创建、访问和扩容(实际运行相比解法二,用时少一半)。\n\n代码:\n```Java \nclass Solution {\n    class Node {\n        Node ls, rs;\n        int val = 0;\n    }\n    void update(Node node, long lc, long rc, long x, int v) {\n        node.val += v;\n        if (lc == rc) return ;\n        long mid = lc + rc >> 1;\n        if (x <= mid) {\n            if (node.ls == null) node.ls = new Node();\n            update(node.ls, lc, mid, x, v);\n        } else {\n            if (node.rs == null) node.rs = new Node();\n            update(node.rs, mid + 1, rc, x, v);\n        }\n    }\n    int query(Node node, long lc, long rc, long l, long r) {\n        if (node == null) return 0;\n        if (r < lc || l > rc) return 0;\n        if (l <= lc && rc <= r) return node.val;\n        long mid = lc + rc >> 1;\n        return query(node.ls, lc, mid, l, r) + query(node.rs, mid + 1, rc, l, r);\n    }\n    public int countRangeSum(int[] nums, int lower, int upper) {\n        long L = 0, R = 0, s = 0;\n        for (int i : nums) {\n            s += i;\n            L = Math.min(Math.min(L, s), Math.min(s - lower, s - upper));\n            R = Math.max(Math.max(R, s), Math.max(s - lower, s - upper));\n        }\n        s = 0;\n        int ans = 0;\n        Node root = new Node();\n        update(root, L, R, 0, 1);\n        for (int i : nums) {\n            s += i;\n            long a = s - upper, b = s - lower;\n            ans += query(root, L, R, a, b);\n            update(root, L, R, s, 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为数组长度,$m$ 为值域大小,复杂度为 $O(n\\log{m})$\n* 空间复杂度:$O(n\\log{m})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.327` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/331-340/331. 验证二叉树的前序序列化（中等）.md", "url_title": "331. 验证二叉树的前序序列化", "url": "https://leetcode-cn.com/problems/verify-preorder-serialization-of-a-binary-tree/solution/xiang-xin-ke-xue-xi-lie-xiang-jie-zhi-gu-e3y9/", "difficulty": "中等", "tags": ["二叉树"], "question": "序列化二叉树的一种方法是使用前序遍历。当我们遇到一个非空节点时,我们可以记录下这个节点的值。如果它是一个空节点,我们可以使用一个标记值记录,例如 #。\n```\n     _9_\n    /   \\\n   3     2\n  / \\   / \\\n 4   1  #  6\n/ \\ / \\   / \\\n# # # #   # #\n```\n例如,上面的二叉树可以被序列化为字符串 \"9,3,4,#,#,1,#,#,2,#,6,#,#\",其中 # 代表一个空节点。\n\n给定一串以逗号分隔的序列,验证它是否是正确的二叉树的前序序列化。编写一个在不重构树的条件下的可行算法。\n\n每个以逗号分隔的字符或为一个整数或为一个表示 null 指针的 '#' 。\n\n你可以认为输入格式总是有效的,例如它永远不会包含两个连续的逗号,比如 \"1,,3\" 。\n\n示例 1:\n```\n输入: \"9,3,4,#,#,1,#,#,2,#,6,#,#\"\n输出: true\n```\n示例 2:\n```\n输入: \"1,#\"\n输出: false\n```\n示例 3:\n```\n输入: \"9,#,#,1\"\n输出: false\n```", "solution": "### 二叉树规律解法\n\n事实上,我们能利用「二叉树」的特性来做。\n\n由于**每一个非空节点都对应了 2 个出度,空节点都对应了 0 个出度;除了根节点,每个节点都有一个入度。**\n\n我们可以使用 `in` 和 `out` 来分别记录「入度」和「出度」的数量;`m` 和 `n` 分别代表「非空节点数量」和「空节点数量」。\n\n同时,一颗合格的二叉树最终结果必然满足 `in == out`。\n\n**但我们又不能只利用最终 `in == out` 来判断是否合法,这很容易可以举出反例:考虑将一个合法序列的空节点全部提前,这样最终结果仍然满足 `in == out`,但这样的二叉树是不存在的。**\n\n**我们还需要一些额外的特性,支持我们在遍历过程中提前知道一颗二叉树不合法。**\n\n**例如,我们可以从合格二叉树的前提出发,挖掘遍历过程中 `in` 和 `out` 与 `n` 和 `m` 的关系。**\n\n***\n\n### 证明 1(利用不等式)\n\n我们令非空节点数量为 $m$,空节点数量为 $n$,入度和出度仍然使用 $in$ 和 $out$ 代表。\n\n找一下 $in$ 和 $out$ 与 $n$ 和 $m$ 之间的关系。\n\n一颗合格二叉树 $m$ 和 $n$ 的最小的比例关系是 $1 : 2$,也就是对应了这么一个形状:\n\n```\n 4 \n/ \\\n# #\n```\n\n而遍历过程中 $m$ 和 $n$ 的最小的比例关系则是 $1 : 0$,**这其实对应了二叉树空节点总是跟在非空节点的后面这一性质。**\n\n换句话说,在没到最后一个节点之前,我们是不会遇到 空节点数量 > 非空节点数量 的情况的。\n\n**`非空节点数量 >= 空节点数量` 在遍历没结束前恒成立:$m>=n$**\n\n然后再结合「**每一个非空节点都对应了 $2$ 个出度,空节点都对应了 $0$ 个出度;除了根节点,每个节点都有一个入度**」特性。\n\n在遍历尚未结束前,我们有以下关系:\n\n1. $m >= n$\n2. $in <= m + n - 1$\n3. $out <= 2 * m$\n\n简单的变形可得:\n\n* 由 $2$ 变形可得:$m >= in + 1 - n$\n* 由 $3$ 变形可得:$m >= out / 2$\n\n即有:\n1. $m >= n$\n2. $m >= in + 1 - n$\n3. $m >= out / 2$\n\n再将 $1$ 和 $2$ 相加,抵消 $n$:$2m >= in + 1$\n1. $2m >= in + 1$ => $in <= 2m - 1$\n2. $m >= out / 2$ => $out <= 2m$\n\n因此,在遍历尚未完成时,$in$ 和 $out$ 始终满足上述关系(与空节点数量 $n$ 无关)。\n\n如果不从合格二叉树的前提($m>=n$)出发,我们是无法得到上述关系式的。\n\n**因此,我们可以一边遍历一边统计「严格出度」和「严格入度」,然后写一个 `check` 函数去判定 $in$、$out$ 和 $m$ 三者关系是否符合要求,如果不符合则说明二叉树不合法。**\n\n代码:\n```Java\nclass Solution {\n  public boolean isValidSerialization(String s) {\n    String[] ss = s.split(\",\");\n    int n = ss.length;\n    int in = 0, out = 0;\n    for (int i = 0, m = 0; i < n; i++) {\n      // 统计「严格出度」和「严格入度」...\n      if (i != n - 1 && !check(m, in, out)) return false;\n    } \n    return in == out;\n  }\n  boolean check(int m, int in, int out) {\n    boolean a = (in <= 2 * m - 1), b = (out <= 2 * m);\n    return a && b; \n  }\n}\n```\n\n**注意:因为我们这里的证明使用到的是不等式。因此统计的必须是「严格出度」&「严格入度」,不能假定一个「非空节点(非根)」必然对应两个「出度」和一个「入度」。**\n\n**要想统计出「严格出度」&「严格入度」在编码上还是有一定难度的。那么是否可以推导出更加简单性质来使用呢?**\n\n**请看「证明 2」。**\n\n***\n\n### 证明 2(利用技巧转换为等式)\n\n我们令非空节点数量为 $m$,空节点数量为 $n$,入度和出度仍然使用 $in$ 和 $out$ 代表。\n\n找一下 $in$ 和 $out$ 与 $n$ 和 $m$ 之间的关系。\n\n一颗合格二叉树 $m$ 和 $n$ 的最小的比例关系是 $1 : 2$,也就是对应了这么一个形状:\n```\n 4 \n/ \\\n# #\n```\n而遍历过程中 $m$ 和 $n$ 的最小的比例关系则是 $1 : 0$,这**其实对应了二叉树空节点总是跟在非空节点的后面这一性质。**\n\n换句话说,在没到最后一个节点之前,我们是不会遇到 `空节点数量 > 非空节点数量` 的情况的。\n\n**`非空节点数量 >= 空节点数量` 在遍历没结束前恒成立:$m>=n$**\n\n之后我们再采用一个技巧,就是**遍历过程中每遇到一个「非空节点」就增加两个「出度」和一个「入度」,每遇到一个「空节点」只增加一个「入度」。而不管每个「非空节点」是否真实对应两个子节点。**\n\n那么我们的起始条件变成:\n\n1. $m >= n$\n2. $in = m + n - 1$\n3. $out = 2 * m$\n\n从第 $2$ 个等式出发,结合第 $1$ 个等式:\n\n$in = m + n - 1 <= m + m - 1 = 2m - 1 = out - 1$\n\n即可得 $in + 1 <= out$ ,也就是 $in < out$ 恒成立。\n\n代码:\n```Java\nclass Solution {\n    public boolean isValidSerialization(String s) {\n        String[] ss = s.split(\",\");\n        int n = ss.length;\n        int in = 0, out = 0;\n        for (int i = 0; i < n; i++) {\n            if (!ss[i].equals(\"#\")) out += 2;\n            if (i != 0) in++;\n            if (i != n - 1 && out <= in) return false;\n        } \n        return in == out;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.331` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/331-340/334. 递增的三元子序列（中等）.md", "url_title": "334. 递增的三元子序列", "url": "https://leetcode-cn.com/problems/increasing-triplet-subsequence/solution/gong-shui-san-xie-zui-chang-shang-sheng-xa08h/", "difficulty": "中等", "tags": ["LIS", "最长上升子序列", "贪心", "二分"], "question": "给你一个整数数组 `nums`,判断这个数组中是否存在长度为 $3$ 的递增子序列。\n\n如果存在这样的三元组下标 `(i, j, k)` 且满足 `i < j < k` ,使得 `nums[i] < nums[j] < nums[k]` ,返回 `true` ;否则,返回 `false`。\n\n示例 1:\n```\n输入:nums = [1,2,3,4,5]\n\n输出:true\n\n解释:任何 i < j < k 的三元组都满足题意\n```\n示例 2:\n```\n输入:nums = [5,4,3,2,1]\n\n输出:false\n\n解释:不存在满足题意的三元组\n```\n示例 3:\n```\n输入:nums = [2,1,5,0,4,6]\n\n输出:true\n\n解释:三元组 (3, 4, 5) 满足题意,因为 nums[3] == 0 < nums[4] == 4 < nums[5] == 6\n```\n\n提示:\n* $1 <= nums.length <= 5 * 10^5$\n* $-2^{31} <= nums[i] <= 2^{31} - 1$\n\n进阶:你能实现时间复杂度为 $O(n$) ,空间复杂度为 $O(1)$ 的解决方案吗?", "solution": "### 最长上升子序列(贪心 + 二分)\n\n题目要我们判断是否存在长度为 $3$ 的上升子序列,问题可以转换为求 $nums$ 的最长上升子序列(`LIS` 问题)的长度。\n\n如果 $nums$ 的最长上升子序列长度大于等于 $3$,那么原问题答案为 `True`,否则为 `False`。\n\n而求最长上升子序列的最优解是有基于「贪心 + 二分」的 $O(n\\log{n})$ 做法,对此不了解的同学,可以先看前置 🧀 :[LCS 问题与 LIS 问题的相互关系,以及 LIS 问题的最优解证明](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487814&idx=1&sn=e33023c2d474ff75af83eda1c4d01892&chksm=fd9cba59caeb334f1fbfa1aefd3d9b2ab6abfccfcab8cb1dbff93191ae9b787e1b4681bbbde3&token=252055586&lang=zh_CN#rd),里面详细讲解了 `LIS` 的贪心解证明,以及与最长公共子序列(`LCS` 问题)的相互关系,本次不再赘述。\n\n**简单来说,就是在遍历每个数 $nums[i]$ 的同时,维护一个具有单调性的 $f[]$ 数组,其中 $f[len] = x$ 代表长度为 $len$ 的最长上升子序列最小结尾元素为 $x$,可以证明 $f$ 数组具有单调性(看 [前置🧀](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487814&idx=1&sn=e33023c2d474ff75af83eda1c4d01892&chksm=fd9cba59caeb334f1fbfa1aefd3d9b2ab6abfccfcab8cb1dbff93191ae9b787e1b4681bbbde3&token=252055586&lang=zh_CN#rd)),因此每次可以通过二分找到小于 $nums[i]$ 的最大下标,来作为 $nums[i]$ 的前一个数。**\n\n综上,我们使用 `LIS` 的「贪心 + 二分」做法求得最长上升子序列的最大长度,然后和 $3$ 比较即可得出答案。\n\n**代码(感谢 [@🍭可乐可乐吗QAQ](/u/littletime_cc/) 同学提供的其他语言版本):**\n```Java\nclass Solution {\n    public boolean increasingTriplet(int[] nums) {\n        int n = nums.length, ans = 1;\n        int[] f = new int[n + 1];\n        Arrays.fill(f, 0x3f3f3f3f);\n        for (int i = 0; i < n; i++) {\n            int t = nums[i];\n            int l = 1, r = i + 1;\n            while (l < r) {\n                int mid = l + r >> 1;\n                if (f[mid] >= t) r = mid;\n                else l = mid + 1;\n            }\n            f[r] = t;\n            ans = Math.max(ans, r);\n        }\n        return ans >= 3;\n    }\n}\n```\n-\n```C++\nclass Solution {\npublic:\n    bool increasingTriplet(vector<int>& nums) {\n        int n = nums.size(), ans = 1;\n        vector<int> f(n + 1, INT_MAX);\n        for(int i = 0; i < n; i++){\n            int t = nums[i];\n            int L = 1, R = i + 1;\n            while(L < R){\n                int mid = L + R >> 1;\n                if(f[mid] >= t) R = mid;\n                else L = mid + 1;\n            }\n            f[R] = t;\n            ans = max(ans, R);\n        }\n        return ans >= 3;\n    }\n};\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 优化 : 定长上升子序列(贪心)\n\n利用本题只需要我们判定是否存在长度为 $3$ 的上升子序列,而不需要回答 `LIS` 最大长度。\n\n我们可以对 $f$ 数组进行优化:**使用有限变量进行替换(将 $f$ 数组的长度压缩为 $2$),数组含义不变,$f[1] = x$ 代表长度为 $1$ 的上升子序列最小结尾元素为 $x$,$f[2] = y$ 代表长度为 $2$ 的上升子序列的最小结尾元素为 $y$。**\n\n**从前往后扫描每个 $nums[i]$,每次将 $nums[i]$ 分别与 $f[1]$ 和 $f[2]$ 进行比较,如果能够满足 $nums[i] > f[2]$,代表 $nums[i]$ 能够接在长度为 $2$ 的上升子序列的后面,直接返回 `True`,否则尝试使用 $nums[i]$ 来更新 $f[1]$ 和 $f[2]。$**\n\n这样,我们只使用了有限变量,每次处理 $nums[i]$ 只需要和有限变量进行比较,时间复杂度为 $O(n)$,空间复杂度为 $O(1)$。\n\n**代码(感谢 [@🍭可乐可乐吗QAQ](/u/littletime_cc/) 和 [@Benhao](/u/himymben/) 同学提供的其他语言版本):**\n```Java\nclass Solution {\n    public boolean increasingTriplet(int[] nums) {\n        int n = nums.length;\n        long[] f = new long[3];\n        f[1] = f[2] = (int)1e19;\n        for (int i = 0; i < n; i++) {\n            int t = nums[i];\n            if (f[2] < t) return true;\n            else if (f[1] < t && t < f[2]) f[2] = t;\n            else if (f[1] > t) f[1] = t;\n        }\n        return false;\n    }\n}\n```\n-\n```Python\nclass Solution:\n    def increasingTriplet(self, nums: List[int]) -> bool:\n        n = len(nums)\n        f = [inf] * 3\n        for i in range(n):\n            t = nums[i]\n            if f[2] < t:\n                return True\n            elif f[1] < t < f[2]:\n                f[2] = t\n            elif f[1] > t:\n                f[1] = t\n        return False\n```\n-\n```Go\nfunc increasingTriplet(nums []int) bool {\n    n := len(nums)\n    f := []int{math.MaxInt32,math.MaxInt32,math.MaxInt32}\n    for i := 0; i < n; i++ {\n        t := nums[i]\n        if f[2] < t{\n            return true\n        } else if f[1] < t && t < f[2]{\n            f[2] = t\n        } else if f[1] > t {\n            f[1] = t\n        }\n    }\n    return false\n}\n```\n-\n```C++\nclass Solution {\npublic:\n    bool increasingTriplet(vector<int>& nums) {\n        int n = nums.size();\n        vector<int> f(3, INT_MAX);\n        for(int i = 0; i < n; i++){\n            int t = nums[i];\n            if(f[2] < t) return true;\n            else if(f[1] < t and t < f[2]) f[2] = t;\n            else if(f[1] > t) f[1] = t;\n        }\n        return false;\n    }\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.334` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/331-340/335. 路径交叉（困难）.md", "url_title": "335. 路径交叉", "url": "https://leetcode-cn.com/problems/self-crossing/solution/gong-shui-san-xie-fen-qing-kuang-tao-lun-zdrb/", "difficulty": "困难", "tags": ["找规律", "脑筋急转弯", "模拟"], "question": "给你一个整数数组 `distance` 。\n\n从 `X-Y` 平面上的点 $(0,0)$ 开始,先向北移动 `distance[0]` 米,然后向西移动 `distance[1]` 米,向南移动 `distance[2]` 米,向东移动 `distance[3]` 米,持续移动。也就是说,每次移动后你的方位会发生逆时针变化。\n\n判断你所经过的路径是否相交。如果相交,返回 `true` ;否则,返回 `false`。\n\n示例 1:\n\n```\n输入:distance = [2,1,1,2]\n\n输出:true\n```\n示例 2:\n\n```\n输入:distance = [1,2,3,4]\n\n输出:false\n```\n示例 3:\n\n```\n输入:distance = [1,1,1,1]\n\n输出:true\n```\n\n提示:\n* $1 <= distance.length <= 10^5$\n* $1 <= distance[i] <= 10^5$", "solution": "### 找规律 + 分情况讨论\n\n这是一道画图找规律的题目。\n\n**首先显然的是,至少需要 $4$ 条边才 可能 存在相交路径,如果 $distance$ 的长度小于 $4$,可直接返回 `False`,同时这引导我们如果某条边 $distance[i]$ 发生相交,不可能是与 $distance[i - 1]$ 或 $distance[i - 2]$ 之间发生的(基于条件 $1 <= distance[i] <= 10^5$)。**\n\n为了方便,我们分别使用 $a$、$b$、$c$ 和 $d$ 来分别代指「往上」、「往左」、「往下」和「往右」的四类方向边。\n\n然后对可能相交情况进行分情况讨论,假设当前枚举到的边为 $distance[i]$(下面使用 $d[i]$ 代指 $distance[i]$):\n\n1. $d[i]$ 与 $d[i - 3]$ 发生相交:此时满足 $d[i] >= d[i - 2]$,同时 $d[i - 1] <= d[i - 3]$; \n\n> **需要注意的时候 $d[i]$ 不一定是 $d$ 类边,而可以是 $abcd$ 任意类的边,此时只是矩形发生旋转,并不会影响路径相交的事实,其余分情况讨论也是同理。**\n\n2. $d[i]$ 与 $d[i - 4]$ 发生相交:此时满足 $d[i - 1] = d[i - 3]$,同时 $d[i] + d[i - 4] >= d[i - 2]$; \n\n3. $d[i]$ 与 $d[i - 5]$ 发生相交:此时满足$d[i - 1] <= d[i - 3]$,同时 $d[i - 2] > d[i - 4]$,同时 $d[i] + d[i - 4] >= d[i - 2]$,同时 $d[i - 1] + d[i - 5] >= d[i - 3]$。\n\n**综上,$d[i]$ 不会与 $d[i - 1]$ 和 $d[i - 2]$ 发生相交,而 $d[i]$ 与 $d[i - 3]$、$d[i - 4]$ 和 $d[i - 5]$ 的相交条件如上述讨论。并且 $d[i]$ 不会与 $d[i - x]$ $(x > 5)$ 发生相交的同时,不与 $d[i - y]$ $(3 <= y <= 5)$ 发生相交。即 $d[i]$ 与 $d[i - x]$ $(x > 5)$ 发生相交前,必然与 $d[i - y]$ $(3 <= y <= 5)$ 发生相交。**\n\n代码:\n```Java\nclass Solution {\n    public boolean isSelfCrossing(int[] d) {\n        int n = d.length;\n        if (n < 4) return false;\n        for (int i = 3; i < n; i++) {\n            if (d[i] >= d[i - 2] && d[i - 1] <= d[i - 3]) return true;\n            if (i >= 4 && d[i - 1] == d[i - 3] && d[i] + d[i - 4] >= d[i - 2]) return true;\n            if (i >= 5 && d[i - 1] <= d[i - 3] && d[i - 2] > d[i - 4] && d[i] + d[i - 4] >= d[i - 2] && d[i - 1] + d[i - 5] >= d[i - 3]) return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.335` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/331-340/338. 比特位计数（简单）.md", "url_title": "338. 比特位计数", "url": "https://leetcode-cn.com/problems/counting-bits/solution/po-su-jie-fa-dong-tai-gui-hua-jie-fa-by-vvail/", "difficulty": "简单", "tags": ["位运算", "数学", "线性 DP"], "question": "给定一个非负整数 `num`。对于 `0 ≤ i ≤ num` 范围中的每个数字 `i`,计算其二进制数中的 $1$ 的数目并将它们作为数组返回。\n\n示例 1:\n```\n输入: 2\n\n输出: [0,1,1]\n```\n示例 2:\n```\n输入: 5\n\n输出: [0,1,1,2,1,2]\n```\n进阶:\n* 给出时间复杂度为 $O(n \\times sizeof(integer))$ 的解答非常容易。但你可以在线性时间 $O(n)$ 内用一趟扫描做到吗?\n* 要求算法的空间复杂度为 $O(n)$ 。\n* 你能进一步完善解法吗?要求在 `C++` 或任何其他语言中不使用任何内置函数(如 `C++` 中的 `__builtin_popcount`)来执行此操作。", "solution": "### 模拟\n\n这道题要对每个数进行统计,因此不会有比 $O(n)$ 更低的做法。\n\n而很容易想到的朴素做法是对每个数进行「位运算」计数,每个数都是 $32$ 位的,因此是一个 $O(32n)$ 的做法。\n\n代码:\n```Java\nclass Solution {\n    public int[] countBits(int n) {\n        int[] ans = new int[n + 1];\n        for (int i = 0; i <= n; i++) ans[i] = getCnt(i);\n        return ans;\n    }\n    int getCnt(int u) {\n        int ans = 0;\n        for (int i = 0; i < 32; i++) ans += (u >> i) & 1;\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:使用与输入同等规模的空间存储答案。复杂度为 $O(n)$\n\n---\n\n### 动态规划\n\n事实上,这道题是有严格 $O(n)$ 的解法的,要求 $O(n)$ 复杂度又是输出方案的题,通常就是递推的 DP 题。\n\n用已算出的值去凑出要算的值。\n\n那么对于这类问题我们该如何考虑呢?一般是靠经验,如果实在没见过这类题型的话,我们就需要在纸上画一下,分析一下我们**朴素做法的最后一步**是怎么进行的。\n\n不失一般性的,假设当前我要统计的数的 `i`,`i` 对应的二进制表示是 `00000...0010100101`(共 32 位)\n\n如果我们是使用「朴素解法」求解的话,无论是从高位进行统计,还是从低位进行统计,最后一位扫描的都是边缘的数(如果是 1 就计数,不是 1 就不计数)。\n\n* **从低位到高位**,最后一步在扫描**最高位**之前,**统计出 1 的个数应该等同于将 `i` 左移一位,并在最低位补 0,也就是等于 `ans[i << 1]`,这时候就要求我们在计算 `i` 的时候 `i << 1` 已经被算出来(从大到小遍历)**\n* **从高位到低位**,最后一步在扫描**最低位**之前,**统计出 1 的个数应该等同于将 `i` 右移一位,并在最高位补 0,也就是等于 `ans[i >> 1]`,这时候就要求我们在计算 `i` 的时候 `i >> 1` 已经被算出来(从小到大遍历)**\n\n通过**对「朴素做法」的最后一步分析**,转移方程就出来了:\n\n* 当**从大到小遍历** :$f(i) = f(i << 1) + ((i >>31 ) \\& 1)$\n* 当**从小到大遍历** :$f(i) = f(i >> 1) + ( i \\& 1 )$\n\n代码:\n```Java\nclass Solution {\n    // 从小到大遍历\n    public int[] countBits(int n) {\n        int[] ans = new int[n + 1];\n        // ans[i] = 「i >> 1 所包含的 1 的个数」+「i 的最低位是否为 1」\n        for (int i = 1; i <= n; i++) ans[i] = ans[i >> 1] + (i & 1);\n        return ans;\n    }\n}\n```\n-\n```Java \nclass Solution {\n    // 从大到小遍历\n    public int[] countBits(int n) {\n        int[] ans = new int[n + 1];\n        for (int i = n; i >= 0; i--) {\n            // 如果计算 i 所需要的 i << 1 超过 n,则不存储在 ans 内,需要额外计算\n            int u = i << 1 <= n ? ans[i << 1] : getCnt(i << 1);\n            // ans[i] =「i << 1 所包含的 1 的个数」 + 「i 的最高位是否为 1」\n            ans[i] = u + ((i >> 31) & 1);\n        } \n        return ans;\n    }\n    int getCnt(int u) {\n        int ans = 0;\n        for (int i = 0; i < 32; i++) ans += (u >> i) & 1;\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:使用与输入同等规模的空间存储答案。复杂度为 $O(n)$\n\n---\n\n### 位运算说明\n\n* `a >> b & 1` 代表检查 `a` 的第 `b` 位是否为 $1$,有两种可能性 $0$ 或者 $1$\n\n* `a += 1 << b` 代表将 `a` 的第 `b` 位设置为 $1$ (当第 `b` 位为 $0$ 的时候适用)\n\n如不想写对第 `b` 位为 $0$ 的前置判断,`a += 1 << b` 也可以改成 `a |= 1 << b`\n\n在之前的题解我就强调过,以上两个操作在位运算中**使用频率超高,建议每位同学都加深理解**。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.338` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/341-350/341. 扁平化嵌套列表迭代器（中等）.md", "url_title": "341. 扁平化嵌套列表迭代器", "url": "https://leetcode-cn.com/problems/flatten-nested-list-iterator/solution/yi-ti-shuang-jie-dfsdui-lie-di-gui-zhan-kvwhy/", "difficulty": "中等", "tags": ["DFS", "队列", "栈"], "question": "给你一个嵌套的整型列表。请你设计一个迭代器,使其能够遍历这个整型列表中的所有整数。\n\n列表中的每一项或者为一个整数,或者是另一个列表。其中列表的元素也可能是整数或是其他列表。\n\n \n\n示例 1:\n```\n输入: [[1,1],2,[1,1]]\n输出: [1,1,2,1,1]\n解释: 通过重复调用 next 直到 hasNext 返回 false,next 返回的元素的顺序应该是: [1,1,2,1,1]。\n```\n示例 2:\n```\n输入: [1,[4,[6]]]\n输出: [1,4,6]\n解释: 通过重复调用 next 直到 hasNext 返回 false,next 返回的元素的顺序应该是: [1,4,6]。\n```", "solution": "### DFS + 队列\n\n由于所有的元素都是在初始化时提供的,因此一个朴素的做法是在初始化的时候进行处理。\n\n由于存在嵌套,比较简单的做法是通过 DFS 进行处理,将元素都放至队列。\n\n代码:\n```java []\npublic class NestedIterator implements Iterator<Integer> {\n\n    Deque<Integer> queue = new ArrayDeque<>();\n\n    public NestedIterator(List<NestedInteger> nestedList) {\n        dfs(nestedList);\n    }\n\n    @Override\n    public Integer next() {\n        return hasNext() ? queue.pollFirst() : -1;\n    }\n\n    @Override\n    public boolean hasNext() {\n        return !queue.isEmpty();\n    }\n\n    void dfs(List<NestedInteger> list) {\n        for (NestedInteger item : list) {\n            if (item.isInteger()) {\n                queue.addLast(item.getInteger());\n            } else {\n                dfs(item.getList());\n            }\n        }\n    }\n}\n```\n* 时间复杂度:构建迭代器的复杂度为 $O(n)$,调用 $next()$ 与 $hasNext()$ 的复杂度为 $O(1)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 递归 + 栈\n\n另外一个做法是,我们不对所有的元素进行预处理。\n\n而是先将所有的 `NestedInteger` 逆序放到栈中,当需要展开的时候才进行展开。\n\n代码:\n```java\npublic class NestedIterator implements Iterator<Integer> {\n\n    Deque<NestedInteger> stack = new ArrayDeque<>();\n\n    public NestedIterator(List<NestedInteger> list) {\n        for (int i = list.size() - 1; i >= 0; i--) {\n            NestedInteger item = list.get(i);\n            stack.addLast(item);\n        }\n    }\n\n    @Override\n    public Integer next() {\n        return hasNext() ? stack.pollLast().getInteger() : -1;\n    }\n\n    @Override\n    public boolean hasNext() {\n        if (stack.isEmpty()) {\n            return false;\n        } else {\n            NestedInteger item = stack.peekLast();\n            if (item.isInteger()) {\n                return true;\n            } else {\n                item = stack.pollLast();\n                List<NestedInteger> list = item.getList();\n                for (int i = list.size() - 1; i >= 0; i--) {\n                    stack.addLast(list.get(i));\n                }\n                return hasNext();\n            }\n        }\n    }\n}\n```\n* 时间复杂度:构建迭代器的复杂度为 $O(n)$,$hasNext()$ 的复杂度为均摊 $O(1)$,$next()$ 严格按照迭代器的访问顺序( 先 $hasNext()$ 再 $next()$ )的话为 $O(1)$,防御性编程生效的情况下为均摊 $O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.341` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/341-350/342. 4的幂（简单）.md", "url_title": "342. 4的幂", "url": "https://leetcode-cn.com/problems/power-of-four/solution/gong-shui-san-xie-zhuan-hua-wei-2-de-mi-y21lq/", "difficulty": "简单", "tags": ["数学", "位运算"], "question": "给定一个整数,写一个函数来判断它是否是 4 的幂次方。如果是,返回 true ;否则,返回 false 。\n\n整数 n 是 4 的幂次方需满足:存在整数 x 使得 n == $4^x$\n\n示例 1:\n```\n输入:n = 16\n输出:true\n```\n示例 2:\n```\n输入:n = 5\n输出:false\n```\n示例 3:\n```\n输入:n = 1\n输出:true\n```\n\n提示:\n\n* -$2^{31}$ <= n <= $2^{31}$ - 1\n\n进阶:\n\n你能不使用循环或者递归来完成本题吗?", "solution": "### 基本分析\n\n一个数 $n$ 如果是 $4$ 的幂,等价于 $n$ 为质因数只有 $2$ 的平方数。\n\n因此我们可以将问题其转换:判断 $\\sqrt{n}$ 是否为 $2$ 的幂。\n\n判断某个数是否为 $2$ 的幂的分析在[(题解)231. 2 的幂](https://leetcode-cn.com/problems/power-of-two/solution/gong-shui-san-xie-2-de-mi-by-ac_oier-qm6e/) 这里。\n\n---\n\n### sqrt + lowbit\n\n我们可以先对 $n$ 执行 `sqrt` 函数,然后应用 `lowbit` 函数快速判断 $\\sqrt{n}$ 是否为 $2$ 的幂。\n\n代码:\n```Java\nclass Solution {\n    public boolean isPowerOfFour(int n) {\n        if (n <= 0) return false;\n        int x = (int)Math.sqrt(n);\n        return x * x == n && (x & -x) == x;\n    }\n}\n```\n```Java\nclass Solution {\n    public boolean isPowerOfFour(int n) {\n        if (n <= 0) return false;\n        int x = getVal(n);\n        return x * x == n && (x & -x) == x;\n    }\n    int getVal(int n) {\n        long l = 0, r = n;\n        while (l < r) {\n            long mid = l + r >> 1;\n            if (mid * mid >= n) {\n                r = mid;\n            } else {\n                l = mid + 1;\n            }\n        }\n        return (int)r;\n    } \n}\n```\n* 时间复杂度:复杂度取决于内置函数 `sqrt`。一个简单的 `sqrt` 的实现接近于 P2 的代码。复杂度为 $O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.342` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/341-350/345. 反转字符串中的元音字母（简单）.md", "url_title": "345. 反转字符串中的元音字母", "url": "https://leetcode-cn.com/problems/reverse-vowels-of-a-string/solution/gong-shui-san-xie-note-bie-pian-shuang-z-c8ii/", "difficulty": "简单", "tags": ["双指针", "模拟"], "question": "编写一个函数,以字符串作为输入,反转该字符串中的元音字母。\n\n示例 1:\n```\n输入:\"hello\"\n\n输出:\"holle\"\n```\n示例 2:\n```\n输入:\"leetcode\"\n\n输出:\"leotcede\"\n```\n\n提示:\n* 元音字母不包含字母 \"y\" 。", "solution": "### 双指针\n\n一个朴素的做法是利用「双指针」进行前后扫描,当左右指针都是元音字母时,进行互换并移到下一位。\n\n由于元音字母相对固定,因此我们可以使用容器将其存储,并使用 `static` 修饰,确保整个容器的创建和元音字母的填入在所有测试样例中只会发生一次。\n\n我们期望该容器能在 $O(1)$ 的复杂度内判断是否为元音字母,可以使用语言自带的哈希类容器($P2$ 代码)或是使用数组模拟($P1$ 代码)。\n\n> 一些细节:由于题目没有说字符串中只包含字母,因此在使用数组模拟哈希表时,我们需要用当前字符减去 ASCII 码的最小值(空字符),而不是 'A'\n\n代码:\n```Java\nclass Solution {\n    static boolean[] hash = new boolean[128];\n    static char[] vowels = new char[]{'a','e','i','o','u'};\n    static {\n        for (char c : vowels) {\n            hash[c - ' '] = hash[Character.toUpperCase(c) - ' '] = true;\n        }\n    }\n    public String reverseVowels(String s) {\n        char[] cs = s.toCharArray();\n        int n = s.length();\n        int l = 0, r = n - 1;\n        while (l < r) {\n            if (hash[cs[l] - ' '] && hash[cs[r] - ' ']) {\n                swap(cs, l++, r--);\n            } else {\n                if (!hash[cs[l] - ' ']) l++;\n                if (!hash[cs[r] - ' ']) r--;\n            }\n        }\n        return String.valueOf(cs);\n    }\n    void swap(char[] cs, int l, int r) {\n        char c = cs[l];\n        cs[l] = cs[r];\n        cs[r] = c;\n    }\n}\n```\n\n```Java\nclass Solution {\n    static char[] vowels = new char[]{'a','e','i','o','u'};\n    static Set<Character> set = new HashSet<>();\n    static {\n        for (char c : vowels) {\n            set.add(c);\n            set.add(Character.toUpperCase(c));\n        }\n    }\n    public String reverseVowels(String s) {\n        char[] cs = s.toCharArray();\n        int n = s.length();\n        int l = 0, r = n - 1;\n        while (l < r) {\n            if (set.contains(cs[l]) && set.contains(cs[r])) {\n                swap(cs, l++, r--);\n            } else {\n                if (!set.contains(cs[l])) l++;\n                if (!set.contains(cs[r])) r--;\n            }\n        }\n        return String.valueOf(cs);\n    }\n    void swap(char[] cs, int l, int r) {\n        char c = cs[l];\n        cs[l] = cs[r];\n        cs[r] = c;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:由于 `toCharArray` 会创建新数组,复杂度为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.345` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/351-360/352. 将数据流变为多个不相交区间（困难）.md", "url_title": "352. 将数据流变为多个不相交区间", "url": "https://leetcode-cn.com/problems/data-stream-as-disjoint-intervals/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-afrk/", "difficulty": "困难", "tags": ["二分", "模拟"], "question": "给你一个由非负整数 `a1, a2, ..., an` 组成的数据流输入,请你将到目前为止看到的数字总结为不相交的区间列表。\n\n实现 `SummaryRanges` 类:\n\n* `SummaryRanges()` 使用一个空数据流初始化对象。\n* `void addNum(int val)` 向数据流中加入整数 `val` 。\n* `int[][] getIntervals()` 以不相交区间 `[starti, endi]` 的列表形式返回对数据流中整数的总结。\n\n示例:\n```\n输入:\n[\"SummaryRanges\", \"addNum\", \"getIntervals\", \"addNum\", \"getIntervals\", \"addNum\", \"getIntervals\", \"addNum\", \"getIntervals\", \"addNum\", \"getIntervals\"]\n[[], [1], [], [3], [], [7], [], [2], [], [6], []]\n\n输出:\n[null, null, [[1, 1]], null, [[1, 1], [3, 3]], null, [[1, 1], [3, 3], [7, 7]], null, [[1, 3], [7, 7]], null, [[1, 3], [6, 7]]]\n\n解释:\nSummaryRanges summaryRanges = new SummaryRanges();\nsummaryRanges.addNum(1);      // arr = [1]\nsummaryRanges.getIntervals(); // 返回 [[1, 1]]\nsummaryRanges.addNum(3);      // arr = [1, 3]\nsummaryRanges.getIntervals(); // 返回 [[1, 1], [3, 3]]\nsummaryRanges.addNum(7);      // arr = [1, 3, 7]\nsummaryRanges.getIntervals(); // 返回 [[1, 1], [3, 3], [7, 7]]\nsummaryRanges.addNum(2);      // arr = [1, 2, 3, 7]\nsummaryRanges.getIntervals(); // 返回 [[1, 3], [7, 7]]\nsummaryRanges.addNum(6);      // arr = [1, 2, 3, 6, 7]\nsummaryRanges.getIntervals(); // 返回 [[1, 3], [6, 7]]\n```\n\n提示:\n* 0 <= val <= $10^4$\n* 最多调用 addNum 和 getIntervals 方法 $3 * 10^4$ 次\n\n**进阶:如果存在大量合并,并且与数据流的大小相比,不相交区间的数量很小,该怎么办?**", "solution": "### 二分查找 + 朴素维护区间\n\n一个朴素的做法是直接使用 `ArrayList`(数组)来维护所有的不相交区间,然后调用 `addNum` 时先通过二分找到当前值相邻的区间,然后根据题意进行模拟即可。\n\n同时为了简化复杂的分情况讨论,起始时我们可以先往 `ArrayList` 添加两个哨兵分别代表正无穷和负无穷。\n\n代码(不使用哨兵的代码见 $P2$):\n```Java\nclass SummaryRanges {\n    List<int[]> list = new ArrayList<>();\n    int[] head = new int[]{-10, -10}, tail = new int[]{10010, 10010};\n    public SummaryRanges() {\n        list.add(head);\n        list.add(tail);\n    }\n    public void addNum(int val) {\n        int n = list.size();\n        if (n == 0) {\n            list.add(new int[]{val, val});\n            return ;\n        }\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (list.get(mid)[0] <= val) l = mid;\n            else r = mid - 1;\n        }\n        int[] cur = new int[]{val, val};\n        int[] prev = list.get(r);\n        int[] next = list.get(r + 1);\n        if ((prev[0] <= val && val <= prev[1]) || (next[0] <= val && val <= next[1])) {\n            // pass\n        } else if (prev[1] + 1 == val && val == next[0] - 1) {\n            prev[1] = next[1];\n            list.remove(next);\n        } else if (prev[1] + 1 == val) {\n            prev[1] = val;\n        } else if (next[0] - 1 == val) {\n            next[0] = val;\n        } else {\n            list.add(r + 1, cur);\n        }\n    }\n    public int[][] getIntervals() {\n        int n = list.size();\n        int[][] ans = new int[n - 2][2];\n        int idx = 0;\n        for (int i = 1; i < n - 1; i++) ans[idx++] = list.get(i);\n        return ans;\n    }\n}\n```\n\n```Java\nclass SummaryRanges {\n    List<int[]> list = new ArrayList<>();\n    public void addNum(int val) {\n        int n = list.size();\n        if (n == 0) {\n            list.add(new int[]{val, val});\n            return ;\n        }\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (list.get(mid)[0] <= val) l = mid;\n            else r = mid - 1;\n        }\n        int[] cur = list.get(r);\n        if (cur[0] > val) {\n            if (val + 1 == cur[0]) {\n                cur[0] = val;\n            } else {\n                list.add(r, new int[]{val, val});\n            }\n            return ;\n        }\n        if (cur[0] <= val && val <= cur[1]) {\n            // pass\n        } else if (r == n - 1) {\n            if (cur[1] + 1 == val) {\n                cur[1] = val;\n            } else {\n                list.add(new int[]{val, val});\n            }\n        } else {\n            int[] next = list.get(r + 1);\n            if (cur[1] + 1 == val && val == next[0] - 1) {\n                cur[1] = next[1];\n                list.remove(r + 1);\n            } else if (cur[1] + 1 == val) {\n                cur[1] = val;\n            } else if (next[0] - 1 == val) {\n                next[0] = val;\n            } else {\n                list.add(r + 1, new int[]{val, val});\n            }\n        }\n    }\n    public int[][] getIntervals() {\n        int n = list.size();\n        int[][] ans = new int[n][2];\n        for (int i = 0; i < n; i++) ans[i] = list.get(i);\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $m$ 为不交区间个数,`addNum` 操作中查询相邻区间的复杂度为 $O(\\log{m})$,维护不相交区间时,由于需要针对 $list$ 的索引位置进行元素插入和删除,复杂度为 $O(m)$,整体复杂度为 $O(m)$;`getIntervals` 操作需要遍历所有的 $list$ 元素,复杂度为 $O(m)$\n* 空间复杂度:$O(m)$\n\n---\n\n### 二分查找 + 优化维护区间\n\n解法一中虽然在 `addNum` 使用到了复杂度诶 $O(\\log{m})$ 的二分查找,但在维护区间时,由于要对 $list$ 进行针对索引的插入和删除,导致整体复杂度为 $O(m)$。\n\n我们期望找到一种插入/删除操作复杂度同样为 $O(\\log{m})$ 的方式来维护区间,这引导我们使用 `TreeSet`(红黑树)等数据结构。\n\n具体做法不变,仍然是先使用「二分」(`TreeSet` 自带的 `floor/ceiling`)来找到当前值的相邻区间,\n\n同时为了简化复杂的分情况讨论,起始时我们可以先往 `TreeSet` 添加两个哨兵分别代表正无穷和负无穷,以确保调用 `floor/ceiling` 时不会返回空。\n\n代码:\n```Java\nclass SummaryRanges {\n    TreeSet<int[]> ts = new TreeSet<>((a, b)->a[0]-b[0]);\n    int[] head = new int[]{-10, -10}, tail = new int[]{10010, 10010};\n    public SummaryRanges() {\n        ts.add(head);\n        ts.add(tail);\n    }\n    public void addNum(int val) {\n        int[] cur = new int[]{val, val};\n        int[] prev = ts.floor(cur);\n        int[] next = ts.ceiling(cur);\n        if ((prev[0] <= val && val <= prev[1]) || (next[0] <= val && val <= next[1])) {\n            // pass\n        } else if (prev[1] + 1 == val && next[0] - 1 == val) {\n            prev[1] = next[1];\n            ts.remove(next);\n        } else if (prev[1] + 1 == val) {\n            prev[1] = val;\n        } else if (next[0] - 1 == val) {\n            next[0] = val;\n        } else {\n            ts.add(cur);\n        }\n    }\n    public int[][] getIntervals() {\n        // using ceiling\n        // int n = ts.size();\n        // int[][] ans = new int[n - 2][2];\n        // int[] cur = head;\n        // for (int i = 0; i < n - 2; i++) {\n        //     ans[i] = ts.ceiling(new int[]{cur[0] + 1, cur[1] + 1});\n        //     cur = ans[i];\n        // }\n        // return ans;\n\n        // using iterator\n        int n = ts.size();\n        int[][] ans = new int[n - 2][2];\n        Iterator<int[]> iterator = ts.iterator();\n        iterator.next();\n        for (int i = 0; i < n - 2; i++) ans[i] = iterator.next();\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $m$ 为不交区间个数,`addNum` 操作中「查询相邻区间」和「维护不相交区间」的复杂度为 $O(\\log{m})$,整体复杂度为 $O(\\log{m})$;`getIntervals` 操作需要获取有序集合中的所有元素,使用 `ceiling` 复杂度为 $O(m\\log{m})$。使用 `iterator` 的话,由于 `TreeSet` 底层同步维护了一个 `TreeMap`,迭代器由 `TreeMap` 所提供,获取 `iterator` 来遍历所有元素的复杂度为 $O(m)$\n* 空间复杂度:$O(m)$\n\n---\n\n### 进阶\n\n如果存在大量合并,并且与数据流的大小相比,不相交区间的数量很小,该怎么办?\n\n即需要确保 `addNum` 的复杂度,而对 `getIntervals` 复杂度要求不高,上述解法就已经是这么做的了。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.352` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/351-360/354. 俄罗斯套娃信封问题（困难）.md", "url_title": "354. 俄罗斯套娃信封问题", "url": "https://leetcode-cn.com/problems/russian-doll-envelopes/solution/zui-chang-shang-sheng-zi-xu-lie-bian-xin-6s8d/", "difficulty": "困难", "tags": ["二分", "序列 DP"], "question": "给你一个二维整数数组 envelopes ,其中 envelopes[i] = [wi, hi] ,表示第 i 个信封的宽度和高度。\n\n当另一个信封的宽度和高度都比这个信封大的时候,这个信封就可以放进另一个信封里,如同俄罗斯套娃一样。\n\n请计算「最多能有多少个」信封能组成一组“俄罗斯套娃”信封(即可以把一个信封放到另一个信封里面)。\n\n注意:不允许旋转信封。\n\n示例 1:\n```\n输入:envelopes = [[5,4],[6,4],[6,7],[2,3]]\n输出:3\n解释:最多信封的个数为 3, 组合为: [2,3] => [5,4] => [6,7]。\n```\n示例 2:\n```\n输入:envelopes = [[1,1],[1,1],[1,1]]\n输出:1\n```\n\n提示:\n* 1 <= envelopes.length <= 5000\n* envelopes[i].length == 2\n* 1 <= wi, hi <= $10^4$", "solution": "### 动态规划\n\n这是一道经典的 DP 模型题目:最长上升子序列(LIS)。\n\n首先我们先对 `envelopes` 进行排序,确保信封是从小到大进行排序。\n\n问题就转化为我们从这个序列中选择 `k` 个信封形成新的序列,使得新序列中的每个信封都能严格覆盖前面的信封(宽高都严格大于)。\n\n我们可以**定义状态 $f[i]$ 为考虑前 i 个物品,并以第 $i$ 个物品为结尾的最大值。**\n\n对于每个$f[i]$ 而言,最小值为 $1$,代表只选择自己一个信封。\n\n那么对于一般的 $f[i]$ 该如何求解呢?因为第 i 件物品是必须选择的。我们可以枚举前面的 $i - 1$ 件物品,哪一件可以作为第 $i$ 件物品的上一件物品。\n\n在前 $i - 1$ 件物品中只要有符合条件的,我们就使用 $max(f[i], f[j] + 1)$ 更新 $f[i]$。\n\n然后在所有方案中取一个 `max` 即是答案。\n\n代码:\n\n```Java\nclass Solution {\n    public int maxEnvelopes(int[][] es) {\n        int n = es.length;\n        if (n == 0) return n;\n        // 因为我们在找第 i 件物品的前一件物品时,会对前面的 i - 1 件物品都遍历一遍,因此第二维(高度)排序与否都不影响\n        Arrays.sort(es, (a, b)->a[0]-b[0]);\n        int[] f = new int[n]; // f(i) 为考虑前 i 个物品,并以第 i 个物品为结尾的最大值\n        int ans = 1;\n        for (int i = 0; i < n; i++) {\n            // 对于每个 f[i] 都满足最小值为 1\n            f[i] = 1; \n            // 枚举第 i 件物品的前一件物品,\n            for (int j = i - 1; j >= 0; j--) {\n                // 只要有满足条件的前一件物品,我们就尝试使用 f[j] + 1 更新 f[i]\n                if (check(es, j, i)) {\n                    f[i] = Math.max(f[i], f[j] + 1);\n                }\n            }\n            // 在所有的 f[i] 中取 max 作为 ans\n            ans = Math.max(ans, f[i]);\n        }\n        return ans;\n    }\n    boolean check(int[][] es, int mid, int i) {\n        return es[mid][0] < es[i][0] && es[mid][1] < es[i][1];\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 二分 + 动态规划\n\n上述方案其实算是一个朴素方案,复杂度是 $O(n^2)$ 的,也是我最先想到思路,但是题目没有给出数据范围,也不知道能不能过。\n\n唯唯诺诺交了一个居然过了。\n\n下面讲下其他优化解法。\n\n首先还是和之前一样,我们可以通过复杂度分析来想优化方向。\n\n指数算法往下优化就是对数解法或者线性解法。\n\n仔细观察朴素解法,其实可优化的地方主要就是找第 $i$ 件物品的前一件物品的过程。\n\n如果想要加快这个查找过程,我们需要使用某种数据结构进行记录。\n\n并且是边迭代边更新数据结构里面的内容。\n\n首先因为我们对 `w` 进行了排序(从小到大),然后迭代也是从前往后进行,因此我们只需要保证迭代过程中,对于 `w` 相同的数据不更新,就能保证 `g` 中只会出现满足 `w` 条件的信封。\n\n到这一步,还需要用到的东西有两个:一个是 `h`,因为只有 `w` 和 `h` 都同时满足,我们才能加入上升序列中;一个是信封所对应的上升序列长度,这是我们加速查找的核心。\n\n我们使用数组 `g` 来记录,$g[i]$ 表示长度为 $i$ 的最长上升子序列的中的最小「信封高度」,同时需要使用 `len` 记录当前记录到的最大长度。\n\n还是不理解?没关系,我们可以直接看看代码,我把基本逻辑写在了注释当中(你的重点应该落在对 $g[]$ 数组的理解上)。\n\n代码:\n\n```Java\nclass Solution {\n    public int maxEnvelopes(int[][] es) {\n        int n = es.length;\n        if (n == 0) return n;\n        // 由于我们使用了 g 记录高度,因此这里只需将 w 从小到达排序即可\n        Arrays.sort(es, (a, b)->a[0] - b[0]);\n        // f(i) 为考虑前 i 个物品,并以第 i 个物品为结尾的最大值\n        int[] f = new int[n]; \n        // g(i) 记录的是长度为 i 的最长上升子序列的最小「信封高度」\n        int[] g = new int[n]; \n        // 因为要取 min,用一个足够大(不可能)的高度初始化\n        Arrays.fill(g, Integer.MAX_VALUE); \n        g[0] = 0;\n        int ans = 1;\n        for (int i = 0, j = 0, len = 1; i < n; i++) {\n            // 对于 w 相同的数据,不更新 g 数组\n            if (es[i][0] != es[j][0]) {\n                // 限制 j 不能越过 i,确保 g 数组中只会出现第 i 个信封前的「历史信封」\n                while (j < i) {\n                    int prev = f[j], cur = es[j][1];\n                    if (prev == len) {\n                        // 与当前长度一致了,说明上升序列多增加一位\n                        g[len++] = cur;\n                    } else {\n                        // 始终保留最小的「信封高度」,这样可以确保有更多的信封可以与其行程上升序列\n                        // 举例:同样是上升长度为 5 的序列,保留最小高度为 5 记录(而不是保留任意的,比如 10),这样之后高度为 7 8 9 的信封都能形成序列;\n                        g[prev] = Math.min(g[prev], cur);\n                    }\n                    j++;\n                }\n            }\n\n            // 二分过程\n            // g[i] 代表的是上升子序列长度为 i 的「最小信封高度」\n            int l = 0, r = len;\n            while (l < r) {\n                int mid = l + r >> 1;\n                // 令 check 条件为 es[i][1] <= g[mid](代表 w 和 h 都严格小于当前信封)\n                // 这样我们找到的就是满足条件,最靠近数组中心点的数据(也就是满足 check 条件的最大下标)\n                // 对应回 g[] 数组的含义,其实就是找到 w 和 h 都满足条件的最大上升长度\n                if (es[i][1] <= g[mid]) {\n                    r = mid;\n                } else {\n                    l = mid + 1;\n                }\n            }\n            // 更新 f[i] 与答案\n            f[i] = r;\n            ans = Math.max(ans, f[i]);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:对于每件物品都是通过「二分」找到其前一件物品。复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n***\n\n### 证明\n\n我们可以这样做的前提是 `g` 数组具有二段性,可以通过证明其具有「单调性」来实现。\n\n当然这里指的是 `g` 被使用的部分,也就是 $[0, len - 1]$ 的部分。\n\n我们再回顾一下 `g[]` 数组的定义:**$g[i]$ 表示长度为 $i$ 的最长上升子序列的中的最小「信封高度」**\n\n例如 $g[] = [0, 3, 4, 5]$ 代表的含义是:\n* 上升序列长度为 0 的最小历史信封高度为 0\n* 上升序列长度为 1 的最小历史信封高度为 3\n* 上升序列长度为 2 的最小历史信封高度为 4\n* 上升序列长度为 3 的最小历史信封高度为 5\n\n可以通过反证法来证明其单调性:\n\n假设 $g[]$ 不具有单调性,即至少有 $g[i] > g[j]$ ( $i < j$,令 $a = g[i]$, $b = g[j]$)\n\n显然与我们的处理逻辑冲突。因为如果考虑一个「最小高度」为 `b` 的信封能够凑出长度为 `j` 的上升序列,自然也能凑出比 `j` 短的上升序列,对吧?\n\n举个🌰,我们有信封:[[1,1],[2,2],[3,3],[4,4],[5,5]],我们能凑出很多种长度为 2 的上升序列方案,其中最小的方案是高度最小的方案是 [[1,1],[2,2]]。因此这时候 g[2] = 2,代表能凑出长度为 2 的上升序列所 **必须使用的信封** 的最小高度为 2。\n\n这时候反过来考虑,如果使用 [2,2] 能够凑出长度为 2 的上升序列,必然也能凑出长度为 1 的上升序列(删除前面的其他信封即可)。\n\n**推而广之,如果我们有 $g[j] = b$,也就是凑成长度为 `j` 必须使用的最小信封高度为 b。那么我必然能够保留高度为 `b` 的信封,删掉上升序列中的一些信封,凑成任意长度比 `j` 小的上升序列。**\n\n综上,$g[i] > g[j](i < j)$ 与处理逻辑冲突,$g[]$ 数组为严格单调上升数组。\n\n既然 $g[]$ 具有单调性,我们可以通过「二分」找到恰满足 check 条件的最大下标(最大下标达标表示最长上升序列长度)。\n\n***\n\n### 树状数组 + 动态规划\n\n在「二分 + 动态规划」的解法中,我们通过「二分」来优化找第 $i$ 个文件的前一个文件过程。\n\n这个过程同样能通过「树状数组」来实现。\n\n首先仍然是对 `w` 进行排序,然后使用「树状数组」来维护 h 维度的前缀最大值。\n\n对于 `h` 的高度,我们只关心多个信封之间的大小关系,而不关心具体相差多少,我们需要对 `h` 进行离散化。\n\n通常使用「树状数组」都需要进行离散化,尤其是这里我们本身就要使用 $O(n)$ 的空间来存储 dp 值。\n\n代码:\n\n```java\nclass Solution {\n    int[] tree;\n    int lowbit(int x) {\n        return x & -x;\n    }\n\n    public int maxEnvelopes(int[][] es) {\n        int n = es.length;\n        if (n == 0) return n;\n\n        // 由于我们使用了 g 记录高度,因此这里只需将 w 从小到达排序即可\n        Arrays.sort(es, (a, b)->a[0] - b[0]);\n\n        // 先将所有的 h 进行离散化\n        Set<Integer> set = new HashSet<>();\n        for (int i = 0; i < n; i++) set.add(es[i][1]);\n        int cnt = set.size();\n        int[] hs = new int[cnt];\n        int idx = 0;\n        for (int i : set) hs[idx++] = i;\n        Arrays.sort(hs);\n        for (int i = 0; i < n; i++) es[i][1] = Arrays.binarySearch(hs, es[i][1]) + 1;\n\n        // 创建树状数组\n        tree = new int[cnt + 1];\n\n        // f(i) 为考虑前 i 个物品,并以第 i 个物品为结尾的最大值\n        int[] f = new int[n]; \n        int ans = 1;\n        for (int i = 0, j = 0; i < n; i++) {\n            // 对于 w 相同的数据,不更新 tree 数组\n            if (es[i][0] != es[j][0]) {\n                // 限制 j 不能越过 i,确保 tree 数组中只会出现第 i 个信封前的「历史信封」\n                while (j < i) {\n                    for (int u = es[j][1]; u <= cnt; u += lowbit(u)) {\n                        tree[u] = Math.max(tree[u], f[j]);\n                    }\n                    j++;\n                }\n            }\n            f[i] = 1;\n            for (int u = es[i][1] - 1; u > 0; u -= lowbit(u)) {\n                f[i] = Math.max(f[i], tree[u] + 1);\n            }\n            ans = Math.max(ans, f[i]);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:处理每个物品时更新「树状数组」复杂度为$O(\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.354` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/351-360/357. 统计各位数字都不同的数字个数（中等）.md", "url_title": "357. 统计各位数字都不同的数字个数", "url": "https://leetcode-cn.com/problems/count-numbers-with-unique-digits/solution/by-ac_oier-6tfl/", "difficulty": "中等", "tags": ["数学", "容斥原理", "数位 DP"], "question": "给你一个整数 $n$ ,统计并返回各位数字都不同的数字 $x$ 的个数,其中 $0 <= x < 10^n$ 。\n\n示例 1:\n```\n输入:n = 2\n\n输出:91\n\n解释:答案应为除去 11、22、33、44、55、66、77、88、99 外,在 0 ≤ x < 100 范围内的所有数字。 \n```\n示例 2:\n```\n输入:n = 0\n\n输出:1\n```\n\n提示:\n* $0 <= n <= 8$", "solution": "### 乘法原理\n\n对于 $n = 0$ 的情况较为特殊,特判一下,返回 $1$。\n\n对于其他情况,由于不能含有前导 $0$,最高位可选择的数值个数为 $9$,而从次高位开始到最低位,可选的个数从 $9$ 开始逐一递减。\n\n利用乘法原理,每位数可选的数值个数相乘即是长度为 $n$ 的数的可能方案数 $cur$,而所有长度 $[1, n]$ 的方案数累加即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int countNumbersWithUniqueDigits(int n) {\n        if (n == 0) return 1;\n        int ans = 10;\n        for (int i = 2, last = 9; i <= n; i++) {\n            int cur = last * (10 - i + 1);\n            ans += cur; last = cur;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 数位 DP\n\n一种更为进阶的做法,应当是可以回答任意区间 $[l, r]$ 内合法数的个数。\n\n这需要运用「数位 DP」进行求解,假定我们存在函数 `int dp(int x)` 函数,能够返回区间 $[0, x]$ 内合法数的个数,那么配合「容斥原理」我们便能够回答任意区间合法数的查询:\n\n$$\nans_{(l, r)} = dp(r) - dp(l - 1)\n$$\n\n然后考虑如何实现 `int dp(int x)` 函数,我们将组成 $[0, x]$ 的合法数分成三类:\n* 位数和 $x$ 相同,且最高位比 $x$ 最高位要小的,这部分统计为 `res1`;\n* 位数和 $x$ 相同,且最高位与 $x$ 最高位相同的,这部分统计为 `res2`;\n* 位数比 $x$ 少,这部分统计为 `res3`。\n\n其中 `res1` 和 `res3` 求解相对简单,重点落在如何求解 `res2` 上。\n\n**对 $x$ 进行「从高到低」的处理(假定 $x$ 数位为 $n$),对于第 $k$ 位而言($k$ 不为最高位),假设在 $x$ 中第 $k$ 位为 $cur$,那么为了满足「大小限制」关系,我们只能在 $[0, cur - 1]$ 范围内取数,同时为了满足「相同数字只能使用一次」的限制,我们需要使用一个 `int` 变量 $s$ 来记录使用情况(用 $s$ 的低十位来代指数字 $[0, 9]$ 是否被使用),统计 $[0, cur - 1]$ 范围内同时符合两个限制条件的数的个数,记为 $cnt$。**\n\n**当第 $k$ 位有 $cnt$ 种合法选择之后,后面的位数可以在满足「相同数字只能使用一次」的限制条件下任意选择(因为大小关系已经由第 $k$ 位保证),为了快速知道剩下的 $n - k$ 位有多少种方案,我们还需要预处理乘积数组,其中 $f[l][r]$ 代表 $l * (l + 1) * ... * (j - 1) * j$ 的乘积之和。**\n\n> 上述讲解若是觉得抽象,我们可以举个 🌰,假设 $x = 678$,我们该如何求解 `res2`:由于限定了 `res2` 为「位数和 $x$ 相同,且最高位与 $x$ 最高位相同的」的合法数个数,因此最高位没有选,只能是 $6$,然后考虑处理次高位,次高位在 $x$ 中为 $7$,为了满足大小关系,我们只能在 $[0, 6]$ 范围内做限制,同时由于 $6$ 已用过,因此次高位实际只有 $[0, 5]$,共 $6$ 种选择,当确定次高位后,后面的位数任意取,由于前面已经填充了 $p = 2$ 位(即消耗了 $p$ 个不同数字),因此从后面的位数开始应该是 $a = 10 - p$ 开始往后自减累乘到 $b = (10 - p) - (n - p) + 1$ 为止,即此时方案数为 $cnt * f[b][a]$(当前位不是最低位)或者 $cnt$(当前位是最低位)。按照此逻辑循环处理所有位数即可,直到遇到重复数值或正常结束。\n\n需要说明的是,上述的举例部分只是为方便大家理解过程,看懂了举例部分不代表理解了数位 DP 做法成立的内在条件,阅读的重点还是要放在前面加粗字体部分,只会使用样例理解算法永远不是科学的做法。\n\n其他细节:乘积数组的预处理与样例无关,我们可以使用 `static` 进行打表优化,同时可以将 `res1` 和 `res2` 两种情况进行合并。\n\n代码:\n```Java\nclass Solution {\n    // f[l][r] 代表 i * (i + 1) * ... * (j - 1) * j\n    static int[][] f = new int[10][10];\n    static {\n        for (int i = 1; i < 10; i++) {\n            for (int j = i; j < 10; j++) {\n                int cur = 1;\n                for (int k = i; k <= j; k++) cur *= k;\n                f[i][j] = cur;\n            }\n        }\n    }\n    int dp(int x) {\n        int t = x;\n        List<Integer> nums = new ArrayList<>();\n        while (t != 0) {\n            nums.add(t % 10);\n            t /= 10;\n        }\n        int n = nums.size();\n        if (n <= 1) return x + 1; // [0, 9]\n        // 位数和 x 相同(res1 + res2)\n        int ans = 0;\n        for (int i = n - 1, p = 1, s = 0; i >= 0; i--, p++) {\n            int cur = nums.get(i), cnt = 0;\n            for (int j = cur - 1; j >= 0; j--) {\n                if (i == n - 1 && j == 0) continue;\n                if (((s >> j) & 1) == 0) cnt++;\n            }\n            int a = 10 - p, b = a - (n - p) + 1;\n            ans += b <= a ? cnt * f[b][a] : cnt;\n            if (((s >> cur) & 1) == 1) break;\n            s |= (1 << cur);\n            if (i == 0) ans++;\n        }\n        // 位数比 x 少(res3)\n        ans += 10;\n        for (int i = 2, last = 9; i < n; i++) {\n            int cur = last * (10 - i + 1);\n            ans += cur; last = cur;\n        }\n        return ans;\n    }\n    public int countNumbersWithUniqueDigits(int n) {\n        return dp((int)Math.pow(10, n) - 1);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.357` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/361-370/363. 矩形区域不超过 K 的最大数值和（困难）.md", "url_title": "363. 矩形区域不超过 K 的最大数值和", "url": "https://leetcode-cn.com/problems/max-sum-of-rectangle-no-larger-than-k/solution/gong-shui-san-xie-you-hua-mei-ju-de-ji-b-dh8s/", "difficulty": "困难", "tags": ["二分", "前缀和"], "question": "给你一个 `m x n` 的矩阵 `matrix` 和一个整数 $k$ ,找出并返回矩阵内部矩形区域的不超过 $k$ 的最大数值和。\n\n题目数据保证总会存在一个数值和不超过 $k$ 的矩形区域。\n\n示例 1:\n\n```\n输入:matrix = [[1,0,1],[0,-2,3]], k = 2\n\n输出:2\n\n解释:蓝色边框圈出来的矩形区域 [[0, 1], [-2, 3]] 的数值和是 2,且 2 是不超过 k 的最大数字(k = 2)。\n```\n示例 2:\n```\n输入:matrix = [[2,2,-1]], k = 3\n\n输出:3\n```\n\n提示:\n* $m == matrix.length$\n* $n == matrix[i].length$\n* $1 <= m, n <= 100$\n* $-100 <= matrix[i][j] <= 100$\n* -$10^5 <= k <= 10^5$", "solution": "### 朴素二维前缀和\n\n从题面来看显然是一道「二维前缀和」的题目,如果你还不了解「二维前缀和」,可以看看 [(题解)304. 二维区域和检索 - 矩阵不可变](https://leetcode-cn.com/problems/range-sum-query-2d-immutable/solution/xia-ci-ru-he-zai-30-miao-nei-zuo-chu-lai-ptlo/)。本题预处理前缀和的复杂度为 $O(m * n)$。\n\n搜索所有子矩阵需要枚举「矩形左上角」和「矩形右下角」,复杂度是 $O(m^2 * n^2)$。\n\n因此,如果把本题当做二维前缀和模板题来做的话,整体复杂度是 $O(m^2 * n^2)$。\n\n数据范围是 $10^2$,对应的计算量是 $10^8$,理论上会超时,但当我们枚举「矩形左上角」$(i,j)$ 的时候,我们只需要搜索位于 $(i,j)$ 的右下方的点 $(p,q)$ 作为「矩形右下角」,所以其实我们是取不满 $m^2 * n^2$ 的,但仍然具有超时风险(2021/04/20 Java 测试可通过,C++ 使用 `vector` 会 TLE)。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxSumSubmatrix(int[][] mat, int k) {\n        int m = mat.length, n = mat[0].length;\n        int[][] sum = new int[m + 1][n + 1];\n        for (int i = 1; i <= m; i++) {\n            for (int j = 1; j <= n; j++) {\n                sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + mat[i - 1][j - 1];\n            }\n        }\n        int ans = Integer.MIN_VALUE;\n        for (int i = 1; i <= m; i++) {\n            for (int j = 1; j <= n; j++) {\n                for (int p = i; p <= m; p++) {\n                    for (int q = j; q <= n; q++) {\n                        int cur = sum[p][q] - sum[i - 1][q] - sum[p][j - 1] + sum[i - 1][j - 1];\n                        if (cur <= k) {\n                            ans = Math.max(ans, cur);\n                        } \n                    }\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nint sum[110][110];\nclass Solution {\npublic:\n    int maxSumSubmatrix(vector<vector<int>>& mat, int k) {\n        int m = mat.size(), n = mat[0].size();\n        for(int i = 1; i <= m; i++){\n            for(int j = 1; j <= n; j++){\n                sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + mat[i - 1][j - 1];\n            }\n        }\n        int ans = INT_MIN;\n        for(int i = 1; i <= m; i++){\n            for(int j = 1; j <= n; j++){\n                for(int p = i; p <= m; p++){\n                    for(int q = j; q <= n; q++){\n                        int cur = sum[p][q] - sum[i - 1][q] - sum[p][j - 1] + sum[i - 1][j - 1];\n                        if(cur <= k){\n                            ans = max(ans,cur);\n                        }\n                    }\n                }\n            }\n        }\n        return ans;\n    }\n};\n```\n* 时间复杂度:预处理前缀和数组复杂度为 $O(m * n)$,查找答案的复杂度为 $O(m^2 * n^2)$。整体复杂度为 $O(m^2 * n^2)$。\n* 空间复杂度:$O(m * n)$\n\n---\n\n### 前缀和 & 二分(抽象一维)\n\n我们来细想一下「朴素二维前缀和」解法是如何搜索答案(子矩阵):**通过枚举「左上角」&「右下角」来唯一确定某个矩阵**。\n\n**换句话说是通过枚举 $(i,j)$ 和 $(p,q)$ 来唯一确定子矩阵的四条边,每个坐标点可以看作确定子矩阵的某条边。**\n\n既然要确定的边有四条,我们可以如何降低复杂度呢?\n\n简单的,我们先思考一下同样是枚举的 [1. 两数之和](https://leetcode-cn.com/problems/two-sum/) 问题。\n\n在 [1. 两数之和](https://leetcode-cn.com/problems/two-sum/) 中可以暴力枚举两个数,也可以只枚举其中一个数,然后使用数据结构(哈希表)来加速找另一个数(这是一个通用的「降低枚举复杂度」思考方向)。\n\n对应到本题,我们可以枚举其中三条边,然后使用数据结构来加速找第四条边。\n\n当我们确定了三条边(红色)之后,形成的子矩阵就单纯取决于第四条边的位置(黄色):\n\n于是问题转化为「**如何快速求得第四条边(黄色)的位置在哪**」。\n\n我们可以进一步将问题缩小,考虑矩阵只有一行(一维)的情况:\n\n这时候问题进一步转化为「**在一维数组中,求解和不超过 K 的最大连续子数组之和**」。\n\n对于这个一维问题,我们可以先预处理出「前缀和」,然后枚举子数组的左端点,然后通过「二分」来求解其右端点的位置。\n\n假定我们已经求得一维数组的前缀和数组 `sum`,即可得下标范围 $[i,j]$ 的和为:\n\n$$areaSum(i, j) = sum[j] - sum[i - 1] \\leqslant k$$\n\n经过变形后得:\n\n$$sum[j] \\leqslant k + sum[i - 1]$$\n\n我们有两种思路来最大化 $areaSum(i, j)$:\n\n* 确定(枚举)左端点位置 `i`,求得符合条件的最大右端点 `sum[j]`\n* 确定(枚举)右端点位置 `j`,求得符合条件的最小左端点 `sum[i]`\n\n**对于没有负权值的一维数组,我们可以枚举左端点 `i`,同时利用前缀和的「单调递增」特性,通过「二分」找到符合 $sum[j] \\leqslant k + sum[i - 1]$ 条件的最大值 `sum[j]`,从而求解出答案。**\n\n**但是如果是含有负权值的话,前缀和将会丢失「单调递增」的特性,我们也就无法使用枚举 `i` 并结合「二分」查找 `j` 的做法。**\n\n**这时候需要将过程反过来处理:我们从左到右枚举 `j`,并使用「有序集合」结构维护遍历过的位置,找到符合 $sum[j] - k \\leqslant sum[i]$ 条件的最小值 `sum[i]`,从而求解出答案。**\n\n基于上述分析,解决这样的一维数组问题复杂度是 $O(n\\log{n})$ 的。\n\n将这样的思路应用到二维需要一点点抽象能力。\n\n同时,将一维思路应用到本题(二维),复杂度要么是 $O(m^2 * n\\log{n})$ 要么是 $O(n^2 * m\\log{m})$。\n\n我们先不考虑「最大化二分收益」问题,先假设我们是固定枚举「上下行」和「右边列」,这时候唯一能够确定一个子矩阵则是取决于「左边列」:\n\n**重点是如何与「一维」问题进行关联:显然「目标子矩阵的和」等于「子矩阵的右边列 与 原矩阵的左边列 形成的子矩阵和」-「子矩阵左边列 与 原矩阵左边列 形成的子矩阵和」**\n\n我们可以使用 `area[r]` 代表「**子矩阵的右边列 与 原矩阵的左边列 形成的子矩阵和**」,使用 `area[l - 1]` 代表「**子矩阵的左边列 与 原矩阵的左边列 形成的子矩阵和**」的话,则有:\n\n$$\ntarget = area[r] - area[l - 1] \\leqslant k\n$$\n\n这与我们「一维问题」完全一致,同时由「上下行」&「右边列」可以直接确定 `area[r]` 的大小,通过「有序集合」存储我们遍历 `r` 过程中的所有的 `area[r]` 从而实现「二分」查找符合 $area[r] - k \\leqslant area[l - 1]$ 条件的 **最小** 的 `area[l - 1]`。\n\n至此,我们通过预处理前缀和 + 容斥原理彻底将题目转化为「一维问题」进行来求解。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxSumSubmatrix(int[][] mat, int k) {\n        int m = mat.length, n = mat[0].length;\n\n        // 预处理前缀和\n        int[][] sum = new int[m + 1][n + 1];\n        for (int i = 1; i <= m; i++) {\n            for (int j = 1; j <= n; j++) {\n                sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + mat[i - 1][j - 1];\n            }\n        }\n\n        int ans = Integer.MIN_VALUE;\n        // 遍历子矩阵的上边界\n        for (int top = 1; top <= m; top++) {\n            // 遍历子矩阵的下边界\n            for (int bot = top; bot <= m; bot++) {\n                // 使用「有序集合」维护所有遍历到的右边界\n                TreeSet<Integer> ts = new TreeSet<>();\n                ts.add(0);\n                // 遍历子矩阵的右边界\n                for (int r = 1; r <= n; r++) {\n                    // 通过前缀和计算 right\n                    int right = sum[bot][r] - sum[top - 1][r];\n                    // 通过二分找 left\n                    Integer left = ts.ceiling(right - k);\n                    if (left != null) {\n                        int cur = right - left;\n                        ans = Math.max(ans, cur);\n                    }\n                    // 将遍历过的 right 加到有序集合\n                    ts.add(right);\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxSumSubmatrix(vector<vector<int>>& mat, int k) {\n        int m = mat.size(), n = mat[0].size();\n        vector<vector<int>> sum(m + 1,vector<int>(n + 1,0));\n        for(int i = 1; i <= m; i++){\n            for(int j = 1; j <= n; j++){\n                sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + mat[i - 1][j - 1];\n            }\n        }\n        int ans = INT_MIN;\n        for(int top = 1; top <= m; top++){\n            for(int bot = top; bot <= m; bot++){\n                set<int> st;\n                st.insert(0);\n                for(int r = 1; r <= n; r++){\n                    int right = sum[bot][r] - sum[top - 1][r];\n                    auto left = st.lower_bound(right - k);\n                    if(left != st.end()){\n                        int cur = right - *left;\n                        ans = max(ans,cur);\n                    }\n                    st.insert(right);\n                }\n            }\n        }\n        return ans;\n    }\n};\n```\n* 时间复杂度:枚举上下边界复杂度为 $O(m^2)$;枚举右边界为 $O(n)$,使用 `TreeSet`(基于红黑树)存储和查找左边界复杂度为 $O(\\log{n})$。整体复杂度为 $O(m^2 * n\\log{n})$\n* 空间复杂度:$O(m * n)$\n\n---\n\n### 最大化「二分」效益\n\n上述解法中,我们先枚举的是「上下行」和「右边列」,然后通过 `TreeSet` 来「二分」出符合条件的「左边列」。\n\n事实上,我们需要将「二分过程」应用到数值较大的行或者列之中,这样才能最大化我们查找的效率(同时也回答了本题的进阶部分)。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxSumSubmatrix(int[][] mat, int k) {\n        int m = mat.length, n = mat[0].length;\n        int[][] sum = new int[m + 1][n + 1];\n        for (int i = 1; i <= m; i++) {\n            for (int j = 1; j <= n; j++) {\n                sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + mat[i - 1][j - 1];\n            }\n        }\n        // 固定的是否为右边界\n        boolean isRight = n > m;\n        int ans = Integer.MIN_VALUE;\n        for (int i = 1; i <= (isRight ? m : n); i++) {\n            for (int j = i; j <= (isRight ? m : n); j++) {\n                TreeSet<Integer> ts = new TreeSet<>();\n                ts.add(0);\n                for (int fixed = 1; fixed <= (isRight ? n : m); fixed++) {\n                    int a = isRight ? sum[j][fixed] - sum[i - 1][fixed] : sum[fixed][j] - sum[fixed][i - 1];\n                    Integer b = ts.ceiling(a - k);\n                    if (b != null) {\n                        int cur = a - b;\n                        ans = Math.max(ans, cur);\n                    }\n                    ts.add(a);\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxSumSubmatrix(vector<vector<int>>& mat, int k) {\n        int m = mat.size(), n = mat[0].size();\n        vector<vector<int>> sum(m + 1,vector<int>(n + 1,0));\n        for(int i = 1; i <= m; i++){\n            for(int j = 1; j <= n; j++){\n                sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + mat[i - 1][j - 1];\n            }\n        }\n        bool isRight = n > m;\n        int ans = INT_MIN;\n        for(int i = 1; i <= (isRight ? m : n); i++){\n            for(int j = i; j <= (isRight ? m : n); j++){\n                set<int> st;\n                st.insert(0);\n                for(int fixed = 1; fixed <= (isRight ? n : m); fixed++){\n                    int a = isRight ? sum[j][fixed] - sum[i - 1][fixed] : sum[fixed][j] - sum[fixed][i - 1];\n                    auto b = st.lower_bound(a - k);\n                    if(b != st.end()){\n                        int cur = a - *b;\n                        ans = max(ans,cur);\n                    }\n                    st.insert(a);\n                }\n            }\n        }\n        return ans;\n    }\n};\n```\n* 时间复杂度:预处理「每行」或「每列」的前缀和,复杂度为 $O(m * n)$;枚举子矩阵的「上下行」或「左右行」,复杂度为 $O(\\min(m, n)^2)$;结合二维前缀和套用一维最大连续子数组解决方案,复杂度为$\\max(m, n)\\log{\\max(m, n)}$。整体复杂度为 $O(\\min(m, n)^2 * \\max(m, n)\\log{\\max(m, n)})$\n* 空间复杂度:$O(m * n)$\n\n---\n\n### 空间优化\n\n不难发现,我们在原矩阵搜索目标子矩阵的过程是严格的「从上到下」&「从左到右」的。\n\n因此我们可以将计算前缀和的逻辑下放到搜索子矩阵的循环里去做,从而将 $O(m * n)$ 的空间复杂度下降到 $O(\\max(m,n))$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxSumSubmatrix(int[][] mat, int k) {\n        int m = mat.length, n = mat[0].length;\n        boolean isRight = n > m;\n        int[] sum = isRight ? new int[n + 1] : new int[m + 1];\n        int ans = Integer.MIN_VALUE;\n        for (int i = 1; i <= (isRight ? m : n); i++) {\n            Arrays.fill(sum, 0);\n            for (int j = i; j <= (isRight ? m : n); j++) {\n                TreeSet<Integer> ts = new TreeSet<>();\n                ts.add(0);\n                int a = 0;\n                for (int fixed = 1; fixed <= (isRight ? n : m); fixed++) {\n                    sum[fixed] += isRight ? mat[j - 1][fixed - 1] : mat[fixed - 1][j - 1] ;\n                    a += sum[fixed];\n                    Integer b = ts.ceiling(a - k);\n                    if (b != null) {\n                        int cur = a - b;\n                        ans = Math.max(ans, cur);\n                    }\n                    ts.add(a);\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxSumSubmatrix(vector<vector<int>>& mat, int k) {\n        int m = mat.size(), n = mat[0].size();\n        bool isRight = n > m;\n        vector<int> sum((isRight ? n + 1 : m + 1), 0);\n        int ans = INT_MIN;\n        for(int i = 1; i <= (isRight ? m : n); i++){\n            fill(sum.begin(),sum.end(),0);\n            for(int j = i; j <= (isRight ? m : n); j++){\n                set<int> st;\n                st.insert(0);\n                int a = 0;\n                for(int fixed = 1; fixed <= (isRight ? n : m); fixed++){\n                    sum[fixed] += isRight ? mat[j - 1][fixed - 1] : mat[fixed - 1][j - 1];\n                    a += sum[fixed];\n                    auto b = st.lower_bound(a - k);\n                    if(b != st.end()){\n                        int cur = a - *b;\n                        ans = max(ans,cur);\n                    }\n                    st.insert(a);\n                }\n            }\n        }\n        return ans;\n    }\n};\n```\n* 时间复杂度:预处理「每行」或「每列」的前缀和,复杂度为 $O(m * n)$;枚举子矩阵的「上下行」或「左右行」,复杂度为 $O(\\min(m, n)^2)$;结合二维前缀和套用一维最大连续子数组解决方案,复杂度为$\\max(m, n)\\log{max(m, n)}$。整体复杂度为 $O(\\min(m, n)^2 * \\max(m, n)\\log{\\max(m, n)})$\n* 空间复杂度:$O(\\max(m, n))$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.363` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/361-370/367. 有效的完全平方数（简单）.md", "url_title": "367. 有效的完全平方数", "url": "https://leetcode-cn.com/problems/valid-perfect-square/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-g5el/", "difficulty": "简单", "tags": ["二分", "数学"], "question": "给定一个 正整数 $num$ ,编写一个函数,如果 $num$ 是一个完全平方数,则返回 $true$ ,否则返回 $false$ 。\n\n进阶:不要使用任何内置的库函数,如  `sqrt`。\n\n示例 1:\n```\n输入:num = 16\n\n输出:true\n```\n示例 2:\n```\n输入:num = 14\n\n输出:false\n```\n\n提示:\n* $1 <= num <= 2^{31} - 1$", "solution": "### 二分\n\n假如答案为 $ans$,那么以 $ans$ 为分割点的数轴上具有二段性:\n\n* 小于 $ans$ 的一段 $x$ 必然不满足 $x * x \\geq num$;\n* 大于等于 $ans$ 的一段 $x$ 必然满足 $x * x \\geq num$。\n\n因此可以通过「二分」来找到分割点 $ans$。\n\n代码:\n```Java\nclass Solution {\n    public boolean isPerfectSquare(int num) {\n        long l = 0, r = num;\n        while (l < r) {\n            long mid = l + r + 1 >> 1;\n            if (mid * mid <= num) l = mid;\n            else r = mid - 1;\n        }\n        return r * r == num;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 数学 \n\n我们知道对于一个完全平方数而言,可以写成如下形式:\n\n$$\nnum = n^2 = 1 + 3 + 5 + ... + (2 * n - 1)\n$$\n\n因此另外一种做法是对 $num$ 进行不断的奇数试减,如果最终能够减到 $0$,说明 $num$ 可展开成如 $1+3+5+...+(2*n-1)$ 的形式,$num$ 为完全平方数。\n\n代码:\n```Java\nclass Solution {\n    public boolean isPerfectSquare(int num) {\n        int x = 1;\n        while (num > 0) {\n            num -= x;\n            x += 2;\n        }\n        return num == 0;\n    }\n}\n```\n* 时间复杂度:$O(\\sqrt{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.367` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/361-370/368. 最大整除子集（中等）.md", "url_title": "368. 最大整除子集", "url": "https://leetcode-cn.com/problems/largest-divisible-subset/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-0a3jc/", "difficulty": "中等", "tags": ["序列 DP"], "question": "给你一个由 无重复 正整数组成的集合 nums ,请你找出并返回其中最大的整除子集 answer ,子集中每一元素对 (answer[i], answer[j]) 都应当满足:\n* answer[i] % answer[j] == 0 ,或\n* answer[j] % answer[i] == 0\n\n如果存在多个有效解子集,返回其中任何一个均可。\n\n示例 1:\n```\n输入:nums = [1,2,3]\n\n输出:[1,2]\n\n解释:[1,3] 也会被视为正确答案。\n```\n示例 2:\n```\n输入:nums = [1,2,4,8]\n\n输出:[1,2,4,8]\n```\n\n提示:\n* 1 <= nums.length <= 1000\n* 1 <= nums[i] <= 2 * $10^9$\n* nums 中的所有整数 互不相同", "solution": "### 基本分析\n\n根据题意:**对于符合要求的「整除子集」中的任意两个值,必然满足「较大数」是「较小数」的倍数。**\n\n数据范围是 $10^3$,我们不可能采取获取所有子集,再检查子集是否合法的爆搜解法。\n\n通常「递归」做不了,我们就往「递推」方向去考虑。\n\n**由于存在「整除子集」中任意两个值必然存在倍数/约数关系的性质,我们自然会想到对 `nums` 进行排序,然后从集合 `nums` 中从大到小进行取数,每次取数只考虑当前决策的数是否与「整除子集」中的最后一个数成倍数关系即可。**\n\n这时候你可能会想枚举每个数作为「整除子集」的起点,然后从前往后遍历一遍,每次都将符合「与当前子集最后一个元素成倍数」关系的数加入答案。\n\n举个🌰,假设有原数组 `[1,2,4,8]`,“或许”我们期望的决策过程是:\n\n1. 遍历到数字 `1`,此时「整除子集」为空,加到「整除子集」中;\n2. 遍历到数字 `2`,与「整除子集」的最后一个元素(`1`)成倍数关系,加到「整除子集」中;\n3. 遍历到数字 `4`,与「整除子集」的最后一个元素(`2`)成倍数关系,自然也与 `2` 之前的元素成倍数关系,加到「整除子集」中;\n4. 遍历到数字 `8`,与「整除子集」的最后一个元素(`4`)成倍数关系,自然也与 `4` 之前的元素成倍数关系,加到「整除子集」中。\n\n**但这样的做法只能够确保得到「合法解」,无法确保得到的是「最长整除子集」**。\n\n当时担心本题数据太弱,上述错误的解法也能够通过,所以还特意实现了一下,还好被卡住了(🤣\n\n同时也得到这个反例:`[9,18,54,90,108,180,360,540,720]`,如果按照我们上述逻辑,我们得到的是 `[9,18,54,108,540]` 答案(长度为 5),但事实上存在更长的「整除子集」: `[9,18,90,180,360,720]`(长度为 6)。\n\n**其本质是因为同一个数的不同倍数之间不存在必然的「倍数/约数关系」,而只存在「具有公约数」的性质,这会导致我们「模拟解法」错过最优解。**\n\n比如上述 🌰,`54` & `90` 和 `18` 存在倍数关系,但两者本身不存在倍数关系。\n\n因此当我们决策到某一个数 `nums[i]` 时(`nums` 已排好序),我们无法直接将 `nums[i]` 直接接在符合「约数关系」的、最靠近位置 `i` 的数后面,而是要**检查位置 `i` 前面的所有符合「约数关系」的位置,找一个已经形成「整除子集」长度最大的数**。\n\n**换句话说,当我们对 `nums` 排好序并从前往后处理时,在处理到 `nums[i]` 时,我们希望知道位置 `i` 之前的下标已经形成的「整除子集」长度是多少,然后从中选一个最长的「整除子集」,将 `nums[i]` 接在后面(前提是符合「倍数关系」)。**\n\n---\n\n### 动态规划\n\n基于上述分析,我们不难发现这其实是一个序列 DP 问题:**某个状态的转移依赖于与前一个状态的关系。即 `nums[i]` 能否接在 `nums[j]` 后面,取决于是否满足 `nums[i] % nums[j] == 0` 条件。**\n\n可看做是「最长上升子序列」问题的变形题。\n\n**定义 $f[i]$ 为考虑前 `i` 个数字,且以第 `i` 个数为结尾的最长「整除子集」长度。**\n\n我们不失一般性的考虑任意位置 `i`,存在两种情况:\n\n* 如果在 `i` 之前找不到符合条件 `nums[i] % nums[j] == 0` 的位置 `j`,那么 `nums[i]` 不能接在位置 `i` 之前的任何数的后面,只能自己独立作为「整除子集」的第一个数,此时状态转移方程为 $f[i] = 1$;\n* 如果在 `i` 之前能够找到符合条件的位置 `j`,则取所有符合条件的 `f[j]` 的最大值,代表如果希望找到以 `nums[i]` 为结尾的最长「整除子集」,需要将 `nums[i]` 接到符合条件的最长的 `nums[j]` 后面,此时状态转移方程为 $f[i] = f[j] + 1$。\n\n同时由于我们需要输出具体方案,需要额外使用 `g[]` 数组来记录每个状态是由哪个状态转移而来。\n\n**定义 $g[i]$ 为记录 $f[i]$ 是由哪个下标的状态转移而来,如果 $f[i] = f[j] + 1$, 则有 $g[i] = j$。**\n\n对于求方案数的题目,多开一个数组来记录状态从何转移而来是最常见的手段。\n\n当我们求得所有的状态值之后,可以对 `f[]` 数组进行遍历,取得具体的最长「整除子集」长度和对应下标,然后使用 `g[]` 数组进行回溯,取得答案。\n\n代码:\n```Java\nclass Solution {\n    public List<Integer> largestDivisibleSubset(int[] nums) {\n        Arrays.sort(nums);\n        int n = nums.length;\n        int[] f = new int[n];\n        int[] g = new int[n];\n        for (int i = 0; i < n; i++) {\n            // 至少包含自身一个数,因此起始长度为 1,由自身转移而来\n            int len = 1, prev = i;\n            for (int j = 0; j < i; j++) {\n                if (nums[i] % nums[j] == 0) {\n                    // 如果能接在更长的序列后面,则更新「最大长度」&「从何转移而来」\n                    if (f[j] + 1 > len) {\n                        len = f[j] + 1;\n                        prev = j;\n                    }\n                }\n            }\n            // 记录「最终长度」&「从何转移而来」\n            f[i] = len;\n            g[i] = prev;\n        }\n        \n        // 遍历所有的 f[i],取得「最大长度」和「对应下标」\n        int max = -1, idx = -1;\n        for (int i = 0; i < n; i++) {\n            if (f[i] > max) {\n                idx = i;\n                max = f[i];\n            }\n        }\n\n        // 使用 g[] 数组回溯出具体方案\n        List<Integer> ans = new ArrayList<>();\n        while (ans.size() != max) {\n            ans.add(nums[idx]);\n            idx = g[idx];\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 证明\n\n**之所以上述解法能够成立,问题能够转化为「最长上升子序列(LIS)」问题进行求解,本质是利用了「全序关系」中的「可传递性」。**\n\n在 LIS 问题中,我们是利用了「关系运算符 $\\geqslant$ 」的传递性,因此当我们某个数 `a` 能够接在 `b` 后面,只需要确保 $a \\geqslant b$ 成立,即可确保 `a` 大于等于 `b` 之前的所有值。\n\n那么同理,如果我们想要上述解法成立,我们还需要证明如下内容:\n\n* #### 「倍数/约数关系」具有传递性\n由于我们将 `nums[i]` 往某个数字后面接时(假设为 `nums[j]`),只检查了其与 `nums[j]` 的关系,并没有去检查 `nums[i]` 与 `nums[j]` 之前的数值是否具有「倍数/约数关系」。\n\n换句话说,我们只确保了最终答案 `[a1, a2, a3, ..., an]` 相邻两数值之间具有「倍数/约数关系」,并不明确任意两值之间具有「倍数/约数关系」。\n\n因此需要证得由 $a | b$ 和 $b | c$,可推导出 $a | c$ 的传递性:\n\n由 $a | b$ 可得 $b = x * a$\n由 $b | c$ 可得 $c = y * b$\n\n最终有 $c = y * b = y * x * a$,由于 $x$ 和 $y$ 都是整数,因此可得 $a | c$。\n\n得证「倍数/约数关系」具有传递性。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.368` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/371-380/371. 两整数之和（中等）.md", "url_title": "371. 两整数之和", "url": "https://leetcode-cn.com/problems/sum-of-two-integers/solution/gong-shui-san-xie-shi-yong-wei-yun-suan-4hpb7/", "difficulty": "中等", "tags": ["位运算"], "question": "给你两个整数 `a` 和 `b` ,不使用 运算符 `+` 和 `-`,计算并返回两整数之和。\n\n示例 1:\n```\n输入:a = 1, b = 2\n\n输出:3\n```\n示例 2:\n```\n输入:a = 2, b = 3\n\n输出:5\n``` \n\n提示:\n* -1000 <= a, b <= 1000", "solution": "### 位运算\n\n一个朴素的做法是使用「位运算」,利用二进制的「逢二进一」和「`int` 二进制表示长度为 $32$」,我们可以从低位往高位进行处理,处理过程中使用变量 $t$ 记录进位信息。\n\n然后对两数当前位进行分情况讨论:\n\n* 两个当前位均为 $1$:此时当前位是什么取决于前一位的进位情况,即有 `ans |= (t << i)`,同时进位 $t = 1$;\n* 两个当前位只有一位是 $1$:此时当前位是什么取决于前一位的进位情况(整理后可统一为 `ans |= ((1 ^ t) << i)`:\n    * 前一进位若为 $1$,结合该位为 $1$,则有当前位为 $0$,进位不变 $t = 1$;\n    * 前一进位若为 $0$,结合该位为 $1$,则有当前位为 $1$,进位不变 $t = 0$;\n* 两个当前位为 $0$:此时当前位是什么取决于前一位的进位情况,则有 `ans |= (t << i)`,同时进位 $t = 0$。\n\n代码:\n```Java\nclass Solution {\n    public int getSum(int a, int b) {\n        int ans = 0;\n        for (int i = 0, t = 0; i < 32; i++) {\n            int u1 = (a >> i) & 1, u2 = (b >> i) & 1;\n            if (u1 == 1 && u2 == 1) {\n                ans |= (t << i);\n                t = 1;\n            } else if (u1 == 1 || u2 == 1) {\n                ans |= ((1 ^ t) << i);\n            } else {\n                ans |= (t << i);\n                t = 0;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(C)$,$C$ 为常数,固定为 $32$\n* 空间复杂度:$O(1)$\n\n---\n\n### 递归\n\n在彻底理解「解法一」后,不难发现「解法一」中本质是分别对两数的当前位进行“拆分”求解。\n\n先计算原始的 $a$ 的和原始 $b$ 在不考虑进位的情况下的结果,结果为 `a ^ b`,然后在此基础上,考虑将进位累加进来,累加操作可以递归使用 `getSum` 来处理。\n\n问题转化为如何求得 $a$ 和 $b$ 的进位值。\n\n不难发现,当且仅当 $a$ 和 $b$ 的当前位均为 $1$,该位才存在进位,同时进位回应用到当前位的下一位(左边的一边,高一位),因此最终的进位结果为 `(a & b) << 1`。\n\n因此,递归调用 `getSum(a ^ b, (a & b) << 1)` 我们可以得到最终答案。\n\n最后还要考虑,该拆分过程何时结束。\n\n由于在进位结果 `(a & b) << 1` 中存在左移操作,因此最多执行 $32$ 次的递归操作之后,该值会变为 $0$,而 $0$ 与任何值 $x$ 相加结果均为 $x$。\n\n代码:\n```Java\nclass Solution {\n    public int getSum(int a, int b) {\n        return b == 0 ? a : getSum(a ^ b, (a & b) << 1);\n    }\n}\n```\n* 时间复杂度:令 $C$ 为常数,固定为 $32$,最多执行 $C$ 次的 `(a & b) << 1`,递归过程结束。复杂度为 $O(C)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.371` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/371-380/372. 超级次方（中等）.md", "url_title": "372. 超级次方", "url": "https://leetcode-cn.com/problems/super-pow/solution/gong-shui-san-xie-di-gui-kuai-su-mi-ying-yx1j/", "difficulty": "中等", "tags": ["数学", "快速幂"], "question": "你的任务是计算 `ab` 对 $1337$ 取模,`a` 是一个正整数,`b` 是一个非常大的正整数且会以数组形式给出。\n\n示例 1:\n```\n输入:a = 2, b = [3]\n\n输出:8\n```\n示例 2:\n```\n输入:a = 2, b = [1,0]\n\n输出:1024\n```\n示例 3:\n```\n输入:a = 1, b = [4,3,3,8,5,2]\n\n输出:1\n```\n示例 4:\n```\n输入:a = 2147483647, b = [2,0,0]\n\n输出:1198\n```\n\n提示:\n* $1 <= a <= 2^{31} - 1$\n* $1 <= b.length <= 2000$\n* $0 <= b[i] <= 9$\n* b 不含前导 0", "solution": "### 递归 + 快速幂(可选)\n\n根据题意,要我们求得的是 $a^b \\bmod {1337}$ 的值,其中 $b$ 是以数组形式给出。\n\n刚一看是一道快速幂的题目(事实上也确实可以使用快速幂,但不是必须),由于 $b$ 是数组形式,因此我们还需要对其进行分解。\n\n假设 $b$ 所代表的数值为 $K$,则有:\n\n$$\na^{K} = a^{(\\left \\lfloor \\frac{K}{10} \\right \\rfloor * 10) + (K \\bmod 10)} = a^{(\\left \\lfloor \\frac{K}{10} \\right \\rfloor * 10)} * a^{(K \\bmod 10)} = ({a^{\\left \\lfloor \\frac{K}{10} \\right \\rfloor}) ^  {10}} * a^{(K \\bmod 10)}\n$$\n\n也就是说,我们每次只需要计算 $b$ 数组的最后一位作为次方的值即可将问题规模缩小。\n\n上述公式可能不好直接理解,举个🌰,设我们的 $a$ 为 $99$,要计算的 $b$ 数组所代表的数值为 $K = 2345$,那么其计算过程可以分解为:\n\n0. $a^K = 99^{2345}$\n1. $99^{2345} = 99^{234 * 10 + 5}$\n2. $99^{234 * 10 + 5} = 99^{234 * 10} * 99^{5}$\n3. $99^{234 * 10} * 99^{5} = {(99^{234})}^{10} * 99^{5}$\n...\n\n可见,真正涉及计算次方的操作,所用到的次方都是一个 $10$ 以内的数字,因此并非一定要使用快速幂。\n\n代码($P2$ 为不使用快速幂):\n```Java\nclass Solution {\n    int MOD = 1337;\n    public int superPow(int a, int[] b) {\n        return dfs(a, b, b.length - 1);\n    }\n    int dfs(int a, int[] b, int u) {\n        if (u == -1) return 1;\n        return qpow(dfs(a, b, u - 1), 10) * qpow(a, b[u]) % MOD;\n    }\n    int qpow(int a, int b) {\n        int ans = 1;\n        a %= MOD;\n        while (b != 0) {\n            if ((b & 1) != 0) ans = ans * a % MOD;\n            a = a * a % MOD;\n            b >>= 1;\n        }\n        return ans;\n    }\n}\n```\n\n```Java\nclass Solution {\n    int MOD = 1337;\n    public int superPow(int a, int[] b) {\n        return dfs(a, b, b.length - 1);\n    }\n    int dfs(int a, int[] b, int u) {\n        if (u == -1) return 1;\n        return pow(dfs(a, b, u - 1), 10) * pow(a, b[u]) % MOD;\n    }\n    int pow(int a, int b) {\n        int ans = 1;\n        a %= MOD;\n        while (b-- > 0) ans = ans * a % MOD;\n        return ans;\n    }\n}\n```\n* 时间复杂度:假设 $b$ 数组所代表的数字为 $K$,使用快速幂的复杂度为 $O(\\log{K})$,或者说是 $O(n * \\log{10})$,其中 $n$ 为数组 $b$ 的长度,数字 $10$ 所代表的含义是计算一个次方为 $10$ 以内的值;而不使用快速幂的复杂度为 $O(n * 10)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.372` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/371-380/373. 查找和最小的K对数字（中等）.md", "url_title": "373. 查找和最小的K对数字", "url": "https://leetcode-cn.com/problems/find-k-pairs-with-smallest-sums/solution/gong-shui-san-xie-duo-lu-gui-bing-yun-yo-pgw5/", "difficulty": "中等", "tags": ["优先队列(堆)", "二分", "多路归并"], "question": "给定两个以升序排列的整数数组 `nums1` 和 `nums2` , 以及一个整数 `k` 。\n\n定义一对值 $(u,v)$,其中第一个元素来自 `nums1`,第二个元素来自 `nums2`。\n\n请找到和最小的 `k` 个数对 $(u_1,v_1),  (u_2,v_2)  ...  (u_k,v_k)$ 。 \n\n示例 1:\n```\n输入: nums1 = [1,7,11], nums2 = [2,4,6], k = 3\n\n输出: [1,2],[1,4],[1,6]\n\n解释: 返回序列中的前 3 对数:\n     [1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6]\n```\n示例 2:\n```\n输入: nums1 = [1,1,2], nums2 = [1,2,3], k = 2\n\n输出: [1,1],[1,1]\n\n解释: 返回序列中的前 2 对数:\n     [1,1],[1,1],[1,2],[2,1],[1,2],[2,2],[1,3],[1,3],[2,3]\n```\n示例 3:\n```\n输入: nums1 = [1,2], nums2 = [3], k = 3 \n\n输出: [1,3],[2,3]\n\n解释: 也可能序列中所有的数对都被返回:[1,3],[2,3]\n```\n\n提示:\n* $1 <= nums1.length, nums2.length <= 10^4$\n* $-10^9 <= nums1[i], nums2[i] <= 10^9$\n* $nums1, nums2 均为升序排列$\n* $1 <= k <= 1000$", "solution": "### 基本分析 \n\n这道题和 [(题解) 786. 第 K 个最小的素数分数](https://leetcode-cn.com/problems/k-th-smallest-prime-fraction/solution/gong-shui-san-xie-yi-ti-shuang-jie-you-x-8ymk/) 几乎是一模一样,先做哪一道都是一样的,难度上没有区别 🤣 \n\n最常规的做法是使用「多路归并」,还不熟悉「多路归并」的同学,建议先学习前置🧀:[多路归并入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247490029&idx=1&sn=bba9ddff88d247db310406ee418d5a15&chksm=fd9cb2f2caeb3be4b1f84962677337dcb5884374e5b6b80340834eaff79298d11151da2dd5f7&token=252055586&lang=zh_CN#rd),里面讲述了如何从「朴素优先队列」往「多路归并」进行转换。\n\n---\n\n### 多路归并\n\n令 $nums1$ 的长度为 $n$,$nums2$ 的长度为 $m$,所有的点对数量为 $n * m$。\n\n其中每个 $nums1[i]$ 参与所组成的点序列为:\n\n$$\n[(nums1[0], nums2[0]), (nums1[0], nums2[1]), ..., (nums1[0], nums2[m - 1])]\\\\\n[(nums1[1], nums2[0]), (nums1[1], nums2[1]), ..., (nums1[1], nums2[m - 1])]\\\\\n...\\\\\n[(nums1[n - 1], nums2[0]), (nums1[n - 1], nums2[1]), ..., (nums1[n - 1], nums2[m - 1])]\\\\\n$$\n\n由于 $nums1$ 和 $nums2$ 均已按升序排序,因此每个 $nums1[i]$ 参与构成的点序列也为升序排序,这引导我们使用「多路归并」来进行求解。\n\n具体的,起始我们将这 $n$ 个序列的首位元素(点对)以二元组 $(i, j)$ 放入优先队列(小根堆),其中 $i$ 为该点对中 $nums1[i]$ 的下标,$j$ 为该点对中 $nums2[j]$ 的下标,这步操作的复杂度为 $O(n\\log{n})$。这里也可以得出一个小优化是:我们始终确保 $nums1$ 为两数组中长度较少的那个,然后通过标识位来记录是否发生过交换,确保答案的点顺序的正确性。\n\n每次从优先队列(堆)中取出堆顶元素(含义为当前未被加入到答案的所有点对中的最小值),加入答案,并将该点对所在序列的下一位(如果有)加入优先队列中。\n\n举个 🌰,首次取出的二元组为 $(0, 0)$,即点对 $(nums1[0], nums2[0])$,取完后将序列的下一位点对 $(nums1[0], nums2[1])$ 以二元组 $(0, 1)$ 形式放入优先队列。\n\n可通过「反证法」证明,每次这样的「取当前,放入下一位」的操作,可以确保当前未被加入答案的所有点对的最小值必然在优先队列(堆)中,即前 $k$ 个出堆的元素必然是所有点对的前 $k$ 小的值。\n\nJava 代码:\n```Java\nclass Solution {\n    boolean flag = true;\n    public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {\n        List<List<Integer>> ans = new ArrayList<>();\n        int n = nums1.length, m = nums2.length;\n        if (n > m && !(flag = false)) return kSmallestPairs(nums2, nums1, k);\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->(nums1[a[0]]+nums2[a[1]])-(nums1[b[0]]+nums2[b[1]]));\n        for (int i = 0; i < Math.min(n, k); i++) q.add(new int[]{i, 0});\n        while (ans.size() < k && !q.isEmpty()) {\n            int[] poll = q.poll();\n            int a = poll[0], b = poll[1];\n            ans.add(new ArrayList<>(){{\n                add(flag ? nums1[a] : nums2[b]);\n                add(flag ? nums2[b] : nums1[a]);\n            }});\n            if (b + 1 < m) q.add(new int[]{a, b + 1});\n        }\n        return ans;\n    }\n}\n```\nPython3 代码:\n```Python3\nclass Solution:\n    def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:\n        flag, ans = (n := len(nums1)) > (m := len(nums2)), []\n        if flag:\n            n, m, nums1, nums2 = m, n, nums2, nums1\n        pq = []\n        for i in range(min(n, k)):\n            heapq.heappush(pq, (nums1[i] + nums2[0], i, 0))\n        while len(ans) < k and pq:\n            _, a, b = heapq.heappop(pq)\n            ans.append([nums2[b], nums1[a]] if flag else [nums1[a], nums2[b]])\n            if b + 1 < m:\n                heapq.heappush(pq, (nums1[a] + nums2[b + 1], a, b + 1))\n        return ans\n```\nGolang 代码:\n```Golang\nfunc kSmallestPairs(nums1 []int, nums2 []int, k int) [][]int {\n    n, m, ans := len(nums1), len(nums2), [][]int{}\n    flag := n > m\n    if flag {\n        n, m, nums1, nums2 = m, n, nums2, nums1\n    }\n    if n > k {\n        n = k\n    }\n    pq := make(hp, n)\n    for i := 0; i < n; i++ {\n        pq[i] = []int{nums1[i] + nums2[0], i, 0}\n    }\n    heap.Init(&pq)\n    for pq.Len() > 0 && len(ans) < k {\n        poll := heap.Pop(&pq).([]int)\n        a, b := poll[1], poll[2] \n        if flag{\n            ans = append(ans, []int{nums2[b], nums1[a]})\n        }else{\n            ans = append(ans, []int{nums1[a], nums2[b]})\n        }\n        if b < m - 1 {\n            heap.Push(&pq, []int{nums1[a] + nums2[b + 1], a, b + 1})\n        }\n    }\n    return ans\n}\n// 最小堆模板\ntype hp [][]int\nfunc (h hp) Len() int            { return len(h) }\nfunc (h hp) Less(i, j int) bool  { return h[i][0] < h[j][0] }\nfunc (h hp) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }\nfunc (h *hp) Push(v interface{}) { *h = append(*h, v.([]int)) }\nfunc (h *hp) Pop() interface{}   { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }\n```\n* 时间复杂度:令 $M$ 为 $n$、$m$ 和 $k$ 三者中的最小值,复杂度为 $O(M + k) \\times \\log{M})$\n* 空间复杂度:$O(M)$\n\n---\n\n### 二分\n\n我们还能够使用多次「二分」来做。\n\n假设我们将所有「数对和」按照升序排序,两端的值分别为 $l = nums1[0] + nums2[0]$ 和 $r = nums1[n - 1] + nums2[m - 1]$。\n\n因此我们可以在值域 $[l, r]$ 上进行二分,找到第一个满足「点对和小于等于 $x$ 的,且数量超过 $k$ 的值 $x$」。\n\n之所以能够二分,是因为 $x$ 所在的点对和数轴上具有二段性:\n\n* 点对和小于 $x$ 的点对数量少于 $k$ 个;\n* 点对和大于等于 $x$ 的点对数量大于等于 $k$ 个。\n\n判定小于等于 $x$ 的点对数量是否大于等于 $k$ 个这一步可直接使用循环来做,由于二分是从中间值开始,这一步不会出现跑满两层循环的情况。\n\n当二分出第 $k$ 小的值为 $x$ 后,由于存在不同点对的点对和值相等,我们需要先将所有点对和小于等于 $x$ 的值加入答案,然后酌情把值等于 $x$ 的点对加入答案,知道满足答案数量为 $k$。\n\n找值为 $x$ 的所有点对这一步,可以通过枚举 $nums1[i]$,然后在 $nums2$ 上二分目标值 $x - nums1[i]$ 的左右端点来做。\n\n最后,在所有处理过程中,我们都可以利用答案数组的大小与 $k$ 的关系做剪枝。\n\nJava 代码:\n```Java\nclass Solution {\n    int[] nums1, nums2;\n    int n, m;\n    public List<List<Integer>> kSmallestPairs(int[] n1, int[] n2, int k) {\n        nums1 = n1; nums2 = n2;\n        n = nums1.length; m = nums2.length;\n        List<List<Integer>> ans = new ArrayList<>();\n        int l = nums1[0] + nums2[0], r = nums1[n - 1] + nums2[m - 1];\n        while (l < r) {\n            int mid = (int)(0L + l + r >> 1);\n            if (check(mid, k)) r = mid;\n            else l = mid + 1;\n        }\n        int x = r;\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                if (nums1[i] + nums2[j] < x) {\n                    List<Integer> temp = new ArrayList<>();\n                    temp.add(nums1[i]); temp.add(nums2[j]);\n                    ans.add(temp);\n                } else break;\n            }\n        }\n        for (int i = 0; i < n && ans.size() < k; i++) {\n            int a = nums1[i], b = x - a;\n            int c = -1, d = -1;\n            l = 0; r = m - 1;\n            while (l < r) {\n                int mid = (int)(0L + l + r >> 1);\n                if (nums2[mid] >= b) r = mid;\n                else l = mid + 1;\n            }\n            if (nums2[r] != b) continue;\n            c = r;\n            l = 0; r = m - 1;\n            while (l < r) {\n                int mid = (int)(0L + l + r + 1) >> 1;\n                if (nums2[mid] <= b) l = mid;\n                else r = mid - 1;\n            }\n            d = r;\n            for (int p = c; p <= d && ans.size() < k; p++) {\n                List<Integer> temp = new ArrayList<>();\n                temp.add(a); temp.add(b);\n                ans.add(temp);\n            }\n        }\n        return ans;\n    }\n    boolean check(int x, int k) {\n        int ans = 0;\n        for (int i = 0; i < n && ans < k; i++) {\n            for (int j = 0; j < m && ans < k; j++) {\n                if (nums1[i] + nums2[j] <= x) ans++;\n                else break;\n            }\n        }\n        return ans >= k;\n    }\n}\n```\n* 时间复杂度:假设点对和的值域大小范围为 $M$,第一次二分的复杂度为 $O((n \\times m) \\times \\log{M})$;统计点对和值小于目标值 $x$ 的复杂度为 $O(n \\times m)$;统计所有点对和等于目标值的复杂度为 $O(\\max(n \\times \\log{m}, k))$(整个处理过程中利用了大小关系做了剪枝,大多循环都不会跑满,实际计算量会比理论分析的要低)\n* 空间复杂度:$O(k)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.373` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/371-380/374. 猜数字大小（简单）.md", "url_title": "374. 猜数字大小", "url": "https://leetcode-cn.com/problems/guess-number-higher-or-lower/solution/gong-shui-san-xie-shi-yong-jiao-hu-han-s-tocm/", "difficulty": "简单", "tags": ["二分"], "question": "猜数字游戏的规则如下:\n* 每轮游戏,我都会从 1 到 n 随机选择一个数字。 请你猜选出的是哪个数字。\n* 如果你猜错了,我会告诉你,你猜测的数字比我选出的数字是大了还是小了。\n\n你可以通过调用一个预先定义好的接口 int guess(int num) 来获取猜测结果,返回值一共有 3 种可能的情况(-1,1 或 0):\n\n* -1:我选出的数字比你猜的数字小 pick < num\n* 1:我选出的数字比你猜的数字大 pick > num\n* 0:我选出的数字和你猜的数字一样。恭喜!你猜对了!pick == num\n\n返回我选出的数字。\n\n示例 1:\n```\n输入:n = 10, pick = 6\n输出:6\n```\n示例 2:\n```\n输入:n = 1, pick = 1\n输出:1\n```\n示例 3:\n```\n输入:n = 2, pick = 1\n输出:1\n```\n示例 4:\n```\n输入:n = 2, pick = 2\n输出:2\n```\n\n提示:\n* 1 <= n <= $2^{31}$ - 1\n* 1 <= pick <= n", "solution": "### 二分\n\n端午安康呀 🍭🍭🍭\n\n今天的题目表达不太好 🤣,还是逐字阅读才明白是啥意思 🤣\n\n就当做是因为题目本身要比 [278. 第一个错误的版本](https://leetcode-cn.com/problems/first-bad-version/) 简单(不需要考虑完全相同,没有二段性的情况),所以在阅读上增加了难度吧 🤣\n\n一道交互题,根据题意可知,是尽可能少调用 `guess` 方法来找到分割点。\n\n直接使用 `guess` 当做 `check` 函数进行二分即可。\n\n另外根据数据范围需要注意计算 `mid` 时的爆 `int` 问题,可以通过使用类似 `l + (r - l) / 2` 的做法解决,也可以通过一个临时 `long` 来解决。\n\n代码:\n```Java\npublic class Solution extends GuessGame {\n    public int guessNumber(int n) {\n        int l = 1, r = n;\n        while (l < r) {\n            long tmp = (long)l + r >> 1;\n            int mid = (int)tmp;\n            if (guess(mid) <= 0) {\n                r = mid;\n            } else {\n                l = mid + 1;\n            }\n        }\n        return r;\n    }\n}\n```\n```Java\npublic class Solution extends GuessGame {\n    public int guessNumber(int n) {\n        int l = 1, r = n;\n        while (l < r) {\n            long tmp = (long)l + r + 1 >> 1;\n            int mid = (int)tmp;\n            if (guess(mid) >= 0) {\n                l = mid;\n            } else {\n                r = mid - 1;\n            }\n        }\n        return r;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 其他「二分」相关题解\n\n* 二分模板\n    [29. 两数相除](https://leetcode-cn.com/problems/divide-two-integers/) : [二分 + 倍增乘法解法(含模板)](https://leetcode-cn.com/problems/divide-two-integers/solution/shua-chuan-lc-er-fen-bei-zeng-cheng-fa-j-m73b/)\n\n* 二分模板题\n    [278. 第一个错误的版本](https://leetcode-cn.com/problems/first-bad-version/) : [使用交互函数充当 check 进行二分](https://leetcode-cn.com/problems/first-bad-version/solution/gong-shui-san-xie-shi-yong-jiao-hu-han-s-8hpv/)\n\n    [374. 猜数字大小](https://leetcode-cn.com/problems/guess-number-higher-or-lower/) : [使用交互函数充当 check 进行二分](https://leetcode-cn.com/problems/guess-number-higher-or-lower/solution/gong-shui-san-xie-shi-yong-jiao-hu-han-s-tocm/)\n\n* 二分本质 & 恢复二段性处理\n\n    [33. 搜索旋转排序数组(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/)\n\n    [81. 搜索旋转排序数组 II(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-xtam4/)\n\n    [153. 寻找旋转排序数组中的最小值(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/)\n\n    [154. 寻找旋转排序数组中的最小值 II(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-7xbty/)\n\n* 二分 check 函数如何确定\n    [34. 在排序数组中查找元素的第一个和最后一个位置](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/) : [考察对「二分」的理解,以及 check 函数的「大于 小于」怎么写](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/gong-shui-san-xie-kao-cha-dui-er-fen-de-86bk0/)", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.374` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/371-380/375. 猜数字大小 II（中等）.md", "url_title": "375. 猜数字大小 II", "url": "https://leetcode-cn.com/problems/guess-number-higher-or-lower-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-ji-yi-92e5/", "difficulty": "中等", "tags": ["博弈论", "区间 DP", "记忆化搜索"], "question": "我们正在玩一个猜数游戏,游戏规则如下:\n1. 我从 `1` 到 `n` 之间选择一个数字。\n2. 你来猜我选了哪个数字。\n3. 如果你猜到正确的数字,就会 赢得游戏 。\n4. 如果你猜错了,那么我会告诉你,我选的数字比你的 更大或者更小 ,并且你需要继续猜数。\n5. 每当你猜了数字 `x` 并且猜错了的时候,你需要支付金额为 `x` 的现金。如果你花光了钱,就会 输掉游戏 。\n\n给你一个特定的数字 `n` ,返回能够 确保你获胜 的最小现金数,不管我选择那个数字 。\n\n示例 1:\n\n```\n输入:n = 10\n\n输出:16\n\n解释:制胜策略如下:\n- 数字范围是 [1,10] 。你先猜测数字为 7 。\n    - 如果这是我选中的数字,你的总费用为 $0 。否则,你需要支付 $7 。\n    - 如果我的数字更大,则下一步需要猜测的数字范围是 [8,10] 。你可以猜测数字为 9 。\n        - 如果这是我选中的数字,你的总费用为 $7 。否则,你需要支付 $9 。\n        - 如果我的数字更大,那么这个数字一定是 10 。你猜测数字为 10 并赢得游戏,总费用为 $7 + $9 = $16 。\n        - 如果我的数字更小,那么这个数字一定是 8 。你猜测数字为 8 并赢得游戏,总费用为 $7 + $9 = $16 。\n    - 如果我的数字更小,则下一步需要猜测的数字范围是 [1,6] 。你可以猜测数字为 3 。\n        - 如果这是我选中的数字,你的总费用为 $7 。否则,你需要支付 $3 。\n        - 如果我的数字更大,则下一步需要猜测的数字范围是 [4,6] 。你可以猜测数字为 5 。\n            - 如果这是我选中的数字,你的总费用为 $7 + $3 = $10 。否则,你需要支付 $5 。\n            - 如果我的数字更大,那么这个数字一定是 6 。你猜测数字为 6 并赢得游戏,总费用为 $7 + $3 + $5 = $15 。\n            - 如果我的数字更小,那么这个数字一定是 4 。你猜测数字为 4 并赢得游戏,总费用为 $7 + $3 + $5 = $15 。\n        - 如果我的数字更小,则下一步需要猜测的数字范围是 [1,2] 。你可以猜测数字为 1 。\n            - 如果这是我选中的数字,你的总费用为 $7 + $3 = $10 。否则,你需要支付 $1 。\n            - 如果我的数字更大,那么这个数字一定是 2 。你猜测数字为 2 并赢得游戏,总费用为 $7 + $3 + $1 = $11 。\n在最糟糕的情况下,你需要支付 $16 。因此,你只需要 $16 就可以确保自己赢得游戏。\n```\n示例 2:\n```\n输入:n = 1\n\n输出:0\n\n解释:只有一个可能的数字,所以你可以直接猜 1 并赢得游戏,无需支付任何费用。\n```\n示例 3:\n```\n输入:n = 2\n\n输出:1\n\n解释:有两个可能的数字 1 和 2 。\n- 你可以先猜 1 。\n    - 如果这是我选中的数字,你的总费用为 $0 。否则,你需要支付 $1 。\n    - 如果我的数字更大,那么这个数字一定是 2 。你猜测数字为 2 并赢得游戏,总费用为 $1 。\n最糟糕的情况下,你需要支付 $1 。\n```\n\n提示:\n* 1 <= n <= 200", "solution": "### 基本分析\n\n这不是一道可通过「二分」求解的题目,主要原因为每次惩罚的金额不固定,最小惩罚次数不等同于猜中数字的最小成本。\n\n---\n\n### 记忆化搜索\n\n比较容易想到的做法为使用「递归」进行求解。\n\n设计递归函数为 `int dfs(int l, int r)` 传入参数 `l` 和 `r` 代表在范围 $[l, r]$ 内进行猜数,返回值为在 $[l, r]$ 内猜中数字至少需要多少钱。\n\n**我们可决策的部分为「选择猜哪个数 $x$」,而不可决策的是「选择某个数 $x$ 之后(假设没有猜中),真实值会落在哪边」。**\n\n因此为求得「最坏情况下最好」的结果,我们应当取所有的 $x$ 中的最小值。\n\n最后,为减少重复计算,我们需要在「递归」基础上加入记忆化搜索。并且当我们使用 `static` 修饰 $cache$ 时,可以确保每个区间的计算在所有样例中只会发生一次。\n\n代码:\n```Java\nclass Solution {\n    static int N = 210;\n    static int[][] cache = new int[N][N];\n    public int getMoneyAmount(int n) {\n        return dfs(1, n);\n    }\n    int dfs(int l, int r) {\n        if (l >= r) return 0;\n        if (cache[l][r] != 0) return cache[l][r];\n        int ans = 0x3f3f3f3f;\n        for (int x = l; x <= r; x++) {\n            // 当选择的数位 x 时,至少需要 cur 才能猜中数字\n            int cur = Math.max(dfs(l, x - 1), dfs(x + 1, r)) + x;\n            // 在所有我们可以决策的数值之间取最优\n            ans = Math.min(ans, cur);\n        }\n        cache[l][r] = ans;\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^3)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(n^2)$\n\n---\n\n### 区间 DP\n\n同样能够通过「递推」来进行求解。\n\n**通过「记忆化搜索」的递归过程,我们发现,在求解 $[l, r]$ 的最小成本时,需要依赖于 $[l, i - 1]$ 和 $[i + 1, r]$ 这样的比 $[l, r]$ 更小的区间。**\n\n这引导我们使用「区间 DP」进行求解,对「区间 DP」不了解的同学可以先看 [「区间 DP」入门题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489400&idx=1&sn=0b629d3669329a6bf4f6ec71c2571ce7&chksm=fd9cbc67caeb357132fe0a1ca6240e2183748d94039100f539193d3eeb1dc223e0ddd4aa9584&token=2094656911&lang=zh_CN#rd) 。\n\n**定义 $f[l][r]$ 为考虑在 $[l, r]$ 范围内进行猜数的最小成本。**\n\n不失一般性的考虑 $f[l][r]$ 该如何计算。**同样的,我们可决策的部分为「选择猜哪个数 $x$」,而不可决策的是「选择某个数 $x$ 之后(假设没有猜中),真实值在落在哪边」。** \n\n我们对本次选择哪个数进行讨论,假设本次选择的数值为 $x$ ( $l <= x <= r$ ),则有 $cur = \\max(f[l][x - 1], f[x + 1][r]) + x$\n\n最终的 $f[l][r]$ 为所有可选的数值 $x$ 中的最小值。\n\n代码:\n```Java\nclass Solution {\n    public int getMoneyAmount(int n) {\n        int[][] f = new int[n + 10][n + 10];\n        for (int len = 2; len <= n; len++) {\n            for (int l = 1; l + len - 1 <= n; l++) {\n                int r = l + len - 1;\n                f[l][r] = 0x3f3f3f3f;\n                for (int x = l; x <= r; x++) {\n                    int cur = Math.max(f[l][x - 1], f[x + 1][r]) + x;\n                    f[l][r] = Math.min(f[l][r], cur);\n                }\n            }\n        }\n        return f[1][n];\n    }\n}\n```\n* 时间复杂度:$O(n^3)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 打表\n\n由于任意的 $[l,r]$ 对应结果均为定值,可以进行打表预处理。\n\n代码:\n```Java\nclass Solution {\n    static int N = 200;\n    static int[][] f = new int[N + 10][N + 10];\n    static {\n        for (int len = 2; len <= N; len++) {\n            for (int l = 1; l + len - 1 <= N; l++) {\n                int r = l + len - 1;\n                f[l][r] = 0x3f3f3f3f;\n                for (int x = l; x <= r; x++) {\n                    int cur = Math.max(f[l][x - 1], f[x + 1][r]) + x;\n                    f[l][r] = Math.min(f[l][r], cur);\n                }\n            }\n        }\n    }\n    public int getMoneyAmount(int n) {\n        return f[1][n];\n    }\n}\n```\n* 时间复杂度:$O(C^3)$\n* 空间复杂度:$O(C^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.375` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/371-380/380. O(1) 时间插入、删除和获取随机元素（中等）.md", "url_title": "380. O(1) 时间插入、删除和获取随机元素", "url": "https://leetcode-cn.com/problems/insert-delete-getrandom-o1/solution/by-ac_oier-tpex/", "difficulty": "中等", "tags": ["数据结构", "哈希表"], "question": "实现 `RandomizedSet` 类:\n\n* `RandomizedSet()` 初始化 `RandomizedSet` 对象\n* `bool insert(int val)` 当元素 `val` 不存在时,向集合中插入该项,并返回 `true`;否则,返回 `false`。\n* `bool remove(int val)` 当元素 `val` 存在时,从集合中移除该项,并返回 `true`;否则,返回 `false`。\n* `int getRandom()` 随机返回现有集合中的一项(测试用例保证调用此方法时集合中至少存在一个元素)。每个元素应该有 相同的概率 被返回。\n\n你必须实现类的所有函数,并满足每个函数的 平均 时间复杂度为 $O(1)$ 。\n\n示例:\n```\n输入\n[\"RandomizedSet\", \"insert\", \"remove\", \"insert\", \"getRandom\", \"remove\", \"insert\", \"getRandom\"]\n[[], [1], [2], [2], [], [1], [2], []]\n\n输出\n[null, true, false, true, 2, true, false, 2]\n\n解释\nRandomizedSet randomizedSet = new RandomizedSet();\nrandomizedSet.insert(1); // 向集合中插入 1 。返回 true 表示 1 被成功地插入。\nrandomizedSet.remove(2); // 返回 false ,表示集合中不存在 2 。\nrandomizedSet.insert(2); // 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。\nrandomizedSet.getRandom(); // getRandom 应随机返回 1 或 2 。\nrandomizedSet.remove(1); // 从集合中移除 1 ,返回 true 。集合现在包含 [2] 。\nrandomizedSet.insert(2); // 2 已在集合中,所以返回 false 。\nrandomizedSet.getRandom(); // 由于 2 是集合中唯一的数字,getRandom 总是返回 2 。\n```\n\n提示:\n* $-2^{31} <= val <= 2^{31} - 1$\n* 最多调用 `insert`、`remove` 和 `getRandom` 函数 $2 * 10^5$ 次\n* 在调用 `getRandom` 方法时,数据结构中 至少存在一个 元素。", "solution": "### 哈希表 + 删除交换\n\n对于 `insert` 和 `remove` 操作容易想到使用「哈希表」来实现 $O(1)$ 复杂度,但对于 `getRandom` 操作,比较理想的情况是能够在一个数组内随机下标进行返回。\n\n将两者结合,我们可以将哈希表设计为:以入参 `val` 为键,数组下标 `loc` 为值。\n\n**为了确保严格 $O(1)$,我们不能「使用拒绝采样」和「在数组非结尾位置添加/删除元素」。**\n\n因此我们需要申请一个足够大的数组 `nums`(利用数据范围为 $2* 10^5$),并使用变量 `idx` 记录当前使用到哪一位(即下标在 $[0, idx]$ 范围内均是存活值)。\n\n对于几类操作逻辑:\n\n* `insert` 操作:使用哈希表判断 `val` 是否存在,存在的话返回 `false`,否则将其添加到 `nums`,更新 `idx`,同时更新哈希表;\n* `remove` 操作:使用哈希表判断 `val` 是否存在,不存在的话返回 `false`,否则从哈希表中将 `val` 删除,同时取出其所在 `nums` 的下标 `loc`,然后将 `nums[idx]` 赋值到 `loc` 位置,并更新 `idx`(含义为将原本处于 `loc` 位置的元素删除),同时更新原本位于 `idx` 位置的数在哈希表中的值为 `loc`(若 `loc` 与 `idx` 相等,说明删除的是最后一个元素,这一步可跳过);\n* `getRandom` 操作:由于我们人为确保了 $[0, idx]$ 均为存活值,因此直接在 $[0, idx + 1)$ 范围内进行随机即可。\n\n代码:\n```Java\nclass RandomizedSet {\n    static int[] nums = new int[200010];\n    Random random = new Random();\n    Map<Integer, Integer> map = new HashMap<>();\n    int idx = -1;\n    public boolean insert(int val) {\n        if (map.containsKey(val)) return false;\n        nums[++idx] = val;\n        map.put(val, idx);\n        return true;\n    }\n    public boolean remove(int val) {\n        if (!map.containsKey(val)) return false;\n        int loc = map.remove(val);\n        if (loc != idx) map.put(nums[idx], loc);\n        nums[loc] = nums[idx--];\n        return true;\n    }\n    public int getRandom() {\n        return nums[random.nextInt(idx + 1)];\n    }\n}\n```\n* 时间复杂度:所有操作均为 $O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.380` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/381-390/382. 链表随机节点（中等）.md", "url_title": "382. 链表随机节点", "url": "https://leetcode-cn.com/problems/linked-list-random-node/solution/gong-shui-san-xie-xu-shui-chi-chou-yang-1lp9d/", "difficulty": "中等", "tags": ["链表", "模拟", "蓄水池抽样"], "question": "给你一个单链表,随机选择链表的一个节点,并返回相应的节点值。每个节点 **被选中的概率一样** 。\n\n实现 `Solution` 类:\n* `Solution(ListNode head)` 使用整数数组初始化对象。\n* `int getRandom()` 从链表中随机选择一个节点并返回该节点的值。链表中所有节点被选中的概率相等。\n\n示例:\n\n```\n输入\n[\"Solution\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\"]\n[[[1, 2, 3]], [], [], [], [], []]\n\n输出\n[null, 1, 3, 2, 2, 3]\n\n解释\nSolution solution = new Solution([1, 2, 3]);\nsolution.getRandom(); // 返回 1\nsolution.getRandom(); // 返回 3\nsolution.getRandom(); // 返回 2\nsolution.getRandom(); // 返回 2\nsolution.getRandom(); // 返回 3\n// getRandom() 方法应随机返回 1、2、3中的一个,每个元素被返回的概率相等。\n```\n\n提示:\n* $链表中的节点数在范围 [1, 10^4] 内$\n* $-10^4 <= Node.val <= 10^4$\n* 至多调用 `getRandom` 方法 $10^4$ 次\n\n进阶:\n* 如果链表非常大且长度未知,该怎么处理?\n* 你能否在不使用额外空间的情况下解决此问题?", "solution": "### 模拟\n\n由于链表长度只有 $10^4$,因此可以在初始化时遍历整条链表,将所有的链表值预处理到一个数组内。\n\n在查询时随机一个下标,并将数组中对应下标内容返回出去。\n\n**代码(感谢 [@Benhao](/u/himymben/) 同学提供的其他语言版本):**\n```Java\nclass Solution {\n    List<Integer> list = new ArrayList<>();\n    Random random = new Random(20220116);\n    public Solution(ListNode head) {\n        while (head != null) {\n            list.add(head.val);\n            head = head.next;\n        }\n    }\n    public int getRandom() {\n        int idx = random.nextInt(list.size());\n        return list.get(idx);\n    }\n}\n```\n-\n```Python3\nclass Solution:\n\n    def __init__(self, head: Optional[ListNode]):\n        self.nodes = []\n        while head:\n            self.nodes.append(head)\n            head = head.next\n\n    def getRandom(self) -> int:\n        return self.nodes[randint(0, len(self.nodes) - 1)].val\n```\n-\n```Golang\ntype Solution struct {\n    Nodes []int\n}\nfunc Constructor(head *ListNode) Solution {\n    nodes := make([]int, 0)\n    for head != nil {\n        nodes = append(nodes, head.Val)\n        head = head.Next\n    }\n    return Solution{nodes}\n}\nfunc (this *Solution) GetRandom() int {\n    return this.Nodes[rand.Intn(len(this.Nodes))]\n}\n```\n* 时间复杂度:令 $n$ 为链表长度,预处理数组的复杂度为 $O(n)$;随机获取某个值的复杂度为 $O(1)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 蓄水池抽样\n\n整理题意:总的样本数量未知,从所有样本中抽取若干个,要求每个样本被抽到的概率相等。\n\n具体做法为:**从前往后处理每个样本,每个样本成为答案的概率为 $\\frac{1}{i}$,其中 $i$ 为样本编号(编号从 $1$ 开始),最终可以确保每个样本成为答案的概率均为 $\\frac{1}{n}$(其中 $n$ 为样本总数)。**\n\n容易证明该做法的正确性,假设最终成为答案的样本编号为 $k$,那么 $k$ 成为答案的充要条件为「在遍历到 $k$ 时被选中」并且「遍历大于 $k$ 的所有元素时,均没有被选择(没有覆盖 $k$)」。\n\n对应事件概率为:\n\n$$\nP = \\frac{1}{k} * (1 - \\frac{1}{k + 1}) * (1 - \\frac{1}{k + 2}) * ... * (1 - \\frac{1}{n})\n$$\n\n首项 $\\frac{1}{k}$ 为选中 $k$ 的概率,后面每项分别为编号为 $[k + 1, n]$ 的样本 **不被选中** 的概率。\n\n化简得:\n\n$$\nP = \\frac{1}{k} * \\frac{k}{k + 1} * \\frac{k + 1}{k + 2} * ... * \\frac{n - 1}{n}\n$$\n\n进一步抵消化简后,可得:\n$$\nP = \\frac{1}{n}\n$$\n\n因此,在每一次 `getRandom` 时,从前往后处理每个节点,同时记录当前节点的编号,当处理到节点 $k$ 时,在 $[0, k)$ 范围内进行随机,若随机到结果为 $0$(发生概率为 $\\frac{1}{k}$),则将节点 $k$ 的值存入答案,最后一次覆盖答案的节点即为本次抽样结果。\n\n**代码(感谢 [@Benhao](/u/himymben/) 同学提供的其他语言版本):**\n```Java\nclass Solution {\n    ListNode head;\n    Random random = new Random(20220116);\n    public Solution(ListNode _head) {\n        head = _head;\n    }\n    public int getRandom() {\n        int ans = 0, idx = 0;\n        ListNode t = head;\n        while (t != null && ++idx >= 0) {\n            if (random.nextInt(idx) == 0) ans = t.val;\n            t = t.next;\n        }\n        return ans;\n    }\n}\n```\n-\n```Python3\nclass Solution:\n\n    def __init__(self, head: Optional[ListNode]):\n        self.root = head\n\n    def getRandom(self) -> int:\n        node, ans, i = self.root, None, 0\n        while node:\n            if not randint(0, i):\n                ans = node.val\n            node, i = node.next, i + 1\n        return ans\n```\n-\n```Golang\ntype Solution struct {\n    Root *ListNode\n}\nfunc Constructor(head *ListNode) Solution {\n    return Solution{head}\n}\nfunc (this *Solution) GetRandom() (ans int) {\n    for node, idx := this.Root, 1;node != nil; idx++ {\n        if rand.Intn(idx) == 0{\n            ans = node.Val\n        }\n        node = node.Next\n    }\n    return\n}\n```\n* 时间复杂度:令 $n$ 为链表长度,随机获取某个值的复杂度为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.382` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/381-390/383. 赎金信（简单）.md", "url_title": "383. 赎金信", "url": "https://leetcode-cn.com/problems/ransom-note/solution/gong-shui-san-xie-jian-dan-ji-shu-mo-ni-udpzn/", "difficulty": "简单", "tags": ["模拟"], "question": "为了不在赎金信中暴露字迹,从杂志上搜索各个需要的字母,组成单词来表达意思。\n\n给你一个赎金信 (`ransomNote`) 字符串和一个杂志(`magazine`)字符串,判断` ransomNote` 能不能由 `magazines` 里面的字符构成。\n\n如果可以构成,返回 `true` ;否则返回 `false` 。\n\n`magazine` 中的每个字符只能在 `ransomNote` 中使用一次。\n\n示例 1:\n```\n输入:ransomNote = \"a\", magazine = \"b\"\n\n输出:false\n```\n示例 2:\n```\n输入:ransomNote = \"aa\", magazine = \"ab\"\n\n输出:false\n```\n示例 3:\n```\n输入:ransomNote = \"aa\", magazine = \"aab\"\n\n输出:true\n```\n\n提示:\n* $1 <= ransomNote.length, magazine.length <= 10^5$\n* `ransomNote` 和 `magazine` 由小写英文字母组成", "solution": "### 计数模拟\n\n根据题意并利用两字符串只包含小写字母,先使用大小为字符集大小的数组(充当哈希表)对 $magazine$ 进行词频统计,然后在遍历 $ransomNote$ 时对计数数组进行抵消操作。\n\n若处理过程中出现词频数量为负数,则说明 $magazine$ 不能凑出 $ransomNote$。\n\n代码:\n```Java\nclass Solution {\n    public boolean canConstruct(String a, String b) {\n        int[] cnt = new int[26];\n        for (char c : b.toCharArray()) cnt[c - 'a']++;\n        for (char c : a.toCharArray()) if (--cnt[c - 'a'] < 0) return false;\n        return true;\n    }\n}\n```\n* 时间复杂度:令 $n$ 和 $m$ 分别为两字符串的长度,复杂度为 $O(n + m)$\n* 空间复杂度:令字符集大小为 $C = 26$。偷懒使用 `toCharArray` 操作的话,复杂度为 $O(n + m + C)$;使用 `charAt` 代替的话,复杂度为 $O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.383` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/381-390/384. 打乱数组（中等）.md", "url_title": "384. 打乱数组", "url": "https://leetcode-cn.com/problems/shuffle-an-array/solution/gong-shui-san-xie-xi-pai-suan-fa-yun-yon-0qmy/", "difficulty": "中等", "tags": ["洗牌算法"], "question": "给你一个整数数组 `nums`,设计算法来打乱一个没有重复元素的数组。\n\n实现 `Solution class`:\n* `Solution(int[] nums)` 使用整数数组 `nums` 初始化对象\n* `int[] reset()` 重设数组到它的初始状态并返回\n* `int[] shuffle()` 返回数组随机打乱后的结果\n\n示例:\n```\n输入\n[\"Solution\", \"shuffle\", \"reset\", \"shuffle\"]\n[[[1, 2, 3]], [], [], []]\n输出\n[null, [3, 1, 2], [1, 2, 3], [1, 3, 2]]\n\n解释\nSolution solution = new Solution([1, 2, 3]);\nsolution.shuffle();    // 打乱数组 [1,2,3] 并返回结果。任何 [1,2,3]的排列返回的概率应该相同。例如,返回 [3, 1, 2]\nsolution.reset();      // 重设数组到它的初始状态 [1, 2, 3] 。返回 [1, 2, 3]\nsolution.shuffle();    // 随机返回数组 [1, 2, 3] 打乱后的结果。例如,返回 [1, 3, 2]\n```\n\n提示:\n* $1 <= nums.length <= 200$\n* $-10^6 <= nums[i] <= 10^6$\n* `nums` 中的所有元素都是 唯一的\n* 最多可以调用 $5 \\times 10^4$ 次 `reset` 和 `shuffle`", "solution": "### 洗牌算法\n\n共有 $n$ 个不同的数,根据每个位置能够选择什么数,共有 $n!$ 种组合。\n\n题目要求每次调用 `shuffle` 时等概率返回某个方案,或者说每个元素都够等概率出现在每个位置中。\n\n我们可以使用 $Knuth$ 洗牌算法,在 $O(n)$ 复杂度内等概率返回某个方案。\n\n具体的,我们从前往后尝试填充 $[0, n - 1]$ 该填入什么数时,通过随机当前下标与(剩余的)哪个下标进行值交换来实现。\n\n对于下标 $x$ 而言,我们从 $[x, n - 1]$ 中随机出一个位置与 $x$ 进行值交换,当所有位置都进行这样的处理后,我们便得到了一个公平的洗牌方案。\n\n> 对于下标为 $0$ 位置,从 $[0, n - 1]$ 随机一个位置进行交换,共有 $n$ 种选择;下标为 $1$ 的位置,从 $[1, n - 1]$ 随机一个位置进行交换,共有 $n - 1$ 种选择 ... 且每个位置的随机位置交换过程相互独立。\n\nJava 代码:\n```Java\nclass Solution {\n    int[] nums;\n    int n;\n    Random random = new Random();\n    public Solution(int[] _nums) {\n        nums = _nums;\n        n = nums.length;\n    }\n    public int[] reset() {\n        return nums;\n    }\n    public int[] shuffle() {\n        int[] ans = nums.clone();\n        for (int i = 0; i < n; i++) {\n            swap(ans, i, i + random.nextInt(n - i));\n        }\n        return ans;\n    }\n    void swap(int[] arr, int i, int j) {\n        int c = arr[i];\n        arr[i] = arr[j];\n        arr[j] = c;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> nums;\n    int n;\n    Solution(vector<int>& _nums) : nums(_nums), n(_nums.size()) {}\n    vector<int> reset() {\n        return nums;\n    }\n    vector<int> shuffle() {\n        vector<int> ans = nums;\n        for (int i = 0; i < n; i++) {\n            swap(ans[i], ans[i + rand() % (n - i)]);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def __init__(self, nums: List[int]):\n        self.nums = nums\n        self.n = len(nums)\n\n    def reset(self) -> List[int]:\n        return self.nums\n\n    def shuffle(self) -> List[int]:\n        ans = self.nums[:]\n        for i in range(self.n):\n            j = i + random.randint(0, self.n - i - 1)\n            ans[i], ans[j] = ans[j], ans[i]\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nclass Solution {\n    private nums: number[];\n    private n: number;\n    \n    constructor(nums: number[]) {\n        this.nums = nums;\n        this.n = nums.length;\n    }\n\n    reset(): number[] {\n        return this.nums.slice();\n    }\n\n    shuffle(): number[] {\n        const ans: number[] = this.nums.slice();\n        for (let i = 0; i < this.n; i++) {\n            const j = i + Math.floor(Math.random() * (this.n - i));\n            [ans[i], ans[j]] = [ans[j], ans[i]];\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.384` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/381-390/385. 迷你语法分析器（中等）.md", "url_title": "385. 迷你语法分析器", "url": "https://leetcode-cn.com/problems/mini-parser/solution/by-ac_oier-zuy6/", "difficulty": "中等", "tags": ["栈", "模拟"], "question": "给定一个字符串 `s` 表示一个整数嵌套列表,实现一个解析它的语法分析器并返回解析的结果 `NestedInteger` 。\n\n列表中的每个元素只可能是整数或整数嵌套列表\n\n示例 1:\n```\n输入:s = \"324\",\n\n输出:324\n\n解释:你应该返回一个 NestedInteger 对象,其中只包含整数值 324。\n```\n示例 2:\n```\n输入:s = \"[123,[456,[789]]]\",\n\n输出:[123,[456,[789]]]\n\n解释:返回一个 NestedInteger 对象包含一个有两个元素的嵌套列表:\n1. 一个 integer 包含值 123\n2. 一个包含两个元素的嵌套列表:\n    i.  一个 integer 包含值 456\n    ii. 一个包含一个元素的嵌套列表\n         a. 一个 integer 包含值 789\n```\n\n提示:\n* $1 <= s.length <= 5 * 10^4$\n* `s` 由数字、方括号 `\"[]\"`、负号 `'-'` 、逗号 `','`组成\n* 用例保证 `s` 是可解析的 `NestedInteger`\n* 输入中的所有值的范围是 $[-10^6, 10^6]$", "solution": "### 栈\n\n每个 `[` 的出现意味着存在一个嵌套类型的 `NestedInteger` 实例,同时每个 `NestedInteger` 实例(无论是嵌套类型还是数值类型)都归属于其最近一个左边的嵌套类型的 `NestedInteger` 实例(即其左边最近一个 `[`),因此我们可以使用栈来处理。\n\n对出现的几类字符进行简单分情况讨论:\n\n* `,`:跳过即可;\n* `-` 或 `数字`:将连续段代表数值的字符串取出,创建数值型的 `NestedInteger` 实例并压入栈中;\n* `[`:创建一个嵌套类型的 `NestedInteger` 实例并压入栈中,同时为了方便,同时压入一个起「标识」作用的 `NestedInteger` 对象;\n* `]`:从栈中取出元素,直到遇到起「标识」作用的 `NestedInteger` 对象(说明找到与当前 `]` 成对的 `[`),将 `[` 和 `]` 之间的所有元素添加到 `[` 所代指的嵌套 `NestedInteger` 实例中,然后将 `[` 所代指的嵌套 `NestedInteger` 实例重新放入栈中。\n\n按照上述逻辑处理完整个 `s`,最终栈顶元素即是答案。\n\n代码:\n```Java\nclass Solution {\n    static NestedInteger ph = new NestedInteger(0);\n    public NestedInteger deserialize(String s) {\n        Deque<NestedInteger> d = new ArrayDeque<>();\n        char[] cs = s.toCharArray();\n        int n = cs.length, i = 0;\n        while (i < n) {\n            if (cs[i] == ',' && ++i >= 0) continue;\n            if (cs[i] == '-' || (cs[i] >= '0' && cs[i] <= '9')) {\n                int j = cs[i] == '-' ? i + 1 : i, num = 0;\n                while (j < n && (cs[j] >= '0' && cs[j] <= '9')) num = num * 10 + (cs[j++] - '0');\n                d.addLast(new NestedInteger(cs[i] == '-' ? -num : num));\n                i = j;\n            } else if (cs[i] == '[') {\n                d.addLast(new NestedInteger());\n                d.addLast(ph);\n                i++;\n            } else {\n                List<NestedInteger> list = new ArrayList<>();\n                while (!d.isEmpty()) {\n                    NestedInteger poll = d.pollLast();\n                    if (poll == ph) break;\n                    list.add(poll);\n                }\n                for (int j = list.size() - 1; j >= 0; j--) d.peekLast().add(list.get(j));\n                i++;\n            }\n        }\n        return d.peekLast();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.385` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/381-390/386. 字典序排数（中等）.md", "url_title": "386. 字典序排数", "url": "https://leetcode-cn.com/problems/lexicographical-numbers/solution/by-ac_oier-ktn7/", "difficulty": "中等", "tags": ["DFS", "递归", "迭代"], "question": "给你一个整数 `n` ,按字典序返回范围 $[1, n]$ 内所有整数。\n\n你必须设计一个时间复杂度为 $O(n)$ 且使用 $O(1)$ 额外空间的算法。\n\n示例 1:\n```\n输入:n = 13\n\n输出:[1,10,11,12,13,2,3,4,5,6,7,8,9]\n```\n示例 2:\n```\n输入:n = 2\n\n输出:[1,2]\n```\n\n提示:\n* $1 <= n <= 5 * 10^4$", "solution": "### 递归\n\n首先容易想到使用「递归」来实现 `DFS`。\n\n将 $[1, n]$ 的数按照字典序添加到答案,本质上是对一颗节点数量为 $n$,形态类似字典树的多阶树进行遍历,根节点为 $0$,需要被跳过,因此我们可以从树的第二层开始搜索。\n\n树中每个节点的值为其搜索路径所代表的数字,且每个节点有 $[0, 9]$ 共 $10$ 个子节点。\n\n代码:\n```Java\nclass Solution {\n    List<Integer> ans = new ArrayList<>();\n    public List<Integer> lexicalOrder(int n) {\n        for (int i = 1; i <= 9; i++) dfs(i, n);\n        return ans;\n    }\n    void dfs(int cur, int limit) {\n        if (cur > limit) return ;\n        ans.add(cur);\n        for (int i = 0; i <= 9; i++) dfs(cur * 10 + i, limit);\n    }\n}\n```\n* 时间复杂度:本质上在搜索一棵节点数量为 $n$ 的多阶树(形态类似于字典树),复杂度为 $O(n)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$\n\n---\n\n### 迭代\n\n递归具有额外的空间开销,为了实现严格的 $O(1)$ 空间,我们需要使用「迭代」来实现 `DFS`。\n\n共有 $n$ 个数需要被处理,假设当前处理到的数为 $j$,根据字典序规则,在满足条件的前提下,我们优先在 $j$ 的后面添加 $0$(即 $j * 10 < n$ 满足),否则我们考虑将上一位回退并进行加一操作。\n\n代码:\n```Java\nclass Solution {\n    public List<Integer> lexicalOrder(int n) {\n        List<Integer> ans = new ArrayList<>();\n        for (int i = 0, j = 1; i < n; i++) {\n            ans.add(j);\n            if (j * 10 <= n) {\n                j *= 10;\n            } else {\n                while (j % 10 == 9 || j + 1 > n) j /= 10;\n                j++;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.386` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/381-390/388. 文件的最长绝对路径（中等）.md", "url_title": "388. 文件的最长绝对路径", "url": "https://leetcode-cn.com/problems/longest-absolute-file-path/solution/by-ac_oier-c55t/", "difficulty": "中等", "tags": ["模拟", "哈希表"], "question": "假设有一个同时存储文件和目录的文件系统。下图展示了文件系统的一个示例:\n\n这里将 `dir` 作为根目录中的唯一目录。`dir` 包含两个子目录 `subdir1` 和 `subdir2` 。\n\n`subdir1` 包含文件 `file1.ext` 和子目录 `subsubdir1`;`subdir2` 包含子目录 `subsubdir2`,该子目录下包含文件 `file2.ext`。\n\n在文本格式中,如下所示(⟶表示制表符):\n```\ndir\n⟶ subdir1\n⟶ ⟶ file1.ext\n⟶ ⟶ subsubdir1\n⟶ subdir2\n⟶ ⟶ subsubdir2\n⟶ ⟶ ⟶ file2.ext\n```\n\n如果是代码表示,上面的文件系统可以写为 `\"dir\\n\\tsubdir1\\n\\t\\tfile1.ext\\n\\t\\tsubsubdir1\\n\\tsubdir2\\n\\t\\tsubsubdir2\\n\\t\\t\\tfile2.ext\"` 。`'\\n'` 和 `'\\t'` 分别是换行符和制表符。\n\n文件系统中的每个文件和文件夹都有一个唯一的 绝对路径 ,即必须打开才能到达文件/目录所在位置的目录顺序,所有路径用 '/' 连接。上面例子中,指向 `file2.ext` 的 绝对路径 是 `\"dir/subdir2/subsubdir2/file2.ext\"` 。每个目录名由字母、数字和/或空格组成,每个文件名遵循 `name.extension` 的格式,其中 `name` 和 `extension` 由字母、数字和/或空格组成。\n\n给定一个以上述格式表示文件系统的字符串 `input` ,返回文件系统中 指向 文件 的 最长绝对路径 的长度 。 如果系统中没有文件,返回 $0$。\n\n示例 1:\n\n```\n输入:input = \"dir\\n\\tsubdir1\\n\\tsubdir2\\n\\t\\tfile.ext\"\n\n输出:20\n\n解释:只有一个文件,绝对路径为 \"dir/subdir2/file.ext\" ,路径长度 20\n```\n示例 2:\n\n```\n输入:input = \"dir\\n\\tsubdir1\\n\\t\\tfile1.ext\\n\\t\\tsubsubdir1\\n\\tsubdir2\\n\\t\\tsubsubdir2\\n\\t\\t\\tfile2.ext\"\n\n输出:32\n\n解释:存在两个文件:\n\"dir/subdir1/file1.ext\" ,路径长度 21\n\"dir/subdir2/subsubdir2/file2.ext\" ,路径长度 32\n返回 32 ,因为这是最长的路径\n```\n示例 3:\n```\n输入:input = \"a\"\n\n输出:0\n\n解释:不存在任何文件\n```\n示例 4:\n```\n输入:input = \"file1.txt\\nfile2.txt\\nlongfile.txt\"\n\n输出:12\n\n解释:根目录下有 3 个文件。\n因为根目录中任何东西的绝对路径只是名称本身,所以答案是 \"longfile.txt\" ,路径长度为 12\n```\n\n提示:\n* $1 <= input.length <= 10^4$\n* `input` 可能包含小写或大写的英文字母,一个换行符 `'\\n'`,一个制表符 `'\\t'`,一个点 `'.'`,一个空格 `' '`,和数字。", "solution": "### 模拟 + 哈希表\n\n为了方便,我们将 `input` 替换为 `s`。\n\n对于每一个文件或文件夹而言,我们可以通过访问到结尾(`\\n`)的方式取得,记为 `cur`,然后根据 `cur` 前面有多少个 `\\t` 得知其所在的层级,假设当前其所在层级为 `level`,那么它自然归属到最新一个层级为 `level - 1` 的文件夹中,因此我们可以使用哈希表记录每个层级最新的文件夹路径,通过字符串拼接的方式得到 `cur` 所在的完整路径 `path`,并在处理整个 `s` 过程中,统计长度最大的文件路径。\n\n代码:\n```Java\nclass Solution {\n    public int lengthLongestPath(String s) {\n        Map<Integer, String> map = new HashMap<>();\n        int n = s.length();\n        String ans = null;\n        for (int i = 0; i < n; ) {\n            int level = 0;\n            while (i < n && s.charAt(i) == '\\t' && ++level >= 0) i++;\n            int j = i;\n            boolean isDir = true;\n            while (j < n && s.charAt(j) != '\\n') {\n                if (s.charAt(j++) == '.') isDir = false;\n            }\n            String cur = s.substring(i, j);\n            String prev = map.getOrDefault(level - 1, null);\n            String path = prev == null ? cur : prev + \"/\" + cur;\n            if (isDir) map.put(level, path);\n            else if (ans == null || path.length() > ans.length()) ans = path;\n            i = j + 1;\n        }\n        return ans == null ? 0 : ans.length();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 优化\n\n上述做法只是为了方便我们输出具体方案。\n\n实际上,我们只关心最终的路径长度,而不关心具体路径,因此容易将解法一修改为只记录长度,而不记录路径的做法,从而避免掉字符串拼接带来的消耗,同时利用 `s` 的长度数据范围,使用数组来替代常数较大的哈希表。\n\n代码:\n```Java\nclass Solution {\n    static int[] hash = new int[10010];\n    public int lengthLongestPath(String s) {\n        Arrays.fill(hash, -1);\n        int n = s.length(), ans = 0;\n        for (int i = 0; i < n; ) {\n            int level = 0;\n            while (i < n && s.charAt(i) == '\\t' && ++level >= 0) i++;\n            int j = i;\n            boolean isDir = true;\n            while (j < n && s.charAt(j) != '\\n') {\n                if (s.charAt(j++) == '.') isDir = false;\n            }\n            Integer cur = j - i;\n            Integer prev = level - 1 >= 0 ? hash[level - 1] : -1;\n            Integer path = prev + 1 + cur;\n            if (isDir) hash[level] = path;\n            else if (path > ans) ans = path;\n            i = j + 1;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.388` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/381-390/390. 消除游戏（中等）.md", "url_title": "390. 消除游戏", "url": "https://leetcode-cn.com/problems/elimination-game/solution/gong-shui-san-xie-yue-se-fu-huan-yun-yon-x60m/", "difficulty": "中等", "tags": ["动态规划", "数学", "约瑟夫环"], "question": "列表 `arr` 由在范围 `[1, n]` 中的所有整数组成,并按严格递增排序。\n\n请你对 `arr` 应用下述算法:\n\n* 从左到右,删除第一个数字,然后每隔一个数字删除一个,直到到达列表末尾。\n* 重复上面的步骤,但这次是从右到左。也就是,删除最右侧的数字,然后剩下的数字每隔一个删除一个。\n* 不断重复这两步,从左到右和从右到左交替进行,直到只剩下一个数字。\n\n给你整数 `n`,返回 `arr` 最后剩下的数字。\n\n示例 1:\n```\n输入:n = 9\n\n输出:6\n\n解释:\narr = [1, 2, 3, 4, 5, 6, 7, 8, 9]\narr = [2, 4, 6, 8]\narr = [2, 6]\narr = [6]\n```\n示例 2:\n```\n输入:n = 1\n\n输出:1\n```\n\n提示:\n* $1 <= n <= 10^9$", "solution": "### 约瑟夫环\n\n与求解约瑟夫环类似,本题也可以通常找规律,分析出公式之后进行递推求解。\n\n对于本题,定义 $f[i]$ 为在 **连续序列** $[1, i]$ 中进行「起始先从左到右,再从右往左」的轮流换向间隔删除,最终左边剩余的编号;定义 $f'[i]$ 为在 **连续序列** $[1, i]$ 中进行「起始先从右到左,再从左往右」的轮流换向间隔删除,最终右边剩余的编号。\n\n**由于「从左往右」和「从右往左」分别为「从左端点发起,间隔删除」和「从右端点发起,间隔删除」,因此整个删除过程在连续序列中 $[1, i]$ 中具有对称性,两者最终剩余的编号在连续序列中也具有对称性。**\n\n即可得出第一个公式:\n\n$$\nf[i] + f'[i] = i + 1\n$$\n\n考虑题目规定的「左右轮流进行发起删除」的操作如何进行。\n\n由于我们对 $f[i]$ 和 $f'[i]$ 的定义都是「连续序列」,因此如果我们希望使用 $f[i]$ 和 $f'[i]$ 得出最终答案,我们需要在每次消除后对序列进行「重新编号」,确保能够使用 $f[i]$ 和 $f'[i]$ 作为合法状态值,在计算出「重新编号」后的,需要将答案(编号)映射回去重新编号前的值。\n\n起始时,我们对连续序列 $[1, 2, 3, ... , i]$ 执行了一次「从左往右」的消除之后,得到的序列为 $[2, 4, 6, ..., x]$(其中 $x$ 根据 $i$ 的奇偶性不同,可能为 $i$ 或 $i - 1$)。新序列的长度为 $\\left \\lfloor \\frac{i}{2} \\right \\rfloor$。\n\n考虑对得到的序列进行重新编号,使其继续保有「连续序列」的定义,即变为 $[1, 2, 3, ... , \\left \\lfloor \\frac{i}{2} \\right \\rfloor]$,然后执行「从右往左」的间隔删除,最终得到 $f'[\\left \\lfloor \\frac{i}{2} \\right \\rfloor]$,之后考虑将答案编号映射回「重新编号」前的值。\n\n此时可得到第二个公式:\n\n$$\nf[i] = f'[\\left \\lfloor \\frac{i}{2} \\right \\rfloor] * 2\n$$\n\n通过上述两个公式,我们可以将 $f'[i]$ 进行消除,得到最终的 $f[i]$ 关系式:\n\n$$\nf[i] = 2 * (\\left \\lfloor \\frac{i}{2} \\right \\rfloor + 1 - f[\\left \\lfloor \\frac{i}{2} \\right \\rfloor])\n$$\n\n我们知道需要实现的函数 `lastRemaining` 其实就是 $f[i]$,因此该递推过程我们可以使用递归进行实现(注意的出口条件 $f[1] = 1$)。\n\n代码:\n```Java\nclass Solution {\n    public int lastRemaining(int n) {\n        return n == 1 ? 1 : 2 * (n / 2 + 1 - lastRemaining(n / 2));\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.390` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/391-400/391. 完美矩形（困难）.md", "url_title": "391. 完美矩形", "url": "https://leetcode-cn.com/problems/perfect-rectangle/solution/gong-shui-san-xie-chang-gui-sao-miao-xia-p4q4/", "difficulty": "困难", "tags": ["扫描线"], "question": "给你一个数组 `rectangles`,其中 $rectangles[i] = [x_i, y_i, a_i, b_i]$ 表示一个坐标轴平行的矩形。这个矩形的左下顶点是 $(x_i, y_i)$ ,右上顶点是 $(a_i, b_i)$ 。\n\n如果所有矩形一起精确覆盖了某个矩形区域,则返回 `true` ;否则,返回 `false` 。\n\n示例 1:\n\n```\n输入:rectangles = [[1,1,3,3],[3,1,4,2],[3,2,4,4],[1,3,2,4],[2,3,3,4]]\n\n输出:true\n\n解释:5 个矩形一起可以精确地覆盖一个矩形区域。 \n```\n示例 2:\n\n```\n输入:rectangles = [[1,1,2,3],[1,3,2,4],[3,1,4,2],[3,2,4,4]]\n\n输出:false\n\n解释:两个矩形之间有间隔,无法覆盖成一个矩形。\n```\n示例 3:\n\n```\n输入:rectangles = [[1,1,3,3],[3,1,4,2],[1,3,2,4],[3,2,4,4]]\n\n输出:false\n\n解释:图形顶端留有空缺,无法覆盖成一个矩形。\n```\n示例 4:\n\n```\n输入:rectangles = [[1,1,3,3],[3,1,4,2],[1,3,2,4],[2,2,4,4]]\n\n输出:false\n\n解释:因为中间有相交区域,虽然形成了矩形,但不是精确覆盖。\n```\n\n提示:\n* $1 <= rectangles.length <= 2 \\times 10^4$\n* $rectangles[i].length = 4$\n* $-10^5 <= x_i, y_i, a_i, b_i <= 10^5$", "solution": "### 扫描线\n\n将每个矩形 $rectangles[i]$ 看做两条竖直方向的边,使用 $(x, y1, y2)$ 的形式进行存储(其中 $y1$ 代表该竖边的下端点,$y2$ 代表竖边的上端点),同时为了区分是矩形的左边还是右边,再引入一个标识位,即以四元组 $(x, y1, y2, flag)$ 的形式进行存储。\n\n一个完美矩形的充要条件为:**对于完美矩形的每一条非边缘的竖边,都「成对」出现(存在两条完全相同的左边和右边重叠在一起);对于完美矩形的两条边缘竖边,均独立为一条连续的(不重叠)的竖边。**\n\n如图(红色框的为「完美矩形的边缘竖边」,绿框的为「完美矩形的非边缘竖边」):\n\n* 绿色:非边缘竖边必然有成对的左右两条完全相同的竖边重叠在一起;\n* 红色:边缘竖边由于只有单边,必然不重叠,且连接成一条完成的竖边。\n\n代码:\n```Java\nclass Solution {\n    public boolean isRectangleCover(int[][] rectangles) {\n        int n = rectangles.length;\n        int[][] rs = new int[n * 2][4];\n        for (int i = 0, idx = 0; i < n; i++) {\n            int[] re = rectangles[i];\n            rs[idx++] = new int[]{re[0], re[1], re[3], 1};\n            rs[idx++] = new int[]{re[2], re[1], re[3], -1};\n        }\n        Arrays.sort(rs, (a,b)->{\n            if (a[0] != b[0]) return a[0] - b[0];\n            return a[1] - b[1];\n        });\n        n *= 2;\n        // 分别存储相同的横坐标下「左边的线段」和「右边的线段」 (y1, y2)\n        List<int[]> l1 = new ArrayList<>(), l2 = new ArrayList<>(); \n        for (int l = 0; l < n; ) {\n            int r = l;\n            l1.clear(); l2.clear();\n            // 找到横坐标相同部分\n            while (r < n && rs[r][0] == rs[l][0]) r++;\n            for (int i = l; i < r; i++) {\n                int[] cur = new int[]{rs[i][1], rs[i][2]};\n                List<int[]> list = rs[i][3] == 1 ? l1 : l2;\n                if (list.isEmpty()) {\n                    list.add(cur);\n                } else {\n                    int[] prev = list.get(list.size() - 1);\n                    if (cur[0] < prev[1]) return false; // 存在重叠\n                    else if (cur[0] == prev[1]) prev[1] = cur[1]; // 首尾相连\n                    else list.add(cur); \n                }\n            }\n            if (l > 0 && r < n) {\n                // 若不是完美矩形的边缘竖边,检查是否成对出现\n                if (l1.size() != l2.size()) return false;\n                for (int i = 0; i < l1.size(); i++) {\n                    if (l1.get(i)[0] == l2.get(i)[0] && l1.get(i)[1] == l2.get(i)[1]) continue;\n                    return false;\n                }\n            } else {\n                // 若是完美矩形的边缘竖边,检查是否形成完整一段\n                if (l1.size() + l2.size() != 1) return false;\n            }\n            l = r;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:将 `rectangles` 划分成边集的复杂度为 $O(n)$;对边集进行排序的复杂度为 $O(n\\log{n})$,对排序好的边集进行遍历检查,每条边会被扫描线性次,复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.391` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/391-400/393. UTF-8 编码验证（中等）.md", "url_title": "393. UTF-8 编码验证", "url": "https://leetcode-cn.com/problems/utf-8-validation/solution/by-ac_oier-zvoy/", "difficulty": "中等", "tags": ["模拟"], "question": "给定一个表示数据的整数数组 `data` ,返回它是否为有效的 $UTF-8$ 编码。\n\n`UTF-8` 中的一个字符可能的长度为 $1$ 到 $4$ 字节,遵循以下的规则:\n\n1. 对于 $1$ 字节 的字符,字节的第一位设为 $0$ ,后面 $7$ 位为这个符号的 `unicode` 码。\n2. 对于 $n$ 字节 的字符 ($n > 1$),第一个字节的前 $n$ 位都设为 $1$,第 $n+1$ 位设为 $0$ ,后面字节的前两位一律设为 $10$ 。剩下的没有提及的二进制位,全部为这个符号的 `unicode` 码。\n\n这是 UTF-8 编码的工作方式:\n```\n   Char. number range  |        UTF-8 octet sequence\n      (hexadecimal)    |              (binary)\n   --------------------+---------------------------------------------\n   0000 0000-0000 007F | 0xxxxxxx\n   0000 0080-0000 07FF | 110xxxxx 10xxxxxx\n   0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx\n   0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx\n```\n注意:输入是整数数组。只有每个整数的 最低 8 个有效位 用来存储数据。这意味着每个整数只表示 1 字节的数据。\n\n示例 1:\n```\n输入:data = [197,130,1]\n\n输出:true\n\n解释:数据表示字节序列:11000101 10000010 00000001。\n这是有效的 utf-8 编码,为一个 2 字节字符,跟着一个 1 字节字符。\n```\n示例 2:\n```\n输入:data = [235,140,4]\n\n输出:false\n\n解释:数据表示 8 位的序列: 11101011 10001100 00000100.\n前 3 位都是 1 ,第 4 位为 0 表示它是一个 3 字节字符。\n下一个字节是开头为 10 的延续字节,这是正确的。\n但第二个延续字节不以 10 开头,所以是不符合规则的。\n```\n\n提示:\n* $1 <= data.length <= 2 \\times 10^4$\n* $0 <= data[i] <= 255$", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n从前往后处理每个 $data[i]$,先统计 $data[i]$ 从第 $7$ 位开始往后有多少位连续的 $1$,代表这是一个几字节的字符,记为 $cnt$ :\n\n* 如果 $cnt$ 为 $1$ 或者大于 $4$ 均违反编码规则(与字符长度为 $1$ 时的编码规则 和 字符长度只能是 $1$ 到 $4$ 冲突),返回 `False`;\n* 如果位置 $i$ 后面不足 $cnt - 1$ 也返回 `False`;\n* 否则检查下标范围为 $[i + 1, i + cnt - 1]$ 的数是否满足前两位为 $10$ 的要求,若不满足返回 `False`。\n\n如果上述过程满足要求,跳到下一个检查点进行检查,整个 `data` 都没有冲突则返回 `True`。\n\n代码:\n```Java\nclass Solution {\n    public boolean validUtf8(int[] data) {\n        int n = data.length;\n        for (int i = 0; i < n; ) {\n            int t = data[i], j = 7;\n            while (j >= 0 && (((t >> j) & 1) == 1)) j--;\n            int cnt = 7 - j;\n            if (cnt == 1 || cnt > 4) return false;\n            if (i + cnt - 1 >= n) return false;\n            for (int k = i + 1; k < i + cnt; k++) {\n                if ((((data[k] >> 7) & 1) == 1) && (((data[k] >> 6) & 1) == 0)) continue;\n                return false;\n            }\n            i += cnt == 0 ? 1 : cnt;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.393` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/391-400/395. 至少有 K 个重复字符的最长子串（中等）.md", "url_title": "395. 至少有 K 个重复字符的最长子串", "url": "https://leetcode-cn.com/problems/longest-substring-with-at-least-k-repeating-characters/solution/xiang-jie-mei-ju-shuang-zhi-zhen-jie-fa-50ri1/", "difficulty": "中等", "tags": ["双指针", "枚举"], "question": "给你一个字符串 s 和一个整数 k ,请你找出 s 中的最长子串, 要求该子串中的每一字符出现次数都不少于 k 。返回这一子串的长度。\n\n示例 1:\n```\n输入:s = \"aaabb\", k = 3\n输出:3\n解释:最长子串为 \"aaa\" ,其中 'a' 重复了 3 次。\n```\n示例 2:\n```\n输入:s = \"ababbc\", k = 2\n输出:5\n解释:最长子串为 \"ababb\" ,其中 'a' 重复了 2 次, 'b' 重复了 3 次。\n```\n\n提示:\n* 1 <= s.length <= $10^4$\n* s 仅由小写英文字母组成\n* 1 <= k <= $10^5$", "solution": "### 枚举 + 双指针\n\n其实看到这道题,我第一反应是「二分」,直接「二分」答案。\n\n但是往下分析就能发现「二分」不可行,因为不具有二段性质。\n\n也就是假设有长度 `t` 的一段区间满足要求的话,`t + 1` 长度的区间是否「一定满足」或者「一定不满足」呢?\n\n显然并不一定,是否满足取决于 `t + 1` 个位置出现的字符在不在原有区间内。\n\n举个🌰吧,假设我们已经画出来一段长度为 `t` 的区间满足要求(且此时 k > 1),那么当我们将长度扩成 `t + 1` 的时候(无论是往左扩还是往右扩):\n\n* 如果新位置的字符在原有区间**出现过**,那必然还是满足出现次数大于 k,这时候 **`t + 1` 的长度满足要求**\n* 如果新位置的字符在原有区间**没出现过**,那新字符的出现次数只有一次,这时候 **`t + 1` 的长度不满足要求**\n\n因此我们无法是使用「二分」,相应的也无法直接使用「滑动窗口」思路的双指针。\n\n因为双指针其实也是利用了二段性质,当一个指针确定在某个位置,另外一个指针能够落在某个明确的分割点,使得左半部分满足,右半部分不满足。\n\n**那么还有什么性质可以利用呢?这时候要留意数据范围「数值小」的内容。**\n\n题目说明了只包含小写字母(26 个,为有限数据),**我们可以枚举最大长度所包含的字符类型数量,答案必然是 [1, 26],即最少包含 1 个字母,最多包含 26 个字母。**\n\n你会发现,**当确定了长度所包含的字符种类数量时,区间重新具有了二段性质。**\n\n当我们使用双指针的时候:\n1. 右端点往右移动必然会导致字符类型数量增加(或不变)\n2. 左端点往右移动必然会导致字符类型数量减少(或不变)\n\n当然,我们还需要记录有多少字符符合要求(出现次数不少于 k),当区间内所有字符都符合时更新答案。\n\n代码:\n```Java\nclass Solution {\n    public int longestSubstring(String s, int k) {\n        int ans = 0;\n        int n = s.length();\n        char[] cs = s.toCharArray();\n        int[] cnt = new int[26];\n        for (int p = 1; p <= 26; p++) {\n            Arrays.fill(cnt, 0);\n            // tot 代表 [j, i] 区间所有的字符种类数量;sum 代表满足「出现次数不少于 k」的字符种类数量\n            for (int i = 0, j = 0, tot = 0, sum = 0; i < n; i++) {\n                int u = cs[i] - 'a';\n                cnt[u]++;\n                // 如果添加到 cnt 之后为 1,说明字符总数 +1\n                if (cnt[u] == 1) tot++;\n                // 如果添加到 cnt 之后等于 k,说明该字符从不达标变为达标,达标数量 + 1\n                if (cnt[u] == k) sum++;\n                // 当区间所包含的字符种类数量 tot 超过了当前限定的数量 p,那么我们要删除掉一些字母,即「左指针」右移\n                while (tot > p) {\n                    int t = cs[j++] - 'a';\n                    cnt[t]--;\n                    // 如果添加到 cnt 之后为 0,说明字符总数-1\n                    if (cnt[t] == 0) tot--;\n                    // 如果添加到 cnt 之后等于 k - 1,说明该字符从达标变为不达标,达标数量 - 1\n                    if (cnt[t] == k - 1) sum--;\n                }\n                // 当所有字符都符合要求,更新答案\n                if (tot == sum) ans = Math.max(ans, i - j + 1);\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:枚举 26 种可能性,每种可能性会扫描一遍数组。复杂度为 $O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 总结 & 补充\n\n【总结】:\n\n「当确定了窗口内所包含的字符数量时,区间重新具有了二段性质」。这是本题的滑动窗口解法和迄今为止做的滑动窗口题目的最大不同,本题需要手动增加限制,即限制窗口内字符种类。\n\n【补充】这里解释一下「为什么需要先枚举 26 种可能性」:\n\n首先我们知道「**答案子串的左边界左侧的字符以及右边界右侧的字符一定不会出现在子串中,否则就不会是最优解**」。\n\n但**如果我们只从该性质出发的话,朴素解法应该是使用一个滑动窗口,不断的调整滑动窗口的左右边界,使其满足「左边界左侧的字符以及右边界右侧的字符一定不会出现在窗口中」**,这实际上就是双指针解法,但是如果不先敲定(枚举)出答案所包含的字符数量的话,**这里的双指针是不具有单调性的**。\n\n换句话说,只利用这一性质是没法完成逻辑的。\n\n这时候我们面临的问题是:**性质是正确的,但是还无法直接利用**。\n\n因此我们需要**先利用字符数量有限性(可枚举)作为切入点,使得「答案子串的左边界左侧的字符以及右边界右侧的字符一定不会出现在子串中」这一性质在双指针的实现下具有单调性**。也就是题解说的「让区间重新具有二段性质」。\n\n然后遍历 26 种可能性(答案所包含的字符种类数量),**对每种可能性应用滑动窗口(由上述性质确保正确),可以得到每种可能性的最大值(局部最优),由所有可能性的最大值可以得出答案(全局最优)**。\n\n***\n\n### 点评\n\n这道题的突破口分析其实和 [1178. 猜字谜](https://leetcode-cn.com/problems/number-of-valid-words-for-each-puzzle/solution/xiang-jin-zhu-shi-xiang-jie-po-su-wei-yu-3cr2/) 类似。\n\n解决思路:当我们采用常规的分析思路发现无法进行时,**要去关注一下数据范围中「数值小」的值。因为数值小其实是代表了「可枚举」,往往是解题或者降低复杂度的一个重要(甚至是唯一)的突破口。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.395` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/391-400/396. 旋转函数（中等）.md", "url_title": "396. 旋转函数", "url": "https://leetcode-cn.com/problems/rotate-function/solution/by-ac_oier-sxbi/", "difficulty": "中等", "tags": ["前缀和", "滑动窗口"], "question": "给定一个长度为 $n$ 的整数数组 $nums$ 。\n\n假设 $arr_k$ 是数组 $nums$ 顺时针旋转 $k$ 个位置后的数组,我们定义 $nums$ 的 旋转函数  `F` 为:\n\n* `F(k) = 0 * arrk[0] + 1 * arrk[1] + ... + (n - 1) * arrk[n - 1]`\n\n返回 `F(0), F(1), ..., F(n-1)` 中的最大值 。\n\n生成的测试用例让答案符合 $32$ 位 整数。\n\n示例 1:\n```\n输入: nums = [4,3,2,6]\n\n输出: 26\n\n解释:\nF(0) = (0 * 4) + (1 * 3) + (2 * 2) + (3 * 6) = 0 + 3 + 4 + 18 = 25\nF(1) = (0 * 6) + (1 * 4) + (2 * 3) + (3 * 2) = 0 + 4 + 6 + 6 = 16\nF(2) = (0 * 2) + (1 * 6) + (2 * 4) + (3 * 3) = 0 + 6 + 8 + 9 = 23\nF(3) = (0 * 3) + (1 * 2) + (2 * 6) + (3 * 4) = 0 + 2 + 12 + 12 = 26\n所以 F(0), F(1), F(2), F(3) 中的最大值是 F(3) = 26 。\n```\n示例 2:\n```\n输入: nums = [100]\n\n输出: 0\n```\n\n提示:\n* $n = nums.length$\n* $1 <= n <= 10^5$\n* $-100 <= nums[i] <= 100$", "solution": "### 前缀和 + 滑动窗口\n\n为了方便,我们将 $nums$ 的长度记为 $n$。\n\n题目要对「旋转数组」做逻辑,容易想到将 $nums$ 进行复制拼接,得到长度为 $2 \\times n$ 的新数组,在新数组上任意一个长度为 $n$ 的滑动窗口都对应了一个旋转数组。\n\n然后考虑在窗口的滑动过程中,计算结果会如何变化,假设当前我们处理到下标为 $[i, i + n - 1]$ 的滑动窗口,根据题意,当前结果为:\n\n$$\ncur = nums[i] \\times 0 + nums[i + 1] \\times 1  + ... + nums[i + n - 1] \\times (n - 1)\n$$\n\n当窗口往后移动一位,也就是窗口的右端点来到 $i + n$ 的位置,左端点来到 $i + 1$ 的位置。\n\n我们需要增加「新右端点」的值,即增加 $nums[i + n] \\times (n - 1)$,同时减去「旧左端点」的值,即减少 $nums[i] \\times 0$(固定为 $0$),然后更新新旧窗口的公共部分 $[i + 1, i + n - 1]$。\n\n不难发现,随着窗口的逐步右移,每一位公共部分的权值系数都会进行减一。\n\n$$\nnums[i + 1] \\times 1 + nums[i + 2] \\times 2 + ... + nums[i + n - 1] \\times (n - 1)\n$$\n\n变为 \n\n$$\nnums[i + 1] \\times 0 + nums[i + 2] \\times 1 + ... + nums[i + n - 1] \\times (n - 2)\n$$\n\n因此,公共部分的差值为 $\\sum_{idx = i + 1}^{i + n - 1}nums[idx]$,这引导我们可以使用前缀和进行优化。\n\n至此,我们从旧窗口到新窗口的过渡,都是 $O(1)$,整体复杂度为 $O(n)$。\n\n> 实现上,我们并不需要真正对 $nums$ 进行复制拼接,而只需要在计算前缀和数组 $sum$ 进行简单的下标处理即可。\n\n代码:\n```Java\nclass Solution {\n    public int maxRotateFunction(int[] nums) {\n        int n = nums.length;\n        int[] sum = new int[n * 2 + 10];\n        for (int i = 1; i <= 2 * n; i++) sum[i] = sum[i - 1] + nums[(i - 1) % n];\n        int ans = 0;\n        for (int i = 1; i <= n; i++) ans += nums[i - 1] * (i - 1);\n        for (int i = n + 1, cur = ans; i < 2 * n; i++) {\n            cur += nums[(i - 1) % n] * (n - 1);\n            cur -= sum[i - 1] - sum[i - n];\n            if (cur > ans) ans = cur;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.396` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/391-400/397. 整数替换（中等）.md", "url_title": "397. 整数替换", "url": "https://leetcode-cn.com/problems/integer-replacement/solution/gong-shui-san-xie-yi-ti-san-jie-dfsbfs-t-373h/", "difficulty": "中等", "tags": ["DFS", "BFS", "贪心"], "question": "给定一个正整数 `n` ,你可以做如下操作:\n1. 如果 `n` 是偶数,则用  `n / 2` 替换 `n` 。\n2. 如果 `n` 是奇数,则可以用 `n + 1` 或 `n - 1` 替换 `n` 。\n\n`n` 变为 $1$ 所需的最小替换次数是多少?\n\n 示例 1:\n```\n输入:n = 8\n\n输出:3\n\n解释:8 -> 4 -> 2 -> 1\n```\n示例 2:\n```\n输入:n = 7\n\n输出:4\n\n解释:7 -> 8 -> 4 -> 2 -> 1\n或 7 -> 6 -> 3 -> 2 -> 1\n```\n示例 3:\n```\n输入:n = 4\n\n输出:2\n```\n\n提示:\n* $1 <= n <= 2^{31} - 1$", "solution": "### DFS\n\n运用 `DFS` 进行求解。为防止重复处理某些数值,可以使用「哈希表」进行记忆化。\n\n代码:\n```Java\nclass Solution {\n    Map<Long, Integer> map = new HashMap<>();\n    public int integerReplacement(int n) {\n        return dfs(n * 1L);\n    }\n    int dfs(long n) {\n        if (n == 1) return 0;\n        if (map.containsKey(n)) return map.get(n);\n        int ans = n % 2 == 0 ? dfs(n / 2) : Math.min(dfs(n + 1), dfs(n - 1));\n        map.put(n, ++ans);\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(\\log{n})$\n\n---\n\n### BFS\n\n同理,也可以使用 `BFS` 进行求解。同样使用「哈希表」记录步数,进行防止重复处理。\n\n代码:\n```Java\nclass Solution {\n    public int integerReplacement(int n) {\n        if (n == 1) return 0;\n        Map<Long, Integer> map = new HashMap<>();\n        Deque<Long> d = new ArrayDeque<>();\n        d.addLast(n * 1L);\n        map.put(n * 1L, 0);\n        while (!d.isEmpty()) {\n            long t = d.pollFirst();\n            int step = map.get(t);\n            long[] ns = t % 2 == 0 ? new long[]{t / 2} : new long[]{t + 1, t - 1};\n            for (long x : ns) {\n                if (x == 1) return step + 1;\n                if (!map.containsKey(x)) {\n                    map.put(x, step + 1);\n                    d.addLast(x);\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(\\log{n})$\n\n---\n\n### 贪心(位运算)\n\n上述两种做法,我们不可避免地在每个回合枚举了所有我们可以做的决策:主要体现在对 $x$ 为奇数时的处理,我们总是处理 $x + 1$ 和 $x - 1$ 两种情况。\n\n我们可以从二进制的角度进行分析:**给定起始值 $n$,求解将其变为 $(000...0001)_2$ 的最小步数。**\n\n* 对于偶数(二进制最低位为 $0$)而言,我们只能进行一种操作,其作用是将当前值 $x$ 其进行一个单位的右移;\n* 对于奇数(二进制最低位为 $1$)而言,我们能够进行 `+1` 或 `-1` 操作,分析两种操作为 $x$ 产生的影响:\n    * 对于 `+1` 操作而言:最低位必然为 $1$,此时如果次低位为 $0$ 的话, `+1` 相当于将最低位和次低位交换;如果次低位为 $1$ 的话,`+1` 操作将将「从最低位开始,连续一段的 $1$」进行消除(置零),并在连续一段的高一位添加一个 $1$;\n    * 对于 `-1` 操作而言:最低位必然为 $1$,其作用是将最低位的 $1$ 进行消除。\n\n因此,对于 $x$ 为奇数所能执行的两种操作,`+1` 能够消除连续一段的 $1$,只要次低位为 $1$(存在连续段),应当优先使用 `+1` 操作,但需要注意边界 $x = 3$ 时的情况(此时选择 `-1` 操作)。\n\n代码:\n```Java\nclass Solution {\n    public int integerReplacement(int _n) {\n        long n = _n;\n        int ans = 0;\n        while (n != 1) {\n            if (n % 2 == 0) {\n                n >>= 1;\n            } else {\n                if (n != 3 && ((n >> 1) & 1) == 1) n++;\n                else n--;\n            }\n            ans++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.397` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/391-400/398. 随机数索引（中等）.md", "url_title": "398. 随机数索引", "url": "https://leetcode-cn.com/problems/random-pick-index/solution/by-ac_oier-zhml/", "difficulty": "中等", "tags": ["哈希表", "模拟", "随机化", "蓄水池抽样"], "question": "给定一个可能含有重复元素的整数数组,要求随机输出给定的数字的索引。 您可以假设给定的数字一定存在于数组中。\n\n注意:\n\n数组大小可能非常大。 使用太多额外空间的解决方案将不会通过测试。\n\n示例:\n```\nint[] nums = new int[] {1,2,3,3,3};\nSolution solution = new Solution(nums);\n\n// pick(3) 应该返回索引 2,3 或者 4。每个索引的返回概率应该相等。\nsolution.pick(3);\n\n// pick(1) 应该返回 0。因为只有nums[0]等于1。\nsolution.pick(1);\n```\n\n提示:\n* $1 <= nums.length <= 2 * 10^4$\n* $-2^{31} <= nums[i] <= 2^{31} - 1$\n* `target` 确保存在于 `nums` 中\n* 最多调用 $10^4$ 次的 `pick`", "solution": "### 哈希表 预处理(定长数据流)\n\n切换英文补全一下数据范围:\n* $1 <= nums.length <= 2 * 10^4$\n* $-2^{31} <= nums[i] <= 2^{31} - 1$\n* `target` 确保存在于 `nums` 中\n* 最多调用 $10^4$ 次的 `pick`\n\n为了方便,我们令 `nums` 的长度为 $n$,利用 $n$ 的数据范围为 $2 * 10^4$,且完整的数组为初始化时已给出,我们可以通过使用「哈希表 + 预处理」的方式进行求解。\n\n具体的,在构造函数传入 `nums` 时,遍历 `nums` 并存储每个 $nums[i]$ 对应的下标集合,即使用哈希表以 $nums[i]$ 为键,下标集合 `List` 作为值进行存储。\n\n在 `pick` 操作时,通过 $O(1)$ 的复杂度取出所有 $nums[i] = target$ 的集合下标,再随机一个下标进行返回。\n\n代码:\n```Java\nclass Solution {\n    Random random = new Random();\n    Map<Integer, List<Integer>> map = new HashMap<>();\n    public Solution(int[] nums) {\n        int n = nums.length;\n        for (int i = 0; i < n; i++) {\n            List<Integer> list = map.getOrDefault(nums[i], new ArrayList<>());\n            list.add(i);\n            map.put(nums[i], list);\n        }\n    }\n    public int pick(int target) {\n        List<Integer> list = map.get(target);\n        return list.get(random.nextInt(list.size()));\n    }\n}\n```\n* 时间复杂度:初始化的复杂度为 $O(n)$;`pick` 操作的复杂度为 $O(1)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 蓄水池抽样(不定长数据流)\n\n若 `nums` 并不是在初始化时完全给出,而是持续以「流」的形式给出,且数据流的很长,不便进行预处理的话,我们只能使用「蓄水池抽样」的方式求解。\n\n**不了解「蓄水池抽样」的同学可以看前置 🧀 : [多语言入门「蓄水池抽样」知识点](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247490892&idx=1&sn=c1fe373edc88142cbabd383ef3c0669b)**\n\n具体的,我们在每次 `pick` 时对流进行遍历,由于数据流很大,我们不能在遍历过程中使用诸如数组的容器存储所有满足条件的下标,只能对于每个 $nums[i] = target$ 执行「是否要将 $i$ 作为最新答案候选」的操作。\n\n假设共有 $m$ 个下标满足 $nums[i] = target$,我们需要做到以 $\\frac{1}{m}$ 概率返回任一坐标。\n\n我们规定当遇到第 $k$ 个满足 $nums[i] = target$ 的下标时,执行一次 $[0, k)$ 的随机操作,当随机结果为 $0$ 时(发生概率为 $\\frac{1}{k}$),我们将该坐标作为最新的答案候选。\n\n当对每一个 $nums[i] = target$ 的下标都进行上述操作后,容易证明每一位下标返回的概率均为 $\\frac{1}{m}$。\n\n假设最后返回的是第 $k$ 个满足条件的下标,发生概率为 = 第 $k$ 个下标被候选的概率 $\\times$ 后面 $k + 1$ 到 $m$ 个下标不被候选的概率 = $\\frac{1}{k} \\times (1 - \\frac{1}{k + 1}) \\times ... \\times (1 - \\frac{1}{m})$ = $\\frac{1}{m}$ 。\n\n代码:\n```Java\nclass Solution {\n    Random random = new Random();\n    int[] nums;\n    public Solution(int[] _nums) {\n        nums = _nums;\n    }\n    public int pick(int target) {\n        int n = nums.length, ans = 0;\n        for (int i = 0, cnt = 0; i < n; i++) {\n            if (nums[i] == target) {\n                cnt++;\n                if (random.nextInt(cnt) == 0) ans = i;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:初始化的复杂度为 $O(1)$;`pick` 操作的复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.398` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/391-400/400. 第 N 位数字（中等）.md", "url_title": "400. 第 N 位数字", "url": "https://leetcode-cn.com/problems/nth-digit/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-w5wl/", "difficulty": "中等", "tags": ["数学", "模拟"], "question": "给你一个整数 $n$ ,请你在无限的整数序列 `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...]` 中找出并返回第 $n$ 位数字。\n\n示例 1:\n```\n输入:n = 3\n\n输出:3\n```\n示例 2:\n```\n输入:n = 11\n\n输出:0\n\n解释:第 11 位数字在序列 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ... 里是 0 ,它是 10 的一部分。\n```\n\n提示:\n* $1 <= n <= 2^{31} - 1$", "solution": "### 模拟\n\n我们知道,对于长度为 $len$ 的数字的范围为 $[10^{len - 1}, 10^{len} - 1]$(共 $9 * 10^{len - 1}$ 个),总长度为:\n\n$$\nL = len * 9 * 10^{len - 1}\n$$\n\n因此我们可以先对 $n$ 进行不断试减(更新 $n$),确定下来目标数字 $x$ 的长度为多少,假设为 $len$。\n\n然后直接计算出长度 $len$ 的最小值为 $s = 10^{len - 1}$,由于范围内的数长度都是 $len$,因此我们可以直接定位到目标数字 $x$ 为何值。\n\n根据目标值 $x$ 必然满足关系式:\n\n$$\n(x - s + 1) * len \\geq n\n$$\n\n变形可得:\n\n$$\nx \\geq \\left \\lfloor \\frac{n}{len} \\right \\rfloor - 1 + s\n$$\n\n对 $n$ 进行最后一次的试减(更新 $n$),若恰好有 $n = 0$,说明答案为 $x$ 的最后一位,可由 `x % 10` 取得;若大于 $0$,说明答案是 $x + 1$ 的第 $n$ 位(十进制表示,从左往右数),可由 `(x + 1) / (int) (Math.pow(10, len - n)) % 10` 取得。\n\n代码:\n```Java\nclass Solution {\n    public int findNthDigit(int n) {\n        int len = 1;\n        while (len * 9 * Math.pow(10, len - 1) < n) {\n            n -= len * 9 * Math.pow(10, len - 1);\n            len++;\n        }\n        long s = (long) Math.pow(10, len - 1);\n        long x = n / len - 1 + s;\n        n -= (x - s + 1) * len;\n        return n == 0 ? (int) (x % 10) : (int) ((x + 1) / Math.pow(10, len - n) % 10);\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 补充\n\n看到评论区,不少小伙伴对上述推导理解感到困难。我们可以换个思路,从更加纯粹直接的角度进行分析。\n\n首先和上述解法一样,我们还是需要先对 $n$ 进行第一阶段的试减(更新 $n$),得到目标数字所在的数值的长度 $len$ 是多少。\n\n然后根据 $len$ 我们可以算得起点值 $s = 10^{len - 1}$(例如 $len = 2$ 时,$s = 10$;$len = 3$ 时,$s = 100$)。\n\n由于每个数长度都是 $len$,因此我们可以用剩余的数 $n$ 除 $len$,得到从起点的偏移量是多少(并将偏移量累加更新到 $s$),然后对 $n$ 做第二阶段的试减,减去的值就是 $\\left \\lfloor \\frac{n}{len} \\right \\rfloor * len$。\n\n如果试减后结果恰好为 $0$,那么答案为当前 $s$ 的最后一个数字;否则(试减结果大于 $0$),则是 $x + 1$ 中(十进制表示,从左往右数)的第 $n$ 个数字。\n\n代码:\n```Java\nclass Solution {\n    public int findNthDigit(int n) {\n        int len = 1;\n        while (len * 9 * Math.pow(10, len - 1) < n) {\n            n -= len * 9 * Math.pow(10, len - 1);\n            len++;\n        }\n        long s = (long) Math.pow(10, len - 1);\n        s += n / len - 1;\n        n -= len * (n / len);\n        return n == 0 ? (int) (s % 10) : (int) ((s + 1) / Math.pow(10, len - n) % 10);\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n**最终你会发现,两种做法是完全等价的,只是对应了不同的角度描述而已。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.400` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/401-410/401. 二进制手表（简单）.md", "url_title": "401. 二进制手表", "url": "https://leetcode-cn.com/problems/binary-watch/solution/gong-shui-san-xie-jian-dan-ti-xue-da-bia-gwn2/", "difficulty": "简单", "tags": ["打表", "二进制"], "question": "二进制手表顶部有 4 个 LED 代表 小时(0-11),底部的 6 个 LED 代表 分钟(0-59)。每个 LED 代表一个 0 或 1,最低位在右侧。\n\n例如,下面的二进制手表读取 \"3:25\" 。\n\n(图源:WikiMedia - Binary clock samui moon.jpg ,许可协议:Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0) )\n\n给你一个整数 turnedOn ,表示当前亮着的 LED 的数量,返回二进制手表可以表示的所有可能时间。你可以 按任意顺序 返回答案。\n\n小时不会以零开头:\n\n例如,\"01:00\" 是无效的时间,正确的写法应该是 \"1:00\" 。\n分钟必须由两位数组成,可能会以零开头:\n\n例如,\"10:2\" 是无效的时间,正确的写法应该是 \"10:02\" 。\n\n示例 1:\n\n输入:turnedOn = 1\n输出:[\"0:01\",\"0:02\",\"0:04\",\"0:08\",\"0:16\",\"0:32\",\"1:00\",\"2:00\",\"4:00\",\"8:00\"]\n示例 2:\n\n输入:turnedOn = 9\n输出:[]\n\n提示:\n* 0 <= turnedOn <= 10", "solution": "### 打表\n\n具体的,我们可以创建一个 `静态数据结构` 来存储打表信息(需确保全局唯一,即使存在多组测试数据只生成一次打表数据)。\n\n然后在返回数据的时候直接 $O(1)$ 查表返回。\n\nPS. 如果打表逻辑计算量接近 $10^7$ 上限,可以考虑放到本地去做,这里数据量较少,直接放到 `static` 代码块去做即可。\n\n代码:\n```Java\nclass Solution {    \n    // 打表逻辑,也可以放到本地做\n    // 注意使用 static 修饰,确保打表数据只会被生成一次\n    static Map<Integer, List<String>> map = new HashMap<>();\n    static {\n        for (int h = 0; h <= 11; h++) {\n            for (int m = 0; m <= 59; m++) {\n                int tot = getCnt(h) + getCnt(m);\n                List<String> list = map.getOrDefault(tot, new ArrayList<String>());\n                list.add(h + \":\" + (m <= 9 ? \"0\" + m : m));\n                map.put(tot, list);\n            }\n        }\n    }\n    static int getCnt(int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans++;\n        return ans;\n    }\n    static int lowbit(int x) {\n        return x & -x;\n    }\n    public List<String> readBinaryWatch(int t) {\n        return map.getOrDefault(t, new ArrayList<>());\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.401` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/401-410/403. 青蛙过河（困难）.md", "url_title": "403. 青蛙过河", "url": "https://leetcode-cn.com/problems/frog-jump/solution/gong-shui-san-xie-yi-ti-duo-jie-jiang-di-74fw/", "difficulty": "困难", "tags": ["DFS", "BFS", "记忆化搜索", "线性 DP"], "question": "一只青蛙想要过河。 假定河流被等分为若干个单元格,并且在每一个单元格内都有可能放有一块石子(也有可能没有)。 青蛙可以跳上石子,但是不可以跳入水中。\n\n给你石子的位置列表 stones(用单元格序号 升序 表示), 请判定青蛙能否成功过河(即能否在最后一步跳至最后一块石子上)。\n\n开始时, 青蛙默认已站在第一块石子上,并可以假定它第一步只能跳跃一个单位(即只能从单元格 1 跳至单元格 2 )。\n\n如果青蛙上一步跳跃了 k 个单位,那么它接下来的跳跃距离只能选择为 k - 1、k 或 k + 1 个单位。 另请注意,青蛙只能向前方(终点的方向)跳跃。\n\n示例 1:\n```\n输入:stones = [0,1,3,5,6,8,12,17]\n\n输出:true\n\n解释:青蛙可以成功过河,按照如下方案跳跃:跳 1 个单位到第 2 块石子, 然后跳 2 个单位到第 3 块石子, 接着 跳 2 个单位到第 4 块石子, 然后跳 3 个单位到第 6 块石子, 跳 4 个单位到第 7 块石子, 最后,跳 5 个单位到第 8 个石子(即最后一块石子)。\n```\n示例 2:\n```\n输入:stones = [0,1,2,3,4,8,9,11]\n\n输出:false\n\n解释:这是因为第 5 和第 6 个石子之间的间距太大,没有可选的方案供青蛙跳跃过去。\n```\n\n提示:\n\n* 2 <= stones.length <= 2000\n* 0 <= stones[i] <= $2^{31}$ - 1\n* stones[0] == 0", "solution": "### DFS(TLE)\n\n根据题意,我们可以使用 `DFS` 来模拟/爆搜一遍,检查所有的可能性中是否有能到达最后一块石子的。\n\n通常设计 `DFS` 函数时,我们只需要不失一般性的考虑完成第 $i$ 块石子的跳跃需要些什么信息即可:\n\n* 需要知道当前所在位置在哪,也就是需要知道当前石子所在列表中的下标 $u$。\n* 需要知道当前所在位置是经过多少步而来的,也就是需要知道上一步的跳跃步长 $k$。\n\n代码:\n```Java\nclass Solution {\n    Map<Integer, Integer> map = new HashMap<>();\n    public boolean canCross(int[] ss) {\n        int n = ss.length;\n        // 将石子信息存入哈希表\n        // 为了快速判断是否存在某块石子,以及快速查找某块石子所在下标\n        for (int i = 0; i < n; i++) {\n            map.put(ss[i], i);\n        }\n        // check first step\n        // 根据题意,第一步是固定经过步长 1 到达第一块石子(下标为 1)\n        if (!map.containsKey(1)) return false;\n        return dfs(ss, ss.length, 1, 1);\n    }\n\n    /**\n     * 判定是否能够跳到最后一块石子\n     * @param ss 石子列表【不变】\n     * @param n  石子列表长度【不变】\n     * @param u  当前所在的石子的下标\n     * @param k  上一次是经过多少步跳到当前位置的\n     * @return 是否能跳到最后一块石子\n     */\n    boolean dfs(int[] ss, int n, int u, int k) {\n        if (u == n - 1) return true;\n        for (int i = -1; i <= 1; i++) {\n            // 如果是原地踏步的话,直接跳过\n            if (k + i == 0) continue;\n            // 下一步的石子理论编号\n            int next = ss[u] + k + i;\n            // 如果存在下一步的石子,则跳转到下一步石子,并 DFS 下去\n            if (map.containsKey(next)) {\n                boolean cur = dfs(ss, n, map.get(next), k + i);\n                if (cur) return true;\n            }\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(3^n)$\n* 空间复杂度:$O(3^n)$\n\n但数据范围为 $10^3$,直接使用 DFS 肯定会超时。\n\n**我们需要考虑加入「记忆化」功能,或者改为使用带标记的 `BFS`。**\n\n---\n\n### 记忆化搜索\n\n**在考虑加入「记忆化」时,我们只需要将 `DFS` 方法签名中的【可变】参数作为维度,`DFS` 方法中的返回值作为存储值即可。**\n\n通常我们会使用「数组」来作为我们缓存中间结果的容器,\n\n对应到本题,就是需要一个 `boolean[石子列表下标][跳跃步数]` 这样的数组,但使用布尔数组作为记忆化容器往往无法区分「状态尚未计算」和「状态已经计算,并且结果为 `false`」两种情况。\n\n因此我们需要转为使用 `int[石子列表下标][跳跃步数]`,默认值 $0$ 代表状态尚未计算,$-1$ 代表计算状态为 `false`,$1$ 代表计算状态为 `true`。\n\n接下来需要估算数组的容量,可以从「数据范围」入手分析。\n\n根据 `2 <= stones.length <= 2000`,我们可以确定第一维(数组下标)的长度为 $2009$,而另外一维(跳跃步数)是与跳转过程相关的,无法直接确定一个精确边界,但是一个显而易见的事实是,跳到最后一块石子之后的位置是没有意义的,因此我们不会有「跳跃步长」大于「石子列表长度」的情况,因此也可以定为 $2009$(这里是利用了由下标为 $i$ 的位置发起的跳跃不会超过 $i + 1$ 的性质)。\n\n至此,我们定下来了记忆化容器为 `int[][] cache = new int[2009][2009]`。\n\n但是可以看出,上述确定容器大小的过程还是需要一点点分析 & 经验的。\n\n那么是否有思维难度再低点的方法呢?\n\n答案是有的,直接使用「哈希表」作为记忆化容器。「哈希表」本身属于非定长容器集合,我们不需要分析两个维度的上限到底是多少。\n\n**另外,当容器维度较多且上界较大时(例如上述的 `int[2009][2009]`),直接使用「哈希表」可以有效降低「爆空间/时间」的风险(不需要每跑一个样例都创建一个百万级的数组)。**\n\n代码:\n```Java\nclass Solution {\n    Map<Integer, Integer> map = new HashMap<>();\n    // int[][] cache = new int[2009][2009];\n    Map<String, Boolean> cache = new HashMap<>();\n    public boolean canCross(int[] ss) {\n        int n = ss.length;\n        for (int i = 0; i < n; i++) {\n            map.put(ss[i], i);\n        }\n        // check first step\n        if (!map.containsKey(1)) return false;\n        return dfs(ss, ss.length, 1, 1);\n    }\n    boolean dfs(int[] ss, int n, int u, int k) {\n        String key = u + \"_\" + k;\n        // if (cache[u][k] != 0) return cache[u][k] == 1;\n        if (cache.containsKey(key)) return cache.get(key);\n        if (u == n - 1) return true;\n        for (int i = -1; i <= 1; i++) {\n            if (k + i == 0) continue;\n            int next = ss[u] + k + i;\n            if (map.containsKey(next)) {\n                boolean cur = dfs(ss, n, map.get(next), k + i);\n                // cache[u][k] = cur ? 1 : -1;\n                cache.put(key, cur);\n                if (cur) return true;\n            }\n        }\n        // cache[u][k] = -1;\n        cache.put(key, false);\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 动态规划\n\n有了「记忆化搜索」的基础,要写写出来动态规划就变得相对简单了。\n\n**我们可以从 `DFS` 函数出发,写出「动态规划」解法。**\n\n我们的 `DFS` 函数签名为:\n\n```Java\nboolean dfs(int[] ss, int n, int u, int k);\n```\n\n其中前两个参数为不变参数,后两个为可变参数,返回值是我们的答案。\n\n因此可以设定为 $f[][]$ 作为动规数组:\n1. 第一维为可变参数 $u$,代表石子列表的下标,范围为数组 `stones` 长度;\n2. 第二维为可变参数 $k$,代表上一步的的跳跃步长,前面也分析过了,最多不超过数组 `stones` 长度。\n\n**这样的「状态定义」所代表的含义:当前在第 $i$ 个位置,并且是以步长 $k$ 跳到位置 $i$ 时,是否到达最后一块石子。**\n\n那么对于 $f[i][k]$ 是否为真,则取决于上一位置 $j$ 的状态值,结合每次步长的变化为 `[-1,0,1]` 可知:\n\n* 可从 $f[j][k - 1]$ 状态而来:先是经过 $k - 1$ 的跳跃到达位置 $j$,再在原步长的基础上 `+1`,跳到了位置 $i$。\n* 可从 $f[j][k]$ 状态而来:先是经过 $k$ 的跳跃到达位置 $j$,维持原步长不变,跳到了位置 $i$。\n* 可从 $f[j][k + 1]$ 状态而来:先是经过 $k + 1$ 的跳跃到达位置 $j$,再在原步长的基础上 `-1`,跳到了位置 $i$。\n\n只要上述三种情况其中一种为真,则 $f[i][j]$ 为真。\n\n至此,我们解决了动态规划的「状态定义」&「状态转移方程」部分。\n\n但这就结束了吗?还没有。\n\n我们还缺少可让状态递推下去的「有效值」,或者说缺少初始化环节。\n\n因为我们的 $f[i][k]$ 依赖于之前的状态进行“或运算”而来,转移方程本身不会产生 $true$ 值。因此为了让整个「递推」过程可滚动,我们需要先有一个为 $true$ 的状态值。\n\n这时候再回看我们的状态定义:**当前在第 $i$ 个位置,并且是以步长 $k$ 跳到位置 $i$ 时,是否到达最后一块石子。**\n\n显然,我们事先是不可能知道经过「多大的步长」跳到「哪些位置」,最终可以到达最后一块石子。\n\n**这时候需要利用「对偶性」将跳跃过程「翻转」过来分析:**\n\n**我们知道起始状态是「经过步长为 1」的跳跃到达「位置 1」,如果从起始状态出发,存在一种方案到达最后一块石子的话,那么必然存在一条反向路径,它是以从「最后一块石子」开始,并以「某个步长 $k$」开始跳跃,最终以回到位置 1。**\n\n因此我们可以设 $f[1][1] = true$,作为我们的起始值。\n\n**这里本质是利用「路径可逆」的性质,将问题进行了「等效对偶」。表面上我们是进行「正向递推」,但事实上我们是在验证是否存在某条「反向路径」到达位置 $1$。**\n\n建议大家加强理解 ~ \n\n代码:\n```Java\nclass Solution {\n    public boolean canCross(int[] ss) {\n        int n = ss.length;\n        // check first step\n        if (ss[1] != 1) return false;\n        boolean[][] f = new boolean[n + 1][n + 1];\n        f[1][1] = true;\n        for (int i = 2; i < n; i++) {\n            for (int j = 1; j < i; j++) {\n                int k = ss[i] - ss[j];\n                // 我们知道从位置 j 到位置 i 是需要步长为 k 的跳跃\n\n                // 而从位置 j 发起的跳跃最多不超过 j + 1\n                // 因为每次跳跃,下标至少增加 1,而步长最多增加 1 \n                if (k <= j + 1) {\n                    f[i][k] = f[j][k - 1] || f[j][k] || f[j][k + 1];\n                }\n            }\n        }\n        for (int i = 1; i < n; i++) {\n            if (f[n - 1][i]) return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### BFS\n\n事实上,前面我们也说到,解决超时 `DFS` 问题,除了增加「记忆化」功能以外,还能使用带标记的 `BFS`。\n\n**因为两者都能解决 `DFS` 的超时原因:大量的重复计算。**\n\n但为了「记忆化搜索」&「动态规划」能够更好的衔接,所以我把 `BFS` 放到最后。\n\n如果你能够看到这里,那么这里的 `BFS` 应该看起来会相对轻松。\n\n它更多是作为「记忆化搜索」的另外一种实现形式。\n\n代码:\n```Java\nclass Solution {\n    Map<Integer, Integer> map = new HashMap<>();\n    public boolean canCross(int[] ss) {\n        int n = ss.length;\n        for (int i = 0; i < n; i++) {\n            map.put(ss[i], i);\n        }\n        // check first step\n        if (!map.containsKey(1)) return false;\n\n        boolean[][] vis = new boolean[n][n];\n        Deque<int[]> d = new ArrayDeque<>();\n        vis[1][1] = true;\n        d.addLast(new int[]{1, 1});\n\n        while (!d.isEmpty()) {\n            int[] poll = d.pollFirst();\n            int idx = poll[0], k = poll[1];\n            if (idx == n - 1) return true;\n            for (int i = -1; i <= 1; i++) {\n                if (k + i == 0) continue;\n                int next = ss[idx] + k + i;\n                if (map.containsKey(next)) {\n                    int nIdx = map.get(next), nK = k + i;\n                    if (nIdx == n - 1) return true;\n                    if (!vis[nIdx][nK]) {\n                        vis[nIdx][nK] = true;\n                        d.addLast(new int[]{nIdx, nK});\n                    }\n                }\n            }\n        }\n\n        return false;\n    }\n}\n```\n\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.403` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/401-410/405. 数字转换为十六进制数（简单）.md", "url_title": "405. 数字转换为十六进制数", "url": "https://leetcode-cn.com/problems/convert-a-number-to-hexadecimal/solution/gong-shui-san-xie-yi-ti-shuang-jie-jin-z-d93o/", "difficulty": "简单", "tags": ["位运算", "模拟"], "question": "给定一个整数,编写一个算法将这个数转换为十六进制数。对于负整数,我们通常使用 补码运算 方法。\n\n注意:\n1. 十六进制中所有字母(a-f)都必须是小写。\n2. 十六进制字符串中不能包含多余的前导零。如果要转化的数为0,那么以单个字符'0'来表示;对于其他情况,十六进制字符串中的第一个字符将不会是0字符。 \n3. 给定的数确保在32位有符号整数范围内。\n4. 不能使用任何由库提供的将数字直接转换或格式化为十六进制的方法。\n\n示例 1:\n```\n输入:26\n\n输出:\"1a\"\n```\n示例 2:\n```\n输入:-1\n\n输出:\"ffffffff\"\n```", "solution": "### 模拟 + 进制转换\n\n首先,我们可以利用通用的进制转换思路来做,不断循环 `num % k` 和 `num / k` 的操作来构造出 $k$ 进制每一位。\n\n但需要处理「补码」问题:对于负数的 $num$,我们需要先在 $num$ 基础上加上 $2^{32}$ 的偏移量,再进行进制转换。\n\n代码:\n```Java\nclass Solution {\n    public String toHex(int _num) {\n        if (_num == 0) return \"0\";\n        long num = _num;\n        StringBuilder sb = new StringBuilder();\n        if(num < 0) num = (long)(Math.pow(2, 32) + num);\n        while (num != 0) {\n            long u = num % 16;\n            char c = (char)(u + '0');\n            if (u >= 10) c = (char)(u - 10 + 'a');\n            sb.append(c);\n            num /= 16;\n        }\n        return sb.reverse().toString();\n    }\n}\n```\n* 时间复杂度:复杂度取决于构造的十六进制数的长度,固定为 $C = 8$。整体复杂度为 $O(C)$\n* 空间复杂度:复杂度取决于构造的十六进制数的长度,固定为 $C = 8$。整体复杂度为 $O(C)$\n\n---\n\n### 位运算 + 分组换算\n\n将长度为 $32$ 的二进制转换为 $16$ 进制数,本质是对长度为 $32$ 的二进制数进行分组,每 $4$ 个一组(二进制 $(1111)_2$ 表示 $15$,则使用长度为 $4$ 的二进制可以表示 `0-15`)。\n\n同时,由于我们是直接对长度为 $32$ 的二进制进行分组转算($4$ 个为一组,共 $8$ 组),而长度为 $32$ 的二进制本身就是使用补码规则来表示的,因此我们无须额外处理「补码」问题。\n\n具体的,我们将 $num$ 与 $15$ = $(1111)_2$ 进行 `&` 运算,然后对 $num$ 进行无符号右移 $4$ 位来实现每 $4$ 位处理。\n\n代码:\n```Java\nclass Solution {\n    public String toHex(int num) {\n        if (num == 0) return \"0\";\n        StringBuilder sb = new StringBuilder();\n        while (num != 0) {\n            int u = num & 15;\n            char c = (char)(u + '0');\n            if (u >= 10) c = (char)(u - 10 + 'a');\n            sb.append(c);\n            num >>>= 4;\n        }\n        return sb.reverse().toString();\n    }\n}\n```\n* 时间复杂度:复杂度取决于构造的十六进制数的长度,固定为 $C = 8$。整体复杂度为 $O(C)$\n* 空间复杂度:复杂度取决于构造的十六进制数的长度,固定为 $C = 8$。整体复杂度为 $O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.405` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/401-410/406. 根据身高重建队列（中等）.md", "url_title": "406. 根据身高重建队列", "url": "https://leetcode.cn/problems/queue-reconstruction-by-height/solution/by-ac_oier-fda2/", "difficulty": "中等", "tags": ["排序", "构造", "二分", "树状数组"], "question": "假设有打乱顺序的一群人站成一个队列,数组 `people` 表示队列中一些人的属性(不一定按顺序)。每个 $people[i] = [h_i, k_i]$ 表示第 $i$ 个人的身高为 $h_i$ ,前面 正好 有 $k_i$ 个身高大于或等于 $h_i$ 的人。\n\n请你重新构造并返回输入数组 `people` 所表示的队列。返回的队列应该格式化为数组 `queue` ,其中 $queue[j] = [h_j, k_j]$ 是队列中第 $j$ 个人的属性($queue[0]$ 是排在队列前面的人)。\n\n示例 1:\n```\n输入:people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]\n\n输出:[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]\n\n解释:\n编号为 0 的人身高为 5 ,没有身高更高或者相同的人排在他前面。\n编号为 1 的人身高为 7 ,没有身高更高或者相同的人排在他前面。\n编号为 2 的人身高为 5 ,有 2 个身高更高或者相同的人排在他前面,即编号为 0 和 1 的人。\n编号为 3 的人身高为 6 ,有 1 个身高更高或者相同的人排在他前面,即编号为 1 的人。\n编号为 4 的人身高为 4 ,有 4 个身高更高或者相同的人排在他前面,即编号为 0、1、2、3 的人。\n编号为 5 的人身高为 7 ,有 1 个身高更高或者相同的人排在他前面,即编号为 1 的人。\n因此 [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] 是重新构造后的队列。\n```\n示例 2:\n```\n输入:people = [[6,0],[5,0],[4,0],[3,2],[2,2],[1,4]]\n\n输出:[[4,0],[5,0],[2,2],[3,2],[1,4],[6,0]]\n```\n\n提示:\n* $1 <= people.length <= 2000$\n* $0 <= h_i <= 10^6$\n* $0 <= k_i < people.length$\n* 题目数据确保队列可以被重建", "solution": "### 构造 + 二分 + 树状数组\n\n这是一道非常综合的题目。\n\n首先根据双关键字排序:当「高度(第一维)」不同,根据高度排升序,对于高度相同的情况,则根据「编号(第二维)」排降序。\n\n采取这样的排序规则的好处在于:**在从前往后处理某个 $people[i]$ 时,我们可以直接将其放置在「当前空位序列(从左往后统计的,不算已被放置的位置)」中的 $people[i][1] + 1$ 位(预留了前面的 $people[i][1]$ 个位置给后面的数)。**\n\n关于「空位序列」如图所示(黄色代表已被占用,白色代表尚未占用):\n\n具体的,我们按照构造的合理性来解释双关键字排序的合理性,假设当前处理的是 $people[i]$:\n\n根据「高度」排升序,根据「编号」排降序:由于首先是根据「高度」排升序,因此当 $people[i]$ 被放置在「当前空位序列」的第 $people[i][1] + 1$ 之后,无论后面的 $people[j]$ 如何放置,都不会影响 $people[i]$ 的合法性:后面的数的高度都不低于 $people[i][0]$,无论放在 $people[i][1] + 1$ 前面还是后面都不会影响 $people[i]$ 的合法性。\n\n同时对于高度(第一维)相同,编号(第二维)不同的情况,我们进行了「降序」处理,因此「每次将 $people[i]$ 放置在空白序列的 $people[i][1] + 1$ 位置的」的逻辑能够沿用:\n\n**对于「高度」相同「编号」不同的情况,会被按照「从右到左」依次放置,导致了每个 $people[i]$ 被放置时,都不会受到「高度」相同的其他 $people[j]$ 所影响。换句话说,当 $people[i]$ 放置时,其左边必然不存在其他高度为 $people[i][0]$ 的成员。**\n\n剩下的在于,如何快速找到「空白序列中的第 $k$ 个位置」,这可以通过「二分 + 树状数组」来做:\n\n对于已被使用的位置标记为 $1$,未使用的位置为 $0$,那么第一个满足「$0$ 的个数大于等于 $k + 1$」的位置即是目标位置,在长度明确的情况下,求 $0$ 的个数和求 $1$ 的个数等同,对于位置 $x$ 而言(下标从 $1$ 开始,总个数为 $x$),如果在 $[1, x]$ 范围内有 $k + 1$ 个 $0$,等价于有 $x - (k + 1)$ 个 $1$。\n\n求解 $[1, x]$ 范围内 $1$ 的个数等价于求前缀和,即「区间查询」,同时我们每次使用一个新的位置后 ,需要对其进行标记,涉及「单点修改」,因此使用「树状数组」进行求解。\n\n代码:\n```Java\nclass Solution {\n    int n;\n    int[] tr;\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void add(int x, int v) {\n        for (int i = x; i <= n; i += lowbit(i)) tr[i] += v;\n    }\n    int query(int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];\n        return ans;\n    }\n    public int[][] reconstructQueue(int[][] ps) {\n        Arrays.sort(ps, (a, b)->{\n            if (a[0] != b[0]) return a[0] - b[0];\n            return b[1] - a[1];\n        });\n        n = ps.length;\n        tr = new int[n + 1];\n        int[][] ans = new int[n][2];\n        for (int[] p : ps) {\n            int h = p[0], k = p[1];\n            int l = 1, r = n;\n            while (l < r) {\n                int mid = l + r >> 1;\n                if (mid - query(mid) >= k + 1) r = mid;\n                else l = mid + 1;\n            }\n            ans[r - 1] = p;\n            add(r, 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序的复杂度为 $O(n\\log{n})$;共要处理 $n$ 个 $people[i]$,每次处理需要二分,复杂度为 $O(\\log{n})$;每次二分和找到答案后需要操作树状数组,复杂度为 $O(\\log{n})$。整体复杂度为 $O(n \\times \\log{n} \\times \\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.406` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/401-410/407. 接雨水 II（困难）.md", "url_title": "407. 接雨水 II", "url": "https://leetcode-cn.com/problems/trapping-rain-water-ii/solution/gong-shui-san-xie-jing-dian-dijkstra-yun-13ik/", "difficulty": "困难", "tags": ["最短路", "优先队列(堆)"], "question": "给你一个 $m x n$ 的矩阵,其中的值均为非负整数,代表二维高度图每个单元的高度,请计算图中形状最多能接多少体积的雨水。\n\n示例 1:\n\n```\n输入: heightMap = [[1,4,3,1,3,2],[3,2,1,3,2,4],[2,3,3,2,3,1]]\n\n输出: 4\n\n解释: 下雨后,雨水将会被上图蓝色的方块中。总的接雨水量为1+2+1=4。\n```\n示例 2:\n\n```\n输入: heightMap = [[3,3,3,3,3],[3,2,2,2,3],[3,2,1,2,3],[3,2,2,2,3],[3,3,3,3,3]]\n\n输出: 10\n```\n\n提示:\n* m == heightMap.length\n* n == heightMap[i].length\n* 1 <= m, n <= 200\n* $0 <= heightMap[i][j] <= 2 * 10^4$", "solution": "### Dijkstra 变形 + 优先队列(堆)\n\n首先,最外层的一圈(边界)是不会接到任何雨水的(会从边界流出)。\n\n我们定义从点 $(x, y)$ 到边界的路径中出现的最大高度为「路径高度」,路径高度 $h$ 必然满足 $h >= heightMap[x][y]$。\n\n**问题的本质是求「从点 $(x, y)$ 到边界的所有路径高度的最小值为多少」,这个路径高度的最小值与 $(x, y)$ 本身的高度 $heightMap[x][y]$ 之间的差值,即是该点能接到的雨水数量。**\n\n> PS. 对此觉得不好理解的同学,可以尝试从现实角度出发进行考虑:假如该位置是出水口(能够源源不断的出水并往各个方向蔓延),那么该位置最终承载多少水,取决于所有路径高度中的最小值(水流最终会被该路径高度的最小值所拦截),即出水口最终形成的水量为「路径高度最小值」与「出水口起始高度」之间的差值。\n\n我们考虑如何计算某个位置 $(x, y)$ 的所有路径高度中的最小值。\n\n如果是求从 $(x, y)$ 出发的所有路径中,路径总和的最小值,那么可以直接使用 Dijkstra 等单源最短路算法来进行求解。\n\n本题求的是所有路径中,路径高度的最小值,需要对 Dijkstra 进行变形。\n\n首先「从 $(x, y)$ 出发到达边界的路径」也可看作「从边界到达点 $(x, y)$ 的路径」,经过转换操作后,直接计算边界到点 $(x, y)$ 的路径是一个多源点问题。\n\n我们可以考虑引入「超级源点」进行简化:超级源点与所有的边界格子连有一条权值为 $0$ 的边,从而进一步将问题转化为「求从超级源点出发到达 $(x, y)$ 的路径高度的最小值」。\n\n与求最短路的 Dijkstra 类似,我们可以将「使用出队元素更新邻点的松弛操作」等价「使用出队元素更新相邻格子的雨水量」。\n\n**如果我们能够保证被出队元素所更新的高度为最终高度(或者说出队元素的高度为最终高度),那么该做法的正确性就能被 Dijkstra 的正确性所保证。**\n\n我们知道,对于边界格子而言,由于其不能接到任何雨水(即最终高度为起始高度),因此它们可以先进行入队。\n\n然后考虑如何出队并更新邻点可以确保正确性。\n\n对于某个位置 $(x, y)$ 而言,根据「木桶原理」,其最终高度取决于四个方向的邻点的最终高度的最小值。\n\n这引导我们使用优先队列(堆)来做:建立一个小根堆,存储 $(x, y, h)$ 三元组信息( $h$ 为 位置  $(x, y)$ 的最终高度),每次使用出队元素来更新邻点,由于是小根堆,可以确保出队元素是被更新的元素的最小高度的邻点,并且被更新元素会被更新为最终高度,然后将被更新元素进行入队,重复此过程,直到所有位置均被更新。\n\n> 实现上,我们不需要真将超级源点建立出来,只需要起始将所有边界点放入优先队列即可。同时由于每个点只有被第一个出队元素所更新的高度为最终高度,我们还需要使用 $vis$ 数组来避免重复更新。\n\n代码:\n```Java\nclass Solution {\n    public int trapRainWater(int[][] heightMap) {\n        int m = heightMap.length, n = heightMap[0].length;\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[2]-b[2]);\n        boolean[][] vis = new boolean[m][n];\n        for (int i = 0; i < n; i++) {\n            q.add(new int[]{0, i, heightMap[0][i]});\n            q.add(new int[]{m - 1, i, heightMap[m - 1][i]});\n            vis[0][i] = vis[m - 1][i] = true;\n        }\n        for (int i = 1; i < m - 1; i++) {\n            q.add(new int[]{i, 0, heightMap[i][0]});\n            q.add(new int[]{i, n - 1, heightMap[i][n - 1]});\n            vis[i][0] = vis[i][n - 1] = true;\n        }\n        int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n        int ans = 0;\n        while (!q.isEmpty()) {\n            int[] poll = q.poll();\n            int x = poll[0], y = poll[1], h = poll[2];\n            for (int[] d : dirs) {\n                int nx = x + d[0], ny = y + d[1];\n                if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;\n                if (vis[nx][ny]) continue;\n                if (h > heightMap[nx][ny]) ans += h - heightMap[nx][ny];\n                q.add(new int[]{nx, ny, Math.max(heightMap[nx][ny], h)});\n                vis[nx][ny] = true;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:所有的点均进出一次优先队列(堆),复杂度为 $O((m * n)\\log{(m * n)})$\n* 空间复杂度:$O(m * n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.407` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/41-50/41. 缺失的第一个正数（困难）.md", "url_title": "41. 缺失的第一个正数", "url": "https://leetcode-cn.com/problems/first-missing-positive/solution/yan-ge-on-de-tong-pai-xu-si-lu-yi-ji-wei-wm8d/", "difficulty": "困难", "tags": ["桶排序", "原地哈希"], "question": "给你一个未排序的整数数组 `nums` ,请你找出其中没有出现的最小的正整数。\n\n **进阶**:你可以实现时间复杂度为 $O(n)$ 并且只使用常数级别额外空间的解决方案吗? \n\n示例 1:\n```\n输入:nums = [1,2,0]\n\n输出:3\n```\n示例 2:\n```\n输入:nums = [3,4,-1,1]\n\n输出:2\n```\n示例 3:\n```\n输入:nums = [7,8,9,11,12]\n\n输出:1\n```\n\n提示:\n* $0 <= nums.length <= 300$\n* $-2^{31} <= nums[i] <= 2^{31} - 1$", "solution": "### 桶排序(原地哈希)\n\n令数组长度为 `n`,那么答案必然在 `[1, n + 1]` 范围内。\n\n**因此我们可以使用「桶排序」的思路,将每个数放在其应该出现的位置上。**\n\n基本思路为:\n\n1. 按照桶排序思路进行预处理:保证 1 出现在 `nums[0]` 的位置上,2 出现在 `nums[1]` 的位置上,...,`n` 出现在 `nums[n - 1]` 的位置上。不在 `[1, n]` 范围内的数不用动。\n\n例如样例中 `[3,4,-1,1]` 将会被预处理成 `[1,-1,3,4]`。\n\n2. 遍历 `nums`,找到第一个不在应在位置上的 `[1, n]` 的数。如果没有找到,说明数据连续,答案为 `n + 1`\n\n例如样例预处理后的数组 `[1,-1,3,4]` 中第一个 `nums[i] != i + 1` 的是数字 2(i = 1)。\n\n代码:\n```Java\nclass Solution {\n    public int firstMissingPositive(int[] nums) {\n        int n = nums.length;\n        for (int i = 0; i < n; i++) {\n            while (nums[i] >= 1 && nums[i] <= n && nums[i] != i + 1 && nums[i] != nums[nums[i] - 1]) {\n                swap(nums, i, nums[i] - 1);\n            }\n        }   \n        for (int i = 0; i < n; i++) {\n            if (nums[i] != i + 1) return i + 1;\n        }\n        return n + 1;\n    }\n    void swap(int[] nums, int a, int b) {\n        int c = nums[a];\n        nums[a] = nums[b];\n        nums[b] = c;\n    }\n}\n```\n* 时间复杂度:每个数字应该被挪动的数都会被一次性移动到目标位置。复杂度为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.41` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/41-50/42. 接雨水（困难）.md", "url_title": "42. 接雨水", "url": "https://leetcode-cn.com/problems/trapping-rain-water/solution/po-su-jie-fa-on2-cha-zhao-you-hua-on-dan-iu44/", "difficulty": "困难", "tags": ["模拟", "单调栈", "数学"], "question": "给定 `n` 个非负整数表示每个宽度为 `1` 的柱子的高度图,计算按此排列的柱子,下雨之后能接多少雨水。\n\n示例 1:\n\n```\n输入:height = [0,1,0,2,1,0,1,3,2,1,2,1]\n\n输出:6\n\n解释:上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图,在这种情况下,可以接 6 个单位的雨水(蓝色部分表示雨水)。 \n```\n示例 2:\n```\n输入:height = [4,2,0,3,2,5]\n\n输出:9\n```\n\n提示:\n* $n = height.length$\n* $0 <= n <= 2 \\times 10^4$\n* $0 <= height[i] <= 10^5$", "solution": "### 模拟\n\n对每根柱子而言,我们先找出其「左边最高的柱子」和「右边最高的柱子」。\n\n对左右最高柱子取较小值,再和当前柱子高度做比较,即可得出当前位置可以接下的雨水。\n\n同时,边缘的柱子不可能接到雨水(某一侧没有柱子)。\n\n最后注意:该解法计算量会去到 $n^2 = 4 \\times 10^8$,一旦计算量上界接近 $10^7$,我们就需要考虑 `TLE`(超时)问题,在 LeetCode 上该解法 `C++` 无法通过,其他语言目前还能通过。\n\nJava 代码:\n```Java\nclass Solution {\n    public int trap(int[] height) {\n        int n = height.length;\n        int ans = 0;\n        for (int i = 1; i < n - 1; i++) {\n            int cur = height[i];\n\n            // 获取当前位置的左边最大值\n            int l = Integer.MIN_VALUE;\n            for (int j = i - 1; j >= 0; j--) l = Math.max(l, height[j]);\n            if (l <= cur) continue;\n\n            // 获取当前位置的右边边最大值\n            int r = Integer.MIN_VALUE;\n            for (int j = i + 1; j < n; j++) r = Math.max(r, height[j]);\n            if (r <= cur) continue;\n\n            // 计算当前位置可接的雨水\n            ans += Math.min(l, r) - cur;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int trap(vector<int>& height) {\n        int n = height.size();\n        int ans = 0;\n        for (int i = 1; i < n - 1; i++) {\n            int cur = height[i];\n\n            // 获取当前位置的左边最大值\n            int l = INT_MIN;\n            for (int j = i - 1; j >= 0; j--) l = max(l, height[j]);\n            if (l <= cur) continue;\n\n            // 获取当前位置的右边边最大值\n            int r = INT_MIN;\n            for (int j = i + 1; j < n; j++) r = max(r, height[j]);\n            if (r <= cur) continue;\n\n            // 计算当前位置可接的雨水\n            ans += min(l, r) - cur;\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def trap(self, height: List[int]) -> int:\n        n = len(height)\n        ans = 0\n        for i in range(1, n - 1):\n            cur = height[i]\n\n            # 获取当前位置的左边最大值\n            l = max(height[:i])\n            if l <= cur:  continue\n\n            # 获取当前位置的右边最大值\n            r = max(height[i + 1:])\n            if r <= cur: continue\n\n            # 计算当前位置可接的雨水\n            ans += min(l, r) - cur\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction trap(height: number[]): number {\n    const n = height.length;\n    let ans = 0;\n    for (let i = 1; i < n - 1; i++) {\n        const cur = height[i];\n\n        // 获取当前位置的左边最大值\n        const l = Math.max(...height.slice(0, i));\n        if (l <= cur) continue;\n\n        // 获取当前位置的右边最大值\n        const r = Math.max(...height.slice(i + 1));\n        if (r <= cur) continue;\n            \n        // 计算当前位置可接的雨水\n        ans += Math.min(l, r) - cur;\n    }\n    return ans;\n};\n```\n* 时间复杂度:需要处理所有非边缘的柱子,复杂度为 $O(n)$;对于每根柱子而言,需要往两边扫描分别找到最大值,复杂度为 $O(n)$。整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 预处理最值\n\n朴素解法的思路有了,我们想想怎么优化。\n\n事实上,任何的优化无非都是「减少重复」。\n\n想想在朴素思路中有哪些环节比较耗时,耗时环节中又有哪些地方是重复的,可以优化的。\n\n首先对每根柱子进行遍历,求解每根柱子可以接下多少雨水,这个 $O(n)$ 操作肯定省不了。\n\n**但在求解某根柱子可以接下多少雨水时,需要对两边进行扫描,求两侧的最大值。每一根柱子都进行这样的扫描操作,导致每个位置都被扫描了 $n$ 次。这个过程显然是可优化的。**\n\n换句话说:**我们希望通过不重复遍历的方式找到任意位置的两侧最大值。**\n\n问题转化为:**给定一个数组,如何求得任意位置的左半边的最大值和右半边的最大值。**\n\n一个很直观的方案是:**直接将某个位置的两侧最大值存起来。**\n\n我们可以先从两端分别出发,预处理每个位置的「左右最值」,这样可以将我们「查找左右最值」的复杂度降到 $O(1)$。\n\n整体算法的复杂度也从 $O(n^2)$ 下降到 $O(n)$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int trap(int[] height) {\n        int n = height.length;\n        int ans = 0;\n        // 由于预处理最值的时候,我们会直接访问到 height[0] 或者 height[n - 1],因此要特判一下\n        if (n == 0) return ans;\n\n        // 预处理每个位置左边的最值\n        int[] lm = new int[n];\n        lm[0] = height[0];\n        for (int i = 1; i < n; i++) lm[i] = Math.max(height[i], lm[i - 1]);\n        \n        // 预处理每个位置右边的最值\n        int[] rm = new int[n];\n        rm[n - 1] = height[n - 1];\n        for (int i = n - 2; i >= 0; i--) rm[i] = Math.max(height[i], rm[i + 1]);\n\n        for (int i = 1; i < n - 1; i++) {\n            int cur = height[i], l = lm[i], r = rm[i];\n            if (l <= cur || r <= cur) continue;\n            ans += Math.min(l, r) - cur;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int trap(vector<int>& height) {\n        int n = height.size(), ans = 0;\n        // 由于预处理最值的时候,我们会直接访问到 height[0] 或者 height[n - 1],因此要特判一下\n        if (n == 0) return ans;\n\n        vector<int> lm(n, 0), rm(n, 0);\n        // 预处理每个位置左边的最值\n        lm[0] = height[0];\n        for (int i = 1; i < n; i++) lm[i] = max(height[i], lm[i - 1]);\n        // 预处理每个位置右边的最值\n        rm[n - 1] = height[n - 1];\n        for (int i = n - 2; i >= 0; i--) rm[i] = max(height[i], rm[i + 1]);\n\n        for (int i = 1; i < n - 1; i++) {\n            int cur = height[i], l = lm[i], r = rm[i];\n            if (l <= cur || r <= cur) continue;\n            ans += min(l, r) - cur;\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def trap(self, height: List[int]) -> int:\n        n, ans = len(height), 0\n        # 由于预处理最值的时候,我们会直接访问到 height[0] 或者 height[n - 1],因此要特判一下\n        if n == 0: return ans\n\n        lm, rm = [0] * n, [0] * n\n        # 预处理每个位置左边的最值\n        lm[0] = height[0]\n        for i in range(1, n):\n            lm[i] = max(height[i], lm[i - 1])\n\n        # 预处理每个位置右边的最值\n        rm[n - 1] = height[n - 1]\n        for i in range(n - 2, -1, -1):\n            rm[i] = max(height[i], rm[i + 1])\n\n        for i in range(1, n - 1):\n            cur, l, r = height[i], lm[i], rm[i]\n            if l <= cur or r <= cur: continue\n            ans += min(l, r) - cur\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction trap(height: number[]): number {\n    let n = height.length, ans = 0;\n    // 由于预处理最值的时候,我们会直接访问到 height[0] 或者 height[n - 1],因此要特判一下\n    if (n == 0) return ans;\n    \n    const lm = new Array(n).fill(0), rm = new Array(n).fill(0);\n    // 预处理每个位置左边的最值\n    lm[0] = height[0];\n    for (let i = 1; i < n; i++) lm[i] = Math.max(height[i], lm[i - 1]);\n\n    // 预处理每个位置右边的最值\n    rm[n - 1] = height[n - 1];\n    for (let i = n - 2; i >= 0; i--) rm[i] = Math.max(height[i], rm[i + 1]);\n\n    for (let i = 1; i < n - 1; i++) {\n        const cur = height[i], l = lm[i], r = rm[i];\n        if (l <= cur || r <= cur) continue;\n        ans += Math.min(l, r) - cur;\n    }\n    return ans;\n};\n```\n* 时间复杂度:预处理出两个最大值数组,复杂度为 $O(n)$;计算每根柱子可接的雨水量,复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:使用了数组存储两侧最大值。复杂度为 $O(n)$\n\n---\n\n### 单调栈\n\n前面我们讲到,优化思路将问题转化为:**给定一个数组,如何求得任意位置的左半边的最大值和右半边的最大值。**\n\n但仔细一想,其实我们并不需要找两侧最大值,只需要找到两侧最近的比当前位置高的柱子就行了。\n\n针对这一类找最近值的问题,有一个通用解法:**单调栈**。\n\n**单调栈其实就是在栈的基础上,维持一个栈内元素单调。**\n\n在这道题,由于需要找某个位置两侧比其高的柱子(只有两侧有比当前位置高的柱子,当前位置才能接下雨水),我们可以维持栈内元素的单调递减。\n\n**PS. 找某侧最近一个比其大的值,使用单调栈维持栈内元素递减;找某侧最近一个比其小的值,使用单调栈维持栈内元素递增 ...**\n\n当某个位置的元素弹出栈时,例如位置 `a` ,我们自然可以得到 `a` 位置两侧比 `a` 高的柱子:\n\n* 一个是导致 `a` 位置元素弹出的柱子( `a` 右侧比 `a` 高的柱子)\n* 一个是 `a` 弹栈后的栈顶元素(`a` 左侧比 `a` 高的柱子)\n\n当有了 `a` 左右两侧比 `a` 高的柱子后,便可计算 `a` 位置可接下的雨水量。\n\nJava 代码:\n```Java\nclass Solution {\n    public int trap(int[] height) {\n        int n = height.length, ans = 0;\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            while (!d.isEmpty() && height[i] > height[d.peekLast()]) {\n                int cur = d.pollLast();\n                // 如果栈内没有元素,说明当前位置左边没有比其高的柱子,跳过\n                if (d.isEmpty()) continue;\n                // 左右位置,并由左右位置得出「宽度」和「高度」\n                int l = d.peekLast(), r = i;\n                int w = r - l + 1 - 2, h = Math.min(height[l], height[r]) - height[cur];\n                ans += w * h;\n            }\n            d.addLast(i);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int trap(vector<int>& height) {\n        int n = height.size(), ans = 0;\n        deque<int> d;\n        for (int i = 0; i < n; i++) {\n            while (!d.empty() && height[i] > height[d.back()]) {\n                int cur = d.back();\n                d.pop_back();\n                // 如果栈内没有元素,说明当前位置左边没有比其高的柱子,跳过\n                if (d.empty()) continue;\n                // 左右位置,并由左右位置得出「宽度」和「高度」\n                int l = d.back(), r = i;\n                int w = r - l + 1 - 2, h = min(height[l], height[r]) - height[cur];\n                ans += w * h;\n            }\n            d.push_back(i);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def trap(self, height: List[int]) -> int:\n        n, ans = len(height), 0\n        d = deque()\n        for i in range(n):\n            while d and height[i] > height[d[-1]]:\n                cur = d.pop()\n                # 如果栈内没有元素,说明当前位置左边没有比其高的柱子,跳过\n                if not d: continue\n                # 左右位置,并由左右位置得出「宽度」和「高度」\n                l, r = d[-1], i\n                w, h = r - l + 1 - 2, min(height[l], height[r]) - height[cur]\n                ans += w * h\n            d.append(i)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction trap(height: number[]): number {\n    let n = height.length, ans = 0;\n    const d = [];\n    for (let i = 0; i < n; i++) {\n        while (d.length && height[i] > height[d[d.length - 1]]) {\n            const cur = d.pop() as number;\n            // 如果栈内没有元素,说明当前位置左边没有比其高的柱子,跳过\n            if (!d.length) continue;\n            // 左右位置,并由左右位置得出「宽度」和「高度」\n            const l = d[d.length - 1], r = i;\n            const w = r - l + 1 - 2, h = Math.min(height[l], height[r]) - height[cur];\n            ans += w * h;\n        }\n        d.push(i);\n    }\n    return ans;\n};\n```\n* 时间复杂度:每个元素最多进栈和出栈一次。复杂度为 $O(n)$\n* 空间复杂度:栈最多存储 $n$ 个元素。复杂度为 $O(n)$\n\n---\n\n### 面积差值\n\n事实上,我们还能利用「面积差值」来进行求解。\n\n我们先统计出「柱子面积」$sum$ 和「以柱子个数为宽、最高柱子高度为高的矩形面积」$full$。\n\n然后分别「从左往右」和「从右往左」计算一次最大高度覆盖面积 $lSum$ 和 $rSum$。\n\n**显然会出现重复面积,并且重复面积只会独立地出现在「山峰」的左边和右边。**\n\n利用此特性,我们可以通过简单的等式关系求解出「雨水面积」:\n\nJava 代码:\n```Java\nclass Solution {\n    public int trap(int[] height) {\n        int n = height.length;\n\n        int sum = 0, max = 0;\n        for (int i = 0; i < n; i++) {\n            int cur = height[i];\n            sum += cur;\n            max = Math.max(max, cur);\n        }\n        int full = max * n;\n\n        int lSum = 0, lMax = 0;\n        for (int i = 0; i < n; i++) {\n            lMax = Math.max(lMax, height[i]);\n            lSum += lMax;\n        }\n\n        int rSum = 0, rMax = 0;\n        for (int i = n - 1; i >= 0; i--) {\n            rMax = Math.max(rMax, height[i]);\n            rSum += rMax;\n        }\n\n        return lSum + rSum - full - sum;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int trap(vector<int>& height) {\n        int n = height.size();\n\n        int sum = 0, maxv = 0;\n        for (int i = 0; i < n; i++) {\n            int cur = height[i] * 1L;\n            sum += cur;\n            maxv = max(maxv, cur);\n        }\n        int full = maxv * n;\n\n        int lSum = 0, lMax = 0;\n        for (int i = 0; i < n; i++) {\n            lMax = max(lMax, height[i]);\n            lSum += lMax;\n        }\n\n        int rSum = 0, rMax = 0;\n        for (int i = n - 1; i >= 0; i--) {\n            rMax = max(rMax, height[i]);\n            rSum += rMax;\n        }\n\n        return lSum - full - sum + rSum; // 考虑到 C++ 溢出报错, 先减后加\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def trap(self, height: List[int]) -> int:\n        n = len(height)\n\n        sum_val, max_val = 0, 0\n        for cur in height:\n            sum_val += cur\n            max_val = max(max_val, cur)\n        full = max_val * n\n\n        l_sum, l_max = 0, 0\n        for h in height:\n            l_max = max(l_max, h)\n            l_sum += l_max\n\n        r_sum, r_max = 0, 0\n        for i in range(n - 1, -1, -1):\n            r_max = max(r_max, height[i])\n            r_sum += r_max\n\n        return l_sum + r_sum - full - sum_val\n```\nTypeScript 代码:\n```TypeScript\nfunction trap(height: number[]): number {\n    const n = height.length;\n\n    let sum = 0, max = 0;\n    for (let i = 0; i < n; i++) {\n        const cur = height[i];\n        sum += cur;\n        max = Math.max(max, cur);\n    }\n    const full = max * n;\n\n    let lSum = 0, lMax = 0;\n    for (let i = 0; i < n; i++) {\n        lMax = Math.max(lMax, height[i]);\n        lSum += lMax;\n    }\n\n    let rSum = 0, rMax = 0;\n    for (let i = n - 1; i >= 0; i--) {\n        rMax = Math.max(rMax, height[i]);\n        rSum += rMax;\n    }\n\n    return lSum + rSum - full - sum;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.42` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/41-50/43. 字符串相乘（中等）.md", "url_title": "43. 字符串相乘", "url": "https://leetcode-cn.com/problems/multiply-strings/solution/zhi-yao-ni-hui-shou-suan-cheng-fa-zhe-ti-ainl/", "difficulty": "中等", "tags": ["数学", "模拟"], "question": "给定两个以字符串形式表示的非负整数 `num1` 和 `num2`,返回 `num1` 和 `num2` 的乘积,它们的乘积也表示为字符串形式。\n\n示例 1:\n```\n输入: num1 = \"2\", num2 = \"3\"\n\n输出: \"6\"\n```\n示例 2:\n```\n输入: num1 = \"123\", num2 = \"456\"\n\n输出: \"56088\"\n```\n说明:\n* `num1` 和 `num2` 的长度小于 $110$。\n* `num1` 和 `num2` 只包含数字 `0-9`。\n* `num1` 和 `num2` 均不以零开头,除非是数字 `0` 本身。\n* **不能使用任何标准库的大数类型(比如 BigInteger)或直接将输入转换为整数来处理。**", "solution": "### 模拟\n\n本质上是道模拟题,模拟手算乘法的过程。\n\n想要做出这道题,需要知道一个数学定理:\n\n**两个长度分别为 `n` 和 `m` 的数相乘,长度不会超过 `n + m`。**\n\n因此我们可以创建一个长度为 `n + m` 的数组 `res` 存储结果。\n\n另外,最后拼接结果时需要注意忽略前导零。\n\nJava 代码:\n```Java\nclass Solution {\n    public String multiply(String n1, String n2) {\n        int n = n1.length(), m = n2.length();\n        int[] res = new int[n + m];\n        for (int i = n - 1; i >= 0; i--) {\n            for (int j = m - 1; j >= 0; j--) {\n                int a = n1.charAt(i) - '0', b = n2.charAt(j) - '0';\n                int r = a * b;\n                r += res[i + j + 1];\n                res[i + j + 1] = r % 10;\n                res[i + j] += r / 10;\n            }\n        }\n        StringBuilder sb = new StringBuilder();\n        for (int i = 0; i < n + m; i++) {\n            if (sb.length() == 0 && res[i] == 0) continue;\n            sb.append(res[i]);\n        }\n        return sb.length() == 0 ? \"0\" : sb.toString();\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    string multiply(string num1, string num2) {\n        int n = num1.length(), m = num2.length();\n        vector<int> res(n + m, 0);\n        for (int i = n - 1; i >= 0; i--) {\n            for (int j = m - 1; j >= 0; j--) {\n                int a = num1[i] - '0', b = num2[j] - '0';\n                int r = a * b;\n                r += res[i + j + 1];\n                res[i + j + 1] = r % 10;\n                res[i + j] += r / 10;\n            }\n        }\n        string result;\n        for (int i = 0; i < n + m; i++) {\n            if (result.empty() && res[i] == 0) continue;\n            result.push_back(res[i] + '0');\n        }\n        return result.empty() ? \"0\" : result;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def multiply(self, num1: str, num2: str) -> str:\n        n, m = len(num1), len(num2)\n        res = [0] * (n + m)\n        for i in range(n - 1, -1, -1):\n            for j in range(m - 1, -1, -1):\n                a, b = int(num1[i]), int(num2[j])\n                r = a * b\n                r += res[i + j + 1]\n                res[i + j + 1] = r % 10\n                res[i + j] += r // 10\n        result = ''.join(str(x) for x in res).lstrip('0')\n        return result if result else '0'\n```\nTypeScript 代码:\n```TypeScript\nfunction multiply(num1: string, num2: string): string {\n    const n = num1.length, m = num2.length;\n    const res = new Array(n + m).fill(0);\n    for (let i = n - 1; i >= 0; i--) {\n        for (let j = m - 1; j >= 0; j--) {\n            const a = parseInt(num1[i]), b = parseInt(num2[j]);\n            let r = a * b;\n            r += res[i + j + 1];\n            res[i + j + 1] = r % 10;\n            res[i + j] += Math.floor(r / 10);\n        }\n    }\n    let result = \"\";\n    for (let i = 0; i < n + m; i++) {\n        if (result.length == 0 && res[i] == 0) continue;\n        result += res[i].toString();\n    }\n    return result.length == 0 ? \"0\" : result;  \n};\n```\n* 时间复杂度:使用 `n` 和 `m` 分别代表两个数的长度。复杂度为 $O(n \\times m)$\n* 空间复杂度:使用了长度为 `m + n` 的数组存储结果。复杂度为 $O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.43` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/41-50/44. 通配符匹配（困难）.md", "url_title": "44. 通配符匹配", "url": "https://leetcode-cn.com/problems/wildcard-matching/solution/gong-shui-san-xie-xiang-jie-dong-tai-gui-ifyx/", "difficulty": "困难", "tags": ["动态规划", "序列 DP"], "question": "给定一个字符串 (`s`) 和一个字符模式 (`p`) ,实现一个支持 `'?'` 和 `'*'` 的通配符匹配。\n\n* `'?'` 可以匹配任何单个字符。\n* `'*'` 可以匹配任意字符串(包括空字符串)。\n\n两个字符串完全匹配才算匹配成功。\n\n说明:\n\n* `s` 可能为空,且只包含从 `a-z` 的小写字母。\n* `p` 可能为空,且只包含从 `a-z` 的小写字母,以及字符 `?` 和 `*`。\n\n示例 1:\n```\n输入:\ns = \"aa\"\np = \"a\"\n\n输出: false\n\n解释: \"a\" 无法匹配 \"aa\" 整个字符串。\n```\n示例 2:\n```\n输入:\ns = \"aa\"\np = \"*\"\n\n输出: true\n\n解释: '*' 可以匹配任意字符串。\n```\n示例 3:\n```\n输入:\ns = \"cb\"\np = \"?a\"\n\n输出: false\n\n解释: '?' 可以匹配 'c', 但第二个 'a' 无法匹配 'b'。\n```\n示例 4:\n```\n输入:\ns = \"adceb\"\np = \"*a*b\"\n\n输出: true\n\n解释: \n第一个 '*' 可以匹配空字符串, \n第二个 '*' 可以匹配字符串 \"dce\".\n```\n示例 5:\n```\n输入:\ns = \"acdcb\"\np = \"a*c?b\"\n\n输出: false\n```", "solution": "### 动态规划\n\n这道题与 [10. 正则表达式匹配](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247484130&idx=1&sn=af3517194634dde1652ec72eb5ea9ff2&chksm=fd9ca9fdcaeb20eb1fd7509e3adf8fee6f75d77b8afbd30067ac11a56bd77b5066b0f164eb49&token=840813710&lang=zh_CN#rd) 的分析思路是类似的。\n\n但和第 10 题相比,本题要简单一些。\n\n整理一下题意,对于字符串 `p` 而言,有三种字符:\n\n* 普通字符:需要和 `s` 中同一位置的字符完全匹配\n\n* `'?'`:能够匹配 `s` 中同一位置的任意字符\n\n* `'*'`:能够匹配任意字符串\n\n所以本题关键是分析当出现 `'*'` 这种字符时,是匹配 0 个字符、还是 1 个字符、还是 2 个字符 ...\n\n本题可以使用动态规划进行求解:\n\n* 状态定义:`f(i,j)` 代表考虑 `s` 中以 `i` 为结尾的子串和 `p` 中的 `j` 为结尾的子串是否匹配。最终我们要求的结果为 `f[n][m]` 。\n\n* 状态转移:也就是我们要考虑 `f(i,j)` 如何求得,前面说到了 `p` 有三种字符,所以这里的状态转移也要分三种情况讨论:\n  \n  1. `p[j]` 为普通字符:匹配的条件是前面的字符匹配,同时 `s` 中的第 `i` 个字符和 `p` 中的第 `j` 位相同。 \n  \n      即 `f(i,j) = f(i - 1, j - 1) && s[i] == p[j]` 。\n  \n  2. `p[j]` 为 `'?'`:匹配的条件是前面的字符匹配,`s` 中的第 `i` 个字符可以是任意字符。\n  \n      即 `f(i,j) = f(i - 1, j - 1) && p[j] == '?'`。\n  \n  3. `p[j]` 为 `'*'`:可匹配任意长度的字符,可以匹配 0 个字符、匹配 1 个字符、匹配 2 个字符\n  \n      3.1. 当匹配为 0 个:`f(i,j) = f(i, j - 1)`\n  \n      3.2. 当匹配为 1 个:`f(i,j) = f(i - 1, j - 1)`\n  \n      3.3. 当匹配为 2 个:`f(i,j) = f(i - 2, j - 1)`\n  \n      ...\n  \n      3.k. 当匹配为 k 个:`f(i,j) = f(i - k, j - 1)`\n  \n\n因此对于 `p[j] = '*'` 的情况,想要 `f(i, j) = true`,只需要其中一种情况为 `true` 即可。\n\n也就是状态之间是「或」的关系:\n$$\nf[i][j] = f[i][j - 1] || f[i - 1][j - 1] || ... || f[i - k][j - 1] (i >= k)\n$$\n\n这意味着我们要对 `k` 种情况进行枚举检查吗?\n\n其实并不用,对于这类问题,我们通常可以通过「代数」进简化,将 `i - 1` 代入上述的式子:\n\n$$\nf[i - 1][j] = f[i - 1][j - 1] || f[i - 2][j - 1] || ... || f[i - k][j - 1] (i >= k)\n$$\n\n可以发现,`f[i - 1][j]` 与 `f[i][j]` 中的 `f[i][j - 1]` 开始的后半部分是一样的。\n\n因此有:\n\n$$\nf[i][j] = f[i][j - 1] || f[i - 1][j] (i >= 1)\n$$\n\n*PS. 其实类似的推导,我在 [10. 正则表达式匹配](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247484130&idx=1&sn=af3517194634dde1652ec72eb5ea9ff2&chksm=fd9ca9fdcaeb20eb1fd7509e3adf8fee6f75d77b8afbd30067ac11a56bd77b5066b0f164eb49&token=840813710&lang=zh_CN#rd) 也做过,第 10 题的推导过程还涉及等差概念,我十分推荐你去回顾一下。如果你能搞懂第 10 题整个过程,这题其实就是小 Case。*\n\n编码细节:\n\n1. 通过上述的推导过程,你会发现设计不少的「回退检查」操作(即遍历到 `i` 位,要回头检查 `i - 1` 等),因此我们可以将「哨兵技巧」应用到本题,往两个字符串的头部插入哨兵\n2. 对于 `p[j] = '?'` 和 `p[j] = 普通字符` 的情况,想要为 `true`,其实有共同的条件 `f[i - 1][j - 1] == true`,因此可以合到一起来做\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean isMatch(String s, String p) {\n        int n = s.length(), m = p.length();\n        // 技巧:往原字符头部插入空格,这样得到 char 数组是从 1 开始,而且可以使得 f[0][0] = true,可以将 true 这个结果滚动下去\n        s = \" \" + s; p = \" \" + p;\n        char[] ss = s.toCharArray(), pp = p.toCharArray();\n        // f(i,j) 代表考虑 s 中的 1~i 字符和 p 中的 1~j 字符 是否匹配\n        boolean[][] f = new boolean[n + 1][m + 1];\n        f[0][0] = true;\n        for (int i = 0; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                if (pp[j] == '*') {\n                    f[i][j] = f[i][j - 1] || (i - 1 >= 0 && f[i - 1][j]);\n                } else {\n                    f[i][j] = i - 1 >= 0 && f[i - 1][j - 1] && (ss[i] == pp[j] || pp[j] == '?');\n                }\n            }\n        }\n        return f[n][m];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool isMatch(string s, string p) {\n        int n = s.length(), m = p.length();\n        s = \" \" + s; p = \" \" + p;\n        vector<vector<bool>> f(n + 1, vector<bool>(m + 1, false));\n        f[0][0] = true;\n        for (int i = 0; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                if (p[j] == '*') {\n                    f[i][j] = f[i][j - 1] || (i - 1 >= 0 && f[i - 1][j]);\n                } else {\n                    f[i][j] = i - 1 >= 0 && f[i - 1][j - 1] && (s[i] == p[j] || p[j] == '?');\n                }\n            }\n        }\n        return f[n][m];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def isMatch(self, s: str, p: str) -> bool:\n        n, m = len(s), len(p)\n        s = \" \" + s\n        p = \" \" + p\n        f = [[False] * (m + 1) for _ in range(n + 1)]\n        f[0][0] = True\n        for i in range(n + 1):\n            for j in range(1, m + 1):\n                if p[j] == '*':\n                    f[i][j] = f[i][j - 1] or (i - 1 >= 0 and f[i - 1][j])\n                else:\n                    f[i][j] = i - 1 >= 0 and f[i - 1][j - 1] and (s[i] == p[j] or p[j] == '?')\n        return f[n][m]\n```\nTypeScript 代码:\n```TypeScript\nfunction isMatch(s: string, p: string): boolean {\n    const n = s.length, m = p.length;\n    s = \" \" + s;\n    p = \" \" + p;\n    const f = new Array(n + 1).fill(false).map(() => new Array(m + 1).fill(false));\n    f[0][0] = true;\n    for (let i = 0; i <= n; i++) {\n        for (let j = 1; j <= m; j++) {\n            if (p[j] === '*') {\n                f[i][j] = f[i][j - 1] || (i - 1 >= 0 && f[i - 1][j]);\n            } else {\n                f[i][j] = i - 1 >= 0 && f[i - 1][j - 1] && (s[i] === p[j] || p[j] === '?');\n            }\n        }\n    }\n    return f[n][m];\n};\n```\n* 时间复杂度:`n` 表示 `s` 的长度,`m` 表示 `p` 的长度,总共 $n \\times m$ 个状态。复杂度为 $O(n \\times m)$\n* 空间复杂度:使用了二维数组记录结果。复杂度为 $O(n \\times m)$\n\n**再次强调,动态规划本质上是枚举(不重复的暴力枚举),因此其复杂度很好分析,有多少个状态就要被计算多少次,复杂度就为多少。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.44` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/41-50/45. 跳跃游戏 II（中等）.md", "url_title": "45. 跳跃游戏 II", "url": "https://leetcode-cn.com/problems/jump-game-ii/solution/xiang-jie-dp-tan-xin-shuang-zhi-zhen-jie-roh4/", "difficulty": "中等", "tags": ["贪心", "线性 DP", "双指针"], "question": "给定一个非负整数数组,你最初位于数组的第一个位置。\n\n数组中的每个元素代表你在该位置可以跳跃的最大长度。\n\n你的目标是使用最少的跳跃次数到达数组的最后一个位置。\n\n假设你总是可以到达数组的最后一个位置。\n\n示例 1:\n```\n输入: [2,3,1,1,4]\n\n输出: 2\n\n解释: 跳到最后一个位置的最小跳跃数是 2。\n     从下标为 0 跳到下标为 1 的位置,跳 1 步,然后跳 3 步到达数组的最后一个位置。\n```\n示例 2:\n```\n输入: [2,3,0,1,4]\n\n输出: 2\n```\n\n提示:\n* 1 <= nums.length <= 1000\n* 0 <= nums[i] <= $10^5$", "solution": "### BFS\n\n对于这一类问题,我们一般都是使用 BFS 进行求解。\n\n本题的 BFS 解法的复杂度是 $O(n^2)$,数据范围为 $10^3$,可以过。\n\n代码:\n```Java\nclass Solution {\n    public int jump(int[] nums) {\n        int n = nums.length;\n        int ans = 0;\n        boolean[] st = new boolean[n];\n        Deque<Integer> d = new ArrayDeque<>();\n        st[0] = true;\n        d.addLast(0);\n        while (!d.isEmpty()) {\n            int size = d.size();\n            while (size-- > 0) {\n                int idx = d.pollFirst();\n                if (idx == n - 1) return ans;\n                for (int i = idx + 1; i <= idx + nums[idx] && i < n; i++) {\n                    if (!st[i]) {\n                        st[i] = true;\n                        d.addLast(i);\n                    }\n                }\n            }\n            ans++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:如果每个点跳跃的距离足够长的话,每次都会将当前点「后面的所有点」进行循环入队操作(由于 st 的存在,不一定都能入队,但是每个点都需要被循环一下)。复杂度为 $O(n^2)$\n* 空间复杂度:队列中最多有 $n - 1$ 个元素。复杂度为 $O(n)$\n\n---\n\n### 双指针 + 贪心 + 动态规划\n\n本题数据范围只有 $10^3$,所以 $O(n^2)$ 勉强能过。\n\n*如果面试官要将数据范围出到 $10^6$,又该如何求解呢?*\n\n*我们需要考虑 $O(n)$ 的做法。*\n\n其实通过 $10^6$ 这个数据范围,就已经可以大概猜到是道 DP 题。\n\n我们定义 $f[i]$ 为到达第 $i$ 个位置所需要的最少步数,那么答案是 $f[n - 1]$。\n\n学习过 [路径 DP 专题](https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MzU4NDE3MTEyMA==&action=getalbum&album_id=1773144264147812354&scene=173&from_msgid=2247485565&from_itemidx=1&count=3&scene=21#wechat_redirect) 的同学应该知道,通常确定 DP 的「状态定义」有两种方法。\n\n* 一种是根据经验猜一个状态定义,会结合题目给定的维度,和要求的答案去猜。\n\n* 另外一种则是通过设计一个合理的 `DFS` 方法签名来确定状态定义。\n\n这里我是采用第一种方法。\n\n至于如何确定「状态定义」是否可靠,关键是看使用这个状态定义能否推导出合理的「状态转移方程」,来覆盖我们所有的状态。\n\n不失一般性的考虑 $f[n - 1]$ 该如何转移:\n\n我们知道最后一个点前面可能会有很多个点能够一步到达最后一个点。\n\n也就是有 $f[n - 1] = min(f[n - k],...,f[n - 3],f[n - 2]) + 1$。\n\n然后我们再来考虑集合 $f[n - k],...,f[n - 3],f[n - 2]$ 有何特性。\n\n不然发现其实必然有 $f[n - k] <= ...<= f[n - 3] <= f[n - 2]$。\n\n推而广之,不止是经过一步能够到达最后一个点的集合,其实任意连续的区间都有这个性质。\n\n*举个🌰,比如我经过至少 5 步到达第 $i$ 个点,那么必然不可能出现使用步数少于 5 步就能达到第 $i + 1$ 个点的情况。到达第 $i + 1$ 个点的至少步数必然是 5 步或者 6 步。*\n\n搞清楚性质之后,再回头看我们的状态定义:*$f[i]$ 为到达第 $i$ 个位置所需要的最少步数。*\n\n因此当我们要求某一个 $f[i]$ 的时候,我们需要找到最早能够经过一步到达 $i$ 点的 $j$ 点。\n\n即有状态转移方程:$f[i] = f[j] + 1$。\n\n也就是我们每次都贪心的取离 $i$ 点最远的点 $j$ 来更新 $f[i]$。\n\n而这个找 $j$ 的过程可以使用双指针来找。\n\n因此这个思路其实是一个「双指针 + 贪心 + 动态规划」的一个解法。\n\n代码:\n```Java\nclass Solution {\n    public int jump(int[] nums) {\n        int n = nums.length;\n        int[] f = new int[n]; \n        for (int i = 1, j = 0; i < n; i++) {\n            while (j + nums[j] < i) j++;\n            f[i] = f[j] + 1;\n        }\n        return f[n - 1];\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.45` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/411-420/412. Fizz Buzz（简单）.md", "url_title": "412. Fizz Buzz", "url": "https://leetcode-cn.com/problems/fizz-buzz/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-jll0/", "difficulty": "简单", "tags": ["模拟"], "question": "写一个程序,输出从 `1` 到 `n` 数字的字符串表示。\n\n1. 如果 `n` 是 `3` 的倍数,输出 `“Fizz”`;\n\n2. 如果 `n` 是 `5` 的倍数,输出 `“Buzz”`;\n\n3. 如果 `n` 同时是 `3` 和 `5` 的倍数,输出 `“FizzBuzz”`。\n\n示例:\n```\nn = 15,\n\n返回:\n[\n    \"1\",\n    \"2\",\n    \"Fizz\",\n    \"4\",\n    \"Buzz\",\n    \"Fizz\",\n    \"7\",\n    \"8\",\n    \"Fizz\",\n    \"Buzz\",\n    \"11\",\n    \"Fizz\",\n    \"13\",\n    \"14\",\n    \"FizzBuzz\"\n]\n```", "solution": "### 模拟\n\n根据题意进行模拟。\n\n代码:\n```Java\nclass Solution {\n    public List<String> fizzBuzz(int n) {\n        List<String> ans = new ArrayList<>();\n        for (int i = 1; i <= n; i++) {\n            String cur = \"\";\n            if (i % 3 == 0) cur += \"Fizz\";\n            if (i % 5 == 0) cur += \"Buzz\";\n            if (cur.length() == 0) cur = i + \"\";\n            ans.add(cur);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.412` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/411-420/413. 等差数列划分（中等）.md", "url_title": "413. 等差数列划分", "url": "https://leetcode-cn.com/problems/arithmetic-slices/solution/gong-shui-san-xie-shuang-zhi-zhen-qiu-ji-ef1q/", "difficulty": "中等", "tags": ["双指针", "模拟", "数学"], "question": "如果一个数列 至少有三个元素 ,并且任意两个相邻元素之差相同,则称该数列为等差数列。\n\n例如,[1,3,5,7,9]、[7,7,7,7] 和 [3,-1,-5,-9] 都是等差数列。\n\n给你一个整数数组 nums ,返回数组 nums 中所有为等差数组的 子数组 个数。\n\n子数组 是数组中的一个连续序列。\n\n示例 1:\n```\n输入:nums = [1,2,3,4]\n\n输出:3\n\n解释:nums 中有三个子等差数组:[1, 2, 3]、[2, 3, 4] 和 [1,2,3,4] 自身。\n```\n示例 2:\n```\n输入:nums = [1]\n\n输出:0\n```\n\n提示:\n* $1 <= nums.length <= 5000$\n* $-1000 <= nums[i] <= 1000$", "solution": "### 双指针\n\n具体的,我们可以枚举 $i$ 作为差值为 $d$ 的子数组的左端点,然后通过「双指针」的方式找到当前等差并最长的子数组的右端点 $j$,令区间 $[i, j]$ 长度为 $len$。\n\n那么显然,符合条件的子数组的数量为:\n\n$$\ncnt = \\sum_{k = 3}^{len}countWithArrayLength(k)\n$$\n\n函数 `int countWithArrayLength(int k)` 求的是长度为 $k$ 的子数组的数量。\n\n不难发现,随着入参 $k$ 的逐步减小,函数返回值逐步增大。\n\n因此上述结果 $cnt$ 其实是一个 **首项为 $1$,末项为 $len - 3 + 1$,公差为 $1$ 的等差数列的求和结果**。直接套用「等差数列求和」公式求解即可。\n\n代码:\n```Java\nclass Solution {\n    public int numberOfArithmeticSlices(int[] nums) {\n        int n = nums.length;\n        int ans = 0;\n        for (int i = 0; i < n - 2; ) {\n            int j = i, d = nums[i + 1] - nums[i];\n            while (j + 1 < n && nums[j + 1] - nums[j] == d) j++;\n            int len = j - i + 1;\n            // a1:长度为 len 的子数组数量;an:长度为 3 的子数组数量\n            int a1 = 1, an = len - 3 + 1;\n            // 符合条件(长度大于等于3)的子数组的数量为「差值数列求和」结果\n            int cnt = (a1 + an) * an / 2;\n            ans += cnt;\n            i = j;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.413` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/411-420/414. 第三大的数（简单）.md", "url_title": "414. 第三大的数", "url": "https://leetcode-cn.com/problems/third-maximum-number/solution/gong-shui-san-xie-yi-ti-shuang-jie-pai-x-pmln/", "difficulty": "简单", "tags": ["排序", "数组", "模拟"], "question": "给你一个非空数组,返回此数组中 第三大的数 。如果不存在,则返回数组中最大的数。\n\n示例 1:\n```\n输入:[3, 2, 1]\n\n输出:1\n\n解释:第三大的数是 1 。\n```\n示例 2:\n```\n输入:[1, 2]\n\n输出:2\n\n解释:第三大的数不存在, 所以返回最大的数 2 。\n```\n示例 3:\n```\n输入:[2, 2, 3, 1]\n\n输出:1\n\n解释:注意,要求返回第三大的数,是指在所有不同数字中排第三大的数。\n此例中存在两个值为 2 的数,它们都排第二。在所有不同数字中排第三大的数为 1 。\n```\n\n提示:\n* 1 <= nums.length <= $10^4$\n* $-2^{31}$ <= nums[i] <= $2^{31} - 1$\n\n**进阶:你能设计一个时间复杂度 O(n) 的解决方案吗?**", "solution": "### Set 去重 + 排序\n\n题目要求返回含重复元素的数组 $nums$ 中的第三大数。\n\n一个朴素的做法是,先使用 `Set` 对重复元素进行去重,然后对去重后的元素进行排序,并返回第三大的元素。\n\n代码:\n```Java\nclass Solution {\n    public int thirdMax(int[] nums) {\n        Set<Integer> set = new HashSet<>();\n        for (int x : nums) set.add(x);\n        List<Integer> list = new ArrayList<>(set);\n        Collections.sort(list);\n        return list.size() < 3 ? list.get(list.size() - 1) : list.get(list.size() - 3); \n    }\n}\n```\n* 时间复杂度:使用 `Set` 去重的复杂度为 $O(n)$;排序复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 有限变量 + 遍历\n\n**经典的找数组次大值的做法是使用两个变量 `a` 和 `b` 分别存储遍历过程中的最大值和次大值。**\n\n假设当前遍历到的元素为 $x$,当满足如下条件时,考虑更新 `a` 或者 `b`:\n1. 当 $x > a$ 时,说明最大值被更新,同时原来的最大值沦为次大值。即有 $b = a; a = x;$\n2. 在条件 $1$ 不满足,且有$x > b$ 时,此时可以根据是否有「严格次大值」的要求,而决定是否要增加 $x < a$ 的条件:\n    * 不要求为「严格次大值」:直接使用 $x$ 来更新 `b`,即有 $b = x$;\n    * 当要求为「严格次大值」: 此时需要满足 $x < a$ 的条件,才能更新 `b`。\n\n回到本题,同理我们可以使用 `a`、`b` 和 `c` 三个变量来代指「最大值」、「严格次大值」和「严格第三大值」。\n\n从前往后遍历 $nums$,假设当前元素为 $x$,对是否更新三者进行分情况讨论(判断优先级从上往下):\n\n1. $x > a$,说明最大值被更新,将原本的「最大值」和「次大值」往后顺延为「次大值」和「第三大值」,并用 $x$ 更新 `a`;\n2. $x < a$ 且 $x > b$,说明次大值被更新,将原本的「次大值」往后顺延为「第三大值」,并用 $x$ 更新 `b`;\n3. $x < b$ 且 $x > c$,说明第三大值被更新,使用 $x$ 更新 `c`。\n\n起始时,我们希望使用一个足够小的数来初始化 `a`、`b` 和 `c`,但由于 $num[i]$ 的范围为 $[-2^{31}, 2^{31} - 1]$,因此需要使用 `long` 来进行代替。\n\n返回时,通过判断第三大值是否为初始化时的负无穷,来得知是否存在第三大值。\n\n代码:\n```Java\nclass Solution {\n    long INF = (long)-1e18;\n    public int thirdMax(int[] nums) {\n        long a = INF, b = INF, c = INF;\n        for (int x : nums) {\n            if (x > a) {\n                c = b; b = a; a = x;\n            } else if (x < a && x > b) {\n                c = b; b = x;\n            } else if (x < b && x > c) {\n                c = x;\n            }\n        }\n        return c != INF ? (int)c : (int)a;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.414` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/411-420/416. 分割等和子集(上)（中等）.md", "url_title": "416. 分割等和子集(上)", "url": "https://leetcode-cn.com/problems/partition-equal-subset-sum/solution/gong-shui-san-xie-bei-bao-wen-ti-shang-r-ln14/", "difficulty": "中等", "tags": ["背包 DP"], "question": "给你一个 只包含正整数 的 非空 数组 nums 。\n\n请你判断是否可以将这个数组分割成两个子集,使得两个子集的元素和相等。\n\n示例 1:\n```\n输入:nums = [1,5,11,5]\n\n输出:true\n\n解释:数组可以分割成 [1, 5, 5] 和 [11] 。\n```\n示例 2:\n```\n输入:nums = [1,2,3,5]\n\n输出:false\n\n解释:数组不能分割成两个元素和相等的子集。\n```\n\n提示:\n* 1 <= nums.length <= 200\n* 1 <= nums[i] <= 100", "solution": "### 前言\n\n今天是我们讲解**动态规划专题**中的 *「背包问题」的第二天*。\n\n在众多背包问题中「01 背包问题」是最为核心的,因此我建议你先精读过 [背包问题 第一讲](https://mp.weixin.qq.com/s/xmgK7SrTnFIM3Owpk-emmg) 之后再阅读本文。\n\n**另外,我在文章结尾处列举了我所整理的关于背包问题的相关题目。**\n\n背包问题我会按照编排好的顺序进行讲解(*每 2~3 天更新一篇,确保大家消化*)。\n\n你也先可以尝试做做,也欢迎你向我留言补充,你觉得与背包相关的 DP 类型题目 ~ \n\n***\n\n## 基本分析\n\n**通常「背包问题」相关的题,都是在考察我们的「建模」能力,也就是将问题转换为「背包问题」的能力。**\n\n由于本题是问我们能否将一个数组分成两个「等和」子集。\n\n问题等效于**能否从数组中挑选若干个元素,使得元素总和等于所有元素总和的一半**。\n\n这道题如果抽象成「背包问题」的话,应该是:\n\n**我们背包容量为 $target=sum/2$,每个数组元素的「价值」与「成本」都是其数值大小,求我们能否装满背包。**\n\n***\n\n### 转换为 01 背包\n\n由于每个数字(数组元素)只能被选一次,而且每个数字选择与否对应了「价值」和「成本」,求解的问题也与「最大价值」相关。\n\n可以使用「01 背包」的模型来做。\n\n当我们确定一个问题可以转化为「01 背包」之后,就可以直接套用「01 背包」的状态定义进行求解了。\n\n**注意,我们积累 DP 模型的意义,就是在于我们可以快速得到可靠的「状态定义」。**\n\n**在 [路径问题](https://mp.weixin.qq.com/s/flnaRo6VnvkeUQoRDkin9w) 中我教过你通用的 DP 技巧解法,但那是基于我们完全没见过那样的题型才去用的,而对于一些我们见过题型的 DP 题目,我们应该直接套用(或微调)该模型「状态定义」来做。**\n\n我们直接套用「01 背包」的状态定义:\n\n$f[i][j]$ 代表考虑前 $i$ 个数值,其选择数字总和不超过 $j$ 的最大价值。\n\n当有了「状态定义」之后,结合我们的「最后一步分析法」,每个数字都有「选」和「不选」两种选择。\n\n因此不难得出状态转移方程:\n\n代码:\n\n```java\nclass Solution {\n    public boolean canPartition(int[] nums) {\n        int n = nums.length;\n\n        //「等和子集」的和必然是总和的一半\n        int sum = 0;\n        for (int i : nums) sum += i;\n        int target = sum / 2;\n        \n        // 对应了总和为奇数的情况,注定不能被分为两个「等和子集」\n        if (target * 2 != sum) return false;\n\n        int[][] f = new int[n][target + 1];\n        // 先处理考虑第 1 件物品的情况\n        for (int j = 0; j <= target; j++) {\n            f[0][j] = j >= nums[0] ? nums[0] : 0;\n        }\n\n        // 再处理考虑其余物品的情况\n        for (int i = 1; i < n; i++) {\n            int t = nums[i];\n            for (int j = 0; j <= target; j++) {\n                // 不选第 i 件物品\n                int no = f[i-1][j];\n                // 选第 i 件物品\n                int yes = j >= t ? f[i-1][j-t] + t : 0;\n                f[i][j] = Math.max(no, yes);\n            }\n        }\n        // 如果最大价值等于 target,说明可以拆分成两个「等和子集」\n        return f[n-1][target] == target;\n    }\n}\n```\n* 时间复杂度:$target$ 为数组总和的一半,$n$ 数组元素个数。为共有 $n * target$ 个状态需要被转移,复杂度为 $O(n * target)$\n* 空间复杂度:$O(n * target)$\n\n***\n\n### 「滚动数组」解法\n\n在上一讲我们讲到过「01 背包」具有两种空间优化方式。\n\n其中一种优化方式的编码实现十分固定,只需要固定的修改「物品维度」即可。\n\n代码:\n\n```java\nclass Solution {\n    public boolean canPartition(int[] nums) {\n        int n = nums.length;\n\n        //「等和子集」的和必然是总和的一半\n        int sum = 0;\n        for (int i : nums) sum += i;\n        int target = sum / 2;\n        if (target * 2 != sum) return false;\n\n        // 将「物品维度」修改为 2\n        int[][] f = new int[2][target + 1];\n        // 先处理考虑第 1 件物品的情况\n        for (int j = 0; j <= target; j++) {\n            f[0][j] = j >= nums[0] ? nums[0] : 0;\n        }\n\n        // 再处理考虑其余物品的情况\n        for (int i = 1; i < n; i++) {\n            int t = nums[i];\n            for (int j = 0; j <= target; j++) {\n                // 不选第 i 件物品,将物品维度的使用加上「&1」\n                int no = f[(i-1)&1][j];\n                // 选第 i 件物品,将物品维度的使用加上「&1」\n                int yes = j >= t ? f[(i-1)&1][j-t] + t : 0;\n                f[i&1][j] = Math.max(no, yes);\n            }\n        }\n        // 如果最大价值等于 target,说明可以拆分成两个「等和子集」\n        // 将物品维度的使用加上「&1」\n        return f[(n-1)&1][target] == target;\n    }\n}\n```\n* 时间复杂度:$target$ 为数组总和的一半,$n$ 数组元素个数。为共有 $n * target$ 个状态需要被转移,复杂度为 $O(n * target)$\n* 空间复杂度:$O(target)$\n\n***\n\n### 「一维空间优化」解法\n\n事实上,我们还能继续进行空间优化:只保留代表「剩余容量」的维度,同时将容量遍历方向修改为「从大到小」。\n\n代码:\n\n```java\nclass Solution {\n    public boolean canPartition(int[] nums) {\n        int n = nums.length;\n\n        //「等和子集」的和必然是总和的一半\n        int sum = 0;\n        for (int i : nums) sum += i;\n        int target = sum / 2;\n\n        // 对应了总和为奇数的情况,注定不能被分为两个「等和子集」\n        if (target * 2 != sum) return false;\n\n        // 将「物品维度」取消\n        int[] f = new int[target + 1];\n        for (int i = 0; i < n; i++) {\n            int t = nums[i];\n            // 将「容量维度」改成从大到小遍历\n            for (int j = target; j >= 0; j--) {\n                // 不选第 i 件物品\n                int no = f[j];\n                // 选第 i 件物品\n                int yes = j >= t ? f[j-t] + t : 0;\n                f[j] = Math.max(no, yes);\n            }\n        }\n        // 如果最大价值等于 target,说明可以拆分成两个「等和子集」\n        return f[target] == target;\n    }\n}\n```\n* 时间复杂度:$target$ 为数组总和的一半,$n$ 数组元素个数。为共有 $n * target$ 个状态需要被转移,复杂度为 $O(n * target)$\n* 空间复杂度:$O(target)$\n\n***\n\n### 总结\n\n今天我们对昨天学的「01 背包」进行了应用。\n\n可以发现,本题的难点在于**对问题的抽象**,主要考察的是如何将原问题转换为一个「01 背包」问题。\n\n事实上,无论是 DP 还是图论,对于特定问题,大多都有相应的模型或算法。\n\n难是难在如何将问题转化为我们的模型。\n\n至于如何培养自己的「问题抽象能力」?\n\n*首先通常需要我们积累一定的刷题量,并对「转换问题的关键点」做总结。*\n\n例如本题,一个转换「01 背包问题」的关键点是我们需要将「划分等和子集」的问题等效于「在某个数组中选若干个数,使得其总和为某个特定值」的问题。\n\n***\n\n### 拓展\n\n但这道题到这里还有一个”小问题“。\n\n就是我们最后是通过「判断」来取得答案的。\n\n通过判断取得的最大价值是否等于 $target$ 来决定是否能划分出「等和子集」。  \n\n虽然说逻辑上完全成立,但总给我们一种「间接求解」的感觉。\n\n*造成这种「间接求解」的感觉,主要是因为我们没有对「01 背包」的「状态定义」和「初始化」做任何改动。*\n\n但事实上,我们是可以利用「01 背包」的思想进行「直接求解」的。\n\n因此在下一讲,我们还会再做一遍这道题。\n\n不过却是以「另外一个角度」的「01 背包」思维来解决。\n\n敬请期待 ~", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.416` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/411-420/416. 分割等和子集(下)（中等）.md", "url_title": "416. 分割等和子集(下)", "url": "https://leetcode-cn.com/problems/partition-equal-subset-sum/solution/gong-shui-san-xie-bei-bao-wen-ti-xia-con-mr8a/", "difficulty": "中等", "tags": ["背包 DP"], "question": "给你一个 只包含正整数 的 非空 数组 nums 。\n\n请你判断是否可以将这个数组分割成两个子集,使得两个子集的元素和相等。\n\n示例 1:\n```\n输入:nums = [1,5,11,5]\n\n输出:true\n\n解释:数组可以分割成 [1, 5, 5] 和 [11] 。\n```\n示例 2:\n```\n输入:nums = [1,2,3,5]\n\n输出:false\n\n解释:数组不能分割成两个元素和相等的子集。\n```\n\n提示:\n* 1 <= nums.length <= 200\n* 1 <= nums[i] <= 100", "solution": "### 基本分析\n\n基本的「将原问题抽象为 01 背包问题」的分析在 [上一讲](https://mp.weixin.qq.com/s/NnVbGs5Chm9BwAQeMOnJfg) 讲过啦 ~ \n\n本节要解决的问题是:**如何将「间接求解」的方式转为「直接求解」,并学习为什么能这么做,此类做法是否有共性 ...**\n\n---\n\n### 直接求解\n\n我们先来回顾一下 [上一节](https://mp.weixin.qq.com/s/NnVbGs5Chm9BwAQeMOnJfg) 使用的「状态定义」和「转移方程」。\n\n状态定义:\n\n$f[i][j]$ 代表考虑前 $i$ 个数值,其选择数字总和不超过 $j$ 的最大价值。\n\n转移方程:\n\n但题目并不是问我们「最大价值是多少」,而是问「是否能凑出最大价值」。\n\n因此我们可以对 01 背包的状态定义进行修改,使其直接与我们答案相关联:\n\n$f[i][j]$ 代表考虑前 $i$ 个数值,其选择数字总和是否恰好为 $j$。\n\n此时 $dp$ 数组中存储的是「布尔类型」的动规值。\n\n相应的状态转移方程调整为:\n\n$∨$ 代表逻辑「或」的意思。\n\n新转移方程代表的意思为:**想要 $f[i][j]$ (考虑前 $i$ 个数值,选择的数字总和恰好为 $j$ ) 为真**。需要满足以下两种方案,至少一种为 $true$:\n\n**1. $f[i-1][j]$ (不选第 $i$ 件物品,选择的数字总和恰好为 $j$ ) 为 $true$**\n\n**2. $f[i-1][j-nums[i]]$ (选第 $i$ 件物品,选择的数字总和恰好为 $j$ ) 为 $true$**\n\n至此,我们利用 01 背包的基本思想,修改了「状态定义」,使其与答案直接相关联,然后根据新的「状态定义」调整了我们的「转移方程」。\n\n但还没结束。\n\n**当我们与某个模型的「状态定义」进行了修改之后,除了考虑调整「转移方程」以外,还需要考虑修改「初始化」状态。**\n\n试考虑,我们创建的 $dp$ 数组存储的是布尔类型,初始值都是 $false$,这意味着无论我们怎么转移下去,都不可能产生一个 $true$,最终所有的状态都仍然是 $false$。\n\n换句话说,我们还需要一个有效值 $true$ 来帮助整个过程能递推下去。\n\n**通常我们使用「首行」来初始化「有效值」。**\n\n对于本题,显然我们可以通过「先处理第一个物品」来得到「有效值」,即令 $f[0][nums[0]] = true$。\n\n$f[0][nums[0]] = true$ 代表只有容量为 $nums[0]$ 的背包才符合「恰好」的要求。\n\n但我们无法确保 $nums[0]$ 不会超过我们的「最大背包」容量(也就是第一个物品过大,永远无法装入背包的情况)。\n\n因此我们要通过处理下一行来得到有效值?或是先给物品排个序?\n\n事实上,这里有一个技巧,就是我们增加一个「不考虑任何物品」的情况讨论。\n\n之前我们的状态定义是 $f[i][j]$ 代表考虑下标为 $i$ 之前的所有物品。现在我们可以加入**不考虑任何物品**的情况,也就是*将「物品编号」从 0 开始调整为从 1 开始*。\n\n举个🌰,原本我们的 $f[0][x]$ 代表只考虑第一件物品、$f[1][x]$ 代表考虑第一件和第二件物品;调整后我们的 $f[0][x]$ 代表不考虑任何物品、$f[1][x]$ 代表只考虑第一件物品 ...\n\n这种技巧本质上还是利用了「哨兵」的思想。\n\n有了以上的分析思路,和 [上一讲](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247485658&idx=1&sn=f298abe76d9cc058805b6a18d2523db6&chksm=fd9ca3c5caeb2ad31f6faefd800471b339d21cf54988e123fc507ff07b1447ae31337d826b0e&token=1589043586&lang=zh_CN#rd) 的代码基础之后,我们可以很容易写出代码。\n\n**虽然更换了状态定义和转移方程,但仍然有「常规解法」、「滚动数组优化」「一维空间优化」几种实现方法。我们快速过一下 ~**\n\n***\n\n### 常规解法\n\n代码:\n```java\nclass Solution {\n    public boolean canPartition(int[] nums) {\n        int n = nums.length;\n\n        //「等和子集」的和必然是总和的一半\n        int sum = 0;\n        for (int i : nums) sum += i;\n        int target = sum / 2;\n\n        // 对应了总和为奇数的情况,注定不能被分为两个「等和子集」\n        if (target * 2 != sum) return false;\n\n        // f[i][j] 代表考虑前 i 件物品,能否凑出价值「恰好」为 j 的方案\n        boolean[][] f = new boolean[n+1][target+1];\n        f[0][0] = true;\n        for (int i = 1; i <= n; i++) {\n            int t = nums[i-1];\n            for (int j = 0; j <= target; j++) {\n                // 不选该物品\n                boolean no = f[i-1][j];\n                // 选该物品\n                boolean yes = j >= t ? f[i-1][j-t] : false;\n                f[i][j] = no | yes;\n            }\n        }\n        return f[n][target];\n    }\n}\n```\n* 时间复杂度:$target$ 为数组总和的一半,$n$ 数组元素个数。为共有 $n * target$ 个状态需要被转移,复杂度为 $O(n * target)$\n* 空间复杂度:$O(n * target)$\n\n***\n\n### 「滚动数组」解法\n\n代码:\n```java\nclass Solution {\n    public boolean canPartition(int[] nums) {\n        int n = nums.length;\n\n        //「等和子集」的和必然是总和的一半\n        int sum = 0;\n        for (int i : nums) sum += i;\n        int target = sum / 2;\n\n        // 对应了总和为奇数的情况,注定不能被分为两个「等和子集」\n        if (target * 2 != sum) return false;\n\n        // f[i][j] 代表考虑前 i 件物品,能否凑出价值「恰好」为 j 的方案\n        // 修改「物品维度」为 2\n        boolean[][] f = new boolean[2][target+1];\n        f[0][0] = true;\n        for (int i = 1; i <= n; i++) {\n            int t = nums[i-1];\n            for (int j = 0; j <= target; j++) {\n                // 不选该物品\n                boolean no = f[(i-1)&1][j];\n                // 选该物品\n                boolean yes = j >= t ? f[(i-1)&1][j-t] : false;\n                f[i&1][j] = no | yes;\n            }\n        }\n        return f[n&1][target];\n    }\n}\n```\n* 时间复杂度:$target$ 为数组总和的一半,$n$ 数组元素个数。为共有 $n * target$ 个状态需要被转移,复杂度为 $O(n * target)$\n* 空间复杂度:$O(target)$\n\n***\n\n### 「一维空间优化」解法\n\n代码:\n```java\nclass Solution {\n    public boolean canPartition(int[] nums) {\n        int n = nums.length;\n\n        //「等和子集」的和必然是总和的一半\n        int sum = 0;\n        for (int i : nums) sum += i;\n        int target = sum / 2;\n\n        // 对应了总和为奇数的情况,注定不能被分为两个「等和子集」\n        if (target * 2 != sum) return false;\n\n        // 取消「物品维度」\n        boolean[] f = new boolean[target+1];\n        f[0] = true;\n        for (int i = 1; i <= n; i++) {\n            int t = nums[i-1];\n            for (int j = target; j >= 0; j--) {\n                // 不选该物品\n                boolean no = f[j];\n                // 选该物品\n                boolean yes = j >= t ? f[j-t] : false;\n                f[j] = no | yes;\n            }\n        }\n        return f[target];\n    }\n}\n```\n* 时间复杂度:$target$ 为数组总和的一半,$n$ 数组元素个数。为共有 $n * target$ 个状态需要被转移,复杂度为 $O(n * target)$\n* 空间复杂度:$O(target)$\n\n***\n\n### 总结\n\n今天我们又做了一遍「416. 分割等和子集」,但却是以另外一个角度进行求解:\n\n**通过修改 01 背包的「状态定义」和「转移方程」实现「直接求解」。**\n\n但这样的做法属于特题特解吗?\n\n其实不属于。反而这是「背包问题」中一个可推广的性质:\n\n我们可以通过将一个背包问题的「状态定义」从**最多不超过 XX 容量**修改为**背包容量恰好为 XX**,同时再把「有效值构造」出来,也即是将**物品下标调整为从 1 开始,设置 $dp[0][0]$ 为初始值**。\n\n这其实是另外一类「背包问题」,它不对应「价值最大化」,对应的是「能否取得最大/特定价值」。这样的「背包问题」同样具有普遍性。\n\n需要大家进行掌握 ~", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.416` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/411-420/417. 太平洋大西洋水流问题（中等）.md", "url_title": "417. 太平洋大西洋水流问题", "url": "https://leetcode-cn.com/problems/pacific-atlantic-water-flow/solution/by-ac_oier-do7d/", "difficulty": "中等", "tags": ["DFS", "BFS", "多源 BFS", "并查集"], "question": "有一个 `m × n` 的矩形岛屿,与 太平洋 和 大西洋 相邻。 “太平洋” 处于大陆的左边界和上边界,而 “大西洋” 处于大陆的右边界和下边界。\n\n这个岛被分割成一个由若干方形单元格组成的网格。给定一个 `m x n` 的整数矩阵 `heights` , $heights[r][c]$ 表示坐标 $(r, c)$ 上单元格 高于海平面的高度 。\n\n岛上雨水较多,如果相邻单元格的高度 小于或等于 当前单元格的高度,雨水可以直接向北、南、东、西流向相邻单元格。水可以从海洋附近的任何单元格流入海洋。\n\n返回 网格坐标 `result` 的 2D 列表 ,其中 $result[i] = [r_i, c_i]$ 表示雨水可以从单元格 $(r_i, c_i)$ 流向 太平洋和大西洋 。\n\n示例 1:\n\n```\n输入: heights = [[1,2,2,3,5],[3,2,3,4,4],[2,4,5,3,1],[6,7,1,4,5],[5,1,1,2,4]]\n\n输出: [[0,4],[1,3],[1,4],[2,2],[3,0],[3,1],[4,0]]\n```\n示例 2:\n```\n输入: heights = [[2,1],[1,2]]\n\n输出: [[0,0],[0,1],[1,0],[1,1]]\n```\n\n提示:\n* $m == heights.length$\n* $n == heights[r].length$\n* $1 <= m, n <= 200$\n* $0 <= heights[r][c] <= 10^5$", "solution": "### 基本分析 \n\n整理题意,需要我们统计能够同时流向两片海域的格子。\n\n从源点(格子)流向汇点(海域)是按照高度从高到低(非严格)的规则,那么反过来从海域到格子则是按照从低到高(非严格)规则进行,同时本身处于边缘的格子与海域联通。\n\n因此我们可以使用两遍 `DFS/BFS`  进行求解:分别从与当前海域直接相连的边缘格子出发,统计能够流向当前海域的格子集合,两片海域求得的集合交集即是答案。\n\n---\n\n### BFS(多源 BFS)\n\n使用 `BFS`  进行求解:目的是构造出两个答案矩阵 $res_1$ 和 $res_2$,$res_k[i][j] = true$ 代表格子 $(i, j)$ 能够流向海域,起始将所有与海域相连的格子放入队列,然后跑一遍 `BFS` ,所有能够进入队列的格子均能够与海域联通。\n\n最后统计所有满足 $res_1[i][j] = res_2[i][j] = true$ 的格子即是答案。\n\n代码:\n```Java \nclass Solution {\n    int n, m;\n    int[][] g;\n    public List<List<Integer>> pacificAtlantic(int[][] heights) {\n        g = heights;\n        m = g.length; n = g[0].length;\n        Deque<int[]> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();\n        boolean[][] res1 = new boolean[m][n], res2 = new boolean[m][n];\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (i == 0 || j == 0) {\n                    res1[i][j] = true;\n                    d1.addLast(new int[]{i, j});\n                }\n                if (i == m - 1 || j == n - 1) {\n                    res2[i][j] = true;\n                    d2.addLast(new int[]{i, j});\n                }\n            }\n        }\n        bfs(d1, res1); bfs(d2, res2);\n        List<List<Integer>> ans = new ArrayList<>();\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (res1[i][j] && res2[i][j]) {\n                    List<Integer> list = new ArrayList<>();\n                    list.add(i); list.add(j);\n                    ans.add(list);\n                }\n            }\n        }\n        return ans;\n    }\n    int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n    void bfs(Deque<int[]> d, boolean[][] res) {\n        while (!d.isEmpty()) {\n            int[] info = d.pollFirst();\n            int x = info[0], y = info[1], t = g[x][y];\n            for (int[] di : dirs) {\n                int nx = x + di[0], ny = y + di[1];\n                if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;\n                if (res[nx][ny] || g[nx][ny] < t) continue;\n                d.addLast(new int[]{nx, ny});\n                res[nx][ny] = true;\n            }\n        }\n    }\n}\n```\n* 时间复杂度:`BFS`  和统计答案的复杂度均为 $O(m \\times n)$。整体复杂度为 $O(m \\times n)$\n* 空间复杂度:$O(m \\times n)$\n\n---\n\n### DFS\n\n同理,使用 `DFS`  进行求解。\n\n代码:\n```Java \nclass Solution {\n    int n, m;\n    int[][] g;\n    public List<List<Integer>> pacificAtlantic(int[][] heights) {\n        g = heights;\n        m = g.length; n = g[0].length;\n        boolean[][] res1 = new boolean[m][n], res2 = new boolean[m][n];\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (i == 0 || j == 0) {\n                    if (!res1[i][j]) dfs(i, j, res1);\n                }\n                if (i == m - 1 || j == n - 1) {\n                    if (!res2[i][j]) dfs(i, j, res2);\n                }\n            }\n        }\n        List<List<Integer>> ans = new ArrayList<>();\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (res1[i][j] && res2[i][j]) {\n                    List<Integer> list = new ArrayList<>();\n                    list.add(i); list.add(j);\n                    ans.add(list);\n                }\n            }\n        }\n        return ans;\n    }\n    int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n    void dfs(int x, int y, boolean[][] res) {\n        res[x][y] = true;\n        for (int[] di : dirs) {\n            int nx = x + di[0], ny = y + di[1];\n            if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;\n            if (res[nx][ny] || g[nx][ny] < g[x][y]) continue;\n            dfs(nx, ny, res);\n        }\n    }\n}\n```\n* 时间复杂度:`DFS`  和统计答案的复杂度均为 $O(m \\times n)$。整体复杂度为 $O(m \\times n)$\n* 空间复杂度:$O(m \\times n)$\n\n---\n\n### 并查集 \n\n其中维护连通性部分可以使用「并查集」来做:起始将与海域 A 联通的边缘格子与 `S` 联通,将与海域 B 联通的边缘格子与 `T` 联通,然后跑一遍 `DFS/BFS`,最后将既和 `S` 联通又和 `T` 联通的格子加入答案。\n\n代码:\n```Java\nclass Solution {\n    int N = 200 * 200 + 10;\n    int[] p1 = new int[N], p2 = new int[N];\n    int n, m, tot, S, T;\n    int[][] g;\n    void union(int[] p, int a, int b) {\n        p[find(p, a)] = p[find(p, b)];\n    }\n    int find(int[] p, int x) {\n        if (p[x] != x) p[x] = find(p, p[x]);\n        return p[x];\n    }\n    boolean query(int[] p, int a, int b) {\n        return find(p, a) == find(p, b);\n    }\n    int getIdx(int x, int y) {\n        return x * n + y;\n    }\n    public List<List<Integer>> pacificAtlantic(int[][] _g) {\n        g = _g;\n        m = g.length; n = g[0].length; tot = m * n; S = tot + 1; T = tot + 2;\n        for (int i = 0; i <= T; i++) p1[i] = p2[i] = i;\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                int idx = getIdx(i, j);\n                if (i == 0 || j == 0) {\n                    if (!query(p1, S, idx)) dfs(p1, S, i, j);\n                }\n                if (i == m - 1 || j == n - 1) {\n                    if (!query(p2, T, idx)) dfs(p2, T, i, j);\n                }\n            }\n        }\n        List<List<Integer>> ans = new ArrayList<>();\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                int idx = getIdx(i, j);\n                if (query(p1, S, idx) && query(p2, T, idx)) {\n                    List<Integer> list = new ArrayList<>();\n                    list.add(i); list.add(j);\n                    ans.add(list);\n                }\n            }\n        }\n        return ans;\n    }\n    int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n    void dfs(int[] p, int ori, int x, int y) {\n        union(p, ori, getIdx(x, y));\n        for (int[] di : dirs) {\n            int nx = x + di[0], ny = y + di[1];\n            if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;\n            if (query(p, ori, getIdx(nx, ny)) || g[nx][ny] < g[x][y]) continue;\n            dfs(p, ori, nx, ny);\n        }\n    }\n}\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n \\times m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.417` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/411-420/419. 甲板上的战舰（中等）.md", "url_title": "419. 甲板上的战舰", "url": "https://leetcode-cn.com/problems/battleships-in-a-board/solution/gong-shui-san-xie-ji-chong-sao-miao-xian-trmc/", "difficulty": "中等", "tags": ["脑筋急转弯"], "question": "给你一个大小为 $m x n$ 的矩阵 $board$ 表示甲板,其中,每个单元格可以是一艘战舰 `'X'` 或者是一个空位 `'.'` ,返回在甲板 $board$ 上放置的 战舰 的数量。\n\n战舰 只能水平或者垂直放置在 $board$ 上。换句话说,战舰只能按 $1 * k$($1$ 行,$k$ 列)或 $k * 1$($k$ 行,$1$ 列)的形状建造,其中 $k$ 可以是任意大小。\n\n两艘战舰之间至少有一个水平或垂直的空位分隔 (即没有相邻的战舰)。\n\n示例 1:\n\n```\n输入:board = [[\"X\",\".\",\".\",\"X\"],[\".\",\".\",\".\",\"X\"],[\".\",\".\",\".\",\"X\"]]\n\n输出:2\n```\n示例 2:\n```\n输入:board = [[\".\"]]\n\n输出:0\n```\n\n提示:\n* $m == board.length$\n* $n == board[i].length$\n* $1 <= m, n <= 200$\n* $board[i][j]$ 是 `'.'` 或 `'X'`\n\n进阶:你可以实现一次扫描算法,并只使用 $O(1)$ 额外空间,并且不修改 `board` 的值来解决这个问题吗?", "solution": "### 脑筋急转弯\n\n如果「允许扫描多次」或者「使用与输入同规模的空间」的话,做法都十分简单:\n\n* 允许扫描多次,但空间只能 $O(1)$:每次遇到 `X` 的格子,则将 `X` 所在的战舰修改为 `-`,统计完答案后,再扫描一次,将 `-` 恢复为 `X` 即可;\n* 扫描一次,但空间允许 $O(m * n)$:使用一个与矩阵同等大小的辅助数组 $vis$ 记录访问过的位置即可。\n\n但题目要求「扫描一次」并且「空间 $O(1)$」,这就需要有点「脑筋急转弯」了。\n\n> 注意这里的「扫描一次」是指使用一次遍历,而非要求每个单元格仅能访问一次,注意两者区别。\n\n思考上述两种做法,我们本质 **都是在战舰的首个格子进行计数,并将该战舰的所有格子进行处理,同时使用去重手段(原数组标记 或 使用辅助数组)来防止该战舰在后面遍历中被重复计数。**\n\n如果我们能够找到某种规律,直接判断出某个 `X` 格子是否为战舰开头,则不再需要其他去重手段。\n\n当且仅当某个 `X` 格子的「上方」&「左方」不为 `X` 时,该格子为战舰首个格子,可以进行计数,同时需要注意当前当为 $0$(没有「上方」)和当前列为 $0$(没有「左方」)时的边界情况。\n\n* 一次扫描 + $O(1)$ 代码:\n```Java\nclass Solution {\n    public int countBattleships(char[][] board) {\n        int m = board.length, n = board[0].length;\n        int ans = 0;\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (i > 0 && board[i - 1][j] == 'X') continue;\n                if (j > 0 && board[i][j - 1] == 'X') continue;\n                if (board[i][j] == 'X') ans++;\n            }\n        }\n        return ans;\n    }\n}\n```\n\n* 两次扫描 + $O(1)$ 代码:\n```Java\nclass Solution {\n    public int countBattleships(char[][] board) {\n        int m = board.length, n = board[0].length;\n        int ans = 0;\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (board[i][j] != 'X') continue;\n                board[i][j] = '-';\n                for (int k = i + 1; k < m && board[k][j] == 'X'; k++) board[k][j] = '-';\n                for (int k = j + 1; k < n && board[i][k] == 'X'; k++) board[i][k] = '-';\n                ans++;\n            }\n        }\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (board[i][j] == '-') board[i][j] = 'X';\n            }\n        }\n        return ans;\n    }\n}\n```\n\n* 一次扫描 + $O(m * n)$ 代码:\n```Java\nclass Solution {\n    public int countBattleships(char[][] board) {\n        int m = board.length, n = board[0].length;\n        int ans = 0;\n        boolean[][] vis = new boolean[m][n];\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (board[i][j] != 'X' || vis[i][j]) continue;\n                vis[i][j] = true;\n                for (int k = i + 1; k < m && board[k][j] == 'X'; k++) vis[k][j] = true;\n                for (int k = j + 1; k < n && board[i][k] == 'X'; k++) vis[i][k] = true;\n                ans++;\n            }\n        }\n        return ans;\n    }\n}\n```", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.419` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/411-420/420. 强密码检验器（困难）.md", "url_title": "420. 强密码检验器", "url": "https://leetcode-cn.com/problems/strong-password-checker/solution/by-ac_oier-unp5/", "difficulty": "困难", "tags": ["模拟"], "question": "如果一个密码满足下述所有条件,则认为这个密码是强密码:\n\n* 由至少 $6$ 个,至多 $20$ 个字符组成。\n* 至少包含一个小写字母,一个大写字母,和一个数字。\n* 同一字符不能连续出现三次 (比如 `\"...aaa...\"` 是不允许的, 但是 `\"...aa...a...\"` 如果满足其他条件也可以算是强密码)。\n\n给你一个字符串 `password`,返回将 `password` 修改到满足强密码条件需要的最少修改步数。如果 `password` 已经是强密码,则返回 $0$ 。\n\n在一步修改操作中,你可以:\n\n* 插入一个字符到 `password`,\n* 从 `password` 中删除一个字符,或\n* 用另一个字符来替换 `password` 中的某个字符。\n\n示例 1:\n```\n输入:password = \"a\"\n\n输出:5\n```\n示例 2:\n```\n输入:password = \"aA1\"\n\n输出:3\n```\n示例 3:\n```\n输入:password = \"1337C0d3\"\n\n输出:0\n```\n\n提示:\n* $1 <= password.length <= 50$\n* `password` 由字母、数字、点 `'.'` 或者感叹号 `'!'`", "solution": "### 模拟(分情况讨论)\n\n这是一道麻烦而又没啥意义的题。\n\n需要满足的条件有三个,根据 `password` 的长度 $n$,字符种类数量 $m$,以及相同字符连续长度不低于 $3$ 的情况 $g$(数组 $g$ 的长度为相同字符长度不低于 $3$ 的连续段个数,$g[i]$ 代表第 $i$ 个连续段的长度),进行分情况讨论:\n\n* $n < 6$:长度过短,不满足要求,任何一次「删除」操作都需要额外搭配一个「增加」操作,而这两步操作可以使用「替换」来代替,结果不会变差;同时为了满足长度要求,我们必然要使用到「增加」操作。因此**需要用到「增加」和「替换」操作**,枚举所有的情况发现,最少操作次数最终可以归纳到 $\\max(6 - n, 3 - m)$;\n* $6 \\leqslant n \\leqslant 20$:任何的有效的「增加」操作目的只能是为了「破坏连续段长度不低于 $3$」或者「增加字符种类数量」,这两个目的都可以使用「替换」来做到;而任何有效的「删除」操作只能是为了「破坏连续段长度不低于 $3$」,这一目的也可以使用「替换」来做到。因此只**需要用到「替换」操作**,结果不会变差。对于某个 $g[i]$ 而言,我们需要使用  $\\left \\lfloor \\frac{g[i]}{3} \\right \\rfloor$ 次「替换」操作来满足「连续段长度不能不低于 $3$」的要求,在此基础上再考虑字符种类的问题,最少操作次数最终可以归纳到 $\\max(\\sum_{i = 0}^{g.length - 1}\\left \\lfloor \\frac{g[i]}{3} \\right \\rfloor, 3 - m)$;\n* $n > 20$:长度过长,不满足要求,任何一次「增加」操作都需要额外搭配一个「删除」操作,**只需要用到「删除」和「替换」操作**,为了满足长度要求,必然用到的「删除」操作可能会影响到最终的「替换」操作,直觉上,应当优先删除那些「连续段长度不低于 $3$」的字符。由于连续段长度 $g[i]$ 与其消耗的「替换」次数的关系为 $\\lfloor \\frac{g[i]}{3} \\rfloor$,在不考虑余数的情况下,每删除 $3$ 个字符,能够连带的减少一次「替换」操作。因此我们可以根据 $g[i]$ 对 $3$ 取模进行统计,得到 $cnts$ 数组($cnts$ 数组长度为 $3$,其中 $cnts[i] = x$ 含义为在所有「连续段长度不低于 $3$」的连续段中,长度余数为 $i$ 的数量有 $x$ 个),按照余数从小到大的优先级进行同步抵消,得到最终的「替换」操作数 $tot$($tot$ 起始值为 $\\sum_{i = 0}^{g.length - 1}\\left \\lfloor \\frac{g[i]}{3} \\right \\rfloor$)。除了可变的「替换」操作以外,我们不可避免还需要 $base = n - 20$ 的「删除」操作,最少操作次数可以归纳到 $base + \\max(tot, 3 - m)$\n\n实现上,我们并不需要真正处理出来 $g$ 数组,可以边统计「连续段长度不低于 $3$」边累加需要的「替换」次数。\n\n代码:\n```Java\nclass Solution {\n    public int strongPasswordChecker(String password) {\n        char[] cs = password.toCharArray();\n        int n = cs.length;\n        int A = 0, B = 0, C = 0;\n        for (char c : cs) {\n            if (c >= 'a' && c <= 'z') A = 1;\n            else if (c >= '0' && c <= '9') B = 1;\n            else if (c >= 'A' && c <= 'Z') C = 1;\n        }\n        int m = A + B + C;\n        if (n < 6) {\n            return Math.max(6 - n, 3 - m);\n        } else if (n <= 20) {\n            int tot = 0;\n            for (int i = 0; i < n; ) {\n                int j = i;\n                while (j < n && cs[j] == cs[i]) j++;\n                int cnt = j - i;\n                if (cnt >= 3) tot += cnt / 3;\n                i = j;\n            }\n            return Math.max(tot, 3 - m);\n        } else {\n            int tot = 0;\n            int[] cnts = new int[3];\n            for (int i = 0; i < n; ) {\n                int j = i;\n                while (j < n && cs[j] == cs[i]) j++;\n                int cnt = j - i;\n                if (cnt >= 3) {\n                    tot += cnt / 3; cnts[cnt % 3]++;\n                }\n                i = j;\n            }\n            int base = n - 20, cur = base;\n            for (int i = 0; i < 3; i++) {\n                if (i == 2) cnts[i] = tot;\n                if (cnts[i] != 0 && cur > 0) {\n                    int t = Math.min(cnts[i] * (i + 1), cur);\n                    cur -= t; tot -= t / (i + 1);\n                }\n            }\n            return base + Math.max(tot, 3 - m);\n        }\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.420` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/421-430/421. 数组中两个数的最大异或值（中等）.md", "url_title": "421. 数组中两个数的最大异或值", "url": "https://leetcode-cn.com/problems/maximum-xor-of-two-numbers-in-an-array/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-bmjdg/", "difficulty": "中等", "tags": ["字典树", "贪心"], "question": "给你一个整数数组 $nums$ ,返回 `nums[i] XOR nums[j]` 的最大运算结果,其中 $0 ≤ i ≤ j < n$ 。\n\n**进阶**:你可以在 $O(n)$ 的时间解决这个问题吗?\n\n示例 1:\n```\n输入:nums = [3,10,5,25,2,8]\n\n输出:28\n\n解释:最大运算结果是 5 XOR 25 = 28.\n```\n示例 2:\n```\n输入:nums = [0]\n\n输出:0\n```\n示例 3:\n```\n输入:nums = [2,4]\n\n输出:6\n```\n示例 4:\n```\n输入:nums = [8,10,2]\n\n输出:10\n```\n示例 5:\n```\n输入:nums = [14,70,53,83,49,91,36,80,92,51,66,70]\n\n输出:127\n```\n\n提示:\n* $1 <= nums.length <= 2 \\times 10^5$\n* $0 <= nums[i] <= 2^{31} - 1$", "solution": "### 基本分析\n\n要求得数组 `nums` 中的「最大异或结果」,假定 $nums[i]$ 与 $nums[j]$ 异或可以取得最终结果。\n\n**由于异或计算「每位相互独立」(又称为不进位加法),同时具有「相同值异或结果为 $0$,不同值异或结果为 $1$」的特性。**\n\n因此对于 $nums[j]$ 而言,可以从其二进制表示中的最高位开始往低位找,尽量让每一位的异或结果为 $1$,这样找到的 $nums[i]$ 与 $nums[j]$ 的异或结果才是最大的。\n\n具体的,我们需要先将 `nums` 中下标范围为 $[0, j]$ 的数(二进制表示)加入 $Trie$ 中,然后每次贪心的匹配每一位(优先匹配与之不同的二进制位)。\n\n---\n\n### 证明\n\n由于我们会从前往后扫描 `nums` 数组,因此 $nums[j]$ 必然会被处理到,所以我们只需要证明,在选定 $nums[j]$ 的情况下,我们的算法能够在 $[0, j]$ 范围内找到 $nums[i]$ 即可。\n\n假定我们算法找出来的数值与 $nums[j]$ 的异或结果为 $x$,而真实的最优异或结果为 $y$。\n\n接下来需要证得 $x$ 和 $y$ 相等。\n\n由于找的是「最大异或结果」, 而 $x$ 是一个合法值,因此我们天然有 $x \\leq y$。\n\n然后利用反证法证明 $x \\geq y$,假设 $x \\geq y$ 不成立,即有 $x < y$,那么从两者的二进制表示的高位开始找,必然能找到第一位不同:$y$ 的「不同位」的值为 $1$,而 $x$ 的「不同位」的值为 $0$。\n\n那么对应到选择这一个「不同位」的逻辑:能够选择与 $nums[j]$ 该位不同的值,使得该位的异或结果为 $1$,但是我们的算法选择了与 $nums[j]$ 该位相同的值,使得该位的异或结果为 $0$。\n\n这与我们的算法逻辑冲突,因此必然不存在这样的「不同位」。即 $x < y$ 不成立,反证 $x \\geq y$ 成立。\n\n得证 $x$ 与 $y$ 相等。\n\n---\n\n### Trie 数组实现\n\n可以使用数组来实现 $Trie$,但由于 OJ 每跑一个样例都会创建一个新的对象,因此使用数组实现,相当于每跑一个数据都需要 `new` 一个百万级别的数组,会 TLE 。\n\n因此这里使用数组实现必须要做的一个优化是:**使用 `static` 来修饰 $Trie$ 数组,然后在初始化时做相应的清理工作。**\n\n担心有不熟 Java 的同学,在代码里添加了相应注释说明。\n\nJava 代码:\n```Java\nclass Solution {\n    // static 成员整个类独一份,只有在类首次加载时才会创建,因此只会被 new 一次\n    static int N = (int)2e5 * 31, idx = 0;\n    static int[][] tr = new int[N][2];\n    // 每跑一个数据,会被实例化一次,每次实例化的时候被调用,做清理工作\n    public Solution() {\n        for (int i = 0; i <= idx; i++) Arrays.fill(tr[i], 0);\n        idx = 0;\n    }\n    void add(int x) {\n        int p = 0;\n        for (int i = 31; i >= 0; i--) {\n            int u = (x >> i) & 1;\n            if (tr[p][u] == 0) tr[p][u] = ++idx;\n            p = tr[p][u];\n        }\n    }\n    int getVal(int x) {\n        int p = 0, ans = 0;\n        for (int i = 31; i >= 0; i--) {\n            int a = (x >> i) & 1, b = 1 - a;\n            if (tr[p][b] != 0) {\n                ans |= (b << i);\n                p = tr[p][b];\n            } else {\n                ans |= (a << i);\n                p = tr[p][a];\n            }\n        }\n        return ans;\n    }\n    public int findMaximumXOR(int[] nums) {\n        int ans = 0;\n        for (int i : nums) {\n            add(i);\n            int j = getVal(i);\n            ans = Math.max(ans, i ^ j);\n        }\n        return ans;\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def findMaximumXOR(self, nums: List[int]) -> int:\n        N, idx = (len(nums) + 1) * 31, 0\n        tr = [[0, 0] for _ in range(N)]\n        def add(x):\n            nonlocal idx\n            p = 0\n            for i in range(31, -1, -1):\n                u = (x >> i) & 1\n                if tr[p][u] == 0:\n                    idx += 1\n                    tr[p][u] = idx\n                p = tr[p][u]\n        def getVal(x):\n            p, ans = 0, 0\n            for i in range(31, -1, -1):\n                a = (x >> i) & 1\n                b = 1 - a\n                if tr[p][b] != 0:\n                    ans |= (b << i)\n                    p = tr[p][b]\n                else:\n                    ans |= (a << i)\n                    p = tr[p][a]\n            return ans\n        ans = 0\n        for i in nums:\n            add(i)\n            j = getVal(i)\n            ans = max(ans, i ^ j)\n        return ans\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    static const int N = 2e5 * 31;\n    int idx = 0;\n    int tr[N][2] = {0};\n    Solution() {\n        for (int i = 0; i <= idx; i++) tr[i][0] = tr[i][1] = 0;\n        idx = 0;\n    }\n    void add(int x) {\n        int p = 0;\n        for (int i = 31; i >= 0; i--) {\n            int u = (x >> i) & 1;\n            if (tr[p][u] == 0) {\n                tr[p][u] = ++idx;\n            }\n            p = tr[p][u];\n        }\n    }\n    int getVal(int x) {\n        int p = 0, ans = 0;\n        for (int i = 31; i >= 0; i--) {\n            int a = (x >> i) & 1;\n            int b = 1 - a;\n            if (tr[p][b] != 0) {\n                ans |= (b << i);\n                p = tr[p][b];\n            } else {\n                ans |= (a << i);\n                p = tr[p][a];\n            }\n        }\n        return ans;\n    }\n    int findMaximumXOR(vector<int>& nums) {\n        int ans = 0;\n        for (int i : nums) {\n            add(i);\n            int j = getVal(i);\n            ans = max(ans, i ^ j);\n        }\n        return ans;\n    }\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(C)$\n\n---\n\n### Trie 类实现\n\n相比于使用 `static` 来优化,一个更好的做法是使用类来实现 $Trie$,这样可以真正做到「按需分配」内存,缺点是会发生不确定次数的 `new`。\n\nJava 代码:\n```Java\nclass Solution {\n    class Node {\n        Node[] ns = new Node[2];\n    }\n    Node root = new Node();\n    void add(int x) {\n        Node p = root;\n        for (int i = 31; i >= 0; i--) {\n            int u = (x >> i) & 1;\n            if (p.ns[u] == null) p.ns[u] = new Node();\n            p = p.ns[u];\n        }\n    }\n    int getVal(int x) {\n        int ans = 0;\n        Node p = root;\n        for (int i = 31; i >= 0; i--) {\n            int a = (x >> i) & 1, b = 1 - a;\n            if (p.ns[b] != null) {\n                ans |= (b << i);\n                p = p.ns[b];\n            } else {\n                ans |= (a << i);\n                p = p.ns[a];\n            }\n        }\n        return ans;\n    }\n    public int findMaximumXOR(int[] nums) {\n        int ans = 0;\n        for (int i : nums) {\n            add(i);\n            int j = getVal(i);\n            ans = Math.max(ans, i ^ j);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    class Node {\n    public:\n        Node* ns[2];\n        Node() {\n            ns[0] = nullptr;\n            ns[1] = nullptr;\n        }\n    };\n    Node* root = new Node();\n    void add(int x) {\n        Node* p = root;\n        for (int i = 31; i >= 0; i--) {\n            int u = (x >> i) & 1;\n            if (!p->ns[u]) p->ns[u] = new Node();\n            p = p->ns[u];\n        }\n    }\n    int getVal(int x) {\n        int ans = 0;\n        Node* p = root;\n        for (int i = 31; i >= 0; i--) {\n            int a = (x >> i) & 1, b = 1 - a;\n            if (p->ns[b]) {\n                ans |= (b << i);\n                p = p->ns[b];\n            } else {\n                ans |= (a << i);\n                p = p->ns[a];\n            }\n        }\n        return ans;\n    }\n    int findMaximumXOR(vector<int>& nums) {\n        int ans = 0;\n        for (int i : nums) {\n            add(i);\n            int j = getVal(i);\n            ans = max(ans, i ^ j);\n        }\n        return ans;\n    }\n};\n\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.421` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/421-430/423. 从英文中重建数字（中等）.md", "url_title": "423. 从英文中重建数字", "url": "https://leetcode-cn.com/problems/reconstruct-original-digits-from-english/solution/gong-shui-san-xie-nao-jin-ji-zhuan-wan-m-vg7a/", "difficulty": "中等", "tags": ["模拟", "脑筋急转弯"], "question": "给你一个字符串 `s` ,其中包含字母顺序打乱的用英文单词表示的若干数字`(0-9)`。按 升序 返回原始的数字。\n\n示例 1:\n```\n输入:s = \"owoztneoer\"\n\n输出:\"012\"\n```\n示例 2:\n```\n输入:s = \"fviefuro\"\n\n输出:\"45\"\n```\n\n提示:\n* $1 <= s.length <= 10^5$\n* `s[i]` 为 `[\"e\",\"g\",\"f\",\"i\",\"h\",\"o\",\"n\",\"s\",\"r\",\"u\",\"t\",\"w\",\"v\",\"x\",\"z\"]` 这些字符之一\n* `s` 保证是一个符合题目要求的字符串", "solution": "### 模拟\n\n题目要求我们将打乱的英文单词重建为数字。\n\n我们可以先对 `s` 进行词频统计,然后根据「英文单词中的字符唯一性」确定构建的顺序,最后再对答案进行排序即可。\n\n具体的,`zero` 中的 `z` 在其余所有单词中都没出现过,我们可以先统计 `zero` 的出现次数,并构建 $0$;然后观察剩余数字,其中 `eight` 中的 `g` 具有唯一性,构建 $8$;再发现 `six` 中的 `x` 具有唯一性,构建 $6$;发现 `three` 中的 `h` 具有唯一性(利用在此之前 `eight` 已经被删除干净,词频中仅存在 `three` 对应的 `h`),构建 $3$ ...\n\n最终可以确定一个可行的构建序列为 `0, 8, 6, 3, 2, 7, 5, 9, 4, 1`。\n\n代码:\n```Java\nclass Solution {\n    static String[] ss = new String[]{\"zero\", \"one\", \"two\", \"three\", \"four\", \"five\", \"six\", \"seven\", \"eight\", \"nine\"};\n    static int[] priority = new int[]{0, 8, 6, 3, 2, 7, 5, 9, 4, 1};\n    public String originalDigits(String s) {\n        int n = s.length();\n        int[] cnts = new int[26];\n        for (int i = 0; i < n; i++) cnts[s.charAt(i) - 'a']++;\n        StringBuilder sb = new StringBuilder();\n        for (int i : priority) {\n            int k = Integer.MAX_VALUE;\n            for (char c : ss[i].toCharArray()) k = Math.min(k, cnts[c - 'a']);\n            for (char c : ss[i].toCharArray()) cnts[c - 'a'] -= k;\n            while (k-- > 0) sb.append(i);\n        }\n        char[] cs = sb.toString().toCharArray();\n        Arrays.sort(cs);\n        return String.valueOf(cs);\n    }\n}\n```\n* 时间复杂度:令 $m$ 为最终答案的长度,$L$ 为所有英文单词的字符总长度。构建答案的复杂度为 $O(L + m)$;对构建答案进行排序复杂度为 $O(m\\log{m})$。整体复杂度为 $O(m\\log{m})$\n* 空间复杂度:$O(L + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.423` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/421-430/424. 替换后的最长重复字符（中等）.md", "url_title": "424. 替换后的最长重复字符", "url": "https://leetcode-cn.com/problems/longest-repeating-character-replacement/solution/ping-ping-wu-qi-shuang-zhi-zhen-da-bai-h-fgif/", "difficulty": "中等", "tags": ["双指针", "滑动窗口"], "question": "给你一个仅由大写英文字母组成的字符串,你可以将任意位置上的字符替换成另外的字符,总共可最多替换 $k$ 次。\n\n在执行上述操作后,找到包含重复字母的最长子串的长度。\n\n注意:字符串长度 和 $k$ 不会超过 $10^4$。\n\n示例 1:\n```\n输入:s = \"ABAB\", k = 2\n\n输出:4\n\n解释:用两个'A'替换为两个'B',反之亦然。\n```\n示例 2:\n```\n输入:s = \"AABABBA\", k = 1\n\n输出:4\n\n解释:\n将中间的一个'A'替换为'B',字符串变为 \"AABBBBA\"。\n子串 \"BBBB\" 有最长重复字母, 答案为 4。\n```", "solution": "### 滑动窗口\n\n令 `l` 为符合条件的子串的左端点,`r` 为符合条件的子串的右端点。\n\n使用 `cnt` 统计 `[l,r]` 范围的子串中每个字符串出现的次数。\n\n对于合法的子串而言,必然有 `sum(所有字符的出现次数) - max(出现次数最多的字符的出现次数)= other(其他字符的出现次数) <= k`。\n\n当找到这样的性质之后,我们可以对 `s` 进行遍历,每次让 `r` 右移并计数,如果符合条件,更新最大值;如果不符合条件,让 `l` 右移,更新计数,直到符合条件。\n\n代码:\n```Java\nclass Solution {\n    public int characterReplacement(String s, int k) {\n        char[] cs = s.toCharArray();\n        int[] cnt = new int[26];\n        int ans = 0;\n        for (int l = 0, r = 0; r < s.length(); r++) {\n            cnt[cs[r] - 'A']++;\n            while (!check(cnt, k)) cnt[cs[l++] - 'A']--;    \n            ans = Math.max(ans, r - l + 1);\n        }\n        return ans;\n    }\n    boolean check(int[] cnt, int k) {\n        int max = 0, sum = 0;\n        for (int i = 0; i < 26; i++) {\n            max = Math.max(max, cnt[i]);\n            sum += cnt[i];\n        }\n        return sum - max <= k;\n    }\n}\n```\n* 时间复杂度:使用 `l` 和 `r` 指针对 `s` 进行单次扫描,复杂度为 $O(n)$;令 $C = 26$ 为字符集大小,`check` 方法复杂度为 $O(C)$。整体复杂度为 $O(n * C)$。\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.424` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/421-430/427. 建立四叉树（中等）.md", "url_title": "427. 建立四叉树", "url": "https://leetcode.cn/problems/construct-quad-tree/solution/by-ac_oier-maul/", "difficulty": "中等", "tags": ["递归", "前缀和"], "question": "给你一个 $n \\times n$ 矩阵 `grid` ,矩阵由若干 $0$ 和 $1$ 组成。请你用四叉树表示该矩阵 `grid` 。\n\n你需要返回能表示矩阵的 四叉树 的根结点。\n\n注意,当 `isLeaf` 为 `False` 时,你可以把 `True` 或者 `False` 赋值给节点,两种值都会被判题机制 接受 。\n\n四叉树数据结构中,每个内部节点只有四个子节点。此外,每个节点都有两个属性:\n\n* `val`:储存叶子结点所代表的区域的值。$1$ 对应 `True`,$0$ 对应 `False`;\n* `isLeaf`: 当这个节点是一个叶子结点时为 `True`,如果它有 $4$ 个子节点则为 `False` 。\n```Java\nclass Node {\n    public boolean val;\n    public boolean isLeaf;\n    public Node topLeft;\n    public Node topRight;\n    public Node bottomLeft;\n    public Node bottomRight;\n}\n```\n我们可以按以下步骤为二维区域构建四叉树:\n\n1. 如果当前网格的值相同(即,全为 $0$ 或者全为 $1$),将 `isLeaf` 设为 `True` ,将 `val` 设为网格相应的值,并将四个子节点都设为 `Null` 然后停止。\n2. 如果当前网格的值不同,将 `isLeaf` 设为 `False`, 将 `val` 设为任意值,然后如下图所示,将当前网格划分为四个子网格。\n3. 使用适当的子网格递归每个子节点。\n\n四叉树格式:\n\n输出为使用层序遍历后四叉树的序列化形式,其中 `null` 表示路径终止符,其下面不存在节点。\n\n它与二叉树的序列化非常相似。唯一的区别是节点以列表形式表示 $[isLeaf, val]$ 。\n\n如果 `isLeaf` 或者 `val` 的值为 `True` ,则表示它在列表 $[isLeaf, val]$ 中的值为 $1$ ;如果 `isLeaf` 或者 `val` 的值为 `False` ,则表示值为 $0$ 。\n\n示例 1:\n\n```\n输入:grid = [[0,1],[1,0]]\n\n输出:[[0,1],[1,0],[1,1],[1,1],[1,0]]\n\n解释:请注意,在下面四叉树的图示中,0 表示 false,1 表示 True 。\n```\n\n示例 2:\n\n```\n输入:grid = [[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,1,1,1,1],[1,1,1,1,1,1,1,1],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0]]\n\n输出:[[0,1],[1,1],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]]\n\n解释:网格中的所有值都不相同。我们将网格划分为四个子网格。\ntopLeft,bottomLeft 和 bottomRight 均具有相同的值。\ntopRight 具有不同的值,因此我们将其再分为 4 个子网格,这样每个子网格都具有相同的值。\n```\n\n示例 3:\n\n```\n输入:grid = [[1,1],[1,1]]\n\n输出:[[1,1]]\n```\n示例 4:\n```\n输入:grid = [[0]]\n\n输出:[[1,0]]\n```\n示例 5:\n```\n输入:grid = [[1,1,0,0],[1,1,0,0],[0,0,1,1],[0,0,1,1]]\n\n输出:[[0,1],[1,1],[1,0],[1,0],[1,1]]\n```\n\n提示:\n* $n == grid.length == grid[i].length$\n* $n == 2^x$ 其中 $0 <= x <= 6$", "solution": "### 递归\n\n假定我们存在函数 `Node dfs(int a, int b, int c, int d)`,其能够返回「以 $(a, b)$ 为左上角,$(c, d)$ 为右下角」所代表的矩阵的根节点。\n\n那么最终答案为 `dfs(0, 0, n-1, n-1)`,不失一般性考虑「以 $(a, b)$ 为左上角,$(c, d)$ 为右下角」时如何计算:\n\n* 判断该矩阵是否为全 $0$ 或全 $1$:\n    * 如果是则直接创建根节点(该节点四个子节点属性均为空)并进行返回;\n    * 如果不是则创建根节点,递归创建四个子节点并进行赋值,利用左上角 $(a,b)$ 和右下角 $(c, d)$ 可算的横纵坐标的长度为 $c - a + 1$ 和 $d - b + 1$,从而计算出将当前矩阵四等分所得到的子矩阵的左上角和右下角坐标。\n\n由于矩阵大小最多为 $2^6 = 64$ ,因此判断某个子矩阵是否为全 $0$ 或全 $1$ 的操作用「前缀和」或者是「暴力」来做都可以。\n\n代码:\n```Java\nclass Solution {\n    int[][] g;\n    public Node construct(int[][] grid) {\n        g = grid;\n        return dfs(0, 0, g.length - 1, g.length - 1);\n    }\n    Node dfs(int a, int b, int c, int d) {\n        boolean ok = true;\n        int t = g[a][b];\n        for (int i = a; i <= c && ok; i++) {\n            for (int j = b; j <= d && ok; j++) {\n                if (g[i][j] != t) ok = false;\n            }\n        }\n        if (ok) return new Node(t == 1, true);\n        Node root = new Node(t == 1, false);\n        int dx = c - a + 1, dy = d - b + 1;\n        root.topLeft = dfs(a, b, a + dx / 2 - 1, b + dy / 2 - 1); \n        root.topRight = dfs(a, b + dy / 2, a + dx / 2 - 1, d);\n        root.bottomLeft = dfs(a + dx / 2, b, c, b + dy / 2 - 1);\n        root.bottomRight = dfs(a + dx / 2, b + dy / 2, c, d);\n        return root;\n    }\n}\n```\n* 时间复杂度:递归的复杂度分析要根据主定理,假设矩阵大小为 $n \\times n$,根据主定理 $T(n) = aT(\\frac{n}{b}) + f(n)$,单次递归最多会产生 $4$ 个子问题(由大矩阵递归 $4$ 个小矩阵),因此问题递归子问题数量 $a = 4$,而子问题规模缩减系数 $b$ 为原本的一半(子矩阵的大小为 $\\frac{n}{2} \\times \\frac{n}{2}$),剩余的 $f(n)$ 为判断全 $0$ 和 全 $1$ 的时间开销,不考虑标识位 $ok$ 带来的剪枝效果,每次判断全 $0$ 或全 $1$ 的复杂度与当前问题规模相等,即 $f(n) = O(n^2)$,但整个大小为 $n \\times n$ 矩阵每次进行长宽减半的子矩阵拆分,最多会被拆分为 $\\log{n}$ 次,因此这部分总的计算量为 $\\log{n} \\times n^2$ 。整体复杂度为 $O(n^2 + \\log{n} \\times n^2)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$\n\n---\n\n### 递归(前缀和优化)\n\n使用前缀和优化「判断全 $0$ 和全 $1$」的操作:对矩阵 `grid` 求前缀和数组 `sum`,对于一个「以左上角为 $(a, b)$,右下角为 $(c, d)$ 」的子矩阵而言,其所包含的格子总数为 $tot = (c - a + 1) * (d - b + 1)$ 个,当且仅当矩阵和为 $0$ 或 $tot$ 时,矩阵全 $0$ 或 $1$。\n\n代码:\n```Java\nclass Solution {\n    static int[][] sum = new int[70][70];   \n    int[][] g;\n    public Node construct(int[][] grid) {\n        g = grid;\n        int n = grid.length;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= n; j++) {\n                sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + g[i - 1][j - 1];\n            }\n        }\n        return dfs(0, 0, n - 1, n - 1);\n    }\n    Node dfs(int a, int b, int c, int d) {\n        int cur = sum[c + 1][d + 1] - sum[a][d + 1] - sum[c + 1][b] + sum[a][b];\n        int dx = c - a + 1, dy = d - b + 1, tot = dx * dy;\n        if (cur == 0 || cur == tot) return new Node(g[a][b] == 1, true);\n        Node root = new Node(g[a][b] == 1, false);\n        root.topLeft = dfs(a, b, a + dx / 2 - 1, b + dy / 2 - 1);\n        root.topRight = dfs(a, b + dy / 2, a + dx / 2 - 1, d);\n        root.bottomLeft = dfs(a + dx / 2, b, c, b + dy / 2 - 1);\n        root.bottomRight = dfs(a + dx / 2, b + dy / 2, c, d);\n        return root;\n    }\n}\n```\n* 时间复杂度:分析同理,但判断全 $0$ 和全 $1$ 的复杂度下降为 $O(1)$,整体复杂度为 $O(n^2 + \\log{n})$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.427` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/421-430/429. N 叉树的层序遍历（中等）.md", "url_title": "429. N 叉树的层序遍历", "url": "https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal/solution/by-ac_oier-yeye/", "difficulty": "中等", "tags": ["BFS", "树"], "question": "给定一个 `N` 叉树,返回其节点值的层序遍历。(即从左到右,逐层遍历)。\n\n树的序列化输入是用层序遍历,每组子节点都由 `null` 值分隔(参见示例)。\n\n示例 1:\n\n```\n输入:root = [1,null,3,2,4,null,5,6]\n\n输出:[[1],[3,2,4],[5,6]]\n```\n示例 2:\n\n```\n输入:root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]\n\n输出:[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]\n```\n\n提示:\n* 树的高度不会超过 `1000`\n* 树的节点总数在 $[0, 10^4]$ 之间", "solution": "### BFS\n\n根据题意进行 `BFS` 即可。\n\n由于我们需要以「层」为单位构建答案,因此在单次 `BFS` 过程中也按层进行。\n\n代码:\n```Java\nclass Solution {\n    public List<List<Integer>> levelOrder(Node root) {\n        List<List<Integer>> ans = new ArrayList<>();\n        Deque<Node> d = new ArrayDeque<>();\n        if (root != null) d.addLast(root);\n        while (!d.isEmpty()) {\n            int size = d.size();\n            List<Integer> list = new ArrayList<>();\n            while (size-- > 0) {\n                Node t = d.pollFirst();\n                for (Node node : t.children) d.addLast(node);\n                list.add(t.val);\n            }\n            ans.add(list);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.429` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/421-430/430. 扁平化多级双向链表（中等）.md", "url_title": "430. 扁平化多级双向链表", "url": "https://leetcode-cn.com/problems/flatten-a-multilevel-doubly-linked-list/solution/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-9wfz/", "difficulty": "中等", "tags": ["链表", "迭代", "递归"], "question": "多级双向链表中,除了指向下一个节点和前一个节点指针之外,它还有一个子链表指针,可能指向单独的双向链表。这些子列表也可能会有一个或多个自己的子项,依此类推,生成多级数据结构,如下面的示例所示。\n\n给你位于列表第一级的头节点,请你扁平化列表,使所有结点出现在单级双链表中。\n\n示例 1:\n```\n输入:head = [1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]\n\n输出:[1,2,3,7,8,11,12,9,10,4,5,6]\n\n解释:\n```\n输入的多级列表如下图所示:\n\n扁平化后的链表如下图:\n\n示例 2:\n```\n输入:head = [1,2,null,3]\n\n输出:[1,3,2]\n\n解释:\n输入的多级列表如下图所示:\n\n  1---2---NULL\n  |\n  3---NULL\n```\n\n示例 3:\n```\n输入:head = []\n\n输出:[]\n```", "solution": "### 递归\n\n一道常规链表模拟题。\n\n利用 `flatten` 函数本身的含义(将链表头为 $head$ 的链表进行扁平化,并将扁平化后的头结点进行返回),我们可以很容易写出递归版本。\n\n为防止空节点等边界问题,起始时建立一个哨兵节点 $dummy$ 指向 $head$,然后利用 $head$ 指针从前往后处理链表:\n\n* 当前节点 $head$ 没有 $child$ 节点:直接让指针后即可,即 $head = head.next$;\n* 当前节点 $head$ 有 $child$ 节点:将 $head.child$ 传入 `flatten` 函数递归处理,拿到普遍化后的头结点 $chead$,然后将 $head$ 和 $chead$ 建立“相邻”关系(注意要先存起来原本的 $tmp = head.next$ 以及将 $head.child$ 置空),然后继续往后处理,直到扁平化的 $chead$ 链表的尾部,将其与 $tmp$ 建立“相邻”关系。\n\n重复上述过程,直到整条链表被处理完。\n\n代码:\n```Java\nclass Solution {\n    public Node flatten(Node head) {\n        Node dummy = new Node(0);\n        dummy.next = head;\n        while (head != null) {\n            if (head.child == null) {\n                head = head.next;\n            } else {\n                Node tmp = head.next;\n                Node chead = flatten(head.child);\n                head.next = chead;\n                chead.prev = head;\n                head.child = null;\n                while (head.next != null) head = head.next;\n                head.next = tmp;\n                if (tmp != null) tmp.prev = head;\n                head = tmp;\n            }\n        }\n        return dummy.next;\n    }\n}\n```\n* 时间复杂度:最坏情况下,每个节点会被访问 $h$ 次($h$ 为递归深度,最坏情况下 $h = n$)。整体复杂度为 $O(n^2)$\n* 空间复杂度:最坏情况下所有节点都分布在 `child` 中,此时递归深度为 $n$。复杂度为 $O(n)$\n\n---\n\n### 递归(优化)\n\n在上述解法中,由于我们直接使用 `flatten` 作为递归函数,导致递归处理 $head.child$ 后不得不再进行遍历来找当前层的“尾结点”,这导致算法复杂度为 $O(n^2)$。\n\n一个可行的优化是,额外设计一个递归函数 `dfs` 用于返回扁平化后的链表“尾结点”,从而确保我们找尾结点的动作不会在每层发生。\n\n代码:\n```Java\nclass Solution {\n    public Node flatten(Node head) {\n        dfs(head);\n        return head;\n    }\n    Node dfs(Node head) {\n        Node last = head;\n        while (head != null) {\n            if (head.child == null) {\n                last = head;\n                head = head.next;\n            } else {\n                Node tmp = head.next;\n                Node childLast = dfs(head.child);\n                head.next = head.child;\n                head.child.prev = head;\n                head.child = null;\n                if (childLast != null) childLast.next = tmp;\n                if (tmp != null) tmp.prev = childLast;\n                last = head;\n                head = childLast;\n            }\n        }\n        return last;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:最坏情况下所有节点都分布在 `child` 中,此时递归深度为 $n$。复杂度为 $O(n)$\n\n---\n\n### 迭代\n\n自然也能够使用迭代进行求解。\n\n与「递归」不同的是,「迭代」是以“段”为单位进行扁平化,而「递归」是以深度(方向)进行扁平化,这就导致了两种方式对每个扁平节点的处理顺序不同。\n\n已样例 $1$ 为 🌰。\n\n递归的处理节点(新的 $next$ 指针的构建)顺序为:\n\n迭代的处理节点(新的 $next$ 指针的构建)顺序为:\n\n但由于链表本身不存在环,「迭代」的构建顺序发生调整,仍然可以确保每个节点被访问的次数为常数次。\n\n代码:\n```Java\nclass Solution {\n    public Node flatten(Node head) {\n        Node dummy = new Node(0);\n        dummy.next = head;\n        for (; head != null; ) {\n            if (head.child == null) {\n                head = head.next;\n            } else {\n                Node tmp = head.next;\n                Node child = head.child;\n                head.next = child;\n                child.prev = head;\n                head.child = null;\n                Node last = head;\n                while (last.next != null) last = last.next;\n                last.next = tmp;\n                if (tmp != null) tmp.prev = last;\n                head = head.next;   \n            }\n        }\n        return dummy.next;\n    }\n}\n```\n* 时间复杂度:可以发现,迭代写法的扁平化过程并不与遍历方向保持一致(以段为单位进行扁平化,而非像递归那样总是往遍历方向进行扁平化),但每个节点被访问的次数仍为常数次。复杂度为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.430` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/431-440/432. 全 O(1) 的数据结构（困难）.md", "url_title": "432. 全 O(1) 的数据结构", "url": "https://leetcode-cn.com/problems/all-oone-data-structure/solution/by-ac_oier-t26d/", "difficulty": "困难", "tags": ["双向链表", "哈希表"], "question": "请你设计一个用于存储字符串计数的数据结构,并能够返回计数最小和最大的字符串。\n\n实现 `AllOne` 类:\n\n* `AllOne()` 初始化数据结构的对象。\n* `inc(String key)` 字符串 `key` 的计数增加 $1$ 。如果数据结构中尚不存在 `key` ,那么插入计数为 $1$ 的 `key` 。\n* `dec(String key)` 字符串 `key` 的计数减少 $1$ 。如果 `key` 的计数在减少后为 $0$ ,那么需要将这个 `key` 从数据结构中删除。测试用例保证:在减少计数前,`key` 存在于数据结构中。\n* `getMaxKey()` 返回任意一个计数最大的字符串。如果没有元素存在,返回一个空字符串 `\"\"` 。\n* `getMinKey()` 返回任意一个计数最小的字符串。如果没有元素存在,返回一个空字符串 `\"\"` 。\n\n示例:\n```\n输入\n[\"AllOne\", \"inc\", \"inc\", \"getMaxKey\", \"getMinKey\", \"inc\", \"getMaxKey\", \"getMinKey\"]\n[[], [\"hello\"], [\"hello\"], [], [], [\"leet\"], [], []]\n\n输出\n[null, null, null, \"hello\", \"hello\", null, \"hello\", \"leet\"]\n\n解释\nAllOne allOne = new AllOne();\nallOne.inc(\"hello\");\nallOne.inc(\"hello\");\nallOne.getMaxKey(); // 返回 \"hello\"\nallOne.getMinKey(); // 返回 \"hello\"\nallOne.inc(\"leet\");\nallOne.getMaxKey(); // 返回 \"hello\"\nallOne.getMinKey(); // 返回 \"leet\"\n```\n\n提示:\n* $1 <= key.length <= 10$\n* `key` 由小写英文字母组成\n* 测试用例保证:在每次调用 `dec` 时,数据结构中总存在 `key`\n* 最多调用 `inc`、`dec`、`getMaxKey` 和 `getMinKey` 方法 $5 * 10^4$ 次", "solution": "### 双向链表 + 哈希表\n\n题目要求我们支持 $O(1)$ 的查询和修改,其中查询只需返回任意一个计数次数「最多」和「最少」的元素即可(如果有)。\n\n虽然插入的字符串长度不超过 $10$(该数据范围的含义为字符串的哈希计算消耗可看作常数),但单纯的使用「哈希表」仅能做到 $O(1)$ 的计数,无法做到 $O(1)$ 查询。\n\n**我们可以采取和 [实现一个 LRUCache](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486820&idx=1&sn=2055864e10848bce55afc4e2feda79a7&chksm=fd9ca67bcaeb2f6d2038706e32cafffd701d3d6b71b60c52a568ed6dc0e268d93f8a78498105&token=146288031&lang=zh_CN#rd) & [实现一个 LFUCache](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486856&idx=1&sn=59b2ed57e4a75eac0e63fc0cf08bed5d&chksm=fd9ca697caeb2f81f83cdc741375f9130c3fa40463edb4ae98d702354ca106378fdfe23735ad&token=146288031&lang=zh_CN#rd) 类似的思路,通过自定义节点并手写双链表来实现。**\n\n定义一个节点类 `Node`,除了包含用于实现双向链表的 `left` 和 `right` 以外,还包含一个数值类型的变量 `cnt`, 用于记录该节点存储的是计数次数为多少的元素,以及一个 `Set` 类型的容器,用于支持 $O(1)$ 插入和删除元素,记作 `set`。\n\n同时为了快速知道某个字符串属于哪个 `Node`,我们还需要开一个「哈希表」进行定位(以字符串为哈希表的键,字符串所在 `Node` 作为值),当定位到字符串对应的 `Node` 之后则可以利用双向链表的 $O(1)$ 增加/修改/删除。\n\n在双向链表中,起始只有两个哨兵节点 `hh` 和 `tt` ,当进行若干 `inc/dec` 操作后的基本形态为:\n\n对应几个操作:\n\n`inc/dec` 操作:当对一个字符串 `key` 进行「增加计数」或「减少计数」时,先在哈希表中看 `key` 是否存在:\n\n* 若存在:根据其所属的 `Node` 的计数 `cnt` 为多少,并结合当前是「增加计数」还是「减少计数」来决定是找 `Node` 的「右节点」还是「左节点」,同时检查相邻节点的计数值 `cnt` 是否为目标值,对应要检查数值是 $cnt + 1$ 和 $cnt - 1$:\n  * 若相邻节点的 `cnt` 为目标值:即目标节点存在,将 `key` 从原 `Node` 的 `set` 集合中移除,并添加到目标节点的集合中,更新哈希表;\n  * 若相邻节点的 `cnt` 不是目标值:则需要创建相应的目标节点,并构建双向链表关系,把 `key` 存入新创建的目标节点,更新哈希表。\n* 若不存在(只能是 `inc` 操作):查找是否存在 $cnt = 1$ 的节点(也就是检查 `hh.right` 节点的计数值):\n  * 如果存在 $cnt = 1$ 的目标节点:将 `key` 添加到目标节点的 `set` 集合中,更新哈希表;\n  * 若不存在 $cnt = 1$ 的目标节点:创建相应的节点,并构建双向关系,并构建双向链表关系,把 `key` 存入新创建的目标节点,更新哈希表。\n\n`getMaxKey/getMinKey` 操作:分别从 `tt.left` 和 `hh.right` 中尝试查找,如果存在非哨兵节点,则从节点的 `set` 集合中取任意元素进行返回,否则返回空串。\n\n最后,为了确保 `getMaxKey/getMinKey` 操作能够严格 $O(1)$,我们在进行 `inc/dec` 操作时我们需要对一些 `set` 容量为 $0$ 的节点进行释放,即解除其所在双向链表的关系。\n\n代码:\n```Java \nclass AllOne {\n\n    class Node {\n        int cnt;\n        Set<String> set = new HashSet<>();\n        Node left, right;\n        Node(int _cnt) {\n            cnt = _cnt;\n        }\n    }\n    \n    Node hh, tt;\n    Map<String, Node> map = new HashMap<>();\n    public AllOne() {\n        hh = new Node(-1000); tt = new Node(-1000);\n        hh.right = tt; tt.left = hh;\n    }\n\n    void clear(Node node) {\n        if (node.set.size() == 0) {\n            node.left.right = node.right;\n            node.right.left = node.left;\n        }\n    }\n    \n    public void inc(String key) {\n        if (map.containsKey(key)) {\n            Node node = map.get(key);\n            node.set.remove(key);\n            int cnt = node.cnt;\n            Node next = null;\n            if (node.right.cnt == cnt + 1) {\n                next = node.right;\n            } else {\n                next = new Node(cnt + 1);\n                next.right = node.right;\n                next.left = node;\n                node.right.left = next;\n                node.right = next;\n            }\n            next.set.add(key);\n            map.put(key, next);\n            clear(node);\n        } else {\n            Node node = null;\n            if (hh.right.cnt == 1) {\n                node = hh.right;\n            } else {\n                node = new Node(1);\n                node.right = hh.right;\n                node.left = hh;\n                hh.right.left = node;\n                hh.right = node;\n            }\n            node.set.add(key);\n            map.put(key, node);\n        }\n    }\n    \n    public void dec(String key) {\n        Node node = map.get(key);\n        node.set.remove(key);\n        int cnt = node.cnt;\n        if (cnt == 1) {\n            map.remove(key);\n        } else {\n            Node prev = null;\n            if (node.left.cnt == cnt - 1) {\n                prev = node.left;\n            } else {\n                prev = new Node(cnt - 1);\n                prev.right = node;\n                prev.left = node.left;\n                node.left.right = prev;\n                node.left = prev;\n            }\n            prev.set.add(key);\n            map.put(key, prev);\n        }\n        clear(node);\n    }\n    \n    public String getMaxKey() {\n        Node node = tt.left;\n        for (String str : node.set) return str;\n        return \"\";\n    }\n    \n    public String getMinKey() {\n        Node node = hh.right;\n        for (String str : node.set) return str;\n        return \"\";\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.432` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/431-440/433. 最小基因变化（中等）.md", "url_title": "433. 最小基因变化", "url": "https://leetcode-cn.com/problems/minimum-genetic-mutation/solution/by-ac_oier-74b4/", "difficulty": "中等", "tags": ["BFS", "双向 BFS", "图论 DFS", "AStar 算法", "启发式搜索"], "question": "基因序列可以表示为一条由 $8$ 个字符组成的字符串,其中每个字符都是 `'A'`、`'C'`、`'G'` 和 `'T'` 之一。\n\n假设我们需要调查从基因序列 `start` 变为 `end` 所发生的基因变化。一次基因变化就意味着这个基因序列中的一个字符发生了变化。\n\n* 例如,`\"AACCGGTT\" --> \"AACCGGTA\"` 就是一次基因变化。\n\n另有一个基因库 `bank` 记录了所有有效的基因变化,只有基因库中的基因才是有效的基因序列。\n\n给你两个基因序列 `start` 和 `end` ,以及一个基因库 `bank` ,请你找出并返回能够使 `start` 变化为 `end` 所需的最少变化次数。如果无法完成此基因变化,返回 $-1$ 。\n\n注意:起始基因序列 `start` 默认是有效的,但是它并不一定会出现在基因库中。\n\n示例 1:\n```\n输入:start = \"AACCGGTT\", end = \"AACCGGTA\", bank = [\"AACCGGTA\"]\n\n输出:1\n```\n示例 2:\n```\n输入:start = \"AACCGGTT\", end = \"AAACGGTA\", bank = [\"AACCGGTA\",\"AACCGCTA\",\"AAACGGTA\"]\n\n输出:2\n```\n示例 3:\n```\n输入:start = \"AAAAACCC\", end = \"AACCCCCC\", bank = [\"AAAACCCC\",\"AAACCCCC\",\"AACCCCCC\"]\n\n输出:3\n```\n提示:\n* $start.length == 8$\n* $end.length == 8$\n* $0 <= bank.length <= 10$\n* $bank[i].length == 8$\n* `start`、`end` 和 `bank[i]` 仅由字符 `['A', 'C', 'G', 'T']` 组成", "solution": "### BFS\n\n为了方便,我们令 $S = start$、 $T = end$,将每个基因序列视为「状态」。\n\n容易想到使用 `BFS`  进行求解,并使用「哈希表」记录到达某个状态所消耗的步数(同时为了快速判断某个状态是否合法,我们使用 `Set` 结构对 $bank[i]$ 进行转存)。\n\n起始将 `S` 加入队列,并更新到达 `S` 所使用的步数为 $0$,然后进行常规的 `BFS` 过程:每次取出队头元素,尝试替换当前状态的某一位,来得到新的状态(限定新状态必须合法,即必须出现在 `Set` 中),如果新状态合法并且没有在记录步数的哈希表中出现过,则将新状态入队并更新得到新状态所用步数,否则丢弃新状态。\n\n重复上述过程直到找到 `T`(返回具体步数) 或者队列为空(返回 $-1$)。\n\n代码:\n```Java\nclass Solution {\n    static char[] items = new char[]{'A', 'C', 'G', 'T'};\n    public int minMutation(String S, String T, String[] bank) {\n        Set<String> set = new HashSet<>();\n        for (String s : bank) set.add(s);\n        Deque<String> d = new ArrayDeque<>();\n        Map<String, Integer> map = new HashMap<>();\n        d.addLast(S);\n        map.put(S, 0);\n        while (!d.isEmpty()) {\n            int size = d.size();\n            while (size-- > 0) {\n                String s = d.pollFirst();\n                char[] cs = s.toCharArray();\n                int step = map.get(s);\n                for (int i = 0; i < 8; i++) {\n                    for (char c : items) {\n                        if (cs[i] == c) continue;\n                        char[] clone = cs.clone();\n                        clone[i] = c;\n                        String sub = String.valueOf(clone);\n                        if (!set.contains(sub)) continue;\n                        if (map.containsKey(sub)) continue;\n                        if (sub.equals(T)) return step + 1;\n                        map.put(sub, step + 1);\n                        d.addLast(sub);\n                    }\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为 `bank` 的数组长度(合法状态数),将 `bank` 存入 `Set` 结构复杂度为 $O(n)$,每个状态经过一步操作最多拓展出 $C = 32$ 个新基因(共有 $8$ 个位置,每个位置有 $4$ 个选择),`BFS`  过程复杂度为 $O(C \\times n)$。整体复杂度为  $O(C \\times n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 双向 BFS\n\n同理,我们可以使用「双向 `BFS`」进行求解。\n\n双向 `BFS` 与常规 `BFS`  相比,能够有效解决「搜索空间爆炸」的问题:\n\n对双向 `BFS`  不熟悉的同学可以看前置🧀:[(题解) 127. 单词接龙](https://leetcode-cn.com/problems/word-ladder/solution/gong-shui-san-xie-ru-he-shi-yong-shuang-magjd/)。\n\n代码:\n```Java\nclass Solution {\n    static char[] items = new char[]{'A', 'C', 'G', 'T'};\n    Set<String> set = new HashSet<>();\n    public int minMutation(String S, String T, String[] bank) {\n        set.add(S);\n        for (String s : bank) set.add(s);\n        if (!set.contains(T)) return -1;\n        Deque<String> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();\n        d1.addLast(S); d2.addLast(T);\n        Map<String, Integer> m1 = new HashMap<>(), m2 = new HashMap<>();\n        m1.put(S, 0); m2.put(T, 0);\n        while (!d1.isEmpty() && !d2.isEmpty()) {\n            int t = -1;\n            if (d1.size() <= d2.size()) t = update(d1, m1, m2);\n            else t = update(d2, m2, m1);\n            if (t != -1) return t;\n        }\n        return -1;\n    }\n    int update(Deque<String> d, Map<String, Integer> cur, Map<String, Integer> other) {\n        int m = d.size();\n        while (m-- > 0) {\n            String s = d.pollFirst();\n            char[] cs = s.toCharArray();\n            int step = cur.get(s);\n            for (int i = 0; i < 8; i++) {\n                for (char c : items) {\n                    if (cs[i] == c) continue;\n                    char[] clone = cs.clone();\n                    clone[i] = c;\n                    String sub = String.valueOf(clone);\n                    if (!set.contains(sub) || cur.containsKey(sub)) continue;\n                    if (other.containsKey(sub)) return other.get(sub) + step + 1;\n                    d.addLast(sub);\n                    cur.put(sub, step + 1);\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为 `bank` 的数组长度(合法状态数),将 `bank` 存入 `Set` 结构复杂度为 $O(n)$,每个状态经过一步操作最多拓展出 $C = 32$ 个新基因(共有 $8$ 个位置,每个位置有 $4$ 个选择),`BFS`  过程复杂度为 $O(C \\times n)$。整体复杂度为  $O(C \\times n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### AStar 算法\n\n若不考虑 `bank` 的限制,对于一个特定状态而言,我们可以任意选择一位替换为 $4$ 类字符之一,因此对于任意状态 $x$ 而言,其与目标状态 $T$ 的「理论最小转换步数」为两者对应位置不同字符的数量,而由于存在 `bank` 限制,实际最小步数必然满足「大于等于」该理论最小转换步数。\n\n基于此,我们可以计算当前状态到目标状态的「理论最小转换步数」作为启发式函数,进行启发式搜索。\n\n具体的,我们使用优先队列(堆)维护所有的状态,每次优先「启发值 = 理论最小转换步数」的状态进行优先出队拓展。\n\n对「AStar 算法」不了解的同学可以看前置 🧀:[发挥 A* 算法最大价值的关键点](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489588&idx=1&sn=479e4c0627247ab7e20af7909f2a8b64)。\n\n代码:\n```Java\nclass Solution {\n    class Node {\n        String s;\n        int val;\n        Node(String _s) {\n            s = _s;\n            for (int i = 0; i < 8; i++) {\n                if (s.charAt(i) != T.charAt(i)) val++;\n            }\n        }\n    }\n    static char[] items = new char[]{'A', 'C', 'G', 'T'};\n    String S, T;\n    public int minMutation(String start, String end, String[] bank) {\n        Set<String> set = new HashSet<>();\n        for (String s : bank) set.add(s);\n        S = start; T = end;\n        PriorityQueue<Node> q = new PriorityQueue<>((a,b)->a.val-b.val);\n        Map<String, Integer> map = new HashMap<>();\n        q.add(new Node(S));\n        map.put(S, 0);\n        while (!q.isEmpty()) {\n            Node node = q.poll();\n            char[] cs = node.s.toCharArray();\n            int step = map.get(node.s);\n            for (int i = 0; i < 8; i++) {\n                for (char c : items) {\n                    if (cs[i] == c) continue;\n                    char[] clone = cs.clone();\n                    clone[i] = c;\n                    String sub = String.valueOf(clone);\n                    if (!set.contains(sub)) continue;\n                    if (sub.equals(T)) return step + 1;\n                    if (!map.containsKey(sub) || map.get(sub) > step + 1) {\n                        map.put(sub, step + 1);\n                        q.add(new Node(sub));\n                    }\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:启发式搜索分析时空复杂度意义不大\n* 空间复杂度:启发式搜索分析时空复杂度意义不大\n\n---\n\n### 建图 + DFS\n\n**由 `S` 和 $bank[i]$ 组成合法点集,且点集中任意两点之间存在无向边的充要条件是:点 $u$ 和点 $v$ 所代表的字符中,仅有一个位置字符不同。**\n\n因此我们可以将所有的点存入 `list` 中,假设 `list` 长度为 $n$。同时为了方便,我们人为确保 `S` 出现在头部(点编号为 $1$),`T` 出现在尾部(点编号为 $n$)。\n\n遍历 `list` 进行建图(对于两字符串中仅有一位置不同的点进行连边操作),然后跑一遍从 $1$ 到 $n$ 的 `DFS`。\n\n由于图中可能有环或无解,因此必须「设定一个最大搜索深度」并增加「最优解剪枝」,确保搜索过程结束。\n\n最大搜索深度的设定可以利用反证法:如果 `S` 能够到达 `T`,那么最优路径中必然不存在环(否则可以把环去掉,得到一条更短的路径),即最优路径所经过的点的数量必然不超过 $n$。\n\n代码:\n```Java\nclass Solution {\n    int N = 15, M = 15 * 15 * 2 + 50, idx = 0, loc = 1;\n    int[] he = new int[N], e = new int[M], ne = new int[M];\n    int n, ans;\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    void dfs(int u, int fa, int depth) {\n        if (depth >= ans) return ; // 最优解剪枝\n        if (u == n) {\n            ans = depth;\n            return ;\n        }\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (j == fa) continue;\n            dfs(j, u, depth + 1);\n        }\n    }\n    public int minMutation(String S, String T, String[] bank) {\n        List<String> list = new ArrayList<>();\n        list.add(S);\n        boolean ok = false;\n        for (String s : bank) {\n            if (s.equals(S)) continue;\n            if (s.equals(T)) {\n                ok = true;\n                continue;\n            }\n            list.add(s);\n        }\n        if (!ok) return -1;\n        list.add(T);\n        n = list.size();\n        ans = n;\n        Arrays.fill(he, -1);\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                if (i == j) continue;\n                int cnt = 0;\n                for (int k = 0; k < 8 && cnt <= 1; k++) {\n                    if (list.get(i).charAt(k) != list.get(j).charAt(k)) cnt++;\n                }\n                if (cnt == 1) {\n                    add(i + 1, j + 1); add(j + 1, i + 1);\n                }\n            }\n        }\n        dfs(1, -1, 0);\n        return ans == n ? -1 : ans;\n    }\n}\n```\n* 时间复杂度:令 `bank` 的长度为 $n$(即点集的数量级为 $n$),预处理出 `list` 的复杂度为 $O(n)$;建图操作的复杂度为 $O(C \\times n^2)$,其中 $C = 8$ 基因序列长度;`DFS` 过程由于设定了最大搜索深度,复杂度为 $O(n^2)$。整体复杂度为 $O(C \\times n^2)$\n* 空间复杂度:最坏情况下为完全图,复杂度为 $O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.433` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/431-440/434. 字符串中的单词数（简单）.md", "url_title": "434. 字符串中的单词数", "url": "https://leetcode-cn.com/problems/number-of-segments-in-a-string/solution/gong-shui-san-xie-jian-dan-zi-fu-mo-ni-t-0gx6/", "difficulty": "简单", "tags": ["模拟"], "question": "统计字符串中的单词个数,这里的单词指的是连续的不是空格的字符。\n\n请注意,你可以假定字符串里不包括任何不可打印的字符。\n\n示例:\n```\n输入: \"Hello, my name is John\"\n\n输出: 5\n\n解释: 这里的单词是指连续的不是空格的字符,所以 \"Hello,\" 算作 1 个单词。\n```", "solution": "### 模拟\n\n题目对于「单词」的定义为「连续的不是空格的字符」。\n\n因此,我们可以从前往后处理字符串 `s` 并进行计数,对于是空格的字符进行跳过(不计数),而对于非空格字符,则在遍历完一个完整单词(连续一段)后进行一次计数。\n\n代码:\n```Java\nclass Solution {\n    public int countSegments(String s) {\n        int n = s.length();\n        int ans = 0;\n        for (int i = 0; i < n; ) {\n            if (s.charAt(i) == ' ' && i++ >= 0) continue;\n            while (i < n && s.charAt(i) != ' ') i++;\n            ans++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.434` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/431-440/436. 寻找右区间（中等）.md", "url_title": "436. 寻找右区间", "url": "https://leetcode.cn/problems/find-right-interval/solution/by-ac_oier-sijp/", "difficulty": "中等", "tags": ["排序", "二分", "双指针", "莫队算法"], "question": "给你一个区间数组 `intervals` ,其中 $intervals[i] = [start_i, end_i]$,且每个 $start_i$ 都 不同 。\n\n区间 $i$ 的 右侧区间 可以记作区间 $j$ ,并满足 $start_j >= end_i$ ,且 $start_j$ 最小化 。\n\n返回一个由每个区间 $i$ 的 右侧区间 的最小起始位置组成的数组。如果某个区间 $i$ 不存在对应的 右侧区间 ,则下标 $i$ 处的值设为 $-1$ 。\n\n示例 1:\n```\n输入:intervals = [[1,2]]\n\n输出:[-1]\n\n解释:集合中只有一个区间,所以输出-1。\n```\n示例 2:\n```\n输入:intervals = [[3,4],[2,3],[1,2]]\n\n输出:[-1,0,1]\n\n解释:对于 [3,4] ,没有满足条件的“右侧”区间。\n对于 [2,3] ,区间[3,4]具有最小的“右”起点;\n对于 [1,2] ,区间[2,3]具有最小的“右”起点。\n```\n示例 3:\n```\n输入:intervals = [[1,4],[2,3],[3,4]]\n\n输出:[-1,2,-1]\n\n解释:对于区间 [1,4] 和 [3,4] ,没有满足条件的“右侧”区间。\n对于 [2,3] ,区间 [3,4] 有最小的“右”起点。\n```\n\n提示:\n* $1 <= intervals.length <= 2 \\times 10^4$\n* $intervals[i].length == 2$\n* $-10^6 <= start_i <= end_i <= 10^6$\n* 每个间隔的起点都 不相同", "solution": "### 排序 + 二分 \n\n为了方便,我们称 $intervals$ 为 $its$。\n\n对于每个 $its[i]$ 而言,我们需要在所有满足「$its[j][0] \\geqslant its[i][1]$」中找到 $its[j][0]$ 值最小的下标 $j$,并将其记为 $ans[i]$。\n\n对于一个特定的 $its[i]$ 而言,其右端点固定,并且我们只关心目标位置的左端点。\n\n因此我们可以构造一个记录区间左端点的数组 $clone$,并将其进行排序,同时为了记录每个左端点来自于原序列中的那个下标,还需要额外记录原序列下标,即以 $(start, idx)$ 二元组的形式进行转存,并根据 $start$ 排序。\n\n然后从前往后处理每个 $its[i]$,运用「二分」在 $clone$ 中找到第一个满足左端点 $start$ 大于等于 $its[i][1]$ 的成员 $clone[j]$,将其 $clone[j][1]$ 即是 $its[i]$ 的最右区间。\n\n代码:\n```Java\nclass Solution {\n    public int[] findRightInterval(int[][] its) {\n        int n = its.length;\n        int[][] clone = new int[n][2];\n        for (int i = 0; i < n; i++) clone[i] = new int[]{its[i][0], i};\n        Arrays.sort(clone, (a,b)->a[0]-b[0]);\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) {\n            int l = 0, r = n - 1;\n            while (l < r) {\n                int mid = l + r >> 1;\n                if (clone[mid][0] >= its[i][1]) r = mid;\n                else l = mid + 1;\n            }\n            ans[i] = clone[r][0] >= its[i][1] ? clone[r][1] : -1;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$;对于每个 $its[i]$ 找到最右区间需要进行二分,复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 双指针(莫队思想)\n\n更进一步,在解法一中我们并没有对求解询问的顺序进行调整,这导致了我们不得不每次都在整个左端点序列中进行二分。\n\n朴素处理询问的方式,需要每次对整个序列进行扫描,复杂度为 $O(n^2)$。\n\n实际上,如果我们按照「右端点从小到大」的顺序处理询问,其每个询问对应的「最右区间的左端点」也具有单调特性。\n\n因此,我们可以运用莫队思想:**通过调整询问的处理顺序,来减少扫描目标位置的指针移动次数。将其从「必然进行 $n^2$ 次移动」优化为「最多不超过 $n$ 次移动」,从而将 构造答案 的复杂度从 $O(n^2)$ 优化为 $O(n)$。**\n\n最后,由于每个 $its[i]$ 只关心目标位置的「左端点」,因此我们无须对某一段进行分块,而直接使用双指针实现即可。\n\n代码:\n```Java\nclass Solution {\n    public int[] findRightInterval(int[][] its) {\n        int n = its.length;\n        int[][] ss = new int[n][2], es = new int[n][2];\n        for (int i = 0; i < n; i++) {\n            ss[i] = new int[]{its[i][0], i};\n            es[i] = new int[]{its[i][1], i};\n        }\n        Arrays.sort(ss, (a,b)->a[0]-b[0]);\n        Arrays.sort(es, (a,b)->a[0]-b[0]);\n        int[] ans = new int[n];\n        for (int i = 0, j = 0; i < n; i++) {\n            int[] cur = es[i];\n            int loc = cur[0], idx = cur[1];\n            while (j < n && ss[j][0] < loc) j++;\n            ans[idx] = j == n ? -1 : ss[j][1];\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$;双指针构造答案的复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.436` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/431-440/437. 路径总和 III（中等）.md", "url_title": "437. 路径总和 III", "url": "https://leetcode-cn.com/problems/path-sum-iii/solution/gong-shui-san-xie-yi-ti-shuang-jie-dfs-q-usa7/", "difficulty": "中等", "tags": ["DFS", "树的遍历", "前缀和"], "question": "给定一个二叉树的根节点 `root` ,和一个整数 `targetSum`,求该二叉树里节点值之和等于 `targetSum` 的 路径 的数目。\n\n路径 不需要从根节点开始,也不需要在叶子节点结束,但是路径方向必须是向下的(只能从父节点到子节点)。\n\n示例 1:\n\n```\n输入:root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8\n\n输出:3\n\n解释:和等于 8 的路径有 3 条,如图所示。\n```\n示例 2:\n```\n输入:root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22\n\n输出:3\n```\n\n提示:\n* 二叉树的节点个数的范围是 [0,1000]\n* $-10^9 <= Node.val <= 10^9$ \n* $-1000 <= targetSum <= 1000$", "solution": "### 树的遍历 + DFS\n\n一个朴素的做法是搜索以每个节点为根的(往下的)所有路径,并对路径总和为 $targetSum$ 的路径进行累加统计。\n\n使用 `dfs1` 来搜索所有节点,复杂度为 $O(n)$;在 `dfs1` 中对于每个当前节点,使用 `dfs2` 搜索以其为根的所有(往下的)路径,同时累加路径总和为 $targetSum$ 的所有路径,复杂度为 $O(n)$。\n\n整体复杂度为 $O(n^2)$,数据范围为 $10^3$,可以过。\n\n代码:\n```Java\nclass Solution {\n    int ans, t;\n    public int pathSum(TreeNode root, int _t) {\n        t = _t;\n        dfs1(root);\n        return ans;\n    }\n    void dfs1(TreeNode root) {\n        if (root == null) return;\n        dfs2(root, root.val);\n        dfs1(root.left);\n        dfs1(root.right);\n    }\n    void dfs2(TreeNode root, long val) {\n        if (val == t) ans++;\n        if (root.left != null) dfs2(root.left, val + root.left.val);\n        if (root.right != null) dfs2(root.right, val + root.right.val);\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$\n\n---\n\n### 树的遍历 + 前缀和\n\n在「解法一」中,我们统计的是以每个节点为根的(往下的)所有路径,也就是说统计的是以每个节点为「路径开头」的所有合法路径。\n\n**本题的一个优化切入点为「路径只能往下」,因此如果我们转换一下,统计以每个节点为「路径结尾」的合法数量的话,配合原本就是「从上往下」进行的数的遍历(最完整的路径必然是从原始根节点到当前节点的唯一路径),相当于只需要在完整路径中找到有多少个节点到当前节点的路径总和为 $targetSum$。**\n\n**于是这个树上问题彻底转换一维问题:求解从原始起点(根节点)到当前节点 $b$ 的路径中,有多少节点 $a$ 满足 $sum[a...b] = targetSum$,由于从原始起点(根节点)到当前节点的路径唯一,因此这其实是一个「一维前缀和」问题。**\n\n具体的,我们可以在进行树的遍历时,记录下从原始根节点 $root$ 到当前节点 $cur$ 路径中,从 $root$ 到任意中间节点 $x$ 的路径总和,配合哈希表,快速找到满足以 $cur$ 为「路径结尾」的、使得路径总和为 $targetSum$ 的目标「路径起点」有多少个。\n\n> 一些细节:由于我们只能统计往下的路径,但是树的遍历会同时搜索两个方向的子树。因此我们应当在搜索完以某个节点为根的左右子树之后,应当回溯地将路径总和从哈希表中删除,防止统计到跨越两个方向的路径。\n\n代码:\n```Java\nclass Solution {\n    Map<Long, Integer> map = new HashMap<>();\n    int ans, t;\n    public int pathSum(TreeNode root, int _t) {\n        if (root == null) return 0;\n        t = _t;\n        map.put(0L, 1);\n        dfs(root, root.val);\n        return ans;\n    }\n    void dfs(TreeNode root, long val) {\n        if (map.containsKey(val - t)) ans += map.get(val - t);\n        map.put(val, map.getOrDefault(val, 0) + 1);\n        if (root.left != null) dfs(root.left, val + root.left.val);\n        if (root.right != null) dfs(root.right, val + root.right.val);\n        map.put(val, map.getOrDefault(val, 0) - 1);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.437` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/431-440/438. 找到字符串中所有字母异位词（中等）.md", "url_title": "438. 找到字符串中所有字母异位词", "url": "https://leetcode-cn.com/problems/find-all-anagrams-in-a-string/solution/gong-shui-san-xie-shuang-zhi-zhen-shi-xi-t5hc/", "difficulty": "中等", "tags": ["双指针", "滑动窗口"], "question": "给定两个字符串 `s` 和 `p`,找到 `s` 中所有 `p` 的 异位词 的子串,返回这些子串的起始索引。不考虑答案输出的顺序。\n\n**异位词** 指由相同字母重排列形成的字符串(包括相同的字符串)。\n\n示例 1:\n```\n输入: s = \"cbaebabacd\", p = \"abc\"\n\n输出: [0,6]\n\n解释:\n起始索引等于 0 的子串是 \"cba\", 它是 \"abc\" 的异位词。\n起始索引等于 6 的子串是 \"bac\", 它是 \"abc\" 的异位词。\n```\n 示例 2:\n```\n输入: s = \"abab\", p = \"ab\"\n\n输出: [0,1,2]\n\n解释:\n起始索引等于 0 的子串是 \"ab\", 它是 \"ab\" 的异位词。\n起始索引等于 1 的子串是 \"ba\", 它是 \"ab\" 的异位词。\n起始索引等于 2 的子串是 \"ab\", 它是 \"ab\" 的异位词。\n```\n\n提示:\n* $1 <= s.length, p.length <= 3 * 10^4$\n* `s` 和 `p` 仅包含小写字母", "solution": "### 双指针(滑动窗口)\n\n这是一道使用双指针实现滑动窗口的裸题。\n\n具体的,我们可以先创建一个大小为 $26$ 的数组 $c2$ 来统计字符串 `p` 的词频,另外一个同等大小的数组 $c1$ 用来统计「滑动窗口」内的 `s` 的子串词频。\n\n当两个数组所统计词频相等,说明找到了一个异位组,将窗口的左端点加入答案。\n\n代码:\n```Java\nclass Solution {\n    public List<Integer> findAnagrams(String s, String p) {\n        List<Integer> ans = new ArrayList<>();\n        int n = s.length(), m = p.length();\n        int[] c1 = new int[26], c2 = new int[26];\n        for (int i = 0; i < m; i++) c2[p.charAt(i) - 'a']++;\n        for (int l = 0, r = 0; r < n; r++) {\n            c1[s.charAt(r) - 'a']++;\n            if (r - l + 1 > m) c1[s.charAt(l++) - 'a']--;\n            if (check(c1, c2)) ans.add(l);\n        }\n        return ans;\n    }\n    boolean check(int[] c1, int[] c2) {\n        for (int i = 0; i < 26; i++) {\n            if (c1[i] != c2[i]) return false;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:令 `s` 和 `p` 的长度分别为 $n$ 和 $m$,$C = 26$ 为字符集大小。统计 `p` 词频(构建 $c2$ 数组)的复杂度为 $O(m)$;使用双指针检查 `s` 串的复杂度为 $O(C * n)$。整体复杂度为 $O(C*n + m)$\n* 空间复杂度:$O(C)$\n\n---\n\n### 优化 check\n\n解法一中每次对滑动窗口的检查都不可避免需要检查两个词频数组,复杂度为 $O(C)$。\n\n事实上,我们只关心两个数组是否完全一致,因而我们能够只维护一个词频数组 $cnt$ 来实现。\n\n起始处理 `p` 串时,只对 $cnt$ 进行词频字符自增操作。当处理 `s` 的滑动窗口子串时,尝试对 $cnt$ 中的词频进行「抵消/恢复」操作:\n* 当滑动窗口的右端点右移时(增加字符),对 $cnt$ 执行右端点字符的「抵消」操作;\n* 当滑动窗口的左端点右移时(减少字符),对 $cnt$ 执行左端点字符的「恢复」操作。\n\n同时,使用变量 $a$ 统计 `p` 中不同字符的数量,使用变量 $b$ 统计滑动窗口(子串)内有多少个字符词频与 $p$ 相等。\n\n当滑动窗口移动( 执行「抵消/恢复」)时,如果「抵消」后该字符词频为 $0$,说明本次右端点右移,多产生了一位词频相同的字符;如果「恢复」后该字符词频数量为 $1$,说明少了一个为词频相同的字符。当且仅当 $a = b$ 时,我们找到了一个新的异位组。\n\n代码:\n```Java\nclass Solution {\n    public List<Integer> findAnagrams(String s, String p) {\n        List<Integer> ans = new ArrayList<>();\n        int n = s.length(), m = p.length();\n        int[] cnt = new int[26];\n        for (int i = 0; i < m; i++) cnt[p.charAt(i) - 'a']++;\n        int a = 0;\n        for (int i = 0; i < 26; i++) if (cnt[i] != 0) a++;\n        for (int l = 0, r = 0, b = 0; r < n; r++) {\n            // 往窗口增加字符,进行词频的抵消操作,如果抵消后词频为 0,说明有一个新的字符词频与 p 完全相等\n            if (--cnt[s.charAt(r) - 'a'] == 0) b++; \n            // 若窗口长度超过规定,将窗口左端点右移,执行词频恢复操作,如果恢复后词频为 1(恢复前为 0),说明少了一个词频与 p 完全性相等的字符\n            if (r - l + 1 > m && ++cnt[s.charAt(l++) - 'a'] == 1) b--;\n            if (b == a) ans.add(l);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 `s` 和 `p` 的长度分别为 $n$ 和 $m$,$C = 26$ 为字符集大小。构造 $cnt$ 的复杂度为 $O(m)$,统计 $p$ 中不同的字符数量为 $O(C)$,对 `s` 进行滑动窗口扫描得出答案的复杂度为 $O(n)$。整体复杂度为 $O(m + C + n)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.438` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/431-440/440. 字典序的第K小数字（困难）.md", "url_title": "440. 字典序的第K小数字", "url": "https://leetcode-cn.com/problems/k-th-smallest-in-lexicographical-order/solution/by-ac_oier-m3zl/", "difficulty": "困难", "tags": ["数学", "模拟", "找规律", "计数"], "question": "给定整数 $n$ 和 $k$,返回  $[1, n]$ 中字典序第 $k$ 小的数字。\n\n示例 1:\n```\n输入: n = 13, k = 2\n\n输出: 10\n\n解释: 字典序的排列是 [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9],所以第二小的数字是 10。\n```\n示例 2:\n```\n输入: n = 1, k = 1\n\n输出: 1\n```\n\n提示:\n* $1 <= k <= n <= 10^9$", "solution": "### 计数模拟\n\n寻找字典序第 $k$ 小的数。\n\n我们可以将该过程分两步操作 :「确定前缀」和「从以某个前缀开始找目标值」。\n\n假定我们存在某个函数 `int getCnt(int x, int limit)`,该函数实现了统计范围 $[1, limit]$ 内以 $x$ 为前缀的数的个数。\n\n有了该函数之后,我们可以从最小的前缀 $1$ 开始枚举,假设当前枚举到前缀 $x$,根据 $cnt = getCnt(x, n)$ 与 $k$ 的大小关系进行分情况讨论:\n\n* $cnt < k$:说明所有以 $x$ 为前缀的数组均可跳过,此时让 $x$ 自增,$k$ 减去 $cnt$。含义为从下一个「数值比 $x$ 大」的前缀中找目标值;\n* $cnt \\geqslant k$:说明目标值前缀必然为 $x$,此时我们需要在以 $x$ 为前缀的前提下找目标值。此时让 $x$ 乘 $10$,$k$ 减 $1$(代表跳过了 $x$ 本身)。含义为从下一个「字典序比 $x$ 大」的前缀中找目标值。\n\n当 $k = 1$ 时,当前前缀 $x$ 即是答案(含义为以 $x$ 为前缀的所有数中,最小的数,也就是 $x$ 本身)。\n\n然后重点看看 `int getCnt(int x, int limit)` 函数如何实现。\n\n为了方便,记 $x$ 的位数为 $n$,$limit$ 位数为 $m$。\n\n根据 `getCnt` 的函数定义,在范围 $[1, limit]$ 内,以 $x$ 为前缀的数值数量等于下面所有情况的数量之和:\n\n* 位数为 $n$ 的数:仅有 $x$ 本身,共 $1$ 个;\n* 位数为 $n + 1 < m$ 的数,有 `x0` 到 `x9`,共 $10$ 个;\n* 位数为 $n + 2 < m$ 的数,有 `x00` 到 `x99`,共 $100$ 个;\n* ...\n* 位数为 $m$ 的数,此时根据「$limit$ 长度与 $x$ 等同的前缀 $u$」和「$x$」的大小关系,进一步分情况讨论(举个 🌰,当 $limit = 12456$,$x$ 为 $123$ 时,$u = 124$,两者位数相差 $k = 2$ 位):\n    * $u < x$:此时所有位数为 $m$ 的数均大于 $limit$,合法个数为 $0$;\n    * $u == x$:此时所有位数为 $m$ 的数中部分满足 $limit$ 限制,合法个数为 $limit - x * 10^k + 1$ 个(只有 $[x0...0, limit]$ 为合法数);\n    * $u > x$:此时所有位数为 $m$ 的数均小于 $limit$,合法个数为 $10^k$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int findKthNumber(int n, int k) {\n        int ans = 1;\n        while (k > 1) {\n            int cnt = getCnt(ans, n);\n            if (cnt < k) {\n                k -= cnt; ans++;\n            } else {\n                k--; ans *= 10;\n            }\n        }\n        return ans;\n    }\n    int getCnt(int x, int limit) {\n        String a = String.valueOf(x), b = String.valueOf(limit);\n        int n = a.length(), m = b.length(), k = m - n;\n        int ans = 0, u = Integer.parseInt(b.substring(0, n));\n        for (int i = 0; i < k; i++) ans += Math.pow(10, i);\n        if (u > x) ans += Math.pow(10, k);\n        else if (u == x) ans += limit - x * Math.pow(10, k) + 1;\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int findKthNumber(int n, int k) {\n        int ans = 1;\n        while (k > 1) {\n            int cnt = getCnt(ans, n);\n            if (cnt < k) {\n                k -= cnt; ans++;\n            } else {\n                k--; ans *= 10;\n            }\n        }\n        return ans;\n    }\n    int getCnt(int x, int limit) {\n        string a = to_string(x), b = to_string(limit);\n        int n = a.length(), m = b.length(), k = m - n;\n        int ans = 0, u = stoi(b.substr(0, n));\n        for (int i = 0; i < k; i++) ans += pow(10, i);\n        if (u > x) ans += pow(10, k);\n        else if (u == x) ans += limit - x * pow(10, k) + 1;\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def findKthNumber(self, n: int, k: int) -> int:\n        def get_cnt(x, limit):\n            a, b = str(x), str(limit)\n            n, m = len(a), len(b)\n            k = m - n\n            ans = 0\n            u = int(b[:n])\n            for i in range(k):\n                ans += int(pow(10, i))\n            if u > x:\n                ans += int(pow(10, k))\n            elif u == x:\n                ans += limit - x * int(pow(10, k)) + 1\n            return ans\n\n        ans = 1\n        while k > 1:\n            cnt = get_cnt(ans, n)\n            if cnt < k:\n                k, ans = k - cnt, ans + 1\n            else:\n                k, ans = k - 1, ans * 10\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction findKthNumber(n: number, k: number): number {\n    const getCnt = function(x: number, limit: number): number {\n        const a = String(x), b = String(limit);\n        const n = a.length, m = b.length, k = m - n;\n        let ans = 0;\n        let u = parseInt(b.substring(0, n));\n        for (let i = 0; i < k; i++) ans += Math.pow(10, i);\n        if (u > x) ans += Math.pow(10, k);\n        else if (u == x) ans += limit - x * Math.pow(10, k) + 1;\n        return ans;\n    };\n    let ans = 1;\n    while (k > 1) {\n        let cnt = getCnt(ans, n);\n        if (cnt < k) {\n            k -= cnt; ans++;\n        } else {\n            k--; ans *= 10;\n        }\n    }\n    return ans;\n};\n```\n* 时间复杂度:枚举前缀以及 `getCnt` 操作均与位数相关,复杂度均为 $O(\\log{n})$。整体复杂度为 $O(\\log{^2}{n})$\n* 空间复杂度:忽略子串生成复杂度为 $O(1)$,否则为 $O(\\log{^2}{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.440` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/441-450/441. 排列硬币（简单）.md", "url_title": "441. 排列硬币", "url": "https://leetcode-cn.com/problems/arranging-coins/solution/gong-shui-san-xie-yi-ti-shuang-jie-shu-x-sv9o/", "difficulty": "简单", "tags": ["数学", "二分"], "question": "你总共有 `n` 枚硬币,并计划将它们按阶梯状排列。\n\n对于一个由 `k` 行组成的阶梯,其第 `i` 行必须正好有 i 枚硬币。阶梯的最后一行**可能**是不完整的。\n\n给你一个数字 `n` ,计算并返回可形成**完整阶梯行**的总行数。\n\n示例 1:\n\n```\n输入:n = 5\n\n输出:2\n\n解释:因为第三行不完整,所以返回 2 。\n```\n示例 2:\n\n```\n输入:n = 8\n\n输出:3\n\n解释:因为第四行不完整,所以返回 3 。\n```\n\n提示:\n* $1 <= n <= 2^{31} - 1$", "solution": "### 数学\n\n假设 $n$ 个硬币最多凑出 $x$ 行,根据等差数列求和公式 $S_n = n * a_1 + \\frac{n * (n - 1)}{2} * d$(首项和公差均为 $1$),可得 $n$ 和 $x$ 的关系:\n\n$$\n\\frac{x * (x + 1)}{2} <= n\n$$\n\n问题为求满足上式前提下,$x$ 的最大值为多少。\n\n根据 [求解一元二次方程](https://baike.baidu.com/item/%E4%B8%80%E5%85%83%E4%BA%8C%E6%AC%A1%E6%96%B9%E7%A8%8B) 求根公式,可得:\n\n$$\nx <= \\left \\lfloor \\frac{- 1 + \\sqrt{1 + 8 * n}}{2} \\right \\rfloor\n$$\n\n代码:\n```Java\nclass Solution {\n    public int arrangeCoins(int n) {\n        return (int)((Math.sqrt(1 + 8.0 * n) - 1) / 2);\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 二分\n\n对于解方程不熟悉的同学,也可以使用「二分」来做。\n\n对于 $n$ 个硬币而言,最多凑成的行数不会超过 $n$ 行,当且仅当 $n = 1$ 的时候可以取到。\n\n假设最大能够凑成的行数为 $x$,那么以 $x$ 为分割点的数轴上具有二段性,使用 $n$ 个硬币如果能够凑成 $x$ 行,那么必然也能够凑成少于等于 $x$ 行的阶梯硬币,必然不能凑成大于 $x$ 行的阶梯硬币。\n\n对于 $x$ 行阶梯硬币所需要的硬币数量,还是可以利用等差数列求和公式直接算出。\n\n代码:\n```Java\nclass Solution {\n    public int arrangeCoins(int n) {\n        long l = 1, r = n;\n        while (l < r) {\n            long mid = l + r + 1 >> 1;\n            if (mid * (mid + 1) / 2 <= n) l = mid;\n            else r = mid - 1;\n        }\n        return (int)r;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.441` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/441-450/442. 数组中重复的数据（中等）.md", "url_title": "442. 数组中重复的数据", "url": "https://leetcode-cn.com/problems/find-all-duplicates-in-an-array/solution/by-ac_oier-0m3c/", "difficulty": "中等", "tags": ["原地哈希", "数组"], "question": "给你一个长度为 $n$ 的整数数组 `nums`,其中 `nums` 的所有整数都在范围 $[1, n]$ 内,且每个整数出现 一次 或 两次 。请你找出所有出现 两次 的整数,并以数组形式返回。\n\n你必须设计并实现一个时间复杂度为 $O(n)$ 且仅使用常量额外空间的算法解决此问题。\n\n示例 1:\n```\n输入:nums = [4,3,2,7,8,2,3,1]\n\n输出:[2,3]\n```\n示例 2:\n```\n输入:nums = [1,1,2]\n\n输出:[1]\n```\n示例 3:\n```\n输入:nums = [1]\n\n输出:[]\n```\n\n提示:\n* $n == nums.length$\n* $1 <= n <= 10^5$\n* $1 <= nums[i] <= n$\n* `nums` 中的每个元素出现 一次 或 两次", "solution": "### 原地哈希\n\n给定数组长度为 $n$,且所有数范围在 $[1, n]$,找出出现次数超过一次的所有数字。\n\n利用值域与数字下标空间大小的等同关系,我们可以构造一种对应“关系”,使得每个数出现在它应该出现的位置:对于值为 $k$ 的数字,我们将其应该出现在的位置定为 $k - 1$。\n\n基于此,我们从前往后遍历 $nums$,并尝试将当前处理到的 $nums[i]$ 放到目标位置 $nums[i] - 1$ 处。如果一个数在尝试移动到它应该出现的位置时,发现 $nums[nums[i] - 1] = nums[i] (nums[i] - 1 \\neq i)$,则说明该数字出现了超过一次。此时我们将 $nums[i]$ 加入答案,由于此时没有发生交换,而 $nums[i]$ 占用的仍是其他数字的目标位置,为了防止 $nums[i]$ 与其他数字发生交换后,再次被检验并重复加入答案,我们将 $nums[i]$ 置为负数,并在遍历过程中跳过负数。\n\n代码:\n```Java\nclass Solution {\n    public List<Integer> findDuplicates(int[] nums) {\n        List<Integer> ans = new ArrayList<>();\n        int n = nums.length;\n        for (int i = 0; i < n; i++) {\n            int t = nums[i];\n            if (t < 0 || t - 1 == i) continue;\n            if (nums[t - 1] == t) {\n                ans.add(t);\n                nums[i] *= -1;\n            } else {\n                int c = nums[t - 1];\n                nums[t - 1] = t;\n                nums[i--] = c;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.442` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/441-450/443. 压缩字符串（中等）.md", "url_title": "443. 压缩字符串", "url": "https://leetcode-cn.com/problems/string-compression/solution/gong-shui-san-xie-shuang-zhi-zhen-yuan-d-bppu/", "difficulty": "中等", "tags": ["模拟", "双指针", "字符串"], "question": "给你一个字符数组 chars ,请使用下述算法压缩:\n\n从一个空字符串 s 开始。对于 chars 中的每组 连续重复字符 :\n\n* 如果这一组长度为 1 ,则将字符追加到 s 中。\n* 否则,需要向 s 追加字符,后跟这一组的长度。\n\n压缩后得到的字符串 s 不应该直接返回 ,需要转储到字符数组 chars 中。需要注意的是,如果组长度为 10 或 10 以上,则在 chars 数组中会被拆分为多个字符。\n\n请在** 修改完输入数组后**,返回该数组的新长度。\n\n你必须设计并实现一个只使用常量额外空间的算法来解决此问题。\n\n示例 1:\n```\n输入:chars = [\"a\",\"a\",\"b\",\"b\",\"c\",\"c\",\"c\"]\n\n输出:返回 6 ,输入数组的前 6 个字符应该是:[\"a\",\"2\",\"b\",\"2\",\"c\",\"3\"]\n\n解释:\n\"aa\" 被 \"a2\" 替代。\"bb\" 被 \"b2\" 替代。\"ccc\" 被 \"c3\" 替代。\n```\n示例 2:\n```\n输入:chars = [\"a\"]\n\n输出:返回 1 ,输入数组的前 1 个字符应该是:[\"a\"]\n\n解释:\n没有任何字符串被替代。\n```\n示例 3:\n```\n输入:chars = [\"a\",\"b\",\"b\",\"b\",\"b\",\"b\",\"b\",\"b\",\"b\",\"b\",\"b\",\"b\",\"b\"]\n\n输出:返回 4 ,输入数组的前 4 个字符应该是:[\"a\",\"b\",\"1\",\"2\"]。\n\n解释:\n由于字符 \"a\" 不重复,所以不会被压缩。\"bbbbbbbbbbbb\" 被 “b12” 替代。\n注意每个数字在数组中都有它自己的位置。\n```\n\n提示:\n* 1 <= chars.length <= 2000\n* chars[i] 可以是小写英文字母、大写英文字母、数字或符号", "solution": "### 双指针\n\n令输入数组 `cs` 长度为 $n$。\n\n使用两个指针 `i` 和 `j` 分别指向「当前处理到的位置」和「答案待插入的位置」:\n\n1. `i` 指针一直往后处理,每次找到字符相同的连续一段 $[i, idx)$,令长度为 $cnt$;\n2. 将当前字符插入到答案,并让 `j` 指针后移:`cs[j++] = cs[i]`;\n3. 检查长度 $cnt$ 是否大于 $1$,如果大于 $1$,需要将数字拆分存储。由于简单的实现中,我们只能从个位开始处理 $cnt$,因此需要使用 `start` 和 `end` 记录下存储数字的部分,再处理完 $cnt$ 后,将 $[start, end)$ 部分进行翻转,并更新 `j` 指针;\n4. 更新 `i` 为 `idx`,代表循环处理下一字符。\n\n代码:\n```Java\nclass Solution {\n    public int compress(char[] cs) {\n        int n = cs.length;\n        int i = 0, j = 0;\n        while (i < n) {\n            int idx = i;\n            while (idx < n && cs[idx] == cs[i]) idx++;\n            int cnt = idx - i;\n            cs[j++] = cs[i];\n            if (cnt > 1) {\n                int start = j, end = start;\n                while (cnt != 0) {\n                    cs[end++] = (char)((cnt % 10) + '0');\n                    cnt /= 10;\n                }\n                reverse(cs, start, end - 1);\n                j = end;\n            }\n            i = idx;\n        }\n        return j;\n    }\n    void reverse(char[] cs, int start, int end) {\n        while (start < end) {\n            char t = cs[start];\n            cs[start] = cs[end];\n            cs[end] = t;\n            start++; end--;\n        }\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.446` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/441-450/446. 等差数列划分 II - 子序列（困难）.md", "url_title": "446. 等差数列划分 II - 子序列", "url": "https://leetcode-cn.com/problems/arithmetic-slices-ii-subsequence/solution/gong-shui-san-xie-xiang-jie-ru-he-fen-xi-ykvk/", "difficulty": "困难", "tags": ["动态规划", "序列 DP", "容斥原理", "数学"], "question": "给你一个整数数组 nums ,返回 nums 中所有 等差子序列 的数目。\n\n如果一个序列中 至少有三个元素 ,并且任意两个相邻元素之差相同,则称该序列为等差序列。\n\n* 例如,[1, 3, 5, 7, 9]、[7, 7, 7, 7] 和 [3, -1, -5, -9] 都是等差序列。\n* 再例如,[1, 1, 2, 5, 7] 不是等差序列。\n\n数组中的子序列是从数组中删除一些元素(也可能不删除)得到的一个序列。\n\n* 例如,[2,5,10] 是 [1,2,1,2,4,1,5,10] 的一个子序列。\n\n题目数据保证答案是一个 32-bit 整数。\n\n示例 1:\n```\n输入:nums = [2,4,6,8,10]\n\n输出:7\n\n解释:所有的等差子序列为:\n[2,4,6]\n[4,6,8]\n[6,8,10]\n[2,4,6,8]\n[4,6,8,10]\n[2,4,6,8,10]\n[2,6,10]\n```\n示例 2:\n```\n输入:nums = [7,7,7,7,7]\n\n输出:16\n\n解释:数组中的任意子序列都是等差子序列。\n```\n\n提示:\n* 1  <= nums.length <= 1000\n* -$2^{31}$ <= nums[i] <= $2^{31}$ - 1", "solution": "### 基本分析\n\n从题目描述来看,我们可以确定这是一个「序列 DP」问题,通常「序列 DP」需要 $O(n^2)$ 的时间复杂度,而某些具有特殊性质的「序列 DP」问题,例如 LIS 问题,能够配合贪心思路 + 二分做到 $O(n\\log{n})$ 复杂度。再看一眼数据范围为 $10^3$,基本可以确定这是一道复杂度为 $O(n^2)$ 的「序列 DP」问题。\n\n---\n\n### 动态规划 + 容斥原理\n\n**既然分析出是序列 DP 问题,我们可以先猜想一个基本的状态定义,看是否能够「不重不漏」的将状态通过转移计算出来。如果不行,我们再考虑引入更多的维度来进行求解。**\n\n先从最朴素的猜想出发,定义 $f[i]$ 为考虑下标不超过 $i$ 的所有数,并且以 $nums[i]$ 为结尾的等差序列的个数。\n\n不失一般性的 $f[i]$ 该如何转移,不难发现我们需要枚举 $[0, i - 1]$ 范围内的所有数,假设当前我们枚举到 $[0, i - 1]$ 中的位置 $j$,我们可以直接算出两个位置的差值 $d = nums[i] - nums[j]$,但我们不知道 $f[j]$ 存储的子序列数量是差值为多少的。\n\n同时,根据题目我们要求的是所有的等差序列的个数,而不是求差值为某个具体值 $x$ 的等差序列的个数。换句话说,我们需要记录下所有差值的子序列个数,并求和才是答案。\n\n**因此我们的 $f[i]$ 不能是一个数,而应该是一个「集合」,该集合记录下了所有以 $nums[i]$ 为结尾,差值为所有情况的子序列的个数。**\n\n我们可以设置 $f[i] = g$,其中 $g$ 为一个「集合」数据结构,我们期望在 $O(1)$ 的复杂度内查的某个差值 $d$ 的子序列个数是多少。\n\n**这样 $f[i][j]$ 就代表了以 $nums[i]$ 为结尾,并且差值为 $j$ 的子序列个数是多少。**\n\n当我们多引入一维进行这样的状态定义后,我们再分析一下能否「不重不漏」的通过转移计算出所有的动规值。\n\n不失一般性的考虑 $f[i][j]$ 该如何转移,显然序列 DP 问题我们还是要枚举区间 $[0, i - 1]$ 的所有数。\n\n**和其他的「序列 DP」问题一样,枚举当前位置前面的所有位置的目的,是为了找到当前位置的数,能够接在哪一个位置的后面,形成序列。**\n\n**对于本题,枚举区间 $[0, i - 1]$ 的所有数的含义是:枚举以 $nums[i]$ 为子序列结尾时,它的前一个值是什么,也就是 $nums[i]$ 接在哪个数的后面,形成等差子序列。**\n\n这样必然是可以「不重不漏」的处理到所有以 $nums[i]$ 为子序列结尾的情况的。\n\n至于具体的状态转移方程,我们令差值 $d = nums[i] - nums[j]$,显然有(先不考虑长度至少为 $3$ 的限制):\n\n$$\nf[i][d] = \\sum_{j = 0}^{i - 1} (f[j][d] + 1)\n$$\n\n含义为:**在原本以 $nums[j]$ 为结尾的,且差值为 $d$ 的子序列的基础上接上 $nums[i]$,再加上新的子序列 $(nums[j], nums[i])$,共 $f[j][d] + 1$ 个子序列。**\n\n**最后对所有的哈希表的「值」对进行累加计数,就是以任意位置为结尾,长度大于 $1$ 的等差子序列的数量 $ans$。**\n\n这时候再看一眼数据范围 $-2^{31} <= nums[i] <= 2^{31}-1$,如果从数据范围出发,使用「数组」充当集合的话,我们需要将数组开得很大,必然会爆内存。\n\n但同时有 $1  <= nums.length <= 1000$,也就是说「最小差值」和「最大差值」之间可能相差很大,但是差值的数量是有限的,不会超过 $n^2$ 个。\n\n为了不引入复杂的「离散化」操作,我们可以直接使用「哈希表」来充当「集合」。\n\n每一个 $f[i]$ 为一个哈希表,哈希表的以 `{d:cnt}` 的形式进行存储,`d` 为子序列差值,`cnt` 为子序列数量。\n\n虽然相比使用数组,哈希表常数更大,但是经过上述分析,我们的复杂度为 $O(n^2)$,计算量为 $10^6$,距离计算量上界 $10^7$ 还保有一段距离,因此直接使用哈希表十分安全。\n\n到这里,我们解决了不考虑「长度为至少为 $3$」限制的原问题。\n\n那么需要考虑「长度为至少为 $3$」限制怎么办?\n\n**显然,我们计算的 $ans$ 为统计所有的「长度大于 $1$」的等差子序列数量,由于长度必然为正整数,也就是统计的是「长度大于等于 $2$」的等差子序列的数量。**\n\n**因此,如果我们能够求出长度为 $2$ 的子序列的个数的话,从 $ans$ 中减去,得到的就是「长度为至少为 $3$」子序列的数量。**\n\n长度为 $2$ 的等差子序列,由于没有第三个数的差值限制,因此任意的数对 $(j, i)$ 都是一个合法的长度为 $2$ 的等差子序列。\n\n而求长度为 $n$ 的数组的所有数对,其实就是求 **首项为 $0$,末项为 $n - 1$,公差为 $1$,长度为 $n$ 的等差数列之和**,直接使用「等差数列求和」公式求解即可。\n\n代码:\n```Java\nclass Solution {\n    public int numberOfArithmeticSlices(int[] nums) {\n        int n = nums.length;\n        // 每个 f[i] 均为哈希表,哈希表键值对为 {d : cnt}\n        // d : 子序列差值\n        // cnt : 以 nums[i] 为结尾,且差值为 d 的子序列数量\n        List<Map<Long, Integer>> f = new ArrayList<>();\n        for (int i = 0; i < n; i++) {\n            Map<Long, Integer> cur = new HashMap<>();\n            for (int j = 0; j < i; j++) {\n                Long d = nums[i] * 1L - nums[j];\n                Map<Long, Integer> prev = f.get(j);\n                int cnt = cur.getOrDefault(d, 0);\n                cnt += prev.getOrDefault(d, 0);\n                cnt ++;\n                cur.put(d, cnt);\n            }\n            f.add(cur);\n        }\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            Map<Long, Integer> cur = f.get(i);\n            for (Long key : cur.keySet()) ans += cur.get(key);\n        }\n        int a1 = 0, an = n - 1;\n        int cnt = (a1 + an) * n / 2;\n        return ans - cnt;\n    }\n}\n```\n* 时间复杂度:DP 过程的复杂度为 $O(n^2)$,遍历所有的哈希表的复杂度上界不会超过 $O(n^2)$。整体复杂度为 $O(n^2)$\n* 空间复杂度:所有哈希表存储的复杂度上界不会超过 $O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.446` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/441-450/447. 回旋镖的数量（中等）.md", "url_title": "447. 回旋镖的数量", "url": "https://leetcode-cn.com/problems/number-of-boomerangs/solution/gong-shui-san-xie-shu-ju-jie-gou-yun-yon-evu2/", "difficulty": "中等", "tags": ["哈希表", "模拟"], "question": "给定平面上 `n` 对 互不相同 的点 `points`,其中 `points[i] = [xi, yi]` 。回旋镖 是由点 `(i, j, k)` 表示的元组 ,其中 `i` 和 `j` 之间的距离和 `i` 和 `k` 之间的距离相等(需要考虑元组的顺序)。\n\n返回平面上所有回旋镖的数量。\n\n示例 1:\n```\n输入:points = [[0,0],[1,0],[2,0]]\n\n输出:2\n\n解释:两个回旋镖为 [[1,0],[0,0],[2,0]] 和 [[1,0],[2,0],[0,0]]\n```\n示例 2:\n```\n输入:points = [[1,1],[2,2],[3,3]]\n\n输出:2\n```\n示例 3:\n```\n输入:points = [[1,1]]\n\n输出:0\n```\n\n提示:\n* $n == points.length$\n* $1 <= n <= 500$\n* $points[i].length == 2$\n* -$10^4 <= x_i, y_i <= 10^4$\n* 所有点都 互不相同", "solution": "### 哈希表\n\n数据范围为 $500$,三层循环的朴素做法显然会 TLE。\n\n对于每个回旋镖三元组而言,本质上我们在统计给定 $i$ 的情况下,与 $i$ 距离相等的 $(j, k)$ 组合个数为多少。\n\n我们可以使用哈希表进行预处理,在统计以 $i$ 为三元组第一位的回旋镖个数前,先计算出 $i$ 和其余点的距离,并以 `{ 距离 : 个数 }` 的形式进行存储,然后分别对所有的距离进行累加计数。\n\n在计算距离时为了避免使用 `sqrt`,我们直接使用 $x^2 + y^2$ 来代指两点间的距离。\n\n代码:\n```Java\nclass Solution {\n    public int numberOfBoomerangs(int[][] points) {\n        int n = points.length;\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            Map<Integer, Integer> map = new HashMap<>();\n            for (int j = 0; j < n; j++) {\n                if (i == j) continue;\n                int x = points[i][0] - points[j][0], y = points[i][1] - points[j][1];\n                int dist = x * x + y * y;\n                map.put(dist, map.getOrDefault(dist, 0) + 1);\n            }\n            for (int dist : map.keySet()) {\n                int cnt = map.get(dist);\n                ans += cnt * (cnt - 1);\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.447` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/441-450/448. 找到所有数组中消失的数字（简单）.md", "url_title": "448. 找到所有数组中消失的数字", "url": "https://leetcode-cn.com/problems/find-all-numbers-disappeared-in-an-array/solution/li-yong-tong-pai-xu-de-si-lu-ni-huan-ke-e3t4w/", "difficulty": "简单", "tags": ["排序", "原地哈希"], "question": "给定一个范围在  $1 ≤ a[i] ≤ n$ ( $n$ = 数组大小 ) 的 整型数组,数组中的元素一些出现了两次,另一些只出现一次。\n\n找到所有在 $[1, n]$ 范围之间没有出现在数组中的数字。\n\n您能在不使用额外空间且时间复杂度为 $O(n)$ 的情况下完成这个任务吗? 你可以假定返回的数组不算在额外空间内。\n\n示例:\n```\n输入:\n[4,3,2,7,8,2,3,1]\n\n输出:\n[5,6]\n```", "solution": "### 桶排序(原地哈希)\n\n题目规定了 $1 ≤ a[i] ≤ n$,因此我们可以使用「桶排序」的思路,将每个数放在其应该出现的位置上。\n\n基本思路为:\n\n按照桶排序思路进行预处理:保证 $1$ 出现在 $nums[0]$ 的位置上,$2$ 出现在 $nums[1]$ 的位置上,...,$n$ 出现在 $nums[n - 1]$ 的位置上。不在 $[1, n]$ 范围内的数不用动。\n\n例如样例中 $[4,3,2,7,8,2,3,1]$ 将会被预处理成 $[1,2,3,4,3,2,7,8]$。\n\n遍历 $nums$,将不符合 `nums[i] != i + 1` 的数字加入结果集 ~ \n\n代码:\n```Java \nclass Solution {\n    public List<Integer> findDisappearedNumbers(int[] nums) {\n        int n = nums.length;\n        for (int i = 0; i < n; i++) {\n            while (nums[i] != i + 1 && nums[nums[i] - 1] != nums[i]) swap(nums, i, nums[i] - 1);\n        }\n        List<Integer> ans = new ArrayList<>();\n        for (int i = 0; i < n; i++) {\n            if (nums[i] != i + 1) ans.add(i + 1);\n        }\n        return ans;\n    }\n    void swap(int[] nums, int a, int b) {\n        int c = nums[a];\n        nums[a] = nums[b];\n        nums[b] = c;\n    }\n}\n```\n* 时间复杂度:每个数字最多挪动一次。复杂度为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.448` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/441-450/449. 序列化和反序列化二叉搜索树（中等）.md", "url_title": "449. 序列化和反序列化二叉搜索树", "url": "https://leetcode.cn/problems/serialize-and-deserialize-bst/solution/by-ac_oier-ncwn/", "difficulty": "中等", "tags": ["前序遍历", "BST", "二分"], "question": "序列化是将数据结构或对象转换为一系列位的过程,以便它可以存储在文件或内存缓冲区中,或通过网络连接链路传输,以便稍后在同一个或另一个计算机环境中重建。\n\n设计一个算法来序列化和反序列化 二叉搜索树 。 对序列化/反序列化算法的工作方式没有限制。 您只需确保二叉搜索树可以序列化为字符串,并且可以将该字符串反序列化为最初的二叉搜索树。\n\n编码的字符串应尽可能紧凑。\n\n示例 1:\n```\n输入:root = [2,1,3]\n\n输出:[2,1,3]\n```\n示例 2:\n```\n输入:root = []\n\n输出:[]\n```\n\n提示:\n* 树中节点数范围是 $[0, 10^4]$\n* $0 <= Node.val <= 10^4$\n* 题目数据 保证 输入的树是一棵二叉搜索树。", "solution": "### BST 特性(前序遍历)\n\n实现上,我们可以忽略「BST」这一条件,使用「BFS」或者「直接充当满二叉树」来序列化和反序列化。\n\n但由于点的数量是 $1e4$,最坏情况下是当 BST 成链时,会有较大的空间浪费。\n\n因此,一种较为紧凑的序列化/反序列化的方式是利用「前序遍历 + BST 特性」:\n\n* 序列化:对 BST 进行「前序遍历」,并跳过空节点,节点值通过 `,` 进行分割,假设最终序列化出来的字符串是 `s`。\n    之所以使用「前序遍历」是为了方便反序列化:首先对于某个子树而言,其必然是连续存储,也就是必然能够使用 $s[l,r]$ 所表示处理,同时首位元素必然是该子树的头结点;\n\n* 反序列化:将 `s` 根据分隔符 `,` 进行分割,假设分割后数组 `ss` 长度为 $n$,那么 $ss[0, n - 1]$ 代表完整的子树,我们可以利用「二叉树」特性递归构建,设计递归函数 `TreeNode dfs2(int l, int r, Sring[] ss)`,其含义为利用 $ss[l, r]$ 连续段构造二叉树,并返回头结点:\n    1. $ss[l]$ 为头结点,其值为 $t$,在 $[l, r]$ 范围内找到第一个比 $t$ 大的位置 $j$:\n    2. $ss[l]$ 的左子树的所有值均比 $t$ 小,且在 `s` 中连续存储,我们可以递归处理 $[l + 1, j - 1]$ 构建左子树;\n    3. $ss[l]$ 的右子树的所有值均比 $t$ 大,且在 `s` 中连续存储,我们可以递归处理 $[j, r]$ 构建右子树。\n\n代码:\n```Java\npublic class Codec {\n    public String serialize(TreeNode root) {\n        if (root == null) return null;\n        List<String> list = new ArrayList<>();\n        dfs1(root, list);\n        int n = list.size();\n        StringBuilder sb = new StringBuilder();\n        for (int i = 0; i < n; i++) {\n            sb.append(list.get(i));\n            if (i != n - 1) sb.append(\",\");\n        }\n        return sb.toString();\n    }\n    void dfs1(TreeNode root, List<String> list) {\n        if (root == null) return ;\n        list.add(String.valueOf(root.val));\n        dfs1(root.left, list);\n        dfs1(root.right, list);\n    }\n    public TreeNode deserialize(String s) {\n        if (s == null) return null;\n        String[] ss = s.split(\",\");\n        return dfs2(0, ss.length - 1, ss);\n    }\n    TreeNode dfs2(int l, int r, String[] ss) {\n        if (l > r) return null;\n        int j = l + 1, t = Integer.parseInt(ss[l]);\n        TreeNode ans = new TreeNode(t);\n        while (j <= r && Integer.parseInt(ss[j]) <= t) j++;\n        ans.left = dfs2(l + 1, j - 1, ss);\n        ans.right = dfs2(j, r, ss);\n        return ans;\n    }\n}\n```\n* 时间复杂度:令节点数量为 $n$,序列化的复杂度为 $O(n)$;反序列时由于存在「找第一个比头结点值大的位置」操作,每个节点可能被扫描多次,扫描次数与当前节点所在的深度相关,最坏情况下为一条往左下方的链,复杂度为 $O(n^2)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 二分优化\n\n在解法一中的「反序列操作」操作的瓶颈在于需要「找第一个比头结点值大的位置」。\n\n假设连续段 $s[l, r]$ 代表某棵子树的话,由于我们是采用「前序遍历」的方式生成 `s`,因此头结点必然是 $s[l]$,而对于头结点的左右子树,必然是连续两段(先左再右)的形式存储在 $[l + 1, r]$ 中,同时由于该子树是 BST,因此这连续两段必然满足「前一段(左子树)小于 $t$」和「后一段(右子树)大于 $t$」。\n\n即具有「二段性」,因此「找第一个比头结点值大的位置」可用「二分」实现。\n\n代码:\n```Java\npublic class Codec {\n    public String serialize(TreeNode root) {\n        if (root == null) return null;\n        List<String> list = new ArrayList<>();\n        dfs1(root, list);\n        int n = list.size();\n        StringBuilder sb = new StringBuilder();\n        for (int i = 0; i < n; i++) {\n            sb.append(list.get(i));\n            if (i != n - 1) sb.append(\",\");\n        }\n        return sb.toString();\n    }\n    void dfs1(TreeNode root, List<String> list) {\n        if (root == null) return ;\n        list.add(String.valueOf(root.val));\n        dfs1(root.left, list);\n        dfs1(root.right, list);\n    }\n    public TreeNode deserialize(String s) {\n        if (s == null) return null;\n        String[] ss = s.split(\",\");\n        return dfs2(0, ss.length - 1, ss);\n    }\n    TreeNode dfs2(int l, int r, String[] ss) {\n        if (l > r) return null;\n        int ll = l + 1, rr = r, t = Integer.parseInt(ss[l]);\n        while (ll < rr) {\n            int mid = ll + rr >> 1;\n            if (Integer.parseInt(ss[mid]) > t) rr = mid;\n            else ll = mid + 1;\n        }\n        if (Integer.parseInt(ss[rr]) <= t) rr++;\n        TreeNode ans = new TreeNode(t);\n        ans.left = dfs2(l + 1, rr - 1, ss);\n        ans.right = dfs2(rr, r, ss);\n        return ans;\n    }\n}\n```\n* 时间复杂度:令节点数量为 $n$,序列化的复杂度为 $O(n)$;反序列时由于存在「找第一个比头结点值大的位置」操作,最坏情况下为一条往左下方的链,该操作采用「二分」,复杂度为 $O(\\log{n})$,整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.449` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/441-450/450. 删除二叉搜索树中的节点（中等）.md", "url_title": "450. 删除二叉搜索树中的节点", "url": "https://leetcode.cn/problems/delete-node-in-a-bst/solution/by-ac_oier-s60a/", "difficulty": "中等", "tags": ["递归", "BST", "二叉树"], "question": "给定一个二叉搜索树的根节点 `root` 和一个值 `key`,删除二叉搜索树中的 `key` 对应的节点,并保证二叉搜索树的性质不变。返回二叉搜索树(有可能被更新)的根节点的引用。\n\n一般来说,删除节点可分为两个步骤:\n\n* 首先找到需要删除的节点;\n* 如果找到了,删除它。\n\n示例 1:\n\n```\n输入:root = [5,3,6,2,4,null,7], key = 3\n\n输出:[5,4,6,2,null,null,7]\n\n解释:给定需要删除的节点值是 3,所以我们首先找到 3 这个节点,然后删除它。\n一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。\n```\n\n```\n另一个正确答案是 [5,2,6,null,4,null,7]。\n```\n\n示例 2:\n```\n输入: root = [5,3,6,2,4,null,7], key = 0\n\n输出: [5,3,6,2,4,null,7]\n\n解释: 二叉树不包含值为 0 的节点\n```\n示例 3:\n```\n输入: root = [], key = 0\n\n输出: []\n```\n\n提示:\n* 节点数的范围 $[0, 10^4]$\n* $-10^5 <= Node.val <= 10^5$\n* 节点值唯一\n* root 是合法的二叉搜索树\n* $-10^5 <= key <= 10^5$\n\n进阶: 要求算法时间复杂度为 $O(h)$,$h$ 为树的高度。", "solution": "### 递归\n\n利用题目本身的函数签名的含义,也就是「**在以 `root` 为根的子树中,删除值为 `key` 的节点,并返回删除节点后的树的根节点**」,我们可以用「递归」来做。\n\n起始先对边界情况进行处理,当 `root` 为空(可能起始传入的 `root` 为空,也可能是递归过程中没有找到值为 `key` 的节点时,导致的 `root` 为空),我们无须进行任何删除,直接返回 `null` 即可。\n\n根据当前 `root.val` 与 `key` 的大小关系,进行分情况讨论:\n\n1. 若有 $root.val < key$,说明待删除的节点必然不是当前节点,以及不在当前节点的左子树中,我们将删除动作「递归」到当前节点的右子树,并将删除(可能进行)之后的新的右子树根节点,重新赋值给 `root.right`,即有 `root.right = deleteNode(root.right, key)`;\n2. 若有 $root.val > key$,说明待删除的节点必然不是当前节点,以及不在当前节点的右子树,我们将删除节点「递归」到当前节点的左子树,并将删除(可能进行)之后的新的左子树根节点,重新赋值给 `root.left`,即有 `root.left = deleteNode(root.left, key)`;\n3. 若有 $root.val = key$,此时找到了待删除的节点,我们根据左右子树的情况,进行进一步分情况讨论:\n    * 若左/右子树为空,我们直接返回右/左子树节点即可(含义为直接将右/左子树节点搬到当前节点的位置)如图所示:\n        \n    * 若左右子树均不为空,我们有两种选择:\n        * 从「当前节点的左子树」中选择「值最大」的节点替代 `root` 的位置,确保替代后仍满足 `BST` 特性;\n        * 从「当前节点的右子树」中选择「值最小」的节点替代 `root` 的位置,确保替代后仍满足 `BST` 特性;\n\n        我们以「从当前节点的左子树中选择值最大的节点」为例子,我们通过树的遍历,找到其位于「最右边」的节点,记为 $t$($t$ 作为最右节点,必然有 `t.right = null`),利用原本的 `root` 也是合法 `BST`,原本的 `root.right` 子树的所有及节点,必然满足大于 `t.val`,我们可以直接将 `root.right` 接在 `t.right` 上,并返回我们重接后的根节点,也就是 `root.left`。\n        \n        \n        \n        而「从当前节点的右子树中选择值最小的节点」,同理(代码见 $P2$)。\n\n代码:\n```Java\nclass Solution {\n    public TreeNode deleteNode(TreeNode root, int key) {\n        if (root == null) return null;\n        if (root.val == key) {\n            if (root.left == null) return root.right;\n            if (root.right == null) return root.left;\n            TreeNode t = root.left;\n            while (t.right != null) t = t.right;\n            t.right = root.right;\n            return root.left;\n        } else if (root.val < key) root.right = deleteNode(root.right, key);\n        else root.left = deleteNode(root.left, key);\n        return root;\n    }\n}\n```\n\n-\n\n```Java\nclass Solution {\n    public TreeNode deleteNode(TreeNode root, int key) {\n        if (root == null) return null;\n        if (root.val == key) {\n            if (root.left == null) return root.right;\n            if (root.right == null) return root.left;\n            TreeNode t = root.right;\n            while (t.left != null) t = t.left;\n            t.left = root.left;\n            return root.right;\n        } else if (root.val < key) root.right = deleteNode(root.right, key);\n        else root.left = deleteNode(root.left, key);\n        return root;\n    }\n}\n```\n* 时间复杂度:$O(h)$,其中 $h$ 为树的深度\n* 空间复杂度:忽略递归带来的额外空间消耗,复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.450` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/451-460/451. 根据字符出现频率排序（中等）.md", "url_title": "451. 根据字符出现频率排序", "url": "https://leetcode-cn.com/problems/sort-characters-by-frequency/solution/gong-shui-san-xie-shu-ju-jie-gou-yun-yon-gst9/", "difficulty": "中等", "tags": ["模拟", "桶排序", "哈希表", "数组", "优先队列(堆)"], "question": "给定一个字符串,请将字符串里的字符按照出现的频率降序排列。\n\n示例 1:\n```\n输入:\n\"tree\"\n\n输出:\n\"eert\"\n\n解释:\n'e'出现两次,'r'和't'都只出现一次。\n因此'e'必须出现在'r'和't'之前。此外,\"eetr\"也是一个有效的答案。\n```\n示例 2:\n```\n输入:\n\"cccaaa\"\n\n输出:\n\"cccaaa\"\n\n解释:\n'c'和'a'都出现三次。此外,\"aaaccc\"也是有效的答案。\n注意\"cacaca\"是不正确的,因为相同的字母必须放在一起。\n```\n示例 3:\n```\n输入:\n\"Aabb\"\n\n输出:\n\n\"bbAa\"\n\n解释:\n此外,\"bbaA\"也是一个有效的答案,但\"Aabb\"是不正确的。\n注意'A'和'a'被认为是两种不同的字符。\n```\n\n提示:\n* $1 <= s.length <= 5 \\times 10^5$\n* `s` 由大小写英文字母和数字组成", "solution": "### 数据结构 + 模拟\n\n这是一道考察数据结构运用的模拟题。\n\n具体做法如下:\n1. 先使用「哈希表」对词频进行统计;\n2. 遍历统计好词频的哈希表,将每个键值对以 `{字符,词频}` 的形式存储到「优先队列(堆)」中。并规定「优先队列(堆)」排序逻辑为:\n    * 如果 `词频` 不同,则按照 `词频` 倒序;\n    * 如果 `词频` 相同,则根据 `字符字典序` 升序(由于本题采用 Special Judge 机制,这个排序策略随意调整也可以。但通常为了确保排序逻辑满足「全序关系」,这个地方可以写正写反,但理论上不能不写,否则不能确保每次排序结果相同);\n3. 从「优先队列(堆)」依次弹出,构造答案。\n\n代码:\n```Java\nclass Solution {\n    public String frequencySort(String s) {\n        char[] cs = s.toCharArray();\n        Map<Character, Integer> map = new HashMap<>();\n        for (char c : cs) map.put(c, map.getOrDefault(c, 0) + 1);\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->{\n            return a[1] != b[1] ? b[1] - a[1] : a[0] - b[0];\n        });\n        for (char c : map.keySet()) q.add(new int[]{c, map.get(c)});\n        StringBuilder sb = new StringBuilder();\n        while (!q.isEmpty()) {\n            int[] poll = q.poll();\n            int c = poll[0], k = poll[1];\n            while (k-- > 0) sb.append((char)(c));\n        }\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:令字符集的大小为 $C$。使用「哈希表」统计词频的复杂度为 $O(n)$;最坏情况下字符集中的所有字符都有出现,最多有 $C$ 个节点要添加到「优先队列(堆)」中,复杂度为 $O(C\\log{C})$;构造答案需要从「优先队列(堆)」中取出元素并拼接,复杂度为 $O(n)$。整体复杂度为 $O(\\max(n, C\\log{C}))$\n* 空间复杂度:$O(n)$\n\n---\n\n### 数组实现 + 模拟\n\n基本思路不变,将上述过程所用到的数据结构使用数组替代。\n\n具体的,利用 ASCII 字符集共 $128$ 位,预先建立一个大小为 $128$ 的数组,利用「桶排序」的思路替代「哈希表」和「优先队列(堆)」的作用。\n\n代码:\n```Java\nclass Solution {   \n    public String frequencySort(String s) {\n        int[][] cnts = new int[128][2];\n        char[] cs = s.toCharArray();\n        for (int i = 0; i < 128; i++) cnts[i][0] = i;\n        for (char c : cs) cnts[c][1]++;\n        Arrays.sort(cnts, (a, b)->{\n            return a[1] != b[1] ? b[1] - a[1] : a[0] - b[0];\n        });\n        StringBuilder sb = new StringBuilder();\n        for (int i = 0; i < 128; i++) {\n            char c = (char)cnts[i][0];\n            int k = cnts[i][1];\n            while (k-- > 0) sb.append(c);\n        }\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:令字符集的大小为 $C$,复杂度为 $O(\\max(n, C\\log{C}))$\n* 空间复杂度:$O(n + C + \\log{C})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.451` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/451-460/453. 最小操作次数使数组元素相等（简单）.md", "url_title": "453. 最小操作次数使数组元素相等", "url": "https://leetcode-cn.com/problems/minimum-moves-to-equal-array-elements/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-tt3zu/", "difficulty": "简单", "tags": ["数学"], "question": "给你一个长度为 `n` 的整数数组,每次操作将会使 `n - 1` 个元素增加 `1` 。\n\n返回让数组所有元素相等的最小操作次数。\n\n示例 1:\n```\n输入:nums = [1,2,3]\n\n输出:3\n\n解释:\n只需要3次操作(注意每次操作会增加两个元素的值):\n[1,2,3]  =>  [2,3,3]  =>  [3,4,3]  =>  [4,4,4]\n```\n示例 2:\n```\n输入:nums = [1,1,1]\n\n输出:0\n```\n\n提示:\n* n == nums.length\n* $1 <= nums.length <= 10^5$\n* $-10^9 <= nums[i] <= 10^9$\n* 答案保证符合 32-bit 整数", "solution": "### 数学\n\n为了方便,令原数组 $num$ 的总和为 $sum$,最小值为 $min$,最大值为 $max$,长度为 $n$,真实最小操作次数为 $ans$。\n\n由于每次只能将 $n - 1$ 个元素整体加一,因此在最终的相等状态,整体元素的大小值 $t$ 满足关系 $t \\geqslant max$。\n\n我们考虑是否必然可以取到关系式中的等号?\n\n答案是不一定,当且仅当 $num$ 本身有 $n - 1$ 个元素与 $max$ 差值相等,才能取得关系式中的等号。\n\n同时我们知道,$ans$ 与 $t$ 存在一一对应关系:\n\n$$\nans = \\frac{t * n - sum}{n - 1}\n$$\n\n要取得最小的 $ans$,其实等价于取得最小的 $t$,但仅靠 $t \\geqslant max$ 关系,我们无法直接求得 $ans$。\n\n事实上,我们可以通过值变化来进行分析,凭直觉我们会觉得:**在配平整个数组的过程中,当前数组中的最小值会参与到自增过程中。**\n\n我们通过「反证法」来证明该猜想的正确性。\n\n假设在配平数组的过程,某次自增操作中,「当前最小值」没有参与到自增当中,那么此时自增的对象是除「当前最小值」以外的其余元素,这时候「当前最小值」与其他元素的差值将会增加 $1$,此时如果将操作换成「包含当前最小值自增」的话,我们是可以将最终值 $t$ 减一的,如果最终值 $t$ 变小的话,那么 $ans$ 也会变小,结果会更好。\n\n**因此,如果我们某次自增操作中没有包含「当前最小值」对应的元素的话,我们可以通过调整 $t$ 的大小(减一),来将操作调整为「包含当前最小值进行自增」,同时结果会变好。**\n\n到这里就结束了吗?\n\n还没有,因为到这里我们还不能直接与原始最小值 $min$ 结合起来。\n\n我们还需要证明 **原始的相对最小值 $min$ 在匹配过程中,可以一直保持自身是当前数组中的「相对最小值」**。\n\n这可以通过「归纳法」来证明:\n\n**如果在每次自增操作中,都包含「当前最小值」,那么意味着原始最小值与其他元素的「相对大小」关系不会发生改变(因为原始最小值会一直作为「相对最小值」参与到每一次自增当中)得证成立。**\n\n至此,我们可以得到 $t$ 和 $min$ 的关系式:\n\n$$\nt = min + ans\n$$\n\n代入之前我们得到的关系式可得:\n\n$$\nans = \\frac{(min + ans) * n - sum}{n - 1}\n$$\n\n变形整理后可得:\n\n$$\nans = sum - min * n\n$$\n\n代码:\n```Java\nclass Solution {\n    public int minMoves(int[] nums) {\n        int n = nums.length;\n        long min = nums[0], sum = 0;\n        for (int i : nums) {\n            min = Math.min(min, i);\n            sum += i;\n        }\n        return (int)(sum - min * n);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.453` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/451-460/456. 132 模式（中等）.md", "url_title": "456. 132 模式", "url": "https://leetcode-cn.com/problems/132-pattern/solution/xiang-xin-ke-xue-xi-lie-xiang-jie-wei-he-95gt/", "difficulty": "中等", "tags": ["单调栈"], "question": "给你一个整数数组 `nums`,数组中共有 `n` 个整数。`132` 模式的子序列 由三个整数 `nums[i]`、`nums[j]` 和 `nums[k]` 组成,并同时满足:$i < j < k$ 和 $nums[i] < nums[k] < nums[j]$ 。\n\n如果 `nums` 中存在 `132` 模式的子序列 ,返回 `true`;否则,返回 `false`。\n\n进阶:很容易想到时间复杂度为 $O(n^2)$ 的解决方案,你可以设计一个时间复杂度为 $O(n \\log{n})$ 或$ O(n)$ 的解决方案吗?\n\n示例 1:\n```\n输入:nums = [1,2,3,4]\n\n输出:false\n\n解释:序列中不存在 132 模式的子序列。\n```\n示例 2:\n```\n输入:nums = [3,1,4,2]\n\n输出:true\n\n解释:序列中有 1 个 132 模式的子序列: [1, 4, 2] 。\n```\n示例 3:\n```\n输入:nums = [-1,3,2,0]\n\n输出:true\n\n解释:序列中有 3 个 132 模式的的子序列:[-1, 3, 2]、[-1, 3, 0] 和 [-1, 2, 0] 。\n```\n\n提示:\n* $n = nums.length$\n* $1 <= n <= 10^4$\n* $-10^9 <= nums[i] <= 10^9$", "solution": "### 基本思路\n\n朴素的做法是分别对三个数进行枚举,这样的做法是 $O(n^3)$ 的,数据范围是 $10^4$,稳稳超时。\n\n事实上,这样的数据范围甚至不足以我们枚举其中两个数,然后优化找第三个数的 $O(n^2)$ 做法。\n\n**这时候根据数据范围会联想到树状数组,使用树状数组的复杂度是 $O(n\\log{n})$ 的,可以过。但是代码量会较多一点,还需要理解离散化等前置知识**。题解也不太好写。\n\n因此,我们可以从 132 的大小特性去分析,如果在确定一个数之后,如何快速找到另外两个数(我们使用 `ijk` 来代指 132 结构):\n\n1. 枚举 `i`:由于 `i` 是 132 结构中最小的数,那么相当于我们要从 i 后面,找到一个对数 `(j,k)`,使得 `(j,k)` 都满足比 `i` 大,同时 `j` 和 `k` 之间存在 `j > k` 的关系。由于我们的遍历是单向的,因此我们可以将问题转化为找 `k`,首先 `k` 需要比 `i` 大,同时在 `[i, k]` 之间存在比 `k` 大的数即可。\n\n2. 枚举 `j`:由于 `j` 是 132 结构里最大的数,因此我们需要在 `j` 的右边中比 `j` 小的「最大」的数,在 `j` 的左边找比 `j` 小的「最小」的数。这很容易联想到单调栈,但是朴素的单调栈是帮助我们找到左边或者右边「最近」的数,无法直接满足我们「最大」和「最小」的要求,需要引入额外逻辑。\n\n3. 枚举 `k`:由于 `k` 是 132 结构中的中间值,这里的分析逻辑和「枚举 i」类似,因为遍历是单向的,我们需要找到 `k` 左边的 `i`,同时确保 `[i,k]` 之间存在比 `i` 和 `k` 大的数字。\n\n以上三种分析方法都是可行的,但「枚举 i」的做法是最简单的。\n\n**因为如果存在 `(j,k)` 满足要求的话,我们只需要找到一个最大的满足条件的 `k`,通过与 `i` 的比较即可。**\n\n也许你还不理解是什么意思。没关系,我们一边证明一边说。\n\n---\n\n### 过程 & 证明\n\n先说处理过程吧,我们从后往前做,维护一个「单调递减」的栈,同时使用 `k` 记录所有出栈元素的最大值(`k` 代表满足 132 结构中的 2)。\n\n那么当我们遍历到 `i`,只要满足发现满足 `nums[i] < k`,说明我们找到了符合条件的 `i j k`。\n\n举个🌰,对于样例数据 `[3, 1, 4, 2]`,我们知道满足 132 结构的子序列是 `[1, 4, 2]`,其处理逻辑是(遍历从后往前):\n\n1. 枚举到 2:栈内元素为 [2],`k` = INF\n2. 枚举到 4:不满足「单调递减」,2 出栈更新 `k`,4 入栈。栈内元素为 [4],`k` = 2\n3. 枚举到 1:满足 `nums[i] < k`,说明对于 `i` 而言,后面有一个比其大的元素(满足 `i < k` 的条件),同时这个 `k` 的来源又是因为维护「单调递减」而弹出导致被更新的(满足 `i` 和 `k` 之间,有比 `k` 要大的元素)。因此我们找到了满足 132 结构的组合。\n\n**这样做的本质是:我们通过维护「单调递减」来确保已经找到了有效的 `(j,k)`。换句话说如果 `k` 有值的话,那么必然是因为有 `j > k`,导致的有值。也就是 132 结构中,我们找到了 32,剩下的 `i` (也就是 132 结构中的 1)则是通过遍历过程中与 `k` 的比较来找到。这样做的复杂度是 $O(n)$ 的,比树状数组还要快。**\n\n从过程上分析,是没有问题的。\n\n搞清楚了处理过程,证明也变得十分简单。\n\n我们不失一般性的考虑任意数组 `nums`,假如真实存在 `ijk` 符合 132 的结构(这里的 `ijk` 特指所有满足 132 结构要求的组合中 `k` 最大的那个组合)。\n\n由于我们的比较逻辑只针对 `i` 和 `k`,而 `i` 是从后往前的处理的,必然会被遍历到;漏掉 `ijk` 的情况只能是:在遍历到 `i` 的时候,我们没有将 `k` 更新到变量中:\n\n1. 这时候变量的值要比真实情况下的 `k` 要小,说明 `k` 还在栈中,而遍历位置已经到达了 `i`,说明 `j` 和 `k` 同时在栈中,与「单调递减」的性质冲突。\n2. 这时候变量的值要比真实情况下的 `k` 要大,说明在 `k` 出栈之后,有比 `k` 更大的数值出栈了(同时必然有比变量更大的值在栈中),这时候要么与我们假设 `ijk` 是 `k` 最大的组合冲突;要么与我们遍历到的位置为 `i` 冲突。\n\n**综上,由于「单调递减」的性质,我们至少能找到「遍历过程中」所有符合条件的 `ijk` 中 `k` 最大的那个组合。**\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean find132pattern(int[] nums) {\n        int n = nums.length;\n        Deque<Integer> d = new ArrayDeque<>();\n        int k = Integer.MIN_VALUE;\n        for (int i = n - 1; i >= 0; i--) {\n            if (nums[i] < k) return true;\n            while (!d.isEmpty() && d.peekLast() < nums[i]) {\n                // 事实上,k 的变化也具有单调性,直接使用 k = pollLast() 也是可以的\n                k = Math.max(k, d.pollLast()); \n            }\n            d.addLast(nums[i]);\n        }\n        return false;\n    }\n}\n```\nPython3 代码:\n```Python3\nclass Solution:\n    def find132pattern(self, nums: List[int]) -> bool:\n        stack = []\n        k = -(10 ** 9 + 7)\n        for i in range(len(nums) - 1,-1,-1):\n            if nums[i] < k:\n                return True\n            while stack and stack[-1] < nums[i]:\n                k = max(k,stack.pop())\n            stack.append(nums[i])\n        return False\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool find132pattern(vector<int>& nums) {\n        stack<int> st;\n        int n = nums.size(), k = INT_MIN;\n        for(int i = n - 1; i >= 0; i--){\n            if(nums[i] < k) return true;\n            while(!st.empty() and st.top() < nums[i]) { \n                k = max(k,st.top()); st.pop();\n            }\n            st.push(nums[i]);\n        }\n        return false;\n    }\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.456` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/451-460/457. 环形数组是否存在循环（中等）.md", "url_title": "457. 环形数组是否存在循环", "url": "https://leetcode-cn.com/problems/circular-array-loop/solution/gong-shui-san-xie-yi-ti-shuang-jie-mo-ni-ag05/", "difficulty": "中等", "tags": ["图", "模拟"], "question": "存在一个不含 $0$ 的 环形 数组 $nums$ ,每个 $nums[i]$ 都表示位于下标 $i$ 的角色应该向前或向后移动的下标个数:\n\n* 如果 $nums[i]$ 是正数,向前 移动 $nums[i]$ 步\n* 如果 $nums[i]$ 是负数,向后 移动 $nums[i]$ 步\n\n因为数组是**环形**的,所以可以假设从最后一个元素向前移动一步会到达第一个元素,而第一个元素向后移动一步会到达最后一个元素。\n\n数组中的 循环 由长度为 $k$ 的下标序列 $seq$ :\n* 遵循上述移动规则将导致重复下标序列 `seq[0] -> seq[1] -> ... -> seq[k - 1] -> seq[0] -> ...`\n* 所有 $nums[seq[j]]$ 应当不是 全正 就是 全负\n* $k > 1$\n\n如果 $nums$ 中存在循环,返回 $true$ ;否则,返回 $false$。\n\n示例 1:\n```\n输入:nums = [2,-1,1,2,2]\n\n输出:true\n\n解释:存在循环,按下标 0 -> 2 -> 3 -> 0 。循环长度为 3 。\n```\n示例 2:\n```\n输入:nums = [-1,2]\n\n输出:false\n\n解释:按下标 1 -> 1 -> 1 ... 的运动无法构成循环,因为循环的长度为 1 。根据定义,循环的长度必须大于 1 。\n```\n示例 3:\n```\n输入:nums = [-2,1,-1,-2,-2]\n\n输出:false\n\n解释:按下标 1 -> 2 -> 1 -> ... 的运动无法构成循环,因为 nums[1] 是正数,而 nums[2] 是负数。\n所有 nums[seq[j]] 应当不是全正就是全负。\n```\n\n提示:\n* 1 <= nums.length <= 5000\n* -1000 <= nums[i] <= 1000\n* nums[i] != 0\n\n进阶:你能设计一个时间复杂度为 O(n) 且额外空间复杂度为 O(1) 的算法吗?", "solution": "### 模拟\n\n根据题意,我们可以从每个下标 $i$ 进行出发检查,如果以某个下标 $i$ 为出发点发现了「循环」,返回 `True`,否则返回 `False`。\n\n唯一需要注意的细节是,当我们处理到的下标为 $cur$,计算下一个跳转点 $next = cur + nums[cur]$ 时,对于越过数组的情况进行处理:\n\n1. 如果 $next$ 为负数:在 $next$ 的基础上增加 $n * \\left \\lceil next / n \\right \\rceil$,将其映射回正值;\n\n2. 如果 $next$ 为正数:将 $next$ 模数组长度 $n$,确保不会越界。\n\n整理一下,我们可以统一写成 `next = ((cur + nums[cur]) % n + n ) % n`。\n\n在 `check` 内部,当以下任一条件出现,则可以结束检查(令 $k$ 为记录过程中扫描过的下标数量):\n\n1. 如果在检查过程中,找到了与起点相同的下标,且 $k > 1$,说明存在符合条件的「循环」,返回 `True`;\n\n2. 如果检查过程中扫描的数量 $k$ 超过了数组长度 $n$,那么根据「[鸽笼原理](https://baike.baidu.com/item/%E6%8A%BD%E5%B1%89%E5%8E%9F%E7%90%86/233776)」,必然有数被重复处理了,同时条件一并不符合,因此再处理下去,也不会到达与起点相同的下标,返回 `False`;\n\n3. 处理过程中发现不全是正数或者负数,返回 `False`。\n\n代码:\n```Java\nclass Solution {\n    int n;\n    int[] nums;\n    public boolean circularArrayLoop(int[] _nums) {\n        nums = _nums;\n        n = nums.length;\n        for (int i = 0; i < n; i++) {\n            if (check(i)) return true;\n        }\n        return false;\n    }\n    boolean check(int start) {\n        int cur = start;\n        boolean flag = nums[start] > 0;\n        int k = 1;\n        while (true) {\n            if (k > n) return false;\n            int next = ((cur + nums[cur]) % n + n ) % n;\n            if (flag && nums[next] < 0) return false;\n            if (!flag && nums[next] > 0) return false;\n            if (next == start) return k > 1;\n            cur = next;\n            k++;\n        }\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 图的遍历标记(使用新数组标记)\n\n**这是一种补充做法,更多的作为「解法一」和「解法三」之间的过渡,建议在充分理解本解法之后,再学习解法三。**\n\n从「解法一」我们发现,我们会对很多重复的路径进行重复检查。\n\n假如从位置 $a$ 到位置 $d$ 存在一条无环通路 $a-b-c-d$,根据「解法一」我们会在对 $a$ 进行通路是否有环的检查之后,再对 $b$ 、$c$ 和 $d$ 进行路径是否有环的检查。\n\n事实上,由于每个点只有一个出度(某个位置能跳到的下一个位置是唯一确定的),因此我们可以使用 `vis` 数组记录那些下标被检查过了,从而避免相同的路径被重复检查。\n\n**同时,我们可以扩充 `vis` 数组的功能,使其不仅仅能用于判断某个位置是否被检查过,还能记录下某个位置是在哪一轮被检查过。具体的,我们令 $vis[i] = idx$ 代表位置 $i$ 在第 $idx$ 轮被标记。**\n\n如此一来,当我们检查某个位置 $start$ 的通路时,如果遇到一个跳点 $next$,发现 $vis[next]$ 不为 $0$(代表被被记过),可通过将 $vis[next]$ 与当前轮次编号做对比,来得知该位置是否在本轮被标记。\n\n代码:\n```Java\nclass Solution {   \n    public boolean circularArrayLoop(int[] nums) {\n        int n = nums.length;\n        // 使用 vis 数组对每个下标进行标记\n        // 如果下标为 i 的位置在第 idx 轮被标记,则有 vis[i] = idx\n        int[] vis = new int[n];\n        for (int start = 0, idx = 1; start < n; start++, idx++) {\n            if (vis[start] != 0) continue;\n            int cur = start;\n            boolean flag = nums[cur] > 0;\n            while (true) {\n                int next = ((cur + nums[cur]) % n + n) % n;\n                if (next == cur) break;\n                if (vis[next] != 0) {\n                    // 如果 next 点已经被标记过,并且不是在本轮被标记,那么往后的通路必然都被标记,且无环,跳出   \n                    if (vis[next] != idx) break;\n                    // 如果 next 点已被标记,并且是本来被标记,说明找到了环\n                    else return true;\n                }\n                if (flag && nums[next] < 0) break;\n                if (!flag && nums[next] > 0) break;\n                vis[next] = idx;\n                cur = next;\n            }\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 图的遍历标记(使用原数组标记)\n\n**根据题意,我们将每个下标看做“点”,「当前点」和「当前点所能到达的下一个点」看作“边”。**\n\n**从而将问题转换为经典的「图论寻环」问题,同时又因为每个点出度固定为 $1$,并且规定「循环」必然是「同向」才合法,因此如果我们在遍历过程中发现存在反向,就停止检查。**\n\n另外,为实现 $O(1)$ 的空间,我们需要在原数组上进行标记,我们设立一个足够大的数 `OFFSET`,对于由下标 $i$ 发起的寻环操作,我们将扫描的数标记为 `OFFSET + i`。如果在扫描完由 $i$ 发起的寻环后,没法发现自环,说明找到了「循环」,输出 `True`。\n\n代码:\n```Java\nclass Solution {\n    int OFFSET = 100010;\n    public boolean circularArrayLoop(int[] nums) {\n        int n = nums.length;\n        for (int i = 0; i < n; i++) {\n            if (nums[i] >= OFFSET) continue;\n            int cur = i, tag = OFFSET + i, last = -1;\n            boolean flag = nums[cur] > 0;\n            while (true) {\n                int next = ((cur + nums[cur]) % n + n ) % n;\n                last = nums[cur];\n                nums[cur] = tag;\n                cur = next;\n                if (cur == i) break;\n                if (nums[cur] >= OFFSET) break;\n                if (flag && nums[cur] < 0) break;\n                if (!flag && nums[cur] > 0) break;\n            }\n            if (last % n != 0 && nums[cur] == tag) return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.457` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/451-460/458. 可怜的小猪（困难）.md", "url_title": "458. 可怜的小猪", "url": "https://leetcode-cn.com/problems/poor-pigs/solution/gong-shui-san-xie-jin-zhi-cai-xiang-xian-69fl/", "difficulty": "困难", "tags": ["数学"], "question": "有 `buckets` 桶液体,其中 正好 有一桶含有毒药,其余装的都是水。它们从外观看起来都一样。\n\n为了弄清楚哪只水桶含有毒药,你可以喂一些猪喝,通过观察猪是否会死进行判断。不幸的是,你只有 `minutesToTest` 分钟时间来确定哪桶液体是有毒的。\n\n喂猪的规则如下:\n\n1. 选择若干活猪进行喂养\n2. 可以允许小猪同时饮用任意数量的桶中的水,并且该过程不需要时间。\n3. 小猪喝完水后,必须有 `minutesToDie` 分钟的冷却时间。在这段时间里,你只能观察,而不允许继续喂猪。\n4. 过了 `minutesToDie` 分钟后,所有喝到毒药的猪都会死去,其他所有猪都会活下来。\n5. 重复这一过程,直到时间用完。\n\n给你桶的数目 `buckets` ,`minutesToDie` 和 `minutesToTest` ,返回在规定时间内判断哪个桶有毒所需的 最小 猪数。\n\n示例 1:\n```\n输入:buckets = 1000, minutesToDie = 15, minutesToTest = 60\n\n输出:5\n```\n示例 2:\n```\n输入:buckets = 4, minutesToDie = 15, minutesToTest = 15\n\n输出:2\n```\n示例 3:\n```\n输入:buckets = 4, minutesToDie = 15, minutesToTest = 30\n\n输出:2\n```\n\n提示:\n* $1 <= buckets <= 1000$\n* $1 <= minutesToDie <= minutesToTest <= 100$", "solution": "### 数学\n\n我们用实验对象来代指题干的小动物。同时为了方便,我们使用 $n$ 代指有多少桶水,$d$ 为实验对象的反应时间,$t$ 为测试总时间。\n\n根据题意,最大测试次数为 $k = \\left \\lfloor \\frac{t}{d} \\right \\rfloor$。\n\n我们可以先考虑 $k = 1$ 的情况,最简单的情况是,我们使用与水同等数量的实验对象数量来进行测试。\n\n此时哪个实验对象有反应,则可以推断出哪一桶水有问题。\n\n但这样的测试方式,每个实验动物承载的信息量是很低的,每个实验对象仅承载了某一桶水是否有问题。\n\n**为减少实验对象数量,我们需要增大每个实验对象承载的信息量(让每个实验对象同时测试多桶水),然后从最终所有实验对象的状态(是否有所反应)来反推哪一桶水有问题。**\n\n用最小单位表示最大信息量,这引导我们使用「进制表示」相关方式。由于我们只有 $1$ 次测试机会,因此我们可以使用二进制的方式进行测试。\n\n当 $k = 1$,使用二进制的方式测试哪桶水有问题,我们至少需要 $m$ 个实验对象(其中 $m$ 为 $n$ 的二进制表示的长度),然后让编号为 $x$($0 <= x < m$)的实验对象喝掉二进制表示中第 $x$ 位为 $1$ 的水。\n\n最终这 $m$ 个实验对象会对应一个结果序列:如果编号 $x_1$ 的实验对象没有反应,说明有问题的水的二进制表示中第 $x_1$ 位为 $0$,如果编号为 $x_2$ 的实验对象有反应,则说明有问题的水的二进制表示中第 $x_2$ 为 $1$。即根据最终每个实验对象的状态,我们可以完整地反推回有问题的水的编号是多少。\n\n当 $k > 1$ 时,相当于在原问题基础上,多考虑一层「轮数」维度,即不仅考虑某个实验对象是否有所反应,还需要考虑是在哪一轮有所反应。\n\n我们还是使用「进制表示」的方式来最大化每个单位所能承载的最大信息量。\n\n具体的,我们先使用 $k + 1$ 进制对所有水进行编号,此时每桶水都有唯一的进制表示编码。然后我们考虑「什么时候」将水喂给「哪个实验对象」。\n\n其中一种可行的测试方式是:设定需要的实验对象数量 $m$ 为 $k + 1$ 进制数的长度,若某桶水的 $k + 1$ 进制中的第 $x$ 位为 $i$($0 <= i <= k$),则代表将该水在第 $i$ 轮喂给编号为 $x$ 的实验对象。\n\n同理,利用最终的结果矩阵,我们可以反推回是哪一桶水是有问题的。\n\n**上述做法,只是阐述了我们存在这样的可行解,需要证明这样的做法是最优解。**\n\n利用 [香农熵](https://baike.baidu.com/item/香农熵),我们可以计算明确熵值,公式为:\n\n$$\nH(X) = - \\sum_{x}^{} P(x) \\log_2[P(x)]\n$$\n\n其中 $P(x)$ 代表随机事件 $x$ 的发生概率。\n\n对于本题,记随机事件 $A$ 为 $n$ 桶水中哪一个桶有问题,概率为 $\\frac{1}{n}$。\n\n记随机事件 $B$ 为在测试轮数为 $k$ 时,所有实验对象的最终状态,每个实验对象的状态共有 $k + 1$ 种,即共有 $C = (k + 1)^m$ 种最终结果,可近似看做等概率 $\\frac{1}{C}$。\n\n我们需要求得在满足 $H(A) <= H(B)$ 前提下的最小 $m$ 值。\n\n代入公式可得:\n\n$$\n-(\\log_2{\\frac{1}{n}}) <= - \\sum_{result = 0}^{(k + 1)^m} \\frac{1}{(k + 1)^m} \\log_2{\\frac{1}{(k + 1)^m}} = m \\log_2(k + 1)\n$$\n\n移项化简得:\n\n$$\n\\frac{\\log_2{n}}{\\log_2{(k + 1)}} <= m\n$$\n\n代码:\n```Java\nclass Solution {\n    public int poorPigs(int n, int d, int t) {\n        int k = t / d;\n        return (int) Math.ceil(Math.log(n) / Math.log(k + 1));\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.458` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/451-460/460. LFU 缓存（困难）.md", "url_title": "460. LFU 缓存", "url": "https://leetcode-cn.com/problems/lfu-cache/solution/gong-shui-san-xie-yun-yong-tong-pai-xu-s-53m3/", "difficulty": "困难", "tags": ["链表", "双向链表", "设计"], "question": "请你为 **最不经常使用(LFU)** 缓存算法设计并实现数据结构。\n\n实现 `LFUCache` 类:\n\n* `LFUCache(int capacity)` - 用数据结构的容量 `capacity` 初始化对象\n* `int get(int key)` - 如果键存在于缓存中,则获取键的值,否则返回 -1。\n* `void put(int key, int value)` - 如果键已存在,则变更其值;如果键不存在,请插入键值对。当缓存达到其容量时,则应该在插入新项之前,使最不经常使用的项无效。在此问题中,当存在平局(即两个或更多个键具有相同使用频率)时,应该去除 **最近最久未使用** 的键。\n\n注意「项的使用次数」就是自插入该项以来对其调用 `get` 和 `put` 函数的次数之和。使用次数会在对应项被移除后置为 0 。\n\n为了确定最不常使用的键,可以为缓存中的每个键维护一个 使用计数器 。使用计数最小的键是最久未使用的键。\n\n当一个键首次插入到缓存中时,它的使用计数器被设置为 1 (由于 `put` 操作)。对缓存中的键执行 `get` 或 `put` 操作,使用计数器的值将会递增。\n\n示例:\n```\n输入:\n[\"LFUCache\", \"put\", \"put\", \"get\", \"put\", \"get\", \"get\", \"put\", \"get\", \"get\", \"get\"]\n[[2], [1, 1], [2, 2], [1], [3, 3], [2], [3], [4, 4], [1], [3], [4]]\n输出:\n[null, null, null, 1, null, -1, 3, null, -1, 3, 4]\n\n解释:\n// cnt(x) = 键 x 的使用计数\n// cache=[] 将显示最后一次使用的顺序(最左边的元素是最近的)\nLFUCache lFUCache = new LFUCache(2);\nlFUCache.put(1, 1);   // cache=[1,_], cnt(1)=1\nlFUCache.put(2, 2);   // cache=[2,1], cnt(2)=1, cnt(1)=1\nlFUCache.get(1);      // 返回 1\n                      // cache=[1,2], cnt(2)=1, cnt(1)=2\nlFUCache.put(3, 3);   // 去除键 2 ,因为 cnt(2)=1 ,使用计数最小\n                      // cache=[3,1], cnt(3)=1, cnt(1)=2\nlFUCache.get(2);      // 返回 -1(未找到)\nlFUCache.get(3);      // 返回 3\n                      // cache=[3,1], cnt(3)=2, cnt(1)=2\nlFUCache.put(4, 4);   // 去除键 1 ,1 和 3 的 cnt 相同,但 1 最久未使用\n                      // cache=[4,3], cnt(4)=1, cnt(3)=2\nlFUCache.get(1);      // 返回 -1(未找到)\nlFUCache.get(3);      // 返回 3\n                      // cache=[3,4], cnt(4)=1, cnt(3)=3\nlFUCache.get(4);      // 返回 4\n                      // cache=[3,4], cnt(4)=2, cnt(3)=3\n```\n\n提示:\n* 0 <= capacity, key, value <= $10^4$\n* 最多调用 $10^5$ 次 `get` 和 `put` 方法\n\n进阶:你可以为这两种操作设计时间复杂度为 $O(1)$ 的实现吗?", "solution": "### 基本分析\n\n前两天我们刚讲过 [146. LRU 缓存机制](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486820&idx=1&sn=2055864e10848bce55afc4e2feda79a7&chksm=fd9ca67bcaeb2f6d2038706e32cafffd701d3d6b71b60c52a568ed6dc0e268d93f8a78498105&token=672687058&lang=zh_CN#rd) ,简单理解 LRU 就是「移除最久不被使用的元素」。\n\n因此对于 LRU 我们只需要在使用「哈希表」的同时,维护一个「双向链表」即可:\n\n* 每次发生 `get` 或 `put` 的时候就将元素存放双向链表头部\n* 当需要移除元素时,则从双向链表尾部开始移除\n\nLFU 简单理解则是指「移除使用次数最少的元素」,如果存在多个使用次数最小的元素,则移除「最近不被使用的那个」(LRU 规则)。同样的 `get` 和 `put` 都算作一次使用。\n\n因此,我们需要记录下每个元素的使用次数,并且在 $O(1)$ 的复杂度内「修改某个元素的使用次数」和「找到使用次数最小的元素」。\n\n---\n\n### 桶排序 + 双向链表\n\n**我们可以使用「桶排序」的思路,搭配「双向链表」实现 $O(1)$ 操作。**\n\n**在 `LFUCache` 中,我们维护一个由 `Bucket` 作为节点的双向链表,每个 `Bucket` 都有一个 `idx` 编号,代表当前桶存放的是「使用了多少次」的键值对**(`idx = 1` 的桶存放使用一次的键值对;`idx = 2` 的桶存放的是使用两次的键值对 ... )。\n\n同时 `LFUCache` 持有一个「哈希表」,用来记录哪些 `key` 在哪个桶内。\n\n**在 `Bucket` 内部则是维护了一条以 `Item` 作为节点的双向链表,`Item` 是用作存放真实键值对的。**\n\n同样的,`Bucket` 也持有一个「哈希表」,用来记录 `key` 与 `Item` 的映射关系。\n\n因此 `LFUCache` 其实是一个「链表套链表」的数据结构:\n\n对应到 `LFUCache` 的几种操作:\n\n* `get` :先通过 `LFUCache` 持有的哈希表进行查找,如果不存在返回 $-1$,如果存在找到键值对所在的桶 `cur`:\n    * 调用对应的 `cur` 的 `remove` 操作,得到键值对对应的 `item`(移除代表当前键值对使用次数加一了,不会在存在于原来的桶中)。\n    * 将 `item` 放到 `idx` 为 $cur.idx + 1$ 的桶 `target` 中(代表代表当前键值对使用次数加一,应该放到新的目标桶中)。\n    * 如果目标桶 `target` 不存在,则创建;如果原来桶 `cur` 移除键值对后为空,则销毁。\n    * 更新 `LFUCache` 中哈希表的信息。\n* `put` : 先通过 `LFUCache` 持有的哈希表进行查找:\n    * 如果存在:找到键值对所在的桶 `cur`,调用 `cur` 的 `put` 操作,更新键值对,然后调用 `LFUCache` 的 `get` 操作实现使用次数加一。\n    * 如果不存在:先检查容量是否达到数量:\n        * 容量达到数量的话需要调用「编号最小的桶」的 `clear` 操作,在 `clear` 操作内部,会从 `item` 双向链表的尾部开始移除元素。完成后再执行插入操作。\n    * 插入操作:将键值对添加到 $idx = 1$ 的桶中(代表当前键值对使用次数为 $1$),如果桶不存在则创建。\n\n代码:\n```Java\nclass LFUCache {\n\n    class Item {\n        Item l, r;\n        int k, v;\n        public Item(int _k, int _v) {\n            k = _k;\n            v = _v;\n        }\n    }\n\n    class Bucket {\n        Bucket l, r;\n        int idx;\n        Item head, tail;\n        Map<Integer, Item> map = new HashMap<>();\n        public Bucket(int _idx) {\n            idx = _idx;\n            head = new Item(-1, -1);\n            tail = new Item(-1, -1);\n            head.r = tail;\n            tail.l = head;\n        }\n        void put(int key, int value) {\n            Item item = null;\n            if (map.containsKey(key)) {\n                item = map.get(key);\n                // 更新值\n                item.v = value;\n                // 在原来的双向链表位置中移除\n                item.l.r = item.r;\n                item.r.l = item.l;\n            } else {\n                item = new Item(key, value);\n                // 添加到哈希表中\n                map.put(key, item);\n            }\n            // 增加到双向链表头部\n            item.r = head.r;\n            item.l = head;\n            head.r.l = item;\n            head.r = item;\n        }\n        Item remove(int key) {\n            if (map.containsKey(key)) {\n                Item item = map.get(key);\n                // 从双向链表中移除\n                item.l.r = item.r;\n                item.r.l = item.l;\n                // 从哈希表中移除\n                map.remove(key);\n                return item;\n            }\n            return null; // never\n        }\n        Item clear() {\n            // 从双向链表尾部找到待删除的节点\n            Item item = tail.l;\n            item.l.r = item.r;\n            item.r.l = item.l;\n            // 从哈希表中移除\n            map.remove(item.k);\n            return item;\n        }\n        boolean isEmpty() {\n            return map.size() == 0;\n        }\n    }\n\n    Map<Integer, Bucket> map = new HashMap<>();\n    Bucket head, tail;\n    int n;\n    int cnt;\n    public LFUCache(int capacity) {\n        n = capacity;\n        cnt = 0;\n        head = new Bucket(-1);\n        tail = new Bucket(-1);\n        head.r = tail;\n        tail.l = head;\n    }\n    \n    public int get(int key) {\n        if (map.containsKey(key)) {\n            Bucket cur = map.get(key);\n            \n            Bucket target = null;\n            if (cur.r.idx != cur.idx + 1) { \n                // 目标桶空缺\n                target = new Bucket(cur.idx + 1);\n                target.r = cur.r;\n                target.l = cur;\n                cur.r.l = target;\n                cur.r = target;\n            } else {\n                target = cur.r;\n            }\n\n            // 将当前键值对从当前桶移除,并加入新的桶\n            Item remove = cur.remove(key);\n            target.put(remove.k, remove.v);\n            // 更新当前键值对所在桶信息\n            map.put(key, target);\n\n            // 如果在移除掉当前键值对后,当前桶为空,则将当前桶删除(确保空间是 O(n) 的)\n            // 也确保调用编号最小的桶的 clear 方法,能够有效移除掉一个元素\n            deleteIfEmpty(cur);\n\n            return remove.v;\n        } \n        return -1;\n    }\n    \n    public void put(int key, int value) {\n        if (n == 0) return;\n        if (map.containsKey(key)) {\n            // 元素已存在,修改一下值\n            Bucket cur = map.get(key);\n            cur.put(key, value);\n            // 调用一下 get 实现「使用次数」+ 1\n            get(key); \n        } else {\n            // 容器已满,需要先删除元素\n            if (cnt == n) {\n                // 从第一个桶(编号最小、使用次数最小)中进行清除\n                Bucket cur = head.r;\n                Item clear = cur.clear();\n                map.remove(clear.k);\n                cnt--;\n\n                // 如果在移除掉键值对后,当前桶为空,则将当前桶删除(确保空间是 O(n) 的)\n                // 也确保调用编号最小的桶的 clear 方法,能够有效移除掉一个元素\n                deleteIfEmpty(cur);\n            } \n\n            // 需要将当前键值对增加到 1 号桶\n            Bucket first = null;\n\n            // 如果 1 号桶不存在则创建\n            if (head.r.idx != 1) {\n                first = new Bucket(1);\n                first.r = head.r;\n                first.l = head;\n                head.r.l = first;\n                head.r = first;\n            } else {\n                first = head.r;\n            }\n\n            // 将键值对添加到 1 号桶\n            first.put(key, value);\n            // 更新键值对所在桶信息\n            map.put(key, first);\n            // 计数器加一\n            cnt++;\n        }\n    }\n\n    void deleteIfEmpty(Bucket cur) {\n        if (cur.isEmpty()) {\n            cur.l.r = cur.r;\n            cur.r.l = cur.l;\n            cur = null; // help GC\n        }\n    }\n}\n```\n* 时间复杂度:各操作均为 $O(1)$\n* 时间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.460` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/461-470/461. 汉明距离（简单）.md", "url_title": "461. 汉明距离", "url": "https://leetcode-cn.com/problems/hamming-distance/solution/gong-shui-san-xie-tong-ji-liang-shu-er-j-987a/", "difficulty": "简单", "tags": ["位运算"], "question": "两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。\n\n给出两个整数 x 和 y,计算它们之间的汉明距离。\n\n注意:\n0 ≤ x, y < 231.\n\n示例:\n```\n输入: x = 1, y = 4\n\n输出: 2\n\n解释:\n1   (0 0 0 1)\n4   (0 1 0 0)\n       ↑   ↑\n\n上面的箭头指出了对应二进制位不同的位置。\n```", "solution": "### 逐位比较\n\n本身不改变 $x$ 和 $y$,每次取不同的偏移位进行比较,不同则加一。\n\n循环固定取满 $32$ 。\n\n代码:\n```Java\nclass Solution {\n    public int hammingDistance(int x, int y) {\n        int ans = 0;\n        for (int i = 0; i < 32; i++) {\n            int a = (x >> i) & 1 , b = (y >> i) & 1;\n            ans += a != b ? 1 : 0;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(C)$,$C$ 固定为 $32$\n* 空间复杂度:$O(1)$\n\n---\n\n### 右移统计\n\n每次都统计当前 $x$ 和 $y$ 的最后一位,统计完则将 $x$ 和 $y$ 右移一位。\n\n当 $x$ 和 $y$ 的最高一位 $1$ 都被统计过之后,循环结束。\n\n代码:\n```Java\nclass Solution {\n    public int hammingDistance(int x, int y) {\n        int ans = 0;\n        while ((x | y) != 0) {\n            int a = x & 1, b = y & 1;\n            ans += a ^ b;\n            x >>= 1; y >>= 1;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(C)$,$C$ 最多为 $32$\n* 空间复杂度:$O(1)$\n\n---\n\n### lowbit\n\n熟悉树状数组的同学都知道,`lowbit` 可以快速求得 $x$ 二进制表示中最低位 $1$ 表示的值。\n\n因此我们可以先将 $x$ 和 $y$ 进行异或,再统计异或结果中 $1$ 的个数。\n\n代码:\n```Java\nclass Solution {\n    int lowbit(int x) {\n        return x & -x;\n    }\n    public int hammingDistance(int x, int y) {\n        int ans = 0;\n        for (int i = x ^ y; i > 0; i -= lowbit(i)) ans++;\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(C)$,$C$ 最多为 $32$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.461` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/461-470/462. 最少移动次数使数组元素相等 II（中等）.md", "url_title": "462. 最少移动次数使数组元素相等 II", "url": "https://leetcode.cn/problems/minimum-moves-to-equal-array-elements-ii/solution/by-ac_oier-db44/", "difficulty": "中等", "tags": ["数学"], "question": "给你一个长度为 $n$ 的整数数组 $nums$,返回使所有数组元素相等需要的最少移动数。\n\n在一步操作中,你可以使数组中的一个元素加 $1$ 或者减 $1$ 。\n\n示例 1:\n```\n输入:nums = [1,2,3]\n\n输出:2\n\n解释:\n只需要两步操作(每步操作指南使一个元素加 1 或减 1):\n[1,2,3]  =>  [2,2,3]  =>  [2,2,2]\n```\n示例 2:\n```\n输入:nums = [1,10,2,9]\n\n输出:16\n```\n\n提示:\n* $n == nums.length$\n* $1 <= nums.length <= 10^5$\n* $-10^9 <= nums[i] <= 10^9$", "solution": "### 数学\n\n假定所有的 $nums[i]$ 均位于数轴上的 $nums[i]$ 的位置,题目要求我们在数轴上找出一个点 $t$,使得所有 $nums[i]$ 到 $t$ 的距离之和最小。\n\n**首先,容易证明 $t$ 不可能位于最小的 $nums[i]$ 的左侧,也不可能位于最大的 $nums[i]$ 的右侧,否则我们「至少」能够将目标点调整为 最小的 $nums[i]$ 或 最大的 $nums[i]$ 来得到更小的距离总和。**\n\n> 其实由上述这一点进行推广,已经可以证明最优点必然是在中间点($nums$ 数量为奇数时)或者中间两点形成的闭区间中的任意点($nums$ 数量为偶数时)。\n但为了证明更加直观,我们仍从「反证法」的角度进行证明。\n\n我们根据每个 $nums[i]$ 位于 $t$ 的左侧还是右侧进行划分:假设位于 $t$ 左侧的 $nums[i]$ 对答案的贡献为 $A$,位于 $t$ 右侧的 $nums[i]$ 对答案的贡献为 $B$,最终目的是为了让 $A + B$ 最小。\n\n我们猜想当 $t$ 取中位数时,$A + B$ 取得最小值,并通过「反证法」进行证明:\n\n* 假设真实最优解 $t'$ 位于中位数 $t$ 的 左侧:假设调整距离为 $d$,导致变化的点数为 $x$,则有左边总和为 $A - xd$,右边总和为 $B + (n - x)d$,总和为 $A + B - 2xd + nd$,如果要使得结果更好,需要满足 $nd - 2xd < 0$,即满足 $x > \\frac{n}{2}$,这与我们本身 $t$ 为中位数,即左右两边数的个数均为 $\\frac{n}{2}$ 冲突(特别地,当 $nums$ 为偶数时,且目标点位于中间两点中的任一点时,左右数的个数并非为 $\\frac{n}{2}$,但距离总和情况与 $t$ 位于两点间的其余点的情况一致);\n\n* 假设真实最优解 $t'$ 位于中位数 $t$ 的 右侧:同理。\n\n代码:\n```Java\nclass Solution {\n    public int minMoves2(int[] nums) {\n        Arrays.sort(nums);\n        int n = nums.length, t = nums[(n - 1) / 2], ans = 0;\n        for (int i : nums) ans += Math.abs(t - i);\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.462` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/461-470/464. 我能赢吗（中等）.md", "url_title": "464. 我能赢吗", "url": "https://leetcode.cn/problems/can-i-win/solution/by-ac_oier-0ed9/", "difficulty": "中等", "tags": ["博弈论 DP", "记忆化搜索", "状态压缩"], "question": "在 \"100 game\" 这个游戏中,两名玩家轮流选择从 $1$ 到 $10$ 的任意整数,累计整数和,先使得累计整数和 达到或超过  $100$ 的玩家,即为胜者。\n\n如果我们将游戏规则改为 “玩家 不能 重复使用整数” 呢?\n\n例如,两个玩家可以轮流从公共整数池中抽取从 $1$ 到 $15$ 的整数(不放回),直到累计整数和 >= $100$。\n\n给定两个整数 `maxChoosableInteger` (整数池中可选择的最大数)和 `desiredTotal`(累计和),若先出手的玩家是否能稳赢则返回 `true` ,否则返回 `false` 。假设两位玩家游戏时都表现 最佳 。\n\n示例 1:\n```\n输入:maxChoosableInteger = 10, desiredTotal = 11\n\n输出:false\n\n解释:\n无论第一个玩家选择哪个整数,他都会失败。\n第一个玩家可以选择从 1 到 10 的整数。\n如果第一个玩家选择 1,那么第二个玩家只能选择从 2 到 10 的整数。\n第二个玩家可以通过选择整数 10(那么累积和为 11 >= desiredTotal),从而取得胜利.\n同样地,第一个玩家选择任意其他整数,第二个玩家都会赢。\n```\n示例 2:\n```\n输入:maxChoosableInteger = 10, desiredTotal = 0\n\n输出:true\n```\n示例 3:\n```\n输入:maxChoosableInteger = 10, desiredTotal = 1\n\n输出:true\n```\n\n提示:\n* $1 <= maxChoosableInteger <= 20$\n* $0 <= desiredTotal <= 300$", "solution": "### 二维博弈论 DP(TLE)\n\n这是一道博弈论 DP 的题,为了方便,我们使用 $n$ 来表示 $maxChoosableInteger$,使用 $t$ 来表示 $desiredTotal$。\n\n由于 $n$ 数据范围为 $20$,且每个数只能选一次,我们可以使用一个二进制数 $state$ 来表示 $[1, n]$ 范围内的被选择的数的情况:二进制表示中 $1$ 的位置代表数已被选择,否则代表尚未选择。\n\n首先朴素二维状态表示相对容易想到:**定义 $f[statue][k]$ 为当前已被选择的数为 $state$,轮数为 $k$ 时,「原始回合的先手」能否获胜($1$ 代表能,$-1$ 代表不能),其中 $k$ 从 $0$ 开始,通过 $k$ 的奇偶性可知是原始回合的先手还是后手。**\n\n设计递归函数来实现「记忆化搜索」,函数 `int dfs(int state, int tot, int k)` 表示当前状态为 $state$,$tot$ 对应累计和,$k$ 代表轮数,最终答案通过判断 `dfs(0, 0, 0)` 是否为 $1$ 来得知。\n\n**转移过程中,如果发现当前回合的决策,能够直接使得累积和超过 $t$,说明当前回合玩家获胜;或者如果当前决策能够导致下一回合的玩家失败的话,当前回合玩家也获胜,否则当前玩家失败。**\n\n代码:\n```Java\nclass Solution {\n    int n, t;\n    int[][] f = new int[1 << 20][2];\n    // 1 true / -1 false\n    int dfs(int state, int tot, int k) {\n        if (state == ((1 << n) - 1) && tot < t) return -1;\n        if (f[state][k % 2] != 0) return f[state][k % 2];\n        int hope = k % 2 == 0 ? 1 : -1;\n        for (int i = 0; i < n; i++) {\n            if (((state >> i) & 1) == 1) continue;\n            if (tot + i + 1 >= t) return f[state][k % 2] = hope;\n            if (dfs(state | (1 << i), tot + i + 1, k + 1) == hope) return f[state][k % 2] = hope;\n        }\n        return f[state][k % 2] = -hope;\n    }\n    public boolean canIWin(int _n, int _t) {\n        n = _n; t = _t;\n        if (t == 0) return true;\n        return dfs(0, 0, 0) == 1;\n    }\n}\n```\n* 时间复杂度:共有 $2^{n} \\times 2$ 个状态,每个状态转移需要 $O(n)$ 复杂度,整体复杂度为 $O(2^{n + 1} \\times n)$\n* 空间复杂度:$O(2^{n + 1})$\n\n---\n\n### 优化状态表示\n\n进一步发现,若能优化轮数维度,可以有效减少一半的计算量,我们调整状态定义为:**定义 $f[state]$ 为当前状态为 $state$,「当前先手」能否获胜($1$ 代表能,$-1$ 代表不能)。**\n\n同时调整递归函数为 $int dfs(int state, int tot)$,最终答案通过判断 `dfs(0, 0)` 是否为 $1$ 来得知。\n\n注意这里调整的重点在于:将记录「原始回合的先后手发起 和 原始回合的先后手获胜情况」调整为「当前回合发起 和 当前回合获胜情况」。\n\n代码:\n```Java\nclass Solution {\n    int n, t;\n    int[] f = new int[1 << 20];\n    // 1 true / -1 false\n    int dfs(int state, int tot) {\n        if (f[state] != 0) return f[state];\n        for (int i = 0; i < n; i++) {\n            if (((state >> i) & 1) == 1) continue;\n            if (tot + i + 1 >= t) return f[state] = 1;\n            if (dfs(state | (1 << i), tot + i + 1) == -1) return f[state] = 1;\n        }\n        return f[state] = -1;\n    }\n    public boolean canIWin(int _n, int _t) {\n        n = _n; t = _t;\n        if (n * (n + 1) / 2 < t) return false;\n        if (t == 0) return true;\n        return dfs(0, 0) == 1;\n    }\n}\n```\n* 时间复杂度:共有 $2^{n}$ 个状态,每个状态转移需要 $O(n)$ 复杂度,整体复杂度为 $O(2^{n} \\times n)$\n* 空间复杂度:$O(2^{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.464` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/461-470/467. 环绕字符串中唯一的子字符串（中等）.md", "url_title": "467. 环绕字符串中唯一的子字符串", "url": "https://leetcode.cn/problems/unique-substrings-in-wraparound-string/solution/by-ac_oier-qteu/", "difficulty": "中等", "tags": ["线性 DP", "树状数组"], "question": "把字符串 `s` 看作是 `“abcdefghijklmnopqrstuvwxyz”` 的无限环绕字符串,所以 `s` 看起来是这样的:\n\n`\"...zabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd....\"` . \n\n现在给定另一个字符串 `p` 。返回 `s` 中 唯一 的 `p` 的 非空子串 的数量 。 \n\n示例 1:\n```\n输入: p = \"a\"\n\n输出: 1\n\n解释: 字符串 s 中只有一个\"a\"子字符。\n```\n示例 2:\n```\n输入: p = \"cac\"\n\n输出: 2\n\n解释: 字符串 s 中的字符串“cac”只有两个子串“a”、“c”。.\n```\n示例 3:\n```\n输入: p = \"zab\"\n\n输出: 6\n\n解释: 在字符串 s 中有六个子串“z”、“a”、“b”、“za”、“ab”、“zab”。\n```\n\n提示:\n* $1 <= p.length <= 10^5$\n* `p` 由小写英文字母构成", "solution": "### 线性 DP + 树状数组 + 同字符最大长度计数\n\n> ~~早上起来没睡醒~~ 老了,脑袋不行了,第一反应是用「线性 DP + 树状数组」来做,估了一下时间复杂度没问题就写了。\n该做法有一点点思维难度,因此可能不是这道中等题的标准解法。\n\n**定义 $f[i]$ 为以 $s[i]$ 为结尾的最大有效子串的长度。** \n\n从该状态定义容易得到如下的状态转移方程:\n\n* 存在 $s[i - 1]$ 并且 $s[i]$ 能够接在 $s[i - 1]$ 后面(除了 $s[i]$ 为 $s[i - 1]$ 的下一字母以外,还特别包括 $s[i - 1] = z$ 同时 $s[i] = a$ 的情况),则我们有 $f[i] = f[i - 1] + 1$;\n* 不存在 $s[i - 1]$ 或者 $s[i]$ 不能接在 $s[i - 1]$ 后面,则有 $f[i] = 1$,含义为 $s[i]$ 只能自身组成子串。\n\n**与此同时,我们知道当结尾元素固定,子串长度固定,对应子串唯一确定。**\n\n当不考虑子串重复问题时,若 $f[i] = k$,则以 $s[i]$ 为结尾的有效子串数量为 $k$ 个(对应以 $s[i]$ 为结尾,长度范围为 $[1, k]$ 的子数组)。\n\n但实际上,我们不能统计相同的子串,因此我们需要考虑该如何去重。\n\n不失一般性地,假设我们当前处理到字符串 `p` 中的第 $i$ 位,以 $s[i]$ 为结尾的最大子串长度为 $f[i]$:\n\n* 此前如果 **出现过** 以 $s[i]$ 为结尾,长度「大于等于」$f[i]$ 的子串的话,那么以 $s[i]$ 为结尾长度为 $f[i]$ 的子串必然已被统计,需要跳过。因此我们可以使用一个长度为 $26$ 的数组 `max`,记录以每个字符 $s[i]$ 结尾的,出现过的最大子串长度为多少(当 `max[s[i]] >= f[i]` 时,跳过计数);\n* 此前如果 **出现过** 以 $s[i]$ 为结尾,长度「小于」$f[i]$ 的子串的话,我们也不能直接统计累加 $f[i]$ 到答案上,这会导致那些以 $s[i]$ 为结尾,长度小于 $f[i]$ 的子串被重复计数,此时我们 **需要知道在以 $s[i]$ 为结尾,长度为 $[1, f[i]]$ 范围内还有多少个子串尚未被统计**,这可以使用「树状数组」解决:在 $[1, f[i]]$ 中总个数为 $a = f[i]$,使用树状数组维护在 $[1, f[i]]$ 中已被统计的数的个数 $b$,那么 $cnt = a - b$ 即是本次可增加的计数,计数完成后我们还需要在树状数组中的 $f[i]$ 位置增加 $cnt$,确保下次查询相同字符结尾长度不小于 $f[i]$ 的已覆盖子串数量时不会出错。\n\n至此,我们通过「树状数组」+「记录同字符最大长度」的方式来分别解决「长度比 $f[i]$ 小」和「长度比 $f[i]$ 大」的重复子串统计问题。\n\n代码:\n```Java\nclass Solution {\n    int N = 100010;\n    int[][] trs = new int[26][N];\n    int[] f = new int[N], max = new int[26];\n    int n, ans;\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void add(int[] tr, int x, int v) {\n        for (int i = x; i <= n + 1; i += lowbit(i)) tr[i] += v;\n    }\n    int query(int[] tr, int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];\n        return ans;\n    }\n    public int findSubstringInWraproundString(String _p) {\n        char[] cs = _p.toCharArray();\n        n = cs.length; \n        for (int i = 0; i < n; i++) {\n            int c = cs[i] - 'a';\n            if (i == 0) {\n                f[i] = 1;\n            } else {\n                int p = cs[i - 1] - 'a';\n                if ((c == 0 && p == 25) || p + 1 == c) f[i] = f[i - 1] + 1;\n                else f[i] = 1;\n            }\n            if (max[c] >= f[i]) continue;\n            int cnt = f[i] - query(trs[c], f[i]);\n            if (cnt == 0) continue;\n            ans += cnt;\n            add(trs[c], f[i], cnt);\n            max[c] = f[i];\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(C \\times n)$,其中 $C = 26$ 为字符串 `p` 的字符集大小\n\n---\n\n### 线性 DP\n\n对于相同的结尾字符 $c$ 而言,如果在整个动规过程中的最大长度为 $len$,那么以 $c$ 为结尾字符对答案的贡献为 $len$。\n\n基于此,我们只需保留解法一中的 `max` 数组即可,同时利用 $f[i]$ 只依赖于 $f[i - 1]$ 进行更新,因此动规数组也可以使用一个变量来代替。\n\n代码:\n```Java\nclass Solution {\n    public int findSubstringInWraproundString(String _p) {\n        char[] cs = _p.toCharArray();\n        int n = cs.length, ans = 0;\n        int[] max = new int[26];\n        max[cs[0] - 'a']++;\n        for (int i = 1, j = 1; i < n; i++) {\n            int c = cs[i] - 'a', p = cs[i - 1] - 'a';\n            if ((p == 25 && c == 0) || p + 1 == c) j++;\n            else j = 1;\n            max[c] = Math.max(max[c], j);\n        }\n        for (int i = 0; i < 26; i++) ans += max[i];\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(C)$,其中 $C = 26$ 为字符串 `p` 的字符集大小", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.467` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/461-470/468. 验证IP地址（中等）.md", "url_title": "468. 验证IP地址", "url": "https://leetcode.cn/problems/validate-ip-address/solution/by-ac_oier-s217/", "difficulty": "中等", "tags": ["模拟", "双指针"], "question": "给定一个字符串 `queryIP`。如果是有效的 `IPv4` 地址,返回 `\"IPv4\"` ;如果是有效的 `IPv6` 地址,返回 `\"IPv6\"` ;如果不是上述类型的 `IP` 地址,返回 `\"Neither\"` 。\n\n有效的 `IPv4` 地址 是 `“x1.x2.x3.x4”` 形式的 `IP` 地址。 其中$ 0 <= x_i <= 255$ 且 $x_i$ 不能包含 前导零。\n\n例如: `“192.168.1.1”` 、 `“192.168.1.0”` 为有效 `IPv4` 地址, `“192.168.01.1”` 为无效 `IPv4` 地址; `“192.168.1.00”` 、 `“192.168@1.1”` 为无效 `IPv4` 地址。\n\n一个有效的 `IPv6` 地址 是一个格式为 `“x1:x2:x3:x4:x5:x6:x7:x8”` 的 `IP` 地址,其中:\n\n* $1 <= x_i.length <= 4$\n* $x_i$ 是一个 十六进制字符串 ,可以包含数字、小写英文字母( `'a'` 到 `'f'` )和大写英文字母( `'A'` 到 `'F'` )。\n* 在 $x_i$ 中允许前导零。\n\n例如 `\"2001:0db8:85a3:0000:0000:8a2e:0370:7334\"` 和 `\"2001:db8:85a3:0:0:8A2E:0370:7334\"` 是有效的 `IPv6` 地址,而 `\"2001:0db8:85a3::8A2E:037j:7334\"` 和 `\"02001:0db8:85a3:0000:0000:8a2e:0370:7334\"` 是无效的 `IPv6` 地址。\n\n示例 1:\n```\n输入:queryIP = \"172.16.254.1\"\n\n输出:\"IPv4\"\n\n解释:有效的 IPv4 地址,返回 \"IPv4\"\n```\n示例 2:\n```\n输入:queryIP = \"2001:0db8:85a3:0:0:8A2E:0370:7334\"\n\n输出:\"IPv6\"\n\n解释:有效的 IPv6 地址,返回 \"IPv6\"\n```\n示例 3:\n```\n输入:queryIP = \"256.256.256.256\"\n\n输出:\"Neither\"\n\n解释:既不是 IPv4 地址,又不是 IPv6 地址\n```\n\n提示:\n* `queryIP` 仅由英文字母,数字,字符 `'.'` 和 `':'` 组成。", "solution": "### 模拟\n\n为了方便,我们称合法 `IPv4`/`IPv6` 中由 `.`/`:` 分割的部分称为 `item`。\n\n无论是 `IPv4` 还是 `IPv6`,我们都只需将连续段的 `item` 取出,并结合题意判断即可,一个较为简单的方式使用 `split` 操作来得到所有的 `item`,考虑到某些语言并不内置 `split`,这里采取双指针的方式来做。\n\n为方便大家理解,今天将题解文字说明写到注释中。\n\n代码:\n```Java\nclass Solution {\n    public String validIPAddress(String ip) {\n        if (ip.indexOf(\".\") >= 0 && check4(ip)) return \"IPv4\";\n        if (ip.indexOf(\":\") >= 0 && check6(ip)) return \"IPv6\";\n        return \"Neither\";\n    }\n    boolean check4(String ip) {\n        int n = ip.length(), cnt = 0;\n        char[] cs = ip.toCharArray();\n        for (int i = 0; i < n && cnt <= 3; ) {\n            // 找到连续数字段,以 x 存取\n            int j = i, x = 0;\n            while (j < n && cs[j] >= '0' && cs[j] <= '9' && x <= 255) x = x * 10 + (cs[j++] - '0');\n            // 非 item 字符之间没有 item\n            if (i == j) return false;\n            // 含前导零 或 数值大于 255\n            if ((j - i > 1 && cs[i] == '0') || (x > 255)) return false;\n            i = j + 1;\n            if (j == n) continue;\n            // 存在除 . 以外的其他非数字字符\n            if (cs[j] != '.') return false;\n            cnt++;\n        }\n        // 恰好存在 3 个不位于两端的 .\n        return cnt == 3 && cs[0] != '.' && cs[n - 1] != '.';\n    }\n    boolean check6(String ip) {\n        int n = ip.length(), cnt = 0;\n        char[] cs = ip.toCharArray();\n        for (int i = 0; i < n && cnt <= 7; ) {\n            int j = i;\n            while (j < n && ((cs[j] >= 'a' && cs[j] <= 'f') || (cs[j] >= 'A' && cs[j] <= 'F') || (cs[j] >= '0' && cs[j] <= '9'))) j++;\n            // 非 item 字符之间没有 item 或 长度超过 4\n            if (i == j || j - i > 4) return false;\n            i = j + 1;\n            if (j == n) continue;\n            // 存在除 : 以外的其他非数字字符\n            if (cs[j] != ':') return false;\n            cnt++;\n        }\n        // 恰好存在 7 个不位于两段的 :\n        return cnt == 7 && cs[0] != ':' && cs[n - 1] != ':';\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:使用 `toCharArray` 操作会产生新数组,复杂度为 $O(n)$,使用 `charAt` 操作代替复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.468` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/461-470/470. 用 Rand7() 实现 Rand10()（中等）.md", "url_title": "470. 用 Rand7() 实现 Rand10()", "url": "https://leetcode-cn.com/problems/implement-rand10-using-rand7/solution/gong-shui-san-xie-k-jin-zhi-zhu-wei-shen-zmd4/", "difficulty": "中等", "tags": ["位运算", "数学"], "question": "已有方法 rand7 可生成 1 到 7 范围内的均匀随机整数,试写一个方法 rand10 生成 1 到 10 范围内的均匀随机整数。\n\n不要使用系统的 Math.random() 方法。\n\n示例 1:\n```\n输入: 1\n\n输出: [7]\n```\n示例 2:\n```\n输入: 2\n\n输出: [8,4]\n```\n示例 3:\n```\n输入: 3\n\n输出: [8,1,10]\n```\n\n提示:\n1. rand7 已定义。\n2. 传入参数: n 表示 rand10 的调用次数。\n\n进阶:\n* rand7()调用次数的 期望值 是多少 ?\n* 你能否尽量少调用 rand7() ?", "solution": "### 基本分析\n\n给定一个随机生成 $1$ ~ $7$ 的函数,要求实现等概率返回 $1$ ~ $10$ 的函数。\n\n首先需要知道,在输出域上进行定量整体偏移,仍然满足等概率,即要实现 $0$ ~ $6$ 随机器,只需要在 `rand7` 的返回值上进行 $-1$ 操作即可。\n\n但输出域的 拼接/叠加 并不满足等概率。例如 `rand7() + rand7()` 会产生 $[2, 14]$ 范围内的数,但每个数并非等概率:\n\n* 产生 $2$ 的概率为:$\\frac{1}{7} * \\frac{1}{7} = \\frac{1}{49}$\n* 产生 $4$ 的概率为:$\\frac{1}{7} * \\frac{1}{7} + \\frac{1}{7} * \\frac{1}{7} + \\frac{1}{7} * \\frac{1}{7} = \\frac{3}{49}$\n\n在 $[2, 14]$ 这 $13$ 个数里面,等概率的数值不足 $10$ 个。\n\n**因此,你应该知道「执行两次 `rand7()` 相加,将 $[1, 10]$ 范围内的数进行返回,否则一直重试」的做法是错误的。**\n\n---\n\n### $k$ 进制诸位生成 + 拒绝采样\n\n上述做法出现概率分布不均的情况,是因为两次随机值的不同组合「相加」的会出现相同的结果($(1, 3)$、$(2, 2)$、$(3, 1)$ 最终结果均为 $4$)。\n\n结合每次执行 `rand7` 都可以看作一次独立事件。我们可以将两次 `rand7` 的结果看作生成 $7$ 进制的两位。**从而实现每个数值都唯一对应了一种随机值的组合(等概率),反之亦然。**\n\n举个🌰,设随机执行两次 `rand7` 得到的结果分别是 $4$(第一次)、$7$(第二次),由于我们是要 $7$ 进制的数,因此可以先对 `rand7` 的执行结果进行 $-1$ 操作,将输出域偏移到 $[0, 6]$(仍为等概率),即得到 $3$(第一次)和 $6$(第二次),最终得到的是数值 $(63)_7$,数值 $(63)_7$ 唯一对应了我们的随机值组合方案,反过来随机值组合方案也唯一对应一个 $7$ 进制的数值。\n\n**那么根据「进制转换」的相关知识,如果我们存在一个 `randK` 的函数,对其执行 $n$ 次,我们能够等概率产生 $[0, K^n - 1]$ 范围内的数值。**\n\n回到本题,执行一次 `rand7` 只能产生 $[0, 6]$ 范围内的数值,不足 $10$ 个;而执行 $2$ 次 `rand7` 的话则能产生 $[0, 48]$ 范围内的数值,足够 $10$ 个,且等概率。\n\n我们只需要判定生成的值是否为题意的 $[1, 10]$ 即可,如果是的话直接返回,否则一直重试。\n\n代码:\n\n```Java\nclass Solution extends SolBase {\n    public int rand10() {\n        while (true) {\n            int ans = (rand7() - 1) * 7 + (rand7() - 1); // 进制转换\n            if (1 <= ans && ans <= 10) return ans;\n        }\n    }\n}\n```\n* 时间复杂度:期望复杂度为 $O(1)$,最坏情况下为 $O(\\infty)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 进阶\n\n1. 降低对 `rand7` 的调用次数\n\n我们发现,在上述解法中,范围 $[0, 48]$ 中,只有 $[1, 10]$ 范围内的数据会被接受返回,其余情况均被拒绝重试。\n\n为了尽可能少的调用 `rand7` 方法,我们可以从 $[0, 48]$ 中取与 $[1, 10]$ 成倍数关系的数,来进行转换。\n\n我们可以取 $[0, 48]$ 中的 $[1, 40]$ 范围内的数来代指 $[1, 10]$。\n\n首先在 $[0, 48]$ 中取 $[1, 40]$ 仍为等概率,其次形如 $x1$ 的数值有 $4$ 个($1$、$11$、$21$、$31$),形如 $x2$ 的数值有 $4$ 个($2$、$12$、$22$、$32$)... 因此最终结果仍为等概率。\n\n代码:\n```Java\nclass Solution extends SolBase {\n    public int rand10() {\n        while (true) {\n            int ans = (rand7() - 1) * 7 + (rand7() - 1); // 进制转换\n            if (1 <= ans && ans <= 40) return ans % 10 + 1;\n        }\n    }\n}\n```\n* 时间复杂度:期望复杂度为 $O(1)$,最坏情况下为 $O(\\infty)$\n* 空间复杂度:$O(1)$\n\n2.  计算 `rand7` 的期望调用次数\n\n在 $[0, 48]$ 中我们采纳了 $[1, 40]$ 范围内的数值,即以调用两次为基本单位的话,有 $\\frac{40}{49}$ 的概率被接受返回(成功)。\n\n成功的概率为 $\\frac{40}{49}$,那么需要触发成功所需次数(期望次数)为其倒数 $\\frac{49}{40} = 1.225$,每次会调用两次 `rand7`,因而总的期望调用次数为 $1.225 * 2 = 2.45$ 。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.470` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/471-480/472. 连接词（困难）.md", "url_title": "472. 连接词", "url": "https://leetcode-cn.com/problems/concatenated-words/solution/gong-shui-san-xie-xu-lie-dpzi-fu-chuan-h-p7no/", "difficulty": "困难", "tags": ["字符串哈希", "序列 DP"], "question": "给你一个 不含重复 单词的字符串数组 `words` ,请你找出并返回 `words` 中的所有 连接词 。\n\n连接词 定义为:一个完全由给定数组中的至少两个较短单词组成的字符串。\n\n示例 1:\n```\n输入:words = [\"cat\",\"cats\",\"catsdogcats\",\"dog\",\"dogcatsdog\",\"hippopotamuses\",\"rat\",\"ratcatdogcat\"]\n\n输出:[\"catsdogcats\",\"dogcatsdog\",\"ratcatdogcat\"]\n\n解释:\"catsdogcats\" 由 \"cats\", \"dog\" 和 \"cats\" 组成; \n     \"dogcatsdog\" 由 \"dog\", \"cats\" 和 \"dog\" 组成; \n     \"ratcatdogcat\" 由 \"rat\", \"cat\", \"dog\" 和 \"cat\" 组成。\n```\n示例 2:\n```\n输入:words = [\"cat\",\"dog\",\"catdog\"]\n\n输出:[\"catdog\"]\n```\n\n提示:\n* $1 <= words.length <= 10^4$\n* $0 <= words[i].length <= 1000$\n* $words[i]$ 仅由小写字母组成\n* $0 <= sum(words[i].length) <= 10^5$", "solution": "### 序列 DP + 字符串哈希\n\n给定数组 $words$,先考虑如何判断某个 $s = words[i]$ 是否为「连接词」。\n\n为了方便,我们称组成 `s` 的每个连接部分为 `item`。\n\n举个 🌰,例如 `s = abc`,其可能的 `item` 组合为 `a` 和 `bc`。\n\n判断单个字符串是否为连接词可使用动态规划求解:**定义 $f[i]$ 为考虑 `s` 的前 $i$ 个字符(令下标从 $1$ 开始),能够切分出的最大 `item` 数的个数。**\n\n这里之所以采用「记录 $f[i]$ 为最大分割 `item` 数(`int` 类型动规数组)」,而不是「记录 $f[i]$ 为是否可由多个 `item` 组成(`bool` 类型动规数组)」,是因为每个 $s = words[i]$ 至少可由自身组成,采用 `bool` 记录状态的话,最终 $f[n]$ 必然为 `True`,需要额外处理最后一个状态,干脆记录最大分割数量好了。此时如果 `s` 为「连接词」必然有 $f[n] > 1$。\n\n不失一般性的考虑 $f[i]$ 该如何转移:**假设 $f[i]$ 可由 $f[j]$ 转移而来(其中 $j < i$),那么能够转移的充要条件为 $f[j] != 0$ 且子串 $s[(j + 1)..i]$ 在 $words$ 出现过**。\n\n其中枚举 $i$ 和 $j$ 的复杂度已经去到 $O(n^2)$ 了,如果常规通过 `HashMap` 等数据结构判断某个字符串是否存在,执行哈希函数时需要对字符进行遍历,整体复杂度去到了 $O(n^3)$,会 `TLE`。\n\n**我们通过「字符串哈希」方式来优化判断某个子串是否存在于 $words$ 中。**\n\n具体的,在判断每个 $s = words[i]$ 是否为为连接词前,先对 $words$ 进行遍历,预处理每个 $words[i]$ 的哈希值,并存入 `HashSet` 中,这样我们将「判断某个子串是否存在于 $words$」的问题转化为「判断某个数值是否存在于 `Set` 当中」。\n\n又由于 **我们在计算某个子串 `s` 的哈希值时,是从前往后处理每一位的 $s[i]$,因此在转移 $f[i]$ 时,我们期望能够从前往后处理子串,这是常规的从 $[0, i - 1]$ 范围内找可转移点 $f[j]$ 无法做到的**。\n\n所以 **我们调整转移逻辑为:从 $f[i]$ 出发,枚举范围 $[i + 1, n]$,找到可由 $f[i]$ 所能更新的状态 $f[j]$,并尝试使用 $f[i]$ 来更新 $f[j]$。转移方程为:**\n\n$$\nf[j] = \\max(f[j], f[i] + 1)\n$$\n\n当然,能够转移的前提条件为 $f[i]$ 为有效值,且子串 $s[(i + 1), j]$ 在 $words$ 出现过。\n\n> 一些细节:为了方便,我们定义 $f[i] = -1$ 为无效状态;\n另外由于字符串哈希会产生哈希碰撞,这里在计算哈希值的时候,修改了一下哈希计算方式(额外增加了一个 `OFFSET`),当时的目的是想在电脑没电前 `AC`,而另一个更加稳妥的方式是使用双哈希,或是干脆记录某个哈希值对应了哪些字符串。\n\n代码:\n```Java\nclass Solution {\n    Set<Long> set = new HashSet<>();\n    int P = 131, OFFSET = 128;\n    public List<String> findAllConcatenatedWordsInADict(String[] words) {\n        for (String s : words) {\n            long hash = 0;\n            for (char c : s.toCharArray()) hash = hash * P + (c - 'a') + OFFSET;\n            set.add(hash);\n        }\n        List<String> ans = new ArrayList<>();\n        for (String s : words) {\n            if (check(s)) ans.add(s);\n        }\n        return ans;\n    }\n    boolean check(String s) {\n        int n = s.length();\n        int[] f = new int[n + 1];\n        Arrays.fill(f, -1);\n        f[0] = 0;\n        for (int i = 0; i <= n; i++) {\n            if (f[i] == -1) continue;\n            long cur = 0;\n            for (int j = i + 1; j <= n; j++) {\n                cur = cur * P + (s.charAt(j - 1) - 'a') + OFFSET;\n                if (set.contains(cur)) f[j] = Math.max(f[j], f[i] + 1);\n            }\n            if (f[n] > 1) return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为 $words$ 数组长度,$N = \\sum_{i = 0}^{n - 1}words[i].length$,根据数据范围 $N$ 最大为 $1e5$。预处理出 `Set` 的复杂度为 $O(N)$;会对所有 $words[i]$ 执行 `check` 操作,复杂度为 $O((words[i].length)^2)$,总的计算量最大值为 $O(N^2)$,由于存在剪枝,实际上达不到该计算量\n* 空间复杂度:$O(n + \\max(words[i].length))$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.472` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/471-480/473. 火柴拼正方形（中等）.md", "url_title": "473. 火柴拼正方形", "url": "https://leetcode.cn/problems/matchsticks-to-square/solution/by-ac_oier-k8i7/", "difficulty": "中等", "tags": ["剪枝", "DFS", "爆搜", "模拟退火", "启发式搜索", "随机化"], "question": "你将得到一个整数数组 `matchsticks`,其中 $matchsticks[i]$ 是第 `i` 个火柴棒的长度。你要用 所有的火柴棍 拼成一个正方形。\n\n你 不能折断 任何一根火柴棒,但你可以把它们连在一起,而且每根火柴棒必须 使用一次 。\n\n如果你能使这个正方形,则返回 `true`,否则返回 `false`。\n\n示例 1:\n\n```\n输入: matchsticks = [1,1,2,2,2]\n\n输出: true\n\n解释: 能拼成一个边长为2的正方形,每边两根火柴。\n```\n示例 2:\n```\n输入: matchsticks = [3,3,3,3,4]\n\n输出: false\n\n解释: 不能用所有火柴拼成一个正方形。\n```\n\n提示:\n* $1 <= matchsticks.length <= 15$\n* $1 <= matchsticks[i] <= 10^8$", "solution": "> 祝大家儿童节快乐,永葆童心,一直善良 😊 ~ \n\n### DFS 剪枝\n\n为了方便,我们称 `matchsticks` 为 `ms`。\n\n数据范围为 $n = 15$,朴素的 `DFS` 爆搜(搜索过程中维护一个大小为 $4$ 的数组 `cur`,数组中的每一位代表正方形一条边长所使用到的火柴总长度,若最终数组中每一位均等于 $t = \\frac{\\sum_{i = 0}^{n - 1}ms[i]}{4}$,代表存在合法方案)复杂度为 $4^n$,会 `TLE`。\n\n我们考虑如何进行「剪枝」。\n\n首先一个较为明显的剪枝操作是进行「可行性剪枝」:我们在决策 $ms[idx]$ 时,如果将其累加到某个 $cur[i]$ 之后,会导致 $cur[i] > t$,则说明必然不会是合法方案,该分支不再往后搜索。\n\n另外一个较为 trick 的剪枝是通过「调整搜索顺序/检查当前桶的总长度」来进行「重复性剪枝」:我们可以先对 `ms` 排倒序,进行「从大到小」的爆搜。本质上,我们是将一些小火柴重复放到某几个桶的搜索路径(其实对应的是相同的分配方案),放到了最后处理;同时,当我们要放置 $ms[idx]$ 的火柴时,如果存在多个桶总长度相等,例如 $cur[i] = cur[j]$,将 $ms[idx]$ 放置在 $cur[i]$ 或 $cur[j]$ 也是等价的。\n\n代码:\n```Java\nclass Solution {\n    int[] ms;\n    int t;\n    public boolean makesquare(int[] _ms) {\n        ms = _ms;\n        int sum = 0;\n        for (int i : ms) sum += i;\n        t = sum / 4;\n        if (t * 4 != sum) return false;\n        Arrays.sort(ms);\n        return dfs(ms.length - 1, new int[4]);\n    }\n    boolean dfs(int idx, int[] cur) {\n        if (idx == -1) return true;\n        out:for (int i = 0; i < 4; i++) {\n            for (int j = 0; j < i; j++) {\n                if (cur[j] == cur[i]) continue out;\n            }\n            int u = ms[idx];\n            if (cur[i] + u > t) continue;\n            cur[i] += u;\n            if (dfs(idx - 1, cur)) return true;\n            cur[i] -= u;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(4^n)$\n* 空间复杂度:排序的复杂度为 $O(\\log{n})$,忽略递归带来的额外空间开销,复杂度为 $O(\\log{n})$\n\n---\n\n### 模拟退火\n\n事实上,这道题还能使用「模拟退火」进行求解。\n\n**因为将 $n$ 个数划分为 $4$ 份,等效于用 $n$ 个数构造出一个「特定排列」,然后对「特定排列」进行固定模式的构造逻辑,就能实现「答案」与「最优排列」的对应关系。**\n\n基于此,我们可以使用「模拟退火」进行求解。\n\n单次迭代的基本流程:\n\n1. 随机选择两个下标,计算「交换下标元素前对应序列的得分」&「交换下标元素后对应序列的得分」\n2. 如果温度下降(交换后的序列更优),进入下一次迭代\n3. 如果温度上升(交换前的序列更优),以「一定的概率」恢复现场(再交换回来)\n\n值得一提的是,这道题造数据的人十分有水平,在最后一个样例中放了个卡 `SA` 的数据:\n```\n[403,636,824,973,815,318,881,506,863,21,834,211,316,772,803]\n```\n\n但我不知道为什么 LC 的提交结果会这么奇怪,已通过 `184/183` 样例?是总样例数哪个地方更新漏了,还是缓存没刷新:\n\n这个数据点优秀在于起始排序可以导致我们固定的 `calc` 逻辑最终落入局部最优。针对这种情况,也很好解决,只需要在执行 `SA`  之前,先对原数组进行一次随机化打乱即可。\n\n代码(`2022/06/01` 可通过):\n```Java\nclass Solution {\n    int[] ms;\n    int n, k;\n    Random random = new Random(20220601);\n    double hi = 1e9, lo = 1e-4, fa = 0.95;\n    int N = 400;\n    boolean ans = false;\n    int calc() {\n        int diff = 0;\n        for (int i = 0, j = 0; i < 4; i++) {\n            int cnt = 0;\n            while (j < n && cnt < k) cnt += ms[j++];\n            diff += Math.abs(k - cnt);\n        }\n        if (diff == 0) ans = true;\n        return diff;\n    }\n    void sa() {\n        shuffle(ms);\n        for (double t = hi; t > lo && !ans; t *= fa) {\n            int a = random.nextInt(n), b = random.nextInt(n);\n            if (a == b) continue;\n            int prev = calc();\n            swap(ms, a, b);\n            int cur = calc();\n            int diff = cur - prev;\n            if (Math.log(diff / t) > random.nextDouble()) swap(ms, a, b);\n        }\n    }\n    public boolean makesquare(int[] _ms) {\n        ms = _ms;\n        n = ms.length;\n        int sum = 0;\n        for (int i : ms) sum += i;\n        k = sum / 4;\n        if (k * 4 != sum) return false;\n        while (!ans && N-- > 0) sa();\n        return ans;\n    }\n    void shuffle(int[] nums) {\n        for (int i = n; i > 0; i--) {\n            int idx = random.nextInt(i);\n            swap(nums, idx, i - 1);\n        }\n    }\n    void swap(int[] nums, int a, int b) {\n        int c = nums[a];\n        nums[a] = nums[b];\n        nums[b] = c;\n    }\n}\n```\n\n---\n\n### 我猜你问\n\n**Q0. 模拟退火有何风险?**\n随机算法,会面临 `WA` 和 `TLE` 风险。\n\n**Q1. 模拟退火中的参数如何敲定的?**\n根据经验猜的,然后提交。根据结果是 `WA` 还是 `TLE` 来决定之后的调参方向。如果是 `WA` 说明部分数据落到了「局部最优」或者尚未达到「全局最优」。\n\n**Q2. 参数如何调整?**\n如果是 `WA` 了,一般我是优先调大 fa 参数,使降温变慢,来变相增加迭代次数;如果是 `TLE` 了,一般是优先调小 fa 参数,使降温变快,减小迭代次数。总迭代参数 `N` 也是同理。\n\n可以简单理解调大 fa 代表将「大步」改为「baby step」,防止越过全局最优,同时增加总执行步数。\n\n**Q3. 关于「模拟退火」正确性?**\n\n随机种子不变,测试数据不变,迭代参数不变,那么退火的过程就是恒定的,必然都能找到这些测试样例的「全局最优」。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.472` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/471-480/474. 一和零（中等）.md", "url_title": "474. 一和零", "url": "https://leetcode-cn.com/problems/ones-and-zeroes/solution/gong-shui-san-xie-xiang-jie-ru-he-zhuan-174wv/", "difficulty": "中等", "tags": ["01 背包", "背包问题", "多维背包", "动态规划"], "question": "给你一个二进制字符串数组 strs 和两个整数 m 和 n 。\n\n请你找出并返回 strs 的最大子集的大小,该子集中 最多 有 m 个 0 和 n 个 1 。\n\n如果 x 的所有元素也是 y 的元素,集合 x 是集合 y 的 子集 。\n\n示例 1:\n```\n输入:strs = [\"10\", \"0001\", \"111001\", \"1\", \"0\"], m = 5, n = 3\n输出:4\n解释:最多有 5 个 0 和 3 个 1 的最大子集是 {\"10\",\"0001\",\"1\",\"0\"} ,因此答案是 4 。\n其他满足题意但较小的子集包括 {\"0001\",\"1\"} 和 {\"10\",\"1\",\"0\"} 。{\"111001\"} 不满足题意,因为它含 4 个 1 ,大于 n 的值 3 。\n```\n示例 2:\n```\n输入:strs = [\"10\", \"0\", \"1\"], m = 1, n = 1\n输出:2\n解释:最大的子集是 {\"0\", \"1\"} ,所以答案是 2 。\n```\n\n提示:\n* 1 <= strs.length <= 600\n* 1 <= strs[i].length <= 100\n* strs[i] 仅由 '0' 和 '1' 组成\n* 1 <= m, n <= 100", "solution": "### (多维)01 背包\n\n通常与「背包问题」相关的题考察的是 **将原问题转换为「背包问题」的能力**。\n\n要将原问题转换为「背包问题」,往往需要从题目中抽象出「价值」与「成本」的概念。\n\n这道题如果抽象成「背包问题」的话,应该是:\n\n**每个字符串的价值都是 1(对答案的贡献都是 1),选择的成本是该字符串中 1 的数量和 0 的数量。**\n\n问我们在 1 的数量不超过 $m$,0 的数量不超过 $n$ 的条件下,最大价值是多少。\n\n由于每个字符串只能被选一次,且每个字符串的选与否对应了「价值」和「成本」,求解的问题也是「最大价值」是多少。\n\n因此可以直接套用 01 背包的「状态定义」来做:\n\n**$f[k][i][j]$ 代表考虑前 k 件物品,在数字 1 容量不超过 $i$,数字 0 容量不超过 $j$ 的条件下的「最大价值」(每个字符串的价值均为 1)。**\n\n有了「状态定义」之后,「转移方程」也很好推导:\n\n$$f[k][i][j] = \\max(f[k - 1][i][j], f[k - 1][i - cnt[k][0]][j - cnt[k][1]] + 1)$$\n\n其中 $cnt$ 数组记录的是字符串中出现的 $01$ 数量。\n\n代码(为了方便理解,$P1$ 将第一件物品的处理单独抽了出来,也可以不抽出来,只需要将让物品下标从 $1$ 开始即可,见 $P2$):\n```Java\nclass Solution {\n    public int findMaxForm(String[] strs, int m, int n) {\n        int len = strs.length;\n        // 预处理每一个字符包含 0 和 1 的数量\n        int[][] cnt = new int[len][2];\n        for (int i = 0; i < len; i++) {\n            String str = strs[i];\n            int zero = 0, one = 0;\n            for (char c : str.toCharArray()) {\n                if (c == '0') {\n                    zero++;\n                } else {\n                    one++;\n                }\n            }\n            cnt[i] = new int[]{zero, one}; \n        }\n\n        // 处理只考虑第一件物品的情况\n        int[][][] f = new int[len][m + 1][n + 1];\n        for (int i = 0; i <= m; i++) {\n            for (int j = 0; j <= n; j++) {\n                f[0][i][j] = (i >= cnt[0][0] && j >= cnt[0][1]) ? 1 : 0;\n            }\n        }\n\n        // 处理考虑其余物品的情况\n        for (int k = 1; k < len; k++) {\n            int zero = cnt[k][0], one = cnt[k][1];\n            for (int i = 0; i <= m; i++) {\n                for (int j = 0; j <= n; j++) {\n                    // 不选择第 k 件物品\n                    int a = f[k-1][i][j];\n                    // 选择第 k 件物品(前提是有足够的 m 和 n 额度可使用)\n                    int b = (i >= zero && j >= one) ? f[k-1][i-zero][j-one] + 1 : 0;\n                    f[k][i][j] = Math.max(a, b);\n                }\n            }\n        }\n        return f[len-1][m][n];\n    }\n}\n```\n```Java\nclass Solution {\n    public int findMaxForm(String[] strs, int m, int n) {\n        int len = strs.length;\n        int[][] cnt = new int[len][2];\n        for (int i = 0; i < len; i++) {\n            String str = strs[i];\n            int zero = 0, one = 0;\n            for (char c : str.toCharArray()) {\n                if (c == '0') zero++;    \n                else one++;\n\n            }\n            cnt[i] = new int[]{zero, one}; \n        }\n        int[][][] f = new int[len + 1][m + 1][n + 1];\n        for (int k = 1; k <= len; k++) {\n            int zero = cnt[k - 1][0], one = cnt[k - 1][1];\n            for (int i = 0; i <= m; i++) {\n                for (int j = 0; j <= n; j++) {\n                    int a = f[k - 1][i][j];\n                    int b = (i >= zero && j >= one) ? f[k - 1][i - zero][j - one] + 1 : 0;\n                    f[k][i][j] = Math.max(a, b);\n                }\n            }\n        }\n        return f[len][m][n];\n    }\n}\n```\n* 时间复杂度:预处理字符串的复杂度为 $O(\\sum_{i = 0}^{k - 1}len(strs[i]))$,处理状态转移的 $O(k * m * n)$。整体复杂度为:$O(k * m * n + \\sum_{i = 0}^{k - 1}len(strs[i]))$\n* 空间复杂度:$O(k * m * n)$\n\n---\n\n### 滚动数组\n\n根据「状态转移」可知,更新某个物品的状态时,只依赖于上一个物品的状态。\n\n因此,可以使用「滚动数组」的方式进行空间优化。\n\n代码(为了方便理解,$P1$ 将第一件物品的处理单独抽了出来,也可以不抽出来,只需要将让物品下标从 $1$ 开始即可,见 $P2$):\n```Java\nclass Solution {\n    public int findMaxForm(String[] strs, int m, int n) {\n        int len = strs.length;\n        // 预处理每一个字符包含 0 和 1 的数量\n        int[][] cnt = new int[len][2];\n        for (int i = 0; i < len; i++) {\n            String str = strs[i];\n            int zero = 0, one = 0;\n            for (char c : str.toCharArray()) {\n                if (c == '0') {\n                    zero++;\n                } else {\n                    one++;\n                }\n            }\n            cnt[i] = new int[]{zero, one}; \n        }\n\n        // 处理只考虑第一件物品的情况\n        // 「物品维度」修改为 2 \n        int[][][] f = new int[2][m + 1][n + 1];\n        for (int i = 0; i <= m; i++) {\n            for (int j = 0; j <= n; j++) {\n                f[0][i][j] = (i >= cnt[0][0] && j >= cnt[0][1]) ? 1 : 0;\n            }\n        }\n\n        // 处理考虑其余物品的情况\n        for (int k = 1; k < len; k++) {\n            int zero = cnt[k][0], one = cnt[k][1];\n            for (int i = 0; i <= m; i++) {\n                for (int j = 0; j <= n; j++) {\n                    // 不选择第 k 件物品\n                    // 将 k-1 修改为 (k-1)&1\n                    int a = f[(k-1)&1][i][j];\n                    // 选择第 k 件物品(前提是有足够的 m 和 n 额度可使用)\n                    // 将 k-1 修改为 (k-1)&1\n                    int b = (i >= zero && j >= one) ? f[(k-1)&1][i-zero][j-one] + 1 : 0;\n                    f[k&1][i][j] = Math.max(a, b);\n                }\n            }\n        }\n        // 将 len-1 修改为 (len-1)&1\n        return f[(len-1)&1][m][n];\n    }\n}\n```\n```Java\nclass Solution {\n    public int findMaxForm(String[] strs, int m, int n) {\n        int len = strs.length;\n        int[][] cnt = new int[len][2];\n        for (int i = 0; i < len; i++) {\n            String str = strs[i];\n            int zero = 0, one = 0;\n            for (char c : str.toCharArray()) {\n                if (c == '0') zero++;\n                else one++; \n            }\n            cnt[i] = new int[]{zero, one}; \n        }\n        int[][][] f = new int[2][m + 1][n + 1];\n        for (int k = 1; k <= len; k++) {\n            int zero = cnt[k - 1][0], one = cnt[k - 1][1];\n            for (int i = 0; i <= m; i++) {\n                for (int j = 0; j <= n; j++) {\n                    int a = f[(k-1) & 1][i][j];\n                    int b = (i >= zero && j >= one) ? f[(k-1) & 1][i - zero][j - one] + 1 : 0;\n                    f[k&1][i][j] = Math.max(a, b);\n                }\n            }\n        }\n        return f[len&1][m][n];\n    }\n}\n```\n* 时间复杂度:预处理字符串的复杂度为 $O(\\sum_{i = 0}^{k - 1}len(strs[i]))$,处理状态转移的 $O(k * m * n)$。整体复杂度为:$O(k * m * n + \\sum_{i = 0}^{k - 1}len(strs[i]))$\n* 空间复杂度:$O(m * n)$\n\n---\n\n### 一维空间优化\n\n事实上,我们还能继续进行空间优化。\n\n再次观察我们的「状态转移方程」发现:**$f[k][i][j]$ 不仅仅依赖于上一行,还明确依赖于比 $i$ 小和比 $j$ 小的状态。**\n\n即可只依赖于「上一行」中「正上方」的格子,和「正上方左边」的格子。\n\n对应到「朴素的 01 背包问题」依赖关系如图:\n\n因此可直接参考「01 背包的空间优化」方式:取消掉「物品维度」,然后调整容量的遍历顺序。\n\n代码:\n```Java\nclass Solution {\n    public int findMaxForm(String[] strs, int m, int n) {\n        int len = strs.length;\n        int[][] cnt = new int[len][2];\n        for (int i = 0; i < len; i++) {\n            int zero = 0, one = 0;\n            for (char c : strs[i].toCharArray()) {\n                if (c == '0') zero++;\n                else one++;\n            }\n            cnt[i] = new int[]{zero, one};\n        }\n        int[][] f = new int[m + 1][n + 1];\n        for (int k = 0; k < len; k++) {\n            int zero = cnt[k][0], one = cnt[k][1];\n            for (int i = m; i >= zero; i--) {\n                for (int j = n; j >= one; j--) {\n                    f[i][j] = Math.max(f[i][j], f[i - zero][j - one] + 1);\n                }\n            }\n        }\n        return f[m][n];\n    }\n}\n```\n* 时间复杂度:预处理字符串的复杂度为 $O(\\sum_{i = 0}^{k - 1}len(strs[i]))$,处理状态转移的 $O(k * m * n)$。整体复杂度为:$O(k * m * n + \\sum_{i = 0}^{k - 1}len(strs[i]))$\n* 空间复杂度:$O(m * n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.474` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/471-480/475. 供暖器（中等）.md", "url_title": "475. 供暖器", "url": "https://leetcode-cn.com/problems/heaters/solution/gong-shui-san-xie-er-fen-shuang-zhi-zhen-mys4/", "difficulty": "中等", "tags": ["排序", "二分", "双指针"], "question": "冬季已经来临。 你的任务是设计一个有固定加热半径的供暖器向所有房屋供暖。\n\n在加热器的加热半径范围内的每个房屋都可以获得供暖。\n\n现在,给出位于一条水平线上的房屋 `houses` 和供暖器 `heaters` 的位置,请你找出并返回可以覆盖所有房屋的最小加热半径。\n\n说明:所有供暖器都遵循你的半径标准,加热的半径也一样。\n\n示例 1:\n```\n输入: houses = [1,2,3], heaters = [2]\n\n输出: 1\n\n解释: 仅在位置2上有一个供暖器。如果我们将加热半径设为1,那么所有房屋就都能得到供暖。\n```\n示例 2:\n```\n输入: houses = [1,2,3,4], heaters = [1,4]\n\n输出: 1\n\n解释: 在位置1, 4上有两个供暖器。我们需要将加热半径设为1,这样所有房屋就都能得到供暖。\n```\n示例 3:\n```\n输入:houses = [1,5], heaters = [2]\n\n输出:3\n```\n\n提示:\n* $1 <= houses.length, heaters.length <= 3 \\times 10^4$\n* $1 <= houses[i], heaters[i] <= 10^9$", "solution": "### 二分 + 双指针\n\n需要求得最小加热半径 $ans$,使得所有的 $houses[i]$ 均被覆盖。\n\n在以 $ans$ 为分割点的数轴上具有「二段性」:\n\n* 数值小于 $ans$ 的半径无法覆盖所有的房子;\n* 数值大于等于 $ans$ 的半径可以覆盖所有房子。\n\n因此可直接「二分答案」,考虑应该在什么范围内进行「二分」。\n\n可以从数据范围入手,使用 $1e9$ 为二分上界,该做法能确保答案在二分范围内。\n\n考虑如何实现 `check` 函数。\n\n先对 $houses$ 和 $heaters$ 进行排序,使用 $i$ 指向当前处理到的 $houses[i]$;$j$ 指向 **可能** 覆盖到 $houses[i]$ 的最小下标 $heaters[j]$;$x$ 代表当前需要 `check` 的半径。\n\n当且仅当 $heaters[j] + x < houses[i]$ 时,$houses[i]$ 必然不能被 $heaters[j]$ 所覆盖,此时让 $j$ 自增。\n\n找到合适的 $j$ 之后,再检查 $heaters[j] - x <= houses[i] <= heaters[j] + x$ 是否满足,即可知道 $houses[i]$ 的覆盖情况。\n\n代码:\n```Java\nclass Solution {\n    public int findRadius(int[] houses, int[] heaters) {\n        Arrays.sort(houses);\n        Arrays.sort(heaters);\n        int l = 0, r = (int) 1e9;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (check(houses, heaters, mid)) r = mid;\n            else l = mid + 1;\n        }\n        return r;\n    }\n    boolean check(int[] houses, int[] heaters, int x) {\n        int n = houses.length, m = heaters.length;\n        for (int i = 0, j = 0; i < n; i++) {\n            while (j < m && houses[i] > heaters[j] + x) j++;\n            if (j < m && heaters[j] - x <= houses[i] && houses[i] <= heaters[j] + x) continue;\n            return false;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:令 $n$ 和 $m$ 分别为 `houses` 和 `heaters` 长度,$L = 1e9$ 为最大长度,对其进行排序复杂度为 $O(n\\log{n} + m\\log{m})$,在 $[0, L]$ 范围进行二分,单次 `check` 会使用「双指针」判断是否每个 $houses[i]$ 是否被覆盖,复杂度为 $O(\\max(n, m) \\times \\log{L})$。整体复杂度为 $O(\\max(n, m) \\times \\log{L})$\n* 空间复杂度:排序所需要消耗的空间。复杂度为 $O(\\log{n} + \\log{m})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.475` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/471-480/476. 数字的补数（简单）.md", "url_title": "476. 数字的补数", "url": "https://leetcode-cn.com/problems/number-complement/solution/gong-shui-san-xie-yi-ti-shuang-jie-bian-wjl0y/", "difficulty": "简单", "tags": ["模拟", "位运算"], "question": "对整数的二进制表示取反(`0` 变 `1` ,`1` 变 `0`)后,再转换为十进制表示,可以得到这个整数的补数。\n\n* 例如,整数 `5` 的二进制表示是 `\"101\"` ,取反后得到 `\"010\"` ,再转回十进制表示得到补数 2 。\n给你一个整数 `num`,输出它的补数。\n\n示例 1:\n```\n输入:num = 5\n\n输出:2\n\n解释:5 的二进制表示为 101(没有前导零位),其补数为 010。所以你需要输出 2 。\n```\n示例 2:\n```\n输入:num = 1\n\n输出:0\n\n解释:1 的二进制表示为 1(没有前导零位),其补数为 0。所以你需要输出 0 。\n```\n\n提示:\n* $1 <= num < 2^{31}$", "solution": "### 模拟(遍历)\n\n返回对 $num$ 的二进制表示取反的数,注意 $num$ 的二进制表示是不包含前导零的。\n\n因此主要问题求得 $num$ 最高位 $1$ 的位置。\n\n一个简单的做法是:先对 $num$ 进行「从高到低」的检查,找到最高位 $1$ 的位置 $s$,然后再对 $num$ 进行遍历,将低位到 $s$ 位的位置执行逐位取反操作。\n\n代码:\n```Java\nclass Solution {\n    public int findComplement(int num) {\n        int s = -1;\n        for (int i = 31; i >= 0; i--) {\n            if (((num >> i) & 1) != 0) {\n                s = i;\n                break;\n            }\n        }\n        int ans = 0;\n        for (int i = 0; i < s; i++) {\n            if (((num >> i) & 1) == 0) ans |= (1 << i);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(\\log{num})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 模拟(lowbit)\n\n通过解法一我们发现,如果 $num$ 的二进制表示中最高位 $1$ 的位置为 $s$ 的话,那么实际上我们只需要对 $num$ 的前 $s - 1$ 位进行取反即是答案(第 $s$ 位的取反结果始终为 $0$)。\n\n因此我们可以先使用 `lowbit` 操作来得到 $num$ 二进制表示中最高位 $1$ 的位置为 $1$,其余位为 $0$ 时所代表的数字 $x$。\n\n然后 $x - 1$ 即是二进制表示中前 $s - 1$ 位均为 $1$,其余位为 $0$ 的数字,将其与 $num$ 的取反数执行「按位与」操作,即可达到「仅对 $num$ 的前 $s - 1$ 位进行取反」的效果。\n\n代码:\n```Java\nclass Solution {\n    public int findComplement(int num) {\n        int x = 0;\n        for (int i = num; i != 0; i -= i & -i) x = i;\n        return ~num & (x - 1);\n    }\n}\n```\n* 时间复杂度:$O(\\log{num})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.476` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/471-480/477. 汉明距离总和（中等）.md", "url_title": "477. 汉明距离总和", "url": "https://leetcode-cn.com/problems/total-hamming-distance/solution/gong-shui-san-xie-ying-yong-cheng-fa-yua-g21t/", "difficulty": "中等", "tags": ["位运算", "数学"], "question": "两个整数的 汉明距离 指的是这两个数字的二进制数对应位不同的数量。\n\n给你一个整数数组 nums,请你计算并返回 nums 中任意两个数之间汉明距离的总和。\n\n \n\n示例 1:\n```\n输入:nums = [4,14,2]\n输出:6\n解释:在二进制表示中,4 表示为 0100 ,14 表示为 1110 ,2表示为 0010 。(这样表示是为了体现后四位之间关系)\n所以答案为:\nHammingDistance(4, 14) + HammingDistance(4, 2) + HammingDistance(14, 2) = 2 + 2 + 2 = 6\n```\n示例 2:\n```\n输入:nums = [4,14,4]\n输出:4\n```\n\n提示:\n```\n1 <= nums.length <= $10^5$\n0 <= nums[i] <= $10^9$\n```", "solution": "### 按位统计\n\n我们知道,汉明距离为两数二进制表示中不同位的个数,同时每位的统计是相互独立的。\n\n即最终的答案为 $\\sum_{x = 0}^{31} calc(x)$,其中 $calc$ 函数为求得所有数二进制表示中的某一位 $x$ 所产生的不同位的个数。\n\n我们考虑某个 $cacl(x)$ 如何求得:\n\n事实上,对于某个 `nums[i]` 我们只关心在 `nums` 中有多少数的第 $x$ 位的与其不同,而不关心具体是哪些数与其不同,同时二进制表示中非 $0$ 即 $1$。\n\n**这指导我们可以建立两个集合 $s0$ 和 $s1$,分别统计出 `nums` 中所有数的第 $x$ 位中 $0$ 的个数和 $1$ 的个数,集合中的每次计数代表了 `nums` 中的某一元素,根据所在集合的不同代表了其第 $x$ 位的值。那么要找到在 `nums` 中有多少数与某一个数的第 $x$ 位不同,只需要读取另外一个集合的元素个数即可,变成了 $O(1)$ 操作。那么要求得「第 $x$ 位所有不同数」的对数的个数,只需要应用乘法原理,将两者元素个数相乘即可。**\n\n前面说到每位的统计是相对独立的,因此只要对「每一位」都应用上述操作,并把「每一位」的结果累加即是最终答案。\n\n代码:\n```Java\nclass Solution {\n    public int totalHammingDistance(int[] nums) {\n        int ans = 0;\n        for (int x = 31; x >= 0; x--) {\n            int s0 = 0, s1 = 0;\n            for (int u : nums) {\n                if (((u >> x) & 1) == 1) {\n                    s1++;\n                } else {\n                    s0++;\n                }  \n            }\n            ans += s0 * s1;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(C * n)$,$C$ 固定为 $32$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.477` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/471-480/478. 在圆内随机生成点（中等）.md", "url_title": "478. 在圆内随机生成点", "url": "https://leetcode.cn/problems/generate-random-point-in-a-circle/solution/by-ac_oier-btkm/", "difficulty": "中等", "tags": ["数学", "随机化"], "question": "给定圆的半径和圆心的位置,实现函数 `randPoint`,在圆中产生均匀随机点。\n\n实现 `Solution` 类:\n* `Solution(double radius, double x_center, double y_center)` 用圆的半径 `radius` 和圆心的位置 $(x_center, y_center)$ 初始化对象\n* `randPoint()` 返回圆内的一个随机点。圆周上的一点被认为在圆内。答案作为数组返回 $[x, y]$ 。\n\n示例 1:\n```\n输入: \n[\"Solution\",\"randPoint\",\"randPoint\",\"randPoint\"]\n[[1.0, 0.0, 0.0], [], [], []]\n输出: [null, [-0.02493, -0.38077], [0.82314, 0.38945], [0.36572, 0.17248]]\n\n解释:\nSolution solution = new Solution(1.0, 0.0, 0.0);\nsolution.randPoint ();//返回[-0.02493,-0.38077]\nsolution.randPoint ();//返回[0.82314,0.38945]\nsolution.randPoint ();//返回[0.36572,0.17248\n```\n\n提示:\n* $0 < radius <= 10^8$\n* $-10^7 <= x_center, y_center <= 10^7$\n* `randPoint` 最多被调用 $3 \\times 10^4$ 次", "solution": "### 等概率随机采样\n\n为了方便,我们称圆心为 $(x, y)$,半径为 $r$。\n\n对给定圆内的点进行等概率随机采样,容易想到随机化两个信息:一个是距离圆心的距离 `len`(在范围 $[0, r]$ 中进行随机),另外一个是夹角 `ang`(在范围 $[0, 2\\pi]$ 中随机,随便找个参考线即可,例如以往 $x$ 轴正方向的射线为参考)。\n\n然后根据 `len` 和 `ang` 直接计算对应的点的坐标,这样 **可以确保随机出来的点一定在圆内,但并非「等概率」。**\n\n在不考虑夹角的情况下,我们本质是在 $[0, r]$ 范围内随机,这在「一维」上「等概率」是成立的,因为满足「任意连续段中点被抽到的次数与总次数的比例」与「该连续段长度与总长度的比例」。\n\n但在圆中并非如此,不考虑夹角时,「任意连续段 `len` 与总长度 `r` 的比例」和「`len` 对应面积与总面积比例」并不相等。例如 `len` 有 $\\frac{1}{2}$ 的概率取到小于等于 $\\frac{r}{2}$ 的值,而半径为 $\\frac{r}{2}$ 扫过的面积仅为总面积的 $\\frac{1}{4}$,因此我们的 `len` 不能直接在 $[0, r]$ 范围内随机,为了消除这种一维转圆导致的「等概率」失效,我们可以从 $[0, r^2]$ 内随机再开平方,从而确保距离与面积比例一致。\n\n代码:\n```Java\nclass Solution {\n    double r, x, y;\n    Random random = new Random();\n    public Solution(double _r, double _x, double _y) {\n        r = _r; x = _x; y = _y;\n    }\n    public double[] randPoint() {\n        double len = Math.sqrt(random.nextDouble(r * r)), ang = random.nextDouble(2 * Math.PI);\n        double nx = x + len * Math.cos(ang), ny = y + len * Math.sin(ang);\n        return new double[]{nx, ny};\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.478` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/471-480/479. 最大回文数乘积（困难）.md", "url_title": "479. 最大回文数乘积", "url": "https://leetcode-cn.com/problems/largest-palindrome-product/solution/by-ac_oier-t8j7/", "difficulty": "困难", "tags": ["枚举", "数学"], "question": "给定一个整数 $n$ ,返回 可表示为两个 $n$ 位整数乘积的 最大回文整数 。\n\n因为答案可能非常大,所以返回它对 $1337$ 取余 。\n\n示例 1:\n``` \n输入:n = 2\n\n输出:987\n\n解释:99 x 91 = 9009, 9009 % 1337 = 987\n```\n示例 2:\n``` \n输入: n = 1\n\n输出: 9\n```\n\n提示:\n* $1 <= n <= 8$", "solution": "### 枚举 + 数学\n\n对于数位为 $n$ 的两个数而言,其乘积的位数要么是 $2 * n$,要么是 $2 * n - 1$。\n\n当数位 $n > 1$ 时,我们总能在数位为 $2 * n$ 中找到答案。\n\n利用回文串的特性,我们只需枚举回文串的前半部分即可(后半部分唯一确定),我们只要在枚举前半部分时按照「从大到小」进行,即可确保找到的第一个合法值为最大数,对于一个数位为 $n$ 的最大数为 $10^n - 1$。\n\n具体的,当枚举到回文串的前半部分 $i$ 时,我们利用回文串特性构造出具实际的回文数值 $nums$,随后检查 $nums$ 能否分解成数位为 $n$ 的数对 $(a, b)$,利用乘法具有交换律,我们只需要枚举数对中的较大数即可。\n\n代码:\n```Java\nclass Solution {\n    public int largestPalindrome(int n) {\n        if (n == 1) return 9;\n        int max = (int) Math.pow(10, n) - 1;\n        for (int i = max; i >= 0; i--) {\n            long num = i, t = i;\n            while (t != 0) {\n                num = num * 10 + (t % 10);\n                t /= 10;\n            }\n            for (long j = max; j * j >= num; j--) {\n                if (num % j == 0) return (int)(num % 1337);\n            }\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:枚举回文串的前半部分复杂度为 $O(10^n)$;检查回文串能否被分解复杂度为 $O(10^n)$。整体复杂度为 $O(10^{2n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.479` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/471-480/480. 滑动窗口中位数（困难）.md", "url_title": "480. 滑动窗口中位数", "url": "https://leetcode-cn.com/problems/sliding-window-median/solution/xiang-jie-po-su-jie-fa-you-xian-dui-lie-mo397/", "difficulty": "困难", "tags": ["滑动窗口", "优先队列(堆)"], "question": "中位数是有序序列最中间的那个数。如果序列的长度是偶数,则没有最中间的数;此时中位数是最中间的两个数的平均数。\n\n例如:\n* $[2,3,4]$,中位数是 $3$\n* $[2,3]$,中位数是 $(2 + 3) / 2 = 2.5$\n\n给你一个数组 $nums$,有一个长度为 $k$ 的窗口从最左端滑动到最右端。\n\n窗口中有  $k$ 个数,每次窗口向右移动 $1$ 位。\n\n你的任务是找出每次窗口移动后得到的新窗口中元素的中位数,并输出由它们组成的数组。\n\n示例:\n```\n给出 nums = [1,3,-1,-3,5,3,6,7],以及 k = 3。\n\n窗口位置                      中位数\n---------------               -----\n[1  3  -1] -3  5  3  6  7       1\n 1 [3  -1  -3] 5  3  6  7      -1\n 1  3 [-1  -3  5] 3  6  7      -1\n 1  3  -1 [-3  5  3] 6  7       3\n 1  3  -1  -3 [5  3  6] 7       5\n 1  3  -1  -3  5 [3  6  7]      6\n \n 因此,返回该滑动窗口的中位数数组 [1,-1,-1,3,5,6]。\n```\n\n提示:\n* 你可以假设 $k$ 始终有效,即:$k$ 始终小于等于输入的非空数组的元素个数。\n* 与真实值误差在 $10 ^ {-5}$ 以内的答案将被视作正确答案。", "solution": "### 朴素解法\n\n一个直观的做法是:对每个滑动窗口的数进行排序,获取排序好的数组中的第 $\\frac{k}{2}$ 和 $\\frac{k - 1}{2}$ 个数(避免奇偶数讨论),计算中位数。\n\n我们大概分析就知道这个做法至少 $O(n * k)$ 的,算上排序的话应该是 $O(n * (k + k\\log{k}))$。\n\n比较无奈的是,这道题的中文说明中没有给出数据范围。我们无法根据判断这样的做法会不会超时。\n\n朴素做法通常是优化的开始,所以还是提供一下朴素做法的代码。\n\n代码:\n```Java\nclass Solution {\n    public double[] medianSlidingWindow(int[] nums, int k) {\n        int n = nums.length;\n        int cnt = n - k + 1;\n        double[] ans = new double[cnt];\n        int[] t = new int[k];\n        for (int l = 0, r = l + k - 1; r < n; l++, r++) {\n            for (int i = l; i <= r; i++) t[i - l] = nums[i];\n            Arrays.sort(t);\n            ans[l] = (t[k / 2] / 2.0) + (t[(k - 1) / 2] / 2.0);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:最多有 `n` 个窗口需要滑动计算。每个窗口,需要先插入数据,复杂度为 $O(k)$,插入后需要排序,复杂度为 $O(k\\log{k})$。整体复杂度为 $O(n * (k + k\\log{k}))$\n* 空间复杂度:使用了长度为 `k` 的临时数组。复杂度为 $O(k)$\n\n---\n\n### 优先队列(堆)\n\n从朴素解法中我们可以发现,其实我们需要的就是滑动窗口中的第 $\\frac{k}{2}$ 小的值和第 $\\frac{k - 1}{2}$ 小的值。\n\n我们知道滑动窗口求最值的问题,可以使用优先队列来做。\n\n但这里我们求的是第 $k$ 小的数,而且是需要两个值。还能不能使用优先队列来做呢?\n\n我们可以维护两个堆:\n\n* 一个大根堆维护着滑动窗口中一半较小的值(此时堆顶元素为滑动窗口中的第 $\\frac{k - 1}{2}$ 小的值)\n* 一个小根堆维护着滑动窗口中一半较大的值(此时堆顶元素为滑动窗口中的第 $\\frac{k}{2}$ 小的值)\n\n滑动窗口的中位数就是两个堆的堆顶元素的平均值。\n\n实现细节:\n\n1. 初始化时,先让 `k` 个元素直接入 `right`,再从 `right` 中倒出 $\\frac{k}{2}$ 个到 `left` 中。这时候可以根据 `left` 和 `right` 得到第一个滑动窗口的中位值。\n\n2. 开始滑动窗口,每次滑动都有一个待添加和待移除的数:\n  \n    2.1 根据与右堆的堆顶元素比较,决定是插入哪个堆和从哪个堆移除\n  \n    2.2 之后调整两堆的大小(确保只会出现 `left.size() == right.size()` 或 `right.size() - left.size() == 1`,对应了窗口长度为偶数或者奇数的情况)\n    \n    2.3 根据 `left` 堆 和 `right` 堆得到当前滑动窗口的中位值\n\n代码:\n```Java\nclass Solution {\n    public double[] medianSlidingWindow(int[] nums, int k) {\n        int n = nums.length;\n        int cnt = n - k + 1;\n        double[] ans = new double[cnt];\n        // 如果是奇数滑动窗口,让 right 的数量比 left 多一个\n        PriorityQueue<Integer> left  = new PriorityQueue<>((a,b)->Integer.compare(b,a)); // 滑动窗口的左半部分\n        PriorityQueue<Integer> right = new PriorityQueue<>((a,b)->Integer.compare(a,b)); // 滑动窗口的右半部分\n        for (int i = 0; i < k; i++) right.add(nums[i]);\n        for (int i = 0; i < k / 2; i++) left.add(right.poll());\n        ans[0] = getMid(left, right);\n        for (int i = k; i < n; i++) {\n            // 人为确保了 right 会比 left 多,因此,删除和添加都与 right 比较(left 可能为空)\n            int add = nums[i], del = nums[i - k];\n            if (add >= right.peek()) {\n                right.add(add);\n            } else {\n                left.add(add);\n            }\n            if (del >= right.peek()) {\n                right.remove(del);\n            } else {\n                left.remove(del);\n            }\n            adjust(left, right);\n            ans[i - k + 1] = getMid(left, right);\n        }\n        return ans;\n    }\n    void adjust(PriorityQueue<Integer> left, PriorityQueue<Integer> right) {\n        while (left.size() > right.size()) right.add(left.poll());\n        while (right.size() - left.size() > 1) left.add(right.poll());\n    }\n    double getMid(PriorityQueue<Integer> left, PriorityQueue<Integer> right) {\n        if (left.size() == right.size()) {\n            return (left.peek() / 2.0) + (right.peek() / 2.0);\n        } else {\n            return right.peek() * 1.0;\n        }\n    }\n}\n```\n* 时间复杂度:调整过程中堆大小最大为 `k`,堆操作中的指定元素删除复杂度为 $O(k)$;窗口数量最多为 `n`。整体复杂度为 $O(n * k)$\n* 空间复杂度:最多有 `n` 个元素在堆内。复杂度为 $O(n)$\n\n---\n\n### 答疑\n\n以下是针对一些具有代表性的问题进行的集中答疑:\n\n* 为什么 `new PriorityQueue<>((x,y)->(y-x))` 的写法会有某些案例无法通过?和 `new PriorityQueue<>((x,y)->Integer.compare(y,x))` 写法有何区别?\n\n  `(x,y)->(y-x)` 的写法逻辑没有错,AC 不了是因为 int 溢出。\n  \n  在 Java 中 Integer.compare 的实现是 `(x < y) ? -1 : ((x == y) ? 0 : 1)`。只是单纯的比较,不涉及运算,所以不存在溢出风险。\n  \n  而直接使用 `y - x`,当 `y = Integer.MAX_VALUE`, `x = Integer.MIN_VALUE` 时,到导致溢出,返回的是 **负数** ,而不是逻辑期望的 **正数**\n\n同样具有溢出问题的还有计算第 $\\frac{k}{2}$ 小的数和第 $\\frac{k - 1}{2}$ 小的数的平均值时。\n\n因此题解中使用的是  `(a / 2.0) + (b / 2.0)` 的形式,而不是采用 `(a + b) / 2.0` 的形式。后者有相加溢出的风险。\n\n---\n\n### 复杂度说明\n\nJDK 中 `PriorityQueue` 的 `remove(Object o)` 实现是先调用 `indexOf(Object o)` 方法进行线性扫描找到下标(复杂度为 $O(n)$),之后再调用 `removeAt(int i)` 进行删除(复杂度为 $O(\\log{n})$)。\n\n对于本题而言,如果需要实现 $O(\\log{n})$ 的 `remove(Object o)`, 只能通过引入其他数据结构(如哈希表)来实现快速查找元素在对堆数组中的下标。\n\n对于本题,可以使用元素在原数组中的下标作为 key,在堆数组中的真实下标作为 val。\n\n通过哈希表可以 $O(1)$ 的复杂度找到下标,之后的删除只需要算堆调整的复杂度即可(最多 down 一遍,up 一遍,复杂度为 $O(\\log{n})$)。\n\n至于 JDK 没有这样做的原因,猜测是因为基本类型的包装类型存在小数缓存机制,导致无法很好的使用哈希表来对应一个插入元素的下标。\n\n举个🌰,我们调用三次 `add(10)`, 会有 $3$ 个 $10$ 在堆内,但是由于小数(默认范围为 $[-128,127]$)包装类型存在缓存机制,使用哈希表继续记录的话,只会有 { Integer.valueOf(10) : 移动过程中最后一次访问的数组下标 } 这样一条记录(`add` 进去的 $10$ 均为同一对象)。这时候删除一个 $10$ 之后,哈希表无法正确指导我们找到下一个 $10$ 的位置。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.480` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/481-490/481. 神奇字符串（中等）.md", "url_title": "481. 神奇字符串", "url": "https://leetcode.cn/problems/magical-string/solution/by-ac_oier-7wjo/", "difficulty": "中等", "tags": ["模拟", "构造", "双指针", "打表"], "question": "神奇字符串 `s` 仅由 `'1'` 和 `'2'` 组成,并需要遵守下面的规则:\n\n* 神奇字符串 `s` 的神奇之处在于,串联字符串中 `'1'` 和 `'2'` 的连续出现次数可以生成该字符串。\n\n`s` 的前几个元素是 `s = \"1221121221221121122......\"` 。如果将 `s` 中连续的若干 `1` 和 `2` 进行分组,可以得到 `\"1 22 11 2 1 22 1 22 11 2 11 22 ......\"` 。\n\n每组中 `1` 或者 `2` 的出现次数分别是 `\"1 2 2 1 1 2 1 2 2 1 2 2 ......\"` 。上面的出现次数正是 `s` 自身。\n\n给你一个整数 `n` ,返回在神奇字符串 `s` 的前 `n` 个数字中 `1` 的数目。\n\n示例 1:\n```\n输入:n = 6\n\n输出:3\n\n解释:神奇字符串 s 的前 6 个元素是 “122112”,它包含三个 1,因此返回 3 。 \n```\n示例 2:\n```\n输入:n = 1\n\n输出:1\n```\n\n提示:\n* $1 <= n <= 10^5$", "solution": "### 双指针 + 构造 + 打表\n\n我们将相关的字符串分为三类:**题目描述的神奇字符串 `s` 称为“原串”,对 `s` 进行连续段划分所得的串叫“划分串”,对划分串进行计数的串叫“计数串”**。\n\n解题的核心思路:**由于划分串是对原串的划分,同时计数串又与原串相同,因此可得三类串均只有 `1` 和 `2` 两种数值。即可知划分串的每段长度只能是「长度为 `1`」或「长度为 `2`」,利用划分串的每段构造长度有限,我们可以通过「简单分情况讨论」的方式进行构造**。\n\n具体的,我们需要利用「原串和计数串的相同的性质」对 `s` 进行构造:不难发现计数串总是不长于原串,因此我们可以使用变量 `i` 来记录当前构造到原串位置,使用变量 `j` 来记录计数串对应到的实际位置。\n\n不失一般性假设当前构造到 `s` 中的某一位为 `last`,而计数串对应的实际位置为 `t`,由于两者均只有 `1` 和 `2` 两种可能,我们可以对其进行简单的分情况讨论(可见代码注释)。\n\n> 一些细节:由于神奇字符串起始字符固定,构造逻辑固定,因此神奇字符串唯一固定。\n我们可以采取 `static` 代码块的方式进行打表预处理(`Java` 中的 `static` 代码块只会在类加载的过程执行一次,而 `LC` 的测评机制是实例化多个 `Solution` 对象来跑多个样例,但 `Solution` 类仍只会被加载一次,即 `static` 在多个样例测评中只会被执行一次。\n\nJava 代码:\n```Java\nclass Solution {\n    static int N = 100010;\n    static int[] f = new int[N];\n    static {\n        StringBuilder sb = new StringBuilder();\n        sb.append(\"01\"); // 首位多加一个 0 作为哨兵\n        for (int i = 1, j = 1, cnt = 0; i < N; j++) {\n            int last = sb.charAt(sb.length() - 1) - '0', t = sb.charAt(j) - '0';\n            if (last == 1) {\n                if (t == 1) {\n                    // 当原串当前字符是 1,而计数串当前字符为 1 \n                    // 往后构造形成的原串只能是 12,原串指针后移一位\n                    sb.append(\"2\");\n                    f[i] = ++cnt; i++;\n                } else {\n                    // 当原串当前字符是 1,而计数串当前字符为 2\n                    // 往后构造形成的原串只能是 112,此时同步更新 f[i + 1],原串指针后移两位\n                    sb.append(\"12\");\n                    f[i] = ++cnt; f[i + 1] = ++cnt; i += 2;\n                }\n            } else {\n                if (t == 1) {\n                    // 当原串当前字符是 2,而计数串当前字符为 1 \n                    // 往后构造形成的原串只能是 21,原串指针后移一位\n                    sb.append(\"1\");\n                    f[i] = cnt; i++;\n                } else {\n                    // 当原串当前字符是 2,而计数串当前字符为 2\n                    // 往后构造形成的原串只能是 221,原串指针后移两位\n                    sb.append(\"21\");\n                    f[i] = f[i + 1] = cnt; i += 2;\n                }\n            }\n        }\n    }\n    public int magicalString(int n) {\n        return f[n];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    static const int N = 100010;\n    static vector<int> f;\n    Solution() {\n        if(!f.empty()) return;\n        f.resize(N);\n        string sb = \"01\"; // 首位多加一个 0 作为哨兵\n        for (int i = 1, j = 1, cnt = 0; i < N; j++) {\n            int last = sb[sb.size() - 1] - '0', t = sb[j] - '0';\n            if (last == 1) {\n                if (t == 1) {\n                    sb += '2';\n                    f[i++] = ++cnt;\n                } else {\n                    sb += \"12\";\n                    f[i++] = ++cnt; f[i++] = ++cnt;\n                }\n            } else {\n                if (t == 1) {\n                    sb += '1';\n                    f[i++] = cnt;\n                } else {\n                    sb += \"21\";\n                    f[i++] = f[i++] = cnt;\n                }\n            }\n        }\n    }\n    int magicalString(int n) {\n        return f[n];\n    }\n};\nvector<int> Solution::f = {};\n```\nPython 代码:\n```Python\nclass Solution:\n    def magicalString(self, n: int) -> int:\n        ss = '01' # 首位多加一个 0 作为哨兵\n        i, j, cnt = 1, 1, 0\n        f = [0] * (n + 10)\n        while i <= n:\n            last, t = ss[i], ss[j]\n            if last == '1':\n                if t == '1':\n                    # 当原串当前字符是 1,而计数串当前字符为 1 \n                    # 往后构造形成的原串只能是 12,原串指针后移一位\n                    ss += '2'\n                    f[i], cnt, i = cnt + 1, cnt + 1, i + 1\n                else:\n                    # 当原串当前字符是 1,而计数串当前字符为 2\n                    # 往后构造形成的原串只能是 112,此时同步更新 f[i + 1],原串指针后移两位\n                    ss += '12'\n                    f[i], f[i + 1], cnt, i = cnt + 1, cnt + 2, cnt + 2, i + 2\n            else:\n                if t == '1':\n                    # 当原串当前字符是 2,而计数串当前字符为 1 \n                    # 往后构造形成的原串只能是 21,原串指针后移一位\n                    ss += '1'\n                    f[i], i = cnt, i + 1\n                else:\n                    # 当原串当前字符是 2,而计数串当前字符为 2\n                    # 往后构造形成的原串只能是 221,原串指针后移两位\n                    ss += '21'\n                    f[i], f[i + 1], i = cnt, cnt, i + 2\n            j += 1\n        return f[n]\n```\nTypeScript 代码:\n```TypeScript\nfunction magicalString(n: number): number {\n    let str = '01' // 首位多加一个 0 作为哨兵\n    const f = new Array<number>(n + 10).fill(0)\n    for (let i = 1, j = 1, cnt = 0; i <= n; j++) {\n        const last = str[str.length - 1], t = str[j]\n        if (last == '1') {\n            if (t == '1') {\n                // 当原串当前字符是 1,而计数串当前字符为 1 \n                // 往后构造形成的原串只能是 12,原串指针后移一位\n                str += '2'\n                f[i] = ++cnt; i++\n            } else {\n                // 当原串当前字符是 1,而计数串当前字符为 2\n                // 往后构造形成的原串只能是 112,此时同步更新 f[i + 1],原串指针后移两位\n                str += '12'\n                f[i] = ++cnt; f[i + 1] = ++cnt; i += 2\n            }\n        } else {\n            if (t == '1') {\n                // 当原串当前字符是 2,而计数串当前字符为 1 \n                // 往后构造形成的原串只能是 21,原串指针后移一位\n                str += '1'\n                f[i] = cnt; i++\n            } else {\n                // 当原串当前字符是 2,而计数串当前字符为 2\n                // 往后构造形成的原串只能是 221,原串指针后移两位\n                str += '21'\n                f[i] = f[i + 1] = cnt; i += 2\n            }\n        }\n    }\n    return f[n]\n}\n```\n* 时间复杂度:$O(n)$,若将 `static` 打表逻辑放到本地进行,能够减少构造的计算量,但仍会有创建答案数组的 $O(n)$ 开销,因此为均摊 $O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.481` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/481-490/482. 密钥格式化（简单）.md", "url_title": "482. 密钥格式化", "url": "https://leetcode-cn.com/problems/license-key-formatting/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-piya/", "difficulty": "简单", "tags": ["模拟"], "question": "有一个密钥字符串 `S`,只包含字母,数字以及 `'-'`(破折号)。其中,`N` 个 `'-'` 将字符串分成了 `N+1` 组。\n\n给你一个数字 `K`,请你重新格式化字符串,使每个分组恰好包含 `K` 个字符。特别地,第一个分组包含的字符个数必须小于等于 `K`,但至少要包含 `1` 个字符。两个分组之间需要用 `'-'`(破折号)隔开,并且将所有的小写字母转换为大写字母。\n\n给定非空字符串 `S` 和数字 `K`,按照上面描述的规则进行格式化。\n\n示例 1:\n```\n输入:S = \"5F3Z-2e-9-w\", K = 4\n\n输出:\"5F3Z-2E9W\"\n\n解释:字符串 S 被分成了两个部分,每部分 4 个字符;\n     注意,两个额外的破折号需要删掉。\n```\n示例 2:\n```\n输入:S = \"2-5g-3-J\", K = 2\n\n输出:\"2-5G-3J\"\n\n解释:字符串 S 被分成了 3 个部分,按照前面的规则描述,第一部分的字符可以少于给定的数量,其余部分皆为 2 个字符。\n```\n\n提示:\n* S 的长度可能很长,请按需分配大小。K 为正整数。\n* S 只包含字母数字(a-z,A-Z,0-9)以及破折号'-'\n* S 非空", "solution": "### 模拟\n\n简单字符串模拟,从后往前处理,避免对首个分区的分情况讨论和取余操作。\n\n代码:\n```Java\nclass Solution {\n    public String licenseKeyFormatting(String s, int k) {\n        StringBuilder sb = new StringBuilder();\n        for (int i = s.length() - 1, cnt = 0; i >= 0; i--) {\n            if (s.charAt(i) == '-') continue;\n            if (cnt == k && (cnt = 0) >= 0) sb.append(\"-\");\n            sb.append(s.charAt(i));\n            cnt++;\n        }\n        return sb.reverse().toString().toUpperCase();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.482` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/481-490/483. 最小好进制（困难）.md", "url_title": "483. 最小好进制", "url": "https://leetcode-cn.com/problems/smallest-good-base/solution/gong-shui-san-xie-xiang-jie-ru-he-fen-xi-r94g/", "difficulty": "困难", "tags": ["数学", "推公式"], "question": "对于给定的整数 n, 如果n的k(k>=2)进制数的所有数位全为1,则称 k(k>=2)是 n 的一个好进制。\n\n以字符串的形式给出 n, 以字符串的形式返回 n 的最小好进制。\n\n示例 1:\n```\n输入:\"13\"\n输出:\"3\"\n解释:13 的 3 进制是 111。\n```\n示例 2:\n```\n输入:\"4681\"\n输出:\"8\"\n解释:4681 的 8 进制是 11111。\n```\n示例 3:\n```\n输入:\"1000000000000000000\"\n输出:\"999999999999999999\"\n解释:1000000000000000000 的 999999999999999999 进制是 11。\n```\n\n提示:\n* n的取值范围是 [3, $10^{18}$]。\n* 输入总是有效且没有前导 0。", "solution": "### 基本分析 \n\n设 $(n)_{10}$ 的 $k$ 进制表示共有 $Len$ 位,那么根据「进制转换」相关知识,必然有如下等式:\n\n$$\n(n)_{10} = (11...11)_{k} = k^0 + k^1 + k^2 + ... + k^{Len - 1}\n$$\n\n当 $n$ 给定的情况下,$k$ 随着 $Len$ 减小而增大,由此我们可以分析出 $k$ 的上界:\n\n* 当 $Len$ 取 $1$ 的时候:$k^0 = n$,即 $n = 1$,与题目给定的数据范围冲突,不可取;\n* 当 $Len$ 取 $2$ 的时候:$k^0 + k^1 = n$,即 $k = n - 1$,为合法值。\n\n**因此 $k$ 的上界为 $n - 1$,同时我们知道长度 $Len$ 满足等式 $Len \\geq 2$。**\n\n然后我们再分析一下 $Len$ 的上界。\n\n**根据 $k$ 与 $Len$ 大小变化关系,同时已知 $k \\geq 2$,不难分析当 $k$ 取最小值 $2$ 的时候,$Len$ 可得最大值(同时 $n$ 的最大值为 $10^{18}$),可分析出 $Len \\leq \\lceil \\log_2{n} \\rceil$,$\\log_2{10^{18}}$ 不超过 $60$。**\n\n因此可以采取枚举 $Len$ 的做法。\n\n---\n\n### 枚举 $Len$\n\n根据分析,我们可以在 $[2, 60]$ 范围内从大到小枚举 $Len$,当取得第一位合法的 $Len$ 时,$k$ 为最小合法值。\n\n剩下的问题在于如何在给定 $Len$ 的情况下,求得 $k$ 为多少。\n\n前面分析到 $Len \\geq 2$,令 $s = Len - 1$,再根据 [二项式定理](https://baike.baidu.com/item/%E4%BA%8C%E9%A1%B9%E5%BC%8F%E5%AE%9A%E7%90%86) 可得:\n\n$$\nn = k^0 + k^1 + k^2 + ... + k^s < C_{s}^{0} * k^0 + C_{s}^{1} * k^1 + ... + C_{s}^{s} * k^s = (k + 1)^{s}\n$$\n\n同时结合 $n > k^ s$,可得 $k^s < n < (k + 1)^s$,整理后可得:\n\n$$\nk < n^{\\frac{1}{s}} < k + 1\n$$\n\n因此,对于任意的 $s = Len - 1$ 都有唯一的解为 $n^{\\frac{1}{s}}$(正整数),我们只需要验证 $n^{\\frac{1}{s}}$ 是否为正整数即可。\n\n一些细节:实现上为了方便,不处理 $k = n - 1$ 的边界问题,我们可以调整枚举下界为 $3$,当枚举不出合法 $k$ 时,直接返回 $n - 1$ 作为答案。\n\n代码:\n```Java\nclass Solution {\n    public String smallestGoodBase(String n) {\n        long m = Long.parseLong(n);\n        int max = (int)(Math.log(m) / Math.log(2) + 1);\n        for (int len = max; len >= 3; len--) {\n            long k = (long)Math.pow(m, 1.0 / (len - 1));\n            long res = 0;\n            for (int i = 0; i < len; i++) res = res * k + 1;\n            if (res == m) return String.valueOf(k);\n        }\n        return String.valueOf(m - 1);\n    }\n}\n```\n* 时间复杂度:$O(\\log^2{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.483` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/481-490/485. 最大连续 1 的个数（简单）.md", "url_title": "485. 最大连续 1 的个数", "url": "https://leetcode-cn.com/problems/max-consecutive-ones/solution/you-shi-yi-tian-gao-pin-jian-dan-ti-ni-d-avj1/", "difficulty": "简单", "tags": ["双指针"], "question": "给定一个二进制数组, 计算其中最大连续 1 的个数。\n\n示例:\n```\n输入:[1,1,0,1,1,1]\n输出:3\n解释:开头的两位和最后的三位都是连续 1 ,所以最大连续 1 的个数是 3.\n```\n\n提示:\n* 输入的数组只包含 0 和 1 。\n* 输入数组的长度是正整数,且不超过 10,000。", "solution": "### 双指针解法\n\n使用 `i` 和 `j` 分别代表连续 1 的左右边界。\n\n起始状态 `i == j`,当 `i` 到达第一个 1 的位置时,让 `j` 不断右移直到右边界。\n\n更新 `ans`\n\n```java\nclass Solution {\n    public int findMaxConsecutiveOnes(int[] nums) {\n        int n = nums.length;\n        int ans = 0;\n        for (int i = 0, j = 0; i < n; j = i) {\n            if (nums[i] == 1) {\n                while (j + 1 < n && nums[j + 1] == 1) j++;\n                ans = Math.max(ans, j - i + 1);\n                i = j + 1;\n            } else {\n                i++;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.485` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/481-490/488. 祖玛游戏（困难）.md", "url_title": "488. 祖玛游戏", "url": "https://leetcode-cn.com/problems/zuma-game/solution/gong-shui-san-xie-yi-ti-shuang-jie-sou-s-3ftb/", "difficulty": "困难", "tags": ["DFS", "搜索", "启发式搜索", "AStar 算法"], "question": "你正在参与祖玛游戏的一个变种。\n\n在这个祖玛游戏变体中,桌面上有 一排 彩球,每个球的颜色可能是:红色 `'R'`、黄色 `'Y'`、蓝色 `'B'`、绿色 `'G'` 或白色 `'W'` 。你的手中也有一些彩球。\n\n你的目标是 清空 桌面上所有的球。每一回合:\n\n* 从你手上的彩球中选出 任意一颗 ,然后将其插入桌面上那一排球中:两球之间或这一排球的任一端。\n* 接着,如果有出现 三个或者三个以上 且 颜色相同 的球相连的话,就把它们移除掉。\n\t* 如果这种移除操作同样导致出现三个或者三个以上且颜色相同的球相连,则可以继续移除这些球,直到不再满足移除条件。\n* 如果桌面上所有球都被移除,则认为你赢得本场游戏。\n* 重复这个过程,直到你赢了游戏或者手中没有更多的球。\n\n给你一个字符串 board ,表示桌面上最开始的那排球。另给你一个字符串 hand ,表示手里的彩球。请你按上述操作步骤移除掉桌上所有球,计算并返回所需的 最少 球数。如果不能移除桌上所有的球,返回 -1 。\n\n示例 1:\n```\n输入:board = \"WRRBBW\", hand = \"RB\"\n\n输出:-1\n\n解释:无法移除桌面上的所有球。可以得到的最好局面是:\n- 插入一个 'R' ,使桌面变为 WRRRBBW 。WRRRBBW -> WBBW\n- 插入一个 'B' ,使桌面变为 WBBBW 。WBBBW -> WW\n桌面上还剩着球,没有其他球可以插入。\n```\n示例 2:\n```\n输入:board = \"WWRRBBWW\", hand = \"WRBRW\"\n\n输出:2\n\n解释:要想清空桌面上的球,可以按下述步骤:\n- 插入一个 'R' ,使桌面变为 WWRRRBBWW 。WWRRRBBWW -> WWBBWW\n- 插入一个 'B' ,使桌面变为 WWBBBWW 。WWBBBWW -> WWWW -> empty\n只需从手中出 2 个球就可以清空桌面。\n```\n示例 3:\n```\n输入:board = \"G\", hand = \"GGGGG\"\n\n输出:2\n\n解释:要想清空桌面上的球,可以按下述步骤:\n- 插入一个 'G' ,使桌面变为 GG 。\n- 插入一个 'G' ,使桌面变为 GGG 。GGG -> empty\n只需从手中出 2 个球就可以清空桌面。\n```\n示例 4:\n```\n输入:board = \"RBYYBBRRB\", hand = \"YRBGB\"\n\n输出:3\n\n解释:要想清空桌面上的球,可以按下述步骤:\n- 插入一个 'Y' ,使桌面变为 RBYYYBBRRB 。RBYYYBBRRB -> RBBBRRB -> RRRB -> B\n- 插入一个 'B' ,使桌面变为 BB 。\n- 插入一个 'B' ,使桌面变为 BBB 。BBB -> empty\n只需从手中出 3 个球就可以清空桌面。\n```\n\n提示:\n* 1 <= board.length <= 16\n* 1 <= hand.length <= 5\n* board 和 hand 由字符 `'R'`、`'Y'`、`'B'`、`'G'` 和 `'W'` 组成\n* 桌面上一开始的球中,不会有三个及三个以上颜色相同且连着的球", "solution": "### 搜索 + 剪枝\n\n数据范围 $1 <= board.length <= 16$ 和 $1 <= hand.length <= 5$。\n\n为了方便,我们使用 $a$ 和 $b$ 来代指 $board$ 和 $hand$。\n\n但在爆搜过程中同时维持两个字符串构造会超时,考虑使用一个 `int` 来记录 $hand$ 的使用情况。\n\n代码:\n```Java\nclass Solution {\n    int INF = 0x3f3f3f3f;\n    String b;\n    int m;\n    Map<String, Integer> map = new HashMap<>();\n    public int findMinStep(String a, String _b) {\n        b = _b;\n        m = b.length();\n        int ans = dfs(a, 1 << m);\n        return ans == INF ? -1 : ans;\n    }\n    int dfs(String a, int cur) {\n        if (a.length() == 0) return 0;\n        String hashKey = a + \"_\" + cur;\n        if (map.containsKey(hashKey)) return map.get(hashKey);\n        int ans = INF;\n        int n = a.length();\n        for (int i = 0; i < m; i++) {\n            if (((cur >> i) & 1) == 1) continue;\n            int next = (1 << i) | cur;\n            for (int j = 0; j <= n; j++) {\n                boolean ok = false;\n                if (j > 0 && j < n && a.charAt(j) == a.charAt(j - 1) && a.charAt(j - 1) != b.charAt(i)) ok = true;\n                if (j < n && a.charAt(j) == b.charAt(i)) ok = true;\n                if (!ok) continue;\n                StringBuilder sb = new StringBuilder();\n                sb.append(a.substring(0, j)).append(b.substring(i, i + 1));\n                if (j != n) sb.append(a.substring(j));\n                int k = j;\n                while (0 <= k && k < sb.length()) {\n                    char c = sb.charAt(k);\n                    int l = k, r = k;\n                    while (l >= 0 && sb.charAt(l) == c) l--;\n                    while (r < sb.length() && sb.charAt(r) == c) r++;\n                    if (r - l - 1 >= 3) {\n                        sb.delete(l + 1, r);\n                        k = l >= 0 ? l : r; \n                    } else {\n                        break;\n                    }\n                }\n                ans = Math.min(ans, dfs(sb.toString(), next) + 1);\n            }\n        }\n        map.put(hashKey, ans);\n        return ans;\n    }\n}\n```\n* 时间复杂度:略。「爆搜」同时还得考虑「剪枝」的复杂度分析意义不大。\n* 空间复杂度:略\n\n---\n\n### AStar 算法\n\n我们建立一个类 `Node` 来代指当前搜索局面。\n\n```Java\nclass Node {\n    // 当前的棋盘状况\n    String a;\n    // cur 代表当前 hand 的使用情况(若 cur 二进制表示中的第 k 位为 1,代表 hand 的第 k 个彩球已被使用)\n    // val 代表「当前棋盘为 a」和「hand 使用情况为 cur」的情况下,至少还需要多少步才能将 a 全部消掉(启发式估算值)\n    // step 代表当前局面是经过多少步而来\n    int cur, val, step;\n    Node (String _a, int _c, int _v, int _s) {\n        a = _a;\n        cur = _c; val = _v; step = _s;\n    }\n}\n```\n\n显然,直接对此进行 `BFS`,会 TLE。\n\n我们考虑将优化 `BFS` 中使用到的队列改为优先队列:**更接近答案的局面先出队进行局面延展。**\n\n然后我们考虑如何设计 AStar 的启发式函数。\n\n**首先,一个合格的 AStar 启发式函数应当能够确保「估值不会小于理论最小距离」。同时由于启发式的估值函数是针对于最终状态进行估算,因此只确保最终状态的第一次出队时为最短路,其余中间状态的首次出队不一定是最短路,为此我们需要使用哈希表来记录中间状态的距离变化,如果某个局面的最短距离被更新,我们应当将其再次入队。**\n\n基于此,我们设计如下的 AStar 的启发式函数:使用哈希表来统计「当前的棋盘 $a$ 的彩球数量」&「当前手上拥有的彩球数量」,对「无解情况」和「理论最小次数」进行分析:\n\n * 对于某个彩球 $c$ 而言,如果当前棋盘的数量 + 手上的数量 都不足 $3$ 个,那么该局面往下搜索也必然无解,该局面无须入队;\n * 对于某个彩球 $c$ 而言,如果当前棋盘数量少于 $3$ 个,那么至少需要补充至 $3$ 个才能被消除,而缺少的个数则是「从手上彩球放入棋盘内」的次数,即对于彩球 $c$,我们理论上至少需要消耗 $3 - cnt$ 次($cnt$ 为当前棋盘拥有的彩球 $c$ 的数量)。\n\n需要注意的是:对于某个局面 $node$ 而言,最终的距离是由「已确定距离」+「估值距离」两部分组成,我们应当根据这两部分之和进行出队,才能确保算法的正确性。\n\n代码:\n```Java\nclass Solution {\n    class Node {\n        String a;\n        int cur, val, step;\n        Node (String _a, int _c, int _v, int _s) {\n            a = _a;\n            cur = _c; val = _v; step = _s;\n        }\n    }\n    int f(String a, int k) {\n        Map<Character, Integer> m1 = new HashMap<>(), m2 =  new HashMap<>();\n        for (int i = 0; i < a.length(); i++) {\n            m1.put(a.charAt(i), m1.getOrDefault(a.charAt(i), 0) + 1);\n        }\n        for (int i = 0; i < m; i++) {\n            if (((k >> i) & 1) == 0) m2.put(b.charAt(i), m2.getOrDefault(b.charAt(i), 0) + 1);\n        }\n        int ans = 0;\n        for (char c : m1.keySet()) {\n            int c1 = m1.get(c), c2 = m2.getOrDefault(c, 0);\n            if (c1 + c2 < 3) return INF;\n            if (c1 < 3) ans += (3 - c1);\n        }\n        return ans;\n    }\n\n    int INF = 0x3f3f3f3f;\n    String b;\n    int m;\n    Map<String, Integer> map = new HashMap<>();\n    public int findMinStep(String _a, String _b) {\n        b = _b;\n        m = b.length();\n        PriorityQueue<Node> q = new PriorityQueue<>((o1,o2)->(o1.val+o1.step)-(o2.val+o2.step));\n        q.add(new Node(_a, 1 << m, f(_a, 1 << m), 0));\n        map.put(_a + \"_\" + (1 << m), 0);\n        while (!q.isEmpty()) {\n            Node poll = q.poll();\n            String a = poll.a;\n            int cur = poll.cur;\n            int step = poll.step;\n            int n = a.length();\n            for (int i = 0; i < m; i++) {\n                if (((cur >> i) & 1) == 1) continue;\n                int next = (1 << i) | cur;\n                for (int j = 0; j <= n; j++) {\n                    boolean ok = false;\n                    if (j > 0 && j < n && a.charAt(j) == a.charAt(j - 1) && a.charAt(j - 1) != b.charAt(i)) ok = true;\n                    if (j < n && a.charAt(j) == b.charAt(i)) ok = true;\n                    if (!ok) continue;\n                    StringBuilder sb = new StringBuilder();\n                    sb.append(a.substring(0, j)).append(b.substring(i, i + 1));\n                    if (j != n) sb.append(a.substring(j));\n                    int k = j;\n                    while (0 <= k && k < sb.length()) {\n                        char c = sb.charAt(k);\n                        int l = k, r = k;\n                        while (l >= 0 && sb.charAt(l) == c) l--;\n                        while (r < sb.length() && sb.charAt(r) == c) r++;\n                        if (r - l - 1 >= 3) {\n                            sb.delete(l + 1, r);\n                            k = l >= 0 ? l : r; \n                        } else {\n                            break;\n                        }\n                    }\n                    String nextStr = sb.toString();\n                    if (nextStr.length() == 0) return step + 1;\n                    if (f(nextStr, next) == INF) continue;\n                    String hashKey = nextStr + \"_\" + next;\n                    if (!map.containsKey(hashKey) || map.get(hashKey) > step + 1) {\n                        map.put(hashKey, step + 1);\n                        q.add(new Node(nextStr, next, f(nextStr, next), step + 1));\n                    }\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:略。「爆搜」同时还得考虑「启发式加速」的复杂度分析意义不大。\n* 空间复杂度:略", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.488` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/491-500/492. 构造矩形（简单）.md", "url_title": "492. 构造矩形", "url": "https://leetcode-cn.com/problems/construct-the-rectangle/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-7ser/", "difficulty": "简单", "tags": ["模拟"], "question": "作为一位web开发者, 懂得怎样去规划一个页面的尺寸是很重要的。 现给定一个具体的矩形页面面积,你的任务是设计一个长度为 L 和宽度为 W 且满足以下要求的矩形的页面。要求:\n\n1. 你设计的矩形页面必须等于给定的目标面积。\n\n2. 宽度 W 不应大于长度 L,换言之,要求 L >= W 。\n\n3. 长度 L 和宽度 W 之间的差距应当尽可能小。\n\n你需要按顺序输出你设计的页面的长度 L 和宽度 W。\n\n示例:\n```\n输入: 4\n\n输出: [2, 2]\n\n解释: 目标面积是 4, 所有可能的构造方案有 [1,4], [2,2], [4,1]。\n但是根据要求2,[1,4] 不符合要求; 根据要求3,[2,2] 比 [4,1] 更能符合要求. 所以输出长度 L 为 2, 宽度 W 为 2。\n```\n\n说明:\n1. 给定的面积不大于 10,000,000 且为正整数。\n2. 你设计的页面的长度和宽度必须都是正整数。", "solution": "### 模拟 \n\n根据题意,从 $\\sqrt{area}$ 开始往后模拟,遇到第一个能够被整除的数值,则返回该答案。\n\n代码:\n```Java\nclass Solution {\n    public int[] constructRectangle(int area) {\n        for (int i = (int)(Math.sqrt(area)); ;i--) {\n            if (area % i == 0) return new int[]{area / i, i};\n        }\n    }\n}\n```\n* 时间复杂度:$O(\\sqrt{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.492` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/491-500/494. 目标和（中等）.md", "url_title": "494. 目标和", "url": "https://leetcode-cn.com/problems/target-sum/solution/gong-shui-san-xie-yi-ti-si-jie-dfs-ji-yi-et5b/", "difficulty": "中等", "tags": ["DFS", "记忆化搜索", "背包 DP", "01 背包"], "question": "给你一个整数数组 nums 和一个整数 target 。\n\n向数组中的每个整数前添加 '+' 或 '-' ,然后串联起所有整数,可以构造一个 表达式 :\n\n* 例如,nums = [2, 1] ,可以在 2 之前添加 '+' ,在 1 之前添加 '-' ,然后串联起来得到表达式 \"+2-1\" 。\n返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。\n\n示例 1:\n```\n输入:nums = [1,1,1,1,1], target = 3\n输出:5\n解释:一共有 5 种方法让最终目标和为 3 。\n-1 + 1 + 1 + 1 + 1 = 3\n+1 - 1 + 1 + 1 + 1 = 3\n+1 + 1 - 1 + 1 + 1 = 3\n+1 + 1 + 1 - 1 + 1 = 3\n+1 + 1 + 1 + 1 - 1 = 3\n```\n示例 2:\n```\n输入:nums = [1], target = 1\n输出:1\n```\n\n提示:\n* 1 <= nums.length <= 20\n* 0 <= nums[i] <= 1000\n* 0 <= sum(nums[i]) <= 100\n* -1000 <= target <= 100", "solution": "### DFS\n\n数据范围只有 $20$,而且每个数据只有 $+/-$ 两种选择,因此可以直接使用 DFS 进行「爆搜」。\n\n而 DFS 有「使用全局变量维护」和「接收返回值处理」两种形式。\n\n代码:\n```Java\nclass Solution {\n    public int findTargetSumWays(int[] nums, int t) {\n        return dfs(nums, t, 0, 0);\n    }\n    int dfs(int[] nums, int t, int u, int cur) {\n        if (u == nums.length) {\n            return cur == t ? 1 : 0;\n        }\n        int left = dfs(nums, t, u + 1, cur + nums[u]);\n        int right = dfs(nums, t, u + 1, cur - nums[u]);\n        return left + right;\n    }\n}\n```\n\n```Java\nclass Solution {\n    int ans = 0;\n    public int findTargetSumWays(int[] nums, int t) {\n        dfs(nums, t, 0, 0);\n        return ans;\n    }\n    void dfs(int[] nums, int t, int u, int cur) {\n        if (u == nums.length) {\n            ans += cur == t ? 1 : 0;\n            return;\n        }\n        dfs(nums, t, u + 1, cur + nums[u]);\n        dfs(nums, t, u + 1, cur - nums[u]);\n    }\n}\n```\n* 时间复杂度:$O(2^n)$\n* 空间复杂度:忽略递归带来的额外空间消耗。复杂度为 $O(1)$\n\n---\n\n### 记忆化搜索\n\n不难发现,在 DFS 的函数签名中只有「数值下标 `u`」和「当前结算结果 `cur`」为可变参数,考虑将其作为记忆化容器的两个维度,返回值作为记忆化容器的记录值。\n\n由于 `cur` 存在负权值,为了方便,我们这里不设计成静态数组,而是使用「哈希表」进行记录。\n\n以上分析都在 [(题解)403. 青蛙过河](https://leetcode-cn.com/problems/frog-jump/solution/gong-shui-san-xie-yi-ti-duo-jie-jiang-di-74fw/) 完整讲过。\n\n代码:\n```Java\nclass Solution {\n    public int findTargetSumWays(int[] nums, int t) {\n        return dfs(nums, t, 0, 0);\n    }\n    Map<String, Integer> cache = new HashMap<>();\n    int dfs(int[] nums, int t, int u, int cur) {\n        String key = u + \"_\" + cur;\n        if (cache.containsKey(key)) return cache.get(key);\n        if (u == nums.length) {\n            cache.put(key, cur == t ? 1 : 0);\n            return cache.get(key);\n        }\n        int left = dfs(nums, t, u + 1, cur + nums[u]);\n        int right = dfs(nums, t, u + 1, cur - nums[u]);\n        cache.put(key, left + right);\n        return cache.get(key);\n    }\n}\n```\n* 时间复杂度:$O(n * \\sum_{i = 0}^{n - 1} abs(nums[i]))$\n* 空间复杂度:忽略递归带来的额外空间消耗。复杂度为 $O(n * \\sum_{i = 0}^{n - 1} abs(nums[i]))$\n\n---\n\n### 动态规划\n\n能够以「递归」的形式实现动态规划(记忆化搜索),自然也能使用「递推」的方式进行实现。\n\n根据记忆化搜索的分析,我们可以定义:\n\n**$f[i][j]$ 代表考虑前 $i$ 个数,当前计算结果为 $j$ 的方案数,令 `nums` 下标从 $1$ 开始。**\n\n那么 $f[n][target]$ 为最终答案,$f[0][0] = 1$ 为初始条件:代表不考虑任何数,凑出计算结果为 $0$ 的方案数为 $1$ 种。\n\n根据每个数值只能搭配 $+/-$ 使用,可得状态转移方程:\n\n$$f[i][j] = f[i - 1][j - nums[i - 1]] + f[i - 1][j + nums[i - 1]]$$\n\n到这里,既有了「状态定义」和「转移方程」,又有了可以滚动下去的「有效值」(起始条件)。\n\n距离我们完成所有分析还差最后一步。\n\n当使用递推形式时,我们通常会使用「静态数组」来存储动规值,因此还需要考虑维度范围的:\n\n* 第一维为物品数量:范围为 `nums` 数组长度\n* 第二维为中间结果:令 `s` 为所有 `nums` 元素的总和(题目给定了 `nums[i]` 为非负数的条件,否则需要对 `nums[i]` 取绝对值再累加),那么中间结果的范围为 $[-s, s]$\n\n因此,我们可以确定动规数组的大小。**同时在转移时,对第二维度的使用做一个 `s` 的右偏移,以确保「负权值」也能够被合理计算/存储。**\n\n代码:\n```Java\nclass Solution {\n    public int findTargetSumWays(int[] nums, int t) {\n        int n = nums.length;\n        int s = 0;\n        for (int i : nums) s += Math.abs(i);\n        if (Math.abs(t) > s) return 0;\n        int[][] f = new int[n + 1][2 * s + 1];\n        f[0][0 + s] = 1;\n        for (int i = 1; i <= n; i++) {\n            int x = nums[i - 1];\n            for (int j = -s; j <= s; j++) {\n                if ((j - x) + s >= 0) f[i][j + s] += f[i - 1][(j - x) + s];\n                if ((j + x) + s <= 2 * s) f[i][j + s] += f[i - 1][(j + x) + s];\n            }\n        }\n        return f[n][t + s];\n    }\n}\n```\n* 时间复杂度:$O(n * \\sum_{i = 0}^{n - 1} abs(nums[i]))$\n* 空间复杂度:$O(n * \\sum_{i = 0}^{n - 1} abs(nums[i]))$\n\n---\n\n### 动态规划(优化)\n\n**在上述「动态规划」分析中,我们总是尝试将所有的状态值都计算出来,当中包含很多对「目标状态」不可达的“额外”状态值。**\n\n即达成某些状态后,不可能再回到我们的「目标状态」。\n\n例如当我们的 $target$ 不为 $-s$ 和 $s$ 时,$-s$ 和 $s$ 就是两个对「目标状态」不可达的“额外”状态值,到达 $-s$ 或 $s$ 已经使用所有数值,对 $target$ 不可达。\n\n那么我们如何规避掉这些“额外”状态值呢?\n\n我们可以从哪些数值使用哪种符号来分析,即划分为「负值部分」&「非负值部分」,令「负值部分」的绝对值总和为 $m$,即可得:\n\n$$(s - m) - m = s - 2 * m = target$$\n\n变形得:\n\n$$m = \\frac{s - target}{2}$$\n\n问题转换为:**只使用 $+$ 运算符,从 `nums` 凑出 $m$ 的方案数。**\n\n**这样「原问题的具体方案」和「转换问题的具体方案」具有一一对应关系:「转换问题」中凑出来的数值部分在实际计算中应用 $-$,剩余部分应用 $+$,从而实现凑出来原问题的 $target$ 值。**\n\n另外,由于 `nums` 均为非负整数,因此我们需要确保 $s - target$ 能够被 $2$ 整除。\n\n同时,由于问题转换为 **从 `nums` 中凑出 $m$ 的方案数,因此「状态定义」和「状态转移」都需要进行调整(01 背包求方案数):**\n\n**定义 $f[i][j]$ 为从 `nums` 凑出总和「恰好」为 $j$ 的方案数。**\n\n最终答案为 $f[n][m]$,$f[0][0] = 1$ 为起始条件:代表不考虑任何数,凑出计算结果为 $0$ 的方案数为 $1$ 种。\n\n每个数值有「选」和「不选」两种决策,转移方程为:\n\n$$f[i][j] = f[i - 1][j] + f[i - 1][j - nums[i - 1]]$$\n\n代码:\n```Java\nclass Solution {\n    public int findTargetSumWays(int[] nums, int t) {\n        int n = nums.length;\n        int s = 0;\n        for (int i : nums) s += Math.abs(i);\n        if (t > s || (s - t) % 2 != 0) return 0;\n        int m = (s - t) / 2;\n        int[][] f = new int[n + 1][m + 1];\n        f[0][0] = 1;\n        for (int i = 1; i <= n; i++) {\n            int x = nums[i - 1];\n            for (int j = 0; j <= m; j++) {\n                f[i][j] += f[i - 1][j];\n                if (j >= x) f[i][j] += f[i - 1][j - x];\n            }\n        }\n        return f[n][m];\n    }\n}\n```\n* 时间复杂度:$O(n * (\\sum_{i = 0}^{n - 1} abs(nums[i]) - target))$\n* 空间复杂度:$O(n * (\\sum_{i = 0}^{n - 1} abs(nums[i]) - target))$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.494` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/491-500/495. 提莫攻击（简单）.md", "url_title": "495. 提莫攻击", "url": "https://leetcode-cn.com/problems/teemo-attacking/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-gteh/", "difficulty": "简单", "tags": ["模拟"], "question": "在《英雄联盟》的世界中,有一个叫 “提莫” 的英雄。他的攻击可以让敌方英雄艾希(编者注:寒冰射手)进入中毒状态。\n\n当提莫攻击艾希,艾希的中毒状态正好持续 `duration` 秒。\n\n正式地讲,提莫在 `t` 发起发起攻击意味着艾希在时间区间 `[t, t + duration - 1]`(含 `t` 和 `t + duration - 1`)处于中毒状态。如果提莫在中毒影响结束 前 再次攻击,中毒状态计时器将会 重置 ,在新的攻击之后,中毒影响将会在 `duration` 秒后结束。\n\n给你一个 非递减 的整数数组 `timeSeries`,其中 `timeSeries[i]` 表示提莫在 `timeSeries[i]` 秒时对艾希发起攻击,以及一个表示中毒持续时间的整数 `duration`。\n\n返回艾希处于中毒状态的  **总** 秒数。\n\n示例 1:\n```\n输入:timeSeries = [1,4], duration = 2\n\n输出:4\n\n解释:提莫攻击对艾希的影响如下:\n- 第 1 秒,提莫攻击艾希并使其立即中毒。中毒状态会维持 2 秒,即第 1 秒和第 2 秒。\n- 第 4 秒,提莫再次攻击艾希,艾希中毒状态又持续 2 秒,即第 4 秒和第 5 秒。\n艾希在第 1、2、4、5 秒处于中毒状态,所以总中毒秒数是 4 。\n```\n示例 2:\n```\n输入:timeSeries = [1,2], duration = 2\n\n输出:3\n\n解释:提莫攻击对艾希的影响如下:\n- 第 1 秒,提莫攻击艾希并使其立即中毒。中毒状态会维持 2 秒,即第 1 秒和第 2 秒。\n- 第 2 秒,提莫再次攻击艾希,并重置中毒计时器,艾希中毒状态需要持续 2 秒,即第 2 秒和第 3 秒。\n艾希在第 1、2、3 秒处于中毒状态,所以总中毒秒数是 3 。\n```\n\n提示:\n* $1 <= timeSeries.length <= 10^4$\n* $0 <= timeSeries[i], duration <= 10^7$\n* timeSeries 按 非递减 顺序排列", "solution": "### 模拟\n\n题目已确保 $timeSeries$ 为非递减排序,按照顺序进行遍历处理即可。\n\n我们使用 $ans$ 统计答案,使用 $last$ 记录上一次攻击的结束点,对于任意的 $timeSeries[i]$ 而言,假设其发起点为 $s = timeSeries[i]$,结束点为 $e = s + duration - 1$,针对 $last$ 和 $s$ 进行分情况讨论即可:\n\n* $last < s$ :两次攻击不重合,则有 $ans += duration; last = e;$\n* $last >= s$ :两次攻击重合,则有 $ans += e - last; last = e$\n\n>注意:$last$ 作为上次的结束点,在处理 $timeSeries[i]$ 时,$last$ 是一个「已被统计」的存在,因此我们需要将其初始化为 $-1$(使用一个比 $0$ 小的数值作为哨兵),以确保当 $timeSeries[0] = 0$ 时,第 $0$ 秒能够被计数。\n\n代码:\n```Java\nclass Solution {\n    public int findPoisonedDuration(int[] timeSeries, int duration) {\n        int ans = 0, last = -1;\n        for (int s : timeSeries) {\n            int e = s + duration - 1;\n            ans += last < s ? duration : e - last;\n            last = e;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.495` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/491-500/496. 下一个更大元素 I（简单）.md", "url_title": "496. 下一个更大元素 I", "url": "https://leetcode-cn.com/problems/next-greater-element-i/solution/gong-shui-san-xie-yi-ti-shuang-jie-bian-n6nwz/", "difficulty": "简单", "tags": ["模拟", "单调栈", "哈希表"], "question": "给你两个 没有重复元素 的数组 `nums1` 和 `nums2`,其中 `nums1` 是 `nums2` 的子集。\n\n请你找出 `nums1` 中每个元素在 `nums2` 中的下一个比其大的值。\n\n`nums1` 中数字 `x` 的下一个更大元素是指 `x` 在 `nums2` 中对应位置的右边的第一个比 `x` 大的元素。如果不存在,对应位置输出 $-1$ 。\n\n示例 1:\n```\n输入: nums1 = [4,1,2], nums2 = [1,3,4,2].\n\n输出: [-1,3,-1]\n\n解释:\n对于 num1 中的数字 4 ,你无法在第二个数组中找到下一个更大的数字,因此输出 -1 。\n对于 num1 中的数字 1 ,第二个数组中数字1右边的下一个较大数字是 3 。\n对于 num1 中的数字 2 ,第二个数组中没有下一个更大的数字,因此输出 -1 。\n```\n示例 2:\n```\n输入: nums1 = [2,4], nums2 = [1,2,3,4].\n\n输出: [3,-1]\n\n解释:\n对于 num1 中的数字 2 ,第二个数组中的下一个较大数字是 3 。\n对于 num1 中的数字 4 ,第二个数组中没有下一个更大的数字,因此输出 -1 。\n```\n\n提示:\n* 1 <= nums1.length <= nums2.length <= 1000\n* 0 <= nums1[i], nums2[i] <= $10^4$\n* nums1和nums2中所有整数 互不相同\n* nums1 中的所有整数同样出现在 nums2 中", "solution": "### 模拟\n\n一个朴素的做法是直接根据题意进行模拟,对于每个 $ans[i]$ 而言,先找到 $nums1[i]$ 在 $nums2$ 的位置 $j$,然后接着往后找到最近一个比其大的数,如果 $j$ 走到结尾尚未出现合法的 $ans[i]$,则是 $-1$。\n\n代码:\n```Java\nclass Solution {\n    public int[] nextGreaterElement(int[] nums1, int[] nums2) {\n        int n = nums1.length, m = nums2.length;\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) {\n            int j = 0;\n            while (j < m && nums1[i] != nums2[j]) j++;\n            while (j < m && nums1[i] >= nums2[j]) j++;\n            ans[i] = j < m ? nums2[j] : -1;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n * m)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 单调栈\n\n当题目出现「找到最近一个比其大的元素」的字眼时,自然会想到「单调栈」。\n\n具体的,由于我们目标是找到某个数其在 $nums2$ 的右边中第一个比其大的数,因此我们可以对 $nums2$ 进行逆序遍历。\n\n我们在遍历 $nums2$ 时,实时维护一个单调栈,当我们遍历到元素 $nums2[i]$ 时,可以先将栈顶中比 $nums2[i]$ 小的元素出栈,最终结果有两种可能:\n\n1. 栈为空,说明 $nums2[i]$ 之前(右边)没有比其大的数;\n\n2. 栈不为空, 此时栈顶元素为 $nums2[i]$ 在 $nums2$ 中(右边)最近的比其大的数。\n\n再利用数组中数值各不相同,在遍历 $nums2$ 的同时,使用哈希表记录每个 $nums2[i]$ 对应目标值是多少即可。\n\n代码:\n```Java\nclass Solution {\n    public int[] nextGreaterElement(int[] nums1, int[] nums2) {\n        int n = nums1.length, m = nums2.length;\n        Deque<Integer> d = new ArrayDeque<>();\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = m - 1; i >= 0; i--) {\n            int x = nums2[i];\n            while (!d.isEmpty() && d.peekLast() <= x) d.pollLast();\n            map.put(x, d.isEmpty() ? -1 : d.peekLast());\n            d.addLast(x);\n        }\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) ans[i] = map.get(nums1[i]);\n        return ans;\n    }\n}\n```\n* 时间复杂度:维护单调栈,每个元素最多入栈出栈一次,复杂度为 $O(m)$;构造答案复杂度为 $O(n)$。整体复杂度为 $O(n + m)$\n* 空间复杂度:$O(m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.496` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/491-500/497. 非重叠矩形中的随机点（中等）.md", "url_title": "497. 非重叠矩形中的随机点", "url": "https://leetcode.cn/problems/random-point-in-non-overlapping-rectangles/solution/by-ac_oier-mhi6/", "difficulty": "中等", "tags": ["前缀和", "二分", "随机化"], "question": "给定一个由非重叠的轴对齐矩形的数组 `rects`,其中 $rects[i] = [a_i, b_i, x_i, y_i]$ 表示 $(a_i, b_i)$ 是第 $i$ 个矩形的左下角点,$(x_i, y_i)$ 是第 $i$ 个矩形的右上角点。\n\n设计一个算法来随机挑选一个被某一矩形覆盖的整数点。矩形周长上的点也算做是被矩形覆盖。所有满足要求的点必须等概率被返回。\n\n在给定的矩形覆盖的空间内的任何整数点都有可能被返回。\n\n请注意 ,整数点是具有整数坐标的点。\n\n实现 `Solution` 类:\n* `Solution(int[][] rects)` 用给定的矩形数组 `rects` 初始化对象。\n* `int[] pick()` 返回一个随机的整数点 $[u, v]$ 在给定的矩形所覆盖的空间内。\n\n示例 1:\n\n```\n输入: \n[\"Solution\", \"pick\", \"pick\", \"pick\", \"pick\", \"pick\"]\n[[[[-2, -2, 1, 1], [2, 2, 4, 6]]], [], [], [], [], []]\n\n输出: \n[null, [1, -2], [1, -1], [-1, -2], [-2, -2], [0, 0]]\n\n解释:\nSolution solution = new Solution([[-2, -2, 1, 1], [2, 2, 4, 6]]);\nsolution.pick(); // 返回 [1, -2]\nsolution.pick(); // 返回 [1, -1]\nsolution.pick(); // 返回 [-1, -2]\nsolution.pick(); // 返回 [-2, -2]\nsolution.pick(); // 返回 [0, 0]\n```\n\n提示:\n* $1 <= rects.length <= 100$\n* $rects[i].length == 4$\n* $-10^9 <= a_i < x_i <= 10^9$\n* $-10^9 <= b_i < y_i <= 10^9$\n* $x_i - a_i <= 2000$\n* $y_i - b_i <= 2000$\n* 所有的矩形不重叠。\n* `pick` 最多被调用 $10^4$ 次。", "solution": "### 前缀和 + 二分\n\n为了方便,我们使用 `rs` 来代指 `rects`,定义某个矩阵内整数点的数量为「面积」。\n\n一个朴素的想法是「先随机使用哪个矩形,再随机该矩形内的点」,其中后者是极其容易的,根据矩形特质,只需在该矩形的 `XY` 坐标范围内随机即可确保等概率,而前者(随机使用哪个矩形)为了确保是等概率,我们不能简单随机坐标,而需要结合面积来做。\n\n具体的,我们可以预处理前缀和数组 `sum`(前缀和数组下标默认从 $1$ 开始),其中 $sum[i]$ 代表前 $i$ 个矩形的面积之和(即下标范围 $[0, i - 1]$ 的面积总和),最终 $sum[n]$ 为所有矩形的总面积,我们可以在 $[1, sum[n]]$ 范围内随机,假定随机到的值为 $val$,然后利用 `sum` 数组的具有单调性,进行「二分」,找到 $val$ 所在的矩形(每个矩形均会贡献面积,可看做是每个矩形在数轴 $[1, sum[n]]$ 内贡献一段长度为面积的连续段,我们二分是为了找到点 $val$ 所在的连续段是由哪个矩形所贡献),然后在该矩形中进行随机,得到最终的随机点。\n\n代码:\n```Java\nclass Solution {\n    int[][] rs;\n    int[] sum;\n    int n;\n    Random random = new Random();\n    public Solution(int[][] rects) {\n        rs = rects;\n        n = rs.length;\n        sum = new int[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (rs[i - 1][2] - rs[i - 1][0] + 1) * (rs[i - 1][3] - rs[i - 1][1] + 1);\n    }\n    public int[] pick() {\n        int val = random.nextInt(sum[n]) + 1;\n        int l = 0, r = n;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (sum[mid] >= val) r = mid;\n            else l = mid + 1;\n        }\n        int[] cur = rs[r - 1];\n        int x = random.nextInt(cur[2] - cur[0] + 1) + cur[0], y = random.nextInt(cur[3] - cur[1] + 1) + cur[1];\n        return new int[]{x, y};\n    }\n}\n```\n* 时间复杂度:令 $n$ 为给定的 `rs` 数组长度。初始化 `Solution` 时需要预处理前缀和数组,复杂度为 $O(n)$;每次 `pick` 时需要在矩形个数 $n$ 范围内进行二分,复杂度为 $O(\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.497` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/491-500/498. 对角线遍历（中等）.md", "url_title": "498. 对角线遍历", "url": "https://leetcode.cn/problems/diagonal-traverse/solution/by-ac_oier-yw5x/", "difficulty": "中等", "tags": ["模拟"], "question": "给你一个大小为 `m x n` 的矩阵 `mat`,请以对角线遍历的顺序,用一个数组返回这个矩阵中的所有元素。\n\n示例 1:\n\n```\n输入:mat = [[1,2,3],[4,5,6],[7,8,9]]\n\n输出:[1,2,4,7,5,3,6,8,9]\n```\n示例 2:\n```\n输入:mat = [[1,2],[3,4]]\n\n输出:[1,2,3,4]\n```\n\n提示:\n* $m == mat.length$\n* $n == mat[i].length$\n* $1 <= m, n <= 10^4$\n* $1 <= m \\times n <= 10^4$\n* $-10^5 <= mat[i][j] <= 10^5$", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n为了方便,令 `mat` 为 `g`,记 `g` 的行和宽分别为 $n$ 和 $m$。当前所在位置为 $(x, y)$,遍历方向使用 $dir$ 代指(当 $dir = 1$ 代表往右上方进行遍历,当 $dir = -1$ 代表往左下方进行遍历),使用 $idx$ 记录当前处理到的答案下标。\n\n每次除了将当前格子放入答案(`ans[idx++]=g[x][y]`)以外,还需要结合 $dir$ 找到当前位置的右上方格子 $(x - 1, y + 1)$ 或是左下方格子 $(x + 1, y - 1)$,若下一目标位置「越界」并且还没搜索完整个矩阵,我们需要根据优先级来找「下一个发起点」的位置,并且翻转遍历方向。\n\n具体的找「下一个发起点」的优先级为:\n\n* 若当前遍历方向为往右上角,即 $dir = 1$,优先找 $(x, y + 1)$ 作为下一发起点,若越界,则找 $(x + 1, y)$ 作为下一发起点;\n* 若当前遍历方向为往左下角,即 $dir = -1$,优先找 $(x + 1, y)$ 作为下一发起点,若越界,则找 $(x, y + 1)$ 作为下一发起点。\n\n代码:\n```Java\nclass Solution {\n    public int[] findDiagonalOrder(int[][] g) {\n        int n = g.length, m = g[0].length, cnt = n * m;\n        int[] ans = new int[cnt];\n        int x = 0, y = 0, dir = 1, idx = 0;\n        while (idx != cnt) {\n            ans[idx++] = g[x][y];\n            int nx = x, ny = y;\n            if (dir == 1) {\n                nx = x - 1; ny = y + 1;\n            } else {\n                nx = x + 1; ny = y - 1;\n            }\n            if (idx < cnt && (nx < 0 || nx >= n || ny < 0 || ny >= m)) {\n                if (dir == 1) {\n                    nx = y + 1 < m ? x : x + 1;\n                    ny = y + 1 < m ? y + 1 : y;\n                } else {\n                    nx = x + 1 < n ? x + 1 : x;\n                    ny = x + 1 < n ? y : y + 1;\n                }\n                dir *= -1;\n            }\n            x = nx; y = ny;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.498` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/491-500/500. 键盘行（简单）.md", "url_title": "500. 键盘行", "url": "https://leetcode-cn.com/problems/keyboard-row/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-zx6b/", "difficulty": "简单", "tags": ["模拟", "哈希表"], "question": "给你一个字符串数组 `words`,只返回可以使用在 美式键盘 同一行的字母打印出来的单词。键盘如下图所示。\n\n美式键盘 中:\n\n* 第一行由字符 `\"qwertyuiop\"` 组成。\n* 第二行由字符 `\"asdfghjkl\"` 组成。\n* 第三行由字符 `\"zxcvbnm\"` 组成。\n\n示例 1:\n```\n输入:words = [\"Hello\",\"Alaska\",\"Dad\",\"Peace\"]\n\n输出:[\"Alaska\",\"Dad\"]\n```\n示例 2:\n```\n输入:words = [\"omk\"]\n\n输出:[]\n```\n示例 3:\n```\n输入:words = [\"adsdf\",\"sfd\"]\n\n输出:[\"adsdf\",\"sfd\"]\n```\n\n提示:\n* 1 <= words.length <= 20\n* 1 <= words[i].length <= 100\n* words[i] 由英文字母(小写和大写字母)组成", "solution": "### 模拟\n\n根据题意,进行模拟即可。\n\n先将键盘上的三行字母进行打表分类,依次检查 $words$ 中的单词中的每个字符是否都属于同一编号,若属于同一编号,则将其单词加入答案。\n\n代码:\n```Java\nclass Solution {\n    static String[] ss = new String[]{\"qwertyuiop\", \"asdfghjkl\", \"zxcvbnm\"};\n    static int[] hash = new int[26];\n    static {\n        for (int i = 0; i < ss.length; i++) {\n            for (char c : ss[i].toCharArray()) hash[c - 'a'] = i;\n        }\n    }\n    public String[] findWords(String[] words) {\n        List<String> list = new ArrayList<>();\n        out:for (String w : words) {\n            int t = -1;\n            for (char c : w.toCharArray()) {\n                c = Character.toLowerCase(c);\n                if (t == -1) t = hash[c - 'a'];\n                else if (t != hash[c - 'a']) continue out;\n            }\n            list.add(w);\n        }\n        return list.toArray(new String[list.size()]);\n    }\n}\n```\n* 时间复杂度:$O(\\sum_{i = 0}^{n - 1} words[i].length)$\n* 空间复杂度:`toCharArray` 会拷贝新数组,不使用 `toCharArray`,使用 `charAt` 的话,复杂度为 $O(C)$,$C$ 为常数,固定为 $26$;否则复杂度为 $O(\\sum_{i = 0}^{n - 1} words[i].length)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.500` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/501-510/502. IPO（困难）.md", "url_title": "502. IPO", "url": "https://leetcode-cn.com/problems/next-greater-element-ii/solution/cong-po-su-jie-fa-de-jiao-du-qu-li-jie-d-trht/", "difficulty": "困难", "tags": ["贪心", "优先队列(堆)"], "question": "假设 力扣(LeetCode)即将开始 IPO 。\n\n为了以更高的价格将股票卖给风险投资公司,力扣 希望在 IPO 之前开展一些项目以增加其资本。 \n\n由于资源有限,它只能在 IPO 之前完成最多 k 个不同的项目。\n\n帮助 力扣 设计完成最多 k 个不同项目后得到最大总资本的方式。\n\n给你 n 个项目。对于每个项目 i ,它都有一个纯利润 profits[i] ,和启动该项目需要的最小资本 capital[i] 。\n\n最初,你的资本为 w 。当你完成一个项目时,你将获得纯利润,且利润将被添加到你的总资本中。\n\n总而言之,从给定项目中选择 最多 k 个不同项目的列表,以 最大化最终资本 ,并输出最终可获得的最多资本。\n\n答案保证在 32 位有符号整数范围内。\n\n示例 1:\n```\n输入:k = 2, w = 0, profits = [1,2,3], capital = [0,1,1]\n\n输出:4\n\n解释:\n由于你的初始资本为 0,你仅可以从 0 号项目开始。\n在完成后,你将获得 1 的利润,你的总资本将变为 1。\n此时你可以选择开始 1 号或 2 号项目。\n由于你最多可以选择两个项目,所以你需要完成 2 号项目以获得最大的资本。\n因此,输出最后最大化的资本,为 0 + 1 + 3 = 4。\n```\n示例 2:\n```\n输入:k = 3, w = 0, profits = [1,2,3], capital = [0,1,2]\n\n输出:6\n```\n\n提示:\n* 1 <= k <= $10^5$\n* 0 <= w <= $10^9$\n* n == profits.length\n* n == capital.length\n* 1 <= n <= $10^5$\n* 0 <= profits[i] <= $10^4$\n* 0 <= capital[i] <= $10^9$", "solution": "### 贪心 + 优先队列(堆)\n\n由于每完成一个任务都会使得总资金 `w` 增加或不变。因此对于所选的第 $i$ 个任务而言,应该在所有「未被选择」且启动资金不超过 `w` 的所有任务里面选利润最大的。\n\n**可通过「归纳法」证明每次都在所有候选中选择利润最大的任务,可使得总资金最大。**\n\n对于第 $i$ 次选择而言(当前所有的资金为 $w$),如果选择的任务利润为 $cur$,而实际可选的最大任务利润为 $max$( $cur <= max$ )。\n\n将「选择 $cur$」调整为「选择 $max$」,结果不会变差:\n\n1. 根据传递性,由 $cur <= max$ 可得 $w + cur <= w + max$,可推导出调整后的总资金不会变少;\n2. 利用推论 $1$,由于总资金相比调整前没有变少,因此后面可选择的任务集合也不会变少。这意味着 **至少可以维持** 第 $i$ 次选择之后的所有原有选择。\n\n至此,我们证明了将每次的选择调整为选择最大利润的任务,结果不会变差。\n\n**当知道了「每次都应该在所有可选择的任务里选利润最大」的推论之后,再看看算法的具体流程。**\n\n由于每完成一个任务总资金都会 增大/不变,因此所能覆盖的任务集合数量也随之 增加/不变 。\n\n因此算法核心为「**每次决策前,将启动资金不超过当前总资金的任务加入集合,再在里面取利润最大的任务**」。\n\n**「取最大」的过程可以使用优先队列(根据利润排序的大根堆),而「将启动资金不超过当前总资金的任务加入集合」的操作,可以利用总资金在整个处理过程递增,而先对所有任务进行预处理排序来实现。**\n\n具体的,我们可以按照如下流程求解:\n\n1. 根据 `profits` 和 `capital` 预处理出总的任务集合二元组,并根据「启动资金」进行升序排序;\n\n2. 每次决策前,将所有的启动资金不超过 $w$ 的任务加入优先队列(根据利润排序的大根堆),然后从优先队列(根据利润排序的大根堆),将利润累加到 $w$;\n\n3. 循环步骤 $2$,直到达到 $k$ 个任务,或者队列为空(当前资金不足以选任何任务)。\n\n代码:\n\n```Java\nclass Solution {\n    public int findMaximizedCapital(int k, int w, int[] profits, int[] capital) {\n        int n = profits.length;\n        List<int[]> list = new ArrayList<>();\n        for (int i = 0; i < n; i++) {\n            list.add(new int[]{capital[i], profits[i]});\n        }\n        Collections.sort(list, (a,b)->a[0]-b[0]);\n        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);\n        int i = 0;\n        while (k-- > 0) {\n            while (i < n && list.get(i)[0] <= w) q.add(list.get(i++)[1]);\n            if (q.isEmpty()) break;\n            w += q.poll();\n        }\n        return w;\n    }\n}\n```\n* 时间复杂度:构造出二元组数组并排序的复杂度为 $O(n\\log{n})$;大根堆最多有 $n$ 个元素,使用大根堆计算答案的复杂度为 $O(k\\log{n})$。整体复杂度为 $O(\\max(n\\log{n}, k\\log{n}))$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.502` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/501-510/503. 下一个更大元素 II（中等）.md", "url_title": "503. 下一个更大元素 II", "url": "https://leetcode-cn.com/problems/next-greater-element-ii/solution/cong-po-su-jie-fa-de-jiao-du-qu-li-jie-d-trht/", "difficulty": "中等", "tags": ["单调栈"], "question": "给定一个循环数组(最后一个元素的下一个元素是数组的第一个元素),输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序,这个数字之后的第一个比它更大的数,这意味着你应该循环地搜索它的下一个更大的数。如果不存在,则输出 -1。\n\n示例 1:\n```\n输入: [1,2,1]\n输出: [2,-1,2]\n解释: 第一个 1 的下一个更大的数是 2;\n数字 2 找不到下一个更大的数; \n第二个 1 的下一个最大的数需要循环搜索,结果也是 2。\n```", "solution": "### 单调栈解法\n\n对于「找最近一个比当前值大/小」的问题,都可以使用单调栈来解决。\n\n单调栈就是在栈的基础上维护一个栈内元素单调。\n\n在理解单调栈之前,我们先回想一下「朴素解法」是如何解决这个问题的。\n\n对于每个数而言,我们需要遍历其右边的数,直到找到比自身大的数,这是一个 $O(n^2)$ 的做法。\n\n**之所以是 $O(n^2)$,是因为每次找下一个最大值,我们是通过「主动」遍历来实现的。**\n\n而如果使用的是单调栈的话,可以做到 $O(n)$ 的复杂度,我们**将当前还没得到答案的下标暂存于栈内,从而实现「被动」更新答案。**\n\n也就是说,栈内存放的永远是还没更新答案的下标。\n\n具体的做法是:\n\n每次将当前遍历到的下标存入栈内,**将当前下标存入栈内前,检查一下当前值是否能够作为栈内位置的答案(即成为栈内位置的「下一个更大的元素」),如果可以,则将栈内下标弹出。**\n\n如此一来,我们便实现了「被动」更新答案,同时由于我们的弹栈和出栈逻辑,决定了我们**整个过程中栈内元素单调**。    \n\n还有一些编码细节,由于我们要找每一个元素的下一个更大的值,因此我们需要对原数组遍历两次,对遍历下标进行取余转换。\n\n以及因为栈内存放的是还没更新答案的下标,可能会有位置会一直留在栈内(最大值的位置),因此我们要在处理前预设答案为 -1。而从实现那些没有下一个更大元素(不出栈)的位置的答案是 -1。\n\n代码:\n```java\nclass Solution {\n    public int[] nextGreaterElements(int[] nums) {\n        int n = nums.length;\n        int[] ans = new int[n];\n        Arrays.fill(ans, -1);\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n * 2; i++) {\n            while (!d.isEmpty() && nums[i % n] > nums[d.peekLast()]) {\n                int u = d.pollLast();\n                ans[u] = nums[i % n];\n            }\n            d.addLast(i % n);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 卡常小技巧\n\n本题不需要用到这个技巧,但是还是介绍一下,可作为拓展。\n\n我们可以使用静态数组来模拟栈,这样我们的代码将会更快一点:\n\n```java\nclass Solution {\n    public int[] nextGreaterElements(int[] nums) {\n        int n = nums.length;\n        int[] ans = new int[n];\n        Arrays.fill(ans, -1);\n        // 使用数组模拟栈,hh 代表栈底,tt 代表栈顶\n        int[] d = new int[n * 2];\n        int hh = 0, tt = -1;\n        for (int i = 0; i < n * 2; i++) {\n            while (hh <= tt && nums[i % n] > nums[d[tt]]) {\n                int u = d[tt--];\n                ans[u] = nums[i % n];\n            }\n            d[++tt] = i % n;\n        }\n        return ans;\n    }\n}\n```\n\n***\n\n### 总结\n\n要从逻辑上去理解为什么能用「单调栈」解决问题:\n\n1. 我们希望将 $O(n^2)$ 算法优化为 $O(n)$ 算法,因此需要将「主动」获取答案转换为「被动」更新\n2. 我们需要使用数据结构保持那些「尚未更新」的位置下标,由于题目要求的是找「下一个更大的元素」,因此使用栈来保存\n3. 「被动」更新答案的逻辑导致了我们栈内元素单调", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.501` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/501-510/504. 七进制数（简单）.md", "url_title": "504. 七进制数", "url": "https://leetcode-cn.com/problems/base-7/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-2759/", "difficulty": "简单", "tags": ["模拟"], "question": "给定一个整数 `num`,将其转化为 $7$ 进制,并以字符串形式输出。\n\n示例 1:\n```\n输入: num = 100\n\n输出: \"202\"\n```\n示例 2:\n```\n输入: num = -7\n\n输出: \"-10\"\n```\n\n提示:\n* $-10^7 <= num <= 10^7$", "solution": "### 模拟\n\n今天是个特别的日子,可惜是个简单题 QWQ\n\n按照通用的进制转换方式进行模拟即可。\n\n代码:\n```Java\nclass Solution {\n    public String convertToBase7(int n) {\n        boolean flag = n < 0;\n        if (flag) n = -n;\n        StringBuilder sb = new StringBuilder();\n        do {\n            sb.append(n % 7);\n            n /= 7;\n        } while (n != 0);\n        sb.reverse();\n        return flag ? \"-\" + sb.toString() : sb.toString();\n    }\n}\n```\n* 时间复杂度:$O(\\log{|n|})$\n* 空间复杂度:$O(\\log{|n|})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.504` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/501-510/506. 相对名次（简单）.md", "url_title": "506. 相对名次", "url": "https://leetcode-cn.com/problems/relative-ranks/solution/gong-shui-san-xie-jian-dan-pai-xu-mo-ni-cmuzj/", "difficulty": "简单", "tags": ["排序", "模拟"], "question": "给你一个长度为 `n` 的整数数组 `score`,其中 `score[i]` 是第 $i$ 位运动员在比赛中的得分。所有得分都**互不相同**。\n\n运动员将根据得分**决定名次**,其中名次第 `1` 的运动员得分最高,名次第 `2` 的运动员得分第 `2` 高,依此类推。运动员的名次决定了他们的获奖情况:\n* 名次第 `1` 的运动员获金牌 `\"Gold Medal\"` 。\n* 名次第 `2` 的运动员获银牌 `\"Silver Medal\"`。\n* 名次第 `3` 的运动员获铜牌 `\"Bronze Medal\"`。\n* 从名次第 `4` 到第 `n` 的运动员,只能获得他们的名次编号(即,名次第 x 的运动员获得编号 `\"x\"`)。\n\n使用长度为 `n` 的数组 `answer` 返回获奖,其中 `answer[i]` 是第 `i` 位运动员的获奖情况。\n\n示例 1:\n```\n输入:score = [5,4,3,2,1]\n\n输出:[\"Gold Medal\",\"Silver Medal\",\"Bronze Medal\",\"4\",\"5\"]\n\n解释:名次为 [1st, 2nd, 3rd, 4th, 5th] 。\n```\n示例 2:\n```\n输入:score = [10,3,8,9,4]\n\n输出:[\"Gold Medal\",\"5\",\"Bronze Medal\",\"Silver Medal\",\"4\"]\n\n解释:名次为 [1st, 5th, 3rd, 2nd, 4th] 。\n```\n\n提示:\n* $n == score.length$\n* $1 <= n <= 10^4$\n* $0 <= score[i] <= 10^6$\n* $score$ 中的所有值 互不相同", "solution": "### 模拟\n\n根据题意,我们可以先对 `score` 数组进行拷贝并排序,利用分数各不相同,对排序数组中分值进行名次编号(存入哈希表),再利用名次编号构造答案。\n\n代码:\n```Java\nclass Solution {\n    String[] ss = new String[]{\"Gold Medal\", \"Silver Medal\", \"Bronze Medal\"};\n    public String[] findRelativeRanks(int[] score) {\n        int n = score.length;\n        String[] ans = new String[n];\n        int[] clone = score.clone();\n        Arrays.sort(clone);\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = n - 1; i >= 0; i--) map.put(clone[i], n - 1 - i);\n        for (int i = 0; i < n; i++) {\n            int rank = map.get(score[i]);\n            ans[i] = rank < 3 ? ss[rank] : String.valueOf(rank + 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:拷贝 `score` 数组的复杂度为 $O(n)$;对拷贝数组进行排序的复杂度为 $O(n\\log{n})$;构造哈希表的复杂度为 $O(n)$;利用哈希表构造答案复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.506` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/501-510/507. 完美数（简单）.md", "url_title": "507. 完美数", "url": "https://leetcode-cn.com/problems/perfect-number/solution/gong-shui-san-xie-jian-dan-mo-ni-tong-ji-e6jk/", "difficulty": "简单", "tags": ["模拟", "数论", "数学"], "question": "对于一个 正整数,如果它和除了它自身以外的所有 **正因子** 之和相等,我们称它为 「完美数」。\n\n给定一个 整数 `n`, 如果是完美数,返回 `true`,否则返回 `false`。\n\n示例 1:\n```\n输入:num = 28\n\n输出:true\n\n解释:28 = 1 + 2 + 4 + 7 + 14\n1, 2, 4, 7, 和 14 是 28 的所有正因子。\n```\n示例 2:\n```\n输入:num = 6\n\n输出:true\n```\n示例 3:\n```\n输入:num = 496\n\n输出:true\n```\n示例 4:\n```\n输入:num = 8128\n\n输出:true\n```\n示例 5:\n```\n输入:num = 2\n\n输出:false\n```\n\n提示:\n* $1 <= num <= 10^8$", "solution": "### 数学\n\n我们知道正因数总是成对的出现,因此我们可以仅枚举每对正因数的较小数,即从 $[1, \\sqrt{num}]$ 范围内进行枚举(其中 $nums > 1$)。\n\n同时为避免使用 `sqrt` 库函数和溢出,使用 $i <= \\frac{num}{i}$ 作为上界判断。\n\n代码:\n```Java\nclass Solution {\n    public boolean checkPerfectNumber(int num) {\n        if (num == 1) return false;\n        int ans = 1;\n        for (int i = 2; i <= num / i; i++) {\n            if (num % i == 0) {\n                ans += i;\n                if (i * i != num) ans += num / i;\n            }\n        }\n        return ans == num;\n    }\n}\n```\n* 时间复杂度:$O(\\sqrt{num})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.507` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/501-510/508. 出现次数最多的子树元素和（中等）.md", "url_title": "508. 出现次数最多的子树元素和", "url": "https://leetcode.cn/problems/most-frequent-subtree-sum/solution/by-ac_oier-t3y4/", "difficulty": "中等", "tags": ["树的遍历", "DFS", "哈希表"], "question": "给你一个二叉树的根结点 `root`,请返回出现次数最多的子树元素和。如果有多个元素出现的次数相同,返回所有出现次数最多的子树元素和(不限顺序)。\n\n一个结点的 「子树元素和」 定义为以该结点为根的二叉树上所有结点的元素之和(包括结点本身)。\n\n示例 1:\n\n```\n输入: root = [5,2,-3]\n\n输出: [2,-3,4]\n```\n示例 2:\n\n```\n输入: root = [5,2,-5]\n\n输出: [2]\n```\n\n提示:\n* 节点数在 $[1, 10^4]$ 范围内\n* $-10^5 <= Node.val <= 10^5$", "solution": "### DFS\n\n使用 `DFS` 对树进行遍历,同时将每棵子树的总和值存入哈希表(以元素和为 `key`,出现次数为 `value`),并实时维护最大子树和,使用变量 `max` 存储。\n\n当遍历完整棵树后,将哈希表中值为 `max` 的键存入答案。\n\n代码:\n```Java\nclass Solution {\n    Map<Integer, Integer> map = new HashMap<>();\n    int max = 0;\n    public int[] findFrequentTreeSum(TreeNode root) {\n        dfs(root);\n        List<Integer> list = new ArrayList<>();\n        for (int k : map.keySet()) {\n            if (map.get(k) == max) list.add(k);\n        }\n        int n = list.size();\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) ans[i] = list.get(i);\n        return ans;\n    }\n    int dfs(TreeNode root) {\n        if (root == null) return 0;\n        int cur = root.val + dfs(root.left) + dfs(root.right);\n        map.put(cur, map.getOrDefault(cur, 0) + 1);\n        max = Math.max(max, map.get(cur));\n        return cur;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.508` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/51-60/53. 最大子数组和（中等）.md", "url_title": "53. 最大子数组和", "url": "https://leetcode.cn/problems/maximum-subarray/solutions/2534027/gong-shui-san-xie-cong-on-de-chang-gui-l-22hq/", "difficulty": "中等", "tags": ["前缀和", "区间求和问题", "线性 DP", "分治"], "question": "给你一个整数数组 `nums`,请你找出一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。\n\n子数组是数组中的一个连续部分。\n\n示例 1:\n```\n输入:nums = [-2,1,-3,4,-1,2,1,-5,4]\n\n输出:6\n\n解释:连续子数组 [4,-1,2,1] 的和最大,为 6 。\n```\n示例 2:\n```\n输入:nums = [1]\n\n输出:1\n```\n示例 3:\n```\n输入:nums = [5,4,-1,7,8]\n\n输出:23\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $-10^4 <= nums[i] <= 10^4$\n\n进阶:如果你已经实现复杂度为 $O(n)$ 的解法,尝试使用更为精妙的分治法求解。", "solution": "### 前缀和 or 线性 DP\n\n当要我们求「连续段」区域和的时候,要很自然的想到「前缀和」。\n\n所谓前缀和,是指对原数组“累计和”的描述,通常是指一个与原数组等长的数组。\n\n设前缀和数组为 `sum`,**`sum` 的每一位记录的是从「起始位置」到「当前位置」的元素和**。例如 $sum[x]$ 是指原数组中“起始位置”到“位置 `x`”这一连续段的元素和。\n\n有了前缀和数组 `sum`,当我们求连续段 $[i, j]$ 的区域和时,利用「容斥原理」,便可进行快速求解。\n\n通用公式:`ans = sum[j] - sum[i - 1]`。\n\n由于涉及 `-1` 操作,为减少边界处理,我们可让前缀和数组下标从 $1$ 开始。在进行快速求和时,再根据原数组下标是否从 $1$ 开始,决定是否进行相应的下标偏移。\n\n学习完一维前缀和后,回到本题。\n\n先用 `nums` 预处理出前缀和数组 `sum`,然后在遍历子数组右端点 `j` 的过程中,通过变量 `m` 动态记录已访问的左端点 `i` 的前缀和最小值。最终,在所有 `sum[j] - m` 的取值中选取最大值作为答案。\n\n代码实现上,我们无需明确计算前缀和数组 `sum`,而是使用变量 `s` 表示当前累计的前缀和(充当右端点),并利用变量 `m` 记录已访问的前缀和的最小值(充当左端点)即可。\n\n**本题除了将其看作为「前缀和裸题用有限变量进行空间优化」以外,还能以「线性 DP」角度进行理解。**\n\n定义 $f[i]$ 为考虑前 $i$ 个元素,且第 $nums[i]$ 必选的情况下,形成子数组的最大和。\n\n不难发现,仅考虑前 $i$ 个元素,且 $nums[i]$ 必然参与的子数组中。要么是 $nums[i]$ 自己一个成为子数组,要么与前面的元素共同组成子数组。\n\n因此,状态转移方程:\n$$\nf[i] = \\max(f[i - 1] + nums[i], nums[i])\n$$\n\n由于 $f[i]$ 仅依赖于 $f[i - 1]$ 进行转移,可使用有限变量进行优化,因此写出来的代码也是和上述前缀和角度分析的类似。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxSubArray(int[] nums) {\n        int s = 0, m = 0, ans = -10010;\n        for (int x : nums) {\n            s += x;\n            ans = Math.max(ans, s - m);\n            m = Math.min(m, s);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxSubArray(vector<int>& nums) {\n        int s = 0, m = 0, ans = -10010;\n        for (int x : nums) {\n            s += x;\n            ans = max(ans, s - m);\n            m = min(m, s);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxSubArray(self, nums: List[int]) -> int:\n        s, m, ans = 0, 0, -10010\n        for x in nums:\n            s += x\n            ans = max(ans, s - m)\n            m = min(m, s)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction maxSubArray(nums: number[]): number {\n    let s = 0, m = 0, ans = -10010;\n    for (let x of nums) {\n        s += x;\n        ans = Math.max(ans, s - m);\n        m = Math.min(m, s);\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 分治\n\n“分治法”的核心思路是将大问题拆分成更小且相似的子问题,通过递归解决这些子问题,最终合并子问题的解来得到原问题的解。\n\n实现分治,关键在于对“递归函数”的设计(入参 & 返回值)。\n\n在涉及数组的分治题中,左右下标 `l` 和 `r` 必然会作为函数入参,因为它能用于表示当前所处理的区间,即小问题的范围。\n\n对于本题,仅将最大子数组和(答案)作为返回值并不足够,因为单纯从小区间的解无法直接推导出大区间的解,我们需要一些额外信息来辅助求解。\n\n具体的,我们可以将返回值设计成四元组,分别代表 `区间和`,`前缀最大值`,`后缀最大值` 和 `最大子数组和`,用 `[sum, lm, rm, max]` 表示。\n\n有了完整的函数签名 `int[] dfs(int[] nums, int l, int r)`,考虑如何实现分治:\n\n1. 根据当前区间 $[l, r]$ 的长度进行分情况讨论:\n   1. 若 $l = r$,只有一个元素,区间和为 $nums[l]$,而 最大子数组和、前缀最大值 和 后缀最大值 由于允许“空数组”,因此均为 $\\max(nums[l], 0)$\n   2. 否则,将当前问题划分为两个子问题,通常会划分为两个相同大小的子问题,划分为 $[l, mid]$ 和 $[mid + 1, r]$ 两份,递归求解,其中 $mid = \\left \\lfloor \\frac{l + r}2{} \\right \\rfloor$\n\n随后考虑如何用“子问题”的解合并成“原问题”的解:\n\n1. **合并区间和 (`sum`):** 当前问题的区间和等于左右两个子问题的区间和之和,即 `sum = left[0] + right[0]`。\n2. **合并前缀最大值 (`lm`):** 当前问题的前缀最大值可以是左子问题的前缀最大值,或者左子问题的区间和加上右子问题的前缀最大值。即 `lm = max(left[1], left[0] + right[1])`。\n3. **合并后缀最大值 (`rm`):** 当前问题的后缀最大值可以是右子问题的后缀最大值,或者右子问题的区间和加上左子问题的后缀最大值。即 `rm = max(right[2], right[0] + left[2])`。\n4. **合并最大子数组和 (`max`):** 当前问题的最大子数组和可能出现在左子问题、右子问题,或者跨越左右两个子问题的边界。因此,`max` 可以通过 `max(left[3], right[3], left[2] + right[1])` 来得到。\n\n一些细节:由于我们在计算 `lm`、`rm` 和 `max` 的时候允许数组为空,而答案对子数组的要求是至少包含一个元素。因此对于 `nums` 全为负数的情况,我们会错误得出最大子数组和为 `0` 的答案。针对该情况,需特殊处理,遍历一遍 `nums`,若最大值为负数,直接返回最大值。\n\nJava 代码:\n\n```Java\nclass Solution {\n    // 返回值: [sum, lm, rm, max] = [区间和, 前缀最大值, 后缀最大值, 最大子数组和]\n    int[] dfs(int[] nums, int l, int r) {\n        if (l == r) {\n            int t = Math.max(nums[l], 0);\n            return new int[]{nums[l], t, t, t};\n        }\n        // 划分成两个子区间,分别求解\n        int mid = l + r >> 1;\n        int[] left = dfs(nums, l, mid), right = dfs(nums, mid + 1, r);\n        // 组合左右子区间的信息,得到当前区间的信息\n        int[] ans = new int[4];\n        ans[0] = left[0] + right[0]; // 当前区间和\n        ans[1] = Math.max(left[1], left[0] + right[1]); // 当前区间前缀最大值\n        ans[2] = Math.max(right[2], right[0] + left[2]); // 当前区间后缀最大值\n        ans[3] = Math.max(Math.max(left[3], right[3]), left[2] + right[1]); // 最大子数组和\n        return ans;\n    }\n    public int maxSubArray(int[] nums) {\n        int m = nums[0];\n        for (int x : nums) m = Math.max(m, x);\n        if (m <= 0) return m;\n        return dfs(nums, 0, nums.length - 1)[3];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    // 返回值: [sum, lm, rm, max] = [区间和, 前缀最大值, 后缀最大值, 最大子数组和]\n    vector<int> dfs(vector<int>& nums, int l, int r) {\n        if (l == r) {\n            int t = max(nums[l], 0);\n            return {nums[l], t, t, t};\n        }\n        // 划分成两个子区间,分别求解\n        int mid = l + r >> 1;\n        auto left = dfs(nums, l, mid), right = dfs(nums, mid + 1, r);\n        // 组合左右子区间的信息,得到当前区间的信息\n        vector<int> ans(4);\n        ans[0] = left[0] + right[0]; // 当前区间和\n        ans[1] = max(left[1], left[0] + right[1]); // 当前区间前缀最大值\n        ans[2] = max(right[2], right[0] + left[2]); // 当前区间后缀最大值\n        ans[3] = max({left[3], right[3], left[2] + right[1]}); // 最大子数组和\n        return ans;\n    }\n    int maxSubArray(vector<int>& nums) {\n        int m = nums[0];\n        for (int x : nums) m = max(m, x);\n        if (m <= 0) return m;\n        return dfs(nums, 0, nums.size() - 1)[3];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxSubArray(self, nums: List[int]) -> int:\n        def dfs(l, r):\n            if l == r:\n                t = max(nums[l], 0)\n                return [nums[l], t, t, t]\n            # 划分成两个子区间,分别求解\n            mid = (l + r) // 2\n            left, right = dfs(l, mid), dfs(mid + 1, r)\n            # 组合左右子区间的信息,得到当前区间的信息\n            ans = [0] * 4\n            ans[0] = left[0] + right[0] # 当前区间和\n            ans[1] = max(left[1], left[0] + right[1]) # 当前区间前缀最大值\n            ans[2] = max(right[2], right[0] + left[2]) # 当前区间后缀最大值\n            ans[3] = max(left[3], right[3], left[2] + right[1]) # 最大子数组和\n            return ans\n        \n        m = max(nums)\n        if m <= 0:\n            return m\n        return dfs(0, len(nums) - 1)[3]\n```\nTypeScript 代码:\n```TypeScript\nfunction maxSubArray(nums: number[]): number {\n    const dfs = function (l: number, r: number): number[] {\n        if (l == r) {\n            const t = Math.max(nums[l], 0);\n            return [nums[l], t, t, t];\n        }\n        // 划分成两个子区间,分别求解\n        const mid = (l + r) >> 1;\n        const left = dfs(l, mid), right = dfs(mid + 1, r);\n        // 组合左右子区间的信息,得到当前区间的信息\n        const ans = Array(4).fill(0);\n        ans[0] = left[0] + right[0]; // 当前区间和\n        ans[1] = Math.max(left[1], left[0] + right[1]); // 当前区间前缀最大值\n        ans[2] = Math.max(right[2], right[0] + left[2]); // 当前区间后缀最大值\n        ans[3] = Math.max(left[3], right[3], left[2] + right[1]); // 最大子数组和\n        return ans;\n    }\n    \n    const m = Math.max(...nums);\n    if (m <= 0) return m;\n    return dfs(0, nums.length - 1)[3];\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.53` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/51-60/54. 螺旋矩阵（中等）.md", "url_title": "59. 螺旋矩阵", "url": "https://leetcode-cn.com/problems/spiral-matrix/solution/xiang-jie-xing-zhuang-jie-fa-fang-xiang-3qmhf/", "difficulty": "中等", "tags": ["模拟"], "question": "给你一个 $m$ 行 $n$ 列的矩阵 `matrix`,请按照顺时针螺旋顺序,返回矩阵中的所有元素。\n\n示例 1:\n\n```\n输入:matrix = [[1,2,3],[4,5,6],[7,8,9]]\n\n输出:[1,2,3,6,9,8,7,4,5]\n```\n示例 2:\n\n```\n输入:matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]\n\n输出:[1,2,3,4,8,12,11,10,9,5,6,7]\n```\n\n提示:\n* $m == matrix.length$\n* $n == matrix[i].length$\n* $1 <= m, n <= 10$\n* $-100 <= matrix[i][j] <= 100$", "solution": "### 按照「形状」进行模拟\n\n我们可以按「圈」进行划分打印。\n\n使用「左上角」$(x1,y1)$ &「右下角」$(x2,y2)$ 来确定某个「圈」,进行打印。\n\n完成后,令「左上角」&「右下角」往里收,分别得到 $(x1 + 1, y1 + 1)$ 和 $(x2 - 1, y2 - 1)$,执行相同的打印规则。\n\n代码 :\n```Java\nclass Solution {\n    public List<Integer> spiralOrder(int[][] mat) {\n        List<Integer> ans = new ArrayList<>();\n        int m = mat.length, n = mat[0].length;\n        circle(mat, 0, 0, m - 1, n - 1, ans);\n        return ans;\n    }\n    \n    // 遍历 以 (x1, y1) 作为左上角,(x2, y2) 作为右下角形成的「圈」\n    void circle(int[][] mat, int x1, int y1, int x2, int y2, List<Integer> ans) {\n        if (x2 < x1 || y2 < y1) return;\n        // 只有一行时,按「行」遍历\n        if (x1 == x2) {\n            for (int i = y1; i <= y2; i++) ans.add(mat[x1][i]);\n            return;\n        }\n        // 只有一列时,按「列」遍历\n        if (y1 == y2) {\n            for (int i = x1; i <= x2; i++) ans.add(mat[i][y2]);\n            return;\n        }\n        // 遍历当前「圈」\n        for (int i = y1; i < y2; i++) ans.add(mat[x1][i]);\n        for (int i = x1; i < x2; i++) ans.add(mat[i][y2]);\n        for (int i = y2; i > y1; i--) ans.add(mat[x2][i]);\n        for (int i = x2; i > x1; i--) ans.add(mat[i][y1]);\n        // 往里收一圈,继续遍历\n        circle(mat, x1 + 1, y1 + 1, x2 - 1, y2 - 1, ans);\n    }\n}\n```\n* 时间复杂度:$O(n * m)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 按照「方向」进行模拟\n\n事实上,我们还可以根据「方向」进行模拟。\n\n因为每一圈的打印输出都是按照特定的「四个方向」进行的。\n\n这种解法更为简洁。而触发方向转换的时机:\n\n1. 下一步发生位置溢出\n2. 回到了本圈的起点\n\n代码:\n```Java\nclass Solution {\n    int INF = 101;\n    public List<Integer> spiralOrder(int[][] mat) {\n        List<Integer> ans = new ArrayList<>();\n        int m = mat.length, n = mat[0].length;\n        // 定义四个方向\n        int[][] dirs = new int[][]{{0,1},{1,0},{0,-1},{-1,0}};\n        for (int x = 0, y = 0, d = 0, i = 0; i < m * n; i++) {\n            ans.add(mat[x][y]);\n            mat[x][y] = INF;\n            // 下一步要到达的位置\n            int nx = x + dirs[d][0], ny = y + dirs[d][1];\n            // 如果下一步发生「溢出」或者已经访问过(说明四个方向已经走过一次)\n            if (nx < 0 || nx >= m || ny < 0 || ny >= n || mat[nx][ny] == INF) {\n                d = (d + 1) % 4;\n                nx = x + dirs[d][0]; ny = y + dirs[d][1];\n            }\n            x = nx; y = ny;\n        }\n        return ans;\n    }\n}\n```\n\n-\n\n```C++\nclass Solution {\npublic:\n    const int dir[4][2] = {{0,1}, {1,0},{0,-1},{-1,0}};\n    vector<int> spiralOrder(vector<vector<int>>& matrix) {\n        int idx = 0, m = matrix.size(), n = matrix[0].size();\n        vector<int> res;\n        for(int x = 0, y = 0, d = 0; idx < m * n; idx++){\n            res.push_back(matrix[x][y]);\n            matrix[x][y] = 101; \n            int t_x = x + dir[d][0], t_y = y + dir[d][1];\n            if(t_x < 0 or t_x >= m or t_y < 0 or t_y >= n or matrix[t_x][t_y] == 101){\n                d = (d + 1) % 4;\n                t_x = x + dir[d][0],t_y = y + dir[d][1];\n            }\n            x = t_x, y = t_y;\n        }\n        return res;\n    }\n};\n```\n* 时间复杂度:$O(n * m)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.54` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/51-60/58. 最后一个单词的长度（简单）.md", "url_title": "58. 最后一个单词的长度", "url": "https://leetcode-cn.com/problems/length-of-last-word/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-tt6t/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个字符串 `s`,由若干单词组成,单词前后用一些空格字符隔开。返回字符串中最后一个单词的长度。\n\n**单词**是指仅由字母组成、不包含任何空格字符的最大子字符串。\n\n示例 1:\n```\n输入:s = \"Hello World\"\n\n输出:5\n```\n示例 2:\n```\n输入:s = \"   fly me   to   the moon  \"\n\n输出:4\n```\n示例 3:\n```\n输入:s = \"luffy is still joyboy\"\n\n输出:6\n```\n\n提示:\n* 1 <= s.length <= $10^4$\n* s 仅有英文字母和空格 ' ' 组成\n* s 中至少存在一个单词", "solution": "### 模拟\n\n根据题意,我们可以「从后往前」对字符串进行遍历,使用两个指针 $i$ 和 $j$ 来代指最后一个单词的范围($i$ 最终会指向目标单词首个字符的前一个字符,$j$ 最终会指向目标单词的最后一个字符),最终 $j - i$ 即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int lengthOfLastWord(String s) {\n        int n = s.length();\n        int j = n - 1;\n        while (j >= 0 && s.charAt(j) == ' ') j--;\n        int i = j;\n        while (i >= 0 && s.charAt(i) != ' ') i--;\n        return j - i;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.58` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/51-60/59. 螺旋矩阵 II（中等）.md", "url_title": "59. 螺旋矩阵 II", "url": "https://leetcode-cn.com/problems/spiral-matrix-ii/solution/yi-ti-shuang-jie-xiang-jie-xing-zhuang-j-24x8/", "difficulty": "中等", "tags": ["模拟"], "question": "给你一个正整数 $n$ ,生成一个包含 $1$ 到 $n^2$ 所有元素,且元素按顺时针顺序螺旋排列的 `n x n` 正方形矩阵 `matrix` 。\n\n示例 1:\n```\n输入:n = 3\n\n输出:[[1,2,3],[8,9,4],[7,6,5]]\n```\n示例 2:\n```\n输入:n = 1\n\n输出:[[1]]\n```\n\n提示:\n* $1 <= n <= 20$", "solution": "### 按照「形状」进行模拟\n\n我们可以按「圈」进行构建。\n\n使用「左上角」$(x1,y1)$ &「右下角」$(x2,y2)$ 来确定某个「圈」,进行构建。\n\n完成后,令「左上角」&「右下角」往里收,分别得到 $(x1 + 1, y1 + 1)$ 和 $(x2 - 1, y2 - 1)$,执行相同的构建规则。\n\n代码:\n```Java\nclass Solution {\n    public int[][] generateMatrix(int n) {\n        int[][] ans = new int[n][n];\n        circle(0, 0, n - 1, n - 1, 1, ans);\n        return ans;\n    }\n    void circle(int x1, int y1, int x2, int y2, int start, int[][] ans) {\n        if (x2 < x1 || y2 < y1) return ;\n        if (x1 == x2) {\n            ans[x1][y1] = start;\n            return;\n        }\n        int val = start;\n        for (int i = y1; i < y2; i++) ans[x1][i] = val++;\n        for (int i = x1; i < x2; i++) ans[i][y2] = val++;\n        for (int i = y2; i > y1; i--) ans[x2][i] = val++;\n        for (int i = x2; i > x1; i--) ans[i][y1] = val++;\n        circle(x1 + 1, y1 + 1, x2 - 1, y2 - 1, val, ans); \n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 按照「方向」进行模拟\n\n事实上,我们还可以根据「方向」进行模拟。\n\n因为每一圈的构建都是按照特定的「四个方向」进行的。\n\n这种解法更为简洁。而触发方向转换的时机:\n\n1. 下一步发生位置溢出\n2. 回到了本圈的起点\n\n代码:\n```Java\nclass Solution {\n    public int[][] generateMatrix(int n) {\n        int[][] ans = new int[n][n];\n        // 定义四个方向\n        int[][] dirs = new int[][]{{0,1},{1,0},{0,-1},{-1,0}};\n        for (int x = 0, y = 0, d = 0, i = 1; i <= n * n; i++) {\n            ans[x][y] = i;\n            // 下一步要到达的位置\n            int nx = x + dirs[d][0], ny = y + dirs[d][1];\n            // 如果下一步发生「溢出」或者已经访问过(说明四个方向已经走过一次)\n            if (nx < 0 || nx >= n || ny < 0 || ny >= n || ans[nx][ny] != 0) {\n                d = (d + 1) % 4;\n                nx = x + dirs[d][0]; ny = y + dirs[d][1];\n            }\n            x = nx; y = ny;\n        }\n        return ans;\n    }\n}\n```\n\n-\n\n```C++\nclass Solution {\npublic:\n    const int dir[4][2] = { {0,1},{1,0},{0,-1},{-1,0}};\n    vector<vector<int>> generateMatrix(int n) {\n        vector<vector<int>> res(n,vector<int>(n,0));\n        for(int i = 1, x = 0, y = 0, d = 0; i <= n * n; i++){\n            res[x][y] = i;\n            int t_x = x + dir[d][0],t_y = y + dir[d][1];\n            if(t_x < 0 or t_x >= n or t_y < 0 or t_y >= n or res[t_x][t_y] != 0){\n                d = (d + 1) % 4;\n                t_x = x + dir[d][0],t_y = y + dir[d][1];\n            }\n            x = t_x, y = t_y;\n        }\n        return res;\n    }\n};\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.59` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/511-520/513. 找树左下角的值（中等）.md", "url_title": "513. 找树左下角的值", "url": "https://leetcode.cn/problems/find-bottom-left-tree-value/solution/by-ac_oier-sv59/", "difficulty": "中等", "tags": ["BFS", "DFS", "树的遍历"], "question": "给定一个二叉树的 根节点 `root`,请找出该二叉树的 最底层 最左边 节点的值。\n\n假设二叉树中至少有一个节点。\n\n示例 1:\n\n```\n输入: root = [2,1,3]\n\n输出: 1\n```\n示例 2:\n\n```\n输入: [1,2,3,4,null,5,6,null,null,7]\n\n输出: 7\n```\n\n提示:\n* 二叉树的节点个数的范围是 $[1,10^4]$\n* $-2^{31} <= Node.val <= 2^{31} - 1$", "solution": "### BFS\n\n使用 `BFS` 进行「层序遍历」,每次用当前层的首个节点来更新 `ans`,当 `BFS` 结束后,`ans` 存储的是最后一层最靠左的节点。\n\n代码:\n```Java\nclass Solution {\n    public int findBottomLeftValue(TreeNode root) {\n        Deque<TreeNode> d = new ArrayDeque<>();\n        d.addLast(root);\n        int ans = 0;\n        while (!d.isEmpty()) {\n            int sz = d.size();\n            ans = d.peek().val;\n            while (sz-- > 0) {\n                TreeNode poll = d.pollFirst();\n                if (poll.left != null) d.addLast(poll.left);\n                if (poll.right != null) d.addLast(poll.right);\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:最坏情况下所有节点都在同一层,复杂度为 $O(n)$\n\n---\n\n### DFS\n\n同理,可以使用 `DFS`  进行树的遍历,每次优先 `DFS` 当前节点的左子树,每次第一次搜索到当前深度 `depth` 时,必然是当前深度的最左节点,此时用当前节点值来更新 `ans`。\n\n代码:\n```Java\nclass Solution {\n    int max, ans;\n    public int findBottomLeftValue(TreeNode root) {\n        dfs(root, 1);\n        return ans;\n    }\n    void dfs(TreeNode root, int depth) {\n        if (root == null) return ;\n        if (depth > max) {\n            max = depth; ans = root.val;\n        }\n        dfs(root.left, depth + 1);\n        dfs(root.right, depth + 1);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:最坏情况下退化成链,递归深度为 $n$。复杂度为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.513` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/511-520/515. 在每个树行中找最大值（中等）.md", "url_title": "515. 在每个树行中找最大值", "url": "https://leetcode.cn/problems/find-largest-value-in-each-tree-row/solution/by-ac_oier-vc06/", "difficulty": "中等", "tags": ["DFS", "BFS"], "question": "给定一棵二叉树的根节点 `root`,请找出该二叉树中每一层的最大值。\n\n示例1:\n\n```\n输入: root = [1,3,2,5,3,null,9]\n\n输出: [1,3,9]\n```\n示例2:\n```\n输入: root = [1,2,3]\n\n输出: [1,3]\n```\n\n提示:\n* 二叉树的节点个数的范围是 $[0,10^4]$\n* $-2^{31} <= Node.val <= 2^{31} - 1$", "solution": "### BFS\n\n使用 `BFS` 进行层序遍历,单次 `BFS` 逻辑将整一层的元素进行出队,维护当前层的最大值,并将最大值加入答案。\n\n代码:\n```Java\nclass Solution {\n    public List<Integer> largestValues(TreeNode root) {\n        List<Integer> ans = new ArrayList<>();\n        if (root == null) return ans;\n        Deque<TreeNode> d = new ArrayDeque<>();\n        d.addLast(root);\n        while (!d.isEmpty()) {\n            int sz = d.size(), max = d.peek().val;\n            while (sz-- > 0) {\n                TreeNode node = d.pollFirst();\n                max = Math.max(max, node.val);\n                if (node.left != null) d.addLast(node.left);\n                if (node.right != null) d.addLast(node.right);\n            }\n            ans.add(max);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### DFS\n\n同理,可以借助 `DFS` 进行求解,在 `DFS` 整棵树时,同时传递一个当前层深度 `depth`,使用「哈希表」维护所有深度的最大节点值,同时使用变量 `max` 记录最大深度。\n\n结束 `DFS` 后,使用哈希表构造答案。\n\n代码:\n```Java\nclass Solution {\n    int max = 0;\n    Map<Integer, Integer> map = new HashMap<>();\n    public List<Integer> largestValues(TreeNode root) {\n        List<Integer> ans = new ArrayList<>();\n        dfs(root, 1);\n        for (int i = 1; i <= max; i++) ans.add(map.get(i));\n        return ans;\n    }\n    void dfs(TreeNode node, int depth) {\n        if (node == null) return ;\n        max = Math.max(max, depth);\n        map.put(depth, Math.max(map.getOrDefault(depth, Integer.MIN_VALUE), node.val));\n        dfs(node.left, depth + 1);\n        dfs(node.right, depth + 1);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.515` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/511-520/516. 最长回文子序列（中等）.md", "url_title": "516. 最长回文子序列", "url": "https://leetcode-cn.com/problems/longest-palindromic-subsequence/solution/gong-shui-san-xie-qu-jian-dp-qiu-jie-zui-h2ya/", "difficulty": "中等", "tags": ["动态规划", "区间 DP"], "question": "给你一个字符串 `s` ,找出其中最长的回文子序列,并返回该序列的长度。\n\n子序列定义为:不改变剩余字符顺序的情况下,删除某些字符或者不删除任何字符形成的一个序列。\n\n示例 1:\n```\n输入:s = \"bbbab\"\n\n输出:4\n\n解释:一个可能的最长回文子序列为 \"bbbb\" 。\n```\n示例 2:\n```\n输入:s = \"cbbd\"\n\n输出:2\n\n解释:一个可能的最长回文子序列为 \"bb\" 。\n```\n\n提示:\n* $1 <= s.length <= 1000$\n* `s` 仅由小写英文字母组成", "solution": "### 动态规划\n\n这是一道经典的区间 DP 题。\n\n**之所以可以使用区间 DP 进行求解,是因为在给定一个回文串的基础上,如果在回文串的边缘分别添加两个新的字符,可以通过判断两字符是否相等来得知新串是否回文。**\n\n也就是说,使用小区间的回文状态可以推导出大区间的回文状态值。\n\n**从图论意义出发就是,任何一个长度为 $len$ 的回文串,必然由「长度为 $len - 1$」或「长度为 $len - 2$」的回文串转移而来。**\n\n**两个具有公共回文部分的回文串之间存在拓扑序(存在由「长度较小」回文串指向「长度较大」回文串的有向边)。**\n\n通常区间 DP 问题都是,常见的基本流程为:\n\n1. 从小到大枚举区间大小 $len$\n2. 枚举区间左端点 $l$,同时根据区间大小 $len$ 和左端点计算出区间右端点 $r = l + len - 1$\n3. 通过状态转移方程求 $f[l][r]$ 的值\n\n因此,我们 **定义 $f[l][r]$ 为考虑区间 $[l, r]$ 的最长回文子序列长度为多少。**\n\n不失一般性的考虑 $f[l][r]$ 该如何转移。\n\n由于我们的状态定义 **没有限制** 回文串中必须要选 $s[l]$ 或者 $s[r]$。\n\n我们对边界字符 $s[l]$ 和 $s[r]$ 分情况讨论,最终的 $f[l][r]$ 应该在如下几种方案中取 $max$ :\n\n* 形成的回文串一定不包含 $s[l]$ 和 $s[r]$,即完全不考虑 $s[l]$ 和 $s[r]$:\n$$\nf[l][r] = f[l + 1][r - 1]\n$$\n\n* 形成的回文串可能包含 $s[l]$,但一定不包含 $s[r]$:\n\n$$\nf[l][r] = f[l][r - 1]\n$$\n\n* 形成的回文串可能包含 $s[r]$,但一定不包含 $s[l]$:\n\n$$\nf[l][r] = f[l + 1][r]\n$$\n\n* 形成的回文串可能包含 $s[l]$,也可能包含 $s[r]$,根据 $s[l]$ 和 $s[r]$ 是否相等:\n\n$$\nf[l][r] = \\begin{cases}\nf[l + 1][r - 1] + 2 & s[l] = s[r] \\\\\nf[l + 1][r - 1] & s[l] \\neq s[r] \\\\\n\\end{cases}\n$$\n\n需要说明的是,上述几种情况可以确保我们做到「不漏」,但不能确保「不重」,对于求最值问题,我们只需要确保「不漏」即可,某些状态重复参与比较,不会影响结果的正确性。\n\n> 一些细节:我们需要特判掉长度为 $1$ 和 $2$ 的两种基本情况。当长度为 $1$ 时,必然回文,当长度为 $2$ 时,当且仅当两字符相等时回文。\n\n代码:\n```Java\nclass Solution {\n    public int longestPalindromeSubseq(String s) {\n        int n = s.length();\n        char[] cs = s.toCharArray();\n        int[][] f = new int[n][n]; \n        for (int len = 1; len <= n; len++) {\n            for (int l = 0; l + len - 1 < n; l++) {\n                int r = l + len - 1;\n                if (len == 1) {\n                    f[l][r] = 1;\n                } else if (len == 2) {\n                    f[l][r] = cs[l] == cs[r] ? 2 : 1;\n                } else {\n                    f[l][r] = Math.max(f[l + 1][r], f[l][r - 1]);\n                    f[l][r] = Math.max(f[l][r], f[l + 1][r - 1] + (cs[l] == cs[r] ? 2 : 0));\n                }\n            }\n        }\n        return f[0][n - 1];\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.516` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/511-520/517. 超级洗衣机（困难）.md", "url_title": "517. 超级洗衣机", "url": "https://leetcode-cn.com/problems/super-washing-machines/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-mzqia/", "difficulty": "困难", "tags": ["贪心"], "question": "假设有 `n` 台超级洗衣机放在同一排上。开始的时候,每台洗衣机内可能有一定量的衣服,也可能是空的。\n\n在每一步操作中,你可以选择任意 `m` (`1 <= m <= n`) 台洗衣机,与此同时将每台洗衣机的一件衣服送到相邻的一台洗衣机。\n\n给定一个整数数组 `machines` 代表从左至右每台洗衣机中的衣物数量,请给出能让所有洗衣机中剩下的衣物的数量相等的 最少的操作步数 。如果不能使每台洗衣机中衣物的数量相等,则返回 `-1` 。\n\n示例 1:\n```\n输入:machines = [1,0,5]\n\n输出:3\n\n解释:\n第一步:    1     0 <-- 5    =>    1     1     4\n第二步:    1 <-- 1 <-- 4    =>    2     1     3    \n第三步:    2     1 <-- 3    =>    2     2     2   \n```\n示例 2:\n```\n输入:machines = [0,3,0]\n\n输出:2\n\n解释:\n第一步:    0 <-- 3     0    =>    1     2     0    \n第二步:    1     2 --> 0    =>    1     1     1     \n```\n示例 3:\n```\n输入:machines = [0,2,0]\n\n输出:-1\n\n解释:\n不可能让所有三个洗衣机同时剩下相同数量的衣物。\n```\n\n提示:\n* $n = machines.length$\n* $1 <= n <= 10^4$\n* $0 <= machines[i] <= 10^5$", "solution": "### 基本分析\n\n由于最终是要让所有洗衣机衣服相等,因此无解的情况很好分析,如果衣服数量 $sum$ 不能整除洗衣机数量 $n$ 的话,则返回 $-1$,否则必然有解(最坏情况下,每次只移动一件衣服,也可以使得衣服均分),要求最小移动次数。\n\n由于每次操作都可以选任意台机器进行,不难猜想到最小移动次数为 **所有机器的「最小运输衣服数量」中的最大值**。\n\n计算某台洗衣机的「最小运输衣服数量」为经过当前机器的衣服数量(每次只能运输一件衣服),其值等于「起始左边衣服总量 与 最终左边衣服总量 的差值」+「起始右边衣服总量 与 最终右边衣服总量 的差值」,这里的差值都需要与 $0$ 取 $\\max$ 代指缺少衣服的数量(因为如果是多余数量的话,可以通过同时传输来满足增加缺少的一边,减少多余的一边)。\n\n我们猜想取所有机器中的「最小操作次数」的最大值即是答案。\n\n**但这显然是理论的最小操作次数,我们来证明最终答案等于该值。**\n\n假设理论最下操作次数为 $cnt$,真实答案为 $ans$,那么天然有 $ans \\geq cnt$,我们需要通过证明 $ans \\leq cnt$ 恒成立,来得证 $ans = cnt$。\n\n可以通过「反证法」来证明 $ans \\leq cnt$ 恒成立,假设 $ans > cnt$,即在某个特定序列中,实际最小操作次数 $ans$ 大于 $cnt$,假定我们是在位置 $x$ 中取得这个实际最小操作次数。\n\n那么我们需要思考:**在没有无效传输的前提,什么情况下需要在 $x$ 位置传输大于 $cnt$ 件衣服来达到最终平衡。**\n\n> 注:无效的意思是,衣服从位置 $x$ 的一边传到另外一边,随后又传输回来。\n\n(注 1)当且仅当位置 $x$ 本身衣服为 $0$ 时,会发生该种情况。\n\n也就是说首次传输,并没有实现「从 $x$ 左边往右边传输衣服」或者「从 $x$ 右边往左边传输衣服」的目的,而是需要先往位置 $x$ 填送衣服。\n\n那么是否可能由起始衣服为 $0$ 的位置来取得 $ans$ 呢?我们通过「反证法」来证明「$ans$ 不可能由衣服为 $0$ 的起始位置得出」。\n\n由于位置 $x$ 的起始数量为 $0$,那么位置 $x$ 必然至少有一侧的起始数量小于最终数量的(缺少衣服的),可以继续利用「反证法」来证明:\n\n* 如果是两边都多于最终数量,说明最终是两边衣服流向位置 $x$,而且我们得到的 $ans$ 是两边的缺少总和,这种情况下得到的 $ans$ 为 $0$,但是整体衣服本身不相等,必然要消耗步数,必然不为 $0$,因此该情况不存在。\n\n既然位置 $x$ 至少有一侧的起始数量小于最终数量的(缺少衣服的),那么自然我们可以将位置 $x$ 归到那一边,使得那一侧缺少衣服的数量更多,从而使答案 $ans$ 更大。这与 $ans$ 为所有位置中的「最小操作次数」最大的位置矛盾。\n\n**得证,取得 $ans$ 的位置 $x$ 起始衣服必然不为 $0$。**\n\n如果位置 $x$ 起始衣服必然不为 $0$,那么(注 1)的条件不成立,则 $ans > cnt$ 恒不成立,得证 $ans \\leq cnt$ 恒成立。\n\n**至此,我们通过三次「反证法」来证明了结论成立。首先通过「反证法」证明取得 $ans$ 的位置 $x$ 衣服不可能为 $0$;然后根据该位置起始衣服不为 $0$ 的前提条件,来证明 $ans > cnt$ 恒不成立,得证 $ans \\leq cnt$ 恒成立,最终结合 $ans \\geq cnt$ 来得证 $ans = cnt$。**\n\n---\n\n### 贪心\n\n实现上,首先我们可以求得衣服总和 $sum$ 以及洗衣机数量 $n$,从而判断无解情况(`sum % n != 0`),或者计算最终每台洗衣机的衣服数量 $t = sum / n$。\n\n然后使用两个变量 $ls$ 和 $rs$ 分别表示当前位置「左边的衣服总数」和「右边的衣服总数」,并在从左往右的遍历过程中实时维护。\n\n对于某个位置 $x$ 而言,达到最终平衡需要从 $x$ 右边往左边运送的衣服数量为 $a =  \\max(i * t - ls, 0)$,即左边的当前的衣服数量与最终状态的衣服数量的差值,与 $0$ 取 $\\max$ 含义代表为如果当前左边衣服多于最终衣服数量时,此时不需要消耗从右到左的移动次数(只需要消耗从 $x$ 左边到 $x$ 右边的移动次数);右边分析同理,我们可以得到达到最终平衡需要从 $x$ 左边到右运送的衣服数量为 $b =  \\max((n - i - 1) * t - rs, 0)$。\n\n在所有位置的 $a + b$ 之间取最大值即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int findMinMoves(int[] ms) {\n        int n = ms.length;\n        int sum = 0;\n        for (int i : ms) sum += i;\n        if (sum % n != 0) return -1;\n        int t = sum / n;\n        int ls = 0, rs = sum;\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            rs -= ms[i];\n            int a = Math.max(t * i - ls, 0);\n            int b = Math.max((n - i - 1) * t - rs, 0);\n            ans = Math.max(ans, a + b);\n            ls += ms[i];\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.517` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/511-520/518. 零钱兑换 II（中等）.md", "url_title": "518. 零钱兑换 II", "url": "https://leetcode-cn.com/problems/coin-change-2/solution/gong-shui-san-xie-xiang-jie-wan-quan-bei-6hxv/", "difficulty": "中等", "tags": ["背包问题", "完全背包", "动态规划"], "question": "给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。 \n\n示例 1:\n```\n输入: amount = 5, coins = [1, 2, 5]\n输出: 4\n解释: 有四种方式可以凑成总金额:\n5=5\n5=2+2+1\n5=2+1+1+1\n5=1+1+1+1+1\n```\n示例 2:\n```\n输入: amount = 3, coins = [2]\n输出: 0\n解释: 只用面额2的硬币不能凑成总金额3。\n```\n示例 3:\n```\n输入: amount = 10, coins = [10] \n输出: 1\n```\n\n注意:\n\n你可以假设:\n* 0 <= amount (总金额) <= 5000\n* 1 <= coin (硬币面额) <= 5000\n* 硬币种类不超过 500 种\n* 结果符合 32 位符号整数", "solution": "### 完全背包(朴素解法)\n\n在 [322. 零钱兑换](https://leetcode-cn.com/problems/coin-change/solution/dong-tai-gui-hua-bei-bao-wen-ti-zhan-zai-3265/) 中,我们求的是「取得特定价值所需要的最小物品个数」。\n\n对于本题,我们求的是「取得特定价值的方案数量」。\n\n**求的东西不一样,但问题的本质没有发生改变,同样属于「组合优化」问题。**\n\n你可以这样来理解什么是组合优化问题:\n\n**被选物品之间不需要满足特定关系,只需要选择物品,以达到「全局最优」或者「特定状态」即可。**\n\n同时硬币相当于我们的物品,每种硬币可以选择「无限次」,很自然的想到「完全背包」。\n\n这时候可以将「完全背包」的状态定义搬过来进行“微调”:\n\n**定义 $f[i][j]$ 为考虑前 $i$ 件物品,凑成总和为 $j$ 的方案数量。**\n\n为了方便初始化,我们一般让 $f[0][x]$ 代表不考虑任何物品的情况。\n\n因此我们有显而易见的初始化条件:$f[0][0] = 1$,其余 $f[0][x] = 0$。\n\n代表当没有任何硬币的时候,存在凑成总和为 0 的方案数量为 1;凑成其他总和的方案不存在。\n\n当「状态定义」与「基本初始化」有了之后,我们不失一般性的考虑 $f[i][j]$ 该如何转移。\n\n对于第 $i$ 个硬币我们有两种决策方案:\n\n* 不使用该硬币:\n\n$$\nf[i - 1][j]\n$$\n\n* 使用该硬币:由于每个硬币可以被选择多次(容量允许的情况下),因此方案数量应当是选择「任意个」该硬币的方案总和:\n\n$$\n\\sum_{k = 1}^{\\left \\lfloor {j / val} \\right \\rfloor}f[i - 1][j - k * val], val = nums[i - 1]\n$$\n\n代码:\n```Java\nclass Solution {\n    public int change(int cnt, int[] cs) {\n        int n = cs.length;\n        int[][] f = new int[n + 1][cnt + 1];\n        f[0][0] = 1;\n        for (int i = 1; i <= n; i++) {\n            int val = cs[i - 1];\n            for (int j = 0; j <= cnt; j++) {\n                f[i][j] = f[i - 1][j];\n                for (int k = 1; k * val <= j; k++) {\n                    f[i][j] += f[i - 1][j - k * val];  \n                }\n            }\n        }\n        return f[n][cnt];\n    }\n}\n```\n* 时间复杂度:共有 $n * cnt$ 个状态需要转移,每个状态转移最多遍历 $cnt$ 次。整体复杂度为 $O(n * cnt^2)$。\n* 空间复杂度:$O(n * cnt)$。\n\n---\n\n### 完全背包(一维优化)\n\n显然二维完全背包求解方案复杂度有点高。\n\n$n$ 的数据范围为 $10^2$,$cnt$ 的数据范围为 $10^3$,总的计算量为 $10^8$ 以上,处于超时边缘(实际测试可通过)。\n\n我们需要对其进行「降维优化」,可以使用最开始讲的 [数学分析方式](https://leetcode-cn.com/problems/perfect-squares/solution/dong-tai-gui-hua-bei-bao-wen-ti-qiang-hu-hcmi/),或者上一讲讲的 [换元优化方式](https://leetcode-cn.com/problems/coin-change/solution/dong-tai-gui-hua-bei-bao-wen-ti-zhan-zai-3265/) 进行降维优化。\n\n由于 [数学分析方式](https://leetcode-cn.com/problems/perfect-squares/solution/dong-tai-gui-hua-bei-bao-wen-ti-qiang-hu-hcmi/) 十分耗时,我们用得更多的 [换元优化方式](https://leetcode-cn.com/problems/coin-change/solution/dong-tai-gui-hua-bei-bao-wen-ti-zhan-zai-3265/)。两者同样具有「可推广」特性。\n\n因为后者更为常用,所以我们再来回顾一下如何进行「直接上手写一维空间优化的版本」 :\n\n1. 在二维解法的基础上,直接取消「物品维度」\n2. 确保「容量维度」的遍历顺序为「从小到大」(适用于「完全背包」)\n3. 将形如 $f[i - 1][j - k * val]$ 的式子更替为 $f[j - val]$,同时解决「数组越界」问题(将物品维度的遍历修改为从 $val$ 开始)\n\n代码:\n```java []\nclass Solution {\n    public int change(int cnt, int[] cs) {\n        int n = cs.length;\n        int[] f = new int[cnt + 1];\n        f[0] = 1;\n        for (int i = 1; i <= n; i++) {\n            int val = cs[i - 1];\n            for (int j = val; j <= cnt; j++) {\n                f[j] += f[j - val];\n            }\n        }\n        return f[cnt];\n    }\n}\n```\n* 时间复杂度:共有 $n * cnt$ 个状态需要转移,整体复杂度为 $O(n * cnt)$。\n* 空间复杂度:$O(cnt)$。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.518` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/511-520/519. 随机翻转矩阵（中等）.md", "url_title": "519. 随机翻转矩阵", "url": "https://leetcode-cn.com/problems/random-flip-matrix/solution/gong-shui-san-xie-note-bie-pian-yi-ti-sh-e6gi/", "difficulty": "中等", "tags": ["哈希表", "双指针"], "question": "给你一个 $m x n$ 的二元矩阵 $matrix$,且所有值被初始化为 $0$。\n\n请你设计一个算法,随机选取一个满足 `matrix[i][j] == 0` 的下标 $(i, j)$ ,并将它的值变为 $1$ 。\n\n所有满足 `matrix[i][j] == 0` 的下标 $(i, j)$ 被选取的概率应当均等。\n\n尽量最少调用内置的随机函数,并且优化时间和空间复杂度。\n\n实现 `Solution` 类:\n\n* `Solution(int m, int n)` 使用二元矩阵的大小 $m$ 和 $n$ 初始化该对象\n* `int[] flip()` 返回一个满足 `matrix[i][j] == 0` 的随机下标 `[i, j]` ,并将其对应格子中的值变为 $1$\n* `void reset()` 将矩阵中所有的值重置为 $0$\n\n示例:\n```\n输入\n[\"Solution\", \"flip\", \"flip\", \"flip\", \"reset\", \"flip\"]\n[[3, 1], [], [], [], [], []]\n\n输出\n[null, [1, 0], [2, 0], [0, 0], null, [2, 0]]\n\n解释\nSolution solution = new Solution(3, 1);\nsolution.flip();  // 返回 [1, 0],此时返回 [0,0]、[1,0] 和 [2,0] 的概率应当相同\nsolution.flip();  // 返回 [2, 0],因为 [1,0] 已经返回过了,此时返回 [2,0] 和 [0,0] 的概率应当相同\nsolution.flip();  // 返回 [0, 0],根据前面已经返回过的下标,此时只能返回 [0,0]\nsolution.reset(); // 所有值都重置为 0 ,并可以再次选择下标返回\nsolution.flip();  // 返回 [2, 0],此时返回 [0,0]、[1,0] 和 [2,0] 的概率应当相同\n```\n\n提示:\n* $1 <= m, n <= 10^4$\n* 每次调用 `flip` 时,矩阵中至少存在一个值为 $0$ 的格子。\n* 最多调用 1000 次 `flip` 和 `reset` 方法。", "solution": "### 双指针\n\n矩阵大小的数据范围为 $10^4$,因此我们不能使用真实构建矩阵的做法来做,同时利用二维的坐标能够唯一对应出编号($idx = row * n + col$),可以将问题转换为一维问题。\n\n一个最为朴素的做法是利用调用次数只有 $10^3$,我们可以在 $[0, m * n)$ 范围内随机出一个下标 $idx$(对应矩阵的某个具体位置),然后从 $idx$ 往两边进行扫描,找到最近一个未被使用的位置,将其进行标记翻转并返回。\n\n该做法相比于一直随机的「拒绝采样」做法,能够确保单次 `flip` 操作中只会调用一次随机方法,同时利用矩阵只有 $10^3$ 个位置被翻转,因而复杂度上具有保证。\n\n代码:\n```Java\nclass Solution {\n    int m, n;\n    Set<Integer> set = new HashSet<>();\n    Random random = new Random(300);\n    public Solution(int _m, int _n) {\n        m = _m; n = _n;\n    }\n    public int[] flip() {\n        int a = random.nextInt(m * n), b = a;\n        while (a >= 0 && set.contains(a)) a--;\n        while (b < m * n && set.contains(b)) b++;\n        int c = a >= 0 && !set.contains(a) ? a : b;\n        set.add(c);\n        return new int[]{c / n, c % n};\n    }\n    public void reset() {\n        set.clear();\n    }\n}\n```\n* 时间复杂度:令最大调用次数为 $C = 1000$,即矩阵中最多有 $C$ 个位置被翻转。`flip` 操作的复杂度为 $O(C)$;`reset` 复杂度为 $O(C)$\n* 空间复杂度:$O(C)$\n\n---\n\n### 哈希表 + swap\n\n在解法一中,我们将二维问题转化为了一维问题。\n\n起始时,我们只需要在 $[0, m * n)$ 这连续一段的区间内进行随机,但当我们经过了多次翻转后,该区间内的某些位置会被断开,使得数组不再连续。\n\n如果我们希望在每次随机时都采用起始的方式(在连续一段内进行随机),需要确保某些位置被翻转后,剩余位置仍是连续。\n\n具体的,我们可以使用「哈希表」多记录一层映射关系:起始时所有位置未被翻转,我们规定未被翻转的位置其映射值为编号本身($idx = row * n + col$),由于未被翻转的部分具有等值映射关系,因此无须在哈希表中真实存储。当随机到某个位置 $idx$ 时,进行分情况讨论:\n\n* 该位置未被哈希表真实记录(未被翻转):说明 $idx$ 可被直接使用,使用 $idx$ 作为本次随机点。同时将右端点(未被使用的)位置的映射值放到该位置,将右端点左移。确保下次再随机到 $idx$,仍能直接使用 $idx$ 的映射值,同时维护了随机区间的连续性;\n* 该位置已被哈希表真实记录(已被翻转):此时直接使用 $idx$ 存储的映射值(上一次交换时的右端点映射值)即可,然后用新的右端点映射值将其进行覆盖,更新右端点。确保下次再随机到 $idx$,仍能直接使用 $idx$ 的映射值,同时维护了随机区间的连续性。\n\n代码:\n```Java\nclass Solution {\n    int m, n, cnt; // cnt 为剩余数个数,同时 cnt - 1 为区间右端点位置\n    Map<Integer, Integer> map = new HashMap<>();\n    Random random = new Random(300);\n    public Solution(int _m, int _n) {\n        m = _m; n = _n; cnt = m * n;\n    }\n    public int[] flip() {\n        int x = random.nextInt(cnt--);\n        int idx = map.getOrDefault(x, x);\n        map.put(x, map.getOrDefault(cnt, cnt));\n        return new int[]{idx / n, idx % n};\n    }\n    public void reset() {\n        cnt = m * n;\n        map.clear();\n    }\n}\n```\n* 时间复杂度:令最大调用次数为 $C = 1000$,即矩阵中最多有 $C$ 个位置被翻转。`flip` 操作的复杂度为 $O(1)$;`reset` 复杂度为 $O(C)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.519` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/511-520/520. 检测大写字母（简单）.md", "url_title": "520. 检测大写字母", "url": "https://leetcode-cn.com/problems/detect-capital/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-rpor/", "difficulty": "简单", "tags": ["模拟"], "question": "我们定义,在以下情况时,单词的大写用法是正确的:\n\n* 全部字母都是大写,比如 \"USA\" 。\n* 单词中所有字母都不是大写,比如 \"leetcode\" 。\n* 如果单词不只含有一个字母,只有首字母大写, 比如 \"Google\" 。\n\n给你一个字符串 word 。如果大写用法正确,返回 true ;否则,返回 false 。\n\n示例 1:\n```\n输入:word = \"USA\"\n\n输出:true\n```\n示例 2:\n```\n输入:word = \"FlaG\"\n\n输出:false\n```\n提示:\n* 1 <= word.length <= 100\n* word 由小写和大写英文字母组成", "solution": "### 模拟\n\n根据题意,分别进行三种规则的判断即可。\n\n代码:\n```Java\nclass Solution {\n    public boolean detectCapitalUse(String word) {\n        if (word.toUpperCase().equals(word)) return true;\n        if (word.toLowerCase().equals(word)) return true;\n        int n = word.length(), idx = 1;\n        if (Character.isUpperCase(word.charAt(0))) {\n            while (idx < n && Character.isLowerCase(word.charAt(idx))) idx++;\n        }\n        return idx == n;\n    }\n}\n```\n* 时间复杂度:$O(n)$,常数为 $5$。\n* 空间复杂度:算法执行过程会产生新的字符串,复杂度为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.520` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/521-530/521. 最长特殊序列 Ⅰ（简单）.md", "url_title": "521. 最长特殊序列 I", "url": "https://leetcode-cn.com/problems/longest-uncommon-subsequence-i/solution/gong-shui-san-xie-nao-jin-ji-zhuan-wan-z-nj3w/", "difficulty": "简单", "tags": ["脑筋急转弯"], "question": "给你两个字符串 `a` 和 `b`,请返回 这两个字符串中 最长的特殊序列  。如果不存在,则返回 $-1$ 。\n\n「最长特殊序列」 定义如下:该序列为 某字符串独有的最长子序列(即不能是其他字符串的子序列) 。\n\n字符串 `s` 的子序列是在从 `s` 中删除任意数量的字符后可以获得的字符串。\n\n例如,`“abc”` 是 `“aebdc”` 的子序列,因为您可以删除 `“aebdc”` 中的下划线字符来得到 `“abc”` 。 `“aebdc”` 的子序列还包括 `“aebdc”` 、 `“aeb”` 和 `“”` (空字符串)。\n\n示例 1:\n```\n输入: a = \"aba\", b = \"cdc\"\n\n输出: 3\n\n解释: 最长特殊序列可为 \"aba\" (或 \"cdc\"),两者均为自身的子序列且不是对方的子序列。\n```\n示例 2:\n```\n输入:a = \"aaa\", b = \"bbb\"\n\n输出:3\n\n解释: 最长特殊序列是“aaa”和“bbb”。\n```\n示例 3:\n```\n输入:a = \"aaa\", b = \"aaa\"\n\n输出:-1\n\n解释: 字符串a的每个子序列也是字符串b的每个子序列。同样,字符串b的每个子序列也是字符串a的子序列。\n```\n\n提示:\n* $1 <= a.length, b.length <= 100$\n* `a` 和 `b` 由小写英文字母组成", "solution": "### 脑筋急转弯\n\n当两字符串不同时,我们总能选择长度不是最小的字符串作为答案,而当两字符串相同时,我们无法找到特殊序列。\n\n代码:\n```Java\nclass Solution {\n    public int findLUSlength(String a, String b) {\n        return a.equals(b) ? -1 : Math.max(a.length(), b.length());\n    }\n}\n```\n* 时间复杂度:字符串比较复杂度与长度成正比,复杂度为 $O(\\max(n, m))$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.521` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/521-530/522. 最长特殊序列 II（中等）.md", "url_title": "522. 最长特殊序列 II", "url": "https://leetcode.cn/problems/longest-uncommon-subsequence-ii/solution/by-ac_oier-vuez/", "difficulty": "中等", "tags": ["LCS", "最长公共子序列", "序列 DP", "枚举", "动态规划"], "question": "给定字符串列表 `strs`,返回其中 最长的特殊序列 。如果最长特殊序列不存在,返回 $-1$ 。\n\n特殊序列 定义如下:该序列为某字符串 独有的子序列(即不能是其他字符串的子序列)。\n\n`s` 的 子序列可以通过删去字符串 `s` 中的某些字符实现。\n\n* 例如,`\"abc\"` 是 `\"aebdc\"` 的子序列,因为您可以删除 `\"aebdc\"` 中的下划线字符来得到 `\"abc\"` 。`\"aebdc\"` 的子序列还包括 `\"aebdc\"`、 `\"aeb\"` 和 `\"\"` (空字符串)。\n\n示例 1:\n```\n输入: strs = [\"aba\",\"cdc\",\"eae\"]\n\n输出: 3\n```\n示例 2:\n```\n输入: strs = [\"aaa\",\"aaa\",\"aa\"]\n\n输出: -1\n```\n\n提示:\n* $2 <= strs.length <= 50$\n* $1 <= strs[i].length <= 10$\n* `strs[i]` 只包含小写英文字母", "solution": "### LCS\n\n记 `strs` 数组长度为 $n$,单个 $strs[i]$ 的最大长度 $m$。其中 $n$ 数据范围为 $50$,$m$ 数据范围为 $10$。\n\n根据题意,我们可以枚举每个 $s1 = str[i]$,检查其是否为其他 $s2 = strs[j]$ 的子序列,这需要枚举所有点对,复杂度为 $O(n^2)$。同时记录遍历过程中的最大长度 `ans`,用于剪枝(对于字符串长度本身小于等于 `ans` 的 $strs[i]$ 可直接跳过)。\n\n我们可以实现一个 `check` 函数来检查 `s1` 是否为 `s2` 的子序列,该问题可转化为求 `s1` 和 `s2` 的最长公共子序列长度。若最长公共子序列长度为 `s1` 长度,说明 `s1` 为 `s2` 的子序列,此时 $strs[i]$ 不满足条件,否则我们使用 $strs[i]$ 的长度来更新 `ans`。`check` 函数的复杂度为 $O(m^2)$。\n\n> **不了解 LCS 的同学可以看前置 🧀 : [LCS 模板题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492097&idx=1&sn=f51f29d86df809d8ac43a40a1369b3d6)**\n\n因此总的计算量为 $n^2 \\times m^2 = 2.5 * 10^5$,可以过。\n\n代码:\n```Java\nclass Solution {\n    public int findLUSlength(String[] strs) {\n        int n = strs.length, ans = -1;\n        for (int i = 0; i < n; i++) {\n            if (strs[i].length() <= ans) continue;\n            boolean ok = true;\n            for (int j = 0; j < n && ok; j++) {\n                if (i == j) continue;\n                if (check(strs[i], strs[j])) ok = false;\n            }\n            if (ok) ans = strs[i].length();\n        }\n        return ans;\n    }\n    boolean check(String s1, String s2) {\n        int n = s1.length(), m = s2.length();\n        if (m < n) return false;\n        int[][] f = new int[n + 1][m + 1];\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                f[i][j] = s1.charAt(i - 1) == s2.charAt(j - 1) ? f[i - 1][j - 1] + 1 : f[i - 1][j - 1];\n                f[i][j] = Math.max(f[i][j], f[i - 1][j]);\n                f[i][j] = Math.max(f[i][j], f[i][j - 1]);\n                if (f[i][j] == n) return true;\n            }\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:检查每个 $strs[i]$ 是否符合要求,需要枚举所有的点对,复杂度为 $O(n^2)$;求解 LCS 问题的复杂度为 $O(m^2)$。整体复杂度为 $O(n^2 \\times m^2)$\n* 空间复杂度:$O(m^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.522` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/521-530/523. 连续的子数组和（中等）.md", "url_title": "523. 连续的子数组和", "url": "https://leetcode-cn.com/problems/continuous-subarray-sum/solution/gong-shui-san-xie-tuo-zhan-wei-qiu-fang-1juse/", "difficulty": "中等", "tags": ["前缀和"], "question": "给你一个整数数组 `nums` 和一个整数 `k` ,编写一个函数来判断该数组是否含有同时满足下述条件的连续子数组:\n\n* 子数组大小至少为 `2` ,且\n* 子数组元素总和为 `k` 的倍数。\n\n如果存在,返回 `true`;否则,返回 `false`。\n\n如果存在一个整数 `n` ,令整数 `x` 符合 `x = n * k` ,则称 `x` 是 `k` 的一个倍数。\n\n示例 1:\n```\n输入:nums = [23,2,4,6,7], k = 6\n\n输出:true\n\n解释:[2,4] 是一个大小为 2 的子数组,并且和为 6 。\n```\n示例 2:\n```\n输入:nums = [23,2,6,4,7], k = 6\n\n输出:true\n\n解释:[23, 2, 6, 4, 7] 是大小为 5 的子数组,并且和为 42 。 \n42 是 6 的倍数,因为 42 = 7 * 6 且 7 是一个整数。\n```\n示例 3:\n```\n输入:nums = [23,2,6,4,7], k = 13\n\n输出:false\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $0 <= nums[i] <= 10^9$\n* $0 <= sum(nums[i]) <= 2^{31} - 1$\n* $1 <= k <= 2^{31} - 1$", "solution": "### 基本分析\n\n这是一道很经典的前缀和题目,类似的原题也在蓝桥杯出现过,坐标在 [K 倍区间](http://lx.lanqiao.cn/problem.page?gpid=T444) http://lx.lanqiao.cn/problem.page?gpid=T444。\n\n本题与那道题不同在于:\n\n* [K 倍区间] 需要求得所有符合条件的区间数量;本题需要判断是否存在。\n* [K 倍区间] 序列全是正整数,不需要考虑 $0$ 值问题;本题需要考虑 $0$ 值问题。\n\n数据范围为 $10^4$,因此无论是纯朴素的做法 ($O(n^3)$)还是简单使用前缀和优化的做法 ($O(n^2)$) 都不能满足要求。\n\n我们需要从 $k$ 的倍数作为切入点来做。\n\n预处理前缀和数组 $sum$,方便快速求得某一段区间的和。然后假定 $[i, j]$ 是我们的目标区间,那么有:\n\n$$\nsum[j] - sum[i - 1] = n * k\n$$\n\n经过简单的变形可得:\n\n$$\n\\frac{sum[j]}{k} - \\frac{sum[i - 1]}{k} = n\n$$\n\n**要使得两者除 $k$ 相减为整数,需要满足 $sum[j]$ 和 $sum[i - 1]$ 对 $k$ 取余相同。**\n\n也就是说,我们只需要枚举右端点 $j$,然后在枚举右端点 $j$ 的时候检查之前是否出现过左端点 $i$,使得 $sum[j]$ 和 $sum[i - 1]$ 对 $k$ 取余相同。\n\n---\n\n### 前缀和 + HashSet\n\n具体的,使用 `HashSet` 来保存出现过的值。\n\n让循环从 $2$ 开始枚举右端点(根据题目要求,子数组长度至少为 $2$),每次将符合长度要求的位置的取余结果存入 `HashSet`。\n\n如果枚举某个右端点 $j$ 时发现存在某个左端点 $i$ 符合要求,则返回 `True`。\n\n代码:\n```Java\nclass Solution {\n    public boolean checkSubarraySum(int[] nums, int k) {\n        int n = nums.length;\n        int[] sum = new int[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n        Set<Integer> set = new HashSet<>();\n        for (int i = 2; i <= n; i++) {\n            set.add(sum[i - 2] % k);\n            if (set.contains(sum[i] % k)) return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 拓展(求方案数)\n\n蓝桥杯官网登录经常性罢工,我登录十几次都没登录上去,这里直接截图了 [K 倍区间] 的题目给大家。\n\n写了代码,但很可惜没 OJ 可以测试 🤣 \n\n比较简单,应该没啥问题,可以直接参考 🤣\n\n代码:\n```Java\nimport java.util.*;\nclass Main {\n    public static void main(String[] args) {\n        Scanner sc = new Scanner(System.in);\n        int n = sc.nextInt(), k = sc.nextInt();\n        long[] s  = new long[n + 1];\n        for (int i = 1; i <= n; i++) s[i] = s[i - 1] + sc.nextLong();\n        long ans = 0;\n        Map<Long, Integer> map = new HashMap<>();\n        map.put(0L, 1);\n        for (int i = 1 ; i <= n; i++) {\n            long u = s[i] % k;\n            if (map.containsKey(u)) ans += map.get(u);\n            map.put(u, map.getOrDefault(u, 0) + 1);\n        }\n        System.out.println(ans);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.523` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/521-530/524. 通过删除字母匹配到字典里最长单词（中等）.md", "url_title": "524. 通过删除字母匹配到字典里最长单词", "url": "https://leetcode-cn.com/problems/longest-word-in-dictionary-through-deleting/solution/gong-shui-san-xie-xiang-jie-pai-xu-shuan-qi20/", "difficulty": "中等", "tags": ["双指针", "贪心", "排序"], "question": "给你一个字符串 `s` 和一个字符串数组 `dictionary` 作为字典,找出并返回字典中最长的字符串,该字符串可以通过删除 `s` 中的某些字符得到。\n\n如果答案不止一个,返回长度最长且字典序最小的字符串。\n\n如果答案不存在,则返回空字符串。\n\n示例 1:\n```\n输入:s = \"abpcplea\", dictionary = [\"ale\",\"apple\",\"monkey\",\"plea\"]\n\n输出:\"apple\"\n```\n示例 2:\n```\n输入:s = \"abpcplea\", dictionary = [\"a\",\"b\",\"c\"]\n\n输出:\"a\"\n```\n\n提示:\n* $1 <= s.length <= 1000$\n* $1 <= dictionary.length <= 1000$\n* $1 <= dictionary[i].length <= 1000$\n* `s` 和 `dictionary[i]` 仅由小写英文字母组成", "solution": "### 排序 + 双指针 + 贪心\n\n根据题意,我们需要找到 `dictionary` 中为 `s` 的子序列,且「长度最长(优先级 $1$)」及「字典序最小(优先级 $2$)」的字符串。\n\n数据范围全是 $1000$。\n\n我们可以先对 `dictionary` 根据题意进行自定义排序:\n\n1. 长度不同的字符串,按照字符串长度排倒序;\n2. 长度相同的,则按照字典序排升序。\n\n然后我们只需要对 `dictionary` 进行顺序查找,找到的第一个符合条件的字符串即是答案。\n\n具体的,我们可以使用「贪心」思想的「双指针」实现来进行检查:\n\n1. 使用两个指针 `i` 和 `j` 分别代表检查到 `s` 和 `dictionary[x]` 中的哪位字符;\n2. 当 `s[i] != dictionary[x][j]`,我们使 `i` 指针右移,直到找到 `s` 中第一位与 `dictionary[x][j]` 对得上的位置,然后当 `i` 和 `j` 同时右移,匹配下一个字符;\n3. 重复步骤 $2$,直到整个 `dictionary[x]` 被匹配完。\n\n> 证明:对于某个字符 `dictionary[x][j]` 而言,选择 `s` 中 **当前** 所能选择的下标最小的位置进行匹配,对于后续所能进行选择方案,会严格覆盖不是选择下标最小的位置,因此结果不会变差。\n\nJava 代码:\n```Java\nclass Solution {\n    public String findLongestWord(String s, List<String> dictionary) {\n        Collections.sort(dictionary, (a,b)->{\n            if (a.length() != b.length()) return b.length() - a.length();\n            return a.compareTo(b);\n        });\n        int n = s.length();\n        for (String ss : dictionary) {\n            int m = ss.length();\n            int i = 0, j = 0;\n            while (i < n && j < m) {\n                if (s.charAt(i) == ss.charAt(j)) j++;\n                i++;\n            }\n            if (j == m) return ss;\n        }\n        return \"\";\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    string findLongestWord(string s, vector<string>& dictionary) {\n        sort(dictionary.begin(), dictionary.end(), [](const string& a, const string& b) {\n            if (a.length() != b.length()) return b.length() < a.length();\n            return a < b;\n        });\n        int n = s.length();\n        for (const string& word : dictionary) {\n            int m = word.length();\n            int i = 0, j = 0;\n            while (i < n && j < m) {\n                if (s[i] == word[j]) j++;\n                i++;\n            }\n            if (j == m) return word;\n        }\n        return \"\";\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def findLongestWord(self, s: str, dictionary: List[str]) -> str:\n        dictionary.sort(key=lambda x: (-len(x), x))\n        n = len(s)\n        for word in dictionary:\n            m = len(word)\n            i, j = 0, 0\n            while i < n and j < m:\n                if s[i] == word[j]: j += 1\n                i += 1\n            if j == m: return word\n        return \"\"\n```\nTypeScript 代码:\n```TypeScript\nfunction findLongestWord(s: string, dictionary: string[]): string {\n    dictionary.sort((a, b) => {\n        if (a.length !== b.length) return b.length - a.length;\n        return a.localeCompare(b);\n    });\n    const n = s.length;\n    for (const word of dictionary) {\n        const m = word.length;\n        let i = 0, j = 0;\n        while (i < n && j < m) {\n            if (s[i] === word[j]) j++;\n            i++;\n        }\n        if (j === m) return word;\n    }\n    return \"\";  \n};\n```\n* 时间复杂度:令 `n` 为 `s` 的长度,`m` 为 `dictionary` 的长度。排序复杂度为 $O(m\\log{m})$;对 `dictionary` 中的每个字符串进行检查,单个字符串的检查复杂度为 $O(\\min(n, dictionary[i]))\\approx O(n)$。整体复杂度为 $O(m\\log{m} + m \\times n)$\n* 空间复杂度:$O(\\log{m})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.524` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/521-530/525. 连续数组（中等）.md", "url_title": "525. 连续数组", "url": "https://leetcode-cn.com/problems/contiguous-array/solution/gong-shui-san-xie-qian-zhui-he-ha-xi-bia-q400/", "difficulty": "中等", "tags": ["前缀和", "哈希表"], "question": "给定一个二进制数组 `nums` , 找到含有相同数量的 $0$ 和 $1$ 的最长连续子数组,并返回该子数组的长度。\n\n示例 1:\n```\n输入: nums = [0,1]\n\n输出: 2\n\n说明: [0, 1] 是具有相同数量0和1的最长连续子数组。\n```\n示例 2:\n```\n输入: nums = [0,1,0]\n\n输出: 2\n\n说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* `nums[i]` 不是 $0$ 就是 $1$", "solution": "### 前缀和 + 哈希表\n\n根据题意,我们可以轻易发现如下性质:如果答案非 $0$,那么子数组长度必然为偶数,且长度至少为 $2$。\n\n具体的,我们在预处理前缀和时,将 $nums[i]$ 为 $0$ 的值当做 $-1$ 处理。\n\n从而将问题转化为:**如何求得最长一段区间和为 $0$ 的子数组。** 同时使用「哈希表」来记录「某个前缀和出现的最小下标」是多少。\n\nJava 代码:\n```Java\nclass Solution {\n    public int findMaxLength(int[] nums) {\n        int n = nums.length, ans = 0;\n        int[] sum = new int[n + 10];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (nums[i - 1] == 0 ? -1 : 1);\n        Map<Integer, Integer> map = new HashMap<>();\n        map.put(0, 0);\n        for (int i = 1; i <= n; i++) {\n            int t = sum[i];\n            if (map.containsKey(t)) ans = Math.max(ans, i - map.get(t));\n            if (!map.containsKey(t)) map.put(t, i);\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction findMaxLength(nums: number[]): number {\n    let n = nums.length, ans = 0\n    const sum = new Array<number>(n + 10).fill(0)\n    for (let i = 1; i <= n; i++) sum[i] = sum[i - 1] + (nums[i - 1] == 0 ? -1 : 1)\n    const map = new Map<number, number>()\n    map.set(0, 0)\n    for (let i = 1; i <= n; i++) {\n        const t = sum[i]\n        if (map.has(t)) ans = Math.max(ans, i - map.get(t))\n        if (!map.has(t)) map.set(t, i)\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.525` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/521-530/526. 优美的排列（中等）.md", "url_title": "526. 优美的排列", "url": "https://leetcode-cn.com/problems/beautiful-arrangement/solution/gong-shui-san-xie-xiang-jie-liang-chong-vgsia/", "difficulty": "中等", "tags": ["位运算", "状压 DP", "动态规划"], "question": "假设有从 $1$ 到 $N$ 的 $N$ 个整数,如果从这 $N$ 个数字中成功构造出一个数组,使得数组的第 $i$ 位 ($1 <= i <= N$) 满足如下两个条件中的一个,我们就称这个数组为一个优美的排列。\n\n条件:\n* 第 $i$ 位的数字能被 $i$ 整除\n* $i$ 能被第 $i$ 位上的数字整除\n\n现在给定一个整数 $N$,请问可以构造多少个优美的排列?\n\n示例1:\n```\n输入: 2\n\n输出: 2\n\n解释: \n第 1 个优美的排列是 [1, 2]:\n  第 1 个位置(i=1)上的数字是1,1能被 i(i=1)整除\n  第 2 个位置(i=2)上的数字是2,2能被 i(i=2)整除\n\n第 2 个优美的排列是 [2, 1]:\n  第 1 个位置(i=1)上的数字是2,2能被 i(i=1)整除\n  第 2 个位置(i=2)上的数字是1,i(i=2)能被 1 整除\n```\n\n说明:\n* $N$ 是一个正整数,并且不会超过 $15$。", "solution": "### 状态压缩 DP\n\n利用数据范围不超过 $15$,我们可以使用「状态压缩 DP」进行求解。\n\n**使用一个二进制数表示当前哪些数已被选,哪些数未被选,目的是为了可以使用位运算进行加速。**\n\n我们可以通过一个具体的样例,来感受下「状态压缩」是什么意思:\n\n例如 $(000...0101)_2$ 代表值为 $1$ 和值为 $3$ 的数字已经被使用了,而值为 $2$ 的节点尚未被使用。\n\n然后再来看看使用「状态压缩」的话,一些基本的操作该如何进行:\n\n假设变量 $state$ 存放了「当前数的使用情况」,当我们需要检查值为 $k$ 的数是否被使用时,可以使用位运算 `a = (state >> k) & 1`,来获取 $state$ 中第 $k$ 位的二进制表示,如果 `a` 为 $1$ 代表值为 $k$ 的数字已被使用,如果为 $0$ 则未被访问。\n\n**定义 $f[i][state]$ 为考虑前 $i$ 个数,且当前选择方案为 $state$ 的所有方案数量。**\n\n一个显然的初始化条件为 $f[0][0] = 1$,代表当我们不考虑任何数($i = 0$)的情况下,一个数都不被选择($state = 0$)为一种合法方案。\n\n不失一般性的考虑 $f[i][state]$ 该如何转移,由于本题是求方案数,我们的转移方程必须做到「不重不漏」。\n\n我们可以通过枚举当前位置 $i$ 是选哪个数,假设位置 $i$ 所选数值为 $k$,首先 $k$ 值需要同时满足如下两个条件:\n\n* $state$ 中的第 $k$ 位为 $1$;\n* 要么 $k$ 能被 $i$ 整除,要么 $i$ 能被 $k$ 整除。\n\n那么根据状态定义,位置 $i$ 选了数值 $k$,通过位运算我们可以直接得出决策位置 $i$ 之前的状态是什么:$state \\& (\\lnot (1 << (k - 1)))$,代表将 $state$ 的二进制表示中的第 $k$ 位置 $0$。\n\n最终的 $f[i][state]$ 为当前位置 $i$ 选择的是所有合法的 $k$ 值的方案数之和:\n\n$$\nf[i][state] = \\sum_{k = 1}^{n} f[i - 1][state \\& (\\lnot (1 << (k - 1)))]\n$$\n\n> 一些细节:由于给定的数值范围为 $[1,n]$,但实现上为了方便,我们使用 $state$ 从右往左的第 $0$ 位表示数值 $1$ 选择情况,第 $1$ 位表示数值 $2$ 的选择情况 ... 即对选择数值 $k$ 做一个 $-1$ 的偏移。\n\n代码:\n```Java\nclass Solution {\n    public int countArrangement(int n) {\n        int mask = 1 << n;\n        int[][] f = new int[n + 1][mask];\n        f[0][0] = 1;\n        for (int i = 1; i <= n; i++) {\n            // 枚举所有的状态\n            for (int state = 0; state < mask; state++) {\n                // 枚举位置 i(最后一位)选的数值是 k\n                for (int k = 1; k <= n; k++) {\n                    // 首先 k 在 state 中必须是 1\n                    if (((state >> (k - 1)) & 1) == 0) continue;\n                    // 数值 k 和位置 i 之间满足任一整除关系\n                    if (k % i != 0 && i % k != 0) continue;\n                    // state & (~(1 << (k - 1))) 代表将 state 中数值 k 的位置置零\n                    f[i][state] += f[i - 1][state & (~(1 << (k - 1)))];\n                }\n            }\n        }\n        return f[n][mask - 1];\n    }\n}\n```\n* 时间复杂度:共有 $n * 2^n$ 的状态需要被转移,每次转移复杂度为 $O(n)$,整体复杂度为 $O(n^2 * 2^n)$\n* 空间复杂度:$O(n * 2^n)$\n\n---\n\n### 状态压缩 DP(优化)\n\n通过对朴素的状压 DP 的分析,我们发现,在决策第 $i$ 位的时候,理论上我们应该使用的数字数量也应该为 $i$ 个。\n\n但这一点在朴素状压 DP 中并没有体现,这就导致了我们在决策第 $i$ 位的时候,仍然需要对所有的 $state$ 进行计算检查(即使是那些二进制表示中 $1$ 的出现次数不为 $i$ 个的状态)。\n\n因此我们可以换个思路进行枚举(使用新的状态定义并优化转移方程)。\n\n**定义 $f[state]$ 为当前选择数值情况为 $state$ 时的所有方案的数量。**\n\n这样仍然有 $f[0] = 1$ 的初始化条件,最终答案为 $f[(1 << n) - 1]$。\n\n不失一般性考虑 $f[state]$ 如何计算:\n\n**从当前状态 $state$ 进行出发,检查 $state$ 中的每一位 $1$ 作为最后一个被选择的数值,这样仍然可以确保方案数「不重不漏」的被统计,同时由于我们「从小到大」对 $state$ 进行枚举,因此计算 $f[state]$ 所依赖的其他状态值必然都已经被计算完成。**\n\n同样的,我们仍然需要确保 $state$ 中的那一位作为最后一个的 $1$ 需要与所放的位置成整除关系。\n\n因此我们需要一个计算 $state$ 的 $1$ 的个数的方法,这里使用 $lowbit$ 实现即可。\n\n最终的 $f[state]$ 为当前位置选择的是所有合法值的方案数之和:\n\n$$\nf[state] = \\sum_{i = 0}^{n}f[state \\& ( \\lnot (1 << i))]\n$$\n\n代码:\n```Java\nclass Solution {\n    int getCnt(int x) {\n        int ans = 0;\n        while (x != 0) {\n            x -= (x & -x); // lowbit\n            ans++;\n        }\n        return ans;\n    }\n    public int countArrangement(int n) {\n        int mask = 1 << n;\n        int[] f = new int[mask];\n        f[0] = 1;\n        // 枚举所有的状态\n        for (int state = 1; state < mask; state++) {\n            // 计算 state 有多少个 1(也就是当前排序长度为多少)\n            int cnt = getCnt(state);\n            // 枚举最后一位数值为多少\n            for (int i = 0; i < n; i++) {\n                // 数值在 state 中必须是 1\n                if (((state >> i) & 1) == 0) continue;\n                // 数值(i + 1)和位置(cnt)之间满足任一整除关系\n                if ((i + 1) % cnt != 0 && cnt % (i + 1) != 0) continue;\n                // state & (~(1 << i)) 代表将 state 中所选数值的位置置零\n                f[state] += f[state & (~(1 << i))];\n            }\n        }\n        return f[mask - 1];\n    }\n}\n```\n* 时间复杂度:共有 $2^n$ 的状态需要被转移,每次转移复杂度为 $O(n)$,整体复杂度为 $O(n * 2^n)$\n* 空间复杂度:$O(2^n)$\n\n---\n\n### 总结\n\n不难发现,其实两种状态压缩 DP 的思路其实是完全一样的。\n\n只不过在朴素状压 DP 中我们是显式的枚举了考虑每一种长度的情况(存在维度 $i$),而在状压 DP(优化)中利用则 $state$ 中的 $1$ 的个数中蕴含的长度信息。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.525` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/521-530/528. 按权重随机选择（中等）.md", "url_title": "528. 按权重随机选择", "url": "https://leetcode-cn.com/problems/random-pick-with-weight/solution/gong-shui-san-xie-yi-ti-shuang-jie-qian-8bx50/", "difficulty": "中等", "tags": ["前缀和", "二分", "模拟"], "question": "给定一个正整数数组 $w$ ,其中 $w[i]$ 代表下标 $i$ 的权重(下标从 $0$ 开始),请写一个函数 `pickIndex` ,它可以随机地获取下标 $i$,选取下标 $i$ 的概率与 $w[i]$ 成正比。\n\n例如,对于 $w = [1, 3]$,挑选下标 $0$ 的概率为 $1 / (1 + 3) = 0.25$ (即,$25$%),而选取下标 $1$ 的概率为 $3 / (1 + 3) = 0.75$(即,$75$%)。\n\n也就是说,选取下标 $i$ 的概率为 $w[i] / sum(w)$ 。 \n\n示例 1:\n```\n输入:\n[\"Solution\",\"pickIndex\"]\n[[[1]],[]]\n\n输出:\n[null,0]\n\n解释:\nSolution solution = new Solution([1]);\nsolution.pickIndex(); // 返回 0,因为数组中只有一个元素,所以唯一的选择是返回下标 0。\n```\n示例 2:\n```\n输入:\n[\"Solution\",\"pickIndex\",\"pickIndex\",\"pickIndex\",\"pickIndex\",\"pickIndex\"]\n[[[1,3]],[],[],[],[],[]]\n\n输出:\n[null,1,1,1,1,0]\n\n解释:\nSolution solution = new Solution([1, 3]);\nsolution.pickIndex(); // 返回 1,返回下标 1,返回该下标概率为 3/4 。\nsolution.pickIndex(); // 返回 1\nsolution.pickIndex(); // 返回 1\nsolution.pickIndex(); // 返回 1\nsolution.pickIndex(); // 返回 0,返回下标 0,返回该下标概率为 1/4 。\n\n由于这是一个随机问题,允许多个答案,因此下列输出都可以被认为是正确的:\n[null,1,1,1,1,0]\n[null,1,1,1,1,1]\n[null,1,1,1,0,0]\n[null,1,1,1,0,1]\n[null,1,0,1,0,0]\n......\n诸若此类。\n```\n\n提示:\n* $1 <= w.length <= 10000$\n* $1 <= w[i] <= 10^5$\n* `pickIndex` 将被调用不超过 $10000$ 次", "solution": "### 前缀和 + 二分\n\n根据题意,权重值 $w[i]$ 可以作为 `pickIndex` 调用总次数为 $\\sum_{i = 0}^{w.length - 1} w[i]$ 时,下标 $i$ 的返回次数。\n\n随机数的产生可以直接使用语言自带的 API,剩下的我们需要构造一个分布符合权重的序列。\n\n由于 $1 <= w[i] <= 10^5$,且 $w$ 长度为 $10^4$,因此直接使用构造一个有 $w[i]$ 个的 $i$ 的数字会 MLE。\n\n**我们可以使用「前缀和」数组来作为权重分布序列,权重序列的基本单位为 $1$。**\n\n一个长度为 $n$ 的构造好的「前缀和」数组可以看是一个基本单位为 $1$ 的 $[1, sum[n - 1]]$ 数轴。\n\n使用随机函数参数产生 $[1, sum[n - 1]]$ 范围内的随机数,通过「二分」前缀和数组即可找到分布位置对应的原始下标值。\n\n代码:\n```Java\nclass Solution {\n    int[] sum;\n    public Solution(int[] w) {\n        int n = w.length;\n        sum = new int[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + w[i - 1];\n    }\n    \n    public int pickIndex() {\n        int n = sum.length;\n        int t = (int) (Math.random() * sum[n - 1]) + 1;\n        int l = 1, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (sum[mid] >= t) r = mid;\n            else l = mid + 1;\n        }\n        return r - 1;\n    }\n}\n```\n* 时间复杂度:`Solution` 类的构造方法整体复杂度为 $O(n)$;`pickIndex` 的复杂度为 $O(\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 模拟(桶轮询)\n\n利用 OJ 不太聪明(对权重分布做近似检查),我们可以构造一个最小轮询序列(权重精度保留到小数点一位),并使用 $(i, cnt)$ 的形式进行存储,代表下标 $i$ 在最小轮询序列中出现次数为 $cnt$。\n\n然后使用两个编号 $bid$ 和 $iid$ 来对桶进行轮询返回(循环重置 & 跳到下一个桶)。\n\n**该解法的最大好处是不需要使用 random 函数,同时返回的连续序列满足每一段(长度不短于最小段)都符合近似权重分布。**\n\n代码:\n```Java\nclass Solution {\n    // 桶编号 / 桶内编号 / 总数\n    int bid, iid, tot;\n    List<int[]> list = new ArrayList<>();\n    public Solution(int[] w) {\n        int n = w.length;\n        double sum = 0, min = 1e9;\n        for (int i : w) {\n            sum += i;\n            min = Math.min(min, i);\n        }\n        double minv = min / sum;\n        int k = 1;\n        while (minv * k < 1) k *= 10;\n        for (int i = 0; i < n; i++) {\n            int cnt = (int)(w[i] / sum * k);\n            list.add(new int[]{i, cnt});\n            tot += cnt;\n        }\n    }\n    \n    public int pickIndex() {\n        if (bid >= list.size()) {\n            bid = 0; iid = 0;\n        }\n        int[] info = list.get(bid);\n        int id = info[0], cnt = info[1];\n        if (iid >= cnt) {\n            bid++; iid = 0;\n            return pickIndex();\n        }\n        iid++;\n        return id;\n    }\n}\n```\n* 时间复杂度:计算 $k$ 的操作只会发生一次,可以看作是一个均摊到每个下标的常数计算,`Solution` 类的构造方法的整体复杂度可看作 $O(n)$;`pickIndex` 的复杂度为 $O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.528` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/531-540/532. 数组中的 k-diff 数对（中等）.md", "url_title": "532. 数组中的 k-diff 数对", "url": "https://leetcode.cn/problems/k-diff-pairs-in-an-array/solution/by-ac_oier-ap3v/", "difficulty": "中等", "tags": ["哈希表", "离散化", "二分", "双指针"], "question": "给定一个整数数组和一个整数 $k$,你需要在数组里找到 不同的 `k-diff` 数对,并返回不同的 `k-diff` 数对 的数目。\n\n这里将 `k-diff` 数对定义为一个整数对 $(nums[i], nums[j])$,并满足下述全部条件:\n\n* `0 <= i < j < nums.length`\n* `|nums[i] - nums[j]| == k`\n\n注意,`|val|` 表示 `val` 的绝对值。\n\n示例 1:\n```\n输入:nums = [3, 1, 4, 1, 5], k = 2\n\n输出:2\n\n解释:数组中有两个 2-diff 数对, (1, 3) 和 (3, 5)。\n尽管数组中有两个1,但我们只应返回不同的数对的数量。\n```\n示例 2:\n```\n输入:nums = [1, 2, 3, 4, 5], k = 1\n\n输出:4\n\n解释:数组中有四个 1-diff 数对, (1, 2), (2, 3), (3, 4) 和 (4, 5)。\n```\n示例 3:\n```\n输入:nums = [1, 3, 1, 5, 4], k = 0\n\n输出:1\n\n解释:数组中只有一个 0-diff 数对,(1, 1)。\n```\n\n提示:\n* $1 <= nums.length <= 10^4$\n* $-10^7 <= nums[i] <= 10^7$\n* $0 <= k <= 10^7$", "solution": "### 哈希表\n\n一个简单的想法是先使用「哈希表」进行计数。\n\n对于每个 $x = nums[i]$ 而言,根据 $k$ 是否为 $0$ 进行分情况讨论:\n\n* $k$ 为 $0$:此时只能 $(x, x)$ 组成数对,此时判断 $nums[i]$ 出现次数是否大于 $1$ 次,若满足则进行计数加一;\n* $k$ 不为 $0$:此时 $x$ 能够与 $a = x - k$ 或 $b = x + k$ 组成数对,分别查询 $a$ 和 $b$ 是否出现过,若出现过则进行计数加一。\n\n为了防止相同的 $x$ 进行重复计数,我们需要统计完 $x$ 后,清空其出现次数。\n\n代码:\n```Java\nclass Solution {\n    public int findPairs(int[] nums, int k) {\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i : nums) map.put(i, map.getOrDefault(i, 0) + 1);\n        int ans = 0;\n        for (int i : nums) {\n            if (map.get(i) == 0) continue;\n            if (k == 0) {\n                if (map.get(i) > 1) ans++;\n            } else {\n                int a = i - k, b = i + k;\n                if (map.getOrDefault(a, 0) > 0) ans++;\n                if (map.getOrDefault(b, 0) > 0) ans++;\n            }\n            map.put(i, 0);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 离散化 + 二分\n\n我们知道可以使用「数组」充当「哈希表」来减少常数,但由于 $nums[i]$ 的值域大小为 $2 \\times 10^7$,可能会有 `MLE` 风险。\n\n我们需要对 $nums$ 进行离散化,预处理出一个去重且有序的数组 `list`。\n\n在统计答案时,我们不再需要在 `nums` 基础上统计,而可以直接在去重数组 `list` 上进行统计,同时将对「数值」的统计操作转换为对「下标」的统计操作。\n\n代码:\n```Java\nclass Solution {\n    static int[] cnt = new int[10010];\n    List<Integer> list;\n    int find(int x) {\n        int n = list.size(), l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (list.get(mid) >= x) r = mid;\n            else l = mid + 1;\n        }\n        return list.get(r) == x ? r : -1;\n    }\n    public int findPairs(int[] nums, int k) {\n        Arrays.sort(nums);\n        list = new ArrayList<>();\n        for (int i : nums) {\n            if (list.isEmpty() || i != list.get(list.size() - 1)) list.add(i);\n        }\n        Arrays.fill(cnt, 0);\n        for (int i : nums) cnt[find(i)]++;\n        int ans = 0, idx = 0;\n        for (int i : list) {\n            if (k == 0) {\n                if (cnt[idx] > 1) ans++;\n            } else {\n                int a = find(i - k), b = find(i + k);\n                if (a != -1 && cnt[a] > 0) ans++;\n                if (b != -1 && cnt[b] > 0) ans++;\n            }\n            cnt[idx++] = 0;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序离散化复杂度为 $O(n\\log{n})$,统计答案复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 离散化 + 双指针\n\n跟进一步的,对于 $x = nums[i]$ 而言,我们每次都在整段的 `list` 中二分找 $a = nums[i] - k$ 和 $b = nums[i] + k$ 的下标,导致我们统计 $nums[i]$ 对答案的贡献时复杂度为 $O(\\log{n})$,统计所有 $nums[i]$ 对答案的贡献为 $O(n\\log{n})$。\n\n实际上,利用 `list` 本身的有序性,我们在从前往后处理每个 $nums[idx]$ 时,对应的 $a$ 和 $b$ 也必然是逐步增大,因此我们可以使用「双指针」来避免「二分」操作,使得统计所有 $nums[i]$ 对答案贡献的复杂度从 $O(n\\log{n})$ 下降到 $O(n)$。\n\n代码:\n```Java\nclass Solution {\n    static int[] cnt = new int[10010];\n    public int findPairs(int[] nums, int k) {\n        Arrays.sort(nums);\n        List<Integer> list = new ArrayList<>();\n        for (int i : nums) {\n            if (list.isEmpty() || i != list.get(list.size() - 1)) list.add(i);\n        }\n        Arrays.fill(cnt, 0);\n        for (int i = 0, j = 0; i < nums.length; i++) {\n            if (nums[i] != list.get(j)) j++;\n            cnt[j]++;\n        }\n        int n = list.size(), idx = 0, ans = 0, l = 0, r = 0;\n        for (int i : list) {\n            if (k == 0) {\n                if (cnt[idx] > 1) ans++;\n            } else {\n                int a = i - k, b = i + k;\n                while (l < n && list.get(l) < a) l++;\n                while (r < n && list.get(r) < b) r++;\n                if (l < n && list.get(l) == a && cnt[l] > 0) ans++;\n                if (r < n && list.get(r) == b && cnt[r] > 0) ans++;\n            }\n            cnt[idx++] = 0;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序离散化复杂度为 $O(n\\log{n})$,统计答案复杂度为 $O(n)$,整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.532` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/531-540/535. TinyURL 的加密与解密（中等）.md", "url_title": "535. TinyURL 的加密与解密", "url": "https://leetcode.cn/problems/encode-and-decode-tinyurl/solution/by-ac_oier-ca6o/", "difficulty": "中等", "tags": ["哈希表", "模拟"], "question": "`TinyURL` 是一种 `URL` 简化服务, 比如:当你输入一个 URL `https://leetcode.com/problems/design-tinyurl` 时,它将返回一个简化的URL `http://tinyurl.com/4e9iAk` 。\n\n请你设计一个类来加密与解密 `TinyURL` 。\n\n加密和解密算法如何设计和运作是没有限制的,你只需要保证一个 `URL` 可以被加密成一个 `TinyURL` ,并且这个 `TinyURL` 可以用解密方法恢复成原本的 `URL` 。\n\n实现 `Solution` 类:\n* `Solution()` 初始化 `TinyURL` 系统对象。\n* `String encode(String longUrl)` 返回 `longUrl` 对应的 `TinyURL` 。\n* `String decode(String shortUrl)` 返回 `shortUrl` 原本的 `URL`。题目数据保证给定的 `shortUrl` 是由同一个系统对象加密的。\n\n示例:\n```\n输入:url = \"https://leetcode.com/problems/design-tinyurl\"\n\n输出:\"https://leetcode.com/problems/design-tinyurl\"\n\n解释:\nSolution obj = new Solution();\nstring tiny = obj.encode(url); // 返回加密后得到的 TinyURL 。\nstring ans = obj.decode(tiny); // 返回解密后得到的原本的 URL 。\n```\n\n提示:\n* $1 <= url.length <= 10^4$\n* 题目数据保证 `url` 是一个有效的 `URL`", "solution": "### 模拟 + 哈希表\n\n对于每个 `longUrl` 我们都在「大写字母/小写字母/数字」中随机 $k = 6$ 位作为其映射标识,这需要使用一个哈希表 `tiny2Origin` 进行记录。\n\n同时了防止相同的 `longUrl` 多次调用,确保 `encode` 服务的「幂等性」,我们再额外建立哈希表 `origin2Tiny` 来记录原串和映射标识的对应关系。\n\nJava 代码:\n```Java\npublic class Codec {\n    Map<String, String> origin2Tiny = new HashMap<>(), tiny2Origin = new HashMap<>();\n    String str = \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890\";\n    String prefix = \"https://acoier.com/tags/\";\n    int k = 6;\n    Random random = new Random();\n    public String encode(String longUrl) {\n        while (!origin2Tiny.containsKey(longUrl)) {\n            char[] cs = new char[k];\n            for (int i = 0; i < k; i++) cs[i] = str.charAt(random.nextInt(str.length()));\n            String cur = prefix + String.valueOf(cs);\n            if (tiny2Origin.containsKey(cur)) continue;\n            tiny2Origin.put(cur, longUrl);\n            origin2Tiny.put(longUrl, cur);\n        }\n        return origin2Tiny.get(longUrl);\n    }\n    public String decode(String shortUrl) {\n\t\treturn tiny2Origin.get(shortUrl);\n    }\n}\n```\n\nPython 代码:\n\n```Python\nclass Codec:\n    def __init__(self):\n        self.origin_to_tiny = {}\n        self.tiny_to_origin = {}\n        self.k = 6\n        self.prefix = 'https://acoier.com/tags/'\n        self.ss = string.ascii_letters + string.digits\n\n    def encode(self, longUrl: str) -> str:\n        while longUrl not in self.origin_to_tiny.keys():\n            cur = ''.join([self.ss[random.randint(0,len(self.ss) - 1)] for _ in range(self.k)])\n            if cur in self.tiny_to_origin.keys():\n                continue\n            self.tiny_to_origin[cur] = longUrl\n            self.origin_to_tiny[longUrl] = cur\n        return self.origin_to_tiny[longUrl]\n        \n    def decode(self, shortUrl: str) -> str:\n        return self.tiny_to_origin[shortUrl]\n```\n* 时间复杂度:`encode` 操作复杂度为 $O(C + L)$,其中 $C = 6$ 为短串长度,$L$ 为传入参数 `longUrl` 的长度(存入哈希表需要计算 `longUrl` 哈希值,该过程需要遍历 `longUrl`);`decode` 操作复杂度为 $O(C)$,其中 $L$ 为传入参数 `shortUrl` 的长度,该长度固定为 `prefix` 长度加 $6$\n* 空间复杂度:$O(K \\times L)$,其中 $K$ 为调用次数,$L$ 为平均 `longUrl` 长度\n\n---\n\n### 关于使用「自增 `id`」的答疑\n\n群里有同学问到为啥要使用「哈希存储映射关系」的方式,而不是用「自增 `id`」的方式,感觉可能是一部分同学的共同疑惑,这里统一回答一下。\n\n其中两点较为致命的弊端是:\n\n1. 使用「自增 `id`」更容易被枚举;\n    (再补充,提出原问题的好奇宝宝又问了另外一个问题)关于被枚举的坏处:粗略来说会导致安全性下降,被攻击的可能性大大增强。因为可枚举意味着,不能光靠 URL 特定发放来确保安全。\n    结合具体场景来说,假设某个活动日期生成了短 URL 的活动链接,只有特定用户可以访问,可枚举意味着竞品只需要大概知道你自增 id 当前在什么范围即可拿到活动链接,即使活动链接做了鉴权,也能通过攻击手段导致服务请求数量突增,影响真实的活动用户使用。\n    或许这个场景并不致命,竞品要拿到活动链接有很多方式,未必是通过枚举短 URL 来做到。\n    但另外一个场景则是致命的,就是可枚举会导致使用短 URL 服务的「验证服务」失效。\n    例如某个服务会通过「邮件/短信」发送短 URL 链接,让用户通过点击短 URL 来验证是否为某个「邮箱/手机号」的拥有者,短 URL 可枚举,意味着只需要知道当前自增 `id` 大概范围,就可通过枚举的方式访问到真实的验证地址,从而实现「不收到某个邮件/短信」也可以通过验证的目的。\n\n2. 相比于使用「哈希存储映射关系」的方式,不好重用:\n\n    举个🌰,例如映射关系都是 $7$ 天过期,每天会产生了 $10$ 个短 URL,当进行到第 $8$ 天,此时 `id` 已经自增到 $71$,同时第一天产生的短 URL 已过期,但是实现上,我们不好将 `id` 进行回拨(需要考虑当重用数字用完后要回到 $71$ 的位置)。也就是说,发现而且重用某些数字段(过期的 `id`)会为“自增”带来困扰,而引入「重用池」则违背了选择自增方案的初衷。\n    \n    但「哈希存储映射关系」要实现重用则是简单的,如果随机产生的短 URL 发生冲突,只需要直接拒绝进行重试即可,一旦产生短 URL 无冲突,则可以直接使用。同时由于随机通常服从某种分布,我们无须引入「过期时间戳」等信息,即可达到「某个短 URL 在使用后的一段时间后,都不会被随机到(不会在过期后就被迅速重用)」的作用,这一点可以通过调大 $k$ 值来进一步保证。\n\n防杠声明:当然,如果你只是在单纯的做算法题,就当我没说 🤣", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.535` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/531-540/537. 复数乘法（中等）.md", "url_title": "537. 复数乘法", "url": "https://leetcode-cn.com/problems/complex-number-multiplication/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-avlh/", "difficulty": "中等", "tags": ["模拟"], "question": "复数 可以用字符串表示,遵循 \"实部+虚部i\" 的形式,并满足下述条件:\n\n* 实部 是一个整数,取值范围是 $[-100, 100]$\n* 虚部 也是一个整数,取值范围是 $[-100, 100]$\n* $i^2 == -1$\n\n给你两个字符串表示的复数 `num1` 和 `num2` ,请你遵循复数表示形式,返回表示它们乘积的字符串。\n\n示例 1:\n```\n输入:num1 = \"1+1i\", num2 = \"1+1i\"\n\n输出:\"0+2i\"\n\n解释:(1 + i) * (1 + i) = 1 + i2 + 2 * i = 2i ,你需要将它转换为 0+2i 的形式。\n```\n示例 2:\n```\n输入:num1 = \"1+-1i\", num2 = \"1+-1i\"\n\n输出:\"0+-2i\"\n\n解释:(1 - i) * (1 - i) = 1 + i2 - 2 * i = -2i ,你需要将它转换为 0+-2i 的形式。 \n```\n\n提示:\n* `num1` 和 `num2` 都是有效的复数表示。", "solution": "### 模拟\n\n本题考察的是「复数乘法法则」运用。\n\n根据 $(a+bi)(c+di)=(ac-bd)+(bc+ad)i$,我们可以直接对 `nums1` 和 `nums2` 进行「实数」和「虚数」分割,按照法则运算后重新组成答案。\n\n代码:\n```Java\nclass Solution {\n    public String complexNumberMultiply(String num1, String num2) {\n        String[] ss1 = num1.split(\"\\\\+|i\"), ss2 = num2.split(\"\\\\+|i\");\n        int a = parse(ss1[0]), b = parse(ss1[1]);\n        int c = parse(ss2[0]), d = parse(ss2[1]);\n        int A = a * c - b * d, B = b * c + a * d;\n        return A + \"+\" + B + \"i\";\n    }\n    int parse(String s) {\n        return Integer.parseInt(s);\n    }\n}\n```\n* 时间复杂度:令 $n$ 和 $m$ 分别为两字符串长度,复杂度上界取决于正则分割,正则复杂度与字符串长度呈正比,整体复杂度为 $O(n + m)$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.537` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/531-540/538. 把二叉搜索树转换为累加树（中等）.md", "url_title": "538. 把二叉搜索树转换为累加树", "url": "https://leetcode.cn/problems/convert-bst-to-greater-tree/solutions/2555345/gong-shui-san-xie-li-yong-bst-de-zhong-x-vzqe/", "difficulty": "中等", "tags": ["BST", "中序遍历"], "question": "给出二叉搜索树的根节点,该树的节点值各不相同,请你将其转换为累加树(Greater Sum Tree),使每个节点 `node` 的新值等于原树中大于或等于 `node.val` 的值之和。\n\n提醒一下, 二叉搜索树满足下列约束条件:\n\n* 节点的左子树仅包含键小于节点键的节点。\n* 节点的右子树仅包含键大于节点键的节点。\n* 左右子树也必须是二叉搜索树。\n\n示例 1:\n\n```\n输入:[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]\n\n输出:[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]\n```\n示例 2:\n```\n输入:root = [0,null,1]\n\n输出:[1,null,1]\n```\n\n提示:\n* 树中的节点数在 $[1, 100]$ 范围内。\n* $0 <= Node.val <= 100$\n* 树中的所有值均不重复 。", "solution": "### 中序遍历\n\n利用 **`BST` 的中序遍历是有序** 的特性,我们可以通过两次遍历 `BST` 来求解问题。\n\n首先,通过一次遍历,计算出整棵树的节点总和 `tot`,然后在中序遍历过程中,不断对 `tot` 进行更新,将其作为当前未遍历到的节点的总和,用于给当前节点赋值。\n\n假设当前遍历到的节点为 `x`(起始节点值为 `t`),那么将节点更新为当前节点 `tot` 后,更新 `tot = tot - t`。\n\n这是常规的中序遍历做法,更进一步,如果将其中序遍历的顺序进行翻转(从「左中右」调整为「右中左」),则可实现一次遍历。\n\nJava 代码:\n```Java\nclass Solution {\n    int tot = 0;\n    public TreeNode convertBST(TreeNode root) {\n        dfs(root);\n        return root;\n    }\n    void dfs(TreeNode root) {\n        if (root == null) return ;\n        dfs(root.right);\n        tot += root.val;\n        root.val = tot;\n        dfs(root.left);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int tot = 0;\n    TreeNode* convertBST(TreeNode* root) {\n        dfs(root);\n        return root;\n    }\n    void dfs(TreeNode* root) {\n        if (root == nullptr) return;\n        dfs(root->right);\n        tot += root->val;\n        root->val = tot;\n        dfs(root->left);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def convertBST(self, root: TreeNode) -> TreeNode:\n        tot = 0\n        def dfs(root):\n            nonlocal tot\n            if not root: return\n            dfs(root.right)\n            tot += root.val\n            root.val = tot\n            dfs(root.left)\n        dfs(root)\n        return root\n```\nTypeScript 代码:\n```TypeScript\nfunction convertBST(root: TreeNode | null): TreeNode | null {\n    let tot = 0;\n    const dfs = function(root: TreeNode | null): void {\n        if (!root) return ;\n        dfs(root.right);\n        tot += root.val;\n        root.val = tot;\n        dfs(root.left);\n    }\n    dfs(root);\n    return root;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.538` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/531-540/539. 最小时间差（中等）.md", "url_title": "539. 最小时间差", "url": "https://leetcode-cn.com/problems/minimum-time-difference/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-eygg/", "difficulty": "中等", "tags": ["模拟", "排序", "哈希表"], "question": "给定一个 $24$ 小时制(小时:分钟 `\"HH:MM\"`)的时间列表,找出列表中任意两个时间的最小时间差并以分钟数表示。\n\n示例 1:\n```\n输入:timePoints = [\"23:59\",\"00:00\"]\n\n输出:1\n```\n示例 2:\n```\n输入:timePoints = [\"00:00\",\"23:59\",\"00:00\"]\n\n输出:0\n```\n\n提示:\n* $2 <= timePoints <= 2 * 10^4$\n* `timePoints[i]` 格式为 `\"HH:MM\"`", "solution": "### 模拟(排序)\n\n根据题意,我们需要找出「时钟盘」中的夹角最小的两个时间点,其中包括了分布在 `00:00` 左右两侧(横跨了一天)的时间点。\n\n因此,一种简单的方式是对于每个 $timePoints[i]$,我们不仅记录「当天该时间点」对应的的偏移量,还记录「下一天该时间点」对应的偏移量。\n\n处理所有的 $timePoints[i]$ 后,对偏移量进行排序,遍历找到所有相邻元素之间的最小值。\n\n**代码(感谢 [@Benhao](/u/himymben/) 和 [@🍭可乐可乐吗](/u/littletime_cc/) 同学提供的其他语言版本):**\n```Java\nclass Solution {\n    public int findMinDifference(List<String> timePoints) {\n        int n = timePoints.size() * 2;\n        int[] nums = new int[n];\n        for (int i = 0, idx = 0; i < n / 2; i++, idx += 2) {\n            String[] ss = timePoints.get(i).split(\":\");\n            int h = Integer.parseInt(ss[0]), m = Integer.parseInt(ss[1]);\n            nums[idx] = h * 60 + m;\n            nums[idx + 1] = nums[idx] + 1440;\n        }\n        Arrays.sort(nums);\n        int ans = nums[1] - nums[0];\n        for (int i = 0; i < n - 1; i++) ans = Math.min(ans, nums[i + 1] - nums[i]);\n        return ans;\n    }\n}\n```\n-\n```Python3\nclass Solution:\n    def findMinDifference(self, timePoints: List[str]) -> int:\n        n = len(timePoints) * 2\n        nums, idx = [0] * n, 0\n        for time in timePoints:\n            h, m = int(time[:2]), int(time[-2:])\n            nums[idx] = h * 60 + m\n            nums[idx + 1] = nums[idx] + 1440\n            idx += 2\n        nums.sort()\n        return min(nums[i + 1] - nums[i] for i in range(n - 1))\n```\n-\n```Go\nfunc findMinDifference(timePoints []string) int {\n    n := len(timePoints) * 2\n    nums := make([]int, n)\n    for i, idx := 0, 0; i < n / 2; i++ {\n        ss := strings.Split(timePoints[i], \":\")\n        h, _ := strconv.Atoi(ss[0])\n        m, _ := strconv.Atoi(ss[1])\n        nums[idx] = h * 60 + m\n        nums[idx + 1] = nums[idx] + 1440\n        idx += 2\n    }\n    sort.Ints(nums)\n    ans := nums[1] - nums[0];\n    for i := 1; i < n - 1; i++ {\n        if v := nums[i + 1] - nums[i]; v < ans {\n            ans = v\n        }\n    }\n    return ans\n}\n```\n-\n```C++\nclass Solution {\npublic:\n    int findMinDifference(vector<string>& timePoints) {\n        int n = timePoints.size() * 2;\n        vector<int> nums(n);\n        for(int i = 0, idx = 0; i < n / 2; i++, idx += 2){\n            string ss = timePoints[i];\n            auto pos = ss.find(':');\n            int h = stoi(ss.substr(0, pos)), m = stoi(ss.substr(pos + 1));\n            nums[idx] = h * 60 + m;\n            nums[idx + 1] = nums[idx] + 1440;\n        }\n        sort(nums.begin(), nums.end());\n        int ans = nums[1] - nums[0];\n        for(int i = 0; i < n - 1; i++){\n            ans = min(ans, nums[i + 1] - nums[i]);\n        }\n        return ans;\n    }\n};\n```\n-\n```C\nint min(int a,int b){ return a > b ? b : a; }\nint cmp(const void* a , const void* b){ return  (*(int*)a) - (*(int*)b); }\n\nint findMinDifference(char ** timePoints, int timePointsSize){\n    int n = timePointsSize * 2;\n    int* nums = (int*) malloc(sizeof(int) * n);\n    for(int i = 0, idx = 0; i < n / 2; i++, idx += 2){\n        timePoints[i][2] = '\\0';\n        int h = atoi(timePoints[i]), m = atoi(timePoints[i] + 3);\n        nums[idx] = h * 60 + m;\n        nums[idx + 1] = nums[idx] + 1440;\n    }\n    qsort(nums, n, sizeof(nums[0]), cmp);\n    int ans = nums[1] - nums[0];\n    for(int i = 0; i < n - 1; i++){\n        ans = min(ans, nums[i + 1] - nums[i]);\n    }\n    free(nums);\n    nums = NULL;\n    return ans;\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 模拟(哈希表计数)\n\n利用当天最多只有 $60 * 24 = 1440$ 个不同的时间点(跨天的话则是双倍),我们可以使用数组充当哈希表进行计数,同时根据「抽屉原理」,若 $timePoints$ 数量大于 $1440$,必然有两个相同时间点,用作剪枝。\n\n然后找到间隔最小两个时间点,这种利用「桶排序」的思路避免了对 $timePoints$ 所对应的偏移量进行排序,而 $O(C)$ 的复杂度使得所能处理的数据范围没有上限。\n\n代码:\n```Java\nclass Solution {\n    public int findMinDifference(List<String> timePoints) {\n        int n = timePoints.size();\n        if (n > 1440) return 0;\n        int[] cnts = new int[1440 * 2 + 10];\n        for (String s : timePoints) {\n            String[] ss = s.split(\":\");\n            int h = Integer.parseInt(ss[0]), m = Integer.parseInt(ss[1]);\n            cnts[h * 60 + m]++;\n            cnts[h * 60 + m + 1440]++;\n        }\n        int ans = 1440, last = -1;\n        for (int i = 0; i <= 1440 * 2 && ans != 0; i++) {\n            if (cnts[i] == 0) continue;\n            if (cnts[i] > 1) ans = 0;\n            else if (last != -1) ans = Math.min(ans, i - last);\n            last = i;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(C)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.539` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/531-540/540. 有序数组中的单一元素（中等）.md", "url_title": "540. 有序数组中的单一元素", "url": "https://leetcode-cn.com/problems/single-element-in-a-sorted-array/solution/gong-shui-san-xie-er-duan-xing-fen-xi-yu-17nv/", "difficulty": "中等", "tags": ["二分", "异或"], "question": "给你一个仅由整数组成的有序数组,其中每个元素都会出现两次,唯有一个数只会出现一次。\n\n请你找出并返回只出现一次的那个数。\n\n你设计的解决方案必须满足 $O(\\log n)$ 时间复杂度和 $O(1)$ 空间复杂度。\n\n示例 1:\n```\n输入: nums = [1,1,2,3,3,4,4,8,8]\n\n输出: 2\n```\n示例 2:\n```\n输入: nums =  [3,3,7,7,10,11,11]\n\n输出: 10\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $0 <= nums[i] <= 10^5$", "solution": "### 遍历\n\n数据范围为 $10^5$,最简单的方法是以「步长为 $2$」的方式进行从前往后的遍历,找到第一个不符合「与后一个数相等」条件的值即是答案。\n\n或是利用单个元素只有一个(其余成对出现),从头到尾异或一遍,最终结果为单一元素值。\n\n代码:\n```Java\nclass Solution {\n    public int singleNonDuplicate(int[] nums) {\n        int n = nums.length;\n        for (int i = 0; i < n - 1; i += 2) {\n            if (nums[i] != nums[i + 1]) return nums[i];\n        }\n        return nums[n - 1];\n    }\n}\n```\n-\n```Java\nclass Solution {\n    public int singleNonDuplicate(int[] nums) {\n        int ans = 0;\n        for (int i : nums) ans ^= i;\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 二分\n\n这道题的「二段性」分析需要一点点「脑筋急转弯」。\n\n由于给定数组有序 且 常规元素总是两两出现,**因此如果不考虑“特殊”的单一元素的话,我们有结论:成对元素中的第一个所对应的下标必然是偶数,成对元素中的第二个所对应的下标必然是奇数。**\n\n然后再考虑存在单一元素的情况,假如单一元素所在的下标为 $x$,那么下标 $x$ 之前(左边)的位置仍满足上述结论,而下标 $x$ 之后(右边)的位置由于 $x$ 的插入,导致结论翻转。\n\n存在这样的二段性,指导我们根据当前二分点 $mid$ 的奇偶性进行分情况讨论:\n\n* $mid$ 为偶数下标:根据上述结论,正常情况下偶数下标的值会与下一值相同,因此如果满足该条件,可以确保 $mid$ 之前并没有插入单一元素。正常情况下,此时应该更新 $l = mid$,否则应当让 $r = mid - 1$,但需要注意这样的更新逻辑,会因为更新 $r$ 时否决 $mid$ 而错过答案,我们可以将否决 $mid$ 的动作放到更新 $l$ 的一侧,即需要将更新逻辑修改为 $l = mid + 1$ 和 $r = mid$ ;\n\n* $mid$ 为奇数下标:同理,根据上述结论,正常情况下奇数下标的值会与上一值相同,因此如果满足该条件,可以确保 $mid$ 之前并没有插入单一元素,相应的更新 $l$ 和 $r$。\n\n代码:\n```Java\nclass Solution {\n    public int singleNonDuplicate(int[] nums) {\n        int n = nums.length;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (mid % 2 == 0) {\n                if (mid + 1 < n && nums[mid] == nums[mid + 1]) l = mid + 1;\n                else r = mid;\n            } else {\n                if (mid - 1 >= 0 && nums[mid - 1] == nums[mid]) l = mid + 1;\n                else r = mid;\n            }\n        }\n        return nums[r];\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 二分(异或技巧)\n\n不难发现,上述解法对奇偶下标的分情况讨论仅在于当前值 $nums[i]$ 是与 $nums[i + 1]$(当 $i$ 为偶数时)还是 $nums[i - 1]$(当 $i$ 为奇数时)进行比较。\n\n而这样的「连续段 偶奇 两两成对」的组合,适合使用「异或」来找相应的成组对象。\n\n实际上,该技巧广泛地应用在图论存图中:**使用邻接表(链式向前星)存无向图时,直接访问「当前边 $e$」所对应的「反向边 $e'$」。这也是为什么在「链式向前星」中我们只需要使用「单链表」并设定 $idx$ 从 $0$ 开始进行存图即可:能够满足遍历所有出边,同时如果有访问相应反向边的需求,只需要通过 `e[i^1]` 访问。**\n\n对这种存图方式不熟悉的同学,可以看前置 🧀:[涵盖所有的「存图方式」与「最短路算法(详尽注释)」](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488007&idx=1&sn=9d0dcfdf475168d26a5a4bd6fcd3505d&chksm=fd9cb918caeb300e1c8844583db5c5318a89e60d8d552747ff8c2256910d32acd9013c93058f&token=381012359&lang=zh_CN#rd)。\n\n代码:\n```Java\nclass Solution {\n    public int singleNonDuplicate(int[] nums) {\n        int n = nums.length;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (nums[mid] == nums[mid ^ 1]) l = mid + 1;\n            else r = mid;\n        }\n        return nums[r];\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.540` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/541-550/541. 反转字符串 II（简单）.md", "url_title": "541. 反转字符串 II", "url": "https://leetcode-cn.com/problems/reverse-string-ii/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-p88f/", "difficulty": "简单", "tags": ["模拟"], "question": "给定一个字符串 s 和一个整数 k,从字符串开头算起,每 2k 个字符反转前 k 个字符。\n\n* 如果剩余字符少于 k 个,则将剩余字符全部反转。\n* 如果剩余字符小于 2k 但大于或等于 k 个,则反转前 k 个字符,其余字符保持原样。\n\n示例 1:\n```\n输入:s = \"abcdefg\", k = 2\n\n输出:\"bacdfeg\"\n```\n示例 2:\n```\n输入:s = \"abcd\", k = 2\n\n输出:\"bacd\"\n```\n\n提示:\n* 1 <= s.length <= $10^4$\n* s 仅由小写英文组成\n* 1 <= k <= $10^4$", "solution": "### 模拟\n\n使用 `l` 和 `r` 两个指针分别圈出每次需要翻转的“理论”范围,每次翻转完更新 `l` 和 `r`,同时注意范围 $[l, r]$ 内不足 $k$ 个的情况(将 `r` 与真实边界 `n - 1`取个 $min$)。\n\n代码:\n```Java\nclass Solution {\n    public String reverseStr(String s, int k) {\n        char[] cs = s.toCharArray();\n        int n = s.length();\n        for (int l = 0; l < n; l = l + 2 * k) {\n            int r = l + k - 1;\n            reverse(cs, l, Math.min(r, n - 1));\n        }\n        return String.valueOf(cs);\n    }\n    void reverse(char[] cs, int l, int r) {\n        while (l < r) {\n            char c = cs[l];\n            cs[l] = cs[r];\n            cs[r] = c;\n            l++; r--;\n        }\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:Java 中 `String` 属于不可变,复杂度为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.541` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/541-550/543. 二叉树的直径（简单）.md", "url_title": "543. 二叉树的直径", "url": "https://leetcode.cn/problems/diameter-of-binary-tree/solutions/2454405/gong-shui-san-xie-jian-dan-dfs-yun-yong-vbf27/", "difficulty": "简单", "tags": ["二叉树", "DFS"], "question": "给你一棵二叉树的根节点,返回该树的直径。\n\n二叉树的直径是指树中任意两个节点之间最长路径的长度。\n\n这条路径可能经过也可能不经过根节点 `root`。\n\n两节点之间路径的长度由它们之间边数表示。\n\n示例 1:\n\n```\n输入:root = [1,2,3,4,5]\n\n输出:3\n\n解释:3 ,取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。\n```\n示例 2:\n```\n输入:root = [1,2]\n\n输出:1\n```\n\n提示:\n* 树中节点数目在范围 $[1, 10^4]$ 内\n* $-100 <= Node.val <= 100$", "solution": "### DFS\n\n定义全局变量 `ans`(初始化为 `0`),用于记录二叉树的最大直径。\n\n设计用于遍历二叉树的 `DFS` 函数:函数传入当前节点 `u`,返回以该节点为根时,方向“往下”的最大路径节点数量(注意这里是点数,而不是题目要求的边数)。\n\n单次执行流程中,先递归处理当前节点 `u` 的左右节点,得到左右子树为根时的“往下”最大路径 `l` 和 `r`,两者中的较大值 `+1` 即是本次执行流程的返回值(`+1` 的含义是在子路径基础上增加当前节点)。\n\n同时,`l + r` 则是以当前节点 `u` 为路径最高点时的路径长度,用此更新全局 `ans` 即可。\n\nJava 代码:\n```Java\nclass Solution {\n    int ans = 0;\n    public int diameterOfBinaryTree(TreeNode root) {\n        dfs(root);\n        return ans;\n    }\n    int dfs(TreeNode u) {\n        if (u == null) return 0;\n        int l = dfs(u.left), r = dfs(u.right);\n        ans = Math.max(ans, l + r);\n        return Math.max(l, r) + 1;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int ans = 0;\n    int diameterOfBinaryTree(TreeNode* root) {\n        dfs(root);\n        return ans;\n    }\n    int dfs(TreeNode* u) {\n        if (u == NULL) return 0;\n        int l = dfs(u->left), r = dfs(u->right);\n        ans = max(ans, l + r);\n        return max(l, r) + 1;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def diameterOfBinaryTree(self, root: TreeNode) -> int:\n        ans = 0\n        def dfs(u):\n            nonlocal ans\n            if not u: return 0\n            left, right = dfs(u.left), dfs(u.right)\n            ans = max(ans, left + right)\n            return max(left, right) + 1 \n        dfs(root)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction diameterOfBinaryTree(root: TreeNode | null): number {\n    let ans = 0;\n    const dfs = function(u: TreeNode): number {\n        if (!u) return 0;\n        const l = dfs(u.left), r = dfs(u.right);\n        ans = Math.max(ans, l + r);\n        return Math.max(l, r) + 1;\n    };\n    dfs(root);\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.543` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/551-560/551. 学生出勤记录 I（简单）.md", "url_title": "551. 学生出勤记录 I", "url": "https://leetcode-cn.com/problems/student-attendance-record-i/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-hui7/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个字符串 s 表示一个学生的出勤记录,其中的每个字符用来标记当天的出勤情况(缺勤、迟到、到场)。记录中只含下面三种字符:\n* 'A':Absent,缺勤\n* 'L':Late,迟到\n* 'P':Present,到场\n\n如果学生能够 同时 满足下面两个条件,则可以获得出勤奖励:\n\n按 总出勤 计,学生缺勤('A')严格 少于两天。\n学生 不会 存在 连续 3 天或 3 天以上的迟到('L')记录。\n如果学生可以获得出勤奖励,返回 true ;否则,返回 false 。\n\n示例 1:\n```\n输入:s = \"PPALLP\"\n\n输出:true\n\n解释:学生缺勤次数少于 2 次,且不存在 3 天或以上的连续迟到记录。\n```\n示例 2:\n```\n输入:s = \"PPALLL\"\n\n输出:false\n\n解释:学生最后三天连续迟到,所以不满足出勤奖励的条件。\n```\n\n提示:\n* 1 <= s.length <= 1000\n* s[i] 为 'A'、'L' 或 'P'", "solution": "### 模拟\n\n放大假,根据题意进行模拟即可。\n\n代码:\n```Java\nclass Solution {\n    public boolean checkRecord(String s) {\n        int n = s.length();\n        char[] cs = s.toCharArray();\n        for (int i = 0, cnt = 0; i < n; ) {\n            char c = cs[i];\n            if (c == 'A') {\n                cnt++;\n                if (cnt >= 2) return false;\n            } else if (c == 'L') {\n                int j = i;\n                while (j < n && cs[j] == 'L') j++;\n                int len = j - i;\n                if (len >= 3) return false;\n                i = j;\n                continue;\n            }\n            i++;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:使用 `charAt` 代替 `toCharArray` 的话为 $O(1)$,否则为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.551` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/551-560/552. 学生出勤记录 II（困难）.md", "url_title": "552. 学生出勤记录 II", "url": "https://leetcode-cn.com/problems/student-attendance-record-ii/solution/gong-shui-san-xie-yi-ti-san-jie-ji-yi-hu-fdfx/", "difficulty": "困难", "tags": ["动态规划", "状态机", "记忆化搜索", "矩阵快速幂", "数学"], "question": "可以用字符串表示一个学生的出勤记录,其中的每个字符用来标记当天的出勤情况(缺勤、迟到、到场)。\n\n记录中只含下面三种字符:\n\n* 'A':Absent,缺勤\n* 'L':Late,迟到\n* 'P':Present,到场\n\n如果学生能够**同时**满足下面两个条件,则可以获得出勤奖励:\n\n* 按**总出勤**计,学生缺勤('A')严格 少于两天。\n* 学生**不会**存在 连续 3 天或 连续 3 天以上的迟到('L')记录。\n\n给你一个整数 n ,表示出勤记录的长度(次数)。请你返回记录长度为 n 时,可能获得出勤奖励的记录情况 数量 。\n\n答案可能很大,所以返回对 $10^9 + 7$ **取余**的结果。\n\n示例 1:\n```\n输入:n = 2\n\n输出:8\n\n解释:\n有 8 种长度为 2 的记录将被视为可奖励:\n\"PP\" , \"AP\", \"PA\", \"LP\", \"PL\", \"AL\", \"LA\", \"LL\" \n只有\"AA\"不会被视为可奖励,因为缺勤次数为 2 次(需要少于 2 次)。\n```\n示例 2:\n```\n输入:n = 1\n\n输出:3\n```\n示例 3:\n```\n输入:n = 10101\n\n输出:183236316\n```\n\n提示:\n* 1 <= n <= $10^5$", "solution": "### 基本分析\n\n根据题意,我们知道一个合法的方案中 `A` 的总出现次数最多为 $1$ 次,`L` 的连续出现次数最多为 $2$ 次。\n\n**因此在枚举/统计合法方案的个数时,当我们决策到某一位应该选什么时,我们关心的是当前方案中已经出现了多少个 `A`(以决策当前能否填入 `A`)以及连续出现的 `L` 的次数是多少(以决策当前能否填入 `L`)。**\n\n---\n\n### 记忆化搜索\n\n枚举所有方案的爆搜 `DFS` 代码不难写,大致的函数签名设计如下:\n\n```Java\n/**\n * @param u 当前还剩下多少位需要决策\n * @param acnt 当前方案中 A 的总出现次数\n * @param lcnt 当前方案中结尾 L 的连续出现次数\n * @param cur 当前方案\n * @param ans 结果集\n */\nvoid dfs(int u, int acnt, int lcnt, String cur, List<String> ans);\n```\n实际上,我们不需要枚举所有的方案数,因此我们只需要保留函数签名中的前三个参数即可。\n\n同时由于我们在计算某个 $(u, acnt, lcnt)$ 的方案数时,其依赖的状态可能会被重复使用,考虑加入记忆化,将结果缓存起来。\n\n根据题意,$n$ 的取值范围为 $[0, n]$,$acnt$ 取值范围为 $[0,1]$,$lcnt$ 取值范围为 $[0, 2]$。\n\n代码:\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    int[][][] cache;\n    public int checkRecord(int n) {\n        cache = new int[n + 1][2][3];\n        for (int i = 0; i <= n; i++) {\n            for (int j = 0; j < 2; j++) {\n                for (int k = 0; k < 3; k++) {\n                    cache[i][j][k] = -1;\n                }\n            }\n        }\n        return dfs(n, 0, 0);\n    }\n    int dfs(int u, int acnt, int lcnt) {\n        if (acnt >= 2) return 0;\n        if (lcnt >= 3) return 0;\n        if (u == 0) return 1;\n        if (cache[u][acnt][lcnt] != -1) return cache[u][acnt][lcnt];\n        int ans = 0;\n        ans = dfs(u - 1, acnt + 1, 0) % mod; // A\n        ans = (ans + dfs(u - 1, acnt, lcnt + 1)) % mod; // L\n        ans = (ans + dfs(u - 1, acnt, 0)) % mod; // P\n        cache[u][acnt][lcnt] = ans;\n        return ans;\n    }\n}\n```\n* 时间复杂度:有 $O(n * 2 * 3)$ 个状态需要被计算,复杂度为 $O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 状态机 DP\n\n通过记忆化搜索的分析我们发现,当我们在决策下一位是什么的时候,依赖于前面已经填入的 `A` 的个数以及当前结尾处的 `L` 的连续出现次数。\n\n**也就说是,状态 $f[u][acnt][lcnt]$ 必然被某些特定状态所更新,或者说由 $f[u][[acnt][lcnt]$ 出发,所能更新的状态是固定的。**\n\n因此这其实是一个状态机模型的 DP 问题。\n\n**根据「更新 $f[u][acnt][lcnt]$ 需要哪些状态值」还是「从 $f[u][acnt][lcnt]$  出发,能够更新哪些状态」,我们能够写出两种方式(方向)的 DP 代码:**\n\n**一类是从 $f[u][acnt][lcnt]$ 往回找所依赖的状态;一类是从 $f[u][acnt][lcnt]$  出发往前去更新所能更新的状态值。**\n\n无论是何种方式(方向)的 DP 实现都只需搞清楚「当前位的选择对 $acnt$​ 和 $lcnt$​ 的影响」即可。\n\n代码:\n```Java\n// 从 f[u][acnt][lcnt] 往回找所依赖的状态\nclass Solution {\n    int mod = (int)1e9+7;\n    public int checkRecord(int n) {\n        int[][][] f = new int[n + 1][2][3];\n        f[0][0][0] = 1;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 0; j < 2; j++) {\n                for (int k = 0; k < 3; k++) {\n                    if (j == 1 && k == 0) { // A\n                        f[i][j][k] = (f[i][j][k] + f[i - 1][j - 1][0]) % mod;\n                        f[i][j][k] = (f[i][j][k] + f[i - 1][j - 1][1]) % mod;\n                        f[i][j][k] = (f[i][j][k] + f[i - 1][j - 1][2]) % mod;\n                    }\n                    if (k != 0) { // L\n                        f[i][j][k] = (f[i][j][k] + f[i - 1][j][k - 1]) % mod;\n                    }\n                    if (k == 0) { // P\n                        f[i][j][k] = (f[i][j][k] + f[i - 1][j][0]) % mod;\n                        f[i][j][k] = (f[i][j][k] + f[i - 1][j][1]) % mod;\n                        f[i][j][k] = (f[i][j][k] + f[i - 1][j][2]) % mod;\n                    }\n                }\n            }\n        }\n        int ans = 0;\n        for (int j = 0; j < 2; j++) {\n            for (int k = 0; k < 3; k++) {\n                ans += f[n][j][k];\n                ans %= mod;\n            }\n        }\n        return ans;\n    }\n}\n```\n\n```Java\n// 从 f[u][acnt][lcnt] 出发往前去更新所能更新的状态值\nclass Solution {\n    int mod = (int)1e9+7;\n    public int checkRecord(int n) {\n        int[][][] f = new int[n + 1][2][3];\n        f[0][0][0] = 1;\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < 2; j++) {\n                for (int k = 0; k < 3; k++) {\n                    if (j != 1) f[i + 1][j + 1][0] = (f[i + 1][j + 1][0] + f[i][j][k]) % mod; // A\n                    if (k != 2) f[i + 1][j][k + 1] = (f[i + 1][j][k + 1] + f[i][j][k]) % mod; // L\n                    f[i + 1][j][0] = (f[i + 1][j][0] + f[i][j][k]) % mod; // P\n                }\n            }\n        }\n        int ans = 0;\n        for (int j = 0; j < 2; j++) {\n            for (int k = 0; k < 3; k++) {\n                ans += f[n][j][k];\n                ans %= mod;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 矩阵快速幂\n\n之所以在动态规划解法中强调更新状态的方式(方向)是「往回」还是「往前」,是因为对于存在线性关系(同时又具有结合律)的递推式,我们能够通过「矩阵快速幂」来进行加速。\n\n矩阵快速幂的基本分析之前在 [(题解) 1137. 第 N 个泰波那契数](https://leetcode-cn.com/problems/n-th-tribonacci-number/solution/gong-shui-san-xie-yi-ti-si-jie-die-dai-d-m1ie/) 详细讲过。\n\n由于 $acnt$ 和 $lcnt$ 的取值范围都很小,其组合的状态只有 $2 * 3  = 6$ 种,我们使用 $idx = acnt * 3 + lcnt$ 来代指组合(通用的二维转一维方式):\n\n* $idx = 0$ :$acnt = 0、lcnt = 0$;\n* $idx = 1$ :$acnt = 1、lcnt = 0$;\n...\n* $idx = 5$ :$acnt = 1、lcnt = 2$;\n\n最终答案为 $ans = \\sum_{idx = 0}^{5} f[n][idx]$​,将答案依赖的状态整理成列向量:\n\n$$\ng[n] = \\begin{bmatrix}\nf[n][0]\\\\ \nf[n][1]\\\\ \nf[n][2]\\\\\nf[n][3]\\\\\nf[n][4]\\\\\nf[n][5]\n\\end{bmatrix}\n$$\n\n根据状态机逻辑,可得:\n\n$$\ng[n] = \\begin{bmatrix}\nf[n][0]\\\\ \nf[n][1]\\\\ \nf[n][2]\\\\\nf[n][3]\\\\\nf[n][4]\\\\\nf[n][5]\n\\end{bmatrix}\n = \\begin{bmatrix}\nf[n - 1][0] * 1 + f[n - 1][1] * 1 + f[n - 1][2] * 1 + f[n - 1][3] * 0 + f[n - 1][4] * 0 + f[n - 1][5] * 0\\\\ \nf[n - 1][0] * 1 + f[n - 1][1] * 0 + f[n - 1][2] * 0 + f[n - 1][3] * 0 + f[n - 1][4] * 0 + f[n - 1][5] * 0\\\\ \nf[n - 1][0] * 0 + f[n - 1][1] * 1 + f[n - 1][2] * 0 + f[n - 1][3] * 0 + f[n - 1][4] * 0 + f[n - 1][5] * 0\\\\\nf[n - 1][0] * 1 + f[n - 1][1] * 1 + f[n - 1][2] * 1 + f[n - 1][3] * 1 + f[n - 1][4] * 1 + f[n - 1][5] * 1\\\\\nf[n - 1][0] * 0 + f[n - 1][1] * 0 + f[n - 1][2] * 0 + f[n - 1][3] * 1 + f[n - 1][4] * 0 + f[n - 1][5] * 0\\\\\nf[n - 1][0] * 0 + f[n - 1][1] * 0 + f[n - 1][2] * 0 + f[n - 1][3] * 0 + f[n - 1][4] * 1 + f[n - 1][5] * 0\n\\end{bmatrix}\n$$\n\n我们令:\n$$\nmat = \\begin{bmatrix}\n1 &1 &1 &0 &0 &0 \\\\ \n1 &0 &0 &0 &0 &0 \\\\\n0 &1 &0 &0 &0 &0 \\\\\n1 &1 &1 &1 &1 &1 \\\\\n0 &0 &0 &1 &0 &0 \\\\\n0 &0 &0 &0 &1 &0\n\\end{bmatrix}\n$$\n\n根据「矩阵乘法」即有:\n\n$$\ng[n] = mat * g[n - 1]\n$$\n\n起始时,我们只有 $g[0]$,根据递推式得:\n\n$$\ng[n] = mat * mat * ... * mat * g[0]\n$$\n\n再根据矩阵乘法具有「结合律」,最终可得:\n\n$$\ng[n] = mat^n * g[0]\n$$\n\n计算 $mat^n$ 可以套用「快速幂」进行求解。\n\n代码:\n```Java\nclass Solution {\n    int N = 6;\n    int mod = (int)1e9+7;\n    long[][] mul(long[][] a, long[][] b) {\n        int r = a.length, c = b[0].length, z = b.length;\n        long[][] ans = new long[r][c];\n        for (int i = 0; i < r; i++) {\n            for (int j = 0; j < c; j++) {\n                for (int k = 0; k < z; k++) {\n                    ans[i][j] += a[i][k] * b[k][j];\n                    ans[i][j] %= mod;\n                }\n            }\n        }\n        return ans;\n    }\n    public int checkRecord(int n) {\n        long[][] ans = new long[][]{\n            {1}, {0}, {0}, {0}, {0}, {0}\n        };\n        long[][] mat = new long[][]{\n            {1, 1, 1, 0, 0, 0},\n            {1, 0, 0, 0, 0, 0},\n            {0, 1, 0, 0, 0, 0},\n            {1, 1, 1, 1, 1, 1},\n            {0, 0, 0, 1, 0, 0},\n            {0, 0, 0, 0, 1, 0}\n        };\n        while (n != 0) {\n            if ((n & 1) != 0) ans = mul(mat, ans);\n            mat = mul(mat, mat);\n            n >>= 1;\n        }\n        int res = 0;\n        for (int i = 0; i < N; i++) {\n            res += ans[i][0];\n            res %= mod;\n        }\n        return res;\n    } \n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.552` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/551-560/553. 最优除法（中等）.md", "url_title": "553. 最优除法", "url": "https://leetcode-cn.com/problems/optimal-division/solution/gong-shui-san-xie-shu-xue-lei-tan-xin-yu-61sq/", "difficulty": "中等", "tags": ["贪心", "数学"], "question": "给定一组正整数,相邻的整数之间将会进行浮点除法操作。例如, [2,3,4] -> 2 / 3 / 4 。\n\n但是,你可以在任意位置添加任意数目的括号,来改变算数的优先级。你需要找出怎么添加括号,才能得到最大的结果,并且返回相应的字符串格式的表达式。你的表达式不应该含有冗余的括号。\n\n示例:\n```\n输入: [1000,100,10,2]\n\n输出: \"1000/(100/10/2)\"\n\n解释:\n1000/(100/10/2) = 1000/((100/10)/2) = 200\n但是,以下加粗的括号 \"1000/((100/10)/2)\" 是冗余的,\n因为他们并不影响操作的优先级,所以你需要返回 \"1000/(100/10/2)\"。\n\n其他用例:\n1000/(100/10)/2 = 50\n1000/(100/(10/2)) = 50\n1000/100/10/2 = 0.5\n1000/100/(10/2) = 2\n```\n说明:\n* 输入数组的长度在 $[1, 10]$ 之间。\n* 数组中每个元素的大小都在 $[2, 1000]$ 之间。\n* 每个测试用例只有一个最优除法解。", "solution": "### 数学 + 贪心\n\n我们假定取得最优解的表示为 $\\frac{a}{b}$,可以留意到任意的 $nums[i]$ 的范围为 $[2, 1000]$,因此我们应当让尽可能多的 $nums[i]$ 参与 $a$(分子)的构建中。\n\n因此一种可以构成最优表示的方式为「将除第一位以外的所有数作为一组,进行连除(转乘法),从而将所有 **可以** 变成分子的数都参与到 $a$ 的构建中」。\n\n即有:\n$$\n\\frac{nums[0]}{nums[1] / nums[2] / ... / nums[n - 1]} = \\frac{nums[0]}{nums[1] * \\frac{1}{nums[2]} * ... * \\frac{1}{nums[n - 1]}} = \\frac{nums[0] * nums[2] * ... * nums[n - 1]}{nums[1]}\n$$\n\n综上,我们只需要从前往后进行构建出连除的答案,如果 $nums$ 的长度大于 $2$,再追加一对大括号即可。\n\n$[a_0, a_1, ... , a_n]$ => $a_0/a_1/.../a_n$ => $a_0/(a_1/.../a_n)$\n\n代码:\n```Java\nclass Solution {\n    public String optimalDivision(int[] nums) {\n        int n = nums.length;\n        StringBuilder sb = new StringBuilder();\n        for (int i = 0; i < n; i++) {\n            sb.append(nums[i]);\n            if (i + 1 < n) sb.append(\"/\");\n        }\n        if (n > 2) {\n            sb.insert(sb.indexOf(\"/\") + 1, \"(\");\n            sb.append(\")\");\n        }\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n * C)$,其中 $C$ 为 $nums[i]$ 的最大长度,对于本题 $C = 4$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.553` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/551-560/554. 砖墙（中等）.md", "url_title": "554. 砖墙", "url": "https://leetcode-cn.com/problems/brick-wall/solution/gong-shui-san-xie-zheng-nan-ze-fan-shi-y-gsri/", "difficulty": "中等", "tags": ["哈希表"], "question": "你的面前有一堵矩形的、由 n 行砖块组成的砖墙。\n\n这些砖块高度相同(也就是一个单位高)但是宽度不同。每一行砖块的宽度之和相等。\n\n你现在要画一条 自顶向下 的、穿过 最少 砖块的垂线。\n\n如果你画的线只是从砖块的边缘经过,就不算穿过这块砖。\n\n你不能沿着墙的两个垂直边缘之一画线,这样显然是没有穿过一块砖的。\n\n给你一个二维数组 wall ,该数组包含这堵墙的相关信息。\n\n其中,wall[i] 是一个代表从左至右每块砖的宽度的数组。\n\n你需要找出怎样画才能使这条线 穿过的砖块数量最少 ,并且返回 穿过的砖块数量 。\n\n \n\n示例 1:\n\n```\n输入:wall = [[1,2,2,1],[3,1,2],[1,3,2],[2,4],[3,1,2],[1,3,1,1]]\n\n输出:2\n```\n示例 2:\n```\n输入:wall = [[1],[1],[1]]\n\n输出:3\n```\n提示:\n* n == wall.length\n* 1 <= n <= $10^4$\n* 1 <= wall[i].length <= $10^4$\n* 1 <= sum(wall[i].length) <= 2 * $10^4$\n* 对于每一行 i ,sum(wall[i]) 是相同的\n* 1 <= `wall[i][j]` <= $2^{31}$ - 1", "solution": "### 哈希表\n\n题目要求穿过的砖块数量最少,等效于通过的间隙最多。\n\n**我们可以使用「哈希表」记录每个间隙的出现次数,最终统计所有行中哪些间隙出现得最多,使用「总行数」减去「间隙出现的最多次数」即是答案。**\n\n如何记录间隙呢?直接使用行前缀记录即可。\n\n就用示例数据来举 🌰 :\n\n* 第 1 行的间隙有 `[1,3,5]`\n* 第 2 行的间隙有 `[3,4]`\n* 第 3 行的间隙有 `[1,4]`\n* 第 4 行的间隙有 `[2]`\n* 第 5 行的间隙有 `[3,4]`\n* 第 6 行的间隙有 `[1,4,5]`\n\n对间隙计数完成后,遍历「哈希表」找出出现次数最多间隙 `4`,根据同一个间隙编号只会在单行内被统计一次,用总行数减去出现次数,即得到「最少穿过的砖块数」。\n\n代码:\n```Java\nclass Solution {\n    public int leastBricks(List<List<Integer>> wall) {\n        int n = wall.size();\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = 0, sum = 0; i < n; i++, sum = 0) {\n            for (int cur : wall.get(i)) {\n                sum += cur;\n                map.put(sum, map.getOrDefault(sum, 0) + 1);\n            }\n            map.remove(sum); // 不能从两边穿过,需要 remove 掉最后一个\n        }\n        int ans = n;\n        for (int u : map.keySet()) {\n            int cnt = map.get(u);\n            ans = Math.min(ans, n - cnt);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:记所有砖块数量为 `n`,所有砖块都会被扫描。复杂度为 $O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 关于是否需要考虑「溢出」的说明\n\n类似的问题,在之前 [题解](https://leetcode-cn.com/problems/combination-sum-iv/solution/gong-shui-san-xie-yu-wan-quan-bei-bao-we-x0kn/) 也说过,这里再提一下 ~ \n\n**当 Java 发生溢出时,会直接转成负数来处理**。因此对于本题不会影响正确性(不重复溢出的话)。\n\n可以通过以下例子来体会:\n\n```Java\n{\n    System.out.println(Integer.MIN_VALUE); // -2147483648\n    \n    int a = Integer.MAX_VALUE;\n    System.out.println(a); // 2147483647\n    a += 1;\n    System.out.println(a); // -2147483648\n    a -= 1;\n    System.out.println(a); //2147483647\n}\n```\n\n这意味着,如果我们在运算过程中如果只涉及「纯加减运算」,而不涉及「乘除」、「取最大值/最小值」和「数值大小判断」的话,Java 是不需要使用 `Long` 来确保正确性的,因为最终溢出会被转化回来。\n\n按道理,CPP 本身对于 `int` 溢出的转化处理也是一样的。\n\n**但在 LC 上的 CPP 发生溢出时,不会直接转成负数来处理,而是直接抛出异常**。因此同样的代码在 LC 上是无法被正常执行的:\n\n```C++ []\n{\n    cout << INT_MIN << endl; //-2147483648\n\n    int a = INT_MAX; \n    cout << a << endl; // 2147483647\n    a += 1; // 溢出报错\n    cout << a << endl;\n    a -= 1;\n    cout << a << endl;\n}\n```\n\n**这是一般性的,对于 LC 上的同一道题,Java 不需要处理溢出,CPP 需要处理的原因。**\n\n***\n其实对应到本题,我这里不使用 long long,是因为猜想「题目」中的条件写错了:\n\n```Java \n1 <= sum(wall[i]) <= 2 * 10^4\n\n错写成了\n\n1 <= sum(wall[i].length) <= 2 * 10^4\n```\n\n因为在给定下面两个条件的情况下:\n\n```\n1 <= n <= 10^4\n1 <= wall[i].length <= 10^4\n```\n\n$1 <= sum(wall[i].length) <= 2 * 10^4$ 十分多余。\n\n针对反例:\n```Java\n[\n    [2147483647,2147483647,2147483647,2147483647,1,2], \n    [2,2147483647,2147483647,2147483647,2147483647,1]\n]\n```\n\n我用官方提供的代码,跑的也是 0,所以如果是以官方的代码为评测标准的话,用 long long 反而是 WA 了 🤣", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.554` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/551-560/556. 下一个更大元素 III（中等）.md", "url_title": "556. 下一个更大元素 III", "url": "https://leetcode.cn/problems/next-greater-element-iii/solution/by-ac_oier-99bj/", "difficulty": "中等", "tags": ["模拟", "双指针"], "question": "给你一个正整数 $n$,请你找出符合条件的最小整数,其由重新排列 $n$ 中存在的每位数字组成,并且其值大于 $n$。\n\n如果不存在这样的正整数,则返回 $-1$ 。\n\n注意 ,返回的整数应当是一个 $32$ 位整数 ,如果存在满足题意的答案,但不是 $32$ 位整数 ,同样返回 $-1$。\n\n示例 1:\n```\n输入:n = 12\n\n输出:21\n```\n示例 2:\n```\n输入:n = 21\n\n输出:-1\n```\n\n提示:\n* $1 <= n <= 2^{31} - 1$", "solution": "### 模拟\n\n根据题意,只有给定数字 $x$ 本身从高位到低位是「非严格降序」时,我们无法找到一个合法值。\n\n首先,我们可以先对 $x$ 诸位取出,存成 `nums` 数组(数组的首位元素为原数 $x$ 的最低位)。\n\n然后尝试找到第一个能够交换的位置 `idx`(若无法找到,说明不存在合法值,返回 $-1$),即从 $nums[0]$(原始 $x$ 的最低位)开始找,找到第一个「降序」的位置 `idx`,然后从 $[0, idx)$ 范围内找一个比 $nums[idx]$ 要大的最小数与其进行互换,也是从 $nums[0]$ 开始找,找到第一个满足比 $nums[idx]$ 大的数。\n\n当互换完成后,此时比 $x$ 要大这一目标已由第 `idx` 位所保证(后续的排序应该按照从小到大放置),同时互换结束后的 $[0, idx)$ 仍然满足「非严格升序」特性,因此我们可以对其运用「双指针」进行翻转。\n\nJava 代码:\n```Java\nclass Solution {\n    public int nextGreaterElement(int x) {\n        List<Integer> nums = new ArrayList<>();\n        while (x != 0) {\n            nums.add(x % 10);\n            x /= 10;\n        }\n        int n = nums.size(), idx = -1;\n        for (int i = 0; i < n - 1 && idx == -1; i++) {\n            if (nums.get(i + 1) < nums.get(i)) idx = i + 1;\n        }\n        if (idx == -1) return -1;\n        for (int i = 0; i < idx; i++) {\n            if (nums.get(i) > nums.get(idx)) {\n                swap(nums, i, idx);\n                break;\n            }\n        }\n        for (int l = 0, r = idx - 1; l < r; l++, r--) swap(nums, l, r);\n        long ans = 0;\n        for (int i = n - 1; i >= 0; i--) ans = ans * 10 + nums.get(i);\n        return ans > Integer.MAX_VALUE ? -1 : (int)ans;\n    }\n    void swap(List<Integer> nums, int a, int b) {\n        int c = nums.get(a);\n        nums.set(a, nums.get(b));\n        nums.set(b, c);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int nextGreaterElement(int x) {\n        vector<int> nums;\n        while (x != 0) {\n            nums.push_back(x % 10);\n            x /= 10;\n        }\n        int n = nums.size(), idx = -1;\n        for (int i = 0; i < n - 1 && idx == -1; i++) {\n            if (nums[i + 1] < nums[i]) idx = i + 1;\n        }\n        if (idx == -1) return -1;\n        for (int i = 0; i < idx; i++) {\n            if (nums[i] > nums[idx]) {\n                swap(nums[i], nums[idx]);\n                break;\n            }\n        }\n        reverse(nums.begin(), nums.begin() + idx);\n        long long ans = 0;\n        for (int i = n - 1; i >= 0; i--) ans = ans * 10 + nums[i];\n        return ans > INT_MAX ? -1 : static_cast<int>(ans);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def nextGreaterElement(self, x: int) -> int:\n        nums = []\n        while x != 0:\n            nums.append(x % 10)\n            x //= 10\n        n, idx = len(nums), -1\n        for i in range(n - 1):\n            if nums[i + 1] < nums[i]:\n                idx = i + 1\n                break\n        if idx == -1: return -1\n        for i in range(idx):\n            if nums[i] > nums[idx]:\n                nums[i], nums[idx] = nums[idx], nums[i]\n                break\n        l, r = 0, idx - 1\n        while l < r:\n            nums[l], nums[r] = nums[r], nums[l]\n            l, r = l + 1, r - 1\n        ans = 0\n        for num in nums[::-1]: ans = ans * 10 + num\n        return -1 if ans > 2**31 - 1 else ans\n```\nTypeScript 代码:\n```TypeScript\nfunction nextGreaterElement(x: number): number {\n    const nums = [];\n    while (x !== 0) {\n        nums.push(x % 10);\n        x = Math.floor(x / 10);\n    }\n    const n = nums.length;\n    let idx = -1;\n    for (let i = 0; i < n - 1 && idx == -1; i++) {\n        if (nums[i + 1] < nums[i]) idx = i + 1;\n    }\n    if (idx == -1) return -1;\n    for (let i = 0; i < idx; i++) {\n        if (nums[i] > nums[idx]) {\n            [nums[i], nums[idx]] = [nums[idx], nums[i]];\n            break;\n        }\n    }\n    for (let l = 0, r = idx - 1; l < r; l++, r--) [nums[l], nums[r]] = [nums[r], nums[l]];\n    let ans = 0;\n    for (let i = n - 1; i >= 0; i--) ans = ans * 10 + nums[i];\n    return ans > 2**31 - 1 ? -1 : ans;\n};\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.556` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/551-560/558. 四叉树交集（中等）.md", "url_title": "558. 四叉树交集", "url": "https://leetcode.cn/problems/logical-or-of-two-binary-grids-represented-as-quad-trees/solution/by-ac_oier-2ri3/", "difficulty": "中等", "tags": ["递归"], "question": "二进制矩阵中的所有元素不是 $0$ 就是 $1$ 。\n\n给你两个四叉树,`quadTree1` 和 `quadTree2`。\n\n其中 `quadTree1` 表示一个 $n \\times n$ 二进制矩阵,而 `quadTree2` 表示另一个 $n \\times n$ 二进制矩阵。\n\n请你返回一个表示 $n \\times n$ 二进制矩阵的四叉树,它是 `quadTree1` 和 `quadTree2` 所表示的两个二进制矩阵进行 按位逻辑或运算 的结果。\n\n注意,当 `isLeaf` 为 `False` 时,你可以把 `True` 或者 `False` 赋值给节点,两种值都会被判题机制 接受 。\n\n四叉树数据结构中,每个内部节点只有四个子节点。此外,每个节点都有两个属性:\n\n* `val`:储存叶子结点所代表的区域的值。$1$ 对应 `True`,$0$ 对应 `False`;\n* `isLeaf`: 当这个节点是一个叶子结点时为 `True`,如果它有 $4$ 个子节点则为 `False` 。\n\n```\nclass Node {\n    public boolean val;\n    public boolean isLeaf;\n    public Node topLeft;\n    public Node topRight;\n    public Node bottomLeft;\n    public Node bottomRight;\n}\n```\n我们可以按以下步骤为二维区域构建四叉树:\n\n1. 如果当前网格的值相同(即,全为 $0$ 或者全为 $1$),将 `isLeaf` 设为 `True` ,将 `val` 设为网格相应的值,并将四个子节点都设为 `Null` 然后停止。\n2. 如果当前网格的值不同,将 `isLeaf` 设为 `False`, 将 `val` 设为任意值,然后如下图所示,将当前网格划分为四个子网格。\n3. 使用适当的子网格递归每个子节点。\n\n四叉树格式:\n\n输出为使用层序遍历后四叉树的序列化形式,其中 null 表示路径终止符,其下面不存在节点。\n\n它与二叉树的序列化非常相似。唯一的区别是节点以列表形式表示 `[isLeaf, val]` 。\n\n如果 `isLeaf` 或者 `val` 的值为 `True` ,则表示它在列表 `[isLeaf, val]` 中的值为 $1$ ;如果 `isLeaf` 或者 `val` 的值为 `False` ,则表示值为 $0$ 。\n\n示例 1:\n\n```\n输入:quadTree1 = [[0,1],[1,1],[1,1],[1,0],[1,0]]\n, quadTree2 = [[0,1],[1,1],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]]\n\n输出:[[0,0],[1,1],[1,1],[1,1],[1,0]]\n\n解释:quadTree1 和 quadTree2 如上所示。由四叉树所表示的二进制矩阵也已经给出。\n如果我们对这两个矩阵进行按位逻辑或运算,则可以得到下面的二进制矩阵,由一个作为结果的四叉树表示。\n注意,我们展示的二进制矩阵仅仅是为了更好地说明题意,你无需构造二进制矩阵来获得结果四叉树。\n```\n示例 2:\n```\n输入:quadTree1 = [[1,0]]\n, quadTree2 = [[1,0]]\n\n输出:[[1,0]]\n\n解释:两个数所表示的矩阵大小都为 1*1,值全为 0 \n结果矩阵大小为 1*1,值全为 0 。\n```\n示例 3:\n```\n输入:quadTree1 = [[0,0],[1,0],[1,0],[1,1],[1,1]]\n, quadTree2 = [[0,0],[1,1],[1,1],[1,0],[1,1]]\n\n输出:[[1,1]]\n```\n示例 4:\n```\n输入:quadTree1 = [[0,0],[1,1],[1,0],[1,1],[1,1]]\n, quadTree2 = [[0,0],[1,1],[0,1],[1,1],[1,1],null,null,null,null,[1,1],[1,0],[1,0],[1,1]]\n\n输出:[[0,0],[1,1],[0,1],[1,1],[1,1],null,null,null,null,[1,1],[1,0],[1,0],[1,1]]\n```\n示例 5:\n```\n输入:quadTree1 = [[0,1],[1,0],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]]\n, quadTree2 = [[0,1],[0,1],[1,0],[1,1],[1,0],[1,0],[1,0],[1,1],[1,1]]\n\n输出:[[0,0],[0,1],[0,1],[1,1],[1,0],[1,0],[1,0],[1,1],[1,1],[1,0],[1,0],[1,1],[1,1]]\n```\n\n提示:\n* `quadTree1` 和 `quadTree2` 都是符合题目要求的四叉树,每个都代表一个 $n \\times n$ 的矩阵。\n* $n == 2^x$ ,其中 $0 <= x <= 9$", "solution": "### 递归\n\n为了方便,我们令 `quadTree1` 为 `t1`,令 `quadTree2` 为 `t2`。\n\n根据题意,并利用给定函数作为递归函数,当 `t1` 和 `t2` 均为叶子节点数时,执行「与逻辑」,即若 `t1` 和 `t2` 任一值为 $1$ 时,返回该节点,否则(两者均为 $0$),返回任一节点。\n\n然后考虑其他情况下,如何使用 `t1` 和 `t2` 构造新节点 `ans`,分别使用对应位置的进行「递归」构造即可(即使用 `t1.topLeft` 和 `t2.topLeft` 来赋值给 `ans.topLeft`,其余位置同理),要注意可能存在 `t1` 或 `t2` 其中一节点为叶子节点的情况,此时应当使用当前叶子节点和另一节点的子节点进行构造。\n\n最后考虑什么情况下,会产生新的叶子节点:若当前节点 `ans` 的四个子节点均为叶子节点,并且值相同时,`ans` 会成为叶子节点,`ans` 值为叶子节点的值,此时需要执行的操作为将 `isLeaf` 设定为 `True`,修改 `val` 为原子节点的值,将四个原子节点置空。\n\nJava 代码:\n```Java\nclass Solution {\n    public Node intersect(Node t1, Node t2) {\n        if (t1.isLeaf && t2.isLeaf) {\n            if (t1.val) return t1;\n            else if (t2.val) return t2;\n            else return t1;\n        }\n        Node ans = new Node();\n        ans.topLeft = intersect(t1.isLeaf ? t1 : t1.topLeft, t2.isLeaf ? t2 : t2.topLeft);\n        ans.topRight = intersect(t1.isLeaf ? t1 : t1.topRight, t2.isLeaf ? t2 : t2.topRight);\n        ans.bottomLeft = intersect(t1.isLeaf ? t1 : t1.bottomLeft, t2.isLeaf ? t2 : t2.bottomLeft);\n        ans.bottomRight = intersect(t1.isLeaf ? t1 : t1.bottomRight, t2.isLeaf ? t2 : t2.bottomRight);\n        boolean a = ans.topLeft.isLeaf && ans.topRight.isLeaf && ans.bottomLeft.isLeaf && ans.bottomRight.isLeaf;\n        boolean b = ans.topLeft.val && ans.topRight.val && ans.bottomLeft.val && ans.bottomRight.val;\n        boolean c = ans.topLeft.val || ans.topRight.val || ans.bottomLeft.val || ans.bottomRight.val;\n        ans.isLeaf = a && (b || !c);\n        ans.val = ans.topLeft.val;\n        if (ans.isLeaf) ans.topLeft = ans.topRight = ans.bottomLeft = ans.bottomRight = null;\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction intersect(t1: Node | null, t2: Node | null): Node | null {\n    if (t1.isLeaf && t2.isLeaf) {\n        if (t1.val) return t1\n        else if (t2.val) return t2\n        else return t1\n    }\n    const ans: Node = new Node()\n    ans.topLeft = intersect(t1.isLeaf ? t1 : t1.topLeft, t2.isLeaf ? t2 : t2.topLeft)\n    ans.topRight = intersect(t1.isLeaf ? t1 : t1.topRight, t2.isLeaf ? t2 : t2.topRight)\n    ans.bottomLeft = intersect(t1.isLeaf ? t1 : t1.bottomLeft, t2.isLeaf ? t2 : t2.bottomLeft)\n    ans.bottomRight = intersect(t1.isLeaf ? t1 : t1.bottomRight, t2.isLeaf ? t2 : t2.bottomRight)\n    const a: boolean = ans.topLeft.isLeaf && ans.topRight.isLeaf && ans.bottomLeft.isLeaf && ans.bottomRight.isLeaf\n    const b: boolean = ans.topLeft.val && ans.topRight.val && ans.bottomLeft.val && ans.bottomRight.val\n    const c: boolean = ans.topLeft.val || ans.topRight.val || ans.bottomLeft.val || ans.bottomRight.val\n    ans.isLeaf = a && (b || !c)\n    ans.val = ans.topLeft.val\n    if (ans.isLeaf) ans.topLeft = ans.topRight = ans.bottomLeft = ans.bottomRight = null\n    return ans\n};\n```\n* 时间复杂度:复杂度与最终矩阵大小相关,而最终矩阵大小不会超过原矩阵大小,复杂度为 $O(n^2)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$\n\n---\n\n### 加餐\n\n**另外一道也是「四叉树」相关的递归运用题 : [【综合笔试题】难度 2/5,递归运用及前缀和优化](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492391&idx=1&sn=bf2b27842d461bba6766b1ca2b426eff) 🎉🎉**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.558` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/551-560/559. N 叉树的最大深度（简单）.md", "url_title": "559. N 叉树的最大深度", "url": "https://leetcode-cn.com/problems/brick-wall/solution/gong-shui-san-xie-zheng-nan-ze-fan-shi-y-gsri/", "difficulty": "简单", "tags": ["DFS", "BFS"], "question": "给定一个 `N` 叉树,找到其最大深度。\n\n最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。\n\n`N` 叉树输入按层序遍历序列化表示,每组子节点由空值分隔(请参见示例)。\n\n示例 1:\n\n```\n输入:root = [1,null,3,2,4,null,5,6]\n\n输出:3\n```\n示例 2:\n\n```\n输入:root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]\n\n输出:5\n```\n\n提示:\n* 树的深度不会超过 1000 。\n* 树的节点数目位于 $[0, 10^4]$ 之间。", "solution": "### DFS\n\n根据题意,可以写出如下的 `DFS` 实现:从 $root$ 的所有子节点中的取最大深度,并在此基础上加一(统计 $root$ 节点)即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int maxDepth(Node root) {\n        if (root == null) return 0;\n        int ans = 0;\n        for (Node node : root.children) {\n            ans = Math.max(ans, maxDepth(node));\n        }\n        return ans + 1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$\n\n---\n\n### BFS\n\n同理,可以使用 `BFS`  进行求解:其本质是对多叉树进行层序处理,当 `BFS`  过程结束,意味着达到最大层数(深度),所记录的最大层数(深度)即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int maxDepth(Node root) {\n        if (root == null) return 0;\n        int ans = 0;\n        Deque<Node> d = new ArrayDeque<>();\n        d.addLast(root);\n        while (!d.isEmpty()) {\n            int size = d.size();\n            while (size-- > 0) {\n                Node t = d.pollFirst();\n                for (Node node : t.children) {\n                    d.addLast(node);\n                }\n            }\n            ans++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.559` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/551-560/560. 和为 K 的子数组（中等）.md", "url_title": "560. 和为 K 的子数组", "url": "https://leetcode.cn/problems/subarray-sum-equals-k/solution/by-ac_oier-pttu/", "difficulty": "中等", "tags": ["前缀和", "哈希表"], "question": "给你一个整数数组 `nums` 和一个整数 `k` ,请你统计并返回该数组中和为 `k` 的子数组的个数 。\n\n示例 1:\n```\n输入:nums = [1,1,1], k = 2\n\n输出:2\n```\n示例 2:\n```\n输入:nums = [1,2,3], k = 3\n\n输出:2\n```\n\n提示:\n* $1 <= nums.length <= 2 \\times 10^4$\n* $-1000 <= nums[i] <= 1000$\n* $-10^7 <= k <= 10^7$", "solution": "### 前缀和 + 哈希表\n\n这是一道经典的前缀和运用题。\n\n统计以每一个 $nums[i]$ 为结尾,和为 $k$ 的子数组数量即是答案。\n\n我们可以预处理前缀和数组 `sum`(前缀和数组下标默认从 $1$ 开始),对于求解以某一个 $nums[i]$ 为结尾的,和为 $k$ 的子数组数量,本质上是求解在 $[0, i]$ 中,`sum` 数组中有多少个值为 $sum[i + 1] - k$ 的数,这可以在遍历过程中使用「哈希表」进行同步记录。\n\nJava 代码:\n```Java\nclass Solution {\n    public int subarraySum(int[] nums, int k) {\n        int n = nums.length, ans = 0;\n        int[] sum = new int[n + 10];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n        Map<Integer, Integer> map = new HashMap<>();\n        map.put(0, 1);\n        for (int i = 1; i <= n; i++) {\n            int t = sum[i], d = t - k;\n            ans += map.getOrDefault(d, 0);\n            map.put(t, map.getOrDefault(t, 0) + 1);\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction subarraySum(nums: number[], k: number): number {\n    let n = nums.length, ans = 0\n    const sum = new Array<number>(n + 10).fill(0)\n    for (let i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1]\n    const map = new Map<number, number>()\n    map.set(0, 1)\n    for (let i = 1; i <= n; i++) {\n        const t = sum[i], d = t - k\n        if (map.has(d)) ans += map.get(d)\n        map.set(t, map.has(t) ? map.get(t) + 1 : 1)\n    }\n    return ans\n};\n```\n* 时间复杂度:预处理前缀和的复杂度为 $O(n)$,统计答案的复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.560` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/561-570/561. 数组拆分 I（简单）.md", "url_title": "561. 数组拆分 I", "url": "https://leetcode-cn.com/problems/array-partition-i/solution/jue-dui-neng-kan-dong-de-zheng-ming-fan-f7trz/", "difficulty": "简单", "tags": ["贪心"], "question": "给定长度为 $2 \\times n$ 的整数数组 `nums `,你的任务是将这些数分成 `n` 对, 例如 $(a_1, b_1), (a_2, b_2), ..., (a_n, b_n)$ ,使得从 `1` 到 `n` 的 $min(a_i, b_i)$ 总和最大。\n\n返回该 最大总和 。\n\n示例 1:\n```\n输入:nums = [1,4,3,2]\n输出:4\n解释:所有可能的分法(忽略元素顺序)为:\n1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3\n2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3\n3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4\n所以最大总和为 4\n```\n示例 2:\n```\n输入:nums = [6,2,6,5,1,2]\n输出:9\n解释:最优的分法为 (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9\n```\n\n提示:\n* $1 <= n <= 10^4$\n* $nums.length = 2 \\times n$\n* $-10^4 <= nums[i] <= 10^4$", "solution": "### 贪心解法\n\n我们先对数组进行排序。\n\n由于每两个数,我们只能选择当前小的一个进行累加。\n\n因此我们猜想应该从第一个位置进行选择,然后隔一步选择下一个数。这样形成的序列的求和值最大。\n\n```java\nclass Solution {\n    public int arrayPairSum(int[] nums) {\n        int n = nums.length;\n        Arrays.sort(nums);\n        int ans = 0;\n        for (int i = 0; i < n; i += 2) ans += nums[i];\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$\n\n***\n\n### 证明\n\n我们用反证法来证明下,为什么这样选择的序列的求和值一定是最大的:\n\n猜想:对数组进行排序,从第一个位置进行选择,然后隔一步选择下一个数。这样形成的序列的求和值最大(下图黑标,代表当前被选择的数字)。\n\n之所以我们能这么选择,是因为每一个被选择的数的「下一位位置」都对应着一个「大于等于」当前数的值(假设位置为 `k` ),使得当前数在 `min(a,b)` 关系中能被选择(下图红标,代表保证前面一个黑标能够被选择的辅助数)。\n\n假如我们这样选择的序列求和不是最大值,那么说明至少我们有一个值选错了,应该选择更大的数才对。\n\n那么意味着我们「某一位置」的黑标应该从当前位置指向更后的位置。\n\n**PS. 因为要满足 min(a, b) 的数才会被累加,因此每一个红标右移(变大)必然导致原本所对应的黑标发生「同样程度 或 不同程度」的右移(变大)**\n\n这会导致我们所有的红标黑标同时往后平移。\n\n最终会导致我们最后一个黑标出现在最后一位,这时候最后一位黑标不得不与我们第 `k` 个位置的数形成一对。\n\n我们看看这是求和序列的变化( `k` 位置前的求和项没有发生变化,我们从 `k` 位置开始分析):\n\n1. 原答案 = `nums[k] + nums[k + 2] + ... + nums[n - 1]`\n2. 调整后答案 = `nums[k + 1] + nums[k + 3] + ... + nums[n - 2] + min(nums[n], nums[k])`\n由于 `min(nums[n], nums[k])` 中必然是 `nums[k]` 被选择。因此:\n调整后答案 = `nums[k] + nums[k + 1] + nums[k + 3] + ... + nums[n - 2]`\n\n显然从原答案的每一项都「大于等于」调整后答案的每一项,因此**不可能在「假想序列」中通过选择别的更大的数得到更优解,假想得证。**\n\n***\n\n### 为什么要「证明」或「理解证明」?\n\n证明的意义在于,**你知道为什么这样做是对的**。\n\n带来的好处是:\n\n1. 一道「贪心」题目能搞清楚证明,那么同类的「贪心」题目你就都会做了。**否则就会停留在“我知道这道题可以这样贪心,别的题我不确定是否也能这样做”**。\n2. 在「面试」阶段,**你可以很清晰讲解你的思路**。让面试官从你的「思维方式」上喜欢上你( emmm 当然从颜值上也可以 :)\n...\n\n***\n\n### 更多与证明/分析相关的题解:\n\n[765. 情侣牵手](https://leetcode-cn.com/problems/couples-holding-hands/) : [为什么交换任意一个都是对的?:两种 100% 的解法:并查集 & 贪心](https://leetcode-cn.com/problems/couples-holding-hands/solution/liang-chong-100-de-jie-fa-bing-cha-ji-ta-26a6/)\n[1579. 保证图可完全遍历](https://leetcode-cn.com/problems/remove-max-number-of-edges-to-keep-graph-fully-traversable/) : [为什么先处理公共边是对的?含贪心证明 + 数组模板 ~](https://leetcode-cn.com/problems/remove-max-number-of-edges-to-keep-graph-fully-traversable/solution/tan-xin-bing-cha-ji-shu-zu-shi-xian-jian-w7ko/)\n\n[1631. 最小体力消耗路径](https://leetcode-cn.com/problems/path-with-minimum-effort/) : [反证法证明思路的合法性](https://leetcode-cn.com/problems/path-with-minimum-effort/solution/fan-zheng-fa-zheng-ming-si-lu-de-he-fa-x-ohby/)\n\n[11. 盛最多水的容器](https://leetcode-cn.com/problems/container-with-most-water/) : [双指针+贪心解法【含证明】](https://leetcode-cn.com/problems/container-with-most-water/solution/shua-chuan-lc-shuang-zhi-zhen-tan-xin-ji-52gf/)", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.561` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/561-570/563. 二叉树的坡度（简单）.md", "url_title": "563. 二叉树的坡度", "url": "https://leetcode-cn.com/problems/binary-tree-tilt/solution/gong-shui-san-xie-jian-dan-er-cha-shu-di-ekz4/", "difficulty": "简单", "tags": ["二叉树", "DFS"], "question": "给定一个二叉树,计算**整个树**的坡度 。\n\n一个树的 节点的坡度 定义即为,该节点左子树的节点之和和右子树节点之和的 差的绝对值 。\n\n如果没有左子树的话,左子树的节点之和为 $0$ ;没有右子树的话也是一样。空结点的坡度是 $0$ 。\n\n整个树 的坡度就是其所有节点的坡度之和。\n\n示例 1:\n\n```\n输入:root = [1,2,3]\n\n输出:1\n\n解释:\n节点 2 的坡度:|0-0| = 0(没有子节点)\n节点 3 的坡度:|0-0| = 0(没有子节点)\n节点 1 的坡度:|2-3| = 1(左子树就是左子节点,所以和是 2 ;右子树就是右子节点,所以和是 3 )\n坡度总和:0 + 0 + 1 = 1\n```\n示例 2:\n\n```\n输入:root = [4,2,9,3,5,null,7]\n\n输出:15\n\n解释:\n节点 3 的坡度:|0-0| = 0(没有子节点)\n节点 5 的坡度:|0-0| = 0(没有子节点)\n节点 7 的坡度:|0-0| = 0(没有子节点)\n节点 2 的坡度:|3-5| = 2(左子树就是左子节点,所以和是 3 ;右子树就是右子节点,所以和是 5 )\n节点 9 的坡度:|0-7| = 7(没有左子树,所以和是 0 ;右子树正好是右子节点,所以和是 7 )\n节点 4 的坡度:|(3+5+2)-(9+7)| = |10-16| = 6(左子树值为 3、5 和 2 ,和是 10 ;右子树值为 9 和 7 ,和是 16 )\n坡度总和:0 + 0 + 0 + 2 + 7 + 6 = 15\n```\n示例 3:\n\n```\n输入:root = [21,7,14,1,1,2,2,3,3]\n\n输出:9\n```\n\n提示:\n* 树中节点数目的范围在 $[0, 10^4]$ 内\n* $-1000 <= Node.val <= 1000$", "solution": "### 递归\n\n根据题目对「坡度」的定义,我们可以直接写出对应的递归实现。\n\n代码:\n```Java\nclass Solution {\n    public int findTilt(TreeNode root) {\n        if (root == null) return 0;\n        return findTilt(root.left) + findTilt(root.right) + Math.abs(getSum(root.left) - getSum(root.right));\n    }\n    int getSum(TreeNode root) {\n        if (root == null) return 0;\n        return getSum(root.left) + getSum(root.right) + root.val;\n    }\n}\n```\n* 时间复杂度:每个节点被访问的次数与其所在深度有关。复杂度为 $O(n^2)$\n* 空间复杂度:忽略递归来带的额外空间消耗。复杂度为 $O(1)$\n\n---\n\n### 递归\n\n上述解法之所以为 $O(n^2)$ 的时间复杂度,是因为我们将「计算子树坡度」和「计算子树权值和」两个操作分开进行。\n\n事实上,我们可以在计算子树权值和的时候将坡度进行累加,从而将复杂度降为 $O(n)$。\n\n代码:\n```Java\nclass Solution {\n    int ans;\n    public int findTilt(TreeNode root) {\n        dfs(root);\n        return ans;\n    }\n    int dfs(TreeNode root) {\n        if (root == null) return 0;\n        int l = dfs(root.left), r = dfs(root.right);\n        ans += Math.abs(l - r);\n        return l + r + root.val;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.563` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/561-570/564. 寻找最近的回文数（困难）.md", "url_title": "564. 寻找最近的回文数", "url": "https://leetcode-cn.com/problems/find-the-closest-palindrome/solution/gong-shui-san-xie-tan-xin-fen-xi-shang-x-vtr6/", "difficulty": "困难", "tags": ["贪心", "脑筋急转弯"], "question": "给定一个表示整数的字符串 $n$ ,返回与它最近的回文整数(不包括自身)。如果不止一个,返回较小的那个。\n\n“最近的”定义为两个整数差的绝对值最小。\n\n示例 1:\n```\n输入: n = \"123\"\n\n输出: \"121\"\n```\n示例 2:\n```\n输入: n = \"1\"\n\n输出: \"0\"\n\n解释: 0 和 2是最近的回文,但我们返回最小的,也就是 0。\n```\n\n提示:\n* $1 <= n.length <= 18$\n* $n$ 只由数字组成\n* $n$ 不含前导 $0$\n* $n$ 代表在 $[1, 10^{18} - 1]$ 范围内的整数", "solution": "### 上下界分析 + 边界处理\n\n对于任意字符串数值 $s$ 而言(令其长度为 $n$),先考虑如何找到「第一个比其大」和「第一个比其小」的回文串数值(上下界)。\n\n由于是找「最近」的数值,因此一个自然的想法是优先修改低位数字,但由于回文串本身的对称性质,每个「低位」的修改带来的副作用是需要同时修改对应的「高位」,因此一个真正可以修改的位置是(相对)中间的位置。\n\n举个 🌰,对于长度为奇数回文串数值 $abcde$,其中 $de$ 的修改会导致 $ab$ 同步修改,因此最近一个可以修改的低位是 $c$;对于长度为偶数的回文串数值 $abcd$ 而言,其中 $d$ 的修改会导致 $a$ 同步修改,因此最近一个可以修改的位置是 $bc$。\n\n**当对目标位置进行修改后,其余位置的数值可由回文串性质唯一确定,因此只需要找到可修改位置相邻数值即可。**\n\n例如对于 $abcde$ 来说,最近的回文数值的前三位可能是 $abc$、$abc+1$ 和 $abc-1$ 三者之一,其他位置的数值随着前三位的确定而唯一确定。\n\n上述分析对于一般情况成立,而边界情况是指 $abc + 1$ 和 $abc - 1$ 导致整体长度发生变化,即 $abc=999$ 和 $abc=100$ 的情况,此时直接套用上述方法得到的值分别为 $1000001$ 和 $999$,但真实最近的值为 $100001$ 和 $9999$。\n\n> 展开来说就是:对于 $abc = 999$(对应原串为 $999xx$ 的情况)而言,按照上述逻辑得到的是 $1000$,进行回文补充后得到 $1000001$(事实上应该是 $100001$ 更优);对于 $abc = 100$(对应原串为 $100xx$ 的情况)而言,按照上述逻辑得到是 $99$,进行回文补充后得到 $999$(事实上应该是 $9999$ 更优)。\n\n因此对于长度为 $n$ 的数值,值考虑枚举前一半数的三种情况(前一半数不变,前一半数加一或减一)可能会错过最优解,我们需要将与长度相关的边界值也纳入考虑,即将「长度为 $n - 1$ 的回文串最大值($99...99$)」和「长度为 $n + 1$ 的回文串最小值($10...01$)」也纳入考虑,也就是对应的 $10^{n - 1} - 1$ 和 $10^n + 1$ 也纳入考虑,最后从上述 $5$ 个值中选绝对差值最小的作为答案。\n\n> 一些细节:在枚举完前一半数后,我们需要根据原串长度的奇偶性来决定,如何生成后一半数,从而确保构建的回文串长度仍和原串长度相等。\n> 即对于原串长度 $n$ 为奇数的 $abcde$ 而言,在处理完 $abc$ 之后,生成后一半数时,只需要根据前两位 $ab$ 生成对应的 $ba$,而无须处理中间字符 $c$;而对于原串长度 $n$ 为偶数的 $abcd$ 而言,在处理完 $ab$ 之后,生成另外一般数值需要根据整一个 $ab$ 来生成 $ba$,没有中间字符需要被跳过。\n>\n> 另外由于数据范围为 $[1, 10^{18} - 1]$,而 $999999999999999999$ 也属于合法输入($2022/03/03$ 目前样例里还没有这个数据),因此我们需要考虑 `getNum` 爆 `long` 的问题,一个比直接特判更好做法是:利用答案长度必然不会超过 $19$ 来做处理,对于长度超过 $19$ 的直接当成 $-1$ 来处理,由于个位数均为回文,$-1$ 注定不会成为答案。\n\n代码:\n```Java\nclass Solution {\n    public String nearestPalindromic(String s) {\n        int n = s.length();\n        long cur = Long.parseLong(s);\n        Set<Long> set = new HashSet<>();\n        set.add((long) Math.pow(10, (n - 1)) - 1);\n        set.add((long) Math.pow(10, n) + 1);\n        long t = Long.parseLong(s.substring(0, (n + 1) / 2));\n        for (long i = t - 1; i <= t + 1; i++) {\n            long temp = getNum(i, n % 2 == 0);\n            if (temp != cur) set.add(temp);\n        }\n        long ans = -1;\n        for (long i : set) {\n            if (ans == -1) ans = i;\n            else if (Math.abs(i - cur) < Math.abs(ans - cur)) ans = i;\n            else if (Math.abs(i - cur) == Math.abs(ans - cur) && i < ans) ans = i;\n        }\n        return String.valueOf(ans);\n    }\n    long getNum(long k, boolean isEven) {\n        StringBuilder sb = new StringBuilder();\n        sb.append(k);\n        int n = sb.length(), idx = isEven ? n - 1 : n - 2;\n        while (idx >= 0) sb.append(sb.charAt(idx--));\n        String str = sb.toString();\n        return str.length() > 19 ? -1 : Long.parseLong(str);\n    }\n}\n```\n* 时间复杂度:令 $N$ 为字符串 `s` 所代指的数值,$n$ 为字符串 `s` 的长度,复杂度为 $O(\\log{N})$ 或者说是 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.564` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/561-570/565. 数组嵌套（中等）.md", "url_title": "565. 数组嵌套", "url": "https://leetcode-cn.com/problems/find-the-closest-palindrome/solution/gong-shui-san-xie-tan-xin-fen-xi-shang-x-vtr6/", "difficulty": "中等", "tags": ["模拟"], "question": "索引从 $0$ 开始长度为 `N` 的数组 `A`,包含 $0$ 到 $N - 1$ 的所有整数。找到最大的集合 `S` 并返回其大小,其中 $S[i] = {A[i], A[A[i]], A[A[A[i]]], ... }$ 且遵守以下的规则。\n\n假设选择索引为 `i` 的元素 $A[i]$ 为 `S` 的第一个元素,`S` 的下一个元素应该是 $A[A[i]]$,之后是 $A[A[A[i]]]$ ... 以此类推,不断添加直到 `S` 出现重复的元素。\n\n示例 1:\n```\n输入: A = [5,4,0,3,1,6,2]\n\n输出: 4\n\n解释: \nA[0] = 5, A[1] = 4, A[2] = 0, A[3] = 3, A[4] = 1, A[5] = 6, A[6] = 2.\n\n其中一种最长的 S[K]:\nS[0] = {A[0], A[5], A[6], A[2]} = {5, 6, 2, 0}\n```\n\n提示:\n* `N` 是 $[1, 20,000]$ 之间的整数。\n* `A` 中不含有重复的元素。\n* `A` 中的元素大小在 $[0, N-1]$ 之间。", "solution": "### 模拟\n\n将 $A[i]$ 与 $A[A[i]]$ 之间看作存在一条有向边,由于所有数范围都在 $[0, N - 1]$,且不重复,因此至少存在一个环,而问题本质是求所有环的最大长度。\n\n直接根据题意记进行模拟即可,从前往后处理每个 $nums[i]$,并尝试从 $nums[i]$ 出发遍历其所在的环,为了防止某些环被重复处理,对于当前经过的 $nums[i]$ 标记为 $-1$,这样每个数被访问的次数最多不超过 $3$ 次,整体复杂度为 $O(n)$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int arrayNesting(int[] nums) {\n        int n = nums.length, ans = 0;\n        for (int i = 0; i < n; i++) {\n            int cur = i, cnt = 0;\n            while (nums[cur] != -1) {\n                cnt++;\n                int c = cur;\n                cur = nums[cur];\n                nums[c] = -1;\n            }\n            ans = Math.max(ans, cnt);\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction arrayNesting(nums: number[]): number {\n    let n = nums.length, ans = 0\n    for (let i = 0; i < n; i++) {\n        let cur = i, cnt = 0\n        while (nums[cur] != -1) {\n            cnt++\n            const c = cur\n            cur = nums[cur]\n            nums[c] = -1\n        }\n        ans = Math.max(ans, cnt)\n    }\n    return ans\n};\n```\n* 时间复杂度:每个数字被访问的次数为常数次,复杂度为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.565` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/561-570/566. 重塑矩阵（简单）.md", "url_title": "566. 重塑矩阵", "url": "https://leetcode-cn.com/problems/reshape-the-matrix/solution/jian-dan-ti-zhong-quan-chu-ji-ke-yi-kan-79gv5/", "difficulty": "简单", "tags": ["模拟"], "question": "在 MATLAB 中,有一个非常有用的函数 `reshape`,它可以将一个矩阵重塑为另一个大小不同的新矩阵,但保留其原始数据。\n\n给出一个由二维数组表示的矩阵,以及两个正整数 `r` 和 `c`,分别表示想要的重构的矩阵的行数和列数。\n\n重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。\n\n如果具有给定参数的 `reshape` 操作是可行且合理的,则输出新的重塑矩阵;否则,输出原始矩阵。\n\n示例 1:\n```\n输入: \nnums = \n[[1,2],\n [3,4]]\nr = 1, c = 4\n\n输出: \n[[1,2,3,4]]\n\n解释:\n行遍历nums的结果是 [1,2,3,4]。新的矩阵是 1 * 4 矩阵, 用之前的元素值一行一行填充新矩阵。\n```\n示例 2:\n```\n输入: \nnums = \n[[1,2],\n [3,4]]\nr = 2, c = 4\n\n输出: \n[[1,2],\n [3,4]]\n\n解释:\n没有办法将 2 * 2 矩阵转化为 2 * 4 矩阵。 所以输出原矩阵。\n```\n注意:\n* 给定矩阵的宽和高范围在 $[1, 100]$。\n* 给定的 $r$ 和 $c$ 都是正数。", "solution": "### 模拟\n\n按照题意,从头模拟一遍即可。\n\n使用 $idx$ 记录新矩阵当前分配到的位置(一维),利用通用的一维转二维方式对应回行列坐标即可。\n\n代码:\n```Java\nclass Solution {\n    public int[][] matrixReshape(int[][] nums, int r, int c) {\n        int or = nums.length, oc = nums[0].length;\n        if (or * oc != r * c) return nums;\n        int[][] ans = new int[r][c];\n        for (int i = 0, idx = 0; i < or; i++) {\n            for (int j = 0; j < oc; j++, idx++) {\n                ans[idx / c][idx % c] = nums[i][j];\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(r * c)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.566` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/561-570/567. 字符串的排列（中等）.md", "url_title": "567. 字符串的排列", "url": "https://leetcode-cn.com/problems/permutation-in-string/solution/an-zi-fu-hua-dong-ruo-bao-liao-lai-shi-s-h2xq/", "difficulty": "中等", "tags": ["滑动窗口"], "question": "给定两个字符串 s1 和 s2,写一个函数来判断 s2 是否包含 s1 的排列。\n\n换句话说,第一个字符串的排列之一是第二个字符串的 子串 。\n\n示例 1:\n```\n输入: s1 = \"ab\" s2 = \"eidbaooo\"\n输出: True\n解释: s2 包含 s1 的排列之一 (\"ba\").\n```\n示例 2:\n```\n输入: s1= \"ab\" s2 = \"eidboaoo\"\n输出: False\n```\n\n提示:\n* 输入的字符串只包含小写字母\n* 两个字符串的长度都在 [1, 10,000] 之间", "solution": "### 滑动窗口\n\n由于是 `s2` 中判断是否包含 `s1` 的排列,而且 `s1` 和 `s2` 均为小数。\n\n可以使用数组先对 `s1` 进行统计,之后使用滑动窗口进行扫描,每滑动一次检查窗口内的字符频率和 `s1` 是否相等 ~ \n\n以下代码,可以作为滑动窗口模板使用:\n\n**PS. 你会发现以下代码和 [643. 子数组最大平均数 I](https://leetcode-cn.com/problems/maximum-average-subarray-i/) 和 [1423. 可获得的最大点数](https://leetcode-cn.com/problems/maximum-points-you-can-obtain-from-cards/) 代码很相似,因为是一套模板。**\n\n1. 初始化将滑动窗口压满,取得第一个滑动窗口的目标值\n\n2. 继续滑动窗口,每往前滑动一次,需要删除一个和添加一个元素\n\n代码:\n```java\nclass Solution {\n    public boolean checkInclusion(String s1, String s2) {\n        int m = s1.length(), n = s2.length();\n        if (m > n) return false;\n        int[] cnt = new int[26];\n        for (char c : s1.toCharArray()) cnt[c - 'a']++;\n        int[] cur = new int[26];\n        for (int i = 0; i < m; i++) cur[s2.charAt(i) - 'a']++;\n        if (check(cnt, cur)) return true;\n        for (int i = m; i < n; i++) {\n            cur[s2.charAt(i) - 'a']++;\n            cur[s2.charAt(i - m) - 'a']--;\n            if (check(cnt, cur)) return true;\n        }\n        return false;\n    }\n    boolean check(int[] cnt1, int[] cnt2) {\n        for (int i = 0; i < 26; i++) {\n            if (cnt1[i] != cnt2[i]) return false;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n经过了前面几天的「滑动窗口」,相信你做这题已经很有感觉了。\n\n但其实这是某道困难题的简化版,本题根据「字符」滑动,而 [30. 串联所有单词的子串](https://leetcode-cn.com/problems/substring-with-concatenation-of-all-words/) 则是根据「单词」来。但基本思路都是一样的,强烈建议你来试试 ~ \n\n***\n\n### 相关链接\n\n[30. 串联所有单词的子串:【刷穿LC】朴素哈希表解法 + 滑动窗口解法](https://leetcode-cn.com/problems/substring-with-concatenation-of-all-words/solution/shua-chuan-lc-po-su-ha-xi-biao-jie-fa-hu-ml3x/)\n\n[643. 子数组最大平均数 I:滑动窗口裸题 (含模板)~](https://leetcode-cn.com/problems/maximum-average-subarray-i/solution/hua-dong-chuang-kou-luo-ti-han-mo-ban-by-buo3/)\n\n[1423. 可获得的最大点数:详解滑动窗口基本思路(含模板)~](https://leetcode-cn.com/problems/maximum-points-you-can-obtain-from-cards/solution/jian-dan-de-hua-dong-chuang-kou-he-kuai-1go5h/)\n\n***", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.567` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/571-580/575. 分糖果（简单）.md", "url_title": "575. 分糖果", "url": "https://leetcode-cn.com/problems/distribute-candies/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-pjjxo/", "difficulty": "简单", "tags": ["贪心"], "question": "给定一个偶数长度的数组,其中不同的数字代表着不同种类的糖果,每一个数字代表一个糖果。你需要把这些糖果平均分给一个弟弟和一个妹妹。\n\n返回妹妹可以获得的最大糖果的种类数。\n\n示例 1:\n```\n输入: candies = [1,1,2,2,3,3]\n\n输出: 3\n\n解析: 一共有三种种类的糖果,每一种都有两个。\n     最优分配方案:妹妹获得[1,2,3],弟弟也获得[1,2,3]。这样使妹妹获得糖果的种类数最多。\n```\n\n示例 2 :\n```\n输入: candies = [1,1,2,3]\n\n输出: 2\n\n解析: 妹妹获得糖果[2,3],弟弟获得糖果[1,1],妹妹有两种不同的糖果,弟弟只有一种。这样使得妹妹可以获得的糖果种类数最多。\n```\n\n注意:\n* 数组的长度为[2, 10,000],并且确定为偶数。\n* 数组中数字的大小在范围[-100,000, 100,000]内。", "solution": "### 贪心\n\n由于题目规定糖果数量 $n$ 为偶数,因此一定能将糖果平均分配成两份,每份数量固定为 $\\frac{n}{2}$。\n\n假设糖果种类数量为 $m$,那么单份中可使得糖果种类数量最大为 $\\min(m, \\frac{n}{2})$。\n\n可以使用「分情况讨论」进行证明:\n\n1. $m > \\frac{n}{2}$:糖果种类大于单份的糖果数量。此时可以从 $m$ 类糖果中找出 $\\frac{n}{2}$ 类不同的糖果组成单份,此时可取得的最大种类数量为 $\\frac{n}{2}$;\n\n2. $m = \\frac{n}{2}$:糖果种类等于单份的糖果数量。同理,此时可以从 $m$ 类糖果中找出 $\\frac{n}{2}$ 类不同的糖果组成单份,此时可取得的最大种类数量为 $m = \\frac{n}{2}$;\n\n3. $m < \\frac{n}{2}$:糖果种类小于单份的糖果数量。此时先从 $m$ 类糖果中找出 $m$ 类不同糖果组成单份,再使用相同种类的糖果凑齐 $\\frac{n}{2}$,此时可取得的最大种类数量为 $m$。\n\n综上,无论糖果种类数与单份糖果数呈何种关系,我们可取得的最大糖果种类数量均为 $\\min(m, \\frac{n}{2})$。\n\n代码:\n```Java\nclass Solution {\n    public int distributeCandies(int[] candyType) {\n        Set<Integer> set = new HashSet<>();\n        for (int i : candyType) set.add(i);\n        return Math.min(candyType.length / 2, set.size());\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.575` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/571-580/576. 出界的路径数（中等）.md", "url_title": "576. 出界的路径数", "url": "https://leetcode-cn.com/problems/out-of-boundary-paths/solution/gong-shui-san-xie-yi-ti-shuang-jie-ji-yi-asrz/", "difficulty": "中等", "tags": ["路径 DP", "动态规划", "记忆化搜索"], "question": "给你一个大小为 m x n 的网格和一个球。球的起始坐标为 [startRow, startColumn] 。\n\n你可以将球移到在四个方向上相邻的单元格内(可以穿过网格边界到达网格之外)。\n\n你**最多**可以移动 maxMove 次球。\n\n给你五个整数 m、n、maxMove、startRow 以及 startColumn ,找出并返回可以将球移出边界的路径数量。\n\n因为答案可能非常大,返回对 $10^9 + 7$​ 取余 后的结果。\n\n示例 1:\n\n```\n输入:m = 2, n = 2, maxMove = 2, startRow = 0, startColumn = 0\n\n输出:6\n```\n示例 2:\n\n```\n输入:m = 1, n = 3, maxMove = 3, startRow = 0, startColumn = 1\n\n输出:12\n```\n\n提示:\n* 1 <= m, n <= 50\n* 0 <= maxMove <= 50\n* 0 <= startRow < m\n* 0 <= startColumn < n", "solution": "### 基本分析\n\n通常来说,朴素的路径 DP 问题之所以能够使用常规 DP 方式进行求解,是因为只能往某一个方向(一维棋盘的路径问题)或者只能往某两个方向(二维棋盘的路径问题)移动。\n\n这样的移动规则意味着,我们不会重复进入同一个格子。\n\n**从图论的意义出发:将每个格子视为点的话,如果能够根据移动规则从 `a` 位置一步到达 `b` 位置,则说明存在一条由 `a` 指向 `b` 的有向边。**\n\n**也就是说,在朴素的路径 DP 问题中,“单向”的移动规则注定了我们的图不存在环,是一个存在拓扑序的有向无环图,因此我们能够使用常规 DP 手段来求解。**\n\n回到本题,移动规则是四联通,并不是“单向”的,在某条出界的路径中,我们是有可能重复进入某个格子,即存在环。\n\n因此我们需要换一种 DP 思路进行求解。\n\n---\n\n### 记忆化搜索\n\n通常在直接 DP 不好入手的情况下,我们可以先尝试写一个「记忆化搜索」的版本。\n\n那么如果是让你设计一个 DFS 函数来解决本题,你会如何设计?\n\n我大概会这样设计:\n\n```Java\nint dfs(int x, int y, int k) {}\n```\n\n重点放在几个「可变参数」与「返回值」上:$(x,y)$ 代表当前所在的位置,$k$ 代表最多使用多少步,返回值代表路径数量。\n\n根据 [DP-动态规划 第八讲](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247485297&idx=1&sn=5ee4ce31c42d368af0653f60aa263c82&chksm=fd9cac6ecaeb25787e6da90423c5467e1679da0a8aaf1a3445475199a8f148d8629e851fea57&scene=178&cur_album_id=1773144264147812354#rd) 的学习中,我们可以确定递归出口为:\n\n1. 当前到达了棋盘外的位置,说明找到了一条出界路径,返回 $1$;\n2. 在条件 $1$ 不满足的前提下,当剩余步数为 $0$(不能再走下一步),说明没有找到一条合法的出界路径,返回 $0$。\n\n主逻辑则是根据四联通规则进行移动即可,最终答案为 `dfs(startRow, startColumn, maxMove)`。\n\n代码:\n```Java\nclass Solution {\n    int MOD = (int)1e9+7;\n    int m, n, max;\n    int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n    int[][][] cache;\n    public int findPaths(int _m, int _n, int _max, int r, int c) {\n        m = _m; n = _n; max = _max;\n        cache = new int[m][n][max + 1];\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                for (int k = 0; k <= max; k++) {\n                    cache[i][j][k] = -1;\n                }\n            }\n        }\n        return dfs(r, c, max);\n    }\n    int dfs(int x, int y, int k) {\n        if (x < 0 || x >= m || y < 0 || y >= n) return 1;\n        if (k == 0) return 0;\n        if (cache[x][y][k] != -1) return cache[x][y][k];\n        int ans = 0;\n        for (int[] d : dirs) {\n            int nx = x + d[0], ny = y + d[1];\n            ans += dfs(nx, ny, k - 1);\n            ans %= MOD;\n        }\n        cache[x][y][k] = ans;\n        return ans;\n    }\n}\n```\n\n---\n\n### 动态规划\n\n根据我们的「记忆化搜索」,我们可以设计一个二维数组 $f[][]$ 作为我们的 dp 数组:\n\n* **第一维代表 DFS 可变参数中的 $(x,y)$ 所对应 $index$。取值范围为 $[0, m*n)$**\n* **第二维代表 DFS 可变参数中的 $k$。取值范围为 $[0,max]$**\n\n**dp 数组中存储的就是我们 `DFS` 的返回值:路径数量。**\n\n根据 dp 数组中的维度设计和存储目标值,我们可以得知「状态定义」为:\n\n**$f[i][j]$ 代表从位置 $i$ 出发,可用步数不超过 $j$ 时的路径数量。**\n\n至此,我们只是根据「记忆化搜索」中的 `DFS` 函数的签名,就已经得出我们的「状态定义」了,接下来需要考虑「转移方程」。\n\n当有了「状态定义」之后,我们需要从「最后一步」来推导出「转移方程」:\n\n由于题目允许往四个方向进行移动,因此我们的最后一步也要统计四个相邻的方向。\n\n由此可得我们的状态转移方程:\n\n$$\nf[(x,y)][step] = f[(x-1,y)][step-1]+f[(x+1,y)][step-1]+f[(x,y-1)][step-1]+f[(x,y+1)][step-1]\n$$\n\n注意,转移方程中 dp 数组的第一维存储的是 $(x,y)$ 对应的 $idx$。\n\n从转移方程中我们发现,更新 $f[i][j]$ 依赖于 $f[x][j-1]$,因此我们转移过程中需要将最大移动步数进行「从小到大」枚举。\n\n至此,我们已经完成求解「路径规划」问题的两大步骤:「状态定义」&「转移方程」。\n\n但这还不是所有,我们还需要一些 **有效值** 来滚动下去。\n\n**其实就是需要一些「有效值」作为初始化状态。**\n\n观察我们的「转移方程」可以发现,整个转移过程是一个累加过程,如果没有一些有效的状态(非零值)进行初始化的话,整个递推过程并没有意义。\n\n那么哪些值可以作为成为初始化状态呢?\n\n显然,当我们已经位于矩阵边缘的时候,我们可以一步跨出矩阵,这算作一条路径。\n\n同时,由于我们能够往四个方向进行移动,因此不同的边缘格子会有不同数量的路径。\n\n换句话说,我们需要先对边缘格子进行初始化操作,预处理每个边缘格子直接走出矩阵的路径数量。\n\n目的是为了我们整个 DP 过程可以有效的递推下去。\n\n**可以发现,动态规划的实现,本质是将问题进行反向:原问题是让我们求从棋盘的特定位置出发,出界的路径数量。实现时,我们则是从边缘在状态出发,逐步推导回起点的出界路径数量为多少。**\n\n代码:\n```Java\nclass Solution {\n    int MOD = (int)1e9+7;\n    int m, n, max;\n    int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n    public int findPaths(int _m, int _n, int _max, int r, int c) {\n        m = _m; n = _n; max = _max;\n        int[][] f = new int[m * n][max + 1];\n        // 初始化边缘格子的路径数量\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                if (i == 0) add(i, j, f);\n                if (j == 0) add(i, j, f);\n                if (i == m - 1) add(i, j, f);\n                if (j == n - 1) add(i, j, f);\n            }\n        }\n        // 从小到大枚举「可移动步数」\n        for (int k = 1; k <= max; k++) {\n            // 枚举所有的「位置」\n            for (int idx = 0; idx < m * n; idx++) {\n                int[] info = parseIdx(idx);\n                int x = info[0], y = info[1];\n                for (int[] d : dirs) {\n                    int nx = x + d[0], ny = y + d[1];\n                    if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;\n                    int nidx = getIdx(nx, ny);\n                    f[idx][k] += f[nidx][k - 1];\n                    f[idx][k] %= MOD;\n                }\n            }\n        }\n        return f[getIdx(r, c)][max];       \n    }\n    void add(int x, int y, int[][] f) {\n        for (int k = 1; k <= max; k++) {\n            f[getIdx(x, y)][k]++;\n        }\n    }\n    int getIdx(int x, int y) {\n        return x * n + y;\n    }\n    int[] parseIdx(int idx) {\n        return new int[]{idx / n, idx % n};\n    }\n}\n```\n* 时间复杂度:共有 $m * n * max$ 个状态需要转移,复杂度为 $O(m * n * max)$ \n* 空间复杂度:$O(m * n * max)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.576` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/581-590/581. 最短无序连续子数组（中等）.md", "url_title": "581. 最短无序连续子数组", "url": "https://leetcode-cn.com/problems/shortest-unsorted-continuous-subarray/solution/gong-shui-san-xie-yi-ti-shuang-jie-shuan-e1le/", "difficulty": "中等", "tags": ["排序", "双指针"], "question": "给你一个整数数组 `nums` ,你需要找出一个 连续子数组 ,如果对这个子数组进行升序排序,那么整个数组都会变为升序排序。\n\n请你找出符合题意的 最短 子数组,并输出它的长度。\n\n示例 1:\n```\n输入:nums = [2,6,4,8,10,9,15]\n\n输出:5\n\n解释:你只需要对 [6, 4, 8, 10, 9] 进行升序排序,那么整个表都会变为升序排序。\n```\n示例 2:\n```\n输入:nums = [1,2,3,4]\n\n输出:0 \n```\n示例 3:\n```\n输入:nums = [1]\n\n输出:0\n```\n\n提示:\n* $1 <= nums.length <= 10^4$\n* $-10^5 <= nums[i] <= 10^5$\n\n* 进阶:你可以设计一个时间复杂度为 $O(n)$ 的解决方案吗?", "solution": "### 双指针 + 排序 \n\n最终目的是让整个数组有序,那么我们可以先将数组拷贝一份进行排序,然后使用两个指针 $i$ 和 $j$ 分别找到左右两端第一个不同的地方,那么 $[i, j]$ 这一区间即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int findUnsortedSubarray(int[] nums) {\n        int n = nums.length;\n        int[] arr = nums.clone();\n        Arrays.sort(arr);\n        int i = 0, j = n - 1;\n        while (i <= j && nums[i] == arr[i]) i++;\n        while (i <= j && nums[j] == arr[j]) j--;\n        return j - i + 1;\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 双指针 + 线性扫描\n\n另外一个做法是,我们把整个数组分成三段处理。\n\n起始时,先通过双指针 $i$ 和 $j$ 找到左右两次侧满足 **单调递增** 的分割点。\n\n即此时 $[0, i]$ 和 $[j, n)$ 满足升序要求,而中间部分 $(i, j)$ **不确保有序**。\n\n然后我们对中间部分 $[i, j]$ 进行遍历:\n\n* 发现 $nums[x] < nums[i - 1]$:由于对 $[i, j]$ 部分进行排序后 $nums[x]$ 会出现在 $nums[i - 1]$ 后,将不满足整体升序,此时我们需要调整分割点 $i$ 的位置;\n* 发现 $nums[x] > nums[j + 1]$:由于对 $[i, j]$ 部分进行排序后 $nums[x]$ 会出现在 $nums[j + 1]$ 前,将不满足整体升序,此时我们需要调整分割点 $j$ 的位置。\n\n> 一些细节:在调整 $i$ 和 $j$ 的时候,我们可能会到达数组边缘,这时候可以建立两个哨兵:数组左边存在一个足够小的数,数组右边存在一个足够大的数。\n\n代码:\n```Java\nclass Solution {\n    int MIN = -100005, MAX = 100005;\n    public int findUnsortedSubarray(int[] nums) {\n        int n = nums.length;\n        int i = 0, j = n - 1;\n        while (i < j && nums[i] <= nums[i + 1]) i++;\n        while (i < j && nums[j] >= nums[j - 1]) j--;\n        int l = i, r = j;\n        int min = nums[i], max = nums[j];\n        for (int u = l; u <= r; u++) {\n            if (nums[u] < min) {\n                while (i >= 0 && nums[i] > nums[u]) i--;\n                min = i >= 0 ? nums[i] : MIN;\n            }\n            if (nums[u] > max) {\n                while (j < n && nums[j] < nums[u]) j++;\n                max = j < n ? nums[j] : MAX;\n            }\n        }\n        return j == i ? 0 : (j - 1) - (i + 1) + 1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.581` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/581-590/583. 两个字符串的删除操作（中等）.md", "url_title": "583. 两个字符串的删除操作", "url": "https://leetcode-cn.com/problems/delete-operation-for-two-strings/solution/gong-shui-san-xie-cong-liang-chong-xu-li-wqv7/", "difficulty": "中等", "tags": ["最长公共子序列", "序列 DP"], "question": "给定两个单词 `s1` 和 `s2`,找到使得 `s1` 和 `s2` 相同所需的最小步数,每步可以删除任意一个字符串中的一个字符。\n\n示例:\n\n```\n输入: \"sea\", \"eat\"\n\n输出: 2\n\n解释: 第一步将\"sea\"变为\"ea\",第二步将\"eat\"变为\"ea\"\n```\n\n提示:\n* 给定单词的长度不超过 $500$。\n* 给定单词中的字符只含有小写字母。", "solution": "### 转换为 LCS 问题\n\n首先,给定两字符 `s1` 和 `s2`,求经过多少次删除操作,可使得两个相等字符串。\n\n该问题等价于求解两字符的「最长公共子序列」,若两者长度分别为 $n$ 和 $m$,而最长公共子序列长度为 $max$,则 $n - max + m - max$ 即为答案。\n\n对「最长公共子序列(LCS)」不熟悉的同学,可以看 [(题解) 1143. 最长公共子序列](https://leetcode-cn.com/problems/longest-common-subsequence/solution/gong-shui-san-xie-zui-chang-gong-gong-zi-xq0h/)。\n\n**$f[i][j]$ 代表考虑 $s1$ 的前 $i$ 个字符、考虑 $s2$ 的前 $j$ 个字符(但最长公共子序列中不一定包含 $s1[i]$ 或者 $s2[j]$)时形成的「最长公共子序列(LCS)」长度。**\n\n当有了「状态定义」之后,基本上「转移方程」就是呼之欲出:\n\n* `s1[i]==s2[j]` : $f[i][j]=f[i-1][j-1]+1$。代表 **必然使用 $s1[i]$ 与 $s2[j]$ 时** LCS 的长度。\n* `s1[i]!=s2[j]` : $f[i][j]=max(f[i-1][j], f[i][j-1])$。代表 **必然不使用 $s1[i]$(但可能使用$s2[j]$)时** 和 **必然不使用 $s2[j]$(但可能使用$s1[i]$)时** LCS 的长度。\n\n可以发现,上述两种讨论已经包含了「不使用 $s1[i]$ 和 $s2[j]$」、「仅使用 $s1[i]$」、「仅使用 $s2[j]$」和「使用 $s1[i]$ 和 $s2[j]$」四种情况。\n\n虽然「不使用 $s1[i]$ 和 $s2[j]$」会被 $f[i - 1][j]$ 和 $f[i][j - 1]$ 重复包含,但对于求最值问题,重复比较并不想影响答案正确性。\n\n因此最终的 $f[i][j]$ 为上述两种讨论中的最大值。\n\n一些编码细节:\n\n通常会习惯性往字符串头部追加一个空格,以减少边界判断(使下标从 1 开始,并很容易构造出可滚动的「有效值」)。但实现上,不用真的往字符串中最佳空格,只需在初始化动规值时假定存在首部空格,以及对最后的 LCS 长度进行减一操作即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public int minDistance(String s1, String s2) {\n        char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray();\n        int n = s1.length(), m = s2.length();\n        int[][] f = new int[n + 1][m + 1];\n        // 假定存在哨兵空格,初始化 f[0][x] 和 f[x][0]\n        for (int i = 0; i <= n; i++) f[i][0] = 1;\n        for (int j = 0; j <= m; j++) f[0][j] = 1;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);\n                if (cs1[i - 1] == cs2[j - 1]) f[i][j] = Math.max(f[i][j], f[i - 1][j - 1] + 1);\n            }\n        }\n        int max = f[n][m] - 1; // 减去哨兵空格\n        return n - max + m - max;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int minDistance(string s1, string s2) {\n        int n = s1.size(), m = s2.size();\n        vector<vector<int>> f(n + 1, vector<int>(m + 1));\n        for (int i = 0; i <= n; i++) f[i][0] = 1;\n        for (int j = 0; j <= m; j++) f[0][j] = 1;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                f[i][j] = max(f[i - 1][j], f[i][j - 1]);\n                if (s1[i - 1] == s2[j - 1]) f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1);\n            }\n        }\n        int max = f[n][m] - 1;\n        return n - max + m - max;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minDistance(self, s1: str, s2: str) -> int:\n        n, m = len(s1), len(s2)\n        f = [[1]* (m + 1) for _ in range(n + 1)]\n        for i in range(1, n + 1):\n            for j in range(1, m + 1):\n                f[i][j] = max(f[i - 1][j], f[i][j - 1])\n                if s1[i - 1] == s2[j - 1]:\n                    f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1)\n        max_val = f[n][m] - 1\n        return n - max_val + m - max_val\n```\nTypeScript 代码:\n```TypeScript\nfunction minDistance(s1: string, s2: string): number {\n    const n = s1.length, m = s2.length;\n    const f: number[][] = Array(n + 1).fill(0).map(() => Array(m + 1).fill(1));\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= m; j++) {\n            f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);\n            if (s1[i - 1] === s2[j - 1]) {\n                f[i][j] = Math.max(f[i][j], f[i - 1][j - 1] + 1);\n            }\n        }\n    }\n    const max = f[n][m] - 1;\n    return n - max + m - max;  \n};\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n \\times m)$\n\n---\n\n### 序列 DP\n\n上述解决方案是套用了「最长公共子序列(LCS)」进行求解,最后再根据 LCS 长度计算答案。\n\n而更加契合题意的状态定义是根据「最长公共子序列(LCS)」的原始状态定义进行微调:**定义 $f[i][j]$ 代表考虑 $s1$ 的前 $i$ 个字符、考虑 $s2$ 的前 $j$ 个字符(最终字符串不一定包含 $s1[i]$ 或 $s2[j]$)时形成相同字符串的最小删除次数。**\n\n同理,不失一般性的考虑 $f[i][j]$ 该如何计算:\n\n* `s1[i]==s2[j]`:$f[i][j] = f[i - 1][j - 1]$,代表可以不用必然删掉 $s1[i]$ 和 $s2[j]$ 形成相同字符串;\n* `s1[i]!=s2[j]`:$f[i][j] = \\min(f[i - 1][j] + 1, f[i][j - 1] + 1)$,代表至少一个删除 $s1[i]$ 和 $s2[j]$ 中的其中一个。\n\n$f[i][j]$ 为上述方案中的最小值,最终答案为 $f[n][m]$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int minDistance(String s1, String s2) {\n        char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray();\n        int n = s1.length(), m = s2.length();\n        int[][] f = new int[n + 1][m + 1];\n        for (int i = 0; i <= n; i++) f[i][0] = i;\n        for (int j = 0; j <= m; j++) f[0][j] = j;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                f[i][j] = Math.min(f[i - 1][j] + 1, f[i][j - 1] + 1);\n                if (cs1[i - 1] == cs2[j - 1]) f[i][j] = Math.min(f[i][j], f[i - 1][j - 1]);\n            }\n        }\n        return f[n][m];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int minDistance(string s1, string s2) {\n        int n = s1.size(), m = s2.size();\n        vector<vector<int>> f(n + 1, vector<int>(m + 1));\n        for(int i = 0; i <= n; i++) f[i][0] = i;\n        for(int j = 0; j <= m; j++) f[0][j] = j;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1);\n                if (s1[i - 1] == s2[j - 1]) f[i][j] = min(f[i][j], f[i - 1][j - 1]);\n            }\n        }\n        return f[n][m];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minDistance(self, s1: str, s2: str) -> int:\n        n, m = len(s1), len(s2)\n        f = [[0]* (m + 1) for _ in range(n + 1)]\n        for i in range(n + 1):\n            f[i][0] = i\n        for i in range(m + 1): \n            f[0][i] = i\n        for i in range(1, n + 1):\n            for j in range(1, m + 1):\n                f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1)\n                if s1[i - 1] == s2[j - 1]:\n                    f[i][j] = min(f[i][j], f[i - 1][j - 1])\n        return f[n][m]\n```\nTypeScript 代码:\n```TypeScript\nfunction minDistance(s1: string, s2: string): number {\n    const n = s1.length, m = s2.length;\n    const f: number[][] = Array.from({length: n + 1}, () => Array(m + 1).fill(0));\n    for(let i = 0; i <= n; i++) f[i][0] = i;\n    for(let i = 0; i <= m; i++) f[0][i] = i;\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= m; j++) {\n            f[i][j] = Math.min(f[i - 1][j] + 1, f[i][j - 1] + 1);\n            if (s1.charAt(i - 1) == s2.charAt(j - 1)) f[i][j] = Math.min(f[i][j], f[i - 1][j - 1]);\n        }\n    }\n    return f[n][m];\n};\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n \\times m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.583` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/581-590/587. 安装栅栏（困难）.md", "url_title": "587. 安装栅栏", "url": "https://leetcode-cn.com/problems/erect-the-fence/solution/by-ac_oier-4xuu/", "difficulty": "困难", "tags": ["计算几何", "凸包"], "question": "在一个二维的花园中,有一些用 $(x, y)$ 坐标表示的树。由于安装费用十分昂贵,你的任务是先用最短的绳子围起所有的树。只有当所有的树都被绳子包围时,花园才能围好栅栏。\n\n你需要找到正好位于栅栏边界上的树的坐标。\n\n示例 1:\n\n```\n输入: [[1,1],[2,2],[2,0],[2,4],[3,3],[4,2]]\n\n输出: [[1,1],[2,0],[4,2],[3,3],[2,4]]\n\n```\n示例 2:\n\n```\n输入: [[1,2],[2,2],[4,2]]\n\n输出: [[1,2],[2,2],[4,2]]\n\n解释:即使树都在一条直线上,你也需要先用绳子包围它们。\n```\n\n注意:\n* 所有的树应当被围在一起。你不能剪断绳子来包围树或者把树分成一组以上。\n* 输入的整数在 $0$ 到 $100$ 之间。\n* 花园至少有一棵树。\n* 所有树的坐标都是不同的。\n* 输入的点没有顺序。输出顺序也没有要求。", "solution": "### 二维凸包(Andrew 算法)\n\n这是一道「二维凸包」板子题,需要注意的是网上大多数 `Andrew` 算法的板子都是有问题的(下面会说)。\n\n`Andrew` 算法正是用于求解凸包上的所有点(围成所有点的最小周长),其算法逻辑将凸包分为「上凸壳」和「下凸壳」,并分别画出(蓝色分割线将凸包分为两部分):\n\n基本流程为:\n\n1. 对所有点进行双关键字排序,先根据 $x$ 坐标排升序,后根据 $y$ 排升序;\n    根据 $x$ 排升序的目的,是为了我们能够往一个方向画出凸包边缘(从左往后画出一半凸壳,从右往左画出另外一半),而将 $y$ 升序目的是可以确保一旦我们现在从 $a$ 到 $b$ 进行连线,那么 $a$ 到 $b$ 之间的所有点能够确保被围住;\n    \n2. 使用栈来维护所有凸包上的点,或者说凸包上的边,会更为准确,凸包起点元素会在栈中出现两次(首尾),因此更为准确的描述应该是使用栈维护凸包的所有的边,栈中相邻元素代表凸包上的一条边;\n\n3. 分别「从前往后」和「从后往前」处理排序好的所有点,来分别画出凸包的两半部分,根据画的是第一部分还是第二部分,维护栈内元的处理逻辑稍有不同:\n\n    **a. 画的是凸包的第一部分:**\n    * 若栈内元素少于 $2$ 个,组成一条线至少需要两个点,说明此时第一条边都还没画出,直接将元素添加到栈中;\n    * 若栈内元素不少于 $2$ 个,考虑是否要将栈顶的边删掉(由栈顶前两个元素组成的边)假设栈顶元素为 $b$,栈顶元素的下一位为 $a$,即栈顶存在一条 $a$ 到 $b$ 的边,当前处理到的点为 $c$,此时我们根据 $ac$ 边是否在 $ab$ 边的时针方向来决定是否要将 $ab$ 边去掉:\n    \n        \n\n        按照上述逻辑处理完所有点,凸包第一部分的点(边)都存在于栈中。\n    \n    **b. 画的是凸包的第二部分:逻辑同理,唯一需要注意的是,第一部分的凸包边我们不能删去,假定处理完第一部分凸包,我们栈内有 $m$ 个元素,我们需要将上述「栈顶元素不少于 $2$ 个」的逻辑替换为「栈顶元素大于 $m$ 个」,同时已参与到凸包第一部分的点,不能再考虑,因此需要额外使用一个 $vis$ 数组来记录使用过的点。**\n\n一些细节,为了方便取得栈顶的前两位元素,我们使用数组实现栈,$stk$ 代表栈容器,$tp$ 代表栈顶元素下标。\n\n正如刚刚讲到,起点会被入栈两次(对应第一条边和最后一条边),因此输出方案时,栈顶和栈底我们只选其一即可。\n\n代码:\n```Java\nclass Solution {\n    int[] subtraction(int[] a, int[] b) { // 向量相减\n        return new int[]{a[0] - b[0], a[1] - b[1]};\n    }\n    double cross(int[] a, int[] b) { // 叉乘\n        return a[0] * b[1] - a[1] * b[0];\n    }\n    double getArea(int[] a, int[] b, int[] c) { // 向量 ab 转为 向量 ac 过程中扫过的面积\n        return cross(subtraction(b, a), subtraction(c, a));\n    }\n    public int[][] outerTrees(int[][] trees) {\n        Arrays.sort(trees, (a, b)->{\n            return a[0] != b[0] ? a[0] - b[0] : a[1] - b[1];\n        });\n        int n = trees.length, tp = 0;\n        int[] stk = new int[n + 10];\n        boolean[] vis = new boolean[n + 10];\n        stk[++tp] = 0; // 不标记起点\n        for (int i = 1; i < n; i++) {\n            int[] c = trees[i];\n            while (tp >= 2) {\n                int[] a = trees[stk[tp - 1]], b = trees[stk[tp]];\n                if (getArea(a, b, c) > 0) vis[stk[tp--]] = false;\n                else break;\n            }\n            stk[++tp] = i;\n            vis[i] = true;\n        }\n        int size = tp;\n        for (int i = n - 1; i >= 0; i--) {\n            if (vis[i]) continue;\n            int[] c = trees[i];\n            while (tp > size) {\n                int[] a = trees[stk[tp - 1]], b = trees[stk[tp]];\n                if (getArea(a, b, c) > 0) tp--;\n                // vis[stk[tp--]] = false; // 非必须\n                else break;\n            }\n            stk[++tp] = i;\n            // vis[i] = true; // 非必须\n        }\n        int[][] ans = new int[tp - 1][2];\n        for (int i = 1; i < tp; i++) ans[i - 1] = trees[stk[i]];\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$,统计凸包上的点复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 网上 `Andrew` 板子问题\n\n由于我太久没写计算几何了,翻了一下以前在其他 OJ 提交的题,找回自己几年前的板子,好奇心驱使,想看看现在是否有板子上的突破(通常很难,尤其对于计算几何而言),结果发现网上绝大多数板子都存在严重逻辑错误:\n\n1. 最为严重的错误是,处理凸包第一部分和第二部分,都是使用「栈顶元素不少于 $2$ 个」的逻辑:即使存在 $vis$ 数组也无法避免该逻辑错误,在某些数据上,该逻辑**会导致最右边的一些点无法被围住**;\n2. 存在对 `vis` 数组的错误理解:`vis` 的作用仅是为了处理凸包第二部分的时候,不要使用到凸包第一部分的点而已。**含义并非是处理过的点,或者当前凸包上的点**,因此你可以看到我代码注释中写了「不标记起点」和「非必须」,在画第二部分的凸包时,只需要确保第一部分使用的点不参与即可,**重复点问题本身就由遍历所保证,而并非 $vis$ 数组**。当然,为了记忆方便,让模板更具有“对称性”,也可以保留在画第二部分凸包的时候,保留对 $vis$ 的维护逻辑,但千万不要搞错了 $vis$ 的含义。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.587` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/581-590/589. N 叉树的前序遍历（简单）.md", "url_title": "589. N 叉树的前序遍历", "url": "https://leetcode-cn.com/problems/n-ary-tree-preorder-traversal/solution/gong-shui-san-xie-shu-de-sou-suo-yun-yon-pse1/", "difficulty": "简单", "tags": ["树的搜索", "递归", "迭代"], "question": "给定一个 $n$ 叉树的根节点  $root$ ,返回 其节点值的 前序遍历 。\n\n$n$ 叉树 在输入中按层序遍历进行序列化表示,每组子节点由空值 `null` 分隔(请参见示例)。\n\n示例 1:\n\n```\n输入:root = [1,null,3,2,4,null,5,6]\n\n输出:[1,3,5,6,2,4]\n```\n示例 2:\n\n```\n输入:root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]\n\n输出:[1,2,3,6,7,11,14,4,8,12,5,9,13,10]\n```\n\n提示:\n* 节点总数在范围 $[0, 10^4]$ 内\n* $0 <= Node.val <= 10^4$\n* $n$ 叉树的高度小于或等于 $1000$\n\n进阶:递归法很简单,你可以使用迭代法完成此题吗?", "solution": "### 递归\n\n常规做法,不再赘述。\n\n代码:\n```Java\nclass Solution {\n    List<Integer> ans = new ArrayList<>();\n    public List<Integer> preorder(Node root) {\n        dfs(root);\n        return ans;\n    }\n    void dfs(Node root) {\n        if (root == null) return ;\n        ans.add(root.val);\n        for (Node node : root.children) dfs(node);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$\n\n---\n\n### 迭代\n\n针对本题,使用「栈」模拟递归过程。\n\n迭代过程中记录 `(node = 当前节点, cnt = 当前节点遍历过的子节点数量)` 二元组,每次取出栈顶元素,如果当前节点是首次出队(当前遍历过的子节点数量为 $cnt = 0$),则将当前节点的值加入答案,然后更新当前元素遍历过的子节点数量,并重新入队,即将 $(node, cnt + 1)$ 入队,以及将下一子节点 $(node.children[cnt], 0)$ 进行首次入队。\n\n代码;\n```Java\nclass Solution {\n    public List<Integer> preorder(Node root) {\n        List<Integer> ans = new ArrayList<>();\n        Deque<Object[]> d = new ArrayDeque<>();\n        d.addLast(new Object[]{root, 0});\n        while (!d.isEmpty()) {\n            Object[] poll = d.pollLast();\n            Node t = (Node)poll[0]; Integer cnt = (Integer)poll[1];\n            if (t == null) continue;\n            if (cnt == 0) ans.add(t.val);\n            if (cnt < t.children.size()) {\n                d.addLast(new Object[]{t, cnt + 1});\n                d.addLast(new Object[]{t.children.get(cnt), 0});\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 通用「递归」转「迭代」\n\n另外一种「递归」转「迭代」的做法,是直接模拟系统执行「递归」的过程,这是一种更为通用的做法。\n\n**由于现代编译器已经做了很多关于递归的优化,现在这种技巧已经无须掌握。**\n\n在迭代过程中记录当前栈帧位置状态 `loc`,在每个状态流转节点做相应操作。\n\n代码:\n```Java\nclass Solution {\n    public List<Integer> preorder(Node root) {\n        List<Integer> ans = new ArrayList<>();\n        Deque<Object[]> d = new ArrayDeque<>();\n        d.addLast(new Object[]{0, root});\n        while (!d.isEmpty()) {\n            Object[] poll = d.pollLast();\n            Integer loc = (Integer)poll[0]; Node t = (Node)poll[1];\n            if (t == null) continue;\n            if (loc == 0) {\n                ans.add(t.val);\n                d.addLast(new Object[]{1, t});\n            } else if (loc == 1) {\n                int n = t.children.size();\n                for (int i = n - 1; i >= 0; i--) {\n                    d.addLast(new Object[]{0, t.children.get(i)});\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.589` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/581-590/590. N 叉树的后序遍历（简单）.md", "url_title": "590. N 叉树的后序遍历", "url": "https://leetcode-cn.com/problems/n-ary-tree-postorder-traversal/solution/by-ac_oier-ul7t/", "difficulty": "简单", "tags": ["递归", "迭代", "非递归", "DFS", "BFS"], "question": "给定一个 $n$ 叉树的根节点 $root$ ,返回 其节点值的**后序遍历**。\n\n$n$ 叉树在输入中按层序遍历进行序列化表示,每组子节点由空值 `null` 分隔(请参见示例)。\n\n示例 1:\n\n```\n输入:root = [1,null,3,2,4,null,5,6]\n\n输出:[5,6,3,2,4,1]\n```\n示例 2:\n\n``` \n输入:root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]\n\n输出:[2,6,14,11,7,3,12,8,4,13,9,10,5,1]\n```\n\n提示:\n* 节点总数在范围 $[0, 10^4]$ 内\n* $0 <= Node.val <= 10^4$\n* $n$ 叉树的高度小于或等于 $1000$\n\n进阶:递归法很简单,你可以使用迭代法完成此题吗?", "solution": "### 递归\n\n常规做法,不再赘述。\n\nJava 代码:\n```Java\nclass Solution {\n    List<Integer> ans = new ArrayList<>();\n    public List<Integer> postorder(Node root) {\n        dfs(root);\n        return ans;\n    }\n    void dfs(Node root) {\n        if (root == null) return;\n        for (Node node : root.children) dfs(node);\n        ans.add(root.val);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> postorder(Node* root) {\n        vector<int> ans;\n        dfs(root, ans);\n        return ans;\n    }\n    void dfs(Node* root, vector<int>& ans) {\n        if (!root) return;\n        for (Node* child : root->children) dfs(child, ans);\n        ans.push_back(root->val);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def postorder(self, root: 'Node') -> List[int]:\n        def dfs(root, ans):\n            if not root: return\n            for child in root.children:\n                dfs(child, ans)\n            ans.append(root.val)\n        ans = []\n        dfs(root, ans)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction postorder(root: Node | null): number[] {\n    const dfs = function(root: Node | null, ans: number[]): void {\n        if (!root) return ;\n        for (const child of root.children) dfs(child, ans);\n        ans.push(root.val);\n    };\n    const ans: number[] = [];\n    dfs(root, ans);\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$\n\n---\n\n### 非递归\n\n针对本题,使用「栈」模拟递归过程。\n\n迭代过程中记录 `(cnt = 当前节点遍历过的子节点数量, node = 当前节点)` 二元组,每次取出栈顶元素,如果当前节点已经遍历完所有的子节点(当前遍历过的子节点数量为 $cnt = 子节点数量$),则将当前节点的值加入答案。\n\n否则更新当前元素遍历过的子节点数量,并重新入队,即将 $(cnt + 1, node)$ 入队,以及将下一子节点 $(0, node.children[cnt])$ 进行首次入队。\n\nJava 代码:\n```Java\nclass Solution {\n    public List<Integer> postorder(Node root) {\n        List<Integer> ans = new ArrayList<>();\n        Deque<Object[]> d = new ArrayDeque<>();\n        d.addLast(new Object[]{0, root});\n        while (!d.isEmpty()) {\n            Object[] poll = d.pollLast();\n            Integer cnt = (Integer)poll[0]; Node t = (Node)poll[1];\n            if (t == null) continue;\n            if (cnt == t.children.size()) ans.add(t.val);\n            if (cnt < t.children.size()) {\n                d.addLast(new Object[]{cnt + 1, t});\n                d.addLast(new Object[]{0, t.children.get(cnt)});      \n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> postorder(Node* root) {\n        vector<int> ans;\n        stack<pair<int, Node*>> st;\n        st.push({0, root});\n        while (!st.empty()) {\n            auto [cnt, t] = st.top();\n            st.pop();\n            if (!t) continue;\n            if (cnt == t->children.size()) ans.push_back(t->val);\n            if (cnt < t->children.size()) {\n                st.push({cnt + 1, t});\n                st.push({0, t->children[cnt]});\n            }\n        }\n        return ans;\n    }   \n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def postorder(self, root: 'Node') -> List[int]:\n        ans = []\n        stack = [(0, root)]\n        while stack:\n            cnt, t = stack.pop()\n            if not t: continue\n            if cnt == len(t.children):\n                ans.append(t.val)\n            if cnt < len(t.children):\n                stack.append((cnt + 1, t))\n                stack.append((0, t.children[cnt]))\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction postorder(root: Node | null): number[] {\n    const ans = [], stack = [];\n    stack.push([0, root]);\n    while (stack.length > 0) {\n        const [cnt, t] = stack.pop()!;\n        if (!t) continue;\n        if (cnt === t.children.length) ans.push(t.val);\n        if (cnt < t.children.length) {\n            stack.push([cnt + 1, t]);\n            stack.push([0, t.children[cnt]]);\n        }\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 通用「非递归」\n\n另外一种「递归」转「迭代」的做法,是直接模拟系统执行「递归」的过程,这是一种更为通用的做法。\n\n**由于现代编译器已经做了很多关于递归的优化,现在这种技巧已经无须掌握。**\n\n在迭代过程中记录当前栈帧位置状态 `loc`,在每个状态流转节点做相应操作。\n\nJava 代码:\n```Java\nclass Solution {\n    public List<Integer> postorder(Node root) {\n        List<Integer> ans = new ArrayList<>();\n        Deque<Object[]> d = new ArrayDeque<>();\n        d.addLast(new Object[]{0, root});\n        while (!d.isEmpty()) {\n            Object[] poll = d.pollLast();\n            Integer loc = (Integer)poll[0]; Node t = (Node)poll[1];\n            if (t == null) continue;\n            if (loc == 0) {\n                d.addLast(new Object[]{1, t});\n                int n = t.children.size();\n                for (int i = n - 1; i >= 0; i--) d.addLast(new Object[]{0, t.children.get(i)});\n            } else if (loc == 1) {\n                ans.add(t.val);\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> postorder(Node* root) {\n        vector<int> ans;\n        stack<pair<int, Node*>> st;\n        st.push({0, root});\n        while (!st.empty()) {\n            int loc = st.top().first;\n            Node* t = st.top().second;\n            st.pop();\n            if (!t) continue;\n            if (loc == 0) {\n                st.push({1, t});\n                for (int i = t->children.size() - 1; i >= 0; i--) {\n                    st.push({0, t->children[i]});\n                }\n            } else if (loc == 1) {\n                ans.push_back(t->val);\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def postorder(self, root: 'Node') -> List[int]:\n        ans = []\n        stack = [(0, root)]\n        while stack:\n            loc, t = stack.pop()\n            if not t: continue\n            if loc == 0:\n                stack.append((1, t))\n                for child in reversed(t.children):\n                    stack.append((0, child))\n            elif loc == 1:\n                ans.append(t.val)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction postorder(root: Node | null): number[] {\n    const ans: number[] = [];\n    const stack: [number, Node | null][] = [[0, root]];\n    while (stack.length > 0) {\n        const [loc, t] = stack.pop()!;\n        if (!t) continue;\n        if (loc === 0) {\n            stack.push([1, t]);\n            for (let i = t.children.length - 1; i >= 0; i--) {\n                stack.push([0, t.children[i]]);\n            }\n        } else if (loc === 1) {\n            ans.push(t.val);\n        }\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.590` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/591-600/591. 标签验证器（困难）.md", "url_title": "591. 标签验证器", "url": "https://leetcode-cn.com/problems/tag-validator/solution/by-ac_oier-9l8z/", "difficulty": "困难", "tags": ["模拟", "栈"], "question": "给定一个表示代码片段的字符串,你需要实现一个验证器来解析这段代码,并返回它是否合法。合法的代码片段需要遵守以下的所有规则:\n\n1. 代码必须被合法的闭合标签包围。否则,代码是无效的。\n2. 闭合标签(不一定合法)要严格符合格式:`<TAG_NAME>TAG_CONTENT</TAG_NAME>`。其中,`<TAG_NAME>` 是起始标签,`</TAG_NAME>` 是结束标签。起始和结束标签中的 `TAG_NAME` 应当相同。当且仅当 `TAG_NAME` 和 `TAG_CONTENT` 都是合法的,闭合标签才是合法的。\n3. 合法的 `TAG_NAME` 仅含有大写字母,长度在范围 $[1,9]$ 之间。否则,该 `TAG_NAME` 是不合法的。\n4. 合法的 `TAG_CONTENT` 可以包含其他合法的闭合标签,`cdata` ( 请参考规则 $7$ )和任意字符( 注意参考规则 $1$ )除了不匹配的 `<`、不匹配的起始和结束标签、不匹配的或带有不合法 `TAG_NAME` 的闭合标签。否则,`TAG_CONTENT` 是不合法的。\n5. 一个起始标签,如果没有具有相同 `TAG_NAME` 的结束标签与之匹配,是不合法的。反之亦然。不过,你也需要考虑标签嵌套的问题。\n6. 一个 `<`,如果你找不到一个后续的 `>` 与之匹配,是不合法的。并且当你找到一个 `<` 或`</` 时,所有直到下一个 `>` 的前的字符,都应当被解析为 `TAG_NAME`(不一定合法)。\n7. `cdata` 有如下格式:`<![CDATA[CDATA_CONTENT]]>`。`CDATA_CONTENT` 的范围被定义成 `<![CDATA[` 和后续的第一个 `]]>`之间的字符。\n8. `CDATA_CONTENT` 可以包含任意字符。`cdata` 的功能是阻止验证器解析 `CDATA_CONTENT`,所以即使其中有一些字符可以被解析为标签(无论合法还是不合法),也应该将它们视为常规字符。\n\n合法代码的例子:\n```\n输入: \"<DIV>This is the first line <![CDATA[<div>]]></DIV>\"\n\n输出: True\n\n解释: \n\n代码被包含在了闭合的标签内: <DIV> 和 </DIV> 。\n\nTAG_NAME 是合法的,TAG_CONTENT 包含了一些字符和 cdata 。 \n\n即使 CDATA_CONTENT 含有不匹配的起始标签和不合法的 TAG_NAME,它应该被视为普通的文本,而不是标签。\n\n所以 TAG_CONTENT 是合法的,因此代码是合法的。最终返回True。\n\n输入: \"<DIV>>>  ![cdata[]] <![CDATA[<div>]>]]>]]>>]</DIV>\"\n\n输出: True\n\n解释:\n\n我们首先将代码分割为: start_tag|tag_content|end_tag 。\n\nstart_tag -> \"<DIV>\"\n\nend_tag -> \"</DIV>\"\n\ntag_content 也可被分割为: text1|cdata|text2 。\n\ntext1 -> \">>  ![cdata[]] \"\n\ncdata -> \"<![CDATA[<div>]>]]>\" ,其中 CDATA_CONTENT 为 \"<div>]>\"\n\ntext2 -> \"]]>>]\"\n\nstart_tag 不是 \"<DIV>>>\" 的原因参照规则 6 。\ncdata 不是 \"<![CDATA[<div>]>]]>]]>\" 的原因参照规则 7 。\n```\n不合法代码的例子:\n```\n输入: \"<A>  <B> </A>   </B>\"\n输出: False\n解释: 不合法。如果 \"<A>\" 是闭合的,那么 \"<B>\" 一定是不匹配的,反之亦然。\n\n输入: \"<DIV>  div tag is not closed  <DIV>\"\n输出: False\n\n输入: \"<DIV>  unmatched <  </DIV>\"\n输出: False\n\n输入: \"<DIV> closed tags with invalid tag name  <b>123</b> </DIV>\"\n输出: False\n\n输入: \"<DIV> unmatched tags with invalid tag name  </1234567890> and <CDATA[[]]>  </DIV>\"\n输出: False\n\n输入: \"<DIV>  unmatched start tag <B>  and unmatched end tag </C>  </DIV>\"\n输出: False\n```\n注意:\n* 为简明起见,你可以假设输入的代码(包括提到的任意字符)只包含`数字`, `字母`, `'<'`,`'>'`,`'/'`,`'!'`,`'['`,`']'`和`' '`。", "solution": "### 模拟(栈)\n\n字符串大模拟,假设字符串 `s` 长度为 $n$,当前处理到的位置为 $i$,根据以下优先级进行检查:\n\n1. 优先尝试检查以 $i$ 为开始的连续段是否为 `CDATA`,若能匹配到开头,则尝试匹配到 `CDATA` 的结尾处,并更新 $i$,若无法找到结尾,返回 `False`;\n2. 尝试匹配 $s[i]$ 是否为 `<`,若满足,则根据 $s[i + 1]$ 是否为 `/` 来判断当前 `TAG_NAME` 是处于右边还是左边,然后将 `TAG_NAME` 取出,记为 $tag$,判断 $tag$ 长度是否合法,不合法返回 `False`,合法则根据是左边还是右边的 `TAG_NAME` 分情况讨论:\n    * 位于左边的 `TAG_NAME`:将其加入栈中,等待右边的 `TAG_NAME` 与其匹配;\n    * 位于右边的 `TAG_NAME`:将其与当前栈顶的元素进行匹配,若栈为空或匹配不上,返回 `False`(注意:由于整个 `s` 应当被一对 `TAG_NAME` 所包裹,因此如果取出后栈顶元素匹配后,栈为空,同时又还没处理完整个 `s`,此时 `s` 也不合法,返回 `Fasle`);\n3. 其余情况则为普通字符。\n\n最后由于整个 `s` 应当被一对 `TAG_NAME` 所包裹,因此当 $i = 0$ 时,不能是情况 $1$ 和情况 $3$,需要特判一下。\n\n代码:\n```Java\nclass Solution {\n    String CDATA1 = \"<![CDATA[\", CDATA2 = \"]]>\";\n    public boolean isValid(String s) {\n        Deque<String> d = new ArrayDeque<>();\n        int n = s.length(), i = 0;\n        while (i < n) {\n            if (i + 8 < n && s.substring(i, i + 9).equals(CDATA1)) {\n                if (i == 0) return false;\n                int j = i + 9;\n                boolean ok = false;\n                while (j < n && !ok) {\n                    if (j + 2 < n && s.substring(j, j + 3).equals(CDATA2)) {\n                        j = j + 3; ok = true;\n                    } else {\n                        j++;\n                    }\n                }\n                if (!ok) return false;\n                i = j;\n            } else if (s.charAt(i) == '<') {\n                if (i == n - 1) return false;\n                boolean isEnd = s.charAt(i + 1) == '/';\n                int p = isEnd ? i + 2 : i + 1, j = p;\n                while (j < n && s.charAt(j) != '>') {\n                    if (!Character.isUpperCase(s.charAt(j))) return false;\n                    j++;\n                }\n                if (j == n) return false;\n                int len = j - p;\n                if (len < 1 || len > 9) return false;\n                String tag = s.substring(p, j);\n                i = j + 1;\n                if (!isEnd) {\n                    d.addLast(tag);\n                } else {\n                    if (d.isEmpty() || !d.pollLast().equals(tag)) return false;\n                    if (d.isEmpty() && i < n) return false;\n                }\n            } else {\n                if (i == 0) return false;\n                i++;\n            }\n        }\n        return d.isEmpty();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.591` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/591-600/592. 分数加减运算（中等）.md", "url_title": "592. 分数加减运算", "url": "https://leetcode.cn/problems/fraction-addition-and-subtraction/solution/by-ac_oier-rmpy/", "difficulty": "中等", "tags": ["表达式计算", "模拟"], "question": "给定一个表示分数加减运算的字符串 `expression`,你需要返回一个字符串形式的计算结果。 \n\n这个结果应该是不可约分的分数,即最简分数。 如果最终结果是一个整数,例如 $2$,你需要将它转换成分数形式,其分母为 $1$。所以在上述例子中, $2$ 应该被转换为 `2/1`。\n\n示例 1:\n```\n输入: expression = \"-1/2+1/2\"\n\n输出: \"0/1\"\n```\n示例 2:\n```\n输入: expression = \"-1/2+1/2+1/3\"\n\n输出: \"1/3\"\n```\n示例 3:\n```\n输入: expression = \"1/3-1/2\"\n\n输出: \"-1/6\"\n```\n\n提示:\n* 输入和输出字符串只包含 `'0'` 到 `'9'` 的数字,以及 `'/'`, `'+'` 和 `'-'`。 \n* 输入和输出分数格式均为 `±分子/分母`。如果输入的第一个分数或者输出的分数是正数,则 `'+'` 会被省略掉。\n* 输入只包含合法的最简分数,每个分数的分子与分母的范围是  $[1,10]$。 如果分母是 $1$,意味着这个分数实际上是一个整数。\n* 输入的分数个数范围是 $[1,10]$。\n* 最终结果的分子与分母保证是 $32$ 位整数范围内的有效整数。", "solution": "### 表达式计算\n\n为了方便,令 `expression` 为 `s`。\n\n由于给定的表达式中只有 `+` 和 `-`,因此无须考虑优先级问题,直接从前往后计算即可。\n\n使用变量 `ans` 代指计算过程中的结果,从前往后处理表达式 `s`,每次以 `±分子/分母` 的形式取出当前操作数(若为表达式的首个操作数,且为正数时,需要手动补一个 `+`)。\n\n假设当前取出的操作数为 `num`,根据 `ans` 的情况进行运算:\n\n* 若 `ans` 为空串,说明 `num` 是首个操作数,直接将 `num` 赋值给 `ans` 即可\n* 若 `ans` 不为空串,此时计算 `num` 和 `ans` 的计算结果赋值给 `ans`\n\n考虑实现一个计算函数 `String calc(String a, String b)` 计算两个操作 `a` 和 `b` 的结果,其中入参 `a` 和 `b` 以及返回值均满足 `±分子/分母` 形式。\n\n首先通过读取 `a` 和 `b` 的首个字符,得到两操作数的正负情况。若为一正一负,通过交换的形式,确保 `a` 为正数,`b` 为负数。\n\n然后通过 `parse` 方法拆解出字符串操作数的分子和分母,`parse` 使用指针扫描的方式实现即可,以数组形式将结果返回(第 $0$ 位为分子数值,第 $1$ 位分母数值)。\n\n假设操作数 `a` 对应的值为 $\\frac{p[0]}{p[1]}$,操作数的值为 $\\frac{q[0]}{q[1]}$,先将其转换为 $\\frac{p[0] \\times q[1]}{p[1] \\times q[1]}$ 和 $\\frac{q[0] \\times p[1]}{q[1] \\times p[1]}$,进行运算后,再通过求最大公约数 `gcd` 的方式进行化简。\n\nJava 代码:\n```Java\nclass Solution {\n    public String fractionAddition(String s) {\n        int n = s.length();\n        char[] cs = s.toCharArray();\n        String ans = \"\";\n        for (int i = 0; i < n; ) {\n            int j = i + 1;\n            while (j < n && cs[j] != '+' && cs[j] != '-') j++;\n            String num = s.substring(i, j);\n            if (cs[i] != '+' && cs[i] != '-') num = \"+\" + num;\n            if (!ans.equals(\"\")) ans = calc(num, ans);\n            else ans = num;\n            i = j;\n        }\n        return ans.charAt(0) == '+' ? ans.substring(1) : ans;\n    }\n    String calc(String a, String b) {\n        boolean fa = a.charAt(0) == '+', fb = b.charAt(0) == '+';\n        if (!fa && fb) return calc(b, a);\n        long[] p = parse(a), q = parse(b);\n        long p1 = p[0] * q[1], q1 = q[0] * p[1];\n        if (fa && fb) {\n            long r1 = p1 + q1, r2 = p[1] * q[1], c = gcd(r1, r2);\n            return \"+\" + (r1 / c) + \"/\" + (r2 / c);\n        } else if (!fa && !fb) {\n            long r1 = p1 + q1, r2 = p[1] * q[1], c = gcd(r1, r2);\n            return \"-\" + (r1 / c) + \"/\" + (r2 / c);\n        } else {\n            long r1 = p1 - q1, r2 = p[1] * q[1], c = gcd(Math.abs(r1), r2);\n            String ans = (r1 / c) + \"/\" + (r2 / c);\n            if (p1 >= q1) ans = \"+\" + ans;\n            return ans;\n        }\n    }\n    long[] parse(String s) {\n        int n = s.length(), idx = 1;\n        while (idx < n && s.charAt(idx) != '/') idx++;\n        long a = Long.parseLong(s.substring(1, idx)), b = Long.parseLong(s.substring(idx + 1));\n        return new long[]{a, b};\n    }\n    long gcd(long a, long b) {\n        return b == 0 ? a : gcd(b, a % b);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction fractionAddition(s: string): string {\n    const n = s.length\n    let ans = \"\"\n    for (let i = 0; i < n; ) {\n        let j = i + 1\n        while (j < n && s[j] != '+' && s[j] != '-') j++\n        let num = s.substring(i, j)\n        if (s[i] != '+' && s[i] != '-') num = \"+\" + num\n        if (ans != \"\") ans = calc(num, ans)\n        else ans = num\n        i = j\n    }\n    return ans[0] == \"+\" ? ans.substring(1) : ans\n};\nfunction calc(a: string, b: string): string {\n    const fa = a[0] == \"+\", fb = b[0] == \"+\"\n    if (!fa && fb) return calc(b, a)\n    const p = parse(a), q = parse(b)\n    const p1 = p[0] * q[1], q1 = q[0] * p[1]\n    if (fa && fb) {\n        const r1 = p1 + q1, r2 = p[1] * q[1], c = gcd(r1, r2)\n        return \"+\" + (r1 / c) + \"/\" + (r2 / c)\n    } else if (!fa && !fb) {\n        const r1 = p1 + q1, r2 = p[1] * q[1], c = gcd(r1, r2)\n        return \"-\" + (r1 / c) + \"/\" + (r2 / c)\n    } else {\n        const r1 = p1 - q1, r2 = p[1] * q[1], c = gcd(Math.abs(r1), r2)\n        let ans = (r1 / c) + \"/\" + (r2 / c)\n        if (p1 > q1) ans = \"+\" + ans\n        return ans\n    }\n}\nfunction parse(s: string): number[] {\n    let n = s.length, idx = 1\n    while (idx < n && s[idx] != \"/\") idx++\n    const a = Number(s.substring(1, idx)), b = Number(s.substring(idx + 1))\n    return [a, b]\n}\nfunction gcd(a: number, b: number): number {\n    return b == 0 ? a : gcd(b, a % b)\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 加餐 & 加练\n\n**加餐一道更贴合笔试面试的「表达式计算」问题 : [双栈 : 表达式计算问题的通用解法](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492602&idx=1&sn=135fd5b530189f13e0395414a6b47893) 🎉🎉**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.592` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/591-600/593. 有效的正方形（中等）.md", "url_title": "593. 有效的正方形", "url": "https://leetcode.cn/problems/valid-square/solution/by-ac_oier-lwdf/", "difficulty": "中等", "tags": ["模拟", "数学", "计算几何"], "question": "给定 `2D` 空间中四个点的坐标 `p1`, `p2`, `p3` 和 `p4`,如果这四个点构成一个正方形,则返回 `true` 。\n\n点的坐标 `pi` 表示为 $[x_i, y_i]$ 。输入 不是 按任何顺序给出的。\n\n一个 有效的正方形 有四条等边和四个等角(`90`度角)。\n\n示例 1:\n```\n输入: p1 = [0,0], p2 = [1,1], p3 = [1,0], p4 = [0,1]\n\n输出: True\n```\n示例 2:\n```\n输入:p1 = [0,0], p2 = [1,1], p3 = [1,0], p4 = [0,12]\n\n输出:false\n```\n示例 3:\n```\n输入:p1 = [1,0], p2 = [-1,0], p3 = [0,1], p4 = [0,-1]\n\n输出:true\n```\n\n提示:\n* $p1.length == p2.length == p3.length == p4.length == 2$\n* $-10^4 <= x_i, y_i <= 10^4$", "solution": "### 计算几何\n\n根据题意进行模拟即可。\n\n从给定的 $4$ 个顶点中选 $3$ 个顶点,检查其能否形成「直角三角形」,同时保存下来首个直角三角形的直角边边长,供后续其余直角三角形进行对比(注意不能共点,即直角边长不能为 $0$)。\n\nJava 代码:\n```Java\nclass Solution {\n    long len = -1;\n    public boolean validSquare(int[] a, int[] b, int[] c, int[] d) {\n        return calc(a, b, c) && calc(a, b, d) && calc(a, c, d) && calc(b, c, d);\n    }\n    boolean calc(int[] a, int[] b, int[] c) {\n        long l1 = (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]);\n        long l2 = (a[0] - c[0]) * (a[0] - c[0]) + (a[1] - c[1]) * (a[1] - c[1]);\n        long l3 = (b[0] - c[0]) * (b[0] - c[0]) + (b[1] - c[1]) * (b[1] - c[1]);\n        boolean ok = (l1 == l2 && l1 + l2 == l3) || (l1 == l3 && l1 + l3 == l2) || (l2 == l3 && l2 + l3 == l1);\n        if (!ok) return false;\n        if (len == -1) len = Math.min(l1, l2);\n        else if (len == 0 || len != Math.min(l1, l2)) return false;\n        return true;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nlet len = -1\nfunction validSquare(a: number[], b: number[], c: number[], d: number[]): boolean {\n    len = -1\n    return calc(a, b, c) && calc(a, b, d) && calc(a, c, d) && calc(b, c, d)\n};\nfunction calc(a: number[], b: number[], c: number[]): boolean {\n    const l1 = (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1])\n    const l2 = (a[0] - c[0]) * (a[0] - c[0]) + (a[1] - c[1]) * (a[1] - c[1])\n    const l3 = (b[0] - c[0]) * (b[0] - c[0]) + (b[1] - c[1]) * (b[1] - c[1])\n    const ok = (l1 == l2 && l1 + l2 == l3) || (l1 == l3 && l1 + l3 == l2) || (l2 == l3 && l2 + l3 == l1)\n    if (!ok) return false\n    if (len == -1) len = Math.min(l1, l2)\n    else if (len == 0 || len != Math.min(l1, l2)) return false\n    return true\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.593` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/591-600/594. 最长和谐子序列（简单）.md", "url_title": "594. 最长和谐子序列", "url": "https://leetcode-cn.com/problems/longest-harmonious-subsequence/solution/gong-shui-san-xie-yi-ti-shuang-jie-hua-d-quuh/", "difficulty": "简单", "tags": ["模拟", "双指针", "滑动窗口", "哈希表"], "question": "和谐数组是指一个数组里元素的最大值和最小值之间的差别 **正好是 $1$**。\n\n现在,给你一个整数数组 $nums$ ,请你在所有可能的子序列中找到最长的和谐子序列的长度。\n\n数组的子序列是一个由数组派生出来的序列,它可以通过删除一些元素或不删除元素、且不改变其余元素的顺序而得到。\n\n示例 1:\n```\n输入:nums = [1,3,2,2,5,2,3,7]\n\n输出:5\n\n解释:最长的和谐子序列是 [3,2,2,2,3]\n```\n示例 2:\n```\n输入:nums = [1,2,3,4]\n\n输出:2\n```\n示例 3:\n```\n输入:nums = [1,1,1,1]\n\n输出:0\n```\n\n提示:\n* $1 <= nums.length <= 2 * 10^4$\n* $-10^9 <= nums[i] <= 10^9$", "solution": "### 排序 + 滑动窗口\n\n一个直观的想法是,先对 $nums$ 进行排序,然后从前往后使用「双指针」实现「滑动窗口」进行扫描,统计所有符合条件的窗口长度,并在所有长度中取最大值即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int findLHS(int[] nums) {\n        Arrays.sort(nums);\n        int n = nums.length, ans = 0;\n        for (int i = 0, j = 0; j < n; j++) {\n            while (i < j && nums[j] - nums[i] > 1) i++;\n            if (nums[j] - nums[i] == 1) ans = Math.max(ans, j - i + 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序的复杂度为 $O(n\\log{n})$,通过双指针实现的滑动窗口复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$\n\n---\n\n### 哈希计数\n\n题目规定的「和谐子序列」中的最值差值正好为 $1$,因而子序列排序后必然符合 $[a,a,..,a+1,a+1]$ 形式,即符合条件的和谐子序列长度为相邻两数(差值为 $1$) 的出现次数之和。\n\n我们可以使用「哈希表」记录所有 $nums[i]$ 的出现次数,然后通过 $O(n)$ 的复杂度找出所有可能的数对(两数差值为 $1$),并在所有符合条件的数对所能构成的「和谐子序列」长度中取最大值。\n\n代码:\n```Java\nclass Solution {\n    public int findLHS(int[] nums) {\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i : nums) map.put(i, map.getOrDefault(i, 0) + 1);\n        int ans = 0;\n        for (int i : nums) {\n            if (map.containsKey(i - 1)) {\n                ans = Math.max(ans, map.get(i) + map.get(i - 1));\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.594` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/591-600/598. 范围求和 II（简单）.md", "url_title": "598. 范围求和 II", "url": "https://leetcode-cn.com/problems/range-addition-ii/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-006h/", "difficulty": "简单", "tags": ["模拟"], "question": "给定一个初始元素全部为 $0$,大小为 $m*n$ 的矩阵 $M$ 以及在 $M$ 上的一系列更新操作。\n\n操作用二维数组表示,其中的每个操作用一个含有两个正整数 $a$ 和 $b$ 的数组表示,含义是将所有符合 $0 <= i < a$ 以及 $0 <= j < b$ 的元素 $M[i][j]$ 的值都增加 $14。\n\n在执行给定的一系列操作后,你需要返回矩阵中含有最大整数的元素个数。\n\n示例 1:\n```\n输入: \nm = 3, n = 3\noperations = [[2,2],[3,3]]\n\n输出: 4\n\n解释: \n初始状态, M = \n[[0, 0, 0],\n [0, 0, 0],\n [0, 0, 0]]\n\n执行完操作 [2,2] 后, M = \n[[1, 1, 0],\n [1, 1, 0],\n [0, 0, 0]]\n\n执行完操作 [3,3] 后, M = \n[[2, 2, 1],\n [2, 2, 1],\n [1, 1, 1]]\n\nM 中最大的整数是 2, 而且 M 中有4个值为2的元素。因此返回 4。\n```\n注意:\n* $m$ 和 $n$ 的范围是 $[1,40000]$。\n* $a$ 的范围是 $[1,m]$,$b$ 的范围是 $[1,n]$。\n* 操作数目不超过 $10000$。", "solution": "### 模拟\n\n由于每次都是对 $0 \\leq i < a$ 和 $0 \\leq j < b$ 进行操作,因此每次操作都会包含点 $(0, 0)$,最后的最大值一定出现在位置 $(0, 0)$ 上。\n\n问题转换为:什么范围内的数与位置 $(0, 0)$ 上的值相等,即什么范围会被每一次操作所覆盖。\n\n不难发现,在所有的 $ops[i]$ 中的横纵坐标 $(x, y)$ 与左上角 $(0, 0)$ 形成的区域面积可确保被每次操作覆盖,$x * y$ 即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int maxCount(int m, int n, int[][] ops) {\n        for (int[] op : ops) {\n            m = Math.min(m, op[0]);\n            n = Math.min(n, op[1]);\n        }\n        return m * n;\n    }\n}\n```\n* 时间复杂度:令 $k$ 为 $ops$ 数组的长度。复杂度为 $O(k)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.598` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/591-600/599. 两个列表的最小索引总和（简单）.md", "url_title": "599. 两个列表的最小索引总和", "url": "https://leetcode-cn.com/problems/minimum-index-sum-of-two-lists/solution/by-ac_oier-oh5b/", "difficulty": "简单", "tags": ["哈希表", "模拟"], "question": "假设 Andy 和 Doris 想在晚餐时选择一家餐厅,并且他们都有一个表示最喜爱餐厅的列表,每个餐厅的名字用字符串表示。\n\n你需要帮助他们用最少的索引和找出他们共同喜爱的餐厅。 如果答案不止一个,则输出所有答案并且不考虑顺序。 你可以假设答案总是存在。\n\n示例 1:\n```\n输入: list1 = [\"Shogun\", \"Tapioca Express\", \"Burger King\", \"KFC\"],list2 = [\"Piatti\", \"The Grill at Torrey Pines\", \"Hungry Hunter Steakhouse\", \"Shogun\"]\n\n输出: [\"Shogun\"]\n\n解释: 他们唯一共同喜爱的餐厅是“Shogun”。\n```\n示例 2:\n```\n输入:list1 = [\"Shogun\", \"Tapioca Express\", \"Burger King\", \"KFC\"],list2 = [\"KFC\", \"Shogun\", \"Burger King\"]\n\n输出: [\"Shogun\"]\n\n解释: 他们共同喜爱且具有最小索引和的餐厅是“Shogun”,它有最小的索引和1(0+1)。\n```\n\n提示:\n* $1 <= list1.length, list2.length <= 1000$\n* $1 <= list1[i].length, list2[i].length <= 30$\n* $list1[i]$ 和 $list2[i]$ 由空格 `' '` 和英文字母组成。\n* $list1$ 的所有字符串都是 唯一 的。\n* $list2$ 中的所有字符串都是 唯一 的。", "solution": "### 哈希表\n\n为了快速判断某个字符串是否在另外一个数组中出现,我们可以先使用「哈希表」对 `list1` 中的字符串进行处理,以 $(list1[i]: i)$ 键值对形式进行存储。\n\n然后遍历 `list2`,判断每个 $list2[i]$ 是否在哈希表中出现过,同时维护一个当前的 **最小索引总和** $min$,以及 **用于存储能够取得最小索引总和的字符串数组** $ans$。\n\n假设当前遍历到的元素是 $list2[i]$,根据「$list2[i]$ 是否在哈希表中出现」以及「当前索引和与 $min$ 的大小关系」分情况讨论:\n\n* 如果 $list2[i]$ 不在哈希表中,跳过:\n* 如果 $list2[i]$ 在哈希表中:\n    * 索引之和等于 $min$,将 $list2[i]$ 加入 $ans$;\n    * 索引之和小于 $min$,更新 $min$,清空 $ans$,将 $list2[i]$ 加入 $ans$;\n    * 索引之和大于 $min$,跳过。\n\n代码:\n```Java\nclass Solution {\n    public String[] findRestaurant(String[] list1, String[] list2) {\n        int n = list1.length, m = list2.length;\n        Map<String, Integer> map = new HashMap<>();\n        for (int i = 0; i < n; i++) map.put(list1[i], i);\n        List<String> ans = new ArrayList<>();\n        int min = 3000;\n        for (int i = 0; i < m; i++) {\n            String s = list2[i];\n            if (!map.containsKey(s)) continue;\n            if (i + map.get(s) < min) {\n                ans.clear();\n                min = i + map.get(s);\n                ans.add(s);\n            } else if (i + map.get(s) == min) {\n                ans.add(s);\n            }\n        }\n        return ans.toArray(new String[ans.size()]);\n    }\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 答疑\n\n评论区有位同学提出了一个挺有意思的疑问,或许是部分同学的共同疑问,这里集中答疑一下。\n\nQ0: `for` 循环里的 `ans.clear()` 这个函数也是 $O(n)$ 复杂度吧,为什么合起来还是 $O(n)$ ?\n\nA0: 在 `ArrayList` 源码中的 `clear` 实现会为了消除容器对对象的强引用,遍历容器内的内容并置空来帮助 GC。\n\n但不代表这会导致复杂度上界变成 $n^2$。\n\n不会导致复杂度退化的核心原因是:**由于 `clear` 导致的循环计算量总共必然不会超过 $n$**。因为最多只有 $n$ 个元素在 `ans` 里面,且同一元素不会被删除多次(即每个元素对 `clear` 的贡献不会超过 $1$)。\n\n如果有同学还是觉得不好理解,可以考虑一种极端情况:`clear` 操作共发生 $n$ 次,但发生 $n$ 次的前提条件是每次 `ans` 中只有 $1$ 位元素,此时由 `clear` 操作带来的额外计算量为最大值 $n$。\n\n因此这里的 `clear` 操作对复杂度影响是「累加」,而不是「累乘」,即复杂度仍为 $O(n)$,而不是 $O(n^2)$。\n\n<br/>\n\nQ1: 判断 $list[i]$ 是否在哈希中的操作,复杂度是多少?\n\nA1: 在 Java 的 `HashMap` 实现中,当键值对中的键数据类型为 `String` 时,会先计算一次(之后使用缓存)该字符串的 `HashCode`,计算 `HashCode` 的过程需要遍历字符串,因此该操作是与字符串长度相关的(对于本题字符串长度不超过 $30$),然后根据 `HashCode`「近似」$O(1)$ 定位到哈希桶位置并进行插入/更新。\n\n因此在 Java 中,该操作与「当前的字符串长度」相关,而与「当前容器所包含元素多少」无关。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.599` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/591-600/600. 不含连续1的非负整数（困难）.md", "url_title": "600. 不含连续1的非负整数", "url": "https://leetcode-cn.com/problems/non-negative-integers-without-consecutive-ones/solution/gong-shui-san-xie-jing-dian-shu-wei-dp-y-mh92/", "difficulty": "困难", "tags": ["数位 DP"], "question": "给定一个正整数 n,找出小于或等于 n 的非负整数中,其二进制表示不包含**连续的1**的个数。\n\n示例 1:\n```\n输入: 5\n\n输出: 5\n\n解释: \n下面是带有相应二进制表示的非负整数<= 5:\n0 : 0\n1 : 1\n2 : 10\n3 : 11\n4 : 100\n5 : 101\n其中,只有整数3违反规则(有两个连续的1),其他5个满足规则。\n```\n\n说明: 1 <= n <= 109", "solution": "### 数位 DP\n\n这是一道典型的「数位 DP」题。\n\n**对于「数位 DP」题,都存在「询问 $[a, b]$($a$ 和 $b$ 均为正整数,且 $a < b$)区间内符合条件的数值个数为多少」的一般形式,通常我们需要实现一个查询 $[0, x]$ 有多少合法数值的函数 `int dp(int x)`,然后应用「容斥原理」求解出 $[a, b]$ 的个数:$dp(b) - dp(a - 1)$。**\n\n对于本题,虽然只需要求解 $[0, n]$ 范围内数的个数,但其实拓展到求 $[a, b]$ 区间个数的也不会增加难度。\n\n具体的,对于「数位 DP」问题通常是「从高位到低位」的分情况讨论。\n\n不失一般性的考虑数值 $n$ 的某一位 $cur$ 是如何被处理的:\n\n1. 如果当前位 $cur = 1$ 的话,由于我们需要满足「小于等于 $n$」的要求,因此如果该位填 $0$ 的话,后面的低位填什么都是满足要求的,因此我们期望能够查表得出「长度为 $i + 1$,且二进制位置 $i$ 数值为 $0$ 时」有多少合法数值,将其累加到答案中;\n    与此同时,我们需要确保当前位选 $1$ 是合法的,即我们需要记录上一位 $prev$ 是什么,确保 $cur$ 和 $prev$ 不同时为 $1$。\n2. 如果当前位 $cur = 0$ 的话,我们只能选 $0$,并决策下一位。\n\n当出现「当前位无法填入 $cur$」或者「决策到最低位」时,则完成了所有合法答案的统计。\n\n至于流程 $1$ 中的查表操作,我们可以使用 `static` 预处理出 `f` 数组,定义 $f[i][j]$ 为考虑二进制长度为 $i$,且最高位为 $j$($0$ or $1$)时的合法数个数(值不超过)。\n\nPS. 值不超过的含义代表了不仅仅统计高位为 $j$ 的情况。例如 $f[4][1]$ 代表长度为 $4$,最高为 $1$,其包含了 1xxx 和 0xxx 的合法数的个数。\n\n> 注意:为了防止重复计数问题,我们在不失一般性的计算 $f[i][0]$ 和 $f[i][1]$ 时,既能采用诸如 $f[i][cur] += f[i - 1][prev]$ 的 “后向查找依赖” 的方式进行转移,也能采用 $f[i + 1][cur] += f[i][prev]$ “前向主动更新” 的方式进行转移。\n\n不失一般性的考虑 $f[i][0]$ 和 $f[i][1]$ 能够更新哪些状态:\n\n* 如果期望当前位填 $0$ 的话,需要统计所有满足 $(0...)_2$ 形式的合法数值,当前位的低一位只能填 $1$(填 $0$ 会出现重复计数,即需要忽略前导零的数值),此时有:$f[i + 1][0] = f[i][1]$;\n\n* 如果期望当前位填 $1$ 的话,需要统计所有满足 $(1...)_2$ 和 $(0...)_2$ 形式的合法数值:\n    * $(1...)_2$ 时,当前位的低一位只能填 $0$;此时有:$f[i + 1][1] += f[i][0]$;\n    * $(0...)_2$ 时,当前位的低一位只能填 $1$;此时有:$f[i + 1][1] += f[i][1]$。\n\n代码:\n```Java\nclass Solution {\n    static int N = 50;\n    // f[i][j] 为考虑二进制长度为 i,而且最高位为 j(0 or 1)时的合法数个数(值不超过)\n    // 如 f[2][1] 代表二进制长度为 2,且(值不超过)最高位为 1 的合法数的个数:10、01、00\n    static int[][] f = new int[N][2];\n    static {\n        f[1][0] = 1; f[1][1] = 2;\n        for (int i = 1; i < N - 1; i++) {\n            f[i + 1][0] = f[i][1];\n            f[i + 1][1] = f[i][0] + f[i][1];\n        }\n    }\n    int getLen(int n) {\n        for (int i = 31; i >= 0; i--) {\n            if (((n >> i) & 1) == 1) return i;\n        }\n        return 0;\n    }\n    public int findIntegers(int n) {\n        int len = getLen(n);\n        int ans = 0, prev = 0;\n        for (int i = len; i >= 0; i--) {\n            // 当前位是 0 还是 1\n            int cur = ((n >> i) & 1); \n            // 如果当前位是 1,那么填 0 的话,后面随便填都符合,将方案数累加\n            if (cur == 1) ans += f[i + 1][0]; \n            // 出现连续位为 1,分支结束,方案数被计算完\n            if (prev == 1 && cur == 1) break; \n            prev = cur;\n            if (i == 0) ans++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:由于我们预处理 `f` 数组的操作使用了 `static` 修饰(在跑样例数据前已经预处理完,且预处理结果被所有样例数据所共享),因此访问 `f` 数组是 $O(1)$ 的查表操作;统计答案的复杂度与二进制长度相关,复杂度为 $O(\\log{n})$。整体复杂度为 $O(\\log{n})$\n* 空间复杂度:令 $C$ 为预处理数值的大小,固定为 $50 * 2$,复杂度为 $O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.600` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/601-610/606. 根据二叉树创建字符串（简单）.md", "url_title": "606. 根据二叉树创建字符串", "url": "https://leetcode-cn.com/problems/construct-string-from-binary-tree/solution/by-ac_oier-i2sk/", "difficulty": "简单", "tags": ["二叉树", "DFS", "递归", "迭代", "栈"], "question": "你需要采用前序遍历的方式,将一个二叉树转换成一个由括号和整数组成的字符串。\n\n空节点则用一对空括号 `\"()\"` 表示。而且你需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。\n\n示例 1:\n```\n输入: 二叉树: [1,2,3,4]\n       1\n     /   \\\n    2     3\n   /    \n  4     \n\n输出: \"1(2(4))(3)\"\n\n解释: 原本将是“1(2(4)())(3())”,\n在你省略所有不必要的空括号对之后,\n它将是“1(2(4))(3)”。\n```\n示例 2:\n```\n输入: 二叉树: [1,2,3,null,4]\n       1\n     /   \\\n    2     3\n     \\  \n      4 \n\n输出: \"1(2()(4))(3)\"\n\n解释: 和第一个示例相似,\n除了我们不能省略第一个对括号来中断输入和输出之间的一对一映射关系。\n```", "solution": "### 递归 \n\n生成字符串的规则其实就是在「前序遍历」输出节点值的同时,在每颗子树的左右添加一对 `()`(根节点除外),同时需要忽略掉一些不必要的 `()` 。\n\n所谓的不必要就是指当以某个节点 $x$ 为根时,其只「有左子树」而「没有右子树」时,右子树的 `()` 可被忽略,或者「左右子树都没有」时,两者的 `()` 可被忽略。\n\n或者反过来说,如果对于每个非空节点才添加 `()` 的话,那么当「有右子树」同时「没有左子树」时,左子树的 `()` 不能被忽略,需要额外添加,从而确保生成出来的字符串能够与「有左子树」同时「没有右子树」的情况区分开来,而不会产生二义性。\n\n代码:\n```Java\nclass Solution {\n    StringBuilder sb = new StringBuilder();\n    public String tree2str(TreeNode root) {\n        dfs(root);\n        return sb.substring(1, sb.length() - 1);\n    }\n    void dfs(TreeNode root) {\n        sb.append(\"(\");\n        sb.append(root.val);\n        if (root.left != null) dfs(root.left);\n        else if (root.right != null) sb.append(\"()\");\n        if (root.right != null) dfs(root.right);\n        sb.append(\")\");        \n    }\n}\n```\n* 时间复杂度:令点数为 $n$,边数为 $m$。整体复杂度为 $O(n + m)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 迭代(非递归)\n\n自然也能使用「迭代(非递归)」来做,使用栈来模拟上述递归过程。\n\n由于当以某个节点 $x$ 为根节点时,其需要在 **开始** 前序遍历当前子树时添加 `(`,在 **结束** 前序遍历时添加 `)`,因此某个节点需要出入队两次。\n\n同时区分是首次出队(开始前序遍历)还是二次出队(结束前序遍历),这需要使用一个 `set` 来做记录,其余逻辑与「递归」做法类似。\n\n代码:\n```Java \nclass Solution {\n    public String tree2str(TreeNode root) {\n        StringBuilder sb = new StringBuilder();\n        Set<TreeNode> vis = new HashSet<>();\n        Deque<TreeNode> d = new ArrayDeque<>();\n        d.addLast(root);\n        while (!d.isEmpty()) {\n            TreeNode t = d.pollLast();\n            if (vis.contains(t)) {\n                sb.append(\")\");\n            } else {\n                d.addLast(t);\n                sb.append(\"(\");\n                sb.append(t.val);\n                if (t.right != null) d.addLast(t.right);\n                if (t.left != null) d.addLast(t.left);\n                else if (t.right != null) sb.append(\"()\");\n                vis.add(t);\n            }\n        }\n        return sb.substring(1, sb.length() - 1);\n    }\n}\n```\n* 时间复杂度:令点数为 $n$,边数为 $m$。整体复杂度为 $O(n + m)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 迭代(通用非递归)\n\n上述的「迭代(非递归)」解法,我们还是需要针对题目再做简单分析。\n\n而利用通用的「递归」转「非递归」技巧,我们可以直接对「递归」解法进行改写,同时利用通用非递归过程中的 `loc` 可以帮助我们省掉用作区分是否首次出队的 `set` 结构。\n\n需要特别说明的是:**由于现代编译器已经做了很多关于递归的优化,现在这种技巧已经无须掌握。**\n\n代码:\n```Java\nclass Solution {\n    public String tree2str(TreeNode root) {\n        StringBuilder sb = new StringBuilder();\n        Deque<Object[]> d = new ArrayDeque<>();\n        d.addLast(new Object[]{0, root});\n        while (!d.isEmpty()) {\n            Object[] poll = d.pollLast();\n            int loc = (Integer)poll[0]; TreeNode t = (TreeNode)poll[1];\n            if (loc == 0) {\n                sb.append(\"(\");\n                sb.append(t.val);\n                d.addLast(new Object[]{1, t});\n            } else if (loc == 1) {\n                d.addLast(new Object[]{2, t});\n                if (t.right != null) d.addLast(new Object[]{0, t.right});\n                if (t.left != null) d.addLast(new Object[]{0, t.left});\n                else if (t.right != null) sb.append(\"()\");\n            } else if (loc == 2) {\n                sb.append(\")\");\n            }\n        }\n        return sb.substring(1, sb.length() - 1);\n    }\n}\n```\n* 时间复杂度:令点数为 $n$,边数为 $m$。整体复杂度为 $O(n + m)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.606` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/61-70/61. 旋转链表（中等）.md", "url_title": "61. 旋转链表", "url": "https://leetcode-cn.com/problems/rotate-list/solution/kuai-man-zhi-zhen-ru-he-fen-bu-zou-jie-j-ns7u/", "difficulty": "中等", "tags": ["链表"], "question": "给你一个链表的头节点 `head`,旋转链表,将链表每个节点向右移动 `k` 个位置。\n\n示例 1:\n\n```\n输入:head = [1,2,3,4,5], k = 2\n\n输出:[4,5,1,2,3]\n```\n示例 2:\n\n```\n输入:head = [0,1,2], k = 4\n\n输出:[2,0,1]\n```\n\n提示:\n* 链表中节点的数目在范围 $[0, 500]$ 内\n* $-100 <= Node.val <= 100$\n* $0 <= k <= 2 * 10^9$", "solution": "### 快慢指针\n\n本质还是道模拟题,分步骤处理即可:\n\n* 避免不必要的旋转:与链表长度成整数倍的「旋转」都是没有意义的(旋转前后链表不变)\n* 使用「快慢指针」找到倒数第 `k` 个节点(新头结点),然后完成基本的链接与断开与断开操作\n\nJava 代码:\n```Java\nclass Solution {\n    public ListNode rotateRight(ListNode head, int k) {\n        if (head == null || k == 0) return head;\n        // 计算有效的 k 值:对于与链表长度成整数倍的「旋转」都是没有意义的(旋转前后链表不变)\n        int tot = 0;\n        ListNode tmp = head;\n        while (tmp != null && ++tot > 0) tmp = tmp.next;\n        k %= tot;\n        if (k == 0) return head;\n        // 使用「快慢指针」找到倒数第 k 个节点(新头结点):slow 会停在「新头结点」的「前一位」,也就是「新尾结点」\n        ListNode slow = head, fast = head;\n        while (k-- > 0) fast = fast.next;\n        while (fast.next != null) {\n            slow = slow.next;\n            fast = fast.next;\n        }\n        // 保存新头结点,并将新尾结点的 next 指针置空\n        ListNode nHead = slow.next;\n        slow.next = null;\n        // 将新链表的前半部分(原链表的后半部分)与原链表的头结点链接上\n        fast.next = head;\n        return nHead;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    ListNode* rotateRight(ListNode* head, int k) {\n        if (head == NULL || k == 0) return head;\n        // 计算有效的 k 值:对于与链表长度成整数倍的「旋转」都是没有意义的(旋转前后链表不变)\n        int tot = 0;\n        ListNode* tmp = head;\n        while (tmp != NULL && ++tot > 0) tmp = tmp->next;\n        k %= tot;\n        // 使用「快慢指针」找到倒数第 k 个节点(新头结点):slow 会停在「新头结点」的「前一位」,也就是「新尾结点」\n        if (k == 0) return head;\n        // 使用快慢指针找到倒数第 k 个节点\n        ListNode* slow = head;\n        ListNode* fast = head;\n        while (k-- > 0) fast = fast->next;\n        while (fast->next != NULL) {\n            slow = slow->next;\n            fast = fast->next;\n        }\n        // 保存新头结点,并将新尾结点的 next 指针置空\n        ListNode* nHead = slow->next;\n        slow->next = NULL;\n        // 将新链表的前半部分(原链表的后半部分)与原链表的头结点链接上\n        fast->next = head;\n        return nHead;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:\n        if not head or k == 0: return head\n        # 计算有效的 k 值:对于与链表长度成整数倍的「旋转」都是没有意义的(旋转前后链表不变)\n        tot, tmp = 0, head\n        while tmp:\n            tmp = tmp.next\n            tot += 1\n        k %= tot\n        # 使用「快慢指针」找到倒数第 k 个节点(新头结点):slow 会停在「新头结点」的「前一位」,也就是「新尾结点」\n        if k == 0: return head\n        # 使用快慢指针找到倒数第 k 个节点\n        slow, fast = head, head\n        while k > 0:\n            fast = fast.next\n            k -= 1\n        while fast.next:\n            slow = slow.next\n            fast = fast.next\n        # 保存新头结点,并将新尾结点的 next 指针置空\n        nHead = slow.next\n        slow.next = None\n        # 将新链表的前半部分(原链表的后半部分)与原链表的头结点链接上\n        fast.next = head\n        return nHead\n```\nTypeScript 代码:\n```TypeScript\nfunction rotateRight(head: ListNode | null, k: number): ListNode | null {\n    if (head == null || k == 0) return head;\n    // 计算有效的 k 值:对于与链表长度成整数倍的「旋转」都是没有意义的(旋转前后链表不变)\n    let tot = 0, tmp = head;\n    while (tmp !== null && ++tot > 0) tmp = tmp.next;\n    k %= tot;\n    // 使用「快慢指针」找到倒数第 k 个节点(新头结点):slow 会停在「新头结点」的「前一位」,也就是「新尾结点」\n    if (k == 0) return head;\n    // 使用快慢指针找到倒数第 k 个节点\n    let slow = head, fast = head;\n    while (k-- > 0) fast = fast.next;\n    while (fast.next !== null) {\n        slow = slow.next;\n        fast = fast.next;\n    }\n    // 保存新头结点,并将新尾结点的 next 指针置空\n    let nHead = slow.next;\n    slow.next = null;\n    // 将新链表的前半部分(原链表的后半部分)与原链表的头结点链接上\n    fast.next = head;\n    return nHead;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 闭合成环\n\n另外一个做法是,先成环,再断开:\n\n* 找到原链表的最后一个节点,将其与原链表的头结点相连(成环),并统计链表长度,更新有效 `k` 值\n* 从原链表的头节点出发,找到需要断开的点,进行断开\n\nJava 代码:\n```java\nclass Solution {\n    public ListNode rotateRight(ListNode head, int k) {\n        if (head == null || k == 0) return head;\n        // 先将链表成环,并记录链表的长度\n        // tmp 会记录住原链表最后一位节点\n        int tot = 1;\n        ListNode tmp = head;\n        while (tmp.next != null && ++tot > 0) tmp = tmp.next;\n        k %= tot;\n        if (k == 0) return head;\n        // 正式成环\n        tmp.next = head;\n        // 从原链表 head 出发,走 tot - k - 1 步,找到「新尾结点」进行断开,并将其下一个节点作为新节点返回\n        k = tot - k - 1;\n        while (k-- > 0) head = head.next;\n        ListNode nHead = head.next;\n        head.next = null;\n        return nHead;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    ListNode* rotateRight(ListNode* head, int k) {\n        if (head == NULL || k == 0) return head;\n        // 先将链表成环,并记录链表的长度\n        // tmp 会记录住原链表最后一位节点\n        int tot = 1;\n        ListNode* tmp = head;\n        while (tmp->next != NULL && ++tot > 0) tmp = tmp->next;\n        k %= tot;\n        if (k == 0) return head;\n        // 正式成环\n        tmp->next = head;\n        // 从原链表 head 出发,走 tot - k - 1 步,找到「新尾结点」进行断开,并将其下一个节点作为新节点返回\n        k = tot - k - 1;\n        while (k-- > 0) head = head->next;\n        ListNode* nHead = head->next;\n        head->next = NULL;\n        return nHead;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:\n        if not head or k == 0: return head\n        # 先将链表成环,并记录链表的长度\n        # tmp 会记录住原链表最后一位节点\n        tot, tmp = 1, head\n        while tmp.next:\n            tmp = tmp.next\n            tot += 1\n        k %= tot\n        if k == 0: return head\n        # 正式成环\n        tmp.next = head\n        # 从原链表 head 出发,走 tot - k - 1 步,找到「新尾结点」进行断开,并将其下一个节点作为新节点返回\n        k = tot - k - 1\n        while k > 0:\n            head = head.next\n            k -= 1\n        nHead = head.next\n        head.next = None\n        return nHead\n```\nTypeScript 代码:\n```TypeScript\nfunction rotateRight(head: ListNode | null, k: number): ListNode | null {\n    if (head == null || k == 0) return head;\n    // 先将链表成环,并记录链表的长度\n    // tmp 会记录住原链表最后一位节点\n    let tot = 1, tmp = head;\n    while (tmp.next !== null && ++tot > 0) tmp = tmp.next;\n    k %= tot;\n    if (k == 0) return head;\n    // 正式成环\n    tmp.next = head;\n    k = tot - k - 1;\n    while (k-- > 0) head = head.next;\n    let nHead = head.next;\n    head.next = null;\n    return nHead;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.61` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/61-70/65. 有效数字（困难）.md", "url_title": "65. 有效数字", "url": "https://leetcode-cn.com/problems/valid-number/solution/gong-shui-san-xie-zi-fu-chuan-mo-ni-by-a-7cgc/", "difficulty": "困难", "tags": ["模拟"], "question": "有效数字(按顺序)可以分成以下几个部分:\n\n1. 一个 小数 或者 整数\n2. (可选)一个 `'e'` 或 `'E'` ,后面跟着一个 整数\n\n小数(按顺序)可以分成以下几个部分:\n\n1. (可选)一个符号字符(`'+'` 或 `'-'`)\n2. 下述格式之一:\n\t1. 至少一位数字,后面跟着一个点 `'.'`\n\t2. 至少一位数字,后面跟着一个点 `'.'` ,后面再跟着至少一位数字\n\t3. 一个点 `'.'` ,后面跟着至少一位数字\n\n整数(按顺序)可以分成以下几个部分:\n\n1. (可选)一个符号字符(`'+'` 或 `'-'`)\n2. 至少一位数字\n\n部分有效数字列举如下:\n\n* `[\"2\", \"0089\", \"-0.1\", \"+3.14\", \"4.\", \"-.9\", \"2e10\", \"-90E3\", \"3e+7\", \"+6e-1\", \"53.5e93\", \"-123.456e789\"]`\n\n部分无效数字列举如下:\n\n* `[\"abc\", \"1a\", \"1e\", \"e3\", \"99e2.5\", \"--6\", \"-+3\", \"95a54e53\"]`\n\n给你一个字符串 `s`,如果 `s` 是一个 有效数字 ,请返回 `true`。\n\n示例 1:\n```\n输入:s = \"0\"\n\n输出:true\n```\n示例 2:\n```\n输入:s = \"e\"\n\n输出:false\n```\n示例 3:\n```\n输入:s = \".\"\n\n输出:false\n```\n示例 4:\n```\n输入:s = \".1\"\n\n输出:true\n```\n\n提示:\n* $1 <= s.length <= 20$\n* `s` 仅含英文字母(大写和小写),数字(`0-9`),加号 `'+'` ,减号 `'-'` ,或者点 `'.'` 。", "solution": "### 模拟\n\n字符串大模拟,根据「有效数字定义」梳理规则即可。\n\n本题有多种解法:「正则」、「DFA」、「模拟」...\n\n**「模拟」是在各类场景中最容易实现的方式,只要头脑不发热都能写出来。**\n\n将字符串以 `e/E` 进行分割后,其实规则十分简单:\n\n* 如果存在 `e/E` :左侧可以「整数」或「浮点数」,右侧必须是「整数」\n* 如果不存在 `e/E` :整段可以是「整数」或「浮点数」\n\n关键在于如何实现一个 `check` 函数用于判断「整数」或「浮点数」:\n\n* `+/-` 只能出现在头部\n* `.` 最多出现一次\n* 至少存在一个数字\n\n代码:\n```Java\nclass Solution {\n    public boolean isNumber(String s) {\n        int n = s.length();\n        char[] cs = s.toCharArray();\n        int idx = -1;\n        for (int i = 0; i < n; i++) {\n            if (cs[i] == 'e' || cs[i] == 'E') {\n                if (idx == -1) idx = i;\n                else return false;\n            }\n        }\n        boolean ans = true;\n        if (idx != -1) {\n            ans &= check(cs, 0, idx - 1, false);\n            ans &= check(cs, idx + 1, n - 1, true);\n        } else {\n            ans &= check(cs, 0, n - 1, false);\n        }\n        return ans;\n    }\n    boolean check(char[] cs, int start, int end, boolean mustInteger) {\n        if (start > end) return false;\n        if (cs[start] == '+' || cs[start] == '-') start++;\n        boolean hasDot = false, hasNum = false;\n        for (int i = start; i <= end; i++) {\n            if (cs[i] == '.') {\n                if (mustInteger || hasDot) return false;\n                hasDot = true;\n            } else if (cs[i] >= '0' && cs[i] <= '9') {\n                hasNum = true;\n            } else {\n                return false;\n            }\n        }\n        return hasNum;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:将 `toCharArray` 替换为 `charAt` 为 $O(1)$,否则为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.65` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/61-70/66. 加一（简单）.md", "url_title": "66. 加一", "url": "https://leetcode-cn.com/problems/plus-one/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-5av1/", "difficulty": "简单", "tags": ["模拟"], "question": "给定一个由 整数 组成的 非空 数组所表示的非负整数,在该数的基础上加一。\n\n最高位数字存放在数组的首位, 数组中每个元素只存储单个数字。\n\n你可以假设除了整数 0 之外,这个整数不会以零开头。\n\n示例 1:\n```\n输入:digits = [1,2,3]\n\n输出:[1,2,4]\n\n解释:输入数组表示数字 123。\n```\n示例 2:\n```\n输入:digits = [4,3,2,1]\n\n输出:[4,3,2,2]\n\n解释:输入数组表示数字 4321。\n```\n\n示例 3:\n```\n输入:digits = [0]\n\n输出:[1]\n```\n\n提示:\n* 1 <= digits.length <= 100\n* 0 <= digits[i] <= 9", "solution": "### 模拟\n\n这是 [2. 两数相加](https://leetcode-cn.com/problems/add-two-numbers/solution/po-su-jie-fa-shao-bing-ji-qiao-by-ac_oie-etln/) 的简化版,其中一个操作固定为 $1$。\n\n只需要按照题目进行模拟即可,使用 $t$ 记录进位。\n\n代码:\n```Java\nclass Solution {\n    public int[] plusOne(int[] digits) {\n        int n = digits.length;\n        digits[n - 1]++;\n        List<Integer> list = new ArrayList<>();\n        for (int i = n - 1, t = 0; i >= 0 || t != 0; i--) {\n            int x = i >= 0 ? digits[i] + t : t;\n            list.add(x % 10);\n            t = x / 10;\n        }\n        Collections.reverse(list);\n        int[] ans = new int[list.size()];\n        for (int i = 0; i < list.size(); i++) ans[i] = list.get(i);\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.66` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/61-70/68. 文本左右对齐（困难）.md", "url_title": "68. 文本左右对齐", "url": "https://leetcode-cn.com/problems/text-justification/solution/gong-shui-san-xie-zi-fu-chuan-mo-ni-by-a-s3v7/", "difficulty": "困难", "tags": ["模拟", "字符串"], "question": "给定一个单词数组和一个长度 `maxWidth`,重新排版单词,使其成为每行恰好有 `maxWidth` 个字符,且左右两端对齐的文本。\n\n你应该使用“贪心算法”来放置给定的单词;也就是说,尽可能多地往每行中放置单词。必要时可用空格 ' ' 填充,使得每行恰好有 `maxWidth` 个字符。\n\n要求尽可能均匀分配单词间的空格数量。如果某一行单词间的空格不能均匀分配,则左侧放置的空格数要多于右侧的空格数。\n\n文本的最后一行应为左对齐,且单词之间不插入额外的空格。\n\n说明:\n* 单词是指由非空格字符组成的字符序列\n* 每个单词的长度大于 $0$,小于等于 `maxWidth`\n* 输入单词数组 `words` 至少包含一个单词\n\n示例:\n\n```\n输入:\nwords = [\"This\", \"is\", \"an\", \"example\", \"of\", \"text\", \"justification.\"]\nmaxWidth = 16\n\n输出:\n[\n   \"This    is    an\",\n   \"example  of text\",\n   \"justification.  \"\n]\n```\n示例 2:\n```\n输入:\nwords = [\"What\",\"must\",\"be\",\"acknowledgment\",\"shall\",\"be\"]\n\nmaxWidth = 16\n\n输出:\n[\n  \"What   must   be\",\n  \"acknowledgment  \",\n  \"shall be        \"\n]\n\n解释: 注意最后一行的格式应为 \"shall be    \" 而不是 \"shall     be\",\n     因为最后一行应为左对齐,而不是左右两端对齐。       \n     第二行同样为左对齐,这是因为这行只包含一个单词。\n```\n示例 3:\n```\n输入:\nwords = [\"Science\",\"is\",\"what\",\"we\",\"understand\",\"well\",\"enough\",\"to\",\"explain\",\n         \"to\",\"a\",\"computer.\",\"Art\",\"is\",\"everything\",\"else\",\"we\",\"do\"]\nmaxWidth = 20\n\n输出:\n[\n  \"Science  is  what we\",\n  \"understand      well\",\n  \"enough to explain to\",\n  \"a  computer.  Art is\",\n  \"everything  else  we\",\n  \"do                  \"\n]\n```", "solution": "### 模拟\n\n字符串大模拟,分情况讨论即可:\n\n1. 如果当前行只有一个单词,特殊处理为左对齐;\n2. 如果当前行为最后一行,特殊处理为左对齐;\n3. 其余为一般情况,分别计算「当前行单词总长度」、「当前行空格总长度」和「往下取整后的单位空格长度」,然后依次进行拼接。当空格无法均分时,每次往靠左的间隙多添加一个空格,直到剩余的空格能够被后面的间隙所均分。\n\n代码:\n```Java\nclass Solution {\n    public List<String> fullJustify(String[] words, int maxWidth) {\n        List<String> ans = new ArrayList<>();\n        int n = words.length;\n        List<String> list = new ArrayList<>();\n        for (int i = 0; i < n; ) {\n            // list 装载当前行的所有 word\n            list.clear();\n            list.add(words[i]);\n            int cur = words[i++].length();\n            while (i < n && cur + 1 + words[i].length() <= maxWidth) {\n                cur += 1 + words[i].length();\n                list.add(words[i++]);\n            }\n\n            // 当前行为最后一行,特殊处理为左对齐\n            if (i == n) {\n                StringBuilder sb = new StringBuilder(list.get(0));\n                for (int k = 1; k < list.size(); k++) {\n                    sb.append(\" \").append(list.get(k));\n                }\n                while (sb.length() < maxWidth) sb.append(\" \");\n                ans.add(sb.toString());\n                break;\n            }\n\n            // 如果当前行只有一个 word,特殊处理为左对齐\n            int cnt = list.size();\n            if (cnt == 1) {\n                String str = list.get(0);\n                while (str.length() != maxWidth) str += \" \";\n                ans.add(str);\n                continue;\n            }\n\n            /**\n            * 其余为一般情况\n            * wordWidth : 当前行单词总长度;\n            * spaceWidth : 当前行空格总长度;\n            * spaceItem : 往下取整后的单位空格长度\n            */\n            int wordWidth = cur - (cnt - 1);\n            int spaceWidth = maxWidth - wordWidth;\n            int spaceItemWidth = spaceWidth / (cnt - 1);\n            String spaceItem = \"\";\n            for (int k = 0; k < spaceItemWidth; k++) spaceItem += \" \";\n            StringBuilder sb = new StringBuilder();\n            for (int k = 0, sum = 0; k < cnt; k++) {\n                String item = list.get(k);\n                sb.append(item);\n                if (k == cnt - 1) break;\n                sb.append(spaceItem);\n                sum += spaceItemWidth;\n                // 剩余的间隙数量(可填入空格的次数)\n                int remain = cnt - k - 1 - 1;\n                // 剩余间隙数量 * 最小单位空格长度 + 当前空格长度 < 单词总长度,则在当前间隙多补充一个空格\n                if (remain * spaceItemWidth + sum < spaceWidth) {\n                    sb.append(\" \");\n                    sum++;\n                }\n            }\n            ans.add(sb.toString());\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:会对 $words$ 做线性扫描,最坏情况下每个 $words[i]$ 独占一行,此时所有字符串的长度为 $n * maxWidth$。复杂度为 $O(n * maxWidth)$\n* 空间复杂度:最坏情况下每个 $words[i]$ 独占一行,复杂度为 $O(n * maxWidth)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.68` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/611-620/611. 有效三角形的个数（中等）.md", "url_title": "611. 有效三角形的个数", "url": "https://leetcode-cn.com/problems/valid-triangle-number/solution/gong-shui-san-xie-yi-ti-san-jie-jian-dan-y1we/", "difficulty": "中等", "tags": ["排序", "二分", "双指针"], "question": "给定一个包含非负整数的数组,你的任务是统计其中可以组成三角形三条边的三元组个数。\n\n示例 1:\n```\n输入: [2,2,3,4]\n\n输出: 3\n\n解释:\n有效的组合是: \n2,3,4 (使用第一个 2)\n2,3,4 (使用第二个 2)\n2,2,3\n```\n注意:\n1. 数组长度不超过 $1000$。\n2. 数组里整数的范围为 $[0, 1000]$。", "solution": "### 基本分析\n\n**根据题意,是要我们统计所有符合 $nums[k] + nums[j] > nums[i]$ 条件的三元组 $(k,j,i)$ 的个数。**\n\n为了防止统计重复的三元组,我们可以先对数组进行排序,然后采取「先枚举较大数;在下标不超过较大数下标范围内,找次大数;在下标不超过次大数下标范围内,找较小数」的策略。\n\n---\n\n### 排序 + 暴力枚举\n\n根据「基本分析」,我们可以很容易写出「排序 + 三层循环」的实现。\n\n代码:\n```Java\nclass Solution {\n    public int triangleNumber(int[] nums) {\n        int n = nums.length;\n        Arrays.sort(nums);\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            for (int j = i - 1; j >= 0; j--) {\n                for (int k = j - 1; k >= 0; k--) {\n                    if (nums[j] + nums[k] > nums[i]) ans++;\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序时间复杂度为 $O(n\\log{n})$;三层遍历找所有三元祖的复杂度为 $O(n^3)$。整体复杂度为 $O(n^3)$\n* 空间复杂度:$O(\\log{n})$\n\n---\n\n### 排序 + 二分\n\n根据我们以前讲过的的 [优化枚举的基本思路](https://leetcode-cn.com/problems/number-of-submatrices-that-sum-to-target/solution/gong-shui-san-xie-you-hua-mei-ju-de-ji-b-uttw/),要找符合条件的三元组,其中一个切入点可以是「枚举三元组中的两个值,然后优化找第三数的逻辑」。\n\n我们发现,在数组有序的前提下,**当枚举到较大数下标 $i$ 和次大数下标 $j$ 时,在 $[0, j)$ 范围内找的符合 $nums[k'] + nums[j] > nums[i]$ 条件的 $k'$ 的集合时,以符合条件的最小下标 $k$ 为分割点的数轴上具有「二段性」。**\n\n令 $k$ 为符合条件的最小下标,那么在 $nums[i]$ 和 $nums[j]$ 固定时,$[0,j)$ 范围内:\n\n* 下标大于等于 $k$ 的点集符合条件 $nums[k'] + nums[j] > nums[i]$;\n* 下标小于 $k$ 的点集合不符合条件 $nums[k'] + nums[j] > nums[i]$。\n\n因此我们可以通过「二分」找到这个分割点 $k$,在 $[k,j)$ 范围内即是固定 $j$ 和 $i$ 时,符合条件的 $k'$ 的个数。\n\n代码:\n```Java\nclass Solution {\n    public int triangleNumber(int[] nums) {\n        int n = nums.length;\n        Arrays.sort(nums);\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            for (int j = i - 1; j >= 0; j--) {\n                int l = 0, r = j - 1;\n                while (l < r) {\n                    int mid = l + r >> 1;\n                    if (nums[mid] + nums[j] > nums[i]) r = mid;\n                    else l = mid + 1;\n                }\n                if (l == r && nums[r] + nums[j] > nums[i]) ans += j - r;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序时间复杂度为 $O(n\\log{n})$;两层遍历加二分所有符合条件的三元组的复杂度为 $O(n^2*\\log{n})$。整体复杂度为 $O(n^2*\\log{n})$\n* 空间复杂度:$O(\\log{n})$\n\n---\n\n### 排序 + 双指针\n\n更进一步我们发现,当我们在枚举较大数下标 $i$,并在 $[0, i)$ 范围内逐步减小下标(由于数组有序,也就是逐步减少值)找次大值下标 $j$ 时,符合条件的 $k'$ 必然是从 $0$ 逐步递增(这是由三角不等式 $nums[k] + nums[j] > nums[i]$ 所决定的)。\n\n因此,我们可以枚举较大数下标 $i$ 时,在 $[0, i)$ 范围内通过双指针,以逐步减少下标的方式枚举 $j$,并在遇到不满足条件的 $k$ 时,增大 $k$ 下标。从而找到所有符合条件三元组的个数。\n\n代码:\n```Java\nclass Solution {\n    public int triangleNumber(int[] nums) {\n        int n = nums.length;\n        Arrays.sort(nums);\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            for (int j = i - 1, k = 0; k < j; j--) {\n                while (k < j && nums[k] + nums[j] <= nums[i]) k++;\n                ans += j - k;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序时间复杂度为 $O(n\\log{n})$,双指针找所有符合条件的三元组的复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.611` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/621-630/621. 任务调度器（中等）.md", "url_title": "621. 任务调度器", "url": "https://leetcode.cn/problems/task-scheduler/solution/by-ac_oier-3560/", "difficulty": "中等", "tags": ["构造", "脑筋急转弯"], "question": "给你一个用字符数组 `tasks` 表示的 `CPU` 需要执行的任务列表,其中每个字母表示一种不同种类的任务。\n\n任务可以以任意顺序执行,并且每个任务都可以在 `1` 个单位时间内执行完。\n\n在任何一个单位时间,`CPU` 可以完成一个任务,或者处于待命状态。\n\n然而,两个相同种类的任务之间必须有长度为整数 `n` 的冷却时间,因此至少有连续 `n` 个单位时间内 `CPU` 在执行不同的任务,或者在待命状态。\n\n你需要计算完成所有任务所需要的最短时间。\n\n示例 1:\n```\n输入:tasks = [\"A\",\"A\",\"A\",\"B\",\"B\",\"B\"], n = 2\n\n输出:8\n\n解释:A -> B -> (待命) -> A -> B -> (待命) -> A -> B\n     在本示例中,两个相同类型任务之间必须间隔长度为 n = 2 的冷却时间,而执行一个任务只需要一个单位时间,所以中间出现了(待命)状态。 \n```\n示例 2:\n```\n输入:tasks = [\"A\",\"A\",\"A\",\"B\",\"B\",\"B\"], n = 0\n\n输出:6\n\n解释:在这种情况下,任何大小为 6 的排列都可以满足要求,因为 n = 0\n[\"A\",\"A\",\"A\",\"B\",\"B\",\"B\"]\n[\"A\",\"B\",\"A\",\"B\",\"A\",\"B\"]\n[\"B\",\"B\",\"B\",\"A\",\"A\",\"A\"]\n...\n诸如此类\n```\n示例 3:\n```\n输入:tasks = [\"A\",\"A\",\"A\",\"A\",\"A\",\"A\",\"B\",\"C\",\"D\",\"E\",\"F\",\"G\"], n = 2\n\n输出:16\n\n解释:一种可能的解决方案是:\n     A -> B -> C -> A -> D -> E -> A -> F -> G -> A -> (待命) -> (待命) -> A -> (待命) -> (待命) -> A\n```\n\n提示:\n* $1 <= task.length <= 10^4$\n* `tasks[i]` 是大写英文字母\n* `n` 的取值范围为 $[0, 100]$", "solution": "### 构造\n\n先考虑最为简单的情况:假设只有一类任务,除了最后一个任务以外,其余任务在安排后均需要增加 $n$ 个单位的冻结时间。\n\n将任务数记为 $m$ 个,其中前 $m - 1$ 个任务均要消耗 $n + 1$ 的单位时间,最后一个任务仅消耗 $1$ 个单位时间,即所需要的时间为 $(n + 1) \\times (m - 1) + 1$。\n\n**当存在多个任务时,由于每一类任务都需要被完成,因此本质上我们最需要考虑的是将数量最大的任务安排掉,其他任务则是间插其中。**\n\n假设数量最大的任务数为 `max`,共有 `tot` 个任务数为 `max` 的任务种类。\n\n实际上,当任务总数不超过 $(n + 1) \\times (\\max - 1) + tot$ 时,我们总能将其他任务插到空闲时间中去,不会引入额外的冻结时间(下左图);而当任务数超过该值时,我们可以在将其横向添加每个 $n + 1$ 块的后面,同时不会引入额外的冻结时间(下右图):\n\n综上,我们所需要的最小时间为上述两种情况中的较大值即可:\n\n$$\n\\max(task.length, (n + 1) \\times (max - 1) + tot)\n$$\n\nJava 代码:\n```Java\nclass Solution {\n    public int leastInterval(char[] tasks, int n) {\n        int[] cnts = new int[26];\n        for (char c : tasks) cnts[c - 'A']++;\n        int max = 0, tot = 0;\n        for (int i = 0; i < 26; i++) max = Math.max(max, cnts[i]);\n        for (int i = 0; i < 26; i++) tot += max == cnts[i] ? 1 : 0;\n        return Math.max(tasks.length, (n + 1) * (max - 1) + tot);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int leastInterval(vector<char>& tasks, int n) {\n        vector<int> cnts(26, 0);\n        for (char c : tasks) cnts[c - 'A']++;\n        int maxv = *max_element(cnts.begin(), cnts.end());\n        int tot = count(cnts.begin(), cnts.end(), maxv);\n        return max(static_cast<int>(tasks.size()), (n + 1) * (maxv - 1) + tot);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def leastInterval(self, tasks: List[str], n: int) -> int:\n        cnts = [0] * 26\n        for c in tasks:\n            cnts[ord(c) - ord('A')] += 1\n        maxv, tot = 0, 0\n        for i in range(26):\n            maxv = max(maxv, cnts[i])\n        for i in range(26):\n            tot += 1 if maxv == cnts[i] else 0\n        return max(len(tasks), (n + 1) * (maxv - 1) + tot)\n```\nTypeScript 代码:\n```TypeScript\nfunction leastInterval(tasks: string[], n: number): number {\n    const cnts = new Array<number>(26).fill(0)\n    for (const c of tasks) cnts[c.charCodeAt(0) - 'A'.charCodeAt(0)]++\n    let max = 0, tot = 0\n    for (let i = 0; i < 26; i++) max = Math.max(max, cnts[i])\n    for (let i = 0; i < 26; i++) tot += max == cnts[i] ? 1 : 0\n    return Math.max(tasks.length, (n + 1) * (max - 1) + tot)\n}\n```\n* 时间复杂度:$O(n + C)$\n* 空间复杂度:$O(C)$,其中 $C = 26$ 为任务字符集大小", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.621` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/621-630/622. 设计循环队列（中等）.md", "url_title": "622. 设计循环队列", "url": "https://leetcode.cn/problems/design-circular-queue/solution/by-ac_oier-y11p/", "difficulty": "中等", "tags": ["设计数据结构", "队列"], "question": "设计你的循环队列实现。 循环队列是一种线性数据结构,其操作表现基于 `FIFO`(先进先出)原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。\n\n循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里,一旦一个队列满了,我们就不能插入下一个元素,即使在队列前面仍有空间。但是使用循环队列,我们能使用这些空间去存储新的值。\n\n你的实现应该支持如下操作:\n\n* `MyCircularQueue(k)`: 构造器,设置队列长度为 $k$ 。\n* `Front`: 从队首获取元素。如果队列为空,返回 $-1$ 。\n* `Rear`: 获取队尾元素。如果队列为空,返回 $-1$ 。\n* `enQueue(value)`: 向循环队列插入一个元素。如果成功插入则返回真。\n* `deQueue()`: 从循环队列中删除一个元素。如果成功删除则返回真。\n* `isEmpty()`: 检查循环队列是否为空。\n* `isFull()`: 检查循环队列是否已满。\n\n示例:\n```\nMyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3\ncircularQueue.enQueue(1);  // 返回 true\ncircularQueue.enQueue(2);  // 返回 true\ncircularQueue.enQueue(3);  // 返回 true\ncircularQueue.enQueue(4);  // 返回 false,队列已满\ncircularQueue.Rear();  // 返回 3\ncircularQueue.isFull();  // 返回 true\ncircularQueue.deQueue();  // 返回 true\ncircularQueue.enQueue(4);  // 返回 true\ncircularQueue.Rear();  // 返回 4\n```\n\n提示:\n* 所有的值都在 $0$ 至 $1000$ 的范围内;\n* 操作数将在 $1$ 至 $1000$ 的范围内;\n* 请不要使用内置的队列库。", "solution": "### 数据结构\n\n创建一个长度为 $k$ 的数组充当循环队列,使用两个变量 `he` 和 `ta` 来充当队列头和队列尾(起始均为 $0$),整个过程 `he` 始终指向队列头部,`ta` 始终指向队列尾部的下一位置(待插入元素位置)。\n\n两变量始终自增,通过与 $k$ 取模来确定实际位置。\n\n分析各类操作的基本逻辑:\n* `isEmpty` 操作:当 `he` 和 `ta` 相等,队列存入元素和取出元素的次数相同,此时队列为空;\n* `isFull` 操作:`ta - he` 即队列元素个数,当元素个数为 $k$ 个时,队列已满;\n* `enQueue` 操作:若队列已满,返回 $-1$,否则在 `nums[ta % k]` 位置存入目标值,并将 `ta` 指针后移;\n* `deQueue` 操作:若队列为空,返回 $-1$,否则将 `he` 指针后移,含义为弹出队列头部元素;\n* `Front` 操作:若队列为空,返回 $-1$,否则返回 `nums[he % k]` 队头元素;\n* `Rear` 操作:若队列为空,返回 $-1$,否则返回 `nums[(ta - 1) % k]` 队尾元素;\n\nJava 代码:\n```Java\nclass MyCircularQueue {\n    int k, he, ta;\n    int[] nums;\n    public MyCircularQueue(int _k) {\n        k = _k;\n        nums = new int[k];\n    }\n    public boolean enQueue(int value) {\n        if (isFull()) return false;\n        nums[ta % k] = value;\n        return ++ta >= 0;\n    }\n    public boolean deQueue() {\n        if (isEmpty()) return false;\n        return ++he >= 0;\n    }\n    public int Front() {\n        return isEmpty() ? -1 : nums[he % k];\n    }\n    public int Rear() {\n        return isEmpty() ? -1 : nums[(ta - 1) % k];\n    }\n    public boolean isEmpty() {\n        return he == ta;\n    }\n    public boolean isFull() {\n        return ta - he == k;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nclass MyCircularQueue {\n    k: number = 0; he: number = 0; ta: number = 0;\n    nums: number[];\n    constructor(k: number) {\n        this.k = k\n        this.nums = new Array<number>(this.k)\n    }\n    enQueue(value: number): boolean {\n        if (this.isFull()) return false\n        this.nums[this.ta % this.k] = value\n        return this.ta++ >= 0\n    }\n    deQueue(): boolean {\n        if (this.isEmpty()) return false\n        return this.he++ >= 0\n    }\n    Front(): number {\n        return this.isEmpty() ? -1 : this.nums[this.he % this.k]\n    }\n    Rear(): number {\n        return this.isEmpty() ? -1 : this.nums[(this.ta - 1) % this.k]\n    }\n    isEmpty(): boolean {\n        return this.he == this.ta\n    }\n    isFull(): boolean {\n        return this.ta - this.he == this.k\n    }\n}\n```\n* 时间复杂度:构造函数复杂度为 $O(k)$,其余操作复杂度为 $O(1)$\n* 空间复杂度:$O(k)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.622` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/621-630/623. 在二叉树中增加一行（中等）.md", "url_title": "623. 在二叉树中增加一行", "url": "https://leetcode.cn/problems/add-one-row-to-tree/solution/by-ac_oier-sc34/", "difficulty": "中等", "tags": ["二叉树", "BFS", "DFS"], "question": "给定一个二叉树的根 `root` 和两个整数 `val` 和 `depth`,在给定的深度 `depth` 处添加一个值为 `val` 的节点行。\n\n注意,根节点 `root` 位于深度 $1$ 。\n\n加法规则如下:\n\n* 给定整数 `depth`,对于深度为 `depth - 1` 的每个非空树节点 `cur`,创建两个值为 `val` 的树节点作为 `cur` 的左子树根和右子树根。\n* `cur` 原来的左子树应该是新的左子树根的左子树。\n* `cur` 原来的右子树应该是新的右子树根的右子树。\n* 如果 `depth == 1` 意味着 `depth - 1` 根本没有深度,那么创建一个树节点,值 `val` 作为整个原始树的新根,而原始树就是新根的左子树。\n\n示例 1:\n\n```\n输入: root = [4,2,6,3,1,5], val = 1, depth = 2\n\n输出: [4,1,1,2,null,null,6,3,1,5]\n```\n示例 2:\n\n```\n输入: root = [4,2,null,3,1], val = 1, depth = 3\n\n输出:  [4,2,null,1,1,3,null,null,1]\n```\n\n提示:\n* 节点数在 $[1, 10^4]$ 范围内\n* 树的深度在 $[1, 10^4]$范围内\n* $-100 <= Node.val <= 100$\n* $-10^5 <= val <= 10^5$\n* $1 <= depth <= the depth of tree + 1$", "solution": "### BFS\n\n根据 `BFS` 来做,每次 `BFS` 将整一层进行拓展,同时记录当前深度,当到达第 `depth - 1` 层,则进行加点操作。\n\nJava 代码:\n```Java\nclass Solution {\n    public TreeNode addOneRow(TreeNode root, int val, int depth) {\n        if (depth == 1) return new TreeNode(val, root, null);\n        Deque<TreeNode> d = new ArrayDeque<>();\n        d.addLast(root);\n        int cur = 1;\n        while (!d.isEmpty()) {\n            int sz = d.size();\n            while (sz-- > 0) {\n                TreeNode t = d.pollFirst();\n                if (cur == depth - 1) {\n                    TreeNode a = new TreeNode(val), b = new TreeNode(val);\n                    a.left = t.left; b.right = t.right;\n                    t.left = a; t.right = b;\n                } else {\n                    if (t.left != null) d.addLast(t.left);\n                    if (t.right != null) d.addLast(t.right);\n                }\n            }\n            cur++;\n        }\n        return root;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction addOneRow(root: TreeNode | null, val: number, depth: number): TreeNode | null {\n    if (depth == 1) return new TreeNode(v, root, null);\n    const stk = new Array<TreeNode>()\n    let he = 0, ta = 0, cur = 1\n    stk[ta++] = root\n    while (he < ta) {\n        let sz = ta - he\n        while (sz-- > 0) {\n            const t = stk[he++]\n            if (cur == depth - 1) {\n                const a = new TreeNode(val), b = new TreeNode(val)\n                a.left = t.left; b.right = t.right\n                t.left = a; t.right = b\n            } else {\n                if (t.left != null) stk[ta++] = t.left\n                if (t.right != null) stk[ta++] = t.right\n            }\n        }\n        cur++\n    }\n    return root\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### DFS\n\n同理,使用 `DFS` 也可进行求解,在 `DFS` 过程中记录当前深度。\n\nJava 代码:\n```Java\nclass Solution {\n    int d, v;\n    public TreeNode addOneRow(TreeNode root, int val, int depth) {\n        d = depth; v = val;\n        if (d == 1) return new TreeNode(val, root, null);\n        dfs(root, 1);\n        return root;\n    }\n    void dfs(TreeNode root, int cur) {\n        if (root == null) return ;\n        if (cur == d - 1) {\n            TreeNode a = new TreeNode(v), b = new TreeNode(v);\n            a.left = root.left; b.right = root.right;\n            root.left = a; root.right = b;\n        } else {\n            dfs(root.left, cur + 1);\n            dfs(root.right, cur + 1);\n        }\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nlet d = 0, v = 0\nfunction addOneRow(root: TreeNode | null, val: number, depth: number): TreeNode | null {\n    d = depth; v = val\n    if (d == 1) return new TreeNode(v, root, null);\n    dfs(root, 1)\n    return root\n};\nfunction dfs(root: TreeNode | null, cur: number): void {\n    if (root == null) return \n    if (cur == d - 1) {\n        const a = new TreeNode(v), b = new TreeNode(v)\n        a.left = root.left; b.right = root.right\n        root.left = a; root.right = b\n    } else {\n        dfs(root.left, cur + 1)\n        dfs(root.right, cur + 1)\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.623` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/621-630/629. K个逆序对数组（困难）.md", "url_title": "629. K个逆序对数组", "url": "https://leetcode-cn.com/problems/k-inverse-pairs-array/solution/gong-shui-san-xie-yi-dao-xu-lie-dp-zhuan-tm01/", "difficulty": "困难", "tags": ["序列 DP", "前缀和"], "question": "给出两个整数 `n` 和 `k`,找出所有包含从 `1` 到 `n` 的数字,且恰好拥有 `k` 个逆序对的不同的数组的个数。\n\n逆序对的定义如下:对于数组的第 `i` 个和第 `j` 个元素,如果满 `i < j` 且 `a[i] > a[j]`,则其为一个逆序对;否则不是。\n\n由于答案可能很大,只需要返回 答案 mod $10^9 + 7$ 的值。\n\n示例 1:\n```\n输入: n = 3, k = 0\n\n输出: 1\n\n解释: \n只有数组 [1,2,3] 包含了从1到3的整数并且正好拥有 0 个逆序对。\n```\n示例 2:\n```\n输入: n = 3, k = 1\n\n输出: 2\n\n解释: \n数组 [1,3,2] 和 [2,1,3] 都有 1 个逆序对。\n```\n\n说明:\n*  `n` 的范围是 `[1, 1000]` 并且 `k` 的范围是 `[0, 1000]`。", "solution": "### 序列 DP\n\n从 $n$ 和 $k$ 数据范围均为 $10^3$ 可以看出这是一道二维的动态规划题。\n\n**定义 $f[i][j]$ 为考虑使用数值 $[1,i]$,凑成逆序对数量恰好为 $j$ 的数组个数。**\n\n不失一般性的考虑 $f[i][j]$ 该如何计算,对第 $i$ 个数(即数值为 $i$ 的数)所在位置进行讨论,共有 $i$ 种选择。\n\n假设第 $i$ 个数所在位置为 $k$,由于数值 $i$ 为整个数组的最大值,因此数值 $i$ 与前面所有数均不形成逆序对,与后面的所有数均形成逆序对。因此与数值 $i$ 直接相关的逆向对的数量为 $(i - 1)- k$,由此也得出与 $i$ 不相关的逆序对数量为 $j - (i - 1 - k)$,而与 $i$ 不相关的逆序对数量由 $f[i - 1][x]$ 可得出。\n\n举个 🌰 帮助大家理解:\n\n* 当数值 $i$ 放置在下标为 $0$ 的位置上,那么由数值 $i$ 产生的逆序对数量为 $i - 1$,总的逆序对数量为 $j$,因此由数值范围为 $[1, i - 1]$(与数值 $i$ 不相关)构成的逆序对数量为 $j - (i - 1)$,即 $f[i - 1][j - (i - 1)]$;\n\n* 当数值 $i$ 放置在下标为 $1$ 的位置上,那么由数值 $i$ 产生的逆序对数量为 $(i - 1) - 1$,总的逆序对数量为 $j$,因此由数值范围为 $[1, i - 1]$(与数值 $i$ 不相关)构成的逆序对数量为 $j - (i - 1 - 1)$,即 $f[i - 1][j - (i - 1 - 1)]$;\n\n    ...\n\n* 当数值 $i$ 放置在下标为 $k$ 的位置上,那么由数值 $i$ 产生的逆序对数量为 $(i - 1) - k$,总的逆序对数量为 $j$,因此由数值范围为 $[1, i - 1]$(与数值 $i$ 不相关)构成的逆序对数量为 $j - (i - 1 - k)$,即 $f[i - 1][j - (i - 1 - k)]$。\n\n综上,最终 $f[i][j]$ 转移方程为($k$ 为数值 $i$ 放置的位置):\n\n$$\nf[i][j] = \\sum_{k = 0}^{i - 1}(f[i - 1][j - (i - 1 - k)])\n$$\n\n共有 $n * k$ 个状态,每个 $f[i][j]$ 的计算需要枚举数值 $i$ 所在位置并进行累加,总的复杂度为 $O(n^2 *k)$,计算量为 $10^9$,会 TLE。\n\n状态数量不可减少,考虑如何优化单个状态的转移过程。\n\n不难发现 $\\sum_{k = 0}^{i - 1}(f[i - 1][j - (i - 1 - k)])$ 部分为上一次转移结果 $f[i - 1][x]$ 的某个前缀,可以使用前缀和数组进行优化,从而将计算单个状态的复杂度从 $O(n)$ 降到 $O(1)$。\n\n> 一些细节:为处理负数问题,我们可以在取模之前先加一次 mod;另外需要对 $j$ 和 $i$ 的大小进行分情况讨论,防止数值 $i$ 放置的位置“过于靠前”导致组成逆序对的数量超过 $j$。\n\n代码($P1$ $P2$ 分别为使用 `long` 和不使用 `long`):\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int kInversePairs(int n, int k) {\n        long[][] f = new long[n + 1][k + 1];\n        long[][] sum = new long[n + 1][k + 1];\n        f[1][0] = 1;\n        Arrays.fill(sum[1], 1);\n        for (int i = 2; i <= n; i++) {\n            for (int j = 0; j <= k; j++) {\n                f[i][j] = j < i ? sum[i - 1][j] : sum[i - 1][j] - sum[i - 1][j - (i - 1) - 1];\n                f[i][j] = (f[i][j] + mod) % mod;\n                sum[i][j] = j == 0 ? f[i][j] : sum[i][j - 1] + f[i][j];\n                sum[i][j] = (sum[i][j] + mod) % mod;\n            }\n        }\n        return (int)f[n][k];\n    }\n}\n```\n\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int kInversePairs(int n, int k) {\n        int[][] f = new int[n + 1][k + 1];\n        int[][] sum = new int[n + 1][k + 1];\n        f[1][0] = 1;\n        Arrays.fill(sum[1], 1);\n        for (int i = 2; i <= n; i++) {\n            for (int j = 0; j <= k; j++) {\n                f[i][j] = j < i ? sum[i - 1][j] : (sum[i - 1][j] - sum[i - 1][j - (i - 1) - 1] + mod) % mod;\n                sum[i][j] = j == 0 ? f[i][j] : (sum[i][j - 1] + f[i][j]) % mod;\n            }\n        }\n        return f[n][k];\n    }\n}\n```\n* 时间复杂度:$O(n \\times k)$\n* 空间复杂度:$O(n \\times k)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.629` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/621-630/630. 课程表 III（困难）.md", "url_title": "630. 课程表 III", "url": "https://leetcode-cn.com/problems/course-schedule-iii/solution/gong-shui-san-xie-jing-dian-tan-xin-yun-ghii2/", "difficulty": "困难", "tags": ["贪心"], "question": "这里有 $n$ 门不同的在线课程,按从 $1$ 到 $n$ 编号。给你一个数组 $courses$ ,其中 $courses[i] = [durationi, lastDayi]$ 表示第 $i$ 门课将会 持续 上 $duration_i$ 天课,并且必须在不晚于 $lastDay_i$ 的时候完成。\n\n你的学期从第 $1$ 天开始。且不能同时修读两门及两门以上的课程。\n\n返回你最多可以修读的课程数目。\n\n示例 1:\n```\n输入:courses = [[100, 200], [200, 1300], [1000, 1250], [2000, 3200]]\n\n输出:3\n\n解释:\n这里一共有 4 门课程,但是你最多可以修 3 门:\n首先,修第 1 门课,耗费 100 天,在第 100 天完成,在第 101 天开始下门课。\n第二,修第 3 门课,耗费 1000 天,在第 1100 天完成,在第 1101 天开始下门课程。\n第三,修第 2 门课,耗时 200 天,在第 1300 天完成。\n第 4 门课现在不能修,因为将会在第 3300 天完成它,这已经超出了关闭日期。\n```\n示例 2:\n```\n输入:courses = [[1,2]]\n\n输出:1\n```\n示例 3:\n```\n输入:courses = [[3,2],[4,3]]\n\n输出:0\n```\n\n提示:\n* $1 <= courses.length <= 10^4$\n* $1 <= durationi, lastDayi <= 10^4$", "solution": "### 贪心 + 优先队列(堆)\n\n这是一道很好的题目。\n\n题目是要我们构造出一种可行的排列,排列中每个课程的实际结束时间满足「最晚完成时间」要求,求可行排序的最大长度(每个课程对答案的贡献都是 $1$)。\n\n这容易引导我们往「泛化背包」方面进行思考:简单来说,对于某个物品(课程)而言,在不同条件下成本不同,在时间轴 $[1, courses[i][1] - courses[i][0]]$ 上该物品可被选,成本为其持续时间,在比该范围大的数轴上无法被选,成本为正无穷。因此某一段特定的时间轴上,问题可抽象成有条件限制的组合优化问题。\n\n**由于数据范围为 $10^4$,泛化背包做法需要记录的维度大于一维,不予考虑。**\n\n再然后容易想到「二分」,显然在以最大选择数量 $ans$ 为分割点的数组上具有「二段性」:\n\n* 使用数量小于等于 $ans$ 的课程能够构造出合法排序(考虑在最长合法序列上做减法即可);\n* 使用数量大于 $ans$ 的课程无法构造出合法排列。\n\n此时二分范围为 $[0, n]$,问题转化为:如何在 $O(n)$ 检查是否可构造出某个长度 $len$ 的合法排列(实现 `check` 方法)。\n\n**常规的线性扫描做法无法确定是否存在某个长度的合法排列,因此二分不予考虑。**\n\n我们需要运用「贪心」思维考虑可能的方案。\n\n具体的,我们先根据「结束时间」对 $courses$ 排升序,从前往后考虑每个课程,处理过程中维护一个总时长 $sum$,对于某个课程 $courses[i]$ 而言,根据如果学习该课程,是否满足「最晚完成时间」要求进行分情况讨论:\n\n* 学习该课程后,满足「最晚完成时间」要求,即 $sum + courses[i][0] <= courses[i][1]$,则进行学习;\n\n* 学习该课程后,不满足「最晚完成时间」要求,此时从过往学习的课程中找出「持续时间」最长的课程进行「回退」操作(这个持续时长最长的课程有可能是当前课程)。\n\n其中「记录当前已选课程」和「从过往学习的课程中找出持续时间最长的课程」操作可以使用优先队列(大根堆)实现。\n\n可用「归纳法 + 反证法」证明该做法能够取到最优排列之一,定义最优排列为「总课程数最大,且总耗时最少」的合法排列。\n\n1. 在课程数量相同的前提下,该做法得到的排列总耗时最少\n    \n    这点可通过「反证法」来证明:当不满足「最后完成时间」时,我们总是弹出「持续时间」最长的课程来进行回退,因此在所有课程对答案的贡献都是 $1$ 的前提下,该做法能够确保总耗时最少。即当堆中元素数量被调整为 $x$ 时,必然是由元素数量为 $x + 1$ 时,将持续时间最长的课程弹出所得来。\n\n2. 该做法能够确保取得最大课程数量\n\n    在得证第 $1$ 点后,可用「归纳法」进行证明第 $2$ 点:只考虑一个课程的情况下(假定 $courses[0][0] < courses[0][1]$),选该课程会比不选更好。\n    将 $courses[0]$ 的最优解排列记为 $s[0]$,当确定了 $s[0]$ 后再考虑如何处理 $courses[1]$ 来得到 $s[1]$。\n    首先可知 $s[1]$ 只有三种情况:\n    * $s[1] = s[0]$:意味着 $courses[1]$ 不参与到最优解排列当中;\n    * $s[1] \\neq s[0]$,但两个最优解长度相同:意味着 $s[1]$ 是由 $courses[1]$ 替换了 $s[0]$ 中的某个课程而来(此时只有第 $0$ 个课程),且基于证明 $1$ 可以得证,被替换的课程持续时间比 $courses[1]$ 要长;\n    * $s[1] \\neq s[0]$,且 $s[1]$ 长度比 $s[0]$ 大 $1$:意味着 $s[1]$ 是由 $courses[1]$ 最接追加到 $s[0]$ 而来。\n\n    综上,我们证明了,如果已知某个边界情况的最优解,那么由边界的最优解可推导出在此基础上多考虑一个课程时的最优解。即以上分析可以推广到任意的 $s[i - 1]$ 和 $s[i]$。\n\n    **需要注意,在推广到任意的 $s[i - 1]$ 和 $s[i]$ 时,还需要证明在已知 $s[i - 1]$ 时,多考虑一个 $courses[i]$ 不会出现 $s[i]$ 的和 $s[i - 1]$ 的长度差超过 $1$ 的情况。**\n    这个基于已得证的第 $1$ 点,再用反证法可证:如果在 $s[i - 1]$ 的基础上多考虑一个 $courses[i]$ 能够使得总长度增加超过 $1$,说明存在一个「之前没有被选的课程」+「课程 $courses[i]$」的持续时间比「被替换的课程」短。\n    那么使用这个「之前没有被选的课程」直接替换「被替换的课程」可得到长度与 $s[i - 1]$ 相同,且总耗时更短的排列方案,这与 $s[i - 1]$ 本身是最优排列冲突。\n\n代码:\n```Java\nclass Solution {\n    public int scheduleCourse(int[][] courses) {\n        Arrays.sort(courses, (a,b)->a[1]-b[1]);\n        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);\n        int sum = 0;\n        for (int[] c : courses) {\n            int d = c[0], e = c[1];\n            sum += d;\n            q.add(d);\n            if (sum > e) sum -= q.poll();\n        }\n        return q.size();\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.630` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/631-640/633. 平方数之和（中等）.md", "url_title": "633. 平方数之和", "url": "https://leetcode-cn.com/problems/sum-of-square-numbers/solution/gong-shui-san-xie-yi-ti-san-jie-mei-ju-s-7qi5/", "difficulty": "中等", "tags": ["数学", "双指针"], "question": "给定一个非负整数 c ,你要判断是否存在两个整数 a 和 b,使得 $a^2$ + $b^2$ = c 。\n\n示例 1:\n```\n输入:c = 5\n\n输出:true\n\n解释:1 * 1 + 2 * 2 = 5\n```\n示例 2:\n```\n输入:c = 3\n\n输出:false\n```\n示例 3:\n```\n输入:c = 4\n\n输出:true\n```\n示例 4:\n```\n输入:c = 2\n\n输出:true\n```\n示例 5:\n```\n输入:c = 1\n\n输出:true\n```\n\n提示:\n* 0 <= c <= $2^{31}$ - 1", "solution": "### 基本分析\n\n**根据等式 $a^2 + b^2 = c$,可得知 `a` 和 `b` 的范围均为 $[0,\\sqrt{c}]$。**\n\n基于此我们会有以下几种做法。\n\n---\n\n### 枚举\n\n我们可以枚举 `a` ,边枚举边检查是否存在 `b` 使得等式成立。\n\n这样做的复杂度为 $O(\\sqrt{c})$。\n\n代码:\n```Java\nclass Solution {\n    public boolean judgeSquareSum(int c) {\n        int max = (int)Math.sqrt(c);\n        for (int a = 0; a <= max; a++) {\n            int b = (int)Math.sqrt(c - a * a);\n            if (a * a + b * b == c) return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(\\sqrt{c})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 双指针\n\n由于 `a` 和 `b` 的范围均为 $[0,\\sqrt{c}]$,因此我们可以使用「双指针」在 $[0,\\sqrt{c}]$ 范围进行扫描:\n\n* $a^2 + b^2 == c$ : 找到符合条件的 `a` 和 `b`,返回 $true$\n* $a^2 + b^2 < c$ : 当前值比目标值要小,`a++`\n* $a^2 + b^2 > c$ : 当前值比目标值要大,`b--`\n\n代码:\n```Java\nclass Solution {\n    public boolean judgeSquareSum(int c) {\n        int a = 0, b = (int)Math.sqrt(c);\n        while (a <= b) {\n            int cur = a * a + b * b;\n            if (cur == c) {\n                return true;\n            } else if (cur > c) {\n                b--;\n            } else {\n                a++;\n            }\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(\\sqrt{c})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 费马平方和\n\n**费马平方和 : 奇质数能表示为两个平方数之和的充分必要条件是该质数被 4 除余 1 。**\n\n翻译过来就是:**当且仅当一个自然数的质因数分解中,满足 `4k+3` 形式的质数次方数均为偶数时,该自然数才能被表示为两个平方数之和。**\n\n因此我们对 `c` 进行质因数分解,再判断满足 `4k+3` 形式的质因子的次方数是否均为偶数即可。\n\n代码:\n```Java\npublic class Solution {\n    public boolean judgeSquareSum(int c) {\n        for (int i = 2, cnt = 0; i * i <= c; i++, cnt = 0) {\n            while (c % i == 0 && ++cnt > 0) c /= i;\n            if (i % 4 == 3 && cnt % 2 != 0) return false;\n        }\n        return c % 4 != 3;\n    }\n}\n```\n* 时间复杂度:$O(\\sqrt{c})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 我猜你问\n\n* 三种解法复杂度都一样,哪个才是最优解呀?\n\n前两套解法是需要「真正掌握」的,而「费马平方和」更多的是作为一种拓展。\n\n你会发现从复杂度上来说,其实「费马平方和」并没有比前两种解法更好,但由于存在对 `c` 除质因数操作,导致「费马平方和」实际表现效果要优于同样复杂度的其他做法。但这仍然不成为我们必须掌握「费马平方和」的理由。\n\n三者从复杂度上来说,都是 $O(\\sqrt{c})$ 算法,不存在最不最优的问题。\n\n* 是否有关于「费马平方和」的证明呢?\n\n想要看 莱昂哈德·欧拉 对于「费马平方和」的证明在 [这里](https://zh.wikipedia.org/wiki/%E8%B4%B9%E9%A9%AC%E5%B9%B3%E6%96%B9%E5%92%8C%E5%AE%9A%E7%90%86),我这里直接引用 费马 本人的证明:\n\n> 我确实发现了一个美妙的证明,但这里空白太小写不下。\n\n* 我就是要学「费马平方和」,有没有可读性更高的代码?\n\n有的,在这里。喜欢的话可以考虑背过:\n\n```Java\npublic class Solution {\n    public boolean judgeSquareSum(int c) {\n        for (int i = 2; i * i <= c; i++) {\n            int cnt = 0;\n            while (c % i == 0) {\n                cnt++;\n                c /= i;\n            }\n            if (i % 4 == 3 && cnt % 2 != 0) return false;\n        }\n        return c % 4 != 3;\n    }\n}\n```", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.633` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/631-640/636. 函数的独占时间（中等）.md", "url_title": "636. 函数的独占时间", "url": "https://leetcode.cn/problems/exclusive-time-of-functions/solution/by-ac_oier-z3ed/", "difficulty": "中等", "tags": ["模拟", "栈"], "question": "有一个单线程 `CPU` 正在运行一个含有 `n` 道函数的程序。\n\n每道函数都有一个位于  `0` 和 `n-1` 之间的唯一标识符。\n\n函数调用存储在一个调用栈上 :当一个函数调用开始时,它的标识符将会推入栈中。而当一个函数调用结束时,它的标识符将会从栈中弹出。标识符位于栈顶的函数是当前正在执行的函数。每当一个函数开始或者结束时,将会记录一条日志,包括函数标识符、是开始还是结束、以及相应的时间戳。\n\n给你一个由日志组成的列表 `logs` ,其中 `logs[i]` 表示第 `i` 条日志消息,该消息是一个按 `\"{function_id}:{\"start\" | \"end\"}:{timestamp}\"` 进行格式化的字符串。\n\n例如,`\"0:start:3\"` 意味着标识符为 `0` 的函数调用在时间戳 `3` 的 起始开始执行 ;而 `\"1:end:2\"` 意味着标识符为 `1` 的函数调用在时间戳 `2` 的末尾结束执行。\n\n注意,函数可以调用多次,可能存在递归调用 。\n\n函数的「独占时间」定义是在这个函数在程序所有函数调用中执行时间的总和,调用其他函数花费的时间不算该函数的独占时间。\n\n例如,如果一个函数被调用两次,一次调用执行 `2` 单位时间,另一次调用执行 `1` 单位时间,那么该函数的独占时间为 `2 + 1 = 3` 。\n\n以数组形式返回每个函数的独占时间,其中第 `i` 个下标对应的值表示标识符 `i` 的函数的独占时间。\n\n示例 1:\n\n```\n输入:n = 2, logs = [\"0:start:0\",\"1:start:2\",\"1:end:5\",\"0:end:6\"]\n\n输出:[3,4]\n\n解释:\n函数 0 在时间戳 0 的起始开始执行,执行 2 个单位时间,于时间戳 1 的末尾结束执行。 \n函数 1 在时间戳 2 的起始开始执行,执行 4 个单位时间,于时间戳 5 的末尾结束执行。 \n函数 0 在时间戳 6 的开始恢复执行,执行 1 个单位时间。 \n所以函数 0 总共执行 2 + 1 = 3 个单位时间,函数 1 总共执行 4 个单位时间。 \n```\n示例 2:\n```\n输入:n = 1, logs = [\"0:start:0\",\"0:start:2\",\"0:end:5\",\"0:start:6\",\"0:end:6\",\"0:end:7\"]\n\n输出:[8]\n\n解释:\n函数 0 在时间戳 0 的起始开始执行,执行 2 个单位时间,并递归调用它自身。\n函数 0(递归调用)在时间戳 2 的起始开始执行,执行 4 个单位时间。\n函数 0(初始调用)恢复执行,并立刻再次调用它自身。\n函数 0(第二次递归调用)在时间戳 6 的起始开始执行,执行 1 个单位时间。\n函数 0(初始调用)在时间戳 7 的起始恢复执行,执行 1 个单位时间。\n所以函数 0 总共执行 2 + 4 + 1 + 1 = 8 个单位时间。\n```\n示例 3:\n```\n输入:n = 2, logs = [\"0:start:0\",\"0:start:2\",\"0:end:5\",\"1:start:6\",\"1:end:6\",\"0:end:7\"]\n\n输出:[7,1]\n\n解释:\n函数 0 在时间戳 0 的起始开始执行,执行 2 个单位时间,并递归调用它自身。\n函数 0(递归调用)在时间戳 2 的起始开始执行,执行 4 个单位时间。\n函数 0(初始调用)恢复执行,并立刻调用函数 1 。\n函数 1在时间戳 6 的起始开始执行,执行 1 个单位时间,于时间戳 6 的末尾结束执行。\n函数 0(初始调用)在时间戳 7 的起始恢复执行,执行 1 个单位时间,于时间戳 7 的末尾结束执行。\n所以函数 0 总共执行 2 + 4 + 1 = 7 个单位时间,函数 1 总共执行 1 个单位时间。 \n```\n示例 4:\n```\n输入:n = 2, logs = [\"0:start:0\",\"0:start:2\",\"0:end:5\",\"1:start:7\",\"1:end:7\",\"0:end:8\"]\n\n输出:[8,1]\n```\n示例 5:\n```\n输入:n = 1, logs = [\"0:start:0\",\"0:end:0\"]\n\n输出:[1]\n```\n\n提示:\n* $1 <= n <= 100$\n* $1 <= logs.length <= 500$\n* $0 <= function_id < n$\n* $0 <= timestamp <= 10^9$\n* 两个开始事件不会在同一时间戳发生\n* 两个结束事件不会在同一时间戳发生\n* 每道函数都有一个对应 `\"start\"` 日志的 `\"end\"` 日志", "solution": "### 模拟\n\n我们使用「栈」来模拟执行过程:当一个函数被调用(`op = start`)时,压入栈内,当函数调用完成(`op = end`)时,从栈顶弹出(此时栈顶元素必然是该结束函数的入栈记录),使用变量 `cur` 记录当前时间。\n\n从前往后处理所有的 $log[i]$,根据 $log[i]$ 是属于函数调用还是函数结束进行分情况讨论:\n\n* 当 $log[i]$ 为函数调用:此时从该函数的调用发起时间 `ts` 到上一次记录的当前时间,都是前一函数的执行时间,因此可以将 `ts - cur` 累加到栈帧中的前一函数。即若栈不为空,则将该时间累加到栈顶对应的函数上,然后将 $log[i]$ 入栈,同时更新当前时间;\n* 当 $log[i]$ 为函数结束:此时栈顶元素必然是该函数的调用记录,此时 $log[i]$ 的结束时间与上一次记录的当前时间的时长 `ts - cur + 1`,必然是该函数的执行时间,将其累加到当前函数中,并更新当前时间。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] exclusiveTime(int n, List<String> logs) {\n        int[] ans = new int[n];\n        Deque<Integer> d = new ArrayDeque<>();\n        int cur = -1;\n        for (String log : logs) {\n            String[] ss = log.split(\":\");\n            int idx = Integer.parseInt(ss[0]), ts = Integer.parseInt(ss[2]);\n            if (ss[1].equals(\"start\")) {\n                if (!d.isEmpty()) ans[d.peekLast()] += ts - cur;\n                d.addLast(idx);\n                cur = ts;\n            } else {\n                int func = d.pollLast();\n                ans[func] += ts - cur + 1;\n                cur = ts + 1;\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> exclusiveTime(int n, vector<string>& logs) {\n        vector<int> ans(n, 0);\n        stack<int> s;\n        int cur = -1;\n        for (auto log : logs) {\n            istringstream ss(log);\n            string buf;\n            vector<string> tokens;\n            while (getline(ss, buf, ':')) {\n                tokens.push_back(buf);\n            }\n            int idx = stoi(tokens[0]), ts = stoi(tokens[2]);\n            if (tokens[1] == \"start\") {\n                if (!s.empty()) ans[s.top()] += ts - cur;\n                s.push(idx);\n                cur = ts;\n            } else {\n                ans[s.top()] += ts - cur + 1;\n                s.pop();\n                cur = ts + 1;\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def exclusiveTime(self, n: int, logs: List[str]) -> List[int]:\n        ans = [0] * n\n        s = []\n        cur = -1\n        for log in logs:\n            ss = log.split(':')\n            idx, ts = int(ss[0]), int(ss[2])\n            if ss[1] == \"start\":\n                if s: ans[s[-1]] += ts - cur\n                s.append(idx)\n                cur = ts\n            else:\n                ans[s.pop()] += ts - cur + 1\n                cur = ts + 1\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction exclusiveTime(n: number, logs: string[]): number[] {\n    const ans = new Array<number>(n).fill(0)\n    const stk = new Array<number>()\n    let he = 0, ta = 0, cur = -1\n    for (let log of logs) {\n        const ss = log.split(\":\")\n        const idx = Number(ss[0]), ts = Number(ss[2])\n        if (ss[1] == \"start\") {\n            if (he < ta) ans[stk[ta - 1]] += ts - cur\n            stk[ta++] = idx\n            cur = ts\n        } else {\n            const func = stk[--ta]\n            ans[func] += ts - cur + 1\n            cur = ts + 1\n        }\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.636` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/631-640/638. 大礼包（中等）.md", "url_title": "638. 大礼包", "url": "https://leetcode-cn.com/problems/shopping-offers/solution/gong-shui-san-xie-yi-ti-shuang-jie-zhuan-qgk1/", "difficulty": "中等", "tags": ["完全背包", "背包问题", "DFS"], "question": "在 LeetCode 商店中, 有 `n` 件在售的物品。每件物品都有对应的价格。然而,也有一些大礼包,每个大礼包以优惠的价格捆绑销售一组物品。\n\n给你一个整数数组 `price` 表示物品价格,其中 `price[i]` 是第 `i` 件物品的价格。另有一个整数数组 `needs` 表示购物清单,其中 `needs[i]` 是需要购买第 `i` 件物品的数量。\n\n还有一个数组 special 表示大礼包,`special[i]` 的长度为 `n + 1` ,其中 `special[i][j]` 表示第 `i` 个大礼包中内含第 `j` 件物品的数量,且 `special[i][n]` (也就是数组中的最后一个整数)为第 `i` 个大礼包的价格。\n\n返回 确切 满足购物清单所需花费的最低价格,你可以充分利用大礼包的优惠活动。你不能购买超出购物清单指定数量的物品,即使那样会降低整体价格。任意大礼包可无限次购买。\n\n示例 1:\n```\n输入:price = [2,5], special = [[3,0,5],[1,2,10]], needs = [3,2]\n\n输出:14\n\n解释:有 A 和 B 两种物品,价格分别为 ¥2 和 ¥5 。 \n大礼包 1 ,你可以以 ¥5 的价格购买 3A 和 0B 。 \n大礼包 2 ,你可以以 ¥10 的价格购买 1A 和 2B 。 \n需要购买 3 个 A 和 2 个 B , 所以付 ¥10 购买 1A 和 2B(大礼包 2),以及 ¥4 购买 2A 。\n```\n示例 2:\n```\n输入:price = [2,3,4], special = [[1,1,0,4],[2,2,1,9]], needs = [1,2,1]\n\n输出:11\n\n解释:A ,B ,C 的价格分别为 ¥2 ,¥3 ,¥4 。\n可以用 ¥4 购买 1A 和 1B ,也可以用 ¥9 购买 2A ,2B 和 1C 。 \n需要买 1A ,2B 和 1C ,所以付 ¥4 买 1A 和 1B(大礼包 1),以及 ¥3 购买 1B , ¥4 购买 1C 。 \n不可以购买超出待购清单的物品,尽管购买大礼包 2 更加便宜。\n```\n\n提示:\n* n == price.length\n* n == needs.length\n* 1 <= n <= 6\n* 0 <= price[i] <= 10\n* 0 <= needs[i] <= 10\n* 1 <= special.length <= 100\n* special[i].length == n + 1\n* 0 <= special[i][j] <= 50", "solution": "### 转换 DFS(转换为礼包处理)\n\n对于某个 $need[i]$ 而言,既可以「单买」也可以使用「礼包形式购买」,同时两种购买方式都存在对「份数」的决策(单买多少份/买多少个相应的礼包)。\n\n利用物品数量和礼包数量数据范围都较少,我们可以先对「单买」情况进行预处理,将其转换为「礼包」形式。若 $price[0] = 100$,则使用礼包 $[1, 0, 0, ...,0, 100]$ 来代指。\n\n然后再预处理每个礼包最多选多少个,并使用哈希表进行存储。\n\n最后使用 `DFS` 对每个「礼包」如何选择进行爆搜即可。\n\n代码:\n```Java\nclass Solution {\n    int ans = 0x3f3f3f3f;\n    List<Integer> price, needs;\n    List<List<Integer>> special;\n    Map<Integer, Integer> map = new HashMap<>();\n    int n, m;\n    public int shoppingOffers(List<Integer> _price, List<List<Integer>> _special, List<Integer> _needs) {\n        price = _price; special = _special; needs = _needs;\n        n = price.size();\n        List<Integer> temp = new ArrayList<>();\n        for (int i = 0; i < n; i++) temp.add(0);\n        for (int i = 0; i < n; i++) {\n            List<Integer> clone = new ArrayList<>(temp);\n            clone.set(i, 1);\n            clone.add(price.get(i));\n            special.add(clone);\n        }\n        m = special.size();\n        for (int i = 0; i < m; i++) {\n            List<Integer> x = special.get(i);\n            int max = 0;\n            for (int j = 0; j < n; j++) {\n                int a = x.get(j), b = needs.get(j);\n                if (a == 0 || b == 0) continue;\n                max = Math.max(max, (int)Math.ceil(b / a));\n            }\n            map.put(i, max);\n        }\n        dfs(0, needs, 0);\n        return ans;\n    }\n    void dfs(int u, List<Integer> list, int cur) {\n        if (cur >= ans) return ;\n        if (u == m) {\n            for (int i = 0; i < n; i++) {\n                if (list.get(i) != 0) return ;\n            }\n            ans = Math.min(ans, cur);\n            return ;\n        }\n        List<Integer> x = special.get(u);\n        out:for (int k = 0; k <= map.get(u); k++) {\n            List<Integer> clist = new ArrayList<>(list);\n            for (int i = 0; i < n; i++) {\n                int a = x.get(i), b = clist.get(i);\n                if (a * k > b) break out;\n                clist.set(i, b - a * k);\n            }\n            dfs(u + 1, clist, cur + k * x.get(n));\n        }\n    }\n}\n```\n* 时间复杂度:令物品数量为 $n$,原礼包数量为 $m$。将「单买」预处理成「礼包」,共有 $n$ 中「单买」情况需要转换,同时每个转换需要对数组进行复制,复杂度为 $O(n^2)$,预处理完后,共有 $n + m$ 个礼包;预处理每个礼包所能选的最大数量,复杂度为 $O((n * m) * n)$;对礼包的选择方案进行决策,一个礼包最多选择 $k = \\max(needs[i]) = 10$ 个,复杂度为 $O(k ^ {n + m})$\n* 空间复杂度:$O(k ^ {n + m})$\n\n---\n\n### 完全背包\n\n这还是一道很有意思的「完全背包」问题。\n\n不了解「完全背包」的同学,可以先看前置🧀:[完全背包](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486107&idx=1&sn=e5fa523008fc5588737b7ed801caf4c3&chksm=fd9ca184caeb28926959c0987208a3932ed9c965267ed366b5b82a6fc16d42f1ff40c29db5f1&scene=178&cur_album_id=1751702161341628417#rd)。目前[「背包问题」专题](https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MzU4NDE3MTEyMA==&action=getalbum&album_id=1751702161341628417&scene=173&from_msgid=2247486107&from_itemidx=1&count=3&nolastread=1#wechat_redirect) 已经讲了 $21$ 篇,大概还有 $2$ - $4$ 篇彻底讲完,完全覆盖了所有的「背包问题」。\n\n背包问题难点在于对「成本」和「价值」的抽象。\n\n对于本题,我们可以定义 **$f[i, j_0, j_1, j_2, ... , j_{n - 1}]$ 为考虑前 $i$ 个大礼包,购买 $j_0$ 件物品 $0$,购买 $j_1$ 件物品 $1$,....,购买 $j_{n - 1}$ 件物品 $n - 1$ 时的最小花费。**\n\n同时,我们有初始化条件 $f[0, 0, 0, ... , 0] = 0$(其余 $f[0, x_0, x_1, x_2, ..., x_n]$ 为正无穷)的初始化条件,最终答案为 $f[m - 1, need[0], need[1], ..., need[n - 1]]$。\n\n这样的朴素完全背包做法复杂度过高,根据我们的前置🧀 [完全背包](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486107&idx=1&sn=e5fa523008fc5588737b7ed801caf4c3&chksm=fd9ca184caeb28926959c0987208a3932ed9c965267ed366b5b82a6fc16d42f1ff40c29db5f1&scene=178&cur_album_id=1751702161341628417#rd) 中的数学推导分析,我们发现完全背包的一维空间优化,是具有优化复杂度的意义。\n\n因此,我们可以对礼包维度进行优化,使用 $f[need[0], need[1], ... , need[n - 1]]$ 来作为状态表示。\n\n不失一般性的考虑 $f[j_0, j_1, ... , j_{n - 1}]$ 该如何转移(以物品 $0$ 为例进行分析,其他同理):\n\n1. 不选择任何大礼包,只进行单买:$f[j_0, j_1, ... , j_{n - 1}] = min(f[j_0, j_1, ... , j_{n - 1}], f[j_0 - 1, j_1, ..., j_{n - 1}] + price[0]$;\n2. 购买大礼包:$f[j_0, j_1, ... , j_{n - 1}] = min(f[j_0, j_1, ... , j_{n - 1}], f[j_0 - special[i][0], j_1 - special[i][1],, ..., j_{n - 1} - special[i][n - 1]] + special[i][n]$\n\n最终的 $f[j_0, j_1, ... , j_{n - 1}]$ 为上述所有方案中的最小值。\n\n>一些细节:实现时,为了防止过多的维度,以及可能存在的 MLE 风险,我们可以对维度进行压缩处理,而最简单的方式可以通过与排列数建立映射关系。\n\n代码:\n```Java\nclass Solution {\n    public int shoppingOffers(List<Integer> price, List<List<Integer>> special, List<Integer> needs) {\n        int n = price.size();\n        int[] g = new int[n + 1];\n        g[0] = 1;\n        for (int i = 1; i <= n; i++) {\n            g[i] = g[i - 1] * (needs.get(i - 1) + 1);\n        }\n        int mask = g[n];\n        int[] f = new int[mask];\n        int[] cnt = new int[n];\n        for (int state = 1; state < mask; state++) {\n            f[state] = 0x3f3f3f3f;\n            Arrays.fill(cnt, 0);\n            for (int i = 0; i < n; i++) {\n                cnt[i] = state % g[i + 1] / g[i];\n            }\n            for (int i = 0; i < n; i++) {\n                if (cnt[i] > 0) f[state] = Math.min(f[state], f[state - g[i]] + price.get(i));\n            }\n            out:for (List<Integer> x : special) {\n                int cur = state;\n                for (int i = 0; i < n; i++) {\n                    if (cnt[i] < x.get(i)) continue out;\n                    cur -= x.get(i) * g[i];\n                }\n                f[state] = Math.min(f[state], f[cur] + x.get(n));\n            }\n        }\n        return f[mask - 1];\n    }\n}\n```\n* 时间复杂度:令物品数量为 $n$,原礼包数量为 $m$。每个物品最多需要 $k = \\max(needs[i]) = 10$ 个,共有 $k^n$ 个状态需要转移,转移时需要考虑「单买」和「礼包」决策,复杂度分别为 $O(n)$ 和 $O(m * n)$。整体复杂度为 $O(k^n * (m * n))$\n* 空间复杂度:$O(k^n * (m * n))$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.638` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/631-640/639. 解码方法 II（困难）.md", "url_title": "639. 解码方法 II", "url": "https://leetcode-cn.com/problems/decode-ways-ii/solution/gong-shui-san-xie-fen-qing-kuang-tao-lun-902h/", "difficulty": "困难", "tags": ["线性 DP", "枚举"], "question": "一条包含字母 A-Z 的消息通过以下的方式进行了编码:\n```\n'A' -> 1\n'B' -> 2\n...\n'Z' -> 26\n```\n要 解码 一条已编码的消息,所有的数字都必须分组,然后按原来的编码方案反向映射回字母(可能存在多种方式)。例如,\"11106\" 可以映射为:\n* \"AAJF\" 对应分组 (1 1 10 6)\n* \"KJF\" 对应分组 (11 10 6)\n\n注意,像 (1 11 06) 这样的分组是无效的,因为 \"06\" 不可以映射为 'F' ,因为 \"6\" 与 \"06\" 不同。\n\n除了 上面描述的数字字母映射方案,编码消息中可能包含 `'*'` 字符,可以表示从 '1' 到 '9' 的任一数字(不包括 '0')。例如,编码字符串 `\"1*\"` 可以表示 \"11\"、\"12\"、\"13\"、\"14\"、\"15\"、\"16\"、\"17\"、\"18\" 或 \"19\" 中的任意一条消息。对 \"1*\" 进行解码,相当于解码该字符串可以表示的任何编码消息。\n\n给你一个字符串 s ,由数字和 '*' 字符组成,返回 解码 该字符串的方法 数目 。\n\n由于答案数目可能非常大,返回对 $10^9 + 7$ 取余 的结果。\n\n示例 1:\n```\n输入:s = \"*\"\n\n输出:9\n\n解释:这一条编码消息可以表示 \"1\"、\"2\"、\"3\"、\"4\"、\"5\"、\"6\"、\"7\"、\"8\" 或 \"9\" 中的任意一条。\n可以分别解码成字符串 \"A\"、\"B\"、\"C\"、\"D\"、\"E\"、\"F\"、\"G\"、\"H\" 和 \"I\" 。\n因此,\"*\" 总共有 9 种解码方法。\n```\n示例 2:\n```\n输入:s = \"1*\"\n\n输出:18\n\n解释:这一条编码消息可以表示 \"11\"、\"12\"、\"13\"、\"14\"、\"15\"、\"16\"、\"17\"、\"18\" 或 \"19\" 中的任意一条。\n每种消息都可以由 2 种方法解码(例如,\"11\" 可以解码成 \"AA\" 或 \"K\")。\n因此,\"1*\" 共有 9 * 2 = 18 种解码方法。\n```\n示例 3:\n```\n输入:s = \"2*\"\n\n输出:15\n\n解释:这一条编码消息可以表示 \"21\"、\"22\"、\"23\"、\"24\"、\"25\"、\"26\"、\"27\"、\"28\" 或 \"29\" 中的任意一条。\n\"21\"、\"22\"、\"23\"、\"24\"、\"25\" 和 \"26\" 由 2 种解码方法,但 \"27\"、\"28\" 和 \"29\" 仅有 1 种解码方法。\n因此,\"2*\" 共有 (6 * 2) + (3 * 1) = 12 + 3 = 15 种解码方法。\n```\n\n提示:\n* $1$ <= s.length <= $10^5$\n* s[i] 是 `0-9` 中的一位数字或字符 '*'", "solution": "### 分情况讨论 DP\n\n这是一道普通的线性 DP 题(之所以说普通,是因为状态定义比较容易想到),也是 [(题解)91. 解码方法](https://leetcode-cn.com/problems/decode-ways/solution/gong-shui-san-xie-gen-ju-shu-ju-fan-wei-ug3dd/) 的进阶题。\n\n我们称一个解码内容为一个 `item`。\n\n**定义 $f[i]$ 为考虑以 $s[i]$ 为结尾的字符串,共有多少种解码方案。**\n\n那么最终答案为 $f[n - 1]$,同时我们有显而易见的起始状态 `f[0] = s[0] == '*' ? 9 : (s[0] != '0' ? 1 : 0)`.\n\n不失一般性考虑 $f[i]$ 该如何转移,$s[i]$ 要么是 `*`,要么是数字,对应一个分情况讨论过程:\n\n* 当 $s[i]$ 为 `*`:此时考虑 $s[i]$ 是单独作为一个 `item`,还是与上一个字符共同作为一个 `item`:\n    * $s[i]$ 单独作为一个 `item`:由于 `*` 可以代指数字 `1-9`,因此有 $f[i] = f[i - 1] * 9$;\n    * $s[i]$ 与上一个字符共同作为一个 `item`:此时需要对上一个字符 $s[j]$ 进行讨论:\n        * $s[j]$ 为数字 `1`:此时 $s[i]$ 可以代指 `1-9`,对应了 `item` 为 `11-19` 这 $9$ 种情况,此时有 $f[i] = f[i - 2] * 9$(**如果 $f[i - 2]$ 取不到,则使用 $1$ 代指,下面同理**);\n        * $s[j]$ 为数字 `2`:此时 $s[i]$ 可以代指 `1-6`,对应了 `item` 为 `21-26` 这 $6$ 种情况,此时有 $f[i] = f[i - 2] * 6$;\n        *  $s[j]$ 为字符 `*`:此时两个 `*` 对应了合法方案为 $11-19$ 和 $21-26$ 共 $15$ 种方案,此时有 $f[i] = f[i - 2] * 15$;\n\n* 当 $s[i]$ 为数字:此时可以从「前一字符 $s[j]$ 为何种字符」和「当前 $s[i]$ 是否为 $0$」出发进行讨论:\n    *  $s[j]$ 为字符 `*`,根据当前 $s[i]$ 是否为 $0$ 讨论:\n        * $s[i]$ 为数字 $0$:此时 $s[i]$ 无法独自作为一个 `item`,只能与 $s[j]$ 组合,对应了 $10$ 和 $20$ 两种情况,此时有 $f[i] = f[i - 2] * 2$;\n        * $s[i]$ 为数字 `1-9`,此时首先有 $s[i]$ 可以作为一个独立 `item` 的情况,即有 $f[i] = f[i - 1]$,然后对 $s[i]$ 的数值大小进一步分情况讨论:\n            * $s[i]$ 为数字 `1-6`,此时 $s[j]$ 可以代指 $1$ 和 $2$,对应了方案 $1x$ 和 $2x$,此时有 $f[i] = f[i - 2] * 2$;\n            * $s[i]$ 为数字 `7-9`,此时 $s[j]$ 可以代指 $1$,对应方案 $1x$,此时有 $f[i] = f[i - 2]$;\n    * $s[j]$ 为数字类型,此时从「当前 $s[i]$ 是否为 $0$」出发进行讨论:\n        * $s[i]$ 为数字 $0$:此时 $s[j]$ 只有为 $1$ 和 $2$ 时,才是合法方案,则有 $f[i] = f[i - 2]$;\n        * $s[i]$ 为数字 `1-9`:此时首先有 $s[i]$ 可以作为一个独立 `item` 的情况,即有 $f[i] = f[i - 1]$,然后再考虑能够与 $s[j]$ 组成合法 `item` 的情况:\n            * $s[j]$ 为数值 $1$:此时有 $f[i] = f[i - 2]$;\n            * $s[j]$ 为数值 $2$,且 $s[i]$ 为数值 `1-6`:此时有 $f[i] = f[i - 2]$。\n\n由于是求方案数,因此最终的 $f[i]$ 为上述所有的合法的分情况讨论的累加值,并对 $1e9+ 7$ 取模。\n\n> 一些细节:实现上了避免大量对 $f[i - 2]$ 是否可以取得的讨论,我们可以对 `s` 前追加一个空格作为哨兵(无须真正插入),以简化代码,同时由于 $f[i]$ 只依赖于 $f[i - 1]$ 和 $f[i - 1]$,可以使用「滚动数组」的形式进行空间空间优化(见 $P2$)。\n\n> 另外,对于「滚动数组」的空间优化方式,还需要说明两点:转移前先使用变量保存 `(i-1)%3` 和 `(i-2)%3` 的计算结果,防止大量的重复计算;不能再偷懒使用 `toCharArray`,只能使用 `charAt`,因为 Java 为了遵循字符串不变的原则,会在调用 `toCharArray` 时返回新数组,这样复杂度就还是 $O(n)$ 的。\n诸如此类的「滚动数组」优化方式,最早在 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247485638&idx=1&sn=d7468955c5b121664031fd5c1b5a6f10&chksm=fd9ca3d9caeb2acf2dd4e9f512b2d4dc820107489a094749ffe7cae646f0cc60de06f2d18898&scene=178&cur_album_id=1751702161341628417#rd) 讲过。\n\n代码:\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int numDecodings(String s) {\n        char[] cs = s.toCharArray();\n        int n = cs.length;\n        long[] f = new long[n];\n        f[0] = cs[0] == '*' ? 9 : (cs[0] != '0' ? 1 : 0);\n        for (int i = 1; i < n; i++) {\n            char c = cs[i], prev = cs[i - 1];\n            if (c == '*') {\n                // cs[i] 单独作为一个 item\n                f[i] += f[i - 1] * 9;\n                // cs[i] 与前一个字符共同作为一个 item\n                if (prev == '*') {\n                    // 11 - 19 & 21 - 26\n                    f[i] += (i - 2 >= 0 ? f[i - 2] : 1) * 15;\n                } else {\n                    int u = (int)(prev - '0');\n                    if (u == 1) {\n                        f[i] += (i - 2 >= 0 ? f[i - 2] : 1) * 9;\n                    } else if (u == 2) {\n                        f[i] += (i - 2 >= 0 ? f[i - 2] : 1) * 6;\n                    }\n                }\n            } else {\n                int t = (int)(c - '0');\n                if (prev == '*') {\n                    if (t == 0) {\n                        f[i] += (i - 2 >= 0 ? f[i - 2] : 1) * 2;\n                    } else {\n                        // cs[i] 单独作为一个 item\n                        f[i] += f[i - 1];\n                        // cs[i] 与前一个字符共同作为一个 item\n                        if (t <= 6) {\n                            f[i] += (i - 2 >= 0 ? f[i - 2] : 1) * 2;\n                        } else {\n                            f[i] += i - 2 >= 0 ? f[i - 2] : 1;\n                        }\n                    }\n                } else {\n                    int u = (int)(prev - '0');\n                    if (t == 0) {\n                        if (u == 1 || u == 2) {\n                            f[i] += i - 2 >= 0 ? f[i - 2] : 1;\n                        }\n                    } else {\n                        // cs[i] 单独作为一个 item\n                        f[i] += (f[i - 1]);\n                        // cs[i] 与前一个字符共同作为一个 item\n                        if (u == 1) {\n                            f[i] += i - 2 >= 0 ? f[i - 2] : 1;\n                        } else if (u == 2 && t <= 6) {\n                            f[i] += i - 2 >= 0 ? f[i - 2] : 1;\n                        }\n                    }\n                }\n            }\n            f[i] %= mod;\n        }\n        return (int)(f[n - 1]);\n    }\n}\n```\n\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int numDecodings(String s) {\n        int n = s.length() + 1;\n        long[] f = new long[3];\n        f[0] = 1;\n        f[1] = s.charAt(0) == '*' ? 9 : (s.charAt(0) != '0' ? 1 : 0);\n        for (int i = 2; i < n; i++) {\n            char c = s.charAt(i - 1), prev = s.charAt(i - 2);\n            int p1 = (i - 1) % 3, p2 = (i - 2) % 3;\n            long cnt = 0;\n            if (c == '*') {\n                // cs[i] 单独作为一个 item\n                cnt += f[p1] * 9;\n                // cs[i] 与前一个字符共同作为一个 item\n                if (prev == '*') {\n                    cnt += f[p2] * 15;\n                } else {\n                    int u = (int)(prev - '0');\n                    if (u == 1) cnt += f[p2] * 9;\n                    else if (u == 2) cnt += f[p2] * 6;\n                }\n            } else {\n                int t = (int)(c - '0');\n                if (prev == '*') {\n                    if (t == 0) {\n                        cnt += f[p2]* 2;\n                    } else {\n                        // cs[i] 单独作为一个 item\n                        cnt += f[p1];\n                        // cs[i] 与前一个字符共同作为一个 item\n                        if (t <= 6) cnt += f[p2] * 2;\n                        else cnt += f[p2];\n                    }\n                } else {\n                    int u = (int)(prev - '0');\n                    if (t == 0) {\n                        if (u == 1 || u == 2) cnt += f[p2];\n                    } else {\n                        // cs[i] 单独作为一个 item\n                        cnt += f[p1];\n                        // cs[i] 与前一个字符共同作为一个 item\n                        if (u == 1) cnt += f[p2];\n                        else if (u == 2 && t <= 6) cnt += f[p2];\n                    }\n                }\n            }\n            f[i % 3] = cnt % mod;\n        }\n        return (int)(f[(n - 1) % 3]);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:使用「滚动数组」进行优化,复杂度为 $O(1)$,否则为 $O(n)$\n\n---\n\n### 枚举 DP\n\n上述解法之所以复杂,是因为不仅仅要对当前字符 $s[i]$ 分情况讨论,还需要对上一个字符 $s[j]$ 分情况讨论。\n\n事实上,我们可以利用解码对象只有 `A-Z` 来进行枚举。\n\n在从前往后处理字符串 `s` 时,枚举 $s[i]$ 参与构成的解码内容 `item` 是字母 `A-Z` 中哪一个,从而将分情况讨论转变成对应位的字符对比。\n\n代码:\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int numDecodings(String s) {\n        int n = s.length();\n        long[] f = new long[3];\n        f[0] = 1;\n        for (int i = 1; i <= n; i++) {\n            char c = s.charAt(i - 1);\n            int t = c - '0';\n            long cnt = 0;\n            int p1 = (i - 1) % 3, p2 = (i - 2) % 3;\n            // 枚举组成什么 item(A -> 1; B -> 2 ...)\n            for (int item = 1; item <= 26; item++) { \n                if (item < 10) { // 该 item 由一个字符组成\n                    if (c == '*' || t == item) cnt += f[p1];\n                } else { // 该 item 由两个字符组成\n                    if (i - 2 < 0) break;\n                    char prev = s.charAt(i - 2);\n                    int u = prev - '0';\n                    int a = item / 10, b = item % 10;\n                    if ((prev == '*' || u == a) && (t == b || (c == '*' && b != 0))) cnt += f[p2];\n                }\n            }\n            f[i % 3] = cnt % mod;\n        }\n        return (int)(f[n % 3]);\n    }\n}\n```\n* 时间复杂度:$O(n * C)$,其中 $C$ 为解码内容字符集大小,固定为 $26$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.639` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/631-640/640. 求解方程（中等）.md", "url_title": "640. 求解方程", "url": "https://leetcode.cn/problems/solve-the-equation/solution/by-ac_oier-fvee/", "difficulty": "中等", "tags": ["模拟", "数学", "双指针"], "question": "求解一个给定的方程,将 `x` 以字符串 `\"x=#value\"` 的形式返回。该方程仅包含 `'+'` , `'-'` 操作,变量 `x` 和其对应系数。\n\n如果方程没有解,请返回 `\"No solution\"`。如果方程有无限解,则返回 `\"Infinite solutions\"`。\n\n题目保证,如果方程中只有一个解,则 'x' 的值是一个整数。\n\n示例 1:\n```\n输入: equation = \"x+5-3+x=6+x-2\"\n\n输出: \"x=2\"\n```\n示例 2:\n```\n输入: equation = \"x=x\"\n\n输出: \"Infinite solutions\"\n```\n示例 3:\n```\n输入: equation = \"2x=x\"\n\n输出: \"x=0\"\n```\n\n提示:\n* $3 <= equation.length <= 1000$\n* `equation` 只有一个 `'='`.\n* `equation` 方程由整数组成,其绝对值在 $[0, 100]$ 范围内,不含前导零和变量 `'x'` 。", "solution": "### 模拟\n\n为了方便,我们令 `equation` 为 `s`。\n\n由于运算符只有 `+` 和 `-`,因此无须考虑运算优先级,可在遍历过程中进行计算。\n\n使用变量 `x` 和 `num` 分别代指当前运算结果中 $x$ 的系数以及数值部分,从前往后处理 `s` 的每个字符,根据字符类型进行分情况讨论,假设当前处理到的数值为 $s[i]$:\n\n* 若 $s[i] =$ `+/-`:此时影响的是下一个运算数值的正负,修改对应的 `op` 标识;\n* 若 $s[i] =$ `数值`:此时将完整的运算值进行取出(运算值可能是关于 $x$ 的描述,可能是纯数值),假设连续段 $s[i:j - 1]$ 之间为当前运算值,根据 $s[j - 1]$ 是否为字符 `x` 可知,是要将 $s[i:j - 2]$ 的数值累加到变量 `x`,还是将 $s[i:j - 1]$ 的数值累加到变量 `num`;\n* 若 $s[i] =$ `=`:此时代表方程的左边已处理完,将变量 `x` 和 `num` 进行翻转(含义为将左边的运算结果移项到右边),并继续往后处理。\n\n当整个字符串 `s` 处理完后,我们得到最终关于 $x$ 的系数 `x`,以及数值大小 `num`。\n\n根据 `x` 是否为 $0$ 可知答案:\n\n* 若 `x` 为 $0$:此时根据 `num` 是否为 $0$ 可知是 `Infinite solutions`(对应 `num` 为 $0$) 还是 `No solution`(对应 `num` 不为 $0$)\n* 若 `x` 不为 $0$:对 `x` 和 `num` 进行约分后,返回对应答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public String solveEquation(String s) {\n        int x = 0, num = 0, n = s.length();\n        char[] cs = s.toCharArray();\n        for (int i = 0, op = 1; i < n; ) {\n            if (cs[i] == '+') {\n                op = 1; i++;\n            } else if (cs[i] == '-') {\n                op = -1; i++;\n            } else if (cs[i] == '=') {\n                x *= -1; num *= -1; op = 1; i++;\n            } else {\n                int j = i;\n                while (j < n && cs[j] != '+' && cs[j] != '-' && cs[j] != '=') j++;\n                if (cs[j - 1] == 'x') x += (i < j - 1 ? Integer.parseInt(s.substring(i, j - 1)) : 1) * op;\n                else num += Integer.parseInt(s.substring(i, j)) * op;\n                i = j;\n            }\n        }\n        if (x == 0) return num == 0 ? \"Infinite solutions\" : \"No solution\";    \n        else return \"x=\" + (num / -x);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction solveEquation(s: string): string {\n    let x = 0, num = 0, n = s.length\n    for (let i = 0, op = 1; i < n; ) {\n        if (s[i] == '+') {\n            op = 1; i++;\n        } else if (s[i] == '-') {\n            op = -1; i++\n        } else if (s[i] == '=') {\n            x *= -1; num *= -1; op = 1; i++;\n        } else {\n            let j = i\n            while (j < n && s[j] != '+' && s[j] != '-' && s[j] != '=') j++\n            if (s[j - 1] == 'x') x += (i < j - 1 ? Number(s.substring(i, j - 1)) : 1) * op\n            else num += Number(s.substring(i, j)) * op\n            i = j\n        }\n    }\n    if (x == 0) return num == 0 ? \"Infinite solutions\" : \"No solution\"    \n    else return \"x=\" + (num / -x)\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:使用 `charAt` 替换 `toCharArray`。复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.640` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/641-650/641. 设计循环双端队列（中等）.md", "url_title": "641. 设计循环双端队列", "url": "https://leetcode.cn/problems/design-circular-deque/solution/by-ac_oier-fwhm/", "difficulty": "中等", "tags": ["数组", "链表", "数据结构"], "question": "设计实现双端队列。\n\n实现 `MyCircularDeque` 类:\n\n* `MyCircularDeque(int k)` :构造函数,双端队列最大为 $k$ 。\n* `boolean insertFront()`:将一个元素添加到双端队列头部。 如果操作成功返回 `true` ,否则返回 `false` 。\n* `boolean insertLast()` :将一个元素添加到双端队列尾部。如果操作成功返回 `true` ,否则返回 `false` 。\n* `boolean deleteFront()` :从双端队列头部删除一个元素。 如果操作成功返回 `true` ,否则返回 `false` 。\n* `boolean deleteLast()` :从双端队列尾部删除一个元素。如果操作成功返回 `true` ,否则返回 `false` 。\n* `int getFront()` :从双端队列头部获得一个元素。如果双端队列为空,返回 `-1` 。\n* `int getRear()` :获得双端队列的最后一个元素。 如果双端队列为空,返回 `-1` 。\n* `boolean isEmpty()` :若双端队列为空,则返回 `true` ,否则返回 `false`  。\n* `boolean isFull()` :若双端队列满了,则返回 `true` ,否则返回 `false` 。\n\n示例 1:\n```\n输入\n[\"MyCircularDeque\", \"insertLast\", \"insertLast\", \"insertFront\", \"insertFront\", \"getRear\", \"isFull\", \"deleteLast\", \"insertFront\", \"getFront\"]\n[[3], [1], [2], [3], [4], [], [], [], [4], []]\n\n输出\n[null, true, true, true, false, 2, true, true, true, 4]\n\n解释\nMyCircularDeque circularDeque = new MycircularDeque(3); // 设置容量大小为3\ncircularDeque.insertLast(1);\t\t\t        // 返回 true\ncircularDeque.insertLast(2);\t\t\t        // 返回 true\ncircularDeque.insertFront(3);\t\t\t        // 返回 true\ncircularDeque.insertFront(4);\t\t\t        // 已经满了,返回 false\ncircularDeque.getRear();  \t\t\t\t// 返回 2\ncircularDeque.isFull();\t\t\t\t        // 返回 true\ncircularDeque.deleteLast();\t\t\t        // 返回 true\ncircularDeque.insertFront(4);\t\t\t        // 返回 true\ncircularDeque.getFront();\t\t\t\t// 返回 4\n```\n\n提示:\n* $1 <= k <= 1000$\n* $0 <= value <= 1000$\n* `insertFront`, `insertLast`, `deleteFront`, `deleteLast`, `getFront`, `getRear`, `isEmpty`, `isFull`  调用次数不大于 `2000` 次", "solution": "### 基本分析\n\n一个基本的实现,需要满足除构造函数以外复杂度为 $O(k)$ 以外,其余操作均为 $O(1)$。\n\n常规实现包含两种方式:**数组实现** 与 **链表实现**。\n\n其中数组实现可以利用调用次数较小,开成调用次数 $3$ 倍大小,然后从中间开始往两边存储,这样做就不用考虑下标边的界问题;而更为常规的解法是构造一个与限定空间 $k$ 等大的数组,使用两下标并配合坐标转换来做,对于下标自增操作而言,只需要进行「加一取模」即可,而对于下标自减操作,由于考虑负值问题,需要进行「增加限定空间偏移后,进行减一再取模」。\n\n而链表实现则无须考虑额外的下标转换问题,但需要额外定义类。\n\n---\n\n### 数组\n\n使用两坐标 `he` 和 `ta` 分别代表队列头和尾(初始值均为 $0$),使用 `cnt` 记录当前队列元素大小,使用 `k` 记录初始化时指定的空间大小。\n\n对各类操作进行逻辑控制:\n\n* `insertFront` 操作:需要对 `he` 进行自减操作,即 `he = (he + k - 1) % k` 为目标位置,同时对 `cnt` 进行自增;\n* `insertLast` 操作:需要对 `ta` 进行自增操作,但 `ta` 起始指向是待插入位置,因此 `ta` 为目标位置,随后更新 `ta = (ta + 1) % k`,同时对 `cnt` 进行自增;\n* `deleteFront` 操作:需要对 `he` 进行自增操作,直接更新 `he = (he + 1) % k`,同时更新 `cnt` 进行自减;\n* `deleteLast` 操作:需要对 `ta` 进行自减操作,更新 `ta = (ta + k - 1) % k`,同时更新 `cnt` 进行自减;\n* `getFront` 操作:返回 `nums[he]` 即可, 若 `isFull` 为 `True`,返回 `-1`;\n* `getRear` 操作:返回 `nums[ta - 1]`,由于存在负值问题,需要转换为返回 `nums[(ta + k - 1) % k]` 若 `isFull` 为 `True`,返回 `-1`;\n* `isEmpty` 操作:根据 `cnt` 与 `k` 的关系进行返回;\n* `isFull` 操作:根据 `cnt` 与 `k` 的关系进行返回;\n\nJava 代码:\n```Java\nclass MyCircularDeque {\n    int[] nums;\n    int he, ta, cnt, k;\n    public MyCircularDeque(int _k) {\n        k = _k;\n        nums = new int[k];\n    }\n    public boolean insertFront(int value) {\n        if (isFull()) return false;\n        he = (he + k - 1) % k;\n        nums[he] = value; cnt++;\n        return true;\n    }\n    public boolean insertLast(int value) {\n        if (isFull()) return false;\n        nums[ta++] = value; cnt++;\n        ta %= k;\n        return true;\n    }\n    public boolean deleteFront() {\n        if (isEmpty()) return false;\n        he = (he + 1) % k; cnt--;\n        return true;\n    }\n    public boolean deleteLast() {\n        if (isEmpty()) return false;\n        ta = (ta + k - 1) % k; cnt--;\n        return true;\n    }\n    public int getFront() {\n        return isEmpty() ? -1 : nums[he];\n    }\n    public int getRear() {\n        return isEmpty() ? -1 : nums[(ta + k - 1) % k];\n    }\n    public boolean isEmpty() {\n        return cnt == 0;\n    }\n    public boolean isFull() {\n        return cnt == k;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nclass MyCircularDeque {\n    he = 0; ta = 0; cnt = 0; k = 0;\n    nums: number[];\n    constructor(_k: number) {\n        this.k = _k\n        this.he = this.ta = this.cnt = 0\n        this.nums = new Array<number>(this.k)\n    }\n    insertFront(value: number): boolean {\n        if (this.isFull()) return false\n        this.he = (this.he + this.k - 1) % this.k\n        this.nums[this.he] = value\n        this.cnt++\n        return true\n    }\n    insertLast(value: number): boolean {\n        if (this.isFull()) return false\n        this.nums[this.ta++] = value\n        this.ta %= this.k\n        this.cnt++\n        return true\n    }\n    deleteFront(): boolean {\n        if (this.isEmpty()) return false\n        this.he = (this.he + 1) % this.k\n        this.cnt--\n        return true\n    }\n    deleteLast(): boolean {\n        if (this.isEmpty()) return false\n        this.ta = (this.ta + this.k - 1) % this.k\n        this.cnt--\n        return true\n    }\n    getFront(): number {\n        return this.isEmpty() ? -1 : this.nums[this.he]\n    }\n    getRear(): number {\n        return this.isEmpty() ? -1 : this.nums[(this.ta + this.k - 1) % this.k]\n    }\n    isEmpty(): boolean {\n        return this.cnt == 0\n    }\n    isFull(): boolean {\n        return this.cnt == this.k\n    }\n}\n```\n* 时间复杂度:除在初始化函数中构造容器复杂度为 $O(k)$ 以外,其余操作复杂度均为 $O(1)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 链表\n\n创建 `Node` 代指每个操作的元素,使用双向链表来构造循环队列。\n\n各类操作均对应基本的链表操作,不再赘述。\n\nJava 代码:\n```Java\nclass MyCircularDeque {\n    class Node {\n        Node prev, next;\n        int val;\n        Node (int _val) {\n            val = _val;\n        }\n    }\n    int cnt, k;\n    Node he, ta;\n    public MyCircularDeque(int _k) {\n        k = _k;\n        he = new Node(-1); ta = new Node(-1);\n        he.next = ta; ta.prev = he;\n    }\n    public boolean insertFront(int value) {\n        if (isFull()) return false;\n        Node node = new Node(value);\n        node.next = he.next;\n        node.prev = he;\n        he.next.prev = node;\n        he.next = node;\n        cnt++;\n        return true;\n    }\n    public boolean insertLast(int value) {\n        if (isFull()) return false;\n        Node node = new Node(value);\n        node.next = ta;\n        node.prev = ta.prev;\n        ta.prev.next = node;\n        ta.prev = node;\n        cnt++;\n        return true;\n    }\n    public boolean deleteFront() {\n        if (isEmpty()) return false;\n        he.next.next.prev = he;\n        he.next = he.next.next;\n        cnt--;\n        return true;\n    }\n    public boolean deleteLast() {\n        if (isEmpty()) return false;\n        ta.prev.prev.next = ta;\n        ta.prev = ta.prev.prev;\n        cnt--;\n        return true;\n    }\n    public int getFront() {\n        return isEmpty() ? -1 : he.next.val;\n    }\n    public int getRear() {\n        return isEmpty() ? -1 : ta.prev.val;\n    }\n    public boolean isEmpty() {\n        return cnt == 0;\n    }\n    public boolean isFull() {\n        return cnt == k;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nclass TNode {\n    prev: TNode = null; next: TNode = null;\n    val: number = 0;\n    constructor(_val: number) {\n        this.val = _val\n    }\n}\nclass MyCircularDeque {\n    he = null; ta = null;\n    cnt = 0; k = 0;\n    constructor(_k: number) {\n        this.cnt = 0; this.k = _k;\n        this.he = new TNode(-1); this.ta = new TNode(-1);\n        this.he.next = this.ta\n        this.ta.prev = this.he\n    }\n    insertFront(value: number): boolean {\n        if (this.isFull()) return false\n        const node = new TNode(value)\n        node.next = this.he.next\n        node.prev = this.he\n        this.he.next.prev = node\n        this.he.next = node\n        this.cnt++\n        return true\n    }\n    insertLast(value: number): boolean {\n        if (this.isFull()) return false\n        const node = new TNode(value)\n        node.next = this.ta\n        node.prev = this.ta.prev\n        this.ta.prev.next = node\n        this.ta.prev = node\n        this.cnt++\n        return true\n    }\n    deleteFront(): boolean {\n        if (this.isEmpty()) return false\n        this.he.next.next.prev = this.he\n        this.he.next = this.he.next.next\n        this.cnt--\n        return true\n    }\n    deleteLast(): boolean {\n        if (this.isEmpty()) return false\n        this.ta.prev.prev.next = this.ta\n        this.ta.prev = this.ta.prev.prev\n        this.cnt--\n        return true\n    }\n    getFront(): number {\n        return this.isEmpty() ? -1 : this.he.next.val\n    }\n    getRear(): number {\n        return this.isEmpty() ? -1 : this.ta.prev.val\n    }\n    isEmpty(): boolean {\n        return this.cnt == 0\n    }\n    isFull(): boolean {\n        return this.cnt == this.k\n    }\n}\n```\n* 时间复杂度:所有操作复杂度均为 $O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.641` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/641-650/643. 子数组最大平均数 I（简单）.md", "url_title": "643. 子数组最大平均数 I", "url": "https://leetcode-cn.com/problems/maximum-average-subarray-i/solution/hua-dong-chuang-kou-luo-ti-han-mo-ban-by-buo3/", "difficulty": "简单", "tags": ["滑动窗口"], "question": "给定 n 个整数,找出平均数最大且长度为 k 的连续子数组,并输出该最大平均数。\n\n示例:\n```\n输入:[1,12,-5,-6,50,3], k = 4\n\n输出:12.75\n\n解释:最大平均数 (12-5-6+50)/4 = 51/4 = 12.75\n```\n\n提示:\n* 1 <= k <= n <= 30,000。\n* 所给数据范围 [-10,000,10,000]。", "solution": "### 滑动窗口\n\n这是一道道滑动窗口裸题。\n\n以下代码,可以作为滑动窗口模板使用:\n\n1. 初始化将滑动窗口压满,取得第一个滑动窗口的目标值\n\n2. 继续滑动窗口,每往前滑动一次,需要删除一个和添加一个元素\n\n代码:\n```Java\nclass Solution {\n    public double findMaxAverage(int[] nums, int k) {\n        double ans = 0, sum = 0;\n        for (int i = 0; i < k; i++) sum += nums[i];\n        ans = sum / k;\n        for (int i = k; i < nums.length; i++) {\n            sum = sum + nums[i] - nums[i - k]; // int add = nums[i], del = nums[i - k];\n            ans = Math.max(ans, sum / k);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:每个元素最多滑入和滑出窗口一次。复杂度为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.643` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/641-650/645. 错误的集合（简单）.md", "url_title": "645. 错误的集合", "url": "https://leetcode-cn.com/problems/set-mismatch/solution/gong-shui-san-xie-yi-ti-san-jie-ji-shu-s-vnr9/", "difficulty": "简单", "tags": ["模拟", "哈希表", "数学", "桶排序"], "question": "集合 `s` 包含从 `1` 到 `n` 的整数。不幸的是,因为数据错误,导致集合里面某一个数字复制了成了集合里面的另外一个数字的值,导致集合 丢失了一个数字 并且 有一个数字重复 。\n\n给定一个数组 `nums` 代表了集合 `S` 发生错误后的结果。\n\n请你找出重复出现的整数,再找到丢失的整数,将它们以数组的形式返回。\n\n示例 1:\n```\n输入:nums = [1,2,2,4]\n输出:[2,3]\n```\n示例 2:\n```\n输入:nums = [1,1]\n输出:[1,2]\n```\n\n提示:\n* 2 <= nums.length <= $10^4$\n* 1 <= nums[i] <= $10^4$", "solution": "### 计数\n\n一个朴素的做法是,使用「哈希表」统计每个元素出现次数,然后在 $[1, n]$ 查询每个元素的出现次数。\n\n在「哈希表」中出现 $2$ 次的为重复元素,未在「哈希表」中出现的元素为缺失元素。\n\n由于这里数的范围确定为 $[1, n]$,我们可以使用数组来充当「哈希表」,以减少「哈希表」的哈希函数执行和冲突扩容的时间开销。\n\n代码:\n```Java\nclass Solution {\n    public int[] findErrorNums(int[] nums) {\n        int n = nums.length;\n        int[] cnts = new int[n + 1];\n        for (int x : nums) cnts[x]++;\n        int[] ans = new int[2];\n        for (int i = 1; i <= n; i++) {\n            if (cnts[i] == 0) ans[1] = i;\n            if (cnts[i] == 2) ans[0] = i;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 数学\n\n我们还可以利用数值范围为 $[1, n]$,只有一个数重复和只有一个缺失的特性,进行「作差」求解。\n\n* 令 $[1, n]$ 的求和为 $tot$,这部分可以使用「等差数列求和公式」直接得出:$tot = \\frac{n (1 + n)}{2}$ ;\n* 令数组 $nums$ 的求和值为 $sum$,由循环累加可得;\n* 令数组 $sums$ 去重求和值为 $set$,由循环配合「哈希表/数组」累加可得。\n\n最终答案为 `(重复元素, 缺失元素) = (sum-set, tot-set)` 。\n\n代码;\n```Java\nclass Solution {\n    public int[] findErrorNums(int[] nums) {\n        int n = nums.length;\n        int[] cnts = new int[n + 1];\n        int tot = (1 + n) * n / 2;\n        int sum = 0, set = 0;\n        for (int x : nums) {\n            sum += x;\n            if (cnts[x] == 0) set += x;\n            cnts[x] = 1;\n        }\n        return new int[]{sum - set, tot - set};\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 桶排序\n\n因为值的范围在 $[1, n]$,我们可以运用「桶排序」的思路,根据 $nums[i] = i + 1$ 的对应关系使用 $O(n)$ 的复杂度将每个数放在其应该落在的位置里。\n\n然后线性扫描一遍排好序的数组,找到不符合 $nums[i] = i + 1$ 对应关系的位置,从而确定重复元素和缺失元素是哪个值。\n\n代码:\n```Java\nclass Solution {\n    public int[] findErrorNums(int[] nums) {\n        int n = nums.length;\n        for (int i = 0; i < n; i++) {\n            while (nums[i] != i + 1 && nums[nums[i] - 1] != nums[i]) {\n                swap(nums, i, nums[i] - 1);\n            }\n        }\n        int a = -1, b = -1;\n        for (int i = 0; i < n; i++) {\n            if (nums[i] != i + 1) {\n                a = nums[i];\n                b = i == 0 ? 1 : nums[i - 1] + 1;\n            }\n        }\n        return new int[]{a, b};\n    }\n    void swap(int[] nums, int i, int j) {\n        int tmp = nums[i];\n        nums[i] = nums[j];\n        nums[j] = tmp;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.645` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/641-650/646. 最长数对链（中等）.md", "url_title": "646. 最长数对链", "url": "https://leetcode.cn/problems/maximum-length-of-pair-chain/solution/by-ac_oier-z91l/", "difficulty": "中等", "tags": ["贪心", "排序", "二分", "序列 DP", "LIS"], "question": "给出 `n` 个数对。 在每一个数对中,第一个数字总是比第二个数字小。\n\n现在,我们定义一种跟随关系,当且仅当 `b < c` 时,数对 $(c, d)$ 才可以跟在 $(a, b)$ 后面。我们用这种形式来构造一个数对链。\n\n给定一个数对集合,找出能够形成的最长数对链的长度。你不需要用到所有的数对,你可以以任何顺序选择其中的一些数对来构造。\n\n示例:\n```\n输入:[[1,2], [2,3], [3,4]]\n\n输出:2\n\n解释:最长的数对链是 [1,2] -> [3,4]\n```\n\n提示:\n* 给出数对的个数在 $[1, 1000]$ 范围内。", "solution": "### 排序 + 贪心 DP\n\n起始先将 `pairs` 根据第一维排升序(或直接双关键字排升序)。\n\n考虑定义 $f[i]$ 为以 $pairs[i]$ 为结尾的最长数对链长度,所有 $f[i]$ 中的最大值为答案。\n\n不失一般性考虑 $f[i]$ 该如何转移:不难发现 $f[i]$ 为所有满足「下标范围在 $[0, i - 1]$,且 $pairs[j][1] < pairs[i][0]$」条件的 $f[j] + 1$ 的最大值。\n\n但实际上,我们只需要从 $j = i - 1$ 开始往回找,找到第一个满足 $pairs[j][1] < pairs[i][0]$ 的位置 $j$ 即可。\n\n容易证明该做法的正确性:**假设贪心解(该做法)找到的位置 $j$ 不是最优位置,即存在比 $j$ 更小的合法下标 $j'$ 满足 $f[j'] > f[j]$。根据我们的排序规则必然有 $pairs[j'][0] <= pairs[j][0]$ 的性质,则可知 $pairs[j]$ 必然可以代替 $pairs[j']$ 接在原本以 $pairs[j']$ 为结尾的最优数链上(最优数链长度不变,结果不会变差),则至少有 $f[j'] = f[j]$。**\n\n代码:\n```Java\nclass Solution {\n    public int findLongestChain(int[][] pairs) {\n        Arrays.sort(pairs, (a,b)->a[0]-b[0]);\n        int n = pairs.length, ans = 1;\n        int[] f = new int[n];\n        for (int i = 0; i < n; i++) {\n            f[i] = 1;\n            for (int j = i - 1; j >= 0 && f[i] == 1; j--) {\n                if (pairs[j][1] < pairs[i][0]) f[i] = f[j] + 1;\n            }\n            ans = Math.max(ans, f[i]);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序的复杂度为 $O(n\\log{n})$;不考虑剪枝效果 `DP` 复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 排序 + 贪心 DP(优化转移)\n\n根据上述分析,我们知道对于一个特定的 $pairs[i]$ 而言,其所有合法(满足条件 $pairs[j][1] < pairs[i][0]$)的前驱状态 $f[j]$ 必然是非单调递增的。\n\n根据 `LIS` 问题的贪心解的思路,我们可以额外使用一个数组记录下特定长度数链的最小结尾值,从而实现二分找前驱状态。\n\n具体的,创建 $g$ 数组,其中 $g[len] = x$ 代表数链长度为 $len$ 时结尾元素的第二维最小值为 $x$。\n\n如此一来,当我们要找 $f[i]$ 的前驱状态时,等价于在 $g$ 数组中找满足「小于 $pairs[i][0]$」的最大下标。同时,我们不再需要显式维护 $f$ 数组,只需要边转移变更新答案即可。\n\n> **不了解 `LIS` 问题的同学可以看前置 🧀 : [LCS 问题与 LIS 问题的相互关系,以及 LIS 问题的最优解证明](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487814&idx=1&sn=e33023c2d474ff75af83eda1c4d01892) 🎉🎉🎉**\n\n代码:\n```Java\nclass Solution {\n    public int findLongestChain(int[][] pairs) {\n        Arrays.sort(pairs, (a,b)->a[0]-b[0]);\n        int n = pairs.length, ans = 1;\n        int[] g = new int[n + 10];\n        Arrays.fill(g, 0x3f3f3f3f);\n        for (int i = 0; i < n; i++) {\n            int l = 1, r = i + 1;\n            while (l < r) {\n                int mid = l + r >> 1;\n                if (g[mid] >= pairs[i][0]) r = mid;\n                else l = mid + 1;\n            }\n            g[r] = Math.min(g[r], pairs[i][1]);\n            ans = Math.max(ans, r);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序的复杂度为 $O(n\\log{n})$;`DP` 复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.646` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/641-650/648. 单词替换（中等）.md", "url_title": "648. 单词替换", "url": "https://leetcode.cn/problems/replace-words/solution/by-ac_oier-jecf/", "difficulty": "中等", "tags": ["字典树"], "question": "在英语中,我们有一个叫做 词根(`root`) 的概念,可以词根后面添加其他一些词组成另一个较长的单词——我们称这个词为 继承词(`successor`)。例如,词根`an`,跟随着单词 `other`(其他),可以形成新的单词 `another`(另一个)。\n\n现在,给定一个由许多词根组成的词典 `dictionary` 和一个用空格分隔单词形成的句子 `sentence`。你需要将句子中的所有继承词用词根替换掉。如果继承词有许多可以形成它的词根,则用最短的词根替换它。\n\n你需要输出替换之后的句子。\n\n示例 1:\n```\n输入:dictionary = [\"cat\",\"bat\",\"rat\"], sentence = \"the cattle was rattled by the battery\"\n\n输出:\"the cat was rat by the bat\"\n```\n示例 2:\n```\n输入:dictionary = [\"a\",\"b\",\"c\"], sentence = \"aadsfasf absbs bbab cadsfafs\"\n\n输出:\"a a b c\"\n```\n\n提示:\n* $1 <= dictionary.length <= 1000$\n* $1 <= dictionary[i].length <= 100$\n* `dictionary[i]` 仅由小写字母组成。\n* $1 <= sentence.length <= 10^6$\n* `sentence` 仅由小写字母和空格组成。\n* `sentence` 中单词的总量在范围 $[1, 1000]$ 内。\n* `sentence` 中每个单词的长度在范围 $[1, 1000]$ 内。\n* `sentence` 中单词之间由一个空格隔开。\n* `sentence` 没有前导或尾随空格。", "solution": "### 基本分析\n\n这是一道 `Trie` 的模板题,还不了解 `Trie` 的同学可以先看前置 🧀:[【设计数据结构】实现 Trie (前缀树)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089)\n\n前置 🧀 通过图解形式讲解了 `Trie` 的结构与原理,以及提供了两种实现 `Trie` 的方式。\n\n回到本题,为了方便,我们令 `ds` 为 `dictionary`,令 `s` 为 `sentence`。\n\n---\n\n### 二维数组 \n\n一个比较习惯的做法,是使用「二维数组」来实现 `Trie`,配合 `static` 优化,可以有效控制 `new` 的次数,耗时相对稳定。\n\n考虑两个 `Trie` 的基本操作:\n\n* `add` 操作:变量入参字符串 `s`,将字符串中的每位字符映射到 $[0, 25]$,同时为了能够方便查询某个字符串(而不只是某个前缀)是否曾经存入过 `Trie` 中,额外使用一个布尔数组 `isEnd` 记录某个位置是否为单词结尾。\n* `query` 操作:对变量入参字符串 `s` 进行遍历,如果在字典树不存在该字符串的任何前缀,直接返回 `s`,否则返回首个出现(最短)的前缀。\n\n至于二维数组的大小估算,可以直接开成 $N \\times C$,其中 $N$ 为要插入到 `Trie` 中的字符总数,$C$ 为对应的字符集大小。在 $N \\times C$ 没有 `MLE` 风险时,可以直接开这么多;而当 $N \\times C$ 较大(超过 $1e7$,甚至 $1e8$ 时),可以适当将 $N \\times C$ 中的 $N$ 减少,使得总空间在 $1e7$ 左右,因为实际上由于二维数组中的某些行中会存储一个字符以上,实际上我们用不到这么多行。\n\n代码(不使用 `static` 优化,耗时增加十倍):\n```Java\nclass Solution {\n    static int N = 100000, M = 26;\n    static int[][] tr = new int[N][M];\n    static boolean[] isEnd = new boolean[N * M];\n    static int idx;\n    void add(String s) {\n        int p = 0;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (tr[p][u] == 0) tr[p][u] = ++idx;\n            p = tr[p][u];\n        }\n        isEnd[p] = true;\n    }\n    String query(String s) {\n        for (int i = 0, p = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (tr[p][u] == 0) break;\n            if (isEnd[tr[p][u]]) return s.substring(0, i + 1);\n            p = tr[p][u];\n        }\n        return s;\n    }\n    public String replaceWords(List<String> ds, String s) {\n        for (int i = 0; i <= idx; i++) {\n            Arrays.fill(tr[i], 0);\n            isEnd[i] = false;\n        }\n        for (String d : ds) add(d);\n        StringBuilder sb = new StringBuilder();\n        for (String str : s.split(\" \")) sb.append(query(str)).append(\" \");\n        return sb.substring(0, sb.length() - 1);\n    }\n}\n```\n* 时间复杂度:令 $n = \\sum_{i = 0}^{ds.length - 1} ds[i].length$,$m$ 为 `s` 长度,复杂度为 $O(n + m)$\n* 空间复杂度:$O(n \\times C)$,其中 $C = 26$ 为字符集大小\n\n---\n\n### TrieNode\n\n另外一个能够有效避免「估数组大小」操作的方式,是使用 `TrieNode` 的方式实现 `Trie`:每次使用到新的格子再触发 `new` 操作。\n\n至于为什么有了 `TrieNode` 的方式,我还是会采用「二维数组」优先的做法,在 [知乎](https://zhuanlan.zhihu.com/p/531180364) 上有同学问过我类似的问题,只不过原问题是「为什么有了动态开点线段树,直接 `build` 出 $4n$ 空间的做法仍有意义」,这对应到本题使用「二维数组」还是「TrieNode」是一样的道理:\n\n除非某些语言在启动时,采用虚拟机的方式,并且预先分配了足够的内存,否则所有的 `new` 操作都需要反映到 os 上,而在 `linux` 分配时需要遍历红黑树,因此即使是总空间一样,一次性的 `new` 要比多次小空间的 `new` 更省时间,同时集中性的 `new` 也比分散性的 `new` 操作要更快,这也就是为什么我们不无脑使用 `TrieNode` 的原因。\n\n代码:\n```Java\nclass Solution {\n    class Node {\n        boolean isEnd;\n        Node[] tns = new Node[26];\n    }\n    Node root = new Node();\n    void add(String s) {\n        Node p = root;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (p.tns[u] == null) p.tns[u] = new Node();\n            p = p.tns[u];\n        }\n        p.isEnd = true;\n    }\n    String query(String s) {\n        Node p = root;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (p.tns[u] == null) break;\n            if (p.tns[u].isEnd) return s.substring(0, i + 1);\n            p = p.tns[u];\n        }\n        return s;\n    }\n    public String replaceWords(List<String> ds, String s) {\n        for (String str : ds) add(str);\n        StringBuilder sb = new StringBuilder();\n        for (String str : s.split(\" \")) sb.append(query(str)).append(\" \");\n        return sb.substring(0, sb.length() - 1);\n    }\n}\n```\n* 时间复杂度:令 $n = \\sum_{i = 0}^{ds.length - 1} ds[i].length$,$m$ 为 `s` 长度,复杂度为 $O(n + m)$\n* 空间复杂度:$O(n \\times C)$,其中 $C = 26$ 为字符集大小\n\n---\n\n### 加餐\n\n**今天额外增加一道更贴合笔试面试的加餐题 : [结合 DFS 的 Trie 运用题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492188&idx=1&sn=a1436d1ffe2b8200a36c3196ca1c7ed1) 🎉🎉**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.648` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/641-650/649. Dota2 参议院（中等）.md", "url_title": "649. Dota2 参议院", "url": "https://leetcode.cn/problems/dota2-senate/solutions/2402101/gong-shui-san-xie-jie-he-shu-ju-jie-gou-x581k/", "difficulty": "中等", "tags": ["贪心", "红黑树", "有序集合", "队列"], "question": "Dota2 的世界里有两个阵营:`Radiant`(天辉)和 `Dire`(夜魇)。\n\nDota2 参议院由来自两派的参议员组成,现在参议院希望对一个 Dota2 游戏里的改变作出决定,他们以一个基于轮为过程的投票进行。\n\n在每一轮中,每一位参议员都可以行使两项权利中的一项:\n\n* 禁止一名参议员的权利:参议员可以让另一位参议员在这一轮和随后的几轮中丧失所有的权利 。\n* 宣布胜利:如果参议员发现有权利投票的参议员都是同一个阵营的,他可以宣布胜利并决定在游戏中的有关变化。\n\n给你一个字符串 `s` 代表每个参议员的阵营。字母 `'R'` 和 `'D'`分别代表了 `Radiant`(天辉)和 `Dire`(夜魇)。\n\n然后,如果有 `n` 个参议员,给定字符串的大小将是 `n`。\n\n以轮为基础的过程从给定顺序的第一个参议员开始到最后一个参议员结束,这一过程将持续到投票结束,所有失去权利的参议员将在过程中被跳过。\n\n假设每一位参议员都足够聪明,会为自己的政党做出最好的策略,你需要预测哪一方最终会宣布胜利并在 Dota2 游戏中决定改变。\n\n输出应该是 `\"Radiant\"` 或 `\"Dire\"`。\n\n示例 1:\n```\n输入:s = \"RD\"\n\n输出:\"Radiant\"\n\n解释:\n第 1 轮时,第一个参议员来自 Radiant 阵营,他可以使用第一项权利让第二个参议员失去所有权利。\n这一轮中,第二个参议员将会被跳过,因为他的权利被禁止了。\n第 2 轮时,第一个参议员可以宣布胜利,因为他是唯一一个有投票权的人。\n```\n示例 2:\n```\n输入:s = \"RDD\"\n\n输出:\"Dire\"\n\n解释:\n第 1 轮时,第一个来自 Radiant 阵营的参议员可以使用第一项权利禁止第二个参议员的权利。\n这一轮中,第二个来自 Dire 阵营的参议员会将被跳过,因为他的权利被禁止了。\n这一轮中,第三个来自 Dire 阵营的参议员可以使用他的第一项权利禁止第一个参议员的权利。\n因此在第二轮只剩下第三个参议员拥有投票的权利,于是他可以宣布胜利\n```\n\n提示:\n* $n = s.length$\n* $1 <= n <= 10^4$\n* `senate[i]` 为 `'R'` 或 `'D'`", "solution": "### 基本分析\n\n整理题意:每次选择对方的一个成员进行消除,直到所有剩余成员均为我方时,宣布胜利。\n\n由于每个对方成员执行权利都意味着我方损失一名成员,因此最佳方式是 **尽量让对方的权利不执行,或延迟执行(意味着我方有更多执行权利的机会)**。因此,最优决策为 **每次都选择对方的下一个行权成员进行消除**。\n\n---\n\n### 贪心\n\n这个找“最近一个”对方行权成员的操作既可以使用「有序集合」来做,也可以使用「循环队列」来做。\n\n先说使用「有序集合」的做法。\n\n起始我们先将 `s` 中的 `Radiant` 和 `Dire` 分别存入有序集合 `rs` 和 `ds` 当中,然后从前往后模拟消除过程,过程中使用 `idx` 代表当前处理到的成员下标,使用 `set` 记录当前哪些成员已被消除。\n\n当轮到 `s[idx]` 行权时(若 `s[idx]` 已被消除,则跳过本轮),从对方的有序队列中取出 **首个大于等于 `idx` 的下标**(取出代表移除);若对方的有序序列不存在该下标,而行权过程又是循环进行的,说明此时下一个行权的对方成员是 **首个大于等于 $0$** 的下标,我们对其进行取出消除,随后往后继续决策。\n\nJava 代码:\n```Java\nclass Solution {\n    public String predictPartyVictory(String s) {\n        TreeSet<Integer> rs = new TreeSet<>(), ds = new TreeSet<>();\n        int n = s.length();\n        for (int i = 0; i < n; i++) {\n            if (s.charAt(i) == 'R') rs.add(i);\n            else ds.add(i);\n        }\n        Set<Integer> set = new HashSet<>();\n        int idx = 0;\n        while (rs.size() != 0 && ds.size() != 0) {\n            if (!set.contains(idx)) {\n                TreeSet<Integer> temp = null;\n                if (s.charAt(idx) == 'R') temp = ds;\n                else temp = rs;\n                Integer t = temp.ceiling(idx);\n                if (t == null) t = temp.ceiling(0);\n                set.add(t);\n                temp.remove(t);\n            }\n            idx = (idx + 1) % n;\n        }\n        return rs.size() != 0 ? \"Radiant\" : \"Dire\";\n    }\n}\n```\n不难发现,虽然将所有成员存入有序集合和取出的复杂度均为 $O(n\\log{n})$,但整体复杂度仍是大于 $O(n\\log{n})$。\n\n因为我们在每一轮的消除中,从 `idx` 位置找到下一个决策者,总是需要遍历那些已被消除的位置,而该无效遍历操作可使用「循环队列」优化。\n\n---\n\n### 优化\n\n使用循环队列 `rd` 和 `dd` 来取代有序集合 `rs` 和 `ds`。起始将各个成员分类依次入队,每次从两队列队头中取出成员,假设从 `rs` 中取出成员下标为 `a`,从 `dd` 中取出成员下标为 `b`,对两者进行比较:\n\n* 若有 `a < b`,说明 `a` 先行权,且其消除对象为 `b`,`a` 行权后需等到下一轮,对其进行大小为 $n$ 的偏移后重新添加到 `rd` 尾部(含义为本次行权后需要等到下一轮);\n* 若有 `b < a`,同理,将 `a` 消除后,对 `b` 进行大小为 $n$ 的偏移后重新添加到 `dd` 尾部。\n\nJava 代码:\n```Java\nclass Solution {\n    public String predictPartyVictory(String s) {\n        Deque<Integer> rd = new ArrayDeque<>(), dd = new ArrayDeque<>();\n        int n = s.length();\n        for (int i = 0; i < n; i++) {\n            if (s.charAt(i) == 'R') rd.addLast(i);\n            else dd.addLast(i);\n        }\n        while (rd.size() != 0 && dd.size() != 0) {\n            int a = rd.pollFirst(), b = dd.pollFirst();\n            if (a < b) rd.addLast(a + n);\n            else dd.addLast(b + n);\n        }\n        return rd.size() != 0 ? \"Radiant\" : \"Dire\";\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    string predictPartyVictory(string s) {\n        deque<int> rd, dd;\n        int n = s.length();\n        for (int i = 0; i < n; i++) {\n            if (s[i] == 'R') rd.push_back(i);\n            else dd.push_back(i);\n        }\n        while (!rd.empty() && !dd.empty()) {\n            int a = rd.front(), b = dd.front();\n            rd.pop_front();\n            dd.pop_front();\n            if (a < b) rd.push_back(a + n);\n            else dd.push_back(b + n);\n        }\n        return !rd.empty() ? \"Radiant\" : \"Dire\";\n    }\n};\n```\nPython 代码:\n```Python\nfrom collections import deque\n\nclass Solution:\n    def predictPartyVictory(self, s: str) -> str:\n        rd, dd = deque(), deque()\n        n = len(s)\n        for i in range(n):\n            if s[i] == 'R':\n                rd.append(i)\n            else:\n                dd.append(i)\n        while rd and dd:\n            a, b = rd.popleft(), dd.popleft()\n            if a < b:\n                rd.append(a + n)\n            else:\n                dd.append(b + n)\n        return \"Radiant\" if rd else \"Dire\"\n```\nTypeScript 代码:\n```TypeScript\nfunction predictPartyVictory(s: string): string {\n    let rd: Array<number> = [], dd: Array<number> = [];\n    let n: number = s.length;\n    for (let i = 0; i < n; i++) {\n        if (s.charAt(i) == 'R') rd.push(i);\n        else dd.push(i);\n    }\n    while (rd.length != 0 && dd.length != 0) {\n        let a: number = rd.shift()!, b: number = dd.shift()!;\n        if (a < b) rd.push(a + n);\n        else dd.push(b + n);\n    }\n    return rd.length != 0 ? \"Radiant\" : \"Dire\";  \n};\n```\n* 时间复杂度:将所有成员进行分队,复杂度为 $O(n)$;每个回合会有一名成员被消除,最多有 $n$ 个成员,复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.649` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/641-650/650. 只有两个键的键盘（中等）.md", "url_title": "650. 只有两个键的键盘", "url": "https://leetcode-cn.com/problems/2-keys-keyboard/solution/gong-shui-san-xie-yi-ti-san-jie-dong-tai-f035/", "difficulty": "中等", "tags": ["动态规划", "线性 DP", "数学", "打表"], "question": "最初记事本上只有一个字符 `'A'` 。你每次可以对这个记事本进行两种操作:\n\n* `Copy All(复制全部)`:复制这个记事本中的所有字符(不允许仅复制部分字符)。\n* `Paste(粘贴)`:粘贴 上一次 复制的字符。\n\n给你一个数字 `n` ,你需要使用最少的操作次数,在记事本上输出 恰好 `n` 个 `'A'` 。返回能够打印出 `n` 个 `'A'` 的最少操作次数。\n\n示例 1:\n```\n输入:3\n\n输出:3\n\n解释:\n最初, 只有一个字符 'A'。\n第 1 步, 使用 Copy All 操作。\n第 2 步, 使用 Paste 操作来获得 'AA'。\n第 3 步, 使用 Paste 操作来获得 'AAA'。\n```\n示例 2:\n```\n输入:n = 1\n\n输出:0\n```\n\n提示:\n* $1 <= n <= 1000$", "solution": "### 动态规划\n\n**定义 $f[i][j]$ 为经过最后一次操作后,当前记事本上有 $i$ 个字符,粘贴板上有 $j$ 个字符的最小操作次数。**\n\n由于我们粘贴板的字符必然是经过 `Copy All` 操作而来,因此对于一个合法的 $f[i][j]$ 而言,必然有 $j <= i$。\n\n不失一般性地考虑 $f[i][j]$ 该如何转移:\n\n* 最后一次操作是 `Paste` 操作:此时粘贴板的字符数量不会发生变化,即有 $f[i][j] = f[i - j][j] + 1$;\n\n* 最后一次操作是 `Copy All` 操作:那么此时的粘贴板的字符数与记事本上的字符数相等(满足 $i = j$),此时的 $f[i][j] = \\min(f[i][x] + 1), 0 \\leq x < i$。\n\n我们发现最后一个合法的 $f[i][j]$(满足 $i = j$)依赖与前面 $f[i][j]$(满足 $j < i$)。\n\n因此实现上,我们可以使用一个变量 $min$ 保存前面转移的最小值,用来更新最后的 $f[i][j]$。\n\n再进一步,我们发现如果 $f[i][j]$ 的最后一次操作是由 `Paste` 而来,原来粘贴板的字符数不会超过 $i / 2$,因此在转移 $f[i][j]$(满足 $j < i$)时,其实只需要枚举 $[0, i/2]$ 即可。\n\n代码:\n```Java\nclass Solution {\n    int INF = 0x3f3f3f3f;\n    public int minSteps(int n) {\n        int[][] f = new int[n + 1][n + 1];\n        for (int i = 0; i <= n; i++) {\n            for (int j = 0; j <= n; j++) {\n                f[i][j] = INF;\n            }\n        }\n        f[1][0] = 0; f[1][1] = 1;\n        for (int i = 2; i <= n; i++) {\n            int min = INF;\n            for (int j = 0; j <= i / 2; j++) {\n                f[i][j] = f[i - j][j] + 1;\n                min = Math.min(min, f[i][j]);\n            }\n            f[i][i] = min + 1;\n        }\n        int ans = INF;\n        for (int i = 0; i <= n; i++) ans = Math.min(ans, f[n][i]);\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 数学\n\n如果我们将「$1$ 次 `Copy All` + $x$ 次 `Paste`」看做一次“动作”的话。\n\n那么 **一次“动作”所产生的效果就是将原来的字符串变为原来的 $x + 1$ 倍**。\n\n最终的最小操作次数方案可以等价以下操作流程:\n\n1. 起始对长度为 $1$ 的记事本字符进行 $1$ 次 `Copy All` + $k_1 - 1$ 次 `Paste` 操作(消耗次数为 $k_1$,得到长度为 $k_1$ 的记事本长度);\n2. 对长度为为 $k_1$ 的记事本字符进行 $1$ 次 `Copy All` + $k_2 - 1$ 次 `Paste` 操作(消耗次数为 $k_1 + k_2$,得到长度为 $k_1 * k_2$ 的记事本长度)\n...\n\n最终经过 $k$ 次“动作”之后,得到长度为 $n$ 的记事本长度,即有:\n\n$$\nn = k_1 * k_2 * ... * k_x\n$$\n\n问题转化为:如何对 $n$ 进行拆分,可以使得 $k_1 + k_2 + ... + k_x$ 最小。\n\n对于任意一个 $k_i$(合数)而言,根据定理 $a * b >= a + b$ 可知进一步的拆分必然不会导致结果变差。\n\n因此,我们只需要使用「试除法」对 $n$ 执行分解质因数操作,累加所有的操作次数,即可得到答案。\n\n代码:\n```Java\nclass Solution {\n    public int minSteps(int n) {\n        int ans = 0;\n        for (int i = 2; i * i <= n; i++) {\n            while (n % i == 0) {\n                ans += i;\n                n /= i;\n            }\n        }\n        if (n != 1) ans += n;\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(\\sqrt{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 打表\n\n我们发现,对于某个 $minSteps(i)$ 而言为定值,且数据范围只有 $1000$,因此考虑使用打表来做。\n\n代码:\n```Java\nclass Solution {\n    static int N = 1010;\n    static int[] g = new int[N];\n    static {\n        for (int k = 2; k < N; k++) {\n            int cnt = 0, n = k;\n            for (int i = 2; i * i <= n; i++) {\n                while (n % i == 0) {\n                    cnt += i;\n                    n /= i;\n                }\n            }\n            if (n != 1) cnt += n;\n            g[k] = cnt;\n        }\n        // System.out.println(Arrays.toString(g)); // 输出打表结果\n    }\n    public int minSteps(int n) {\n        return g[n];\n    }\n}\n```\n\n```Java\nclass Solution {\n    static int[] g = new int[]{0, 0, 2, 3, 4, 5, 5, 7, 6, 6, 7, 11, 7, 13, 9, 8, 8, 17, 8, 19, 9, 10, 13, 23, 9, 10, 15, 9, 11, 29, 10, 31, 10, 14, 19, 12, 10, 37, 21, 16, 11, 41, 12, 43, 15, 11, 25, 47, 11, 14, 12, 20, 17, 53, 11, 16, 13, 22, 31, 59, 12, 61, 33, 13, 12, 18, 16, 67, 21, 26, 14, 71, 12, 73, 39, 13, 23, 18, 18, 79, 13, 12, 43, 83, 14, 22, 45, 32, 17, 89, 13, 20, 27, 34, 49, 24, 13, 97, 16, 17, 14, 101, 22, 103, 19, 15, 55, 107, 13, 109, 18, 40, 15, 113, 24, 28, 33, 19, 61, 24, 14, 22, 63, 44, 35, 15, 15, 127, 14, 46, 20, 131, 18, 26, 69, 14, 23, 137, 28, 139, 16, 50, 73, 24, 14, 34, 75, 17, 41, 149, 15, 151, 25, 23, 20, 36, 20, 157, 81, 56, 15, 30, 14, 163, 45, 19, 85, 167, 16, 26, 24, 25, 47, 173, 34, 17, 19, 62, 91, 179, 15, 181, 22, 64, 29, 42, 36, 28, 51, 16, 26, 191, 15, 193, 99, 21, 18, 197, 19, 199, 16, 70, 103, 36, 24, 46, 105, 29, 21, 30, 17, 211, 57, 74, 109, 48, 15, 38, 111, 76, 20, 30, 42, 223, 17, 16, 115, 227, 26, 229, 30, 21, 35, 233, 21, 52, 63, 82, 26, 239, 16, 241, 24, 15, 65, 19, 46, 32, 37, 86, 17, 251, 17, 34, 129, 25, 16, 257, 48, 44, 22, 35, 133, 263, 20, 58, 28, 92, 71, 269, 16, 271, 25, 23, 139, 21, 30, 277, 141, 37, 18, 281, 52, 283, 75, 27, 26, 48, 16, 34, 36, 100, 77, 293, 19, 64, 43, 20, 151, 36, 17, 50, 153, 104, 27, 66, 25, 307, 22, 106, 38, 311, 22, 313, 159, 18, 83, 317, 58, 40, 17, 110, 32, 36, 16, 23, 165, 112, 47, 54, 21, 331, 87, 43, 169, 72, 18, 337, 28, 116, 26, 42, 27, 21, 49, 31, 175, 347, 36, 349, 19, 22, 21, 353, 64, 76, 93, 27, 181, 359, 17, 38, 183, 25, 24, 78, 66, 367, 31, 47, 44, 60, 38, 373, 30, 18, 53, 42, 18, 379, 28, 130, 193, 383, 17, 23, 195, 49, 101, 389, 23, 40, 20, 134, 199, 84, 21, 397, 201, 29, 18, 401, 72, 44, 105, 17, 38, 48, 26, 409, 48, 140, 107, 66, 31, 88, 23, 142, 32, 419, 19, 421, 213, 53, 59, 27, 76, 68, 111, 27, 50, 431, 17, 433, 40, 37, 113, 42, 78, 439, 22, 20, 32, 443, 44, 94, 225, 152, 19, 449, 18, 52, 117, 154, 229, 25, 28, 457, 231, 26, 32, 461, 23, 463, 37, 39, 235, 467, 23, 74, 54, 160, 65, 54, 84, 29, 28, 59, 241, 479, 18, 50, 243, 33, 26, 102, 17, 487, 67, 166, 21, 491, 48, 46, 34, 22, 39, 78, 88, 499, 19, 170, 253, 503, 19, 106, 36, 29, 131, 509, 27, 80, 18, 28, 259, 108, 50, 58, 46, 176, 24, 521, 37, 523, 135, 20, 265, 48, 22, 46, 60, 65, 30, 54, 94, 112, 73, 182, 271, 25, 18, 541, 273, 184, 27, 114, 25, 547, 141, 67, 23, 48, 32, 86, 279, 45, 143, 557, 39, 56, 20, 31, 283, 563, 54, 118, 285, 19, 77, 569, 29, 571, 28, 194, 50, 33, 18, 577, 36, 196, 38, 90, 102, 64, 79, 24, 295, 587, 21, 50, 66, 200, 45, 593, 22, 29, 153, 202, 38, 599, 19, 601, 52, 73, 155, 27, 106, 607, 29, 39, 68, 60, 27, 613, 309, 49, 24, 617, 108, 619, 40, 32, 313, 96, 24, 20, 315, 33, 161, 54, 20, 631, 85, 214, 319, 132, 60, 27, 42, 77, 19, 641, 112, 643, 34, 51, 38, 647, 18, 70, 25, 41, 167, 653, 114, 136, 49, 79, 56, 659, 23, 661, 333, 33, 89, 31, 45, 52, 171, 226, 74, 72, 20, 673, 339, 19, 30, 677, 118, 104, 28, 230, 44, 683, 29, 142, 23, 232, 51, 66, 33, 691, 177, 24, 349, 144, 38, 58, 351, 236, 21, 701, 24, 56, 23, 55, 355, 108, 66, 709, 78, 85, 95, 54, 29, 29, 183, 242, 361, 719, 19, 110, 40, 244, 185, 39, 27, 727, 26, 18, 80, 60, 68, 733, 369, 22, 33, 78, 49, 739, 46, 35, 62, 743, 40, 154, 375, 89, 32, 114, 20, 751, 55, 254, 44, 156, 20, 757, 381, 37, 30, 761, 132, 116, 195, 28, 385, 72, 19, 769, 25, 260, 197, 773, 51, 41, 103, 47, 391, 60, 25, 82, 42, 38, 22, 162, 136, 787, 201, 266, 86, 120, 23, 74, 399, 61, 203, 797, 31, 64, 20, 95, 403, 84, 74, 35, 46, 272, 107, 809, 19, 811, 40, 274, 50, 168, 28, 62, 411, 26, 50, 821, 142, 823, 109, 24, 68, 827, 33, 829, 90, 280, 25, 31, 144, 172, 34, 40, 421, 839, 21, 58, 423, 284, 215, 31, 55, 29, 61, 286, 29, 60, 78, 853, 70, 30, 113, 857, 29, 859, 52, 51, 433, 863, 19, 178, 435, 37, 42, 90, 39, 80, 115, 103, 44, 22, 80, 877, 441, 296, 24, 881, 22, 883, 34, 67, 445, 887, 46, 134, 96, 23, 227, 66, 154, 184, 21, 39, 451, 60, 20, 70, 54, 53, 119, 186, 156, 907, 231, 107, 27, 911, 30, 94, 459, 69, 233, 138, 28, 919, 34, 310, 463, 84, 25, 47, 465, 109, 39, 929, 41, 33, 237, 314, 469, 33, 25, 937, 76, 316, 56, 941, 162, 64, 67, 21, 56, 947, 86, 86, 31, 320, 30, 953, 61, 196, 243, 43, 481, 144, 20, 62, 52, 113, 245, 198, 35, 967, 28, 39, 104, 971, 19, 146, 489, 26, 69, 977, 168, 100, 23, 115, 493, 983, 50, 202, 48, 57, 36, 66, 24, 991, 41, 334, 80, 204, 90, 997, 501, 46, 21, 31, 172, 76, 255, 75, 505, 72, 21, 1009};\n    public int minSteps(int n) {\n        return g[n];\n    }\n}\n```\n* 时间复杂度:将打表逻辑配合 `static` 交给 OJ 执行,复杂度为 $O(C * \\sqrt{C})$,$C$ 为常数,固定为 $1010$;将打表逻辑放到本地执行,复杂度为 $O(1)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.650` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/651-660/652. 寻找重复的子树（中等）.md", "url_title": "652. 寻找重复的子树", "url": "https://leetcode.cn/problems/find-duplicate-subtrees/solution/by-ac_oier-ly58/", "difficulty": "中等", "tags": ["二叉树", "哈希表", "DFS"], "question": "给定一棵二叉树 `root`,返回所有重复的子树。\n\n对于同一类的重复子树,你只需要返回其中任意一棵的根结点即可。\n\n如果两棵树具有相同的结构和相同的结点值,则它们是重复的。\n\n示例 1:\n\n```\n输入:root = [1,2,3,4,null,2,4,null,null,4]\n\n输出:[[2,4],[4]]\n```\n示例 2:\n\n```\n输入:root = [2,1,1]\n\n输出:[[1]]\n```\n示例 3:\n\n```\n输入:root = [2,2,2,3,null,3,null]\n\n输出:[[2,3],[3]]\n```\n\n提示:\n* 树中的结点数在 $[1,10^4]$ 范围内。\n* $-200 <= Node.val <= 200$", "solution": "### DFS + 哈希表\n\n设计递归函数 `String dfs(TreeNode root)`,含义为返回以传入参数 `root` 为根节点的子树所对应的指纹标识。\n\n对于标识的设计只需使用 `\"_\"` 分割不同的节点值,同时对空节点进行保留(定义为空串 `\" \"`)即可。\n\n使用哈希表记录每个标识(子树)出现次数,当出现次数为 $2$(首次判定为重复出现)时,将该节点加入答案。\n\nJava 代码:\n```Java\nclass Solution {\n    Map<String, Integer> map = new HashMap<>();\n    List<TreeNode> ans = new ArrayList<>();\n    public List<TreeNode> findDuplicateSubtrees(TreeNode root) {\n        dfs(root);\n        return ans;\n    }\n    String dfs(TreeNode root) {\n        if (root == null) return \" \";\n        StringBuilder sb = new StringBuilder();\n        sb.append(root.val).append(\"_\");\n        sb.append(dfs(root.left)).append(dfs(root.right));\n        String key = sb.toString();\n        map.put(key, map.getOrDefault(key, 0) + 1);\n        if (map.get(key) == 2) ans.add(root);\n        return key;\n    }\n}\n```\nTypescript 代码:\n```Typescript\nlet ans: Array<TreeNode>\nlet map: Map<string, number>\nfunction findDuplicateSubtrees(root: TreeNode | null): Array<TreeNode | null> {\n    ans = new Array<TreeNode>()\n    map = new Map<string, number>()\n    dfs(root)\n    return ans\n};\nfunction dfs(root: TreeNode | null): string {\n    if (root == null) return \" \"\n    let key = root.val + \"_\"\n    key += dfs(root.left)\n    key += dfs(root.right)\n    if (!map.has(key)) map.set(key, 1)\n    else map.set(key, map.get(key) + 1)\n    if (map.get(key) == 2) ans.push(root)\n    return key\n}\n```\n* 时间复杂度:`DFS` 过程复杂度为 $O(n)$,对于每个子树需要构造出与子树同等规模的字符串,复杂度为 $O(n)$。整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.652` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/651-660/653. 两数之和 IV - 输入 BST（简单）.md", "url_title": "650. 只有两个键的键盘", "url": "https://leetcode-cn.com/problems/two-sum-iv-input-is-a-bst/solution/by-ac_oier-zr4o/", "difficulty": "简单", "tags": ["二叉树", "迭代", "中序遍历", "双指针", "哈希表", "树的搜索"], "question": "给定一个二叉搜索树 `root` 和一个目标结果 `k`,如果 `BST` 中存在两个元素且它们的和等于给定的目标结果,则返回 `true`。\n\n示例 1:\n\n```\n输入: root = [5,3,6,2,4,null,7], k = 9\n\n输出: true\n```\n示例 2:\n\n```\n输入: root = [5,3,6,2,4,null,7], k = 28\n\n输出: false\n```\n\n提示:\n* 二叉树的节点个数的范围是  $[1, 10^4]$\n* $-10^4 <= Node.val <= 10^4$\n* `root` 为二叉搜索树\n* $-10^5 <= k <= 10^5$", "solution": "### 哈希表 + 树的搜索\n\n在递归搜索过程中记录下相应的节点值(使用 `Set` 集合),如果在遍历某个节点 $x$ 时发现集合中存在 $k - x.val$,说明存在两个节点之和等于 $k$,返回 `True`,若搜索完整棵树都没有则返回 `False`。\n\n代码:\n```Java\nclass Solution {\n    Set<Integer> set = new HashSet<>();\n    public boolean findTarget(TreeNode root, int k) {\n        if (root == null) return false;\n        if (set.contains(k - root.val)) return true;\n        set.add(root.val);\n        return findTarget(root.left, k) | findTarget(root.right, k);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 双指针 + BST 中序遍历\n\n解法一中没有利用 `BST` 特性,利用 `BST` 中序遍历有序的特性,我们可以实现类似「双指针」的效果。\n\n起始先让 BST 的最左链和最右链完全入栈,此时栈顶元素为 BST 中的最小值和最大值,分别使用 `l` 和 `r` 充当指针代指,根据两指针指向的节点值之和与 $k$ 的大小关系来指导如何让 `l` 和 `r` 移动,`l` 的移动过程其实就是找下一个比 `l.val` 更大的值,而 `r` 的移动过程其实就是找下一个比 `r.val` 更小的值。\n\n代码:\n```Java\nclass Solution {\n    public boolean findTarget(TreeNode root, int k) {\n        Deque<TreeNode> ld = new ArrayDeque<>(), rd = new ArrayDeque<>();\n        TreeNode temp = root;\n        while (temp != null) {\n            ld.addLast(temp);\n            temp = temp.left;\n        }\n        temp = root;\n        while (temp != null) {\n            rd.addLast(temp);\n            temp = temp.right;\n        }\n        TreeNode l = ld.peekLast(), r = rd.peekLast();\n        while (l.val < r.val) {\n            int t = l.val + r.val;\n            if (t == k) return true;\n            else if (t < k) l = getNext(ld, true);\n            else r = getNext(rd, false);\n        }\n        return false;\n    }\n    TreeNode getNext(Deque<TreeNode> d, boolean isLeft) {\n        TreeNode cur = d.pollLast();\n        TreeNode node = isLeft ? cur.right : cur.left;\n        while (node != null) {\n            d.addLast(node);\n            node = isLeft ? node.left : node.right;\n        }\n        return d.peekLast();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.653` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/651-660/654. 最大二叉树（中等）.md", "url_title": "654. 最大二叉树", "url": "https://leetcode.cn/problems/maximum-binary-tree/solution/by-ac_oier-s0wc/", "difficulty": "中等", "tags": ["二叉树", "递归", "分治", "线段树", "单调栈"], "question": "给定一个不重复的整数数组 `nums`。 \n\n最大二叉树 可以用下面的算法从 `nums` 递归地构建:\n\n1. 创建一个根节点,其值为 `nums` 中的最大值。\n2. 递归地在最大值 左边 的 子数组前缀上 构建左子树。\n3. 递归地在最大值 右边 的 子数组后缀上 构建右子树。\n\n返回 `nums` 构建的最大二叉树。\n\n示例 1:\n\n```\n输入:nums = [3,2,1,6,0,5]\n\n输出:[6,3,5,null,2,0,null,null,1]\n\n解释:递归调用如下所示:\n- [3,2,1,6,0,5] 中的最大值是 6 ,左边部分是 [3,2,1] ,右边部分是 [0,5] 。\n    - [3,2,1] 中的最大值是 3 ,左边部分是 [] ,右边部分是 [2,1] 。\n        - 空数组,无子节点。\n        - [2,1] 中的最大值是 2 ,左边部分是 [] ,右边部分是 [1] 。\n            - 空数组,无子节点。\n            - 只有一个元素,所以子节点是一个值为 1 的节点。\n    - [0,5] 中的最大值是 5 ,左边部分是 [0] ,右边部分是 [] 。\n        - 只有一个元素,所以子节点是一个值为 0 的节点。\n        - 空数组,无子节点。\n```\n示例 2:\n\n```\n输入:nums = [3,2,1]\n\n输出:[3,null,2,null,1]\n```\n\n提示:\n* $1 <= nums.length <= 1000$\n* $0 <= nums[i] <= 1000$\n* `nums` 中的所有整数 互不相同", "solution": "### 基本分析\n\n根据题目描述,可知该问题本质是「区间求最值」问题(RMQ)。\n\n而求解 RMQ 有多种方式:递归分治、有序集合/ST/线段树 和 单调栈。\n\n其中递归分治做法复杂度为 $O(n^2)$,对本题来说可过;而其余诸如线段树的方式需要 $O(n\\log{n})$ 的建树和单次 $O(\\log{n})$ 的查询,整体复杂度为 $O(n\\log{n})$;单调栈解法则是整体复杂度为 $O(n)$。\n\n---\n\n### 递归分治\n\n设置递归函数 `TreeNode build(int[] nums, int l, int r)` 含义为从 `nums` 中的 $[l, r]$ 下标范围进行构建,返回构建后的头结点。\n\n当 $l > r$ 时,返回空节点,否则在 $[l, r]$ 中进行扫描,找到最大值对应的下标 `idx` 并创建对应的头结点,递归构建 $[l, idx - 1]$ 和 $[idx + 1, r]$ 作为头节点的左右子树。\n\nJava 代码:\n```Java\nclass Solution {\n    public TreeNode constructMaximumBinaryTree(int[] nums) {\n        return build(nums, 0, nums.length - 1);\n    }\n    TreeNode build(int[] nums, int l, int r) {\n        if (l > r) return null;\n        int idx = l;\n        for (int i = l; i <= r; i++) {\n            if (nums[i] > nums[idx]) idx = i;\n        }\n        TreeNode ans = new TreeNode(nums[idx]);\n        ans.left = build(nums, l, idx - 1);\n        ans.right = build(nums, idx + 1, r);\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {\n        return build(nums, 0, nums.size() - 1);\n    }\n    TreeNode* build(vector<int>& nums, int l, int r) {\n        if (l > r) return nullptr;\n        int idx = l;\n        for (int i = l; i <= r; ++i) {\n            if (nums[i] > nums[idx]) idx = i;\n        }\n        TreeNode* ans = new TreeNode(nums[idx]);\n        ans->left = build(nums, l, idx - 1);\n        ans->right = build(nums, idx + 1, r);\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:\n        return self.build(nums, 0, len(nums) - 1)\n\n    def build(self, nums, l, r):\n        if l > r:\n            return None\n        idx = l\n        for i in range(l, r + 1):\n            if nums[i] > nums[idx]:\n                idx = i\n        node = TreeNode(nums[idx])\n        node.left = self.build(nums, l, idx - 1)\n        node.right = self.build(nums, idx + 1, r)\n        return node\n```\nTypeScript 代码:\n```TypeScript\nfunction constructMaximumBinaryTree(nums: number[]): TreeNode | null {\n    return build(nums, 0, nums.length - 1)\n};\nfunction build(nums: number[], l: number, r: number): TreeNode | null {\n    if (l > r) return null\n    let idx = l\n    for (let i = l; i <= r; i++) {\n        if (nums[i] > nums[idx]) idx = i\n    }\n    const ans = new TreeNode(nums[idx])\n    ans.left = build(nums, l, idx - 1)\n    ans.right = build(nums, idx + 1, r)\n    return ans\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$\n\n---\n\n### 线段树 \n\n抽象成区间求和问题后,涉及「单点修改」和「区间查询」,再结合节点数量为 $1e3$,可使用 `build` $4n$ 空间不带懒标记的线段树进行求解。\n\n设计线段树节点 `Node` 包含属性:左节点下标 `l`、右节点下标 `r` 和当前区间 $[l, r]$ 所对应的最值 $val$。\n\n构建线段树的过程为基本的线段树模板内容,而构建答案树的过程与递归分治过程类型(将线性找最值过程用线段树优化)。\n\nJava 代码:\n```Java\nclass Solution {\n    class Node {\n        int l, r, val;\n        Node (int _l, int _r) {\n            l = _l; r = _r;\n        }\n    }\n    void build(int u, int l, int r) {\n        tr[u] = new Node(l, r);\n        if (l == r) return ;\n        int mid = l + r >> 1;\n        build(u << 1, l, mid);\n        build(u << 1 | 1, mid + 1, r);\n    }\n    void update(int u, int x, int v) {\n        if (tr[u].l == x && tr[u].r == x) {\n            tr[u].val = Math.max(tr[u].val, v);\n            return ;\n        }\n        int mid = tr[u].l + tr[u].r >> 1;\n        if (x <= mid) update(u << 1, x, v);\n        else update(u << 1 | 1, x, v);\n        pushup(u);\n    }\n    int query(int u, int l, int r) {\n        if (l <= tr[u].l && tr[u].r <= r) return tr[u].val;\n        int mid = tr[u].l + tr[u].r >> 1, ans = 0;\n        if (l <= mid) ans = query(u << 1, l, r);\n        if (r > mid) ans = Math.max(ans, query(u << 1 | 1, l, r));\n        return ans;\n    }\n    void pushup(int u) {\n        tr[u].val = Math.max(tr[u << 1].val, tr[u << 1 | 1].val);\n    }\n    Node[] tr = new Node[4010];\n    int[] hash = new int[1010];\n    public TreeNode constructMaximumBinaryTree(int[] nums) {\n        int n = nums.length;\n        build(1, 1, n);\n        for (int i = 0; i < n; i++) {\n            hash[nums[i]] = i + 1;\n            update(1, i + 1, nums[i]);\n        }\n        return dfs(nums, 1, n);\n    }\n    TreeNode dfs(int[] nums, int l, int r) {\n        if (l > r) return null;\n        int val = query(1, l, r), idx = hash[val];\n        TreeNode ans = new TreeNode(val);\n        ans.left = dfs(nums, l, idx - 1);\n        ans.right = dfs(nums, idx + 1, r);\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nstruct Node {\n    int l, r, val;\n    Node(int _l, int _r) : l(_l), r(_r), val(0) {}\n    Node() : l(0), r(0), val(0) {}\n};\nclass Solution {\npublic:\n    vector<Node> tr;\n    unordered_map<int, int> hash;\n    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {\n        int n = nums.size();\n        tr.resize(4010);\n        build(1, 1, n);\n        for (int i = 0; i < n; ++i) {\n            hash[nums[i]] = i + 1;\n            update(1, i + 1, nums[i]);\n        }\n        return dfs(nums, 1, n);\n    }\n    void build(int u, int l, int r) {\n        tr[u] = Node(l, r);\n        if (l == r) return;\n        int mid = (l + r) >> 1;\n        build((u << 1), l, mid);\n        build((u << 1) + 1, mid + 1, r);\n    }\n    void update(int u, int x, int v) {\n        if (tr[u].l == x && tr[u].r == x) {\n            tr[u].val = max(tr[u].val, v);\n            return;\n        }\n        int mid = (tr[u].l + tr[u].r) >> 1;\n        if (x <= mid) update((u << 1), x, v);\n        else update((u << 1) + 1, x, v);\n        pushup(u);\n    }\n    int query(int u, int l, int r) {\n        if (l <= tr[u].l && tr[u].r <= r) return tr[u].val;\n        int mid = (tr[u].l + tr[u].r) >> 1, ans = 0;\n        if (l <= mid) ans = max(ans, query((u << 1), l, r));\n        if (r > mid) ans = max(ans, query((u << 1) + 1, l, r));\n        return ans;\n    }\n    void pushup(int u) {\n        tr[u].val = max(tr[(u << 1)].val, tr[(u << 1) + 1].val);\n    }\n    TreeNode* dfs(vector<int>& nums, int l, int r) {\n        if (l > r) return NULL;\n        int val = query(1, l, r), idx = hash[val];\n        TreeNode* ans = new TreeNode(val);\n        ans -> left = dfs(nums, l, idx - 1);\n        ans -> right = dfs(nums, idx + 1, r);\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Node:\n    def __init__(self, l=0, r=0, val=0):\n        self.l = l\n        self.r = r\n        self.val = val\n\nclass Solution:\n    def __init__(self):\n        self.tr = [Node() for _ in range(4010)]\n        self.hash = {}\n\n    def constructMaximumBinaryTree(self, nums):\n        n = len(nums)\n        self.build(1, 1, n)\n        for i, num in enumerate(nums):\n            self.hash[num] = i + 1\n            self.update(1, i + 1, num)\n        return self.dfs(nums, 1, n)\n\n    def build(self, u, l, r):\n        self.tr[u] = Node(l, r)\n        if l == r: return\n        mid = (l + r) >> 1\n        self.build(u << 1, l, mid)\n        self.build(u << 1 | 1, mid + 1, r)\n\n    def update(self, u, x, v):\n        if self.tr[u].l == x and self.tr[u].r == x:\n            self.tr[u].val = max(self.tr[u].val, v)\n            return\n        mid = (self.tr[u].l + self.tr[u].r) >> 1\n        if x <= mid: self.update(u << 1, x, v)\n        else: self.update(u << 1 | 1, x, v)\n        self.pushup(u)\n\n    def query(self, u, l, r):\n        if l <= self.tr[u].l and self.tr[u].r <= r: return self.tr[u].val\n        mid = (self.tr[u].l + self.tr[u].r) >> 1\n        ans = 0\n        if l <= mid: ans = max(ans, self.query(u << 1, l, r))\n        if r > mid: ans = max(ans, self.query(u << 1 | 1, l, r))\n        return ans\n\n    def pushup(self, u):\n        self.tr[u].val = max(self.tr[u << 1].val, self.tr[u << 1 | 1].val)\n\n    def dfs(self, nums, l, r):\n        if l > r: return None\n        val = self.query(1, l, r)\n        idx = self.hash[val]\n        node = TreeNode(val)\n        node.left = self.dfs(nums, l, idx - 1)\n        node.right = self.dfs(nums, idx + 1, r)\n        return node\n```\nTypeScript 代码:\n```TypeScript\nclass TNode {\n    l = 0; r = 0; val = 0;\n    constructor (_l: number, _r: number) {\n        this.l = _l; this.r = _r;\n    }\n}\nconst tr: TNode[] = new Array<TNode>(4010)\nconst hash: number[] = new Array<number>(1010)\nfunction constructMaximumBinaryTree(nums: number[]): TreeNode | null {\n    const n = nums.length\n    build(1, 1, n)\n    for (let i = 0; i < n; i++) {\n        hash[nums[i]] = i + 1\n        update(1, i + 1, nums[i])\n    }\n    return dfs(nums, 1, n)\n};\nfunction build(u: number, l: number, r: number): void {\n    tr[u] = new TNode(l, r)\n    if (l == r) return \n    const mid = l + r >> 1\n    build(u << 1, l, mid)\n    build(u << 1 | 1, mid + 1, r)\n}\nfunction update(u: number, x: number, v: number): void {\n    if (tr[u].l == x && tr[u].r == x) {\n        tr[u].val = Math.max(tr[u].val, v)\n        return \n    }\n    const mid = tr[u].l + tr[u].r >> 1\n    if (x <= mid) update(u << 1, x, v)\n    else update(u << 1 | 1, x, v)\n    pushup(u)\n}\nfunction query(u: number, l: number, r: number): number {\n    if (l <= tr[u].l && tr[u].r <= r) return tr[u].val\n    let mid = tr[u].l + tr[u].r >> 1, ans = 0\n    if (l <= mid) ans = query(u << 1, l, r)\n    if (r > mid) ans = Math.max(ans, query(u << 1 | 1, l, r))\n    return ans\n}\nfunction pushup(u: number): void {\n    tr[u].val = Math.max(tr[u << 1].val, tr[u << 1 | 1].val)\n}\nfunction dfs(nums: number[], l: number, r: number): TreeNode {\n    if (l > r) return null\n    let val = query(1, l, r), idx = hash[val]\n    const ans = new TreeNode(val)\n    ans.left = dfs(nums, l, idx - 1)\n    ans.right = dfs(nums, idx + 1, r)\n    return ans\n}\n\n```\n* 时间复杂度:构建线段树复杂度为 $O(n\\log{n})$;构造答案树复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 单调栈\n\n更进一步,根据题目对树的构建的描述可知,`nums` 中的任二节点所在构建树的水平截面上的位置仅由下标大小决定。\n\n不难想到可抽象为找最近元素问题,可使用单调栈求解。\n\n具体的,我们可以从前往后处理所有的 $nums[i]$,若存在栈顶元素并且栈顶元素的值比当前值要小,根据我们从前往后处理的逻辑,可确定栈顶元素可作为当前 $nums[i]$ 对应节点的左节点,同时为了确保最终 $nums[i]$ 的左节点为 $[0, i - 1]$ 范围的最大值,我们需要确保在构建 $nums[i]$ 节点与其左节点的关系时,$[0, i - 1]$ 中的最大值最后出队,此时可知容器栈具有「单调递减」特性。基于此,我们可以分析出,当处理完 $nums[i]$ 节点与其左节点关系后,可明确 $nums[i]$ 可作为未出栈的栈顶元素的右节点。\n\n> 一些细节:`Java` 容易使用 `ArrayDeque` 充当容器,但为与 `TS` 保存一致,两者均使用数组充当容器。\n\nJava 代码:\n```Java\nclass Solution {\n    static TreeNode[] stk = new TreeNode[1010];\n    public TreeNode constructMaximumBinaryTree(int[] nums) {\n        int he = 0, ta = 0;\n        for (int x : nums) {\n            TreeNode node = new TreeNode(x);\n            while (he < ta && stk[ta - 1].val < x) node.left = stk[--ta];\n            if (he < ta) stk[ta - 1].right = node;\n            stk[ta++] = node;\n        }\n        return stk[0];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    TreeNode* stk[1010];\n    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {\n        int he = 0, ta = 0;\n        for (int x : nums) {\n            TreeNode* node = new TreeNode(x);\n            while (he < ta && stk[ta - 1]->val < x) node->left = stk[--ta];\n            if (he < ta) stk[ta - 1]->right = node;\n            stk[ta++] = node;\n        }\n        return stk[0];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:\n        stk = [None] * 1010 \n        he, ta = 0, 0\n        for x in nums:\n            node = TreeNode(x)\n            while he < ta and stk[ta - 1].val < x:\n                node.left = stk[ta - 1]\n                ta -= 1\n            if he < ta:\n                stk[ta - 1].right = node\n            stk[ta] = node\n            ta += 1\n        return stk[0]\n```\nTypeScript 代码:\n```TypeScript\nconst stk = new Array<TreeNode>(1010)\nfunction constructMaximumBinaryTree(nums: number[]): TreeNode | null {\n    let he = 0, ta = 0\n    for (const x of nums) {\n        const node = new TreeNode(x)\n        while (he < ta && stk[ta - 1].val < x) node.left = stk[--ta]\n        if (he < ta) stk[ta - 1].right = node\n        stk[ta++] = node\n    }\n    return stk[0]\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.654` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/651-660/655. 输出二叉树（中等）.md", "url_title": "655. 输出二叉树", "url": "https://leetcode.cn/problems/print-binary-tree/solution/by-ac_oier-mays/", "difficulty": "中等", "tags": ["二叉树", "递归"], "question": "给你一棵二叉树的根节点 root ,请你构造一个下标从 0 开始、大小为 m x n 的字符串矩阵 res ,用以表示树的 格式化布局 。构造此格式化布局矩阵需要遵循以下规则:\n\n* 树的 高度 为 $height$,矩阵的行数 $m$ 应该等于 $height + 1$。\n* 矩阵的列数 $n$ 应该等于 $2^{height+1 - 1}$ 。\n* 根节点 需要放置在 顶行 的 正中间 ,对应位置为 $res[0][(n-1)/2]$ 。\n* 对于放置在矩阵中的每个节点,设对应位置为 $res[r][c]$ ,将其左子节点放置在 $res[r+1][c-2^{height-r-1}]$ ,右子节点放置在 $res[r+1][c+2^{height-r-1}]$ 。\n* 继续这一过程,直到树中的所有节点都妥善放置。\n* 任意空单元格都应该包含空字符串 `\"\"` 。\n\n返回构造得到的矩阵 `res` 。\n\n示例 1:\n\n```\n输入:root = [1,2]\n\n输出:\n[[\"\",\"1\",\"\"],\n [\"2\",\"\",\"\"]]\n```\n示例 2:\n\n```\n输入:root = [1,2,3,null,4]\n\n输出:\n[[\"\",\"\",\"\",\"1\",\"\",\"\",\"\"],\n [\"\",\"2\",\"\",\"\",\"\",\"3\",\"\"],\n [\"\",\"\",\"4\",\"\",\"\",\"\",\"\"]]\n```\n\n提示:\n* 树中节点数在范围 $[1, 2^{10}]$ 内\n* $-99 <= Node.val <= 99$\n* 树的深度在范围 $[1, 10]$ 内", "solution": "### DFS\n\n根据题意,我们可以先设计 `dfs1` 递归函数得到树的高度 `h`,以及与其相关的矩阵行列大小(并初始化矩阵)。\n\n随后根据填充规则,设计 `dfs2` 递归函数往矩阵进行填充。\n\nJava 代码:\n```Java\nclass Solution {\n    int h, m, n;\n    List<List<String>> ans;\n    public List<List<String>> printTree(TreeNode root) {\n        dfs1(root, 0);\n        m = h + 1; n = (1 << (h + 1)) - 1;\n        ans = new ArrayList<>();\n        for (int i = 0; i < m; i++) {\n            List<String> cur = new ArrayList<>();\n            for (int j = 0; j < n; j++) cur.add(\"\");\n            ans.add(cur);\n        }\n        dfs2(root, 0, (n - 1) / 2);\n        return ans;\n    }\n    void dfs1(TreeNode root, int depth) {\n        if (root == null) return ;\n        h = Math.max(h, depth);\n        dfs1(root.left, depth + 1);\n        dfs1(root.right, depth + 1);\n    }\n    void dfs2(TreeNode root, int x, int y) {\n        if (root == null) return ;\n        ans.get(x).set(y, String.valueOf(root.val));\n        dfs2(root.left, x + 1, y - (1 << (h - x - 1)));\n        dfs2(root.right, x + 1, y + (1 << (h - x - 1)));\n    }\n} \n```\nTypescript 代码:\n```Typescript\nlet h: number, m: number, n: number;\nlet ans: string[][];\nfunction printTree(root: TreeNode | null): string[][] {\n    h = 0\n    dfs1(root, 0)\n    m = h + 1; n = (1 << (h + 1)) - 1\n    ans = new Array<Array<string>>()\n    for (let i = 0; i < m; i++) {\n        ans[i] = new Array<string>(n).fill(\"\")\n    }\n    dfs2(root, 0, (n - 1) / 2)\n    return ans\n};\nfunction dfs1(root: TreeNode | null, depth: number): void {\n    if (root == null) return \n    h = Math.max(h, depth)\n    dfs1(root.left, depth + 1)\n    dfs1(root.right, depth + 1)\n}\nfunction dfs2(root: TreeNode | null, x: number, y: number): void {\n    if (root == null) return \n    ans[x][y] = root.val + \"\";\n    dfs2(root.left, x + 1, y - (1 << (h - x - 1)))\n    dfs2(root.right, x + 1, y + (1 << (h - x - 1)))\n}\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n \\times m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.655` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/651-660/658. 找到 K 个最接近的元素（中等）.md", "url_title": "658. 找到 K 个最接近的元素", "url": "https://leetcode.cn/problems/find-k-closest-elements/solution/by-ac_oier-8xh5/", "difficulty": "中等", "tags": ["二分", "双指针"], "question": "给定一个 排序好 的数组 `arr`,两个整数 `k` 和 `x` ,从数组中找到最靠近 `x`(两数之差最小)的 `k` 个数。返回的结果必须要是按升序排好的。\n\n整数 `a` 比整数 `b` 更接近 `x` 需要满足:\n\n* `|a - x| < |b - x|` 或者\n* `|a - x| == |b - x|` 且 `a < b`\n\n示例 1:\n```\n输入:arr = [1,2,3,4,5], k = 4, x = 3\n\n输出:[1,2,3,4]\n```\n示例 2:\n```\n输入:arr = [1,2,3,4,5], k = 4, x = -1\n\n输出:[1,2,3,4]\n```\n\n提示:\n* $1 <= k <= arr.length$\n* $1 <= arr.length <= 10^4$\n* `arr` 按升序排列\n* $-10^4 <= arr[i], x <= 10^4$", "solution": "### 二分 + 双指针\n\n容易想到先通过「二分」找到与 `x` 差值最小的位置 `idx`,然后从 `idx` 开始使用「双指针」往两边进行拓展(初始化左端点 $i = idx - 1$,右端点 $j = idx + 1$),含义为 $[i + 1, j - 1]$ 范围内子数组为候选区间,不断根据两边界与 `x` 的差值关系进行扩充,直到候选区间包含 $k$ 个数。\n\nJava 代码:\n```Java\nclass Solution {\n    public List<Integer> findClosestElements(int[] arr, int k, int x) {\n        int n = arr.length, l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (arr[mid] <= x) l = mid;\n            else r = mid - 1;\n        }\n        r = r + 1 < n && Math.abs(arr[r + 1] - x) < Math.abs(arr[r] - x) ? r + 1 : r;\n        int i = r - 1, j = r + 1;\n        while (j - i - 1 < k) {\n            if (i >= 0 && j < n) {\n                if (Math.abs(arr[j] - x) < Math.abs(arr[i] - x)) j++;\n                else i--;\n            } else if (i >= 0) {\n                i--;\n            } else {\n                j++;\n            }\n        }\n        List<Integer> ans = new ArrayList<>();\n        for (int p = i + 1; p <= j - 1; p++) ans.add(arr[p]);\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction findClosestElements(arr: number[], k: number, x: number): number[] {\n    let n = arr.length, l = 0, r = n - 1\n    while (l < r) {\n        const mid = l + r + 1 >> 1\n        if (arr[mid] <= x) l = mid\n        else r = mid - 1\n    }\n    r = r + 1 < n && Math.abs(arr[r + 1] - x) < Math.abs(arr[r] - x) ? r + 1 : r\n    let i = r - 1, j = r + 1\n    while (j - i - 1 < k) {\n        if (i >= 0 && j < n) {\n            if (Math.abs(arr[j] - x) < Math.abs(arr[i] - x)) j++\n            else i--\n        } else if (i >= 0) {\n            i--\n        } else {\n            j++\n        }\n    }\n    return arr.slice(i + 1, j);\n};\n```\n* 时间复杂度:查找分割点复杂度为 $O(\\log{n})$;从分割点往两边拓展复杂度为 $O(k)$。整体复杂度为 $O(\\log{n} + k)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.658` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/661-670/661. 图片平滑器（简单）.md", "url_title": "661. 图片平滑器", "url": "https://leetcode-cn.com/problems/image-smoother/solution/by-ac_oier-nn3v/", "difficulty": "简单", "tags": ["模拟", "前缀和"], "question": "图像平滑器 是大小为 $3 * 3$ 的过滤器,用于对图像的每个单元格平滑处理,平滑处理后单元格的值为该单元格的平均灰度。\n\n每个单元格的  平均灰度 定义为:该单元格自身及其周围的 $8$ 个单元格的平均值,结果需向下取整。(即,需要计算蓝色平滑器中 $9$ 个单元格的平均值)。\n\n如果一个单元格周围存在单元格缺失的情况,则计算平均灰度时不考虑缺失的单元格(即,需要计算红色平滑器中 $4$ 个单元格的平均值)。\n\n给你一个表示图像灰度的 $m * n$ 整数矩阵 `img` ,返回对图像的每个单元格平滑处理后的图像 。\n\n示例 1:\n\n```\n输入:img = [[1,1,1],[1,0,1],[1,1,1]]\n\n输出:[[0, 0, 0],[0, 0, 0], [0, 0, 0]]\n\n解释:\n对于点 (0,0), (0,2), (2,0), (2,2): 平均(3/4) = 平均(0.75) = 0\n对于点 (0,1), (1,0), (1,2), (2,1): 平均(5/6) = 平均(0.83333333) = 0\n对于点 (1,1): 平均(8/9) = 平均(0.88888889) = 0\n```\n示例 2:\n\n```\n输入: img = [[100,200,100],[200,50,200],[100,200,100]]\n\n输出: [[137,141,137],[141,138,141],[137,141,137]]\n\n解释:\n对于点 (0,0), (0,2), (2,0), (2,2): floor((100+200+200+50)/4) = floor(137.5) = 137\n对于点 (0,1), (1,0), (1,2), (2,1): floor((200+200+50+200+100+100)/6) = floor(141.666667) = 141\n对于点 (1,1): floor((50+200+200+200+200+100+100+100+100)/9) = floor(138.888889) = 138\n```\n\n提示:\n* $m == img.length$\n* $n == img[i].length$\n* $1 <= m, n <= 200$\n* $0 <= img[i][j] <= 255$", "solution": "### 朴素解法\n\n为了方便,我们称每个单元格及其八连通方向单元格所组成的连通块为一个 `item`。\n\n数据范围只有 $200$,我们可以直接对每个 `item` 进行遍历模拟。\n\n代码:\n```Java\nclass Solution {\n    public int[][] imageSmoother(int[][] img) {\n        int m = img.length, n = img[0].length;\n        int[][] ans = new int[m][n];\n        int[][] dirs = new int[][]{{0,0},{1,0},{-1,0},{0,1},{0,-1},{-1,-1},{-1,1},{1,-1},{1,1}};\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                int tot = 0, cnt = 0;\n                for (int[] di : dirs) {\n                    int nx = i + di[0], ny = j + di[1];\n                    if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;\n                    tot += img[nx][ny]; cnt++;\n                }\n                ans[i][j] = tot / cnt;\n            }\n        }\n        return ans;\n    }\n}\n```\n---\n```Python\ndirs = list(product(*[[-1,0,1]] * 2))\nclass Solution:\n    def imageSmoother(self, img: List[List[int]]) -> List[List[int]]:\n        m, n = len(img), len(img[0])\n        ans = [[0] * n for _ in range(m)]\n        for i in range(m):\n            for j in range(n):\n                tot, cnt = 0, 0\n                for di in dirs:\n                    if 0 <= (nx := i + di[0]) < m and 0 <= (ny := j + di[1]) < n:\n                        tot += img[nx][ny]\n                        cnt += 1\n                ans[i][j] = tot // cnt\n        return ans\n```\n* 时间复杂度:$O(m \\times n \\times C)$,其中 $C$ 为灰度单位所包含的单元格数量,固定为 $9$\n* 空间复杂度:$O(m \\times n)$\n\n---\n\n### 前缀和 \n\n在朴素解法中,对于每个 $ans[i][j]$ 我们都不可避免的遍历 $8$ 联通方向,而利用「前缀和」我们可以对该操作进行优化。\n\n对于某个 $ans[i][j]$ 而言,我们可以直接计算出其所在 `item` 的左上角 $(a, b) = (i - 1, j - 1)$ 以及其右下角 $(c, d) = (i + 1, j + 1)$,同时为了防止超出原矩阵,我们需要将 $(a, b)$ 与 $(c, d)$ 对边界分别取 `max` 和 `min`。\n\n当有了合法的 $(a, b)$ 和 $(c, d)$ 后,我们可以直接计算出 `item` 的单元格数量(所包含的行列乘积)及 `item`  的单元格之和(前缀和查询),从而算得 $ans[i][j]$。\n\n代码:\n```Java\nclass Solution {\n    public int[][] imageSmoother(int[][] img) {\n        int m = img.length, n = img[0].length;\n        int[][] sum = new int[m + 10][n + 10];\n        for (int i = 1; i <= m; i++) {\n            for (int j = 1; j <= n; j++) {\n                sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + img[i - 1][j - 1];\n            }\n        }\n        int[][] ans = new int[m][n];\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                int a = Math.max(0, i - 1), b = Math.max(0, j - 1);\n                int c = Math.min(m - 1, i + 1), d = Math.min(n - 1, j + 1);\n                int cnt = (c - a + 1) * (d - b + 1);\n                int tot = sum[c + 1][d + 1] - sum[a][d + 1] - sum[c + 1][b] + sum[a][b];\n                ans[i][j] = tot / cnt;\n            }\n        }\n        return ans;\n    }\n}\n```\n---\n```Python\nclass Solution:\n    def imageSmoother(self, img: List[List[int]]) -> List[List[int]]:\n        m, n = len(img), len(img[0])\n        sum = [[0] * (n + 10) for _ in range(m + 10)]\n        for i in range(1, m + 1):\n            for j in range(1, n + 1):\n                sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + img[i - 1][j - 1]\n        ans = [[0] * n for _ in range(m)]\n        for i in range(m):\n            for j in range(n):\n                a, b = max(0, i - 1), max(0, j - 1)\n                c, d = min(m - 1, i + 1), min(n - 1, j + 1)\n                cnt = (c - a + 1) * (d - b + 1)\n                tot = sum[c + 1][d + 1] - sum[a][d + 1] - sum[c + 1][b] + sum[a][b]\n                ans[i][j] = tot // cnt\n        return ans\n```\n* 时间复杂度:$O(m \\times n)$\n* 空间复杂度:$O(m \\times n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.661` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/661-670/662. 二叉树最大宽度（中等）.md", "url_title": "662. 二叉树最大宽度", "url": "https://leetcode.cn/problems/maximum-width-of-binary-tree/solution/by-ac_oier-33er/", "difficulty": "中等", "tags": ["二叉树", "DFS", "哈希表"], "question": "给你一棵二叉树的根节点 `root`,返回树的最大宽度。\n\n树的「最大宽度」是所有层中最大的宽度 。\n\n每一层的宽度被定义为该层最左和最右的非空节点(即两个端点)之间的长度。\n\n将这个二叉树视作与满二叉树结构相同,两端点间会出现一些延伸到这一层的 `null` 节点,这些 `null` 节点也计入长度。\n\n题目数据保证答案将会在  `32` 位 带符号整数范围内。\n\n示例 1:\n\n```\n输入:root = [1,3,2,5,3,null,9]\n\n输出:4\n\n解释:最大宽度出现在树的第 3 层,宽度为 4 (5,3,null,9) 。\n```\n示例 2:\n\n```\n输入:root = [1,3,2,5,null,null,9,6,null,7]\n\n输出:7\n\n解释:最大宽度出现在树的第 4 层,宽度为 7 (6,null,null,null,null,null,7) 。\n```\n示例 3:\n\n```\n输入:root = [1,3,2,5]\n\n输出:2\n\n解释:最大宽度出现在树的第 2 层,宽度为 2 (3,2) 。\n```\n\n提示:\n* 树中节点的数目范围是 $[1, 3000]$\n* $-100 <= Node.val <= 100$", "solution": "### DFS\n\n根据满二叉树的节点编号规则:若根节点编号为 `u`,则其左子节点编号为 `u << 1`,其右节点编号为 `u << 1 | 1`。\n\n一个朴素的想法是:我们在 `DFS`过程中使用两个哈希表分别记录每层深度中的最小节点编号和最大节点编号,两者距离即是当前层的宽度,最终所有层数中的最大宽度即是答案。\n\n而实现上,我们可以利用先 `DFS` 左节点,再 `DFS` 右节点的性质可知,每层的最左节点必然是最先被遍历到,因此我们只需要记录当前层最先被遍历到点编号(即当前层最小节点编号),并在 `DFS` 过程中计算宽度,更新答案即可。\n\n> 看到评论区有同学讨论关于编号溢出问题,之所以溢出仍能 `AC` 是因为测试数组中没有同层内「宽度」左端点不溢出,右端点溢出,同时该层就是最大宽度的数据点。\n我们可以通过 `u = u - map.get(depth) + 1` 操作来对同层内的节点进行重新编号(使得同层最靠左的非空节点编号为 $1$)。\n通过重编号操作 我们可以消除由于深度加深带来的编号溢出问题,同时 `TS` 代码不再需要使用 `bigint`。\n\nJava 代码:\n```Java\nclass Solution {\n    Map<Integer, Integer> map = new HashMap<>();\n    int ans;\n    public int widthOfBinaryTree(TreeNode root) {\n        dfs(root, 1, 0);\n        return ans;\n    }\n    void dfs(TreeNode root, int u, int depth) {\n        if (root == null) return ;\n        if (!map.containsKey(depth)) map.put(depth, u);\n        ans = Math.max(ans, u - map.get(depth) + 1);\n        u = u - map.get(depth) + 1;\n        dfs(root.left, u << 1, depth + 1);\n        dfs(root.right, u << 1 | 1, depth + 1);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    unordered_map<int, int> map;\n    int ans = 0;\n    int widthOfBinaryTree(TreeNode* root) {\n        dfs(root, 1, 0);\n        return ans;\n    }\n    void dfs(TreeNode* root, int u, int depth) {\n        if (!root) return;\n        if (!map.count(depth)) map[depth] = u;\n        ans = max(ans, u - map[depth] + 1);\n        u = u - map[depth] + 1;\n        dfs(root->left, u << 1, depth + 1);\n        dfs(root->right, u << 1 | 1, depth + 1);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def widthOfBinaryTree(self, root: Optional[TreeNode]) -> int:\n        mapping = {}\n        ans = 0\n        def dfs(root, u, depth):\n            nonlocal ans\n            if not root: \n                return\n            if depth not in mapping: \n                mapping[depth] = u\n            ans = max(ans, u - mapping[depth] + 1)\n            u = u - mapping[depth] + 1\n            dfs(root.left, u << 1, depth + 1)\n            dfs(root.right, u << 1 | 1, depth + 1)\n        dfs(root, 1, 0)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nlet map = new Map<number, number>()\nlet ans = 0\nfunction widthOfBinaryTree(root: TreeNode | null): number {\n    map.clear()\n    ans = 0\n    dfs(root, 1, 0)\n    return ans\n};\nfunction dfs(root: TreeNode | null, u: number, depth: number): void {\n    if (root == null) return \n    if (!map.has(depth)) map.set(depth, u)\n    ans = Math.max(ans, u - map.get(depth) + 1)\n    u = u - map.get(depth) + 1\n    dfs(root.left, u << 1, depth + 1)\n    dfs(root.right, u << 1 | 1, depth + 1)\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.662` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/661-670/664. 奇怪的打印机（困难）.md", "url_title": "664. 奇怪的打印机", "url": "https://leetcode-cn.com/problems/strange-printer/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-xqeo9/", "difficulty": "困难", "tags": ["区间 DP"], "question": "有台奇怪的打印机有以下两个特殊要求:\n\n* 打印机每次只能打印由 同一个字符 组成的序列。\n* 每次可以在任意起始和结束位置打印新字符,并且会覆盖掉原来已有的字符。\n\n给你一个字符串 `s`,你的任务是计算这个打印机打印它需要的最少打印次数。\n\n示例 1:\n```\n输入:s = \"aaabbb\"\n\n输出:2\n\n解释:首先打印 \"aaa\" 然后打印 \"bbb\"。\n```\n示例 2:\n```\n输入:s = \"aba\"\n\n输出:2\n\n解释:首先打印 \"aaa\" 然后在第二个位置打印 \"b\" 覆盖掉原来的字符 'a'。\n```\n\n提示:\n* $1 <= s.length <= 100$\n* `s` 由小写英文字母组成", "solution": "### 基本分析\n\n首先,根据题意我们可以分析出一个重要推论:**连续相同的一段字符,必然可以归到同一次打印中,而不会让打印次数变多。注意,这里说的是「归到一次」,而不是说「单独作为一次」。**\n\n怎么理解这句话呢?\n\n举个 🌰,对于诸如 `...bbaaabb...` 的样例数据,其中多个连续的 `a` 必然可以归到同一次打印中,但这一次打印可能只是将 `aaa` 作为整体进行打印;也有可能是 `aaa` 与前面或者后面的 `a` 作为整体被打印(然后中间的 `b` 被后来的打印所覆盖)。但无论是何种情况连续一段的 `aaa` 必然是可以「归到同一次打印」中。\n\n**我们可以不失一般性证明「连续相同的一段字符,必然可以归到同一次打印中,而不会让打印次数变多」这个推理是否正确:**\n\n假设有目标序列 $[...,ai,...,aj,...]$ 其中 $[i, j]$ 连续一段字符相同,假如这一段的打印被最后完成(注意最后完成不代表这一段要保留空白,这一段可以此前被打印多次),除了这一段以外所消耗的打印次数为 $x$,那么根据 $[i, j]$ 不同的打印方案有:\n\n1. 将 $[i, j]$ 单纯划分为多段:总共打印的次数大于 $x + 1$(此方案不会取到打印最小值 $x + 1$,可忽略)\n2. 将 $[i, j]$ 归到同一次打印:总共打印的次数等于 $x + 1$\n3. 将 $[i, j]$ 结合之前的打印划分为多段,即 $[i, j]$ 一段的两段本身就是「目标字符」,我们本次只需要打印 $[i, j]$ 中间的部分。总共打印的次数等于 $x + 1$\n\n由于同样的地方可以被重复打印,因此我们可以将情况 $3$ 中打印边缘扩展到 $i$ 和 $j$ 处,这样最终打印结果不变,而且总的打印次数没有增加。\n\n到这一步,我们其实已经证明出「连续相同的一段字符,必然可以归到同一次打印中,而不会让打印次数变多」的推论成立了。\n\n但可能会有同学提出疑问:怎么保证 $[i, j]$ 是被最后涂的?怎么保证 $[i, j]$ 不是和其他「不相邻的同样字符」一起打印的?\n\n**答案是不用保证,因为不同状态(打印结果)之间相互独立,而有明确的最小转移成本。即从当前打印结果 `a` 变成打印结果 `b`,是具有明确的最小打印次数的(否则本题无解)。因此我们上述的分析可以看做任意两个中间状态转移的“最后一步”,而且不会整体的结果。**\n\n对应到本题,题目给定的起始状态是空白字符串 `a`,目标状态是入参字符串 `s`。那么真实最优解中,从 `a` 状态到 `s` 状态中间可能会经过任意个中间状态,假设有两个中间状态 `p` 和 `q`,那么我们上述的分析就可以应用到中间状态 `p` 到 `q` 的转移中,可以令得 `p` 到 `q` 转移所花费的转移成本最低(最优),同时这个转移不会影响「`a` 到 `p` 的转移」和「`q` 到 `s` 的转移」,是相互独立的。\n\n因此这个分析可以推广到真实最优转移路径中的任意一步,是一个具有一般性的结论。\n\n上述分析是第一个切入点,第二个切入点是「重复打印会进行覆盖」,这意味着我们其实不需要确保 $[i,j]$ 这一段在目标字符串中完全相同,而只需要 $s[i] = s[j]$ 相同即可,即后续打印不会从边缘上覆盖 $[i,j]$ 区间的原有打印,否则 $[i,j]$ 这一段的打印就能用范围更小的区间所代替。\n\n这样就引导出我们状态转移的关键:状态转移之间只需要确保首位字符相同。\n\n---\n\n### 动态规划\n\n定义 $f[l][r]$ 为将 $[l, r]$ 这一段打印成目标结果所消耗的最小打印次数。\n\n不失一般性考虑 $f[l][r]$ 该如何转移:\n\n* 只染 $l$ 这个位置,此时 $f[l][r] = f[l + 1][r] + 1$\n* 不只染 $l$ 这个位置,而是从 $l$ 染到 $k$(需要确保首位相同 $s[l] = s[k]$):$f[l][r] = f[l][k - 1] + f[k + 1][r], l < k <= r$\n\n其中状态转移方程中的情况 $2$ 需要说明一下:由于我们只确保 $s[l] = s[k]$,并不确保 $[l, k]$ 之间的字符相同,根据我们基本分析可知,$s[k]$ 这个点可由打印 $s[l]$ 的时候一同打印,因此本身 $s[k]$ 并不独立消耗打印次数,所以这时候 $[l, k]$ 这一段的最小打印次数应该取 $f[l][k - 1]$,而不是 $f[l][k]$。\n\n最终的 $f[l][r]$ 为上述所有方案中取 $min$。\n\n代码:\n```Java\nclass Solution {\n    public int strangePrinter(String s) {\n        int n = s.length();\n        int[][] f = new int[n + 1][n + 1];\n        for (int len = 1; len <= n; len++) {\n            for (int l = 0; l + len - 1 < n; l++) {\n                int r = l + len - 1;\n                f[l][r] = f[l + 1][r] + 1;\n                for (int k = l + 1; k <= r; k++) {\n                    if (s.charAt(l) == s.charAt(k)) {\n                        f[l][r] = Math.min(f[l][r], f[l][k - 1] + f[k + 1][r]);\n                    }\n                }\n            }\n        }\n        return f[0][n - 1];\n    }\n}\n```\n* 时间复杂度:$O(n^3)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 总结\n\n这道题的原型应该出自 [String painter](http://acm.hdu.edu.cn/showproblem.php?pid=2476)。\n\n如果只是为了把题做出来,难度不算特别大,根据数据范围 $10^2$,可以猜到是 $O(n^3)$ 做法,通常就是区间 DP 的「枚举长度 + 枚举左端点 + 枚举分割点」的三重循环。\n\n但是要搞懂为啥可以这样做,还是挺难,大家感兴趣的话可以好好想想 ~  🤣", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.664` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/661-670/667. 优美的排列 II（中等）.md", "url_title": "667. 优美的排列 II", "url": "https://leetcode.cn/problems/beautiful-arrangement-ii/solution/by-ac_oier-lyns/", "difficulty": "中等", "tags": ["构造", "脑筋急转弯"], "question": "给你两个整数 `n` 和 `k` ,请你构造一个答案列表 `answer`,该列表应当包含从 `1` 到 `n` 的 `n` 个不同正整数,并同时满足下述条件:\n\n假设该列表是 $answer = [a_1, a_2, a_3, ... , a_n]$ ,那么列表 $[|a_1 - a_2|, |a_2 - a_3|, |a_3 - a_4|, ... , |a_{n-1} - a_n|]$ 中应该有且仅有 k 个不同整数。\n\n返回列表 `answer`。如果存在多种答案,只需返回其中 任意一种 。\n\n示例 1:\n```\n输入:n = 3, k = 1\n\n输出:[1, 2, 3]\n\n解释:[1, 2, 3] 包含 3 个范围在 1-3 的不同整数,并且 [1, 1] 中有且仅有 1 个不同整数:1\n```\n示例 2:\n```\n输入:n = 3, k = 2\n\n输出:[1, 3, 2]\n\n解释:[1, 3, 2] 包含 3 个范围在 1-3 的不同整数,并且 [2, 1] 中有且仅有 2 个不同整数:1 和 2\n```\n\n提示:\n* $1 <= k < n <= 10^4$", "solution": "### 构造\n\n给定范围在 $[1, n]$ 的 $n$ 个数,当「直接升序/降序」排列时,相邻项差值为 $1$,仅一种;而从首位开始按照「升序」间隔排列,次位开始按照「降序」间隔排列(即排列为 `[1, n, 2, n - 1, 3, ...]`)时,相邻差值会从 $n - 1$ 开始递减至 $1$,共 $n - 1$ 种。\n\n那么当我们需要构造 $k$ 种序列时,我们可以先通过「直接升序」的方式构造出若干个 $1$,然后再通过「间隔位分别升降序」的方式构造出从 $k$ 到 $1$ 的差值,共 $k$ 个。\n\n显然,我们需要 $k + 1$ 个数来构造出 $k$ 个差值。因此我们可以先从 $1$ 开始,使用 $n - (k + 1)$ 个数来直接升序(通过方式一构造出若干个 $1$),然后从 $n - k$ 开始间隔升序排列,按照 $n$ 开始间隔降序排列,构造出剩下的序列。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] constructArray(int n, int k) {\n        int[] ans = new int[n];\n        int t = n - k - 1;\n        for (int i = 0; i < t; i++) ans[i] = i + 1;\n        for (int i = t, a = n - k, b = n; i < n; ) {\n            ans[i++] = a++;\n            if (i < n) ans[i++] = b--;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction constructArray(n: number, k: number): number[] {\n    const ans = new Array<number>(n).fill(0)\n    const t = n - k - 1\n    for (let i = 0; i < t; i++) ans[i] = i + 1\n    for (let i = t, a = n - k, b = n; i < n; ) {\n        ans[i++] = a++\n        if (i < n) ans[i++] = b--\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.667` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/661-670/668. 乘法表中第k小的数（困难）.md", "url_title": "668. 乘法表中第k小的数", "url": "https://leetcode.cn/problems/kth-smallest-number-in-multiplication-table/solution/by-ac_oier-7pmt/", "difficulty": "困难", "tags": ["二分", "计数"], "question": "几乎每一个人都用 乘法表,但是你能在乘法表中快速找到第 $k$ 小的数字吗?\n\n给定高度 $m$ 、宽度 $n$ 的一张 $m \\times n$ 的乘法表,以及正整数 $k$,你需要返回表中第 $k$ 小的数字。\n\n例 1:\n```\n输入: m = 3, n = 3, k = 5\n\n输出: 3\n\n解释: \n乘法表:\n1\t2\t3\n2\t4\t6\n3\t6\t9\n\n第5小的数字是 3 (1, 2, 2, 3, 3).\n```\n例 2:\n```\n输入: m = 2, n = 3, k = 6\n\n输出: 6\n\n解释: \n乘法表:\n1\t2\t3\n2\t4\t6\n\n第6小的数字是 6 (1, 2, 2, 3, 4, 6).\n```\n注意:\n* $m$ 和 $n$ 的范围在 $[1, 30000]$ 之间。\n* $k$ 的范围在 $[1, m \\times n]$ 之间。", "solution": "### 二分 + 计数判定\n\n由于 $n$ 和 $m$ 的数据范围都是 $3 \\times 10^4$,总数本身就超过了 $10^7$,我们考虑线性复杂度往下的对数复杂度。\n\n题目要求我们求一维展开有序序列中的第 $k$ 小的数,问题本身具有「二段性」:\n\n* 答案右边的每个数均 **满足**「其在一维展开有序序列中左边数的个数大于等于 $k$ 个」\n* 答案左边的每个数均 **不满足**「其在一维展开有序序列中左边数的个数大于等于 $k$ 个」\n\n我们考虑如何进行「二分答案」: 假设当前我们二分到的值是 $mid$,对于乘法表中的每行和每列均是单调递增,我们可以通过累加统计 每行/每列 中比 $mid$ 小的数,记作 $a$,累加统计 每行/每列 中等于 $mid$ 的数,记作 $b$,那么 $cnt = a + b$ 即是整个乘法表中小于等于 $mid$ 的数的个数,再通过 $cnt$ 和 $k$ 的大小关系来指导左右指针的变化。\n\n具体的,假设我们通过枚举行来统计 $a$ 和 $b$,当前枚举到的行号为 $i$(行号从 $1$ 开始),该行的最大数为 $i \\times m$:\n\n* 若 $i \\times m < mid$,整行都是小于 $mid$ 的数,直接在 $a$ 基础上累加 $m$;\n* 若 $i \\times m >= mid$,根据 $mid$ 是否存在于该行进行分情况讨论:\n    * $mid$ 能够被 $i$ 整除,说明 $mid$ 存在于该行,那么比 $mid$ 小的数的个数为 $\\frac{mid}{i} - 1$,将其累加到 $a$,同时对 $b$ 进行加一;\n    * $mid$ 不能够被 $i$ 整除,说明 $mid$ 不存在于该行,那么比 $mid$ 小的数的个数为 $\\frac{mid}{i}$,将其累加到 $a$。\n\n> 一些细节:由于乘法表具有对称性,我们统计时可以对 行和列 中较小的一方进行遍历。\n\n代码:\n```Java\nclass Solution {\n    int n, m, k;\n    public int findKthNumber(int _m, int _n, int _k) {\n        n = Math.min(_m, _n); m = Math.max(_m, _n); k = _k;\n        int l = 1, r = m * n;\n        while (l < r) {\n            int mid = l + r >> 1, cnt = getCnt(mid);\n            if (cnt >= k) r = mid;\n            else l = mid + 1;\n        }\n        return r;\n    }\n    int getCnt(int mid) {\n        int a = 0, b = 0;\n        for (int i = 1; i <= n; i++) {\n            if (i * m < mid) {\n                a += m;\n            } else {\n                if (mid % i == 0 && ++b >= 0) a += mid / i - 1;\n                else a += mid / i;\n            }\n        }\n        return a + b;\n    }\n}\n```\n* 时间复杂度:$O(\\min(n, m) \\times \\log{nm})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.668` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/661-670/669. 修剪二叉搜索树（中等）.md", "url_title": "669. 修剪二叉搜索树", "url": "https://leetcode.cn/problems/trim-a-binary-search-tree/solution/by-ac_oier-help/", "difficulty": "中等", "tags": ["BST", "二叉树", "递归", "迭代"], "question": "给你二叉搜索树的根节点 `root`,同时给定最小边界 `low` 和最大边界 `high`。通过修剪二叉搜索树,使得所有节点的值在 $[low, high]$ 中。修剪树 不应该 改变保留在树中的元素的相对结构 (即,如果没有被移除,原有的父代子代关系都应当保留)。 可以证明,存在 唯一的答案 。\n\n所以结果应当返回修剪好的二叉搜索树的新的根节点。注意,根节点可能会根据给定的边界发生改变。\n\n示例 1:\n\n```\n输入:root = [1,0,2], low = 1, high = 2\n\n输出:[1,null,2]\n```\n示例 2:\n\n```\n输入:root = [3,0,4,null,2,null,null,1], low = 1, high = 3\n\n输出:[3,2,null,1]\n```\n\n提示:\n* 树中节点数在范围 $[1, 10^4]$ 内\n* $0 <= Node.val <= 10^4$\n* 树中每个节点的值都是 唯一 的\n* 题目数据保证输入是一棵有效的二叉搜索树\n* $0 <= low <= high <= 10^4$", "solution": "### 递归\n\n由于被修剪的是二叉搜索树,因此修剪过程必然能够顺利进行。\n\n容易想到使用原函数作为递归函数:\n\n* 若 `root.val` 小于边界值 `low`,则 `root` 的左子树必然均小于边界值,我们递归处理 `root.right` 即可;\n* 若 `root.val` 大于边界值 `high`,则 `root` 的右子树必然均大于边界值,我们递归处理 `root.left` 即可;\n* 若 `root.val` 符合要求,则 `root` 可被保留,递归处理其左右节点并重新赋值即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public TreeNode trimBST(TreeNode root, int low, int high) {\n        if (root == null) return null;\n        if (root.val < low) return trimBST(root.right, low, high);\n        else if (root.val > high) return trimBST(root.left, low, high);\n        root.left = trimBST(root.left, low, high);\n        root.right = trimBST(root.right, low, high);\n        return root;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction trimBST(root: TreeNode | null, low: number, high: number): TreeNode | null {\n    if (root == null) return null\n    if (root.val < low) return trimBST(root.right, low, high)\n    else if (root.val > high) return trimBST(root.left, low, high)\n    root.left = trimBST(root.left, low, high)\n    root.right = trimBST(root.right, low, high)\n    return root\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$\n\n---\n\n### 迭代\n\n自然能够使用「迭代」进行求解:起始先从给定的 `root` 进行出发,找到第一个满足值符合 $[low, high]$ 范围的节点,该节点为最后要返回的根节点 `ans`。\n\n随后考虑如何修剪 `ans` 的左右节点:当根节点符合 $[low, high]$ 要求时,修剪左右节点过程中仅需考虑一边的边界值即可。即对于 `ans.left` 只需考虑将值小于 `low` 的节点去掉(因为二叉搜索树的特性,`ans` 满足不大于 `high` 要求,则其左节点必然满足);同理 `ans.right` 只需要考虑将大于 `high` 的节点去掉即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public TreeNode trimBST(TreeNode root, int low, int high) {\n        while (root != null && (root.val < low || root.val > high)) root = root.val < low ? root.right : root.left;\n        TreeNode ans = root;\n        while (root != null) {\n            while (root.left != null && root.left.val < low) root.left = root.left.right;\n            root = root.left;\n        }\n        root = ans;\n        while (root != null) {\n            while (root.right != null && root.right.val > high) root.right = root.right.left;\n            root = root.right;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction trimBST(root: TreeNode | null, low: number, high: number): TreeNode | null {\n    while (root != null && (root.val < low || root.val > high)) root = root.val < low ? root.right : root.left\n    const ans = root\n    while (root != null) {\n        while (root.left != null && root.left.val < low) root.left = root.left.right\n        root = root.left\n    }\n    root = ans\n    while (root != null) {\n        while (root.right != null && root.right.val > high) root.right = root.right.left\n        root = root.right\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.669` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/661-670/670. 最大交换（中等）.md", "url_title": "670. 最大交换", "url": "https://leetcode.cn/problems/maximum-swap/solution/by-ac_oier-jxmh/", "difficulty": "中等", "tags": ["模拟"], "question": "给定一个非负整数,你至多可以交换一次数字中的任意两位。\n\n返回你能得到的最大值。\n\n示例 1 :\n```\n输入: 2736\n\n输出: 7236\n\n解释: 交换数字2和数字7。\n```\n示例 2 :\n```\n输入: 9973\n\n输出: 9973\n\n解释: 不需要交换。\n```\n注意:\n* 给定数字的范围是 $[0, 10^8]$", "solution": "### 模拟\n\n根据题意,我们应当将大的数放置在高位,而当有数值相同的多个大数时,我们应当选择低位的数字。\n\n因此,我们可以先将 `num` 的每一位处理出来存放到数组 `list` 中,随后预处理一个与 `list` 等长的数组 `idx`,带来代指 `num` 后缀中最大值对应的下标,即当 `idx[i] = j` 含义为在下标为 $[0, i]$ 位中 $num[j]$ 对应的数值最大。\n\n同时由于我们需要遵循「当有数值相同的多个大数时,选择低位的数字」原则,我们应当出现采取严格大于才更新的方式来预处理 `idx`。\n\n最后则是从高位往低位遍历,找到第一个替换的位置进行交换,并重新拼凑回答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maximumSwap(int num) {\n        List<Integer> list = new ArrayList<>();\n        while (num != 0) {\n            list.add(num % 10); num /= 10;\n        }\n        int n = list.size(), ans = 0;\n        int[] idx = new int[n];\n        for (int i = 0, j = 0; i < n; i++) {\n            if (list.get(i) > list.get(j)) j = i;\n            idx[i] = j;\n        }\n        for (int i = n - 1; i >= 0; i--) {\n            if (list.get(idx[i]) != list.get(i)) {\n                int c = list.get(idx[i]);\n                list.set(idx[i], list.get(i));\n                list.set(i, c);\n                break;\n            }\n        }\n        for (int i = n - 1; i >= 0; i--) ans = ans * 10 + list.get(i);\n        return ans; \n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maximumSwap(int num) {\n        vector<int> list;\n        while (num != 0) {\n            list.push_back(num % 10); num /= 10;\n        }\n        int n = list.size(), ans = 0;\n        int* idx = new int[n];\n        for (int i = 0, j = 0; i < n; i++) {\n            if (list[i] > list[j]) j = i;\n            idx[i] = j;\n        }\n        for (int i = n - 1; i >= 0; i--) {\n            if (list[idx[i]] != list[i]) {\n                int c = list[idx[i]];\n                list[idx[i]] = list[i];\n                list[i] = c;\n                break;\n            }\n        }\n        for (int i = n - 1; i >= 0; i--) ans = ans * 10 + list[i];\n        return ans; \n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maximumSwap(self, num: int) -> int:\n        nums = []\n        while num != 0:\n            nums.append(num % 10); num //= 10\n        n, ans = len(nums), 0\n        idx = [0] * n\n        i, j = 0, 0\n        while i < n:\n            if nums[i] > nums[j]: j = i\n            idx[i] = j\n            i += 1\n        for i in range(n - 1, -1, -1):\n            if nums[idx[i]] != nums[i]:\n                c = nums[idx[i]]\n                nums[idx[i]] = nums[i]\n                nums[i] = c\n                break\n        for i in range(n - 1, -1, -1):\n            ans = ans * 10 + nums[i]\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction maximumSwap(num: number): number {\n    const list = new Array<number>()\n    while (num != 0) {\n        list.push(num % 10)\n        num = Math.floor(num / 10)\n    }\n    let n = list.length, ans = 0\n    const idx = new Array<number>()\n    for (let i = 0, j = 0; i < n; i++) {\n        if (list[i] > list[j]) j = i\n        idx.push(j)\n    }\n    for (let i = n - 1; i >= 0; i--) {\n        if (list[idx[i]] != list[i]) {\n            const c = list[idx[i]]\n            list[idx[i]] = list[i]\n            list[i] = c\n            break\n        }\n    }\n    for (let i = n - 1; i >= 0; i--) ans = ans * 10 + list[i];\n    return ans\n};\n```\n* 时间复杂度:$O(\\log{num})$\n* 空间复杂度:$O(\\log{num})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.670` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/671-680/671. 二叉树中第二小的节点（简单）.md", "url_title": "671. 二叉树中第二小的节点", "url": "https://leetcode-cn.com/problems/second-minimum-node-in-a-binary-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-shu-d-eupu/", "difficulty": "简单", "tags": ["二叉树", "树的遍历", "递归"], "question": "给定一个非空特殊的二叉树,每个节点都是正数,并且每个节点的子节点数量只能为 2 或 0。如果一个节点有两个子节点的话,那么该节点的值等于两个子节点中较小的一个。\n\n更正式地说,root.val = min(root.left.val, root.right.val) 总成立。\n\n给出这样的一个二叉树,你需要输出所有节点中的第二小的值。如果第二小的值不存在的话,输出 -1 。\n\n \n\n示例 1:\n\n```\n输入:root = [2,2,5,null,null,5,7]\n\n输出:5\n\n解释:最小的值是 2 ,第二小的值是 5 。\n```\n示例 2:\n\n```\n输入:root = [2,2,2]\n\n输出:-1\n\n解释:最小的值是 2, 但是不存在第二小的值。\n```\n提示:\n* 树中节点数目在范围 $[1, 25]$ 内\n* $1$ <= Node.val <= $2^{31}$ - 1\n* 对于树中每个节点 root.val == min(root.left.val, root.right.val)", "solution": "### 树的遍历\n\n一个朴素的做法是,直接对树进行遍历(广度 & 深度),使用 `HashSet` 进行存储,得到所有去重后的节点大小。\n\n然后找次小值的方式有多种:可以通过排序找次小值,复杂度为 $O(n\\log{n})$;也可以使用经典的两个变量 & 一次遍历的方式,找到次小值,复杂度为 $O(n)$。\n\n代码:\n```Java\nclass Solution {\n    Set<Integer> set = new HashSet<>();\n    public int findSecondMinimumValue(TreeNode root) {\n        dfs(root);\n        if (set.size() < 2) return -1;\n        int first = Integer.MAX_VALUE, second = Integer.MAX_VALUE;\n        for (int i : set) {\n            if (i <= first) {\n                second = first;\n                first = i;\n            } else if (i <= second) {\n                second = i;\n            }\n        }\n        return second;\n    }\n    void dfs(TreeNode root) {\n        if (root == null) return;\n        set.add(root.val);\n        dfs(root.left);\n        dfs(root.right);\n    }\n}\n```\n```Java\nclass Solution {\n    Set<Integer> set = new HashSet<>();\n    public int findSecondMinimumValue(TreeNode root) {\n        bfs(root);\n        if (set.size() < 2) return -1;\n        int first = Integer.MAX_VALUE, second = Integer.MAX_VALUE;\n        for (int i : set) {\n            if (i <= first) {\n                second = first;\n                first = i;\n            } else if (i <= second) {\n                second = i;\n            }\n        }\n        return second;\n    }\n    void bfs(TreeNode root) {\n        Deque<TreeNode> d = new ArrayDeque<>();\n        d.addLast(root);\n        while (!d.isEmpty()) {\n            TreeNode poll = d.pollFirst();\n            set.add(poll.val);\n            if (poll.left != null) d.addLast(poll.left);\n            if (poll.right != null) d.addLast(poll.right);\n        }\n    }\n}\n```\n* 时间复杂度:树的搜索复杂度为 $O(n)$,通过线性遍历找次小值,复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 递归\n\n解法一显然没有利用到本题核心条件 :「`root.val = min(root.left.val, root.right.val)`」和「每个子节点数量要么是 `0` 要么是 `2`」。\n\n我们可以设计如下递归函数,含义为 **从 `root` 为根的树进行搜索,找到值比 `cur` 大的最小数**。然后使用全局变量 `ans` 存储答案。\n```Java\nvoid dfs(TreeNode root, int cur)\n```\n\n那么最终搜索范围为 `dfs(root, root.val)`,这是因为 **性质 `root.val = min(root.left.val, root.right.val)`,即最小值会不断往上传递,最终根节点必然是全局最小值**。\n\n然后再结合「每个子节点数量要么是 `0` 要么是 `2`」,我们可以特判一下 `ans` 是否为第一次赋值,如果给 `ans` 赋了新值或者更新了更小的 `ans`,则不再需要往下搜索了。\n\n代码:\n```Java\nclass Solution {\n    int ans = -1;\n    public int findSecondMinimumValue(TreeNode root) {\n        dfs(root, root.val);\n        return ans;\n    }\n    void dfs(TreeNode root, int cur) {\n        if (root == null) return ;\n        if (root.val != cur) {\n            if (ans == -1) ans = root.val;\n            else ans = Math.min(ans, root.val);\n            return ;\n        }\n        dfs(root.left, cur);\n        dfs(root.right, cur);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:忽略递归带来的空间开销。复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.671` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/671-680/672. 灯泡开关 Ⅱ（中等）.md", "url_title": "672. 灯泡开关 II", "url": "https://leetcode.cn/problems/bulb-switcher-ii/solution/by-ac_oier-3ttx/", "difficulty": "中等", "tags": ["脑筋急转弯", "找规律"], "question": "房间中有 `n` 只已经打开的灯泡,编号从 `1` 到 `n` 。\n\n墙上挂着 `4` 个开关 ,这 `4` 个开关各自都具有不同的功能,其中:\n\n* 开关 1 :反转当前所有灯的状态(即开变为关,关变为开)\n* 开关 2 :反转编号为偶数的灯的状态(即 `2, 4, ...`)\n* 开关 3 :反转编号为奇数的灯的状态(即 `1, 3, ...`)\n* 开关 4 :反转编号为 `j = 3k + 1` 的灯的状态,其中 `k = 0, 1, 2, ...`(即 `1, 4, 7, 10, ...`)\n\n你必须 恰好 按压开关 `presses` 次。每次按压,你都需要从 `4` 个开关中选出一个来执行按压操作。\n\n给你两个整数 `n` 和 `presses`,执行完所有按压之后,返回 不同可能状态 的数量。\n\n示例 1:\n```\n输入:n = 1, presses = 1\n\n输出:2\n\n解释:状态可以是:\n- 按压开关 1 ,[关]\n- 按压开关 2 ,[开]\n```\n示例 2:\n```\n输入:n = 2, presses = 1\n\n输出:3\n\n解释:状态可以是:\n- 按压开关 1 ,[关, 关]\n- 按压开关 2 ,[开, 关]\n- 按压开关 3 ,[关, 开]\n```\n示例 3:\n```\n输入:n = 3, presses = 1\n\n输出:4\n\n解释:状态可以是:\n- 按压开关 1 ,[关, 关, 关]\n- 按压开关 2 ,[关, 开, 关]\n- 按压开关 3 ,[开, 关, 开]\n- 按压开关 4 ,[关, 开, 开]\n```\n\n提示:\n* $1 <= n <= 1000$\n* $0 <= presses <= 1000$", "solution": "### 分情况讨论\n\n记灯泡数量为 $n$(至少为 $1$),翻转次数为 $k$(至少为 $0$),使用 `1` 代表灯亮,使用 `0` 代表灯灭。\n\n我们根据 $n$ 和 $k$ 的数值分情况讨论:\n\n* 当 $k = 0$ 时,无论 $n$ 为何值,都只有起始(全 `1`)一种状态;\n* 当 $k > 0$ 时,根据 $n$ 进一步分情况讨论:\n    * 当 $n = 1$ 时,若 $k$ 为满足「$k > 0$」的最小值 $1$ 时,能够取满「`1`/`0`」两种情况,而其余更大 $k$ 值情况能够使用操作无效化(不影响灯的状态);\n    * 当 $n = 2$ 时,若 $k = 1$,能够取得「`00`/`10`/`01`」三种状态,当 $k = 2$ 时,能够取满「`11`/`10`/`01`/`00`」四种状态,其余更大 $k$ 可以通过前 $k - 1$ 步归结到任一状态,再通过最后一次的操作 $1$ 归结到任意状态;\n    * 当 $n = 3$ 时,若 $k = 1$ 时,对应 $4$ 种操作可取得 $4$ 种方案;当 $k = 2$ 时,可取得 $7$ 种状态;而当 $k = 3$ 时可取满 $2^3 = 8$ 种状态,更大的 $k$ 值可通过同样的方式归结到取满的 $8$ 种状态。\n    * 当 $n > 3$ 时,根据四类操作可知,灯泡每 $6$ 组一循环(对应序列 `k + 1`、`2k + 2`、`2k + 1` 和 `3k + 1`),即只需考虑 $n <= 6$ 的情况,而 $n = 4$、$n = 5$ 和 $n = 6$ 时,后引入的灯泡状态均不会产生新的组合(即新引入的灯泡状态由前三个灯泡的状态所唯一确定),因此均可归纳到 $n = 3$ 的情况。\n\nJava 代码:\n```Java\nclass Solution {\n    public int flipLights(int n, int k) {\n        if (k == 0) return 1;\n        if (n == 1) return 2;\n        else if (n == 2) return k == 1 ? 3 : 4;\n        else return k == 1 ? 4 : k == 2 ? 7 : 8;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int flipLights(int n, int k) {\n        if (k == 0) return 1;\n        if (n == 1) return 2;\n        else if (n == 2) return (k == 1) ? 3 : 4;\n        else return (k == 1) ? 4 : (k == 2) ? 7 : 8;\n    }\n};\n```\nPython 3 代码:\n```Python\nclass Solution:\n    def flipLights(self, n: int, k: int) -> int:\n        if k == 0:\n            return 1\n        if n == 1:\n            return 2\n        elif n == 2:\n            return 3 if k == 1 else 4\n        else:\n            return 4 if k == 1 else 7 if k == 2 else 8\n```\nTypeScript 代码:\n```TypeScript\nfunction flipLights(n: number, k: number): number {\n    if (k == 0) return 1\n    if (n == 1) return 2\n    else if (n == 2) return k == 1 ? 3 : 4;\n    else return k == 1 ? 4 : k == 2 ? 7 : 8;\n};\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.672` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/671-680/673. 最长递增子序列的个数（中等）.md", "url_title": "673. 最长递增子序列的个数", "url": "https://leetcode-cn.com/problems/number-of-longest-increasing-subsequence/solution/gong-shui-san-xie-lis-de-fang-an-shu-wen-obuz/", "difficulty": "中等", "tags": ["动态规划", "序列 DP", "树状数组", "最长上升子序列"], "question": "给定一个未排序的整数数组,找到最长递增子序列的个数。\n\n示例 1:\n```\n输入: [1,3,5,4,7]\n\n输出: 2\n\n解释: 有两个最长递增子序列,分别是 [1, 3, 4, 7] 和[1, 3, 5, 7]。\n```\n示例 2:\n```\n输入: [2,2,2,2,2]\n\n输出: 5\n\n解释: 最长递增子序列的长度是1,并且存在5个子序列的长度为1,因此输出5。\n注意: 给定的数组长度不超过 2000 并且结果一定是32位有符号整数。\n```\n提示: \n* $1 <= nums.length <= 2000$\n* $-10^6 <= nums[i] <= 10^6$", "solution": "### 序列 DP\n\n与朴素的 LIS 问题(问长度)相比,本题问的是最长上升子序列的个数。\n\n我们只需要在朴素 LIS 问题的基础上通过「记录额外信息」来进行求解即可。\n\n在朴素的 LIS 问题中,我们定义 **$f[i]$ 为考虑以 $nums[i]$ 为结尾的最长上升子序列的长度。** 最终答案为所有 $f[0...(n - 1)]$ 中的最大值。\n\n不失一般性地考虑 $f[i]$ 该如何转移:\n\n* 由于每个数都能独自一个成为子序列,因此起始必然有 $f[i] = 1$;\n* 枚举区间 $[0, i)$ 的所有数 $nums[j]$,如果满足 $nums[j] < nums[i]$,说明 $nums[i]$ 可以接在 $nums[j]$ 后面形成上升子序列,此时使用 $f[j]$ 更新 $f[i]$,即有 $f[i] = f[j] + 1$。\n\n回到本题,由于我们需要求解的是最长上升子序列的个数,因此需要额外定义 **$g[i]$ 为考虑以 $nums[i]$ 结尾的最长上升子序列的个数。**\n\n结合 $f[i]$ 的转移过程,不失一般性地考虑 $g[i]$ 该如何转移:\n\n* 同理,由于每个数都能独自一个成为子序列,因此起始必然有 $g[i] = 1$;\n* 枚举区间 $[0, i)$ 的所有数 $nums[j]$,如果满足 $nums[j] < nums[i]$,说明 $nums[i]$ 可以接在 $nums[j]$ 后面形成上升子序列,这时候对 $f[i]$ 和 $f[j] + 1$ 的大小关系进行分情况讨论:\n    * 满足 $f[i] < f[j] + 1$:说明 $f[i]$ 会被 $f[j] + 1$ 直接更新,此时同步直接更新 $g[i] = g[j]$ 即可;\n    * 满足 $f[i] = f[j] + 1$:说明找到了一个新的符合条件的前驱,此时将值继续累加到方案数当中,即有 $g[i] += g[j]$。\n\n在转移过程,我们可以同时记录全局最长上升子序列的最大长度 $max$,最终答案为所有满足 $f[i] = max$ 的 $g[i]$ 的累加值。\n\nJava 代码:\n```Java\nclass Solution {\n    public int findNumberOfLIS(int[] nums) {\n        int n = nums.length;\n        int[] f = new int[n], g = new int[n];\n        int max = 1;\n        for (int i = 0; i < n; i++) {\n            f[i] = g[i] = 1;\n            for (int j = 0; j < i; j++) {\n                if (nums[j] < nums[i]) {\n                    if (f[i] < f[j] + 1) {\n                        f[i] = f[j] + 1; g[i] = g[j];\n                    } else if (f[i] == f[j] + 1) {\n                        g[i] += g[j];\n                    }\n                }\n            }\n            max = Math.max(max, f[i]);\n        }\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            if (f[i] == max) ans += g[i];\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int findNumberOfLIS(vector<int>& nums) {\n        int n = nums.size();\n        vector<int> f(n), g(n);\n        int maxv = 1;\n        for (int i = 0; i < n; i++) {\n            f[i] = g[i] = 1;\n            for (int j = 0; j < i; j++) {\n                if (nums[j] < nums[i]) {\n                    if (f[i] < f[j] + 1) {\n                        f[i] = f[j] + 1;\n                        g[i] = g[j];\n                    } else if (f[i] == f[j] + 1) {\n                        g[i] += g[j];\n                    }\n                }\n            }\n            maxv = max(maxv, f[i]);\n        }\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            if (f[i] == maxv) ans += g[i];\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def findNumberOfLIS(self, nums: List[int]) -> int:\n        n = len(nums)\n        f, g = [1] * n, [1] * n\n        maxv = 1\n        for i in range(1, n):\n            for j in range(i):\n                if nums[j] < nums[i]:\n                    if f[i] < f[j] + 1:\n                        f[i], g[i] = f[j] + 1, g[j]\n                    elif f[i] == f[j] + 1:\n                        g[i] += g[j]\n            maxv = max(maxv, f[i])\n        ans = 0\n        for i in range(n):\n            if f[i] == maxv: ans += g[i]\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction findNumberOfLIS(nums: number[]): number {\n    const n = nums.length;\n    let f = new Array(n).fill(1), g = new Array(n).fill(1);\n    let max = 1;\n    for (let i = 1; i < n; i++) {\n        for (let j = 0; j < i; j++) {\n            if (nums[j] < nums[i]) {\n                if (f[i] < f[j] + 1) {\n                    f[i] = f[j] + 1;\n                    g[i] = g[j];\n                } else if (f[i] == f[j] + 1) {\n                    g[i] += g[j];\n                }\n            }\n        }\n        max = Math.max(max, f[i]);\n    }\n    let ans = 0;\n    for (let i = 0; i < n; i++) {\n        if (f[i] == max) ans += g[i];\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n)$\n\n---\n\n### LIS 问题的贪心解 + 树状数组\n\n我们知道,对于朴素的 LIS 问题存在贪心解法,能够在 $O(n\\log{n})$ 复杂度内求解 LIS 问题。\n\n在贪心解中,我们会多开一个贪心数组 $q$,用来记录长度为 $len$ 的最长上升子序列的「最小结尾元素」为何值:**$q[len] = x$ 代表长度为 $len$ 的最长上升子序列的最小结尾元素为 $x$。**\n\n**可以证明 $q$ 存在单调性,因此每次确定 $nums[i]$ 可以接在哪个 $nums[j]$ 后面会形成最长上升子序列时,可以通过「二分」来找到满足 $nums[j] < nums[i]$ 的最大下标来实现。**\n\n对于本题,由于我们需要求最长上升子序列的个数,单纯使用一维的贪心数组记录最小结尾元素并不足以。\n\n考虑对其进行扩展,期望能取到「最大长度」的同时,能够知道这个「最大长度」对应多少个子序列数量,同时期望该操作复杂度为 $O(\\log{n})$。\n\n我们可以使用「树状数组」维护二元组 $(len, cnt)$ 信息:\n\n1. 因为数据范围较大($-10^6 <= nums[i] <= 10^6$),但数的个数为 $2000$,因此第一步先对 $nums$ 进行离散化操作;\n2. 在遍历 $nums$ 时,每次从树状数组中查询值严格小于 $nums[i]$ 离散值(利用 $nums[i]$ 离散化后的值仍为正整数,我们可以直接查询小于等于 $nums[i]$ 离散值 $-1$ 的值)的最大长度,及最大长度对应的数量;\n3. 对于流程 $2$ 中查得的 $(len, cnt)$,由于 $nums[i]$ 可以接在其后,因此首先长度加一,同时数量将 $cnt$ 累加到该离散值中。\n\nJava 代码:\n```Java\nclass Solution {\n    int n;\n    int[][] tr = new int[2010][2];\n    int lowbit(int x) {\n        return x & -x;\n    }\n    int[] query(int x) {\n        int len = 0, cnt = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) {\n            if (len == tr[i][0]) {\n                cnt += tr[i][1];\n            } else if (len < tr[i][0]) {\n                len = tr[i][0];\n                cnt = tr[i][1];\n            }\n        }\n        return new int[]{len, cnt};\n    }\n    void add(int x, int[] info) {\n        for (int i = x; i <= n; i += lowbit(i)) {\n            int len = tr[i][0], cnt = tr[i][1];\n            if (len == info[0]) {\n                cnt += info[1];\n            } else if (len < info[0]) {\n                len = info[0];\n                cnt = info[1];\n            }\n            tr[i][0] = len; tr[i][1] = cnt;\n        }\n    }\n    public int findNumberOfLIS(int[] nums) {\n        n = nums.length;\n        // 离散化\n        int[] tmp = nums.clone();\n        Arrays.sort(tmp);\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = 0, idx = 1; i < n; i++) {\n            if (!map.containsKey(tmp[i])) map.put(tmp[i], idx++);\n        }\n        // 树状数组维护 (len, cnt) 信息\n        for (int i = 0; i < n; i++) {\n            int x = map.get(nums[i]);\n            int[] info = query(x - 1);\n            int len = info[0], cnt = info[1];            \n            add(x, new int[]{len + 1, Math.max(cnt, 1)});\n        }\n        int[] ans = query(n);\n        return ans[1];\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.673` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/671-680/675. 为高尔夫比赛砍树（困难）.md", "url_title": "675. 为高尔夫比赛砍树", "url": "https://leetcode.cn/problems/cut-off-trees-for-golf-event/solution/by-ac_oier-ksth/", "difficulty": "困难", "tags": ["图论 BFS", "AStar 算法", "启发式搜索", "并查集"], "question": "你被请来给一个要举办高尔夫比赛的树林砍树。树林由一个 $m \\times n$ 的矩阵表示, 在这个矩阵中:\n\n* $0$ 表示障碍,无法触碰\n* $1$ 表示地面,可以行走\n* 比 $1$ 大的数 表示有树的单元格,可以行走,数值表示树的高度\n\n每一步,你都可以向上、下、左、右四个方向之一移动一个单位,如果你站的地方有一棵树,那么你可以决定是否要砍倒它。\n\n你需要按照树的高度从低向高砍掉所有的树,每砍过一颗树,该单元格的值变为 $1$(即变为地面)。\n\n你将从 $(0, 0)$ 点开始工作,返回你砍完所有树需要走的最小步数。 如果你无法砍完所有的树,返回 $-1$ 。\n\n可以保证的是,没有两棵树的高度是相同的,并且你至少需要砍倒一棵树。\n\n示例 1:\n\n```\n输入:forest = [[1,2,3],[0,0,4],[7,6,5]]\n\n输出:6\n\n解释:沿着上面的路径,你可以用 6 步,按从最矮到最高的顺序砍掉这些树。\n```\n示例 2:\n\n```\n输入:forest = [[1,2,3],[0,0,0],[7,6,5]]\n\n输出:-1\n\n解释:由于中间一行被障碍阻塞,无法访问最下面一行中的树。\n```\n示例 3:\n```\n输入:forest = [[2,3,4],[0,0,5],[8,7,6]]\n\n输出:6\n\n解释:可以按与示例 1 相同的路径来砍掉所有的树。\n(0,0) 位置的树,可以直接砍去,不用算步数。\n```\n\n提示:\n* $m == forest.length$\n* $n == forest[i].length$\n* $1 <= m, n <= 50$\n* $0 <= forest[i][j] <= 10^9$", "solution": "### 基本分析 \n\n基本题意为:给定一个 $n \\times m$ 的矩阵,每次能够在当前位置往「四联通」移动一个单位,其中 $0$ 的位置代表障碍(无法访问),$1$ 的位置代表平地(可直接访问,且无须进行任何决策),其余大于 $1$ 的位置代表有树,经过该位置的时候可以考虑将树砍掉(相应值变为平地 $1$)。\n\n同时题目限定了我们只能按照「从低到高」的顺序进行砍树,并且图中不存在高度相等的两棵树,这意味着 **整个砍树的顺序唯一确定,就是对所有有树的地方进行「高度」排升序,即是完整的砍树路线。**\n\n而另外一个更为重要的性质是:**点与点之间的最短路径,不会随着砍树过程的进行而发生变化(某个树点被砍掉,只会变为平地,不会变为阻碍点,仍可通过)。**\n\n综上,**砍树的路线唯一确定,当我们求出每两个相邻的砍树点最短路径,并进行累加即是答案(整条砍树路径的最少步数)**。\n\n---\n\n### BFS\n\n因此,再结合数据范围只有 $50$,并且点与点之间边权为 $1$(每次移动算一步),我们可以直接进行 `BFS` 进行求解。\n\n先对整张图进行一次遍历,预处理出所有的树点(以三元组 $(height, x, y)$ 的形式进行存储),并对其以 $height$ 排升序,得到唯一确定的砍树路径。\n\n之后就是计算砍树路径中相邻点的最短距离,运用 `BFS` 求解任意两点的最短路径复杂度为 $O(n \\times m)$,我们最多有 $n \\times m$ 个树点,因此整体复杂度为 $O(n^2 * \\times m^2)$。\n\n求解相邻点的最短距离的部分也是整个算法的复杂度上界,数据范围只有 $50$,计算量不超过 $10^7$,可以过。\n\n代码:\n```Java\nclass Solution {\n    int N = 50;\n    int[][] g = new int[N][N];\n    int n, m;\n    List<int[]> list = new ArrayList<>();\n    public int cutOffTree(List<List<Integer>> forest) {\n        n = forest.size(); m = forest.get(0).size();\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                g[i][j] = forest.get(i).get(j);\n                if (g[i][j] > 1) list.add(new int[]{g[i][j], i, j});\n            }\n        }\n        Collections.sort(list, (a,b)->a[0]-b[0]);\n        if (g[0][0] == 0) return -1;\n        int x = 0, y = 0, ans = 0;\n        for (int[] ne : list) {\n            int nx = ne[1], ny = ne[2];\n            int d = bfs(x, y, nx, ny);\n            if (d == -1) return -1;\n            ans += d;\n            x = nx; y = ny;\n        }\n        return ans;\n    }\n    int[][] dirs = new int[][]{{0,1},{0,-1},{1,0},{-1,0}};\n    int bfs(int X, int Y, int P, int Q) {\n        if (X == P && Y == Q) return 0;\n        boolean[][] vis = new boolean[n][m];\n        Deque<int[]> d = new ArrayDeque<>();\n        d.addLast(new int[]{X, Y});\n        vis[X][Y] = true;\n        int ans = 0;\n        while (!d.isEmpty()) {\n            int size = d.size();\n            while (size-- > 0) {\n                int[] info = d.pollFirst();\n                int x = info[0], y = info[1];\n                for (int[] di : dirs) {\n                    int nx = x + di[0], ny = y + di[1];\n                    if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;\n                    if (g[nx][ny] == 0 || vis[nx][ny]) continue;\n                    if (nx == P && ny == Q) return ans + 1;\n                    d.addLast(new int[]{nx, ny});\n                    vis[nx][ny] = true;\n                }\n            }\n            ans++;\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:预处理出所有树点的复杂度为 $O(n \\times m)$,对树点进行排序的复杂度为 $O(nm \\log{nm})$,最多有 $n \\times m$ 个树点,对每两个相邻树点运用 `BFS`  求最短路的复杂度为 $O(n \\times m)$,统计完整路径的复杂度为 $O(n^2 \\times m^2)$\n* 空间复杂度:$O(n \\times m)$\n\n---\n\n### AStar 算法\n\n**由于问题的本质是求最短路,同时原问题的边权为 $1$,因此套用其他复杂度比 `BFS` 高的最短路算法,对于本题而言是没有意义,但运用启发式搜索 AStar 算法来优化则是有意义。**\n\n因为在 `BFS` 过程中,我们会无差别往「四联通」方向进行搜索,直到找到「当前树点的下一个目标位置」为止,而实际上,两点之间的最短路径往往与两点之间的相对位置相关。\n\n举个 🌰,当前我们在位置 $S$,我们目标位置是 $T$,而 $T$ 在 $S$ 的右下方,此时我们应当优先搜索方向\"往右下方\"的路径,当无法从\"往右下方\"的路径到达 $T$,我们再考虑搜索其他大方向的路径:\n\n如何设计这样带有优先级的搜索顺序,则是 AStar 算法「启发式函数」的设计过程,其本质是对应了对「最小步数」的估算,只有当我们确保「最小步数估算 $\\leq $ 实际最小步数」,AStar 算法的正确性才得以保证。\n\n因此我们往往会直接使用「理论最小步数」来作为启发式函数的,对于本题,可直接使用「曼哈顿距离」作为「理论最小步数」。\n\n因此,如果我们是要从源点 $S$ 到汇点 $T$,并且当前位于中途点 $x$ 的话,点 $x$ 的最小步数估算包括两部分:**到点 $x$ 的实际步数 + 从点 $x$ 到点 $T$ 的理论最小步数(曼哈顿距离)**。使用「优先队列」按照「总的最小步数估算」进行出队,即可实现 AStar 算法的搜索顺序。\n\n> **AStar 算法做过很多次了,相关合集可以在 [这里](https://sharingsource.github.io/tags/AStar-%E7%AE%97%E6%B3%95/) 看到。**\n另外,网上很多对 AStar 正确性证明不了解的人,会缺少以下 `map.get(nidx) > step + 1` 判断逻辑。\n简单来说,启发式函数的设计是针对汇点而言的,**因此 AStar 算法搜索过程只确保对 $T$ 的出入队次序能够对应回到点 $T$ 第 $k$ 短路,而对于其余点的出入队次序到其余点的最短路没有必然的对应关系,因此当某个点的最小步数被更新,我们是要将其进行再次入队的。**\n\n代码:\n```Java\nclass Solution {\n    int N = 50;\n    int[][] g = new int[N][N];\n    int n, m;\n    List<int[]> list = new ArrayList<>();\n    public int cutOffTree(List<List<Integer>> forest) {\n        n = forest.size(); m = forest.get(0).size();\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                g[i][j] = forest.get(i).get(j);\n                if (g[i][j] > 1) list.add(new int[]{g[i][j], i, j});\n            }\n        }\n        if (g[0][0] == 0) return -1;\n        Collections.sort(list, (a,b)->a[0]-b[0]);\n        int x = 0, y = 0, ans = 0;\n        for (int[] ne : list) {\n            int nx = ne[1], ny = ne[2];\n            int d = astar(x, y, nx, ny);\n            if (d == -1) return -1;\n            ans += d;\n            x = nx; y = ny;\n        }\n        return ans;\n    }\n    int[][] dirs = new int[][]{{0,1},{0,-1},{1,0},{-1,0}};\n    int getIdx(int x, int y) {\n        return x * m + y;\n    }\n    int f(int X, int Y, int P, int Q) {\n        return Math.abs(X - P) + Math.abs(Y - Q);\n    }\n    int astar(int X, int Y, int P, int Q) {\n        if (X == P && Y == Q) return 0;\n        Map<Integer, Integer> map = new HashMap<>();\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[0]-b[0]);\n        q.add(new int[]{f(X, Y, P, Q), X, Y});\n        map.put(getIdx(X, Y), 0);\n        while (!q.isEmpty()) {\n            int[] info = q.poll();\n            int x = info[1], y = info[2], step = map.get(getIdx(x, y));\n            for (int[] di : dirs) {\n                int nx = x + di[0], ny = y + di[1], nidx = getIdx(nx, ny);\n                if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;\n                if (g[nx][ny] == 0) continue;\n                if (nx == P && ny == Q) return step + 1;\n                if (!map.containsKey(nidx) || map.get(nidx) > step + 1) {\n                    q.add(new int[]{step + 1 + f(nx, ny, P, Q), nx, ny});\n                    map.put(nidx, step + 1);\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:启发式搜索分析时空复杂度意义不大\n* 空间复杂度:启发式搜索分析时空复杂度意义不大\n\n---\n\n### AStar 算法 + 并查集预处理无解\n\n我们知道,AStar 算法使用到了「优先队列(堆)」来进行启发式搜索,而对于一些最佳路径方向与两点相对位置相反(例如 $T$ 在 $S$ 的右边,但由于存在障碍,最短路径需要先从左边绕一圈才能到 $T$),AStar 反而会因为优先队列(堆)而多一个 $\\log$ 的复杂度。\n\n因此一个可行的优化是,我们先提前处理「无解」的情况,常见的做法是在预处理过程中运用「并查集」来维护连通性。\n\n这种对于不影响复杂度上界的预处理相比后续可能出现的大量无效搜索(最终无解)的计算量而言,是有益的。\n\n代码:\n```Java\nclass Solution {\n    int N = 50;\n    int[][] g = new int[N][N];\n    int n, m;\n    int[] p = new int[N * N + 10];\n    List<int[]> list = new ArrayList<>();\n    void union(int a, int b) {\n        p[find(a)] = p[find(b)];\n    }\n    boolean query(int a, int b) {\n        return find(a) == find(b);\n    }\n    int find(int x) {\n        if (p[x] != x) p[x] = find(p[x]);\n        return p[x];\n    }\n    int getIdx(int x, int y) {\n        return x * m + y;\n    }\n    public int cutOffTree(List<List<Integer>> forest) {\n        n = forest.size(); m = forest.get(0).size();\n        // 预处理过程中,同时使用「并查集」维护连通性\n        for (int i = 0; i < n * m; i++) p[i] = i;\n        int[][] tempDirs = new int[][]{{0,-1},{-1,0}};\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                g[i][j] = forest.get(i).get(j);\n                if (g[i][j] > 1) list.add(new int[]{g[i][j], i, j});\n                if (g[i][j] == 0) continue;\n                // 只与左方和上方的区域联通即可确保不重不漏\n                for (int[] di : tempDirs) {\n                    int nx = i + di[0], ny = j + di[1];\n                    if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;\n                    if (g[nx][ny] != 0) union(getIdx(i, j), getIdx(nx, ny));\n                }\n            }\n        }\n        // 若不满足所有树点均与 (0,0),提前返回无解\n        for (int[] info : list) {\n            int x = info[1], y = info[2];\n            if (!query(getIdx(0, 0), getIdx(x, y))) return -1;\n        }\n        Collections.sort(list, (a,b)->a[0]-b[0]);\n        int x = 0, y = 0, ans = 0;\n        for (int[] ne : list) {\n            int nx = ne[1], ny = ne[2];\n            int d = astar(x, y, nx, ny);\n            if (d == -1) return -1;\n            ans += d;\n            x = nx; y = ny;\n        }\n        return ans;\n    }\n    int f(int X, int Y, int P, int Q) {\n        return Math.abs(X - P) + Math.abs(Y - Q);\n    }\n    int[][] dirs = new int[][]{{0,1},{0,-1},{1,0},{-1,0}};\n    int astar(int X, int Y, int P, int Q) {\n        if (X == P && Y == Q) return 0;\n        Map<Integer, Integer> map = new HashMap<>();\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[0]-b[0]);\n        q.add(new int[]{f(X, Y, P, Q), X, Y});\n        map.put(getIdx(X, Y), 0);\n        while (!q.isEmpty()) {\n            int[] info = q.poll();\n            int x = info[1], y = info[2], step = map.get(getIdx(x, y));\n            for (int[] di : dirs) {\n                int nx = x + di[0], ny = y + di[1], nidx = getIdx(nx, ny);\n                if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;\n                if (g[nx][ny] == 0) continue;\n                if (nx == P && ny == Q) return step + 1;\n                if (!map.containsKey(nidx) || map.get(nidx) > step + 1) {\n                    q.add(new int[]{step + 1 + f(nx, ny, P, Q), nx, ny});\n                    map.put(nidx, step + 1);\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:启发式搜索分析时空复杂度意义不大\n* 空间复杂度:启发式搜索分析时空复杂度意义不大", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.675` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/671-680/676. 实现一个魔法字典（中等）.md", "url_title": "676. 实现一个魔法字典", "url": "https://leetcode.cn/problems/cut-off-trees-for-golf-event/solution/by-ac_oier-ksth/", "difficulty": "中等", "tags": ["字典树", "DFS"], "question": "设计一个使用单词列表进行初始化的数据结构,单词列表中的单词 互不相同 。 如果给出一个单词,请判定能否只将这个单词中一个字母换成另一个字母,使得所形成的新单词存在于你构建的字典中。\n\n实现 `MagicDictionary` 类:\n\n* `MagicDictionary()` 初始化对象\n* `void buildDict(String[] dictionary)` 使用字符串数组 `dictionary` 设定该数据结构,`dictionary` 中的字符串互不相同\n* `bool search(String searchWord)` 给定一个字符串 `searchWord`,判定能否只将字符串中 一个 字母换成另一个字母,使得所形成的新字符串能够与字典中的任一字符串匹配。如果可以,返回 `true`;否则,返回 `false`。\n\n示例:\n```\n输入\n[\"MagicDictionary\", \"buildDict\", \"search\", \"search\", \"search\", \"search\"]\n[[], [[\"hello\", \"leetcode\"]], [\"hello\"], [\"hhllo\"], [\"hell\"], [\"leetcoded\"]]\n\n输出\n[null, null, false, true, false, false]\n\n解释\nMagicDictionary magicDictionary = new MagicDictionary();\nmagicDictionary.buildDict([\"hello\", \"leetcode\"]);\nmagicDictionary.search(\"hello\"); // 返回 False\nmagicDictionary.search(\"hhllo\"); // 将第二个 'h' 替换为 'e' 可以匹配 \"hello\" ,所以返回 True\nmagicDictionary.search(\"hell\"); // 返回 False\nmagicDictionary.search(\"leetcoded\"); // 返回 False\n```\n\n提示:\n* $1 <= dictionary.length <= 100$\n* $1 <= dictionary[i].length <= 100$\n* `dictionary[i]` 仅由小写英文字母组成\n* `dictionary` 中的所有字符串 互不相同\n* $1 <= searchWord.length <= 100$\n* `searchWord` 仅由小写英文字母组成\n* `buildDict` 仅在 `search` 之前调用一次\n* 最多调用 $100$ 次 `search`", "solution": "### Trie + DFS\n\n为了方便,我们令 `dictionary` 为 `ss`,令 `searchWord` 为 `s`。\n\n整体题意:给定字符串 `s`,问能否存在替换掉 `s` 中的某个字符,使得新字符串出现在 `ss` 数组中。\n\n考虑如何使用「字典树/`Trie`」求解该问题:\n*  `buildDict` 操作:我们可以将所有的 $ss[i]$ 存入字典树中,方便后续检索;\n\n* `search` 操作:设计递归函数 `boolean query(String s, int idx, int p, int limit)`,其中 `s` 为待检索的字符串,`idx` 为当前处理到字符串 `s` 的哪一位,`p` 为当前搜索到字典树的索引编号(起始有 $p = 0$),`limit` 为当前剩余的替换字符次数,根据题意,`limit` 固定为 $1$,含义为必须替换掉 `s` 的一个字符。\n    对于 $s[idx]$ 而言,我们可以枚举新字符串在当前位置是何种字符($C = 26$ 个选择),若当前枚举到的字符与 $s[idx]$ 一致,则不消耗替换次数。\n    爆搜过程中替换次数为负数直接剪枝,当爆搜到结尾位置,再检查当前的字典树索引 $p$ 是否为单词结尾节点(对应查询数组 `ss` 中是否存在该字符串),以及剩余的替换次数 `limit` 是否为 $0$。\n\n> **不了解「Trie / 字典树」的同学可以看前置 🧀:[字典树入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089)。里面通过图例展示了字典树基本形态,以及提供了「数组实现」和「TrieNode 实现」两种方式,还有「数组大小估算方式」和「Trie 应用面」介绍**\n\nJava 代码:\n```Java\nclass MagicDictionary {\n    int N = 100 * 100, M = 26, idx = 0;\n    int[][] tr = new int[N][M];\n    boolean[] isEnd = new boolean[N * M];\n    void add(String s) {\n        int p = 0;\n        for (int i = 0; i < s.length(); i++) {\n            int u = s.charAt(i) - 'a';\n            if (tr[p][u] == 0) tr[p][u] = ++idx;\n            p = tr[p][u];\n        }\n        isEnd[p] = true;\n    }\n    boolean query(String s, int idx, int p, int limit) {\n        if (limit < 0) return false;\n        if (idx == s.length()) return isEnd[p] && limit == 0;\n        int u = s.charAt(idx) - 'a';\n        for (int i = 0; i < 26; i++) {\n            if (tr[p][i] == 0) continue;\n            if (query(s, idx + 1, tr[p][i], i == u ? limit : limit - 1)) return true;\n        }\n        return false;\n    }\n    public void buildDict(String[] ss) {\n        for (String s : ss) add(s);\n    }\n    public boolean search(String s) {\n        return query(s, 0, 0, 1);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nclass MagicDictionary {\n    N: number = 100 * 100; M: number = 26; idx: number = 0;\n    tr: number[][] = new Array<Array<number>>(this.N)\n    isEnd: boolean[] = new Array<boolean>(this.N * this.M).fill(false)\n    add(s: string): void {\n        let p = 0\n        for (let i = 0; i < s.length; i++) {\n            const u = s.charCodeAt(i) - 'a'.charCodeAt(0)\n            if (this.tr[p] == undefined) this.tr[p] = new Array<number>(this.M).fill(0)\n            if (this.tr[p][u] == 0) this.tr[p][u] = ++this.idx\n            p = this.tr[p][u]\n        }\n        this.isEnd[p] = true\n    }\n    query(s: string, idx: number, p: number, limit: number): boolean {\n        if (limit < 0) return false\n        if (idx == s.length) return this.isEnd[p] && limit == 0\n        const u = s.charCodeAt(idx) - 'a'.charCodeAt(0)\n        for (let i = 0; i < 26; i++) {\n            if (this.tr[p] == undefined || this.tr[p][i] == 0) continue\n            if (this.query(s, idx + 1, this.tr[p][i], i == u ? limit : limit - 1)) return true\n        }\n        return false\n    }\n    buildDict(ss: string[]): void {\n        for (const s of ss) this.add(s)\n    }\n    search(s: string): boolean {\n        return this.query(s, 0, 0, 1)\n    }\n}\n```\n* 时间复杂度:`buildDict` 操作需要将所有字符存入 `Trie`,复杂度为 $\\sum_{i = 0}^{n - 1} len(ss[i]])$;`search` 操作在不考虑 `limit` 以及字典树中最多只有 $100$ 具体方案所带来的剪枝效果的话,最坏情况下要搜索所有 $C^L$ 个方案,其中 $C = 26$ 为字符集大小,$L = 100$ 为搜索字符串的最大长度\n* 空间复杂度:$O(N \\times L \\times C)$,其中 $N = 100$ 为存入 `Trie` 的最大方案数,$L = 100$ 为存入字符串的最大长度,$C = 26$ 为字符集大小\n\n---\n\n### 模拟\n\n当然,利用数据范围只有 $100$,直接使用模拟也是可以的。\n\nJava 代码:\n```Java\nclass MagicDictionary {\n    String[] ss;\n    public void buildDict(String[] _ss) {\n        ss = _ss;\n    }\n    public boolean search(String str) {\n        for (String s : ss) {\n            int cnt = 0;\n            for (int i = 0; s.length() == str.length() && i < s.length() && cnt <= 1; i++) {\n                if (s.charAt(i) != str.charAt(i)) cnt++;\n            }\n            if (cnt == 1) return true;\n        }\n        return false;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nclass MagicDictionary {\n    ss: string[]\n    buildDict(_ss: string[]): void {\n        this.ss = _ss\n    }\n    search(s: string): boolean {\n        for (const str of this.ss) {\n            let cnt = 0\n            for (let i = 0; str.length == s.length && i < s.length && cnt <= 1; i++) {\n                if (s.charAt(i) != str.charAt(i)) cnt++\n            }\n            if (cnt == 1) return true\n        }\n        return false\n    }\n}\n```\n* 时间复杂度:`buildDict` 操作复杂度为 $O(1)$;`search` 操作复杂度为 $O(n \\times L)$,其中 $n$ 为数组 `ss` 的长度,$L$ 为查询字符串的长度\n* 空间复杂度:$O(n)$\n\n---\n\n### 加餐\n\n1. 前置练习题 [可用 Trie 进阶的模拟题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492214&idx=1&sn=40fa070fe3b014873297f7ff740ba60f)\n\n2. 另外一道 [结合 DFS 的 Trie 运用题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247492188&idx=1&sn=a1436d1ffe2b8200a36c3196ca1c7ed1)", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.676` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/671-680/677. 键值映射（中等）.md", "url_title": "677. 键值映射", "url": "https://leetcode-cn.com/problems/map-sum-pairs/solution/gong-shui-san-xie-jie-he-dfs-de-trie-yun-i4xa/", "difficulty": "中等", "tags": ["字典树", "DFS", "哈希表"], "question": "实现一个 `MapSum` 类,支持两个方法,`insert` 和 `sum`:\n\n* `MapSum()` 初始化 `MapSum` 对象\n* `void insert(String key, int val)` 插入 `key-val` 键值对,字符串表示键 `key` ,整数表示值 `val` 。如果键 `key` 已经存在,那么原来的键值对将被替代成新的键值对。\n* `int sum(string prefix)` 返回所有以该前缀 `prefix` 开头的键 `key` 的值的总和。\n\n示例:\n```\n输入:\n[\"MapSum\", \"insert\", \"sum\", \"insert\", \"sum\"]\n[[], [\"apple\", 3], [\"ap\"], [\"app\", 2], [\"ap\"]]\n\n输出:\n[null, null, 3, null, 5]\n\n解释:\nMapSum mapSum = new MapSum();\nmapSum.insert(\"apple\", 3);  \nmapSum.sum(\"ap\");           // return 3 (apple = 3)\nmapSum.insert(\"app\", 2);    \nmapSum.sum(\"ap\");           // return 5 (apple + app = 3 + 2 = 5)\n```\n\n提示:\n* $1 <= key.length, prefix.length <= 50$\n* `key` 和 `prefix` 仅由小写英文字母组成\n* `1 <= val <= 1000`\n* 最多调用 `50` 次 `insert` 和 `sum`", "solution": "### Trie + DFS\n\n从需要实现「存储字符串(映射关系)」并「检索某个字符串前缀的总和」来看,可以知道这是与 $Trie$ 相关的题目,还不了解 $Trie$ 的同学可以先看前置 🧀:[实现 Trie (前缀树)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089&chksm=fd9cb8f5caeb31e3f7f67dba981d8d01a24e26c93ead5491edb521c988adc0798d8acb6f9e9d&token=59039721&lang=zh_CN#rd) 。\n\n考虑如何实现两个操作:\n\n* `insert` :在基本的 $Trie$ 插入操作的基础上进行拓展即可。与常规的插入操作的唯一区别为,不能简单记录单词的结束位置,还要存储 $key$ 对应的 $val$ 是多少。具体的我们可以使用 `int` 类型的数组 $hash$ 来代替原有的 `boolean` 类型的数组 $isWord$;\n\n* `sum` : 先对入参 $prefix$ 进行字典树搜索,到达尾部后再使用 `DFS` 搜索后面的所有方案,并累加结果。\n\n代码(`static` 优化代码见 $P2$,避免每个样例都 `new` 大数组):\n```Java\nclass MapSum {\n    int[][] tr = new int[2510][26];\n    int[] hash = new int[2510];\n    int idx;\n    public void insert(String key, int val) {\n        int p = 0;\n        for (int i = 0; i < key.length(); i++) {\n            int u = key.charAt(i) - 'a';\n            if (tr[p][u] == 0) tr[p][u] = ++idx;\n            p = tr[p][u];\n        }\n        hash[p] = val;\n    }\n    public int sum(String prefix) {\n        int p = 0;\n        for (int i = 0; i < prefix.length(); i++) {\n            int u = prefix.charAt(i) - 'a';\n            if (tr[p][u] == 0) return 0;\n            p = tr[p][u];\n        }\n        return dfs(p);\n    }\n    int dfs(int p) {\n        int ans = hash[p];\n        for (int u = 0; u < 26; u++) {\n            if (tr[p][u] != 0) ans += dfs(tr[p][u]);\n        }\n        return ans;\n    }\n}\n```\n\n```Java\nclass MapSum {\n    static int[][] tr = new int[2510][26];\n    static int[] hash = new int[2510];\n    static int idx;\n    public MapSum() {\n        for (int i = 0; i <= idx; i++) Arrays.fill(tr[i], 0);\n        Arrays.fill(hash, 0);\n        idx = 0;\n    }\n    public void insert(String key, int val) {\n        int p = 0;\n        for (int i = 0; i < key.length(); i++) {\n            int u = key.charAt(i) - 'a';\n            if (tr[p][u] == 0) tr[p][u] = ++idx;\n            p = tr[p][u];\n        }\n        hash[p] = val;\n    }\n    public int sum(String prefix) {\n        int p = 0;\n        for (int i = 0; i < prefix.length(); i++) {\n            int u = prefix.charAt(i) - 'a';\n            if (tr[p][u] == 0) return 0;\n            p = tr[p][u];\n        }\n        return dfs(p);\n    }\n    int dfs(int p) {\n        int ans = hash[p];\n        for (int u = 0; u < 26; u++) {\n            if (tr[p][u] != 0) ans += dfs(tr[p][u]);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $key$ 的最大长度为 $n$,最大调用次数为 $m$,字符集大小为 $C$( 本题 $C$ 固定为 $26$ ),`insert` 操作的复杂度为 $O(n)$;从 `DFS` 的角度分析,`sum` 操作的复杂度为 $O(C^n)$,但事实上,对于本题具有明确的计算量上界,搜索所有的格子的复杂度为 $O(n \\times m \\times C)$\n* 空间复杂度:$O(n \\times m \\times C)$\n\n---\n\n### Trie 记录前缀字符串总和\n\n为降低 `sum` 操作的复杂度,我们可以在 `insert` 操作中同时记录(累加)每个前缀的总和。\n\n代码(`static` 优化代码见 $P2$,避免每个样例都 `new` 大数组):\n```Java\nclass MapSum {\n    int N = 2510;\n    int[][] tr = new int[N][26];\n    int[] hash = new int[N];\n    int idx;\n    Map<String, Integer> map = new HashMap<>();\n    public void insert(String key, int val) {\n        int _val = val;\n        if (map.containsKey(key)) val -= map.get(key);\n        map.put(key, _val);\n        for (int i = 0, p = 0; i < key.length(); i++) {\n            int u = key.charAt(i) - 'a';\n            if (tr[p][u] == 0) tr[p][u] = ++idx;\n            p = tr[p][u];\n            hash[p] += val;\n        }\n    }\n    public int sum(String prefix) {\n        int p = 0;\n        for (int i = 0; i < prefix.length(); i++) {\n            int u = prefix.charAt(i) - 'a';\n            if (tr[p][u] == 0) return 0;\n            p = tr[p][u];\n        }\n        return hash[p];\n    }\n}\n```\n\n```Java\nclass MapSum {\n    static int N = 2510;\n    static int[][] tr = new int[N][26];\n    static int[] hash = new int[N];\n    static int idx;\n    static Map<String, Integer> map = new HashMap<>();\n    public MapSum() {\n        for (int i = 0; i <= idx; i++) Arrays.fill(tr[i], 0);\n        Arrays.fill(hash, 0);\n        idx = 0;\n        map.clear();\n    }\n    public void insert(String key, int val) {\n        int _val = val;\n        if (map.containsKey(key)) val -= map.get(key);\n        map.put(key, _val);\n        for (int i = 0, p = 0; i < key.length(); i++) {\n            int u = key.charAt(i) - 'a';\n            if (tr[p][u] == 0) tr[p][u] = ++idx;\n            p = tr[p][u];\n            hash[p] += val;\n        }\n    }\n    public int sum(String prefix) {\n        int p = 0;\n        for (int i = 0; i < prefix.length(); i++) {\n            int u = prefix.charAt(i) - 'a';\n            if (tr[p][u] == 0) return 0;\n            p = tr[p][u];\n        }\n        return hash[p];\n    }\n}\n```\n* 时间复杂度:令 $key$ 的最大长度为 $n$,`insert` 操作的复杂度为 $O(n)$;`sum` 操作的复杂度为 $O(n)$\n* 空间复杂度:令 $key$ 的最大长度为 $n$,最大调用次数为 $m$,字符集大小为 $C$( 本题 $C$ 固定为 $26$ ),复杂度为 $O(n \\times m \\times C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.677` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/671-680/678. 有效的括号字符串（中等）.md", "url_title": "678. 有效的括号字符串", "url": "https://leetcode-cn.com/problems/valid-parenthesis-string/solution/gong-shui-san-xie-yi-ti-shuang-jie-dong-801rq/", "difficulty": "中等", "tags": ["有效括号问题", "动态规划", "模拟"], "question": "给定一个只包含三种字符的字符串:`(` ,`)` 和 `*`,写一个函数来检验这个字符串是否为有效字符串。\n\n有效字符串具有如下规则:\n* 任何左括号 `(` 必须有相应的右括号 `)`。\n* 任何右括号 `)` 必须有相应的左括号 `(` 。\n* 左括号 `(` 必须在对应的右括号之前 `)`。\n* 可以被视为单个右括号 `)` ,或单个左括号 `(` ,或一个空字符串。\n* 一个空字符串也被视为有效字符串。\n\n示例 1:\n\n```\n输入: \"()\"\n\n输出: True\n```\n示例 2:\n```\n输入: \"(*)\"\n\n输出: True\n```\n示例 3:\n```\n输入: \"(*))\"\n\n输出: True\n```\n\n注意:\n* 字符串大小将在 $[1,100]$ 范围内。", "solution": "### 动态规划\n\n**定义 $f[i][j]$ 为考虑前 $i$ 个字符(字符下标从 $1$ 开始),能否与 $j$ 个右括号形成合法括号序列。**\n\n起始时只有 $f[0][0]$ 为 $true$,最终答案为 $f[n][0]$。\n\n不失一般性的考虑 $f[i][j]$ 该如何转移:\n\n* 当前字符为 `(` : 如果 $f[i][j]$ 为 $true$,必然有 $f[i - 1][j - 1]$ 为 $true$,反之亦然。即有 $f[i][j] = f[i - 1][j - 1]$;\n* 当前字符为 `)` : 如果 $f[i][j]$ 为 $true$,必然有 $f[i - 1][j + 1]$ 为 $true$,反之亦然。即有 $f[i][j] = f[i - 1][j + 1]$;\n* 当前字符为 `*` : 根据 `*` 代指的符号不同,分为三种情况,只有有一种情况为 $true$ 即可。即有 $f[i][j] = f[i - 1][j - 1] ∨ f[i - 1][j + 1] ∨ f[i - 1][j]$。\n\n代码:\n```Java\nclass Solution {\n    public boolean checkValidString(String s) {\n        int n = s.length();\n        boolean[][] f = new boolean[n + 1][n + 1];\n        f[0][0] = true;\n        for (int i = 1; i <= n; i++) {\n            char c = s.charAt(i - 1);\n            for (int j = 0; j <= i; j++) {\n                if (c == '(') {\n                    if (j - 1 >= 0) f[i][j] = f[i - 1][j - 1];\n                } else if (c == ')') {\n                    if (j + 1 <= i) f[i][j] = f[i - 1][j + 1];\n                } else {\n                    f[i][j] = f[i - 1][j];\n                    if (j - 1 >= 0) f[i][j] |= f[i - 1][j - 1];\n                    if (j + 1 <= i) f[i][j] |= f[i - 1][j + 1];\n                }\n            }\n        }\n        return f[n][0];\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 模拟\n\n通过解法一,我们进一步发现,对于某个 $f[i][x]$ 而言(即动规数组中的某一行),值为 $true$ 的必然为连续一段。\n\n即 **由于存在可变化的 `*` 符号,因此考虑在考虑前 $i$ 个字符,其能与消耗的左括号的数量具有明确的「上界与下界」。且当前上界与下界的变化,仅取决于「当前为何种字符」,以及「处理上一个字符时上界与下界为多少」。**\n\n但直接记录所能消耗的左括号上限和下限需要处理较多的边界问题。\n\n我们可以使用与[(题解)301. 删除无效的括号](https://leetcode-cn.com/problems/remove-invalid-parentheses/solution/yi-fen-zhong-nei-kan-dong-jiang-gua-hao-aya6k/) 类似的思路:\n\n令左括号的得分为 $1$;右括号的得分为 $-1$。那么对于合法的方案而言,必定满足最终得分为 $0$。\n\n同时由于本题存在 `*`,因此我们需要记录得分的区间区间是多少,而不仅是一个具体的得分。\n\n具体的,使用两个变量 `l` 和 `r` 分别表示「最低得分」和「最高得分」。\n\n根据当前处理到的字符进行分情况讨论:\n\n* 当前字符为 `(` : `l` 和 `r` 同时加一;\n* 当前字符为 `)` : `l` 和 `r` 同时减一;\n* 当前字符为 `*` : 如果 `*` 代指成 `(` 的话,`l` 和 `r` 都进行加一;如果 `*` 代指成 `)` 的话,`l` 和 `r` 都进行减一;如果 `*` 不变的话,`l` 和 `r` 均不发生变化。因此总的 `l` 的变化为减一,总的 `r` 的变化为加一。\n\n需要注意的是,在匹配过程中如果 `l` 为负数,需要重置为 $0$,因为如果当前序列本身为不合法括号序列的话,增加 `(` 必然还是不合法。同时,当出现 `l > r` 说明上界为负数,即右括号过多,必然为非合法方案,返回 $false$。\n\n代码:\n```Java\nclass Solution {\n    public boolean checkValidString(String s) {\n        int l = 0, r = 0;\n        for (char c : s.toCharArray()) {\n            if (c == '(') {\n                l++; r++;\n            } else if (c == ')') {\n                l--; r--;\n            } else {\n                l--; r++;\n            }\n            l = Math.max(l, 0);\n            if (l > r) return false;\n        }\n        return l == 0;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.678` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/681-690/682. 棒球比赛（简单）.md", "url_title": "682. 棒球比赛", "url": "https://leetcode-cn.com/problems/baseball-game/solution/by-ac_oier-4mhz/", "difficulty": "简单", "tags": ["模拟"], "question": "你现在是一场采用特殊赛制棒球比赛的记录员。这场比赛由若干回合组成,过去几回合的得分可能会影响以后几回合的得分。\n\n比赛开始时,记录是空白的。你会得到一个记录操作的字符串列表 `ops`,其中 $ops[i]$ 是你需要记录的第 $i$ 项操作,`ops` 遵循下述规则:\n\n1. 整数 `x` - 表示本回合新获得分数 `x`\n2. `\"+\"` - 表示本回合新获得的得分是前两次得分的总和。题目数据保证记录此操作时前面总是存在两个有效的分数。\n3. `\"D\"` - 表示本回合新获得的得分是前一次得分的两倍。题目数据保证记录此操作时前面总是存在一个有效的分数。\n4. `\"C\"` - 表示前一次得分无效,将其从记录中移除。题目数据保证记录此操作时前面总是存在一个有效的分数。\n\n请你返回记录中所有得分的总和。\n\n示例 1:\n```\n输入:ops = [\"5\",\"2\",\"C\",\"D\",\"+\"]\n\n输出:30\n\n解释:\n\"5\" - 记录加 5 ,记录现在是 [5]\n\"2\" - 记录加 2 ,记录现在是 [5, 2]\n\"C\" - 使前一次得分的记录无效并将其移除,记录现在是 [5].\n\"D\" - 记录加 2 * 5 = 10 ,记录现在是 [5, 10].\n\"+\" - 记录加 5 + 10 = 15 ,记录现在是 [5, 10, 15].\n所有得分的总和 5 + 10 + 15 = 30\n```\n示例 2:\n```\n输入:ops = [\"5\",\"-2\",\"4\",\"C\",\"D\",\"9\",\"+\",\"+\"]\n\n输出:27\n\n解释:\n\"5\" - 记录加 5 ,记录现在是 [5]\n\"-2\" - 记录加 -2 ,记录现在是 [5, -2]\n\"4\" - 记录加 4 ,记录现在是 [5, -2, 4]\n\"C\" - 使前一次得分的记录无效并将其移除,记录现在是 [5, -2]\n\"D\" - 记录加 2 * -2 = -4 ,记录现在是 [5, -2, -4]\n\"9\" - 记录加 9 ,记录现在是 [5, -2, -4, 9]\n\"+\" - 记录加 -4 + 9 = 5 ,记录现在是 [5, -2, -4, 9, 5]\n\"+\" - 记录加 9 + 5 = 14 ,记录现在是 [5, -2, -4, 9, 5, 14]\n所有得分的总和 5 + -2 + -4 + 9 + 5 + 14 = 27\n```\n示例 3:\n```\n输入:ops = [\"1\"]\n\n输出:1\n```\n\n提示:\n* $1 <= ops.length <= 1000$\n* $ops[i]$ 为 `\"C\"`、`\"D\"`、`\"+\"`,或者一个表示整数的字符串。整数范围是 $[-3 * 10^4, 3 * 10^4]$\n* 对于 `\"+\"` 操作,题目数据保证记录此操作时前面总是存在两个有效的分数\n* 对于 `\"C\"` 和 `\"D\"` 操作,题目数据保证记录此操作时前面总是存在一个有效的分数", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n代码:\n```Java\nclass Solution {\n    static int[] nums = new int[1010];\n    public int calPoints(String[] ops) {\n        int n = ops.length, idx = 0;\n        for (int i = 0; i < n; i++, idx++) {\n            if (ops[i].equals(\"+\")) nums[idx] = nums[idx - 1] + nums[idx - 2];    \n            else if (ops[i].equals(\"D\")) nums[idx] = nums[idx - 1] * 2;\n            else if (ops[i].equals(\"C\")) idx -= 2;\n            else nums[idx] = Integer.parseInt(ops[i]);\n        }\n        int ans = 0;\n        for (int i = 0; i < idx; i++) ans += nums[i];\n        return ans;\n    }\n}\n```\n\n```python\nnums = [0] * 1010\nclass Solution:\n    def calPoints(self, ops: List[str]) -> int:\n        idx = 0\n        for x in ops:\n            if x == '+':\n                nums[idx] = nums[idx - 1] + nums[idx - 2]\n            elif x == 'D':\n                nums[idx] = nums[idx - 1] * 2\n            elif x == 'C':\n                idx -= 2\n            else:\n                nums[idx] = int(x)\n            idx += 1\n        return sum(nums[:idx])\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.682` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/681-690/686. 重复叠加字符串匹配（中等）.md", "url_title": "686. 重复叠加字符串匹配", "url": "https://leetcode-cn.com/problems/repeated-string-match/solution/gong-shui-san-xie-yi-ti-san-jie-qia-chan-3hbr/", "difficulty": "中等", "tags": ["字符串哈希", "KMP"], "question": "给定两个字符串 `a` 和 `b`,寻找重复叠加字符串 `a` 的最小次数,使得字符串 `b` 成为叠加后的字符串 `a` 的子串,如果不存在则返回 `-1`。\n\n注意:字符串 `\"abc\"` 重复叠加 `0` 次是 `\"\"`,重复叠加 `1` 次是 `\"abc\"`,重复叠加 `2` 次是 `\"abcabc\"`。\n\n示例 1:\n```\n输入:a = \"abcd\", b = \"cdabcdab\"\n\n输出:3\n\n解释:a 重复叠加三遍后为 \"abcdabcdabcd\", 此时 b 是其子串。\n```\n示例 2:\n```\n输入:a = \"a\", b = \"aa\"\n\n输出:2\n```\n示例 3:\n```\n输入:a = \"a\", b = \"a\"\n\n输出:1\n```\n示例 4:\n```\n输入:a = \"abc\", b = \"wxyz\"\n\n输出:-1\n```\n\n提示:\n* $1 <= a.length <= 10^4$\n* $1 <= b.length <= 10^4$\n* `a` 和 `b` 由小写英文字母组成", "solution": "### 基本分析\n\n首先,可以分析复制次数的「下界」和「上界」为何值:\n\n**对于「下界」的分析是容易的:至少将 `a` 复制长度大于等于 `b` 的长度,才有可能匹配。**\n\n在明确了「下界」后,再分析再经过多少次复制,能够明确得到答案,能够得到明确答案的最小复制次数即是上界。\n\n**由于主串是由 `a` 复制多次而来,并且是从主串中找到子串 `b`,因此可以明确子串的起始位置,不会超过 `a` 的长度。**\n\n即**长度越过 `a` 长度的起始匹配位置,必然在此前已经被匹配过了。**\n\n由此,我们可知复制次数「上界」最多为「下界 + $1$」。\n\n令 `a` 的长度为 $n$,`b` 的长度为 $m$,下界次数为 $c1$,上界次数为 $c2 = c1 + 1$。\n\n因此我们可以对 `a` 复制 $c2$ 次,得到主串后匹配 `b`,如果匹配成功后的结束位置不超过了 $n * c1$,说明复制 $c1$ 即可,返回 $c1$,超过则返回 $c2$;匹配不成功则返回 $-1$。\n\n---\n\n### 卡常\n\n这是我最开始的 AC 版本。\n\n虽然这是道挺显然的子串匹配问题,但是昨晚比平时晚睡了一个多小时,早上起来精神状态不是很好,身体的每个细胞都在拒绝写 KMP 🤣 \n\n就动了歪脑筋写了个「卡常」做法。\n\n通过该做法再次印证了 LC 的评测机制十分奇葩:居然不是对每个用例单独计时,也不是算总的用例用时,而是既算单用例耗时,又算总用时??\n\n导致我直接 `TLE` 了 $6$ 次才通过(从 $700$ 试到了 $100$),其中有 $4$ 次 `TLE` 是显示通过了所有样例,但仍然 `TLE`,我不理解为什么要设置这样迷惑的机制。\n\n回到该做法本身,首先对 `a` 进行复制确保长度大于等于 `b`,然后在一定时间内,不断的「复制 - 检查」,如果在规定时间内能够找到则返回复制次数,否则返回 `-1`。\n\n代码:\n```Java\nimport java.time.Clock;\nclass Solution {\n    public int repeatedStringMatch(String a, String b) {\n        StringBuilder sb = new StringBuilder();\n        int ans = 0;\n        while (sb.length() < b.length() && ++ans > 0) sb.append(a);\n        Clock clock = Clock.systemDefaultZone();\n        long start = clock.millis();\n        while (clock.millis() - start < 100) {\n            if (sb.indexOf(b) != -1) return ans;\n            sb.append(a);\n            ans++;\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:$O(C)$\n* 空间复杂度:$O(C)$\n\n---\n\n### 上下界性质\n\n通过「基本分析」后,我们发现「上下界」具有准确的大小关系,其实不需要用到「卡常」做法。\n\n只需要进行「上界」次复制后,尝试匹配,根据匹配结果返回答案即可。\n\n代码:\n```Java\nclass Solution {\n    public int repeatedStringMatch(String a, String b) {\n        StringBuilder sb = new StringBuilder();\n        int ans = 0;\n        while (sb.length() < b.length() && ++ans > 0) sb.append(a);\n        sb.append(a);\n        int idx = sb.indexOf(b);\n        if (idx == -1) return -1;\n        return idx + b.length() > a.length() * ans ? ans + 1 : ans;\n    }\n}\n```\n* 时间复杂度:需要 $\\left \\lceil \\frac{m}{n} \\right \\rceil + 1$ 次拷贝 和 一次子串匹配。复杂度为 $O(n * (\\left \\lceil \\frac{m}{n} \\right \\rceil + 1))$\n* 空间复杂度:$O(n * (\\left \\lceil \\frac{m}{n} \\right \\rceil + 1))$\n\n---\n\n### KMP\n\n其中 `indexOf` 部分可以通过 KMP/字符串哈希 实现,不熟悉 KMP 的同学,可以查看 [一文详解 KMP 算法](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486317&idx=1&sn=9c2ff2fa5db427133cce9c875064e7a4&chksm=fd9ca072caeb29642bf1f5c151e4d5aaff4dc10ba408b23222ea1672cfc41204a584fede5c05&token=1782709324&lang=zh_CN#rd),里面通过大量配图讲解了 KMP 的匹配过程与提供了实用模板。\n\n使用 KMP 代替 `indexOf` 可以有效利用主串是由多个 `a` 复制而来的性质。\n\n代码:\n```Java\nclass Solution {\n    public int repeatedStringMatch(String a, String b) {\n        StringBuilder sb = new StringBuilder();\n        int ans = 0;\n        while (sb.length() < b.length() && ++ans > 0) sb.append(a);\n        sb.append(a);\n        int idx = strStr(sb.toString(), b);\n        if (idx == -1) return -1;\n        return idx + b.length() > a.length() * ans ? ans + 1 : ans;\n    }\n\n    int strStr(String ss, String pp) {\n        if (pp.isEmpty()) return 0;\n        \n        // 分别读取原串和匹配串的长度\n        int n = ss.length(), m = pp.length();\n        // 原串和匹配串前面都加空格,使其下标从 1 开始\n        ss = \" \" + ss;\n        pp = \" \" + pp;\n\n        char[] s = ss.toCharArray();\n        char[] p = pp.toCharArray();\n\n        // 构建 next 数组,数组长度为匹配串的长度(next 数组是和匹配串相关的)\n        int[] next = new int[m + 1];\n        // 构造过程 i = 2,j = 0 开始,i 小于等于匹配串长度 【构造 i 从 2 开始】\n        for (int i = 2, j = 0; i <= m; i++) {\n            // 匹配不成功的话,j = next(j)\n            while (j > 0 && p[i] != p[j + 1]) j = next[j];\n            // 匹配成功的话,先让 j++\n            if (p[i] == p[j + 1]) j++;\n            // 更新 next[i],结束本次循环,i++\n            next[i] = j;\n        }\n\n        // 匹配过程,i = 1,j = 0 开始,i 小于等于原串长度 【匹配 i 从 1 开始】\n        for (int i = 1, j = 0; i <= n; i++) {\n            // 匹配不成功 j = next(j)\n            while (j > 0 && s[i] != p[j + 1]) j = next[j];\n            // 匹配成功的话,先让 j++,结束本次循环后 i++\n            if (s[i] == p[j + 1]) j++;\n            // 整一段匹配成功,直接返回下标\n            if (j == m) return i - m;\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:需要 $\\left \\lceil \\frac{m}{n} \\right \\rceil + 1$ 次拷贝 和 一次子串匹配。复杂度为 $O(n * (\\left \\lceil \\frac{m}{n} \\right \\rceil + 1))$\n* 空间复杂度:$O(n * (\\left \\lceil \\frac{m}{n} \\right \\rceil + 1))$\n\n---\n\n### 字符串哈希\n\n结合「基本分析」,我们知道这本质是一个子串匹配问题,我们可以使用「字符串哈希」来解决。\n\n令 `a` 的长度为 $n$,`b` 的长度为 $m$。\n\n仍然是先将 `a` 复制「上界」次,得到主串 `ss`,目的是从 `ss` 中检测是否存在子串为 `b`。\n\n在字符串哈希中,为了方便,我们将 `ss` 和 `b` 进行拼接,设拼接后长度为 $len$,那么 `b` 串的哈希值为 $[len - m + 1, len]$ 部分(下标从 $1$ 开始),记为 $target$。\n\n然后在 $[1, n]$ 范围内枚举起点,尝试找长度为 $m$ 的哈希值与 $target$ 相同的哈希值。\n\n代码:\n```Java\nclass Solution {\n    public int repeatedStringMatch(String a, String b) {\n        StringBuilder sb = new StringBuilder();\n        int ans = 0;\n        while (sb.length() < b.length() && ++ans > 0) sb.append(a);\n        sb.append(a);\n        int idx = strHash(sb.toString(), b);\n        if (idx == -1) return -1;\n        return idx + b.length() > a.length() * ans ? ans + 1 : ans;\n    }\n    int strHash(String ss, String b) {\n        int P = 131;\n        int n = ss.length(), m = b.length();\n        String str = ss + b;\n        int len = str.length();\n        int[] h = new int[len + 10], p = new int[len + 10];\n        h[0] = 0; p[0] = 1;\n        for (int i = 0; i < len; i++) {\n            p[i + 1] = p[i] * P;\n            h[i + 1] = h[i] * P + str.charAt(i);\n        }\n        int r = len, l = r - m + 1;\n        int target = h[r] - h[l - 1] * p[r - l + 1]; // b 的哈希值\n        for (int i = 1; i <= n; i++) {\n            int j = i + m - 1;\n            int cur = h[j] - h[i - 1] * p[j - i + 1]; // 子串哈希值\n            if (cur == target) return i - 1;\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:需要 $\\left \\lceil \\frac{m}{n} \\right \\rceil + 1$ 次拷贝 和 一次子串匹配。复杂度为 $O(n * (\\left \\lceil \\frac{m}{n} \\right \\rceil + 1))$\n* 空间复杂度:$O(n * (\\left \\lceil \\frac{m}{n} \\right \\rceil + 1))$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.686` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/681-690/687. 最长同值路径（中等）.md", "url_title": "687. 最长同值路径", "url": "https://leetcode.cn/problems/longest-univalue-path/solution/by-ac_oier-8ue8/", "difficulty": "中等", "tags": ["二叉树", "DFS", "递归"], "question": "给定一个二叉树的 `root`,返回 最长的路径的长度 ,这个路径中的 每个节点具有相同值 。 这条路径可以经过也可以不经过根节点。\n\n两个节点之间的路径长度 由它们之间的边数表示。\n\n示例 1:\n\n```\n输入:root = [5,4,5,1,1,5]\n\n输出:2\n```\n示例 2:\n\n```\n输入:root = [1,4,5,4,4,5]\n\n输出:2\n```\n\n提示:\n* 树的节点数的范围是 $[0, 10^4] $\n* $-1000 <= Node.val <= 1000$\n* 树的深度将不超过 `1000`", "solution": "### 递归\n\n设计递归函数 `int dfs(TreeNode root)`,含义为传入根节点 `root`,返回以该节点为起点,往下走同值路径所能经过的最大路径长度(即不能同时往左右节点走),同时使用全局变量 `max` 记录答案路径所能经过最大路径长度。\n\n在递归函数内部,先通过递归 `root` 的左右子节点,拿到以 `root.left` 和 `root.right` 为起点的最大路径长度 `l` 和 `r`,然后根据当前节点值和左右子节点值的相等关系来更新 `ans`,同时用 `cur` 维护「以当前节点 `root` 为目标路径中深度最小(位置最高)节点时」所经过的最大路径长度。\n\nJava 代码:\n```Java\nclass Solution {\n    int max = 0;\n    public int longestUnivaluePath(TreeNode root) {\n        dfs(root);\n        return max;\n    }\n    int dfs(TreeNode root) {\n        if (root == null) return 0;\n        int ans = 0, cur = 0, l = dfs(root.left), r = dfs(root.right);\n        if (root.left != null && root.left.val == root.val) {\n            ans = l + 1; cur += l + 1;\n        }\n        if (root.right != null && root.right.val == root.val) {\n            ans = Math.max(ans, r + 1); cur += r + 1;\n        }\n        max = Math.max(max, cur);\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxv = 0;\n    int dfs(TreeNode* root) {\n        if (root == nullptr) return 0;\n        int ans = 0, cur = 0;\n        int l = dfs(root->left), r = dfs(root->right);\n        if (root->left != nullptr && root->left->val == root->val) {\n            ans = l + 1; cur += l + 1;\n        }\n        if (root->right != nullptr && root->right->val == root->val) {\n            ans = max(ans, r + 1); cur += r + 1;\n        }\n        maxv = max(maxv, cur);\n        return ans;\n    }\n    int longestUnivaluePath(TreeNode* root) {\n        dfs(root);\n        return maxv;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def longestUnivaluePath(self, root: Optional[TreeNode]) -> int:\n        maxv = 0\n        def dfs(root):\n            nonlocal maxv\n            if not root: return 0\n            ans, cur = 0, 0\n            l, r = dfs(root.left), dfs(root.right)\n            if root.left and root.left.val == root.val:\n                ans = l + 1\n                cur += l + 1\n            if root.right and root.right.val == root.val:\n                ans = max(ans, r + 1)\n                cur += r + 1\n            maxv = max(maxv, cur)\n            return ans\n        dfs(root)\n        return maxv\n```\nTypeScript 代码:\n```TypeScript\nlet max = 0;\nfunction longestUnivaluePath(root: TreeNode | null): number {\n    max = 0\n    dfs(root)\n    return max\n};\nfunction dfs(root: TreeNode | null): number {\n    if (root == null) return 0\n    let ans = 0, cur = 0, l = dfs(root.left), r = dfs(root.right)\n    if (root.left != null && root.left.val == root.val) {\n        ans = l + 1; cur += l + 1\n    }\n    if (root.right != null && root.right.val == root.val) {\n        ans = Math.max(ans, r + 1); cur += r + 1\n    }\n    max = Math.max(max, cur)\n    return ans\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.687` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/681-690/688. 骑士在棋盘上的概率（中等）.md", "url_title": "688. 骑士在棋盘上的概率", "url": "https://leetcode-cn.com/problems/knight-probability-in-chessboard/solution/gong-shui-san-xie-jian-dan-qu-jian-dp-yu-st8l/", "difficulty": "中等", "tags": ["线性 DP"], "question": "在一个 $n \\times n$ 的国际象棋棋盘上,一个骑士从单元格 $(row, column)$ 开始,并尝试进行 $k$ 次移动。行和列是 从 $0$ 开始 的,所以左上单元格是 $(0,0)$ ,右下单元格是 $(n - 1, n - 1)$ 。\n\n象棋骑士有 $8$ 种可能的走法,如下图所示。每次移动在基本方向上是两个单元格,然后在正交方向上是一个单元格。\n\n每次骑士要移动时,它都会随机从 $8$ 种可能的移动中选择一种(即使棋子会离开棋盘),然后移动到那里。\n\n骑士继续移动,直到它走了 $k$ 步或离开了棋盘。\n\n返回 骑士在棋盘停止移动后仍留在棋盘上的概率 。\n\n示例 1:\n```\n输入: n = 3, k = 2, row = 0, column = 0\n\n输出: 0.0625\n\n解释: 有两步(到(1,2),(2,1))可以让骑士留在棋盘上。\n在每一个位置上,也有两种移动可以让骑士留在棋盘上。\n骑士留在棋盘上的总概率是0.0625。\n```\n示例 2:\n```\n输入: n = 1, k = 0, row = 0, column = 0\n\n输出: 1.00000\n```\n\n提示:\n* $1 <= n <= 25$\n* $0 <= k <= 100$\n* $0 <= row, column <= n$", "solution": "### 线性 DP\n\n**定义 $f[i][j][p]$ 为从位置 $(i, j)$ 出发,使用步数不超过 $p$ 步,最后仍在棋盘内的概率。**\n\n不失一般性考虑 $f[i][j][p]$ 该如何转移,根据题意,移动规则为「八连通」,对下一步的落点 $(nx, ny)$ 进行分情况讨论即可:\n\n* 由于计算的是仍在棋盘内的概率,因此对于 $(nx, ny)$ 在棋盘外的情况,无须考虑;\n* 若下一步的落点 $(nx, ny)$ 在棋盘内,其剩余可用步数为 $p - 1$,则最后仍在棋盘的概率为 $f[nx][ny][p - 1]$,则落点 $(nx, ny)$ 对 $f[i][j][p]$ 的贡献为 $f[nx][ny][p - 1] \\times \\frac{1}{8}$,其中 $\\frac{1}{8}$ 为事件「**从 $(i, j)$ 走到 $(nx, ny)$**」的概率(八连通移动等概率发生),该事件与「**到达 $(nx, ny)$ 后进行后续移动并留在棋盘**」为相互独立事件。\n\n最终的 $f[i][j][p]$ 为「八连通」落点的概率之和,即有:\n\n$$\nf[i][j][p] = \\sum {f[nx][ny][p - 1] \\times \\frac{1}{8}}\n$$\n\n代码:\n```Java\nclass Solution {\n    int[][] dirs = new int[][]{{-1,-2},{-1,2},{1,-2},{1,2},{-2,1},{-2,-1},{2,1},{2,-1}};\n    public double knightProbability(int n, int k, int row, int column) {\n        double[][][] f = new double[n][n][k + 1];\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                f[i][j][0] = 1;\n            }\n        }\n        for (int p = 1; p <= k; p++) {\n            for (int i = 0; i < n; i++) {\n                for (int j = 0; j < n; j++) {\n                    for (int[] d : dirs) {\n                        int nx = i + d[0], ny = j + d[1];\n                        if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;\n                        f[i][j][p] += f[nx][ny][p - 1] / 8;\n                    }\n                }\n            }\n        }\n        return f[row][column][k];\n    }\n}\n```\n* 时间复杂度:令某个位置可联通的格子数量 $C = 8$,复杂度为 $O(n^2 \\times k \\times C)$\n* 空间复杂度:$O(n^2 \\times k)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.688` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/681-690/689. 三个无重叠子数组的最大和（困难）.md", "url_title": "689. 三个无重叠子数组的最大和", "url": "https://leetcode-cn.com/problems/maximum-sum-of-3-non-overlapping-subarrays/solution/gong-shui-san-xie-jie-he-qian-zhui-he-de-ancx/", "difficulty": "困难", "tags": ["序列 DP", "前缀和"], "question": "给你一个整数数组 `nums` 和一个整数 `k` ,找出三个长度为 `k` 、互不重叠、且 `3 * k` 项的和最大的子数组,并返回这三个子数组。\n\n以下标的数组形式返回结果,数组中的每一项分别指示每个子数组的起始位置(下标从 $0$ 开始)。如果有多个结果,返回字典序最小的一个。\n\n示例 1:\n```\n输入:nums = [1,2,1,2,6,7,5,1], k = 2\n\n输出:[0,3,5]\n\n解释:子数组 [1, 2], [2, 6], [7, 5] 对应的起始下标为 [0, 3, 5]。\n也可以取 [2, 1], 但是结果 [1, 3, 5] 在字典序上更大。\n```\n示例 2:\n```\n输入:nums = [1,2,1,2,1,2,1,2,1], k = 2\n\n输出:[0,2,4]\n```\n\n提示:\n* $1 <= nums.length <= 2 * 10^4$\n* $1 <= nums[i] < 2^{16}$\n* $1 <= k <= floor(nums.length / 3)$", "solution": "### 前缀和 + 序列 DP\n\n若不考虑输出方案,仅是求「三个无重叠子数组的最大和」的最大值。\n\n只需要使用动态规划求解即可:**定义 $f[i][j]$ 为考虑前 $i$ 个数,凑成无重叠子数组数量为 $j$ 个时的最大值。**\n\n最终答案为 $f[n - 1][3]$。\n\n不失一般性的考虑 $f[i][j]$ 该如何计算(以最优方案是否包含 $nums[i]$ 进行讨论):\n\n*   最优方案中包含 $num[i]$:由于这 $j$ 个无重叠,因此前面的 $j - 1$ 个子数组不能覆盖 $[i - k + 1, i]$。即只能在 $[0, i - k]$ 中选 $j - 1$ 个子数组。此时有:\n\n$$\nf[i][j] = f[i - k][j - 1] + \\sum_{idx = i - k + 1}^{i} nums[idx]\n$$\n\n> 其中求解 $\\sum_{idx = i - k + 1}^{i} nums[idx]$ 部分可以使用「前缀和」优化\n\n*   最优方案不包含 $num[i]$:当明确了 $nums[i]$ 对最优方案无贡献,此时问题等价于考虑前 $i - 1$ 个数,凑成 $j$ 个不重叠子数组的最大值。此时有:\n\n$$\nf[i][j] = f[i - 1][j]\n$$\n\n最终 $f[i][j]$ 为上述两种方案中的最大值。\n\n然后考虑「如何回溯出字典序最小的具体方案」,常规的回溯具体方案的做法是,从最终答案 $f[n - 1][3]$ 开始往回追溯。\n\n利用 $f[n - 1][3]$ 仅由两个可能的节点($f[n - 2][3]$ 和 $f[n - 1 - k][2]$)转移而来,通过判断 $f[n - 1][3]$ 等于 $f[n - 2][3]$ 还是 $f[n - 1 - k][2] + \\sum_{idx = n - k }^{n - 1} nums[idx]$ 来决定回溯点为何值。\n\n但该做法只能确保回溯出字典序最大的方案是正确(当两个可能的前驱节点都能转移到 $f[i][j]$ 时优先采纳靠后的位置),而我们需要回溯出字典序最小的方案。\n\n在上述解法的基础上,有两种「求解字典序最小具体方案」的做法:\n\n1.  将正序 DP 调整为反序 DP。修改状态定义为 $f[i][j]$ 为考虑 $[i, n - 1]$ 中进行选择,凑出无重叠子数组数量为 $j$ 个时的最大值(最终答案为 $f[0][3]$)。转移过程分析同理,然后从下标 $idx = 0$ 开始进行回溯,优先采纳 $idx$ 小的方案即可;\n\n2.  仍然采取正序 DP 的做法,但对原数组进行翻转,从而将回溯「字典序最大」转换为「字典序最小」具体方案。\n\n> 一些细节:为了避免对边界的处理,我们令动规数组 $f$ 和前缀和数组 $sun$ 的下标从 $1$ 开始。\n\n代码($P1$ 为反序 DP 做法,$P2$ 为翻转数组做法):\n\n```Java\nclass Solution {\n    public int[] maxSumOfThreeSubarrays(int[] nums, int k) {\n        int n = nums.length;\n        long[] sum = new long[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n        long[][] f = new long[n + 10][4];\n        for (int i = n - k + 1; i >= 1; i--) {\n            for (int j = 1; j < 4; j++) {\n                f[i][j] = Math.max(f[i + 1][j], f[i + k][j - 1] + sum[i + k - 1] - sum[i - 1]);\n            }\n        }\n        int[] ans = new int[3];\n        int i = 1, j = 3, idx = 0;\n        while (j > 0) {\n            if (f[i + 1][j] > f[i + k][j - 1] + sum[i + k - 1] - sum[i - 1]) {\n                i++;\n            } else {\n                ans[idx++] = i - 1;\n                i += k; j--;\n            }\n        }\n        return ans;\n    }\n}\n```\n\n```Java\nclass Solution {\n    public int[] maxSumOfThreeSubarrays(int[] nums, int k) {\n        int n = nums.length;\n        reverse(nums);\n        long[] sum = new long[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n        long[][] f = new long[n + 10][4];\n        for (int i = k; i <= n; i++) {\n            for (int j = 1; j < 4; j++) {\n                f[i][j] = Math.max(f[i - 1][j], f[i - k][j - 1] + sum[i] - sum[i - k]);\n            }\n        }\n        int[] ans = new int[3];\n        int i = n, j = 3, idx = 0;\n        while (j > 0) {\n            if (f[i - 1][j] > f[i - k][j - 1] + sum[i] - sum[i - k]) {\n                i--;\n            } else {\n                ans[idx++] = n - i;\n                i -= k; j--;\n            }\n        }\n        return ans;\n    }\n    void reverse(int[] nums) {\n        int n = nums.length;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int c = nums[l];\n            nums[l++] = nums[r];\n            nums[r--] = c;\n        }\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.689` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/681-690/690. 员工的重要性（简单）.md", "url_title": "690. 员工的重要性", "url": "https://leetcode-cn.com/problems/employee-importance/solution/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-s79x/", "difficulty": "简单", "tags": ["BFS", "DFS", "队列"], "question": "给定一个保存员工信息的数据结构,它包含了员工 唯一的 id ,重要度 和 直系下属的 id 。\n\n比如,员工 1 是员工 2 的领导,员工 2 是员工 3 的领导。他们相应的重要度为 15 , 10 , 5 。那么员工 1 的数据结构是 [1, 15, [2]] ,员工 2的 数据结构是 [2, 10, [3]] ,员工 3 的数据结构是 [3, 5, []] 。注意虽然员工 3 也是员工 1 的一个下属,但是由于 并不是直系 下属,因此没有体现在员工 1 的数据结构中。\n\n现在输入一个公司的所有员工信息,以及单个员工 id ,返回这个员工和他所有下属的重要度之和。\n\n示例:\n```\n输入:[[1, 5, [2, 3]], [2, 3, []], [3, 3, []]], 1\n\n输出:11\n\n解释:\n员工 1 自身的重要度是 5 ,他有两个直系下属 2 和 3 ,而且 2 和 3 的重要度均为 3 。因此员工 1 的总重要度是 5 + 3 + 3 = 11 。\n```\n\n提示:\n* 一个员工最多有一个 直系 领导,但是可以有多个 直系 下属\n* 员工数量不超过 2000 。", "solution": "### 递归 / DFS\n\n一个直观的做法是,写一个递归函数来统计某个员工的总和。\n\n统计自身的 $importance$ 值和直系下属的 $importance$ 值。同时如果某个下属还有下属的话,则递归这个过程。\n\n代码:\n```Java\nclass Solution {\n    Map<Integer, Employee> map = new HashMap<>();\n    public int getImportance(List<Employee> es, int id) {\n        int n = es.size();\n        for (int i = 0; i < n; i++) map.put(es.get(i).id, es.get(i));\n        return getVal(id);\n    }\n    int getVal(int id) {\n        Employee master = map.get(id);\n        int ans = master.importance;\n        for (int oid : master.subordinates) {\n            Employee other = map.get(oid);\n            ans += other.importance;\n            for (int sub : other.subordinates) ans += getVal(sub);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 迭代 / BFS\n\n另外一个做法是使用「队列」来存储所有将要计算的 $Employee$ 对象,每次弹出时进行统计,并将其「下属」添加到队列尾部。\n\n代码:\n```Java\nclass Solution {\n    public int getImportance(List<Employee> es, int id) {\n        int n = es.size();\n        Map<Integer, Employee> map = new HashMap<>();\n        for (int i = 0; i < n; i++) map.put(es.get(i).id, es.get(i));\n        int ans = 0;\n        Deque<Employee> d = new ArrayDeque<>();\n        d.addLast(map.get(id));\n        while (!d.isEmpty()) {\n            Employee poll = d.pollFirst();\n            ans += poll.importance;\n            for (int oid : poll.subordinates) {\n                d.addLast(map.get(oid));\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.690` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/691-700/691. 贴纸拼词（困难）.md", "url_title": "691. 贴纸拼词", "url": "https://leetcode.cn/problems/stickers-to-spell-word/solution/by-ac_oier-5vv3/", "difficulty": "困难", "tags": ["记忆化搜索", "DFS", "状压 DP", "爆搜", "动态规划", "二进制枚举", "状态压缩"], "question": "我们有 $n$ 种不同的贴纸。每个贴纸上都有一个小写的英文单词。\n\n您想要拼写出给定的字符串 `target` ,方法是从收集的贴纸中切割单个字母并重新排列它们。如果你愿意,你可以多次使用每个贴纸,每个贴纸的数量是无限的。\n\n返回你需要拼出 `target` 的最小贴纸数量。如果任务不可能,则返回 $-1$ 。\n\n注意:在所有的测试用例中,所有的单词都是从 $1000$ 个最常见的美国英语单词中随机选择的,并且 `target` 被选择为两个随机单词的连接。\n\n示例 1:\n```\n输入: stickers = [\"with\",\"example\",\"science\"], target = \"thehat\"\n\n输出:3\n\n解释:\n我们可以使用 2 个 \"with\" 贴纸,和 1 个 \"example\" 贴纸。\n把贴纸上的字母剪下来并重新排列后,就可以形成目标 “thehat“ 了。\n此外,这是形成目标字符串所需的最小贴纸数量。\n```\n示例 2:\n```\n输入:stickers = [\"notice\",\"possible\"], target = \"basicbasic\"\n\n输出:-1\n\n解释:我们不能通过剪切给定贴纸的字母来形成目标“basicbasic”。\n```\n\n提示:\n* $n == stickers.length$\n* $1 <= n <= 50$\n* $1 <= stickers[i].length <= 10$\n* $1 <= target <= 15$\n* `stickers[i]` 和 `target` 由小写英文单词组成", "solution": "### 动态规划(记忆化搜索)\n\n为了方便,我们记 $ss = stickers$,$t = target$,其中 $t$ 的长度为 $n$。\n\n我们使用一个 $state$(一个 `int` 类型变量)来代表当前 $t$ 的凑成情况:若 $t[i]$ 已被凑成,则在 $state$ 中低 $i$ 位为 $1$,否则为 $0$。\n\n起始时有 `state = 0`,最终若能凑成 $t$,则有 `state = (1 << n) - 1`。\n\n由于每个 $ss[i]$ 可以被使用多次,因此对于一个特定的 $state$ 而言,其转换为最终的 `(1 << n) - 1` 的最小步数固定,因此我们可以使用「记忆化搜索」来避免对相同的 $state$ 进行重复搜索。\n\n而在单步的搜索过程中,我们枚举每个 $ss[i]$ 来更新 $state$,假设使用某个 $ss[i]$ 得到的新状态为 $nstate$,则所有的 `dfs(nstate) + 1` 的最小值即是 $f[state]$。\n\n代码:\n```Java\nclass Solution {\n    int N = 20, M = 1 << 20, INF = 50;\n    int[] f = new int[M];\n    String[] ss;\n    String t;\n    int dfs(int state) {\n        int n = t.length();\n        if (state == ((1 << n) - 1)) return 0;\n        if (f[state] != -1) return f[state];\n        int ans = INF;\n        for (String s : ss) {\n            int nstate = state;\n            out:for (char c : s.toCharArray()) {\n                for (int i = 0; i < n; i++) {\n                    if (t.charAt(i) == c && ((nstate >> i) & 1) == 0) {\n                        nstate |= (1 << i);\n                        continue out;\n                    }\n                }\n            }\n            if (nstate != state) ans = Math.min(ans, dfs(nstate) + 1);\n        }\n        return f[state] = ans;\n    }\n    public int minStickers(String[] stickers, String target) {\n        ss = stickers; t = target;\n        Arrays.fill(f, -1);\n        int ans = dfs(0);\n        return ans == INF ? -1 : ans;\n    }\n}\n```\n* 时间复杂度:令 $n$ 和 $m$ 分别代表字符串 `t` 的长度和数组 `ss` 的长度。共有 $2^n$ 个状态,单次状态的计算复杂度为 $$O(\\sum_{i = 0}^{m - 1}ss[i].length \\times n)$$。整体复杂度为 $$O(2^n \\times \\sum_{i = 0}^{m - 1}ss[i].length \\times n)$$\n* 空间复杂度:$O(2^n)$\n\n---\n\n### 动态规划\n\n定义 $f[state]$ 为当前 $t$ 的凑成情况为 $state$ 时,使用的最少贴纸数量。\n\n对应的我们有 $f[0] = 0$,代表当 $t$ 的任何一位都不被凑成时,所需要的最小贴纸数量为 $0$。\n\n每次我们尝试使用有效的状态 $s$($f[s]$ 不为 `INF`  为有效状态)来更新新状态 $ns$,状态转移过程与解法一类似,每次尝试使用任意的 $ss[i]$ 来得到新的 $ns$。\n\n代码:\n```Java\nclass Solution {\n    static int N = 15, INF = 20;\n    static int[] f = new int[1 << N];\n    public int minStickers(String[] ss, String t) {\n        int n = ss.length, m = t.length(), mask = 1 << m;\n        Arrays.fill(f, INF);\n        f[0] = 0;\n        for (int s = 0; s < mask; s++) {\n            if (f[s] == INF) continue;\n            for (String str : ss) {\n                int ns = s, len = str.length();\n                for (int i = 0; i < len; i++) {\n                    int c = str.charAt(i) - 'a';\n                    for (int j = 0; j < m; j++) {\n                        if (t.charAt(j) - 'a' == c && (((ns >> j) & 1) == 0)) {\n                            ns |= (1 << j);\n                            break;\n                        }\n                    }\n                }\n                f[ns] = Math.min(f[ns], f[s] + 1);\n            }\n        }\n        return f[mask - 1] == INF ? -1 : f[mask - 1];\n    }\n}\n```\n* 时间复杂度:令 $n$ 和 $m$ 分别代表字符串 `t` 的长度和数组 `ss` 的长度。共有 $2^n$ 个状态,单次状态的计算复杂度为 $$O(\\sum_{i = 0}^{m - 1}ss[i].length \\times n)$$。整体复杂度为 $$O(2^n \\times \\sum_{i = 0}^{m - 1}ss[i].length \\times n)$$\n* 空间复杂度:$O(2^n)$\n\n---\n\n### 预处理优化 \n\n在解法一和解法二的状态转移过程中,我们每次都尝试枚举所有的 $ss[i]$ 来将 $s$ 更新为 $ns$。\n\n实际上,可以有效填充 $t$ 中尚未被占用字符的 $ss[i]$ 可能只是少数,因此我们可以先预处理每个 $ss[i]$ 到底能够提供那些字符。\n\n在将状态 $s$ 更新为 $ns$ 时,我们只枚举那些有效的 $ss[i]$。\n\n代码:\n```Java \nclass Solution {\n    static int N = 15, INF = 20;\n    static int[] f = new int[1 << N];\n    public int minStickers(String[] ss, String t) {\n        int n = ss.length, m = t.length(), mask = 1 << m;\n        Map<Integer, List<Integer>> map = new HashMap<>();\n        for (int i = 0; i < n; i++) {\n            String str = ss[i];\n            for (char c : str.toCharArray()) {\n                int d = c - 'a';\n                List<Integer> list = map.getOrDefault(d, new ArrayList<>());\n                if (list.size() == 0 || list.get(list.size() - 1) != i) list.add(i);\n                map.put(d, list);\n            }\n        }\n        Arrays.fill(f, INF);\n        f[0] = 0;\n        for (int s = 0; s < mask; s++) {\n            if (f[s] == INF) continue;\n            int loc = -1;\n            for (int i = 0; i < m && loc == -1; i++) {\n                if (((s >> i) & 1) == 0) loc = i;\n            }\n            if (loc == -1) continue;\n            List<Integer> list = map.getOrDefault(t.charAt(loc) - 'a', new ArrayList<>());\n            for (int i = 0; i < list.size(); i++) {\n                String str = ss[list.get(i)];\n                int ns = s, len = str.length();\n                for (int j = 0; j < len; j++) {\n                    char c = str.charAt(j);\n                    for (int k = 0; k < m; k++) {\n                        if (t.charAt(k) == c && (((ns >> k) & 1) == 0)) {\n                            ns |= (1 << k);\n                            break;\n                        }\n                    }\n                }\n                f[ns] = Math.min(f[ns], f[s] + 1);\n            }\n        }\n        return f[mask - 1] == INF ? -1 : f[mask - 1];\n    }\n}\n```\n* 时间复杂度:令 $n$ 和 $m$ 分别代表字符串 `t` 的长度和数组 `ss` 的长度。共有 $2^n$ 个状态,单次状态的计算复杂度为 $$O(\\sum_{i = 0}^{m - 1}ss[i].length \\times n)$$。整体复杂度为 $$O(2^n \\times \\sum_{i = 0}^{m - 1}ss[i].length \\times n)$$\n* 空间复杂度:$O(2^n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.691` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/691-700/692. 前K个高频单词（中等）.md", "url_title": "692. 前K个高频单词", "url": "https://leetcode-cn.com/problems/top-k-frequent-words/solution/gong-shui-san-xie-xiang-jie-shi-yong-ha-8dxt2/", "difficulty": "中等", "tags": ["哈希表", "优先队列(堆)"], "question": "给一非空的单词列表,返回前 `k` 个出现次数最多的单词。\n\n返回的答案应该按单词出现频率由高到低排序。\n\n如果不同的单词有相同出现频率,按字母顺序排序。\n\n示例 1:\n```\n输入: [\"i\", \"love\", \"leetcode\", \"i\", \"love\", \"coding\"], k = 2\n\n输出: [\"i\", \"love\"]\n\n解析: \"i\" 和 \"love\" 为出现次数最多的两个单词,均为2次。\n    注意,按字母顺序 \"i\" 在 \"love\" 之前。\n```\n\n示例 2:\n```\n输入: [\"the\", \"day\", \"is\", \"sunny\", \"the\", \"the\", \"the\", \"sunny\", \"is\", \"is\"], k = 4\n\n输出: [\"the\", \"is\", \"sunny\", \"day\"]\n\n解析: \"the\", \"is\", \"sunny\" 和 \"day\" 是出现次数最多的四个单词,\n    出现次数依次为 4, 3, 2 和 1 次。\n```\n\n注意:\n* 假定 `k` 总为有效值,`1 ≤ k ≤ 集合元素数`。\n* 输入的单词均由小写字母组成。\n\n扩展练习:\n* 尝试以 $O(n\\log{k})$ 时间复杂度和 $O(n)$ 空间复杂度解决。", "solution": "### 哈希表 & 优先队列(堆)\n\n这道题是在「优先队列(堆)」裸题的基础上增加了字典序大小的比较。\n\n相应的,我们不能只根据「词频大小」构建小根堆来获取前 $k$ 个元素,还需要结合字典序大小来做。\n\n具体的,我们可以使用「哈希表」&「优先队列」进行求解:\n\n1. 使用「哈希表」来统计所有的词频\n2. 构建大小为 $k$ 按照「词频升序 + (词频相同)字典序倒序」的优先队列:\n    * 如果词频不相等,根据词频进行升序构建,确保堆顶元素是堆中词频最小的元素\n    * 如果词频相等,根据字典序大小进行倒序构建,结合 $2.1$ 可以确保堆顶元素是堆中「词频最小 & 字典序最大」的元素\n3. 对所有元素进行遍历,尝试入堆:\n    * 堆内元素不足 $k$ 个:直接入堆\n    * 词频大于堆顶元素:堆顶元素不可能是前 $k$ 大的元素。将堆顶元素弹出,并将当前元素添加到堆中\n    * 词频小于堆顶元素;当前元素不可能是前 $k$ 大的元素,直接丢弃。\n    * 词频等于堆顶元素:根据当前元素与堆顶元素的字典序大小决定(如果字典序大小比堆顶元素要小则入堆)\n4. 输出堆内元素,并翻转\n\n代码:\n```Java\nclass Solution {\n    public List<String> topKFrequent(String[] ws, int k) {\n        Map<String, Integer> map = new HashMap<>();\n        for (String w : ws) map.put(w, map.getOrDefault(w, 0) + 1);\n        PriorityQueue<Object[]> q = new PriorityQueue<>(k, (a, b)->{ \n            // 如果词频不同,根据词频升序\n            int c1 = (Integer)a[0], c2 = (Integer)b[0];\n            if (c1 != c2) return c1 - c2;\n            // 如果词频相同,根据字典序倒序\n            String s1 = (String)a[1], s2 = (String)b[1];\n            return s2.compareTo(s1);\n        });\n        for (String s : map.keySet()) {\n            int cnt = map.get(s);\n            if (q.size() < k) { // 不足 k 个,直接入堆\n                q.add(new Object[]{cnt, s});\n            } else {\n                Object[] peek = q.peek();\n                if (cnt > (Integer)peek[0]) { // 词频比堆顶元素大,弹出堆顶元素,入堆\n                    q.poll();\n                    q.add(new Object[]{cnt, s});\n                } else if (cnt == (Integer)peek[0]) { // 词频与堆顶元素相同\n                    String top = (String)peek[1];\n                    if (s.compareTo(top) < 0) { // 且字典序大小比堆顶元素小,弹出堆顶元素,入堆\n                        q.poll();\n                        q.add(new Object[]{cnt, s});\n                    }\n                }\n            }\n        }\n        List<String> ans = new ArrayList<>();\n        while (!q.isEmpty()) ans.add((String)q.poll()[1]);\n        Collections.reverse(ans);\n        return ans;\n    }\n}\n```\n* 时间复杂度:使用哈希表统计词频,复杂度为 $O(n)$;使用最多 $n$ 个元素维护一个大小为 $k$ 的堆,复杂度为 $O(n\\log{k})$;输出答案复杂度为 $O(k)$(同时 $k \\leq n$)。整体复杂度为 $O(n\\log{k})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.692` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/691-700/693. 交替位二进制数（简单）.md", "url_title": "693. 交替位二进制数", "url": "https://leetcode-cn.com/problems/binary-number-with-alternating-bits/solution/gong-si-shui-by-ac_oier-zuw7/", "difficulty": "简单", "tags": ["模拟", "位运算"], "question": "给定一个正整数,检查它的二进制表示是否总是 $0$、$1$ 交替出现:换句话说,就是二进制表示中相邻两位的数字永不相同。\n\n示例 1:\n```\n输入:n = 5\n\n输出:true\n\n解释:5 的二进制表示是:101\n```\n示例 2:\n```\n输入:n = 7\n\n输出:false\n\n解释:7 的二进制表示是:111.\n```\n示例 3:\n```\n输入:n = 11\n\n输出:false\n\n解释:11 的二进制表示是:1011.\n```\n\n提示:\n* $1 <= n <= 2^{31} - 1$", "solution": "### 遍历\n\n根据题意,对 $n$  的每一位进行遍历检查。\n\n代码:\n```Java\nclass Solution {\n    public boolean hasAlternatingBits(int n) {\n        int cur = -1;\n        while (n != 0) {\n            int u = n & 1;\n            if ((cur ^ u) == 0) return false;\n            cur = u; n >>= 1;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 位运算\n\n另外一种更为巧妙的方式是利用交替位二进制数性质。\n\n当给定值 $n$ 为交替位二进制数时,将 $n$ 右移一位得到的值 $m$ 仍为交替位二进制数,且与原数 $n$ 错开一位,两者异或能够得到形如 $0000...1111$ 的结果 $x$,此时对 $x$ 执行加法(进位操作)能够得到形如 $0000...10000$ 的结果,将该结果与 $x$ 执行按位与后能够得到全 $0$ 结果。 \n\n代码:\n```Java\nclass Solution {\n    public boolean hasAlternatingBits(int n) {\n        int x = n ^ (n >> 1);\n        return (x & (x + 1)) == 0;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.693` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/691-700/697. 数组的度（简单）.md", "url_title": "697. 数组的度", "url": "https://leetcode-cn.com/problems/degree-of-an-array/solution/shu-zu-ji-shu-ha-xi-biao-ji-shu-jie-fa-y-a0mg/", "difficulty": "简单", "tags": ["哈希表"], "question": "给定一个非空且只包含非负数的整数数组 nums,数组的度的定义是指数组里任一元素出现频数的最大值。\n\n你的任务是在 nums 中找到与 nums 拥有相同大小的度的最短连续子数组,返回其长度。\n\n示例 1:\n```\n输入:[1, 2, 2, 3, 1]\n输出:2\n解释:\n输入数组的度是2,因为元素1和2的出现频数最大,均为2.\n连续子数组里面拥有相同度的有如下所示:\n[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]\n最短连续子数组[2, 2]的长度为2,所以返回2.\n```\n示例 2:\n```\n输入:[1,2,2,3,1,4,2]\n输出:6\n```\n\n提示:\n* nums.length 在1到 50,000 区间范围内。\n* nums[i] 是一个在 0 到 49,999 范围内的整数。", "solution": "### 数组计数\n\n由于已知值的范围是 `[0, 49999]`。\n\n我们可以使用数组 `cnt` 来统计每个值出现的次数,数组 `first` 和 `last` 记录每个值「首次出现」和「最后出现」的下标。\n\n同时统计出最大词频为 `max`。\n\n然后再遍历一次数组,对于那些满足词频为 `max` 的数值进行长度计算。\n\n```Java\nclass Solution {\n    int N = 50009;\n    public int findShortestSubArray(int[] nums) {\n        int n = nums.length;\n        int[] cnt = new int[N];\n        int[] first = new int[N], last = new int[N];\n        Arrays.fill(first, -1);\n        int max = 0;\n        for (int i = 0; i < n; i++) {\n            int t = nums[i];\n            max = Math.max(max, ++cnt[t]);\n            if (first[t] == -1) first[t] = i;\n            last[t] = i;\n        }\n        int ans = Integer.MAX_VALUE;\n        for (int i = 0; i < n; i++) {\n            int t = nums[i];\n            if (cnt[t] == max) ans = Math.min(ans, last[t] - first[t] + 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:对数组进行常数次扫描。复杂度为 $O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 哈希表计数\n\n同样的,除了使用静态数组,我们还可以使用哈希表进行计数。\n\n```java \nclass Solution {\n    public int findShortestSubArray(int[] nums) {\n        int n = nums.length;\n        Map<Integer, Integer> cnt = new HashMap<>();\n        Map<Integer, Integer> first = new HashMap<>(), last = new HashMap<>();\n        int max = 0;\n        for (int i = 0; i < n; i++) {\n            int t = nums[i];\n            cnt.put(t, cnt.getOrDefault(t, 0) + 1);\n            max = Math.max(max, cnt.get(t));\n            if (!first.containsKey(t)) first.put(t, i);\n            last.put(t, i);\n        }\n        int ans = Integer.MAX_VALUE;\n        for (int i = 0; i < n; i++) {\n            int t = nums[i];\n            if (cnt.get(t) == max) {\n                ans = Math.min(ans, last.get(t) - first.get(t) + 1);\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:对数组进行常数次扫描。复杂度为 $O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 总结\n\n我们知道 `哈希表 = 哈希函数 + 数组`,由于哈希函数计算需要消耗时间(Java 中首先涉及自动装箱/拆箱,之后还要取对象的 hashCode 进行右移异或,最后才计算哈希桶的下标),以及处理哈希冲突的开销。\n\n其效率必然比不上使用我们静态数组进行计数。\n\n因此我建议,对于那些 **数值范围确定且不太大($10^6$ 以内都可以使用,本题数量级在 $10^4$)** 的计算场景,使用数组进行计数,而不是使用哈希表。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.697` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/691-700/698. 划分为k个相等的子集（中等）.md", "url_title": "698. 划分为k个相等的子集", "url": "https://leetcode.cn/problems/partition-to-k-equal-sum-subsets/solution/by-ac_oier-mryw/", "difficulty": "中等", "tags": ["搜索", "爆搜", "剪枝", "模拟退火", "启发式搜索", "回溯算法", "贪心"], "question": "给定一个整数数组  `nums` 和一个正整数 `k`,找出是否有可能把这个数组分成 `k` 个非空子集,其总和都相等。\n\n示例 1:\n```\n输入: nums = [4, 3, 2, 3, 5, 2, 1], k = 4\n\n输出: True\n\n说明: 有可能将其分成 4 个子集(5),(1,4),(2,3),(2,3)等于总和。\n```\n示例 2:\n```\n输入: nums = [1,2,3,4], k = 3\n\n输出: false\n```\n\n提示:\n* $1 <= k <= len(nums) <= 16$\n* $0 < nums[i] < 10000$\n* 每个元素的频率在 $[1,4]$ 范围内", "solution": "### 搜索 + 剪枝(贪心策略)\n\n将 $n$ 个数均分成 $k$ 份,且 $n$ 与 $k$ 数据范围为 $16$,容易想到搜索剪枝。\n\n先对一些显然的无解情况进行分析:记 $tot = \\sum_{i = 0}^{n - 1}nums[i]$,**若 $tot$ 不为 $k$ 的倍数,必然是无法实现均分,直接返回 `false`(可行性剪枝)**。同时可知单个集合的总和为 $t = \\frac{tot}{k}$。\n\n设计搜索函数为 `boolean dfs(int idx, int cur, int cnt, boolean[] vis)`,各项参数含义如下:\n* `cur` 为当前集合的元素和(初始值为 $0$);\n* `cnt` 是已凑成多少个总和为 $t$ 的集合(初始值为 $0$,当 $cnt = k$ 时,我们搜索到了合法方案,返回 `true`,否则对 `cnt` 进行加一操作,并将 `cur` 置零,搜索下个集合);\n* `vis` 用于记录哪些 $nums[i]$ 已被使用;\n* `idx` 是搜索关键,其含义为搜索空间的分割点。即对于当前正在搜索的集合,我们不会每次都扫描整个 `nums` 来找添加到该集合的下一个元素,而是能够明确下一个元素必然在 $idx$ 的左边或右边。\n具体的,我们知道若最终存在合法方案,必然每个 $nums[i]$ 都均棣属于某个具体集合。我们考虑搜索某个集合的组成元素时,按照「从大到小」的方式进行搜索(起始先对 `nums` 进行排序),这样能够**确保若上一个被加入该集合的元素为 $nums[i]$,则下一个被添加的元素 $nums[j]$ 必然位于 $nums[i]$ 的左边,即从下标 $i - 1$ 开始往前搜索(顺序性剪枝)**;\n同时,也正是我们按照「从大到小」的方式进行搜索,**确保了当前集合的搜索,无须对已搜索到的集合进行调整**。\n也就是说我们搜索的第一个集合是所有 $nums[i]$ 中的最大值所在的那个集合;二次搜索是所有 $nums[i]$ 减去第一个集合后剩余元素中最大值所在的集合 ... \n这引导我们,**如果当前集合如果连第一个值都无法搜到(即剩余元素的最大值不能作为当前集合的元素),必然无解(可行性剪枝)**。\n\n这样的「搜索 + 剪枝」的解法本质是利用了「贪心」来做策略:**我们每个回合的搜索总是在搜索「剩余未使用元素的最大值」所在的那个集合,并且按照「优先使用大数值」的原则来构造。**\n\n可证明该做法的正确性:由于搜索的是「剩余未使用元素的最大值」所在的那个集合,因此剩余未使用元素必然在集合内,若被搜索到的其余元素参与集合构造导致有解变无解(即需要将其余元素进行替换才能确保有解),根据我们「从大到小」搜索下一个元素原则,替换过程必然不会使集合元素个数变少,即总是会拿不少于 $K$ 个的元素来替换当前集合的 $K$ 个元素(总和相同),从而可推断该替换并非必须。\n\nJava 代码:\n```Java\nclass Solution {\n    int[] nums;\n    int n, t, k;\n    public boolean canPartitionKSubsets(int[] _nums, int _k) {\n        nums = _nums; k = _k;\n        int tot = 0;\n        for (int x : nums) tot += x;\n        if (tot % k != 0) return false; // 可行性剪枝\n        Arrays.sort(nums);\n        n = nums.length; t = tot / k;\n        return dfs(n - 1, 0, 0, new boolean[n]);\n    }\n    boolean dfs(int idx, int cur, int cnt, boolean[] vis) {\n        if (cnt == k) return true;\n        if (cur == t) return dfs(n - 1, 0, cnt + 1, vis);\n        for (int i = idx; i >= 0; i--) {  // 顺序性剪枝\n            if (vis[i] || cur + nums[i] > t) continue;  // 可行性剪枝\n            vis[i] = true;\n            if (dfs(i - 1, cur + nums[i], cnt, vis)) return true;\n            vis[i] = false;\n            if (cur == 0) return false; // 可行性剪枝\n        }\n        return false;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> nums;\n    int n, t, k;\n    bool dfs(int idx, int cur, int cnt, vector<bool>& vis) {\n        if (cnt == k) return true;\n        if (cur == t) return dfs(n - 1, 0, cnt + 1, vis);\n        for (int i = idx; i >= 0; i--) {\n            if (vis[i] || cur + nums[i] > t) continue;\n            vis[i] = true;\n            if (dfs(i - 1, cur + nums[i], cnt, vis)) return true;\n            vis[i] = false;\n            if (cur == 0) return false;\n        }\n        return false;\n    }\n    bool canPartitionKSubsets(vector<int>& _nums, int _k) {\n        nums = _nums; k = _k;\n        int tot = 0;\n        for (int x : nums) tot += x;\n        if (tot % k != 0) return false;\n        sort(nums.begin(), nums.end());\n        n = nums.size(); t = tot / k;\n        vector<bool> vis(n, false);\n        return dfs(n - 1, 0, 0, vis);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def canPartitionKSubsets(self, _nums, _k):\n        nums, k = _nums, _k\n        tot = sum(nums)\n        if tot % k != 0:\n            return False\n        nums.sort()\n        n, t = len(nums), tot // k\n        def dfs(idx, cur, cnt, vis):\n            if cnt == k:\n                return True\n            if cur == t:\n                return dfs(n - 1, 0, cnt + 1, vis)\n            for i in range(idx, -1, -1):\n                if vis[i] or cur + nums[i] > t:\n                    continue\n                vis[i] = True\n                if dfs(i - 1, cur + nums[i], cnt, vis):\n                    return True\n                vis[i] = False\n                if cur == 0:\n                    return False\n            return False\n        return dfs(n - 1, 0, 0, [False] * n)\n```\nTypeScript 代码:\n```TypeScript\nlet nums: number[];\nlet n: number, t: number, k: number;\nfunction canPartitionKSubsets(_nums: number[], _k: number): boolean {\n    nums = _nums; k = _k;\n    let tot = 0\n    for (let x of nums) tot += x\n    if (tot % k != 0) return false\n    nums.sort((a,b)=>a-b)\n    n = nums.length; t = tot / k\n    return dfs(n - 1, 0, 0, new Array<boolean>(n).fill(false))\n};\nfunction dfs(idx: number, cur: number, cnt: number, vis: boolean[]): boolean {\n    if (cnt == k) return true\n    if (cur == t) return dfs(n - 1, 0, cnt + 1, vis)\n    for (let i = idx; i >= 0; i--) {\n        if (vis[i] || cur + nums[i] > t) continue\n        vis[i] = true\n        if (dfs(idx - 1, cur + nums[i], cnt, vis)) return true\n        vis[i] = false\n        if (cur == 0) return false\n    }\n    return false\n}\n```\n* 时间复杂度:爆搜剪枝不分析时空复杂度\n* 空间复杂度:爆搜剪枝不分析时空复杂度\n\n---\n\n### 模拟退火\n\n数据范围为 $16$ 自然也是很好的调参运用题。\n\n**因为将 $n$ 个数划分为 $k$ 份,等效于用 $n$ 个数构造出一个「特定排列」,然后对「特定排列」进行固定模式的构造逻辑,就能实现「答案」与「目标排列」的对应关系。**\n\n基于此,我们可以使用「模拟退火」进行求解。\n\n单次迭代的基本流程:\n\n1. 随机选择两个下标,计算「交换下标元素前对应序列的得分」&「交换下标元素后对应序列的得分」\n2. 如果温度下降(交换后的序列更优),进入下一次迭代\n3. 如果温度上升(交换前的序列更优),以「一定的概率」恢复现场(再交换回来)\n\n我们可以制定如下规则来衡量当前排列与合法排列的差异程度:将当前的 `nums` 从前往后划分成总和不超过 $t$ 的 $k$ 份,并将 $k$ 份与 $t$ 的差值之和,作为对当前排列的差异程度评级 `diff`,当出现 `diff = 0` 说明找到了合法排列,可结束搜索。\n\n该计算规则可确保排列变化的连续性能有效体现在 `diff` 数值上。\n\nJava 代码(`2024/06/01` 可通过):\n```Java\nclass Solution {\n    int[] nums;\n    int n, tval, k;\n    Random random = new Random(20220920);\n    double hi = 1e9, lo = 1e-4, fa = 0.95;\n    int N = 600;\n    boolean ans;\n    int calc() {\n        int diff = tval * k;\n        for (int i = 0, j = 0; i < n && j < k; j++) {\n            int cur = 0;\n            while (i < n && cur + nums[i] <= tval) cur += nums[i++];\n            diff -= cur;\n        }\n        if (diff == 0) ans = true;\n        return diff;\n    }\n    void sa() {\n        shuffle(nums);\n        for (double t = hi; t > lo && !ans; t *= fa) {\n            int a = random.nextInt(n), b = random.nextInt(n);\n            if (a == b) continue;\n            int prev = calc();\n            swap(nums, a, b);\n            int cur = calc();\n            int diff = cur - prev;\n            if (Math.log(diff / t) > random.nextDouble()) swap(nums, a, b);\n        }\n    }\n    public boolean canPartitionKSubsets(int[] _nums, int _k) {\n        nums = _nums; k = _k;\n        int tot = 0;\n        for (int x : nums) tot += x;\n        if (tot % k != 0) return false;\n        n = nums.length; tval = tot / k;\n        while (!ans && N-- > 0) sa();\n        return ans;\n    }\n    void shuffle(int[] nums) {\n        for (int i = n; i > 0; i--) swap(nums, random.nextInt(i), i - 1);\n    }\n    void swap(int[] nums, int a, int b) {\n        int c = nums[a];\n        nums[a] = nums[b];\n        nums[b] = c;\n    }\n}\n```\nTypeScript 代码(`2024/06/01` 可通过):\n```TypeScript\nlet nums: number[];\nlet n: number, tval: number, k: number\nlet ans: boolean\nlet hi: number, lo: number, fa: number, N: number\nfunction getRandom(max: number): number {\n    return Math.floor(Math.random() * (max + 1))\n}\nfunction calc(): number {\n    let diff = tval * k\n    for (let i = 0, j = 0; i < n && j < k; j++) {\n        let cur = 0\n        while (i < n && cur + nums[i] <= tval) cur += nums[i++]\n        diff -= cur\n    }\n    if (diff == 0) ans = true\n    return diff\n}\nfunction sa(): void {\n    shuffle(nums)\n    for (let t = hi; t > lo && !ans; t *= fa) {\n        const a = getRandom(n - 1), b = getRandom(n - 1)\n        if (a == b) continue\n        const prev = calc()\n        swap(nums, a, b)\n        const cur = calc()\n        const diff = cur - prev\n        if (Math.log(diff / t) > Math.random()) swap(nums, a, b)\n    }\n}\nfunction canPartitionKSubsets(_nums: number[], _k: number): boolean {\n    nums = _nums; k = _k\n    let tot = 0\n    for (let x of nums) tot += x\n    if (tot % k != 0) return false\n    n = nums.length; tval = tot / k\n    hi = 1e7; lo = 1e-4; fa = 0.977; N = 420;\n    ans = false\n    while (!ans && N-- > 0) sa()\n    return ans\n}\nfunction shuffle(nums: number[]): void {\n    for (let i = n; i > 0; i--) swap(nums, getRandom(i), i - 1)\n}\nfunction swap(nums: number[], a: number, b: number): void {\n    const c = nums[a]\n    nums[a] = nums[b]\n    nums[b] = c\n}\n```\n* 时间复杂度:启发式搜索不分析时空复杂度\n* 空间复杂度:启发式搜索不分析时空复杂度", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.698` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/691-700/699. 掉落的方块（困难）.md", "url_title": "699. 掉落的方块", "url": "https://leetcode.cn/problems/falling-squares/solution/by-ac_oier-zpf0/", "difficulty": "困难", "tags": ["线段树(动态开点)", "线段树"], "question": "在无限长的数轴(即 `x` 轴)上,我们根据给定的顺序放置对应的正方形方块。\n\n第 i 个掉落的方块(`positions[i] = (left, side_length)`)是正方形,其中 `left` 表示该方块最左边的点位置(`positions[i][0]`),`side_length` 表示该方块的边长(`positions[i][1]`)。\n\n每个方块的底部边缘平行于数轴(即 `x` 轴),并且从一个比目前所有的落地方块更高的高度掉落而下。在上一个方块结束掉落,并保持静止后,才开始掉落新方块。\n\n方块的底边具有非常大的粘性,并将保持固定在它们所接触的任何长度表面上(无论是数轴还是其他方块)。邻接掉落的边不会过早地粘合在一起,因为只有底边才具有粘性。\n\n返回一个堆叠高度列表 `ans`。每一个堆叠高度 `ans[i]` 表示在通过 `positions[0], positions[1], ..., positions[i]` 表示的方块掉落结束后,目前所有已经落稳的方块堆叠的最高高度。\n\n示例 1:\n```\n输入: [[1, 2], [2, 3], [6, 1]]\n\n输出: [2, 5, 5]\n\n解释:\n\n第一个方块 positions[0] = [1, 2] 掉落:\n_aa\n_aa\n-------\n方块最大高度为 2 。\n\n第二个方块 positions[1] = [2, 3] 掉落:\n__aaa\n__aaa\n__aaa\n_aa__\n_aa__\n--------------\n方块最大高度为5。\n大的方块保持在较小的方块的顶部,不论它的重心在哪里,因为方块的底部边缘有非常大的粘性。\n\n第三个方块 positions[1] = [6, 1] 掉落:\n__aaa\n__aaa\n__aaa\n_aa\n_aa___a\n-------------- \n方块最大高度为5。\n\n因此,我们返回结果[2, 5, 5]。\n```\n\n示例 2:\n```\n输入: [[100, 100], [200, 100]]\n\n输出: [100, 100]\n\n解释: 相邻的方块不会过早地卡住,只有它们的底部边缘才能粘在表面上。\n```\n\n注意:\n* $1 <= positions.length <= 1000$\n* $1 <= positions[i][0] <= 10^8$\n* $1 <= positions[i][1] <= 10^6$", "solution": "### 基本分析 \n\n为了方便,我们使用 `ps` 来代指 `positions`。\n\n每次从插入操作都附带一次询问,因此询问次数为 $1e3$,左端点的最大值为 $10e8$,边长最大值为 $1e6$,由此可知值域范围大于 $1e8$,但不超过 $1e9$。\n\n对于值域范围大,但查询次数有限的区间和问题,不久前曾经总结过 : [求解常见「值域爆炸,查询有限」区间问题的几种方式](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247491187&idx=2&sn=bb2d8b7e89c535914da8107387e951a2),可作为前置 🧀 进行了解。\n\n而我的个人习惯,一般要么使用「离散化 + 线段树」,要么使用「线段树(动态开点)」进行求解。\n\n本题为「非强制在线」问题,因此可以先对 `ps` 数组进行离散化,将值域映射到较小的空间,然后套用固定占用 $4 \\times n$ 空间的线段树求解。\n\n但更为灵活(能够同时应对强制在线问题)的求解方式是「线段树(动态开点)」。\n\n同时实现动态开点的方式有两种:\n\n1. 根据操作次数对使用到的最大点数进行预估,并采用数组方式进行实现线段树(解法一);\n2. 使用动态指针(解法二);\n\n方式一在不久之前的每日一题 [933. 最近的请求次数](https://sharingsource.github.io/2022/05/06/933.%20%E6%9C%80%E8%BF%91%E7%9A%84%E8%AF%B7%E6%B1%82%E6%AC%A1%E6%95%B0%EF%BC%88%E7%AE%80%E5%8D%95%EF%BC%89/) 讲过,因此今天把方式二也写一下。\n\n具体的,我们将顺序放置方块的操作(假设当前方块的左端点为 $a$,边长为 $len$,则有右端点为 $b = a + len$),分成如下两步进行:\n\n* 查询当前范围 $[a, b]$ 的最大高度为多少,假设为 $cur$;\n* 更新当前范围 $[a, b]$ 的最新高度为 $cur + len$。\n\n因此这本质上是一个「区间修改 + 区间查询」的问题,我们需要实现带「懒标记」的线段树,从而确保在进行「区间修改」时复杂度仍为 $O(\\log{n})$。\n\n> 另外有一个需要注意的细节是:不同方块之间的边缘可以重合,但不会导致方块叠加,因此我们当我们对一个区间 $[a, b]$ 进行操作(查询或插入)时,可以将其调整为 $[a, b - 1]$,从而解决边缘叠加操作高度错误的问题。\n\n---\n\n### 线段树(动态开点 - 估点)\n\n估点的基本方式在前置 🧀 [求解常见「值域爆炸,查询有限」区间问题的几种方式](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247491187&idx=2&sn=bb2d8b7e89c535914da8107387e951a2) 详细讲过。\n\n简单来说,可以直接估算为 $6 \\times m \\times \\log{n}$ 即可,其中 $m$ 为询问次数(对应本题就是 `ps` 的长度),而 $n$ 为值域大小(对应本题可直接取成 $1e9$);而另外一个比较实用(避免估算)的估点方式可以「尽可能的多开点数」,利用题目给定的空间上界和我们创建的自定义类(结构体)的大小,尽可能的多开(不考虑字节对齐,或者结构体过大的情况,`Java` 的 $128M$ 可以开到 $5 \\times 10^6$ 以上)。\n\n代码:\n```Java\nclass Solution {\n    class Node {\n        // ls 和 rs 分别代表当前区间的左右子节点所在 tr 数组中的下标\n        // val 代表当前区间的最大高度,add 为懒标记\n        int ls, rs, val, add;\n    }\n    int N = (int)1e9, cnt = 0;\n    Node[] tr = new Node[1000010];\n    void update(int u, int lc, int rc, int l, int r, int v) {\n        if (l <= lc && rc <= r) {\n            tr[u].val = v;\n            tr[u].add = v;\n            return ;\n        }\n        pushdown(u);\n        int mid = lc + rc >> 1;\n        if (l <= mid) update(tr[u].ls, lc, mid, l, r, v);\n        if (r > mid) update(tr[u].rs, mid + 1, rc, l, r, v);\n        pushup(u);\n    }\n    int query(int u, int lc, int rc, int l, int r) {\n        if (l <= lc && rc <= r) return tr[u].val;\n        pushdown(u);\n        int mid = lc + rc >> 1, ans = 0;\n        if (l <= mid) ans = query(tr[u].ls, lc, mid, l, r);\n        if (r > mid) ans = Math.max(ans, query(tr[u].rs, mid + 1, rc, l, r));\n        return ans;\n    }\n    void pushdown(int u) {\n        if (tr[u] == null) tr[u] = new Node();\n        if (tr[u].ls == 0) {\n            tr[u].ls = ++cnt;\n            tr[tr[u].ls] = new Node();\n        }\n        if (tr[u].rs == 0) {\n            tr[u].rs = ++cnt;\n            tr[tr[u].rs] = new Node();\n        }\n        if (tr[u].add == 0) return ;\n        int add = tr[u].add;\n        tr[tr[u].ls].add = add; tr[tr[u].rs].add = add;\n        tr[tr[u].ls].val = add; tr[tr[u].rs].val = add;\n        tr[u].add = 0;\n    }\n    void pushup(int u) {\n        tr[u].val = Math.max(tr[tr[u].ls].val, tr[tr[u].rs].val);\n    }\n    public List<Integer> fallingSquares(int[][] ps) {\n        List<Integer> ans = new ArrayList<>();\n        tr[1] = new Node();\n        for (int[] info : ps) {\n            int x = info[0], h = info[1], cur = query(1, 1, N, x, x + h - 1);\n            update(1, 1, N, x, x + h - 1, cur + h);\n            ans.add(tr[1].val);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $m$ 为查询次数,$n$ 为值域大小,复杂度为 $O(m\\log{n})$\n* 空间复杂度:$O(m\\log{n})$\n\n---\n\n### 线段树(动态开点 - 动态指针)\n\n利用「动态指针」实现的「动态开点」可以有效避免数组估点问题,更重要的是可以有效避免 `new` 大数组的初始化开销,对于 LC 这种还跟你算所有样例总时长的 OJ 来说,在不考虑 `static` 优化/全局数组优化 的情况下,动态指针的方式要比估点的方式来得好。\n\n代码:\n```Java\nclass Solution {\n    int N = (int)1e9;\n    class Node {\n        // ls 和 rs 分别代表当前区间的左右子节点\n        Node ls, rs;\n        // val 代表当前区间的最大高度,add 为懒标记\n        int val, add;\n    }\n    Node root = new Node();\n    void update(Node node, int lc, int rc, int l, int r, int v) {\n        if (l <= lc && rc <= r) {\n            node.add = v;\n            node.val = v;\n            return ;\n        }\n        pushdown(node);\n        int mid = lc + rc >> 1;\n        if (l <= mid) update(node.ls, lc, mid, l, r, v);\n        if (r > mid) update(node.rs, mid + 1, rc, l, r, v);\n        pushup(node);\n    }\n    int query(Node node, int lc, int rc, int l, int r) {\n        if (l <= lc && rc <= r) return node.val;\n        pushdown(node);\n        int mid = lc + rc >> 1, ans = 0;\n        if (l <= mid) ans = query(node.ls, lc, mid, l, r);\n        if (r > mid) ans = Math.max(ans, query(node.rs, mid + 1, rc, l, r));\n        return ans;\n    }\n    void pushdown(Node node) {\n        if (node.ls == null) node.ls = new Node();\n        if (node.rs == null) node.rs = new Node();\n        if (node.add == 0) return ;\n        node.ls.add = node.add; node.rs.add = node.add;\n        node.ls.val = node.add; node.rs.val = node.add;\n        node.add = 0;\n    }\n    void pushup(Node node) {\n        node.val = Math.max(node.ls.val, node.rs.val);\n    }\n    public List<Integer> fallingSquares(int[][] ps) {\n        List<Integer> ans = new ArrayList<>();\n        for (int[] info : ps) {\n            int x = info[0], h = info[1], cur = query(root, 0, N, x, x + h - 1);\n            update(root, 0, N, x, x + h - 1, cur + h);\n            ans.add(root.val);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $m$ 为查询次数,$n$ 为值域大小,复杂度为 $O(m\\log{n})$\n* 空间复杂度:$O(m\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.699` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/691-700/700. 二叉搜索树中的搜索（简单）.md", "url_title": "700. 二叉搜索树中的搜索", "url": "https://leetcode-cn.com/problems/search-in-a-binary-search-tree/solution/gong-shui-san-xie-er-cha-shu-de-sou-suo-8z7hj/", "difficulty": "简单", "tags": ["树的搜索", "迭代", "递归"], "question": "给定二叉搜索树(BST)的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在,则返回 NULL。\n\n例如,\n```\n给定二叉搜索树:\n\n        4\n       / \\\n      2   7\n     / \\\n    1   3\n\n和值: 2\n```\n你应该返回如下子树:\n```\n      2     \n     / \\   \n    1   3\n```\n在上述示例中,如果要找的值是 5,但因为没有节点值为 5,我们应该返回 NULL。", "solution": "### 递归\n\n根据题意,进行「递归」搜索即可。\n\n代码:\n```Java\nclass Solution {\n    public TreeNode searchBST(TreeNode root, int val) {\n        if (root == null || root.val == val) return root;\n        return root.val < val ? searchBST(root.right, val) : searchBST(root.left, val);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(n)$\n\n---\n\n### 迭代\n\n同理,可以使用「迭代」进行搜索。\n\n代码:\n```Java\nclass Solution {\n    public TreeNode searchBST(TreeNode root, int val) {\n        while (root != null && root.val != val) {\n            root = root.val < val ? root.right : root.left;\n        }\n        return root;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.700` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/701-710/703. 数据流中的第 K 大元素（简单）.md", "url_title": "703. 数据流中的第 K 大元素", "url": "https://leetcode-cn.com/problems/kth-largest-element-in-a-stream/solution/jian-da-ti-de-duo-chong-jie-fa-mou-pao-p-d1qi/", "difficulty": "简单", "tags": ["Top K", "排序", "优先队列(堆)"], "question": "设计一个找到数据流中第 `k` 大元素的类(class)。注意是排序后的第 `k` 大元素,不是第 `k` 个不同的元素。\n\n请实现 `KthLargest` 类:\n* `KthLargest(int k, int[] nums)` 使用整数 `k` 和整数流 `nums` 初始化对象。\n* `int add(int val)` 将 `val` 插入数据流 `nums` 后,返回当前数据流中第 `k` 大的元素。\n\n示例:\n```\n输入:\n[\"KthLargest\", \"add\", \"add\", \"add\", \"add\", \"add\"]\n[[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]]\n输出:\n[null, 4, 5, 5, 8, 8]\n\n解释:\nKthLargest kthLargest = new KthLargest(3, [4, 5, 8, 2]);\nkthLargest.add(3);   // return 4\nkthLargest.add(5);   // return 5\nkthLargest.add(10);  // return 5\nkthLargest.add(9);   // return 8\nkthLargest.add(4);   // return 8\n```\n\n提示:\n* $1 <= k <= 10^4$\n* $0 <= nums.length <= 10^4$\n* $-10^4 <= nums[i] <= 10^4$\n* $-10^4 <= val <= 10^4$\n* 最多调用 `add` 方法 $10^4$ 次\n* 题目数据保证,在查找第 `k` 大元素时,数组中至少有 `k` 个元素", "solution": "### 冒泡排序 (TLE)\n\n每次调用 `add` 时先将数装入数组,然后遍历 `k` 次,通过找 `k` 次最大值来找到 Top K。\n\n代码:\n```Java\nclass KthLargest {\n    int k;\n    List<Integer> list = new ArrayList<>(10009);\n    public KthLargest(int _k, int[] _nums) {\n        k = _k;\n        for (int i : _nums) list.add(i);\n    }\n    public int add(int val) {\n        list.add(val);\n        int cur = 0;\n        for (int i = 0; i < k; i++) {\n            int idx = findMax(cur, list.size() - 1);\n            swap(cur++, idx);\n        }\n        return list.get(cur - 1); \n    }\n    int findMax(int start, int end) {\n        int ans = 0, max = Integer.MIN_VALUE;\n        for (int i = start; i <= end; i++) {\n            int t = list.get(i);\n            if (t > max) {\n                max = t;\n                ans = i;\n            }\n        }\n        return ans;\n    }\n    void swap(int a, int b) {\n        int c = list.get(a);\n        list.set(a, list.get(b));\n        list.set(b, c);\n    }\n}\n```\n* 时间复杂度:$O(nk)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 快速排序\n\n上述的解法时间复杂度是 $O(nk)$ 的,当 `k` 很大的时候会超时。\n\n我们可以使用快排来代替冒泡,将复杂度变为 $O(n\\log{n})$。\n\n代码:\n```Java\nclass KthLargest {\n    int k;\n    List<Integer> list = new ArrayList<>(10009);\n    public KthLargest(int _k, int[] _nums) {\n        k = _k;\n        for (int i : _nums) list.add(i);\n    }\n    \n    public int add(int val) {\n        list.add(val);\n        Collections.sort(list);\n        return list.get(list.size() - k);\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 优先队列\n\n使用优先队列构建一个容量为 `k` 的小根堆。\n\n将 `nums` 中的前 `k` 项放入优先队列(此时堆顶元素为前 `k` 项的最大值)。\n\n随后逐项加入优先队列:\n\n* 堆内元素个数达到 `k` 个:\n\n  * 加入项小于等于堆顶元素:加入项排在第 `k` 大元素的后面。直接忽略\n  * 加入项大于堆顶元素:将堆顶元素弹出,加入项加入优先队列,调整堆\n\n* 堆内元素个数不足 `k` 个,将加入项加入优先队列\n\n将堆顶元素进行返回(数据保证返回答案时,堆内必然有 `k` 个元素):\n\n代码:\n```Java\nclass KthLargest {\n    int k;\n    PriorityQueue<Integer> queue;\n    public KthLargest(int _k, int[] _nums) {\n        k = _k;\n        queue = new PriorityQueue<>(k, (a,b)->Integer.compare(a,b));\n        int n = _nums.length;\n        for (int i = 0; i < k && i < n; i++) queue.add(_nums[i]);\n        for (int i = k; i < n; i++) add(_nums[i]);\n    }\n    public int add(int val) {\n        int t = !queue.isEmpty() ? queue.peek() : Integer.MIN_VALUE;\n        if (val > t || queue.size() < k) {\n            if (!queue.isEmpty() && queue.size() >= k) queue.poll();\n            queue.add(val);\n        }\n        return queue.peek();\n    }\n}\n```\n* 时间复杂度:最坏情况下,`n` 个元素都需要入堆。复杂度为 $O(n\\log{k})$\n* 空间复杂度:$O(k)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.703` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/701-710/704. 二分查找（简单）.md", "url_title": "704. 二分查找", "url": "https://leetcode-cn.com/problems/binary-search/solution/gong-shui-san-xie-yun-yong-er-fen-zhao-f-5jyj/", "difficulty": "简单", "tags": ["二分"], "question": "给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target  ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1。\n\n示例 1:\n```\n输入: nums = [-1,0,3,5,9,12], target = 9\n\n输出: 4\n\n解释: 9 出现在 nums 中并且下标为 4\n```\n示例 2:\n```\n输入: nums = [-1,0,3,5,9,12], target = 2\n\n输出: -1\n\n解释: 2 不存在 nums 中因此返回 -1\n```\n\n提示:\n* 你可以假设 nums 中的所有元素是不重复的。\n* n 将在 [1, 10000]之间。\n* nums 的每个元素都将在 [-9999, 9999]之间。", "solution": "### 二分 \n\n一道二分裸题,写二分重点在于学会从「二段性」出发进行分析,想清楚二分的是哪个端点/边界。\n\n而不是局限于用什么模板,大于还是小于,硬记这些对理解二分不会有任何帮助。\n\n事实上,当搞清楚二分的是什么内容之后,何种形式写法都能写出。\n\n代码:\n\n```Java\nclass Solution {\n    public int search(int[] nums, int t) {\n        int n = nums.length;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (nums[mid] <= t) l = mid;\n            else r = mid - 1;\n        }\n        return nums[r] == t ? r : -1;\n    }\n}\n```\n```Java\nclass Solution {\n    public int search(int[] nums, int t) {\n        int n = nums.length;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (nums[mid] >= t) r = mid;\n            else l = mid + 1;\n        }\n        return nums[r] == t ? r : -1;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.704` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/701-710/705. 设计哈希集合（简单）.md", "url_title": "705. 设计哈希集合", "url": "https://leetcode-cn.com/problems/design-hashset/solution/yi-ti-san-jie-jian-dan-shu-zu-lian-biao-nj3dg/", "difficulty": "简单", "tags": ["哈希表"], "question": "不使用任何内建的哈希表库设计一个哈希集合(HashSet)。\n\n实现 MyHashSet 类:\n\nvoid add(key) 向哈希集合中插入值 key 。\nbool contains(key) 返回哈希集合中是否存在这个值 key 。\nvoid remove(key) 将给定值 key 从哈希集合中删除。如果哈希集合中没有这个值,什么也不做。\n\n示例:\n```\n输入:\n[\"MyHashSet\", \"add\", \"add\", \"contains\", \"contains\", \"add\", \"contains\", \"remove\", \"contains\"]\n[[], [1], [2], [1], [3], [2], [2], [2], [2]]\n输出:\n[null, null, null, true, false, null, true, null, false]\n\n解释:\nMyHashSet myHashSet = new MyHashSet();\nmyHashSet.add(1);      // set = [1]\nmyHashSet.add(2);      // set = [1, 2]\nmyHashSet.contains(1); // 返回 True\nmyHashSet.contains(3); // 返回 False ,(未找到)\nmyHashSet.add(2);      // set = [1, 2]\nmyHashSet.contains(2); // 返回 True\nmyHashSet.remove(2);   // set = [1]\nmyHashSet.contains(2); // 返回 False ,(已移除)\n```\n\n提示:\n* 0 <= key <= $10^6$\n* 最多调用 $10^4$ 次 add、remove 和 contains 。", "solution": "### 简单数组\n\n由于题目给出了 `0 <= key <= 10^6` 数据范围,同时限定了 key 只能是 int。\n\n我们可以直接使用一个 boolean 数组记录某个 key 是否存在,key 直接对应 boolean 的下标。\n\n代码:\n```Java\nclass MyHashSet {\n    boolean[] nodes = new boolean[1000009];\n    \n    public void add(int key) {\n        nodes[key] = true;\n    }\n    \n    public void remove(int key) {\n        nodes[key] = false;\n    }\n    \n    public boolean contains(int key) {\n        return nodes[key];\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$\n\n***\n\n### 链表\n\n我们利用「链表」来构建 Set,这也是工程上最简单的一种实现方式。\n\n代码:\n```Java\nclass MyHashSet {\n    // 由于使用的是「链表」,这个值可以取得很小\n    Node[] nodes = new Node[10009];\n\n    public void add(int key) {\n        // 根据 key 获取哈希桶的位置\n        int idx = getIndex(key);\n        // 判断链表中是否已经存在\n        Node loc = nodes[idx], tmp = loc;\n        if (loc != null) {\n            Node prev = null;\n            while (tmp != null) {\n                if (tmp.key == key) { \n                    return;\n                }\n                prev = tmp;\n                tmp = tmp.next;\n            }\n            tmp = prev;\n        }\n        Node node = new Node(key);\n\n        // 头插法\n        // node.next = loc;\n        // nodes[idx] = node;\n\n        // 尾插法 \n        if (tmp != null) {\n            tmp.next = node;\n        } else {\n            nodes[idx] = node;\n        }\n    }\n\n    public void remove(int key) {\n        int idx = getIndex(key);\n        Node loc = nodes[idx];\n        if (loc != null) {\n            Node prev = null;\n            while (loc != null) {\n                if (loc.key == key) {\n                    if (prev != null) {\n                        prev.next = loc.next;\n                    } else {\n                        nodes[idx] = loc.next;\n                    }\n                    return;\n                }\n                prev = loc;\n                loc = loc.next;\n            }\n        }\n    }\n\n    public boolean contains(int key) {\n        int idx = getIndex(key);\n        Node loc = nodes[idx];\n        if (loc != null) {\n            while (loc != null) {\n                if (loc.key == key) {\n                    return true;\n                }\n                loc = loc.next;\n            }\n        }\n        return false;\n    }\n\n    static class Node {\n        private int key;\n        private Node next;\n        private Node(int key) {\n            this.key = key;\n        }\n    }\n    \n    int getIndex(int key) {\n        // 因为 nodes 的长度只有 10009,对应的十进制的 10011100011001(总长度为 32 位,其余高位都是 0)\n        // 为了让 key 对应的 hash 高位也参与运算,这里对 hashCode 进行右移异或\n        // 使得 hashCode 的高位随机性和低位随机性都能体现在低 16 位中\n        int hash = Integer.hashCode(key);\n        hash ^= (hash >>> 16);\n        return hash % nodes.length;\n    }\n}\n```\n* 时间复杂度:由于没有扩容的逻辑,最坏情况下复杂度为 $O(n)$,一般情况下复杂度为 $O(1)$\n* 空间复杂度:$O(1)$\n\n***\n\n### 分桶数组\n\n事实上我们还可以实现一个类似「bitmap」数据结构。\n\n使用 int 中的每一位代表一个位置。\n\n由于数据范围为 `0 <= key <= 10^6`,我们最多需要的 int 数量不会超过 40000。\n\n因此我们可以建立一个 buckets 数组,数组装载的 int 类型数值。\n\n* 先对 key 进行 `key / 32`,确定当前 key 所在桶的位置(大概位置)\n* 再对 key 进行 `key % 32`,确定当前 key 所在桶中的哪一位(精确位置)\n\n根据位运算对「精确位置」进行修改。\n\n代码:\n```Java\nclass MyHashSet {\n    int[] bs = new int[40000];\n    public void add(int key) {\n        int bucketIdx = key / 32;\n        int bitIdx = key % 32;\n        setVal(bucketIdx, bitIdx, true);\n    }\n    \n    public void remove(int key) {\n        int bucketIdx = key / 32;\n        int bitIdx = key % 32;\n        setVal(bucketIdx, bitIdx, false);\n    }\n    \n    public boolean contains(int key) {\n        int bucketIdx = key / 32;\n        int bitIdx = key % 32;\n        return getVal(bucketIdx, bitIdx);\n    }\n\n    void setVal(int bucket, int loc, boolean val) {\n        if (val) {\n            int u = bs[bucket] | (1 << loc);\n            bs[bucket] = u;\n        } else {\n            int u = bs[bucket] & ~(1 << loc);\n            bs[bucket] = u;\n        }\n    }\n\n    boolean getVal(int bucket, int loc) {\n        int u = (bs[bucket] >> loc) & 1;\n        return u == 1;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.705` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/701-710/706. 设计哈希映射（简单）.md", "url_title": "706. 设计哈希映射", "url": "https://leetcode-cn.com/problems/design-hashmap/solution/yi-ti-shuang-jie-jian-dan-shu-zu-lian-bi-yhiw/", "difficulty": "简单", "tags": ["哈希表"], "question": "不使用任何内建的哈希表库设计一个哈希映射(HashMap)。\n\n实现 MyHashMap 类:\n\nMyHashMap() 用空映射初始化对象\nvoid put(int key, int value) 向 HashMap 插入一个键值对 (key, value) 。如果 key 已经存在于映射中,则更新其对应的值 value 。\nint get(int key) 返回特定的 key 所映射的 value ;如果映射中不包含 key 的映射,返回 -1 。\nvoid remove(key) 如果映射中存在 key 的映射,则移除 key 和它所对应的 value 。\n\n示例:\n```\n输入:\n[\"MyHashMap\", \"put\", \"put\", \"get\", \"get\", \"put\", \"get\", \"remove\", \"get\"]\n[[], [1, 1], [2, 2], [1], [3], [2, 1], [2], [2], [2]]\n输出:\n[null, null, null, 1, -1, null, 1, null, -1]\n\n解释:\nMyHashMap myHashMap = new MyHashMap();\nmyHashMap.put(1, 1); // myHashMap 现在为 [[1,1]]\nmyHashMap.put(2, 2); // myHashMap 现在为 [[1,1], [2,2]]\nmyHashMap.get(1);    // 返回 1 ,myHashMap 现在为 [[1,1], [2,2]]\nmyHashMap.get(3);    // 返回 -1(未找到),myHashMap 现在为 [[1,1], [2,2]]\nmyHashMap.put(2, 1); // myHashMap 现在为 [[1,1], [2,1]](更新已有的值)\nmyHashMap.get(2);    // 返回 1 ,myHashMap 现在为 [[1,1], [2,1]]\nmyHashMap.remove(2); // 删除键为 2 的数据,myHashMap 现在为 [[1,1]]\nmyHashMap.get(2);    // 返回 -1(未找到),myHashMap 现在为 [[1,1]]\n```\n\n提示:\n* 0 <= key, value <= $10^6$\n* 最多调用 $10^4$ 次 put、get 和 remove 方法", "solution": "### 简单数组解法 \n\n与昨天的 [705. 设计哈希集合](https://leetcode-cn.com/problems/design-hashset/solution/yi-ti-san-jie-jian-dan-shu-zu-lian-biao-nj3dg/) 不同。\n\n我们不仅仅需要记录一个元素存在与否,还需要记录该元素对应的值是什么。\n\n由于题目限定了数据范围 $0 <= key, value <= 10^6$,和 kv 的数据类型。\n\n我们可以使用 int 类型的数组实现哈希表功能。\n\n```java\nclass MyHashMap {\n    int INF = Integer.MAX_VALUE;\n    int N = 1000009;\n    int[] map = new int[N];\n    public MyHashMap() {\n        Arrays.fill(map, INF);\n    }\n    \n    public void put(int key, int value) {\n        map[key] = value;\n    }\n    \n    public int get(int key) {\n        return map[key] == INF ? -1 : map[key];\n    }\n    \n    public void remove(int key) {\n        map[key] = INF;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$\n\n***\n\n### 链表解法\n\n与 [705. 设计哈希集合](https://leetcode-cn.com/problems/design-hashset/solution/yi-ti-san-jie-jian-dan-shu-zu-lian-biao-nj3dg/) 同理,我们可以利用「链表」来构建 Map,这也是工程上最简单的一种实现方式。\n\n```java\nclass MyHashMap {\n    static class Node {\n        int key, value;\n        Node next;\n        Node(int _key, int _value) {\n            key = _key;\n            value = _value;\n        }\n    }\n\n    // 由于使用的是「链表」,这个值可以取得很小\n    Node[] nodes = new Node[10009];\n\n    public void put(int key, int value) {\n        // 根据 key 获取哈希桶的位置\n        int idx = getIndex(key);\n        // 判断链表中是否已经存在\n        Node loc = nodes[idx], tmp = loc;\n        if (loc != null) {\n            Node prev = null;\n            while (tmp != null) {\n                if (tmp.key == key) { \n                    tmp.value = value;\n                    return;\n                }\n                prev = tmp;\n                tmp = tmp.next;\n            }\n            tmp = prev;\n        }\n        Node node = new Node(key, value);\n\n        // 头插法\n        // node.next = loc;\n        // nodes[idx] = node;\n\n        // 尾插法 \n        if (tmp != null) {\n            tmp.next = node;\n        } else {\n            nodes[idx] = node;\n        }\n    }\n\n    public void remove(int key) {\n        int idx = getIndex(key);\n        Node loc = nodes[idx];\n        if (loc != null) {\n            Node prev = null;\n            while (loc != null) {\n                if (loc.key == key) {\n                    if (prev != null) {\n                        prev.next = loc.next;\n                    } else {\n                        nodes[idx] = loc.next;\n                    }\n                    return;\n                }\n                prev = loc;\n                loc = loc.next;\n            }\n        }\n    }\n\n    public int get(int key) {\n        int idx = getIndex(key);\n        Node loc = nodes[idx];\n        if (loc != null) {\n            while (loc != null) {\n                if (loc.key == key) {\n                    return loc.value;\n                }\n                loc = loc.next;\n            }\n        }\n        return -1;\n    }\n    \n    int getIndex(int key) {\n        // 因为 nodes 的长度只有 10009,对应的十进制的 10011100011001(总长度为 32 位,其余高位都是 0)\n        // 为了让 key 对应的 hash 高位也参与运算,这里对 hashCode 进行右移异或\n        // 使得 hashCode 的高位随机性和低位随机性都能体现在低 16 位中\n        int hash = Integer.hashCode(key);\n        hash ^= (hash >>> 16);\n        return hash % nodes.length;\n    }\n}\n```\n* 时间复杂度:由于没有扩容的逻辑,最坏情况下复杂度为 $O(n)$,一般情况下复杂度为 $O(1)$\n* 空间复杂度:$O(1)$\n\n***\n\n### 开放寻址解法\n\n除了使用「链表」来解决哈希冲突以外,还能使用「开放寻址法」来解决。\n\n```java\nclass MyHashMap {\n    static class Node {\n        int key, value;\n        Node next;\n        boolean isDeleted;\n        Node(int _key, int _value) {\n            key = _key;\n            value = _value;\n        }\n    }\n    \n    // 冲突时的偏移量\n    int OFFSET = 1;\n    Node[] nodes = new Node[10009];\n\n    public void put(int key, int value) {\n        int idx = getIndex(key);\n        Node node = nodes[idx];\n        if (node != null) {\n            node.value = value;\n            node.isDeleted = false;\n        } else {\n            node = new Node(key, value);\n            nodes[idx] = node;\n        }\n    }\n\n    public void remove(int key) {\n        Node node = nodes[getIndex(key)];\n        if (node != null) node.isDeleted = true;\n    }\n\n    public int get(int key) {\n        Node node = nodes[getIndex(key)];\n        if (node == null) return -1;\n        return node.isDeleted ? -1 : node.value;\n    }\n    \n    // 当 map 中没有 key 的时候,getIndex 总是返回一个空位置\n    // 当 map 中包含 key 的时候,getIndex 总是返回 key 所在的位置\n    int getIndex(int key) {\n        int hash = Integer.hashCode(key);\n        hash ^= (hash >>> 16);\n        int n = nodes.length;\n        int idx = hash % n;\n        while (nodes[idx] != null && nodes[idx].key != key) {\n            hash += OFFSET;\n            idx = hash % n;\n        }\n        return idx;\n    }\n}\n```\n* 时间复杂度:一般情况下复杂度为 $O(1)$,极端情况下为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.706` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/701-710/707. 设计链表（中等）.md", "url_title": "707. 设计链表", "url": "https://leetcode.cn/problems/design-linked-list/solution/by-ac_oier-vaib/", "difficulty": "中等", "tags": ["链表"], "question": "设计链表的实现。您可以选择使用单链表或双链表。\n\n单链表中的节点应该具有两个属性:`val` 和 `next`。`val` 是当前节点的值,`next` 是指向下一个节点的指针/引用。\n\n如果要使用双向链表,则还需要一个属性 `prev` 以指示链表中的上一个节点。假设链表中的所有节点都是 `0-index` 的。\n\n在链表类中实现这些功能:\n\n* `get(index)`:获取链表中第 `index` 个节点的值。如果索引无效,则返回`-1`。\n* `addAtHead(val)`:在链表的第一个元素之前添加一个值为 `val` 的节点。插入后,新节点将成为链表的第一个节点。\n* `addAtTail(val)`:将值为 `val` 的节点追加到链表的最后一个元素。\n* `addAtIndex(index,val)`:在链表中的第 `index` 个节点之前添加值为 `val`  的节点。如果 `index` 等于链表的长度,则该节点将附加到链表的末尾。如果 `index` 大于链表长度,则不会插入节点。如果 `index` 小于 `0`,则在头部插入节点。\n* `deleteAtIndex(index)`:如果索引 `index` 有效,则删除链表中的第 `index` 个节点。\n\n示例:\n```\nMyLinkedList linkedList = new MyLinkedList();\nlinkedList.addAtHead(1);\nlinkedList.addAtTail(3);\nlinkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3\nlinkedList.get(1);            //返回2\nlinkedList.deleteAtIndex(1);  //现在链表是1-> 3\nlinkedList.get(1);            //返回3\n```\n\n提示:\n* 所有 `val` 值都在 $[1, 1000]$ 之内。\n* 操作次数将在  $[1, 1000]$ 之内。\n* 请不要使用内置的 `LinkedList` 库。", "solution": "### 双向链表\n\n一道手写链表裸题(啊嘿,$9$ 月活动的同学表示很棒 🤣\n\n由于需要涉及部分 `index` 相关操作,因此我们可以实现一个「双向链表」,同时使用变量 `sz` 记录下当前链表的总长度,这样在涉及 `index` 操作时,可从较近的一边出发遍历,剩下的则是常规的链表节点操作。\n\n> 一些细节:所有的链表题目我们都可以引入前后哨兵来简化边界处理;同时能写双链表自然能写单链表,因此如果你没有顺利写出双链表的话,在看了题解写完双链表后,再手写一遍单链表作为练习。\n\nJava 代码:\n```Java\nclass MyLinkedList {\n    class Node {\n        Node prev, next;\n        int val;\n        Node (int _val) {\n            val = _val;\n        }\n    }\n    Node he = new Node(-1), ta = new Node(-1);\n    int sz = 0;\n    public MyLinkedList() {\n        he.next = ta; ta.prev = he;\n    }\n    public int get(int index) {\n        Node node = getNode(index);\n        return node == null ? -1 : node.val;\n    }\n    public void addAtHead(int val) {\n        Node node = new Node(val);        \n        node.next = he.next; node.prev = he;\n        he.next.prev = node; he.next = node;\n        sz++;\n    }\n    public void addAtTail(int val) {\n        Node node = new Node(val);\n        node.prev = ta.prev; node.next = ta;\n        ta.prev.next = node; ta.prev = node;\n        sz++;\n    }\n    public void addAtIndex(int index, int val) {\n        if (index > sz) return ;\n        if (index <= 0) {\n            addAtHead(val); \n        } else if (index == sz) {\n            addAtTail(val);\n        } else {\n            Node node = new Node(val), cur = getNode(index);\n            node.next = cur; node.prev = cur.prev;\n            cur.prev.next = node; cur.prev = node;\n            sz++;\n        }\n    }\n    public void deleteAtIndex(int index) {\n        Node cur = getNode(index);\n        if (cur == null) return ;\n        cur.next.prev = cur.prev;\n        cur.prev.next = cur.next;\n        sz--;\n    }\n    Node getNode(int index) {\n        boolean isLeft = index < sz / 2;\n        if (!isLeft) index = sz - index - 1;\n        for (Node cur = isLeft ? he.next : ta.prev; cur != ta && cur != he; cur = isLeft ? cur.next : cur.prev) {\n            if (index-- == 0) return cur;\n        }\n        return null;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nclass TNode {\n    prev: TNode\n    next: TNode\n    val: number\n    constructor(_val: number) {\n        this.val = _val\n    }\n}\nclass MyLinkedList {\n    he = new TNode(-1)\n    ta = new TNode(-1)\n    sz = 0\n    constructor() {\n        this.he.next = this.ta; this.ta.prev = this.he    \n    }\n    get(index: number): number {\n        const node = this.getNode(index)\n        return node == null ? -1 : node.val\n    }\n    addAtHead(val: number): void {\n        const node = new TNode(val)\n        node.next = this.he.next; node.prev = this.he\n        this.he.next.prev = node; this.he.next = node\n        this.sz++\n    }\n    addAtTail(val: number): void {\n        const node = new TNode(val)\n        node.prev = this.ta.prev; node.next = this.ta\n        this.ta.prev.next = node; this.ta.prev = node\n        this.sz++\n    }\n    addAtIndex(index: number, val: number): void {\n        if (index > this.sz) return \n        if (index <= 0) {\n            this.addAtHead(val)\n        } else if (index == this.sz) {\n            this.addAtTail(val)\n        } else {\n            const node = new TNode(val), cur = this.getNode(index)\n            node.next = cur; node.prev = cur.prev\n            cur.prev.next = node; cur.prev = node\n            this.sz++\n        }\n    }\n    deleteAtIndex(index: number): void {\n        const cur = this.getNode(index)\n        if (cur == null) return \n        cur.prev.next = cur.next\n        cur.next.prev = cur.prev\n        this.sz--\n    }\n    getNode(index: number): TNode | null {\n        const isLeft = index < this.sz / 2\n        if (!isLeft) index = this.sz - index - 1\n        for (let cur = isLeft ? this.he.next : this.ta.prev; cur != this.ta && cur != this.he; cur = isLeft ? cur.next : cur.prev) {\n            if (index-- == 0) return cur\n        }\n        return null\n    }\n}\n```\nPython 代码:\n```Python\nclass Node:\n    def __init__(self, _val):\n        self.val = _val\n        self.prev = None\n        self.next = None\n\nclass MyLinkedList:\n    def __init__(self):\n        self.he = Node(-1)\n        self.ta = Node(-1)\n        self.he.next = self.ta\n        self.ta.prev = self.he\n        self.sz = 0\n\n    def get(self, index: int) -> int:\n        node = self.getNode(index)\n        return node.val if node else -1\n\n    def addAtHead(self, val: int) -> None:\n        node = Node(val)\n        node.next = self.he.next\n        node.prev = self.he\n        self.he.next.prev = node\n        self.he.next = node\n        self.sz += 1\n\n    def addAtTail(self, val: int) -> None:\n        node = Node(val)\n        node.prev = self.ta.prev\n        node.next = self.ta\n        self.ta.prev.next = node\n        self.ta.prev = node\n        self.sz += 1\n\n    def addAtIndex(self, index: int, val: int) -> None:\n        if index > self.sz:\n            return \n        if index <= 0:\n            self.addAtHead(val)\n        elif index == self.sz:\n            self.addAtTail(val)\n        else:\n            node, cur = Node(val), self.getNode(index)\n            node.next = cur\n            node.prev = cur.prev\n            cur.prev.next = node\n            cur.prev = node\n            self.sz += 1\n\n    def deleteAtIndex(self, index: int) -> None:\n        node = self.getNode(index)\n        if node:\n            node.prev.next = node.next\n            node.next.prev = node.prev\n            self.sz -= 1\n\n    def getNode(self, index: int) -> Node | None:\n        isLeft = index < self.sz / 2\n        if not isLeft:\n            index = self.sz - index - 1\n        cur = self.he.next if isLeft else self.ta.prev\n        while cur != self.he and cur != self.ta:\n            if index == 0:\n                return cur\n            index -= 1\n            cur = cur.next if isLeft else cur.prev\n        return None\n```\n* 时间复杂度:涉及 `index` 的相关操作复杂度为 $O(index)$;其余操作均为 $O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.707` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/701-710/709. 转换成小写字母（简单）.md", "url_title": "709. 转换成小写字母", "url": "https://leetcode-cn.com/problems/to-lower-case/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-czpo/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个字符串 `s` ,将该字符串中的大写字母转换成相同的小写字母,返回新的字符串。\n\n示例 1:\n```\n输入:s = \"Hello\"\n\n输出:\"hello\"\n```\n示例 2:\n```\n输入:s = \"here\"\n\n输出:\"here\"\n```\n示例 3:\n```\n输入:s = \"LOVELY\"\n\n输出:\"lovely\"\n```\n\n提示:\n* `1 <= s.length <= 100`\n* `s` 由 `ASCII` 字符集中的可打印字符组成", "solution": "### 模拟\n\n根据题意进行模拟。\n\n代码:\n```Java\nclass Solution {\n    public String toLowerCase(String s) {\n        return s.toLowerCase();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.709` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/701-710/710. 黑名单中的随机数（困难）.md", "url_title": "710. 黑名单中的随机数", "url": "https://leetcode.cn/problems/random-pick-with-blacklist/solution/by-ac_oier-2rww/", "difficulty": "困难", "tags": ["前缀和", "二分", "离散化", "随机化", "哈希表"], "question": "给定一个整数 `n` 和一个 无重复 黑名单整数数组 `blacklist`。\n\n设计一种算法,从 $[0, n - 1]$ 范围内的任意整数中选取一个 未加入 黑名单 `blacklist` 的整数。任何在上述范围内且不在黑名单 `blacklist` 中的整数都应该有 同等的可能性 被返回。\n\n优化你的算法,使它最小化调用语言 内置 随机函数的次数。\n\n实现 `Solution` 类:\n* `Solution(int n, int[] blacklist)` 初始化整数 `n` 和被加入黑名单 `blacklist` 的整数\n* `int pick()` 返回一个范围为 $[0, n - 1]$ 且不在黑名单 `blacklist` 中的随机整数\n\n示例 1:\n```\n输入\n[\"Solution\", \"pick\", \"pick\", \"pick\", \"pick\", \"pick\", \"pick\", \"pick\"]\n[[7, [2, 3, 5]], [], [], [], [], [], [], []]\n\n输出\n[null, 0, 4, 1, 6, 1, 0, 4]\n\n解释\nSolution solution = new Solution(7, [2, 3, 5]);\nsolution.pick(); // 返回0,任何[0,1,4,6]的整数都可以。注意,对于每一个pick的调用,\n                 // 0、1、4和6的返回概率必须相等(即概率为1/4)。\nsolution.pick(); // 返回 4\nsolution.pick(); // 返回 1\nsolution.pick(); // 返回 6\nsolution.pick(); // 返回 1\nsolution.pick(); // 返回 0\nsolution.pick(); // 返回 4\n```\n\n提示:\n* $1 <= n <= 10^9$\n* $0 <= blacklist.length <= \\min(1065, n - 1)$\n* $0 <= blacklist[i] < n$\n* `blacklist` 中所有值都 不同\n*  `pick` 最多被调用 $2 \\times 10^4$ 次", "solution": "### 前缀和 + 二分\n\n为了方便,我们记 `blacklist` 为 `bs`,将其长度记为 `m`。\n\n问题本质是让我们从 $[0, n - 1]$ 范围内随机一个数,这数不能在 `bs` 里面。\n\n由于 $n$ 的范围是 $1e9$,我们不能在对范围在 $[0, n - 1]$ 且不在 `bs` 中的点集进行离散化,因为离散化后的点集大小仍很大。\n\n同时 $m$ 的范围是 $1e5$,我们也不能使用普通的拒绝采样做法,这样单次 `pick` 被拒绝的次数可能很大。\n\n一个简单且绝对正确的做法是:**我们不对「点」做离散化,而利用 `bs` 数据范围为 $1e5$,来对「线段」做离散化**。\n\n具体的,我们先对 `bs` 进行排序,然后从前往后处理所有的 $bs[i]$,将相邻 $bs[i]$ 之间的能被选择的「线段」以二元组 $(a, b)$ 的形式进行记录(即一般情况下的 $a = bs[i - 1] + 1$,$b = bs[i] - 1$),存入数组 `list` 中(注意特殊处理一下两端的线段)。\n\n当处理完所有的 $bs[i]$ 后,我们得到了所有可被选择线段,同时对于每个线段可直接算得其所包含的整数点数。\n\n我们可以对 `list` 数组做一遍「线段所包含点数」的「前缀和」操作,得到 `sum` 数组,同时得到所有线段所包含的总点数(前缀和数组的最后一位)。\n\n对于 `pick` 操作而言,我们先在 $[1, tot]$ 范围进行随机(其中 $tot$ 代表总点数),假设取得的随机值为 $val$,然后在前缀和数组中进行二分,找到第一个满足「值大于等于 $val$」的位置(含义为找到这个点所在的线段),然后再利用该线段的左右端点的值,取出对应的点。\n\n代码:\n```Java\nclass Solution {\n    List<int[]> list = new ArrayList<>();\n    int[] sum = new int[100010];\n    int sz;\n    Random random = new Random();\n    public Solution(int n, int[] bs) {\n        Arrays.sort(bs);\n        int m = bs.length;\n        if (m == 0) {\n            list.add(new int[]{0, n - 1});\n        } else {\n            if (bs[0] != 0) list.add(new int[]{0, bs[0] - 1});\n            for (int i = 1; i < m; i++) {\n                if (bs[i - 1] == bs[i] - 1) continue;\n                list.add(new int[]{bs[i - 1] + 1, bs[i] - 1});\n            }\n            if (bs[m - 1] != n - 1) list.add(new int[]{bs[m - 1] + 1, n - 1});\n        }\n        sz = list.size();\n        for (int i = 1; i <= sz; i++) {\n            int[] info = list.get(i - 1);\n            sum[i] = sum[i - 1] + info[1] - info[0] + 1;\n        }\n    }\n    public int pick() {\n        int val = random.nextInt(sum[sz]) + 1;\n        int l = 1, r = sz;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (sum[mid] >= val) r = mid;\n            else l = mid + 1;\n        }\n        int[] info = list.get(r - 1);\n        int a = info[0], b = info[1], end = sum[r];\n        return b - (end - val);\n    }\n}\n```\n* 时间复杂度:在初始化操作中:对 `bs` 进行排序复杂度为 $O(m\\log{m})$;统计所有线段复杂度为 $O(m)$;对所有线段求前缀和复杂度为 $O(m)$。在 `pick` 操作中:随机后会对所有线段做二分,复杂度为 $O(\\log{m})$\n* 空间复杂度:$O(m)$\n\n---\n\n### 哈希表 \n\n总共有 $n$ 个数,其中 $m$ 个数不可被选,即真实可选个数为 $n - m$ 个。\n\n为了能够在 $[0, n - m)$ 连续段内进行随机,我们可以将 $[0, n - m)$ 内不可被选的数映射到 $[n - m, n - 1]$ 内可选的数上。\n\n具体的,我们可以使用两个 `Set` 结构 `s1` 和 `s2` 分别记录在 $[0, n - m)$ 和 $[n - m, n - 1]$ 范围内的黑名单数字。\n\n在 `pick` 操作时,我们在 $[0, n - m)$ 范围内进行随机,根据随机值 $val$ 是否为黑名单内数字(是否在 `s1` 中)进行分情况讨论:\n\n* 随机值 `val` 不在 `s1` 中,说明 `val` 是真实可选的数值,直接返回;\n* 随机值 `val` 在 `s1` 中,说明 `val` 是黑名单内的数值,我们先查询是否已存在 `val` 的映射记录,若已存在直接返回其映射值;否则需要在 $[n - m, n - 1]$ 内找到一个可替代它的数值,我们可以使用一个变量 `idx` 在 $[n- m, n - 1]$ 范围内从前往后扫描,找到第一个未被使用的,同时不在 `s2` 中(不在黑名单内)的数字,假设找到的值为 `x`,将 `x` 进行返回(同时将 `val` 与 `x` 的映射关系,用哈希表进行记录)。\n\n代码:\n```Java \nclass Solution {\n    int n, m, idx;\n    Random random = new Random();\n    Set<Integer> s1 = new HashSet<>(), s2 = new HashSet<>();\n    Map<Integer, Integer> map = new HashMap<>();\n    public Solution(int _n, int[] bs) {\n        n = _n; m = bs.length;\n        int max = n - m;\n        for (int x : bs) {\n            if (x < max) s1.add(x);\n            else s2.add(x);\n        }\n        idx = n - m;\n    }\n    public int pick() {\n        int val = random.nextInt(n - m);\n        if (!s1.contains(val)) return val;\n        if (!map.containsKey(val)) {\n            while (s2.contains(idx)) idx++;\n            map.put(val, idx++);\n        }\n        return map.get(val);\n    }\n}\n```\n* 时间复杂度:初始化操作复杂度为 $O(m)$,`pick` 操作复杂度为 $O(1)$\n* 空间复杂度:$O(m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.710` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/71-80/71. 简化路径（中等）.md", "url_title": "71. 简化路径", "url": "https://leetcode-cn.com/problems/simplify-path/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-w7xi/", "difficulty": "中等", "tags": ["模拟", "栈"], "question": "给你一个字符串 `path`,表示指向某一文件或目录的 `Unix` 风格 绝对路径 (以 `'/'` 开头),请你将其转化为更加简洁的规范路径。\n\n在 `Unix` 风格的文件系统中,一个点(`.`)表示当前目录本身;此外,两个点 (`..`) 表示将目录切换到上一级(指向父目录);两者都可以是复杂相对路径的组成部分。任意多个连续的斜杠(即,`'//'`)都被视为单个斜杠 `'/'` 。 对于此问题,任何其他格式的点(例如,`'...'`)均被视为文件`/`目录名称。\n\n请注意,返回的 规范路径 必须遵循下述格式:\n\n* 始终以斜杠 `'/'` 开头。\n* 两个目录名之间必须只有一个斜杠 `'/'` 。\n* 最后一个目录名(如果存在)不能 以 `'/'` 结尾。\n* 此外,路径仅包含从根目录到目标文件或目录的路径上的目录(即,不含 '`.'` 或 `'..'`)。\n\n返回简化后得到的 **规范路径**。\n\n示例 1:\n```\n输入:path = \"/home/\"\n\n输出:\"/home\"\n\n解释:注意,最后一个目录名后面没有斜杠。 \n```\n示例 2:\n```\n输入:path = \"/../\"\n\n输出:\"/\"\n\n解释:从根目录向上一级是不可行的,因为根目录是你可以到达的最高级。\n```\n示例 3:\n```\n输入:path = \"/home//foo/\"\n\n输出:\"/home/foo\"\n\n解释:在规范路径中,多个连续斜杠需要用一个斜杠替换。\n```\n示例 4:\n```\n输入:path = \"/a/./b/../../c/\"\n\n输出:\"/c\"\n```\n\n提示:\n* $1 <= path.length <= 3000$\n* `path` 由英文字母,数字,`'.'`,`'/'` 或 `'_'` 组成。\n* `path` 是一个有效的 `Unix` 风格绝对路径。", "solution": "### 模拟\n\n根据题意,使用栈进行模拟即可。\n\n具体的,从前往后处理 `path`,每次以 `item` 为单位进行处理(有效的文件名),根据 `item` 为何值进行分情况讨论:\n\n* `item` 为有效值 :存入栈中;\n* `item` 为 `..` :弹出栈顶元素(若存在);\n* `item` 为 `.` :不作处理。\n\n代码:\n```Java\nclass Solution {\n    public String simplifyPath(String path) {\n        Deque<String> d = new ArrayDeque<>();\n        int n = path.length();\n        for (int i = 1; i < n; ) {\n            if (path.charAt(i) == '/' && ++i >= 0) continue;\n            int j = i + 1;\n            while (j < n && path.charAt(j) != '/') j++;\n            String item = path.substring(i, j);\n            if (item.equals(\"..\")) {\n                if (!d.isEmpty()) d.pollLast();\n            } else if (!item.equals(\".\")) {\n                d.addLast(item);\n            }\n            i = j;\n        }\n        StringBuilder sb = new StringBuilder();\n        while (!d.isEmpty()) sb.append(\"/\" + d.pollFirst());\n        return sb.length() == 0 ? \"/\" : sb.toString();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.71` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/71-80/73. 矩阵置零（中等）.md", "url_title": "73. 矩阵置零", "url": "https://leetcode-cn.com/problems/set-matrix-zeroes/solution/xiang-jie-fen-san-bu-de-o1-kong-jian-jie-dbxd/", "difficulty": "中等", "tags": ["模拟"], "question": "给定一个 $m \\times n$ 的矩阵,如果一个元素为 $0$ ,则将其所在行和列的所有元素都设为 $0$ 。\n\n请使用「原地」算法。\n\n进阶:\n* 一个直观的解决方案是使用  $O(m \\times n)$ 的额外空间,但这并不是一个好的解决方案。\n* 一个简单的改进方案是使用 $O(m + n)$ 的额外空间,但这仍然不是最好的解决方案。\n* 你能想出一个仅使用常量空间的解决方案吗?\n\n示例 1:\n\n```\n输入:matrix = [[1,1,1],[1,0,1],[1,1,1]]\n\n输出:[[1,0,1],[0,0,0],[1,0,1]]\n```\n示例 2:\n\n```\n输入:matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]\n\n输出:[[0,0,0,0],[0,4,5,0],[0,3,1,0]]\n```\n\n提示:\n* $m == matrix.length$\n* $n == matrix[0].length$\n* $1 <= m, n <= 200$\n* $-2^{31} <= matrix[i][j] <= 2^{31} - 1$", "solution": "### 前言\n\n由于 $O(m \\times n)$ 和 $O(m+n)$ 空间的解法都十分简单,无非是「同等大小的矩阵」或「与行列数量相等的标识」来记录置零信息。\n\n这里着重讲解利用原矩阵的 $O(1)$ 空间解法。\n\n---\n\n### O(1) 空间\n\n**1. 使用两个变量(r0 & c0),记录「首行 & 首列」是否该被置零**\n\n**2.「非首行首列」的位置**\n* 将置零信息存储到原矩阵\n* 根据置零信息,置零「非首行首列」的位置\n\n**3. 使用 r0 & c0 ,置零「首行 & 首列」**\n\n代码:\n```Java\nclass Solution {\n    public void setZeroes(int[][] mat) {\n        int m = mat.length, n = mat[0].length;\n        // 1. 扫描「首行」和「首列」记录「首行」和「首列」是否该被置零\n        boolean r0 = false, c0 = false;\n        for (int i = 0; i < m; i++) {\n            if (mat[i][0] == 0) {\n                r0 = true;\n                break;\n            }\n        }\n        for (int j = 0; j < n; j++) {\n            if (mat[0][j] == 0) {\n                c0 = true;\n                break;\n            }\n        }\n        // 2.1 扫描「非首行首列」的位置,如果发现零,将需要置零的信息存储到该行的「最左方」和「最上方」的格子内\n        for (int i = 1; i < m; i++) {\n            for (int j = 1; j < n; j++) {\n                if (mat[i][j] == 0) mat[i][0] = mat[0][j] = 0;\n            }\n        }\n        // 2.2 根据刚刚记录在「最左方」和「最上方」格子内的置零信息,进行「非首行首列」置零\n        for (int j = 1; j < n; j++) {\n            if (mat[0][j] == 0) {\n                for (int i = 1; i < m; i++) mat[i][j] = 0;\n            }\n        }\n        for (int i = 1; i < m; i++) {\n            if (mat[i][0] == 0) Arrays.fill(mat[i], 0);\n        }\n        // 3. 根据最开始记录的「首行」和「首列」信息,进行「首行首列」置零\n        if (r0) for (int i = 0; i < m; i++) mat[i][0] = 0;\n        if (c0) Arrays.fill(mat[0], 0);\n    }\n}\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.73` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/71-80/74. 搜索二维矩阵（中等）.md", "url_title": "74. 搜索二维矩阵", "url": "https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/", "difficulty": "中等", "tags": ["二叉搜索树", "二分"], "question": "编写一个高效的算法来判断 m x n 矩阵中,是否存在一个目标值。该矩阵具有如下特性:\n\n每行中的整数从左到右按升序排列。\n每行的第一个整数大于前一行的最后一个整数。\n\n示例 1:\n\n```\n输入:matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3\n\n输出:true\n```\n示例 2:\n\n```\n输入:matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13\n\n输出:false\n```\n\n提示:\n* m == matrix.length\n* n == matrix[i].length\n* 1 <= m, n <= 100\n* -$10^4$ <= matrix[i][j], target <= $10^4$", "solution": "### 二分解法(一)\n\n由于二维矩阵固定列的「从上到下」或者固定行的「从左到右」都是升序的。\n\n因此我们可以使用两次二分来定位到目标位置:\n\n1. 第一次二分:从第 0 列中的「所有行」开始找,找到合适的行 `row`\n\n2. 第二次二分:从 `row` 中「所有列」开始找,找到合适的列 `col`\n\n代码:\n```Java\nclass Solution {\n    public boolean searchMatrix(int[][] mat, int t) {\n        int m = mat.length, n = mat[0].length;\n\n        // 第一次二分:定位到所在行(从上往下,找到最后一个满足 mat[x]][0] <= t 的行号)\n        int l = 0, r = m - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (mat[mid][0] <= t) {\n                l = mid;\n            } else {\n                r = mid - 1;\n            }\n        }\n\n        int row = r;\n        if (mat[row][0] == t) return true;\n        if (mat[row][0] > t) return false;\n\n        // 第二次二分:从所在行中定位到列(从左到右,找到最后一个满足 mat[row][x] <= t 的列号)\n        l = 0; r = n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (mat[row][mid] <= t) {\n                l = mid;\n            } else {\n                r = mid - 1;\n            }\n        }\n        int col = r;\n\n        return mat[row][col] == t;\n    }\n}\n```\n* 时间复杂度:$O(\\log{m} + \\log{n})$\n* 空间复杂度:$O(1)$\n\n***\n\n### 二分解法(二)\n\n当然,因为将二维矩阵的行尾和行首连接,也具有单调性。\n\n我们可以将「二维矩阵」当做「一维矩阵」来做。\n\n代码:\n```Java\nclass Solution {\n    public boolean searchMatrix(int[][] mat, int t) {\n        int m = mat.length, n = mat[0].length;\n        int l = 0, r = m * n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (mat[mid / n][mid % n] <= t) {\n                l = mid;\n            } else {\n                r = mid - 1;\n            }\n        }\n        return mat[r / n][r % n] == t;\n    }\n}\n```\n* 时间复杂度:$O(\\log{(m * n)})$\n* 空间复杂度:$O(1)$\n\n***\n\n### 抽象 BST 解法\n\n我们可以将二维矩阵抽象成「以右上角为根的 BST」:\n\n那么我们可以从根(右上角)开始搜索,如果当前的节点不等于目标值,可以按照树的搜索顺序进行:\n\n1. 当前节点「大于」目标值,搜索当前节点的「左子树」,也就是当前矩阵位置的「左方格子」,即 y--\n2. 当前节点「小于」目标值,搜索当前节点的「右子树」,也就是当前矩阵位置的「下方格子」,即 x++\n\n代码:\n```Java\nclass Solution {\n    int m, n;\n    public boolean searchMatrix(int[][] mat, int t) {\n        m = mat.length; n = mat[0].length;\n        int x = 0, y = n - 1;\n        while (check(x, y) && mat[x][y] != t) {\n            if (mat[x][y] > t) {\n                y--;\n            } else {\n                x++;\n            }\n        }\n        return check(x, y) && mat[x][y] == t;\n    }\n    boolean check(int x, int y) {\n        return x >= 0 && x < m && y >= 0 && y < n;\n    }\n}\n```\n* 时间复杂度:$O(m+n)$\n* 空间复杂度:$O(1)$\n\n***\n\n### 拓展\n\n如果你掌握了上述解法的话,你还可以试试这题:\n\n[240. 搜索二维矩阵 II](https://leetcode-cn.com/problems/search-a-2d-matrix-ii/)", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.74` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/71-80/75. 颜色分类（中等）.md", "url_title": "75. 颜色分类", "url": "https://leetcode.cn/problems/sort-colors/solution/by-ac_oier-7lwk/", "difficulty": "中等", "tags": ["排序", "双指针"], "question": "给定一个包含红色、白色和蓝色、共 `n` 个元素的数组 `nums`,原地对它们进行排序,使得相同颜色的元素相邻,并按照红色、白色、蓝色顺序排列。\n\n我们使用整数 `0`、 `1` 和 `2` 分别表示红色、白色和蓝色。\n\n必须在不使用库的 `sort` 函数的情况下解决这个问题。\n\n示例 1:\n```\n输入:nums = [2,0,2,1,1,0]\n\n输出:[0,0,1,1,2,2]\n```\n示例 2:\n```\n输入:nums = [2,0,1]\n\n输出:[0,1,2]\n```\n\n提示:\n* $n = nums.length$\n* $1 <= n <= 300$\n* `nums[i]` 为 `0`、`1` 或 `2`\n\n进阶:\n* 你可以不使用代码库中的排序函数来解决这道题吗?\n* 你能想出一个仅使用常数空间的一趟扫描算法吗?", "solution": "### 双指针\n\n该题为经典的荷兰国旗问题,由于题目本质是要我们将数分成三段。\n\n因此除了使用一个变量 `idx` 代指处理到哪一个 $nums[i]$ 以外,至少还需要两个变量来代指三段的边界:\n\n* 变量 `l` 为下一个填入 `0` 的位置(因此范围 $[0, l - 1]$ 均为 `0`,初始化 $l = 0$,代表空集)\n* 变量 `r` 为下一个填入 `2` 的位置(因此范围 $[r + 1, n - 1]$ 均为 `2`,初始化 $r = n - 1$,代表空集)\n\n由于 $[0, idx - 1]$ 均为处理过的数值(即 `0` 和 `2` 必然都被分到了两端),同时 $l - 1$ 又是 `0` 的右边界,因此 $[l, idx - 1]$ 为 `1` 的区间,而 $[idx, r]$ 为未处理的数值。\n\n上述几个变量的定义是该题唯一需要理清的地方。\n\n不失一般性,根据当前处理到的 $nums[idx]$ 进行分情况讨论:\n\n* $nums[idx] = 0$:此时将其与位置 `l` 进行互换(记住 `l` 为下一个待填入 `0` 的位置,同时 $[l, idx - 1]$ 为 `1` 的区间),本质是将 $nums[idx]$ 的 `0` 和 $nums[l]$ 的 `1` 进行互换,因此互换后将 `l` 和 `idx` 进行右移;\n* $nums[idx] = 1$:由于 $[l, idx - 1]$ 本身就是 `1` 的区间,直接将 `idx` 进行右移即可;\n* $nums[idx] = 2$:此时将其与位置 `r` 进行互换(`r` 为下一个待填入 `2` 的位置,但 $[idx, r]$ 为未处理区间),也就是我们互换后,只能明确换到位置 $nums[r]$ 的位置为 `2`,可以对 `r` 进行左移,但不确定新 $nums[idx]$ 为何值,因此保持 `idx` 不变再入循环判断。\n\n最后当 $idx > r$(含义为未处理区间为空集),整个分三段过程结束。\n\nJava 代码:\n```Java\nclass Solution {\n    public void sortColors(int[] nums) {\n        int n = nums.length;\n        int l = 0, r = n - 1, idx = 0;\n        while (idx <= r) {\n            if (nums[idx] == 0) swap(nums, l++, idx++);\n            else if (nums[idx] == 1) idx++;\n            else swap(nums, idx, r--);\n        }\n    }\n    void swap(int[] nums, int i, int j) {\n        int c = nums[i];\n        nums[i] = nums[j];\n        nums[j] = c;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction sortColors(nums: number[]): void {\n    const n = nums.length\n    let l = 0, r = n - 1, idx = 0\n    while (idx <= r) {\n        if (nums[idx] == 0) swap(nums, l++, idx++)\n        else if (nums[idx] == 1) idx++\n        else swap(nums, idx, r--)\n    }\n}\nfunction swap(nums: number[], i: number, j: number): void {\n    const c = nums[i]\n    nums[i] = nums[j]\n    nums[j] = c\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def sortColors(self, nums: List[int]) -> None:\n        n = len(nums)\n        l, r, idx = 0, n - 1, 0\n        while idx <= r:\n            if nums[idx] == 0:\n                nums[l], nums[idx] = nums[idx], nums[l]\n                l += 1\n                idx += 1\n            elif nums[idx] == 1:\n                idx += 1\n            else:\n                nums[r], nums[idx] = nums[idx], nums[r]\n                r -= 1\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.75` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/71-80/76. 最小覆盖子串（困难）.md", "url_title": "76. 最小覆盖子串", "url": "https://leetcode.cn/problems/minimum-window-substring/solutions/2384313/gong-shui-san-xie-hua-dong-chuang-kou-ji-14q9/", "difficulty": "困难", "tags": ["双指针", "滑动窗口"], "question": "给你一个字符串 `s`、一个字符串 `t`。返回 `s` 中涵盖 `t` 所有字符的最小子串。\n\n如果 `s` 中不存在涵盖 `t` 所有字符的子串,则返回空字符串 `\"\"`。\n\n注意:\n* 对于 `t` 中重复字符,我们寻找的子字符串中该字符数量必须不少于 `t` 中该字符数量。\n* 如果 `s` 中存在这样的子串,我们保证它是唯一的答案。\n\n示例 1:\n```\n输入:s = \"ADOBECODEBANC\", t = \"ABC\"\n\n输出:\"BANC\"\n\n解释:最小覆盖子串 \"BANC\" 包含来自字符串 t 的 'A'、'B' 和 'C'。\n```\n示例 2:\n```\n输入:s = \"a\", t = \"a\"\n\n输出:\"a\"\n\n解释:整个字符串 s 是最小覆盖子串。\n```\n示例 3:\n```\n输入: s = \"a\", t = \"aa\"\n\n输出: \"\"\n\n解释: t 中两个字符 'a' 均应包含在 s 的子串中,\n因此没有符合条件的子字符串,返回空字符串。\n```\n\n提示:\n* `m == s.length`\n* `n == t.length`\n* $1 <= m, n <= 10^5$\n* `s` 和 `t` 由英文字母组成\n\n进阶:你能设计一个在 $O(m+n)$ 时间内解决此问题的算法吗?", "solution": "### 滑动窗口\n\n定义两个长度为 $60$(足够存下所有字母种类)的数组 `c1` 和 `c2`,用于存储字符频率。其中 `c1` 用于记录字符串 `t` 中字符的频率,`c2` 用于记录当前滑动窗口内字符的频率。\n\n设定好字母与频率数组下标的映射关系:小写字母 `a-z` 对应下标 `0-25`,大写字母 `A-Z` 对应下标 `26-51`。\n\n使用变量 `tot` 来记录还需要匹配的字符种类数,当 `tot = 0` 代表当前滑动窗口对应的子串能够实现对 `t` 的覆盖,即任意字符满足 $c2[i] \\geq c1[i]$。\n\n使用双指针 `j` 和 `i` 表示滑动窗口的左右边界。从前往后遍历字符串 `s`,在每个位置上更新字符频率数组 `c2`。若 `c2` 中字符的频率达到了 `c1` 中的字符频率,则将 `tot` 减 1,表示一个字符已经匹配完成。\n\n每当右边界往后移动一步之后,滑动窗口会增加一个字符。此时我们检查左边界能否右移,同时不会使得 `tot` 变大。即每次右边界右移后,我们检查左边界 $c2[j] > c1[j]$ 是否满足:\n\n* 若满足:说明当前左边界指向字符并非必须,当前子串 $s[j...i]$ 必然不是最短子串。我们让左边界 `j` 进行右移,并重复进行左边界 $c2[j] > c1[j]$ 的检查,直到窗口不能再收缩\n* 若不满足:说明当前窗口没有任何一个后缀字符串能够实现对 `t` 的覆盖,我们并不能对窗口实现收缩\n\n每次对窗口移动完成后,我们检查当前 `tot` 是否为 $0$(对字符串 `t` 的覆盖是否完成),若为 $0$ 则尝试用当前窗口对应的字符串 $s[j...i]$ 更新 `ans`。\n\nJava 代码:\n```Java\nclass Solution {\n    public String minWindow(String s, String t) {\n        int n = s.length(), tot = 0;\n        int[] c1 = new int[60], c2 = new int[60];\n        for (char x : t.toCharArray()) {\n            if (++c1[getIdx(x)] == 1) tot++;\n        }\n        String ans = \"\";\n        for (int i = 0, j = 0; i < n; i++) {\n            int idx1 = getIdx(s.charAt(i));\n            if (++c2[idx1] == c1[idx1]) tot--;\n            while (j < i) {\n                int idx2 = getIdx(s.charAt(j));\n                if (c2[idx2] > c1[idx2] && --c2[idx2] >= 0) j++;\n                else break;\n            }\n            if (tot == 0 && (ans.length() == 0 || ans.length() > i - j + 1)) ans = s.substring(j, i + 1);\n        }\n        return ans;\n    }\n    int getIdx(char x) {\n        return x >= 'A' && x <= 'Z' ? x - 'A' + 26 : x - 'a';\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    string minWindow(string s, string t) {\n        int n = s.length(), tot = 0;\n        vector<int> c1(60), c2(60);\n        for (char x : t) {\n            if (++c1[getIdx(x)] == 1) tot++;\n        }\n        string ans = \"\";\n        for (int i = 0, j = 0; i < n; i++) {\n            int idx1 = getIdx(s[i]);\n            if (++c2[idx1] == c1[idx1]) tot--;\n            while (j < i) {\n                int idx2 = getIdx(s[j]);\n                if (c2[idx2] > c1[idx2] && --c2[idx2] >= 0) j++;\n                else break;\n            }\n            if (tot == 0 && (ans.empty() || ans.length() > i - j + 1)) ans = s.substr(j, i - j + 1);\n        }\n        return ans;\n    }\n    int getIdx(char x) {\n        return x >= 'A' && x <= 'Z' ? x - 'A' + 26 : x - 'a';\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minWindow(self, s: str, t: str) -> str:\n        def getIdx(x):\n            return ord(x) - ord('A') + 26 if 'A' <= x <= 'Z' else ord(x) - ord('a')\n\n        n, tot = len(s), 0\n        c1, c2 = [0] * 60, [0] * 60\n        for x in t:\n            idx = getIdx(x)\n            c1[idx] += 1\n            if c1[idx] == 1:\n                tot += 1\n        ans = \"\"\n        j = 0\n        for i in range(n):\n            idx1 = getIdx(s[i])\n            c2[idx1] += 1\n            if c2[idx1] == c1[idx1]:\n                tot -= 1\n            while j < i:\n                idx2 = getIdx(s[j])\n                if c2[idx2] > c1[idx2]:\n                    j += 1\n                    c2[idx2] -= 1\n                else:\n                    break\n            if tot == 0 and (not ans or len(ans) > i - j + 1):\n                ans = s[j:i + 1]\n        return ans\n```\nTypeScript 代码:\n```TypeScript \nfunction minWindow(s: string, t: string): string {\n    let n = s.length, tot = 0;\n    const c1 = Array(60).fill(0), c2 = Array(60).fill(0);\n    for (const x of t) {\n        if (++c1[getIdx(x)] === 1) tot++;\n    }\n    let ans = \"\";\n    for (let i = 0, j = 0; i < n; i++) {\n        const idx1 = getIdx(s[i]);\n        if (++c2[idx1] == c1[idx1]) tot--;\n        while (j < i) {\n            const idx2 = getIdx(s[j]);\n            if (c2[idx2] > c1[idx2] && --c2[idx2] >= 0) j++;\n            else break;\n        }\n        if (tot == 0 && (!ans || ans.length > i - j + 1)) ans = s.substring(j, i + 1);\n    }\n    return ans;\n}\nfunction getIdx(x: string): number {\n    return x >= 'A' && x <= 'Z' ? x.charCodeAt(0) - 'A'.charCodeAt(0) + 26 : x.charCodeAt(0) - 'a'.charCodeAt(0);\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(C)$,其中 $C = 26 \\times 2$,为字符集大小", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.76` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/71-80/80. 删除有序数组中的重复项 II（中等）.md", "url_title": "80. 删除有序数组中的重复项 II", "url": "https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array-ii/solution/gong-shui-san-xie-guan-yu-shan-chu-you-x-glnq/", "difficulty": "中等", "tags": ["双指针"], "question": "给你一个有序数组 `nums` ,请你「原地」删除重复出现的元素,使每个元素 最多出现两次 ,返回删除后数组的新长度。\n\n不要使用额外的数组空间,你必须「原地」修改输入数组 并在使用 $O(1)$ 额外空间的条件下完成。\n\n说明:\n\n为什么返回数值是整数,但输出的答案是数组呢?\n\n请注意,输入数组是以「引用」方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。\n\n你可以想象内部操作如下:\n\n```\n// nums 是以“引用”方式传递的。也就是说,不对实参做任何拷贝\nint len = removeDuplicates(nums);\n\n// 在函数里修改输入数组对于调用者是可见的。\n// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。\nfor (int i = 0; i < len; i++) {\n    print(nums[i]);\n}\n```\n\n示例 1:\n```\n输入:nums = [1,1,1,2,2,3]\n\n输出:5, nums = [1,1,2,2,3]\n\n解释:函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。 不需要考虑数组中超出新长度后面的元素。\n```\n示例 2:\n```\n输入:nums = [0,0,1,1,1,1,2,3,3]\n\n输出:7, nums = [0,0,1,1,2,3,3]\n\n解释:函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。 不需要考虑数组中超出新长度后面的元素。\n```\n\n提示:\n\n* $1 <= nums.length <= 3 \\times 10^4$\n* $-10^4 <= nums[i] <= 10^4$\n* `nums` 已按升序排列", "solution": "### 通用解法\n\n为了让解法更具有一般性,我们将原问题的「保留 2 位」修改为「保留 k 位」。\n\n对于此类问题,我们应该进行如下考虑:\n\n* 由于是保留 `k` 个相同数字,**对于前 `k` 个数字,我们可以直接保留**\n* 对于后面的任意数字,能够保留的前提是:**与当前写入的位置前面的第 `k` 个元素进行比较,不相同则保留**\n\n举个🌰,我们令 `k=2`,假设有如下样例 $[1,1,1,1,1,1,2,2,2,2,2,2,3]$\n\n1. 首先我们先让前 2 位直接保留,得到 1,1\n2. 对后面的每一位进行继续遍历,能够保留的前提是与当前位置的前面 `k` 个元素不同(答案中的第一个 1),因此我们会跳过剩余的 1,将第一个 2 追加,得到 1,1,2\n3. 继续这个过程,这时候是和答案中的第 2 个 1 进行对比,因此可以得到 1,1,2,2\n4. 这时候和答案中的第 1 个 2 比较,只有与其不同的元素能追加到答案,因此剩余的 2 被跳过,3 被追加到答案:1,1,2,2,3\n\n代码:\n```Java\nclass Solution {\n    public int removeDuplicates(int[] nums) {   \n        return process(nums, 2);\n    }\n    int process(int[] nums, int k) {\n        int u = 0; \n        for (int x : nums) {\n            if (u < k || nums[u - k] != x) nums[u++] = x;\n        }\n        return u;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 其他\n\n**这是一种针对「数据有序,相同元素保留 `k` 位」问题更加本质的解法,该解法是从性质出发提炼的,利用了「数组有序 & 保留逻辑」两大主要性质。**\n\n当你掌握这种通解之后,要解决 [26. 删除有序数组中的重复项](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/) ,只需要改上述代码一个数字即可(将相同数字保留 2 个修改为保留 1 个)。\n\n这种通解最早我也在 [「双指针」&「通用」解法](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shua-chuan-lc-jian-ji-shuang-zhi-zhen-ji-2eg8/) 讲过。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.80` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/711-720/713. 乘积小于 K 的子数组（中等）.md", "url_title": "713. 乘积小于 K 的子数组", "url": "https://leetcode-cn.com/problems/subarray-product-less-than-k/solution/by-ac_oier-3w08/", "difficulty": "中等", "tags": ["滑动窗口", "双指针"], "question": "给你一个整数数组 `nums` 和一个整数 $k$ ,请你返回子数组内所有元素的乘积严格小于 $k$ 的连续子数组的数目。\n\n示例 1:\n```\n输入:nums = [10,5,2,6], k = 100\n\n输出:8\n\n解释:8 个乘积小于 100 的子数组分别为:[10]、[5]、[2],、[6]、[10,5]、[5,2]、[2,6]、[5,2,6]。\n需要注意的是 [10,5,2] 并不是乘积小于 100 的子数组。\n```\n示例 2:\n```\n输入:nums = [1,2,3], k = 0\n\n输出:0\n```\n\n提示: \n* $1 <= nums.length <= 3 \\times 10^4$\n* $1 <= nums[i] <= 1000$\n* $0 <= k <= 10^6$", "solution": "### 滑动窗口\n\n利用 $1 <= nums[i] <= 1000$,我们可以从前往后处理所有的 $nums[i]$,使用一个变量 $cur$ 记录当前窗口的乘积,使用两个变量 $j$ 和 $i$ 分别代表当前窗口的左右端点。\n\n当 $cur >= k$ 时,我们考虑将左端点 $j$ 右移,同时消除原来左端点元素 $nums[j]$ 对 $cur$ 的贡献,直到 $cur >= k$ 不再满足,这样我们就可以得到每个右端点 $nums[i]$ 的最远左端点 $nums[j]$,从而得知以 $nums[i]$ 为结尾的合法子数组个数为 $i - j + 1$。\n\nJava 代码:\n```Java \nclass Solution {\n    public int numSubarrayProductLessThanK(int[] nums, int k) {\n        int n = nums.length, ans = 0;\n        if (k <= 1) return 0;\n        for (int i = 0, j = 0, cur = 1; i < n; i++) {\n            cur *= nums[i];\n            while (cur >= k) cur /= nums[j++];\n            ans += i - j + 1;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction numSubarrayProductLessThanK(nums: number[], k: number): number {\n    let n = nums.length, ans = 0\n    if (k <= 1) return 0\n    for (let i = 0, j = 0, cur = 1; i < n; i++) {\n        cur *= nums[i]\n        while (cur >= k) cur /= nums[j++]\n        ans += i - j + 1\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.713` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/711-720/715. Range 模块（困难）.md", "url_title": "715. Range 模块", "url": "https://leetcode.cn/problems/range-module/solution/by-ac_oier-i4sw/", "difficulty": "困难", "tags": ["线段树", "线段树(动态开点)"], "question": "`Range` 模块是跟踪数字范围的模块。设计一个数据结构来跟踪表示为 半开区间 的范围并查询它们。\n\n半开区间 $[left, right)$ 表示所有 $left <= x < right$ 的实数 `x` 。\n\n实现 `RangeModule` 类:\n\n* `RangeModule()` 初始化数据结构的对象。\n* `void addRange(int left, int right)` 添加 半开区间 `[left, right)`,跟踪该区间中的每个实数。添加与当前跟踪的数字部分重叠的区间时,应当添加在区间 `[left, right)` 中尚未跟踪的任何数字到该区间中。\n* `boolean queryRange(int left, int right)` 只有在当前正在跟踪区间 `[left, right)` 中的每一个实数时,才返回 `true` ,否则返回 `false` 。\n* `void removeRange(int left, int right)` 停止跟踪 半开区间 `[left, right)` 中当前正在跟踪的每个实数。\n\n示例 1:\n```\n输入\n[\"RangeModule\", \"addRange\", \"removeRange\", \"queryRange\", \"queryRange\", \"queryRange\"]\n[[], [10, 20], [14, 16], [10, 14], [13, 15], [16, 17]]\n\n输出\n[null, null, null, true, false, true]\n\n解释\nRangeModule rangeModule = new RangeModule();\nrangeModule.addRange(10, 20);\nrangeModule.removeRange(14, 16);\nrangeModule.queryRange(10, 14); 返回 true (区间 [10, 14) 中的每个数都正在被跟踪)\nrangeModule.queryRange(13, 15); 返回 false(未跟踪区间 [13, 15) 中像 14, 14.03, 14.17 这样的数字)\nrangeModule.queryRange(16, 17); 返回 true (尽管执行了删除操作,区间 [16, 17) 中的数字 16 仍然会被跟踪)\n```\n\n提示:\n* $1 <= left < right <= 10^9$\n* 在单个测试用例中,对 `addRange`、 `queryRange` 和 `removeRange` 的调用总数不超过 $10^4$ 次", "solution": "### 基本分析\n\n线段树(动态开点)写过超多次了。\n\n令 $m$ 为 `addRange`、`queryRange` 和 `removeRange` 的调用总数,$n = 1e9$ 为值域大小。\n\n由于值域过大,我们无法直接使用空间大小固定为 $4 \\times n$ 的常规线段树,而要采用「动态开点」的方式,其中动态开点的方式有两种 :「需要进行估点的数组实现」和「无须估点的动态指针」。\n\n设计 `Node` 节点维护什么信息:\n\n* `ls` 和 `rs` 分别指向左右区间子节点(当采用「估点数组」方式时,记录的是左右区间子节点在线段树数组中的下标;在「动态指针」方式时,记录的是左右区间子节点对象);\n* `sum` 为记录当前区间有多少个整数被追踪;\n* `add` 为懒标记,当 `add = -1` 代表 `removeRange` 懒标记,当 `add = 1` 则代表 `addRange` 懒标记。\n\n---\n\n### 线段树(动态开点)- 数组估点\n\n对于常规的线段树实现来说,都是一开始就调用 `build` 操作创建空树,而线段树一般以「满二叉树」的形式用数组存储,因此需要 $4 \\times n$ 的空间,并且这些空间在起始 `build` 空树的时候已经锁死。\n\n如果一道题仅仅是「值域很大」的离线题(提前知晓所有的询问),我们还能通过「离散化」来进行处理,将值域映射到一个小空间去,从而解决 `MLE`  问题。\n\n但对于本题而言,由于「强制在线」的原因,我们无法进行「离散化」,同时值域大小达到 $1e9$ 级别,因此如果我们想要使用「线段树」进行求解,只能采取「动态开点」的方式进行。\n\n动态开点的优势在于,不需要事前构造空树,而是在插入操作 `add` 和查询操作 `query` 时根据访问需要进行「开点」操作。由于我们不保证查询和插入都是连续的,因此对于父节点 $u$ 而言,我们不能通过 `u << 1` 和 `u << 1  | 1` 的固定方式进行访问,而要将节点 $tr[u]$ 的左右节点所在 `tr` 数组的下标进行存储,分别记为 `ls` 和 `rs` 属性。对于 $tr[u].ls = 0$ 和 $tr[u].rs = 0$ 则是代表子节点尚未被创建,当需要访问到它们,而又尚未创建的时候,则将其进行创建。\n\n由于存在「懒标记」,线段树的插入和查询都是 $\\log{n}$ 的,因此我们在单次操作的时候,最多会创建数量级为 $\\log{n}$ 的点,因此空间复杂度为 $O(m\\log{n})$,而不是 $O(4 \\times n)$,而开点数的预估需不能仅仅根据 $\\log{n}$ 来进行,还要对常熟进行分析,才能得到准确的点数上界。\n\n动态开点相比于原始的线段树实现,本质仍是使用「满二叉树」的形式进行存储,只不过是按需创建区间,如果我们是按照连续段进行查询或插入,最坏情况下仍然会占到 $4 \\times n$ 的空间,因此盲猜 $\\log{n}$ 的常数在 $4$ 左右,保守一点可以直接估算到 $6$,因此我们可以估算点数为 $6 \\times m \\times \\log{n}$,其中 $n = 1e9$ 和 $m = 1e4$ 分别代表值域大小和查询次数。\n\n当然一个比较实用的估点方式可以「尽可能的多开点数」,利用题目给定的空间上界和我们创建的自定义类(结构体)的大小,尽可能的多开( `Java` 的 `128M` 可以开到 $5 \\times 10^6$ 以上)。\n\n代码:\n```Java\nclass RangeModule {\n    class Node {\n        int ls, rs, sum, add;\n    }\n    int N = (int)1e9 + 10, M = 500010, cnt = 1;\n    Node[] tr = new Node[M];\n    void update(int u, int lc, int rc, int l, int r, int v) {\n        int len = rc - lc + 1;\n        if (l <= lc && rc <= r) {\n            tr[u].sum = v == 1 ? len : 0;\n            tr[u].add = v;\n            return ;\n        }\n        pushdown(u, len);\n        int mid = lc + rc >> 1;\n        if (l <= mid) update(tr[u].ls, lc, mid, l, r, v);\n        if (r > mid) update(tr[u].rs, mid + 1, rc, l, r, v);\n        pushup(u);\n    }\n    int query(int u, int lc, int rc, int l, int r) {\n        if (l <= lc && rc <= r) return tr[u].sum;\n        pushdown(u, rc - lc + 1);\n        int mid = lc + rc >> 1, ans = 0;\n        if (l <= mid) ans = query(tr[u].ls, lc, mid, l, r);\n        if (r > mid) ans += query(tr[u].rs, mid + 1, rc, l, r);\n        return ans;\n    }\n    void pushdown(int u, int len) {\n        if (tr[u] == null) tr[u] = new Node();\n        if (tr[u].ls == 0) {\n            tr[u].ls = ++cnt;\n            tr[tr[u].ls] = new Node();\n        }\n        if (tr[u].rs == 0) {\n            tr[u].rs = ++cnt;\n            tr[tr[u].rs] = new Node();\n        }\n        if (tr[u].add == 0) return;\n        if (tr[u].add == -1) {\n            tr[tr[u].ls].sum = tr[tr[u].rs].sum = 0;\n        } else {\n            tr[tr[u].ls].sum = len - len / 2;\n            tr[tr[u].rs].sum = len / 2;\n        }\n        tr[tr[u].ls].add = tr[tr[u].rs].add = tr[u].add;\n        tr[u].add = 0;\n    }\n    void pushup(int u) {\n        tr[u].sum = tr[tr[u].ls].sum + tr[tr[u].rs].sum;\n    }\n    public void addRange(int left, int right) {\n        update(1, 1, N - 1, left, right - 1, 1);\n    }\n    public boolean queryRange(int left, int right) {\n        return query(1, 1, N - 1, left, right - 1) == right - left;\n    }\n    public void removeRange(int left, int right) {\n        update(1, 1, N - 1, left, right - 1, -1);\n    }\n}\n```\n* 时间复杂度:`addRange`、`queryRange` 和 `removeRange` 操作复杂度均为 $O(\\log{n})$\n* 空间复杂度:$O(m\\log{n})$\n\n---\n\n### 线段树(动态开点)- 动态指针\n\n利用「动态指针」实现的「动态开点」可以有效避免数组估点问题,更重要的是可以有效避免 `new` 大数组的初始化开销,对于 LC 这种还跟你算所有样例总时长的 OJ 来说,在不考虑 `static` 优化/全局数组优化 的情况下,动态指针的方式要比估点的方式来得好。\n\n代码:\n```Java\nclass RangeModule {\n    class Node {\n        Node ls, rs;\n        int sum, add;\n    }\n    int N = (int)1e9 + 10;\n    Node root = new Node();\n    void update(Node node, int lc, int rc, int l, int r, int v) {\n        int len = rc - lc + 1;\n        if (l <= lc && rc <= r) {\n            node.sum = v == 1 ? len : 0;\n            node.add = v;\n            return ;\n        }\n        pushdown(node, len);\n        int mid = lc + rc >> 1;\n        if (l <= mid) update(node.ls, lc, mid, l, r, v);\n        if (r > mid) update(node.rs, mid + 1, rc, l, r, v);\n        pushup(node);\n    }\n    int query(Node node, int lc, int rc, int l, int r) {\n        if (l <= lc && rc <= r) return node.sum;\n        pushdown(node, rc - lc + 1);\n        int mid = lc + rc >> 1, ans = 0;\n        if (l <= mid) ans = query(node.ls, lc, mid, l, r);\n        if (r > mid) ans += query(node.rs, mid + 1, rc, l, r);\n        return ans;\n    }\n    void pushdown(Node node, int len) {\n        if (node.ls == null) node.ls = new Node();\n        if (node.rs == null) node.rs = new Node();\n        if (node.add == 0) return ;\n        int add = node.add;\n        if (add == -1) {\n            node.ls.sum = node.rs.sum = 0;\n        } else {\n            node.ls.sum = len - len / 2;\n            node.rs.sum = len / 2;\n        }\n        node.ls.add = node.rs.add = add;\n        node.add = 0;\n    }\n    void pushup(Node node) {\n        node.sum = node.ls.sum + node.rs.sum;\n    }\n    public void addRange(int left, int right) {\n        update(root, 1, N - 1, left, right - 1, 1);\n    }\n    public boolean queryRange(int left, int right) {\n        return query(root, 1, N - 1, left, right - 1) == right - left;\n    }\n    public void removeRange(int left, int right) {\n        update(root, 1, N - 1, left, right - 1, -1);\n    }\n}\n```\n* 时间复杂度:`addRange`、`queryRange` 和 `removeRange` 操作复杂度均为 $O(\\log{n})$\n* 空间复杂度:$O(m\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.715` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/711-720/717. 1比特与2比特字符（简单）.md", "url_title": "717. 1比特与2比特字符", "url": "https://leetcode-cn.com/problems/1-bit-and-2-bit-characters/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-igh7/", "difficulty": "简单", "tags": ["模拟"], "question": "有两种特殊字符:\n* 第一种字符可以用一个比特 $0$ 来表示\n* 第二种字符可以用两个比特($10$ 或 $11$)来表示、\n给定一个以 $0$ 结尾的二进制数组 `bits` ,如果最后一个字符必须是一位字符,则返回 `true` 。\n\n示例 1:\n```\n输入: bits = [1, 0, 0]\n\n输出: true\n\n解释: 唯一的编码方式是一个两比特字符和一个一比特字符。\n所以最后一个字符是一比特字符。\n```\n示例 2:\n```\n输入: bits = [1, 1, 1, 0]\n\n输出: false\n\n解释: 唯一的编码方式是两比特字符和两比特字符。\n所以最后一个字符不是一比特字符。\n```\n\n提示:\n* $1 <= bits.length <= 1000$\n* $bits[i] == 0$ or $1$", "solution": "### 模拟\n\n根据题意进行模拟即可,使用 $n$ 代指 `bits` 的长度,$idx$ 为当前「比特字」的开头,从前往后扫描每个「比特字」,如果最后一个「比特字」的开头为 $n - 1$ 返回 `True`,否则返回 `False`。\n\n代码:\n```Java\nclass Solution {\n    public boolean isOneBitCharacter(int[] bits) {\n        int n = bits.length, idx = 0;\n        while (idx < n - 1) {\n            if (bits[idx] == 0) idx++;\n            else idx += 2;\n        }\n        return idx == n - 1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.717` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/711-720/719. 找出第 K 小的数对距离（困难）.md", "url_title": "719. 找出第 K 小的数对距离", "url": "https://leetcode.cn/problems/find-k-th-smallest-pair-distance/solution/by-ac_oier-o4if/", "difficulty": "困难", "tags": ["双指针", "二分"], "question": "数对 $(a,b)$ 由整数 `a` 和 `b` 组成,其数对距离定义为 `a` 和 `b` 的绝对差值。\n\n给你一个整数数组 `nums` 和一个整数 $k$ ,数对由 $nums[i]$ 和 $nums[j]$ 组成且满足 $0 <= i < j < nums.length$ 。\n\n返回 所有数对距离中 第 $k$ 小的数对距离。\n\n示例 1:\n```\n输入:nums = [1,3,1], k = 1\n\n输出:0\n\n解释:数对和对应的距离如下:\n(1,3) -> 2\n(1,1) -> 0\n(3,1) -> 2\n距离第 1 小的数对是 (1,1) ,距离为 0 。\n```\n示例 2:\n```\n输入:nums = [1,1,1], k = 2\n\n输出:0\n```\n示例 3:\n```\n输入:nums = [1,6,1], k = 3\n\n输出:5\n```\n\n提示:\n* $n == nums.length$\n* $2 <= n <= 10^4$\n* $0 <= nums[i] <= 10^6$\n* $1 <= k <= n \\times (n - 1) / 2$", "solution": "### 二分 + 双指针\n\n根据题意,由于对距离定义使用的是绝对值,因此从原数组中找数对 $(i, j)$,等价于在排序数组中找数对 $(i, j)$。\n\n同时由于 $k$ 的范围为 $n^2$,因此我们不能使用复杂度为 $O(k\\log{n})$ 的「多路归并」做法来做。\n\n利用数据范围 $0 <= nums[i] <= 10^6$,我们知道距离值域范围为 $[0, 10^6]$,假设所能形成的距离序列为 $A = a_1, a_2, ... ,a_m$,此时在以第 $k$ 小的距离值为分割点的数轴上,具有「二段性」,记这第 $k$ 小的距离值为 $a_k$:\n\n* 处于 $a_k$ 右侧的所有位置 $a_i$(包含 $a_k$)**必然满足**「序列 $A$ 中值小于等于 $a_i$ 的数不少于 $k$ 个」;\n* 处于 $a_k$ 左侧的所有位置 $a_i$(不包含 $a_k$)**不一定满足**「序列 $A$ 中值小于等于 $a_i$ 的数不少于 $k$ 个」(当且仅当 $a_k$ 在序列 $A$ 中不重复,或 $a_k$ 恰好是连续段距离值中的左端点时,必然不满足)。\n\n因此这本质上是一个满足 `1?` 特性(而不是 `10` 特性)的问题,我们可以使用「二分」来找到 $a_k$ 值。\n\n假设当前我们二分到的值是 $x$,利用我们排序好的 `nums`,我们并不需要真正的构建出序列 $A$,即可统计值小于等于 $x$ 的数量:枚举左端点 $i$,每次找第一个不满足条件的右端点 $j$(由于 $j$ 是第一个不满足条件的值,因此合法右端点范围为 $[i + 1, j - 1]$,共 $j - i - 1$ 个),利用 `nums` 有序,并且所有 $nums[i]$ 均为正数,可知 $j$ 会随着 $i$ 增大而逐步增大,即这部分利用「双指针」可实现 $O(n)$ 复杂度。\n\n代码:\n```Java\nclass Solution {\n    public int smallestDistancePair(int[] nums, int k) {\n        Arrays.sort(nums);\n        int l = 0, r = (int)1e6;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (check(nums, mid) >= k) r = mid;\n            else l = mid + 1;\n        }\n        return r;\n    }\n    int check(int[] nums, int x) {\n        int n = nums.length, ans = 0;\n        for (int i = 0, j = 1; i < n; i++) {\n            while (j < n && nums[j] - nums[i] <= x) j++;\n            ans += j - i - 1;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序的复杂度为 $O(n\\log{n})$,二分答案复杂度为 $O(n\\log{m})$,其中 $m = 1e6$ 为距离值域。整体复杂度为 $O(n\\log{m})$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.719` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/711-720/720. 词典中最长的单词（简单）.md", "url_title": "720. 词典中最长的单词", "url": "https://leetcode-cn.com/problems/longest-word-in-dictionary/solution/by-ac_oier-bmot/", "difficulty": "简单", "tags": ["模拟", "哈希表", "字典树"], "question": "给出一个字符串数组 `words` 组成的一本英语词典。返回 `words` 中最长的一个单词,该单词是由 `words` 词典中其他单词逐步添加一个字母组成。\n\n若其中有多个可行的答案,则返回答案中字典序最小的单词。若无答案,则返回空字符串。\n\n示例 1:\n```\n输入:words = [\"w\",\"wo\",\"wor\",\"worl\", \"world\"]\n\n输出:\"world\"\n\n解释: 单词\"world\"可由\"w\", \"wo\", \"wor\", 和 \"worl\"逐步添加一个字母组成。\n```\n示例 2:\n```\n输入:words = [\"a\", \"banana\", \"app\", \"appl\", \"ap\", \"apply\", \"apple\"]\n\n输出:\"apple\"\n\n解释:\"apply\" 和 \"apple\" 都能由词典中的单词组成。但是 \"apple\" 的字典序小于 \"apply\" \n```\n\n提示:\n* $1 <= words.length <= 1000$\n* $1 <= words[i].length <= 30$\n* 所有输入的字符串 $words[i]$ 都只包含小写字母。", "solution": "### 模拟\n\n数据范围很小,我们可以直接模拟来做。\n\n先将所有的 $words[i]$ 存入 `Set` 集合,方便后续可以近似 $O(1)$ 查询某个子串是否存在 $words$ 中。\n\n遍历 $words$ 数组(题目没有说 $words$ 不重复,因此最好遍历刚刚预处理的 `Set`  集合),判断每个 $words[i]$ 是否为「合法单词」,同时利用当前的最长单词来做剪枝。\n\n不算剪枝效果,该做法计算量不超过 $10^6$,可以过。\n\n代码:\n```Java\nclass Solution {\n    public String longestWord(String[] words) {\n        String ans = \"\";\n        Set<String> set = new HashSet<>();\n        for (String s : words) set.add(s);\n        for (String s : set) {\n            int n = s.length(), m = ans.length();\n            if (n < m) continue;\n            if (n == m && s.compareTo(ans) > 0) continue;\n            boolean ok = true;\n            for (int i = 1; i <= n && ok; i++) {\n                String sub = s.substring(0, i);\n                if (!set.contains(sub)) ok = false;\n            }\n            if (ok) ans = s;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:预处理 `Set` 集合复杂度近似 $O(n)$;判断某个 $words[i]$ 是否合法需要判断所有子串是否均在 $words$ 中,复杂度为 $O(m^2)$,其中 $m$ 为字符串长度,处理 $words[i]$ 的过程还使用到 `compareTo` 操作,其复杂度为 $O(\\min(N, M))$,其中 $N$ 和 $M$ 为参与比较的两字符串长度,该操作相比于生成子串可忽略,而对于一个长度为 $m$ 的字符串而言,生成其所有的子串的计算量为首项为 $1$,末项为 $m$,公差为 $1$ 的等差数列求和结果。整体复杂度为 $O(\\sum_{i = 0}^{n - 1}words[i].length^2)$\n* 空间复杂度:$O(\\sum_{i = 0}^{n - 1}words[i].length)$\n\n---\n\n### 字典树\n\n上述解法中「枚举某个 $words[i]$ 的所有子串,并判断子串是否在 $words$ 数组中出现」的操作可使用「字典树」来实现。\n\n**不了解「Trie / 字典树」的同学可以看前置 🧀:[字典树入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089)。里面通过图例展示了字典树基本形态,以及提供了「数组实现」和「TrieNode 实现」两种方式,还有「数组大小估算方式」和「Trie 应用面」介绍。**\n\n回到本题,起始先将所有的 $words[i]$ 存入字典树,并记录每个字符的结尾编号。\n\n对于某个 $words[i]$ 而言,其能成为「合法单词」的充要条件为:$words[i]$ 的每个前缀编号都有「以结尾编号」所被记录。\n\n> 一些细节:为了防止每个样例都 `new` 大数组,我们使用 `static` 进行优化,并在跑样例前进行相应的清理工作。\n\n代码:\n```Java\nclass Solution {\n    static int N = 30010, M = 26;\n    static int[][] tr = new int[N][M];\n    static boolean[] isEnd = new boolean[N];\n    static int idx = 0;\n    void add(String s) {\n        int p = 0, n = s.length();\n        for (int i = 0; i < n; i++) {\n            int u = s.charAt(i) - 'a';\n            if (tr[p][u] == 0) tr[p][u] = ++idx;\n            p = tr[p][u];\n        }\n        isEnd[p] = true;\n    }\n    boolean query(String s) {\n        int p = 0, n = s.length();\n        for (int i = 0; i < n; i++) {\n            int u = s.charAt(i) - 'a';\n            p = tr[p][u];\n            if (!isEnd[p]) return false;\n        }\n        return true;\n    }\n    public String longestWord(String[] words) {\n        Arrays.fill(isEnd, false);\n        for (int i = 0; i <= idx; i++) Arrays.fill(tr[i], 0);\n        idx = 0;\n\n        String ans = \"\";\n        for (String s : words) add(s);\n        for (String s : words) {\n            int n = s.length(), m = ans.length();\n            if (n < m) continue;\n            if (n == m && s.compareTo(ans) > 0) continue;\n            if (query(s)) ans = s;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:将所有 $words[i]$ 存入字典树的复杂度为 $O(\\sum_{i = 0}^{n - 1}words[i].length)$;查询每个 $words[i]$ 是否合法的复杂度为 $O(m)$,其中 $m$ 为当前 $words[i]$ 长度。整体复杂度为 $O(\\sum_{i = 0}^{n - 1}words[i].length)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.720` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/721-730/724. 寻找数组的中心下标（简单）.md", "url_title": "724. 寻找数组的中心下标", "url": "https://leetcode-cn.com/problems/find-pivot-index/solution/shi-yong-shao-bing-ji-qiao-liang-bian-qi-vkju/", "difficulty": "简单", "tags": ["前缀和"], "question": "给你一个整数数组 nums,请编写一个能够返回数组 “中心下标” 的方法。\n\n数组 中心下标 是数组的一个下标,其左侧所有元素相加的和等于右侧所有元素相加的和。\n\n如果数组不存在中心下标,返回 -1 。\n\n如果数组有多个中心下标,应该返回最靠近左边的那一个。\n\n注意:中心下标可能出现在数组的两端。\n\n示例 1:\n```\n输入:nums = [1, 7, 3, 6, 5, 6]\n\n输出:3\n\n解释:\n中心下标是 3 。\n左侧数之和 (1 + 7 + 3 = 11),\n右侧数之和 (5 + 6 = 11) ,二者相等。\n```\n示例 2:\n```\n输入:nums = [1, 2, 3]\n\n输出:-1\n\n解释:\n数组中不存在满足此条件的中心下标。\n```\n示例 3:\n```\n输入:nums = [2, 1, -1]\n\n输出:0\n\n解释:\n中心下标是 0 。\n下标 0 左侧不存在元素,视作和为 0 ;\n右侧数之和为 1 + (-1) = 0 ,二者相等。\n```\n\n提示:\n* nums 的长度范围为 [0, 10000]。\n* 任何一个 nums[i] 将会是一个范围在 [-1000, 1000]的整数。", "solution": "### 基本分析\n\n这是一道前缀和的裸题。\n\n只需要用两个数组,前后处理两遍前缀和,再对两个前缀和数组的相同下标进行判别即可。\n\n为了简化数组越界的判断,我们通常会给前缀和数组多预留一位作为哨兵。\n\n这里由于要求前后前缀和。所以我们直接多开两位。\n\n代码:\n```Java\nclass Solution {\n    public int pivotIndex(int[] nums) {\n        int n = nums.length;\n        int[] s1 = new int[n + 2], s2 = new int[n + 2];\n        for (int i = 1; i <= n; i++) s1[i] = s1[i - 1] + nums[i - 1];\n        for (int i = n; i >= 1; i--) s2[i] = s2[i + 1] + nums[i - 1];\n        for (int i = 1; i <= n; i++) {\n            if (s1[i] == s2[i]) return i - 1;\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:对数组进行线性扫描。复杂度为 $O(n)$\n* 空间复杂度:使用了前缀和数组。复杂度为$O(n)$\n\n---\n\n### 空间优化(常数级别的优化)\n\n当然,我们也可以只处理一遍前缀和。\n\n然后在判定一个下标是否为”中心索引“的时候,利用前缀和计算左侧值和右侧值。\n\n但这只是常数级别的优化,并不影响其时空复杂度。\n\n代码:\n```Java\nclass Solution {\n    public int pivotIndex(int[] nums) {\n        int n = nums.length;\n        int[] sum = new int[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n        for (int i = 1; i <= n; i++) {\n            int left = sum[i - 1], right = sum[n] - sum[i];\n            if (left == right) return i - 1;\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:对数组进行线性扫描。复杂度为 $O(n)$\n* 空间复杂度:使用了前缀和数组。复杂度为$O(n)$\n\n---\n\n### 空间优化(优化至常数级别)\n\n甚至可以不使用额外空间。\n\n先求一遍总和 `total`,再使用 `sum` 记录当前遍历位置的左侧总和。\n\n对于中心索引必然有:`sum = total - sum - nums[i]` (左边值 = 右边值)\n\n代码:\n```Java\nclass Solution {\n    public int pivotIndex(int[] nums) {\n        int n = nums.length;\n        int total = 0, sum = 0;\n        // 我们的 nums 处理不涉及并行操作,使用循环要比 Arrays.stream 快\n        // total = Arrays.stream(nums).sum(); \n        for (int i = 0; i < n; i++) total += nums[i];\n        for (int i = 0; i < n; i++) {\n            if (sum == total - sum - nums[i]) return i;\n            sum += nums[i];\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:对数组进行线性扫描。复杂度为 $O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 总结\n\n这是我使用到的前缀和模板(高频):\n\n```Java\nclass Solution {\n    public void func(int[] nums) {\n        int n = nums.length;\n        int[] sum = new int[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n    }\n}\n```", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.724` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/721-730/725. 分隔链表（中等）.md", "url_title": "725. 分隔链表", "url": "https://leetcode-cn.com/problems/split-linked-list-in-parts/solution/gong-shui-san-xie-jing-dian-lian-biao-ju-9yj4/", "difficulty": "中等", "tags": ["模拟", "链表"], "question": "给你一个头结点为 `head` 的单链表和一个整数 `k` ,请你设计一个算法将链表分隔为 `k` 个连续的部分。\n\n每部分的长度应该尽可能的相等:任意两部分的长度差距不能超过 $1$ 。这可能会导致有些部分为 null 。\n\n这 `k` 个部分应该按照在链表中出现的顺序排列,并且排在前面的部分的长度应该大于或等于排在后面的长度。\n\n返回一个由上述 k 部分组成的数组。\n\n示例 1:\n\n```\n输入:head = [1,2,3], k = 5\n\n输出:[[1],[2],[3],[],[]]\n\n解释:\n第一个元素 output[0] 为 output[0].val = 1 ,output[0].next = null 。\n最后一个元素 output[4] 为 null ,但它作为 ListNode 的字符串表示是 [] 。\n```\n示例 2:\n\n```\n输入:head = [1,2,3,4,5,6,7,8,9,10], k = 3\n\n输出:[[1,2,3,4],[5,6,7],[8,9,10]]\n\n解释:\n输入被分成了几个连续的部分,并且每部分的长度相差不超过 1 。前面部分的长度大于等于后面部分的长度。\n```\n\n提示:\n* 链表中节点的数目在范围 [0, 1000]\n* 0 <= Node.val <= 1000\n* 1 <= k <= 50", "solution": "### 模拟\n\n根据题意,我们应当近可能将链表平均分为 $k$ 份。\n\n我们可以采取与 [(题解) 68. 文本左右对齐](https://leetcode-cn.com/problems/text-justification/solution/gong-shui-san-xie-zi-fu-chuan-mo-ni-by-a-s3v7/) 类似的思路(在 $68$ 中,填充空格的操作与本题一致:尽可能平均,无法均分时,应当使前面比后面多)。\n\n回到本题,我们可以先对链表进行一次扫描,得到总长度 $cnt$,再结合需要将将链表划分为 $k$ 份,可知每一份的 **最小** 分配单位 $per = \\left \\lfloor \\frac{cnt}{k} \\right \\rfloor$(当 $cnt < k$ 时,$per$ 为 $0$)。\n\n然后从前往后切割出 $k$ 份链表,由于是在原链表的基础上进行,因此这里的切分只需要在合适的位置将节点的 $next$ 指针置空即可。\n\n**当我们需要构造出 $ans[i]$ 的链表长度时,首先可以先分配 $per$ 的长度,如果 `已处理的链表长度 + 剩余待分配份数 * per < cnt`,说明后面「待分配的份数」如果按照每份链表分配 $per$ 长度的话,会有节点剩余,基于「不能均分时,前面的应当比后面长」原则,此时只需为当前 $ans[i]$ 多分一个单位长度即可。**\n\n代码:\n```Java\nclass Solution {\n    public ListNode[] splitListToParts(ListNode head, int k) {\n        // 扫描链表,得到总长度 cnt\n        int cnt = 0;\n        ListNode tmp = head;\n        while (tmp != null && ++cnt > 0) tmp = tmp.next;\n        // 理论最小分割长度\n        int per = cnt / k;\n        // 将链表分割为 k 份(sum 代表已经被处理的链表长度为多少)\n        ListNode[] ans = new ListNode[k];\n        for (int i = 0, sum = 1; i < k; i++, sum++) {\n            ans[i] = head;\n            tmp = ans[i];\n            // 每次首先分配 per 的长度\n            int u = per;\n            while (u-- > 1 && ++sum > 0) tmp = tmp.next;\n            // 当「已处理的链表长度 + 剩余待分配份数 * per < cnt」,再分配一个单位长度\n            int remain = k - i - 1;\n            if (per != 0 && sum + per * remain < cnt && ++sum > 0) tmp = tmp.next;\n            head = tmp != null ? tmp.next : null;\n            if (tmp != null) tmp.next = null; \n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.725` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/721-730/726. 原子的数量（困难）.md", "url_title": "726. 原子的数量", "url": "https://leetcode-cn.com/problems/number-of-atoms/solution/gong-shui-san-xie-shi-yong-xiao-ji-qiao-l5ak4/", "difficulty": "困难", "tags": ["模拟", "数据结构运用", "栈", "哈希表", "优先队列(堆)"], "question": "给定一个化学式 `formula`(作为字符串),返回每种原子的数量。\n\n原子总是以一个大写字母开始,接着跟随0个或任意个小写字母,表示原子的名字。\n\n如果数量大于 1,原子后会跟着数字表示原子的数量。如果数量等于 1 则不会跟数字。例如,`H2O` 和 `H2O2` 是可行的,但 `H1O2` 这个表达是不可行的。\n\n两个化学式连在一起是新的化学式。例如 `H2O2He3Mg4` 也是化学式。\n\n一个括号中的化学式和数字(可选择性添加)也是化学式。例如 `(H2O2)` 和 `(H2O2)3` 是化学式。\n\n给定一个化学式,输出所有原子的数量。格式为:第一个(按字典序)原子的名子,跟着它的数量(如果数量大于 1),然后是第二个原子的名字(按字典序),跟着它的数量(如果数量大于 1),以此类推。\n\n示例 1:\n```\n输入: formula = \"H2O\"\n\n输出: \"H2O\"\n\n解释: 原子的数量是 {'H': 2, 'O': 1}。\n```\n示例 2:\n```\n输入: formula = \"Mg(OH)2\"\n\n输出: \"H2MgO2\"\n\n解释: 原子的数量是 {'H': 2, 'Mg': 1, 'O': 2}。\n```\n示例 3:\n```\n输入: formula = \"K4(ON(SO3)2)2\"\n\n输出: \"K4N2O14S4\"\n\n解释: 原子的数量是 {'K': 4, 'N': 2, 'O': 14, 'S': 4}。\n```\n\n注意:\n* 所有原子的第一个字母为大写,剩余字母都是小写。\n* `formula` 的长度在[1, 1000]之间。\n* `formula` 只包含字母、数字和圆括号,并且题目中给定的是合法的化学式。", "solution": "### 数据结构 + 模拟\n\n一道综合模拟题。\n\n相比于[(题解)227. 基本计算器 II](https://leetcode-cn.com/problems/basic-calculator-ii/solution/shi-yong-shuang-zhan-jie-jue-jiu-ji-biao-c65k/) 的表达式计算问题,本题设计模拟流程的难度要低很多,之所谓定位困难估计是使用到的数据结构较多一些。\n\n为了方便,我们约定以下命名:\n* 称一段完整的连续字母为「原子」\n* 称一段完整的连续数字为「数值」\n* 称 `(` 和`)` 为「符号」\n\n基本实现思路如下:\n\n1. 在处理入参 `s` 的过程中,始终维护着一个哈希表 `map`,`map` 中 **实时维护** 着某个「原子」对应的实际「数值」(即存储格式为 `{H:2,S:1}`);\n  \n    > 由于相同原子可以出在 `s` 的不同位置中,为了某个「数值」对「原子」的累乘效果被重复应用,我们这里应用一个”小技巧“:为每个「原子」增加一个”编号后缀“。即实际存储时为 `{H_1:2, S_2:1, H_3:1}`。\n    \n2. 根据当前处理到的字符分情况讨论:\n    * 符号:直接入栈;\n    * 原子:继续往后取,直到取得完整的原子名称,将完整原子名称入栈,同时在 `map` 中计数加 $1$;\n    * 数值:继续往后取,直到取得完整的数值并解析,然后根据栈顶元素是否为 `)` 符号,决定该数值应用给哪些原子:\n        * 如果栈顶元素不为 `)`,说明该数值只能应用给栈顶的原子\n        * 如果栈顶元素是 ),说明当前数值可以应用给「连续一段」的原子中\n\n3. 对 `map` 的原子做 “合并” 操作:`{H_1:2, S_2:1, H_3:1}` => `{H:3, S:1}` ;\n\n4. 使用「优先队列(堆)」实现字典序排序(也可以直接使用 `List`,然后通过 `Collections.sort` 进行排序),并构造答案。\n\n代码:\n```Java\nclass Solution {\n    class Node {\n        String s; int v;\n        Node (String _s, int _v) {\n            s = _s; v = _v;\n        }\n    }\n    public String countOfAtoms(String s) {\n        int n = s.length();\n        char[] cs = s.toCharArray();\n        Map<String, Integer> map = new HashMap<>();\n        Deque<String> d = new ArrayDeque<>();\n        int idx = 0;\n        for (int i = 0; i < n; ) {\n            char c = cs[i];\n            if (c == '(' || c == ')') {\n                d.addLast(String.valueOf(c));\n                i++;\n            } else {\n                if (Character.isDigit(c)) {\n                    // 获取完整的数字,并解析出对应的数值\n                    int j = i;\n                    while (j < n && Character.isDigit(cs[j])) j++;\n                    String numStr = s.substring(i, j);\n                    i = j;\n                    int cnt = Integer.parseInt(String.valueOf(numStr));  \n\n                    // 如果栈顶元素是 ),说明当前数值可以应用给「连续一段」的原子中\n                    if (!d.isEmpty() && d.peekLast().equals(\")\")) {\n                        List<String> tmp = new ArrayList<>();\n\n                        d.pollLast(); // pop )\n                        while (!d.isEmpty() && !d.peekLast().equals(\"(\")) {\n                            String cur = d.pollLast();\n                            map.put(cur, map.getOrDefault(cur, 1) * cnt);\n                            tmp.add(cur);\n                        }\n                        d.pollLast(); // pop (\n\n                        for (int k = tmp.size() - 1; k >= 0; k--) {\n                            d.addLast(tmp.get(k));\n                        }\n\n                    // 如果栈顶元素不是 ),说明当前数值只能应用给栈顶的原子\n                    } else {\n                        String cur = d.pollLast();\n                        map.put(cur, map.getOrDefault(cur, 1) * cnt);\n                        d.addLast(cur);\n                    }\n                } else {\n                    // 获取完整的原子名\n                    int j = i + 1;\n                    while (j < n && Character.isLowerCase(cs[j])) j++;\n                    String cur = s.substring(i, j) + \"_\" + String.valueOf(idx++);\n                    map.put(cur, map.getOrDefault(cur, 0) + 1);\n                    i = j;\n                    d.addLast(cur);\n                }\n            }\n        }\n\n        // 将不同编号的相同原子进行合并\n        Map<String, Node> mm = new HashMap<>();\n        for (String key : map.keySet()) {\n            String atom = key.split(\"_\")[0];\n            int cnt = map.get(key);\n            Node node = null;\n            if (mm.containsKey(atom)) {\n                node = mm.get(atom);\n            } else {\n                node = new Node(atom, 0);\n            }\n            node.v += cnt;\n            mm.put(atom, node);\n        }\n\n        // 使用优先队列(堆)对 Node 进行字典序排序,并构造答案\n        PriorityQueue<Node> q = new PriorityQueue<Node>((a,b)->a.s.compareTo(b.s));\n        for (String atom : mm.keySet()) q.add(mm.get(atom));\n\n        StringBuilder sb = new StringBuilder();\n        while (!q.isEmpty()) {\n            Node poll = q.poll();\n            sb.append(poll.s);\n            if (poll.v > 1) sb.append(poll.v);\n        }\n\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:最坏情况下,每次处理数值都需要从栈中取出元素进行应用,处理 `s` 的复杂度为 $O(n^2)$;最坏情况下,每个原子独立分布,合并的复杂度为 $O(n)$;将合并后的内容存入优先队列并取出构造答案的复杂度为 $O(n\\log{n})$;整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.726` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/721-730/728. 自除数（简单）.md", "url_title": "728. 自除数", "url": "https://leetcode-cn.com/problems/self-dividing-numbers/solution/by-ac_oier-pvb1/", "difficulty": "简单", "tags": ["模拟", "打表", "哈希表", "二分"], "question": "自除数是指可以被它包含的每一位数整除的数。\n\n* 例如,$128$ 是一个 自除数 ,因为 `128 % 1 == 0`,`128 % 2 == 0`,`128 % 8 == 0`。\n\n自除数不允许包含 $0$ 。\n\n给定两个整数 `left` 和 `right` ,返回一个列表,列表的元素是范围 $[left, right]$ 内所有的 自除数 。\n\n示例 1:\n```\n输入:left = 1, right = 22\n\n输出:[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]\n```\n示例 2:\n```\n输入:left = 47, right = 85\n\n输出:[48,55,66,77]\n```\n\n提示:\n* $1 <= left <= right <= 10^4$", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n代码:\n```Java\nclass Solution {\n    public List<Integer> selfDividingNumbers(int left, int right) {\n        List<Integer> ans = new ArrayList<>();\n        out:for (int i = left; i <= right; i++) {\n            int cur = i;\n            while (cur != 0) {\n                int t = cur % 10;\n                if (t == 0 || i % t != 0) continue out;\n                cur /= 10;\n            }\n            ans.add(i);\n        }\n        return ans;\n    }\n}\n```\n\n-\n\n```Python\nclass Solution:\n    def selfDividingNumbers(self, left: int, right: int) -> List[int]:\n        ans = []\n        for i in range(left, right + 1):\n            cur, ok = i, True\n            while cur and ok:\n                ok = not ((t := cur % 10) == 0 or i % t != 0)\n                cur //= 10\n            if ok:\n                ans.append(i)\n        return ans\n```\n* 时间复杂度:令 $n = right - left + 1$,复杂度为 $O(n * \\log{right})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 打表 + 二分\n\n利用数据范围只有 $1e4$,我们可以打表预处理出所有的自除数,通过二分找到 $[left, right]$ 范围内的最小自除数,再从前往后找到所有合法的自除数。\n\n代码:\n```Java\nclass Solution {\n    static List<Integer> list = new ArrayList<>();\n    static {\n        out:for (int i = 1; i <= 10000; i++) {\n            int cur = i;\n            while (cur != 0) {\n                int u = cur % 10;\n                if (u == 0 || i % u != 0) continue out;\n                cur /= 10;\n            }\n            list.add(i);\n        }\n    }\n    public List<Integer> selfDividingNumbers(int left, int right) {\n        List<Integer> ans = new ArrayList<>();\n        int l = 0, r = list.size() - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (list.get(mid) >= left) r = mid;\n            else l = mid + 1;\n        }\n        while (r < list.size() && list.get(r) <= right) ans.add(list.get(r++));\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $m$ 为范围在 $[left, right]$ 之间的自除数的数量,$n = right - left + 1$。复杂度为$O(\\log{m} + n)$,对于本题,$m$ 上界为 $339$\n* 空间复杂度:$O(m)$\n\n---\n\n### 打表 + 哈希表 \n\n在打表预处理了所有范围内的自除数的基础上,我们可以干脆将索引也预处理出来,从而避免二分操作。\n\n其中 $hash[x]$ 的含义为值不超过 $x$ 的最大自除数在 `list` 中的下标。\n\n代码:\n```Java\nclass Solution {\n    static List<Integer> list = new ArrayList<>();\n    static int[] hash = new int[10010];\n    static {\n        for (int i = 1; i <= 10000; i++) {\n            int cur = i;\n            boolean ok = true;\n            while (cur != 0 && ok) {\n                int u = cur % 10;\n                if (u == 0 || i % u != 0) ok = false;\n                cur /= 10;\n            }\n            if (ok) list.add(i);\n            hash[i] = list.size() - 1;\n        }\n    }\n    public List<Integer> selfDividingNumbers(int left, int right) {\n        List<Integer> ans = new ArrayList<>();\n        int idx = list.get(hash[left]) == left ? hash[left] : hash[left] + 1;\n        while (idx < list.size() && list.get(idx) <= right) ans.add(list.get(idx++));\n        return ans;\n    }\n}\n```\n* 时间复杂度:$n = right - left + 1$。复杂度为$O(n)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.726` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/721-730/729. 我的日程安排表 I（中等）.md", "url_title": "729. 我的日程安排表 I", "url": "https://leetcode.cn/problems/my-calendar-i/solution/by-ac_oier-hnjl/", "difficulty": "中等", "tags": ["模拟", "红黑树", "线段树(动态开点)", "线段树", "分块", "位运算", "哈希表"], "question": "实现一个 `MyCalendar` 类来存放你的日程安排。如果要添加的日程安排不会造成 重复预订 ,则可以存储这个新的日程安排。\n\n当两个日程安排有一些时间上的交叉时(例如两个日程安排都在同一时间内),就会产生 重复预订 。\n\n日程可以用一对整数 `start` 和 `end` 表示,这里的时间是半开区间,即 $[start, end)$, 实数 $x$ 的范围为,  $start <= x < end$ 。\n\n实现 MyCalendar 类:\n\n* `MyCalendar()` 初始化日历对象。\n* `boolean book(int start, int end)` 如果可以将日程安排成功添加到日历中而不会导致重复预订,返回 `true`。否则,返回 `false` 并且不要将该日程安排添加到日历中。\n\n示例:\n```\n输入:\n[\"MyCalendar\", \"book\", \"book\", \"book\"]\n[[], [10, 20], [15, 25], [20, 30]]\n\n输出:\n[null, true, false, true]\n\n解释:\nMyCalendar myCalendar = new MyCalendar();\nmyCalendar.book(10, 20); // return True\nmyCalendar.book(15, 25); // return False ,这个日程安排不能添加到日历中,因为时间 15 已经被另一个日程安排预订了。\nmyCalendar.book(20, 30); // return True ,这个日程安排可以添加到日历中,因为第一个日程安排预订的每个时间都小于 20 ,且不包含时间 20 。\n```\n\n提示:\n* $0 <= start < end <= 10^9$\n* 每个测试用例,调用 `book` 方法的次数最多不超过 $1000$ 次。", "solution": "### 模拟\n\n利用 `book` 操作最多调用 $1000$ 次,我们可以使用一个数组存储所有已被预定的日期 $[start, end - 1]$,对于每次 `book` 操作,检查当前传入的 $[start, end)$ 是否会与已有的日期冲突,冲突返回 `False`,否则将 $[start, end- 1]$ 插入数组并返回 `True`。\n\n代码:\n```Java\nclass MyCalendar {\n    List<int[]> list = new ArrayList<>();\n    public boolean book(int start, int end) {\n        end--;\n        for (int[] info : list) {\n            int l = info[0], r = info[1];\n            if (start > r || end < l) continue;\n            return false;\n        }\n        list.add(new int[]{start, end});\n        return true;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为 `book` 的最大调用次数,复杂度为 $O(n^2)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 线段树(动态开点)\n\n线段树维护的节点信息包括:\n\n* `ls/rs`: 分别代表当前节点的左右子节点在线段树数组 `tr` 中的下标;\n* `add`: 懒标记;\n* `val`: 为当前区间的所包含的点的数量。\n\n对于常规的线段树实现来说,都是一开始就调用 `build` 操作创建空树,而线段树一般以「满二叉树」的形式用数组存储,因此需要 $4 * n$ 的空间,并且这些空间在起始 `build` 空树的时候已经锁死。\n\n如果一道题仅仅是「值域很大」的离线题(提前知晓所有的询问),我们还能通过「离散化」来进行处理,将值域映射到一个小空间去,从而解决 `MLE`  问题。\n\n但对于本题而言,由于「强制在线」的原因,我们无法进行「离散化」,同时值域大小达到 $1e9$ 级别,因此如果我们想要使用「线段树」进行求解,只能采取「动态开点」的方式进行。\n\n动态开点的优势在于,不需要事前构造空树,而是在插入操作 `add` 和查询操作 `query` 时根据访问需要进行「开点」操作。由于我们不保证查询和插入都是连续的,因此对于父节点 $u$ 而言,我们不能通过 `u << 1` 和 `u << 1  | 1` 的固定方式进行访问,而要将节点 $tr[u]$ 的左右节点所在 `tr` 数组的下标进行存储,分别记为 `ls` 和 `rs` 属性。对于 $tr[u].ls = 0$ 和 $tr[u].rs = 0$ 则是代表子节点尚未被创建,当需要访问到它们,而又尚未创建的时候,则将其进行创建。\n\n由于存在「懒标记」,线段树的插入和查询都是 $\\log{n}$ 的,因此我们在单次操作的时候,最多会创建数量级为 $\\log{n}$ 的点,因此空间复杂度为 $O(m\\log{n})$,而不是 $O(4 * n)$,而开点数的预估需不能仅仅根据 $\\log{n}$ 来进行,还要对常熟进行分析,才能得到准确的点数上界。\n\n动态开点相比于原始的线段树实现,本质仍是使用「满二叉树」的形式进行存储,只不过是按需创建区间,如果我们是按照连续段进行查询或插入,最坏情况下仍然会占到 $4 * n$ 的空间,因此盲猜 $\\log{n}$ 的常数在 $4$ 左右,保守一点可以直接估算到 $6$,因此我们可以估算点数为 $6 * m * \\log{n}$,其中 $n = 1e9$ 和 $m = 1e3$ 分别代表值域大小和查询次数。\n\n当然一个比较实用的估点方式可以「尽可能的多开点数」,利用题目给定的空间上界和我们创建的自定义类(结构体)的大小,尽可能的多开( `Java` 的 $128M$ 可以开到 $5 * 10^6$ 以上)。\n\n代码:\n```Java\nclass MyCalendar {\n    class Node {\n        // ls 和 rs 分别代表当前节点的左右子节点在 tr 的下标\n        // val 代表当前节点有多少数\n        // add 为懒标记\n        int ls, rs, add, val;\n    }\n    int N = (int)1e9, M = 120010, cnt = 1;\n    Node[] tr = new Node[M];\n    void update(int u, int lc, int rc, int l, int r, int v) {\n        if (l <= lc && rc <= r) {\n            tr[u].val += (rc - lc + 1) * v;\n            tr[u].add += v;\n            return ;\n        }\n        lazyCreate(u);\n        pushdown(u, rc - lc + 1);\n        int mid = lc + rc >> 1;\n        if (l <= mid) update(tr[u].ls, lc, mid, l, r, v);\n        if (r > mid) update(tr[u].rs, mid + 1, rc, l, r, v);\n        pushup(u);\n    }\n    int query(int u, int lc, int rc, int l, int r) {\n        if (l <= lc && rc <= r) return tr[u].val;\n        lazyCreate(u);\n        pushdown(u, rc - lc + 1);\n        int mid = lc + rc >> 1, ans = 0;\n        if (l <= mid) ans = query(tr[u].ls, lc, mid, l, r);\n        if (r > mid) ans += query(tr[u].rs, mid + 1, rc, l, r);\n        return ans;\n    }\n    void lazyCreate(int u) {\n        if (tr[u] == null) tr[u] = new Node();\n        if (tr[u].ls == 0) {\n            tr[u].ls = ++cnt;\n            tr[tr[u].ls] = new Node();\n        }\n        if (tr[u].rs == 0) {\n            tr[u].rs = ++cnt;\n            tr[tr[u].rs] = new Node();\n        }\n    }\n    void pushdown(int u, int len) {\n        tr[tr[u].ls].add += tr[u].add; tr[tr[u].rs].add += tr[u].add;\n        tr[tr[u].ls].val += (len - len / 2) * tr[u].add; tr[tr[u].rs].val += len / 2 * tr[u].add;\n        tr[u].add = 0;\n    }\n    void pushup(int u) {\n        tr[u].val = tr[tr[u].ls].val + tr[tr[u].rs].val;\n    }\n    public boolean book(int start, int end) {\n        if (query(1, 1, N + 1, start + 1, end) > 0) return false;\n        update(1, 1, N + 1, start + 1, end, 1);\n        return true;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为值域大小,本题固定为 $1e9$,线段树的查询和增加复杂度均为 $O(\\log{n})$\n* 空间复杂度:令询问数量为 $m$,复杂度为 $O(m\\log{n})$\n\n---\n\n### 分块 + 位运算(分桶)\n\n另一个留有遗憾的算法是「分块」,朴素的分块做法是使用一个布尔数组 `region` 代表某个块是否有被占用,使用哈希表记录具体某个位置是否被占用,但可惜被奇怪的测评机制卡了。\n\n`TLE` 代码:\n```Java\nclass MyCalendar {\n    static Boolean T = Boolean.TRUE, F = Boolean.FALSE;\n    static int n = (int)1e9, len = (int) Math.sqrt(n) + 30;\n    static boolean[] region = new boolean[len];\n    static Map<Integer, Boolean> map = new HashMap<>();\n    int getIdx(int x) {\n        return x / len;\n    }\n    void add(int l, int r) {\n        if (getIdx(l) == getIdx(r)) {\n            for (int k = l; k <= r; k++) map.put(k, T);\n        } else {\n            int j = l, i = r;\n            while (getIdx(j) == getIdx(l)) map.put(j++, T);\n            while (getIdx(i) == getIdx(r)) map.put(i--, T);\n            for (int k = getIdx(j); k <= getIdx(i); k++) region[k] = true;\n        }\n    }\n    boolean query(int l, int r) {\n        if (getIdx(l) == getIdx(r)) {\n            boolean cur = region[getIdx(l)];\n            for (int k = l; k <= r; k++) {\n                if (map.getOrDefault(k, F) || cur) return false;\n            }\n            return true;\n        } else {\n            int j = l, i = r;\n            while (getIdx(j) == getIdx(l)) {\n                if (map.getOrDefault(j, F) || region[getIdx(j)]) return false;\n                j++;\n            }\n            while (getIdx(i) == getIdx(r)) {\n                if (map.getOrDefault(i, F) || region[getIdx(i)]) return false;\n                i--;\n            }\n            for (int k = getIdx(j); k <= getIdx(i); k++) {\n                if (region[k]) return false;\n            }\n            return true;\n        }\n    }\n    public MyCalendar() {\n        Arrays.fill(region, false);\n        map.clear();\n    }\n    public boolean book(int start, int end) {\n        if (query(start, end - 1)) {\n            add(start, end - 1);\n            return true;\n        }\n        return false;\n    }\n}\n```\n\n但我们知道分块算法的复杂度并不糟糕,而哈希表可能是被卡常数的关键,因此我们可以使用 `int` 数组来充当哈希表,由于只需要记录「是否被占用」,因此我们可以使用 `int` 的每一位充当格子,通过这种「分桶 + 位运算」,有效降低常数。\n\n`AC` 代码(`2022-07-05` 可过):\n```Java\nclass MyCalendar {\n    static int n = (int)1e9, len = (int) Math.sqrt(n) + 50, cnt = 32;\n    static boolean[] region = new boolean[len];\n    static int[] map = new int[n / cnt];\n    int getIdx(int x) {\n        return x / len;\n    }\n    boolean get(int x) {\n        return ((map[x / cnt] >> (x % cnt)) & 1) == 1;\n    }\n    void set(int x) {\n        map[x / cnt] |= (1 << (x % cnt));\n    }\n    void add(int l, int r) {\n        if (getIdx(l) == getIdx(r)) {\n            for (int k = l; k <= r; k++) set(k);\n        } else {\n            int j = l, i = r;\n            while (getIdx(j) == getIdx(l)) set(j++);\n            while (getIdx(i) == getIdx(r)) set(i--);\n            for (int k = getIdx(j); k <= getIdx(i); k++) region[k] = true;\n        }\n    }\n    boolean query(int l, int r) {\n        if (getIdx(l) == getIdx(r)) {\n            boolean cur = region[getIdx(l)];\n            for (int k = l; k <= r; k++) {\n                if (get(k) || cur) return false;\n            }\n            return true;\n        } else {\n            int j = l, i = r;\n            while (getIdx(j) == getIdx(l)) {\n                if (get(j) || region[getIdx(j)]) return false;\n                j++;\n            }\n            while (getIdx(i) == getIdx(r)) {\n                if (get(i) || region[getIdx(i)]) return false;\n                i--;\n            }\n            for (int k = getIdx(j); k <= getIdx(i); k++) {\n                if (region[k]) return false;\n            }\n            return true;\n        }\n    }\n    public MyCalendar() {\n        Arrays.fill(region, false);\n        Arrays.fill(map, 0);\n    }\n    public boolean book(int start, int end) {\n        if (query(start, end - 1)) {\n            add(start, end - 1);\n            return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(n\\sqrt{m})$\n* 空间复杂度:$O(\\sqrt{m} + \\frac{M}{k})$,其中 $M = 1e9$ 为值域大小,$k = 32$ 为单个数字的能够存储的格子数", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.729` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/721-730/730. 统计不同回文子序列（困难）.md", "url_title": "730. 统计不同回文子序列", "url": "https://leetcode.cn/problems/count-different-palindromic-subsequences/solution/by-ac_oier-lbva/", "difficulty": "困难", "tags": ["区间 DP", "动态规划"], "question": "给定一个字符串 `s`,返回 `s` 中不同的非空「回文子序列」个数 。\n\n通过从 `s` 中删除 $0$ 个或多个字符来获得子序列。\n\n如果一个字符序列与它反转后的字符序列一致,那么它是「回文字符序列」。\n\n如果有某个 $i$ , 满足 $a_i$ != $b_i$ ,则两个序列 `a1, a2, ...` 和 `b1, b2, ...` 不同。\n\n注意:\n* 结果可能很大,你需要对 $10^9 + 7$ 取模 。\n\n示例 1:\n```\n输入:s = 'bccb'\n\n输出:6\n\n解释:6 个不同的非空回文子字符序列分别为:'b', 'c', 'bb', 'cc', 'bcb', 'bccb'。\n注意:'bcb' 虽然出现两次但仅计数一次。\n```\n示例 2:\n```\n输入:s = 'abcdabcdabcdabcdabcdabcdabcdabcddcbadcbadcbadcbadcbadcbadcbadcba'\n\n输出:104860361\n\n解释:共有 3104860382 个不同的非空回文子序列,104860361 对 109 + 7 取模后的值。\n```\n\n提示:\n* $1 <= s.length <= 1000$\n* `s[i]` 仅包含 `'a'`, `'b'`, `'c'` 或 `'d'`", "solution": "### 区间 DP\n\n往长度较少的回文串两端添加字符,可能组成新的长度大的回文串,容易想到「区间 DP」,同时 `s` 仅由 $4$ 类小写字母组成,也是一个切入点。\n\n根据区间 DP 的一般思路,定义 $f[i][j]$ 为考虑字符串 `s` 中的 $[i,j]$ 范围内回文子序列的个数,最终答案为 $f[0][n - 1]$。\n\n**不失一般性考虑 $f[i][j]$ 该如何转移,通过枚举 `abcd` 作为回文方案「边缘字符」来进行统计,即分别统计各类字符作为「边缘字符」时对 $f[i][j]$ 的贡献,此类统计方式天生不存在重复性问题。**\n\n假设当前枚举到的字符为 $k$ :\n\n* 若 $s[i...j]$ 中没有字符 $k$,则字符 $k$ 对 $f[i][j]$ 贡献为 $0$,跳过;\n* 若 $s[i...j]$ 中存在字符 $k$,根据字符 $k$ 在范围 $s[i...j]$ 中「最小下标」和「最大下标」进行分情况讨论,假设字符 $k$ 在 $s[i...j]$ 中「最靠左」的位置为 $l$,「最靠右」的位置为 $r$:\n  * 当 $l = r$ 时,此时字符 $k$ 对 $f[i][j]$ 的贡献为 $1$,即 `k` 本身;\n  * 当 $l = r - 1$ 时,说明字符 $k$ 中间不存在任何字符,此时字符 $k$ 对 $f[i][j]$ 的贡献为 $2$,包括 `k` 和 `kk` 两种回文方案;\n  * 其余情况,可根据已算得的「小区间回文方案」进行延伸(两段分别补充位于 $l$ 和 $r$ 的字符 $k$),得到新的大区间方案,此部分对 $f[i][j]$ 的贡献是 $f[l + 1][r - 1]$,另外还有 `k` 和 `kk` 两种回文方案,因此总的对答案的贡献为 $f[l + 1][r - 1] + 2$。\n\n统计 $s[i...j]$ 中各类字符「最靠左」和「最靠右」的位置,可通过调整枚举方向来实现:从大到小枚举 $i$,同时维护 `L[s[i]-'a'] = i`,即可得到「最靠左」的位置;在确定左端点 $i$ 之后,从小到大枚举右端点 $j$,同时维护 `R[s[j]-'a'] = j`,即可得到「最靠右」的位置。\n\n代码:\n```Java\nclass Solution {\n    int MOD = (int)1e9+7;\n    public int countPalindromicSubsequences(String s) {\n        char[] cs = s.toCharArray();\n        int n = cs.length;\n        int[][] f = new int[n][n];\n        int[] L = new int[4], R = new int[4];\n        Arrays.fill(L, -1);\n        for (int i = n - 1; i >= 0; i--) {\n            L[cs[i] - 'a'] = i;\n            Arrays.fill(R, -1);\n            for (int j = i; j < n; j++) {\n                R[cs[j] - 'a'] = j;\n                for (int k = 0; k < 4; k++) {\n                    if (L[k] == -1 || R[k] == -1) continue;\n                    int l = L[k], r = R[k];\n                    if (l == r) f[i][j] = (f[i][j] + 1) % MOD;\n                    else if (l == r - 1) f[i][j] = (f[i][j] + 2) % MOD;\n                    else f[i][j] = (f[i][j] + f[l + 1][r - 1] + 2) % MOD;\n                }\n            }\n        }\n        return f[0][n - 1];\n    }\n}\n```\n* 时间复杂度:$O(C \\times n^2)$,其中 $C = 4$ 为字符集大小\n* 空间复杂度:$O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.730` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/731-740/731. 我的日程安排表 II（中等）.md", "url_title": "731. 我的日程安排表 II", "url": "https://leetcode.cn/problems/my-calendar-ii/solution/by-ac_oier-a1b3/", "difficulty": "中等", "tags": ["线段树(动态开点)", "线段树"], "question": "实现一个 `MyCalendar` 类来存放你的日程安排。如果要添加的时间内不会导致三重预订时,则可以存储这个新的日程安排。\n\n`MyCalendar` 有一个 `book(int start, int end)` 方法。它意味着在 `start` 到 `end` 时间内增加一个日程安排,注意,这里的时间是半开区间,即 $[start, end)$, 实数 $x$ 的范围为,$ start <= x < end$。\n\n当三个日程安排有一些时间上的交叉时(例如三个日程安排都在同一时间内),就会产生三重预订。\n\n每次调用 `MyCalendar.book` 方法时,如果可以将日程安排成功添加到日历中而不会导致三重预订,返回 `true`。否则,返回 `false` 并且不要将该日程安排添加到日历中。\n\n请按照以下步骤调用 `MyCalendar` 类: `MyCalendar cal = new MyCalendar(); MyCalendar.book(start, end)`\n\n示例:\n```\nMyCalendar();\nMyCalendar.book(10, 20); // returns true\nMyCalendar.book(50, 60); // returns true\nMyCalendar.book(10, 40); // returns true\nMyCalendar.book(5, 15); // returns false\nMyCalendar.book(5, 10); // returns true\nMyCalendar.book(25, 55); // returns true\n\n解释: \n前两个日程安排可以添加至日历中。 第三个日程安排会导致双重预订,但可以添加至日历中。\n第四个日程安排活动(5,15)不能添加至日历中,因为它会导致三重预订。\n第五个日程安排(5,10)可以添加至日历中,因为它未使用已经双重预订的时间10。\n第六个日程安排(25,55)可以添加至日历中,因为时间 [25,40] 将和第三个日程安排双重预订;\n时间 [40,50] 将单独预订,时间 [50,55)将和第二个日程安排双重预订。\n```\n\n提示:\n* 每个测试用例,调用 `MyCalendar.book` 函数最多不超过 $1000$ 次。\n* 调用函数 `MyCalendar.book(start, end)` 时, `start` 和 `end` 的取值范围为 $[0, 10^9]$。", "solution": "### 线段树(动态开点)- 估点\n\n和 [729. 我的日程安排表 I](https://leetcode-cn.com/problems/my-calendar-i/solution/by-ac_oier-1znx/) 几乎完全一致,只需要将对「线段树」所维护的节点信息进行调整即可。\n\n线段树维护的节点信息包括:\n\n* `ls/rs`: 分别代表当前节点的左右子节点在线段树数组 `tr` 中的下标;\n* `add`: 懒标记;\n* `max`: 为当前区间的最大值。\n\n对于常规的线段树实现来说,都是一开始就调用 `build` 操作创建空树,而线段树一般以「满二叉树」的形式用数组存储,因此需要 $4 \\times n$ 的空间,并且这些空间在起始 `build` 空树的时候已经锁死。\n\n如果一道题仅仅是「值域很大」的离线题(提前知晓所有的询问),我们还能通过「离散化」来进行处理,将值域映射到一个小空间去,从而解决 `MLE`  问题。\n\n但对于本题而言,由于「强制在线」的原因,我们无法进行「离散化」,同时值域大小达到 $1e9$ 级别,因此如果我们想要使用「线段树」进行求解,只能采取「动态开点」的方式进行。\n\n动态开点的优势在于,不需要事前构造空树,而是在插入操作 `add` 和查询操作 `query` 时根据访问需要进行「开点」操作。由于我们不保证查询和插入都是连续的,因此对于父节点 $u$ 而言,我们不能通过 `u << 1` 和 `u << 1  | 1` 的固定方式进行访问,而要将节点 $tr[u]$ 的左右节点所在 `tr` 数组的下标进行存储,分别记为 `ls` 和 `rs` 属性。对于 $tr[u].ls = 0$ 和 $tr[u].rs = 0$ 则是代表子节点尚未被创建,当需要访问到它们,而又尚未创建的时候,则将其进行创建。\n\n由于存在「懒标记」,线段树的插入和查询都是 $\\log{n}$ 的,因此我们在单次操作的时候,最多会创建数量级为 $\\log{n}$ 的点,因此空间复杂度为 $O(m\\log{n})$,而不是 $O(4 \\times n)$,而开点数的预估需不能仅仅根据 $\\log{n}$ 来进行,还要对常熟进行分析,才能得到准确的点数上界。\n\n动态开点相比于原始的线段树实现,本质仍是使用「满二叉树」的形式进行存储,只不过是按需创建区间,如果我们是按照连续段进行查询或插入,最坏情况下仍然会占到 $4 \\times n$ 的空间,因此盲猜 $\\log{n}$ 的常数在 $4$ 左右,保守一点可以直接估算到 $6$,因此我们可以估算点数为 $6 \\times m \\times \\log{n}$,其中 $n = 1e9$ 和 $m = 1e3$ 分别代表值域大小和查询次数。\n\n当然一个比较实用的估点方式可以「尽可能的多开点数」,利用题目给定的空间上界和我们创建的自定义类(结构体)的大小,尽可能的多开( `Java` 的 $128M$ 可以开到 $5 \\times 10^6$ 以上)。\n\nJava 代码:\n```Java\nclass MyCalendarTwo {\n    class Node {\n        int ls, rs, add, max;\n    }\n    int N = (int)1e9, M = 120010, cnt = 1;\n    Node[] tr = new Node[M];\n    void update(int u, int lc, int rc, int l, int r, int v) {\n        if (l <= lc && rc <= r) {\n            tr[u].add += v;\n            tr[u].max += v;\n            return ;\n        }\n        lazyCreate(u);\n        pushdown(u);\n        int mid = lc + rc >> 1;\n        if (l <= mid) update(tr[u].ls, lc, mid, l, r, v);\n        if (r > mid) update(tr[u].rs, mid + 1, rc, l, r, v);\n        pushup(u);\n    }\n    int query(int u, int lc, int rc, int l, int r) {\n        if (l <= lc && rc <= r) return tr[u].max;\n        lazyCreate(u);\n        pushdown(u);\n        int mid = lc + rc >> 1, ans = 0;\n        if (l <= mid) ans = Math.max(ans, query(tr[u].ls, lc, mid, l, r));\n        if (r > mid) ans = Math.max(ans, query(tr[u].rs, mid + 1, rc, l, r));\n        return ans;\n    }\n    void lazyCreate(int u) {\n        if (tr[u] == null) tr[u] = new Node();\n        if (tr[u].ls == 0) {\n            tr[u].ls = ++cnt;\n            tr[tr[u].ls] = new Node();\n        }\n        if (tr[u].rs == 0) {\n            tr[u].rs = ++cnt;\n            tr[tr[u].rs] = new Node();\n        }\n    }\n    void pushup(int u) {\n        tr[u].max = Math.max(tr[tr[u].ls].max, tr[tr[u].rs].max);\n    }\n    void pushdown(int u) {\n        tr[tr[u].ls].add += tr[u].add; tr[tr[u].rs].add += tr[u].add;\n        tr[tr[u].ls].max += tr[u].add; tr[tr[u].rs].max += tr[u].add;\n        tr[u].add = 0;\n    }\n    public boolean book(int start, int end) {\n        if (query(1, 1, N + 1, start + 1, end) >= 2) return false;\n        update(1, 1, N + 1, start + 1, end, 1);\n        return true;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nclass TNode {\n    ls: number = 0; rs: number = 0\n    max:number = 0; add: number = 0;  \n}\nclass MyCalendarTwo {\n    N = 1e9; M = 120010; cnt = 1\n    tr: TNode[] = new Array<TNode>(this.M)\n    query(u: number, lc: number, rc: number, l: number, r: number): number {\n        if (l <= lc && rc <= r) return this.tr[u].max;\n        this.pushdown(u)\n        let mid = lc + rc >> 1, ans = 0\n        if (l <= mid) ans = Math.max(ans, this.query(this.tr[u].ls, lc, mid, l, r))\n        if (r > mid) ans = Math.max(ans, this.query(this.tr[u].rs, mid + 1, rc, l, r))\n        return ans\n    }\n    update(u: number, lc: number, rc: number, l: number, r: number, v: number): number {\n        if (l <= lc && rc <= r) {\n            this.tr[u].add += v\n            this.tr[u].max += v\n            return \n        }\n        this.pushdown(u)\n        let mid = lc + rc >> 1\n        if (l <= mid) this.update(this.tr[u].ls, lc, mid, l, r, v)\n        if (r > mid) this.update(this.tr[u].rs, mid + 1, rc, l, r, v)\n        this.pushdup(u)\n    }\n    pushdown(u: number): void {\n        if (this.tr[u] == null) this.tr[u] = new TNode()\n        if (this.tr[u].ls == 0) {\n            this.tr[u].ls = ++this.cnt\n            this.tr[this.tr[u].ls] = new TNode()\n        }\n        if (this.tr[u].rs == 0) {\n            this.tr[u].rs = ++this.cnt\n            this.tr[this.tr[u].rs] = new TNode()\n        }\n        const add = this.tr[u].add\n        this.tr[this.tr[u].ls].add += add; this.tr[this.tr[u].rs].add += add\n        this.tr[this.tr[u].ls].max += add; this.tr[this.tr[u].rs].max += add\n        this.tr[u].add = 0\n    }\n    pushdup(u: number): void {\n        this.tr[u].max = Math.max(this.tr[this.tr[u].ls].max, this.tr[this.tr[u].rs].max)\n    }\n    book(start: number, end: number): boolean {\n        if (this.query(1, 1, this.N + 1, start + 1, end) >= 2) return false\n        this.update(1, 1, this.N + 1, start + 1, end, 1)\n        return true\n    }\n}\n```\n* 时间复杂度:令 $n$ 为值域大小,本题固定为 $1e9$,线段树的查询和增加复杂度均为 $O(\\log{n})$\n* 空间复杂度:令询问数量为 $m$,复杂度为 $O(m\\log{n})$\n\n---\n\n### 线段树(动态开点)- 动态指针\n\n利用「动态指针」实现的「动态开点」可以有效避免数组估点问题,更重要的是可以有效避免 `new` 大数组的初始化开销,对于 LC 这种还跟你算所有样例总时长的 OJ 来说,在不考虑 `static` 优化/全局数组优化 的情况下,动态指针的方式要比估点的方式来得好。\n\nJava 代码:\n```Java\nclass MyCalendarTwo {\n    class Node {\n        Node ls, rs;\n        int max, add;\n    }\n    int N = (int)1e9;\n    Node root = new Node();\n    void update(Node node, int lc, int rc, int l, int r, int v) {\n        if (l <= lc && rc <= r) {\n            node.add += v;\n            node.max += v;\n            return ;\n        }\n        pushdown(node);\n        int mid = lc + rc >> 1;\n        if (l <= mid) update(node.ls, lc, mid, l, r, v);\n        if (r > mid) update(node.rs, mid + 1, rc, l, r, v);\n        pushup(node);\n    }\n    int query(Node node, int lc, int rc, int l, int r) {\n        if (l <= lc && rc <= r) return node.max;\n        pushdown(node);\n        int mid = lc + rc >> 1, ans = 0;\n        if (l <= mid) ans = query(node.ls, lc, mid, l, r);\n        if (r > mid) ans = Math.max(ans, query(node.rs, mid + 1, rc, l, r));\n        return ans;\n    }\n    void pushdown(Node node) {\n        if (node.ls == null) node.ls = new Node();\n        if (node.rs == null) node.rs = new Node();\n        int add = node.add;\n        node.ls.max += add; node.rs.max += add;\n        node.ls.add += add; node.rs.add += add;\n        node.add = 0;\n    }\n    void pushup(Node node) {\n        node.max = Math.max(node.ls.max, node.rs.max);\n    }\n    public boolean book(int start, int end) {\n        if (query(root, 0, N, start, end - 1) >= 2) return false;\n        update(root, 0, N, start, end - 1, 1);\n        return true;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nclass TNode {\n    ls: TNode = null; rs: TNode = null\n    max: number = 0; add: number = 0\n}\nclass MyCalendarTwo {\n    root: TNode = new TNode()\n    update(node: TNode, lc: number, rc: number, l: number, r: number, v: number): void {\n        if (l <= lc && rc <= r) {\n            node.add += v\n            node.max += v\n            return \n        }\n        this.pushdown(node)\n        let mid = lc + rc >> 1\n        if (l <= mid) this.update(node.ls, lc, mid, l, r, v)\n        if (r > mid) this.update(node.rs, mid + 1, rc, l, r, v)\n        this.pushup(node)\n    }\n    query(node: TNode, lc: number, rc: number, l: number, r: number): number {\n        if (l <= lc && rc <= r) return node.max\n        let mid = lc + rc >> 1, ans = 0\n        this.pushdown(node)\n        if (l <= mid) ans = this.query(node.ls, lc, mid, l, r)\n        if (r > mid) ans = Math.max(ans, this.query(node.rs, mid + 1, rc, l, r))\n        return ans\n    }\n    pushdown(node: TNode): void {\n        if (node.ls == null) node.ls = new TNode()\n        if (node.rs == null) node.rs = new TNode()\n        const add = node.add\n        node.ls.add += add; node.rs.add += add\n        node.ls.max += add; node.rs.max += add\n        node.add = 0\n    }\n    pushup(node: TNode): void {\n        node.max = Math.max(node.ls.max, node.rs.max)\n    }\n    book(start: number, end: number): boolean {\n        if (this.query(this.root, 0, 1e9, start, end - 1) >= 2) return false\n        this.update(this.root, 0, 1e9, start, end - 1, 1)\n        return true\n    }\n}\n```\n* 时间复杂度:令 $n$ 为值域大小,本题固定为 $1e9$,线段树的查询和增加复杂度均为 $O(\\log{n})$\n* 空间复杂度:令询问数量为 $m$,复杂度为 $O(m\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.731` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/731-740/732. 我的日程安排表 III（困难）.md", "url_title": "732. 我的日程安排表 III", "url": "https://leetcode-cn.com/problems/my-calendar-iii/solution/by-ac_oier-cv31/", "difficulty": "困难", "tags": ["线段树(动态开点)", "分块", "线段树"], "question": "当 $k$ 个日程安排有一些时间上的交叉时(例如 $k$ 个日程安排都在同一时间内),就会产生 $k$ 次预订。\n\n给你一些日程安排 $[start, end)$ ,请你在每个日程安排添加后,返回一个整数 $k$ ,表示所有先前日程安排会产生的最大 $k$ 次预订。\n\n实现一个 `MyCalendarThree` 类来存放你的日程安排,你可以一直添加新的日程安排。\n\n* `MyCalendarThree()` 初始化对象。\n* `int book(int start, int end)` 返回一个整数 $k$ ,表示日历中存在的 $k$ 次预订的最大值。\n\n示例:\n```\n输入:\n[\"MyCalendarThree\", \"book\", \"book\", \"book\", \"book\", \"book\", \"book\"]\n[[], [10, 20], [50, 60], [10, 40], [5, 15], [5, 10], [25, 55]]\n\n输出:\n[null, 1, 1, 2, 3, 3, 3]\n\n解释:\nMyCalendarThree myCalendarThree = new MyCalendarThree();\nmyCalendarThree.book(10, 20); // 返回 1 ,第一个日程安排可以预订并且不存在相交,所以最大 k 次预订是 1 次预订。\nmyCalendarThree.book(50, 60); // 返回 1 ,第二个日程安排可以预订并且不存在相交,所以最大 k 次预订是 1 次预订。\nmyCalendarThree.book(10, 40); // 返回 2 ,第三个日程安排 [10, 40) 与第一个日程安排相交,所以最大 k 次预订是 2 次预订。\nmyCalendarThree.book(5, 15); // 返回 3 ,剩下的日程安排的最大 k 次预订是 3 次预订。\nmyCalendarThree.book(5, 10); // 返回 3\nmyCalendarThree.book(25, 55); // 返回 3\n```\n\n提示:\n* $0 <= start < end <= 10^9$\n* 每个测试用例,调用 `book` 函数最多不超过 $400$ 次", "solution": "### 线段树(动态开点)\n\n和 [731. 我的日程安排表 II](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247491636&idx=1&sn=48bfdd56cdcc33ededd6f154ffd41f0a) 几乎完全一致,只需要将对「线段树」所维护的节点信息进行调整即可。\n\n线段树维护的节点信息包括:\n\n* `ls/rs`: 分别代表当前节点的左右子节点在线段树数组 `tr` 中的下标;\n* `add`: 懒标记;\n* `max`: 为当前区间的最大值。\n\n对于常规的线段树实现来说,都是一开始就调用 `build` 操作创建空树,而线段树一般以「满二叉树」的形式用数组存储,因此需要 $4 \\times n$ 的空间,并且这些空间在起始 `build` 空树的时候已经锁死。\n\n如果一道题仅仅是「值域很大」的离线题(提前知晓所有的询问),我们还能通过「离散化」来进行处理,将值域映射到一个小空间去,从而解决 `MLE`  问题。\n\n但对于本题而言,由于「强制在线」的原因,我们无法进行「离散化」,同时值域大小达到 $1e9$ 级别,因此如果我们想要使用「线段树」进行求解,只能采取「动态开点」的方式进行。\n\n动态开点的优势在于,不需要事前构造空树,而是在插入操作 `add` 和查询操作 `query` 时根据访问需要进行「开点」操作。由于我们不保证查询和插入都是连续的,因此对于父节点 $u$ 而言,我们不能通过 `u << 1` 和 `u << 1  | 1` 的固定方式进行访问,而要将节点 $tr[u]$ 的左右节点所在 `tr` 数组的下标进行存储,分别记为 `ls` 和 `rs` 属性。对于 $tr[u].ls = 0$ 和 $tr[u].rs = 0$ 则是代表子节点尚未被创建,当需要访问到它们,而又尚未创建的时候,则将其进行创建。\n\n由于存在「懒标记」,线段树的插入和查询都是 $\\log{n}$ 的,因此我们在单次操作的时候,最多会创建数量级为 $\\log{n}$ 的点,因此空间复杂度为 $O(m\\log{n})$,而不是 $O(4 \\times n)$,而开点数的预估需不能仅仅根据 $\\log{n}$ 来进行,还要对常熟进行分析,才能得到准确的点数上界。\n\n动态开点相比于原始的线段树实现,本质仍是使用「满二叉树」的形式进行存储,只不过是按需创建区间,如果我们是按照连续段进行查询或插入,最坏情况下仍然会占到 $4 \\times n$ 的空间,因此盲猜 $\\log{n}$ 的常数在 $4$ 左右,保守一点可以直接估算到 $6$,因此我们可以估算点数为 $6 \\times m \\times \\log{n}$,其中 $n = 1e9$ 和 $m = 1e3$ 分别代表值域大小和查询次数。\n\n当然一个比较实用的估点方式可以「尽可能的多开点数」,利用题目给定的空间上界和我们创建的自定义类(结构体)的大小,尽可能的多开( `Java` 的 `128M` 可以开到 $5 \\times 10^6$ 以上)。\n\n代码:\n```Java\nclass MyCalendarThree {\n    class Node {\n        int ls, rs, add, max;\n    }\n    int N = (int)1e9, M = 4 * 400 * 20, cnt = 1;\n    Node[] tr = new Node[M];\n    void update(int u, int lc, int rc, int l, int r, int v) {\n        if (l <= lc && rc <= r) {\n            tr[u].add += v;\n            tr[u].max += v;\n            return ;\n        }\n        lazyCreate(u);\n        pushdown(u);\n        int mid = lc + rc >> 1;\n        if (l <= mid) update(tr[u].ls, lc, mid, l, r, v);\n        if (r > mid) update(tr[u].rs, mid + 1, rc, l, r, v);\n        pushup(u);\n    }\n    int query(int u, int lc, int rc, int l, int r) {\n        if (l <= lc && rc <= r) return tr[u].max;\n        lazyCreate(u);\n        pushdown(u);\n        int mid = lc + rc >> 1, ans = 0;\n        if (l <= mid) ans = query(tr[u].ls, lc, mid, l, r);\n        if (r > mid) ans = Math.max(ans, query(tr[u].rs, mid + 1, rc, l, r));\n        return ans;\n    }\n    void lazyCreate(int u) {\n        if (tr[u] == null) tr[u] = new Node();\n        if (tr[u].ls == 0) {\n            tr[u].ls = ++cnt;\n            tr[tr[u].ls] = new Node();\n        }\n        if (tr[u].rs == 0) {\n            tr[u].rs = ++cnt;\n            tr[tr[u].rs] = new Node();\n        }\n    }\n    void pushdown(int u) {\n        tr[tr[u].ls].add += tr[u].add; tr[tr[u].rs].add += tr[u].add;\n        tr[tr[u].ls].max += tr[u].add; tr[tr[u].rs].max += tr[u].add;\n        tr[u].add = 0;\n    }\n    void pushup(int u) {\n        tr[u].max = Math.max(tr[tr[u].ls].max, tr[tr[u].rs].max);\n    }\n    public int book(int start, int end) {\n        update(1, 1, N + 1, start + 1, end, 1);\n        return query(1, 1, N + 1, 1, N + 1);\n    }\n}\n```\n* 时间复杂度:令 $n$ 为值域大小,本题固定为 $1e9$,线段树的查询和增加复杂度均为 $O(\\log{n})$\n* 空间复杂度:令询问数量为 $m$,复杂度为 $O(m\\log{n})$\n\n---\n\n### 带懒标记的分块(TLE)\n\n实际上,还存在另外一种十分值得学习的算法:分块。\n\n但该做法被奇怪的测评机制卡掉,是给每个样例都定了执行用时吗 🤣 ?\n\n旧题解没有这种做法,今天补充的,我们可以大概讲讲「分块」算法是如何解决涉及「区间修改」,也就是带懒标记的问题。\n\n对于本题,我们设定两个块数组 `max` 和 `add`,其中 `max[idx]` 含义为块编号为 `idx` 的连续区间的最大重复值,而 `add[idx]` 代表块编号的懒标记,同时使用「哈希表」记录下某些具体位置的覆盖次数。\n\n然后我们考虑如何指定块大小,设定一个合理的块大小是减少运算量的关键。\n\n通常情况下,我们会设定块大小为 $\\sqrt{n}$,从而确保块内最多不超过 $\\sqrt{n}$ 个元素,同时块的总个数也不超过 $\\sqrt{n}$,即无论我们是块内暴力,还是操作多个块,复杂度均为 $O(\\sqrt{n})$。因此对于本题而言,设定块大小为 $\\sqrt{1e9}$(经试验,调成 $1200010$ 能够通过较多样例),较为合适。\n\n对于涉及「区间修改」的分块算法,我们需要在每次修改和查询前,先将懒标记下传到区间的每个元素中。\n\n然后考虑如何处理「块内」和「块间」操作:\n\n* 块内操作:\n    * 块内更新:直接操作 `map` 进行累加,同时使用更新后的 `map` 来维护相应的 `max[idx]`;\n    * 块内查询:直接查询 `map` 即可;\n* 块间操作:\n    * 块间更新:直接更新懒标记 `add[idx]` 即可,同时由于我们是对整个区间进行累加操作,因此最大值必然也会同步被累加,因此同步更新 `max[idx]`;\n    * 块间查询:直接查询 `max[idx]` 即可。\n\n代码:\n```Java\nclass MyCalendarThree {\n    static int N = (int)1e9 + 10, M = 1200010, SZ = N / M + 10;\n    static int[] max = new int[M], add = new int[M];\n    static Map<Integer, Integer> map = new HashMap<>();\n    int minv = -1, maxv = -1;\n    int getIdx(int x) {\n        return x / SZ;\n    }\n    void add(int l, int r) {\n        pushdown(l); pushdown(r);\n        if (getIdx(l) == getIdx(r)) {\n            for (int k = l; k <= r; k++) {\n                map.put(k, map.getOrDefault(k, 0) + 1);\n                max[getIdx(k)] = Math.max(max[getIdx(k)], map.get(k));\n            }\n        } else {\n            int i = l, j = r;\n            while (getIdx(i) == getIdx(l)) {\n                map.put(i, map.getOrDefault(i, 0) + 1);\n                max[getIdx(i)] = Math.max(max[getIdx(i)], map.get(i));\n                i++;\n            }\n            while (getIdx(j) == getIdx(r)) {\n                map.put(j, map.getOrDefault(j, 0) + 1);\n                max[getIdx(j)] = Math.max(max[getIdx(j)], map.get(j));\n                j--;\n            }\n            for (int k = getIdx(i); k <= getIdx(j); k++) {\n                max[k]++; add[k]++;\n            }\n        }\n    }\n    int query(int l, int r) {\n        pushdown(l); pushdown(r);\n        int ans = 0;\n        if (getIdx(l) == getIdx(r)) {\n            for (int k = l; k <= r; k++) ans = Math.max(ans, map.getOrDefault(k, 0));\n        } else {\n            int i = l, j = r;\n            while (getIdx(i) == getIdx(l)) ans = Math.max(ans, map.getOrDefault(i++, 0));\n            while (getIdx(j) == getIdx(r)) ans = Math.max(ans, map.getOrDefault(j--, 0));\n            for (int k = getIdx(i); k <= getIdx(j); k++) ans = Math.max(ans, max[k]);\n        }\n        return ans;\n    }\n    void pushdown(int x) {\n        int idx = getIdx(x);\n        if (add[idx] == 0) return ;\n        int i = x, j = x + 1;\n        while (getIdx(i) == idx) map.put(i, map.getOrDefault(i--, 0) + add[idx]);\n        while (getIdx(j) == idx) map.put(j, map.getOrDefault(j++, 0) + add[idx]);\n        add[idx] = 0;\n    }\n    public MyCalendarThree() {\n        Arrays.fill(max, 0);\n        Arrays.fill(add, 0);\n        map.clear();\n    }\n    public int book(int start, int end) {\n        add(start + 1, end);\n        minv = minv == -1 ? start : Math.min(minv, start);\n        maxv = maxv == -1 ? end + 1 : Math.max(maxv, end + 1);\n        return query(minv, maxv);\n    }\n}\n```\n* 时间复杂度:令 $M$ 为块大小,复杂度为 $O(\\sqrt{M})$\n* 空间复杂度:$O(C \\times \\sqrt{M})$,其中 $C = 1e3$ 为最大调用次数", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.732` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/731-740/735. 行星碰撞（中等）.md", "url_title": "735. 行星碰撞", "url": "https://leetcode.cn/problems/asteroid-collision/solution/by-ac_oier-p4qh/", "difficulty": "中等", "tags": ["栈", "模拟"], "question": "给定一个整数数组 `asteroids`,表示在同一行的行星。\n\n对于数组中的每一个元素,其绝对值表示行星的大小,正负表示行星的移动方向(正表示向右移动,负表示向左移动)。\n\n每一颗行星以相同的速度移动,找出碰撞后剩下的所有行星。\n\n碰撞规则:\n\n1. 两个行星相互碰撞,较小的行星会爆炸。\n2. 如果两颗行星大小相同,则两颗行星都会爆炸。\n3. 两颗移动方向相同的行星,永远不会发生碰撞。\n\n示例 1:\n```\n输入:asteroids = [5,10,-5]\n\n输出:[5,10]\n\n解释:10 和 -5 碰撞后只剩下 10 。 5 和 10 永远不会发生碰撞。\n```\n示例 2:\n```\n输入:asteroids = [8,-8]\n\n输出:[]\n\n解释:8 和 -8 碰撞后,两者都发生爆炸。\n```\n示例 3:\n```\n输入:asteroids = [10,2,-5]\n\n输出:[10]\n\n解释:2 和 -5 发生碰撞后剩下 -5 。10 和 -5 发生碰撞后剩下 10 。\n```\n\n提示:\n* $2 <= asteroids.length <= 10^4$\n* $-1000 <= asteroids[i] <= 1000$\n* $asteroids[i] != 0$", "solution": "### 模拟 + 栈\n\n由于碰撞抵消总是从相邻行星之间发生,我们可以使用「栈」来模拟该过程。\n\n从前往后处理所有的 $ats[i]$,使用栈存储当前未被抵消的行星,当栈顶元素方向往右,当前 $ats[i]$ 方向往左时,会发生抵消操作,抵消过程根据规则进行即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] asteroidCollision(int[] asteroids) {\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int t : asteroids) {\n            boolean ok = true;\n            while (ok && !d.isEmpty() && d.peekLast() > 0 && t < 0) {\n                int a = d.peekLast(), b = -t;\n                if (a <= b) d.pollLast();\n                if (a >= b) ok = false;\n            }\n            if (ok) d.addLast(t);\n        }\n        int sz = d.size();\n        int[] ans = new int[sz];\n        while (!d.isEmpty()) ans[--sz] = d.pollLast();\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> asteroidCollision(vector<int>& asteroids) {\n        deque<int> d;\n        for (int t : asteroids) {\n            bool ok = true;\n            while (ok && !d.empty() && d.back() > 0 && t < 0) {\n                int a = d.back(), b = -t;\n                if (a <= b) d.pop_back();\n                if (a >= b) ok = false;\n            }\n            if (ok) d.push_back(t);\n        }\n        vector<int> ans(d.begin(), d.end());\n        return ans;\n    }\n};\n```\nPython 3 代码:\n```Python3\nclass Solution:\n    def asteroidCollision(self, asteroids: List[int]) -> List[int]:\n        stk = []\n        for t in asteroids:\n            ok = True\n            while ok and stk and stk[-1] > 0 and t < 0:\n                a, b = stk[-1], -t\n                if a <= b:\n                    stk.pop(-1)\n                if a >= b:\n                    ok = False\n            if ok:\n                stk.append(t)\n        return stk\n```\nTypeScript 代码:\n```TypeScript\nfunction asteroidCollision(asteroids: number[]): number[] {\n    const stk = new Array<number>()\n    for (const t of asteroids) {\n        let ok = true\n        while (ok && stk.length > 0 && stk[stk.length - 1] > 0 && t < 0) {\n            const a = stk[stk.length - 1], b = -t\n            if (a <= b) stk.pop()\n            if (a >= b) ok = false\n        }\n        if (ok) stk.push(t)\n    }\n    return stk\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.735` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/731-740/736. Lisp 语法解析（困难）.md", "url_title": "736. Lisp 语法解析", "url": "https://leetcode.cn/problems/parse-lisp-expression/solution/by-ac_oier-i7w1/", "difficulty": "困难", "tags": ["DFS", "模拟", "哈希表"], "question": "给你一个类似 `Lisp` 语句的字符串表达式 `expression`,求出其计算结果。\n\n表达式语法如下所示:\n\n* 表达式可以为整数,`let` 表达式,`add` 表达式,`mult` 表达式,或赋值的变量。表达式的结果总是一个整数。\n* 整数可以是正整数、负整数、$0$\n* `let` 表达式采用 `\"(let v1 e1 v2 e2 ... vn en expr)\"` 的形式,其中 `let` 总是以字符串 `\"let\"`来表示,接下来会跟随一对或多对交替的变量和表达式,也就是说,第一个变量 `v1`被分配为表达式 `e1` 的值,第二个变量 `v2` 被分配为表达式 `e2` 的值,依次类推;最终 `let` 表达式的值为 `expr` 表达式的值。\n* `add` 表达式表示为 `\"(add e1 e2)\"` ,其中 `add` 总是以字符串 `\"add\"` 来表示,该表达式总是包含两个表达式 `e1`、`e2` ,最终结果是 `e1` 表达式的值与 `e2` 表达式的值之 和 。\n* `mult` 表达式表示为 `\"(mult e1 e2)\"` ,其中 `mult` 总是以字符串 `\"mult\"` 表示,该表达式总是包含两个表达式 `e1`、e2,最终结果是 `e1` 表达式的值与 `e2` 表达式的值之 积 。\n* 在该题目中,变量名以小写字符开始,之后跟随 $0$ 个或多个小写字符或数字。为了方便,`\"add\"` ,`\"let\"` ,`\"mult\"` 会被定义为 `\"关键字\" ,不会用作变量名。\n* 最后,要说一下作用域的概念。计算变量名所对应的表达式时,在计算上下文中,首先检查最内层作用域(按括号计),然后按顺序依次检查外部作用域。测试用例中每一个表达式都是合法的。有关作用域的更多详细信息,请参阅示例。\n\n示例 1:\n\n```\n输入:expression = \"(let x 2 (mult x (let x 3 y 4 (add x y))))\"\n\n输出:14\n\n解释:\n计算表达式 (add x y), 在检查变量 x 值时,\n在变量的上下文中由最内层作用域依次向外检查。\n首先找到 x = 3, 所以此处的 x 值是 3 。\n```\n示例 2:\n```\n输入:expression = \"(let x 3 x 2 x)\"\n\n输出:2\n\n解释:let 语句中的赋值运算按顺序处理即可。\n```\n示例 3:\n```\n输入:expression = \"(let x 1 y 2 x (add x y) (add x y))\"\n\n输出:5\n\n解释:\n第一个 (add x y) 计算结果是 3,并且将此值赋给了 x 。 \n第二个 (add x y) 计算结果是 3 + 2 = 5 。\n```\n\n提示:\n* $1 <= expression.length <= 2000$\n* `exprssion` 中不含前导和尾随空格\n* `expressoin` 中的不同部分(`token`)之间用单个空格进行分隔\n* 答案和所有中间计算结果都符合 `32-bit` 整数范围", "solution": "### DFS 模拟\n\n今天身体不舒服,不写太详细,题目不难,大家结合代码看吧。\n\n设计函数 `int dfs(int l, int r, Map<String, Integer> map)`,代表计算 $s[l...r]$ 的结果,答案为 `dfs(0,n-1,map)`,其中 $n$ 为字符串的长度。\n\n根据传入的 $[l, r]$ 是否为表达式分情况讨论:\n\n* 若 $s[l] = ($,说明是表达式,此时从 $l$ 开始往后取,取到空格为止(假设位置为 `idx`),从而得到操作 `op`(其中 `op` 为 `let`、`add` 或 `mult` 三者之一),此时 `op` 对应参数为 $[idx + 1, r - 1]$,也就是需要跳过位置 $r$(即跳过 `op` 对应的 `)` 符号);\n\n    再根据 `op` 为何种操作进一步处理,我们设计一个「传入左端点找右端点」的函数 `int getRight(int left, int end)`,含义为从 `left` 出发,一直往右找(不超过 `end`),直到取得合法的「子表达式」或「对应的值」。\n\n    ```Java\n    // 对于 getRight 函数作用,给大家举个 🌰 理解吧,其实就是从 left 出发,找到合法的「子表达式」或「值」为止\n\n    // (let x 2 (mult x (let x 3 y 4 (add x y))))\n    //          a                               b\n    // 传入 a 返回 b,代表 [a, b) 表达式为 (mult x (let x 3 y 4 (add x y)))\n\n    // (let x 2 (mult x (let x 3 y 4 (add x y))))\n    //      ab\n    // 传入 a 返回 b,代表 [a, b) 表达式为 x\n    ```\n\n* 否则 $s[l...r]$ 不是表达式,通过判断 $s[l...r]$ 是否有被哈希表记录来得知结果:若在哈希表中有记录,结果为哈希表中的映射值,否则结果为本身所代表的数值。\n\n需要注意,根据「作用域」的定义,我们不能使用全局哈希表,而要在每一层递归时,传入 `clone` 出来的 `map`。\n\n代码:\n```Java\nclass Solution {\n    char[] cs;\n    String s;\n    public int evaluate(String _s) {\n        s = _s;\n        cs = s.toCharArray();\n        return dfs(0, cs.length - 1, new HashMap<>());\n    }\n    int dfs(int l, int r, Map<String, Integer> map) {\n        if (cs[l] == '(') {\n            int idx = l;\n            while (cs[idx] != ' ') idx++;\n            String op = s.substring(l + 1, idx);\n            r--;\n            if (op.equals(\"let\")) {\n                for (int i = idx + 1; i <= r; ) {\n                    int j = getRight(i, r);\n                    String key = s.substring(i, j);\n                    if (j >= r) return dfs(i, j - 1, new HashMap<>(map));\n                    j++; i = j;\n                    j = getRight(i, r);\n                    int value = dfs(i, j - 1, new HashMap<>(map));\n                    map.put(key, value);\n                    i = j + 1;\n                }\n                return -1; // never\n            } else {\n                int j = getRight(idx + 1, r);\n                int a = dfs(idx + 1, j - 1, new HashMap<>(map)), b = dfs(j + 1, r, new HashMap<>(map));\n                return op.equals(\"add\") ? a + b : a * b;\n            }\n        } else {\n            String cur = s.substring(l, r + 1);\n            if (map.containsKey(cur)) return map.get(cur);\n            return Integer.parseInt(cur);\n        }\n    }\n    int getRight(int left, int end) {\n        int right = left, score = 0;\n        while (right <= end) {\n            if (cs[right] == '(') {\n                score++; right++;\n            } else if (cs[right] == ')') {\n                score--; right++;\n            } else if (cs[right] == ' ') {\n                if (score == 0) break;\n                right++;\n            } else {\n                right++;\n            }\n        }\n        return right;\n    }\n}\n```\n* 时间复杂度:除对表达式进行递归划分以外,还存在对 `map` 的每层拷贝操作,复杂度为 $O(n^2)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.736` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/731-740/739. 每日温度（中等）.md", "url_title": "739. 每日温度", "url": "https://leetcode.cn/problems/daily-temperatures/solution/by-ac_oier-aj5k/", "difficulty": "中等", "tags": ["单调栈"], "question": "给定一个整数数组 `temperatures`,表示每天的温度,返回一个数组 `answer`,其中 `answer[i]` 是指对于第 `i` 天,下一个更高温度出现在几天后。如果气温在这之后都不会升高,请在该位置用 `0` 来代替。\n\n示例 1:\n```\n输入: temperatures = [73,74,75,71,69,72,76,73]\n\n输出: [1,1,4,2,1,1,0,0]\n```\n示例 2:\n```\n输入: temperatures = [30,40,50,60]\n\n输出: [1,1,1,0]\n```\n示例 3:\n```\n输入: temperatures = [30,60,90]\n\n输出: [1,1,0]\n```\n\n提示:\n* $1 <= temperatures.length <= 10^5$\n* $30 <= temperatures[i] <= 100$", "solution": "### 单调栈\n\n抽象题意为 : 求解给定序列中每个位置(右边)最近一个比其大的位置,可使用「单调栈」来进行求解。\n\n具体的,我们可以从前往后处理所有的 $temperatures[i]$,使用某类容器装载我们所有的「待更新」的位置(下标),假设当前处理到的是 $temperatures[i]$:\n\n* 若其比容器内的任意位置(下标)对应温度要低,其必然不能更新任何位置(下标),将其也加入容器尾部(此时我们发现,若有一个新的位置(下标)加入容器,其必然是当前所有待更新位置(下标)中的温度最低的,即容器内的温度单调递减);\n\n* 若其价格高于容器内的任一位置(下标)对应温度,其能够更新容器位置(下标)的答案,并且由于我们容器满足单调递减特性,我们必然能够从尾部开始取出待更新位置来进行更新答案,直到处理完成或遇到第一个无法更新位置。\n\n由于我们需要往尾部添加和取出元素,因此容器可使用「栈」。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] dailyTemperatures(int[] temperatures) {\n        int n = temperatures.length;\n        int[] ans = new int[n];\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            while (!d.isEmpty() && temperatures[d.peekLast()] < temperatures[i]) {\n                int idx = d.pollLast();\n                ans[idx] = i - idx;\n            }\n            d.addLast(i);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> dailyTemperatures(vector<int>& temperatures) {\n        int n = temperatures.size();\n        vector<int> ans(n);\n        deque<int> d;\n        for (int i = 0; i < n; i++) {\n            while (!d.empty() && temperatures[d.back()] < temperatures[i]) {\n                int idx = d.back();\n                ans[idx] = i - idx;\n                d.pop_back();\n            }\n            d.push_back(i);\n        }\n        return ans;\n    }\n};\n```\nPython3 代码:\n```Python\nclass Solution:\n    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:\n        n, he, ta = len(temperatures), 0, 0\n        ans, stk = [0] * n, [-1] * n\n        for i in range(n):\n            while he < ta and temperatures[stk[ta - 1]] < temperatures[i]:\n                ta -= 1\n                idx = stk[ta]\n                ans[idx] = i - idx\n            stk[ta] = i\n            ta += 1\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction dailyTemperatures(temperatures: number[]): number[] {\n    const n = temperatures.length\n    const ans = new Array<number>(n).fill(0)\n    const stk = new Array<number>(n).fill(-1)\n    let he = 0, ta = 0\n    for (let i = 0; i < n; i++) {\n        while (he < ta && temperatures[stk[ta - 1]] < temperatures[i]) {\n            const idx = stk[--ta]\n            ans[idx] = i - idx\n        }\n        stk[ta++] = i\n    }\n    return ans\n};\n```\n\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.739` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/731-740/740. 删除并获得点数（中等）.md", "url_title": "740. 删除并获得点数", "url": "https://leetcode-cn.com/problems/delete-and-earn/solution/gong-shui-san-xie-zhuan-huan-wei-xu-lie-6c9t0/", "difficulty": "中等", "tags": ["序列 DP"], "question": "给你一个整数数组 nums ,你可以对它进行一些操作。\n\n每次操作中,选择任意一个 nums[i] ,删除它并获得 nums[i] 的点数。之后,你必须删除 所有 等于 nums[i] - 1 和 nums[i] + 1 的元素。\n\n开始你拥有 0 个点数。返回你能通过这些操作获得的最大点数。\n\n示例 1:\n```\n输入:nums = [3,4,2]\n\n输出:6\n\n解释:\n删除 4 获得 4 个点数,因此 3 也被删除。\n之后,删除 2 获得 2 个点数。总共获得 6 个点数。\n```\n示例 2:\n```\n输入:nums = [2,2,3,3,3,4]\n\n输出:9\n\n解释:\n删除 3 获得 3 个点数,接着要删除两个 2 和 4 。\n之后,再次删除 3 获得 3 个点数,再次删除 3 获得 3 个点数。\n总共获得 9 个点数。\n```\n\n提示:\n* 1 <= nums.length <= 2 * $10^4$\n* 1 <= nums[i] <= $10^4$", "solution": "### 动态规划\n\n根据题意,当我们选择 $nums[i]$ 的时候,比 $nums[i]$ 大/小 一个单位的数都不能被选择。\n\n如果我们将数组排好序,从前往后处理,其实只需要考虑“当前数”与“前一个数”的「大小 & 选择」关系即可,这样处理完,显然每个数的「前一位/后一位」都会被考虑到。\n\n这样我们将问题转化为一个「序列 DP」问题(选择某个数,需要考虑前一个数的「大小/选择」状态)。\n\n**定义 $f[i][0]$ 代表数值为 $i$ 的数字「不选择」的最大价值;$f[i][1]$ 代表数值为 $i$ 的数字「选择」的最大价值。**\n\n为了方便,我们可以先对 $nums$ 中出现的所有数值进行计数,而且由于数据范围只有 $10^4$,我们可以直接使用数组 $cnts[]$ 进行计数:$cnts[x] = i$ 代表数值 $x$ 出现了 $i$ 次。\n\n**然后分别考虑一般性的 $f[i][0]$ 和 $f[i][1]$ 该如何计算:**\n\n* **$f[i][0]$:当数值 $i$ 不被选择,那么前一个数「可选/可不选」,在两者中取 $max$ 即可。转移方程为 $f[i][0] = \\max(f[i - 1][0], f[i - 1][1])$**\n* **$f[i][1]$:当数值 $i$ 被选,那么前一个数只能「不选」,同时为了总和最大数值 $i$ 要选就全部选完。转移方程为 $f[i][1] = f[i - 1][0] + i * cnts[i]$**\n\n代码:\n```Java\nclass Solution {\n    int[] cnts = new int[10009];\n    public int deleteAndEarn(int[] nums) {\n        int n = nums.length;\n        int max = 0;\n        for (int x : nums) {\n            cnts[x]++;\n            max = Math.max(max, x);\n        }\n        // f[i][0] 代表「不选」数值 i;f[i][1] 代表「选择」数值 i\n        int[][] f = new int[max + 1][2]; \n        for (int i = 1; i <= max; i++) {\n            f[i][1] = f[i - 1][0] + i * cnts[i];\n            f[i][0] = Math.max(f[i - 1][1], f[i - 1][0]);\n        }\n        return Math.max(f[max][0], f[max][1]);\n    }\n}\n```\n* 时间复杂度:遍历 $nums$ 进行计数和取最大值 $max$,复杂度为 $O(n)$;共有 $max * 2$ 个状态需要被转移,每个状态转移的复杂度为 $O(1)$。整体复杂度为 $O(n + max)$。 \n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.740` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/741-750/741. 摘樱桃（困难）.md", "url_title": "741. 摘樱桃", "url": "https://leetcode.cn/problems/cherry-pickup/solution/by-ac_oier-pz7i/", "difficulty": "困难", "tags": ["线性 DP"], "question": "一个$N \\times N$ 的网格( `grid`) 代表了一块樱桃地,每个格子由以下三种数字的一种来表示:\n\n* $0$ 表示这个格子是空的,所以你可以穿过它。\n* $1$ 表示这个格子里装着一个樱桃,你可以摘到樱桃然后穿过它。\n* $-1$ 表示这个格子里有荆棘,挡着你的路。\n\n你的任务是在遵守下列规则的情况下,尽可能的摘到最多樱桃:\n\n* 从位置 $(0, 0)$ 出发,最后到达 $(N-1, N-1)$ ,只能向下或向右走,并且只能穿越有效的格子(即只可以穿过值为 $0$ 或者 $1$ 的格子);\n* 当到达 $(N-1, N-1)$ 后,你要继续走,直到返回到 $(0, 0)$ ,只能向上或向左走,并且只能穿越有效的格子;\n* 当你经过一个格子且这个格子包含一个樱桃时,你将摘到樱桃并且这个格子会变成空的(值变为0);\n* 如果在 $(0, 0)$ 和 $(N-1, N-1)$ 之间不存在一条可经过的路径,则没有任何一个樱桃能被摘到。\n\n示例 1:\n```\n输入: grid =\n[[0, 1, -1],\n [1, 0, -1],\n [1, 1,  1]]\n\n输出: 5\n\n解释: \n玩家从(0,0)点出发,经过了向下走,向下走,向右走,向右走,到达了点(2, 2)。\n在这趟单程中,总共摘到了4颗樱桃,矩阵变成了[[0,1,-1],[0,0,-1],[0,0,0]]。\n接着,这名玩家向左走,向上走,向上走,向左走,返回了起始点,又摘到了1颗樱桃。\n在旅程中,总共摘到了5颗樱桃,这是可以摘到的最大值了。\n```\n\n说明:\n* `grid` 是一个 $N \\times N$ 的二维数组,N的取值范围是 $1 <= N <= 50$\n* 每一个 `grid[i][j]` 都是集合 `{-1, 0, 1}` 其中的一个数\n* 可以保证起点 `grid[0][0]` 和终点 `grid[N-1][N-1]` 的值都不会是 $-1$", "solution": "### 线性 DP\n\n为了方便,我们令 `grid` 为 `g`,同时调整矩阵横纵坐标从 $1$ 开始。\n\n原问题为先从左上角按照「只能往下 + 只能往右」的规则走到右下角,然后再按照「只能往上 + 只能往左」的规则走回左上角,途径的值为 $1$ 的格子得一分(只能得分一次,得分后置零),同时不能经过值为 $-1$ 的格子。\n\n其中第二趟的规则等价于按照第一趟的规则从左上角到右下角再走一遍,再结合每个位置的只能得分一次,可以将原问题等价于:两个点从左上角开始同时走,最终都走到右下角的最大得分。\n\n定义 $f[k][i1][i2]$ 为当前走了 $k$ 步(横纵坐标之和),且第一个点当前在第 $i1$ 行,第二点在第 $i2$ 行时的最大得分,最终答案为 $f[2n][n][n]$,同时有 $f[2][1][1] = g[0][0]$ 的起始状态。\n\n由于两个点是同时走(都走了 $k$ 步),结合「只能往下 + 只能往右」的规则,可直接算得第一个点所在的列为 $j1 = k - i1$,第二点所在的列为 $j2 = k - i2$。\n\n不失一般性考虑 $f[k][i1][i2]$ 该如何转移,两个点均有可能走行或走列,即有 $4$ 种前驱状态:$f[k - 1][i1 - 1][i2]$、$f[k - 1][i1 - 1][i2 - 1]$、$f[k - 1][i1][i2 - 1]$ 和 $f[k - 1][i1][i2]$,在四者中取最大值,同时当前位置 $(i1, j1)$ 和 $(i2, j2)$ 的得分需要被累加,假设两者得分别为 $A$ 和 $B$,若两个位置不重叠的话,可以同时累加,否则只能累加一次。\n\n一些细节:为了防止从值为 $-1$ 的格子进行转移影响正确性,我们需要先将所有 $f[k][i1][i2]$ 初始化为负无穷。\n\n代码:\n```Java\nclass Solution {\n    static int N = 55, INF = Integer.MIN_VALUE;\n    static int[][][] f = new int[2 * N][N][N];\n    public int cherryPickup(int[][] g) {\n        int n = g.length;\n        for (int k = 0; k <= 2 * n; k++) {\n            for (int i1 = 0; i1 <= n; i1++) {\n                for (int i2 = 0; i2 <= n; i2++) {\n                    f[k][i1][i2] = INF;\n                }\n            }\n        }\n        f[2][1][1] = g[0][0];\n        for (int k = 3; k <= 2 * n; k++) {\n            for (int i1 = 1; i1 <= n; i1++) {\n                for (int i2 = 1; i2 <= n; i2++) {\n                    int j1 = k - i1, j2 = k - i2;\n                    if (j1 <= 0 || j1 > n || j2 <= 0 || j2 > n) continue;\n                    int A = g[i1 - 1][j1 - 1], B = g[i2 - 1][j2 - 1];\n                    if (A == -1 || B == -1) continue;\n                    int a = f[k - 1][i1 - 1][i2], b = f[k - 1][i1 - 1][i2 - 1], c = f[k - 1][i1][i2 - 1], d = f[k - 1][i1][i2];\n                    int t = Math.max(Math.max(a, b), Math.max(c, d)) + A;\n                    if (i1 != i2) t += B;\n                    f[k][i1][i2] = t;\n                }\n            }\n        }\n        return f[2 * n][n][n] <= 0 ? 0 : f[2 * n][n][n];\n    }\n}\n```\n* 时间复杂度:状态数量级为 $n^3$,每个状态转移复杂度为 $O(1)$。整体复杂度为 $O(n^3)$\n* 空间复杂度:$O(n^3)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.741` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/741-750/743. 网络延迟时间（中等）.md", "url_title": "743. 网络延迟时间", "url": "https://leetcode-cn.com/problems/network-delay-time/solution/gong-shui-san-xie-yi-ti-wu-jie-wu-chong-oghpz/", "difficulty": "中等", "tags": ["最短路", "图", "优先队列(堆)"], "question": "有 $n$ 个网络节点,标记为 $1$ 到 $n$。\n\n给你一个列表 times,表示信号经过 有向 边的传递时间。 times[i] = (ui, vi, wi),其中 ui 是源节点,vi 是目标节点, wi 是一个信号从源节点传递到目标节点的时间。\n\n现在,从某个节点 K 发出一个信号。需要多久才能使所有节点都收到信号?如果不能使所有节点收到信号,返回 -1 。\n\n示例 1:\n\n```\n输入:times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2\n\n输出:2\n```\n示例 2:\n```\n输入:times = [[1,2,1]], n = 2, k = 1\n\n输出:1\n```\n示例 3:\n```\n输入:times = [[1,2,1]], n = 2, k = 2\n\n输出:-1\n```\n\n提示:\n* $1 <= k <= n <= 100$\n* $1 <= times.length <= 6000$\n* $times[i].length == 3$\n* $1 <= u_i, v_i <= n$\n* $u_i != v_i$\n* $0 <= w_i <= 100$\n* 所有 $(u_i, v_i)$ 对都 互不相同(即,不含重复边)", "solution": "### 基本分析\n\n**为了方便,我们约定 $n$ 为点数,$m$ 为边数。**\n\n根据题意,首先 $n$ 的数据范围只有 $100$,$m$ 的数据范围为 $6000$,使用「邻接表」或「邻接矩阵」来存图都可以。\n\n同时求的是「**从 $k$ 点出发,所有点都被访问到的最短时间**」,将问题转换一下其实就是求「**从 $k$ 点出发,到其他点 $x$ 的最短距离的最大值**」。\n\n---\n\n### 存图方式\n\n在开始讲解最短路之前,我们先来学习三种「存图」方式。\n\n#### 邻接矩阵\n\n这是一种使用二维矩阵来进行存图的方式。\n\n适用于边数较多的**稠密图**使用,当边数量接近点的数量的平方,即 $m \\approx n^2$ 时,可定义为**稠密图**。\n\n```Java\n// 邻接矩阵数组:w[a][b] = c 代表从 a 到 b 有权重为 c 的边\nint[][] w = new int[N][N];\n\n// 加边操作\nvoid add(int a, int b, int c) {\n    w[a][b] = c;\n}\n```\n#### 邻接表\n\n这也是一种在图论中十分常见的存图方式,与数组存储单链表的实现一致(头插法)。\n\n这种存图方式又叫**链式前向星存图**。\n\n适用于边数较少的**稀疏图**使用,当边数量接近点的数量,即 $m \\approx n$ 时,可定义为**稀疏图**。\n\n```Java\nint[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];\nint idx;\n\nvoid add(int a, int b, int c) {\n    e[idx] = b;\n    ne[idx] = he[a];\n    he[a] = idx;\n    w[idx] = c;\n    idx++;\n}\n```\n\n首先 `idx` 是用来对边进行编号的,然后对存图用到的几个数组作简单解释:\n* `he` 数组:存储是某个节点所对应的边的集合(链表)的头结点;\n* `e`  数组:由于访问某一条边指向的节点;\n* `ne` 数组:由于是以链表的形式进行存边,该数组就是用于找到下一条边;\n* `w`  数组:用于记录某条边的权重为多少。\n\n因此当我们想要遍历所有由 `a` 点发出的边时,可以使用如下方式:\n\n```Java\nfor (int i = he[a]; i != -1; i = ne[i]) {\n    int b = e[i], c = w[i]; // 存在由 a 指向 b 的边,权重为 c\n}\n```\n\n#### 类\n\n这是一种最简单,但是相比上述两种存图方式,使用得较少的存图方式。\n\n只有当我们需要确保某个操作复杂度严格为 $O(m)$ 时,才会考虑使用。\n\n具体的,我们建立一个类来记录有向边信息:\n\n```Java\nclass Edge {\n    // 代表从 a 到 b 有一条权重为 c 的边\n    int a, b, c;\n    Edge(int _a, int _b, int _c) {\n        a = _a; b = _b; c = _c;\n    }\n}\n```\n\n通常我们会使用 List 存起所有的边对象,并在需要遍历所有边的时候,进行遍历:\n\n```Java\nList<Edge> es = new ArrayList<>();\n\n...\n\nfor (Edge e : es) {\n    ...\n}\n```\n\n---\n\n### Floyd(邻接矩阵)\n\n根据「基本分析」,我们可以使用复杂度为 $O(n^3)$ 的「多源汇最短路」算法 Floyd 算法进行求解,同时使用「邻接矩阵」来进行存图。\n\n此时计算量约为 $10^6$,可以过。\n\n跑一遍 Floyd,可以得到「**从任意起点出发,到达任意起点的最短距离**」。然后从所有 $w[k][x]$ 中取 $max$ 即是「**从 $k$ 点出发,到其他点 $x$ 的最短距离的最大值**」。\n\n代码:\n```Java\nclass Solution {\n    int N = 110, M = 6010;\n    // 邻接矩阵数组:w[a][b] = c 代表从 a 到 b 有权重为 c 的边\n    int[][] w = new int[N][N];\n    int INF = 0x3f3f3f3f;\n    int n, k;\n    public int networkDelayTime(int[][] ts, int _n, int _k) {\n        n = _n; k = _k;\n        // 初始化邻接矩阵\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= n; j++) {\n                w[i][j] = w[j][i] = i == j ? 0 : INF;\n            }\n        }\n        // 存图\n        for (int[] t : ts) {\n            int u = t[0], v = t[1], c = t[2];\n            w[u][v] = c;\n        }\n        // 最短路\n        floyd();\n        // 遍历答案\n        int ans = 0;\n        for (int i = 1; i <= n; i++) {\n            ans = Math.max(ans, w[k][i]);\n        }\n        return ans >= INF / 2 ? -1 : ans;\n    }\n    void floyd() {\n        // floyd 基本流程为三层循环:\n        // 枚举中转点 - 枚举起点 - 枚举终点 - 松弛操作        \n        for (int p = 1; p <= n; p++) {\n            for (int i = 1; i <= n; i++) {\n                for (int j = 1; j <= n; j++) {\n                    w[i][j] = Math.min(w[i][j], w[i][p] + w[p][j]);\n                }\n            }\n        }\n    }\n}\n```\n* 时间复杂度:$O(n^3)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 朴素 Dijkstra(邻接矩阵)\n\n同理,我们可以使用复杂度为 $O(n^2)$ 的「单源最短路」算法朴素 Dijkstra 算法进行求解,同时使用「邻接矩阵」来进行存图。\n\n根据题意,$k$ 点作为源点,跑一遍 Dijkstra 我们可以得到从源点 $k$ 到其他点 $x$ 的最短距离,再从所有最短路中取 $max$ 即是「**从 $k$ 点出发,到其他点 $x$ 的最短距离的最大值**」。\n\n朴素 Dijkstra 复杂度为 $O(n^2)$,可以过。\n\n代码:\n```Java\nclass Solution {\n    int N = 110, M = 6010;\n    // 邻接矩阵数组:w[a][b] = c 代表从 a 到 b 有权重为 c 的边\n    int[][] w = new int[N][N];\n    // dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y\n    int[] dist = new int[N];\n    // 记录哪些点已经被更新过\n    boolean[] vis = new boolean[N];\n    int INF = 0x3f3f3f3f;\n    int n, k;\n    public int networkDelayTime(int[][] ts, int _n, int _k) {\n        n = _n; k = _k;\n        // 初始化邻接矩阵\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= n; j++) {\n                w[i][j] = w[j][i] = i == j ? 0 : INF;\n            }\n        }\n        // 存图\n        for (int[] t : ts) {\n            int u = t[0], v = t[1], c = t[2];\n            w[u][v] = c;\n        }\n        // 最短路\n        dijkstra();\n        // 遍历答案\n        int ans = 0;\n        for (int i = 1; i <= n; i++) {\n            ans = Math.max(ans, dist[i]);\n        }\n        return ans > INF / 2 ? -1 : ans;\n    }\n    void dijkstra() {\n        // 起始先将所有的点标记为「未更新」和「距离为正无穷」\n        Arrays.fill(vis, false);\n        Arrays.fill(dist, INF);\n        // 只有起点最短距离为 0\n        dist[k] = 0;\n        // 迭代 n 次\n        for (int p = 1; p <= n; p++) {\n            // 每次找到「最短距离最小」且「未被更新」的点 t\n            int t = -1;\n            for (int i = 1; i <= n; i++) {\n                if (!vis[i] && (t == -1 || dist[i] < dist[t])) t = i;\n            }\n            // 标记点 t 为已更新\n            vis[t] = true;\n            // 用点 t 的「最小距离」更新其他点\n            for (int i = 1; i <= n; i++) {\n                dist[i] = Math.min(dist[i], dist[t] + w[t][i]);\n            }\n        }\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 堆优化 Dijkstra(邻接表)\n\n由于边数据范围不算大,我们还可以使用复杂度为 $O(m\\log{n})$ 的堆优化 Dijkstra 算法进行求解。\n\n堆优化 Dijkstra 算法与朴素 Dijkstra 都是「单源最短路」算法。\n\n跑一遍堆优化 Dijkstra 算法求最短路,再从所有最短路中取 $max$ 即是「**从 $k$ 点出发,到其他点 $x$ 的最短距离的最大值**」。\n\n此时算法复杂度为 $O(m\\log{n})$,可以过。\n\n代码:\n```Java\nclass Solution {\n    int N = 110, M = 6010;\n    // 邻接表\n    int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];\n    // dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y\n    int[] dist = new int[N];\n    // 记录哪些点已经被更新过\n    boolean[] vis = new boolean[N];\n    int n, k, idx;\n    int INF = 0x3f3f3f3f;\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx;\n        w[idx] = c;\n        idx++;\n    }\n    public int networkDelayTime(int[][] ts, int _n, int _k) {\n        n = _n; k = _k;\n        // 初始化链表头\n        Arrays.fill(he, -1);\n        // 存图\n        for (int[] t : ts) {\n            int u = t[0], v = t[1], c = t[2];\n            add(u, v, c);\n        }\n        // 最短路\n        dijkstra();\n        // 遍历答案\n        int ans = 0;\n        for (int i = 1; i <= n; i++) {\n            ans = Math.max(ans, dist[i]);\n        }\n        return ans > INF / 2 ? -1 : ans;\n    }\n    void dijkstra() {\n        // 起始先将所有的点标记为「未更新」和「距离为正无穷」\n        Arrays.fill(vis, false);\n        Arrays.fill(dist, INF);\n        // 只有起点最短距离为 0\n        dist[k] = 0;\n        // 使用「优先队列」存储所有可用于更新的点\n        // 以 (点编号, 到起点的距离) 进行存储,优先弹出「最短距离」较小的点\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[1]-b[1]);\n        q.add(new int[]{k, 0});\n        while (!q.isEmpty()) {\n            // 每次从「优先队列」中弹出\n            int[] poll = q.poll();\n            int id = poll[0], step = poll[1];\n            // 如果弹出的点被标记「已更新」,则跳过\n            if (vis[id]) continue;\n            // 标记该点「已更新」,并使用该点更新其他点的「最短距离」\n            vis[id] = true;\n            for (int i = he[id]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (dist[j] > dist[id] + w[i]) {\n                    dist[j] = dist[id] + w[i];\n                    q.add(new int[]{j, dist[j]});\n                }\n            }\n        }\n    }\n}\n```\n* 时间复杂度:$O(m\\log{n} + n)$\n* 空间复杂度:$O(m)$\n\n---\n\n### Bellman Ford(类 & 邻接表)\n\n虽然题目规定了不存在「负权边」,但我们仍然可以使用可以在「负权图中求最短路」的 Bellman Ford 进行求解,该算法也是「单源最短路」算法,复杂度为 $O(n * m)$。\n\n通常为了确保 $O(n * m)$,可以单独建一个类代表边,将所有边存入集合中,在 $n$ 次松弛操作中直接对边集合进行遍历(代码见 $P1$)。\n\n由于本题边的数量级大于点的数量级,因此也能够继续使用「邻接表」的方式进行边的遍历,遍历所有边的复杂度的下界为 $O(n)$,上界可以确保不超过 $O(m)$(代码见 $P2$)。\n\n代码:\n```Java\nclass Solution {\n    class Edge {\n        int a, b, c;\n        Edge(int _a, int _b, int _c) {\n            a = _a; b = _b; c = _c;\n        }\n    }\n    int N = 110, M = 6010;\n    // dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y\n    int[] dist = new int[N];\n    int INF = 0x3f3f3f3f;\n    int n, m, k;\n    // 使用类进行存边\n    List<Edge> es = new ArrayList<>();\n    public int networkDelayTime(int[][] ts, int _n, int _k) {\n        n = _n; k = _k;\n        m = ts.length;\n        // 存图\n        for (int[] t : ts) {\n            int u = t[0], v = t[1], c = t[2];\n            es.add(new Edge(u, v, c));\n        }\n        // 最短路\n        bf();\n        // 遍历答案\n        int ans = 0;\n        for (int i = 1; i <= n; i++) {\n            ans = Math.max(ans, dist[i]);\n        }\n        return ans > INF / 2 ? -1 : ans;\n    }\n    void bf() {\n        // 起始先将所有的点标记为「距离为正无穷」\n        Arrays.fill(dist, INF);\n        // 只有起点最短距离为 0\n        dist[k] = 0;\n        // 迭代 n 次\n        for (int p = 1; p <= n; p++) {\n            int[] prev = dist.clone();\n            // 每次都使用上一次迭代的结果,执行松弛操作\n            for (Edge e : es) {\n                int a = e.a, b = e.b, c = e.c;\n                dist[b] = Math.min(dist[b], prev[a] + c);\n            }\n        }\n    }\n}\n```\n```Java\nclass Solution {\n    int N = 110, M = 6010;\n    // 邻接表\n    int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];\n    // dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y\n    int[] dist = new int[N];\n    int INF = 0x3f3f3f3f;\n    int n, m, k, idx;\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx;\n        w[idx] = c;\n        idx++;\n    }\n    public int networkDelayTime(int[][] ts, int _n, int _k) {\n        n = _n; k = _k;\n        m = ts.length;\n        // 初始化链表头\n        Arrays.fill(he, -1);\n        // 存图\n        for (int[] t : ts) {\n            int u = t[0], v = t[1], c = t[2];\n            add(u, v, c);\n        }\n        // 最短路\n        bf();\n        // 遍历答案\n        int ans = 0;\n        for (int i = 1; i <= n; i++) {\n            ans = Math.max(ans, dist[i]);\n        }\n        return ans > INF / 2 ? -1 : ans;\n    }\n    void bf() {\n        // 起始先将所有的点标记为「距离为正无穷」\n        Arrays.fill(dist, INF);\n        // 只有起点最短距离为 0\n        dist[k] = 0;\n        // 迭代 n 次\n        for (int p = 1; p <= n; p++) {\n            int[] prev = dist.clone();\n            // 每次都使用上一次迭代的结果,执行松弛操作\n            for (int a = 1; a <= n; a++) {\n                for (int i = he[a]; i != -1; i = ne[i]) {\n                    int b = e[i];\n                    dist[b] = Math.min(dist[b], prev[a] + w[i]);\n                }\n            }\n        }\n    }\n}\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(m)$\n\n---\n\n### SPFA(邻接表)\n\nSPFA 是对 Bellman Ford 的优化实现,可以使用队列进行优化,也可以使用栈进行优化。\n\n通常情况下复杂度为 $O(k*m)$,$k$ 一般为 $4$ 到 $5$,最坏情况下仍为 $O(n * m)$,当数据为网格图时,复杂度会从 $O(k*m)$ 退化为 $O(n*m)$。\n\n代码:\n```Java\nclass Solution {\n    int N = 110, M = 6010;\n    // 邻接表\n    int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];\n    // dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y\n    int[] dist = new int[N];\n    // 记录哪一个点「已在队列」中\n    boolean[] vis = new boolean[N];\n    int INF = 0x3f3f3f3f;\n    int n, k, idx;\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx;\n        w[idx] = c;\n        idx++;\n    }\n    public int networkDelayTime(int[][] ts, int _n, int _k) {\n        n = _n; k = _k;\n        // 初始化链表头\n        Arrays.fill(he, -1);\n        // 存图\n        for (int[] t : ts) {\n            int u = t[0], v = t[1], c = t[2];\n            add(u, v, c);\n        }\n        // 最短路\n        spfa();\n        // 遍历答案\n        int ans = 0;\n        for (int i = 1; i <= n; i++) {\n            ans = Math.max(ans, dist[i]);\n        }\n        return ans > INF / 2 ? -1 : ans;\n    }\n    void spfa() {\n        // 起始先将所有的点标记为「未入队」和「距离为正无穷」\n        Arrays.fill(vis, false);\n        Arrays.fill(dist, INF);\n        // 只有起点最短距离为 0\n        dist[k] = 0;\n        // 使用「双端队列」存储,存储的是点编号\n        Deque<Integer> d = new ArrayDeque<>();\n        // 将「源点/起点」进行入队,并标记「已入队」\n        d.addLast(k);\n        vis[k] = true;\n        while (!d.isEmpty()) {\n            // 每次从「双端队列」中取出,并标记「未入队」\n            int poll = d.pollFirst();\n            vis[poll] = false;\n            // 尝试使用该点,更新其他点的最短距离\n            // 如果更新的点,本身「未入队」则加入队列中,并标记「已入队」\n            for (int i = he[poll]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (dist[j] > dist[poll] + w[i]) {\n                    dist[j] = dist[poll] + w[i];\n                    if (vis[j]) continue;\n                    d.addLast(j);\n                    vis[j] = true;\n                }\n            }\n        }\n    }\n}\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.743` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/741-750/744. 寻找比目标字母大的最小字母（简单）.md", "url_title": "744. 寻找比目标字母大的最小字母", "url": "https://leetcode-cn.com/problems/find-smallest-letter-greater-than-target/solution/by-ac_oier-to07/", "difficulty": "简单", "tags": ["二分"], "question": "给你一个排序后的字符列表 `letters`,列表中只包含小写英文字母。另给出一个目标字母 `target`,请你寻找在这一有序列表里比目标字母大的最小字母。\n\n在比较时,字母是依序循环出现的。举个例子:\n\n如果目标字母 `target = 'z'` 并且字符列表为 `letters = ['a', 'b']`,则答案返回 `'a'`\n\n示例 1:\n```\n输入: letters = [\"c\", \"f\", \"j\"],target = \"a\"\n\n输出: \"c\"\n```\n示例 2:\n```\n输入: letters = [\"c\",\"f\",\"j\"], target = \"c\"\n\n输出: \"f\"\n```\n示例 3:\n```\n输入: letters = [\"c\",\"f\",\"j\"], target = \"d\"\n\n输出: \"f\"\n```\n\n提示:\n* $2 <= letters.length <= 10^4$\n* $letters[i]$ 是一个小写字母\n* $letters$ 按非递减顺序排序\n* $letters$ 最少包含两个不同的字母\n* $target$ 是一个小写字母", "solution": "### 二分\n\n给定的数组「有序」,找到比 $target$ 大的最小字母,容易想到二分。\n\n唯一需要注意的是,二分结束后需要再次 `check`,如果不满足,则取数组首位元素。\n\n代码:\n```Java\nclass Solution {\n    public char nextGreatestLetter(char[] letters, char target) {\n        int n = letters.length;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (letters[mid] > target) r = mid;\n            else l = mid + 1;\n        }\n        return letters[r] > target ? letters[r] : letters[0];\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.744` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/741-750/745. 前缀和后缀搜索（困难）.md", "url_title": "745. 前缀和后缀搜索", "url": "https://leetcode.cn/problems/prefix-and-suffix-search/solution/by-ac_oier-ayej/", "difficulty": "困难", "tags": ["字典树"], "question": "设计一个包含一些单词的特殊词典,并能够通过前缀和后缀来检索单词。\n\n实现 `WordFilter` 类:\n\n* `WordFilter(string[] words)` 使用词典中的单词 `words` 初始化对象。\n* `f(string pref, string suff)` 返回词典中具有前缀 `prefix` 和后缀 `suff` 的单词的下标。如果存在不止一个满足要求的下标,返回其中 最大的下标 。如果不存在这样的单词,返回 $-1$ 。\n\n示例:\n```\n输入\n[\"WordFilter\", \"f\"]\n[[[\"apple\"]], [\"a\", \"e\"]]\n\n输出\n[null, 0]\n\n解释\nWordFilter wordFilter = new WordFilter([\"apple\"]);\nwordFilter.f(\"a\", \"e\"); // 返回 0 ,因为下标为 0 的单词:前缀 prefix = \"a\" 且 后缀 suff = \"e\" 。\n```\n提示:\n* $1 <= words.length <= 10^4$\n* $1 <= words[i].length <= 7$\n* $1 <= pref.length, suff.length <= 7$\n* `words[i]`、`pref` 和 `suff` 仅由小写英文字母组成\n* 最多对函数 `f` 执行 $10^4$ 次调用", "solution": "### 基本分析\n\n为了方便,我们令 `words` 为 `ss`,令 `pref` 和 `suff` 分别为 `a` 和 `b`。\n\n搜索某个前缀(后缀可看做是反方向的前缀)容易想到字典树,但单词长度数据范围只有 $7$,十分具有迷惑性,使用暴力做法最坏情况下会扫描所有的 $ss[i]$,不考虑任何的剪枝操作的话,计算量也才为 $2 \\times \\ 7 \\times 1e4 = 1.4 \\times 10^5$,按道理是完全可以过的。\n\n但不要忘记 LC 是一个具有「设定每个样例时长,同时又有总时长」这样奇怪机制的 OJ。\n\n---\n\n### 暴力(TLE or 双百)\n\n于是有了 `Java` 总时间超时,`TypeScripe` 双百的结果(应该是 `TypeScript` 提交不多,同时设限宽松的原因):\n\nJava 代码:\n```Java\nclass WordFilter {\n    String[] ss;\n    public WordFilter(String[] words) {\n        ss = words;\n    }\n    public int f(String a, String b) {\n        int n = a.length(), m = b.length();\n        for (int k = ss.length - 1; k >= 0; k--) {\n            String cur = ss[k];\n            int len = cur.length();\n            if (len < n || len < m) continue;\n            boolean ok = true;\n            for (int i = 0; i < n && ok; i++) {\n                if (cur.charAt(i) != a.charAt(i)) ok = false;\n            }\n            for (int i = 0; i < m && ok; i++) {\n                if (cur.charAt(len - 1 - i) != b.charAt(m - 1 - i)) ok = false;\n            }\n            if (ok) return k;\n        }\n        return -1;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nclass WordFilter {\n    ss: string[]\n    constructor(words: string[]) {\n        this.ss = words\n    }\n    f(a: string, b: string): number {\n        const n = a.length, m = b.length\n        for (let k = this.ss.length - 1; k >= 0; k--) {\n            const cur = this.ss[k]\n            const len = cur.length\n            if (len < n || len < m) continue\n            let ok = true\n            for (let i = 0; i < n && ok; i++) {\n                if (cur[i] != a[i]) ok = false\n            }\n            for (let i = m - 1; i >= 0; i--) {\n                if (cur[len - 1 - i] != b[m - 1 - i]) ok = false\n            }\n            if (ok) return k\n        }\n        return -1\n    }\n}\n```\n* 时间复杂度:初始化操作复杂度为 $O(1)$,检索操作复杂度为 $O(\\sum_{i = 0}^{n - 1} ss[i].length)$\n* 空间复杂度:$O(\\sum_{i = 0}^{n - 1} ss[i].length)$\n\n---\n\n### Trie\n\n使用字典树优化检索过程也是容易的,分别使用两棵 `Trie` 树来记录 $ss[i]$ 的前后缀,即正着存到 `tr1` 中,反着存到 `Tr2` 中。\n\n> 还不了解 `Trie` 的同学可以先看前置 🧀:[【设计数据结构】实现 Trie (前缀树)](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488490&idx=1&sn=db2998cb0e5f08684ee1b6009b974089)\n前置 🧀 通过图解形式讲解了 `Trie` 的结构与原理,以及提供了两种实现 `Trie` 的方式\n\n同时对于字典树的每个节点,我们使用数组 `idxs` 记录经过该节点的字符串 $ss[i]$ 所在 `ss` 中的下标 $i$,若某个字典树节点的索引数组 `tr.idxs` 为 $[a_1, a_2, ..., a_k]$ 则代表「从根节点到 `tr` 节点所对应的字符串」为 $ss[a_1], ss[a_2], ..., ss[a_k]$ 的前缀。\n\n这样我们可以即可在扫描前后缀 `a` 和 `b` 时,得到对应的候选下标列表 `l1` 和 `l2`,由于我们将 $ss[i]$ 添加到两棵 `tr` 中是按照下标「从小到大」进行,因此我们使用「双指针」算法分别从 `l1` 和 `l2` 结尾往后找到第一个共同元素即是答案(满足条件的最大下标)。\n\n> 使用 `Trie` 优化后,`Java` 从 `TLE` 到 `AC`,`TypeScript` 耗时为原本的 $\\frac{1}{7}$ :\n\nJava 代码:\n```Java\nclass WordFilter {\n    class TrieNode {\n        TrieNode[] tns = new TrieNode[26];\n        List<Integer> idxs = new ArrayList<>();\n    }\n    void add(TrieNode p, String s, int idx, boolean isTurn) {\n        int n = s.length();\n        p.idxs.add(idx);\n        for (int i = isTurn ? n - 1 : 0; i >= 0 && i < n; i += isTurn ? -1 : 1) {\n            int u = s.charAt(i) - 'a';\n            if (p.tns[u] == null) p.tns[u] = new TrieNode();\n            p = p.tns[u];\n            p.idxs.add(idx);\n        }\n    }\n    int query(String a, String b) {\n        int n = a.length(), m = b.length();\n        TrieNode p = tr1;\n        for (int i = 0; i < n; i++) {\n            int u = a.charAt(i) - 'a';\n            if (p.tns[u] == null) return -1;\n            p = p.tns[u];\n        }\n        List<Integer> l1 = p.idxs;\n        p = tr2;\n        for (int i = m - 1; i >= 0; i--) {\n            int u = b.charAt(i) - 'a';\n            if (p.tns[u] == null) return -1;\n            p = p.tns[u];\n        }\n        List<Integer> l2 = p.idxs;\n        n = l1.size(); m = l2.size();\n        for (int i = n - 1, j = m - 1; i >= 0 && j >= 0; ) {\n            if (l1.get(i) > l2.get(j)) i--;\n            else if (l1.get(i) < l2.get(j)) j--;\n            else return l1.get(i);\n        }\n        return -1;\n    }\n    TrieNode tr1 = new TrieNode(), tr2 = new TrieNode();\n    public WordFilter(String[] ss) {\n        int n = ss.length;\n        for (int i = 0; i < n; i++) {\n            add(tr1, ss[i], i, false);\n            add(tr2, ss[i], i, true);\n        }\n    }\n    public int f(String a, String b) {\n        return query(a, b);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nclass TrieNode {\n    tns: TrieNode[] = new Array<TrieNode>()\n    idxs: number[] = new Array<number>()\n}\nclass WordFilter {\n    add(p: TrieNode, s: string, idx: number, isTurn: boolean): void {\n        const n = s.length\n        p.idxs.push(idx)\n        for (let i = isTurn ? n - 1 : 0; i >= 0 && i < n; i += isTurn ? -1 : 1) {\n            const u = s.charCodeAt(i) - 'a'.charCodeAt(0)\n            if (p.tns[u] == null) p.tns[u] = new TrieNode()\n            p = p.tns[u]\n            p.idxs.push(idx)\n        }\n    }\n    query(a: string, b: string): number {\n        let n = a.length, m = b.length\n        let p = this.tr1\n        for (let i = 0; i < n; i++) {\n            const u = a.charCodeAt(i) - 'a'.charCodeAt(0)\n            if (p.tns[u] == null) return -1\n            p = p.tns[u]\n        }\n        const l1 = p.idxs\n        p = this.tr2\n        for (let i = m - 1; i >= 0; i--) {\n            const u = b.charCodeAt(i) - 'a'.charCodeAt(0)\n            if (p.tns[u] == null) return -1\n            p = p.tns[u]\n        }\n        const l2 = p.idxs\n        n = l1.length; m = l2.length\n        for (let i = n - 1, j = m - 1; i >= 0 && j >= 0; ) {\n            if (l1[i] < l2[j]) j--\n            else if (l1[i] > l2[j]) i--\n            else return l1[i]\n        }\n        return -1\n    }\n    tr1: TrieNode = new TrieNode()\n    tr2: TrieNode = new TrieNode()\n    constructor(ss: string[]) {\n        for (let i = 0; i < ss.length; i++) {\n            this.add(this.tr1, ss[i], i, false)\n            this.add(this.tr2, ss[i], i, true)\n        }\n    }\n    f(a: string, b: string): number {\n        return this.query(a, b)\n    }\n}\n```\nC++ 代码:\n```C++\nclass WordFilter {\npublic:\n    struct TrieNode {\n        TrieNode* tns[26] {nullptr};\n        vector<int> idxs;\n    };\n    \n    void add(TrieNode* p, const string& s, int idx, bool isTurn) {\n        int n = s.size();\n        p->idxs.push_back(idx);\n        for(int i = isTurn ? n - 1 : 0; i >= 0 && i < n; i += isTurn ? -1 : 1) {\n            int u = s[i] - 'a';\n            if(p->tns[u] == nullptr) p->tns[u] = new TrieNode();\n            p = p->tns[u];\n            p->idxs.push_back(idx);\n        }\n    }\n    \n    int query(const string& a, const string& b) {\n        int n = a.size(), m = b.size();\n        auto p = tr1;\n        for(int i = 0; i < n; i++) {\n            int u = a[i] - 'a';\n            if(p->tns[u] == nullptr) return -1;\n            p = p->tns[u];\n        }\n        vector<int>& l1 = p->idxs;\n        p = tr2;\n        for(int i = m - 1; i >= 0; i--) {\n            int u = b[i] - 'a';\n            if(p->tns[u] == nullptr) return -1;\n            p = p->tns[u];\n        }\n        vector<int>& l2 = p->idxs;\n        n = l1.size(), m = l2.size();\n        for(int i = n - 1, j = m - 1; i >= 0 && j >= 0; ) {\n            if(l1[i] > l2[j]) i--;\n            else if(l1[i] < l2[j]) j--;\n            else return l1[i];\n        }\n        return -1;\n    }\n    \n    TrieNode* tr1 = new TrieNode, *tr2 = new TrieNode;\n    WordFilter(vector<string>& ss) {\n        int n = ss.size();\n        for(int i = 0; i < n; i++) {\n            add(tr1, ss[i], i, false);\n            add(tr2, ss[i], i, true);\n        }\n    }\n    \n    int f(string a, string b) {\n        return query(a, b);\n    }\n};\n```\n* 时间复杂度:初始化操作复杂度为 $O(\\sum_{i = 0}^{n - 1} ss[i].length)$,检索过程复杂度为 $O(a + b + n)$,其中 $a = b = 7$ 为前后缀的最大长度,$n = 1e4$ 为初始化数组长度,代表最多有 $n$ 个候选下标(注意:这里的 $n$ 只是粗略分析,实际上如果候选集长度越大的话,说明两个候选集是重合度是越高的,从后往前找的过程是越快结束的,可以通过方程算出一个双指针的理论最大比较次数 $k$,如果要将 $n$ 卡满成 $1e4$ 的话,需要将两个候选集设计成交替下标,此时 `f` 如果仍是 $1e4$ 次调用的话,必然会面临大量的重复查询,可通过引入 `map` 记录查询次数来进行优化)\n* 空间复杂度:$O(\\sum_{i = 0}^{n - 1} ss[i].length)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.745` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/741-750/747. 至少是其他数字两倍的最大数（简单）.md", "url_title": "747. 至少是其他数字两倍的最大数", "url": "https://leetcode-cn.com/problems/largest-number-at-least-twice-of-others/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-8179/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个整数数组 $nums$ ,其中总是存在 **唯一的** 一个最大整数 。\n\n请你找出数组中的最大元素并检查它是否 至少是数组中每个其他数字的两倍 。\n\n如果是,则返回 **最大元素的下标** ,否则返回 $-1$ 。\n\n示例 1:\n```\n输入:nums = [3,6,1,0]\n\n输出:1\n\n解释:6 是最大的整数,对于数组中的其他整数,6 大于数组中其他元素的两倍。6 的下标是 1 ,所以返回 1 。\n```\n\n示例 2:\n```\n输入:nums = [1,2,3,4]\n输出:-1\n解释:4 没有超过 3 的两倍大,所以返回 -1 。\n```\n示例 3:\n```\n输入:nums = [1]\n\n输出:0\n\n解释:因为不存在其他数字,所以认为现有数字 1 至少是其他数字的两倍。\n```\n\n提示:\n* $1 <= nums.length <= 50$\n* $0 <= nums[i] <= 100$\n* $nums$ 中的最大元素是唯一的", "solution": "### 模拟\n\n根据题意进行模拟即可,遍历过程中维护最大值和次大值的下标,最后判断最大值是否至少为次大值两倍。\n\n然后?今天属于圆梦了?(这真的只是他们的日常可爱 🤣\n\n**代码(感谢 [@5cm/s 🌸](/u/megurine/)、[@Benhao](/u/himymben/) 和 [@Qian](/u/qian2/) 几位总提供的其他语言版本 🤣 🤣 ):**\n```Java\nclass Solution {\n    public int dominantIndex(int[] nums) {\n        int n = nums.length;\n        if (n == 1) return 0;\n        int a = -1, b = 0;\n        for (int i = 1; i < n; i++) {\n            if (nums[i] > nums[b]) {\n                a = b; b = i;\n            } else if (a == -1 || nums[i] > nums[a]) {\n                a = i;\n            }\n        }\n        return nums[b] >= nums[a] * 2 ? b : -1;\n    }\n}\n```\n-\n```Python\nclass Solution(object):\n    def dominantIndex(self, nums):\n        n = len(nums)\n        if n == 1:\n            return 0\n        a, b = -1, 0\n        for i in range(1, n):\n            if nums[i] > nums[b]:\n                a, b = b, i\n            elif a == -1 or nums[i] > nums[a]:\n                a = i\n        return b if nums[b] >= nums[a] * 2 else -1\n```\n-\n```Python\nclass Solution:\n    def dominantIndex(self, nums: List[int]) -> int:\n        n = len(nums)\n        if n == 1:\n            return 0\n        a, b = -1, 0\n        for i in range(1, n):\n            if nums[i] > nums[b]:\n                a, b = b, i\n            elif a == -1 or nums[i] > nums[a]:\n                a = i\n        return b if nums[b] >= nums[a] * 2 else -1\n```\n-\n```Go\nfunc dominantIndex(nums []int) int {\n    n := len(nums)\n    if n == 1{\n        return 0\n    }\n    a, b := -1, 0\n    for i := 1; i < n; i++ {\n        if nums[i] > nums[b] {\n            a, b = b, i\n        } else if a == -1 || nums[i] > nums[a] {\n            a = i\n        }\n    }\n    if nums[b] >= nums[a] * 2{\n        return b\n    }\n    return -1\n}\n```\n-\n```Rust\nimpl Solution {\n    pub fn dominant_index(nums: Vec<i32>) -> i32 {\n        let mut mx = 0;\n        let mut ans = -1 as i32;\n        for i in 0..nums.len() {\n            if nums[i] >= mx * 2 {\n                ans = i as i32;\n            }\n            else if nums[i] * 2 > mx {\n                ans = -1 as i32;\n            }\n            if nums[i] > mx {\n                mx = nums[i];\n            }\n        }\n        ans\n    }\n}\n```\n-\n```C\nint dominantIndex(int* nums, int numsSize){\n    if(numsSize == 1) return 0;\n    int a = -1, b = 0;\n    for(int i = 1; i < numsSize; i++){\n        if (nums[i] > nums[b]) {\n            a = b; b = i;\n        } else if (a == -1 || nums[i] > nums[a]) {\n            a = i;\n        }\n    }\n    return nums[b] >= nums[a] * 2 ? b : -1;\n}\n```\n-\n```C#\npublic class Solution {\n    public int DominantIndex(int[] nums) {\n        int n = nums.Length;\n        if (n == 1) return 0;\n        int a = -1, b = 0;\n        for (int i = 1; i < n; i++) {\n            if (nums[i] > nums[b]) {\n                a = b; b = i;\n            } else if (a == -1 || nums[i] > nums[a]) {\n                a = i;\n            }\n        }\n        return nums[b] >= nums[a] * 2 ? b : -1;\n    }\n}\n```\n-\n```C++\nclass Solution {\npublic:\n    int dominantIndex(vector<int>& nums) {\n        int mx = 0, ans = -1;\n        for (int i = 0; i < nums.size(); ++i) {\n            if (nums[i] >= mx * 2) ans = i;\n            else if (nums[i] * 2 > mx) ans = -1;\n            mx = max(nums[i], mx);\n        }\n        return ans;\n    }\n};\n```\n-\n```JS\nvar dominantIndex = function(nums) {\n    const n = nums.length\n    if(n == 1) return 0\n    let a = -1, b = 0\n    for (let i = 1; i < n; i++){\n        if (nums[i] > nums[b]) {\n            a = b; b = i;\n        } else if (a == -1 || nums[i] > nums[a]) {\n            a = i;\n        }\n    }\n    return nums[b] >= nums[a] * 2 ? b : -1;\n};\n```\n-\n```TS\nfunction dominantIndex(nums: number[]): number {\n    const n = nums.length\n    if(n == 1) return 0\n    let a = -1, b = 0\n    for (let i = 1; i < n; i++){\n        if (nums[i] > nums[b]) {\n            a = b; b = i;\n        } else if (a == -1 || nums[i] > nums[a]) {\n            a = i;\n        }\n    }\n    return nums[b] >= nums[a] * 2 ? b : -1;\n};\n```\n-\n```PHP\nclass Solution {\n    function dominantIndex($nums) {\n        $n = sizeof($nums);\n        if ($n == 1) return 0;\n        $a = -1; $b = 0;\n        for ($i = 1; $i < $n; $i++) {\n            if ($nums[$i] > $nums[$b]) {\n                $a = $b;\n                $b = $i;\n            } else if ($a == -1 || $nums[$i] > $nums[$a]) {\n                $a = $i;\n            }\n        }\n        if($nums[$b] >= $nums[$a] * 2){\n            return $b;\n        }\n        return -1;\n    }\n}\n```\n-\n```Swift\nclass Solution {\n    func dominantIndex(_ nums: [Int]) -> Int {\n        var n = nums.count\n        if n == 1 {\n            return 0\n        }\n        var (a, b) = (-1, 0)\n        for i in 1..<nums.count {\n            if nums[i] > nums[b] {\n                (a, b) = (b, i)\n            }\n            else if a == -1 || nums[i] > nums[a] {\n                a = i\n            }\n        }\n        return nums[b] >= nums[a] * 2 ? b : -1\n    }\n}\n```\n-\n```Kotlin\nclass Solution {\n    fun dominantIndex(nums: IntArray): Int {\n        var mx = 0\n        var ans = -1\n        for (i in nums.indices) {\n            when {\n                nums[i] >= mx * 2 -> ans = i\n                nums[i] * 2 > mx -> ans = -1\n            }\n            if (nums[i] > mx) mx = nums[i]\n        }\n        return ans\n    }\n}\n```\n-\n```Scala\nobject Solution {\n    def dominantIndex(nums: Array[Int]): Int = {\n        var mx = 0\n        var ans = -1\n        for (i <- 0 to (nums.length - 1)) {\n            if (nums(i) >= mx * 2) ans = i\n            else if (nums(i) * 2 > mx) ans = -1\n            if (nums(i) > mx) mx = nums(i)\n        }\n        return ans\n    }\n}\n```\n-\n```Ruby\ndef dominant_index(nums)\n    n = nums.length\n    return 0 if n == 1\n    a = -1\n    b = 0\n    nums.each_with_index do |num, i|\n        next if i == 0\n        if nums[i] > nums[b]\n            a = b\n            b = i\n        elsif a.eql?(-1) or nums[i] > nums[a]\n            a = i\n        end\n    end\n    return nums[b] >= nums[a] * 2 ? b : -1\nend\n```\n-\n```lisp\n(define/contract (dominant-index nums)\n  (-> (listof exact-integer?) exact-integer?)\n  (let loop ([nums nums] [i 0] [mx 0] [ans -1])\n    (cond\n      [(empty? nums) ans]\n      [else\n        (define x (car nums))\n        (define mxx (max x mx))\n        (cond\n          [(>= x (* mx 2)) (loop (cdr nums) (+ i 1) mxx i)]\n          [(> (* x 2) mx) (loop (cdr nums) (+ i 1) mxx -1)]\n          [else (loop (cdr nums) (+ i 1) mxx ans)]\n        )\n      ]\n    )\n  )\n)\n```\n-\n\n```Elixir\ndefmodule Solution do\n  @spec dominant_index(nums :: [integer]) :: integer\n  def dominant_index(nums) do\n    solve(nums, 0, -1, 0)\n  end\n  def solve([], mx, ans, cur) do\n    ans\n  end\n  def solve([x | rest], mx, ans, cur) when x >= mx * 2 do\n    solve(rest, max(x, mx), cur, cur + 1)\n  end\n  def solve([x | rest], mx, ans, cur) when x * 2 > mx do\n    solve(rest, max(x, mx), -1, cur + 1)\n  end\n  def solve([x | rest], mx, ans, cur) do\n    solve(rest, max(x, mx), ans, cur + 1)\n  end\nend\n```\n-\n```Erlang\n-spec dominant_index(Nums :: [integer()]) -> integer().\ndominant_index(Nums) ->\n  solve(Nums).\n\nsolve(List) ->\n  solve(List, 0, -1, 0).\nsolve([], Max, Ans, Cur) ->\n  Ans;\nsolve([Head|Rest], Max, Ans, Cur) when Head >= Max * 2 ->\n  solve(Rest, max(Max, Head), Cur, Cur + 1);\nsolve([Head|Rest], Max, Ans, Cur) when Head * 2 > Max ->\n  solve(Rest, max(Max, Head), -1, Cur + 1);\nsolve([Head|Rest], Max, Ans, Cur) ->\n  solve(Rest, max(Max, Head), Ans, Cur + 1).\n\nmax(A, B) when A > B ->\n  A;\nmax(A, B) ->\n  B.\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 全鱼宴(是全语言 这错别字还挺可爱 🤣\n\n经过三位总 [@5cm/s 🌸](/u/megurine/)、[@Benhao](/u/himymben/) 和 [@Qian](/u/qian2/) 的不懈努力,通过举一反三、连蒙带猜,把所有语言弄出了 🤣\n\n这个过程中也有幸见到,如果一个语言只有一份代码,居然界面是这样的(没有时间和内存的分布图:\n\n我和我的小伙伴纷纷表示这样的 Flag 再也不敢了 🤣", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.747` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/741-750/748. 最短补全词（简单）.md", "url_title": "748. 最短补全词", "url": "https://leetcode-cn.com/problems/shortest-completing-word/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-j-x4ao/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个字符串 $licensePlate$ 和一个字符串数组 $words$ ,请你找出并返回 $words$ 中的 最短补全词 。\n\n补全词 是一个包含 $licensePlate$ 中所有的字母的单词。在所有补全词中,最短的那个就是 最短补全词 。\n\n在匹配 $licensePlate$ 中的字母时:\n* 忽略 $licensePlate$ 中的 数字和空格 。\n* 不区分大小写。\n* 如果某个字母在 $licensePlate$ 中出现不止一次,那么该字母在补全词中的出现次数应当一致或者更多。\n\n例如:`licensePlate = \"aBc 12c\"`,那么它的补全词应当包含字母 `'a'`、`'b'` (忽略大写)和两个 `'c'` 。可能的 补全词 有 `\"abccdef\"`、`\"caaacab\"` 以及 `\"cbca\"`。\n\n请你找出并返回 $words$ 中的 最短补全词 。题目数据保证一定存在一个最短补全词。当有多个单词都符合最短补全词的匹配条件时取 $words$ 中 最靠前的 那个。\n\n示例 1:\n```\n输入:licensePlate = \"1s3 PSt\", words = [\"step\", \"steps\", \"stripe\", \"stepple\"]\n\n输出:\"steps\"\n\n解释:最短补全词应该包括 \"s\"、\"p\"、\"s\"(忽略大小写) 以及 \"t\"。\n\"step\" 包含 \"t\"、\"p\",但只包含一个 \"s\",所以它不符合条件。\n\"steps\" 包含 \"t\"、\"p\" 和两个 \"s\"。\n\"stripe\" 缺一个 \"s\"。\n\"stepple\" 缺一个 \"s\"。\n因此,\"steps\" 是唯一一个包含所有字母的单词,也是本例的答案。\n```\n示例 2:\n```\n输入:licensePlate = \"1s3 456\", words = [\"looks\", \"pest\", \"stew\", \"show\"]\n\n输出:\"pest\"\n\n解释:licensePlate 只包含字母 \"s\" 。所有的单词都包含字母 \"s\" ,其中 \"pest\"、\"stew\"、和 \"show\" 三者最短。答案是 \"pest\" ,因为它是三个单词中在 words 里最靠前的那个。\n```\n示例 3:\n```\n输入:licensePlate = \"Ah71752\", words = [\"suggest\",\"letter\",\"of\",\"husband\",\"easy\",\"education\",\"drug\",\"prevent\",\"writer\",\"old\"]\n\n输出:\"husband\"\n```\n示例 4:\n```\n输入:licensePlate = \"OgEu755\", words = [\"enough\",\"these\",\"play\",\"wide\",\"wonder\",\"box\",\"arrive\",\"money\",\"tax\",\"thus\"]\n\n输出:\"enough\"\n```\n示例 5:\n```\n输入:licensePlate = \"iMSlpe4\", words = [\"claim\",\"consumer\",\"student\",\"camera\",\"public\",\"never\",\"wonder\",\"simple\",\"thought\",\"use\"]\n\n输出:\"simple\"\n```\n\n提示:\n* $1 <= licensePlate.length <= 7$\n* $licensePlate$ 由数字、大小写字母或空格 ' ' 组成\n* $1 <= words.length <= 1000$\n* $1 <= words[i].length <= 15$\n* $words[i]$ 由小写英文字母组成", "solution": "### 模拟\n\n根据题意,先对 $licensePlate$ 进行词频统计(忽略空格和数字),然后遍历 $words$ 进行词频统计,从所有符合要求的 $words[i]$ 找到最短的补全词。\n\n代码:\n```Java\nclass Solution {\n    public String shortestCompletingWord(String licensePlate, String[] words) {\n        int[] cnt = getCnt(licensePlate);\n        String ans = null;\n        for (String s : words) {\n            int[] cur = getCnt(s);\n            boolean ok = true;\n            for (int i = 0; i < 26 && ok; i++) {\n                if (cnt[i] > cur[i]) ok = false;\n            }\n            if (ok && (ans == null || ans.length() > s.length())) ans = s;\n        }\n        return ans;\n    }\n    int[] getCnt(String s) {\n        int[] cnt = new int[26];\n        for (char c : s.toCharArray()) {\n            if (Character.isLetter(c)) cnt[Character.toLowerCase(c) - 'a']++;\n        }\n        return cnt;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为字符串 $licensePlate$ 的长度,$m$ 为数组 $words$ 的长度,$L$ 为所有 $words[i]$ 的长度总和,字符集大小为 $C = 26$。整体复杂度为 $O(n + \\sum_{i = 0}^{m - 1}{(C + words[i].length)})$\n* 空间复杂度:偷懒使用 `toCharArray` 的话,复杂度和时间复杂度一样;仅使用 `charAt` 的话复杂度为 $O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.748` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/741-750/749. 隔离病毒（困难）.md", "url_title": "749. 隔离病毒", "url": "https://leetcode.cn/problems/contain-virus/solution/by-ac_oier-l9ya/", "difficulty": "困难", "tags": ["模拟", "图论搜索", "BFS"], "question": "病毒扩散得很快,现在你的任务是尽可能地通过安装防火墙来隔离病毒。\n\n假设世界由 $m \\times n$ 的二维矩阵 `isInfected` 组成,`isInfected[i][j] == 0` 表示该区域未感染病毒,而  `isInfected[i][j] == 1` 表示该区域已感染病毒。可以在任意 $2$ 个相邻单元之间的共享边界上安装一个防火墙(并且只有一个防火墙)。\n\n每天晚上,病毒会从被感染区域向相邻未感染区域扩散,除非被防火墙隔离。现由于资源有限,每天你只能安装一系列防火墙来隔离其中一个被病毒感染的区域(一个区域或连续的一片区域),且该感染区域对未感染区域的威胁最大且 保证唯一 。\n\n你需要努力使得最后有部分区域不被病毒感染,如果可以成功,那么返回需要使用的防火墙个数; 如果无法实现,则返回在世界被病毒全部感染时已安装的防火墙个数。\n\n示例 1:\n\n```\n输入: isInfected = [[0,1,0,0,0,0,0,1],[0,1,0,0,0,0,0,1],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]\n\n输出: 10\n\n解释:一共有两块被病毒感染的区域。\n在第一天,添加 5 墙隔离病毒区域的左侧。病毒传播后的状态是:\n\n第二天,在右侧添加 5 个墙来隔离病毒区域。此时病毒已经被完全控制住了。\n```\n\n示例 2:\n\n```\n输入: isInfected = [[1,1,1],[1,0,1],[1,1,1]]\n\n输出: 4\n\n解释: 虽然只保存了一个小区域,但却有四面墙。\n注意,防火墙只建立在两个不同区域的共享边界上。\n```\n示例 3:\n```\n输入: isInfected = [[1,1,1,0,0,0,0,0,0],[1,0,1,0,1,1,1,1,1],[1,1,1,0,0,0,0,0,0]]\n\n输出: 13\n\n解释: 在隔离右边感染区域后,隔离左边病毒区域只需要 2 个防火墙。\n```\n\n提示:\n* $m == isInfected.length$\n* $n == isInfected[i].length$\n* $1 <= m, n <= 50$\n* `isInfected[i][j]` is either `0` or `1`\n* 在整个描述的过程中,总有一个相邻的病毒区域,它将在下一轮 严格地感染更多未受污染的方块", "solution": "### 搜索模拟\n\n根据题意,我们可以按天进行模拟,设计函数 `getCnt` 用于返回当天会被安装的防火墙数量,在 `getCnt` 内部我们会进行如下操作:\n\n* 找出当天「对未感染区域的威胁最大」的区域,并将该区域进行隔离(将 $1$ 设置为 $-1$);\n* 对其他区域,进行步长为 $1$ 的感染操作。\n\n考虑如何实现 `getCnt`:我们需要以「连通块」为单位进行处理,因此每次的 `getCnt` 操作,我们先重建一个与矩阵等大的判重数组 `vis`,对于每个 $g[i][j] = 1$ 且未被 $vis[i][j]$ 标记为 `True` 的位置进行搜索,搜索过程使用 `BFS` 实现。\n\n**在 `BFS` 过程中,我们除了统计该连通块所需要的防火墙数量 $b$ 以外,还需要额外记录当前连通块中 $1$ 的点集 `s1`(简称为原集,含义为连通块的格子集合),以及当前连通块相邻的 $0$ 的点集 `s2`(简称为扩充集,含义为将要被感染的格子集合)。**\n\n根据题意,在单次的 `getCnt` 中,我们需要在所有连通块中取出其 `s2` 大小最大(对未感染区域的威胁最大)的连通块进行隔离操作,而其余连通块则进行扩充操作。\n\n因此我们可以使用两个变量 `max` 和 `ans` 分别记录所有 `s2` 中的最大值,以及取得最大 `s2` 所对应连通块所需要的防火墙数量,同时需要使用两个数组 `l1` 和 `l2` 分别记录每个连通块对应的「原集」和「扩充集」,方便我们后续进行「隔离」和「感染」。\n\nJava 代码:\n```Java\nclass Solution {\n    int[][] g;\n    int n, m, ans;\n    int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n    boolean[][] vis;\n    int search(int _x, int _y, Set<Integer> s1, Set<Integer> s2) {\n        int ans = 0;\n        Deque<int[]> d = new ArrayDeque<>();\n        vis[_x][_y] = true;\n        d.addLast(new int[]{_x, _y});\n        s1.add(_x * m + _y);\n        while (!d.isEmpty()) {\n            int[] info = d.pollFirst();\n            int x = info[0], y = info[1];\n            for (int[] di : dirs) {\n                int nx = x + di[0], ny = y + di[1], loc = nx * m + ny;\n                if (nx < 0 || nx >= n || ny < 0 || ny >= m || vis[nx][ny]) continue;\n                if (g[nx][ny] == 1) {\n                    s1.add(loc);\n                    vis[nx][ny] = true;\n                    d.addLast(new int[]{nx, ny});\n                } else if (g[nx][ny] == 0) {\n                    s2.add(loc);\n                    ans++;\n                }\n            }\n        }\n        return ans;\n    }\n    int getCnt() {\n        vis = new boolean[n][m];\n        int max = 0, ans = 0;\n        // l1: 每个连通块的点集 s2: 每个连通块的候选感染点集\n        List<Set<Integer>> l1 = new ArrayList<>(), l2 = new ArrayList<>();\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                if (g[i][j] == 1 && !vis[i][j]) {\n                    // s1: 当前连通块的点集 s2: 当前连通块的候选感染点集\n                    Set<Integer> s1 = new HashSet<>(), s2 = new HashSet<>();\n                    int b = search(i, j, s1, s2), a = s2.size();\n                    if (a > max) {\n                        max = a; ans = b;\n                    }\n                    l1.add(s1); l2.add(s2);\n                }\n            }\n        }\n        for (int i = 0; i < l2.size(); i++) {\n            for (int loc : l2.get(i).size() == max ? l1.get(i) : l2.get(i)) {\n                int x = loc / m, y = loc % m;\n                g[x][y] = l2.get(i).size() == max ? -1 : 1;\n            }\n        }\n        return ans;\n    }\n    public int containVirus(int[][] _g) {\n        g = _g;\n        n = g.length; m = g[0].length;\n        while (true) {\n            int cnt = getCnt();\n            if (cnt == 0) break;\n            ans += cnt;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nlet g: number[][] = null\nlet n: number = 0, m: number = 0\nlet vis: boolean[][] = null\nconst dirs: number[][] = [[1,0],[-1,0],[0,1],[0,-1]]\nfunction search(_x: number, _y: number, s1: Set<number>, s2: Set<number>): number {\n    let he = 0, ta = 0, ans = 0\n    let d: Array<number> = new Array<number>()\n    s1.add(_x * m + _y)\n    vis[_x][_y] = true\n    d[ta++] = _x * m + _y\n    while (he < ta) {\n        const poll = d[he++]\n        const x = Math.floor(poll / m), y = poll % m\n        for (const di of dirs) {\n            const nx = x + di[0], ny = y + di[1], loc = nx * m + ny\n            if (nx < 0 || nx >= n || ny < 0 || ny >= m || vis[nx][ny]) continue\n            if (g[nx][ny] == 1) {\n                s1.add(loc)\n                vis[nx][ny] = true\n                d[ta++] = loc\n            } else if (g[nx][ny] == 0) {\n                s2.add(loc)\n                ans++\n            }\n        }\n    }\n    return ans\n}\nfunction getCnt(): number {\n    vis = new Array<Array<boolean>>(n)\n    for (let i = 0; i < n; i++) vis[i] = new Array<boolean>(m).fill(false)\n    let max = 0, ans = 0\n    let l1: Array<Set<number>> = new Array<Set<number>>(), l2: Array<Set<number>> = new Array<Set<number>>()\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < m; j++) {\n            if (g[i][j] == 1 && !vis[i][j]) {\n                let s1 = new Set<number>(), s2 = new Set<number>()\n                const b = search(i, j, s1, s2), a = s2.size\n                if (a > max) {\n                    max = a; ans = b\n                }\n                l1.push(s1); l2.push(s2)\n            }\n        }\n    }\n    for (let i = 0; i < l2.length; i++) {\n        for (let loc of l2[i].size == max ? l1[i] : l2[i]) {\n            const x = Math.floor(loc / m), y = loc % m\n            g[x][y] = l2[i].size == max ? -1 : 1\n        }\n    }\n    return ans\n}\nfunction containVirus(_g: number[][]): number {\n    g = _g\n    n = g.length; m = g[0].length\n    let ans: number = 0\n    while (true) {\n        const cnt = getCnt()\n        if (cnt == 0) break\n        ans += cnt\n    }\n    return ans\n};\n```\n* 时间复杂度:最多有 $n + m$ 天需要模拟,每天模拟复杂度 $O(n \\times m)$,整体复杂度为 $O((n + m) \\times nm)$\n* 空间复杂度:$O(nm)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.749` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/751-760/752. 打开转盘锁（中等）.md", "url_title": "752. 打开转盘锁", "url": "https://leetcode-cn.com/problems/open-the-lock/solution/gong-shui-san-xie-yi-ti-shuang-jie-shuan-wyr9/", "difficulty": "中等", "tags": ["双向 BFS", "启发式搜索", "AStar 算法", "IDAStar 算法"], "question": "你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字: '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' 。每个拨轮可以自由旋转:例如把 '9' 变为 '0','0' 变为 '9' 。每次旋转都只能旋转一个拨轮的一位数字。\n\n锁的初始数字为 '0000' ,一个代表四个拨轮的数字的字符串。\n\n列表 deadends 包含了一组死亡数字,一旦拨轮的数字和列表里的任何一个元素相同,这个锁将会被永久锁定,无法再被旋转。\n\n字符串 target 代表可以解锁的数字,你需要给出解锁需要的最小旋转次数,如果无论如何不能解锁,返回 -1 。\n\n示例 1:\n```\n输入:deadends = [\"0201\",\"0101\",\"0102\",\"1212\",\"2002\"], target = \"0202\"\n输出:6\n解释:\n可能的移动序列为 \"0000\" -> \"1000\" -> \"1100\" -> \"1200\" -> \"1201\" -> \"1202\" -> \"0202\"。\n注意 \"0000\" -> \"0001\" -> \"0002\" -> \"0102\" -> \"0202\" 这样的序列是不能解锁的,\n因为当拨动到 \"0102\" 时这个锁就会被锁定。\n```\n示例 2:\n```\n输入: deadends = [\"8888\"], target = \"0009\"\n输出:1\n解释:\n把最后一位反向旋转一次即可 \"0000\" -> \"0009\"。\n```\n示例 3:\n```\n输入: deadends = [\"8887\",\"8889\",\"8878\",\"8898\",\"8788\",\"8988\",\"7888\",\"9888\"], target = \"8888\"\n输出:-1\n解释:\n无法旋转到目标数字且不被锁定。\n```\n示例 4:\n```\n输入: deadends = [\"0000\"], target = \"8888\"\n输出:-1\n```\n\n提示:\n* 1 <= deadends.length <= 500\n* deadends[i].length == 4\n* target.length == 4\n* target 不在 deadends 之中\n* target 和 deadends[i] 仅由若干位数字组成", "solution": "### 基本分析\n\n首先,我建议你先做 [127. 单词接龙](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&token=394346611&lang=zh_CN#rd),然后再回过头将本题作为「练习题」。\n\n[127. 单词接龙](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&token=394346611&lang=zh_CN#rd) 定位困难,而本题定位中等。主要体现在数据范围上,思维难度上 [127. 单词接龙](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&token=394346611&lang=zh_CN#rd) 并不比本题难,大胆做。\n\n回到本题,根据题意,可以确定这是一个「最短路/最小步数」问题。\n\n此类问题,通常我们会使用「BFS」求解,但朴素的 BFS 通常会带来搜索空间爆炸问题。\n\n因此我们可以使用与  [127. 单词接龙](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486981&idx=1&sn=045ea6c880080fea1ce807794ccff69b&chksm=fd9ca51acaeb2c0c83d13e3b2a5196895d1a1b44f8981cc3efad9d6a2af158267010646cc262&token=394346611&lang=zh_CN#rd) 类似的思路进行求解。\n\n---\n\n### 双向 BFS\n\n我们知道,递归树的展开形式是一棵多阶树。\n\n使用朴素 BFS 进行求解时,队列中最多会存在“两层”的搜索节点。\n\n因此搜索空间的上界取决于 **目标节点所在的搜索层次的深度所对应的宽度**。\n\n下图展示了朴素 BFS 可能面临的搜索空间爆炸问题:\n\n**在朴素的 BFS 实现中,空间的瓶颈主要取决于搜索空间中的最大宽度。**\n\n那么有没有办法让我们不使用这么宽的搜索空间,同时又能保证搜索到目标结果呢?\n\n「双向 BFS」 可以很好的解决这个问题:\n\n**同时从两个方向开始搜索,一旦搜索到相同的值,意味着找到了一条联通起点和终点的最短路径。**\n\n对于「有解」、「有一定数据范围」同时「层级节点数量以倍数或者指数级别增长」的情况,「双向 BFS」的搜索空间通常只有「朴素 BFS」的空间消耗的几百分之一,甚至几千分之一。\n\n「双向 BFS」的基本实现思路如下:\n\n1. 创建「两个队列」分别用于两个方向的搜索;\n2. 创建「两个哈希表」用于「解决相同节点重复搜索」和「记录转换次数」;\n3. 为了尽可能让两个搜索方向“平均”,每次从队列中取值进行扩展时,先判断哪个队列容量较少;\n4. 如果在搜索过程中「搜索到对方搜索过的节点」,说明找到了最短路径。\n\n「双向 BFS」基本思路对应的伪代码大致如下:\n\n```Java\nd1、d2 为两个方向的队列\nm1、m2 为两个方向的哈希表,记录每个节点距离起点的\n    \n// 只有两个队列都不空,才有必要继续往下搜索\n// 如果其中一个队列空了,说明从某个方向搜到底都搜不到该方向的目标节点\nwhile(!d1.isEmpty() && !d2.isEmpty()) {\n    if (d1.size() < d2.size()) {\n        update(d1, m1, m2);\n    } else {\n        update(d2, m2, m1);\n    }\n}\n\n// update 为将当前队列 d 中包含的元素取出,进行「一次完整扩展」的逻辑(按层拓展)\nvoid update(Deque d, Map cur, Map other) {}\n```\n\n回到本题,我们看看如何使用「双向 BFS」进行求解。\n\n估计不少同学是第一次接触「双向 BFS」,因此这次我写了大量注释。\n\n建议大家带着对「双向 BFS」的基本理解去阅读。\n\n代码:\n```Java\nclass Solution {\n    String t, s;\n    Set<String> set = new HashSet<>();\n    public int openLock(String[] _ds, String _t) {\n        s = \"0000\";\n        t = _t;\n        if (s.equals(t)) return 0;\n        for (String d : _ds) set.add(d);\n        if (set.contains(s)) return -1;\n        int ans = bfs();\n        return ans;\n    }\n    int bfs() {\n        // d1 代表从起点 s 开始搜索(正向)\n        // d2 代表从结尾 t 开始搜索(反向)\n        Deque<String> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();\n        /*\n         * m1 和 m2 分别记录两个方向出现的状态是经过多少次转换而来\n         * e.g.\n         * m1 = {\"1000\":1} 代表 \"1000\" 由 s=\"0000\" 旋转 1 次而来\n         * m2 = {\"9999\":3} 代表 \"9999\" 由 t=\"9996\" 旋转 3 次而来\n         */\n        Map<String, Integer> m1 = new HashMap<>(), m2 = new HashMap<>();\n        d1.addLast(s);\n        m1.put(s, 0);\n        d2.addLast(t);\n        m2.put(t, 0);\n\n        /*\n         * 只有两个队列都不空,才有必要继续往下搜索\n         * 如果其中一个队列空了,说明从某个方向搜到底都搜不到该方向的目标节点\n         * e.g. \n         * 例如,如果 d1 为空了,说明从 s 搜索到底都搜索不到 t,反向搜索也没必要进行了\n         */\n        while (!d1.isEmpty() && !d2.isEmpty()) {\n            int t = -1;\n            if (d1.size() <= d2.size()) {\n                t = update(d1, m1, m2);\n            } else {\n                t = update(d2, m2, m1);\n            }\n            if (t != -1) return t;\n        }\n        return -1;       \n    }\n    int update(Deque<String> deque, Map<String, Integer> cur, Map<String, Integer> other) {\n        int m = deque.size();\n        while (m-- > 0) {\n            String poll = deque.pollFirst();\n            char[] pcs = poll.toCharArray();\n            int step = cur.get(poll);\n            // 枚举替换哪个字符\n            for (int i = 0; i < 4; i++) {\n                // 能「正向转」也能「反向转」,这里直接枚举偏移量 [-1,1] 然后跳过 0\n                for (int j = -1; j <= 1; j++) {\n                    if (j == 0) continue;\n\n                    // 求得替换字符串 str\n                    int origin = pcs[i] - '0';\n                    int next = (origin + j) % 10;\n                    if (next == -1) next = 9;\n\n                    char[] clone = pcs.clone();\n                    clone[i] = (char)(next + '0');\n                    String str = String.valueOf(clone);\n\n                    if (set.contains(str)) continue;\n                    if (cur.containsKey(str)) continue;\n\n                    // 如果在「另一方向」找到过,说明找到了最短路,否则加入队列\n                    if (other.containsKey(str)) { \n                        return step + 1 + other.get(str);\n                    } else {\n                        deque.addLast(str);\n                        cur.put(str, step + 1);\n                    }\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\n\n---\n\n### AStar 算法\n\n可以直接根据本题规则来设计 A* 的「启发式函数」。\n\n比如对于两个状态 `a` 和 `b` 可直接计算出「理论最小转换次数」:**不同字符的转换成本之和** 。\n\n**需要注意的是:由于我们衡量某个字符 `str` 的估值是以目标字符串 `target` 为基准,因此我们只能确保 `target` 出队时为「距离最短」,而不能确保中间节点出队时「距离最短」,因此我们不能单纯根据某个节点是否「曾经入队」而决定是否入队,还要结合当前节点的「最小距离」是否被更新而决定是否入队。**\n\n这一点十分关键,在代码层面上体现在 `map.get(str).step > poll.step + 1` 的判断上。\n\n注意:本题用 A* 过了,但通常我们需要先「确保有解」,A* 的启发搜索才会发挥真正价值。而本题,除非 `t` 本身在 `deadends` 中,其余情况我们无法很好提前判断「是否有解」。对于无解的情况 A* 效果不如「双向 BFS」。\n\n代码:\n```Java\nclass Solution {\n    class Node {\n        String str;\n        int val, step;\n       /**\n        *  str : 对应字符串\n        *  val : 估值(与目标字符串 target 的最小转换成本)\n        *  step: 对应字符串是经过多少步转换而来\n        */\n        Node(String _str, int _val, int _step) {\n            str = _str;\n            val = _val;\n            step = _step;\n        }\n    }\n    int f(String str) {\n        int ans = 0;\n        for (int i = 0; i < 4; i++) {\n            int cur = str.charAt(i) - '0', target = t.charAt(i) - '0';\n            int a = Math.min(cur, target), b = Math.max(cur, target);\n            // 在「正向转」和「反向转」之间取 min\n            int min = Math.min(b - a, a + 10 - b);\n            ans += min;\n        }\n        return ans;\n    }\n    String s, t;\n    Set<String> set = new HashSet<>();\n    public int openLock(String[] ds, String _t) {\n        s = \"0000\";\n        t = _t;\n        if (s.equals(t)) return 0;\n        for (String d : ds) set.add(d);\n        if (set.contains(s)) return -1;\n        \n        PriorityQueue<Node> q = new PriorityQueue<>((a,b)->a.val-b.val);\n        Map<String, Node> map = new HashMap<>();\n        Node root = new Node(s, f(s), 0);\n        q.add(root);\n        map.put(s, root);\n        while (!q.isEmpty()) {\n            Node poll = q.poll();\n            char[] pcs = poll.str.toCharArray();\n            int step = poll.step;\n            if (poll.str.equals(t)) return step;\n            for (int i = 0; i < 4; i++) {\n                for (int j = -1; j <= 1; j++) {\n                    if (j == 0) continue;\n                    int cur = pcs[i] - '0';\n                    int next = (cur + j) % 10;\n                    if (next == -1) next = 9;\n\n                    char[] clone = pcs.clone();\n                    clone[i] = (char)(next + '0');\n                    String str = String.valueOf(clone);\n\n                    if (set.contains(str)) continue;\n                    // 如果 str 还没搜索过,或者 str 的「最短距离」被更新,则入队\n                    if (!map.containsKey(str) || map.get(str).step > step + 1) {\n                        Node node = new Node(str, step + 1 + f(str), step + 1);\n                        map.put(str, node);\n                        q.add(node);\n                    }\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\n\n---\n\n### IDA* 算法\n\n同样我们可以使用基于 `DFS` 的启发式 IDA* 算法:\n\n* 仍然使用 `f()` 作为估值函数\n* 利用旋转次数有限:总旋转次数不会超过某个阈值 $\\max$。 \n* 利用「迭代加深」的思路找到最短距离\n\n理想情况下,由于存在正向旋转和反向旋转,每一位转轮从任意数字开始到达任意数字,消耗次数不会超过 $5$ 次,因此理想情况下可以设定 $\\max = 5 * 4$ 。\n\n但考虑 `deadends` 的存在,我们需要将 $\\max$ 定义得更加保守一些:$\\max = 10 * 4$ 。\n\n**但这样的阈值设定,加上 IDA\\* 算法每次会重复遍历「距离小于与目标节点距离」的所有节点,会有很大的 TLE 风险。**\n\n**因此我们需要使用动态阈值:不再使用固定的阈值,而是利用 `target` 计算出「最大的转移成本」作为我们的「最深数量级」。**\n\nPS. 上述的阈值分析是科学做法。对于本题可以利用数据弱,直接使用 $\\max = 5 * 4$ 也可以通过,并且效果不错。\n\n但必须清楚 $\\max = 5 * 4$ 可能是一个错误的阈值,本题起点为 `0000`,考虑将所有正向转换的状态都放入 `deadends` 中,`target` 为 `2222`。这时候我们可以只限定 `0000` 先变为 `9999` 再往回变为 `2222` 的通路不在 `deadends` 中。\n\n这时候使用 $\\max = 5 * 4$ 就不对,但本题数据弱,可以通过(想提交错误数据拿积分吗?别试了,我已经提交了 🤣\n\n代码:\n```Java\nclass Solution {\n    String s, t;\n    String cur;\n    Set<String> set = new HashSet<>();\n    Map<String, Integer> map = new HashMap<>();\n    public int openLock(String[] ds, String _t) {\n        s = \"0000\";\n        t = _t;\n        if (s.equals(t)) return 0;\n        for (String d : ds) set.add(d);\n        if (set.contains(s)) return -1;   \n\n        int depth = 0, max = getMax();\n        cur = s;\n        map.put(cur, 0);\n        while (depth <= max && !dfs(0, depth)) {\n            map.clear();\n            cur = s;\n            map.put(cur, 0);\n            depth++;\n        }\n        return depth > max ? -1 : depth;\n    }\n    int getMax() {\n        int ans = 0;\n        for (int i = 0; i < 4; i++) {\n            int origin = s.charAt(i) - '0', next = t.charAt(i) - '0';\n            int a = Math.min(origin, next), b = Math.max(origin, next);\n            int max = Math.max(b - a, a + 10 - b);\n            ans += max;\n        }\n        return ans;\n    }\n    int f() {\n        int ans = 0;\n        for (int i = 0; i < 4; i++) {\n            int origin = cur.charAt(i) - '0', next = t.charAt(i) - '0';\n            int a = Math.min(origin, next), b = Math.max(origin, next);\n            int min = Math.min(b - a, a + 10 - b);\n            ans += min;\n        }\n        return ans;\n    }\n    boolean dfs(int u, int max) {\n        if (u + f() > max) return false;\n        if (f() == 0) return true;\n        String backup = cur;\n        char[] cs = cur.toCharArray();\n        for (int i = 0; i < 4; i++) {\n            for (int j = -1; j <= 1; j++) {\n                if (j == 0) continue;\n                int origin = cs[i] - '0';\n                int next = (origin + j) % 10;\n                if (next == -1) next = 9;\n                char[] clone = cs.clone();\n                clone[i] = (char)(next + '0');\n                String str = String.valueOf(clone);  \n                if (set.contains(str)) continue;\n                if (!map.containsKey(str) || map.get(str) > u + 1) {\n                    cur = str;\n                    map.put(str, u + 1);\n                    if (dfs(u + 1, max)) return true;\n                    cur = backup;\n                }\n            }\n        }\n        return false;\n    }\n}\n```", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.752` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/751-760/754. 到达终点数字（中等）.md", "url_title": "754. 到达终点数字", "url": "https://leetcode.cn/problems/reach-a-number/solution/by-ac_oier-o4ze/", "difficulty": "中等", "tags": ["数学"], "question": "在一根无限长的数轴上,你站在 `0` 的位置。终点在 `target` 的位置。\n\n你可以做一些数量的移动 numMoves :\n\n* 每次你可以选择向左或向右移动。\n* 第 `i` 次移动(从  `i == 1` 开始,到 `i == numMoves`),在选择的方向上走 `i` 步。\n\n给定整数 `target`,返回 到达目标所需的 最小 移动次数(即最小 `numMoves` ) 。\n\n示例 1:\n```\n输入: target = 2\n\n输出: 3\n\n解释:\n第一次移动,从 0 到 1 。\n第二次移动,从 1 到 -1 。\n第三次移动,从 -1 到 2 。\n```\n示例 2:\n```\n输入: target = 3\n\n输出: 2\n\n解释:\n第一次移动,从 0 到 1 。\n第二次移动,从 1 到 3 。\n```\n\n提示:\n* $-10^9 <= target <= 10^9$\n* $target != 0$", "solution": "### 数学\n\n#### 提示一:数轴上的任意点都以起点($0$ 点)对称,只需要考虑对称点的任意一边\n\n由于题目没有限制我们「不能到达哪些点」以及「出发的起始方向」,因此以起点为中心的左右两边对称。\n\n即:左边所能到达任意一个点,都能通过调整所达路径的方向来将终点调整到右边。\n\n同时由于起点是一个特殊的位置 $0$ 点,因此相应的「正数点」和「负数点」对称,我们仅需考虑一边(例如正数域)即可。\n\n#### 提示二:先往靠近 `target` 的方向移动,到达或越过 `target` 的时候则停止\n\n只考虑 `target` 为正的情况,我们假定起始先往靠近 `target` 的方向移动(即所有步数均为正值),根据是「到达」还是「越过」`target` 位置分情况讨论:\n\n* 若能直接到达 `target`,此时消耗的必然是最小步数,可直接返回;\n* 若越过了 `target`,假设此时消耗的步数为 $k$,所走的距离为 $dist = \\frac{k \\times (k + 1)}{2} > target$,我们可以考虑是否需要增加额外步数来到达 `target`。\n\n#### 提示三:越过 `target` 时,如何不引入额外步数\n\n若不引入额外步数,意味着我们需要将此前某些移动的方向进行翻转,使得调整后的 $dist = target$。\n\n我们假设需要调整的步数总和为 `tot`,则有 $dist - 2 \\times tot = target$,变形可得 $tot = \\frac{dist - target}{2}$。\n\n若想满足上述性质,需要确保能找到这样的 `tot`,即 `tot` 合法,\n\n不难推导出当 `dist` 和 `target` 差值为「偶数」时(两者奇偶性相同),我们可以找到这样的 `tot`,从而实现不引入额外步数来到达 `target` 位置。\n\n> 由于我们的 $dist$ 是由数列 $[1,2,3,...,k]$ 累加而来,因此必然能够在该数列 $[1,2,3...k]$ 中通过「不重复选择某些数」来凑成任意一个小于等于 $dist$ 的数。\n\n#### 提示四:越过 `target` 时,如何尽量减少引入额外步数\n\n当 `dist` 和 `target` 差值不为「偶数」时,我们只能通过引入额外步数(继续往右走)来使得,两者差值为偶数。\n\n可以证明,最多引入步数不超过 $4$ 步,可使用得两者奇偶性相同,即不超过 $4$ 步可以覆盖到「奇数」和「偶数」两种情况。\n\n根据 $k$ 与 $4$ 的余数关系分情况讨论:\n\n* 余数为 $0$,即 $k = 4X$,由于 $dist = \\frac{k(k+1)}{2} = \\frac{4X(4X+1)}{2} = 2X(4X+1)$,其中一数为偶数,$dist$ 为偶数;\n* 余数为 $1$,即 $k = 4X + 1$,由于 $dist = \\frac{k(k+1)}{2} = \\frac{(4X+1)(4X+2)}{2} = (4X+1)(2X+1)$,两个奇数相乘为奇数,$dist$ 为奇数;\n* 余数为 $2$,即 $k = 4X + 2$,$dist = \\frac{k(k+1)}{2} = \\frac{(4X+2)(4X+3)}{2} = (2X+1)(4X+3)$,两个奇数相乘为奇数,$dist$ 为奇数;\n* 余数为 $3$,即 $k = 4X + 3$,$dist = \\frac{k(k+1)}{2} = \\frac{(4X+3)(4X+4)}{2} = (4X+3)(2X+2)$,其中一数为偶数,$dist$ 为偶数。\n\n因此在越过 `target` 后,最多引入不超过 $4$ 步可使得 `dist` 和 `target` 奇偶性相同。\n\n#### 提示五:如何不通过「遍历」或「二分」的方式找到一个合适的 `k` 值,再通过不超过 $4$ 步的调整找到答案\n\n我们期望找到一个合适的 `k` 值,使得 $dist = \\frac{k \\times (k + 1)}{2} < target$,随后通过增加 `k` 值来找到答案。\n\n利用求和公式 $dist = \\frac{k \\times (k + 1)}{2}$,我们可以设定 $k = \\left \\lfloor \\sqrt{2 \\times target}) \\right \\rfloor$ 为起始值,随后逐步增大 `k` 值,直到满足「`dist` 和 `target` 奇偶性相同」。\n\nJava 代码:\n```Java\nclass Solution {\n    public int reachNumber(int target) {\n        if (target < 0) target = -target;\n        int k = (int) Math.sqrt(2 * target), dist = k * (k + 1) / 2;\n        while (dist < target || (dist - target) % 2 == 1) {\n            k++;\n            dist = k * (k + 1) / 2;\n        }\n        return k;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int reachNumber(int target) {\n        if (target < 0) target = -target;\n        int k = static_cast<int>(std::sqrt(2 * target));\n        int dist = k * (k + 1) / 2;\n        while (dist < target || (dist - target) % 2 == 1) {\n            k++;\n            dist = k * (k + 1) / 2;\n        }\n        return k;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def reachNumber(self, target: int) -> int:\n        if target < 0:\n            target = -target\n        k = int(math.sqrt(2 * target))\n        dist = k * (k + 1) / 2\n        while dist < target or (dist - target) % 2 == 1:\n            k += 1\n            dist = k * (k + 1) / 2\n        return k\n```\nTypeScript 代码:\n```TypeScript\nfunction reachNumber(target: number): number {\n    if (target < 0) target = -target\n    let k = Math.floor(Math.sqrt(2 * target)), dist = k * (k + 1) / 2\n    while (dist < target || (dist - target) % 2 == 1) {\n        k++\n        dist = k * (k + 1) / 2\n    }\n    return k\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.754` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/751-760/757. 设置交集大小至少为2（困难）.md", "url_title": "757. 设置交集大小至少为2", "url": "https://leetcode.cn/problems/set-intersection-size-at-least-two/solution/by-ac_oier-3xn6/", "difficulty": "困难", "tags": ["贪心"], "question": "一个整数区间 $[a, b]$  ($a < b$) 代表着从 `a` 到 `b` 的所有连续整数,包括 `a` 和 `b`。\n\n给你一组整数区间 `intervals`,请找到一个最小的集合 `S`,使得 `S` 里的元素与区间 `intervals` 中的每一个整数区间都至少有 $2$ 个元素相交。\n\n输出这个最小集合 `S` 的大小。\n\n示例 1:\n```\n输入: intervals = [[1, 3], [1, 4], [2, 5], [3, 5]]\n\n输出: 3\n\n解释:\n考虑集合 S = {2, 3, 4}. S与intervals中的四个区间都有至少2个相交的元素。\n且这是S最小的情况,故我们输出3。\n```\n示例 2:\n```\n输入: intervals = [[1, 2], [2, 3], [2, 4], [4, 5]]\n\n输出: 5\n\n解释:\n最小的集合S = {1, 2, 3, 4, 5}.\n```\n\n注意:\n* `intervals` 的长度范围为 $[1, 3000]$。\n* `intervals[i]` 长度为 $2$,分别代表左、右边界。\n* `intervals[i][j]` 的值是 $[0, 10^8]$ 范围内的整数。", "solution": "### 贪心\n\n不要被样例数据误导了,题目要我们求最小点集的数量,并不规定点集 `S` 是连续段。\n\n为了方便,我们令 `intervals` 为 `ins`。\n\n当只有一个线段时,我们可以在线段内取任意两点作为 `S` 成员,而当只有两个线段时,我们可以两个线段重合情况进行决策:\n\n1. 当两个线段完全不重合时,为满足题意,我们需要从两个线段中各取两个点,此时这四个点都可以任意取;\n2. 当两个线段仅有一个点重合,为满足 `S` 最小化的题意,我们可以先取重合点,然后再两个线段中各取一个;\n3. 当两个线段有两个及以上的点重合,此时在重合点中任选两个即可。\n\n不难发现,当出现重合的所有情况中,必然可以归纳某个线段的边缘点上。即不存在两个线段存在重合点,仅发生在两线段的中间部分:\n\n因此我们可以从边缘点决策进行入手。\n\n具体的,我们可以按照「右端点从小到大,左端点从大到小」的双关键字排序,然后从前往后处理每个区间,处理过程中不断往 `S` 中添加元素,由于我们已对所有区间排序且从前往后处理,因此我们往 `S` 中增加元素的过程中必然是单调递增,同时在对新的后续区间考虑是否需要往 `S` 中添加元素来满足题意时,也是与 `S` 中的最大/次大值(点集中的边缘元素)做比较,因此我们可以使用两个变量 `a` 和 `b` 分别代指当前集合 `S` 中的次大值和最大值(`a` 和 `b` 初始化为足够小的值 $-1$),而无需将整个 `S` 存下来。\n\n不失一般性的考虑,当我们处理到 $ins[i]$ 时,该如何决策:\n\n1. 若 $ins[i][0] > b$(当前区间的左端点大于当前点集 `S` 的最大值),说明 $ins[i]$ 完全不被 `S` 所覆盖,为满足题意,我们要在 $ins[i]$ 中选两个点,此时直观思路是选择 $ins[i]$ 最靠右的两个点(即 $ins[i][1] - 1$ 和 $ins[i][1]$);\n2. 若 $ins[i][0] > a$(即当前区间与点集 `S` 存在一个重合点 `b`,由于次大值 `a` 和 最大值 `b` 不总是相差 $1$,我们不能写成 $ins[i][0] == b$),此时为了满足 $ins[i]$ 至少被 $2$ 个点覆盖,我们需要在 $ins[i]$ 中额外选择一个点,此时直观思路是选择 $ins[i]$ 最靠右的点(即$ins[i][1]$);\n3. 其余情况,说明当前区间 $ins[i]$ 与点集 `S` 至少存在两个点 `a` 和 `b`,此时无须额外引入其余点来覆盖 $ins[i]$。\n\n上述情况是对「右端点从小到大」的必要性说明,而「左端点从大到小」目的是为了方便我们处理边界情况而引入的:若在右端点相同的情况下,如果「左端点从小到大」处理的话,会有重复的边缘点被加入 `S`。\n\n> 有同学对重复边缘点加入 `S` 不理解,假设 `S` 当前的次大值和最大值分别为 `j` 和 `k`(其中 $k - j > 1$),如果后面有两个区间分别为 $[k - 1, d]$ 和 $[k + 1, d]$ 时,就会出现问题(其中 `d` 为满足条件的任意右端点)\n更具体的:假设当前次大值和最大值分别为 $2$ 和 $4$,后续两个区间分别为 $[3, 8]$ 和 $[5, 8]$,你会发现先处理 $[3, 8]$ 的话,数值 $8$ 会被重复添加\n\n**上述决策存在直观判断,需要证明不存在比该做法取得的点集 `S` 更小的合法解**:\n\n若存在更小的合法集合方案 `A`(最优解),根据我们最前面对两个线段的重合分析知道,由于存在任意选点均能满足覆盖要求的情况,因此最优解 `A` 的具体方案可能并不唯一。\n\n因此首先我们先在不影响 `A` 的集合大小的前提下,**对具体方案 `A` 中的非关键点(即那些被选择,但既不是某个具体区间的边缘点,也不是边缘点的相邻点)进行调整(修改为区间边缘点或边缘点的相邻点)**。\n\n这样我们能够得到一个唯一的最优解具体方案,该方案既能取到最小点集大小,同时与贪心解 `S` 的选点有较大重合度。\n\n此时如果贪心解并不是最优解的话,意味着贪心解中存在某些不必要的点(可去掉,同时不会影响覆盖要求)。\n\n然后我们在回顾下,我们什么情况下会往 `S` 中进行加点,根据上述「不失一般性」的分析:\n\n1. 当 $ins[i][0] > b$ 时,我们会往 `S` 中添加两个点,若这个不必要的点是在这个分支中被添加的话,意味着当前 $ins[i]$ 可以不在此时被覆盖,而在后续其他区间 $ins[j]$ 被覆盖时被同步覆盖(其中 $j > i$),此时必然对应了我们重合分析中的后两种情况,可以将原本在 $ins[j]$ 中被选择的点,调整为 $ins[i]$ 的两个边缘点,结果不会变差(覆盖情况不变,点数不会变多):\n\n即此时原本在最优解 `A` 中不存在,在贪心解 `S` 中存在的「不必要点」会变成「必要点」。\n\n2. 当 $ins[i] > a$ 时,我们会往 `S` 中添加一个点,若这个不必要的点是在这个分支被添加的话,分析方式同理,且情况 $1$ 不会发生,如果 $ins[i]$ 和 $ins[j]$ 只有一个重合点的话,起始 $ins[i][1]$ 不会是不必要点:\n\n**综上,我们可以经过两步的“调整”,将贪心解变为最优解:第一步调整是在最优解的任意具体方案 `A` 中发生,通过将所有非边缘点调整为边缘点,来得到一个唯一的最优解具体方案;然后通过反证法证明,贪心解 `S` 中并不存在所谓的可去掉的「不必要点」,从而证明「贪心解大小必然不会大于最优解的大小」,即 $S > A$ 不成立,$S \\leq A$ 恒成立,再结合 `A` 是最优解的前提($A \\leq S$),可得 $S = A$。**\n\nJava 代码:\n```Java\nclass Solution {\n    public int intersectionSizeTwo(int[][] ins) {\n        Arrays.sort(ins, (a, b)->{\n            return a[1] != b[1] ? a[1] - b[1] : b[0] - a[0];\n        });\n        int a = -1, b = -1, ans = 0;\n        for (int[] i : ins) {\n            if (i[0] > b) {\n                a = i[1] - 1; b = i[1];\n                ans += 2;\n            } else if (i[0] > a) {\n                a = b; b = i[1];\n                ans++;\n            }\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction intersectionSizeTwo(ins: number[][]): number {\n    ins = ins.sort((a, b)=> {\n        return a[1] != b[1] ? a[1] - b[1] : b[0] - a[0]\n    });\n    let a = -1, b = -1, ans = 0\n    for (const i of ins) {\n        if (i[0] > b) {\n            a = i[1] - 1; b = i[1]\n            ans += 2\n        } else if (i[0] > a) {\n            a = b; b = i[1]\n            ans++\n        }\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.752` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/761-770/761. 特殊的二进制序列（困难）.md", "url_title": "761. 特殊的二进制序列", "url": "https://leetcode.cn/problems/special-binary-string/solution/by-ac_oier-cz6h/", "difficulty": "困难", "tags": ["构造"], "question": "特殊的二进制序列是具有以下两个性质的二进制序列:\n\n* `0` 的数量与 `1` 的数量相等。\n* 二进制序列的每一个前缀码中 `1` 的数量要大于等于 `0` 的数量。\n\n给定一个特殊的二进制序列 `S`,以字符串形式表示。定义一个操作为首先选择 `S` 的两个连续且非空的特殊的子串,然后将它们交换。(两个子串为连续的当且仅当第一个子串的最后一个字符恰好为第二个子串的第一个字符的前一个字符。)\n\n在任意次数的操作之后,交换后的字符串按照字典序排列的最大的结果是什么?\n\n示例 1:\n```\n输入: S = \"11011000\"\n\n输出: \"11100100\"\n\n解释:\n将子串 \"10\" (在S[1]出现) 和 \"1100\" (在S[3]出现)进行交换。\n这是在进行若干次操作后按字典序排列最大的结果。\n```\n说明:\n* `S` 的长度不超过 $50$。\n* `S` 保证为一个满足上述定义的特殊 的二进制序列。", "solution": "### 构造\n\n我们可以定义每个字符的得分:字符 `1` 得分为 $1$ 分,字符 `0` 得分为 $-1$ 分。\n\n根据题目对「特殊字符串」的定义可知,给定字符串 `s` 的总得分为 $0$,且任意前缀串不会出现得分为负数的情况。\n\n考虑将 `s` 进行划分为多个足够小特殊字符串 `item`(足够小的含义为每个 `item` 无法再进行划分),每个 `item` 的总得分为 $0$。根据 `s` 定义,必然可恰好划分为多个 `item`。\n\n每次操作可以将相邻特殊字符串进行交换,于是问题转换为将 `s` 进行重排,求其重排后字典序最大的方案。\n\n首先可以证明一个合法 `item` 必然满足 `1...0` 的形式,可通过「反证法」进行进行证明:定义了 `item` 总得分为 $0$,且长度不为 $0$,因此必然有 `1` 有 `0`。**若第一位字符为 `0`,则必然能够从第一位字符作为起点,找到一个得分为负数的子串,这与 `s` 本身的定义冲突(`s` 中不存在得分为负数的前缀串);若最后一位为 `1`,根据 `item` 总得分为 $0$,可知当前 `item` 去掉最后一位后得分为负,也与 `s` 本身定义冲突(`s` 中不存在得分为负数的前缀串)。**\n\n因此可将构造分两步进行:\n\n1. 对于每个 `item` 进行重排,使其调整为字典序最大\n2. 对于 `item` 之间的位置进行重排,使其整体字典序最大\n\n由于题目没有规定重排后的性质,为第一步调整和第二步调整的保持相对独立,我们只能对 `item` 中的 `1...0` 中的非边缘部分进行调整(递归处理子串部分)。\n\n假设所有 `item` 均被处理后,考虑如何进行重排能够使得最终方案字典序最大。\n\n若有两个 `item`,分别为 `a` 和 `b`,我们可以根据拼接结果 `ab` 和 `ba` 的字典序大小来决定将谁放在前面。\n\n**这样根据「排序比较逻辑」需要证明在集合上具有[「全序关系」](https://baike.baidu.com/item/%E5%85%A8%E5%BA%8F%E5%85%B3%E7%B3%BB):**\n\n我们使用符号 $@$ 来代指我们的「排序」逻辑:\n\n* 如果 $a$ 必须排在 $b$ 的前面,我们记作 `a@b`;\n* 如果 $a$ 必须排在 $b$ 的后面,我们记作 `b@a`;\n* 如果 $a$ 既可以排在 $b$ 的前面,也可以排在 $b$ 的后面,我们记作 `a#b`;\n\n**2.1 完全性**\n\n**具有完全性是指从集合 `items` 中任意取出两个元素 $a$ 和 $b$,必然满足 `a@b`、`b@a` 和 `a#b` 三者之一。**\n\n**这点其实不需要额外证明,因为由 $a$ 和 $b$ 拼接的字符串 $ab$ 和 $ba$ 所在「字典序大小关系中」要么完全相等,要么具有明确的字典序大小关系,导致 $a$ 必须排在前面或者后面。**\n\n**2.2 反对称性**\n\n**具有反对称性是指由 `a@b` 和 `b@a` 能够推导出 `a#b`。**\n\n$a@b$ 说明字符串 $ab$ 的字典序大小数值要比字符串 $ba$ 字典序大小数值大。\n\n$b@a$ 说明字符串 $ab$ 的字典序大小数值要比字符串 $ba$ 字典序大小数值小。\n\n**这样,基于「字典序本身满足全序关系」和「数学上的 $a \\geqslant b$ 和 $a \\leqslant b$ 可推导出 $a = b$」。**\n\n**得证 `a@b` 和 `b@a` 能够推导出 `a#b`。**\n\n**2.3 传递性**\n\n**具有传递性是指由 `a@b` 和 `b@c` 能够推导出 `a@c`。**\n\n**我们可以利用「两个等长的拼接字符串,字典序大小关系与数值大小关系一致」这一性质来证明,因为字符串 $ac$ 和 $ca$ 必然是等长的。**\n\n接下来,让我们从「自定义排序逻辑」出发,换个思路来证明 `a@c`:\n\n**然后我们只需要证明在不同的 $i$ $j$ 关系之间(共三种情况),`a@c` 恒成立即可:**\n\n1. 当 $i == j$ 的时候:\n\n2. 当 $i > j$ 的时候:\n\n3. 当 $i < j$ 的时候:\n\n**综上,我们证明了无论在何种情况下,只要有 `a@b` 和 `b@c` 的话,那么 `a@c` 恒成立。**\n\n**我们之所以能这样证明「传递性」,本质是利用了自定义排序逻辑中「对于确定任意元素 $a$ 和 $b$ 之间的排序关系只依赖于 $a$ 和 $b$ 的第一个不同元素之间的大小关系」这一性质。**\n\n最终,我们证明了该「排序比较逻辑」必然能排序出字典序最大的方案。\n\nJava 代码:\n```Java\nclass Solution {\n    public String makeLargestSpecial(String s) {\n        if (s.length() == 0) return s;\n        List<String> list = new ArrayList<>();\n        char[] cs = s.toCharArray();\n        for (int i = 0, j = 0, k = 0; i < cs.length; i++) {\n            k += cs[i] == '1' ? 1 : -1;\n            if (k == 0) {\n                list.add(\"1\" + makeLargestSpecial(s.substring(j + 1, i)) + \"0\");\n                j = i + 1;\n            }\n        }\n        Collections.sort(list, (a, b)->(b + a).compareTo(a + b));\n        StringBuilder sb = new StringBuilder();\n        for (String str : list) sb.append(str);\n        return sb.toString();\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction makeLargestSpecial(s: string): string {\n    const list = new Array<string>()\n    for (let i = 0, j = 0, k = 0; i < s.length; i++) {\n        k += s[i] == '1' ? 1 : -1\n        if (k == 0) {\n            list.push('1' + makeLargestSpecial(s.substring(j + 1, i)) + '0')\n            j = i + 1\n        }\n    }\n    list.sort((a, b)=>(b + a).localeCompare(a + b));\n    return [...list].join(\"\")\n};\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.761` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/761-770/762. 二进制表示中质数个计算置位（简单）.md", "url_title": "762. 二进制表示中质数个计算置位", "url": "https://leetcode-cn.com/problems/prime-number-of-set-bits-in-binary-representation/solution/by-ac_oier-w50x/", "difficulty": "简单", "tags": ["模拟", "位运算"], "question": "给你两个整数 `left` 和 `right`,在闭区间 $[left, right]$ 范围内,统计并返回计算置位位数为质数的整数个数。\n\n计算置位位数就是二进制表示中 $1$ 的个数。\n\n例如, $21$ 的二进制表示 `10101` 有 $3$ 个计算置位。\n\n示例 1:\n```\n输入:left = 6, right = 10\n\n输出:4\n\n解释:\n6 -> 110 (2 个计算置位,2 是质数)\n7 -> 111 (3 个计算置位,3 是质数)\n9 -> 1001 (2 个计算置位,2 是质数)\n10-> 1010 (2 个计算置位,2 是质数)\n共计 4 个计算置位为质数的数字。\n```\n示例 2:\n```\n输入:left = 10, right = 15\n\n输出:5\n\n解释:\n10 -> 1010 (2 个计算置位, 2 是质数)\n11 -> 1011 (3 个计算置位, 3 是质数)\n12 -> 1100 (2 个计算置位, 2 是质数)\n13 -> 1101 (3 个计算置位, 3 是质数)\n14 -> 1110 (3 个计算置位, 3 是质数)\n15 -> 1111 (4 个计算置位, 4 不是质数)\n共计 5 个计算置位为质数的数字。\n```\n\n提示:\n* $1 <= left <= right <= 10^6$\n* $0 <= right - left <= 10^4$", "solution": "### 模拟 + lowbit\n\n利用一个 `int` 的二进制表示不超过 $32$,我们可以先将 $32$ 以内的质数进行打表。\n\n从前往后处理 $[left, right]$ 中的每个数 $x$,利用 `lowbit` 操作统计 $x$ 共有多少位 $1$,记为 $cnt$,若 $cnt$ 为质数,则对答案进行加一操作。\n\n代码:\n```Java\nclass Solution {\n    static boolean[] hash = new boolean[40];\n    static {\n        int[] nums = new int[]{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};\n        for (int x : nums) hash[x] = true;\n    }\n    public int countPrimeSetBits(int left, int right) {\n        int ans = 0;\n        for (int i = left; i <= right; i++) {\n            int x = i, cnt = 0;\n            while (x != 0 && ++cnt >= 0) x -= (x & -x);\n            if (hash[cnt]) ans++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O((right - left) * \\log{right})$\n* 空间复杂度:$O(C)$\n\n---\n\n### 模拟 + 分治\n\n枚举 $[left, right]$ 范围内的数总是不可避免,上述解法的复杂度取决于复杂度为 $O(\\log{x})$ 的 `lowbit` 操作。\n\n而比 `lowbit` 更加优秀的统计「二进制 $1$ 的数量」的做法最早在 [(题解) 191. 位1的个数](https://leetcode-cn.com/problems/number-of-1-bits/solution/yi-ti-san-jie-wei-shu-jian-cha-you-yi-to-av1r/) 讲过,采用「分治」思路对二进制进行成组统计,复杂度为 $O(\\log{\\log{x}})$。\n\n代码:\n```Java\nclass Solution {\n    static boolean[] hash = new boolean[40];\n    static {\n        int[] nums = new int[]{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};\n        for (int x : nums) hash[x] = true;\n    }\n    public int countPrimeSetBits(int left, int right) {\n        int ans = 0;\n        for (int i = left; i <= right; i++) {\n            int x = i;\n            x = (x & 0x55555555) + ((x >>> 1)  & 0x55555555);\n            x = (x & 0x33333333) + ((x >>> 2)  & 0x33333333);\n            x = (x & 0x0f0f0f0f) + ((x >>> 4)  & 0x0f0f0f0f);\n            x = (x & 0x00ff00ff) + ((x >>> 8)  & 0x00ff00ff);\n            x = (x & 0x0000ffff) + ((x >>> 16) & 0x0000ffff);\n            if (hash[x]) ans++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O((right - left) * \\log{\\log{right}})$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.762` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/761-770/764. 最大加号标志（中等）.md", "url_title": "764. 最大加号标志", "url": "https://leetcode.cn/problems/largest-plus-sign/solution/by-ac_oier-q932/", "difficulty": "中等", "tags": ["模拟", "预处理"], "question": "在一个 $n \\times n$ 的矩阵 `grid` 中,除了在数组 `mines` 中给出的元素为 `0`,其他每个元素都为 `1`。$mines[i] = [x_i, y_i]$ 表示 $grid[x_i][y_i] = 0$。\n\n返回  `grid` 中包含 `1` 的最大的轴对齐加号标志的阶数 。\n\n如果未找到加号标志,则返回 `0` 。\n\n一个 `k` 阶由 `1` 组成的 “轴对称”加号标志 具有中心网格 $grid[r][c] = 1$ ,以及 `4` 个从中心向上、向下、向左、向右延伸,长度为 `k-1`,由 `1` 组成的臂。\n\n注意,只有加号标志的所有网格要求为 `1` ,别的网格可能为 `0` 也可能为 `1` 。\n\n示例 1:\n\n```\n输入: n = 5, mines = [[4, 2]]\n\n输出: 2\n\n解释: 在上面的网格中,最大加号标志的阶只能是2。一个标志已在图中标出。\n```\n示例 2:\n\n```\n输入: n = 1, mines = [[0, 0]]\n\n输出: 0\n\n解释: 没有加号标志,返回 0 。\n```\n\n提示:\n* $1 <= n <= 500$\n* $1 <= mines.length <= 5000$\n* $0 <= x_i, y_i < n$\n* 每一对 $(x_i, y_i)$ 都 不重复", "solution": "### 预处理 + 模拟\n\n假设点 $(x, y)$ 能够取得最大长度 $k$,我们知道 $k$ 取决于以点 $(x, y)$ 为起点,四联通方向中「最短的连续 $1$ 的长度」。\n\n基于此,我们可以建立四个大小为 $n \\times n$ 的矩阵(二维数组)`a`、`b`、`c` 和 `d` 分别代表四个方向连续 $1$ 的前缀数:\n\n数据范围为 $500$,预处理前缀数组复杂度为 $O(n^2)$,统计答案复杂度为 $O(n^2)$,时间复杂度没有问题。\n\n再考虑空间,建立四个方向的前缀数组所需空间为 $500 \\times 500 \\times 4 = 10^6$,即使加上原矩阵 `g` 也不会有 `MLE` 风险,空间复杂度也没有问题。\n\nJava 代码:\n```Java\nclass Solution {\n    public int orderOfLargestPlusSign(int n, int[][] mines) {\n        int[][] g = new int[n + 10][n + 10];\n        for (int i = 1; i <= n; i++) Arrays.fill(g[i], 1);\n        for (int[] info : mines) g[info[0] + 1][info[1] + 1] = 0;\n        int[][] a = new int[n + 10][n + 10], b = new int[n + 10][n + 10], c = new int[n + 10][n + 10], d = new int[n + 10][n + 10];\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= n; j++) {\n                if (g[i][j] == 1) {\n                    a[i][j] = a[i - 1][j] + 1;\n                    b[i][j] = b[i][j - 1] + 1;\n                }\n                if (g[n + 1 - i][n + 1 - j] == 1) {\n                    c[n + 1 - i][n + 1 - j] = c[n + 2 - i][n + 1 - j] + 1;\n                    d[n + 1 - i][n + 1 - j] = d[n + 1 - i][n + 2 - j] + 1;\n                }\n            }\n        }\n        int ans = 0;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= n; j++) {\n                ans = Math.max(ans, Math.min(Math.min(a[i][j], b[i][j]), Math.min(c[i][j], d[i][j])));\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int orderOfLargestPlusSign(int n, vector<vector<int>>& mines) {\n        vector<vector<int>> g(n + 10, vector<int>(n + 10, 1));\n        for (vector<int>& info : mines) g[info[0] + 1][info[1] + 1] = 0;\n        vector<vector<int>> a(n + 10, vector<int>(n + 10)), b(n + 10, vector<int>(n + 10)), c(n + 10, vector<int>(n + 10)), d(n + 10, vector<int>(n + 10));\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= n; j++) {\n                if (g[i][j] == 1) {\n                    a[i][j] = a[i - 1][j] + 1;\n                    b[i][j] = b[i][j - 1] + 1;\n                }\n                if (g[n + 1 - i][n + 1 - j] == 1) {\n                    c[n + 1 - i][n + 1 - j] = c[n + 2 - i][n + 1 - j] + 1;\n                    d[n + 1 - i][n + 1 - j] = d[n + 1 - i][n + 2 - j] + 1;\n                }\n            }\n        }\n        int ans = 0;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= n; j++) {\n                ans = max(ans, min(min(a[i][j], b[i][j]), min(c[i][j], d[i][j])));\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def orderOfLargestPlusSign(self, n: int, mines: List[List[int]]) -> int:\n        g = [[1] * (n + 10) for _ in range(n + 10)]\n        for x, y in mines:\n            g[x + 1][y + 1] = 0\n        a, b, c, d = [[0] * (n + 10) for _ in range(n + 10)], [[0] * (n + 10) for _ in range(n + 10)], [[0] * (n + 10) for _ in range(n + 10)], [[0] * (n + 10) for _ in range(n + 10)]\n        for i in range(1, n + 1):\n            for j in range(1, n + 1):\n                if g[i][j] == 1:\n                    a[i][j] = a[i - 1][j] + 1\n                    b[i][j] = b[i][j - 1] + 1\n                if g[n + 1 - i][n + 1 - j] == 1:\n                    c[n + 1 - i][n + 1 - j] = c[n + 2 - i][n + 1 - j] + 1\n                    d[n + 1 - i][n + 1 - j] = d[n + 1 - i][n + 2 - j] + 1\n        ans = 0\n        for i in range(1, n + 1):\n            for j in range(1, n + 1):\n                ans = max(ans, min(min(a[i][j], b[i][j]), min(c[i][j], d[i][j])))\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction orderOfLargestPlusSign(n: number, mines: number[][]): number {\n    function getMat(x: number, y: number, val: number): number[][] {\n        const ans = new Array<Array<number>>(x)\n        for (let i = 0; i < x; i++) ans[i] = new Array<number>(y).fill(val)\n        return ans\n    }\n    const g = getMat(n + 10, n + 10, 1)\n    for (const info of mines) g[info[0] + 1][info[1] + 1] = 0\n    const a = getMat(n + 10, n + 10, 0), b = getMat(n + 10, n + 10, 0), c = getMat(n + 10, n + 10, 0), d = getMat(n + 10, n + 10, 0)\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= n; j++) {\n            if (g[i][j] == 1) {\n                a[i][j] = a[i - 1][j] + 1\n                b[i][j] = b[i][j - 1] + 1\n            }\n            if (g[n + 1 - i][n + 1 - j] == 1) {\n                c[n + 1 - i][n + 1 - j] = c[n + 2 - i][n + 1 - j] + 1\n                d[n + 1 - i][n + 1 - j] = d[n + 1 - i][n + 2 - j] + 1\n            }\n        }\n    }\n    let ans = 0\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= n; j++) {\n            ans = Math.max(ans, Math.min(Math.min(a[i][j], b[i][j]), Math.min(c[i][j], d[i][j])))\n        }\n    }\n    return ans\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.764` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/761-770/765. 情侣牵手（困难）.md", "url_title": "765. 情侣牵手", "url": "https://leetcode-cn.com/problems/couples-holding-hands/solution/liang-chong-100-de-jie-fa-bing-cha-ji-ta-26a6/", "difficulty": "困难", "tags": ["并查集", "贪心"], "question": "N 对情侣坐在连续排列的 2N 个座位上,想要牵到对方的手。 计算最少交换座位的次数,以便每对情侣可以并肩坐在一起。 一次交换可选择任意两人,让他们站起来交换座位。\n\n人和座位用 0 到 2N-1 的整数表示,情侣们按顺序编号,第一对是 (0, 1),第二对是 (2, 3),以此类推,最后一对是 (2N-2, 2N-1)。\n\n这些情侣的初始座位  row[i] 是由最初始坐在第 i 个座位上的人决定的。\n\n示例 1:\n```\n输入: row = [0, 2, 1, 3]\n输出: 1\n解释: 我们只需要交换row[1]和row[2]的位置即可。\n```\n示例 2:\n```\n输入: row = [3, 2, 0, 1]\n输出: 0\n解释: 无需交换座位,所有的情侣都已经可以手牵手了。\n```\n说明:\n* len(row) 是偶数且数值在 [4, 60]范围内。\n* 可以保证row 是序列 `0...len(row)-1` 的一个全排列。", "solution": "### 并查集\n\n首先,我们总是以「情侣对」为单位进行设想:\n\n1. 当有两对情侣相互坐错了位置,ta们两对之间形成了一个环。需要进行一次交换,使得每队情侣独立(相互牵手)\n\n2. 如果三对情侣相互坐错了位置,ta们三对之间形成了一个环,需要进行两次交换,使得每队情侣独立(相互牵手)\n\n3. 如果四对情侣相互坐错了位置,ta们四对之间形成了一个环,需要进行三次交换,使得每队情侣独立(相互牵手)\n\n也就是说,如果我们有 `k` 对情侣形成了错误环,需要交换 `k - 1` 次才能让情侣牵手。\n\n**于是问题转化成 `n / 2` 对情侣中,有多少个这样的环。**\n\n可以直接使用「并查集」来做。\n\n由于 0和1配对、2和3配对 ... 因此互为情侣的两个编号除以 2 对应同一个数字,可直接作为它们的「情侣组」编号:\n\n```Java\n class Solution {\n    int[] p = new int[70];\n    void union(int a, int b) {\n        p[find(a)] = p[find(b)];\n    }\n    int find(int x) {\n        if (p[x] != x) p[x] = find(p[x]);\n        return p[x];\n    }\n    public int minSwapsCouples(int[] row) {\n        int n = row.length, m = n / 2;\n        for (int i = 0; i < m; i++) p[i] = i;\n        for (int i = 0; i < n; i += 2) union(row[i] / 2, row[i + 1] / 2);\n        int cnt = 0;\n        for (int i = 0; i < m; i++) {\n            if (i == find(i)) cnt++;\n        }\n        return m - cnt;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 贪心\n\n还是以「情侣对」为单位进行分析:\n\n由于题目保证有解,我们也可以从前往后(每两格作为一步)处理,对于某一个位置而言,如果下一个位置不是应该出现的情侣的话。\n\n则对下一个位置进行交换。\n\n同时为了方便我们找到某个值的下标,需要先对 `row` 进行预处理(可以使用哈希表或数组)。\n\n```Java\nclass Solution {\n    public int minSwapsCouples(int[] row) {\n        int n = row.length;\n        int ans = 0;\n        int[] cache = new int[n];\n        for (int i = 0; i < n; i++) cache[row[i]] = i;\n        for (int i = 0; i < n - 1; i += 2) {\n            int a = row[i], b = a ^ 1;\n            if (row[i + 1] != b) {\n                int src = i + 1, tar = cache[b];\n                cache[row[tar]] = src;\n                cache[row[src]] = tar;\n                swap(row, src, tar);\n                ans++;\n            }\n        }\n        return ans;\n    }\n    void swap(int[] nums, int a, int b) {\n        int c = nums[a];\n        nums[a] = nums[b];\n        nums[b] = c;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 证明/分析\n\n我们这样的做法本质是什么?\n\n**其实相当于,当我处理到第 `k` 个位置的时候,前面的 `k - 1` 个位置的情侣已经牵手成功了。我接下来怎么处理,能够使得总花销最低。**\n\n分两种情况讨论:\n\na. 现在处理第 `k` 个位置,使其牵手成功:\n\n那么我要使得第 `k` 个位置的情侣也牵手成功,那么必然是保留第 `k` 个位置的情侣中其中一位,再进行修改,这样的成本是最小的(因为只需要交换一次)。\n\n而且由于前面的情侣已经牵手成功了,因此交换的情侣必然在 `k` 位置的后面。\n\n然后我们再考虑交换左边或者右边对最终结果的影响。\n\n分两种情况来讨论:\n\n1. 与第 `k` 个位置的匹配的两个情侣不在同一个位置上:这时候无论交换左边还是右边,后面需要调整的「情侣对数量」都是一样。假设处理第 `k` 个位置前需要调整的数量为 `n` 的话,处理完第 `k` 个位置(交换左边或是右边),需要调整的「情侣对数量」都为 `n - 1` 。\n\n2. 与第 `k` 个位置的匹配的两个情侣在同一个位置上:这时候无论交换左边还是右边,后面需要调整的「情侣对数量」都是一样。假设处理第 `k` 个位置前需要调整的数量为 `n` 的话,处理完第 `k` 个位置(交换左边或是右边),需要调整的「情侣对数量」都为 `n - 2` 。\n\n因此对于第 `k` 个位置而言,交换左边还是右边,并不会影响后续需要调整的「情侣对数量」。\n\nb. 现在先不处理第 `k` 个位置,等到后面的情侣处理的时候「顺便」处理第 `k` 位置:\n\n由于我们最终都是要所有位置的情侣牵手,而且每一个数值对应的情侣数值是唯一确定的。\n\n因此我们这个等“后面”的位置处理,其实就是等与第 `k` 个位置互为情侣的位置处理(对应上图的就是我们是在等 【0 x】和【8 y】或者【0 8】这些位置被处理)。\n\n由于被处理都是同一批的联通位置,因此和「a. 现在处理第 `k` 个位置」的分析结果是一样的。\n\n---\n\n不失一般性的,我们可以将这个分析推广到第一个位置,其实就已经是符合「当我处理到第 `k` 个位置的时候,前面的 `k - 1` 个位置的情侣已经牵手成功了」的定义了。\n\n**综上所述,我们只需要确保从前往后处理,并且每次处理都保留第 `k` 个位置的其中一位,无论保留的左边还是右边都能得到最优解。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.765` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/761-770/766. 托普利茨矩阵（简单）.md", "url_title": "766. 托普利茨矩阵", "url": "https://leetcode-cn.com/problems/toeplitz-matrix/solution/cong-ci-pan-du-qu-cheng-ben-fen-xi-liang-f20w/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个 m x n 的矩阵 matrix 。如果这个矩阵是托普利茨矩阵,返回 true ;否则,返回 false 。\n\n如果矩阵上每一条由左上到右下的对角线上的元素都相同,那么这个矩阵是 托普利茨矩阵 。\n\n示例 1:\n\n```\n输入:matrix = [[1,2,3,4],[5,1,2,3],[9,5,1,2]]\n输出:true\n解释:\n在上述矩阵中, 其对角线为: \n\"[9]\", \"[5, 5]\", \"[1, 1, 1]\", \"[2, 2, 2]\", \"[3, 3]\", \"[4]\"。 \n各条对角线上的所有元素均相同, 因此答案是 True 。\n```\n示例 2:\n\n```\n输入:matrix = [[1,2],[2,2]]\n输出:false\n解释:\n对角线 \"[1, 2]\" 上的元素不同。\n```\n\n提示:\n* m == matrix.length\n* n == matrix[i].length\n* 1 <= m, n <= 20\n* 0 <= matrix[i][j] <= 99\n\n进阶:\n* 如果矩阵存储在磁盘上,并且内存有限,以至于一次最多只能将矩阵的一行加载到内存中,该怎么办?\n* 如果矩阵太大,以至于一次只能将不完整的一行加载到内存中,该怎么办?", "solution": "### 按「格子」遍历\n\n对于一个合格的「托普利茨矩阵」而言,每个格子总是与其左上角格子相等(如果有的话)。\n\n我们以「格子」为单位进行遍历,每次与左上角的格子进行检查即可。\n\n这样我们每对一个格子进行判断,都要读 `matrix` 上的两个格子的值(即**非边缘格子其实会被读取两次**)。\n\n```Java\nclass Solution {\n    public boolean isToeplitzMatrix(int[][] matrix) {\n        int m = matrix.length, n = matrix[0].length;\n        for (int i = 1; i < m; i++) {\n            for (int j = 1; j < n; j++) {\n                if (matrix[i][j] != matrix[i - 1][j - 1]) return false;\n            }\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n * m)$\n* 空间复杂度:$O(1)$\n\n***\n\n### 按「线」遍历\n\n如果稍微增加一点点难度:限制每个格子只能被读取一次呢?\n\n这时候我们也可以按照「线」为单位进行检查。\n\n当一条完整的斜线值都相等,我们再对下一条斜线做检查。\n\n这样对于每个格子,我们都是**严格只读取一次**(如果整个矩阵是存在磁盘中,且不考虑操作系统的按页读取等机制,那么 IO 成本将下降为原来的一半)。\n\n```Java\nclass Solution {\n    public boolean isToeplitzMatrix(int[][] matrix) {\n        int m = matrix.length, n = matrix[0].length;\n        int row = m, col = n;\n        while (col-- > 0) {\n            for (int i = 0, j = col, val = matrix[i++][j++]; i < m && j < n; i++, j++) {\n                if (matrix[i][j] != val) return false;\n            }\n        }\n        while (row-- > 0) {\n            for (int i = row, j = 0, val = matrix[i++][j++]; i < m && j < n; i++, j++) {\n                if (matrix[i][j] != val) return false;\n            }\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n * m)$\n* 空间复杂度:$O(1)$\n\n***\n\n### 进阶\n\n1. 如果矩阵存储在磁盘上,并且内存有限,以至于一次最多只能将矩阵的一行加载到内存中,该怎么办?\n使用「背包问题」的一维优化思路:假设我们有装载一行数据大小的内存,每次读取新的行时都进行「从右往左」的覆盖,每次覆盖都与前一个位置的进行比较(其实就是和上一行的左上角位置进行比较)。\n\n如图:\n\n如果你对更多「背包问题」相关内容感兴趣,可以看我这篇总结:[深度讲解背包问题](https://leetcode-cn.com/circle/discuss/GWpXCM/)\n\n2. 如果矩阵太大,以至于一次只能将不完整的一行加载到内存中,该怎么办?\n亲,这边建议升级内存,啊呸 ...\n将问题看做子问题进行解决:调整读取矩阵的方式(按照垂直方向进行读取);或使用额外数据记录当前当前片段的行/列数。\n更为合理的解决方案是:存储的时候按照「数组」的形式进行存储(行式存储),然后读取的时候计算偏移量直接读取其「左上角」或者「右下角」的值。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.761` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/761-770/768. 最多能完成排序的块 II（困难）.md", "url_title": "768. 最多能完成排序的块 II", "url": "https://leetcode.cn/problems/max-chunks-to-make-sorted-ii/solution/by-ac_oier-z4wt/", "difficulty": "困难", "tags": ["贪心"], "question": "这个问题和“最多能完成排序的块”相似,但给定数组中的元素可以重复,输入数组最大长度为$2000$,其中的元素最大为 $10^8$。\n\n`arr` 是一个可能包含重复元素的整数数组,我们将这个数组分割成几个“块”,并将这些块分别进行排序。之后再连接起来,使得连接的结果和按升序排序后的原数组相同。\n\n我们最多能将数组分成多少块?\n\n示例 1:\n```\n输入: arr = [5,4,3,2,1]\n\n输出: 1\n\n解释:\n将数组分成2块或者更多块,都无法得到所需的结果。\n例如,分成 [5, 4], [3, 2, 1] 的结果是 [4, 5, 1, 2, 3],这不是有序的数组。 \n```\n示例 2:\n```\n输入: arr = [2,1,3,4,4]\n\n输出: 4\n\n解释:\n我们可以把它分成两块,例如 [2, 1], [3, 4, 4]。\n然而,分成 [2, 1], [3], [4], [4] 可以得到最多的块数。 \n```\n注意:\n* `arr` 的长度在 $[1, 2000]$ 之间。\n* `arr[i]` 的大小在 $[0, 10^8]$ 之间。", "solution": "### 贪心 + 构造\n\n一种容易想到的构造方法,是与目标序列(已排升序的数组 `clone`)做区间比较。\n\n由于题目要求尽可能划分出多的区间,我们可以从前往后处理 `arr` 和 `clone` 时统计区间内数的情况,若有 `arr[i...j]` 和 `clone[i...j]` 词频完全相同,可知 `arr[i...j]` 可通过内部排序调整为 `clone[i...j]`,此时我们将范围 $[i...j]$ 划分为一个区间,然后继续往后处理直到整个数组处理完。\n\n容易证明该做法的正确性:可从边界开始进行归纳分析,起始两者均从下标为 $0$ 的位置进行扫描。假设最优解和贪心解的第一个区间的结束位置相同,问题就会归结到子问题上(即双方均从相同的子数组起始位置开始构造),因此无须额外证明;而当起始位置相同,结束位置不同时,假设分别为 $clone[i...j_1]$ 和 $arr[i...j_2]$,则必然有 $j_1 > j_2$(因为如果有 $j_1 < j_2$,那么在 $arr$ 扫描到 $j_1$ 位置时已经满足划分区间的条件,已经会停下来,即与贪心决策逻辑冲突),而当 $j_1 > j_2$ 时,我们可以将最优解中的区间 $clone[i...j_1]$ 进一步划分为 $clone[i...j_2]$ 和 $clone[j_2+1 ... j_1]$ 两段,同时不影响后续的构造过程,使得最终划分的区间数增大,即与最优解本身无法划分冲突。\n\n根据数值之间满足严格全序,可知当 $j_1 > j_2$ 和 $j_1 < j_2$ 均不满足时,必然有 $j_1 = j_2$ 为真。\n\n综上,我们证明了对于相同起点,贪心解与最优解结束位置必然相同,从而证明贪心解区间数与最优解相等。\n\n于是原问题转换为如何快速对两数组(原数组 `arr` 和目标数组 `clone`)进行词频比较,由于数值的范围为 $10^8$,如果使用最裸的词频对比方案的话,需要先进行离散化,最终算法的复杂度为 $O(n\\log{n} + n^2)$。而更好的解决方案是使用哈希表进行计数,同时维护当前计数不为 $0$ 的数值数量 `tot`,具体的,当我们处理 $arr[i]$ 时,我们在哈希表中对 $arr[i]$ 进行计数加一,而在处理 $clone[i]$ 时,对 $clone[i]$ 进行计数减一。从而将词频比较的复杂度从 $O(n^2)$ 下降到 $O(n)$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxChunksToSorted(int[] arr) {\n        int[] clone = arr.clone();\n        Arrays.sort(clone);\n        int n = arr.length, ans = 0;\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = 0, tot = 0; i < n; i++) {\n            int a = arr[i], b = clone[i];\n            if (map.getOrDefault(a, 0) == -1) tot--;\n            else if (map.getOrDefault(a, 0) == 0) tot++;\n            map.put(a, map.getOrDefault(a, 0) + 1);\n            if (map.getOrDefault(b, 0) == 1) tot--;\n            else if (map.getOrDefault(b, 0) == 0) tot++;\n            map.put(b, map.getOrDefault(b, 0) - 1);\n            if (tot == 0) ans++;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction maxChunksToSorted(arr: number[]): number {\n    let clone = [...arr].sort((a,b)=>a-b)\n    let n = arr.length, ans = 0\n    const map = new Map<number, number>()\n    for (let i = 0, tot = 0; i < n; i++) {\n        const a = arr[i], b = clone[i]\n        if (!map.has(a)) map.set(a, 0)\n        if (map.get(a) == 0) tot++\n        else if (map.get(a) == -1) tot--;\n        map.set(a, map.get(a) + 1)\n        if (!map.has(b)) map.set(b, 0)\n        if (map.get(b) == 0) tot++\n        else if (map.get(b) == 1) tot--\n        map.set(b, map.get(b) - 1)\n        if (tot == 0) ans++\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.768` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/761-770/769. 最多能完成排序的块（中等）.md", "url_title": "769. 最多能完成排序的块", "url": "https://leetcode.cn/problems/max-chunks-to-make-sorted/solution/by-ac_oier-4uny/", "difficulty": "中等", "tags": ["模拟"], "question": "给定一个长度为 `n` 的整数数组 `arr` ,它表示在 $[0, n - 1]$ 范围内的整数的排列。\n\n我们将 `arr` 分割成若干块 (即分区),并对每个块单独排序。\n\n将它们连接起来后,使得连接的结果和按升序排序后的原数组相同。\n\n返回数组能分成的最多块数量。\n\n示例 1:\n```\n输入: arr = [4,3,2,1,0]\n\n输出: 1\n\n解释:\n将数组分成2块或者更多块,都无法得到所需的结果。\n例如,分成 [4, 3], [2, 1, 0] 的结果是 [3, 4, 0, 1, 2],这不是有序的数组。\n```\n示例 2:\n```\n输入: arr = [1,0,2,3,4]\n\n输出: 4\n\n解释:\n我们可以把它分成两块,例如 [1, 0], [2, 3, 4]。\n然而,分成 [1, 0], [2], [3], [4] 可以得到最多的块数。\n```\n\n提示:\n* $n = arr.length$\n* $1 <= n <= 10$\n* $0 <= arr[i] < n$\n* `arr` 中每个元素都不同", "solution": "### 模拟\n\n本题考察的是简单模拟能力,或者说是简单的对「循环不变量」的设计。\n\n我们从前往后处理所有的 $arr[i]$(即 `i` 定义为当前划分块的右边界下标),处理过程中定义变量 `j` 为当前划分块的左边界下标(初始值为 $0$),定义 `min` 为当前划分块中元素最小值(初始值为 $arr[0]$ 或 $n$),定义 `max` 为当前划分块中元素最大值(初始值为 $arr[0]$ 或 $-1$)。\n\n当且仅当 $j = min$ 且 $i = max$ 时,下标范围 $[j, i]$ 排序结果为 $[min, max]$,此时块的个数加一,并重新初始化几个变量,继续循环统计下个块的信息。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxChunksToSorted(int[] arr) {\n        int n = arr.length, ans = 0;\n        for (int i = 0, j = 0, min = n, max = -1; i < n; i++) {\n            min = Math.min(min, arr[i]);\n            max = Math.max(max, arr[i]);\n            if (j == min && i == max) {\n                ans++; j = i + 1; min = n; max = -1;\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxChunksToSorted(vector<int>& arr) {\n        int n = arr.size(), ans = 0;\n        int j = 0, minv = n, maxv = -1;\n        for (int i = 0; i < n; i++) {\n            minv = min(minv, arr[i]);\n            maxv = max(maxv, arr[i]);\n            if (j == minv && i == maxv) {\n                ans++; j = i + 1; minv = n; maxv = -1;\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxChunksToSorted(self, arr: List[int]) -> int:\n        n, ans = len(arr), 0\n        j, minv, maxv = 0, n, -1\n        for i in range(n):\n            minv, maxv = min(minv, arr[i]), max(maxv, arr[i])\n            if j == minv and i == maxv:\n                ans, j, minv, maxv = ans + 1, i + 1, n, -1\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction maxChunksToSorted(arr: number[]): number {\n    let n = arr.length, ans = 0\n    for (let i = 0, j = 0, min = n, max = -1; i < n; i++) {\n        min = Math.min(min, arr[i])\n        max = Math.max(max, arr[i])\n        if (j == min && i == max) {\n            ans++; j = i + 1; min = n; max = -1;\n        }\n    }\n    return ans\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.769` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/771-780/773. 滑动谜题（困难）.md", "url_title": "773. 滑动谜题", "url": "https://leetcode-cn.com/problems/sliding-puzzle/solution/gong-shui-san-xie-fa-hui-a-suan-fa-zui-d-3go8/", "difficulty": "困难", "tags": ["BFS", "最小步数", "AStar 算法", "启发式搜索"], "question": "在一个 `2 x 3` 的板上(`board`)有 $5$ 块砖瓦,用数字 `1~5` 来表示, 以及一块空缺用 $0$ 来表示.\n\n一次移动定义为选择 $0$ 与一个相邻的数字(上下左右)进行交换.\n\n最终当板 `board` 的结果是 $[[1,2,3],[4,5,0]]$ 谜板被解开。\n\n给出一个谜板的初始状态,返回最少可以通过多少次移动解开谜板,如果不能解开谜板,则返回 $-1$ 。\n\n示例 1:\n```\n输入:board = [[1,2,3],[4,0,5]]\n\n输出:1\n\n解释:交换 0 和 5 ,1 步完成\n```\n示例 2:\n```\n输入:board = [[1,2,3],[5,4,0]]\n\n输出:-1\n\n解释:没有办法完成谜板\n```\n示例 3:\n```\n输入:board = [[4,1,2],[5,0,3]]\n\n输出:5\n\n解释:\n最少完成谜板的最少移动次数是 5 ,\n一种移动路径:\n尚未移动: [[4,1,2],[5,0,3]]\n移动 1 次: [[4,1,2],[0,5,3]]\n移动 2 次: [[0,1,2],[4,5,3]]\n移动 3 次: [[1,0,2],[4,5,3]]\n移动 4 次: [[1,2,0],[4,5,3]]\n移动 5 次: [[1,2,3],[4,5,0]]\n```\n示例 4:\n```\n输入:board = [[3,2,4],[1,5,0]]\n\n输出:14\n```\n提示:\n* `board` 是一个如上所述的 `2 x 3` 的数组.\n* `board[i][j]` 是一个 $[0, 1, 2, 3, 4, 5]$ 的排列.", "solution": "### 基本分析\n\n这是八数码问题的简化版:将 $3 * 3$ 变为 $2 * 3$,同时将「输出路径」变为「求最小步数」。\n\n通常此类问题可以使用「BFS」、「AStar 算法」、「康拓展开」进行求解。\n\n由于问题简化到了 $2 * 3$,我们使用前两种解法即可。\n\n---\n\n### BFS\n\n为了方便,将原来的二维矩阵转成字符串(一维矩阵)进行处理。\n\n这样带来的好处直接可以作为哈希 `Key` 使用,也可以很方便进行「二维坐标」与「一维下标」的转换。\n\n由于固定是 $2 * 3$ 的格子,因此任意的合法二维坐标 $(x, y)$ 和对应一维下标 $idx$ 可通过以下转换:\n\n* $idx = x * 3 + y$\n* $x = idx / 3,y = idx \\% 3$\n\n其余的就是常规的 `BFS` 过程了。\n\n代码:\n```Java\nclass Solution {\n    class Node {\n        String str;\n        int x, y;\n        Node(String _str, int _x, int _y) {\n            str = _str; x = _x; y = _y;\n        }\n    }\n    int n = 2, m = 3;\n    String s, e;\n    int x, y;\n    public int slidingPuzzle(int[][] board) {\n        s = \"\";\n        e = \"123450\";\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                s += board[i][j];\n                if (board[i][j] == 0) {\n                    x = i; y = j;\n                }\n            }\n        }\n        int ans = bfs();\n        return ans;\n    }\n    int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n    int bfs() {\n        Deque<Node> d = new ArrayDeque<>();\n        Map<String, Integer> map = new HashMap<>();\n        Node root = new Node(s, x, y);\n        d.addLast(root);\n        map.put(s, 0);\n        while (!d.isEmpty()) {\n            Node poll = d.pollFirst();\n            int step = map.get(poll.str);\n            if (poll.str.equals(e)) return step;\n            int dx = poll.x, dy = poll.y;\n            for (int[] di : dirs) {\n                int nx = dx + di[0], ny = dy + di[1];\n                if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;\n                String nStr = update(poll.str, dx, dy, nx, ny);      \n                if (map.containsKey(nStr)) continue;          \n                Node next = new Node(nStr, nx, ny);\n                d.addLast(next);\n                map.put(nStr, step + 1);\n            }\n        }\n        return -1;\n    }\n    String update(String cur, int i, int j, int p, int q) {\n        char[] cs = cur.toCharArray();\n        char tmp = cs[i * m + j];\n        cs[i * m + j] = cs[p * m + q];\n        cs[p * m + q] = tmp;\n        return String.valueOf(cs);\n    }\n}\n```\n\n---\n\n### AStar 算法\n\n可以直接根据本题规则来设计 AStar 算法的「启发式函数」。\n\n比如对于两个状态 `a` 和 `b` 可直接计算出「理论最小转换次数」:**所有位置的数值「所在位置」与「目标位置」的曼哈顿距离之和(即横纵坐标绝对值之和)** 。\n\n注意,我们只需要计算「非空格」位置的曼哈顿距离即可,因为空格的位置会由其余数字占掉哪些位置而唯一确定。\n\n**AStar 求最短路的正确性问题:由于我们衡量某个状态 `str` 的估值是以目标字符串 `e=123450` 为基准,因此我们只能确保 `e` 出队时为「距离最短」,而不能确保中间节点出队时「距离最短」,因此我们不能单纯根据某个节点是否「曾经入队」而决定是否入队,还要结合当前节点的「最小距离」是否被更新而决定是否入队。**\n\n这一点十分关键,在代码层面上体现在 `map.get(nStr) > step + 1` 的判断上。\n\n**我们知道,AStar 算法在有解的情况下,才会发挥「启发式搜索」的最大价值,因此如果我们能够提前判断无解的情况,对 AStar 算法来说会是巨大的提升。**\n\n而对于通用的 $N * N$ 数码问题,判定有解的一个充要条件是:**「逆序对」数量为偶数,如果不满足,必然无解,直接返回 $-1$ 即可。**\n\n对该结论的充分性证明和必要性证明完全不在一个难度上,所以建议记住这个结论即可。\n\n代码:\n```Java\nclass Solution {\n    class Node {\n        String str;\n        int x, y;\n        int val;\n        Node(String _str, int _x, int _y, int _val) {\n            str = _str; x = _x; y = _y; val = _val;\n        }\n    }\n    int f(String str) {\n        int ans = 0;\n        char[] cs1 = str.toCharArray(), cs2 = e.toCharArray();\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                // 跳过「空格」,计算其余数值的曼哈顿距离\n                if (cs1[i * m + j] == '0' || cs2[i * m + j] == '0') continue;\n                int cur = cs1[i * m + j], next = cs2[i * m + j];\n                int xd = Math.abs((cur - 1) / 3 - (next - 1) / 3);\n                int yd = Math.abs((cur - 1) % 3 - (next - 1) % 3); \n                ans += (xd + yd);\n            }\n        }\n        return ans;\n    }\n    int n = 2, m = 3;\n    String s, e;\n    int x, y;\n    public int slidingPuzzle(int[][] board) {\n        s = \"\";\n        e = \"123450\";\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                s += board[i][j];\n                if (board[i][j] == 0) {\n                    x = i; y = j;\n                }\n            }\n        }\n\n        // 提前判断无解情况\n        if (!check(s)) return -1;\n\n        int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n        Node root = new Node(s, x, y, f(s));\n        PriorityQueue<Node> q = new PriorityQueue<>((a,b)->a.val-b.val);\n        Map<String, Integer> map = new HashMap<>();\n        q.add(root);\n        map.put(s, 0);\n        while (!q.isEmpty()) {\n            Node poll = q.poll();\n            int step = map.get(poll.str);\n            if (poll.str.equals(e)) return step;\n            int dx = poll.x, dy = poll.y;\n            for (int[] di : dirs) {\n                int nx = dx + di[0], ny = dy + di[1];\n                if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;\n                String nStr = update(poll.str, dx, dy, nx, ny);      \n                if (!map.containsKey(nStr) || map.get(nStr) > step + 1) {\n                    Node next = new Node(nStr, nx, ny, step + 1 + f(nStr));\n                    q.add(next);\n                    map.put(nStr, step + 1);\n                }\n            }\n        }\n        return 0x3f3f3f3f; // never\n    }\n    String update(String cur, int i, int j, int p, int q) {\n        char[] cs = cur.toCharArray();\n        char tmp = cs[i * m + j];\n        cs[i * m + j] = cs[p * m + q];\n        cs[p * m + q] = tmp;\n        return String.valueOf(cs);\n    }\n    boolean check(String str) {\n        char[] cs = str.toCharArray();\n        List<Integer> list = new ArrayList<>();\n        for (int i = 0; i < n * m; i++) {\n            if (cs[i] != '0') list.add(cs[i] - '0');\n        }\n        int cnt = 0;\n        for (int i = 0; i < list.size(); i++) {\n            for (int j = i + 1; j < list.size(); j++) {\n                if (list.get(i) > list.get(j)) cnt++;\n            }\n        }\n        return cnt % 2 == 0;\n    }\n}\n```", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.773` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/771-780/775. 全局倒置与局部倒置（中等）.md", "url_title": "775. 全局倒置与局部倒置", "url": "https://leetcode.cn/problems/global-and-local-inversions/solution/by-ac_oier-jc7a/", "difficulty": "中等", "tags": ["树状数组", "数学"], "question": "给你一个长度为 `n` 的整数数组 `nums`,表示由范围 $[0, n - 1]$ 内所有整数组成的一个排列。\n\n全局倒置 的数目等于满足下述条件不同下标对 $(i, j)$ 的数目:\n\n* $0 <= i < j < n$\n* $nums[i] > nums[j]$\n\n局部倒置 的数目等于满足下述条件的下标 i 的数目:\n\n* $0 <= i < n - 1$\n* $nums[i] > nums[i + 1]$\n\n当数组 `nums` 中 全局倒置 的数量等于 局部倒置 的数量时,返回 `true` ;否则,返回 `false` 。\n\n示例 1:\n```\n输入:nums = [1,0,2]\n\n输出:true\n\n解释:有 1 个全局倒置,和 1 个局部倒置。\n```\n示例 2:\n```\n输入:nums = [1,2,0]\n\n输出:false\n\n解释:有 2 个全局倒置,和 1 个局部倒置。\n```\n\n提示:\n* $n = nums.length$\n* $1 <= n <= 10^5$\n* $0 <= nums[i] < n$\n* `nums` 中的所有整数 互不相同\n* `nums` 是范围 $[0, n - 1]$ 内所有数字组成的一个排列", "solution": "### 树状数组\n\n根据题意,对于每个 $nums[i]$ 而言:\n\n* 其左边比它大的 $nums[j]$ 的个数,是以 $nums[i]$ 为右端点的“全局倒置”数量,统计所有以 $nums[i]$ 为右端点的“全局倒置”数量即是总的“全局倒置”数量 `a`\n\n* 同时我们可以将每个 $nums[i]$ 与前一个值进行比较,从而统计总的“局部倒置”数量 `b`,其中 $i$ 的取值范围为 $[1, n - 1)$\n\n一个容易想到的做法是利用「树状数组」,虽然该做法没有利用到核心条件「$nums$ 是一个 $[0, n - 1]$ 的排列」,但根据数据范围 $n$ 可知该复杂度为 $O(n\\log{n})$ 的做法可过,且依赖的条件更少,适用范围更广。\n\nJava 代码:\n```Java\nclass Solution {\n    int n;\n    int[] tr;\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void add(int x) {\n        for (int i = x; i <= n; i += lowbit(i)) tr[i]++;\n    }\n    int query(int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];\n        return ans;\n    }\n    public boolean isIdealPermutation(int[] nums) {\n        n = nums.length;\n        tr = new int[n + 10];\n        add(nums[0] + 1);\n        int a = 0, b = 0;\n        for (int i = 1; i < n; i++) {\n            a += query(n) - query(nums[i] + 1);\n            b += nums[i] < nums[i - 1] ? 1 : 0;\n            add(nums[i] + 1);\n        }\n        return a == b;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int n;\n    vector<int> tr;\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void add(int x) {\n        for (int i = x; i <= n; i += lowbit(i)) tr[i]++;\n    }\n    int query(int x) {\n        int ans = 0;\n        for (int i = x; i > 0; i -= lowbit(i)) ans += tr[i];\n        return ans;\n    }\n    bool isIdealPermutation(vector<int>& nums) {\n        n = nums.size();\n        tr.resize(n + 10);\n        add(nums[0] + 1);\n        long a = 0, b = 0;\n        for (int i = 1; i < n; i++) {\n            a += query(n) - query(nums[i] + 1);\n            b += nums[i] < nums[i - 1] ? 1 : 0;\n            add(nums[i] + 1);\n        }\n        return a == b;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def lowbit(self, x):\n        return x & -x\n\n    def add(self, tr, x, n):\n        i = x\n        while i <= n:\n            tr[i] += 1\n            i += self.lowbit(i)\n\n    def query(self, tr, x):\n        i, ans = x, 0\n        while i > 0:\n            ans += tr[i]\n            i -= self.lowbit(i)\n        return ans\n\n    def isIdealPermutation(self, nums: List[int]) -> bool:\n        n = len(nums)\n        tr = [0] * (n + 10)\n        self.add(tr, nums[0] + 1, n)\n        a, b = 0, 0\n        for i in range(1, n):\n            a += self.query(tr, n) - self.query(tr, nums[i] + 1)\n            b += nums[i] < nums[i - 1]\n            self.add(tr, nums[i] + 1, n)\n        return a == b\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 数学\n\n解法一中并没有利用到核心条件「$nums$ 是一个 $[0, n - 1]$ 的排列」,我们可以从该条件以及两类倒置的定义出发进行分析。\n\n#### 提示一:由“局部倒置”组成的集合为由“全局倒置”组成的集合的子集\n\n任意一个“局部倒置”均满足“全局倒置”的定义,因此要判定两者数量是否相同,可转换为统计是否存在「不满足“局部倒置”定义的“全局倒置”」。\n\n#### 提示二:何为不满足“局部倒置”定义的“全局倒置”\n\n结合题意,若存在坐标 $j$ 和 $i$,满足 $nums[j] > nums[i]$ 且 $j + 1 < i$,那么该倒置满足“全局倒置”定义,且不满足“局部倒置”定义。\n\n若存在这样的逆序对,不满足,则有两类倒置数量不同。\n\n#### 提示三:考虑「如何构造」或「如何避免构造」不满足“全局倒置”定义的“局部倒置”\n\n如果我们能够总结出「如何构造」或「如何避免构造」一个不满足“全局倒置”定义的“局部倒置” 所需的条件,问题可以转换为检查 `nums` 是否满足这样的条件,来得知 `nums` 是否存在不满足“全局倒置”定义的“局部倒置”。\n\n我们可以结合「$nums$ 是一个 $[0, n - 1]$ 的排列」来分析,若需要避免所有 $nums[j] > nums[i]$ 的逆序对均不满足 $j + 1 < i$,只能是所有逆序对均由相邻数值产生。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean isIdealPermutation(int[] nums) {\n        for (int i = 0; i < nums.length; i++) {\n            if (Math.abs(nums[i] - i) >= 2) return false;\n        }\n        return true;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool isIdealPermutation(vector<int>& nums) {\n        for (int i = 0; i < nums.size(); ++i) {\n            if (abs(nums[i] - i) >= 2) return false;\n        }\n        return true;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def isIdealPermutation(self, nums: List[int]) -> bool:\n        for i in range(len(nums)):\n            if abs(nums[i] - i) >= 2:\n                return False\n        return True\n```\nTypeScript 代码:\n```TypeScript\nfunction isIdealPermutation(nums: number[]): boolean {\n    for (let i = 0; i < nums.length; i++) {\n        if (Math.abs(nums[i] - i) >= 2) return false;\n    }\n    return true;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.775` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/771-780/777. 在LR字符串中交换相邻字符（中等）.md", "url_title": "777. 在LR字符串中交换相邻字符", "url": "https://leetcode.cn/problems/swap-adjacent-in-lr-string/solutions/1863778/by-ac_oier-ye71/", "difficulty": "中等", "tags": ["双指针"], "question": "在一个由 `'L'` ,`'R'` 和 `'X'` 三个字符组成的字符串(例如 `\"RXXLRXRXL\"`)中进行移动操作。\n\n一次移动操作指用一个 `\"LX\"` 替换一个 `\"XL\"`,或者用一个 `\"XR\"` 替换一个 `\"RX\"`。\n\n现给定起始字符串 `start` 和结束字符串 `end`,请编写代码,当且仅当存在一系列移动操作使得 `start` 可以转换成 `end` 时, 返回 `True`。\n\n示例 :\n```\n输入: start = \"RXXLRXRXL\", end = \"XRLXXRRLX\"\n\n输出: True\n\n解释:\n我们可以通过以下几步将start转换成end:\nRXXLRXRXL ->\nXRXLRXRXL ->\nXRLXRXRXL ->\nXRLXXRRXL ->\nXRLXXRRLX\n```\n\n提示:\n* $1 <= len(start) = len(end) <= 10000$\n* `start` 和 `end` 中的字符串仅限于 `'L'`, `'R'` 和 `'X'`", "solution": "### 双指针\n\n根据题意,我们每次移动要么是将 `XL` 变为 `LX`,要么是将 `RX` 变为 `XR`,而该两者操作可分别看做将 `L` 越过多个 `X` 向左移动,将 `R` 越过多个 `X` 向右移动。\n\n因此在 `start` 和 `end` 中序号相同的 `L` 和 `R` 必然满足坐标性质:\n\n1. 序号相同的 `L` : `start` 的下标不小于 `end` 的下标(即 `L` 不能往右移动)\n2. 序号相同的 `R` : `start` 的下标不大于 `end` 的下标(即 `R` 不能往左移动)\n\n其中「序号」是指在 `LR` 字符串中出现的相对顺序。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean canTransform(String start, String end) {\n        int n = start.length(), i = 0, j = 0;\n        while (i < n || j < n) {\n            while (i < n && start.charAt(i) == 'X') i++;\n            while (j < n && end.charAt(j) == 'X') j++;\n            if (i == n || j == n) return i == j;\n            if (start.charAt(i) != end.charAt(j)) return false;\n            if (start.charAt(i) == 'L' && i < j) return false;\n            if (start.charAt(i) == 'R' && i > j) return false;\n            i++; j++;\n        }\n        return i == j;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool canTransform(string start, string end) {\n        int n = start.size();\n        int i = 0, j = 0;\n        while (i < n || j < n) {\n            while (i < n && start[i] == 'X') i++;\n            while (j < n && end[j] == 'X') j++;\n            if (i == n || j == n) return i == j;\n            if (start[i] != end[j]) return false;\n            if (start[i] == 'L' && i < j) return false;\n            if (start[i] == 'R' && i > j) return false;\n            i++; j++;\n        }\n        return i == j;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def canTransform(self, start: str, end: str) -> bool:\n        i, j, n = 0, 0, len(start)\n        while i < n or j < n:\n            while i < n and start[i] == 'X': i += 1\n            while j < n and end[j] == 'X': j += 1\n            if i == n or j == n: return i == j\n            if start[i] != end[j]: return False\n            if start[i] == 'L' and i < j: return False\n            if start[i] == 'R' and i > j: return False\n            i, j = i + 1, j + 1\n        return i == j\n```\nTypeScript 代码:\n```TypeScript\nfunction canTransform(start: string, end: string): boolean {\n    let n = start.length;\n    let i = 0, j = 0;\n    while (i < n || j < n) {\n        while (i < n && start.charAt(i) === 'X') i++;\n        while (j < n && end.charAt(j) === 'X') j++;\n        if (i === n || j === n) return i === j;\n        if (start.charAt(i) !== end.charAt(j)) return false;\n        if (start.charAt(i) === 'L' && i < j) return false;\n        if (start.charAt(i) === 'R' && i > j) return false;\n        i++; j++;\n    }\n    return i === j;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.777` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/771-780/778. 水位上升的泳池中游泳（困难）.md", "url_title": "778. 水位上升的泳池中游泳", "url": "https://leetcode-cn.com/problems/swim-in-rising-water/solution/gong-shui-san-xie-yi-ti-shuang-jie-krusk-7c6o/", "difficulty": "困难", "tags": ["最小生成树", "并查集", "Kruskal", "二分", "BFS"], "question": "在一个 `N x N` 的坐标方格 `grid` 中,每一个方格的值 $grid[i][j]$ 表示在位置 $(i,j)$ 的平台高度。\n\n现在开始下雨了。当时间为 $t$ 时,此时雨水导致水池中任意位置的水位为 $t$ 。\n\n你可以从一个平台游向四周相邻的任意一个平台,但是前提是此时水位必须同时淹没这两个平台。\n\n假定你可以瞬间移动无限距离,也就是默认在方格内部游动是不耗时的。\n\n当然,在你游泳的时候你必须待在坐标方格里面。\n\n你从坐标方格的左上平台 $(0, 0)$ 出发,最少耗时多久你才能到达坐标方格的右下平台 $(N-1,N-1)$?\n\n示例 1:\n```\n输入: [[0,2],[1,3]]\n\n输出: 3\n\n解释:\n时间为0时,你位于坐标方格的位置为 (0, 0)。\n此时你不能游向任意方向,因为四个相邻方向平台的高度都大于当前时间为 0 时的水位。\n等时间到达 3 时,你才可以游向平台 (1, 1). 因为此时的水位是 3,坐标方格中的平台没有比水位 3 更高的,所以你可以游向坐标方格中的任意位置\n```\n示例2:\n```\n输入: [[0,1,2,3,4],[24,23,22,21,5],[12,13,14,15,16],[11,17,18,19,20],[10,9,8,7,6]]\n输出: 16\n\n解释:\n 0  1  2  3  4\n             5\n12 13 14 15 16\n11  \n10  9  8  7  6\n```\n\n提示:\n* 2 <= N <= 50.\n* grid[i][j] 是 `[0, ..., N*N - 1]` 的排列。", "solution": "### Kruskal\n\n由于在任意点可以往任意方向移动,所以相邻的点(四个方向)之间存在一条无向边。\n\n边的权重 $w$ 是指两点节点中的最大高度。\n\n按照题意,我们需要找的是从左上角点到右下角点的最优路径,其中最优路径是指**途径的边的最大权重值最小**,然后输入最优路径中的最大权重值。\n\n我们可以先遍历所有的点,将所有的边加入集合,存储的格式为数组 $[a, b, w]$ ,代表编号为 $a$ 的点和编号为 $b$ 的点之间的权重为 $w$(按照题意,$w$ 为两者的最大高度)。\n\n对集合进行排序,按照 $w$ 进行从小到达排序。\n\n当我们有了所有排好序的候选边集合之后,我们可以对边从前往后处理,每次加入一条边之后,使用并查集来查询左上角的点和右下角的点是否连通。\n\n当我们的合并了某条边之后,判定左上角和右下角的点联通,那么该边的权重即是答案。\n\n这道题和前天的 [1631. 最小体力消耗路径](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486139&idx=1&sn=37083315de3c6a7e1b675e0363ee7d98&chksm=fd9ca1a4caeb28b220eba888ebc773b460d41123a1042e3b01cfd2001ddfb487ff2a3959f3b9&token=990510480&lang=zh_CN#rd) 几乎是完全一样的思路。\n\n你甚至可以将那题的代码拷贝过来,改一下对于 $w$ 的定义即可。\n\n代码:\n```Java\nclass Solution {\n    int n;\n    int[] p;\n    void union(int a, int b) {\n        p[find(a)] = p[find(b)];\n    }\n    boolean query(int a, int b) {\n        return find(a) == find(b);\n    }\n    int find(int x) {\n        if (p[x] != x) p[x] = find(p[x]);\n        return p[x];\n    }\n    \n    public int swimInWater(int[][] grid) {\n        n = grid.length;\n        \n        // 初始化并查集\n        p = new int[n * n];\n        for (int i = 0; i < n * n; i++) p[i] = i;\n\n        // 预处理出所有的边\n        // edge 存的是 [a, b, w]:代表从 a 到 b 所需要的时间为 w\n        // 虽然我们可以往四个方向移动,但是只要对于每个点都添加「向右」和「向下」两条边的话,其实就已经覆盖了所有边了\n        List<int[]> edges =  new ArrayList<>();\n        for (int i = 0; i < n ;i++) {\n            for (int j = 0; j < n; j++) {\n                int idx = getIndex(i, j);\n                p[idx] = idx;\n                if (i + 1 < n) {\n                    int a = idx, b = getIndex(i + 1, j);\n                    int w = Math.max(grid[i][j], grid[i + 1][j]);\n                    edges.add(new int[]{a, b, w});\n                }\n                if (j + 1 < n) {\n                    int a = idx, b = getIndex(i, j + 1);\n                    int w = Math.max(grid[i][j], grid[i][j + 1]);\n                    edges.add(new int[]{a, b, w});\n                }\n            }\n        }\n\n        // 根据权值 w 升序\n        Collections.sort(edges, (a,b)->a[2]-b[2]);\n\n        // 从「小边」开始添加,当某一条边别应用之后,恰好使用得「起点」和「结点」联通\n        // 那么代表找到了「最短路径」中的「权重最大的边」\n        int start = getIndex(0, 0), end = getIndex(n - 1, n - 1);\n        for (int[] edge : edges) {\n            int a = edge[0], b = edge[1], w = edge[2];\n            union(a, b);\n            if (query(start, end)) {\n                return w;\n            }\n        }   \n        return 0;\n    }\n    int getIndex(int i, int j) {\n        return i * n + j;\n    }\n}\n```\n节点的数量为 $n * n$,无向边的数量严格为 $2 * n * (n - 1)$,数量级上为 $n^2$。\n\n* 时间复杂度:获取所有的边复杂度为 $O(n^2)$,排序复杂度为 $O(n^2\\log{n})$,遍历得到最终解复杂度为 $O(n^2)$。整体复杂度为 $O(n^2\\log{n})$。\n* 空间复杂度:使用了并查集数组。复杂度为 $O(n^2)$。\n\n注意:假定 Collections.sort() 使用 Arrays.sort() 中的双轴快排实现。\n\n---\n\n### 二分 + BFS/DFS\n\n在与本题类型的 [1631. 最小体力消耗路径](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486139&idx=1&sn=37083315de3c6a7e1b675e0363ee7d98&chksm=fd9ca1a4caeb28b220eba888ebc773b460d41123a1042e3b01cfd2001ddfb487ff2a3959f3b9&token=990510480&lang=zh_CN#rd)中,有同学问到是否可以用「二分」。\n\n答案是可以的。\n\n题目给定了 $grid[i][j]$ 的范围是 $[0, n^2 - 1]$,所以答案必然落在此范围。\n\n假设最优解为 $min$ 的话(恰好能到达右下角的时间)。那么小于 $min$ 的时间无法到达右下角,大于 $min$ 的时间能到达右下角。\n\n*因此在以最优解 $min$ 为分割点的数轴上具有两段性,可以通过「二分」来找到分割点 $min$。*\n\n> 注意:「二分」的本质是两段性,并非单调性。只要一段满足某个性质,另外一段不满足某个性质,就可以用「二分」。其中 [33. 搜索旋转排序数组](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247486020&idx=2&sn=9ada4b6e7eccecddbd8faa18f14c4eeb&chksm=fd9ca15bcaeb284d727905c174624e32b39b196e2337a2bfc791b22fcce35eb543b552031530&token=990510480&lang=zh_CN#rd) 是一个很好的说明例子。\n\n接着分析,假设最优解为 $min$,我们在 $[l, r]$ 范围内进行二分,当前二分到的时间为 $mid$ 时:\n\n1. 能到达右下角:必然有 $min \\leqslant mid$,让 $r = mid$\n\n2. 不能到达右下角:必然有 $min > mid$,让 $l = mid + 1$\n\n**当确定了「二分」逻辑之后,我们需要考虑如何写 $check$ 函数。**\n\n显然 $check$ 应该是一个判断给定 时间/步数 能否从「起点」到「终点」的函数。\n\n我们只需要按照规则走特定步数,边走边检查是否到达终点即可。\n\n实现 $check$ 既可以使用 DFS 也可以使用 BFS。两者思路类似,这里就只以 BFS 为例。\n\n代码:\n\n```Java\nclass Solution {\n    int[][] dirs = new int[][]{{1,0}, {-1,0}, {0,1}, {0,-1}};\n    public int swimInWater(int[][] grid) {\n        int n = grid.length;\n        int l = 0, r = n * n;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (check(grid, mid)) {\n                r = mid;\n            } else {\n                l = mid + 1;\n            }\n        }\n        return r;\n    }\n    boolean check(int[][] grid, int time) {\n        int n = grid.length;\n        boolean[][] visited = new boolean[n][n];\n        Deque<int[]> queue = new ArrayDeque<>();\n        queue.addLast(new int[]{0, 0});\n        visited[0][0] = true;\n        while (!queue.isEmpty()) {\n            int[] pos = queue.pollFirst();\n            int x = pos[0], y = pos[1];\n            if (x == n - 1 && y == n - 1) return true;\n\n            for (int[] dir : dirs) {\n                int newX = x + dir[0], newY = y + dir[1];\n                int[] to = new int[]{newX, newY};\n                if (inArea(n, newX, newY) && !visited[newX][newY] && canMove(grid, pos, to, time)) {\n                    visited[newX][newY] = true;\n                    queue.addLast(to);\n                }\n            }\n        }\n        return false;\n    }\n    boolean inArea(int n, int x, int y) {\n        return x >= 0 && x < n && y >= 0 && y < n;\n    }\n    boolean canMove(int[][] grid, int[] from, int[] to, int time) {\n        return time >= Math.max(grid[from[0]][from[1]], grid[to[0]][to[1]]);\n    }\n}\n```\n* 时间复杂度:在 $[0, n^2]$ 范围内进行二分,复杂度为 $O(\\log{n})$;每一次 BFS 最多有 $n^2$ 个节点入队,复杂度为 $O(n^2)$。整体复杂度为 $O({n^2}\\log{n})$\n* 空间复杂度:使用了 visited 数组。复杂度为 $O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.778` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/771-780/779. 第K个语法符号（中等）.md", "url_title": "779. 第K个语法符号", "url": "https://leetcode.cn/problems/k-th-symbol-in-grammar/solution/by-ac_oier-fp2f/", "difficulty": "中等", "tags": ["DFS", "递归"], "question": "我们构建了一个包含 `n` 行( 索引从 `1`  开始 )的表。首先在第一行我们写上一个 `0`。接下来的每一行,将前一行中的 `0` 替换为 `01`,`1` 替换为 `10`。\n\n* 例如,对于 `n = 3`,第 `1` 行是 `0` ,第 `2` 行是 `01`,第 `3` 行是 `0110` 。\n\n给定行数 `n` 和序数 `k`,返回第 `n` 行中第 `k` 个字符。( `k` 从索引 `1` 开始)\n\n示例 1:\n```\n输入: n = 1, k = 1\n\n输出: 0\n\n解释: 第一行:0\n```\n示例 2:\n```\n输入: n = 2, k = 1\n\n输出: 0\n\n解释: \n第一行: 0 \n第二行: 01\n```\n示例 3:\n```\n输入: n = 2, k = 2\n\n输出: 1\n\n解释:\n第一行: 0\n第二行: 01\n```\n\n提示:\n* $1 <= n <= 30$\n* $1 <= k <= 2^{n - 1}$", "solution": "### 递归(倒推验证)\n\n整理一下条件:首行为 `0`,每次用当前行拓展出下一行时,字符数量翻倍(将 `0` 拓展为 `01`,将 `1` 拓展为 `10`),且字符种类仍为 `01`。\n\n要求我们输出第 $n$ 行第 $k$ 列的字符,我们可以通过「倒推验证」的方式来求解:假设第 $n$ 行第 $k$ 为 `1`,若能倒推出首行为 $0$,说明假设成立,返回 `1`,否则返回 `0`。\n\n倒推验证可通过实现递归函数 `int dfs(int r, int c, int cur)` 来做,含义为当第 $r$ 行第 $c$ 列的字符为 $cur$ 时,首行首列字符为何值。同时实现该函数是容易的:\n\n* 若「当前列 $c$ 为偶数且 $cur = 0$」或「当前列 $c$ 为奇数且 $cur = 1$」时,说明当前列所在的组为 `10`,由此可推出其是由上一行的 `1` 拓展而来,结合每次拓展新行字符数量翻倍的条件,可知是由第 $r - 1$ 行的第 $\\left \\lfloor \\frac{c - 1}{2} \\right \\rfloor + 1$ 列的 `1` 拓展而来,递归处理;\n* 否则,同理,必然是上一行(第 $r - 1$ 行)对应位置的 `0` 拓展而来,递归处理。\n\n最终,当倒推到首行时,我们找到了递归出口,直接返回 `cur`。\n\nJava 代码:\n```Java\nclass Solution {\n    public int kthGrammar(int n, int k) {\n        return dfs(n, k, 1) == 0 ? 1 : 0;\n    }\n    int dfs(int r, int c, int cur) {\n        if (r == 1) return cur;\n        if ((c % 2 == 0 && cur == 0) || (c % 2 == 1 && cur == 1)) return dfs(r - 1, (c - 1) / 2 + 1, 1);\n        else return dfs(r - 1, (c - 1) / 2 + 1, 0);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction kthGrammar(n: number, k: number): number {\n    function dfs(r: number, c: number, cur: number): number {\n        if (r == 1) return cur\n        if ((c % 2 == 0 && cur == 0) || (c % 2 == 1 && cur == 1)) return dfs(r - 1, Math.floor((c - 1) / 2) + 1, 1)\n        else return dfs(r - 1, Math.floor((c - 1) / 2) + 1, 0)\n    }\n    return dfs(n, k, 1) == 0 ? 1 : 0\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def kthGrammar(self, n: int, k: int) -> int:\n        def dfs(r, c, cur):\n            if r == 1:\n                return cur\n            if (c % 2 == 0 and cur == 0) or (c % 2 == 1 and cur == 1):\n                return dfs(r - 1, (c - 1) // 2 + 1, 1)\n            else:\n                return dfs(r - 1, (c - 1) // 2 + 1, 0)\n        return 1 if dfs(n, k, 1) == 0 else 0\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.779` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/771-780/780. 到达终点（困难）.md", "url_title": "780. 到达终点", "url": "https://leetcode-cn.com/problems/reaching-points/solution/by-ac_oier-hw11/", "difficulty": "困难", "tags": ["数学"], "question": "给定四个整数 `sx`,`sy`,`tx` 和 `ty`,如果通过一系列的转换可以从起点 $(sx, sy)$ 到达终点 $(tx, ty)$,则返回 `true`,否则返回 `false`。\n\n从点 $(x, y)$ 可以转换到 $(x, x+y)$  或者 $(x+y, y)$。\n\n示例 1:\n```\n输入: sx = 1, sy = 1, tx = 3, ty = 5\n\n输出: true\n\n解释:\n可以通过以下一系列转换从起点转换到终点:\n(1, 1) -> (1, 2)\n(1, 2) -> (3, 2)\n(3, 2) -> (3, 5)\n```\n示例 2:\n```\n输入: sx = 1, sy = 1, tx = 2, ty = 2 \n\n输出: false\n```\n示例 3:\n```\n输入: sx = 1, sy = 1, tx = 1, ty = 1 \n\n输出: true\n```\n\n提示:\n* $1 <= sx, sy, tx, ty <= 10^9$", "solution": "### 数学\n\n给定的 $(sx, sy)$ 的数据范围为 $[1, 10^9]$(即均为正整数),且每次转换,只能将另外一维的数值累加到当前维,因此对于每一维的数值而言,随着转换次数的进行,呈(非严格)递增趋势,再结合起始值为正整数,可知在转换过程中均不会出现负数。\n\n**由此得知从 $(tx, ty)$ 到 $(sx, sy)$ 的转换过程唯一确定:总是取较大数减去较小数来进行反推(否则会出现负数)。**\n\n但即使反向转换唯一确定,数据范围为 $10^9$,线性模拟仍会超时。\n\n我们考虑将「相同操作的连续段转换动作」进行合并,在某次反向转换中,如果有 $tx < ty$,我们会将 $(tx, ty)$ 转换为 $(tx, ty - tx)$,若相减完仍有 $tx < ty - tx$,该操作会继续进行,得到 $(tx, ty - 2 * tx)$,直到不满足 $tx < ty - k * tx$,其中 $k$ 为转换次数。\n\n即对于一般性的情况而言,$(tx, ty)$ 中的较大数会一直消减到「与较小数的余数」为止。\n\n因此我们可以先使用 $O(\\log{max(tx, ty)})$ 的复杂度将其消减到不超过 $(sx, sy)$ 为止。此时如果消减后的结果 $(tx, ty)$ 任一维度小于 $(sx, sy)$,必然不能进行转换,返回 `False`;如果任一维度相等(假定是 $x$ 维度),则检查另一维度($y$ 维度)的差值,能够由当前维度($x$ 维度)拼凑而来。\n\n代码:\n```Java\nclass Solution {\n    public boolean reachingPoints(int sx, int sy, int tx, int ty) {\n        while (sx < tx && sy < ty) {\n            if (tx < ty) ty %= tx;\n            else tx %= ty;\n        }\n        if (tx < sx || ty < sy) return false;\n        return sx == tx ? (ty - sy) % tx == 0 : (tx - sx) % ty == 0;\n    }\n}\n```\n* 时间复杂度:$O(\\log{\\max(tx, ty)})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.780` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/781-790/781. 森林中的兔子（中等）.md", "url_title": "781. 森林中的兔子", "url": "https://leetcode-cn.com/problems/rabbits-in-forest/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-v17p5/", "difficulty": "中等", "tags": ["贪心"], "question": "森林中,每个兔子都有颜色。其中一些兔子(可能是全部)告诉你还有多少其他的兔子和自己有相同的颜色。我们将这些回答放在 `answers` 数组里。\n\n返回森林中兔子的最少数量。\n\n示例:\n```\n输入: answers = [1, 1, 2]\n\n输出: 5\n\n解释:\n两只回答了 \"1\" 的兔子可能有相同的颜色,设为红色。\n之后回答了 \"2\" 的兔子不会是红色,否则他们的回答会相互矛盾。\n设回答了 \"2\" 的兔子为蓝色。\n此外,森林中还应有另外 2 只蓝色兔子的回答没有包含在数组中。\n因此森林中兔子的最少数量是 5: 3 只回答的和 2 只没有回答的。\n\n输入: answers = [10, 10, 10]\n输出: 11\n\n输入: answers = []\n输出: 0\n```\n\n说明:\n* `answers` 的长度最大为 $1000$\n* `answers[i]` 是在 $[0, 999]$ 范围内的整数。", "solution": "### 基本分析\n\n首先,兔子它不会说谎 (`・ω・ ́),因此我们可以得出以下结论:\n\n* **同一颜色的兔子回答的数值必然是一样的**\n* **但回答同样数值的,不一定就是同颜色兔子**\n\n举个🌰,假如有 3 只白兔,每只白兔的回答必然都是 2(对应结论 1);但假如有兔子回答了数值 2,可能只是三只白兔,也可能是三只白兔和三只灰兔同时进行了回答(对应结论 2)。\n\n**答案要我们求最少的兔子数量。**\n\n不妨设有某种颜色的兔子 $m$ 只,它们回答的答案数值为 $cnt$,那么 $m$ 和 $cnt$ 满足什么关系?\n\n显然两者关系为 $m = cnt + 1$。\n\n但如果是在 $answers$ 数组里,回答 $cnt$ 的数量为 $t$ 的话呢?这时候我们需要分情况讨论:\n\n* $t \\leqslant cnt + 1$ : 为达到「最少的兔子数量」,我们可以假定这 $t$ 只兔子为同一颜色,这样能够满足题意,同时不会导致「额外」兔子数量增加(颜色数量最少)。\n* $t > cnt + 1$ : 我们知道回答 $cnt$ 的兔子应该有 $cnt + 1$ 只。这时候说明有数量相同的不同颜色的兔子进行了回答。为达到「最少的兔子数量」,我们应当将 $t$ 分为若干种颜色,并尽可能让某一种颜色的兔子为 $cnt + 1$ 只,这样能够满足题意,同时不会导致「额外」兔子数量增加(颜色数量最少)。\n\n**换句话说,我们应该让「同一颜色的兔子数量」尽量多,从而实现「总的兔子数量」最少。**\n\n***\n\n### 证明\n\n我们来证明一下,为什么这样的贪心思路是对的:\n\n基于上述分析,我们其实是在处理 $answers$ 数组中每一个 $cnt$ ,使得满足题意的前提下,数值 $cnt$ 带来的影响(总的兔子数量,或者说总的颜色数量)最小。\n\n首先 $answers$ 中的每个数都会导致我们总的兔子数量增加,**因此我们应该「让 $answers$ 的数字尽可能变少」,也就是我们需要去抵消掉 $answers$ 中的一些数字。**\n\n对于 $answers$ 中的某个 $cnt$ 而言(注意是某个 $cnt$,含义为一只兔子的回答),必然代表了有 $cnt + 1$ 只兔子,同时也代表了数值 $cnt$ 最多在 $answers$ 数组中出现 $cnt + 1$ 次(与其颜色相同的兔子都进行了回答)。\n\n这时候我们可以从数组中移走 $cnt + 1$ 个数值 $cnt$(如果有的话)。\n\n**当每次处理 $cnt$ 的时候,我们都执行这样的抵消操作。最后得到的 $answers$ 数值数量必然最少(而固定),抵消完成后的 $answers$ 中的每个 $cnt$ 对答案的影响也固定(增加 $cnt + 1$),从而实现「总的兔子数量」最少。**\n\n**相反,如果不执行这样的操作的话,得到的 $answers$ 数值数量必然会更多,「总的兔子数量」也必然会更多,也必然不会比这样做法更优。**\n\n***\n\n### 模拟解法\n\n按照上述思路,我们可以先对 $answers$ 进行排序,然后根据遍历到某个 $cnt$ 时,将其对答案的影响应用到 $ans$ 中(`ans += cnt + 1`),并将后面的 $cnt$ 个 $cnt$ 进行忽略。\n\n代码:\n```Java\nclass Solution {\n    public int numRabbits(int[] cs) {\n        Arrays.sort(cs);\n        int n = cs.length;\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            int cnt = cs[i];\n            ans += cnt + 1;\n            // 跳过「数值 cnt」后面的 cnt 个「数值 cnt」 \n            int k = cnt;\n            while (k-- > 0 && i + 1 < n && cs[i] == cs[i + 1]) i++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(1)$\n\n***\n\n### 统计分配\n\n我们也可以先对所有出现过的数字进行统计,然后再对数值进行(颜色)分配。\n\n代码:\n```Java\nclass Solution {\n    int N = 1009;\n    int[] counts = new int[N];\n    public int numRabbits(int[] cs) {\n        // counts[x] = cnt 代表在 cs 中数值 x 的数量为 cnt\n        for (int i : cs) counts[i]++;\n        int ans = counts[0];\n        for (int i = 1; i < N; i++) {\n            int per = i + 1;\n            int cnt = counts[i];\n            int k = cnt / per;\n            if (k * per < cnt) k++;\n            ans += k * per;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 拓展\n\n保持题目现有的条件不变,假定颜色相同的兔子至少有一只发声,问题改为「问兔子颜色数量可能有多少种」,又该如何求解呢?", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.781` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/781-790/782. 变为棋盘（困难）.md", "url_title": "782. 变为棋盘", "url": "https://leetcode.cn/problems/transform-to-chessboard/solution/by-ac_oier-vf1m/", "difficulty": "困难", "tags": ["构造"], "question": "一个 `n x n` 的二维网络 `board` 仅由 `0` 和 `1` 组成 。每次移动,你能任意交换两列或是两行的位置。\n\n返回 将这个矩阵变为  “棋盘”  所需的最小移动次数 。如果不存在可行的变换,输出 `-1`。\n\n“棋盘” 是指任意一格的上下左右四个方向的值均与本身不同的矩阵。\n\n示例 1:\n\n```\n输入: board = [[0,1,1,0],[0,1,1,0],[1,0,0,1],[1,0,0,1]]\n\n输出: 2\n\n解释:一种可行的变换方式如下,从左到右:\n第一次移动交换了第一列和第二列。\n第二次移动交换了第二行和第三行。\n```\n示例 2:\n\n```\n输入: board = [[0, 1], [1, 0]]\n\n输出: 0\n\n解释: 注意左上角的格值为0时也是合法的棋盘,也是合法的棋盘.\n```\n示例 3:\n\n```\n输入: board = [[1, 0], [1, 0]]\n\n输出: -1\n\n解释: 任意的变换都不能使这个输入变为合法的棋盘。\n```\n\n提示:\n* $n == board.length$\n* $n == board[i].length$\n* $2 <= n <= 30$\n* `board[i][j]` 将只包含 `0`或 `1`", "solution": "### 构造分析\n\n数据范围具有一定的迷惑性,但其并不是一个棋盘搜索问题。\n\n我们需要考虑何种情况下无解,以及有解情况的最小步数。\n\n在给定棋盘大小 $n$ 的前提下,所能构造的合法棋盘只有两种情况:首个格子为 $0$ 或首个格子为 $1$,即问题转化为能否构造出合法棋盘,以及构造哪种合法棋盘所用步数更小。\n\n同时,**交换行和交换列均不会影响行的种类数量和列的种类数量**,因此我们可以得到第一个判断无解的条件:若起始棋盘的行/列种类数不为 $2$,必然无法构造出合法棋盘。\n\n假设起始的行分别为 `r1` 和 `r2`,起始的列分别为 `c1` 和 `c2`。不难发现第二性质:**若能构成合法棋盘,`r1` 和 `r2` 中 $0$ 和 $1$ 的数量必然相等,`c1` 和 `c2` 中的 $0$ 和 $1$ 的数量必然相等**。\n\n同时由于交换行和交换列具有对称性和独立性,我们可以先使用「交换列」来进行分析,交换列不会导致行种类发生变化,但会导致行的数值分布发生变化。\n\n因此第二性质可拓展为:**`r1` 和 `r2` 对称位置为必然不同,`c1` 和 `c2` 对称位置必然不同,即两者异或结果为必然为 $(111...111)_2$,即为 `mask = (1 << n) - 1`,否则必然无解。**\n\n若上述两性质满足,可能有解。\n\n由于 `r1` 和 `r2` 及 `c1` 和 `c2` 对称位置必然不同,因此我们调整好 `r1` 后,`r2` 唯一确定(`c1` 和 `c2` 同理),同时构造其中一种间隔行为 `t` = $(...101)_2$,根据合法棋盘定义可知要么是将首行调整为 $t$,要么是将次行调整为 $t$。\n\n我们设置函数 `int getCnt(int a, int b)` 计算将 `a` 变为 `b` 所需要的最小转换次数,两状态转换所需次数为不同位个数除以 $2$(一次交换可实现消除两个不同位)。\n\n分别计算「将 `r1` 和 `r2` 转换为 `t` 所需步数」和「将 `c1` 和 `c2` 转换为 `t` 所需步数」,两者之和即为答案。\n\nJava 代码:\n```Java\nclass Solution {\n    int n = 0, INF = 0x3f3f3f3f;\n    int getCnt(int a, int b) {\n        return Integer.bitCount(a) != Integer.bitCount(b) ? INF : Integer.bitCount(a ^ b) / 2;\n    }\n    public int movesToChessboard(int[][] g) {\n        n = g.length;\n        int r1 = -1, r2 = -1, c1 = -1, c2 = -1, mask = (1 << n) - 1;\n        for (int i = 0; i < n; i++) {\n            int a = 0, b = 0;\n            for (int j = 0; j < n; j++) {\n                if (g[i][j] == 1) a += (1 << j);\n                if (g[j][i] == 1) b += (1 << j);\n            }\n            if (r1 == -1) r1 = a;\n            else if (r2 == -1 && a != r1) r2 = a;\n            if (c1 == -1) c1 = b;\n            else if (c2 == -1 && b != c1) c2 = b;\n            if (a != r1 && a != r2) return -1;\n            if (b != c1 && b != c2) return -1;\n        }\n        if (Integer.bitCount(r1) + Integer.bitCount(r2) != n) return -1;\n        if (Integer.bitCount(c1) + Integer.bitCount(c2) != n) return -1;\n        if ((r1 ^ r2) != mask || (c1 ^ c2) != mask) return -1;\n        int t = 0;\n        for (int i = 0; i < n; i += 2) t += (1 << i);\n        int ans = Math.min(getCnt(r1, t), getCnt(r2, t)) + Math.min(getCnt(c1, t), getCnt(c2, t));\n        return ans >= INF ? -1 : ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int n = 0, INF = 0x3f3f3f3f;\n    int getCnt(int a, int b) {\n        return __builtin_popcount(a) != __builtin_popcount(b) ? INF : (__builtin_popcount(a ^ b) / 2);\n    }\n    int movesToChessboard(vector<vector<int>>& g) {\n        n = g.size();\n        int r1 = -1, r2 = -1, c1 = -1, c2 = -1, mask = (1 << n) - 1;\n        for (int i = 0; i < n; i++) {\n            int a = 0, b = 0;\n            for (int j = 0; j < n; j++) {\n                if (g[i][j] == 1) a |= (1 << j);\n                if (g[j][i] == 1) b |= (1 << j);\n            }\n            if (r1 == -1) r1 = a;\n            else if (r2 == -1 && a != r1) r2 = a;\n            if (c1 == -1) c1 = b;\n            else if (c2 == -1 && b != c1) c2 = b;\n            if (a != r1 && a != r2) return -1;\n            if (b != c1 && b != c2) return -1;\n        }\n        if (__builtin_popcount(r1) + __builtin_popcount(r2) != n) return -1;\n        if (__builtin_popcount(c1) + __builtin_popcount(c2) != n) return -1;\n        if ((r1 ^ r2) != mask || (c1 ^ c2) != mask) return -1;\n        int t = 0;\n        for (int i = 0; i < n; i += 2) t |= (1 << i);\n        int ans = min(getCnt(r1, t), getCnt(r2, t)) + min(getCnt(c1, t), getCnt(c2, t));\n        return (ans >= INF) ? -1 : ans;\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nlet n: number = 0, INF = 0x3f3f3f3f\nfunction bitCount(x: number): number {\n    let ans = 0\n    while (x != 0 && ++ans >= 0) x -= (x & -x)\n    return ans\n}\nfunction getCnt(a: number, b: number): number {\n    return bitCount(a) != bitCount(b) ? INF : bitCount(a ^ b) / 2\n}\nfunction movesToChessboard(g: number[][]): number {\n    n = g.length\n    let r1 = -1, r2 = -1, c1 = -1, c2 = -1, mask = (1 << n) - 1\n    for (let i = 0; i < n; i++) {\n        let a = 0, b = 0\n        for (let j = 0; j < n; j++) {\n            if (g[i][j] == 1) a += (1 << j)\n            if (g[j][i] == 1) b += (1 << j)\n        }\n        if (r1 == -1) r1 = a\n        else if (r2 == -1 && a != r1) r2 = a\n        if (c1 == -1) c1 = b\n        else if (c2 == -1 && b != c1) c2 = b\n        if (a != r1 && a != r2) return -1\n        if (b != c1 && b != c2) return -1\n    }\n    if (bitCount(r1) + bitCount(r2) != n) return -1\n    if (bitCount(c1) + bitCount(c2) != n) return -1\n    if ((r1 ^ r2) != mask || (c1 ^ c2) != mask) return -1\n    let t = 0\n    for (let i = 0; i < n; i += 2) t += (1 << i)\n    const ans = Math.min(getCnt(r1, t), getCnt(r2, t)) + Math.min(getCnt(c1, t), getCnt(c2, t))\n    return ans >= INF ? -1 : ans\n};\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.782` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/781-790/783. 二叉搜索树节点最小距离（简单）.md", "url_title": "783. 二叉搜索树节点最小距离", "url": "https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/solution/gong-shui-san-xie-yi-ti-san-jie-shu-de-s-7r17/", "difficulty": "简单", "tags": ["树的搜索", "迭代", "非迭代", "中序遍历", "BFS", "DFS"], "question": "给你一个二叉搜索树的根节点 root ,返回 树中任意两不同节点值之间的最小差值 。\n\n注意:本题与 530:https://leetcode-cn.com/problems/minimum-absolute-difference-in-bst/ 相同\n\n示例 1:\n\n```\n输入:root = [4,2,6,1,3]\n\n输出:1\n```\n示例 2:\n\n```\n输入:root = [1,0,48,null,null,12,49]\n\n输出:1\n```\n\n提示:\n* 树中节点数目在范围 [2, 100] 内\n* 0 <= Node.val <= $10^5$\n* 差值是一个正数,其数值等于两值之差的绝对值", "solution": "### 朴素解法(BFS & DFS)\n\n如果不考虑利用二叉搜索树特性的话,一个朴素的做法是将所有节点的 $val$ 存到一个数组中。\n\n对数组进行排序,并获取答案。\n\n将所有节点的 $val$ 存入数组,可以使用 BFS 或者 DFS。\n\n代码:\n```java []\nclass Solution {\n    public int minDiffInBST(TreeNode root) {\n        List<Integer> list = new ArrayList<>();\n\n        // BFS\n        Deque<TreeNode> d = new ArrayDeque<>();\n        d.addLast(root);\n        while (!d.isEmpty()) {\n            TreeNode poll = d.pollFirst();\n            list.add(poll.val);\n            if (poll.left != null) d.addLast(poll.left);\n            if (poll.right != null) d.addLast(poll.right);\n        }\n\n        // DFS\n        // dfs(root, list);\n\n        Collections.sort(list);\n        int n = list.size();\n        int ans = Integer.MAX_VALUE;\n        for (int i = 1; i < n; i++) {\n            int cur = Math.abs(list.get(i) - list.get(i - 1));\n            ans = Math.min(ans, cur);\n        }\n        return ans;\n    }\n    void dfs(TreeNode root, List<Integer> list) {\n        list.add(root.val);\n        if (root.left != null) dfs(root.left, list);\n        if (root.right != null) dfs(root.right, list);\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n***\n\n### 中序遍历(栈模拟 & 递归)\n\n不难发现,在朴素解法中,我们对树进行搜索的目的是为了获取一个「有序序列」,然后从「有序序列」中获取答案。\n\n而二叉搜索树的中序遍历是有序的,因此我们可以直接对「二叉搜索树」进行中序遍历,保存遍历过程中的相邻元素最小值即是答案。\n\n代码:\n```java []\nclass Solution {\n    int ans = Integer.MAX_VALUE;\n    TreeNode prev = null;\n    public int minDiffInBST(TreeNode root) {\n        // 栈模拟\n        Deque<TreeNode> d = new ArrayDeque<>();\n        while (root != null || !d.isEmpty()) {\n            while (root != null) {\n                d.addLast(root);\n                root = root.left;\n            }\n            root = d.pollLast();\n            if (prev != null) {\n                ans = Math.min(ans, Math.abs(prev.val - root.val));\n            }\n            prev = root;\n            root = root.right;\n        }\n\n        // 递归\n        // dfs(root);\n\n        return ans;\n    }\n    void dfs(TreeNode root) {\n        if (root == null) return;\n        dfs(root.left);\n        if (prev != null) {\n            ans = Math.min(ans, Math.abs(prev.val - root.val));\n        } \n        prev = root;\n        dfs(root.right);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.783` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/781-790/784. 字母大小写全排列（中等）.md", "url_title": "784. 字母大小写全排列", "url": "https://leetcode.cn/problems/letter-case-permutation/solution/by-ac_oier-x7f0/", "difficulty": "中等", "tags": ["DFS", "爆搜", "二进制枚举"], "question": "给定一个字符串 `s` ,通过将字符串 `s` 中的每个字母转变大小写,我们可以获得一个新的字符串。\n\n返回 所有可能得到的字符串集合 。以 任意顺序 返回输出。\n\n示例 1:\n```\n输入:s = \"a1b2\"\n\n输出:[\"a1b2\", \"a1B2\", \"A1b2\", \"A1B2\"]\n```\n示例 2:\n```\n输入: s = \"3z4\"\n\n输出: [\"3z4\",\"3Z4\"]\n```\n\n提示:\n* $1 <= s.length <= 12$\n* `s` 由小写英文字母、大写英文字母和数字组成", "solution": "### DFS\n\n数据范围为 $12$,同时要我们求所有具体方案,容易想到使用 `DFS` 进行「爆搜」。\n\n我们可以从前往后考虑每个 $s[i]$,根据 $s[i]$ 是否为字母进行分情况讨论:\n\n* 若 $s[i]$ 不是字母,直接保留\n* 若 $s[i]$ 是字母,则有「保留原字母」或「进行大小写转换」两种决策\n\n设计 `DFS` 函数为 `void dfs(int idx, int n, String cur)`:其中 $n$ 固定为具体方案的长度(即原字符串长度),而 `idx` 和 `cur` 分别为当前处理到哪一个 $s[idx]$,而 `cur` 则是当前具体方案。\n\n根据上述分析可知,当 $s[idx]$ 不为字母,将其直接追加到 `cur` 上,并决策下一个位置 $idx + 1$;而当 $s[idx]$ 为字母时,我们可以选择将 $s[idx]$ 追加到 `cur` 上(保留原字母)或是将 $s[idx]$ 进行翻转后再追加到 `cur` 上(进行大小写转换)。\n\n最后当我们满足 `idx = n` 时,说明已经对原字符串的每一位置决策完成,将当前具体方案 `cur` 加入答案。\n\n> 一些细节:我们可以通过与 `32` 异或来进行大小写转换\n\nJava 代码:\n```Java\nclass Solution {\n    char[] cs;\n    List<String> ans = new ArrayList<>();\n    public List<String> letterCasePermutation(String s) {\n        cs = s.toCharArray();\n        dfs(0, s.length(), new char[s.length()]);\n        return ans;\n    }\n    void dfs(int idx, int n, char[] cur) {\n        if (idx == n) {\n            ans.add(String.valueOf(cur));\n            return ;\n        }\n        cur[idx] = cs[idx];\n        dfs(idx + 1, n, cur);\n        if (Character.isLetter(cs[idx])) {\n            cur[idx] = (char) (cs[idx] ^ 32);\n            dfs(idx + 1, n, cur);\n        }\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<string> ans;\n    string s;\n    void dfs(int idx, int n, string cur) {\n        if (idx == n) {\n            ans.push_back(cur);\n            return;\n        }\n        cur.push_back(s[idx]);\n        dfs(idx + 1, n, cur);\n        if (isalpha(s[idx])) {\n            cur[idx] = s[idx] ^ 32;\n            dfs(idx + 1, n, cur);\n        }\n    }\n    vector<string> letterCasePermutation(string s) {\n        this->s = s;\n        dfs(0, s.length(), \"\");\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def letterCasePermutation(self, s: str) -> List[str]:\n        ans = []\n        def dfs(idx, n, cur):\n            if idx == n:\n                ans.append(cur)\n                return \n            dfs(idx + 1, n, cur + s[idx])\n            if 'a' <= s[idx] <= 'z' or 'A' <= s[idx] <= 'Z':\n                dfs(idx + 1, n, cur + s[idx].swapcase())\n        dfs(0, len(s), '')\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction letterCasePermutation(s: string): string[] {\n    const ans = new Array<string>()\n    function dfs(idx: number, n: number, cur: string): void {\n        if (idx == n) {\n            ans.push(cur)\n            return \n        }\n        dfs(idx + 1, n, cur + s[idx])\n        if ((s[idx] >= 'a' && s[idx] <= 'z') || (s[idx] >= 'A' && s[idx] <= 'Z')) {\n            dfs(idx + 1, n, cur + String.fromCharCode(s.charCodeAt(idx) ^ 32))\n        }\n    }\n    dfs(0, s.length, \"\")\n    return ans\n}\n```\n* 时间复杂度:最坏情况下原串 `s` 的每一位均为字母(均有保留和转换两种决策),此时具体方案数量共 $2^n$ 种;同时每一种具体方案我们都需要用与原串长度相同的复杂度来进行构造。复杂度为 $O(n \\times 2^n)$\n* 空间复杂度:$O(n \\times 2^n)$\n\n---\n\n### 二进制枚举\n\n根据解法一可知,具体方案的个数与字符串 `s1` 存在的字母个数相关,当 `s1` 存在 `m` 个字母时,由于每个字母存在两种决策,总的方案数个数为 $2^m$ 个。\n\n因此可以使用「二进制枚举」的方式来做:使用变量 `s` 代表字符串 `s1` 的字母翻转状态,`s` 的取值范围为 `[0, 1 << m)`。若 `s` 的第 $j$ 位为 `0` 代表在 `s1` 中第 $j$ 个字母不进行翻转,而当为 `1` 时则代表翻转。\n\n每一个状态 `s` 对应了一个具体方案,通过枚举所有翻转状态 `s`,可构造出所有具体方案。\n\nJava 代码:\n```Java\nclass Solution {\n    public List<String> letterCasePermutation(String str) {\n        List<String> ans = new ArrayList<String>();\n        int n = str.length(), m = 0;\n        for (int i = 0; i < n; i++) m += Character.isLetter(str.charAt(i)) ? 1 : 0;\n        for (int s = 0; s < (1 << m); s++) {\n            char[] cs = str.toCharArray();\n            for (int i = 0, j = 0; i < n; i++) {\n                if (!Character.isLetter(cs[i])) continue;\n                cs[i] = ((s >> j) & 1) == 1 ? (char) (cs[i] ^ 32) : cs[i];\n                j++;\n            }\n            ans.add(String.valueOf(cs));\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<string> letterCasePermutation(string str) {\n        vector<string> ans;\n        int n = str.length(), m = 0;\n        for (int i = 0; i < n; i++) m += isalpha(str[i]) ? 1 : 0;\n        for (int s = 0; s < (1 << m); s++) {\n            string cs = str;\n            for (int i = 0, j = 0; i < n; i++) {\n                if (!isalpha(cs[i])) continue;\n                cs[i] = ((s >> j) & 1) ? (cs[i] ^ 32) : cs[i];\n                j++;\n            }\n            ans.push_back(cs);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def letterCasePermutation(self, s1: str) -> List[str]:\n        def isLetter(ch):\n            return 'a' <= ch <= 'z' or 'A' <= ch <= 'Z'\n        ans = []\n        n, m = len(s1), len([ch for ch in s1 if isLetter(ch)])\n        for s in range(1 << m):\n            cur = ''\n            j = 0\n            for i in range(n):\n                if not isLetter(s1[i]) or not ((s >> j) & 1):\n                    cur += s1[i]\n                else:\n                    cur += s1[i].swapcase()\n                if isLetter(s1[i]):\n                    j += 1\n            ans.append(cur)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction letterCasePermutation(str: string): string[] {\n    function isLetter(ch: string): boolean {\n        return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')\n    }\n    const ans = new Array<string>()\n    let n = str.length, m = 0\n    for (let i = 0; i < n; i++) m += isLetter(str[i]) ? 1 : 0\n    for (let s = 0; s < (1 << m); s++) {\n        let cur = ''\n        for (let i = 0, j = 0; i < n; i++) {\n            if (!isLetter(str[i]) || ((s >> j) & 1) == 0) cur += str[i]\n            else cur += String.fromCharCode(str.charCodeAt(i) ^ 32)\n            if (isLetter(str[i])) j++\n        }\n        ans.push(cur)\n    }\n    return ans\n}\n```\n* 时间复杂度:最坏情况下原串 `s` 的每一位均为字母(均有保留和转换两种决策),此时具体方案数量共 $2^n$ 种;同时每一种具体方案我们都需要用与原串长度相同的复杂度来进行构造。复杂度为 $O(n \\times 2^n)$\n* 空间复杂度:$O(n \\times 2^n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.784` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/781-790/786. 第 K 个最小的素数分数（中等）.md", "url_title": "786. 第 K 个最小的素数分数", "url": "https://leetcode-cn.com/problems/k-th-smallest-prime-fraction/solution/gong-shui-san-xie-yi-ti-shuang-jie-you-x-8ymk/", "difficulty": "中等", "tags": ["优先队列(堆)", "多路归并", "二分", "双指针"], "question": "给你一个按递增顺序排序的数组 `arr` 和一个整数 `k` 。\n\n数组 `arr` 由 $1$ 和若干 **素数**  组成,且其中所有整数互不相同。\n\n对于每对满足 $0 < i < j < arr.length$ 的 $i$ 和 $j$ ,可以得到分数 $arr[i] / arr[j]$ 。\n\n那么第 $k$ 个最小的分数是多少呢?  以长度为 $2$ 的整数数组返回你的答案, 这里 $answer[0] == arr[i]$ 且 $answer[1] == arr[j]$ 。\n\n示例 1:\n```\n输入:arr = [1,2,3,5], k = 3\n\n输出:[2,5]\n\n解释:已构造好的分数,排序后如下所示: \n1/5, 1/3, 2/5, 1/2, 3/5, 2/3\n很明显第三个最小的分数是 2/5\n```\n示例 2:\n```\n输入:arr = [1,7], k = 1\n\n输出:[1,7]\n```\n\n提示:\n* $2 <= arr.length <= 1000$\n* $1 <= arr[i] <= 3 \\times 10^4$\n* $arr[0] = 1$\n* $arr[i]$ 是一个 素数 ,$i > 0$\n* $arr$ 中的所有数字 互不相同 ,且按**严格递增**排序\n* $1 <= k <= arr.length \\times (arr.length - 1) / 2$", "solution": "### 优先队列(堆)\n\n数据范围只有 $10^3$,直接扫描所有点对的计算量不超过 $10^6$。\n\n因此我们可以使用「扫描点对」+「优先队列(堆)」的做法,使用二元组 $(arr[i], arr[j])$ 进行存储,构建大小为 $k$ 的大根堆。\n\n根据「堆内元素多少」和「当前计算值与堆顶元素的大小关系」决定入堆行为:\n\n* 若堆内元素不足 $k$ 个,直接将当前二元组进行入堆;\n* 若堆内元素已达 $k$ 个,根据「当前计算值 $\\frac{arr[i]}{arr[j]}$ 与堆顶元素 $\\frac{peek[0]}{peek[1]}$ 的大小关系」进行分情况讨论:\n    * 如果当前计算值比堆顶元素大,那么当前元素不可能是第 $k$ 小的值,直接丢弃;\n    * 如果当前计算值比堆顶元素小,那么堆顶元素不可能是第 $k$ 小的值,使用当前计算值置换掉堆顶元素。\n\n代码:\n```Java\nclass Solution {\n    public int[] kthSmallestPrimeFraction(int[] arr, int k) {\n        int n = arr.length;\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->Double.compare(b[0]*1.0/b[1],a[0]*1.0/a[1]));\n        for (int i = 0; i < n; i++) {\n            for (int j = i + 1; j < n; j++) {\n                double t = arr[i] * 1.0 / arr[j];\n                if (q.size() < k || q.peek()[0] * 1.0 / q.peek()[1] > t) {\n                    if (q.size() == k) q.poll();\n                    q.add(new int[]{arr[i], arr[j]});\n                }\n            }\n        }\n        return q.poll();\n    }\n}\n```\n* 时间复杂度:扫描所有的点对复杂度为 $O(n^2)$;将二元组入堆和出堆的复杂度为 $O(\\log{k})$。整体复杂度为 $O(n^2\\log{k})$\n* 空间复杂度:$O(k)$\n\n---\n\n### 多路归并\n\n在解法一中,我们没有利用「数组内元素严格单调递增」的特性。\n\n由于题目规定所有的点对 $(i, j)$ 必须满足 $i < j$,即给定 $arr[j]$ 后,其所能构建的分数个数为 $j$ 个,而这 $j$ 个分数值满足严格单调递增:$\\frac{arr[0]}{arr[j]} < \\frac{arr[1]}{arr[j]} < \\frac{arr[2]}{arr[j]} < ... < \\frac{arr[j - 1]}{arr[j]}$。\n\n问题等价于我们从 $n - 1$ 个(下标 $0$ 作为分母的话,不存在任何分数)有序序列中找到第 $k$ 小的数值。这 $n - 1$ 个序列分别为:\n\n* $[\\frac{arr[0]}{arr[1]}]$\n* $[\\frac{arr[0]}{arr[2]}, \\frac{arr[1]}{arr[2]}]$\n* $[\\frac{arr[0]}{arr[3]}, \\frac{arr[1]}{arr[3]}, \\frac{arr[2]}{arr[3]}]$\n    ... \n* $[\\frac{arr[0]}{arr[j]}, \\frac{arr[1]}{arr[j]}, \\frac{arr[2]}{arr[j]}, ... , \\frac{arr[j - 1]}{arr[j]}]$\n\n问题彻底切换为「多路归并」问题,我们使用「优先队列(堆)」来维护多个有序序列的当前头部的最小值即可。\n\n代码:\n```Java\nclass Solution {\n    public int[] kthSmallestPrimeFraction(int[] arr, int k) {\n        int n = arr.length;\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->{\n            double i1 = arr[a[0]] * 1.0 / arr[a[1]], i2 = arr[b[0]] * 1.0 / arr[b[1]];\n            return Double.compare(i1, i2);\n        });\n        for (int i = 1; i < n; i++) q.add(new int[]{0, i});\n        while (k-- > 1) {\n            int[] poll = q.poll();\n            int i = poll[0], j = poll[1];\n            if (i + 1 < j) q.add(new int[]{i + 1, j});\n        }\n        int[] poll = q.poll();\n        return new int[]{arr[poll[0]], arr[poll[1]]};\n    }\n}\n```\n* 时间复杂度:起始将 $n - 1$ 个序列的头部元素放入堆中,复杂度为 $O(n\\log{n})$;然后重复 $k$ 次操作得到第 $k$ 小的值,复杂度为 $O(k\\log{n})$。整体复杂度为 $O(\\max(n, k) \\times \\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 二分 + 双指针\n\n进一步,利用 $arr$ 递增,且每个点对 $(i, j)$ 满足 $i < j$,我们可以确定 $(i, j)$ 对应的分数 $\\frac{arr[i]}{arr[j]}$ 必然落在 $[0, 1]$ 范围内。\n\n假设最终答案 $\\frac{arr[i]}{arr[j]}$ 为 $x$,那么以 $x$ 为分割点的数轴(该数轴上的点为 $arr$ 所能构造的分数值)上具有「二段性」:\n\n* 小于等于 $x$ 的值满足:其左边分数值个数小于 $k$ 个;\n* 大于 $x$ 的值不满足:其左边分数值个数小于 $k$ 个(即至少有 $k$ 个)。\n\n而当确定 $arr[j]$ 时,利用 $arr$ 有序,我们可以通过「双指针」快速得知,满足 $\\frac{arr[i]}{arr[j]} <= x$ 的分子位置在哪(找到最近一个满足 $\\frac{arr[i]}{arr[j]} > x$ 的位置)。\n\n另外,我们可以在每次 `check` 的同时,记录下相应的 $arr[i]$ 和 $arr[j]$。\n\n代码:\n```Java\nclass Solution {\n    double eps = 1e-8;\n    int[] arr;\n    int n, a, b;\n    public int[] kthSmallestPrimeFraction(int[] _arr, int k) {\n        arr = _arr;\n        n = arr.length;\n        double l = 0, r = 1;\n        while (r - l > eps) {\n            double mid = (l + r) / 2;\n            if (check(mid) >= k) r = mid;\n            else l = mid;\n        }\n        return new int[]{a, b};\n    }\n    int check(double x){\n        int ans = 0;\n        for (int i = 0, j = 1; j < n; j++) {\n            while (arr[i + 1] * 1.0 / arr[j] <= x) i++;\n            if (arr[i] * 1.0 / arr[j] <= x) ans += i + 1;\n            if (Math.abs(arr[i] * 1.0 / arr[j] - x) < eps) {\n                a = arr[i]; b = arr[j];\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:二分次数取决于精度,精度为 $C = 10^8$,二分复杂度为 $O(\\log{C});$`check` 的复杂度为 $O(n)$。整体复杂度为 $O(n\\log{C})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.786` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/781-790/787. K 站中转内最便宜的航班（中等）.md", "url_title": "787. K 站中转内最便宜的航班", "url": "https://leetcode-cn.com/problems/cheapest-flights-within-k-stops/solution/gong-shui-san-xie-xiang-jie-bellman-ford-dc94/", "difficulty": "中等", "tags": ["最短路", "Bellman Ford"], "question": "有 `n` 个城市通过一些航班连接。给你一个数组 `flights`,其中 $flights[i] = [from_i, to_i, price_i]$ ,表示该航班都从城市 $from_i$ 开始,以价格 $price_i$ 抵达 $to_i$。\n\n现在给定所有的城市和航班,以及出发城市 `src` 和目的地 `dst`,你的任务是找到出一条最多经过 `k` 站中转的路线,使得从 `src` 到 `dst` 的 价格最便宜 ,并返回该价格。 如果不存在这样的路线,则输出 `-1`。\n\n示例 1:\n```\n输入: \nn = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]\nsrc = 0, dst = 2, k = 1\n\n输出: 200\n\n解释: \n城市航班图如下\n从城市 0 到城市 2 在 1 站中转以内的最便宜价格是 200,如图中红色所示。\n```\n\n示例 2:\n```\n输入: \nn = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]\nsrc = 0, dst = 2, k = 0\n\n输出: 500\n\n解释: \n城市航班图如下\n从城市 0 到城市 2 在 0 站中转以内的最便宜价格是 500,如图中蓝色所示。\n```\n\n提示:\n* 1 <= n <= 100\n* 0 <= flights.length <= (n * (n - 1) / 2)\n* flights[i].length == 3\n* 0 <= fromi, toi < n\n* fromi != toi\n* 1 <= pricei <= $10^4$\n* 航班没有重复,且不存在自环\n* 0 <= src, dst, k < n\n* src != dst", "solution": "### 基本分析\n\n从题面看就能知道,这是一类「有限制」的最短路问题。\n\n「限制最多经过不超过 $k$ 个点」等价于「限制最多不超过 $k + 1$ 条边」,而解决「有边数限制的最短路问题」是 SPFA 所不能取代 Bellman Ford 算法的经典应用之一(SPFA 能做,但不能直接做)。\n\n**Bellman Ford/SPFA 都是基于动态规划,其原始的状态定义为 $f[i][k]$ 代表从起点到 $i$ 点,且经过最多 $k$ 条边的最短路径。这样的状态定义引导我们能够使用 Bellman Ford 来解决有边数限制的最短路问题。**\n\n**同样多源汇最短路算法 Floyd 也是基于动态规划,其原始的三维状态定义为 $f[i][j][k]$ 代表从点 $i$ 到点 $j$,且经过的所有点编号不会超过 $k$(即可使用点编号范围为 $[1, k]$)的最短路径。这样的状态定义引导我们能够使用 Floyd 求最小环或者求“重心点”(即删除该点后,最短路值会变大)。**\n\n如果你对几类最短算法不熟悉,可以看 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488007&idx=1&sn=9d0dcfdf475168d26a5a4bd6fcd3505d&chksm=fd9cb918caeb300e1c8844583db5c5318a89e60d8d552747ff8c2256910d32acd9013c93058f&token=754098973&lang=zh_CN#rd),里面涵盖所有的「最短路算法」和「存图方式」。\n\n---\n\n### Bellman Ford + 邻接矩阵\n\n回到本题,「限制最多经过不超过 $k$ 个点」等价于「限制最多不超过 $k + 1$ 条边」,因此可以使用 Bellman Ford 来求解。\n\n点的数量只有 $100$,可以直接使用「邻接矩阵」的方式进行存图。\n\n> 需要注意的是,在遍历所有的“点对/边”进行松弛操作前,需要先对 $dist$ 进行备份,否则会出现「本次松弛操作所使用到的边,也是在同一次迭代所更新的」,从而不满足边数限制的要求。\n举个 🌰,例如本次松弛操作使用了从 $a$ 到 $b$ 的当前最短距离来更新 $dist[b]$,直接使用 $dist[a]$ 的话,不能确保 $dist[a]$ 不是在同一次迭代中所更新,如果 $dist[a]$ 是同一次迭代所更新的话,那么使用的边数将会大于 $k$ 条。\n因此在每次迭代开始前,我们都应该对 $dist$ 进行备份,在迭代时使用备份来进行松弛操作。\n\n代码:\n```Java\nclass Solution {\n    int N = 110, INF = 0x3f3f3f3f;\n    int[][] g = new int[N][N];\n    int[] dist = new int[N];\n    int n, m, s, t, k;\n    public int findCheapestPrice(int _n, int[][] flights, int _src, int _dst, int _k) {\n        n = _n; s = _src; t = _dst; k = _k + 1;\n        for (int i = 0; i < N; i++) {\n            for (int j = 0; j < N; j++) {\n                g[i][j] = i == j ? 0 : INF;\n            }\n        }\n        for (int[] f : flights) {\n            g[f[0]][f[1]] = f[2];\n        }\n        int ans = bf();\n        return ans > INF / 2 ? -1 : ans;\n    }\n    int bf() {\n        Arrays.fill(dist, INF);\n        dist[s] = 0;\n        for (int limit = 0; limit < k; limit++) {\n            int[] clone = dist.clone();\n            for (int i = 0; i < n; i++) {\n                for (int j = 0; j < n; j++) {\n                    dist[j] = Math.min(dist[j], clone[i] + g[i][j]);\n                }\n            }\n        }\n        return dist[t];\n    }\n}\n```\n* 时间复杂度:$O(k * n^2)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### Bellman Ford + 类\n\n我们知道 Bellman Ford 需要遍历所有的边,而使用「邻接矩阵」的存图方式让我们不得不遍历所有的点对,复杂度为 $O(n^2)$。\n\n而边的数量 $m$ 的数据范围为 $0 <= flights.length <= (n * (n - 1) / 2)$,因此我们可以使用「类」的方式进行存图,从而确保在遍历所有边的时候,复杂度严格为 $O(m)$,而不是 $O(n^2)$。\n\n代码:\n```Java\nclass Solution {\n    class Edge {\n        int x, y, w;\n        Edge(int _x, int _y, int _w) {\n            x = _x; y = _y; w = _w;\n        }\n    }\n    int N = 110, INF = 0x3f3f3f3f;\n    int[] dist = new int[N];\n    List<Edge> list = new ArrayList<>();\n    int n, m, s, t, k;\n    public int findCheapestPrice(int _n, int[][] flights, int _src, int _dst, int _k) {\n        n = _n; s = _src; t = _dst; k = _k + 1;\n        for (int[] f : flights) {\n            list.add(new Edge(f[0], f[1], f[2]));\n        }\n        m = list.size();\n        int ans = bf();\n        return ans > INF / 2 ? -1 : ans;\n    }\n    int bf() {\n        Arrays.fill(dist, INF);\n        dist[s] = 0;\n        for (int i = 0; i < k; i++) {\n            int[] clone = dist.clone();\n            for (Edge e : list) {\n                int x = e.x, y = e.y, w = e.w;\n                dist[y] = Math.min(dist[y], clone[x] + w);\n            }\n        }\n        return dist[t];\n    }\n}\n```\n* 时间复杂度:共进行 $k + 1$ 次迭代,每次迭代备份数组复杂度为 $O(n)$,然后遍历所有的边进行松弛操作,复杂度为 $O(m)$。整体复杂度为 $O(k * (n + m))$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### Bellman Ford\n\n更进一步,由于 Bellman Ford 核心操作需要遍历所有的边,因此也可以直接使用 $flights$ 数组作为存图信息,而无须额外存图。\n\n代码:\n```Java\nclass Solution {\n    int N = 110, INF = 0x3f3f3f3f;\n    int[] dist = new int[N];\n    public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {\n        Arrays.fill(dist, INF);\n        dist[src] = 0;\n        for (int limit = 0; limit < k + 1; limit++) {\n            int[] clone = dist.clone();\n            for (int[] f : flights) {\n                int x = f[0], y = f[1], w = f[2];\n                dist[y] = Math.min(dist[y], clone[x] + w);\n            }\n        }\n        return dist[dst] > INF / 2 ? -1 : dist[dst];\n    }\n}\n```\n* 时间复杂度:共进行 $k + 1$ 次迭代,每次迭代备份数组复杂度为 $O(n)$,然后遍历所有的边进行松弛操作,复杂度为 $O(m)$。整体复杂度为 $O(k * (n + m))$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.787` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/781-790/788. 旋转数字（中等）.md", "url_title": "788. 旋转数字", "url": "https://leetcode.cn/problems/rotated-digits/solution/by-ac_oier-9qpw/", "difficulty": "中等", "tags": ["模拟"], "question": "我们称一个数 `X` 为好数, 如果它的每位数字逐个地被旋转 `180` 度后,我们仍可以得到一个有效的,且和 `X` 不同的数。要求每位数字都要被旋转。\n\n如果一个数的每位数字被旋转以后仍然还是一个数字, 则这个数是有效的。0, 1, 和 8 被旋转后仍然是它们自己;2 和 5 可以互相旋转成对方(在这种情况下,它们以不同的方向旋转,换句话说,2 和 5 互为镜像);6 和 9 同理,除了这些以外其他的数字旋转以后都不再是有效的数字。\n\n现在我们有一个正整数 `N`, 计算从 `1` 到 `N` 中有多少个数 X 是好数?\n\n示例:\n```\n输入: 10\n\n输出: 4\n\n解释: \n在[1, 10]中有四个好数: 2, 5, 6, 9。\n注意 1 和 10 不是好数, 因为他们在旋转之后不变。\n```\n\n提示:\n* `N` 的取值范围是 $[1, 10000]$。", "solution": "### 模拟\n\n利用 $n$ 的范围为 $1e4$,我们可以直接检查 $[1, n]$ 的每个数。\n\n由于每一个位数都需要翻转,因此如果当前枚举到的数值 `x` 中包含非有效翻转数字(非 `0125689`)则必然不是好数;而在每一位均为有效数字的前提下,若当前枚举到的数值 `x` 中包含翻转后能够发生数值上变化的数值(`2569`),则为好数。\n\nJava 代码:\n```Java\nclass Solution {\n    public int rotatedDigits(int n) {\n        int ans = 0;\n        out:for (int i = 1; i <= n; i++) {\n            boolean ok = false;\n            int x = i;\n            while (x != 0) {\n                int t = x % 10;\n                x /= 10;\n                if (t == 2 || t == 5 || t == 6 || t == 9) ok = true;\n                else if (t != 0 && t != 1 && t != 8) continue out;\n            }\n            if (ok) ans++;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction rotatedDigits(n: number): number {\n    let ans = 0\n    out:for (let i = 1; i <= n; i++) {\n        let ok = false\n        let x = i\n        while (x != 0) {\n            const t = x % 10\n            x = Math.floor(x / 10)\n            if (t == 2 || t == 5 || t == 6 || t == 9) ok = true\n            else if (t != 0 && t != 1 && t != 8) continue out\n        }\n        if (ok) ans++\n    }\n    return ans\n};\n```\nPython3 代码:\n```Python3\nclass Solution:\n    def rotatedDigits(self, n: int) -> int:\n        ans = 0\n        for i in range(1, n + 1):\n            ok, x = False, i\n            while x != 0:\n                t = x % 10\n                x = x // 10\n                if t == 2 or t == 5 or t == 6 or t == 9:\n                    ok = True\n                elif t != 0 and t != 1 and t != 8:\n                    ok = False\n                    break\n            ans = ans + 1 if ok else ans\n        return ans\n```\n* 时间复杂度:共有 $n$ 个数需要枚举,检查一个数需要遍历其每个数字,复杂度为 $O(\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.788` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/781-790/789. 逃脱阻碍者（中等）.md", "url_title": "789. 逃脱阻碍者", "url": "https://leetcode-cn.com/problems/escape-the-ghosts/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-w69gr/", "difficulty": "中等", "tags": ["数学"], "question": "你在进行一个简化版的吃豆人游戏。你从 [0, 0] 点开始出发,你的目的地是 target = [xtarget, ytarget] 。地图上有一些阻碍者,以数组 ghosts 给出,第 i 个阻碍者从 ghosts[i] = [xi, yi] 出发。所有输入均为 整数坐标 。\n\n每一回合,你和阻碍者们可以同时向东,西,南,北四个方向移动,每次可以移动到距离原位置 1 个单位 的新位置。当然,也可以选择 不动 。所有动作 同时 发生。\n\n如果你可以在任何阻碍者抓住你 之前 到达目的地(阻碍者可以采取任意行动方式),则被视为逃脱成功。如果你和阻碍者同时到达了一个位置(包括目的地)都不算是逃脱成功。\n\n只有在你有可能成功逃脱时,输出 true ;否则,输出 false 。\n\n示例 1:\n```\n输入:ghosts = [[1,0],[0,3]], target = [0,1]\n\n输出:true\n\n解释:你可以直接一步到达目的地 (0,1) ,在 (1, 0) 或者 (0, 3) 位置的阻碍者都不可能抓住你。 \n```\n示例 2:\n```\n输入:ghosts = [[1,0]], target = [2,0]\n\n输出:false\n\n解释:你需要走到位于 (2, 0) 的目的地,但是在 (1, 0) 的阻碍者位于你和目的地之间。 \n```\n示例 3:\n```\n输入:ghosts = [[2,0]], target = [1,0]\n\n输出:false\n\n解释:阻碍者可以和你同时达到目的地。 \n```\n示例 4:\n```\n输入:ghosts = [[5,0],[-10,-2],[0,-5],[-2,-2],[-7,1]], target = [7,7]\n\n输出:false\n```\n示例 5:\n```\n输入:ghosts = [[-1,0],[0,1],[-1,0],[0,1],[-1,0]], target = [0,0]\n\n输出:true\n```\n\n提示:\n* 1 <= ghosts.length <= 100\n* ghosts[i].length == 2\n* -$10^4$ <= xi, yi <= $10^4$\n* 同一位置可能有 多个阻碍者 。\n* target.length == 2\n* -$10^4$ <= xtarget, ytarget <= $10^4$", "solution": "### 数学\n\n从数据范围 $-10^4 <= x_{target}, y_{target} <= 10^4$ 且每次只能移动一个单位(或不移动)就注定了不能使用朴素的 `BFS` 进行求解。\n\n朴素的 `BFS` 是指每次在玩家移动一步前,先将阻碍者可以一步到达的位置“置灰”(即设为永不可达),然后判断玩家是否能够到达 $target$。\n\n朴素 `BFS` 本质是模拟,由于棋盘足够大,步长只有 $1$,因此该做法显然会 TLE。\n\n是否有比模拟更快的做法呢?\n\n**根据「树的直径」类似的证明,我们可以证明出「如果一个阻碍者能够抓到玩家,必然不会比玩家更晚到达终点」。**\n\n为了方便,我们设玩家起点、阻碍者起点、终点分别为 $s$、$e$ 和 $t$,计算两点距离的函数为 $dist(x, y)$。\n\n假设玩家从 $s$ 到 $t$ 的路径中会经过点 $k$,**当且仅当 $dist(e, k) <= dist(s, k)$,即「阻碍者起点与点 $k$ 的距离」小于等于「玩家起点与点 $k$ 的距离」时,阻碍者可以在点 $k$ 抓到玩家。**\n\n由于「玩家到终点」以及「阻碍者到终点」的路径存在公共部分 $dist(k, t)$,可推导出:\n\n$$\ndist(e, k) + dist(k, t) <= dist(s, k) + dist(k, t)\n$$\n\n即得证 **如果一个阻碍者能够抓到玩家,那么该阻碍者必然不会比玩家更晚到达终点。**\n\n由于步长为 $1$,且移动规则为上下左右四联通方向,因此 $dist(x, y)$ 的实现为计算两点的曼哈顿距离。\n\n代码:\n```Java\nclass Solution {\n    int dist(int x1, int y1, int x2, int y2) {\n        return Math.abs(x1 - x2) + Math.abs(y1 - y2);\n    }\n    public boolean escapeGhosts(int[][] gs, int[] t) {\n        int cur = dist(0, 0, t[0], t[1]);\n        for (int[] g : gs) {\n            if (dist(g[0], g[1], t[0], t[1]) <= cur) return false;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:令 $gs$ 长度为 $n$,计算曼哈顿距离复杂度为 $O(1)$,整体复杂度为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.789` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/781-790/790. 多米诺和托米诺平铺（中等）.md", "url_title": "790. 多米诺和托米诺平铺", "url": "https://leetcode.cn/problems/domino-and-tromino-tiling/solution/gong-shui-san-xie-by-ac_oier-kuv4/", "difficulty": "中等", "tags": ["状态机 DP", "动态规划"], "question": "有两种形状的瓷砖:一种是 `2 x 1` 的多米诺形,另一种是形如 `\"L\"` 的托米诺形,两种形状都可以旋转。\n\n给定整数 `n` ,返回可以平铺 `2 x n` 的面板的方法的数量,返回对 $10^9 + 7$ 取模 的值。\n\n平铺指的是每个正方形都必须有瓷砖覆盖。\n\n两个平铺不同,当且仅当面板上有四个方向上的相邻单元中的两个,使得恰好有一个平铺有一个瓷砖占据两个正方形。\n\n示例 1:\n\n```\n输入: n = 3\n\n输出: 5\n\n解释: 五种不同的方法如上所示。\n```\n示例 2:\n```\n输入: n = 1\n\n输出: 1\n```\n\n提示:\n* $1 <= n <= 1000$", "solution": "### 状态机 DP\n\n定义 $f[i][j]$ 为无须考虑前 $i - 1$ 列(含义为前 $i - 1$ 列已铺满),当前第 $i$ 列状态为 $j$ 时的方案数。\n\n其中 $j$ 取值范围为 $[0, 4)$ 分别对应了当前列的填充情况:\n\n为了方便,我们人为规定列数从 $1$ 开始。\n\n由于骨牌只能在 $2 \\times n$ 的棋盘内填充(不能延伸出棋盘两端),因此我们有显而易见的初始化状态:\n\n$$\nf[1][0] = f[1][1] = 1\n$$\n\n分别对应「第一列不放置任何骨牌」和「第一列竖着放一块 $1 \\times 2$ 骨牌」合法方案。\n\n而 $f[1][2]$ 和 $f[1][3]$ 由于没法在棋盘左侧以外的位置放置骨牌,不存在合法方案,其值均为 $0$。\n\n同时可知 $f[n][1]$ 为我们最终答案,含义为所有列都恰好铺完,不溢出棋盘右侧位置。\n\n不失一般性考虑 $f[i][j]$ 该如何计算,其实就是一个简单的状态机转移分情况讨论:\n\n* $f[i][0]$ : 需要前 $i - 1$ 列铺满,同时第 $i$ 列没有被铺,只能由 $f[i - 1][1]$ 转移而来,即有 $f[i][0] = f[i - 1][1]$\n    > 这里需要尤其注意:虽然我们能够在上一步留空第 $i - 1$ 列,然后在 $i - 1$ 列竖放一块 $1 \\times 2$ 的骨牌(如下图)\n    \n    \n    \n    > 但我们不能从 $f[i - 1][0]$ 转移到 $f[i][0]$,因为此时放置的骨牌,仅对第 $i - 1$ 列产生影响,不会对第 $i$ 列产生影响,该决策所产生的方案数,已在 $f[i - 1][X]$ 时被统计\n\n* $f[i][1]$ : 可由 $f[i - 1][j]$ 转移而来(见下图),其中 $j \\in [0, 4)$,即有 $f[i][1] = \\sum_{j = 0}^{3} f[i - 1][j]$\n\n    \n\n* $f[i][2]$ : 可由 $f[i - 1][0]$ 和 $f[i - 1][3]$ 转移而来\n\n* $f[i][3]$ : 可由 $f[i - 1][0]$ 和 $f[i - 1][2]$ 转移而来\n\nJava 代码:\n```Java\nclass Solution {\n    int MOD = (int)1e9+7;\n    public int numTilings(int n) {\n        int[][] f = new int[n + 10][4];\n        f[1][0] = f[1][1] = 1;\n        for (int i = 2; i <= n; i++) {\n            f[i][0] = f[i - 1][1];\n            int cur = 0;\n            for (int j = 0; j < 4; j++) cur = (cur + f[i - 1][j]) % MOD;\n            f[i][1] = cur;\n            f[i][2] = (f[i - 1][0] + f[i - 1][3]) % MOD;\n            f[i][3] = (f[i - 1][0] + f[i - 1][2]) % MOD;\n        }\n        return f[n][1];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\n    const int MOD = 1e9 + 7;\npublic:\n    int numTilings(int n){\n        vector<vector<int>> f(n + 10, vector<int>(4));\n        f[1][0] = f[1][1] = 1;\n        for (int i = 2; i <= n; ++i){\n            f[i][0] = f[i - 1][1];\n            int cur = 0;\n            for (int j = 0; j < 4; ++j) cur = (cur + f[i - 1][j]) % MOD;\n            f[i][1] = cur;\n            f[i][2] = (f[i - 1][0] + f[i - 1][3]) % MOD;\n            f[i][3] = (f[i - 1][0] + f[i - 1][2]) % MOD;\n        }\n        return f[n][1];\n    }\n};\n```\nPython3 代码:\n```Python\nclass Solution:\n    def numTilings(self, n: int) -> int:\n        f = [[0] * 4 for _ in range(n + 10)]\n        f[1][0] = f[1][1] = 1\n        for i in range(2, n + 1):\n            f[i][0] = f[i - 1][1]\n            f[i][1] = sum([f[i - 1][j] for j in range(4)])\n            f[i][2] = f[i - 1][0] + f[i - 1][3]\n            f[i][3] = f[i - 1][0] + f[i - 1][2]\n        return f[n][1] % 1000000007\n```\nTypeScript 代码:\n```TypeScript\nfunction numTilings(n: number): number {\n    const MOD = 1e9+7\n    const f = new Array<Array<number>>()\n    for (let i = 0; i <= n; i++) f[i] = new Array<number>(4).fill(0)\n    f[1][0] = f[1][1] = 1\n    for (let i = 2; i <= n; i++) {\n        f[i][0] = f[i - 1][1]\n        let cur = 0\n        for (let j = 0; j < 4; j++) cur = (cur + f[i - 1][j]) % MOD\n        f[i][1] = cur\n        f[i][2] = (f[i - 1][0] + f[i - 1][3]) % MOD\n        f[i][3] = (f[i - 1][0] + f[i - 1][2]) % MOD\n    }\n    return f[n][1]\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 滚动数组优化\n\n利用 $f[i][X]$ 仅依赖于 $f[i - 1][X]$,我们可以采用「滚动数组」方式将其空间优化至 $O(1)$。\n\nJava 代码:\n```Java\nclass Solution {\n    int MOD = (int)1e9+7;\n    public int numTilings(int n) {\n        int[][] f = new int[2][4];\n        f[1][0] = f[1][1] = 1;\n        for (int i = 2; i <= n; i++) {\n            int a = i & 1, b = (i - 1) & 1;\n            f[a][0] = f[b][1];\n            int cur = 0;\n            for (int j = 0; j < 4; j++) cur = (cur + f[b][j]) % MOD;\n            f[a][1] = cur;\n            f[a][2] = (f[b][0] + f[b][3]) % MOD;\n            f[a][3] = (f[b][0] + f[b][2]) % MOD;\n        }\n        return f[n & 1][1];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\n    const int MOD = 1e9 + 7;\npublic:\n    int numTilings(int n){\n        vector<vector<int>> f(2, vector<int>(4));\n        f[1][0] = f[1][1] = 1;\n        for (int i = 2; i <= n; ++i){\n            int a = i & 1, b = (i - 1) & 1;\n            f[a][0] = f[b][1];\n            int cur = 0;\n            for (int j = 0; j < 4; ++j) cur = (cur + f[b][j]) % MOD;\n            f[a][1] = cur;\n            f[a][2] = (f[b][0] + f[b][3]) % MOD;\n            f[a][3] = (f[b][0] + f[b][2]) % MOD;\n        }\n        return f[n & 1][1];\n    }\n};\n```\nPython3 代码:\n```Python\nclass Solution:\n    def numTilings(self, n: int) -> int:\n        f = [[0] * 4 for _ in range(2)]\n        f[1][0] = f[1][1] = 1\n        for i in range(2, n + 1):\n            a, b = i & 1, (i - 1) & 1\n            f[a][0] = f[b][1]\n            f[a][1] = sum([f[b][j] for j in range(4)])\n            f[a][2] = f[b][0] + f[b][3]\n            f[a][3] = f[b][0] + f[b][2]\n        return f[n & 1][1] % 1000000007\n```\nTypeScript 代码:\n```TypeScript\nfunction numTilings(n: number): number {\n    const MOD = 1e9+7\n    const f = new Array<Array<number>>()\n    for (let i = 0; i <= 1; i++) f[i] = new Array<number>(4).fill(0)\n    f[1][0] = f[1][1] = 1\n    for (let i = 2; i <= n; i++) {\n        const a = i & 1, b = (i - 1) & 1\n        f[a][0] = f[b][1]\n        let cur = 0\n        for (let j = 0; j < 4; j++) cur = (cur + f[b][j]) % MOD\n        f[a][1] = cur\n        f[a][2] = (f[b][0] + f[b][3]) % MOD\n        f[a][3] = (f[b][0] + f[b][2]) % MOD\n    }\n    return f[n & 1][1]\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.790` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/791-800/791. 自定义字符串排序（中等）.md", "url_title": "791. 自定义字符串排序", "url": "https://leetcode.cn/problems/custom-sort-string/solution/by-ac_oier-ali0/", "difficulty": "中等", "tags": ["构造", "模拟"], "question": "给定两个字符串 `order` 和 `s` 。\n\n`order` 的所有单词都是唯一的,并且以前按照一些自定义的顺序排序。\n\n对 `s` 的字符进行置换,使其与排序的 `order` 相匹配。\n\n更具体地说,如果在 `order` 中的字符 `x` 出现字符 `y` 之前,那么在排列后的字符串中, `x` 也应该出现在 `y` 之前。\n\n返回满足这个性质的 `s` 的任意排列 。\n\n示例 1:\n```\n输入: order = \"cba\", s = \"abcd\"\n\n输出: \"cbad\"\n\n解释: \n“a”、“b”、“c”是按顺序出现的,所以“a”、“b”、“c”的顺序应该是“c”、“b”、“a”。\n因为“d”不是按顺序出现的,所以它可以在返回的字符串中的任何位置。“dcba”、“cdba”、“cbda”也是有效的输出。\n```\n示例 2:\n```\n输入: order = \"cbafg\", s = \"abcd\"\n\n输出: \"cbad\"\n```\n\n提示:\n* $1 <= order.length <= 26$\n* $1 <= s.length <= 200$\n* `order` 和 `s` 由小写英文字母组成\n* `order` 中的所有字符都 不同", "solution": "### 构造\n\n根据题意进行模拟即可:起始先使用大小为 $C = 26$ 的数组 `cnts` 对 `s` 的所有字符进行词频统计,随后根据 `order` 的优先级进行构造。\n\n若字符 `x` 在 `order` 中排于 `y` 前面,则先往答案追加 `cnts[x]` 个字符 `x`,再往答案追加 `cnts[y]` 个字符 `y`,并更新对应词频,最后将仅出现在 `s` 中的字符追加到答案尾部。\n\nJava 代码:\n```Java\nclass Solution {\n    public String customSortString(String order, String s) {\n        int[] cnts = new int[26];\n        for (char c : s.toCharArray()) cnts[c - 'a']++;\n        StringBuilder sb = new StringBuilder();\n        for (char c : order.toCharArray()) {\n            while (cnts[c - 'a']-- > 0) sb.append(c);\n        }\n        for (int i = 0; i < 26; i++) {\n            while (cnts[i]-- > 0) sb.append((char)(i + 'a'));\n        }\n        return sb.toString();\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    string customSortString(string order, string s) {\n        vector<int> cnts(26, 0);\n        for (char c : s) cnts[c - 'a']++;\n        string result = \"\";\n        for (char c : order) {\n            while (cnts[c - 'a']-- > 0) result += c;\n        }\n        for (int i = 0; i < 26; i++) {\n            while (cnts[i]-- > 0) result += (char)(i + 'a');\n        }\n        return result;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def customSortString(self, order: str, s: str) -> str:\n        cnts = [0] * 26\n        for c in s:\n            cnts[ord(c) - ord('a')] += 1\n        ans = ''\n        for c in order:\n            num = ord(c) - ord('a')\n            if cnts[num] > 0:\n                ans += c * cnts[num]\n                cnts[num] = 0\n        for i in range(26):\n            if cnts[i] > 0:\n                ans += chr(i + ord('a')) * cnts[i]\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction customSortString(order: string, s: string): string {\n    const cnts = new Array<number>(26).fill(0)\n    for (const c of s) cnts[c.charCodeAt(0) - 'a'.charCodeAt(0)]++\n    let ans = ''\n    for (const c of order) {\n        while (cnts[c.charCodeAt(0) - 'a'.charCodeAt(0)]-- > 0) ans += c\n    }\n    for (let i = 0; i < 26; i++) {\n        while (cnts[i]-- > 0) ans += String.fromCharCode(i + 'a'.charCodeAt(0));\n    }\n    return ans\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(C)$,其中 $C = 26$ 为字符集大小", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.791` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/791-800/792. 匹配子序列的单词数（中等）.md", "url_title": "792. 匹配子序列的单词数", "url": "https://leetcode.cn/problems/number-of-matching-subsequences/solution/by-ac_oier-u1ox/", "difficulty": "中等", "tags": ["二分", "哈希表"], "question": "给定字符串 `s` 和字符串数组 `words`, 返回  `words[i]` 中是 `s` 的子序列的单词个数 。\n\n字符串的子序列是从原始字符串中生成的新字符串,可以从中删去一些字符(可以是`\"\"`),而不改变其余字符的相对顺序。\n\n例如, `“ace”` 是 `“abcde”` 的子序列。\n\n示例 1:\n```\n输入: s = \"abcde\", words = [\"a\",\"bb\",\"acd\",\"ace\"]\n\n输出: 3\n\n解释: 有三个是 s 的子序列的单词: \"a\", \"acd\", \"ace\"。\n```\n示例 2:\n```\n输入: s = \"dsahjpjauf\", words = [\"ahjpjau\",\"ja\",\"ahbwzgqnuk\",\"tnmlanowax\"]\n\n输出: 2\n```\n\n提示:\n* $1 <= s.length <= 5 \\times 10^4$\n* $1 <= words.length <= 5000$\n* $1 <= words[i].length <= 50$\n* `words[i]` 和 `s` 都只由小写字母组成。", "solution": "### 预处理 + 哈希表 + 二分\n\n朴素判定某个字符串是为另一字符串的子序列的复杂度为 $O(n + m)$,对于本题共有 $5000$ 个字符串需要判定,每个字符串最多长为 $50$,因此整体计算量为 $(5 \\times 10^4 + 50) \\times 5000 \\approx 2.5 \\times 10^8$,会超时。\n\n不可避免的是,我们要对每个 $words[i]$ 进行检查,因此优化的思路可放在如何优化单个 $words[i]$ 的判定操作。\n\n朴素的判定过程需要使用双指针扫描两个字符串,其中对于原串的扫描,会有大量的字符会被跳过(无效匹配),即只有两指针对应的字符相同时,匹配串指针才会后移。\n\n我们考虑如何优化这部分无效匹配。\n\n对于任意一个 $w = words[i]$ 而言,假设我们当前匹配到 $w[j]$ 位置,此时我们已经明确下一个待匹配的字符为 $w[j + 1]$,因此我们可以直接在 `s` 中字符为 $w[j + 1]$ 的位置中找候选。\n\n具体的,我们可以使用哈希表 `map` 对 `s` 进行预处理:以字符 $c = s[i]$ 为哈希表的 `key`,对应的下标 $i$ 集合为 `value`,由于我们从前往后处理 `s` 进行预处理,因此对于所有的 `value` 均满足递增性质。\n\n> 举个 🌰 : 对于 `s = abcabc` 而言,预处理的哈希表为 `{a=[0,3], b=[1,4], c=[2,5]}`\n\n最后考虑如何判定某个 $w = words[i]$ 是否满足要求:待匹配字符串 `w` 长度为 `m`,我们从前往后对 `w` 进行判定,假设当前判待匹配位置为 $w[i]$,我们使用变量 `idx` 代表能够满足匹配 $w[0:i]$ 的最小下标(贪心思路)。\n\n对于匹配的 $w[i]$ 字符,可以等价为在 `map[w[i]]` 中找到第一个大于 `idx` 的下标,含义在原串 `s` 中找到字符为 `w[i]` 且下标大于 `idx` 的最小值,由于我们所有的 `map[X]` 均满足单调递增,该过程可使用「二分」进行。\n\nJava 代码:\n```Java\nclass Solution {\n    public int numMatchingSubseq(String s, String[] words) {\n        int n = s.length(), ans = 0;\n        Map<Character, List<Integer>> map = new HashMap<>();\n        for (int i = 0; i < n; i++) {\n            List<Integer> list = map.getOrDefault(s.charAt(i), new ArrayList<>());\n            list.add(i);\n            map.put(s.charAt(i), list);\n        }\n        for (String w : words) {\n            boolean ok = true;\n            int m = w.length(), idx = -1;\n            for (int i = 0; i < m && ok; i++) {\n                List<Integer> list = map.getOrDefault(w.charAt(i), new ArrayList<>());\n                int l = 0, r = list.size() - 1;\n                while (l < r) {\n                    int mid = l + r >> 1;\n                    if (list.get(mid) > idx) r = mid;\n                    else l = mid + 1;\n                }\n                if (r < 0 || list.get(r) <= idx) ok = false;\n                else idx = list.get(r);\n            }\n            if (ok) ans++;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction numMatchingSubseq(s: string, words: string[]): number {\n    let n = s.length, ans = 0\n    const map = new Map<String, Array<number>>()\n    for (let i = 0; i < n; i++) {\n        if (!map.has(s[i])) map.set(s[i], new Array<number>())\n        map.get(s[i]).push(i)\n    }\n    for (const w of words) {\n        let ok = true\n        let m = w.length, idx = -1\n        for (let i = 0; i < m && ok; i++) {\n            if (!map.has(w[i])) {\n                ok = false\n            } else {\n                const list = map.get(w[i])\n                let l = 0, r = list.length - 1\n                while (l < r) {\n                    const mid = l + r >> 1\n                    if (list[mid] > idx) r = mid\n                    else l = mid + 1\n                }\n                if (r < 0 || list[r] <= idx) ok = false\n                else idx = list[r]\n            }\n        }\n        if (ok) ans++\n    }\n    return ans\n}\n```\nPython3 代码:\n```Python\nclass Solution:\n    def numMatchingSubseq(self, s: str, words: List[str]) -> int:\n        dmap = defaultdict(list)\n        for i, c in enumerate(s):\n            dmap[c].append(i)\n        ans = 0\n        for w in words:\n            ok = True\n            idx = -1\n            for i in range(len(w)):\n                idxs = dmap[w[i]]\n                l, r = 0, len(idxs) - 1\n                while l < r :\n                    mid = l + r >> 1\n                    if dmap[w[i]][mid] > idx:\n                        r = mid\n                    else:\n                        l = mid + 1\n                if r < 0 or dmap[w[i]][r] <= idx:\n                    ok = False\n                    break\n                else:\n                    idx = dmap[w[i]][r]\n            ans += 1 if ok else 0\n        return ans\n```\n* 时间复杂度:令 `n` 为 `s` 长度,`m` 为 `words` 长度,`l = 50` 为 $words[i]$ 长度的最大值。构造 `map` 的复杂度为 $O(n)$;统计符合要求的 $words[i]$ 的数量复杂度为 $O(m \\times l \\times \\log{n})$。整体复杂度为 $O(n + m \\times l \\times \\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.792` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/791-800/793. 阶乘函数后 K 个零（困难）.md", "url_title": "793. 阶乘函数后 K 个零", "url": "https://leetcode.cn/problems/preimage-size-of-factorial-zeroes-function/solution/by-ac_oier-pk9g/", "difficulty": "困难", "tags": ["数学", "二分", "容斥原理"], "question": "`f(x)` 是 `x!` 末尾是 `0` 的数量。回想一下 `x! = 1 * 2 * 3 * ... * x`,且 `0! = 1`。\n\n例如, `f(3) = 0`,因为 `3! = 6` 的末尾没有 `0` ;而 `f(11) = 2`,因为 `11!= 39916800` 末端有 `2` 个 `0` 。\n\n给定 `k`,找出返回能满足 `f(x) = k` 的非负整数 `x` 的数量。\n\n示例 1:\n```\n输入:k = 0\n\n输出:5\n\n解释:0!, 1!, 2!, 3!, 和 4! 均符合 k = 0 的条件。\n```\n示例 2:\n```\n输入:k = 5\n\n输出:0\n\n解释:没有匹配到这样的 x!,符合 k = 5 的条件。\n```\n示例 3:\n```\n输入: k = 3\n\n输出: 5\n```\n\n提示:\n* $0 <= k <= 10^9$", "solution": "### 数学 + 二分\n\n对于一个 $n! = 1 \\times 2 \\times ... \\times (n - 1) \\times n$ 而言,其最终结果尾部包含 $0$ 的数量取决于其被累乘 $10$ 的次数,而 $10$ 可通过质因数 $2$ 和 $5$ 相乘而来,因此假设对 $n!$ 进行阶乘分解,最终分解出 $2^p$ 和 $5^q$ 的话,那么最终结果尾部包含 $0$ 的个数为 $q$ 个(可证明 $p >= q$ 始终满足)。 \n\n因此原问题转化为:在非负整数中,有多少个数进行阶乘分解后,所含质因数 $5$ 的个数恰好为 $k$ 个。\n\n同时我们可知:随着 $n$ 的增大,其所能分解出来的 $5$ 的个数必然是递增的。\n\n基于此,我们可以通过「二分 + 容斥原理」来得出分解 $5$ 个数恰好为 $k$ 的连续段长度。假设我们存在函数 `f(k)` 可得到非负整数中分解 $5$ 个数为小于等于 `k` 的个数,那么最终 `f(k) - f(k - 1)` 即是答案。\n\n在单调函数上求解小于等于 `k` 分割点,可通过「二分」来做。剩下的问题是,如何求得给定 `x` 时,其阶乘分解所包含 $5$ 个个数,这可以通过 $O(\\log{x})$ 的筛法来做。\n\n最后还要确定二分的值域,由于我们是求阶乘分解中 $5$ 的个数,因此值域的上界为 $5k$,利用 $k$ 的范围为 $1e9$,直接取成 $1e10$ 即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public int preimageSizeFZF(int k) {\n        if (k <= 1) return 5;\n        return f(k) - f(k - 1);\n    }\n    int f(int x) {\n        long l = 0, r = (long) 1e10;\n        while (l < r) {\n            long mid = l + r + 1 >> 1;\n            if (getCnt(mid) <= x) l = mid;\n            else r = mid - 1;\n        }\n        return (int)r;\n    }\n    long getCnt(long x) {\n        long ans = 0;\n        while (x != 0) {\n            ans += x / 5; x /= 5;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction preimageSizeFZF(k: number): number {\n    if (k <= 1) return 5\n    return f(k) - f(k - 1)\n};\nfunction f(x: number): number {\n    let l = 0n, r = BigInt(\"10000000000\")\n    while (l < r) {\n        const mid = l + r + 1n >> 1n\n        if (getCnt(mid) <= x) l = mid\n        else r = mid - 1n\n    }\n    return Number(r)\n}\nfunction getCnt(x: bigint): bigint {\n    let ans = 0n\n    while (x != 0n) {\n        ans += BigInt(Math.floor(Number(x / 5n))); x = BigInt(Math.floor(Number(x / 5n)))\n    }\n    return ans\n}\n```\n* 时间复杂度:$O(\\log^2{k})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.793` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/791-800/794. 有效的井字游戏（中等）.md", "url_title": "794. 有效的井字游戏", "url": "https://leetcode-cn.com/problems/valid-tic-tac-toe-state/solution/gong-shui-san-xie-fen-qing-kuang-tao-lun-pikn/", "difficulty": "中等", "tags": ["模拟"], "question": "给你一个字符串数组 `board` 表示井字游戏的棋盘。当且仅当在井字游戏过程中,棋盘有可能达到 `board` 所显示的状态时,才返回 `true` 。\n\n井字游戏的棋盘是一个 `3 x 3` 数组,由字符 `' '`,`'X'` 和 `'O'` 组成。字符 `' '` 代表一个空位。\n\n以下是井字游戏的规则:\n* 玩家轮流将字符放入空位(`' '`)中。\n* 玩家 $1$ 总是放字符 `'X'` ,而玩家 $2$ 总是放字符 `'O'` 。\n* 'X' 和 'O' 只允许放置在空位中,不允许对已放有字符的位置进行填充。\n* 当有 $3$ 个相同(且非空)的字符填充任何行、列或对角线时,游戏结束。\n* 当所有位置非空时,也算为游戏结束。\n* 如果游戏结束,玩家不允许再放置字符。\n\n示例 1:\n\n```\n输入:board = [\"O  \",\"   \",\"   \"]\n\n输出:false\n\n解释:玩家 1 总是放字符 \"X\" 。\n```\n示例 2:\n\n```\n输入:board = [\"XOX\",\" X \",\"   \"]\n\n输出:false\n\n解释:玩家应该轮流放字符。\n```\n示例 3:\n\n```\n输入:board = [\"XXX\",\"   \",\"OOO\"]\n\n输出:false\n```\n示例 4:\n\n```\n输入:board = [\"XOX\",\"O O\",\"XOX\"]\n\n输出:true\n```\n\n提示:\n* `board.length == 3`\n* `board[i].length == 3`\n* `board[i][j]` 为 `'X'`、`'O'` 或 `' '`", "solution": "### 分情况讨论\n\n给定的棋盘大小固定,对于无效情况进行分情况讨论即可:\n\n1. 由于 `X` 先手,`O` 后手,两者轮流下子。因此 `O` 的数量不会超过 `X`,且两者数量差不会超过 $1$,否则为无效局面;\n2. 若局面是 `X` 获胜,导致该局面的最后一个子必然是 `X`,此时必然有 `X` 数量大于 `O`(`X` 为先手),否则为无效局面;\n3. 若局面是 `O` 获胜,导致该局面的最后一个子必然是 `O`,此时必然有 `X` 数量等于 `O`(`X` 为先手),否则为无效局面;\n4. 局面中不可能出现两者同时赢(其中一方赢后,游戏结束)。\n\n代码:\n```Java\nclass Solution {\n    public boolean validTicTacToe(String[] board) {\n        char[][] cs = new char[3][3];\n        int x = 0, o = 0;\n        for (int i = 0; i < 3; i++) {\n            for (int j = 0; j < 3; j++) {\n                char c = board[i].charAt(j);\n                if (c == 'X') x++;\n                else if (c == 'O') o++;\n                cs[i][j] = c;\n            }\n        }\n        boolean a = check(cs, 'X'), b = check(cs, 'O');\n        if (o > x || x - o > 1) return false;\n        if (a && x <= o) return false;        \n        if (b && o != x) return false;\n        if (a && b) return false;\n        return true;\n    }\n    boolean check(char[][] cs, char c) {\n        for (int i = 0; i < 3; i++) {\n            if (cs[i][0] == c && cs[i][1] == c && cs[i][2] == c) return true;\n            if (cs[0][i] == c && cs[1][i] == c && cs[2][i] == c) return true;\n        }\n        boolean a = true, b = true;\n        for (int i = 0; i < 3; i++) {\n            for (int j = 0; j < 3; j++) {\n                if (i == j) a &= cs[i][j] == c;\n                if (i + j == 2) b &= cs[i][j] == c;\n            }\n        }\n        return a || b;\n    }\n}\n```\n* 时间复杂度:棋盘大小固定,遍历棋盘次数为常数。复杂度为 $O(C)$\n* 空间复杂度:使用了 $char$ 二维数组对 $board$ 进行转存,复杂度为 $O(C)$;全程使用 `charAt` 的话复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.794` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/791-800/795. 区间子数组个数（中等）.md", "url_title": "795. 区间子数组个数", "url": "https://leetcode.cn/problems/number-of-subarrays-with-bounded-maximum/solution/by-ac_oier-gmpt/", "difficulty": "中等", "tags": ["模拟", "单调栈"], "question": "给你一个整数数组 `nums` 和两个整数:`left` 及 `right` 。\n\n找出 `nums` 中连续、非空且其中最大元素在范围 $[left, right]$ 内的子数组,并返回满足条件的子数组的个数。\n\n生成的测试用例保证结果符合 `32-bit` 整数范围。\n\n示例 1:\n``` \n输入:nums = [2,1,4,3], left = 2, right = 3\n\n输出:3\n\n解释:满足条件的三个子数组:[2], [2, 1], [3]\n```\n示例 2:\n``` \n输入:nums = [2,9,2,5,6], left = 2, right = 8\n\n输出:7\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $0 <= nums[i] <= 10^9$\n* $0 <= left <= right <= 10^9$", "solution": "### 单调栈\n\n为了方便,我们令 $[left, right]$ 为 $[a, b]$。\n\n一个容易想到的思路是使用「单调栈」。\n\n**统计所有最大值范围在 $[a, b]$ 之间的子数组个数,可等价为统计每一个范围落在 $[a, b]$ 之间的 $nums[i]$ 作为最大值时子数组的个数。**\n\n由此可以进一步将问题转换为:求解每个 $nums[i]$ 作为子数组最大值时,最远的合法左右端点的位置。也就是求解每一个 $nums[i]$ 左右最近一个比其“大”的位置,这可以使用「单调栈」来进行求解。\n\n> 对于单调栈不了解的同学,可以看前置 🧀 : [【RMQ 专题】关于 RMQ 的若干解法](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247493262&idx=1&sn=2d8e192a5767b49b9a13a6192ab3b833)\n\n**统计所有 $nums[i]$ 对答案的贡献即是最终答案,但我们忽略了「当  `nums` 存在重复元素,且该元素作为子数组最大值时,最远左右端点的边界越过重复元素时,导致重复统计子数组」的问题。**\n\n我们不失一般性的举个 🌰 来理解(下图):\n\n为了消除这种重复统计,我们可以将「最远左右边界」的一端,从「严格小于」调整为「小于等于」,从而实现半开半闭的效果。\n\nJava 代码:\n```Java\nclass Solution {\n    public int numSubarrayBoundedMax(int[] nums, int a, int b) {\n        int n = nums.length, ans = 0;\n        int[] l = new int[n + 10], r = new int[n + 10];\n        Arrays.fill(l, -1); Arrays.fill(r, n);\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            while (!d.isEmpty() && nums[d.peekLast()] < nums[i]) r[d.pollLast()] = i;\n            d.addLast(i);\n        }\n        d.clear();\n        for (int i = n - 1; i >= 0; i--) {\n            while (!d.isEmpty() && nums[d.peekLast()] <= nums[i]) l[d.pollLast()] = i;\n            d.addLast(i);\n        }\n        for (int i = 0; i < n; i++) {\n            if (nums[i] < a || nums[i] > b) continue;\n            ans += (i - l[i]) * (r[i] - i);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int numSubarrayBoundedMax(vector<int>& nums, int a, int b) {\n        int n = nums.size(), ans = 0;\n        vector<int> l(n + 10, -1), r(n + 10, n);\n        deque<int> d;\n        for (int i = 0; i < n; i++) {\n            while (!d.empty() && nums[d.back()] < nums[i]) {\n                r[d.back()] = i;\n                d.pop_back();\n            }\n            d.push_back(i);\n        }\n        d.clear();\n        for (int i = n - 1; i >= 0; i--) {\n            while (!d.empty() && nums[d.back()] <= nums[i]) {\n                l[d.back()] = i;\n                d.pop_back();\n            }\n            d.push_back(i);\n        }\n        for (int i = 0; i < n; i++) {\n            if (nums[i] < a || nums[i] > b) continue;\n            ans += (i - l[i]) * (r[i] - i);\n        }\n        return ans;\n    }\n};\n```\nPython3 代码:\n```Python\nclass Solution:\n    def numSubarrayBoundedMax(self, nums: List[int], a: int, b: int) -> int:\n        n, ans = len(nums), 0\n        l, r = [-1] * n, [n] * n\n        stk = []\n        for i in range(n):\n            while stk and nums[stk[-1]] < nums[i]:\n                r[stk.pop()] = i\n            stk.append(i)\n        stk = []\n        for i in range(n - 1, -1, -1):\n            while stk and nums[stk[-1]] <= nums[i]:\n                l[stk.pop()] = i\n            stk.append(i)\n        for i in range(n):\n            if a <= nums[i] <= b:\n                ans += (i - l[i]) * (r[i] - i)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction numSubarrayBoundedMax(nums: number[], a: number, b: number): number {\n    let n = nums.length, ans = 0\n    const l = new Array<number>(n).fill(-1), r = new Array<number>(n).fill(n)\n    let stk = new Array<number>()\n    for (let i = 0; i < n; i++) {\n        while (stk.length > 0 && nums[stk[stk.length - 1]] < nums[i]) r[stk.pop()] = i\n        stk.push(i)\n    }\n    stk = new Array<number>()\n    for (let i = n - 1; i >= 0; i--) {\n        while (stk.length > 0 && nums[stk[stk.length - 1]] <= nums[i]) l[stk.pop()] = i\n        stk.push(i)\n    }\n    for (let i = 0; i < n; i++) {\n        if (nums[i] < a || nums[i] > b) continue\n        ans += (i - l[i]) * (r[i] - i)\n    }\n    return ans\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 模拟\n\n除了统计「每个 $nums[i]$ 作为子数组最大值时,所能贡献的子数组个数」以外,我们还可以统计「每个 $nums[i]$ 作为子数组右端点时,所能贡献的子数组个数」。\n\n具体的,我们从前往后处理每个 $nums[i]$,并统计其作为子数组右端点时,所能贡献的子数组个数。同时使用变量 `j` 和 `k` 分别记录最近一次满足「$nums[i]$ 范围落在 $[a, b]$ 之间」以及「$nums[i]$ 数值大于 $b$」的下标位置。\n\n遍历过程中根据 $nums[i]$ 与规定范围 $[a, b]$ 之间的关系进行分情况讨论:\n\n* $nums[i]$ 大于 $b$,$nums[i]$ 作为右端点,必不可能贡献合法子数组。更新 `k`;\n* $nums[i]$ 小于 $a$,此时 $nums[i]$ 想作为右端点的话,子数组必须有其他满足「范围落在 $[a, b]$ 之间」的其他数,而最近一个满足要求的位置为 $j$,若有 $j > k$,说明范围在 $(k, j]$ 均能作为子数组的左端点,累加方案数 $j - k$;若有 $j < k$,说明我们无法找到任何一个左端点,使得形成的子数组满足要求(要么最值不在 $[a, b]$ 范围内,要么有 $[a, b]$ 范围内的数,但最大值又大于 `b` 值);\n* $nums[i]$ 落在范围 $[a, b]$,此时 $nums[i]$ 想作为右端点的话,只需要找到左边第一个数值大于 $b$ 的数值即可(即变量 `k`),累加方案数 $i - k$。更新 `j`。\n\nJava 代码:\n```Java\nclass Solution {\n    public int numSubarrayBoundedMax(int[] nums, int a, int b) {\n        int n = nums.length, ans = 0;\n        for (int i = 0, j = -1, k = -1; i < n; i++) {\n            if (nums[i] > b) {\n                k = i;\n            } else {\n                if (nums[i] < a) {\n                    if (j > k) ans += j - k;\n                } else {\n                    ans += i - k;\n                    j = i;\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int numSubarrayBoundedMax(vector<int>& nums, int a, int b) {\n        int n = nums.size(), ans = 0;\n        for (int i = 0, j = -1, k = -1; i < n; i++) {\n            if (nums[i] > b) {\n                k = i;\n            } else {\n                if (nums[i] < a) {\n                    if (j > k) ans += j - k;\n                } else {\n                    ans += i - k;\n                    j = i;\n                }\n            }\n        }\n        return ans;\n    }\n};\n```\nPython3 代码:\n```Python\nclass Solution:\n    def numSubarrayBoundedMax(self, nums: List[int], a: int, b: int) -> int:\n        n, ans = len(nums), 0\n        j, k = -1, -1\n        for i in range(n):\n            if nums[i] > b:\n                k = i\n            else:\n                if nums[i] < a:\n                    ans += j - k if j > k else 0\n                else:\n                    ans += i - k\n                    j = i\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction numSubarrayBoundedMax(nums: number[], a: number, b: number): number {\n    let n = nums.length, ans = 0\n    for (let i = 0, j = -1, k = -1; i < n; i++) {\n        if (nums[i] > b) {\n            k = i\n        } else {\n            if (nums[i] < a) {\n                if (j > k) ans += j - k\n            } else {\n                ans += i - k\n                j = i\n            }\n        }\n    }\n    return ans\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.795` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/791-800/796. 旋转字符串（简单）.md", "url_title": "796. 旋转字符串", "url": "https://leetcode-cn.com/problems/rotate-string/solution/by-ac_oier-bnkx/", "difficulty": "简单", "tags": ["模拟"], "question": "给定两个字符串,`s` 和 `goal`。如果在若干次旋转操作之后,`s` 能变成 `goal`,那么返回 `true`。\n\n`s` 的旋转操作就是将 `s` 最左边的字符移动到最右边。 \n\n* 例如, 若 `s = 'abcde'`,在旋转一次之后结果就是`'bcdea'` 。\n\n示例 1:\n```\n输入: s = \"abcde\", goal = \"cdeab\"\n\n输出: true\n```\n示例 2:\n```\n输入: s = \"abcde\", goal = \"abced\"\n\n输出: false\n```\n\n提示:\n* $1 <= s.length, goal.length <= 100$\n* `s` 和 `goal` 由小写英文字母组成", "solution": "### 模拟\n\n由于每次旋转操作都是将最左侧字符移动到最右侧,因此如果 `goal` 可由 `s` 经过多步旋转而来,那么 `goal` 必然会出现在 `s + s` 中,即满足 `(s + s).contains(goal)`,同时为了 `s` 本身过长导致的结果成立,我们需要先确保两字符串长度相等。\n\n代码:\n```Java\nclass Solution {\n    public boolean rotateString(String s, String goal) {\n        return s.length() == goal.length() && (s + s).contains(goal);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 关于 `contains` 操作的复杂度说明\n\n看到不少同学对 `contains` 的复杂度写成 $O(n)$ 有疑问。\n\n在 Java 中,`contains` 实际最终是通过 `indexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset, int targetCount, int fromIndex)` 来拿到子串在原串的下标,通过判断下标是否为 $-1$ 来得知子串是否在原串出现过。\n\n我们知道一个较为普通的子串匹配算法的复杂度通为 $O(n*k)$,其中 $n$ 和 $k$ 分别是原串和子串的长度,而一些复杂度上较为优秀的算法可以做到 $O(n + k)$,例如 [KMP](https://leetcode-cn.com/problems/implement-strstr/solution/shua-chuan-lc-shuang-bai-po-su-jie-fa-km-tb86/)。\n\n从复杂度上来看 KMP 似乎要更好,但实际上对于 `indexOf` 这一高频操作而言,KMP 的预处理逻辑和空间开销都是不可接受的。\n\n因此在 OpenJDK 中的 `indexOf` 源码中,你看不到诸如 KMP 这一类「最坏情况下仍为线性复杂度」的算法实现。\n\n但是 `contains` 的复杂度真的就是 $O(n * k)$ 吗?\n\n其实并不是,这取决于 JVM 是否有针对 `indexOf` 的优化,在最为流行 HotSpot VM 中,就有对 `indexOf` 的优化。\n\n使用以下两行命令执行 `Main.java`,会得到不同的用时。\n\n```Java\n// Main.java\nimport java.util.*;\nclass Main {\n    static String ss = \"1900216589537958049456207450268985232242852754963049829410964867980510717200606495004259179775210762723370289106970649635773837906542900276476226929871813370344374628795427969854262816333971458418647697497933767559786473164055741512717436542961770628985635269208255141092673831132865\";\n    static String pp = \"830411595466023844647269831101019568881117264597716557501027220546437084223034983361631430958163646150071031688420479928498493050624766427709034028819288384316713084883575266906600102801186671777455503932259958027055697399984336592981698127456301551509241\";\n    static int cnt = (int) 1e8;\n    static public void main(String[] args) {\n        long start = System.currentTimeMillis();\n        while (cnt-- > 0) ss.contains(pp);\n        System.out.println(System.currentTimeMillis() - start);\n    }\n}\n```\n\n环境说明:\n```Shell\n➜  java -version\njava version \"1.8.0_131\"\nJava(TM) SE Runtime Environment (build 1.8.0_131-b11)\nJava HotSpot(TM) 64-Bit Server VM (build 25.131-b11, mixed mode)\n```\n\n先执行 `javac Main.java` 进行编译后:\n\n1. 使用原始的 `indexOf` 实现进行匹配(执行多次,平均耗时为基准值 $X$):\n```\njava -XX:+UnlockDiagnosticVMOptions -XX:DisableIntrinsic=_indexOf Main\n```\n2. 使用 HotSpot VM 优化的 `indexOf` 进行匹配(执行多次,平均耗时为基准值 $X$ 的 $[0.55, 0.65]$ 之间):\n```\njava Main\n```\n\n因此实际运行的 `contains` 操作的复杂度为多少并不好确定,但可以确定是要优于 $O(n * k)$ 的。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.796` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/791-800/797. 所有可能的路径（中等）.md", "url_title": "797. 所有可能的路径", "url": "https://leetcode-cn.com/problems/all-paths-from-source-to-target/solution/gong-shui-san-xie-yun-yong-dfs-bao-sou-s-xlz9/", "difficulty": "中等", "tags": ["回溯算法", "DFS"], "question": "给你一个有 n 个节点的 有向无环图(DAG),请你找出所有从节点 0 到节点 n-1 的路径并输出(不要求按特定顺序)\n\n二维数组的第 i 个数组中的单元都表示有向图中 i 号节点所能到达的下一些节点,空就是没有下一个结点了。\n\n译者注:有向图是有方向的,即规定了 a→b 你就不能从 b→a 。\n\n示例 1:\n\n```\n输入:graph = [[1,2],[3],[3],[]]\n\n输出:[[0,1,3],[0,2,3]]\n\n解释:有两条路径 0 -> 1 -> 3 和 0 -> 2 -> 3\n```\n示例 2:\n\n```\n输入:graph = [[4,3,1],[3,2,4],[3],[4],[]]\n\n输出:[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]\n```\n示例 3:\n```\n输入:graph = [[1],[]]\n\n输出:[[0,1]]\n```\n示例 4:\n```\n输入:graph = [[1,2,3],[2],[3],[]]\n\n输出:[[0,1,2,3],[0,2,3],[0,3]]\n```\n示例 5:\n```\n输入:graph = [[1,3],[2],[3],[]]\n\n输出:[[0,1,2,3],[0,3]]\n```\n\n提示:\n* n == graph.length\n* 2 <= n <= 15\n* 0 <= graph[i][j] < n\n* graph[i][j] != i(即,不存在自环)\n* graph[i] 中的所有元素 互不相同\n* 保证输入为 有向无环图(DAG)", "solution": "### DFS \n\n$n$ 只有 $15$,且要求输出所有方案,因此最直观的解决方案是使用 `DFS` 进行爆搜。\n\n起始将 $0$ 进行加入当前答案,当 $n - 1$ 被添加到当前答案时,说明找到了一条从 $0$ 到 $n - 1$ 的路径,将当前答案加入结果集。\n\n当我们决策到第 $x$ 位(非零)时,该位置所能放入的数值由第 $x - 1$ 位已经填入的数所决定,同时由于给定的 $graph$ 为有向无环图(拓扑图),因此按照第 $x - 1$ 位置的值去决策第 $x$ 位的内容,必然不会决策到已经在当前答案的数值,否则会与 $graph$ 为有向无环图(拓扑图)的先决条件冲突。\n\n换句话说,与一般的爆搜不同的是,我们不再需要 $vis$ 数组来记录某个点是否已经在当前答案中。\n\n代码:\n```Java\nclass Solution {\n    int[][] g;\n    int n;\n    List<List<Integer>> ans = new ArrayList<>();\n    List<Integer> cur = new ArrayList<>();\n    public List<List<Integer>> allPathsSourceTarget(int[][] graph) {\n        g = graph; \n        n = g.length;\n        cur.add(0);\n        dfs(0);\n        return ans;\n    }\n    void dfs(int u) {\n        if (u == n - 1) {\n            ans.add(new ArrayList<>(cur));\n            return ;\n        }\n        for (int next : g[u]) {\n            cur.add(next);\n            dfs(next);\n            cur.remove(cur.size() - 1);\n        }\n    }\n}\n```\n* 时间复杂度:共有 $n$ 个节点,每个节点有选和不选两种决策,总的方案数最多为 $2^n$,对于每个方案最坏情况需要 $O(n)$ 的复杂度进行拷贝并添加到结果集。整体复杂度为 $O(n * 2^n)$\n* 空间复杂度:最多有 $2^n$ 种方案,每个方案最多有 $n$ 个元素。整体复杂度为 $O(n * 2^n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.797` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/791-800/798. 得分最高的最小轮调（困难）.md", "url_title": "798. 得分最高的最小轮调", "url": "https://leetcode-cn.com/problems/smallest-rotation-with-highest-score/solution/gong-shui-san-xie-shang-xia-jie-fen-xi-c-p6kh/", "difficulty": "困难", "tags": ["区间求和问题", "差分"], "question": "给你一个数组 $nums$,我们可以将它按一个非负整数 $k$ 进行轮调,这样可以使数组变为 $[nums[k], nums[k + 1], ... nums[nums.length - 1], nums[0], nums[1], ..., nums[k-1]]$ 的形式。此后,任何值小于或等于其索引的项都可以记作一分。\n\n例如,数组为 $nums = [2,4,1,3,0]$,我们按 $k = 2$ 进行轮调后,它将变成 $[1,3,0,2,4]$。这将记为 $3$ 分,因为 $1 > 0$  [不计分]、$3 > 1$ [不计分]、$0 <= 2$ [计 $1$ 分]、$2 <= 3$ [计 $1$ 分],$4 <= 4$ [计 $1$ 分]。\n在所有可能的轮调中,返回我们所能得到的最高分数对应的轮调下标 $k$ 。如果有多个答案,返回满足条件的最小的下标 $k$ 。\n\n示例 1:\n```\n输入:nums = [2,3,1,4,0]\n\n输出:3\n\n解释:\n下面列出了每个 k 的得分:\nk = 0,  nums = [2,3,1,4,0],    score 2\nk = 1,  nums = [3,1,4,0,2],    score 3\nk = 2,  nums = [1,4,0,2,3],    score 3\nk = 3,  nums = [4,0,2,3,1],    score 4\nk = 4,  nums = [0,2,3,1,4],    score 3\n所以我们应当选择 k = 3,得分最高。\n```\n示例 2:\n```\n输入:nums = [1,3,0,2,4]\n\n输出:0\n\n解释:\nnums 无论怎么变化总是有 3 分。\n所以我们将选择最小的 k,即 0。\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $0 <= nums[i] < nums.length$", "solution": "### 上下界分析 + 差分应用\n\n为了方便,令 $n$ 为 $nums$ 长度(中文的数据范围是错的,数组长度应该是 $10^5$,不是 $20000$)。\n\n对于给定的 $nums$ 而言,有效的轮调范围为 $[0, n - 1]$,即对于任意 $nums[i]$ 而言,可取的下标共有 $n$ 种。\n\n假定当前下标为 $i$,轮调次数为 $k$,那么轮调后下标为 $i - k$,当新下标为负数时,相当于 $nums[i]$ 出现在比原数组更“靠后”的位置,此时下标等价于 $(i - k + n) \\mod n$。\n\n考虑什么情况下 $nums[i]$ 能够得分?\n\n首先新下标的取值范围为 $[0, n - 1]$,即有 $0 \\leqslant i - k \\leqslant n - 1$ 。由此可分析出 $k$ 的取值范围为:\n\n$$\n0 \\leqslant i - k \\Leftrightarrow k \\leqslant i\n$$\n\n$$\ni - k \\leqslant n - 1 \\Leftrightarrow i - (n - 1) \\leqslant k\n$$\n\n即由新下标取值范围可知 $k$ 的上下界分别为 $i$ 和 $i - (n - 1)$。\n\n同时为了满足得分定义,还有 $nums[i] \\leqslant i - k$,进行变形可得:\n\n$$\nnums[i] \\leqslant i - k \\Leftrightarrow k \\leqslant i - nums[i]\n$$\n\n此时我们有两个关于 $k$ 的上界 $k \\leqslant i$ 和 $k \\leqslant i - nums[i]$,由于 $nums[i]$ 取值范围为 $[0, n)$,则有 $i - nums[i] \\leqslant i$,由于必须同时满足「合法移动(有效下标)」和「能够得分」,我们仅考虑范围更小(更严格)由 $nums[i] \\leqslant i - k$ 推导而来的上界 $k \\leqslant i - nums[i]$ 即可。\n\n综上,$nums[i]$ 能够得分的 $k$ 的取值范围为 $[i - (n - 1), i - nums[i]]$。\n\n最后考虑 $[i - (n - 1), i - nums[i]]$(均进行加 $n$ 模 $n$ 转为正数)什么情况下为合法的连续段:\n\n* 当 $i - (n - 1) \\leqslant i - nums[i]$ 时,$[i - (n - 1), i - nums[i]]$ 为合法连续段;\n* 当 $i - (n - 1) > i - nums[i]$ 时,根据负数下标等价于 $(i - k + n) \\mod n$,此时 $[i - (n - 1), i - nums[i]]$ 等价于 $[0, i - nums[i]]$ 和 $[i - (n - 1), n - 1]$ 两段。\n\n至此,我们分析出原数组的每个 $nums[i]$ 能够得分的 $k$ 的取值范围,假定取值范围为 $[l, r]$,我们可以对 $[l, r]$ 进行 $+1$ 标记,代表范围为 $k$ 能够得 $1$ 分,当处理完所有的 $nums[i]$ 后,找到标记次数最多的位置 $k$ 即是答案。\n\n标记操作可使用「差分」实现(不了解差分的同学,可以先看前置🧀:[差分入门模板题](https%3A//mp.weixin.qq.com/s?__biz%3DMzU4NDE3MTEyMA%3D%3D%26mid%3D2247490329%26idx%3D1%26sn%3D6d448a53cd722bbd990fda82bd262857%26chksm%3Dfd9cb006caeb3910758522054564348b7eb4bde333889300bd5d249950be12a5b990b5d2c059%26token%3D168273153%26lang%3Dzh_CN%23rd),里面讲解了差分的两个核心操作「区间修改」&「单点查询」),而找标记次数最多的位置可对差分数组求前缀和再进行遍历即可。\n\n代码:\n```Java\nclass Solution {\n    static int N = 100010;\n    static int[] c = new int[N];\n    void add(int l, int r) {\n        c[l] += 1; c[r + 1] -= 1;\n    }\n    public int bestRotation(int[] nums) {\n        Arrays.fill(c, 0);\n        int n = nums.length;\n        for (int i = 0; i < n; i++) {\n            int a = (i - (n - 1) + n) % n, b = (i - nums[i] + n) % n;\n            if (a <= b) {\n                add(a, b);\n            } else {\n                add(0, b);\n                add(a, n - 1);\n            }\n        }\n        for (int i = 1; i <= n; i++) c[i] += c[i - 1];\n        int ans = 0, k = c[0];\n        for (int i = 1; i <= n; i++) {\n            if (c[i] > k) {\n                k = c[i]; ans = i;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.798` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/791-800/799. 香槟塔（中等）.md", "url_title": "799. 香槟塔", "url": "https://leetcode.cn/problems/champagne-tower/solution/by-ac_oier-c8jn/", "difficulty": "中等", "tags": ["动态规划", "线性 DP"], "question": "我们把玻璃杯摆成金字塔的形状,其中 第一层 有 `1` 个玻璃杯, 第二层 有 `2` 个,依次类推到第 `100` 层,每个玻璃杯 (`250ml`) 将盛有香槟。\n\n从顶层的第一个玻璃杯开始倾倒一些香槟,当顶层的杯子满了,任何溢出的香槟都会立刻等流量的流向左右两侧的玻璃杯。当左右两边的杯子也满了,就会等流量的流向它们左右两边的杯子,依次类推。(当最底层的玻璃杯满了,香槟会流到地板上)\n\n例如,在倾倒一杯香槟后,最顶层的玻璃杯满了。倾倒了两杯香槟后,第二层的两个玻璃杯各自盛放一半的香槟。在倒三杯香槟后,第二层的香槟满了 - 此时总共有三个满的玻璃杯。在倒第四杯后,第三层中间的玻璃杯盛放了一半的香槟,他两边的玻璃杯各自盛放了四分之一的香槟,如下图所示。\n\n现在当倾倒了非负整数杯香槟后,返回第 i 行 j 个玻璃杯所盛放的香槟占玻璃杯容积的比例( i 和 j 都从0开始)。\n\n示例 1:\n```\n输入: poured(倾倒香槟总杯数) = 1, query_glass(杯子的位置数) = 1, query_row(行数) = 1\n\n输出: 0.00000\n\n解释: 我们在顶层(下标是(0,0))倒了一杯香槟后,没有溢出,因此所有在顶层以下的玻璃杯都是空的。\n```\n示例 2:\n```\n输入: poured(倾倒香槟总杯数) = 2, query_glass(杯子的位置数) = 1, query_row(行数) = 1\n\n输出: 0.50000\n\n解释: 我们在顶层(下标是(0,0)倒了两杯香槟后,有一杯量的香槟将从顶层溢出,位于(1,0)的玻璃杯和(1,1)的玻璃杯平分了这一杯香槟,所以每个玻璃杯有一半的香槟。\n```\n示例 3:\n```\n输入: poured = 100000009, query_row = 33, query_glass = 17\n\n输出: 1.00000\n```\n\n提示:\n* $0 <= poured <= 10^9$\n* $0 <= query_glass <= query_row < 100$", "solution": "### 线性 DP\n\n为了方便,我们令 `poured` 为 `k`,`query_row` 和 `query_glass` 分别为 $n$ 和 $m$。\n\n定义 $f[i][j]$ 为第 $i$ 行第 $j$ 列杯子所经过的水的流量(而不是最终剩余的水量)。\n\n起始我们有 $f[0][0] = k$,最终答案为 $\\min(f[n][m], 1)$。\n\n不失一般性考虑 $f[i][j]$ 能够更新哪些状态:显然当 $f[i][j]$ 不足 $1$ 的时候,不会有水从杯子里溢出,即 $f[i][j]$ 将不能更新其他状态;当 $f[i][j]$ 大于 $1$ 时,将会有 $f[i][j] - 1$ 的水会等量留到下一行的杯子里,所流向的杯子分别是「第 $i + 1$ 行第 $j$ 列的杯子」和「第 $i + 1$ 行第 $j + 1$ 列的杯子」,增加流量均为 $\\frac{f[i][j] - 1}{2}$,即有 $f[i + 1][j] += \\frac{f[i][j] - 1}{2}$ 和 $f[i + 1][j + 1] += \\frac{f[i][j] - 1}{2}$。\n\nJava 代码:\n```Java\nclass Solution {\n    public double champagneTower(int k, int n, int m) {\n        double[][] f = new double[n + 10][n + 10];\n        f[0][0] = k;\n        for (int i = 0; i <= n; i++) {\n            for (int j = 0; j <= i; j++) {\n                if (f[i][j] <= 1) continue;\n                f[i + 1][j] += (f[i][j] - 1) / 2;\n                f[i + 1][j + 1] += (f[i][j] - 1) / 2;\n            }\n        }\n        return Math.min(f[n][m], 1);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    double champagneTower(int k, int n, int m) {\n        vector<vector<double>> f(n + 10, vector<double>(n + 10, 0.0));\n        f[0][0] = k;\n        for (int i = 0; i <= n; ++i) {\n            for (int j = 0; j <= i; ++j) {\n                if (f[i][j] <= 1) continue;\n                f[i + 1][j] += (f[i][j] - 1.0) / 2.0;\n                f[i + 1][j + 1] += (f[i][j] - 1.0) / 2.0;\n            }\n        }\n        return min(f[n][m], 1.0);\n    }\n};\n```\nPython3 代码:\n```Python\nclass Solution:\n    def champagneTower(self, k: int, n: int, m: int) -> float:\n        f = [[0] * (n + 10) for _ in range(n + 10)]\n        f[0][0] = k\n        for i in range(n + 1):\n            for j in range(i + 1):\n                if f[i][j] <= 1:\n                    continue\n                f[i + 1][j] += (f[i][j] - 1) / 2\n                f[i + 1][j + 1] += (f[i][j] - 1) / 2\n        return min(f[n][m], 1)\n```\nTypeScript 代码:\n```TypeScript\nfunction champagneTower(k: number, n: number, m: number): number {\n    const f = new Array<Array<number>>()\n    for (let i = 0; i < n + 10; i++) f.push(new Array<number>(n + 10).fill(0))\n    f[0][0] = k\n    for (let i = 0; i <= n; i++) {\n        for (let j = 0; j <= i; j++) {\n            if (f[i][j] <= 1) continue\n            f[i + 1][j] += (f[i][j] - 1) / 2\n            f[i + 1][j + 1] += (f[i][j] - 1) / 2\n        }\n    }\n    return Math.min(f[n][m], 1)\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.799` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/801-810/801. 使序列递增的最小交换次数（困难）.md", "url_title": "801. 使序列递增的最小交换次数", "url": "https://leetcode.cn/problems/minimum-swaps-to-make-sequences-increasing/solution/by-ac_oier-fjhp/", "difficulty": "困难", "tags": ["状态机 DP", "动态规划"], "question": "我们有两个长度相等且不为空的整型数组 `nums1` 和 `nums2`。\n\n在一次操作中,我们可以交换 $nums1[i]$ 和 $nums2[i]$ 的元素。\n\n例如,如果 $nums1 = [1,2,3,8]$ ,$nums2 =[5,6,7,4]$ ,你可以交换 $i = 3$ 处的元素,得到 $nums1 =[1,2,3,4]$ 和 $nums2 =[5,6,7,8]$ 。\n\n返回 使 `nums1` 和 `nums2` 严格递增 所需操作的最小次数 。\n\n数组 `arr` 严格递增 且  $arr[0] < arr[1] < arr[2] < ... < arr[arr.length - 1]$ 。\n\n注意:\n\n用例保证可以实现操作。\n\n示例 1:\n```\n输入: nums1 = [1,3,5,4], nums2 = [1,2,3,7]\n\n输出: 1\n\n解释: \n交换 A[3] 和 B[3] 后,两个数组如下:\nA = [1, 3, 5, 7] , B = [1, 2, 3, 4]\n两个数组均为严格递增的。\n```\n示例 2:\n```\n输入: nums1 = [0,3,5,8,9], nums2 = [2,1,4,6,9]\n\n输出: 1\n```\n\n提示:\n* $2 <= nums1.length <= 10^5$\n* $nums2.length = nums1.length$\n* $0 <= nums1[i], nums2[i] <= 2 \\times 10^5$", "solution": "### 基本分析\n\n这是一道很裸的状态机 DP 运用题。\n\n由于每次交换只会发生在两数组的相同位置上,使得问题变得简单:**仅需考虑交换当前位置后,当前元素与前后元素大小关系变化即可**。\n\n又因为我们会从前往后处理每个位置,因此只需要考虑当前位置与前一位置的大小关系即可。\n\n---\n\n### 状态机 DP\n\n定义 $f[i][j]$ 为考虑下标范围为 $[0, i]$ 的元素,且位置 $i$ 的交换状态为 $j$ 时(其中 $j = 0$ 为不交换,$j = 1$ 为交换)两数组满足严格递增的最小交换次数。\n\n最终答案为 $\\min(f[n - 1][0], f[n - 1][1])$,同时我们有显而易见的初始化条件 $f[0][0] = 0$ 和 $f[0][1] = 1$,其余未知状态初始化为正无穷。\n\n不失一般性考虑 $f[i][j]$ 该如何转移:\n\n* 若 $nums1[i] > nums1[i - 1]$ 且 $nums2[i] > nums2[i - 1]$(即顺序位满足要求),此时要么当前位置 $i$ 和前一位置 $i - 1$ 都不交换,要么同时发生交换,此时有(分别对应两个位置「都不交换」和「都交换」):\n\n$$\n\\begin{cases}\nf[i][0] = f[i - 1][0] \\\\\nf[i][1] = f[i - 1][1] + 1\n\\end{cases}\n$$\n\n* 若 $nums1[i] > nums2[i - 1]$ 且 $nums2[i] > nums1[i - 1]$(即交叉位满足要求),此时当前位置 $i$ 和前一位置 $i - 1$ 只能有其一发生交换,此时有(分别对应「前一位置交换」和「当前位置交换」):\n\n$$\n\\begin{cases}\nf[i][0] = \\min(f[i][0], f[i - 1][1]); \\\\\nf[i][1] = \\min(f[i][1], f[i - 1][0] + 1)\n\\end{cases}\n$$\n\nJava 代码:\n```Java\nclass Solution {\n    public int minSwap(int[] nums1, int[] nums2) {\n        int n = nums1.length;\n        int[][] f = new int[n][2];\n        for (int i = 1; i < n; i++) f[i][0] = f[i][1] = n + 10;\n        f[0][1] = 1;\n        for (int i = 1; i < n; i++) {\n            if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {\n                f[i][0] = f[i - 1][0];\n                f[i][1] = f[i - 1][1] + 1;\n            }\n            if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {\n                f[i][0] = Math.min(f[i][0], f[i - 1][1]);\n                f[i][1] = Math.min(f[i][1], f[i - 1][0] + 1);\n            }\n        }\n        return Math.min(f[n - 1][0], f[n - 1][1]);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int minSwap(vector<int>& nums1, vector<int>& nums2) {\n        int n = nums1.size();\n        vector<vector<int>> f(n, vector<int>(2, n + 10));\n        f[0][0] = 0; f[0][1] = 1;\n        for (int i = 1; i < n; ++i) {\n            if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {\n                f[i][0] = f[i - 1][0];\n                f[i][1] = f[i - 1][1] + 1;\n            }\n            if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {\n                f[i][0] = min(f[i][0], f[i - 1][1]);\n                f[i][1] = min(f[i][1], f[i - 1][0] + 1);\n            }\n        }\n        return min(f[n - 1][0], f[n - 1][1]);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minSwap(self, nums1: List[int], nums2: List[int]) -> int:\n        n = len(nums1)\n        f = [[0, 0] for _ in range(n)]\n        for i in range(1, n):\n            f[i][0] = f[i][1] = n + 10\n        f[0][1] = 1\n        for i in range(1, n):\n            if nums1[i] > nums1[i - 1] and nums2[i] > nums2[i - 1]:\n                f[i][0], f[i][1] = f[i - 1][0], f[i - 1][1] + 1\n            if nums1[i] > nums2[i - 1] and nums2[i] > nums1[i - 1]:\n                f[i][0], f[i][1] = min(f[i][0], f[i - 1][1]), min(f[i][1], f[i - 1][0] + 1)\n        return min(f[n - 1][0], f[n - 1][1])\n```\nTypeScript 代码:\n```TypeScript\nfunction minSwap(nums1: number[], nums2: number[]): number {\n    const n = nums1.length\n    const f = new Array<Array<number>>(n)\n    f[0] = [0, 1]\n    for (let i = 1; i < n; i++) f[i] = [n + 10, n + 10]\n    for (let i = 1; i < n; i++) {\n        if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {\n            f[i][0] = f[i - 1][0]\n            f[i][1] = f[i - 1][1] + 1\n        }\n        if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {\n            f[i][0] = Math.min(f[i][0], f[i - 1][1])\n            f[i][1] = Math.min(f[i][1], f[i - 1][0] + 1)\n        }\n    }\n    return Math.min(f[n - 1][0], f[n - 1][1])\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 滚动数组\n\n利用 $f[i][X]$ 仅依赖于 $f[i - 1][X]$,我们可以采用「滚动数组」的方式,通过机械性操作将空间优化到 $O(1)$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int minSwap(int[] nums1, int[] nums2) {\n        int n = nums1.length;\n        int[][] f = new int[2][2];\n        f[0][1] = 1;\n        for (int i = 1; i < n; i++) {\n            int a = n + 10, b = n + 10;\n            int prev = (i - 1) & 1, cur = i & 1; // 避免重复的 & 操作\n            if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {\n                a = f[prev][0];\n                b = f[prev][1] + 1;\n            }\n            if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {\n                a = Math.min(a, f[prev][1]);\n                b = Math.min(b, f[prev][0] + 1);\n            }\n            f[cur][0] = a; f[cur][1] = b;\n        }\n        return Math.min(f[(n - 1) & 1][0], f[(n - 1) & 1][1]);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int minSwap(vector<int>& nums1, vector<int>& nums2) {\n        int n = nums1.size();\n        vector<vector<int>> f(2, vector<int>(2, 0));\n        f[0][1] = 1;\n        for (int i = 1; i < n; ++i) {\n            int a = n + 10, b = n + 10;\n            int prev = (i - 1) & 1, cur = i & 1;\n            if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {\n                a = f[prev][0];\n                b = f[prev][1] + 1;\n            }\n            if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {\n                a = min(a, f[prev][1]);\n                b = min(b, f[prev][0] + 1);\n            }\n            f[cur][0] = a;\n            f[cur][1] = b;\n        }\n        return min(f[(n - 1) & 1][0], f[(n - 1) & 1][1]);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minSwap(self, nums1: List[int], nums2: List[int]) -> int:\n        n = len(nums1)\n        f = [[0, 1], [0, 0]]\n        for i in range(1, n):\n            a, b = n + 10, n + 10\n            prev, cur = (i - 1) & 1, i & 1\n            if nums1[i] > nums1[i - 1] and nums2[i] > nums2[i - 1]:\n                a, b = f[prev][0], f[prev][1] + 1\n            if nums1[i] > nums2[i - 1] and nums2[i] > nums1[i - 1]:\n                a, b = min(a, f[prev][1]), min(b, f[prev][0] + 1)\n            f[cur][0], f[cur][1] = a, b\n        return min(f[(n - 1) & 1][0], f[(n - 1) & 1][1])\n```\nTypeScript 代码:\n```TypeScript\nfunction minSwap(nums1: number[], nums2: number[]): number {\n    const n = nums1.length\n    const f = new Array<Array<number>>(2)\n    f[0] = [0, 1], f[1] = [0, 0]\n    for (let i = 1; i < n; i++) {\n        let a = n + 10, b = n + 10\n        const prev = (i - 1) & 1, cur = i & 1\n        if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {\n            a = f[prev][0]\n            b = f[prev][1] + 1\n        }\n        if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {\n            a = Math.min(a, f[prev][1])\n            b = Math.min(b, f[prev][0] + 1)\n        }\n        f[cur][0] = a; f[cur][1] = b\n    }\n    return Math.min(f[(n - 1) & 1][0], f[(n - 1) & 1][1])\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.801` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/801-810/802. 找到最终的安全状态（中等）.md", "url_title": "802. 找到最终的安全状态", "url": "https://leetcode-cn.com/problems/find-eventual-safe-states/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-isy6u/", "difficulty": "中等", "tags": ["图", "拓扑排序"], "question": "在有向图中,以某个节点为起始节点,从该点出发,每一步沿着图中的一条有向边行走。如果到达的节点是终点(即它没有连出的有向边),则停止。\n\n对于一个起始节点,如果从该节点出发,无论每一步选择沿哪条有向边行走,最后必然在有限步内到达终点,则将该起始节点称作是 安全 的。\n\n返回一个由图中所有安全的起始节点组成的数组作为答案。答案数组中的元素应当按 升序 排列。\n\n该有向图有 n 个节点,按 0 到 n - 1 编号,其中 n 是 graph 的节点数。图以下述形式给出:graph[i] 是编号 j 节点的一个列表,满足 (i, j) 是图的一条有向边。 \n\n示例 1:\n\n```\n输入:graph = [[1,2],[2,3],[5],[0],[5],[],[]]\n\n输出:[2,4,5,6]\n\n解释:示意图如上。\n```\n示例 2:\n```\n输入:graph = [[1,2,3,4],[1,2],[3,4],[0,4],[]]\n\n输出:[4]\n```\n\n提示:\n* n == graph.length\n* 1 <= n <= $10^4$\n* 0 <= graph[i].length <= n\n* graph[i] 按严格递增顺序排列。\n* 图中可能包含自环。\n* 图中边的数目在范围 [1, 4 * $10^4$] 内。", "solution": "### 基本分析 & 拓扑排序\n\n为了方便,我们令点数为 $n$,边数为 $m$。\n\n**在图论中,一个有向无环图必然存在至少一个拓扑序与之对应,反之亦然。**\n\n如果对拓扑排序不熟悉的小伙伴,可以看看 [拓扑排序](https://baike.baidu.com/item/%E6%8B%93%E6%89%91%E6%8E%92%E5%BA%8F)。\n\n**简单来说,就是将图中的所有节点展开成一维序列,对于序列中任意的节点 $(u, v)$,如果在序列中 $u$ 在 $v$ 的前面,则说明在图中存在从 $u$ 出发达到 $v$ 的通路,即 $u$ 排在 $v$ 的前面。反之亦然。**\n\n同时,我们需要知晓「入度」和「出度」的概念:\n\n* 入度:有多少条边直接指向该节点;\n* 出度:由该节点指出边的有多少条。\n\n因此,对于有向图的拓扑排序,我们可以使用如下思路输出拓扑序(`BFS` 方式):\n\n1. 起始时,将所有入度为 $0$ 的节点进行入队(入度为 $0$,说明没有边指向这些节点,将它们放到拓扑排序的首部,不会违反拓扑序定义);\n2. **从队列中进行节点出队操作,出队序列就是对应我们输出的拓扑序**。\n    对于当前弹出的节点 $x$,遍历 $x$ 的所有出度,即遍历所有由 $x$ 直接指向的节点 $y$,对 $y$ 做入度减一操作(因为 $x$ 节点已经从队列中弹出,被添加到拓扑序中,等价于从 $x$ 节点从有向图中被移除,相应的由 $x$ 发出的边也应当被删除,带来的影响是与 $x$ 相连的节点 $y$ 的入度减一);\n3. 对 $y$ 进行入度减一之后,检查 $y$ 的入度是否为 $0$,如果为 $0$ 则将 $y$ 入队(当 $y$ 的入度为 $0$,说明有向图中在 $y$ 前面的所有的节点均被添加到拓扑序中,此时 $y$ 可以作为拓扑序的某个片段的首部被添加,而不是违反拓扑序的定义);\n3. 循环流程 $2$、$3$ 直到队列为空。\n\n---\n\n### 证明\n\n上述 `BFS` 方法能够求得「某个有向无环图的拓扑序」的前提是:**我们必然能够找到(至少)一个「入度为 $0$ 的点」,在起始时将其入队。**\n\n这可以使用反证法进行证明:假设有向无环图的拓扑序不存在入度为 $0$ 的点。\n\n**那么从图中的任意节点 $x$ 进行出发,沿着边进行反向检索,由于不存在入度为 $0$ 的节点,因此每个点都能够找到上一个节点。**\n\n**当我们找到一条长度为 $n + 1$ 的反向路径时,由于我们图中只有 $n$ 个节点,因此必然有至少一个节点在该路径中重复出现,即该反向路径中存在环,与我们「有向无环图」的起始条件冲突。**\n\n得证「有向无环图的拓扑序」必然存在(至少)一个「入度为 $0$ 的点」。\n\n即按照上述的 `BFS` 方法,我们能够按照流程迭代下去,直到将有向无环图的所有节点从队列中弹出。\n\n反之,如果一个图不是「有向无环图」的话,我们是无法将所有节点入队的,因此能够通过入队节点数量是否为 $n$ 来判断是否为有向无环图。\n\n---\n\n### 反向图 + 拓扑排序\n\n回到本题,根据题目对「安全节点」的定义,我们知道如果一个节点无法进入「环」的话则是安全的,否则是不安全的。\n\n另外我们发现,**如果想要判断某个节点数 $x$ 是否安全,起始时将 $x$ 进行入队,并跑一遍拓扑排序是不足够的。**\n\n因为我们无法事先确保 $x$ 满足入度为 $0$ 的要求,所以当我们处理到与 $x$ 相连的节点 $y$ 时,可能会存在 $y$ 节点入度无法减到 $0$ 的情况,即我们无法输出真实拓扑序中,从 $x$ 节点开始到结尾的完整部分。\n\n但是根据我们「证明」部分的启发,我们可以将所有边进行反向,这时候「入度」和「出度」翻转了。\n\n对于那些反向图中「入度」为 $0$ 的点集 $x$,其实就是原图中「出度」为 $0$ 的节点,它们「出度」为 $0$,根本没指向任何节点,必然无法进入环,是安全的;同时由它们在反向图中指向的节点(在原图中**只指向**它们的节点),必然也是无法进入环的,对应到反向图中,就是那些减去 $x$ 对应的入度之后,入度为 $0$ 的节点。\n\n因此整个过程就是将图进行反向,再跑一遍拓扑排序,如果某个节点出现在拓扑序列,说明其进入过队列,说明其入度为 $0$,其是安全的,其余节点则是在环内非安全节点。\n\n> 另外,这里的存图方式还是使用前几天一直使用的「链式前向星」,关于几个数组的定义以及其他的存图方式,如果还是有不熟悉的小伙伴可以在 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488007&idx=1&sn=9d0dcfdf475168d26a5a4bd6fcd3505d&chksm=fd9cb918caeb300e1c8844583db5c5318a89e60d8d552747ff8c2256910d32acd9013c93058f&token=1711035050&lang=zh_CN#rd) 查阅,本次不再赘述。\n\n代码:\n```Java\nclass Solution {\n    int N = (int)1e4+10, M = 4 * N;\n    int idx;\n    int[] he = new int[N], e = new int[M], ne = new int[M];\n    int[] cnts = new int[N];\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    public List<Integer> eventualSafeNodes(int[][] g) {\n        int n = g.length;\n        // 存反向图,并统计入度\n        Arrays.fill(he, -1);\n        for (int i = 0; i < n; i++) {\n            for (int j : g[i]) {\n                add(j, i);\n                cnts[i]++;\n            }\n        }\n        // BFS 求反向图拓扑排序\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            if (cnts[i] == 0) d.addLast(i);\n        }\n        while (!d.isEmpty()) {\n            int poll = d.pollFirst();\n            for (int i = he[poll]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (--cnts[j] == 0) d.addLast(j);\n            }\n        }\n        // 遍历答案:如果某个节点出现在拓扑序列,说明其进入过队列,说明其入度为 0\n        List<Integer> ans = new ArrayList<>();\n        for (int i = 0; i < n; i++) {\n            if (cnts[i] == 0) ans.add(i);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.802` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/801-810/804. 唯一摩尔斯密码词（简单）.md", "url_title": "804. 唯一摩尔斯密码词", "url": "https://leetcode-cn.com/problems/unique-morse-code-words/solution/by-ac_oier-a9hv/", "difficulty": "简单", "tags": ["模拟"], "question": "国际摩尔斯密码定义一种标准编码方式,将每个字母对应于一个由一系列点和短线组成的字符串, 比如:\n\n* `'a'` 对应 `\".-\"` ,\n* `'b'` 对应 `\"-...\"` ,\n* `'c'` 对应 `\"-.-.\"`,以此类推。\n\n为了方便,所有 $26$ 个英文字母的摩尔斯密码表如下:\n```\n[\".-\",\"-...\",\"-.-.\",\"-..\",\".\",\"..-.\",\"--.\",\"....\",\"..\",\".---\",\"-.-\",\".-..\",\"--\",\"-.\",\"---\",\".--.\",\"--.-\",\".-.\",\"...\",\"-\",\"..-\",\"...-\",\".--\",\"-..-\",\"-.--\",\"--..\"]\n```\n给你一个字符串数组 `words`,每个单词可以写成每个字母对应摩尔斯密码的组合。\n\n例如,`\"cab\"` 可以写成 `\"-.-..--...\"` ,(即 `\"-.-.\"` + `\".-\"` + `\"-...\"` 字符串的结合)。我们将这样一个连接过程称作单词翻译。\n\n对 `words` 中所有单词进行单词翻译,返回不同单词翻译的数量。\n\n示例 1:\n```\n输入: words = [\"gin\", \"zen\", \"gig\", \"msg\"]\n\n输出: 2\n\n解释: \n各单词翻译如下:\n\"gin\" -> \"--...-.\"\n\"zen\" -> \"--...-.\"\n\"gig\" -> \"--...--.\"\n\"msg\" -> \"--...--.\"\n\n共有 2 种不同翻译, \"--...-.\" 和 \"--...--.\".\n```\n示例 2:\n```\n输入:words = [\"a\"]\n\n输出:1\n```\n\n提示:\n* $1 <= words.length <= 100$\n* $1 <= words[i].length <= 12$\n* $words[i]$ 由小写英文字母组成", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n代码:\n```Java\nclass Solution {\n    String[] ss = new String[]{\".-\",\"-...\",\"-.-.\",\"-..\",\".\",\"..-.\",\"--.\",\"....\",\"..\",\".---\",\"-.-\",\".-..\",\"--\",\"-.\",\"---\",\".--.\",\"--.-\",\".-.\",\"...\",\"-\",\"..-\",\"...-\",\".--\",\"-..-\",\"-.--\",\"--..\"};\n    public int uniqueMorseRepresentations(String[] words) {\n        Set<String> set = new HashSet<>();\n        for (String s : words) {\n            StringBuilder sb = new StringBuilder();\n            for (char c : s.toCharArray()) sb.append(ss[c - 'a']);\n            set.add(sb.toString());\n        }\n        return set.size();\n    }\n}\n```\n* 时间复杂度:$O(\\sum_{i = 0}^{words.length - 1}words[i].length())$\n* 空间复杂度:$O(\\sum_{i = 0}^{words.length - 1}words[i].length())$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.804` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/801-810/805. 数组的均值分割（困难）.md", "url_title": "805. 数组的均值分割", "url": "https://leetcode.cn/problems/split-array-with-same-average/solution/gong-shui-san-xie-by-ac_oier-flsd/", "difficulty": "困难", "tags": ["折半搜索", "二进制枚举", "哈希表"], "question": "给定你一个整数数组 `nums`。\n\n我们要将 `nums` 数组中的每个元素移动到 `A` 数组 或者 `B` 数组中,使得 `A` 数组和 `B` 数组不为空,并且 `average(A) == average(B)` 。\n\n如果可以完成则返回 `true`, 否则返回 `false`。\n\n注意:对于数组 `arr`,  `average(arr)` 是 `arr` 的所有元素除以 `arr` 长度的和。\n\n示例 1:\n```\n输入: nums = [1,2,3,4,5,6,7,8]\n\n输出: true\n\n解释: 我们可以将数组分割为 [1,4,5,8] 和 [2,3,6,7], 他们的平均值都是4.5。\n```\n示例 2:\n```\n输入: nums = [3,1]\n\n输出: false\n```\n\n提示:\n* $1 <= nums.length <= 30$\n* $0 <= nums[i] <= 10^4$", "solution": "### 折半搜索 + 二进制枚举 + 哈希表 + 数学\n\n##### 提示一:将长度为 $n$,总和为 $sum$ 的原数组划分为两组,使得两数组平均数相同,可推导出该平均数 $avg = \\frac{sum}{n}$\n\n若两数组平均数相同,则由两数组组成的新数组(对应原数组 `nums`)平均数不变,而原数组的平均数可直接算得。\n\n##### 提示二:原数组长度为 $30$,直接通过「二进制枚举」的方式来做,计算量为 $2^{30}$,该做法无须额外空间,但会 `TLE`。\n\n所谓的直接使用「二进制枚举」来做,是指用二进制表示中的 `0` 和 `1` 分别代表在划分数组两边。\n\n如果直接对原数组进行「二进制枚举」,由于每个 $nums[i]$ 都有两种决策(归属于数组 `A` 或 `B`),共有 $2^{30}$ 个状态需要计算。同时每个状态 `state` 而言,需要 $O(n)$ 的时间复杂度来判定,但整个过程只需要有限个变量。\n\n因此直接使用「二进制枚举」是一个无须额外空间 `TLE`  做法。\n\n##### 提示三:空间换时间\n\n我们不可避免需要使用「枚举」的思路,也不可避免对每个 $nums[i]$ 有两种决策。**但我们可以考虑缩减每次搜索的长度,将搜索分多次进行。**\n\n具体的,我们可以先对 `nums` 的前半部分进行搜索,并将搜索记录以「二元组 $(tot, cnt)$ 的形式」进行缓存(`map` 套 `set`),其中 `tot` 为划分元素总和,`cnt` 为划分元素个数;随后再对 `nums` 的后半部分进行搜索,假设当前搜索到结果为 $(tot', cnt')$,假设我们能够通过“某种方式”算得另外一半的结果为何值,并能在缓存结果中查得该结果,则说明存在合法划分方案,返回 `true`。\n\n通过「折半 + 缓存结果」的做法,将「累乘」的计算过程优化成「累加」计算过程。\n\n##### 提示四:何为“某种方式”\n\n假设我们已经缓存了前半部分的所有搜索结果,并且在搜索后半部分数组时,当前搜索结果为 $(tot', cnt')$,应该在缓存结果中搜索何值来确定是否存在合法划分方案。\n\n假设存在合法方案,且在缓存结果应当被搜索的结果为 $(x, y)$。我们有 $\\frac{tot' + x}{cnt' + y} = avg = \\frac{sum}{n}$。\n\n因此我们可以直接枚举系数 $k$ 来进行判定,其中 $k$ 的取值范围为 $[\\max(1, cnt'), n - 1]$,结合上式算得 $t = k \\times \\frac{sum}{n}$,若在缓存结果中存在 $(t - tot', k - cnt')$,说明存在合法方案。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean splitArraySameAverage(int[] nums) {\n        int n = nums.length, m = n / 2, sum = 0;\n        for (int x : nums) sum += x;\n        Map<Integer, Set<Integer>> map = new HashMap<>();\n        for (int s = 0; s < (1 << m); s++) {\n            int tot = 0, cnt = 0;\n            for (int i = 0; i < m; i++) {\n                if (((s >> i) & 1) == 1) {\n                    tot += nums[i]; cnt++;\n                }\n            }\n            Set<Integer> set = map.getOrDefault(tot, new HashSet<>());\n            set.add(cnt);\n            map.put(tot, set);\n        }\n        for (int s = 0; s < (1 << (n - m)); s++) {\n            int tot = 0, cnt = 0;\n            for (int i = 0; i < (n - m); i++) {\n                if (((s >> i) & 1) == 1) {\n                    tot += nums[i + m]; cnt++;\n                }\n            }\n            for (int k = Math.max(1, cnt); k < n; k++) {\n                if (k * sum % n != 0) continue;\n                int t = k * sum / n;\n                if (!map.containsKey(t - tot)) continue;\n                if (!map.get(t - tot).contains(k - cnt)) continue;\n                return true;\n            }\n        }\n        return false;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool splitArraySameAverage(vector<int>& nums) {\n        int n = nums.size(), m = n / 2, sum = 0;\n        for (int x : nums) sum += x;\n        map<int, unordered_set<int>> hashMap;\n        for (int s = 0; s < (1 << m); s++) {\n            int tot = 0, cnt = 0;\n            for (int i = 0; i < m; i++) {\n                if ((s >> i) & 1) {\n                    tot += nums[i]; cnt++;\n                }\n            }\n            hashMap[tot].insert(cnt);\n        }\n        for (int s = 0; s < (1 << (n - m)); s++) {\n            int tot = 0, cnt = 0;\n            for (int i = 0; i < (n - m); i++) {\n                if ((s >> i) & 1) {\n                    tot += nums[i + m]; cnt++;\n                }\n            }\n            for (int k = max(1, cnt); k < n; k++) {\n                if (k * sum % n != 0) continue;\n                int t = k * sum / n;\n                if (hashMap.count(t - tot) == 0) continue;\n                if (!hashMap[t - tot].count(k - cnt)) continue;\n                return true;\n            }\n        }\n        return false;\n    }\n};\n```\nPython 代码:\n```Python\nfrom collections import defaultdict\n\nclass Solution:\n    def splitArraySameAverage(self, nums: List[int]) -> bool:\n        n, m = len(nums), len(nums) // 2\n        sum_nums = sum(nums)\n        hash_map = defaultdict(set)\n        for s in range(1 << m):\n            tot = cnt = 0\n            for i in range(m):\n                if ((s >> i) & 1):\n                    tot += nums[i]\n                    cnt += 1\n            hash_map[tot].add(cnt)\n        for s in range(1 << (n - m)):\n            tot = cnt = 0\n            for i in range(n - m):\n                if ((s >> i) & 1):\n                    tot += nums[i + m]\n                    cnt += 1\n            for k in range(max(1, cnt), n):\n                if (k * sum_nums) % n != 0: continue\n                t = (k * sum_nums) // n\n                if (t - tot) not in hash_map: continue\n                if (k - cnt) not in hash_map[t - tot]: continue\n                return True\n        return False\n```\nTypeScript 代码:\n```TypeScript\nfunction splitArraySameAverage(nums: number[]): boolean {\n    let n = nums.length, m = Math.floor(n / 2), sum = 0;\n    for (let x of nums) sum += x;\n    let map = new Map();\n    for (let s = 0; s < (1 << m); s++) {\n        let tot = 0, cnt = 0;\n        for (let i = 0; i < m; i++) {\n            if (((s >> i) & 1) == 1) {\n                tot += nums[i]; cnt++;\n            }\n        }\n        let set = map.get(tot) || new Set();\n        set.add(cnt);\n        map.set(tot, set);\n    }\n    for (let s = 0; s < (1 << (n - m)); s++) {\n        let tot = 0, cnt = 0;\n        for (let i = 0; i < (n - m); i++) {\n            if (((s >> i) & 1) == 1) {\n                tot += nums[i + m]; cnt++;\n            }\n        }\n        for (let k = Math.max(1, cnt); k < n; k++) {\n            if (k * sum % n != 0) continue;\n            let t = Math.floor(k * sum / n);\n            if (!map.has(t - tot)) continue;\n            if (!map.get(t - tot).has(k - cnt)) continue;\n            return true;\n        }\n    }\n    return false;\n};\n```\n* 时间复杂度:对原数组前半部分搜索复杂度为 $O(2^{\\frac{n}{2}})$;对原数组后半部分搜索复杂度为 $O(2^{\\frac{n}{2}})$,搜索同时检索前半部分的结果需要枚举系数 `k`,复杂度为 $O(n)$。整体复杂度为 $O(n \\times 2^{\\frac{n}{2}})$\n* 空间复杂度:$O(2^{\\frac{n}{2}})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.805` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/801-810/806. 写字符串需要的行数（简单）.md", "url_title": "806. 写字符串需要的行数", "url": "https://leetcode-cn.com/problems/number-of-lines-to-write-string/solution/by-ac_oier-5hg2/", "difficulty": "简单", "tags": ["模拟"], "question": "我们要把给定的字符串 `S` 从左到右写到每一行上,每一行的最大宽度为 $100$ 个单位,如果我们在写某个字母的时候会使这行超过了 $100$ 个单位,那么我们应该把这个字母写到下一行。\n\n我们给定了一个数组 `widths`,这个数组 $widths[0]$ 代表 `'a'` 需要的单位, $widths[1]$ 代表 `'b'` 需要的单位,..., $widths[25]$ 代表 `'z'` 需要的单位。\n\n现在回答两个问题:至少多少行能放下 `S`,以及最后一行使用的宽度是多少个单位?\n\n将你的答案作为长度为 $2$ 的整数列表返回。\n\n示例 1:\n```\n输入: \nwidths = [10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]\nS = \"abcdefghijklmnopqrstuvwxyz\"\n\n输出: [3, 60]\n\n解释: \n所有的字符拥有相同的占用单位10。所以书写所有的26个字母,\n我们需要2个整行和占用60个单位的一行。\n```\n示例 2:\n```\n输入: \nwidths = [4,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]\nS = \"bbbcccdddaaa\"\n\n输出: [2, 4]\n\n解释: \n除去字母'a'所有的字符都是相同的单位10,并且字符串 \"bbbcccdddaa\" 将会覆盖 9 * 10 + 2 * 4 = 98 个单位.\n最后一个字母 'a' 将会被写到第二行,因为第一行只剩下2个单位了。\n所以,这个答案是2行,第二行有4个单位宽度。\n```\n\n注:\n* 字符串 `S` 的长度在 $[1, 1000]$ 的范围。\n* `S` 只包含小写字母。\n* `widths` 是长度为 $26$ 的数组。\n* $widths[i]$ 值的范围在 $[2, 10]$。", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n使用变量 `a` 代指当前有多少行是满的,使用变量 `b` 代指当前填充光标所在的位置。\n\n代码:\n```Java\nclass Solution {\n    public int[] numberOfLines(int[] widths, String s) {\n        int a = 0, b = 0;\n        for (char c : s.toCharArray()) {\n            int t = widths[c - 'a'];\n            if (b + t > 100 && ++a >= 0) b = t;\n            else b += t;         \n        }\n        if (b != 0) a++;\n        return new int[]{a, b};\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:不使用 `toCharArray` 为 $O(1)$,否则为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.804` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/801-810/807. 保持城市天际线（中等）.md", "url_title": "807. 保持城市天际线", "url": "https://leetcode-cn.com/problems/max-increase-to-keep-city-skyline/solution/gong-shui-san-xie-jian-dan-tan-xin-yun-y-2f47/", "difficulty": "中等", "tags": ["贪心"], "question": "在二维数组 $grid$ 中,$grid[i][j]$ 代表位于某处的建筑物的高度。 我们被允许增加任何数量(不同建筑物的数量可能不同)的建筑物的高度。 高度 $0$ 也被认为是建筑物。\n\n最后,从新数组的所有四个方向(即顶部,底部,左侧和右侧)观看的“天际线”必须与原始数组的天际线相同。 城市的天际线是从远处观看时,由所有建筑物形成的矩形的外部轮廓。 请看下面的例子。\n\n建筑物高度可以增加的最大总和是多少?\n\n例子:\n```\n输入: grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]\n\n输出: 35\n\n解释: \nThe grid is:\n[ [3, 0, 8, 4], \n  [2, 4, 5, 7],\n  [9, 2, 6, 3],\n  [0, 3, 1, 0] ]\n\n从数组竖直方向(即顶部,底部)看“天际线”是:[9, 4, 8, 7]\n从水平水平方向(即左侧,右侧)看“天际线”是:[8, 7, 9, 3]\n\n在不影响天际线的情况下对建筑物进行增高后,新数组如下:\n\ngridNew = [ [8, 4, 8, 7],\n            [7, 4, 7, 7],\n            [9, 4, 8, 7],\n            [3, 3, 3, 3] ]\n```\n说明:\n* $1 < grid.length = grid[0].length <= 50。$\n* $ grid[i][j]$ 的高度范围是:$[0, 100]$。\n* 一座建筑物占据一个$grid[i][j]$:换言之,它们是 $1 x 1 x grid[i][j]$ 的长方体。", "solution": "### 贪心\n\n根据题意,我们需要确保在调整建筑物高度后,从「水平」和「竖直」两个方向所看到的「行」和「列」的最大高度不变。\n\n因此我们可以先通过 $O(n * m)$ 的复杂度预处理出 `grid` 中每行的最大值(使用 $r$ 数组存储),以及每列的最大值(使用 $c$ 数组存储)。\n\n然后在统计答案时,通过判断当前位置 $g[i][j]$ 与 $\\min(r[i], c[j])$ 的大小关系来决定当前位置能够增高多少。\n\n可以证明,当每个位置都取得最大的增大高度(局部最优)时,可使得总的增加高度最大(全局最优)。\n\n代码:\n```Java\nclass Solution {\n    public int maxIncreaseKeepingSkyline(int[][] grid) {\n        int n = grid.length, m = grid[0].length;\n        int[] r = new int[n], c = new int[m];\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                r[i] = Math.max(r[i], grid[i][j]);\n                c[j] = Math.max(c[j], grid[i][j]);\n            }\n        }\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                ans += Math.min(r[i], c[j]) - grid[i][j];\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n * m)$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.807` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/801-810/808. 分汤（中等）.md", "url_title": "808. 分汤", "url": "https://leetcode.cn/problems/soup-servings/solution/by-ac_oier-3n1h/", "difficulty": "中等", "tags": ["数学", "动态规划", "线性 DP"], "question": "有 `A` 和 `B` 两种类型 的汤,一开始每种类型的汤有 `n` 毫升。\n\n有四种分配操作:\n\n1. 提供 `100ml` 的 汤A 和 `0ml` 的 汤B 。\n2. 提供 `75ml` 的 汤A 和 `25ml` 的 汤B 。\n3. 提供 `50ml` 的 汤A 和 `50ml` 的 汤B 。\n4. 提供 `25ml` 的 汤A 和 `75ml` 的 汤B 。\n\n当我们把汤分配给某人之后,汤就没有了。\n\n每个回合,我们将从四种概率同为 `0.25` 的操作中进行分配选择。\n\n如果汤的剩余量不足以完成某次操作,我们将尽可能分配。\n\n当两种类型的汤都分配完时,停止操作。\n\n注意 不存在先分配 `100 ml` 汤B 的操作。\n\n需要返回的值:汤A 先分配完的概率 +  汤A和汤B 同时分配完的概率 / 2。\n\n返回值在正确答案 $10^{-5}$ 的范围内将被认为是正确的。\n\n示例 1:\n```\n输入: n = 50\n\n输出: 0.62500\n\n解释:如果我们选择前两个操作,A 首先将变为空。\n对于第三个操作,A 和 B 会同时变为空。\n对于第四个操作,B 首先将变为空。\n所以 A 变为空的总概率加上 A 和 B 同时变为空的概率的一半是 0.25 *(1 + 1 + 0.5 + 0)= 0.625。\n```\n示例 2:\n```\n输入: n = 100\n\n输出: 0.71875\n```\n\n提示:\n* $0 <= n <= 10^9$", "solution": "### 数学 + 动态规划\n\n四种分配方式都是 $25$ 的倍数,因此我们可以将 $n$ 进行除以 $25$ 上取整的缩放操作,并将四类操作等价成:\n\n1. 提供 `4ml` 的 汤A 和 `0ml` 的 汤B 。\n2. 提供 `3ml` 的 汤A 和 `1ml` 的 汤B 。\n3. 提供 `2ml` 的 汤A 和 `2ml` 的 汤B 。\n4. 提供 `1ml` 的 汤A 和 `3ml` 的 汤B 。\n\n定义 $f[i][j]$ 为 汤A 剩余 $i$ 毫升,汤B 剩余 $j$ 毫升时的最终概率($概率 = 汤A先分配完的概率 + 汤A和汤B同时分配完的概率 \\times 0.5$)。\n\n最终答案为 $f[n][n]$ 为最终答案,考虑任意项存在为 $0$ 情况时的边界情况:\n\n* 若 $i = 0$ 且 $j = 0$,结果为 $0 + \\frac{1}{2} = \\frac{1}{2}$,即有 $f[0][0] = 0.5$\n* 若 $i = 0$ 且 $j > 0$,结果为 $1 + 0 = 1$,即有 $f[0][X] = 1$,其中 $X > 1$\n* 若 $i > 0$ 且 $j = 0$,结果为 $0 + 0 = 0$,即有 $f[X][0] = 0$,其中 $X > 1$\n\n其余一般情况为 $i$ 和 $j$ 均不为 $0$,由于四类操作均为等概率,结合题意和状态定义可知:\n\n$$\nf[i][j] = \\frac{1}{4} \\times (f[i - 4][j] + f[i - 3][j - 1] + f[i - 2][j - 2] + f[i - 1][j - 3])\n$$\n\n由于 $n = 1e9$,即使进行了除 $25$ 的缩放操作,过多的状态数仍会导致 `TLE`。\n\n此时需要利用「返回值在正确答案 $10^{-5}$ 的范围内将被认为是正确的」来做优化(一下子不太好想到):由于四类操作均是等概率,单个回合期望消耗汤 A 的量为 $2.5$,消耗汤 B 的量为 $1.5$。\n\n因此当 $n$ 足够大,操作回合足够多,汤 A 将有较大的概率结束分配,即当 $n$ 足够大,概率值会趋向于 $1$。\n\n我们考虑多大的 $n$ 能够配合精度误差 $10^{-5}$ 来减少计算量:一个可行的操作是利用上述的 DP 思路 + 二分的方式找到符合精度要求的验算值(不超过 $200$)。\n\nJava 代码:\n```Java\nclass Solution {\n    public double soupServings(int n) {\n        n = Math.min(200, (int) Math.ceil(n / 25.0));\n        double[][] f = new double[n + 10][n + 10];\n        f[0][0] = 0.5;\n        for (int j = 1; j <= n; j++) f[0][j] = 1;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= n; j++) {\n                double a = f[Math.max(i - 4, 0)][j], b = f[Math.max(i - 3, 0)][Math.max(j - 1, 0)];\n                double c = f[Math.max(i - 2, 0)][Math.max(j - 2, 0)], d = f[Math.max(i - 1, 0)][Math.max(j - 3, 0)];\n                f[i][j] = 0.25 * (a + b + c + d);\n            }\n        }\n        return f[n][n];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    double soupServings(int n) {\n        n = min(200, (int)ceil(n / 25.0));\n        vector<vector<double>> f(n + 10, vector<double>(n + 10, 0));\n        f[0][0] = 0.5;\n        for (int j = 1; j <= n; ++j) f[0][j] = 1;\n        for (int i = 1; i <= n; ++i) {\n            for (int j = 1; j <= n; ++j) {\n                double a = f[max(i - 4, 0)][j], b = f[max(i - 3, 0)][max(j - 1, 0)];\n                double c = f[max(i - 2, 0)][max(j - 2, 0)], d = f[max(i - 1, 0)][max(j - 3, 0)];\n                f[i][j] = 0.25 * (a + b + c + d);\n            }\n        }\n        return f[n][n];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def soupServings(self, n: int) -> float:\n        n = min(200, math.ceil(n / 25))\n        f = [[0] * (n + 10) for _ in range(n + 10)]\n        f[0][0] = 0.5\n        for j in range(1, n + 10):\n            f[0][j] = 1\n        for i in range(1, n + 1):\n            for j in range(1, n + 1):\n                a, b = f[max(i - 4, 0)][j], f[max(i - 3, 0)][max(j - 1, 0)]\n                c, d = f[max(i - 2, 0)][max(j - 2, 0)], f[max(i - 1, 0)][max(j - 3, 0)]\n                f[i][j] = 0.25 * (a + b + c + d)\n        return f[n][n]\n```\nTypeScript 代码:\n```TypeScript\nfunction soupServings(n: number): number {\n    n = Math.min(200, Math.ceil(n / 25.0));\n    const f: number[][] = Array(n + 10).fill(0).map(() => Array(n + 10).fill(0));\n    f[0][0] = 0.5;\n    for (let j = 1; j <= n; j++) f[0][j] = 1;\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= n; j++) {\n            let a = f[Math.max(i - 4, 0)][j], b = f[Math.max(i - 3, 0)][Math.max(j - 1, 0)];\n            let c = f[Math.max(i - 2, 0)][Math.max(j - 2, 0)], d = f[Math.max(i - 1, 0)][Math.max(j - 3, 0)];\n            f[i][j] = 0.25 * (a + b + c + d);\n        }\n    }\n    return f[n][n]; \n};\n```\n* 时间复杂度:$O(m^2)$,其中 $m = 200$ 为验算值\n* 空间复杂度:$O(m^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.808` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/801-810/809. 情感丰富的文字（中等）.md", "url_title": "809. 情感丰富的文字", "url": "https://leetcode.cn/problems/expressive-words/solution/by-ac_oier-tb57/", "difficulty": "中等", "tags": ["双指针", "模拟"], "question": "有时候人们会用重复写一些字母来表示额外的感受,比如 `\"hello\" -> \"heeellooo\", \"hi\" -> \"hiii\"`。我们将相邻字母都相同的一串字符定义为相同字母组,例如:`\"h\", \"eee\", \"ll\", \"ooo\"`。\n\n对于一个给定的字符串 `S` ,如果另一个单词能够通过将一些字母组扩张从而使其和 `S` 相同,我们将这个单词定义为可扩张的(`stretchy`)。\n\n扩张操作定义如下:选择一个字母组(包含字母 `c` ),然后往其中添加相同的字母 `c` 使其长度达到 `3` 或以上。\n\n例如,以 `\"hello\"` 为例:\n\n我们可以对字母组 `\"o\"` 扩张得到 `\"hellooo\"`,但是无法以同样的方法得到 `\"helloo\"` 因为字母组 `\"oo\"` 长度小于 `3`。此外,我们可以进行另一种扩张 `\"ll\" -> \"lllll\"` 以获得 `\"helllllooo\"`。\n\n如果 `S = \"helllllooo\"`,那么查询词 `\"hello\"` 是可扩张的,因为可以对它执行这两种扩张操作使得 `query = \"hello\" -> \"hellooo\" -> \"helllllooo\" = S`。\n\n输入一组查询单词,输出其中可扩张的单词数量。\n\n示例:\n```\n输入: \nS = \"heeellooo\"\nwords = [\"hello\", \"hi\", \"helo\"]\n\n输出:1\n\n解释:\n我们能通过扩张 \"hello\" 的 \"e\" 和 \"o\" 来得到 \"heeellooo\"。\n我们不能通过扩张 \"helo\" 来得到 \"heeellooo\" 因为 \"ll\" 的长度小于 3 。\n```\n\n提示:\n* $0 <= len(S) <= 100$\n* $0 <= len(words) <= 100$\n* $0 <= len(words[i]) <= 100$\n* `S` 和所有在 `words` 中的单词都只由小写字母组成。", "solution": "### 双指针\n\n该题最难的部分就是理解 “扩张” 操作:假设有两个字符相同的连续段 `a` 和 `b`,如何判断 `a` 是否能由 `b` 扩张而来。\n\n忘记掉题目所说的规则,我们重新定义 “扩张” 操作:\n\n* 当 `a` 和 `b` 长度相同,定义为可扩张;\n* 当 `a` 和 `b` 长度不同,根据「`a` 和 `b` 长度对比」以及「`a` 的长度大小」分情况讨论:\n    * 当 `b` 长度大于 `a`,不可扩张;\n    * 当 `a` 长度大于 `b`,**我们不一定要拿整一段的 `b` 进行扩张,可以拿 `b` 中的一个字符进行扩张。** 因此只需要满足扩张后的长度(`a` 的长度)大于等于 $3$ 即可定义为可扩张。\n\n搞明白何为 “扩张” 后,剩余的则是简单的「双指针 + 模拟」做法。\n\nJava 代码:\n```Java\nclass Solution {\n    public int expressiveWords(String s, String[] words) {\n        int n = s.length(), ans = 0;\n        out:for (String word : words) {\n            int m = word.length(), i = 0, j = 0;\n            while (i < n && j < m) {\n                if (s.charAt(i) != word.charAt(j)) continue out;\n                int a = i, b = j;\n                while (a < n && s.charAt(a) == s.charAt(i)) a++;\n                while (b < m && word.charAt(b) == word.charAt(j)) b++;\n                a -= i; b -= j;\n                if (a != b && (b > a || a < 3)) continue out;                \n                i += a; j += b;\n            }\n            if (i == n && j == m) ans++;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int expressiveWords(string s, vector<string>& words) {\n        int n = s.size(), ans = 0;\n        for (const string &word : words) {\n            int m = word.size(), i = 0, j = 0;\n            while (i < n && j < m) {\n                if (s[i] != word[j]) break;\n                int a = i, b = j;\n                while (a < n && s[a] == s[i]) a++;\n                while (b < m && word[b] == word[j]) b++;\n                a -= i; b -= j;\n                if (a != b && (b > a || a < 3)) break;                \n                i += a; j += b;\n                if (i == n && j == m) ans++;\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def expressiveWords(self, s: str, words: List[str]) -> int:\n        n, ans = len(s), 0\n        for word in words:\n            m, i, j = len(word), 0, 0\n            ok = True\n            while ok and i < n and j < m:\n                if s[i] != word[j]:\n                    ok = False\n                a, b = i, j\n                while a < n and s[a] == s[i]:\n                    a += 1\n                while b < m and word[b] == word[j]:\n                    b += 1\n                a, b = a - i, b - j\n                if a != b and (b > a or a < 3):\n                    ok = False\n                i, j = i + a, j + b\n            if ok and i == n and j == m:\n                ans += 1\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction expressiveWords(s: string, words: string[]): number {\n    let n = s.length, ans = 0\n    out:for (const word of words) {\n        let m = word.length, i = 0, j = 0\n        while (i < n && j < m) {\n            if (s[i] != word[j]) continue out\n            let a = i, b = j\n            while (a < n && s[a] == s[i]) a++\n            while (b < m && word[b] == word[j]) b++\n            a -= i; b -= j;\n            if (a != b && (b > a || a < 3)) continue out\n            i += a; j += b;\n        }\n        if (i == n && j == m) ans++;\n    }\n    return ans\n}\n```\n* 时间复杂度:$O(n \\times m + \\sum_{i = 0}^{m - 1}words[i].length)$,其中 `n` 为字符串 `s` 的长度,`m` 为数组 `words` 的长度\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.809` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/801-810/810. 黑板异或游戏（困难）.md", "url_title": "810. 黑板异或游戏", "url": "https://leetcode-cn.com/problems/chalkboard-xor-game/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-ges7k/", "difficulty": "困难", "tags": ["博弈论", "数学", "异或"], "question": "黑板上写着一个非负整数数组 `nums[i]` 。\n\n`Alice` 和 `Bob` 轮流从黑板上擦掉一个数字,`Alice` 先手。如果擦除一个数字后,剩余的所有数字按位异或运算得出的结果等于 `0` 的话,当前玩家游戏失败。 (另外,如果只剩一个数字,按位异或运算得到它本身;如果无数字剩余,按位异或运算结果为 `0`。)\n\n换种说法就是,轮到某个玩家时,如果当前黑板上所有数字按位异或运算结果等于 `0`,这个玩家获胜。\n\n假设两个玩家每步都使用最优解,当且仅当 `Alice` 获胜时返回 `true`。\n\n示例:\n```\n输入: nums = [1, 1, 2]\n\n输出: false\n\n解释: \nAlice 有两个选择: 擦掉数字 1 或 2。\n如果擦掉 1, 数组变成 [1, 2]。剩余数字按位异或得到 1 XOR 2 = 3。那么 Bob 可以擦掉任意数字,因为 Alice 会成为擦掉最后一个数字的人,她总是会输。\n如果 Alice 擦掉 2,那么数组变成[1, 1]。剩余数字按位异或得到 1 XOR 1 = 0。Alice 仍然会输掉游戏。\n```\n\n提示:\n* $1 <= N <= 1000$\n* $0 <= nums[i] <= 2^{16}$", "solution": "### 基本分析\n\n这是一道「博弈论」题。\n\n如果没接触过博弈论,其实很难想到,特别是数据范围为 $10^3$,很具有迷惑性。\n\n如果接触过博弈论,对于这种「判断先手后手的必胜必败」的题目,博弈论方向是一个优先考虑的方向。\n\n根据题意,如果某位玩家在操作前所有数值异或和为 $0$,那么该玩家胜利。要我们判断给定序列时,先手是处于「必胜态」还是「必败态」,如果处于「必胜态」返回 `True`,否则返回 `False`。\n\n对于博弈论的题目,通常有两类的思考方式:\n\n1. 经验分析:见过类似的题目,猜一个性质,然后去证明该性质是否可推广。\n2. 状态分析:根据题目给定的规则是判断「胜利」还是「失败」来决定优先分析「必胜态」还是「必败态」时具有何种性质,然后证明性质是否可推广。\n\n---\n\n### 博弈论\n\n**对于本题,给定的是判断「胜利」的规则(在给定序列的情况下,如果所有数值异或和为 $0$ 可立即判断胜利,其他情况无法立即判断胜负),那么我们应该优先判断何为「先手必胜态」,如果不好分析,才考虑分析后手的「必败态」。**\n\n接下来是分情况讨论:\n\n#### 1. 如果给定的序列异或和为 $0$,游戏开始时,先手直接获胜:\n\n由此推导出性质一:**给定序列 `nums` 的异或和为 $0$,先手处于「必胜态」,返回 `True`。**\n\n#### 2. 如果给定序列异或和不为 $0$,我们需要分析,先手获胜的话,序列会满足何种性质:\n\n显然如果要先手获胜,则需要满足「**先手去掉一个数,剩余数值异或和必然不为 $0$;同时后手去掉一个数后,剩余数值异或和必然为 $0$**」。\n\n换句话说,我们需要分析**什么情况下「经过一次后手操作」后,序列会以上述情况 $1$ 的状态,回到先手的局面**。\n\n也就是反过来分析想要出现「后手必败态」,序列会有何种性质。\n\n假设后手操作前的异或和为 $Sum$($Sum \\neq 0$),「后手必败态」意味着去掉任意数字后异或和为 $0$。\n\n同时根据「相同数值异或结果为 $0$」的特性,我们知道去掉某个数值,等价于在原有异或和的基础上异或上这个值。\n\n则有:\n\n$$\nSum' = Sum ⊕ nums[i] = 0\n$$\n\n由于是「后手必败态」,因此 $i$ 取任意一位,都满足上述式子。\n\n则有:\n\n$$\nSum ⊕ nums[0] = ... = Sum ⊕ nums[k] = ... = Sum ⊕ nums[n - 1] = 0\n$$\n\n同时根据「任意数值与 $0$ 异或数值不变」的特性,我们将每一项进行异或:\n\n$$\n(Sum ⊕ nums[0]) ⊕ ... ⊕ (Sum ⊕ nums[k]) ⊕ ... ⊕ (Sum ⊕ nums[n - 1]) = 0\n$$\n\n根据交换律进行变换:\n\n$$\n(Sum ⊕ Sum ⊕ ... ⊕ Sum) ⊕ (nums[0] ⊕ ... ⊕ nums[k] ⊕ ... ⊕ nums[n - 1]) = 0 \n$$\n\n再结合 $Sum$ 为原序列的异或和可得:\n\n$$\n(Sum ⊕ Sum ⊕ ... ⊕ Sum) ⊕ Sum = 0 , Sum \\neq 0\n$$\n\n至此,我们分析出当处于「后手必败态」时,去掉任意一个数值会满足上述式子。\n\n根据「相同数值偶数次异或结果为 $0$」的特性,可推导出「后手必败态」会导致交回到先手的序列个数为偶数,由此推导后手操作前序列个数为奇数,后手操作前一个回合为偶数。\n\n到这一步,我们推导出想要出现「后手必败态」,先手操作前的序列个数应当为偶数。\n\n那么根据先手操作前序列个数为偶数(且异或和不为 $0$),是否能够推导出必然出现「后手必败态」呢?\n\n**显然是可以的,因为如果不出现「后手必败态」,会与我们前面分析过程矛盾。**\n\n假设先手操作前异或和为 $Xor$(序列数量为偶数,同时 $Xor \\neq 0$),如果最终不出现「后手必败态」的话,也就是先手会输掉的话,那么意味着有 $Xor ⊕ nums[i] = 0$,其中 $i$ 为序列的任意位置。利用此性质,像上述分析那样,将每一项进行展开异或,会得到奇数个 $Xor$ 异或结果为 $0$,这与开始的 $Xor \\neq 0$ 矛盾。\n\n由此推导出性质二:**只需要保证先手操作前序列个数为偶数时就会出现「后手必败态」,从而确保先手必胜。**\n\n**综上,如果序列 `nums` 本身异或和为 $0$,天然符合「先手必胜态」的条件,答案返回 `True` ;如果序列 `nums` 异或和不为 $0$,但序列长度为偶数,那么最终会出现「后手必败态」,推导出先手必胜,答案返回 `True`。**\n\n代码:\n```Java\nclass Solution {\n    public boolean xorGame(int[] nums) {\n        int sum = 0;\n        for (int i : nums) sum ^= i;\n        return sum == 0 || nums.length % 2 == 0;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 总结\n\n事实上,在做题的时候,我也是采取「先假定奇偶性,再证明」的做法,因为这样比较快。\n\n但「假定奇偶性」这一步是比较具有跳跃性的,这有点像我前面说到的「经验分析解法」,而本题解证明没有做任何的前置假定,单纯从「先手必胜态」和「后手必败态」进行推导,最终推导出「先手序列偶数必胜」的性质 ,更符合前面说到的「状态分析解法」。\n\n两种做法殊途同归,在某些博弈论问题上,「经验分析解法」可以通过「归纳」&「反证」很好分析出来,但这要求选手本身具有一定的博弈论基础;而「状态分析解法」则对选手的题量要求低些,逻辑推理能力高些。\n\n两种方法并无优劣之分,都是科学严谨的做法。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.810` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/81-90/81. 搜索旋转排序数组 II（中等）.md", "url_title": "81. 搜索旋转排序数组 II", "url": "https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-xtam4/", "difficulty": "中等", "tags": ["二分"], "question": "已知存在一个按非降序排列的整数数组 nums ,数组中的值不必互不相同。\n\n在传递给函数之前,nums 在预先未知的某个下标 k(0 <= k < nums.length)上进行了 旋转 ,使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]](下标 从 0 开始 计数)。例如, [0,1,2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。\n\n给你 旋转后 的数组 nums 和一个整数 target ,请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 target ,则返回 true ,否则返回 false 。\n\n \n\n示例 1:\n```\n输入:nums = [2,5,6,0,0,1,2], target = 0\n\n输出:true\n```\n示例 2:\n```\n输入:nums = [2,5,6,0,0,1,2], target = 3\n\n输出:false\n```\n\n提示:\n* 1 <= nums.length <= 5000\n* -$10^4$ <= nums[i] <= $10^4$\n* 题目数据保证 nums 在预先未知的某个下标上进行了旋转\n* -$10^4$ <= target <= $10^4$", "solution": "### 二分\n\n根据题意,我们知道,所谓的旋转其实就是「将某个下标前面的所有数整体移到后面,使得数组从整体有序变为分段有序」。\n\n但和 [33. 搜索旋转排序数组](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/sou-suo-xuan-zhuan-pai-xu-shu-zu-by-leetcode-solut/) 不同的是,本题元素并不唯一。\n\n**这意味着我们无法直接根据与** $nums[0]$ **的大小关系,将数组划分为两段,即无法通过「二分」来找到旋转点。**\n\n**因为「二分」的本质是二段性,并非单调性。只要一段满足某个性质,另外一段不满足某个性质,就可以用「二分」。**\n\n如果你有看过我 [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/) 这篇题解,你应该很容易就理解上句话的意思。如果没有也没关系,我们可以先解决本题,在理解后你再去做 [33. 搜索旋转排序数组](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/sou-suo-xuan-zhuan-pai-xu-shu-zu-by-leetcode-solut/),我认为这两题都是一样的,不存在先后关系。\n\n举个🌰,我们使用数据 [0,1,2,2,2,3,4,5] 来理解为什么不同的旋转点会导致「二段性丢失」:\n\n代码:\n```java []\nclass Solution {\n    public boolean search(int[] nums, int t) {\n        int n = nums.length;\n        int l = 0, r = n - 1;\n        // 恢复二段性\n        while (l < r && nums[0] == nums[r]) r--;\n\n        // 第一次二分,找旋转点\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (nums[mid] >= nums[0]) {\n                l = mid;\n            } else {\n                r = mid - 1;\n            }\n        }\n        \n        int idx = n;\n        if (nums[r] >= nums[0] && r + 1 < n) idx = r + 1;\n\n        // 第二次二分,找目标值\n        int ans = find(nums, 0, idx - 1, t);\n        if (ans != -1) return true;\n        ans = find(nums, idx, n - 1, t);\n        return ans != -1;\n    }\n    int find(int[] nums, int l, int r, int t) {\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (nums[mid] >= t) {\n                r = mid;\n            } else {\n                l = mid + 1;\n            }\n        }\n        return nums[r] == t ? r : -1;\n    }\n}\n```\n* 时间复杂度:恢复二段性处理中,最坏的情况下(考虑整个数组都是同一个数)复杂度是 $O(n)$,而之后的找旋转点和目标值都是「二分」,复杂度为 $O(log{n})$。整体复杂度为 $O(n)$ 的。\n* 空间复杂度:$O(1)$。\n\n***\n\n### 进阶\n\n如果真正理解「二分」的话,本题和 [33. 搜索旋转排序数组](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/sou-suo-xuan-zhuan-pai-xu-shu-zu-by-leetcode-solut/) 区别不大。\n\n建议大家在完成两题的基础上试试 [面试题 10.03. 搜索旋转数组](https://leetcode-cn.com/problems/search-rotate-array-lcci/) 。\n\n***\n\n### 其他「二分」相关题解\n\n* 二分模板\n    [29. 两数相除](https://leetcode-cn.com/problems/divide-two-integers/) : [二分 + 倍增乘法解法(含模板)](https://leetcode-cn.com/problems/divide-two-integers/solution/shua-chuan-lc-er-fen-bei-zeng-cheng-fa-j-m73b/)\n\n* 二分本质 & 恢复二段性处理\n\n    [33. 搜索旋转排序数组(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/)\n\n    [81. 搜索旋转排序数组 II(找目标值)](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-xtam4/)\n\n    [153. 寻找旋转排序数组中的最小值(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/) : [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/)\n\n    [154. 寻找旋转排序数组中的最小值 II(找最小值)](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/) : [详解为何元素相同会导致 O(n),一起看清二分的本质](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/solution/gong-shui-san-xie-xiang-jie-wei-he-yuan-7xbty/)\n\n* 二分 check 函数如何确定\n    [34. 在排序数组中查找元素的第一个和最后一个位置](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/) : [考察对「二分」的理解,以及 check 函数的「大于 小于」怎么写](https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/gong-shui-san-xie-kao-cha-dui-er-fen-de-86bk0/)\n\n* 二分答案的题目\n    [1482. 制作 m 束花所需的最少天数](https://leetcode-cn.com/problems/minimum-number-of-days-to-make-m-bouquets/) : [利用「二段性」找分割点,以及优化 check 函数](https://leetcode-cn.com/problems/minimum-number-of-days-to-make-m-bouquets/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-ysv4/)\n    [1011. 在 D 天内送达包裹的能力](https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/) : [利用「二段性」找分割点,以及如何确定「二分范围」](https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days/solution/gong-shui-san-xie-li-yong-er-duan-xing-z-95zj/)", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.81` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/81-90/82. 删除排序链表中的重复元素 II（中等）.md", "url_title": "82. 删除排序链表中的重复元素 II", "url": "https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list-ii/solution/tong-yong-shan-chu-zhong-fu-jie-dian-lia-od9g/", "difficulty": "中等", "tags": ["链表"], "question": "存在一个按升序排列的链表,给你这个链表的头节点 `head`,请你删除链表中所有存在数字重复情况的节点,只保留原始链表中没有重复出现的数字。\n\n返回同样按升序排列的结果链表。 \n\n示例 1:\n\n```\n输入:head = [1,2,3,3,4,4,5]\n\n输出:[1,2,5]\n```\n示例 2:\n\n```\n输入:head = [1,1,1,2,3]\n\n输出:[2,3]\n```\n\n提示:\n* 链表中节点数目在范围 $[0, 300]$ 内\n* $-100 <= Node.val <= 100$\n* 题目数据保证链表已经按升序排列", "solution": "### 基本思路\n\n几乎所有的链表题目,都具有相似的解题思路。\n\n1. 建一个虚拟头节点 `dummy` 以减少边界判断,往后的答案链表会接在 `dummy` 后面\n2. 使用 `tail` 代表当前有效链表的结尾\n3. 通过原输入的 `head` 指针进行链表扫描\n\n我们会确保「进入外层循环时 `head` 不会与上一节点相同」,因此插入时机:\n\n1. `head` 已经没有下一个节点,`head` 可以被插入\n2. `head` 有一下个节点,但是值与 `head` 不相同,`head` 可以被插入\n\nJava 代码:\n```Java\nclass Solution {\n    public ListNode deleteDuplicates(ListNode head) {\n        ListNode dummy = new ListNode();\n        ListNode tail = dummy;\n        while (head != null) {\n            // 进入循环时,确保了 head 不会与上一节点相同\n            if (head.next == null || head.val != head.next.val) {\n                tail.next = head;\n                tail = head;\n            }\n            // 如果 head 与下一节点相同,跳过相同节点\n            while (head.next != null && head.val == head.next.val) head = head.next;\n            head = head.next;\n        }\n        tail.next = null;\n        return dummy.next;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    ListNode* deleteDuplicates(ListNode* head) {\n        ListNode* dummy = new ListNode();\n        ListNode* tail = dummy;\n        while (head != nullptr) {\n            // 进入循环时,确保了 head 不会与上一节点相同\n            if (head->next == nullptr || head->val != head->next->val) {\n                tail->next = head;\n                tail = head;\n            }\n            // 如果 head 与下一节点相同,跳过相同节点\n            while (head->next != nullptr && head->val == head->next->val) head = head->next;\n            head = head->next;\n        }\n        tail->next = nullptr;\n        return dummy->next;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n        dummy = ListNode()\n        tail = dummy\n        while head:\n            # 进入循环时,确保了 head 不会与上一节点相同\n            if not head.next or head.val != head.next.val:\n                tail.next = head\n                tail = head\n            # 如果 head 与下一节点相同,跳过相同节点\n            while head.next and head.val == head.next.val: head = head.next\n            head = head.next\n        tail.next = None\n        return dummy.next\n```\nTypeScript 代码:\n```TypeScript\nfunction deleteDuplicates(head: ListNode | null): ListNode | null {\n    const dummy: ListNode = new ListNode();\n    let tail: ListNode | null = dummy;\n    while (head) {\n        // 进入循环时,确保了 head 不会与上一节点相同\n        if (!head.next || head.val !== head.next.val) {\n            tail.next = head;\n            tail = head;\n        }\n        // 如果 head 与下一节点相同,跳过相同节点\n        while (head.next && head.val === head.next.val) head = head.next;\n        head = head.next;\n    }\n    tail.next = null;\n    return dummy.next;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 拓展\n\n如果问题变为「相同节点保留一个」,该如何实现?\n\n还是类似的解题思路。\n\n1. 建一个虚拟头节点 `dummy` 以减少边界判断,往后的答案链表会接在 `dummy` 后面\n2. 使用 `tail` 代表当前有效链表的结尾\n3. 通过原输入的 `head` 指针进行链表扫描\n\nJava 代码:\n```Java\nclass Solution {\n    public ListNode deleteDuplicates(ListNode head) {\n        if (head == null) return head;\n        ListNode dummy = new ListNode(-109);\n        ListNode tail = dummy;\n        while (head != null) {\n            // 值不相等才追加,确保了相同的节点只有第一个会被添加到答案\n            if (tail.val != head.val) {\n                tail.next = head;\n                tail = tail.next;\n            }\n            head = head.next;\n        }\n        tail.next = null;\n        return dummy.next;\n    }   \n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    ListNode* deleteDuplicates(ListNode* head) {\n        if (!head) return head;\n        ListNode* dummy = new ListNode(-109);\n        ListNode* tail = dummy;\n        while (head) {\n            // 值不相等才追加,确保了相同的节点只有第一个会被添加到答案\n            if (tail->val != head->val) {\n                tail->next = head;\n                tail = tail->next;\n            }\n            head = head->next;\n        }\n        tail->next = nullptr;\n        return dummy->next;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n        if not head: return head\n        dummy = ListNode(-109)\n        tail = dummy\n        while head:\n            # 值不相等才追加,确保了相同的节点只有第一个会被添加到答案\n            if tail.val != head.val:\n                tail.next = head\n                tail = tail.next\n            head = head.next\n        tail.next = None\n        return dummy.next\n```\nTypeScript 代码:\n```TypeScript\nfunction deleteDuplicates(head: ListNode | null): ListNode | null {\n    if (!head) return head;\n    const dummy: ListNode = new ListNode(-109);\n    let tail: ListNode | null = dummy;\n    while (head) {\n        // 值不相等才追加,确保了相同的节点只有第一个会被添加到答案\n        if (tail.val !== head.val) {\n            tail.next = head;\n            tail = tail.next;\n        }\n        head = head.next;\n    }\n    tail.next = null;\n    return dummy.next;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.82` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/81-90/83. 删除排序链表中的重复元素（简单）.md", "url_title": "83. 删除排序链表中的重复元素", "url": "https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/solution/tong-yong-shan-chu-zhong-fu-jie-dian-lia-101c/", "difficulty": "简单", "tags": ["链表"], "question": "存在一个按升序排列的链表,给你这个链表的头节点 `head`,请你删除所有重复的元素,使每个元素只出现一次 。\n\n返回同样按升序排列的结果链表。\n\n示例 1:\n\n```\n输入:head = [1,1,2]\n\n输出:[1,2]\n```\n示例 2:\n\n```\n输入:head = [1,1,2,3,3]\n\n输出:[1,2,3]\n```\n\n提示:\n* 链表中节点数目在范围 $[0, 300]$ 内\n* $-100 <= Node.val <= 100$\n* 题目数据保证链表已经按升序排列", "solution": "### 基本思路\n\n几乎所有的链表题目,都具有相似的解题思路。\n\n1. 建一个虚拟头节点 `dummy` 以减少边界判断,往后的答案链表会接在 `dummy` 后面\n2. 使用 `tail` 代表当前有效链表的结尾\n3. 通过原输入的 `head` 指针进行链表扫描\n\nJava 代码:\n```Java\nclass Solution {\n    public ListNode deleteDuplicates(ListNode head) {\n        if (head == null) return head;\n        ListNode dummy = new ListNode(-109);\n        ListNode tail = dummy;\n        while (head != null) {\n            // 值不相等才追加,确保了相同的节点只有第一个会被添加到答案\n            if (tail.val != head.val) {\n                tail.next = head;\n                tail = tail.next;\n            }\n            head = head.next;\n        }\n        tail.next = null;\n        return dummy.next;\n    }   \n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    ListNode* deleteDuplicates(ListNode* head) {\n        if (!head) return head;\n        ListNode* dummy = new ListNode(-109);\n        ListNode* tail = dummy;\n        while (head) {\n            // 值不相等才追加,确保了相同的节点只有第一个会被添加到答案\n            if (tail->val != head->val) {\n                tail->next = head;\n                tail = tail->next;\n            }\n            head = head->next;\n        }\n        tail->next = nullptr;\n        return dummy->next;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n        if not head: return head\n        dummy = ListNode(-109)\n        tail = dummy\n        while head:\n            # 值不相等才追加,确保了相同的节点只有第一个会被添加到答案\n            if tail.val != head.val:\n                tail.next = head\n                tail = tail.next\n            head = head.next\n        tail.next = None\n        return dummy.next\n```\nTypeScript 代码:\n```TypeScript\nfunction deleteDuplicates(head: ListNode | null): ListNode | null {\n    if (!head) return head;\n    const dummy: ListNode = new ListNode(-109);\n    let tail: ListNode | null = dummy;\n    while (head) {\n        // 值不相等才追加,确保了相同的节点只有第一个会被添加到答案\n        if (tail.val !== head.val) {\n            tail.next = head;\n            tail = tail.next;\n        }\n        head = head.next;\n    }\n    tail.next = null;\n    return dummy.next;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 拓展\n\n如果问题变为「重复元素全部删除」,该如何实现?\n\n还是类似的解题思路。\n\n1. 建一个虚拟头节点 `dummy` 以减少边界判断,往后的答案链表会接在 `dummy` 后面\n2. 使用 `tail` 代表当前有效链表的结尾\n3. 通过原输入的 `head` 指针进行链表扫描\n\n我们会确保「进入外层循环时 `head` 不会与上一节点相同」,因此插入时机:\n\n1. `head` 已经没有下一个节点,`head` 可以被插入\n2. `head` 有一下个节点,但是值与 `head` 不相同,`head` 可以被插入\n\nJava 代码:\n```Java\nclass Solution {\n    public ListNode deleteDuplicates(ListNode head) {\n        ListNode dummy = new ListNode();\n        ListNode tail = dummy;\n        while (head != null) {\n            // 进入循环时,确保了 head 不会与上一节点相同\n            if (head.next == null || head.val != head.next.val) {\n                tail.next = head;\n                tail = head;\n            }\n            // 如果 head 与下一节点相同,跳过相同节点\n            while (head.next != null && head.val == head.next.val) head = head.next;\n            head = head.next;\n        }\n        tail.next = null;\n        return dummy.next;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    ListNode* deleteDuplicates(ListNode* head) {\n        ListNode* dummy = new ListNode();\n        ListNode* tail = dummy;\n        while (head != nullptr) {\n            // 进入循环时,确保了 head 不会与上一节点相同\n            if (head->next == nullptr || head->val != head->next->val) {\n                tail->next = head;\n                tail = head;\n            }\n            // 如果 head 与下一节点相同,跳过相同节点\n            while (head->next != nullptr && head->val == head->next->val) head = head->next;\n            head = head->next;\n        }\n        tail->next = nullptr;\n        return dummy->next;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:\n        dummy = ListNode()\n        tail = dummy\n        while head:\n            # 进入循环时,确保了 head 不会与上一节点相同\n            if not head.next or head.val != head.next.val:\n                tail.next = head\n                tail = head\n            # 如果 head 与下一节点相同,跳过相同节点\n            while head.next and head.val == head.next.val: head = head.next\n            head = head.next\n        tail.next = None\n        return dummy.next\n```\nTypeScript 代码:\n```TypeScript\nfunction deleteDuplicates(head: ListNode | null): ListNode | null {\n    const dummy: ListNode = new ListNode();\n    let tail: ListNode | null = dummy;\n    while (head) {\n        // 进入循环时,确保了 head 不会与上一节点相同\n        if (!head.next || head.val !== head.next.val) {\n            tail.next = head;\n            tail = head;\n        }\n        // 如果 head 与下一节点相同,跳过相同节点\n        while (head.next && head.val === head.next.val) head = head.next;\n        head = head.next;\n    }\n    tail.next = null;\n    return dummy.next;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.83` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/81-90/84. 柱状图中最大的矩形（困难）.md", "url_title": "84. 柱状图中最大的矩形", "url": "https://leetcode.cn/problems/largest-rectangle-in-histogram/solution/by-ac_oier-i470/", "difficulty": "困难", "tags": ["单调栈"], "question": "给定 `n` 个非负整数,用来表示柱状图中各个柱子的高度。每个柱子彼此相邻,且宽度为 `1` 。\n\n求在该柱状图中,能够勾勒出来的矩形的最大面积。\n\n示例 1:\n\n```\n输入:heights = [2,1,5,6,2,3]\n\n输出:10\n\n解释:最大的矩形为图中红色区域,面积为 10\n```\n示例 2:\n\n```\n输入: heights = [2,4]\n\n输出: 4\n```\n\n提示:\n* $1 <= heights.length <=10^5$\n* $0 <= heights[i] <= 10^4$", "solution": "### 单调栈 + 枚举高度\n\n为了方便,我们令 `heights` 为 `hs`。\n\n最终矩形的高度必然取自某个 $hs[i]$,因此我们可以枚举最终矩形的高度来做。\n\n问题转换为当使用某个 $hs[i]$ 作为矩形高度时,该矩形所能取得的最大宽度为多少。\n\n假设我们能够预处理出 `l` 和 `r` 数组,其中 $l[i]$ 代表位置 $i$ 左边最近一个比其小的位置(初始值为 $-1$),$r[i]$ 代表位置 $i$ 右边最近一个比其小的位置(初始值为 $n$),那么 $r[i] - l[i] - 1$ 则是以 $hs[i]$ 作为矩形高度时所能取得的最大宽度。\n\n预处理 `l` 和 `r` 则是经典的「求最近一个比当前值大的位置」单调栈问题。\n\nJava 代码:\n```Java\nclass Solution {\n    public int largestRectangleArea(int[] hs) {\n        int n = hs.length;\n        int[] l = new int[n], r = new int[n];\n        Arrays.fill(l, -1); Arrays.fill(r, n);\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            while (!d.isEmpty() && hs[d.peekLast()] > hs[i]) r[d.pollLast()] = i;\n            d.addLast(i);\n        }\n        d.clear();\n        for (int i = n - 1; i >= 0; i--) {\n            while (!d.isEmpty() && hs[d.peekLast()] > hs[i]) l[d.pollLast()] = i;\n            d.addLast(i);\n        }\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            int t = hs[i], a = l[i], b = r[i];\n            ans = Math.max(ans, (b - a - 1) * t);\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction largestRectangleArea(hs: number[]): number {\n    const n = hs.length\n    const l = new Array<number>(n).fill(-1), r = new Array<number>(n).fill(n)\n    const stk = new Array<number>(n).fill(-1)\n    let he = 0, ta = 0\n    for (let i = 0; i < n; i++) {\n        while (he < ta && hs[stk[ta - 1]] > hs[i]) r[stk[--ta]] = i\n        stk[ta++] = i\n    }\n    he = ta = 0\n    for (let i = n - 1; i >= 0; i--) {\n        while (he < ta && hs[stk[ta - 1]] > hs[i]) l[stk[--ta]] = i\n        stk[ta++] = i\n    }\n    let ans = 0\n    for (let i = 0; i < n; i++) {\n        const t = hs[i], a = l[i], b = r[i]\n        ans = Math.max(ans, (b - a - 1) * t)\n    }\n    return ans\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def largestRectangleArea(self, hs: List[int]) -> int:\n        n, he, ta = len(hs), 0, 0\n        stk = [0] * n\n        l, r = [-1] * n, [n] * n\n        for i in range(n):\n            while he < ta and hs[stk[ta - 1]] > hs[i]:\n                ta -= 1\n                r[stk[ta]] = i\n            stk[ta] = i\n            ta += 1\n        he = ta = 0\n        for i in range(n - 1, -1, -1):\n            while he < ta and hs[stk[ta - 1]] > hs[i]:\n                ta -= 1\n                l[stk[ta]] = i\n            stk[ta] = i\n            ta += 1\n        ans = 0\n        for i in range(n):\n            ans = max(ans, (r[i] - l[i] - 1) * hs[i])\n        return ans\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.84` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/81-90/85. 最大矩形（困难）.md", "url_title": "85. 最大矩形", "url": "https://leetcode.cn/problems/maximal-rectangle/solution/by-ac_oier-k02i/", "difficulty": "困难", "tags": ["单调栈", "前缀和"], "question": "给定一个仅包含 `0` 和 `1` 、大小为 `rows x cols` 的二维二进制矩阵,找出只包含 `1` 的最大矩形,并返回其面积。\n\n示例 1:\n\n```\n输入:matrix = [[\"1\",\"0\",\"1\",\"0\",\"0\"],[\"1\",\"0\",\"1\",\"1\",\"1\"],[\"1\",\"1\",\"1\",\"1\",\"1\"],[\"1\",\"0\",\"0\",\"1\",\"0\"]]\n\n输出:6\n\n解释:最大矩形如上图所示。\n```\n示例 2:\n```\n输入:matrix = []\n\n输出:0\n```\n示例 3:\n```\n输入:matrix = [[\"0\"]]\n\n输出:0\n```\n示例 4:\n```\n输入:matrix = [[\"1\"]]\n\n输出:1\n```\n示例 5:\n```\n输入:matrix = [[\"0\",\"0\"]]\n\n输出:0\n```\n\n提示:\n* $rows = matrix.length$\n* $cols = matrix[0].length$\n* $1 <= row, cols <= 200$\n* `matrix[i][j]` 为 `'0'` 或 `'1'`", "solution": "### 前缀和 + 单调栈\n\n为了方便,我们令 `matrix` 为 `mat`,记矩阵的行高为 $n$,矩阵的列宽为 $m$。\n\n定义坐标系 : 左上角坐标为 $(1, 1)$,右下角坐标为 $(n, m)$。\n\n我们将 `mat` 的每一行作为基准,以基准线为起点,往上连续 $1$ 的个数为高度。\n\n以题目样例进行说明:\n\n1. 红框部分代表「以第一行作为基准线,统计每一列中基准线及以上连续 $1$ 的个数」,此时只有第一行,可得:$[1, 0, 1, 0, 0]$\n2. 黄框部分代表「以第二行作为基准线,统计每一列中基准线及以上连续 $1$ 的个数」,此时有第一行和第二行,可得:$[2, 0, 2, 1, 1]$\n3. 蓝框部分代表「以第三行作为基准线,统计每一列中基准线及以上连续 $1$ 的个数」,此时有三行,可得:$[3, 1, 3, 2, 2]$\n...\n\n**将原矩阵进行这样的转换好处是 : 对于原矩中面积最大的矩形,其下边缘必然对应了某一条基准线,从而将问题转换为[(题解)84. 柱状图中最大的矩形](https://leetcode.cn/problems/largest-rectangle-in-histogram/solution/by-ac_oier-i470/) 。**\n\n预处理基准线数据可以通过前缀和思想来做,构建一个二维数组 `sum`(为了方便,我们令二维数组下标从 $1$ 开始)并从上往下地构造:\n\n$$\nsum[i][j] = \\begin{cases}\n0 & mat[i][j] = 0 \\\\\nsum[i - 1][j] + 1 & mat[i][j] = 1 \\\\\n\\end{cases}\n$$\n\n当有了 `sum` 之后,则是和 [(题解)84. 柱状图中最大的矩形](https://leetcode.cn/problems/largest-rectangle-in-histogram/solution/by-ac_oier-i470/) 一样的做法 : 枚举高度 + 单调栈。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maximalRectangle(char[][] mat) {\n        int n = mat.length, m = mat[0].length, ans = 0;\n        int[][] sum = new int[n + 10][m + 10];\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                sum[i][j] = mat[i - 1][j - 1] == '0' ? 0 : sum[i - 1][j] + 1;\n            }\n        }\n        int[] l = new int[m + 10], r = new int[m + 10];\n        for (int i = 1; i <= n; i++) {\n            int[] cur = sum[i];\n            Arrays.fill(l, 0); Arrays.fill(r, m + 1);\n            Deque<Integer> d = new ArrayDeque<>();\n            for (int j = 1; j <= m; j++) {\n                while (!d.isEmpty() && cur[d.peekLast()] > cur[j]) r[d.pollLast()] = j;\n                d.addLast(j);\n            }\n            d.clear();\n            for (int j = m; j >= 1; j--) {\n                while (!d.isEmpty() && cur[d.peekLast()] > cur[j]) l[d.pollLast()] = j;\n                d.addLast(j);\n            }\n            for (int j = 1; j <= m; j++) ans = Math.max(ans, cur[j] * (r[j] - l[j] - 1));\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction maximalRectangle(mat: string[][]): number {\n    const n = mat.length, m = mat[0].length\n    const sum = new Array<Array<number>>(n + 10)\n    sum[0] = new Array<number>(m + 10).fill(0)\n    for (let i = 1; i <= n; i++) {\n        sum[i] = new Array<number>(m + 10).fill(0)\n        for (let j = 1; j <= m; j++) {\n            sum[i][j] = mat[i - 1][j - 1] == '0' ? 0 : sum[i - 1][j] + 1\n        }\n    }\n    let ans = 0\n    const l = new Array<number>(m + 10), r = new Array<number>(m + 10)\n    const stk = new Array<number>(m + 10).fill(0)\n    let he = 0, ta = 0\n    for (let i = 1; i <= n; i++) {\n        const cur = sum[i]\n        l.fill(0); r.fill(m + 1)\n        he = ta = 0\n        for (let j = 1; j <= m; j++) {\n            while (he < ta && cur[stk[ta - 1]] > cur[j]) r[stk[--ta]] = j\n            stk[ta++] = j\n        }\n        he = ta = 0\n        for (let j = m; j >= 1; j--) {\n            while (he < ta && cur[stk[ta - 1]] > cur[j]) l[stk[--ta]] = j\n            stk[ta++] = j\n        }\n        for (let j = 1; j <= m; j++) ans = Math.max(ans, cur[j] * (r[j] - l[j] - 1))\n    }\n    return ans\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def maximalRectangle(self, mat: List[List[str]]) -> int:\n        n, m, ans = len(mat), len(mat[0]), 0\n        psum = [[0] * (m + 10) for _ in range(n + 10)]\n        for i in range(1, n + 1):\n            for j in range(1, m + 1):\n                psum[i][j] = 0 if mat[i - 1][j - 1] == '0' else psum[i - 1][j] + 1\n        stk = [0] * (m + 10)\n        he, ta = 0, 0\n        for i in range(1, n + 1):\n            cur = psum[i]\n            l, r = [0] * (m + 10), [m + 1] * (m + 10)\n            he = ta = 0\n            for j in range(1, m + 1):\n                while he < ta and cur[stk[ta - 1]] > cur[j]:\n                    ta -= 1\n                    r[stk[ta]] = j\n                stk[ta] = j\n                ta += 1\n            he = ta = 0\n            for j in range(m, 0, -1):\n                while he < ta and cur[stk[ta - 1]] > cur[j]:\n                    ta -= 1\n                    l[stk[ta]] = j\n                stk[ta] = j\n                ta += 1\n            for j in range(1, m + 1):\n                ans = max(ans, cur[j] * (r[j] - l[j] - 1))\n        return ans\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n \\times m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.85` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/81-90/87. 扰乱字符串（困难）.md", "url_title": "87. 扰乱字符串", "url": "https://leetcode-cn.com/problems/scramble-string/solution/gong-shui-san-xie-yi-ti-san-jie-di-gui-j-hybk/", "difficulty": "困难", "tags": ["DFS", "记忆化搜索", "区间 DP"], "question": "使用下面描述的算法可以扰乱字符串 s 得到字符串 t :\n1. 如果字符串的长度为 1 ,算法停止\n2. 如果字符串的长度 > 1 ,执行下述步骤:\n\t* 在一个随机下标处将字符串分割成两个非空的子字符串。即,如果已知字符串 s ,则可以将其分成两个子字符串 x 和 y ,且满足 s = x + y 。\n\t* 随机 决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即,在执行这一步骤之后,s 可能是 s = x + y 或者 s = y + x 。\n\t* 在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算法。\n给你两个 长度相等 的字符串 s1 和 s2,判断 s2 是否是 s1 的扰乱字符串。如果是,返回 true ;否则,返回 false 。\n\n示例 1:\n```\n输入:s1 = \"great\", s2 = \"rgeat\"\n\n输出:true\n\n解释:s1 上可能发生的一种情形是:\n\"great\" --> \"gr/eat\" // 在一个随机下标处分割得到两个子字符串\n\"gr/eat\" --> \"gr/eat\" // 随机决定:「保持这两个子字符串的顺序不变」\n\"gr/eat\" --> \"g/r / e/at\" // 在子字符串上递归执行此算法。两个子字符串分别在随机下标处进行一轮分割\n\"g/r / e/at\" --> \"r/g / e/at\" // 随机决定:第一组「交换两个子字符串」,第二组「保持这两个子字符串的顺序不变」\n\"r/g / e/at\" --> \"r/g / e/ a/t\" // 继续递归执行此算法,将 \"at\" 分割得到 \"a/t\"\n\"r/g / e/ a/t\" --> \"r/g / e/ a/t\" // 随机决定:「保持这两个子字符串的顺序不变」\n算法终止,结果字符串和 s2 相同,都是 \"rgeat\"\n这是一种能够扰乱 s1 得到 s2 的情形,可以认为 s2 是 s1 的扰乱字符串,返回 true\n```\n示例 2:\n```\n输入:s1 = \"abcde\", s2 = \"caebd\"\n\n输出:false\n```\n示例 3:\n```\n输入:s1 = \"a\", s2 = \"a\"\n\n输出:true\n```\n\n提示:\n\ns1.length == s2.length\n1 <= s1.length <= 30\ns1 和 s2 由小写英文字母组成", "solution": "### 朴素解法(TLE)\n\n一个朴素的做法根据「扰乱字符串」的生成规则进行判断。\n\n由于题目说了整个生成「扰乱字符串」的过程是通过「递归」来进行。\n\n我们要实现 $isScramble$ 函数的作用是判断 $s1$ 是否可以生成出 $s2$。\n\n这样判断的过程,同样我们可以使用「递归」来做:\n\n假设 $s1$ 的长度为 $n$, 的第一次分割的分割点为 $i$,那么 $s1$ 会被分成 $[0, i)$ 和 $[i, n)$ 两部分。\n\n同时由于生成「扰乱字符串」时,可以选交换也可以选不交换。因此我们的 $s2$ 会有两种可能性:\n\n**因为对于某个确定的分割点,$s1$ 固定分为两部分,分别为 $[0,i)$ & $[i, n)$。**\n\n**而 $s2$ 可能会有两种分割方式,分别 $[0,i)$ & $[i,n)$ 和 $[0, n-i)$ & $[n-i,n)$。**\n\n**我们只需要递归调用 $isScramble$ 检查 $s1$ 的 $[0,i)$ & $[i, n)$ 部分能否与 「$s2$ 的 $[0,i)$ & $[i,n)$」 或者 「$s2$ 的 $[0, n-i)$ & $[n-i,n)$」 匹配即可。**\n\n**同时,我们将「$s1$ 和 $s2$ 相等」和「$s1$ 和 $s2$ 词频不同」作为「递归」出口。**\n\n**理解这套做法十分重要,后续的解法都是基于此解法演变过来。**\n\n代码:\n```java []\nclass Solution {\n    public boolean isScramble(String s1, String s2) {\n        if (s1.equals(s2)) return true;\n        if (!check(s1, s2)) return false;\n        int n = s1.length();\n        for (int i = 1; i < n; i++) {\n            // s1 的 [0,i) 和 [i,n)\n            String a = s1.substring(0, i), b = s1.substring(i);\n            // s2 的 [0,i) 和 [i,n)\n            String c = s2.substring(0, i), d = s2.substring(i);\n            if (isScramble(a, c) && isScramble(b, d)) return true;\n            // s2 的 [0,n-i) 和 [n-i,n)\n            String e = s2.substring(0, n - i), f = s2.substring(n - i);\n            if (isScramble(a, f) && isScramble(b, e)) return true;\n        }\n        return false;\n    }\n    // 检查 s1 和 s2 词频是否相同\n    boolean check(String s1, String s2) {\n        if (s1.length() != s2.length()) return false;\n        int n = s1.length();\n        int[] cnt1 = new int[26], cnt2 = new int[26];\n        char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray();\n        for (int i = 0; i < n; i++) {\n            cnt1[cs1[i] - 'a']++;\n            cnt2[cs2[i] - 'a']++;\n        }\n        for (int i = 0; i < 26; i++) {\n            if (cnt1[i] != cnt2[i]) return false;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(5^n)$\n* 空间复杂度:忽略递归与生成子串带来的空间开销,复杂度为 $O(1)$\n\n---\n\n### 记忆化搜索\n\n朴素解法卡在了 $286 / 288$ 个样例。\n\n我们考虑在朴素解法的基础上,增加「记忆化搜索」功能。\n\n我们可以重新设计我们的「爆搜」逻辑:假设 $s1$ 从 $i$ 位置开始,$s2$ 从 $j$ 位置开始,后面的长度为 $len$ 的字符串是否能形成「扰乱字符串」(互为翻转)。\n\n那么在单次处理中,我们可分割的点的范围为 $[1, len)$,然后和「递归」一下,将 $s1$ 分割出来的部分尝试去和 $s2$ 的对应位置匹配。\n\n同样的,我们将「入参对应的子串相等」和「入参对应的子串词频不同」作为「递归」出口。\n\n代码:\n```java []\nclass Solution {\n    String s1; String s2;\n    int n;\n    int[][][] cache;\n    int N = -1, Y = 1, EMPTY = 0;\n    public boolean isScramble(String _s1, String _s2) {\n        s1 = _s1; s2 = _s2;\n        if (s1.equals(s2)) return true;\n        if (s1.length() != s2.length()) return false;\n        n = s1.length();\n        // cache 的默认值是 EMPTY\n        cache = new int[n][n][n + 1];\n        return dfs(0, 0, n);\n    }\n    boolean dfs(int i, int j, int len) {\n        if (cache[i][j][len] != EMPTY) return cache[i][j][len] == Y;\n        String a = s1.substring(i, i + len), b = s2.substring(j, j + len);\n        if (a.equals(b)) {\n            cache[i][j][len] = Y;\n            return true;\n        } \n        if (!check(a, b)) {\n            cache[i][j][len] = N;\n            return false;\n        } \n        for (int k = 1; k < len; k++) {\n            // 对应了「s1 的 [0,i) & [i,n)」匹配「s2 的 [0,i) & [i,n)」\n            if (dfs(i, j, k) && dfs(i + k, j + k, len - k)) {\n                cache[i][j][len] = Y;\n                return true;\n            }\n            // 对应了「s1 的 [0,i) & [i,n)」匹配「s2 的 [n-i,n) & [0,n-i)」\n            if (dfs(i, j + len - k, k) && dfs(i + k, j, len - k)) {\n                cache[i][j][len] = Y;\n                return true;\n            }\n        }\n        cache[i][j][len] = N;\n        return false;\n    }\n    // 检查 s1 和 s2 词频是否相同\n    boolean check(String s1, String s2) {\n        if (s1.length() != s2.length()) return false;\n        int n = s1.length();\n        int[] cnt1 = new int[26], cnt2 = new int[26];\n        char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray();\n        for (int i = 0; i < n; i++) {\n            cnt1[cs1[i] - 'a']++;\n            cnt2[cs2[i] - 'a']++;\n        }\n        for (int i = 0; i < 26; i++) {\n            if (cnt1[i] != cnt2[i]) return false;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n^4)$\n* 空间复杂度:$O(n^3)$\n\n---\n\n### 动态规划(区间 DP)\n\n其实有了上述「记忆化搜索」方案之后,我们就已经可以直接忽略原问题,将其改成「动态规划」了。\n\n**根据「dfs 方法的几个可变入参」作为「状态定义的几个维度」,根据「dfs 方法的返回值」作为「具体的状态值」。**\n\n**我们可以得到状态定义 $f[i][j][len]$:**\n\n**$f[i][j][len]$ 代表 $s1$ 从 $i$ 开始,$s2$ 从 $j$ 开始,后面长度为 $len$ 的字符是否能形成「扰乱字符串」(互为翻转)。**\n\n状态转移方程其实就是翻译我们「记忆化搜索」中的 dfs 主要逻辑部分:\n```java\n    // 对应了「s1 的 [0,i) & [i,n)」匹配「s2 的 [0,i) & [i,n)」\n    if (dfs(i, j, k) && dfs(i + k, j + k, len - k)) {\n        cache[i][j][len] = Y;\n        return true;\n    }\n    // 对应了「s1 的 [0,i) & [i,n)」匹配「s2 的 [n-i,n) & [0,n-i)」\n    if (dfs(i, j + len - k, k) && dfs(i + k, j, len - k)) {\n        cache[i][j][len] = Y;\n        return true;\n    }\n```\n\n**从状态定义上,我们就不难发现这是一个「区间 DP」问题,区间长度大的状态值可以由区间长度小的状态值递推而来。**\n\n**而且由于本身我们在「记忆化搜索」里面就是从小到大枚举 $len$,因此这里也需要先将 $len$ 这层循环提前,确保我们转移 $f[i][j][len]$ 时所需要的状态都已经被计算好。**\n\n代码:\n```java []\nclass Solution {\n    public boolean isScramble(String s1, String s2) {\n        if (s1.equals(s2)) return true;\n        if (s1.length() != s2.length()) return false;\n        int n = s1.length();\n        char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray();\n        boolean[][][] f = new boolean[n][n][n + 1];\n\n        // 先处理长度为 1 的情况\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                f[i][j][1] = cs1[i] == cs2[j];\n            }\n        }\n\n        // 再处理其余长度情况\n        for (int len = 2; len <= n; len++) {\n            for (int i = 0; i <= n - len; i++) {\n                for (int j = 0; j <= n - len; j++) {\n                    for (int k = 1; k < len; k++) {\n                        boolean a = f[i][j][k] && f[i + k][j + k][len - k];\n                        boolean b = f[i][j + len - k][k] && f[i + k][j][len - k];\n                        if (a || b) {\n                            f[i][j][len] = true;\n                        }\n                    }\n                }\n            }\n        }\n        return f[0][0][n];\n    }\n}\n```\n\n* 时间复杂度:$O(n^4)$\n* 空间复杂度:$O(n^3)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.87` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/81-90/88. 合并两个有序数组（简单）.md", "url_title": "88. 合并两个有序数组", "url": "https://leetcode-cn.com/problems/merge-sorted-array/solution/gong-shui-san-xie-yi-ti-san-jie-shuang-z-47gj/", "difficulty": "简单", "tags": ["双指针", "排序"], "question": "给你两个有序整数数组 `nums1` 和 `nums2`,请你将 `nums2` 合并到 `nums1` 中,使 `nums1` 成为一个有序数组。\n\n初始化 `nums1` 和 `nums2` 的元素数量分别为 `m` 和 `n` 。\n\n你可以假设 `nums1` 的空间大小等于 `m + n`,这样它就有足够的空间保存来自 `nums2` 的元素。\n\n示例 1:\n```\n输入:nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3\n\n输出:[1,2,2,3,5,6]\n```\n示例 2:\n```\n输入:nums1 = [1], m = 1, nums2 = [], n = 0\n\n输出:[1]\n```\n\n提示:\n* $nums1.length = m + n$\n* $nums2.length == n$\n* $0 <= m, n <= 200$\n* $1 <= m + n <= 200$\n* $-10^9 <= nums1[i], nums2[i] <= 10^9$", "solution": "### 模拟\n\n最简单的做法,我们可以将 $nums2$ 的内容先搬到 $nums1$ 去,再对 $nums1$ 进行排序。\n\nJava 代码:\n```Java\nclass Solution {\n    public void merge(int[] nums1, int m, int[] nums2, int n) {\n        System.arraycopy(nums2, 0, nums1, m, n);\n        Arrays.sort(nums1);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {\n        copy(nums2.begin(), nums2.end(), nums1.begin() + m);\n        sort(nums1.begin(), nums1.end());\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n        nums1[m:m+n] = nums2\n        nums1.sort()\n```\nTypeScript 代码:\n```TypeScript\nfunction merge(nums1: number[], m: number, nums2: number[], n: number): void {\n    nums1.splice(m, n, ...nums2);\n    nums1.sort((a, b) => a - b);\n};\n```\n* 时间复杂度:$O((m + n)\\log{(m + n)})$\n* 空间复杂度:$O(1)$\n\n**PS. Java 中的 sort 排序是一个综合排序。包含插入/双轴快排/归并/timsort,这里假定 `Arrays.sort` 使用的是「双轴快排」,并忽略递归带来的空间开销。**\n\n---\n\n### 双指针 - 额外空间\n\n上述方法,粗暴地将两个数组结合,再对结果进行排序,没有很好利用俩数组本身有序的特性。\n\n一个容易想到的,可以避免对结果排序的做法是:创建一个和 $nums1$ 等长的数组 $arr$,使用双指针将 $num1$ 和 $nums2$ 的数据迁移到 $arr$,最后再将 $arr$ 复制到 $nums1$ 中。\n\nJava 代码:\n```Java\nclass Solution {\n    public void merge(int[] nums1, int m, int[] nums2, int n) {\n        int total = m + n, idx = 0;\n        int[] arr = new int[total];\n        for (int i = 0, j = 0; i < m || j < n;) {\n            if (i < m && j < n) {\n                arr[idx++] = nums1[i] < nums2[j] ? nums1[i++] : nums2[j++];\n            } else if (i < m) {\n                arr[idx++] = nums1[i++];\n            } else if (j < n) {\n                arr[idx++] = nums2[j++];\n            }\n        }\n        System.arraycopy(arr, 0, nums1, 0, total);\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {\n        int total = m + n, idx = 0;\n        vector<int> arr(total);\n        for (int i = 0, j = 0; i < m || j < n;) {\n            if (i < m && j < n) {\n                arr[idx++] = nums1[i] < nums2[j] ? nums1[i++] : nums2[j++];\n            } else if (i < m) {\n                arr[idx++] = nums1[i++];\n            } else if (j < n) {\n                arr[idx++] = nums2[j++];\n            }\n        }\n        copy(arr.begin(), arr.end(), nums1.begin());\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n        total, idx = m + n, 0\n        arr = [0] * total\n        i, j = 0, 0\n        while i < m or j < n:\n            if i < m and j < n:\n                if nums1[i] < nums2[j]:\n                    arr[idx] = nums1[i]\n                    i += 1\n                else:\n                    arr[idx] = nums2[j]\n                    j += 1\n                idx += 1\n            elif i < m:\n                arr[idx] = nums1[i]\n                idx += 1\n                i += 1\n            elif j < n:\n                arr[idx] = nums2[j]\n                idx += 1\n                j += 1\n\n        for i in range(total):\n            nums1[i] = arr[i]\n```\nTypeScript 代码:\n```TypeScript\nfunction merge(nums1: number[], m: number, nums2: number[], n: number): void {\n    let total = m + n, idx = 0;\n    const arr = new Array(total);\n    for (let i = 0, j = 0; i < m || j < n;) {\n        if (i < m && j < n) {\n            arr[idx++] = nums1[i] < nums2[j] ? nums1[i++] : nums2[j++];\n        } else if (i < m) {\n            arr[idx++] = nums1[i++];\n        } else if (j < n) {\n            arr[idx++] = nums2[j++];\n        }\n    }\n    for (let i = 0; i < total; i++) nums1[i] = arr[i];\n};\n```\n* 时间复杂度:$O(m + n)$\n* 空间复杂度:$O(m + n)$\n\n---\n\n### 双指针 - 原地合并\n\n上述两类做法都不是最优:\n\n* 要么使用到了“排序”操作,时间复杂度带 $\\log$,不是最优\n* 要么使用到了“额外辅助数组”空间,空间复杂度不为 $O(1)$,也不是最优\n\n那么是否有“不排序”且“不消耗额外空间”的原地做法呢?\n\n答案是有的。\n\n**使用两个指针 `i` 和 `j` 分别指向 `nums1` 和 `nums2` 的结尾位置,从后往前地原地构造出答案。**\n\n所谓的原地构造是指:直接将 $nums1[i]$ 和 $nums2[j]$ 之间的较大值,放到合并后该在 `nums1` 出现的位置。\n\n这也是为什么我们要「从后往前」而不是「从前往后」的原因。\n\n使用 `idx` 代表当构造到答案的下标值,起始有 `idx = m + n - 1`(答案是一个长度为 $m + n$ 的数组,因此下标是 $m + n - 1$),根据指针 `i` 和 `j` 所达位置,以及 $nums1[i]$ 和 $nums2[j]$ 大小关系,分情况讨论:\n\n* 若 `i` 和 `j` 任一到达边界,说明其中一个数组已用完,用另一数组的剩余元素进行填充即可\n* 若 `i` 和 `j` 均未到达边界,进一步比较 $nums1[i]$ 和 $nums2[j]$ 的大小关系:\n  * 若 $nums1[i] > nums2[j]$,说明在合并答案中 $nums1[i]$ 出现 $nums2[j]$ 后面,将 $nums1[i]$ 填入到 $nums1[idx]$ 中,让 `idx` 和 `i` 同时前移\n  * 否则,将 $nums2[j]$ 填入到 $nums1[idx]$ 中,让 `idx` 和 `j` 同时前移\n\n直到 `i` 和 `j` 均到达边界,此时合并答案已全部填充到 `nums1` 中。\n\nJava 代码:\n```Java\nclass Solution {\n    public void merge(int[] nums1, int m, int[] nums2, int n) {\n        int i = m - 1, j = n - 1, idx = m + n - 1;\n        while (i >= 0 || j >= 0) {\n            if (i >= 0 && j >= 0) {\n                nums1[idx--] = nums1[i] >= nums2[j] ? nums1[i--] : nums2[j--];\n            } else if (i >= 0) {\n                nums1[idx--] = nums1[i--];\n            } else {\n                nums1[idx--] = nums2[j--];\n            }\n        }\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {\n        int i = m - 1, j = n - 1, idx = m + n - 1;\n        while (i >= 0 || j >= 0) {\n            if (i >= 0 && j >= 0) {\n                nums1[idx--] = nums1[i] >= nums2[j] ? nums1[i--] : nums2[j--];\n            } else if (i >= 0) {\n                nums1[idx--] = nums1[i--];\n            } else {\n                nums1[idx--] = nums2[j--];\n            }\n        }\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n        i, j, idx = m - 1, n - 1, m + n - 1\n        while i >= 0 or j >= 0:\n            if i >= 0 and j >= 0:\n                if nums1[i] > nums2[j]:\n                    nums1[idx] = nums1[i]\n                    i -= 1\n                else:\n                    nums1[idx] = nums2[j]\n                    j -= 1\n                idx -= 1\n            elif i >= 0:\n                nums1[idx] = nums1[i]\n                idx, i = idx - 1, i - 1\n            else:\n                nums1[idx] = nums2[j]\n                idx, j = idx - 1, j - 1\n```\nTypeScript 代码:\n```TypeScript\nfunction merge(nums1: number[], m: number, nums2: number[], n: number): void {\n    let i = m - 1, j = n - 1, idx = m + n - 1;\n    while (i >= 0 || j >= 0) {\n        if (i >= 0 && j >= 0) {\n            nums1[idx--] = nums1[i] >= nums2[j] ? nums1[i--] : nums2[j--];\n        } else if (i >= 0) {\n            nums1[idx--] = nums1[i--];\n        } else {\n            nums1[idx--] = nums2[j--];\n        }\n    }\n};\n```\n* 时间复杂度:$O(m + n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.88` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/81-90/89. 格雷编码（中等）.md", "url_title": "89. 格雷编码", "url": "https://leetcode-cn.com/problems/gray-code/solution/gong-shui-san-xie-dui-cheng-xing-gou-zao-9ap1/", "difficulty": "中等", "tags": ["模拟"], "question": "$n$ 位格雷码序列 是一个由 $2^n$ 个整数组成的序列,其中:\n* 每个整数都在范围 $[0, 2^n - 1]$ 内(含 $0$ 和 $2^n - 1$)\n* 第一个整数是 0\n* 一个整数在序列中出现 不超过一次\n* 每对 相邻 整数的二进制表示 恰好一位不同 ,且\n* 第一个 和 最后一个 整数的二进制表示 恰好一位不同\n\n给你一个整数 `n` ,返回任一有效的 `n` 位格雷码序列 。\n\n示例 1:\n```\n输入:n = 2\n\n输出:[0,1,3,2]\n\n解释:\n[0,1,3,2] 的二进制表示是 [00,01,11,10] 。\n- 00 和 01 有一位不同\n- 01 和 11 有一位不同\n- 11 和 10 有一位不同\n- 10 和 00 有一位不同\n\n[0,2,3,1] 也是一个有效的格雷码序列,其二进制表示是 [00,10,11,01] 。\n- 00 和 10 有一位不同\n- 10 和 11 有一位不同\n- 11 和 01 有一位不同\n- 01 和 00 有一位不同\n```\n示例 2:\n```\n输入:n = 1\n\n输出:[0,1]\n```\n\n提示:\n* `1 <= n <= 16`", "solution": "### 对称性构造\n\n根据格雷码的定义,我们需要构造一个合法序列,序列之间每两个数的二进制表示中只有一位不同,同时序列第一位和最后一位对应的二进制也只有一位不同。\n\n我们知道 $k + 1$ 位的格雷码序列是 $k$ 位格雷码序列长度的两倍,利用合法 $k$ 位格雷码序列,我们可以「对称性」地构造出 $k + 1$ 位格雷码。\n\n具体的,假定 $k$ 位格雷码序列长度为 $n$,我们将这 $k$ 位的格雷序列进行翻转,并追加到原有序列的尾部,得到长度为 $2 * n$ 的序列,此时新序列的前后两部分均为合法的格雷码。\n\n考虑如何进行解决衔接点的合法性:我们可以对于序列的后半(翻转而来)的部分中的每个数进行「尾部」追加 $1$ 的操作,确保链接点的两个数只有有一位二进制位不同,同时并不影响前后两半部分的合法性。\n\n而且由于后半部分本身是由前半部分翻转而来,序列中的第一个数和最后一个数原本为同一个值,经过追加 $1$ 的操作之后,首尾两个数的二进制表示只有一位不同,整个序列的合法性得以保证。\n\n代码:\n```Java\nclass Solution {\n    public List<Integer> grayCode(int n) {\n        List<Integer> ans = new ArrayList<>();\n        ans.add(0);\n        while (n-- > 0) {\n            int m = ans.size();\n            for (int i = m - 1; i >= 0; i--) {\n                ans.set(i, ans.get(i) << 1);\n                ans.add(ans.get(i) + 1);\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(2^n)$\n* 空间复杂度:$O(2^n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.89` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/81-90/90. 子集 II（中等）.md", "url_title": "90. 子集 II", "url": "https://leetcode-cn.com/problems/subsets-ii/solution/gong-shui-san-xie-yi-ti-shuang-jie-hui-s-g77q/", "difficulty": "中等", "tags": ["位运算", "回溯算法", "状态压缩", "DFS"], "question": "给你一个整数数组 `nums`,其中可能包含重复元素,请你返回该数组所有可能的子集(幂集)。\n\n解集 不能 包含重复的子集。返回的解集中,子集可以按 任意顺序 排列。\n\n示例 1:\n```\n输入:nums = [1,2,2]\n\n输出:[[],[1],[1,2],[1,2,2],[2],[2,2]]\n```\n示例 2:\n```\n输入:nums = [0]\n\n输出:[[],[0]]\n```\n\n提示:\n* $1 <= nums.length <= 10$\n* $-10 <= nums[i] <= 10$", "solution": "### 回溯解法(Set)\n\n由于是求所有的方案,而且数据范围只有 $10$,可以直接用爆搜来做。\n\n同时由于答案中不能包含相同的方案,因此我们可以先对原数组进行排序,从而确保所有爆搜出来的方案,都具有单调性,然后配合 `Set` 进行去重。\n\n代码:\n```Java\nclass Solution {\n    public List<List<Integer>> subsetsWithDup(int[] nums) {\n        Arrays.sort(nums);\n        Set<List<Integer>> ans = new HashSet<>();\n        List<Integer> cur = new ArrayList<>();\n        dfs(nums, 0, cur, ans);\n        return new ArrayList<>(ans);\n    }\n\n    /**\n     * @param nums 原输入数组\n     * @param u 当前决策到原输入数组中的哪一位\n     * @param cur 当前方案\n     * @param ans 最终结果集\n     */\n    void dfs(int[] nums, int u, List<Integer> cur, Set<List<Integer>> ans) {\n        // 所有位置都决策完成,将当前方案放入结果集\n        if (nums.length == u) {\n            ans.add(new ArrayList<>(cur));\n            return;\n        }\n\n        // 选择当前位置的元素,往下决策\n        cur.add(nums[u]);\n        dfs(nums, u + 1, cur, ans);\n\n        // 不选当前位置的元素(回溯),往下决策\n        cur.remove(cur.size() - 1);\n        dfs(nums, u + 1, cur, ans);\n    }\n}\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$,爆搜复杂度为 $(2^n)$,每个方案通过深拷贝存入答案,复杂度为 $O(n)$。整体复杂度为 $(n \\times 2^n)$\n* 空间复杂度:总共有 $2^n$ 个方案,每个方案最多占用 $O(n)$ 空间,整体复杂度为 $(n \\times 2^n)$\n\n---\n\n### 回溯解法\n\n我们知道使用 `Set` 虽然是 $O(1)$ 操作,但是只是均摊 $O(1)$。\n\n因此我们来考虑不使用 `Set` 的做法。\n\n我们使用 `Set` 的目的是为了去重,那什么时候会导致的重复呢?\n\n**其实就是相同的元素,不同的决策方案对应同样的结果。**\n\n举个🌰,[1,1,1] 的数据,只选择第一个和只选择第三个(不同的决策方案),结果是一样的。\n\n**因此如果我们希望去重的话,不能单纯的利用「某个下标是否被选择」来进行决策,而是要找到某个数值的连续一段,根据该数值的选择次数类进行决策。**\n\n还是那个🌰,[1,1,1] 的数据,我们可以需要找到数值为 1 的连续一段,然后决策选择 0 次、选择 1 次、选择 2 次 ... 从而确保不会出现重复\n\n**也就是说,将决策方案从「某个下标是否被选择」修改为「相同的数值被选择的个数」。这样肯定不会出现重复,因为 [1,1,1] 不会因为只选择第一个和只选择第三个产生两个 [1] 的方案,只会因为 1 被选择一次,产生一个 [1] 的方案。**\n\n代码:\n```Java\nclass Solution {\n    public List<List<Integer>> subsetsWithDup(int[] nums) {\n        Arrays.sort(nums);\n        List<List<Integer>> ans = new ArrayList<>();\n        List<Integer> cur = new ArrayList<>();\n        dfs(nums, 0, cur, ans);\n        return ans;\n    }\n\n    /**\n     * @param nums 原输入数组\n     * @param u 当前决策到原输入数组中的哪一位\n     * @param cur 当前方案\n     * @param ans 最终结果集\n     */\n    void dfs(int[] nums, int u, List<Integer> cur, List<List<Integer>> ans) {\n        // 所有位置都决策完成,将当前方案放入结果集\n        int n = nums.length;\n        if (n == u) {\n            ans.add(new ArrayList<>(cur));\n            return;\n        }\n\n        // 记录当前位置是什么数值(令数值为 t),并找出数值为 t 的连续一段\n        int t = nums[u];\n        int last = u;\n        while (last < n && nums[last] == nums[u]) last++;\n\n        // 不选当前位置的元素,直接跳到 last 往下决策\n        dfs(nums, last, cur, ans);\n\n        // 决策选择不同个数的 t 的情况:选择 1 个、2 个、3 个 ... k 个\n        for (int i = u; i < last; i++) {\n            cur.add(nums[i]);\n            dfs(nums, last, cur, ans);\n        }\n\n        // 回溯对数值 t 的选择\n        for (int i = u; i < last; i++) {\n            cur.remove(cur.size() - 1);\n        }\n    }\n}\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$,爆搜复杂度为 $(2^n)$,每个方案通过深拷贝存入答案,复杂度为 $O(n)$。整体复杂度为 $(n \\times 2^n)$\n* 空间复杂度:总共有 $2^n$ 个方案,每个方案最多占用 $O(n)$ 空间,整体复杂度为 $(n \\times 2^n)$\n\n---\n\n### 状态压缩(Set)\n\n由于长度只有 10,我们可以使用一个 `int` 的后 $10$ 位来代表每位数组成员是否被选择。\n\n同样,我们也需要先对原数组进行排序,再配合 `Set` 来进行去重。\n\n代码:\n```Java\nclass Solution {\n    public List<List<Integer>> subsetsWithDup(int[] nums) {\n        Arrays.sort(nums);\n        int n = nums.length;\n        Set<List<Integer>> ans = new HashSet<>();\n        List<Integer> cur = new ArrayList<>();\n        \n        // 枚举 i 代表,枚举所有的选择方案状态\n        // 例如 [1,2],我们有 []、[1]、[2]、[1,2] 几种方案,分别对应了 00、10、01、11 几种状态\n        for (int i = 0; i < (1 << n); i++) {\n            cur.clear();\n            // 对当前状态进行诸位检查,如果当前状态为 1 代表被选择,加入当前方案中\n            for (int j = 0; j < n; j++) {\n                int t = (i >> j) & 1;\n                if (t == 1) cur.add(nums[j]);\n            }\n            // 将当前方案中加入结果集\n            ans.add(new ArrayList<>(cur));\n        }\n        return new ArrayList<>(ans);\n    }\n}\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$,爆搜复杂度为 $(2^n)$,每个方案通过深拷贝存入答案,复杂度为 $O(n)$。整体复杂度为 $(n \\times 2^n)$\n* 空间复杂度:总共有 $2^n$ 个方案,每个方案最多占用 $O(n)$ 空间,整体复杂度为 $(n \\times 2^n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.90` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/811-820/811. 子域名访问计数（中等）.md", "url_title": "811. 子域名访问计数", "url": "https://leetcode.cn/problems/subdomain-visit-count/solution/by-ac_oier-aex6/", "difficulty": "中等", "tags": ["模拟", "哈希表"], "question": "网站域名 `\"discuss.leetcode.com\"` 由多个子域名组成。顶级域名为 `\"com\"` ,二级域名为 `\"leetcode.com\"` ,最低一级为 `\"discuss.leetcode.com\"` 。\n\n当访问域名 `\"discuss.leetcode.com\"` 时,同时也会隐式访问其父域名 `\"leetcode.com\"` 以及 `\"com\"` 。\n\n计数配对域名 是遵循 `\"rep d1.d2.d3\"` 或 `\"rep d1.d2\"` 格式的一个域名表示,其中 `rep` 表示访问域名的次数,`d1.d2.d3` 为域名本身。\n\n例如,`\"9001 discuss.leetcode.com\"` 就是一个 计数配对域名 ,表示 `discuss.leetcode.com` 被访问了 `9001` 次。\n\n给你一个 计数配对域名 组成的数组 `cpdomains` ,解析得到输入中每个子域名对应的 计数配对域名 ,并以数组形式返回。可以按 任意顺序 返回答案。\n\n示例 1:\n```\n输入:cpdomains = [\"9001 discuss.leetcode.com\"]\n\n输出:[\"9001 leetcode.com\",\"9001 discuss.leetcode.com\",\"9001 com\"]\n\n解释:例子中仅包含一个网站域名:\"discuss.leetcode.com\"。\n按照前文描述,子域名 \"leetcode.com\" 和 \"com\" 都会被访问,所以它们都被访问了 9001 次。\n```\n示例 2:\n```\n输入:cpdomains = [\"900 google.mail.com\", \"50 yahoo.com\", \"1 intel.mail.com\", \"5 wiki.org\"]\n\n输出:[\"901 mail.com\",\"50 yahoo.com\",\"900 google.mail.com\",\"5 wiki.org\",\"5 org\",\"1 intel.mail.com\",\"951 com\"]\n\n解释:按照前文描述,会访问 \"google.mail.com\" 900 次,\"yahoo.com\" 50 次,\"intel.mail.com\" 1 次,\"wiki.org\" 5 次。\n而对于父域名,会访问 \"mail.com\" 900 + 1 = 901 次,\"com\" 900 + 50 + 1 = 951 次,和 \"org\" 5 次。\n```\n\n提示:\n* $1 <= cpdomain.length <= 100$\n* $1 <= cpdomain[i].length <= 100$\n* `cpdomain[i]` 会遵循 `\"repi d1i.d2i.d3i\"` 或 `\"repi d1i.d2i\"` 格式\n* `repi` 是范围 $[1, 10^4]$ 内的一个整数\n* $d1_i$、$d2_i$ 和 $d3_i$ 由小写英文字母组成", "solution": "### 哈希表\n\n为了方便,我们令 `cpdomains` 为 `ss`。\n\n根据题意进行模拟:使用哈希表记录每个域名的总访问次数,从前往后处理所有的 $ss[i]$。在处理某个 $ss[i]$ 时(记长度为 $n$,使用指针 `idx` 代指扫描到的游标位置),先通过指针扫描找到访问数字部分 `cnt = ss[i][0:idx]`,然后「从后往前」处理 $ss[i]$ 的 $[idx + 1, n - 1]$ 部分,按照域名层级「从小到大」的顺序进行截取,并累加访问次数 `cnt` 到当前域名。\n\n最后根据哈希表构造答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public List<String> subdomainVisits(String[] ss) {\n        Map<String, Integer> map = new HashMap<>();\n        for (String s : ss) {\n            int n = s.length(), idx = 0;\n            while (idx < n && s.charAt(idx) != ' ') idx++;\n            int cnt = Integer.parseInt(s.substring(0, idx));\n            int start = idx + 1; idx = n - 1;\n            while (idx >= start) {\n                while (idx >= start && s.charAt(idx) != '.') idx--;\n                String cur = s.substring(idx + 1);\n                map.put(cur, map.getOrDefault(cur, 0) + cnt);\n                idx--;\n            }\n        }\n        List<String> ans = new ArrayList<>();\n        for (String key : map.keySet()) ans.add(map.get(key) + \" \" + key);\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction subdomainVisits(ss: string[]): string[] {\n    const map = new Map<string, number>()\n    for (const s of ss) {\n        let n = s.length, idx = 0\n        while (idx < n && s[idx] != ' ') idx++\n        const cnt = Number(s.substring(0, idx))\n        const start = idx + 1; idx = n - 1\n        while (idx >= start) {\n            while (idx >= start && s[idx] != '.') idx--\n            const cur = s.substring(idx + 1)\n            if (!map.has(cur)) map.set(cur, 0)\n            map.set(cur, map.get(cur) + cnt)\n            idx--\n        }\n    }\n    const ans = new Array<string>()\n    for (const key of map.keys()) ans.push(map.get(key) + \" \" + key)\n    return ans\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def subdomainVisits(self, ss: List[str]) -> List[str]:\n        mapping = defaultdict(int)\n        for s in ss:\n            n, idx = len(s), 0\n            while idx < n and s[idx] != ' ':\n                idx += 1\n            cnt = int(s[:idx])\n            start, idx = idx + 1, n - 1\n            while idx >= start:\n                while idx >= start and s[idx] != '.':\n                    idx -= 1\n                mapping[s[idx + 1:]] += cnt\n                idx -= 1\n        return [f'{v} {k}' for k, v in mapping.items()]\n```\n* 时间复杂度:$O(\\sum_{i = 0}^{n - 1}len(ss[i]))$\n* 空间复杂度:$O(\\sum_{i = 0}^{n - 1}len(ss[i]))$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.811` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/811-820/812. 最大三角形面积（简单）.md", "url_title": "812. 最大三角形面积", "url": "https://leetcode.cn/problems/largest-triangle-area/solution/by-ac_oier-htv8/", "difficulty": "简单", "tags": ["模拟"], "question": "给定包含多个点的集合,从其中取三个点组成三角形,返回能组成的最大三角形的面积。\n\n示例:\n```\n输入: points = [[0,0],[0,1],[1,0],[0,2],[2,0]]\n\n输出: 2\n\n解释: \n这五个点如下图所示。组成的橙色三角形是最大的,面积为2。\n```\n\n注意:\n* $3 <= points.length <= 50.$\n* 不存在重复的点。\n* $-50 <= points[i][j] <= 50$\n* 结果误差值在 $10^{-6}$ 以内都认为是正确答案。", "solution": "### 模拟\n\n根据题意模拟即可:枚举三角形三个顶点并计算面积。\n\n代码:\n```Java\nclass Solution {\n    public double largestTriangleArea(int[][] ps) {\n        int n = ps.length;\n        double ans = 0;\n        for (int i = 0; i < n; i++) {\n            for (int j = i + 1; j < n; j++) {\n                for (int k = j + 1; k < n; k++) {\n                    int cur = cross(ps[j][0] - ps[i][0], ps[j][1] - ps[i][1], ps[k][0] - ps[i][0], ps[k][1] - ps[i][1]);\n                    ans = Math.max(ans, Math.abs(cur / 2.0)); \n                }\n            }\n        }\n        return ans;\n    }\n    int cross(int a, int b, int c, int d) {\n        return a * d - c * b;\n    }\n}\n```\n* 时间复杂度:$O(n^3)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.812` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/811-820/813. 最大平均值和的分组（中等）.md", "url_title": "813. 最大平均值和的分组", "url": "https://leetcode.cn/problems/largest-sum-of-averages/solution/by-ac_oier-yfnt/", "difficulty": "中等", "tags": ["序列 DP", "前缀和", "动态规划", "数学"], "question": "给定数组 `nums` 和一个整数 `m` 。\n\n我们将给定的数组 `nums` 分成最多 `m` 个相邻的非空子数组,分数由每个子数组内的平均值的总和构成。\n\n注意我们必须使用 `nums` 数组中的每一个数进行分组,并且分数不一定需要是整数。\n\n返回我们所能得到的最大分数是多少。\n\n答案误差在 $10^{-6}$ 内被视为是正确的。\n\n示例 1:\n```\n输入: nums = [9,1,2,3,9], m = 3\n\n输出: 20.00000\n\n解释: \nnums 的最优分组是[9], [1, 2, 3], [9]. 得到的分数是 9 + (1 + 2 + 3) / 3 + 9 = 20. \n我们也可以把 nums 分成[9, 1], [2], [3, 9]. \n这样的分组得到的分数为 5 + 2 + 6 = 13, 但不是最大值.\n```\n示例 2:\n```\n输入: nums = [1,2,3,4,5,6,7], m = 4\n\n输出: 20.50000\n```\n\n提示:\n* $1 <= nums.length <= 100$\n* $1 <= nums[i] <= 10^4$", "solution": "### 前缀和 + 序列 DP\n\n题意可整理为一句话:将 $n$ 个元素划分为「最多」$m$ 个连续段,最大化连续段的平均值之和。\n\n为了方便,我们令所有数组下标从 $1$ 开始。\n\n定义 $f[i][j]$ 为考虑将前 $i$ 个元素划分成 $j$ 份的最大平均和,答案为 $f[n][k]$,其中 $1 \\leq k \\leq m$。\n\n不失一般性考虑 $f[i][j]$ 该如何计算,由于划分出来的子数组不能是空集,因此我们可以根据 $j$ 的大小分情况讨论:\n\n* 当 $j = 1$,此时有 $f[i][j] = \\frac{\\sum_{idx = 1}^{i} nums[idx - 1]}{i}$\n* 当 $j > 1$,此时枚举最后一个子数组的起点 $k$,其中 $2 \\leq k \\leq i$,此时有平均值之和为 $f[k - 1][j - 1] + \\frac{\\sum_{idx = k}^{i} nums[idx]}{i - k + 1}$,最终 $f[i][j]$ 为枚举所有 $k$ 值的最大值\n\n其中求解连续段之和可以用「前缀和」进行优化。同时,想要简化代码,还可以利用一个简单的数学结论:划分份数越多,平均值之和越大,因此想要取得最大值必然是恰好划分成 $m$ 份。\n\nJava 代码:\n```Java\nclass Solution {\n    public double largestSumOfAverages(int[] nums, int m) {\n        int n = nums.length;\n        double[] sum = new double[n + 10];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n        double[][] f = new double[n + 10][m + 10];\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= Math.min(i, m); j++) {\n                if (j == 1) {\n                    f[i][1] = sum[i] / i;\n                } else {\n                    for (int k = 2; k <= i; k++) {\n                        f[i][j] = Math.max(f[i][j], f[k - 1][j - 1] + (sum[i] - sum[k - 1]) / (i - k + 1));\n                    }\n                }\n            }\n        }\n        return f[n][m];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    double largestSumOfAverages(vector<int>& nums, int m) {\n        int n = nums.size();\n        vector<double> sum(n + 10, 0);\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n        vector<vector<double>> f(n + 10, vector<double>(m + 10, 0));\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= min(i, m); j++) {\n                if (j == 1) {\n                    f[i][j] = sum[i] / i;\n                } else {\n                    for (int k = 2; k <= i; k++) {\n                        f[i][j] = max(f[i][j], f[k - 1][j - 1] + (sum[i] - sum[k - 1]) / (i - k + 1));\n                    }\n                }\n            }\n        }\n        return f[n][m];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def largestSumOfAverages(self, nums: List[int], m: int) -> float:\n        n = len(nums)\n        psum = [0] * (n + 10)\n        for i in range(1, n + 1):\n            psum[i] = psum[i - 1] + nums[i - 1]\n        f = [[0] * (m + 10) for _ in range(n + 10)]\n        for i in range(1, n + 1):\n            for j in range(1, min(i, m) + 1):\n                if j == 1:\n                    f[i][j] = psum[i] / i\n                else:\n                    for k in range(2, i + 1):\n                        f[i][j] = max(f[i][j], f[k - 1][j - 1] + (psum[i] - psum[k - 1]) / (i - k + 1))\n        return f[n][m]\n```\nTypeScript 代码:\n```TypeScript\nfunction largestSumOfAverages(nums: number[], m: number): number {\n    const n = nums.length\n    const sum = new Array<number>(n + 10).fill(0)\n    for (let i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1]\n    const f = new Array<Array<number>>()\n    for (let i = 0; i < n + 10; i++) f[i] = new Array<number>(m + 10).fill(0)\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= Math.min(i, m); j++) {\n            if (j == 1) {\n                f[i][j] = sum[i] / i\n            } else {\n                for (let k = 2; k <= i; k++) {\n                    f[i][j] = Math.max(f[i][j], f[k - 1][j - 1] + (sum[i] - sum[k - 1]) / (i - k + 1))\n                }\n            }\n        }\n    }\n    return f[n][m]\n}\n```\n* 时间复杂度:$O(n^2 \\times m)$\n* 空间复杂度:$O(n \\times m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.813` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/811-820/814. 二叉树剪枝（中等）.md", "url_title": "814. 二叉树剪枝", "url": "https://leetcode.cn/problems/binary-tree-pruning/solution/by-ac_oier-7me9/", "difficulty": "中等", "tags": ["二叉树", "DFS", "递归"], "question": "给你二叉树的根结点 `root`,此外树的每个结点的值要么是 $0$ ,要么是 $1$ 。\n\n返回移除了所有不包含 $1$ 的子树的原二叉树。\n\n节点 `node` 的子树为 `node` 本身加上所有 `node` 的后代。\n\n示例 1:\n\n```\n输入:root = [1,null,0,0,1]\n\n输出:[1,null,0,null,1]\n\n解释:\n只有红色节点满足条件“所有不包含 1 的子树”。 右图为返回的答案。\n```\n示例 2:\n\n```\n输入:root = [1,0,1,0,0,0,1]\n\n输出:[1,null,1,null,1]\n```\n示例 3:\n\n```\n输入:root = [1,1,0,1,1,0,1,0]\n\n输出:[1,1,0,1,1,null,1]\n```\n\n提示:\n* 树中节点的数目在范围 $[1, 200]$ 内\n* `Node.val` 为 $0$ 或 $1$", "solution": "### 递归\n\n根据题意,我们将原函数 `pruneTree` 作为递归函数,递归函数的含义为「将入参 `root` 中的所有不包含 $1$ 的子树移除,并返回新树头结点」。\n\n不失一般性的考虑任意节点作为入参该如何处理:我们可以递归处理左右子树,并将新左右子树重新赋值给 `root`。由于当前节点 `root` 的左右子树可能为空树,因此我们要增加递归函数入参为空的边界处理。\n\n当递归操作完成后,若左右节点任一值不为空(说明当前节点 `root` 不为叶子节点),我们可以直接返回 `root`,否则根据 `root` 的值是否为 $0$ 来决定返回空树还是 `root` 本身。\n\nJava 代码:\n```Java\nclass Solution {\n    public TreeNode pruneTree(TreeNode root) {\n        if (root == null) return null;\n        root.left = pruneTree(root.left);\n        root.right = pruneTree(root.right);\n        if (root.left != null || root.right != null) return root;\n        return root.val == 0 ? null : root;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction pruneTree(root: TreeNode | null): TreeNode | null {\n    if (root == null) return null\n    root.left = pruneTree(root.left)\n    root.right = pruneTree(root.right)\n    if (root.left != null || root.right != null) return root\n    return root.val == 0 ? null : root\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.814` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/811-820/815. 公交路线（困难）.md", "url_title": "815. 公交路线", "url": "https://leetcode-cn.com/problems/bus-routes/solution/gong-shui-san-xie-yi-ti-shuang-jie-po-su-1roh/", "difficulty": "困难", "tags": ["图论 BFS", "双向 BFS", "图论搜索"], "question": "给你一个数组 `routes` ,表示一系列公交线路,其中每个 `routes[i]` 表示一条公交线路,第 `i` 辆公交车将会在上面循环行驶。\n\n* 例如,路线 `routes[0] = [1, 5, 7]` 表示第 0 辆公交车会一直按序列 `1 -> 5 -> 7 -> 1 -> 5 -> 7 -> 1 -> ...` 这样的车站路线行驶。\n\n现在从 `source` 车站出发(初始时不在公交车上),要前往 `target` 车站。 期间仅可乘坐公交车。\n\n求出 最少乘坐的公交车数量 。如果不可能到达终点车站,返回 `-1` 。\n\n示例 1:\n```\n输入:routes = [[1,2,7],[3,6,7]], source = 1, target = 6\n\n输出:2\n\n解释:最优策略是先乘坐第一辆公交车到达车站 7 , 然后换乘第二辆公交车到车站 6 。 \n```\n示例 2:\n```\n输入:routes = [[7,12],[4,5,15],[6],[15,19],[9,12,13]], source = 15, target = 12\n\n输出:-1\n```\n\n提示:\n* 1 <= routes.length <= 500.\n* 1 <= routes[i].length <= $10^5$\n* routes[i] 中的所有值 互不相同\n* sum(routes[i].length) <= $10^5$\n* 0 <= routes[i][j] < $10^6$\n* 0 <= source, target < $10^6$", "solution": "### 基本分析\n\n为了方便,我们令每个公交站为一个「车站」,由一个「车站」可以进入一条或多条「路线」。\n\n问题为从「起点车站」到「终点车站」,所进入的最少路线为多少。\n\n抽象每个「路线」为一个点,当不同「路线」之间存在「公共车站」则为其增加一条边权为 $1$ 的无向边。\n\n---\n\n### 单向 BFS\n\n由于是在边权为 $1$ 的图上求最短路,我们直接使用 `BFS` 即可。\n\n起始时将「起点车站」所能进入的「路线」进行入队,每次从队列中取出「路线」时,查看该路线是否包含「终点车站」:\n\n* 包含「终点车站」:返回进入该线路所花费的距离\n* 不包含「终点车站」:遍历该路线所包含的车站,将由这些车站所能进入的路线,进行入队\n\n一些细节:由于是求最短路,同一路线重复入队是没有意义的,因此将新路线入队前需要先判断是否曾经入队。\n\n代码:\n```Java\nclass Solution {\n    int s, t;\n    int[][] rs;\n    public int numBusesToDestination(int[][] _rs, int _s, int _t) {\n        rs = _rs; s = _s; t = _t;\n        if (s == t) return 0;\n        int ans = bfs();\n        return ans;\n    }\n    int bfs() {\n        // 记录某个车站可以进入的路线\n        Map<Integer, Set<Integer>> map = new HashMap<>();\n        // 队列存的是经过的路线\n        Deque<Integer> d = new ArrayDeque<>();\n        // 哈希表记录的进入该路线所使用的距离\n        Map<Integer, Integer> m = new HashMap<>();\n        int n = rs.length;\n        for (int i = 0; i < n; i++) {\n            for (int station : rs[i]) {\n                // 将从起点可以进入的路线加入队列\n                if (station == s) {\n                    d.addLast(i);\n                    m.put(i, 1);\n                }\n                Set<Integer> set = map.getOrDefault(station, new HashSet<>());\n                set.add(i);\n                map.put(station, set);\n            }\n        }\n        while (!d.isEmpty()) {\n            // 取出当前所在的路线,与进入该路线所花费的距离\n            int poll = d.pollFirst();\n            int step = m.get(poll);\n\n            // 遍历该路线所包含的车站\n            for (int station : rs[poll]) {\n                // 如果包含终点,返回进入该路线花费的距离即可\n                if (station == t) return step;\n\n                // 将由该线路的车站发起的路线,加入队列\n                Set<Integer> lines = map.get(station);\n                if (lines == null) continue;\n                for (int nr : lines) {\n                    if (!m.containsKey(nr)) {\n                        m.put(nr, step + 1);\n                        d.add(nr);\n                    }\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:令路线的数量为 $n$,车站的数量为 $m$。建图的时间复杂度为 $O(\\sum_{i=0}^{n-1} len(rs[i]))$;`BFS` 部分每个路线只会入队一次,最坏情况下每个路线都包含所有车站,复杂度为 $O(n * m)$。整体复杂度为 $O(n * m + \\sum_{i=0}^{n-1} len(rs[i]))$。\n* 空间复杂度:$O(n * m)$\n\n---\n\n### 双向 BFS(并查集预处理无解情况)\n\n另外一个做法是使用双向 `BFS`。\n\n首先建图方式不变,将「起点」和「终点」所能进入的路线分别放入两个方向的队列,如果「遇到公共的路线」或者「当前路线包含了目标位置」,说明找到了最短路径。\n\n另外我们知道,双向 `BFS` 在无解的情况下不如单向 `BFS`。因此我们可以先使用「并查集」进行预处理,判断「起点」和「终点」是否连通,如果不联通,直接返回 $-1$,有解才调用双向 `BFS`。\n\n由于使用「并查集」预处理的复杂度与建图是近似的,增加这样的预处理并不会越过我们时空复杂度的上限,因此这样的预处理是有益的。一定程度上可以最大化双向 `BFS` 减少搜索空间的效益。\n\n代码:\n```Java\nclass Solution {\n    static int N = (int)1e6+10;\n    static int[] p = new int[N];\n    int find(int x) {\n        if (p[x] != x) p[x] = find(p[x]);\n        return p[x];\n    }\n    void union(int a, int b) {\n        p[find(a)] = p[find(b)];\n    }\n    boolean query(int a, int b) {\n        return find(a) == find(b);\n    }\n    int s, t;\n    int[][] rs;\n    public int numBusesToDestination(int[][] _rs, int _s, int _t) {\n        rs = _rs; s = _s; t = _t;\n        if (s == t) return 0;\n        for (int i = 0; i < N; i++) p[i] = i;\n        for (int[] r : rs) {\n            for (int loc : r) {\n                union(loc, r[0]);\n            }\n        }\n        if (!query(s, t)) return -1;\n        int ans = bfs();\n        return ans;\n    }\n    // 记录某个车站可以进入的路线\n    Map<Integer, Set<Integer>> map = new HashMap<>();\n    int bfs() {\n        Deque<Integer> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();\n        Map<Integer, Integer> m1 = new HashMap<>(), m2 = new HashMap<>();\n        \n        int n = rs.length;\n        for (int i = 0; i < n; i++) {\n            for (int station : rs[i]) {\n                // 将从起点可以进入的路线加入正向队列\n                if (station == s) {\n                    d1.addLast(i);\n                    m1.put(i, 1);\n                }\n                // 将从终点可以进入的路线加入反向队列\n                if (station == t) {\n                    d2.addLast(i);\n                    m2.put(i, 1);\n                }\n                Set<Integer> set = map.getOrDefault(station, new HashSet<>());\n                set.add(i);\n                map.put(station, set);\n            }\n        }\n\n        // 如果「起点所发起的路线」和「终点所发起的路线」有交集,直接返回 1\n        Set<Integer> s1 = map.get(s), s2 = map.get(t);\n        Set<Integer> tot = new HashSet<>();\n        tot.addAll(s1);\n        tot.retainAll(s2);\n        if (!tot.isEmpty()) return 1;\n\n        // 双向 BFS\n        while (!d1.isEmpty() && !d2.isEmpty()) {\n            int res = -1;\n            if (d1.size() <= d2.size()) {\n                res = update(d1, m1, m2);\n            } else {\n                res = update(d2, m2, m1);\n            }\n            if (res != -1) return res;\n        }\n\n        return 0x3f3f3f3f; // never\n    }\n    int update(Deque<Integer> d, Map<Integer, Integer> cur, Map<Integer, Integer> other) {\n        int m = d.size();\n        while (m-- > 0) {\n            // 取出当前所在的路线,与进入该路线所花费的距离\n            int poll = d.pollFirst();\n            int step = cur.get(poll);\n\n            // 遍历该路线所包含的车站\n            for (int station : rs[poll]) {\n                // 遍历将由该线路的车站发起的路线\n                Set<Integer> lines = map.get(station);\n                if (lines == null) continue;\n                for (int nr : lines) {\n                    if (cur.containsKey(nr)) continue;\n                    if (other.containsKey(nr)) return step + other.get(nr);\n                    cur.put(nr, step + 1);\n                    d.add(nr);\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:令路线的数量为 $n$,车站的个数为 $m$。并查集和建图的时间复杂度为 $O(\\sum_{i=0}^{n-1} len(rs[i]))$;`BFS` 求最短路径的复杂度为 $O(n * m)$。整体复杂度为 $O(n * m + \\sum_{i=0}^{n-1} len(rs[i]))$。\n* 空间复杂度:$O(n * m + \\sum_{i=0}^{n-1} len(rs[i]))$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.815` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/811-820/816. 模糊坐标（中等）.md", "url_title": "816. 模糊坐标", "url": "https://leetcode.cn/problems/ambiguous-coordinates/solution/by-ac_oier-sbxl/", "difficulty": "中等", "tags": ["枚举", "模拟"], "question": "我们有一些二维坐标,如 `\"(1, 3)\"` 或 `\"(2, 0.5)\"`,然后我们移除所有逗号,小数点和空格,得到一个字符串 `S`。返回所有可能的原始字符串到一个列表中。\n\n原始的坐标表示法不会存在多余的零,所以不会出现类似于 `\"00\", \"0.0\", \"0.00\", \"1.0\", \"001\", \"00.01\"` 或一些其他更小的数来表示坐标。\n\n此外,一个小数点前至少存在一个数,所以也不会出现 `“.1”` 形式的数字。\n\n最后返回的列表可以是任意顺序的。而且注意返回的两个数字中间(逗号之后)都有一个空格。\n\n示例 1:\n```\n输入: \"(123)\"\n\n输出: [\"(1, 23)\", \"(12, 3)\", \"(1.2, 3)\", \"(1, 2.3)\"]\n```\n示例 2:\n```\n输入: \"(00011)\"\n\n输出:  [\"(0.001, 1)\", \"(0, 0.011)\"]\n\n解释: \n0.0, 00, 0001 或 00.01 是不被允许的。\n```\n示例 3:\n```\n输入: \"(0123)\"\n\n输出: [\"(0, 123)\", \"(0, 12.3)\", \"(0, 1.23)\", \"(0.1, 23)\", \"(0.1, 2.3)\", \"(0.12, 3)\"]\n```\n示例 4:\n```\n输入: \"(100)\"\n\n输出: [(10, 0)]\n\n解释: \n1.0 是不被允许的。\n```\n\n提示:\n* $4 <= S.length <= 12$\n* `S[0] = \"(\", S[S.length - 1] = \")\"`, 且字符串 `S` 中的其他元素都是数字。", "solution": "### 枚举\n\n我们先将原字符串 `s` 中的左右括号去掉,重新定义 `s` 为原字符串 $s[1...(n - 2)]$,重新定义后的 `s` 长度为 `n`。\n\n随后枚举逗号的位置 `idx`,枚举范围为 $[0, n - 1)$,含义为在 $s[idx]$ 后面追加逗号。\n\n此时左边部分字符串为 $s[0, idx]$,右边部分字符串为 $s[idx + 1, n - 1]$。\n\n实现一个搜索函数 `List<String> search(int start, int end)`,该函数返回使用字符串 $s[start...end]$ 构造的具体数值集合。\n\n假设左边字符串 $s[0, idx]$ 搜索结果为 `A`,右边字符串 $s[idx + 1, n - 1]$ 搜索结果为 `B`,根据「乘法原理」,可知所有实际方案为 `(x, y)` 其中 $x \\in A$,$y \\in B$。\n\n考虑如何实现 `search` 函数(假设入参函数 `start` 和 `end` 对应的子串为 `sub`):枚举字符串追加小数点的位置 `idx`,枚举范围为 $[start, end - 1)$,含义为在 $sub[idx]$ 后面追加小数点。小数点前面的部分不能包含前导零,小数点后面的部分不能包含后导零。注意记得把不添加小数点的合法方案也存入搜索集合。\n\nJava 代码:\n```Java\nclass Solution {\n    String s;\n    public List<String> ambiguousCoordinates(String _s) {\n        s = _s.substring(1, _s.length() - 1);\n        int n = s.length();\n        List<String> ans = new ArrayList<>();\n        for (int i = 0; i < n - 1; i++) { // 枚举逗号:在 i 的后面追加逗号\n            List<String> a = search(0, i), b = search(i + 1, n - 1);\n            for (String x : a) {\n                for (String y : b) {\n                    ans.add(\"(\" + x + \", \" + y + \")\");\n                }\n            }\n        }\n        return ans;\n    }\n    List<String> search(int start, int end) {\n        List<String> ans = new ArrayList<>();\n        if (start == end || s.charAt(start) != '0') ans.add(s.substring(start, end + 1));\n        for (int i = start; i < end; i++) { // 枚举小数点:在 i 后面追加小数点\n            String a = s.substring(start, i + 1), b = s.substring(i + 1, end + 1);\n            if (a.length() > 1 && a.charAt(0) == '0') continue;\n            if (b.charAt(b.length() - 1) == '0') continue;\n            ans.add(a + \".\" + b);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    string s;\n    vector<string> ambiguousCoordinates(string _s) {\n        s = _s.substr(1, _s.size() - 2);\n        int n = s.size();\n        vector<string> ans;\n        for (int i = 0; i < n - 1; i++) {\n            vector<string> a = search(0, i), b = search(i + 1, n - 1);\n            for (auto &x : a) {\n                for (auto &y : b) {\n                    ans.push_back(\"(\" + x + \", \" + y + \")\");\n                }\n            }\n        }\n        return ans;\n    }\n    vector<string> search(int start, int end) {\n        vector<string> ans;\n        if (start == end || s[start] != '0') ans.push_back(s.substr(start, end - start + 1));\n        for (int i = start; i < end; i++) {\n            string a = s.substr(start, i - start + 1), b = s.substr(i + 1, end - i);\n            if (a.size() > 1 && a[0] == '0') continue;\n            if (b.back() == '0') continue;\n            ans.push_back(a + \".\" + b);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def ambiguousCoordinates(self, _s: str) -> List[str]:\n        def search(s, start, end):\n            ans = []\n            if start == end or s[start] != '0':\n                ans.append(s[start:end+1])\n            for i in range(start, end):\n                a, b = s[start:i+1], s[i+1:end+1]\n                if len(a) > 1 and a[0] == '0':\n                    continue\n                if b[-1] == '0':\n                    continue\n                ans.append(f'{a}.{b}')\n            return ans\n        s = _s[1:len(_s)-1]\n        n = len(s)\n        ans = []\n        for i in range(n - 1):\n            a, b = search(s, 0, i), search(s, i + 1, n - 1)\n            for x in a:\n                for y in b:\n                    ans.append(f'({x}, {y})')\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction ambiguousCoordinates(_s: string): string[] {\n    function search(s: string, start: number, end: number): string[] {\n        const ans = new Array<string>()\n        if (start == end || s[start] != '0') ans.push(s.substring(start, end + 1))\n        for (let i = start; i < end; i++) {\n            const a = s.substring(start, i + 1), b = s.substring(i + 1, end + 1)\n            if (a.length > 1 && a[0] == '0') continue\n            if (b[b.length - 1] == '0') continue\n            ans.push(a + '.' + b)\n        }\n        return ans\n    }\n    const s = _s.substring(1, _s.length - 1)\n    const n = s.length\n    const ans = new Array<string>()\n    for (let i = 0; i < n - 1; i++) {\n        const a = search(s, 0, i), b = search(s, i + 1, n - 1)\n        for (const x of a) {\n            for (const y of b) {\n                ans.push('(' + x + ', ' + y + ')')\n            }\n        }\n    }\n    return ans\n}\n```\n* 时间复杂度:$O(n^3)$\n* 空间复杂度:$O(n^3)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.816` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/811-820/817. 链表组件（中等）.md", "url_title": "817. 链表组件", "url": "https://leetcode.cn/problems/linked-list-components/solution/by-ac_oier-3gl5/", "difficulty": "中等", "tags": ["链表", "模拟", "哈希表"], "question": "给定链表头结点 `head`,该链表上的每个结点都有一个 唯一的整型值 。同时给定列表 `nums`,该列表是上述链表中整型值的一个子集。\n\n返回列表 `nums` 中组件的个数,这里对组件的定义为:链表中一段最长连续结点的值(该值必须在列表 `nums` 中)构成的集合。\n\n示例 1:\n\n```\n输入: head = [0,1,2,3], nums = [0,1,3]\n\n输出: 2\n\n解释: 链表中,0 和 1 是相连接的,且 nums 中不包含 2,所以 [0, 1] 是 nums 的一个组件,同理 [3] 也是一个组件,故返回 2。\n```\n示例 2:\n \n```\n输入: head = [0,1,2,3,4], nums = [0,3,1,4]\n\n输出: 2\n\n解释: 链表中,0 和 1 是相连接的,3 和 4 是相连接的,所以 [0, 1] 和 [3, 4] 是两个组件,故返回 2。\n```\n\n提示:\n* 链表中节点数为 `n`\n* $1 <= n <= 10^4$\n* $0 <= Node.val < n$\n* `Node.val` 中所有值 不同\n* $1 <= nums.length <= n$\n* $0 <= nums[i] < n$\n* `nums` 中所有值 不同", "solution": "### 模拟\n\n根据题意进行模拟即可 : 为了方便判断某个 $node.val$ 是否存在于 `nums` 中,我们先使用 `Set` 结构对所有的 $nums[i]$ 进行转存,随后每次检查连续段(组件)的个数。\n\nJava 代码:\n```Java\nclass Solution {\n    public int numComponents(ListNode head, int[] nums) {\n        int ans = 0;\n        Set<Integer> set = new HashSet<>();\n        for (int x : nums) set.add(x);\n        while (head != null) {\n            if (set.contains(head.val)) {\n                while (head != null && set.contains(head.val)) head = head.next;\n                ans++;\n            } else {\n                head = head.next;\n            }\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction numComponents(head: ListNode | null, nums: number[]): number {\n    let ans = 0\n    const set = new Set<number>()\n    for (const x of nums) set.add(x)\n    while (head != null) {\n        if (set.has(head.val)) {\n            while (head != null && set.has(head.val)) head = head.next\n            ans++\n        } else {\n            head = head.next\n        }\n    }\n    return ans\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def numComponents(self, head: Optional[ListNode], nums: List[int]) -> int:\n        ans = 0\n        nset = set([x for x in nums])\n        while head:\n            if head.val in nset:\n                while head and head.val in nset:\n                    head = head.next\n                ans += 1\n            else:\n                head = head.next\n        return ans\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.817` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/811-820/819. 最常见的单词（简单）.md", "url_title": "819. 最常见的单词", "url": "https://leetcode-cn.com/problems/most-common-word/solution/by-ac_oier-6aqd/", "difficulty": "简单", "tags": ["模拟", "哈希表"], "question": "给定一个段落 (`paragraph`) 和一个禁用单词列表 (`banned`)。返回出现次数最多,同时不在禁用列表中的单词。\n\n题目保证至少有一个词不在禁用列表中,而且答案唯一。\n\n禁用列表中的单词用小写字母表示,不含标点符号。段落中的单词不区分大小写。答案都是小写字母。\n\n示例:\n```\n输入: \nparagraph = \"Bob hit a ball, the hit BALL flew far after it was hit.\"\nbanned = [\"hit\"]\n\n输出: \"ball\"\n\n解释: \n\"hit\" 出现了3次,但它是一个禁用的单词。\n\"ball\" 出现了2次 (同时没有其他单词出现2次),所以它是段落里出现次数最多的,且不在禁用列表中的单词。 \n注意,所有这些单词在段落里不区分大小写,标点符号需要忽略(即使是紧挨着单词也忽略, 比如 \"ball,\"), \n\"hit\"不是最终的答案,虽然它出现次数更多,但它在禁用单词列表中。\n```\n\n提示:\n* $1 <= `段落长度` <= 1000$\n* $0 <= `禁用单词个数` <= 100$\n* $1 <= `禁用单词长度` <= 10$\n* 答案是唯一的, 且都是小写字母 (即使在 `paragraph` 里是大写的,即使是一些特定的名词,答案都是小写的。)\n* `paragraph` 只包含字母、空格和下列标点符号`!?',;.`\n* 不存在没有连字符或者带有连字符的单词。\n* 单词里只包含字母,不会出现省略号或者其他标点符号。", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n代码:\n```Java\nclass Solution {\n    public String mostCommonWord(String s, String[] banned) {\n        Set<String> set = new HashSet<>();\n        for (String b : banned) set.add(b);\n        char[] cs = s.toCharArray();\n        int n = cs.length;\n        String ans = null;\n        Map<String, Integer> map = new HashMap<>();\n        for (int i = 0; i < n; ) {\n            if (!Character.isLetter(cs[i]) && ++i >= 0) continue;\n            int j = i;\n            while (j < n && Character.isLetter(cs[j])) j++;\n            String sub = s.substring(i, j).toLowerCase();\n            i = j + 1;\n            if (set.contains(sub)) continue;\n            map.put(sub, map.getOrDefault(sub, 0) + 1);\n            if (ans == null || map.get(sub) > map.get(ans)) ans = sub;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n + m)$,$n$ 和 $m$ 分别代表 `s` 的字符总长度和 `banned` 的字符总长度(哈希函数的计算与长度成正比)\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.819` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/821-830/821. 字符的最短距离（简单）.md", "url_title": "821. 字符的最短距离", "url": "https://leetcode-cn.com/problems/shortest-distance-to-a-character/solution/by-ac_oier-5bjs/", "difficulty": "简单", "tags": ["模拟", "BFS"], "question": "给你一个字符串 `s` 和一个字符 `c` ,且 `c` 是 `s` 中出现过的字符。\n\n返回一个整数数组 `answer`,其中 $answer.length == s.length$ 且 $answer[i]$ 是 `s` 中从下标 $i$ 到离它 最近 的字符 `c` 的 距离 。\n\n两个下标 $i$ 和 $j$ 之间的 距离 为 `abs(i - j)` ,其中 `abs` 是绝对值函数。\n\n示例 1:\n```\n输入:s = \"loveleetcode\", c = \"e\"\n\n输出:[3,2,1,0,1,0,0,1,2,2,1,0]\n\n解释:字符 'e' 出现在下标 3、5、6 和 11 处(下标从 0 开始计数)。\n距下标 0 最近的 'e' 出现在下标 3 ,所以距离为 abs(0 - 3) = 3 。\n距下标 1 最近的 'e' 出现在下标 3 ,所以距离为 abs(1 - 3) = 2 。\n对于下标 4 ,出现在下标 3 和下标 5 处的 'e' 都离它最近,但距离是一样的 abs(4 - 3) == abs(4 - 5) = 1 。\n距下标 8 最近的 'e' 出现在下标 6 ,所以距离为 abs(8 - 6) = 2 。\n```\n示例 2:\n```\n输入:s = \"aaab\", c = \"b\"\n\n输出:[3,2,1,0]\n```\n\n提示:\n* $1 <= s.length <= 10^4$\n* $s[i]$ 和 `c` 均为小写英文字母\n* 题目数据保证 `c` 在 `s` 中至少出现一次", "solution": "### 遍历\n\n根据题意进行模拟即可:两次遍历,第一次找到每个 $i$ 左边最近的 `c`,第二次找到每个 $i$ 右边最近的 `c`。\n\n代码:\n```Java\nclass Solution {\n    public int[] shortestToChar(String s, char c) {\n        int n = s.length();\n        int[] ans = new int[n];\n        Arrays.fill(ans, n + 1);\n        for (int i = 0, j = -1; i < n; i++) {\n            if (s.charAt(i) == c) j = i;\n            if (j != -1) ans[i] = i - j;\n        }\n        for (int i = n - 1, j = -1; i >= 0; i--) {\n            if (s.charAt(i) == c) j = i;\n            if (j != -1) ans[i] = Math.min(ans[i], j - i);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### BFS\n\n起始令所有的 $ans[i] = -1$,然后将所有的 `c` 字符的下标入队,并更新 $ans[i] = 0$,然后跑一遍 `BFS` 逻辑,通过 $ans[i]$ 是否为 $-1$ 来判断是否重复入队。\n\n代码:\n```Java\nclass Solution {\n    public int[] shortestToChar(String s, char c) {\n        int n = s.length();\n        int[] ans = new int[n];\n        Arrays.fill(ans, -1);\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            if (s.charAt(i) == c) {\n                d.addLast(i);\n                ans[i] = 0;\n            }\n        }\n        int[] dirs = new int[]{-1, 1};\n        while (!d.isEmpty()) {\n            int t = d.pollFirst();\n            for (int di : dirs) {\n                int ne = t + di;\n                if (ne >= 0 && ne < n && ans[ne] == -1) {\n                    ans[ne] = ans[t] + 1;\n                    d.addLast(ne);\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.821` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/821-830/824. 山羊拉丁文（简单）.md", "url_title": "824. 山羊拉丁文", "url": "https://leetcode-cn.com/problems/goat-latin/solution/by-ac_oier-t7hj/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个由若干单词组成的句子 `sentence`,单词间由空格分隔。每个单词仅由大写和小写英文字母组成。\n\n请你将句子转换为 “山羊拉丁文(`Goat Latin`)”(一种类似于 猪拉丁文 - Pig Latin 的虚构语言)。山羊拉丁文的规则如下:\n\n* 如果单词以元音开头(`'a'`, `'e'`, `'i'`, `'o'`, `'u'`),在单词后添加`\"ma\"`。\n\t* 例如,单词 `\"apple\"` 变为 `\"applema\"` 。\n* 如果单词以辅音字母开头(即,非元音字母),移除第一个字符并将它放到末尾,之后再添加`\"ma\"`。\n\t* 例如,单词 `\"goat\"` 变为 `\"oatgma\"` 。\n* 根据单词在句子中的索引,在单词最后添加与索引相同数量的字母`'a'`,索引从 $1$ 开始。\n\t* 例如,在第一个单词后添加 `\"a\"`,在第二个单词后添加 `\"aa\"`,以此类推。\n\n返回将 `sentence` 转换为山羊拉丁文后的句子。 \n\n示例 1:\n```\n输入:sentence = \"I speak Goat Latin\"\n\n输出:\"Imaa peaksmaaa oatGmaaaa atinLmaaaaa\"\n```\n示例 2:\n```\n输入:sentence = \"The quick brown fox jumped over the lazy dog\"\n\n输出:\"heTmaa uickqmaaa rownbmaaaa oxfmaaaaa umpedjmaaaaaa overmaaaaaaa hetmaaaaaaaa azylmaaaaaaaaa ogdmaaaaaaaaaa\"\n```\n\n提示:\n* $1 <= sentence.length <= 150$\n* `sentence` 由英文字母和空格组成\n* `sentence` 不含前导或尾随空格\n* `sentence` 中的所有单词由单个空格分隔", "solution": "### 模拟 \n\n根据题意进行模拟即可。\n\n代码:\n```Java\nclass Solution {\n    public String toGoatLatin(String s) {\n        int n = s.length();\n        String last = \"a\";\n        StringBuilder sb = new StringBuilder();\n        for (int i = 0; i < n; ) {\n            int j = i;\n            while (j < n && s.charAt(j) != ' ') j++;\n            if (\"aeiouAEIOU\".indexOf(s.charAt(i)) >= 0) {\n                sb.append(s.substring(i, j)).append(\"ma\");\n            } else {\n                sb.append(s.substring(i + 1, j)).append(s.charAt(i)).append(\"ma\");\n            }\n            sb.append(last);\n            last += \"a\";\n            i = j + 1;\n            if (i < n) sb.append(\" \");\n        }\n        return sb.toString();\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.824` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/821-830/825. 适龄的朋友（中等）.md", "url_title": "825. 适龄的朋友", "url": "https://leetcode-cn.com/problems/friends-of-appropriate-ages/solution/gong-shui-san-xie-yi-ti-shuang-jie-pai-x-maa8/", "difficulty": "中等", "tags": ["排序", "双指针", "桶排序", "前缀和"], "question": "在社交媒体网站上有 $n$ 个用户。给你一个整数数组 `ages` ,其中 $ages[i]$ 是第 $i$ 个用户的年龄。\n\n如果下述任意一个条件为真,那么用户 $x$ 将不会向用户 $y$(`x != y`)发送好友请求:\n\n* $age[y] <= 0.5 * age[x] + 7$\n* $age[y] > age[x]$\n* $age[y] > 100$ 且 $age[x] < 100$\n\n否则,$x$ 将会向 $y$ 发送一条好友请求。\n\n注意,如果 $x$ 向 $y$ 发送一条好友请求,$y$ 不必也向 $x$ 发送一条好友请求。另外,用户不会向自己发送好友请求。\n\n返回在该社交媒体网站上产生的好友请求总数。\n\n示例 1:\n```\n输入:ages = [16,16]\n\n输出:2\n\n解释:2 人互发好友请求。\n```\n示例 2:\n```\n输入:ages = [16,17,18]\n\n输出:2\n\n解释:产生的好友请求为 17 -> 16 ,18 -> 17 。\n```\n示例 3:\n```\n输入:ages = [20,30,100,110,120]\n\n输出:3\n\n解释:产生的好友请求为 110 -> 100 ,120 -> 110 ,120 -> 100 。\n```\n\n提示:\n* $n == ages.length$\n* $1 <= n <= 2 * 10^4$\n* $1 <= ages[i] <= 120$", "solution": "### 排序 + 双指针 \n\n从三个不发送好友请求的条件来看,以 $y$ 的角度来说,可总结为:**年龄比我小的不考虑(同龄的可以),年龄比我大可以考虑,但是不能超过一定范围则不考虑。**\n\n即对于一个确定的 $y$ 而言,会发送好友请求的 $x$ 范围为连续段:\n\n**随着 $y$ 的逐渐增大,对应的 $x$ 连续段的左右边界均逐渐增大(数轴上均往右移动)。**\n\n因此,我们可以先对 $ages$ 进行排序,枚举每个 $y = ages[k]$,同时使用 $i$ 和 $j$ 维护左右区间,$[i, j)$ 代表在 $ages$ 上会往 $y = ages[k]$ 发送请求的 $x$ 连续段,统计每个 $y = ages[k]$ 的 $x$ 有多少个即是答案,同时需要注意在 $[i, j)$ 范围内是包含 $y = ages[k]$ 自身,统计区间长度时需要进行 $-1$ 操作。\n\n代码:\n```Java\nclass Solution {\n    public int numFriendRequests(int[] ages) {\n        Arrays.sort(ages);\n        int n = ages.length, ans = 0;\n        for (int k = 0, i = 0, j = 0; k < n; k++) {\n            while (i < k && !check(ages[i], ages[k])) i++;\n            if (j < k) j = k;\n            while (j < n && check(ages[j], ages[k])) j++;\n            if (j > i) ans += j - i - 1;\n        }\n        return ans;\n    }\n    boolean check(int x, int y) {\n        if (y <= 0.5 * x + 7) return false;\n        if (y > x) return false;\n        if (y > 100 && x < 100) return false; \n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$\n\n---\n\n### 桶排序 + 前缀和 \n\n在解法一中,复杂度的上界在于「双轴快排」,利用本题数据范围 `1 <= ages[i] <= 120`,值域较小,我们可以通过「桶排序」的方式进行排序优化。\n\n假设对 $ages$ 进行桶排后得到的数组为 $nums$,其中 $cnt = nums[i]$ 的含义为在 $ages$ 中年龄为 $i$ 的人有 $cnt$ 个。\n\n同时,我们发现在解法一中,我们枚举 $y = ages[k]$,并使用 $i$ 和 $j$ 两个指针寻找连续的 $x$ 段的过程,$x$ 会始终停留于值与 $y = ages[k]$ 相等的最小下标处,而对于桶排数组而言,当前位置就是最小合法 $x$ 值(与 $y$ 相等),因此我们只需要找到最大合法 $x$ 值的位置即可(对应解法一的 $j$ 位置)。\n\n同样,最大 $x$ 的位置在桶排数组中也是随着 $y$ 的增大(右移)逐渐增大(右移)。\n\n剩下的问题在于,如何统计桶排数组中连续段下标的和为多少(有多少个合法 $x$ 值),这可以直接在桶排数组应用前缀和即可。\n\n代码:\n```Java\nclass Solution {\n    int N = 130;\n    public int numFriendRequests(int[] ages) {\n        int[] nums = new int[N];\n        for (int i : ages) nums[i]++;\n        for (int i = 1; i < N; i++) nums[i] += nums[i - 1];\n        int ans = 0;\n        for (int y = 1, x = 1; y < N; y++) {\n            int a = nums[y] - nums[y - 1]; // 有 a 个 y\n            if (a == 0) continue;\n            if (x < y) x = y;\n            while (x < N && check(x, y)) x++;\n            int b = nums[x - 1] - nums[y - 1] - 1; // [y, x) 为合法的 x 范围,对于每个 y 而言,有 b 个 x\n            if (b > 0) ans += b * a;\n        }\n        return ans;\n    }\n    boolean check(int x, int y) {\n        if (y <= 0.5 * x + 7) return false;\n        if (y > x) return false;\n        if (y > 100 && x < 100) return false; \n        return true;\n    }\n}\n```\n* 时间复杂度:令 $C$ 为年龄值域大小,对于本题 $C$ 固定为 $130$。复杂度为 $O(\\max(n, C))$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.825` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/821-830/827. 最大人工岛（困难）.md", "url_title": "827. 最大人工岛", "url": "https://leetcode.cn/problems/making-a-large-island/solution/by-ac_oier-1kmp/", "difficulty": "困难", "tags": ["并查集", "枚举"], "question": "给你一个大小为 `n x n` 二进制矩阵 `grid` 。最多 只能将一格 `0` 变成 `1` 。\n\n返回执行此操作后,`grid` 中最大的岛屿面积是多少?\n\n岛屿 由一组上、下、左、右四个方向相连的 `1` 形成。\n\n示例 1:\n```\n输入: grid = [[1, 0], [0, 1]]\n\n输出: 3\n\n解释: 将一格0变成1,最终连通两个小岛得到面积为 3 的岛屿。\n```\n示例 2:\n```\n输入: grid = [[1, 1], [1, 0]]\n\n输出: 4\n\n解释: 将一格0变成1,岛屿的面积扩大为 4。\n```\n示例 3:\n```\n输入: grid = [[1, 1], [1, 1]]\n\n输出: 4\n\n解释: 没有0可以让我们变成1,面积依然为 4。\n```\n\n提示:\n* $n = grid.length$\n* $n == grid[i].length$\n* $1 <= n <= 500$\n* `grid[i][j]` 为 `0` 或 `1`", "solution": "### 并查集 + 枚举\n\n为了方便,我们令 `grid` 为 `g`。\n\n根据题意,容易想到通过「并查集」来维护所有连通块大小,再通过「枚举」来找最优翻转点。\n\n具体的,我们可以先使用「并查集」维护所有 $g[i][j] = 1$ 的块连通性,并在维护连通性的过程中,使用 `sz[idx]` 记录下每个连通块的大小(注意:只有连通块根编号,`sz[idx]` 才有意义,即只有 `sz[find(x)]` 才有意义)。\n\n随后我们再次遍历 `g`,根据原始的 $g[i][j]$ 的值进行分别处理:\n\n* 若 $g[i][j] = 1$,该位置不会作为翻转点,但真实最大面积未必是由翻转后所导致的(可能取自原有的连通块),因此我们需要将 $sz[root]$ 参与比较,其中 `root` 为 $(i, j)$ 所属的连通块根节点编号;\n* 若 $g[i][j] = 0$,该位置可作为翻转点,我们可以统计其四联通位置对应的连通块大小总和 `tot`(注意若四联通方向有相同连通块,只统计一次),那么 $tot + 1$ 即是翻转该位置所得到的新连通块大小。\n\n最后对所有连通块大小取最大值即是答案。\n\n> 一些细节:为了方便,我们令点 $(i, j)$ 的编号从 $1$ 开始;\n同时由于我们本身就要用 `sz` 数组,因此我们可以随手把并查集的「按秩合并」也加上。体现在 `union` 操作时,我们总是将小的连通块合并到大的连通块上,从而确保我们并查集单次操作即使在最坏情况下复杂度仍为 $O(\\alpha(n))$(可看作常数)。需要注意只有同时应用「路径压缩」和「按秩合并」,并查集操作复杂度才为 $O(\\alpha(n))$。\n\nJava 代码:\n```Java\nclass Solution {\n    static int N = 510;\n    static int[] p = new int[N * N], sz = new int[N * N];\n    int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n    int find(int x) {\n        if (p[x] != x) p[x] = find(p[x]);\n        return p[x];\n    }\n    void union(int a, int b) {\n        int ra = find(a), rb = find(b);\n        if (ra == rb) return ;\n        if (sz[ra] > sz[rb]) {\n            union(b, a);\n        } else {\n            sz[rb] += sz[ra]; p[ra] = p[rb];\n        }\n    }\n    public int largestIsland(int[][] g) {\n        int n = g.length;\n        for (int i = 1; i <= n * n; i++) {\n            p[i] = i; sz[i] = 1;\n        }\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                if (g[i][j] == 0) continue;\n                for (int[] di : dirs) {\n                    int x = i + di[0], y = j + di[1];\n                    if (x < 0 || x >= n || y < 0 || y >= n || g[x][y] == 0) continue;\n                    union(i * n + j + 1, x * n + y + 1);\n                }\n            }\n        }\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                if (g[i][j] == 1) {\n                    ans = Math.max(ans, sz[find(i * n + j + 1)]);\n                } else {\n                    int tot = 1;\n                    Set<Integer> set = new HashSet<>();\n                    for (int[] di : dirs) {\n                        int x = i + di[0],y = j + di[1];\n                        if (x < 0 || x >= n || y < 0 || y >= n || g[x][y] == 0) continue;\n                        int root = find(x * n + y + 1);\n                        if (set.contains(root)) continue;\n                        tot += sz[root];\n                        set.add(root);\n                    }\n                    ans = Math.max(ans, tot);\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int p[510 * 510], sz[510 * 510];\n    vector<vector<int>> dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};\n    int find(int x) {\n        if (p[x] != x) p[x] = find(p[x]);\n        return p[x];\n    }\n    void unionX(int a, int b) {\n        int ra = find(a), rb = find(b);\n        if (ra == rb) return;\n        if (sz[ra] > sz[rb]) {\n            unionX(b, a);\n        } else {\n            sz[rb] += sz[ra];\n            p[ra] = p[rb];\n        }\n    }\n    int largestIsland(vector<vector<int>>& g) {\n        int n = g.size();\n        for (int i = 1; i <= n * n; i++) {\n            p[i] = i; sz[i] = 1;\n        }\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                if (g[i][j] == 0) continue;\n                for (const auto& di : dirs) {\n                    int x = i + di[0], y = j + di[1];\n                    if (x < 0 || x >= n || y < 0 || y >= n || g[x][y] == 0) continue;\n                    unionX(i * n + j + 1, x * n + y + 1);\n                }\n            }\n        }\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                if (g[i][j] == 1) {\n                    ans = max(ans, sz[find(i * n + j + 1)]);\n                } else {\n                    int tot = 1;\n                    unordered_set<int> set;\n                    for (const auto& di : dirs) {\n                        int x = i + di[0], y = j + di[1];\n                        if (x < 0 || x >= n || y < 0 || y >= n || g[x][y] == 0) continue;\n                        int root = find(x * n + y + 1);\n                        if (set.find(root) != set.end()) continue;\n                        tot += sz[root];\n                        set.insert(root);\n                    }\n                    ans = max(ans, tot);\n                }\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def find(self, p, x):\n        if p[x] != x:\n            p[x] = self.find(p, p[x])\n        return p[x]\n\n    def union(self, p, sz, a, b):\n        ra, rb = self.find(p, a), self.find(p, b)\n        if ra == rb:\n            return \n        if sz[ra] > sz[rb]:\n            ra, rb = rb, ra\n        sz[rb] += sz[ra]\n        p[ra] = p[rb]\n\n    def largestIsland(self, g: List[List[int]]) -> int:\n        n, ans = len(g), 0\n        p, sz = [i for i in range(n * n + 10)], [1 for _ in range(n * n + 10)]\n        dirs = [[1,0],[-1,0],[0,1],[0,-1]]\n        for i in range(n):\n            for j in range(n):\n                if g[i][j] == 0:\n                    continue\n                for di in dirs:\n                    x, y = i + di[0], j + di[1]\n                    if x < 0 or x >= n or y < 0 or y >= n or g[x][y] == 0:\n                        continue\n                    self.union(p, sz, i * n + j + 1, x * n + y + 1)\n        for i in range(n):\n            for j in range(n):\n                if g[i][j] == 1:\n                    ans = max(ans, sz[self.find(p, i * n + j + 1)])\n                else:\n                    tot = 1\n                    vis = set()\n                    for di in dirs:\n                        x, y = i + di[0], j + di[1]\n                        if x < 0 or x >= n or y < 0 or y >= n or g[x][y] == 0:\n                            continue\n                        root = self.find(p, x * n + y + 1)\n                        if root in vis:\n                            continue\n                        tot += sz[root]\n                        vis.add(root)\n                    ans = max(ans, tot)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nconst N = 510\nconst p = new Array<number>(N * N).fill(-1), sz = new Array<number>(N * N).fill(1)\nconst dirs = [[1,0], [-1,0], [0,1], [0,-1]]\nfunction find(x: number): number {\n    if (p[x] != x) p[x] = find(p[x])\n    return p[x]\n}\nfunction union(a: number, b: number): void {\n    const ra = find(a), rb = find(b)\n    if (ra == rb) return \n    if (sz[ra] > sz[rb]) {\n        union(rb, ra)\n    } else {\n        sz[rb] += sz[ra]; p[ra] = p[rb]\n    }\n}\nfunction largestIsland(g: number[][]): number {\n    const n = g.length\n    for (let i = 1; i <= n * n; i++) {\n        p[i] = i; sz[i] = 1\n    }\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++) {\n            if (g[i][j] == 0) continue\n            for (const di of dirs) {\n                const x = i + di[0], y = j + di[1]\n                if (x < 0 || x >= n || y < 0 || y >= n || g[x][y] == 0) continue\n                union(i * n + j + 1, x * n + y + 1)\n            }\n        }\n    }\n    let ans = 0\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++) {\n            if (g[i][j] == 1) {\n                ans = Math.max(ans, sz[find(i * n + j + 1)])\n            } else {\n                let tot = 1\n                const set = new Set()\n                for (let di of dirs) {\n                    const x = i + di[0], y = j + di[1]\n                    if (x < 0 || x >= n || y < 0 || y >= n || g[x][y] == 0) continue\n                    const root = find(x * n + y + 1)\n                    if (set.has(root)) continue\n                    tot += sz[root]\n                    set.add(root)\n                }\n                ans = Math.max(ans, tot)\n            }\n        }\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.827` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/821-830/828. 统计子串中的唯一字符（困难）.md", "url_title": "828. 统计子串中的唯一字符", "url": "https://leetcode.cn/problems/count-unique-characters-of-all-substrings-of-a-given-string/solution/by-ac_oier-922k/", "difficulty": "困难", "tags": ["模拟", "数学", "线性 DP"], "question": "我们定义了一个函数 `countUniqueChars(s)` 来统计字符串 `s` 中的唯一字符,并返回唯一字符的个数。\n\n例如:`s = \"LEETCODE\"` ,则其中 `\"L\"`, `\"T\"`,`\"C\"`,`\"O\"`,`\"D\"` 都是唯一字符,因为它们只出现一次,所以 `countUniqueChars(s) = 5`。\n\n本题将会给你一个字符串 `s` ,我们需要返回 `countUniqueChars(t)` 的总和,其中 `t` 是 `s` 的子字符串。\n\n输入用例保证返回值为 `32` 位整数。\n\n注意,某些子字符串可能是重复的,但你统计时也必须算上这些重复的子字符串(也就是说,你必须统计 `s` 的所有子字符串中的唯一字符)。\n\n示例 1:\n```\n输入: s = \"ABC\"\n\n输出: 10\n\n解释: 所有可能的子串为:\"A\",\"B\",\"C\",\"AB\",\"BC\" 和 \"ABC\"。\n     其中,每一个子串都由独特字符构成。\n     所以其长度总和为:1 + 1 + 1 + 2 + 2 + 3 = 10\n```\n示例 2:\n```\n输入: s = \"ABA\"\n\n输出: 8\n\n解释: 除了 countUniqueChars(\"ABA\") = 1 之外,其余与示例 1 相同。\n```\n示例 3:\n```\n输入:s = \"LEETCODE\"\n\n输出:92\n```\n\n提示:\n* $1 <= s.length <= 10^5$\n* `s` 只包含大写英文字符", "solution": "### 模拟 + 乘法原理\n\n这道题和 [907. 子数组的最小值之和](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247493485&idx=1&sn=c6d6ac25c171e2617c5a95173aa58825) 如出一辙,只不过无须考虑运用「单调栈」。\n\n原问题为求所有子数组的唯一字符数量和,其可等价为求每个 $s[i]$ 对答案的贡献,即每个 $s[i]$ 可作为多少个子数组的唯一元素。\n\n假定我们能预处理出两数组 `l` 和 `r` 分别代表 $s[i]$ 作为子数组唯一字符时,其所能到达的最远两端:\n* `l[i] = a` 代表下标 $a$ 为 $s[i]$ 能够作为子数组唯一字符时的最远左边界,即为 $s[i]$ 左边第一个与 $s[i]$ 值相同的位置(若不存在,则为 $a = -1$)\n* `r[i] = b` 代表跳表 $b$ 为 $s[i]$ 能够作为子数组唯一字符时的最远右边界,即为 $s[i]$ 右边第一个与 $s[i]$ 值相同的位置(若不存在,则为 $b = n$)\n\n子数组左端点个数为 $(i - a)$ 个,右端点个数为 $(b - i)$ 个,根据乘法原理可知,子数组个数为两者乘积。\n\n预处理 `l` 和 `r` 只需要使用遍历计数即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public int uniqueLetterString(String s) {\n        char[] cs = s.toCharArray();\n        int n = cs.length, ans = 0;\n        int[] l = new int[n], r = new int[n];\n        int[] idx = new int[26];\n        Arrays.fill(idx, -1);\n        for (int i = 0; i < n; i++) {\n            int u = cs[i] - 'A';\n            l[i] = idx[u];\n            idx[u] = i;\n        }\n        Arrays.fill(idx, n);\n        for (int i = n - 1; i >= 0; i--) {\n            int u = cs[i] - 'A';\n            r[i] = idx[u];\n            idx[u] = i;\n        }\n        for (int i = 0; i < n; i++) ans += (i - l[i]) * (r[i] - i);\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int uniqueLetterString(string s) {\n        int n = s.size(), ans = 0;\n        vector<int> l(n, -1), r(n, n);\n        vector<int> idx(26, -1);\n        for (int i = 0; i < n; i++) {\n            int u = s[i] - 'A';\n            l[i] = idx[u];\n            idx[u] = i;\n        }\n        fill(idx.begin(), idx.end(), n);\n        for (int i = n - 1; i >= 0; i--) {\n            int u = s[i] - 'A';\n            r[i] = idx[u];\n            idx[u] = i;\n        }\n        for (int i = 0; i < n; i++) ans += (i - l[i]) * (r[i] - i);\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def uniqueLetterString(self, s: str) -> int:\n        n = len(s)\n        l, r = [-1] * n, [n] * n\n        idx = [-1] * 26\n        for i in range(n):\n            u = ord(s[i]) - ord('A')\n            l[i] = idx[u]\n            idx[u] = i\n        idx = [n] * 26\n        for i in range(n - 1, -1, -1):\n            u = ord(s[i]) - ord('A')\n            r[i] = idx[u]\n            idx[u] = i\n        return sum((i - l[i]) * (r[i] - i) for i in range(n))\n```\nTypescript 代码:\n```Typescript\nfunction uniqueLetterString(s: string): number {\n    let n = s.length, ans = 0\n    const l = new Array<number>(n), r = new Array<number>(n)\n    const idx = new Array<number>(26).fill(-1)\n    for (let i = 0; i < n; i++) {\n        const u = s.charCodeAt(i) - 65\n        l[i] = idx[u]\n        idx[u] = i\n    }\n    idx.fill(n)\n    for (let i = n - 1; i >= 0; i--) {\n        const u = s.charCodeAt(i) - 65\n        r[i] = idx[u]\n        idx[u] = i\n    }\n    for (let i = 0; i < n; i++) ans += (i - l[i]) * (r[i] - i)\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 线性 DP\n\n另外一个实现思路是利用「动态规划」思想。\n\n定义 $f[i]$ 为考虑以 $s[i]$ 为结尾的所有子串中的唯一字符个数。\n\n不失一般性考虑 $f[i]$ 该如何转移:以 $s[i]$ 为结尾的子串包括在所有以 $s[i - 1]$ 为结尾的子串结尾添加一个字符而来,以及 $s[i]$ 字符本身组成的新子串。\n\n首先我们令 $f[i] = f[i - 1]$,同时使用 $b[x]$ 记录字符 $x$ 前一次出现的下标,使用 $a[x]$ 记录字符 $x$ 在上上次出现的下标,然后假设当前处理的字符为 $c = s[i]$,考虑 $s[i]$ 对 $f[i]$ 的影响(注意 $s[i]$ 始终为子串右端点):\n\n* 在子串左端点下标范围在 $[b[c] + 1, i]$ 的子串中,$s[i]$ 必然只出现一次(满足唯一字符要求),即可增加 $i - b[c]$ 个唯一字符 $s[i]$;\n* 在子串左端点下标范围在 $[a[c] + 1, b[c]]$ 的子串中,原本位于 $b[c]$ 的字符在新子串中出现次数变为 $2$ 次(不再满足唯一字符要求),即需减少 $b[c] - a[c]$ 个唯一字符 $s[i]$。\n\n综上,我们有状态转移方程:$f[i] = f[i - 1] + (i - b[s[i]]) - (b[s[i]] - a[s[i]])$\n\n实现上,由于 $f[i]$ 只依赖于 $f[i - 1]$,因此我们无须真的创建动规数组,而只需要使用单个变量 `cur` 来记录当前处理到的 $f[i]$ 即可,累积所有的 $f[i]$ 即是答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int uniqueLetterString(String s) {\n        int n = s.length(), ans = 0, cur = 0;\n        int[] a = new int[26], b = new int[26];\n        Arrays.fill(a, -1); Arrays.fill(b, -1);\n        for (int i = 0; i < n; i++) {\n            int u = s.charAt(i) - 'A';\n            cur += i - b[u] - (b[u] - a[u]);\n            ans += cur;\n            a[u] = b[u]; b[u] = i;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int uniqueLetterString(string s) {\n        int n = s.length(), ans = 0, cur = 0;\n        vector<int> a(26, -1), b(26, -1);\n        for (int i = 0; i < n; ++i) {\n            int u = s[i] - 'A';\n            cur += i - b[u] - (b[u] - a[u]);\n            ans += cur;\n            a[u] = b[u]; b[u] = i;\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def uniqueLetterString(self, s: str) -> int:\n        n, ans, cur = len(s), 0, 0\n        a, b = [-1] * 26, [-1] * 26\n        for i in range(n):\n            u = ord(s[i]) - ord('A')\n            cur += i - b[u] - (b[u] - a[u])\n            ans += cur\n            a[u], b[u] = b[u], i\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction uniqueLetterString(s: string): number {\n    let n = s.length, ans = 0, cur = 0\n    const a = new Array<number>(26).fill(-1), b = new Array<number>(26).fill(-1)\n    for (let i = 0; i < n; i++) {\n        const u = s.charCodeAt(i) - 65\n        cur += i - b[u] - (b[u] - a[u])\n        ans += cur\n        a[u] = b[u]; b[u] = i\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(C)$,其中 $C = 26$ 为字符集大小", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.828` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/821-830/829. 连续整数求和（困难）.md", "url_title": "829. 连续整数求和", "url": "https://leetcode.cn/problems/consecutive-numbers-sum/solution/by-ac_oier-220q/", "difficulty": "困难", "tags": ["数论", "数学"], "question": "给定一个正整数 $n$,返回连续正整数满足所有数字之和为 $n$ 的组数 。 \n\n示例 1:\n```\n输入: n = 5\n\n输出: 2\n\n解释: 5 = 2 + 3,共有两组连续整数([5],[2,3])求和后为 5。\n```\n示例 2:\n```\n输入: n = 9\n\n输出: 3\n\n解释: 9 = 4 + 5 = 2 + 3 + 4\n```\n示例 3:\n```\n输入: n = 15\n\n输出: 4\n\n解释: 15 = 8 + 7 = 4 + 5 + 6 = 1 + 2 + 3 + 4 + 5\n```\n\n提示:\n* $1 <= n <= 10^9$", "solution": "### 数论\n\n假设我们存在某个连续段之和为 $n$,假定该连续段首项为 $a$,长度为 $k$,根据「等差数列求和」可知:\n\n$$\n\\frac{(a + a + k - 1) \\times k}{2} = n\n$$\n\n简单变形可得:\n\n$$\n(2a + k - 1) \\times k = 2n \\Leftrightarrow 2a = \\frac{2n}{k} - k + 1\n$$\n\n根据首项 $a$ 和 $k$ 均为正整数,可得:\n\n$$\n2a = \\frac{2n}{k} - k + 1 \\geq 2\n$$\n\n进一步可得:\n\n$$\n\\frac{2n}{k} \\geq k + 1 \\Leftrightarrow \\frac{2n}{k} > k\n$$\n\n综上,根据 $(2a + k - 1) \\times k = 2n$ 和 $\\frac{2n}{k} > k$ 可知,$k$ 必然是 $2n$ 的约数,并且为「较小」的约数。\n\n因此我们可以在 $[1, \\sqrt{2n})$ 范围内枚举 $k$,如果 $k$ 为 $2n$ 约数,并且结合 $(2a + k - 1) \\times k = 2n$ 可验证 $a$ 合法,说明找到了一组合法的 $(a, k)$,对答案进行累加。\n\nJava 代码:\n```Java\nclass Solution {\n    public int consecutiveNumbersSum(int n) {\n        int ans = 0; n *= 2;\n        for (int k = 1; k * k < n; k++) {\n            if (n % k != 0) continue;\n            if ((n / k - (k - 1)) % 2 == 0) ans++;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int consecutiveNumbersSum(int n) {\n        int ans = 0; n *= 2;\n        for (int k = 1; k * k < n; k++) {\n            if (n % k != 0) continue;\n            if ((n / k - (k - 1)) % 2 == 0) ans++;\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def consecutiveNumbersSum(self, n: int) -> int:\n        ans, n = 0, n * 2\n        for k in range(1, int(n ** 0.5) + 1):\n            ans += n % k == 0 and (n // k - (k - 1)) % 2 == 0\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction consecutiveNumbersSum(n: number): number {\n    let ans = 0; n *= 2;\n    for (let k = 1; k * k < n; k++) {\n        if (n % k != 0) continue;\n        if ((n / k - (k - 1)) % 2 == 0) ans++;\n    }\n    return ans;  \n};\n```\n* 时间复杂度:$O(\\sqrt{2n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.829` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/831-840/832. 翻转图像（简单）.md", "url_title": "832. 翻转图像", "url": "https://leetcode-cn.com/problems/flipping-an-image/solution/shuang-zhi-zhen-yi-bian-chu-li-huan-you-ik0v1/", "difficulty": "简单", "tags": ["双指针"], "question": "给定一个二进制矩阵 A,我们想先水平翻转图像,然后反转图像并返回结果。\n\n水平翻转图片就是将图片的每一行都进行翻转,即逆序。例如,水平翻转 [1, 1, 0] 的结果是 [0, 1, 1]。\n\n反转图片的意思是图片中的 0 全部被 1 替换, 1 全部被 0 替换。例如,反转 [0, 1, 1] 的结果是 [1, 0, 0]。\n\n示例 1:\n```\n输入:[[1,1,0],[1,0,1],[0,0,0]]\n输出:[[1,0,0],[0,1,0],[1,1,1]]\n解释:首先翻转每一行: [[0,1,1],[1,0,1],[0,0,0]];\n     然后反转图片: [[1,0,0],[0,1,0],[1,1,1]]\n```\n示例 2:\n```\n输入:[[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]\n输出:[[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]\n解释:首先翻转每一行: [[0,0,1,1],[1,0,0,1],[1,1,1,0],[0,1,0,1]];\n     然后反转图片: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]\n```\n\n提示:\n* 1 <= A.length = A[0].length <= 20\n* 0 <= A[i][j] <= 1", "solution": "### 双指针代码\n\n对于每行而言,我们都需要对其进行「翻转」和「反转」。\n\n这两步可以到放到一遍循环里做:\n* 翻转部分:使用双指针进行数字交换\n* 反转部分:将数字存储进目标位置前,使用「异或」对 0 1 进行翻转\n\n当前有一些「小细节」需要注意:\n1. 题目要求我们对参数图像进行翻转,并返回新图像。因此我们不能对输入直接进行修改,而要先进行拷贝再处理\n2. 由于我们将「翻转」和「反转」合成了一步,因此对于「奇数」图像,需要对中间一列进行特殊处理:仅「反转」\n\n对于 Java 的基本类型拷贝,有三种方式进行拷贝:\n1. System.arraycopy() : 底层的数组拷贝接口,具体实现与操作系统相关,调用的是系统本地方法。需要自己创建好目标数组进行传入,可指定拷贝长度,实现局部拷贝。\n2. Arrays.copyOf() : 基于 `System.arraycopy()` 封装的接口,省去了自己目标数组这一步。但无法实现局部拷贝。\n3. clone() : Object 的方法。会调用每个数组成员的 clone() 方法进行拷贝。因此对于一维数组而言,可以直接使用 clone() 得到「深拷贝数组」,而对于多维数组而言,得到的是「浅拷贝数组」。\n\n```java [] \nclass Solution {\n    public int[][] flipAndInvertImage(int[][] a) {\n        int n = a.length;\n        int[][] ans = new int[n][n];\n        for (int i = 0; i < n; i++) {\n            // ans[i] = a[i].clone(); \n            // ans[i] = Arrays.copyOf(a[i], n); \n            System.arraycopy(a[i], 0, ans[i], 0, n); \n            int l = 0, r = n - 1;\n            while (l < r) {\n                int c = ans[i][r];\n                ans[i][r--] = ans[i][l] ^ 1;\n                ans[i][l++] = c ^ 1;\n            }\n            if (n % 2 != 0) ans[i][r] ^= 1; \n        }\n        return ans;\n    }\n}\n```\n```java []\nclass Solution {\n    public int[][] flipAndInvertImage(int[][] a) {\n        int n = a.length;\n        int[][] ans = new int[n][n];\n\n        // 遍历每一行进行处理\n        for (int i = 0; i < n; i++) {\n            // 对每一行进行拷贝(共三种方式)\n            // ans[i] = a[i].clone(); \n            // ans[i] = Arrays.copyOf(a[i], n); \n            System.arraycopy(a[i], 0, ans[i], 0, n); \n\n            // 使用「双指针」对其进行数组交换,实现「翻转」\n            // 并通过「异或」进行 0 1 翻转,实现「反转」\n            int l = 0, r = n - 1;\n            while (l < r) {\n                int c = ans[i][r];\n                ans[i][r--] = ans[i][l] ^ 1;\n                ans[i][l++] = c ^ 1;\n            }\n\n            // 由于「奇数」矩形的中间一列不会进入上述双指针逻辑\n            // 需要对其进行单独「反转」\n            if (n % 2 != 0) ans[i][r] ^= 1; \n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:使用了同等大小的空间存储答案。复杂度为 $O(n^2)$\n\n***\n### 补充\n\nQ: 那么 Arrays.copyOfRange() 与 System.arraycopy() 作用是否等同呢?\n\nA: 不等同。\n\nArrays.copyOf() 和 Arrays.copyOfRange() 都会内部创建目标数组。前者是直接创建一个和源数组等长的数组,而后者则是根据传参 to 和 from 计算出目标数组长度进行创建。\n\n它们得到的数组都是完整包含了要拷贝内容的,都无法实现目标数组的局部拷贝功能。\n\n例如我要拿到一个长度为 10 的数组,前面 5 个位置的内容来源于「源数组」的拷贝,后面 5 个位置我希望预留给我后面自己做操作,它们都无法满足,只有 System.arraycopy() 可以。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.832` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/831-840/834. 树中距离之和（困难）.md", "url_title": "834. 树中距离之和", "url": "https://leetcode.cn/problems/sum-of-distances-in-tree/solutions/2449965/gong-shui-san-xie-shu-xing-dp-chang-gui-1v7ud/", "difficulty": "困难", "tags": ["树形 DP", "DFS", "动态规划", "树"], "question": "给定一个无向、连通的树。\n\n树中有 `n` 个标记为 `0...n-1` 的节点以及 `n-1` 条边 。\n\n给定整数 `n` 和数组 `edges`, $edges[i] = [a_{i}, b_{i}]$表示树中的节点 $a_{i}$ 和 $b_{i}$ 之间有一条边。\n\n返回长度为 `n` 的数组 `answer`,其中 `answer[i]` 是树中第 `i` 个节点与所有其他节点之间的距离之和。\n\n示例 1:\n\n```\n输入: n = 6, edges = [[0,1],[0,2],[2,3],[2,4],[2,5]]\n\n输出: [8,12,6,10,10,10]\n\n解释: 树如图所示。\n我们可以计算出 dist(0,1) + dist(0,2) + dist(0,3) + dist(0,4) + dist(0,5) \n也就是 1 + 1 + 2 + 2 + 2 = 8。 因此,answer[0] = 8,以此类推。\n```\n示例 2:\n\n```\n输入: n = 1, edges = []\n\n输出: [0]\n```\n示例 3:\n\n```\n输入: n = 2, edges = [[1,0]]\n\n输出: [1,1]\n```\n\n提示:\n* $1 <= n <= 3 \\times 10^4$\n* $edges.length = n - 1$\n* $edges[i].length = 2$\n* $0 <= a_{i}, b_{i} < n$\n* $a_{i} != b_{i}$\n* 给定的输入保证为有效的树", "solution": "### 树形 DP\n\n**对于树形 DP,可以随便以某个节点为根,把整棵树“拎起来”进行分析,通常还会以“方向”作为切入点进行思考。**\n\n不妨以编号为 `0` 的节点作为根节点进行分析:假设当前处理到的节点为 `u`,当前节点 `u` 的父节点为 `fa`,同时 `u` 有若干子节点 `j`。\n\n对于任意节点 `u` 而言,其树中距离之和可根据「方向/位置」分为两大类(对应示例图的左右两部分):\n\n* 所有从节点 `u` “往下”延伸所达的节点距离之和,即所有经过 `u -> j` 边所能访问到的节点距离之和\n* 所有从节点 `u` “往上”延伸所达的节点距离之和,即经过 `u -> fa` 边所能访问到的节点距离之和\n\n假设我们能够用 $f[u]$ 和 $g[u]$ 预处理出每个节点“往下”和“往上”的距离之和,那么就有 $ans[u] = f[u] + g[u]$。\n\n不失一般性分别考虑 $f[u]$ 和 $g[u]$ 该如何计算。\n\n为了方便,起始先用「链式前向星」对 `edges` 进行转存,同时在递归计算 $f[u]$ 时,将父节点 `fa` 也进行传递,从而避免遍历节点 `u` 的出边时,重新走回 `fa` 。\n\n##### $f[u]$ 的推导\n\n对于叶子节点(没有“往下”出边的节点),我们有 $f[u] = 0$ 的天然条件,计算好的叶子节点值可用于更新其父节点,因此**求解 $f[u]$ 是一个「从下往上」的递推过程**。\n\n假设当前处理到的节点是 `u`,往下节点有 $j_{1}$、$j_{2}$ 和 $j_{3}$ ,且所有 $f[j]$ 均已计算完成。\n\n由于 $f[u]$ 是由所有存在“往下”出边的节点 `j` 贡献而来。而单个子节点 `j` 来说,其对 $f[u]$ 的贡献应当是:**在所有原有节点到节点 `j` 的距离路径中,额外增加一条当前出边(`u -> j`),再加上 `1`(代表节点 `u` 到节点 `j` 的距离)**。\n\n原路径距离之和恰好是 $f[j]$,额外需要增加的出边数量为原来参与计算 $f[j]$ 的点的数量(即挂载在节点 `j` 下的数量),因此我们还需要一个 `c` 数组,来记录某个节点下的子节点数量。\n\n最终的 $f[u]$ 为所有符合条件的节点的 `j` 的 $f[j] + c[j] + 1$ 的总和。\n\n##### $g[u]$ 的推导\n\n对于树形 DP 题目,“往下”的计算往往是容易的,而“往上”的计算则是稍稍麻烦。\n\n假设当前我们处理到节点为 `u`,将要遍历的节点为 `j`,考虑如何使用已经计算好的 $f[X]$ 来求解 $g[j]$。\n\n这里为什么是求解 $g[j]$,而不是 $g[u]$ 呢?\n\n因为我们求解的方向是“往上”的部分,必然是用父节点的计算结果,来推导子节点的结果,即**求解 $g[u]$ 是一个「从上往下」的过程**。\n\n对于树形 DP ,通常需要对“往上”进一步拆分:「往上再往上」和「往上再往下」:\n\n* 往上再往上:是指经过了 `j -> u` 后,还必然经过 `u -> fa` 这条边时,所能到达的节点距离之和:\n\n    \n\n  这部分对 $g[j]$ 的贡献为:在所有原有节点到节点 `u` 的距离路径中,额外增加一条当前出边(`u -> j`),增加当前出边的数量与节点数量相同,点数量为 $n - 1 - c[u]$,含义为 总节点数量 减去 `u` 节点以及子节点数量。\n\n  即此部分对 $g[j]$ 的贡献为 $g[u] + n - 1 - c[u]$。\n\n  \n\n* 往上再往下:是指经过了 `j -> u` 后,还经过「除 `u -> j` 以外」的其他“往下”边时,所能到达的节点距离之和:\n\n    \n\n  这部分的计算需要先在 $f[u]$ 中剔除 $f[j]$ 的贡献,然后再加上额外边(`u -> j`)的累加数量,同样也是节点数量。\n\n  从 $f[u]$ 中剔除 $f[j]$ 后为 $f[u] - f[j] - c[j]$,而点的数量为 $c[u] - 1 - c[j]$,含义为在以节点 `u` 为根的子树中剔除调用以节点 `j` 为根节点的部分。\n\n  即此部分对 $g[j]$ 的贡献为 $f[u] - f[j] - c[j] + c[u] - 1 - c[j]$。\n\nJava 代码:\n```Java\nclass Solution {\n    int N = 30010, M = 60010, idx = 0, n;\n    int[] he = new int[N], e = new int[M], ne = new int[M];\n    int[] f = new int[N], c = new int[N], g = new int[N];\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    public int[] sumOfDistancesInTree(int _n, int[][] es) {\n        n = _n;\n        Arrays.fill(he, -1);\n        for (int[] e : es) {\n            int a = e[0], b = e[1];\n            add(a, b); add(b, a);\n        }\n        dfs1(0, -1);\n        dfs2(0, -1);\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) ans[i] = f[i] + g[i];\n        return ans;\n    }\n    int[] dfs1(int u, int fa) {\n        int tot = 0, cnt = 0;\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (j == fa) continue;\n            int[] next = dfs1(j, u);\n            tot += next[0] + next[1] + 1; cnt += next[1] + 1;\n        }\n        f[u] = tot; c[u] = cnt;\n        return new int[]{tot, cnt};\n    }\n    void dfs2(int u, int fa) {\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (j == fa) continue;\n            g[j] += g[u] + n - 1 - c[u]; // 往上再往上\n            g[j] += f[u] - f[j] - c[j] + c[u] - 1 - c[j];  // 往上再往下\n            dfs2(j, u);\n        }\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int N = 30010, M = 60010, idx = 0, n;\n    int he[30010], e[60010], ne[60010];\n    int f[30010], c[30010], g[30010];\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    vector<int> sumOfDistancesInTree(int _n, vector<vector<int>>& es) {\n        n = _n;\n        memset(he, -1, sizeof(he));\n        for (auto& e : es) {\n            int a = e[0], b = e[1];\n            add(a, b);\n            add(b, a);\n        }\n        dfs1(0, -1);\n        dfs2(0, -1);\n        vector<int> ans(n);\n        for (int i = 0; i < n; i++) ans[i] = f[i] + g[i];\n        return ans;\n    }\n    vector<int> dfs1(int u, int fa) {\n        int tot = 0, cnt = 0;\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (j == fa) continue;\n            vector<int> next = dfs1(j, u);\n            tot += next[0] + next[1] + 1;\n            cnt += next[1] + 1;\n        }\n        f[u] = tot; c[u] = cnt;\n        return {tot, cnt};\n    }\n    void dfs2(int u, int fa) {\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (j == fa) continue;\n            g[j] += g[u] + n - 1 - c[u];\n            g[j] += f[u] - f[j] - c[j] + c[u] - 1 - c[j];\n            dfs2(j, u);\n        }\n    }\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.834` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/831-840/838. 推多米诺（中等）.md", "url_title": "838. 推多米诺", "url": "https://leetcode-cn.com/problems/push-dominoes/solution/gong-shui-san-xie-yi-ti-shuang-jie-bfs-y-z52w/", "difficulty": "中等", "tags": ["BFS", "双指针"], "question": "`n` 张多米诺骨牌排成一行,将每张多米诺骨牌垂直竖立。在开始时,同时把一些多米诺骨牌向左或向右推。\n\n每过一秒,倒向左边的多米诺骨牌会推动其左侧相邻的多米诺骨牌。同样地,倒向右边的多米诺骨牌也会推动竖立在其右侧的相邻多米诺骨牌。\n\n如果一张垂直竖立的多米诺骨牌的两侧同时有多米诺骨牌倒下时,由于受力平衡, 该骨牌仍然保持不变。\n\n就这个问题而言,我们会认为一张正在倒下的多米诺骨牌不会对其它正在倒下或已经倒下的多米诺骨牌施加额外的力。\n\n给你一个字符串 `dominoes` 表示这一行多米诺骨牌的初始状态,其中:\n\n* `dominoes[i] = 'L'`,表示第 `i` 张多米诺骨牌被推向左侧,\n* `dominoes[i] = 'R'`,表示第 `i` 张多米诺骨牌被推向右侧,\n* `dominoes[i] = '.'`,表示没有推动第 `i` 张多米诺骨牌。\n\n返回表示最终状态的字符串。\n\n示例 1:\n```\n输入:dominoes = \"RR.L\"\n\n输出:\"RR.L\"\n\n解释:第一张多米诺骨牌没有给第二张施加额外的力。\n```\n示例 2:\n\n```\n输入:dominoes = \".L.R...LR..L..\"\n\n输出:\"LL.RR.LLRRLL..\"\n```\n\n提示:\n* $n == dominoes.length$\n* $1 <= n <= 10^5$\n* $dominoes[i]$ 为 `'L`、`'R'` 或 `'.'`", "solution": "### BFS\n\n推倒骨牌是一个行为传递的过程,可以使用 `BFS` 来进行模拟。\n\n起始将所有不为 `.` 的骨牌以 $(loc, time, dire)$ 三元组的形式进行入队,三元组所代表的含义为「**位置为 $loc$ 的骨牌在 $time$ 时刻受到一个方向为 $dire$ 的力**」,然后进行常规的 `BFS` 即可。\n\n在受力(入队)时,我们尝试修改骨牌的状态,同时为了解决「一个骨牌同时受到左右推力时,维持站立状态不变」的问题,我们需要在尝试修改骨牌状态后,额外记录下该骨牌的状态修改时间,如果在同一时间内,一块骨牌受力两次(只能是来自左右两个方向的力),需要将该骨牌恢复成竖立状态。\n\n代码:\n```Java\nclass Solution {\n    public String pushDominoes(String dominoes) {\n        char[] cs = dominoes.toCharArray();\n        int n = cs.length;\n        int[] g = new int[n];\n        Deque<int[]> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            if (cs[i] == '.') continue;\n            int dire = cs[i] == 'L' ? -1 : 1;\n            d.add(new int[]{i, 1, dire});\n            g[i] = 1;\n        }\n        while (!d.isEmpty()) {\n            int[] info = d.pollFirst();\n            int loc = info[0], time = info[1], dire = info[2];\n            int ne = loc + dire;\n            if (cs[loc] == '.' || (ne < 0 || ne >= n)) continue;\n            if (g[ne] == 0) { // 首次受力\n                d.addLast(new int[]{ne, time + 1, dire});\n                g[ne] = time + 1;\n                cs[ne] = dire == -1 ? 'L' : 'R';\n            } else if (g[ne] == time + 1) { // 多次受力\n                cs[ne] = '.';\n            }\n        }\n        return String.valueOf(cs);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 预处理 + 双指针\n\n我们知道,**如果一块原本竖立的骨牌最终倒下,必然是「受到来自左侧向右的力」或者「受到来自右侧向左的力」**。\n\n基于此,我们可以**创建两个二维数组 `l` 和 `r` 分别存储每个位置 $i$ 的左侧和右侧的受力情况,每个的 $l[i]$ 和 $r[i]$ 分别存储「左侧」和「右侧」的最近受力点下标,以及该力的方向**。\n\n然后枚举所有 $dominoes[i]$ 为 `.` 的位置,获取其左侧的最近受力点 `loc1` 和受力方向 `dire1`,以及其右侧的最近受力点 `loc2` 和受力方向 `dire2`,并进行分情况讨论即可。\n\n根据左右侧受力情况修改骨牌状态可通过「双指针」实现。\n\n> 一些细节:为了避免每个样例都 `new` 大数组,可以使用 `static` 优化 `l` 和 `r` 的创建。\n\n代码:\n```Java\nclass Solution {\n    static int N = 100010;\n    static int[][] l = new int[N][2], r = new int[N][2];\n    public String pushDominoes(String dominoes) {\n        char[] cs = dominoes.toCharArray();\n        int n = cs.length;\n        for (int i = 0, j = -1; i < n; i++) {\n            if (cs[i] != '.') j = i;\n            l[i] = new int[]{j, j != -1 ? cs[j] : '.'};\n        }\n        for (int i = n - 1, j = -1; i >= 0; i--) {\n            if (cs[i] != '.') j = i;\n            r[i] = new int[]{j, j != -1 ? cs[j] : '.'};\n        }\n        for (int i = 0; i < n; ) {\n            if (cs[i] != '.' && ++i >= 0) continue;\n            int j = i;\n            while (j < n && cs[j] == '.') j++;\n            j--;\n            int[] a = l[i], b = r[j];\n            int loc1 = a[0], dire1 = a[1], loc2 = b[0], dire2 = b[1];\n            if (loc1 == -1 && loc2 == -1) { // 两侧无力\n            } else if (loc1 == -1) { // 只有右侧有力,且力的方向向左\n                if (dire2 == 'L') update(cs, i, j, 'L', 'L');\n            } else if (loc2 == -1) { // 只有左侧有力,且力的方向向右\n                if (dire1 == 'R') update(cs, i, j, 'R', 'R');\n            } else { // 两侧有力,且两力方向「不同时」反向\n                if (!(dire1 == 'L' && dire2 == 'R')) update(cs, i, j, (char)dire1, (char)dire2);\n            }\n            i = j + 1;\n        }\n        return String.valueOf(cs);\n    }\n    void update(char[] cs, int l, int r, char c1, char c2) {\n        for (int p = l, q = r; p <= q; p++, q--) {\n            if (p == q && c1 != c2) continue;\n            cs[p] = c1; cs[q] = c2;\n        }\n    }\n}\n```\n* 时间复杂度:预处理 `l` 和 `r` 的复杂度为 $O(n)$;构造答案复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.838` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/841-850/846. 一手顺子（中等）.md", "url_title": "846. 一手顺子", "url": "https://leetcode-cn.com/problems/hand-of-straights/solution/gong-shui-san-xie-shu-ju-jie-gou-mo-ni-t-4hxw/", "difficulty": "中等", "tags": ["模拟", "优先队列(堆)", "哈希表"], "question": "Alice 手中有一把牌,她想要重新排列这些牌,分成若干组,使每一组的牌数都是 groupSize ,并且由 groupSize 张连续的牌组成。\n\n给你一个整数数组 `hand` 其中 `hand[i]` 是写在第 `i` 张牌,和一个整数 `groupSize`。\n\n如果她可能重新排列这些牌,返回 `true` ;否则,返回 `false` 。\n\n示例 1:\n```\n输入:hand = [1,2,3,6,2,3,4,7,8], groupSize = 3\n\n输出:true\n\n解释:Alice 手中的牌可以被重新排列为 [1,2,3],[2,3,4],[6,7,8]。\n```\n示例 2:\n```\n输入:hand = [1,2,3,4,5], groupSize = 4\n\n输出:false\n\n解释:Alice 手中的牌无法被重新排列成几个大小为 4 的组。\n```\n\n提示:\n* $1 <= hand.length <= 10^4$\n* $0 <= hand[i] <= 10^9$\n* $1 <= groupSize <= hand.length$", "solution": "### 模拟 + 哈希表 + 优先队列(堆)\n\n为了方便,我们令 $m = groupSize$。\n\n题目要求我们将 $hand$ 分为若干份大小为 $m$ 的顺子。\n\n**在给定 $hand$ 的情况下,划分方式唯一确定,因此本质上这是一个「模拟」的过程。**\n\n具体的,我们可以使用「哈希表」对 $hand$ 中的数值进行「出现次数」统计,并用于后续 **实时** 维护剩余元素的出现次数。\n\n然后使用优先队列维护(小根堆)所有的 $hand[i]$。每次从优先队列(堆)中取出堆顶元素 $t$ 来 **尝试作为**「顺子」的发起点/首个元素(当然 $t$ 能够作为发起点的前提是 $t$ 仍是剩余元素,即实时维护的出现次数不为 $0$ ),然后用 $t$ 作为发起点/首个元素构造顺子,即对 $[t, t + 1, ... , t + m - 1]$ 元素的出现次数进行 $-1$ 操作。\n\n若构造过程中没有出现「剩余元素出现次数」不足以 $-1$ 的话,说明整个构造过程没有冲突,返回 `True`,否则返回 `False`。\n\n代码:\n```Java\nclass Solution {\n    public boolean isNStraightHand(int[] hand, int m) {\n        Map<Integer, Integer> map = new HashMap<>();\n        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->a-b);\n        for (int i : hand) {\n            map.put(i, map.getOrDefault(i, 0) + 1);\n            q.add(i);\n        }\n        while (!q.isEmpty()) {\n            int t = q.poll();\n            if (map.get(t) == 0) continue;\n            for (int i = 0; i < m; i++) {\n                int cnt = map.getOrDefault(t + i, 0);\n                if (cnt == 0) return false;\n                map.put(t + i, cnt - 1);\n            }\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为数组 `hand` 长度,使用哈希表进行次数统计的复杂度为 $O(n)$;将所有元素从堆中存入和取出的复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.846` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/841-850/847. 访问所有节点的最短路径（困难）.md", "url_title": "847. 访问所有节点的最短路径", "url": "https://leetcode-cn.com/problems/shortest-path-visiting-all-nodes/solution/gong-shui-san-xie-yi-ti-shuang-jie-bfs-z-6p2k/", "difficulty": "困难", "tags": ["图", "图论 BFS", "动态规划", "状态压缩", "AStar 算法", "启发式搜索"], "question": "存在一个由 $n$ 个节点组成的无向连通图,图中的节点按从 $0$ 到 $n - 1$ 编号。\n\n给你一个数组 `graph` 表示这个图。其中,$graph[i]$ 是一个列表,由所有与节点 $i$ 直接相连的节点组成。\n\n返回能够访问所有节点的最短路径的长度。你可以在任一节点开始和停止,也可以多次重访节点,并且可以重用边。\n\n示例 1:\n\n```\n输入:graph = [[1,2,3],[0],[0],[0]]\n\n输出:4\n\n解释:一种可能的路径为 [1,0,2,0,3]\n```\n示例 2:\n\n```\n输入:graph = [[1],[0,2,4],[1,3,4],[2],[1,2]]\n\n输出:4\n\n解释:一种可能的路径为 [0,1,4,2,3]\n```\n\n提示:\n* $n == graph.length$\n* $1 <= n <= 12$\n* $0 <= graph[i].length < n$\n* `graph[i]` 不包含 $i$\n* 如果 `graph[a]` 包含 `b` ,那么 `graph[b]` 也包含 `a`\n* 输入的图总是连通图", "solution": "### 基本分析 \n\n为了方便,令点的数量为 $n$,边的数量为 $m$。\n\n这是一个等权无向图,题目要我们求从「**一个点都没访问过**」到「**所有点都被访问**」的最短路径。\n\n同时 $n$ 只有 $12$,容易想到使用「状态压缩」来代表「当前点的访问状态」:**使用二进制表示长度为 $32$ 的 `int` 的低 $12$ 来代指点是否被访问过。**\n\n我们可以通过一个具体的样例,来感受下「状态压缩」是什么意思:\n\n例如 $(000...0101)_2$ 代表编号为 $0$ 和编号为 $2$ 的节点已经被访问过,而编号为 $1$ 的节点尚未被访问。\n\n然后再来看看使用「状态压缩」的话,一些基本的操作该如何进行:\n\n假设变量 $state$ 存放了「当前点的访问状态」,当我们需要检查编号为 $x$ 的点是否被访问过时,可以使用位运算 `a = (state >> x) & 1`,来获取 $state$ 中第 $x$ 位的二进制表示,如果 `a` 为 $1$ 代表编号为 $x$ 的节点已被访问,如果为 $0$ 则未被访问。\n\n同理,当我们需要将标记编号为 $x$ 的节点已经被访问的话,可以使用位运算 `state | (1 << x)` 来实现标记。\n\n---\n\n### 状态压缩 + BFS\n\n因为是等权图,求从某个状态到另一状态的最短路,容易想到 `BFS`。\n\n同时我们需要知道下一步能往哪些点进行移动,因此除了记录当前的点访问状态 $state$ 以外,还需要记录最后一步是在哪个点 $u$,因此我们需要使用二元组进行记录 $(state, u)$,同时使用 $dist$ 来记录到达 $(state, u)$ 使用的步长是多少。\n\n> 一些细节:由于点的数量较少,使用「邻接表」或者「邻接矩阵」来存图都可以。对于本题,由于已经给出了 $graph$ 数组,因此可以直接充当「邻接表」来使用,而无须做额外的存图操作。\n\n代码:\n```Java\nclass Solution {\n    int INF = 0x3f3f3f3f;\n    public int shortestPathLength(int[][] graph) {\n        int n = graph.length;\n        int mask = 1 << n;\n\n        // 初始化所有的 (state, u) 距离为正无穷\n        int[][] dist = new int[mask][n];\n        for (int i = 0; i < mask; i++) Arrays.fill(dist[i], INF);\n\n        // 因为可以从任意起点出发,先将起始的起点状态入队,并设起点距离为 0\n        Deque<int[]> d = new ArrayDeque<>(); // state, u\n        for (int i = 0; i < n; i++) {\n            dist[1 << i][i] = 0;\n            d.addLast(new int[]{1 << i, i});\n        }\n\n        // BFS 过程,如果从点 u 能够到达点 i,则更新距离并进行入队\n        while (!d.isEmpty()) {\n            int[] poll = d.pollFirst();\n            int state = poll[0], u = poll[1], step = dist[state][u];\n            if (state == mask - 1) return step;\n            for (int i : graph[u]) {\n                if (dist[state | (1 << i)][i] == INF) {\n                    dist[state | (1 << i)][i] = step + 1;\n                    d.addLast(new int[]{state | (1 << i), i});\n                }\n            }\n        }\n        return -1; // never\n    }\n}\n```\n* 时间复杂度:点(状态)数量为 $n \\times 2^n$,边的数量为 $n^2 \\times 2^n$,`BFS` 复杂度上界为点数加边数,整体复杂度为 $O(n^2 \\times 2^n)$\n* 空间复杂度:$O(n \\times 2^n)$\n\n---\n\n### Floyd + 状压 DP\n\n其实在上述方法中,我们已经使用了与 DP 状态定义分析很像的思路了。甚至我们的元祖设计 $(state, u)$ 也很像状态定义的两个维度。\n\n**那么为什么我们不使用 $f[state][u]$ 为从「没有点被访问过」到「访问过的点状态为 $state$」,并最后一步落在点 $u$ 的状态定义,然后跑一遍 DP 来做呢?** \n\n**是因为如果从「常规的 DP 转移思路」出发,状态之间不存在拓扑序(有环),这就导致了我们在计算某个 $f[state][u]$ 时,它所依赖的状态并不确保已经被计算/更新完成,所以我们无法使用常规的 DP 手段来求解。**\n\n> 这里说的常规 DP 手段是指:枚举所有与 $u$ 相连的节点 $v$,用 $f[state'][v]$ 来更新 $f[state][u]$ 的转移方式。\n\n常规的 DP 转移方式状态间不存在拓扑序,我们需要换一个思路进行转移。\n\n对于某个 $state$ 而言,我们可以枚举其最后一个点 $i$ 是哪一个,充当其达到 $state$ 的最后一步,然后再枚举下一个点 $j$ 是哪一个,充当移动的下一步(当然前提是满足 $state$ 的第 $i$ 位为 $1$,而第 $j$ 位为 $0$)。\n\n求解任意两点最短路径,可以使用 Floyd 算法,复杂度为 $O(n^3)$。\n\n代码:\n```Java\nclass Solution {\n    int INF = 0x3f3f3f3f;\n    public int shortestPathLength(int[][] graph) {\n        int n = graph.length;\n        int mask = 1 << n;\n        \n        // Floyd 求两点的最短路径\n        int[][] dist = new int[n][n];\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                dist[i][j] = INF;\n            }\n        }\n        for (int i = 0; i < n; i++) {\n            for (int j : graph[i]) dist[i][j] = 1;\n        }\n        for (int k = 0; k < n; k++) {\n            for (int i = 0; i < n; i++) {\n                for (int j = 0; j < n; j++) {\n                    dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);\n                }\n            }\n        }\n        \n        // DP 过程,如果从 i 能够到 j 的话,使用 i 到 j 的最短距离(步长)来转移\n        int[][] f = new int[mask][n];\n        // 起始时,让所有状态的最短距离(步长)为正无穷\n        for (int i = 0; i < mask; i++) Arrays.fill(f[i], INF);\n        // 由于可以将任意点作为起点出发,可以将这些起点的最短距离(步长)设置为 0\n        for (int i = 0; i < n; i++) f[1 << i][i] = 0;\n\n        // 枚举所有的 state\n        for (int state = 0; state < mask; state++) {\n            // 枚举 state 中已经被访问过的点\n            for (int i = 0; i < n; i++) {\n                if (((state >> i) & 1) == 0) continue;\n                // 枚举 state 中尚未被访问过的点\n                for (int j = 0; j < n; j++) {\n                    if (((state >> j) & 1) == 1) continue;\n                    f[state | (1 << j)][j] = Math.min(f[state | (1 << j)][j], f[state][i] + dist[i][j]);\n                }\n            }\n        }\n\n        int ans = INF;\n        for (int i = 0; i < n; i++) ans = Math.min(ans, f[mask - 1][i]);\n        return ans;\n    }\n}\n```\n* 时间复杂度:Floyd 复杂度为 $O(n^3)$;DP 共有 $n \\times 2^n$ 个状态需要被转移,每次转移复杂度为 $O(n)$,总的复杂度为 $O(n^2 \\times 2^n)$。整体复杂度为 $O(\\max(n^3, n^2 \\times 2^n))$\n* 空间复杂度:$O(n \\times 2^n)$\n\n---\n\n### AStar 算法\n\n显然,从 $state$ 到 $state'$ 的「理论最小修改成本」为两者二进制表示中不同位数的个数。\n\n同时,当且仅当在 $state$ 中 $1$ 的位置与 $state'$ 中 $0$ 存在边,才有可能取到这个「理论最小修改成本」。\n\n因此直接使用当前状态 $state$ 与最终目标状态 `1 << n` 两者二进制表示中不同位数的个数作为启发预估值是合适的。\n\n代码:\n```Java\nclass Solution {\n    int INF = 0x3f3f3f3f;\n    int n;\n    int f(int state) {\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            if (((state >> i) & 1) == 0) ans++;\n        }\n        return ans;\n    }\n    public int shortestPathLength(int[][] g) {\n        n = g.length;\n        int mask = 1 << n;\n        int[][] dist = new int[mask][n];\n        for (int i = 0; i < mask; i++) {\n            for (int j = 0; j < n; j++) {\n                dist[i][j] = INF;\n            }\n        }\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[2]-b[2]); // state, u, val\n        for (int i = 0; i < n; i++) {\n            dist[1 << i][i] = 0;\n            q.add(new int[]{1<< i, i, f(i << 1)});\n        }\n        while (!q.isEmpty()) {\n            int[] poll = q.poll();\n            int state = poll[0], u = poll[1], step = dist[state][u];\n            if (state == mask - 1) return step;\n            for (int i : g[u]) {\n                int nState = state | (1 << i);\n                if (dist[nState][i] > step + 1) {\n                    dist[nState][i] = step + 1;\n                    q.add(new int[]{nState, i, step + 1 + f(nState)});\n                }\n            }\n        }\n        return -1; // never\n    }\n}\n```\n* 时间复杂度:启发式搜索不讨论时空复杂度\n* 空间复杂度:启发式搜索不讨论时空复杂度", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.847` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/841-850/850. 矩形面积 II（困难）.md", "url_title": "850. 矩形面积 II", "url": "https://leetcode.cn/problems/rectangle-area-ii/solution/gong-shui-san-xie-by-ac_oier-9r36/", "difficulty": "困难", "tags": ["扫描线"], "question": "我们给出了一个(轴对齐的)二维矩形列表 `rectangles`。 对于 $rectangle[i] = [x_1, y_1, x_2, y_2]$,其中$(x_1, y_1)$ 是矩形 `i` 左下角的坐标,$ (x_{i1}, y_{i1})$ 是该矩形 左下角 的坐标,$ (x_{i2}, y_{i2})$ 是该矩形 右上角 的坐标。\n\n计算平面中所有 `rectangles` 所覆盖的 总面积 。任何被两个或多个矩形覆盖的区域应只计算 一次 。\n\n返回 总面积 。因为答案可能太大,返回 $10^9 + 7$ 的 模 。\n\n示例 1:\n\n```\n输入:rectangles = [[0,0,2,2],[1,0,2,3],[1,0,3,1]]\n\n输出:6\n\n解释:如图所示,三个矩形覆盖了总面积为6的区域。\n从(1,1)到(2,2),绿色矩形和红色矩形重叠。\n从(1,0)到(2,3),三个矩形都重叠。\n```\n示例 2:\n```\n输入:rectangles = [[0,0,1000000000,1000000000]]\n\n输出:49\n\n解释:答案是 1018 对 (109 + 7) 取模的结果, 即 49 。\n```\n\n提示:\n* $1 <= rectangles.length <= 200$\n* $rectanges[i].length = 4$\n* $0 <= x_{i1}, y_{i1}, x_{i2}, y_{i2} <= 10^9$\n* 矩形叠加覆盖后的总面积不会超越 $2^{63} - 1$ ,这意味着可以用一个 `64` 位有符号整数来保存面积结果。", "solution": "### 扫描线\n\n这是一道「扫描线」模板题。\n\n将所有给定的矩形的左右边对应的 `x` 端点提取出来并排序,每个端点可看作是一条竖直的线段(红色),问题转换为求解「由多条竖直线段分割开」的多个矩形的面积总和(黄色):\n\n相邻线段之间的宽度为单个矩形的「宽度」(通过 `x` 差值直接算得),问题转换为求该区间内高度的并集(即矩形的高度)。\n\n由于数据范围只有 $200$,我们可以对给定的所有矩形进行遍历,统计所有对该矩形有贡献的 `y` 值线段(即有哪些 `rs[i]` 落在该矩形中),再对线段进行求交集(总长度),即可计算出该矩形的「高度」,从而计算出来该矩形的面积。\n\nJava 代码:\n```Java\nclass Solution {\n    int MOD = (int)1e9+7;\n    public int rectangleArea(int[][] rs) {\n        List<Integer> list = new ArrayList<>();\n        for (int[] info : rs) {\n            list.add(info[0]); list.add(info[2]);\n        }\n        Collections.sort(list);\n        long ans = 0;\n        for (int i = 1; i < list.size(); i++) {\n            int a = list.get(i - 1), b = list.get(i), len = b - a;\n            if (len == 0) continue;\n            List<int[]> lines = new ArrayList<>();\n            for (int[] info : rs) {\n                if (info[0] <= a && b <= info[2]) lines.add(new int[]{info[1], info[3]});\n            }\n            Collections.sort(lines, (l1, l2)->{\n                return l1[0] != l2[0] ? l1[0] - l2[0] : l1[1] - l2[1];\n            });\n            long tot = 0, l = -1, r = -1;\n            for (int[] cur : lines) {\n                if (cur[0] > r) {\n                    tot += r - l;\n                    l = cur[0]; r = cur[1];\n                } else if (cur[1] > r) {\n                    r = cur[1];\n                }\n            }\n            tot += r - l;\n            ans += tot * len;\n            ans %= MOD;\n        }\n        return (int) ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nconst MOD = BigInt(1e9+7)\nfunction rectangleArea(rs: number[][]): number {\n    const list = new Array<number>()\n    for (let info of rs) {\n        list.push(info[0]); list.push(info[2]);\n    }\n    list.sort((a,b)=>a-b)\n    let ans = 0n\n    for (let i = 1; i < list.length; i++) {\n        const a = list[i - 1], b = list[i], len = b - a\n        if (len == 0) continue\n        const lines = new Array<number[]>()\n        for (let info of rs) {\n            if (info[0] <= a && b <= info[2]) lines.push([info[1], info[3]])\n        }\n        lines.sort((l1,l2)=>{\n            return l1[0] != l2[0] ? l1[0] - l2[0] : l1[1] - l2[1]\n        })\n        let tot = 0n, l = -1, r = -1\n        for (let cur of lines) {\n            if (cur[0] > r) {\n                tot += BigInt(r - l)\n                l = cur[0]; r = cur[1]\n            } else if (cur[1] > r) {\n                r = cur[1]\n            }\n        }\n        tot += BigInt(r - l)\n        ans += tot * BigInt(len)\n        ans %= MOD\n    }\n    return Number(ans)\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def rectangleArea(self, rs: List[List[int]]) -> int:\n        ps = []\n        for info in rs:\n            ps.append(info[0])\n            ps.append(info[2])\n        ps.sort()\n        ans = 0\n        for i in range(1, len(ps)):\n            a, b = ps[i - 1], ps[i]\n            width = b - a\n            if width == 0:\n                continue\n            lines = [(info[1], info[3]) for info in rs if info[0] <= a and b <= info[2]]\n            lines.sort()\n            height, l, r = 0, -1, -1\n            for cur in lines:\n                if cur[0] > r:\n                    height += r - l\n                    l, r = cur\n                elif cur[1] > r:\n                    r = cur[1]\n            height += r - l\n            ans += height * width\n        return ans % 1000000007\n```\nGo 代码:\n```Go\nconst MOD = int64(1e9 + 7)\nfunc rectangleArea(rectangles [][]int) int {\n    list := []int{}\n    for _, info := range rectangles {\n        list = append(list, info[0])\n        list = append(list, info[2])\n    }\n    sort.Ints(list)\n    ans := int64(0)\n    for i := 1; i < len(list); i++ {\n        a, b, length := list[i - 1], list[i], list[i] - list[i - 1]\n        if length == 0 {\n            continue\n        }\n        lines := [][]int{}\n        for _, info := range rectangles {\n            if info[0] <= a && b <= info[2] {\n                lines = append(lines, []int{info[1], info[3]})\n            }\n        }\n        sort.Slice(lines, func(i,j int) bool {\n            if lines[i][0] != lines[j][0] {\n                return lines[i][0] - lines[j][0] < 0\n            }\n            return lines[i][1] - lines[j][1] < 0\n        })\n        total, l, r := int64(0), -1, -1\n        for _, cur := range lines {\n            if cur[0] > r {\n                total += int64(r - l)\n                l, r = cur[0], cur[1]\n            } else if cur[1] > r {\n                r = cur[1]\n            }\n        }\n        total += int64(r - l)\n        ans += total * int64(length)\n        ans %= MOD\n    }\n    return int(ans)\n}\n```\n* 时间复杂度:预处理所有扫描线的复杂度为 $O(n\\log{n})$;处理所有相邻的扫描线,并计算相邻扫描线形成的矩形面积复杂度为 $O(n\\log{n})$ 。整体复杂度为 $O(n^2\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.850` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/851-860/851. 喧闹和富有（中等）.md", "url_title": "851. 喧闹和富有", "url": "https://leetcode-cn.com/problems/loud-and-rich/solution/gong-shui-san-xie-tuo-bu-pai-xu-yun-yong-ylih/", "difficulty": "中等", "tags": ["拓扑排序"], "question": "有一组 `n` 个人作为实验对象,从 `0` 到 `n - 1` 编号,其中每个人都有不同数目的钱,以及不同程度的安静值(`quietness`)。为了方便起见,我们将编号为 `x` 的人简称为 `\"person x\"`。\n\n给你一个数组 `richer` ,其中 `richer[i] = [ai, bi]` 表示 $person$ $a_i$ 比 $person$ $b_i$ 更有钱。另给你一个整数数组 `quiet`,其中 `quiet[i]` 是 $person_i$ 的安静值。\n\n`richer` 中所给出的数据 逻辑自恰(也就是说,在 $person_x$ 比 $person_y$ 更有钱的同时,不会出现 $person_y$ 比 $person_x$ 更有钱的情况 )。\n\n现在,返回一个整数数组 `answer` 作为答案,其中 `answer[x] = y` 的前提是,在所有拥有的钱肯定不少于 `person x` 的人中,`person y` 是最安静的人(也就是安静值 `quiet[y]` 最小的人)。\n\n示例 1:\n```\n输入:richer = [[1,0],[2,1],[3,1],[3,7],[4,3],[5,3],[6,3]], quiet = [3,2,5,4,6,1,7,0]\n\n输出:[5,5,2,5,4,5,6,7]\n\n解释: \nanswer[0] = 5,\nperson 5 比 person 3 有更多的钱,person 3 比 person 1 有更多的钱,person 1 比 person 0 有更多的钱。\n唯一较为安静(有较低的安静值 quiet[x])的人是 person 7,\n但是目前还不清楚他是否比 person 0 更有钱。\nanswer[7] = 7,\n在所有拥有的钱肯定不少于 person 7 的人中(这可能包括 person 3,4,5,6 以及 7),\n最安静(有较低安静值 quiet[x])的人是 person 7。\n其他的答案也可以用类似的推理来解释。\n```\n示例 2:\n```\n输入:richer = [], quiet = [0]\n\n输出:[0]\n```\n\n提示:\n* $n == quiet.length$\n* $1 <= n <= 500$\n* $0 <= quiet[i] < n$\n* $quiet$ 的所有值 互不相同\n* $0 <= richer.length <= n * (n - 1) / 2$\n* $0 <= ai, bi < n$\n* $ai != bi$\n* `richer` 中的所有数对 互不相同\n* 对 `richer` 的观察在逻辑上是一致的", "solution": "### 拓扑排序\n\n根据题意,我们可以使用 `richer` 进行建图(邻接矩阵/邻接表),对于每组 $richer[i] = (a_i, b_i)$ 而言,添加一条从 $a$ 到 $b$ 的有向边(有钱指向没钱)。\n\n其中题目中的「`richer` 逻辑自恰」是指在该图中不存在环,即为 DAG。\n\n因此我们可以在建图过程中,同时统计每个节点的入度数,然后在图中跑一遍拓扑排序来求得答案 $ans$。\n\n**对「图论 拓扑排序」不了解的同学,可以先看前置 🧀:[拓扑排序入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489706&idx=1&sn=771cd807f39d1ca545640c0ef7e5baec&chksm=fd9cb3b5caeb3aa333809633f09e3967c8f62d10feec5a463c7e30d4781e1fecb50e7f46e4af&token=126965152&lang=zh_CN#rd),里面详细说明了「拓扑排序的基本流程」&「反向图 + 拓扑排序做法的正确性证明」。**\n\n起始时,每个 $ans[i] = i$,然后将统计入度为 $0$ 的节点进行入队,每次出队时,将该节点删掉,对该 DAG 带来影响是「该节点的邻点的入度减一」,若更新入度后数值为 $0$,则将该邻点进行入队操作。\n\n同时,利用跑拓扑排序过程中的 $t -> u$ 关系,尝试使用 $ans[t]$ 更新 $ans[u]$(由于存在 $t$ 指向 $u$ 的边,说明 $t$ 比 $u$ 有钱,此时检查两者的安静值,若满足 $quiet[ans[t]] < quiet[ans[u]]$,则用 $ans[t]$ 更新 $ans[u]$)。\n\n> 本题为稠密图(点数为 $n$,边数为 $m$,当 $m$ 与 $n^2$ 为同一数据级,定义以为稠密图),可直接使用「邻接矩阵」进行存图。\n关于何种图选择什么存图方式,在 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488007&idx=1&sn=9d0dcfdf475168d26a5a4bd6fcd3505d&chksm=fd9cb918caeb300e1c8844583db5c5318a89e60d8d552747ff8c2256910d32acd9013c93058f&token=126965152&lang=zh_CN#rd) 详细讲过,本次不再赘述。\n\n代码($P1$ 为邻接矩阵,$P2$ 为邻接表):\n```Java\nclass Solution {\n    public int[] loudAndRich(int[][] richer, int[] quiet) {\n        int n = quiet.length;\n        int[][] w = new int[n][n];\n        int[] in = new int[n];\n        for (int[] r : richer) {\n            int a = r[0], b = r[1];\n            w[a][b] = 1; in[b]++;\n        }\n        Deque<Integer> d = new ArrayDeque<>();\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) {\n            ans[i] = i;\n            if (in[i] == 0) d.addLast(i);\n        }\n        while (!d.isEmpty()) {\n            int t = d.pollFirst();\n            for (int u = 0; u < n; u++) {\n                if (w[t][u] == 1) {\n                    if (quiet[ans[t]] < quiet[ans[u]]) ans[u] = ans[t];\n                    if (--in[u] == 0) d.addLast(u);\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\n\n```Java\nclass Solution {\n    int N = 510, M = N * N + 10;\n    int[] he = new int[N], e = new int[M], ne = new int[M];\n    int idx;\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx;\n        idx++;\n    }\n    public int[] loudAndRich(int[][] richer, int[] quiet) {\n        int n = quiet.length;\n        int[] in = new int[n];\n        Arrays.fill(he, -1);\n        for (int[] r : richer) {\n            int a = r[0], b = r[1];\n            add(a, b); in[b]++;\n        }\n        Deque<Integer> d = new ArrayDeque<>();\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) {\n            ans[i] = i;\n            if (in[i] == 0) d.addLast(i);\n        }\n        while (!d.isEmpty()) {\n            int t = d.pollFirst();\n            for (int i = he[t]; i != -1; i = ne[i]) {\n                int u = e[i];\n                if (quiet[ans[t]] < quiet[ans[u]]) ans[u] = ans[t];\n                if (--in[u] == 0) d.addLast(u);\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为 `person` 数量(点数),$m$ 为 `richer` 长度(边数)。的建图的复杂度为 $O(m)$;拓扑排序复杂度为 $O(m + n)$。整体复杂度为 $O(m + n)$\n* 空间复杂度:$O(m + n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.851` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/851-860/852. 山脉数组的峰顶索引（简单）.md", "url_title": "852. 山脉数组的峰顶索引", "url": "https://leetcode-cn.com/problems/peak-index-in-a-mountain-array/solution/gong-shui-san-xie-er-fen-san-fen-cha-zhi-5gfv/", "difficulty": "简单", "tags": ["二分", "三分"], "question": "符合下列属性的数组 `arr` 称为 山脉数组 :\n* `arr.length >= 3`\n* 存在 `i(0 < i < arr.length - 1)` 使得:\n  * `arr[0] < arr[1] < ... arr[i-1] < arr[i]`\n  * `arr[i] > arr[i+1] > ... > arr[arr.length - 1]`\n\n给你由整数组成的山脉数组 `arr` ,返回任何满足 `arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1]` 的下标 `i` 。\n\n示例 1:\n```\n输入:arr = [0,1,0]\n\n输出:1\n```\n示例 2:\n```\n输入:arr = [0,2,1,0]\n\n输出:1\n```\n示例 3:\n```\n输入:arr = [0,10,5,2]\n\n输出:1\n```\n示例 4:\n```\n输入:arr = [3,4,5,1]\n\n输出:2\n```\n示例 5:\n```\n输入:arr = [24,69,100,99,79,78,67,36,26,19]\n\n输出:2\n```\n\n提示:\n* $3 <= arr.length <= 10^4$\n* $0 <= arr[i] <= 10^6$\n* 题目数据保证 `arr` 是一个山脉数组\n\n进阶:很容易想到时间复杂度 $O(n)$ 的解决方案,你可以设计一个 $O(\\log{n})$ 的解决方案吗?", "solution": "### 二分\n\n往常我们使用「二分」进行查值,需要确保序列本身满足「二段性」:当选定一个端点(基准值)后,结合「一段满足 & 另一段不满足」的特性来实现“折半”的查找效果。\n\n但本题求的是峰顶索引值,如果我们选定数组头部或者尾部元素,其实无法根据大小关系“直接”将数组分成两段。\n\n但可以利用题目发现如下性质:**由于 `arr` 数值各不相同,因此峰顶元素左侧必然满足严格单调递增,峰顶元素右侧必然不满足。**\n\n因此 **以峰顶元素为分割点的 `arr` 数组,根据与 前一元素/后一元素 的大小关系,具有二段性:**\n\n* 峰顶元素左侧满足 $arr[i-1] < arr[i]$ 性质,右侧不满足\n* 峰顶元素右侧满足 $arr[i] > arr[i+1]$ 性质,左侧不满足\n\n因此我们可以选择任意条件,写出若干「二分」版本。\n\n代码:\n```Java\nclass Solution {\n    // 根据 arr[i-1] < arr[i] 在 [1,n-1] 范围内找值\n    // 峰顶元素为符合条件的最靠近中心的元素\n    public int peakIndexInMountainArray(int[] arr) {\n        int n = arr.length;\n        int l = 1, r = n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (arr[mid - 1] < arr[mid]) l = mid;    \n            else r = mid - 1;\n        }\n        return r;\n    }\n}\n```\n```Java\nclass Solution {\n    // 根据 arr[i] > arr[i+1] 在 [0,n-2] 范围内找值\n    // 峰顶元素为符合条件的最靠近中心的元素值\n    public int peakIndexInMountainArray(int[] arr) {\n        int n = arr.length;\n        int l = 0, r = n - 2;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (arr[mid] > arr[mid + 1]) r = mid;    \n            else l = mid + 1;\n        }\n        return r;\n    }\n}\n```\n```Java\nclass Solution {\n    // 根据 arr[i-1] > arr[i] 在 [1,n-1] 范围内找值\n    // 峰顶元素为符合条件的最靠近中心的元素的前一个值\n    public int peakIndexInMountainArray(int[] arr) {\n        int n = arr.length;\n        int l = 1, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (arr[mid - 1] > arr[mid]) r = mid;    \n            else l = mid + 1;\n        }\n        return r - 1;\n    }\n}\n```\n```Java\nclass Solution {\n    // 根据 arr[i] < arr[i+1] 在 [0,n-2] 范围内找值\n    // 峰顶元素为符合条件的最靠近中心的元素的下一个值\n    public int peakIndexInMountainArray(int[] arr) {\n        int n = arr.length;\n        int l = 0, r = n - 2;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (arr[mid] < arr[mid + 1]) l = mid;\n            else r = mid - 1;\n        }\n        return r + 1;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 三分\n\n事实上,我们还可以利用「三分」来解决这个问题。\n\n顾名思义,**「三分」就是使用两个端点将区间分成三份,然后通过每次否决三分之一的区间来逼近目标值。**\n\n具体的,由于峰顶元素为全局最大值,因此我们可以每次将当前区间分为 $[l, m1]$、$[m1, m2]$ 和 $[m2, r]$ 三段,如果满足 $arr[m1] > arr[m2]$,说明峰顶元素不可能存在与 $[m2, r]$ 中,让 $r = m2 - 1$ 即可。另外一个区间分析同理。\n\n代码:\n```Java\nclass Solution {\n    public int peakIndexInMountainArray(int[] arr) {\n        int n = arr.length;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int m1 = l + (r - l) / 3, m2 = r - (r - l) / 3;\n            if (arr[m1] > arr[m2]) r = m2 - 1;                \n            else l = m1 + 1;    \n        }\n        return r;\n    }\n}\n```\n* 时间复杂度:$O(\\log_3{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 二分 & 三分 & k 分 ?\n\n必须说明一点,「二分」和「三分」在渐进复杂度上都是一样的,都可以通过换底公式转化为可忽略的常数,因此两者的复杂度都是 $O(\\log{n})$。\n\n而选择「二分」还是「三分」取决于要解决的是什么问题:\n\n* 二分通常用来解决单调函数的找 $target$ 问题,但进一步深入我们发现只需要满足「二段性」就能使用「二分」来找分割点;\n* 三分则是解决单峰函数极值问题。\n\n**因此一般我们将「通过比较两个端点,每次否决 1/3 区间 来解决单峰最值问题」的做法称为「三分」;而不是简单根据单次循环内将区间分为多少份来判定是否为「三分」。**\n\n随手写了一段反例代码:\n```Java\nclass Solution {\n    public int peakIndexInMountainArray(int[] arr) {\n        int left = 0, right = arr.length - 1;\n        while(left < right) {\n            int m1 = left + (right - left) / 3;\n            int m2 = right - (right - left + 2) / 3;\n            if (arr[m1] > arr[m1 + 1]) {\n                right = m1;\n            } else if (arr[m2] < arr[m2 + 1]) {\n                left = m2 + 1;\n            } else {\n                left = m1; right = m2;\n            }\n        }\n        return left;\n    }\n}\n```\n\n这并不是「三分」做法,最多称为「变形二分」。本质还是利用「二段性」来做分割的,只不过同时 check 了两个端点而已。\n\n如果这算「三分」的话,那么我能在一次循环里面划分 $k - 1$ 个端点来实现 $k$ 分?\n\n**显然这是没有意义的,因为按照这种思路写出来的所谓的「四分」、「五分」、「k 分」是需要增加同等数量的分支判断的。这时候单次 `while` 决策就不能算作 $O(1)$ 了,而是需要在 $O(k)$ 的复杂度内决定在哪个分支,就跟上述代码有三个分支进行判断一样。** 因此,这种写法只能算作是「变形二分」。\n\n**综上,只有「二分」和「三分」的概念,不存在所谓的 $k$ 分。** 同时题解中的「三分」部分提供的做法就是标准的「三分」做法。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.852` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/851-860/854. 相似度为 K 的字符串（困难）.md", "url_title": "854. 相似度为 K 的字符串", "url": "https://leetcode.cn/problems/k-similar-strings/solution/by-ac_oier-w8nf/", "difficulty": "困难", "tags": ["启发式搜索", "AStar 算法"], "question": "对于某些非负整数 `k` ,如果交换 $s_1$ 中两个字母的位置恰好 `k` 次,能够使结果字符串等于 $s_2$ ,则认为字符串 $s_1$ 和 $s_2$ 的 相似度为 `k` 。\n\n给你两个字母异位词 $s_1$ 和 $s_2$ ,返回 $s_1$ 和 $s_2$ 的相似度 `k` 的最小值。\n\n示例 1:\n```\n输入:s1 = \"ab\", s2 = \"ba\"\n\n输出:1\n```\n示例 2:\n```\n输入:s1 = \"abc\", s2 = \"bca\"\n\n输出:2\n```\n\n提示:\n* $1 <= s1.length <= 20$\n* $s2.length = s1.length$\n* `s1` 和 `s2`  只包含集合 `{'a', 'b', 'c', 'd', 'e', 'f'}` 中的小写字母\n* `s2` 是 `s1` 的一个字母异位词", "solution": "### AStar 算法\n\n由于题目确保了 `s1` 和 `s2` 互为字母异位词(必然有解),因此最好的求解方式是使用 AStar 算法。\n\n可直接根据本题规则来设计 AStar 的启发式函数: 对于两个状态 `a` 和 `b` 直接计算出「理论最小转换次数」: **不同字符串的转换成本之和,由于每一次交换最多可减少两个不同的字符,我们可计算 `a` 与 `b` 的不同字符数量 $ans$,对应的理论最小转换次数为 $\\left \\lfloor \\frac{ans + 1}{2} \\right \\rfloor$。**\n\n需要注意的是:**由于我们衡量某个字符 `str` 的估值是以目标字符串 `target` 为基准,因此我们只能确保 `target` 出队时为「距离最短」,而不能确保中间节点出队时「距离最短」,因此我们不能单纯根据某个节点是否「曾经入队」而决定是否入队,还要结合当前节点的「最小距离」是否被更新而决定是否入队。**\n\n> 一些细节:在使用当前状态(字符串)`poll` 拓展新状态(字符串)`nstr` 时,只拓展能够减少不同字符数量的方案,从而收窄搜索空间。\n\nJava 代码:\n```Java\nclass Solution {\n    int n;\n    String t;\n    int f(String s) {\n        int ans = 0;\n        for (int i = 0; i < n; i++) ans += s.charAt(i) != t.charAt(i) ? 1 : 0;\n        return ans + 1 >> 1;\n    }\n    public int kSimilarity(String s1, String s2) {\n        if (s1.equals(s2)) return 0;\n        t = s2;\n        n = s1.length();\n        Map<String, Integer> map = new HashMap<>();\n        PriorityQueue<String> pq = new PriorityQueue<>((a,b)->{\n            int v1 = f(a), v2 = f(b), d1 = map.get(a), d2 = map.get(b);\n            return (v1 + d1) - (v2 + d2);\n        });\n        map.put(s1, 0);\n        pq.add(s1);\n        while (!pq.isEmpty()) {\n            String poll = pq.poll();\n            int step = map.get(poll);\n            char[] cs = poll.toCharArray();\n            int idx = 0;\n            while (idx < n && cs[idx] == t.charAt(idx)) idx++;\n            for (int i = idx + 1; i < n; i++) {\n                if (cs[i] != t.charAt(idx) || cs[i] == t.charAt(i)) continue;\n                swap(cs, idx, i);\n                String nstr = String.valueOf(cs);\n                swap(cs, idx, i);\n                if (map.containsKey(nstr) && map.get(nstr) <= step + 1) continue;\n                if (nstr.equals(t)) return step + 1;\n                map.put(nstr, step + 1);\n                pq.add(nstr);\n            }\n        }\n        return -1; // never\n    }\n    void swap(char[] cs, int i, int j) {\n        char c = cs[i];\n        cs[i] = cs[j];\n        cs[j] = c;\n    }\n}\n```\n* 时间复杂度:启发式搜索不分析时空复杂度\n* 空间复杂度:启发式搜索不分析时空复杂度", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.854` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/851-860/856. 括号的分数（中等）.md", "url_title": "856. 括号的分数", "url": "https://leetcode.cn/problems/score-of-parentheses/solution/by-ac_oier-0mhz/", "difficulty": "中等", "tags": ["栈"], "question": "给定一个平衡括号字符串 `S`,按下述规则计算该字符串的分数:\n\n* `()` 得 `1` 分。\n* `AB` 得 `A + B` 分,其中 `A` 和 `B` 是平衡括号字符串。\n* `(A)` 得 `2 * A` 分,其中 `A` 是平衡括号字符串。\n\n示例 1:\n```\n输入: \"()\"\n\n输出: 1\n```\n示例 2:\n```\n输入: \"(())\"\n\n输出: 2\n```\n示例 3:\n```\n输入: \"()()\"\n\n输出: 2\n```\n示例 4:\n```\n输入: \"(()(()))\"\n\n输出: 6\n```\n\n提示:\n* `S` 是平衡括号字符串,且只含有 `(` 和 `)` 。\n* $2 <= S.length <= 50$", "solution": "### 栈\n\n初始化将答案 `0` 放入栈中,从前往后处理整个 `s`,当遇到 `(` 则存入一个占位数值 `0`,遇到 `)` 取出栈顶元素 `cur`,根据栈顶元素数值值分情况讨论:\n\n* 栈顶元素 $cur = 0$,即当前的 `)` 的前一元素即是 `(` ,根据 `()` 得一分的规则可知,我们本次操作得到的分值为 $1$;\n* 栈顶元素 $cur \\neq 0$,即当前 `)` 与其匹配的 `(` 中间相隔了其他字符,根据 `(A)` 的得分规则,此时可知得分为 $cur \\times 2$;\n\n将两者结合可统一为 $\\max(cur \\times 2, 1)$。\n\n由于我们每次遇到 `)` 时,都将最近一次操作计算出来。而再前面无论是 `)` 还是 `(` 我们都可以归结到 `X()` 的相邻项累加规则,将其新得分累加到栈顶元素上,其中 `(` 仍采用累加规则,则利用我们将 `(` 定义为 $0$ 的设定。\n\nJava 代码:\n```Java\nclass Solution {\n    public int scoreOfParentheses(String s) {\n        Deque<Integer> d = new ArrayDeque<>();\n        d.addLast(0);\n        for (char c : s.toCharArray()) {\n            if (c == '(') d.addLast(0);\n            else {\n                int cur = d.pollLast();\n                d.addLast(d.pollLast() + Math.max(cur * 2 , 1));\n            }\n        }\n        return d.peekLast();\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction scoreOfParentheses(s: string): number {\n    const stk = new Array<number>()\n    stk.push(0)\n    for (const c of s) {\n        if (c == '(') stk.push(0)\n        else {\n            const cur = stk.pop()\n            stk.push(stk.pop() + Math.max(cur * 2, 1))\n        }\n    }\n    return stk.pop()\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def scoreOfParentheses(self, s: str) -> int:\n        stk = [0]\n        for c in s:\n            if c == '(':\n                stk.append(0)\n            else:\n                cur = stk.pop()\n                stk.append(stk.pop() + max(cur * 2, 1))\n        return stk[-1]\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.856` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/851-860/857. 雇佣 K 名工人的最低成本（困难）.md", "url_title": "857. 雇佣 K 名工人的最低成本", "url": "https://leetcode.cn/problems/minimum-cost-to-hire-k-workers/solution/by-ac_oier-u42f/", "difficulty": "困难", "tags": ["枚举", "优先队列(堆)"], "question": "有 `n` 名工人。 给定两个数组 `quality` 和 `wage` ,其中,`quality[i]` 表示第 `i` 名工人的工作质量,其最低期望工资为 `wage[i]` 。\n\n现在我们想雇佣 `k` 名工人组成一个工资组。在雇佣 一组 `k` 名工人时,我们必须按照下述规则向他们支付工资:\n\n* 对工资组中的每名工人,应当按其工作质量与同组其他工人的工作质量的比例来支付工资。\n* 工资组中的每名工人至少应当得到他们的最低期望工资。\n\n给定整数 `k`,返回 组成满足上述条件的付费群体所需的最小金额 。在实际答案的 $10^{-5}$ 以内的答案将被接受。。\n\n示例 1:\n```\n输入: quality = [10,20,5], wage = [70,50,30], k = 2\n\n输出: 105.00000\n\n解释: 我们向 0 号工人支付 70,向 2 号工人支付 35。\n```\n示例 2:\n```\n输入: quality = [3,1,10,10,1], wage = [4,8,2,2,7], k = 3\n\n输出: 30.66667\n\n解释: 我们向 0 号工人支付 4,向 2 号和 3 号分别支付 13.33333。\n```\n\n提示:\n* $n = quality.length = wage.length$\n* $1 <= k <= n <= 10^4$\n* $1 <= quality[i], wage[i] <= 10^4$", "solution": "### 枚举 + 优先队列(堆)\n\n为了方便,我们令 `quality` 为 `qs`,`wage` 为 `ws`。\n\n从 $n$ 个工人中选 $k$ 个,使这 $k$ 个工人实际工资与其 $qs[i]$ 成比例,且实际工资不低于 $ws[i]$。\n\n根据条件一,假设实际工资与能力值比值为 $t$,则所选工人的实际工资为 $qs[i] \\times t$,再结合条件二可知 $qs[i] \\times t >= ws[i]$,变形可得 $t >= \\frac{ws[i]}{qs[i]}$。\n\n那么在选定若干工人的情况下,为使得总支出最小,我们可以取 $t$ 为所有被选工人中的最大 $\\frac{ws[i]}{qs[i]}$ 即可。\n\n**因此最终的 $t$ 值必然是取自某个工人的实际比值 $\\frac{ws[i]}{qs[i]}$,这引导我们可以通过「枚举」哪个工人的实际比值为实际 $t$ 值来做。**\n\n假设我们已经预处理出所有工人的 $\\frac{ws[i]}{qs[i]}$ 比值信息,并「从小到大」进行枚举(该过程可看做是以比值信息作为维度来枚举每个工人):假设当前处理到的比值为最终使用到的 $t$,我们能够选的工人必然是在该工人的左边(根据上述分析可知,被选的工人满足 $\\frac{ws[i]}{qs[i]} <= t$ 条件)。\n\n因此,我们可以使用二维数组 `ds` 记录下每个工人的 $\\frac{ws[i]}{qs[i]}$ 比值信息:$ds[i][0] = \\frac{ws[i]}{qs[i]}$,$ds[i][1] = i$。并对其进行排升序,枚举每个工人的实际比值,同时动态维护枚举过程中的最小 $k$ 个 $qs[i]$(使用「大根堆」处理),并使用单变量 `tot` 记录当前堆中的 $qs[i]$ 总和,$tot \\times \\frac{ws[i]}{qs[i]}$ 即是以当前比值作为实际 $t$ 值时的总成本,在所有总成本中取最小值即是答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public double mincostToHireWorkers(int[] qs, int[] ws, int k) {\n        int n = qs.length;\n        double[][] ds = new double[n][2];\n        for (int i = 0; i < n; i++) {\n            ds[i][0] = ws[i] * 1.0 / qs[i]; ds[i][1] = i * 1.0;\n        }\n        Arrays.sort(ds, (a,b)->Double.compare(a[0], b[0]));\n        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);\n        double ans = 1e18;\n        for (int i = 0, tot = 0; i < n; i++) {\n            int cur = qs[(int)ds[i][1]];\n            tot += cur; q.add(cur);\n            if (q.size() > k) tot -= q.poll();\n            if (q.size() == k) ans = Math.min(ans, tot * ds[i][0]);\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction mincostToHireWorkers(qs: number[], ws: number[], k: number): number {\n    const n = qs.length\n    const ds: number[][] = new Array<Array<number>>()\n    for (let i = 0; i < n; i++) ds.push([ws[i] / qs[i], i])\n    ds.sort((a,b)=>a[0]-b[0])\n    const q = new MaxPriorityQueue()\n    let ans = 1e18\n    for (let i = 0, tot = 0; i < n; i++) {\n        const cur = qs[ds[i][1]]\n        tot += cur\n        q.enqueue(cur)\n        if (q.size() > k) tot -= q.dequeue().element\n        if (q.size() == k) ans = Math.min(ans, tot * ds[i][0])\n    }\n    return ans\n};\n```\n* 时间复杂度:构造系数并排序复杂度为 $O(n\\log{n})$;枚举并计算答案复杂度为 $O(n\\log{k})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.857` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/851-860/859. 亲密字符串（简单）.md", "url_title": "859. 亲密字符串", "url": "https://leetcode-cn.com/problems/buddy-strings/solution/gong-shui-san-xie-jian-dan-zi-fu-chuan-m-q056/", "difficulty": "简单", "tags": ["模拟"], "question": "给你两个字符串 `s` 和 `goal` ,只要我们可以通过交换 `s` 中的两个字母得到与 `goal` 相等的结果,就返回 `true` ;否则返回 `false` 。\n\n交换字母的定义是:取两个下标 `i` 和 `j` (下标从 $0$ 开始)且满足 `i != j` ,接着交换 `s[i]` 和 `s[j]` 处的字符。\n\n* 例如,在 `\"abcd\"` 中交换下标 `0` 和下标 `2` 的元素可以生成 `\"cbad\"` 。\n\n示例 1:\n```\n输入:s = \"ab\", goal = \"ba\"\n\n输出:true\n\n解释:你可以交换 s[0] = 'a' 和 s[1] = 'b' 生成 \"ba\",此时 s 和 goal 相等。\n```\n示例 2:\n```\n输入:s = \"ab\", goal = \"ab\"\n\n输出:false\n\n解释:你只能交换 s[0] = 'a' 和 s[1] = 'b' 生成 \"ba\",此时 s 和 goal 不相等。\n```\n示例 3:\n```\n输入:s = \"aa\", goal = \"aa\"\n\n输出:true\n\n解释:你可以交换 s[0] = 'a' 和 s[1] = 'a' 生成 \"aa\",此时 s 和 goal 相等。\n```\n示例 4:\n```\n输入:s = \"aaaaaaabc\", goal = \"aaaaaaacb\"\n\n输出:true\n```\n\n提示:\n* $1 <= s.length, goal.length <= 2 * 10^4$\n* `s` 和 `goal` 由小写英文字母组成", "solution": "### 模拟\n\n根据题意进行模拟即可,搞清楚什么情况下两者为「亲密字符」:\n\n1. 当 $s$ 与 $goal$ 长度 或 词频不同,必然不为亲密字符;\n2. 当「$s$ 与 $goal$ 不同的字符数量为 $2$(能够相互交换)」或「$s$ 与 $goal$ 不同的字符数量为 $0$,但同时 $s$ 中有出现数量超过 $2$ 的字符(能够相互交换)」时,两者必然为亲密字符。\n\n代码:\n```Java\nclass Solution {\n    public boolean buddyStrings(String s, String goal) {\n        int n = s.length(), m = goal.length();\n        if (n != m) return false;\n        int[] cnt1 = new int[26], cnt2 = new int[26];\n        int sum = 0;\n        for (int i = 0; i < n; i++) {\n            int a = s.charAt(i) - 'a', b = goal.charAt(i) - 'a';\n            cnt1[a]++; cnt2[b]++;\n            if (a != b) sum++;\n        }\n        boolean ok = false;\n        for (int i = 0; i < 26; i++) {\n            if (cnt1[i] != cnt2[i]) return false;\n            if (cnt1[i] > 1) ok = true;\n        }\n        return sum == 2 || (sum == 0 && ok);\n    }\n}\n```\n* 时间复杂度:令 $n$ 为两字符串之间的最大长度,$C$ 为字符集大小,$C$ 固定为 $26$,复杂度为 $O(n + C)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.859` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/861-870/862. 和至少为 K 的最短子数组（困难）.md", "url_title": "862. 和至少为 K 的最短子数组", "url": "https://leetcode.cn/problems/shortest-subarray-with-sum-at-least-k/solution/by-ac_oier-es0s/", "difficulty": "困难", "tags": ["前缀和", "离散化", "二分", "树状数组"], "question": "给你一个整数数组 `nums` 和一个整数 `k` ,找出 `nums` 中和至少为 `k` 的 最短非空子数组 ,并返回该子数组的长度。如果不存在这样的子数组,返回 `-1` 。\n\n子数组是数组中连续 的一部分。\n\n示例 1:\n```\n输入:nums = [1], k = 1\n\n输出:1\n```\n示例 2:\n```\n输入:nums = [1,2], k = 4\n\n输出:-1\n```\n示例 3:\n```\n输入:nums = [2,-1,2], k = 3\n\n输出:3\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $-10^5 <= nums[i] <= 10^5$\n* $1 <= k <= 10^9$", "solution": "### 前缀和 + 离散化 + 权值树状数组\n\n由于求解的对象是子数组,容易联想到求连续段之和,容易联想到「前缀和」,假设我们预处理出的前缀和数组为 $sum$(为了方便,我们令前缀和数组坐标从 $1$ 开始)。\n\n即每个 $nums[i]$ 而言,本质上是找满足「$sum[i] - sum[j] \\geqslant k$」条件的最大下标 $j$,其中 $j$ 的取值范围为 $[0, i - 1]$,从而知道以 $i$ 作为右端点时,满足条件的最短子数组长度为 $i - j$。\n\n先考虑存在负数域的问题,由于我们需要使用 $sum[X]$,以及对应的 $sum[X] + k$,同时 $k$ 的取值为 $1e9$(过大),我们可以通过「离散化」手段将其映射到 $2$ 倍的数组长度,即大小为 $2 \\times 10^5$ 的正数域。\n\n随后来考虑如何求解「满足条件的最大下标」问题,可以通过「权值树状数组」来做:对于每个 $sum[i]$ 而言,我们利用「权值树状数组」来维护满足大于等于 $sum[i] + k$ 的最大下标。起始我们先初始化树状数组为 $-1$,遍历过程中,查询是否存在满足条件的下标(若不为 `-1` 则更新 `ans`),并更新权值树状数组对应的最大下标即可。\n\nJava 代码:\n```Java\nclass Solution {\n    static int N = 200010;\n    static int[] tr = new int[N], sum = new int[N];\n    int n, m, ans;\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void update(int val, int loc) {\n        for (int i = val; i < m; i += lowbit(i)) tr[i] = Math.max(tr[i], loc);\n    }\n    int query(int x) {\n        int ans = -1;\n        for (int i = x; i > 0; i -= lowbit(i)) ans = Math.max(ans, tr[i]);\n        return ans;\n    }\n    int getIdx(List<Long> list, long x) {\n        int l = 0, r = list.size() - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (list.get(mid) >= x) r = mid;\n            else l = mid + 1;\n        }\n        return r + 1;\n    }\n    public int shortestSubarray(int[] nums, int k) {\n        n = nums.length; m = 2 * n + 10; ans = n + 10;\n        Arrays.fill(tr, -1);\n        long[] temp = new long[m];\n        List<Long> list = new ArrayList<>();\n        list.add(0L);\n        for (int i = 1; i <= 2 * n + 1; i++) {\n            if (i <= n) temp[i] = temp[i - 1] + nums[i - 1];\n            else temp[i] = temp[i - (n + 1)] + k;\n            list.add(temp[i]);\n        }\n        Collections.sort(list);\n        for (int i = 0; i <= 2 * n + 1; i++) sum[i] = getIdx(list, temp[i]);\n        update(sum[n + 1], 0);\n        for (int i = 1; i <= n; i++) {\n            int j = query(sum[i]);\n            if (j != -1) ans = Math.min(ans, i - j);\n            update(sum[n + 1 + i], i);\n        }\n        return ans == n + 10 ? -1 : ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    static const int N = 200010;\n    vector<int> tr, sum;\n    int n, m, ans;\n    int lowbit(int x) {\n        return x & -x;\n    }\n    void update(int val, int loc) {\n        for (int i = val; i < m; i += lowbit(i)) tr[i] = max(tr[i], loc);\n    }\n    int query(int x) {\n        int ans = -1;\n        for (int i = x; i > 0; i -= lowbit(i)) ans = max(ans, tr[i]);\n        return ans;\n    }\n    int shortestSubarray(vector<int>& nums, int k) {\n        n = nums.size(); m = 2 * n + 10; ans = n + 10;\n        tr.resize(m, -1); sum.resize(m + 10, 0);\n        vector<long long> temp(m);\n        vector<long long> list;\n        for (int i = 1; i <= 2 * n + 1; i++) {\n            if (i <= n) temp[i] = temp[i - 1] + nums[i - 1];\n            else temp[i] = temp[i - (n + 1)] + k;\n            list.push_back(temp[i]);\n        }\n        sort(list.begin(), list.end());\n        for (int i = 0; i <= 2 * n + 1; i++) {\n            sum[i] = lower_bound(list.begin(), list.end(), temp[i]) - list.begin() + 1;\n        }\n        update(sum[n + 1], 0);\n        for (int i = 1; i <= n; i++) {\n            int j = query(sum[i]);\n            if (j != -1) ans = min(ans, i - j);\n            update(sum[n + 1 + i], i);\n        }\n        return ans == n + 10 ? -1 : ans;\n    }\n};\n```\n* 时间复杂度:预处理前缀和的的复杂度为 $O(n)$,排序并进行离散化的复杂度为 $O(n\\log{n})$;构造答案的复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.862` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/861-870/863. 二叉树中所有距离为 K 的结点（中等）.md", "url_title": "863. 二叉树中所有距离为 K 的结点", "url": "https://leetcode-cn.com/problems/all-nodes-distance-k-in-binary-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-jian-x6hak/", "difficulty": "中等", "tags": ["图论 BFS", "图论 DFS", "二叉树"], "question": "给定一个二叉树(具有根结点 root), 一个目标结点 target ,和一个整数值 K 。\n\n返回到目标结点 target 距离为 K 的所有结点的值的列表。 答案可以以任何顺序返回。\n\n示例 1:\n```\n输入:root = [3,5,1,6,2,0,8,null,null,7,4], target = 5, K = 2\n\n输出:[7,4,1]\n\n解释:\n所求结点为与目标结点(值为 5)距离为 2 的结点,\n值分别为 7,4,以及 1\n```\n\n注意,输入的 \"root\" 和 \"target\" 实际上是树上的结点。\n上面的输入仅仅是对这些对象进行了序列化描述。\n\n提示:\n* 给定的树是非空的。\n* 树上的每个结点都具有唯一的值 0 <= node.val <= 500 。\n* 目标结点 target 是树上的结点。\n* 0 <= K <= 1000.", "solution": "### 基本分析\n\n显然,如果题目是以图的形式给出的话,我们可以很容易通过「`BFS` / 迭代加深」找到距离为 $k$ 的节点集。\n\n而树是一类特殊的图,我们可以通过将二叉树转换为图的形式,再进行「`BFS` / 迭代加深」。\n\n由于二叉树每个点最多有 $2$ 个子节点,点和边的数量接近,属于稀疏图,因此我们可以使用「邻接表」的形式进行存储。\n\n建图方式为:对于二叉树中相互连通的节点(`root` 与 `root.left`、`root` 和 `root.right`),建立一条无向边。\n\n建图需要遍历整棵树,使用 `DFS` 或者 `BFS` 均可。\n\n由于所有边的权重均为 $1$,我们可以使用 「`BFS` / 迭代加深」 找到从目标节点 `target` 出发,与目标节点距离为 $k$ 的节点,然后将其添加到答案中。\n\n>一些细节:利用每个节点具有唯一的值,我们可以直接使用节点值进行建图和搜索。\n\n---\n\n### 建图 + `BFS`\n\n由「基本分析」,可写出「建图 + `BFS`」的实现。\n\n代码:\n```Java\nclass Solution {\n    int N = 1010, M = N * 2;\n    int[] he = new int[N], e = new int[M], ne = new int[M];\n    int idx;\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    boolean[] vis = new boolean[N];\n    public List<Integer> distanceK(TreeNode root, TreeNode t, int k) {\n        List<Integer> ans = new ArrayList<>();\n        Arrays.fill(he, -1);\n        dfs(root);\n        Deque<Integer> d = new ArrayDeque<>();\n        d.addLast(t.val);\n        vis[t.val] = true;\n        while (!d.isEmpty() && k >= 0) {\n            int size = d.size();\n            while (size-- > 0) {\n                int poll = d.pollFirst();\n                if (k == 0) {\n                    ans.add(poll);\n                    continue;\n                }\n                for (int i = he[poll]; i != -1 ; i = ne[i]) {\n                    int j = e[i];\n                    if (!vis[j]) {\n                        d.addLast(j);\n                        vis[j] = true;\n                    }\n                }\n            }\n            k--;\n        }\n        return ans;\n    }\n    void dfs(TreeNode root) {\n        if (root == null) return;\n        if (root.left != null) {\n            add(root.val, root.left.val);\n            add(root.left.val, root.val);\n            dfs(root.left);\n        }\n        if (root.right != null) {\n            add(root.val, root.right.val);\n            add(root.right.val, root.val);\n            dfs(root.right);\n        }\n    }\n}\n```\n* 时间复杂度:通过 `DFS` 进行建图的复杂度为 $O(n)$;通过 `BFS` 找到距离 $target$ 为 $k$ 的节点,复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 建图 + 迭代加深\n\n由「基本分析」,可写出「建图 + 迭代加深」的实现。\n\n迭代加深的形式,我们只需要结合题意,搜索深度为 $k$ 的这一层即可。\n\n代码:\n```Java\nclass Solution {\n    int N = 1010, M = N * 2;\n    int[] he = new int[N], e = new int[M], ne = new int[M];\n    int idx;\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    boolean[] vis = new boolean[N];\n    public List<Integer> distanceK(TreeNode root, TreeNode t, int k) {\n        List<Integer> ans = new ArrayList<>();\n        Arrays.fill(he, -1);\n        dfs(root);\n        vis[t.val] = true;\n        find(t.val, k, 0, ans);\n        return ans;\n    }\n    void find(int root, int max, int cur, List<Integer> ans) {\n        if (cur == max) {\n            ans.add(root);\n            return ;\n        }\n        for (int i = he[root]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (!vis[j]) {\n                vis[j] = true;\n                find(j, max, cur + 1, ans);\n            }\n        }\n    }\n    void dfs(TreeNode root) {\n        if (root == null) return;\n        if (root.left != null) {\n            add(root.val, root.left.val);\n            add(root.left.val, root.val);\n            dfs(root.left);\n        }\n        if (root.right != null) {\n            add(root.val, root.right.val);\n            add(root.right.val, root.val);\n            dfs(root.right);\n        }\n    }\n}\n```\n* 时间复杂度:通过 `DFS` 进行建图的复杂度为 $O(n)$;通过迭代加深找到距离 $target$ 为 $k$ 的节点,复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.863` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/861-870/864. 获取所有钥匙的最短路径（困难）.md", "url_title": "864. 获取所有钥匙的最短路径", "url": "https://leetcode.cn/problems/shortest-path-to-get-all-keys/solution/by-ac_oier-5gxc/", "difficulty": "困难", "tags": ["BFS", "状态压缩"], "question": "给定一个二维网格 `g`,其中:\n\n* `'.'` 代表一个空房间\n* `'#'` 代表一堵墙\n* `'@'` 是起点\n* 小写字母代表钥匙\n* 大写字母代表锁\n\n我们从起点开始出发,一次移动是指向四个基本方向之一行走一个单位空间。\n\n我们不能在网格外面行走,也无法穿过一堵墙。\n\n如果途经一个钥匙,我们就把它捡起来,除非我们手里有对应的钥匙,否则无法通过锁。\n\n假设 `k` 为 钥匙/锁 的个数,且满足 $1 <= k <= 6$,字母表中的前 `k` 个字母在网格中都有自己对应的一个小写和一个大写字母。\n\n换言之,每个锁有唯一对应的钥匙,每个钥匙也有唯一对应的锁。另外,代表钥匙和锁的字母互为大小写并按字母顺序排列。\n\n返回获取所有钥匙所需要的移动的最少次数。\n\n如果无法获取所有钥匙,返回 `-1` 。\n\n示例 1:\n\n```\n输入:g = [\"@.a.#\",\"###.#\",\"b.A.B\"]\n\n输出:8\n\n解释:目标是获得所有钥匙,而不是打开所有锁。\n```\n示例 2:\n\n```\n输入:g = [\"@..aA\",\"..B#.\",\"....b\"]\n\n输出:6\n```\n示例 3:\n\n```\n输入: g = [\"@Aa\"]\n\n输出: -1\n```\n\n提示:\n* $m = g.length$\n* $n = g[i].length$\n* $1 <= m, n <= 30$\n* `g[i][j]` 只含有 `'.'`,`'#'`, `'@'`, `'a'-'f'` 以及 `'A'-'F'`\n* 钥匙的数目范围是 $[1, 6]$\n* 每个钥匙都对应一个不同的字母\n* 每个钥匙正好打开一个对应的锁", "solution": "### BFS + 状态压缩\n\n**一道常规的 `BFS` 运用题,只不过需要在 `BFS` 过程中记录收集到的钥匙状态。**\n\n利用「钥匙数量不超过 $6$,并按字母顺序排列」,我们可以使用一个 `int` 类型二进制数 `state` 来代指当前收集到钥匙情况:\n\n* 若 `state` 的二进制中的第 $k$ 位为 `1`,代表当前种类编号为 $k$ 的钥匙 **已被收集**,后续移动若遇到对应的锁则 **能通过**\n* 若 `state` 的二进制中的第 $k$ 位为 `0`,代表当前种类编号为 $k$ 的钥匙 **未被收集**,后续移动若遇到对应的锁则 **无法通过**\n\n其中「钥匙种类编号」则按照小写字母先后顺序,从 $0$ 开始进行划分对应:即字符为 `a` 的钥匙编号为 `0`,字符为 `b` 的钥匙编号为 `1`,字符为 `c` 的钥匙编号为 `2` ...\n\n当使用了这样的「状态压缩」技巧后,我们可以很方便通过「位运算」进行 **钥匙检测** 和 **更新钥匙收集状态**:\n\n* 钥匙检测:`(state >> k) & 1`,若返回 `1` 说明第 $k$ 位为 `1`,当前持有种类编号为 `k` 的钥匙\n* 更新钥匙收集状态:`state |= 1 << k`,将 `state` 的第 $k$ 位设置为 `1`,代表当前新收集到种类编号为 `k` 的钥匙\n\n搞明白如何记录当前收集到的钥匙状态后,剩下的则是常规 `BFS` 过程:\n\n1. 起始遍历一次棋盘,找到起点位置,并将其进行入队,队列维护的是 $(x, y, state)$ 三元组状态(其中 $(x, y)$ 代表当前所在的棋盘位置,$state$ 代表当前的钥匙收集情况)\n    同时统计整个棋盘所包含的钥匙数量 `cnt`,并使用 数组/哈希表 记录到达每个状态所需要消耗的最小步数 `step`\n\n2. 进行四联通方向的 `BFS`,转移过程中需要注意「遇到锁时,必须有对应钥匙才能通过」&「遇到钥匙时,需要更新对应的 `state` 再进行入队」\n\n3. 当 `BFS` 过程中遇到 `state = (1 << cnt) - 1` 时,代表所有钥匙均被收集完成,可结束搜索\n\nJava 代码:\n```Java\nclass Solution {\n    static int N = 35, K = 10, INF = 0x3f3f3f3f;\n    static int[][][] dist = new int[N][N][1 << K];\n    static int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n    public int shortestPathAllKeys(String[] g) {\n        int n = g.length, m = g[0].length(), cnt = 0;\n        Deque<int[]> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                Arrays.fill(dist[i][j], INF);\n                char c = g[i].charAt(j);\n                if (c == '@') {\n                    d.addLast(new int[]{i, j, 0});\n                    dist[i][j][0] = 0;\n                } else if (c >= 'a' && c <= 'z') cnt++;\n            }\n        }\n        while (!d.isEmpty()) {\n            int[] info = d.pollFirst();\n            int x = info[0], y = info[1], cur = info[2], step = dist[x][y][cur];\n            for (int[] di : dirs) {\n                int nx = x + di[0], ny = y + di[1];\n                if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;\n                char c = g[nx].charAt(ny);\n                if (c == '#') continue;\n                if ((c >= 'A' && c <= 'Z') && (cur >> (c - 'A') & 1) == 0) continue;\n                int ncur = cur;\n                if (c >= 'a' && c <= 'z') ncur |= 1 << (c - 'a');\n                if (ncur == (1 << cnt) - 1) return step + 1;\n                if (step + 1 >= dist[nx][ny][ncur]) continue;\n                dist[nx][ny][ncur] = step + 1;\n                d.addLast(new int[]{nx, ny, ncur});\n            }\n        }\n        return -1;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\n    int N = 35, K = 10, INF = 0x3f3f3f3f;\n    vector<vector<vector<int>>> dist = vector<vector<vector<int>>>(N, vector<vector<int>>(N, vector<int>(1<<K, INF)));\n    vector<vector<int>> dirs = {{1,0}, {-1,0}, {0,1}, {0,-1}};\npublic:\n    int shortestPathAllKeys(vector<string>& g) {\n        int n = g.size(), m = g[0].size(), cnt = 0;\n        queue<vector<int>> d;\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                fill(dist[i][j].begin(), dist[i][j].end(), INF);\n                char c = g[i][j];\n                if (c == '@') {\n                    d.push({i, j, 0});\n                    dist[i][j][0] = 0;\n                } else if (c >= 'a' && c <= 'z') cnt++;\n            }\n        }\n        while (!d.empty()) {\n            vector<int> info = d.front();\n            d.pop();\n            int x = info[0], y = info[1], cur = info[2], step = dist[x][y][cur];\n            for (vector<int> di : dirs) {\n                int nx = x + di[0], ny = y + di[1];\n                if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;\n                char c = g[nx][ny];\n                if (c == '#') continue;\n                if ((c >= 'A' && c <= 'Z') && (cur >> (c - 'A') & 1) == 0) continue;\n                int ncur = cur;\n                if (c >= 'a' && c <= 'z') ncur |= 1 << (c - 'a');\n                if (ncur == (1 << cnt) - 1) return step + 1;\n                if (step + 1 >= dist[nx][ny][ncur]) continue;\n                dist[nx][ny][ncur] = step + 1;\n                d.push({nx, ny, ncur});\n            }\n        }\n        return -1;\n    }\n};\n```\nPython3 代码:\n```Python\nclass Solution:\n    def shortestPathAllKeys(self, g: List[str]) -> int:\n        dirs = [[0,1], [0,-1], [1,0], [-1,0]]\n        n, m, cnt = len(g), len(g[0]), 0\n        dist = defaultdict(lambda : 0x3f3f3f3f)\n        for i in range(n):\n            for j in range(m):\n                c = g[i][j]\n                if c == '@':\n                    d = deque([(i, j, 0)])\n                    dist[(i, j, 0)] = 0\n                elif 'a' <= c <= 'z':\n                    cnt += 1\n        while d:\n            x, y, cur = d.popleft()\n            step = dist[(x, y, cur)]\n            for di in dirs:\n                nx, ny = x + di[0], y + di[1]\n                if nx < 0 or nx >= n or ny < 0 or ny >= m:\n                    continue\n                c = g[nx][ny]\n                if c == '#':\n                    continue\n                if 'A' <= c <= 'Z' and (cur >> (ord(c) - ord('A')) & 1) == 0:\n                    continue\n                ncur = cur\n                if 'a' <= c <= 'z':\n                    ncur |= (1 << (ord(c) - ord('a')))\n                if ncur == (1 << cnt) - 1:\n                    return step + 1\n                if step + 1 >= dist[(nx, ny, ncur)]:\n                    continue\n                dist[(nx, ny, ncur)] = step + 1\n                d.append((nx, ny, ncur))\n        return -1\n```\nTypeScript 代码:\n```TypeScript\nfunction shortestPathAllKeys(g: string[]): number {\n    const dirs = [[1,0],[-1,0],[0,1],[0,-1]]\n    let n = g.length, m = g[0].length, cnt = 0\n    const dist = new Array<Array<Array<number>>>()\n    for (let i = 0; i < n; i++) {\n        dist[i] = new Array<Array<number>>(m)\n        for (let j = 0; j < m; j++) {\n            dist[i][j] = new Array<number>(1 << 10).fill(0x3f3f3f3f)\n        }\n    }\n    const d = []\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < m; j++) {\n            if (g[i][j] == '@') {\n                d.push([i, j, 0]); dist[i][j][0] = 0\n            } else if (g[i][j] >= 'a' && g[i][j] <= 'z') cnt++\n        }\n    }\n    while (d.length > 0) {\n        const info = d.shift()\n        const x = info[0], y = info[1], cur = info[2], step = dist[x][y][cur]\n        for (const di of dirs) {\n            const nx = x + di[0], ny = y + di[1]\n            if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue\n            const c = g[nx][ny]\n            if (c == '#') continue\n            if ('A' <= c && c <= 'Z' && ((cur >> (c.charCodeAt(0) - 'A'.charCodeAt(0)) & 1) == 0)) continue\n            let ncur = cur\n            if ('a' <= c && c <= 'z') ncur |= 1 << (c.charCodeAt(0) - 'a'.charCodeAt(0))\n            if (ncur == (1 << cnt) - 1) return step + 1\n            if (step + 1 >= dist[nx][ny][ncur]) continue\n            d.push([nx, ny, ncur])\n            dist[nx][ny][ncur] = step + 1\n        }\n    }\n    return -1\n}\n```\n* 时间复杂度:$O(n \\times m \\times 2^k)$\n* 空间复杂度:$O(n \\times m \\times 2^k)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.864` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/861-870/867. 转置矩阵（简单）.md", "url_title": "867. 转置矩阵", "url": "https://leetcode-cn.com/problems/transpose-matrix/solution/yi-you-wei-jin-huo-xu-ni-neng-kan-kan-zh-m53m/", "difficulty": "简单", "tags": ["模拟"], "question": "给你一个二维整数数组 matrix, 返回 matrix 的 转置矩阵 。\n\n矩阵的 转置 是指将矩阵的主对角线翻转,交换矩阵的行索引与列索引。\n\n示例 1:\n```\n输入:matrix = [[1,2,3],[4,5,6],[7,8,9]]\n输出:[[1,4,7],[2,5,8],[3,6,9]]\n```\n示例 2:\n```\n输入:matrix = [[1,2,3],[4,5,6]]\n输出:[[1,4],[2,5],[3,6]]\n```\n\n提示:\n* m == matrix.length\n* n == matrix[i].length\n* 1 <= m, n <= 1000\n* 1 <= m * n <= $10^5$\n* -$10^9$ <= matrix[i][j] <= $10^9$", "solution": "### 模拟\n\n对角线翻转,只需要从头模拟一遍即可。\n\n```java\nclass Solution {\n    public int[][] transpose(int[][] matrix) {\n        int n = matrix.length, m = matrix[0].length;\n        int[][] ans = new int[m][n];\n        for (int i = 0; i < m; i++) {\n            for (int j = 0; j < n; j++) {\n                ans[i][j] = matrix[j][i];\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n * m)$\n* 空间复杂度:使用同等空间保存答案。复杂度为 $O(n * m)$\n\n***\n\n### 矩阵类题目\n\n题目过于简单,让人怀疑 LeetCode 团队是不是还在放假。\n\n我在 LeetCode 上挑了几道难度适中,与矩阵变换相关的题目,如果大家感觉今天的「每日一题」不够尽兴的话,可以试着做一下:\n\n[566. 重塑矩阵(简单)](https://leetcode-cn.com/problems/reshape-the-matrix/)\n\n[54. 螺旋矩阵(中等)](https://leetcode-cn.com/problems/spiral-matrix/)\n\n[59. 螺旋矩阵 II(中等)](https://leetcode-cn.com/problems/spiral-matrix-ii/)\n\n***\n\n#### 关于复杂度的说明\n\n无论是时间还是空间都是用作描述算法运行所需要的资源消耗\n\n我是将「算法本身占用的内存」和「输入数据」以外的内存作为“额外”内存,所以是 $O(n * m)$\n\n官方的我看了一下,如果说明了忽略输出数据的内存占用的话,说成 $O(1)$ 也是可以的\n\n就像我们使用递归求解问题的时候,栈帧本身也会带来内存消耗。因此进行复杂度分析的时候,出于严谨应该是要说明忽略递归带来的空间消耗", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.867` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/861-870/868. 二进制间距（简单）.md", "url_title": "868. 二进制间距", "url": "https://leetcode-cn.com/problems/binary-gap/solution/by-ac_oier-2sui/", "difficulty": "简单", "tags": ["模拟"], "question": "给定一个正整数 $n$,找到并返回 $n$ 的二进制表示中两个 相邻 $1$ 之间的 最长距离 。如果不存在两个相邻的 $1$,返回 $0$ 。\n\n如果只有 $0$ 将两个 $1$ 分隔开(可能不存在 $0$ ),则认为这两个 $1$ 彼此 相邻 。两个 $1$ 之间的距离是它们的二进制表示中位置的绝对差。例如,`\"1001\"` 中的两个 $1$ 的距离为 $3$ 。\n\n示例 1:\n```\n输入:n = 22\n\n输出:2\n\n解释:22 的二进制是 \"10110\" 。\n在 22 的二进制表示中,有三个 1,组成两对相邻的 1 。\n第一对相邻的 1 中,两个 1 之间的距离为 2 。\n第二对相邻的 1 中,两个 1 之间的距离为 1 。\n答案取两个距离之中最大的,也就是 2 。\n```\n示例 2:\n```\n输入:n = 8\n\n输出:0\n\n解释:8 的二进制是 \"1000\" 。\n在 8 的二进制表示中没有相邻的两个 1,所以返回 0 。\n```\n示例 3:\n```\n输入:n = 5\n\n输出:2\n\n解释:5 的二进制是 \"101\" 。\n```\n\n提示:\n* $1 <= n <= 10^9$", "solution": "### 模拟\n\n根据题意进行模拟即可,遍历 $n$ 的二进制中的每一位 $i$,同时记录上一位 $1$ 的位置 $j$,即可得到所有相邻 $1$ 的间距,所有间距取 $\\max$ 即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int binaryGap(int n) {\n        int ans = 0;\n        for (int i = 31, j = -1; i >= 0; i--) {\n            if (((n >> i) & 1) == 1) {\n                if (j != -1) ans = Math.max(ans, j - i);\n                j = i;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.868` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/861-870/869. 重新排序得到 2 的幂（中等）.md", "url_title": "869. 重新排序得到 2 的幂", "url": "https://leetcode-cn.com/problems/reordered-power-of-2/solution/gong-shui-san-xie-yi-ti-shuang-jie-dfs-c-3s1e/", "difficulty": "中等", "tags": ["DFS", "哈希表"], "question": "给定正整数 `N` ,我们按任何顺序(包括原始顺序)将数字重新排序,注意其前导数字不能为零。\n\n如果我们可以通过上述方式得到 $2$ 的幂,返回 `true`;否则,返回 `false`。\n\n示例 1:\n```\n输入:1\n\n输出:true\n```\n示例 2:\n```\n输入:10\n\n输出:false\n```\n示例 3:\n```\n输入:16\n\n输出:true\n```\n示例 4:\n```\n输入:24\n\n输出:false\n```\n示例 5:\n```\n输入:46\n\n输出:true\n```\n\n提示:\n$1 <= N <= 10^9$", "solution": "### 打表 + DFS\n\n一个朴素的做法是对 $n$ 进行重排,然后检查重排后的数值是否属于 $2$ 的幂。\n\n由于 $2$ 的幂数固定,我们可以先通过「打表」将范围落在 $[1, 1e9]$ 以内的 $2$ 的幂预处理出来,这样我们可以在 $O(1)$ 的复杂度内判断某个数是否为 $2$ 的幂。\n\n重排的过程则是 `DFS` 实现。\n\n代码:\n```Java\nclass Solution {\n    static Set<Integer> set = new HashSet<>();\n    static {\n        for (int i = 1; i < (int)1e9+10; i *= 2) set.add(i);\n    }\n    int m;\n    int[] cnts = new int[10];\n    public boolean reorderedPowerOf2(int n) {\n        while (n != 0) {\n            cnts[n % 10]++;\n            n /= 10;\n            m++;\n        }\n        return dfs(0, 0);\n    }\n    boolean dfs(int u, int cur) {\n        if (u == m) return set.contains(cur);\n        for (int i = 0; i < 10; i++) {\n            if (cnts[i] != 0) {\n                cnts[i]--;\n                if ((i != 0 || cur != 0) && dfs(u + 1, cur * 10 + i)) return true;\n                cnts[i]++;\n            }\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:打表预处理所有 $2$ 的幂放到本地运行为 $O(1)$,放到 $OJ$ 运行则是 $O(C)$,$C$ 为常数,约为 $30$。处理处 $cnts$ 数组的复杂度为 $O(\\log{n})$;重排的复杂度为 $O((\\log{n})!)$,判断是否为 $2$ 的幂的复杂度为 $O(1)$。整体复杂度为 $O((\\log{n})!)$。\n* 空间复杂度:$O(C)$,其中 $C$ 为常数,约为 $40$。\n\n---\n\n### 打表 + 词频统计\n\n解法一,我们发现复杂度上界取决于对 $n$ 的重排,同时数据范围内的 $2$ 的幂数量很少。\n\n因此有效降低复杂度(避免重排)的做法是,直接枚举所有的 $2$ 的幂 $x$,检查 $x$ 的词频是否与 $n$ 相同。\n\n代码:\n```Java\nclass Solution {\n    static Set<Integer> set = new HashSet<>();\n    static {\n        for (int i = 1; i < (int)1e9+10; i *= 2) set.add(i);\n    }\n    public boolean reorderedPowerOf2(int n) {\n        int[] cnts = new int[10];\n        while (n != 0) {\n            cnts[n % 10]++;\n            n /= 10;\n        }\n        int[] cur = new int[10];\n        out:for (int x : set) {\n            Arrays.fill(cur, 0);\n            while (x != 0) {\n                cur[x % 10]++;\n                x /= 10;\n            }\n            for (int i = 0; i < 10; i++) {\n                if (cur[i] != cnts[i]) continue out;\n            }\n            return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:打表预处理所有 $2$ 的幂放到本地运行为 $O(1)$,放到 $OJ$ 运行则是 $O(C)$,$C$ 为常数,约为 $30$。检查所有 $2$ 的幂的词频是否与 $n$ 词频相同复杂度为 $O(C * \\log{n})$。整体复杂度为 $O(C * \\log{n})$。\n* 空间复杂度:$O(C)$,其中 $C$ 为常数,约为 $40$。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.869` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/861-870/870. 优势洗牌（中等）.md", "url_title": "870. 优势洗牌", "url": "https://leetcode.cn/problems/advantage-shuffle/solution/by-ac_oier-i01s/", "difficulty": "中等", "tags": ["红黑树", "哈希表", "排序", "双指针", "贪心"], "question": "给定两个大小相等的数组 `nums1` 和 `nums2`,`nums1` 相对于 `nums` 的优势可以用满足 `nums1[i] > nums2[i]` 的索引 `i` 的数目来描述。\n\n返回 `nums1` 的任意排列,使其相对于 `nums2` 的优势最大化。\n\n示例 1:\n```\n输入:nums1 = [2,7,11,15], nums2 = [1,10,4,11]\n\n输出:[2,11,7,15]\n```\n示例 2:\n```\n输入:nums1 = [12,24,8,32], nums2 = [13,25,32,11]\n\n输出:[24,32,8,12]\n```\n\n提示:\n* $1 <= nums1.length <= 10^5$\n* $nums2.length = nums1.length$\n* $0 <= nums1[i], nums2[i] <= 10^9$", "solution": "### 数据结构\n\n显然,对于任意一个 $t = nums2[i]$ 而言,我们应当在候选集合中选择**比其大的最小数**,若不存在这样的数字,则选择候选集合中的**最小值**。\n\n同时,由于 $nums1$ 相同数会存在多个,我们还要对某个具体数字的可用次数进行记录。\n\n也就是我们总共涉及两类操作:\n\n1. 实时维护一个候选集合,该集合支持高效查询比某个数大的数值操作;\n2. 对候选集合中每个数值的可使用次数进行记录,当使用到了候选集合中的某个数后,要对其进行计数减一操作,若计数为 $0$,则将该数值从候选集合中移除。\n\n计数操作容易想到哈希表,而实时维护候选集合并高效查询可以使用基于红黑树的 `TreeSet` 数据结构。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] advantageCount(int[] nums1, int[] nums2) {\n        int n = nums1.length;\n        TreeSet<Integer> tset = new TreeSet<>();\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int x : nums1) {\n            map.put(x, map.getOrDefault(x, 0) + 1);\n            if (map.get(x) == 1) tset.add(x);\n        }\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) {\n            Integer cur = tset.ceiling(nums2[i] + 1);\n            if (cur == null) cur = tset.ceiling(-1);\n            ans[i] = cur;\n            map.put(cur, map.get(cur) - 1);\n            if (map.get(cur) == 0) tset.remove(cur);\n        }\n        return ans;\n    }\n}\n```\nPython 代码:\n```Python\nfrom sortedcontainers import SortedList\n\nclass Solution:\n    def advantageCount(self, nums1: List[int], nums2: List[int]) -> List[int]:\n        n = len(nums1)\n        cnts, tset = defaultdict(int), SortedList()\n        for i in range(n):\n            cnts[nums1[i]] += 1\n            if cnts[nums1[i]] == 1:\n                tset.add(nums1[i])\n        ans = [0] * n\n        for i in range(n):\n            t = nums2[i]\n            if (idx := tset.bisect_left(t + 1)) == len(tset):\n                idx = tset.bisect_left(-1)\n            ans[i] = tset[idx]\n            cnts[ans[i]] -= 1\n            if cnts[ans[i]] == 0:\n                tset.remove(ans[i])\n        return ans\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 排序 + 双指针\n\n在解法一中,我们是从每个 $nums2[i]$ 出发考虑,使用哪个 $nums1[i]$ 去匹配最为合适。\n\n实际上,我们也能从 $nums1[i]$ 出发,考虑将其与哪个 $nums2[i]$ 进行匹配。\n\n为了让每个决策回合具有独立性,我们需要对两数组进行排序,同时为了在构造答案时,能够对应回 `nums2` 的原下标,排序前我们需要使用「哈希表」记录每个 $nums2[i]$ 的下标为何值。\n\n使用变量 `l1` 代表当前决策将 $nums1[l1]$ 分配到哪个 `nums2` 的位置,使用 `l2` 和 `r2` 代表当前 `nums2` 中还有 $[l2, r2]$ 位置还待填充。\n\n可以证明我们在从前往后给每个 $nums1[l1]$ 分配具体位置时,分配的位置只会在 `l2` 和 `r2` 两者之间产生。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] advantageCount(int[] nums1, int[] nums2) {\n        int n = nums1.length;\n        Map<Integer, List<Integer>> map = new HashMap<>();\n        for (int i = 0; i < n; i++) {\n            List<Integer> list = map.getOrDefault(nums2[i], new ArrayList<>());\n            list.add(i);\n            map.put(nums2[i], list);\n        }\n        Arrays.sort(nums1); Arrays.sort(nums2);\n        int[] ans = new int[n];\n        for (int l1 = 0, l2 = 0, r2 = n - 1; l1 < n; l1++) {\n            int t = nums1[l1] > nums2[l2] ? l2 : r2;\n            List<Integer> list = map.get(nums2[t]);\n            int idx = list.remove(list.size() - 1);\n            ans[idx] = nums1[l1];\n            if (t == l2) l2++;\n            else r2--;\n        }\n        return ans;\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def advantageCount(self, nums1: List[int], nums2: List[int]) -> List[int]:\n        n = len(nums1)\n        mapping = defaultdict(list)\n        for i in range(n):\n            mapping[nums2[i]].append(i)\n        nums1.sort()\n        nums2.sort()\n        ans = [0] * n\n        l2, r2 = 0, n - 1\n        for l1 in range(n):\n            t = l2 if nums1[l1] > nums2[l2] else r2\n            ans[mapping[nums2[t]].pop()] = nums1[l1]\n            if t == l2:\n                l2 += 1\n            else:\n                r2 -= 1\n        return ans\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 加餐\n\n**加餐一道同类型题目 : [难度 2.5/5,敲醒沉睡心灵的数据结构运用题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247493710&idx=1&sn=2d6d4ee9f4b1ff1ea766ddf7ea57bf55) 🎉🎉**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.870` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/871-880/871. 最低加油次数（困难）.md", "url_title": "871. 最低加油次数", "url": "https://leetcode.cn/problems/minimum-number-of-refueling-stops/solution/by-ac_oier-q2mk/", "difficulty": "困难", "tags": ["贪心", "优先队列(堆)", "模拟"], "question": "汽车从起点出发驶向目的地,该目的地位于出发位置东面 `target` 英里处。\n\n沿途有加油站,每个 `station[i]` 代表一个加油站,它位于出发位置东面 `station[i][0]` 英里处,并且有 `station[i][1]` 升汽油。\n\n假设汽车油箱的容量是无限的,其中最初有 `startFuel` 升燃料。它每行驶 $1$ 英里就会用掉 $1$ 升汽油。\n\n当汽车到达加油站时,它可能停下来加油,将所有汽油从加油站转移到汽车中。\n\n为了到达目的地,汽车所必要的最低加油次数是多少?如果无法到达目的地,则返回 $-1$ 。\n\n注意:如果汽车到达加油站时剩余燃料为 $0$,它仍然可以在那里加油。如果汽车到达目的地时剩余燃料为 $0$,仍然认为它已经到达目的地。\n\n示例 1:\n```\n输入:target = 1, startFuel = 1, stations = []\n\n输出:0\n\n解释:我们可以在不加油的情况下到达目的地。\n```\n示例 2:\n```\n输入:target = 100, startFuel = 1, stations = [[10,100]]\n\n输出:-1\n\n解释:我们无法抵达目的地,甚至无法到达第一个加油站。\n```\n示例 3:\n```\n输入:target = 100, startFuel = 10, stations = [[10,60],[20,30],[30,30],[60,40]]\n\n输出:2\n\n解释:\n我们出发时有 10 升燃料。\n我们开车来到距起点 10 英里处的加油站,消耗 10 升燃料。将汽油从 0 升加到 60 升。\n然后,我们从 10 英里处的加油站开到 60 英里处的加油站(消耗 50 升燃料),\n并将汽油从 10 升加到 50 升。然后我们开车抵达目的地。\n我们沿途在1两个加油站停靠,所以返回 2 。\n```\n\n提示:\n* $1 <= target, startFuel, stations[i][1] <= 10^9$\n* $0 <= stations.length <= 500$\n* $1 <= position_{i} < position_{i+1} < target$\n* $1 <= fuel_{i} < 10^9$", "solution": "### 贪心 + 优先队列(堆)\n\n我们可以模拟行进过程,使用 `n` 代表加油站总个数,`idx` 代表经过的加油站下标,使用 `remain` 代表当前有多少油(起始有 `remain = startFuel`),`loc` 代表走了多远,`ans` 代表答案(至少需要的加油次数)。\n\n只要 `loc < target`,代表还没到达(经过)目标位置,我们可以继续模拟行进过程。\n\n每次将 `remain` 累加到 `loc` 中,含义为使用完剩余的油量,可以去到的最远距离,同时将所在位置 `stations[idx][0] <= loc` 的加油站数量加入优先队列(大根堆,根据油量排倒序)中。\n\n再次检查是否满足 `loc < target`(下次循环),此时由于清空了剩余油量 `remain`,我们尝试从优先队列(大根堆)中取出过往油量最大的加油站并进行加油(同时对加油次数 `ans` 进行加一操作)。\n\n使用新的剩余油量 `remain` 重复上述过程,直到满足 `loc >= target` 或无油可加。\n\n容易证明该做法的正确性:同样是消耗一次加油次数,始终选择油量最大的加油站进行加油,可以确保不存在更优的结果。\n\nJava 代码:\n```Java\nclass Solution {\n    public int minRefuelStops(int target, int startFuel, int[][] stations) {\n        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);\n        int n = stations.length, idx = 0;\n        int remain = startFuel, loc = 0, ans = 0;\n        while (loc < target) {\n            if (remain == 0) {\n                if (!q.isEmpty() && ++ans >= 0) remain += q.poll();\n                else return -1;\n            }\n            loc += remain; remain = 0;\n            while (idx < n && stations[idx][0] <= loc) q.add(stations[idx++][1]);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int minRefuelStops(int target, int startFuel, vector<vector<int>>& stations) {\n        priority_queue<int> q;\n        int n = stations.size(), idx = 0;\n        int remain = startFuel, loc = 0, ans = 0;\n        while (loc < target) {\n            if (remain == 0) {\n                if (!q.empty() && ++ans >= 0) {\n                    remain += q.top();\n                    q.pop();\n                } else {\n                    return -1;\n                }\n            }\n            loc += remain; remain = 0;\n            while (idx < n && stations[idx][0] <= loc) q.push(stations[idx++][1]);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minRefuelStops(self, target: int, startFuel: int, stations: List[List[int]]) -> int:\n        q = []\n        n, idx = len(stations), 0\n        remain, loc, ans = startFuel, 0, 0\n        while loc < target:\n            if remain == 0:\n                if q:\n                    ans += 1\n                    remain += -heappop(q)\n                else:\n                    return -1\n            loc, remain = loc + remain, 0\n            while idx < n and stations[idx][0] <= loc:\n                heappush(q, -stations[idx][1])\n                idx += 1\n        return ans\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.871` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/871-880/872. 叶子相似的树（简单）.md", "url_title": "872. 叶子相似的树", "url": "https://leetcode-cn.com/problems/leaf-similar-trees/solution/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-udfc/", "difficulty": "简单", "tags": ["树的搜索", "非递归", "递归", "DFS"], "question": "请考虑一棵二叉树上所有的叶子,这些叶子的值按从左到右的顺序排列形成一个 叶值序列 。\n\n举个例子,如上图所示,给定一棵叶值序列为 (6, 7, 4, 9, 8) 的树。\n\n如果有两棵二叉树的叶值序列是相同,那么我们就认为它们是 叶相似 的。\n\n如果给定的两个根结点分别为 root1 和 root2 的树是叶相似的,则返回 true;否则返回 false 。\n\n \n\n示例 1:\n\n```\n输入:\nroot1 = [3,5,1,6,2,9,8,null,null,7,4], \nroot2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]\n\n输出:true\n```\n示例 2:\n```\n输入:root1 = [1], root2 = [1]\n\n输出:true\n```\n示例 3:\n```\n输入:root1 = [1], root2 = [2]\n\n输出:false\n```\n示例 4:\n```\n输入:root1 = [1,2], root2 = [2,2]\n\n输出:true\n```\n示例 5:\n\n```\n输入:root1 = [1,2,3], root2 = [1,3,2]\n\n输出:false\n```\n\n提示:\n* 给定的两棵树可能会有 1 到 200 个结点。\n* 给定的两棵树上的值介于 0 到 200 之间。", "solution": "### 递归 \n\n递归写法十分简单,属于树的遍历中最简单的实现方式。\n\n代码:\n```Java\nclass Solution {\n    public boolean leafSimilar(TreeNode t1, TreeNode t2) {\n        List<Integer> l1 = new ArrayList<>(), l2 = new ArrayList<>();\n        dfs(t1, l1);\n        dfs(t2, l2);\n        if (l1.size() == l2.size()) {\n            for (int i = 0; i < l1.size(); i++) {\n                if (!l1.get(i).equals(l2.get(i))) return false;\n            }\n            return true;\n        }\n        return false;\n    }\n    void dfs(TreeNode root, List<Integer> list) {\n        if (root == null) return;\n        if (root.left == null && root.right == null) {\n            list.add(root.val);\n            return;\n        }\n        dfs(root.left, list);\n        dfs(root.right, list);\n    }\n}\n```\n* 时间复杂度:`n` 和 `m` 分别代表两棵树的节点数量。复杂度为 $O(n + m)$\n* 空间复杂度:`n` 和 `m` 分别代表两棵树的节点数量,当两棵树都只有一层的情况,所有的节点值都会被存储在 $list$ 中。复杂度为 $O(n + m)$\n\n---\n\n### 迭代\n\n迭代其实就是使用「栈」来模拟递归过程,也属于树的遍历中的常见实现形式。\n\n一般简单的面试中如果问到树的遍历,面试官都不会对「递归」解法感到满意,因此掌握「迭代/非递归」写法同样重要。\n\n代码:\n```Java\nclass Solution {\n    public boolean leafSimilar(TreeNode t1, TreeNode t2) {\n        List<Integer> l1 = new ArrayList<>(), l2 = new ArrayList<>();\n        process(t1, l1);\n        process(t2, l2);\n        if (l1.size() == l2.size()) {\n            for (int i = 0; i < l1.size(); i++) {\n                if (!l1.get(i).equals(l2.get(i))) return false;\n            }\n            return true;\n        }\n        return false;\n    }\n    void process(TreeNode root, List<Integer> list) {\n        Deque<TreeNode> d = new ArrayDeque<>();\n        while (root != null || !d.isEmpty()) {\n            while (root != null) {\n                d.addLast(root);\n                root = root.left;\n            }\n            root = d.pollLast();\n            if (root.left == null && root.right == null) list.add(root.val);\n            root = root.right;\n        }\n    }\n}\n```\n* 时间复杂度:`n` 和 `m` 分别代表两棵树的节点数量。复杂度为 $O(n + m)$\n* 空间复杂度:`n` 和 `m` 分别代表两棵树的节点数量,当两棵树都只有一层的情况,所有的节点值都会被存储在 $list$ 中。复杂度为 $O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.872` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/871-880/873. 最长的斐波那契子序列的长度（中等）.md", "url_title": "873. 最长的斐波那契子序列的长度", "url": "https://leetcode.cn/problems/length-of-longest-fibonacci-subsequence/solution/by-ac_oier-beo2/", "difficulty": "中等", "tags": ["序列 DP", "哈希表", "动态规划"], "question": "如果序列 $X_1, X_2, ..., X_n$ 满足下列条件,就说它是 斐波那契式 的:\n\n* `n >= 3`\n* 对于所有 `i + 2 <= n`,都有 $X_i + X_{i+1} = X_{i+2}$\n\n给定一个严格递增的正整数数组形成序列 `arr`,找到 `arr` 中最长的斐波那契式的子序列的长度。如果一个不存在,返回  $0$ 。\n\n(回想一下,子序列是从原序列 `arr` 中派生出来的,它从 `arr` 中删掉任意数量的元素(也可以不删),而不改变其余元素的顺序。例如, `[3, 5, 8]` 是 `[3, 4, 5, 6, 7, 8]` 的一个子序列)\n\n示例 1:\n```\n输入: arr = [1,2,3,4,5,6,7,8]\n\n输出: 5\n\n解释: 最长的斐波那契式子序列为 [1,2,3,5,8] 。\n```\n示例 2:\n```\n输入: arr = [1,3,7,11,12,14,18]\n\n输出: 3\n\n解释: 最长的斐波那契式子序列有 [1,11,12]、[3,11,14] 以及 [7,11,18] 。\n```\n\n提示:\n* $3 <= arr.length <= 1000$\n* $1 <= arr[i] < arr[i + 1] <= 10^9$", "solution": "### 序列 DP\n\n定义 $f[i][j]$ 为使用 $arr[i]$ 为斐波那契数列的最后一位,使用 $arr[j]$ 为倒数第二位(即 $arr[i]$ 的前一位)时的最长数列长度。\n\n不失一般性考虑 $f[i][j]$ 该如何计算,首先根据斐波那契数列的定义,我们可以直接算得 $arr[j]$ 前一位的值为 $arr[i] - arr[j]$,而快速得知 $arr[i] - arr[j]$ 值的坐标 $t$,可以利用 `arr` 的严格单调递增性质,使用「哈希表」对坐标进行转存,若坐标 $t$ 存在,并且符合 $t < j$,说明此时至少凑成了长度为 $3$ 的斐波那契数列,同时结合状态定义,可以使用 $f[j][t]$ 来更新 $f[i][j]$,即有状态转移方程:\n\n$$\nf[i][j] = \\max(3, f[j][t] + 1)\n$$\n\n同时,当我们「从小到大」枚举 $i$,并且「从大到小」枚举 $j$ 时,我们可以进行如下的剪枝操作:\n\n* 可行性剪枝:当出现 $arr[i] - arr[j] >= arr[j]$,说明即使存在值为 $arr[i] - arr[j]$ 的下标 $t$,根据 `arr` 单调递增性质,也不满足 $t < j < i$ 的要求,且继续枚举更小的 $j$,仍然有 $arr[i] - arr[j] >= arr[j]$,仍不合法,直接 `break` 掉当前枚举 $j$ 的搜索分支;\n* 最优性剪枝:假设当前最大长度为 `ans`,只有当 $j + 2 > ans$,我们才有必要往下搜索,$j + 2$ 的含义为以 $arr[j]$ 为斐波那契数列倒数第二个数时的理论最大长度。\n\n代码:\n```Java\nclass Solution {\n    public int lenLongestFibSubseq(int[] arr) {\n        int n = arr.length, ans = 0;\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = 0; i < n; i++) map.put(arr[i], i);\n        int[][] f = new int[n][n];\n        for (int i = 0; i < n; i++) {\n            for (int j = i - 1; j >= 0 && j + 2 > ans; j--) {\n                if (arr[i] - arr[j] >= arr[j]) break;\n                int t = map.getOrDefault(arr[i] - arr[j], -1);\n                if (t == -1) continue;\n                f[i][j] = Math.max(3, f[j][t] + 1);\n                ans = Math.max(ans, f[i][j]);\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:存入哈希表复杂度为 $O(n)$;`DP` 过程复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.873` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/871-880/875. 爱吃香蕉的珂珂（中等）.md", "url_title": "875. 爱吃香蕉的珂珂", "url": "https://leetcode.cn/problems/koko-eating-bananas/solution/by-ac_oier-4z7i/", "difficulty": "中等", "tags": ["二分"], "question": "珂珂喜欢吃香蕉。这里有 `n` 堆香蕉,第 `i` 堆中有 `piles[i]` 根香蕉。警卫已经离开了,将在 `h` 小时后回来。\n\n珂珂可以决定她吃香蕉的速度 `k` (单位:根/小时)。每个小时,她将会选择一堆香蕉,从中吃掉 `k` 根。如果这堆香蕉少于 `k` 根,她将吃掉这堆的所有香蕉,然后这一小时内不会再吃更多的香蕉。  \n\n珂珂喜欢慢慢吃,但仍然想在警卫回来前吃掉所有的香蕉。\n\n返回她可以在 `h` 小时内吃掉所有香蕉的最小速度 `k`(`k` 为整数)。\n\n示例 1:\n```\n输入:piles = [3,6,7,11], h = 8\n\n输出:4\n```\n示例 2:\n```\n输入:piles = [30,11,23,4,20], h = 5\n\n输出:30\n```\n示例 3:\n```\n输入:piles = [30,11,23,4,20], h = 6\n\n输出:23\n```\n\n提示:\n* $1 <= piles.length <= 10^4$\n* $piles.length <= h <= 10^9$\n* $1 <= piles[i] <= 10^9$", "solution": "### 二分\n\n由于存在「吃完这堆的所有香蕉,然后这一小时内不会再吃更多的香蕉」的条件,因此不会存在多堆香蕉共用一个小时的情况,即每堆香蕉都是相互独立,同时可以明确每堆香蕉的耗时为 $\\left \\lceil \\frac{piles[i]}{k} \\right \\rceil$(其中 $k$ 为速度)。\n\n因此我们可以二分 $k$ 值,在以 $k$ 为分割点的数组上具有「二段性」:\n\n* 小于 $k$ 的值,总耗时 $ans$ 必然不满足 $ans \\leq h$\n* 大于等于 $k$ 的值,总耗时 $ans$ 必然满足 $ans \\leq h$\n\n然后我们需要确定二分的范围,每堆香蕉至少消耗一个小时,因此大于 $\\max(piles[i])$ 的速度值 $k$ 是没有意义的(与 $k = \\max(piles[i])$ 等价),因此我们可以先对 `piles` 进行一次遍历,找最大值,再二分;也可以直接利用数据范围 $1 <= piles[i] <= 10^9$ 确定一个粗略边界进行二分。\n\n最后的 `check` 函数,只需要计算当前速率 $k$ 所对应的总耗时 $ans$,再与 $h$ 做比较即可。\n\n代码:\n```Java\nclass Solution {\n    public int minEatingSpeed(int[] piles, int h) {\n        int l = 0, r = (int)1e9;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (check(piles, mid, h)) r = mid;\n            else l = mid + 1;\n        }\n        return r;\n    }\n    boolean check(int[] p, int k, int h) {\n        int ans = 0;\n        for (int x : p) ans += Math.ceil(x * 1.0 / k);\n        return ans <= h;\n    }\n}\n```\n* 时间复杂度:令 $n$ 数组长度,$m = 1e9$ 为最大的 $piles[i]$,复杂度为 $O(n\\log{m})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.875` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/871-880/877. 石子游戏（中等）.md", "url_title": "877. 石子游戏", "url": "https://leetcode-cn.com/problems/stone-game/solution/gong-shui-san-xie-jing-dian-qu-jian-dp-j-wn31/", "difficulty": "中等", "tags": ["区间 DP", "博弈论"], "question": "亚历克斯和李用几堆石子在做游戏。偶数堆石子排成一行,每堆都有正整数颗石子 piles[i] 。\n\n游戏以谁手中的石子最多来决出胜负。石子的总数是奇数,所以没有平局。\n\n亚历克斯和李轮流进行,亚历克斯先开始。 每回合,玩家从行的开始或结束处取走整堆石头。 这种情况一直持续到没有更多的石子堆为止,此时手中石子最多的玩家获胜。\n\n假设亚历克斯和李都发挥出最佳水平,当亚历克斯赢得比赛时返回 true ,当李赢得比赛时返回 false 。\n\n示例:\n```\n输入:[5,3,4,5]\n输出:true\n解释:\n亚历克斯先开始,只能拿前 5 颗或后 5 颗石子 。\n假设他取了前 5 颗,这一行就变成了 [3,4,5] 。\n如果李拿走前 3 颗,那么剩下的是 [4,5],亚历克斯拿走后 5 颗赢得 10 分。\n如果李拿走后 5 颗,那么剩下的是 [3,4],亚历克斯拿走后 4 颗赢得 9 分。\n这表明,取前 5 颗石子对亚历克斯来说是一个胜利的举动,所以我们返回 true 。\n```\n\n提示:\n* 2 <= piles.length <= 500\n* piles.length 是偶数。\n* 1 <= piles[i] <= 500\n* sum(piles) 是奇数。", "solution": "### 动态规划\n\n**定义 $f[l][r]$ 为考虑区间 $[l,r]$,在双方都做最好选择的情况下,先手与后手的最大得分差值为多少。**\n\n那么 $f[1][n]$ 为考虑所有石子,先手与后手的得分差值:\n\n* $f[1][n] > 0$,则先手必胜,返回 `True`\n* $f[1][n] < 0$,则先手必败,返回 `False`\n\n不失一般性的考虑 $f[l][r]$ 如何转移。根据题意,只能从两端取石子(令 $piles$ 下标从 $1$ 开始),共两种情况:\n\n* 从左端取石子,价值为 $piles[l - 1]$;取完石子后,原来的后手变为先手,从 $[l + 1, r]$ 区间做最优决策,所得价值为 $f[l + 1][r]$。**因此本次先手从左端点取石子的话,双方差值为**:\n\n$$\npiles[l - 1] - f[l + 1][r]\n$$\n\n* 从右端取石子,价值为 $piles[r - 1]$;取完石子后,原来的后手变为先手,从 $[l, r - 1]$ 区间做最优决策,所得价值为 $f[l][r - 1]$。**因此本次先手从右端点取石子的话,双方差值为**:\n\n$$\npiles[r - 1] - f[l][r - 1]\n$$\n\n双方都想赢,都会做最优决策(即使自己与对方分差最大)。因此 $f[l][r]$ 为上述两种情况中的最大值。\n\n根据状态转移方程,我们发现大区间的状态值依赖于小区间的状态值,典型的区间 DP 问题。\n\n按照从小到大「枚举区间长度」和「区间左端点」的常规做法进行求解即可。\n\n代码:\n```Java\nclass Solution {\n    public boolean stoneGame(int[] ps) {\n        int n = ps.length;\n        int[][] f = new int[n + 2][n + 2]; \n        for (int len = 1; len <= n; len++) { // 枚举区间长度\n            for (int l = 1; l + len - 1 <= n; l++) { // 枚举左端点\n                int r = l + len - 1; // 计算右端点\n                int a = ps[l - 1] - f[l + 1][r];\n                int b = ps[r - 1] - f[l][r - 1];\n                f[l][r] = Math.max(a, b);\n            }\n        }\n        return f[1][n] > 0;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 博弈论\n\n事实上,这还是一道很经典的博弈论问题,也是最简单的一类博弈论问题。\n\n为了方便,我们称「石子序列」为石子在原排序中的编号,下标从 $1$ 开始。\n\n由于石子的堆数为偶数,且只能从两端取石子。**因此先手后手所能选择的石子序列,完全取决于先手每一次决定。**\n\n由于石子的堆数为偶数,对于先手而言:**每一次的决策局面,都能「自由地」选择奇数还是偶数的序列,从而限制后手下一次「只能」奇数还是偶数石子。**\n\n具体的,对于本题,**由于石子堆数为偶数,因此先手的最开始局面必然是 $[奇数, 偶数]$,即必然是「奇偶性不同的局面」;当先手决策完之后,交到给后手的要么是 $[奇数,奇数]$ 或者 $[偶数,偶数]$,即必然是「奇偶性相同的局面」;后手决策完后,又恢复「奇偶性不同的局面」交回到先手** ...\n\n不难归纳推理,这个边界是可以应用到每一个回合。\n\n**因此先手只需要在进行第一次操作前计算原序列中「奇数总和」和「偶数总和」哪个大,然后每一次决策都「限制」对方只能选择「最优奇偶性序列」的对立面即可。**\n\n同时又由于所有石子总和为奇数,堆数为偶数,即没有平局,所以先手必胜。\n\n代码:\n```Java\nclass Solution {\n    public boolean stoneGame(int[] piles) {\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(1)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.877` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/871-880/878. 第 N 个神奇数字（困难）.md", "url_title": "878. 第 N 个神奇数字", "url": "https://leetcode.cn/problems/nth-magical-number/solution/by-ac_oier-ln3b/", "difficulty": "困难", "tags": ["数学", "容斥原理", "二分", "gcd", "lcm"], "question": "一个正整数如果能被 `a` 或 `b` 整除,那么它是神奇的。\n\n给定三个整数 `n` , `a` , `b` ,返回第 `n` 个神奇的数字。因为答案可能很大,所以返回答案 对 $10^9 + 7$ 取模 后的值。\n\n示例 1:\n```\n输入:n = 1, a = 2, b = 3\n\n输出:2\n```\n示例 2:\n```\n输入:n = 4, a = 2, b = 3\n\n输出:6\n```\n\n提示:\n* $1 <= n <= 10^9$\n* $2 <= a, b <= 4 \\times 10^4$", "solution": "### 数学\n\n#### 提示一 : 从题面分析常见做法,从常见做法复杂度出发考虑其他做法\n\n若不看数据范围,只看题面,容易想到的做法是「多路归并」:起始使用两个指针指向 `[a, 2a, 3a, ... ]` 和 `[b, 2b, 3b, ...]` 的开头,不断比较两指针所指向的数值大小,从而决定将谁后移,并不断更新顺位计数。\n\n该做法常见,但其复杂度为 $O(n)$,对于本题 $n = 1e9$ 来说并不可行。\n\n确定线性复杂度的做法不可行后,我们考虑是否存在对数复杂度的做法。\n\n#### 提示二 : 如何考虑常见的对数复杂度做法,如何定义二段性\n\n题目要我们求第 $n$ 个符合要求的数,假设我们想要通过「二分」来找该数值,那么我们需要分析其是否存在「二段性」。\n\n假设在所有「能够被 `a` 或 `b` 整除的数」形成的数轴上,我们要找的分割点是 `k`,我们期望通过「二分」来找到 `k` 值,那么需要定义某种性质,使得 `k` 左边的数均满足该性质,`k` 右边的数均不满足该性质。\n\n不难想到可根据题意来设定该性质:小于 `k` 的任意数字 `x` 满足在 $[0, x]$ 范围数的个数不足 `k` 个,而大于等于 `k` 的任意数字 `x` 则不满足该性质。\n\n#### 提示三 : 如何实现高效的 `check` 函数\n\n当确定使用「二分」来做时,剩下问题转化为:**如何快速得知某个 $[0, n]$ 中满足要求的数的个数。**\n\n容易联想到「容斥原理」:**能被 `a` 或 `b` 整除的数的个数 = 能够被 `a` 整除的数的个数 + 能够被 `b` 整除的数的个数 - 既能被 `a` 又能被 `b` 整除的数的个数**。\n\n$$\n\\left \\lfloor \\frac{n}{a} \\right \\rfloor + \\left \\lfloor \\frac{n}{b} \\right \\rfloor - \\left \\lfloor \\frac{n}{c} \\right \\rfloor\n$$\n\n其中 `c` 为 `a` 和 `b` 的最小公倍数。\n\n求解最小公倍数 `lcm` 需要实现最大公约数 `gcd`,两者模板分别为:\n\n```Java []\nint gcd(int a, int b) {\n    return b == 0 ? a : gcd(b, a % b);\n}\nint lcm(int a, int b) {\n    return a * b / gcd(a, b);\n}\n```\n\n#### 提示四 : 如何确定值域\n\n一个合格的值域只需要确定答案在值域范围即可,因此我们可以直接定值域大小为 $1e18$。\n\n或是根据 `a` 和 `b` 的取值来大致确定:假设两者中的较大值为 $m$,此时第 $n$ 个符合要求的数最大不会超过 $n \\times m$,因此也可以设定值域大小为 $[0, 40000n]$。\n\nJava 代码:\n```Java\nclass Solution {\n    int n, a, b, c;\n    int gcd(int a, int b) {\n        return b == 0 ? a : gcd(b, a % b);\n    }\n    public int nthMagicalNumber(int _n, int _a, int _b) {\n        n = _n; a = _a; b = _b; c = a * b / gcd(a, b);\n        long l = 0, r = (long)1e18;\n        while (l < r) {\n            long mid = l + r >> 1;\n            if (check(mid) >= n) r = mid;\n            else l = mid + 1;\n        }\n        return (int)(r % 1000000007);\n    }\n    long check(long x) {\n        return x / a + x / b - x / c;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int n, a, b, c;\n    int gcd(int a, int b) {\n        return b == 0 ? a : gcd(b, a % b);\n    }\n    long check(long x) {\n        return x / a + x / b - x / c;\n    }\n    int nthMagicalNumber(int _n, int _a, int _b) {\n        n = _n; a = _a; b = _b; c = a * b / gcd(a, b);\n        long l = 0, r = 1e18;\n        while (l < r) {\n            long mid = l + r >> 1;\n            if (check(mid) >= n) r = mid;\n            else l = mid + 1;\n        }\n        return (int)(r % 1000000007);\n    }\n};\n```\nPython3 代码:\n```Python\nclass Solution:\n    def nthMagicalNumber(self, n: int, a: int, b: int) -> int:\n        def gcd(a, b):\n            return a if b == 0 else gcd(b, a % b)\n        def check(x):\n            return x // a + x // b - x // c\n        c = a * b // gcd(a, b)\n        l, r = 0, 1e18\n        while l < r:\n            mid = (l + r) // 2\n            if check(mid) >= n:\n                r = mid\n            else:\n                l = mid + 1\n        return int(r % 1000000007)\n```\nTypeScript 代码:\n```TypeScript\nfunction nthMagicalNumber(n: number, a: number, b: number): number {\n    function gcd(a: number, b: number): number {\n        return b == 0 ? a : gcd(b, a % b)\n    }\n    function check(x: number): number {\n        return Math.floor(x / a) + Math.floor(x / b) - Math.floor(x / c)\n    }\n    const c = Math.floor(a * b / gcd(a, b))\n    let l = 0, r = 1e18\n    while (l < r) {\n        const mid = Math.floor((l + r) / 2)\n        if (check(mid) >= n) r = mid\n        else l = mid + 1\n    }\n    return r % 1000000007\n}\n```\n* 时间复杂度:$O(\\log{N})$,其中 $N = 1e18$ 为值域大小\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.878` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/871-880/879. 盈利计划（困难）.md", "url_title": "879. 盈利计划", "url": "https://leetcode-cn.com/problems/profitable-schemes/solution/gong-shui-san-xie-te-shu-duo-wei-fei-yon-7su9/", "difficulty": "困难", "tags": ["动态规划", "容斥原理", "数学", "背包问题", "多维背包"], "question": "集团里有 `n` 名员工,他们可以完成各种各样的工作创造利润。\n\n第 `i` 种工作会产生 `profit[i]` 的利润,它要求 `group[i]` 名成员共同参与。如果成员参与了其中一项工作,就不能参与另一项工作。\n\n工作的任何至少产生 `minProfit` 利润的子集称为 盈利计划 。并且工作的成员总数最多为 `n` 。\n\n有多少种计划可以选择?因为答案很大,所以 返回结果模 $10^9 + 7 $ 的值。\n\n示例 1:\n```\n输入:n = 5, minProfit = 3, group = [2,2], profit = [2,3]\n输出:2\n解释:至少产生 3 的利润,该集团可以完成工作 0 和工作 1 ,或仅完成工作 1 。\n总的来说,有两种计划。\n```\n示例 2:\n```\n输入:n = 10, minProfit = 5, group = [2,3,5], profit = [6,7,8]\n输出:7\n解释:至少产生 5 的利润,只要完成其中一种工作就行,所以该集团可以完成任何工作。\n有 7 种可能的计划:(0),(1),(2),(0,1),(0,2),(1,2),以及 (0,1,2) 。\n```\n\n提示:\n* 1 <= n <= 100\n* 0 <= minProfit <= 100\n* 1 <= group.length <= 100\n* 1 <= group[i] <= 100\n* profit.length == group.length\n* 0 <= profit[i] <= 100", "solution": "### 动态规划\n\n这是一类特殊的多维费用背包问题。\n\n将每个任务看作一个「物品」,完成任务所需要的人数看作「成本」,完成任务得到的利润看作「价值」。\n\n其特殊在于存在一维容量维度需要满足「不低于」,而不是常规的「不超过」。这需要我们对于某些状态作等价变换。\n\n**定义 $f[i][j][k]$ 为考虑前 $i$ 件物品,使用人数不超过 $j$,所得利润至少为 $k$ 的方案数。**\n\n对于每件物品(令下标从 $1$ 开始),我们有「选」和「不选」两种决策:\n\n* 不选:显然有:\n\n$$\nf[i - 1][j][k]\n$$\n\n* 选:首先需要满足人数达到要求( $j >= group[i - 1]$ ),还需要考虑「至少利润」负值问题:\n    如果直接令「利润维度」为 $k - profit[i - 1]$ 可能会出现负值,那么负值是否为合法状态呢?这需要结合「状态定义」来看,由于是「利润至少为 $k$」,因此属于「合法状态」,需要参与转移。\n    **由于我们没有设计动规数组存储「利润至少为负权」状态,我们需要根据「状态定义」做一个等价替换,将这个「状态」映射到 $f[i][j][0]$。这主要是利用所有的任务利润都为“非负数”,所以不可能出现利润为负的情况,这时候「利润至少为某个负数 $k$」的方案数其实是完全等价于「利润至少为 $0$」的方案数。**\n\n$$\nf[i - 1][j - group[i - 1]][\\max(k - profit[i - 1], 0)]\n$$\n\n最终 $f[i][j][k]$ 为上述两种情况之和.\n\n然后考虑「如何构造有效起始值」问题,还是结合我们的「状态定义」来考虑:\n\n当不存在任何物品(任务)时,所得利用利润必然为 $0$(满足至少为 $0$),同时对人数限制没有要求。\n\n因此可以让所有 $f[0][x][0] = 1$。\n\n代码(一维空间优化代码见 P2):\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int profitableSchemes(int n, int min, int[] gs, int[] ps) {\n        int m = gs.length;\n        long[][][] f = new long[m + 1][n + 1][min + 1];\n        for (int i = 0; i <= n; i++) f[0][i][0] = 1;            \n        for (int i = 1; i <= m; i++) {\n            int a = gs[i - 1], b = ps[i - 1];\n            for (int j = 0; j <= n; j++) {\n                for (int k = 0; k <= min; k++) {\n                    f[i][j][k] = f[i - 1][j][k];\n                    if (j >= a) {\n                        int u = Math.max(k - b, 0);\n                        f[i][j][k] += f[i - 1][j - a][u];\n                        f[i][j][k] %= mod;\n                    }\n                }\n            }\n        }\n        return (int)f[m][n][min]; \n    }\n}\n```\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int profitableSchemes(int n, int min, int[] gs, int[] ps) {\n        int m = gs.length;\n        int[][] f = new int[n + 1][min + 1];\n        for (int i = 0; i <= n; i++) f[i][0] = 1;            \n        for (int i = 1; i <= m; i++) {\n            int a = gs[i - 1], b = ps[i - 1];\n            for (int j = n; j >= a; j--) {\n                for (int k = min; k >= 0; k--) {\n                    int u = Math.max(k - b, 0);\n                    f[j][k] += f[j - a][u];\n                    if (f[j][k] >= mod) f[j][k] -= mod;\n                }\n            }\n        }\n        return f[n][min]; \n    }\n}\n```\n* 时间复杂度:$O(m * n * min)$\n* 空间复杂度:$O(m * n * min)$\n\n---\n\n### 动态规划(作差法)\n\n这个方案足足调了快一个小时 🤣\n\n先是爆 `long`,然后转用高精度后被卡内存,最终改为滚动数组后~~勉强过了~~(不是,稳稳的过了,之前调得久是我把 `N` 多打了一位,写成 1005 了,`N` 不打错的话,不滚动也是能过的 😭😭😭 )\n\n基本思路是先不考虑最小利润 `minProfit`,求得所有只受「人数限制」的方案数 `a`,然后求得考虑「人数限制」同时,利润低于 `minProfit`(不超过 `minProfit - 1`)的所有方案数 `b`。\n\n由 `a` - `b` 即是答案。\n\n代码:\n```Java\nimport java.math.BigInteger;\nclass Solution {\n    static int N = 105;\n    static BigInteger[][] f = new BigInteger[2][N]; \n    static BigInteger[][][] g = new BigInteger[2][N][N];\n    static BigInteger mod = new BigInteger(\"1000000007\");\n    \n    public int profitableSchemes(int n, int min, int[] gs, int[] ps) {\n        int m = gs.length;\n\n        for (int j = 0; j <= n; j++) {\n            f[0][j] = new BigInteger(\"1\"); \n            f[1][j] = new BigInteger(\"0\"); \n        }\n        for (int j = 0; j <= n; j++) {\n            for (int k = 0; k <= min; k++) {\n                g[0][j][k] = new BigInteger(\"1\"); \n                g[1][j][k] = new BigInteger(\"0\"); \n            }\n        }\n\n        for (int i = 1; i <= m; i++) {\n            int a = gs[i - 1], b = ps[i - 1];\n            int x = i & 1, y = (i - 1) & 1;\n            for (int j = 0; j <= n; j++) {\n                f[x][j] = f[y][j];\n                if (j >= a) {\n                    f[x][j] = f[x][j].add(f[y][j - a]);\n                } \n            }\n        }\n        if (min == 0) return (f[m&1][n]).mod(mod).intValue();\n\n        for (int i = 1; i <= m; i++) {\n            int a = gs[i - 1], b = ps[i - 1];\n            int x = i & 1, y = (i - 1) & 1;\n            for (int j = 0; j <= n; j++) {\n                for (int k = 0; k < min; k++) {\n                    g[x][j][k] = g[y][j][k];\n                    if (j - a >= 0 && k - b >= 0) {\n                        g[x][j][k] = g[x][j][k].add(g[y][j - a][k - b]);\n                    } \n                }\n            }\n        }\n\n        return f[m&1][n].subtract(g[m&1][n][min - 1]).mod(mod).intValue();\n    }\n}\n```\n* 时间复杂度:第一遍 `DP` 复杂度为 $O(m * n)$;第二遍 `DP` 复杂度为 $O(m * n * min)$。整体复杂度为 $O(m * n * min)$\n* 空间复杂度:$O(m * n * min)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.879` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/881-890/881. 救生艇（中等）.md", "url_title": "881. 救生艇", "url": "https://leetcode-cn.com/problems/boats-to-save-people/solution/gong-shui-san-xie-noxiang-xin-ke-xue-xi-hosg8/", "difficulty": "中等", "tags": ["贪心", "双指针"], "question": "第 `i` 个人的体重为 `people[i]`,每艘船可以承载的最大重量为 `limit`。\n\n每艘船最多可同时载两人,但条件是这些人的重量之和最多为 `limit`。\n\n返回载到每一个人所需的最小船数。(保证每个人都能被船载)。\n\n示例 1:\n```\n输入:people = [1,2], limit = 3\n\n输出:1\n\n解释:1 艘船载 (1, 2)\n```\n示例 2:\n```\n输入:people = [3,2,2,1], limit = 3\n\n输出:3\n\n解释:3 艘船分别载 (1, 2), (2) 和 (3)\n```\n示例 3:\n```\n输入:people = [3,5,3,4], limit = 5\n\n输出:4\n\n解释:4 艘船分别载 (3), (3), (4), (5)\n```\n\n提示:\n* 1 <= people.length <= 50000\n* 1 <= people[i] <= limit <= 30000", "solution": "### 贪心\n\n一个直观的想法是:由于一个船要么载两人要么载一人,在人数给定的情况下,为了让使用的总船数最小,要当尽可能让更多船载两人,即尽可能多的构造出数量之和不超过 $limit$ 的二元组。\n\n先对 $people$ 进行排序,然后使用两个指针 `l` 和 `r` 分别从首尾开始进行匹配:\n\n* 如果 $people[l] + people[r] <= limit$,说明两者可以同船,此时船的数量加一,两个指针分别往中间靠拢;\n* 如果 $people[l] + people[r] > limit$,说明不能成组,由于题目确保人的重量不会超过 $limit$,此时让 $people[r]$ 独立成船,船的数量加一,`r` 指针左移。\n\n**我们猜想这样「最重匹配最轻、次重匹配次轻」的做法能使双人船的重量之和尽可能平均,从而使双人船的数量最大化。**\n\n接下来,我们使用「归纳法」证明猜想的正确性。\n\n假设最优成船组合中二元组的数量为 $c1$,我们贪心做法的二元组数量为 $c2$。\n\n最终答案 = 符合条件的二元组的数量 + 剩余人数数量,而在符合条件的二元组数量固定的情况下,剩余人数也固定。因此我们只需要证明 $c1 = c2$ 即可。\n\n通常使用「归纳法」进行证明,都会先从边界入手。\n\n当我们处理最重的人 $people[r]$(此时 $r$ 为原始右边界 $n - 1$)时:\n\n* 假设其与 $people[l]$(此时 $l$ 为原始左边界 $0$)之和超过 $limit$,说明 $people[r]$ 与数组任一成员组合都会超过 $limit$,即无论在最优组合还是贪心组合中,$people[r]$ 都会独立成船;\n* 假设 $people[r] + people[l] <= limit$,说明数组中存在至少一个成员能够与 $people[l]$ 成船:\n  \n    * 假设在最优组合中 $people[l]$ 独立成船,此时如果将贪心组合 $(people[l], people[r])$ 中的 $people[l]$ 拆分出来独立成船,贪心二元组数量 $c2$ 必然不会变大(可能还会变差),即将「贪心解」调整成「最优解」结果不会变好;\n    \n    * 假设在最优组合中,$people[l]$ 不是独立成船,又因此当前 $r$ 处于原始右边界,因此与 $people[l]$ 成组的成员 $people[x]$ 必然满足 $people[x] <= people[r]$。\n      此时我们将 $people[x]$ 和 $people[r]$ 位置进行交换(将贪心组合调整成最优组合),此时带来的影响包括:\n        * 与 $people[l]$ 成组的对象从 $people[r]$ 变为 $people[x]$,但因为 $people[x] <= people[r]$,即有 $people[l] + people[x] <= people[l] + people[r] <= limit$,仍为合法二元组,消耗船的数量为 $1$;\n        * 原本位置 $x$ 的值从 $people[x]$ 变大为 $people[r]$,如果调整后的值能组成二元组,那么原本更小的值也能组成二元组,结果没有变化;如果调整后不能成为组成二元组,那么结果可能会因此变差。\n      \n        综上,将 $people[x]$ 和 $people[r]$ 位置进行交换(将贪心组合调整成最优组合),贪心二元组数量 $c2$ 不会变大,即将「贪心解」调整成「最优解」结果不会变好。\n\n**对于边界情况,我们证明了从「贪心解」调整为「最优解」不会使得结果更好,因此可以保留当前的贪心决策,然后将问题规模缩减为 $n - 1$ 或者 $n - 2$,同时数列仍然满足升序特性,即归纳分析所依赖的结构没有发生改变,可以将上述的推理分析推广到每一个决策的回合(新边界)中。**\n\n**至此,我们证明了将「贪心解」调整为「最优解」结果不会变好,即贪心解是最优解之一。**\n\n代码:\n```Java\nclass Solution {\n    public int numRescueBoats(int[] people, int limit) {\n        Arrays.sort(people);\n        int n = people.length;\n        int l = 0, r = n - 1;\n        int ans = 0;\n        while (l <= r) {\n            if (people[l] + people[r] <= limit) l++;\n            r--;\n            ans++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$;双指针统计答案复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.881` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/881-890/882. 细分图中的可到达节点（困难）.md", "url_title": "882. 细分图中的可到达节点", "url": "https://leetcode.cn/problems/reachable-nodes-in-subdivided-graph/solution/by-ac_oier-yrhg/", "difficulty": "困难", "tags": ["最短路", "单源最短路", "Dijkstra", "SPFA"], "question": "给你一个无向图(原始图),图中有 `n` 个节点,编号从 `0` 到 `n - 1` 。你决定将图中的每条边 细分 为一条节点链,每条边之间的新节点数各不相同。\n\n图用由边组成的二维数组 `edges` 表示,其中 $edges[i] = [u_{i}, v_{i}, cnt_{i}]$ 表示原始图中节点 $u_{i}$ 和 $v_{i}$ 之间存在一条边,$cnt_{i}$ 是将边 细分 后的新节点总数。注意,$cnt_{i} = 0$ 表示边不可细分。\n\n要 细分边 $[u_{i}, v_{i}]$ ,需要将其替换为 $(cnt_{i} + 1)$ 条新边,和 $cnt_{i}$ 个新节点。新节点为 $x_1, x_2, ..., x_{cnt_{i}}$ ,新边为 $[u_{i}, x_{1}], [x_{1}, x_{2}], [x_{2}, x_{3}], ..., [x_{cnt_{i}}+1, x_{cnt_{i}}], [x_{cnt_{i}}, v_{i}]$ 。\n\n现在得到一个 新的细分图 ,请你计算从节点 `0` 出发,可以到达多少个节点?如果节点间距离是 `maxMoves` 或更少,则视为 可以到达 。\n\n给你原始图和 `maxMoves` ,返回 新的细分图中从节点 `0` 出发 可到达的节点数 。\n\n示例 1:\n```\n输入:edges = [[0,1,10],[0,2,1],[1,2,2]], maxMoves = 6, n = 3\n\n输出:13\n\n解释:边的细分情况如上图所示。\n可以到达的节点已经用黄色标注出来。\n```\n示例 2:\n```\n输入:edges = [[0,1,4],[1,2,6],[0,2,8],[1,3,1]], maxMoves = 10, n = 4\n\n输出:23\n```\n示例 3:\n```\n输入:edges = [[1,2,4],[1,4,5],[1,3,1],[2,3,4],[3,4,5]], maxMoves = 17, n = 5\n\n输出:1\n\n解释:节点 0 与图的其余部分没有连通,所以只有节点 0 可以到达。\n```\n\n提示:\n* $0 <= edges.length <= \\min(n * (n - 1) / 2, 10^4)$\n* $edges[i].length = 3$\n* $0 <= u_{i} < v_{i} < n$\n* 图中 不存在平行边\n* $0 <= cnt_{i} <= 10^4$\n* $0 <= maxMoves <= 10^9$\n* $1 <= n <= 3000$", "solution": "### 朴素 Dijkstra\n\n为了方便,我们将原始图边的数量记为 `m`,因此对于原始图而言,点的数量 $3000$,边的数量为 $10000$。\n\n题目要我们求新图上,从 `0` 点出发可到达的点的数量,我们将原图上存在的点称为「原点」,细分边上增加的点称为「细分点」,两类点中可达点的数量即是答案。\n\n在分别考虑如何统计两类点之前,我们需要重新定义一下边的权重:**若原点 `u` 和原点 `v` 的边上存在 `c` 个细分点,我们将原点 `u` 和原点 `v` 之间的边看作是一条权重为 `c + 1` 的无向边(结合题意,`c` 个点存在 `c + 1` 个分段/距离)**。\n\n重新定义边的权重后,因为该图是「稠密图」,我们可以使用「朴素 Dijkstra」来求解最短路,得到 $dist$ 数组,其中 $dist[x] = t$ 含义为从原点 `0` 点出发,到达原点 `x` 的最短距离为 `t`。\n\n> **不了解最短路的同学可以看前置 🧀 : [涵盖所有的「存图方式」与「最短路算法(详尽注释)」](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488007&idx=1&sn=9d0dcfdf475168d26a5a4bd6fcd3505d)**\n\n随后考虑如何统计答案(可达点的数量),根据统计点的类型分情况讨论:\n\n1. 对于原点:若有 $dist[x] \\leq max$ 的话,说明原点 `x` 可达,累加到答案中;\n\n2. 对于细分点:由于所有的细分点都在原图边上,因此我们可以统计所有原图边上有多少细分点可达。\n    对于任意一条边 $e(u, v)$ 而言,该边上可达点数量包含「经过原点 `u` 可达」以及「经过原点 `v` 可达」的并集,其中原点 `0` 到达原点 `u` 以及原点 `v` 的距离,我们是已知的。因此经过原点 `u` 可达的数量为 $\\max(0, max - dist[u])$,经过原点 `v` 可达的数量为 $\\max(0, max - dist[v])$,两者之和与该边上细分点的总数取 `min` 即是这条边可达点的数量。\n\n代码:\n```Java\nclass Solution {\n    static int N = 3010, INF = 0x3f3f3f3f;\n    static int[][] g = new int[N][N];\n    static int[] dist = new int[N];\n    static boolean[] vis = new boolean[N];\n    public int reachableNodes(int[][] edges, int max, int n) {\n        // 建图\n        for (int i = 0; i < n; i++) Arrays.fill(g[i], INF);\n        for (int[] info : edges) {\n            int a = info[0], b = info[1], c = info[2] + 1;\n            g[a][b] = g[b][a] = c;\n        }\n        // 朴素 Dijkstra\n        Arrays.fill(dist, INF);\n        Arrays.fill(vis, false);\n        dist[0] = 0;\n        for (int i = 0; i < n; i++) {\n            int t = -1;\n            for (int j = 0; j < n; j++) {\n                if (!vis[j] && (t == -1 || dist[j] < dist[t])) t = j;\n            }\n            vis[t] = true;\n            for (int j = 0; j < n; j++) dist[j] = Math.min(dist[j], dist[t] + g[t][j]);\n        }\n        // 统计答案\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            if (dist[i] <= max) ans++;\n        }\n        for (int[] info : edges) {\n            int a = info[0], b = info[1], c = info[2];\n            int c1 = Math.max(0, max - dist[a]), c2 = Math.max(0, max - dist[b]);\n            ans += Math.min(c, c1 + c2);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:建图复杂度为 $O(m)$;使用朴素 Dijkstra 求最短路复杂度为 $O(n^2)$;统计答案复杂度为 $O(n + m)$。整体复杂度为 $O(m + n^2)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### SPFA\n\n从数据范围来看,无论是朴素 Dijkstra 还是堆优化版的 Dijkstra 都可以过,复杂度分别为 $O(n^2)$ 和 $O(m\\log{n})$。\n\n那 Bellman Ford 类的单源最短路就无法通过了吗?\n\n理论上,无论是 Bellman Ford 还是 SPFA 复杂度均为 $O(n \\times m)$,均无法通过本题。但实际上 SPFA 由于使用队列对松弛顺序进行了调整,因此在应对「非菊花图」时均表现良好,复杂度可视为 $O(k \\times m)$,近似 $O(m)$。\n\n代码:\n```Java\nclass Solution {\n    static int N = 3010, M = 20010, INF = 0x3f3f3f3f, idx = 0;\n    static int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];\n    static int[] dist = new int[N];\n    static boolean[] vis = new boolean[N];\n    void add(int a, int b, int c) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        w[idx] = c;\n        he[a] = idx++;\n    }\n    public int reachableNodes(int[][] edges, int max, int n) {\n        // 建图\n        Arrays.fill(he, -1);\n        idx = 0;\n        for (int[] info : edges) {\n            int a = info[0], b = info[1], c = info[2] + 1;\n            add(a, b, c); add(b, a, c);\n        }\n        // SPFA\n        Arrays.fill(dist, INF);\n        Arrays.fill(vis, false);\n        Deque<Integer> d = new ArrayDeque<>();\n        d.addLast(0);\n        dist[0] = 0;\n        vis[0] = true;\n        while (!d.isEmpty()) {\n            int t = d.pollFirst();\n            vis[t] = false;\n            for (int i = he[t]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (dist[j] > dist[t] + w[i]) {\n                    dist[j] = dist[t] + w[i];\n                    if (vis[j]) continue;\n                    d.addLast(j);\n                    vis[j] = true;\n                }\n            }\n        }\n        // 统计答案\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            if (dist[i] <= max) ans++;\n        }\n        for (int[] info : edges) {\n            int a = info[0], b = info[1], c = info[2];\n            int c1 = Math.max(0, max - dist[a]), c2 = Math.max(0, max - dist[b]);\n            ans += Math.min(c, c1 + c2);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:建图复杂度为 $O(m)$;使用 SPFA 求最短路复杂度为 $O(n \\times m)$;统计答案复杂度为 $O(n + m)$。整体复杂度为 $O(n \\times m)$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.882` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/881-890/883. 三维形体投影面积（简单）.md", "url_title": "883. 三维形体投影面积", "url": "https://leetcode-cn.com/problems/projection-area-of-3d-shapes/solution/by-ac_oier-r6hj/", "difficulty": "简单", "tags": ["模拟"], "question": "在 $n * n$ 的网格 `grid` 中,我们放置了一些与 `x`,`y`,`z` 三轴对齐的 $1 * 1 * 1$ 立方体。\n\n每个值 $v = grid[i][j]$ 表示 $v$ 个正方体叠放在单元格 $(i, j)$ 上。\n\n现在,我们查看这些立方体在 `xy`、`yz` 和 `zx` 平面上的投影。\n\n投影 就像影子,将 三维 形体映射到一个 二维 平面上。从顶部、前面和侧面看立方体时,我们会看到“影子”。\n\n返回 所有三个投影的总面积 。\n\n示例 1:\n\n```\n输入:[[1,2],[3,4]]\n\n输出:17\n\n解释:这里有该形体在三个轴对齐平面上的三个投影(“阴影部分”)。\n```\n示例 2:\n```\n输入:grid = [[2]]\n\n输出:5\n```\n示例 3:\n```\n输入:[[1,0],[0,2]]\n\n输出:8\n```\n\n提示:\n* $n == grid.length == grid[i].length$\n* $1 <= n <= 50$\n* $0 <= grid[i][j] <= 50$", "solution": "### 模拟\n\n根据题意进行模拟即可,使用三个变量分别统计三视图的阴影面积:\n\n* `ans1`:统计俯视图的面积,共有 $n * n$ 个位置需要被统计,当任意格子 $g[i][j] > 0$,阴影面积加一;\n* `ans2`:统计左视图的面积,共有 $n$ 行需要被统计,每一行对 `ans2` 的贡献为该行的最大高度;\n* `ans3`:统计主视图的面积,共有 $n$ 列需要被统计,每一列对 `ans3` 的贡献为该列的最大高度。\n\n代码:\n```Java\nclass Solution {\n    public int projectionArea(int[][] g) {\n        int ans1 = 0, ans2 = 0, ans3 = 0;\n        int n = g.length;\n        for (int i = 0; i < n; i++) {\n            int a = 0, b = 0;\n            for (int j = 0; j < n; j++) {\n                if (g[i][j] > 0) ans1++;\n                a = Math.max(a, g[i][j]);\n                b = Math.max(b, g[j][i]);\n            }\n            ans2 += a; ans3 += b;\n        }\n        return ans1 + ans2 + ans3;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.883` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/881-890/884. 两句话中的不常见单词（简单）.md", "url_title": "884. 两句话中的不常见单词", "url": "https://leetcode-cn.com/problems/uncommon-words-from-two-sentences/solution/gong-shui-san-xie-shu-ju-jie-gou-mo-ni-t-wwam/", "difficulty": "简单", "tags": ["模拟", "哈希表"], "question": "句子 是一串由空格分隔的单词。每个 单词 仅由小写字母组成。\n\n如果某个单词在其中一个句子中恰好出现一次,在另一个句子中却 没有出现 ,那么这个单词就是 不常见的 。\n\n给你两个 句子 `s1` 和 `s2` ,返回所有 不常用单词 的列表。返回列表中单词可以按 任意顺序 组织。\n\n示例 1:\n```\n输入:s1 = \"this apple is sweet\", s2 = \"this apple is sour\"\n\n输出:[\"sweet\",\"sour\"]\n```\n示例 2:\n```\n输入:s1 = \"apple apple\", s2 = \"banana\"\n\n输出:[\"banana\"]\n```\n\n提示:\n* $1 <= s1.length, s2.length <= 200$\n* `s1` 和 `s2` 由小写英文字母和空格组成\n* `s1` 和 `s2` 都不含前导或尾随空格\n* `s1` 和 `s2` 中的所有单词间均由单个空格分隔", "solution": "### 数据结构 + 模拟\n\n根据题意进行模拟即可,先使用「哈希表」对两字符串进行「词频统计」,然后分别从两边的「哈希表」出发,统计符合题意的字符串数量。\n\n或是利用某个单词在一边出现一次,另外一边不曾出现,等价于「某个单词总共只出现一次」。\n\n代码:\n```Java\nclass Solution {\n    public String[] uncommonFromSentences(String s1, String s2) {\n        Map<String, Integer> map = new HashMap<>();\n        String str = s1 + \" \" + s2;\n        String[] ss = str.split(\" \");\n        for (String s : ss) map.put(s, map.getOrDefault(s, 0) + 1);\n        List<String> list = new ArrayList<>();\n        for (String s : map.keySet()) if (map.get(s) == 1) list.add(s);\n        return list.toArray(new String[list.size()]);\n    }\n}\n```\n* 时间复杂度:令 `n` 和 `m` 分别为两字符串长度,复杂度为 $O(n + m)$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.884` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/881-890/886. 可能的二分法（中等）.md", "url_title": "886. 可能的二分法", "url": "https://leetcode.cn/problems/possible-bipartition/solution/by-ac_oier-6j0n/", "difficulty": "中等", "tags": ["二分图", "染色法", "并查集", "DFS"], "question": "给定一组 `n` 人(编号为 `1, 2, ..., n`), 我们想把每个人分进任意大小的两组。\n\n每个人都可能不喜欢其他人,那么他们不应该属于同一组。\n\n给定整数 `n` 和数组 `dislikes` ,其中 $dislikes[i] = [a_i, b_i]$ ,表示不允许将编号为 $a_i$ 和  $b_i$ 的人归入同一组。\n\n当可以用这种方法将所有人分进两组时,返回 `true`;否则返回 `false`。\n\n示例 1:\n```\n输入:n = 4, dislikes = [[1,2],[1,3],[2,4]]\n\n输出:true\n\n解释:group1 [1,4], group2 [2,3]\n```\n示例 2:\n```\n输入:n = 3, dislikes = [[1,2],[1,3],[2,3]]\n\n输出:false\n```\n示例 3:\n```\n输入:n = 5, dislikes = [[1,2],[2,3],[3,4],[4,5],[1,5]]\n\n输出:false\n```\n\n提示:\n* $1 <= n <= 2000$\n* $0 <= dislikes.length <= 10^4$\n* $dislikes[i].length = 2$\n* $1 <= dislikes[i][j] <= n$\n* $a_i < b_i$\n* `dislikes` 中每一组都 不同", "solution": "### 染色法\n\n无论是从题目描述和对点边的描述,这都是一道「染色法判定二分图」的模板题。\n\n为了方便,我们令 `dislikes` 为 `ds`,将其长度记为 $m$。\n\n题目要求我们将 $n$ 个点划分到两个集合中,同时我们将每个 $ds[i]$ 看做无向边的话,可知集合内部无边,即所有的边必然横跨两个集合之间。\n\n使用 $ds[i]$ 进行建图,并将两个将要划分出的两个集合分别记为 `A` 和 `B`,我们可以采用「染色」的方式,尝试将所有点进行划分。\n\n构建一个与点数相等的数组 `color`,我们人为规定划分到集合 `A` 的点满足 $color[i] = 1$,划分到集合 `B` 的点满足 $color[i] = 2$,起始有 $color[i] = 0$,代表该点尚未被划分。\n\n随后我们可以实现 `DFS`  函数为 `boolean dfs(int u, int cur)` 含义为尝试将点 `u` 上 `cur` 色。根据定义可知,我们除了需要 `color[u] = cur` 以外,还需要遍历点 `u` 的所有出边(处理其邻点,将其划分到另一集合上),若在处理过程中发生冲突,则返回 `false`,若能顺利染色则返回 `true`。\n\n由于我们固定了颜色编号为 `1` 和 `2`,因此 `cur` 的对立色可统一为 `3 - cur`。\n\n最终,我们根据能否给所有点染色成功来决定答案。\n\nJava 代码:\n```Java\nclass Solution {\n    int N = 2010, M = 2 * 10010;\n    int[] he = new int[N], e = new int[M], ne = new int[M], color = new int[N];\n    int idx;\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    boolean dfs(int u, int cur) {\n        color[u] = cur;\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (color[j] == cur) return false;\n            if (color[j] == 0 && !dfs(j, 3 - cur)) return false;\n        }\n        return true;\n    }\n    public boolean possibleBipartition(int n, int[][] ds) {\n        Arrays.fill(he, -1);\n        for (int[] info : ds) {\n            int a = info[0], b = info[1];\n            add(a, b); add(b, a);\n        }\n        for (int i = 1; i <= n; i++) {\n            if (color[i] != 0) continue;\n            if (!dfs(i, 1)) return false;\n        }\n        return true;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int he[2010], e[2 * 10010], ne[2 * 10010], color[2010], idx = 0;\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n    }\n    bool dfs(int u, int cur) {\n        color[u] = cur;\n        for (int i = he[u]; i != -1; i = ne[i]) {\n            int j = e[i];\n            if (color[j] == cur) return false;\n            if (color[j] == 0 && !dfs(j, 3 - cur)) return false;\n        }\n        return true;\n    }\n    bool possibleBipartition(int n, vector<vector<int>>& ds) {\n        fill(he, he + n + 10, -1);\n        for (const auto& info : ds) {\n            int a = info[0], b = info[1];\n            add(a, b); add(b, a);\n        }\n        for (int i = 1; i <= n; i++) {\n            if (color[i] != 0) continue;\n            if (!dfs(i, 1)) return false;\n        }\n        return true;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def possibleBipartition(self, n: int, ds: List[List[int]]) -> bool:\n        N, M = 2010, 20010\n        he, e, ne, color = [-1] * N, [0] * M, [0] * M, [0] * N\n        idx = 0\n        def add(a, b):\n            nonlocal idx\n            e[idx], ne[idx], he[a] = b, he[a], idx\n            idx += 1\n        def dfs(u, cur):\n            color[u] = cur\n            i = he[u]\n            while i != -1:\n                j = e[i]\n                if color[j] == cur:\n                    return False\n                if color[j] == 0 and not dfs(j, 3 - cur):\n                    return False\n                i = ne[i]\n            return True\n        for info in ds:\n            a, b = info[0], info[1]\n            add(a, b)\n            add(b, a)\n        for i in range(1, n + 1):\n            if color[i] != 0:\n                continue\n            if not dfs(i, 1):\n                return False\n        return True\n```\nTypeScript 代码:\n```TypeScript\nfunction possibleBipartition(n: number, ds: number[][]): boolean {\n    const N = 2010, M = 2 * 10010\n    const he = new Array<number>(N).fill(-1), e = new Array<number>(M).fill(0), ne = new Array<number>(M).fill(0), color = new Array<number>(N).fill(0)\n    let idx = 0\n    function add(a: number, b: number): void {\n        e[idx] = b\n        ne[idx] = he[a]\n        he[a] = idx++\n    }\n    function dfs(u: number, cur: number): boolean {\n        color[u] = cur\n        for (let i = he[u]; i != -1; i = ne[i]) {\n            const j = e[i];\n            if (color[j] == cur) return false\n            if (color[j] == 0 && !dfs(j, 3 - cur)) return false\n        }\n        return true\n    }\n    for (const info of ds) {\n        const a = info[0], b = info[1]\n        add(a, b); add(b, a)\n    }\n    for (let i = 1; i <= n; i++) {\n        if (color[i] != 0) continue\n        if (!dfs(i, 1)) return false\n    }\n    return true\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### 反向点 + 并查集\n\n我们知道对于 $ds[i] = (a, b)$ 而言,点 `a` 和点 `b` 必然位于不同的集合中,同时由于只有两个候选集合,因此这样的关系具有推断性:即对于 $(a, b)$ 和 $(b, c)$ 可知 `a` 和 `c` 位于同一集合。\n\n因此,我们可以对于每个点 `x` 而言,建议一个反向点 `x + n`:若点 `x` 位于集合 `A` 则其反向点 `x + n` 位于集合 `B`,反之同理。\n\n基于此,我们可以使用「并查集」维护所有点的连通性:边维护变检查每个 $ds[i]$ 的联通关系,若 $ds[i] = (a, b)$ 联通,必然是其反向点联通所导致,必然是此前的其他 $ds[j]$ 导致的关系冲突,必然不能顺利划分成两个集合,返回 `false`,否则返回 `true`。 \n\nJava 代码:\n```Java\nclass Solution {\n    int[] p = new int[4010];\n    int find(int x) {\n        if (p[x] != x) p[x] = find(p[x]);\n        return p[x];\n    }\n    void union(int a, int b) {\n        p[find(a)] = p[find(b)];\n    }\n    boolean query(int a, int b) {\n        return find(a) == find(b);\n    }\n    public boolean possibleBipartition(int n, int[][] ds) {\n        for (int i = 1; i <= 2 * n; i++) p[i] = i;\n        for (int[] info : ds) {\n            int a = info[0], b = info[1];\n            if (query(a, b)) return false;\n            union(a, b + n); union(b, a + n);\n        }\n        return true;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> p;\n    int find(int x) {\n        if (p[x] != x) p[x] = find(p[x]);\n        return p[x];\n    }\n    void unionp(int a, int b) {\n        p[find(a)] = p[find(b)];\n    }\n    bool query(int a, int b) {\n        return find(a) == find(b);\n    }\n    bool possibleBipartition(int n, vector<vector<int>>& ds) {\n        p.resize(2 * n + 1);\n        for (int i = 1; i <= 2 * n; ++i) p[i] = i;\n        for (const auto& info : ds) {\n            int a = info[0], b = info[1];\n            if (query(a, b)) return false;\n            unionp(a, b + n);\n            unionp(b, a + n);\n        }\n        return true;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def possibleBipartition(self, n: int, ds: List[List[int]]) -> bool:\n        p = [i for i in range(0, 2 * n + 10)]\n        def find(x):\n            if p[x] != x:\n                p[x] = find(p[x])\n            return p[x]\n        def union(a, b):\n            p[find(a)] = p[find(b)]\n        def query(a, b):\n            return find(a) == find(b)\n        for info in ds:\n            a, b = info[0], info[1]\n            if query(a, b):\n                return False\n            else:\n                union(a, b + n)\n                union(b, a + n)\n        return True\n```\nTypeScript 代码:\n```TypeScript\nfunction possibleBipartition(n: number, ds: number[][]): boolean {\n    const p = new Array<number>(4010).fill(0)\n    function find(x: number): number {\n        if (p[x] != x) p[x] = find(p[x])\n        return p[x]\n    }\n    function union(a: number, b: number): void {\n        p[find(a)] = p[find(b)]\n    }\n    function query(a: number, b: number): boolean {\n        return find(a) == find(b)\n    }\n    for (let i = 1; i <= 2 * n; i++) p[i] = i\n    for (const info of ds) {\n        const a = info[0], b = info[1]\n        if (query(a, b)) return false\n        union(a, b + n); union(b, a + n)\n    }\n    return true\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.886` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/881-890/888. 公平的糖果棒交换（简单）.md", "url_title": "888. 公平的糖果棒交换", "url": "https://leetcode-cn.com/problems/fair-candy-swap/solution/xiang-jie-po-su-jie-fa-cha-zhao-you-hua-9nd9y/", "difficulty": "简单", "tags": ["哈希表"], "question": "爱丽丝和鲍勃有不同大小的糖果棒:A[i] 是爱丽丝拥有的第 i 根糖果棒的大小,B[j] 是鲍勃拥有的第 j 根糖果棒的大小。\n\n因为他们是朋友,所以他们想交换一根糖果棒,这样交换后,他们都有相同的糖果总量。(一个人拥有的糖果总量是他们拥有的糖果棒大小的总和。)\n\n返回一个整数数组 ans,其中 ans[0] 是爱丽丝必须交换的糖果棒的大小,ans[1] 是 Bob 必须交换的糖果棒的大小。\n\n如果有多个答案,你可以返回其中任何一个。\n\n保证答案存在。\n\n示例 1:\n```\n输入:A = [1,1], B = [2,2]\n\n输出:[1,2]\n```\n示例 2:\n```\n输入:A = [1,2], B = [2,3]\n\n输出:[1,2]\n```\n示例 3:\n```\n输入:A = [2], B = [1,3]\n\n输出:[2,3]\n```\n示例 4:\n```\n输入:A = [1,2,5], B = [2,4]\n\n输出:[5,4]\n```\n\n提示:\n* 1 <= A.length <= 10000\n* 1 <= B.length <= 10000\n* 1 <= A[i] <= 100000\n* 1 <= B[i] <= 100000\n* 保证爱丽丝与鲍勃的糖果总量不同。\n* 答案肯定存在。", "solution": "### 朴素解法\n\n最终目的是让两个数组总和相等。\n\n我们可以先分别求得两个数组总和为 $aSum$ 和 $bSum$。\n\n即有数组总和 $total = aSum + bSum$。\n\n同时得数组目标总和 $target = total / 2$。\n\n当前两个数组与目标总和的差值分别为 $target - aSum$ 和 $target - bSum$。\n\n我们记 $diff = target - aSum$。\n\n对于某个 $a[i]$ 而言,如果 $a[i]$ 能构成答案,那么 `b` 数组中必然存在大小为 $a[i] + diff$ 的值,使得两者交换后,数组总和均为 $target$。\n\n因此我们只需要遍历数组 `a`,查找哪一个 $a[i]$ 使得 $a[i] + diff$ 存在于数组 `b` 即可。\n\n代码:\n```Java\nclass Solution {\n    public int[] fairCandySwap(int[] a, int[] b) {\n        int aSum = 0, bSum = 0;\n        for (int i : a) aSum += i;  \n        for (int i : b) bSum += i;  \n        int total = aSum + bSum, target = total / 2;\n        int diff = target - aSum;\n        int[] ans = new int[2];\n        for (int i : a) {\n            if (find(b, i + diff)) {\n                ans[0] = i;\n                ans[1] = i + diff;\n            }\n        }\n        return ans;\n    }\n    boolean find(int[] nums, int target) {\n        for (int i : nums) {\n            if (i == target) return true;\n        }\n        return false;\n    }\n}\n```\n\n* 时间复杂度: 计算总和复杂度为 $O(n)$,找到最终解复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 查找优化\n\n上述解法之所以无法做到线性,是因为我们每次都要对数组 `b` 进行扫描,确定 $a[i] + diff$ 是否存在。\n\n我们知道 map/set/数组 都可以实现 $O(1)$ 查找,由于这里明确给出了两个数组中出现的数的范围,因此可以使用数组进行计数。\n\n同时可以优化一下变量的使用,使用一个变量 $diff$ 来计算最终的差异值。\n\n这种优化,是典型的空间换时间做法。\n\n代码:\n```Java\nclass Solution {\n    public int[] fairCandySwap(int[] a, int[] b) {\n        // 先求得 a 的总和\n        int diff = 0;\n        for (int i : a) diff += i;  \n\n        // 使用 cnt 统计 b 中的数的出现次数,同时计算 a 总和与 b 总和的差值\n        int[] cnt = new int[100009];\n        for (int i : b) {\n            diff -= i;\n            cnt[i]++;\n        }\n\n        // 计算出 a 中具体的替换差值是多少\n        diff /= -2;\n        int[] ans = new int[2];\n        for (int i : a) {\n            int target = i + diff;\n            // 如果目标替换量在合法范围,并且存在于 b 数组中。说明找到解了\n            if (target >= 1 && target <= 100000 && cnt[target] > 0) {\n                ans[0] = i;\n                ans[1] = target;\n                break;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:计算总和复杂度为 $O(n)$,找到最终解复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:使用 `cnt` 数组进行计数。复杂度为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.888` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/881-890/890. 查找和替换模式（中等）.md", "url_title": "890. 查找和替换模式", "url": "https://leetcode.cn/problems/find-and-replace-pattern/solution/by-ac_oier-s4cw/", "difficulty": "中等", "tags": ["哈希表", "模拟"], "question": "你有一个单词列表 `words` 和一个模式  `pattern`,你想知道 `words` 中的哪些单词与模式匹配。\n\n如果存在字母的排列 `p` ,使得将模式中的每个字母 `x` 替换为 `p(x)` 之后,我们就得到了所需的单词,那么单词与模式是匹配的。\n\n(回想一下,字母的排列是从字母到字母的双射:每个字母映射到另一个字母,没有两个字母映射到同一个字母。)\n\n返回 `words` 中与给定模式匹配的单词列表。\n\n你可以按任何顺序返回答案。\n\n示例:\n```\n输入:words = [\"abc\",\"deq\",\"mee\",\"aqq\",\"dkd\",\"ccc\"], pattern = \"abb\"\n\n输出:[\"mee\",\"aqq\"]\n\n解释:\n\"mee\" 与模式匹配,因为存在排列 {a -> m, b -> e, ...}。\n\"ccc\" 与模式不匹配,因为 {a -> c, b -> c, ...} 不是排列。\n因为 a 和 b 映射到同一个字母。\n```\n\n提示:\n* $1 <= words.length <= 50$\n* $1 <= pattern.length = words[i].length <= 20$", "solution": "### 哈希表 模拟\n\n根据题意进行模拟即可,使用 `map` 记录具体的映射关系,使用 `vis` 记录哪些字符已被映射,利用字符集大小只有 $26$,我们可以使用数组充当哈希表。\n\n代码:\n```Java\nclass Solution {\n    public List<String> findAndReplacePattern(String[] ws, String pe) {\n        List<String> ans = new ArrayList<>();\n        int[] map = new int[26], vis = new int[26];\n        for (String s : ws) {\n            Arrays.fill(map, -1);\n            Arrays.fill(vis, 0);\n            boolean ok = true;\n            for (int i = 0; i < pe.length() && ok; i++) {\n                int c1 = s.charAt(i) - 'a', c2 = pe.charAt(i) - 'a';\n                if (map[c1] == -1 && vis[c2] == 0) {\n                    map[c1] = c2; vis[c2] = 1;\n                } else if (map[c1] != c2) ok = false;\n            }\n            if (ok) ans.add(s);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(\\sum_{i = 0}^{n}len(ws[i]) + n \\times C)$,其中 $C = 26$ 代表字符集大小\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.890` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/891-900/891. 子序列宽度之和（困难）.md", "url_title": "891. 子序列宽度之和", "url": "https://leetcode.cn/problems/sum-of-subsequence-widths/solution/by-ac_oier-6tyk/", "difficulty": "困难", "tags": ["数学"], "question": "一个序列的 宽度 定义为该序列中最大元素和最小元素的差值。\n\n给你一个整数数组 `nums`,返回 `nums` 的所有非空 子序列 的 宽度之和 。由于答案可能非常大,请返回对 $10^9 + 7$ 取余 后的结果。\n\n子序列 定义为从一个数组里删除一些(或者不删除)元素,但不改变剩下元素的顺序得到的数组。例如,`[3,6,2,7]` 就是数组 `[0,3,1,6,2,2,7]` 的一个子序列。\n\n示例 1:\n```\n输入:nums = [2,1,3]\n\n输出:6\n\n解释:子序列为 [1], [2], [3], [2,1], [2,3], [1,3], [2,1,3] 。\n相应的宽度是 0, 0, 0, 1, 1, 2, 2 。\n宽度之和是 6 。\n```\n示例 2:\n```\n输入:nums = [2]\n\n输出:0\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $1 <= nums[i] <= 10^5$", "solution": "### 数学\n\n#### 提示一:每个子序列对答案的贡献\n\n对于某个子序列而言,若其最大值为 $a$,最小值为 $b$,则该子序列对答案的贡献为 $(a - b)$。\n\n我们有若干个子序列,即有若干个 $(a - b)$,答案为所有 $(a - b)$ 之和,我们称一个 $(a - b)$ 为 `item`。\n\n#### 提示二:每个 $nums[i]$ 参与了多少个 `item` 的组成,在最终展开式中又是如何\n\n对于每个 $(a - b)$ 而言,`a` 和 `b` 均必然是具体的 $nums[i]$。\n\n同时易知若 $nums[i]$ 作为了 $k$ 个子序列的最小值,那么在最终表达式展开中,必然有 $k$ 个 $-nums[i]$;同理若 $nums[i]$ 作为了 $k$ 个子序列的最大值,那么在最终表达式展开中,必然有 $k$ 个 $nums[i]$。\n\n#### 提示三:统计每个 $nums[i]$ 作为最值时,有多少个子序列\n\n先不考虑 $nums[i]$ 的重复问题。\n\n若 $nums[i]$ 作为子序列最小值时,首先 $nums[i]$ 必选,小于 $nums[i]$ 的必不选,而大于 $nums[i]$ 的可选可不选,组合个数取决于大于 $nums[i]$ 的数的个数,假设有 $k$ 个,那么根据组合数原理,共有 $2^k$ 个组合,即共有 $2^k$ 个子序列。此时 $nums[i]$ 对答案的贡献为 $2^k \\times (-nums[i])$。\n\n同理,$nums[i]$ 作为子序列最大值时,子序列个数取决于小于 $nums[i]$ 的数的个数,假设有 $k$ 个,此时 $nums[i]$ 对答案的贡献为 $2^k \\times nums[i]$。\n\n#### 提示四:如何快速得知比 $nums[i]$ 大/小 的数的个数\n\n排序。\n\n#### 提示五:$nums[i]$ 的重复问题\n\n无论是将 $nums[i]$ 视作最大值还是最小值,我们的组合数均取决于某一侧的数的个数,因此不会答案正确性产生影响。\n\n#### 提示六:$2^k$ 操作的重复计算问题\n\n将 $nums[i]$ 视作最值,我们都需要统计两边数所产生的组合数个数,因此即使对于单个用例都会面临重复计算某个 $2^k$ 的问题(对称性)。\n\n同时对于跨样例而言,我们仍会重复计算某些 $2^k$(尤其是较小的 $k$ 值),为避免重复计算,我们可以通过打表预处理的方式算得所有可能要用到 $2^k$ 结果,在使用的时候直接通过查表取得。\n\nJava 代码:\n```Java\nclass Solution {\n    static int N = 100010, MOD = (int)1e9+7;\n    static long[] p = new long[N];\n    static {\n        p[0] = 1; \n        for (int i = 1; i < N; i++) p[i] = p[i - 1] * 2 % MOD;\n    }\n    public int sumSubseqWidths(int[] nums) {\n        int n = nums.length;\n        long ans = 0;\n        Arrays.sort(nums);\n        for (int i = 0; i < n; i++) {\n            ans += (p[i] * nums[i]) % MOD;\n            ans %= MOD;\n            ans -= (p[n - i - 1] * nums[i]) % MOD;\n            ans %= MOD;\n        }\n        return (int) ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction sumSubseqWidths(nums: number[]): number {\n    let n = nums.length, mod = 1000000007, ans = 0\n    const p = new Array<number>(n + 10).fill(1)\n    for (let i = 1; i <= n; i++) p[i] = p[i - 1] * 2 % mod\n    nums.sort((a,b)=>a-b)\n    for (let i = 0; i < n; i++) {\n        ans += p[i] * nums[i] % mod\n        ans %= mod\n        ans -= p[n - i - 1] * nums[i] % mod\n        ans %= mod\n    }\n    return ans\n}\n```\nPython3 代码:\n```Python3\nclass Solution:\n    def sumSubseqWidths(self, nums: List[int]) -> int:\n        n, mod, ans = len(nums), 1000000007, 0\n        p = [1] * (n + 10)\n        for i in range(1, n + 1):\n            p[i] = p[i - 1] * 2 % mod\n        nums.sort()\n        for i in range(n):\n            ans = ans + p[i] * nums[i] % mod\n            ans = ans - p[n - i - 1] * nums[i] % mod\n        return ans % mod\n```\n* 时间复杂度:排序复杂度为 $O(n\\log{n})$;统计答案复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.891` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/891-900/895. 最大频率栈（困难）.md", "url_title": "895. 最大频率栈", "url": "https://leetcode.cn/problems/maximum-frequency-stack/solution/by-ac_oier-tquk/", "difficulty": "困难", "tags": ["哈希表", "模拟"], "question": "设计一个类似堆栈的数据结构,将元素推入堆栈,并从堆栈中弹出出现频率最高的元素。\n\n实现 `FreqStack` 类:\n* `FreqStack()` 构造一个空的堆栈。\n* `void push(int val)` 将一个整数 `val` 压入栈顶。\n* `int pop()` 删除并返回堆栈中出现频率最高的元素。\n\n如果出现频率最高的元素不只一个,则移除并返回最接近栈顶的元素。\n\n示例 1:\n```\n输入:\n[\"FreqStack\",\"push\",\"push\",\"push\",\"push\",\"push\",\"push\",\"pop\",\"pop\",\"pop\",\"pop\"],\n[[],[5],[7],[5],[7],[4],[5],[],[],[],[]]\n\n输出:[null,null,null,null,null,null,null,5,7,5,4]\n\n解释:\nFreqStack = new FreqStack();\nfreqStack.push (5);//堆栈为 [5]\nfreqStack.push (7);//堆栈是 [5,7]\nfreqStack.push (5);//堆栈是 [5,7,5]\nfreqStack.push (7);//堆栈是 [5,7,5,7]\nfreqStack.push (4);//堆栈是 [5,7,5,7,4]\nfreqStack.push (5);//堆栈是 [5,7,5,7,4,5]\nfreqStack.pop ();//返回 5 ,因为 5 出现频率最高。堆栈变成 [5,7,5,7,4]。\nfreqStack.pop ();//返回 7 ,因为 5 和 7 出现频率最高,但7最接近顶部。堆栈变成 [5,7,5,4]。\nfreqStack.pop ();//返回 5 ,因为 5 出现频率最高。堆栈变成 [5,7,4]。\nfreqStack.pop ();//返回 4 ,因为 4, 5 和 7 出现频率最高,但 4 是最接近顶部的。堆栈变成 [5,7]。\n```\n\n提示:\n* $0 <= val <= 10^9$\n* `push` 和 `pop` 的操作数不大于 $2 \\times 10^4$\n* 输入保证在调用 `pop` 之前堆栈中至少有一个元素", "solution": "### 哈希表\n\n这是一道很纯的哈希表题儿。\n\n首先,我们容易想到建立 **第一个哈希表 `cnts` 用于记录某个数值的出现次数,`cnts[val] = c` 含义为数值 `val` 当前在栈中的出现次数为 `c`。我们称该哈希表为「计数哈希表」**。\n\n再结合每次 `pop` 需要返回「频率最大的元素,若有多个则返回最考虑栈顶的一个」的要求,我们还可以 **建立第二个哈希 `map`,该哈希表以「出现次数 `c`」为键,以「出现次数均为 `c` 的元素序列」为值,`map[c] = A = [...]` 含义为出现次数为 `c` 的序列为 `A`,并且序列 `A` 中的结尾元素为出现次数为 `c` 的所有元素中最靠近栈顶的元素。我们称该哈希表为「分桶哈希表」**。\n\n最后再额外使用一个变量 `max` 记录当前最大出现频数,不难发现,`max` 必然是以步长 $\\pm 1$ 进行变化(当出现次数为 `max` 的元素被 `pop` 掉了一个后,必然剩下 `max - 1` 个),因此当我们在某次 `pop` 操作后发现出现次数为 `max` 的集合为空时,对 `max` 进行自减操作即可。\n\n将题目给的样例作为 🌰 ,大家可以看看 `cnts`、`map` 和 `max` 三者如何变化,以及 `pop` 的更新逻辑:\n\nJava 代码:\n```Java\nclass FreqStack {\n    Map<Integer, List<Integer>> map = new HashMap<>();\n    Map<Integer, Integer> cnts = new HashMap<>();\n    int max;\n    public void push(int val) {\n        cnts.put(val, cnts.getOrDefault(val, 0) + 1);\n        int c = cnts.get(val);\n        List<Integer> list = map.getOrDefault(c, new ArrayList<>());\n        list.add(val);\n        map.put(c, list);\n        max = Math.max(max, c);\n    }\n    public int pop() {\n        List<Integer> list = map.get(max);\n        int ans = list.remove(list.size() - 1);\n        cnts.put(ans, cnts.get(ans) - 1);\n        if (list.size() == 0) max--;\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass FreqStack {\npublic:\n    unordered_map<int, int> freq;\n    unordered_map<int, vector<int>> m;\n    int maxv = 0;\n    \n    void push(int val) {\n        maxv = max(maxv, ++freq[val]);\n        m[freq[val]].push_back(val);\n    }\n    \n    int pop() {\n        int x = m[maxv].back(); \n        m[maxv].pop_back();\n        if (m[freq[x]--].empty()) maxv--;\n        return x;\n    }\n};\n```\nPython 代码:\n```Python\nclass FreqStack:\n    def __init__(self):\n        self.cnts = defaultdict(int)\n        self.map = defaultdict(list)\n        self.mv = 0\n\n    def push(self, val: int) -> None:\n        self.cnts[val] += 1\n        c = self.cnts[val]\n        self.map[c].append(val)\n        self.mv = max(self.mv, c)\n\n    def pop(self) -> int:\n        ans = self.map[self.mv].pop()\n        self.cnts[ans] -= 1\n        self.mv -= 0 if self.map[self.mv] else 1\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nclass FreqStack {\n    map: Map<number, Array<number>> = new Map<number, Array<number>>()\n    cnst: Map<number, number> = new Map<number, number>()\n    max: number = 0\n    push(val: number): void {\n        if (!this.cnst.has(val)) this.cnst.set(val, 0)\n        this.cnst.set(val, this.cnst.get(val) + 1)\n        const c = this.cnst.get(val)\n        if (!this.map.has(c)) this.map.set(c, new Array<number>())\n        this.map.get(c).push(val)\n        this.max = Math.max(this.max, c)\n    }\n    pop(): number {\n        const ans = this.map.get(this.max).pop()\n        if (this.map.get(this.max).length == 0) this.max--\n        this.cnst.set(ans, this.cnst.get(ans) - 1)\n        return ans\n    }\n}\n```\n* 时间复杂度:所有操作均为 $O(1)$\n* 空间复杂度:所有入栈的节点最多会被存储两次,一次在计数哈希表中,一次在分桶哈希表中,复杂度为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.895` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/891-900/896. 单调数列（简单）.md", "url_title": "896. 单调数列", "url": "https://leetcode-cn.com/problems/monotonic-array/solution/wei-shi-yao-yi-ci-bian-li-yao-bi-liang-c-uglp/", "difficulty": "简单", "tags": ["数组", "模拟"], "question": "如果数组是单调递增或单调递减的,那么它是单调的。\n\n如果对于所有 i <= j,A[i] <= A[j],那么数组 A 是单调递增的。 如果对于所有 i <= j,A[i]> = A[j],那么数组 A 是单调递减的。\n\n当给定的数组 A 是单调数组时返回 true,否则返回 false。\n\n示例 1:\n```\n输入:[1,2,2,3]\n输出:true\n```\n示例 2:\n```\n输入:[6,5,4,4]\n输出:true\n```\n示例 3:\n```\n输入:[1,3,2]\n输出:false\n```\n示例 4:\n```\n输入:[1,2,4,5]\n输出:true\n```\n示例 5:\n```\n输入:[1,1,1]\n输出:true\n```\n\n提示:\n* 1 <= A.length <= 50000\n* -100000 <= A[i] <= 100000", "solution": "### 朴素解法(所谓的两次遍历)\n\n两次遍历,分别检查是否为单调递增和单调递减。\n\n```java []\nclass Solution {\n    public boolean isMonotonic(int[] a) {\n        return check(a, true) || check(a, false);\n    }\n    boolean check(int[] a, boolean flag) {\n        for (int i = 0; i < a.length - 1; i++) {\n            if (flag) {\n                if (a[i] > a[i + 1]) return false;\n            } else {\n                if (a[i] < a[i + 1]) return false;\n            }\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n***\n\n### 朴素解法(所谓的一次遍历)\n\n一次遍历。\n\n同时为了防止扫完整个数组,增加一个提前 return 的逻辑:\n\n```java \nclass Solution {\n    public boolean isMonotonic(int[] a) {\n        boolean up = true, down = true;\n        for (int i = 0; i < a.length - 1; i++) {\n            if (a[i] > a[i + 1]) up = false;\n            if (a[i] < a[i + 1]) down = false;\n            if (!up && !down) return false;\n        }\n        return up || down;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n***\n\n### 总结\n\n事实上,上述两种解法其实并**不应该区分为「一次遍历」与「两次遍历」**。\n\n**我们应该用「对数组的访问次数」来定义遍历多少次,而不是「利用 for 循环的个数」来定义。上述无论那种方法,对数组访问次数都是一样的。**\n\n而在不对解法二进行剪枝的情况下,要比解法一慢。主要是因为解法一明确了是「递增」还是「递减」之后,在循环内部做了剪枝。\n\n当我们对解法二进行同样的内部剪枝之后,其实和解法一应该是类似的。\n\n前三次提交是保留 `if (!up && !down) return false;` 的提交 (1 ms)\n后三次提交是不保留 `if (!up && !down) return false;` 的提交记录 (2 ms)\n\n简单题,大家就看个乐呵 ~ \n\n***\n\n### 有趣的实验\n\n评论区有位同学提出了一个很有意思的问题:如果数据量很大,大到内存都无法一次完全读入,那么一个循环里两次重复读应该比两次循环要快得多了吧?\n\n我理解 ta 的意思是,每次读取值都算一次 IO 成本的话,一个循环里两次重复读的的成本应该是要**小于**比两次循环的成本吧?\n\n因此有了以下的测试代码:\n\n```java\nclass Solution {\n    // 统计「二次循环」的访问次数\n    int cnt;\n    public boolean isMonotonic(int[] a) {\n        cnt = 0;\n        // 这里不直接写成「短路与」进行返回,确保两个循环都会被执行\n        boolean t = check(a, true), u = check(a, false); \n        System.out.println(cnt);\n        return t || u;\n    }\n    boolean check(int[] a, boolean flag) {\n        for (int i = 0; i < a.length - 1; i++) {\n            if (flag) {\n                if (getVal(a, i) > getVal(a, i + 1)) return false;\n            } else {\n                if (getVal(a, i) < getVal(a, i + 1)) return false;\n            }\n        }\n        return true;\n    }\n    int getVal(int[] a, int idx) {\n        cnt++;\n        return a[idx];\n    }\n}\n```\n对于样例数据的输出:8 8 6 8 8\n\n```java\nclass Solution {\n    // 统计「一次循环」的访问次数\n    int cnt;\n    public boolean isMonotonic(int[] a) {\n        cnt = 0;\n        boolean up = true, down = true;\n        for (int i = 0; i < a.length - 1; i++) {\n            if (getVal(a, i) > getVal(a, i + 1)) up = false;\n            if (getVal(a, i) < getVal(a, i + 1)) down = false;\n            if (!up && !down) break;\n        }\n        System.out.println(cnt);\n        return up || down;\n    }\n    int getVal(int[] a, int idx) {\n        cnt++;\n        return a[idx];\n    }\n}\n```\n对于样例数据的输出:12 12 8 12 8\n\n**结论:二次循环的剪枝效果应该是要比一次循环要更好点(更加直接)。如果还有人坚持「所谓的一次循环」要优于「所谓的二次循环」,实验代码就是最好的证明。**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.896` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/891-900/897. 递增顺序搜索树（简单）.md", "url_title": "897. 递增顺序搜索树", "url": "https://leetcode-cn.com/problems/increasing-order-search-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-yc8l/", "difficulty": "简单", "tags": ["树的遍历", "递归", "非递归"], "question": "给你一棵二叉搜索树,请你 按中序遍历 将其重新排列为一棵递增顺序搜索树,使树中最左边的节点成为树的根节点,并且每个节点没有左子节点,只有一个右子节点。\n\n示例 1:\n\n```\n输入:root = [5,3,6,2,4,null,8,1,null,null,null,7,9]\n\n输出:[1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]\n```\n示例 2:\n\n```\n输入:root = [5,1,7]\n\n输出:[1,null,5,null,7]\n```\n\n提示:\n* 树中节点数的取值范围是 [1, 100]\n* 0 <= Node.val <= 1000", "solution": "### 基本思路\n\n由于给定的树是一棵「二叉搜索树」,因此只要对其进行「中序遍历」即可得到有序列表,再根据有序列表构建答案即可。\n\n而二叉搜索树的「中序遍历」有「迭代」和「递归」两种形式。\n\n---\n\n### 递归\n\n递归写法十分简单,属于树的遍历中最简单的实现方式。\n\n代码:\n```Java\nclass Solution {\n    List<TreeNode> list = new ArrayList<>();\n    public TreeNode increasingBST(TreeNode root) {\n        dfs(root);\n        TreeNode dummy = new TreeNode(-1);\n        TreeNode cur = dummy;\n        for (TreeNode node : list) {\n            cur.right = node;\n            node.left = null;\n            cur = node;\n        }\n        return dummy.right;\n    }\n    void dfs(TreeNode root) {\n        if (root == null) return ;\n        dfs(root.left);\n        list.add(root);\n        dfs(root.right);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 迭代\n\n迭代其实就是使用「栈」来模拟递归过程,也属于树的遍历中的常见实现形式。\n\n一般简单的面试中如果问到树的遍历,面试官都不会对「递归」解法感到满意,因此掌握「迭代/非递归」写法同样重要。\n\n代码:\n```Java\nclass Solution {\n    List<TreeNode> list = new ArrayList<>();\n    public TreeNode increasingBST(TreeNode root) {\n        Deque<TreeNode> d = new ArrayDeque<>();\n        while (root != null || !d.isEmpty()) {\n            while (root != null) {\n                d.add(root);\n                root = root.left;\n            }\n            root = d.pollLast();\n            list.add(root);\n            root = root.right;\n        }   \n        TreeNode dummy = new TreeNode(-1);\n        TreeNode cur = dummy;\n        for (TreeNode node : list) {\n            cur.right = node;\n            node.left = null;\n            cur = node;\n        }\n        return dummy.right;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.897` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/891-900/899. 有序队列（困难）.md", "url_title": "899. 有序队列", "url": "https://leetcode.cn/problems/orderly-queue/solution/by-ac_oier-443m/", "difficulty": "困难", "tags": ["构造", "最小表示法"], "question": "给定一个字符串 `s` 和一个整数 `k` 。你可以从 `s` 的前 `k` 个字母中选择一个,并把它加到字符串的末尾。\n\n返回 在应用上述步骤的任意数量的移动后,字典上最小的字符串 。\n\n示例 1:\n```\n输入:s = \"cba\", k = 1\n\n输出:\"acb\"\n\n解释:\n在第一步中,我们将第一个字符(“c”)移动到最后,获得字符串 “bac”。\n在第二步中,我们将第一个字符(“b”)移动到最后,获得最终结果 “acb”。\n```\n示例 2:\n```\n输入:s = \"baaca\", k = 3\n\n输出:\"aaabc\"\n\n解释:\n在第一步中,我们将第一个字符(“b”)移动到最后,获得字符串 “aacab”。\n在第二步中,我们将第三个字符(“c”)移动到最后,获得最终结果 “aaabc”。\n```\n\n提示:\n* $1 <= k <= S.length <= 1000$\n* `s` 只由小写字母组成。", "solution": "### 最小表示法\n\n当 $k > 1$ 时,我们能够构造出任意的字符串方案,因此当 $k > 1$ 时,我们可以直接通过对字符串排序来得到答案,复杂度为 $O(n\\log{n})$。\n\n当 $k = 1$ 时,我们共有 $n$ 种候选方案(将字符串 `s` 看作一个首尾相接的循环字符串,共有 $n$ 个起点可枚举),枚举过程中需要与当前最优的方案进行比较,比较复杂度为 $O(n)$,因此整体复杂度为 $O(n^2)$。\n\n上述的做法已经可以通过本题,可以看出瓶颈在于对 $k = 1$ 的处理。\n\n而实际上,对于给定字符串 `s`,求其循环同构的所有方案中字典序最小的方案,可以使用「最小表示法」来做,复杂度为 $O(n)$。\n\n最小表示法将「方案比较」与「构造更优方案」进行结合:假设我们当前有两字符串 `a` 和 `b` 需要进行比较,其均为原串 `s` 的循环同构具体方案。假设 `a` 和 `b` 分别对应了原串下标为 `i` 和 `j` 的具体方案,且假设两字符串前 $k$ 个字符均相同。\n\n当两字符串第一个不同的字符大小关系为 $cs[i + k] > cs[j + k]$ 时,可以发现在下标范围 $idx \\in [i, i + k]$ 作为起点的新方案 `a'` 必然不会是最优方案,即必然存在下标范围 $idx - i + j$ 作为起点的新方案 `b'` 比其更优,因此我们可以直接从 $i + k + 1$ 位置构造新的更优方案,并与 `b` 再次比较。而 $cs[i + k] < cs[j + k]$ 的分析同理。\n\n> 更为直白的表述为:分别从 `i` 和 `j` 作为起点的字符串 `a` 和 `b`,其前 $k$ 个字符相同,而当 $cs[i + k] > cs[j + k]$ 时,我们可以明确「以 $i + p$ 为起点的字符串」必不可能比「以 $j + p$ 为起点的字符串」更优,其中 $p \\in [0, k]$。\n\nJava 代码:\n```Java\nclass Solution {\n    public String orderlyQueue(String s, int _k) {\n        char[] cs = s.toCharArray();\n        if (_k == 1) {\n            int i = 0, j = 1, k = 0, n = cs.length;\n            while (i < n && j < n && k < n) {\n                char a = cs[(i + k) % n], b = cs[(j + k) % n];\n                if (a == b) k++;\n                else {\n                    if (a > b) i += k + 1;\n                    else j += k + 1;\n                    if (i == j) i++;\n                    k = 0;\n                }\n            }\n            i = Math.min(i, j);\n            return s.substring(i) + s.substring(0, i);\n        } else {\n            Arrays.sort(cs);\n            return String.valueOf(cs);\n        }\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction orderlyQueue(s: string, _k: number): string {\n    if (_k == 1) {\n        let i = 0, j = 1, k = 0, n = s.length\n        while (i < n && j < n && k < n) {\n            const a = s[(i + k) % n], b = s[(j + k) % n]\n            if (a == b) k++;\n            else {\n                if (a > b) i += k + 1\n                else j += k + 1\n                if (i == j) i++\n                k = 0\n            }\n        }\n        i = Math.min(i, j)\n        return s.substring(i) + s.substring(0, i)\n    } else {\n        return [...s].sort().join('');\n    }\n};\n```\n* 时间复杂度:当 $k = 1$ 时,复杂度为 $O(n)$;当 $k > 1$ 时,复杂度为 $O(n\\log{n})$\n* 空间复杂度:当 $k > 1$ 时,需要使用额外的排序空间 $O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.899` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/901-910/901. 股票价格跨度（中等）.md", "url_title": "901. 股票价格跨度", "url": "https://leetcode.cn/problems/online-stock-span/solution/by-ac_oier-m8g7/", "difficulty": "中等", "tags": ["分块", "单调栈"], "question": "编写一个 `StockSpanner` 类,它收集某些股票的每日报价,并返回该股票当日价格的跨度。\n\n今天股票价格的跨度被定义为股票价格小于或等于今天价格的最大连续日数(从今天开始往回数,包括今天)。\n\n例如,如果未来 `7` 天股票的价格是 `[100, 80, 60, 70, 60, 75, 85]`,那么股票跨度将是 `[1, 1, 1, 2, 1, 4, 6]`。\n\n示例:\n```\n输入:[\"StockSpanner\",\"next\",\"next\",\"next\",\"next\",\"next\",\"next\",\"next\"], [[],[100],[80],[60],[70],[60],[75],[85]]\n\n输出:[null,1,1,1,2,1,4,6]\n\n解释:\n首先,初始化 S = StockSpanner(),然后:\nS.next(100) 被调用并返回 1,\nS.next(80) 被调用并返回 1,\nS.next(60) 被调用并返回 1,\nS.next(70) 被调用并返回 2,\nS.next(60) 被调用并返回 1,\nS.next(75) 被调用并返回 4,\nS.next(85) 被调用并返回 6。\n\n注意 (例如) S.next(75) 返回 4,因为截至今天的最后 4 个价格\n(包括今天的价格 75) 小于或等于今天的价格。\n```\n\n提示:\n* 调用 `StockSpanner.next(int price)` 时,将有 $1 <= price <= 10^5$。\n* 每个测试用例最多可以调用  `10000` 次 `StockSpanner.next`。\n* 在所有测试用例中,最多调用 `150000` 次 `StockSpanner.next`。\n* 此问题的总时间限制减少了 `50%`。", "solution": "### 分块\n\n又名优雅的暴力。\n\n这是一道在线问题,在调用 `next` 往数据流存入元素的同时,返回连续段不大于当前元素的数的个数。\n\n一个朴素的想法是:使用数组 `nums` 将所有 `price` 进行存储,每次返回时往前找到第一个不满足要求的位置,并返回连续段的长度。\n\n但对于 $10^4$ 的调用次数来看,该做法的复杂度为 $O(n^2)$,计算量为 $10^8$,不满足 `OJ` 要求。\n\n实际上我们可以利用「分块」思路对其进行优化,将与连续段的比较转换为与最值的比较。\n\n具体的,我们仍然使用 `nums` 对所有的 `price` 进行存储,同时使用 `region` 数组来存储每个连续段的最大值,其中 $region[loc] = x$ 含义为块编号为 `loc` 的最大值为 `x`,其中块编号 `loc` 块对应了数据编号 `idx` 的范围 $[(loc - 1) \\times len + 1, loc \\times len]$。\n\n对于 `next` 操作而言,除了直接更新数据数组 `nums[++idx] = price` 以外,我们还需要更新 `idx` 所在块的最值 `region[loc]`,然后从当前块 `loc` 开始往前扫描其余块,使用 `left` 和 `right` 代指当前处理到的块的左右端点,若当前块满足 `region[loc] <= price`,说明块内所有元素均满足要求,直接将当前块 `loc` 所包含元素个数累加到答案中,直到遇到不满足的块或达到块数组边界,若存在遇到不满足要求的块,再使用 `right` 和 `left` 统计块内满足要求 `nums[i] <= price` 的个数。\n\n对于块个数和大小的设定,是运用分块降低复杂度的关键,数的个数为 $10^4$,我们可以设定块大小为 $\\sqrt{n} = 100$,这样也限定了块的个数为 $\\sqrt{n} = 100$ 个。这样对于单次操作而言,我们最多遍历进行 $\\sqrt{n}$ 次的块间操作,同时最多进行一次块内操作,整体复杂度为 $O(\\sqrt{n})$,单次 `next` 操作计算量为 $2 \\times 10^2$ 以内,单样例计算量为 $2 \\times 10^6$,可以过。\n\n为了方便,我们令块编号 `loc` 和数据编号 `idx` 均从 $1$ 开始;同时为了防止每个样例都 `new` 大数组,我们采用 `static` 优化,并在 `StockSpanner` 的初始化中做重置工作。\n\nJava 代码:\n```Java\nclass StockSpanner {\n    static int N = 10010, len = 100, idx = 0;\n    static int[] nums = new int[N], region = new int[N / len + 10];\n    public StockSpanner() {\n        for (int i = 0; i <= getIdx(idx); i++) region[i] = 0;\n        idx = 0;\n    }\n    int getIdx(int x) {\n        return (x - 1) / len + 1;\n    }\n    int query(int price) {\n        int ans = 0, loc = getIdx(idx), left = (loc - 1) * len + 1, right = idx;\n        while (loc >= 1 && region[loc] <= price) {\n            ans += right - left + 1;\n            loc--; right = left - 1; left = (loc - 1) * len + 1;\n        }\n        for (int i = right; loc >= 1 && i >= left && nums[i] <= price; i--) ans++;\n        return ans;\n    }\n    public int next(int price) {\n        nums[++idx] = price;\n        int loc = getIdx(idx);\n        region[loc] = Math.max(region[loc], price);\n        return query(price);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nclass StockSpanner {\n    N: number = 10010; sz: number = 100; idx: number = 0\n    nums: number[] = new Array<number>(this.N).fill(0);\n    region = new Array<number>(Math.floor(this.N / this.sz) + 10).fill(0)\n    getIdx(x: number): number {\n        return Math.floor((x - 1) / this.sz) + 1\n    }\n    query(price: number): number {\n        let ans = 0, loc = this.getIdx(this.idx), left = (loc - 1) * this.sz + 1, right = this.idx\n        while (loc >= 1 && this.region[loc] <= price) {\n            ans += right - left + 1\n            loc--; right = left - 1; left = (loc - 1) * this.sz + 1\n        }\n        for (let i = right; loc >= 1 && i >= left && this.nums[i] <= price; i--) ans++\n        return ans\n    }\n    next(price: number): number {\n        this.nums[++this.idx] = price\n        const loc = this.getIdx(this.idx)\n        this.region[loc] = Math.max(this.region[loc], price)\n        return this.query(price)\n    }\n}\n```\nPython3 代码:\n```Python\nclass StockSpanner:\n    def __init__(self):\n        self.N, self.sz, self.idx = 10010, 110, 0\n        self.nums, self.region = [0] * self.N, [0] * (self.N // self.sz + 10)\n\n    def next(self, price: int) -> int:\n        def getIdx(x):\n            return (x - 1) // self.sz + 1\n\n        def query(price):\n            ans, loc = 0, getIdx(self.idx)\n            left, right = (loc - 1) * self.sz + 1, self.idx\n            while loc >= 1 and self.region[loc] <= price:\n                ans += right - left + 1\n                loc -= 1\n                right, left = left - 1, (loc - 1) * self.sz + 1\n            while loc >= 1 and right >= left and self.nums[right] <= price:\n                right, ans = right - 1, ans + 1\n            return ans\n\n        self.idx += 1\n        loc = getIdx(self.idx)\n        self.nums[self.idx] = price\n        self.region[loc] = max(self.region[loc], price)\n        return query(price)\n```\n* 时间复杂度:由于使用了 `static` 优化,`StockSpanner` 初始化时,需要对上一次使用的块进行重置,复杂度为 $O(\\sqrt{n})$;由于块大小和数量均为 $\\sqrt{n}$,`next` 操作复杂度为 $O(\\sqrt{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 单调栈 \n\n另外一个容易想到的想法是使用「单调栈」,栈内以二元组 $(idx, price)$ 形式维护比当前元素 `price` 大的元素。\n\n每次执行 `next` 操作时,从栈顶开始处理,将所有满足「不大于 `price`」的元素进行出栈,从而找到当前元素 `price` 左边最近一个比其大的位置。\n\nJava 代码:\n```Java\nclass StockSpanner {\n    Deque<int[]> d = new ArrayDeque<>();\n    int cur = 0;\n    public int next(int price) {\n        while (!d.isEmpty() && d.peekLast()[1] <= price) d.pollLast();\n        int prev = d.isEmpty() ? -1 : d.peekLast()[0], ans = cur - prev;\n        d.addLast(new int[]{cur++, price});\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nclass StockSpanner {\n    stk = new Array<Array<number>>(10010).fill([0, 0])\n    he = 0; ta = 0; cur = 0\n    next(price: number): number {\n        while (this.he < this.ta && this.stk[this.ta - 1][1] <= price) this.ta--\n        const prev = this.he >= this.ta ? -1 : this.stk[this.ta - 1][0], ans = this.cur - prev\n        this.stk[this.ta++] = [this.cur++, price]\n        return ans\n    }\n}\n```\nPython3 代码:\n```Python\nclass StockSpanner:\n    def __init__(self):\n        self.stk = []\n        self.cur = 0\n\n    def next(self, price: int) -> int:\n        while self.stk and self.stk[-1][1] <= price:\n            self.stk.pop()\n        prev = -1 if not self.stk else self.stk[-1][0]\n        ans = self.cur - prev\n        self.stk.append([self.cur, price])\n        self.cur += 1\n        return ans\n```\n* 时间复杂度:`next` 操作的均摊复杂度为 $O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.901` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/901-910/902. 最大为 N 的数字组合（困难）.md", "url_title": "902. 最大为 N 的数字组合", "url": "https://leetcode-cn.com/problems/numbers-at-most-n-given-digit-set/solution/by-ac_oier-8k27/", "difficulty": "困难", "tags": ["动态规划", "二分", "数位 DP"], "question": "给定一个按 非递减顺序 排列的数字数组 `digits`。你可以用任意次数 $digits[i]$ 来写的数字。例如,如果 $digits = [1,3,5]$,我们可以写数字,如 `'13'`, `'551'`, 和 `'1351315'`。\n\n返回 **可以生成的小于或等于给定整数** $n$ 的正整数的个数 。\n\n示例 1:\n```\n输入:digits = [\"1\",\"3\",\"5\",\"7\"], n = 100\n\n输出:20\n\n解释:\n可写出的 20 个数字是:\n1, 3, 5, 7, 11, 13, 15, 17, 31, 33, 35, 37, 51, 53, 55, 57, 71, 73, 75, 77.\n```\n示例 2:\n```\n输入:digits = [\"1\",\"4\",\"9\"], n = 1000000000\n\n输出:29523\n\n解释:\n我们可以写 3 个一位数字,9 个两位数字,27 个三位数字,\n81 个四位数字,243 个五位数字,729 个六位数字,\n2187 个七位数字,6561 个八位数字和 19683 个九位数字。\n总共,可以使用D中的数字写出 29523 个整数。\n```\n示例 3:\n```\n输入:digits = [\"7\"], n = 8\n\n输出:1\n```\n\n提示:\n* $1 <= digits.length <= 9$\n* $digits[i].length == 1$\n* $digits[i]$ 是从 `'1'` 到 `'9'` 的数\n* `digits` 中的所有值都 不同 \n* `digits` 按 非递减顺序 排列\n* $1 <= n <= 10^9$", "solution": "### 数位 DP + 二分\n\n这是一道「数位 DP」的经典运用题。\n\n由于题目给定的 `digits` 不包含 $0$,因此相当于只需要回答使用 `digits` 的数值能够覆盖 $[1, x]$ 范围内的多少个数字。\n\n起始先将字符串数组 `digits` 转为数字数组 `nums`,假定 `nums` 的长度为 $m$,然后考虑如何求得 $[1, x]$ 范围内合法数字的个数。\n\n假定我们存在函数 `int dp(int x)` 函数,能够返回区间 $[1, x]$ 内合法数的个数,那么配合「容斥原理」我们便能够回答任意区间合法数的查询:\n$$\nans_{(l, r)} = dp(r) - dp(l - 1)\n$$\n对于本题,查询区间的左端点固定为 $1$,同时 $dp(0) = 0$,因此答案为 $dp(x)$。\n\n然后考虑如何实现 `int dp(int x)` 函数,我们将组成 $[1, x]$ 的合法数分成三类:\n* 位数和 $x$ 相同,且最高位比 $x$ 最高位要小的,这部分统计为 `res1`;\n* 位数和 $x$ 相同,且最高位与 $x$ 最高位相同的,这部分统计为 `res2`;\n* 位数比 $x$ 少,这部分统计为 `res3`。\n\n其中 `res1` 和 `res3` 求解相对简单,重点落在如何求解 `res2` 上。\n\n**对 $x$ 进行「从高到低」的处理(假定 $x$ 数位为 $n$),对于第 $k$ 位而言($k$ 不为最高位),假设在 $x$ 中第 $k$ 位为 $cur$,那么为了满足「大小限制」关系,我们只能在 $[1, cur - 1]$ 范围内取数,同时为了满足「数字只能取自 `nums`」的限制,因此我们可以利用 `nums` 本身有序,对其进行二分,找到满足 `nums[mid] <= cur` 的最大下标 $r$,根据 $nums[r]$ 与 $cur$ 的关系进行分情况讨论:**\n\n* $nums[r] = cur$: 此时位置 $k$ 共有 $r$ 种选择,而后面的每个位置由于 $nums[i]$ 可以使用多次,每个位置都有 $m$ 种选择,共有 $n - p$ 个位置,因此该分支往后共有 $r * m^{n - p}$ 种合法方案。且由于 $nums[r] = cur$,往后还有分支可决策(需要统计),因此需要继续处理;\n* $nums[r] < cur$:此时算上 $nums[r]$,位置 $k$ 共有 $r + 1$ 种选择,而后面的每个位置由于 $nums[i]$ 可以使用多次,每个位置都有 $m$ 种选择,共有 $n - p$ 个位置,因此该分支共有 $(r + 1) * m^{n - p}$ 种合法方案,由于 $nums[r] < cur$,往后的方案数(均满足小于关系)已经在这次被统计完成,累加后进行 `break`;\n* $nums[r] > cur$:该分支往后不再满足「大小限制」要求,合法方案数为 $0$,直接 `break`。\n\n其他细节:实际上,我们可以将 `res1` 和 `res2` 两种情况进行合并处理。\n\n代码:\n\n```Java\nclass Solution {\n    int[] nums;\n    int dp(int x) {\n        List<Integer> list = new ArrayList<>();\n        while (x != 0) {\n            list.add(x % 10);\n            x /= 10;\n        }\n        int n = list.size(), m = nums.length, ans = 0;\n        // 位数和 x 相同\n        for (int i = n - 1, p = 1; i >= 0; i--, p++) {\n            int cur = list.get(i);\n            int l = 0, r = m - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (nums[mid] <= cur) l = mid;\n                else r = mid - 1;\n            }\n            if (nums[r] > cur) {\n                break;\n            } else if (nums[r] == cur) {\n                ans += r * (int) Math.pow(m, (n - p));\n                if (i == 0) ans++;\n            } else if (nums[r] < cur) {\n                ans += (r + 1) * (int) Math.pow(m, (n - p));\n                break;\n            }\n        }\n        // 位数比 x 少的\n        for (int i = 1, last = 1; i < n; i++) {\n            int cur = last * m;\n            ans += cur; last = cur;\n        }\n        return ans;\n    }\n    public int atMostNGivenDigitSet(String[] digits, int max) {\n        int n = digits.length;\n        nums = new int[n];\n        for (int i = 0; i < n; i++) nums[i] = Integer.parseInt(digits[i]);\n        return dp(max);\n    }\n}\n```\n* 时间复杂度:由于 `digits` 最多存在 $9$ 个元素,因此二分的复杂度可以忽略,整体复杂度为 $O(\\log{n})$\n* 空间复杂度:$O(C)$\n\n---\n\n### 总结\n\n数位 DP 的难度取决于「限制条件」的多少,而 LC 上仅有的几道数位 DP 题目限制条件都很少,且不需要引入额外的数据结构来记录状态,因此都属于数位 DP 的入门难度(LC 难度均为 Hard)。\n\n几乎所有的数位 DP 问题都可以归纳到上述的解法 :「将问题抽象为求解一个 $[0, x]$ / $[1, x]$ 范围方案数的方法」->「对方案数统计根据 位数 来分情况讨论:数位相等的情况 + 数位不等情况」->「统计数位相等的方案数时,需要按位处理,并根据限制条件做逻辑;统计数位不等的方案数时,通常要做一些预处理,然后配合乘法原理直接算得」。\n\n在还没卷到数位 DP 烂大街的现在,掌握此类求解方式单一,普遍定位为「困难」的数位 DP 类型,还是极具性价比的。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.902` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/901-910/904. 水果成篮（中等）.md", "url_title": "904. 水果成篮", "url": "https://leetcode.cn/problems/fruit-into-baskets/solution/by-ac_oier-skgk/", "difficulty": "中等", "tags": ["双指针", "模拟", "滑动窗口"], "question": "你正在探访一家农场,农场从左到右种植了一排果树。\n\n这些树用一个整数数组 `fruits` 表示,其中 `fruits[i]` 是第 `i` 棵树上的水果种类。\n\n你想要尽可能多地收集水果。然而,农场的主人设定了一些严格的规矩,你必须按照要求采摘水果:\n\n* 你只有两个篮子,并且每个篮子只能装单一类型 的水果。每个篮子能够装的水果总量没有限制。\n* 你可以选择任意一棵树开始采摘,你必须从每棵树(包括开始采摘的树)上恰好摘一个水果。采摘的水果应当符合篮子中的水果类型。每采摘一次,你将会向右移动到下一棵树,并继续采摘。\n* 一旦你走到某棵树前,但水果不符合篮子的水果类型,那么就必须停止采摘。\n\n给你一个整数数组 `fruits`,返回你可以收集的水果的最大数目。\n\n示例 1:\n```\n输入:fruits = [1,2,1]\n\n输出:3\n\n解释:可以采摘全部 3 棵树。\n```\n示例 2:\n```\n输入:fruits = [0,1,2,2]\n\n输出:3\n\n解释:可以采摘 [1,2,2] 这三棵树。\n如果从第一棵树开始采摘,则只能采摘 [0,1] 这两棵树。\n```\n示例 3:\n```\n输入:fruits = [1,2,3,2,2]\n\n输出:4\n\n解释:可以采摘 [2,3,2,2] 这四棵树。\n如果从第一棵树开始采摘,则只能采摘 [1,2] 这两棵树。\n```\n示例 4:\n```\n输入:fruits = [3,3,3,1,2,1,1,2,3,3,4]\n\n输出:5\n\n解释:可以采摘 [1,2,1,1,2] 这五棵树。\n```\n\n提示:\n* $1 <= fruits.length <= 10^5$\n* $0 <= fruits[i] < fruits.length$", "solution": "### 滑动窗口\n\n本题至少一半的难度在于理解题意。\n\n坏消息是,像此类描述不够清晰的算法题,并不在少数。\n\n好消息是,此类题目,通常都有对应的解决方案。就是如果读一遍题面,不能理解题意的时候,切勿来回阅读题面,而是从示例数据进行入手进行理解。\n\n通过对先看「示例」再阅读「题面」的理解方式,整理出基本题意:从任意位置开始,**同时使用**两个篮子采集,一旦选择后不能修改篮子所装的水果种类,当所有树处理完或遇到第一棵种类不同的树则停止。\n\n核心求解思路为滑动窗口:使用 `j` 和 `i` 分别代表滑动窗口的两端,窗口种类不超过 $2$ 种为合法。\n\nJava 代码:\n```Java\nclass Solution {\n    public int totalFruit(int[] fruits) {\n        int n = fruits.length, ans = 0;\n        int[] cnts = new int[n + 10];\n        for (int i = 0, j = 0, tot = 0; i < n; i++) {\n            if (++cnts[fruits[i]] == 1) tot++;\n            while (tot > 2) {\n                if (--cnts[fruits[j++]] == 0) tot--;\n            }\n            ans = Math.max(ans, i - j + 1);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int totalFruit(vector<int>& fruits) {\n        int n = fruits.size(), ans = 0;\n        unordered_map<int, int> cnts;\n        for (int i = 0, j = 0, tot = 0; i < n; i++) {\n            if (++cnts[fruits[i]] == 1) tot++;\n            while (tot > 2) {\n                if (--cnts[fruits[j++]] == 0) tot--;\n            }\n            ans = max(ans, i - j + 1);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def totalFruit(self, fruits: List[int]) -> int:\n        n, ans = len(fruits), 0\n        j, tot = 0, 0\n        cnts = defaultdict(int)\n        for i in range(n):\n            cnts[fruits[i]] += 1\n            if cnts[fruits[i]] == 1:\n                tot += 1\n            while tot > 2:\n                cnts[fruits[j]] -= 1\n                if cnts[fruits[j]] == 0:\n                    tot -= 1\n                j += 1\n            ans = max(ans, i - j + 1)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction totalFruit(fruits: number[]): number {\n    let n = fruits.length, ans = 0\n    const cnts = new Array<number>(n + 10).fill(0)\n    for (let i = 0, j = 0, tot = 0; i < n; i++) {\n        if (++cnts[fruits[i]] == 1) tot++\n        while (tot > 2) {\n            if (--cnts[fruits[j++]] == 0) tot--\n        }\n        ans = Math.max(ans, i - j + 1)\n    }\n    return ans\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.904` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/901-910/905. 按奇偶排序数组（简单）.md", "url_title": "905. 按奇偶排序数组", "url": "https://leetcode-cn.com/problems/sort-array-by-parity/solution/by-ac_oier-nuz7/", "difficulty": "简单", "tags": ["模拟", "双指针"], "question": "给你一个整数数组 `nums`,将 `nums` 中的的所有偶数元素移动到数组的前面,后跟所有奇数元素。\n\n返回满足此条件的 任一数组 作为答案。\n\n示例 1:\n```\n输入:nums = [3,1,2,4]\n\n输出:[2,4,3,1]\n\n解释:[4,2,3,1]、[2,4,1,3] 和 [4,2,1,3] 也会被视作正确答案。\n```\n示例 2:\n```\n输入:nums = [0]\n\n输出:[0]\n```\n\n提示:\n* $1 <= nums.length <= 5000$\n* $0 <= nums[i] <= 5000$", "solution": "### 模拟\n\n根据题意进行模拟即可:使用指针 $i$ 和 $j$ 分别代表未处理区间的左右端点,当 $nums[i]$ 不为偶数时,将 $i$ 和 $j$ 两个位置互换,原有位置 $j$ 必然是奇数(已处理好),让 $j$ 自减左移,但原有位置 $i$ 交换后不确保是偶数,需要再次检查。\n\n代码:\n```Java\nclass Solution {\n    public int[] sortArrayByParity(int[] nums) {\n        int n = nums.length;\n        for (int i = 0, j = n - 1; i < j; i++) {\n            if (nums[i] % 2 == 1) {\n                int c = nums[j];\n                nums[j--] = nums[i];\n                nums[i--] = c;\n            }\n        }\n        return nums;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.905` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/901-910/907. 子数组的最小值之和（中等）.md", "url_title": "907. 子数组的最小值之和", "url": "https://leetcode.cn/problems/sum-of-subarray-minimums/solution/by-ac_oier-w2ya/", "difficulty": "中等", "tags": ["数学", "单调栈"], "question": "给定一个整数数组 `arr`,找到 `min(b)` 的总和,其中 `b` 的范围为 `arr` 的每个(连续)子数组。\n\n由于答案可能很大,因此 返回答案模 $10^9 + 7$ 。\n\n示例 1:\n```\n输入:arr = [3,1,2,4]\n\n输出:17\n\n解释:\n子数组为 [3],[1],[2],[4],[3,1],[1,2],[2,4],[3,1,2],[1,2,4],[3,1,2,4]。 \n最小值为 3,1,2,4,1,1,2,1,1,1,和为 17。\n```\n示例 2:\n```\n输入:arr = [11,81,94,43,3]\n\n输出:444\n```\n\n提示:\n* $1 <= arr.length <= 3 \\times 10^4$\n* $1 <= arr[i] <= 3 \\times 10^4$", "solution": "### 单调栈 + 数学\n\n原问题为求所有子数组的最小值之和。\n\n统计所有子数组需要枚举左右端点,复杂度为 $O(n^2)$,对于每个子数组,我们还需要通过线性扫描的方式找到其最小值,复杂度为 $O(n)$,因此朴素解法的整体复杂度为 $O(n^3)$,题目给定数据范围为 $3 \\times 10^4$,会 `TLE`。\n\n由于我们是从子数组中取最小值来进行累加,即参与答案构成的每个数必然某个具体的 $arr[i]$。\n\n**因此我们可以将原问题转化为「考虑统计每个 $arr[i]$ 对答案的贡献」。**\n\n对于某一个 $arr[i]$ 而言,我们考虑其能够作为哪些子数组的最小值。\n\n我们可以想象以 $arr[i]$ 为中心,分别往两端进行拓展,只要新拓展的边界不会改变「$arr[i]$ 为当前子数组的最小值」的性质即可。\n\n换句话说,我们需要找到 $arr[i]$ 作为最小值的最远左右边界,即找到 $arr[i]$ 左右最近一个比其小的位置 `l` 和 `r`。\n\n**在给定序列中,找到任意 $A[i]$ 最近一个比其大/小的位置,可使用「单调栈」进行求解。**\n\n到这里,我们会自然想到,通过单调栈的方式,分别预处理除 `l` 和 `r` 数组:\n\n* `l[i] = loc` 含义为下标 `i` 左边最近一个比 `arr[i]` 小的位置是 `loc`(若在 $arr[i]$ 左侧不存在比其小的数,则 `loc = -1`)\n* `r[i] = loc` 含义为下标 `i` 右边最近一个比 `arr[i]` 小的位置是 `loc`(若在 $arr[i]$ 左侧不存在比其小的数,则 `loc = n`)\n\n当我们预处理两数组后,通过简单「乘法原理」即可统计以 $arr[i]$ 为最小值时,子数组的个数:\n\n* 包含 $arr[i]$ 的子数组左端点个数为 $a = i - l[i]$ 个\n* 包含 $arr[i]$ 的子数组右端点个数为 $b = r[i] - i$ 个\n\n子数组的个数 $\\times$ 子数组最小值 $arr[i]$,即是当前 $arr[i]$ 对答案的贡献:$a \\times b \\times arr[i]$。\n\n**统计所有 $arr[i]$ 对答案的贡献即是最终答案,但我们忽略了「当  `arr` 存在重复元素,且该元素作为子数组最小值时,最远左右端点的边界越过重复元素时,导致重复统计子数组」的问题。**\n\n我们不失一般性的举个 🌰 来理解(下图):\n\n为了消除这种重复统计,我们可以将「最远左右边界」的一端,从「严格小于」调整为「小于等于」,从而实现半开半闭的效果。\n\nJava 代码:\n```Java\nclass Solution {\n    int MOD = (int)1e9+7;\n    public int sumSubarrayMins(int[] arr) {\n        int n = arr.length, ans = 0;\n        int[] l = new int[n], r = new int[n];\n        Arrays.fill(l, -1); Arrays.fill(r, n);\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            while (!d.isEmpty() && arr[d.peekLast()] >= arr[i]) r[d.pollLast()] = i;\n            d.addLast(i);\n        }\n        d.clear();\n        for (int i = n - 1; i >= 0; i--) {\n            while (!d.isEmpty() && arr[d.peekLast()] > arr[i]) l[d.pollLast()] = i;\n            d.addLast(i);\n        }\n        for (int i = 0; i < n; i++) {\n            int a = i - l[i], b = r[i] - i;\n            ans += a * 1L * b % MOD * arr[i] % MOD;\n            ans %= MOD;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int MOD = 1e9 + 7;\n    int sumSubarrayMins(vector<int>& arr) {\n        int n = arr.size(), ans = 0;\n        vector<int> l(n, -1), r(n, n);\n        stack<int> d;\n        for (int i = 0; i < n; i++) {\n            while (!d.empty() && arr[d.top()] >= arr[i]) {\n                r[d.top()] = i;\n                d.pop();\n            }\n            d.push(i);\n        }\n        while (!d.empty()) d.pop();\n        for (int i = n - 1; i >= 0; i--) {\n            while (!d.empty() && arr[d.top()] > arr[i]) {\n                l[d.top()] = i;\n                d.pop();\n            }\n            d.push(i);\n        }\n        for (int i = 0; i < n; i++) {\n            long long a = i - l[i], b = r[i] - i;\n            ans = (ans + a * b % MOD * arr[i] % MOD) % MOD;\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def sumSubarrayMins(self, arr: List[int]) -> int:\n        n, ans = len(arr), 0\n        l, r = [-1] * n, [n] * n\n        stk = []\n        for i in range(n):\n            while stk and arr[stk[-1]] >= arr[i]:\n                r[stk.pop()] = i\n            stk.append(i)\n        stk = []\n        for i in range(n - 1, -1, -1):\n            while stk and arr[stk[-1]] > arr[i]:\n                l[stk.pop()] = i\n            stk.append(i)\n        for i in range(n):\n            a, b = i - l[i], r[i] - i\n            ans += a * b * arr[i]\n        return ans % (10 ** 9 + 7)\n```\nTypeScript 代码:\n```TypeScript\nconst MOD = 1000000007\nfunction sumSubarrayMins(arr: number[]): number {\n    let n = arr.length, ans = 0\n    const l = new Array<number>(n).fill(-1), r = new Array<number>(n).fill(n)\n    const stk = new Array<number>(n).fill(0)\n    let he = 0, ta = 0\n    for (let i = 0; i < n; i++) {\n        while (he < ta && arr[stk[ta - 1]] >= arr[i]) r[stk[--ta]] = i\n        stk[ta++] = i\n    }\n    he = ta = 0\n    for (let i = n - 1; i >= 0; i--) {\n        while (he < ta && arr[stk[ta - 1]] > arr[i]) l[stk[--ta]] = i\n        stk[ta++] = i\n    }\n    for (let i = 0; i < n; i++) {\n        const a = i - l[i], b = r[i] - i\n        ans += a * b % MOD * arr[i] % MOD\n        ans %= MOD\n    }\n    return ans\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 优化\n\n实际上,当我们从栈中弹出某个 $arr[cur]$ 时,其右边界必然是导致其弹出的 `arr[r]`(当前所遍历到的元素),而 $arr[cur]$ 若存在左边界,必然是位于 $cur$ 栈中的前一位置,即 $arr[cur]$ 弹出后的新栈顶元素(若不存在物理左边界,则左边界为 $-1$)。\n\nJava 代码:\n```Java\nclass Solution {\n    int MOD = (int)1e9+7;\n    public int sumSubarrayMins(int[] arr) {\n        int n = arr.length, ans = 0;\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int r = 0; r <= n; r++) {\n            int t = r < n ? arr[r] : 0;\n            while (!d.isEmpty() && arr[d.peekLast()] >= t) {\n                int cur = d.pollLast();\n                int l = d.isEmpty() ? -1 : d.peekLast();\n                int a = cur - l, b = r - cur;\n                ans += a * 1L * b % MOD * arr[cur] % MOD;\n                ans %= MOD;\n            }\n            d.addLast(r);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int MOD = 1e9 + 7;\n    int sumSubarrayMins(vector<int>& arr) {\n        int n = arr.size(), ans = 0;\n        deque<int> d;\n        for (int r = 0; r <= n; r++) {\n            int t = (r < n) ? arr[r] : 0;\n            while (!d.empty() && arr[d.back()] >= t) {\n                int cur = d.back();\n                d.pop_back();\n                int l = d.empty() ? -1 : d.back();\n                long long a = cur - l, b = r - cur;\n                ans = (ans + a * b % MOD * arr[cur] % MOD) % MOD;\n            }\n            d.push_back(r);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def sumSubarrayMins(self, arr: List[int]) -> int:\n        n, ans = len(arr), 0\n        stk = []\n        for r in range(n + 1):\n            t = arr[r] if r < n else 0\n            while stk and arr[stk[-1]] >= t:\n                cur = stk.pop()\n                l = stk[-1] if stk else -1\n                a, b = cur - l, r - cur\n                ans += a * b * arr[cur]\n            stk.append(r)\n        return ans % (10 ** 9 + 7)\n```\nTypeScript 代码:\n```TypeScript\nconst MOD = 1000000007\nfunction sumSubarrayMins(arr: number[]): number {\n    let n = arr.length, ans = 0\n    const stk = new Array<number>(n).fill(0)\n    let he = 0, ta = 0\n    for (let r = 0; r <= n; r++) {\n        const t = r < n ? arr[r] : 0\n        while (he < ta && arr[stk[ta - 1]] >= t) {\n            const cur = stk[--ta]\n            const l = he < ta ? stk[ta - 1] : -1\n            const a = cur - l, b = r - cur\n            ans += a * b % MOD * arr[cur] % MOD\n            ans %= MOD\n        }\n        stk[ta++] = r\n    }\n    return ans\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.907` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/901-910/908. 最小差值 I（简单）.md", "url_title": "908. 最小差值 I", "url": "https://leetcode.cn/problems/smallest-range-i/solution/by-ac_oier-7fh0/", "difficulty": "简单", "tags": ["模拟", "脑筋急转弯"], "question": "给你一个整数数组 `nums`,和一个整数 `k` 。\n\n在一个操作中,您可以选择 $0 <= i < nums.length$ 的任何索引 `i` 。将 $nums[i]$ 改为 $nums[i] + x$ ,其中 $x$ 是一个范围为 $[-k, k]$ 的整数。对于每个索引 `i` ,最多 只能 应用 一次 此操作。\n\n`nums` 的 分数 是 `nums` 中最大和最小元素的差值。 \n\n在对  `nums` 中的每个索引最多应用一次上述操作后,返回 `nums` 的最低 分数 。\n\n示例 1:\n```\n输入:nums = [1], k = 0\n\n输出:0\n\n解释:分数是 max(nums) - min(nums) = 1 - 1 = 0。\n```\n示例 2:\n```\n输入:nums = [0,10], k = 2\n\n输出:6\n\n解释:将 nums 改为 [2,8]。分数是 max(nums) - min(nums) = 8 - 2 = 6。\n```\n示例 3:\n```\n输入:nums = [1,3,6], k = 3\n\n输出:0\n\n解释:将 nums 改为 [4,4,4]。分数是 max(nums) - min(nums) = 4 - 4 = 0。\n```\n\n提示:\n* $1 <= nums.length <= 10^4$\n* $0 <= nums[i] <= 10^4$\n* $0 <= k <= 10^4$", "solution": "### 脑筋急转弯\n\n根据题意,对于任意一个数 $nums[i]$ 而言,其所能变化的范围为 $[nums[i] - k, nums[i] + k]$,我们需要最小化变化后的差值。而当 $k$ 足够大时,我们必然能够将所有数变为同一个值,此时答案为 $0$,而更一般的情况,我们能够缩减的数值距离为 $2 * k$,因此如果原来的最大差值为 $d = \\max - \\min$,若 $d <= 2 * k$ 时,答案为 $0$,否则答案为 $d - 2 * k$。\n\n代码:\n```Java\nclass Solution {\n    public int smallestRangeI(int[] nums, int k) {\n        int max = nums[0], min = nums[0];\n        for (int i : nums) {\n            max = Math.max(max, i);\n            min = Math.min(min, i);\n        }\n        return Math.max(0, max - min - 2 * k);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.908` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/901-910/909. 蛇梯棋（中等）.md", "url_title": "909. 蛇梯棋", "url": "https://leetcode-cn.com/problems/snakes-and-ladders/solution/gong-shui-san-xie-bfs-mo-ni-by-ac_oier-woh6/", "difficulty": "中等", "tags": ["图论 BFS"], "question": "给你一个大小为 `n x n` 的整数矩阵 `board` ,方格按从 $1$ 到 $n^2$ 编号,编号遵循 转行交替方式 ,从左下角开始 (即,从 `board[n - 1][0]` 开始)每一行交替方向。\n\n玩家从棋盘上的方格 $1$ (总是在最后一行、第一列)开始出发。\n\n每一回合,玩家需要从当前方格 $curr$ 开始出发,按下述要求前进:\n\n* 选定目标方格 `next`,目标方格的编号符合范围 $[curr + 1, min(curr + 6, n^2)]$。\n* 该选择模拟了掷 六面体骰子 的情景,无论棋盘大小如何,玩家最多只能有 $6$ 个目的地。\n* 传送玩家:如果目标方格 `next` 处存在蛇或梯子,那么玩家会传送到蛇或梯子的目的地。否则,玩家传送到目标方格 `next`。 \n* 当玩家到达编号 $n^2$ 的方格时,游戏结束。\n\n`r` 行 `c` 列的棋盘,按前述方法编号,棋盘格中可能存在 “蛇” 或 “梯子”;\n\n如果 `board[r][c] != -1`,那个蛇或梯子的目的地将会是 `board[r][c]`。\n\n编号为 $1$ 和 $n^2$ 的方格上没有蛇或梯子。\n\n注意,玩家在每回合的前进过程中最多只能爬过蛇或梯子一次:就算目的地是另一条蛇或梯子的起点,玩家也 不能 继续移动。\n\n* 举个例子,假设棋盘是 $[[-1,4],[-1,3]]$ ,第一次移动,玩家的目标方格是 $2$ 。那么这个玩家将会顺着梯子到达方格 $3$ ,但 不能 顺着方格 $3$ 上的梯子前往方格 $4$ 。\n\n返回达到编号为 $n^2$ 的方格所需的最少移动次数,如果不可能,则返回 $-1$。\n\n示例 1:\n\n```\n输入:board = \n[\n[-1,-1,-1,-1,-1,-1],\n[-1,-1,-1,-1,-1,-1],\n[-1,-1,-1,-1,-1,-1],\n[-1,35,-1,-1,13,-1],\n[-1,-1,-1,-1,-1,-1],\n[-1,15,-1,-1,-1,-1]\n]\n\n输出:4\n\n解释:\n首先,从方格 1 [第 5 行,第 0 列] 开始。 \n先决定移动到方格 2 ,并必须爬过梯子移动到到方格 15 。\n然后决定移动到方格 17 [第 3 行,第 4 列],必须爬过蛇到方格 13 。\n接着决定移动到方格 14 ,且必须通过梯子移动到方格 35 。 \n最后决定移动到方格 36 , 游戏结束。 \n可以证明需要至少 4 次移动才能到达最后一个方格,所以答案是 4 。 \n```\n\n提示:\n* $n == board.length == board[i].length$\n* $2 <= n <= 20$\n* $grid[i][j]$ 的值是 $-1$ 或在范围 $[1, n^2]$ 内\n* 编号为 $1$ 和 $n^2$ 的方格上没有蛇或梯子", "solution": "### BFS\n\n最多有 $20 * 20$ 个格子,直接使用常规的单向 `BFS` 进行求解即可。\n\n为了方便我们可以按照题目给定的意思,将二维的矩阵「扁平化」为一维的矩阵,然后再按照规则进行 `BFS`。\n\n代码:\n```Java\nclass Solution {\n    int n;\n    int[] nums;\n    public int snakesAndLadders(int[][] board) {\n        n = board.length;\n        if (board[0][0] != -1) return -1;\n        nums = new int[n * n + 1];\n        boolean isRight = true;\n        for (int i = n - 1, idx = 1; i >= 0; i--) {\n            for (int j = (isRight ? 0 : n - 1); isRight ? j < n : j >= 0; j += isRight ? 1 : -1) {\n                nums[idx++] = board[i][j];\n            }\n            isRight = !isRight;\n        }\n        int ans = bfs();\n        return ans;\n    }\n    int bfs() {\n        Deque<Integer> d = new ArrayDeque<>();\n        Map<Integer, Integer> m = new HashMap<>();\n        d.addLast(1);\n        m.put(1, 0);\n        while (!d.isEmpty()) {\n            int poll = d.pollFirst();\n            int step = m.get(poll);\n            if (poll == n * n) return step;\n            for (int i = 1; i <= 6; i++) {\n                int np = poll + i;\n                if (np <= 0 || np > n * n) continue;\n                if (nums[np] != -1) np = nums[np];\n                if (m.containsKey(np)) continue;\n                m.put(np, step + 1);\n                d.addLast(np);\n            }\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.909` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/91-100/91. 解码方法（中等）.md", "url_title": "91. 解码方法", "url": "https://leetcode-cn.com/problems/decode-ways/solution/gong-shui-san-xie-gen-ju-shu-ju-fan-wei-ug3dd/", "difficulty": "中等", "tags": ["线性 DP"], "question": "一条包含字母 A-Z 的消息通过以下映射进行了 编码 :\n```\n'A' -> 1\n'B' -> 2\n...\n'Z' -> 26\n```\n要 解码 已编码的消息,所有数字必须基于上述映射的方法,反向映射回字母(可能有多种方法)。例如,\"11106\" 可以映射为:\n\n* \"AAJF\" ,将消息分组为 (1 1 10 6)\n* \"KJF\" ,将消息分组为 (11 10 6)\n\n注意,消息不能分组为  (1 11 06) ,因为 \"06\" 不能映射为 \"F\" ,这是由于 \"6\" 和 \"06\" 在映射中并不等价。\n\n给你一个只含数字的 非空 字符串 s ,请计算并返回 解码 方法的 总数 。\n\n题目数据保证答案肯定是一个 32 位 的整数。\n\n示例 1:\n```\n输入:s = \"12\"\n\n输出:2\n\n解释:它可以解码为 \"AB\"(1 2)或者 \"L\"(12)。\n```\n示例 2:\n```\n输入:s = \"226\"\n\n输出:3\n\n解释:它可以解码为 \"BZ\" (2 26), \"VF\" (22 6), 或者 \"BBF\" (2 2 6) 。\n```\n示例 3:\n```\n输入:s = \"0\"\n\n输出:0\n\n解释:没有字符映射到以 0 开头的数字。\n含有 0 的有效映射是 'J' -> \"10\" 和 'T'-> \"20\" 。\n由于没有字符,因此没有有效的方法对此进行解码,因为所有数字都需要映射。\n```\n示例 4:\n```\n输入:s = \"06\"\n\n输出:0\n\n解释:\"06\" 不能映射到 \"F\" ,因为字符串含有前导 0(\"6\" 和 \"06\" 在映射中并不等价)。\n```\n\n提示:\n* 1 <= s.length <= 100\n* s 只包含数字,并且可能包含前导零。", "solution": "### 基本分析\n\n我们称一个解码内容为一个 `item`。\n\n为根据题意,每个 `item` 可以由一个数字组成,也可以由两个数字组成。\n\n数据范围为 100,很具有迷惑性,可能会有不少同学会想使用 DFS 进行爆搜。\n\n我们可以大致分析一下这样的做法是否可行:不失一般性的考虑字符串 `s` 中的任意位置 `i`,位置 `i` 既可以作为一个独立 `item`,也可以与上一位置组成新 `item`,那么相当于每个位置都有两种分割选择(先不考虑分割结果的合法性问题),这样做法的复杂度是 $O(2^n)$ 的,当 `n` 范围是 100 时,远超我们计算机单秒运算量($10^7$)。即使我们将「判断分割结果是否合法」的操作放到爆搜过程中做剪枝,也与我们的单秒最大运算量相差很远。\n\n递归的方法不可行,我们需要考虑递推的解法。\n\n---\n\n### 动态规划\n\n**这其实是一道字符串类的动态规划题,不难发现对于字符串 `s` 的某个位置 `i` 而言,我们只关心「位置 `i` 自己能否形成独立 `item` 」和「位置 `i` 能够与上一位置(`i-1`)能否形成 `item`」,而不关心 `i-1` 之前的位置。**\n\n有了以上分析,我们可以从前往后处理字符串 `s`,使用一个数组记录以字符串 `s` 的每一位作为结尾的解码方案数。即定义 $f[i]$ 为考虑前 $i$ 个字符的解码方案数。\n\n对于字符串 `s` 的任意位置 `i` 而言,其存在三种情况:\n\n* 只能由位置 `i` 的单独作为一个 `item`,设为 `a`,转移的前提是 `a` 的数值范围为 $[1,9]$,转移逻辑为 $f[i] = f[i - 1]$。\n* 只能由位置 `i` 的与前一位置(`i-1`)共同作为一个 `item`,设为 `b`,转移的前提是 `b` 的数值范围为 $[10,26]$,转移逻辑为 $f[i] = f[i - 2]$。\n* 位置 `i` 既能作为独立 `item` 也能与上一位置形成 `item`,转移逻辑为 $f[i] = f[i - 1] + f[i - 2]$。\n\n因此,我们有如下转移方程:\n\n$$\n\\begin{cases}\n  \nf[i] = f[i - 1], 1 \\leqslant a \\leq 9 \\\\\n\nf[i] = f[i - 2], 10 \\leqslant b \\leqslant 26 \\\\\n\nf[i] = f[i - 1] + f[i - 2], 1 \\leqslant a \\leq 9, 10 \\leqslant b \\leqslant 26 \\\\\n\n\\end{cases}\n$$\n\n其他细节:由于题目存在前导零,而前导零属于无效 `item`。可以进行特判,但个人习惯往字符串头部追加空格作为哨兵,追加空格既可以避免讨论前导零,也能使下标从 1 开始,简化 `f[i-1]` 等负数下标的判断。\n\n代码:\n```Java\nclass Solution {\n    public int numDecodings(String s) {\n        int n = s.length();\n        s = \" \" + s;\n        char[] cs = s.toCharArray();\n        int[] f = new int[n + 1];\n        f[0] = 1;\n        for (int i = 1; i <= n; i++) { \n            // a : 代表「当前位置」单独形成 item\n            // b : 代表「当前位置」与「前一位置」共同形成 item\n            int a = cs[i] - '0', b = (cs[i - 1] - '0') * 10 + (cs[i] - '0');\n            // 如果 a 属于有效值,那么 f[i] 可以由 f[i - 1] 转移过来\n            if (1 <= a && a <= 9) f[i] = f[i - 1];\n            // 如果 b 属于有效值,那么 f[i] 可以由 f[i - 2] 或者 f[i - 1] & f[i - 2] 转移过来\n            if (10 <= b && b <= 26) f[i] += f[i - 2];\n        }\n        return f[n];\n    }\n}\n```\n* 时间复杂度:共有 `n` 个状态需要被转移。复杂度为 $O(n)$。\n* 空间复杂度:$O(n)$。\n\n---\n\n### 空间优化\n\n不难发现,我们转移 `f[i]` 时只依赖 `f[i-1]` 和 `f[i-2]` 两个状态。\n\n因此我们可以采用与「滚动数组」类似的思路,只创建长度为 3 的数组,通过取余的方式来复用不再需要的下标。\n\n代码:\n```Java\nclass Solution {\n    public int numDecodings(String s) {\n        int n = s.length();\n        s = \" \" + s;\n        char[] cs = s.toCharArray();\n        int[] f = new int[3];\n        f[0] = 1;\n        for (int i = 1; i <= n; i++) {\n            f[i % 3] = 0;\n            int a = cs[i] - '0', b = (cs[i - 1] - '0') * 10 + (cs[i] - '0');\n            if (1 <= a && a <= 9) f[i % 3] = f[(i - 1) % 3];\n            if (10 <= b && b <= 26) f[i % 3] += f[(i - 2) % 3];\n        }\n        return f[n % 3];\n    }\n}\n```\n* 时间复杂度:共有 `n` 个状态需要被转移。复杂度为 $O(n)$。\n* 空间复杂度:$O(1)$。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.91` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/91-100/92. 反转链表 II（中等）.md", "url_title": "92. 反转链表 II", "url": "https://leetcode-cn.com/problems/reverse-linked-list-ii/solution/yi-ge-neng-ying-yong-suo-you-lian-biao-t-vjx6/", "difficulty": "中等", "tags": ["链表"], "question": "给你单链表的头指针 head 和两个整数 left 和 right ,其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点,返回 反转后的链表 。\n\n示例 1:\n\n```\n输入:head = [1,2,3,4,5], left = 2, right = 4\n输出:[1,4,3,2,5]\n```\n示例 2:\n```\n输入:head = [5], left = 1, right = 1\n输出:[5]\n```\n\n提示:\n* 链表中节点数目为 n\n* 1 <= n <= 500\n* -500 <= Node.val <= 500\n* 1 <= left <= right <= n", "solution": "### 朴素解法\n\n为了减少边界判断,我们可以建立一个虚拟头结点 dummy,使其指向 head,最终返回 dummy.next。\n\n这种「哨兵」技巧能应用在所有的「链表」题目。\n\n黄色部分的节点代表需要「翻转」的部分:\n\n之后就是常规的模拟,步骤我写在示意图里啦 ~ \n\n代码:\n\n```java []\nclass Solution {\n    public ListNode reverseBetween(ListNode head, int l, int r) {\n        ListNode dummy = new ListNode(0);\n        dummy.next = head;\n\n        r -= l;\n        ListNode hh = dummy;\n        while (l-- > 1) hh = hh.next;\n\n        ListNode a = hh.next, b = a.next;\n        while (r-- > 0) {\n            ListNode tmp = b.next;\n            b.next = a;\n            a = b;\n            b = tmp;\n        }\n        \n        hh.next.next = b;\n        hh.next = a;\n        return dummy.next;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.92` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/91-100/93. 复原 IP 地址（中等）.md", "url_title": "93. 复原 IP 地址", "url": "https://leetcode.cn/problems/restore-ip-addresses/solutions/2519711/gong-shui-san-xie-hui-su-suan-fa-yun-yon-khnj/", "difficulty": "中等", "tags": ["回溯算法", "DFS"], "question": "有效 `IP` 地址 正好由四个整数(每个整数位于 `0` 到 `255` 之间组成,且不能含有前导 `0`),整数之间用 `'.'` 分隔。\n\n例如:`\"0.1.2.201\"` 和 `\"192.168.1.1\"` 是 有效 `IP` 地址,但是 `\"0.011.255.245\"`、`\"192.168.1.312\"` 和 `\"192.168@1.1\"` 是 无效 `IP` 地址。\n\n给定一个只包含数字的字符串 `s` ,用以表示一个 `IP` 地址,返回所有可能的有效 `IP` 地址,这些地址可以通过在 `s` 中插入 `'.'` 来形成。你 不能 重新排序或删除 `s` 中的任何数字。你可以按 任何 顺序返回答案。\n\n示例 1:\n```\n输入:s = \"25525511135\"\n\n输出:[\"255.255.11.135\",\"255.255.111.35\"]\n```\n示例 2:\n```\n输入:s = \"0000\"\n\n输出:[\"0.0.0.0\"]\n```\n示例 3:\n```\n输入:s = \"101023\"\n\n输出:[\"1.0.10.23\",\"1.0.102.3\",\"10.1.0.23\",\"10.10.2.3\",\"101.0.2.3\"]\n```\n\n提示:\n* $1 <= s.length <= 20$\n* `s` 仅由数字组成", "solution": "### 回溯算法\n\n和 [131. 分割回文串](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487047&idx=1&sn=117c48f20778868442fce44e100d2ea8) 一样,同样是一道求所有方案的题目,只能是没有太多优化的「爆搜」做法。\n\n设计递归函数 `void dfs(int idx, int n, List<Integer> cur)`,其中 `idx` 代表当前处理字符串 `s` 的哪个位置,`n` 代表字符串 `s` 总长度,而 `cur` 的则是代表子串 $s[0 ... (idx - 1)]$ 部分的具体划分方案。\n\n用题目样例 `s = \"25525511135\"` 作为 🌰,`n` 固定为 `11`。\n\n当 `idx = 3` 时,`cur` 为 $s[0...2] = 255$,`cur` 部分的划分方案可能是 `[2,5,5]`、`[2,55]`、`[25,5]`、`[255]` 之一。\n\n在 `cur` 的基础上,我们继续爆搜剩余部分,即递归执行 `dfs(idx, n, cur)`,算法会将剩余部分的划分方案添加到 `cur` 上,我们只需要确保每次追加到 `cur` 的数值符合要求即可(没有前导零 且 范围在 $[0, 255]$ 中)。\n\n在单次回溯过程中,我们可以将 `idx` 作为当前划分数字的左端点,通过枚举的形式找到右端点 `j`,并将当前数字 $s[idx ... (j - 1)]$ 加到 `cur` 中(若合法),回溯到底后再添加到 `cur` 的元素进行移除。\n\n当 `idx = n` 代表整个 `s` 已经处理完成,若此时 `cur` 恰好有 $4$ 个元素,说明我们找到了一组合法方案,将其拼接成字符串追加到答案数组中。\n\n同时也是由于划分过程中 `cur` 最多只有 $4$ 个元素,我们可以用此做简单剪枝。\n\nJava 代码:\n```Java\nclass Solution {\n    List<String> ans = new ArrayList<>();\n    char[] cs;\n    public List<String> restoreIpAddresses(String s) {\n        cs = s.toCharArray();\n        dfs(0, cs.length, new ArrayList<>());\n        return ans;\n    }\n    void dfs(int idx, int n, List<Integer> cur) {\n        if (cur.size() > 4) return ;\n        if (idx == n) {\n            if (cur.size() == 4) {\n                StringBuilder sb = new StringBuilder();\n                for (int i = 0; i < 4; i++) sb.append(cur.get(i)).append(\".\");\n                ans.add(sb.substring(0, sb.length() - 1));\n            }\n        } else {\n            for (int i = idx; i < n; i++) {\n                int t = 0;\n                for (int j = idx; j <= i; j++) t = t * 10 + (cs[j] - '0');\n                if (cs[idx] == '0' && i != idx) break;\n                if (t > 255) break;\n                cur.add(t);\n                dfs(i + 1, n, cur);\n                cur.remove(cur.size() - 1);\n            }\n        }\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<string> ans;\n    string s;\n    void dfs(int idx, int n, vector<int>& cur) {\n        if (cur.size() > 4) return ;\n        if (idx == n) {\n            if (cur.size() == 4) {\n                string sb;\n                for (int i = 0; i < 4; i++) sb += to_string(cur[i]) + \".\";\n                ans.push_back(sb.substr(0, sb.length() - 1));\n            }\n        } else {\n            for (int i = idx; i < n; i++) {\n                int t = 0;\n                for (int j = idx; j <= i; j++) t = t * 10 + (s[j] - '0');\n                if (s[idx] == '0' && i != idx) break;\n                if (t > 255) break;\n                cur.push_back(t);\n                dfs(i + 1, n, cur);\n                cur.pop_back();\n            }\n        }\n    }\n    vector<string> restoreIpAddresses(string _s) {\n        s = _s;\n        vector<int> cur;\n        dfs(0, s.length(), cur);\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def restoreIpAddresses(self, s: str) -> List[str]:\n        ans = []\n        def dfs(idx, n, cur):\n            if len(cur) > 4:\n                return \n            if idx == n:\n                if len(cur) == 4:\n                    ans.append('.'.join(cur))\n            else:\n                for i in range(idx, n):\n                    t = 0\n                    for j in range(idx, i + 1):\n                        t = t * 10 + (ord(s[j]) - ord('0'))\n                    if s[idx] == '0' and i != idx:\n                        break\n                    if t > 255:\n                        break\n                    cur.append(str(t))\n                    dfs(i + 1, n, cur)\n                    cur.pop()\n        dfs(0, len(s), [])\n        return ans\n```\nTypeScript 代码:\n```TypeScript \nfunction restoreIpAddresses(s: string): string[] {\n    const ans = new Array<string>()\n    function dfs(idx: number, n: number, cur: Array<number>): void {\n        if (cur.length > 4) return \n        if (idx == n) {\n            if (cur.length == 4) {\n                let str = ''\n                for (let i = 0; i < 4; i++) str += cur[i] + \".\"\n                ans.push(str.substring(0, str.length - 1))\n            }\n        } else {\n            for (let i = idx; i < n; i++) {\n                let t = 0\n                for (let j = idx; j <= i; j++) t = t * 10 + (s.charCodeAt(j) - '0'.charCodeAt(0))\n                if (s[idx] == '0' && i != idx) break\n                if (t > 255) break\n                cur.push(t)\n                dfs(i + 1, n, cur)\n                cur.pop()\n            }\n        }\n    }\n    dfs(0, s.length, new Array<number>())\n    return ans\n}\n```\n* 时间复杂度:爆搜不讨论时空复杂度\n* 空间复杂度:爆搜不讨论时空复杂度", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.93` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/91-100/95. 不同的二叉搜索树 II（中等）.md", "url_title": "95. 不同的二叉搜索树 II", "url": "https://leetcode.cn/problems/unique-binary-search-trees-ii/solutions/2438263/gong-shui-san-xie-chang-gui-er-cha-shu-b-h4sw/", "difficulty": "中等", "tags": ["树", "二叉搜索树", "BST", "DFS", "递归", "爆搜"], "question": "给你一个整数 `n`,请你生成并返回所有由 `n` 个节点组成且节点值从 `1` 到 `n` 互不相同的不同 二叉搜索树 。\n\n可以按 任意顺序 返回答案。\n\n示例 1:\n\n```\n输入:n = 3\n\n输出:[[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]\n```\n示例 2:\n```\n输入:n = 1\n\n输出:[[1]]\n```\n\n提示:\n* $1 <= n <= 8$", "solution": "### 回溯算法\n\n题目要我们求所有所能构造的二叉搜索树的具体方案,而给定 $n$ 个节点所能构成的二叉搜索树的个数为 [卡特兰数](https://baike.baidu.com/item/%E5%8D%A1%E7%89%B9%E5%85%B0%E6%95%B0)。\n\n其他方案数同为卡特兰数的还包括:凸多边形三角划分、`n` 对括号正确匹配数目 ... \n\n回到本题,根据二叉搜索搜索的特性,若某个子树的根节点为 `root`,那么 `root` 的左子树任意节点值均比 `root.val` 要小,`root` 的右子树任意节点值均比 `root.val` 要大。\n\n因此,假设我们使用 $[l, r]$ 连续段来构造二叉搜索树,并且选择了节点 `t` 作为二叉搜索树的根节点时:\n\n* 那么使用 $[l, t - 1]$ 构造出来的二叉搜索树均可作为根节点 $t$ 的左子树\n* 使用 $[t + 1, r]$ 构造出来的二叉搜索树均可作为根节点 $t$ 的右子树\n\n也就是说,我们可以设计递归函数 `List<TreeNode> dfs(int l, int r)`,含义为使用连续段 $[l, r]$ 进行二叉搜索树构造,并返回相应集合。\n\n最终答案为 `dfs(1,n)`,起始我们可以枚举 $[1, n]$ 范围内的的每个数 `t` 作为根节点,并递归 `dfs(l,t-1)` 和 `dfs(t+1,r)` 获取左右子树的集合 `left` 和 `right`。\n\n结合「乘法原理」,枚举任意左子树和任意右子树,即可得到 `t` 作为根节点的二叉搜索树方案集,枚举所有 `t` 后即可得到所有二叉搜索树的总集。\n\n> 注意:当我们运用乘法原理,来构造以 `t` 为根节点的二叉搜索树时,其 `left` 或 `right` 某一边可能为空集,但此时我们仍要将非空的一边子树进行挂载。\n为了确保两层新循环的逻辑会被执行,对于空集我们不能使用 `null` 来代指,而要使用 `[null]` 来代指。\n\nJava 代码:\n```Java \nclass Solution {\n    public List<TreeNode> generateTrees(int n) {\n        return dfs(1, n);\n    }\n    List<TreeNode> dfs(int l, int r) {\n        if (l > r) return new ArrayList<>(){{add(null);}};\n        List<TreeNode> ans = new ArrayList<>();\n        for (int i = l; i <= r; i++) {\n            for (TreeNode x : dfs(l, i - 1)) {\n                for (TreeNode y : dfs(i + 1, r)) {\n                    TreeNode root = new TreeNode(i);\n                    root.left = x; root.right = y;\n                    ans.add(root);\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<TreeNode*> generateTrees(int n) {\n        return dfs(1, n);\n    }\n    vector<TreeNode*> dfs(int l, int r) {\n        if (l > r) return vector<TreeNode*>{NULL};\n        vector<TreeNode*> ans;\n        for (int i = l; i <= r; i++) {\n            for (TreeNode* x : dfs(l, i - 1)) {\n                for (TreeNode* y : dfs(i + 1, r)) {\n                    // 创建当前节点并添加到结果列表中\n                    TreeNode* root = new TreeNode(i);\n                    root->left = x;\n                    root->right = y;\n                    ans.push_back(root);\n                }\n            }\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def generateTrees(self, n: int) -> List[Optional[TreeNode]]:\n        def dfs(l, r):\n            if l > r:\n                return [None]\n            ans = []\n            for i in range(l, r + 1):\n                for x in dfs(l, i - 1):\n                    for y in dfs(i + 1, r):\n                        root = TreeNode(i)\n                        root.left, root.right = x, y\n                        ans.append(root)\n            return ans\n        return dfs(1, n)\n```\nTypeScript 代码:\n```TypeScript\nfunction generateTrees(n: number): Array<TreeNode | null> {\n    function dfs(l: number, r: number): Array<TreeNode | null> {\n        if (l > r) return [null]\n        const ans = new Array<TreeNode>()\n        for (let i = l; i <= r; i++) {\n            for (const x of dfs(l, i - 1)) {\n                for (const y of dfs(i + 1, r)) {\n                    const root = new TreeNode(i)\n                    root.left = x; root.right = y\n                    ans.push(root)\n                }\n            }\n        }\n        return ans\n    }\n    return dfs(1, n)\n}\n```\n* 时间复杂度:卡特兰数\n* 空间复杂度:卡特兰数", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.95` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/91-100/96. 不同的二叉搜索树（中等）.md", "url_title": "96. 不同的二叉搜索树", "url": "https://leetcode.cn/problems/unique-binary-search-trees/solutions/2438266/gong-shui-san-xie-cong-qu-jian-dp-dao-qi-fz5z/", "difficulty": "中等", "tags": ["树", "二叉搜索树", "动态规划", "区间 DP", "数学", "卡特兰数"], "question": "给你一个整数 `n` ,求恰由 `n` 个节点组成且节点值从 `1` 到 `n` 互不相同的 二叉搜索树 有多少种?\n\n返回满足题意的二叉搜索树的种数。\n\n示例 1:\n\n```\n输入:n = 3\n\n输出:5\n```\n示例 2:\n```\n输入:n = 1\n\n输出:1\n```\n\n提示:\n* $1 <= n <= 19$", "solution": "### 区间 DP\n\n沿用 [95. 不同的二叉搜索树 II](https://www.acoier.com/2022/12/09/95.%20%E4%B8%8D%E5%90%8C%E7%9A%84%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%20II%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/) 的基本思路,只不过本题不是求具体方案,而是求个数。\n\n除了能用 [95. 不同的二叉搜索树 II](https://www.acoier.com/2022/12/09/95.%20%E4%B8%8D%E5%90%8C%E7%9A%84%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%20II%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/) 提到的「卡特兰数」直接求解 $n$ 个节点的以外,本题还能通过常规「区间 DP」的方式进行求解。\n\n> 求数量使用 DP,求所有具体方案使用爆搜,是极其常见的一题多问搭配。\n\n**定义 $f[l][r]$ 为使用数值范围在 $[l, r]$ 之间的节点,所能构建的 `BST` 个数**。\n\n不失一般性考虑 $f[l][r]$ 该如何求解,仍用 $[l, r]$ 中的根节点 `i` 为何值,作为切入点进行思考。\n\n根据「`BST` 定义」及「乘法原理」可知:$[l, i - 1]$ 相关节点构成的 `BST`  子树只能在 `i` 的左边,而 $[i + 1, r]$ 相关节点构成的 `BST`  子树只能在 `i` 的右边。所有的左右子树相互独立,因此以 `i` 为根节点的 `BST` 数量为 $f[l][i - 1] \\times f[i + 1][r]$,而 `i` 共有 $r - l + 1$ 个取值($i \\in [l, r]$)。\n\n即有:\n$$\nf[l][r] = \\sum_{i = l}^{r} (f[l][i - 1] \\times f[i + 1][r])\n$$\n不难发现,求解区间 $[l, r]$ 的 `BST`  数量 $f[l][r]$ 依赖于比其小的区间 $[l, i - 1]$ 和 $[i + 1, r]$,这引导我们使用「区间 DP」的方式进行递推。\n\n> 不了解区间 DP 的同学,可看 [前置 🧀](https://mp.weixin.qq.com/s/RuIKpDEuxkhhKiTeVRMXng)\n\n一些细节:由于我们 `i` 的取值可能会取到区间中的最值 `l` 和 `r`,为了能够该情况下,$f[l][i - 1]$ 和 $f[i + 1][r]$ 能够顺利参与转移,起始我们需要先对所有满足 $i >= j$ 的 $f[i][j]$ 初始化为 `1`。\n\nJava 代码:\n```Java\nclass Solution {\n    public int numTrees(int n) {\n        int[][] f = new int[n + 10][n + 10];\n        for (int i = 0; i <= n + 1; i++) {\n            for (int j = 0; j <= n + 1; j++) {\n                if (i >= j) f[i][j] = 1;\n            }\n        }\n        for (int len = 2; len <= n; len++) {\n            for (int l = 1; l + len - 1 <= n; l++) {\n                int r = l + len - 1;\n                for (int i = l; i <= r; i++) {\n                    f[l][r] += f[l][i - 1] * f[i + 1][r];\n                }\n            }\n        }\n        return f[1][n];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int numTrees(int n) {\n        vector<vector<int>> f(n + 2, vector<int>(n + 2, 0));\n        for (int i = 0; i <= n + 1; i++) {\n            for (int j = 0; j <= n + 1; j++) {\n                if (i >= j) f[i][j] = 1;\n            }\n        }\n        for (int len = 2; len <= n; len++) {\n            for (int l = 1; l + len - 1 <= n; l++) {\n                int r = l + len - 1;\n                for (int i = l; i <= r; i++) {\n                    f[l][r] += f[l][i - 1] * f[i + 1][r];\n                }\n            }\n        }\n        return f[1][n];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution(object):\n    def numTrees(self, n):\n        f = [[0] * (n + 2) for _ in range(n + 2)]\n        for i in range(n + 2):\n            for j in range(n + 2):\n                if i >= j:\n                    f[i][j] = 1\n        for length in range(2, n + 1):\n            for l in range(1, n - length + 2):\n                r = l + length - 1\n                for i in range(l, r + 1):\n                    f[l][r] += f[l][i - 1] * f[i + 1][r]\n        return f[1][n]\n```\nTypeScript 代码:\n```TypeScript\nfunction numTrees(n: number): number {\n    const f = new Array(n + 2).fill(0).map(() => new Array(n + 2).fill(0));\n    for (let i = 0; i <= n + 1; i++) {\n        for (let j = 0; j <= n + 1; j++) {\n            if (i >= j) f[i][j] = 1;\n        }\n    }\n    for (let len = 2; len <= n; len++) {\n        for (let l = 1; l + len - 1 <= n; l++) {\n            const r = l + len - 1;\n            for (let i = l; i <= r; i++) {\n                f[l][r] += f[l][i - 1] * f[i + 1][r];\n            }\n        }\n    }\n    return f[1][n];\n};\n```\n* 时间复杂度:$O(n^3)$\n* 空间复杂度:$O(n^2)$\n\n---\n\n### 区间 DP(优化)\n\n求解完使用 $[1, n]$ 共 $n$ 个连续数所能构成的 `BST`  个数后,再来思考一个问题:使用 $[L, R]$ 共 $n = R - L + 1$ 个连续数,所能构成的 `BST`  个数又是多少。\n\n答案是一样的。\n\n**由 $n$ 个连续数构成的 `BST`  个数仅与数值个数有关系,与数值大小本身并无关系**。\n\n由于可知,我们上述的「区间 DP」必然进行了大量重复计算,例如 $f[1][3]$ 和 $f[2][4]$ 同为大小为 $3$ 的区间,却被计算了两次。\n\n调整我们的状态定义:**定义 $f[k]$ 为考虑连续数个数为 $k$ 时,所能构成的 `BST`  的个数**。\n\n不失一般性考虑 $f[i]$ 如何计算,仍用 $[1, i]$ 中哪个数值作为根节点进行考虑。假设使用数值 $j$ 作为根节点,则有 $f[j - 1] \\times f[i - j]$ 个 `BST` 可贡献到 $f[i]$,而 $j$ 共有 $i$ 个取值($j \\in [1, i]$)。\n\n即有:\n$$\nf[i] = \\sum_{j = 1}^{i}(f[j - 1] \\times f[i - j])\n$$\n\n同时有初始化 $f[0] = 1$,含义为没有任何连续数时,只有“空树”一种合法方案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int numTrees(int n) {\n        int[] f = new int[n + 10];\n        f[0] = 1;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= i; j++) {\n                f[i] += f[j - 1] * f[i - j];\n            }\n        }\n        return f[n];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int numTrees(int n) {\n        vector<int> f(n + 10, 0);\n        f[0] = 1;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= i; j++) {\n                f[i] += f[j - 1] * f[i - j];\n            }\n        }\n        return f[n];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def numTrees(self, n: int) -> int:\n        f = [0] * (n + 10)\n        f[0] = 1\n        for i in range(1, n + 1):\n            for j in range(1, i + 1):\n                f[i] += f[j - 1] * f[i - j]\n        return f[n]\n```\nTypeScript 代码:\n```TypeScript\nfunction numTrees(n: number): number {\n    const f = new Array(n + 10).fill(0);\n    f[0] = 1;\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= i; j++) {\n            f[i] += f[j - 1] * f[i - j];\n        }\n    }\n    return f[n];\n};\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 数学 - 卡特兰数\n\n在「区间 DP(优化)」中的递推过程,正是“卡特兰数”的 $O(n^2)$ 递推过程。通过对常规「区间 DP」的优化,我们得证 [95. 不同的二叉搜索树 II](https://www.acoier.com/2022/12/09/95.%20%E4%B8%8D%E5%90%8C%E7%9A%84%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%20II%EF%BC%88%E4%B8%AD%E7%AD%89%EF%BC%89/) 中「给定 $n$ 个节点所能构成的 `BST`  的个数为卡特兰数」这一结论。\n\n对于精确求卡特兰数,存在时间复杂度为 $O(n)$ 的通项公式做法,公式为 $C_{n+1} = \\frac{C_n \\cdot (4n + 2)}{n + 2}$。\n\nJava 代码:\n\n```Java\nclass Solution {\n    public int numTrees(int n) {\n        if (n <= 1) return 1;\n        long ans = 1;\n        for (int i = 0; i < n; i++) ans = ans * (4 * i + 2) / (i + 2);\n        return (int)ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int numTrees(int n) {\n        if (n <= 1) return 1;\n        long long ans = 1;\n        for (int i = 0; i < n; i++) ans = ans * (4 * i + 2) / (i + 2);\n        return (int)ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def numTrees(self, n: int) -> int:\n        if n <= 1:\n            return 1\n        ans = 1\n        for i in range(n):\n            ans = ans * (4 * i + 2) // (i + 2)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction numTrees(n: number): number {\n    if (n <= 1) return 1;\n    let ans = 1;\n    for (let i = 0; i < n; i++) ans = ans * (4 * i + 2) / (i + 2);\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.96` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/91-100/97. 交错字符串（中等）.md", "url_title": "97. 交错字符串", "url": "https://leetcode.cn/problems/interleaving-string/solution/gong-shui-san-xie-yi-ti-shuang-jie-ji-yi-51da/", "difficulty": "中等", "tags": ["线性 DP", "记忆化搜索"], "question": "给定三个字符串 `s1`、`s2`、`s3`,请你帮忙验证 `s3` 是否是由 `s1` 和 `s2` 交错 组成的。\n\n两个字符串 `s` 和 `t` **交错** 的定义与过程如下,其中每个字符串都会被分割成若干 **非空** 子字符串:\n\n* `s = s1 + s2 + ... + sn`\n* `t = t1 + t2 + ... + tm`\n* `|n - m| <= 1`\n\n交错是 `s1 + t1 + s2 + t2 + s3 + t3 + ...` 或者 `t1 + s1 + t2 + s2 + t3 + s3 + ...`\n\n注意:`a + b` 意味着字符串 `a` 和 `b` 连接。\n\n示例 1:\n\n```\n输入:s1 = \"aabcc\", s2 = \"dbbca\", s3 = \"aadbbcbcac\"\n\n输出:true\n```\n示例 2:\n```\n输入:s1 = \"aabcc\", s2 = \"dbbca\", s3 = \"aadbbbaccc\"\n\n输出:false\n```\n示例 3:\n```\n输入:s1 = \"\", s2 = \"\", s3 = \"\"\n\n输出:true\n```\n\n提示:\n* $0 <= s1.length, s2.length <= 100$\n* $0 <= s3.length <= 200$\n* `s1`、`s2`、和 `s3` 都由小写英文字母组成\n\n进阶:您能否仅使用 $O(s2.length)$ 额外的内存空间来解决它?", "solution": "### 记忆化搜索\n\n数据范围相比于「暴搜」而言有点大,但将「暴搜」解法作为前置思考,总能为我们带来灵感。\n\n将 `s1`、`s2` 和 `s3` 的长度分别记为 $n$、$m$ 和 $l$。\n\n一个显然的情况是若 $n + m$ 不为 $l$,必然不能用 `s1` 和 `s2` 来凑成 `s3`,返回 `false`。\n\n定义暴搜函数为 `boolean dfs(int i, int j)`,代表当前处理到 `s1` 的第 $i$ 个字符,`s2` 的第 $j$ 个字符,能否凑成 `s3` 的前 $i + j$ 个字符。\n\n最终答案为 `dfs(0, 0)`。\n\n根据 $s1[i]$、$s2[j]$ 和 $s3[i + j]$ 的关系分情况讨论:\n\n* $s1[i] = s3[i + j]$,可使用 $s1[i]$ 充当 $s3[i + j]$ ,暴搜 $s1[i]$ 已被使用的情况,决策下一位 `dfs(i + 1, j)`\n* $s2[j] = s3[i + j]$,可使用 $s2[j]$ 充当 $s3[i + j]$ ,暴搜 $s2[j]$ 已被使用的情况,决策下一位`dfs(i, j + 1)`\n\n当 $i + j = l$ 时,代表我们成功用 `s1` 和 `s2` 凑成了 `s3`,返回 `true`;而若在任一回合出现 $s1[i] \\neq s3[i + j]$ 且 $s2[j] \\neq s3[i + j]$,说明构造无法进行,返回 `false`。\n\n`TLE` Java 代码:\n\n```Java\nclass Solution {\n    char[] cs1, cs2, cs3;\n    int n, m, l;\n    public boolean isInterleave(String s1, String s2, String s3) {\n        cs1 = s1.toCharArray(); cs2 = s2.toCharArray(); cs3 = s3.toCharArray();\n        n = s1.length(); m = s2.length(); l = s3.length();\n        if (n + m != l) return false;\n        return dfs(0, 0);\n    }\n    boolean dfs(int i, int j) {\n        if (i + j == l) return true;\n        boolean ans = false;\n        if (i < n && cs1[i] == cs3[i + j]) ans |= dfs(i + 1, j);\n        if (j < m && cs2[j] == cs3[i + j]) ans |= dfs(i, j + 1);\n        return ans;\n    }\n}\n```\n\n可分析上述 `TLE`  做法的时间复杂度上界为交错序列个数。\n\n长度分别为 $n$ 和 $m$ 形成的交错序列数量为 $C(n+m, n) = \\frac{(n+m)!}{n! \\times m!}$ : 从 $n + m$ 个位置中选 $n$ 个位置按顺序放置 `s1`,剩下的 $m$ 个位置唯一确定的放置 `s2`。\n\n实际上,不同交错序列之间有着相同的前缀(例如 `s1 = aac` 和 `s2 = bbd`,具体交错方案中的 `aabbcd` 和 `aabbdc` 之间有着相同的前缀 `aabb__`),可通过「记忆化搜索」来进行减少这些重复的构造。\n\n直接根据 `dfs` 函数的入参构建缓存器 `cache`,起始 `cache[i][j] = 0`;若 `cache[i][j] = 1` 代表 `true`;`cache[i][j] = -1` 代表 `false`。\n\n如此简单的改动,即可将朴素的 `DFS`  改成记忆化搜索。\n\nJava 代码:\n```Java\nclass Solution {\n    char[] cs1, cs2, cs3;\n    int n, m, l;\n    int[][] cache;\n    public boolean isInterleave(String s1, String s2, String s3) {\n        cs1 = s1.toCharArray(); cs2 = s2.toCharArray(); cs3 = s3.toCharArray();\n        n = s1.length(); m = s2.length(); l = s3.length();\n        if (n + m != l) return false;\n        cache = new int[n + 10][m + 10];\n        return dfs(0, 0);\n    }\n    boolean dfs(int i, int j) {\n        if (cache[i][j] != 0) return cache[i][j] == 1;\n        if (i + j == l) return true;\n        boolean ans = false;\n        if (i < n && cs1[i] == cs3[i + j]) ans |= dfs(i + 1, j);\n        if (j < m && cs2[j] == cs3[i + j]) ans |= dfs(i, j + 1);\n        cache[i][j] = ans ? 1 : -1;\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool isInterleave(string s1, string s2, string s3) {\n        int n = s1.length(), m = s2.length(), l = s3.length();\n        if (n + m != l) return false;\n        vector<vector<int>> cache(n + 10, vector<int>(m + 10, 0));\n        function<bool(int, int)> dfs = [&](int i, int j) {\n            if (cache[i][j] != 0) return cache[i][j] == 1;\n            if (i + j == l) return true;\n            bool ans = false;\n            if (i < n && s1[i] == s3[i + j]) ans |= dfs(i + 1, j);\n            if (j < m && s2[j] == s3[i + j]) ans |= dfs(i, j + 1);\n            cache[i][j] = ans ? 1 : -1;\n            return ans;\n        };\n        return dfs(0, 0);\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def isInterleave(self, s1: str, s2: str, s3: str) -> bool:\n        n, m, l = len(s1), len(s2), len(s3)\n        if n + m != l:\n            return False\n        @lru_cache\n        def dfs(i, j):\n            if i + j == l:\n                return True\n            ans = False\n            if i < n and s1[i] == s3[i + j]:\n                ans |= dfs(i + 1, j)\n            if j < m and s2[j] == s3[i + j]:\n                ans |= dfs(i, j + 1)\n            return ans\n        return dfs(0, 0)\n```\nTypeScript 代码:\n```TypeScript\nfunction isInterleave(s1: string, s2: string, s3: string): boolean {\n    const n = s1.length, m = s2.length, l = s3.length;\n    if (n + m !== l) return false;\n    const cache = new Array(n + 10).fill(0).map(() => new Array(m + 10).fill(0));\n    const dfs = (i: number, j: number): boolean => {\n        if (cache[i][j] !== 0) return cache[i][j] === 1;\n        if (i + j === l) return true;\n        let ans = false;\n        if (i < n && s1[i] === s3[i + j]) ans ||= dfs(i + 1, j);\n        if (j < m && s2[j] === s3[i + j]) ans ||= dfs(i, j + 1);\n        cache[i][j] = ans ? 1 : -1;\n        return ans;\n    };\n    return dfs(0, 0);\n};\n```\n* 时间复杂度:共有 $n \\times m$ 个状态,复杂度为 $O(n \\times m)$\n* 空间复杂度:$O(n \\times m)$\n\n---\n\n### 线性 DP\n\n直接将「记忆化搜索」中的缓存器修改为我们的动态规划状态定义。\n\n**定义 $f[i][j]$ 为使用 `s1` 的前 $i$ 个字符,使用 `s2` 的前 $j$ 个字符,能否凑出 `s3` 的前 $i + j$ 个字符**。\n\n为了方便,我们令所有字符串的下标均从 $1$ 开始。\n\n不失一般性,考虑 $f[i][j]$ 如何转移,根据 $s1[i]$、$s2[j]$ 和 $s3[i+j]$ 是否相等进行分析,即**根据当前 `s3` 的最后一个字符 $s3[i + j]$ 由 $s1[i]$ 和 $s2[j]$ 谁来提供进行讨论**:\n\n* $s1[i] = s3[i + j]$:说明当前 `s3` 的最后一个字符 $s3[i + j]$ 可由 $s1[i]$ 提供,而 `s3` 此前的 $i + j - 1$ 个字符,可由 `s1` 的前  $i - 1$ 字符和 `s2` 的前 $j$ 个字符共同提供。此时若 $f[i - 1][j]$ 为真,则有 $f[i][j]$ 为真。\n* $s2[j] = s3[i+j]$:说明当前 `s3` 的最后一个字符串 $s3[i+j]$ 可由 $s2[j]$ 提供,而 `s3` 此前的 $i + j - 1$ 个字符,可由 `s1` 的前  $i$ 字符和 `s2` 的前 $j - 1$ 个字符共同提供。此时若 $f[i][j - 1]$ 为真,则有 $f[i][j]$ 为真。\n\n综上,只有上述条件任一成立,$f[i][j]$ 即为真。\n\n一些细节:为了在转移过程中减少边界处理,我们先预处理出 $f[0][X]$ 和 $f[X][0]$ 的状态值(即 `s1`、`s2` 和 `s3` 之间的公共前缀)。\n\nJava 代码:\n\n```Java\nclass Solution {\n    public boolean isInterleave(String s1, String s2, String s3) {\n        char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray(), cs3 = s3.toCharArray();\n        int n = s1.length(), m = s2.length(), l = s3.length();\n        if (n + m != l) return false;\n        boolean[][] f = new boolean[n + 10][m + 10];\n        f[0][0] = true;\n        for (int i = 1; i <= n && f[i - 1][0]; i++) f[i][0] = cs1[i - 1] == cs3[i - 1];\n        for (int i = 1; i <= m && f[0][i - 1]; i++) f[0][i] = cs2[i - 1] == cs3[i - 1];\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                if (cs1[i - 1] == cs3[i + j - 1]) f[i][j] |= f[i - 1][j];\n                if (cs2[j - 1] == cs3[i + j - 1]) f[i][j] |= f[i][j - 1];\n            }\n        }\n        return f[n][m];\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def isInterleave(self, s1: str, s2: str, s3: str) -> bool:\n        n, m, l = len(s1), len(s2), len(s3)\n        if n + m != l:\n            return False\n        f = [[False] * (m + 10) for _ in range(n + 10)]\n        f[0][0] = True\n        for i in range(1, n + 1):\n            f[i][0] = f[i - 1][0] and s1[i - 1] == s3[i - 1]\n        for i in range(1, m + 1):\n            f[0][i] = f[0][i - 1] and s2[i - 1] == s3[i - 1]\n        for i in range(1, n + 1):\n            for j in range(1, m + 1):\n                if s1[i - 1] == s3[i + j - 1]:\n                    f[i][j] |= f[i - 1][j]\n                if s2[j - 1] == s3[i + j - 1]:\n                    f[i][j] |= f[i][j - 1]\n        return f[n][m]\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool isInterleave(string s1, string s2, string s3) {\n        int n = s1.length(), m = s2.length(), l = s3.length();\n        if (n + m != l) return false;\n        vector<vector<bool>> f(n + 10, vector<bool>(m + 10, false));\n        f[0][0] = true;\n        for (int i = 1; i <= n && f[i - 1][0]; i++) f[i][0] = (s1[i - 1] == s3[i - 1]);\n        for (int i = 1; i <= m && f[0][i - 1]; i++) f[0][i] = (s2[i - 1] == s3[i - 1]);\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                if (s1[i - 1] == s3[i + j - 1]) f[i][j] = f[i][j] | f[i - 1][j];\n                if (s2[j - 1] == s3[i + j - 1]) f[i][j] = f[i][j] | f[i][j - 1];\n            }\n        }\n        return f[n][m];\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nfunction isInterleave(s1: string, s2: string, s3: string): boolean {\n    const n = s1.length, m = s2.length, l = s3.length;\n    if (n + m !== l) return false;\n    const f = new Array(n + 10).fill(false).map(() => new Array(m + 10).fill(false));\n    f[0][0] = true;\n    for (let i = 1; i <= n && f[i - 1][0]; i++) f[i][0] = s1[i - 1] === s3[i - 1];\n    for (let i = 1; i <= m && f[0][i - 1]; i++) f[0][i] = s2[i - 1] === s3[i - 1];\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= m; j++) {\n            if (s1[i - 1] === s3[i + j - 1]) f[i][j] ||= f[i - 1][j];\n            if (s2[j - 1] === s3[i + j - 1]) f[i][j] ||= f[i][j - 1];\n        }\n    }\n    return f[n][m];\n};\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n \\times m)$\n\n---\n\n### 进阶\n\n根据状态转移方程可知 $f[i][j]$ 仅依赖于 $f[i - 1][j]$ 和 $f[i][j - 1]$,因此可通过「滚动数组」的方式进行优化。\n\n状态定义不变,将动规数组开成 $f[2][m + 10]$ 大小(另外一维的 `+10` 操作仅为个人习惯)。\n\n随后,当我们需要更新 `f[i][X]` 时,需要写成 `f[i & 1][X]`;需要访问 `f[i - 1][X]` 时,则写成 `f[(i - 1) & 1][X]` 即可。\n\n最后,同样是为了转移过程中减少边界处理,我们需要使用两个变量 `a` 和 `b` 记住 `s1` 和 `s2` 与 `s3` 的公共前缀,并特判掉 `s1` 或 `s2` 为空的情况。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean isInterleave(String s1, String s2, String s3) {\n        char[] cs1 = s1.toCharArray(), cs2 = s2.toCharArray(), cs3 = s3.toCharArray();\n        int n = s1.length(), m = s2.length(), l = s3.length();\n        if (n + m != l) return false;\n        int a = 0, b = 0;\n        while (a < n && cs1[a] == cs3[a]) a++;\n        while (b < m && cs2[b] == cs3[b]) b++;\n        if (m == 0) return n <= a;\n        if (n == 0) return m <= b;\n        boolean[][] f = new boolean[2][m + 10];\n        f[0][0] = true;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                boolean cur = false;\n                if (cs1[i - 1] == cs3[i + j - 1]) {\n                    if (i == 1) cur |= j <= b;\n                    else cur |= f[(i - 1) & 1][j];\n                }\n                if (cs2[j - 1] == cs3[i + j - 1]) {\n                    if (j == 1) cur |= i <= a;\n                    else cur |= f[i & 1][j - 1];\n                }\n                f[i & 1][j] = cur;\n            }\n        }\n        return f[n & 1][m];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool isInterleave(string s1, string s2, string s3) {\n        int n = s1.length(), m = s2.length(), l = s3.length();\n        if (n + m != l) return false;\n        int a = 0, b = 0;\n        while (a < n && s1[a] == s3[a]) a++;\n        while (b < m && s2[b] == s3[b]) b++;\n        if (n == 0) return m <= b;\n        if (m == 0) return n <= a;\n        vector<vector<bool>> f(2, vector<bool>(m + 1, false));\n        f[0][0] = true;\n        for (int i = 1; i <= n; i++) {\n            for (int j = 1; j <= m; j++) {\n                bool cur = false;\n                if (s1[i - 1] == s3[i + j - 1]) {\n                    if (i == 1) cur |= j <= b;    \n                    else cur |= f[(i - 1) & 1][j];\n                }\n                if (s2[j - 1] == s3[i + j - 1]) {\n                    if (j == 1) cur |= i <= a;\n                    else cur |= f[i & 1][j - 1]; \n                }\n                f[i & 1][j] = cur;\n            }\n        }\n        return f[n & 1][m];\n    }\n};\n```\nPython 代码:\n```Python \nclass Solution:\n    def isInterleave(self, s1: str, s2: str, s3: str) -> bool:\n        n, m, l = len(s1), len(s2), len(s3)\n        if n + m != l:\n            return False\n        a, b = 0, 0\n        while a < n and s1[a] == s3[a]:\n            a += 1\n        while b < m and s2[b] == s3[b]:\n            b += 1\n        if m == 0:\n            return n <= a\n        if n == 0:\n            return m <= b\n        f = [[False for _ in range(m + 1)] for _ in range(2)]\n        f[0][0] = True\n        for i in range(1, n+1):\n            for j in range(1, m+1):\n                cur = False\n                if s1[i - 1] == s3[i + j - 1]:\n                    if i == 1:\n                        cur |= j <= b\n                    else:\n                        cur |= f[(i - 1) & 1][j]\n                if s2[j - 1] == s3[i + j - 1]:\n                    if j == 1:\n                        cur |= i <= a\n                    else:\n                        cur |= f[i & 1][j - 1]\n                f[i & 1][j] = cur\n        return f[n & 1][m]\n```\nTypeScript 代码:\n```TypeScript\nfunction isInterleave(s1: string, s2: string, s3: string): boolean {\n    const n = s1.length, m = s2.length, l = s3.length;\n    if (n + m !== l) return false;\n    let a = 0, b = 0;\n    while (a < n && s1[a] === s3[a]) a++;\n    while (b < m && s2[b] === s3[b]) b++;\n    if (m == 0) return n <= a;\n    if (n == 0) return m <= b;\n    const f = new Array(2).fill(null).map(() => new Array(m + 1).fill(false));\n    f[0][0] = true;\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= m; j++) {\n            let cur = false;\n            if (s1[i - 1] === s3[i + j - 1]) {\n                if (i === 1) cur ||= j <= b;    \n                else cur ||= f[(i - 1) & 1][j];\n            }\n            if (s2[j - 1] === s3[i + j - 1]) {\n                if (j === 1) cur ||= i <= a;    \n                else cur ||= f[i & 1][j - 1];\n            }\n            f[i & 1][j] = cur;\n        }\n    }\n    return f[n & 1][m];\n};\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.97` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/91-100/99. 恢复二叉搜索树（中等）.md", "url_title": "99. 恢复二叉搜索树", "url": "https://leetcode.cn/problems/recover-binary-search-tree/solutions/2431878/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-4po4/", "difficulty": "中等", "tags": ["二叉树", "树的搜索", "递归", "迭代", "中序遍历", "Morris 遍历"], "question": "给你二叉搜索树的根节点 `root`,该树中的 恰好 两个节点的值被错误地交换。\n\n请在不改变其结构的情况下,恢复这棵树 。\n\n示例 1:\n\n```\n输入:root = [1,3,null,null,2]\n\n输出:[3,1,null,null,2]\n\n解释:3 不能是 1 的左孩子,因为 3 > 1 。交换 1 和 3 使二叉搜索树有效。\n```\n示例 2:\n\n```\n输入:root = [3,1,4,null,null,2]\n\n输出:[2,1,4,null,null,3]\n\n解释:2 不能在 3 的右子树中,因为 2 < 3 。交换 2 和 3 使二叉搜索树有效。\n```\n\n提示:\n* 树上节点的数目在范围 $[2, 1000]$ 内\n* $-2^{31} <= Node.val <= 2^{31} - 1$\n\n进阶:使用 $O(n)$ 空间复杂度的解法很容易实现。你能想出一个只使用 $O(1)$ 空间的解决方案吗?", "solution": "### 基本分析\n\n首先,别想复杂了。\n\n所谓的恢复二叉树(两节点互换),只需要将两节点的 `val` 进行互换即可,而不需要对节点本身进行互换。\n\n---\n\n### 中序遍历 - 递归 & 迭代\n\n二叉搜索树,其中序遍历是有序的。\n\n要找到哪两个节点被互换,可通过比对中序遍历序列来实现。\n\n但将整个中序遍历序列保存下来,再检测序列有序性的做法,复杂度是 $O(n)$ 的(不要说题目要求的 $O(1)$,连 $O(h)$ 都达不到)。\n\n所以第一步,**这个「递归 & 迭代」的次优解,我们先考虑如何做到 $O(h)$ 的空间复杂度,即在中序遍历过程中找到互换节点**。\n\n其实也很简单,除了使用 `a` 和 `b` 来记录互换节点,额外使用变量 `last` 来记录当前遍历过程中的前一节点即可:\n\n若存在前一节点 `last` 存在,而且满足前一节点值大于当前节点(`last.val > root.val`),违反“有序性”,根据是否为首次出现该情况分情况讨论:\n\n* 若是首次满足条件,即 `a == null`,此时上一节点 `last` 必然是两个互换节点之一,而当前 `root` 只能说是待定,因为有可能是 `last` 和 `root` 实现互换,也有可能是 `last` 和后续的某个节点实现互换。\n\n  此时有 `a = last, b = root`\n\n* 若是非首次满足条件,即 `a != null`,此时当前节点 `root` 必然是两个互换节点中的另外一个。\n\n  此时有 `b = root`\n\n综上:如果整个中序遍历的序列中“逆序对”为一对,那么互换节点为该“逆序对”的两个成员;若“逆序对”数量为两对,则互换节点为「第一对“逆序对”的首个节点」和「第二对“逆序对”的第二个节点」。\n\nJava 代码(递归):\n\n```Java\nclass Solution {\n    TreeNode a = null, b = null, last = null;\n    public void recoverTree(TreeNode root) {\n        dfs(root);\n        int val = a.val;\n        a.val = b.val;\n        b.val = val;\n    }\n    void dfs(TreeNode root) {\n        if (root == null) return ;\n        dfs(root.left);\n        if (last != null && last.val > root.val) {\n            if (a == null) {\n                a = last; b = root;\n            } else {\n                b = root;\n            }\n        }\n        last = root;\n        dfs(root.right);\n    }\n}\n```\nJava 代码(迭代):\n```Java\nclass Solution {\n    public void recoverTree(TreeNode root) {\n        Deque<TreeNode> d = new ArrayDeque<>();\n        TreeNode a = null, b = null, last = null;\n        while (root != null || !d.isEmpty()) {\n            while (root != null) {\n                d.addLast(root);\n                root = root.left;\n            }\n            root = d.pollLast();\n            if (last != null && last.val > root.val) {\n                if (a == null) {\n                    a = last; b = root;\n                } else {\n                    b = root;\n                }\n            }\n            last = root;\n            root = root.right;\n        }\n        int val = a.val;\n        a.val = b.val;\n        b.val = val;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(h)$,其中 $h$ 为树高\n\n---\n\n### 中序遍历 - Morris 遍历\n\nMorris 遍历也就是经常说到的“神级遍历”,其本质是通过做大常数来降低空间复杂度。\n\n还是以二叉树的中序遍历为例,无论是递归或是迭代,为了在遍历完左节点(也可以是左子树)时,仍能回到父节点,我们需要使用数据结构栈,只不过在递归做法中是用函数调用充当栈,而在迭代做法则是显式栈。\n\n**这使得空间复杂度为 $O(h)$,而 Morris 遍历的核心则是利用“路径底部节点”中的空闲指针进行线索。**\n\n举个 🌰,对于一棵最简单的二叉树:\n\n在中序遍历过程中,如果选择递归或迭代方式,并且不使用栈的情况,当遍历完左子节点(或左子树的最后一个节点)后,将会面临无法返回根节点的问题。\n\n在 Morris 遍历中,从根节点开始,尚未真正遍历左子节点之前,就会先建立「左子节点(或左子树的最后一个节点)」与「当前根节点」之间的链接,从而避免使用栈。\n\n具体的,Morris 遍历的中序遍历遵循如下流程(喜欢的话可以背过):\n\n1. 令根节点为当前节点\n\n2. 只要当前节点不为空(`while (root != null) `),重复执行如下流程:\n\n   * 若当前节点的左子节点为空(`root.left = null`),将当前节点更新为其右子节点(`root = root.right`)\n\n   * 若当前节点的左子节点不为空,利用临时变量 `t` 存储,找到当前节点的前驱节点(左子树中最后一个节点):\n     * 若前驱节点的右子节点为空(`t.right = null`),将前驱节点的右子节点链接到当前节点(`t.right = root`),并将当前节点更新为左子节点(`root = root.left`)\n     * 若前驱节点的右子节点不为空,说明已链接到当前节点,此时将前驱节点的右子节点置空(删除链接 `t.right = null`),遍历当前节点,并将当前节点更新为右子节点(`root = root.right`)\n\nJava 代码:\n```Java\nclass Solution {\n    public void recoverTree(TreeNode root) {\n        TreeNode a = null, b = null, last = null;\n        while (root != null) {\n            if (root.left == null) {\n                if (last != null && last.val > root.val) {\n                    if (a == null) {\n                        a = last; b = root;\n                    } else {\n                        b = root;\n                    }\n                }\n                last = root;\n                root = root.right;\n            } else {\n                TreeNode t = root.left;\n                while (t.right != null && t.right != root) t = t.right;\n                if (t.right == null) { // 若前驱节点右子树为空, 说明是真正遍历左子树前, 建立与当前根节点的链接, 然后开始真正遍历左子树\n                    t.right = root;\n                    root = root.left;\n                } else {  // 若已存在链接, 说明是第二次访问根节点, 左子树(前驱节点)已遍历完, 此时应该解开链接, 遍历当前节点以及右子树\n                    t.right = null;\n                    if (last != null && last.val > root.val) {\n                        if (a == null) {\n                            a = last; b = root;\n                        } else {\n                            b = root;\n                        }\n                    }\n                    last = root;\n                    root = root.right;\n                }\n            }\n        }\n        int val = a.val;\n        a.val = b.val;\n        b.val = val;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    void recoverTree(TreeNode* root) {\n        TreeNode *a = nullptr, *b = nullptr, *last = nullptr;\n        while (root != nullptr) {\n            if (root->left == nullptr) {\n                if (last != nullptr && last->val > root->val) {\n                    if (a == nullptr) {\n                        a = last; b = root;\n                    } else {\n                        b = root;\n                    }\n                }\n                last = root;\n                root = root->right;\n            } else {\n                TreeNode *t = root->left;\n                while (t->right != nullptr && t->right != root) t = t->right;\n                if (t->right == nullptr) {\n                    t->right = root;\n                    root = root->left;\n                } else {\n                    t->right = nullptr;\n                    if (last != nullptr && last->val > root->val) {\n                        if (a == nullptr) {\n                            a = last, b = root;\n                        } else {\n                            b = root;\n                        }\n                    }\n                    last = root;\n                    root = root->right;\n                }\n            }\n        }\n        swap(a->val, b->val);\n    }\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.99` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/911-920/911. 在线选举（中等）.md", "url_title": "911. 在线选举", "url": "https://leetcode-cn.com/problems/online-election/solution/gong-shui-san-xie-er-fen-yun-yong-ti-by-5y3hi/", "difficulty": "中等", "tags": ["二分"], "question": "给你两个整数数组 $persons$ 和 $times$ 。\n\n在选举中,第 $i$ 张票是在时刻为 $times[i]$ 时投给候选人 $persons[i]$ 的。\n\n对于发生在时刻 $t$ 的每个查询,需要找出在 t 时刻在选举中领先的候选人的编号。\n\n在 $t$ 时刻投出的选票也将被计入我们的查询之中。在平局的情况下,最近获得投票的候选人将会获胜。\n\n实现 TopVotedCandidate 类:\n* `TopVotedCandidate(int[] persons, int[] times)` 使用 $persons$ 和 $times$ 数组初始化对象。\n* `int q(int t)` 根据前面描述的规则,返回在时刻 $t$ 在选举中领先的候选人的编号。\n\n示例:\n```\n输入:\n[\"TopVotedCandidate\", \"q\", \"q\", \"q\", \"q\", \"q\", \"q\"]\n[[[0, 1, 1, 0, 0, 1, 0], [0, 5, 10, 15, 20, 25, 30]], [3], [12], [25], [15], [24], [8]]\n\n输出:\n[null, 0, 1, 1, 0, 0, 1]\n\n解释:\nTopVotedCandidate topVotedCandidate = new TopVotedCandidate([0, 1, 1, 0, 0, 1, 0], [0, 5, 10, 15, 20, 25, 30]);\ntopVotedCandidate.q(3); // 返回 0 ,在时刻 3 ,票数分布为 [0] ,编号为 0 的候选人领先。\ntopVotedCandidate.q(12); // 返回 1 ,在时刻 12 ,票数分布为 [0,1,1] ,编号为 1 的候选人领先。\ntopVotedCandidate.q(25); // 返回 1 ,在时刻 25 ,票数分布为 [0,1,1,0,0,1] ,编号为 1 的候选人领先。(在平局的情况下,1 是最近获得投票的候选人)。\ntopVotedCandidate.q(15); // 返回 0\ntopVotedCandidate.q(24); // 返回 0\ntopVotedCandidate.q(8); // 返回 1\n```\n\n提示:\n* $1 <= persons.length <= 5000$\n* $times.length == persons.length$\n* $0 <= persons[i] < persons.length$\n* $0 <= times[i] <= 10^9$\n* $times$ 是一个严格递增的有序数组\n* $times[0] <= t <= 10^9$\n* 每个测试用例最多调用 $10^4$ 次 `q`", "solution": "### 二分\n\n根据题意,我们会在 $times[i]$ 时刻为 $persons[i]$ 候选人增加一票。\n\n**利用 $times$ 数组严格递增,我们可以在处理 $times$ 时(模拟加票过程),使用一个变量 $val$ 来维护当前得票的最大数量,使用 $list$ 来记录不同时刻点的候选人交替情况。**\n\n起始时 $val = 0$,当出现票数大于等于 $val$ 时,我们往 $list$ 追加二元组记录 $list[idx] = (times[i], persons[i])$,并更新 $val$。\n\n**每个 $list[idx]$ 代表了当前候选人 $list[idx][1]$ 的首次当选时刻为 $list[idx][0]$。**\n\n举个 🌰,若 $i = list[idx][0], j = list[idx + 1][0]$,则意味着在时间段 $[i, j)$ 内当选的候选人为 $list[idx][1]$。\n\n在查询时,我们只需要通过「二分」找到 $list$ 中满足 $list[i][0] <= t$ 的分割点 $r$(最大下标),取 $list[r][1]$ 即是答案。\n\n代码:\n```Java\nclass TopVotedCandidate {\n    List<int[]> list = new ArrayList<>();\n    public TopVotedCandidate(int[] persons, int[] times) {\n        int val = 0;\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = 0; i < times.length; i++) {\n            map.put(persons[i], map.getOrDefault(persons[i], 0) + 1);\n            if (map.get(persons[i]) >= val) {\n                val = map.get(persons[i]);\n                list.add(new int[]{times[i], persons[i]});\n            }\n        }\n    }\n    public int q(int t) {\n        int l = 0, r = list.size() - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (list.get(mid)[0] <= t) l = mid;\n            else r = mid - 1;\n        }\n        return list.get(r)[0] <= t ? list.get(r)[1] : 0;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为数组长度,$m$ 为查询次数(调用 `q` 的次数)。预处理出 $list$ 的复杂度为 $O(n)$;最坏情况下,每个 $time[i]$ 时刻都会交替产生新的候选人编号,即最坏情况下 $list$ 的数组长度为 $n$,总的查询复杂度为 $O(m * \\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.911` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/911-920/913. 猫和老鼠（困难）.md", "url_title": "913. 猫和老鼠", "url": "https://leetcode-cn.com/problems/cat-and-mouse/solution/gong-shui-san-xie-dong-tai-gui-hua-yun-y-0bx1/", "difficulty": "困难", "tags": ["动态规划", "记忆化搜索"], "question": "两位玩家分别扮演猫和老鼠,在一张**无向**图上进行游戏,两人轮流行动。\n\n图的形式是:`graph[a]` 是一个列表,由满足 `ab` 是图中的一条边的所有节点 `b` 组成。\n\n老鼠从节点 `1` 开始,第一个出发;猫从节点 `2` 开始,第二个出发。在节点 `0` 处有一个洞。\n\n在每个玩家的行动中,他们 必须 沿着图中与所在当前位置连通的一条边移动。\n\n例如,如果老鼠在节点 `1` ,那么它必须移动到 `graph[1]` 中的任一节点。\n\n此外,猫无法移动到洞中(节点 `0`)。\n\n然后,游戏在出现以下三种情形之一时结束:\n\n如果猫和老鼠出现在同一个节点,猫获胜。\n如果老鼠到达洞中,老鼠获胜。\n如果某一位置重复出现(即,玩家的位置和移动顺序都与上一次行动相同),游戏平局。\n给你一张图 `graph`,并假设两位玩家都都以最佳状态参与游戏:\n* 如果老鼠获胜,则返回 `1`;\n* 如果猫获胜,则返回 `2`;\n* 如果平局,则返回 `0` 。\n\n示例 1:\n\n```\n输入:graph = [[2,5],[3],[0,4,5],[1,4,5],[2,3],[0,2,3]]\n\n输出:0\n```\n示例 2:\n\n```\n输入:graph = [[1,3],[0],[3],[0,2]]\n\n输出:1\n```\n\n提示:\n* 3 <= graph.length <= 50\n* 1 <= graph[i].length < graph.length\n* 0 <= graph[i][j] < graph.length\n* graph[i][j] != i\n* graph[i] 互不相同\n* 猫和老鼠在游戏中总是移动", "solution": "### 动态规划\n\n数据范围只有 $50$,使得本题的难度大大降低。\n\n**定义 $f[k][i][j]$ 为当前进行了 $k$ 步,老鼠所在位置为 $i$,猫所在的位置为 $j$ 时,最终的获胜情况($0$ 为平局,$1$ 和 $2$ 分别代表老鼠和猫获胜),起始我们让所有的 $f[k][i][j] = -1$(为无效值),最终答案为 $f[0][1][2]$。**\n\n不失一般性的考虑 $f[i][j][k]$ 该如何转移,根据题意,将当前所在位置 $i$ 和 $j$ 结合「游戏结束,判定游戏」的规则来分情况讨论:\n\n* 若 $i = 0$,说明老鼠位于洞中,老鼠获胜,此时有 $f[k][i][j] = 1$;\n* 若 $i = j$,说明两者为与同一位置,猫获胜,此时有 $f[k][i][j] = 2$;\n* 考虑如何定义平局,即 $f[k][i][j] = 0$ 的情况?\n\n我们最多有 $n$ 个位置,因此 $(i, j)$ 位置对组合数最多为 $n^2$ 种,然后 $k$ 其实代表的是老鼠先手还是猫先手,共有 $2$ 种可能,因此状态数量数据有明确上界为 $2 * n^2$。\n\n所以我们可以设定 $k$ 的上界为 $2 * n^2$(抽屉原理,走超过 $2 * n^2$ 步,必然会有相同的局面出现过至少两次),但是这样的计算量为 $2 * 50^2 * 50 * 50 = 1.25 * 10^7$,有 `TLE` 风险,转移过程增加剪枝,可以过。\n\n而更小的 $k$ 值需要证明:在最优策略中,相同局面(状态)成环的最大长度的最小值为 $k$。\n\n题目规定轮流移动,且只能按照 $graph$ 中存在的边进行移动。\n\n1. 如果当前 $k$ 为偶数(该回合老鼠移动),此时所能转移所有点为 $f[k + 1][ne][j]$,其中 $ne$ 为 $i$ 所能到达的点。由于采用的是最优移动策略,因此 $f[k][i][j]$ 会优先往 $f[k + 1][ne][j] = 1$ 的点移动(自身获胜),否则往 $f[k + 1][ne][j] = 0$ 的点移动(平局),再否则才是往 $f[k + 1][ne][j] = 2$ 的点移动(对方获胜);\n\n2. 同理,如果当前 $k$ 为奇数(该回合猫移动),此时所能转移所有点为 $f[k + 1][i][ne]$,其中 $ne$ 为 $j$ 所能到达的点。由于采用的是最优移动策略,因此 $f[k][i][j]$ 会优先往 $f[k + 1][i][ne] = 2$ 的点移动(自身获胜),否则往 $f[k + 1][i][ne] = 0$ 的点移动(平局),再否则才是往 $f[k + 1][i][ne] = 1$ 的点移动(对方获胜)。\n\n使用该转移优先级进行递推即可,为了方便我们使用「记忆化搜索」的方式来实现动态规划。\n\n注意,该优先级转移其实存在「贪心」决策,但证明这样的决策会使得「最坏情况最好」是相对容易的,而证明存在更小的 $k$ 值才是本题难点。\n\n> 一些细节:由于本身就要对动规数组进行无效值的初始化,为避免每个样例都 `new` 大数组,我们使用 `static` 来修饰大数组,可以有效减少一点时间(不使用 `static` 的话,`N` 只能取到 $51$)。\n\n代码:\n```Java\nclass Solution {\n    static int N = 55;\n    static int[][][] f = new int[2 * N * N][N][N];\n    int[][] g;\n    int n;\n    public int catMouseGame(int[][] graph) {\n        g = graph;\n        n = g.length;\n        for (int k = 0; k < 2 * n * n; k++) {\n            for (int i = 0; i < n; i++) {\n                for (int j = 0; j < n; j++) {\n                    f[k][i][j] = -1;\n                }\n            }\n        }\n        return dfs(0, 1, 2);\n    }\n    // 0:draw / 1:mouse / 2:cat\n    int dfs(int k, int a, int b) {\n        int ans = f[k][a][b];\n        if (a == 0) ans = 1;\n        else if (a == b) ans = 2;\n        else if (k >= 2 * n * n) ans = 0;\n        else if (ans == -1) {\n            if (k % 2 == 0) { // mouse\n                boolean win = false, draw = false;\n                for (int ne : g[a]) {\n                    int t = dfs(k + 1, ne, b);\n                    if (t == 1) win = true;\n                    else if (t == 0) draw = true;\n                    if (win) break;\n                }\n                if (win) ans = 1;\n                else if (draw) ans = 0;\n                else ans = 2;\n            } else { // cat\n                boolean win = false, draw = false;\n                for (int ne : g[b]) {\n                    if (ne == 0) continue;\n                    int t = dfs(k + 1, a, ne);\n                    if (t == 2) win = true;\n                    else if (t == 0) draw = true;\n                    if (win) break;\n                }\n                if (win) ans = 2;\n                else if (draw) ans = 0;\n                else ans = 1;\n            }\n        }\n        f[k][a][b] = ans;\n        return ans;\n    }\n}\n```\n* 时间复杂度:状态的数量级为 $n^4$,可以确保每个状态只会被计算一次。复杂度为 $O(n^4)$\n* 空间复杂度:$O(n^4)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.913` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/911-920/915. 分割数组（中等）.md", "url_title": "915. 分割数组", "url": "https://leetcode.cn/problems/partition-array-into-disjoint-intervals/solution/by-ac_oier-yyen/", "difficulty": "中等", "tags": ["模拟"], "question": "给定一个数组 `nums`,将其划分为两个连续子数组 `left` 和 `right`,使得:\n\n* `left` 中的每个元素都小于或等于 `right` 中的每个元素。\n* `left` 和 `right` 都是非空的。\n* `left` 的长度要尽可能小。\n\n在完成这样的分组后返回 `left` 的长度。\n\n用例可以保证存在这样的划分方法。\n\n示例 1:\n```\n输入:nums = [5,0,3,8,6]\n\n输出:3\n\n解释:left = [5,0,3],right = [8,6]\n```\n示例 2:\n```\n输入:nums = [1,1,1,0,6,12]\n\n输出:4\n\n解释:left = [1,1,1,0],right = [6,12]\n```\n\n提示:\n* $2 <= nums.length <= 10^5$\n* $0 <= nums[i] <= 10^6$\n* 可以保证至少有一种方法能够按题目所描述的那样对 `nums` 进行划分。", "solution": "### 模拟\n\n根据题意,我们知道本质是求分割点,使得分割点的「左边的子数组的最大值」小于等于「右边的子数组的最小值」。\n\n我们可以先通过一次遍历(从后往前)统计出所有后缀的最小值 `min`,其中 `min[i] = x` 含义为下标范围在 $[i, n - 1]$ 的 $nums[i]$ 的最小值为 `x`,然后再通过第二次遍历(从前往后)统计每个前缀的最大值(使用单变量进行维护),找到第一个符合条件的分割点即是答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int partitionDisjoint(int[] nums) {\n        int n = nums.length;\n        int[] min = new int[n + 10];\n        min[n - 1] = nums[n - 1];\n        for (int i = n - 2; i >= 0; i--) min[i] = Math.min(min[i + 1], nums[i]);\n        for (int i = 0, max = 0; i < n - 1; i++) {\n            max = Math.max(max, nums[i]);\n            if (max <= min[i + 1]) return i + 1;\n        }\n        return -1; // never\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int partitionDisjoint(vector<int>& nums) {\n        int n = nums.size();\n        vector<int> arr(n + 10);\n        arr[n - 1] = nums[n - 1];\n        for (int i = n - 2; i >= 0; i--) arr[i] = min(arr[i + 1], nums[i]);\n        int maxv = 0;\n        for (int i = 0; i < n - 1; i++) {\n            maxv = max(maxv, nums[i]);\n            if (maxv <= arr[i + 1]) return i + 1;\n        }\n        return -1; // never\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def partitionDisjoint(self, nums: List[int]) -> int:\n        n = len(nums)\n        minv = [0] * (n + 10)\n        minv[n - 1] = nums[n - 1]\n        for i in range(n - 2, -1, -1):\n            minv[i] = min(minv[i + 1], nums[i])\n        maxv = 0\n        for i in range(n - 1):\n            maxv = max(maxv, nums[i])\n            if maxv <= minv[i + 1]:\n                return i + 1\n        return -1\n```\nTypeScript 代码:\n```TypeScript\nfunction partitionDisjoint(nums: number[]): number {\n    const n = nums.length\n    const min = new Array<number>(n + 10).fill(nums[n - 1])\n    for (let i = n - 2; i >= 0; i--) min[i] = Math.min(min[i + 1], nums[i])\n    for (let i = 0, max = 0; i < n; i++) {\n        max = Math.max(max, nums[i])\n        if (max <= min[i + 1]) return i + 1\n    }\n    return -1\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.915` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/911-920/917. 仅仅反转字母（简单）.md", "url_title": "917. 仅仅反转字母", "url": "https://leetcode-cn.com/problems/reverse-only-letters/solution/gong-shui-san-xie-jian-dan-shuang-zhi-zh-xrpt/", "difficulty": "简单", "tags": ["双指针"], "question": "给你一个字符串 `s` ,根据下述规则反转字符串:\n\n* 所有非英文字母保留在原有位置。\n* 所有英文字母(小写或大写)位置反转。\n\n返回反转后的 `s` 。\n\n示例 1:\n```\n输入:s = \"ab-cd\"\n\n输出:\"dc-ba\"\n```\n示例 2:\n```\n输入:s = \"a-bC-dEf-ghIj\"\n\n输出:\"j-Ih-gfE-dCba\"\n```\n示例 3:\n```\n输入:s = \"Test1ng-Leet=code-Q!\"\n\n输出:\"Qedo1ct-eeLg=ntse-T!\"\n```\n\n提示\n* $1 <= s.length <= 100$\n* `s` 仅由 `ASCII` 值在范围 $[33, 122]$ 的字符组成\n* `s` 不含 `'\\\"'` 或 `'\\\\'`", "solution": "### 双指针\n\n根据题意进行模拟即可,每次都使用 `i` 和 `j` 分别指向左端和右端可以被交换的字母,若当前指针指向的不是字母,则分别往中间移动,直到找到下一个可交换的字母位置,每次交换结束,两指针均往中间移动一位。\n\n代码:\n```Java\nclass Solution {\n    public String reverseOnlyLetters(String s) {\n        char[] cs = s.toCharArray();\n        int n = cs.length;\n        for (int i = 0, j = n - 1; i < j; ) {\n            while (i < j && !Character.isLetter(cs[i])) i++;\n            while (i < j && !Character.isLetter(cs[j])) j--;\n            if (i < j) {\n                char c = cs[i];\n                cs[i++] = cs[j];\n                cs[j--] = c;\n            }\n        }\n        return String.valueOf(cs);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:调用 `toCharArray` 和构造新字符串均需要与字符串长度等同的空间。复杂度为 $O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.917` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/911-920/919. 完全二叉树插入器（中等）.md", "url_title": "919. 完全二叉树插入器", "url": "https://leetcode.cn/problems/complete-binary-tree-inserter/solution/by-ac_oier-t9dh/", "difficulty": "中等", "tags": ["模拟", "BFS", "树的遍历"], "question": "完全二叉树 是每一层(除最后一层外)都是完全填充(即,节点数达到最大)的,并且所有的节点都尽可能地集中在左侧。\n\n设计一种算法,将一个新节点插入到一个完整的二叉树中,并在插入后保持其完整。\n\n实现 `CBTInserter` 类:\n\n* `CBTInserter(TreeNode root)` 使用头节点为 `root` 的给定树初始化该数据结构;\n* `CBTInserter.insert(int v)`  向树中插入一个值为 `Node.val == val` 的新节点 `TreeNode`。使树保持完全二叉树的状态,并返回插入节点 `TreeNode` 的父节点的值\n* `CBTInserter.get_root()` 将返回树的头节点。\n\n示例 1:\n\n```\n输入\n[\"CBTInserter\", \"insert\", \"insert\", \"get_root\"]\n[[[1, 2]], [3], [4], []]\n\n输出\n[null, 1, 2, [1, 2, 3, 4]]\n\n解释\nCBTInserter cBTInserter = new CBTInserter([1, 2]);\ncBTInserter.insert(3);  // 返回 1\ncBTInserter.insert(4);  // 返回 2\ncBTInserter.get_root(); // 返回 [1, 2, 3, 4]\n```\n\n提示:\n* 树中节点数量范围为 $[1, 1000]$\n* $0 <= Node.val <= 5000$\n* `root` 是完全二叉树\n* $0 <= val <= 5000 $\n* 每个测试用例最多调用 `insert` 和 `get_root` 操作 $10^4$ 次", "solution": "### BFS\n\n起始使用数组对构造函数传入的 `root` 进行 `BFS` 层序遍历(由于仍要保留层序遍历顺序,因此使用下标指针 `cur` 来模拟出队位置)。\n\n对于 `insert` 操作而言,我们要在数组(层序遍历顺序)中找到首个「存在左右空子节点」的父节点 `fa`,由于找到 `fa` 节点的过程数组下标单调递增,因此可以使用全局变量 `idx` 不断往后搜索,每次将新节点 `node` 添加到当前树后,需要将 `node` 添加到数组尾部。\n\n`get_root` 操作则始终返回数组首位元素即可。\n\nJava 代码:\n```Java\nclass CBTInserter {\n    List<TreeNode> list = new ArrayList<>();\n    int idx = 0;\n    public CBTInserter(TreeNode root) {\n        list.add(root);\n        int cur = 0;\n        while (cur < list.size()) {\n            TreeNode node = list.get(cur);\n            if (node.left != null) list.add(node.left);\n            if (node.right != null) list.add(node.right);\n            cur++;\n        }\n    }\n    public int insert(int val) {\n        TreeNode node = new TreeNode(val);\n        while (list.get(idx).left != null && list.get(idx).right != null) idx++;\n        TreeNode fa = list.get(idx);\n        if (fa.left == null) fa.left = node;\n        else if (fa.right == null) fa.right = node;\n        list.add(node);\n        return fa.val;\n    }\n    public TreeNode get_root() {\n        return list.get(0);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nclass CBTInserter {\n    list: TreeNode[] = new Array<TreeNode>()\n    idx: number = 0\n    constructor(root: TreeNode | null) {\n        this.list.push(root)\n        let cur = 0\n        while (cur < this.list.length) {\n            const node = this.list[cur]\n            if (node.left != null) this.list.push(node.left)\n            if (node.right != null) this.list.push(node.right)\n            cur++\n        }\n    }\n    insert(val: number): number {\n        const node = new TreeNode(val)\n        while (this.list[this.idx].left != null && this.list[this.idx].right != null) this.idx++\n        const fa = this.list[this.idx]\n        if (fa.left == null) fa.left = node\n        else if (fa.right == null) fa.right = node\n        this.list.push(node)\n        return fa.val\n    }\n    get_root(): TreeNode | null {\n        return this.list[0]\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.919` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/921-930/921. 使括号有效的最少添加（中等）.md", "url_title": "921. 使括号有效的最少添加", "url": "https://leetcode.cn/problems/minimum-add-to-make-parentheses-valid/solution/by-ac_oier-9tn1/", "difficulty": "中等", "tags": ["模拟"], "question": "只有满足下面几点之一,括号字符串才是有效的:\n\n* 它是一个空字符串,或者\n* 它可以被写成 `AB` (`A` 与 `B` 连接), 其中 `A` 和 `B` 都是有效字符串,或者\n* 它可以被写作 (`A`),其中 `A` 是有效字符串。\n\n给定一个括号字符串 `s` ,移动 `N` 次,你就可以在字符串的任何位置插入一个括号。\n\n* 例如,如果 `s = \"()))\"` ,你可以插入一个开始括号为 `\"(()))\"` 或结束括号为 `\"())))\"` 。\n\n返回 为使结果字符串 `s` 有效而必须添加的最少括号数。\n\n示例 1:\n```\n输入:s = \"())\"\n\n输出:1\n```\n示例 2:\n```\n输入:s = \"(((\"\n\n输出:3\n```\n\n提示:\n* $1 <= s.length <= 1000$\n* `s` 只包含 `'('` 和 `')'` 字符", "solution": "### 模拟\n\n一个介绍过很多次的做法 : 将「有效括号问题」转化为「分值有效性」的数学判定。\n\n使用 `score` 代指处理过程中的得分,将 `(` 记为 `+1`,将 `)` 记为 `-1`。\n\n一个有效的括号应当在整个过程中不出现负数,因此一旦 `score` 出现负数,我们需要马上增加 `(` 来确保合法性;当整个 `s` 处理完后,还需要添加 `socre` 等同的 `)` 来确保合法性。\n\nJava 代码:\n```Java\nclass Solution {\n    public int minAddToMakeValid(String s) {\n        int score = 0, ans = 0;\n        for (char c : s.toCharArray()) {\n            score += c == '(' ? 1 : -1;\n            if (score < 0) {\n                score = 0; ans++;\n            }\n        }\n        return ans + score;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction minAddToMakeValid(s: string): number {\n    let scroe = 0, ans = 0\n    for (const c of s) {\n        scroe += c == '(' ? 1 : -1\n        if (scroe < 0) {\n            scroe = 0; ans++\n        }\n    }\n    return ans + scroe\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def minAddToMakeValid(self, s: str) -> int:\n        score, ans = 0, 0\n        for c in s:\n            score += 1 if c == '(' else -1\n            if score < 0:\n                score = 0\n                ans += 1\n        return ans + score\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:使用 `charAt` 代替 `toCharArray` 操作,复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.921` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/921-930/926. 将字符串翻转到单调递增（中等）.md", "url_title": "926. 将字符串翻转到单调递增", "url": "https://leetcode.cn/problems/flip-string-to-monotone-increasing/solution/by-ac_oier-h0we/", "difficulty": "中等", "tags": ["LIS", "序列 DP", "贪心", "二分", "动态规划", "前缀和", "枚举", "容斥原理"], "question": "如果一个二进制字符串,是以一些 $0$(可能没有 $0$)后面跟着一些 $1$(也可能没有 $1$)的形式组成的,那么该字符串是 单调递增 的。\n\n给你一个二进制字符串 `s`,你可以将任何 $0$ 翻转为 $1$ 或者将 $1$ 翻转为 $0$ 。\n\n返回使 `s` 单调递增的最小翻转次数。\n\n示例 1:\n```\n输入:s = \"00110\"\n\n输出:1\n\n解释:翻转最后一位得到 00111.\n```\n示例 2:\n```\n输入:s = \"010110\"\n\n输出:2\n\n解释:翻转得到 011111,或者是 000111。\n```\n示例 3:\n```\n输入:s = \"00011000\"\n\n输出:2\n\n解释:翻转得到 00000000。\n```\n\n提示:\n* $1 <= s.length <= 10^5$\n* `s[i]` 为 `'0'` 或 `'1'`", "solution": "### LIS 问题贪心解\n\n根据题意,不难想到将原题进行等价转换:**令 `s` 长度为 $n$,原问题等价于在 `s` 中找到最长不下降子序列,设其长度为 $ans$,那么对应的 $n - ans$ 即是答案。**\n\n由于数据范围为 $1e5$,因此我们需要使用 `LIS` 问题的贪心求解方式:**使用 `g` 数组记录每个长度的最小结尾元素,即 `g[len] = x` 含义为长度为 $len$ 的最长不下降子序列的结尾元素为 $x$,然后在从前往后处理每个 $t = s[i]$ 时,由于是求解「最长不下降子序列」,等价于找「满足大于 $t$ 的最小下标」,这可以运用「二分」进行求解。**\n\n> 不了解 `LIS` 问题或者不清楚 `LIS`  问题贪心解法的同学可以看前置 🧀 : **[LCS 问题与 LIS 问题的相互关系,以及 LIS 问题的最优解证明](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247487814&idx=1&sn=e33023c2d474ff75af83eda1c4d01892)**,里面详细讲解了 `LIS` 贪心解的正确性证明,以及 `LCS` 和 `LIS` 在特定条件下存在的内在联系。\n\n代码:\n```Java\nclass Solution {\n    public int minFlipsMonoIncr(String s) {\n        char[] cs = s.toCharArray();\n        int n = cs.length, ans = 0;\n        int[] g = new int[n + 10];\n        Arrays.fill(g, n + 10);\n        for (int i = 0; i < n; i++) {\n            int t = s.charAt(i) - '0';\n            int l = 1, r = i + 1;\n            while (l < r) {\n                int mid = l + r >> 1;\n                if (g[mid] > t) r = mid;\n                else l = mid + 1;\n            }\n            g[r] = t;\n            ans = Math.max(ans, r);\n        }\n        return n - ans;\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 前缀和 + 枚举\n\n更进一步,利用 `s` 只存在 $0$ 和 $1$ 两种数值,我们知道最后的目标序列形如 `000...000`、`000...111` 或 `111...111` 的形式。\n\n因此我们可以枚举目标序列的 $0$ 和 $1$ 分割点位置 $idx$(分割点是 $0$ 是 $1$ 都可以,不消耗改变次数)。\n\n于是问题转换为:分割点 $idx$ 左边有多少个 $1$(目标序列中分割点左边均为 $0$,因此 $1$ 的个数为左边的改变次数),分割点 $idx$ 的右边有多少个 $0$(目标序列中分割点右边均为 $1$,因此 $0$ 的个数为右边的改变次数),两者之和即是分割点为 $idx$ 时的总变化次数,所有 $idx$ 的总变化次数最小值即是答案。\n\n而求解某个点左边或者右边有多少 $1$ 和 $0$ 可通过「前缀和」进行优化。\n\n代码:\n```Java\nclass Solution {\n    public int minFlipsMonoIncr(String s) {\n        char[] cs = s.toCharArray();\n        int n = cs.length, ans = n;\n        int[] sum = new int[n + 10];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (cs[i - 1] - '0');\n        for (int i = 1; i <= n; i++) {\n            int l = sum[i - 1], r = (n - i) - (sum[n] - sum[i]);\n            ans = Math.min(ans, l + r);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.926` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/921-930/927. 三等分（困难）.md", "url_title": "927. 三等分", "url": "https://leetcode.cn/problems/three-equal-parts/solution/by-ac_oier-9i2s/", "difficulty": "困难", "tags": ["模拟"], "question": "给定一个由 `0` 和 `1` 组成的数组 `arr`,将数组分成  `3` 个非空的部分 ,使得所有这些部分表示相同的二进制值。\n\n如果可以做到,请返回任何 `[i, j]`,其中 `i+1 < j`,这样一来:\n\n* `arr[0], arr[1], ..., arr[i]` 为第一部分;\n* `arr[i + 1], arr[i + 2], ..., arr[j - 1]` 为第二部分;\n* `arr[j], arr[j + 1], ..., arr[arr.length - 1]` 为第三部分。\n* 这三个部分所表示的二进制值相等。\n\n如果无法做到,就返回 `[-1, -1]`。\n\n注意,在考虑每个部分所表示的二进制时,应当将其看作一个整体。例如,`[1,1,0]` 表示十进制中的 `6`,而不会是 `3`。此外,前导零也是被允许的,所以 `[0,1,1]` 和 `[1,1]` 表示相同的值。\n\n示例 1:\n```\n输入:arr = [1,0,1,0,1]\n\n输出:[0,3]\n```\n示例 2:\n```\n输入:arr = [1,1,0,1,1]\n\n输出:[-1,-1]\n```\n示例 3:\n```\n输入:arr = [1,1,0,0,1]\n\n输出:[0,2]\n```\n\n提示:\n* $3 <= arr.length <= 3 \\times 10^4$\n* `arr[i]` 是 `0` 或 `1`", "solution": "### 模拟\n\n心情不好,写的代码也不好。\n\n就大概讲讲啥意思吧:\n\n1. 先统计 `1` 的个数 `cnt`,若 `cnt = 0` 代表能够任意划分,直接返回 `[0, 2]`;\n2. 若 `cnt` 不为 $3$ 的倍数,必然不能正常划分,返回无解 `[-1, -1]`,否则可知三段中必然每一段 `1` 的数量均为 $t = \\frac{cnt}{3}$ 个;\n3. 最后检查「三段中 `1` 的间隔位是否相同,后缀 `0` 个数是否相同」即可:\n    1. 创建二维数组 `ins` 记录三段中,相邻 `1` 之间的间隔情况,若存在间隔 `1` 不同,返回无解 `[-1, -1]`;\n    2. 预处理四个变量 `l1`、`l2`、`r1` 和 `r2`,分别代表能够划分出最左边 `t` 个 `1` 的左右端点,以及能够划分出最右边 `t` 个 `1` 的左右端点,同时统计最后一段的后缀 `0` 的数量 `d`,配合四个变量来检查能否划分出具有 `d` 个后缀 `0` 的前两段。\n\n代码:\n```Java\nclass Solution {\n    public int[] threeEqualParts(int[] arr) {\n        int[] fail = new int[]{-1, -1};\n        // 检查总数\n        int n = arr.length, cnt = 0;\n        for (int i = 0; i < n; i++) cnt += arr[i];\n        if (cnt == 0) return new int[]{0, 2};\n        if (cnt % 3 != 0) return fail;\n        // 检查间隔相对位\n        int t = cnt / 3;\n        int[][] ins = new int[3][t];\n        for (int i = 0, j = -1, k = 0, p = 0, idx = 0; i < n; i++) {\n            if (arr[i] == 0) continue;\n            if (j != -1) ins[p][idx++] = i - j;\n            if (++k == t) {\n                j = -1; k = 0; p++; idx = 0;\n            } else {\n                j = i;\n            }\n        }\n        for (int i = 0; i < t; i++) {\n            if (ins[0][i] == ins[1][i] && ins[0][i] == ins[2][i] && ins[1][i] == ins[2][i]) continue;\n            return fail;\n        }\n        // 构造答案(l1 和 l2 分别为能够划分出最左边 t 个 1 的 左右端点;r1 和 r2 分别为能够划分出最右边 t 个 1 的左右端点)\n        int l1 = -1, l2 = -1, r1 = -1, r2 = -1;\n        for (int i = 0, k = 0; i < n; i++) {\n            k += arr[i];\n            if (k == t) {\n                if (l1 == -1) l1 = i;\n            } else if (k == t + 1) {\n                l2 = i - 1;\n                break;\n            }\n        }\n        for (int i = n - 1, k = 0; i >= 0; i--) {\n            k += arr[i];\n            if (k == t) {\n                if (r2 == -1) r2 = i;\n            } else if (k == t + 1) {\n                r1 = i + 1;\n                break;\n            }\n        }\n        int d = 0; // d 为最右边一段的后缀 0 的数量\n        for (int i = n - 1; i >= 0; i--) {\n            if (arr[i] == 1) break;\n            d++;\n        }\n        if (l1 + d > l2 || r1 + d > r2) return fail;\n        return new int[]{l1 + d, r1 + d};\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.927` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/921-930/929. 独特的电子邮件地址（简单）.md", "url_title": "929. 独特的电子邮件地址", "url": "https://leetcode.cn/problems/unique-email-addresses/solution/by-ac_oier-d3zu/", "difficulty": "简单", "tags": ["模拟"], "question": "每个 有效电子邮件地址 都由一个 本地名 和一个 域名 组成,以 `'@'` 符号分隔。除小写字母之外,电子邮件地址还可以含有一个或多个 `'.'` 或 `'+'` 。\n\n* 例如,在 `alice@leetcode.com` 中, `alice` 是 本地名 ,而 `leetcode.com` 是域名 。\n\n如果在电子邮件地址的 本地名 部分中的某些字符之间添加句点('`.'`),则发往那里的邮件将会转发到本地名中没有点的同一地址。请注意,此规则 不适用于域名 。\n\n* 例如,`\"alice.z@leetcode.com”` 和 `“alicez@leetcode.com”` 会转发到同一电子邮件地址。\n\n如果在 本地名 中添加加号(`'+'`),则会忽略第一个加号后面的所有内容。这允许过滤某些电子邮件。同样,此规则 不适用于域名 。\n\n* 例如 `m.y+name@email.com` 将转发到 `my@email.com`。\n\n可以同时使用这两个规则。\n\n给你一个字符串数组 `emails`,我们会向每个 `emails[i]` 发送一封电子邮件。返回实际收到邮件的不同地址数目。\n\n示例 1:\n```\n输入:emails = [\"test.email+alex@leetcode.com\",\"test.e.mail+bob.cathy@leetcode.com\",\"testemail+david@lee.tcode.com\"]\n\n输出:2\n\n解释:实际收到邮件的是 \"testemail@leetcode.com\" 和 \"testemail@lee.tcode.com\"。\n```\n示例 2:\n```\n输入:emails = [\"a@leetcode.com\",\"b@leetcode.com\",\"c@leetcode.com\"]\n\n输出:3\n```\n\n提示:\n* $1 <= emails.length <= 100$\n* $1 <= emails[i].length <= 100$\n* `emails[i]` 由小写英文字母、`'+'`、`'.'` 和 `'@'` 组成\n* 每个 `emails[i]` 都包含有且仅有一个 `'@'` 字符\n* 所有本地名和域名都不为空\n* 本地名不会以 `'+'` 字符作为开头", "solution": "### 模拟\n\n根据题意进行模拟。\n\n代码:\n```Java\nclass Solution {\n    public int numUniqueEmails(String[] emails) {\n        Set<String> set = new HashSet<>();\n        for (String s : emails) {\n            StringBuilder sb = new StringBuilder();\n            int n = s.length(), i = 0;\n            boolean ok = true;\n            while (i < n) {\n                char c = s.charAt(i);\n                if (c == '@') break;\n                if (c == '.' && ++i >= 0) continue;\n                if (c == '+') ok = false;\n                if (ok) sb.append(c);\n                i++;\n            }\n            set.add(sb.append(s.substring(i)).toString());\n        }\n        return set.size();\n    }\n}\n```\n* 时间复杂度:$O(\\sum_{i = 0}^{n - 1} len(emails[i]))$\n* 空间复杂度:$O(\\sum_{i = 0}^{n - 1} len(emails[i]))$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.929` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/921-930/930. 和相同的二元子数组（中等）.md", "url_title": "930. 和相同的二元子数组", "url": "https://leetcode-cn.com/problems/binary-subarrays-with-sum/solution/gong-shui-san-xie-yi-ti-shuang-jie-qian-hfoc0/", "difficulty": "中等", "tags": ["前缀和", "哈希表", "双指针"], "question": "给你一个二元数组 nums ,和一个整数 goal ,请你统计并返回有多少个和为 goal 的 非空 子数组。\n\n子数组 是数组的一段连续部分。\n\n示例 1:\n```\n输入:nums = [1,0,1,0,1], goal = 2\n\n输出:4\n\n解释:\n如下面黑体所示,有 4 个满足题目要求的子数组:\n[1,0,1,0,1]\n[1,0,1,0,1]\n[1,0,1,0,1]\n[1,0,1,0,1]\n```\n示例 2:\n```\n输入:nums = [0,0,0,0,0], goal = 0\n\n输出:15\n```\n\n提示:\n* 1 <= nums.length <= 3 * $10^4$\n* nums[i] 不是 0 就是 1\n* 0 <= goal <= nums.length", "solution": "### 前缀和 + 哈希表\n\n一个简单的想法是,先计算 $nums$ 的前缀和数组 $sum$,然后从前往后扫描 $nums$,对于右端点 $r$,通过前缀和数组可以在 $O(1)$ 复杂度内求得 $[0, r]$ 连续一段的和,根据容斥原理,我们还需要求得某个左端点 $l$,使得 $[0, r]$ 减去 $[0, l - 1]$ 和为 $t$,即满足 $sum[r] - sum[l - 1] = t$,这时候利用哈希表记录扫描过的 $sum[i]$ 的出现次数,可以实现 $O(1)$ 复杂度内求得满足要求的左端点个数。\n\n该方法适用于 $nums[i]$ 值不固定为 $0$ 和 $1$ 的其他情况。\n\n代码:\n```Java\nclass Solution {\n    public int numSubarraysWithSum(int[] nums, int t) {\n        int n = nums.length;\n        int[] sum = new int[n + 1];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n        Map<Integer, Integer> map = new HashMap<>();\n        map.put(0, 1);\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            int r = sum[i + 1], l = r - t;\n            ans += map.getOrDefault(l, 0);\n            map.put(r, map.getOrDefault(r, 0) + 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 双指针\n\n另外一个通用性稍差一点的做法则是利用 $nums[i]$ 没有负权值。\n\n**$nums[i]$ 没有负权值意味着前缀和数组必然具有(非严格)单调递增特性。**\n\n不难证明,在给定 $t$ 的情况下,当我们右端点 $r$ 往右移动时,满足条件的左端点 $l$ 必然往右移动。\n\n实现上,我们可以使用两个左端点 $l1$ 和 $l2$,代表在给定右端点 $r$ 的前提下满足要求的左端点集合,同时使用 $s1$ 和 $s2$ 分别代表两个端点到 $r$ 这一段的和。\n\n代码:\n```Java\nclass Solution {\n    public int numSubarraysWithSum(int[] nums, int t) {\n        int n = nums.length;\n        int ans = 0;\n        for (int r = 0, l1 = 0, l2 = 0, s1 = 0, s2 = 0; r < n; r++) {\n            s1 += nums[r];\n            s2 += nums[r];\n            while (l1 <= r && s1 > t) s1 -= nums[l1++];\n            while (l2 <= r && s2 >= t) s2 -= nums[l2++];\n            ans += l2 - l1;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.930` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/931-940/933. 最近的请求次数（简单）.md", "url_title": "933. 最近的请求次数", "url": "https://leetcode-cn.com/problems/number-of-recent-calls/solution/by-ac_oier-evqe/", "difficulty": "简单", "tags": ["分块", "线段树(动态开点)"], "question": "写一个 `RecentCounter` 类来计算特定时间范围内最近的请求。\n\n请你实现 `RecentCounter` 类:\n* `RecentCounter()` 初始化计数器,请求数为 $0$ 。\n* `int ping(int t)` 在时间 $t$ 添加一个新请求,其中 $t$ 表示以毫秒为单位的某个时间,并返回过去 $3000$ 毫秒内发生的所有请求数(包括新请求)。确切地说,返回在 $[t-3000, t]$ 内发生的请求数。\n\n保证 每次对 `ping` 的调用都使用比之前更大的 $t$ 值。\n\n示例 1:\n```\n输入:\n[\"RecentCounter\", \"ping\", \"ping\", \"ping\", \"ping\"]\n[[], [1], [100], [3001], [3002]]\n\n输出:\n[null, 1, 2, 3, 3]\n\n解释:\nRecentCounter recentCounter = new RecentCounter();\nrecentCounter.ping(1);     // requests = [1],范围是 [-2999,1],返回 1\nrecentCounter.ping(100);   // requests = [1, 100],范围是 [-2900,100],返回 2\nrecentCounter.ping(3001);  // requests = [1, 100, 3001],范围是 [1,3001],返回 3\nrecentCounter.ping(3002);  // requests = [1, 100, 3001, 3002],范围是 [2,3002],返回 3\n```\n\n提示:\n* $1 <= t <= 10^9$\n* 保证每次对 `ping` 调用所使用的 $t$ 值都 严格递增\n* 至多调用 `ping` 方法 $10^4$ 次", "solution": "> 以下内容(支持任意的 $[l, r]$ 查询)基于我漏看了 $t$ 递增这一条件。由于 $t$ 递增,因此往前距离大于 $3000$ 的记录无须保留,从而简化了问题,可以使用队列直接做,今天打字很多了,不补充了。\n\n### 基本分析 \n\n根据题意,题目涉及「单点修改」和「区间查询」,根据 [区间求和问题](https://leetcode-cn.com/problems/range-sum-query-mutable/solution/guan-yu-ge-lei-qu-jian-he-wen-ti-ru-he-x-41hv/) 的总结,可以使用「树状数组」和「线段树」进行求解。\n\n但是留意到 $t$ 的数据范围为 $1e9$,虽然调用次数是 $1e4$,但由于本题是「强制在线」问题,因此我们无法利用「离散化」手段来解决 `MLE`  问题,而要使用「线段树(动态开点)」来解决。\n\n---\n\n### 线段树(动态开点)\n\n动态开点的优势在于,不需要事前构造空树,而是在插入操作 `update` 和查询操作 `query` 时根据访问需要进行「开点」操作。由于我们不保证查询和插入都是连续的,因此对于父节点 $u$ 而言,我们不能通过 `u << 1` 和 `u << 1  | 1` 的固定方式进行访问,而要将节点 $tr[u]$ 的左右节点所在 `tr` 数组的下标进行存储,分别记为 `ls` 和 `rs` 属性。对于 $tr[u].ls = 0$ 和 $tr[u].rs = 0$ 则是代表子节点尚未被创建,当需要访问到它们,而又尚未创建的时候,则将其进行创建。\n\n线段树的插入和查询都是 $\\log{n}$ 的(如果涉及区间修改,则由懒标记来确保 $\\log{n}$ 复杂度),因此我们在单次操作的时候,最多会创建数量级为 $\\log{n}$ 的点,因此空间复杂度为 $O(m\\log{n})$,而不是 $O(4 * n)$,而开点数的预估需不能仅仅根据 $\\log{n}$ 来进行,还要对具体常数进行分析,才能得到准确的点数上界。\n\n动态开点相比于原始的线段树实现,本质仍是使用「满二叉树」的形式进行存储,只不过是按需创建区间,如果我们是按照连续段进行查询或插入,最坏情况下仍然会占到 $4 * n$ 的空间,因此盲猜 $\\log{n}$ 的常数在 $4$ 左右,保守一点可以直接估算到 $6$,因此我们可以估算点数为 $6 * m * \\log{n}$,其中 $n = 1e9$ 和 $m = 1e4$ 分别代表值域大小和查询次数。\n\n当然一个比较实用的估点方式可以「尽可能的多开点数」,利用题目给定的空间上界和我们创建的自定义类(结构体)的大小,尽可能的多开( `Java` 的 $128M$ 可以开到 $5 * 10^6$ 以上)。\n\n代码:\n```Java\nclass RecentCounter {\n    class Node {\n        // ls 和 rs 分别代表当前节点(区间)的左右子节点在 tr 的下标\n        // val 代表在当前节点(区间)所包含的数的个数\n        int ls, rs, val;\n    }\n    int N = (int)1e9, M = 800010, idx = 1;\n    Node[] tr = new Node[M];\n    void update(int u, int lc, int rc, int x, int v) {\n        if (lc == x && rc == x) {\n            tr[u].val += (rc - lc + 1) * v;\n            return ;\n        }\n        lazyCreate(u);\n        int mid = lc + rc >> 1;\n        if (x <= mid) update(tr[u].ls, lc, mid, x, v);\n        else update(tr[u].rs, mid + 1, rc, x, v);\n        pushup(u);\n    }\n    int query(int u, int lc, int rc, int l, int r) {\n        if (l <= lc && rc <= r) return tr[u].val;\n        lazyCreate(u);\n        int mid = lc + rc >> 1, ans = 0;\n        if (l <= mid) ans = query(tr[u].ls, lc, mid, l, r);\n        if (r > mid) ans += query(tr[u].rs, mid + 1, rc, l, r);\n        return ans;\n    }\n    void lazyCreate(int u) {\n        if (tr[u] == null) tr[u] = new Node();\n        if (tr[u].ls == 0) {\n            tr[u].ls = ++idx;\n            tr[tr[u].ls] = new Node();\n        }\n        if (tr[u].rs == 0) {\n            tr[u].rs = ++idx;\n            tr[tr[u].rs] = new Node();\n        }\n    }\n    void pushup(int u) {\n        tr[u].val = tr[tr[u].ls].val + tr[tr[u].rs].val;\n    }\n    public int ping(int t) {\n        update(1, 1, N, t, 1);\n        return query(1, 1, N, Math.max(0, t - 3000), t);\n    }\n}\n```\n* 时间复杂度:令 `ping` 的调用次数为 $m$,值域大小为 $n$,线段树的插入和查询复杂度均为 $O(\\log{n})$\n* 空间复杂度:$O(m * \\log{n})$\n\n---\n\n### 分块\n\n另外一个稍有遗憾的算法是「分块」。\n\n通常来说,值域范围为 $n = 1e9$,我们可以定义块大小为 $\\sqrt{n}$,这样时空复杂度都是 $O(\\sqrt{n})$。\n\n回到本题,我们定义一个 `region` 数组,用于存储每个块所包含的数的个数。\n\n对于在位置 $x$ 插入一个值 $v$ 而言,我们可以计算位置 $x$ 所在的块编号 $idx = \\left \\lfloor \\frac{x}{m} \\right \\rfloor$,然后对块大小进行累加操作($region[idx] += x$)。同时由于在查询 $[t - 3000, t]$ 时不总是覆盖完整的块(也就是我们可能需要询问某一段的总个数,而这一段仅是块内的部分区间),因此我们需要额外记录位置 $x$ 当前所包含的总数是多少,本题值域大小达到了 $1e9$,因此不能使用静态数组来做,只能使用哈希表来实现动态记录。\n\n我们可以分析单个 `ping` 操作的计算量/复杂度:\n* `update` 操作:$O(1)$;\n* `query` 操作:不限制区域大小的话,计算量为 $1e5 * C$($C$ 是一个小于 $4$ 的常数),由于存在 $[t - 3000, t]$ 的限制,相当于这部分操作全部变成块内了,计算量固定为 $3000$。\n\n于是有通过了所有样例,居然还 `TLE` 的结果???(这是啥测评机制\n\n但经过分析,我们知道瓶颈在于块内操作过多,我们可以利用 $[t - 3000, t]$ 来优化我们的分块算法:直接定义块大小为 $300$,然后倒推出需要多个块空间,分块算法就可以过了(~~特别说明:通过时间为 `2022-05-06`,未来可能还会有无聊的人来卡分块。~~ 我不信,卡不掉 🤣\n\n代码:\n```Java\nclass RecentCounter {\n    static int m = 300, n = (int)(1e9 / m) + 10;\n    static Map<Integer, Integer> map = new HashMap<>();\n    static int[] region = new int[n];\n    int getIdx(int x) {\n        return x / m;\n    }\n    void update(int x, int v) {\n        map.put(x, map.getOrDefault(x, 0) + v);\n        region[getIdx(x)] += v;\n    }\n    int query(int l, int r) {\n        int ans = 0;\n        if (getIdx(l) == getIdx(r)) {\n            for (int k = l; k <= r; k++) ans += map.getOrDefault(k, 0);\n        } else {\n            int i = l, j = r;\n            while (getIdx(i) == getIdx(l)) ans += map.getOrDefault(i++, 0);\n            while (getIdx(j) == getIdx(r)) ans += map.getOrDefault(j--, 0);\n            for (int k = getIdx(i); k <= getIdx(j); k++) ans += region[k];\n        }\n        return ans;\n    }\n    public RecentCounter() {\n        map.clear();\n        Arrays.fill(region, 0);\n    }\n    public int ping(int t) {\n        update(t, 1);\n        return query(Math.max(0, t - 3000), t);\n    }\n}\n```\n* 时间复杂度:通常情况下:调用次数为 $m$,值域大小为 $n$,复杂度为 $O(\\sqrt{n})$;本题:$O(C)$,其中 $C = 300$ 为块大小\n* 空间复杂度:通常情况下:$O(m +\\sqrt{n})$;本题:$O(m + M)$,其中 $M$ 为分块数组大小", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.933` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/931-940/934. 最短的桥（中等）.md", "url_title": "934. 最短的桥", "url": "https://leetcode.cn/problems/shortest-bridge/solution/by-ac_oier-56ly/", "difficulty": "中等", "tags": ["并查集", "双向 BFS"], "question": "给你一个大小为 `n x n` 的二元矩阵 `g`,其中 `1` 表示陆地,`0` 表示水域。\n\n岛是由四面相连的 `1` 形成的一个最大组,即不会与非组内的任何其他 `1` 相连,`g` 中恰好存在两座岛。\n\n你可以将任意数量的 `0` 变为 `1` ,以使两座岛连接起来,变成一座岛。\n\n返回必须翻转的 `0` 的最小数目。\n\n示例 1:\n```\n输入:g = [[0,1],[1,0]]\n\n输出:1\n```\n示例 2:\n```\n输入:g = [[0,1,0],[0,0,0],[0,0,1]]\n\n输出:2\n```\n示例 3:\n```\n输入:g = [[1,1,1,1,1],[1,0,0,0,1],[1,0,1,0,1],[1,0,0,0,1],[1,1,1,1,1]]\n\n输出:1\n```\n\n提示:\n* $n = g.length = g[i].length$\n* $2 <= n <= 100$\n* `g[i][j]` 为 `0` 或 `1`\n* `g` 中恰有两个岛", "solution": "### 并查集 + 双向 BFS\n\n**使用「并查集」将两个岛标记出来,然后将两个岛的点分别入队,再运用「双向 BFS」来找最短通路。**\n\n对于所有满足 $g[i][j] = 1$ 的节点与其四联通的方向,值同为 $1$ 的节点进行并查集连通性维护。\n\n随后建立两个队列 `d1` 和 `d2` 分别存储两个岛的节点(以二元组 $(x, y)$ 的方式出入队),并使用两个哈希表 `m1` 和 `m2` 来记录从两岛屿出发到达该节点所消耗的步数(以节点的一维编号为 `key`,以消耗步数为 `value`)。\n\n最后是使用「双向 BFS」来求解使两岛屿联通的最小通路:每次从队列中较少的进行拓展,只有尚未被处理过的节点(没有被当前哈希表所记录)才进行入队并更新消耗步数,当拓展节点在另外一个队列对应的哈希表表中出现过,说明找到了最短通路。\n\nJava 代码:\n```Java\nclass Solution {\n    static int N = 10010;\n    static int[] p = new int[N];\n    static int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};\n    int n;\n    int getIdx(int x, int y) {\n        return x * n + y;\n    }\n    int find(int x) {\n        if (p[x] != x) p[x] = find(p[x]);\n        return p[x];\n    }\n    void union(int x, int y) {\n        p[find(x)] = p[find(y)];\n    }\n    public int shortestBridge(int[][] g) {\n        n = g.length;\n        for (int i = 0; i <= n * n; i++) p[i] = i;\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                if (g[i][j] == 0) continue;\n                for (int[] di : dirs) {\n                    int x = i + di[0], y = j + di[1];\n                    if (x < 0 || x >= n || y < 0 || y >= n) continue;\n                    if (g[x][y] == 0) continue;\n                    union(getIdx(i, j), getIdx(x, y));\n                }\n            }\n        }\n        int a = -1, b = -1;\n        Deque<int[]> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();\n        Map<Integer, Integer> m1 = new HashMap<>(), m2 = new HashMap<>();\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                if (g[i][j] == 0) continue;\n                int idx = getIdx(i, j), root = find(idx);\n                if (a == -1) a = root;    \n                else if (a != root && b == -1) b = root;\n                if (root == a) {\n                    d1.addLast(new int[]{i, j});\n                    m1.put(idx, 0);\n                } else if (root == b) {\n                    d2.addLast(new int[]{i, j});\n                    m2.put(idx, 0);\n                }\n            }\n        }\n        while (!d1.isEmpty() && !d2.isEmpty()) {\n            int t = -1;\n            if (d1.size() < d2.size()) t = update(d1, m1, m2);\n            else t = update(d2, m2, m1);\n            if (t != -1) return t - 1;\n        }\n        return -1; // never\n    }\n    int update(Deque<int[]> d, Map<Integer, Integer> m1, Map<Integer, Integer> m2) {\n        int sz = d.size();\n        while (sz-- > 0) {\n            int[] info = d.pollFirst();\n            int x = info[0], y = info[1], idx = getIdx(x, y), step = m1.get(idx);\n            for (int[] di : dirs) {\n                int nx = x + di[0], ny = y + di[1], nidx = getIdx(nx, ny);\n                if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;\n                if (m1.containsKey(nidx)) continue;\n                if (m2.containsKey(nidx)) return step + 1 + m2.get(nidx);\n                d.addLast(new int[]{nx, ny});\n                m1.put(nidx, step + 1);\n            }\n        }\n        return -1;\n    }\n}\n```\nPython 代码:\n```Python\nimport queue\n\nclass Solution:\n    def shortestBridge(self, g: List[List[int]]) -> int:\n        def getIdx(x, y):\n            return x * n + y\n\n        def find(x):\n            if p[x] != x:\n                p[x] = find(p[x])\n            return p[x]\n\n        def union(x, y):\n            p[find(x)] = p[find(y)]\n\n        def update(d, cur, other):\n            sz = d.qsize()\n            while sz != 0:\n                x, y = d.get()\n                idx, step = getIdx(x, y), cur.get(getIdx(x, y))\n                for di in dirs:\n                    nx, ny = x + di[0], y + di[1]\n                    nidx = getIdx(nx, ny)\n                    if nx < 0 or nx >= n or ny < 0 or ny >= n:\n                        continue\n                    if nidx in cur:\n                        continue\n                    if nidx in other:\n                        return step + 1 + other.get(nidx)\n                    d.put([nx, ny])\n                    cur[nidx] = step + 1\n                sz -= 1\n            return -1\n\n        n = len(g)\n        p = [i for i in range(n * n + 10)]\n        dirs = [[1, 0], [-1, 0], [0, 1], [0, -1]]\n        for i in range(n):\n            for j in range(n):\n                if g[i][j] == 0:\n                    continue\n                for di in dirs:\n                    x, y = i + di[0], j + di[1]\n                    if x < 0 or x >= n or y < 0 or y >= n:\n                        continue\n                    if g[x][y] == 0:\n                        continue\n                    union(getIdx(i, j), getIdx(x, y))\n        a, b = -1, -1\n        d1, d2 = queue.Queue(), queue.Queue()\n        m1, m2 = {}, {}\n        for i in range(n):\n            for j in range(n):\n                if g[i][j] == 0:\n                    continue\n                idx, root = getIdx(i, j), find(getIdx(i, j))\n                if a == -1:\n                    a = root\n                elif a != root and b == -1:\n                    b = root\n                if a == root:\n                    d1.put([i, j])\n                    m1[idx] = 0\n                elif b == root:\n                    d2.put([i, j])\n                    m2[idx] = 0\n        while not d1.empty() and not d2.empty():\n            t = -1\n            if d1.qsize() < d2.qsize():\n                t = update(d1, m1, m2)\n            else:\n                t = update(d2, m2, m1)\n            if t != -1:\n                return t - 1\n        return -1\n```\nTypeScript 代码:\n```TypeScript\nlet n: number\nconst p = new Array<number>(10010).fill(0)\nconst dirs = [[0,1],[0,-1],[1,0],[-1,0]]\nfunction shortestBridge(g: number[][]): number {\n    function getIdx(x: number, y: number): number {\n        return x * n + y\n    }\n    function find(x: number): number {\n        if (p[x] != x) p[x] = find(p[x])\n        return p[x]\n    }\n    function union(x: number, y: number): void {\n        p[find(x)] = p[find(y)]\n    }\n    function update(d: Array<Array<number>>, m1: Map<number, number>, m2: Map<number, number>): number {\n        let sz = d.length\n        while (sz-- > 0) {\n            const info = d.shift()\n            const x = info[0], y = info[1], idx = getIdx(x, y), step = m1.get(idx)\n            for (const di of dirs) {\n                const nx = x + di[0], ny = y + di[1], nidx = getIdx(nx, ny)\n                if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue\n                if (m1.has(nidx)) continue\n                if (m2.has(nidx)) return step + 1 + m2.get(nidx)\n                d.push([nx, ny])\n                m1.set(nidx, step + 1)\n            }\n        }\n        return -1\n    }\n    n = g.length\n    for (let i = 0; i < n * n; i++) p[i] = i\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++) {\n            if (g[i][j] == 0) continue\n            for (const di of dirs) {\n                const x = i + di[0], y = j + di[1]\n                if (x < 0 || x >= n || y < 0 || y >= n) continue\n                if (g[x][y] == 0) continue\n                union(getIdx(i, j), getIdx(x, y))\n            }\n        }\n    }\n    let a = -1, b = -1\n    const d1 = new Array<number[]>(), d2 = new Array<number[]>()\n    const m1 = new Map<number, number>(), m2 = new Map<number, number>()\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++) {\n            if (g[i][j] == 0) continue\n            const idx = getIdx(i, j), root = find(idx)\n            if (a == -1) a = root\n            else if (a != root && b == -1) b = root\n            if (a == root) {\n                d1.push([i, j])\n                m1.set(idx, 0)\n            } else if (b == root) {\n                d2.push([i, j])\n                m2.set(idx, 0)\n            }\n        }\n    }\n    while (d1.length != 0 && d2.length != 0) {\n        let t = -1\n        if (d1.length < d2.length) t = update(d1, m1, m2)\n        else t = update(d2, m2, m1)\n        if (t != -1) return t - 1\n    }\n    return -1\n}\n```\n* 时间复杂度:$O(n^2)$\n* 空间复杂度:$O(n^2)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.934` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/931-940/937. 重新排列日志文件（简单）.md", "url_title": "937. 重新排列日志文件", "url": "https://leetcode-cn.com/problems/reorder-data-in-log-files/solution/by-ac_oier-ap28/", "difficulty": "简单", "tags": ["排序"], "question": "给你一个日志数组 logs。每条日志都是以空格分隔的字串,其第一个字为字母与数字混合的 标识符 。\n\n有两种不同类型的日志:\n\n* 字母日志:除标识符之外,所有字均由小写字母组成\n* 数字日志:除标识符之外,所有字均由数字组成\n\n请按下述规则将日志重新排序:\n\n* 所有 字母日志 都排在 数字日志 之前。\n* 字母日志 在内容不同时,忽略标识符后,按内容字母顺序排序;在内容相同时,按标识符排序。\n* 数字日志 应该保留原来的相对顺序。\n\n返回日志的最终顺序。\n\n示例 1:\n```\n输入:logs = [\"dig1 8 1 5 1\",\"let1 art can\",\"dig2 3 6\",\"let2 own kit dig\",\"let3 art zero\"]\n\n输出:[\"let1 art can\",\"let3 art zero\",\"let2 own kit dig\",\"dig1 8 1 5 1\",\"dig2 3 6\"]\n\n解释:\n字母日志的内容都不同,所以顺序为 \"art can\", \"art zero\", \"own kit dig\" 。\n数字日志保留原来的相对顺序 \"dig1 8 1 5 1\", \"dig2 3 6\" 。\n```\n示例 2:\n```\n输入:logs = [\"a1 9 2 3 1\",\"g1 act car\",\"zo4 4 7\",\"ab1 off key dog\",\"a8 act zoo\"]\n\n输出:[\"g1 act car\",\"a8 act zoo\",\"ab1 off key dog\",\"a1 9 2 3 1\",\"zo4 4 7\"]\n```\n\n提示:\n* $1 <= logs.length <= 100$\n* $3 <= logs[i].length <= 100$\n* $logs[i]$ 中,字与字之间都用 单个 空格分隔\n* 题目数据保证 $logs[i]$ 都有一个标识符,并且在标识符之后至少存在一个字", "solution": "### 自定义类 + 排序\n\n根据排序规则,我们需要对每个 $str[i]$ 进行裁剪处理,从而得知每个 $str[i]$ 是属于「字母日志」还是「数字日志」,以及得到 `sign` 部分和 `content` 部分。\n\n在排序过程中,每个 $str[i]$ 会被访问多次,为了让每个 $str[i]$ 只进行一次这样的预处理工作,我们可以自定义类,将这部分工作放到类的实例化去做。\n\n最后是简单将 $str[i]$ 转存成 `Log` 实例,自定义排序,用排序结果构造答案的基本逻辑。\n\n代码:\n```Java\nclass Solution {\n    class Log {\n        int type, idx;\n        String ori, sign, content;\n        Log(String s, int _idx) {\n            idx = _idx;\n            int n = s.length(), i = 0;\n            while (i < n && s.charAt(i) != ' ') i++;\n            sign = s.substring(0, i);\n            content = s.substring(i + 1);\n            ori = s;\n            type = Character.isDigit(content.charAt(0)) ? 1 : 0;\n        }\n    }\n    public String[] reorderLogFiles(String[] logs) {\n        int n = logs.length;\n        List<Log> list = new ArrayList<>();\n        for (int i = 0; i < n; i++) list.add(new Log(logs[i], i));\n        Collections.sort(list, (a, b)->{\n            if (a.type != b.type) return a.type - b.type;\n            if (a.type == 1) return a.idx - b.idx;\n            return !a.content.equals(b.content) ? a.content.compareTo(b.content) : a.sign.compareTo(b.sign);\n        });\n        String[] ans = new String[n];\n        for (int i = 0; i < n; i++) ans[i] = list.get(i).ori;\n        return ans;\n    }\n}\n```\n* 时间复杂度:将所有的 $str[i]$ 转存成 `Log` 实例,复杂度为 $O(n)$;排序复杂度为 $O(n\\log{n})$;构造答案复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.937` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/931-940/938. 二叉搜索树的范围和（简单）.md", "url_title": "938. 二叉搜索树的范围和", "url": "https://leetcode-cn.com/problems/range-sum-of-bst/solution/gong-shui-san-xie-yi-ti-shuang-jie-di-gu-q2fo/", "difficulty": "简单", "tags": ["树的搜索", "DFS", "BFS"], "question": "给定二叉搜索树的根结点 root,返回值位于范围 [low, high] 之间的所有结点的值的和。\n\n示例 1:\n\n```\n输入:root = [10,5,15,3,7,null,18], low = 7, high = 15\n\n输出:32\n```\n示例 2:\n\n```\n输入:root = [10,5,15,3,7,13,18,1,null,6], low = 6, high = 10\n\n输出:23\n```\n\n提示:\n* 树中节点数目在范围 [1, 2 * $10^4$] 内\n* 1 <= Node.val <= $10^5$\n* 1 <= low <= high <= $10^5$\n* 所有 Node.val 互不相同", "solution": "### 基本思路\n\n这又是众多「二叉搜索树遍历」题目中的一道。\n\n**二叉搜索树的中序遍历是有序的。**\n\n只要对其进行「中序遍历」即可得到有序列表,在遍历过程中判断节点值是否符合要求,对于符合要求的节点值进行累加即可。\n\n二叉搜索树的「中序遍历」有「迭代」和「递归」两种形式。**由于给定了值范围 $[low, high]$,因此可以在遍历过程中做一些剪枝操作,但并不影响时空复杂度。**\n\n---\n\n### 递归\n\n递归写法十分简单,属于树的遍历中最简单的实现方式。\n\n代码:\n```Java\nclass Solution {\n    int low, high;\n    int ans;\n    public int rangeSumBST(TreeNode root, int _low, int _high) {\n        low = _low; high = _high;\n        dfs(root);\n        return ans;\n    }\n    void dfs(TreeNode root) {\n        if (root == null) return;\n        dfs(root.left);\n        if (low <= root.val && root.val <= high) ans += root.val;\n        dfs(root.right);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 迭代\n\n迭代其实就是使用「栈」来模拟递归过程,也属于树的遍历中的常见实现形式。\n\n一般简单的面试中如果问到树的遍历,面试官都不会对「递归」解法感到满意,因此掌握「迭代/非递归」写法同样重要。\n\n代码:\n```Java\nclass Solution {\n    public int rangeSumBST(TreeNode root, int low, int high) {\n        int ans = 0;\n        Deque<TreeNode> d = new ArrayDeque<>();\n        while (root != null || !d.isEmpty()) {\n            while (root != null) {\n                d.addLast(root);\n                root = root.left;\n            }\n            root = d.pollLast();\n            if (low <= root.val && root.val <= high) {\n                ans += root.val;\n            }\n            root = root.right;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.938` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/931-940/940. 不同的子序列 II（困难）.md", "url_title": "940. 不同的子序列 II", "url": "https://leetcode.cn/problems/distinct-subsequences-ii/solution/by-ac_oier-ph94/", "difficulty": "困难", "tags": ["序列 DP", "动态规划"], "question": "给定一个字符串 `s`,计算 `s` 的 不同非空子序列 的个数。\n\n因为结果可能很大,所以返回答案需要对 $10^9 + 7$ 取余 。\n\n字符串的 子序列 是经由原字符串删除一些(也可能不删除)字符但不改变剩余字符相对位置的一个新字符串。\n\n例如,`\"ace\"` 是 `\"abcde\"` 的一个子序列,但 `\"aec\"` 不是。\n\n示例 1:\n```\n输入:s = \"abc\"\n\n输出:7\n\n解释:7 个不同的子序列分别是 \"a\", \"b\", \"c\", \"ab\", \"ac\", \"bc\", 以及 \"abc\"。\n```\n示例 2:\n```\n输入:s = \"aba\"\n\n输出:6\n\n解释:6 个不同的子序列分别是 \"a\", \"b\", \"ab\", \"ba\", \"aa\" 以及 \"aba\"。\n```\n示例 3:\n```\n输入:s = \"aaa\"\n\n输出:3\n\n解释:3 个不同的子序列分别是 \"a\", \"aa\" 以及 \"aaa\"。\n```\n\n提示:\n* $1 <= s.length <= 2000$\n* `s` 仅由小写英文字母组成", "solution": "### 序列 DP\n\n为了方便,我们令 `s` 下标从 $1$ 开始,定义 $f[i][j]$ 为考虑前 $i$ 个字符,且结尾字符为 $j$ 的不同子序列的个数,其中 $j$ 的范围为 $[0, 25]$ 代指小写字符 `a-z`。\n\n我们有显而易见的初始化条件 $f[0][X] = 0$,最终答案为 $\\sum_{i = 0}^{25}f[n][i]$。\n\n不失一般性考虑 $f[i][j]$ 该如何转移,根据 $s[i]$ 是否为 $j$ 进行分情况讨论:\n\n* $s[i] \\neq j$ : 由于状态定义限定了结尾字符必须是 $j$,因而 $s[i]$ 必然不会用到,此时有:\n\n$$\nf[i][j] = f[i - 1][j]\n$$\n\n* $s[i] = j$ : 此时 $s[i]$ 可作为结尾元素,同时由于我们统计的是「不同」的子序列个数,因而「以 $j$ 结尾的子序列方案数」与「以 $s[i]$ 结尾的子序列方案数」完全等价。\n    对于以 $s[i]$ 作为子序列结尾字符的方案数,容易想到其方案数等于「$s[i]$ 单独作为子序列」+「$s[i]$ 拼接在其余子序列后面形成新子序列」,即有:\n\n$$\nf[i][j] = 1 + \\sum_{k = 0}^{25} f[i - 1][k]\n$$\n\nJava 代码:\n```Java\nclass Solution {\n    int MOD = (int)1e9+7;\n    public int distinctSubseqII(String s) {\n        int n = s.length(), ans = 0;\n        int[][] f = new int[n + 1][26];\n        for (int i = 1; i <= n; i++) {\n            int c = s.charAt(i - 1) - 'a';\n            for (int j = 0; j < 26; j++) {\n                if (c != j) {\n                    f[i][j] = f[i - 1][j];\n                } else {\n                    int cur = 1;\n                    for (int k = 0; k < 26; k++) cur = (cur + f[i - 1][k]) % MOD;\n                    f[i][j] = cur;\n                }\n            }\n        }\n        for (int i = 0; i < 26; i++) ans = (ans + f[n][i]) % MOD;\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int distinctSubseqII(string s) {\n        int n = s.length(), MOD = 1e9 + 7;\n        vector<vector<int>> f(n + 1, vector<int>(26, 0));\n        for (int i = 1; i <= n; ++i) {\n            int c = s[i - 1] - 'a';\n            for (int j = 0; j < 26; ++j) {\n                if (c != j) {\n                    f[i][j] = f[i - 1][j];\n                } else {\n                    int cur = 1;\n                    for (int k = 0; k < 26; ++k) cur = (cur + f[i - 1][k]) % MOD;\n                    f[i][j] = cur;\n                }\n            }\n        }\n        int ans = 0;\n        for (int i = 0; i < 26; ++i) ans = (ans + f[n][i]) % MOD;\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def distinctSubseqII(self, s: str) -> int:\n        n, MOD = len(s), 1e9+7\n        f = [[0] * 26 for _ in range(n + 1)]\n        for i in range(1, n + 1):\n            c = ord(s[i - 1]) - ord('a')\n            for j in range(26):\n                f[i][j] = f[i - 1][j] if c != j else (1 + sum(f[i - 1])) % MOD\n        return int(sum(f[n]) % MOD)\n```\nTypeScript 代码:\n```TypeScript\nfunction distinctSubseqII(s: string): number {\n    const MOD = 1e9+7\n    let n = s.length, ans = 0\n    const f = new Array<Array<number>>(n + 1)\n    for (let i = 0; i <= n; i++) f[i] = new Array<number>(26).fill(0)\n    for (let i = 1; i <= n; i++) {\n        const c = s.charCodeAt(i - 1) - 'a'.charCodeAt(0)\n        for (let j = 0; j < 26; j++) {\n            if (c != j) {\n                f[i][j] = f[i - 1][j]\n            } else {\n                let cur = 1\n                for (let k = 0; k < 26; k++) cur = (cur + f[i - 1][k]) % MOD\n                f[i][j] = cur\n            }\n        }\n    }\n    for (let i = 0; i < 26; i++) ans = (ans + f[n][i]) % MOD\n    return ans\n}\n```\n* 时间复杂度:$O(n \\times C^2)$,其中 $C = 26$ 为字符集大小\n* 空间复杂度:$O(n \\times C)$\n\n---\n\n### 转移优化\n\n根据转移的依赖关系,实现上,我们并不需要真正记录每一个 $f[i][X]$,而可以直接记录一个总的不同子序列方案数 `ans`。\n\n这可以避免每次计算新状态时,都累加前一个 $f[i - 1][X]$ 的值,有效减低时空复杂度。\n\nJava 代码:\n```Java\nclass Solution {\n    int MOD = (int)1e9+7;\n    public int distinctSubseqII(String s) {\n        int n = s.length(), ans = 0;\n        int[] f = new int[26];\n        for (int i = 0; i < n; i++) {\n            int c = s.charAt(i) - 'a', prev = f[c];\n            f[c] = (ans + 1) % MOD;\n            ans = (ans + f[c]) % MOD;\n            ans = (ans - prev + MOD) % MOD;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int distinctSubseqII(string s) {\n        int n = s.length(), ans = 0, MOD = 1e9 + 7;\n        vector<int> f(26, 0);\n        for (int i = 0; i < n; ++i) {\n            int c = s[i] - 'a', prev = f[c];\n            f[c] = (ans + 1) % MOD;\n            ans = (ans + f[c]) % MOD;\n            ans = (ans - prev + MOD) % MOD;\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def distinctSubseqII(self, s: str) -> int:\n        n, MOD, ans = len(s), 1e9+7, 0\n        f = [0] * 26\n        for i in range(n):\n            c = ord(s[i]) - ord('a')\n            prev = f[c]\n            f[c] = (ans + 1) % MOD\n            ans = (ans + f[c] - prev) % MOD            \n        return int(ans)\n```\nTypeScript 代码:\n```TypeScript\nfunction distinctSubseqII(s: string): number {\n    const MOD = 1e9+7\n    let n = s.length, ans = 0\n    const f = new Array<number>(26).fill(0)\n    for (let i = 0; i < n; i++) {\n        const c = s.charCodeAt(i) - 'a'.charCodeAt(0), prev = f[c]\n        f[c] = (ans + 1) % MOD\n        ans = (ans + f[c]) % MOD\n        ans = (ans - prev + MOD) % MOD\n    }\n    return ans\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.940` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/941-950/942. 增减字符串匹配（简单）.md", "url_title": "942. 增减字符串匹配", "url": "https://leetcode.cn/problems/di-string-match/solution/by-ac_oier-pvjk/", "difficulty": "简单", "tags": ["贪心", "构造", "双指针"], "question": "由范围 $[0,n]$ 内所有整数组成的 $n + 1$ 个整数的排列序列可以表示为长度为 $n$ 的字符串 `s` ,其中:\n\n* 如果 `perm[i] < perm[i + 1]` ,那么 `s[i] == 'I'` \n* 如果 `perm[i] > perm[i + 1]` ,那么 `s[i] == 'D'` \n\n给定一个字符串 `s` ,重构排列 `perm` 并返回它。如果有多个有效排列 `perm`,则返回其中 任何一个 。\n\n示例 1:\n```\n输入:s = \"IDID\"\n\n输出:[0,4,1,3,2]\n```\n示例 2:\n```\n输入:s = \"III\"\n\n输出:[0,1,2,3]\n```\n示例 3:\n```\n输入:s = \"DDI\"\n\n输出:[3,2,0,1]\n```\n\n提示:\n* $1 <= s.length <= 10^5$\n* `s` 只包含字符 `\"I\"` 或 `\"D\"`", "solution": "### 构造 \n\n根据题意,我们需要设想一种「构造」方式,使得利用 `s` 创建序列的过程能够顺利进行。\n\n直觉上容易猜想到当 $s[i] = I$ 时,使用当前最小值进行构造,当 $s[i] = D$ 时使用当前最大值进行构造。\n\n使用「归纳法」来证明该做法的可行性(可用数的范围为 $[0, n]$,构造答案为 $ans$ 数组):\n\n1. 对于边界情况:起始最小值为 $0$,最大值为 $n$:\n\n    * 若有 $s[0] = I$,使用 $0$ 进行构造(即有 $ans[0] = 0$),可用数范围变为 $[1, n]$,后续再利用 $s[1]$ 进行构造 $ans[1]$ 时,可以确保始终满足 $ans[1] > ans[0]$,即上一步构造的正确性与下一步的决策无关;\n\n    * 若有 $s[1] = D$,使用 $n$ 进行构造(即有 $ans[0] = n$),可用数范围变为 $[0, n - 1]$,后续再利用 $s[1]$ 进行构造 $ans[1]$ 时,可以确保始终满足 $ans[1] < ans[0]$,即上一步构造的正确性与下一步的决策无关;\n\n2. 原问题的非边界情况:与边界情况等同,可用数仍是连续段,且当前的决策无须考虑额外的条件(上一步的构造的正确性已有保证)。\n\n此外,我们证明了该构造方法必然能够利用顺利构造出合法序列。\n\n该做法成立的本质为:**始终确保可用数是连续段,每次选择位于边界的数进行构造,可以直接确保当前构造回合的正确性,从而让边界情况的归纳推理可以运用到每个构造回合。**\n\n代码:\n```Java\nclass Solution {\n    public int[] diStringMatch(String s) {\n        int n = s.length(), l = 0, r = n, idx = 0;\n        int[] ans = new int[n + 1];\n        for (int i = 0; i < n; i++) {\n            if (s.charAt(i) == 'I') ans[idx++] = l++;\n            else ans[idx++] = r--;\n        }\n        ans[idx] = l;\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.942` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/941-950/943. 最短超级串（困难）.md", "url_title": "943. 最短超级串", "url": "https://leetcode.cn/problems/find-the-shortest-superstring/solution/gong-shui-san-xie-zhuang-ya-dp-yun-yong-p6hlz/", "difficulty": "困难", "tags": ["状压 DP", "位运算"], "question": "给定一个字符串数组 `words`,找到以 `words` 中每个字符串作为子字符串的最短字符串。如果有多个有效最短字符串满足题目条件,返回其中 任意一个 即可。\n\n我们可以假设 `words` 中没有字符串是 `words` 中另一个字符串的子字符串。\n\n示例 1:\n```\n输入:words = [\"alex\",\"loves\",\"leetcode\"]\n\n输出:\"alexlovesleetcode\"\n\n解释:\"alex\",\"loves\",\"leetcode\" 的所有排列都会被接受。\n```\n示例 2:\n```\n输入:words = [\"catg\",\"ctaagt\",\"gcta\",\"ttca\",\"atgcatc\"]\n\n输出:\"gctaagttcatgcatc\"\n```\n\n提示:\n* $1 <= words.length <= 12$\n* $1 <= words[i].length <= 20$\n* `words[i]` 由小写英文字母组成\n* `words` 中的所有字符串互不相同", "solution": "### 状压 DP\n\n为了方便,将 `words` 记为 `ws`。\n\n预处理二维数组 `g` 来表示字符串 `ws[i]` 和 `ws[j]` 的重叠部分的长度:若 `g[i][j] = len` 代表字符串 `ws[i]` 长度为 `len`  的后缀与字符串 `ws[j]` 长度为 `len` 的前缀相同。\n\n另外用一个二进制数 `status` 来代表当前超级串 `ans` 对 `ws` 的使用(覆盖)情况:**若 `status` 的第 `i` 位为 `1` 代表字符串 `ws[i]` 已被使用(即 `ws[i]` 已是 `ans` 的子串),若 `status` 的第 `i` 位为 `0` 代表 `ws[i]` 未被使用。**\n\n我们知道,当所有的 $g[i][j] = 0$ 时,代表所有拼接方式长度均为 $\\sum_{i = 0}^{n - 1}ws[i].length$,即不能通过产生重叠部分来缩短超级串的长度。\n\n因此,**最小化超级串 `ans` 的长度等价于最大化重叠部分的长度**。\n\n定义 $f[s][i]$ 代表当前状态为 `s` 且当前最后一个使用到的字符串为 `ws[i]` (当前超级串 `ans` 的结尾部分为 `ws[i]`)时的最大重合长度。\n\n最终超级串的长度为所有字符串的总长度 $\\sum_{i = 0}^{n - 1}ws[i].length$ 减去最大重合长度 $\\max(f[2^n - 1][i])$。\n\n不失一般性考虑 $f[s][i]$ 可用于更新哪些状态,我们可枚举接在字符串 `ws[i]` 后面的字符串 `ws[j]` 为何值:\n\n1. 由于每个字符串只能使用一次,转移需要满足 `s` 的第 `i` 位为 $1$,`s` 的第 `j` 位为 $0$ 的前提条件,含义为 `ws[i]` 已被使用,而 `ws[j]` 未被使用\n2. 满足前提条件 $1$,代表 `ws[j]` 可接在 `ws[i]` 后面,此时有状态转移方程: \n\t$$\n\t    f[s | (1 << j)][j] = f[s][i] + g[i][j]\n  $$\n\n接下来,考虑如何构建具体方案。\n\n**使用二维数组 $p[s][i]$ 记录每个状态是由哪个前驱转移而来**:若有 $p[s][i] = j$,代表取得最大重叠长度过程中,字符串 `ws[j]` 接在 `ws[i]` 后面。\n\n我们从后往前对 `ans` 进行构造,若 `ans = ws[0] + ws[1] + ... + ws[k - 1] + ws[k]`,我们是先找 `ws[k]`,再通过 `ws[k]` 找 `ws[k - 1]`,直到将整个 `ans` 构建出来。\n\n构造过程中使用变量解释如下:\n\n* `ans` 为具体的超级串\n* `status` 代表当前还有哪些字符串待拼接到,初始化为 $2^n - 1$,代表还没有任何字符串拼接到 `ans` 中\n* `idx` 代表当前处理到的字符串下标,初始化通过遍历所有的 $f[2^n - 1][i]$ 找到合适的 $i$ 作为 `idx`\n* `last` 代表前一个处理到字符串下标,初始化为 `-1`\n\n一些细节:当 `last` 不为初始值 `-1` 时,需要跳过 `ws[idx]` 与 `ws[last]` 的重复部分进行拼接。\n\nJava 代码:\n```Java\nclass Solution {\n    public String shortestSuperstring(String[] ws) {\n        int n = ws.length, mask = 1 << n;\n        int[][] g = new int[n][n];\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                String a = ws[i], b = ws[j];\n                int l1 = a.length(), l2 = b.length(), len = Math.min(l1, l2);\n                for (int k = len; k >= 1; k--) {\n                    if (a.substring(l1 - k).equals(b.substring(0, k))) {\n                        g[i][j] = k;\n                        break;\n                    }\n                }\n            }\n        }\n        int[][] f = new int[mask][n], p = new int[mask][n];\n        for (int s = 0; s < mask; s++) {\n            for (int i = 0; i < n; i++) {\n                if (((s >> i) & 1) == 0) continue;\n                for (int j = 0; j < n; j++) {\n                    if (((s >> j) & 1) == 1) continue;\n                    if (f[s | (1 << j)][j] <= f[s][i] + g[i][j]) {\n                        f[s | (1 << j)][j] = f[s][i] + g[i][j];\n                        p[s | (1 << j)][j] = i;\n                    }\n                }\n            }\n        }\n        int max = f[mask - 1][0], idx = 0, last = -1, status = mask - 1;\n        for (int i = 1; i < n; i++) {\n            if (max < f[mask - 1][i]) {\n                max = f[mask - 1][i];\n                idx = i;\n            }\n        }\n        String ans = \"\";\n        while (status != 0) {\n            if (last == -1) ans = ws[idx];\n            else ans = ws[idx].substring(0, ws[idx].length() - g[idx][last]) + ans;\n            last = idx;\n            idx = p[status][idx];\n            status ^= (1 << last);\n        }\n        return ans;\n    }\n}\n```\nPython 代码:\n```Python\nclass Solution:\n    def shortestSuperstring(self, ws: List[str]) -> str:\n        n, mask = len(ws), 1 << len(ws)\n        g = [[0 for _ in range(n)] for _ in range(n)]\n        for i in range(n):\n            for j in range(n):\n                a, b = ws[i], ws[j]\n                l1, l2 = len(a), len(b)\n                length = min(l1, l2)\n                for k in range(length, 0, -1):\n                    if a[l1 - k:] == b[:k]:\n                        g[i][j] = k\n                        break\n        f = [[0 for _ in range(n)] for _ in range(mask)]\n        p = [[0 for _ in range(n)] for _ in range(mask)]\n        for s in range(mask):\n            for i in range(n):\n                if (s >> i) & 1 == 0:\n                    continue\n                for j in range(n):\n                    if (s >> j) & 1 == 1:\n                        continue\n                    if f[s | (1 << j)][j] <= f[s][i] + g[i][j]:\n                        f[s | (1 << j)][j] = f[s][i] + g[i][j]\n                        p[s | (1 << j)][j] = i\n        \n        max_val = f[mask - 1][0]\n        idx, last, status = 0, -1, mask - 1        \n        for i in range(1, n):\n            if max_val < f[mask - 1][i]:\n                max_val = f[mask - 1][i]\n                idx = i\n        ans = \"\"\n        while status != 0:\n            if last == -1:\n                ans = ws[idx]\n            else:\n                ans = ws[idx][:len(ws[idx]) - g[idx][last]] + ans\n            last = idx\n            idx = p[status][idx]\n            status ^= 1 << last\n        return ans\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    string shortestSuperstring(vector<string>& ws) {\n int n = ws.size(), mask = 1 << n;\n        vector<vector<int>> g(n, vector<int>(n, 0));\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                string a = ws[i], b = ws[j];\n                int l1 = a.length(), l2 = b.length(), len = min(l1, l2);\n                for (int k = len; k >= 1; k--) {\n                    if (a.substr(l1 - k) == b.substr(0, k)) {\n                        g[i][j] = k;\n                        break;\n                    }\n                }\n            }\n        }\n        vector<vector<int>> f(mask, vector<int>(n, 0)), p(mask, vector<int>(n, 0));\n        for (int s = 0; s < mask; s++) {\n            for (int i = 0; i < n; i++) {\n                if (((s >> i) & 1) == 0) continue;\n                for (int j = 0; j < n; j++) {\n                    if (((s >> j) & 1) == 1) continue;\n                    if (f[s | (1 << j)][j] <= f[s][i] + g[i][j]) {\n                        f[s | (1 << j)][j] = f[s][i] + g[i][j];\n                        p[s | (1 << j)][j] = i;\n                    }\n                }\n            }\n        }\n        int max = f[mask - 1][0], idx = 0, last = -1, status = mask - 1;\n        for (int i = 1; i < n; i++) {\n            if (max < f[mask - 1][i]) {\n                max = f[mask - 1][i];\n                idx = i;\n            }\n        }\n        string ans = \"\";\n        while (status != 0) {\n            if (last == -1) ans = ws[idx];\n            else ans = ws[idx].substr(0, ws[idx].length() - g[idx][last]) + ans;\n            last = idx;\n            idx = p[status][idx];\n            status ^= (1 << last);\n        }\n        return ans;\n    }\n};\n```\nTypeScript 代码:\n```TypeScript\nfunction shortestSuperstring(ws: string[]): string {\n    const n = ws.length, mask = 1 << n;\n    const g = new Array(n).fill(0).map(() => new Array(n).fill(0));\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++) {\n            const a = ws[i], b = ws[j];\n            const l1 = a.length, l2 = b.length;\n            const len = Math.min(l1, l2);\n            for (let k = len; k >= 1; k--) {\n                if (a.substring(l1 - k) === b.substring(0, k)) {\n                    g[i][j] = k;\n                    break;\n                }\n            }\n        }\n    }\n    const f = new Array(mask).fill(0).map(() => new Array(n).fill(0));\n    const p = new Array(mask).fill(0).map(() => new Array(n).fill(0));\n    for (let s = 0; s < mask; s++) {\n        for (let i = 0; i < n; i++) {\n            if (((s >> i) & 1) === 0) continue;\n            for (let j = 0; j < n; j++) {\n                if (((s >> j) & 1) === 1) continue;\n                if (f[s | (1 << j)][j] <= f[s][i] + g[i][j]) {\n                    f[s | (1 << j)][j] = f[s][i] + g[i][j];\n                    p[s | (1 << j)][j] = i;\n                }\n            }\n        }\n    }\n    let max = f[mask - 1][0], idx = 0, last = -1, status = mask - 1;\n    for (let i = 1; i < n; i++) {\n        if (max < f[mask - 1][i]) {\n            max = f[mask - 1][i];\n            idx = i;\n        }\n    }\n    let ans = \"\";\n    while (status != 0) {\n        if (last === -1) ans = ws[idx];    \n        else ans = ws[idx].substring(0, ws[idx].length - g[idx][last]) + ans;\n        last = idx;\n        idx = p[status][idx];\n        status ^= (1 << last);\n    }\n    return ans;\n}\n```\n* 时间复杂度:将字符串 $ws[i]$ 的最大长度记为 $C = 20$,预处理复杂度为 $O(n^2 \\times C)$;状态数量为 $2^n$,`DP` 复杂度为 $O(2^n \\times n^2)$。构造答案复杂度为 $O(n)$。整体复杂度为 $O(2^n\\times n^2)$\n* 空间复杂度:$O(2^n \\times n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.943` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/941-950/944. 删列造序（简单）.md", "url_title": "944. 删列造序", "url": "https://leetcode.cn/problems/delete-columns-to-make-sorted/solution/by-ac_oier-smoz/", "difficulty": "简单", "tags": ["模拟"], "question": "给你由 $n$ 个小写字母字符串组成的数组 `strs`,其中每个字符串长度相等。\n\n这些字符串可以每个一行,排成一个网格。例如,`strs = [\"abc\", \"bce\", \"cae\"]` 可以排列为:\n```\nabc\nbce\ncae\n```\n你需要找出并删除 不是按字典序升序排列的 列。在上面的例子(下标从 $0$ 开始)中,列 $0$(`'a', 'b', 'c'`)和列 $2$(`'c', 'e', 'e'`)都是按升序排列的,而列 $1$(`'b', 'c', 'a'`)不是,所以要删除列 $1$ 。\n\n返回你需要删除的列数。\n\n示例 1:\n```\n输入:strs = [\"cba\",\"daf\",\"ghi\"]\n\n输出:1\n\n解释:网格示意如下:\n  cba\n  daf\n  ghi\n列 0 和列 2 按升序排列,但列 1 不是,所以只需要删除列 1 。\n```\n示例 2:\n```\n输入:strs = [\"a\",\"b\"]\n\n输出:0\n\n解释:网格示意如下:\n  a\n  b\n只有列 0 这一列,且已经按升序排列,所以不用删除任何列。\n```\n示例 3:\n```\n输入:strs = [\"zyx\",\"wvu\",\"tsr\"]\n\n输出:3\n\n解释:网格示意如下:\n  zyx\n  wvu\n  tsr\n所有 3 列都是非升序排列的,所以都要删除。\n```\n\n提示:\n* $n == strs.length$\n* $1 <= n <= 100$\n* $1 <= strs[i].length <= 1000$\n* `strs[i]` 由小写英文字母组成", "solution": "### 模拟\n\n根据题意进行模拟即可。\n\n代码:\n```Java\nclass Solution {\n    public int minDeletionSize(String[] strs) {\n        int n = strs.length, m = strs[0].length(), ans = 0;\n        out:for (int i = 0; i < m; i++) {\n            for (int j = 0, cur = -1; j < n; j++) {\n                int t = (int) strs[j].charAt(i);\n                if (t < cur && ++ans >= 0) continue out;\n                cur = t;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.942` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/941-950/946. 验证栈序列（中等）.md", "url_title": "946. 验证栈序列", "url": "https://leetcode.cn/problems/validate-stack-sequences/solution/by-ac_oier-84qd/", "difficulty": "中等", "tags": ["模拟", "栈", "双指针"], "question": "给定 `pushed` 和 `popped` 两个序列,每个序列中的 值都不重复,只有当它们可能是在最初空栈上进行的推入 `push` 和弹出 `pop` 操作序列的结果时,返回 `true`;否则,返回 `false`。\n\n示例 1:\n```\n输入:pushed = [1,2,3,4,5], popped = [4,5,3,2,1]\n\n输出:true\n\n解释:我们可以按以下顺序执行:\npush(1), push(2), push(3), push(4), pop() -> 4,\npush(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1\n```\n示例 2:\n```\n输入:pushed = [1,2,3,4,5], popped = [4,3,5,1,2]\n\n输出:false\n\n解释:1 不能在 2 之前弹出。\n```\n\n提示:\n* $1 <= pushed.length <= 1000$\n* $0 <= pushed[i] <= 1000$\n* `pushed` 的所有元素 互不相同\n* $popped.length = pushed.length$\n* `popped` 是 `pushed` 的一个排列", "solution": "### 栈运用模拟\n\n根据题意,利用元素各不相同,我们使用一个栈来处理 `pushed` 数组,每次将 $pushed[i]$ 放入栈中,然后比较当前栈顶元素是否与待弹出元素相同(使用变量 `j` 来代指当前待弹出元素下标),若相等则弹栈并进行 `j` 自增,当所有的元素处理完后,栈为空说明栈序列合法。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean validateStackSequences(int[] pushed, int[] popped) {\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0, j = 0; i < pushed.length; i++) {\n            d.addLast(pushed[i]);\n            while (!d.isEmpty() && d.peekLast() == popped[j] && ++j >= 0) d.pollLast(); \n        }\n        return d.isEmpty();\n    }\n}\n```\nTypescript 代码:\n```Typescript\nfunction validateStackSequences(pushed: number[], popped: number[]): boolean {\n    let n = pushed.length, he = 0, ta = 0\n    const stk: number[] = new Array<number>(n).fill(0)\n    for (let i = 0, j = 0; i < n; i++) {\n        stk[ta++] = pushed[i]\n        while (he < ta && stk[ta - 1] == popped[j] && ++j >= 0) ta--\n    }\n    return he == ta\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 双指针\n\n我们也可以直接利用 `pushed` 充当栈,使用变量 `idx` 代指栈顶下标,变量 `j` 指向 `popped` 中待弹出的元素。\n\n该做法好处无须额外空间,坏处是会修改入参数组。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean validateStackSequences(int[] pushed, int[] popped) {\n        int n = pushed.length, idx = 0;\n        for (int i = 0, j = 0; i < n; i++) {\n            pushed[idx++] = pushed[i];\n            while (idx > 0 && pushed[idx - 1] == popped[j] && ++j >= 0) idx--;\n        }\n        return idx == 0;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction validateStackSequences(pushed: number[], popped: number[]): boolean {\n    let n = pushed.length, idx = 0\n    for (let i = 0, j = 0; i < n; i++) {\n        pushed[idx++] = pushed[i]\n        while (idx > 0 && pushed[idx - 1] == popped[j] && ++j >= 0) idx--\n    }\n    return idx == 0\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 加餐\n\n**加餐一道同类型题目 : [常规栈运用题](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247493276&idx=1&sn=b4b1ff8e6b1794f4f2e4327399755b0c)🎉🎉**", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.946` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/941-950/950. 按递增顺序显示卡牌（中等）.md", "url_title": "950. 按递增顺序显示卡牌", "url": "https://leetcode.cn/problems/reveal-cards-in-increasing-order/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-nu48/", "difficulty": "中等", "tags": ["模拟", "队列", "排序", "构造"], "question": "牌组中的每张卡牌都对应有一个唯一的整数。你可以按你想要的顺序对这套卡片进行排序。\n\n最初,这些卡牌在牌组里是正面朝下的(即,未显示状态)。\n\n现在,重复执行以下步骤,直到显示所有卡牌为止:\n\n1. 从牌组顶部抽一张牌,显示它,然后将其从牌组中移出。\n2. 如果牌组中仍有牌,则将下一张处于牌组顶部的牌放在牌组的底部。\n3. 如果仍有未显示的牌,那么返回步骤 1。否则,停止行动。\n\n返回能以递增顺序显示卡牌的牌组顺序。\n\n答案中的第一张牌被认为处于牌堆顶部。\n\n示例:\n```\n输入:[17,13,11,2,3,5,7]\n\n输出:[2,13,3,11,5,17,7]\n\n解释:\n我们得到的牌组顺序为 [17,13,11,2,3,5,7](这个顺序不重要),然后将其重新排序。\n重新排序后,牌组以 [2,13,3,11,5,17,7] 开始,其中 2 位于牌组的顶部。\n我们显示 2,然后将 13 移到底部。牌组现在是 [3,11,5,17,7,13]。\n我们显示 3,并将 11 移到底部。牌组现在是 [5,17,7,13,11]。\n我们显示 5,然后将 17 移到底部。牌组现在是 [7,13,11,17]。\n我们显示 7,并将 13 移到底部。牌组现在是 [11,17,13]。\n我们显示 11,然后将 17 移到底部。牌组现在是 [13,17]。\n我们展示 13,然后将 17 移到底部。牌组现在是 [17]。\n我们显示 17。\n由于所有卡片都是按递增顺序排列显示的,所以答案是正确的。\n```\n\n提示:\n* $1 <= A.length <= 1000$\n* $1 <= A[i] <= 10^6$\n* 对于所有的 `i != j`,`A[i] != A[j]`", "solution": "### 模拟\n\n根据题意,我们可以先使用双端队列对 `deck` 进行一次模拟,并用哈希表记下每个元素 $deck[i]$ 的显示顺序(利用 $deck[i]$ 元素各不相同,可直接用 $deck[i]$ 作为 `key`)。\n\n随后考虑如何通过哈希表来构建答案数组 `ans`。\n\n假设原数组中的 $deck[i]$ 为首次显示的卡牌,那么 $ans[i]$ 应该放置 `deck` 中最小的元素,同理若 $deck[j]$ 若最后显示的卡牌,则 $ans[j]$ 应放置 `deck` 中的最大元素。\n\n为了方便找 `deck` 中第 $k$ 大元素,可对 `deck` 进行拷贝并排序。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] deckRevealedIncreasing(int[] deck) {\n        int n = deck.length, idx = 0;\n        Map<Integer, Integer> map = new HashMap<>();\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int x : deck) d.addLast(x);\n        while (!d.isEmpty()) {\n            map.put(d.pollFirst(), idx++);\n            if (!d.isEmpty()) d.addLast(d.pollFirst());\n        }\n        int[] ans = new int[n], temp = deck.clone();\n        Arrays.sort(temp);\n        for (int i = 0; i < n; i++) ans[i] = temp[map.get(deck[i])];\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> deckRevealedIncreasing(vector<int>& deck) {\n        int n = deck.size(), idx = 0;\n        map<int, int> map;\n        deque<int> d;\n        for (int x : deck) d.push_back(x);\n        while (!d.empty()) {\n            map[d.front()] = idx++;\n            d.pop_front();\n            if (!d.empty()) {\n                d.push_back(d.front());\n                d.pop_front();\n            }\n        }\n        vector<int> ans(n);\n        vector<int> temp = deck;\n        sort(temp.begin(), temp.end());\n        for (int i = 0; i < n; i++) ans[i] = temp[map[deck[i]]];\n        return ans;\n    }\n};\n```\nPython3 代码:\n```Python\nclass Solution:\n    def deckRevealedIncreasing(self, deck: List[int]) -> List[int]:\n        n, idx = len(deck), 0\n        map = {}\n        d = deque(deck)\n        while d:\n            map[d.popleft()] = idx\n            idx += 1\n            if d:\n                d.append(d.popleft())\n        temp = sorted(deck)\n        return [temp[map[deck[i]]] for i in range(n)]\n```\nTypeScript 代码:\n```TypeScript\nfunction deckRevealedIncreasing(deck: number[]): number[] {\n    let n = deck.length, idx = 0;\n    const map = {};\n    const d = [...deck];\n    while (d.length > 0) {\n        map[d.shift()!] = idx++;\n        if (d.length > 0) d.push(d.shift()!);\n    }\n    const ans = new Array(n);\n    const temp = [...deck].sort((a, b) => a - b);\n    for (let i = 0; i < n; i++) ans[i] = temp[map[deck[i]]];\n    return ans;\n};\n```\n* 时间复杂度:使用队列模拟一次操作的复杂度为 $O(n)$(每个元素只有一次出入队机会);对原数组进行复制并排序的复杂度 $O(n\\log{n})$;构建答案复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.950` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/951-960/952. 按公因数计算最大组件大小（困难）.md", "url_title": "952. 按公因数计算最大组件大小", "url": "https://leetcode.cn/problems/largest-component-size-by-common-factor/solution/by-ac_oier-mw04/", "difficulty": "困难", "tags": ["数学", "并查集"], "question": "给定一个由不同正整数的组成的非空数组 `nums`,考虑下面的图:\n\n* 有 `nums.length` 个节点,按从 `nums[0]` 到 `nums[nums.length - 1]` 标记;\n* 只有当 `nums[i]` 和 `nums[j]` 共用一个大于 $1$ 的公因数时,`nums[i]` 和 `nums[j]`之间才有一条边。\n\n返回 图中最大连通组件的大小 。\n\n示例 1:\n\n```\n输入:nums = [4,6,15,35]\n\n输出:4\n```\n示例 2:\n\n```\n输入:nums = [20,50,9,63]\n\n输出:2\n```\n示例 3:\n\n```\n输入:nums = [2,3,6,7,4,12,21,39]\n\n输出:8\n```\n\n提示:\n* $1 <= nums.length <= 2 \\times 10^4$\n* $1 <= nums[i] <= 10^5$\n* `nums` 中所有值都 不同", "solution": "### 枚举质因数 + 并查集\n\n先考虑如何使用 `nums` 进行建图,`nums` 大小为 $n = 2 \\times 10^4$,枚举所有点对并通过判断两数之间是否存在边的做法复杂度为 $O(n^2\\sqrt{M})$(其中 $M = 1e5$ 为 $nums[i]$ 的最大值),无须考虑。\n\n而不通过「枚举点 + 求公约数」的建图方式,可以对 $nums[i]$ 进行质因数分解(复杂度为 $O(\\sqrt{nums[i]})$),假设其分解出来的质因数集合为 $S$,我们可以建立从 $S_{k}$ 到 $nums[i]$ 的映射关系,若 $nums[i]$ 与 $nums[j]$ 存在边,则 $nums[i]$ 和 $nums[j]$ 至少会被同一个质因数所映射。\n\n维护连通块数量可以使用「并查集」来做,维护映射关系可以使用「哈希表」来做。\n\n维护映射关系时,使用质因数为 `key`,下标值 $i$ 为 `value`(我们使用下标 $i$ 作为点编号,而不是使用 $nums[i]$ ,是利用$nums[i]$ 各不相同,从而将并查集数组大小从 $1e5$ 收窄到 $2 \\times 10^4$)。\n\n同时在使用「并查集」维护连通块时,同步维护每个连通块大小 `sz` 以及当前最大的连通块大小 `ans`。\n\nJava 代码:\n```Java\nclass Solution {\n    static int N = 20010;\n    static int[] p = new int[N], sz = new int[N];\n    int ans = 1;\n    int find(int x) {\n        if (p[x] != x) p[x] = find(p[x]);\n        return p[x];\n    }\n    void union(int a, int b) {\n        if (find(a) == find(b)) return ;\n        sz[find(a)] += sz[find(b)];\n        p[find(b)] = p[find(a)];\n        ans = Math.max(ans, sz[find(a)]);\n    }\n    public int largestComponentSize(int[] nums) {\n        int n = nums.length;\n        Map<Integer, List<Integer>> map = new HashMap<>();\n        for (int i = 0; i < n; i++) {\n            int cur = nums[i];\n            for (int j = 2; j * j <= cur; j++) {\n                if (cur % j == 0) add(map, j, i);\n                while (cur % j == 0) cur /= j;\n            }\n            if (cur > 1) add(map, cur, i);\n        }\n        for (int i = 0; i <= n; i++) {\n            p[i] = i; sz[i] = 1;\n        }\n        for (int key : map.keySet()) {\n            List<Integer> list = map.get(key);\n            for (int i = 1; i < list.size(); i++) union(list.get(0), list.get(i));\n        }\n        return ans;\n    }\n    void add(Map<Integer, List<Integer>> map, int key, int val) {\n        List<Integer> list = map.getOrDefault(key, new ArrayList<>());\n        list.add(val);\n        map.put(key, list);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nconst N = 20010\nconst p: number[] = new Array<number>(N), sz = new Array<number>(N)\nlet ans = 0\nfunction find(x: number): number {\n    if (p[x] != x) p[x] = find(p[x])\n    return p[x]\n}\nfunction union(a: number, b: number): void {\n    if (find(a) == find(b)) return \n    sz[find(a)] += sz[find(b)]\n    p[find(b)] = p[find(a)]\n    ans = Math.max(ans, sz[find(a)])\n}\nfunction largestComponentSize(nums: number[]): number {\n    const n = nums.length\n    const map: Map<number, Array<number>> = new Map<number, Array<number>>()\n    for (let i = 0; i < n; i++) {\n        let cur = nums[i]\n        for (let j = 2; j * j <= cur; j++) {\n            if (cur % j == 0) add(map, j, i)\n            while (cur % j == 0) cur /= j\n        }\n        if (cur > 1) add(map, cur, i)\n    }\n    for (let i = 0; i < n; i++) {\n        p[i] = i; sz[i] = 1\n    }\n    ans = 1\n    for (const key of map.keys()) {\n        const list = map.get(key)\n        for (let i = 1; i < list.length; i++) union(list[0], list[i])\n    }\n    return ans\n};\nfunction add(map: Map<number, Array<number>>, key: number, val: number): void {\n    let list = map.get(key)\n    if (list == null) list = new Array<number>()\n    list.push(val)\n    map.set(key, list)\n}\n```\n* 时间复杂度:$O(n\\sqrt{M})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.952` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/951-960/953. 验证外星语词典（简单）.md", "url_title": "953. 验证外星语词典", "url": "https://leetcode.cn/problems/verifying-an-alien-dictionary/solution/by-ac_oier-sxf1/", "difficulty": "简单", "tags": ["排序", "模拟"], "question": "某种外星语也使用英文小写字母,但可能顺序 `order` 不同。字母表的顺序(`order`)是一些小写字母的排列。\n\n给定一组用外星语书写的单词 `words`,以及其字母表的顺序 `order`,只有当给定的单词在这种外星语中按字典序排列时,返回 `true`;否则,返回 `false`。\n\n示例 1:\n```\n输入:words = [\"hello\",\"leetcode\"], order = \"hlabcdefgijkmnopqrstuvwxyz\"\n\n输出:true\n\n解释:在该语言的字母表中,'h' 位于 'l' 之前,所以单词序列是按字典序排列的。\n```\n示例 2:\n```\n输入:words = [\"word\",\"world\",\"row\"], order = \"worldabcefghijkmnpqstuvxyz\"\n\n输出:false\n\n解释:在该语言的字母表中,'d' 位于 'l' 之后,那么 words[0] > words[1],因此单词序列不是按字典序排列的。\n```\n示例 3:\n```\n输入:words = [\"apple\",\"app\"], order = \"abcdefghijklmnopqrstuvwxyz\"\n\n输出:false\n\n解释:当前三个字符 \"app\" 匹配时,第二个字符串相对短一些,然后根据词典编纂规则 \"apple\" > \"app\",因为 'l' > '∅',其中 '∅' 是空白字符,定义为比任何其他字符都小(更多信息)。\n```\n\n提示:\n* $1 <= words.length <= 100$\n* $1 <= words[i].length <= 20$\n* $order.length == 26$\n* 在 `words[i]` 和 `order` 中的所有字符都是英文小写字母。", "solution": "### 自定义排序\n\n为了快速判断某两个字符在字典序的前后关系,先使用一个大小与字符集相等的数组对 `order` 进行转存。\n\n然后对 `words` 进行拷贝复制得到 `clone`,并执行自定义排序,最后根据排序前后顺序是否相等来返回答案。\n\n代码:\n```Java\nclass Solution {\n    public boolean isAlienSorted(String[] words, String order) {\n        int[] ord = new int[26];\n        for (int i = 0; i < 26; i++) ord[order.charAt(i) - 'a'] = i;\n        String[] clone = words.clone();\n        Arrays.sort(clone, (a, b)->{\n            int n = a.length(), m = b.length();\n            int i = 0, j = 0;\n            while (i < n && j < m) {\n                int c1 = a.charAt(i) - 'a', c2 = b.charAt(j) - 'a';\n                if (c1 != c2) return ord[c1] - ord[c2];\n                i++; j++;\n            }\n            if (i < n) return 1;\n            if (j < m) return -1;\n            return 0;\n        });\n        int n = words.length;\n        for (int i = 0; i < n; i++) {\n            if (!clone[i].equals(words[i])) return false;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(\\log{n})$\n\n---\n\n### 模拟\n\n更近一步,我们无须对整个数组进行排序,只需要将「自定义排序」中的规则抽出来,判断相邻两个字符串是满足字典序排序即可。\n\n代码:\n```Java\nclass Solution {\n    int[] ord = new int[26];\n    int check(String a, String b) {\n        int n = a.length(), m = b.length();\n        int i = 0, j = 0;\n        while (i < n && j < m) {\n            int c1 = a.charAt(i) - 'a', c2 = b.charAt(j) - 'a';\n            if (c1 != c2) return ord[c1] - ord[c2];\n            i++; j++;\n        }\n        if (i < n) return 1;\n        if (j < m) return -1;\n        return 0;\n    }\n    public boolean isAlienSorted(String[] words, String order) {\n        for (int i = 0; i < 26; i++) ord[order.charAt(i) - 'a'] = i;\n        int n = words.length;\n        for (int i = 1; i < n; i++) {\n            if (check(words[i - 1], words[i]) > 0) return false;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(C)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.953` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/951-960/954. 二倍数对数组（中等）.md", "url_title": "954. 二倍数对数组", "url": "https://leetcode-cn.com/problems/array-of-doubled-pairs/solution/by-ac_oier-d1z7/", "difficulty": "中等", "tags": ["优先队列(堆)", "构造", "哈希表", "拓扑排序"], "question": "给定一个长度为偶数的整数数组 `arr`,只有对 `arr` 进行重组后可以满足 “对于每个$ 0 <= i < len(arr) / 2$,都有 $arr[2 \\times i + 1] = 2 \\times arr[2 \\times i]$” 时,返回 `true`;否则,返回 `false`。\n\n示例 1:\n```\n输入:arr = [3,1,3,6]\n\n输出:false\n```\n示例 2:\n```\n输入:arr = [2,1,2,6]\n\n输出:false\n```\n示例 3:\n```\n输入:arr = [4,-2,2,-4]\n\n输出:true\n\n解释:可以用 [-2,-4] 和 [2,4] 这两组组成 [-2,-4,2,4] 或是 [2,4,-2,-4]\n```\n\n提示:\n* $0 <= arr.length <= 3 \\times 10^4$\n* `arr.length` 是偶数\n* $-10^5 <= arr[i] <= 10^5$", "solution": "### 逐个构造 + 优先队列\n\n整理一下题意:是否能对 `arr` 进行重组,使得每一个奇数位置的值均是前一个位置的值的两倍,即凑成 $\\frac{n}{2}$ 组形如 $(x, 2 \\times x)$ 的数对。\n\n对于一个任意的有理数而言,对其乘 $2$ 仅会改变数值的大小,而不会改变其方向(正负性质)。\n\n因此如果我们每次都拿最接近 $0$ 的值作为起点,整个构造过程就是唯一确定的。\n\n具体的,我们可以借助优先队列(堆)来实现,构造一个以与 $0$ 值距离作为基准的小根堆。每次从堆中取出元素 $x$,根据当前元素 $x$ 是否被「预定」过进行分情况讨论:\n\n* 当前值 $x$ 没有被预定过,说明 $x$ 必然是数对中的「绝对值」的较小值,此时给 $x$ 并预定一个 $x \\times 2$,即对 $x \\times 2$ 的预定次数加一;\n* 当前值 $x$ 已经被预定过,说明 $x$ 和此前的某个数 $\\frac{x}{2}$ 组成过数对,对 $x$ 的预定次数减一。\n\n当且仅当构成过程结束后,所有数的「预定」次数为 $0$ 时,`arr` 可以凑成 $\\frac{n}{2}$ 组形如 $(x, 2 \\times x)$ 的数对。\n\n> 一些细节:由于 $arr[i]$ 的数值范围为 $[-10^5, 10^5]$,同时存在乘 $2$ 操作,因此我们需要对计算结果进行 $2 \\times 10^5$ 的偏移操作,确保其为正数。\n\n代码:\n```Java\nclass Solution {\n    static int N = 100010, M = N * 2;\n    static int[] cnts = new int[M * 2];\n    public boolean canReorderDoubled(int[] arr) {\n        Arrays.fill(cnts, 0);\n        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->Math.abs(a)-Math.abs(b));\n        for (int i : arr) q.add(i);\n        while (!q.isEmpty()) {\n            int x = q.poll(), t = x * 2;\n            if (cnts[x + M] != 0 && --cnts[x + M] >= 0) continue;\n            cnts[t + M]++;\n        }\n        for (int i = 0; i < M * 2; i++) {\n            if (cnts[i] != 0) return false;\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为 `arr` 长度,$m$ 为 $arr[i]$ 的值域范围,起始将所有数值放入优先队列(堆)的复杂度为 $O(n\\log{n})$,从优先队列(堆)中取出并构造复杂度为 $O(n\\log{n})$,检查构造是否成功复杂度为 $O(m)$,整体复杂度为 $O(n\\log{n} + m)$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### 成组构造 + 排序 + 预处理剪枝\n\n上述解法中,我们不可避免的对 `arr` 进行一遍完成的尝试构造,并且在尝试构造结束后再进行一次性的合法性检查。\n\n事实上,如果 `arr` 能够凑成 $\\frac{n}{2}$ 组形如 $(x, 2 \\times x)$ 的数对,并且对于某个 $x$ 可能会出现多次,我们可以统计 $arr[i]$ 的数量,并根据绝对值大小进行排序,进行成组构造:$cnts[x]$ 个 $x$ 消耗 $cnts[x]$ 个 $2 \\times x$。\n\n同时由于我们提前预处理了每个 $arr[i]$ 的出现次数,我们可以提前知道是否有 $cnts[x]$ 个 $2 \\times x$ 和 $x$ 成组,从而可以边构造边检查合法性。\n\n 代码:\n```Java\nclass Solution {\n    static int N = 100010, M = N * 2;\n    static int[] cnts = new int[M * 2];\n    public boolean canReorderDoubled(int[] arr) {\n        Arrays.fill(cnts, 0);\n        List<Integer> list = new ArrayList<>();\n        for (int i : arr) {\n            if (++cnts[i + M] == 1) list.add(i);\n        }\n        Collections.sort(list, (a,b)->Math.abs(a)-Math.abs(b));\n        for (int i : list) {\n            if (cnts[i * 2 + M] < cnts[i + M]) return false;\n            cnts[i * 2 + M] -= cnts[i + M];\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:统计 $arr[i]$ 的出现次数以及对 $arr[i]$ 去重的复杂度为 $O(n)$,对去重数组进行排序的复杂度为 $O(n\\log{n})$,验证是否合法复杂度为 $O(n)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### 成组构造 + 拓扑排序\n\n对于上述两种解法,要么利用「优先队列」要么利用「排序」,目的都是为了找到数对中的「绝对值较小」的那一位,然后开始往后构造。\n\n**事实上,我们可以利用任意 $x$ 只可能与 $\\frac{x}{2}$ 或者 $2 \\times x$ 组成数对来进行建图,通过对图跑拓扑序来验证是否能够凑成 $\\frac{n}{2}$ 组形如 $(x, 2 \\times x)$ 的数对。**\n\n> 不了解「拓扑排序」的同学可以看前置 🧀:[图论拓扑排序入门](https%3A//mp.weixin.qq.com/s?__biz%3DMzU4NDE3MTEyMA%3D%3D%26mid%3D2247489706%26idx%3D1%26sn%3D771cd807f39d1ca545640c0ef7e5baec),里面通过图解演示了何为拓扑序,以及通过「反证法」证明了为何有向无环图能够能够进行拓扑排序。\n\n特别的,我们需要特殊处理 $arr[i] = 0$ 的情况,由于 $0$ 只能与本身组成数对,为了避免自环,我们需要跳过 $arr[i] = 0$ 的点,同时特判 $arr[i] = 0$ 的出现数量为奇数时,返回无解。\n\n和解法二一样,先对 $arr[i]$ 进行数量统计以及去重预处理(跳过 $0$),然后对去重数组 `list` 中出现的数值 $x$ 进行分情况讨论:\n\n* $x$ 为奇数,由于 $\\frac{x}{2}$ 不为整数,因此 $x$ 只能作为数对中绝对值较小的那个(即 $x$ 入度为 $0$),加入队列;\n* $x$ 为偶数,首先令 $x$ 的入度 $in[x] = cnts[\\frac{x}{2}]$,代表有 $cnts[\\frac{x}{2}]$ 个 $\\frac{x}{2}$ 与其对应。当 $in[x] = 0$ 时,说明没有 $\\frac{x}{2}$ 与其成对,此时 $x$ 只能作为数对中绝对值较小的那个(即 $x$ 入度为 $0$),加入队列。\n\n跑一遍拓扑排序,假设当前出队值为 $t$,此时需要消耗掉 $cnts[t]$ 个 $t \\times 2$ 与其形成数对(即 $cnts[t \\times 2] -= cnts[t]$ ),同时 $t \\times 2$ 的入度也要更新(即 $in[t \\times 2] -= cnts[t]$ ),若 $in[t \\times 2] = 0$ 且此时 $cnts[t \\times 2] > 0$,将 $t \\times 2$ 进行入队。同时由于我们明确减少了 $t \\times 2$ 的数量,因此需要同步更新 $t \\times 4$ 的入度,同理,当 $t \\times 4$ 的入度 $in[t \\times 4] = 0$,同时 $cnts[t \\times 4] > 0$ 时,需要将 $t \\times 4$ 进行入队。\n\n代码:\n```Java\nclass Solution {\n    static int N = 100010, M = 2 * N;\n    static int[] cnts = new int[M * 2], in = new int[M * 2];\n    public boolean canReorderDoubled(int[] arr) {\n        Arrays.fill(cnts, 0);\n        Arrays.fill(in, 0);\n        List<Integer> list = new ArrayList<>();\n        for (int i : arr) {\n            if (++cnts[i + M] == 1 && i != 0) list.add(i);\n        }\n        if (cnts[M] % 2 != 0) return false;\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i : list) {\n            if (i % 2 == 0) {\n                in[i + M] = cnts[i / 2 + M];\n                if (in[i + M] == 0) d.addLast(i);\n            } else { \n                d.addLast(i);\n            }\n        }\n        while (!d.isEmpty()) {\n            int t = d.pollFirst();\n            if (cnts[t * 2 + M] < cnts[t + M]) return false;\n            cnts[t * 2 + M] -= cnts[t + M];\n            in[t * 2 + M] -= cnts[t + M];\n            if (in[t * 2 + M] == 0 && cnts[t * 2 + M] != 0) d.addLast(t * 2);\n            in[t * 4 + M] -= cnts[t + M];\n            if (in[t * 4 + M] == 0 && cnts[t * 4 + M] != 0) d.addLast(t * 4);\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:统计数量和入度的复杂度为 $O(n)$;跑拓扑序验证的复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.954` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/961-970/961. 在长度 2N 的数组中找出重复 N 次的元素（简单）.md", "url_title": "961. 在长度 2N 的数组中找出重复 N 次的元素", "url": "https://leetcode.cn/problems/n-repeated-element-in-size-2n-array/solution/by-ac_oier-bslq/", "difficulty": "简单", "tags": ["模拟", "计数", "构造", "哈希表"], "question": "给你一个整数数组 `nums` ,该数组具有以下属性:\n\n* $nums.length == 2 \\times n$\n* `nums` 包含 $n + 1$ 个 不同的 元素\n* `nums` 中恰有一个元素重复 $n$ 次\n\n找出并返回重复了 $n$ 次的那个元素。\n\n示例 1:\n```\n输入:nums = [1,2,3,3]\n\n输出:3\n```\n示例 2:\n```\n输入:nums = [2,1,2,5,3,2]\n\n输出:2\n```\n示例 3:\n```\n输入:nums = [5,1,5,2,5,3,5,4]\n\n输出:5\n```\n\n提示:\n* $2 <= n <= 50004\n* $nums.length == 2 \\times n$\n* $0 <= nums[i] <= 10^4$\n* `nums` 由 $n + 1$ 个 不同的 元素组成,且其中一个元素恰好重复 $n$ 次", "solution": "### 计数模拟\n\n根据题目给定的三个条件可推断出:数组中仅有一个元素出现多次,其余元素均出现一次。\n\n又利用数据范围为 $10^4$,我们可以使用数组充当哈希表进行计数,当出现一个 $nums[i]$ 重复出现即是答案。\n\n代码:\n```Java\nclass Solution {\n    int[] cnts = new int[10010];\n    public int repeatedNTimes(int[] nums) {\n        for (int x : nums) {\n            if (++cnts[x] > 1) return x;\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(C)$\n\n---\n\n### 构造共性\n\n假设重复出现的数字是 $x$,数字 $x$ 重复了 $n$ 次,要将这 $n$ 个相同的 $x$ 间隔开,需要 $n - 1$ 个额外数字,而实际上我们除 $x$ 以外还有 $n$ 个额外数字(数字总数为 $n + 1$ 个),因此在我们所能构造出的所有排列方式中,**最多** 使相邻 $x$ 之间间隔了 $2$ 个额外数字。\n\n对于每个 $nums[i]$ 而言,我们检查往前的三个位置(若有),如果有重复相等情况,说明当前的 $nums[i]$ 即是答案。\n\n代码:\n```Java\nclass Solution {\n    public int repeatedNTimes(int[] nums) {\n        int n = nums.length;\n        for (int i = 0; i < n; i++) {\n            int t = nums[i];\n            if (i - 1 >= 0 && nums[i - 1] == t) return t;\n            if (i - 2 >= 0 && nums[i - 2] == t) return t;\n            if (i - 3 >= 0 && nums[i - 3] == t) return t;\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.961` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/961-970/965. 单值二叉树（简单）.md", "url_title": "965. 单值二叉树", "url": "https://leetcode.cn/problems/univalued-binary-tree/solution/by-ac_oier-zxjl/", "difficulty": "简单", "tags": ["DFS", "BFS", "二叉树", "树的遍历", "层序遍历"], "question": "如果二叉树每个节点都具有相同的值,那么该二叉树就是单值二叉树。\n\n只有给定的树是单值二叉树时,才返回 `true`;否则返回 `false`。\n\n示例 1:\n\n```\n输入:[1,1,1,1,1,null,1]\n\n输出:true\n```\n示例 2:\n\n```\n输入:[2,2,2,5,2]\n\n输出:false\n```\n\n提示:\n* 给定树的节点数范围是 $[1, 100]¥。\n* 每个节点的值都是整数,范围为 $[0, 99]$ 。", "solution": "### 递归\n\n根据题意进行模拟即可。\n\n代码:\n```Java\nclass Solution {\n    int val = -1;\n    public boolean isUnivalTree(TreeNode root) {\n        if (val == -1) val = root.val;\n        if (root == null) return true;\n        if (root.val != val) return false;\n        return isUnivalTree(root.left) && isUnivalTree(root.right);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:忽略递归带来的额外空间消耗,复杂度为 $O(1)$\n\n---\n\n### 迭代\n\n也可以使用迭代的方式进行层序遍历。\n\n代码:\n```Java\nclass Solution {\n    public boolean isUnivalTree(TreeNode root) {\n        int val = root.val;\n        Deque<TreeNode> d = new ArrayDeque<>();\n        d.addLast(root);\n        while (!d.isEmpty()) {\n            TreeNode poll = d.pollFirst();\n            if (poll.val != val) return false;\n            if (poll.left != null) d.addLast(poll.left);\n            if (poll.right != null) d.addLast(poll.right);\n        }\n        return true;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.965` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/961-970/969. 煎饼排序（中等）.md", "url_title": "969. 煎饼排序", "url": "https://leetcode-cn.com/problems/pancake-sorting/solution/gong-shui-san-xie-mou-pao-pai-xu-yun-yon-c0mn/", "difficulty": "中等", "tags": ["排序"], "question": "给你一个整数数组 `arr`,请使用 **煎饼翻转** 完成对数组的排序。\n\n一次煎饼翻转的执行过程如下:\n\n* 选择一个整数 `k` ,$1 <= k <= arr.length$\n* 反转子数组 `arr[0...k-1]`(下标从 $0$ 开始)\n\n例如,`arr = [3,2,1,4]`,选择 `k = 3` 进行一次煎饼翻转,反转子数组 `[3,2,1]` ,得到 `arr = [1,2,3,4]` 。\n\n以数组形式返回能使 `arr` 有序的煎饼翻转操作所对应的 `k` 值序列。任何将数组排序且翻转次数在 `10 * arr.length` 范围内的有效答案都将被判断为正确。\n\n示例 1:\n```\n输入:[3,2,4,1]\n\n输出:[4,2,4,3]\n\n解释:\n我们执行 4 次煎饼翻转,k 值分别为 4,2,4,和 3。\n初始状态 arr = [3, 2, 4, 1]\n第一次翻转后(k = 4):arr = [1, 4, 2, 3]\n第二次翻转后(k = 2):arr = [4, 1, 2, 3]\n第三次翻转后(k = 4):arr = [3, 2, 1, 4]\n第四次翻转后(k = 3):arr = [1, 2, 3, 4],此时已完成排序。 \n```\n示例 2:\n```\n输入:[1,2,3]\n\n输出:[]\n\n解释:\n输入已经排序,因此不需要翻转任何内容。\n请注意,其他可能的答案,如 [3,3] ,也将被判断为正确。\n```\n\n提示:\n* $1 <= arr.length <= 100$\n* $1 <= arr[i] <= arr.length$\n* `arr` 中的所有整数互不相同(即,arr 是从 1 到 arr.length 整数的一个排列)", "solution": "### 冒泡排序\n\n由于每次我们都对「某段前缀」进行整体翻转,并且规定了翻转次数在一定范围内的方案均为合法翻转方案,同时 $arr$ 又是 $1$ 到 $n$ 的排列。\n\n我们可以很自然想到「冒泡排序」:**每次确定未排序部分最右端的元素(最大值)。**\n\n具体的,假设下标 $[k + 1, n - 1]$ 部分已有序,如果我们希望当前值 $t$ 出现在某个位置 $k$ 上,可以进行的操作为:\n\n* 如果当前值 $t$ 已在 $k$ 上,无须进行操作;\n* 如果当前值不在 $k$ 上,根据当前值是否在数组头部(下标为 $0$)进行分情况讨论:\n    * 当前值在数组头部(下标为 $0$),直接将 $[0, k]$ 部分进行翻转(将 $k + 1$ 加入答案中),即可将当前值 $t$ 放到位置 $k$ 上;\n    * 当前值不在数组头部(下标为 $0$),而是在 $idx$ 位置上,需要先将 $[0, idx]$ 部分进行翻转(将 $idx + 1$ 加入答案中),这样使得当前值 $t$ 出现数组头部(下标为 $0$),然后再将 $[0, k]$ 部分进行翻转(将 $k + 1$ 加入答案中),即可将当前值 $t$ 放到位置 $k$ 上。\n\n而翻转某个前缀的操作可使用「双指针」实现,复杂度为 $O(n)$。\n\n代码:\n```Java\nclass Solution {\n    public List<Integer> pancakeSort(int[] arr) {\n        int n = arr.length;\n        int[] idxs = new int[n + 10];\n        for (int i = 0; i < n; i++) idxs[arr[i]] = i;\n        List<Integer> ans = new ArrayList<>();\n        for (int i = n; i >= 1; i--) {\n            int idx = idxs[i];\n            if (idx == i - 1) continue;\n            if (idx != 0) {\n                ans.add(idx + 1);\n                reverse(arr, 0, idx, idxs);\n            }\n            ans.add(i);\n            reverse(arr, 0, i - 1, idxs);\n        }\n        return ans;\n    }\n    void reverse(int[] arr, int i, int j, int[] idxs) {\n        while (i < j) {\n            idxs[arr[i]] = j; idxs[arr[j]] = i;\n            int c = arr[i];\n            arr[i++] = arr[j];\n            arr[j--] = c;\n        }\n    }\n}\n```\n* 时间复杂度:需要对 $n$ 个元素进行排序,每个元素最多触发两次翻转,每次翻转的复杂度为 $O(n)$。整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.969` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/971-980/978. 最长湍流子数组（中等）.md", "url_title": "978. 最长湍流子数组", "url": "https://leetcode-cn.com/problems/longest-turbulent-subarray/solution/xiang-jie-dong-tai-gui-hua-ru-he-cai-dp-3spgj/", "difficulty": "中等", "tags": ["线性 DP", "序列 DP"], "question": "当 `A` 的子数组 $A[i], A[i+1], ..., A[j]$ 满足下列条件时,我们称其为湍流子数组:\n\n* 若 $i <= k < j$,当 $k$ 为奇数时,$A[k] > A[k+1]$,且当 $k$ 为偶数时,$A[k] < A[k+1]$;\n* 若 $i <= k < j$,当 $k$ 为偶数时,$A[k] > A[k+1]$ ,且当 $k$ 为奇数时,$A[k] < A[k+1]$。\n\n也就是说,如果比较符号在子数组中的每个相邻元素对之间翻转,则该子数组是湍流子数组。\n\n返回 `A` 的最大湍流子数组的长度。\n\n示例 1:\n```\n输入:[9,4,2,10,7,8,8,1,9]\n输出:5\n解释:(A[1] > A[2] < A[3] > A[4] < A[5])\n```\n示例 2:\n```\n输入:[4,8,12,16]\n输出:2\n```\n示例 3:\n```\n输入:[100]\n输出:1\n```\n\n提示:\n* $1 <= A.length <= 40000$\n* $0 <= A[i] <= 10^9$", "solution": "### 基本思路\n\n本题其实是要我们求最长一段呈 `↗ ↘ ↗ ↘` 或者 `↘ ↗ ↘ ↗` 形状的数组长度。\n\n看一眼数据范围,有 $40000$,那么枚举起点和终点,然后对划分出来的子数组检查是否为「湍流子数组」的朴素解法就不能过了。\n\n朴素解法的复杂度为 $O(n^3)$ ,直接放弃朴素解法。\n\n复杂度往下优化,其实就 $O(n)$ 的 DP 解法了。\n\n---\n\n### 动态规划\n\n至于 DP 如何分析,通过我们会先考虑一维 DP 能否求解,不行再考虑二维 DP。\n\n对于本题,**由于每个位置而言,能否「接着」上一个位置**形成「湍流」,取决于上一位置是由什么形状而来。\n\n举个例子,对于样例 `[3,4,2]`,从 4 -> 2 已经确定是 `↘` 状态,那么对于 2 这个位置能否「接着」4 形成「湍流」,要求 4 必须是由 `↗` 而来。\n\n**因此我们还需要记录某一位是如何来的(`↗` 还是 `↘`),需要使二维 DP 来求解 ~**\n\n我们定义 $f[i][j]$ 代表以位置 $i$ 为结尾,而结尾状态为 $j$ 的最长湍流子数组长度(0:上升状态 / 1:下降状态)\n\n> PS. 这里的状态定义我是猜的,这其实是个技巧。通常我们做 DP 题,都是先猜一个定义,然后看看这个定义是否能分析出状态转移方程帮助我们「不重不漏」的枚举所有的方案。一般我是直接根据答案来猜定义,这里是求最长子数组长度,所以我猜一个 f(i,j) 代表最长湍流子数组长度\n\n不失一般性考虑 $f[i][j]$ 该如何求解,我们知道位置 $i$ 是如何来是唯一确定的(取决于 $arr[i]$ 和 $arr[i - 1]$ 的大小关系),而只有三种可能性:\n\n* $arr[i - 1] < arr[i]$:该点是由上升而来,能够「接着」的条件是 $i - 1$ 是由下降而来。则有:$f[i][0] = f[i - 1][1] + 1$\n* $arr[i - 1] > arr[i]$:改点是由下降而来,能够「接着」的条件是 $i - 1$ 是由上升而来。则有:$f[i][1] = f[i - 1][0] + 1$\n* $arr[i - 1] = arr[i]$:不考虑,不符合「湍流」的定义\n\n代码:\n```Java\nclass Solution {\n    public int maxTurbulenceSize(int[] arr) {\n        int n = arr.length, ans = 1;\n        int[][] f = new int[n][2];\n        f[0][0] = f[0][1] = 1;\n        for (int i = 1; i < n; i++) {\n            f[i][0] = f[i][1] = 1;\n            if (arr[i] > arr[i - 1]) f[i][0] = f[i - 1][1] + 1;\n            else if (arr[i] < arr[i - 1]) f[i][1] = f[i - 1][0] + 1;\n            ans = Math.max(ans, Math.max(f[i][0], f[i][1]));\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 空间优化:奇偶滚动\n\n我们发现对于 $f[i][j]$ 状态的更新只依赖于 $f[i - 1][j]$ 的状态。\n\n因此我们可以使用「奇偶滚动」方式来将第一维从 $n$ 优化到 $2$。\n\n修改的方式也十分机械,只需要改为「奇偶滚动」的维度直接修改成 $2$ ,然后该维度的所有访问方式增加 `%2` 或者 `&1` 即可:\n\n代码:\n```Java\nclass Solution {\n    public int maxTurbulenceSize(int[] arr) {\n        int n = arr.length, ans = 1;\n        int[][] f = new int[2][2];\n        f[0][0] = f[0][1] = 1;\n        for (int i = 1; i < n; i++) {\n            f[i % 2][0] = f[i % 2][1] = 1;\n            if (arr[i] > arr[i - 1]) f[i % 2][0] = f[(i - 1) % 2][1] + 1;\n            else if (arr[i] < arr[i - 1]) f[i % 2][1] = f[(i - 1) % 2][0] + 1;\n            ans = Math.max(ans, Math.max(f[i % 2][0], f[i % 2][1]));\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:使用固定 `2 * 2` 的数组空间。复杂度为 $O(1)$\n\n---\n\n### 空间优化:维度消除\n\n既然只需要记录上一行状态,能否直接将行的维度消除呢?\n\n答案是可以的,当我们要转移第 $i$ 行的时候,$f[i]$ 装的就已经是 $i - 1$ 行的结果。\n\n这也是著名「背包问题」的一维通用优手段。\n\n但相比于「奇偶滚动」的空间优化,这种优化手段只是常数级别的优化(空间复杂度与「奇偶滚动」相同),而且优化通常涉及代码改动。\n\n代码:\n```Java\nclass Solution {\n    public int maxTurbulenceSize(int[] arr) {\n        int n = arr.length, ans = 1;\n        int[] f = new int[2];\n        f[0] = f[1] = 1;\n        for (int i = 1; i < n; i++) {\n            int a = f[0], b = f[1];\n            f[0] = arr[i - 1] < arr[i] ? b + 1 : 1;\n            f[1] = arr[i - 1] > arr[i] ? a + 1 : 1;\n            ans = Math.max(ans, Math.max(f[0], f[1]));\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.978` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/981-990/981. 基于时间的键值存储（中等）.md", "url_title": "981. 基于时间的键值存储", "url": "https://leetcode-cn.com/problems/time-based-key-value-store/solution/gong-shui-san-xie-yi-ti-shuang-jie-ha-xi-h5et/", "difficulty": "中等", "tags": ["设计数据结构", "哈希表", "二分", "数组", "红黑树"], "question": "创建一个基于时间的键值存储类 `TimeMap`,它支持下面两个操作:\n\n1. set(string key, string value, int timestamp)\n\t* 存储键 key、值 value,以及给定的时间戳 timestamp。\n2. get(string key, int timestamp)\n\t* 返回先前调用 set(key, value, timestamp_prev) 所存储的值,其中 timestamp_prev <= timestamp。\n\t* 如果有多个这样的值,则返回对应最大的  timestamp_prev 的那个值。\n\t* 如果没有值,则返回空字符串(\"\")。\n\n示例 1:\n```\n输入:inputs = [\"TimeMap\",\"set\",\"get\",\"get\",\"set\",\"get\",\"get\"], inputs = [[],[\"foo\",\"bar\",1],[\"foo\",1],[\"foo\",3],[\"foo\",\"bar2\",4],[\"foo\",4],[\"foo\",5]]\n\n输出:[null,null,\"bar\",\"bar\",null,\"bar2\",\"bar2\"]\n\n解释:  \nTimeMap kv;   \nkv.set(\"foo\", \"bar\", 1); // 存储键 \"foo\" 和值 \"bar\" 以及时间戳 timestamp = 1   \nkv.get(\"foo\", 1);  // 输出 \"bar\"   \nkv.get(\"foo\", 3); // 输出 \"bar\" 因为在时间戳 3 和时间戳 2 处没有对应 \"foo\" 的值,所以唯一的值位于时间戳 1 处(即 \"bar\")   \nkv.set(\"foo\", \"bar2\", 4);   \nkv.get(\"foo\", 4); // 输出 \"bar2\"   \nkv.get(\"foo\", 5); // 输出 \"bar2\"   \n```\n示例 2:\n```\n输入:inputs = [\"TimeMap\",\"set\",\"set\",\"get\",\"get\",\"get\",\"get\",\"get\"], inputs = [[],[\"love\",\"high\",10],[\"love\",\"low\",20],[\"love\",5],[\"love\",10],[\"love\",15],[\"love\",20],[\"love\",25]]\n\n输出:[null,null,null,\"\",\"high\",\"high\",\"low\",\"low\"]\n```\n\n提示:\n* 所有的键/值字符串都是小写的。\n* 所有的键/值字符串长度都在 [1, 100] 范围内。\n* 所有 TimeMap.set 操作中的时间戳 timestamps 都是严格递增的。\n* 1 <= timestamp <= $10^7$\n* TimeMap.set 和 TimeMap.get 函数在每个测试用例中将(组合)调用总计 `120000` 次。", "solution": "### 哈希表套数组\n\n由于 `timestamp` 是严格递增,且没有删除 KV 的操作。\n\n**我们可以使用哈希表套数组的方式进行实现,从而达到均摊 $O(1)$ 的插入操作和 $O(\\log{n})$ 的查询操作。**\n\n具体的,为了方便理解,我们可以先建一个 `Node` 类,类中包含键值对和时间戳信息。\n\n然后使用一个全局哈希表 `map` 记录某个 `key` 对应了哪些 `Node`。其中多个 `Node` 是以动态数组的形式进行「以 `timestamp` 升序」存储:\n\n* `set` 操作:以 $O(1)$ 的复杂度找到某个 `key` 对应的数组,利用 `timestamp` 严格递增的特性,以 $O(1)$ 复杂度将新 `Node` 加入当前数组尾部;\n* `get` 操作:以 $O(1)$ 的复杂度找到某个 `key` 对应的数组,利用 `timestamp` 严格递增的特性,通过二分以 $O(\\log{n})$ 复杂度找到可能符合条件的 `Node`。\n\n代码:\n```Java\nclass TimeMap {\n    class Node {\n        String k, v; \n        int t;\n        Node (String _k, String _v, int _t) {\n            k = _k; v = _v; t = _t;\n        }\n    }\n    \n    Map<String, List<Node>> map = new HashMap<>();\n    public void set(String k, String v, int t) {\n        List<Node> list = map.getOrDefault(k, new ArrayList<>());\n        list.add(new Node(k, v, t));\n        map.put(k, list);\n    }\n    \n    public String get(String k, int t) {\n        List<Node> list = map.getOrDefault(k, new ArrayList<>());\n        if (list.isEmpty()) return \"\";\n        int n = list.size();\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (list.get(mid).t <= t) {\n                l = mid;\n            } else {\n                r = mid - 1;\n            }\n        }\n        return list.get(r).t <= t ? list.get(r).v : \"\";\n    }\n}\n```\n* 时间复杂度:`set` 操作的复杂度为 $O(1)$;`get` 操作的复杂度为 $O(\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 哈希表套树\n\n如果增加 `del` 操作呢?我们需要做出何种调整?\n\n考虑在原题的基础上,增加一个 `String del(String k, int t)` 的功能:将严格等于键和时间戳的 KV 对删掉。\n\n**由于存在删除 KV 的动作,我们需要将实现从「哈希表套数组」改成「哈希表套树」,这里直接使用基于红黑树实现的 `TreeMap` 即可。**\n\n同时为了验证删除逻辑的正确性,我们在 `get` 动作发生前,先产生一次随机性的删除,删除后又重新插入。\n\n代码:\n```Java\nclass TimeMap {\n    class Node {\n        String k, v;\n        int t;\n        Node (String _k, String _v, int _t) {\n            k = _k; v = _v; t = _t;\n        }\n    }\n\n    Map<String, TreeMap<Integer, Node>> map = new HashMap<>();\n    public void set(String k, String v, int t) {\n        update(k, t);\n        TreeMap<Integer, Node> ts = map.getOrDefault(k, new TreeMap<Integer, Node>());\n        ts.put(t, new Node(k, v, t));\n        map.put(k, ts);\n    }\n\n    Node _get(String k, int t) {\n        TreeMap<Integer, Node> ts = map.get(k);\n        if (ts == null) return null;\n        Map.Entry<Integer, Node> entry = ts.floorEntry(t);\n        if (entry == null) return null;\n        Node node = entry.getValue();\n        return node;\n    }\n\n    public String get(String k, int t) {\n        randomDel();\n        Node node = _get(k, t);\n        return node != null && node.t <= t ? node.v : \"\";\n    }\n\n    public String del(String k, int t) {\n        TreeMap<Integer, Node> ts = map.get(k);\n        if (ts == null) return null;\n        Map.Entry<Integer, Node> entry = ts.floorEntry(t);\n        if (entry == null) return null;\n        Node node = entry.getValue();\n        if (node != null && node.t == t) {\n            ts.remove(t);\n            return node.v;\n        }\n        return \"\";\n    }\n\n    List<String> allInfo = new ArrayList<>(); \n    Random random = new Random();\n    // 保存所有的 kt 信息\n    void update(String k, int t) {\n        String nk = k + \"_\" + t;\n        allInfo.add(nk);\n    } \n    // 随机删除,再重新插入,验证代码正确性\n    void randomDel() {\n        int idx = random.nextInt(allInfo.size());\n        String[] ss = allInfo.get(idx).split(\"_\");\n        String k = ss[0];\n        int t = Integer.parseInt(ss[1]);\n        Node node = _get(k, t);\n        del(node.k, node.t);\n        set(node.k, node.v, node.t);\n    }\n}\n```\n* 时间复杂度:`set` 操作的复杂度为 $O(\\log{n})$;`get` 操作会完成随机删除/重新插入/查询的动作,复杂度均为为 $O(\\log{n})$,整个 `get` 的复杂度仍是 $O(\\log{n})$(只是常数变大了)\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.981` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/981-990/985. 查询后的偶数和（中等）.md", "url_title": "985. 查询后的偶数和", "url": "https://leetcode.cn/problems/sum-of-even-numbers-after-queries/solution/gong-shui-san-xie-jian-dan-mo-ni-ti-by-a-lwfq/", "difficulty": "中等", "tags": ["模拟"], "question": "给出一个整数数组 `A` 和一个查询数组 `queries`。\n\n对于第 `i` 次查询,有 `val = queries[i][0]`, `index = queries[i][1]`,我们会把 `val` 加到 `A[index]` 上。然后,第 `i` 次查询的答案是 `A` 中偶数值的和。\n\n(此处给定的 `index = queries[i][1]` 是从 `0` 开始的索引,每次查询都会永久修改数组 `A`。)\n\n返回所有查询的答案。你的答案应当以数组 `answer` 给出,`answer[i]` 为第 `i` 次查询的答案。\n\n示例:\n```\n输入:A = [1,2,3,4], queries = [[1,0],[-3,1],[-4,0],[2,3]]\n\n输出:[8,6,2,4]\n\n解释:\n开始时,数组为 [1,2,3,4]。\n将 1 加到 A[0] 上之后,数组为 [2,2,3,4],偶数值之和为 2 + 2 + 4 = 8。\n将 -3 加到 A[1] 上之后,数组为 [2,-1,3,4],偶数值之和为 2 + 4 = 6。\n将 -4 加到 A[0] 上之后,数组为 [-2,-1,3,4],偶数值之和为 -2 + 4 = 2。\n将 2 加到 A[3] 上之后,数组为 [-2,-1,3,6],偶数值之和为 -2 + 6 = 4。\n```\n\n提示:\n* $1 <= A.length <= 10000$\n* $-10000 <= A[i] <= 10000$\n* $1 <= queries.length <= 10000$\n* $-10000 <= queries[i][0] <= 10000$\n* $0 <= queries[i][1] < A.length$", "solution": "### 模拟\n\n为了方便,将 `queries` 记为 `qs`。\n\n由于每次修改都是对 `A` 的永久修改,因此我们使用一个变量 `t` 来记录当前所有偶数和即可。\n\n具体的,我们先统计原数组所有偶数和为 `t`,从前往后处理每个 $qs[i]$,若修改前的原值 $nums[qs[i][1]]$ 为偶数,我们需要将其从 `t` 中减去,再进行实际修改 `nums[qs[i][1]] += qs[i][0]`,若修改后值为偶数,则将其累加到 `t` 上。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] sumEvenAfterQueries(int[] nums, int[][] qs) {\n        int m = qs.length, t = 0;\n        int[] ans = new int[m];\n        for (int x : nums) t += x % 2 == 0 ? x : 0;\n        for (int i = 0; i < m; i++) {\n            int val = qs[i][0], idx = qs[i][1];\n            if (nums[idx] % 2 == 0) t -= nums[idx];\n            nums[idx] += val;\n            if (nums[idx] % 2 == 0) t += nums[idx];\n            ans[i] = t;\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    vector<int> sumEvenAfterQueries(vector<int>& nums, vector<vector<int>>& qs) {\n        int m = qs.size(), t = 0;\n        std::vector<int> ans(m);\n        for (int x : nums) t += x % 2 == 0 ? x : 0;\n        for (int i = 0; i < m; i++) {\n            int val = qs[i][0], idx = qs[i][1];\n            if (nums[idx] % 2 == 0) t -= nums[idx];\n            nums[idx] += val;\n            if (nums[idx] % 2 == 0) t += nums[idx];\n            ans[i] = t;\n        }\n        return ans;\n    }\n};\n```\nPython3 代码:\n```Python3 \nclass Solution:\n    def sumEvenAfterQueries(self, nums: List[int], qs: List[List[int]]) -> List[int]:\n        m, t = 0, sum(x for x in nums if x % 2 == 0)\n        ans = []\n        for val, idx in qs:\n            if nums[idx] % 2 == 0:\n                t -= nums[idx]\n            nums[idx] += val\n            if nums[idx] % 2 == 0:\n                t += nums[idx]\n            ans.append(t)\n        return ans\n```\nGo 代码:\n```Go\nfunc sumEvenAfterQueries(nums []int, qs [][]int) []int {\n    m, t := len(qs), 0\n    ans := make([]int, m)\n    for _, x := range nums {\n        if x % 2 == 0 {\n            t += x\n        }\n    }\n    for i := 0; i < m; i++ {\n        val, idx := qs[i][0], qs[i][1]\n        if nums[idx] % 2 == 0 {\n            t -= nums[idx]\n        }\n        nums[idx] += val\n        if nums[idx] % 2 == 0 {\n            t += nums[idx]\n        }\n        ans[i] = t\n    }\n    return ans\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction sumEvenAfterQueries(nums: number[], qs: number[][]): number[] {\n    let m = qs.length, t = 0\n    for (const x of nums) t += x % 2 == 0 ? x : 0\n    const ans = new Array(m)\n    for (let i = 0; i < m; i++) {\n        const val = qs[i][0], idx = qs[i][1]\n        if (nums[idx] % 2 == 0) t -= nums[idx]\n        nums[idx] += val\n        if (nums[idx] % 2 == 0) t += nums[idx]\n        ans[i] = t;\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.985` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/981-990/987. 二叉树的垂序遍历（困难）.md", "url_title": "987. 二叉树的垂序遍历", "url": "https://leetcode-cn.com/problems/vertical-order-traversal-of-a-binary-tree/solution/gong-shui-san-xie-yi-ti-shuang-jie-dfs-h-wfm3/", "difficulty": "困难", "tags": ["数据结构运用", "二叉树", "哈希表", "排序", "优先队列(堆)", "DFS"], "question": "给你二叉树的根结点 `root` ,请你设计算法计算二叉树的 垂序遍历 序列。\n\n对位于 $(row, col)$ 的每个结点而言,其左右子结点分别位于 $(row + 1, col - 1)$ 和 $(row + 1, col + 1)$ 。树的根结点位于 $(0, 0)$ 。\n\n二叉树的 垂序遍历 从最左边的列开始直到最右边的列结束,按列索引每一列上的所有结点,形成一个按出现位置从上到下排序的有序列表。如果同行同列上有多个结点,则按结点的值从小到大进行排序。\n\n返回二叉树的 垂序遍历 序列。\n\n示例 1:\n\n```\n输入:root = [3,9,20,null,null,15,7]\n\n输出:[[9],[3,15],[20],[7]]\n\n解释:\n列 -1 :只有结点 9 在此列中。\n列  0 :只有结点 3 和 15 在此列中,按从上到下顺序。\n列  1 :只有结点 20 在此列中。\n列  2 :只有结点 7 在此列中。\n```\n示例 2:\n\n```\n输入:root = [1,2,3,4,5,6,7]\n\n输出:[[4],[2],[1,5,6],[3],[7]]\n\n解释:\n列 -2 :只有结点 4 在此列中。\n列 -1 :只有结点 2 在此列中。\n列  0 :结点 1 、5 和 6 都在此列中。\n          1 在上面,所以它出现在前面。\n          5 和 6 位置都是 (2, 0) ,所以按值从小到大排序,5 在 6 的前面。\n列  1 :只有结点 3 在此列中。\n列  2 :只有结点 7 在此列中。\n```\n示例 3:\n\n```\n输入:root = [1,2,3,4,6,5,7]\n\n输出:[[4],[2],[1,5,6],[3],[7]]\n\n解释:\n这个示例实际上与示例 2 完全相同,只是结点 5 和 6 在树中的位置发生了交换。\n因为 5 和 6 的位置仍然相同,所以答案保持不变,仍然按值从小到大排序。\n```\n\n提示:\n* 树中结点数目总数在范围 $[1, 10]$", "solution": "### DFS + 哈希表 + 排序\n\n根据题意,我们需要按照优先级「**“列号从小到大”,对于同列节点,“行号从小到大”,对于同列同行元素,“节点值从小到大”**」进行答案构造。\n\n因此我们可以对树进行遍历,遍历过程中记下这些信息 $(col, row, val)$,然后根据规则进行排序,并构造答案。\n\n我们可以先使用「哈希表」进行存储,最后再进行一次性的排序。\n\n代码:\n```Java\nclass Solution {\n    Map<TreeNode, int[]> map = new HashMap<>(); // col, row, val\n    public List<List<Integer>> verticalTraversal(TreeNode root) {\n        map.put(root, new int[]{0, 0, root.val});\n        dfs(root);\n        List<int[]> list = new ArrayList<>(map.values());\n        Collections.sort(list, (a, b)->{\n            if (a[0] != b[0]) return a[0] - b[0];\n            if (a[1] != b[1]) return a[1] - b[1];\n            return a[2] - b[2];\n        });\n        int n = list.size();\n        List<List<Integer>> ans = new ArrayList<>();\n        for (int i = 0; i < n; ) {\n            int j = i;\n            List<Integer> tmp = new ArrayList<>();\n            while (j < n && list.get(j)[0] == list.get(i)[0]) tmp.add(list.get(j++)[2]);\n            ans.add(tmp);\n            i = j;\n        }\n        return ans;\n    }\n    void dfs(TreeNode root) {\n        if (root == null) return ;\n        int[] info = map.get(root);\n        int col = info[0], row = info[1], val = info[2];\n        if (root.left != null) {\n            map.put(root.left, new int[]{col - 1, row + 1, root.left.val});\n            dfs(root.left);\n        }\n        if (root.right != null) {\n            map.put(root.right, new int[]{col + 1, row + 1, root.right.val});\n            dfs(root.right);\n        }\n    }\n}\n```\n* 时间复杂度:令总节点数量为 $n$,填充哈希表时进行树的遍历,复杂度为 $O(n)$;构造答案时需要进行排序,复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### DFS + 优先队列(堆)\n\n显然,最终要让所有节点的相应信息有序,可以使用「优先队列(堆)」边存储边维护有序性。\n\n代码:\n```Java\nclass Solution {\n    PriorityQueue<int[]> q = new PriorityQueue<>((a, b)->{ // col, row, val\n        if (a[0] != b[0]) return a[0] - b[0];\n        if (a[1] != b[1]) return a[1] - b[1];\n        return a[2] - b[2];\n    });\n    public List<List<Integer>> verticalTraversal(TreeNode root) {\n        int[] info = new int[]{0, 0, root.val};\n        q.add(info);\n        dfs(root, info);\n        List<List<Integer>> ans = new ArrayList<>();\n        while (!q.isEmpty()) {\n            List<Integer> tmp = new ArrayList<>();\n            int[] poll = q.peek();\n            while (!q.isEmpty() && q.peek()[0] == poll[0]) tmp.add(q.poll()[2]);\n            ans.add(tmp);\n        }\n        return ans;\n    }\n    void dfs(TreeNode root, int[] fa) {\n        if (root.left != null) {\n            int[] linfo = new int[]{fa[0] - 1, fa[1] + 1, root.left.val};\n            q.add(linfo);\n            dfs(root.left, linfo);\n        }\n        if (root.right != null) {\n            int[] rinfo = new int[]{fa[0] + 1, fa[1] + 1, root.right.val};\n            q.add(rinfo);\n            dfs(root.right, rinfo);\n        }\n    }\n}\n```\n* 时间复杂度:令总节点数量为 $n$,将节点信息存入优先队列(堆)复杂度为 $O(n\\log{n})$;构造答案复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### DFS + 哈希嵌套 + 排序\n\n当然,如果想锻炼一下自己的代码能力,不使用三元组 $(col, row, val)$ 进行存储,而是使用哈希表嵌套,也是可以的。\n\n用三个「哈希表」来记录相关信息:\n\n1. 使用 `node2row` 和 `node2col` 分别用来记录「**节点到行**」&「**节点到列**」的映射关系,并实现 `dfs1` 对树进行遍历,目的是为了记录下相关的映射关系;\n\n2. 使用 `col2row2nodes` 记录「**从列到行,从行到节点集**」的映射关系,具体的存储格式为 `{col : {row : [node1, node2, ... ]}}`,实现 `dfs2` 再次进行树的遍历,配合之前 `node2row` 和 `node2col`信息,填充 `col2row2nodes` 的映射关系;\n\n3. 按照题意,按「列号从小到大」,对于同列节点,按照「行号从小到大」,对于同列同行元素,按照「节点值从小到大」的规则,使用 `col2row2nodes` + 排序 构造答案。\n\n> 注意:本解法可以只进行一次树的遍历,分两步主要是不想 `dfs` 操作过于复杂,加大读者的阅读难度,于是在拆开不影响复杂度上界的情况,选择了分两步。\n\n代码:\n```Java\nclass Solution {\n    Map<TreeNode, Integer> node2col = new HashMap<>(), node2row = new HashMap<>();\n    Map<Integer, Map<Integer, List<Integer>>> col2row2nodes = new HashMap<>();\n    public List<List<Integer>> verticalTraversal(TreeNode root) {\n        List<List<Integer>> ans = new ArrayList<>();\n        node2col.put(root, 0);\n        node2row.put(root, 0);\n        dfs1(root);\n        dfs2(root);\n        List<Integer> cols = new ArrayList<>(col2row2nodes.keySet());\n        Collections.sort(cols);\n        for (int col : cols) {\n            Map<Integer, List<Integer>> row2nodes = col2row2nodes.get(col);\n            List<Integer> rows = new ArrayList<>(row2nodes.keySet());\n            Collections.sort(rows);\n            List<Integer> cur = new ArrayList<>();\n            for (int row : rows) {\n                List<Integer> nodes = row2nodes.get(row);\n                Collections.sort(nodes);\n                cur.addAll(nodes);\n            }\n            ans.add(cur);\n        }\n        return ans;\n    }\n    // 树的遍历,根据「节点到列」&「节点到行」的映射关系,构造出「从列到行,从行到节点集」的映射关系\n    void dfs2(TreeNode root) {\n        if (root == null) return ;\n        int col = node2col.get(root), row = node2row.get(root);\n        Map<Integer, List<Integer>> row2nodes = col2row2nodes.getOrDefault(col, new HashMap<>());\n        List<Integer> nodes = row2nodes.getOrDefault(row, new ArrayList<>());\n        nodes.add(root.val);\n        row2nodes.put(row, nodes);\n        col2row2nodes.put(col, row2nodes);\n        dfs2(root.left);\n        dfs2(root.right);\n    }\n    // 树的遍历,记录下「节点到列」&「节点到行」的映射关系\n    void dfs1(TreeNode root) {\n        if (root == null) return ;\n        if (root.left != null) {\n            int col = node2col.get(root);\n            node2col.put(root.left, col - 1);\n            int row = node2row.get(root);\n            node2row.put(root.left, row + 1);\n            dfs1(root.left);\n        }\n        if (root.right != null) {\n            int col = node2col.get(root);\n            node2col.put(root.right, col + 1);\n            int row = node2row.get(root);\n            node2row.put(root.right, row + 1);\n            dfs1(root.right);\n        }\n    }\n}\n```\n* 时间复杂度:令总的节点数量为 $n$,填充几个哈希表的复杂度为 $O(n)$;构造答案时需要对行号、列号和节点值进行排序,总的复杂度上界为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.987` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/991-1000/992. K 个不同整数的子数组（困难）.md", "url_title": "992. K 个不同整数的子数组", "url": "https://leetcode-cn.com/problems/subarrays-with-k-different-integers/solution/miao-dong-xi-lie-xiang-jie-shuang-zhi-zh-9k8w/", "difficulty": "困难", "tags": ["双指针", "滑动窗口"], "question": "给定一个正整数数组 $A$,如果 $A$ 的某个子数组中不同整数的个数恰好为 $K$,则称 $A$ 的这个连续、不一定不同的子数组为好子数组。\n\n例如,$[1,2,3,1,2]$ 中有 $3$ 个不同的整数:$1$,$2$,以及 $3$。\n\n返回 $A$ 中好子数组的数目。\n\n示例 1:\n```\n输入:A = [1,2,1,2,3], K = 2\n\n输出:7\n\n解释:恰好由 2 个不同整数组成的子数组:[1,2], [2,1], [1,2], [2,3], [1,2,1], [2,1,2], [1,2,1,2]\n```\n示例 2:\n```\n输入:A = [1,2,1,3,4], K = 3\n\n输出:3\n\n解释:恰好由 3 个不同整数组成的子数组:[1,2,1,3], [2,1,3], [1,3,4]\n```\n\n提示:\n* $1 <= A.length <= 20000$\n* $1 <= A[i] <= A.length$\n* $1 <= K <= A.length$", "solution": "### 滑动窗口\n\n对原数组每个 $nums[i]$ 而言:\n\n1. 找到其左边「最远」满足出现 $k$ 个不同字符的下标,记为 $p$ ,这时候形成的区间为 $[p, i]$\n2. 找到其左边「最远」满足出现 $k - 1$ 个不同字符的下标,记为 $j$ ,这时候形成的区间为 $[j, i]$\n3. **那么对于 $j - p$ 其实就是代表以 $nums[i]$ 为右边界(必须包含 $num[i]$),不同字符数量「恰好」为 $k$ 的子数组数量**\n\n我们使用 $lower$ 数组存起每个位置的 $p$;使用 $upper$ 数组存起每个位置的 $j$。\n\n累积每个位置的 $upper[i] - lower[i]$ 就是答案。\n\n计算 $lower$ 数组 和 $upper$ 数组的过程可以使用双指针。\n\n代码:\n```Java\nclass Solution {\n    public int subarraysWithKDistinct(int[] nums, int k) {\n        int n = nums.length;\n        int[] lower = new int[n], upper = new int[n];\n        find(nums, lower, k);\n        find(nums, upper, k - 1);\n        int ans = 0;\n        for (int i = 0; i < n; i++) ans += upper[i] - lower[i];\n        return ans;\n    }\n    void find(int[] nums, int[] arr, int k) {\n        int n = nums.length;\n        int[] cnt = new int[20010];\n        for (int i = 0, j = 0, sum = 0; j < n; j++) {\n            if (++cnt[nums[j]] == 1) sum++;\n            while (sum > k) {\n                if (--cnt[nums[i++]] == 0) sum--;\n            }\n            if (sum == k) arr[j] = i;\n        }\n    }\n}\n```\n* 时间复杂度:对数组进行常数次扫描。复杂度为 $O(n)$。\n* 空间复杂度:$O(n)$\n\n---\n\n### 其他\n\n这里的 $lower$ 和 $upper$ 其实可以优化掉,但也只是常数级别的优化,空间复杂度仍为 $O(n)$。\n\n推荐大家打印一下 $lower$ 和 $upper$ 来看看,加深对 **「 $upper[i] - lower[i]$ 代表了考虑 $nums[i]$ 为右边界,不同字符数量「恰好」为 $k$ 的子数组数量 」** 这句话的理解。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.992` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/991-1000/993. 二叉树的堂兄弟节点（简单）.md", "url_title": "993. 二叉树的堂兄弟节点", "url": "https://leetcode-cn.com/problems/cousins-in-binary-tree/solution/gong-shui-san-xie-shu-de-sou-suo-dfs-bfs-b200/", "difficulty": "简单", "tags": ["树的搜索", "BFS", "DFS"], "question": "在二叉树中,根节点位于深度 $0$ 处,每个深度为 $k$ 的节点的子节点位于深度 $k+1$ 处。\n\n如果二叉树的两个节点深度相同,但 父节点不同 ,则它们是一对堂兄弟节点。\n\n我们给出了具有唯一值的二叉树的根节点 $root$ ,以及树中两个不同节点的值 $x$ 和 $y$ 。\n\n只有与值 $x$ 和 $y$ 对应的节点是堂兄弟节点时,才返回 $true$ 。否则,返回 $false$。\n\n示例 1:\n\n```\n输入:root = [1,2,3,4], x = 4, y = 3\n\n输出:false\n```\n示例 2:\n\n```\n输入:root = [1,2,3,null,4,null,5], x = 5, y = 4\n\n输出:true\n```\n示例 3:\n\n```\n输入:root = [1,2,3,null,4], x = 2, y = 3\n\n输出:false\n```\n\n提示:\n* 二叉树的节点数介于 $2$ 到 $100$ 之间。\n* 每个节点的值都是唯一的、范围为 $1$ 到 $100$ 的整数。", "solution": "### DFS\n\n显然,我们希望得到某个节点的「父节点」&「所在深度」,不难设计出如下「DFS 函数签名」:\n\n```Java\n/**\n * 查找 t 的「父节点值」&「所在深度」\n * @param root 当前搜索到的节点\n * @param fa root 的父节点\n * @param depth 当前深度\n * @param t 搜索目标值\n * @return [fa.val, depth]\n */\nint[] dfs(TreeNode root, TreeNode fa, int depth, int t);\n```\n之后按照遍历的逻辑处理即可。\n\n需要注意的时,我们需要区分出「搜索不到」和「搜索对象为 $root$(没有 $fa$ 父节点)」两种情况。\n\n我们约定使用 $-1$ 代指没有找到目标值 $t$,使用 $0$ 代表找到了目标值 $t$,但其不存在父节点。\n\n代码:\n```Java\nclass Solution {\n    public boolean isCousins(TreeNode root, int x, int y) {\n        int[] xi = dfs(root, null, 0, x);\n        int[] yi = dfs(root, null, 0, y);\n        return xi[1] == yi[1] && xi[0] != yi[0];\n    }\n    int[] dfs(TreeNode root, TreeNode fa, int depth, int t) {\n        if (root == null) return new int[]{-1, -1}; // 使用 -1 代表为搜索不到 t\n        if (root.val == t) {\n            return new int[]{fa != null ? fa.val : 1, depth}; // 使用 1 代表搜索值 t 为 root\n        }\n        int[] l = dfs(root.left, root, depth + 1, t);\n        if (l[0] != -1) return l;\n        return dfs(root.right, root, depth + 1, t);\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:忽略递归开销为 $O(1)$,否则为 $O(n)$\n\n---\n\n### BFS\n\n能使用 `DFS`,自然也能使用 `BFS`,两者大同小异。\n\n代码:\n```Java\nclass Solution {\n    public boolean isCousins(TreeNode root, int x, int y) {\n        int[] xi = bfs(root, x);\n        int[] yi = bfs(root, y);\n        return xi[1] == yi[1] && xi[0] != yi[0];\n    }\n    int[] bfs(TreeNode root, int t) {\n        Deque<Object[]> d = new ArrayDeque<>(); // 存储值为 [cur, fa, depth]\n        d.addLast(new Object[]{root, null, 0});\n        while (!d.isEmpty()) {\n            int size = d.size();\n            while (size-- > 0) {\n                Object[] poll = d.pollFirst();\n                TreeNode cur = (TreeNode)poll[0], fa = (TreeNode)poll[1];\n                int depth = (Integer)poll[2];\n\n                if (cur.val == t) return new int[]{fa != null ? fa.val : 0, depth};\n                if (cur.left != null) d.addLast(new Object[]{cur.left, cur, depth + 1});\n                if (cur.right != null) d.addLast(new Object[]{cur.right, cur, depth + 1});\n            }\n        }\n        return new int[]{-1, -1};\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.993` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/991-1000/995. K 连续位的最小翻转次数（困难）.md", "url_title": "995. K 连续位的最小翻转次数", "url": "https://leetcode-cn.com/problems/minimum-number-of-k-consecutive-bit-flips/solution/po-su-tan-xin-jie-fa-yu-tan-xin-chai-fen-4lyy/", "difficulty": "困难", "tags": ["贪心", "差分"], "question": "在仅包含 0 和 1 的数组 A 中,一次 K 位翻转包括选择一个长度为 K 的(连续)子数组,同时将子数组中的每个 0 更改为 1,而每个 1 更改为 0。\n\n返回所需的 K 位翻转的最小次数,以便数组没有值为 0 的元素。如果不可能,返回 -1。\n\n示例 1:\n```\n输入:A = [0,1,0], K = 1\n输出:2\n解释:先翻转 A[0],然后翻转 A[2]。\n```\n示例 2:\n```\n输入:A = [1,1,0], K = 2\n输出:-1\n解释:无论我们怎样翻转大小为 2 的子数组,我们都不能使数组变为 [1,1,1]。\n```\n示例 3:\n```\n输入:A = [0,0,0,1,0,1,1,0], K = 3\n输出:3\n解释:\n翻转 A[0],A[1],A[2]: A变成 [1,1,1,1,0,1,1,0]\n翻转 A[4],A[5],A[6]: A变成 [1,1,1,1,1,0,0,0]\n翻转 A[5],A[6],A[7]: A变成 [1,1,1,1,1,1,1,1]\n```\n\n提示:\n* 1 <= A.length <= 30000\n* 1 <= K <= A.length", "solution": "### 贪心解法\n\n目标是将数组的每一位都变为 1 ,因此对于每一位 0 都需要翻转。\n\n我们可以从前往后处理,遇到 0 则对后面的 `k` 位进行翻转。\n\n这样我们的算法复杂度是 $O(nk)$ 的,数据范围是 3w(数量级为 $10^4$),极限数据下单秒的运算量在 $10^8$ 以上,会有超时风险。\n\n```java []\nclass Solution {\n    public int minKBitFlips(int[] nums, int k) {\n        int n = nums.length;\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            if (nums[i] == 0) {\n                if (i + k > n) return -1;\n                for (int j = i; j < i + k; j++) nums[j] ^= 1;\n                ans++;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(nk)$\n* 空间复杂度:$O(1)$\n\n***\n\n### 补充\n评论有同学提出了一些有价值的疑问,我觉得挺有代表性的,因此补充到题解:\n\n1. **为什么这样的解法是「贪心解法」,而不是「暴力解法」?**\n\n首先「暴力解法」必然是**对所有可能出现的翻转方案进行枚举**,然后检查每一个方案得到的结果是否符合全是 1 的要求。\n\n这样的解法,才是暴力解法,它的本质是通过「穷举」找答案。复杂度是指数级别的。\n\n而我们的「朴素贪心解法」只是执行了众多翻转方案中的一种。\n\n举个 🌰,对于 `nums = [0,0,1,1]` 并且 `k = 2` 的数据:\n\n暴力解法应该是「枚举」以下三种方案:\n\n1. 只翻转以第一个 0 开头的子数组(长度固定为 2)\n2. 只翻转以第二个 0 开头的子数组(长度固定为 2)\n3. 同时翻转第一个 0 开头和第二个 0 开头的子数组(长度固定为 2,只不过这时候第一个 0 被翻转了一次,第二个 0 被翻转了两次)\n\n然后对三种方案得到的最终解进行检查,找出符合结果全是 1 的方案。这种通过「穷举」方案检查合法性的解法才是「暴力」解法。\n\n2. **为什么我采用了与「朴素贪心」解法相似的做法,超时了?**\n\n结果测试 C++、Python 超时,只有 Java 能过。\n\n同样是 97 号样例数据,提交给 LeetCode 执行。Java 运行 200 ms 以内,而 C++ 运行 600 ms。\n\n***\n\n### 贪心 + 差分解法\n\n由于我们总是对连续的一段进行「相同」的操作,同时只有「奇数」次数的翻转才会真正改变当前位置上的值。\n\n自然而然,我们会想到使用数组 `arr` 来记录每一位的翻转次数。\n\n同时我们又不希望是通过「遍历记 `arr` 的 `k` 位进行 +1」来完成统计。\n\n因此可以使用差分数组来进行优化:当需要对某一段 `[l,r]` 进行 +1 的时候,只需要 `arr[l]++` 和 `arr[r + 1]--` 即可。\n\n```java\nclass Solution {\n    public int minKBitFlips(int[] nums, int k) {\n        int n = nums.length;\n        int ans = 0;\n        int[] arr = new int[n + 1];\n        for (int i = 0, cnt = 0; i < n; i++) {\n            cnt += arr[i];\n            if ((nums[i] + cnt) % 2 == 0) {\n                if (i + k > n) return -1;\n                arr[i + 1]++;\n                arr[i + k]--;\n                ans++;\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n***\n\n### 证明\n\n为什么「一遇到 0 就马上进行翻转」这样的做法得到的是最优解?\n\n这道题的贪心证明思路和 [765. 情侣牵手](https://leetcode-cn.com/problems/couples-holding-hands/solution/liang-chong-100-de-jie-fa-bing-cha-ji-ta-26a6/) 是一样的。\n\n本质上是在证明**当我在处理第 `k` 个位置的 0 的时候,前面 `k - 1` 个位置不存在 0,接下来要如何进行操作,可使得总的翻转次数最小。**\n\n如果你上次真正理解了我的证明过程的话,那么你会很容易就能证明出本题的贪心思路。\n\n所以这次将这个证明过程留给大家思考 ~ \n\n***\n\n### 为什么要「证明」或「理解证明」?\n\n证明的意义在于,**你知道为什么这样做是对的**。\n\n带来的好处是:\n\n1. 一道「贪心」题目能搞清楚证明,那么同类的「贪心」题目你就都会做了。**否则就会停留在“我知道这道题可以这样贪心,别的题我不确定是否也能这样做”**。\n\n2. 在「面试」阶段,**你可以很清晰讲解你的思路**。让面试官从你的「思维方式」上喜欢上你\n\n***\n\n### 更多与证明/分析相关的题解:\n\n[561. 数组拆分 I](https://leetcode-cn.com/problems/array-partition-i/) : [反证法证明贪心算法的正确性](https://leetcode-cn.com/problems/array-partition-i/solution/jue-dui-neng-kan-dong-de-zheng-ming-fan-f7trz/)\n\n[765. 情侣牵手](https://leetcode-cn.com/problems/couples-holding-hands/) : [为什么交换任意一个都是对的?:两种 100% 的解法:并查集 & 贪心](https://leetcode-cn.com/problems/couples-holding-hands/solution/liang-chong-100-de-jie-fa-bing-cha-ji-ta-26a6/)\n\n[1579. 保证图可完全遍历](https://leetcode-cn.com/problems/remove-max-number-of-edges-to-keep-graph-fully-traversable/) : [为什么先处理公共边是对的?含贪心证明 + 数组模板 ~](https://leetcode-cn.com/problems/remove-max-number-of-edges-to-keep-graph-fully-traversable/solution/tan-xin-bing-cha-ji-shu-zu-shi-xian-jian-w7ko/)\n\n[1631. 最小体力消耗路径](https://leetcode-cn.com/problems/path-with-minimum-effort/) : [反证法证明思路的合法性](https://leetcode-cn.com/problems/path-with-minimum-effort/solution/fan-zheng-fa-zheng-ming-si-lu-de-he-fa-x-ohby/)\n\n[11. 盛最多水的容器](https://leetcode-cn.com/problems/container-with-most-water/) : [双指针+贪心解法【含证明】](https://leetcode-cn.com/problems/container-with-most-water/solution/shua-chuan-lc-shuang-zhi-zhen-tan-xin-ji-52gf/)", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.995` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/991-1000/997. 找到小镇的法官（简单）.md", "url_title": "997. 找到小镇的法官", "url": "https://leetcode-cn.com/problems/find-the-town-judge/solution/gong-shui-san-xie-jian-dan-chu-du-ru-du-5ms57/", "difficulty": "简单", "tags": ["模拟", "图论"], "question": "在一个小镇里,按从 $1$ 到 $n$ 为 $n$ 个人进行编号。传言称,这些人中有一个是小镇上的秘密法官。\n\n如果小镇的法官真的存在,那么:\n\n* 小镇的法官不相信任何人。\n* 每个人(除了小镇法官外)都信任小镇的法官。\n* 只有一个人同时满足条件 $1$ 和条件 $24 。\n\n给定数组 $trust$,该数组由信任对 $trust[i] = [a, b]$ 组成,表示编号为 $a$ 的人信任编号为 $b$ 的人。\n\n如果小镇存在秘密法官并且可以确定他的身份,请返回该法官的编号。否则,返回 $-1$。\n\n示例 1:\n```\n输入:n = 2, trust = [[1,2]]\n\n输出:2\n```\n示例 2:\n```\n输入:n = 3, trust = [[1,3],[2,3]]\n\n输出:3\n```\n示例 3:\n```\n输入:n = 3, trust = [[1,3],[2,3],[3,1]]\n\n输出:-1\n```\n示例 4:\n```\n输入:n = 3, trust = [[1,2],[2,3]]\n\n输出:-1\n```\n示例 5:\n```\n输入:n = 4, trust = [[1,3],[1,4],[2,3],[2,4],[4,3]]\n\n输出:3\n```\n\n提示:\n* $1 <= n <= 1000$\n* $0 <= trust.length <= 10^4$\n* $trust[i].length == 2$\n* $trust[i]$ 互不相同\n* $trust[i][0] != trust[i][1]$\n* $1 <= trust[i][0], trust[i][1] <= n$", "solution": "### 模拟\n\n今天起晚了 🤣\n\n令 $m$ 为 `trust` 数组长度,对于每个 $trust[i] = (a, b)$ 而言,看作是从 $a$ 指向 $b$ 的有向边。\n\n遍历 `trust`,统计每个节点的「入度」和「出度」:若存在 $a -> b$,则 $a$ 节点「出度」加一,$b$ 节点「入度」加一。\n\n最后遍历所有点,若存在「入度」数量为 $n - 1$,且「出度」数量为 $0$ 的节点即是法官。\n\n代码:\n```Java\nclass Solution {\n    public int findJudge(int n, int[][] trust) {\n        int[] in = new int[n + 1], out = new int[n + 1];\n        for (int[] t : trust) {\n            int a = t[0], b = t[1];\n            in[b]++; out[a]++;\n        }\n        for (int i = 1; i <= n; i++) {\n            if (in[i] == n - 1 && out[i] == 0) return i;\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:$O(m + n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.997` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/991-1000/998. 最大二叉树 II（中等）.md", "url_title": "998. 最大二叉树 II", "url": "https://leetcode.cn/problems/maximum-binary-tree-ii/solution/by-ac_oier-v82s/", "difficulty": "中等", "tags": ["迭代", "模拟"], "question": "最大树定义:一棵树,并满足「其中每个节点的值都大于其子树中的任何其他值」。\n\n给你最大树的根节点 `root` 和一个整数 `val` 。\n\n给定的树是利用 `Construct(a)` 例程从列表 `a`(`root = Construct(a)`)递归地构建的:\n\n* 如果 `a` 为空,返回 `null` 。\n* 否则,令 `a[i]` 作为 `a` 的最大元素。创建一个值为 `a[i]` 的根节点 `root` 。\n* `root` 的左子树将被构建为 `Construct([a[0], a[1], ..., a[i - 1]])` 。\n* `root` 的右子树将被构建为 `Construct([a[i + 1], a[i + 2], ..., a[a.length - 1]])` 。\n* 返回 `root` 。\n\n请注意,题目没有直接给出 `a` ,只是给出一个根节点 `root = Construct(a)` 。\n\n假设 `b` 是 `a` 的副本,并在末尾附加值 `val`。题目数据保证 `b` 中的值互不相同。\n\n返回 `Construct(b)`。\n\n示例 1:\n\n```\n输入:root = [4,1,3,null,null,2], val = 5\n\n输出:[5,4,null,1,3,null,null,2]\n\n解释:a = [1,4,2,3], b = [1,4,2,3,5]\n```\n示例 2:\n\n```\n输入:root = [5,2,4,null,1], val = 3\n\n输出:[5,2,4,null,1,null,3]\n\n解释:a = [2,1,5,4], b = [2,1,5,4,3]\n```\n示例 3:\n\n```\n输入:root = [5,2,3,null,1], val = 4\n\n输出:[5,2,4,null,1,3]\n\n解释:a = [2,1,5,3], b = [2,1,5,3,4]\n```\n\n提示:\n* 树中节点数目在范围 $[1, 100]$ 内\n* $1 <= Node.val <= 100$\n* 树中的所有值 互不相同\n* $1 <= val <= 100$", "solution": "### 模拟\n\n题意不是很好理解,先稍微解释一下吧。\n\n大概意思是最大树 `root` 是根据特定的规则构造出来的,即给定的 `root` 其实对应一个具体的 `nums`,题目要求是将 `val` 追加到 `nums` 的尾部,然后再对得到的 `nums` 运用相同规则的构造,返回重新构造的最大树头结点。\n\n根据构造规则,若有下标 $i < j$,则 $nums[i]$ 必然在 $nums[j]$ 水平线的左边,而 `val` 又是追加在原有 `nums` 的结尾。因此其最终位置分如下两种情况:\n\n* `val` 为新 `nums` 中的最大值,同时 `val` 又是追加在原有 `nums` 的结尾,此时将原有的 `root` 挂在 `val` 对应节点的左子树即可,新树的根节点为 `val` 对应节点;\n* 否则,我们只需要不断在 `root` 的右子树中找目标位置(反证法可以知,`val` 必不可能出现在任一非右位置,否则可推断出在 `val` 右边仍有元素,这与 `val` 位于 `nums` 的结尾位置冲突)。假设目标位置的父节点为 `prev`,目标位置的原节点为 `cur`,根据构造规则可知 `prev.right = node` 且 `node.left = cur`,新树的根节点不变。\n\nJava 代码:\n```Java\nclass Solution {\n    public TreeNode insertIntoMaxTree(TreeNode root, int val) {\n        TreeNode node = new TreeNode(val);\n        TreeNode prev = null, cur = root;\n        while (cur != null && cur.val > val) {\n            prev = cur; cur = cur.right;\n        }\n        if (prev == null) {\n            node.left = cur;\n            return node;\n        } else {\n            prev.right = node;\n            node.left = cur;\n            return root;\n        }\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    TreeNode* insertIntoMaxTree(TreeNode* root, int val) {\n        TreeNode* node = new TreeNode(val);\n        TreeNode* prev = nullptr;\n        TreeNode* cur = root;\n        while (cur != nullptr && cur->val > val) {\n            prev = cur; cur = cur->right;\n        }\n        if (prev == nullptr) {\n            node->left = cur;\n            return node;\n        } else {\n            prev->right = node;\n            node->left = cur;\n            return root;\n        }\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def insertIntoMaxTree(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:\n        node = TreeNode(val)\n        prev, cur = None, root\n        while cur is not None and cur.val > val:\n            prev = cur\n            cur = cur.right\n        if prev is None:\n            node.left = cur\n            return node\n        else:\n            prev.right = node\n            node.left = cur\n            return root\n```\nTypescript 代码:\n```Typescript\nfunction insertIntoMaxTree(root: TreeNode | null, val: number): TreeNode | null {\n    const node = new TreeNode(val)\n    let prev = null, cur = root\n    while (cur != null && cur.val > val) {\n        prev = cur; cur = cur.right\n    }\n    if (prev == null) {\n        node.left = root\n        return node\n    } else {\n        prev.right = node\n        node.left = cur\n        return root\n    }\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.998` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/LCP/LCP 07. 传递信息（简单）.md", "url_title": "LCP 07. 传递信息", "url": "https://leetcode-cn.com/problems/chuan-di-xin-xi/solution/gong-shui-san-xie-tu-lun-sou-suo-yu-dong-cyxo/", "difficulty": "简单", "tags": ["图论搜索", "图论 BFS", "图论 DFS", "线性 DP"], "question": "小朋友 A 在和 ta 的小伙伴们玩传信息游戏,游戏规则如下:\n\n1. 有 n 名玩家,所有玩家编号分别为 0 ~ n-1,其中小朋友 A 的编号为 0\n2. 每个玩家都有固定的若干个可传信息的其他玩家(也可能没有)。传信息的关系是单向的(比如 A 可以向 B 传信息,但 B 不能向 A 传信息)。\n3. 每轮信息必须需要传递给另一个人,且信息可重复经过同一个人\n\n给定总玩家数 n,以及按 [玩家编号,对应可传递玩家编号] 关系组成的二维数组 relation。返回信息从小 A (编号 0 ) 经过 k 轮传递到编号为 n-1 的小伙伴处的方案数;若不能到达,返回 0。\n\n示例 1:\n```\n输入:n = 5, relation = [[0,2],[2,1],[3,4],[2,3],[1,4],[2,0],[0,4]], k = 3\n\n输出:3\n\n解释:信息从小 A 编号 0 处开始,经 3 轮传递,到达编号 4。\n\n共有 3 种方案,分别是 0->2->0->4, 0->2->1->4, 0->2->3->4。\n```\n示例 2:\n```\n输入:n = 3, relation = [[0,2],[2,1]], k = 2\n\n输出:0\n\n解释:信息不能从小 A 处经过 2 轮传递到编号 2\n```\n\n限制:\n* 2 <= n <= 10\n* 1 <= k <= 5\n* 1 <= relation.length <= 90, 且 relation[i].length == 2\n* 0 <= relation[i][0],relation[i][1] < n 且 relation[i][0] != relation[i][1]", "solution": "### 基本分析\n\n`n` 和 `k` 的数据范围都很小,并且根据题目对 `relation` 的定义可以知道这是一个边权相等的图。\n\n对于边权相等的图,统计有限步数的到达某个节点的方案数,最常见的方式是使用 `BFS` 或 `DFS`。\n\n---\n\n### BFS\n\n一个朴素的做法是使用 `BFS` 进行求解。\n\n起始时,将起点入队,按照常规的 `BFS` 方式进行拓展,直到拓展完第 $k$ 层。\n\n然后统计队列中编号为 `n-1` 的节点的出现次数。\n\n一些细节:为了方便找到某个点 $i$ 所能到达的节点,我们需要先预处理出所有的边。数据量较少,直接使用 `Map` 套 `Set` 即可。\n\n代码:\n```Java\nclass Solution {\n    public int numWays(int n, int[][] rs, int k) {\n        Map<Integer, Set<Integer>> map = new HashMap<>();\n        for (int[] r : rs) {\n            int a = r[0], b = r[1];\n            Set<Integer> s = map.getOrDefault(a, new HashSet<>());\n            s.add(b);\n            map.put(a, s);\n        }\n        Deque<Integer> d = new ArrayDeque<>();\n        d.addLast(0);\n        while (!d.isEmpty() && k-- > 0) {\n            int size = d.size();\n            while (size-- > 0) {\n                int poll = d.pollFirst();\n                Set<Integer> es = map.get(poll);\n                if (es == null) continue;\n                for (int next : es) {\n                    d.addLast(next);\n                }\n            }\n        }\n        int ans = 0;\n        while (!d.isEmpty()) {\n            if (d.pollFirst() == n - 1) ans++;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:最多搜索 $k$ 层,最坏情况下每层的每个节点都能拓展出 $n - 1$ 个节点,复杂度为 $O(n^k)$\n* 空间复杂度:最坏情况下,所有节点都相互连通。复杂度为 $O(n^k + n^2)$\n\n---\n\n### DFS\n\n同理,我们可以使用 `DFS` 进行求解。\n\n在 `DFS` 过程中限制深度最多为 $k$,然后检查所达节点为 `n-1` 的次数即可。\n\n代码:\n```Java\nclass Solution {\n    Map<Integer, Set<Integer>> map = new HashMap<>();\n    int n, k, ans;\n    public int numWays(int _n, int[][] rs, int _k) {\n        n = _n; k = _k;\n        for (int[] r : rs) {\n            int a = r[0], b = r[1];\n            Set<Integer> s = map.getOrDefault(a, new HashSet<>());\n            s.add(b);\n            map.put(a, s);\n        }\n        dfs(0, 0);\n        return ans;\n    }\n    void dfs(int u, int sum) {\n        if (sum == k) {\n            if (u == n - 1) ans++;\n            return;\n        }\n        Set<Integer> es = map.get(u);\n        if (es == null) return;\n        for (int next : es) {\n            dfs(next, sum + 1);\n        }\n    }\n}\n```\n* 时间复杂度:最多搜索 $k$ 层,最坏情况下每层的每个节点都能拓展出 $n - 1$ 个节点,复杂度为 $O(n^k)$\n* 空间复杂度:最坏情况下,所有节点都相互连通。忽略递归带来的额外空间消耗,复杂度为 $O(n^2)$\n\n---\n\n### 动态规划\n\n假设当前我们已经走了 $i$ 步,所在位置为 $j$,那么剩余的 $k - i$ 步,能否到达位置 $n - 1$,仅取决于「剩余步数 $k - i$」和「边权关系 `relation`」,而与我是如何到达位置 $i$ 无关。\n\n而对于方案数而言,如果已经走了 $i$ 步,所在位置为 $j$,到达位置 $n - 1$ 的方案数仅取决于「剩余步数 $i - k$」、「边权关系 `relation`」和「花费 $i$ 步到达位置 $j$ 的方案数」。\n\n**以上分析,归纳到边界「已经走了 $0$ 步,所在位置为 $0$」同样成立。**\n\n**这是一个「无后效性」的问题,可以使用动态规划进行求解。**\n\n定义 $f[i][j]$ 为当前已经走了 $i$ 步,所在位置为 $j$ 的方案数。\n\n那么 $f[k][n - 1]$ 为最终答案,$f[0][0] = 1$ 为显而易见的初始化条件。\n\n不失一般性的考虑,$f[i][j]$ 该如何转移,$f[i][j]$ 应该为所有能够到达位置 $j$ 的点 $p$ 的 $f[i - 1][p]$ 的总和:\n\n$$\nf[i][j] = \\sum_{i = 0}^{relation.length - 1}f[i - 1][p], relation[i][0]=p,relation[i][1]=j\n$$\n\n代码:\n```Java\nclass Solution {\n    public int numWays(int n, int[][] rs, int k) {\n        int[][] f = new int[k + 1][n];\n        f[0][0] = 1;\n        for (int i = 1; i <= k; i++) {\n            for (int[] r : rs) {\n                int a = r[0], b = r[1];\n                f[i][b] += f[i - 1][a];\n            }\n        }\n        return f[k][n - 1];\n    }\n}\n```\n* 时间复杂度:$O(relation.length * k)$\n* 空间复杂度:$O(n * k)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `LCP 07` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/LCR/LCR 161. 连续天数的最高销售额（简单）.md", "url_title": "LCR 161. 连续天数的最高销售额", "url": "https://leetcode.cn/problems/lian-xu-zi-shu-zu-de-zui-da-he-lcof/solution/gong-shui-san-xie-tu-jie-cong-on-chang-g-se9p/", "difficulty": "简单", "tags": ["前缀和", "区间求和问题", "线性 DP", "分治"], "question": "某公司每日销售额记于整数数组 `sales`,请返回所有连续一或多天销售额总和的最大值。\n\n要求实现时间复杂度为 $O(n)$ 的算法。\n\n示例 1:\n```\n输入:sales = [-2,1,-3,4,-1,2,1,-5,4]\n\n输出:6\n\n解释:[4,-1,2,1] 此连续四天的销售总额最高,为 6。\n```\n示例 2:\n```\n输入:sales = [5,4,-1,7,8]\n\n输出:23\n\n解释:[5,4,-1,7,8] 此连续五天的销售总额最高,为 23。 \n```\n\n提示:\n* $1 <= arr.length <= 10^5$\n* $-100 <= arr[i] <= 100$", "solution": "### 前缀和 or 线性 DP\n\n当要我们求「连续段」区域和的时候,要很自然的想到「前缀和」。\n\n所谓前缀和,是指对原数组“累计和”的描述,通常是指一个与原数组等长的数组。\n\n设前缀和数组为 `sum`,**`sum` 的每一位记录的是从「起始位置」到「当前位置」的元素和**。例如 $sum[x]$ 是指原数组中“起始位置”到“位置 `x`”这一连续段的元素和。\n\n有了前缀和数组 `sum`,当我们求连续段 $[i, j]$ 的区域和时,利用「容斥原理」,便可进行快速求解。\n\n通用公式:`ans = sum[j] - sum[i - 1]`。\n\n由于涉及 `-1` 操作,为减少边界处理,我们可让前缀和数组下标从 $1$ 开始。在进行快速求和时,再根据原数组下标是否从 $1$ 开始,决定是否进行相应的下标偏移。\n\n学习完一维前缀和后,回到本题。\n\n先用 `nums` 预处理出前缀和数组 `sum`,然后在遍历子数组右端点 `j` 的过程中,通过变量 `m` 动态记录已访问的左端点 `i` 的前缀和最小值。最终,在所有 `sum[j] - m` 的取值中选取最大值作为答案。\n\n代码实现上,我们无需明确计算前缀和数组 `sum`,而是使用变量 `s` 表示当前累计的前缀和(充当右端点),并利用变量 `m` 记录已访问的前缀和的最小值(充当左端点)即可。\n\n**本题除了将其看作为「前缀和裸题用有限变量进行空间优化」以外,还能以「线性 DP」角度进行理解。**\n\n定义 $f[i]$ 为考虑前 $i$ 个元素,且第 $nums[i]$ 必选的情况下,形成子数组的最大和。\n\n不难发现,仅考虑前 $i$ 个元素,且 $nums[i]$ 必然参与的子数组中。要么是 $nums[i]$ 自己一个成为子数组,要么与前面的元素共同组成子数组。\n\n因此,状态转移方程:\n$$\nf[i] = \\max(f[i - 1] + nums[i], nums[i])\n$$\n\n由于 $f[i]$ 仅依赖于 $f[i - 1]$ 进行转移,可使用有限变量进行优化,因此写出来的代码也是和上述前缀和角度分析的类似。\n\nJava 代码:\n```Java\nclass Solution {\n    public int maxSales(int[] nums) {\n        int s = 0, m = 0, ans = -10010;\n        for (int x : nums) {\n            s += x;\n            ans = Math.max(ans, s - m);\n            m = Math.min(m, s);\n        }\n        return ans;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    int maxSales(vector<int>& nums) {\n        int s = 0, m = 0, ans = -10010;\n        for (int x : nums) {\n            s += x;\n            ans = max(ans, s - m);\n            m = min(m, s);\n        }\n        return ans;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxSales(self, nums: List[int]) -> int:\n        s, m, ans = 0, 0, -10010\n        for x in nums:\n            s += x\n            ans = max(ans, s - m)\n            m = min(m, s)\n        return ans\n```\nTypeScript 代码:\n```TypeScript\nfunction maxSales(nums: number[]): number {\n    let s = 0, m = 0, ans = -10010;\n    for (let x of nums) {\n        s += x;\n        ans = Math.max(ans, s - m);\n        m = Math.min(m, s);\n    }\n    return ans;\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 分治\n\n“分治法”的核心思路是将大问题拆分成更小且相似的子问题,通过递归解决这些子问题,最终合并子问题的解来得到原问题的解。\n\n实现分治,关键在于对“递归函数”的设计(入参 & 返回值)。\n\n在涉及数组的分治题中,左右下标 `l` 和 `r` 必然会作为函数入参,因为它能用于表示当前所处理的区间,即小问题的范围。\n\n对于本题,仅将最大子数组和(答案)作为返回值并不足够,因为单纯从小区间的解无法直接推导出大区间的解,我们需要一些额外信息来辅助求解。\n\n具体的,我们可以将返回值设计成四元组,分别代表 `区间和`,`前缀最大值`,`后缀最大值` 和 `最大子数组和`,用 `[sum, lm, rm, max]` 表示。\n\n有了完整的函数签名 `int[] dfs(int[] nums, int l, int r)`,考虑如何实现分治:\n\n1. 根据当前区间 $[l, r]$ 的长度进行分情况讨论:\n   1. 若 $l = r$,只有一个元素,区间和为 $nums[l]$,而 最大子数组和、前缀最大值 和 后缀最大值 由于允许“空数组”,因此均为 $\\max(nums[l], 0)$\n   2. 否则,将当前问题划分为两个子问题,通常会划分为两个相同大小的子问题,划分为 $[l, mid]$ 和 $[mid + 1, r]$ 两份,递归求解,其中 $mid = \\left \\lfloor \\frac{l + r}2{} \\right \\rfloor$\n\n随后考虑如何用“子问题”的解合并成“原问题”的解:\n\n1. **合并区间和 (`sum`):** 当前问题的区间和等于左右两个子问题的区间和之和,即 `sum = left[0] + right[0]`。\n2. **合并前缀最大值 (`lm`):** 当前问题的前缀最大值可以是左子问题的前缀最大值,或者左子问题的区间和加上右子问题的前缀最大值。即 `lm = max(left[1], left[0] + right[1])`。\n3. **合并后缀最大值 (`rm`):** 当前问题的后缀最大值可以是右子问题的后缀最大值,或者右子问题的区间和加上左子问题的后缀最大值。即 `rm = max(right[2], right[0] + left[2])`。\n4. **合并最大子数组和 (`max`):** 当前问题的最大子数组和可能出现在左子问题、右子问题,或者跨越左右两个子问题的边界。因此,`max` 可以通过 `max(left[3], right[3], left[2] + right[1])` 来得到。\n\n一些细节:由于我们在计算 `lm`、`rm` 和 `max` 的时候允许数组为空,而答案对子数组的要求是至少包含一个元素。因此对于 `nums` 全为负数的情况,我们会错误得出最大子数组和为 `0` 的答案。针对该情况,需特殊处理,遍历一遍 `nums`,若最大值为负数,直接返回最大值。\n\nJava 代码:\n\n```Java\nclass Solution {\n    // 返回值: [sum, lm, rm, max] = [区间和, 前缀最大值, 后缀最大值, 最大子数组和]\n    int[] dfs(int[] nums, int l, int r) {\n        if (l == r) {\n            int t = Math.max(nums[l], 0);\n            return new int[]{nums[l], t, t, t};\n        }\n        // 划分成两个子区间,分别求解\n        int mid = l + r >> 1;\n        int[] left = dfs(nums, l, mid), right = dfs(nums, mid + 1, r);\n        // 组合左右子区间的信息,得到当前区间的信息\n        int[] ans = new int[4];\n        ans[0] = left[0] + right[0]; // 当前区间和\n        ans[1] = Math.max(left[1], left[0] + right[1]); // 当前区间前缀最大值\n        ans[2] = Math.max(right[2], right[0] + left[2]); // 当前区间后缀最大值\n        ans[3] = Math.max(Math.max(left[3], right[3]), left[2] + right[1]); // 最大子数组和\n        return ans;\n    }\n    public int maxSales(int[] nums) {\n        int m = nums[0];\n        for (int x : nums) m = Math.max(m, x);\n        if (m <= 0) return m;\n        return dfs(nums, 0, nums.length - 1)[3];\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    // 返回值: [sum, lm, rm, max] = [区间和, 前缀最大值, 后缀最大值, 最大子数组和]\n    vector<int> dfs(vector<int>& nums, int l, int r) {\n        if (l == r) {\n            int t = max(nums[l], 0);\n            return {nums[l], t, t, t};\n        }\n        // 划分成两个子区间,分别求解\n        int mid = l + r >> 1;\n        auto left = dfs(nums, l, mid), right = dfs(nums, mid + 1, r);\n        // 组合左右子区间的信息,得到当前区间的信息\n        vector<int> ans(4);\n        ans[0] = left[0] + right[0]; // 当前区间和\n        ans[1] = max(left[1], left[0] + right[1]); // 当前区间前缀最大值\n        ans[2] = max(right[2], right[0] + left[2]); // 当前区间后缀最大值\n        ans[3] = max({left[3], right[3], left[2] + right[1]}); // 最大子数组和\n        return ans;\n    }\n    int maxSales(vector<int>& nums) {\n        int m = nums[0];\n        for (int x : nums) m = max(m, x);\n        if (m <= 0) return m;\n        return dfs(nums, 0, nums.size() - 1)[3];\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def maxSales(self, nums: List[int]) -> int:\n        def dfs(l, r):\n            if l == r:\n                t = max(nums[l], 0)\n                return [nums[l], t, t, t]\n            # 划分成两个子区间,分别求解\n            mid = (l + r) // 2\n            left, right = dfs(l, mid), dfs(mid + 1, r)\n            # 组合左右子区间的信息,得到当前区间的信息\n            ans = [0] * 4\n            ans[0] = left[0] + right[0] # 当前区间和\n            ans[1] = max(left[1], left[0] + right[1]) # 当前区间前缀最大值\n            ans[2] = max(right[2], right[0] + left[2]) # 当前区间后缀最大值\n            ans[3] = max(left[3], right[3], left[2] + right[1]) # 最大子数组和\n            return ans\n        \n        m = max(nums)\n        if m <= 0:\n            return m\n        return dfs(0, len(nums) - 1)[3]\n```\nTypeScript 代码:\n```TypeScript\nfunction maxSales(nums: number[]): number {\n    const dfs = function (l: number, r: number): number[] {\n        if (l == r) {\n            const t = Math.max(nums[l], 0);\n            return [nums[l], t, t, t];\n        }\n        // 划分成两个子区间,分别求解\n        const mid = (l + r) >> 1;\n        const left = dfs(l, mid), right = dfs(mid + 1, r);\n        // 组合左右子区间的信息,得到当前区间的信息\n        const ans = Array(4).fill(0);\n        ans[0] = left[0] + right[0]; // 当前区间和\n        ans[1] = Math.max(left[1], left[0] + right[1]); // 当前区间前缀最大值\n        ans[2] = Math.max(right[2], right[0] + left[2]); // 当前区间后缀最大值\n        ans[3] = Math.max(left[3], right[3], left[2] + right[1]); // 最大子数组和\n        return ans;\n    }\n    \n    const m = Math.max(...nums);\n    if (m <= 0) return m;\n    return dfs(0, nums.length - 1)[3];\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.LCR 161` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer II/剑指 Offer II 003. 前 n 个数字二进制中 1 的个数（简单）.md", "url_title": "剑指 Offer II 003. 前 n 个数字二进制中 1 的个数", "url": "https://leetcode.cn/problems/w3tCBm/solution/by-ac_oier-cnlt/", "difficulty": "简单", "tags": ["模拟", "动态规划"], "question": "给定一个非负整数 `n` ,请计算 `0` 到 `n` 之间的每个数字的二进制表示中 $1$ 的个数,并输出一个数组。\n\n示例 1:\n```\n输入: n = 2\n\n输出: [0,1,1]\n\n解释: \n0 --> 0\n1 --> 1\n2 --> 10\n```\n示例 2:\n```\n输入: n = 5\n\n输出: [0,1,1,2,1,2]\n\n解释:\n0 --> 0\n1 --> 1\n2 --> 10\n3 --> 11\n4 --> 100\n5 --> 101\n```\n\n说明 :\n* $0 <= n <= 10^5$\n\n进阶:\n* 给出时间复杂度为 $O(n \\times sizeof(integer))$ 的解答非常容易。但你可以在线性时间 $O(n)$ 内用一趟扫描做到吗?\n* 要求算法的空间复杂度为 $O(n)$。\n* 你能进一步完善解法吗?要求在 `C++` 或任何其他语言中不使用任何内置函数(如 `C++` 中的 `__builtin_popcount` )来执行此操作。", "solution": "### 模拟\n\n这道题要对每个数进行统计,因此不会有比 $O(n)$ 更低的做法。\n\n而很容易想到的朴素做法是对每个数进行「位运算」计数,每个数都是 $32$ 位的,因此是一个 $O(32n)$ 的做法。\n\n代码:\n```Java\nclass Solution {\n    public int[] countBits(int n) {\n        int[] ans = new int[n + 1];\n        for (int i = 0; i <= n; i++) ans[i] = getCnt(i);\n        return ans;\n    }\n    int getCnt(int u) {\n        int ans = 0;\n        for (int i = 0; i < 32; i++) ans += (u >> i) & 1;\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:使用与输入同等规模的空间存储答案。复杂度为 $O(n)$\n\n---\n\n### 动态规划\n\n事实上,这道题是有严格 $O(n)$ 的解法的,要求 $O(n)$ 复杂度又是输出方案的题,通常就是递推的 DP 题。\n\n用已算出的值去凑出要算的值。\n\n那么对于这类问题我们该如何考虑呢?一般是靠经验,如果实在没见过这类题型的话,我们就需要在纸上画一下,分析一下我们**朴素做法的最后一步**是怎么进行的。\n\n不失一般性的,假设当前我要统计的数的 `i`,`i` 对应的二进制表示是 `00000...0010100101`(共 32 位)\n\n如果我们是使用「朴素解法」求解的话,无论是从高位进行统计,还是从低位进行统计,最后一位扫描的都是边缘的数(如果是 1 就计数,不是 1 就不计数)。\n\n* **从低位到高位**,最后一步在扫描**最高位**之前,**统计出 1 的个数应该等同于将 `i` 左移一位,并在最低位补 0,也就是等于 `ans[i << 1]`,这时候就要求我们在计算 `i` 的时候 `i << 1` 已经被算出来(从大到小遍历)**\n* **从高位到低位**,最后一步在扫描**最低位**之前,**统计出 1 的个数应该等同于将 `i` 右移一位,并在最高位补 0,也就是等于 `ans[i >> 1]`,这时候就要求我们在计算 `i` 的时候 `i >> 1` 已经被算出来(从小到大遍历)**\n\n通过**对「朴素做法」的最后一步分析**,转移方程就出来了:\n\n* 当**从大到小遍历** :$f(i) = f(i << 1) + ((i >>31 ) \\& 1)$\n* 当**从小到大遍历** :$f(i) = f(i >> 1) + ( i \\& 1 )$\n\n代码:\n```Java\nclass Solution {\n    // 从小到大遍历\n    public int[] countBits(int n) {\n        int[] ans = new int[n + 1];\n        // ans[i] = 「i >> 1 所包含的 1 的个数」+「i 的最低位是否为 1」\n        for (int i = 1; i <= n; i++) ans[i] = ans[i >> 1] + (i & 1);\n        return ans;\n    }\n}\n```\n-\n```Java\nclass Solution {\n    // 从大到小遍历\n    public int[] countBits(int n) {\n        int[] ans = new int[n + 1];\n        for (int i = n; i >= 0; i--) {\n            // 如果计算 i 所需要的 i << 1 超过 n,则不存储在 ans 内,需要额外计算\n            int u = i << 1 <= n ? ans[i << 1] : getCnt(i << 1);\n            // ans[i] =「i << 1 所包含的 1 的个数」 + 「i 的最高位是否为 1」\n            ans[i] = u + ((i >> 31) & 1);\n        } \n        return ans;\n    }\n    int getCnt(int u) {\n        int ans = 0;\n        for (int i = 0; i < 32; i++) ans += (u >> i) & 1;\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:使用与输入同等规模的空间存储答案。复杂度为 $O(n)$\n\n---\n\n### 位运算说明\n\n* `a >> b & 1` 代表检查 `a` 的第 `b` 位是否为 $1$,有两种可能性 $0$ 或者 $1$\n\n* `a += 1 << b` 代表将 `a` 的第 `b` 位设置为 $1$ (当第 `b` 位为 $0$ 的时候适用)\n\n如不想写对第 `b` 位为 $0$ 的前置判断,`a += 1 << b` 也可以改成 `a |= 1 << b`\n\n在之前的题解我就强调过,以上两个操作在位运算中**使用频率超高,建议每位同学都加深理解**。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 003` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer II/剑指 Offer II 005. 单词长度的最大乘积（中等）.md", "url_title": "剑指 Offer II 005. 单词长度的最大乘积", "url": "https://leetcode.cn/problems/aseY1I/solution/by-ac_oier-qk3a/", "difficulty": "中等", "tags": ["模拟", "位运算"], "question": "给定一个字符串数组 `words`,请计算当两个字符串 `words[i]` 和 `words[j]` 不包含相同字符时,它们长度的乘积的最大值。假设字符串中只包含英语的小写字母。如果没有不包含相同字符的一对字符串,返回 $0$。\n\n示例 1:\n```\n输入: words = [\"abcw\",\"baz\",\"foo\",\"bar\",\"fxyz\",\"abcdef\"]\n\n输出: 16 \n\n解释: 这两个单词为 \"abcw\", \"fxyz\"。它们不包含相同字符,且长度的乘积最大。\n```\n示例 2:\n```\n输入: words = [\"a\",\"ab\",\"abc\",\"d\",\"cd\",\"bcd\",\"abcd\"]\n\n输出: 4 \n\n解释: 这两个单词为 \"ab\", \"cd\"。\n```\n示例 3:\n```\n输入: words = [\"a\",\"aa\",\"aaa\",\"aaaa\"]\n\n输出: 0 \n\n解释: 不存在这样的两个单词。\n```\n\n提示:\n* $2 <= words.length <= 1000$\n* $1 <= words[i].length <= 1000$\n* `words[i]` 仅包含小写字母", "solution": "### 模拟\n\n根据题意进行模拟即可,利用每个 $words[i]$ 只有小写字母,且只需要区分两字符是否有字母重复。\n\n我们可以使用一个 `int` 来代指某个 $word[i]$:低 $26$ 来代指字母 `a-z` 是否出现过。\n\n然后对每个「字符对」所对应的两个 `int` 值执行 `&` 操作(若两字符无重复字符,则结果为 $0$),并得出最终答案。\n\n代码:\n```Java []\nclass Solution {\n    public int maxProduct(String[] words) {\n        int n = words.length, idx = 0;\n        int[] masks = new int[n];\n        for (String w : words) {\n            int t = 0;\n            for (int i = 0; i < w.length(); i++) {\n                int u = w.charAt(i) - 'a';\n                t |= (1 << u);\n            }\n            masks[idx++] = t;\n        }\n        int ans = 0;\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < i; j++) {\n                if ((masks[i] & masks[j]) == 0) ans = Math.max(ans, words[i].length() * words[j].length());\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为 $words$ 数组的长度,转换出 $masks$ 的复杂度为 $O(\\sum_{i = 0}^{i = n - 1}words[i].length)$;得到答案的复杂度为 $O(n^2)$。整体复杂度为 $O(\\max(\\sum_{i = 0}^{i = n - 1}words[i].length, n^2))$\n* 空间复杂度:$O(n)$\n\n---\n\n### 优化\n\n不难发现,对于词频相同($mask$ 值相等)的两字符,只需要保留字符长度大的即可,因此我们可以使用「哈希表」代替 $masks$ 数组。\n\n代码:\n```Java\nclass Solution {\n    public int maxProduct(String[] words) {\n        Map<Integer, Integer> map = new HashMap<>();\n        for (String w : words) {\n            int t = 0, m = w.length();\n            for (int i = 0; i < m; i++) {\n                int u = w.charAt(i) - 'a';\n                t |= (1 << u);\n            }\n            if (!map.containsKey(t) || map.get(t) < m) map.put(t, m);\n        }\n        int ans = 0;\n        for (int a : map.keySet()) {\n            for (int b : map.keySet()) {\n                if ((a & b) == 0) ans = Math.max(ans, map.get(a) * map.get(b));\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为 $words$ 数组的长度,得到 $map$ 的复杂度为 $O(\\sum_{i = 0}^{i = n - 1}words[i].length)$;得到答案的复杂度为 $O(n^2)$。整体复杂度为 $O(\\max(\\sum_{i = 0}^{i = n - 1}words[i].length, n^2))$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 005` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer II/剑指 Offer II 007. 数组中和为 0 的三个数（中等）.md", "url_title": "剑指 Offer II 007. 数组中和为 0 的三个数", "url": "https://leetcode.cn/problems/1fGaJU/solution/by-ac_oier-6mfb/", "difficulty": "中等", "tags": ["双指针", "排序", "n 数之和"], "question": "给你一个包含 $n$ 个整数的数组 `nums`,判断 `nums` 中是否存在三个元素 `a`,`b`,`c` ,使得 `a + b + c = 0` ?\n\n请你找出所有和为 $0$ 且不重复的三元组。\n\n注意:答案中不可以包含重复的三元组。\n\n示例 1:\n```\n输入:nums = [-1,0,1,2,-1,-4]\n\n输出:[[-1,-1,2],[-1,0,1]]\n```\n示例 2:\n```\n输入:nums = []\n\n输出:[]\n```\n示例 3:\n```\n输入:nums = [0]\n\n输出:[]\n```\n\n提示:\n* $0 <= nums.length <= 3000$\n* $-10^5 <= nums[i] <= 10^5$", "solution": "### 排序 + 双指针\n\n对数组进行排序,使用三个指针 `i`、`j` 和 `k` 分别代表要找的三个数。\n\n1. 通过枚举 `i` 确定第一个数,另外两个指针 `j`,`k` 分别从左边 `i + 1` 和右边 `n - 1` 往中间移动,找到满足 `nums[i] + nums[j] + nums[k] == 0` 的所有组合。\n\n2. `j` 和 `k` 指针的移动逻辑,分情况讨论 `sum = nums[i] + nums[j] + nums[k]` :\n    * `sum` > 0:`k` 左移,使 `sum` 变小\n    * `sum` < 0:`j` 右移,使 `sum` 变大\n    * `sum` = 0:找到符合要求的答案,存起来\n\n由于题目要求答案不能包含重复的三元组,所以在确定第一个数和第二个数的时候,要跳过数值一样的下标(在三数之和确定的情况下,确保第一个数和第二个数不会重复,即可保证三元组不重复)。\n\n代码:\n```Java\nclass Solution {\n    public List<List<Integer>> threeSum(int[] nums) {\n        Arrays.sort(nums);\n        int n = nums.length;\n        List<List<Integer>> ans = new ArrayList<>();\n        for (int i = 0; i < n; i++) {\n            if (i > 0 && nums[i] == nums[i - 1]) continue;\n            int j = i + 1, k = n - 1;\n            while (j < k) {\n                while (j > i + 1 && j < n && nums[j] == nums[j - 1]) j++;\n                if (j >= k) break;\n                int sum = nums[i] + nums[j] + nums[k];\n                if (sum == 0) {\n                    ans.add(Arrays.asList(nums[i], nums[j], nums[k]));\n                    j++;\n                } else if (sum > 0) {\n                    k--;\n                } else if (sum < 0) {\n                    j++;\n                }\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序的复杂度为 $O(n\\log{n})$,对于每个 `i` 而言,最坏的情况 `j` 和 `k` 都要扫描一遍数组的剩余部分,复杂度为 $O(n^2)$。整体复杂度为 $O(n^2)$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 007` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer II/剑指 Offer II 008. 和大于等于 target 的最短子数组（中等）.md", "url_title": "剑指 Offer II 008. 和大于等于 target 的最短子数组", "url": "https://leetcode.cn/problems/2VG8Kg/solution/by-ac_oier-vw5r/", "difficulty": "中等", "tags": ["前缀和", "二分"], "question": "给定一个含有 `n` 个正整数的数组和一个正整数 `target`。\n\n找出该数组中满足其和 `≥ target` 的长度最小的 连续子数组 $[nums_{l}, nums_{l+1}, ..., nums_{r-1}, nums_{r}]$ ,并返回其长度。如果不存在符合条件的子数组,返回 $0$ 。\n\n示例 1:\n```\n输入:target = 7, nums = [2,3,1,2,4,3]\n\n输出:2\n\n解释:子数组 [4,3] 是该条件下的长度最小的子数组。\n```\n示例 2:\n```\n输入:target = 4, nums = [1,4,4]\n\n输出:1\n```\n示例 3:\n```\n输入:target = 11, nums = [1,1,1,1,1,1,1,1]\n\n输出:0\n```\n\n提示:\n* $1 <= target <= 10^9$\n* $1 <= nums.length <= 10^5$\n* $1 <= nums[i] <= 10^5$", "solution": "### 前缀和 + 二分\n\n利用 $nums[i]$ 的数据范围为 $[1, 10^5]$,可知前缀和数组满足「单调递增」。\n\n我们先预处理出前缀和数组 `sum`(前缀和数组下标默认从 $1$ 开始),对于每个 $nums[i]$ 而言,假设其对应的前缀和值为 $s = sum[i + 1]$,我们将 $nums[i]$ 视为子数组的右端点,问题转换为:在前缀和数组下标 $[0, i]$ 范围内找到满足「**值小于等于 $s - t$**」的最大下标,充当子数组左端点的前一个值。\n\n利用前缀和数组的「单调递增」(即具有二段性),该操作可使用「二分」来做。\n\n代码:\n```Java\nclass Solution {\n    public int minSubArrayLen(int t, int[] nums) {\n        int n = nums.length, ans = n + 10;\n        int[] sum = new int[n + 10];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n        for (int i = 1; i <= n; i++) {\n            int s = sum[i], d = s - t;\n            int l = 0, r = i;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (sum[mid] <= d) l = mid;\n                else r = mid - 1;\n            }\n            if (sum[r] <= d) ans = Math.min(ans, i - r);\n        }\n        return ans == n + 10 ? 0 : ans;\n    }\n}\n```\n* 时间复杂度:预处理前缀和数组的复杂度为 $O(n)$,遍历前缀和数组统计答案复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 008` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer II/剑指 Offer II 009. 乘积小于 K 的子数组（中等）.md", "url_title": "剑指 Offer II 009. 乘积小于 K 的子数组", "url": "https://leetcode.cn/problems/ZVAVXX/solution/by-ac_oier-lop5/", "difficulty": "中等", "tags": ["滑动窗口", "双指针"], "question": "给你一个整数数组 `nums` 和一个整数 $k$ ,请你返回子数组内所有元素的乘积严格小于 $k$ 的连续子数组的数目。\n\n示例 1:\n```\n输入:nums = [10,5,2,6], k = 100\n\n输出:8\n\n解释:8 个乘积小于 100 的子数组分别为:[10]、[5]、[2],、[6]、[10,5]、[5,2]、[2,6]、[5,2,6]。\n需要注意的是 [10,5,2] 并不是乘积小于 100 的子数组。\n```\n示例 2:\n```\n输入:nums = [1,2,3], k = 0\n\n输出:0\n```\n\n提示: \n* $1 <= nums.length <= 3 \\times 10^4$\n* $1 <= nums[i] <= 1000$\n* $0 <= k <= 10^6$", "solution": "### 滑动窗口\n\n利用 $1 <= nums[i] <= 1000$,我们可以从前往后处理所有的 $nums[i]$,使用一个变量 $cur$ 记录当前窗口的乘积,使用两个变量 $j$ 和 $i$ 分别代表当前窗口的左右端点。\n\n当 $cur >= k$ 时,我们考虑将左端点 $j$ 右移,同时消除原来左端点元素 $nums[j]$ 对 $cur$ 的贡献,直到 $cur >= k$ 不再满足,这样我们就可以得到每个右端点 $nums[i]$ 的最远左端点 $nums[j]$,从而得知以 $nums[i]$ 为结尾的合法子数组个数为 $i - j + 1$。\n\nJava 代码:\n```Java \nclass Solution {\n    public int numSubarrayProductLessThanK(int[] nums, int k) {\n        int n = nums.length, ans = 0;\n        if (k <= 1) return 0;\n        for (int i = 0, j = 0, cur = 1; i < n; i++) {\n            cur *= nums[i];\n            while (cur >= k) cur /= nums[j++];\n            ans += i - j + 1;\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction numSubarrayProductLessThanK(nums: number[], k: number): number {\n    let n = nums.length, ans = 0\n    if (k <= 1) return 0\n    for (let i = 0, j = 0, cur = 1; i < n; i++) {\n        cur *= nums[i]\n        while (cur >= k) cur /= nums[j++]\n        ans += i - j + 1\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 009` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer II/剑指 Offer II 010. 和为 k 的子数组（中等）.md", "url_title": "剑指 Offer II 010. 和为 k 的子数组", "url": "https://leetcode.cn/problems/QTMn0o/solution/by-ac_oier-hr6k/", "difficulty": "中等", "tags": ["前缀和", "哈希表"], "question": "给你一个整数数组 `nums` 和一个整数 `k` ,请你统计并返回该数组中和为 `k` 的子数组的个数 。\n\n示例 1:\n```\n输入:nums = [1,1,1], k = 2\n\n输出:2\n```\n示例 2:\n```\n输入:nums = [1,2,3], k = 3\n\n输出:2\n```\n\n提示:\n* $1 <= nums.length <= 2 \\times 10^4$\n* $-1000 <= nums[i] <= 1000$\n* $-10^7 <= k <= 10^7$", "solution": "### 前缀和 + 哈希表\n\n这是一道经典的前缀和运用题。\n\n统计以每一个 $nums[i]$ 为结尾,和为 $k$ 的子数组数量即是答案。\n\n我们可以预处理前缀和数组 `sum`(前缀和数组下标默认从 $1$ 开始),对于求解以某一个 $nums[i]$ 为结尾的,和为 $k$ 的子数组数量,本质上是求解在 $[0, i]$ 中,`sum` 数组中有多少个值为 $sum[i + 1] - k$ 的数,这可以在遍历过程中使用「哈希表」进行同步记录。\n\nJava 代码:\n```Java\nclass Solution {\n    public int subarraySum(int[] nums, int k) {\n        int n = nums.length, ans = 0;\n        int[] sum = new int[n + 10];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];\n        Map<Integer, Integer> map = new HashMap<>();\n        map.put(0, 1);\n        for (int i = 1; i <= n; i++) {\n            int t = sum[i], d = t - k;\n            ans += map.getOrDefault(d, 0);\n            map.put(t, map.getOrDefault(t, 0) + 1);\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction subarraySum(nums: number[], k: number): number {\n    let n = nums.length, ans = 0\n    const sum = new Array<number>(n + 10).fill(0)\n    for (let i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1]\n    const map = new Map<number, number>()\n    map.set(0, 1)\n    for (let i = 1; i <= n; i++) {\n        const t = sum[i], d = t - k\n        if (map.has(d)) ans += map.get(d)\n        map.set(t, map.has(t) ? map.get(t) + 1 : 1)\n    }\n    return ans\n};\n```\n* 时间复杂度:预处理前缀和的复杂度为 $O(n)$,统计答案的复杂度为 $O(n)$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 010` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer II/剑指 Offer II 011. 0 和 1 个数相同的子数组（中等）.md", "url_title": "剑指 Offer II 011. 0 和 1 个数相同的子数组", "url": "https://leetcode-cn.com/problems/contiguous-array/solution/gong-shui-san-xie-qian-zhui-he-ha-xi-bia-q400/", "difficulty": "中等", "tags": ["前缀和", "哈希表"], "question": "给定一个二进制数组 `nums` , 找到含有相同数量的 $0$ 和 $1$ 的最长连续子数组,并返回该子数组的长度。\n\n示例 1:\n```\n输入: nums = [0,1]\n\n输出: 2\n\n说明: [0, 1] 是具有相同数量0和1的最长连续子数组。\n```\n示例 2:\n```\n输入: nums = [0,1,0]\n\n输出: 2\n\n说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* `nums[i]` 不是 $0$ 就是 $1$", "solution": "### 前缀和 + 哈希表\n\n根据题意,我们可以轻易发现如下性质:如果答案非 $0$,那么子数组长度必然为偶数,且长度至少为 $2$。\n\n具体的,我们在预处理前缀和时,将 $nums[i]$ 为 $0$ 的值当做 $-1$ 处理。\n\n从而将问题转化为:**如何求得最长一段区间和为 $0$ 的子数组。** 同时使用「哈希表」来记录「某个前缀和出现的最小下标」是多少。\n\nJava 代码:\n```Java\nclass Solution {\n    public int findMaxLength(int[] nums) {\n        int n = nums.length, ans = 0;\n        int[] sum = new int[n + 10];\n        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (nums[i - 1] == 0 ? -1 : 1);\n        Map<Integer, Integer> map = new HashMap<>();\n        map.put(0, 0);\n        for (int i = 1; i <= n; i++) {\n            int t = sum[i];\n            if (map.containsKey(t)) ans = Math.max(ans, i - map.get(t));\n            if (!map.containsKey(t)) map.put(t, i);\n        }\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction findMaxLength(nums: number[]): number {\n    let n = nums.length, ans = 0\n    const sum = new Array<number>(n + 10).fill(0)\n    for (let i = 1; i <= n; i++) sum[i] = sum[i - 1] + (nums[i - 1] == 0 ? -1 : 1)\n    const map = new Map<number, number>()\n    map.set(0, 0)\n    for (let i = 1; i <= n; i++) {\n        const t = sum[i]\n        if (map.has(t)) ans = Math.max(ans, i - map.get(t))\n        if (!map.has(t)) map.set(t, i)\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 011` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer II/剑指 Offer II 029. 排序的循环链表（中等）.md", "url_title": "剑指 Offer II 029. 排序的循环链表", "url": "https://leetcode.cn/problems/4ueAj6/solution/by-ac_oier-kqv3/", "difficulty": "中等", "tags": ["链表", "模拟"], "question": "给定循环单调非递减列表中的一个点,写一个函数向这个列表中插入一个新元素 `insertVal`,使这个列表仍然是循环升序的。\n\n给定的可以是这个列表中任意一个顶点的指针,并不一定是这个列表中最小元素的指针。\n\n如果有多个满足条件的插入位置,可以选择任意一个位置插入新的值,插入后整个列表仍然保持有序。\n\n如果列表为空(给定的节点是 `null`),需要创建一个循环有序列表并返回这个节点。否则。请返回原先给定的节点。\n\n示例 1:\n\n```\n输入:head = [3,4,1], insertVal = 2\n\n输出:[3,4,1,2]\n```\n\n```\n解释:在上图中,有一个包含三个元素的循环有序列表,你获得值为 3 的节点的指针,我们需要向表中插入元素 2 。新插入的节点应该在 1 和 3 之间,插入之后,整个列表如上图所示,最后返回节点 3 。\n```\n\n示例 2:\n```\n输入:head = [], insertVal = 1\n\n输出:[1]\n\n解释:列表为空(给定的节点是 null),创建一个循环有序列表并返回这个节点。\n```\n示例 3:\n```\n输入:head = [1], insertVal = 0\n\n输出:[1,0]\n```\n\n提示:\n* $0 <= Number of Nodes <= 5 \\times 10^4$\n* $-10^6 <= Node.val <= 10^6$\n* $-10^6 <= insertVal <= 10^6$", "solution": "### 链表\n\n这是一道常规的链表模拟题。\n\n为了方便,我们记 `insertVal` 为 `x`,记 `head` 为 `he`。\n\n起始我们先将待插入的节点创建出来,记为 `t`,当 `he` 为空时,直接返回 `t` 即可。\n\n由于我们需要返回原本的头结点,因此我们先使用变量 `ans` 对原始的 `he` 进行转存,随后复用 `he` 来充当游标进行遍历。\n\n我们先对链表进行一次完成遍历,遍历过程中维护节点最值 `max` 和 `min`,由于链表是循环的,我们需要使用 `he.next != ans` 作为我们循环的结束条件,含义为回到链表开头。\n\n此时根据最大值和最小值是否相等(即整段链表值是否一致)来进行分情况讨论:\n\n* 若满足 `max = min`,此时目标节点 `t` 插入在哪个位置都满足条件,我们直接将其与 `ans` 关联即可;\n* 若不满足 `max = min`,此时我们先对链表进行一次遍历,找到有序列表的结束点(结束点的定义为:当前节点值为最大值,下一节点值为最小值。即为有序链表分割位置的左端点),在根据「插入值 `x` 是否为新链表的最值」进行分情况讨论:\n    * 若满足 $x >= max$ 或 $x <= min$ ,说明目标节点 `t` 插入分割位置即可;\n    * 若不满足上述两条件,需要从分割位置出发,找到目标插入位置,即满足 `he.val <= x && x <= he.next.val` 的位置。\n\n代码:\n```Java\nclass Solution {\n    public Node insert(Node he, int x) {\n        Node t = new Node(x);\n        t.next = t;\n        if (he == null) return t;\n        Node ans = he;\n        int min = he.val, max = he.val;\n        while (he.next != ans) {\n            he = he.next;\n            min = Math.min(min, he.val);\n            max = Math.max(max, he.val);\n        }\n        if (min == max) {\n            t.next = ans.next;\n            ans.next = t;\n        } else {\n            while (!(he.val == max && he.next.val == min)) he = he.next;\n            while (!(x <= min || x >= max) && !(he.val <= x && x <= he.next.val)) he = he.next;\n            t.next = he.next;\n            he.next = t;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 029` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer II/剑指 Offer II 030. 插入、删除和随机访问都是 O(1) 的容器（中等）.md", "url_title": "剑指 Offer II 030. 插入、删除和随机访问都是 O(1) 的容器", "url": "https://leetcode-cn.com/problems/FortPu/solution/by-ac_oier-rls4/", "difficulty": "中等", "tags": ["数据结构", "哈希表"], "question": "实现 `RandomizedSet` 类:\n\n* `RandomizedSet()` 初始化 `RandomizedSet` 对象\n* `bool insert(int val)` 当元素 `val` 不存在时,向集合中插入该项,并返回 `true`;否则,返回 `false`。\n* `bool remove(int val)` 当元素 `val` 存在时,从集合中移除该项,并返回 `true`;否则,返回 `false`。\n* `int getRandom()` 随机返回现有集合中的一项(测试用例保证调用此方法时集合中至少存在一个元素)。每个元素应该有 相同的概率 被返回。\n\n你必须实现类的所有函数,并满足每个函数的 平均 时间复杂度为 $O(1)$ 。\n\n示例:\n```\n输入\n[\"RandomizedSet\", \"insert\", \"remove\", \"insert\", \"getRandom\", \"remove\", \"insert\", \"getRandom\"]\n[[], [1], [2], [2], [], [1], [2], []]\n\n输出\n[null, true, false, true, 2, true, false, 2]\n\n解释\nRandomizedSet randomizedSet = new RandomizedSet();\nrandomizedSet.insert(1); // 向集合中插入 1 。返回 true 表示 1 被成功地插入。\nrandomizedSet.remove(2); // 返回 false ,表示集合中不存在 2 。\nrandomizedSet.insert(2); // 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。\nrandomizedSet.getRandom(); // getRandom 应随机返回 1 或 2 。\nrandomizedSet.remove(1); // 从集合中移除 1 ,返回 true 。集合现在包含 [2] 。\nrandomizedSet.insert(2); // 2 已在集合中,所以返回 false 。\nrandomizedSet.getRandom(); // 由于 2 是集合中唯一的数字,getRandom 总是返回 2 。\n```\n\n提示:\n* $-2^{31} <= val <= 2^{31} - 1$\n* 最多调用 `insert`、`remove` 和 `getRandom` 函数 $2 * 10^5$ 次\n* 在调用 `getRandom` 方法时,数据结构中 至少存在一个 元素。", "solution": "### 哈希表 + 删除交换\n\n对于 `insert` 和 `remove` 操作容易想到使用「哈希表」来实现 $O(1)$ 复杂度,但对于 `getRandom` 操作,比较理想的情况是能够在一个数组内随机下标进行返回。\n\n将两者结合,我们可以将哈希表设计为:以入参 `val` 为键,数组下标 `loc` 为值。\n\n**为了确保严格 $O(1)$,我们不能「使用拒绝采样」和「在数组非结尾位置添加/删除元素」。**\n\n因此我们需要申请一个足够大的数组 `nums`(利用数据范围为 $2* 10^5$),并使用变量 `idx` 记录当前使用到哪一位(即下标在 $[0, idx]$ 范围内均是存活值)。\n\n对于几类操作逻辑:\n\n* `insert` 操作:使用哈希表判断 `val` 是否存在,存在的话返回 `false`,否则将其添加到 `nums`,更新 `idx`,同时更新哈希表;\n* `remove` 操作:使用哈希表判断 `val` 是否存在,不存在的话返回 `false`,否则从哈希表中将 `val` 删除,同时取出其所在 `nums` 的下标 `loc`,然后将 `nums[idx]` 赋值到 `loc` 位置,并更新 `idx`(含义为将原本处于 `loc` 位置的元素删除),同时更新原本位于 `idx` 位置的数在哈希表中的值为 `loc`(若 `loc` 与 `idx` 相等,说明删除的是最后一个元素,这一步可跳过);\n* `getRandom` 操作:由于我们人为确保了 $[0, idx]$ 均为存活值,因此直接在 $[0, idx + 1)$ 范围内进行随机即可。\n\n代码:\n```Java\nclass RandomizedSet {\n    static int[] nums = new int[200010];\n    Random random = new Random();\n    Map<Integer, Integer> map = new HashMap<>();\n    int idx = -1;\n    public boolean insert(int val) {\n        if (map.containsKey(val)) return false;\n        nums[++idx] = val;\n        map.put(val, idx);\n        return true;\n    }\n    public boolean remove(int val) {\n        if (!map.containsKey(val)) return false;\n        int loc = map.remove(val);\n        if (loc != idx) map.put(nums[idx], loc);\n        nums[loc] = nums[idx--];\n        return true;\n    }\n    public int getRandom() {\n        return nums[random.nextInt(idx + 1)];\n    }\n}\n```\n* 时间复杂度:所有操作均为 $O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 030` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer II/剑指 Offer II 041. 滑动窗口的平均值（简单）.md", "url_title": "剑指 Offer II 041. 滑动窗口的平均值", "url": "https://leetcode.cn/problems/qIsx9U/solution/by-ac_oier-g5ha/", "difficulty": "简单", "tags": ["模拟", "队列"], "question": "给定一个整数数据流和一个窗口大小,根据该滑动窗口的大小,计算滑动窗口里所有数字的平均值。\n\n实现 `MovingAverage` 类:\n\n* `MovingAverage(int size)` 用窗口大小 `size` 初始化对象。\n* `double next(int val)` 成员函数 `next` 每次调用的时候都会往滑动窗口增加一个整数,请计算并返回数据流中最后 `size` 个值的移动平均值,即滑动窗口里所有数字的平均值。\n\n示例:\n```\n输入:\ninputs = [\"MovingAverage\", \"next\", \"next\", \"next\", \"next\"]\ninputs = [[3], [1], [10], [3], [5]]\n\n输出:\n[null, 1.0, 5.5, 4.66667, 6.0]\n\n解释:\nMovingAverage movingAverage = new MovingAverage(3);\nmovingAverage.next(1); // 返回 1.0 = 1 / 1\nmovingAverage.next(10); // 返回 5.5 = (1 + 10) / 2\nmovingAverage.next(3); // 返回 4.66667 = (1 + 10 + 3) / 3\nmovingAverage.next(5); // 返回 6.0 = (10 + 3 + 5) / 3\n```\n\n提示:\n* $1 <= size <= 1000$\n* $-10^5 <= val <= 10^5$\n* 最多调用 `next` 方法 $10^4$ 次", "solution": "### 双端队列\n\n根据题意,我们可以使用变量 `n` 将初始化传入的 `size` 进行转存,同时使用「双端队列」来存储 `next` 所追加的值(添加到队列尾部),当双端队列所包含元素超过规定数量 `n` 时,我们从队列头部进行 `pop` 操作,整个维护过程使用变量 `sum` 记录当前包含的元素和。\n\n利用 `next` 操作最多被调用 $10^4$ 次,我们可以使用直接开个 $10^4$ 数组来充当双端队列,使用两指针 `j` 和 `i` 分别指向队列的头部和尾部。\n\nJava 代码:\n```Java\nclass MovingAverage {\n    int[] arr = new int[10010];\n    int n, sum, j, i;\n    public MovingAverage(int size) {\n        n = size;\n    }\n    public double next(int val) {\n        sum += arr[i++] = val;\n        if (i - j > n) sum -= arr[j++];\n        return sum * 1.0 / (i - j);\n    }\n}\n```\nTypescript 代码:\n```Typescript\nclass MovingAverage {\n    arr: number[] = new Array<number>(10010).fill(0)\n    n: number = 0; sum: number = 0; i: number = 0; j: number = 0;\n    constructor(size: number) {\n        this.n = size\n    }\n    next(val: number): number {\n        this.sum += this.arr[this.i++] = val\n        if (this.i - this.j > this.n) this.sum -= this.arr[this.j++]\n        return this.sum / (this.i - this.j)\n    }\n}\n```\n* 时间复杂度:$O(m)$,其中 $m$ 为 `next` 操作的调用次数\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 041` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer II/剑指 Offer II 067. 最大的异或（中等）.md", "url_title": "剑指 Offer II 067. 最大的异或", "url": "https://leetcode.cn/problems/ms70jA/solution/by-ac_oier-d9kx/", "difficulty": "中等", "tags": ["贪心", "字典树"], "question": "给定一个整数数组 `nums`,返回 `nums[i] XOR nums[j]` 的最大运算结果,其中 $0 ≤ i ≤ j < n$ 。\n\n示例 1:\n```\n输入:nums = [3,10,5,25,2,8]\n\n输出:28\n\n解释:最大运算结果是 5 XOR 25 = 28.\n```\n示例 2:\n```\n输入:nums = [0]\n\n输出:0\n```\n示例 3:\n```\n输入:nums = [2,4]\n\n输出:6\n```\n示例 4:\n```\n输入:nums = [8,10,2]\n\n输出:10\n```\n示例 5:\n```\n输入:nums = [14,70,53,83,49,91,36,80,92,51,66,70]\n\n输出:127\n```\n\n提示:\n* $1 <= nums.length <= 2 \\times 10^4$\n* $0 <= nums[i] <= 2^{31} - 1$\n\n进阶:你可以在 $O(n)$ 的时间解决这个问题吗?", "solution": "### 基本分析\n\n要求得数组 `nums` 中的「最大异或结果」,假定 $nums[i]$ 与 $nums[j]$ 异或可以取得最终结果。\n\n**由于异或计算「每位相互独立」(又称为不进位加法),同时具有「相同值异或结果为 $0$,不同值异或结果为 $1$」的特性。**\n\n因此对于 $nums[j]$ 而言,可以从其二进制表示中的最高位开始往低位找,尽量让每一位的异或结果为 $1$,这样找到的 $nums[i]$ 与 $nums[j]$ 的异或结果才是最大的。\n\n具体的,我们需要先将 `nums` 中下标范围为 $[0, j]$ 的数(二进制表示)加入 $Trie$ 中,然后每次贪心的匹配每一位(优先匹配与之不同的二进制位)。\n\n---\n\n### 证明\n\n由于我们会从前往后扫描 `nums` 数组,因此 $nums[j]$ 必然会被处理到,所以我们只需要证明,在选定 $nums[j]$ 的情况下,我们的算法能够在 $[0, j]$ 范围内找到 $nums[i]$ 即可。\n\n假定我们算法找出来的数值与 $nums[j]$ 的异或结果为 $x$,而真实的最优异或结果为 $y$。\n\n接下来需要证得 $x$ 和 $y$ 相等。\n\n由于找的是「最大异或结果」, 而 $x$ 是一个合法值,因此我们天然有 $x \\leq y$。\n\n然后利用反证法证明 $x \\geq y$,假设 $x \\geq y$ 不成立,即有 $x < y$,那么从两者的二进制表示的高位开始找,必然能找到第一位不同:$y$ 的「不同位」的值为 $1$,而 $x$ 的「不同位」的值为 $0$。\n\n那么对应到选择这一个「不同位」的逻辑:能够选择与 $nums[j]$ 该位不同的值,使得该位的异或结果为 $1$,但是我们的算法选择了与 $nums[j]$ 该位相同的值,使得该位的异或结果为 $0$。\n\n这与我们的算法逻辑冲突,因此必然不存在这样的「不同位」。即 $x < y$ 不成立,反证 $x \\geq y$ 成立。\n\n得证 $x$ 与 $y$ 相等。\n\n---\n\n### Trie 数组实现\n\n可以使用数组来实现 $Trie$,但由于 OJ 每跑一个样例都会创建一个新的对象,因此使用数组实现,相当于每跑一个数据都需要 `new` 一个百万级别的数组,会 TLE 。\n\n因此这里使用数组实现必须要做的一个优化是:**使用 `static` 来修饰 $Trie$ 数组,然后在初始化时做相应的清理工作。**\n\n担心有不熟 Java 的同学,在代码里添加了相应注释说明。\n\n代码:\n```Java\nclass Solution {\n    // static 成员整个类独一份,只有在类首次加载时才会创建,因此只会被 new 一次\n    static int N = (int)1e6;\n    static int[][] trie = new int[N][2];\n    static int idx = 0;\n    // 每跑一个数据,会被实例化一次,每次实例化的时候被调用,做清理工作\n    public Solution() {\n        for (int i = 0; i <= idx; i++) {\n            Arrays.fill(trie[i], 0);\n        }\n        idx = 0;\n    }\n    void add(int x) {\n        int p = 0;\n        for (int i = 31; i >= 0; i--) {\n            int u = (x >> i) & 1;\n            if (trie[p][u] == 0) trie[p][u] = ++idx;\n            p = trie[p][u];\n        }\n    }\n    int getVal(int x) {\n        int ans = 0;\n        int p = 0;\n        for (int i = 31; i >= 0; i--) {\n            int a = (x >> i) & 1, b = 1 - a;\n            if (trie[p][b] != 0) {\n                ans |= (b << i);\n                p = trie[p][b];\n            } else {\n                ans |= (a << i);\n                p = trie[p][a];\n            }\n        }\n        return ans;\n    }\n    public int findMaximumXOR(int[] nums) {\n        int ans = 0;\n        for (int i : nums) {\n            add(i);\n            int j = getVal(i);\n            ans = Math.max(ans, i ^ j);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1e6)$\n\n---\n\n### Trie 类实现\n\n相比于使用 `static` 来优化,一个更好的做法是使用类来实现 $Trie$,这样可以真正做到「按需分配」内存,缺点是会发生不确定次数的 `new`。\n\n代码:\n```Java\nclass Solution {\n    class Node {\n        Node[] ns = new Node[2];\n    }\n    Node root = new Node();\n    void add(int x) {\n        Node p = root;\n        for (int i = 31; i >= 0; i--) {\n            int u = (x >> i) & 1;\n            if (p.ns[u] == null) p.ns[u] = new Node();\n            p = p.ns[u];\n        }\n    }\n    int getVal(int x) {\n        int ans = 0;\n        Node p = root;\n        for (int i = 31; i >= 0; i--) {\n            int a = (x >> i) & 1, b = 1 - a;\n            if (p.ns[b] != null) {\n                ans |= (b << i);\n                p = p.ns[b];\n            } else {\n                ans |= (a << i);\n                p = p.ns[a];\n            }\n        }\n        return ans;\n    }\n    public int findMaximumXOR(int[] nums) {\n        int ans = 0;\n        for (int i : nums) {\n            add(i);\n            int j = getVal(i);\n            ans = Math.max(ans, i ^ j);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer II 067` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer II/剑指 Offer II 069. 山峰数组的顶部（简单）.md", "url_title": "剑指 Offer II 069. 山峰数组的顶部", "url": "https://leetcode-cn.com/problems/B1IidL/solution/gong-shui-san-xie-er-fen-san-fen-ji-zhi-lc8zl/", "difficulty": "简单", "tags": ["二分", "三分"], "question": "符合下列属性的数组 `arr` 称为 山峰数组(山脉数组) :\n* `arr.length >= 3`\n* 存在 `i`(`0 < i < arr.length - 1`)使得:\n\t* `arr[0] < arr[1] < ... arr[i-1] < arr[i]`\n\t* `arr[i] > arr[i+1] > ... > arr[arr.length - 1]`\n\n给定由整数组成的山峰数组 arr ,返回任何满足 `arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1]` 的下标 `i` ,即山峰顶部。\n\n示例 1:\n```\n输入:arr = [0,1,0]\n\n输出:1\n```\n示例 2:\n```\n输入:arr = [1,3,5,4,2]\n\n输出:2\n```\n示例 3:\n```\n输入:arr = [0,10,5,2]\n\n输出:1\n```\n示例 4:\n```\n输入:arr = [3,4,5,1]\n\n输出:2\n```\n示例 5:\n```\n输入:arr = [24,69,100,99,79,78,67,36,26,19]\n\n输出:2\n```\n\n提示:\n* 3 <= arr.length <= $10^4$\n* 0 <= arr[i] <= $10^6$\n* 题目数据保证 arr 是一个山脉数组\n\n**进阶:很容易想到时间复杂度 O(n) 的解决方案,你可以设计一个 O(log(n)) 的解决方案吗?**", "solution": "### 二分\n\n往常我们使用「二分」进行查值,需要确保序列本身满足「二段性」:当选定一个端点(基准值)后,结合「一段满足 & 另一段不满足」的特性来实现“折半”的查找效果。\n\n但本题求的是峰顶索引值,如果我们选定数组头部或者尾部元素,其实无法根据大小关系“直接”将数组分成两段。\n\n但可以利用题目发现如下性质:**由于 `arr` 数值各不相同,因此峰顶元素左侧必然满足严格单调递增,峰顶元素右侧必然不满足。**\n\n因此 **以峰顶元素为分割点的 `arr` 数组,根据与 前一元素/后一元素 的大小关系,具有二段性:**\n\n* 峰顶元素左侧满足 $arr[i-1] < arr[i]$ 性质,右侧不满足\n* 峰顶元素右侧满足 $arr[i] > arr[i+1]$ 性质,左侧不满足\n\n因此我们可以选择任意条件,写出若干「二分」版本。\n\n代码:\n```Java\nclass Solution {\n    // 根据 arr[i-1] < arr[i] 在 [1,n-1] 范围内找值\n    // 峰顶元素为符合条件的最靠近中心的元素\n    public int peakIndexInMountainArray(int[] arr) {\n        int n = arr.length;\n        int l = 1, r = n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (arr[mid - 1] < arr[mid]) l = mid;\n            else r = mid - 1;\n        }\n        return r;\n    }\n}\n```\n```Java\nclass Solution {\n    // 根据 arr[i] > arr[i+1] 在 [0,n-2] 范围内找值\n    // 峰顶元素为符合条件的最靠近中心的元素值\n    public int peakIndexInMountainArray(int[] arr) {\n        int n = arr.length;\n        int l = 0, r = n - 2;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (arr[mid] > arr[mid + 1]) r = mid;\n            else l = mid + 1;\n        }\n        return r;\n    }\n}\n```\n```Java\nclass Solution {\n    // 根据 arr[i-1] > arr[i] 在 [1,n-1] 范围内找值\n    // 峰顶元素为符合条件的最靠近中心的元素的前一个值\n    public int peakIndexInMountainArray(int[] arr) {\n        int n = arr.length;\n        int l = 1, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (arr[mid - 1] > arr[mid]) r = mid;\n            else l = mid + 1;\n        }\n        return r - 1;\n    }\n}\n```\n```Java\nclass Solution {\n    // 根据 arr[i] < arr[i+1] 在 [0,n-2] 范围内找值\n    // 峰顶元素为符合条件的最靠近中心的元素的下一个值\n    public int peakIndexInMountainArray(int[] arr) {\n        int n = arr.length;\n        int l = 0, r = n - 2;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (arr[mid] < arr[mid + 1]) l = mid;\n            else r = mid - 1;\n        }\n        return r + 1;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 三分\n\n事实上,我们还可以利用「三分」来解决这个问题。\n\n顾名思义,**「三分」就是使用两个端点将区间分成三份,然后通过每次否决三分之一的区间来逼近目标值。**\n\n具体的,由于峰顶元素为全局最大值,因此我们可以每次将当前区间分为 $[l, m1]$、$[m1, m2]$ 和 $[m2, r]$ 三段,如果满足 $arr[m1] > arr[m2]$,说明峰顶元素不可能存在与 $[m2, r]$ 中,让 $r = m2 - 1$ 即可。另外一个区间分析同理。\n\n代码:\n```Java\nclass Solution {\n    public int peakIndexInMountainArray(int[] arr) {\n        int n = arr.length;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int m1 = l + (r - l) / 3;\n            int m2 = r - (r - l) / 3;\n            if (arr[m1] > arr[m2]) r = m2 - 1;\n            else l = m1 + 1;\n        }\n        return r;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 二分 & 三分 & k 分 ?\n\n必须说明一点,「二分」和「三分」在渐进复杂度上都是一样的,都可以通过换底公式转化为可忽略的常数,因此两者的复杂度都是 $O(\\log{n})$。\n\n因此选择「二分」还是「三分」取决于要解决的是什么问题:\n\n* 二分通常用来解决单调函数的找 $target$ 问题,但进一步深入我们发现只需要满足「二段性」就能使用「二分」来找分割点;\n* 三分则是解决单峰函数极值问题。\n\n**因此一般我们将「通过比较两个端点,每次否决 1/3 区间 来解决单峰最值问题」的做法称为「三分」;而不是简单根据单次循环内将区间分为多少份来判定是否为「三分」。**\n\n随手写了一段反例代码:\n```Java\nclass Solution {\n    public int peakIndexInMountainArray(int[] arr) {\n        int left = 0, right = arr.length - 1;\n        while(left < right) {\n            int m1 = left + (right - left) / 3;\n            int m2 = right - (right - left + 2) / 3;\n            if (arr[m1] > arr[m1 + 1]) {\n                right = m1;\n            } else if (arr[m2] < arr[m2 + 1]) {\n                left = m2 + 1;\n            } else {\n                left = m1;\n                right = m2;\n            }\n        }\n        return left;\n    }\n}\n```\n\n这并不是「三分」做法,最多称为「变形二分」。本质还是利用「二段性」来做分割的,只不过同时 check 了两个端点而已。\n\n如果这算「三分」的话,那么我能在一次循环里面划分 $k - 1$ 个端点来实现 $k$ 分?\n\n**显然这是没有意义的,因为按照这种思路写出来的所谓的「四分」、「五分」、「k 分」是需要增加同等数量的分支判断的。这时候单次 `while` 决策就不能算作 $O(1)$ 了,而是需要在 $O(k)$ 的复杂度内决定在哪个分支,就跟上述代码有三个分支进行判断一样。** 因此,这种写法只能算作是「变形二分」。\n\n**综上,只有「二分」和「三分」的概念,不存在所谓的 $k$ 分。** 同时题解中的「三分」部分提供的做法就是标准的「三分」做法。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer II 069` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer II/剑指 Offer II 091. 粉刷房子（中等）.md", "url_title": "剑指 Offer II 091. 粉刷房子", "url": "https://leetcode.cn/problems/JEj789/solution/by-ac_oier-6v2v/", "difficulty": "中等", "tags": ["状态机 DP", "动态规划"], "question": "假如有一排房子,共 `n` 个,每个房子可以被粉刷成红色、蓝色或者绿色这三种颜色中的一种,你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。\n\n当然,因为市场上不同颜色油漆的价格不同,所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个 `n x 3` 的正整数矩阵 `costs` 来表示的。\n\n例如,`costs[0][0]` 表示第 $0$ 号房子粉刷成红色的成本花费;`costs[1][2]` 表示第 $1$ 号房子粉刷成绿色的花费,以此类推。\n\n请计算出粉刷完所有房子最少的花费成本。\n\n示例 1:\n```\n输入: costs = [[17,2,17],[16,16,5],[14,3,19]]\n\n输出: 10\n\n解释: 将 0 号房子粉刷成蓝色,1 号房子粉刷成绿色,2 号房子粉刷成蓝色。\n最少花费: 2 + 5 + 3 = 10。\n```\n示例 2:\n```\n输入: costs = [[7,6,2]]\n\n输出: 2\n```\n\n提示:\n* $costs.length == n$\n* $costs[i].length == 3$\n* $1 <= n <= 100$\n* $1 <= costs[i][j] <= 20$", "solution": "### 状态机 DP\n\n为了方便,我们记 `costs` 为 `cs`。\n\n根据题意,当我们从前往后决策每间房子的颜色时,当前房子所能刷的颜色,取决于上一间房子的颜色。\n\n我们可以定义 $f[i][j]$ 为考虑下标不超过 $i$ 的房子,且最后一间房子颜色为 $j$ 时的最小成本。\n\n起始我们有 $f[0][i] = cs[0][i]$,代表只有第一间房子时,对应成本为第一间房子的上色成本。\n\n然后不失一般性考虑,$f[i][j]$ 该如何计算:$f[i][j]$ 为所有 $f[i - 1][prev]$(其中 $prev \\neq j$)中的最小值加上 $cs[i][j]$。\n\n本质上这是一道「状态机 DP」问题:某些状态只能由规则限定的状态所转移,通常我们可以从 $f[i][j]$ 能够更新哪些目标状态(后继状态)进行转移,也能够从 $f[i][j]$ 依赖哪些前置状态(前驱状态)来转移。\n\n一些细节:考虑到我们 $f[i][X]$ 的计算只依赖于 $f[i - 1][X]$,因此我们可以使用三个变量来代替我们的动规数组。\n\nJava 代码:\n```Java\nclass Solution {\n    public int minCost(int[][] cs) {\n        int n = cs.length;\n        int a = cs[0][0], b = cs[0][1], c = cs[0][2];\n        for (int i = 1; i < n; i++) {\n            int d = Math.min(b, c) + cs[i][0];\n            int e = Math.min(a, c) + cs[i][1];\n            int f = Math.min(a, b) + cs[i][2];\n            a = d; b = e; c = f;\n        }\n        return Math.min(a, Math.min(b, c));\n    }\n}\n```\n\nJava 代码:\n\n```Java\nclass Solution {\n    public int minCost(int[][] cs) {\n        int n = cs.length;\n        int a = cs[0][0], b = cs[0][1], c = cs[0][2];\n        for (int i = 0; i < n - 1; i++) {\n            int d = Math.min(b, c) + cs[i + 1][0];\n            int e = Math.min(a, c) + cs[i + 1][1];\n            int f = Math.min(a, b) + cs[i + 1][2];\n            a = d; b = e; c = f;\n        }\n        return Math.min(a, Math.min(b, c));\n    }\n}\n```\n* 时间复杂度:$O(n \\times C)$,其中 $C = 3$ 为颜色数量\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 091` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer II/剑指 Offer II 114. 外星文字典（困难）.md", "url_title": "剑指 Offer II 114. 外星文字典", "url": "https://leetcode.cn/problems/Jf1JuT/solution/by-ac_oier-4xmv/", "difficulty": "困难", "tags": ["图论", "拓扑排序", "建图", "图论 BFS"], "question": "现有一种使用英语字母的外星文语言,这门语言的字母顺序与英语顺序不同。\n\n给定一个字符串列表 `words` ,作为这门语言的词典,`words` 中的字符串已经 按这门新语言的字母顺序进行了排序 。\n\n请你根据该词典还原出此语言中已知的字母顺序,并 按字母递增顺序 排列。若不存在合法字母顺序,返回 `\"\"` 。若存在多种可能的合法字母顺序,返回其中 任意一种 顺序即可。\n\n字符串 `s` 字典顺序小于 字符串 `t` 有两种情况:\n\n在第一个不同字母处,如果 `s` 中的字母在这门外星语言的字母顺序中位于 `t` 中字母之前,那么 `s` 的字典顺序小于 `t` 。\n如果前面 `min(s.length, t.length)` 字母都相同,那么 `s.length < t.length` 时,`s` 的字典顺序也小于 `t` 。\n\n示例 1:\n```\n输入:words = [\"wrt\",\"wrf\",\"er\",\"ett\",\"rftt\"]\n\n输出:\"wertf\"\n```\n示例 2:\n```\n输入:words = [\"z\",\"x\"]\n\n输出:\"zx\"\n```\n示例 3:\n```\n输入:words = [\"z\",\"x\",\"z\"]\n\n输出:\"\"\n\n解释:不存在合法字母顺序,因此返回 \"\" 。\n```\n\n提示:\n* $1 <= words.length <= 100$\n* $1 <= words[i].length <= 100$\n* `words[i]` 仅由小写英文字母组成", "solution": "### 建图 + 拓扑排序\n\n为了方便,我们称 `words` 为 `ws`,同时将两个字符串 `a` 和 `b` 之间的字典序关系简称为「关系」。\n\n由于数组长度和每个 $ws[i]$ 的最大长度均为 $100$,我们可以实现复杂度为 $O(n^3)$ 的算法。\n\n首先容易想到,我们从前往后处理每个 $ws[i]$,利用 `ws` 数组本身已按字典序排序,然后通过 $ws[i]$ 与 $ws[j]$ 的关系(其中 $j$ 的范围为 $[0, i - 1]$),来构建字符之间的关系。\n\n具体的,当我们明确字符 $c1$ 比 $c2$ 字典序要小,可以建立从 $c1$ 到 $c2$ 的有向边,同时统计增加 $c1$ 的出度,增加 $c2$ 的入度。\n\n当建图完成后,我们从所有入度为 $0$ 的点开始(含义为没有比这些字符字典序更小的字符),跑一遍拓扑排序:在 `BFS` 过程中,不断的删点(出队的点可以看做从图中移除)和更新删除点的出边点的入度,若有新的入度为 $0$ 的点,则将其进行入队操作。\n\n> **不了解拓扑排序的同学可以看前置 🧀 : [图论拓扑排序入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489706&idx=1&sn=771cd807f39d1ca545640c0ef7e5baec)**\n\n若最终出队节点数量与总数量 $cnt$ 相等,说明这是一张拓扑图(无环,字符之间不存在字典序冲突),出队的顺序即是字典序,否则存在冲突,返回空串。\n\n代码:\n```Java\nclass Solution {\n    int N = 26, M = N * N, idx = 0, cnt = 0;\n    int[] he = new int[N], e = new int[M], ne = new int[M];\n    int[] in = new int[N], out = new int[N];\n    boolean[] vis = new boolean[N];\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n        out[a]++; in[b]++;\n    }\n    public String alienOrder(String[] ws) {\n        int n = ws.length;\n        Arrays.fill(he, -1);\n        for (int i = 0; i < n; i++) {\n            for (char c : ws[i].toCharArray()) {\n                if (!vis[c - 'a'] && ++cnt >= 0) vis[c - 'a'] = true;\n            }\n            for (int j = 0; j < i; j++) {\n                if (!build(ws[j], ws[i])) return \"\";\n            }\n        }\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < 26; i++) {\n            if (vis[i] && in[i] == 0) d.addLast(i);\n        }\n        StringBuilder sb = new StringBuilder();\n        while (!d.isEmpty()) {\n            int u = d.pollFirst();\n            sb.append((char)(u + 'a'));\n            for (int i = he[u]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (--in[j] == 0) d.addLast(j);\n            }\n        }\n        return sb.length() == cnt ? sb.toString() : \"\";\n    }\n    boolean build(String a, String b) {\n        int n = a.length(), m = b.length(), len = Math.min(n, m);\n        for (int i = 0; i < len; i++) {\n            int c1 = a.charAt(i) - 'a', c2 = b.charAt(i) - 'a';\n            if (c1 != c2) {\n                add(c1, c2);\n                return true;\n            }\n        }\n        return n <= m;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为数组 `ws` 的长度,统计字符数的复杂度为 $O(\\sum_{i}^{n - 1} len(ws[i]))$,建图复杂度为 $O(n^3)$;跑拓扑序构建答案复杂度 $O(n^2)$。整体复杂度为 $O(n^3)$\n* 空间复杂度:$O(C^2)$,其中 $C = 26$ 为字符集大小", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 114` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer II/剑指 Offer II 115. 重建序列（中等）.md", "url_title": "剑指 Offer II 115. 重建序列", "url": "https://leetcode.cn/problems/ur2n8P/solution/by-ac_oier-oqxs/", "difficulty": "中等", "tags": ["图论", "拓扑排序", "建图", "图论 BFS"], "question": "给定一个长度为 `n` 的整数数组 `nums` ,其中 `nums` 是范围为 $[1,n]$ 的整数的排列。还提供了一个 `2D` 整数数组 `sequences`,其中 `sequences[i]` 是 `nums` 的子序列。\n\n检查 `nums` 是否是唯一的最短 超序列 。最短 超序列 是 长度最短 的序列,并且所有序列 `sequences[i]` 都是它的子序列。对于给定的数组 `sequences`,可能存在多个有效的 超序列 。\n\n* 例如,对于 `sequences = [[1,2],[1,3]]` ,有两个最短的 超序列,`[1,2,3]` 和 `[1,3,2]` 。\n* 而对于 `sequences = [[1,2],[1,3],[1,2,3]]`,唯一可能的最短 超序列 是 `[1,2,3]` 。`[1,2,3,4]` 是可能的超序列,但不是最短的。\n\n如果 `nums` 是序列的唯一最短 超序列 ,则返回 `true` ,否则返回 `false` 。\n\n子序列 是一个可以通过从另一个序列中删除一些元素或不删除任何元素,而不改变其余元素的顺序的序列。\n\n示例 1:\n```\n输入:nums = [1,2,3], sequences = [[1,2],[1,3]]\n\n输出:false\n\n解释:有两种可能的超序列:[1,2,3]和[1,3,2]。\n序列 [1,2] 是[1,2,3]和[1,3,2]的子序列。\n序列 [1,3] 是[1,2,3]和[1,3,2]的子序列。\n因为 nums 不是唯一最短的超序列,所以返回false。\n```\n示例 2:\n```\n输入:nums = [1,2,3], sequences = [[1,2]]\n\n输出:false\n\n解释:最短可能的超序列为 [1,2]。\n序列 [1,2] 是它的子序列:[1,2]。\n因为 nums 不是最短的超序列,所以返回false。\n```\n示例 3:\n```\n输入:nums = [1,2,3], sequences = [[1,2],[1,3],[2,3]]\n\n输出:true\n\n解释:最短可能的超序列为[1,2,3]。\n序列 [1,2] 是它的一个子序列:[1,2,3]。\n序列 [1,3] 是它的一个子序列:[1,2,3]。\n序列 [2,3] 是它的一个子序列:[1,2,3]。\n因为 nums 是唯一最短的超序列,所以返回true。\n```\n\n提示:\n* $n == nums.length$\n* $1 <= n <= 104$\n* `nums` 是 $[1, n]$ 范围内所有整数的排列\n* $1 <= sequences.length <= 10^4$\n* $1 <= sequences[i].length <= 104$\n* $1 <= sum(sequences[i].length) <= 10^5$\n* $1 <= sequences[i][j] <= n$\n* `sequences` 的所有数组都是 唯一 的\n* `sequences[i]` 是 `nums` 的一个子序列", "solution": "### 拓扑排序 + 构造\n\n为了方便,我们令 `sequences` 为 `ss`。\n\n根据题意,如果我们能够利用所有的 $ss[i]$ 构造出一个唯一的序列,且该序列与 `nums` 相同,则返回 `True`,否则返回 `False`。\n\n将每个 $ss[i]$ 看做对 $ss[i]$ 所包含点的前后关系约束,我们可以将问题转换为拓扑排序问题。\n\n利用所有 $ss[i]$ 构造新图:对于 $ss[i] = [A_1, A_2, ..., A_k]$,我们将其转换为点 $A_1$ -> $A_2$ -> ... -> $A_k$ 的有向图,同时统计每个点的入度情况。\n\n然后在新图上跑一遍拓扑排序,构造对应的拓扑序列,与 `nums` 进行对比。\n\n实现上,由于拓扑排序过程中,出点的顺序即为拓扑序,因此我们并不需要完整保存整个拓扑序,只需使用一个变量 `loc` 来记录当前拓扑序的下标,将出点 $t$ 与 $nums[loc]$ 做比较即可。\n\n在拓扑序过程中若有 $t$ 不等于 $nums[loc]$(构造出来的方案与 `nums` 不同) 或某次拓展过程中发现队列元素不止 $1$ 个(此时可能的原因有 :「起始入度为 $0$ 的点不止一个或存在某些点根本不在 $ss$ 中」或「单次拓展新产生的入度为 $0$ 的点不止一个,即拓扑序不唯一」),则直接返回 `False`,\n\nJava 代码:\n```Java \nclass Solution {\n    int N = 10010, M = N, idx;\n    int[] he = new int[N], e = new int[M], ne = new int[M], in = new int[N];\n    void add(int a, int b) {\n        e[idx] = b;\n        ne[idx] = he[a];\n        he[a] = idx++;\n        in[b]++;\n    }\n    public boolean sequenceReconstruction(int[] nums, int[][] ss) {\n        int n = nums.length;\n        Arrays.fill(he, -1);\n        for (int[] s : ss) {\n            for (int i = 1; i < s.length; i++) add(s[i - 1], s[i]);\n        }\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 1; i <= n; i++) {\n            if (in[i] == 0) d.addLast(i);\n        }\n        int loc = 0;\n        while (!d.isEmpty()) {\n            if (d.size() != 1) return false;\n            int t = d.pollFirst();\n            if (nums[loc++] != t) return false;\n            for (int i = he[t]; i != -1; i = ne[i]) {\n                int j = e[i];\n                if (--in[j] == 0) d.addLast(j);\n            }\n        }\n        return true;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nconst N = 10010, M = N\nconst he: number[] = new Array<number>(N).fill(-1), e = new Array<number>(N).fill(0), ne = new Array<number>(N).fill(0), ind = new Array<number>(N).fill(0);\nlet idx = 0\nfunction add(a: number, b: number): void {\n    e[idx] = b\n    ne[idx] = he[a]\n    he[a] = idx++\n    ind[b]++\n}\nfunction sequenceReconstruction(nums: number[], ss: number[][]): boolean {\n    he.fill(-1); ind.fill(0)\n    idx = 0\n    const n = nums.length\n    for (const s of ss) {\n        for (let i = 1; i < s.length; i++) add(s[i - 1], s[i])\n    }\n    const stk: number[] = new Array<number>()\n    let head = 0, tail = 0\n    for (let i = 1; i <= n; i++) {\n        if (ind[i] == 0) stk[tail++] = i\n    }\n    let loc = 0\n    while (head < tail) {\n        if (tail - head > 1) return false\n        const t = stk[head++]\n        if (nums[loc++] != t) return false\n        for (let i = he[t]; i != -1; i = ne[i]) {\n            const j = e[i]\n            if (--ind[j] == 0) stk[tail++] = j\n        }\n    }\n    return true\n};\n```\n* 时间复杂度:建图复杂度为 $O(\\sum_{i = 0}^{n - 1}ss[i].length)$;跑拓扑排序的复杂度为 $O(n + \\sum_{i = 0}^{n - 1}ss[i].length)$。整体复杂度为 $O(n + \\sum_{i = 0}^{n - 1}ss[i].length)$\n* 空间复杂度: $O(n + \\sum_{i = 0}^{n - 1}ss[i].length)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 115` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 04. 二维数组中的查找（中等）.md", "url_title": "剑指 Offer 04. 二维数组中的查找", "url": "https://leetcode.cn/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof/solution/by-ac_oier-7jo0/", "difficulty": "中等", "tags": ["二叉树搜索树", "BST", "二分"], "question": "在一个 $n \\times m$ 的二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个高效的函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。\n\n示例:\n```\n现有矩阵 matrix 如下:\n\n[\n  [1,   4,  7, 11, 15],\n  [2,   5,  8, 12, 19],\n  [3,   6,  9, 16, 22],\n  [10, 13, 14, 17, 24],\n  [18, 21, 23, 26, 30]\n]\n\n给定 target = 5,返回 true。\n给定 target = 20,返回 false。\n```\n\n限制:\n* $0 <= n <= 1000$\n* $0 <= m <= 1000$", "solution": "### 二分\n\n与 [(题解)74. 搜索二维矩阵](https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/) 不同,本题没有确保「每行的第一个整数大于前一行的最后一个整数」,因此我们无法采取「两次二分」的做法。\n\n只能退而求之,遍历行/列,然后再对列/行进行二分。\n\n代码:\n```Java\nclass Solution {\n    public boolean searchMatrix(int[][] matrix, int target) {\n        if (matrix.length == 0 || matrix[0].length == 0) return false;\n        int m = matrix.length, n = matrix[0].length;\n        for (int i = 0; i < m; i++) {\n            int l = 0, r = n - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (matrix[i][mid] <= target) l = mid;\n                else r = mid - 1;\n            }\n            if (matrix[i][r] == target) return true;\n        }\n        return false;\n    }\n}\n```\n-\n```Java\nclass Solution {\n    public boolean searchMatrix(int[][] matrix, int target) {\n        if (matrix.length == 0 || matrix[0].length == 0) return false;\n        int m = matrix.length, n = matrix[0].length;\n        for (int i = 0; i < n; i++) {\n            int l = 0, r = m - 1;\n            while (l < r) {\n                int mid = l + r + 1 >> 1;\n                if (matrix[mid][i] <= target) l = mid;\n                else r = mid - 1;\n            }\n            if (matrix[r][i] == target) return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(m\\log{n})$ 或 $O(n\\log{m})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 抽象 BST\n\n该做法则与 [(题解)74. 搜索二维矩阵](https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/) 的「解法二」完全一致。\n\n我们可以将二维矩阵抽象成「以右上角为根的 BST」:\n\n那么我们可以从根(右上角)开始搜索,如果当前的节点不等于目标值,可以按照树的搜索顺序进行:\n\n1. 当前节点「大于」目标值,搜索当前节点的「左子树」,也就是当前矩阵位置的「左方格子」,即 $c$--\n2. 当前节点「小于」目标值,搜索当前节点的「右子树」,也就是当前矩阵位置的「下方格子」,即 $r$++\n\n代码:\n```Java\nclass Solution {\n    public boolean searchMatrix(int[][] matrix, int target) {\n        if (matrix.length == 0 || matrix[0].length == 0) return false;\n        int m = matrix.length, n = matrix[0].length;\n        int r = 0, c = n - 1;\n        while (r < m && c >= 0) {\n            if (matrix[r][c] < target) r++;\n            else if (matrix[r][c] > target) c--;\n            else return true;\n        }\n        return false;\n    }\n}\n```\n* 时间复杂度:$O(m + n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 04` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 06. 从尾到头打印链表（简单）.md", "url_title": "剑指 Offer 06. 从尾到头打印链表", "url": "https://leetcode.cn/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/solution/by-ac_oier-3qsk/", "difficulty": "简单", "tags": ["链表", "迭代", "递归", "双指针"], "question": "输入一个链表的头节点,从尾到头反过来返回每个节点的值(用数组返回)。\n\n示例 1:\n```\n输入:head = [1,3,2]\n\n输出:[2,3,1]\n```\n\n限制:\n* $0 <= 链表长度 <= 10000$", "solution": "### 迭代\n\n使用「迭代」方式求解是极其容易的。\n\n在遍历链表 `head` 时,使用变长数组将节点值进行转存,随后再利用变长数组来「从后往前」构造定长数组并进行返回即可(其中 `TS`  代码无须额外构造定长数组,直接在原有数组基础上使用「双指针」翻转即可)。\n\nJava 代码:\n```Java \nclass Solution {\n    public int[] reversePrint(ListNode head) {\n        List<Integer> list = new ArrayList<>();\n        while (head != null) {\n            list.add(head.val);\n            head = head.next;\n        }\n        int n = list.size();\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) ans[i] = list.get(n - 1 - i);\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction reversePrint(head: ListNode | null): number[] {\n    const ans = new Array<number>()\n    while (head != null) {\n        ans.push(head.val)\n        head = head.next\n    }\n    const n = ans.length\n    for (let i = 0, j = n - 1; i < j; i++, j--) {\n        const c = ans[i]\n        ans[i] = ans[j]\n        ans[j] = c\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 递归\n\n使用「递归」求解只需要进行常规的 `DFS`  即可,每次先将当前节点的 `next` 指针进行递归处理,然后再将当前节点值加入数组,即可实现「从后往前」的顺序添加。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] reversePrint(ListNode head) {\n        List<Integer> list = new ArrayList<>();\n        dfs(head, list);\n        int n = list.size();\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) ans[i] = list.get(i);\n        return ans;\n    }\n    void dfs(ListNode head, List<Integer> list) {\n        if (head == null) return ;\n        dfs(head.next, list);\n        list.add(head.val);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction reversePrint(head: ListNode | null): number[] {\n    const ans: number[] = new Array<number>()\n    dfs(head, ans)\n    return ans\n};\nfunction dfs(head: ListNode | null, list: number[]) {\n    if (head == null) return \n    dfs(head.next, list)\n    list.push(head.val)\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 06` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 10- I. 斐波那契数列（简单）.md", "url_title": "剑指 Offer 10- I. 斐波那契数列", "url": "https://leetcode-cn.com/problems/fei-bo-na-qi-shu-lie-lcof/solution/gong-shui-san-xie-yi-ti-si-jie-dong-tai-9zip0/", "difficulty": "简单", "tags": ["动态规划", "线性 DP", "记忆化搜索", "打表", "矩阵快速幂"], "question": "写一个函数,输入 n ,求斐波那契(Fibonacci)数列的第 n 项(即 F(N))。斐波那契数列的定义如下:\n\n* F(0) = 0,   F(1) = 1\n* F(N) = F(N - 1) + F(N - 2), 其中 N > 1.\n\n斐波那契数列由 0 和 1 开始,之后的斐波那契数就是由之前的两数相加而得出。\n\n答案需要取模 1e9+7(1000000007),如计算初始结果为:1000000008,请返回 1。\n\n示例 1:\n```\n输入:n = 2\n\n输出:1\n```\n示例 2:\n```\n输入:n = 5\n\n输出:5\n```\n\n提示:\n* 0 <= n <= 100", "solution": "### 递推实现动态规划\n\n既然转移方程都给出了,直接根据转移方程从头到尾递递推一遍即可。\n\n代码:\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    public int fib(int n) {\n        if (n <= 1) return n;\n        int a = 0, b = 1;\n        for (int i = 2; i <= n; i++) {\n            int c = a + b;\n            c %= mod;\n            a = b;\n            b = c;\n        }\n        return b;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 递归实现动态规划\n\n能以「递推」形式实现动态规划,自然也能以「递归」的形式实现。\n\n为防止重复计算,我们需要加入「记忆化搜索」功能,同时利用某个值 $x$ 在不同的样例之间可能会作为“中间结果”被重复计算,并且计算结果 $fib(x)$ 固定,我们可以使用 `static` 修饰缓存器,以实现计算过的结果在所有测试样例中共享。\n\n代码:\n```Java\nclass Solution {\n    static int mod = (int)1e9+7;\n    static int N = 110;\n    static int[] cache = new int[N];\n    public int fib(int n) {\n        if (n <= 1) return n;\n        if (cache[n] != 0) return cache[n];\n        cache[n] = fib(n - 1) + fib(n - 2);\n        cache[n] %= mod;\n        return cache[n];\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 打表\n\n经过「解法二」,我们进一步发现,可以利用数据范围只有 $100$ 进行打表预处理,然后直接返回。\n\n代码:\n```Java\nclass Solution {\n    static int mod = (int)1e9+7;\n    static int N = 110;\n    static int[] cache = new int[N];\n    static {\n        cache[1] = 1;\n        for (int i = 2; i < N; i++) {\n            cache[i] = cache[i - 1] + cache[i - 2];\n            cache[i] %= mod;\n        }\n    }\n    public int fib(int n) {\n        return cache[n];\n    }\n}\n```\n* 时间复杂度:将打表逻辑放到本地执行,复杂度为 $O(1)$;否则为 $O(C)$,$C$ 为常量,固定为 $110$\n* 空间复杂度:$O(C)$\n\n---\n\n### 矩阵快速幂\n\n**对于数列递推问题,可以使用矩阵快速幂进行加速,最完整的介绍在 [这里](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247488198&idx=1&sn=8272ca6b0ef6530413da4a270abb68bc&chksm=fd9cb9d9caeb30cf6c2defab0f5204adc158969d64418916e306f6bf50ae0c38518d4e4ba146&token=1067450240&lang=zh_CN#rd) 讲过。**\n\n对于本题,某个 $f(n)$ 依赖于 $f(n - 1)$ 和 $f(n - 2)$,将其依赖的状态存成列向量:\n\n$$\n\\begin{bmatrix}\nf(n - 1)\\\\ \nf(n - 2)\n\\end{bmatrix}\n$$\n\n目标值 $f(n)$ 所在矩阵为:\n\n$$\n\\begin{bmatrix}\nf(n)\\\\ \nf(n - 1)\n\\end{bmatrix}\n$$\n\n根据矩阵乘法,不难发现:\n\n$$\n\\begin{bmatrix}\nf(n)\\\\ \nf(n - 1)\n\\end{bmatrix} \n\n= \n\n\\begin{bmatrix}\n1& 1\\\\ \n1& 0\n\\end{bmatrix}\n\n*\n\n\\begin{bmatrix}\nf(n - 1)\\\\ \nf(n - 2)\n\\end{bmatrix}\n$$\n\n我们令:\n\n$$\nmat = \n\\begin{bmatrix}\n1& 1\\\\ \n1& 0\n\\end{bmatrix}\n$$\n\n起始时,我们只有 $\n\\begin{bmatrix}\nf(1)\\\\ \nf(0)\n\\end{bmatrix}\n$,根据递推式得:\n\n$$\n\\begin{bmatrix}\nf(n)\\\\ \nf(n - 1)\n\\end{bmatrix}\n\n=\n\nmat * mat * ... * mat * \n\n\\begin{bmatrix}\nf(1)\\\\ \nf(0)\n\\end{bmatrix}\n$$\n\n再根据矩阵乘法具有「结合律」,最终可得:\n\n$$\n\\begin{bmatrix}\nf(n)\\\\ \nf(n - 1)\n\\end{bmatrix}\n\n=\n\nmat^{n - 1} \n\n*\n\n\\begin{bmatrix}\nf(1)\\\\ \nf(0)\n\\end{bmatrix}\n$$\n\n计算 $mat^{n - 1}$ 可以套用「快速幂」进行求解。\n\n代码:\n```Java\nclass Solution {\n    int mod = (int)1e9+7;\n    long[][] mul(long[][] a, long[][] b) {\n        int r = a.length, c = b[0].length, z = b.length;\n        long[][] ans = new long[r][c];\n        for (int i = 0; i < r; i++) {\n            for (int j = 0; j < c; j++) {\n                for (int k = 0; k < z; k++) {\n                    ans[i][j] += a[i][k] * b[k][j];\n                    ans[i][j] %= mod;\n                }\n            }\n        }\n        return ans;\n    }\n    public int fib(int n) {\n        if (n <= 1) return n;\n        long[][] mat = new long[][]{\n            {1, 1},\n            {1, 0}\n        };\n        long[][] ans = new long[][]{\n            {1},\n            {0}\n        };\n        int x = n - 1;\n        while (x != 0) {\n            if ((x & 1) != 0) ans = mul(mat, ans);\n            mat = mul(mat, mat);\n            x >>= 1;\n        }\n        return (int)(ans[0][0] % mod);\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 10- I` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 11. 旋转数组的最小数字（简单）.md", "url_title": "剑指 Offer 11. 旋转数组的最小数字", "url": "https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof/solution/by-ac_oier-p751/", "difficulty": "简单", "tags": ["二分"], "question": "把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转。\n\n给你一个可能存在 重复 元素值的数组 `numbers`,它原来是一个升序排列的数组,并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如,数组 `[3,4,5,1,2]` 为 `[1,2,3,4,5]` 的一次旋转,该数组的最小值为 $1$。  \n\n注意,数组 `[a[0], a[1], a[2], ..., a[n-1]]` 旋转一次 的结果为数组 `[a[n-1], a[0], a[1], a[2], ..., a[n-2]]`。\n\n示例 1:\n```\n输入:numbers = [3,4,5,1,2]\n\n输出:1\n```\n示例 2:\n```\n输入:numbers = [2,2,2,0,1]\n\n输出:0\n```\n\n提示:\n* $n = numbers.length$\n* $1 <= n <= 5000$\n* $-5000 <= numbers[i] <= 5000$\n* `numbers` 原来是一个升序排序的数组,并进行了 $1$ 至 $n$ 次旋转", "solution": "### 二分\n\n根据题意,我们知道,所谓的旋转其实就是「将某个下标前面的所有数整体移到后面,使得数组从整体有序变为分段有序」。\n\n但和 [153. 寻找旋转排序数组中的最小值](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/) 不同的是,本题元素并不唯一。\n\n**这意味着我们无法直接根据与** $nums[0]$ **的大小关系,将数组划分为两段,即无法通过「二分」来找到旋转点。**\n\n**因为「二分」的本质是二段性,并非单调性。只要一段满足某个性质,另外一段不满足某个性质,就可以用「二分」。**\n\n如果你有看过我 [严格 O(logN),一起看清二分的本质](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/shua-chuan-lc-yan-ge-ologn100yi-qi-kan-q-xifo/) 这篇题解,你应该很容易就理解上句话的意思。如果没有也没关系,我们可以先解决本题,在理解后你再去做 [153. 寻找旋转排序数组中的最小值](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/),我认为这两题都是一样的,不存在先后关系。\n\n举个🌰,我们使用数据 `[0,1,2,2,2,3,4,5]` 来理解为什么不同的旋转点会导致「二段性丢失」:\n\njava 代码:\n```Java\nclass Solution {\n    public int minArray(int[] nums) {\n        int n = nums.length;\n        int l = 0, r = n - 1;\n        while (l < r && nums[0] == nums[r]) r--;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (nums[mid] >= nums[0]) l = mid;                \n            else r = mid - 1;\n        }\n        return r + 1 < n ? nums[r + 1] : nums[0];\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction minArray(nums: number[]): number {\n    const n = nums.length\n    let l = 0, r = n - 1\n    while (l < r && nums[0] == nums[r]) r--\n    while (l < r) {\n        const mid = l + r + 1 >> 1\n        if (nums[mid] >= nums[0]) l = mid\n        else r = mid - 1\n    }\n    return r + 1 < n ? nums[r + 1] : nums[0]\n};\n```\n* 时间复杂度:恢复二段性处理中,最坏的情况下(考虑整个数组都是同一个数)复杂度是 $O(n)$,而之后的找旋转点是「二分」,复杂度为 $O(\\log{n})$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 11` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 15. 二进制中1的个数（简单）.md", "url_title": "剑指 Offer 15. 二进制中1的个数", "url": "https://leetcode-cn.com/problems/er-jin-zhi-zhong-1de-ge-shu-lcof/solution/gong-shui-san-xie-yi-ti-si-jie-wei-shu-j-g9w6/", "difficulty": "简单", "tags": ["位运算", "分治"], "question": "请实现一个函数,输入一个整数(以二进制串形式),输出该数二进制表示中 1 的个数。例如,把 9 表示成二进制是 1001,有 2 位是 1。因此,如果输入 9,则该函数输出 2。\n\n示例 1:\n```\n输入:00000000000000000000000000001011\n输出:3\n解释:输入的二进制串 00000000000000000000000000001011 中,共有三位为 '1'。\n```\n示例 2:\n```\n输入:00000000000000000000000010000000\n输出:1\n解释:输入的二进制串 00000000000000000000000010000000 中,共有一位为 '1'。\n```\n示例 3:\n```\n输入:11111111111111111111111111111101\n输出:31\n解释:输入的二进制串 11111111111111111111111111111101 中,共有 31 位为 '1'。\n```\n\n提示:\n* 输入必须是长度为 32 的 二进制串 。", "solution": "### 「位数检查」解法\n\n一个朴素的做法是,对 `int` 的每一位进行检查,并统计 $1$ 的个数。\n\n代码:\n```Java\npublic class Solution {\n    public int hammingWeight(int n) {\n        int ans = 0;\n        for (int i = 0; i < 32; i++) {\n            ans += ((n >> i) & 1);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(k)$,$k$ 为 `int` 的位数,固定为 $32$ 位\n* 空间复杂度:$O(1)$\n\n***\n\n### 「右移统计」解法\n\n对于方法一,即使 $n$ 的高位均为是 $0$,我们也会对此进行循环检查。\n\n因此另外一个做法是:通过 `n & 1` 来统计当前 $n$ 的最低位是否为 $1$,同时每次直接对 $n$ 进行右移并高位补 0。\n\n当 $n = 0$ 代表,我们已经将所有的 $1$ 统计完成。\n\n这样的做法,可以确保只会循环到最高位的 $1$。\n\n代码:\n```Java\npublic class Solution {\n    public int hammingWeight(int n) {\n        int ans = 0;\n        while (n != 0) {\n            ans += (n & 1);\n            n >>>= 1;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(k)$,$k$ 为 `int` 的位数,固定为 $32$ 位,最坏情况 $n$ 的二进制表示全是 $1$\n* 空间复杂度:$O(1)$\n\n---\n\n### 「lowbit」解法\n\n对于方法二,如果最高位 $1$ 和 最低位 $1$ 之间全是 $0$,我们仍然会诸次右移,直到处理到最高位的 $1$ 为止。\n\n那么是否有办法,只对位数为 $1$ 的二进制位进行处理呢?\n\n使用 `lowbit` 即可做到,`lowbit` 会在 $O(1)$ 复杂度内返回二进制表示中最低位 $1$ 所表示的数值。\n\n例如 $(0000...111100)_2$ 传入 `lowbit` 返回 $(0000...000100)_2$;$(0000...00011)_2$ 传入 `lowbit` 返回 $(0000...00001)_2$ ...\n\n代码:\n```Java\npublic class Solution {\n    public int hammingWeight(int n) {\n        int ans = 0;\n        for (int i = n; i != 0; i -= lowbit(i)) ans++;\n        return ans;\n    }\n    int lowbit(int x) {\n        return x & -x;\n    }\n}\n```\n* 时间复杂度:$O(k)$,$k$ 为 `int` 的位数,固定为 $32$ 位,最坏情况 $n$ 的二进制表示全是 $1$\n* 空间复杂度:$O(1)$\n\n---\n\n### 「分组统计」解法\n\n以上三种解法都是 $O(k)$ 的,事实上我们可以通过分组统计的方式,做到比 $O(k)$ 更低的复杂度。\n\n代码:\n```Java\npublic class Solution {\n    public int hammingWeight(int n) {\n        n = (n & 0x55555555) + ((n >>> 1)  & 0x55555555);\n        n = (n & 0x33333333) + ((n >>> 2)  & 0x33333333);\n        n = (n & 0x0f0f0f0f) + ((n >>> 4)  & 0x0f0f0f0f);\n        n = (n & 0x00ff00ff) + ((n >>> 8)  & 0x00ff00ff);\n        n = (n & 0x0000ffff) + ((n >>> 16) & 0x0000ffff);\n        return n;\n    }\n}\n```\n* 时间复杂度:$O(\\log{k})$,$k$ 为 `int` 的位数,固定为 $32$ 位\n* 空间复杂度:$O(1)$\n\nPS. 对于该解法,如果大家学有余力的话,还是建议大家在纸上模拟一下这个过程。如果不想深入,也可以当成模板背过(写法非常固定),但通常如果不是写底层框架,你几乎不会遇到需要一个 $O(\\log{k})$ 解法的情况。\n\n而且这个做法的最大作用,不是处理 `int`,而是处理更大位数的情况,在长度只有 $32$ 位的 `int` 的情况下,该做法不一定就比循环要快(该做法会产生多个的中间结果,导致赋值发生多次,而且由于指令之间存在对 $n$ 数值依赖,可能不会被优化为并行指令),这个道理和对于排序元素少的情况下,我们会选择「选择排序」而不是「归并排序」是一样的。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 15` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 20. 表示数值的字符串（中等）.md", "url_title": "剑指 Offer 20. 表示数值的字符串", "url": "https://leetcode.cn/problems/biao-shi-shu-zhi-de-zi-fu-chuan-lcof/solution/gong-shui-san-xie-chang-gui-zi-fu-chuan-sduvz/", "difficulty": "中等", "tags": ["模拟"], "question": "请实现一个函数用来判断字符串是否表示数值(包括整数和小数)。\n\n**数值**(按顺序)可以分成以下几个部分:\n\n1. 若干空格\n2. 一个 小数 或者 整数\n3. (可选)一个 `'e'` 或 `'E'` ,后面跟着一个 整数\n4. 若干空格\n\n**小数**(按顺序)可以分成以下几个部分:\n\n1. (可选)一个符号字符(`'+'` 或 `'-'`)\n2. 下述格式之一:\n\t1. 至少一位数字,后面跟着一个点 `'.'`\n\t2. 至少一位数字,后面跟着一个点 `'.'` ,后面再跟着至少一位数字\n\t3. 一个点 `'.'` ,后面跟着至少一位数字\n\n**整数**(按顺序)可以分成以下几个部分:\n\n1. (可选)一个符号字符(`'+'` 或 `'-'`)\n2. 至少一位数字\n\n部分数值列举如下:\n* `[\"+100\", \"5e2\", \"-123\", \"3.1416\", \"-1E-16\", \"0123\"]`\n\n部分非数值列举如下:\n* `[\"12e\", \"1a3.14\", \"1.2.3\", \"+-5\", \"12e+5.4\"]`\n\n示例 1:\n```\n输入:s = \"0\"\n\n输出:true\n```\n示例 2:\n```\n输入:s = \"e\"\n\n输出:false\n```\n示例 3:\n```\n输入:s = \".\"\n\n输出:false\n```\n示例 4:\n```\n输入:s = \"    .1  \"\n\n输出:true\n```\n\n提示:\n* $1 <= s.length <= 20$\n* `s` 仅含英文字母(大写和小写),数字(`0-9`),加号 `'+'`,减号 `'-'` ,空格 `' '` 或者点 `'.'` 。", "solution": "### 模拟\n\n我们对题面中的「数值」、「小数」和「整数」进行重新定义。\n\n* 整数:可以有 `'+'` 或 `'-'`,但不能同时存在;且至少有一个数字\n* 小数:可以有 `'+'` 或 `'-'`,但不能同时存在;有 `.`,且 `.` 的两边至少有一个数字\n* 数值:前后可以有连续段的空格,其余位置则不能有;可以有 `E/e`,但最多只能有一个,同时 `E/e` 分割的左边可以是「整数」或「小数」,右边则只能是「整数」\n\n根据上面的重新定义,再来设计我们的基本处理流程:\n\n* 将 `s` 两端的连续段空格进行去除,得到不该含有空格的核心串,若核心串为空,则返回 `False`;\n* 将所有的小写 `e` 切换为 `E`\n* 从前往后,找到第一个 `E` 的所在位置 `idx`,根据是否有 `E` 进行分情况讨论:\n  * 若没有 `E`(即 `idx = n`),判断整个核心串是否为「整数」或「小数」\n  * 若有 `E`(即 `idx < n`),判断以 `E` 为分割的左半部分是否为「整数」或「小数」,判断以 `E` 为分割的右半部分是否「整数」\n\nJava 代码:\n\n```Java\nclass Solution {\n    public boolean isNumber(String s) {\n        int n = s.length(), l = 0, r = n - 1;\n        while (l < n && s.charAt(l) == ' ') l++;\n        while (r >= 0 && s.charAt(r) == ' ') r--;\n        if (l > r) return false;\n        s = s.substring(l, r + 1).replace('e', 'E');\n        n = s.length();\n        int idx = 0;\n        while (idx < n && s.charAt(idx) != 'E') idx++;\n        if (idx == n) {\n            return check(s, true);\n        } else {\n            return check(s.substring(0, idx), true) && check(s.substring(idx + 1), false);\n        }\n    }\n    boolean check(String s, boolean isDecimal) {\n        if (s.equals(\".\") || s.equals(\"\")) return false;\n        int n = s.length();\n        for (int i = 0, cnt = 0; i < n; i++) {\n            char c = s.charAt(i);\n            if (c == '+' || c == '-') {\n                if (i != 0 || i == n - 1) return false;\n            } else if (c == '.') {\n                if (!isDecimal) return false;\n                if (cnt != 0) return false;\n                boolean a = i - 1 >= 0 && Character.isDigit(s.charAt(i - 1));\n                boolean b = i + 1 < n && Character.isDigit(s.charAt(i + 1));\n                if (!(a || b)) return false;\n                cnt++;\n            } else if (!Character.isDigit(c)) return false;\n        }\n        return true;\n    }\n}\n```\nC++ 代码:\n```C++\nclass Solution {\npublic:\n    bool isNumber(string s) {\n        int n = s.length(), l = 0, r = n - 1;\n        while (l < n && s[l] == ' ') l++;\n        while (r >= 0 && s[r] == ' ') r--;\n        if (l > r) return false;\n        s = s.substr(l, r - l + 1);\n        for (char& c : s) {\n            if (c == 'e') c = 'E';\n        }\n        n = s.length();\n        int idx = 0;\n        while (idx < n && s[idx] != 'E') idx++;\n        if (idx == n) {\n            return check(s, true);\n        } else {\n            return check(s.substr(0, idx), true) && check(s.substr(idx + 1), false);\n        }\n    }\n    bool check(string s, bool isDecimal) {\n        if (s == \".\" || s == \"\") return false;\n        int n = s.length();\n        for (int i = 0, cnt = 0; i < n; i++) {\n            char c = s[i];\n            if (c == '+' || c == '-') {\n                if (i != 0 || i == n - 1) return false;\n            } else if (c == '.') {\n                if (!isDecimal) return false;\n                if (cnt != 0) return false;\n                bool a = i - 1 >= 0 && isdigit(s[i - 1]);\n                bool b = i + 1 < n && isdigit(s[i + 1]);\n                if (!(a || b)) return false;\n                cnt++;\n            } else if (!isdigit(c)) return false;\n        }\n        return true;\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def isNumber(self, s: str) -> bool:\n        n, l, r = len(s), 0, len(s) - 1\n        while l < n and s[l] == ' ':\n            l += 1\n        while r >= 0 and s[r] == ' ':\n            r -= 1\n        if l > r:\n            return False\n        s = s[l:r + 1].replace('e', 'E')\n        n, idx = len(s), 0\n        while idx < n and s[idx] != 'E':\n            idx += 1\n        if idx == n:\n            return self.check(s, True)\n        else:\n            return self.check(s[:idx], True) and self.check(s[idx + 1:], False)\n            \n    def check(self, s: str, is_decimal: bool) -> bool:\n        if s == \".\" or s == \"\":\n            return False\n        n, cnt = len(s), 0\n        for i in range(n):\n            c = s[i]\n            if c == '+' or c == '-':\n                if i != 0 or i == n - 1:\n                    return False\n            elif c == '.':\n                if not is_decimal:\n                    return False\n                if cnt != 0:\n                    return False\n                a = i - 1 >= 0 and s[i - 1].isdigit()\n                b = i + 1 < n and s[i + 1].isdigit()\n                if not (a or b):\n                    return False\n                cnt += 1\n            elif not c.isdigit():\n                return False\n        return True\n```\nTypeScript 代码:\n```TypeScript\nfunction isNumber(s: string): boolean {\n    let n = s.length, l = 0, r = n - 1;\n    while (l < n && s.charAt(l) === ' ') l++;\n    while (r >= 0 && s.charAt(r) === ' ') r--;\n    if (l > r) return false;\n    s = s.substring(l, r + 1).replace(/e/g, 'E');\n    n = s.length;\n    let idx = 0;\n    while (idx < n && s.charAt(idx) !== 'E') idx++;\n    if (idx === n) {\n        return check(s, true);\n    } else {\n        return check(s.substring(0, idx), true) && check(s.substring(idx + 1), false);\n    }\n}\n\nfunction check(s: string, isDecimal: boolean): boolean {\n    if (s === '.' || s === '') return false;\n    const n = s.length;\n    for (let i = 0, cnt = 0; i < n; i++) {\n        const c = s.charAt(i);\n        if (c === '+' || c === '-') {\n            if (i !== 0 || i === n - 1) return false;\n        } else if (c === '.') {\n            if (!isDecimal) return false;\n            if (cnt !== 0) return false;\n            const a = i - 1 >= 0 && /\\d/.test(s.charAt(i - 1));\n            const b = i + 1 < n && /\\d/.test(s.charAt(i + 1));\n            if (!(a || b)) return false;\n            cnt++;\n        } else if (!/\\d/.test(c)) return false;\n    }\n    return true;\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 20` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 22. 链表中倒数第k个节点（简单）.md", "url_title": "剑指 Offer 22. 链表中倒数第k个节点", "url": "https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/solution/gong-shui-san-xie-yi-ti-san-jie-zhan-dui-w3rz/", "difficulty": "简单", "tags": ["链表", "栈", "队列", "快慢指针"], "question": "输入一个链表,输出该链表中倒数第k个节点。为了符合大多数人的习惯,本题从1开始计数,即链表的尾节点是倒数第1个节点。\n\n例如,一个链表有 6 个节点,从头节点开始,它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。\n\n示例:\n```\n给定一个链表: 1->2->3->4->5, 和 k = 2.\n\n返回链表 4->5.\n```", "solution": "### 栈/队列 解法\n\n一个使用额外空间的解法是利用栈(队列),将所有的节点压入占中栈(队列)中,令当前栈(队列)容量为 $cnt$。\n\n然后从栈顶(队列头)弹出 $k$ 个($cnt - k + 1$ 个)元素,最后一个出栈(出队列)的元素即是答案。\n\n代码(栈):\n```Java\nclass Solution {\n    public ListNode getKthFromEnd(ListNode head, int k) {\n        Deque<ListNode> d = new ArrayDeque<>();\n        while (head != null) {\n            d.addLast(head);\n            head = head.next;\n        }\n        ListNode ans = null;\n        while (k-- > 0) ans = d.pollLast();\n        return ans;\n    }\n}\n```\n代码(队列):\n```Java\nclass Solution {\n    public ListNode getKthFromEnd(ListNode head, int k) {\n        Deque<ListNode> d = new ArrayDeque<>();\n        while (head != null) {\n            d.addLast(head);\n            head = head.next;\n        }\n        k = d.size() - k + 1;\n        ListNode ans = null;\n        while (k-- > 0) ans = d.pollFirst();\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 差值法\n\n我们可以先对链表进行一次完整遍历,拿到总长度 $cnt$,最后由 $cnt - k$ 即是倒数第 $k$ 个节点距离 $head$ 节点的距离。\n\n代码:\n```Java\nclass Solution {\n    public ListNode getKthFromEnd(ListNode head, int k) {\n        int cnt = 0;\n        ListNode tmp = head;\n        while (tmp != null && ++cnt > 0) tmp = tmp.next;\n        cnt -= k;\n        while (cnt-- > 0) head = head.next;\n        return head; \n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 快慢指针\n\n事实上,我们还可以使用「快慢指针」进行求解。\n\n起始先让快指针 `fast` 先走 $k$ 步,此时 `fast` 和 `slow` 之间距离为 $k$,之后让 `fast` 和 `slow` 指针一起走(始终维持相对距离为 $k$),当 `fast` 到达链表尾部,`slow` 即停在倒数第 $k$ 个节点处。\n\n代码:\n```Java\nclass Solution {\n    public ListNode getKthFromEnd(ListNode head, int k) {\n        ListNode slow = head, fast = head;\n        while (k-- > 0) fast = fast.next;\n        while (fast != null) {\n            slow = slow.next;\n            fast = fast.next;\n        }\n        return slow;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 22. 链表中倒数第k个节点` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 24. 反转链表（简单）.md", "url_title": "剑指 Offer 24. 反转链表", "url": "https://leetcode.cn/problems/fan-zhuan-lian-biao-lcof/solution/by-ac_oier-nqfc/", "difficulty": "简单", "tags": ["链表", "迭代", "递归"], "question": "定义一个函数,输入一个链表的头节点,反转该链表并输出反转后链表的头节点。\n\n示例:\n```\n输入: 1->2->3->4->5->NULL\n\n输出: 5->4->3->2->1->NULL\n```\n\n限制:\n* $0 <= 节点个数 <= 5000$", "solution": "### 迭代\n\n迭代做法只需要使用两个指针即可,复用 `head` 变量来代指当前处理到的节点,使用 `prev` 变量代指原链表中 `head` 的上一节点,只需使用循环构造出所有的 `head.next = prev` 关系即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public ListNode reverseList(ListNode head) {\n        ListNode prev = null;\n        while (head != null) {\n            ListNode temp = head.next;\n            head.next = prev;\n            prev = head;\n            head = temp;\n        }\n        return prev;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction reverseList(head: ListNode | null): ListNode | null {\n    let prev = null\n    while (head != null) {\n        const temp = head.next\n        head.next = prev\n        prev = head\n        head = temp\n    }\n    return prev\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 递归\n\n相对而言,递归方法需要一定的抽象能力:将 `reverseList` 作为我们的递归函数,函数的含义为将以 `head` 为头节点进行翻转,并返回新的头节点。\n\n不失一般性考虑某个递归回合:当传入节点 `head` 为空,或者其 `next` 节点为空(即只有单个节点)时,我们 直接返回 `head` 即可。而对于剩余情况,对于某个节点 `head` 而言,我们可以先递归处理它的剩余部分 `reverseList(head.next)` ,此时我们拿到的返回值既是以 `head.next` 为头结点进行翻转后的新链表头结点,也是以 `head` 为头结点进行翻转后的新链表头结点,将其记为 `ans`。我们只需要关注原有 `head` 部分如何处理,即将原来的 `head -> head.next` 关系进行翻转,则有 `head.next.next = head`,并 `head.next` 指向空即可,最后返回 `ans`。\n\nJava 代码:\n```Java\nclass Solution {\n    public ListNode reverseList(ListNode head) {\n        if (head == null || head.next == null) return head;\n        ListNode ans = reverseList(head.next);\n        head.next.next = head;\n        head.next = null;\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction reverseList(head: ListNode | null): ListNode | null {\n    if (head == null || head.next == null) return head\n    const ans = reverseList(head.next)\n    head.next.next = head\n    head.next = null\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 24` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 25. 合并两个排序的链表（简单）.md", "url_title": "剑指 Offer 25. 合并两个排序的链表", "url": "https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof/solution/by-ac_oier-d6wf/", "difficulty": "简单", "tags": ["链表", "迭代", "递归"], "question": "输入两个递增排序的链表,合并这两个链表并使新链表中的节点仍然是递增排序的。\n\n示例1:\n```\n输入:1->2->4, 1->3->4\n\n输出:1->1->2->3->4->4\n```\n\n限制:\n* $0 <= 链表长度 <= 1000$", "solution": "### 迭代 - 二路归并\n\n使用「迭代」方式求解的话,本质与合并两个有序数组并无区别。\n\n创建一个虚拟头结点 `dummy` 来拼接合并后的链表,`cur` 代表当前合并链表的末尾位置,同时复用入参的 `l1` 和 `l2` 来进行构造。\n\n当 `l1` 和 `l2` 均不为空的时候,找到两者中的较小值拼接到 `cur ` 的后面,若 `l1` 和 `l2` 任一为空,则将另外的链表拼接完。\n\nJava 代码:\n```Java\nclass Solution {\n    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {\n        ListNode dummy = new ListNode(-1), cur = dummy;\n        while (l1 != null || l2 != null) {\n            if (l1 != null && l2 != null) {\n                if (l1.val < l2.val) {\n                    cur.next = l1;\n                    cur = cur.next; l1 = l1.next;\n                } else {\n                    cur.next = l2;\n                    cur = cur.next; l2 = l2.next;\n                }\n            } else if (l1 != null) {\n                cur.next = l1;\n                cur = cur.next; l1 = l1.next;\n            } else {\n                cur.next = l2;\n                cur = cur.next; l2 = l2.next;\n            }\n        }\n        return dummy.next;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction mergeTwoLists(l1: ListNode | null, l2: ListNode | null): ListNode | null {\n    let dummy = new ListNode(-1), cur = dummy\n    while (l1 != null || l2 != null) {\n        if (l1 != null && l2 != null) {\n            if (l1.val < l2.val) {\n                cur.next = l1\n                cur = cur.next; l1 = l1.next\n            } else {\n                cur.next = l2\n                cur = cur.next; l2 = l2.next\n            }\n        } else if (l1 != null) {\n            cur.next = l1\n            cur = cur.next; l1 = l1.next\n        } else {\n            cur.next = l2\n            cur = cur.next; l2 = l2.next\n        }\n    }\n    return dummy.next\n};\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 递归\n\n另一种实现方式是使用「递归」进行构造。\n\n直接将 `mergeTwoLists` 作为递归函数,该函数的定义为传入两个「有序」链表,并返回合并链表的头结点。\n\n显然当 `l1` 或者 `l2` 任一为空时,返回另一链表即可。\n\n而对于其余一般情况而言,根据 `l1` 和 `l2` 的节点值分情况讨论:\n\n* 若 `l1.val < l2.val`,说明此时 `l1` 必然是当前构造回合中值最小的节点,也就是需要被返回的头结点,而 `l1` 后接的内容应该是 `mergeTwoLists(l1.next, l2)`,含义 `l1` 后接的内容应该是由有序链表 `l1.next` 和 `l2` 合并而来;\n* 其余情况 `l1.val >= l2.val`,分析同理,此时有 `l2.next = mergeTwoLists(l2.next, l1)`,同时返回 `l2`。\n\nJava 代码:\n```Java\nclass Solution {\n    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {\n        if (l1 == null) return l2;\n        else if (l2 == null) return l1;\n        else if (l1.val < l2.val) {\n            l1.next = mergeTwoLists(l1.next, l2);\n            return l1;\n        } else {\n            l2.next = mergeTwoLists(l2.next, l1);\n            return l2;\n        }\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction mergeTwoLists(l1: ListNode | null, l2: ListNode | null): ListNode | null {\n    if (l1 == null) return l2\n    else if (l2 == null) return l1\n    else if (l1.val < l2.val) {\n        l1.next = mergeTwoLists(l1.next, l2)\n        return l1\n    } else {\n        l2.next = mergeTwoLists(l2.next, l1)\n        return l2\n    }\n};\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:忽略递归带来的额外空间开销,复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 25` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 32 - I. 从上到下打印二叉树（中等）.md", "url_title": "剑指 Offer 32 - I. 从上到下打印二叉树", "url": "https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof/solution/by-ac_oier-a9n5/", "difficulty": "中等", "tags": ["二叉树", "DFS", "BFS", "递归", "迭代"], "question": "从上到下打印出二叉树的每个节点,同一层的节点按照从左到右的顺序打印。\n\n例如:\n\n给定二叉树: `[3,9,20,null,null,15,7]`,\n```\n    3\n   / \\\n  9  20\n    /  \\\n   15   7\n```\n返回:\n```\n[3,9,20,15,7]\n```\n\n提示:\n* `节点总数 <= 1000`", "solution": "### 迭代 - BFS\n\n使用「迭代」进行求解是容易的,只需使用常规的 `BFS` 方法进行层序遍历即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] levelOrder(TreeNode root) {\n        List<Integer> list = new ArrayList<>();\n        Deque<TreeNode> d = new ArrayDeque<>();\n        if (root != null) d.addLast(root);\n        while (!d.isEmpty()) {\n            TreeNode t = d.pollFirst();\n            list.add(t.val);\n            if (t.left != null) d.addLast(t.left);\n            if (t.right != null) d.addLast(t.right);\n        }\n        int n = list.size();\n        int[] ans = new int[n];\n        for (int i = 0; i < n; i++) ans[i] = list.get(i);\n        return ans;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction levelOrder(root: TreeNode | null): number[] {\n    let he = 0, ta = 0\n    const ans: number[] = new Array<number>()\n    const d: TreeNode[] = new Array<TreeNode>()\n    if (root != null) d[ta++] = root\n    while (he < ta) {\n        const t = d[he++]\n        ans.push(t.val)\n        if (t.left != null) d[ta++] = t.left\n        if (t.right != null) d[ta++] = t.right\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 递归 - DFS\n\n使用「递归」来进行「层序遍历」虽然不太符合直观印象,但也是可以的。\n\n此时我们需要借助「哈希表」来存储起来每一层的节点情况。\n\n首先我们按照「中序遍历」的方式进行 `DFS`,同时在 `DFS` 过程中传递节点所在的深度(`root` 节点默认在深度最小的第 $0$ 层),每次处理当前节点时,通过哈希表获取所在层的数组,并将当前节点值追加到数组尾部,同时维护一个最大深度 `max`,在 `DFS` 完成后,再使用深度范围 $[0, max]$ 从哈希表中进行构造答案。\n\nJava 代码:\n```Java\nclass Solution {\n    Map<Integer, List<Integer>> map = new HashMap<>();\n    int max = -1, cnt = 0;\n    public int[] levelOrder(TreeNode root) {\n        dfs(root, 0);\n        int[] ans = new int[cnt];\n        for (int i = 0, idx = 0; i <= max; i++) {\n            for (int x : map.get(i)) ans[idx++] = x;\n        }\n        return ans;\n    }\n    void dfs(TreeNode root, int depth) {\n        if (root == null) return ;\n        max = Math.max(max, depth);\n        cnt++;\n        dfs(root.left, depth + 1);\n        List<Integer> list = map.getOrDefault(depth, new ArrayList<Integer>());\n        list.add(root.val);\n        map.put(depth, list);\n        dfs(root.right, depth + 1);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nconst map:Map<number, Array<number>> = new Map<number, Array<number>>()\nlet max = -1, cnt = 0\nfunction levelOrder(root: TreeNode | null): number[] {\n    map.clear()\n    max = -1; cnt = 0;\n    dfs(root, 0)\n    const ans: Array<number> = new Array<number>()\n    for (let i = 0; i <= max; i++) {\n        for (const x of map.get(i)) ans.push(x)\n    }\n    return ans\n};\nfunction dfs(root: TreeNode | null, depth: number): void {\n    if (root == null) return \n    max = Math.max(max, depth)\n    cnt++\n    dfs(root.left, depth + 1)\n    if (!map.has(depth)) map.set(depth, new Array<number>())\n    map.get(depth).push(root.val)\n    dfs(root.right, depth + 1)\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 32 - I` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 32 - II. 从上到下打印二叉树 II（简单）.md", "url_title": "剑指 Offer 32 - II. 从上到下打印二叉树 II", "url": "https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-ii-lcof/solution/by-ac_oier-s9jz/", "difficulty": "简单", "tags": ["二叉树", "DFS", "BFS", "递归", "迭代"], "question": "从上到下按层打印二叉树,同一层的节点按从左到右的顺序打印,每一层打印到一行。\n\n例如:\n给定二叉树: `[3,9,20,null,null,15,7]`,\n```\n    3\n   / \\\n  9  20\n    /  \\\n   15   7\n```\n返回其层次遍历结果:\n```\n[\n  [3],\n  [9,20],\n  [15,7]\n]\n```\n\n提示:\n* `节点总数 <= 1000`", "solution": "### 迭代 - BFS\n\n这道题是 [(题解)剑指 Offer 32 - I. 从上到下打印二叉树](https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof/solution/by-ac_oier-a9n5/) 的练习版本。\n\n只需要在每次 `BFS` 拓展时,将完整的层进行取出,存如独立数组后再加入答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public List<List<Integer>> levelOrder(TreeNode root) {\n        Deque<TreeNode> d = new ArrayDeque<>();\n        if (root != null) d.addLast(root);\n        List<List<Integer>> ans = new ArrayList<>();\n        while (!d.isEmpty()) {\n            int sz = d.size();\n            List<Integer> list = new ArrayList<>();\n            while (sz-- > 0) {\n                TreeNode t = d.pollFirst();\n                list.add(t.val);\n                if (t.left != null) d.addLast(t.left);\n                if (t.right != null) d.addLast(t.right);\n            }\n            ans.add(list);\n        }\n        return ans;\n    }\n}\n```\nTypescript 代码:\n```Typescript\nfunction levelOrder(root: TreeNode | null): number[][] {\n    const ans: number[][] = new Array<Array<number>>()\n    const stk: TreeNode[] = new Array<TreeNode>()\n    let he = 0, ta = 0\n    if (root != null) stk[ta++] = root\n    while (he < ta) {\n        const temp = new Array<number>()\n        let sz = ta - he\n        while (sz-- > 0) {\n            const t = stk[he++]\n            temp.push(t.val)\n            if (t.left != null) stk[ta++] = t.left\n            if (t.right != null) stk[ta++] = t.right\n        }\n        ans.push(temp)\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 递归 - DFS\n\n同理,可以使用「递归」来进行「层序遍历」。\n\n此时我们需要借助「哈希表」来存储起来每一层的节点情况。\n\n首先我们按照「中序遍历」的方式进行 `DFS`,同时在 `DFS` 过程中传递节点所在的深度(`root` 节点默认在深度最小的第 $0$ 层),每次处理当前节点时,通过哈希表获取所在层的数组,并将当前节点值追加到数组尾部,同时维护一个最大深度 `max`,在 `DFS` 完成后,再使用深度范围 $[0, max]$ 从哈希表中进行构造答案。\n\nJava 代码:\n```Java\nclass Solution {\n    Map<Integer, List<Integer>> map = new HashMap<>();\n    int max = -1;\n    public List<List<Integer>> levelOrder(TreeNode root) {\n        dfs(root, 0);\n        List<List<Integer>> ans = new ArrayList<>();\n        for (int i = 0; i <= max; i++) ans.add(map.get(i));\n        return ans;\n    }\n    void dfs(TreeNode root, int depth) {\n        if (root == null) return ;\n        max = Math.max(max, depth);\n        dfs(root.left, depth + 1);\n        List<Integer> list = map.getOrDefault(depth, new ArrayList<>());\n        list.add(root.val);\n        map.put(depth, list);\n        dfs(root.right, depth + 1);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nconst map: Map<number, Array<number>> = new Map<number, Array<number>>()\nlet max = -1\nfunction levelOrder(root: TreeNode | null): number[][] {\n    map.clear()\n    max = -1\n    dfs(root, 0)\n    const ans = new Array<Array<number>>()\n    for (let i = 0; i <= max; i++) ans.push(map.get(i))\n    return ans\n};\nfunction dfs(root: TreeNode | null, depth: number): void {\n    if (root == null) return \n    max = Math.max(max, depth)\n    dfs(root.left, depth + 1)\n    if (!map.has(depth)) map.set(depth, new Array<number>())\n    map.get(depth).push(root.val)\n    dfs(root.right, depth + 1)\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 32 - II` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 32 - III. 从上到下打印二叉树 III（中等）.md", "url_title": "剑指 Offer 32 - III. 从上到下打印二叉树 III", "url": "https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-iii-lcof/solution/by-ac_oier-98od/", "difficulty": "中等", "tags": ["二叉树", "DFS", "BFS", "递归", "迭代"], "question": "请实现一个函数按照之字形顺序打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右到左的顺序打印,第三行再按照从左到右的顺序打印,其他行以此类推。\n\n例如:\n\n给定二叉树: `[3,9,20,null,null,15,7]`,\n```\n    3\n   / \\\n  9  20\n    /  \\\n   15   7\n```\n返回其层次遍历结果:\n```\n[\n  [3],\n  [20,9],\n  [15,7]\n]\n```\n\n提示:\n* `节点总数 <= 1000`", "solution": "### 迭代 - BFS\n\n这题相比于前两道二叉树打印题目,增加了打印方向的要求。\n\n在 `BFS` 过程中,入队我们可以仍然采用「左子节点优先入队」进行,而在出队构造答案时,我们则要根据当前所在层数来做判别:对于所在层数为偶数(`root` 节点在第 $0$ 层),我们按照「出队添加到尾部」的方式进行;对于所在层数为奇数,我们按照「出队添加到头部」的方式进行。\n\n> 为支持「从尾部追加元素」和「从头部追加元素」操作,`Java` 可使用基于链表的 `LinkedList`,而 `TS` 可创建定长数组后通过下标赋值。\n\n其中判断当前所在层数,无须引用额外变量,直接根据当前 `ans` 的元素大小即可。\n\nJava 代码:\n```Java\nclass Solution {\n    public List<List<Integer>> levelOrder(TreeNode root) {\n        List<List<Integer>> ans = new ArrayList<>();\n        Deque<TreeNode> d = new ArrayDeque<>();\n        if (root != null) d.addLast(root);\n        while (!d.isEmpty()) {\n            LinkedList<Integer> list = new LinkedList<>();\n            int sz = d.size(), dirs = ans.size() % 2;\n            while (sz-- > 0) {\n                TreeNode t = d.pollFirst();\n                if (dirs == 0) list.addLast(t.val);\n                else list.addFirst(t.val); \n                if (t.left != null) d.addLast(t.left);\n                if (t.right != null) d.addLast(t.right);\n            }\n            ans.add(list);\n        }\n        return ans;\n    }\n}\n```\nTypescript 代码:\n```Typescript\nfunction levelOrder(root: TreeNode | null): number[][] {\n    const ans = new Array<Array<number>>()\n    const stk = new Array<TreeNode>()\n    let he = 0, ta = 0\n    if (root != null) stk[ta++] = root\n    while (he < ta) {\n        const dirs = ans.length % 2 == 0\n        let sz = ta - he, idx = dirs ? 0 : sz - 1\n        const temp = new Array<number>(sz)\n        while (sz-- > 0) {\n            const t = stk[he++]\n            temp[idx] = t.val\n            idx += dirs ? 1 : -1\n            if (t.left != null) stk[ta++] = t.left\n            if (t.right != null) stk[ta++] = t.right\n        }\n        ans.push(temp)\n    }\n    return ans\n};\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 递归 - DFS\n\n递归的实现方式与前两题同理。\n\n不过对于 `TS`  语言来说,由于 `DFS` 过程中无法知道当前层有多少节点,因此只能在使用「哈希表」记录每层「从左往右」的方向,然后在构造答案时,运用「双指针」来将奇数层的节点进行翻转。\n\nJava 代码:\n```Java\nclass Solution {\n    Map<Integer, LinkedList<Integer>> map = new HashMap<>();\n    int max = -1;\n    public List<List<Integer>> levelOrder(TreeNode root) {\n        dfs(root, 0);\n        List<List<Integer>> ans = new ArrayList<>();\n        for (int i = 0; i <= max; i++) ans.add(map.get(i));\n        return ans;\n    }\n    void dfs(TreeNode root, int depth) {\n        if (root == null) return ;\n        max = Math.max(max, depth);\n        dfs(root.left, depth + 1);\n        LinkedList<Integer> list = map.getOrDefault(depth, new LinkedList<>());\n        if (depth % 2 == 0) list.addLast(root.val);\n        else list.addFirst(root.val);\n        map.put(depth, list);\n        dfs(root.right, depth + 1);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nconst map: Map<number, Array<number>> = new Map<number, Array<number>> ()\nlet max = -1\nfunction levelOrder(root: TreeNode | null): number[][] {\n    map.clear()\n    max = -1\n    dfs(root, 0)\n    const ans = new Array<Array<number>>()\n    for (let i = 0; i <= max; i++) {\n        const temp = map.get(i)\n        if (i % 2 == 1) {\n            for (let p = 0, q = temp.length - 1; p < q; p++, q--) {\n                const c = temp[p]\n                temp[p] = temp[q]\n                temp[q] = c\n            } \n        }\n        ans.push(temp)\n    }\n    return ans\n};\nfunction dfs(root: TreeNode | null, depth: number): void {\n    if (root == null) return \n    max = Math.max(max, depth)\n    dfs(root.left, depth + 1)\n    if (!map.has(depth)) map.set(depth, new Array<number>())\n    map.get(depth).push(root.val)\n    dfs(root.right, depth + 1)\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 32 - III` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 34. 二叉树中和为某一值的路径（中等）.md", "url_title": "剑指 Offer 34. 二叉树中和为某一值的路径", "url": "https://leetcode.cn/problems/er-cha-shu-zhong-he-wei-mou-yi-zhi-de-lu-jing-lcof/solution/by-ac_oier-3ehr/", "difficulty": "中等", "tags": ["二叉树", "DFS", "BFS", "递归", "迭代"], "question": "给你二叉树的根节点 `root` 和一个整数目标和 `targetSum`,找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。\n\n叶子节点 是指没有子节点的节点。\n\n示例 1:\n\n```\n输入:root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22\n\n输出:[[5,4,11,2],[5,8,4,5]]\n```\n示例 2:\n\n```\n输入:root = [1,2,3], targetSum = 5\n\n输出:[]\n```\n示例 3:\n```\n输入:root = [1,2], targetSum = 0\n\n输出:[]\n```\n\n提示:\n* 树中节点总数在范围 $[0, 5000]$ 内\n* $-1000 <= Node.val <= 1000$\n* $-1000 <= targetSum <= 1000$", "solution": "### DFS\n\n较为直观的做法是使用 `DFS`,在 `DFS`  过程中记录路径以及路径对应的元素和,当出现元素和为 `target`,且到达了叶子节点,说明找到了一条满足要求的路径,将其加入答案。\n\n使用 `DFS` 的好处是在记录路径的过程中可以使用「回溯」的方式进行记录及回退,而无须时刻进行路径数组的拷贝。\n\nJava 代码:\n```Java\nclass Solution {\n    List<List<Integer>> ans = new ArrayList<>();\n    int t;\n    public List<List<Integer>> pathSum(TreeNode root, int target) {\n        t = target;\n        dfs(root, 0, new ArrayList<>());\n        return ans;\n    }\n    void dfs(TreeNode root, int cur, List<Integer> list) {\n        if (root == null) return ;\n        list.add(root.val);\n        if (cur + root.val == t && root.left == null && root.right == null) ans.add(new ArrayList<>(list));\n        dfs(root.left, cur + root.val, list);\n        dfs(root.right, cur + root.val, list);\n        list.remove(list.size() - 1);\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nlet ans: number[][]\nlet t\nfunction pathSum(root: TreeNode | null, target: number): number[][] {\n    ans = new Array<Array<number>>()\n    t = target\n    dfs(root, 0, new Array<number>())\n    return ans\n};\nfunction dfs(root: TreeNode | null, cur: number, list: Array<number>): void {\n    if (root == null) return \n    list.push(root.val)\n    if (cur + root.val == t && root.left == null && root.right == null) ans.push(list.slice())\n    dfs(root.left, cur + root.val, list)\n    dfs(root.right, cur + root.val, list)\n    list.pop()\n}\n```\n* 时间复杂度:最坏情况所有路径均为合法路径,复杂度为 $O(n \\times h)$\n* 空间复杂度:最坏情况所有路径均为合法路径,复杂度为 $O(n \\times h)$\n\n---\n\n### BFS\n\n使用 `BFS` 的话,我们需要封装一个类/结构体 `TNode`,该结构体存储所对应的原始节点 `node`,到达 `node` 所经过的路径 `list`,以及对应的路径和 `tot`。\n\n由于 `BFS` 过程并非按照路径进行(即相邻出队的节点并非在同一路径),因此我们每次创建新的 `TNode` 对象时,需要对路径进行拷贝操作。\n\nJava 代码:\n```Java\nclass Solution {\n    class Node {\n        TreeNode node;\n        List<Integer> list;\n        int tot;\n        Node (TreeNode _node, List<Integer> _list, int _tot) {\n            node = _node; list = new ArrayList<>(_list); tot = _tot;\n            list.add(node.val); tot += node.val;\n        }\n    }\n    public List<List<Integer>> pathSum(TreeNode root, int target) {\n        List<List<Integer>> ans = new ArrayList<>();\n        Deque<Node> d = new ArrayDeque<>();\n        if (root != null) d.addLast(new Node(root, new ArrayList<>(), 0));\n        while (!d.isEmpty()) {\n            Node t = d.pollFirst();\n            if (t.tot == target && t.node.left == null && t.node.right == null) ans.add(t.list);\n            if (t.node.left != null) d.addLast(new Node(t.node.left, t.list, t.tot));\n            if (t.node.right != null) d.addLast(new Node(t.node.right, t.list, t.tot));\n        }\n        return ans;\n    }\n}\n```\nTypescript 代码:\n```Typescript\nclass TNode {\n    node: TreeNode\n    tot: number\n    list: Array<number>\n    constructor(node: TreeNode, tot: number, list: Array<number>) {\n        this.node = node; this.tot = tot; this.list = list.slice();\n        this.list.push(node.val)\n        this.tot += node.val\n    }\n}\nfunction pathSum(root: TreeNode | null, target: number): number[][] {\n    const ans = new Array<Array<number>>()\n    const stk = new Array<TNode>()\n    let he = 0, ta = 0\n    if (root != null) stk[ta++] = new TNode(root, 0, new Array<number>())\n    while (he < ta) {\n        const t = stk[he++]\n        if (t.tot == target && t.node.left == null && t.node.right == null) ans.push(t.list)\n        if (t.node.left != null) stk[ta++] = new TNode(t.node.left, t.tot, t.list)\n        if (t.node.right != null) stk[ta++] = new TNode(t.node.right, t.tot, t.list)\n    }\n    return ans\n};\n```\n* 时间复杂度:最坏情况所有路径均为合法路径,复杂度为 $O(n \\times h)$\n* 空间复杂度:最坏情况所有路径均为合法路径,复杂度为 $O(n \\times h)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 34` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 35. 复杂链表的复制（中等）.md", "url_title": "剑指 Offer 35. 复杂链表的复制", "url": "https://leetcode.cn/problems/fu-za-lian-biao-de-fu-zhi-lcof/solution/by-ac_oier-6atv/", "difficulty": "中等", "tags": ["哈希表", "链表"], "question": "给你一个长度为 `n` 的链表,每个节点包含一个额外增加的随机指针 `random`,该指针可以指向链表中的任何节点或空节点。\n\n构造这个链表的 深拷贝。 深拷贝应该正好由 `n` 个 全新 节点组成,其中每个新节点的值都设为其对应的原节点的值。新节点的 `next` 指针和 `random` 指针也都应指向复制链表中的新节点,并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。\n\n例如,如果原链表中有 `X` 和 `Y` 两个节点,其中 `X.random --> Y` 。那么在复制链表中对应的两个节点 `x` 和 `y` ,同样有 `x.random --> y` 。\n\n返回复制链表的头节点。\n\n用一个由 `n` 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 `[val, random_index]` 表示:\n\n* `val`:一个表示 `Node.val` 的整数。\n* `random_index`:随机指针指向的节点索引(范围从 $0$ 到 $n-1$);如果不指向任何节点,则为  `null` 。\n\n你的代码 只 接受原链表的头节点 `head` 作为传入参数。\n\n示例 1:\n\n```\n输入:head = [[7,null],[13,0],[11,4],[10,2],[1,0]]\n\n输出:[[7,null],[13,0],[11,4],[10,2],[1,0]]\n```\n示例 2:\n\n```\n输入:head = [[1,1],[2,1]]\n\n输出:[[1,1],[2,1]]\n```\n示例 3:\n\n```\n输入:head = [[3,null],[3,0],[3,null]]\n\n输出:[[3,null],[3,0],[3,null]]\n```\n示例 4:\n```\n输入:head = []\n\n输出:[]\n\n解释:给定的链表为空(空指针),因此返回 null。\n```\n\n提示:\n* $0 <= n <= 1000$\n* $-10000 <= Node.val <= 10000$", "solution": "### 模拟 + 哈希表\n\n如果不考虑 `random` 指针的话,对一条链表进行拷贝,我们只需要使用两个指针:一个用于遍历原链表,一个用于构造新链表(始终指向新链表的尾部)即可。这一步操作可看做是「创建节点 + 构建 `next` 指针关系」。\n\n现在在此基础上增加一个 `random` 指针,我们可以将 `next` 指针和 `random` 指针关系的构建拆开进行:\n\n1. 先不考虑 `random` 指针,和原本的链表复制一样,创建新新节点,并构造 `next` 指针关系,同时使用「哈希表」记录原节点和新节点的映射关系;\n2. 对原链表和新链表进行同时遍历,对于原链表的每个节点上的 `random` 都通过「哈希表」找到对应的新 `random` 节点,并在新链表上构造 `random` 关系。\n\n代码:\n```Java\nclass Solution {\n    public Node copyRandomList(Node head) {\n        Node t = head;\n        Node dummy = new Node(-10010), cur = dummy;\n        Map<Node, Node> map = new HashMap<>();\n        while (head != null) {\n            Node node = new Node(head.val);\n            map.put(head, node);\n            cur.next = node;\n            cur = cur.next; head = head.next;\n        }\n        cur = dummy.next; head = t;\n        while (head != null) {\n            cur.random = map.get(head.random);\n            cur = cur.next; head = head.next;\n        }\n        return dummy.next;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 模拟(原地算法)\n\n显然时间复杂度上无法优化,考虑如何降低空间(不使用「哈希表」)。\n\n我们使用「哈希表」的目的为了实现原节点和新节点的映射关系,更进一步的是为了快速找到某个节点 `random` 在新链表的位置。\n\n那么我们可以利用原链表的 `next` 做一个临时中转,从而实现映射。\n\n具体的,我们可以按照如下流程进行:\n\n1. 对原链表的每个节点节点进行复制,并追加到原节点的后面;\n2. 完成 $1$ 操作之后,链表的奇数位置代表了原链表节点,链表的偶数位置代表了新链表节点,且每个原节点的 `next` 指针执行了对应的新节点。这时候,我们需要构造新链表的 `random` 指针关系,可以利用 `link[i + 1].random = link[i].random.next`,$i$ 为奇数下标,含义为 **新链表节点的 `random` 指针指向旧链表对应节点的 `random` 指针的下一个值**;\n3. 对链表进行拆分操作。\n\n代码:\n```Java\nclass Solution {\n    public Node copyRandomList(Node head) {\n        if (head == null) return head;\n        Node t = head;\n        while (head != null) {\n            Node node = new Node(head.val);\n            node.next = head.next;\n            head.next = node;\n            head = node.next;\n        }\n        head = t;\n        while (head != null) {\n            if (head.random != null) head.next.random = head.random.next;\n            head = head.next.next;\n        }\n        head = t;\n        Node ans = head.next;\n        while (head != null) {\n            Node ne = head.next;\n            if (ne != null) head.next = ne.next;\n            head = ne;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 35` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 37. 序列化二叉树（困难）.md", "url_title": "剑指 Offer 37. 序列化二叉树", "url": "https://leetcode-cn.com/problems/xu-lie-hua-er-cha-shu-lcof/solution/gong-shui-san-xie-er-cha-shu-de-xu-lie-h-n89a/", "difficulty": "困难", "tags": ["二叉树", "层序遍历"], "question": "序列化是将一个数据结构或者对象转换为连续的比特位的操作,进而可以将转换后的数据存储在一个文件或者内存中,同时也可以通过网络传输到另一个计算机环境,采取相反方式重构得到原数据。\n\n请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑,你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。\n\n提示: 输入输出格式与 LeetCode 目前使用的方式一致,详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式,你也可以采用其他的方法解决这个问题。\n\n示例 1:\n\n```\n输入:root = [1,2,3,null,null,4,5]\n输出:[1,2,3,null,null,4,5]\n```\n示例 2:\n```\n输入:root = []\n输出:[]\n```\n示例 3:\n```\n输入:root = [1]\n输出:[1]\n```\n示例 4:\n```\n输入:root = [1,2]\n输出:[1,2]\n```\n\n提示:\n* 树中结点数在范围 $[0, 10^4]$ 内\n* -1000 <= Node.val <= 1000", "solution": "### 基本思路\n\n无论使用何种「遍历方式」进行二叉树存储,为了方便,我们都需要对空节点有所表示。\n\n其实题目本身的样例就给我们提供了很好的思路:**使用层序遍历的方式进行存储,对于某个叶子节点的空节点进行存储,同时确保不递归存储空节点对应的子节点。**\n\n---\n\n### 层序遍历\n\n根据节点值的数据范围 `-1000 <= Node.val <= 1000`(我是在 [297. 二叉树的序列化与反序列化](https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree/) 看的,你也可以不使用数字,使用某个特殊字符进行表示,只要能在反序列时有所区分即可),我们可以建立占位节点 `emptyNode` 用来代指空节点(`emptyNode.val = INF`)。\n\n序列化:先特判掉空树的情况,之后就是常规的层序遍历逻辑:\n\n1. 起始时,将 `root` 节点入队;\n2. 从队列中取出节点,检查节点是否有左/右节点:\n    * 如果有的话,将值追加序列化字符中(注意使用分隔符),并将节点入队;\n    * 如果没有,检查当前节点是否为 `emptyNode` 节点,如果不是 `emptyNode` 说明是常规的叶子节点,需要将其对应的空节点进行存储,即将 `emptyNode` 入队;\n3. 循环流程 $2$,直到整个队列为空。\n\n反序列:同理,怎么「序列化」就怎么进行「反序列」即可:\n\n1. 起始时,构造出 `root` 并入队;\n2. 每次从队列取出元素时,同时从序列化字符中截取两个值(对应左右节点),检查是否为 `INF`,若不为 `INF` 则构建对应节点;\n3. 循环流程 $2$,直到整个序列化字符串被处理完(注意跳过最后一位分隔符)。\n\n代码:\n```Java\npublic class Codec {\n    int INF = -2000;\n    TreeNode emptyNode = new TreeNode(INF);\n    public String serialize(TreeNode root) {\n        if (root == null) return \"\";\n\n        StringBuilder sb = new StringBuilder();\n        Deque<TreeNode> d = new ArrayDeque<>();\n        d.addLast(root);\n        while (!d.isEmpty()) {\n            TreeNode poll = d.pollFirst();\n            sb.append(poll.val + \"_\");\n            if (!poll.equals(emptyNode)) {\n                d.addLast(poll.left != null ? poll.left : emptyNode);\n                d.addLast(poll.right != null ? poll.right : emptyNode);\n            }\n        }\n        return sb.toString();\n    }\n\n    public TreeNode deserialize(String data) {\n        if (data.equals(\"\")) return null;\n\n        String[] ss = data.split(\"_\");\n        int n = ss.length;\n        TreeNode root = new TreeNode(Integer.parseInt(ss[0]));\n        Deque<TreeNode> d = new ArrayDeque<>();\n        d.addLast(root);\n        for (int i = 1; i < n - 1; i += 2) {\n            TreeNode poll = d.pollFirst();\n            int a = Integer.parseInt(ss[i]), b = Integer.parseInt(ss[i + 1]);\n            if (a != INF) {\n                poll.left = new TreeNode(a);\n                d.addLast(poll.left);\n            }\n            if (b != INF) {\n                poll.right = new TreeNode(b);\n                d.addLast(poll.right);\n            }\n        }\n        return root;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 37` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 38. 字符串的排列（中等）.md", "url_title": "剑指 Offer 38. 字符串的排列", "url": "https://leetcode-cn.com/problems/zi-fu-chuan-de-pai-lie-lcof/solution/gong-shui-san-xie-tong-yong-shi-xian-qu-4jbkj/", "difficulty": "中等", "tags": ["字符串", "回溯算法"], "question": "输入一个字符串,打印出该字符串中字符的所有排列。\n\n你可以以任意顺序返回这个字符串数组,但里面不能有重复元素。\n\n示例:\n```\n输入:s = \"abc\"\n输出:[\"abc\",\"acb\",\"bac\",\"bca\",\"cab\",\"cba\"]\n```\n\n限制:\n* 1 <= s 的长度 <= 8", "solution": "### 基本分析\n\n根据题意,我们需要返回所有不重复的排列字符串。\n\n此类问题通常都是使用 `DFS` 来做:**决策当前字符串的某一位填入什么字符。**\n\n设计如下 `DFS` 函数:\n\n```Java\n/**\n *   cs : 原字符串\n *    u : 当前决策到目标字符串的哪一位\n *  cur : 当前目标字符串\n */\nvoid dfs(char[] cs, int u, String cur);\n```\n\n而对于去重通常有两种方式:\n\n1. 使用 `Set` 实现去重;\n2. 先对原字符串进行排序,然后确保相同字符传入同一目标位置的动作只发生一次。\n\n---\n\n### 回溯(Set 去重)\n\n使用 `HashSet` 实现去重十分简单,就是不用考虑去重问题。\n\n直接决策目标字符串哪一位取哪个字符即可,同时使用布尔数组记录哪些字符已使用。\n\n代码:\n```Java\nclass Solution {\n    int N = 10;\n    Set<String> set = new HashSet<>();\n    boolean[] vis = new boolean[N];\n    public String[] permutation(String s) {\n        char[] cs = s.toCharArray();\n        dfs(cs, 0, \"\");\n        String[] ans = new String[set.size()];\n        int idx = 0;\n        for (String str : set) ans[idx++] = str;\n        return ans;\n    }\n    void dfs(char[] cs, int u, String cur) {\n        int n = cs.length;\n        if (u == n) {\n            set.add(cur);\n            return;\n        }\n        for (int i = 0; i < n; i++) {\n            if (!vis[i]) {\n                vis[i] = true;\n                dfs(cs, u + 1, cur + String.valueOf(cs[i]));\n                vis[i] = false;\n            }\n        }\n    }\n}\n```\n* 时间复杂度:$O(n * n!)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 回溯(排序去重)\n\n想要通过预处理实现去重,需要「**先对原字符串进行排序,然后确保相同字符传入同一目标位置的动作只发生一次**」。\n\n具体的,我们可以在「决策目标字符串的第 $u$ 个位置」时,对于 `cs[i-1] = cs[i]` 的情况进行跳过,同时为了确保这个动作不会影响到后面的位置决策,需要利用同一目标位置会进行“回溯”的特性,增加一个 `!vis[i - 1]` 的判断。\n\n这样对于形如 `...xxx...` 的原字符串,使用字符 `x` 决策目标字符串的第 $u$ 个位置的动作只会发生一次,从而确保了一模一样的分支不会在「递归树」中展开多次。\n\n此类去重方式在很多方式出现过,事实上这种去重方式不仅仅能应用于排列问题。\n\n其本质是对递归树中「状态完全相同」的节点进行跳过,从而实现去重。\n\n这里的「状态完全相同」是指:**当前形成部分结果为 $cur$ 相同,同时剩余字符集合也相同**。\n\n代码:\n```Java\nclass Solution {\n    int N = 10;\n    List<String> list = new ArrayList<>();\n    boolean[] vis = new boolean[N];\n    public String[] permutation(String s) {\n        char[] cs = s.toCharArray();\n        Arrays.sort(cs);\n        dfs(cs, 0, \"\");\n        String[] ans = new String[list.size()];\n        int idx = 0;\n        for (String str : list) ans[idx++] = str;\n        return ans;\n    }\n    void dfs(char[] cs, int u, String cur) {\n        int n = cs.length;\n        if (u == n) {\n            list.add(cur);\n            return;\n        }\n        for (int i = 0; i < n; i++) {\n            if (i > 0 && !vis[i - 1] && cs[i] == cs[i - 1]) continue;\n            if (!vis[i]) {\n                vis[i] = true;\n                dfs(cs, u + 1, cur + String.valueOf(cs[i]));\n                vis[i] = false;\n            }\n        }\n    }\n}\n```\n* 时间复杂度:$O(n * n!)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 38` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 41. 数据流中的中位数（困难）.md", "url_title": "剑指 Offer 41. 数据流中的中位数", "url": "https://leetcode.cn/problems/shu-ju-liu-zhong-de-zhong-wei-shu-lcof/solution/by-ac_oier-exn5/", "difficulty": "困难", "tags": ["优先队列(堆)"], "question": "中位数是有序列表中间的数。如果列表长度是偶数,中位数则是中间两个数的平均值。\n\n例如,\n\n* `[2,3,4]` 的中位数是 $3$\n* `[2,3]` 的中位数是 $(2 + 3) / 2 = 2.5$\n\n设计一个支持以下两种操作的数据结构:\n* `void addNum(int num)` - 从数据流中添加一个整数到数据结构中。\n* `double findMedian()` - 返回目前所有元素的中位数。\n\n示例:\n```\naddNum(1)\naddNum(2)\nfindMedian() -> 1.5\naddNum(3) \nfindMedian() -> 2\n```\n\n进阶:\n* 如果数据流中所有整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法?\n* 如果数据流中 `99%` 的整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法?", "solution": "### 优先队列(堆)\n\n这是一道经典的数据结构运用题。\n\n具体的,**我们可以使用两个优先队列(堆)来维护整个数据流数据,令维护数据流左半边数据的优先队列(堆)为 `l`,维护数据流右半边数据的优先队列(堆)为 `r`**。\n\n显然,**为了可以在 $O(1)$ 的复杂度内取得当前中位数,我们应当令 `l` 为大根堆,`r` 为小根堆,并人为固定 `l` 和 `r` 之前存在如下的大小关系**:\n\n* **当数据流元素数量为偶数:`l` 和 `r` 大小相同,此时动态中位数为两者堆顶元素的平均值;**\n* **当数据流元素数量为奇数:`l` 比 `r` 多一,此时动态中位数为 `l` 的堆顶原数。**\n\n为了满足上述说的奇偶性堆大小关系,在进行 `addNum` 时,我们应当分情况处理:\n\n* 插入前两者大小相同,说明插入前数据流元素个数为偶数,插入后变为奇数。我们期望操作完达到「`l` 的数量为 `r` 多一,同时双堆维持有序」,进一步分情况讨论:\n    * 如果 `r` 为空,说明当前插入的是首个元素,直接添加到 `l` 即可;\n    * 如果 `r` 不为空,且 `num <= r.peek()`,说明 `num` 的插入位置不会在后半部分(不会在 `r` 中),直接加到 `l` 即可;\n    * 如果 `r` 不为空,且 `num > r.peek()`,说明 `num` 的插入位置在后半部分,此时将 `r` 的堆顶元素放到 `l` 中,再把 `num` 放到 `r`(相当于从 `r` 中置换一位出来放到 `l` 中)。\n\n* 插入前两者大小不同,说明前数据流元素个数为奇数,插入后变为偶数。我们期望操作完达到「`l` 和 `r` 数量相等,同时双堆维持有序」,进一步分情况讨论(此时 `l` 必然比 `r` 元素多一):\n    * 如果 `num >= l.peek()`,说明 `num` 的插入位置不会在前半部分(不会在 `l` 中),直接添加到 `r` 即可。\n    * 如果 `num < l.peek()`,说明 `num` 的插入位置在前半部分,此时将 `l` 的堆顶元素放到 `r` 中,再把 `num` 放入 `l` 中(相等于从 `l` 中替换一位出来当到 `r` 中)。\n\n代码:\n```Java\nclass MedianFinder {\n    PriorityQueue<Integer> l = new PriorityQueue<>((a,b)->b-a);\n    PriorityQueue<Integer> r = new PriorityQueue<>((a,b)->a-b);\n    public void addNum(int num) {\n        int s1 = l.size(), s2 = r.size();\n        if (s1 == s2) {\n            if (r.isEmpty() || num <= r.peek()) {\n                l.add(num);\n            } else {\n                l.add(r.poll());\n                r.add(num);\n            }\n        } else {\n            if (l.peek() <= num) {\n                r.add(num);\n            } else {\n                r.add(l.poll());\n                l.add(num);\n            }\n        }\n    }\n    public double findMedian() {\n        int s1 = l.size(), s2 = r.size();\n        if (s1 == s2) {\n            return (l.peek() + r.peek()) / 2.0;\n        } else {\n            return l.peek();\n        }\n    }\n}\n```\n* 时间复杂度:`addNum` 函数的复杂度为 $O(\\log{n})$;`findMedian` 函数的复杂度为 $O(1)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 进阶\n\n* 如果数据流中所有整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法?\n\n可以使用建立长度为 $101$ 的桶,每个桶分别统计每个数的出现次数,同时记录数据流中总的元素数量,每次查找中位数时,先计算出中位数是第几位,从前往后扫描所有的桶得到答案。\n\n**这种做法相比于对顶堆做法,计算量上没有优势,更多的是空间上的优化。**\n\n**对顶堆解法两个操作中耗时操作复杂度为 $O(\\log{n})$,$\\log$ 操作常数不会超过 $3$,在极限数据 $10^7$ 情况下计算量仍然低于耗时操作复杂度为 $O(C)$($C$ 固定为 $101$)桶计数解法。**\n\n* 如果数据流中 `99%` 的整数都在 $0$ 到 $100$ 范围内,你将如何优化你的算法?\n\n和上一问解法类似,对于 $1$% 采用哨兵机制进行解决即可,在常规的最小桶和最大桶两侧分别维护一个有序序列,即建立一个代表负无穷和正无穷的桶。\n\n上述两个进阶问题的代码如下,但注意由于真实样例的数据分布不是进阶所描述的那样(不是绝大多数都在 $[0,100]$ 范围内),所以会 `TLE`。\n\n代码:\n```Java\nclass MedianFinder {\n    TreeMap<Integer, Integer> head = new TreeMap<>(), tail = new TreeMap<>();\n    int[] arr = new int[101];\n    int a, b, c;\n    public void addNum(int num) {\n        if (num >= 0 && num <= 100) {\n            arr[num]++;\n            b++;\n        } else if (num < 0) {\n            head.put(num, head.getOrDefault(num, 0) + 1);\n            a++;\n        } else if (num > 100) {\n            tail.put(num, tail.getOrDefault(num, 0) + 1);\n            c++;\n        }\n    }\n    public double findMedian() {\n        int size = a + b + c;\n        if (size % 2 == 0) return (find(size / 2) + find(size / 2 + 1)) / 2.0;\n        return find(size / 2 + 1);\n    }\n    int find(int n) {\n        if (n <= a) {\n            for (int num : head.keySet()) {\n                n -= head.get(num);\n                if (n <= 0) return num; \n            }\n        } else if (n <= a + b) {\n            n -= a;\n            for (int i = 0; i <= 100; i++) {\n                n -= arr[i];\n                if (n <= 0) return i;\n            }\n        } else {\n            n -= a + b;\n            for (int num : tail.keySet()) {\n                n -= tail.get(num);\n                if (n <= 0) return num;\n            }\n        }\n        return -1; // never\n    }\n}\n```", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 41` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 42. 连续子数组的最大和（简单）.md", "url_title": "剑指 Offer 42. 连续子数组的最大和", "url": "https://leetcode-cn.com/problems/lian-xu-zi-shu-zu-de-zui-da-he-lcof/solution/gong-shui-san-xie-jian-dan-xian-xing-dp-mqk5v/", "difficulty": "简单", "tags": ["线性 DP"], "question": "输入一个整型数组,数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。\n\n要求时间复杂度为$O(n)$。\n\n示例1:\n```\n输入: nums = [-2,1,-3,4,-1,2,1,-5,4]\n\n输出: 6\n\n解释: 连续子数组 [4,-1,2,1] 的和最大,为 6。\n```\n\n提示:\n* 1 <= arr.length <= $10^5$\n* -100 <= arr[i] <= 100", "solution": "### 动态规划\n\n这是一道简单线性 DP 题。\n\n定义 $f[i]$ 为考虑以 $nums[i]$ 为结尾的子数组的最大值。\n\n不失一般性的考虑 $f[i]$ 如何转移。\n\n显然对于 $nums[i]$ 而言,以它为结尾的子数组分两种情况:\n\n* $num[i]$ 自身作为独立子数组:$f[i] = nums[i]$ ;\n* $num[i]$ 与之前的数值组成子数组,由于是子数组,其只能接在 $nums[i - 1]$,即有:$f[i] = f[i - 1] + nums[i]$。\n\n最终 $f[i]$ 为上述两种情况取 $\\max$ 即可:\n\n$$\nf[i] = \\max(nums[i], f[i - 1] + nums[i])\n$$\n\n代码:\n```Java\nclass Solution {\n    public int maxSubArray(int[] nums) {\n        int n = nums.length;\n        int[] f = new int[n];\n        f[0] = nums[0];\n        int ans = f[0];\n        for (int i = 1; i < n; i++) {\n            f[i] = Math.max(nums[i], f[i - 1] + nums[i]);\n            ans = Math.max(ans, f[i]);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n--- \n\n### 空间优化\n\n观察状态转移方程,我们发现 $f[i]$ 明确值依赖于 $f[i - 1]$。\n\n因此我们可以使用「有限变量」或者「滚动数组」的方式,将空间优化至 $O(1)$。\n\n代码:\n```Java\nclass Solution {\n    public int maxSubArray(int[] nums) {\n        int n = nums.length;\n        int max = nums[0], ans = max;\n        for (int i = 1; i < n; i++) {\n            max = Math.max(nums[i], max + nums[i]);\n            ans = Math.max(ans, max);\n        }\n        return ans;\n    }\n}\n```\n```Java\nclass Solution {\n    public int maxSubArray(int[] nums) {\n        int n = nums.length;\n        int[] f = new int[2];\n        f[0] = nums[0];\n        int ans = f[0];\n        for (int i = 1; i < n; i++) {\n            int a = i & 1, b = (i - 1) & 1;\n            f[a] = Math.max(nums[i], f[b] + nums[i]);\n            ans = Math.max(ans, f[a]);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 拓展\n\n一个有意思的拓展是,将 **加法** 替换成 **乘法**。\n\n题目变成 [152. 乘积最大子数组(中等)](https://leetcode-cn.com/problems/maximum-product-subarray/)。\n\n又该如何考虑呢?\n\n一个朴素的想法,仍然是考虑定义 $f[i]$ 代表以 $nums[i]$ 为结尾的最大值,但存在「负负得正」取得最大值的情况,光维护一个前缀最大值显然是不够的,我们可以多引入一维 $g[i]$ 作为前缀最小值。\n\n其余分析与本题同理。\n\n代码:\n```Java\nclass Solution {\n    public int maxProduct(int[] nums) {\n        int n = nums.length;\n        int[] g = new int[n + 1]; // 考虑前 i 个,结果最小值\n        int[] f = new int[n + 1]; // 考虑前 i 个,结果最大值\n        g[0] = 1;\n        f[0] = 1;\n        int ans = nums[0];\n        for (int i = 1; i <= n; i++) {\n            int x = nums[i - 1];\n            g[i] = Math.min(x, Math.min(g[i - 1] * x, f[i - 1] * x));\n            f[i] = Math.max(x, Math.max(g[i - 1] * x, f[i - 1] * x));\n            ans = Math.max(ans, f[i]);\n        }\n        return ans;\n    }\n}\n```\n```Java\nclass Solution {\n    public int maxProduct(int[] nums) {\n        int n = nums.length;\n        int min = 1, max = 1;\n        int ans = nums[0];\n        for (int i = 1; i <= n; i++) {\n            int x = nums[i - 1];\n            int nmin = Math.min(x, Math.min(min * x, max * x));\n            int nmax = Math.max(x, Math.max(min * x, max * x));\n            min = nmin;\n            max = nmax;\n            ans = Math.max(ans, max);\n        }\n        return ans;\n    }\n}\n```", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 42` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 44. 数字序列中某一位的数字（中等）.md", "url_title": "剑指 Offer 44. 数字序列中某一位的数字", "url": "https://leetcode.cn/problems/shu-zi-xu-lie-zhong-mou-yi-wei-de-shu-zi-lcof/solution/by-ac_oier-wgr8/", "difficulty": "中等", "tags": ["数学", "模拟"], "question": "数字以 `0123456789101112131415...` 的格式序列化到一个字符序列中。在这个序列中,第 $5$ 位(从下标 $0$ 开始计数)是 $5$,第 $13$ 位是 $1$,第 $19$ 位是 $4$,等等。\n\n请写一个函数,求任意第 $n$ 位对应的数字。\n\n示例 1:\n```\n输入:n = 3\n\n输出:3\n```\n示例 2:\n```\n输入:n = 11\n\n输出:0\n```\n\n限制:\n* $0 <= n < 2^31$", "solution": "### 模拟\n\n我们知道,对于长度为 $len$ 的数字的范围为 $[10^{len - 1}, 10^{len} - 1]$(共 $9 \\times 10^{len - 1}$ 个),总长度为:\n\n$$\nL = len \\times 9 \\times 10^{len - 1}\n$$\n\n因此我们可以先对 $n$ 进行不断试减(更新 $n$),确定下来目标数字 $x$ 的长度为多少,假设为 $len$。\n\n然后直接计算出长度 $len$ 的最小值为 $s = 10^{len - 1}$,由于范围内的数长度都是 $len$,因此我们可以直接定位到目标数字 $x$ 为何值。\n\n根据目标值 $x$ 必然满足关系式:\n\n$$\n(x - s + 1) \\times len \\geq n\n$$\n\n变形可得:\n\n$$\nx \\geq \\left \\lfloor \\frac{n}{len} \\right \\rfloor - 1 + s\n$$\n\n对 $n$ 进行最后一次的试减(更新 $n$),若恰好有 $n = 0$,说明答案为 $x$ 的最后一位,可由 `x % 10` 取得;若大于 $0$,说明答案是 $x + 1$ 的第 $n$ 位(十进制表示,从左往右数),可由 `(x + 1) / (int) (Math.pow(10, len - n)) % 10` 取得。\n\n代码:\n```Java\nclass Solution {\n    public int findNthDigit(int n) {\n        int len = 1;\n        while (len * 9 * Math.pow(10, len - 1) < n) {\n            n -= len * 9 * Math.pow(10, len - 1);\n            len++;\n        }\n        long s = (long) Math.pow(10, len - 1);\n        long x = n / len - 1 + s;\n        n -= (x - s + 1) * len;\n        return n == 0 ? (int) (x % 10) : (int) ((x + 1) / Math.pow(10, len - n) % 10);\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$\n\n---\n\n### 补充\n\n上述讲解可能对于新手并不友好,尤其是对一些上来只做剑指 Offer 的面试向同学,下面使用更为通俗的方式进行讲解。\n\n对于长度 `len` 的所有数,其最小值为 $10^{len - 1}$,最大值为 $10^{len} - 1$,每个数所能贡献的数的个数为 $len$ 个,因此对于长度为 `len` 的所有数,其所能贡献的数的个数为 $(10^{len} - 10^{len - 1}) \\times len$。我们专门开一个函数 `getCnt` 来计算长度为 `len` 的数的个数有多少。\n\n然后我们从 `len = 1` 开始,不断对 `n` 进行试减(`len` 递增),直到 `getCnt(len) <= n` 不再满足。\n\n假设此时的递增到的长度为 `len`,可知长度为 `len` 的最小值 $start = 10^{len - 1}$,我们可以通过计算偏移量 $\\left \\lfloor \\frac{n}{len} \\right \\rfloor$ 并将其累加到 $start$ 中去,同时对 `n` 进行 $\\left \\lfloor \\frac{n}{len} \\right \\rfloor \\times len$ 的消减。\n\n然后根据 `n` 是否为 $0$ 进行分情况讨论:\n\n* 当 `n` 为 $0$,说明答案落在 $start - 1$ 的最后一位,即 `(start - 1) % 10` ;\n* 当 `n` 不为 $0$,说明答案为 `start` 数值中从左往右数的第 $n$ 位,可通过解法一的方式取得,也可以将其转字符串再通过下标获取。\n\n代码:\n```Java\nclass Solution {\n    long getCnt(int len) {\n        return (long)(Math.pow(10, len) - Math.pow(10, len - 1)) * len;\n    }\n    public int findNthDigit(int n) {\n        int len = 1;\n        while (getCnt(len) <= n) {\n            n -= getCnt(len);\n            len++;\n        }\n        long start = (long)Math.pow(10, len - 1);\n        start += n / len;\n        n -= n / len * len;\n        if (n == 0) return (int)(start - 1) % 10;\n        else return String.valueOf(start).toCharArray()[n - 1] - '0';\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 44` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 52. 两个链表的第一个公共节点（简单）.md", "url_title": "剑指 Offer 52. 两个链表的第一个公共节点", "url": "https://leetcode-cn.com/problems/liang-ge-lian-biao-de-di-yi-ge-gong-gong-jie-dian-lcof/solution/gong-shui-san-xie-zhao-liang-tiao-lian-b-ifqw/", "difficulty": "简单", "tags": ["链表"], "question": "输入两个链表,找出它们的第一个公共节点。\n\n如下面的两个链表:\n\n在节点 c1 开始相交。\n\n示例 1:\n\n```\n输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3\n\n输出:Reference of the node with value = 8\n\n输入解释:相交节点的值为 8 (注意,如果两个列表相交则不能为 0)。从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,0,1,8,4,5]。在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。\n```\n\n示例 2:\n\n```\n输入:intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1\n\n输出:Reference of the node with value = 2\n\n输入解释:相交节点的值为 2 (注意,如果两个列表相交则不能为 0)。从各自的表头开始算起,链表 A 为 [0,9,1,2,4],链表 B 为 [3,2,4]。在 A 中,相交节点前有 3 个节点;在 B 中,相交节点前有 1 个节点。\n```\n\n示例 3:\n\n```\n输入:intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2\n\n输出:null\n\n输入解释:从各自的表头开始算起,链表 A 为 [2,6,4],链表 B 为 [1,5]。由于这两个链表不相交,所以 intersectVal 必须为 0,而 skipA 和 skipB 可以是任意值。\n\n解释:这两个链表不相交,因此返回 null。\n```\n\n注意:\n* 如果两个链表没有交点,返回 null.\n* 在返回结果后,两个链表仍须保持原有的结构。\n* 可假定整个链表结构中没有循环。\n* 程序尽量满足 $O(n)$ 时间复杂度,且仅用 $O(1)$ 内存。", "solution": "### 朴素解法\n\n一个朴素的解法自然是两层枚举,逐个检查哪个节点相同。\n\n代码:\n```Java\npublic class Solution {\n    public ListNode getIntersectionNode(ListNode a, ListNode b) {\n        for (ListNode h1 = a; h1 != null ; h1 = h1.next) {\n            for (ListNode h2 = b; h2 != null ; h2 = h2.next) {\n                if (h1 == h2) return h1;\n            }\n        }\n        return null;\n    }\n}\n```\n* 时间复杂度:$O(n * m)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 栈解法\n\n这是一种「从后往前」找的方式。\n\n将两条链表分别压入两个栈中,然后循环比较两个栈的栈顶元素,同时记录上一位栈顶元素。\n\n当遇到第一个不同的节点时,结束循环,上一位栈顶元素即是答案。\n\n代码:\n```Java\npublic class Solution {\n    public ListNode getIntersectionNode(ListNode a, ListNode b) {\n        Deque<ListNode> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();\n        while (a != null) {\n            d1.add(a);\n            a = a.next;\n        }\n        while (b != null) {\n            d2.add(b);\n            b = b.next;\n        }\n        ListNode ans = null;\n        while (!d1.isEmpty() && !d2.isEmpty() && d1.peekLast() == d2.peekLast()) {\n            ans = d1.pollLast();\n            d2.pollLast();\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(n + m)$\n\n---\n\n### Set 解法\n\n这是一种「从前往后」找的方式。\n\n使用 `Set` 数据结构,先对某一条链表进行遍历,同时记录下来所有的节点。\n\n然后在对第二链条进行遍历时,检查当前节点是否在 `Set` 中出现过,第一个在 `Set` 出现过的节点即是交点。\n\n代码:\n```Java\npublic class Solution {\n    public ListNode getIntersectionNode(ListNode a, ListNode b) {\n        Set<ListNode> set = new HashSet<>();\n        while (a != null) {\n            set.add(a);\n            a = a.next;\n        }\n        while (b != null && !set.contains(b)) b = b.next;\n        return b;\n    }\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 差值法\n\n由于两条链表在相交节点后面的部分完全相同,因此我们可以先对两条链表进行遍历,分别得到两条链表的长度,并计算差值 `d`。\n\n让长度较长的链表先走 `d` 步,然后两条链表同时走,第一个相同的节点即是节点。\n\n代码:\n```Java\npublic class Solution {\n    public ListNode getIntersectionNode(ListNode a, ListNode b) {\n        int c1 = 0, c2 = 0;\n        ListNode ta = a, tb = b;\n        while (ta != null && c1++ >= 0) ta = ta.next;\n        while (tb != null && c2++ >= 0) tb = tb.next;\n        int d = c1 - c2;\n        if (d > 0) {\n            while (d-- > 0) a = a.next;\n        } else if (d < 0) {\n            d = -d;\n            while (d-- > 0) b = b.next;\n        }\n        while (a != b) {\n            a = a.next;\n            b = b.next;\n        }\n        return a;\n    }\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 等值法\n\n这是「差值法」的另外一种实现形式,原理同样利用「两条链表在相交节点后面的部分完全相同」。\n\n我们令第一条链表相交节点之前的长度为 `a`,第二条链表相交节点之前的长度为 `b`,相交节点后的公共长度为 `c`(注意 `c` 可能为 $0$,即不存在相交节点)。\n\n分别对两条链表进行遍历:\n* 当第一条链表遍历完,移动到第二条链表的头部进行遍历;\n* 当第二条链表遍历完,移动到第一条链表的头部进行遍历。\n\n如果存在交点:**第一条链表首次到达「第一个相交节点」的充要条件是第一条链表走了 $a + c + b$ 步,由于两条链表同时出发,并且步长相等,因此当第一条链表走了 $a + c + b$ 步时,第二条链表同样也是走了 $a + c + b$ 步,即 第二条同样停在「第一个相交节点」的位置。**\n\n如果不存在交点:**两者会在走完 $a + c + b + c$ 之后同时变为 $null$,退出循环。**\n\n代码:\n```Java\npublic class Solution {\n    public ListNode getIntersectionNode(ListNode a, ListNode b) {\n        ListNode ta = a, tb = b;\n        while (ta != tb) {\n            ta = ta == null ? b : ta.next;\n            tb = tb == null ? a : tb.next;\n        }\n        return ta;\n    }\n}\n```\n* 时间复杂度:$O(n + m)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 52` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 53 - I. 在排序数组中查找数字 I（简单）.md", "url_title": "剑指 Offer 53 - I. 在排序数组中查找数字 I", "url": "https://leetcode-cn.com/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof/solution/gong-shui-san-xie-liang-chong-er-fen-ton-3epx/", "difficulty": "简单", "tags": ["二分"], "question": "统计一个数字在排序数组中出现的次数。\n\n示例 1:\n```\n输入: nums = [5,7,7,8,8,10], target = 8\n\n输出: 2\n```\n示例 2:\n```\n输入: nums = [5,7,7,8,8,10], target = 6\n\n输出: 0\n```\n\n限制:\n* 0 <= 数组长度 <= 50000", "solution": "### 二分单边 + 线性扫描\n\n一个朴素的想法是,找到目标值 $target$ 「首次」出现或者「最后」出现的下标,然后「往后」或者「往前」进行数量统计。\n\n代码:\n```Java\n// 找到目标值「最后」出现的分割点,并「往前」进行统计\nclass Solution {\n    public int search(int[] nums, int t) {\n        int n = nums.length;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (nums[mid] <= t) l = mid;\n            else r = mid - 1;\n        }\n        int ans = 0;\n        while (r >= 0 && nums[r] == t && r-- >= 0) ans++;\n        return ans;\n    }\n}\n```\n```Java\n// 找到目标值「首次」出现的分割点,并「往后」进行统计\nclass Solution {\n    public int search(int[] nums, int t) {\n        int n = nums.length;\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (nums[mid] >= t) r = mid;\n            else l = mid + 1;\n        }\n        int ans = 0;\n        while (l < n && nums[l] == t && l++ >= 0) ans++;\n        return ans;\n    }\n}\n```\n* 时间复杂度:二分找到分割点之后,需要往前或者往后进行扫描。复杂度为 $O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 二分两边\n\n进一步,我们可以直接经过两次「二分」找到左右边界,计算总长度即是 $target$ 的数量。\n\n代码:\n```Java\nclass Solution {\n    public int search(int[] nums, int t) {\n        int n = nums.length;\n        if (n == 0) return 0;\n        int a = -1, b = -1;\n\n        // 二分出左边界\n        int l = 0, r = n - 1;\n        while (l < r) {\n            int mid = l + r >> 1;\n            if (nums[mid] >= t) r = mid;\n            else l = mid + 1;\n        }\n        if (nums[r] != t) return 0;\n        a = r;\n\n        // 二分出右边界\n        l = 0; r = n - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (nums[mid] <= t) l = mid;\n            else r = mid - 1;\n        }\n        if (nums[r] != t) return 0;\n        b = r;\n\n        return b - a + 1;\n    }\n}\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 53 - I` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 53 - II. 0～n-1中缺失的数字（简单）.md", "url_title": "剑指 Offer 53 - II. 0~n-1中缺失的数字", "url": "https://leetcode.cn/problems/que-shi-de-shu-zi-lcof/solution/by-ac_oier-gs6q/", "difficulty": "简单", "tags": ["二分"], "question": "一个长度为 $n-1$ 的递增排序数组中的所有数字都是唯一的,并且每个数字都在范围 $[0, n-1]$ 之内。\n\n在范围 $[0, n-1]$ 内的 $n$ 个数字中有且只有一个数字不在该数组中,请找出这个数字。\n\n示例 1:\n```\n输入: [0,1,3]\n\n输出: 2\n```\n示例 2:\n```\n输入: [0,1,2,3,4,5,6,7,9]\n\n输出: 8\n```\n\n限制:\n* $1 <= 数组长度 <= 10000$", "solution": "### 二分\n\n强调过无数次,二分的本质是「二段性」。\n\n我们可以考虑对于一个给定数组 `nums` 中,对于缺失元素左右数值而言,有何性质。\n\n假设我们缺失的元素数值为 `x`,那么对于 `x` 左边的元素(若有)必然是完整且连续的,也就是其必然满足 `nums[i] = i`,而其右边的元素(若有)必然由于 `x` 的缺失,导致必然不满足 `nums[i] = i`,因此在以缺失元素为分割点的数轴上,具有二段性,我们可以使用「二分」来找该分割点。\n\n同时由于缺失元素可能是 $[0, n - 1]$ 范围内的最大值,因此我们需要二分结束后再 `check` 一次,若不满足,说明缺失的元素值为 $n - 1$。\n\nJava 代码:\n```Java\nclass Solution {\n    public int missingNumber(int[] nums) {\n        int l = 0, r = nums.length - 1;\n        while (l < r) {\n            int mid = l + r + 1 >> 1;\n            if (nums[mid] == mid) l = mid;\n            else r = mid - 1;\n        }\n        return nums[r] != r ? r : r + 1;\n    }\n}\n```\nTypescript 代码:\n```Typescript\nfunction missingNumber(nums: number[]): number {\n    let l = 0, r = nums.length - 1\n    while (l < r) {\n        const mid = l + r + 1 >> 1\n        if (nums[mid] == mid) l = mid\n        else r = mid - 1\n    }\n    return nums[r] != r ? r : r + 1\n};\n```\n* 时间复杂度:$O(\\log{n})$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 53 - II` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/剑指 Offer/剑指 Offer 59 - I. 滑动窗口的最大值（困难）.md", "url_title": "剑指 Offer 59 - I. 滑动窗口的最大值", "url": "https://leetcode.cn/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof/solution/by-ac_oier-sjym/", "difficulty": "困难", "tags": ["优先队列(堆)", "线段树", "分块", "单调队列", "RMQ"], "question": "给你一个整数数组 `nums`,有一个大小为 `k` 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 `k` 个数字。滑动窗口每次只向右移动一位。\n\n返回滑动窗口中的最大值 。\n\n示例 1:\n```\n输入:nums = [1,3,-1,-3,5,3,6,7], k = 3\n\n输出:[3,3,5,5,6,7]\n\n解释:\n滑动窗口的位置                最大值\n---------------               -----\n[1  3  -1] -3  5  3  6  7       3\n 1 [3  -1  -3] 5  3  6  7       3\n 1  3 [-1  -3  5] 3  6  7       5\n 1  3  -1 [-3  5  3] 6  7       5\n 1  3  -1  -3 [5  3  6] 7       6\n 1  3  -1  -3  5 [3  6  7]      7\n```\n示例 2:\n```\n输入:nums = [1], k = 1\n\n输出:[1]\n```\n\n提示:\n* $1 <= nums.length <= 10^5$\n* $-10^4 <= nums[i] <= 10^4$\n* $1 <= k <= nums.length$", "solution": "### 优先队列(堆)\n\n根据题意,容易想到优先队列(大根堆),同时为了确保滑动窗口的大小合法性,我们以二元组 $(idx, nums[idx])$ 的形式进行入队。\n\n当下标达到首个滑动窗口的右端点后,每次尝试从优先队列(大根堆)中取出最大值(若堆顶元素的下标小于当前滑动窗口左端点时,则丢弃该元素)。\n\n代码:\n```Java \nclass Solution {\n    public int[] maxSlidingWindow(int[] nums, int k) {\n        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->b[1]-a[1]);\n        int n = nums.length, m = n - k + 1, idx = 0;\n        int[] ans = new int[m];\n        for (int i = 0; i < n; i++) {\n            q.add(new int[]{i, nums[i]});\n            if (i >= k - 1) {\n                while (q.peek()[0] <= i - k) q.poll();\n                ans[idx++] = q.peek()[1];\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 线段树 \n\n容易将问题转换为「区间求和」问题:使用原始的 `nums` 构建线段树等价于在位置 $i$ 插入 $nums[i]$,即单点操作,而查询每个滑动窗口最大值,则对应的区间查询。\n\n由于只涉及单点修改,无须实现懒标记 `pushdown` 操作,再结合 $n$ 的数据范围为 $10^5$,无须进行动态开点。\n\n直接写 `build` 四倍空间的线段树数组实现即可。\n\n代码:\n```Java \nclass Solution {\n    class Node {\n        int l, r, val;\n        Node (int _l, int _r) {\n            l = _l; r = _r; val = Integer.MIN_VALUE;\n        }\n    }\n    Node[] tr = new Node[100010 * 4];\n    void build(int u, int l, int r) {\n        tr[u] = new Node(l, r);\n        if (l == r) return ;\n        int mid = l + r >> 1;\n        build(u << 1, l, mid);\n        build(u << 1 | 1, mid + 1, r);\n    }\n    void update(int u, int x, int v) {\n        if (tr[u].l == x && tr[u].r == x) {\n            tr[u].val = Math.max(tr[u].val, v);\n            return ;\n        }\n        int mid = tr[u].l + tr[u].r >> 1;\n        if (x <= mid) update(u << 1, x, v);\n        else update(u << 1 | 1, x, v);\n        pushup(u);\n    }\n    int query(int u, int l, int r) {\n        if (l <= tr[u].l && tr[u].r <= r) return tr[u].val;\n        int mid = tr[u].l + tr[u].r >> 1, ans = Integer.MIN_VALUE;\n        if (l <= mid) ans = query(u << 1, l, r);\n        if (r > mid) ans = Math.max(ans, query(u << 1 | 1, l, r));\n        return ans;\n    }\n    void pushup(int u) {\n        tr[u].val = Math.max(tr[u << 1].val, tr[u << 1 | 1].val);\n    }\n    public int[] maxSlidingWindow(int[] nums, int k) {\n        int n = nums.length, m = n - k + 1;\n        int[] ans = new int[m];\n        build(1, 1, n);\n        for (int i = 0; i < n; i++) update(1, i + 1, nums[i]);\n        for (int i = k; i <= n; i++) ans[i - k] = query(1, i - k + 1, i);\n        return ans;\n    }\n}\n```\n* 时间复杂度:建立线段树复杂度为 $O(n\\log{n})$;构建答案复杂度为 $O(n\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n)$\n\n---\n\n### 分块\n\n另外一个做法是分块,又名「优雅的暴力」,也是莫队算法的基础。\n\n具体的,除了给定的 `nums` 以外,我们构建一个分块数组 `region`,其中 `region[idx] = x` 含义为块编号为 `idx` 的最大值为 `x`,其中一个块对应一个原始区间 $[l, r]$。\n\n如何定义块大小是实现分块算法的关键。\n\n对于本题,本质是求若干个大小为 $k$ 的区间最大值。\n\n我们可以设定块大小为 $\\sqrt{k}$,这样所需创建的分块数组大小为 $\\frac{n}{\\sqrt{k}}$。分块数组的更新操作为 $O(1)$,而查询则为 $\\sqrt{k}$。\n\n容易证明查询操作的复杂度:对于每个长度为 $k$ 的 $[l, r]$ 查询操作而言,最多遍历两个(左右端点对应的块)的块内元素,复杂度为 $O(\\sqrt{k})$,同时最多遍历 $\\sqrt{k}$ 个块,复杂度同为 $O(\\sqrt{k})$。\n\n因此最多两步复杂度为 $O(\\sqrt{k})$ 的块内操作,最多 $\\sqrt{k}$ 步复杂度为 $O(1)$ 的块间操作,整体复杂度为 $O(\\sqrt{k})$。\n\n因此使用分块算法总的计算量为 $n\\times\\sqrt{k} = 10^6$,可以过。\n\n分块算法的几个操作函数:\n\n* `int getIdx(int x)` :计算原始下标对应的块编号;\n* `void add(int x, int v)` :计算原始下标 `x` 对应的下标 `idx`,并将 `region[idx]` 和 `v` 取 `max` 来更新 `region[idx]`;\n* `int query(int l, int r)` :查询 $[l, r]$ 中的最大值,如果 $l$ 和 $r$ 所在块相同,直接遍历 $[l, r]$ 进行取值;若 $l$ 和 $r$ 不同块,则处理 $l$ 和 $r$ 对应的块内元素后,对块编号在 $(getIdx(l), getIdx(r))$ 之间的块进行遍历。\n\n代码:\n```Java \nclass Solution {\n    int n, m, len;\n    int[] nums, region;\n    int getIdx(int x) {\n        return x / len;\n    }\n    void add(int x, int v) {\n        region[getIdx(x)] = Math.max(region[getIdx(x)], v);\n    }\n    int query(int l, int r) {\n        int ans = Integer.MIN_VALUE;\n        if (getIdx(l) == getIdx(r)) {\n            for (int i = l; i <= r; i++) ans = Math.max(ans, nums[i]);\n        } else {\n            int i = l, j = r;\n            while (getIdx(i) == getIdx(l)) ans = Math.max(ans, nums[i++]);\n            while (getIdx(j) == getIdx(r)) ans = Math.max(ans, nums[j--]);\n            for (int k = getIdx(i); k <= getIdx(j); k++) ans = Math.max(ans, region[k]);\n        }\n        return ans;\n    }\n    public int[] maxSlidingWindow(int[] _nums, int k) {\n        nums = _nums;\n        n = nums.length; len = (int) Math.sqrt(k); m = n / len + 10;\n        region = new int[m];\n        Arrays.fill(region, Integer.MIN_VALUE);\n        for (int i = 0; i < n; i++) add(i, nums[i]);\n        int[] ans = new int[n - k + 1];\n        for (int i = 0; i < n - k + 1; i++) ans[i] = query(i, i + k - 1);\n        return ans;\n    }\n}\n```\n* 时间复杂度:数组大小为 $n$,块大小为 $\\sqrt{k}$,分块数组大小为 $\\frac{n}{\\sqrt{k}}$。预处理分块数组复杂度为 $O(n)$(即 `add` 操作复杂度为 $O(1)$ );构造答案复杂度为 $O(n\\times\\sqrt{k})$(即 `query` 操作复杂度为 $O(\\sqrt{k})$,最多有 $n$ 次查询)\n* 空间复杂度:$\\frac{n}{\\sqrt{k}}$\n\n---\n\n### 单调队列\n\n关于 `RMQ` 的另外一个优秀做法通常是使用「单调队列/单调栈」。\n\n当然,我们也能不依靠经验,而从问题的本身出发,逐步分析出该做法。\n\n假设我们当前处理到某个长度为 $k$ 的窗口,此时窗口往后滑动一格,会导致后一个数(新窗口的右端点)添加进来,同时会导致前一个数(旧窗口的左端点)移出窗口。\n\n随着窗口的不断平移,该过程会一直发生。**若同一时刻存在两个数 $nums[j]$ 和 $nums[i]$($j < i$)所在一个窗口内,下标更大的数会被更晚移出窗口,此时如果有 $nums[j] <= nums[i]$ 的话,可以完全确定 $nums[j]$ 将不会成为后续任何一个窗口的最大值,此时可以将必然不会是答案的 $nums[j]$ 从候选中进行移除**。\n\n不难发现,当我们将所有必然不可能作为答案的元素(即所有满足的小于等于 $nums[i]$ )移除后,候选集合满足「单调递减」特性,即集合首位元素为当前窗口中的最大值(为了满足窗口长度为 $k$ 的要求,在从集合头部取答案时需要先将下标小于的等于的 $i - k$ 的元素移除)。\n\n为方便从尾部添加元素,从头部获取答案,我们可使用「双端队列」存储所有候选元素。\n\n代码:\n```Java \nclass Solution {\n    public int[] maxSlidingWindow(int[] nums, int k) {\n        Deque<Integer> d = new ArrayDeque<>();\n        int n = nums.length, m = n - k + 1;\n        int[] ans = new int[m];\n        for (int i = 0; i < n; i++) {\n            while (!d.isEmpty() && nums[d.peekLast()] <= nums[i]) d.pollLast();\n            d.addLast(i);\n            if (i >= k - 1) {\n                while (!d.isEmpty() && d.peekFirst() <= i - k) d.pollFirst();\n                ans[i - k + 1] = nums[d.peekFirst()];\n            }\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 59 - I` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/面试题/面试题 01.02. 判定是否互为字符重排（简单）.md", "url_title": "面试题 01.02. 判定是否互为字符重排", "url": "https://leetcode.cn/problems/check-permutation-lcci/solution/by-ac_oier-qj3j/", "difficulty": "简单", "tags": ["模拟"], "question": "给定两个字符串 `s1` 和 `s2`,请编写一个程序,确定其中一个字符串的字符重新排列后,能否变成另一个字符串。\n\n示例 1:\n```\n输入: s1 = \"abc\", s2 = \"bca\"\n\n输出: true \n```\n示例 2:\n```\n输入: s1 = \"abc\", s2 = \"bad\"\n\n输出: false\n```\n\n说明:\n* $0 <= len(s1) <= 100$\n* $0 <= len(s2) <= 100$", "solution": "### 模拟\n\n根据题意,对两字符串进行词频统计,统计过程中使用变量 `tot` 记录词频不同的字符个数。\n\nJava 代码:\n```Java\nclass Solution {\n    public boolean CheckPermutation(String s1, String s2) {\n        int n = s1.length(), m = s2.length(), tot = 0;\n        if (n != m) return false;\n        int[] cnts = new int[128];\n        for (int i = 0; i < n; i++) {\n            if (++cnts[s1.charAt(i)] == 1) tot++;\n            if (--cnts[s2.charAt(i)] == 0) tot--;\n        }\n        return tot == 0;\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction CheckPermutation(s1: string, s2: string): boolean {\n    let n = s1.length, m = s2.length, tot = 0\n    if (n != m) return false\n    const cnts = new Array<number>(128).fill(0)\n    for (let i = 0; i < n; i++) {\n        if (++cnts[s1.charCodeAt(i)] == 1) tot++\n        if (--cnts[s2.charCodeAt(i)] == 0) tot--\n    }\n    return tot == 0\n};\n```\nPython3 代码:\n```Python3\nclass Solution:\n    def CheckPermutation(self, s1: str, s2: str) -> bool:\n        return Counter(s1) == Counter(s2)\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(C)$,其中 $C = 128$ 为字符集大小", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 01.02` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/面试题/面试题 01.05. 一次编辑（中等）.md", "url_title": "面试题 01.05. 一次编辑", "url": "https://leetcode.cn/problems/one-away-lcci/solution/by-ac_oier-7ml0/", "difficulty": "中等", "tags": ["模拟", "双指针"], "question": "字符串有三种编辑操作:插入一个字符、删除一个字符或者替换一个字符。 给定两个字符串,编写一个函数判定它们是否只需要一次(或者零次)编辑。\n\n示例 1:\n```\n输入: \nfirst = \"pale\"\nsecond = \"ple\"\n\n输出: True\n```\n示例 2:\n```\n输入: \nfirst = \"pales\"\nsecond = \"pal\"\n\n输出: False\n```", "solution": "### 双指针模拟\n\n为了方便,我们令 $a = first$、$b = second$,两者长度为 $n$ 和 $m$,并让 $a$ 为两种中的长度较短的那个(若 $b$ 较短,则将两者交换)。\n\n接下来是简单的双指针处理(使用 $cnt$ 记录操作次数):\n\n1. 我们最多使用不超过一次的操作,因此如果 $\\left | n - m \\right | > 1$,直接返回 `False`;\n2. 若两者长度差不超过 $1$,使用 $i$ 和 $j$ 分别指向两字符的最左侧进行诸位检查:\n    * 若 $a[i] = b[j]$,让 $i$ 和 $j$ 继续后移进行检查;\n    * 若 $a[i] \\neq b[j]$,根据两字符串长度进行分情况讨论:\n        * 若 $n = m$,说明此时只能通过「替换」操作消除不同,分别让 $i$ 和 $j$ 后移,并对 $cnt$ 进行加一操作;\n        * 若 $n \\neq m$,由于我们人为确保了 $a$ 更短,即此时是 $n < m$,此时只能通过对 $a$ 字符串进行「添加」操作来消除不同,此时让 $j$ 后移,$i$ 不动(含义为在 $a$ 字符串中的 $i$ 位置增加一个 $b[j]$ 字符),并对 $cnt$ 进行加一操作。\n\n最终我们根据 $cnt$ 是否不超过 $1$ 来返回结果。\n\n代码:\n```Java\nclass Solution {\n    public boolean oneEditAway(String a, String b) {\n        int n = a.length(), m = b.length();\n        if (Math.abs(n - m) > 1) return false;\n        if (n > m) return oneEditAway(b, a);\n        int i = 0, j = 0, cnt = 0;\n        while (i < n && j < m && cnt <= 1) {\n            char c1 = a.charAt(i), c2 = b.charAt(j);\n            if (c1 == c2) {\n                i++; j++;\n            } else {\n                if (n == m) {\n                    i++; j++; cnt++;\n                } else {\n                    j++; cnt++;\n                }\n            }\n        }\n        return cnt <= 1;\n    }\n}\n```\n* 时间复杂度:令 $n$ 和 $m$ 分别为两字符串长度,复杂度为 $O(\\max(n, m))$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 01.05` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/面试题/面试题 01.08. 零矩阵（中等）.md", "url_title": "面试题 01.08. 零矩阵", "url": "https://leetcode.cn/problems/zero-matrix-lcci/solution/by-ac_oier-0lo0/", "difficulty": "中等", "tags": ["模拟"], "question": "编写一种算法,若 $M \\times N$ 矩阵中某个元素为 $0$,则将其所在的行与列清零。\n\n示例 1:\n```\n输入:\n[\n  [1,1,1],\n  [1,0,1],\n  [1,1,1]\n]\n\n输出:\n[\n  [1,0,1],\n  [0,0,0],\n  [1,0,1]\n]\n```\n示例 2:\n```\n输入:\n[\n  [0,1,2,0],\n  [3,4,5,2],\n  [1,3,1,5]\n]\n\n输出:\n[\n  [0,0,0,0],\n  [0,4,5,0],\n  [0,3,1,0]\n]\n```", "solution": "### 模拟\n\n根据题意进行模拟。\n\nJava 代码:\n```Java\nclass Solution {\n    public void setZeroes(int[][] mat) {\n        int n = mat.length, m = mat[0].length;\n        boolean[] rows = new boolean[n], cols = new boolean[m];\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                if (mat[i][j] == 0) rows[i] = cols[j] = true;\n            }\n        }\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                if (rows[i] || cols[j]) mat[i][j] = 0;\n            }\n        }\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction setZeroes(mat: number[][]): void {\n    const n = mat.length, m = mat[0].length\n    const rows = new Array<boolean>(n).fill(false), cols = new Array<boolean>(m).fill(false)\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < m; j++) {\n            if (mat[i][j] == 0) rows[i] = cols[j] = true\n        }\n    }\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < m; j++) {\n            if (rows[i] || cols[j]) mat[i][j] = 0\n        }\n    }\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def setZeroes(self, mat: List[List[int]]) -> None:\n        n, m = len(mat), len(mat[0])\n        rows, cols = [False] * n, [False] * m\n        for i in range(n):\n            for j in range(m):\n                if mat[i][j] == 0:\n                    rows[i] = cols[j] = True\n        for i in range(n):\n            for j in range(m):\n                mat[i][j] = 0 if rows[i] or cols[j] else mat[i][j]\n```\n* 时间复杂度:$O(n \\times m)$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 01.08` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/面试题/面试题 01.09. 字符串轮转（简单）.md", "url_title": "面试题 01.09. 字符串轮转", "url": "https://leetcode.cn/problems/string-rotation-lcci/solution/by-ac_oier-2wo1/", "difficulty": "简单", "tags": ["字符串哈希"], "question": "字符串轮转。给定两个字符串 `s1` 和 `s2`,请编写代码检查 `s2` 是否为 `s1` 旋转而成(比如,`waterbottle` 是 `erbottlewat` 旋转后的字符串)。\n\n示例1:\n```\n输入:s1 = \"waterbottle\", s2 = \"erbottlewat\"\n\n输出:True\n```\n示例2:\n```\n输入:s1 = \"aa\", s2 = \"aba\"\n\n输出:False\n```\n提示:\n* 字符串长度在 $[0, 100000]$ 范围内。\n\n说明:\n你能只调用一次检查子串的方法吗?", "solution": "### 字符串哈希\n\n若两字符串互为旋转,则「其一字符串」必然为「另一字符串拓展两倍长度后(循环子串)」的子串。\n\n基于此,我们可以使用「字符串哈希」进行求解:先计算 `s2` 的字符串哈希值 `t`,然后构造出 `s1 + s1` 的哈希数组和次方数组,在两数组中检查是否存在长度为 $n$ 的连续子段的哈希值 `cur` 与 `t` 相等。\n\n**不了解字符串哈希的同学可以看前置🧀 : [字符串哈希入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489813&idx=1&sn=7f3bc18ca390d85b17655f7164d8e660)**\n\n> 一些细节:其他语言可能不像 `Java` 那样存在自然取模,可手动取模,对于自带高精度的语言若不取模会导致单次计算复杂度上升,会 `TLE`。\n\nJava 代码:\n```Java\nclass Solution {\n    static int N = 200010, P = 13131;\n    static int[] h = new int[N], p = new int[N];\n    public boolean isFlipedString(String s1, String s2) {\n        if (s1.length() != s2.length()) return false;\n        int n = s1.length();\n        for (int i = 1; i <= n; i++) h[i] = h[i - 1] * P + s2.charAt(i - 1);\n        int t = h[n]; // s2 hash\n        s1 = s1 + s1;\n        p[0] = 1;\n        for (int i = 1; i <= 2 * n; i++) {\n            h[i] = h[i - 1] * P + s1.charAt(i - 1);\n            p[i] = p[i - 1] * P;\n        }\n        for (int i = 1; i + n - 1 <= 2 * n; i++) {\n            int j = i + n - 1, cur = h[j] - h[i - 1] * p[j - i + 1];\n            if (cur == t) return true;\n        }\n        return false;\n    }\n}\n```\nPython 代码:\n```Python\nN, P, MOD = 200010, 13131, 987654321\nh, p = [0] * N, [1] * N\nclass Solution:\n    def isFlipedString(self, s1: str, s2: str) -> bool:\n        if len(s1) != len(s2):\n            return False\n        if s1 == s2:\n            return True\n        n = len(s1)\n        for i in range(1, n + 1):\n            h[i] = (h[i - 1] * P + ord(s2[i - 1])) % MOD\n        t = h[n]\n        s1 = s1 + s1\n        for i in range(1, 2 * n + 1):\n            h[i] = (h[i - 1] * P + ord(s1[i - 1])) % MOD\n            p[i] = (p[i - 1] * P) % MOD\n        for i in range(1, n + 1):\n            j = i + n - 1\n            cur = (h[j] - h[i - 1] * p[j - i + 1]) % MOD\n            if cur == t:\n                return True\n        return False\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 01.09` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/面试题/面试题 02.05. 链表求和（中等）.md", "url_title": "面试题 02.05. 链表求和", "url": "https://leetcode-cn.com/problems/sum-lists-lcci/solution/by-ac_oier-v1zb/", "difficulty": "中等", "tags": ["链表", "模拟"], "question": "给定两个用链表表示的整数,每个节点包含一个数位。\n\n这些数位是反向存放的,也就是个位排在链表首部。\n\n编写函数对这两个整数求和,并用链表形式返回结果。\n\n示例:\n```\n输入:(7 -> 1 -> 6) + (5 -> 9 -> 2),即617 + 295\n\n输出:2 -> 1 -> 9,即912\n```\n\n示例:\n```\n输入:(6 -> 1 -> 7) + (2 -> 9 -> 5),即617 + 295\n\n输出:9 -> 1 -> 2,即912\n```\n\n进阶:思考一下,假设这些数位是正向存放的,又该如何解决呢?", "solution": "### 链表(反向)\n\n访问链表节点的顺序为「个位、百位、千位 ...」,即与执行「竖式加法」时访问的位数次序一致。\n\n因此我们可以边遍历,边模拟「竖式加法」的过程,使用变量 $t$ 存储进位情况,当 $l1$ 和 $l2$ 没遍历完,或者进位 $t$ 不为 $0$,该计算过程就可以继续,每次使用当前计算结果 `t % 10` 来创建新节点,使用 `t / 10` 来更新进位。\n\n代码:\n```Java \nclass Solution {\n    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {\n        ListNode ans = new ListNode(-1), temp = ans;\n        int t = 0;\n        while (l1 != null || l2 != null || t != 0) {\n            if (l1 != null) {\n                t += l1.val;\n                l1 = l1.next;\n            }\n            if (l2 != null) {\n                t += l2.val;\n                l2 = l2.next;\n            }\n            temp.next = new ListNode(t % 10);\n            temp = temp.next;\n            t /= 10;\n        }\n        return ans.next;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为链表 `l1` 的长度,$m$ 为链表 `l2` 的长度,复杂度为 $O(\\max(n, m))$\n* 空间复杂度:$O(1)$\n\n---\n\n### 链表(正向)\n\n如果将链表翻转(先访问到的是数值高位),该如何处理?\n\n由于我们的「竖式加法」是从低位开始,因此我们需要先使用数据结构(栈 / 数组)对链表元素进行存储,再实现「从低位访问」并进行「竖式加法」的模拟过程。\n\n为了验证代码正确性,我们可以先对 `l1` 和 `l2` 进行翻转,再走链表(正向)的处理逻辑。\n\n代码:\n```Java\nclass Solution {\n    ListNode reverse(ListNode node) {\n        ListNode prev = null, cur = node;\n        while (cur != null) {\n            ListNode temp = cur.next;\n            cur.next = prev;\n            prev = cur; cur = temp;\n        }\n        return prev;\n    }\n    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {\n        l1 = reverse(l1);\n        l2 = reverse(l2);\n\n        Deque<Integer> d1 = new ArrayDeque<>(), d2 = new ArrayDeque<>();\n        while (l1 != null) {\n            d1.addLast(l1.val);\n            l1 = l1.next;\n        }\n        while (l2 != null) {\n            d2.addLast(l2.val);\n            l2 = l2.next;\n        }\n        ListNode ans = new ListNode(-1), temp = ans;\n        int t = 0;\n        while (!d1.isEmpty() || !d2.isEmpty() || t != 0) {\n            if (!d1.isEmpty()) t += d1.pollLast();\n            if (!d2.isEmpty()) t += d2.pollLast();\n            temp.next = new ListNode(t % 10);\n            temp = temp.next;\n            t /= 10;\n        }\n        return ans.next;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为链表 `l1` 的长度,$m$ 为链表 `l2` 的长度,复杂度为 $O(\\max(n, m))$\n* 空间复杂度:$O(n + m)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `面试题 02.05. 链表求和` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/面试题/面试题 03.01. 三合一（简单）.md", "url_title": "面试题 03.01. 三合一", "url": "https://leetcode-cn.com/problems/three-in-one-lcci/solution/yi-ti-shuang-jie-er-wei-shu-zu-yi-wei-sh-lih7/", "difficulty": "简单", "tags": ["栈"], "question": "三合一。描述如何只用一个数组来实现三个栈。\n\n你应该实现push(stackNum, value)、pop(stackNum)、isEmpty(stackNum)、peek(stackNum)方法。stackNum表示栈下标,value表示压入的值。\n\n构造函数会传入一个stackSize参数,代表每个栈的大小。\n\n示例1:\n```\n 输入:\n[\"TripleInOne\", \"push\", \"push\", \"pop\", \"pop\", \"pop\", \"isEmpty\"]\n[[1], [0, 1], [0, 2], [0], [0], [0], [0]]\n 输出:\n[null, null, null, 1, -1, -1, true]\n说明:当栈为空时`pop, peek`返回-1,当栈满时`push`不压入元素。\n```\n示例2:\n```\n 输入:\n[\"TripleInOne\", \"push\", \"push\", \"push\", \"pop\", \"pop\", \"pop\", \"peek\"]\n[[2], [0, 1], [0, 2], [0, 3], [0], [0], [0], [0]]\n 输出:\n[null, null, null, null, 2, 1, -1, -1]\n```", "solution": "### 二维数组\n\n题目只要求我们使用「一个数组」来实现栈,并没有限制我们使用数组的维度。\n\n因此一个简单的做法是,建立一个二维数组 $data$ 来做。\n\n二维数组的每一行代表一个栈,同时使用一个 $locations$ 记录每个栈「待插入」的下标。\n\n代码:\n```java\nclass TripleInOne {\n    int N = 3;\n    // 3 * n 的数组,每一行代表一个栈\n    int[][] data; \n    // 记录每个栈「待插入」位置\n    int[] locations; \n\n    public TripleInOne(int stackSize) {\n        data = new int[N][stackSize];\n        locations = new int[N];\n    }\n    \n    public void push(int stackNum, int value) {\n        int[] stk = data[stackNum];\n        int loc = locations[stackNum];\n        if (loc < stk.length) {\n            stk[loc] = value;\n            locations[stackNum]++;\n        }\n    }\n    \n    public int pop(int stackNum) {\n        int[] stk = data[stackNum];\n        int loc = locations[stackNum];\n        if (loc > 0) {\n            int val = stk[loc - 1];\n            locations[stackNum]--;\n            return val;\n        } else {\n            return -1;\n        }\n    }\n    \n    public int peek(int stackNum) {\n        int[] stk = data[stackNum];\n        int loc = locations[stackNum];\n        if (loc > 0) {\n            return stk[loc - 1];\n        } else {\n            return -1;\n        }\n    }\n    \n    public boolean isEmpty(int stackNum) {\n        return locations[stackNum] == 0;\n    }\n}\n```\n* 时间复杂度:所有的操作均为 $O(1)$。\n* 空间复杂度:$O(k * n)$。k 为我们需要实现的栈的个数,n 为栈的容量。\n\n***\n\n### 一维数组\n\n当然了,我们也能使用一个一维数组来做。\n\n建立一个长度为 $3 * stackSize$ 的数组,并将 3 个栈的「待插入」存储在 $locations$ 数组。\n\n代码:\n```java\nclass TripleInOne {\n    int N = 3;\n    int[] data;\n    int[] locations;\n    int size;\n    public TripleInOne(int stackSize) {\n        size = stackSize;\n        data = new int[size * N];\n        locations = new int[N];\n        for (int i = 0; i < N; i++) {\n            locations[i] = i * size;\n        }\n    }\n    \n    public void push(int stackNum, int value) {\n        int idx = locations[stackNum];\n        if (idx < (stackNum + 1) * size) {\n            data[idx] = value;\n            locations[stackNum]++;\n        }\n    }\n    \n    public int pop(int stackNum) {\n        int idx = locations[stackNum];\n        if (idx > stackNum * size) {\n            locations[stackNum]--;\n            return data[idx - 1];\n        } else {\n            return -1;\n        }\n    }\n    \n    public int peek(int stackNum) {\n        int idx = locations[stackNum];\n        if (idx > stackNum * size) {\n            return data[idx - 1];\n        } else {\n            return -1;\n        }\n    }\n    \n    public boolean isEmpty(int stackNum) {\n        return locations[stackNum] == stackNum * size;\n    }\n}\n```\n* 时间复杂度:所有的操作均为 $O(1)$。\n* 空间复杂度:$O(k * n)$。k 为我们需要实现的栈的个数,n 为栈的容量。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `面试题 03.01. 三合一` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/面试题/面试题 04.06. 后继者（中等）.md", "url_title": "面试题 04.06. 后继者", "url": "https://leetcode.cn/problems/successor-lcci/solution/by-ac_oier-xib5/", "difficulty": "中等", "tags": ["BST", "递归"], "question": "设计一个算法,找出二叉搜索树中指定节点的 “下一个” 节点(也即中序后继)。\n\n如果指定节点没有对应的 “下一个” 节点,则返回 `null`。\n\n示例 1:\n```\n输入: root = [2,1,3], p = 1\n\n  2\n / \\\n1   3\n\n输出: 2\n```\n示例 2:\n```\n输入: root = [5,3,6,2,4,null,null,1], p = 6\n\n      5\n     / \\\n    3   6\n   / \\\n  2   4\n /   \n1\n\n输出: null\n```", "solution": "### BST 特性 + 递归\n\n利用 `BST` 的特性,我们可以根据当前节点 `root` 与 `p` 的值大小关系来确定搜索方向:\n\n1. 若有 `root.val <= p.val` : 根据 `BST` 特性可知当前节点 `root` 及其左子树子节点均满足「值小于等于 `p.val`」,因此不可能是 `p` 点的后继,我们直接到 `root` 的右子树搜索 `p` 的后继(递归处理);\n2. 若有 `root.val > p.val` : 当第一次搜索到满足此条件的节点时,在以 `root` 为根节点的子树中「位于最左下方」的值为 `p` 的后继,但也有可能 `root` 没有左子树,因此 `p` 的后继要么在 `root` 的左子树中(若有),要么是 `root` 本身,此时我们可以直接到 `root` 的左子树搜索,若搜索结果为空返回 `root`,否则返回搜索结果。\n\n代码:\n```Java\nclass Solution {\n    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {\n        if (root == null) return null;\n        if (root.val <= p.val) return inorderSuccessor(root.right, p);\n        TreeNode ans = inorderSuccessor(root.left, p);\n        return ans == null ? root : ans;\n    }\n}\n```\n* 时间复杂度:复杂度与深度相关,最坏情况下仍会搜索所有节点,复杂度为 $O(n)$\n* 空间复杂度:忽略递归带来的额外空间消耗,复杂度为 $O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 04.06` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/面试题/面试题 10.02. 变位词组（中等）.md", "url_title": "面试题 10.02. 变位词组", "url": "https://leetcode-cn.com/problems/group-anagrams-lcci/solution/gong-shui-san-xie-tong-ji-bian-wei-ci-de-0iqe/", "difficulty": "中等", "tags": ["哈希表", "排序", "计数", "数学", "打表"], "question": "编写一种方法,对字符串数组进行排序,将所有变位词组合在一起。变位词是指字母相同,但排列不同的字符串。\n\n注意:本题相对原题稍作修改\n\n示例:\n```\n输入: [\"eat\", \"tea\", \"tan\", \"ate\", \"nat\", \"bat\"],\n\n输出:\n[\n  [\"ate\",\"eat\",\"tea\"],\n  [\"nat\",\"tan\"],\n  [\"bat\"]\n]\n```\n说明:\n* 所有输入均为小写字母。\n* 不考虑答案输出的顺序。", "solution": "### 模拟 + 排序\n\n一个朴素的想法是根据题意进行模拟,对每个字符串进行排序作为 `key`,从而实现相同的「变位词」对应同一个 `key`,使用哈希表进行统计即可。\n\n代码:\n```Java\nclass Solution {\n    public List<List<String>> groupAnagrams(String[] ss) {\n        List<List<String>> ans = new ArrayList<>();\n        Map<String, List<String>> map = new HashMap<>();\n        for (String s : ss) {\n            char[] cs = s.toCharArray();\n            Arrays.sort(cs);\n            String key = String.valueOf(cs);\n            List<String> list = map.getOrDefault(key, new ArrayList<>());\n            list.add(s);\n            map.put(key, list);\n        }\n        for (String key : map.keySet()) ans.add(map.get(key));\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(\\sum_{i = 0}^{n - 1}ss[i].length * \\log{ss[i].length})$\n* 空间复杂度:$O(\\sum_{i = 0}^{n - 1}ss[i])$\n\n---\n\n### 模拟 + 计数\n\n方法一无法做到线性,主要是存在对字符串进行排序的环节。\n\n事实上,我们可以利用字符集大小有限作为切入点(只包含小写字母),使用一个大小为 $26$ 的数组进行计数,然后对计数后的数组统计值进行拼接,作为哈希表的 `key`,从而实现线性复杂度。\n\n代码:\n```Java\nclass Solution {\n    public List<List<String>> groupAnagrams(String[] ss) {\n        List<List<String>> ans = new ArrayList<>();\n        Map<String, List<String>> map = new HashMap<>();\n        for (String s : ss) {\n            int[] cnts = new int[26];\n            for (char c : s.toCharArray()) cnts[c - 'a']++;\n            StringBuilder sb = new StringBuilder();\n            for (int i : cnts) sb.append(i + \"_\");\n            String key = sb.toString();\n            List<String> list = map.getOrDefault(key, new ArrayList<>());\n            list.add(s);\n            map.put(key, list);\n        }\n        for (String key : map.keySet()) ans.add(map.get(key));\n        return ans;\n    }\n}\n```\n* 时间复杂度:令 $n$ 为数组大小,$C$ 为字符集大小,固定为 $26$。整体复杂度为 $O(\\sum_{i = 0}^{n - 1}ss[i].length + n * C)$,\n* 空间复杂度:$O(\\sum_{i = 0}^{n - 1}ss[i])$\n\n---\n\n### 质数分解唯一性\n\n事实上,我们还能使用「质数分解唯一性」性质,使用质数乘积代指某个「变位词」。\n\n具体的,我们可以先使用 `static` 代码块(确保只会发生一次)打表最小的 $26$ 个质数(任意 $26$ 个都可以,使用小的,乘积溢出风险低一点),这 $26$ 个质数分别对应了 $26$ 个字母。\n\n对于一个「变位词」而言,其对应的质数乘积必然相同。\n\n代码:\n```Java\nclass Solution {\n    static int[] nums = new int[26]; \n    static {\n        for (int i = 2, idx = 0; idx != 26; i++) {\n            boolean ok = true;\n            for (int j = 2; j <= i / j; j++) {\n                if (i % j == 0) {\n                    ok = false;\n                    break;\n                } \n            }\n            if (ok) nums[idx++] = i;\n        }\n    }\n    public List<List<String>> groupAnagrams(String[] ss) {\n        List<List<String>> ans = new ArrayList<>();\n        Map<Long, List<String>> map = new HashMap<>();\n        for (String s : ss) {\n            long cur = 1;\n            for (char c : s.toCharArray()) {\n                cur *= nums[c - 'a'];\n            }\n            List<String> list = map.getOrDefault(cur, new ArrayList<>());\n            list.add(s);\n            map.put(cur, list);\n        }\n        for (long key : map.keySet()) ans.add(map.get(key));\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(\\sum_{i = 0}^{n - 1}ss[i].length)$\n* 空间复杂度:$O(\\sum_{i = 0}^{n - 1}ss[i])$\n\n---\n\n### 溢出说明\n\n使用 `long` 仍然存在溢出风险,但使用“长度不受限制”的高精度哈希值实现是不现实的。\n\n哈希值必须是有限值域内,才有意义。\n\n换句话说,如果使用高精度的哈希值的话,我们是无法直接将两个哈希值进行异或判断结果是否为 $0$ 来得出哈希值是否相同的结论,而是需要使用 $O(Len)$ 的复杂度来判定哈希值是否相同。\n\n因此,针对存在的哈希冲突问题,要么是解决冲突;要是使用与「字符串哈希」类似的做法,不处理溢出(相当于模 $2^{64}$),但这样会存在溢出次数不一样的值对应的哈希值相同的问题,只能说是一种期望冲突不发生的做法。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 10.02` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/面试题/面试题 16.25. LRU 缓存（中等）.md", "url_title": "面试题 16.25. LRU 缓存", "url": "https://leetcode-cn.com/problems/lru-cache-lcci/solution/gong-shui-san-xie-she-ji-shu-ju-jie-gou-k0iwg/)", "difficulty": "中等", "tags": ["设计", "链表", "哈希表"], "question": "运用你所掌握的数据结构,设计和实现一个  LRU (最近最少使用) 缓存机制 。\n实现 LRUCache 类:\n\n* LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存\n* int get(int key) 如果关键字 key 存在于缓存中,则返回关键字的值,否则返回 -1 。\n* void put(int key, int value) 如果关键字已经存在,则变更其数据值;如果关键字不存在,则插入该组「关键字-值」。当缓存容量达到上限时,它应该在写入新数据之前删除最久未使用的数据值,从而为新的数据值留出空间。\n\n进阶:你是否可以在 $O(1)$ 时间复杂度内完成这两种操作?\n\n示例:\n```\n输入\n[\"LRUCache\", \"put\", \"put\", \"get\", \"put\", \"get\", \"put\", \"get\", \"get\", \"get\"]\n[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]\n输出\n[null, null, null, 1, null, -1, null, -1, 3, 4]\n\n解释\nLRUCache lRUCache = new LRUCache(2);\nlRUCache.put(1, 1); // 缓存是 {1=1}\nlRUCache.put(2, 2); // 缓存是 {1=1, 2=2}\nlRUCache.get(1);    // 返回 1\nlRUCache.put(3, 3); // 该操作会使得关键字 2 作废,缓存是 {1=1, 3=3}\nlRUCache.get(2);    // 返回 -1 (未找到)\nlRUCache.put(4, 4); // 该操作会使得关键字 1 作废,缓存是 {4=4, 3=3}\nlRUCache.get(1);    // 返回 -1 (未找到)\nlRUCache.get(3);    // 返回 3\nlRUCache.get(4);    // 返回 4\n```\n\n提示:\n* 1 <= capacity <= 3000\n* 0 <= key <= 3000\n* 0 <= value <= $10^4$\n* 最多调用 3 * $10^4$ 次 get 和 put", "solution": "### 基本分析\n\nLRU 是一种十分常见的页面置换算法。\n\n将 LRU 翻译成大白话就是:**当不得不淘汰某些数据时(通常是容量已满),选择最久未被使用的数据进行淘汰。**\n\n**题目让我们实现一个容量固定的 `LRUCache` 。如果插入数据时,发现容器已满时,则先按照 LRU 规则淘汰一个数据,再将新数据插入,其中「插入」和「查询」都算作一次“使用”。**\n\n可以通过 🌰 来理解,假设我们有容量为 $2$ 的 `LRUCache` 和 测试键值对 `[`1-1`,`2-2`,`3-3`]` ,将其按照顺序进行插入 & 查询:\n* 插入 `1-1`,此时最新的使用数据为 `1-1`\n* 插入 `2-2`,此时最新使用数据变为 `2-2`\n* 查询 `1-1`,此时最新使用数据为 `1-1`\n* 插入 `3-3`,由于容器已经达到容量,需要先淘汰已有数据才能插入,这时候会淘汰 `2-2`,`3-3` 成为最新使用数据\n\n键值对存储方面,我们可以使用「哈希表」来确保插入和查询的复杂度为 $O(1)$。\n\n另外我们还需要额外维护一个「使用顺序」序列。\n\n我们期望当「新数据被插入」或「发生键值对查询」时,能够将当前键值对放到序列头部,这样当触发 LRU 淘汰时,只需要从序列尾部进行数据删除即可。\n\n**期望在 $O(1)$ 复杂度内调整某个节点在序列中的位置,很自然想到双向链表。**\n\n----\n\n### 双向链表\n\n具体的,我们使用哈希表来存储「键值对」,键值对的键作为哈希表的 Key,而哈希表的 Value 则使用我们自己封装的 `Node` 类,`Node` 同时作为双向链表的节点。\n\n* 插入:检查当前键值对是否已经存在于哈希表:\n  * 如果存在,则更新键值对,并将当前键值对所对应的 `Node` 节点调整到链表头部(`refresh` 操作)\n  * 如果不存在,则检查哈希表容量是否已经达到容量:\n    * 没达到容量:插入哈希表,并将当前键值对所对应的 `Node` 节点调整到链表头部(`refresh` 操作)\n    * 已达到容量:先从链表尾部找到待删除元素进行删除(`delete` 操作),然后再插入哈希表,并将当前键值对所对应的 `Node` 节点调整到链表头部(`refresh` 操作)\n* 查询:如果没在哈希表中找到该 Key,直接返回 $-1$;如果存在该 Key,则将对应的值返回,并将当前键值对所对应的 `Node` 节点调整到链表头部(`refresh` 操作)\n\n一些细节:\n\n* 为了减少双向链表左右节点的「判空」操作,我们预先建立两个「哨兵」节点 `head` 和 `tail`。\n\n代码:\n```Java\nclass LRUCache {\n    class Node {\n        int k, v;\n        Node l, r;\n        Node(int _k, int _v) {\n            k = _k;\n            v = _v;\n        }\n    }\n    int n;\n    Node head, tail;\n    Map<Integer, Node> map;\n    public LRUCache(int capacity) {\n        n = capacity;\n        map = new HashMap<>();\n        head = new Node(-1, -1);\n        tail = new Node(-1, -1);\n        head.r = tail;\n        tail.l = head;\n    }\n    \n    public int get(int key) {\n        if (map.containsKey(key)) {\n            Node node = map.get(key);\n            refresh(node);\n            return node.v;\n        } \n        return -1;\n    }\n    \n    public void put(int key, int value) {\n        Node node = null;\n        if (map.containsKey(key)) {\n            node = map.get(key);\n            node.v = value;\n        } else {\n            if (map.size() == n) {\n                Node del = tail.l;\n                map.remove(del.k);\n                delete(del);\n            }\n            node = new Node(key, value);\n            map.put(key, node);\n        }\n        refresh(node);\n    }\n\t\n    // refresh 操作分两步:\n    // 1. 先将当前节点从双向链表中删除(如果该节点本身存在于双向链表中的话)\n    // 2. 将当前节点添加到双向链表头部\n    void refresh(Node node) {\n        delete(node);\n        node.r = head.r;\n        node.l = head;\n        head.r.l = node;\n        head.r = node;\n    }\n\t\n    // delete 操作:将当前节点从双向链表中移除\n    // 由于我们预先建立 head 和 tail 两位哨兵,因此如果 node.l 不为空,则代表了 node 本身存在于双向链表(不是新节点)\n    void delete(Node node) {\n        if (node.l != null) {\n            Node left = node.l;\n            left.r = node.r;\n            node.r.l = left;\n        }\n    }\n}\n```\n* 时间复杂度:各操作均为 $O(1)$\n* 空间复杂度:$O(n)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 16.25` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/面试题/面试题 17.09. 第 k 个数（中等）.md", "url_title": "面试题 17.09. 第 k 个数", "url": "https://leetcode.cn/problems/get-kth-magic-number-lcci/solution/by-ac_oier-2czm/", "difficulty": "中等", "tags": ["优先队列(堆)", "多路归并", "双指针"], "question": "有些数的素因子只有 `3`,`5`,`7`,请设计一个算法找出第 `k` 个数。注意,不是必须有这些素因子,而是必须不包含其他的素因子。例如,前几个数按顺序应该是 `1`,`3`,`5`,`7`,`9`,`15`,`21`。\n\n示例 1:\n```\n输入: k = 5\n\n输出: 9\n```", "solution": "### 基本分析\n\n本题的基本思路与 [264. 丑数 II : 从朴素优先队列到多路归并](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247490029&idx=1&sn=bba9ddff88d247db310406ee418d5a15) 完全一致。\n\n---\n\n### 优先队列(小根堆)\n\n有了基本的分析思路,一个简单的解法是使用优先队列:\n\n1. 起始先将最小数值 $1$ 放入队列\n2. 每次从队列取出最小值 $x$,然后将 $x$ 所对应的数值 $3x$、$5x$ 和 $7x$ 进行入队\n3. 对步骤 2 循环多次,第 $k$ 次出队的值即是答案\n\n为了防止同一数值多次进队,我们需要使用数据结构 $Set$ 来记录入过队列的数值。\n\nJava 代码:\n```Java\nclass Solution {\n    public int getKthMagicNumber(int k) {\n        int[] nums = new int[]{3, 5, 7};\n        PriorityQueue<Long> q = new PriorityQueue<>();\n        Set<Long> set = new HashSet<>();\n        q.add(1L); set.add(1L);\n        while (!q.isEmpty()) {\n            long t = q.poll();\n            if (--k == 0) return (int) t;\n            for (int x : nums) {\n                if (!set.contains(x * t)) {\n                    q.add(x * t); set.add(x * t);\n                }\n            }\n        }\n        return -1;\n    }\n}\n```\nPython3 代码:\n```Python3\nclass Solution:\n    def getKthMagicNumber(self, k: int) -> int:\n        nums = [3, 5, 7]\n        q, vis = [], set()\n        q.append(1)\n        vis.add(1)\n        while q:\n            t = heapq.heappop(q)\n            k -= 1\n            if k == 0:\n                return t\n            for x in nums:\n                if t * x not in vis:\n                    heapq.heappush(q, t * x)\n                    vis.add(t * x)\n        return -1\n```\n* 时间复杂度:$O(k\\log{k})$\n* 空间复杂度:$O(k)$\n\n---\n\n### 多路归并(多指针)\n\n从解法一中不难发现,我们「往后产生的数值」都是基于「已有数值」而来(使用「已有数值」乘上 $3$、$5$、$7$)。\n\n因此,如果我们最终的数值序列为 $a1,a2,a3,...,an$ 的话,序列中的每一个数都必然能够被以下三个序列(中的至少一个)覆盖:\n\n* 由数值 $\\times 3$ 所得的有序序列:$1 \\times 3$、$2 \\times 3$、$3 \\times 3$、$4 \\times 3$、$5 \\times 3$、$6 \\times 3$、$8 \\times 3$ ...\n* 由数值 $\\times 5$ 所得的有序序列:$1 \\times 5$、$2 \\times 5$、$3 \\times 5$、$4 \\times 5$、$5 \\times 5$、$6 \\times 5$、$8 \\times 5$ ...\n* 由数值 $\\times 6$ 所得的有序序列:$1 \\times 7$、$2 \\times 7$、$3 \\times 7$、$4 \\times 7$、$5 \\times 7$、$6 \\times 7$、$8 \\times 6$ ...\n\n举个🌰,假设我们需要求得 $[1, 3, 5, 7, 9, 15, 21]$ 数值序列 $arr$ 的最后一位,那么该序列可以看作以下三个有序序列归并而来:\n\n* $1 \\times 3, 3 \\times 3, 5 \\times 3, ... , 15 \\times 3, 21 \\times 3$ ,将 $3$ 提出,即 $arr \\times 3$\n* $1 \\times 5, 3 \\times 5, 5 \\times 5, ... , 15 \\times 5, 21 \\times 5$ ,将 $5$ 提出,即 $arr \\times 5$\n* $1 \\times 7, 3 \\times 7, 5 \\times 7, ... , 15 \\times 7, 21 \\times 7$ ,将 $7$ 提出,即 $arr \\times 7$\n\n因此我们可以使用三个指针来指向目标序列 $arr$ 的某个下标(下标 $0$ 作为哨兵不使用,起始都为 $1$),使用 $arr[下标] \\times 系数$(`3`、`5` 和 `7`) 代表当前使用到三个有序序列中的哪一位,同时使用 $idx$ 表示当前生成到 $arr$ 哪一位数值。\n\nJava 代码:\n```Java\nclass Solution {\n    public int getKthMagicNumber(int k) {\n        int[] ans = new int[k + 1];\n        ans[1] = 1;\n        for (int i3 = 1, i5 = 1, i7 = 1, idx = 2; idx <= k; idx++) {\n            int a = ans[i3] * 3, b = ans[i5] * 5, c = ans[i7] * 7;\n            int min = Math.min(a, Math.min(b, c));\n            if (min == a) i3++;\n            if (min == b) i5++;\n            if (min == c) i7++;\n            ans[idx] = min;\n        }\n        return ans[k];\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction getKthMagicNumber(k: number): number {\n    const ans = new Array<number>(k + 1).fill(1)\n    for (let i3 = 1, i5 = 1, i7 = 1, idx = 2; idx <= k; idx++) {\n        const a = ans[i3] * 3, b = ans[i5] * 5, c = ans[i7] * 7\n        const min = Math.min(a, Math.min(b, c))\n        if (a == min) i3++\n        if (b == min) i5++\n        if (c == min) i7++\n        ans[idx] = min\n    }\n    return ans[k]\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def getKthMagicNumber(self, k: int) -> int:\n        ans = [1] * (k + 1)\n        i3, i5, i7 = 1, 1, 1\n        for idx in range(2, k + 1):\n            a, b, c = ans[i3] * 3, ans[i5] * 5, ans[i7] * 7\n            cur = min([a, b, c])\n            i3 = i3 + 1 if cur == a else i3\n            i5 = i5 + 1 if cur == b else i5\n            i7 = i7 + 1 if cur == c else i7\n            ans[idx] = cur\n        return ans[k]\n```\n* 时间复杂度:$O(k)$\n* 空间复杂度:$O(k)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.09` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/面试题/面试题 17.10. 主要元素（简单）.md", "url_title": "面试题 17.10. 主要元素", "url": "https://leetcode-cn.com/problems/find-majority-element-lcci/solution/gong-shui-san-xie-yi-ti-shuang-jie-ha-xi-zkht/", "difficulty": "简单", "tags": ["哈希表", "摩尔投票"], "question": "数组中占比超过一半的元素称之为主要元素。给你一个 整数 数组,找出其中的主要元素。\n\n若没有,返回 -1 。请设计时间复杂度为 $O(N)$ 、空间复杂度为 $O(1)$ 的解决方案。\n\n示例 1:\n```\n输入:[1,2,5,9,5,9,5,5,5]\n\n输出:5\n```\n示例 2:\n```\n输入:[3,2]\n\n输出:-1\n```\n示例 3:\n```\n输入:[2,2,1,1,1,2,2]\n\n输出:2\n```", "solution": "### 哈希表 \n\n一个朴素的做法是使用哈希表进行计数,如果发现某个元素数量超过总数一半,说明找到了答案。\n\n代码:\n```Java\nclass Solution {\n    public int majorityElement(int[] nums) {\n        int n = nums.length;\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int x : nums) {\n            map.put(x, map.getOrDefault(x, 0) + 1);\n            if (map.get(x) > n / 2) return x;\n        }\n        return -1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(n)$\n\n---\n\n### 摩尔投票\n\n这还是道「摩尔投票」模板题。\n\n**[摩尔投票](https://zh.wikipedia.org/wiki/%E5%A4%9A%E6%95%B0%E6%8A%95%E7%A5%A8%E7%AE%97%E6%B3%95) :在集合中寻找可能存在的多数元素,这一元素在输入的序列重复出现并占到了序列元素的一半以上;在第一遍遍历之后应该再进行一个遍历以统计第一次算法遍历的结果出现次数,确定其是否为众数;如果一个序列中没有占到多数的元素,那么第一次的结果就可能是无效的随机元素。**\n\n**换句话说,每次将两个不同的元素进行「抵消」,如果最后有元素剩余,则「可能」为元素个数大于总数一半的那个。**\n\n具体的,我们定义一个变量 $x$ 来保存那个可能为主要元素的值,$cnt$ 用来记录该值的出现次数。然后在遍历数组 $nums$ 过程中执行如下逻辑:\n\n* 如果 $cnt$ 为 $0$:说明之前出现过的 $x$ 已经被抵消完了,更新一下 $x$ 为当前值,出现次数为 $1$:`x = nums[i], cnt = 1`;\n* 如果 $cnt$ 不为 $0$:说明之前统计的 $x$ 还没被抵消完,这是根据 $nums[i]$ 与 $x$ 是否相等进行计算即可:`cnt += nums[i] == x ? 1 : -1`。\n\n当处理完 $nums$ 之后,我们得到了一个「可能」的主要元素。注意只是可能,因为我们在处理过程中只使用了 $x$ 和 $cnt$ 来记录,我们是无法确定最后剩下的 $x$ 是经过多次抵消后剩余的主要元素,还是只是不存在主要元素的数组中的无效随机元素。\n\n因此我们需要再进行一次遍历,检查这个「可能」的主要元素 $x$ 的出现次数是否超过总数一半。\n\n代码:\n```Java\nclass Solution {\n    public int majorityElement(int[] nums) {\n        int n = nums.length;\n        int x = -1, cnt = 0;\n        for (int i : nums) {\n            if (cnt == 0) {\n                x = i;\n                cnt = 1;\n            } else {\n                cnt += x == i ? 1 : -1;\n            }\n        }\n        cnt = 0;\n        for (int i : nums) if (x == i) cnt++;\n        return cnt > n / 2 ? x : -1;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.10` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/面试题/面试题 17.11. 单词距离（中等）.md", "url_title": "面试题 17.11. 单词距离", "url": "https://leetcode.cn/problems/find-closest-lcci/solution/by-ac_oier-0hv9/", "difficulty": "中等", "tags": ["模拟", "双指针"], "question": "有个内含单词的超大文本文件,给定任意两个不同的单词,找出在这个文件中这两个单词的最短距离(相隔单词数)。如果寻找过程在这个文件中会重复多次,而每次寻找的单词不同,你能对此优化吗?\n\n示例:\n```\n输入:words = [\"I\",\"am\",\"a\",\"student\",\"from\",\"a\",\"university\",\"in\",\"a\",\"city\"], word1 = \"a\", word2 = \"student\"\n\n输出:1\n```\n提示:\n* $words.length <= 100000$", "solution": "### 模拟\n\n对 `words` 进行遍历,使用两个指针 `p` 和 `q` 分别记录最近的两个关键字的位置,并维护更新最小距离。\n\n代码:\n```Java\nclass Solution {\n    public int findClosest(String[] ws, String a, String b) {\n        int n = ws.length, ans = n;\n        for (int i = 0, p = -1, q = -1; i < n; i++) {\n            String t = ws[i];\n            if (t.equals(a)) p = i;\n            if (t.equals(b)) q = i;\n            if (p != -1 && q != -1) ans = Math.min(ans, Math.abs(p - q));\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.11` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/面试题/面试题 17.14. 最小K个数（中等）.md", "url_title": "面试题 17.14. 最小K个数", "url": "https://leetcode-cn.com/problems/smallest-k-lcci/solution/gong-shui-san-xie-yi-ti-si-jie-you-xian-yy5k5/", "difficulty": "中等", "tags": ["优先队列(堆)", "排序"], "question": "设计一个算法,找出数组中最小的 $k$ 个数。以任意顺序返回这k个数均可。\n\n示例:\n```\n输入: arr = [1,3,5,7,2,4,6,8], k = 4\n\n输出: [1,2,3,4]\n```\n\n提示:\n* $0 <= len(arr) <= 100000$\n* $0 <= k <= \\min(100000, len(arr))$", "solution": "### 优先队列(小根堆)\n\n一个直观的想法是使用「优先队列(小根堆)」,起始将所有元素放入堆中,然后再从堆中取出 $k$ 个元素并「顺序」构造答案。\n\n代码:\n```Java\nclass Solution {\n    public int[] smallestK(int[] arr, int k) {\n        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->a-b);\n        for (int i : arr) q.add(i);\n        int[] ans = new int[k];\n        for (int i = 0; i < k; i++) ans[i] = q.poll();\n        return ans;\n    }\n}\n```\n* 时间复杂度:建堆复杂度为 $O(n\\log{n})$,构造答案复杂度为 $O(k\\log{n})$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(n + k)$\n\n---\n\n### 优先队列(大根堆)\n\n在解法一中,我们将所有的原始都放入堆中,堆中元素最多有 $n$ 个,这导致了我们复杂度的上界为 $O(n\\log{n})$。\n\n而另外一个比较优秀的做法是,使用「优先队列(大根堆)」。\n\n当处理到原始 $arr[i]$ 时,根据堆内元素个数,以及其与堆顶元素的关系分情况讨论:\n\n* 堆内元素不足 $k$ 个:直接将 $arr[i]$ 放入堆内;\n* 堆内元素为 $k$ 个:根据 $arr[i]$ 与堆顶元素的大小关系分情况讨论:\n    * $arr[i] >= heapTop$:$arr[i]$ 不可能属于第 $k$ 小数(已有 $k$ 个元素在堆中),直接丢弃 $arr[i]$;\n    * $arr[i] < heapTop$:$arr[i]$ 可能属于第 $k$ 小数,弹出堆顶元素,并放入 $arr[i]$。\n\n当 $arr$ 被处理完,我们再使用堆中元素「逆序」构造答案。\n\n代码:\n```Java\nclass Solution {\n    public int[] smallestK(int[] arr, int k) {\n        PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->b-a);\n        int[] ans = new int[k];\n        if (k == 0) return ans;\n        for (int i : arr) {\n            if (q.size() == k && q.peek() <= i) continue;\n            if (q.size() == k) q.poll();\n            q.add(i);\n        }\n        for (int i = k - 1; i >= 0; i--) ans[i] = q.poll();\n        return ans;\n    }\n}\n```\n* 时间复杂度:建堆复杂度为 $O(n\\log{k})$,构造答案复杂度为 $O(k\\log{k})$。整体复杂度为 $O(n\\log{k})$\n* 空间复杂度:$O(k)$\n\n---\n\n### 全排序 \n\nJava 中的 `Arrays.sort` 为综合排序实现。会根据数据规模、元素本身是否大致有序选择不同的排序实现。\n\n因此一个比较省事的实现是先使用 `Arrays.sort` 进行排序,再构造答案。\n\n代码:\n```Java\nclass Solution {\n    public int[] smallestK(int[] arr, int k) {\n        Arrays.sort(arr);\n        int[] ans = new int[k];\n        for (int i = 0; i < k; i++) ans[i] = arr[i];\n        return ans;\n    }\n}\n```\n* 时间复杂度:排序(假定 `Arrays.sort` 使用的是双轴快排实现)的复杂度为 $O(n\\log{n})$;构造答案复杂度为 $O(k)$。整体复杂度为 $O(n\\log{n})$\n* 空间复杂度:$O(\\log{n} + k)$\n\n---\n\n### 快排数组划分\n\n注意到题目要求「任意顺序返回这 $k$ 个数即可」,因此我们只需要确保前 $k$ 小的数都出现在下标为 $[0, k)$ 的位置即可。\n\n利用「快速排序」的数组划分即可做到。\n\n我们知道快排每次都会将小于等于基准值的值放到左边,将大于基准值的值放到右边。\n\n因此我们可以通过判断基准点的下标 $idx$ 与 $k$ 的关系来确定过程是否结束:\n\n* $idx < k$:基准点左侧不足 $k$ 个,递归处理右边,让基准点下标右移;\n* $idx > k$:基准点左侧超过 $k$ 个,递归处理左边,让基准点下标左移;\n* $idx = k$:基准点左侧恰好 $k$ 个,输出基准点左侧元素。\n\n代码:\n```Java\nclass Solution {\n    int k;\n    public int[] smallestK(int[] arr, int _k) {\n        k = _k;\n        int n = arr.length;\n        int[] ans = new int[k];\n        if (k == 0) return ans;\n        qsort(arr, 0, n - 1);\n        for (int i = 0; i < k; i++) ans[i] = arr[i];\n        return ans;\n    }\n    void qsort(int[] arr, int l, int r) {\n        if (l >= r) return ;\n        int i = l, j = r;\n        int ridx = new Random().nextInt(r - l + 1) + l;\n        swap(arr, ridx, l);\n        int x = arr[l];\n        while (i < j) {\n            while (i < j && arr[j] >= x) j--;\n            while (i < j && arr[i] <= x) i++;\n            swap(arr, i, j);\n        }\n        swap(arr, i, l);\n        // 集中答疑:因为题解是使用「基准点左侧」来进行描述(不包含基准点的意思),所以这里用的 k(写成 k - 1 也可以滴\n        if (i > k) qsort(arr, l, i - 1);\n        if (i < k) qsort(arr, i + 1, r);\n    }\n    void swap(int[] arr, int l, int r) {\n        int tmp = arr[l];\n        arr[l] = arr[r];\n        arr[r] = tmp;\n    }\n}\n```\n* 时间复杂度:由于每次都会随机选择基准值,因此每次递归的数组平均长度为 $n / 2$,那么划分数组操作的次数不会超过 $2 \\times n$。整体复杂度为 $O(n)$\n* 空间复杂度:$O(\\log{n})$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.14` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/面试题/面试题 17.19. 消失的两个数字（困难）.md", "url_title": "面试题 17.19. 消失的两个数字", "url": "https://leetcode.cn/problems/missing-two-lcci/solution/by-ac_oier-pgeh/", "difficulty": "困难", "tags": ["数学", "位运算"], "question": "给定一个数组,包含从 `1` 到 `N` 所有的整数,但其中缺了两个数字。你能在 $O(N)$ 时间内只用 $O(1)$ 的空间找到它们吗?\n\n以任意顺序返回这两个数字均可。\n\n示例 1:\n```\n输入: [1]\n\n输出: [2,3]\n```\n示例 2:\n```\n输入: [2,3]\n\n输出: [1,4]\n```\n提示:\n* $nums.length <= 30000$", "solution": "### 数学\n\n根据题意,给定 `nums` 的长度为 $m$ 且缺失了两个数,所有的 $nums[i]$ 加上缺失数字组成连续排列长度为 $n = m + 2$。\n\n根据等差数量求和公式可知,补齐后的排列总和为 $\\frac{n \\times (1 + n)}{2}$,补全后的理论总和与实际总和之间的差值 $cur = \\frac{n \\times (1 + n)}{2} - \\sum_{i = 0}^{m - 1}nums[i]$ 为缺失数值之和。\n\n根据补全后数值各不相同可知,两者必不可能同时位于 $t = \\left \\lfloor \\frac{cur}{2} \\right \\rfloor$ 的同一侧(偏大、偏小或数值重复),因此我们可以计算 $[1, t]$ 范围内的理论总和与实际总和之间的差值来确定其一(将问题转换为求解缺失一值),再结合缺失两值之和 $sum$ 算得答案。\n\nJava 代码:\n```Java\nclass Solution {\n    public int[] missingTwo(int[] nums) {\n        int n = nums.length + 2, cur = n * (1 + n) / 2;\n        for (int x : nums) cur -= x;\n        int sum = cur, t = cur / 2;\n        cur = t * (1 + t) / 2;\n        for (int x : nums) {\n            if (x <= t) cur -= x;\n        }\n        return new int[]{cur, sum - cur};\n    }\n}\n```\nTypeScript 代码:\n```TypeScript\nfunction missingTwo(nums: number[]): number[] {\n    let n = nums.length + 2, cur = Math.floor(n * (1 + n) / 2)\n    for (let x of nums) cur -= x\n    let sum = cur, t = Math.floor(cur / 2)\n    cur = Math.floor(t * (1 + t) / 2)\n    for (let x of nums) {\n        if (x <= t) cur -= x\n    }\n    return [cur, sum - cur]\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def missingTwo(self, nums: List[int]) -> List[int]:\n        n = len(nums) + 2\n        cur = n * (1 + n) // 2 - sum(nums)\n        tot, t = cur, cur // 2\n        cur = t * (1 + t) // 2 - sum([x for x in nums if x <= t])\n        return [cur, tot - cur]\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$\n\n---\n\n### 异或\n\n另外一类求解方法是利用「异或」+「lowbit」。\n\n由于我们明确了是在 $[1, n + 2]$ 中缺失了两个数,我们可以先通过异或 $[1, n + 2]$ 以及所有的 $nums[i]$ 来得到缺失两个数值异或和 `t`。\n\n我们知道异或结果二进制表示为 $1$ 代表了两缺失值该位置数值不同(一个该位置 $0$,另一个该位置为 $1$),我们可以根据异或和 `t` 中任意一位为 $1$ 的位置来将两个缺失值划分到两组中。\n\n更加优雅的方式是使用 `lowbit` 操作:`d = t & -t` 可快速得到只保留 `t` 中最低位 `1` 的对应数值。\n\n随后将 $[1, n + 2]$ 中满足 `i & d != 0` 的所有 `i`(含义为对应位置为 $1$ 的数值)与 $nums[i]$ 中满足 `nums[i] & d != 0` 的所有 $nums[i]$(含义为对应位置为 $1$ 的数值) 进行异或,最终能够确定其中一个缺失值,再结合最开始的异或和 `t` 即可确定另外一个缺失值。\n\nJava 代码:\n```Java \nclass Solution {\n    public int[] missingTwo(int[] nums) {\n        int n = nums.length + 2, cur = 0;\n        for (int i = 1; i <= n; i++) cur ^= i;\n        for (int x : nums) cur ^= x;\n        int t = cur, d = cur & -cur;\n        cur = 0;\n        for (int i = 1; i <= n; i++) {\n            if ((d & i) != 0) cur ^= i;\n        }\n        for (int x : nums) {\n            if ((d & x) != 0) cur ^= x;\n        }\n        return new int[]{cur, t ^ cur};\n    }\n}\n```\nTypeScript 代码:\n```TypeScript \nfunction missingTwo(nums: number[]): number[] {\n    let n = nums.length + 2, cur = 0\n    for (let i = 1; i <= n; i++) cur ^= i\n    for (let x of nums) cur ^= x\n    const t = cur, d = cur & -cur\n    cur = 0\n    for (let i = 1; i <= n; i++) {\n        if ((d & i) != 0) cur ^= i\n    }\n    for (let x of nums) {\n        if ((d & x) != 0) cur ^= x\n    }\n    return [cur, t ^ cur]\n};\n```\nPython 代码:\n```Python\nclass Solution:\n    def missingTwo(self, nums: List[int]) -> List[int]:\n        n, cur = len(nums) + 2, 0\n        for i in range(1, n + 1):\n            cur ^= i\n        for x in nums:\n            cur ^= x\n        t, d = cur, cur & -cur\n        cur = 0\n        for i in range(1, n + 1):\n            if d & i:\n                cur ^= i\n        for x in nums:\n            if d & x:\n                cur ^= x\n        return [cur, t ^ cur]\n```\n* 时间复杂度:$O(n)$\n* 空间复杂度:$O(1)$", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.19` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}
{"file_path": "LeetCode/面试题/面试题 17.21. 直方图的水量（困难）.md", "url_title": "面试题 17.21. 直方图的水量", "url": "https://leetcode-cn.com/problems/volume-of-histogram-lcci/solution/gong-shui-san-xie-yi-ti-si-jie-po-su-yu-sqadp/", "difficulty": "困难", "tags": ["数学", "双指针", "动态规划"], "question": "给定一个直方图(也称柱状图),假设有人从上面源源不断地倒水,最后直方图能存多少水量?直方图的宽度为 1。\n\n上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的直方图,在这种情况下,可以接 6 个单位的水(蓝色部分表示水)。 感谢 Marcos 贡献此图。\n\n示例:\n```\n输入: [0,1,0,2,1,0,1,3,2,1,2,1]\n\n输出: 6\n```", "solution": "### 朴素解法\n\n对于每根柱子而言,我们只需要找出「其左边最高的柱子」和「其右边最高的柱子」。\n\n对左右的最高柱子取一个最小值,再和当前柱子的高度做一个比较,即可得出当前位置可以接下的雨水。\n\n同时,边缘的柱子不可能接到雨水(某一侧没有柱子)。\n\n这样的做法属于「暴力做法」,但题目没有给数据范围,我们无法分析到底能否 AC。\n\n唯唯诺诺交一个,过了 ~ (好题,建议加入蓝桥杯\n\n代码:\n```java []\nclass Solution {\n    public int trap(int[] height) {\n        int n = height.length;\n        int ans = 0;\n        for (int i = 1; i < n - 1; i++) {\n            int cur = height[i];\n\n            // 获取当前位置的左边最大值\n            int l = Integer.MIN_VALUE;\n            for (int j = i - 1; j >= 0; j--) l = Math.max(l, height[j]);\n            if (l <= cur) continue;\n\n            // 获取当前位置的右边边最大值\n            int r = Integer.MIN_VALUE;\n            for (int j = i + 1; j < n; j++) r = Math.max(r, height[j]);\n            if (r <= cur) continue;\n\n            // 计算当前位置可接的雨水\n            ans += Math.min(l, r) - cur;\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:需要处理所有非边缘的柱子,复杂度为 $O(n)$;对于每根柱子而言,需要往两边扫描分别找到最大值,复杂度为 $O(n)$。整体复杂度为 $O(n^2)$。\n* 空间复杂度:$O(1)$。\n\n***\n\n### 预处理最值\n\n朴素解法的思路有了,我们想想怎么优化。\n\n事实上,任何的优化无非都是「减少重复」。\n\n想想在朴素思路中有哪些环节比较耗时,耗时环节中又有哪些地方是重复的,可以优化的。\n\n首先对每根柱子进行遍历,求解每根柱子可以接下多少雨水,这个 $O(n)$ 操作肯定省不了。\n\n**但在求解某根柱子可以接下多少雨水时,需要对两边进行扫描,求两侧的最大值。每一根柱子都进行这样的扫描操作,导致每个位置都被扫描了 $n$ 次。这个过程显然是可优化的。**\n\n换句话说:**我们希望通过不重复遍历的方式找到任意位置的两侧最大值。**\n\n问题转化为:**给定一个数组,如何求得任意位置的左半边的最大值和右半边的最大值。**\n\n一个很直观的方案是:**直接将某个位置的两侧最大值存起来。**\n\n我们可以先从两端分别出发,预处理每个位置的「左右最值」,这样可以将我们「查找左右最值」的复杂度降到 $O(1)$。\n\n整体算法的复杂度也从 $O(n^2)$ 下降到 $O(n)$。\n\n代码:\n```java []\nclass Solution {\n    public int trap(int[] height) {\n        int n = height.length;\n        int ans = 0;\n        // 由于预处理最值的时候,我们会直接访问到 height[0] 或者 height[n - 1],因此要特判一下\n        if (n == 0) return ans;\n\n        // 预处理每个位置左边的最值\n        int[] lm = new int[n];\n        lm[0] = height[0];\n        for (int i = 1; i < n; i++) lm[i] = Math.max(height[i], lm[i - 1]);\n        \n        // 预处理每个位置右边的最值\n        int[] rm = new int[n];\n        rm[n - 1] = height[n - 1];\n        for (int i = n - 2; i >= 0; i--) rm[i] = Math.max(height[i], rm[i + 1]);\n\n        for (int i = 1; i < n - 1; i++) {\n            ans += Math.min(lm[i], rm[i]) - height[i];\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:预处理出两个最大值数组,复杂度为 $O(n)$;计算每根柱子可接的雨水量,复杂度为 $O(n)$。整体复杂度为 $O(n)$。\n* 空间复杂度:使用了数组存储两侧最大值。复杂度为 $O(n)$。\n\n***\n\n### 单调栈\n\n前面我们讲到,优化思路将问题转化为:**给定一个数组,如何求得任意位置的左半边的最大值和右半边的最大值。**\n\n但仔细一想,其实我们并不需要找两侧最大值,只需要找到两侧最近的比当前位置高的柱子就行了。\n\n针对这一类找最近值的问题,有一个通用解法:**单调栈**。\n\n**单调栈其实就是在栈的基础上,维持一个栈内元素单调。**\n\n在这道题,由于需要找某个位置两侧比其高的柱子(只有两侧有比当前位置高的柱子,当前位置才能接下雨水),我们可以维持栈内元素的单调递减。\n\n**PS. 找某侧最近一个比其大的值,使用单调栈维持栈内元素递减;找某侧最近一个比其小的值,使用单调栈维持栈内元素递增 ...**\n\n当某个位置的元素弹出栈时,例如位置 `a` ,我们自然可以得到 `a` 位置两侧比 `a` 高的柱子:\n\n* 一个是导致 `a` 位置元素弹出的柱子( `a` 右侧比 `a` 高的柱子)\n* 一个是 `a` 弹栈后的栈顶元素(`a` 左侧比 `a` 高的柱子)\n\n当有了 `a` 左右两侧比 `a` 高的柱子后,便可计算 `a` 位置可接下的雨水量。\n\n代码:\n```java []\nclass Solution {\n    public int trap(int[] height) {\n        int n = height.length;\n        int ans = 0;\n        Deque<Integer> d = new ArrayDeque<>();\n        for (int i = 0; i < n; i++) {\n            while (!d.isEmpty() && height[i] > height[d.peekLast()]) {\n                int cur = d.pollLast();\n\n                // 如果栈内没有元素,说明当前位置左边没有比其高的柱子,跳过\n                if (d.isEmpty()) continue;\n\n                // 左右位置,并有左右位置得出「宽度」和「高度」\n                int l = d.peekLast(), r = i;\n                int w = r - l + 1 - 2;\n                int h = Math.min(height[l], height[r]) - height[cur];\n                ans += w * h;\n            }\n            d.addLast(i);\n        }\n        return ans;\n    }\n}\n```\n* 时间复杂度:每个元素最多进栈和出栈一次。复杂度为 $O(n)$。\n* 空间复杂度:栈最多存储 $n$ 个元素。复杂度为 $O(n)$。\n\n***\n\n### 面积差值\n\n事实上,我们还能利用「面积差值」来进行求解。\n\n我们先统计出「柱子面积」$sum$ 和「以柱子个数为宽、最高柱子高度为高的矩形面积」$full$。\n\n然后分别「从左往右」和「从右往左」计算一次最大高度覆盖面积 $lSum$ 和 $rSum$。\n\n**显然会出现重复面积,并且重复面积只会独立地出现在「山峰」的左边和右边。**\n\n利用此特性,我们可以通过简单的等式关系求解出「雨水面积」:\n\n代码:\n```java []\nclass Solution {\n    public int trap(int[] height) {\n        int n = height.length;\n\n        int sum = 0, max = 0;\n        for (int i = 0; i < n; i++) {\n            int cur = height[i];\n            sum += cur;\n            max = Math.max(max, cur);\n        }\n        int full = max * n;\n\n        int lSum = 0, lMax = 0;\n        for (int i = 0; i < n; i++) {\n            lMax = Math.max(lMax, height[i]);\n            lSum += lMax;\n        }\n\n        int rSum = 0, rMax = 0;\n        for (int i = n - 1; i >= 0; i--) {\n            rMax = Math.max(rMax, height[i]);\n            rSum += rMax;\n        }\n\n        return lSum + rSum - full - sum;\n    }\n}\n```\n* 时间复杂度:$O(n)$。\n* 空间复杂度:$O(1)$。", "final": "### 最后\n\n这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.21` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。\n\n在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。\n\n为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。\n\n在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。"}