思路：注意审题，这个题不是随意取字母组成单词，而是连起来能组成单词，因此哈希表不合理，因为哈希表存储会损坏原始board的拓扑结构

public class Solution {
    
    

    private static final int[][] DIRECTIONS = {
    
    {
    
    -1, 0}, {
    
    0, -1}, {
    
    0, 1}, {
    
    1, 0}};
    private int rows;
    private int cols;
    private int len;
    private boolean[][] visited;
    private char[] charArray;
    private char[][] board;

    public boolean exist(char[][] board, String word) {
    
    
        rows = board.length;
        if (rows == 0) {
    
    
            return false;
        }
        cols = board[0].length;
        visited = new boolean[rows][cols];

        this.len = word.length();
        this.charArray = word.toCharArray();
        this.board = board;
        for (int i = 0; i < rows; i++) {
    
    
            for (int j = 0; j < cols; j++) {
    
    
                if (dfs(i, j, 0)) {
    
    
                    return true;
                }
            }
        }
        return false;
    }

    private boolean dfs(int x, int y, int begin) {
    
    
        if (begin == len - 1) {
    
    
            return board[x][y] == charArray[begin];
        }
        if (board[x][y] == charArray[begin]) {
    
    
            visited[x][y] = true;
            for (int[] direction : DIRECTIONS) {
    
    
                int newX = x + direction[0];
                int newY = y + direction[1];
                if (inArea(newX, newY) && !visited[newX][newY]) {
    
    
                    if (dfs(newX, newY, begin + 1)) {
    
    
                        return true;
                    }
                }
            }
            visited[x][y] = false;
        }
        return false;
    }

    private boolean inArea(int x, int y) {
    
    
        return x >= 0 && x < rows && y >= 0 && y < cols;
    }
}

所谓回溯，就是递归的过程中判断是否出现错误，出现错误就返回

class Solution {
    
    
    public int lengthOfLIS(int[] nums) {
    
    
        int len = nums.length;
        if(len==0) return 0;
        if(len==1) return 1;
        int[] dp = new int[len];
        int res = 0;
        Arrays.fill(dp,1);
        for(int i=0; i<len; i++){
    
    
            for(int j=0; j<i; j++){
    
    
                if(nums[i]>nums[j]){
    
    
                    dp[i] = Math.max(dp[i],dp[j]+1);
                }
                res = Math.max(res, dp[i]);
            }
        }
        return res;
    }
}