├── Airplane.cpp
├── BasestationsConstruction.cpp
├── BurstBalloons.cpp
├── CPU_Selling.cpp
├── Fishery.cpp
├── KimAndRefrigirators.cpp
├── Marathon.cpp
├── README.md
├── RareElements.cpp
├── RobotRefuling.cpp
├── SamsungMobile(salesBooth).cpp
├── TollGate.cpp
├── TunnelConstruction.cpp
└── WormHoles.cpp


/Airplane.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | int a[13][5],b[5][5];
 4 | 
 5 | void detonate(int row){
 6 |     for(int i=row;i>=row-5;i--){
 7 |         for(int j=0;j<5;j++){
 8 |             b[row-i][j]=0;
 9 |             if(i>=0 && a[i][j]==2){
10 |                 a[i][j]=0;
11 |                 b[row-i][j]=2;
12 |             }
13 |         }
14 |     }
15 | }
16 | 
17 | void undetonate(int row){
18 |     for(int i=row;i>=row-5;i--){
19 |         for(int j=0;j<5;j++){
20 |             if(i>=0 && b[row-i][j]==2){
21 |                 a[i][j]=2;
22 |             }
23 |         }
24 |     }
25 | }
26 | 
27 | void getMax(int pos,int coins,int n,int& maxCoins){
28 |    if(pos<0 || pos>4 || coins<0) return;
29 |    if(a[n-1][pos]==1) coins++;
30 |    if(a[n-1][pos]==2) coins--;
31 |    if(n==1){
32 |        if(coins>maxCoins) maxCoins=coins;
33 |        return;
34 |    }
35 |    else{
36 |        getMax(pos-1,coins,n-1,maxCoins);
37 |        getMax(pos+1,coins,n-1,maxCoins);
38 |        getMax(pos,coins,n-1,maxCoins);
39 |    }
40 | }
41 | 
42 | int main(){
43 |     int t;
44 |     cin >> t;
45 |     while(t--){
46 |         int n;
47 |         int ans=-1;
48 |         cin >> n;
49 |         for(int i=0;i<n;i++){
50 |             for(int j=0;j<5;j++){
51 |                 cin >> a[i][j];
52 |             }
53 |         }
54 |         for(int i=0;i<5;i++) a[n][i]=0;
55 |         a[n][2]=3;
56 |         for(int i=n-1;i>=0;i--){
57 |             int coins=-1;
58 |             detonate(i);
59 |             getMax(2,0,n,coins);
60 |             if(coins>ans) ans=coins;
61 |             undetonate(i);
62 |             // getMax(2,0,n,coins);
63 |             // if(coins>ans) ans=coins;
64 |         }
65 |         if(ans<0) cout << -1 << endl;
66 |         else cout << ans << endl;
67 |     }
68 | }


--------------------------------------------------------------------------------
/BasestationsConstruction.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | using namespace std;
  3 | 
  4 | int ans=-1;
  5 | int n,m;
  6 | int base[13][13];
  7 | bool vis[13][13];
  8 | int odd[6][2]={{-1,0},{1,0},{0,-1},{0,1},{1,-1},{1,1}};
  9 | int even[6][2]={{-1,0},{1,0},{0,-1},{0,1},{-1,-1},{-1,1}};
 10 | 
 11 | bool valid(int i,int j){
 12 |     if(i>=0 && i<n && j>=0 && j<m) return true;
 13 |     return false;
 14 | }
 15 | 
 16 | int upperY(int i,int j){
 17 |     int temp=base[i][j];
 18 |     if(j%2!=0){
 19 |         if(valid(i,j-1) && valid(i,j+1) && valid(i+1,j)){
 20 |             temp+=base[i][j-1]+base[i][j+1]+base[i+1][j];
 21 |             return temp;
 22 |         }else{
 23 |             return 0;
 24 |         }
 25 |     }else{
 26 |         if(valid(i-1,j-1) && valid(i-1,j+1) && valid(i+1,j)){
 27 |             temp+=base[i-1][j-1]+base[i-1][j+1]+base[i+1][j];
 28 |             return temp;
 29 |         }else{
 30 |             return 0;
 31 |         }
 32 |     }
 33 |     return 0; 
 34 | }
 35 | 
 36 | int lowerY(int i,int j){
 37 |     int temp=base[i][j];
 38 |     if(j%2!=0){
 39 |         if(valid(i+1,j-1) && valid(i+1,j+1) && valid(i-1,j)){
 40 |             temp+=base[i+1][j-1]+base[i+1][j+1]+base[i-1][j];
 41 |             return temp;
 42 |         }else{
 43 |             return 0;
 44 |         }
 45 |     }else{
 46 |         if(valid(i,j-1) && valid(i,j+1) && valid(i-1,j)){
 47 |             temp+=base[i][j-1]+base[i][j+1]+base[i-1][j];
 48 |             return temp;
 49 |         }else{
 50 |             return 0;
 51 |         }
 52 |     }
 53 |     return 0;
 54 | }
 55 | 
 56 | void dfs(int i,int j,int depth,int temp){
 57 |     vis[i][j]=true;
 58 |     temp+=base[i][j];
 59 |     if(depth==4){
 60 |         vis[i][j]=false;
 61 |         if(temp>ans) ans=temp;
 62 |         return;
 63 |     }
 64 |     if(j%2==0){
 65 |         for(int k=0;k<6;k++){
 66 |             int x=i+even[k][0];
 67 |             int y=j+even[k][1];
 68 |             if(x>=0 && x<n && y>=0 && y<m && !vis[x][y]){
 69 |                 dfs(x,y,depth+1,temp);
 70 |             }
 71 |         }
 72 |     }else{
 73 |         for(int k=0;k<6;k++){
 74 |             int x=i+odd[k][0];
 75 |             int y=j+odd[k][1];
 76 |             if(x>=0 && x<n && y>=0 && y<m && !vis[x][y]){
 77 |                 dfs(x,y,depth+1,temp);
 78 |             }
 79 |         }
 80 |     }
 81 |     vis[i][j]=false;
 82 | }
 83 | 
 84 | int main(){
 85 |     cin >> n >> m;
 86 |     ans=0;
 87 |     for(int i=0;i<n;i++){
 88 |         for(int j=0;j<m;j++){
 89 |             cin >> base[i][j];
 90 |             vis[i][j]=false;
 91 |         }
 92 |     }
 93 |     for(int i=0;i<n;i++){
 94 |         for(int j=0;j<m;j++){
 95 |             if(!vis[i][j]){
 96 |                 dfs(i,j,1,0);
 97 |                 //cout << i << " " << j << " " << ans << endl;
 98 |                 int iy=upperY(i,j);
 99 |                 //cout << iy << endl;
100 |                 if(iy>ans) ans=iy;
101 |                 int y=lowerY(i,j);
102 |                 //cout << y << endl;
103 |                 if(y>ans) ans=y;
104 |             }
105 |         }
106 |     }
107 |     cout << ans << endl;
108 | }


