add: 516 & 523

Author: hijiangtao

README.md

@@ -53,4 +53,6 @@ This is the solutions collection of my LeetCode submissions, most of them are pr
 |384|[Shuffle an Array](https://leetcode.com/problems/shuffle-an-array/) | [JavaScript](./src/shuffle-an-array/res.js)|Medium|
 |404|[Sum of Left Leaves](https://leetcode.com/problems/sum-of-left-leaves/) | [JavaScript](./src/sum-of-left-leaves/res.js)|Easy|
 |434|[Number of Segments in a String](https://leetcode.com/problems/number-of-segments-in-a-string/) | [JavaScript](./src/number-of-segments-in-a-string/res.js)|Easy|
+|516|[Longest Palindromic Subsequence](https://leetcode.com/problems/longest-palindromic-subsequence/) | [JavaScript](./src/longest-palindromic-subsequence/res.js)|Medium|
+|523|[Continuous Subarray Sum](https://leetcode.com/problems/continuous-subarray-sum/) | [JavaScript](./src/continuous-subarray-sum/res.js)|Medium|
 ||[]() | [](./src//res.js)||

src/continuous-subarray-sum/res.js

@@ -0,0 +1,39 @@
+/**
+ * res.js
+ * @authors Joe Jiang ([email protected])
+ * @date    2017-04-06 14:45:14
+ * 
+ * Problem: Given a list of non-negative numbers and a target integer k, write a function to check if the array has a continuous subarray of size at least 2 that sums up to the multiple of k, that is, sums up to n*k where n is also an integer.
+ * 
+ * Reference: https://discuss.leetcode.com/topic/80793/java-o-n-time-o-k-space
+ * Idea: We iterate through the input array exactly once, keeping track of the running sum mod k of the elements in the process. If we find that a running sum value at index j has been previously seen before in some earlier index i in the array, then we know that the sub-array (i,j] contains a desired sum.
+ * 
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {boolean}
+ */
+let checkSubarraySum = function(nums, k) {
+	let map = new Map(),
+		len = nums.length,
+		sum = 0;
+
+	if (len < 2) return false;
+	map.set(0, -1);
+
+	for (let i = 0; i < len; i++) {
+		sum += nums[i];
+		if (k !== 0) {
+			sum %= k;
+		}
+
+		let preInd = map.get(sum);
+		// console.log('i', i, 'preInd', preInd);
+		if (preInd !== undefined) {
+			if (i - preInd > 1) return true;
+		} else {
+			map.set(sum, i);
+		}
+	}
+
+	return false;
+};

src/longest-palindromic-subsequence/res.js

@@ -0,0 +1,38 @@
+/**
+ * res.js
+ * @authors Joe Jiang ([email protected])
+ * @date    2017-04-06 16:14:56
+ * 
+ * Problem: Given a string s, find the longest palindromic subsequence's length in s. You may assume that the maximum length of s is 1000.
+ * 
+ * Tips: What you should pay attention is that, the subsequence is not guaranteed to be continuous, which means some characters would be deleted when it meets the maximum situation. It confused me for quite a long time. 
+ * 
+ * @param {string} s
+ * @return {number}
+ */
+let longestPalindromeSubseq = function(s) {
+	let len = s.length,
+		matrix = new Array(len);
+
+	for (let i = 0; i < len; i++) {
+		matrix[i] = new Array(len);
+		matrix[i][i] = 1;
+	}
+
+	for (let i = len - 1; i >= 0; i--) {
+		for (let j = i + 1; j < len; j++) {
+			if (s[i] === s[j]) {
+				matrix[i][j] = j - i === 1 ? 2 : matrix[i + 1][j - 1] + 2;
+			} else {
+				matrix[i][j] = max(matrix[i][j - 1], matrix[i + 1][j]);
+			}
+		}
+	}
+
+	return matrix[0][len - 1];
+};
+
+let max = function(a, b) {
+	if (a > b) return a;
+	else return b;
+}