某书2018提前批笔试题之0、1个数相同的最长子序列-CSDN博客

一、题目

　　给定一个只包含0和1的数组，找到其中包含相同0的个数和1的个数的最长子序，输出子序列的长度，要求在o（n）时间内完成。

二、思路

　　这个题目，看起来比较简单，一些同学可能认为题目的描述符合动态规划的特征，然后就开始用动态规划解，努力找状态转移方程。这些同学的感觉，是很正确的。但，找状态转移方程，我们要对原来的数组进行变换一下。

　　原来是0和1的串，我们将0都换为-1。这样题目目标就变成，找到一个最长的子串，子串数字和是0。设原数组为A, DP[i]表示从0开始到i的子数组和。DP遍历一遍数组即可。

　　情况一：子串都是从头开始

　　例如数组10101010产生的DP为：

0	1	2	3	4	5	6	7
1	0	1	0	1	0	1	0

这个例子，最后一个值是0，并且长度是偶数位。直接满足了结果，长度为8。

数组1101000产生的DP为：

0	1	2	3	4	5	6
1	2	1	2	1	0	-1

5的位置为0，最长子串从0开始到5，长度为6。

　　情况二：子串不是从头开始

　　上面这两个例子，所求的子串都是从头开始，如果不是从头开始，会是什么样的呢？看这个例子：1101100

0	1	2	3	4	5	6
1	2	1	2	3	2	1

通过观察上面的表格，我们可以得到，DP[0]==DP[6]==DP[2]，DP[1]==DP[3]==D[5]. 根据DP的定义，如果DP[i]==DP[j]，我们用map保存DP的值到位置的映射，如下表：

DP值	位置	最大位置	最小位置	最大长度
1	0，2，6	6	0	6
2	1，3，5	5	1	4
3	4	4	4	0
最长子串长度				6

我们最终的算法，要综合考虑最常串是否从头开始的。上面的这个思路，时间复杂度是O(n),空间复杂度也是O(n)。

三、代码

package redbook;

/**
 * 给定一个只包含0和1的数组，找到其中包含相同0的个数和1的个数的最长子序，输出子序列的长度，要求在o（n）时间内完成。
 */

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

public class Main2 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            int n = in.nextInt();
            //定义数组，存储输入的01串
            int[] arr = new int[n];
            //输入01数字串，并且把其中的0换成-1
            for (int i = 0; i < n; i++) {
                arr[i] = in.nextInt() == 0 ? -1 : 1;
            }
            //调用方法,输出包含相同0的个数和1的个数的最长子序的长度
            int maxLength = maxLength(arr, arr.length);
            System.out.println(maxLength);
        }
        in.close();
    }

    public static int maxLength(int[] arr, int arrLength) {
        int max=0;//保存最大的长度
        int sum = 0;//保存累加的和
        int index = 0;
        Map<Integer, TreeSet<Integer>> hashMap = new HashMap<>();//保存数字的和与其位置的映射

        for (int i = 0; i < arrLength; i++) {
            sum = sum + arr[i];//依次累加求和

            //第一种情况：子串都是从头开始
            if (sum == 0) {
                index = i;
            }

            //第二种情况：子串都不是从头开始，将数字的和与其位置的映射存入HashMap中
            if (hashMap.containsKey(sum)) {
                hashMap.get(sum).add(i);
            } else {
                TreeSet<Integer> treeSet = new TreeSet<>();
                treeSet.add(i);
                hashMap.put(sum, treeSet);
            }
        }

        //判断
        if (index != 0) {
            max = index + 1;//第一种情况：子串都是从头开始,子串最大值为index+1
        } else { //第二种情况：子串不是从头开始,子串最大值为位置的最大值-位置的最小值
            for (TreeSet<Integer> treeSet : hashMap.values()) {
                max = (treeSet.last() - treeSet.first()) > max ? (treeSet.last() - treeSet.first()) : max;
            }
        }

        return max;
    }

}