Palindrome

Palindrome

Author: dandanhub

Diff for: BackTracking/README.md

@@ -60,26 +60,6 @@ I failed the test case: "2001:0db8:85a3:0:0:8A2E:0370:7334:". The issue here is
 The java file contains solutions to leetcode question about
 palindrome. Some of the problems use backtracking.
 
-## 131. Palindrome Partitioning (Medium) *
-Given a string s, partition s such that every substring of the partition is a palindrome.
-
-Return all possible palindrome partitioning of s.
-
-For example, given s = "aab",
-Return
-~~~~
-[
-  ["aa","b"],
-  ["a","a","b"]
-]
-~~~~
-
-#### Solution
-Use backtracking template.
-1. Given a string s, if s.substring(0, i) is a valid palindrome, then recursively check the palindrome partition of s.substring(i).
-2. The base case of recursion is when a string is empty, we can add the partitions to final result and return.
-3. Handle the base return case carefully.
-
 ## 132. Palindrome Partitioning II (Hard) * (Backtracking exceed time limit)
 Given a string s, partition s such that every substring of the partition is a palindrome.
 
@@ -177,7 +157,7 @@ It takes O(n) to get the solution. The code to build KMP table is kind of compli
 ###### Solution 2
 Recursively check the longest palindrome substring from 0.
 Starting from the char in mid of the array.
-The time complexity n/2 + (n/2 - 1) + (n/2 - 2) + ... + (n/2 - n/2) = n/2 * n/2 - (n/4 + n^2/8) = O(n^2) 
+The time complexity n/2 + (n/2 - 1) + (n/2 - 2) + ... + (n/2 - n/2) = n/2 * n/2 - (n/4 + n^2/8) = O(n^2)
 
 ## 266. Palindrome Permutation (Easy) *
 Given a string, determine if a permutation of the string could form a palindrome.

Diff for: String/Palindrome.md

@@ -36,6 +36,58 @@ public class Solution {
 }
 ~~~
 
+## 5. Longest Palindromic Substring
+Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.
+
+Example:
+~~~
+Input: "babad"
+Output: "bab"
+Note: "aba" is also a valid answer.
+~~~
+
+Example:
+~~~
+Input: "cbbd"
+Output: "bb"
+~~~
+
+#### Solution
+1. O(n^2) 每个节点作为中间点往两边搜索
+2. Manacher’s Algorithm O(n) Solution 可做做到O(n)
+
+Time O(n^2) <br>
+~~~
+public class Solution {
+    public String longestPalindrome(String s) {
+        if (s == null || s.length() == 0) return s;
+        String ans = "";
+
+        for (int i = 0; i < s.length(); i++) {
+            String m = helper(s, i, i);
+            String n = helper(s, i, i + 1);
+            if (m.length() > ans.length()) ans = m;
+            if (n.length() > ans.length()) ans = n;
+        }
+
+        return ans;
+    }
+
+    private String helper(String s, int start, int end) {
+        int i = start;
+        int j = end;
+        while (i >= 0 && j < s.length()) {
+            if (s.charAt(i) != s.charAt(j)) {
+                break;
+            }
+            i--;
+            j++;
+        }
+        return s.substring(i + 1, j);
+    }
+}
+~~~
+
 ## 131. Palindrome Partitioning (Medium) *
 Given a string s, partition s such that every substring of the partition is a palindrome.
 
@@ -104,3 +156,91 @@ public class Solution {
     }
 }
 ~~~
+
+## 132. Palindrome Partitioning II (Hard) *
+Given a string s, partition s such that every substring of the partition is a palindrome.
+
+Return the minimum cuts needed for a palindrome partitioning of s.
+
+For example, given s = "aab",
+Return 1 since the palindrome partitioning ["aa","b"] could be produced using 1 cut.
+
+#### Solution
+1. 最笨的DP，if (s[j:i] is palindrome) DP[i] = dp[j] + 1, i和j有n^2个可能性，每次判断if (s[j:i] is palindrome)需要O(n)的时间，总耗时O(n^3), 不出意料TLE, 如何加快速度
+2. 可以提前计算一个palindrome lookup table, if (s[i] == s[j]) pal[i][j] = p[i+1][j-1]. **注意2维循环的时候i从高位到低位，j从低位到高位**，这样可以提高速度到O(n^2)
+3. Discussion top solution 给出了O(n^2) time, O(n) space的方法
+
+Attempt: 没有想出O(n^2)的方法
+~~~
+public class Solution {
+    public int minCut(String s) {
+        if (s == null || s.length() == 0) return 0;
+
+        int len = s.length();
+
+        // pre-calculate the palindrom look-up table
+        boolean[][] palindrome = new boolean[len][len];
+        for (int i = len - 1; i >= 0; i--) {
+            for (int j = i; j < len; j++) {
+                if (s.charAt(i) == s.charAt(j)) {
+                    if (j - i < 2) {
+                        palindrome[i][j] = true;
+                    }
+                    else {
+                        palindrome[i][j] = palindrome[i + 1][j - 1];
+                    }
+                }
+            }
+        }
+
+        int[] dp = new int[len];
+
+        for (int i = 0; i < len; i++) {
+            dp[i] = i; // dp[0] = 0
+            for (int j = i; j >= 0; j--) {
+                if (palindrome[j][i]) {
+                    if (j == 0) dp[i] = 0;
+                    else dp[i] = Math.min(dp[i], dp[j - 1] + 1);
+                }
+            }
+        }
+
+        return dp[len - 1];
+    }
+}
+~~~
+
+## 266. Palindrome Permutation (Easy)
+Given a string, determine if a permutation of the string could form a palindrome.
+
+For example,
+"code" -> False, "aab" -> True, "carerac" -> True.
+
+#### Solution
+1. Two pass的方法，第一遍扫描这个str, 统计每个字符的词频，然后第二遍判断是否出现了>1的奇数词频的char
+2. One pass 用set，char不在set里面，把char加进来，char在set里面，把char移除，最后判断set.size() == 0 || set.size() == 1 <br>
+这题和409相似
+
+## 409. Longest Palindrome (Easy)
+Given a string which consists of lowercase or uppercase letters, find the length of the longest palindromes that can be built with those letters.
+
+This is case sensitive, for example "Aa" is not considered a palindrome here.
+
+Note:
+Assume the length of given string will not exceed 1,010.
+
+Example:
+~~~
+Input:
+"abccccdd"
+
+Output:
+7
+
+Explanation:
+One longest palindrome that can be built is "dccaccd", whose length is 7.
+~~~~
+
+#### Solution
+1. 笨方法也是扫描两边，第一遍统计每个单词出现的频率，第二遍数数
+2. One pass, 类似于266，用HashSet, char不在set里面，把char加进来，char在set里面，说明当前的char出现第二次了，count += 2, 最后如果set不为空的话，说明至少有一个char落单了，count += 1

