├── Level2
    ├── Excel Column Number.cpp
    ├── Grid Unique Paths.cpp
    ├── Kth Row of Pascal's Triangle.cpp
    ├── Largest Number.cpp
    └── Rearrange Array.cpp
├── Level3
    ├── Allocate Books.cpp
    ├── Atoi.cpp
    └── NumRange.cpp
├── Level4
    └── NextGreater.cpp
├── Level5
    ├── 2 Sum.cpp
    ├── All Unique Permutations.cpp
    ├── Anagrams.cpp
    ├── Generate all Parentheses II.cpp
    ├── Gray code.cpp
    ├── Letter Phone.cpp
    ├── Longest Consecutive Sequence.cpp
    ├── Subset II.cpp
    ├── Subset.cpp
    └── Window String.cpp
├── Level6
    ├── Distinct Numbers in Window.cpp
    ├── Inversions.cpp
    └── Shortest Unique Prefix.cpp
├── Level7
    ├── Assign Mice to Holes.cpp
    ├── Best Time to Buy and Sell Stocks II.cpp
    ├── Bulbs.cpp
    ├── Coins in a Line.cpp
    ├── Highest Product.cpp
    ├── Interleaving Strings.cpp
    ├── Longest Increasing Subsequence.cpp
    ├── Longest valid Parentheses.cpp
    ├── Majority Element.cpp
    ├── Max Rectangle in Binary Matrix.cpp
    ├── Max Sum Without Adjacent Elements.cpp
    ├── Min Sum Path in Matrix.cpp
    ├── Min Sum Path in Triangle.cpp
    ├── Palindrome Partitioning II.cpp
    ├── Repeating Sub-Sequence.cpp
    ├── Seats.cpp
    ├── Stairs.cpp
    ├── Unique Binary Search Trees II.cpp
    ├── Unique Paths in a Grid.cpp
    ├── Ways to Decode.cpp
    └── Word Break II.cpp
├── Level8
    ├── Black Shapes.cpp
    ├── Capture Regions on Board.cpp
    ├── Knight On Chess Board.cpp
    ├── Word Ladder I.cpp
    └── Word Search Board.cpp
└── README.md


/Level2/Excel Column Number.cpp:
--------------------------------------------------------------------------------
1 | int Solution::titleToNumber(string A) {
2 |     int r=0;
3 |     for(int i=A.size()-1,j=0;i>=0;j++,i--){
4 |         r+=(pow(26,j)*(A[i]-'A'+1));
5 |     }
6 |     return r;
7 | }
8 | 


--------------------------------------------------------------------------------
/Level2/Grid Unique Paths.cpp:
--------------------------------------------------------------------------------
 1 | int memo[500][500];
 2 | int dp(int i,int j,int A,int B){
 3 |     if(i==A&&j==B)return 1;
 4 |     if(i>A||j>B)return 0;
 5 |     if(memo[i][j])return memo[i][j];
 6 |     return memo[i][j]=dp(i+1,j,A,B)+dp(i,j+1,A,B);
 7 | }
 8 | int Solution::uniquePaths(int A, int B) {
 9 |     memset(memo,0,sizeof(memo));
10 |     A--;
11 |     B--;
12 |     return dp(0,0,A,B);
13 | }
14 | 


--------------------------------------------------------------------------------
/Level2/Kth Row of Pascal's Triangle.cpp:
--------------------------------------------------------------------------------
 1 | long long m[102][102];
 2 | bool ok=false;
 3 | void pascal(){
 4 |     if(ok)return;
 5 |     m[1][1]=1;
 6 |     m[2][1]=1;
 7 |     m[2][2]=1;
 8 |     for(int i=3;i<=100;i++){
 9 |         m[i][1]=1;
10 |         m[i][i]=1;
11 |         for(int j=2;j<i;j++){
12 |             m[i][j]=m[i-1][j]+m[i-1][j-1];
13 |         }
14 |     }
15 |     ok=true;
16 | }
17 | vector<int> Solution::getRow(int n) {
18 |     pascal();
19 |     n++;
20 |     vector<int>v;
21 |     for(int i=1;i<=n;i++){
22 |         v.push_back(m[n][i]);
23 |     }
24 |     return v;
25 | }
26 | 


--------------------------------------------------------------------------------
/Level2/Largest Number.cpp:
--------------------------------------------------------------------------------
 1 | string wrd(int x){
 2 |     string r="";
 3 |     while(x>0){
 4 |         r+=((x%10)+'0');
 5 |         x/=10;
 6 |     }
 7 | 	reverse(r.begin(),r.end());
 8 |     return r;
 9 | }
10 | bool cmp(string a,string b){
11 | 	return a+b>b+a;
12 | }
13 | string Solution::largestNumber(const vector<int> &v) {
14 |     string r[v.size()];
15 |     for(int i=0;i<v.size();i++){
16 |     	r[i]="";
17 |         r[i]+=wrd(v[i]);
18 |     }
19 |     sort(r,r+v.size(),cmp);
20 |     string re="";
21 |     for(int i=0;i<v.size();i++)re+=r[i];
22 |     if(re=="")re+='0';
23 |     return re;
24 | }
25 | 


--------------------------------------------------------------------------------
/Level2/Rearrange Array.cpp:
--------------------------------------------------------------------------------
1 | void Solution::arrange(vector<int> &A) {
2 |     int n=A.size();
3 |     for(int i=0;i<A.size();i++){
4 |         A[i]+=(A[A[i]]%n)*n;
5 |     }
6 |     for(int i=0;i<n;i++)A[i]/=n;
7 | }
8 | 


--------------------------------------------------------------------------------
/Level3/Allocate Books.cpp:
--------------------------------------------------------------------------------
 1 | bool ok(int k,vector<int>v,int n,int x){
 2 |     int _max_ele = *max_element(v.begin(), v.end());
 3 |             if(_max_ele > k)
 4 |                     return false; 
 5 |     int s=0,c=0;
 6 |     for(int i=0;i<n;){
 7 |         s+=v[i];
 8 |         if(s>k){
 9 |             c++;
10 |             s=0;
11 |         }
12 |         else i++;
13 |     }
14 |     if(c<x)return true;
15 |     return false;
16 | }
17 | int Solution::books(vector<int> &v, int x) {
18 |     int n=v.size(),fin=0,in=0,r=(1<<30);
19 |     if(x>n)return -1;
20 |     for(int i=0;i<n;i++){
21 |         fin+=v[i];
22 |     }
23 |     while(in<=fin){
24 |         int mid=(in+fin)/2;
25 |         if(ok(mid,v,n,x)){
26 |             r=min(r,mid);
27 |             fin=mid-1;
28 |         }
29 |         else in=mid+1;
30 |     }
31 |     return r;
32 | }
33 | 