--------------------------------------------------------------------------------
/BurstBalloons.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     int dp[502][502];
 4 |     vector<int> balloons;
 5 |     int helper(int l,int r,int n){
 6 |         if(dp[l][r]!=-1) return dp[l][r];
 7 |         int ans=0;
 8 |         for(int i=l+1;i<r;i++){
 9 |             int curr=helper(l,i,n)+helper(i,r,n);
10 |             if(l==0 && r==n+1){
11 |                 curr=curr+balloons[i];
12 |             }else{
13 |                 curr=curr+balloons[l]*balloons[r];
14 |             }
15 |             ans=max(ans,curr);
16 |         }
17 |         dp[l][r]=ans;
18 |         return ans;
19 |     }
20 |     
21 |     int maxCoins(vector<int>& nums) {
22 |         balloons=nums;
23 |         memset(dp,-1,sizeof(dp));
24 |         balloons.insert(balloons.begin(),1);
25 |         balloons.push_back(1);
26 |         int n=nums.size();
27 |         int ans=helper(0,n+1,n);
28 |         return ans;
29 |     }
30 | };


--------------------------------------------------------------------------------
/CPU_Selling.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #define max(a,b) (a>b)?a:b
 3 | using namespace std;
 4 | 
 5 | int prod[8][4];
 6 | int dp[100][100][100]={-1};
 7 | 
 8 | int helper(int ncpu,int pcpu,int nmem,int pmem,int nboard,int n){
 9 |     if(dp[ncpu][nmem][nboard]!=-1) return dp[ncpu][nmem][nboard];
10 |     else{
11 |         int temp1=0;
12 |         int temp2=ncpu*pcpu+nmem*pmem;
13 |         for(int i=0;i<n;i++){
14 |             if(ncpu-prod[i][0]>=0 && nmem-prod[i][1]>=0 && nboard-prod[i][2]>=0){
15 |                 temp1=max(temp1,helper(ncpu-prod[i][0],pcpu,nmem-prod[i][1],pmem,nboard-prod[i][2],n)+prod[i][3]);
16 |             }
17 |         }
18 |         dp[ncpu][nmem][nboard]=max(temp1,temp2);
19 |         return dp[ncpu][nmem][nboard];
20 |     } 
21 | }
22 | 
23 | int main(){
24 |     int t;
25 |     cin >> t;
26 |     while(t--){
27 |         int ncpu,nmem,nboard,pcpu,pmem,n;
28 |         cin >> ncpu >> nmem >> nboard >> pcpu >> pmem >> n;
29 |         for(int i=0;i<n;i++){
30 |             cin >> prod[i][0] >> prod[i][1] >> prod[i][2] >> prod[i][3];
31 |         }
32 |         for(int i=0;i<100;i++)
33 |             for(int j=0;j<100;j++)
34 |                 for(int k=0;k<100;k++)
35 |                     dp[i][j][k]=-1;
36 |         cout << helper(ncpu,pcpu,nmem,pmem,nboard,n) << endl;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/Fishery.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int ans=100000;
 4 | 
 5 | void calculate(int j,int* gate,int* person,bool* vis,int* prem,int dis,int n){
 6 |     if(j==3){
 7 |         if(dis<ans) ans=dis;
 8 |         //cout << prem[0] << " " << prem[1] << " " << prem[2] << " " << ans << endl;
 9 |         return;
10 |     }
11 |     int i=prem[j];
12 |     int p=person[i];
13 |     int left=gate[i];
14 |     int right=gate[i]+1;
15 |     for(int k=0;k<p;k++){
16 |         while(left>=0 && vis[left]){
17 |             left--;
18 |             if(left==-1) break;
19 |         }
20 |         while(right<n && vis[right]){
21 |             right++;
22 |             if(right==n) break;
23 |         }
24 |         if(left==-1 && right==n) return;
25 |         else if(left==-1){
26 |             dis+=right-gate[i]+1;
27 |             vis[right]=true;
28 |             right++;
29 |         }else if(right==-1){
30 |             dis+=gate[i]-left+1;
31 |             vis[left]=true;
32 |             left--;
33 |         }else if(k==p-1 && gate[i]-left==right-gate[i]){
34 |             bool tempvis[n];
35 |             for(int l=0;l<n;l++) tempvis[l]=vis[l];
36 |             dis+=right-gate[i]+1;
37 |             vis[right]=true;
38 |             calculate(j+1,gate,person,vis,prem,dis,n);
39 |             dis-=right-gate[i]+1;
40 |             dis+=gate[i]-left+1;
41 |             tempvis[left]=true;
42 |             calculate(j+1,gate,person,tempvis,prem,dis,n);
43 |         }else if(gate[i]-left<right-gate[i]){
44 |             dis+=gate[i]-left+1;
45 |             vis[left]=true;
46 |             left--;
47 |         }else if(gate[i]-left>=right-gate[i]){
48 |             dis+=right-gate[i]+1;
49 |             vis[right]=true;
50 |             right++;
51 |         }
52 |     }
53 |     calculate(j+1,gate,person,vis,prem,dis,n);
54 | }
55 | 
56 | int main(){
57 |     int t;
58 |     cin >> t;
59 |     while(t--){
60 |         int n;
61 |         cin >> n;
62 |         int a[n];
63 |         int g[3],p[3];
64 |         for(int i=0;i<3;i++){
65 |             cin >> g[i] >> p[i];
66 |             g[i]--;
67 |         }
68 |         bool vis[n];
69 |         int premu[3];
70 |         premu[0]=0,premu[1]=1,premu[2]=2;
71 |         for(int i=0;i<n;i++) vis[i]=false;
72 |         calculate(0,g,p,vis,premu,0,n);
73 |         premu[0]=0,premu[1]=2,premu[2]=1;
74 |         for(int i=0;i<n;i++) vis[i]=false;
75 |         calculate(0,g,p,vis,premu,0,n);
76 |         premu[0]=1,premu[1]=0,premu[2]=2;
77 |         for(int i=0;i<n;i++) vis[i]=false;
78 |         calculate(0,g,p,vis,premu,0,n);
79 |         premu[0]=1,premu[1]=2,premu[2]=0;
80 |         for(int i=0;i<n;i++) vis[i]=false;
81 |         calculate(0,g,p,vis,premu,0,n);
82 |         premu[0]=2,premu[1]=1,premu[2]=0;
83 |         for(int i=0;i<n;i++) vis[i]=false;
84 |         calculate(0,g,p,vis,premu,0,n);
85 |         premu[0]=2,premu[1]=0,premu[2]=1;
86 |         for(int i=0;i<n;i++) vis[i]=false;
87 |         calculate(0,g,p,vis,premu,0,n);
88 |         cout << ans << endl;
89 |     }
90 | }


--------------------------------------------------------------------------------
/KimAndRefrigirators.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int x[20],y[20],n,ans;
 4 | 
 5 | int abs(int i){//Absolute function
 6 | 	if(i>0){
 7 | 		return i;
 8 | 	}
 9 | 	return -i;
10 | }
11 | 
12 | int dist(int i, int j){//Calc dist between 2 points
13 |     int x1 = x[i], x2 = x[j];
14 |     int y1 = y[i], y2 = y[j];
15 |     
16 |     return (abs(x1-x2) + abs(y1-y2));
17 | }
18 | 
19 | void optimalPath(int x,bool visited[],int nodes,int value){
20 | 	if(n == nodes){//If number of nodes equal n then set value of answer
21 | 		ans = min(ans,value + dist(x,n+1));
22 | 	}
23 | 	for(int i=1;i<=n;i++){
24 | 		if(!visited[i]){
25 | 			visited[i] = true;
26 | 			optimalPath(i,visited,nodes+1,value + dist(x,i));//Dfs call
27 | 			visited[i] = false;
28 | 		}
29 | 	}
30 | }
31 | 
32 | int main(){
33 | 	int tCases;
34 | 	cin >> tCases;//For testcases
35 | 	for(int i=0;i<tCases;i++){
36 | 		ans=INT_MAX;//Set ans to max value
37 | 		cin >> n;
38 | 		cin >> x[n+1] >> y[n+1] >> x[0] >> y[0];//Input destination and source x,y coordinates
39 | 		for(int i=1;i<=n;i++){//Input drop off location coordinates
40 | 			cin >> x[i] >> y[i];
41 | 		}
42 | 		bool visited[n+2]={false};
43 | 		optimalPath(0,visited,0,0);
44 | 		cout << "#" << i+1 << " " << ans << endl;
45 | 	}
46 | 	return 0;
47 | }


--------------------------------------------------------------------------------
/Marathon.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<climits>
 3 | using namespace std;
 4 | int time1[5];
 5 | int enrgy_spent[5];
 6 |  
 7 | int main(){
 8 |     int t,energy,distance,minutes,seconds;
 9 |     cin>>t;
10 |     for(int i=0;i<t;i++){ 
11 |         cin>>energy>>distance;
12 |         for(int j=0;j<5;j++){
13 |             cin>>minutes>>seconds>>enrgy_spent[j];
14 |             time1[j]=minutes*60+seconds;
15 |         }
16 |         int arr[distance+1][energy+1];
17 |         for(int j=0;j<distance+1;j++){
18 |           for(int k=0;k<energy+1;k++){
19 |             if(j==0)
20 |                 arr[j][k]=0;
21 |             else
22 |                 arr[j][k]=INT_MAX;
23 |           }
24 |         }
25 |         for(int j=1;j<distance+1;j++){
26 |           for(int k=1;k<energy+1;k++){
27 |                 int min1=INT_MAX;
28 |                 for(int q=0;q<5;q++){ 
29 |                     if(k-enrgy_spent[q]<0)
30 |                         continue;
31 |                     int temp;
32 |                     if(arr[j-1][k-enrgy_spent[q]]!=INT_MAX){ 
33 |                         temp=arr[j-1][k-enrgy_spent[q]]+time1[q];
34 |                         min1=min(temp,min1);
35 |                     }
36 |                 }
37 |                 arr[j][k]=min1;
38 |           }
39 |         }
40 |         int ans=INT_MAX ;
41 |         for(int j=0;j<energy+1;j++)
42 |             ans=min(ans,arr[distance][j]);
43 |         cout<<ans/60<<" "<<ans%60<<endl;
44 |     }
45 | }
46 | 
47 | #include<bits/stdc++.h>
48 | using namespace std;
49 |  
50 | int d,e;
51 | int a[5][2];
52 | int dp[1000][1000]; // dp array of dist , energy
53 |  
54 | int solve(int d, int e){
55 |     // base case
56 |     if(d == 0)return 0;
57 |     if(dp[d][e] != 99999)return dp[d][e];
58 |     // recursive case
59 |     int ans = INT_MAX - 100000;
60 |     for(int i =0; i<5; i++){
61 |         if(e >= a[i][1]){
62 |            int temp = a[i][0] + solve(d-1, e - a[i][1]);
63 |            ans = min(ans,temp);
64 |         }
65 |     }
66 |     return dp[d][e] = ans;
67 | }
68 |  
69 | int main(){
70 |    
71 |     cin>>d>>e;
72 |    
73 |     for(int i = 0; i<5; i++)
74 |     cin>>a[i][0]>>a[i][1]; // corresponds to time and energy
75 |    
76 |     for(int i = 0; i<1000; i++)for(int j =0; j<1000; j++)dp[i][j] = 99999;
77 |    
78 |      cout<<solve(d,e)<<endl;
79 |    
80 |     return 0;
81 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # SamsungSolutions
2 | This includes the solution to popular Samsung Competency test Questions
3 | 


--------------------------------------------------------------------------------
/RareElements.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | using namespace std;
  3 | int n,c;
  4 | int ans=100000;
  5 | class queue{
  6 |     int q[100000];
  7 |     int front=0;
  8 |     int back=0;
  9 |     public:
 10 |     bool empty(){
 11 |         if(front-back==0) return true;
 12 |         return false;
 13 |     }
 14 |     int top(){
 15 |         if(back-front==0) return -1;
 16 |         return q[front];
 17 |     }
 18 |     void push(int x){
 19 |         if(back<100000) q[back++]=x;
 20 |     }
 21 |     void pop(){
 22 |         front++;
 23 |     }
 24 | };
 25 | 
 26 | int min(int a,int b){
 27 |     if(a>b) return b;
 28 |     else return a;
 29 | }
 30 | 
 31 | int max(int a,int b){
 32 |     if(a>b) return a;
 33 |     return b;
 34 | }
 35 | 
 36 | bool valid(int i,int j,int** matrix){
 37 |     if(i<0 || i>=n || j<0 || j>=n || matrix[i][j]==0) return false;
 38 |     return true;
 39 | }
 40 | 
 41 | void bfs(int** mat,int** vis,int** res,int x,int y){
 42 |     queue q;
 43 |     q.push(x);
 44 |     q.push(y);
 45 |     int temp=100000;
 46 |     while(!q.empty()){
 47 |         int i=q.top();q.pop();
 48 |         int j=q.top();q.pop();
 49 |         int cnt=0;
 50 |         for(int k=0;k<c;k++){
 51 |             if(vis[res[k][0]][res[k][1]]>0) cnt++;
 52 |         }
 53 |         if(cnt>=c) return;
 54 |         int val=vis[i][j];
 55 |         if(valid(i+1,j,mat)){
 56 |             vis[i+1][j]=val+1;
 57 |             q.push(i+1);
 58 |             q.push(j);
 59 |         }
 60 |         if(valid(i-1,j,mat)){
 61 |             vis[i-1][j]=val+1;
 62 |             q.push(i-1);
 63 |             q.push(j);
 64 |         }
 65 |         if(valid(i,j+1,mat)){
 66 |             vis[i][j+1]=val+1;
 67 |             q.push(i);
 68 |             q.push(j+1);
 69 |         }
 70 |         if(valid(i,j-1,mat)){
 71 |             vis[i][j-1]=val+1;
 72 |             q.push(i);
 73 |             q.push(j-1);
 74 |         }
 75 |     }
 76 | }
 77 | 
 78 | void clear(int** vis){
 79 |     for(int i=0;i<n;i++){
 80 |         for(int j=0;j<n;j++){
 81 |             vis[i][j]=0;
 82 |         }
 83 |     }
 84 | }
 85 | 
 86 | int main(){
 87 |     int t;
 88 |     cin>>t;
 89 |     while(t--){
 90 |         cin>>n>>c;
 91 |         int **matrix;
 92 |         int **vis;
 93 |         queue q;
 94 |         int **res=new int*[c];
 95 |         for(int i=0;i<c;i++){
 96 |             res[i]=new int[2];
 97 |             cin >> res[i][0] >> res[i][1];
 98 |             res[i][0]--;
 99 |             res[i][1]--;
100 |         }
101 |         matrix=new int*[n];
102 |         vis=new int*[n];
103 |         for(int i=0;i<n;i++){
104 |             matrix[i]=new int [n];
105 |             vis[i]=new int[n];
106 |             for(int j=0;j<n;j++){
107 |                 cin>>matrix[i][j];
108 |                 vis[i][j]=0;
109 |             }
110 |         }
111 |         for(int i=0;i<n;i++){
112 |             for(int j=0;j<n;j++){
113 |                 if(matrix[i][j]==1){
114 |                     bfs(matrix,vis,res,i,j);
115 |                     int temp=0;
116 |                     for(int k=0;k<c;k++){
117 |                         temp=max(temp,vis[res[k][0]][res[k][1]]);
118 |                     }
119 |                     ans=min(temp,ans);
120 |                     clear(vis);
121 |                 }
122 |             }
123 |         }
124 |         cout << ans << endl;
125 |     }
126 | }


--------------------------------------------------------------------------------
/RobotRefuling.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<climits>
 3 | using namespace std;
 4 | int n;
 5 | int ans=100000;
 6 | int a[9];
 7 | int vis[9];
 8 | 
 9 | // ins 0 is continuing ans refuiling same type of cars until fuel>0 
10 | // ins 1 is going back to the gas station 
11 | // int 2 is going to the disel station
12 | 
13 | void helper(int n,int dis,int remf,int pind,int cars,int ins,int gas){
14 |     if(n==cars){
15 |         if(ans>dis){
16 |             ans=dis;
17 |         }
18 |         return;
19 |     }
20 |     if(remf<=0) return;
21 |     if(ins==0 && gas==0){
22 |         for(int k=1;k<=n;k++){
23 |             if(vis[k]==0 && a[k]==1){
24 |                 vis[k]=1;
25 |                 helper(n,dis+abs(pind-k),remf-1,k,cars+1,0,0);
26 |                 helper(n,dis+abs(pind-k),2,k,cars+1,1,0);
27 |                 helper(n,dis+abs(pind-k),2,k,cars+1,2,0);
28 |                 vis[k]=0;
29 |             }
30 |         }
31 |     }
32 |     if(ins==0 && gas==1){
33 |         for(int k=n;k>=1;k--){
34 |             if(vis[k]==0 && a[k]==2){
35 |                 vis[k]=1;
36 |                 helper(n,dis+abs(pind-k),remf-1,k,cars+1,0,1);
37 |                 helper(n,dis+abs(pind-k),2,k,cars+1,1,1);
38 |                 helper(n,dis+abs(pind-k),2,k,cars+1,2,1);
39 |                 vis[k]=0;
40 |             }
41 |         }
42 |     }
43 |     if(ins==1){
44 |         helper(n,dis+pind,2,0,cars,0,0);
45 |     }
46 |     if(ins==2){
47 |         helper(n,dis+(n+1-pind),2,n+1,cars,0,1);
48 |     }
49 | }
50 |  
51 | int main(){
52 |     int t;
53 |     cin >> t;
54 |     while(t--){
55 |         cin >> n;
56 |         ans=100000;
57 |         for(int i=0;i<=n;i++) vis[i]=0;
58 |         for(int i=1;i<=n;i++){
59 |             cin >> a[i];
60 |         }
61 |         helper(n,0,2,0,0,0,0);
62 |         if(ans==100000){
63 |             helper(n,n+1,2,n+1,0,0,1);
64 |         }
65 |         cout << ans << endl;
66 |     }
67 | }


--------------------------------------------------------------------------------
/SamsungMobile(salesBooth).cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | using namespace std;
  3 | int starti,endi;
  4 | int n;
  5 | int arr[100000];
  6 | //QUEUE 
  7 | void push(int x){
  8 |   arr[endi]=x;
  9 |   endi++;
 10 | }
 11 | 
 12 | int pop(){
 13 |   starti++;
 14 |   return arr[starti-1];
 15 | }
 16 | 
 17 | int size(){
 18 |   return endi-starti;
 19 | }
 20 |  
 21 | int maxi(int countall[5]){
 22 |   int minindex;
 23 |   int min=0;
 24 |   for(int i=0;i<5;i++){
 25 |     if(countall[i]>=min){
 26 |       min=countall[i];
 27 |       minindex=i;
 28 |     }
 29 |   }
 30 |   return minindex+1;
 31 | }
 32 |  
 33 | void dfs1(int ** matrix,int **visited,int value,int i,int j){
 34 |     visited[i][j]=1;
 35 |     int x[4]={1,-1,0,0};
 36 |     int y[4]={0,0,-1,1};
 37 |     for(int k=0;k<4;k++){
 38 |         int l=i+x[k];
 39 |         int m=j+y[k];
 40 |         if(l>=0 && l<n && m>=0 && m<n && matrix[l][m]==value && !visited[l][m]){
 41 |             dfs1(matrix,visited,value,l,m);
 42 |         }
 43 |     }
 44 | }
 45 | void dfs(int **matrix,int **visited,int i,int j,int value){
 46 |     matrix[i][j]=value;
 47 |     visited[i][j]=1;
 48 |     int x[4]={1,-1,0,0};
 49 |     int y[4]={0,0,-1,1};
 50 |     for(int k=0;k<4;k++){
 51 |         int l=i+x[k];
 52 |         int m=j+y[k];
 53 |         if(l>=0 && l<n && m>=0 && m<n && matrix[l][m]==0 && !visited[l][m]){
 54 |             dfs(matrix,visited,l,m,value);
 55 |         }
 56 |     }
 57 | }
 58 |  
 59 | int bfs(int **matrix,int **visited,int x,int y){ 
 60 |     int countall[4];
 61 |     for(int i=0;i<5;i++)
 62 |         countall[i]=0;
 63 |     push(x);
 64 |     push(y);
 65 |     visited[x][y]=1;
 66 |     int l[4]={-1,0,1,0};
 67 |     int t[4]={0,1,0,-1};
 68 |     //cout << "inside BFS" << endl;
 69 |     while(size()>0){
 70 |         x=pop();
 71 |         y=pop();
 72 |         if(matrix[x][y]==0){
 73 |             //cout << x << " " << y << endl;
 74 |             for(int k=0;k<4;k++){
 75 |                 int i=x+l[k];
 76 |                 int j=y+t[k];
 77 |                 if(i>=0 && i<n && j>=0 && j<n && !visited[i][j]){
 78 |                     push(i);
 79 |                     push(j);
 80 |                     visited[i][j]=1;
 81 |                 }
 82 |             }
 83 |         }
 84 |         else{ 
 85 |             //cout << x << " " << y << " " << matrix[x][y] <<  endl;
 86 |             countall[matrix[x][y]-1]++;
 87 |             for(int k=0;k<4;k++){
 88 |                 int i=x+l[k];
 89 |                 int j=y+t[k];
 90 |                 if(i>=0 && i<n && j>=0 && j<n && !visited[i][j] && (matrix[i][j]==matrix[x][y])){
 91 |                     push(i);
 92 |                     push(j);
 93 |                     visited[i][j]=1;
 94 |                 }
 95 |             }
 96 |         }
 97 |     }
 98 |     // for(int i=0;i<5;i++){
 99 |     //     cout << countall[i] << " ";
100 |     // }
101 |     // cout << "BFS Comp"  << endl;
102 |     return maxi(countall);
103 | }
104 |  
105 |  
106 |  
107 | int main(){
108 |     int t;
109 |     cin>>t;
110 |     while(t--){
111 |         cin>>n;
112 |         int **matrix;
113 |         int **visited;
114 |         starti=0;
115 |         endi=0;
116 |         matrix=new int*[n];
117 |         visited=new int*[n];
118 |         for(int i=0;i<n;i++){
119 |             matrix[i]=new int [n];
120 |             visited[i]=new int[n];
121 |             for(int j=0;j<n;j++){
122 |                 cin>>matrix[i][j];
123 |                 visited[i][j]=0;
124 |             }
125 |         }
126 |         for(int i=0;i<n;i++){
127 |             for(int j=0;j<n;j++){
128 |                 if(matrix[i][j]==0){
129 |                     int temp=bfs(matrix,visited,i,j);
130 |                     //cout<<temp<<" replace "<< i << " "  << j << endl;
131 |                     for(int a=0;a<n;a++)
132 |                         for(int b=0;b<n;b++)
133 |                             visited[a][b]=0;
134 |                     dfs(matrix,visited,i,j,temp+5);
135 |                     for(int a=0;a<n;a++)
136 |                         for(int b=0;b<n;b++)
137 |                             visited[a][b]=0;
138 |                 }
139 |             }
140 |         }
141 |         for(int i=0;i<n;i++){
142 |             for(int j=0;j<n;j++){
143 |                 if(matrix[i][j]>5)
144 |                     matrix[i][j]=matrix[i][j]-5;
145 |             }
146 |         }
147 |         int count=0;
148 |         for(int i=0;i<n;i++){
149 |             for(int j=0;j<n;j++){
150 |                 //cout<<matrix[i][j]<<" ";
151 |                 if(visited[i][j]==0){ 
152 |                     count++;
153 |                     dfs1(matrix,visited,matrix[i][j],i,j);
154 |                 }
155 |             }
156 |             //cout << endl;
157 |         }
158 |         cout<<count<<endl;
159 |     }
160 | }


--------------------------------------------------------------------------------
/TollGate.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<climits>
 3 | using namespace std;
 4 | int n;
 5 | int tc[25];
 6 | int th[25];
 7 | int ans;
 8 |  
 9 | void dfs(int i,int a,int b,int c,int cost){
10 |     if(cost>ans) return;
11 |     int tot=a+b+c;
12 |     if(i==n-1){
13 |         if(tot<th[i]) cost+=tc[i];
14 |         if(cost<ans) ans=cost;
15 |         return;
16 |     }
17 |     dfs(i+1,a,b,c,cost+tc[i]);
18 |     dfs(i+1,a+th[i],b,c,cost+2*tc[i]);
19 |     if(tot>th[i]){
20 |         if(th[i]>b+c) a=tot-th[i];
21 |         if(th[i]>c) b=th[i]-c>=b?0:b+c-th[i];
22 |         dfs(i+1,0,a,b,cost);
23 |     }
24 | } 
25 |  
26 | int main(){
27 |     int t;
28 |     cin >> t;
29 |     while(t--){
30 |         cin >> n;
31 |         ans=100000;
32 |         for(int i=0;i<n;i++){
33 |             cin >> th[i] >> tc[i];
34 |         }
35 |         dfs(0,0,0,0,0);
36 |         cout << ans << endl;
37 |     }
38 | }


--------------------------------------------------------------------------------
/TunnelConstruction.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | int n,m;
 4 | int s_x,s_y,l;
 5 | int arr[50][50];
 6 | int vis[50][50];
 7 | int directions[8][4];
 8 | int answer[50][50];
 9 | 
10 | void setDirections(){
11 |     // 0 left 1 top 2 right 3 bottom
12 |     directions[0][0]=0;
13 |     directions[0][1]=0;
14 |     directions[0][2]=0;
15 |     directions[0][3]=0;
16 |     directions[1][0]=1;
17 |     directions[1][1]=1;
18 |     directions[1][2]=1;
19 |     directions[1][3]=1;
20 |     directions[2][0]=0;
21 |     directions[2][1]=1;
22 |     directions[2][2]=0;
23 |     directions[2][3]=1;
24 |     directions[3][0]=1;
25 |     directions[3][1]=0;
26 |     directions[3][2]=1;
27 |     directions[3][3]=0;
28 |     directions[4][0]=0;
29 |     directions[4][1]=1;
30 |     directions[4][2]=1;
31 |     directions[4][3]=0;
32 |     directions[5][0]=0;
33 |     directions[5][1]=0;
34 |     directions[5][2]=1;
35 |     directions[5][3]=1;
36 |     directions[6][0]=1;
37 |     directions[6][1]=0;
38 |     directions[6][2]=0;
39 |     directions[6][3]=1;
40 |     directions[7][0]=1;
41 |     directions[7][1]=1;
42 |     directions[7][2]=0;
43 |     directions[7][3]=0;
44 | }
45 | 
46 | bool isvalid(int x,int y){
47 |     if(x>=0 && x<n && y>=0 && y<m) return true;
48 |     return false;
49 | }
50 | 
51 | void dfs(int i,int j,int cl){
52 |     if(cl==l) return;
53 |     vis[i][j]=true;
54 |     answer[i][j]=1;
55 |     if(isvalid(i,j-1) && directions[arr[i][j]][0] && directions[arr[i][j-1]][2] && !vis[i][j-1]){
56 |         dfs(i,j-1,cl+1);
57 |         vis[i][j-1]=false;
58 |     }
59 |     if(isvalid(i+1,j) && directions[arr[i][j]][3] && directions[arr[i+1][j]][1] && !vis[i+1][j]){
60 |         dfs(i+1,j,cl+1);
61 |         vis[i+1][j]=false;
62 |     }
63 |     if(isvalid(i,j+1) && directions[arr[i][j]][2] && directions[arr[i][j+1]][0] && !vis[i][j+1]){
64 |         dfs(i,j+1,cl+1);
65 |         vis[i][j+1]=false;
66 |     }
67 |     if(isvalid(i-1,j) && directions[arr[i][j]][1] && directions[arr[i-1][j]][3] && !vis[i-1][j]){
68 |         dfs(i-1,j,cl+1);
69 |         vis[i-1][j]=false;
70 |     }
71 | }
72 | 
73 | int main(){
74 |     int t;
75 |     cin >> t;
76 |     setDirections();
77 |     while(t--){
78 |         cin >> n >> m;
79 |         cin >> s_x >> s_y >> l;
80 |         for(int i=0;i<n;i++){
81 |             for(int j=0;j<m;j++){
82 |                 cin >> arr[i][j];
83 |                 vis[i][j]=false;
84 |                 answer[i][j]=0;
85 |             }
86 |         }
87 |         int ans=0;
88 |         if(arr[s_x][s_y]==0) cout << ans << endl;
89 |         else{
90 |             dfs(s_x,s_y,0);
91 |             for(int i=0;i<n;i++){
92 |                 for(int j=0;j<m;j++){
93 |                     ans+=answer[i][j];
94 |                 }
95 |             }
96 |             cout << ans << endl;
97 |         }
98 |     }
99 | }


--------------------------------------------------------------------------------
/WormHoles.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | int n;
 4 | int x[13];
 5 | int y[13];
 6 | int w[5];
 7 | int g[13][13];
 8 | int vis[13];
 9 | 
10 | int abs(int a){
11 |     if(a<0) return -1*a;
12 |     return a;
13 | }
14 | 
15 | int min(int a,int b){
16 |     if(a<b) return a;
17 |     return b;
18 | }
19 | 
20 | int minind(int* dist,int k){
21 |     int ans=-1;
22 |     int minval=100000;
23 |     for(int i=0;i<k;i++){
24 |         if(!vis[i] && dist[i]<minval){
25 |             ans=i;
26 |             minval=dist[i];
27 |         }    
28 |     }
29 |     return ans;
30 | }
31 | 
32 | int dijkstra(int k){
33 |     int dist[k];
34 |     for(int i=0;i<k;i++) dist[i]=100000;
35 |     dist[0]=0;
36 |     for(int i=0;i<k;i++){
37 |         int index=minind(dist,k);
38 |         vis[index]=1;
39 |         for(int j=0;j<k;j++){
40 |             if(!vis[j] && g[index][j]!=0 && dist[j]>dist[index]+g[index][j]){
41 |                 dist[j]=dist[index]+g[index][j];
42 |             }
43 |         }
44 |     }
45 |     return dist[1];
46 | }
47 | 
48 | int main() {
49 | 	int t;
50 | 	cin >> t;
51 | 	while(t--){
52 | 	    cin >> n;
53 | 	    cin >> x[0] >> y[0] >> x[1] >> y[1] ;
54 | 	    int k=2;
55 | 	    for(int j=0;j<n;j++){
56 | 	        cin >> x[k] >> y[k];
57 | 	        k++;
58 | 	        cin >> x[k] >> y[k];
59 | 	        cin >> w[k-1];
60 | 	        k++;
61 | 	    }
62 | 	    for(int i=0;i<k;i++) vis[i]=0;
63 | 	    for(int i=0;i<k;i++){
64 | 	        for(int j=i+1;j<k;j++){
65 | 	            g[i][j]=abs(x[i]-x[j])+abs(y[i]-y[j]);
66 | 	            g[j][i]=g[i][j];
67 | 	            if(i%2==0 && j==i+1 && i!=0){
68 | 	                g[i][j]=min(g[i][j],w[i]);
69 | 	                g[j][i]=min(g[j][i],w[i]);
70 | 	            }
71 | 	        }
72 | 	    }
73 | 	    cout << dijkstra(k) << endl;
74 | 	}
75 | 	return 0;
76 | }


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