矩阵的最小路径和

矩阵的最小路径和

和本题很类似的一道题，也是用动态规划:https://www.cnblogs.com/jiading/articles/12537515.html

题目描述
给定一个 n * m 的矩阵 a，从左上角开始每次只能向右或者向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，输出所有的路径中最小的路径和。
输入描述:
第一行输入两个整数 n 和 m，表示矩阵的大小。

接下来 n 行每行 m 个整数表示矩阵。
输出描述:
输出一个整数表示答案。
示例1
输入
复制
4 4
1 3 5 9
8 1 3 4
5 0 6 1
8 8 4 0
输出
复制
12

---

本题首先可以粗暴地递归计算:

package com.jiading;

import java.util.*;

public class Problem7 {
    int[][] matrix;

    public static void main(String[]args) {
        Problem7 ma = new Problem7();
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        ma.matrix = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                ma.matrix[i][j] = sc.nextInt();
            }
        }
        int right = ma.move(0, 0, 'r', 0, n, m);
        int down = ma.move(0, 0, 'd', 0, n, m);
        if (right > down) {
            System.out.println(down);
        } else {
            System.out.println(right);
        }
    }

    private int move(int x, int y, char pos, int score, int n, int m) {
        if ((y > m - 1) || (x > n - 1)) {
            if ((x > n - 1 && y == m - 1) || (x == n - 1 && y > m - 1))
                return score;
            else {
                return 300000;
            }
        }
        int right = 0;
        int down = 0;
        if (pos == 'r') {
            right = move(x, y + 1, 'r', score + matrix[x][y], n, m);
            down = move(x, y + 1, 'd', score + matrix[x][y], n, m);
        } else {
            right = move(x + 1, y, 'r', score + matrix[x][y], n, m);
            down = move(x + 1, y, 'd', score + matrix[x][y], n, m);
        }
        if (right > down) {
            return down;
        } else {
            return right;
        }

    }
}

但是这样做很可能会超时，更好的办法是用动态规划来做。

1.生成大小和输入矩阵vec一样大小的矩阵dp，dp[i][j]表示从左上角（0，0）位置走到（i，j）位置的最小路径

2.第一行所有位置只能向右走，所以（0，0）位置到（0，j）位置的路径和就是vec[0][0...j]的值累加，同理，对于第一列的所有位置来说，只能向下走，为vec[0...i][0]的累加

3.除第一行和第一列其他位置都有左位置和上位置，选择值最小的位置加上当前值vec[i][j]就是就是当前路径最小值

时间复杂度O(rowcol) 空间复杂度O(rowcol)

此题貌似还是我学动态规划的例题，-_-||

总体的思路就是，第(i,j)个点处的最短距离就是从左边来或者从上边来的点的距离最短的值再加上自身的值

import java.util.*;
public class Main{
    
    public static void main(String[]args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int[][]matrix=new int[n][m];
        int[][]dp=new int[n][m];
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                matrix[i][j]=sc.nextInt();
                dp[i][j]=0;
            }
        }
        dp[0][0]=matrix[0][0];
        for(int i=1;i<n;i++){
            dp[i][0]=dp[i-1][0]+matrix[i][0];
        }
        for(int j=1;j<m;j++){
            dp[0][j]=dp[0][j-1]+matrix[0][j];
        }
        for(int i=1;i<n;i++){
            for(int j=1;j<m;j++){
                dp[i][j]=Math.min(dp[i-1][j],dp[i][j-1])+matrix[i][j];
            }
        }
        System.out.println(dp[n-1][m-1]);
    }
}