--------------------------------------------------------------------------------
/Level3/Atoi.cpp:
--------------------------------------------------------------------------------
 1 | int Solution::atoi(const string &A) {
 2 |     long long r=0,uso=1;
 3 |     bool ok=false;
 4 |     stack<char>pila;
 5 |     for(int i=0;i<A.size();i++){
 6 |         if(A[i]>=48&&A[i]<=58)pila.push(A[i]);
 7 |         if(A[i]==' '&&!pila.empty()||A[i]==' '&&ok)break;
 8 |         if(pila.empty()&&A[i]=='-'){
 9 |         	uso=-1;
10 |         	ok=true;
11 |         	continue;
12 | 		}
13 | 		if(pila.empty()&&A[i]=='+'){
14 |         	ok=true;
15 |         	continue;
16 | 		}
17 | 		if(!(A[i]>=48&&A[i]<=58)&&A[i]!=' ')break;
18 |     }
19 |     for(long long i=1;!pila.empty();i*=10){
20 |         r+=(long long)((pila.top()-'0')*(i));
21 |         if(r>=INT_MAX&&uso==1)return INT_MAX;
22 |         if(r>=INT_MAX&&uso==-1)return INT_MIN;
23 |         pila.pop();
24 |     }
25 |     r*=uso;
26 |     return r;
27 | }
28 | 


--------------------------------------------------------------------------------
/Level3/NumRange.cpp:
--------------------------------------------------------------------------------
 1 | long long s[900002],a,b,x;
 2 | bool check(int z){
 3 |     if(z>=a&&z<=b)return true;
 4 |     return false;
 5 | }
 6 | int bs(int in,int fin){
 7 |     if(in==fin||fin==0)return in;
 8 |     int mid=(in+fin)/2;
 9 |     if(s[mid]-x>b)return bs(in,mid);
10 |     else return bs(mid+1,fin);
11 | }
12 | int Solution::numRange(vector<int> &A, int B, int C) {
13 |     if(A.size()==0)return 0;
14 |     long long n=A.size(),r=0;
15 |     a=B;
16 |     b=C;
17 |     s[0]=A[0];
18 |     for(int i=1;i<n;i++){
19 |         s[i]=A[i]+s[i-1];
20 |     }
21 |     for(int i=0;i<n;i++){
22 |         if(i==0)x=0;
23 |         else x=s[i-1];
24 |         if(A[i]>b)continue;
25 |         int pos=bs(i,n-1);
26 |         while(pos>=0&&s[pos]-x>b)pos--;
27 |         if(pos<i||!check(s[pos]-x))continue;
28 |         while(pos>=0&&check(s[pos]-x)){
29 |         	r++;
30 |         	pos--;
31 | 		}
32 |     }
33 |     return r;
34 | }
35 | 


--------------------------------------------------------------------------------
/Level4/NextGreater.cpp:
--------------------------------------------------------------------------------
 1 | vector<int> Solution::nextGreater(vector<int> &A) {
 2 |     stack<int>pila;
 3 |     pila.push(0);
 4 |     vector<int>r;
 5 |     r.push_back(-1);
 6 |     for(int i=1;i<A.size();i++){
 7 |         r.push_back(-1);
 8 |         int j=A[i];
 9 |         while(!pila.empty()&&j>A[pila.top()]){
10 |             r[pila.top()]=j;
11 |             pila.pop();
12 |         }
13 |         pila.push(i);
14 |     }
15 |     return r;
16 | }
17 | 


--------------------------------------------------------------------------------
/Level5/2 Sum.cpp:
--------------------------------------------------------------------------------
 1 | vector<int> Solution::twoSum(const vector<int> &v, int B) {
 2 |     map<int,int>memo;
 3 |     vector<int>r;
 4 |     int a=0,b=(1<<30);
 5 |     for(int i=0;i<v.size();i++){
 6 |         if(memo[v[i]]&&v[i]*2==B){
 7 |             a=memo[v[i]];
 8 |             b=min(b,i+1);
 9 |         }
10 |         if(!memo[v[i]])memo[v[i]]=i+1;
11 |     }
12 |     for(int i=0;i<v.size();i++){
13 |         if(memo.find(B-v[i])!=memo.end()){
14 |             if(memo[B-v[i]]<b&&i+1<memo[B-v[i]]){
15 |                 b=memo[B-v[i]];
16 |                 a=i+1;
17 |             }
18 |             else if(memo[B-v[i]]==b&&(i+1<a&&i+1<memo[B-v[i]]||a==0)){
19 |                 b=memo[B-v[i]];
20 |                 a=i+1;
21 |             }
22 |         }
23 |     }
24 |     if(a==0)return r;
25 |     r.push_back(a);
26 |     r.push_back(b);
27 |     return r;
28 | }
29 | 


--------------------------------------------------------------------------------
/Level5/All Unique Permutations.cpp:
--------------------------------------------------------------------------------
 1 | vector<vector<int> >r;
 2 | vector<int>v;
 3 | bool memo[15];
 4 | map<vector<int>,bool>mapita;
 5 | void solve(int i,vector<int>uso){
 6 |     if(i==v.size()&&!mapita[uso]){
 7 |         mapita[uso]=true;
 8 |         r.push_back(uso);
 9 |         return;
10 |     }
11 |     for(int j=0;j<v.size();j++){
12 |         if(!memo[j]){
13 |             memo[j]=true;
14 |             uso.push_back(v[j]);
15 |             solve(i+1,uso);
16 |             uso.pop_back();
17 |             memo[j]=false;
18 |         }
19 |     }
20 | }
21 | vector<vector<int> > Solution::permute(vector<int> &A) {
22 |     v=A;
23 |     r.clear();
24 |     mapita.clear();
25 |     vector<int>uso;
26 |     solve(0,uso);
27 |     return r;
28 | }
29 | 


