一维和二维子数组之和最大值

最新推荐文章于 2022-08-12 17:20:41 发布
最新推荐文章于 2022-08-12 17:20:41 发布
阅读量135 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/AndyDai/p/4734108.html
版权

一、约定

  1. 所谓子数组，是连续的。
  2. 只求和，不返回子数组的具体位置。
  3. 元素是整数，所以数组可能包含正整数，0，负数。

二、一维数组子数组之和的最大值

  1. 最直接的求法——暴力求解

           记sum[ i,...j ]为数组A中第i个元素到第j个元素的和（其中0<=i<=j<n）遍历所有可能的sum[ i,...j ]。

/**
 * 常规解法求一位最大字段和
 * @author DaiSong
 * @Date 2013年12月2日
 */
public class OneDimensionalWithNormalSolution {
	
	/**方法一，复杂度O(N^3)
	 * @param a
	 * @param n
	 * @return
	 */
	public static int MaxSum1(int[] a,int n){
		
		int maximum=Integer.MIN_VALUE;
		int sum;
		for(int i=0;i<n;i++){
			for(int j=i;j<n;j++){
				sum=0;
				for(int k=i;k<=j;k++){
					sum+=a[k];
				}
				if(sum>maximum){
					maximum=sum;
				}
			}
		}
		return maximum;
	}
	
	/**
	 * 方法二，改进：将算法的最后一个for循环省略，避免重复计算，复杂度O(N^2).
	 * @param a
	 * @param n
	 * @return
	 */
	public static int MaxSum2(int[] a,int n){
		int maximum=Integer.MIN_VALUE;
		int sum;
		for(int i=0;i<n;i++){
			sum=0;
			for(int j=i;j<n;j++){
				sum+=a[j];
				if(sum>maximum){
					maximum=sum;
				}
			}
		}
		return maximum;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int a[]={0,-2,3,5,-1,2};
		int b[]={1,-2,3,5,-3,2};
		int c[]={-9,-2,-3,-5,-3};
		//MaxSum1 Test Result
		System.out.println(MaxSum1(a, 6)+" "+MaxSum1(b, 6)+" "+MaxSum1(c, 5));
		//MaxSum2 Test Result
		System.out.println(MaxSum2(a, 6)+" "+MaxSum2(b, 6)+" "+MaxSum2(c, 5));
	}
}

       2.递归法

          将数组（A[0],...A[n-1]）分为长度相等的两端数组（A[0],...A[n/2-1]）和（A[n/2],...,A[N-1]）,分别求出这两端数组各自的最大字段和，则数组（A[0],...A[n-1]）的最大字段和为以下三种情况的最大值：

  1. （A[0],...A[n-1]）的最大字段和与（A[0],...A[n/2-1]）的最大字段和相同。
  2. （A[0],...A[n-1]）的最大字段和与（A[n/2],...,A[N-1]）的最大字段和相同。
  3. （A[0],...A[n-1]）的最大字段和跨过其中间两个元素A[n/2-1]到A[n/2]。

/**
 * 分治策略求一维最大字段和,时间复杂度为O(N*log2N),(以2为底)
 * @author DaiSong
 * @Date 2013年12月2日
 */
public class OneDimensionalWithDivideAndConquer {
	
	public static int FindMaxSubArray(int[] a ,int low,int high){
		int leftSum=0,rightSum=0,crossSum=0;
		if(low==high){
			return a[low];
		}
		int mid=(low+high)/2;
		leftSum=FindMaxSubArray(a,low,mid);
		rightSum=FindMaxSubArray(a,mid+1,high);
		crossSum=FindMaxCrossSubArray(a,low,mid,high);
		return Math.max(Math.max(leftSum, rightSum),crossSum);
	}
	
