【2017猿辅导】求和为0的最长连续子数组

求和为0的最长连续子数组

题目描述

给定一个数组，数组中元素的值只能是1或者-1，求其和为0的最长连续子序列的长度；

数组为1，-1，1，-1，1，-1，1，-1，其结果为：8

数组为1，1，-1，1，1，-1，-1，其结果为：6

参考代码1

参考以上思路实现：

 
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<map>
#include<stack>
#include<sstream>
#include<assert.h>
#include<math.h>
using namespace std;
 
void MaxSubSumof0(vector<int>num,vector<int>&res)
{
	int maxlen = 0; int maxi, maxj;
	vector<int>sum(num.size() + 1, 0);
	for (int i = 0; i < num.size(); i++)
		sum[i + 1] = sum[i] + num[i];
	for (int i = 0; i < sum.size(); i++)
	{
		for (int j = sum.size()-1; j >= i; j--)
		{
			if (sum[i] == sum[j])
			{
				if (maxlen < j - i)
				{
					maxlen = j - i;
					maxi = i;
					maxj = j;
				}
				break;//这次循环是最大的，中间有重复的忽略
			}
		}
	}
	for (int i = maxi; i < maxj; i++)
		res.push_back(num[i]);
	int i = 0;
	for ( i = 0; i<res.size()-1; i++)
		cout << res[i] << " ";
	cout << res[i] << endl;
}
int main(){	 
	int n,i;
	cin >> n;
	vector<int>num(n, 0);
	vector<int>res;
	for ( i = 0; i<num.size(); i++)
		cin >> num[i];
	MaxSubSumof0(num, res);
	return 0;
}

原文：https://blog.csdn.net/dongyanwen6036/article/details/88719060

参考代码2

• 使用Map：key存放数组前（i+1）数的前缀和dp[i]，value存放dp[i]到dp[0]的距离=下标距离=i+1（i：0~数组长度-1）

• 该题转换为：求数组dp中出现两个相同数时，这两个数在dp数组中的最大距离

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/**
 * dp[i] = arr[0] + arr[1] + ... + arr[i]
 * 如果 sum(arr[m]...arr[n]) = 0;
 * 那么 sum(arr[0]...arr[m-1]) = sum(arr[0]...arr[n])
 * 和为0的最长子序列: maxLen = n - m + 1, (dp[n] = dp[m-1])
 */
public class Main {

    public static void main(String[] arg) {
        Scanner scan = new Scanner(System.in);
        while (scan.hasNext()) {
            int n = scan.nextInt();
            int[] numbers = new int[n];
            for (int i = 0; i < n; i++) {
                numbers[i] = scan.nextInt();
            }
            System.out.println(solve(numbers, n));
        }
        scan.close();
    }

    private static int solve(int[] numbers, int n) {
        int[] dp = new int[n];
        dp[0] = numbers[0];
        for (int i = 1; i < n; i++) {
            dp[i] = dp[i - 1] + numbers[i];
        }
        Map<Integer, Integer> dpMap = new HashMap<>();
        dpMap.put(0, 0);
        //记录最大长度
        int maxLen = 0;
        for (int i = 0; i < n; i++) {
        	//如果Map中没有出现，则加入到dpMmap
            if (!dpMap.containsKey(dp[i])) {
                dpMap.put(dp[i], i + 1);
            } else {
            	//如果在Map中找到相同的数，计算距离
                int len = i - dpMap.get(dp[i]) + 1;
                maxLen = maxLen < len ? len : maxLen;
            }
        }
        return maxLen;
    }
}