--------------------------------------------------------------------------------
/Level5/Anagrams.cpp:
--------------------------------------------------------------------------------
 1 | vector<vector<int> > Solution::anagrams(const vector<string> &v) {
 2 |     vector<vector<int> >r;
 3 |     map<string,vector<int> >memo;
 4 |     for(int i=0;i<v.size();i++){
 5 |         string uso=v[i];
 6 |         sort(uso.begin(),uso.end());
 7 |         memo[uso].push_back((i+1));
 8 |     }
 9 |     for(map<string,vector<int> >::iterator it=memo.begin();it!=memo.end();it++){
10 |         r.push_back(it->second);
11 |     }
12 |     sort(r.begin(),r.end());
13 |     return r;
14 | }
15 | 


--------------------------------------------------------------------------------
/Level5/Generate all Parentheses II.cpp:
--------------------------------------------------------------------------------
 1 | vector<string>r;
 2 | bool check(string v){
 3 |     stack<int>pila;
 4 |     for(int i=0;i<v.size();i++){
 5 |         if(v[i]=='(')pila.push(0);
 6 |         else {
 7 |             if(pila.empty())return false;
 8 |             pila.pop();
 9 |         }
10 |     }
11 |     if(pila.empty())return true;
12 |     return false;
13 | }
14 | void solve(int n,string v){
15 |     if(n==0){
16 |         if(check(v))r.push_back(v);
17 |         return;
18 |     }
19 |     solve(n-1,v+'(');
20 |     solve(n-1,v+')');
21 | }
22 | vector<string> Solution::generateParenthesis(int A) {
23 |     r.clear();
24 |     if(A==0)return r;
25 |     solve(A*2,"");
26 |     sort(r.begin(),r.end());
27 |     return r;
28 | }
29 | 


--------------------------------------------------------------------------------
/Level5/Gray code.cpp:
--------------------------------------------------------------------------------
 1 | vector<int> Solution::grayCode(int A) {
 2 |     vector<vector<int> >v,v2;
 3 |     vector<int>a,b,r;
 4 |     a.push_back(0);
 5 |     b.push_back(1);
 6 |     v.push_back(a);
 7 |     v.push_back(b);
 8 |     for(int i=1;i<A;i++){
 9 |     	v2=v;
10 |     	reverse(v2.begin(),v2.end());
11 |     	for(int j=0;j<v.size();j++){
12 |     		v[j].insert(v[j].begin(),0);
13 | 		}
14 | 		for(int j=0;j<v2.size();j++){
15 |     		v2[j].insert(v2[j].begin(),1);
16 | 		}
17 | 		for(int j=0;j<v2.size();j++){
18 |     		v.push_back(v2[j]);
19 | 		}
20 | 	}
21 | 	for(int i=0;i<v.size();i++){
22 | 		int s=0;
23 | 		for(int j=v[i].size()-1,k=0;j>=0;j--,k++){
24 | 			if(v[i][j]==1)s+=(pow(2,k));
25 | 		}
26 | 		r.push_back(s);
27 | 	}
28 | 	return r;
29 | }
30 | 


--------------------------------------------------------------------------------
/Level5/Letter Phone.cpp:
--------------------------------------------------------------------------------
 1 | vector<string>r;
 2 | vector<string >m;
 3 | string v;
 4 | void ini(){
 5 |     string uso="0"; m.push_back(uso);uso="1";m.push_back(uso);
 6 |     uso="abc";m.push_back(uso);uso="def";m.push_back(uso);
 7 |     uso="ghi";m.push_back(uso);uso="jkl";m.push_back(uso);uso="mno";
 8 |     m.push_back(uso);uso="pqrs";m.push_back(uso);uso="tuv";m.push_back(uso);
 9 |     uso="wxyz";m.push_back(uso);
10 | }
11 | void solve(int i,string uso){
12 |     if(i==v.size()){
13 |         r.push_back(uso);
14 |         return;
15 |     }
16 |     for(int j=0;j<m[(v[i]-'0')].size();j++){
17 |         solve(i+1,uso+m[(v[i]-'0')][j]);
18 |     }
19 | }
20 | vector<string> Solution::letterCombinations(string A) {
21 |     r.clear();
22 |     m.clear();
23 |     ini();
24 |     v=A;
25 |     solve(0,"");
26 |     sort(r.begin(),r.end());
27 |     return r;
28 | }
29 | 


--------------------------------------------------------------------------------
/Level5/Longest Consecutive Sequence.cpp:
--------------------------------------------------------------------------------
 1 | int Solution::longestConsecutive(const vector<int> &A) {
 2 |     int res=1,r=1,a=0;
 3 |     vector<int>v=A;
 4 |     sort(v.begin(),v.end());
 5 |     a=v[0];
 6 |     for(int i=1;i<v.size();i++){
 7 |         if(v[i]-a==1){
 8 |             r++;
 9 |             res=max(res,r);
10 |         }
11 |         else if(v[i]!=a) r=1;
12 |         a=v[i];
13 |     }
14 |     return res;
15 | }
16 | 


--------------------------------------------------------------------------------
/Level5/Subset II.cpp:
--------------------------------------------------------------------------------
 1 | vector<int>v;
 2 | map<vector<int>,bool>memo;
 3 | vector<vector<int> > r;
 4 | void solve(int i,vector<int>uso){
 5 |     if(i>=v.size()){
 6 |         if(!memo[uso])r.push_back(uso);
 7 |         memo[uso]=true;
 8 |         return;
 9 |     }
10 |     uso.push_back(v[i]);
11 |     solve(i+1,uso);
12 |     uso.pop_back();
13 |     solve(i+1,uso);
14 | }
15 | vector<vector<int> > Solution::subsetsWithDup(vector<int> &A) {
16 |     v=A;
17 |     memo.clear();
18 |     r.clear();
19 |     sort(v.begin(),v.end());
20 |     vector<int>uso;
21 |     solve(0,uso);
22 |     sort(r.begin(),r.end());
23 |     return r;
24 | }
25 | 


