我需要使用矩阵的最小和求和来计算从[0,0]到[M,N]的路径？
我找到了这样的链接https://www.programcreek.com/2014/05/leetcode-minimum-path-sum-java/,但“动态编程”选项却根本不清楚.
我试图用BFS算法自己实现它,但这是一个缓慢的解决方案
public int minPathSum(final int[][] grid) {
if (grid.length == 1 && grid[0].length == 1) {
return grid[0][0];
}
final int[][] moves = {new int[]{1,0},new int[]{0,1}};
final Queue<int[]> positions = new ArrayDeque<>();
final Queue<Integer> sums = new ArrayDeque<>();
positions.add(new int[]{0,0});
sums.add(grid[0][0]);
int minSum = Integer.MAX_VALUE;
while (!positions.isEmpty()) {
final int[] point = positions.poll();
final int sum = sums.poll();
for (final int[] move : moves) {
final int x = point[0] + move[0];
final int y = point[1] + move[1];
if (x == grid.length - 1 && y == grid[0].length - 1) {
minSum = Math.min(minSum,sum);
} else if (x > -1 && y > -1 && x < grid.length && y < grid[0].length) {
positions.add(new int[]{x,y});
sums.add(sum + grid[x][y]);
}
}
}
return minSum + grid[grid.length - 1][grid[0].length - 1];
}
您能否解释一下,如果可能的话,您将如何解决？
最佳答案
我对如何实现广度优先搜索感到困惑,但是在这里却难以理解动态公式,对我来说,这似乎更简单:)
这几乎是经典的动态编程问题.除第一个单元外,到达第一个单元的solution [y] [x]最多具有两个前身：选项1和选项2.假定我们知道到达每个单元的最佳解决方案,我们将选择哪个边？显然,这两种选择中更好的一种！
如果M保留给定值,则形式上稍微正式一点：
solution[0][0] = M[0][0]
// only one choice along
// the top horizontal and
// left vertical
solution[0][x] =
M[0][x] + solution[0][x - 1]
solution[y][0] =
M[y][0] + solution[y - 1][0]
// two choices otherwise:
// the best of option 1 or 2
solution[y][x] =
M[y][x] + min(
solution[y][x - 1],solution[y - 1][x]
)
我们可以看到我们可以创建一个适当的例程,例如使用for循环,以“自下而上”的顺序访问我们的解决方案矩阵的单元格,因为每个单元格的值取决于我们已经计算出的一个或两个前任.
JavaScript代码：
function show(M){
let str = '';
for (let row of M)
str += JSON.stringify(row) + '\n';
console.log(str);
}
function f(M){
console.log('Input:\n');
show(M);
let solution = new Array();
for (let i=0; i<M.length; i++)
solution.push(new Array(M[0].length).fill(Infinity));
solution[0][0] = M[0][0];
// only one choice along
// the top horizontal and
// left vertical
for (let x=1; x<M[0].length; x++)
solution[0][x] =
M[0][x] + solution[0][x - 1];
for (let y=1; y<M.length; y++)
solution[y][0] =
M[y][0] + solution[y - 1][0];
console.log('Solution borders:\n');
show(solution);
// two choices otherwise:
// the best of option 1 or 2
for (let y=1; y<M.length; y++)
for (let x=1; x<M[0].length; x++)
solution[y][x] =
M[y][x] + Math.min(
solution[y][x - 1],solution[y - 1][x]
);
console.log('Full solution:\n');
show(solution);
return solution[M.length-1][M[0].length-1];
}
let arr = [];
arr[0] = [0,7,-7];
arr[1] = [6,-8];
arr[2] = [1,2,0];
console.log(f(arr));