题目:
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].
思路:
1、动态规划:
首先对pairs进行正常排序,然后定义dp[i]表示以第i个pair为结尾的最长pair chain的长度,那么递推公式为:dp[i] = max(dp[j] + 1), j < i并且dp[j][1] < dp[i][0]。计算出每个dp值之后,返回dp数组中的最大值即可。算法的空间复杂度是O(n),时间复杂度是O(n^2)。
2、贪心法:
如果我们采用另外一种排序方法,也就是按照pairs的第二个数进行升序排序,那么还可以用更简单的贪心算法:我们依次遍历,如果当前的pair能够连接到上一个pair,就连接,否则就跳过。这是因为最终的pair chain一定是目前这种排序后的序列的一个子序列(可以用反证法证明),所以对于每个节点而言,我们要么不连接它,要么连接它。如果能连接,我们就连接。为什么呢?这是因为如果不连接该点,那么pairs数组中的下一个节点的end point比当前一定更靠后(因为这就是排序依据),所以导致能连接到的最终pair个数不会比选择连接当前节点更长。贪心算法本身的时间复杂度是O(n),但是由于贪心之前还需要排序,所以整体算法的时间复杂度是O(nlogn)。空间复杂度可以做到O(1)。
代码:
1、动态规划:
class Solution {
public:
int findLongestChain(vector<vector<int>>& pairs) {
sort(pairs.begin(), pairs.end());
vector<int> dp(pairs.size(), 1);
for (int i = 1; i < dp.size(); ++i) {
for (int j = 0; j < i; ++j) {
if (pairs[j][1] < pairs[i][0]) {
dp[i] = max(dp[i], dp[j] + 1);
}
}
}
return *(max_element(dp.begin(), dp.end()));
}
};
2、贪心法:
class Solution {
public:
int findLongestChain(vector<vector<int>>& pairs) {
sort(pairs.begin(), pairs.end(), cmp);
int cnt = 0;
vector<int>& pair = pairs[0];
for (int i = 0; i < pairs.size(); i++) {
if (i == 0 || pairs[i][0] > pair[1]) { // pairs[i][0] can be behind pair
pair = pairs[i];
cnt++;
}
}
return cnt;
}
private:
static bool cmp(vector<int>& a, vector<int>&b) {
return a[1] < b[1] || a[1] == b[1] && a[0] < b[0];
}
};