蓝桥杯 最大子阵

将二维压缩为一维后，再利用动态规划中基础的最大子段和。

最大连续子序列和：

dp[i - 1] > 0, dp[i] = a[i - 1] + a[i]

dp[i - 1] < 0, dp[i] = a[i]

#include<cstdio>
#include<algorithm>
using namespace std;

const int maxn=10010;

int A[maxn], dp[maxn];

int main()
{
	int n;
	scanf("%d", &n);
	for(int i = 0; i < n; i++)
		scanf("%d", &A[i]);
		
	dp[0] = A[0];
	for(int i = 1; i < n; i++)
	{
		dp[i] = max(dp[i-1] + A[i], A[i]);
	}
	
	int k = 0; 
	for(int i = 1; i < n; i++)
	{
		if(dp[i] > dp[k])
		{
			k = i;
		}
	}
	
	printf("%d\n", dp[k]);
	
	return 0;
}

 

题目代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn = 550;
int mat[maxn][maxn];
ll sum[maxn][maxn], col[maxn];
int n, m;


int main()
{
    cin >> n >> m;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            scanf("%d", &mat[i][j]);
            sum[i][j] = sum[i - 1][j] + mat[i][j];
        }
    }
    ll ans = -1.25e9;
    for(int i = 0; i <= n; i++)
    {
        for(int j = i + 1; j <= n; j++)
        {
            for(int k = 1; k <= m; k++)
            {
                col[k] = sum[j][k] - sum[i][k];
                if(col[k - 1] > 0)
                    col[k] += col[k - 1];
                if(col[k] > ans)
                    ans = col[k];
            }
        }
    }
    cout << ans << endl;
    return 0;
}