solve problem Longest Harmonious Subsequence

Author: P-ppc

README.md

@@ -156,6 +156,7 @@ All solutions will be accepted!
 |645|[Set Mismatch](https://leetcode-cn.com/problems/set-mismatch/description/)|[java/py/js](./algorithms/SetMismatch)|Easy|
 |58|[Length Of Last Word](https://leetcode-cn.com/problems/length-of-last-word/description/)|[java/py/js](./algorithms/LengthOfLastWord)|Easy|
 |14|[Longest Common Prefix](https://leetcode-cn.com/problems/longest-common-prefix/description/)|[java/py/js](./algorithms/LongestCommonPrefix)|Easy|
+|594|[Longest Harmonious Subsequence](https://leetcode-cn.com/problems/longest-harmonious-subsequence/description/)|[java/py/js](./algorithms/LongestHarmoniousSubsequence)|Easy|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/LongestHarmoniousSubsequence/README.md

@@ -0,0 +1,2 @@
+# Longest Harmonious Subsequence
+This problem is easy to solve by hashmap

algorithms/LongestHarmoniousSubsequence/Solution.java

@@ -0,0 +1,47 @@
+class Solution {
+    public int findLHS(int[] nums) {
+        int maxLength = 0;
+        Map<String, Map<String, Object>> harmoniousMap = new HashMap<String, Map<String, Object>>();
+        
+        for (int num : nums) {
+            String prevKey = String.valueOf(num - 1) + "X" + String.valueOf(num),
+                   nextKey = String.valueOf(num) + "X" + String.valueOf(num + 1);
+            
+            if (harmoniousMap.get(prevKey) == null) {
+                Map<String, Object> m = new HashMap<String, Object>();
+                m.put("length", 1);
+                m.put("base", num);
+                m.put("isHarmonious", false);
+                harmoniousMap.put(prevKey, m);
+            } else {
+                Map<String, Object> m = harmoniousMap.get(prevKey);
+                m.put("length", (Integer) m.get("length") + 1);
+                if (!((Integer) m.get("base")).equals(num)) {
+                    m.put("isHarmonious", true);
+                }
+                if ((Boolean) m.get("isHarmonious")) {
+                    maxLength = Math.max(maxLength, (Integer) m.get("length"));
+                }
+            }
+            
+            if (harmoniousMap.get(nextKey) == null) {
+                Map<String, Object> m = new HashMap<String, Object>();
+                m.put("length", 1);
+                m.put("base", num);
+                m.put("isHarmonious", false);
+                harmoniousMap.put(nextKey, m);
+            } else {
+                Map<String, Object> m = harmoniousMap.get(nextKey);
+                m.put("length", (Integer) m.get("length") + 1);
+                if (!((Integer) m.get("base")).equals(num)) {
+                    m.put("isHarmonious", true);
+                }
+                if ((Boolean) m.get("isHarmonious")) {
+                    maxLength = Math.max(maxLength, (Integer) m.get("length"));
+                }
+            }
+        }
+        
+        return maxLength;
+    }
+}

algorithms/LongestHarmoniousSubsequence/solution.js

@@ -0,0 +1,47 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findLHS = function(nums) {
+    let maxLength = 0,
+        harmoniousMap = new Map()
+    
+    nums.forEach(num => {
+        let prevKey = `${num - 1}X${num}`,
+            nextKey = `${num}X${num + 1}`
+        
+        if (harmoniousMap.get(prevKey) === undefined) {
+            harmoniousMap.set(prevKey, {
+                length: 1,
+                base: num,
+                isHarmonious: false
+            })
+        } else {
+            harmoniousMap.get(prevKey).length++
+            if (harmoniousMap.get(prevKey).base !== num) {
+                harmoniousMap.get(prevKey).isHarmonious = true
+            }
+            if (harmoniousMap.get(prevKey).isHarmonious) {
+                maxLength = Math.max(maxLength, harmoniousMap.get(prevKey).length)
+            }
+        }
+        
+        if (harmoniousMap.get(nextKey) === undefined) {
+            harmoniousMap.set(nextKey, {
+                length: 1,
+                base: num,
+                isHarmonious: false
+            })
+        } else {
+            harmoniousMap.get(nextKey).length++
+            if (harmoniousMap.get(nextKey).base !== num) {
+                harmoniousMap.get(nextKey).isHarmonious = true
+            }
+            if (harmoniousMap.get(nextKey).isHarmonious) {
+                maxLength = Math.max(maxLength, harmoniousMap.get(nextKey).length)
+            }
+        }
+    })
+    
+    return maxLength
+};

algorithms/LongestHarmoniousSubsequence/solution.py

@@ -0,0 +1,39 @@
+class Solution(object):
+    def findLHS(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        max_length = 0
+        harmonious_map = {}
+        
+        for num in nums:
+            key_prev = str(num - 1) + 'X' + str(num)
+            key_next = str(num) + 'X' + str(num + 1)
+            if harmonious_map.get(key_prev) == None:
+                harmonious_map[key_prev] = {
+                    'length': 1,
+                    'base': num,
+                    'is_harmonious': False
+                }
+            else:
+                harmonious_map[key_prev]['length'] += 1
+                if harmonious_map[key_prev]['base'] != num:
+                    harmonious_map[key_prev]['is_harmonious'] = True
+                if harmonious_map[key_prev]['is_harmonious'] == True:
+                    max_length = max(max_length, harmonious_map[key_prev]['length'])
+            
+            if harmonious_map.get(key_next) == None:
+                harmonious_map[key_next] = {
+                    'length': 1,
+                    'base': num,
+                    'is_harmonious': False
+                }
+            else:
+                harmonious_map[key_next]['length'] += 1
+                if harmonious_map[key_next]['base'] != num:
+                    harmonious_map[key_next]['is_harmonious'] = True
+                if harmonious_map[key_next]['is_harmonious'] == True:
+                    max_length = max(max_length, harmonious_map[key_next]['length'])
+            
+        return max_length