From fe92a5ff455826e69f4c68ccd430daa67f17260a Mon Sep 17 00:00:00 2001
From: MachangDoniel <donieltripura121@gmail.com>
Date: Tue, 28 Jan 2025 23:50:46 +0600
Subject: [PATCH] added solutions by MachangDoniel

---
 1. Flip Columns/7.cpp                    |  72 ++++++++++
 10. Sum of kth level Nodes/2.cpp         |  47 +++++++
 11. Detect Cycle in Directed Graph/1.cpp | 167 +++++++++++++++++++++++
 2. Kim and Refrigerators/5.cpp           |  58 ++++++++
 3. Travelling SalesPerson/4.cpp          |  86 ++++++++++++
 4. Endoscope/5.cpp                       | 164 ++++++++++++++++++++++
 5. Wormhole/1.cpp                        |  68 +++++++++
 6. Burst Balloons/3.cpp                  |  62 +++++++++
 7. FisherMen/3.cpp                       |  79 +++++++++++
 8. Aeroplane Bombing/3.cpp               |  57 ++++++++
 9. Rock Climbing/4.cpp                   |  88 ++++++++++++
 11 files changed, 948 insertions(+)
 create mode 100644 1. Flip Columns/7.cpp
 create mode 100644 10. Sum of kth level Nodes/2.cpp
 create mode 100644 11. Detect Cycle in Directed Graph/1.cpp
 create mode 100644 2. Kim and Refrigerators/5.cpp
 create mode 100644 3. Travelling SalesPerson/4.cpp
 create mode 100644 4. Endoscope/5.cpp
 create mode 100644 5. Wormhole/1.cpp
 create mode 100644 6. Burst Balloons/3.cpp
 create mode 100644 7. FisherMen/3.cpp
 create mode 100644 8. Aeroplane Bombing/3.cpp
 create mode 100644 9. Rock Climbing/4.cpp

