一、树形DP

1、题目内容

在这里插入图片描述

2、状态划分

（1）存储

用二叉树进行存储

（2）状态集合划分

f[u][0] ：所有人以 u 为根的子树中选，并且不选u这个点的方案。
f[u][1] ：所有人以 u 为根的子树中选，并且选u这个点的方案。

3、题解

import java.util.*;
import java.io.*;

public class Main{
    static int N = 6010;
    static int idx = 0;
    static int[] happy = new int[N];
    static int[] h = new int[N];
    static int[] e = new int[N];
    static int[] ne = new int[N];
    static int[][] f = new int[N][2];
    static boolean[] h_father = new boolean[N];
    
    static void add(int a, int b){      // 单链表进行存储，将a接在b的后面
        e[idx] = b;
        ne[idx] = h[a];
        h[a] = idx++;
    }
    
    static void dfs(int u){
        f[u][1] = happy[u];         // 初始化，选择u节点则，则此处值为happy值
        
        for(int i = h[u]; i != -1; i = ne[i]){      // 遍历u节点下面的节点
            int j = e[i];
            dfs(j);                 // dfs进一步求解
            
            f[u][0] = f[u][0] + Math.max(f[j][0] ,f[j][1]);     // 不选择u节点，则u节点总的快乐指数
            f[u][1] = f[u][1] + f[j][0];                        // 选择u节点，则快乐指数为
            // u节点的快乐指数是由下面的节点选择来决定一部分的
        }
    }
    
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        
        Arrays.fill(h, - 1);
        
        String str1 = in.readLine();
        int n = Integer.parseInt(str1);
        
        for(int i = 1; i <= n; i++){
            String str2 = in.readLine();
            happy[i] = Integer.parseInt(str2);          // happy节点大小
        }
        
        for(int i = 0; i < n - 1; i++){
            String[] str3 = in.readLine().split(" ");
            int a = Integer.parseInt(str3[0]);
            int b = Integer.parseInt(str3[1]);
            h_father[a] = true;         // 说明a节点有父节点了，还不会停下
            add(b, a);
        }
        
        int root = 1;
        while(h_father[root]){
            root++;             // 整棵树的大小
        }
        
        dfs(root);              // 树的最顶层
        
        System.out.println(Math.max(f[root][0],f[root][1]));        // 选择最顶层的节点进行是否选择的判断
        
    }
}

二、记忆化搜索

1、题目内容

在这里插入图片描述

2、状态划分

（1）状态编号

f[i][j]：所有从（i, j）开始滑的路径

（2）状态划分

在满足高低条件情况下，对上下左右进行遍历

在这里插入图片描述

3、题解

import java.util.*;
import java.io.*;

public class Main{
    static int N = 310;
    static int n,m;
    static int[][] h = new int[N][N];
    static int[][] f = new int[N][N];
    static int[] dx = {-1, 0, 1, 0};
    static int[] dy = {0, 1, 0, -1};
    
    static int dp(int x, int y){
        
        if(f[x][y] != -1){
            return f[x][y];
        }
        
        f[x][y] = 1;        
        // 说明还没有算过，需要重新初始化为1，因为最差是遍历自己一遍，也就是自己只滑了自己这一个格子
        
        for(int i = 0; i < 4; i++){
            int a = x + dx[i];  //表示上下左右
            int b = y + dy[i];
            
            if(a >= 1 && a <= n && b >= 1 && b <= m && h[a][b] < h[x][y]){      // 不可以等于，因为必须是低于才可以
                f[x][y] = Math.max(f[x][y], dp(a, b) + 1);      // 寻找 fxy 和 推掉一个点到ab+1之间谁是最大
            }
        }
        
        return f[x][y];
    }
    
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

        String[] str1 = in.readLine().split(" ");
        n = Integer.parseInt(str1[0]);
        m = Integer.parseInt(str1[1]);
        
        for(int i = 0; i < N; i++){
            Arrays.fill(f[i], - 1);        
            // 初始化为 -1 判断是否dp计算过滑雪距离，因为递归的存在，让其可以完美找到最低点
        }
        
        for(int i = 1; i <= n ; i++){
            
            String[] str2 = in.readLine().split(" ");
            for(int j = 1; j <= m; j++){
                h[i][j] = Integer.parseInt(str2[j - 1]);
            }
        }
        
        int res = 0;
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                res = Math.max(res, dp(i, j));      // 递归存在，完美找到最低点，然后遍历上来
            }
        }
        
        
        System.out.println(res);

    }
}