Question

我写了一部分程序，但找不到如何继续。这是我的作业，并且已经工作了十天，我的时间即将到期。我的计划要求： a）通过关键字获得N作为输入。 b）生成1到N * N之间的随机整数 c）用这些整数填充矩阵我做到了这一点，但我得不到更多。

更多是=＆gt;贪婪的方法例如，用户输入3作为输入。和程序返回像矩阵

1 2 6

4 8 5

3 9 7

最短路径是1,2,6,5,7。另一个示例用户输入4作为输入和程序返回矩阵，如

14 11 6 8

15 3 16 1

10 4 2 5

12 9 7 13

最短路径可以是14,11,3,4,2,5,13，

并且路径中不允许交叉步骤。

我的代码如下。

import java.util.*;

public class Challenge1 {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("Enter a value for the matrix size.");
        int length = input.nextInt();
        int[][] x = randomMatrix(length);

        for (int i = 0; i < x.length; i++) {
            for (int j = 0; j < x[i].length; j++) {
                System.out.print(x[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static int[][] randomMatrix(int n) {
        Random r = new Random();
        int[][] matrix = new int[n][n];
        boolean[] trying = new boolean[n * n];
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                matrix[i][j] = r.nextInt(n * n) + 1;
                if (trying[matrix[i][j] - 1] == false)
                    trying[matrix[i][j] - 1] = true;

                else {
                    while (trying[matrix[i][j] - 1] == true) {
                        matrix[i][j] = r.nextInt(n * n) + 1;
                    }
                    trying[matrix[i][j] - 1] = true;
                }
            }
        }
        return matrix;
    }

}

Answer 1

这里有一些python-ish伪代码用于我在评论中提到的解决方案。设shortestPath为最初为空的列表，shortestPathCost为已找到的最短路径权重的总和。最初它的值是+infinity。两者都是全球可见的。

 Procedure exhaustiveSearch (currentCost, currentPath, endNode):
      currentNode = currentPath.last
      if currentNode == endNode and currentCost < shortestPathCost:
           shortestPath = currentPath
           shortestPathCost = currentCost
           return

      for each neighbouringNode of currentNode not in currentPath:
           exhaustiveSearch (currentCost + neighbouringNode.cost, 
                             currentPath + neighbouringNode,
                             endNode)

几乎就是这样。参数按值复制。如果你这样调用它：

 exhaustiveSearch(0, [firstNode], endNode);

shortestPath和shortestPathCost将保留网格中的最短路径之一。显然，解决方案的级别比Java本身要高一些，但它应该很容易实现。

在矩阵上找到最短路径的问题

1 个答案: