longest-consecutive-sequence

题目

题目链接
题目大意：给定一个数组，数组无序并且可以重复。找到最大连续序列的值。

对于重复问题可以通过hashSet过滤掉访问过的节点，因为题目的意思是当重复节点时就不算。

思路

最开始的想法是动态规划，任意一个节点dp[i] = value(num[i]-1) + value(num[i]+1)

后来发现想法是对的 但是不能更新每一个点的最长序列的值，如果1,2,3的值分别为1,2,3但实际应该是3

所以另一种思考方法时：分为很多个区间，min—max 每一次更新区间
更新分为三种情况：[leftA,rightA] [leftB,rightB] 看是否能作为左边的最大值或者作为B的最小值 或者合并A,B

import java.util.*;
public class Solution {
    HashMap<Integer,Integer> Min = new HashMap<Integer,Integer>();
    HashMap<Integer,Integer> Max = new HashMap<Integer,Integer>();
    HashSet<Integer>  visited = new HashSet<Integer>();

    HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
     public int longestConsecutive(int[] num) {
            if(num==null || num.length==0){
                return 0;
            }
            //初始化
            map.put(num[0], 1);
            for(int i=1;i<num.length;i++){
                if(map.containsKey(num[i])){
                    continue;
                }
                map.put(num[i], 1);
                //作为区间的最大值
                if(map.containsKey(num[i]-1)){
                    int left = (num[i]) -  map.get(num[i]-1);
                    int right = num[i];
                    int length = right - left +1;
                    map.put(left, length);
                    map.put(right, length);
                }
                //作为区间的最小值 其实也完成了两段区间的合并功能
                if(map.containsKey(num[i]+1)){
                    int left = num[i] - map.get(num[i]) +1;
                    int right = num[i] + map.get(num[i]+1);
                    int length = right - left +1;
                    map.put(left, length);
                    map.put(right,length);
                }
            }
            int max = 0;
            Iterator iter = map.entrySet().iterator();
            while(iter.hasNext()){
                Map.Entry entry = (Map.Entry) iter.next();
                int min = (int) entry.getKey();
                int length = (int) entry.getValue();
                if(length>max){
                    max = length;
                }
            }
            return max;
     }

// public int longestConsecutive(int[] num) {
// if(num==null || num.length==0){
// return 0;
// }
// for(int i=0;i<num.length;i++){
// if(visited.contains(num[i])){
// continue;
// }
// visited.add(num[i]);
// //判断是否可以作为Min
// if(Min.containsKey(num[i]+1)){
// int min = num[i]+1;
// int max = Min.get(min);
// Min.remove(min);
// Min.put(min-1, max);
// Max.put(max,min-1);
// //看能够与左边集合合并
// if(Max.containsKey(num[i]-1)){
// int min2 = Max.get(num[i]-1);
// //删除四个表
// Min.remove(min-1);
// Min.remove(min2);
// Max.remove(num[i]-1);
// Max.remove(max);
// //加入合并后的表
// Min.put(min2, max);
// Max.put(max, min2);
// }
// }else if(Max.containsKey(num[i]-1)){//判断是否可以最为Max
// int max = num[i]-1;
// int min = Max.get(max);
// Max.remove(max);
// Max.put(max+1, min);
// Min.put(min, max+1);
// //看能否用右边的表合并
// if(Min.containsKey(num[i]+1)){
// int max2 = Min.get(num[i]+1);
// //删除四个表
// Min.remove(min);
// Min.remove(num[i]+1);
// Max.remove(max);
// Max.remove(max2);
// 
// Min.put(min, max2);
// Max.put(max2, min);
// }
// }else{
// Max.put(num[i], num[i]);
// Min.put(num[i], num[i]);
// 
// }
// }
// //
// Iterator iter = Min.entrySet().iterator();
// int result = Integer.MIN_VALUE;
// while(iter.hasNext()){
// Map.Entry entry = (Map.Entry) iter.next();
// int min = (int) entry.getKey();
// int max = (int) entry.getValue();
// if(max-min>result){
// result = max - min;
// }
// }
// return result+1; 
// }
}