Question

我尝试解决问题以找到n * n 2D阵列的局部最小值。 2D阵列的所有元素都是不同的。直到现在我已经完成了这个

2D阵列的局部最小值的定义：

如果出现以下情况，A [i] [j]是当地最低要求：

A [i] [j]＆lt; A [i + 1] [j]
A [i] [j]＆lt; A [i-1] [j]
A [i] [j]＆lt; A [i] [j + 1]
A [i] [j]＆lt; A [i] [j-1]

MinColumn函数： 此函数从其前一个函数接收三个输入：2D数组M，中间列的索引或基本上要考虑的列，以及列中的总列数当前递归

我使用分而治之来找到该列的最小元素并将其返回给调用者。该算法的时间复杂度为 O（log n），因为while循环将要考虑的项减少了2倍。因此，它的时间复杂度为 O（记录n）

MinColumn(M[][],int mid,int last){
    L<-0,R <-last;
    found <- False;
    while(found == false){
        mid2 <- (L+R)/2 
        if(M[mid2][mid] is local minimum of column){
            found <- True
            return mid2
        }
        else if( M[mid2-1][mid] < M[mid2][mid])
            R <- mid2-1
        else 
            L <- mid2 +1
    }
    return mid2;
}

MinGrid函数 此函数首先是找出2D数组的局部最小值。我通过分而治之的方法

找到2D数组的局部最小值

它首先找到2D数组的中间列，调用 MinColumn 函数来查找中间列的最小元素，然后检查这个最小元素是否是局部最小值。如果没有，那么我检查 mid + 1 或 mid-1 的哪一列的值小于考虑的值

如果左侧值较小，则我们的局部最小值位于左侧，如果右侧值小，则局部最小值位于右侧。然后我根据情况改变L / R并最终达到局部最小值。

MinGrid(M[][]){    
    L<-0,R <-last;
    found <- False;
    while(found == false){
        mid <- (L+R)/2
        i <- Mincolumn(M,mid,R);
        if(M[i][mid] is local minima)
            return M[i][mid]    
        else  if(M[mid2][mid+1] < M[i][mid])
            L <- mid+1
        else R <- mid-1
    }
}

现在 Mincolumn 的 O（）复杂度为 O（logn），并且 MinGrid 功能正在运行通过while循环，最多迭代 log（n）次。因此，在找到 MinGrid 的复杂性时，我会写

MinGrid(M[][]){    
    L<-0,R <-last; b    // O(1)
    found <- False;
    while(found == false){     // iterates over log n times
        mid <- (L+R)/2             // O(1)
        i <- Mincolumn(M,mid,R);   // O(log n)
        if(M[i][mid] is local minimum)
            return M[i][mid]         
        else  if(M[mid2][mid+1] < M[i][mid])  //O(1)
            L <- mid+1    //O(1)
        else R <- mid-1
    }
}

因此总共O（f（n））= log（n）（log（n）+ c O（1））

因此O（f（n））=（log（n））^ 2;

特别是我对 MinGrid 部分的疑问，我认为它的复杂性是（log（n））^ 2 ，因为被调用的函数是 O（log n）复杂度和while循环中的其他组件是 O（1），使我的 MinGrid 成为 O（（log（n）））^ 2）算法。

Answer 1

不幸的是，您的算法不正确。问题在于：

如果左侧值较小，则我们的局部最小值位于左侧，如果正确的值小，则局部最小值在右侧。然后我根据情况改变L / R并最终结束当地的最低要求。

考虑这种情况 - 唯一的局部最小值是11

首先，算法找到中间列的局部最小值：20。然后它选择向左，找到13并输出结果。它甚至没有考虑第三列（它拥有唯一正确的解决方案）。

这是一个正确的O（（logn）^ 2）算法来查找二维数组的局部最小值吗？

1 个答案: