Java 如何在董事会中找到最赚钱的途径
假设我们有一个这样的董事会: 我们希望通过以下移动模式从左到右找到最有利可图的路径: 例如,在该董事会中,最赚钱的途径是: i、 e.{2,0}->{2,1}->{3,2}->{3,3} 我编写了以下代码:Java 如何在董事会中找到最赚钱的途径,java,algorithm,data-structures,graph-theory,tree-traversal,Java,Algorithm,Data Structures,Graph Theory,Tree Traversal,假设我们有一个这样的董事会: 我们希望通过以下移动模式从左到右找到最有利可图的路径: 例如,在该董事会中,最赚钱的途径是: i、 e.{2,0}->{2,1}->{3,2}->{3,3} 我编写了以下代码: import java.util.*; public final class Board { private final int[][] board; private final int n; public Board(int n) { b
import java.util.*;
public final class Board {
private final int[][] board;
private final int n;
public Board(int n) {
board = new int[n][n];
this.n = n;
generateBoard();
}
public static class Node {
public int x;
public int y;
public int value;
public Node(int x, int y, int value) {
this.x = x;
this.y = y;
this.value = value;
}
@Override
public String toString() {
return "{" + x + ", " + y + "}";
}
}
public static class Path implements Comparable<Path> {
private LinkedList<Node> path = new LinkedList<>();
public Path() {
}
public Path(List<Node> nodes) {
this.path.addAll(nodes);
}
public void addLast(Node node) {
path.addLast(node);
}
public void removeLast() {
path.removeLast();
}
public List<Node> get() {
return path;
}
public int getProfit() {
return path.stream().map(node -> node.value).mapToInt(value -> value).sum();
}
@Override
public String toString() {
return path.toString();
}
@Override
public int compareTo(Path o) {
return getProfit() > o.getProfit() ? 1 : -1;
}
}
public void generateBoard() {
Random random = new Random();
for (int x = 0; x < n; x++) {
for (int y = 0; y < n; y++) {
board[x][y] = random.nextInt(200) + 1 - 100;
}
}
}
public void printBoard() {
for (int[] b : board) {
System.out.println(Arrays.toString(b));
}
}
public Path findTheMostProfitablePath() {
TreeSet<Path> paths = new TreeSet<>();
for (int x = 0; x < n; x++) {
visit(new Node(x, 0, board[x][0]), paths);
}
return paths.last();
}
private void visit(Node root, Collection<Path> paths) {
Stack<Node> stack = new Stack<>();
stack.add(root);
Node node;
Path currentPath = new Path();
while (!stack.isEmpty()) {
node = stack.pop();
currentPath.addLast(node);
List<Node> children = getChildren(node.x, node.y);
if (children == null) {
paths.add(new Path(currentPath.get()));
currentPath.removeLast();
} else {
stack.addAll(children);
}
}
}
private List<Node> getChildren(int x, int y) {
if (y == n - 1) {
return null;
}
y++;
List<Node> children = new LinkedList<>();
if (x == 0) {
children.add(new Node(x, y, board[x][y]));
children.add(new Node(x + 1, y, board[x + 1][y]));
} else if (x == n - 1) {
children.add(new Node(x - 1, y, board[x - 1][y]));
children.add(new Node(x, y, board[x][y]));
} else {
children.add(new Node(x - 1, y, board[x - 1][y]));
children.add(new Node(x, y, board[x][y]));
children.add(new Node(x + 1, y, board[x + 1][y]));
}
return children;
}
public static void main(String[] args) {
Board board = new Board(3);
System.out.println("Board :");
board.printBoard();
System.out.println("\nThe most profitable path :\n" + board.findTheMostProfitablePath());
}
}
我的代码怎么了
我知道这不是找到最赚钱路径的最佳算法,而且速度非常慢。
在n*n
电路板中,路径数为:
n * 2 ^ (n-1) < number of paths < n * 3 ^ (n-1)
n*2^(n-1)<路径数
在这个算法中,我们检查所有路径以找到最有利的路径
谢谢。您正在解决的问题通常是NP完全问题。但是,在您的情况下,您实际上有一个,因此使用以下递推公式可以得到一个有效的解决方案:
D(i,-1) = D(i,m) = -INFINITY //out of bounds
D(-1,j) = 0 [ j>=0 ] //succesful path
D(i,j) = max{ D(i-1, j-1) , D(i-1,j),D(i-1,j+1)} + A[i][j] //choose best out of 3
通过应用实现该公式的技术,可以获得有效的O(n*m)
最优解
完成后,只需在最右边的一列上进行简单扫描,即可找到“最赚钱”路径的目的地,您可以从那里重新构建实际路径,方法是回顾上述内容,并在每一步写下每个决策。a)算法不好。有一个线性时间算法(电路板上的方块数为线性)。B) 算法的问题在于
visit
方法。它做了一些不该做的事t@user3767784你有什么不清楚的?您熟悉动态规划的概念吗?如果不是,你应该读一读,它是一个强大的工具。在您熟悉它之后,您应该能够从这个答案中了解如何找到有效的解决方案。关于一般情况下的NP完全问题,而你的问题是DAG——这是一个很好的事实,但理解所提出的DP解决方案并不重要。
D(i,-1) = D(i,m) = -INFINITY //out of bounds
D(-1,j) = 0 [ j>=0 ] //succesful path
D(i,j) = max{ D(i-1, j-1) , D(i-1,j),D(i-1,j+1)} + A[i][j] //choose best out of 3