LeetCode#594. Longest Harmonious Subsequence

• 题目：输入一个数组，求满足条件的数组序列的最长长度，条件为：数组元素值较大者与较小者相差1

  Input: [1,3,2,2,5,2,3,7]
  Output: 5
  Explanation: The longest harmonious subsequence is [3,2,2,2,3].
  

• 难度：Easy
• 思路：符合条件的数组序列，可以分为较大者序列和较小者序列，整个符合条件的序列长度是较大者序列长度+较小者序列长度。因此定义small和large两个变量记录序列的长度，序列长度的更新分为3种情况。具体情况分析见代码
• 代码：

方法一：运行时间打败94%

public class Solution {
    public int findLHS(int[] nums) {
        if(nums == null || nums.length <= 1){
            return 0;
        }
        Arrays.sort(nums);
        int len = nums.length;
        int max = 0;
        int curr = 0;
        int small = 1;
        int large = 0;
        //分情况讨论：1.如果当前元素等于前一个元素（再继续判断它是属于小的还是大的）
        //2.如果当前元素值比前一个元素值大1（判断该元素是下一次比较的较大者，还是本次比较的较大者）
        //3.如果不符合上面两种情况，则重置large和small
        //每一轮比较，如果large不为0的话，说明有存在值相差1的序列对，则更新max的值
        for(int i = 1; i < len; i++){
            if(nums[i] == nums[i-1] + 1){
                if(small == 0){
                    small = 1;
                }else if(large != 0){
                    max = Math.max(max, large+small);
                    small = large;
                }
                large = 1;
            }else if(nums[i] == nums[i-1]){
                if(large == 0){
                    small++;
                }else{
                    large++;
                }
            }else{
                small = 1;
                large = 0;
            }
            if(large != 0){
                max = Math.max(max, large+small);
            } 
        }
        return max;
    }
}

方法二：利用数据结构来简化分类讨论（这个算法效率没有方法一高）

public class Solution {
    public int findLHS(int[] nums) {
        if(nums == null || nums.length <= 1){
            return 0;
        }
        HashMap<Integer,Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; i++){
            if(map.containsKey(nums[i])){
                map.put(nums[i],map.get(nums[i]) + 1);
            }else{
                map.put(nums[i],1);
            }
        }
        int result = 0;
        for(int key: map.keySet()){
            if(map.containsKey(key+1)){
                result = Math.max(result, map.get(key) + map.get(key+1));
            }
        }
        return result;
    }      
}