使用分而治之的2d数组的最大列数

时间:2016-08-18 22:36:16

标签: c++ arrays algorithm containers divide-and-conquer

假设我们有一个二维数组

1   2    3   1
5   6    4   0
0   3    2   1 
1   2    1   0

如果行的长度对于每一行都不相同,是否有一种全局方法如何使用分而治之技术在列中找到最大数字?

我指的是在2d数组中找到需要此步骤的峰值的步骤。

在1d数组上,它将类似于

int maxNumber( vector<int> a , int min , int max ){
    if( min == max )
        return a[min];
    int mid = ( min + max)/2;
    int i   = maxNumber( a , min , mid );
    int j   = maxNumber( a , mid +1, max);
    if( i > j)
        return i;
    return j;
    } 

   vector<int> v = { 1 , 2 , 5 , 0 , 10 , 9};
   cout << maxNumber( a , 0 , a.size() -1 );

现在我们可以使用NxN或NxM矩阵

int maxNumberCollum( vector<vector<int>> a , int row_min , int row_max , int size){
    if ( row_min == row_max ){
        return a[row_min][size];
    }

    int row = ( row_min + row_max ) / 2;
    int i   = maxNumberCollum( a , row_min , row     , size );
    int j   = maxNumberCollum( a , row + 1 , row_max , size);

    if( i > j)
        return i;
    return j;
};

 vector< vector<int> > a = { { 1 , 2 , 3 },
                             { 5 , 0 , 1 },
                             { 6 , 2 , 0 }
                           };
cout << maxNumberCollum( a , 0 , a.size() -1 , 2 )

使用列我们希望找到最大值作为参数传递。

但是,如果我们不知道矩阵(2d数组)是NxN / NxM还是行的长度对于每一行都不相同,那么如何将它实现到二维数组会有什么效果呢?

2 个答案:

答案 0 :(得分:0)

由于每个向量都有自己的大小,您可以使用该信息查找每行中的最大数量。

你有这条线:

arg

通过调用您的1d函数替换它:

let lbl = arg in exp ?lbl

答案 1 :(得分:0)

如果考虑不同大小的向量向量,关键是确保您不会尝试访问它们的边界。

例如,请考虑以下代码:

#include <iostream>
#include <vector>
#include <limits>

using std::cout;
using std::vector;

const int lowest_int = std::numeric_limits<int>::lowest();

int max_number_in_column( const vector<vector<int>> &a, 
                          size_t row_min, size_t row_max, size_t col)
{
    if ( row_min == row_max ) {
        return col < a[row_min].size() ? a[row_min][col] : lowest_int;
    }

    int row = ( row_min + row_max ) / 2;
    int i   = maxNumberColumn( a, row_min, row,     col);
    int j   = maxNumberColumn( a, row + 1, row_max, col);

    return i > j ? i : j;
};

int main() {
    vector<vector<int>> a = {
        { 1 , 2 , 3 },
        { 5 , 0 , 1, -8 },
        { 6 , 2 }
    };

    size_t col = 3;
    int max = max_number_in_column(a, 0, a.size() - 1, col);

    if ( max > lowest_int ) 
        cout << "The greater element of column " << col << " is " << max <<'\n';
    else
        cout << "Unable to find a maximum value in column " << col << '\n';

    return 0;
}

我真正不明白的是你为什么要尝试使用分而治之的技术来做到这一点,而使用共同循环会更容易:

int max_number_in_column( const vector<vector<int>> &a , size_t col)
{
    int max = lowest_int;
    for ( auto const &row : a ) {
        if ( col < row.size()  &&  row[col] > max ) max = row[col];
    }
    return max;
};