游客 注册 | 登录
中文 | En

1612 - 最大子矩阵

通过次数

0

提交次数

0

时间限制 : 1 秒 内存限制 : 32 MB

已知矩阵的大小定义为矩阵中所有元素的和。给定一个矩阵，你的任务是找到最大的非空(大小至少是1 * 1)子矩阵。

比如，如下4 * 4的矩阵

0 -2 -7 0
9 2 -6 2
-4 1 -4 1
-1 8 0 -2

的最大子矩阵是

9 2
-4 1
-1 8

这个子矩阵的大小是15。

题目输入

输入是一个N * N的矩阵。输入的第一行给出N (0 < N <= 100)。

再后面的若干行中，依次（首先从左到右给出第一行的N个整数，再从左到右给出第二行的N个整数……）给出矩阵中的N2个整数，整数之间由空白字符分隔（空格或者空行）。
已知矩阵中整数的范围都在[-127, 127]。

题目输出

测试数据可能有多组，对于每组测试数据，输出最大子矩阵的大小。

输入/输出样例

输入格式

1
27 
3
-40 29 -16 
38 18 22 
24 -35 5

输出格式

27
78

C++解答

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int MAX = 110;
int a[MAX][MAX];
int b[MAX];
int n;

// 动态规划求最大子段连续和
int getSum()
{
    int ans = b[0];
    int max = ans;
    for (int i=1; i<n; i++)
    {
        (b[i] + ans > b[i])? ans += b[i] : ans = b[i];

        if (max < ans)
        {
            max = ans;
        }
    }
    return max;
}

int main()
{
    int i, j, k;

    while (scanf("%d", &n) != EOF)
    {
        for (i=0; i<n; i++)
        {
            for (j=0; j<n; j++)
            {
                scanf("%d", &a[i][j]);
            }
        }
        int max = -200;
        int ans;
        for (i=0; i<n; i++)
        {
            // 把第i到第j行相加
            memset(b, 0, sizeof(b));
            for (j=i; j<n; j++)
            {
                // 第i行到第j行的和
                for (k=0; k<n; k++)
                {
                    b[k] += a[j][k];
                }
                ans = getSum();
                if (ans > max)
                {
                    max = ans;
                }
            }
        }
        cout << max << endl;
    }
    return 0;
}

Java解答

//http://blog.csdn.net/wzy_1988/article/details/9470543
import java.util.Scanner;
public class Main{
    public static void main(String[]args){
        Scanner in=new Scanner(System.in);
        int i,j,h,k,n,max,sum,cur,matrix[][];
        while(in.hasNextInt()){// 初始化接收矩阵 
            n=in.nextInt();
            matrix=new int[n][n];
            for(i=0;i<n;i++)
                for(j=0;j<n;j++)
                    matrix[i][j]=in.nextInt();//动态规划(类似于一维数组连续最大子序列和)
            max=matrix[0][0];
            for(i=0;i<n;i++){//i,j确定上下界
                for(j=i;j<n;j++){
                    for(k=i,sum=0;k<=j;k++)
                    sum+=matrix[k][0];
                    if(sum>max)
                        max=sum;
                    for(h=1;h<n;h++){
                        for(k=i,cur=0;k<=j;k++)
                            cur+=matrix[k][h];
                        if(sum>=0)
                            sum+=cur;
                        else
                            sum=cur;
                        if(sum>max)
                            max=sum;
                    }
                }
            }
            System.out.println(max);
        }
    }
}
请先登陆