Merge pull request gzc426#381 from EngineerZhang/master

gzc426 · web-flow · commit ad34c27d191e · 2018-12-08T11:41:12.000+08:00
1
diff --git a/2018.11.30-leetcode890/神秘的火柴人.md b/2018.11.30-leetcode890/神秘的火柴人.md
@@ -0,0 +1,40 @@
+class Solution {
+public:
+	vector<string> findAndReplacePattern(vector<string>& words, string pattern) {
+		vector<string> ret;
+
+		int size = words.size();
+		int n = pattern.length();
+
+		for(int i=0; i<size; i++)
+		{
+			map<char, char> m;
+            map<char, char> m1;
+			int j = 0;
+			for(j=0; j<n; j++)
+			{
+                if(m.find(pattern[j])==m.end())
+				{
+					m[pattern[j]] = words[i][j];
+				}
+                
+                if(m1.find(words[i][j])==m1.end())
+				{
+					m1[words[i][j]] = pattern[j];
+				}
+                
+				if(m.find(pattern[j])!=m.end() && m[pattern[j]] != words[i][j])
+					break;
+                
+                if(m1.find(words[i][j])!=m.end() && m1[words[i][j]]!=pattern[j])
+                    break;
+				
+			}
+
+			if(j == n)
+				ret.push_back(words[i]);
+		}
+
+		return ret;
+	}
+};
diff --git a/2018.12.04-leetcode101/神秘的火柴人.md b/2018.12.04-leetcode101/神秘的火柴人.md
@@ -0,0 +1,49 @@
+```
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+	bool isSymmetric(TreeNode* root) {
+        if(!root)   return true;
+        
+		queue<TreeNode*> q1;
+        queue<TreeNode*> q2;
+        q1.push(root->left);
+        q2.push(root->right);
+        
+        
+        while(!q1.empty() && !q2.empty())
+        {
+            TreeNode *l = q1.front();
+            TreeNode *r = q2.front();
+            
+            q1.pop();
+            q2.pop();
+            
+            if( (!l&&r) || (l&&!r) )    return false;
+            
+            if(l && r)
+            {
+                 if(l->val != r->val)
+                     return false;
+                
+                q1.push(l->left);
+                q1.push(l->right);
+
+                q2.push(r->right);
+                q2.push(r->left);
+            }
+            
+        }
+        
+        return true;
+	}
+};
+```
diff --git a/2018.12.05-leetcode102/神秘的火柴人.md b/2018.12.05-leetcode102/神秘的火柴人.md
@@ -0,0 +1,45 @@
+```
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    vector<vector<int>> levelOrder(TreeNode* root) {
+        vector<vector<int>> ret;
+        if(!root)   return ret;
+        
+        queue<TreeNode*> q;
+        q.push(root);
+        
+        while(!q.empty())
+        {
+            int n = q.size();
+            vector<int> tmp;
+            
+            while(n>0)
+            {
+                TreeNode *node = q.front();
+                q.pop();
+                n--;
+                
+                tmp.push_back(node->val);
+                if(node->left)
+                    q.push(node->left);
+                if(node->right)
+                    q.push(node->right);
+                
+            }
+            
+            ret.push_back(tmp);
+        }
+        
+        return ret;
+    }
+};
+```
diff --git a/2018.12.06-leetcode103/神秘的火柴人.md b/2018.12.06-leetcode103/神秘的火柴人.md
@@ -0,0 +1,47 @@
+```
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
+        vector<vector<int>> ret;
+        if(!root)   return ret;
+        
+        queue<TreeNode *> q;
+        q.push(root);
+        bool flag = true;
+        
+        while(!q.empty())
+        {
+            int n = q.size();
+            vector<int> tmp;
+            
+            while(n>0)
+            {
+                TreeNode *node = q.front();
+                q.pop();
+                n--;
+                
+                tmp.push_back(node->val);
+                if(node->left)  q.push(node->left);
+                if(node->right) q.push(node->right);
+               
+            }
+            
+            if(!flag)
+                reverse(tmp.begin(), tmp.end());
+            flag = !flag;
+            ret.push_back(tmp);
+        }
+        
+        return ret;
+    }
+};
+```
diff --git a/2018.12.1-leetcode387/神秘的火柴人.md b/2018.12.1-leetcode387/神秘的火柴人.md
@@ -0,0 +1,29 @@
+...
+class Solution {
+public:
+    int firstUniqChar(string s) {
+        if(s.length() == 1)
+            return 0;
+        if(s.length() == 0)
+            return -1;
+        
+        map<char, int> m;
+        int i = 0;
+        for(i=0; i<s.length(); i++)
+        {
+            m[s[i]]++;
+        }
+        
+        for(i=0; i<s.length(); i++)
+        {
+            if(m[s[i]] == 1)
+                break;
+        }
+        
+        if(i == s.length())
+            return -1;
+        else
+            return i;
+    }
+};
+...
diff --git a/2018.12.2-leetcode557/神秘的火柴人.md b/2018.12.2-leetcode557/神秘的火柴人.md
@@ -0,0 +1,44 @@
+...
+class Solution {
+public:
+    string reverseWords(string s) {
+        string ret;
+        
+        int cur = 0;
+        while(cur < s.length())
+        {
+            int begin = cur;
+            int end = s.find(" ", begin);
+            if(end == s.npos)
+                end = s.length();
+            
+            string tmp = s.substr(begin, end-begin);
+            reversOne(tmp);
+            if(end != s.length())
+                ret = ret + tmp + " " ;
+            else
+                ret = ret + tmp; 
+            
+            cur = end+1;
+        }
+        
+        return ret;
+    }
+    
+    
+    void reversOne(string &s)
+    {
+        int n = s.length();
+        
+        int i = 0;
+        int j = n-1;
+        while(i < j)
+        {
+            swap(s[i], s[j]);
+            i++;
+            j--;
+        }
+        
+    }
+};
+...
diff --git a/2018.12.3-leetcode58/神秘的火柴人.md b/2018.12.3-leetcode58/神秘的火柴人.md
@@ -0,0 +1,23 @@
+```
+
+
+class Solution {
+public:
+    int lengthOfLastWord(string s) {
+        int end = s.length()-1;
+        while(s[end] == ' ')
+            end--;
+        
+        int ret = 0;
+        while(end>=0 && s[end]!=' ')
+        {
+            end--;
+            ret++;
+        }
+        
+        return ret;
+    }
+};
+
+
+```
