leetcode 646. 最长数对链(Maximum Length of Pair Chain)

最新推荐文章于 2020-11-04 17:02:58 发布

原创最新推荐文章于 2020-11-04 17:02:58 发布 · 276 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

109 篇文章

订阅专栏

本文探讨了在给定的数对集合中寻找最长数对链的问题，通过预排序和动态规划方法，详细讲解了一种高效算法实现。文章提供了代码示例，包括使用单调队列+DP和快速排序的解决方案，旨在帮助读者理解和掌握这一经典算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给出 n 个数对。在每一个数对中，第一个数字总是比第二个数字小。

现在，我们定义一种跟随关系，当且仅当 b < c 时，数对(c, d) 才可以跟在 (a, b) 后面。我们用这种形式来构造一个数对链。

给定一个对数集合，找出能够形成的最长数对链的长度。你不需要用到所有的数对，你可以以任何顺序选择其中的一些数对来构造。

示例 :

输入: [[1,2], [2,3], [3,4]]
输出: 2
解释: 最长的数对链是 [1,2] -> [3,4]

注意：

给出数对的个数在 [1, 1000] 范围内。

原题链接

这题比LIS多了个预排序，另外还有一种效率高一些的做法，快排？

leetcode 300. 最长上升子序列(Longest Increasing Subsequence) 单调队列+dp

class Solution {
	static class Tuple implements Comparable<Tuple>{
		int a,b;
		public Tuple(int a,int b) {
			this.a = a;
			this.b = b;
		}
		@Override
		public int compareTo(Tuple o) {
			return this.b - o.b;
		}
		
	}
	
    public static int findLongestChain(int[][] pairs) {
        int n = pairs.length;
        Tuple[] T = new Tuple[n];
        for(int i=0;i<n;i++)
        	T[i] = new Tuple(pairs[i][0],pairs[i][1]);
        Arrays.sort(T);
        int[] dp = new int[n];
        for(int i=0;i<n;i++)
            dp[i] = 1;
        for(int i=1;i<n;i++)
            for(int j=0;j<i;j++)
                if(T[i].a>T[j].b)
                    dp[i] = Math.max(dp[i],dp[j]+1);
        int max = 0;
        for(int i=0;i<n;i++)
            max = Math.max(dp[i],max);
        return max;        
    }
}

更简洁

class Solution {
	public int findLongestChain(int[][] pairs) {
		if(pairs == null || pairs.length == 0)
			return 0;
		Arrays.sort(pairs, new Comparator<int[]>() {
			@Override
			public int compare(int[] o1, int[] o2) {
				return o1[1] - o2[1];
			}
		});
		int maxLen = 1;
		int curEnd = pairs[0][1];
		for(int i = 1; i < pairs.length; i++) {
			if(pairs[i][0] > curEnd) {
				curEnd = pairs[i][1];
				maxLen++;
			}
		}
		return maxLen;
	}
}

beat 100%

class Solution {
public int findLongestChain(int[][] pairs) {
        if (pairs.length == 0) {
            return 0;
        }
        if (pairs.length == 1) {
            return 1;
        }
        quickSort(pairs, 0, pairs.length - 1);
        int count = 1;
        int foot = pairs[0][1];
        for (int i = 1; i < pairs.length; i++) {
            if (pairs[i][0] > foot) {
                foot = pairs[i][1];
                count++;
            }
        }
        return count;
    }

    private void quickSort(int[][] pairs, int i, int j) {
        if (j > i) {
            int mid = getMid(pairs, i, j);
            quickSort(pairs, i, mid - 1);
            quickSort(pairs, mid + 1, j);
        }
    }

    private int getMid(int[][] pairs, int i, int j) {
        int[] temp = pairs[i];
        while (i < j) {
            while (i < j && pairs[j][1] > temp[1]) {
                j--;
            }
            if (i < j) {
                int[] value = pairs[i];
                pairs[i] = pairs[j];
                pairs[j] = value;
            }
            while (i < j && pairs[i][1] <= temp[1]) {
                i++;
            }
            if (i < j) {
                int[] value = pairs[i];
                pairs[i] = pairs[j];
                pairs[j] = value;
            }
        }
        pairs[i] = temp;
        return i;
    }
}