算法笔记-lc-1640. 能否连接形成数组（中等）

题目

题干

给你一个整数数组 arr ，数组中的每个整数 互不相同 。另有一个由整数数组构成的数组 pieces，其中的整数也 互不相同 。请你以 任意顺序 连接 pieces 中的数组以形成 arr 。但是，不允许 对每个数组 pieces[i] 中的整数重新排序。

如果可以连接 pieces 中的数组形成 arr ，返回 true ；否则，返回 false 。

示例

示例 1：

输入：arr = [15,88], pieces = [[88],[15]]
输出：true
解释：依次连接 [15] 和 [88]
示例 2：

输入：arr = [49,18,16], pieces = [[16,18,49]]
输出：false
解释：即便数字相符，也不能重新排列 pieces[0]
示例 3：

输入：arr = [91,4,64,78], pieces = [[78],[4,64],[91]]
输出：true
解释：依次连接 [91]、[4,64] 和 [78]

提示

提示：

1 <= pieces.length <= arr.length <= 100
sum(pieces[i].length) == arr.length
1 <= pieces[i].length <= arr.length
1 <= arr[i], pieces[i][j] <= 100
arr 中的整数 互不相同
pieces 中的整数 互不相同（也就是说，如果将 pieces 扁平化成一维数组，数组中的所有整数互不相同）

解法

方法一：哈希表

因为数组arr 每个整数互不相同，且pieces 的整数也互不相同，所以我们可以通过 arr 固定 \textit{pieces}pieces 的放置。使用哈希表 index 记录pieces 各个数组的首元素与数组下标的对应关系。

我们不断地将 pieces 中的数组与数组arr 相对应，对于当前遍历的元素 arr[i]，如果它不存在于哈希表中，说明我们无法将pieces 与数组 arr 相对应，直接返回 false；否则我们找到对应的数组 \textit{pieces}[j]pieces[j]，然后将它与arr[i] 及之后的整数进行比较（在比较过程中，如果判断相等不成立，直接返回 false），判断都相等后，将 i 相应地向后移。全部 \textit{pieces}pieces 都匹配成功后，返回 true。

class Solution {
    public boolean canFormArray(int[] arr, int[][] pieces) {
        int n = arr.length, m = pieces.length;
        Map<Integer, Integer> index = new HashMap<Integer, Integer>();
        for (int i = 0; i < m; i++) {
            index.put(pieces[i][0], i);
        }
        for (int i = 0; i < n;) {
            if (!index.containsKey(arr[i])) {
                return false;
            }
            int j = index.get(arr[i]), len = pieces[j].length;
            for (int k = 0; k < len; k++) {
                if (arr[i + k] != pieces[j][k]) {
                    return false;
                }
            }
            i = i + len;
        }
        return true;
    }
}

复杂度分析

时间复杂度：O(n)，其中 nn 是数组 arr 的长度。

空间复杂度：O(n)。保存哈希表需要 O(n) 的空间。

方法二：排序 + 二分

偷懒直接看示例做了，于是漏掉「两数组元素各不相同」且「两数组总元素个数相等」等条件，写了一个「排序 + 二分 + 贪心」的解法。

但实际上该做法也仅能解决「两数组元素各不相同」的问题，若允许元素重复，并不存在多项式解法。

回归到元素互不相同的条件，可以退化出「排序 + 二分」解法。

记 arr 数组长度为 nn，pieces 数组长度为 mm。

起始对 pieces 进行排序（根据pieces[i] 的首位元素排升序），从前往后处理每个 arr[i] 尝试匹配，先通过二分找到合适的pieces[j]（即满足首位元素与 arr[i] 相同的pieces[j]），并进行连续段的匹配，若匹配失败直接返回 false。

代码：

class Solution {
    public boolean canFormArray(int[] arr, int[][] pieces) {
        int n = arr.length, m = pieces.length;
        Arrays.sort(pieces, (a,b)->a[0]-b[0]);
        for (int i = 0; i < n; ) {
            int l = 0, r = m - 1;
            while (l < r) {
                int mid = l + r + 1 >> 1;
                if (pieces[mid][0] <= arr[i]) l = mid;
                else r = mid - 1;
            }
            int len = pieces[r].length, idx = 0;
            while (idx < len && pieces[r][idx] == arr[i + idx]) idx++;
            if (idx == len) i += len;
            else return false;
        }
        return true;
    }
}

时间复杂度：排序复杂度为(mlogm)；构造的复杂度为 O(nlogm)。整体复杂度为 O(mlogm+nlogm)
空间复杂度：O(logm)