求最小子数组之二维篇

一、设计思路

  求出该二维数组的所有子数组，先确定一个位置为起点，然后向右下方依次以此起点为始的所有子数组，

图1—顺序求子数组

具体如上图1，顺序求出子数组，然后和max值相比较，若比max值大，则将该子数组和赋给max，并保存其位置，对该子数组的位置，只需要保存其首尾位置即可，

                        

   图2—保存子数组位置

如上图2所示，得到了最大子数组和与其位置，输出即可。

二、代码

package zishuzu;

import java.util.*;

public class zuixiaozishuzu {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int m,n,M,N,max,sum;
        int i,i1,i2,j,j1,j2;
        int shouL,shouR,weiL,weiR;
        Scanner sc = new Scanner(System.in);
        System.out.println("输入二维数组的行数和列数：");
        m =    sc.nextInt();
        n = sc.nextInt();
        System.out.println("输入该二位数组的取值范围（保证第一个数小于第二个数）:");
        M = sc.nextInt();    
        N = sc.nextInt(); 
        
        int[][] Shuzu = new int[m][n];
        for(i = 0;i < m;i++)
            for(j = 0;j < n;j++)
            {
                Shuzu[i][j] = N + (int)(Math.random()*(M - N));
            }
        System.out.println("该随机二维数组为：");
        for(i = 0;i < m;i++)
            for(j = 0;j < n;j++)
            {
                System.out.print(Shuzu[i][j]+"	");
                if(j == n - 1)
                {
                    System.out.print("
");
                }
            }
        
        sum =0;
        max = Shuzu[0][0];
        shouL = 0;
        shouR = 0;
        weiL = 0;
        weiR = 0;

        for(i = 0;i < m;i++)
        {
            for(j = 0;j < n;j++)
            {
                for(i1 = i;i1 < m;i1++)
                {
                    for(j1 = j;j1 < n;j1++)
                    {
                        for(i2 = i;i2 <= i1;i2++)
                        {
                            for(j2 = j;j2 <= j1;j2++)
                            {
                                sum = sum + Shuzu[i2][j2];
                            }
                        }
                        if(max <= sum)
                        {
                            max = sum;
                            shouL = i;
                            shouR = j;
                            weiL = i1;
                            weiR = j1;
                        }
                        sum = 0;
                    }
                }
            }
        }        
        
        System.out.println("最大子数组和为：");
        System.out.println(max);
        System.out.println("最大子数组为：");
        for(i = shouL;i <= weiL;i++)
            for(j = shouR;j <= weiR;j++)
            {
                System.out.print(Shuzu[i][j] + "	");
                if(j == weiR)
                {
                    System.out.print("
");
                }
            }
        
        sc.close();
    }

三、实验结果

图3—结果1

图4—结果2

图5—结果3

四、开发过程

  一个二维数组，当看到求最小子数组时，立马蹦出的想法就是求出这个二维数组的每一个子数组，虽然想法普通，时间复杂度高，却也不用考虑很多的特殊情况，出错的风险低了许多。

  设计之初就是一个时间复杂度为n⁶的一个思路，第一层即最外层是关于起始位置的循环，第二层是关于终止位置的循环，最里层则是该子数组的自加求和，每层有两个for循环。

  在一开始编写时，将循环时的值设为i,ii,iii,j,jj,jjj,运行时却失败了，花了两节课怎么也找不到错误，突然想起同伴的提醒：为什么不用i,i1,i2,j1,j1,j2,这样不是更容易看点，于是便将所有值该了过来，改到最后一个jjj值时，才发现，我是将“jjj”写成了“jj”，导致了程序的无限循环。

  在研究错误的两节课里，经同伴提醒，想要减少时间复杂度，就是修改每层的for循环，减少一个，将i++写在for循环内，具体代码如下：

i = 0;
        for(j = 0;j < n;j++)
        {
            i1 = i;
            for(j1 =j;j1 < n;j1++)
            {
                i2 = i;
                for(j2 = j;j2 <= j1;j2++)
                {
                    sum += Shuzu[i2][j2];
                    if((j2 == j1)&&(i2 < i1))
                    {
                        i2++;
                        j2 = j;
                    }
                    else if(j2 == j1&&i2 == i1)
                    {
                        break;
                    }
                }
                if(max < sum)
                {
                    max = sum;
                    shouL = i;
                    shouR = j;
                    weiL = i1;
                    weiR = j1;
                }
                sum = 0;
                if(j1 == n -1 && i1 < m -1)
                {
                    i1++;
                    j1 = j;
                }
                else if(j1 == n-1 && j1 == m - 1)
                {
                    break;
                }
            }
            if(j == n - 1 && j < m - 1)
            {
                i++;
                j = 0;
            }
            else if(j == n - 1 && j == m - 1)
            {
                break;
            }
        }    

能运行出来，可检验时发现有的运算结果是错误的，所以就先用了第一种方法。
  这个程序还可以稍作改进，就是当存在最大子数组和相同的子数组时，将所有数组都输出，可以用数组来保存。

五、结对开发成员

刘双渤，刘洪阳