LeetCode 576. 出界的路径数（动规） / 526. 优美的排列（全排列，状压dp）
Posted Zephyr丶J
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了LeetCode 576. 出界的路径数（动规） / 526. 优美的排列（全排列，状压dp）相关的知识，希望对你有一定的参考价值。
576. 出界的路径数
2021.8.15 每日一题
题目描述
给你一个大小为 m x n 的网格和一个球。球的起始坐标为 [startRow, startColumn] 。你可以将球移到在四个方向上相邻的单元格内（可以穿过网格边界到达网格之外）。你 最多 可以移动 maxMove 次球。
给你五个整数 m、n、maxMove、startRow 以及 startColumn ，找出并返回可以将球移出边界的路径数量。因为答案可能非常大，返回对 109 + 7 取余 后的结果。
示例 1：
输入：m = 2, n = 2, maxMove = 2, startRow = 0, startColumn = 0
输出：6
示例 2：
输入：m = 1, n = 3, maxMove = 3, startRow = 0, startColumn = 1
输出：12
提示：
1 <= m, n <= 50
0 <= maxMove <= 50
0 <= startRow < m
0 <= startColumn < n
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/out-of-boundary-paths
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
第一时间dfs，明知超时，但是还是倔强了一下
class Solution {
public static final int MOD = (int)1.0e9 + 7;
int m;
int n;
int res = 0;
int[][] dir = {{1,0},{-1,0},{0,1},{0,-1}};
public int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
//第一时间想到的肯定还是dfs，但是答案很大吓到我了，估计会超范围
//不过先写一下试试吧
this.m = m;
this.n = n;
//因为可以折返，所以不应该有标记走到过的数组
for(int i = 1; i <= maxMove; i++){
dfs(startRow, startColumn, i);
}
return res;
}
public boolean inArea(int x, int y){
return x >= 0 && x < m && y >= 0 && y < n;
}
public void dfs(int x, int y, int k){
if(k == 0 && !inArea(x, y)){
res = (res + 1) % MOD;
return;
}
if(k <= 0)
return;
if(!inArea(x, y))
return;
for(int i = 0; i < 4; i++){
int nx = x + dir[i][0];
int ny = y + dir[i][1];
dfs(nx, ny, k - 1);
}
}
}
动态规划想一下：
想不出来，看了一下题解，先根据状态定义写个记忆化搜索吧，可以在dfs基础上改，好久没写过了
开始想直接加一个记忆化数组memo，然后发现没有返回值好像不太行，因为k这里是从大到小变化的，转移会出问题。然后就加了返回值，可以了
memo[i][j][k]表示还剩下k步，从（i，j）这个点出发走出边界的路径数
记忆化搜索：
class Solution {
public static final int MOD = (int)1.0e9 + 7;
int m;
int n;
int[][] dir = {{1,0},{-1,0},{0,1},{0,-1}};
int[][][] memo;
public int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
//第一时间想到的肯定还是dfs，但是答案很大吓到我了，估计会超范围
//超时以后回过头来想哪些状态重复了
//想一个很简单的例子，走两步可以回到初始状态，所以可以把之前多少步，走到哪里的结果记录下来
//即memo[i][j][k]表示还剩下k步，从（i，j）这个点出发走出边界的路径数
this.m = m;
this.n = n;
//记忆化数组
memo = new int[m][n][maxMove + 1];
//因为可以折返，所以不应该有标记走到过的数组
//初始化
for(int i = 0; i < m; i++){
for(int j = 0; j < n; j++){
Arrays.fill(memo[i][j], -1);
}
}
return dfs(startRow, startColumn, maxMove);
}
public boolean inArea(int x, int y){
return x >= 0 && x < m && y >= 0 && y < n;
}
public int dfs(int x, int y, int k){
//如果步数小于0，return
if(k < 0)
return 0;
//如果步数够，且出界了，就返回1
if(k >= 0 && !inArea(x, y)){
return 1;
}
//如果不在范围内，返回
if(!inArea(x, y))
return 0;
//如果到了这个点，剩余同样的步数，那么结果是已经存在过的，就直接加这个结果
if(memo[x][y][k] != -1){
return memo[x][y][k];
}
int ans = 0;
for(int i = 0; i < 4; i++){
int nx = x + dir[i][0];
int ny = y + dir[i][1];
ans = (ans + dfs(nx, ny, k - 1)) % MOD;
}
memo[x][y][k] = ans;
return ans;
}
}
官解的动态规划：
根据当前状态推后面的状态
这个动态规划的状态定义发生了改变：dp[i][j][k] 表示k步到达(i,j)这个点的路径数目，所以能这样进行转移
class Solution {
public static final int MOD = (int)1.0e9 + 7;
int[][] dir = {{1,0},{-1,0},{0,1},{0,-1}};
public int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
//动规写一版，与一般的动规不同的是，这个是从前面的状态推后面的状态
//这种也要熟练的写出来
//dp[i][j][k] 表示k步到达(i,j)这个点的路径数目
int[][][] dp = new int[m][n][maxMove + 1];
//初始化,开始点0步是1，其他都是0
dp[startRow][startColumn][0] = 1;
int res = 0;
for(int k = 0; k < maxMove; k++){
for(int i = 0; i < m; i++){
for(int j = 0; j < n; j++){
int count = dp[i][j][k];
//如果能到达这里
if(count > 0){
for(int[] d : dir){
int ni = i + d[0];
int nj = j + d[1];
//如果在范围内
if(ni >= 0 && ni < m && nj >= 0 && nj < n){
dp[ni][nj][k + 1] = (dp[ni][nj][k + 1] + count) % MOD;
//如果不在范围内，就在结果中加上这个路径数目
}else{
res = (res + count) % MOD;
}
}
}
}
}
}
return res;
}
}
上面是从一个状态往后面的状态推导，即dp[i + x] = dp[i]…
而如果常用的那种思路，dp[i] = dp[i - 1]，沿用上面的状态定义：
但是这种思路会导致个什么问题呢，就是我们定义的范围是在这个矩形内，所以想要出边界是无法转移的
所以到了边界上，需要对当前步数为1的情况进行处理，也就是最后处理一下边界情况
或者我认为也可以扩展一层边界，然后到达扩展层就是结果
看了三叶姐的动规，发现状态定义是和记忆化搜索的记忆化数组一样的
dp[i][j][k]表示从(i,j)点出发，步数在k次以内，能走出边界的路径数
记忆化递归是自顶向下，动规是自底向上
因此过程反过来了，是从边界返回到初始点
先处理边界，例如角就有三种可能走出去，边就有一种（一行或者一列）或者两种（多行多列）
然后倒着去找到到达初始点的路径数，这个思路怎么说呢，理解了就好了，感觉一般不会这样想
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};
}
}
作者：AC_OIer
链接：https://leetcode-cn.com/problems/out-of-boundary-paths/solution/gong-shui-san-xie-yi-ti-shuang-jie-ji-yi-asrz/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
526. 优美的排列
2021.8.16 每日一题
题目描述
假设有从 1 到 N 的 N 个整数，如果从这 N 个数字中成功构造出一个数组，使得数组的第 i 位 (1 <= i <= N) 满足如下两个条件中的一个，我们就称这个数组为一个优美的排列。条件：
第 i 位的数字能被 i 整除
i 能被第 i 位上的数字整除
现在给定一个整数 N，请问可以构造多少个优美的排列？
示例1:
输入: 2
输出: 2
解释:
第 1 个优美的排列是 [1, 2]:
第 1 个位置（i=1）上的数字是1，1能被 i（i=1）整除
第 2 个位置（i=2）上的数字是2，2能被 i（i=2）整除
第 2 个优美的排列是 [2, 1]:
第 1 个位置（i=1）上的数字是2，2能被 i（i=1）整除
第 2 个位置（i=2）上的数字是1，i（i=2）能被 1 整除
说明:
N 是一个正整数，并且不会超过15。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/beautiful-arrangement
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
简单的全排列问题
class Solution {
int res = 0;
int n;
boolean[] used;
public int countArrangement(int n) {
//看到这个范围，感觉没什么好办法，就是个全排列
this.n = n;
used = new boolean[n + 1];
dfs(1);
return res;
}
//k表示当期第几位
public void dfs(int i){
if(i == n + 1){
res++;
return;
}
for(int k = 1; k <= n; k++){
//如果这个数字使用过了
if(used[k])
continue;
//否则，选一个满足条件的数字递归
if(k / i * i == k || i / k * k == i){
used[k] = true;
dfs(i + 1);
}
//回溯
used[k] = false;
}
}
}
状态压缩+动态规划：
看到最大范围15，想到用状压
mask和往常一样，表示1到n是否被使用过，如果使用过，mask对应位置就是1
如何转移呢？
首先确定mask中有多少个1，即新增的数字要放在哪个位置num
然后遍历mask中为1的位置，也就是当前优美队列中可以包含的数字
然后将这些数字分别放在num这个位置，如果能放进去，那么就可以通过之前的状态来转移
如果放不进去，跳过
最终结果就是f[(1 << n) - 1]
class Solution {
public int countArrangement(int n) {
//再练个状压
int[] f = new int[1 << n];
f[0] = 1;
//mask表示1到n位n个数字，哪个被使用过
//确定这些数字组成的优美排列的情况
for(int mask = 1; mask < (1 << n); mask++){
//mask中1的个数，表示当前数字要被放在第num位
int num = Integer.bitCount(mask);
//num个1，然后确定这些1放在什么位置
for(int i = 0; i < n; i++){
//如果mask的第i位为1，那么假定当前新增的数字就是i + 1
if(((mask >> i) & 1) == 1){
以上是关于LeetCode 576. 出界的路径数（动规） / 526. 优美的排列（全排列，状压dp）的主要内容，如果未能解决你的问题，请参考以下文章
LeetCode 576 出界的路径数[动态规划 状态机] HERODING的LeetCode之路