Diff for: String/README.md

@@ -1,85 +0,0 @@
-The Java code summarizes solutions for leetcode string problems.
-
-# StringSolution.java
-
-## 139. Word Break
-Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s can be segmented into a space-separated sequence of one or more dictionary words. You may assume the dictionary does not contain duplicate words.
-
-For example, given
-s = "leetcode",
-dict = ["leet", "code"].
-
-Return true because "leetcode" can be segmented as "leet code".
-
-#### Solution
-Dynamic Programming.
-1. One dimension array dp[], dp[i] means whether a substring from 0 to i (exclusive) has a valid word break or not.
-2. Transition formula: dp[i] = (dp[0] && dict.contains(s.substring(0, i + 1))) || (dp[1] && dict.contains(s.substring(1, i + 1)))) || ... || (dp[i] && dict.contains(s.substring(i, i + 1)))).
-
-## 140. Word Break II
-Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, add spaces in s to construct a sentence where each word is a valid dictionary word. You may assume the dictionary does not contain duplicate words.
-
-Return all such possible sentences.
-
-For example, given
-s = "catsanddog",
-dict = ["cat", "cats", "and", "sand", "dog"].
-
-A solution is ["cats and dog", "cat sand dog"].
-
-#### Solution
-Niiave backtacking got TLE with the test case:
-~~~~
-"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-["a","aa","aaa","aaaa","aaaaa","aaaaaa","aaaaaaa","aaaaaaaa","aaaaaaaaa","aaaaaaaaaa"]
-
-answer: []
-~~~~
-
-Use a HashMap<String, LinkedList<String>> map to store word breaks of substrings, so as to avoid duplicated search.
-
-## 293. Flip Game (Easy)
-You are playing the following Flip Game with your friend: Given a string that contains only these two characters: + and -, you and your friend take turns to flip two consecutive "++" into "--". The game ends when a person can no longer make a move and therefore the other person will be the winner.
-
-Write a function to compute all possible states of the string after one valid move.
-
-For example, given s = "++++", after one move, it may become one of the following states:
-~~~~
-[
-  "--++",
-  "+--+",
-  "++--"
-]
-~~~~
-If there is no valid move, return an empty list [].
-
-#### Solution
-Simply iterate the string.
-
-## 165. Compare Version Numbers
-Compare two version numbers version1 and version2.
-If version1 > version2 return 1, if version1 < version2 return -1, otherwise return 0.
-
-You may assume that the version strings are non-empty and contain only digits and the . character.
-The . character does not represent a decimal point and is used to separate number sequences.
-For instance, 2.5 is not "two and a half" or "half way to version three", it is the fifth second-level revision of the second first-level revision.
-
-Here is an example of version numbers ordering:
-~~~~
-0.1 < 1.1 < 1.2 < 13.37
-~~~~
-
-#### Solution
-WRONG: my first idea is to compare v1 and v2 at their min length; and then handle the one that is longer. However, it becomes trivial to handle corner case, like "1.0" v.s. "1", and "01" v.s. "1".
-
-~~~~
-for (int i = 0; i < Math.min(tokens1.length, tokens2.length); i++) {
-  int v1 = Integer.parseInt(tokens1[i]);
-  int v2 = Integer.parseInt(tokens2[i]);
-  if (v1 != v2) {
-    return v1 > v2 ? 1 : -1;
-    }
-}
-~~~~
-
-Think from the other side, compare at their max length, for the one which is shorter, simply set it to 0.