646. Maximum Length of Pair Chain（动态规划 vs 贪心）

最新推荐文章于 2022-06-16 18:58:05 发布

stsfang

最新推荐文章于 2022-06-16 18:58:05 发布

阅读量220

点赞数

分类专栏： LeetCode 文章标签：动态规划贪心算法

本文链接：https://blog.csdn.net/w_bu_neng_ku/article/details/78419576

版权

LeetCode 专栏收录该内容

69 篇文章 0 订阅

订阅专栏

1.Description

You are given n pairs of numbers. In every pair, the first number is always smaller than the second number.

Now, we define a pair (c, d) can follow another pair (a, b) if and only if b < c. Chain of pairs can be formed in this fashion.

Given a set of pairs, find the length longest chain which can be formed. You needn’t use up all the given pairs. You can select pairs in any order.

Example 1:

Input: [[1,2], [2,3], [3,4]]
Output: 2

Explanation: The longest chain is [1,2] -> [3,4]
Note:
The number of given pairs will be in the range [1, 1000].

2.Analysis

其实这道题的解法更像是贪心，先对pairs排序，排序根据pair对的second变量递增排序。再进行遍历，当新的pairs <ai+1,bi+1> <script type="math/tex" id="MathJax-Element-1"> </script>，如果前面存在 <script type="math/tex" id="MathJax-Element-2"> </script>，在 $a_{i+1}$ 不小于 $a_i$ 的情况下，可以将pair加入，一旦小于则会使当前的pair链规模减小，达不到最大的要求。

3.Code

C++ 贪心

class Solution {
public:
    static bool compare(const vector<int>& a, const vector<int>& b) {
        return a[1] < b[1]? true :false;
    }

    int findLongestChain(vector<vector<int> >& pairs) {
       if(pairs.size() == 0) return 0;


       vector<vector<int> > res;

       //根据second对pairs排序 
       sort(pairs.begin(),pairs.end(), compare);
       vector<int> min = pairs[0];
       res.push_back(min);
       int count = 1;
       for(int i = 1; i < pairs.size(); i++) {
       //在不减少结果规模时插入向量尾
            if(pairs[i][0] > min[1]) {
                res.push_back(pairs[i]);
                min = pairs[i];
                count++;
            }
       }

       return count;
    }

};

Java 动态规划

    public int findLongestChain(int[][] pairs) {
        if (pairs == null || pairs.length == 0) return 0;
        Arrays.sort(pairs, (a, b) -> (a[0] - b[0]));
        int[] dp = new int[pairs.length];
        Arrays.fill(dp, 1);
        for (int i = 0; i < dp.length; i++) {
            for (int j = 0; j < i; j++) {
                dp[i] = Math.max(dp[i], pairs[i][0] > pairs[j][1]? dp[j] + 1 : dp[j]);
            }
        }
        return dp[pairs.length - 1];
    }