--------------------------------------------------------------------------------
/Level5/Subset.cpp:
--------------------------------------------------------------------------------
 1 | vector<int>v;
 2 | vector<vector<int> > r;
 3 | void solve(int i,vector<int>uso){
 4 |     if(i>=v.size()){
 5 |         r.push_back(uso);
 6 |         return;
 7 |     }
 8 |     uso.push_back(v[i]);
 9 |     solve(i+1,uso);
10 |     uso.pop_back();
11 |     solve(i+1,uso);
12 | }
13 | vector<vector<int> > Solution::subsets(vector<int> &A) {
14 |     v=A;
15 |     r.clear();
16 |     sort(v.begin(),v.end());
17 |     vector<int>uso;
18 |     solve(0,uso);
19 |     sort(r.begin(),r.end());
20 |     return r;
21 | }
22 | 


--------------------------------------------------------------------------------
/Level5/Window String.cpp:
--------------------------------------------------------------------------------
 1 | string Solution::minWindow(string S, string T) {
 2 |     int in=0,fin=0,c=0,a=0,r=0;
 3 |     unordered_map<char,int>memo;
 4 |     for(int i=0;i<T.size();i++){
 5 |         if(memo.find(T[i])==memo.end()){
 6 |             memo[T[i]]=1;
 7 |         }
 8 |         else memo[T[i]]++;
 9 |     }
10 |     for(int i=0;i<S.size();i++,fin++){
11 |         if(memo.find(S[i])==memo.end())continue;
12 |         memo[S[fin]]--;
13 |         if(memo[S[fin]]>=0)c++;
14 |         if(c==T.size()){
15 |             while(memo.find(S[in])==memo.end()||memo[S[in]]<0){
16 |                 if(memo.find(S[in])!=memo.end())memo[S[in]]++;
17 |                 in++;
18 |             }
19 |             if(r==0||fin-in+1<r){
20 |                 r=fin-in+1;
21 |                 a=in;
22 |             }
23 |         }
24 |     }
25 |     return S.substr(a,r);
26 | }
27 | 


--------------------------------------------------------------------------------
/Level6/Distinct Numbers in Window.cpp:
--------------------------------------------------------------------------------
 1 | vector<int> Solution::dNums(vector<int> &A, int k) {
 2 |     int in=0,fin=k-1,r=0;
 3 |     vector<int>res;
 4 |     map<int,int>memo;
 5 |     for(int i=0;i<A.size();i++){
 6 |         if(i<k-1){
 7 |             if(memo[A[i]]<=0){
 8 |             	memo[A[i]]=1;
 9 |             	r++;
10 | 			}
11 |             else memo[A[i]]++;
12 |         }
13 |         else {
14 |             if(memo[A[i]]<=0)r++;
15 |             memo[A[i]]++;
16 |             res.push_back(r);
17 |             if(memo[A[in]]==1)r--;
18 |             memo[A[in]]--;
19 |             in++;
20 |         }
21 |     }
22 |     return res;
23 | }
24 | 


--------------------------------------------------------------------------------
/Level6/Inversions.cpp:
--------------------------------------------------------------------------------
 1 | #define ll long long
 2 | #define MAX 100002
 3 | ll bit[MAX];
 4 | void update(int i,ll x){
 5 |     while(i<=MAX){
 6 |         bit[i]+=x;
 7 |         i+=(i&-i);
 8 |     }
 9 | }
10 | ll query(int i){
11 |     ll r=0;
12 |     while(i>0){
13 |         r+=bit[i];
14 |         i-=(i&-i);
15 |     }
16 |     return r;
17 | }
18 | int Solution::countInversions(vector<int> &A) {
19 |     memset(bit,0,sizeof(bit));
20 |     ll r=0;
21 |     pair<int,int>v[A.size()+1];
22 |     for(int i=0;i<A.size();i++){
23 |         v[i].first=A[i];
24 |         v[i].second=i+1;
25 |     }
26 |     sort(v,v+A.size());
27 |     for(int i=0;i<A.size();i++){
28 |         r+=(i-query(v[i].second));
29 |         update(v[i].second,1);
30 |     }
31 |     return r;
32 | }
33 | 


--------------------------------------------------------------------------------
/Level6/Shortest Unique Prefix.cpp:
--------------------------------------------------------------------------------
 1 | #define MAX 50002
 2 | struct node {
 3 |     int many;
 4 |     int sons[26];
 5 | };
 6 | node trie[MAX];
 7 | int m=1;
 8 | void add(string v){
 9 |     int pos=1;
10 |     for(int i=0;i<v.size();i++){
11 |         int l=(v[i]-'a');
12 |         if(!trie[pos].sons[l])trie[pos].sons[l]=++m;
13 |         pos=trie[pos].sons[l];
14 |         trie[pos].many++;
15 |     }
16 | }
17 | string query(string v){
18 |     int pos=1;
19 |     string r="";
20 |     for(int i=0;i<v.size();i++){
21 |         r+=(v[i]);
22 |         int l=(v[i]-'a');
23 |         pos=trie[pos].sons[l];
24 |         if(trie[pos].many==1)return r;
25 |     }
26 |     return v;
27 | }
28 | vector<string> Solution::prefix(vector<string> &A) {
29 |     memset(trie,0,sizeof(trie));
30 |     for(int i=0;i<A.size();i++){
31 |         add(A[i]);
32 |     }
33 |     vector<string>res;
34 |     for(int i=0;i<A.size();i++){
35 |         res.push_back(query(A[i]));
36 |     }
37 |     return res;
38 | }
39 | 


--------------------------------------------------------------------------------
/Level7/Assign Mice to Holes.cpp:
--------------------------------------------------------------------------------
 1 | int Solution::mice(vector<int> &A, vector<int> &B) {
 2 |     sort(A.begin(),A.end());
 3 |     sort(B.begin(),B.end());
 4 |     int r=0;
 5 |     for(int i=0;i<A.size();i++){
 6 |         r=max(r,abs(A[i]-B[i]));
 7 |     }
 8 |     return r;
 9 | }
10 | 


--------------------------------------------------------------------------------
/Level7/Best Time to Buy and Sell Stocks II.cpp:
--------------------------------------------------------------------------------
 1 | long long memo[100002][2];
 2 | vector<int>v;
 3 | int dp(int i,int s){
 4 |     if(i==v.size())return 0;
 5 |     if(memo[i][s])return memo[i][s];
 6 |     if(s==0){
 7 |         return memo[i][s]=max(dp(i+1,0),dp(i+1,1)-v[i]);
 8 |     }
 9 |     else return memo[i][s]=max(dp(i+1,0)+v[i],dp(i+1,1));
10 | }
11 | int Solution::maxProfit(const vector<int> &A) {
12 |     if(A.size()==0)return 0;
13 |     v=A;
14 |     memset(memo,0,sizeof(memo));
15 |     return dp(0,0);
16 | }
17 | 


