HDU 1081 To The Max【dp，思维】

HDU 1081

题意：给定二维矩阵，求数组的子矩阵的元素和最大是多少。

题解：这个相当于求最大连续子序列和的加强版，把一维变成了二维。

先看看一维怎么办的：

int getsum()
{
    int tot=0;
    int ans=-1e9;
    for(int i=1;i<=n;i++){
        if(tot<0) tot=0;
        tot+=a[i];
        if(tot>ans)
            ans=tot;
    }
    return ans;
}

这种做法太棒了！短短几行，就能解决最大子序列和这个问题。其实这几行代码值得深思。而且这是个在线算法，输入数据及时能给出结果，感觉不能归于动归解法。

　　但当求解这道题时，就不知道怎么办了。我当时受到以前做的一道关于求01矩阵最大0子矩阵面积的题的启发，想先预处理每行得到前缀和数组，然后再想办法dp。可是dp状态和方程一直找不好。后来看到别人的解法才明白，他们其实也是预先处理的每行的前缀和。他们的想法就是先求出每行的前缀和数组sum[][],然后依次枚举前k行的第i列到第j列的和，求最大值。感觉就像是枚举出了每一个子矩阵，像暴力>_<.

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN = 107;
int sum[MAXN][MAXN];

int main()
{
    int N, tmp;
    while (scanf("%d", &N) == 1)
    {
        memset(sum, 0, sizeof(sum));
        for (int i = 1; i <= N; i++)
            for (int j = 1; j <= N; j++)
            {
                scanf(" %d", &tmp);
                sum[i][j] = sum[i][j - 1] + tmp;//预处理得到每行的前缀和
            }
        int ans = -1e9;
        for (int i = 1; i <= N; i++) {//从第i列
            for (int j = i; j <= N; j++) {//到第j列
                int tot = 0;
                for (int k = 1; k <= N; k++)//前k行
                {
                    if (tot < 0) tot = 0;
                    tot += sum[k][j] - sum[k][i - 1];//第i列到第j列的和
                    if (ans < tot)
                        ans = tot;
                }
            }
        }
        printf("%d
", ans);
    }
    return 0;
}

当然，可以前k行第i列到第j列就可以前k列第i行到第j行，其实是一样的：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN = 107;
int sum[MAXN][MAXN];

int main()
{
    int N,tmp;
    while (scanf("%d",&N)==1)
    {
        memset(sum, 0, sizeof(sum));
        for(int i=1;i<=N;i++)
            for (int j = 1; j <= N; j++)
            {
                scanf(" %d", &tmp);
                sum[i][j] = sum[i-1][j] + tmp;
            }
        int ans = -1e9;
        for (int i = 1; i <= N; i++) {
            for (int j = i; j <= N; j++) {
                int tot = 0;
                for (int k = 1; k <= N; k++)
                {
                    if (tot < 0) tot = 0;
                    tot += sum[j][k] - sum[i-1][k];
                    if (ans < tot)
                        ans = tot;
                } 
            }
        }
        printf("%d
", ans);
    }
    return 0;
}

也有人按照矩阵压缩的想法写，我觉得实际上还是上面的做法，而且上面的想法更容易理解。因为这里所谓矩阵压缩也就是几行加在一起求最大连续子序列。虽殊途同归，但毕竟想法不一样，代码上就会稍微有点差别：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXN=105;
int a[MAXN][MAXN],tmp[MAXN];
int N;

int getsum()
{
    int tot=0,mx=0;
    for(int i=1;i<=N;i++){
        tot+=tmp[i];
        if(tot>mx) mx=tot;
        if(tot<0) tot=0;
    }
    return mx;
}

int main()
{
    while(scanf("%d",&N)==1)
    {
        int temp;
        for(int i=1;i<=N;i++)
            for(int j=1;j<=N;j++)
            scanf("%d",&a[i][j]);
        int ans=-1e9;
        for(int i=1;i<=N;i++)
        {
            memset(tmp,0,sizeof(tmp));
            for(int j=i;j<=N;j++)
            {
                for(int k=1;k<=N;k++)
                    tmp[k]+=a[j][k];
                int tot=getsum();
                if(ans<tot)
                    ans=tot;
            }
        }
        printf("%d
",ans);
    }

    return 0;
}

还有人用树状数组写，我觉的也很棒。没想到我第一次用到二维树状数组是再做dp题的时候。。。虽然这是伪装成二维树状数组的，因为只更新了一维。按照我的理解二维树状数组就是存了若干个一维树状数组的和。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXN=105;
int sum[MAXN][MAXN]={0};
int N;

int Lowbit(int x)
{
    return x&-x;
}

void Add(int i,int j,int val)
{
    while(j<=N){
        sum[i][j]+=val;
        j+=Lowbit(j);
    }
    return;
}

int Sum(int k,int x)
{
    int cnt=0;
    while(x>0){
        cnt+=sum[k][x];
        x-=Lowbit(x);
    }
    return cnt;
}

int main()
{
    while(scanf("%d",&N)==1)
    {
        int tmp;
        memset(sum,0,sizeof(sum));
        for(int i=1;i<=N;i++)
        for(int j=1;j<=N;j++){
            scanf("%d",&tmp);
            Add(i,j,tmp);
        }
        int ans=-1e9;
        for(int i=1;i<=N;i++)
        {
            for(int j=i;j<=N;j++){
                int tot=0;
                for(int k=1;k<=N;k++){
                    if(tot<0) tot=0;
                    tot+=Sum(k,j)-Sum(k,i-1);
                    if(ans<tot)
                        ans=tot;
                }
            }
        }
        printf("%d
",ans);
    }

    return 0;
}

当然，加个dp数组看起来更像是dp题。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN = 107;
int sum[MAXN][MAXN];
int dp[MAXN];
int N;

int lowbit(int x)
{
    return x&-x;
}

void add(int i, int j, int d)
{
    while (j <= N)
    {
        sum[i][j] += d;
        j += lowbit(j);
    }
    return;
}

int Sum(int k, int x)
{
    int cnt = 0;
    while (x>0)
    {
        cnt += sum[k][x];
        x -= lowbit(x);
    }
    return cnt;
}

int main()
{
    int tmp;
    while (scanf("%d",&N)==1)
    {
        memset(sum, 0, sizeof(sum));
        for(int i=1;i<=N;i++)
            for (int j = 1; j <= N; j++)
            {
                scanf(" %d", &tmp);
                add(i, j, tmp);
            }
        int ans = -1e9;
        for (int i = 1; i <= N; i++) {
            for (int j = i; j <= N; j++) {
                memset(dp, 0, sizeof(dp));
                for (int k = 1; k <= N; k++) {
                    tmp = Sum(k, j) - Sum(k, i-1);
                    if (dp[k - 1] > 0)
                        dp[k] = dp[k - 1] + tmp;
                    else
                        dp[k] = tmp;
                    ans = max(ans, dp[k]);
                }
            }
        }
        printf("%d
", ans);
    }
    return 0;
}

 参考博客（感谢~）：

【1】：http://blog.csdn.net/acmman/article/details/38580931?spm=5176.100239.blogcont18950.3.TbcH0h

【2】：http://www.cnblogs.com/cenariusxz/p/4309627.html

【3】：http://www.cnblogs.com/gaigai/archive/2012/03/04/2379728.html