给你一个二维数组,二维数组中的每个数都是正数,要求从左上角走到右下角,每一步只能向右或者向下。沿途经过的数字要累加起来。返回最小的路径和。
这道题可以帮助理解暴力递归不好在哪里,动态规划是怎么改正的。
先用暴力递归写代码:
public class Main {
public static void main(String[] args) {
//int[][] array = {{1,3,3},{4,5,6}};
System.out.println(process(array,0,0));
//这里调用的是(0,0)位置到右下角的最短路径和
}
public static int process(int[][] matrix,int i,int j) {
//process这个函数代表的是第i行第j列位置的元素到右下角的最短路径和
if(i == matrix.length-1 && j == matrix[0].length-1) { //base case:到了右下角
return matrix[i][j];
}
//i和j 起码有一个没到终至位置
if(i == matrix.length-1) { //i已经到达最后一行不能再往下走了,所以往右走
return matrix[i][j]+process(matrix, i, j+1);//往右走的最好结果
}
if(j == matrix[0].length-1) { //j已经到达最后一列不能再往下走了,所以往右走
return matrix[i][j]+process(matrix,i+1,j);//往下走的最好结果
}
return matrix[i][j] + Math.min(process(matrix,i,j+1),process(matrix,i+1,j));
//当前位置的值加上往右走和往下走中好的那个结果
}
}
带缓存的递归:
import java.util.HashMap;
public class memo_minpath {
public static void main(String[] args) {
int[][] array = {{1,3,3},{4,5,6}};
System.out.println(process(array,0,0));
}
static HashMap<String,Integer> cache = new HashMap<>();
public static int process(int[][] matrix,int i,int j) {
int result = 0;
if(i == matrix.length-1 && j == matrix[0].length-1) {
result = matrix[i][j];
}
else if(i == matrix.length-1) {
int next = 0;
String nextkey = String.valueOf(i)+"_"+String.valueOf(j+1);
if(cache.containsKey(nextkey)) {
next = cache.get(nextkey);
}
else {
next = process(matrix, i, j+1);
}
result = matrix[i][j]+next;
}
else if(j == matrix[0].length-1) {
int next = 0;
String nextkey = String.valueOf(i+1)+"_"+String.valueOf(j);
if(cache.containsKey(nextkey)) {
next = cache.get(nextkey);
}
else {
next = process(matrix, i+1, j);
}
result = matrix[i][j]+next;
}
else {
int downNext = 0;
String downNextkey = String.valueOf(i+1)+"_"+String.valueOf(j);
if(cache.containsKey(downNextkey)) {
downNext = cache.get(downNextkey);
}
else {
downNext = process(matrix, i+1, j);
}
int rightNext = 0;
String rightNextkey = String.valueOf(i)+"_"+String.valueOf(j+1);
if(cache.containsKey(rightNextkey)) {
rightNext = cache.get(rightNextkey);
}
else {
rightNext = process(matrix, i, j+1);
}
result = matrix[i][j] + Math.min(downNext,rightNext);
}
String key = String.valueOf(i)+"_"+String.valueOf(j);
cache.put(key,result);
return result;
}
}
带缓存的递归方式我们根本不关心依赖状态,当我们开始关心依赖状态的时候,就是动态规划了。不仅仅是这个题,面试中遇到的所有暴力递归的题都是这么一个套路。那我们怎么去推导位置依赖呢,我们从最开始的递归方式看,i 和 j 一旦确定,那么返回值就确定了,那么如果一个m行n列的矩阵,i 的变化范围就是0到m-1,j 的变化范围就是0到n-1。
那么先写出递归的版本,后面的优化就和原题没关系了。先看函数中有哪些可变参数,即哪些参数可以代表解状态,即这些参数一旦确定,解就确定了。
先找解空间的大小,如果是2个可变参数,就是二维表,如果是三个可变参数,就是三维表。
然后看看我们最终要的状态是哪一个,本题中我们要的是从(0,0)位置出发到右下角,(0,0)点的状态就是我们最终要的。
确定目标之后回到base case,看看不被依赖的点是什么,本题中不被依赖的点是最右下角的点。
然后看看最普遍的i ,j位置依赖哪些位置。回到递归中,当来到矩阵最后一行的时候,只依赖右边的位置;当来到矩阵最后一列的时候,只依赖下面的位置,于是可以求出最后一行和最后一列;而一个普遍的i ,j位置既依赖右边的位置也依赖下面的位置。
我们每次可以先用暴力递归写出尝试版本,然后慢慢优化得到递归版本。