返回一个二维整数数组中最大子数组的和

返回结果值 28

import java.io.*;

//行或者列的数字和实际数量不符
//字符串为空无法转化为整形
//判断是否超过32位
//判断是否无法转化

public class sum_02 {
    @SuppressWarnings("resource")
    public static void main (String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("D:\\java\\number.txt"));
        Array array;
        array=getArray(br);

        if(array.rows==1)
        {
            int max=getOneMax(array.rows,array.cols,array.num_1);
            System.out.println("max="+max);
        }
        else if(array.rows>=2)
        {
            int max=getTowMax(array.rows,array.cols,array.num_2);
            System.out.println("max="+max);
        }
    }

    //这个类用来帮助一次性传参给getMax
    public static class Array
    {
        private int rows;
        private int cols;
        private int[] num_1=new int[cols];
        private int[][] num_2=new int[rows][cols];
        public int getRows()
        {
            return rows;
        }
        public int getCols()
        {
            return cols;
        }
        public int[] getNum_1(){
            return num_1;
        }
        public int[][] getNum_2()
        {
            return num_2;
        }
    }

    //这个方法用来获取文件中的数组
    public static Array getArray(BufferedReader br) throws IOException
    {
        Array array=new Array();

        String line = null;
        String[] Rows=new String[1];//暂时储存行，等下转化为整形
        String[] Cols=new String[1];//暂时储存列，等下转化为整形
        String[] Tarray = null;//存放从文件获取的字符串

        //获取数组的列
        line=br.readLine();//读取第一行
        Rows=line.split(",");//去除文本中一行的","，并将得到的元素存入字符串数组Rows中，这里得到的是行的数量，但不是整形，是字符型
        try
        {
            array.rows = Integer.parseInt(Rows[0]);//行的值化为整形
            System.out.println("行数"+array.rows);
        }
        catch (NumberFormatException e)
        {
            System.out.println("行数数字错误格式");
            System.exit(0);
        }

        //获取数组的行
        line=br.readLine();//读取第二行
//        System.out.println(line);
        Cols=line.split(",");//去除文本中一行的","，并将得到的元素存入字符串数组Cols中，这里得到的是列的数量，但不是整形，是字符型
        try
        {
            array.cols= Integer.parseInt(Cols[0]);//列的值化为整形
            System.out.println("列数"+array.cols);
        }
        catch (NumberFormatException e)
        {
            System.out.println("列数数字错误格式");
            System.exit(0);
        }

        //判断是一维数组还是二维数组
        if(array.rows==1)
        {
            System.out.println("是一维数组");
            int i;
            int[] num=new int[array.cols];
            array.num_1=num;//直接给tad.num_1数组赋值老报错，干脆新建一个数组，然后将地址付给
            line = br.readLine();
            Tarray=line.split(",");//去除文本中一行的","并将得到的元素存入字符串数组Tarray中，这里得到的是这一行中的几个数字形成数字，但不是整形，是字符型
            if(Tarray.length            {
                //这里如果一行全空，没有","，由于只有一个空格，那么array数组内只有一个元素，会显示元素不足
                //如果有五个","，那么就会有6个元素，就会在内层循环显示数字格式错误
                System.out.println("元素个数不足");
                System.exit(0);
            }

            int m=0;//这个m用来得到array里的元素的
            for(i=0;i            {
                //将的array数组中存储的数字转化为整形，由于外层的for循环，每次重新给array数组赋值一次都是一行的数字
                try
                {
                    num[i]=Integer.parseInt(Tarray[m]);//列的值化为整形
                    //System.out.print(num[hang][lie]+" ");
                }
                catch (NumberFormatException e)
                {
                    System.out.println("\n"+"第"+(i+1)+"个数字错误格式");
                    System.exit(0);
                }
                catch (ArrayIndexOutOfBoundsException e)
                {
                    System.out.println("\n"+"数组越界");
                    System.exit(0);
                }
            }
        }
        else if(array.rows>=2)
        {
            System.out.println("是二维数组");
            int hang,lie;
            int[][] num=new int[array.rows][array.cols];
            array.num_2=num;//直接给tad.num_2数组赋值老报错，干脆新建一个数组，然后将地址付给
            //System.out.println("二维数组是  ");
            for(hang=0;(line = br.readLine()) != null;hang++) {//hang可以和rows判断，lie可以和cols判断
                Tarray=line.split(",");//去除文本中一行的","并将得到的元素存入字符串数组Tarray中，这里得到的是这一行中的几个数字形成数字，但不是整形，是字符型
                if(Tarray.length                {
                    //这里如果一行全空，没有","，由于只有一个空格，那么array数组内只有一个元素，会显示元素不足
                    //如果有五个","，那么就会有6个元素，就会在内层循环显示数字格式错误
                    System.out.println("第"+(hang+1)+"行元素个数不足");
                    System.exit(0);
                }

                int m=0;//这个m用来得到array里的元素的
                for(lie=0;lie                {
                    //将的array数组中存储的数字转化为整形，由于外层的for循环，每次重新给array数组赋值一次都是一行的数字
                    try
                    {
                        num[hang][lie]=Integer.parseInt(Tarray[m]);//列的值化为整形
                        //System.out.print(num[hang][lie]+" ");
                    }
                    catch (NumberFormatException e)
                    {
                        System.out.println("\n"+"第"+(hang+1)+"行"+"第"+(lie+1)+"列"+"数字错误格式");
                        System.exit(0);
                    }
                    catch (ArrayIndexOutOfBoundsException e)
                    {
                        System.out.println("\n"+"第"+(hang+1)+"行数组越界");
                        System.exit(0);
                    }
                }
            }
        }

        br.close();//关闭文件

        return array;
    }

    public static int getOneMax(int rows,int cols,int[] num)
    {
        int length=cols;//由行和列来判断有几个元素

        int[] sum=new int[length];

        //System.out.println();
        sum[0]=num[0];
        int max=sum[0];
        for (int i = 1; i < length; i++)
        {
            /*
             * 这里要求sum数组之后的元素，求sum[i]时，当sum[i-1]>=0,说明random[i]加上sum[i-1]不会变小，
             * 那么就让sum[i] = sum[i - 1] + randoms[i]
             */
            if (sum[i - 1] >= 0)
            {
                sum[i] = sum[i - 1] + num[i];
            } else {
                sum[i]=num[i];
            }
            if(max            {
                max=sum[i];
            }
        }
        return max;
    }
    public static int getTowMax(int rows, int cols, int[][] num) {
        int length = rows * (rows + 1) / 2;//由行和列来判断有几个元素
        int[][] Num = new int[length][cols];//创建一个一维数组，用来存放需要的二维数组子数组的和
        //大概就是  用来放连续的几行，每一列的总和，第一行，第二行，第一二行，第二三行
        int index = 0;
        for (int m = 1; m <= rows; m++)//一次i行
        {
            
            for (int i = 0; i + m <= rows; i++, index++)//从第几行开始
            {
                for (int j = 0; j < cols; j++)//第几列
                {
                    for (int k = 0; k < m; k++)//从第j列的第i到i+m行加起来
                    {
                        Num[index][j] += num[i + k][j];

                    }

                }

            }
        }

        int[][] sum = new int[length][cols];//存放所需要的一维数组子数组的和
        int max = sum[0][0];

        /*
         * 这里要求sum数组之后的元素，求sum[i]时，当sum[i-1]>=0,说明random[i]加上sum[i-1]不会变小，
         * 那么就让sum[i] = sum[i - 1] + randoms[i]
         */
        for (int nindex = 0; nindex < length; nindex++) {
            sum[nindex][0] = Num[0][0];

            for (int i = 1; i < cols; i++) {
                if (sum[nindex][i - 1] >= 0) {
                    sum[nindex][i] = sum[nindex][i - 1] + Num[nindex][i];
                } else {
                    sum[nindex][i] = Num[nindex][i];
                }
                if (max < sum[nindex][i]) {
                    max = sum[nindex][i];
                }
            }
        }
        return max;
    }
}