Java 如何递归执行蛮力方法

我正在尝试使用蛮力创建一个递归算法。假设此算法比较整数，如果比较的整数不相似，则“编辑距离”。示例：3254应该是2345。这里的编辑距离是2[（3,2）（5,4）]

我的代码可以编译，但没有任何输出。如果有人能帮我排除故障，我将不胜感激

public static int measureEditDistance(int[] rankings) {
    int editDistance = 0;
    int R = rankings.length;

    // You need to write this method.
    //   Add your logic here to compute the editDistance

    for (int m = 0; m < R; m++) {
        for (int i = m + 1; i < R; i++) {
            for (int j = i + 1; j < R; j++) {
                if (rankings[m] + rankings[i] + rankings[j] == 0) {
                    editDistance++;
                }
            }
        }
    }

    return editDistance;
}

公共静态int-measureditdistance（int[]排名）{
int editDistance=0；
int R=排名。长度；
//您需要编写此方法。
//在此处添加逻辑以计算editDistance
对于（int m=0；m

真正的暴力方法需要找到给定数字的所有排列。下面是实现这一点的方法（递归）：

所以我们可以检查一下。我们必须将

permute（int[]）

的代码更改为：

int permute(int[] arr, int[] rankings){
    int distancevar = 0;
    distance var = permute(arr,rankings,0,arr.length-1);
    return distancevar;

}

然后我们必须将

permute（int[]，int，int）

的返回类型更改为

int

，以便返回我们发现为真的距离。这将使代码如下所示：

int permute(int[] arr, int[] rankings, int i, int n) {
    int j;
    int ans = 0;
    bool isAns = false;
    if (i == n)
        System.out.println(Arrays.toString(arr));
    else {
        for (j = i; j <= n; j++) {
            swap(arr, i, j);
            isAns = check(arr, rankings);
            if(isAns){
                **here you would call your distance check on the two arrays, 
    which I am still unsure of what you actually are doing here**
                ans = *some distance calc*;
                return ans;
            }
            ans = permute(arr,rankings, i + 1, n);
            if (ans == 0){
                swap(arr, i, j); // backtrack
                isAns = check(arr, rankings);
                if(isAns){
                    **here you would call your distance check on the two arrays, 
        which I am still unsure of what you actually are doing here**
                    ans = *some distance calc*;
                    return ans;
                }
        }
    }
    return ans;
}

解释

---

注意permute函数如何调用自身并返回

ans

其中

ans=distance\u value

。然后通过所有函数调用传回该值。这是递归。

请将代码粘贴为文本，而不是文本image@Mureinik但你为什么要将图像内联？那是错误的教训。截图一文不值。请将代码复制到您的帖子中，删除图像。你是否觉得拍摄截图、上传并复制链接比直接复制代码更快？你看不到任何输出，因为它没有打印出来。谷歌将了解如何在Java@andrew在我可以帮助回答之前，是否需要使用TRUE bruteforce（如果答案是错误的，请放弃所有内容并尝试新的）？或者你能优化一下，一旦数字在正确的位置就不交换吗？@Andrew我希望这对朋友有帮助。如果代码不适合您，请告诉我，我会编辑或删除它。只需编辑它以修复逻辑中的缺陷。返回了错误的答案，以前每次都可能是0。

int permute(int[] arr, int[] rankings){
    int distancevar = 0;
    distance var = permute(arr,rankings,0,arr.length-1);
    return distancevar;

}

int permute(int[] arr, int[] rankings, int i, int n) {
    int j;
    int ans = 0;
    bool isAns = false;
    if (i == n)
        System.out.println(Arrays.toString(arr));
    else {
        for (j = i; j <= n; j++) {
            swap(arr, i, j);
            isAns = check(arr, rankings);
            if(isAns){
                **here you would call your distance check on the two arrays, 
    which I am still unsure of what you actually are doing here**
                ans = *some distance calc*;
                return ans;
            }
            ans = permute(arr,rankings, i + 1, n);
            if (ans == 0){
                swap(arr, i, j); // backtrack
                isAns = check(arr, rankings);
                if(isAns){
                    **here you would call your distance check on the two arrays, 
        which I am still unsure of what you actually are doing here**
                    ans = *some distance calc*;
                    return ans;
                }
        }
    }
    return ans;
}

bool check(int[] arr, int[] ans)
    int same = 0
    for(int i = 0; i < temp.length; i++){
        if(temp[i] == ans[i])
            same++;
    if (same == 4)
        return true;
    return false;

int ans = permute(*your array to test*, *final array desired*);
System.out.println(ans);