poj 1050

最近比较闲，刷道题。

这道题刚开始以为要使用暴搜去解决。看来有更优雅的做法。其本质还是最大子串值的求法。二维数组，想要求其子矩阵值的最大值，可以将其压缩成一个一维数据，则把问题化解为一个更简单的问题来求解。

例如：

0, -2, -7, 0

9, 2, -6, 2

可以压缩成一个一维数据

9, 0, -13, 2，用这种形式来算。

剩下的就是去穷举可能的子矩阵，压缩，计算。附上自己写的代码。

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;

int arr[101][101];
int tmp_arr[101];

inline int max(int a, int b) {
    return a > b ? a : b;
}

//最大连续子串算法
int findMaxChild(int *a, int len) {
    if (0 == len || NULL == a) {
        return 0;
    }   

    int f[100];
    memset(f, 0, sizeof(f));
    f[0] = a[0];

    int maxVal = f[0];
    for (int i = 1; i < len; ++i) {
        f[i] = max(f[i - 1] + a[i], a[i]);
        if (f[i] > maxVal) {
            maxVal = f[i];
        }   
    }   

    return maxVal;
}


int main(int argc, char ** argv) {

    memset(arr, 0, sizeof(arr));
 //   freopen("input.txt", "r", stdin);
    int lines = 0;
    cin >> lines;

    int maxRes = -10000;
        
    for (int i = 0; i < lines; ++i) {
        for (int j = 0; j < lines; ++j) {
            cin >> arr[i][j];
        }   
                      
        int tmp = findMaxChild(arr[i], lines);
        if (tmp > maxRes) {
            maxRes = tmp;
        }
    }

    //把矩阵进行压缩
    for (int i = 0; i < lines - 1; ++i) {
        for (int j = i + 1; j < lines; ++j) {
            memset(tmp_arr, 0, sizeof(tmp_arr));
            for (int k = 0; k < lines; ++k) {
                for (int t = i; t <= j; ++t) {
                    tmp_arr[k] += arr[k][t];
                }
            }

            int tmp = findMaxChild(tmp_arr, lines);
            if (tmp > maxRes) {
                maxRes = tmp;
            }
        }
    }
    cout << maxRes;
    return 0;
}