Question

我正在尝试使用蛮力创建一个递归算法。该算法假设比较整数，如果比较的整数不相似，则“编辑距离”。例如：3254应该是2345。这里的editDistance应该是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;
}

Answer 1

真正的蛮力方法将要求您查找给定数字的所有排列。因此，这是递归的方法：

void swap(int[] arr, int x, int y) {
    int temp = arr[x];
    arr[x] = arr[y];
    arr[y] = temp;
}


void permute(int[] arr) {
    permute(arr, 0, arr.length - 1);
}


void permute(int[] arr, int i, int n) {
    int j;
    if (i == n)
        System.out.println(Arrays.toString(arr));
    else {
        for (j = i; j <= n; j++) {
            swap(arr, i, j);
            permute(arr, i + 1, n);
            swap(arr, i, j); // backtrack
        }
    }
}

在那之后，您将必须测试您的状况，即您的ranking数组与我们称为temp的其他数组的顺序相同。因此，在方法上方，我们添加了以下内容。

int temp[] = {3, 2, 4, 5};

所以我们可以检查。我们必须将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;
}

现在，在排列函数中，针对您的条件测试数组。

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;

这些功能完成后，main中唯一应包含的代码如下

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

说明

注意置换函数如何调用自身并返回ans，其中ans = distance_value。然后，该值将通过所有函数调用传回。这是递归。

如何递归执行蛮力方法

1 个答案: