diff --git a/LeetCode-CN/48_旋转图像.md b/LeetCode-CN/48_旋转图像.md
new file mode 100644
index 0000000..c24c592
--- /dev/null
+++ b/LeetCode-CN/48_旋转图像.md
@@ -0,0 +1,159 @@
+## 48. 旋转图像@2018/06/24
+
+### jzf 
+* 4ms
+```c++
+class Solution {
+public:
+    void rotate(vector<vector<int>>& matrix) {
+        
+        int tmp;
+        for(size_t i=0; i<matrix.size();i++)
+        {
+            for(size_t j=i+1;j<matrix.size();j++)
+            {
+                
+                tmp =matrix[i][j];
+                matrix[i][j] =matrix[j][i];
+                matrix[j][i] =tmp;
+            }
+        }
+        for(size_t i =0;i<matrix.size();i++)
+        {
+            reverse(matrix[i].begin(),matrix[i].end());
+        }
+    }
+};
+```
+### kiritow
+* 4ms
+```c++
+class Solution {
+public:
+    void rotate(vector<vector<int>>& matrix) {
+        int n = matrix.size();
+        if (n % 2) // odd number, easy
+        {
+            int mid = n / 2;
+
+            for (int dis = 1; dis <= mid; dis++)
+            {
+                // do chain swap at distance:dis
+                int swap_n = 2 * dis + 1;
+                // save right col
+                vector<int> tvec;
+                int begin_pos = mid - dis;
+                for (int i = 0; i < swap_n; i++)
+                {
+                    tvec.push_back(matrix[begin_pos + i][mid + dis]);
+                }
+                // start rotate
+                // RIGHT <- UPPER
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-matrix[%d][%d]\n", begin_pos + i, mid + dis, mid - dis, begin_pos + i);
+                    matrix[begin_pos + i][mid + dis] = matrix[mid - dis][begin_pos + i];
+                }
+                // UPPER <- LEFT
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-matrix[%d][%d]\n", mid - dis, begin_pos + i, begin_pos + i, mid - dis);
+                    matrix[mid - dis][begin_pos + (swap_n - i - 1)] = matrix[begin_pos + i][mid - dis];
+                }
+                // LEFT <- DOWNER
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-matrix[%d][%d]\n", begin_pos + i, mid - dis, mid + dis, begin_pos + i);
+                    matrix[begin_pos + i][mid - dis] = matrix[mid + dis][begin_pos + i];
+                }
+                // DOWNER <- TEMP
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-tvec[%d]\n", mid + dis, begin_pos + i, i);
+                    matrix[mid + dis][begin_pos + (swap_n - i - 1)] = tvec[i];
+                }
+
+                // debug
+                //print(matrix);
+            }
+        }
+        else // oh, this stuff sucks.
+        {
+            int mid = n / 2 ;
+
+            for (int dis = 1; dis <= mid ; dis++)
+            {
+                // do chain swap at distance:dis
+                int swap_n = 2 * dis;
+                // save right col
+                vector<int> tvec;
+                int begin_pos = mid - dis;
+                for (int i = 0; i < swap_n; i++)
+                {
+                    tvec.push_back(matrix[begin_pos + i][mid + dis - 1]);
+                }
+                // start rotate
+                // RIGHT <- UPPER
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-matrix[%d][%d]\n", begin_pos + i, mid + dis, mid - dis, begin_pos + i);
+                    matrix[begin_pos + i][mid + dis - 1] = matrix[mid - dis][begin_pos + i];
+                }
+                // UPPER <- LEFT
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-matrix[%d][%d]\n", mid - dis, begin_pos + i, begin_pos + i, mid - dis);
+                    matrix[mid - dis][begin_pos + (swap_n - i - 1)] = matrix[begin_pos + i][mid - dis];
+                }
+                // LEFT <- DOWNER
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-matrix[%d][%d]\n", begin_pos + i, mid - dis, mid + dis, begin_pos + i);
+                    matrix[begin_pos + i][mid - dis] = matrix[mid + dis -1][begin_pos + i];
+                }
+                // DOWNER <- TEMP
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-tvec[%d]\n", mid + dis, begin_pos + i, i);
+                    matrix[mid + dis -1][begin_pos + (swap_n - i - 1)] = tvec[i];
+                }
+
+                // debug
+                //print(matrix);
+            }
+        }
+    }
+};
+```
+### puck
+class Solution
+{
+  public:
+    void rotate(vector<vector<int>> &matrix)
+    {
+        auto n = matrix.size();
+        auto max = n - 1;
+        auto half = n / 2;
+
+        for (int i{}; i < half; ++i)
+        {
+            for (int j{}; j < half; ++j)
+            {
+                std::swap(matrix[i][j], matrix[j][max - i]);
+                std::swap(matrix[i][j], matrix[max - i][max - j]);
+                std::swap(matrix[i][j], matrix[max - j][i]);
+            }
+        }
+
+        if (n == 2 * half + 1)
+        {
+            for (int i{}; i < half; ++i)
+            {
+                std::swap(matrix[i][half], matrix[half][max - i]);
+                std::swap(matrix[i][half], matrix[max - i][half]);
+                std::swap(matrix[i][half], matrix[half][i]);
+            }
+        }
+    }
+};
+```
diff --git a/LeetCode-CN/刷题.md b/LeetCode-CN/刷题.md
new file mode 100644
index 0000000..e84299d
--- /dev/null
+++ b/LeetCode-CN/刷题.md
@@ -0,0 +1,2475 @@
+>create by jzf@2018/06/20
+
+[TOC]
+# 作业
+## 627. 交换工资 @2018/06/20
+
+### jzf :517ms
+```c++
+update salary 
+    set sex = case when sex ='m' then 'f' else 'm' end;
+```
+### kiritow:563ms
+```c++
+    update salary set sex = case sex
+    when 'f' then 'm'
+    when 'm' then 'f'
+    end
+```
+
+
+## 3. 无重复字符的最长子串 @2018/06/20
+
+### 北河  
+    
+    * 第一版 :392ms
+    ```c++
+    class Solution {
+    public:
+        int lengthOfLongestSubstring(string s) {
+            map<char, short> v;
+            int max_num = 0;
+            for (int i = 0; i < s.size(); ++i) {
+                if (v.find(s[i]) != v.end()) {
+                    if (max_num < v.size()) {
+                        max_num = v.size();
+                    }
+                    i = v.find(s[i])->second + 1;
+                    v.clear();
+                }
+                if (i >= s.size()) {
+                    break;
+                }
+                v[s[i]] = i;
+                if (max_num < v.size()) {
+                    max_num = v.size();
+                }
+            }
+            return max_num;
+        }
+    };
+
+    ```
+    * 第2版 :32ms
+    ```c++
+    class Solution {
+    public:
+        int lengthOfLongestSubstring(string s) {
+            map<char, short> v;
+            int max_num = 0;
+            for (int i = 0; i < s.size(); ++i) {
+                if (v.find(s[i]) != v.end()) {
+                    if (max_num < v.size()) {
+                        max_num = v.size();
+                    }
+                    ++i;
+                    while (i < s.size()) {
+                        if (v.find(s[i]) != v.end()) {
+                            ++i;
+                            continue;
+                        }
+                        --i;
+                        break;
+                    }
+                    if (i >= s.size()) {
+                        return max_num;
+                    }
+                    i = v.find(s[i])->second + 1;
+                    v.clear();
+                }
+                if (i >= s.size()) {
+                    break;
+                }
+                v[s[i]] = i;
+                if (max_num < v.size()) {
+                    max_num = v.size();
+                }
+            }
+            return max_num;
+        }
+    };
+    ```
+### jzf 	:252 ms  8
+```c++
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+        int num =1;
+        int max =0;
+        if(s.length()==1)
+        {
+            return 1;
+        }
+        for(size_t i =0;i<s.length();i++)
+        {
+            
+            for(size_t j=i+1;j<s.length();j++)
+            {
+                int flag =0;
+                for(size_t k =i;k<j;k++)
+                {
+                    if(s[j]==s[k])   
+                    {
+                        flag =1;
+                        break;
+                    }
+                    num++;
+                }
+                    if(num>max)
+                    {
+                        max =num;
+                    }
+                if(flag ==1)
+                {
+                    break;
+                }
+                num =1;
+            }
+             num =1;
+        }
+        return max;
+    }
+};
+```
+###  puck  :544ms  2
+```c++
+#ifndef SOLUTION_H
+#define SOLUTION_H
+
+#include <algorithm>
+#include <string>
+#include <set>
+using std::string;
+class Solution
+{
+  public:
+    int lengthOfLongestSubstring(string s)
+    {
+        int result{};
+        for (std::size_t i{}; i < s.size(); ++i)
+        {
+            string tmp_str = s.substr(i);
+            int cu_length{};
+            std::set<char> set_except;
+            
+            for (auto ch : tmp_str)
+            {
+                if (set_except.end() == set_except.find(ch))
+                {
+                    set_except.insert(ch);
+                    ++cu_length;
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            result = std::max(result, cu_length);
+        }
+
+        return result;
+    }
+};
+
+#endif
+```
+### kiritow  ：24ms  2
+```c++
+#include <cstdlib>
+#include <cstring>
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+        int sz = s.size();
+        int bin[256];
+        int maxlen = 0;
+        int clen = 0;
+        int L = 0;
+        while (L < sz)
+        {
+            memset(bin, 0, sizeof(int) * 256);
+            int i;
+            for (i = L; i < sz; i++)
+            {
+                if (bin[s[i]])
+                {
+                    maxlen = clen > maxlen ? clen : maxlen;
+                    clen = 0;
+                    L++;
+                    break;
+                }
+                else
+                {
+                    bin[s[i]] = 1;
+                    clen++;
+                }
+            }
+            if (i == sz)
+            {
+                maxlen = clen > maxlen ? clen : maxlen;
+                break;
+            }
+        }
+        return maxlen;
+    }
+};
+```
+### 知识点
+   
+    桶排序
+    sync_with_stdio
+### 总结
+
+1, 对比代码发现，利用现有的数据结构，可以快速出活，而且代码简洁，逻辑清晰。
+
+2, STL不好好用，很慢。
+
+
+
+## 494. 目标和 @2018/06/21
+
+### jzf       
+
+    * 第一版 超时  复杂度 n*2^n
+    ```c++
+    class Solution {
+    public:  int findTargetSumWays(vector<int>& nums, int S) {
+        int n = 0;
+        int sum = 0;
+        int b = 0;
+        int size =nums.size();
+        for (size_t k = 0; k <size ; k++)
+        {
+            b = ((1 << k) | b);
+        }
+        for (size_t i = 0; i <= b; i++)
+        {
+            n = 0;
+            for (size_t j = 0; j < size; j++)
+            {
+                n += ((1 << j)&i) ? -nums[j] : nums[j];
+            }
+            if (n == S)
+            {
+                sum++;
+            }
+        }
+        return sum;
+        }
+    };
+    ```
+    * 第二版 
+
+### kiritow  ：24ms  2
+```c++
+class Solution {
+public:
+    int findTargetSumWays(vector<int>& nums, int S) {
+        if (S < -1000 || S>1000) return 0;
+
+        int sz = nums.size();
+        int msz = sizeof(int) * 2048;
+        int _bin[2048] = { 0 };
+        int _xbin[2048] = { 0 };
+        int* p = _bin;
+        int* q = _xbin;
+        memset(p, 0, msz);
+        p[1000] = 1;
+        
+        for (int i = 0; i < sz; i++)
+        {
+            memset(q, 0, msz);
+            for (int j = 0; j < 2048; j++)
+            {
+                if (p[j])
+                {
+                    //printf("p[%d]=%d\n", p[j]);
+                    // now=j-1000;
+                    int L = j - nums[i]; // now-nums[i]+1000
+                    int R = j + nums[i];
+                    q[L] += p[j];
+                    q[R] += p[j];
+                    //printf("q[%d]=%d\n", L, q[L]);
+                    //printf("q[%d]=%d\n", R, q[R]);
+                }
+            }
+            std::swap(p, q);
+        }
+        return p[S + 1000];
+    }
+};
+```
+
+### 知识点
+dfs
+
+bfs
+
+剪枝
+
+记忆搜索
+
+去掉重复
+
+没写dp，身败名裂--惠惠语录
+
+## 601. 体育馆的人流量@2018/06/21
+### jzf :521ms  抄
+```sql
+    select s1.* 
+    from stadium  as s1, stadium  as s2,stadium  as s3 
+    where (((s2.id =s1.id+1) and (s3.id =s1.id+2))
+           or((s2.id =s1.id-1) and (s3.id =s1.id+1))
+           or((s2.id =s1.id-2) and (s3.id =s1.id-1)))
+        and 
+         (s1.people>=100 and s2.people>=100 and s3.people >=100)
+    group by s1.id
+```
+### 知识点
+mysql必知必会 16章 自连接
+### 总结
+
+1，看了下最快的sql语句，感叹逻辑差不过的东西，差距真大呀
+## 9. 回文数@2018/06/22
+### 羽柔子 372ms
+```js
+var isPalindrome = function(x) {
+    return x.toString()===x.toString().split("").reverse().join("");
+};
+```
+* 第二版 ：128ms
+```c++
+class Solution {
+    int list[10],len=0,i=0;
+public:
+    bool isPalindrome(int x) {
+        if(x<0)return false;
+        len=i=0;
+        //分解
+        while(true){
+            if(x>=10){
+                list[len++]=x%10;
+                x/=10;
+            }
+            else{
+                list[len++]=x;
+                break;
+            }
+        }
+
+        //判断
+        --len;
+        for(i=0;i<len&&list[i]==list[len];i++,len--);
+        return i>=len;
+    }
+};
+```
+### jzf 
+* 第一版 ：232ms
+    ```c++
+    class Solution {
+    public:
+        bool isPalindrome(int x) {
+            int mod;
+            int sh =x;
+            vector<int> vec;
+            if(x <0)
+            {
+                return false;
+            }
+            if(x ==0)
+            {
+                return true;
+            }
+            
+            for(size_t i =0;sh>0;i++)
+            {
+                vec.push_back(sh%10);
+                sh = sh/10;
+            }
+            vector<int>::iterator i=vec.begin();
+            vector<int>::iterator j=vec.end()-1;
+            for(;i<j;i++,j--)
+            {
+                if(*i!=*j)
+                {
+                    return false;
+                }
+            }
+            return true;  
+        }
+    };
+    ```
+ * 第2版 ：140ms
+     ```c++
+     class Solution {
+    public: bool isPalindrome(int x) {
+            int mod;
+            int sh =x;
+            vector<int> vec;
+            if(x <0)
+            {
+                return false;
+            }
+            if(x ==0)
+            {
+                return true;
+            }
+            if(x%10 ==0)
+            {
+                return false;
+            }
+            for(size_t i =0;sh>0;i++)
+            {
+                vec.push_back(sh%10);
+                sh = sh/10;
+            }
+            vector<int>::iterator i=vec.begin();
+            vector<int>::iterator j=vec.end()-1;
+            for(;i<j;i++,j--)
+            {
+                if(*i!=*j)
+                {
+                    return false;
+                }
+            }
+            return true;  
+        }
+    };
+     ```
+### 北河  244ms
+
+* 第一版
+```c++
+class Solution {
+public:
+    bool isPalindrome(int x) {
+        char p[10], q[10];
+        short size = sprintf(p, "%d", x);
+        reverse_copy(p, p + size, q);
+        return x < 0 ? false : (mismatch(p, p + size / 2 + 1, q).first == (p + size / 2 + 1) ? true : false);               
+    }
+};
+```
+* 第二版
+```c++
+class Solution {
+public:
+    bool isPalindrome(int x) {
+        if (x < 0) {
+            return false;
+        }
+        string s = to_string(x);
+        return mismatch(s.begin(), s.end(), s.rbegin()).first == s.end();
+    }
+};
+```
+
+
+### kiritow  120ms
+```c++
+#include <cstdio>
+class Solution {
+public:
+    bool isPalindrome(int x) {
+        /*
+        // Converting to string is too slow!!
+        char buff[64] = { 0 };
+        sprintf(buff, "%d", x);
+        int len = strlen(buff);
+        int L = 0, R = len - 1;
+        while (L < R)
+        {
+            if (buff[L] != buff[R]) return false;
+            ++L;
+            --R;
+        }
+        return true;
+        */
+        if (x < 0) return false;
+        int buff[64] = { 0 };
+        int c = 0;
+        int tx = x;
+        while (tx > 0)
+        {
+            buff[c++] = tx % 10;
+            tx /= 10;
+        }
+        int L = 0, R = c - 1;
+        while (L < R)
+        {
+            if (buff[L] != buff[R]) return false;
+            ++L;
+            --R;
+        }
+        return true;
+    }
+};
+```
+### puck 
+```c++
+#include <string>
+
+class Solution
+{
+  public:
+    bool isPalindrome(int x)
+    {
+        if (x < 0)
+            return false;
+
+        std::string tmp = std::to_string(x);
+
+        std::size_t bi_size = tmp.size() / 2;
+        auto half = tmp.begin() + bi_size;
+        auto iter = tmp.begin();
+        auto riter = tmp.rbegin();
+        for (; iter != half; ++iter, ++riter)
+        {
+            if (*iter != *riter)
+                return false;
+        }
+        return true;
+    }
+};
+```
+### 总结
+1，
+我在想一个问题
+*羽柔子撤回了一条消息*
+喵在想一个问题 --羽柔子语录
+## 225. 用队列实现栈@2018/06/22
+
+### 羽柔子 0ms
+```c++
+class MyStack {
+    int stack[10],index=0;
+    
+public:
+    /** Initialize your data structure here. */
+    MyStack() {
+    }
+    
+    /** Push element x onto stack. */
+    void push(int x) {
+        stack[index++]=x;
+    }
+    
+    /** Removes the element on top of the stack and returns that element. */
+    int pop() {
+        return stack[--index];
+    }
+    
+    /** Get the top element. */
+    int top() {
+        return stack[index-1];
+    }
+    
+    /** Returns whether the stack is empty. */
+    bool empty() {
+        return !index;
+    }
+};
+```
+### kiritow
+```c++
+#include <list>
+class MyStack {
+public:
+    /** Initialize your data structure here. */
+    MyStack() {
+        
+    }
+
+    /** Push element x onto stack. */
+    void push(int x) {
+        lst.push_back(x);
+    }
+
+    /** Removes the element on top of the stack and returns that element. */
+    int pop() {
+        int t = lst.back();
+        lst.pop_back();
+        return t;
+    }
+
+    /** Get the top element. */
+    int top() {
+        return lst.back();
+    }
+
+    /** Returns whether the stack is empty. */
+    bool empty() {
+        return lst.empty();
+    }
+private:
+    std::list<int> lst;
+};
+```
+## 28. 实现strStr() @2018/06/23
+
+### jzf
+
+* 第一版 4ms
+
+```c++ 
+class Solution {
+public:
+    int strStr(string haystack, string needle) {
+        string::iterator ihay;
+        string::iterator inee;
+        int ni =haystack.size();
+        int nn =needle.size();
+        int ret = -1;
+        
+        if(nn==0)
+        {
+            return 0;
+        }
+        if(ni<nn)
+        {
+            return -1;
+        }
+        for(size_t i=0;i<ni-nn+1;i++)
+        {
+            if(!(haystack.substr(i,nn)).compare(needle))
+            {
+                ret =i;
+                break;
+            }
+        }
+        
+        return ret;
+    }
+};
+```
+
+### 羽柔子
+
+```c++
+class Solution {
+public:
+    int strStr(string haystack, string needle) {
+        if(needle.size()==0)return 0;
+        if(haystack.size()<needle.size())return -1;
+        size_t 
+            i,j,
+            ilen=haystack.size()-needle.size(),
+            jlen=needle.size(); 
+        for( i = 0; i <= ilen; i++){
+            for( j = 0; j < jlen; j++)
+                if(haystack[i+j]!=needle[j])
+                    goto A;
+            return i;
+            A:;
+        }
+        return -1;
+    }
+};
+
+```
+
+### puck
+
+```c++
+class Solution
+{
+  public:
+    int strStr(string haystack, string needle)
+    {
+        std::size_t size_a{haystack.size()};
+        std::size_t size_b{needle.size()};
+
+        if (0 == size_b)
+        {
+            return 0;
+        }
+
+        bool flag{};
+
+        for (int i{}; i < size_a; ++i)
+        {
+            if (haystack.at(i) == needle.at(0))
+            {
+                flag = true;
+
+                for (int j{1}; j < size_b; ++j)
+                {
+                    if (i + j >= size_a || haystack.at(i + j) != needle.at(j))
+                    {
+                        flag = false;
+                        break;
+                    }
+                }
+
+                if (flag)
+                {
+                    return i;
+                }
+            }
+        }
+
+        return -1;
+    }
+};
+```
+## 823. Binary Trees With Factors@2018/06/23
+
+## 196. 删除重复的电子邮箱@2018/06/23
+
+### 北河
+
+* 
+```sql
+delete from Person where id in (select c.id from (select a.id from Person a  join Person b on a.Email = b.Email and a.Id > b.Id) c);
+```
+## 48. 旋转图像@2018/06/24
+
+### jzf 
+* 4ms
+```c++
+class Solution {
+public:
+    void rotate(vector<vector<int>>& matrix) {
+        
+        int tmp;
+        for(size_t i=0; i<matrix.size();i++)
+        {
+            for(size_t j=i+1;j<matrix.size();j++)
+            {
+                
+                tmp =matrix[i][j];
+                matrix[i][j] =matrix[j][i];
+                matrix[j][i] =tmp;
+            }
+        }
+        for(size_t i =0;i<matrix.size();i++)
+        {
+            reverse(matrix[i].begin(),matrix[i].end());
+        }
+    }
+};
+```
+### kiritow
+```c++
+class Solution {
+public:
+    void rotate(vector<vector<int>>& matrix) {
+        int n = matrix.size();
+        if (n % 2) // odd number, easy
+        {
+            int mid = n / 2;
+
+            for (int dis = 1; dis <= mid; dis++)
+            {
+                // do chain swap at distance:dis
+                int swap_n = 2 * dis + 1;
+                // save right col
+                vector<int> tvec;
+                int begin_pos = mid - dis;
+                for (int i = 0; i < swap_n; i++)
+                {
+                    tvec.push_back(matrix[begin_pos + i][mid + dis]);
+                }
+                // start rotate
+                // RIGHT <- UPPER
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-matrix[%d][%d]\n", begin_pos + i, mid + dis, mid - dis, begin_pos + i);
+                    matrix[begin_pos + i][mid + dis] = matrix[mid - dis][begin_pos + i];
+                }
+                // UPPER <- LEFT
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-matrix[%d][%d]\n", mid - dis, begin_pos + i, begin_pos + i, mid - dis);
+                    matrix[mid - dis][begin_pos + (swap_n - i - 1)] = matrix[begin_pos + i][mid - dis];
+                }
+                // LEFT <- DOWNER
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-matrix[%d][%d]\n", begin_pos + i, mid - dis, mid + dis, begin_pos + i);
+                    matrix[begin_pos + i][mid - dis] = matrix[mid + dis][begin_pos + i];
+                }
+                // DOWNER <- TEMP
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-tvec[%d]\n", mid + dis, begin_pos + i, i);
+                    matrix[mid + dis][begin_pos + (swap_n - i - 1)] = tvec[i];
+                }
+
+                // debug
+                //print(matrix);
+            }
+        }
+        else // oh, this stuff sucks.
+        {
+            int mid = n / 2 ;
+
+            for (int dis = 1; dis <= mid ; dis++)
+            {
+                // do chain swap at distance:dis
+                int swap_n = 2 * dis;
+                // save right col
+                vector<int> tvec;
+                int begin_pos = mid - dis;
+                for (int i = 0; i < swap_n; i++)
+                {
+                    tvec.push_back(matrix[begin_pos + i][mid + dis - 1]);
+                }
+                // start rotate
+                // RIGHT <- UPPER
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-matrix[%d][%d]\n", begin_pos + i, mid + dis, mid - dis, begin_pos + i);
+                    matrix[begin_pos + i][mid + dis - 1] = matrix[mid - dis][begin_pos + i];
+                }
+                // UPPER <- LEFT
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-matrix[%d][%d]\n", mid - dis, begin_pos + i, begin_pos + i, mid - dis);
+                    matrix[mid - dis][begin_pos + (swap_n - i - 1)] = matrix[begin_pos + i][mid - dis];
+                }
+                // LEFT <- DOWNER
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-matrix[%d][%d]\n", begin_pos + i, mid - dis, mid + dis, begin_pos + i);
+                    matrix[begin_pos + i][mid - dis] = matrix[mid + dis -1][begin_pos + i];
+                }
+                // DOWNER <- TEMP
+                for (int i = 0; i < swap_n; i++)
+                {
+                    //printf("matrix[%d][%d]<-tvec[%d]\n", mid + dis, begin_pos + i, i);
+                    matrix[mid + dis -1][begin_pos + (swap_n - i - 1)] = tvec[i];
+                }
+
+                // debug
+                //print(matrix);
+            }
+        }
+    }
+};
+```
+### puck
+
+```c++
+#include <algorithm>
+
+class Solution
+{
+  public:
+    void rotate(vector<vector<int>> &matrix)
+    {
+        auto n = matrix.size();
+        auto max = n - 1;
+        auto half = n / 2;
+
+        for (int i{}; i < half; ++i)
+        {
+            for (int j{}; j < half; ++j)
+            {
+                std::swap(matrix[i][j], matrix[j][max - i]);
+                std::swap(matrix[i][j], matrix[max - i][max - j]);
+                std::swap(matrix[i][j], matrix[max - j][i]);
+            }
+        }
+
+        if (n == 2 * half + 1)
+        {
+            for (int i{}; i < half; ++i)
+            {
+                std::swap(matrix[i][half], matrix[half][max - i]);
+                std::swap(matrix[i][half], matrix[max - i][half]);
+                std::swap(matrix[i][half], matrix[half][i]);
+            }
+        }
+    }
+};
+```
+## 4. 两个排序数组的中位数@2018/06/24
+
+### 种子  似乎不符合复杂度限制
+```c++
+class Solution {
+public:
+    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
+        copy(nums2.begin(),nums2.end(),back_inserter(nums1));
+        sort(nums1.begin(),nums1.end());
+        return nums1.size()%2?\
+            double(nums1[nums1.size()/2]):\
+            double(nums1[nums1.size()/2]+nums1[nums1.size()/2-1])/2;
+    }
+};
+```
+### 北河 48ms
+```c++
+class Solution {
+public:
+    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
+        std::multiset<int> v;
+        copy(nums1.begin(), nums1.end(), inserter(v, v.begin()));
+        copy(nums2.begin(), nums2.end(), inserter(v, v.begin()));
+        std::multiset<int>::iterator p, q;
+        p = q = v.begin();
+        return v.size() % 2 == 0 ? ((double)*(advance(p, v.size() / 2 - 1), p) + (double)*(advance(q, v.size() / 2), q))/ 2 : (double)*(advance(p, v.size() / 2), p);
+    }
+};
+```
+### kiritow
+
+```c++
+#include <algorithm>
+class Solution {
+public:
+    void forward_until(vector<int>& nums1, vector<int>& nums2,
+        int lenA,int lenB,
+        int& idxA, int& idxB, int& passed, int midLen)
+    {
+        while (idxA < lenA&&idxB < lenB && passed < midLen)
+        {
+            if (nums1[idxA] < nums2[idxB])
+            {
+                idxA++;
+                passed++;
+            }
+            else
+            {
+                idxB++;
+                passed++;
+            }
+        }
+        while (idxA < lenA&&passed < midLen)
+        {
+            idxA++;
+            passed++;
+        }
+        while (idxB < lenB&&passed < midLen)
+        {
+            idxB++;
+            passed++;
+        }
+    }
+
+    int getCurrent(vector<int>& nums1, vector<int>& nums2, 
+        int lenA,int lenB,
+        int idxA, int idxB)
+    {
+        if (idxA < lenA&&idxB < lenB)
+        {
+            return std::min(nums1[idxA], nums2[idxB]);
+        }
+        else if (idxA < lenA)
+        {
+            return nums1[idxA];
+        }
+        else
+        {
+            return nums2[idxB];
+        }
+    }
+
+    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
+        int lenA = nums1.size();
+        int lenB = nums2.size();
+        int sumLen = lenA + lenB;
+        int midLen = sumLen / 2 - (1 - (sumLen % 2));
+        int idxA = 0;
+        int idxB = 0;
+        int passed = 0;
+        
+        forward_until(nums1, nums2, lenA, lenB, idxA, idxB, passed, midLen);
+
+        if (sumLen % 2)
+        {
+            return getCurrent(nums1, nums2, lenA, lenB, idxA, idxB);
+        }
+        else
+        {
+            int step1 = getCurrent(nums1, nums2, lenA, lenB, idxA, idxB);
+            
+            forward_until(nums1, nums2, lenA, lenB, idxA, idxB, passed, midLen + 1);
+            
+            int step2 = getCurrent(nums1, nums2, lenA, lenB, idxA, idxB);
+
+            return (step1 + step2) / 2.0;
+        }
+    }
+};
+
+```
+### jzf
+
+算了，我就算是抄上边几个的吧。
+
+### 小白
+
+* 第一版 40ms
+```c++
+
+class Solution {
+public:
+
+    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
+            vector<int> ab;
+
+	std::merge(nums1.begin(), nums1.end(), nums2.begin(), nums2.end(), std::back_inserter(ab));
+
+	return (double(ab[(ab.size() >> 1) - !(ab.size() & 1)]) + double(ab[(ab.size() >> 1)])) *0.5;
+    }
+};
+```
+* 第二版
+
+```c++
+class Solution {
+public:
+
+    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
+            vector<int> ab;
+
+	std::merge(nums1.begin(), nums1.end(), nums2.begin(), nums2.end(), std::back_inserter(ab));
+
+	return (double(ab[(ab.size() >> 1) - !(ab.size() & 1)]) + double(ab[(ab.size() >> 1)])) *0.5;
+    }
+};
+```
+* 第三版 40ms
+```c++
+
+class Solution {
+
+public:
+
+    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
+
+        vector<int> ab;
+
+        ab.reserve(nums1.size() + nums2.size());
+
+	std::merge(nums1.begin(), nums1.end(), nums2.begin(), nums2.end(), std::back_inserter(ab));
+
+	return double(ab[(ab.size() >> 1) - !(ab.size() & 1)] + ab[(ab.size() >> 1)]) * 0.5;
+
+    }
+
+};
+```
+
+### 总结
+
+1，北河和种子的体现了使用STL的巨大优势，利用现有的工具，确实好很多。
+
+而我在解题的过程中出现了自创轮子没本事放弃，和不熟悉STL等问题
+
+2，算法还是要学的，STL的复杂度也要会分析
+
+### 知识点
+1， std::merge
+2，copy
+
+## 724. 寻找数组的中心索引@2018/06/25
+
+### jzf 28ms
+```c++
+class Solution {
+public:
+    int pivotIndex(vector<int>& nums) {
+        vector<int>::iterator iter;
+        int sum =0;
+        int ret =-1;
+        for(iter =nums.begin();iter!=nums.end();iter++)
+        {
+            sum+=*iter;
+        }
+        
+        int tmp =0;
+        
+        for(size_t i=0;i<nums.size();i++)
+        {
+            if((sum -nums[i]-tmp)==tmp)
+            {
+                ret =i;
+                break;
+            }
+            tmp+=nums[i];
+        }
+        return ret;
+    }
+};
+```
+
+### 羽柔子
+
+```js
+var pivotIndex = function(nums) {
+    var r = 0,l=0,len = nums.length;
+    if(len<2)return -1;
+    for(
+        var i = 1;
+        i < len;
+        i++
+    )r += nums[i];
+    for(
+        var i=0;
+        l!=r && i<len;
+    ){
+        l+=nums[i];
+        i++;
+        r-=nums[i];
+    }
+    return i>=len?-1:i;
+};
+```
+```c++
+
+class Solution {
+public:
+    int pivotIndex(vector<int>& nums) {
+        int  r = 0,l=0,len = nums.size(),i;
+        if(len<2)return -1;
+    for( i = 1; i < len; i++ )r += nums[i];
+    for(i=0; l!=r && i<len;){
+        l+=nums[i];
+        i++;
+        r-=nums[i];
+    }
+    return i>=len?-1:i;
+    }
+};
+```
+### puck
+```c++
+#include <algorithm>
+
+class Solution
+{
+public:
+    int pivotIndex(vector<int> &nums)
+    {
+        int n{-1};
+        auto iter = std::find_if(nums.begin(), nums.end(), [&](const int a) {
+            return ++n, std::accumulate(nums.begin(), nums.begin() + n, 0) ==
+                            std::accumulate(nums.begin() + n + 1, nums.end(), 0);
+        });
+
+        if (iter == nums.end())
+        {
+            return -1;
+        }
+        return iter - nums.begin();
+    }
+};
+```
+
+### 小白
+```c++
+
+```
+## 5. 最长回文子串@2018/06/25
+### jzf
+* 第一版 超时
+```c++
+class Solution {
+public:
+    string longestPalindrome(string s) {
+        int len =s.size();
+        string retStr="";
+        for(size_t i = len; i>0;i--)
+        {
+            for(size_t j =0;j+i<=len;j++)
+            {
+                    string str =s.substr(j,i);
+                    string str2 =str;
+                    reverse(str2.begin(),str2.end());
+                    
+                    if(!str.compare(str2))
+                    {
+                        retStr =str;
+                        return retStr;
+                    }
+
+            }
+        }
+        return retStr;
+    }
+};
+```
+
+* 第二版 超时
+```c++
+class Solution {
+public:
+    string longestPalindrome(string s) {
+        int len =s.size();
+        string retStr=s.substr(0,1);
+        for(size_t i = len; i>1;i--)
+        {
+            for(size_t j =0;j+i<=len;j++)
+            {
+                    string str =s.substr(j,i);
+                    string str2 =str;
+                    reverse(str2.begin(),str2.end());
+                    
+                    if(!str.compare(str2))
+                    {
+                        retStr =str;
+                        return retStr;
+                    }
+
+            }
+        }
+        return retStr;
+    }
+};
+```
+* 8ms
+```c++
+class Solution {
+public:
+int  func(string &str, int n)
+{
+	int ret = 1;
+	size_t k = 1;
+	for ( ;k <= n && (n + k)<=str.size(); k++)
+	{
+		if (str[n - k] == str[n + k + 1])
+		{
+			ret ++;
+		}
+		else
+		{
+			break;
+		}
+	}
+	return ret;
+}
+int  func2(string &str, int n)
+{
+	int ret = 1;
+	size_t k = 1;
+	for (; k <= n && (n + k+3) <= str.size(); k++)
+	{
+		if (str[n - k] == str[n + k+2])
+		{
+			ret++;
+		}
+		else
+		{
+			break;
+		}
+	}
+	return ret;
+}
+string longestPalindrome(string s) {
+	int len = s.size();
+	int max = 0;
+	int center = 0;
+	int f = 0;
+	if (len<2)
+	{
+		return s;
+	}
+	if (len == 2)
+	{
+		if (s[0] == s[1])
+		{
+			return s;
+		}
+		else
+		{
+			return s.substr(0, 1);
+		}
+	}
+
+	std::vector<int> vec1;
+	for (size_t i = 0; i<len - 1; i++)
+	{
+		if (s[i] == s[i + 1])
+		{
+			vec1.push_back(i);
+		}
+	}
+
+	for (size_t i = 0; i<vec1.size(); i++)
+	{
+		int tmp = func(s, vec1[i]);
+		if (tmp>max)
+		{
+			max = tmp;
+			center = vec1[i];
+			f = 1;
+		}
+		if (max + i>s.size())
+		{
+			break;
+		}
+	}
+	std::vector<int> vec2;
+	for (size_t i = 0; i<len - 2; i++)
+	{
+		if (s[i] == s[i + 2])
+		{
+			vec2.push_back(i);
+		}
+	}
+	for (size_t i = 0; i<vec2.size(); i++)
+	{
+		int tmp = func2(s, vec2[i]);
+		if (tmp + 1>max)
+		{
+			max = tmp ;
+			center = vec2[i];
+			f = 2;
+		}
+		if (max + i>s.size())
+		{
+			break;
+		}
+	}
+	if (f == 0)
+	{
+		return s.substr(0,1);
+	}
+	if (f == 1)
+	{
+		return s.substr(center - max+1, max * 2);
+	}
+	if (f == 2)
+	{
+		return s.substr(center -max+1, max * 2 + 1);
+	}
+}
+};
+
+```
+### 小白
+* 第一版 超时
+```c++
+std::pair<string::const_iterator, string::const_iterator> longestPalindrome(string::const_iterator a, string::const_iterator b)
+
+{
+
+	if (a==b || std::mismatch(a, b, make_reverse_iterator(b)).first == b)
+
+		return std::make_pair(a, b);
+
+	auto str1 = longestPalindrome(a + 1, b), str2 = longestPalindrome(a, b - 1);
+
+	return (str1.second - str1.first) > (str2.second - str2.first) ? str1 : str2;
+
+}
+
+string longestPalindrome(const string &s) {
+
+	auto pr = longestPalindrome(s.begin(), s.end());
+
+	return std::string(pr.first, pr.second);
+
+}
+```
+```c++
+
+class Solution {
+public:
+    string longestPalindrome(string s) {
+    auto lr_max = std::make_pair( s.crend(), s.cbegin() );
+	auto lr_dist_comp = [](decltype(lr_max) a, decltype(lr_max) b) 
+    {return std::distance(a.first.base(), a.second) < 
+        std::distance(b.first.base(), b.second); };
+	for (auto cent = lr_max; cent != std::make_pair(s.crbegin(), s.cend());             std::distance(cent.first.base(), cent.second) == 0 ? ++cent.second : (--cent.first).base() )
+		lr_max = std::max(lr_max, std::mismatch((cent.first - 1), s.crend(), cent.second), lr_dist_comp);
+	return std::string(lr_max.first.base(), lr_max.second);
+    }
+};
+
+```
+
+## 384. 打乱数组@2018/06/26
+### jzf
+```c++
+class Solution {
+    vector<int> nums;
+public:
+    Solution(vector<int> nums) {
+        this->nums = nums;
+    }
+    
+    /** Resets the array to its original configuration and return it. */
+    vector<int> reset() {
+        return nums;
+    }
+    
+    /** Returns a random shuffling of the array. */
+    vector<int> shuffle() {
+        vector<int> result(nums);
+        for (int i = 0;i < result.size();i++) {
+            int pos = rand()%(result.size()-i);
+            swap(result[i+pos], result[i]);
+        }
+        return result;
+    }
+};
+```
+### 北河
+```c++
+class Solution {
+public:
+    Solution(vector<int> nums) :m_nums(nums.begin(), nums.end()) {
+    }
+    
+    /** Resets the array to its original configuration and return it. */
+    vector<int> reset() {
+        return m_nums;
+    }
+    
+    /** Returns a random shuffling of the array. */
+    vector<int> shuffle() {
+        vector<int> v(m_nums.begin(), m_nums.end());
+        random_shuffle(v.begin(), v.end());
+        return v;
+    }
+private:
+    vector<int> m_nums;
+};
+```
+
+### 总结
+1， 北河的STL确实知道的很多，random_shuffle 惊艳了我
+
+### 知识点
+
+随机数
+
+## 843. 猜猜这个单词@2018/06/26
+### 北河
+```c++
+
+class Solution {
+    vector<int> nums;
+public:
+    Solution(vector<int> nums) {
+        this->nums = nums;
+    }
+    
+    /** Resets the array to its original configuration and return it. */
+    vector<int> reset() {
+        return nums;
+    }
+    
+    /** Returns a random shuffling of the array. */
+    vector<int> shuffle() {
+        vector<int> result(nums);
+        for (int i = 0;i < result.size();i++) {
+            int pos = rand()%(result.size()-i);
+            swap(result[i+pos], result[i]);
+        }
+        return result;
+    }
+};
+```
+## 6. Z字形变换@2018/06/26
+### jzf
+```c++
+
+```
+## 180. 连续出现的数字@2018/06/26
+### jzf
+```sql
+select distinct s1.Num as ConsecutiveNums from Logs as s1 ,Logs as s2,Logs as s3 
+ where(( (s1.id= s2.id-1 and s1.id =s3.id-2)
+        ||(s1.id =s2.id+1 and s1.id =s3.id-1)
+        ||(s1.id =s2.id+2 and s1.id =s3.id+1))
+       and(s1.Num =s2.Num and s1.Num =s3.Num))
+```
+
+## 7. 反转整数@2018/06/27
+### jzf
+
+* 第一版
+```c++
+class Solution {
+public:
+    int reverse(int x) {
+        char str[16]={0};
+        sprintf(str,"%d",x);
+        string s =str;
+        if(s[0]=='-')
+        {
+            std::reverse(s.begin()+1,s.end());
+        }
+        else
+        {
+            std::reverse(s.begin(),s.end());
+        }
+        long ret =atol(s.c_str());
+        
+        if(ret >INT_MAX||ret<INT_MIN)
+        {
+            return 0;
+        }
+        return  ret;
+    }
+};
+```
+* 第二版  抄 ，我很喜欢这个解法
+```c++
+class Solution {
+public:
+    int reverse(int x) {
+        long long res = 0;
+        while (x != 0) {
+            res = res * 10 + x % 10;
+            x /= 10;
+        }
+        return (res < INT_MIN || res > INT_MAX) ? 0 : res;
+    }
+};
+```
+* 第三版
+```c++
+```
+### 小白
+* 第一版 出错
+```c++
+class Solution {
+public:
+int reverse(int x) {
+
+	char str[12], *p = str + sprintf(str, "%d", x);
+
+	std::reverse(str + (x < 0), p);
+
+	int r = strtol(str, NULL, 10);
+
+	return errno == ERANGE ? (errno = 0) : r;
+
+}
+};
+```
+
+* 第二版 
+```c++
+int reverse(int x) {
+        auto str = to_string(x);
+	std::reverse(str.begin(), str.end());
+	try
+	{
+		return str.back() == '-' ? -std::stoi(str): std::stoi(str);
+	}
+	catch (...)
+	{
+		return 0;
+	}
+ }
+```
+
+### 总结
+
+1，他这边用 strtol 和spritnf("%ld")出错
+    原因不知
+
+### 知识点
+
+1，这边atoi strtoi 遇见不合适的字符会跳过，和停止
+
+## 147. 对链表进行插入排序@2018/06/27
+
+### 北河 16ms
+```c++
+class Solution {
+public:
+    ListNode* insertionSortList(ListNode* head) {
+        list<int> v;
+        ListNode *p = head;
+        while (p) { v.push_back(p->val); p = p->next;}
+        v.sort();
+        p = head;
+        for (list<int>::iterator it = v.begin(); it != v.end(); ++it, p = p->next) {
+            p->val = *it;
+        }
+        return head;
+    }
+};
+```
+###  jzf
+```c++
+class Solution {
+public:
+    ListNode* insertionSortList(ListNode* head) {
+        ListNode* node =head;
+        if(head ==NULL)
+        {
+            return head;
+        }
+        vector<ListNode*> vec;
+        while(node != NULL)
+        {
+            vec.push_back(node);
+            node =node->next;
+        }
+        sort(vec.begin(),vec.end(),[](ListNode*a,ListNode*b){return a->val <b->val;});
+        for(auto iter =vec.begin();iter!= vec.end();iter++)
+        {
+            if(iter==vec.end()-1)
+            {
+                (*iter)->next =NULL;
+                break;
+            }
+            (*iter)->next =*(iter+1);
+            
+        }
+        return *vec.begin();
+    }
+};
+```
+### puck
+
+```c++
+
+class Solution
+{
+  public:
+    ListNode *insertionSortList(ListNode *head)
+    {
+        if (nullptr == head)
+        {
+            return nullptr;
+        }
+        
+        ListNode *fast{head->next};
+        ListNode *slow{head};
+        ListNode *new_head{head};
+        ListNode *tmp[2]{};
+
+        while (nullptr != fast)
+        {
+            if (slow->val > fast->val)
+            {
+                // delete the node
+                slow->next = fast->next;
+
+                if (new_head->val > fast->val)
+                {
+                    fast->next = new_head;
+                    new_head = fast;
+                }
+                else
+                {
+                    tmp[0] = new_head;
+                    tmp[1] = new_head->next;
+                    while (nullptr != tmp[1])
+                    {
+                        if (tmp[1]->val > fast->val)
+                        {
+                            fast->next = tmp[1];
+                            tmp[0]->next = fast;
+                            break;
+                        }
+                        tmp[0] = tmp[1];
+                        tmp[1] = tmp[1]->next;
+                    }
+                }
+            }
+            
+            slow = fast;
+            fast = fast->next;
+        }
+
+        return new_head;
+    }
+};
+```
+
+
+
+
+## 828. 独特字符串@2018/06/28
+### 北河
+```c++
+
+```
+### jzf
+
+* 第一版超时
+```c++
+class Solution {
+public:
+int uniqueLetterString(string S) {
+	int sum = 0;
+    vector<pair<int,string>> vec;
+    for(size_t i =0;i<S.size();i++)
+    {
+        vector<pair<int,string>> vecTmp;
+        vecTmp =vec;
+        vec.clear();
+        string str=S.substr(i,1);
+        vec.push_back(make_pair(1,str));
+        sum++;
+        if(i ==0)
+        {
+            continue;
+        }
+        for(size_t j=0;j<i;j++)
+        {
+            int a =count(vecTmp[j].second.begin(),vecTmp[j].second.end(),S[i]);
+            int b =0;
+            if(a==0)
+            {
+                
+                b =vecTmp[j].first+1;
+                vec.push_back(make_pair(b,vecTmp[j].second+str));
+            }
+            else
+            {
+              if(a==1)
+              {
+                b =vecTmp[j].first-1;
+               }
+               else
+               {
+                   b =vecTmp[j].first;
+               }
+                vec.push_back(make_pair(b,vecTmp[j].second+str));
+            }
+            sum+=b;
+        }
+  
+    }
+	return sum;
+}
+};
+```
+* 第二版超时
+```c++
+
+class Solution {
+public:
+int uniqueLetterString(string S) {
+	int sum = 0;
+    vector<pair<int,string>> vec;
+    for(size_t i =0;i<S.size();i++)
+    {
+       
+        string str=S.substr(i,1);
+        vec.push_back(make_pair(1,str));
+        sum++;
+        if(i ==0)
+        {
+            continue;
+        }
+        for(size_t j=0;j<i;j++)
+        {
+            int a =count(vec[j].second.begin(),vec[j].second.end(),S[i]);
+            if(a==0)
+            {
+                vec[j].second+=str;
+                vec[j].first+=1;
+                 sum+= vec[j].first;
+            }
+            else
+            {
+                if(a ==1)
+                {
+                    vec[j].first-=1;
+                }
+                vec[j].second+=str;
+                sum+= vec[j].first;
+            }
+        }
+  
+    }
+	return sum;
+}
+};
+```
+### puck
+```c++
+#include <algorithm>
+#include <unordered_map>
+
+class Solution
+{
+public:
+	int uniqueLetterString(string S)
+	{
+		std::size_t sz = S.size();
+		int result{};
+
+		auto ed = S.end();
+		bool flg{true};
+		for (auto iter{ S.begin() }; iter != ed; ++iter)
+		{
+			for (auto ite2{ 1 + iter }; flg; ++ite2)
+			{
+				if (ite2 == ed)
+				{
+					flg = false;
+				}
+				result += uniqueNum(string(iter, ite2));
+			}
+			flg = true;
+		}
+
+		return result;
+	}
+
+private:
+	int uniqueNum(string s)
+	{
+		//std::unordered_map<char, int> map;
+		//for (string::value_type ch : s)
+		//{
+		//	++map[ch];
+		//}
+
+		//int num{};
+		//for (auto &pair : map)
+		//{
+		//	if (1 == pair.second)
+		//	{
+		//		++num;
+		//	}
+		//}
+
+		//return num;
+		
+		short a[128]{};
+
+		for (string::value_type ch : s)
+		{
+			++a[ch];
+		}
+
+		return std::count(std::begin(a), std::end(a), 1);
+	}
+};
+```
+
+## 693. 交替位二进制数@2018/06/29
+
+### jzf
+* 第一版 错误
+```c++
+class Solution {
+public:
+    bool hasAlternatingBits(int n) {
+       // #define IS_TARGET(x)  ((x&0xaaaaaaaa)&&(x&0x55555555))
+        int x =n;
+        
+        if( ((x&0xaaaaaaaa)==x)&&((x|0xaaaaaaaa)==0xaaaaaaaa))
+        {
+            int x =~n;
+            if( ((x&0x55555555)==x)&&((x|0x55555555)==0x55555555))
+           {
+               return true;
+           }
+            else
+            {
+                return false;
+            }
+        }
+        
+        if( ((x&0x55555555)==x)&&((x|0x55555555)==0x55555555))
+        {
+            int x =~n; 
+             if( ((x&0xaaaaaaaa)==x)&&((x|0xaaaaaaaa)==0xaaaaaaaa))
+             {
+                 return true;
+             }
+            else
+            {
+                return false;
+            }
+        }
+        return false;
+    }
+};
+```
+
+* 第二版 0s
+```c++
+class Solution {
+public:
+    bool hasAlternatingBits(int n) {
+        
+        int tmp=0;
+        for(size_t i= n&1?0:1;i<31;)
+        {
+            tmp |=1<<i;
+            if(tmp>n)
+            {
+                return false;
+            }
+            else if(tmp ==n)
+            {
+                return true;
+            }
+            i +=2;
+        }
+  
+         return false;
+
+    }
+};
+```
+
+
+### 总结
+
+1， 想通过按位与等方式解决问题的时候，对于异或同或之类的转换忘记了，结果绕了很大的弯子。数学还是要学一学的。
+
+2，那个神奇的代码对提升速度真的很有效.
+
+## 63. 不同路径 II@2018/06/30
+### 北河 0ms
+```c++
+
+static auto XXX = []() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    return 0;
+}();
+
+class Solution {
+public:
+    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
+        int m = obstacleGrid.size();
+        int n = obstacleGrid[0].size();
+        int v[m][n];
+        memset(v, 0, m * n * sizeof(int));
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (obstacleGrid[i][j] != 0) {
+                    continue;
+                }
+                if (i == 0 && j != 0) {
+                    v[i][j] = v[i][j - 1];
+                } else if (j == 0 && i != 0) {
+                    v[i][j] = v[i - 1][j];
+                } else if ( i != 0 && j != 0) {
+                    v[i][j] += obstacleGrid[i - 1][j] > 0 ? 0 : v[i - 1][j];
+                    v[i][j] += obstacleGrid[i][j - 1] > 0 ? 0 : v[i][j - 1];
+                } else {
+                   v[i][j] = 1;
+                }
+            }
+        }
+        return v[m - 1][n - 1];
+    }
+};
+```
+### jzf
+```c++
+class Solution {
+public:
+    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
+       int dp[101] ={0};
+        for(int i =0;i<obstacleGrid.size();i++)
+        {
+            for(int j =0;j<obstacleGrid[i].size();j++)
+            {
+                if(i==0 &&j==0 )
+                {
+                    dp[j]=obstacleGrid[i][j]?0:1;
+                }
+                else if(j==0)
+                {
+                    dp[j]=obstacleGrid[i][j]?0:dp[j];
+                }
+                else
+                {
+                     dp[j]=obstacleGrid[i][j]?0:dp[j]+dp[j-1];
+                }
+            }
+        }
+        return dp[(*(obstacleGrid.end()-1)).size()-1];
+    }
+};
+
+```
+### 总结
+
+1，先解决的718，我使用了暴力超时了，在摸索的过程中，我画了二叉树的图，和一个数组A和B为列表项的二维表。发现二维表可以很好的表示关系
+
+2，根据二维表的规律，我学习了动态规划，但是还是多次失败了，其原因在于边界处理十分困难，如何处理二维表的边界上的计算公式很头疼。
+## 718. 最长重复子数组@2018/07/01
+
+### jzf
+* 第一版 超时
+```c++
+class Solution {
+public:
+    int findLength(vector<int>& A, vector<int>& B) {
+        int max=0;
+      
+     
+        for(size_t i =0 ;i<A.size();i++)
+        {  
+           
+            for(size_t j=0;j<B.size();j++)
+            {
+                 int tmp =0;
+                size_t k =i;
+                size_t x =j;
+                while(k<A.size()&&x<B.size())
+                {     
+                    if(A[k]!=B[x]) 
+                    {
+                          break;
+                    }
+                    tmp++;
+                    k++;
+                    x++;
+                 }
+                if(tmp>max)
+                {
+                    max =tmp;
+                }
+            }
+        }
+        return max;
+    }
+};
+```
+* 第二版 dp
+```c++
+
+```
+### 北河
+```c++
+static auto XX = []() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    return 0;
+}();
+
+class Solution {
+public:
+    int findLength(vector<int>& A, vector<int>& B) {
+        vector<int> dp(1001);
+        int m = 0;
+        for (int i = A.size() - 1; i >= 0; --i) {
+            for (size_t j = 0; j < B.size(); ++j) {
+                if (A[i] == B[j]) {
+                    dp[j] = dp[j + 1] + 1;
+                    if (dp[j] > m) {
+                        m = dp[j];
+                    }
+                } else {
+                    dp[j] = 0;
+                }
+            }
+        }
+        return m;
+    }
+};
+
+```
+## 406. 根据身高重建队列@2018/07/02 未备份
+
+
+## 455. 分发饼干@2018/07/03
+### jzf
+```c++
+class Solution {
+public:
+    int findContentChildren(vector<int>& g, vector<int>& s) {
+        sort(g.begin(),g.end());
+        sort(s.begin(),s.end());
+        
+        int j =0;
+        int i=0;
+        int t =0;
+        for(;i<std::min(g.size(),s.size());i++)
+        {
+            for(;j<s.size();)
+            {
+                if(g[i] <=s[j])
+                {
+                    t++;   
+                    j++;
+                    break;
+                }
+                j++;
+            }
+        }
+        return t;
+    }
+};
+```
+### 北河
+
+## 738.单调递增的数字@2018/07/04
+
+### 北河
+```c++
+
+```
+
+### jzf
+```c++
+
+class Solution {
+public:
+    int turn2Int(char *p)
+    {
+        int ret=0;
+        while(*p !=0)
+        {
+            ret= ret*10+(*p-'0');
+            p++;
+        }
+        return ret;
+    }
+    void tostr(int tmp,char* p)
+    {
+        int s =1;
+        int q =tmp;
+        for(;q>10;q/=10)
+        {
+            s*=10;
+        }
+        for(;s>0;s/=10)
+        {
+            *(p++)=tmp/s+'0';
+            tmp=tmp%s;
+        }
+    }
+    int monotoneIncreasingDigits(int N) {
+       // tostring(N);
+        char str[11]={0};
+        tostr(N,str);
+        
+        int t=0;
+        for(size_t i=0;i<11 &&str[i]!=0;i++)
+        {
+            if(str[i] > str[i+1])
+            {
+                t =i;
+                break;
+            }
+        }
+        if(t==0)
+        {
+            str[0]-=1;
+            for(int i= t+1;i<11 &&str[i]!=0;i++)
+            {
+                str[i] ='9';
+            }
+             return turn2Int(str+t);
+        }
+        else if(str[t+1]==0)
+        {
+            return  N;cout<<12;
+        }
+        else
+        {
+            int tmp =t;
+            while(t>0)
+            {
+                    if(str[t]>str[t-1])
+                    {
+                         str[t]-=1;
+                        for(int i= t+1;i<11 &&str[i]!=0;i++)
+                        {
+                            str[i] ='9';
+                        }
+                        return turn2Int(str);
+                    }
+                t--;
+            }
+            
+            if(t==0)
+            {
+               
+                  str[0]-=1;
+                for(int i= t+1;i<11 &&str[i]!=0;i++)
+                 {
+                    str[i] ='9';
+                }
+                return turn2Int(str+t);
+            }
+           
+        }
+        return turn2Int(str+t);
+    }
+};
+```
+## 313. 超级丑数@2018/07/05 无人做
+## 20. 有效的括号@2018/07/06
+### 羽柔子
+```javascript
+var isValid = function (s) {
+    var l = new Array();
+    return s.split("").every(e => {
+        switch (e) {
+            case '(': return l.push(1);
+            case ')': return l.pop() == 1;
+            case '{': return l.push(2);
+            case '}': return l.pop() == 2;
+            case '[': return l.push(3);
+            case ']': return l.pop() == 3;
+        };
+    }) ? !l.length : false;
+};
+```
+### jzf
+* 第一版错误
+```c++
+class Solution {
+public:
+    bool isClosed(char c, char dst)
+ {
+	 switch (c)
+	 {
+	 case '[':
+		 return dst == ']';
+	 case '{':
+		 return dst == '}';
+	 case '(':
+		 return dst == ')';
+	 default:
+		 return false;
+	 }
+ }
+ bool isOpen(char c)
+ {
+	 switch (c)
+	 {
+	 case '[':
+
+	 case '{':
+
+	 case '(':
+		 return true;
+	 default:
+		 return false;
+	 }
+ }
+ bool check(size_t &i, string &s)
+ {
+	 size_t j = i + 1;
+     bool ret=false;
+	 for (; j<s.size(); j++)
+	 {
+		 if (isClosed(s[i], s[j]) && ((j - i) & 1) == 1)
+		 {
+             ret =true;
+			 for (size_t k = (j - i-1)/2; k>0; k--)
+			 {
+                 
+				 if (!isClosed(s[i + k], s[j - k]))
+				 {
+					 return false;
+				 }
+			 }
+             break;
+		 }
+	 }
+	 i = j;
+	 return ret;
+ }
+ bool isValid(string s) {
+	 // '[''{''('')''}'']'
+	 for (size_t i = 0; i<s.size(); i++)
+	 {
+		 if (isOpen(s[i]) && (i & 1) == 0)
+		 {
+			 if (!check(i, s))
+			 {
+				 return false;
+			 }
+		 }
+		 else
+		 {
+			 return false;
+		 }
+	 }
+	 return true;
+ }
+};
+```
+* 第二版
+```c++
+class Solution {
+public:
+    bool isClosed(char c, char dst)
+ {
+	 switch (c)
+	 {
+	 case '[':
+		 return dst == ']';
+	 case '{':
+		 return dst == '}';
+	 case '(':
+		 return dst == ')';
+	 default:
+		 return false;
+	 }
+ }
+ bool isOpen(char c)
+ {
+	 switch (c)
+	 {
+	 case '[':
+
+	 case '{':
+
+	 case '(':
+		 return true;
+	 default:
+		 return false;
+	 }
+ }
+
+ bool isValid(string s) {
+	 // '[''{''('')''}'']'
+     bool ret =false; 
+     int tmp =0; 
+    while(s.size()!=tmp)
+    {
+        tmp =s.size();
+        for(int i=0;i<tmp-1;i++)
+        {
+            if(isClosed(s[i],s[i+1]))
+            {
+                s.erase(i,2);
+                break;
+            }
+        }
+    }
+     return tmp==0?true:false;
+ }
+};
+```
+### 三浪
+```c
+typedef struct tagStack
+{
+	char * p;
+	int iPos;
+}Stack;
+
+void BulidStack(Stack *pStack, int size)
+{
+	pStack->p = (char *)malloc(size * sizeof(char));
+	memset(pStack->p, 0, size);
+	pStack->iPos= 0;
+}
+
+void DestroyStack(Stack *pStack)
+{
+	free(pStack->p);
+}
+
+int Push(Stack *pStack, char ch)
+{
+	if (pStack->iPos >= 0)
+	{
+		*(pStack->p + pStack->iPos) = ch;
+		++(pStack->iPos);
+		return 0;
+	}
+	return -1;
+}
+
+int Pop(Stack *pStack)
+{
+	--(pStack->iPos);
+	if (pStack->iPos >= 0)
+	{
+		*(pStack->p + pStack->iPos) = '\0';
+		return 0;
+	}
+	return -1;
+}
+char GetPairChar(char ch)
+{
+	switch (ch)
+	{
+		case ')':
+			return '(';
+		case '}':
+			return '{';
+
+		case ']':
+			return '[';
+		default:
+			return '\0';
+	}
+}
+
+bool IsPush(char ch)
+{
+	if (ch == '(' || ch == '{' || ch == '[')
+	{
+		return true;
+	}
+	return false;
+}
+
+bool isValid(char *s)
+{
+	if ('\0' == *s)
+	{
+		return true;
+	}
+	int n = 0;
+	char chPre = *s;
+	if (!IsPush(chPre))
+	{
+		return false;
+	}
+
+	Stack myStack;
+	BulidStack(&myStack, strlen(s) + 1);
+	while (*s != '\0')
+	{
+		char chCur = *s;
+		if (IsPush(chCur))
+		{
+			if (0 != Push(&myStack, chCur))
+			{
+				return false;
+			}
+		}
+		else
+		{
+			if ((myStack.iPos >= 1) && 
+			(myStack.p[myStack.iPos - 1] == GetPairChar(chCur)))
+			{
+				if (0 != Pop(&myStack))	
+				{
+					return false;
+				}
+			}
+			else
+			{
+
+				if (0 != Push(&myStack, chCur))
+				{
+					return false;
+				}
+			}
+		}
+		chPre = *s;
+		++s;
+	}
+	if (0 == myStack.iPos)
+	{
+		DestroyStack(&myStack);
+		return true;
+	}
+	else
+	{
+		DestroyStack(&myStack);
+		return false;
+	}
+
+}
+```
+### 总结
+1，我在做这道题的时候，出现了许多次的分析失误，疏忽了一些情形。
+2，发现 s.size()的返回类型是size_t ，遇到了一个比较悲惨的越界错误。
+size_t是unsigned int类型的
+当 for(int i=0; i<tmp -1;i++)中的tmp = 0时，就出现了大bug;