Java-最长和谐子序列（力扣）

和谐数组是指一个数组里元素的最大值和最小值之间的差别 正好是 1 。

现在，给你一个整数数组 nums ，请你在所有可能的子序列中找到最长的和谐子序列的长度。

数组的子序列是一个由数组派生出来的序列，它可以通过删除一些元素或不删除元素、且不改变其余元素的顺序而得到。

示例 1：

输入：nums = [1,3,2,2,5,2,3,7]
输出：5
解释：最长的和谐子序列是 [3,2,2,2,3]

示例 2：

输入：nums = [1,2,3,4]
输出：2

示例 3：

输入：nums = [1,1,1,1]
输出：0

我写的解题思路用枚举但感觉像是暴力解法，比较复杂，最终的效果只能击败百分之八！

我的思路就是先排序再用双重循环遍历每一种方案，把所有结果装到一个数组p里面，再取最大值

太繁琐了

class Solution {
    public int findLHS(int[] nums) {
        Arrays.sort(nums);

        int p[]=new int[nums.length];
       int q=0;
       for(int j=0;j<nums.length;j++){
           int min=nums[j];
           for(int i=j+1;i<nums.length;i++){
               if(nums[i]-min<=1){
                   p[q]++;
               }else{
                   int max=nums[i-1];
                   if(max-min!=1){
                       p[q]=0;
                   }
                   break;

               }

               }
           if(nums[nums.length-1]-min==0){
               p[q]=0;
           }

           q++;
       }
       Arrays.sort(p);
       if(p[p.length-1]==0){
           return 0;
       }
       else{
           return p[p.length-1]+1;

       }


    }
}

 

我们来看看其他大佬是怎么做的

 使用HashMap<Integer,Integer>来存每个元素及其个数,再遍历每个元素，如果（元素值+1）存在，就把符合要求的所有个数相加，用一个Math.max()来求最大值即可

class Solution {
    public int findLHS(int[] nums) {
        Map<Integer ,Integer> map=new HashMap<>();
        for(int x:nums){
            map.put(x,map.getOrDefault(x,0)+1);
        }
        int res=0;
        for(int x:map.keySet()){
            if(map.containsKey(x+1)){
                res=Math.max(res,map.get(x)+map.get(x+1));
            }
        }

        return res;


    }
    }