环形二维数组最大子数组的和

设计思路:

因为之前做过二维数组的和环形一维数组的,所以第一感觉就是能不能把这两种整改一下结合起来,所以采用的做法就是将二维环形变化为一维环形,在此采用的方法是从第一行开始,第一行计算出最大子数组,然后第一行和第二行相加为一维计算最大子数组,然后第一行、第二行和第三行,以此类推,最后将各子数组的最大值进行比较,得到最大的即为子数组和的最大值。

实验代码:

//环形一维数组求最大子数组
package erwei;

public class oneArray {

    private int i;
    public static int maxS;
    public int maxShou;
    public int maxWei;
    void getMax(int[] a,int n){
        boolean x = false;
        for(i = 0;i < n;i++)
        {
            if(a[i] >= 0)
            {
                x = true;
                break;
            }
        }

        int sum=0,s1=0,s2=0,loc=0,loc1=0;
        if(x == true)          //有正数的情况下
        {
            for(i = 0;i < n;i++)        //全部为正数的情况下
            {
                s2 += a[i];
                if(a[i] >= 0)
                    sum += a[i];
                if(sum == s2)
                {
                    s2 = sum;
                    loc1 = n;
                }
                else
                    break;
            }
            if(a[0]>=0)            //默认的开头第一个数即为正数
            {
                sum=a[0];
                for(i=1;i<n;i++)
                {
                    if(a[i]>=0)
                    {
                        sum+=a[i];
                    }
                    else
                    {
                    if(sum>=s1)
                        s1=sum;
                    loc=i;
                    if(a[i]<0)
                        sum=0;
                    break;
                    }
                }

                int sum1=0;
                for(i=0;i<n;i++)
                {
                    if(a[i]>=0)
                    {
                        sum1+=a[i];
                    }
                    else
                    {
                        if(sum1>=s2)
                        {
                            s2=sum1;
                            loc1=i;
                        }
                        if(a[i]<0)
                            sum1=0;
                    }
                }
                int s3=0,loc2=0;
                if(a[n-1]>=0)
                {
                    sum=a[n-1];
                    for(i=n-2;i>=0;i--)
                    {
                        if(a[i]>=0)
                        {
                            sum+=a[i];
                        }
                        else{
                        s3=sum;
                        loc2=i;
                        break;}
                    }
                }
                int s4=s1+s3;
                if(s2>=s4)
                {
                    maxS = s2;
                    maxShou = 0;
                    for(i=0;i<loc1;i++)
                    {
                        if(a[i]>0)
                        {
                            maxWei = i;
                        }
                        else
                            break;
                    }
                    /*
                    System.out.print("最大子数组和为:"+s2);
                    System.out.println();
                    System.out.println("子数组为:");
                    for(i=0;i<loc1;i++)
                    {
                        if(a[i]>0)
                        {
                            System.out.print(a[i]+"\t");
                        }
                        else
                            break;
                    }
                    */
                }
                else
                {
                    maxS = s4;
                    maxShou = loc2 + 1;
                    maxWei = loc - 1;
                    /*
                    System.out.print("最大子数组和为:"+s4);
                    System.out.println();
                    System.out.println("子数组为:");
                    for(i=0;i<loc;i++)
                    {
                         System.out.print(a[i]+"\t");
                    }
                    for(i=n-1;i>loc2;i--)
                    {
                        System.out.print(a[i]+"\t");
                    }
                    */
                }
            }
            else                  //默认的开头第一个数为负数
            {
                sum=0;
                for(i=0;i<n;i++)
                {
                    if(a[i]>=0)
                    {
                        sum+=a[i];
                        if(i==n-1&&sum>s1)
                            s1=sum;
                            loc=i;
                    }
                    else
                    {
                        if(sum>=s1)
                        {
                            s1=sum;

                        }
                        if(a[i]<0)
                            sum=0;
                    }
                }
                maxS = s1;
                maxWei = loc;
                for(i=loc;i>=0;i--)
                {
                    if(a[i]>0)
                    {
                        maxShou = i;
                    }
                    else
                        break;
                }
                /*
                System.out.println("lovc"+loc);
                System.out.print("最大子数组和为:"+s1);
                System.out.println();
                for(i=loc;i>=0;i--)
                {
                    if(a[i]>0)
                    {
                        System.out.print(a[i]+"\t");
                    }
                    else
                        break;
                }
                */
            }
        }
        else if(x == false)              //没有正数的情况下
        {
            int t = a[0];
            for(i = 1;i < n;i++)
            {
                if(a[i] > t)
                {
                    t = a[i];
                    maxShou = i;
                    maxWei = i;
                }
            }
            maxS = t;
            /*
            System.out.print("最大子数组和为:"+t);
            System.out.println();
            System.out.println("子数组为:");
            System.out.print(t);
            */
        }
    }
    public int getmaxS(){
        return maxS;
    }
    public int getmaxShou(){
        return maxShou;
    }
    public int getmaxWei(){
        return maxWei;
    }
}
//环形二维数组求最大子数组
package erwei;

