题目描述

给你一个长度为 n 的二维整数数组 groups，同时给你一个整数数组 nums。

你是否可以从 nums 中选出 n 个 不相交 的子数组，使得第 i 个子数组与 groups[i] （下标从 0 开始）完全相同，且如果 i > 0，那么第 (i-1) 个子数组在 nums 中出现的位置在第 i 个子数组前面。（也就是说，这些子数组在 nums 中出现的顺序需要与 groups 顺序相同）

如果你可以找出这样的 n 个子数组，请你返回 true，否则返回 false。

如果不存在下标为 k 的元素 nums[k] 属于不止一个子数组，就称这些子数组是 不相交 的。子数组指的是原数组中连续元素组成的一个序列。

样例

输入：groups = [[1,-1,-1],[3,-2,0]], nums = [1,-1,0,1,-1,-1,3,-2,0]
输出：true
解释：你可以分别在 nums 中选出第 0 个子数组 [1,-1,0,(1,-1,-1),3,-2,0]
和第 1 个子数组 [1,-1,0,1,-1,-1,(3,-2,0)]。

这两个子数组是不相交的，因为它们没有任何共同的元素。

输入：groups = [[10,-2],[1,2,3,4]], nums = [1,2,3,4,10,-2]
输出：false
解释：选择子数组 [(1,2,3,4),10,-2] 和 [1,2,3,4,(10,-2)] 是不正确的
，因为它们出现的顺序与 groups 中顺序不同。

[10,-2] 必须出现在 [1,2,3,4] 之前。

输入：groups = [[1,2,3],[3,4]], nums = [7,7,1,2,3,4,7,7]
输出：false
解释：选择子数组 [7,7,(1,2,3),4,7,7] 和 [7,7,1,2,(3,4),7,7] 是不正确的，因为它们不是不相交子数组。
它们有一个共同的元素 nums[4] （下标从 0 开始）。

限制

• groups.length == n
• 1 <= n <= 10^3
• 1 <= groups[i].length, sum(groups[i].length) <= 10^3
• 1 <= nums.length <= 10^3
• -10^7 <= groups[i][j], nums[k] <= 10^7

算法

(贪心) $O(n \sum{groups(i)})$

1. 匹配肯定是越靠前越好。
2. 定义双指针，从开始位置匹配 groups[0]，如果匹配成功，则匹配 groups[1]，以此类推，直到匹配完成。

时间复杂度

• nums 的每个数字最多与 groups 中所有数字比对一次，故总时间复杂度为 $O(n \sum{groups(i)})$。

空间复杂度

• 仅需要常数的额外空间。

C++ 代码

class Solution {
private:
    bool match(const vector<int> &nums, int p, const vector<int> &group) {
        const int len = group.size();
        for (int i = p - len + 1, j = 0; j < len; i++, j++)
            if (nums[i] != group[j])
                return false;
        return true;
    }

public:
    bool canChoose(vector<vector<int>>& groups, vector<int>& nums) {
        const int n = nums.size();
        const int m = groups.size();

        int i = groups[0].size() - 1, j = 0;
        while (i < n) {
            if (i >= groups[j].size() - 1 && match(nums, i, groups[j])) {
                j++;
                if (j == m)
                    return true;
                i += groups[j].size();
            } else {
                i++;
            }
        }

        return false;
    }
};