LeetCode 第 27 场双周赛（C++）

1、通过翻转子数组使两个数组相等（3分）

问题描述

给你两个长度相同的整数数组 target和 arr。

每一步中，你可以选择arr的任意 非空子数组 并将它翻转。你可以执行此过程任意次。

如果你能让 arr变得与 target相同，返回True；否则，返回 False。

示例 1：

输入：target = [1,2,3,4], arr = [2,4,1,3]
输出：true
解释：你可以按照如下步骤使 arr 变成 target：
1- 翻转子数组 [2,4,1] ，arr 变成 [1,4,2,3]
2- 翻转子数组 [4,2] ，arr 变成 [1,2,4,3]
3- 翻转子数组 [4,3] ，arr 变成 [1,2,3,4]
上述方法并不是唯一的，还存在多种将 arr 变成 target 的方法。

示例 2：

输入：target = [7], arr = [7]
输出：true
解释：arr 不需要做任何翻转已经与 target 相等

示例 3：

输入：target = [1,12], arr = [12,1]
输出：true

示例 4：

输入：target = [3,7,9], arr = [3,7,11]
输出：false
解释：arr 没有数字 9 ，所以无论如何也无法变成 target 。

示例 5：

输入：target = [1,1,1,1,1], arr = [1,1,1,1,1]
输出：true

提示：

target.length == arr.length
1 <= target.length <= 1000
1 <= target[i] <= 1000
1 <= arr[i] <= 1000

解题思路

• 本题目的含义就是检查两个数组是否是相等的。
• equal()函数用法：如果两个数列的各个元素均相同，返回true。如果第二个数列的元素比较多，多出来的不予考虑。

代码实现

class Solution {
public:
    bool canBeEqual(vector<int>& target, vector<int>& arr) {
        sort(target.begin(), target.end());
        sort(arr.begin(), arr.end());
        return target.size() == arr.size() and equal(target.begin(), target.end(), arr.begin());
    }
};

运行截图

2、检查一个字符串是否包含所有长度为 K 的二进制子串（4分）

问题描述

给你一个二进制字符串s和一个整数k。

如果所有长度为k的二进制字符串都是s的子串，请返回True，否则请返回 False。

示例 1：

输入：s = “00110110”, k = 2
输出：true
解释：长度为 2 的二进制串包括 “00”，“01”，“10” 和 “11”。它们分别是 s 中下标为 0，1，3，2 开始的长度为 2 的子串。

示例 2：

输入：s = “00110”, k = 2
输出：true

示例 3：

输入：s = “0110”, k = 1
输出：true
解释：长度为 1 的二进制串包括 “0” 和 “1”，显然它们都是 s 的子串。

示例 4：

输入：s = “0110”, k = 2
输出：false
解释：长度为 2 的二进制串 “00” 没有出现在 s 中。

示例 5：

输入：s = “0000000001011100”, k = 4
输出：false

提示：

1 <= s.length <= 5 * 10^5
s 中只含 0 和 1 。
1 <= k <= 20

解题思路

• 利用滑动窗口s中的所有长度为k的字符串存储到set中，最终判断set的长度如果等于$2^k$即可。

代码实现

class Solution {
public:
    bool hasAllCodes(string s, int k) {
        set<string> sset;
        int i = 0;
        string str;
        for(; i < k; i++){
            str.push_back(s[i]);
        }
        sset.insert(str);
        for(; i < s.length(); i++){
            str.erase(str.begin());
            str.push_back(s[i]);
            sset.insert(str);
            if(sset.size() == pow(2, k)) // 判断语句写在for循环外面时，TLE。
                return true;
        }
        return false;
    }
};

运行截图

3、课程安排 IV（5分）

问题描述

你总共需要上 n门课，课程编号依次为0到n-1。

有的课会有直接的先修课程，比如如果想上课程0，你必须先上课程1，那么会以[1,0]数对的形式给出先修课程数对。

给你课程总数 n和一个直接先修课程数对列表 prerequisite和一个查询对列表 queries。

对于每个查询对queries[i]，请判断 queries[i][0]是否是queries[i][1]的先修课程。

请返回一个布尔值列表，列表中每个元素依次分别对应queries每个查询对的判断结果。

注意：如果课程a是课程b的先修课程且课程 b是课程 c的先修课程，那么课程a也是课程c的先修课程。

示例 1：

输入：n = 2, prerequisites = [[1,0]], queries = [[0,1],[1,0]]
输出：[false,true]
解释：课程 0 不是课程 1 的先修课程，但课程 1 是课程 0 的先修课程。

示例 2：

输入：n = 2, prerequisites = [], queries = [[1,0],[0,1]]
输出：[false,false]
解释：没有先修课程对，所以每门课程之间是独立的。

示例 3：

输入：n = 3, prerequisites = [[1,2],[1,0],[2,0]], queries = [[1,0],[1,2]]
输出：[true,true]

示例 4：

输入：n = 3, prerequisites = [[1,0],[2,0]], queries = [[0,1],[2,0]]
输出：[false,true]

示例 5：

输入：n = 5, prerequisites = [[0,1],[1,2],[2,3],[3,4]], queries = [[0,4],[4,0],[1,3],[3,0]]
输出：[true,false,true,false]

提示：

2 <= n <= 100
0 <= prerequisite.length <= (n * (n - 1) / 2)
0 <= prerequisite[i][0], prerequisite[i][1] < n
prerequisite[i][0] != prerequisite[i][1]
先修课程图中没有环。
先修课程图中没有重复的边。
1 <= queries.length <= 10^4
queries[i][0] != queries[i][1]

解题思路