import java.util.*;

public class twoArray extends oneArray{

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

        Scanner sc = new Scanner(System.in);

        int max,min,numL,numR;
        int i,j,t;
        int shouL,shouR,weiL,weiR,maxTwo;

        System.out.println("请输入二维数组的行数和列数:");
        numL = sc.nextInt();
        numR = sc.nextInt();

        System.out.println("请输入数组元素取值范围(保证前一个值小于后一个值):");
        min = sc.nextInt();
        max = sc.nextInt();

        int[][] twoArray1 = new int[numL][numR];
        int[] oneArray1 = new int [numR];
        int LTop;

        System.out.println("该二维数组为:");                         //生成随机二维数组
        for(i = 0;i < numL;i++)
            for(j = 0;j < numR;j++){
                twoArray1[i][j] = min + (int)(Math.random()*(max - min));
                System.out.print(twoArray1[i][j] + "\t");
                if(j == numR - 1){
                    System.out.println();
                }
            }

        maxTwo = twoArray1[0][0];
        shouL = 0;
        shouR = 0;
        weiL = 0;
        weiR = 0;

        for(i = 0;i < numR;i++){                                    //一维数组赋初值
            oneArray1[i] = 0;
        }
        System.out.println();
        oneArray one = new oneArray();
        for(LTop = 0;LTop < numL;LTop++){                          //二维数组合并为一维数组
            for(i = LTop;i < numL;i++){
                for(j = 0;j < numR;j++){
                    oneArray1[j] += twoArray1[i][j];
                }
                one.getMax(oneArray1, numR);
                if(one.getmaxS() > maxTwo){
                    maxTwo = one.getmaxS();
                    shouL = LTop;
                    shouR = one.getmaxShou();
                    weiL = i;
                    weiR = one.getmaxWei();
                }
            }
            for(t = 0;t < numR;t++){
                        oneArray1[t] = 0;
            }
        }

        System.out.println("环形二维数组最大子数组和为:");
        System.out.println(maxTwo);
        System.out.println("该最大子数组为:");
        if(shouR > weiR){
            for(i = shouL;i <= weiL;i++){
                for(j = shouR;j < numR;j++){
                    System.out.print(twoArray1[i][j] + "\t");
                }
                for(j = 0;j <= weiR;j++){
                    System.out.print(twoArray1[i][j] + "\t");
                }
                System.out.println();
            }
        }
        else{
            for(i = shouL;i <= weiL;i++){
                for(j = shouR;j <= weiR;j++){
                    System.out.print(twoArray1[i][j] + "\t");
                }
                System.out.println();
            }
        }

        sc.close();
    }

}

实验结果:

结果分析:

在此次试验中更加促进了两个人的协作,同时在Java编程中更好地利用了类的调用,更好地利用之前的程序进行更改,能够合理利用之前做过的。

对于多行代码的大程序能够更好地理清思路,是代码更容易理解。

结对实现:

解决方法:刘双渤、刘洪阳;

代码实现:刘双渤、刘洪阳。

时间: 2024-12-11 10:28:27

环形二维数组最大子数组的和的相关文章

软件工程概论---环状二维数组最大子数组和

1,题目要求 根据软件工程概论--<环状一维数组最大子数组和>和<二维数组最大子数组和>两篇博客,求环状二维数组的和. 2,思路设计 根据前面两篇博客思路做参考.在二维数组的基础上扩充二维数组的列为2*col-1.再进行二维数组的求和即可. 3,代码 #include <iostream> #include<time.h> using namespace std; #define max(a,b) ((a)>(b)?(a):(b)) #define M

环状二维数组最大子数组求和

题目:返回一个二维整数数组中最大子数组的和.要求:输入一个二维整形数组,数组里有正数也有负数.二维数组首尾相接,象个一条首尾相接带子一样. n数组中连续的一个或多个整数组成一个子数组,每个子数组都有一个和.求所有子数组的和的最大值.要求时间复杂度为O(n). 结对编程要求: 两人结对完成编程任务. 一人主要负责程序分析,代码编程. 一人负责代码复审和代码测试计划. 发表一篇博客文章讲述两人合作中的过程.体会以及如何解决冲突(附结对开发的工作照). 结对开发过程: 这次的编程开发是基于上次的以为数

