680_Valid_Palindrome_II

qiyuangong · qiyuangong · commit d462877890e4 · 2018-12-04T23:11:39.000+08:00
diff --git a/README.md b/README.md
@@ -152,6 +152,7 @@ Also, there are open source implementations for basic data structs and algorithm
 | 581 | [Shortest Unsorted Continuous Subarray](https://leetcode.com/problems/subtree-of-another-tree/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/581_Shortest_Unsorted_Continuous_Subarray.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/581_Shortest_Unsorted_Continuous_Subarray.java) | 1. Sort and find the difference (min and max), O(nlgn)<br>2. Using stack to find boundaries (push when correct order, pop when not correct), O(n) and O(n)<br>3. Find min and max of unordered array, O(n) and O(1)|
 | 617 | [Merge Two Binary Trees](https://leetcode.com/problems/merge-two-binary-trees/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/617_Merge_Two_Binary_Trees.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/617_Merge_Two_Binary_Trees.java) | Traverse both trees Recursion & Iterative (stack) |
 | 654 | [Maximum Binary Tree](https://leetcode.com/problems/maximum-binary-tree/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/654_Maximum_Binary_Tree.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/654_Maximum_Binary_Tree.java) | 1. Divide and conquer, recursive, O(n^2)<br>2. Monotonic stack, O(n) |
+| 680 | [Valid Palindrome II](https://leetcode.com/problems/valid-palindrome-ii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/680_Valid_Palindrome_II.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/680_Valid_Palindrome_II.java) | Recursively check s[left == end, when not equal delete left or right. |
 | 692 | [Top K Frequent Words](https://leetcode.com/problems/top-k-frequent-words/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/692_Top_K_Frequent_Words.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/692_Top_K_Frequent_Words.java) | 1. Sort based on frequency and alphabetical order, O(nlgn) and O(n)<br>2. Find top k with Heap, O(nlogk) and O(n) |
 | 697 | [Degree of an Array](https://leetcode.com/problems/degree-of-an-array/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/697_Degree_of_an_Array.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/697_Degree_of_an_Array.java) | 1. Find degree and value, then find smallest subarray (start and end with this value), O(n) and O(n)<br>2. Go through nums, remember left most pos and right most for each value, O(n) and O(n) |
 | 703 | [Kth Largest Element in a Stream](https://leetcode.com/problems/kth-largest-element-in-a-stream/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/703_Kth_Largest_Element_in_a_Stream.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/703_Kth_Largest_Element_in_a_Stream.java) | 1. Sort and insert into right place, O(nlgn) and O(n)<br>2. k largest heap, O(nlogk) and O(n) |
diff --git a/java/680_Valid_Palindrome_II.java b/java/680_Valid_Palindrome_II.java
@@ -0,0 +1,20 @@
+class Solution {
+    public boolean isPalindromeRange(String s, int i, int j) {
+        for (int k = i; k <= i + (j - i) / 2; k++) {
+            if (s.charAt(k) != s.charAt(j - k + i)) return false;
+        }
+        return true;
+    }
+    public boolean validPalindrome(String s) {
+        for (int i = 0; i < s.length() / 2; i++) {
+            if (s.charAt(i) != s.charAt(s.length() - 1 - i)) {
+                // Not equal
+                int j = s.length() - 1 - i;
+                // delete left or right
+                return (isPalindromeRange(s, i + 1, j) ||
+                        isPalindromeRange(s, i, j - 1));
+            }
+        }
+        return true;
+    }
+}
diff --git a/python/252_Meeting_Rooms.py b/python/252_Meeting_Rooms.py
@@ -34,4 +34,4 @@ def canAttendMeetings(self, intervals):
         for i in range(ls - 1):
             if intervals[i].end > intervals[i + 1].start:
                 return False
-        return True
+        return True
diff --git a/python/680_Valid_Palindrome_II.py b/python/680_Valid_Palindrome_II.py
@@ -0,0 +1,30 @@
+class Solution(object):
+    # def validPalindrome(self, s):
+    #     """
+    #     :type s: str
+    #     :rtype: bool
+    #     """
+    #     def is_pali_range(i, j):
+    #         return all(s[k] == s[j - k + i] for k in range(i, j))
+
+    #     for i in xrange(len(s) / 2):
+    #         if s[i] != s[~i]:
+    #             j = len(s) - 1 - i
+    #             return is_pali_range(i + 1, j) or is_pali_range(i, j - 1)
+    #     return True
+
+    # Actually we can make this solution more general
+    def validPalindrome(self, s):
+        return self.validPalindromeHelper(s, 0, len(s) - 1, 1)
+
+    def validPalindromeHelper(self, s, left, right, budget):
+        # Note that budget can be more than 1
+        while left < len(s) and right >= 0 and left <= right and s[left] == s[right]:
+            left += 1
+            right -= 1
+        if left >= len(s) or right < 0 or left >= right:
+            return True
+        if budget == 0:
+            return False
+        budget -= 1
+        return self.validPalindromeHelper(s, left + 1, right, budget) or self.validPalindromeHelper(s, left, right - 1, budget)
