每日一刷经验分享：剑指 中等 Offer II 115. 重建序列

剑指 中等 Offer II 115. 重建序列

🎈题意

给定一个长度为 n 的整数数组 nums ，其中 nums 是范围为 [1，n] 的整数的排列。还提供了一个 2D 整数数组 sequences ，其中 sequences[i] 是 nums 的子序列。
检查 nums 是否是唯一的最短 超序列 。最短 超序列 是 长度最短 的序列，并且所有序列 sequences[i] 都是它的子序列。对于给定的数组 sequences ，可能存在多个有效的 超序列 。

例如，对于 sequences = [[1,2],[1,3]] ，有两个最短的 超序列 ，[1,2,3] 和 [1,3,2] 。
而对于 sequences = [[1,2],[1,3],[1,2,3]] ，唯一可能的最短 超序列 是 [1,2,3] 。[1,2,3,4] 是可能的超序列，但不是最短的。
如果 nums 是序列的唯一最短 超序列 ，则返回 true ，否则返回 false 。
子序列 是一个可以通过从另一个序列中删除一些元素或不删除任何元素，而不改变其余元素的顺序的序列。

🥖示例 1：

输入：nums = [1,2,3], sequences = [[1,2],[1,3]]
输出：false
解释：有两种可能的超序列：[1,2,3]和[1,3,2]。
序列 [1,2] 是[1,2,3]和[1,3,2]的子序列。
序列 [1,3] 是[1,2,3]和[1,3,2]的子序列。
因为 nums 不是唯一最短的超序列，所以返回false。

🥖示例 2：

输入：nums = [1,2,3], sequences = [[1,2]]
输出：false
解释：最短可能的超序列为 [1,2]。
序列 [1,2] 是它的子序列：[1,2]。
因为 nums 不是最短的超序列，所以返回false。

🥖示例 3：

输入：nums = [1,2,3], sequences = [[1,2],[1,3],[2,3]]
输出：true
解释：最短可能的超序列为[1,2,3]。
序列 [1,2] 是它的一个子序列：[1,2,3]。
序列 [1,3] 是它的一个子序列：[1,2,3]。
序列 [2,3] 是它的一个子序列：[1,2,3]。
因为 nums 是唯一最短的超序列，所以返回true。

👀AC代码

class Solution {
    public boolean sequenceReconstruction(int[] nums, int[][] sequences) {
        int n = nums.length;
        int[] topology= new int[n+1];
        Map<Integer,HashSet<Integer>> map = new HashMap<>();
        HashSet<Integer> set1 = new HashSet<Integer>();
        List<Integer> list = new ArrayList<Integer>();
        int len;
        for(int[] re:sequences){ //构建拓扑序列
            len = re.length;
            set1.add(re[0]);
            for(int i=0;i<len-1;i++){
                set1.add(re[i]);
                set1.add(re[i+1]);
                if(!map.containsKey(re[i])) map.put(re[i],new HashSet<Integer>());
                if(!map.get(re[i]).contains(re[i+1])){
                    map.get(re[i]).add(re[i+1]);
                    topology[re[i+1]]++;
                }
            }
        }
        if(set1.size()!=n) return false;
        int flag =0,rec=-1;
        for(int i=1;i<=n;i++){ //找出第一个拓扑序列的位置
            if(topology[i]==0){
                rec = i;
                flag++;
            }
        }
        if(flag>1) return false;
        while(rec!=-1){ //找出其他拓扑排序的位置
            if(topology[rec]==0){
                list.add(rec);
                HashSet<Integer> set = map.get(rec);
                topology[rec]=-1;
                flag=0;
                rec=-1;
                if(set==null||set.size()==0) break;
                for(int t:set){
                    topology[t]--;
                    if(topology[t]==0) {rec=t;flag++;}
                }
                if(flag>1) return false;
            }
        }
        if(list.size()!=n) return false;
        for(int i=0;i<n;i++){
            if(list.get(i)!=nums[i]) return false;
        }
        return true;
    }
}