[面试题]最长连续子序列

1. 题目

题目：
leetcode 128 最长连续子序列
但是有所不同的是，这里求得不仅仅是长度，同时需要将整个子序列给复原出来，最后返回一个子序列的数组。
100, 4, 200, 1, 3, 2 => [1,2,3,4]

2. 分析

第一种方法是利用Map的方法，这种方法的话时间复杂度是O(n)，因为不需要排序，排序的时间复杂度是O(nlogn)，所以时间复杂度上面更加有优势。
第二种方法是利用排序之后，利用动态规划来解决这个问题，因为后面可能与前面连续，也可能不连续，此时只需要通过值的判断就可以知道当前的值是否是有个连续状态。

3. 代码

Map方式

遍历数组中所有的数，每次获取自身左右的数字，然后将自己最左边和最右边去更新，因为自己最右边和最左边只有当前自己能够接触到，如果是自己的下一个，它可能就触碰不到了

	public int longestConsecutive(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        int max = Integer.MIN_VALUE;
        Map<Integer, Integer> map = new HashMap<>();
        for (int num : nums) {
            if (!map.containsKey(num)) {
                int left = map.getOrDefault(num - 1, 0);
                int right = map.getOrDefault(num + 1, 0);
                int sum = left + right;
                map.put(num, sum + 1);
                // 同时需要更新左边和右边
                // 这里更新的措施，是因为如果当前的数被自己的前一个数改变了，如果后面跨过了当前的值的话，此时更新到边界即可
                if (left != 0) {
                    // 更新当前数的左边
                    map.put(num - left, sum + 1);
                }
                if (right != 0) {
                    map.put(num + right, sum + 1);
                }
                max = Math.max(sum + 1, max);
            }
        }
        return max;
    }

后面的话只需要找出值最大的最大的键值，即可通过连续个数个值大小复原

排序&动态规划

	public int[] longestConsecutiveII(int[] nums) {
        if (nums == null || nums.length == 0) return null;
        Arrays.sort(nums);
        int max = Integer.MIN_VALUE;
        int n = nums.length;
        int[] dp = new int[n];
        dp[0] = 1;
        for (int i = 1; i < n; i++) {
            // 这里注意就算啥都不干 dp[i]位置也要为1
            dp[i] = 1;
            if (nums[i] - nums[i - 1] == 1) {
                dp[i] = dp[i - 1] + 1;
            } else if (nums[i] == nums[i - 1]) {
                dp[i] = dp[i - 1];
            }
        }
        // 找到最大值的下标，然后找到最长序列的最大值即可
        int index = 0;
        for (int i = 0; i < dp.length; i++) {
            if (dp[i] > max) {
                max = dp[i];
                index = nums[i];
            }
        }
        int[] num = new int[max];
        int j = 0;
        // 找出当前的一个序列
        for (int i = index - max + 1; i <= index; i++) {
            num[j++] = i;
        }
        return num;
    }

set方式解决

这个的主要思路就是值从最小的开始溯源，每一个最短的长度为1，只要存在比自己小的，自己肯定不是连续的里面最小的一个，此时直接跳过，直到找到不存在比自己小的元素，此时开始遍历，遍历的话只找到比自己大1的，然后递归迭代的方式找寻到所有的长度

	// O(n) 这个如果最小值是在最后的话，可能的时间复杂度是O(n^2)
    public int longestConsecutiveIII(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        Set<Integer> set = new HashSet<>();
        for (int num : nums) {
            set.add(num);
        }
        int longest = 0;
        int current;
        for (Integer num : set) {
            int longLen = 1; // 最短为1,即只从最短的算
            // 那么当前数可能是最最小的的,从最小找到最大，然后当前数只要存在比自己晓得直接跳过
            if (!set.contains(num - 1)) {
                current = num;
                while (set.contains(current + 1)) {
                    current += 1;
                    longLen += 1;
                }
            }
            longest = Math.max(longest, longLen);
        }
        return longest;
    }

3. 小结

整个的思路在面试的时候只想到了Map形式，但是当时只知道去更新左右的两个，没想到更新左右个数边界的值，导致当前的连续最大值没有能够得到传递，最后的结果就是错了。这道题之前做过，但是现在面试的时候还是不会做。

Keep thinking, keep coding!