检查矩阵内的总和并递归地将路径保留在第二个数组上

Question

这个问题是在我对 Java 的期末考试中提出的：

给定一个正数矩阵（未排序）m、一个整数sum 和另一个矩阵p，它到处都是0。 递归检查m 中是否存在一条路径，它的总和等于sum。

规则：

您只能在数组中向下、向上、向左或向右移动。

找到路径后，矩阵p将在正确的路径上填充1's。

只有一条路径

方法完成后，p 上的所有其他单元格应为 0。

如果没有办法得到这笔钱，你会留下p，就像你得到他一样。

示例：

        int[][] p = {{0,0,0,0},
                     {0,0,0,0},
                     {0,0,0,0},
                     {0,0,0,0}};

一开始。

矩阵是：

        int [][] hill = {{3,8,7,1},
                         {5,15,2,4},
                         {12,14,-13,22},
                         {13,16,17,52}};

如果您在 sum = 23 上调用该方法，该方法将返回 true ，而 p 将是：

        int[][] p = {{1,0,0,0},
                     {1,1,0,0},
                     {0,0,0,0},
                     {0,0,0,0}};

方法必须是递归的

这个问题简直把考试搞得一团糟……

希望你能弄清楚，也许能帮助我理解它！谢谢

我的进步：

    public static boolean findSum(int[][] mat , int sum , int[][]path){
    return findSum(mat,sum,path,0,0);
}

private static boolean findSum(int[][] m, int sum, int[][] p, int i, int j) {
    if (i>=m.length || j>= m[i].length) return false;


    boolean op1 = finder(m,sum-m[i][j],p,i,j);
    boolean op2 = findSum(m,sum,p,i+1,j);
    boolean op3 = findSum(m,sum,p,i,j+1);

    if (op1) return true;
    else if (op2) return true;
    return op3;
}

private static boolean finder(int[][] m, int sum,int[][]p , int i, int j) {

    if (sum==0) {
        p[i][j]=1;
        return true;
    }
    p[i][j]=1;
    boolean op1=false,op2=false,op3=false,op4=false;
    if (i>0 && p[i-1][j]==0 && sum-m[i][j]>=0) op1 = finder(m, sum - m[i][j], p, i - 1, j);
    if (i<m.length-1 && p[i+1][j]==0&& sum-m[i][j]>=0) op2 = finder(m, sum - m[i][j], p, i + 1, j);
    if (j>0 && p[i][j-1]==0&& sum-m[i][j]>=0) op3 = finder(m, sum - m[i][j], p, i, j - 1);
    if (j<m[i].length-1 && p[i][j+1]==0&& sum-m[i][j]>=0) op4 = finder(m, sum - m[i][j], p, i, j + 1);
    else p[i][j]=0;
    return op1||op2||op3||op4;

}

Answer 1

我真的很喜欢解决这个问题。我已经在 python 中完成了它，但您可以轻松地将它扩展到 Java。我已经评论了代码以供您理解。如果有什么您没有得到或可以改进的地方，请告诉我。

顺便说一句，在您的示例中，一个总和有多个路径，下面的代码可以找到所有路径。

hill = [[3,8,7,1],[5,15,2,4],[12,14,-13,22],[13,16,17,52]]
p = [ [0 for x in range (4)] for y in range(4)]
num = 23

def checkPath(p, r, c): #Check boundaries
    res = []
    if r+1<len(p):
        res.append(p[r+1][c] == 0)
    if r-1>=0:
        res.append(p[r-1][c] == 0)
    if c+1<len(p[0]):
        res.append(p[r][c+1] == 0)
    if c-1>=0:
        res.append(p[r][c-1] == 0)
    return res


