数组相关算法题

128.：Longest Consecutive Sequence
给定一个未排序的整数数组，找出最长连续序列的长度。

要求是O（n），所以不能使用排序，那么就得考虑辅助。利用Map，key为num，value为其连续长度，每次之更新这个连续序列的首尾两个位置的value值。

    public int longestConsecutive(int[] nums) {
        Map<Integer, Integer> map = new HashMap<>();
        int max = 0;
        for(int num : nums){
            if (map.containsKey(num)) continue;
            Integer leftLn = map.get(num-1);
            Integer rightLn = map.get(num+1);
            int ln = 1;
            if (leftLn != null && rightLn != null) {
                ln = leftLn+rightLn+1;
                map.replace(num-leftLn, ln);
                map.replace(num+rightLn, ln);
                map.put(num, ln);
            }
            else if(leftLn != null) {
                ln = leftLn+1;
                map.replace(num-leftLn, ln);
                map.put(num, ln);
            }
            else if (rightLn != null){
                ln = rightLn+1;
                map.replace(num+rightLn, ln);
                map.put(num, ln);
            }
            else {
                map.put(num, ln);
            }
            max = Math.max(max, ln);
        }
        return max;
    }

解法2：
辅助空间选择Set，看中其不含重复元素的特性，先遍历一遍全部加进来，再遍历一边删除num及其连续序列，算法也是O(n)，因为总共只有n个元素可删除。

    public int longestConsecutive2(int[] nums) {
        Set<Integer> set = new HashSet<>();
        for (int num : nums){
            set.add(num);
        }
        int max = 0;
        for(int num : nums) {
            if (!set.remove(num)) continue;
            int lt = num-1, rt = num+1;
            while (set.remove(lt)) lt--;
            while (set.remove(rt)) rt++;
            max = Math.max(max, rt-lt-1);
        }
        return max;
    }

198.： 打家劫舍
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

概括起来：一个数组求不相邻数的最大和，例如大小为四的数组，最大和的可能只有三种arr[0]+arr[2]，arr[1]+arr[3]，arr[0]+arr[3]，它们种最大值就是最大和的值。
题目很简单，动态规划，dp[ i ]表示arr[0 ~ i ] 的最大和，则dp[ i + 1 ] = max(dp[ i ] , dp[ i - 1 ] + arr[ i+1 ])

    public int rob(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        if (nums.length == 1) return nums[0];
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        for(int i = 2; i < nums.length; i++) {
            dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i]);
        }
        return dp[nums.length-1];
   }

另外还有种解法，这种解法困扰我很久，没想明白为什么？后来从动态规划也就是上面这种解法的思路，解开了疑惑，说白了该种解法就是使用两个变量来代替dp数组。

    public int rob(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        // odd和even的含义与dp[i]的含义一样
        int odd = 0, even = 0;
        for(int i = 0; i < nums.length; i++) {
            if((i & 1) == 0) even = Math.max(even+nums[i], odd);
            else odd = Math.max(even, odd+nums[i]);
        }
        return Math.max(odd, even);
    }

416.,分割等和子集
给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

题目经分析后变为：数组总和sum必须为偶数，求数组是否含有和为sum/2的子序列。
解法一：动态规划
dp[ i ][ j ]的含义是：表示nums[0 - i-1]组成 J 值的可能性。
它的值为：1）nums[ 0 ~ i-2 ]组成 J 的可能性，即dp[ i-1 ][ j ]。
2）j >= nums[i-1]的情况下，nums[ 0 ~ i-2 ]组成 j-nums[i-1] 的可能性，即
dp[ i-1 ][ j-nums[i-1] ]

    public boolean canPartition(int[] nums) {
         if(nums == null) return false;
         int sum = 0;
         for(int num : nums) sum += num;
         if((sum & 1) == 1) return false;
         sum /= 2;
         // dp[i][j]表示nums[0 - i-1]组成 j 值的可能性
         boolean[][] dp = new boolean[nums.length+1][sum+1];
         dp[0][0] = true;

         for(int i = 1; i < dp.length; i++){
             for(int j = 1; j < dp[0].length; j++){
                 dp[i][j] = dp[i-1][j];
                 if(j >= nums[i-1]){
                     dp[i][j] = dp[i][j] || dp[i-1][j-nums[i-1]];
                 }
             }
         }
         return dp[nums.length][sum];
    }

分析后可以进行空间压缩

    public boolean canPartition2(int[] nums) {
        if(nums == null) return false;
        int sum = 0;
        for(int num : nums) sum += num;
        if((sum & 1) == 1) return false;
        sum /= 2;
        boolean[] dp = new boolean[sum+1];
        dp[0] = true;
        for(int num : nums){
            for(int j = sum; j >= num; j--){
                dp[j] = dp[j] || dp[j-nums[i-1]];
            }
        }
        return dp[sum];
    }

一开始分析题目时将问题转化后，可以看出，该题可以使用深度优先搜索的方式找出符合要求的序列。

    public boolean canPartition3(int[] nums) {
        if(nums == null) return false;
        int sum = 0;
        for(int num : nums) sum += num;
        if((sum & 1) == 1) return false;
        return recur(nums, sum/2, nums.length-1);
    }

    private boolean recur(int[] nums, int target, int index){
        if(target == 0) return true;
        if(index < 0 || target < 0) return false;
        // 找出包含 nums[index] 在内的所有序列中是否有符合要求的
        if(recur(nums, target-nums[index], index-1)) return true;
        
        // 排除重复值
        int j = index-1;
        while (j >= 0 && nums[j] == nums[index]) j--;
        // 抛弃nums[index]
        return recur(nums, target, j);
    }

646.，最长数对链
给出 n 个数对。 在每一个数对中，第一个数字总是比第二个数字小。

现在，我们定义一种跟随关系，当且仅当 b < c 时，数对(c, d) 才可以跟在 (a, b) 后面。我们用这种形式来构造一个数对链。

给定一个对数集合，找出能够形成的最长数对链的长度。你不需要用到所有的数对，你可以以任何顺序选择其中的一些数对来构造。

    public int findLongestChain(int[][] pairs) {
        if (pairs == null || pairs.length == 0) return 0;
        // 按尾进行排序
        Arrays.sort(pairs, Comparator.comparingInt(a -> a[1]));
        int res = 0; // 记录长度
        int last = Integer.MIN_VALUE; // 记录链尾
        for(int[] arr : pairs) {
            if (arr[0] > last) {
                res++;
                last = arr[1];
            }
        }
        return res;
    }