JavaScript|LeetCode|动态规划/贪心算法|646. 最长数对链

法1：动态规划
看了题解
想法：

1. 对所有数对pairs：按照每个数对的第一个数进行升序排列
2. 数组dp保存以pairs[i]结尾的最长数对链的长度
3. dp[i]的值：

• 若pairs[i][0] > pairs[j][1] (i > j)，则dp[i] = dp[j] + 1;
• 否则，dp[i] = dp[i];
  注：dp[j] >= dp[k] (j > k)

/** 
* @param {number[][]} pairs 
* @return {number} 
*/
var findLongestChain = function(pairs) {    
    // 将pairs按照每个数对的第一个数进行升序排列    
    pairs.sort(function(a, b){return a[0] - b[0]});    
    var i = 0, j = 0;    
    var dp = [];    
    for(i = 0; i < pairs.length; i++) {        
        dp[i] = 1; // 以pairs[i]结尾的最长数对链    
    }
    for(i = 1; i < pairs.length; i++) {        
        for(j = 0; j < i; j++) { 
            // 对pairs[i]之前的每个数对            
            if(pairs[j][1] < pairs[i][0]) {                
                dp[i] = dp[j] + 1;            
            }        
        }    
    }
    return Math.max.apply(null, dp);
};

法2：贪心算法
看了题解
想法：

1. 对所有数对pairs：按照每个数对的第二个数进行升序排列（数对链的最后一个数对的第二个数越小，后续能够接上的数对就越多）
2. 用cur保存当前数对链最后一个数对的第二个数，找到：第一个数大于cur的数对中，第二个数最小的数对加入数对链，更新cur

/** 
* @param {number[][]} pairs 
* @return {number} 
*/
var findLongestChain = function(pairs) {    
    // 将pairs按照每个数对的第二个数进行升序排列     
    pairs.sort(function(a, b){return a[1] - b[1]});    
    // cur表示当前数对链的最后一个数对的第二个数的值    
    // output为最长数对链长度    
    var i = 0, cur = pairs[0][1], output = 1;    
    for(i = 1; i < pairs.length; i++) {        
        if(pairs[i][0] > cur) {            
            cur = pairs[i][1]; // 更新cur            
            output++;       
        }    
    }    
    return output;
};