diff --git a/1. Flip Columns/7.cpp b/1. Flip Columns/7.cpp
new file mode 100644
index 0000000..297c15a
--- /dev/null
+++ b/1. Flip Columns/7.cpp	
@@ -0,0 +1,72 @@
+// Solution with Bitmasking
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+int n,m,k,ans;
+vector<vector<int>>mat;
+
+void print(){
+    cout<<"mat: "<<endl;
+    for(int i=0;i<n;i++){
+        for(int j=0;j<m;j++){
+            cout<<mat[i][j]<<" ";
+        }
+        cout<<endl;
+    }
+}
+
+void flip(int index){
+    for(int i=0;i<n;i++){
+        mat[i][index]^=1;
+    }
+}
+
+void check(int mask,int k){
+    // cout<<"mask: "<<mask<<" "<<k<<endl;
+    if(k==0){
+        // print();
+        int count=0;
+        for(int i=0;i<n;i++){
+            bool flag=true;
+            for(int j=0;j<m;j++){
+                if(mat[i][j]==0) flag=false;
+            }
+            if(flag) count++;
+        }
+        ans=max(count,ans);
+        // cout<<"ans: "<<ans<<endl;
+        return;
+    }
+    else{
+        for(int j=0;j<m;j++){
+            // if((mask & (1<<j))==0){
+                flip(j);
+                check(mask|(1<<j),k-1);
+                flip(j);
+            // }
+        }
+    }
+}
+
+int main() {
+    /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
+    cin>>n>>m>>k;
+    mat.resize(n,vector<int>(m));
+    for(int i=0;i<n;i++){
+        for(int j=0;j<m;j++){
+            cin>>mat[i][j];
+        }
+    }
+    ans=0;
+    for(int j=0;j<m;j++){
+        flip(j);
+        check(1<<j,k-1);
+        flip(j);
+    }
+    cout<<ans<<endl;
+    return 0;
+}
diff --git a/10. Sum of kth level Nodes/2.cpp b/10. Sum of kth level Nodes/2.cpp
new file mode 100644
index 0000000..e1a8706
--- /dev/null
+++ b/10. Sum of kth level Nodes/2.cpp	
@@ -0,0 +1,47 @@
+// Tricky Solution
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+
+int sToi(string node){
+    int value=0;
+    for(int i=node.size()-1,mul=1;i>=0;i--,mul*=10){
+        value+=(node[i]-'0')*mul;
+    }
+    return value;
+}
+
+
+int main() {
+    /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
+    int k;
+    string s;
+    vector<vector<int>>v(10);
+    cin>>k>>s;
+    int count=-1;
+    string node;
+    for(int i=0;i<int(s.size());i++){
+        if('0'<=s[i] && s[i]<='9'){
+            node+=s[i];
+        }
+        else{
+            if(!node.empty()){
+                int value=sToi(node);
+                v[count].push_back(value);
+            }
+            node.clear();
+            if(s[i]=='(') count++;
+            else if(s[i]==')') count--;
+        }
+    }
+    int sum=0;
+    for(int i=0;i<int(v[k].size());i++){
+        sum+=v[k][i];
+    }
+    cout<<sum<<endl;
+    return 0;
+}
diff --git a/11. Detect Cycle in Directed Graph/1.cpp b/11. Detect Cycle in Directed Graph/1.cpp
new file mode 100644
index 0000000..60b7f99
--- /dev/null
+++ b/11. Detect Cycle in Directed Graph/1.cpp	
@@ -0,0 +1,167 @@
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+#include<cstring> // extra added
+using namespace std;
+
+#define pb push_back
+#define pp pop_back
+
+// // solution 1
+// int n,m,adj[11][11],stack[11],ans[11],idx,minCycleSum=200005;
+// int vis[11];
+
+// void detectCycle1(int node,int index){
+//     if(vis[node]){
+//         int sum=node;
+//         for(int i=index-2;i>=0 && stack[i]!=node;i--){
+//             sum+=stack[i];
+//         }
+//         if(sum<minCycleSum){
+//             idx=0;
+//             ans[idx++]=node;
+//             for(int i=index-2;i>=0 && stack[i]!=node;i--){
+//                 ans[idx++]=stack[i];
+//             }
+//         }
+//         return;
+//     }
+//     else{
+//         vis[node]=1;
+//         for(int i=1;i<=n;i++){
+//             if(adj[node][i]==1){
+//                 stack[index]=i;
+//                 detectCycle1(i,index+1);
+//             }
+//         }
+//         vis[node]=0;
+//     }
+// }
+
+// void solve1(){
+//     cin>>n>>m;
+//     memset(&adj[0][0],0,(n+1)*(n+1)*sizeof(int));
+//     memset(vis,0,(n+1)*sizeof(int));
+//     for(int i=0;i<m;i++){
+//         int u,v; cin>>u>>v;
+//         adj[u][v]=1;
+//     }
+//     for(int i=1;i<=n;i++){
+//         stack[0]=i;
+//         detectCycle1(i,1);
+//     }
+//     sort(ans,ans+idx);
+//     for(int i=0;i<idx;i++){
+//         cout<<ans[i]<<" ";
+//     }
+//     // cout<<n<<m<<endl;
+//     cout<<endl;
+// }
+
+// // solution 2
+// vector<vector<int>>adj;
+// int n,m,idx,minCycleSum=200005;
+// vector<int>vis,stack,ans;
+
+// void detectCycle2(int node,int index){
+//     if(vis[node]){
+//         int sum=node;
+//         for(int i=index-2;i>=0 && stack[i]!=node;i--){
+//             sum+=stack[i];
+//         }
+//         if(sum<minCycleSum){
+//             idx=0;
+//             ans[idx++]=node;
+//             for(int i=index-2;i>=0 && stack[i]!=node;i--){
+//                 ans[idx++]=stack[i];
+//             }
+//         }
+//         return;
+//     }
+//     else{
+//         vis[node]=1;
+//         for(int num:adj[node]){
+//             stack[index]=num;
+//             detectCycle2(num,index+1);
+//         }
+//         vis[node]=0;
+//     }
+// }
+
+// void solve2(){   
+//     cin>>n>>m;
+//     adj.resize(n+1);
+//     vis.resize(n+1,0);
+//     stack.resize(n+1);
+//     ans.resize(n+1);
+//     for(int i=0;i<m;i++){
+//         int u,v; cin>>u>>v;
+//         adj[u].pb(v);
+//     }
+//     for(int i=1;i<=n;i++){
+//         stack[0]=i;
+//         detectCycle2(i,1);
+//     }
+//     sort(ans.begin(),ans.begin()+idx);
+//     for(int i=0;i<idx;i++){
+//         cout<<ans[i]<<" ";
+//     }
+//     // cout<<n<<m<<endl;
+//     cout<<endl;
+// }
+
+int n,m,min_sum;
+vector<vector<int>>adj;
+vector<int>ans;
+
+void findWay(int idx,int mask){
+    // cout<<idx<<" "<<mask<<" "<<(mask & (1<<idx))<<endl;
+    if((mask & (1<<idx))!=0){
+        // loop created
+        int sum=0;
+        vector<int>temp;
+        for(int i=0;i<n;i++){
+            if((mask & (1<<i))!=0) sum+=(i+1),temp.push_back(i+1);
+        }
+        if(sum<min_sum){
+            min_sum=sum;
+            ans=temp;
+        }
+        // cout<<"Found"<<endl;
+        return;
+    }
+    for(int i=0;i<int(adj[idx].size());i++){
+        findWay(adj[idx][i],(mask | (1<<idx)));
+    }                                                         
+}
+
+void solve3() {
+    /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
+    cin>>n>>m;
+    adj.resize(n);
+    for(int i=0;i<m;i++){
+        int u,v; cin>>u>>v;
+        u--,v--;
+        adj[u].push_back(v);
+    }
+    min_sum=1e9;
+    for(int i=0;i<n;i++){
+        findWay(i,0);
+    }
+    sort(ans.begin(),ans.end());
+    // cout<<min_sum<<endl;
+    for(int i=0;i<int(ans.size());i++){
+        cout<<ans[i]<<" ";
+    }
+    cout<<endl;
+}
+
+int main() {
+    /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
+    // solve1();
+    // solve2();
+    solve3();
+    return 0;
+}
\ No newline at end of file
diff --git a/2. Kim and Refrigerators/5.cpp b/2. Kim and Refrigerators/5.cpp
new file mode 100644
index 0000000..2e45732
--- /dev/null
+++ b/2. Kim and Refrigerators/5.cpp	
@@ -0,0 +1,58 @@
+// Solution with Bitmasking
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+int n; 
+int startX,startY,endX,endY;
+int ans;
+vector<pair<int,int>>v;
+int allone;
+
+int dist(int x1,int y1,int x2,int y2){
+    return abs(x1-x2)+abs(y1-y2);
+}
+
+void find(int sum,int mask,int last){
+    if(mask==allone){
+        int d=dist(v[last].first,v[last].second,endX,endY);
+        ans=min(ans,sum+d);
+        return;
+    }
+    for(int i=0;i<n;i++){
+        if((mask & (1<<i))==0){
+            int d=dist(v[last].first,v[last].second,v[i].first,v[i].second);
+            find(sum+d,(mask | (1<<i)),i);
+        }
+    }
+}
+
+void solve(){
+    cin>>n;
+    cin>>startX>>startY>>endX>>endY;
+    v.clear();
+    for(int i=0;i<n;i++){
+        int x,y; cin>>x>>y;
+        v.push_back({x,y});
+    }
+    ans=1e9;
+    allone=(1<<n)-1;
+    for(int i=0;i<n;i++){
+        int sum=dist(startX,startY,v[i].first,v[i].second);
+        find(sum,(1<<i),i);
+    }
+    cout<<ans<<endl;
+}
+
+int main() {
+    /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
+    int T=10;
+    for(int t=1;t<=T;t++){
+        cout<<"# "<<t<<" ";
+        solve();
+    }
+    return 0;
+}
diff --git a/3. Travelling SalesPerson/4.cpp b/3. Travelling SalesPerson/4.cpp
new file mode 100644
index 0000000..7a4b1d0
--- /dev/null
+++ b/3. Travelling SalesPerson/4.cpp	
@@ -0,0 +1,86 @@
+// Solution with Bitmasking
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+#define INT_MAX 2147483647
+
+int n; 
+vector<vector<int>>adj;
+int visited_all;
+
+// O(n!) solution
+int tsp(int mask,int pos){
+    if(mask==visited_all){
+        return adj[pos][0];
+    }
+    int ans=INT_MAX;
+    for(int city=0;city<n;city++){
+        if(!(mask&(1<<city))){
+            int newAns=adj[pos][city]+tsp(mask|(1<<city),city);
+            ans=min(ans,newAns);
+        }
+    }
+    return ans;
+}
+void solve(int& t,int& T){
+    cin>>n;
+    adj.resize(n);
+    for(int i=0;i<n;i++){
+        adj[i].resize(n);
+        for(int j=0;j<n;j++){
+            cin>>adj[i][j];
+        }
+    }
+    visited_all=(1<<n)-1;
+    cout<<tsp(1,0)<<endl;
+}
+
+//O((2^n)*n) solution
+vector<vector<int>>dp;
+int tsp2(int mask,int pos){
+    if(mask==visited_all){
+        return adj[pos][0];
+    }
+    if(dp[mask][pos]!=-1){
+        return dp[mask][pos];
+    }
+    int ans=INT_MAX;
+    for(int city=0;city<n;city++){
+        if(!(mask&(1<<city))){
+            int newAns=adj[pos][city]+tsp2(mask|(1<<city),city);
+            ans=min(ans,newAns);
+        }
+    }
+    return dp[mask][pos]=ans;
+}
+void solve2(int& t,int& T){
+    cin>>n;
+    adj.resize(n);
+    for(int i=0;i<n;i++){
+        adj[i].resize(n);
+        for(int j=0;j<n;j++){
+            cin>>adj[i][j];
+        }
+    }
+    visited_all=(1<<n)-1;
+    dp.clear();
+    dp.resize(1<<n);
+    for(int i=0;i<(1<<n);i++){
+        dp[i].resize(n,-1);
+    }
+    cout<<tsp2(1,0)<<endl;
+}
+
+int main() {
+    /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
+    int T=1;
+    cin>>T;
+    for(int t=1;t<=T;t++){
+        solve2(t,T);
+    }
+    return 0;
+}
diff --git a/4. Endoscope/5.cpp b/4. Endoscope/5.cpp
new file mode 100644
index 0000000..c6af480
--- /dev/null
+++ b/4. Endoscope/5.cpp	
@@ -0,0 +1,164 @@
+// Solution with DFS
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+int n,m,x,y,l;
+vector<vector<int>>arr;
+vector<vector<bool>>vis;
+
+bool valid(int x,int y){
+    return 0<=x && x<n && 0<=y && y<m;
+}
+bool up(int x,int y){
+    x--;
+    return valid(x,y) && (arr[x][y]==1 || arr[x][y]==2 || arr[x][y]==5 || arr[x][y]==6);
+}
+bool down(int x,int y){
+    x++;
+    return valid(x,y) && (arr[x][y]==1 || arr[x][y]==2 || arr[x][y]==4 || arr[x][y]==7);
+}
+bool right(int x,int y){
+    y++;
+    return valid(x,y) && (arr[x][y]==1 || arr[x][y]==3 || arr[x][y]==6 || arr[x][y]==7);
+}
+bool left(int x,int y){
+    y--;
+    return valid(x,y) && (arr[x][y]==1 || arr[x][y]==3 || arr[x][y]==4 || arr[x][y]==5);
+}
+
+void dfs(int x,int y,int d){
+    if(d<1) return;
+    vis[x][y]=true;
+    int type=arr[x][y];
+    switch(type){
+        case 1:
+            // up, down, left, right
+            if(up(x,y)){
+                // cout<<"up at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x-1,y,d-1);
+            }
+            if(down(x,y)){
+                // cout<<"down at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x+1,y,d-1);
+            }
+            if(left(x,y)){
+                // cout<<"left at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x,y-1,d-1);
+            }
+            if(right(x,y)){
+                // cout<<"right at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x,y+1,d-1);
+            }
+            break;
+        case 2:
+            // up, down
+            if(up(x,y)){
+                // cout<<"up at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x-1,y,d-1);
+            }
+            if(down(x,y)){
+                // cout<<"down at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x+1,y,d-1);
+            }
+            break;
+        case 3:
+            // left, right
+            if(left(x,y)){
+                // cout<<"left at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x,y-1,d-1);
+            }
+            if(right(x,y)){
+                // cout<<"right at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x,y+1,d-1);
+            }
+            break;
+        case 4:
+            // up, right
+            if(up(x,y)){
+                // cout<<"up at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x-1,y,d-1);
+            }
+            if(right(x,y)){
+                // cout<<"right at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x,y+1,d-1);
+            }
+            break;
+        case 5:
+            // down, right
+            if(down(x,y)){
+                // cout<<"down at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x+1,y,d-1);
+            }
+            if(right(x,y)){
+                // cout<<"right at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x,y+1,d-1);
+            }
+            break;
+        case 6:
+            // down, left
+            if(down(x,y)){
+                // cout<<"down at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x+1,y,d-1);
+            }
+            if(left(x,y)){
+                // cout<<"left at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x,y-1,d-1);
+            }
+            break;
+        case 7:
+            // up, left
+            if(up(x,y)){
+                // cout<<"up at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x-1,y,d-1);
+            }
+            if(left(x,y)){
+                // cout<<"left at ("<<x<<" "<<y<<") "<<d-1<<endl;
+                dfs(x,y-1,d-1);
+            }
+            break;
+    }
+}
+
+void solve(){
+    cin>>n>>m>>x>>y>>l;
+    vis.clear();
+    arr.resize(n,vector<int>(m));
+    vis.resize(n,vector<bool>(m,false));
+    for(int i=0;i<n;i++){
+        for(int j=0;j<m;j++){
+            cin>>arr[i][j];
+        }
+    }
+    dfs(x,y,l);
+    // cout<<"arr"<<endl;
+    // for(int i=0;i<n;i++){
+    //     for(int j=0;j<m;j++){
+    //         cout<<arr[i][j]<<" ";
+    //     }
+    //     cout<<endl;
+    // }
+    // cout<<endl;
+    // cout<<"visited"<<endl;
+    int ans=0;
+    for(int i=0;i<n;i++){
+        for(int j=0;j<m;j++){
+            // cout<<vis[i][j]<<" ";
+            if(vis[i][j]) ans++;
+        }
+        // cout<<endl;
+    }
+    cout<<ans<<endl;
+}
+
+int main() {
+    /* Enter your code here. Read input from STDIN. Print output to STDOUT */
+    int t; cin>>t;
+    while(t--){
+        solve();
+    }
+    return 0;
+}
diff --git a/5. Wormhole/1.cpp b/5. Wormhole/1.cpp
new file mode 100644
index 0000000..7140820
--- /dev/null
+++ b/5. Wormhole/1.cpp	
@@ -0,0 +1,68 @@
+// Solution with Bitmasking
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+#include<tuple>
+using namespace std;
+
+#define it(idx) get<idx>(it)
+
+int n,startX,startY,endX,endY;
+vector<pair<pair<pair<int,int>,pair<int,int>>,int>>v;
+
+int ans,allone;
+
+int dist(int x1,int y1,int x2,int y2){
+    return abs(x1-x2)+abs(y1-y2);
+}
+
+void getDist(int sourceX,int sourceY,int mask,int sum){
+    int d=dist(sourceX,sourceY,endX,endY);
+    ans=min(ans,sum+d);
+    if(mask==allone) return;
+    for(int i=0;i<n;i++){
+        if((mask & (1<<i))==0){
+            int fromX=v[i].first.first.first;
+            int fromY=v[i].first.first.second;
+            int toX=v[i].first.second.first;
+            int toY=v[i].first.second.second;
+            {
+                int sourceToFrom=dist(sourceX,sourceY,fromX,fromY);
+                int costInWormHole=v[i].second;
+                getDist(toX,toY,(mask | (1<<i)),sum+sourceToFrom+costInWormHole);
+            }
+            {
+                int sourceToTo=dist(sourceX,sourceY,toX,toY);
+                int costInWormHole=v[i].second;
+                getDist(fromX,fromY,(mask | (1<<i)),sum+sourceToTo+costInWormHole);
+            }
+            
+        }
+    }
+}
+
+void solve(){
+    v.clear();
+    cin>>n>>startX>>startY>>endX>>endY;
+    for(int i=0;i<n;i++){
+        int x1,y1,x2,y2,cost; cin>>x1>>y1>>x2>>y2>>cost;
+        v.push_back({{{x1,y1},{x2,y2}},cost});
+    }
+    int mask=0,sum=0;
+    ans=1e9,allone=(1<<n)-1;
+    getDist(startX,startY,mask,sum);
+    cout<<ans<<endl;
+    // cout<<"OK"<<endl;
+}
+
+int main() {
+    /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
+    int T=1;
+    cin>>T;
+    for(int t=1;t<=T;t++){
+        solve();
+    }
+    return 0;
+}
\ No newline at end of file
diff --git a/6. Burst Balloons/3.cpp b/6. Burst Balloons/3.cpp
new file mode 100644
index 0000000..e33db3a
--- /dev/null
+++ b/6. Burst Balloons/3.cpp	
@@ -0,0 +1,62 @@
+// Solution with Bitmasking
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+int n;
+vector<int>v;
+int getScore(int idx,int mask){
+    int prev=0,next=0;
+    for(int i=idx-1;i>=0;i--){
+        if((mask & (1<<i))==0){
+            prev=v[i];
+            break;
+        }
+    }
+    for(int i=idx+1;i<n;i++){
+        if((mask & (1<<i))==0){
+            next=v[i];
+            break;
+        }
+    }
+    if(prev==0 && next==0) return v[idx];
+    else{
+        if(prev==0) return next;
+        else if(next==0) return prev;
+        else return next*prev;
+    }
+}
+int ans,allone;
+
+void find(int sum,int mask){
+    if(allone==mask){
+        ans=max(ans,sum);
+        return;
+    }
+    for(int i=0;i<n;i++){
+        if((mask & (1<<i))==0){
+            int newmask=(mask | (1<<i));
+            find(sum+getScore(i,newmask),newmask);
+        }
+    }
+}
+
+int main() {
+    /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
+    cin>>n;
+    v.resize(n);
+    for(int i=0;i<n;i++){
+        cin>>v[i];
+    }
+    allone=(1<<n)-1;
+    for(int i=0;i<n;i++){
+        int mask=(1<<i);
+        int sum=getScore(i,mask);
+        find(sum,mask);
+    }
+    cout<<ans<<endl;
+    return 0;
+}
diff --git a/7. FisherMen/3.cpp b/7. FisherMen/3.cpp
new file mode 100644
index 0000000..9d98289
--- /dev/null
+++ b/7. FisherMen/3.cpp	
@@ -0,0 +1,79 @@
+// Solution with Bitmasking
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+int n;
+vector<int>gate(3);
+vector<int>people(3);
+int allone,ans;
+
+bool valid(int index){
+    return 0<=index && index<n;
+}
+
+void distributeSeats(int gateNo,int gateMask,int peopleMask,int oldCost){
+    // cout<<gateNo<<" "<<gateMask<<" "<<peopleMask<<" "<<oldCost<<endl;
+    
+    int presentCost=0;
+    int index=gate[gateNo];
+    int remains=people[gateNo];
+    // cout<<"index: "<<index<<" "<<gateNo<<endl;
+    if(valid(index) && (peopleMask & (1<<index))==0 && remains>0){
+        remains--;
+        peopleMask|=(1<<index);
+        presentCost+=1;
+        // cout<<"OK "<<index<<endl;
+    }
+    int r=index+1;
+    int l=index-1;
+    while(remains>0){
+        // cout<<r<<": "<<valid(r)<<" "<<l<<": "<<valid(l)<<endl;
+        if(valid(r) && remains>0){
+            if((peopleMask & (1<<r))==0){
+                remains--;
+                peopleMask|=(1<<r);
+                presentCost+=(1+r-index);   
+                // cout<<"right"<<endl;
+            }
+            r++;
+        }
+
+        if(valid(l) && remains>0){
+            if((peopleMask & (1<<l))==0){
+                remains--;
+                peopleMask|=(1<<l);
+                presentCost+=(1+index-l);
+                // cout<<"left"<<endl;
+            }
+            l--;
+        }
+    }
+    
+    if(gateMask==allone){
+        // cout<<"Found"<<endl;
+        ans=min(ans,oldCost+presentCost);
+        return;
+    }
+    
+    for(int i=0;i<3;i++){
+        if((gateMask & (1<<i))==0) distributeSeats(i,(gateMask | (1<<i)),peopleMask,oldCost+presentCost);
+    }
+    
+}
+
+int main() {
+    /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
+    cin>>n;
+    for(int i=0;i<3;i++) cin>>gate[i],gate[i]--;
+    for(int i=0;i<3;i++) cin>>people[i];
+    allone=(1<<3)-1,ans=1e9;
+    for(int i=0;i<3;i++){
+        distributeSeats(i,(1<<i),0,0);
+    }
+    cout<<ans<<endl;
+    return 0;
+}
diff --git a/8. Aeroplane Bombing/3.cpp b/8. Aeroplane Bombing/3.cpp
new file mode 100644
index 0000000..4155604
--- /dev/null
+++ b/8. Aeroplane Bombing/3.cpp	
@@ -0,0 +1,57 @@
+// Solution with DFS
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+int n,ans;
+vector<vector<int>>v;
+
+bool valid(int position){
+    return 0<=position && position<5;
+}
+
+void game(int index,int position,int sum,int life){
+    // cout<<index<<" "<<position<<" "<<sum<<" "<<life<<endl;
+    if(index==n || !life){
+        ans=max(sum,ans);
+        // cout<<"OK: "<<ans<<endl;
+        return;
+    }
+    if(v[index][position]==1) sum++;
+    else if(v[index][position]==2 || life!=5) life--;
+    
+    if(valid(position)) game(index+1,position,sum,life);
+    if(valid(position-1)) game(index+1,position-1,sum,life);
+    if(valid(position+1)) game(index+1,position+1,sum,life);
+}
+
+void solve(){
+    cin>>n;
+    v.resize(n);
+    for(int i=n-1;i>=0;i--){
+        v[i].resize(5);
+        for(int j=0;j<5;j++){
+            cin>>v[i][j];
+        }
+    }
+    // position,sum,blasted,life
+    ans=0;
+    game(0,2,0,5);
+    game(0,1,0,5);
+    game(0,3,0,5);
+    cout<<ans<<endl;
+}
+
+
+int main() {
+    /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
+    int T; cin>>T;
+    for(int t=1;t<=T;t++){
+        cout<<"#"<<t<<" ";
+        solve();
+    }
+    return 0;
+}
diff --git a/9. Rock Climbing/4.cpp b/9. Rock Climbing/4.cpp
new file mode 100644
index 0000000..e493160
--- /dev/null
+++ b/9. Rock Climbing/4.cpp	
@@ -0,0 +1,88 @@
+// Solution with Bitmasking
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+#define inf 1e9
+
+
+int n,m;
+vector<vector<int>>mat,dis;
+
+bool valid(int x,int y){
+    return 0<=x && x<n && 0<=y && y<m;
+}
+bool right(int x,int y){
+    y++;
+    return valid(x,y) && mat[x][y];
+}
+bool left(int x,int y){
+    y--;
+    return valid(x,y) && mat[x][y];
+}
+bool up(int x,int y){
+    x++;
+    return valid(x,y) && mat[x][y];
+}
+bool down(int x,int y){
+    x--;
+    return valid(x,y) && mat[x][y];
+}
+
+int ans;
+
+void dfs(int x,int y,int max_jump){
+    // cout<<x<<" "<<y<<" "<<max_jump<<endl;
+    if(mat[x][y]==3){
+        // cout<<"YES"<<endl;
+        ans=min(ans,max_jump);
+        return;
+    }
+    dis[x][y]=max_jump;
+    // cout<<right(x,y)<<" "<<dis[x][y]<<endl;
+    
+    if(right(x,y) && dis[x][y+1]>max_jump){
+        dfs(x,y+1,max_jump);
+    }
+    if(left(x,y) && dis[x][y-1]>max_jump){
+        dfs(x,y-1,max_jump);
+    }
+    for(int i=0;i<n;i++){
+        int jump=abs(x-i);
+        if(mat[i][y] && dis[i][y]>max(jump,max_jump)){
+            dfs(i,y,max(max_jump,jump));
+        }
+    }
+}
+
+
+int main() {
+    /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
+    cin>>n>>m;
+    mat.resize(n,vector<int>(m,inf));
+    dis=mat;
+    for(int i=n-1;i>=0;i--){
+        for(int j=0;j<m;j++){
+            cin>>mat[i][j];
+        }
+    }
+    ans=inf;
+    // for(int i=n-1;i>=0;i--){
+    //     for(int j=0;j<m;j++){
+    //         cout<<dis[i][j]<<" ";
+    //     }
+    //     cout<<endl;
+    // }
+    dfs(0,0,0);
+    cout<<ans<<endl;
+    // for(int i=n-1;i>=0;i--){
+    //     for(int j=0;j<m;j++){
+    //         cout<<dis[i][j]<<" ";
+    //     }
+    //     cout<<endl;
+    // }
+    return 0;
+}