Leetcode 646

Maximum Length of Pair Chain

找出最长递增子对，因为有数的大小问题，所以应该要先排序一边，按照子对的第二个数从小到大排序，本来想要直接使用sort函数，但是这个是vector<vector<int>>类型，所以还是自己写了一个冒泡来排序，应该也是因为这里速度比较慢，因为冒泡时间复杂度是O(n^2)的。
算法描述：用了两个数组，一个用来记录当前最小的子对的第二个数num，一个用来记录当前最大的子序列长度dp。对于一个数i，每一次比对从0到i-1的数j，如果大于num[j]并且dp[j] + 1 > dp[i]，那么dp[i] = dp[j] + 1，最后返回dp[n-1]即可，以下是代码：

class Solution {
public:
    int findLongestChain(vector<vector<int>>& pairs) {
        if(pairs.empty()) return 0;
        vector<int> dp(1010, 1), num(1010, 0);
        int res = 1, n = pairs.size();
       for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (pairs[i][1] > pairs[j][1]) {
                    int a = pairs[i][0], b = pairs[i][1];
                    pairs[i][0] = pairs[j][0], pairs[i][1] = pairs[j][1];
                    pairs[j][0] = a, pairs[j][1] = b;
                }
            }
        }
        num[0] = pairs[0][1];
        for (int i = 1; i < n; i++) {
            num[i] = pairs[i][1];
            for (int j = i - 1; j >= 0; j--) {
                if(num[j] < pairs[i][0]  && dp[j] + 1 > dp[i]) {
                    dp[i] = dp[j] + 1;
                    num[i] = pairs[i][1];
                }
            }
            res = max(dp[i], res);
        }
        return res;
    }
};

开始写总结的时候，意识到num数组是多余的，因为数对已经排过序了，只需要每一次比对i的第一个数是否大于j的第二个数并且dp[i]<dp[j]+1就可以了。
以下是代码：

class Solution {
public:
    int findLongestChain(vector<vector<int>>& pairs) {
        if(pairs.empty()) return 0;
        vector<int> dp(1010, 1);
        int n = pairs.size();
       for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (pairs[i][1] > pairs[j][1]) {
                    int a = pairs[i][0], b = pairs[i][1];
                    pairs[i][0] = pairs[j][0], pairs[i][1] = pairs[j][1];
                    pairs[j][0] = a, pairs[j][1] = b;
                }
            }
        }
        for (int i = 1; i < n; i++) {
            for (int j = i - 1; j >= 0; j--) {
                dp[i] = max(dp[i], pairs[j][1] < pairs[i][0] ? dp[j] + 1: dp[j]);
            }
        }
        return dp[n-1];
    }
};