不同路径 [DFS记忆化数组 & 动态规划]

前言

DFS作为深度优先遍历，经常碰到需要一节点多次被遍历的情况，导致时间复杂度呈指数级。往往重复遍历目的就不是单词的访问节点了，而是需要该节点到某终点的一种状态（抽象），可用变量记录该节点的状态，将下一次dfs终止在此处，大大降低时间复杂度，这就是记忆化搜索。而记忆化搜索往往和动态规划关联。

一、不同路径

二、dfs & dp

dfs靠着高时间复杂度，尽量少浪费空间。而其指数级复杂度往往不合题意，则需要用空间换时间，采用dp来递推问题。

1、记忆化数组

/*
    target：从一个格子到另一个格子的不同路径数。
    限制：只能走右和下。
    idea1：直接dfs，能走到末尾，就return 1，回溯时把return回来的路径相加，即为某点出发的不同路径数。
    idea2：右走和下走，也会导致走到同一个格子，所以有些格子被dfs了很多次，所以用一个数组来记录已被计算过的路径数。
    idea3：dfs回溯时把每个格子当起点，如果把每个格子当作终点，由于右走和下走，所以每个格子的路径数是左边格子和上面格子的路径数之和。
     */
    // idea2:dfs + 数组。
    public int uniquePaths(int m, int n) {
        int[][] f = new int[m][n];// 记录以<i,j>为起点，<m-1,n-1>为终点的不同路径数。

        return dfs(f, 0, 0, m, n);
    }

    private int dfs(int[][] f, int i, int j, int m, int n) {
        // 越界，结束递归。
        if (i == -1 || -1 == j || j == n || i == m) return 0;
        // 达到终点，返回需要的1，结束递归。
        if (i == m - 1 && n - 1 == j) return 1;
        // 该格子到终点的不同路径数，已经计算过，直接返回。
        if (f[i][j] != 0) return f[i][j];
        // 回溯计算不同路径数，并记录到该格子的状态里。
        return f[i][j] = dfs(f, i + 1, j, m, n) + dfs(f, i, j + 1, m, n);
    }

2、动态规划

// idea3:动态规划。
    public int uniquePaths2(int m, int n) {
        // 状态定义，f[i][j]表示第<i,j>个格子作为终点的不同路径数。
        int[][] f = new int[m + 1][n + 1];
        // 初始化，f[0][0] = f[i][0] = f[0][j] = 0;f[1][1] = 1;
        f[1][1] = 1;
        // 状态转移：f[i][j] = f[i - 1][j] + f[i][j - 1];
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (i == 1 && 1 == j) continue;

                f[i][j] = f[i - 1][j] + f[i][j - 1];
            }
        }

        // 最终状态：f[m][n]表示以第<m,n>个格子作为终点的不同路径数，正和题目意。
        return f[m][n];
    }

3、状态压缩

// idea3:动态规划 + 状态压缩（优化）。
    // 后面的需要前面的，这层的需要上一层的，所以定义列状态。
    public int uniquePaths3(int m, int n) {
        int[] f = new int[n + 1];// 状态定义，用1行n列记录上层状态即可，从左到右进行滚动更新。
        f[1] = 1;// 初始化。
        // 状态转移，f[j] += f[j - 1];<自身f[j]:上一层> <f[j - 1]:左边格子状态>
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (i == 1 && 1 == j) continue;

                f[j] += f[j - 1];
            }
        }
        // 最终状态：第m行的第n列格子作为终点的不同路径数。
        return f[n];
    }

总结

1）记忆化数组，本质：空间换时间，将一些需要的状态记住，用O(1)的时间得到相要的状态。

2）动态规划，往往出现在DFS超时问题中，空间换时间，将大问题分解成规模更小性质相同的子问题进行递推。状态的定义就是围绕着能递推定义的。