Minimum Path Sum 矩阵最短路径和@LeetCode

一个矩阵要求从左上角走到右下角，只能往右或往下走。

递归，DP

非常好的练习递归和动态规划的简单题

package Level3;

import java.util.Arrays;
import java.util.Iterator;

/**
 * Minimum Path Sum 
 * 
 *  Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.
 *
 */
public class S64 {

	public static void main(String[] args) {
		int[][] grid = {{1,2},{1,1}};
		System.out.println(minPathSum(grid));
		System.out.println(minPathSum2(grid));
	}

	public static int minPathSum(int[][] grid) {
		int[][] sum = new int[grid.length][grid[0].length];
		for (int[] row : sum) {
			Arrays.fill(row, Integer.MIN_VALUE);
		}
        return rec(grid, sum, grid.length-1, grid[0].length-1);
    }
	
	// 递归记忆化，从上至下。因为每次都要做判断是否已经存过，所以写的会很丑陋
	public static int rec(int[][] grid, int[][] sum, int x, int y){
		if(x==0 && y==0){
			if(sum[0][0] == Integer.MIN_VALUE){
				sum[0][0] = grid[0][0];
			}
			return sum[0][0];
		}
		if(x == 0){
			if(sum[x][y] == Integer.MIN_VALUE){
				sum[x][y-1] = rec(grid, sum, x, y-1);
				sum[x][y] = sum[x][y-1] + grid[x][y];
			}
			return sum[x][y];
		}
		if(y == 0){
			if(sum[x][y] == Integer.MIN_VALUE){
				sum[x-1][y] = rec(grid, sum, x-1, y);
				sum[x][y] = sum[x-1][y] + grid[x][y];
			}
			return sum[x][y];
		}
		
		if(sum[x][y-1] == Integer.MIN_VALUE){
			sum[x][y-1] = rec(grid, sum, x, y-1);
		}
		if(sum[x-1][y] == Integer.MIN_VALUE){
			sum[x-1][y] = rec(grid, sum, x-1, y);
		}
		sum[x][y] = Math.min(sum[x][y-1], sum[x-1][y]) + grid[x][y];
		return sum[x][y];
	}
	
	// 没有记忆的递归，超时
	public int rec(int[][] grid, int x, int y){
		if(x==0 && y==0){
			return grid[0][0];
		}
		if(x == 0){
			return rec(grid, x, y-1)+grid[x][y];
		}
		if(y == 0){
			return rec(grid, x-1, y)+grid[x][y];
		}
		return Math.min(rec(grid, x-1, y), rec(grid, x, y-1)) + grid[x][y];
	}
	
	// DP 从下至上
	public static int minPathSum2(int[][] grid) {
		int[][] sum = new int[grid.length][grid[0].length];
		sum[0][0] = grid[0][0];
		
		// 填充第一列
		for(int i=1; i<grid.length; i++){
			sum[i][0] = sum[i-1][0] + grid[i][0];
		}
		// 填充第一行
		for(int i=1; i<grid[0].length; i++){
			sum[0][i] = sum[0][i-1] + grid[0][i];
		}
		
		// 对中间的cell应用递推公式
		for(int i=1; i<grid.length; i++){
			for(int j=1; j<grid[0].length; j++){
				sum[i][j] = Math.min(sum[i-1][j], sum[i][j-1]) + grid[i][j];
			}
		}
		
		return sum[grid.length-1][grid[0].length-1];
	}
}

Again:

public class Solution {
    
    public int minPathSum(int[][] grid) {
        int[][] sums = new int[grid.length][grid[0].length];
        sums[0][0] = grid[0][0];
        for(int i=1; i<grid.length; i++){
            sums[i][0] = grid[i][0] + sums[i-1][0];
        }
        for(int j=1; j<grid[0].length; j++){
            sums[0][j] = grid[0][j] + sums[0][j-1];
        }
        for(int i=1; i<grid.length; i++){
            for(int j=1; j<grid[0].length; j++){
                sums[i][j] = Math.min(sums[i-1][j], sums[i][j-1]) + grid[i][j];
            }
        }
        return sums[grid.length-1][grid[0].length-1];
    }
    
    
    public int minPathSum2(int[][] grid) {
        return rec(grid, grid.length-1, grid[0].length-1);
    }
    
    public int rec(int[][] grid, int x, int y){
        if(x==0 && y==0){
            return grid[0][0];
        }
        if(x == 0){
            return rec(grid, x, y-1) + grid[x][y];
        }
        if(y == 0){
            return rec(grid, x-1, y) + grid[x][y];
        }
        
        return Math.min(rec(grid, x-1, y), rec(grid, x, y-1)) + grid[x][y];
    }
}