--------------------------------------------------------------------------------
/Level7/Bulbs.cpp:
--------------------------------------------------------------------------------
1 | int Solution::bulbs(vector<int> &A) {
2 |     int par=0,r=0;
3 |     for(int i=0;i<A.size();i++){
4 |         while(A[i]==1&&i<A.size()&&r%2==0||A[i]==0&&i<A.size()&&r%2!=0)i++;
5 |         if(i<A.size())r++;
6 |     }
7 |     return r;
8 | }
9 | 


--------------------------------------------------------------------------------
/Level7/Coins in a Line.cpp:
--------------------------------------------------------------------------------
 1 | int memo[1002][1002][2];
 2 | vector<int>v;
 3 | int dp(int i,int j,int s){
 4 |     if(i>j)return 0;
 5 |     if(memo[i][j][s])return memo[i][j][s];
 6 |     if(!s){
 7 |         return memo[i][j][s]=max(v[j]+dp(i,j-1,1),v[i]+dp(i+1,j,1));
 8 |     }
 9 |     else {
10 |         return memo[i][j][s]=min(dp(i,j-1,0),dp(i+1,j,0));
11 |     }
12 | }
13 | int Solution::maxcoin(vector<int> &A) {
14 |     memset(memo,0,sizeof(memo));
15 |     v=A;
16 |     return dp(0,A.size()-1,0);
17 | }
18 | 


--------------------------------------------------------------------------------
/Level7/Highest Product.cpp:
--------------------------------------------------------------------------------
 1 | int Solution::maxp3(vector<int> &A) {
 2 |     sort(A.begin(),A.end());
 3 |     int a=A[0],b=A[1];
 4 |     reverse(A.begin(),A.end());
 5 |     int r=1,many=0,res=(a*b)*A[0];
 6 |     for(int i=0;i<3;i++){
 7 |         r*=A[i];
 8 |     }
 9 |     res=max(res,r);
10 |     return res;
11 | }
12 | 


--------------------------------------------------------------------------------
/Level7/Interleaving Strings.cpp:
--------------------------------------------------------------------------------
 1 | string a,b,v;
 2 | bool dp(int in,int i,int j){
 3 |     if(in==v.size())return true;
 4 |     if(i==a.size()&&j==b.size())return false;
 5 |     bool uso=false;
 6 |     if(i<a.size()&&v[in]==a[i])uso=dp(in+1,i+1,j);
 7 |     if(uso)return true;
 8 |     if(j<b.size()&&v[in]==b[j])uso=dp(in+1,i,j+1);
 9 |     if(uso)return true;
10 |     return false;
11 | }
12 | int Solution::isInterleave(string A, string B, string C) {
13 |     a=A;
14 |     b=B;
15 |     v=C;
16 |     return dp(0,0,0);
17 | }
18 | 


--------------------------------------------------------------------------------
/Level7/Longest Increasing Subsequence.cpp:
--------------------------------------------------------------------------------
 1 | int dp[10002];
 2 | int Solution::lis(const vector<int> &A) {
 3 |     memset(dp,0,sizeof(dp));
 4 |     int n=A.size();
 5 |     for(int i=n-1;i>=0;i--){
 6 |         dp[i]=1;
 7 |         for(int j=i+1;j<n;j++){
 8 |             if(A[j]>A[i])dp[i]=max(dp[i],dp[j]+1);
 9 |         }
10 |     }
11 |     int r=0;
12 |     for(int i=0;i<n;i++)r=max(r,dp[i]);
13 |     return r;
14 | }
15 | 


--------------------------------------------------------------------------------
/Level7/Longest valid Parentheses.cpp:
--------------------------------------------------------------------------------
 1 | int memo[1000002];
 2 | int Solution::longestValidParentheses(string A) {
 3 |     memset(memo,0,sizeof(memo));
 4 |     stack<int>pila;
 5 |     int r=0;
 6 |     for(int i=0;i<A.size();i++){
 7 |         if(A[i]=='(')pila.push(i);
 8 |         else if(!pila.empty()) {
 9 |             int dist=(i-pila.top())+1;
10 |             memo[i]=dist;
11 |             memo[i]+=memo[i-dist];
12 |             r=max(r,memo[i]);
13 |             pila.pop();
14 |         }
15 |     }
16 |     while(!pila.empty())pila.pop();
17 |     return r;
18 | }
19 | 


--------------------------------------------------------------------------------
/Level7/Majority Element.cpp:
--------------------------------------------------------------------------------
 1 | int Solution::majorityElement(const vector<int> &A) {
 2 |     map<int,int>memo;
 3 |     for(int i=0;i<A.size();i++){
 4 |         memo[A[i]]++;
 5 |     }
 6 |     int r=0;
 7 |     for(map<int,int>::iterator it=memo.begin();it!=memo.end();it++){
 8 |         if(it->second>(A.size()/2))r=max(it->first,r);
 9 |     }
10 |     return r;
11 | }
12 | 


--------------------------------------------------------------------------------
/Level7/Max Rectangle in Binary Matrix.cpp:
--------------------------------------------------------------------------------
 1 | #define MAX 1002
 2 | int bit[MAX][MAX];
 3 | void update(int x,int y,int val){
 4 | 	int y1;
 5 | 	while(x<MAX){
 6 | 		y1=y;
 7 | 		while(y1<MAX){
 8 | 			bit[x][y1]+=val;
 9 | 			y1+=(y1&-y1);
10 | 		}
11 | 		x+=(x&-x);
12 | 	}
13 | }
14 | int query(int x,int y){    //query(x1,y1,x2,y2) = query(x2,y2) - query(x2,y1-1) - query(x1-1,y2) + query(x1-1,y1-1);
15 | 	int r=0;
16 | 	while(x>0){
17 | 		int y1=y;
18 | 		while(y1>0){
19 | 			r+=bit[x][y1];
20 | 			y1-=(y1&-y1);
21 | 		}
22 | 		x-=(x&-x);
23 | 	}
24 | 	return r;
25 | }
26 | int Solution::maximalRectangle(vector<vector<int> > &A) {
27 |     memset(bit,0,sizeof(bit));
28 |     for(int i=0;i<A.size();i++){
29 |         for(int j=0;j<A[i].size();j++){
30 |             update(i+1,j+1,A[i][j]);
31 |         }
32 |     }
33 |     int r=0;
34 |     for(int i=0;i<A.size();i++){
35 |         for(int j=0;j<A[i].size();j++){
36 |             for(int i2=i;i2<A.size();i2++){
37 |                 for(int j2=j;j2<A[i2].size();j2++){
38 |                     int uso=query(i2+1,j2+1)-query(i2+1,j)-query(i,j2+1)+query(i,j);
39 |                     if(uso==(((j2-j)+1)*((i2-i)+1)))r=max(r,uso);
40 |                 }
41 |             }
42 |         }
43 |     }
44 |     return r;
45 | }
46 | 


