Java 如何在多维数组中找到所有可能的递增顺序路径？

我想知道查找多维数组的所有可能路径的Java代码。我们应该从

[0][0]

节点开始前进。要记住的是，无论元素的顺序如何，路径都必须是递增的。 如果下一个元素等于（或小于）当前元素，则不应遍历

示例阵列： 结果:

---

我认为下面的代码与您描述的一样。它开始检查第一个节点（0,0）。对于检查的每个节点，将创建一个邻居向量。相邻节点是有资格作为路径的延续的节点（即表中具有较高值的相邻节点）。然后对每个邻居克隆路径，并检查新邻居。这将继续进行，直到选中的节点没有合格的邻居，此时将打印路径并终止算法

试试这个：

import java.util.Arrays;
import java.util.Vector;

class Main {
  class Coords {
    int x;
    int y;
    Coords(int x, int y) {
      this.x = x;
      this.y = y;
    }
  }
  int [][] array = { {3,5,1},{6,7,4},{8,2,9}};
  Vector<Coords> getNeighbors(Coords coords) {
     int x = coords.x;
     int y = coords.y;
     Vector<Coords> result = new Vector<Coords>();
     if (x < array.length - 1) {
        if (array[x + 1][y] >= array[x][y])
          result.add(new Coords(x + 1, y));
     }
     if (x > 0) {
        if (array[x - 1][y] >= array[x][y])
          result.add(new Coords(x - 1, y));
     }
     if (y < array[x].length - 1) {
        if (array[x][y + 1] >= array[x][y])
          result.add(new Coords(x, y + 1));
     }
     if (y > 0) {
        if (array[x][y - 1] >= array[x][y])
          result.add(new Coords(x, y - 1));
     }
     if (x < (array.length - 1 ) &&  (y < array[x].length - 1)) {
        if (array[x + 1][y + 1] >= array[x][y])
          result.add(new Coords(x + 1, y + 1));
     }
     if (x < (array.length - 1 ) &&  (y > 0)) {
        if (array[x + 1][y - 1] >= array[x][y])
          result.add(new Coords(x + 1, y - 1));
     }
     if (x > 0 &&  (y < array[x].length - 1)) {
        if (array[x - 1][y + 1] >= array[x][y])
          result.add(new Coords(x - 1, y + 1));
     }
     if (x > 0 &&  y > 0) {
        if (array[x -1][y - 1] >= array[x][y])
          result.add(new Coords(x - 1, y - 1));
     }
     return result;
  }
  void checkNode(Vector<Integer> path, Coords coords) {
    path.add(array[coords.x][coords.y]);
    Vector<Coords> neighbors = getNeighbors(coords);
    if (neighbors.size() == 0) {
       for (Integer i : path) {
         System.out.print(i+"\t");
       }
       System.out.println();
    }
    for (Coords c : neighbors) {
      Vector<Integer> newpath = (Vector<Integer>) path.clone();
      checkNode(newpath, c);
    }
  }
  Main() {
    System.out.println ("Array: " + Arrays.deepToString(array));
    checkNode(new Vector<Integer>(),new Coords(0,0));
  }

  public static void main(String args[]) {
    new Main();
  }
}

---

它还提供了路径3、6、8，它不在示例输出中

您应该从起点开始构建一棵树。在示例数组中，从左上角开始，树可能如下所示：

     3
   / \ \ 
  5  6  7 
 / \  \  \
7   6  ..  ..

一旦你有了那棵树，你只需要沿着树上的每一条路走下去

尽管看起来很吓人，但您可以将其分为两部分：

• 建造这棵树
• 沿着小路走

---

• 首先，试着想出一种方法，让你的出发点打印出来。 那相当容易

• 一旦你做到了这一点，打印你的起点的邻居 点>其值

• 然后，对每个邻居做同样的事情

---