	/**
	 * 找到跨越终点的子数组的最大值
	 * @param a
	 * @param low
	 * @param mid
	 * @param high
	 * @return
	 */
	public static int FindMaxCrossSubArray(int[] a,int low ,int mid,int high){
		int leftSum=Integer.MIN_VALUE;
		int rightSum=Integer.MIN_VALUE;
		int sum=0;
		for(int i=mid;i>=low;i--){
			sum+=a[i];
			if(sum>leftSum){
				leftSum=sum;
			}
		}
		sum=0;
		for(int i=mid+1;i<=high;i++){
			sum+=a[i];
			if(sum>rightSum){
				rightSum=sum;
			}
		}
		return leftSum+rightSum;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int a[]={0,-2,3,5,-1,2};
		int b[]={1,-2,3,5,-3,2};
		int c[]={-9,-2,-3,-5,-3};
		System.out.println(FindMaxSubArray(a,0,5));
		System.out.println(FindMaxSubArray(b,0,5));
		System.out.println(FindMaxSubArray(c,0,4));
	}

}

    3.DP

       考虑数组第一个元素A[0]，以及最大的一段数组（A[ i ],...,A[ j ]）之间的关系。有以下几种情况：

  1. 当0=i=j是，元素本身构成和的最大的一段。
  2. 当0=i<j，和最大的一段以A[0]开始。
  3. 当0<i时，元素A[0]跟和最大的一段没有关系。

/**
 * DP求解一维最大字段和问题。
 * @author DaiSong
 * @Date 2013年12月2日
 */
public class OneDimensionalWithDP {
	
	/**
	 * 方法一，逆序。时间复杂度O(N),空间复杂度O(N).
	 * @param a
	 * @param n
	 * @return
	 */
	public static int MaxSumDp1(int[] a,int n){
		int[] start=new int[n];
		int[] all=new int[n];
		start[n-1]=all[n-1]=a[n-1];
		for(int i=n-2;i>=0;i--){
			start[i]=Math.max(a[i], a[i]+start[i+1]);
			all[i]=Math.max(start[i],all[i+1]);
		}
		return all[0];
	}
	
	/**
	 * 方法二，验证正序和逆序没有差别
	 * @param a
	 * @param n
	 * @return
	 */
	public static int MaxSumDp2(int[] a,int n){
		int[] start=new int[n];
		int[] all=new int[n];
		start[0]=all[0]=a[0];
		for(int i=1;i<n;i++){
			start[i]=Math.max(a[i], a[i]+start[i-1]);
			all[i]=Math.max(start[i],all[i-1]);
		}
		return all[n-1];
	}
	
	/**
	 * 方法三，空间复杂度进一步改进为O(N).
	 * @param a
	 * @param n
	 * @return
	 */
	public static int MaxSumDp3(int[] a,int n){
		int start,all;
		start=all=a[0];
		for(int i=1;i<n;i++){
			start=Math.max(a[i], a[i]+start);
			all=Math.max(start,all);
		}
		return all;
	}
	
	/**
	 * 方法四，方法三的另一种写法。
	 * @param a
	 * @param n
	 * @return
	 */
	public static int MaxSumDp4(int[] a,int n){
		int start,all;
		start=all=a[0];
		for(int i=1;i<n;i++){
			if(start<0){
				start=0;
			}
			start+=a[i];
			if(start>all){
				all=start;
			}
		}
		return all;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int a[]={0,-2,3,5,-1,2};
		int b[]={1,-2,3,5,-3,2};
		int c[]={-9,-2,-3,-5,-3};
		System.out.println(MaxSumDp1(a,6)+" "+MaxSumDp1(b,6)+" "+MaxSumDp1(c,5));
		System.out.println(MaxSumDp2(a,6)+" "+MaxSumDp2(b,6)+" "+MaxSumDp2(c,5));
		System.out.println(MaxSumDp3(a,6)+" "+MaxSumDp3(b,6)+" "+MaxSumDp3(c,5));
		System.out.println(MaxSumDp4(a,6)+" "+MaxSumDp4(b,6)+" "+MaxSumDp4(c,5));
	}
}

三、二维数组的最大子数组和的最大值

      1.暴力求解

         枚举矩阵的四个点，再就矩阵内的数的和。矩阵求和由于存在重复计算，可以预处理用数组存起来。

/**
 * 暴力解法及其优化求解二维最大子段和。
 * @author DaiSong
 * @Date 2013年12月2日
 */
