动态规划24（1964找出到每个位置为止最长的有效障碍赛跑路线）

从月亮走向月亮7

已于 2023-11-01 15:19:36 修改

阅读量51

点赞数

文章标签：动态规划算法

于 2023-11-01 09:49:57 首次发布

本文链接：https://blog.csdn.net/stacey777/article/details/134154775

版权

class Solution {
    public int[] longestObstacleCourseAtEachPosition(int[] obstacles) {
        int n = obstacles.length;
        int[] dp = new int[n];
        dp[0] = 1;
        for(int i=1;i<n;i++){
            dp[i] = 1;
            for(int j=0;j<i;j++){
                if(obstacles[i]>=obstacles[j]){
                    dp[i] = Math.max(dp[i],dp[j]+1);
                }
            }
        }
        for(int i=0;i<n;i++){
            System.out.println(dp[i]);
        }
        int[] dp2 = new int[n];
        for(int i=0;i<n;i++){
            dp2[i]=1;
            for(int j=0;j<i;j++){
                if(obstacles[j]<=obstacles[i]){
                    dp2[i] = Math.max(dp2[i],dp[j]+1);
                }
            }
        }
        return dp2;
    }
}

二分查找不超时版：

class Solution {
    public int lengthOfLIS(int[] nums) {
        int len = 1,n = nums.length;
        if(n==0){
            return 0;
        }
        int[] d = new int[n+1];
        d[len] = nums[0];
        for(int i=1;i<n;i++){
            if(nums[i]>d[len]){
                len++;
                d[len] = nums[i];
            }else{
                int l=1,r=len,pos=0;
                while(l<=r){
                    int mid = (l+r)/2;
                    if(d[mid]<nums[i]){
                        pos = mid;
                        l = mid + 1;
                    }else{
                        r = mid - 1;
                    }
                }
                d[pos+1] = nums[i];
            }
        }
        return len;
    }
}