--------------------------------------------------------------------------------
/Level7/Max Sum Without Adjacent Elements.cpp:
--------------------------------------------------------------------------------
 1 | vector<vector<int> >m;
 2 | int memo[2][100002];
 3 | int n;
 4 | int dp(int i,int j){
 5 |     if(j>=n)return 0;
 6 |     if(memo[i][j])return memo[i][j];
 7 |     if(i==0){
 8 |         return memo[i][j]=max(m[i][j]+dp(i,j+2),max(m[i][j]+dp(i+1,j+2),dp(i,j+1)));
 9 |     }
10 |     else {
11 |         return memo[i][j]=max(m[i][j]+dp(i,j+2),max(m[i][j]+dp(i-1,j+2),dp(i,j+1)));
12 |     }
13 | }
14 | int Solution::adjacent(vector<vector<int> > &A) {
15 |     m.clear();
16 |     n=A[0].size();
17 |     memset(memo,0,sizeof(memo));
18 |     m.push_back(A[0]);
19 |     m.push_back(A[1]);
20 |     return max(dp(0,0),dp(1,0));
21 | }
22 | 
23 | 


--------------------------------------------------------------------------------
/Level7/Min Sum Path in Matrix.cpp:
--------------------------------------------------------------------------------
 1 | vector<vector<int> > m;
 2 | int memo[1002][1002];
 3 | int dp(int i,int j){
 4 |     if(i==m.size()-1&&j==m[i].size()-1)return m[i][j];
 5 |     if(i>=m.size()||i<0||j<0||j>=m[i].size())return (1<<30);
 6 |     if(memo[i][j])return memo[i][j];
 7 |     return memo[i][j]=m[i][j]+min(dp(i+1,j),dp(i,j+1));
 8 | }
 9 | int Solution::minPathSum(vector<vector<int> > &A) {
10 |     m=A;
11 |     memset(memo,0,sizeof(memo));
12 |     return dp(0,0);
13 | }
14 | 


--------------------------------------------------------------------------------
/Level7/Min Sum Path in Triangle.cpp:
--------------------------------------------------------------------------------
 1 | vector<vector<int> >m;
 2 | int memo[1002][1002];
 3 | int dp(int i,int j){
 4 |     if(i<0||i>=m.size()||j<0||j>=m[i].size())return (1<<30);
 5 |     if(i==m.size()-1)return m[i][j];
 6 |     if(memo[i][j])return memo[i][j];
 7 |     return memo[i][j]=m[i][j]+min(dp(i+1,j),dp(i+1,j+1));
 8 | }
 9 | int Solution::minimumTotal(vector<vector<int> > &A) {
10 |     m=A;
11 |     memset(memo,0,sizeof(memo));
12 |     return dp(0,0);
13 | }
14 | 


--------------------------------------------------------------------------------
/Level7/Palindrome Partitioning II.cpp:
--------------------------------------------------------------------------------
 1 | #define MAX 1002
 2 | int memo[MAX][MAX];
 3 | string v;
 4 | bool ispa(int i,int j){
 5 |     while(i<=j){
 6 |         if(v[i]!=v[j])return false;
 7 |         i++;
 8 |         j--;
 9 |     }
10 |     return true;
11 | }
12 | int dp(int in,int i){
13 |     if(i==v.size()){
14 |         if(!ispa(in,i-1))return (1<<30);
15 |         else return 0;
16 |     }
17 |     if(memo[in][i])return memo[in][i];
18 |     if(ispa(in,i)){
19 |         return memo[in][i]=min(1+dp(i+1,i+1),dp(in,i+1));
20 |     }
21 |     else {
22 |         return memo[in][i]=dp(in,i+1);
23 |     }
24 | }
25 | int Solution::minCut(string A) {
26 |     v=A;
27 |     int r=(A.size()-1);
28 |     memset(memo,0,sizeof(memo));
29 |     return min(r,dp(0,0));
30 | }
31 | 


--------------------------------------------------------------------------------
/Level7/Repeating Sub-Sequence.cpp:
--------------------------------------------------------------------------------
 1 | string v;
 2 | bool ok;
 3 | int memo[1002][1002];
 4 | int dp(int i,int j,int s){
 5 |     if(ok)return 1;
 6 |     if(s==2){
 7 |         ok=true;
 8 |         return 1;
 9 |     }
10 |     if(i==v.size()||j==v.size())return -(1<<30);
11 |     if(memo[i][j])return memo[i][j];
12 |     for(int k=j;k<v.size();k++){
13 |         if(v[k]==v[i]&&k>i)return memo[i][j]=max(dp(i+1,k+1,s+1),dp(i+1,j,s));
14 |     }
15 |     return memo[i][j]=dp(i+1,j,s);
16 | }
17 | int Solution::anytwo(string A) {
18 |     ok=false;
19 |     memset(memo,0,sizeof(memo));
20 |     v=A;
21 |     int uso=dp(0,0,0);
22 |     return ok;
23 | }
24 | 


