DP 求子数组的最大和

输入一个整形数组,数组里有正数也有负数。
数组中连续的一个或多个整数组成一个子数组,每个子数组都有一个和。
求所有子数组的和的最大值。要求时间复杂度为O(n)。


例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5,和最大的子数组为3, 10, -4, 7, 2,
因此输出为该子数组的和18。





package DP;

/**
 * 输入一个整形数组,数组里有正数也有负数。
数组中连续的一个或多个整数组成一个子数组,每个子数组都有一个和。
求所有子数组的和的最大值。要求时间复杂度为O(n)。

例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5,和最大的子数组为3, 10, -4, 7, 2,
因此输出为该子数组的和18。
 *
 */
public class MaxSubSequenceSum {

	public static void main(String[] args) {
//		int[] A = {-2,-3,4,-1,-2,1,5,-3};
		int[] A = {1, -2, 3, 10, -4, 7, 2, -5};
		System.out.println(findMaxSum(A) + ", " + findMaxSum2(A));
	}

	// DP
	// sum[i+1] = max(a[i+1], sum[i] + a[i+1])
	//	result = max(result, sum[i])
	public static int findMaxSum(int[] anArray) {
		// 对于每个元素,存放包括这个元素的最大连续和
		int[] maxIthSum = new int[anArray.length+1];
		
		maxIthSum[0] = anArray[0];
		for(int i=1; i<anArray.length; i++){
			maxIthSum[i] = Math.max(maxIthSum[i-1]+anArray[i], anArray[i]);
		}
		
		// 在maxIthSum中找到最大值即可
		int max = Integer.MIN_VALUE;
		for(int i=0; i<anArray.length; i++){
			max = Math.max(max, maxIthSum[i]);
		}
		
		return max;
	}
	
	// DP 减少空间
	public static int findMaxSum2(int[] anArray) {
		int currentSum = 0;
		int currentMax = 0;

		for (int j = 0; j < anArray.length; j++) {
			currentSum += anArray[j];

			if (currentMax < currentSum)
				currentMax = currentSum;
			else if (currentSum < 0)
				currentSum = 0;
		}
		return currentMax;
	}
	
	
}


  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
首先,我们可以通过暴力枚举所有子数组,并对每个子数组最小公倍数,然后再统计质因子数目之和。 代码如下: ```python def gcd(a, b): if a == 0: return b return gcd(b % a, a) def lcm(a, b): return a * b // gcd(a, b) def factor_count(n): count = 0 i = 2 while i * i <= n: if n % i == 0: count += 1 while n % i == 0: n //= i i += 1 if n > 1: count += 1 return count def subarray_lcm_factor_count(arr): n = len(arr) ans = 0 for i in range(n): for j in range(i, n): lcm_val = arr[i] for k in range(i + 1, j + 1): lcm_val = lcm(lcm_val, arr[k]) ans += factor_count(lcm_val) return ans ``` 但是,这个算法的时间复杂度是 $O(n^3 \log m)$,其中 $m$ 是数组中的最大值。对于较大的数据集,这个算法显然不可行。 因此,我们需要寻找更高效的算法。我们可以考虑先对数组进行预处理,计算出每个位置的最小公倍数,然后通过这些信息来计算子数组的最小公倍数以及质因子数目之和。 具体来说,我们可以使用一个二维数组 $dp$ 来预处理最小公倍数,其中 $dp_{i,j}$ 表示以位置 $i$ 开始、长度为 $2^j$ 的子数组的最小公倍数。状态转移方程如下: $$ dp_{i,j} = \text{lcm}(dp_{i,j-1}, dp_{i+2^{j-1},j-1}) $$ 同时,我们可以再使用一个二维数组 $f$ 来预处理质因子数目之和,其中 $f_{i,j}$ 表示以位置 $i$ 开始、长度为 $2^j$ 的子数组的质因子数目之和。状态转移方程如下: $$ f_{i,j} = f_{i,j-1} + f_{i+2^{j-1},j-1} - f_{i,j-1} \times f_{i+2^{j-1},j-1} $$ 这个方程的含义是,将一个长度为 $2^j$ 的子数组拆分成两个长度为 $2^{j-1}$ 的子数组,分别计算它们的质因子数目之和,然后将它们合并起来,避免重复计算。 最终,我们可以通过下面的代码来实现这个算法: ```python def subarray_lcm_factor_count(arr): n = len(arr) max_pow = int(math.log2(n)) + 1 dp = [[0] * max_pow for _ in range(n)] for i in range(n): dp[i][0] = arr[i] for j in range(1, max_pow): for i in range(n - 2 ** j + 1): dp[i][j] = lcm(dp[i][j - 1], dp[i + 2 ** (j - 1)][j - 1]) f = [[0] * max_pow for _ in range(n)] for i in range(n): f[i][0] = factor_count(arr[i]) for j in range(1, max_pow): for i in range(n - 2 ** j + 1): f[i][j] = f[i][j - 1] + f[i + 2 ** (j - 1)][j - 1] - f[i][j - 1] * f[i + 2 ** (j - 1)][j - 1] ans = 0 for j in range(max_pow): for i in range(n - 2 ** j + 1): ans += f[i][j] lcm_val = dp[i][j] for k in range(j - 1, -1, -1): if i + 2 ** k <= n - 2 ** j: lcm_val = lcm(lcm_val, dp[i + 2 ** k][k]) ans += factor_count(lcm_val) return ans ``` 这个算法的时间复杂度为 $O(n \log n)$,可以通过本题。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值