C++ 在平方二元矩阵中查找二元矩形的位置

给定一个平方二元矩阵，我必须找到“1”的矩形，它附着在矩阵的右边缘。因此，总而言之，我要找到的是左上角矩形的坐标

p.S：1。始终有一个矩形，在按钮右侧垫子的角落处，最小值为1*1

基于“getupperleft”函数调用的材料尺寸（n=材料尺寸）

1仅在矩形内，0始终在矩形外

举例来说

此处，矩形从第4列第3行开始。（左上坐标）

我的想法是使用两次二进制搜索来获得日志（n）中的答案，但是我坚持执行它，这是C++语法中的例外。因此，我们将感谢您的帮助

void getUpperLeft(int mat[][N], int n, int &row, int &col);
void main()
{
    int row = -1;
    int col = -1;
    int matrix[8][N] = {
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,1,1,1},
    {0,0,0,0,0,1,1,1},
    {0,0,0,0,0,1,1,1},
    {0,0,0,0,0,1,1,1},
    {0,0,0,0,0,1,1,1} };

}

void getUpperLeft(int mat[][N], int n, int & row, int & col)
{
    int mid = N - (n / 2);
    if (mat[N][mid] == 1 && mat[N][mid-1] == 0)
    {
        col = mid;
    }
    else if (mat[N][mid] == 0 && mat[N][mid+1] == 0)
    {
        getUpperLeft(mat, n/2 , row, col);
    }
    else if (mat[N][mid] == 1 && mat[N][mid+1] == 1)
    {
        getUpperLeft(mat, N-(n/2), row, col);
    }
}

---

正如其他人指出的，在代码中存在一些维度硬编码问题。显然，您应该在代码和下面的代码中解决这个问题。话虽如此，这将起作用：

int findCol(const int matrix[8][8]) {                                                                                                                                                                    
    int lo = 0, hi = 8 - 1;
    while (lo < hi) {
        int mid = lo + (hi - lo)/2;
        if (matrix[7][mid] < 1)
            lo = mid + 1;
        else
            hi = mid;
    }   
    return lo; 
}   


int findRow(const int matrix[8][8]) {
    int lo = 0, hi = 8 - 1;
    while (lo < hi) {
        int mid = lo + (hi - lo)/2;
        if (matrix[mid][7] < 1)
            lo = mid + 1;
        else
            hi = mid;
    }   
    return lo;
}