--------------------------------------------------------------------------------
/Level7/Seats.cpp:
--------------------------------------------------------------------------------
 1 | #define MOD 10000003
 2 | int Solution::seats(string v) {
 3 |     int n=v.size();
 4 |     int mid=0,x=0,pos,pos2,r=0;
 5 |     for(int i=0;i<n;i++){
 6 |         if(v[i]=='x')mid++;
 7 |     }
 8 |     mid/=2;
 9 |     mid++;
10 |     for(int i=0;i<n;i++){
11 |         if(v[i]=='x'){
12 |         	x++;
13 |         	if(x==mid)pos=i;
14 | 		}
15 |     }
16 |     x=mid-1;
17 |     pos2=pos;
18 |     for(int i=pos-1;i>=0&&x>0;i--){  //De la mid pa abajo
19 |     	if(v[i]=='x'){
20 |     		r+=(pos2-i)-1;
21 |     		r%=MOD;
22 |     		pos2--;
23 |     		x--;
24 | 		}
25 | 	}
26 | 	x=mid-1;
27 | 	pos2=pos;
28 |     for(int i=pos+1;i<n&&x>0;i++){  //de la mid pa arriba
29 |     	if(v[i]=='x'){
30 |     		r+=(i-pos2)-1;
31 |     		r%=MOD;
32 |     		pos2++;
33 |     		x--;
34 | 		}
35 | 	}
36 |     return r%MOD;
37 | }
38 | 


--------------------------------------------------------------------------------
/Level7/Stairs.cpp:
--------------------------------------------------------------------------------
 1 | int memo[1002];
 2 | int dp(int n){
 3 |     if(n==0)return 1;
 4 |     if(n<0)return 0;
 5 |     if(memo[n])return memo[n];
 6 |     return memo[n]=dp(n-1)+dp(n-2);
 7 | }
 8 | int Solution::climbStairs(int A) {
 9 |     memset(memo,0,sizeof(memo));
10 |     return dp(A);
11 | }
12 | 


--------------------------------------------------------------------------------
/Level7/Unique Binary Search Trees II.cpp:
--------------------------------------------------------------------------------
 1 | int memo[1001];
 2 | int dp(int x){
 3 | 	if(x==1)return 1;
 4 | 	if(memo[x])return memo[x];
 5 | 	int s=0;
 6 | 	for(int i=1;i<x;i++){
 7 | 		s+=((dp(i))*dp(x-i));
 8 | 	}
 9 | 	return memo[x]=s;
10 | }
11 | int Solution::numTrees(int A) {
12 |    memset(memo,0,sizeof(memo));
13 |    return dp(A+1);
14 | }
15 | 


--------------------------------------------------------------------------------
/Level7/Unique Paths in a Grid.cpp:
--------------------------------------------------------------------------------
 1 | vector<vector<int> > v;
 2 | int memo[102][102];
 3 | int n,c;
 4 | bool ok;
 5 | int dp(int i,int j){
 6 |     if(i==0&&j==0&&v[i][j]==1)return 0;
 7 |     if(i==(n-1)&&j==(c-1)){
 8 |     	ok=true;
 9 | 		return 1;
10 | 	}
11 |     if(i>=n||j>=c)return 0;
12 |     if(memo[i][j])return memo[i][j];
13 |     memo[i][j]=0;
14 |     if(i+1<n&&v[i+1][j]==0){
15 |         memo[i][j]+=dp(i+1,j);
16 |     }
17 |     if(j+1<c&&v[i][j+1]==0){
18 |         memo[i][j]+=dp(i,j+1);
19 |     }
20 |     return memo[i][j];
21 | }
22 | int Solution::uniquePathsWithObstacles(vector<vector<int> > &A) {
23 |    memset(memo,0,sizeof(memo));
24 |    v.clear();
25 |    for(int i=0;i<A.size();i++)v.push_back(A[i]);
26 |    ok=false;
27 |    n=A.size();
28 |    c=A[0].size();
29 |    int r=dp(0,0);
30 |    if(!ok)r=0;
31 |    return r;
32 | }
33 | 


--------------------------------------------------------------------------------
/Level7/Ways to Decode.cpp:
--------------------------------------------------------------------------------
 1 | string v;
 2 | int memo[1002];
 3 | int dp(int i){
 4 |     if(i==v.size())return 1;
 5 |     if(i>v.size()||v[i]=='0')return 0;
 6 |     if(memo[i])return memo[i];
 7 |     if(v[i]>='1')memo[i]+=dp(i+1);
 8 |     if(i+1<v.size()&&v[i]=='1')memo[i]+=dp(i+2);
 9 |     if(i+1<v.size()&&v[i]=='2'&&v[i+1]<='6')memo[i]+=dp(i+2);
10 |     return memo[i];
11 | }
12 | int Solution::numDecodings(string A) {
13 |     v=A;
14 |     memset(memo,0,sizeof(memo));
15 |     return dp(0);
16 | }
17 | 


--------------------------------------------------------------------------------
/Level7/Word Break II.cpp:
--------------------------------------------------------------------------------
 1 | #define MAX 50002
 2 | struct node {
 3 |   bool fin;
 4 |   int sons[26];
 5 | };
 6 | node trie[MAX];
 7 | int m;
 8 | vector<string>r;
 9 | void add(string v){
10 |     int pos=1;
11 |     for(int i=0;i<v.size();i++){
12 |         int l=v[i]-'a';
13 |         if(!trie[pos].sons[l])trie[pos].sons[l]=++m;
14 |         pos=trie[pos].sons[l];
15 |     }
16 |     trie[pos].fin=true;
17 | }
18 | void solve(string v,string uso,int pos,int i){
19 |     if(i==v.size()){
20 |         r.push_back(uso);
21 |         return;
22 |     }
23 |     while(i<v.size()){
24 |         if(trie[pos].sons[v[i]-'a']){
25 |             uso.push_back(v[i]);
26 |             pos=trie[pos].sons[v[i]-'a'];
27 |             if(trie[pos].fin){
28 |                 string uso2;
29 |                 if(i<v.size()-1)uso2=uso+' ';
30 |                 else uso2=uso;
31 |                 solve(v,uso2,1,i+1);
32 |             }
33 |         }
34 |         else break;
35 |         i++;
36 |     }
37 | }
38 | vector<string> Solution::wordBreak(string A, vector<string> &B) {
39 |     memset(trie,0,sizeof(trie));
40 |     r.clear();
41 |     m=1;
42 |     for(int i=0;i<B.size();i++){
43 |         add(B[i]);
44 |     }
45 |     solve(A,"",1,0);
46 |     sort(r.begin(),r.end());
47 |     return r;
48 | }
49 | 


