首先是形势：
我的方法有很多参数： public static int solve(ReiseCheck rc, int[]values, int[][] next, int goal, int city, int [] path, int pathIdx) reisecheck只对我的junit测试很重要，但是values是一个数组，它按顺序存储不同城市的值，所以values[0]是city0的值（f.ex。3） 值[1]是city1的值（f.ex。5） 等等。。。
接下来的2d数组基本上存储了从city0f.ex可以访问的每个城市。你可以再去0号城市或3号城市，从3号城市你可以再去3号城市或4号城市等等。在任何情况下，出发城市总是0号城市。
在int数组路径中，您以正确的顺序存储所有访问过的城市，如果您访问了足够多的城市以达到您的“目标”（目标也是一个数字f.ex），则一条路径结束。它告诉您完成一条路径需要多少个值）。path数组和goal数组一样大，因此如果goal是18，那么path就有18个条目，并且默认情况下所有条目都是-1。
pathidx只是告诉您当前在路径中的位置。
让我们举一个例子：你访问city0 6次，因为从city0你可以再次访问city0（就像我说的[]接下来告诉我们的），city0的值是3。所以6*3=18->完成一条路径。
现在的想法是编写一个递归方法（如果需要回溯的话），返回所有可能路径的数量（在我的方法中总是有效的），并返回确切的路径（不起作用），因为在我的情况下，我总是覆盖同一路径中的条目，一旦到达第二条路径，我就开始混合它们。
这是我目前的代码：

public static int solve(ReiseCheck rc, int[]values, int[][] next, int goal, int city, int [] path, int pathIdx) {
    rc.check();

    path[0] = 0;
    int hochzaehlen = 0;
    if (goal < values[city]) {
        pathIdx--;
        return 0;
    }

    if (goal == values[city]) {
        rc.report(path);
        pathIdx--;
        return 1;
    }

    if(goal > values[city]) {
        for (int i = 0; i < next[city].length; i++) {
            path[pathIdx] = next[city][i];
            hochzaehlen += solve(rc, values, next, goal - values[city], next[city][i], path, pathIdx + 1);
        }
    }

    return hochzaehlen;
}

为了让你们更好地理解它，我告诉你们一个例子的参数：

int[] values = {3, 5, 10, 5, 13, 23};
int[][] next = {{0, 3}, // from city 0 you can go to city 0 (again) and 3
            {3, 5}, 
            {0, 1, 2, 3}, 
            {3, 4}, //
            {2}, //
            {4, 5}};
goal = 18;

使用rc.report（）返回路径，变量“hochzaehlen”告诉我找到的有效路径的数量。
找到的数量：2这对于本例是正确的，我需要的路径是：

{0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}
AND
{0, 3, 3, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}