最小路径和问题

给你一个二维数组，二维数组中的每个数都是正数，要求从左上角走到右下角，每一步只能向右或者向下。沿途经过的数字要累加起来。返回最小的路径和。

这道题可以帮助理解暴力递归不好在哪里，动态规划是怎么改正的。

先用暴力递归写代码：

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位置既依赖右边的位置也依赖下面的位置。

我们每次可以先用暴力递归写出尝试版本，然后慢慢优化得到递归版本。