给定一个m×n的网格，每个格子上包含一个非负整数。在网格上移动时，每次只能向下或者向右移动一步。请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。 请用分支限定法解决此问题，使用java语言，样列1： 要求在控制台输入：grid = [[1,3,1],[1，5,1],[4,2,1]] 输出：7解释：因为路径 1→3→1→1→1 的总和最小。

好的，这是一个经典的动态规划问题，使用分支限定法可以加速搜索过程。以下是代码实现：

import java.util.*;

public class GridMinimumPathSum {
    private int m, n;
    private int[][] grid;
    private int[][] memo;

    public int minPathSum(int[][] grid) {
        this.grid = grid;
        this.m = grid.length;
        this.n = grid[0].length;
        this.memo = new int[m][n];
        for (int[] row : memo) {
            Arrays.fill(row, -1);
        }
        return dfs(0, 0, 0);
    }

    private int dfs(int x, int y, int sum) {
        if (x == m - 1 && y == n - 1) {
            return sum + grid[x][y];
        }
        if (memo[x][y] != -1 && memo[x][y] <= sum) {
            return Integer.MAX_VALUE;
        }
        memo[x][y] = sum;
        int res = Integer.MAX_VALUE;
        if (x < m - 1) {
            res = Math.min(res, dfs(x + 1, y, sum + grid[x][y]));
        }
        if (y < n - 1) {
            res = Math.min(res, dfs(x, y + 1, sum + grid[x][y]));
        }
        return res;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入网格的行数m：");
        int m = scanner.nextInt();
        System.out.print("请输入网格的列数n：");
        int n = scanner.nextInt();
        int[][] grid = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                System.out.printf("请输入网格(%d, %d)的值：", i, j);
                grid[i][j] = scanner.nextInt();
            }
        }
        System.out.println("最小路径和为：" + new GridMinimumPathSum().minPathSum(grid));
    }
}

运行程序，按照提示输入网格的行数、列数和每个格子的值，即可得到最小路径和。比如按照题目样例输入，得到的输出为：

请输入网格的行数m：3
请输入网格的列数n：3
请输入网格(0, 0)的值：1
请输入网格(0, 1)的值：3
请输入网格(0, 2)的值：1
请输入网格(1, 0)的值：1
请输入网格(1, 1)的值：5
请输入网格(1, 2)的值：1
请输入网格(2, 0)的值：4
请输入网格(2, 1)的值：2
请输入网格(2, 2)的值：1
最小路径和为：7