最大递增链

 

思路：暴力尝试加缓存法

dp是从简单状态推到复杂位置的过程，
这个模型位置相互依赖不好推导，用傻缓存就好

 

  public int solution(int[][] grids){
        int ans=0;
        int[][] dp=new int[grids.length][grids[0].length];
        for(int i=0;i<grids.length;i++){
            for(int j=0;j<grids[0].length;j++){
                ans=Math.max(ans,process(grids,i,j,dp));
            }
        }
        return ans;
    }

    //grids,i,j 出发，找最大递增链
    public int process(int[][] grids,int i,int j,int[][] dp){
        if(dp[i][j]!=0){
            return dp[i][j];
        }
        // i-1,j  i+1,j  i,j-1  i,j+1  max
        int next1=0;
        int next2=0;
        int next3=0;
        int next4=0;
        if(i-1>=0 && grids[i-1][j] >grids[i][j]){
            next1=process(grids,i-1,j,dp);
        }
        if(i+1<grids.length && grids[i+1][j] >grids[i][j]){
            next2=process(grids,i+1,j,dp);
        }

        if(j-1>=0 && grids[i][j-1] >grids[i][j]){
            next3=process(grids,i,j-1,dp);
        }

        if(j+1<grids[0].length && grids[i][j+1] >grids[i][j]){
            next4=process(grids,i,j+1,dp);
        }


        int ans= 1+ Math.max(Math.max(next1,next2),Math.max(next3,next4));
        dp[i][j]=ans;
        return  ans;

    }

　　

　　

674. 最长连续递增序列

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。

 

示例 1：

输入：nums = [1,3,5,4,7]
输出：3
解释：最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为 5 和 7 在原数组里被 4 隔开。

class Solution {
   public int findLengthOfLCIS(int[] nums) {
        int ans=0;
        int[] dp=new int[nums.length];
        for(int i=0;i<nums.length;i++){
            ans=Math.max(ans,process2(nums,i,dp));
        }
        return ans;
    }

    //1 3 5 4 7
    //nums  i find
    public int process2(int[] nums,int i,int[] dp){
        if(dp[i]!=0){
            return dp[i];
        }
        // i+1
        int next=0;
        if(i+1<nums.length && nums[i+1]>nums[i]){
            next=process2(nums,i+1,dp);
        }
        int ans= 1+next;
        dp[i]=ans;
        return ans;
    }
}