--------------------------------------------------------------------------------
/Level8/Black Shapes.cpp:
--------------------------------------------------------------------------------
 1 | vector<string>v;
 2 | void dfs(int i,int j){
 3 |     if(i>=v.size()||i<0||j>=v[i].size()||j<0)return;
 4 |     if(v[i][j]!='X')return;
 5 |     v[i][j]='0';
 6 |     dfs(i+1,j);
 7 |     dfs(i,j+1);
 8 |     dfs(i-1,j);
 9 |     dfs(i,j-1);
10 | }
11 | int Solution::black(vector<string> &A) {
12 |     v=A;
13 |     int r=0;
14 |     for(int i=0;i<v.size();i++){
15 |         for(int j=0;j<v[i].size();j++){
16 |             if(v[i][j]=='X')dfs(i,j),r++;
17 |         }
18 |     }
19 |     return r;
20 | }
21 | 


--------------------------------------------------------------------------------
/Level8/Capture Regions on Board.cpp:
--------------------------------------------------------------------------------
 1 | bool memo[1002][1002];
 2 | vector<vector<char> >v;
 3 | int n,c;
 4 | void dfs(int i,int j){
 5 |     if(memo[i][j])return;
 6 |     if(i>=n||i<0||j<0||j>=c)return;
 7 |     if(v[i][j]=='X')return;
 8 |     memo[i][j]=true;
 9 |     dfs(i+1,j);
10 |     dfs(i,j+1);
11 |     dfs(i-1,j);
12 |     dfs(i,j-1);
13 | }
14 | void Solution::solve(vector<vector<char> > &A) {
15 |     memset(memo,0,sizeof(memo));
16 |     n=A.size();
17 |     c=A[0].size();
18 |     v=A;
19 |     for(int i=0;i<c;i++){
20 |         if(A[0][i]!='X')dfs(0,i);
21 |         if(A[n-1][i]!='X')dfs(n-1,i);
22 |     }
23 |     for(int i=0;i<n;i++){
24 |         if(A[i][0]!='X')dfs(i,0);
25 |         if(A[i][c-1]!='X')dfs(i,c-1);
26 |     }
27 |     for(int i=0;i<n;i++){
28 |         for(int j=0;j<c;j++){
29 |             if(!memo[i][j])A[i][j]='X';
30 |         }
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/Level8/Knight On Chess Board.cpp:
--------------------------------------------------------------------------------
 1 | struct solve {
 2 |   int i,j,d;
 3 |   solve(int x,int y,int z):i(x),j(y),d(z){}
 4 | };
 5 | int p=2,q=1;
 6 | int dx[]={-p,-q,q,p,p,q,-q,-p};
 7 | int dy[]={q,p,p,q,-q,-p,-p,-q};
 8 | bool memo[1002][1002];
 9 | int Solution::knight(int N, int M, int x1, int y1, int x2, int y2) {
10 |     memset(memo,false,sizeof(memo));
11 |     queue<solve>cola;
12 |     solve in(x1,y1,0);
13 |     cola.push(in);
14 |     while(!cola.empty()){
15 |         solve now=cola.front();
16 |         cola.pop();
17 |         if(now.i==x2&&now.j==y2){
18 |             return now.d;
19 |         }
20 |         if(memo[now.i][now.j])continue;
21 |         memo[now.i][now.j]=true;
22 |         for(int i=0;i<8;i++){
23 |             int x=now.i+dx[i];
24 |             int y=now.j+dy[i];
25 |             if(x>0&&x<=N&&y>0&&y<=M){
26 |                 solve r(x,y,now.d+1);
27 |                 cola.push(r);
28 |             }
29 |         }
30 |     }
31 |     return -1;
32 | }
33 | 


--------------------------------------------------------------------------------
/Level8/Word Ladder I.cpp:
--------------------------------------------------------------------------------
 1 | map<string,bool>mapa;
 2 | map<string,bool>memo;
 3 | map<string,int>DP;
 4 | bool ok;
 5 | string fin;
 6 | int dp(string v){
 7 |     if(v==fin){
 8 |         ok=true;
 9 |         return 0;
10 |     }
11 |     if(DP[v])return DP[v];
12 |     int mini=(1<<30);
13 |     for(int i=0;i<v.size();i++){
14 |         char uso=v[i];
15 |         for(int j='a';j<='z';j++){
16 |             if(j!=uso){
17 |             	v[i]=j;
18 |             	if(mapa[v]&&!memo[v]||v==fin){
19 |             		memo[v]=true;
20 |             		mini=min(mini,1+dp(v));
21 |             		memo[v]=false;
22 | 				}
23 | 			}
24 |         }
25 |         v[i]=uso;
26 |     }
27 |     return DP[v]=mini;
28 | }
29 | int Solution::ladderLength(string start, string end, vector<string> &dictV) {
30 |     fin=end;
31 |     ok=false;
32 |     DP.clear();
33 |     mapa.clear();
34 |     memo.clear();
35 |     for(int i=0;i<dictV.size();i++){
36 |         mapa[dictV[i]]=true;
37 |     }
38 |     int r=1+dp(start);
39 |     if(!ok)r=0;
40 |     return r;
41 | }
42 | 


--------------------------------------------------------------------------------
/Level8/Word Search Board.cpp:
--------------------------------------------------------------------------------
 1 | vector<string>m;
 2 | string v;
 3 | bool ok;
 4 | int n,c;
 5 | int dx[]={1,-1,0,0};
 6 | int dy[]={0,0,1,-1};
 7 | void solve(int i,int x,int y){
 8 | 	if(ok)return;
 9 | 	if(i==v.size()){
10 | 		ok=true;
11 | 		return;
12 | 	}
13 | 	for(int j=0;j<4;j++){
14 | 		if(x+dx[j]>=n||x+dx[j]<0||y+dy[j]>=c||y+dy[j]<0)continue;
15 | 		if(m[x+dx[j]][y+dy[j]]==v[i])solve(i+1,x+dx[j],y+dy[j]);
16 | 	}
17 | }
18 | int Solution::exist(vector<string> &A, string B) {
19 |     ok=false;
20 | 	n=A.size();
21 | 	c=A[0].size();
22 |     m=A;
23 |     v=B;
24 |     for(int i=0;i<A.size();i++){
25 |     	for(int j=0;j<A[0].size();j++){
26 |     		if(A[i][j]==v[0])solve(1,i,j);
27 | 		}
28 | 	}
29 |     return ok;
30 | }
31 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # InterviewBit
2 | This is just a bit of all my solutions of this really cool website
3 | 


--------------------------------------------------------------------------------