public class TwoDimensionalWithNormalSolution {
	static int MAX = 501;
	static int[][] ps = new int[MAX][MAX];

	/**
	 * 方法一，暴力求解，时间复杂度为O(N^3*M^3)
	 * 
	 * @param a
	 * @param m
	 * @param n
	 * @return
	 */
	public static int MaxSum1(int a[][], int m, int n) {

		int max = Integer.MIN_VALUE;
		int sum;
		for (int min_i = 0; min_i < n; min_i++) {
			for (int max_i = min_i; max_i < n; max_i++) {
				for (int min_j = 0; min_j < m; min_j++) {
					for (int max_j = min_j; max_j < m; max_j++) {
						// 求区域矩阵的和
						sum = 0;
						for (int i = min_i; i <= max_i; i++) {
							for (int j = min_j; j <= max_j; j++) {
								sum += a[i][j];
							}
						}
						if (sum > max) {
							max = sum;
						}
					}
				}
			}
		}
		return max;
	}

	/**
	 * 方法二，改进：考虑到区域的和需要频繁计算，做了预处理。用ps[n][m]存放i=1..n,j=1..m区域和。
	 * 时间复杂度为O(N^2*M^2)
	 * @param a
	 * @param n
	 * @param m
	 * @return
	 */
	public static int MaxSum2(int a[][], int n, int m) {

		int max = Integer.MIN_VALUE;
		int sum;
		PieceSum(a, n, m);
		for (int min_i = 1; min_i <= n; min_i++) {
			for (int max_i = min_i; max_i <= n; max_i++) {
				for (int min_j = 1; min_j <= m; min_j++) {
					for (int max_j = min_j; max_j <= m; max_j++) {
						// 求区域矩阵的和
						sum = ps[max_i][max_j]-ps[min_i-1][max_j]-ps[max_i][min_j-1]+ps[min_i-1][min_j-1];
						if (sum > max) {
							max = sum;
						}
					}
				}
			}
		}
		return max;
	}

	/**
	 * 预处理求出区域和，时间复杂度为O(N*M)
	 * @param a
	 * @param n
	 * @param m
	 */
	public static void PieceSum(int[][] a, int n, int m) {
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= m; j++) {
				ps[i][j] = ps[i - 1][j] + ps[i][j - 1] - ps[i - 1][j - 1]
						+ a[i][j];
			}
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int a[][] = { { -1, -4, 3 }, { 3, 4, -1 }, { -5, -2, 8 } };
		System.out.println(MaxSum1(a, 3, 3));
		int b[][] = { {0,0,0,0},{ 0, -1, -4, 3 }, { 0, 3, 4, -1 }, { 0, -5, -2, 8 } };
		System.out.println(MaxSum2(b, 3, 3));
	}
}

         2.DP

          把二维数组压缩为一维数组，再求和。

/**
 * 最大子阵，压缩矩阵为一维数组，转化为求最大字段和问题，运用动态规划求解。
 * @author DaiSong
 * @Date 2013年12月2日
 */
public class TwoDimensionalWithDP {
	 
	 /**转化为一位数组，求一维数组的最大字段和。时间复杂度O(N*M*Min(N,M))
	 * @param a
	 * @param n
	 * @param m
	 * @return
	 */
	public static int TwoMaxSum(int a[][],int n,int m){
		 int minMax;
		 int  Max = Integer.MIN_VALUE;  
	     for (int i=0; i<n; i++){
	         minMax = OneMaxSum(a[i], m);  
	         if (minMax > Max)
	        	 Max = minMax;  
	         for (int j=i+1; j<n; j++){  
	             for (int k=0; k<n; k++){  
	                 a[i][k] += a[j][k];  
	             }  
	             minMax = OneMaxSum(a[i], n);  
	             if (minMax > Max)
	            	 Max = minMax;  
	         }  
	     }  
	     return Max;
	 }
	 
	 /**一维最大字段和
	 * @param a
	 * @param n
	 * @return
	 */
	public static int OneMaxSum(int[] a,int n){
			int start,all;
			start=all=a[0];
			for(int i=1;i<n;i++){
				start=Math.max(a[i], a[i]+start);
				all=Math.max(start,all);
			}
			return all;
		}
	
	 public static void main(String[] args) {
		 int[][] a ={{-1,-4,3},{3,4,-1},{-5,-2,8}};
	     System.out.print(TwoMaxSum(a,3,3));  
	 }  
}


参考资料：《编程之美》，《算法导论》。

www.gavinboo.com同步发布。

版权声明：本文为博主原创文章，未经博主允许不得转载。

转载于:https://www.cnblogs.com/AndyDai/p/4734108.html

a136358
关注
单调栈，求解 数组区间中最小数*区间和的最大值
Unknownfuture的博客
04-30 393
题目描述： 思路来源： 求数组中区间中最小数*区间所有数和的最大值 原文写的很好，本文附上Java版本代码，以及自己的注释理解 public int getMaxSum(int[] nums) { int maxSum = Integer.MIN_VALUE; int[] preSum = getPreSumArr(nums); // 维持一个单调栈，存下标。 栈内下标对应元素单调非递减 LinkedList<Integer> s
python一维数组和二维数组_Python numpy实现二维数组和一维数组拼接的方法
weixin_39639919的博客
11-27 4741
Python numpy实现二维数组和一维数组拼接的方法撰写时间：2017.5.23一维数组1.numpy初始化一维数组a = np.array([1,2,3]);print a.shape输出的值应该为（3，）二维数组2.numpy初始化二维数组a = np.array([[1,2,3]]);b = np.array([[1],[2],[3]]);print a.shape//(1，3）prin...
一维整数组所有子数组和的最大值
weixin_30279315的博客
03-10 97
最基本的思路： 先找出所有子数组； 将所有子数组存入一个二维数组中（所有子数组存入二维数组中：以第i个开头的子数组们存入第i行）； 找出每行的最大值存入另一个数组中； 分别比较再找出最大值子数组。 public class Shuzu { public static void main(String[] args){ int []a= {0,1,2,3,...
二维数组的相关内容（与一维数组对比）
一宿的博客
03-04 992
上图所示是一维数组的相关知识。 当变成二维数组时就变成这样： 我们一对一对的看。 1.brr brr+1 可以把二维数组看作成一个特殊的一维数组，这个特殊的一维数组的每一个单元都是一个一维数组。类比一维数组，一维数组的数组名为首元素地址，数据类型为指针，到了二位数组，因为也将它看作是一维数组，那么它的数组名就是一个指向由二维数组第一行组成的数组的指针，叫做数组指针。而数组名＋n，在一维数组中...
贪心算法：寻找最优方案，分配问题、区间覆盖问题、最大子列和问题等
habe33的博客
08-12 2266
贪心算法：寻找最优方案，分配问题、区间覆盖问题、最大子列和问题等
编程之美：求数组的子数组之和的最大值
weixin_33779515的博客
08-17 89
1.问题描述 一个有N个整数元素的一维数组( A[0], A[1], ... , A[n-2], A[n-1])，子数组之和的最大值是什么?(要求子数组的元素是连续的) 例子：有数组( -2, 5, 3, -6, 4, -8, 6)，则其子数组之和的最大值为8，其对应的数组为(5,3)   2.分析与解法 解法一：采用直接法，记Sum[i...j]，为数组A中从第i到第j之间所有...
python+numpy按行求一个二维数组的最大值方法
09-19
本篇文章将详细介绍如何利用NumPy库在Python中按行求解一个二维数组的最大值。 首先，我们要明确问题：给定一个二维数组，我们的目标是找出每行中的最大值，并将这些最大值组成一个新的列向量。例如，对于二维数组`...
C++求二维数组中的最大值和最小值的方法
最新发布
10-09
在C++编程中，处理二维数组是常见的任务之一，特别是在数据处理、图像处理等领域。本文将详细介绍如何在C++中找到二维数组中的最大值和最小值。首先，我们需要理解二维数组的基本概念。二维数组可以看作是一组一维...
Java中一维二维数组的静态和动态初始化
08-29
Java中一维二维数组的静态和动态初始化 Java中的数组是一种基本的数据结构，它可以存储多个相同类型的数据，包括一维数组和二维数组。今天，我们将讨论Java中一维数组和二维数组的静态和动态初始化。 一维数组的...
JS中取二维数组中最大值的方法汇总
10-22
总结一下，从二维数组中找最大值的方法有多种，从基础的双重循环到更高级的数组方法如`map()`和`reduce()`，再到利用函数的`apply()`特性。选择哪种方法取决于具体的需求，如代码可读性、性能要求以及对JavaScript...
求一维数组中最大元素
cad866的专栏
11-02 1310
#import #define size 5 int main(int argc, const char * argv[]) {     @autoreleasepool {                           // insert code here...         NSLog(@"Hello, World!
二维数组的输入输出及求和
twjk的博客
12-26 1732
这里要用到三个自定义的函数，分别是输入，输出，求和。 我用的是input, output 和 sum , 大家随意，只要和其他函数不冲突就可以了！ 不说那么多废话，直接上代码，大家自己看。 #include <stdio.h> #define N 100 void input(int a[N][N], int m, int n); void output(int a[N][N], int m, int n); void sum(int a[N][N], int m, int n
二维数组：把一个二维数组中每行最大的值集合到一个一维数组中
xngjing的博客
07-17 3655
二维数组也是一个一维数组，每个元素都是一个一维数组。初学数组，我认为画图最能帮助我理解，一看就明白，之后再向怎么去写程序，在一步一步调试程序，直到完成。
二维线段树——区间最值系列
mumei的博客
01-27 2430
最近这几天学习了一下二维线段树，二维线段树主要有两种写法，四分树和树套树，暂时还没写过四分树，因为这个东西确实不常用，而且不好写也不好调。 树套树的写法思路其实不难，首先我们知道，我们通常的线段树的操作都是在线段上进行的，即一维的，当推广到二维上，即矩阵时，我们就把它叫做二维线段树。 二维线段树其实就是我们再操作时先找到对应x轴的区间（即第一维），之后再找到对应y轴的区间（即第二维），进行相...
使用int min = Integer.MAX_VALUE导致int类型越界 之 LeetCode刷题【16. 最接近的三数之和】
麦田里的守望者
10-25 978
1 问题 在刷LeetCode题目时，有用到最小值比较，所以我就定义了一个int类型的最大值，即Integer.MAX_VALUE，然后后续的程序运行，发现程序出错，不是语法问题，最后发现就是int类型数据越界。 2 题目 给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。 示例： 输入：nums = [-1,2,1,-4], target = 1 输出：2 解释：与 t
leetcode(363):Max Sum of Rectangle No Larger Than K
sunwill的博客
12-24 408
【原题】 题目链接Max Sum of Rectangle No Larger Than KGiven a non-empty 2D matrix matrix and an integer k, find the max sum of a rectangle in the matrix such that its sum is no larger than k.Example: Given
一维数组中最大连续子数组、二维矩阵中最大子矩阵
Bob__yuan的博客
09-15 894
  共两道题，都是不难，还是记录一下： 1、在一个一维数组中，找出连续子数组的最大和：LeetCode - 53. Maximum Subarray 2、在一个二维矩阵中，找出子矩阵最大和：https://www.51nod.com/Challenge/Problem.html#problemId=1051 一、数组子数组最大和 Given an integer array nums, find...
java int 最值 Integer.MAX_VALUE+1=Integer.MIN_VALUE
04-17 1316
Integer.MAX_VALUE+1=Integer.MIN_VALUE java int类整数的最大值是2的31次方-1=2147483648 - 1 = 2147483647 即 Integer.MAX_VALUE; JAVA的int类整数的最大值等于int类整数的最小值-1 即Integer.MAX_VALUE+1=Integer.MIN_VALUE=-2147483648 常用于比较大小 若比较找最小则定义min为Integer.MAX_VALUE 若比较找最大则定义max= Integer.MI
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值