diff --git a/15.3Sum1.cpp b/15.3Sum1.cpp
new file mode 100644
index 0000000..7b62028
--- /dev/null
+++ b/15.3Sum1.cpp
@@ -0,0 +1,63 @@
+#include <iostream>
+#include <vector>
+#include <fstream>
+#include <map>
+#include <algorithm>
+
+using namespace std;
+
+vector<vector<int> > threeSum(vector<int>& nums)
+    {
+        vector<vector<int> > result;
+        if (nums.size()<3) return result;
+        int target=0;
+        sort(nums.begin(),nums.end());
+        for (int head=0;head<nums.size();head++)
+        {
+            while(head!=0&&nums[head]==nums[head-1]) head++;
+            target=0;
+            vector<int> one;
+            one.push_back(nums[head]);
+            target=target-nums[head];
+            map <int,int> nummap;
+            int flag=nums[nums.size()-1]+1;
+            for (int i=head+1;i<nums.size();i++)
+            {
+                if (nummap.count(target-nums[i])&&nums[i]!=flag)
+                {
+                    flag=nums[i];
+                    one.push_back(nums[nummap[target-nums[i]]]);
+                    one.push_back(nums[i]);
+                    result.push_back(one);
+                    one.pop_back();
+                    one.pop_back();
+                }
+                if (!nummap.count(nums[i]))
+                {
+                    nummap.insert(pair<int,int>(nums[i],i));
+                }
+            }
+        }
+        return result;
+    }
+
+int main()
+{
+    ifstream fin("in.txt");
+    vector <int> nums;
+    int num_tmp;
+    while(!fin.eof())
+    {
+        fin>>num_tmp;
+        nums.push_back(num_tmp);
+    }
+//    for(int i=0;i<nums.size();i++) cout<<nums[i]<<' ';
+    cout<<endl;
+    vector<vector<int> > result=threeSum(nums);
+    for(int i=0;i<result.size();i++)
+    {
+        for(int j=0;j<result[i].size();j++) cout<<result[i][j]<<' ';
+        cout<<endl;
+    }
+    return 0;
+}
diff --git a/3summ.cpp b/3summ.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/Add Binary.cpp b/Add Binary.cpp
new file mode 100644
index 0000000..70890f3
--- /dev/null
+++ b/Add Binary.cpp	
@@ -0,0 +1,55 @@
+#include<iostream>
+#include<cstring>
+using namespace std;
+
+string addBinary(string a, string b) {
+        int lena=a.size();
+        int lenb=b.size();
+
+        int re[max(lena,lenb)+1];
+        re[0]=0;
+
+        int i=0;
+        for (i=0;i<min(lena,lenb);i++)
+        {
+            re[max(lena,lenb)-i]=a[lena-1-i]-'0'+b[lenb-1-i]-'0';
+        }
+        i--;
+        while (i<lenb-1){
+            i++;
+            re[max(lena,lenb)-i]=b[lenb-1-i]-'0';
+        }
+        while (i<lena-1){
+            i++;
+            re[max(lena,lenb)-i]=a[lena-1-i]-'0';
+        }
+
+        for (int j=max(lena,lenb);j>0;j--)
+        {
+            if (re[j]>1)
+            {
+                re[j-1]+=re[j]/2;
+                re[j]=re[j]%2;
+            }
+        }
+
+        string res;
+        for (int k=max(lena,lenb);k>=0;k--)
+        {
+            res.push_back('0'+re[max(lena,lenb)-k]);
+        }
+        if (re[0]==0)
+        {
+            res=res.substr(1);
+        }
+        return res;
+    }
+
+
+int main()
+{
+    string a="0",b="1";
+    string c=addBinary(a,b);
+    cout<<c;
+    return 0;
+}
diff --git a/Add Digits.cpp b/Add Digits.cpp
new file mode 100644
index 0000000..8829800
--- /dev/null
+++ b/Add Digits.cpp	
@@ -0,0 +1,25 @@
+#include<iostream>
+using namespace std;
+
+int addDigits(int num) {
+        while (num/10!=0)
+        {
+            int sum=0;
+            int tmp=num;
+            while (tmp!=0)
+            {
+                sum+=tmp%10;
+                tmp/=10;
+            }
+            num=sum;
+        }
+        return num;
+    }
+
+    int main()
+    {
+        int a=347;
+        int c=addDigits(a);
+        cout<<c;
+        return 0;
+    }
diff --git a/Balanced Binary Tree.cpp b/Balanced Binary Tree.cpp
new file mode 100644
index 0000000..2eb5964
--- /dev/null
+++ b/Balanced Binary Tree.cpp	
@@ -0,0 +1,51 @@
+#include<iostream>
+#include<cmath>
+using namespace std;
+
+struct TreeNode
+{
+    int val;
+    TreeNode* left;
+    TreeNode* right;
+    TreeNode(int x):val(x),left(NULL),right(NULL){}
+};
+int depth(TreeNode* root,bool& isB){
+        if (root->left==NULL&&root->right==NULL)
+        {
+            return 1;
+        }
+        int llen,rlen;
+        if (root->left!=NULL)
+            llen=depth(root->left,isB);
+        else
+            llen=0;
+        if (root->right!=NULL)
+            rlen=depth(root->right,isB);
+        else
+            rlen=0;
+        if (abs(llen-rlen)>1)
+        {
+            isB=false;
+            return 0;
+        }
+        return llen>rlen?(llen+1):(rlen+1);
+    }
+    bool isBalanced(TreeNode* root) {
+        if (root==NULL)
+            return true;
+        bool isB=true;
+        depth(root,isB);
+        return isB;
+    }
+
+int main()
+{
+    TreeNode* root=new TreeNode(1);
+    root->left=new TreeNode(2);
+    root->right=new TreeNode(3);
+    root->left->left=new TreeNode(5);
+    bool isB;
+    isB=isBalanced(root);
+    cout<<isB;
+    return 0;
+}
diff --git a/Best Time to Buy and Sell Stock II.cpp b/Best Time to Buy and Sell Stock II.cpp
new file mode 100644
index 0000000..eea646c
--- /dev/null
+++ b/Best Time to Buy and Sell Stock II.cpp	
@@ -0,0 +1,35 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+int maxProfit(vector<int>& prices)
+{
+    int len = prices.size();
+    if (len == 0)
+        return 0;
+    int low = prices[0];
+    int high;
+    int sum=0;
+    for (int i = 1; i < len; i++)
+        if (prices[i]>prices[i-1])
+            if (i == len-1)
+                sum += prices[i] - low;
+            else
+                continue;
+        else
+        {
+            high = prices[i-1];
+            sum = high - low + sum;
+            low = prices[i];
+        }
+    return sum;
+}
+
+int main()
+{
+    vector<int> nums;
+    nums.push_back(1);
+    nums.push_back(2);
+    cout<<maxProfit(nums);
+    return 0;
+}
diff --git a/Best Time to Buy and Sell Stock with Cooldown.cpp b/Best Time to Buy and Sell Stock with Cooldown.cpp
new file mode 100644
index 0000000..2abc3af
--- /dev/null
+++ b/Best Time to Buy and Sell Stock with Cooldown.cpp	
@@ -0,0 +1,19 @@
+#include "pack.h"
+
+int maxProfit(vector<int>& prices)
+{
+    int len = prices.size();
+    if (len < 2)
+        return 0;
+    int buys[len];
+    int sells[len];
+    sells[0]=0;sells[1]=max(0, prices[1] - prices[0]);
+    buys[0]= -prices[0];buys[1]=max(-prices[0], -prices[1]);
+
+    for (int i = 2 ; i < len ; i++)
+    {
+        sells[i] = max(sells[i-1], buys[i-1] + prices[i]);
+        buys[i] = max(buys[i-1], sells[i-2] - prices[i]);
+    }
+    return sells[len-1];
+}
diff --git a/Best Time to Buy and Sell Stock.cpp b/Best Time to Buy and Sell Stock.cpp
new file mode 100644
index 0000000..c4bc0dd
--- /dev/null
+++ b/Best Time to Buy and Sell Stock.cpp	
@@ -0,0 +1,39 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+int maxProfit(vector<int>& prices)
+{
+    int len = prices.size();
+    if (len == 0)
+        return 0;
+    int out[len];
+    out[0] = 0;
+    int minele = prices[0];
+
+    for (int i = 1; i < len ; i++)
+    {
+        if (prices[i]-minele > out[i-1])
+        {
+            out[i] = prices[i]-minele;
+            minele = min(prices[i],minele);
+        }
+        else
+        {
+            out[i] = out[i-1];
+            minele = min(prices[i],minele);
+        }
+    }
+    return out[len-1];
+}
+
+int main()
+{
+    vector<int> nums;
+    nums.push_back(2);
+    nums.push_back(1);
+    nums.push_back(4);
+    int re = maxProfit(nums);
+    cout<<re;
+    return 0;
+}
diff --git a/Binary Search Tree Iterator.cpp b/Binary Search Tree Iterator.cpp
new file mode 100644
index 0000000..fd4005e
--- /dev/null
+++ b/Binary Search Tree Iterator.cpp	
@@ -0,0 +1,34 @@
+#include "tree.h"
+
+class BSTIterator
+{
+public:
+    stack<TreeNode*> stk;
+    BSTIterator(TreeNode* root)
+    {
+        while (root)
+        {
+            stk.push(root);
+            root = root->left;
+        }
+    }
+
+    bool hasNext()
+    {
+        return !stk.empty();
+    }
+
+    int next()
+    {
+        TreeNode* tmp = stk.top();
+        int res = tmp->val;
+        stk.pop();
+        tmp = tmp->right;
+        while(tmp)
+        {
+            stk.push(tmp);
+            tmp = tmp->left;
+        }
+        return res;
+    }
+};
diff --git a/Binary Tree Inorder Traversal.cpp b/Binary Tree Inorder Traversal.cpp
new file mode 100644
index 0000000..5e72679
--- /dev/null
+++ b/Binary Tree Inorder Traversal.cpp	
@@ -0,0 +1,42 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+
+struct TreeNode{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x):val(x),left(NULL),right(NULL){}
+};
+
+void cur(vector<int>& re,TreeNode* t)
+    {
+        if (t->left!=NULL)
+            cur(re,t->left);
+        re.push_back(t->val);
+        if (t->right!=NULL)
+        {
+            cur(re,t->right);
+        }
+    }
+    vector<int> inorderTraversal(TreeNode* root) {
+        vector<int> re;
+        if (root==NULL)
+            return re;
+        cur(re,root);
+        return re;
+    }
+
+int main()
+{
+    TreeNode* root=new TreeNode(1);
+    root->right=new TreeNode(2);
+    root->right->left=new TreeNode(3);
+    vector<int> re;
+    re=inorderTraversal(root);
+    for (int i=0;i<re.size();i++)
+    {
+        cout<<re[i]<<" ";
+    }
+    return 0;
+}
diff --git a/Binary Tree Level Order Traversal II.cpp b/Binary Tree Level Order Traversal II.cpp
new file mode 100644
index 0000000..5df550c
--- /dev/null
+++ b/Binary Tree Level Order Traversal II.cpp	
@@ -0,0 +1,48 @@
+#include<iostream>
+#include<vector>
+#include<queue>
+using namespace std;
+
+struct TreeNode{
+    int val;
+    TreeNode* left;
+    TreeNode* right;
+    TreeNode(int x):val(x),left(NULL),right(NULL){}
+};
+
+vector<vector<int> > levelOrderBottom(TreeNode* root)
+{
+    vector<vector<int> > re;
+    vector<int> rec;
+    queue<TreeNode*> q1;
+    TreeNode* t=root;
+    if (!t)
+        return re;
+    q1.push(t);
+    while (!q1.empty())
+    {
+        queue<TreeNode*> q2;
+        while (!q1.empty())
+        {
+            t=q1.front();
+            rec.push_back(t->val);
+            q1.pop();
+            if (t->left)
+                q2.push(t->left);
+            if (t->right)
+                q2.push(t->right);
+        }
+        re.insert(re.begin(),rec);
+        rec.clear();
+        q1=q2;
+    }
+    return re;
+}
+
+int main()
+{
+    TreeNode* root=new TreeNode(1);
+    vector<vector<int> > re;
+    re=levelOrderBottom(root);
+    return 0;
+}
diff --git a/Binary Tree Level Order Traversal.cpp b/Binary Tree Level Order Traversal.cpp
new file mode 100644
index 0000000..494ab87
--- /dev/null
+++ b/Binary Tree Level Order Traversal.cpp	
@@ -0,0 +1,49 @@
+#include<iostream>
+#include<vector>
+#include<queue>
+#include<sstream>
+using namespace std;
+
+struct TreeNode{
+    int val;
+    TreeNode* left;
+    TreeNode* right;
+    TreeNode(int x):val(x),left(NULL),right(NULL){}
+};
+
+vector<vector<int> > levelOrder(TreeNode* root)
+{
+    vector<vector<int> > re;
+    vector<int> rec;
+    queue<TreeNode*> q1;
+    TreeNode* t=root;
+    if (!t)
+        return re;
+    q1.push(t);
+    while (!q1.empty())
+    {
+        queue<TreeNode*> q2;
+        while (!q1.empty())
+        {
+            t=q1.front();
+            rec.push_back(t->val);
+            q1.pop();
+            if (t->left)
+                q2.push(t->left);
+            if (t->right)
+                q2.push(t->right);
+        }
+        re.push_back(rec);
+        rec.clear();
+        q1=q2;
+    }
+    return re;
+}
+
+int main()
+{
+    TreeNode* root=new TreeNode(1);
+    vector<vector<int> > re;
+    re=levelOrder(root);
+    return 0;
+}
diff --git a/Binary Tree Maximum Path Sum.cpp b/Binary Tree Maximum Path Sum.cpp
new file mode 100644
index 0000000..3b9dd61
--- /dev/null
+++ b/Binary Tree Maximum Path Sum.cpp	
@@ -0,0 +1,33 @@
+#include"tree.h"
+
+int ans;
+
+int scanT(TreeNode* t)
+{
+    if (t==NULL)
+        return 0;
+    int left = scanT(t->left);
+    int right = scanT(t->right);
+    int val = root->val;
+    if (left>0)
+        val+=left;
+    if (right>0)
+        val+=right;
+    if (val>ans)
+        ans=val;
+    return max(root->val,max(left+root->val,right+root->val));
+}
+
+int maxPathSum(TreeNode *root)
+{
+    if (root==NULL)
+        return 0;
+    ans = root->val;
+    scanT(root);
+    return ans;
+}
+
+int main()
+{
+
+}
diff --git a/Binary Tree Paths.cpp b/Binary Tree Paths.cpp
new file mode 100644
index 0000000..b171f88
--- /dev/null
+++ b/Binary Tree Paths.cpp	
@@ -0,0 +1,61 @@
+#include<vector>
+#include<iostream>
+#include<sstream>
+using namespace std;
+
+struct TreeNode
+{
+    int val;
+    TreeNode* left;
+    TreeNode* right;
+    TreeNode(int x):val(x),left(NULL),right(NULL){}
+};
+
+void cur(vector<string>& re,string& cur_re,TreeNode* t)
+{
+    stringstream ss;
+    ss<<t->val;
+    string s;
+    ss>>s;
+    int len=s.size();
+    if (t->left==NULL&&t->right==NULL)
+    {
+        cur_re=cur_re+s;
+        re.push_back(cur_re);
+        cur_re.erase(cur_re.end()-len,cur_re.end());
+        return;
+    }
+    cur_re=cur_re+s+"->";
+    if (t->left!=NULL)
+    {
+        cur(re,cur_re,t->left);
+    }
+    if (t->right!=NULL)
+    {
+        cur(re,cur_re,t->right);
+    }
+    cur_re.erase(cur_re.end()-len-2,cur_re.end());
+}
+
+vector<string> binaryTreePaths(TreeNode* root)
+{
+    vector<string> re;
+    string cur_re;
+    if (root==NULL)
+        return re;
+    cur(re,cur_re,root);
+    return re;
+}
+int main()
+{
+    TreeNode* root=new TreeNode(1);
+    root->left=new TreeNode(2);
+//    root->right=new TreeNode(3);
+    root->left->left=new TreeNode(5);
+    vector<string> re=binaryTreePaths(root);
+    for (int i=0;i<re.size();i++)
+    {
+        cout<<re[i]<<endl;
+    }
+    return 0;
+}
diff --git a/Binary Tree Right Side View.cpp b/Binary Tree Right Side View.cpp
new file mode 100644
index 0000000..5b8815e
--- /dev/null
+++ b/Binary Tree Right Side View.cpp	
@@ -0,0 +1,47 @@
+#include"tree.h"
+#include<math.h>
+#include<algorithm>
+
+vector<int> rightSideView(TreeNode* root)
+{
+    vector<int> re;
+    queue<TreeNode*> q;
+    if (root==NULL)
+        return re;
+    q.push(root);
+    while (!q.empty())
+    {
+        int len = q.size();
+        TreeNode* t;
+        for (int i=0;i<len;i++)
+        {
+            t = q.front();
+            q.pop();
+            if (t->left!=NULL)
+                q.push(t->left);
+            if (t->right!=NULL)
+                q.push(t->right);
+        }
+        re.push_back(t->val);
+    }
+    return re;
+}
+
+int main()
+{
+    ifstream f("in.txt");
+    string s;
+    vector<string> ss;
+    while (!f.eof())
+    {
+        f>>s;
+        ss.push_back(s);
+    }
+    TreeNode* t = buildtree(ss);
+    vector<int> re = rightSideView(t);
+    for (int i=0;i<re.size();i++)
+    {
+        cout<<re[i]<<endl;
+    }
+    return 0;
+}
diff --git a/Binary Tree Zigzag Level Order Traversal.cpp b/Binary Tree Zigzag Level Order Traversal.cpp
new file mode 100644
index 0000000..1144d8d
--- /dev/null
+++ b/Binary Tree Zigzag Level Order Traversal.cpp	
@@ -0,0 +1,64 @@
+#include "tree.h"
+
+vector<vector<int> > zigzagLevelOrder(TreeNode* root)
+{
+    vector<vector<int> > re;
+    vector<int> cur;
+    vector<TreeNode*> q1;
+    int k = 1;
+    if (root==NULL)
+        return re;
+    q1.push_back(root);
+    while (!q1.empty())
+    {
+        int len = q1.size();
+        vector<TreeNode*> q2;
+        if(k%2==0)
+        {
+            for (int i=len-1;i>=0;i--)
+            {
+                cur.push_back(q1[i]->val);
+                if (q1[len-1-i]->left)
+                    q2.push_back(q1[len-1-i]->left);
+                if (q1[len-1-i]->right)
+                    q2.push_back(q1[len-1-i]->right);
+            }
+        }
+        else
+        {
+            for (int i=0;i<len;i++)
+            {
+                cur.push_back(q1[i]->val);
+                if (q1[i]->left)
+                    q2.push_back(q1[i]->left);
+                if (q1[i]->right)
+                    q2.push_back(q1[i]->right);
+            }
+        }
+        q1 = q2;
+        re.push_back(cur);
+        k++;cout<<k<<endl;
+        cur.clear();
+    }
+    return re;
+}
+
+int main()
+{
+    ifstream f("in.txt");
+    string s;
+    vector<string> ss;
+    while (!f.eof())
+    {
+        f>>s;
+        ss.push_back(s);
+    }
+    TreeNode* t = buildtree(ss);
+    vector<vector<int> > re;
+    re = zigzagLevelOrder(t);
+    for (int i=0;i<re.size();i++)
+    {for (int j=0;j<re[i].size();j++)
+            cout<<re[i][j];
+            cout<<endl;}
+            return 0;
+}
diff --git a/Combination Sum.cpp b/Combination Sum.cpp
new file mode 100644
index 0000000..ffc3569
--- /dev/null
+++ b/Combination Sum.cpp	
@@ -0,0 +1,67 @@
+#include<iostream>
+#include<vector>
+#include<algorithm>
+#include<fstream>
+using namespace std;
+
+void sumc(vector<vector<int> >& re,vector<int> candidates,vector<int>& cur_re,int target,int sum,int index)
+    {
+        if (sum>target)
+            return;
+        if (sum==target){
+            re.push_back(cur_re);
+            return;
+        }
+        for (int i=index;i<candidates.size();i++)
+        {
+            cur_re.push_back(candidates[i]);
+            sumc(re,candidates,cur_re,target,sum+candidates[i],i);
+            cur_re.pop_back();
+        }
+    }
+    vector<vector<int> > combinationSum(vector<int>& candidates, int target) {
+        vector<vector<int> > re;
+        vector<int> cur_re;
+        sort(candidates.begin(),candidates.end());
+        sumc(re,candidates,cur_re,target,0,0);
+        return re;
+    }
+void comb(vector<int> candidates, int index, int sum, int target, vector<vector<int> > &res, vector<int> &path)
+    {
+        if(sum>target)return;
+        if(sum==target){res.push_back(path);return;}
+        for(int i= index; i<candidates.size();i++)
+        {
+            path.push_back(candidates[i]);
+            comb(candidates,i,sum+candidates[i],target,res,path);
+            path.pop_back();
+        }
+    }
+//    vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
+        // Note: The Solution object is instantiated only once.
+//        sort(candidates.begin(),candidates.end());
+//        vector<vector<int> > res;
+//        vector<int> path;
+//        comb(candidates,0,0,target,res,path);
+//        return res;
+//    }
+int main()
+{
+    vector<vector<int> > re;
+    vector<int> candidates;
+    ifstream fin("incombination sum.txt");
+    while(!fin.eof())
+    {
+        int a;
+        fin>>a;
+        candidates.push_back(a);
+    }
+    re=combinationSum(candidates,310);
+    for (int i=0;i<re.size();i++)
+    {
+        for (int j=0;j<re[i].size();j++)
+            cout<<re[i][j]<<" ";
+        cout<<endl;
+    }
+    return 0;
+}
diff --git a/Combination Sum2.cpp b/Combination Sum2.cpp
new file mode 100644
index 0000000..44d9ac8
--- /dev/null
+++ b/Combination Sum2.cpp	
@@ -0,0 +1,55 @@
+#include<iostream>
+#include<fstream>
+#include<algorithm>
+#include<vector>
+using namespace std;
+
+void sumc(vector<vector<int> >& re,vector<int> candidates,vector<int>& cur_re,int target,int sum,int index)
+    {
+        if (sum>target)
+            return;
+        if (sum==target){
+            re.push_back(cur_re);
+            return;
+        }
+        if (index>=candidates.size())
+            return;
+        for (int i=index;i<candidates.size();)
+        {
+            cur_re.push_back(candidates[i]);
+            sumc(re,candidates,cur_re,target,sum+candidates[i],i+1);
+            cur_re.pop_back();
+            if (i<candidates.size()-1)
+                while (candidates[i+1]==candidates[i])
+                    i++;
+            i++;
+        }
+    }
+    vector<vector<int> > combinationSum2(vector<int>& candidates, int target) {
+        vector<vector<int> > re;
+        vector<int> cur_re;
+        sort(candidates.begin(),candidates.end());
+        sumc(re,candidates,cur_re,target,0,0);
+        return re;
+    }
+
+int main()
+{
+    vector<vector<int> > re;
+    vector<int> candidates;
+    ifstream fin("incombination sum.txt");
+    while(!fin.eof())
+    {
+        int a;
+        fin>>a;
+        candidates.push_back(a);
+    }
+    re=combinationSum2(candidates,2);
+    for (int i=0;i<re.size();i++)
+    {
+        for (int j=0;j<re[i].size();j++)
+            cout<<re[i][j]<<" ";
+        cout<<endl;
+    }
+    return 0;
+}
diff --git a/Combination Sum3.cpp b/Combination Sum3.cpp
new file mode 100644
index 0000000..8e7cd30
--- /dev/null
+++ b/Combination Sum3.cpp	
@@ -0,0 +1,49 @@
+#include<iostream>
+#include<vector>
+#include<algorithm>
+#include<fstream>
+using namespace std;
+
+void cur(vector<vector<int> >& re,vector<int> cur_re,int k,int dep,int index,int sum,int target)
+{
+    if (dep==k)
+    {
+        if (sum==target)
+        {
+            re.push_back(cur_re);
+            return;
+        }
+        else
+            return;
+    }
+    if (sum>target)
+        return;
+    for (int i=index;i<10;i++)
+    {
+        cur_re.push_back(i);
+        cur(re,cur_re,k,dep+1,i+1,sum+i,target);
+        cur_re.pop_back();
+    }
+}
+
+vector<vector<int> > combinationSum3(int k,int n)
+{
+    vector<vector<int> > re;
+    vector<int> cur_re;
+    cur(re,cur_re,k,0,1,0,n);
+    return re;
+}
+
+int main()
+{
+    vector<vector<int> > re;
+    vector<int> candidates;
+    re=combinationSum3(3,9);
+    for (int i=0;i<re.size();i++)
+    {
+        for (int j=0;j<re[i].size();j++)
+            cout<<re[i][j]<<" ";
+        cout<<endl;
+    }
+    return 0;
+}
diff --git a/Combinations.cpp b/Combinations.cpp
new file mode 100644
index 0000000..1844651
--- /dev/null
+++ b/Combinations.cpp
@@ -0,0 +1,38 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+
+void dfs(vector<vector<int> >& re,int dep,int num,vector<int>& cur_re,int k,int n)
+    {
+        if (dep==k)
+        {
+            re.push_back(cur_re);
+            return;
+        }
+        for (int i=num;i<=n-k+dep+1;i++)
+        {
+            cur_re.push_back(i);
+            dfs(re,dep+1,i+1,cur_re,k,n);
+            cur_re.pop_back();
+        }
+    }
+    vector<vector<int> > combine(int n, int k) {
+        vector<vector<int> > re;
+        vector<int> cur_re;
+
+        dfs(re,0,1,cur_re,k,n);
+        return re;
+    }
+
+int main()
+{
+    vector<vector<int> > re;
+    re=combine(4,2);
+    for (int i=0;i<re.size();i++)
+    {
+        for (int j=0;j<re[i].size();j++)
+            cout<<re[i][j];
+        cout<<endl;
+    }
+    return 0;
+}
diff --git a/Contains Duplicate II.cpp b/Contains Duplicate II.cpp
new file mode 100644
index 0000000..96a6a95
--- /dev/null
+++ b/Contains Duplicate II.cpp	
@@ -0,0 +1,38 @@
+#include<iostream>
+#include<map>
+#include<hashtable.h>
+using namespace std;
+
+bool containsNearbyDuplicate(vector<int>& nums, int k) {
+        if (nums.size()<2)
+            return 0;
+        map<int,int> nummap;
+        for (int i=0;i<nums.size();i++)
+        {
+            if(nummap.count(nums[i]))
+            {
+                map<int,int>::iterator lit=nummap.find(nums[i]);
+                int j=lit->second;
+                if (i-j<=k)
+                    return true;
+                else
+                    nummap.erase(lit);
+            }
+            nummap.insert(pair<int,int>(nums[i],i));
+        }
+        return false;
+    }
+
+int main()
+{
+    map<int,int> nummap;
+    nummap.insert(pair<int,int>(5,1));
+    nummap.insert(pair<int,int>(4,2));
+    nummap.insert(pair<int,int>(5,3));
+    nummap.insert(pair<int,int>(5,4));
+    nummap.insert(pair<int,int>(4,5));
+
+    map<int,int>::iterator lit=nummap.find(5);
+    cout<<nummap[0];
+    return 0;
+}
diff --git a/Convert Sorted Array to Binary Search Tree.cpp b/Convert Sorted Array to Binary Search Tree.cpp
new file mode 100644
index 0000000..8dfd423
--- /dev/null
+++ b/Convert Sorted Array to Binary Search Tree.cpp	
@@ -0,0 +1,37 @@
+#include"tree.h"
+
+TreeNode* btree(vector<int>& nums,int high,int low)
+{
+    if (high < low)
+        return NULL;
+    int mid = (high+low)/2;
+    TreeNode* re = new TreeNode(nums[mid]);
+
+    re->left = btree(nums,mid-1,low);
+    re->right = btree(nums,high,mid+1);
+    return re;
+}
+
+TreeNode* sortedArrayToBST(vector<int>& nums)
+{
+    int len = nums.size();
+    int high = len - 1, low = 0;
+
+    if (len == 0)
+        return NULL;
+    if (len == 1)
+        return new TreeNode(nums[0]);
+
+    TreeNode* root = btree(nums,high,low);
+    return root;
+}
+
+int main()
+{
+    vector<int> nums;
+    for (int i=0;i<8;i++)
+        nums.push_back(i);
+    TreeNode* root = sortedArrayToBST(nums);
+    printtree(root);
+    return 0;
+}
diff --git a/Count Complete Tree Nodes.cpp b/Count Complete Tree Nodes.cpp
new file mode 100644
index 0000000..2611027
--- /dev/null
+++ b/Count Complete Tree Nodes.cpp	
@@ -0,0 +1,53 @@
+#include "tree.h"
+#include<math.h>
+
+int getleft(TreeNode* l)
+{
+    int cont = 0;
+    while (l!=NULL)
+    {
+        l=l->left;
+        cont++;
+    }
+    return cont;
+}
+
+int getright(TreeNode* r)
+{
+    int cont = 0;
+    while (r!=NULL)
+    {
+        r=r->right;
+        cont++;
+    }
+    return cont;
+}
+
+int countNodes(TreeNode* root)
+{
+    if (root==NULL)
+        return 0;
+    int contleft = getleft(root);
+    int contright = getright(root);
+    if (contleft == contright)
+        return pow(2,contleft)-1;
+    else
+        return countNodes(root->left) + countNodes(root->right) + 1;
+}
+
+int main()
+{
+    ifstream f("in.txt");
+    string s;
+    vector<string> ss;
+    while (!f.eof())
+    {
+        f>>s;
+        ss.push_back(s);
+    }
+    TreeNode* t = buildtree(ss);
+    int cont = countNodes(t);
+    cout<<cont<<endl;
+    return 0;
+}
+
diff --git a/Count Primes.cpp b/Count Primes.cpp
new file mode 100644
index 0000000..692f536
--- /dev/null
+++ b/Count Primes.cpp	
@@ -0,0 +1,50 @@
+#include<iostream>
+#include<math.h>
+#include<vector>
+using namespace std;
+
+//int countPrimes(int n) {
+//        vector<bool> num(n - 1, true);
+//        num[0] = false;
+//        int res = 0, limit = sqrt(n);
+//        for (int i = 2; i <= limit; ++i) {
+//            if (num[i - 1]) {
+//                for (int j = i * i; j < n; j += i) {
+//                    num[j - 1] = false;
+//                }
+//            }
+//        }
+//        for (int j = 0; j < n - 1; ++j) {
+//            if (num[j]) ++res;
+//        }
+//        return res;
+//    }
+
+int countPrimes(int n) {
+        int cont=0;
+        bool isP[n-1];
+        for (int i=0;i<n-1;i++)
+            isP[i]=false;
+        isP[0]=true;
+        for (int i=2;i<=sqrt(n);i++)
+        {
+            if (isP[i-1])
+            {
+                for (int j=i*i;j<n;j+=i)
+                {
+                    isP[j-1]=true;
+                }
+            }
+        }
+        for (int i=1;i<n;i++)
+            if (!isP[i-1])
+                cont++;
+        return cont;
+    }
+    int main()
+{
+    int n=7;
+    int cont=countPrimes(n);
+    cout<<cont;
+    return 0;
+}
diff --git a/Count and Say.cpp b/Count and Say.cpp
new file mode 100644
index 0000000..c31861f
--- /dev/null
+++ b/Count and Say.cpp	
@@ -0,0 +1,62 @@
+#include<iostream>
+#include<string>
+using namespace std;
+
+string countAndSay(int n)
+{
+    if (n==0)
+        return "";
+    string re="1";
+    string cont;
+    for (int i=0;i<n-1;i++)
+    {
+        int num=1;
+        for (int j=0;j<re.size();)
+        {
+            while (re[j]==re[j+1]) {j++;num++;}
+            cont.push_back('0'+num);
+            cont.push_back(re[j]);
+            j++;
+            num=1;
+        }
+        re.assign(cont);
+        cout<<re<<endl;
+        cont.clear();
+    }
+    return re;
+}
+
+//string countAndSay(int n) {
+//     string temp, result;
+//     result.push_back('1');
+//
+//     char currentChar;
+//     int count;
+//
+//     for(int i = 1; i < n; i++) {
+//         temp = result;
+//         result.clear();
+//         currentChar = temp[0];
+//         count = 1;
+//         for(int j = 1; j < temp.size(); j++) {
+//             if(temp[j] == currentChar) {
+//                 count++;
+//             }
+//             else {
+//                 result.push_back('0' + count);
+//                 result.push_back(currentChar);
+//                 currentChar = temp[j];
+//                 count = 1;
+//             }
+//         }
+//         result.push_back('0' + count);
+//         result.push_back(currentChar);
+//     }
+//     return result;
+// }
+int main()
+{
+    string c=countAndSay(6);
+    cout<<c;
+    return 0;
+}
diff --git a/Decode Ways.cpp b/Decode Ways.cpp
new file mode 100644
index 0000000..76e3b01
--- /dev/null
+++ b/Decode Ways.cpp	
@@ -0,0 +1,60 @@
+#include "pack.h"
+
+int stringtoint(string s)
+{
+    stringstream ss;
+    int tmp;
+    ss<<s;
+    ss>>tmp;
+    return tmp;
+}
+
+int numDecodings(string s)
+{
+    int len = s.size();
+    if (len==0)
+        return 0;
+    int cont[len];
+    if (stringtoint(s.substr(0,1))>=1)
+        cont[0]=1;
+    else
+        cont[0]=0;
+    if (len==1)
+        return cont[0];
+    if (cont[0]==0&&len!=1)
+        return 0;
+    int tmp = stringtoint(s.substr(0,2));
+    if(tmp>=1&&tmp<=26)
+        if (stringtoint(s.substr(1,1))!=0)
+            cont[1]=2;
+        else
+            cont[1]=1;
+    else
+        if (stringtoint(s.substr(1,1))!=0)
+            cont[1]=1;
+        else
+            return 0;
+    for (int i=2;i<len;i++)
+    {
+        int tmp = stringtoint(s.substr(i-1,2));
+        if (tmp>=1&&tmp<=26)
+            if (stringtoint(s.substr(i,1))!=0&&stringtoint(s.substr(i-1,1))!=0)
+                cont[i]=cont[i-1]+cont[i-2];
+            else
+                cont[i]=cont[i-2];
+        else
+            if (stringtoint(s.substr(i,1))==0)
+                return 0;
+            else
+                cont[i]=cont[i-1];
+    }
+    return cont[len-1];
+}
+
+int main()
+{
+    string s = "301";
+    int re = numDecodings(s);
+    cout<<re;
+    return 0;
+}
diff --git a/Excel Sheet Column Number.cpp b/Excel Sheet Column Number.cpp
new file mode 100644
index 0000000..2a9060d
--- /dev/null
+++ b/Excel Sheet Column Number.cpp	
@@ -0,0 +1,23 @@
+#include<iostream>
+#include<math.h>
+using namespace std;
+
+int titleToNumber(string s) {
+        int len=s.size();
+        int re=0;
+        for (int i=0;i<len;i++)
+        {
+            re=(s[i]-'A'+1)*pow(26,len-i-1)+re;
+            cout<<(s[i]-'A'+1)*pow(26,len-i-1)<<endl;
+        }
+        return re;
+    }
+
+int main()
+{
+    string a="AB";
+    int re;
+    re=titleToNumber(a);
+    cout<<re;
+    return 0;
+}
diff --git a/Excel Sheet Column Title.cpp b/Excel Sheet Column Title.cpp
new file mode 100644
index 0000000..fd39b1e
--- /dev/null
+++ b/Excel Sheet Column Title.cpp	
@@ -0,0 +1,39 @@
+#include<iostream>
+#include<math.h>
+using namespace std;
+
+string convertToTitle(int n)
+{
+    int level=1;
+    string re;
+    while(n!=0)
+    {
+        if (n%26==0)
+        {
+            re.push_back('Z');
+            n=n/26-1;
+        }
+        else
+        {
+            re.push_back('A'+n%26-1);
+            n=n/26;
+        }
+    }
+    int high=re.size()-1,low=0;
+    while (low<=high)
+    {
+        char tmp=re[low];
+        re[low]=re[high];
+        re[high]=tmp;
+        low++;
+        high--;
+    }
+    return re;
+}
+int main()
+{
+    string a;
+    a=convertToTitle(1);
+    cout<<a;
+    return 0;
+}
diff --git a/Flatten Binary Tree to Linked List.cpp b/Flatten Binary Tree to Linked List.cpp
new file mode 100644
index 0000000..9dbd9bb
--- /dev/null
+++ b/Flatten Binary Tree to Linked List.cpp	
@@ -0,0 +1,34 @@
+#include "tree.h"
+
+void flatten (TreeNode* root)
+{
+    if (root==NULL)
+        return;
+    if (root->left == NULL && root->right == NULL)
+        return;
+    if (root->left!=NULL)
+        flatten(root->left);
+    TreeNode* tmp = root->right;
+    root->right = root->left;
+    root->left = NULL;
+    while (root->right!=NULL)
+        root = root->right;
+    root->right = tmp;
+    flatten(tmp);
+}
+
+int main()
+{
+    ifstream f("in.txt");
+    string s;
+    vector<string> ss;
+    while (!f.eof())
+    {
+        f>>s;
+        ss.push_back(s);
+    }
+    TreeNode* t = buildtree(ss);
+    flatten(t);
+    printtree(t);
+    return 0;
+}
diff --git a/Generate Parentheses.cpp b/Generate Parentheses.cpp
new file mode 100644
index 0000000..09317c5
--- /dev/null
+++ b/Generate Parentheses.cpp	
@@ -0,0 +1,40 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+
+void cur(vector<string>& re,string& cur_re,int leftn,int rightn)
+    {
+        if (leftn==0&&rightn==0)
+        {
+            re.push_back(cur_re);
+            return;
+        }
+        else
+        {
+            if (leftn>rightn)
+                return;
+            if (leftn!=0)
+            {
+                cur_re.push_back('(');
+                cur(re,cur_re,leftn-1,rightn);
+                cur_re.erase(cur_re.end()-1);
+            }
+            cur_re.push_back(')');
+            cur(re,cur_re,leftn,rightn-1);
+            cur_re.erase(cur_re.end()-1);
+        }
+    }
+    vector<string> generateParenthesis(int n) {
+        vector<string> re;
+        string cur_re;
+        cur(re,cur_re,n,n);
+        return re;
+    }
+int main()
+{
+    vector<string> re;
+    re=generateParenthesis(3);
+    for (int i=0;i<re.size();i++)
+        cout<<re[i]<<endl;
+    return 0;
+}
diff --git a/Happy Number.cpp b/Happy Number.cpp
new file mode 100644
index 0000000..fc3421f
--- /dev/null
+++ b/Happy Number.cpp	
@@ -0,0 +1,37 @@
+#include<iostream>
+#include<map>
+#include<math.h>
+using namespace std;
+
+int caqsum(int num){
+        int sum=0;
+        while (num!=0){
+            sum+=pow(num%10,2);
+            num/=10;
+        }
+        return sum;
+    }
+    bool isHappy(int n) {
+        int sum=caqsum(n);
+        map<int,int> nummap;
+        int k=1;
+        while (sum!=1)
+        {
+            sum=caqsum(sum);
+            if (nummap.count(sum))
+            {cout<<sum<<endl;
+                return false;
+            }
+            nummap.insert(pair<int,int>(sum,k));
+            k++;
+        }
+        return true;
+    }
+
+    int main()
+    {
+        int a=7;
+        bool b=isHappy(a);
+        cout<<b;
+        return 0;
+    }
diff --git a/Implement strStr().cpp b/Implement strStr().cpp
new file mode 100644
index 0000000..ca9320c
--- /dev/null
+++ b/Implement strStr().cpp	
@@ -0,0 +1,47 @@
+#include<iostream>
+#include<string>
+using namespace std;
+
+int strStr(string haystack, string needle) {
+        int len=haystack.size();
+        int lenn=needle.size();
+        int pointh=0,pointn=0;
+
+        if(lenn==0)
+            return 0;
+        for (int i=0;i<len;i++)
+        {
+            if (i+lenn-1<len)
+            {
+                pointh=i;
+                if (haystack[pointh]==needle[pointn])
+                {
+                    int flag=0;
+                    for (int j=1;j<lenn;j++)
+                    {
+                        if (haystack[++pointh]==needle[j])
+                            continue;
+                        else
+                        {
+                            flag=1;
+                            break;
+                        }
+                    }
+                    if (flag==0)
+                    {
+                        return i;
+                    }
+                }
+            }
+        }
+        return -1;
+    }
+
+int main()
+{
+    string a="";
+    string b="";
+    int c=strStr(a,b);
+    cout<<c;
+    return 0;
+}
diff --git a/Insersionsortlist.cpp b/Insersionsortlist.cpp
new file mode 100644
index 0000000..bf52ffe
--- /dev/null
+++ b/Insersionsortlist.cpp
@@ -0,0 +1,74 @@
+#include<iostream>
+using namespace std;
+
+struct ListNode {
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+ListNode* insertionSortList(ListNode* head) {
+        ListNode* h=new ListNode(0);
+        h->next=head;
+        ListNode* tmp1=h;
+        ListNode* tmp2=head;
+        int k=0;
+
+        if (head->next==NULL || head==NULL)
+            return head;
+
+        while (tmp2->next!=NULL)
+        {
+            int flag=0;
+            k++;
+            for (int i=0;i<k;i++)
+            {
+                if (tmp1->next->val>tmp2->next->val)
+                {
+                    if (i==0)
+                    {
+                        ListNode* tttt=tmp2->next->next;
+                        tmp2->next->next=head;
+                        head=tmp2->next;
+                        tmp2->next=tttt;
+                        flag=1;
+                        break;
+                    }
+                    else
+                    {
+                        ListNode* tt=tmp2->next->next;
+                        tmp2->next->next=tmp1->next;
+                        tmp1->next=tmp2->next;
+                        tmp2->next=tt;
+                        flag=1;
+                        break;
+                    }
+                }
+                tmp1=tmp1->next;
+            }
+            if (flag==0)
+            {
+                tmp2=tmp2->next;
+            }
+            h->next=head;
+            tmp1=h;
+        }
+        return head;
+    }
+
+int main()
+{
+    ListNode* head=new ListNode(2);
+    head->next=new ListNode(4);
+    head->next->next=new ListNode(3);
+    head->next->next->next=new ListNode(5);
+    head->next->next->next->next=new ListNode(1);
+    head->next->next->next->next->next=new ListNode(0);
+    ListNode* p=insertionSortList(head);
+    while (p!=NULL)
+    {
+        cout<<p->val<<endl;
+        p=p->next;
+    }
+return 0;
+}
diff --git a/Intersection of Two Linked Lists.cpp b/Intersection of Two Linked Lists.cpp
new file mode 100644
index 0000000..750fa50
--- /dev/null
+++ b/Intersection of Two Linked Lists.cpp	
@@ -0,0 +1,68 @@
+#include<iostream>
+using namespace std;
+
+struct ListNode{
+    int val;
+    ListNode* next;
+    ListNode(int x):val(x),next(NULL){}
+};
+
+ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
+        int cont1=0,cont2=0;
+        ListNode* tmp1=headA;
+        ListNode* tmp2=headB;
+        if (headA==NULL||headB==NULL)
+            return NULL;
+        while (tmp1!=NULL)
+        {
+            cont1++;
+            tmp1=tmp1->next;
+        }
+        while (tmp2!=NULL)
+        {
+            cont2++;
+            tmp2=tmp2->next;
+        }
+        if (cont1<cont2)
+        {
+            int cont=cont1;
+            cont1=cont2;
+            cont2=cont;
+            tmp1=headB;
+            tmp2=headA;
+        }
+        else
+        {
+            tmp1=headA;
+            tmp2=headB;
+        }
+        for (int i=0;i<cont1-cont2;i++)
+        {
+            tmp1=tmp1->next;
+        }
+        for (int i=0;i<cont2;i++)
+        {
+            if (tmp1==tmp2)
+                return tmp1;
+            tmp1=tmp1->next;
+            tmp2=tmp2->next;
+        }
+        return NULL;
+    }
+
+int main()
+{
+    ListNode* headA=new ListNode(1);
+    headA->next=new ListNode(2);
+    headA->next->next=new ListNode(3);
+    ListNode* headB=new ListNode(4);
+    headB->next=new ListNode(5);
+    headB->next->next=new ListNode(6);
+    headB->next->next->next=headA->next->next;
+    headA->next->next->next=new ListNode(7);cout<<9;
+    headA->next->next->next->next=new ListNode(8);
+
+    ListNode* tmp=getIntersectionNode(headA,headB);
+    cout<<tmp->val;
+    return 0;
+}
diff --git a/Isomorphic String.cpp b/Isomorphic String.cpp
new file mode 100644
index 0000000..f5d662f
--- /dev/null
+++ b/Isomorphic String.cpp	
@@ -0,0 +1,15 @@
+#include<map>
+#include<iostream>
+#include<string>
+using namespace std;
+
+bool isIsomorphic(string s,string t)
+{
+    bool re;
+    map<>
+}
+
+int main()
+{
+
+}
diff --git a/Kth Smallest Element in a BST.cpp b/Kth Smallest Element in a BST.cpp
new file mode 100644
index 0000000..8b7e309
--- /dev/null
+++ b/Kth Smallest Element in a BST.cpp	
@@ -0,0 +1,45 @@
+#include "tree.h"
+
+int kthSmallest(TreeNode* root, int k)
+{
+    stack<TreeNode*> stk;
+
+    while (root)
+    {
+        stk.push(root);
+        root = root->left;
+    }
+
+    for (int i=0;i<k;i++)
+    {
+        TreeNode* t = stk.top();
+        if (i == k-1)
+            return t->val;
+        stk.pop();
+        if (t->right)
+        {
+            TreeNode* tmp = t->right;
+            while (tmp)
+            {
+                stk.push(tmp);
+                tmp = tmp->left;
+            }
+        }
+    }
+}
+
+int main()
+{
+    ifstream f("in.txt");
+    string s;
+    vector<string> ss;
+    while (!f.eof())
+    {
+        f>>s;
+        ss.push_back(s);
+    }
+    TreeNode* t = buildtree(ss);
+    int kthsmallest = kthSmallest(t,5);
+    cout<<kthsmallest;
+    return 0;
+}
diff --git a/Length of Last Word.cpp b/Length of Last Word.cpp
new file mode 100644
index 0000000..e4c5e45
--- /dev/null
+++ b/Length of Last Word.cpp	
@@ -0,0 +1,27 @@
+#include<iostream>
+#include<string>
+using namespace std;
+
+int lengthOfLastWord(string s) {
+        int len=s.size();
+        if (len==0)
+            return 0;
+        int cont=0;
+        for (int i=len-1;i>=0;i--)
+        {
+            if (s[i]!=' ')
+                cont++;
+            else
+                break;
+
+        }
+        return cont;
+    }
+
+int main()
+{
+    string s="a";
+    int len=lengthOfLastWord(s);
+    cout<<len;
+    return 0;
+}
diff --git a/Linked List Cycle II.cpp b/Linked List Cycle II.cpp
new file mode 100644
index 0000000..f7a5b7d
--- /dev/null
+++ b/Linked List Cycle II.cpp	
@@ -0,0 +1,42 @@
+#include<iostream>
+using namespace std;
+
+struct ListNode {
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+ListNode *detectCycle(ListNode *head) {
+        ListNode* fast=head;
+        ListNode* slow=head;
+
+        if (head==NULL)
+            return NULL;
+
+        int step=0;
+        while (fast->next!=NULL)
+        {
+            fast=fast->next->next;
+            slow=slow->next;
+            if (fast==slow)
+                break;
+        }
+        if (fast->next==NULL)
+            return NULL;
+        while (true)
+        {
+            slow=slow->next;
+            head=head->next;
+            if (slow==head)
+                return slow;
+        }
+    }
+
+int main()
+{
+    ListNode* head=new ListNode(1);
+    head->next=new ListNode(2);
+    detectCycle(head);
+    return 0;
+}
diff --git a/Longest Common Prefix.cpp b/Longest Common Prefix.cpp
new file mode 100644
index 0000000..36a4967
--- /dev/null
+++ b/Longest Common Prefix.cpp	
@@ -0,0 +1,31 @@
+#include<iostream>
+#include<vector>
+#include<string>
+using namespace std;
+
+string longestCommonPrefix(vector<string>& strs)
+{
+    string pre;
+        pre=strs[0];
+
+        for (int i=1;i<strs.size();i++)
+        {
+            for (int j=0;j<pre.size();j++)
+            {
+                if (pre[j]==strs[i][j])
+                    continue;
+                else
+                {
+                    pre=pre.substr(0,j);
+                    break;
+                }
+            }
+        }
+    return pre;
+}
+
+int main()
+{
+
+    return 0;
+}
diff --git a/Longest Substring with At Most Two Distinct Characters.cpp b/Longest Substring with At Most Two Distinct Characters.cpp
new file mode 100644
index 0000000..7597971
--- /dev/null
+++ b/Longest Substring with At Most Two Distinct Characters.cpp	
@@ -0,0 +1,44 @@
+#include "pack.h"
+#include "tree.h"
+
+int lengthOfLongestSubstringTwoDistinct(string s) {
+        int len = s.size();
+        map <char,int> maplist;
+        if (len==0 || len==1)
+            return len;
+        int left = 0, right = 1, maxlen=1, lentmp = 1;
+        maplist.insert(pair<char,int> (s[left],1));
+        while (right <= len-1){
+            if (maplist.size() > 2){
+                maplist[s[left]]--;
+                lentmp--;
+                cout<<maplist[s[left]]<<" ";
+                if (maplist[s[left]]==0)
+                    maplist.erase(maplist.find(s[left]));
+                left++;
+                continue;
+            }
+            if (maplist.count(s[right])){
+                maplist[s[right]]++;
+                lentmp++;
+                maxlen = max(maxlen,lentmp);
+                right++;
+            }
+            else{
+                maplist.insert(pair<char,int> (s[right],1));
+                right++;
+                lentmp++;
+                if (maplist.size()<=2)
+                    maxlen = max(maxlen,lentmp);
+            }
+        }
+        return maxlen;
+    }
+
+int main()
+{
+    TreeNode *t;
+    if (t && t->left)
+        return 3;
+    return 0;
+}
diff --git a/Lowest Common Ancestor of a Binary Tree.cpp b/Lowest Common Ancestor of a Binary Tree.cpp
new file mode 100644
index 0000000..87f3286
--- /dev/null
+++ b/Lowest Common Ancestor of a Binary Tree.cpp	
@@ -0,0 +1,27 @@
+#include"tree.h"
+
+TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q)
+{
+    if (root==NULL)
+        return NULL;
+    if (root==p||root==q)
+        return root;
+    TreeNode* l = lowestCommonAncestor(root->left,p,q);
+    TreeNode* r = lowestCommonAncestor(root->right,p,q);
+    if (l && r)
+        return root;
+    return l?l:R
+}
+
+int main()
+{
+    ifstream f("in.txt");
+    string s;
+    vector<string> ss;
+    while (!f.eof())
+    {
+        f>>s;
+        ss.push_back(s);
+    }
+    TreeNode* t = buildtree(ss);
+}
diff --git a/Maximal Square.cpp b/Maximal Square.cpp
new file mode 100644
index 0000000..4fefe5d
--- /dev/null
+++ b/Maximal Square.cpp	
@@ -0,0 +1,57 @@
+#include "pack.h"
+
+int maximalSquare(vector<vector<char> >& matrix)
+{
+    int len = matrix.size();
+    if (len == 0)
+        return 0;
+    int dp[matrix.size()][matrix[0].size()];
+    for (int i=0;i<matrix.size();i++)
+        for (int j=0;j<matrix[0].size();j++)
+            dp[i][j]=0;
+    int maxarea = 0;
+    for (int i=0;i<len;i++)
+    {
+        for (int j=0;j<matrix[0].size();j++)
+        {
+            if (i > 0 && j > 0)
+                if (matrix[i][j] =='1')
+                    dp[i][j] = min(min(dp[i-1][j],dp[i][j-1]),dp[i-1][j-1]) + 1;
+            else if (matrix[i][j] == '1')
+                    dp[i][j] = 1;
+            if (dp[i][j] > maxarea)
+                maxarea = dp[i][j];
+        }
+    }
+    return maxarea * maxarea;
+}
+
+int main()
+{
+    ifstream in("in.txt");
+    vector<vector<char> > sss;
+    vector<char> t;
+    int k=0;
+    while (!in.eof())
+    {
+        char tmp;
+        in>>tmp;
+        t.push_back(tmp);
+        k++;
+        if (k%5==0)
+        {
+            sss.push_back(t);
+            t.clear();
+        }
+    }
+    for (int i=0;i<sss.size();i++)
+    {
+        for (int j=0;j<sss[i].size();j++)
+            cout<<sss[i][j]<<" ";
+        cout<<endl;
+    }
+    int re = maximalSquare(sss);
+    cout<<re;
+
+    return 0;
+}
diff --git a/Maximum Depth of Binary Tree.cpp b/Maximum Depth of Binary Tree.cpp
new file mode 100644
index 0000000..0976c57
--- /dev/null
+++ b/Maximum Depth of Binary Tree.cpp	
@@ -0,0 +1,41 @@
+#include<iostream>
+using namespace std;
+
+struct TreeNode{
+    int val;
+    TreeNode* left;
+    TreeNode* right;
+    TreeNode(int x):val(x),left(NULL),right(NULL){};
+};
+
+void cur(TreeNode* t,int& cont,int dep)
+    {
+        if (t->left==NULL&&t->right==NULL)
+        {
+            dep++;
+            if (dep>cont)
+                cont=dep;
+            return;
+        }
+        dep++;
+        if (t->left!=NULL)
+            cur(t->left,cont,dep);
+        if (t->right!=NULL)
+            cur(t->right,cont,dep);
+    }
+    int maxDepth(TreeNode* root) {
+        if (root==NULL)
+            return 0;
+        int cont=1;
+        cur(root,cont,0);
+        return cont;
+    }
+
+int main()
+{
+    TreeNode* root=new TreeNode(1);
+    root->left=new TreeNode(2);
+    int a=maxDepth(root);
+    cout<<a;
+    return 0;
+}
diff --git a/Maximum Subarray.cpp b/Maximum Subarray.cpp
new file mode 100644
index 0000000..3095c5a
--- /dev/null
+++ b/Maximum Subarray.cpp	
@@ -0,0 +1,48 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+
+int maxSubArray(vector<int>& nums)
+{
+    int len=nums.size();
+    vector<int> cont(len,0);
+    cont[0]=nums[0];
+    for (int i=1;i<len;i++)
+    {
+        if (nums[i]<=0)
+            cont[i]=cont[i-1];
+        else
+        {
+            int sum=nums[i];
+            cont[i]=cont[i-1];
+            for (int j=i-1;j>=0;j--)
+            {
+                cout<<sum<<endl;
+                if (sum>cont[i])
+                    cont[i]=sum;
+                sum+=nums[j];
+            }
+            if (sum>cont[i])
+                cont[i]=sum;
+            cout<<endl;
+        }
+    }
+    return cont[len-1];
+}
+
+int main()
+{
+    vector<int> nums;
+    nums.push_back(-2);
+        nums.push_back(1);
+            nums.push_back(-3);
+                nums.push_back(4);
+                    nums.push_back(-1);
+                        nums.push_back(2);
+                            nums.push_back(1);
+                                nums.push_back(-5);
+                                    nums.push_back(4);
+    int re=maxSubArray(nums);
+    cout<<re;
+    return 0;
+}
diff --git a/Merge Sorted Array.cpp b/Merge Sorted Array.cpp
new file mode 100644
index 0000000..716db6b
--- /dev/null
+++ b/Merge Sorted Array.cpp	
@@ -0,0 +1,13 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+
+int main()
+{
+    vector<int> a;
+    a.push_back(6);
+    a.push_back(5);
+    a.erase(a.begin());
+    cout<<a[0];
+    return 0;
+}
diff --git a/Minimum Path Sum.cpp b/Minimum Path Sum.cpp
new file mode 100644
index 0000000..997050f
--- /dev/null
+++ b/Minimum Path Sum.cpp	
@@ -0,0 +1,35 @@
+#include<vector>
+#include<iostream>
+using namespace std;
+
+int minPathSum(vector<vector<int> >& grid) {
+        if (grid.size()==0)
+            return 0;
+        int sp[grid.size()][grid[0].size()];
+        sp[0][0]=grid[0][0];
+        for (int i=1;i<grid.size();i++)
+            sp[i][0]=sp[i-1][0]+grid[i][0];
+        for (int i=1;i<grid[0].size();i++)
+            sp[0][i]=sp[0][i-1]+grid[0][i];
+        for (int i=1;i<grid.size();i++)
+            for (int j=1;j<grid[0].size();j++)
+            {
+                if (sp[i-1][j]>sp[i][j-1])
+                    sp[i][j]=sp[i-1][j]+grid[i][j];
+                else
+                    sp[i][j]=sp[i][j-1]+grid[i][j];
+            }
+        return sp[grid.size()-1][grid[0].size()-1];
+    }
+
+int main()
+{
+    vector<int> c({1,2});
+    vector<int> b({1,1});
+    vector<vector<int> > re;
+    re.push_back(c);
+    re.push_back(b);
+    int r=minPathSum(re);
+    cout<<r;
+    return 0;
+}
diff --git a/Minimum Size Subarray Sum.cpp b/Minimum Size Subarray Sum.cpp
new file mode 100644
index 0000000..77f919e
--- /dev/null
+++ b/Minimum Size Subarray Sum.cpp	
@@ -0,0 +1,68 @@
+#include<iostream>
+#include<vector>
+#include<algorithm>
+using namespace std;
+
+int minSubArrayLen(int s, vector<int>& nums)
+{
+    int len=nums.size();
+    int p1=0,p2=1;
+    int re;
+    if(len==0)
+        return 0;
+    if (nums[1]>=s)
+        return 1;
+
+    int sum=nums[p1]+nums[p2];
+    if (sum>=s)
+        re=2;
+    else
+        re=len;
+    int cont=2;
+    while (p2<=len-1)
+    {
+        if (sum<s)
+        {
+            if (cont==len)
+                {return 0;}
+            p2++;
+            cont++;
+            sum+=nums[p2];
+            continue;
+        }
+        else
+        {
+            int tmps=sum-nums[p1];
+            if (tmps>=s)
+            {
+                sum-=nums[p1];
+                p1++;
+                cont--;
+                if (cont<=re)
+                    re=cont;
+            }
+            else
+            {
+                p1++;
+                p2++;
+                if(p2<=len-1)
+                    sum=sum-nums[p1-1]+nums[p2];
+            }
+        }
+    }
+    return re;
+}
+
+int main()
+{
+    vector<int> n;
+//    n.push_back(2);
+//    n.push_back(3);
+//    n.push_back(1);
+    n.push_back(1);
+    n.push_back(1);
+//    n.push_back(3);
+    int a=minSubArrayLen(3,n);
+    cout<<a;
+    return 0;
+}
diff --git a/Move Zeroes.cpp b/Move Zeroes.cpp
new file mode 100644
index 0000000..b5eaaef
--- /dev/null
+++ b/Move Zeroes.cpp	
@@ -0,0 +1,4 @@
+#include<vector>
+#include<iostream>
+using namespace std;
+
diff --git a/Number of Islands.cpp b/Number of Islands.cpp
new file mode 100644
index 0000000..4a303dc
--- /dev/null
+++ b/Number of Islands.cpp	
@@ -0,0 +1,49 @@
+#include "pack.h"
+
+int numIslands(vector<vector<char> >& grid)
+{
+    int lenr = grid.size();
+    if (lenr == 0)
+        return 0;
+    int lenc = grid[0].size();
+
+    int ans=0;
+    for (int i=0;i<lenr;i++)
+        for (int j=0;j<lenc;j++)
+    {
+        if (grid[i][j]=='0')
+            continue;
+        ams++;
+    }
+    return ans;
+}
+
+void dfs(vector<vector<char> >& grid,int i,int j)
+{
+    int lenr = grid.size();
+    int lenc = grid[0].size();
+
+    if (i+1==lenr&&j+1==lenc)
+        return;
+    else if (i+1==lenr)
+    {
+        if (grid[i][j+1]=='0')
+            return;
+    }
+    else if (j+1==lenc)
+    {
+        if (grid[i+1][j]=='0')
+            return;
+    }
+    else
+    {
+        if (grid[i+1][j]=='0'&&grid[i][j+1]=='0')
+            return;
+    }
+    if (grid[i][j]=='1')
+        grid[i][j]=0;
+    if (i+1<lenr)
+        dfs(grid,i+1,j);
+    if (j+1<lenc)
+        dfs(grid,i,j+1);
+}
diff --git a/Paint House II.cpp b/Paint House II.cpp
new file mode 100644
index 0000000..38968d1
--- /dev/null
+++ b/Paint House II.cpp	
@@ -0,0 +1,2 @@
+#include "pack.h"
+
diff --git a/Palindrome Linked List.cpp b/Palindrome Linked List.cpp
new file mode 100644
index 0000000..8765858
--- /dev/null
+++ b/Palindrome Linked List.cpp	
@@ -0,0 +1,3 @@
+#include<iostream>
+using namespace std;
+
diff --git a/Palindrome Number.cpp b/Palindrome Number.cpp
new file mode 100644
index 0000000..48af526
--- /dev/null
+++ b/Palindrome Number.cpp	
@@ -0,0 +1,38 @@
+#include<iostream>
+using namespace std;
+
+bool isPalindrome(int x) {
+        if (x<0)
+            return false;
+        int num=1;
+        while (x/num>=10)
+        {
+            num*=10;
+        }
+        int numl=1;
+        while (num>=numl)
+        {
+            int h=x/num;
+            int l=x%10;
+            if (h==l)
+            {
+                x-=x/num*num;
+                x/=10;
+                num/=100;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        return true;
+     }
+
+int main()
+{
+    int a=10;
+    bool c=isPalindrome(a);
+    cout<<c;
+    return 0;
+}
diff --git a/Palindrome Partitioning.cpp b/Palindrome Partitioning.cpp
new file mode 100644
index 0000000..059a8c4
--- /dev/null
+++ b/Palindrome Partitioning.cpp	
@@ -0,0 +1,13 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+
+void cur(vector<vector<string> >& re,)
+{
+
+}
+
+vector<vector<string> > partition(string s)
+{
+
+}
diff --git a/Pascal's Triangle II.cpp b/Pascal's Triangle II.cpp
new file mode 100644
index 0000000..1731a85
--- /dev/null
+++ b/Pascal's Triangle II.cpp	
@@ -0,0 +1,28 @@
+#include<vector>
+#include<iostream>
+using namespace std;
+
+vector<int> getRow(int rowIndex) {
+        vector<int> re(rowIndex+1,0);
+        vector<int> t(rowIndex+1,0);
+        t[0]=1;
+        for (int i=1;i<rowIndex+1;i++)
+        {cout<<9;
+            re[0]=1;
+            re[i]=1;
+            for (int j=1;j<i;j++)
+            {
+                re[j]=t[j-1]+t[j];
+            }
+            t=re;
+        }
+        return re;
+    }
+
+int main()
+{
+    vector<int> re=getRow(0);
+    for (int i=0;i<re.size();i++)
+        cout<<re[i];
+    return 0;
+}
diff --git a/Pascal's Triangle.cpp b/Pascal's Triangle.cpp
new file mode 100644
index 0000000..f79cb7a
--- /dev/null
+++ b/Pascal's Triangle.cpp	
@@ -0,0 +1,36 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+
+vector<vector<int> > generate(int numRows) {
+        vector<vector<int> > re;
+        vector<int> v(1,1);
+        re.push_back(v);
+        for (int i=1;i<numRows;i++)
+        {
+            vector<int> u(i+1,0);
+            u[0]=1;
+            u[i]=1;
+            for (int j=1;j<i;j++)
+            {
+                u[j]=v[j-1]+v[j];
+            }
+            re.push_back(u);
+            v=u;
+            u.clear();
+        }
+        return re;
+    }
+
+int main()
+{
+    vector<vector<int> > re;
+    re=generate(5);
+    for (int i=0;i<re.size();i++)
+    {
+        for (int j=0;j<re[i].size();j++)
+            cout<<re[i][j];
+        cout<<endl;
+    }
+    return 0;
+}
diff --git a/Path Sum.cpp b/Path Sum.cpp
new file mode 100644
index 0000000..316a777
--- /dev/null
+++ b/Path Sum.cpp	
@@ -0,0 +1,31 @@
+#include<iostream>
+using namespace std;
+
+struct TreeNode{
+    int val;
+    TreeNode* left;
+    TreeNode* right;
+    TreeNode(int x):val(x),left(NULL),right(NULL){}
+};
+
+    void cur(TreeNode* root,int sum,int tsum,bool& re)
+    {
+        tsum+=root->val;
+        if (root->left==NULL&&root->right==NULL)
+        {
+            if (tsum==sum)
+                re=true;
+            return;
+        }
+        if (root->left!=NULL)
+            cur(root->left,sum,tsum,re);
+        if (root->right!=NULL)
+            cur(root->right,sum,tsum,re);
+    }
+    bool hasPathSum(TreeNode* root, int sum) {
+        bool re=false;
+        if (root==NULL)
+            return re;
+        cur(root,sum,0,re);
+        return re;
+    }
diff --git a/Path SumII.cpp b/Path SumII.cpp
new file mode 100644
index 0000000..d998bdf
--- /dev/null
+++ b/Path SumII.cpp	
@@ -0,0 +1,69 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+
+struct TreeNode{
+    int val;
+    TreeNode* left;
+    TreeNode* right;
+    TreeNode(int x):val(x),left(NULL),right(NULL){}
+};
+
+void cur(vector<vector<int> >& re,vector<int>& cur_re,TreeNode* t,int sum,int tsum)
+    {
+        if (t->left==NULL&&t->right==NULL)
+        {
+            if (tsum==sum)
+            {
+                re.push_back(cur_re);
+                return;
+            }
+            else
+                return;
+        }
+        if (t->left!=NULL)
+        {
+            cur_re.push_back(t->left->val);
+            cur(re,cur_re,t->left,sum,tsum+t->left->val);
+            cur_re.pop_back();
+        }
+        if (t->right!=NULL)
+        {
+            cur_re.push_back(t->right->val);
+            cur(re,cur_re,t->right,sum,tsum+t->right->val);
+            cur_re.pop_back();
+        }
+    }
+    vector<vector<int> > pathSum(TreeNode* root, int sum) {
+        vector<vector<int> > re;
+        vector<int> cur_re;
+        if (root==NULL)
+            return re;
+        cur_re.push_back(root->val);
+        cur(re,cur_re,root,sum,root->val);
+        return re;
+    }
+
+int main()
+{
+    TreeNode* root=new TreeNode(5);
+    root->left=new TreeNode(4);
+    root->right=new TreeNode(8);
+    root->left->left=new TreeNode(11);
+    root->right->left=new TreeNode(13);
+    root->right->right=new TreeNode(4);
+    root->left->left->left=new TreeNode(7);
+    root->left->left->right=new TreeNode(2);
+    root->right->right->left=new TreeNode(5);
+    root->right->right->right=new TreeNode(1);
+
+    vector<vector<int> > re;
+    re=pathSum(root,22);
+    for (int i=0;i<re.size();i++)
+    {
+        for (int j=0;j<re[i].size();j++)
+            cout<<re[i][j]<<" ";
+        cout<<endl;
+    }
+    return 0;
+}
diff --git a/Perfect Squares.cpp b/Perfect Squares.cpp
new file mode 100644
index 0000000..a5b661e
--- /dev/null
+++ b/Perfect Squares.cpp	
@@ -0,0 +1,28 @@
+#include<iostream>
+#include<cmath>
+using namespace std;
+
+    int numSquares(int n) {
+        int sq[n+1];
+        for (int i=0;i<n;i++)
+            sq[i]=0;
+        for (int i=1;i*i<=n;i++)
+            sq[i*i]=1;
+        for (int i=1;i<=n;i++)
+            for (int j=1;j*j+i<=n;j++)
+            {
+                if (!sq[i+j*j]||sq[i+j*j]>sq[i]+1)
+                    sq[i+j*j]=sq[i]+1;
+                for (int i=0;i<n;i++)
+                    cout<<sq[i]<<" ";
+                cout<<endl;
+            }
+    return sq[n];
+    }
+
+int main()
+{
+    int s=numSquares(8);
+    cout<<s;
+    return 0;
+}
diff --git a/Permutations.cpp b/Permutations.cpp
new file mode 100644
index 0000000..ad94422
--- /dev/null
+++ b/Permutations.cpp
@@ -0,0 +1,48 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+
+void cur(vector<vector<int> >& re,vector<int>& cur_re,vector<int>& left,int dep)
+{
+    if (dep==0)
+    {
+        re.push_back(cur_re);
+        return;
+    }
+    for (int i=0;i<left.size();i++)
+    {
+        cur_re.push_back(left[i]);
+        int tmp=left[i];
+        left.erase(left.begin()+i);
+        cur(re,cur_re,left,dep-1);
+        cur_re.pop_back();
+        left.insert(left.begin()+i,tmp);
+    }
+}
+
+vector<vector<int> > permute(vector<int>& nums)
+{
+    vector<vector<int> > re;
+    vector<int> cur_re;
+    if (nums.size()==0)
+        return re;
+    cur(re,cur_re,nums,nums.size());
+    return re;
+}
+
+int main()
+{
+    vector<int> nums;
+    nums.push_back(1);
+    nums.push_back(2);
+    nums.push_back(3);
+    vector<vector<int> > re;
+    re=permute(nums);
+    for (int i=0;i<re.size();i++)
+    {
+        for (int j=0;j<re[i].size();j++)
+            cout<<re[i][j]<<" ";
+        cout<<endl;
+    }
+    return 0;
+}
diff --git a/Populating Next Right Pointers in Each Node.cpp b/Populating Next Right Pointers in Each Node.cpp
new file mode 100644
index 0000000..93e5f4c
--- /dev/null
+++ b/Populating Next Right Pointers in Each Node.cpp	
@@ -0,0 +1,33 @@
+#include"tree.h"
+
+void connect(TreeLinkNode* root)
+{
+    if (root==NULL)
+        return;
+    queue<TreeLinkNode*> q;
+    q.push(root);
+
+    while (!q.empty())
+    {
+        int len = q.size();
+        TreeLinkNode* t1;
+        TreeLinkNode* t2;
+
+        for (int i=0;i<len;i++)
+        {
+            t1 = q.front();
+            q.pop();
+            if (i!=len-1)
+            {
+                t2 = q.front();
+                t1->next = t2;
+            }
+            if (t1->left!=NULL)
+                q.push(t1->left);
+            if (t1->right!=NULL)
+                q.push(t1->right);
+        }
+        t1->next = NULL;
+    }
+}
+
diff --git a/Power of Two.cpp b/Power of Two.cpp
new file mode 100644
index 0000000..8cd3af6
--- /dev/null
+++ b/Power of Two.cpp	
@@ -0,0 +1,11 @@
+#include<iostream>
+using namespace std;
+
+int main()
+{
+    bool re;
+    int n=9;
+    re=!(n&(n-1));
+    cout<<re;
+    return 0;
+}
diff --git a/Product of Array Except Self.cpp b/Product of Array Except Self.cpp
new file mode 100644
index 0000000..12e0eef
--- /dev/null
+++ b/Product of Array Except Self.cpp	
@@ -0,0 +1,43 @@
+#include<vector>
+#include<iostream>
+using namespace std;
+
+vector<int> productExceptSelf(vector<int>& nums) {
+        int len=nums.size();
+        vector<int> re;
+        if (len==2)
+        {
+            re.push_back(nums[1]);
+            re.push_back(nums[0]);
+            return re;
+        }
+        re.push_back(1);
+        int p=1;
+
+        for (int i=1;i<len;i++)
+        {
+            p*=nums[i-1];
+            re.push_back(p);
+        }
+
+        p=1;
+        for (int i=len-2;i>=0;i--)
+        {
+            p*=nums[i+1];
+            re[i]*=p;
+        }
+        return re;
+    }
+
+int main()
+{
+    vector<int> nums;
+    nums.push_back(9);
+    nums.push_back(0);
+    nums.push_back(-2);
+    vector<int> re;
+    re=productExceptSelf(nums);
+    for (int i=0;i<re.size();i++)
+        cout<<re[i]<<" ";
+    return 0;
+}
diff --git a/Recover Binary Search Tree.cpp b/Recover Binary Search Tree.cpp
new file mode 100644
index 0000000..a7900a9
--- /dev/null
+++ b/Recover Binary Search Tree.cpp	
@@ -0,0 +1,64 @@
+#include"tree.h"
+
+    TreeNode* mistake1;
+    TreeNode* mistake2;
+    TreeNode* pre;
+    TreeNode* post;
+
+void cur(TreeNode* t)
+{
+    if (t==NULL)
+        return;
+    if (t->left)
+        cur(t->left);
+    if (pre->val>t->val)
+        if (mistake1==NULL)
+        {
+            mistake1=pre;
+            post = t;
+        }
+        else
+            mistake2=t;
+    pre=t;
+    if (t->right)
+        cur(t->right);
+
+}
+
+void recoverTree(TreeNode* root)
+{
+    if (root==NULL)
+        return;
+    TreeNode* t = root;
+    while (t->left)
+        t=t->left;
+    pre=t;
+    cur(root);
+    int tmp=mistake1->val;
+    if (mistake2)
+    {
+        mistake1->val=mistake2->val;
+        mistake2->val=tmp;
+    }
+    else
+    {
+        mistake1->val=post->val;
+        post->val=tmp;
+    }
+}
+
+int main()
+{
+    ifstream f("in.txt");
+    string s;
+    vector<string> ss;
+    while (!f.eof())
+    {
+        f>>s;
+        ss.push_back(s);
+    }
+    TreeNode* t = buildtree(ss);
+    recoverTree(t);
+    printtree(t);
+    return 0;
+}
diff --git a/Rectangle Area.cpp b/Rectangle Area.cpp
new file mode 100644
index 0000000..3a43822
--- /dev/null
+++ b/Rectangle Area.cpp	
@@ -0,0 +1,34 @@
+#include<iostream>
+#include<vector>
+#include<algorithm>
+
+using namespace std;
+
+    int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) {
+        int area1=(C-A)*(D-B);
+        int area2=(G-E)*(H-F);
+
+        vector<int> t1;
+        vector<int> t2;
+
+        t1.push_back(A);
+        t1.push_back(C);
+        t1.push_back(E);
+        t1.push_back(G);
+
+        t2.push_back(B);
+        t2.push_back(D);
+        t2.push_back(F);
+        t2.push_back(H);
+
+
+        sort(t1.begin(),t1.end());
+        sort(t2.begin(),t2.end());
+
+        int area=(t1[2]-t1[1])*(t2[2]-t2[1]);
+        return area1+area2-area;
+    }
+int main
+{
+
+}
diff --git a/Remove Duplicates from Sorted LIst.cpp b/Remove Duplicates from Sorted LIst.cpp
new file mode 100644
index 0000000..044c74a
--- /dev/null
+++ b/Remove Duplicates from Sorted LIst.cpp	
@@ -0,0 +1,43 @@
+#include<iostream>
+using namespace std;
+
+struct ListNode{
+    int val;
+    ListNode* next;
+    ListNode(int x):val(x),next(NULL){}
+};
+
+ListNode* deleteDuplicates(ListNode* head) {
+        ListNode* tmp;
+        ListNode* re=head;
+        if (head==NULL)
+            return head;
+        while (head->next!=NULL)
+        {
+            if (head->val==head->next->val)
+            {
+                tmp=head->next;
+                head->next=head->next->next;
+                delete tmp;
+            }
+            else
+            {
+                head=head->next;
+            }
+        }
+        return re;
+    }
+
+int main()
+{
+    ListNode* head=new ListNode(1);
+    head->next=new ListNode(1);
+    ListNode* re=deleteDuplicates(head);
+    cout<<99;
+    while (re!=NULL)
+    {
+        cout<<re->val<<endl;
+        re=re->next;
+    }
+    return 0;
+}
diff --git a/Remove Element.cpp b/Remove Element.cpp
new file mode 100644
index 0000000..0a95976
--- /dev/null
+++ b/Remove Element.cpp	
@@ -0,0 +1,89 @@
+#include<iostream>
+#include<vector>
+#include<algorithm>
+using namespace std;
+
+int removeElement(vector<int>& nums, int val) {
+        sort(nums.begin(),nums.end());
+        int len=nums.size();
+
+        if (len==0)
+            return 0;
+        if (len==1)
+        {
+            if (nums[0]==val)
+                return 0;
+            else
+                return 1;
+        }
+
+        int high=len-1,low=0,mid=(high+low)/2;
+        while (low<high)
+        {
+            if (nums[mid]>val)
+            {
+                high=mid-1;
+                mid=(low+high)/2;
+
+            }
+            else if (nums[mid]<val)
+            {
+                low=mid+1;
+                mid=(high+low)/2;
+
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        int p1=mid,p2=mid+1;
+        if (p2>len-1)
+            p2=len-1;
+        while (true)
+        {
+            if (p1>=0)
+            {
+                if (nums[p1]==val)
+                {
+                    nums.erase(nums.begin()+p1);
+                    if (p1-1>=0)
+                        p1--;
+                    if (p2-1>=0)
+                        p2--;
+                    len--;
+                    if (len==0)
+                        break;
+                }
+            }
+            if (p2<len)
+            {
+                if (nums[p2]==val)
+                {
+                    cout<<0;
+                    nums.erase(nums.begin()+p2);
+                    len--;
+                    if (len==0)
+                        break;
+                    if (p2>=len)
+                        p2=len-1;
+                }
+            }
+            if (nums[p1]!=val&&nums[p2]!=val)
+                break;
+        }
+
+        return nums.size();
+    }
+
+int main()
+{
+    vector<int> num;
+    num.push_back(4);
+    num.push_back(5);
+    num.push_back(5);
+    int i=removeElement(num,5);
+    cout<<i;
+    return 0;
+}
diff --git a/Remove Nth Node From End of List.cpp b/Remove Nth Node From End of List.cpp
new file mode 100644
index 0000000..616e9e3
--- /dev/null
+++ b/Remove Nth Node From End of List.cpp	
@@ -0,0 +1,52 @@
+#include<iostream>
+using namespace std;
+
+struct ListNode {
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+ListNode* removeNthFromEnd(ListNode* head, int n) {
+        ListNode* h=new ListNode(0);
+        h->next=head;
+        ListNode* front=head;
+        ListNode* back=h;
+
+        for (int i=0;i<n-1;i++)
+        {
+            front=front->next;
+        }
+        while (front->next!=NULL)
+        {
+            front=front->next;
+            back=back->next;
+        }
+
+        if (back->next->next==NULL)
+        {
+            if (head==back->next)
+                head=head->next;
+            back->next=NULL;
+            return head;
+        }
+        if (back->next==head)
+        {
+            head=head->next;
+            return head;
+        }
+        ListNode* tmp=back->next;
+        back->next=back->next->next;
+        delete tmp;
+        return head;
+    }
+
+int main()
+{
+    ListNode* head=new ListNode(1);
+
+    ListNode* h=removeNthFromEnd(head,1);
+    if(h==NULL)
+        cout<<99;
+    return 0;
+}
diff --git a/Reverse Linked List.cpp b/Reverse Linked List.cpp
new file mode 100644
index 0000000..6edbc2b
--- /dev/null
+++ b/Reverse Linked List.cpp	
@@ -0,0 +1,35 @@
+#include<iostream>
+using namespace std;
+
+struct ListNode {
+      int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+ };
+
+ListNode* reverseList(ListNode* head) {
+        if (head==NULL)
+            return head;
+        if (head->next==NULL)
+            return head;
+        ListNode* tmp=reverseList(head->next);
+        ListNode* tmpt=tmp;
+        while (tmpt->next!=NULL)
+        {
+            tmpt=tmpt->next;
+        }
+        tmpt->next=head;
+        head->next=NULL;
+        return tmp;
+    }
+
+    int main()
+    {
+        ListNode* head=new ListNode(1);
+        head->next=new ListNode(2);
+        head->next->next=new ListNode(3);
+        head->next->next->next=new ListNode(4);
+        ListNode* h=reverseList(head);
+        cout<<h->val<<endl<<h->next->val<<endl<<h->next->next->val<<endl<<h->next->next->next->val;
+        return 0;
+    }
diff --git a/Reverse Words in a String II.cpp b/Reverse Words in a String II.cpp
new file mode 100644
index 0000000..818507b
--- /dev/null
+++ b/Reverse Words in a String II.cpp	
@@ -0,0 +1,25 @@
+#include "pack.h"
+
+void reverseWords(string &s)
+{
+    int len = s.size();
+    vector<int> pos;
+    pos.push_back(-1);
+
+    for (int i=0;i<len;i++)
+        if (s[i]==' ')
+            pos.push_back(i);
+    pos.push_back(len);
+
+    for (int i=0;i<pos.size()-1;i++)
+        reverse(s.begin()+pos[i]+1,s.begin()+pos[i+1]);
+    reverse(s.begin(),s.end());
+}
+
+int main()
+{
+    string s = "len inu loppps";
+    reverseWords(s);
+    cout<<s;
+    return 0;
+}
diff --git a/Serialize and Deserialize Binary Tree.cpp b/Serialize and Deserialize Binary Tree.cpp
new file mode 100644
index 0000000..9253d38
--- /dev/null
+++ b/Serialize and Deserialize Binary Tree.cpp	
@@ -0,0 +1,98 @@
+#include "tree.h"
+
+string serialize(TreeNode* root)
+{
+    queue<TreeNode*> q;
+    stringstream ss;
+    q.push(root);
+    string s;
+
+    if (root==NULL)
+        return s;
+
+    while (!q.empty())
+    {
+        TreeNode* tmpnode = q.front();
+        string tmpstring;
+        if (tmpnode != NULL)
+        {
+            tmpstring = inttostring(tmpnode->val);
+            s = s + tmpstring + " ";
+        }
+        else
+        {
+            s = s + "# ";
+        }
+        q.pop();
+        if (tmpnode!=NULL)
+        {
+            q.push(tmpnode->left);
+            q.push(tmpnode->right);
+        }
+    }
+    s.erase(s.end()-1);
+    while (s[s.size()-1]=='#')
+    {
+        s.erase(s.end()-1);
+        s.erase(s.end()-1);
+    }
+    return s;
+}
+
+TreeNode* deserialize(string data)
+{
+    if (data.size()==0)
+        return NULL;
+    queue<TreeNode*> q;
+    istringstream ss(data);
+    vector<string> sv;
+
+    int tmp;
+    do
+    {
+        string s;
+        ss>>s;
+        sv.push_back(s);
+    } while(ss);
+    TreeNode* root = new TreeNode(stringtoint(sv[0]));
+    q.push(root);
+    int k=0;
+    while (k<sv.size()-2)
+    {
+        TreeNode* tm = q.front();
+        q.pop();
+        if (sv[++k]!="#")
+        {
+            tmp = stringtoint(sv[k]);
+            tm->left = new TreeNode(tmp);
+            q.push(tm->left);
+        }
+        if (k+1<sv.size()-1)
+            if (sv[++k]!="#")
+            {
+                tmp = stringtoint(sv[k]);
+                tm->right = new TreeNode(tmp);
+                q.push(tm->right);
+            }
+
+    }
+    return root;
+}
+
+int main()
+{
+    ifstream f("in.txt");
+    string s;
+    vector<string> ss;
+    while (!f.eof())
+    {
+        f>>s;
+        ss.push_back(s);
+    }
+    TreeNode* t = buildtree(ss);
+    string sss = serialize(t);
+    //cout<<sss<<endl;
+    TreeNode* tt = deserialize(sss);
+    //printtree(tt);
+    return 0;
+}
diff --git a/Shortest Word Distance.cpp b/Shortest Word Distance.cpp
new file mode 100644
index 0000000..8aab135
--- /dev/null
+++ b/Shortest Word Distance.cpp	
@@ -0,0 +1,38 @@
+#include "pack.h"
+
+int shortestDistance(vector<string>& words, string word1, string word2) {
+    int loca1=-1;
+    int loca2=-1;
+    int dis = words.size()-1;
+
+    for (int i=0;i<words.size();i++)
+    {
+        if (words[i]==word1)
+        {
+            loca1 = i;
+            if (i - loca2 < dis && loca2>=0)
+                dis = loca1 - loca2;
+        }
+        if (words[i]==word2)
+        {
+            loca2 = i;
+            if (i - loca1 < dis&& loca1>=0)
+                dis = loca2 - loca1;
+        }
+        cout<<loca1<<" "<<loca2<<endl;
+    }
+    return dis;
+}
+
+int main()
+{
+    vector<string> words;
+    words.push_back("a");
+    words.push_back("b");
+    words.push_back("c");
+    words.push_back("d");
+    words.push_back("d");
+    int dis = shortestDistance(words,"a","d");
+    cout<<dis;
+    return 0;
+}
diff --git a/Sort List.cpp b/Sort List.cpp
new file mode 100644
index 0000000..d823bba
--- /dev/null
+++ b/Sort List.cpp	
@@ -0,0 +1,6 @@
+#include "list.h"
+
+ListNode* sortList(ListNode* head)
+{
+
+}
diff --git a/String to Integer (atoi).cpp b/String to Integer (atoi).cpp
new file mode 100644
index 0000000..e450712
--- /dev/null
+++ b/String to Integer (atoi).cpp	
@@ -0,0 +1,32 @@
+#include "pack.h"
+#include <limits.h>
+
+    int myAtoi(string str) {
+        int len = str.size();
+        if (len==0) return 0;
+        long long ans = 0;
+        int sign = 1;
+        int l = 0;
+        while (str[l]==' ') l++;
+        if (str[l]=='-') sign=-1,l++;
+        else if (str[l]=='+') l++;
+        for (int i=l;i<len;i++){
+            if (str[i]-'0'>=0&&str[i]-'0'<=9)
+                ans = ans*10 + (str[i] - '0');
+            else
+                break;
+        }
+        ans = ans*sign;
+        if (ans>INT_MAX)
+            return INT_MAX;
+        if (ans<INT_MIN)
+            return INT_MIN;
+        return ans;
+    }
+
+    int main()
+    {
+        string str = "   123*(99868";
+        cout<<myAtoi(str);
+        return 0;
+    }
diff --git a/Subsets.cpp b/Subsets.cpp
new file mode 100644
index 0000000..b53204e
--- /dev/null
+++ b/Subsets.cpp
@@ -0,0 +1,52 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+
+void cur(vector<vector<int> >& re,vector<int>& cur_re,vector<int> nums,int left,int ss)
+{
+    if (left==0)
+    {
+        re.push_back(cur_re);
+        return;
+    }
+    for (int i=ss;i<=nums.size()-left;i++)
+    {
+        cur_re.push_back(nums[i]);
+        cur(re,cur_re,nums,left-1,i+1);
+        cur_re.pop_back();
+        while (nums[i]==nums[i+1]) {i++;}
+    }
+}
+vector<vector<int> > subsets(vector<int>& nums)
+{
+    vector<int> cur_re;
+    vector<vector<int> > re;
+    re.push_back(cur_re);
+    if (nums.size()==0)
+        return re;
+
+    for (int i=0;i<nums.size();i++)
+    {
+        cur(re,cur_re,nums,i+1,0);
+    }
+    return re;
+}
+
+int main()
+{
+    vector<vector<int> > re;
+    vector<int> cur_re;
+    vector<int> num;
+    num.push_back(1);
+    num.push_back(1);
+    num.push_back(2);
+    num.push_back(2);
+    re=subsets(num);
+    for (int i=0;i<re.size();i++)
+    {
+        for (int j=0;j<re[i].size();j++)
+            cout<<re[i][j]<<" ";
+        cout<<endl;
+    }
+    return 0;
+}
diff --git a/Sum_root_to_leaf_numbers.cpp b/Sum_root_to_leaf_numbers.cpp
new file mode 100644
index 0000000..224bbc0
--- /dev/null
+++ b/Sum_root_to_leaf_numbers.cpp
@@ -0,0 +1,64 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x):val(x),left(NULL),right(NULL){}
+};
+
+void sum_cur(vector<vector<int> >& re,vector<int>& cur,TreeNode* t)
+{
+    cur.push_back(t->val);
+    if (t->left == NULL && t->right == NULL)
+    {
+        re.push_back(cur);
+        return;
+    }
+    if (t->left != NULL)
+    {
+        sum_cur(re,cur,t->left);
+        cur.pop_back();
+    }
+    if (t->right != NULL)
+    {
+        sum_cur(re,cur,t->right);
+        cur.pop_back();
+    }
+    return;
+}
+
+int sumNumbers(TreeNode* root)
+{
+    vector<vector<int> > re;
+    vector<int> cur;
+    if (root == NULL)
+        return 0;
+    sum_cur(re,cur,root);
+
+    int sum = 0;
+    for (int i = 0; i < re.size(); i++)
+    {
+        int tmpsum = re[i][0];
+        for (int j = 1; j < re[i].size(); j++)
+            {tmpsum = tmpsum * 10 + re[i][j];}
+        sum += tmpsum;
+    }
+    return sum;
+}
+
+int main()
+{
+    TreeNode* t = new TreeNode(4);
+    t->left = new TreeNode(9);
+    t->right = new TreeNode(0);
+    t->right->left = new TreeNode(2);
+    t->left->right = new TreeNode(1);
+
+    int sum = sumNumbers(t);
+    cout<<sum;
+    return 0;
+}
diff --git a/Summary Ranges.cpp b/Summary Ranges.cpp
new file mode 100644
index 0000000..0ff72f5
--- /dev/null
+++ b/Summary Ranges.cpp	
@@ -0,0 +1,64 @@
+#include<iostream>
+#include<sstream>
+#include<cstring>
+#include<vector>
+using namespace std;
+
+string inttostring(int num)
+{
+    stringstream ss;
+    string s;
+    ss<<num;
+    ss>>s;
+    return s;
+}
+
+vector<string> summaryRanges(vector<int>& nums)
+{
+    vector<string> re;
+    int len = nums.size();
+    string s;
+    int k = 0;
+
+    if (len==0)
+        return re;
+    if (len==1)
+    {
+        s = inttostring(nums[0]);
+        re.push_back(s);
+        return re;
+    }
+    s = inttostring(nums[k]);
+    while (k<len-1)
+    {
+        int cont = 0;
+        while (nums[k] == nums[k+1]-1)
+        {
+            k++;
+            cont++;
+        }
+        if (cont>0)
+            s = s + "->" + inttostring(nums[k]);
+        k++;
+        re.push_back(s);
+        if (k == len)
+            return re;
+        s = inttostring(nums[k]);
+        if (k == len-1)
+        {
+            re.push_back(s);
+            return re;
+        }
+    }
+}
+
+int main()
+{
+    vector<int> nums;
+    nums.push_back(0);
+    nums.push_back(1);nums.push_back(2);nums.push_back(4);nums.push_back(7);
+    vector<string> re = summaryRanges(nums);
+    for (int i=0;i<re.size();i++)
+        cout<<re[i]<<endl;
+    return 0;
+}
diff --git a/Symmetric Tree.cpp b/Symmetric Tree.cpp
new file mode 100644
index 0000000..137b251
--- /dev/null
+++ b/Symmetric Tree.cpp	
@@ -0,0 +1,9 @@
+#include<iostream>
+using namespace std;
+
+struct TreeNode{
+    int val;
+    TreeNode* left;
+    TreeNode* right;
+    TreeNode(int x):val(x),left(NULL),right(NULL){}
+};
diff --git a/Ugly Number.cpp b/Ugly Number.cpp
new file mode 100644
index 0000000..9f4bf60
--- /dev/null
+++ b/Ugly Number.cpp	
@@ -0,0 +1,33 @@
+#include<iostream>
+using namespace std;
+
+ bool isUgly(int num) {
+        if (num==1)
+            return true;
+        if (num==0)
+            return false;
+        while (num%2==0)
+        {
+            num/=2;
+        }
+        while (num%3==0)
+        {
+            num/=3;
+        }
+        while (num%5==0)
+        {
+            num/=5;
+        }
+        if (num==1)
+            return true;
+        else
+            return false;
+    }
+
+int main()
+{
+    int a=17;
+    bool b=isUgly(a);
+    cout<<b;
+    return 0;
+}
diff --git a/Unique Binary Search Trees.cpp b/Unique Binary Search Trees.cpp
new file mode 100644
index 0000000..205de71
--- /dev/null
+++ b/Unique Binary Search Trees.cpp	
@@ -0,0 +1,47 @@
+#include<iostream>
+using namespace std;
+
+    int cur(int sleft,int eleft,int sright,int eright)
+    {
+        int contl,contr;
+        if (sleft>eleft&&sright>eright)
+            return 1;
+        if (sleft<=eleft)
+        {
+            contl=0;
+            for (int i=sleft;i<=eleft;i++)
+            {
+                contl+=cur(sleft,i-1,i+1,eleft);
+            }
+        }
+        else
+            contl=1;
+        if (sright<=eright)
+        {
+            contr=0;
+            for (int i=sright;i<=eright;i++)
+            {
+                contr+=cur(sright,i-1,i+1,eright);
+
+            }
+        }
+        else
+            contr=1;
+        return contr*contl;
+    }
+    int numTrees(int n) {
+        int cont=0;
+        for (int i=1;i<=n;i++)
+        {
+            cont+=cur(1,i-1,i+1,n);
+        }
+        return cont;
+    }
+
+int main()
+{
+    int num;
+    num=numTrees(3);
+    cout<<num;
+    return 0;
+}
diff --git a/Unique Paths.cpp b/Unique Paths.cpp
new file mode 100644
index 0000000..834ea0f
--- /dev/null
+++ b/Unique Paths.cpp	
@@ -0,0 +1,21 @@
+#include<iostream>
+using namespace std;
+
+int uniquePaths(int m, int n) {
+        double C=1;
+        for (int i=0;i<m-1;i++)
+            {C*=m+n-2-i;C/=(i+1);}
+        int b;
+        if (C>int(C))
+            b=int(C)+1;
+        else
+            b=int(C);
+        return b;
+    }
+
+int main()
+{
+    int re=uniquePaths(56,5);
+    cout<<re;
+    return 0;
+}
diff --git a/Unique Word Abbreviation.cpp b/Unique Word Abbreviation.cpp
new file mode 100644
index 0000000..30863f0
--- /dev/null
+++ b/Unique Word Abbreviation.cpp	
@@ -0,0 +1,42 @@
+#include "pack.h"
+
+class ValidWordAbbr
+{
+public:
+    map<string,string> maplist;
+    ValidWordAbbr(vector<String> &dictionary)
+    {
+        int len = dictionary.size();
+        for (int i=0;i<len;i++)
+        {
+            string tmp = generateabbr(dictionary[i]);
+            if (maplist.count(tmp)!=0)
+                map.insert(pair<string,string>(tmp,dictionary[i]));
+        }
+    }
+    string generateabbr(string s)
+    {
+        int len = s.size();
+        string re;
+        if (len <= 2)
+            return s;
+        re.push_back(s[0]);
+        re = re + to_String(len-2);
+        re.push_back(s[len-1]);
+        return re;
+    }
+    bool isUnique(string word)
+    {
+        string tmp = generateabbr(word);
+        if (map.count(tmp))
+
+            return 0;
+        else
+            return 1;
+    }
+};
+
+int main()
+{
+
+}
diff --git a/Valid Palindrome.cpp b/Valid Palindrome.cpp
new file mode 100644
index 0000000..61b0ed0
--- /dev/null
+++ b/Valid Palindrome.cpp	
@@ -0,0 +1,42 @@
+#include<iostream>
+#include<string>
+using namespace std;
+
+bool isPalindrome(string s) {
+        int len=s.size();
+        for (int i=0;i<len;)
+        {
+            if ((s[i]>='0'&&s[i]<='9')||(s[i]>='a'&&s[i]<='z')||(s[i]>='A'&&s[i]<='Z'))
+                i++;
+            else
+            {
+                s.erase(s.begin()+i);
+                len--;
+            }
+        }
+        if (s.size()==0)
+            return true;
+
+        int p1=0,p2=s.size()-1;
+        while (p1<=p2)
+        {
+            if (s[p1]==s[p2] || (s[p1]-'a')==(s[p2]-'A') || (s[p1]-'A')==(s[p2]-'a'))
+            {
+                p1++;
+                p2--;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+int main()
+{
+    string a="Bab";
+    bool b=isPalindrome(a);
+    cout<<b;
+    return 0;
+}
diff --git a/Valid Parentheses.cpp b/Valid Parentheses.cpp
new file mode 100644
index 0000000..17624d2
--- /dev/null
+++ b/Valid Parentheses.cpp	
@@ -0,0 +1,35 @@
+#include<iostream>
+#include<vector>
+#include<string>
+using namespace std;
+
+bool isValid(string s) {
+        vector<char> judg;
+        judg.push_back(s[0]);
+
+        for (int i=1;i<s.size();i++)
+        {
+            char tmp=judg[judg.size()-1];
+            if ((tmp==char(s[i]-1)||tmp==char(s[i]-2)))
+            {
+                judg.pop_back();
+            }
+            else
+            {
+                judg.push_back(s[i]);
+            }
+        }
+        if (judg.size()==0)
+            return true;
+        else
+            return false;
+    }
+
+int main()
+{
+    vector<char> j;
+    string s="{[]}(}}";
+    bool c=isValid(s);
+    cout<<c;
+    return 0;
+}
diff --git a/Validate Binary Search Tree for yi fing.cpp b/Validate Binary Search Tree for yi fing.cpp
new file mode 100644
index 0000000..d349cdf
--- /dev/null
+++ b/Validate Binary Search Tree for yi fing.cpp	
@@ -0,0 +1,29 @@
+#include"tree.h"
+bool valid=true;
+
+void inorder(TreeNode* p,TreeNode* pre){
+    if(p==NULL) return;
+    inorder(p->left,pre);
+    if(pre!=NULL){
+        if (pre->val>=p->val){
+        valid=false;
+        return;}}
+    pre=p;
+    inorder(p->right,pre);
+}
+
+    bool isValidBST(TreeNode* root) {
+        valid=true;
+        TreeNode* pre=NULL;
+        inorder(root,pre);
+        return valid;
+    }
+
+int main()
+{
+    TreeNode* t = new TreeNode(1);
+    t->left = new TreeNode(1);
+    bool a = isValidBST(t);
+    cout<<a;
+    return 0;
+}
diff --git a/Validate Binary Search Tree.cpp b/Validate Binary Search Tree.cpp
new file mode 100644
index 0000000..d425c6c
--- /dev/null
+++ b/Validate Binary Search Tree.cpp	
@@ -0,0 +1,86 @@
+#include"tree.h"
+#include"limits.h"
+int findmax(TreeNode* root)
+{
+    queue<TreeNode*> q;
+    q.push(root);
+    int maxvalue = root->val;
+    while(!q.empty())
+    {
+        TreeNode* tmp = q.front();
+        if (tmp->val>maxvalue) maxvalue = tmp->val;
+        if (tmp->left!=NULL) q.push(tmp->left);
+        if (tmp->right!=NULL) q.push(tmp->right);
+        q.pop();
+    }
+    return maxvalue;
+}
+
+int findmin(TreeNode* root)
+{
+    queue<TreeNode*> q;
+    q.push(root);
+    int minvalue = root->val;
+    while(!q.empty())
+    {
+        TreeNode* tmp = q.front();
+        if (tmp->val<minvalue) minvalue = tmp->val;
+        if (tmp->left!=NULL) q.push(tmp->left);
+        if (tmp->right!=NULL) q.push(tmp->right);
+        q.pop();
+    }
+    return minvalue;
+}
+
+/*bool isValidBST(TreeNode* root)
+{
+    if (root==NULL) return true;
+    int leftmax,rightmin;
+    if (root->left!=NULL)
+    {
+        leftmax = findmax(root->left);
+        if (leftmax>=root->val)
+            return false;
+    }
+    if (root->right!=NULL)
+    {
+        rightmin = findmin(root->right);
+        if (rightmin<=root->val)
+            return false;
+    }
+    if (!isValidBST(root->left))
+        return false;
+    if (!isValidBST(root->right))
+        return false;
+    return true;
+}*/
+bool check(TreeNode *node, int leftVal, int rightVal)
+     {
+         if (node == NULL)
+             return true;
+
+         return leftVal < node->val && node->val < rightVal && check(node->left, leftVal, node->val) &&
+             check(node->right, node->val, rightVal);
+     }
+
+     bool isValidBST(TreeNode *root) {
+         // Start typing your C/C++ solution below
+         // DO NOT write int main() function
+         return check(root, INT_MIN, INT_MAX);
+     }
+
+int main()
+{
+    ifstream f("in.txt");
+    string s;
+    vector<string> ss;
+    while (!f.eof())
+    {
+        f>>s;
+        ss.push_back(s);
+    }
+    TreeNode* t = buildtree(ss);
+    bool out = isValidBST(t);
+    cout<<out<<endl;
+    return 0;
+}
diff --git a/Word Search.cpp b/Word Search.cpp
new file mode 100644
index 0000000..2afa171
--- /dev/null
+++ b/Word Search.cpp	
@@ -0,0 +1,37 @@
+#include "pack.h"
+
+bool exist(vector<vector<char> >& board,string word)
+{
+    bool re = false;
+    for (int i = 0;i<board.size();i++)
+    {
+        for (int j=0;j<board[0].size();j++)
+        {
+            int k = 0;
+            searchword(board,word,k,i,j,re);
+        }
+    }
+    return re;
+}
+
+void searchword(vector<vector<char> >& board,string& word,int k,int i,int j,bool& re)
+{
+    int h = board.size();
+    int w = board[0].size();
+    if (k==word.size())
+    {
+        re = true;
+        return;
+    }
+    if (board[i][j]==word[k])
+    {
+        if (i+1<h)
+            searchword(board,word,k+1,i+1,j,re);
+        if (j+1<h)
+            searchword(board,word,k+1,i,j+1,re);
+        if (i-1>=0)
+            searchword(board,word,k+1,i-1,j,re);
+        if (j-1>=0)
+            searchword(board,word,k+1,i,j-1,re);
+    }
+}
diff --git a/largestNumber.cpp b/largestNumber.cpp
new file mode 100644
index 0000000..40d4949
--- /dev/null
+++ b/largestNumber.cpp
@@ -0,0 +1,53 @@
+#include<iostream>
+#include<cstring>
+#include<vector>
+#include<cmath>
+#include<algorithm>
+#include<stdio.h>
+using namespace std;
+
+
+
+static bool cmp(const string a, const string b)
+    {
+        return (a+b)>(b+a);
+    }
+    string largestNumber(vector<int> &num) {
+        int len=num.size();
+        vector<string> vec;
+
+        if (len==0)
+            return NULL;
+
+        int zeroc=0;
+        for (int i=0;i<len;i++)
+        {
+            if (num[i]==0)
+                zeroc++;
+            char str[0];
+            sprintf(str,"%d",num[i]);
+            vec.push_back(str);
+        }
+        if (len==1)
+            return vec[0];
+        sort(vec.begin(),vec.end(),cmp);
+        string result;
+        for (int i=0;i<len;i++)
+        {
+            result+=vec[i];
+        }
+        return result;
+    }
+
+int main()
+{
+    vector<int> a;
+    a.push_back(3);
+    a.push_back(1);
+    a.push_back(2);
+    a.push_back(5);
+
+    sort(a);
+
+    return 0;
+}
diff --git a/link.cpp b/link.cpp
new file mode 100644
index 0000000..900fe8c
--- /dev/null
+++ b/link.cpp
@@ -0,0 +1,66 @@
+#include<iostream>
+using namespace std;
+
+struct ListNode {
+     int val;
+     ListNode *next;
+     ListNode(int x) : val(x), next(NULL) {}
+ };
+
+ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
+        ListNode* p1=l1;
+        ListNode* p2=l2;
+
+        if (p1==NULL && p2==NULL)
+        {
+            return NULL;
+        }
+        else if (p1==NULL && p2!=NULL)
+        {
+            return p2;
+        }
+        else if (p1!=NULL && p2==NULL)
+        {
+            return p1;
+        }
+
+        if (p2->val<p1->val)
+        {
+            ListNode* tt=p2->next;
+            p2->next=p1;
+            p1=p2;
+            p2=tt;
+        }
+        l1=p1;
+
+        while (p2!=NULL)
+        {
+            if (p1->next==NULL)
+            {
+                p1->next=p2;
+                return l1;
+            }
+            if (p1->val<=p2->val && p1->next->val>p2->val)
+            {
+                ListNode* tmp=p2->next;
+                p2->next=p1->next;
+                p1->next=p2;
+                p2=tmp;
+            }
+            p1=p1->next;
+        }
+        return l1;
+    }
+
+    int main()
+    {
+        ListNode* l1=new ListNode(5);
+        ListNode* l2=new ListNode(1);
+        l2->next=new ListNode(2);
+        l2->next->next=new ListNode(4);
+        ListNode* l=mergeTwoLists(l1,l2);
+        while (l!=NULL){
+        cout<<l->val<<endl;
+        l=l->next;}
+        return 0;
+    }
diff --git a/map.cpp b/map.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/mergesort.cpp b/mergesort.cpp
new file mode 100644
index 0000000..f5ef14a
--- /dev/null
+++ b/mergesort.cpp
@@ -0,0 +1,42 @@
+#include<iostream>
+using namespace std;
+
+void merger(int a[],int low,int mid,int high)
+{
+    int tmp[high-low+1];
+    int i=low, j=mid, k=0;
+
+    while (i<mid && j<=high)
+    {
+        if (a[i]<a[j])
+            tmp[k++]=a[i++];
+        else
+            tmp[k++]=a[j++];
+    }
+    while (i<mid)
+        tmp[k++]=a[i++];
+    while (j<=high)
+        tmp[k++]=a[j++];
+    for (i=0,k=low;k<=high;)
+        a[k++]=tmp[i++];
+    delete[] tmp;
+}
+
+void mergesort(int a[],int low,int high)
+{
+    if (high==low)
+        return;
+    int mid=(high+low)/2;
+    mergesort(a,mid+1,high);
+    mergesort(a,low,mid);
+    merger(a,low,mid+1,high);
+}
+
+int main()
+{
+    int a[9]={2,1,4,3,7,5,8,6,9};
+    mergesort(a,0,8);
+    for (int i=0;i<9;i++)
+        cout<<a[i]<<endl;
+    return 0;
+}
diff --git a/multiply.cpp b/multiply.cpp
new file mode 100644
index 0000000..5789721
--- /dev/null
+++ b/multiply.cpp
@@ -0,0 +1,167 @@
+#include<iostream>
+#include<cstring>
+using namespace std;
+
+//string multiply(string num1, string num2) {
+//        int len1=num1.size();
+//        int len2=num2.size();
+//
+//        int len=len1+len2;
+//        int s[len];
+//
+//        for (int i=0;i<len;i++)
+//            s[i]=0;
+//        for (int m=0;m<len1;m++)
+//            for (int n=0;n<len2;n++)
+//            {
+//                int tmp=(num1[len1-1-m]-'0')*(num2[len2-1-n]-'0');
+//                if (tmp>=10)
+//                {
+//                    int k=m+n+1;
+//                    int tm=tmp-tmp/10*10;
+//                    int tm2=tmp/10;
+//                    if (s[m+n]+tm>=10)
+//                    {
+//                        s[m+n]=s[m+n]+tm-10;
+//                        tm2++;
+//                    }
+//                    else
+//                    {
+//                        s[m+n]+=tm;
+//                    }
+//                    if (s[m+n+1]+tm2>=10)
+//                    {
+//
+//                        s[m+n+1]=s[m+n+1]+tm2-10;
+//                        while (s[k+1]==9 && k+1<len)
+//                        {
+//                            s[k+1]=0;
+//                            k++;
+//                        }
+//                        s[k+1]++;
+//                    }
+//                    else
+//                    {
+//                        s[m+n+1]+=tm2;
+//                    }
+//                }
+//                else
+//                {
+//                    if (s[m+n]+tmp>=10)
+//                    {
+//                        int k=m+n;
+//                        s[m+n]=s[m+n]+tmp-10;
+//                        while (s[k+1]==9 && k+1<len)
+//                        {
+//                            s[k+1]=0;
+//                            k++;
+//                        }
+//                        s[k+1]++;
+//                    }
+//                    else
+//                    {
+//                        s[m+n]+=tmp;
+//                    }
+//                }
+//            }
+//        int relen;
+//        if (s[len-1]==0)
+//        {
+//            relen=len-1;
+//        }
+//        else
+//        {
+//            relen=len;
+//        }
+//        string re;
+//        for (int i=0;i<relen;i++)
+//            re.push_back('0'+s[relen-1-i]);
+//        return re;
+//    }
+string addTwoString(string num1, string num2)
+    {
+        int len1 = num1.size()-1;
+        int len2 = num2.size()-1;
+        bool carry = false;
+        string res = "";
+        while(len1 >=0 && len2 >=0)
+        {
+            int a = num1[len1]-'0';
+            int b = num2[len2]-'0';
+            int c = a+b;
+            if(carry)
+            {
+                c+=1;
+                carry=false;
+            }
+            if(c>9)
+            {
+                carry=true;
+                c -= 10;
+            }
+            char tmp = '0'+c;
+            res = tmp + res;
+            len1--;
+            len2--;
+        }
+        string pre="";
+        if(len1>=0)
+            pre=num1.substr(0,len1+1);
+        else if(len2>=0)
+            pre=num2.substr(0,len2+1);
+        if(carry){
+            int sz=pre.size()-1;
+            while(sz>=0 && pre[sz]=='9')
+            {
+                pre[sz]='0';
+                sz--;
+            }
+            if(sz<0)
+                pre='1'+pre;
+            else
+                pre[sz]+=1;
+        }
+        res = pre+res;
+        return res;
+    }
+    string multiplyOneBit(string num1, int num2)
+    {
+        int len = num1.size();
+        int* res = new int[len+1];
+        memset(res,0,sizeof(int)*(len+1));
+
+        for(int i=len;i>0;i--)
+        {
+            res[i] += (num1[i-1]-'0')*num2;
+            res[i-1] += res[i]/10;
+            res[i] %= 10;
+        }
+        string ss="";
+        for(int i=0; i<=len; i++)
+            ss += char('0' + res[i]);
+        return ss;
+    }
+    string multiply(string num1, string num2) {
+        // Note: The Solution object is instantiated only once.
+        if(num1=="0" || num2=="0") return "0";
+        int l1 = num1.length(), l2 = num2.length();
+        string res="";
+        for(int i =0; i< l2;i++)
+        {
+            res+='0';
+            string tmp = multiplyOneBit(num1,num2[i]-'0');
+            res = addTwoString(res,tmp);
+        }
+        res = res[0]=='0'? res.substr(1):res;
+        return res;
+    }
+
+int main()
+{
+
+    string s1="7950730684116360645035469888615500796";
+    string s2="841979251126152713721537069775651940998000937338602066982";
+    string s=multiply(s1,s2);
+    cout<<"a"+'b';
+    return 0;
+}
diff --git a/pack.h b/pack.h
new file mode 100644
index 0000000..44ba6a6
--- /dev/null
+++ b/pack.h
@@ -0,0 +1,16 @@
+#ifndef PACK_H_INCLUDED
+#define PACK_H_INCLUDED
+
+#include<iostream>
+#include<algorithm>
+#include<queue>
+#include<vector>
+#include<stack>
+#include<math.h>
+#include<string>
+#include<fstream>
+#include<sstream>
+#include<map>
+using namespace std;
+
+#endif // PACK_H_INCLUDED
diff --git a/palindrome.cpp b/palindrome.cpp
new file mode 100644
index 0000000..3c13d78
--- /dev/null
+++ b/palindrome.cpp
@@ -0,0 +1,56 @@
+#include<iostream>
+#include<cstring>
+using namespace std;
+
+string longestPalindrome(string s) {
+    int len=s.size();
+    int relen=0;
+    string re="";
+    if (len==1)
+    return s;
+
+    for (int i=1;i<len;i++)
+    {
+        if (s[i]==s[i-1])
+        {
+            int j=i;
+            while (2*i-1-j>=0 && j<len)
+            {
+                if (s[j]!=s[2*i-1-j])
+                    break;
+                j++;
+            }
+            if ((j-i)*2>relen)
+            {
+                re.assign(s,2*i-j,(j-i)*2);
+                relen=(j-i)*2;
+            }
+        }
+
+            if (s[i-1]==s[i+1])
+            {
+                int j=i+1;
+                while (j<len && 2*i-j>0)
+                {
+                    if (s[j]!=s[2*i-j])
+                        break;
+                    j++;cout<<j;
+                }
+                if ((j-i)*2-1>relen)
+                {
+                    re.assign(s,2*i-j+1,(j-i)*2-1);
+                    relen=(j-i)*2-1;
+                }
+            }
+
+    }
+    return re;
+    }
+
+int main()
+{
+    string s="aaa";
+    string re=longestPalindrome(s);
+    cout<<re;
+    return 0;
+}
diff --git a/sort.cpp b/sort.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/sortcolor.cpp b/sortcolor.cpp
new file mode 100644
index 0000000..d4c1101
--- /dev/null
+++ b/sortcolor.cpp
@@ -0,0 +1,34 @@
+#include<iostream>
+#include<vector>
+
+using namespace std;
+
+void sortColors(vector<int>& nums) {
+        int len=nums.size();
+
+        for (int i=0;i<len,i++)
+        {
+            if (nums[i]!=0)
+                continue;
+            else
+            {
+                int k=i-1;
+                while (k>0 && nums[k]!=0)
+                {
+                    k--;
+                }
+                int tmp=nums[k+1];
+                nums[k+1]=nums[i];
+                nums[i]=tmp;
+            }
+        }
+    }
+
+int main()
+{
+    vector<int> a;
+    a.push_back(9);
+    a[0]=8;
+    cout<<a[0];
+    return 0;
+}
diff --git a/strin.cpp b/strin.cpp
new file mode 100644
index 0000000..015c969
--- /dev/null
+++ b/strin.cpp
@@ -0,0 +1,11 @@
+#include<iostream>
+#include<cstring>
+#include<vector>
+using namespace std;
+
+int main()
+{
+    vector<string> a;
+    cout<<'1'-48;
+    return 0;
+}
diff --git a/string.cpp b/string.cpp
new file mode 100644
index 0000000..dc33842
--- /dev/null
+++ b/string.cpp
@@ -0,0 +1,56 @@
+#include<iostream>
+#include<string>
+using namespace std;
+
+struct Node
+{
+    int elem;
+    int loca;
+    Node* next;
+    Node(int e,int l):elem(e),loca(l),next(NULL){}
+};
+
+int lengthOfLongestSubstring(string s)
+{
+    Node* ele[26];
+    Node* p[26];
+    Node* temp[26];
+    int len=s.size();
+
+    for (int i=0;i<26;i++)
+    {
+        ele[i]=new Node(i+97,0);
+        p[i]=ele[i]->next;
+        temp[i]=ele[i]->next;
+    }
+
+    for (int i=0;i<len;i++)
+    {
+        p[int(s[i])-97]=new Node(int(s[i]),i);
+        p[int(s[i])-97]=p[int(s[i])-97]->next;
+    }
+
+    int dif=len;
+    for (int i=0;i<26;i++)
+    {
+        while (temp[i]->next!=NULL)
+        {
+            int tmp=temp[i+1]->loca-temp[i]->loca;
+            if (tmp<dif)
+            {
+                dif=tmp;
+            }
+            temp[i]=temp[i]->next;
+        }
+    }
+    return dif;
+
+}
+
+int main()
+{
+    string s="abcabcbb";
+    int p=lengthOfLongestSubstring(s);
+    cout<<p;
+    return 0;
+}
diff --git a/try.cpp b/try.cpp
new file mode 100644
index 0000000..0bccb2a
--- /dev/null
+++ b/try.cpp
@@ -0,0 +1,2 @@
+#include<iostream>
+#include
diff --git a/vector.cpp b/vector.cpp
new file mode 100644
index 0000000..4a3a0bc
--- /dev/null
+++ b/vector.cpp
@@ -0,0 +1,70 @@
+#include<iostream>
+#include<vector>
+#include<cstring>
+using namespace std;
+
+void sxun(vector<string> &out, string digits, int arr[], int loca)
+{
+    vector<string> p;
+    int pn[8]={3,3,3,3,3,4,3,4};
+    p.push_back("abc");
+    p.push_back("def");
+    p.push_back("ghi");
+    p.push_back("jkl");
+    p.push_back("mno");
+    p.push_back("pqrs");
+    p.push_back("tuv");
+    p.push_back("wxyz");
+    int len=array.size();
+    char* s;
+    if (loca==len-1)
+    {
+        for (int j=0;j<arr[i];j++)
+        {
+            for (int i=0;i<len;i++)
+            {
+                s[i]=p[digits[i]-50][j];
+            }
+            out.push_back(s);
+        }
+    }
+
+    for (int j=0;j<arr[i];j++)
+    {
+        sxun(out,digits,arr,loca+1);
+    }
+}
+
+vector<string> letterCombinations(string digits)
+{
+    vector<string> p;
+    vector<string> out;
+    int len=digits.size();
+    int nums[len];
+
+    int pn[8]={3,3,3,3,3,4,3,4};
+    p.push_back("abc");
+    p.push_back("def");
+    p.push_back("ghi");
+    p.push_back("jkl");
+    p.push_back("mno");
+    p.push_back("pqrs");
+    p.push_back("tuv");
+    p.push_back("wxyz");
+
+    for (int i=0;i<len;i++)
+    {
+        nums[i]=pn[digits[i]-50];
+    }
+
+    for (int j=0;j<nums[0];j++)
+    {
+        sxun(out,digits,nums,0,1);
+    }
+    return out;
+}
+
+int main()
+{
+    return 0;
+}
diff --git a/windw.cpp b/windw.cpp
new file mode 100644
index 0000000..c2290a1
--- /dev/null
+++ b/windw.cpp
@@ -0,0 +1,67 @@
+#include<iostream>
+#include<vector>
+#include<math.h>
+#include<algorithm>
+using namespace std;
+
+vector<int> maxSlidingWindow(vector<int>& nums, int k) {
+        vector<int> out;
+        vector<int> win;
+
+        if (nums.size()==0)
+            return win;
+
+        int tmpmax=nums[0];
+        int loca;
+
+        for (int i=0;i<k;i++)
+        {
+            win.push_back(nums[i]);
+            if (nums[i]>tmpmax)
+            {
+                tmpmax=nums[i];
+                loca=i;
+            }
+        }
+
+        out.push_back(tmpmax);
+
+        for (int i=1;i<nums.size()-k+1;i++)
+        {
+            if (nums[i+k-1]>tmpmax)
+            {
+                tmpmax=nums[i+k-1];
+                loca=i+k-1;
+                out.push_back(tmpmax);
+                continue;
+            }
+            else if (nums[i+k-1]<tmpmax)
+            {
+                if (tmpmax==nums[i-1])
+                {
+                    tmpmax=nums[i];
+                    for (int j=0;j<k;j++)
+                    {
+                        if (nums[i+j]>tmpmax)
+                        {
+                            tmpmax=nums[i+j];
+                            loca=i+j;
+                        }
+                    }
+                    out.push_back(tmpmax);
+                }
+                else
+                {
+                    out.push_back(tmpmax);
+                }
+            }
+        }
+        return out;
+    }
+
+int main()
+{
+    vector<int> a;
+    maxSlidingWindow(a,0);
+    return 0;
+}