leetcode

Author: openinx

leetcode/README.md

@@ -468,6 +468,61 @@ double findKth(int a[], int m, int b[], int n, int k){
 * [Longest Palindromic Substring](https://oj.leetcode.com/problems/longest-palindromic-substring/) [Manacher’s Algorithm](http://leetcode.com/2011/11/longest-palindromic-substring-part-ii.html)算法。能在O(N)的复杂度内找到一个字符串的最长回文子串。假设用动态规划或者暴力，复杂度都为O(N^2). 后缀数组也能解决这个问题。
 
 
+* [Regular Expression Matching ](https://oj.leetcode.com/problems/regular-expression-matching/)没找到什么线性算法。 暴力算法来源于leetcode，假设`s=abbbbbbbbbbbbbbbbbb`, `t=ab*cd`这样的话。可能会出现如下情况：当有一个`*`字符时，最坏的情况下会达到O（n*m),这还的用KMP算法去做字串匹配. 当多个 `\*`字符时，就是`\*`的指数级复杂度了。
+
+```
+s = abbbbbbbbbbbbbbbbbb
+     ^
+t = acd
+
+s = abbbbbbbbbbbbbbbbbb
+      ^
+t = a cd
+
+s = abbbbbbbbbbbbbbbbbb
+       ^
+t = a  cd
+
+s = abbbbbbbbbbbbbbbbbb
+        ^
+t = a   cd
+
+....
+```
+
+
+* [Scramble String ](https://oj.leetcode.com/problems/scramble-string/) DFS 类似卡特兰解空间搜索加上减枝，减枝技巧包括： 两串长度相等； 两串无序hash值相等; 两串同类字符数必须相等。
+复杂度分析： 
+
+```
+h[n] = 2 * sum( h[i] * h[n-i] ) (1<= i < n )
+```
+
+* [Recover Binary Search Tree ](https://oj.leetcode.com/problems/recover-binary-search-tree/) 
+
+假设一个序列 , 其中 8 和 14 被误交换了。 如图， 导致序列会有两个`>` , 记录第1个`>`的前驱和第2个`>`的后继两个指针，交换即可.
+
+```
+# noraml
+
+  < < <  <  <  <
+1 5 8 10 11 14 23 
+
+# missing swap
+
+  < <  >  <  > < 
+1 5 14 10 11 8 23
+    ^        ^
+
+# after
+
+  < <  >  <  > < 
+1 5 8 10 11 14 23
+    ^        ^
+``` 
+
+
+* [Minimum Window Substring](https://oj.leetcode.com/problems/minimum-window-substring/)  字符串滑动窗口， 维护4个变量： left 左端点 ； right 右端点 ; cur[256] 各字符当前窗口内的计数值； curlen 当前窗口内目标串字符的个数。 时间复杂度O(N). 类似的题： [Substring with Concatenation of All Words ](https://oj.leetcode.com/problems/substring-with-concatenation-of-all-words/), [Longest Substring Without Repeating Characters ](https://oj.leetcode.com/problems/longest-substring-without-repeating-characters/) . 
 
 
 

leetcode/a.out

@@ -15,34 +15,35 @@ using namespace std;
 class Solution {
 public:
     string minWindow(string S, string T) {
-    	int anslen = S.size() + 1 , start, end, i = 0, j = 0 , curlen = 0; 
-    	unordered_map<char, int> tm , dict ; 
-    	for(i = 0 ; i < T.size(); ++ i) tm[ T[i] ] ++ ;
-    	for(i = 0 ; i < S.size(); ++ i){
-    		if( tm[ S[i] ] == 0 ) continue;
-    		while( j < i && ( dict[ S[i] ] >= tm[ S[i] ] || tm[ S[j] ] == 0)) { 
-    			j ++ ; 
-    			curlen -- ; 
-    			if( dict[ S[j] ] > 0 ) dict[ S[j] ] -- ;
-    		}
-    		dict[ S[i] ] ++ ; 
-    		curlen ++; 
-    		if(curlen >= T.size()){
-    			if( anslen > (i - j + 1)){
-	    			anslen = i - j + 1;
-    				start = j ; 
-    				end = i ; 
-    			}
-    		}
-    	}
-    	cout << "answer length:" << anslen << " start:" << start << " end:" << end << endl;
-    	return anslen != S.size() + 1 ? S.substr(start, end - start + 1): "";
+        int i, n , m , l, r, curlen, len,  start;
+        int need[256] = {0}, cur[256] = {0}; 
+        n = S.size(); m = T.size();
+        for(i = 0 ; i < m; ++ i)
+            need[T[i]] ++ ;
+        len = n + 1 ;  start = 0;
+        for(curlen = l = r = 0 ; r < n ; ++ r){
+            if(need[ S[r] ] == 0 ) continue;
+            if( ++ cur[ S[r] ] <= need[ S[r] ]) 
+                ++ curlen;
+            if(curlen == m){
+                while( need[ S[l] ] == 0 || cur[ S[l] ] > need[ S[l] ]) {
+                    if( cur[ S[l] ] > need[ S[l] ]) --cur[ S[l] ];
+                    ++ l;
+                }
+                if( r - l + 1 < len){
+                    len = r - l + 1;
+                    start = l ;
+                }
+            }
+        }
+        return len == n + 1 ? "" : S.substr(start, len);
     }
 };
 
 int main(){
 	Solution sol;
 	cout << sol.minWindow("a", "a") << endl;
 	cout << sol.minWindow("ADOBECODEBANC", "ABC") << endl;
+    cout << sol.minWindow("acbbaca", "aba") << endl;
 	return 0;
 }

leetcode/minimum-window-substring.cpp

@@ -0,0 +1,109 @@
+#include <iostream>
+#include <cstdio>
+#include <algorithm>
+
+using namespace std;
+
+
+struct TreeNode{
+	int val; 
+	TreeNode *left;
+	TreeNode *right;
+	TreeNode(int x): val(x), left(NULL), right(NULL){}
+};
+
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+
+	void traval(TreeNode *root){
+		if(root == NULL) return;
+		traval(root->left);
+		if(prev == NULL){
+			prev = root;
+		}else{
+			if(prev->val > root->val){
+				if(first == NULL){
+					first = prev;
+				}
+				second = root;
+			}
+			prev = root;
+		}
+		traval(root->right);
+	}
+
+    void recoverTree(TreeNode *root) {
+    	first = second = prev = NULL;
+    	traval(root);
+    	if(first != NULL ){
+    		swap(first->val, second->val);
+    	}
+    }
+private:
+	TreeNode *first,  *second, *prev;
+};
+
+
+void dfs(TreeNode * root, int &index){
+	if(root == NULL) return;
+	dfs(root->left, index);
+	cout << "## " << (++index) << ":"<< root->val << endl ; 
+	dfs(root->right, index);
+}
+
+void test1(){
+	int n , x ; 
+	TreeNode *a1, *a3, *a6, *a8, *a7, *a4, *a10 , *a14, *a13;
+	a1 = new TreeNode(1);
+	a3 = new TreeNode(3);
+	a6 = new TreeNode(6);
+	a8 = new TreeNode(8);
+	a7 = new TreeNode(7);
+	a4 = new TreeNode(4);
+	a10 = new TreeNode(10);
+	a14 = new TreeNode(14);
+	a13 = new TreeNode(13);
+	a4->left = a3 ; 
+	a4->right = a10;
+	a3->left = a1 ;
+	a3->right = a6; 
+	a6->left = a8 ; 
+	a6->right = a7 ; 
+	a10->right = a14;
+	a14->left = a13;
+	int index = 0 ; 
+	dfs(a4, index);
+
+	Solution sol;
+	sol.recoverTree(a4);
+
+	index = 0;
+	dfs(a4, index);
+}
+
+
+void test2(){
+	TreeNode *a0, *a1;
+	a0 = new TreeNode(0);
+	a1 = new TreeNode(1);
+	a0->left = a1;
+
+	Solution sol;
+	sol.recoverTree(a0);
+
+	int index = 0;
+	dfs(a0, index);
+}
+
+int main(){
+	test2();
+}

leetcode/recover-binary-search-tree.cpp

@@ -0,0 +1,32 @@
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <cstring>
+#include <iostream>
+#include <cassert>
+
+using namespace std;
+
+class Solution {
+public:
+  bool isMatch(const char *s, const char *p) {
+    assert(s && p);
+    if (*p == '\0') return *s == '\0';
+    if (*(p+1) != '*') {
+      assert(*p != '*');
+      return ((*p == *s) || (*p == '.' && *s != '\0')) && isMatch(s+1, p+1);
+    }
+    while ((*p == *s) || (*p == '.' && *s != '\0')) {
+      if (isMatch(s, p+2)) return true;
+      s++;
+    }
+    return isMatch(s, p+2);
+  }
+};
+
+
+int main(){
+  Solution sol;
+  cout << sol.isMatch("helloworld", "hb*...*ld") << endl;
+  return 0;
+}

leetcode/regular-expression-matching.cpp

@@ -0,0 +1,42 @@
+#include <algorithm>
+#include <cstdio>
+#include <vector>
+#include <string>
+#include <cstring>
+#include <iostream>
+
+using namespace std;
+
+class Solution {
+public:
+    bool isScramble(string s1, string s2) {
+    	int i, n = s1.size(), m = s2.size(), val1 = 0, val2 = 0;
+    	string sl1, sr1, sl2, sr2;
+    	if( n != m ) return false;
+    	if(s1 == s2) return true;
+    	for( i = 0 ; i < n ; ++ i){
+    		val1 += s1[i] - '0';
+    		val2 += s2[i] - '0';
+    	}
+    	if(val1 != val2) return false;
+    	for(int i = 1; i < n ; ++ i){
+    		sl1 = s1.substr(0, i); sr1 = s1.substr(i);
+    		sl2 = s2.substr(0, i); sr2 = s2.substr(i);
+    		if(isScramble(sl1,sl2) && isScramble(sr1, sr2)) 
+    			return true;
+    		sl2 = s2.substr(n-i); sr2 = s2.substr(0, n-i);
+    		if(isScramble(sl1, sl2) && isScramble(sr1, sr2))
+    			return true;
+    	}
+    	return false;
+    }
+};
+
+int main(){
+	string a, b ; 
+	Solution sol;
+	cout << sol.isScramble("great", "rgeat") << endl;
+	cout << sol.isScramble("rgtae", "great") << endl;
+	cout << sol.isScramble("rgtae", "geart") << endl;
+	return 0;
+}