动态规划之最长子序列

最长数对链 

对每对数对下标为0的排序，遍历数对，使用动态规划记录最长数对

import java.util.Arrays;

class Solution {
    public static int findLongestChain(int[][] pairs) {
        for (int i = 1; i < pairs.length; i++) {
            for (int j = 0; j < i; j++) {
                if (pairs[i][0] < pairs[j][0]) {
                    int arr[] = new int[2];
                    arr = pairs[i];
                    pairs[i] = pairs[j];
                    pairs[j] = arr;
                }
            }
        }
        int dp[] = new int[pairs.length];
        Arrays.fill(dp, 1);
        for (int i = 0; i < pairs.length; i++) {
            for (int j = 0; j < i; j++) {
                if (pairs[j][1] < pairs[i][0]) {
                    dp[i] = Math.max(dp[j] + 1, dp[j]);
                }
            }
        }
        Arrays.sort(dp);
        return dp[dp.length - 1];
    }
}

 

最长定差子序列

遍历数组，存储当前左边所有数的最大的等差数列长度。 

如果当前数左边不存在与当前数存在定差的数，则返回默认值0+1.

class Solution {
    public int longestSubsequence(int[] arr, int difference) {
        Map<Integer, Integer> dp = new HashMap<>();
        int ans = 1;
        for (int v : arr) {
            dp.put(v, dp.getOrDefault(v - difference, 0) + 1);
            ans = Math.max(ans, dp.get(v));
        }
        return ans;
    }
}

最长等差数列 

同上一题，不过没有给等差数列的差值，可以自己遍历 

class Solution {
    public static int longestArithSeqLength(int[] nums) {
        int ans = -1;
        for (int dif = -500; dif <= 500; dif++) {
            Map<Integer, Integer> dp = new HashMap<>();
            for (int num : nums) {
                dp.put(num, dp.getOrDefault(num - dif, 0) + 1);
                ans = Math.max(ans, dp.get(num));
            }
        }
        return ans;
    }
}