像一棵二叉树哎呀，我以为这是PHP，但链接可能会有所帮助。嗯，对Java来说也是一样：你试过什么了吗？如果是，请包括你的想法。这有点像是一个“为我做作业”的问题。那么你试过什么？我从过去8个小时就开始了，这是我在任何在线论坛上的第一个问题。我尝试了很多，从那以后一直在编码，但没有成功。我编写的代码非常有文化，很多，所以我克制自己不发布它。欢迎来到StackOverflow！我们希望问题得到代码和原始研究的支持。因此，我们希望看到解决问题的尝试，或者至少有一种您正在考虑的方法。StackOverflow不是一个“给我代码”网站，我们在这里为您工作。请尝试实现一个解决方案或提出一个算法，然后在遇到实际问题时回来提问。我们很乐意帮助你。我想应该是一张图表。不是树。@Sednus如果节点只能访问一次，我认为不可能有图。@Sednus从技术上讲，树是一种图-请参阅或。但正如SDADAS所说，OP似乎将其限制为向下、向右和向下+向右，因此树可以工作（尽管该限制可能是示例数组填充方式的结果…）3,5,6,7,8向左+向下两次。所以我认为它应该可以向任何方向移动。同样，BFS之类的东西也可以工作，只需使用队列而不是树眼，我同意它应该可以正常工作。我的观点是，首先需要遍历矩阵来构建树。该遍历应该类似于BFS遍历。所以，我的想法是就地生成输出，而不是再次遍历树。我可能不是最好的程序员，但我从下午4:00开始就厌倦了尝试，现在是凌晨1:30。已经8个半小时了。如果你认为我没有试过，那就错了。谢谢You@AnasAzeem是的，在你掌握窍门之前，这类问题有点棘手。。。

import java.util.Arrays;
import java.util.Vector;

class Main {
  class Coords {
    int x;
    int y;
    Coords(int x, int y) {
      this.x = x;
      this.y = y;
    }
  }
  int [][] array = { {3,5,1},{6,7,4},{8,2,9}};
  Vector<Coords> getNeighbors(Coords coords) {
     int x = coords.x;
     int y = coords.y;
     Vector<Coords> result = new Vector<Coords>();
     if (x < array.length - 1) {
        if (array[x + 1][y] >= array[x][y])
          result.add(new Coords(x + 1, y));
     }
     if (x > 0) {
        if (array[x - 1][y] >= array[x][y])
          result.add(new Coords(x - 1, y));
     }
     if (y < array[x].length - 1) {
        if (array[x][y + 1] >= array[x][y])
          result.add(new Coords(x, y + 1));
     }
     if (y > 0) {
        if (array[x][y - 1] >= array[x][y])
          result.add(new Coords(x, y - 1));
     }
     if (x < (array.length - 1 ) &&  (y < array[x].length - 1)) {
        if (array[x + 1][y + 1] >= array[x][y])
          result.add(new Coords(x + 1, y + 1));
     }
     if (x < (array.length - 1 ) &&  (y > 0)) {
        if (array[x + 1][y - 1] >= array[x][y])
          result.add(new Coords(x + 1, y - 1));
     }
     if (x > 0 &&  (y < array[x].length - 1)) {
        if (array[x - 1][y + 1] >= array[x][y])
          result.add(new Coords(x - 1, y + 1));
     }
     if (x > 0 &&  y > 0) {
        if (array[x -1][y - 1] >= array[x][y])
          result.add(new Coords(x - 1, y - 1));
     }
     return result;
  }
  void checkNode(Vector<Integer> path, Coords coords) {
    path.add(array[coords.x][coords.y]);
    Vector<Coords> neighbors = getNeighbors(coords);
    if (neighbors.size() == 0) {
       for (Integer i : path) {
         System.out.print(i+"\t");
       }
       System.out.println();
    }
    for (Coords c : neighbors) {
      Vector<Integer> newpath = (Vector<Integer>) path.clone();
      checkNode(newpath, c);
    }
  }
  Main() {
    System.out.println ("Array: " + Arrays.deepToString(array));
    checkNode(new Vector<Integer>(),new Coords(0,0));
  }

  public static void main(String args[]) {
    new Main();
  }
}

Array: [[3, 5, 1], [6, 7, 4], [8, 2, 9]]
3   6   8   
3   6   7   9   
3   6   7   8   
3   5   7   9   
3   5   7   8   
3   5   6   8   
3   5   6   7   9   
3   5   6   7   8   
3   7   9   
3   7   8   

     3
   / \ \ 
  5  6  7 
 / \  \  \
7   6  ..  ..