【LeetCode练习】[中等] 300. 最长上升子序列(dp)

【LeetCode练习】[中等]300. 最长上升子序列

300. 最长上升子序列

300. 最长上升子序列

算法思想：动态规划

题目：

java代码–转换成LCS问题

蛮力，，，将原数组排序生成新数组，寻找两个数组的最长公共子序列，即为最长上升子序列，，，特别蛮力，效率很低

要特别注意，重复元素的问题，要去重

class Solution {
    public int lengthOfLIS(int[] nums) {
		int n = nums.length;
        int[] sortNums = Arrays.copyOf(nums, n);//排序
        Arrays.sort(sortNums);
        int[][] dp = new int[n+1][n+1];
        for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				if (j > 1 && sortNums[j-2] == sortNums[j-1]) {//如果当前元素与上一个元素相同,则不进行+!操作,因为形同不能判断为上升;
					dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
				}else if (nums[i-1] == sortNums[j-1]) {//相同,+1
					dp[i][j] = dp[i-1][j-1] + 1;
				}else {
					dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);//不同,保留最大的长度答案即可
				}
			}
		}
        return dp[n][n];
    }
}

java代码–动态规划

效率依旧不是很高,在向前遍历中,可以更加优化成二分查找比当值小数中的最大数,效率会更高;

class Solution {
    public int lengthOfLIS(int[] nums) {
		int n = nums.length;
        int[] dp = new int[n];//dp数组
        int max = 0;
        for (int i = 0; i < n; i++) {
        	dp[i] = 1;
			for (int j = 0; j < i; j++) {//向前遍历,寻找各个数中最大的上升序列
				if (nums[i] > nums[j]) {//满足上升条件
					dp[i] = Math.max(dp[i], dp[j]+1);//+1
				}
			}
			max = Math.max(max, dp[i]);//求序列的最大长度
		}
        return max;
    }
}

java代码–动态规划,二分查找

不是太想的明白,再寻思寻思,再写注解吧

假设序列为:{4,2,3,1,5}

class Solution {
    public int lengthOfLIS(int[] nums) {
        int[] tails = new int[nums.length];
        int res = 0;//最长公共子序列的长度
        for(int num : nums) {
            int i = 0, j = res;
            while(i < j) {
                int m = (i + j) / 2;
                if(tails[m] < num) i = m + 1;
                else j = m;
            }
            tails[i] = num;
            if(res == i) res++;
        }
        return res;
    }
}