def pathF(tot, hill, p, r, c):
    p[r][c] = 1 #mark visited
    tot = tot + hill[r][c]    #update total

    if tot == num: #solution found
        print("Found", p)
    else:
        if any (checkPath(p,r,c)):
            if r+1<len(p) and p[r+1][c] == 0: #move right checking if it wasnt visited
                  pathF(tot,hill,p,r+1,c)
            if r-1>=0 and p[r-1][c] == 0:
                pathF(tot,hill,p,r-1,c)
            if c+1<len(p[0]) and p[r][c+1] == 0:
                pathF(tot,hill,p,r,c+1)
            if c-1>=0 and p[r][c-1] == 0:
                pathF(tot,hill,p,r,c-1)
    p[r][c]=0 #mark unvisited
    tot = tot - hill[r][c]     #set total to original       


for x in range(len(hill)): #iterate over every starting point possible
    for y in range(len(hill[0])):
        pathF(0,hill,p,x,y)

这是 num = 23 的输出

Found [[1, 0, 0, 0], [1, 0, 1, 0], [1, 1, 1, 0], [0, 0, 0, 0]]
Found [[1, 0, 0, 0], [1, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
Found [[1, 1, 1, 1], [0, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0]]
Found [[0, 1, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
Found [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 0], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[1, 1, 1, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[0, 0, 0, 1], [0, 1, 1, 1], [0, 1, 1, 0], [0, 0, 0, 0]]
Found [[0, 0, 0, 1], [0, 1, 1, 1], [0, 1, 1, 0], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 0], [1, 1, 1, 0], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[1, 1, 1, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
Found [[0, 0, 0, 0], [1, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]]
Found [[0, 0, 0, 0], [1, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]]
Found [[0, 0, 0, 1], [0, 1, 1, 1], [0, 1, 1, 0], [0, 0, 0, 0]]
Found [[0, 1, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
Found [[1, 0, 0, 0], [1, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[0, 0, 0, 0], [1, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]]
Found [[1, 0, 0, 0], [1, 0, 1, 0], [1, 1, 1, 0], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[1, 1, 1, 1], [0, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0]]
Found [[0, 0, 0, 0], [0, 0, 1, 1], [0, 1, 1, 0], [0, 1, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 0], [1, 1, 1, 0], [0, 0, 0, 0]]
Found [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 0], [0, 0, 0, 0]]
Found [[0, 0, 0, 0], [1, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]]
Found [[0, 0, 0, 0], [0, 0, 0, 0], [0, 1, 1, 1], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[0, 0, 0, 1], [0, 1, 1, 1], [0, 1, 1, 0], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0]]
Found [[0, 0, 0, 0], [0, 0, 0, 0], [0, 1, 1, 1], [0, 0, 0, 0]]
Found [[0, 0, 0, 0], [0, 0, 1, 1], [0, 1, 1, 0], [0, 1, 0, 0]]

Answer 2

所以我设法让它工作:) 在我的课程讲师的帮助下，这里有一个完整的 Java 解决方案！

public static boolean findSum(int[][] m ,int s, int[][]p){
    return findSum(m,s,p,0,0); //calling overloading
}

private static boolean findSum(int[][] m, int s, int[][] p, int i, int j) {
    if (i<0 || i>=m.length) return false; //stop condition
    if (finder(m,s,p,i,j)) return true; //first recursion
    if (j<m[0].length-1) //if the iterator is not on the end of the row 
        return  findSum(m,s,p,i,j+1); //recursive call 
    else //if i checked the whole row , the column will be increase.
        return findSum(m,s,p,i+1,0);//recursive call

}

private static boolean finder(int[][] m, int s, int[][] p, int i, int j) {
    if (s == 0) return true;
    if (i<0 || i>=m.length || j<0 || j>=m.length || s<0 || p[i][j] == 1) return false;

    p[i][j] =1;
    boolean u=false,d=false,r=false,l=false;
    if (i>0) u = finder(m,s-m[i][j],p,i-1,j);
    if (i<m.length-1) d = finder(m,s-m[i][j],p,i+1,j);
    if (j>0) l = finder(m,s-m[i][j],p,i,j-1);
    if (i<m.length-1) r = finder(m,s-m[i][j],p,i,j+1);
    if (u) return true;
    else if (d) return true;
    else if (r) return true;
    else if (l) return true;
    else {
        p[i][j] = 0;
        return false;
    }
}