int findCol（常量int矩阵[8][8]）{
int lo=0，hi=8-1；
while（lo

---

前一个函数对最后一行执行二进制搜索，后一个函数对最后一列执行二进制搜索。

正如其他人所指出的，您的代码中存在一些维度硬编码问题。显然，您应该在代码和下面的代码中解决这个问题。话虽如此，这将起作用：

int findCol(const int matrix[8][8]) {                                                                                                                                                                    
    int lo = 0, hi = 8 - 1;
    while (lo < hi) {
        int mid = lo + (hi - lo)/2;
        if (matrix[7][mid] < 1)
            lo = mid + 1;
        else
            hi = mid;
    }   
    return lo; 
}   


int findRow(const int matrix[8][8]) {
    int lo = 0, hi = 8 - 1;
    while (lo < hi) {
        int mid = lo + (hi - lo)/2;
        if (matrix[mid][7] < 1)
            lo = mid + 1;
        else
            hi = mid;
    }   
    return lo;
}

int findCol（常量int矩阵[8][8]）{
int lo=0，hi=8-1；
while（lo

---

前一个函数对最后一行执行二进制搜索，后一个函数对最后一列执行二进制搜索。

您可以对最后一列执行二进制搜索以查找第一个值为1的行，同样，对最后一行执行另一个二进制搜索以查找第一个值为1的列。这将给出1s矩形的左上角

---

复杂性是O（logn）时间，O（1）空间

您可以对最后一列执行二进制搜索，以查找第一行的值为1，同样，对最后一行执行另一个二进制搜索，以查找第一列的值为1。这将给出1s矩形的左上角

---

复杂性是O（logn）时间，O（1）空间

好的，所以使用迭代版本的BinarySearch，这就是我所做的，它工作得非常好：

void main()
{

}

void getUpperLeft(int mat[][N], int n, int & row, int & col)
{
    col = getCoordinate(mat, true, 0);
    row = getCoordinate(mat, false, col);
}

//getCoordinate function works using BinarySearch algorithm - log(n) until it finds the desirable coordinate.
int getCoordinate(int mat[][N], bool stat, int y) //[stat="true" - horizontal test], [stat="false"  - vertical test (then "y" parameter is the horizontal coordinate)].
{
    int low = 0, high = N;
    int prev, next;

    while (low < high)
    {
        int mid = low + (high - low) / 2;
            if (stat)
            {
                prev = mat[N - 1][mid - 1];
                next = mat[N - 1][mid];
            }
            else
            {
                prev = mat[mid - 1][y];
                next = mat[mid][y];
            }

            /*edge cases*/
        if (mat[0][0] == 1 && mid ==0)
            return 0;
        if (mat[0][N - 1] == 1 && mid ==0)
            return 0;
            /*edge cases*/

        if (next == 1 && prev == 0)
            return mid;
        else if (prev == 0 && next == 0)
            low = mid + 1;
        else if (prev == 1 && next == 1)
            high = mid;
    }
}

void main（）
{
}
void getUpperLeft（int mat[][N]，int N，int&row，int&col）
{
col=getCoordinate（mat，true，0）；
行=获取坐标（mat、false、col）；
}
//getCoordinate函数使用BinarySearch算法-log（n）工作，直到找到所需的坐标。
int getCoordinate（int mat[][N]，bool stat，int y）/[stat=“true”-水平测试]，[stat=“false”-垂直测试（然后“y”参数为水平坐标）]。
{
int低=0，高=N；
int prev，next；
while（低<高）
{
int mid=低+（高-低）/2；
如果（统计）
{
prev=mat[N-1][mid-1]；
next=mat[N-1][mid]；
}
其他的
{
prev=mat[mid-1][y]；
下一个=垫[mid][y]；
}
/*边缘案例*/
if（mat[0][0]==1&&mid==0）
返回0；
if（mat[0][N-1]==1&&mid==0）
返回0；
/*边缘案例*/
if（next==1&&prev==0）
中途返回；
else if（上一个==0&&next==0）
低=中+1；
else if（上一个==1和下一个==1）
高=中；
}
}

好的，使用迭代版本的BinarySearch，这就是我所做的，它工作得非常好：

void main()
{

}

void getUpperLeft(int mat[][N], int n, int & row, int & col)
{
    col = getCoordinate(mat, true, 0);
    row = getCoordinate(mat, false, col);
}

//getCoordinate function works using BinarySearch algorithm - log(n) until it finds the desirable coordinate.
int getCoordinate(int mat[][N], bool stat, int y) //[stat="true" - horizontal test], [stat="false"  - vertical test (then "y" parameter is the horizontal coordinate)].
{
    int low = 0, high = N;
    int prev, next;

    while (low < high)
    {
        int mid = low + (high - low) / 2;
            if (stat)
            {
                prev = mat[N - 1][mid - 1];
                next = mat[N - 1][mid];
            }
            else
            {
                prev = mat[mid - 1][y];
                next = mat[mid][y];
            }

            /*edge cases*/
        if (mat[0][0] == 1 && mid ==0)
            return 0;
        if (mat[0][N - 1] == 1 && mid ==0)
            return 0;
            /*edge cases*/

        if (next == 1 && prev == 0)
            return mid;
        else if (prev == 0 && next == 0)
            low = mid + 1;
        else if (prev == 1 && next == 1)
            high = mid;
    }
}

void main（）
{
}
void getUpperLeft（int mat[][N]，int N，int&row，int&col）
{
col=getCoordinate（mat，true，0）；
行=获取坐标（mat、false、col）；
}
//getCoordinate函数使用BinarySearch算法-log（n）工作，直到找到所需的坐标。
int getCoordinate（int mat[][N]，bool stat，int y）/[stat=“true”-水平测试]，[stat=“false”-垂直测试（然后“y”参数为水平坐标）]。
{
int低=0，高=N；
int prev，next；
while（低<高）
{
int mid=低+（高-低）/2；
如果（统计）
{
prev=mat[N-1][mid-1]；
next=mat[N-1][mid]；
}
其他的
{
prev=mat[mid-1][y]；
下一个=垫[mid][y]；
}
/*边缘案例*/
if（mat[0][0]==1&&mid==0）
返回0；
if（mat[0][N-1]==1&&mid==0）
返回0；
/*边缘案例*/
if（next==1&&prev==0）
中途返回；
else if（上一个==0&&next==0）