大盘涨停，见证历史

见证历史

不管你炒不炒股，这个国庆肯定没少听关于"炒股"的讨论，下楼买瓶水都能听到大爷大妈在聊开户。

以至于不少自媒体炒作，说国庆单日开户的人数多达 600W，能造这个谣的人大概是没有多少常识，对 600W 没概念，后来有"相对靠谱"的说法，说在中信建投后台看到有 140W 人在排队开户，不过也被中信建投辟谣了。

但从侧面不难看出，国民对于炒股这件事的讨论，确实达到了空前高度。

于是在舆论发酵了好几天，再叠加假期几天新加坡 A50 期货上涨 14%，恒生指数上涨 9.3%，恒生科技上涨 13.36% 的大背景，今天上证指数开盘直接涨停：

大盘涨停，这下是真的见证历史了。

前几天，不少人说上证宕机是见证历史，这有啥历史的，只要足够草台，有得你见的。

但大盘涨停是真多少有点不可思议，有投资经历的人会理解当中的离谱程度。

既然开局就是顶峰，那接下来的走势只有「封板」和「砸盘」两条路。

又因为不少股民的成本密集区是 3600~3700 点，那必然是有不少人会想解套离场，于是大盘开始往下。

但有意思的是，国庆开户的新人，最快也要明天才能进场呢，所以今天的大盘表现，会对明天摩拳擦掌的人造成什么心理影响，这是我感兴趣的。

不必客气，我花费万亿，给大家上演大型的"人类行为和社会心理学"的研究课题，答案明天揭晓

...

回归主题。

来一道和「动态规划」相关的算法题。

题目描述

平台：LeetCode

题号：576

给你一个大小为 m x n 的网格和一个球。球的起始坐标为 [startRow, startColumn]。

你可以将球移到在四个方向上相邻的单元格内（可以穿过网格边界到达网格之外）。

你「最多」可以移动 maxMove 次球。

给你五个整数 m、n、maxMove、startRow 以及 startColumn，找出并返回可以将球移出边界的路径数量。

因为答案可能非常大，返回对 ​ 取余 后的结果。

示例 1：

输入：m = 2, n = 2, maxMove = 2, startRow = 0, startColumn = 0

输出：6

示例 2：

输入：m = 1, n = 3, maxMove = 3, startRow = 0, startColumn = 1

输出：12

提示：

基本分析

通常来说，朴素的路径 DP 问题之所以能够使用常规 DP 方式进行求解，是因为只能往某一个方向（一维棋盘的路径问题）或者只能往某两个方向（二维棋盘的路径问题）移动。

这样的移动规则意味着，我们不会重复进入同一个格子。

「从图论的意义出发：将每个格子视为点的话，如果能够根据移动规则从 a 位置一步到达 b 位置，则说明存在一条由 a 指向 b 的有向边。」

「也就是说，在朴素的路径 DP 问题中，“单向”的移动规则注定了我们的图不存在环，是一个存在拓扑序的有向无环图，因此我们能够使用常规 DP 手段来求解。」

回到本题，移动规则是四联通，并不是“单向”的，在某条出界的路径中，我们是有可能重复进入某个格子，即存在环。

因此我们需要换一种 DP 思路进行求解。

记忆化搜索

通常在直接 DP 不好入手的情况下，我们可以先尝试写一个「记忆化搜索」的版本。

那么如果是让你设计一个 DFS 函数来解决本题，你会如何设计？

我大概会这样设计：

int dfs(int x, int y, int k) {}

重点放在几个「可变参数」与「返回值」上： 代表当前所在的位置， 代表最多使用多少步，返回值代表路径数量。

根据 DP-动态规划 第八讲 的学习中，我们可以确定递归出口为：

1. 当前到达了棋盘外的位置，说明找到了一条出界路径，返回 ；
2. 在条件 不满足的前提下，当剩余步数为 （不能再走下一步），说明没有找到一条合法的出界路径，返回 。

主逻辑则是根据四联通规则进行移动即可，最终答案为 dfs(startRow, startColumn, maxMove)。

Java 代码：

class Solution {
    int MOD = (int)1e9+7;
    int m, n, max;
    int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
    int[][][] cache;
    public int findPaths(int _m, int _n, int _max, int r, int c) {
        m = _m; n = _n; max = _max;
        cache = new int[m][n][max + 1];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k <= max; k++) {
                    cache[i][j][k] = -1;
                }
            }
        }
        return dfs(r, c, max);
    }
    int dfs(int x, int y, int k) {
        if (x < 0 || x >= m || y < 0 || y >= n) return 1;
        if (k == 0) return 0;
        if (cache[x][y][k] != -1) return cache[x][y][k];
        int ans = 0;
        for (int[] d : dirs) {
            int nx = x + d[0], ny = y + d[1];
            ans += dfs(nx, ny, k - 1);
            ans %= MOD;
        }
        cache[x][y][k] = ans;
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    int MOD = 1e9 + 7;
    int m, n, max;
    vector<vector<vector<int>>> cache;
    vector<vector<int>> dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    int findPaths(int _m, int _n, int _max, int r, int c) {
        m = _m; n = _n; max = _max;
        cache = vector<vector<vector<int>>>(m, vector<vector<int>>(n, vector<int>(max + 1, -1)));
        return dfs(r, c, max);
    }
    int dfs(int x, int y, int k) {
        if (x < 0 || x >= m || y < 0 || y >= n) return 1;
        if (k == 0) return 0;
        if (cache[x][y][k] != -1) return cache[x][y][k];
        int ans = 0;
        for (auto& d : dirs) {
            int nx = x + d[0], ny = y + d[1];
            ans += dfs(nx, ny, k - 1);
            ans %= MOD;
        }
        cache[x][y][k] = ans;
        return ans;
    }
};

动态规划

根据我们的「记忆化搜索」，我们可以设计一个二维数组 作为我们的 dp 数组：

• 「第一维代表 DFS 可变参数中的 所对应 。取值范围为 」
• 「第二维代表 DFS 可变参数中的 。取值范围为 」

「dp 数组中存储的就是我们 DFS 的返回值：路径数量。」

根据 dp 数组中的维度设计和存储目标值，我们可以得知「状态定义」为：

「 代表从位置 出发，可用步数不超过 时的路径数量。」

至此，我们只是根据「记忆化搜索」中的 DFS 函数的签名，就已经得出我们的「状态定义」了，接下来需要考虑「转移方程」。

当有了「状态定义」之后，我们需要从「最后一步」来推导出「转移方程」：

由于题目允许往四个方向进行移动，因此我们的最后一步也要统计四个相邻的方向。

由此可得我们的状态转移方程：

注意，转移方程中 dp 数组的第一维存储的是 对应的 。

从转移方程中我们发现，更新 依赖于 ，因此我们转移过程中需要将最大移动步数进行「从小到大」枚举。

至此，我们已经完成求解「路径规划」问题的两大步骤：「状态定义」&「转移方程」。

但这还不是所有，我们还需要一些 「有效值」 来滚动下去。

「其实就是需要一些「有效值」作为初始化状态。」

观察我们的「转移方程」可以发现，整个转移过程是一个累加过程，如果没有一些有效的状态（非零值）进行初始化的话，整个递推过程并没有意义。

那么哪些值可以作为成为初始化状态呢？

显然，当我们已经位于矩阵边缘的时候，我们可以一步跨出矩阵，这算作一条路径。

同时，由于我们能够往四个方向进行移动，因此不同的边缘格子会有不同数量的路径。

换句话说，我们需要先对边缘格子进行初始化操作，预处理每个边缘格子直接走出矩阵的路径数量。

目的是为了我们整个 DP 过程可以有效的递推下去。

「可以发现，动态规划的实现，本质是将问题进行反向：原问题是让我们求从棋盘的特定位置出发，出界的路径数量。实现时，我们则是从边缘在状态出发，逐步推导回起点的出界路径数量为多少。」

Java 代码：

class Solution {
    int MOD = (int)1e9+7;
    int m, n, max;
    int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
    public int findPaths(int _m, int _n, int _max, int r, int c) {
        m = _m; n = _n; max = _max;
        int[][] f = new int[m * n][max + 1];
        // 初始化边缘格子的路径数量
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i == 0) add(i, j, f);
                if (j == 0) add(i, j, f);
                if (i == m - 1) add(i, j, f);
                if (j == n - 1) add(i, j, f);
            }
        }
        // 从小到大枚举「可移动步数」
        for (int k = 1; k <= max; k++) {
            // 枚举所有的「位置」
            for (int idx = 0; idx < m * n; idx++) {
                int[] info = parseIdx(idx);
                int x = info[0], y = info[1];
                for (int[] d : dirs) {
                    int nx = x + d[0], ny = y + d[1];
                    if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
                    int nidx = getIdx(nx, ny);
                    f[idx][k] += f[nidx][k - 1];
                    f[idx][k] %= MOD;
                }
            }
        }
        return f[getIdx(r, c)][max];       
    }
    void add(int x, int y, int[][] f) {
        for (int k = 1; k <= max; k++) {
            f[getIdx(x, y)][k]++;
        }
    }
    int getIdx(int x, int y) {
        return x * n + y;
    }
    int[] parseIdx(int idx) {
        return new int[]{idx / n, idx % n};
    }
}

C++ 代码：

class Solution {
public:
    int MOD = 1e9 + 7;
    int m, n, max;
    vector<vector<int>> dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    int findPaths(int _m, int _n, int _max, int r, int c) {
        m = _m; n = _n; max = _max;
        vector<vector<int>> f(m * n, vector<int>(max + 1, 0));
        // 初始化边缘格子的路径数量
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i == 0) add(i, j, f);
                if (j == 0) add(i, j, f);
                if (i == m - 1) add(i, j, f);
                if (j == n - 1) add(i, j, f);
            }
        }
        // 从小到大枚举「可移动步数」
        for (int k = 1; k <= max; k++) {
            // 枚举所有的「位置」
            for (int idx = 0; idx < m * n; idx++) {
                pair<int, int> info = parseIdx(idx);
                int x = info.first, y = info.second;
                for (auto& d : dirs) {
                    int nx = x + d[0], ny = y + d[1];
                    if (nx >= 0 && nx < m && ny >= 0 && ny < n) {
                        int nidx = getIdx(nx, ny);
                        f[idx][k] += f[nidx][k - 1];
                        f[idx][k] %= MOD;
                    }
                }
            }
        }
        return f[getIdx(r, c)][max];
    }
    void add(int x, int y, vector<vector<int>>& f) {
        for (int k = 1; k <= max; k++) {
            f[getIdx(x, y)][k]++;
        }
    }
    int getIdx(int x, int y) {
        return x * n + y;
    }
    pair<int, int> parseIdx(int idx) {
        return {idx / n, idx % n};
    }
};

• 时间复杂度：共有 个状态需要转移，复杂度为
• 空间复杂度：

最后

巨划算的 LeetCode 会员优惠通道目前仍可用 ~

使用福利优惠通道 leetcode.cn/premium/?promoChannel=acoier，年度会员 有效期额外增加两个月，季度会员 有效期额外增加两周，更有超大额专属 🧧 和实物 🎁 福利每月发放。

我是宫水三叶，每天都会分享算法知识，并和大家聊聊近期的所见所闻。

欢迎关注，明天见。

更多更全更热门的「笔试/面试」相关资料可访问排版精美的 合集新基地 🎉🎉