首尾相连的二维数组最大子数组求和

题目:返回一个二维整数数组中最大子数组的和.要求:输入一个二维整形数组,数组里有正数也有负数.二维数组首尾相接,象个一条首尾相接带子一样. n数组中连续的一个或多个整数组成一个子数组,每个子数组都有一个和.求所有子数组的和的最大值.要求时间复杂度为O(n). 结对编程要求: 两人结对完成编程任务. 一人主要负责程序分析,代码编程. 一人负责代码复审和代码测试计划. 发表一篇博客文章讲述两人合作中的过程.体会以及如何解决冲突(附结对开发的工作照). 结对开发过程: 这次的编程开发是基于上次的以为数

编程之美2.15 二维数组最大子数组的和(数组下标从(1,1)开始)

      首先,我们看到这篇文章的题目,我们就会想到之前的那个题目 -- 连续子数组最大和问题.这个问题无疑就是把原问题扩展到二维的情况.       想起来这个问题也不是很难,我们可以求解一维矩阵的思想,即我们可以固定住行(或列),之后,我们去求解列(或行)所构成的最大和就可以了. 这里的解法利用的是固定住行,然后求解需要寻找的列之和,利用书中提到的一个公式: 以左上角的元素(1,1)和当前元素(i,j)为顶点对的子矩阵的部分和,部分和的计算如下 PS[i][j] = A[i][j]+PS[

求二维数组最大子数组的和

结对开发成员:朱少辉,侯涛亮 朱少辉:负责程序分析,代码编程 侯涛亮:负责代码复审和代码测试 设计思路: 根据求一维子数组的最大子数组和的列子,把二维数组分解成若干个一维子数组,如m行n列的数组可分为(m+1)*m/2个子数组,在求每个一维数组的最大子数组和,把这些和放入一个数组中,求这个数组的最大值就是二维数组最大子数组的和.这种算法的时间复杂度为o(n^3). 代码: #include<iostream> using namespace std; void main() { int m,n

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

 要求: 1,输入一个二维整形数组,数组里有正数也有负数. 2,二维数组中连续的一个子矩阵组成一个子数组,每个子数组都有一个和, 3,求所有子数组的和的最大值. 设计思路: 参照一维整数数组求解最大子数组的方法,我们想着将二维数组通过行不同,列相加的方法转化为一维整数数组再求解最大子数组之和. 具体实现:先求出每一行的最大子数组之和,之后比较得出最大和MaxSum,然后通过上述方法求二行的最大子数组之和并与MaxSum比较,用MaxSum存放较大值.以此类推,求三行,四行... 最后实现最大子数

结对开发——返回整数数组最大子数组和2

返回整数数组最大子数组和2 为了实现“敏捷开发”的目的,老师让我们采取“迭代”的方法进行项目的开发,这不,对于周一的求最大子数组和又有了新的要求,如下: 1.延续上次的要求,这里不再赘余… 2.如果数组A[0]……A[j-1]首尾相连,允许A[i-1],……A[n-1],A[0]……A[j-1]之和最大: 3.同时返回最大子数组的位置: 4.要求程序必须能处理1000 个元素,且每个元素是int32 类型的. 一.实验设计思路 首先实现的是数组首尾相连,先存入数组,再将原数组反向存储形成环形数组

求一维循环数组最大子数组

设计思路: 一维循环数组:一维整数组头跟尾相连形成一个环. 问题解决方案:将一个一维数组扩大两倍,求新的数组的最大子数组即可. import java.io.IOException; public class xunhuanshuzu { public static void main(String[] args)throws IOException{ int []a= {23,-12,234,-234,123,2,0,1,-1,-34}; int n=a.length; int []b=new

求一维循环数组最大子数组的和

结对成员:信1201-1班 于海洋   袁佩佩 一.题目与要求 题目:返回一个整数数组中最大子数组的和. 要求: 输入一个整形数组,数组里有正数也有负数. 数组中连续的一个或多个整数组成一个子数组,每个子数组都有一个和.如果数组A[0]……A[j-1]首尾相邻,允许A[i-1], …… A[n-1], A[0]……A[j-1]之和最大. 同时返回最大子数组的位置. 二.设计思路 利用之前的返回一个整数数组最大子数组的和程序的思路,不过这里将数放到一个链表里,首尾相连,来求最大子数组的和. 三.源