Longest Increasing Continuous subsequence1,2（数组和矩阵）

1. 在数组中查找dp

public int findLengthOfLCIS(int[] nums) {
	if (nums.length == 0) return 0;        
	int[] dp = new int[nums.length];        
	Arrays.fill(dp, 1);        
	int max = 1;        
	for (int i = 1; i < nums.length; ++i) {
		if (nums[i] > nums[i - 1]) {  
			dp[i] = dp[i - 1] + 1;       	
		}           
		max = Math.max(max, dp[i]);  
         }     
	return max;    
	}

2. 在矩阵中查找，动态规划+DFS

public class Solution {
    public int longestIncreasingContinuousSubsequenceII(int[][] A) {
        int rows = A.length;
        if (rows == 0) 
            return 0;
        int cols = A[0].length;
        boolean[][] visited = new boolean[rows][cols];
        int[][] dp = new int[rows][cols];
        int max = 1;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (dp[i][j] == 0) 
                    dfs(A, visited, dp, i, j);
                max = Math.max(max, dp[i][j]);
            }
        }
        return max;
    }
    
    public void dfs(int[][] A, boolean[][] visited, int[][] dp, int row, int col) {
        if (visited[row][col]) 
            return;
        visited[row][col] = true;
        int[][] dirs = new int[][]{{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
        int max = 0;
        
        // 对符合要求的邻居分别DFS
        for (int i = 0; i < dirs.length; i++) {
            int x = row + dirs[i][0];
            int y = col + dirs[i][1];
            if (x >= 0 && x < dp.length && y >= 0 && y < dp[0].length && A[x][y] > A[row][col]) {
                dfs(A, visited, dp, x, y);
                max = Math.max(max, dp[x][y]);
            }
        }
        dp[row][col] = max + 1; // 根据邻居DFS后最大值更新自己的值
    }
}