Question

我已经针对上述问题编写了解决方案，但有人可以建议一种优化方式。我已遍历数组中的count（2到n），其中count正在查找大小计数* count的子数组。

int n = 5;      //Size of array, you may take a dynamic array as well
int a[5][5] = {{1,2,3,4,5},{2,4,7,-2,1},{4,3,9,9,1},{5,2,6,8,0},{5,4,3,2,1}};
int max = 0;
int **tempStore, size;

for(int count = 2; count < n; count++)
{
    for(int i = 0; i <= (n-count); i++)
    {
        for(int j = 0; j <= (n-count); j++)
        {
            int **temp = new int*[count]; 
            for(int i = 0; i < count; ++i) {
                temp[i] = new int[count];
            }

            for(int k = 0; k < count; k++)
            {
                for(int l = 0; l <count; l++)
                {
                    temp[k][l] = a[i+k][j+l];
                }
            }
            //printing fetched array
            int sum = 0;
            for(int k = 0; k < count; k++)
            {
                for(int l = 0; l <count; l++)
                {
                    sum += temp[k][l];
                    cout<<temp[k][l]<<" ";
                }cout<<endl;
            }cout<<"Sum = "<<sum<<endl;
            if(sum > max)
            {
                max = sum;
                size = count;
                tempStore = new int*[count]; 
                for(int i = 0; i < count; ++i) {
                    tempStore[i] = new int[count];
                }
                //Locking the max sum array
                for(int k = 0; k < count; k++)
                {
                    for(int l = 0; l <count; l++)
                    {
                        tempStore[k][l] = temp[k][l];
                    }
                }
            }
            //printing finished
            cout<<"------------------\n";
            //Clear temp memory
            for(int i = 0; i < size; ++i) {
                delete[] temp[i];
            }
            delete[] temp;
        }
    }
}

cout<<"Max sum is = "<<max<<endl;
for(int k = 0; k < size; k++)
{
    for(int l = 0; l <size; l++)
    {
        cout<<tempStore[k][l]<<" ";
    }cout<<endl;
}cout<<"-------------------------";

//Clear tempStore memory
for(int i = 0; i < size; ++i) {
    delete[] tempStore[i];
    }
delete[] tempStore;

示例：

1 2 3 4 5

2 4 7 -2 1

4 3 9 9 1

5 2 6 8 0

5 4 3 2 1

输出：最大总和= 71

2 4 7 -2

4 3 9 9

5 2 6 8

5 4 3 2

Answer 1

试试这个（使用天真的方法，会更容易理解）：

#include <iostream> 
#include<vector>
using namespace std; 
int main( )
{ 
    int n = 5; //Size of array, you may take a dynamic array as well
    int a[5][5] = 
      {{2,1,8,9,0},{2,4,7,-2,1},{5,4,3,2,1},{3,4,9,9,2},{5,2,6,8,0}};
    int sum, partsum;
    int i, j, k, m;
    sum = -999999; // presume minimum part sum 
    for (i = 0; i < n; i++) {
        partsum = 0;
        m = sizeof(a[i])/sizeof(int);
        for (j = 0; j < m; j++) {
            partsum += a[i][j];
        }
        if (partsum > sum) {
            k = i;
            sum = partsum;
        }
    }
    // print subarray having largest sum
    m = sizeof(a[k])/sizeof(int); // m needs to be recomputed
    for (j = 0; j < m - 1; j++) {
        cout << a[k][j] << ", ";
    }
    cout << a[k][m - 1] <<"\nmax part sum = " << sum << endl;
    return 0;
}

Answer 2

这是使用动态编程（DP）或记忆最佳解决的问题。

假设n非常大，您会发现重新计算矩阵的每个可能组合的总和将花费太长时间，因此如果您可以重复使先前的计算能够使一切更快。

我们的想法是从较小的矩阵开始，并计算较大矩阵的总和，重新使用较小矩阵的预先计算值。

long long *sub_solutions = new long long[n*n*m];

#define at(r,c,i) sub_solutions[((i)*n + (r))*n + (c)]

// Winner:
unsigned int w_row = 0, w_col = 0, w_size = 0;

// Fill first layer:
for ( int row = 0; row < n; row++) {
    for (int col = 0; col < n; col++) {
        at(r, c, 0) = data[r][c];
        if (data[r][c] > data[w_row][w_col]) { 
            w_row = r;
            w_col = c;
        }           
    }
}

// Fill remaining layers.
for ( int size = 1; size < m; size++) {
    for ( int row = 0; row < n-size; row++) {
        for (int col = 0; col < n-size; col++) {
            long long sum = data[row+size][col+size];
            for (int i = 0; i < size; i++) {
                sum += data[row+size][col+i];
                sum += data[row+i][col+size];
            }
            sum += at(row, col, size-1); // Reuse previous solution.
            at(row, col, size) = sum;
            if (sum > at(w_row, w_col, w_size)) { // Could optimize this part if you only need the sum.
                w_row = row;
                w_col = col;
                w_size = size;
            }
        }
    }
}

// The largest sum is of the sub_matrix starting a w_row, w_col, and has dimensions w_size+1.
long long largest = at(w_row, w_col, w_size);

delete [] sub_solutions;

此算法具有复杂性：O(n*n*m*m)或更精确：0.5*n*(n-1)*m*(m-1)。（现在我还没有测试过这个，所以请告诉我是否有任何错误。）

Answer 3

使用累计和，您可以计算恒定时间内的部分和

std::vector<std::vector<int>>
compute_cumulative(const std::vector<std::vector<int>>& m)
{
    std::vector<std::vector<int>> res(m.size() + 1, std::vector<int>(m.size() + 1));

    for (std::size_t i = 0; i != m.size(); ++i) {
        for (std::size_t j = 0; j != m.size(); ++j) {
            res[i + 1][j + 1] = m[i][j] - res[i][j]
                        + res[i + 1][j] + res[i][j + 1];
        }
    }
    return res;
}

int compute_partial_sum(const std::vector<std::vector<int>>& cumulative, std::size_t i, std::size_t j, std::size_t size)
{
    return cumulative[i][j] + cumulative[i + size][j + size]
           - cumulative[i][j + size] - cumulative[i + size][j];

}

live example

找到m * m的子阵列（2 <= m

3 个答案: