├── README.md
├── SRBD
    ├── Aggressive cows.cpp
    ├── Balloons and bullets.cpp
    ├── Bicoloring.cpp
    ├── Biochemical laughing bomb.cpp
    ├── Cammel.cpp
    ├── Chessboard2.cpp
    ├── Collecting Beepers.cpp
    ├── Crow Pots-2.cpp
    ├── Cycle Detection.cpp
    ├── Days of Week.cpp
    ├── Detect cycle in directed Graph.cpp
    ├── Diving for Gold.cpp
    ├── Doctor Probability.cpp
    ├── Electric banner largest two pipe.cpp
    ├── Endoscope.cpp
    ├── Endscopes.cpp
    ├── Find the smallest positive number.cpp
    ├── Fishery Gates.cpp
    ├── Flip Columns.CPP
    ├── Frog Jump.cpp
    ├── Gasoline and diesel.cpp
    ├── Graph Coloring.cpp
    ├── K ominos number.cpp
    ├── Kim and Refrigerators.cpp
    ├── LaughingBomb.cpp
    ├── LeargestBST.cpp
    ├── Linklist.cpp
    ├── MR Lee Office.cpp
    ├── Marge Sort.cpp
    ├── Maze and  Jewels.cpp
    ├── Mr Kim refrigerators.cpp
    ├── Oil mine.cpp
    ├── Physical energy.cpp
    ├── Protein Fat Carbohidrat.cpp
    ├── Rare Element.cpp
    ├── Restroom.cpp
    ├── Rock climbing.cpp
    ├── Spaceship Bomb.cpp
    ├── Spaceship Game.cpp
    ├── Stockprice.cpp
    ├── Sum of Nodes in Kth Level.cpp
    ├── SumAtLevelK.cpp
    ├── SuperSale.cpp
    ├── Travelling SalesPerson.cpp
    ├── Travelling Salesman.uva.cpp
    ├── Unique BST.cpp
    ├── Urinal problem.cpp
    └── Warmholes.cpp
└── TherapBD
    ├── Compile time polymorphism.cpp
    ├── Concat integers.cpp
    ├── Delete a element from linklist.cpp
    ├── Delete a node from bst.cpp
    ├── Delete the elements in an linked list whose sum is equal to zero.cpp
    ├── Detect Loop and remove in linklist.cpp
    ├── Digit to Binary.cpp
    ├── Dimond shape problem.cpp
    ├── Height of BST.cpp
    ├── Insert and delete into sorted linklist.cpp
    ├── Insert into Linklist.cpp
    ├── Max Sum BST.cpp
    ├── Max value of BT.cpp
    ├── Middle Point of linklist.cpp
    ├── Pallindrome Check in linklist.cpp
    ├── Reverse a linklist.cpp
    ├── Reverse string.cpp
    ├── ReverseString.cpp
    ├── Runtime polymorphism.cpp
    ├── String Spilt.cpp
    ├── Valid Phone Number2.cpp
    ├── Valid licence number check.cpp
    ├── find specifc string.cpp
    ├── friend function and class.cpp
    └── insert into BST.cpp


/README.md:
--------------------------------------------------------------------------------
1 | # Interviews


--------------------------------------------------------------------------------
/SRBD/Aggressive cows.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int binarySearch(int a[], int n, int c)
 5 | {
 6 |     int low = 0, high = a[n-1], best = 0;
 7 |     while(low <= high)
 8 |     {
 9 |         int mid = (low + high + 1)/2;
10 |         int cnt = 1, pre = 0;
11 |         for(int i=0; i<n && cnt < c; i++)
12 |         {
13 |             if(a[i]-a[pre] >= mid)
14 |             {
15 |                 pre = i;
16 |                 cnt++;
17 |             }
18 |         }
19 | 
20 |         if(cnt >= c)
21 |         {
22 |             best = mid;
23 |             low = mid + 1;
24 |         }
25 |         else
26 |             high = mid -1;
27 |     }
28 |     return best;
29 | }
30 | 
31 | int main()
32 | {
33 |     //freopen("input.txt","r",stdin);
34 |     int t;
35 |     cin>>t;
36 | 
37 |     while(t--)
38 |     {
39 |         int n, c;
40 |         cin>>n>>c;
41 | 
42 |         int a[n];
43 |         for(int i=0; i<n; i++)
44 |         {
45 |             cin>>a[i];
46 |         }
47 | 
48 |         sort(a, a+n);
49 |         int ans = binarySearch(a, n, c);
50 |         cout<<ans<<"\n";
51 |     }
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/SRBD/Balloons and bullets.cpp:
--------------------------------------------------------------------------------
 1 | //leetode problem solutions
 2 | #include <iostream>
 3 | #include<vector>
 4 | #include<string.h>
 5 | #define MX 100
 6 | using namespace std;
 7 | 
 8 | int dp[305][305];
 9 | 
10 | int solve(int i, int j, vector<int> &a)
11 | {
12 |     if(i > j)
13 |         return 0;
14 |     if(dp[i][j] >= 0)
15 |         return dp[i][j];
16 | 
17 |     int mx = -1;
18 |     for(int k=i; k<=j; k++)
19 |     {
20 |         int sum = a[i-1] * a[k] * a[j+1] + solve(i, k-1, a) + solve(k+1, j, a);
21 |         //cout<<sum<<endl;
22 |         dp[i][j] = mx = max(sum, mx);
23 |     }
24 |     return dp[i][j] = mx;
25 | }
26 | 
27 | int maxCoins(vector<int>& nums)
28 | {
29 |     int n = nums.size();
30 |     nums.push_back(1);
31 |     nums.insert(nums.begin(), 1);
32 | 
33 |     memset(dp, -1, sizeof(dp));
34 |     int ans = solve(1, n, nums);
35 |     return ans;
36 | }
37 | 
38 | int main()
39 | {
40 |     int n, a;
41 |     cin>>n;
42 | 
43 |     vector<int> v;
44 |     for(int i=0; i<n; i++)
45 |     {
46 |         cin>>a;
47 |         v.push_back(a);
48 |     }
49 | 
50 |     int ans = maxCoins(v);
51 |     cout<<ans<<"\n";
52 | 
53 |     return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/SRBD/Bicoloring.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<stdio.h>
 3 | #include<string.h>
 4 | #define MX 205
 5 | 
 6 | int adj[MX][MX], vis[MX], leb[MX];
 7 | int inp_arr[MX];
 8 | int Rear, Front;
 9 | 
10 | void init()
11 | {
12 |     memset(vis, 0, sizeof(vis));
13 |     memset(leb, 0, sizeof(vis));
14 |     memset(inp_arr, 0, sizeof(vis));
15 |     Rear = -1, Front = -1;
16 | }
17 | 
18 | void push(int n)
19 | {
20 |     if (Front == - 1)
21 |         Front = 0;
22 |     Rear = Rear + 1;
23 |     inp_arr[Rear] = n;
24 | }
25 | 
26 | int pop()
27 | {
28 |     return inp_arr[Front++];
29 | }
30 | 
31 | bool isempty()
32 | {
33 |     if (Front == - 1 || Front > Rear)
34 |         return 1;
35 |     else
36 |         return 0;
37 | }
38 | 
39 | int bfs(int n)
40 | {
41 |     vis[0] = 1;
42 |     leb[0] = 1;
43 |     push(0);
44 | 
45 |     while(!isempty())
46 |     {
47 |         int u = pop();
48 |         //printf("%d\n",u);
49 |         for(int i=0; i<n; i++)
50 |         {
51 |             if(vis[i]==0 && adj[u][i]==1)
52 |             {
53 |                 vis[i] = 1;
54 |                 leb[i] = 1 - leb[u];
55 |                 push(i);
56 |             }
57 |             else if(vis[i]==1 && adj[u][i]==1)
58 |                 if(leb[i]==leb[u])
59 |                     return 0;
60 |         }
61 |     }
62 |     return 1;
63 | }
64 | 
65 | int main()
66 | {
67 |     int n, m;
68 |     while(scanf("%d",&n))
69 |     {
70 |         if(n==0)
71 |             break;
72 | 
73 |         scanf("%d",&m);
74 |         for(int i=0; i<m; i++)
75 |         {
76 |             int a, b;
77 |             scanf("%d%d",&a,&b);
78 |             adj[a][b] = 1;
79 |             adj[b][a] = 1;
80 |         }
81 | 
82 |         init();
83 |         if(bfs(n))
84 |             printf("BICOLORABLE.\n");
85 |         else
86 |             printf("NOT BICOLORABLE.\n");
87 | 
88 |         for(int i=0; i<=n; i++)
89 |         {
90 |             memset(adj[i], 0, sizeof(adj[i]));
91 |         }
92 |     }
93 |     return 0;
94 | }
95 | 


--------------------------------------------------------------------------------
/SRBD/Biochemical laughing bomb.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<stdio.h>
 3 | #include<string.h>
 4 | #include<queue>
 5 | #define pii pair<int, int>
 6 | #define MX 105
 7 | using namespace std;
 8 | 
 9 | int dx[] = { 0, 1, 0, -1 };
10 | int dy[] = { 1, 0, -1, 0 };
11 | int n, m, arr[MX][MX], level[MX][MX];
12 | 
13 | bool isValid(int x, int y)
14 | {
15 |     if(x >=0 && x < n && y >= 0 && y < n)
16 |         return 1;
17 |     return 0;
18 | }
19 | 
20 | int bfs(int sx, int sy)
21 | {
22 |     int ans = 0;
23 |     queue<pii>q;
24 |     q.push({sx, sy});
25 |     arr[sx][sy] = 2;
26 |     level[sx][sy] = 1;
27 | 
28 |     while(!q.empty())
29 |     {
30 |         int x = q.front().first;
31 |         int y = q.front().second;
32 |         q.pop();
33 | 
34 |         for(int i=0; i<4; i++)
35 |         {
36 |             int xx = x + dx[i];
37 |             int yy = y + dy[i];
38 | 
39 |             if(isValid(xx, yy) && arr[xx][yy]==1)
40 |             {
41 |                 q.push({xx, yy});
42 |                 arr[xx][yy] = 2;
43 |                 level[xx][yy] = level[x][y] + 1;
44 |                 ans = level[xx][yy];
45 |             }
46 |         }
47 |     }
48 |     return ans;
49 | }
50 | 
51 | int main()
52 | {
53 | 	int t;
54 | 	cin >> t;
55 | 
56 | 	while (t--)
57 | 	{
58 | 		cin >> n >> m;
59 | 		for (int i = 0; i < m; i++)
60 | 			for (int j = 0; j < n; j++)
61 | 				cin >> arr[i][j];
62 | 
63 | 		int x, y;
64 | 		cin >> x >> y;
65 | 		int ans = bfs(x-1, y-1);
66 | 		cout << ans << "\n";
67 | 	}
68 | 	return 0;
69 | }
70 | 
71 | 


--------------------------------------------------------------------------------
/SRBD/Cammel.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string.h>
 3 | #define MX 10005
 4 | #define INF 999999
 5 | using namespace std;
 6 | 
 7 | int n, arr[MX];
 8 | int vis[MX], ans;
 9 | 
10 | void solve(int lor, int cost, int cnt)
11 | {
12 |     if(cost > ans)
13 |         return;
14 | 
15 |     if(cnt==n)
16 |     {
17 |         ans = min(ans, cost);
18 |         return;
19 |     }
20 | 
21 |     if(lor)
22 |     {
23 |         for(int i=0; i<n; i++)
24 |         {
25 |             for(int j=i+1; j<n; j++)
26 |             {
27 |                 if(vis[i]==0 && vis[j]==0)
28 |                 {
29 |                     vis[i] = vis[j] = 1;
30 |                     int tmp = max(arr[i], arr[j]);
31 |                     solve(1-lor, cost+tmp, cnt+2);
32 |                     vis[i] = vis[j] = 0;
33 |                 }
34 |             }
35 |         }
36 |     }
37 |     else
38 |     {
39 |         for(int i=0; i<n; i++)
40 |         {
41 |             if(vis[i])
42 |             {
43 |                 vis[i] = 0;
44 |                 solve(1-lor, cost+arr[i], cnt-1);
45 |                 vis[i] = 1;
46 |             }
47 |         }
48 |     }
49 | }
50 | 
51 | int main()
52 | {
53 |     int t;
54 |     cin>>t;
55 | 
56 |     while(t--)
57 |     {
58 |         cin>>n;
59 |         for(int i=0; i<n; i++)
60 |             cin>>arr[i];
61 | 
62 |         ans = INF;
63 |         memset(vis, 0, sizeof(vis));
64 |         solve(1, 0, 0);
65 |         cout<<ans<<"\n";
66 |     }
67 |     return 0;
68 | }
69 | 


--------------------------------------------------------------------------------
/SRBD/Chessboard2.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | #define pii pair<int, int>
 3 | #define MX 30
 4 | using namespace std;
 5 | 
 6 | int n, m;
 7 | int vis[MX][MX], level[MX][MX];
 8 | 
 9 | int dx[] = {-1, 1, -1, 1, -2, -2, 2, 2};
10 | int dy[] = {-2, -2, 2, 2, -1, 1, -1, 1};
11 | 
12 | bool isValid(int x, int y)
13 | {
14 |     if(x>=0 && x<n && y>=0 && y<m)
15 |         return 1;
16 |     return 0;
17 | }
18 | 
19 | int bfs(int sx, int sy, int ex, int ey)
20 | {
21 |     queue<pii>q;
22 |     q.push({sx, sy});
23 |     vis[sx][sy] = 1;
24 |     level[sx][sy] = 1;
25 | 
26 |     while(!q.empty())
27 |     {
28 |         int x = q.front().first;
29 |         int y = q.front().second;
30 |         q.pop();
31 | 
32 |         if(x==ex && y==ey)
33 |             return level[x][y];
34 | 
35 |         for(int i=0; i<8; i++)
36 |         {
37 |             int xx = x + dx[i];
38 |             int yy = y + dy[i];
39 | 
40 |             if(isValid(xx, yy) && vis[xx][yy]==0)
41 |             {
42 |                 q.push({xx, yy});
43 |                 vis[xx][yy] = 1;
44 |                 level[xx][yy] = level[x][y] + 1;
45 |             }
46 |         }
47 |     }
48 |     return -1;
49 | }
50 | 
51 | 
52 | int main()
53 | {
54 |     int t, cas = 0;
55 |     cin>>t;
56 | 
57 |     while(t--)
58 |     {
59 |         int c, s, r, k;
60 |         cin>>n>>m>>r>>c>>s>>k;
61 | 
62 |         memset(vis, 0, sizeof(vis));
63 |         int ans = bfs(r, c, s, k);
64 |         cout<<"Case #"<< ++cas <<"\n"<<ans<<"\n";
65 |     }
66 |     return 0;
67 | }
68 | 
69 | 


--------------------------------------------------------------------------------
/SRBD/Collecting Beepers.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #define MX 25
 3 | using namespace std;
 4 | 
 5 | struct point {
 6 |     int x, y;
 7 | }adj[MX];
 8 | 
 9 | int distance(point a, point b)
10 | {
11 |     return abs(a.x - b.x) + abs(a.y - b.y);
12 | }
13 | 
14 | void Swap(point &a, point &b)
15 | {
16 |     point t = a;
17 |     a = b;
18 |     b = t;
19 | }
20 | 
21 | int totalDistance(int n)
22 | {
23 |     int sum = 0;
24 |     for (int i = 1; i < n; i++)
25 |     {
26 |         sum += distance(adj[i - 1], adj[i]);
27 |     }
28 |     return sum;
29 | }
30 | 
31 | void permutation(point adj[], int l, int r, point s, int &ans)
32 | {
33 |     if (l == r)
34 |     {
35 |         int tmp = distance(s, adj[0]) + totalDistance(r+1) + distance(s, adj[r]);
36 |         //cout<<tmp<<endl;
37 |         ans = min(ans, tmp);
38 |         return;
39 |     }
40 |     else
41 |     {
42 |         for (int i = l; i <= r; i++)
43 |         {
44 |             swap(adj[l], adj[i]);
45 |             permutation(adj, l + 1, r, s, ans);
46 |             swap(adj[l], adj[i]);
47 |         }
48 |     }
49 | }
50 | 
51 | int main()
52 | {
53 |     freopen("input.txt","r", stdin);
54 |     int t;
55 |     cin >> t;
56 | 
57 |     while (t--)
58 |     {
59 |         int n, m;
60 |         point s;
61 |         cin >> n >> m >> s.x >> s.y;
62 | 
63 |         int q, a, b;
64 |         cin >> q;
65 |         for (int i = 0; i < q; i++)
66 |         {
67 |             cin >> a >> b;
68 |             adj[i].x = a;
69 |             adj[i].y = b;
70 |         }
71 | 
72 |         int ans = distance(s, adj[0]) + totalDistance(q) + distance(s, adj[q - 1]);
73 |         permutation(adj, 0, q-1, s, ans);
74 |         cout <<"The shortest path has length "<< ans << endl;
75 |     }
76 |     return 0;
77 | }
78 | 


--------------------------------------------------------------------------------
/SRBD/Crow Pots-2.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<algorithm>
 3 | #define MX 105
 4 | #define INF 99999999
 5 | using namespace std;
 6 | 
 7 | int dp[MX][MX], a[MX];
 8 | int solve(int n, int z)
 9 | {
10 |     for(int i=1; i<=n; i++)
11 |         dp[i][1] = a[i] * (n-i+1);
12 | 
13 |     for(int i=n; i>0; i--)
14 |     {
15 |         for(int j=2; j<=z; j++)
16 |         {
17 |             for(int k=i+1; k<=n; k++)
18 |             {
19 |                 dp[i][j] = min(dp[i][j], dp[k][j-1]+(k-i)*a[i]);
20 |                 cout<<i<<j<<" "<<dp[k][j-1]+(k-i)*a[i]0<<endl;
21 |             }
22 |         }
23 |     }
24 | 
25 |     int ans = INF;
26 |     for(int i=1; i<=n; i++)
27 |         ans = min(dp[i][z], ans);
28 |     return ans;
29 | }
30 | 
31 | void init(int n)
32 | {
33 |     for(int i = 0; i<=n; i++)
34 |         for(int j =0; j<=n; j++)
35 |             dp[i][j] = INF;
36 | }
37 | 
38 | int main()
39 | {
40 |     int t;
41 |     cin>>t;
42 | 
43 |     while(t--)
44 |     {
45 |         int n, k;
46 |         cin>>n>>k;
47 | 
48 |         for(int i =1; i<=n; i++)
49 |             cin>>a[i];
50 | 
51 |         init(n);
52 |         sort(a+1, a+n+1);
53 |         int ans = solve(n, k);
54 |         cout<<ans<<"\n";
55 |     }
56 |     return 0;
57 | }
58 | 


--------------------------------------------------------------------------------
/SRBD/Cycle Detection.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | #define MX 1005
 4 | using namespace std;
 5 | 
 6 | vector<int> vis, par;
 7 | vector<int>adj[MX];
 8 | 
 9 | vector<int> vis, cir;
10 | bool dfs(int s, vector<int>adj[])
11 | {
12 |     vis[s] = 1;
13 |     cir[s] = 1;
14 | 
15 |     for(int i=0; i<adj[s].size(); i++)
16 |     {
17 |         int u = adj[s][i];
18 |         //cout<<u<<endl;
19 |         if(!vis[u] && dfs(u, adj))
20 |             return 1;
21 |         else if(cir[u])
22 |             return 1;
23 |     }
24 |     cir[s] = 0;
25 |     return 0;
26 | }
27 | 
28 | bool isCyclic(int V, vector<int> adj[])
29 | {
30 |     vis.assign(V, 0);
31 |     cir.assign(V, 0);
32 | 
33 |     for(int i=0; i<V; i++)
34 |         if(!vis[i] && dfs(i, adj))
35 |             return 1;
36 |     return 0;
37 | }
38 | 
39 | int main()
40 | {
41 |     int n, m;
42 |     cin>>n>>m;
43 | 
44 |     for(int i=0; i<m; i++)
45 |     {
46 |         int a, b;
47 |         cin>>a>>b;
48 |         adj[a].push_back(b);
49 |     }
50 | 
51 |     find_cycle(n);
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/SRBD/Days of Week.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<stdio.h>
 3 | 
 4 | using namespace std;
 5 | 
 6 | string week[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
 7 | 
 8 | int dayOfWeek(int y, int m, int d)
 9 | {
10 | 	int t[] = { 12, 11, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
11 | 
12 | 	for (int i = 0; i < 12; i++)
13 | 	{
14 | 		int ans = t[i] * 2.6 - 0.2;
15 | 		t[i] = ans % 7;
16 | 	}
17 | 
18 | 	int i = (y + y / 4 - y / 100 + y / 400 + t[m-1] + d) % 7;
19 | 	return i;
20 | }
21 | 
22 | int main()
23 | {
24 | 	int day, month, year;
25 | 	cin >> day >> month >> year;
26 | 
27 | 	int ans = dayOfWeek(year, month, day);
28 | 	cout << week[ans] << "\n";
29 | 	return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/SRBD/Detect cycle in directed Graph.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<vector>
 3 | #include<string.h>
 4 | #include<algorithm>
 5 | #define MX 15
 6 | using namespace std;
 7 | 
 8 | vector<int>adj[MX], ans;
 9 | int vis[MX], par[MX], mx = 999999;
10 | 
11 | void dfs(int u, int p)
12 | {
13 |     if(vis[u]==1)
14 |     {
15 |         int sum = u;
16 |         vector<int> cycle;
17 |         cycle.push_back(u);
18 | 
19 |         for(int v = p; v != u; v = par[v])
20 |         {
21 |             //cout<<v<<endl;
22 |             cycle.push_back(v);
23 |             sum += v;
24 |         }
25 |         if(sum < mx)
26 |         {
27 |             ans = cycle;
28 |             mx = sum;
29 |         }
30 |         return;
31 |     }
32 | 
33 |     vis[u] = 1;
34 |     par[u] = p;
35 | 
36 |     for(int i=0; i<adj[u].size(); i++)
37 |     {
38 |         int v = adj[u][i];
39 |         dfs(v, u);
40 |     }
41 |     vis[u] = 0;
42 | }
43 | 
44 | void findCycle(int n)
45 | {
46 |     memset(vis, 0, sizeof(vis));
47 |     memset(par, -1, sizeof(par));
48 | 
49 |     for(int i=1; i<=n; i++)
50 |     {
51 |         if(!vis[i])
52 |             dfs(i, -1);
53 |     }
54 | 
55 |     sort(ans.begin(), ans.end());
56 |     for(int i=0; i<ans.size(); i++)
57 |         cout<<ans[i]<<" ";
58 |     cout<<"\n";
59 | }
60 | 
61 | int main()
62 | {
63 |     int n, m;
64 |     cin>>n>>m;
65 | 
66 |     for(int i=0; i<m; i++)
67 |     {
68 |         int a, b;
69 |         cin>>a>>b;
70 |         adj[a].push_back(b);
71 |     }
72 | 
73 |     findCycle(n);
74 |     return 0;
75 | }
76 | 


--------------------------------------------------------------------------------
/SRBD/Diving for Gold.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<stdio.h>
 3 | #include<string.h>
 4 | #define MX 105
 5 | using namespace std;
 6 | 
 7 | int cap, w, n;
 8 | int bin[MX], d[MX], v[MX];
 9 | int path[MX], mx = -1;
10 | 
11 | void update()
12 | {
13 |     int sum = 0;
14 |     for(int i=0; i<n; i++)
15 |     {
16 |         if(bin[i])
17 |         {
18 |             sum += v[i];
19 |             if(sum > mx)
20 |             {
21 |                 //cout<<sum<<endl;
22 |                 mx = sum;
23 |                 for(int j=0; j<n; j++)
24 |                     path[i] = bin[i];
25 |             }
26 |         }
27 |     }
28 | }
29 | 
30 | void solve(int i, int sum)
31 | {
32 |     if(i==n)
33 |     {
34 |         update();
35 |         return;
36 |     }
37 | 
38 |     bin[i] = 0;
39 |     solve(i+1, sum);
40 | 
41 |     bin[i] = 1;
42 |     if(cap >= sum + 3*w*d[i])
43 |         solve(i+1, sum + 3*w*d[i]);
44 | }
45 | 
46 | int main()
47 | {
48 |     int flag = 0;
49 |     freopen("input.txt","r",stdin);
50 |     while(cin>>cap>>w)
51 |     {
52 |         if(flag++)
53 |             cout<<"\n";
54 | 
55 |         cin>>n;
56 |         for(int i=0; i<n; i++)
57 |         {
58 |             cin>>d[i]>>v[i];
59 |         }
60 | 
61 |         mx = -1;
62 |         memset(path, 0, sizeof(path));
63 |         memset(bin, 0, sizeof(path));
64 |         solve(0, 0);
65 | 
66 |         int cnt = 0;
67 |         for(int i=0; i<n; i++)
68 |             if(path[i])
69 |                 cnt++;
70 | 
71 |         cout<<mx<<"\n"<<cnt<<"\n";
72 |         for(int i=0; i<n; i++)
73 |             if(path[i])
74 |                 cout<<d[i]<<" "<<v[i]<<"\n";
75 |     }
76 |     return 0;
77 | }
78 | 


--------------------------------------------------------------------------------
/SRBD/Doctor Probability.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 | 	float pm[100][100] = {0};
 7 | 	float rm[100][100] = {0};
 8 | 	int nodes, e, t;
 9 | 
10 | 	cin >> nodes>>e>>t;
11 | 	int x, y;
12 | 	for (int i = 0; i < e; i++)
13 | 	{
14 | 		cin >> x >> y;
15 | 		cin >> pm[x-1][y-1];
16 | 	}
17 | 
18 | 	rm[0][0] = 1;
19 | 
20 | 	for (int i = 0; i < t/10; i++)  // time
21 | 	{
22 | 		for (int j = 0; j < nodes ; j++)  // nodes
23 | 		{
24 | 			if (rm[i][j] > 0)
25 | 			{
26 | 				for (int k = 0; k < nodes; k++)
27 | 				{
28 | 					rm[i+1][k]  += rm[i][j]*pm[j][k];
29 | 				}
30 | 			}
31 | 		}
32 | 	}
33 | 	float ans = 0;
34 | 	int res;
35 | 	for (int i = 0; i < nodes; i++)
36 | 	{
37 | 		if (rm[t / 10][i] > ans)
38 | 		{
39 | 			ans = rm[t / 10][i];
40 | 			res = i;
41 | 		}
42 | 	}
43 | 	cout << res+1 <<" "<< ans << endl;
44 | 	return 0;
45 | }
46 | 


--------------------------------------------------------------------------------
/SRBD/Electric banner largest two pipe.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string.h>
 3 | #define MX 105
 4 | using namespace std;
 5 | 
 6 | int n, arr[MX];
 7 | int dp[999][999][MX];
 8 | 
 9 | int solve(int p1, int p2, int i, int mx_p)
10 | {
11 |     if(p1 > mx_p || p2 > mx_p || i > n)
12 |         return -1;
13 | 
14 |     if(dp[p1][p2][i] != -1)
15 |         return dp[p1][p2][i];
16 | 
17 |     if(p1==p2)
18 |         dp[p1][p2][i] = max(dp[p1][p2][i], p1);
19 | 
20 |     dp[p1][p2][i] = max(dp[p1][p2][i], solve(p1, p2, i+1, mx_p));
21 |     dp[p1][p2][i] = max(dp[p1][p2][i], solve(p1+arr[i], p2, i+1, mx_p));
22 |     dp[p1][p2][i] = max(dp[p1][p2][i], solve(p1, p2+arr[i], i+1, mx_p));
23 |     return dp[p1][p2][i];
24 | }
25 | 
26 | int main()
27 | {
28 |     int t;
29 |     cin>>t;
30 | 
31 |     while(t--)
32 |     {
33 |         cin>>n;
34 | 
35 |         int sum = 0;
36 |         for(int i=0; i<n; i++)
37 |         {
38 |             cin>>arr[i];
39 |             sum += arr[i];
40 |         }
41 | 
42 |         memset(dp, -1, sizeof(dp));
43 |         int ans = solve(0, 0, 0, sum/2);
44 |         cout<<ans<<"\n";
45 |     }
46 |     return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/SRBD/Endoscope.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<string.h>
  3 | #include<queue>
  4 | #define pii pair<int, int>
  5 | #define MX 1005
  6 | using namespace std;
  7 | 
  8 | int n, m;
  9 | int arr[MX][MX], vis[MX][MX], lev[MX][MX];
 10 | 
 11 | struct point{
 12 |     int up, down, left, right;
 13 | }pipe[MX][MX];
 14 | 
 15 | bool isValid(int x, int y)
 16 | {
 17 |     if(x < n && y < m && x >= 0 && y >= 0 && !vis[x][y])
 18 |         return 1;
 19 |     return 0;
 20 | }
 21 | 
 22 | int bfs(int x, int y, int l)
 23 | {
 24 |     int ans = 1;
 25 |     queue<pii> q;
 26 |     q.push({x, y});
 27 |     vis[x][y] = 1;
 28 |     lev[x][y] = 1;
 29 | 
 30 |     while(!q.empty())
 31 |     {
 32 |         int r = q.front().first;
 33 |         int c = q.front().second;
 34 |         q.pop();
 35 | 
 36 |         if(lev[r][c] < l)
 37 |         {
 38 |             if(isValid(r+1, c) && pipe[r+1][c].up && pipe[r][c].down)
 39 |             {
 40 |                 q.push({r+1, c});
 41 |                 vis[r+1][c] = 1;
 42 |                 lev[r+1][c] = lev[r][c] + 1;
 43 |                 ans++;
 44 |             }
 45 |             if(isValid(r-1, c) && pipe[r-1][c].down && pipe[r][c].up)
 46 |             {
 47 |                 q.push({r-1, c});
 48 |                 vis[r-1][c] = 1;
 49 |                 lev[r-1][c] = lev[r][c] + 1;
 50 |                 ans++;
 51 |             }
 52 |             if(isValid(r, c+1) && pipe[r][c+1].left && pipe[r][c].right)
 53 |             {
 54 |                 q.push({r, c+1});
 55 |                 vis[r][c+1] = 1;
 56 |                 lev[r][c+1] = lev[r][c] + 1;
 57 |                 ans++;
 58 |             }
 59 |             if(isValid(r, c-1) && pipe[r][c-1].right && pipe[r][c].left)
 60 |             {
 61 |                 q.push({r, c-1});
 62 |                 vis[r][c-1] = 1;
 63 |                 lev[r][c-1] = lev[r][c] + 1;
 64 |                 ans++;
 65 |             }
 66 |         }
 67 |     }
 68 |     return ans;
 69 | }
 70 | 
 71 | int main()
 72 | {
 73 |     int t;
 74 |     cin>>t;
 75 | 
 76 |     while(t--)
 77 |     {
 78 |         int x, y, l;
 79 |         cin>>n>>m>>x>>y>>l;
 80 | 
 81 |         for(int i=0; i<n; i++)
 82 |         {
 83 |             for(int j=0; j<m; j++)
 84 |             {
 85 |                 cin>>arr[i][j];
 86 | 
 87 |                 if( arr[i][j] == 1 )
 88 |                 {
 89 |                     pipe[i][j].left = true;
 90 |                     pipe[i][j].right = true;
 91 |                     pipe[i][j].up = true;
 92 |                     pipe[i][j].down = true;
 93 |                 }
 94 |                 else if( arr[i][j] == 2 )
 95 |                 {
 96 |                     pipe[i][j].left = false;
 97 |                     pipe[i][j].right = false;
 98 |                     pipe[i][j].up = true;
 99 |                     pipe[i][j].down = true;
100 |                 }
101 |                 else if( arr[i][j] == 3 )
102 |                 {
103 |                     pipe[i][j].left = true;
104 |                     pipe[i][j].right = true;
105 |                     pipe[i][j].up = false;
106 |                     pipe[i][j].down = false;
107 |                 }
108 |                 else if( arr[i][j] == 4 )
109 |                 {
110 |                     pipe[i][j].left = false;
111 |                     pipe[i][j].right = true;
112 |                     pipe[i][j].up = true;
113 |                     pipe[i][j].down = false;
114 |                 }
115 |                 else if( arr[i][j] == 5 )
116 |                 {
117 |                     pipe[i][j].left = false;
118 |                     pipe[i][j].right = true;
119 |                     pipe[i][j].up = false;
120 |                     pipe[i][j].down = true;
121 |                 }
122 |                 else if( arr[i][j] == 6 )
123 |                 {
124 |                     pipe[i][j].left = true;
125 |                     pipe[i][j].right = false;
126 |                     pipe[i][j].up = false;
127 |                     pipe[i][j].down = true;
128 |                 }
129 |                 else if( arr[i][j] == 7 )
130 |                 {
131 |                     pipe[i][j].left = true;
132 |                     pipe[i][j].right = false;
133 |                     pipe[i][j].up = true;
134 |                     pipe[i][j].down = false;
135 |                 }
136 |                 else
137 |                 {
138 |                     pipe[i][j].left = false;
139 |                     pipe[i][j].right = false;
140 |                     pipe[i][j].up = false;
141 |                     pipe[i][j].down = false;
142 |                 }
143 |             }
144 |         }
145 | 
146 |         memset(vis, 0, sizeof(vis));
147 |         int ans = bfs(x, y, l);
148 |         cout<<ans<<"\n";
149 |     }
150 |     return 0;
151 | }
152 | 
153 | 


--------------------------------------------------------------------------------
/SRBD/Endscopes.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<string.h>
  3 | #include<stdio.h>
  4 | #define MX 1005
  5 | 
  6 | using namespace std;
  7 | 
  8 | int n, m, frnt = - 1, rear = -1;
  9 | int vis[MX][MX], level[MX][MX], arr[MX][MX];
 10 | 
 11 | struct node
 12 | {
 13 |     bool up, down, left, right;
 14 | } pipes[MX][MX];
 15 | 
 16 | struct point
 17 | {
 18 |     int x, y;
 19 | } que[1000005];
 20 | 
 21 | void push(int a, int b)
 22 | {
 23 |     if(frnt==-1)
 24 |         frnt = 0;
 25 |     rear++;
 26 |     rear = rear % 1000005;
 27 | 
 28 |     que[rear].x = a;
 29 |     que[rear].y = b;
 30 |     //cout<<level[a][b]<<endl;
 31 | }
 32 | 
 33 | void pop()
 34 | {
 35 |     frnt++;
 36 |     frnt = frnt % 1000005;
 37 | }
 38 | 
 39 | bool isEmpty()
 40 | {
 41 |     if(frnt==-1 || rear < frnt)
 42 |         return 1;
 43 |     return 0;
 44 | }
 45 | 
 46 | void init()
 47 | {
 48 |     memset(arr, 0, sizeof(arr));
 49 |     memset(vis, 0, sizeof(vis));
 50 |     memset(level, 0, sizeof(level));
 51 | }
 52 | 
 53 | bool isValid(int x, int y)
 54 | {
 55 |     if(x < n && y < m && x >= 0 && y >= 0)
 56 |         return 1;
 57 |     return 0;
 58 | }
 59 | 
 60 | int bfs(int r, int c, int l)
 61 | {
 62 |     if(arr[r][c]==0)
 63 |         return 0;
 64 | 
 65 |     push(r, c);
 66 |     vis[r][c] = 1;
 67 |     level[r][c] = 1;
 68 | 
 69 |     int ans = 1;
 70 |     while(!isEmpty())
 71 |     {
 72 |         int p = que[frnt].x;
 73 |         int q = que[frnt].y;
 74 |         pop();
 75 | 
 76 |         if(level[p][q] < l)
 77 |         {
 78 |             /* Row Up */
 79 |             if(isValid(p-1, q) && vis[p-1][q]==0 && pipes[p-1][q].down && pipes[p][q].up)
 80 |             {
 81 |                 vis[p-1][q] = 1;
 82 |                 level[p-1][q] = level[p][q] + 1;
 83 |                 ans++;
 84 |                 push(p-1, q);
 85 |             }
 86 |             /* Row down */
 87 |             if(isValid(p+1, q) && vis[p+1][q]==0 && pipes[p+1][q].up && pipes[p][q].down)
 88 |             {
 89 |                 vis[p+1][q] = 1;
 90 |                 level[p+1][q] = level[p][q] + 1;
 91 |                 ans++;
 92 |                 push(p+1, q);
 93 |             }
 94 |             /* Row left */
 95 |             if(isValid(p, q-1) && vis[p][q-1]==0 && pipes[p][q-1].right && pipes[p][q].left)
 96 |             {
 97 |                 vis[p][q-1] = 1;
 98 |                 level[p][q-1] = level[p][q] + 1;
 99 |                 ans++;
100 |                 push(p, q-1);
101 |             }
102 |             if(isValid(p, q+1) && vis[p][q+1]==0 && pipes[p][q+1].left && pipes[p][q].right)
103 |             {
104 |                 vis[p][q+1] = 1;
105 |                 level[p][q+1] = level[p][q] + 1;
106 |                 ans++;
107 |                 push(p, q+1);
108 |             }
109 |         }
110 |     }
111 |     return ans;
112 | }
113 | 
114 | int main()
115 | {
116 |     //freopen("input.txt", "r", stdin);
117 | 
118 |     int t;
119 |     cin>>t;
120 | 
121 |     while(t--)
122 |     {
123 |         int r, c, l;
124 |         cin>>n>>m>>r>>c>>l;
125 | 
126 |         init();
127 |         for(int i=0; i<n; i++)
128 |         {
129 |             for(int j=0; j<m; j++)
130 |             {
131 |                 cin>>arr[i][j];
132 | 
133 |                 if( arr[i][j] == 1 )
134 |                 {
135 |                     pipes[i][j].left = true;
136 |                     pipes[i][j].right = true;
137 |                     pipes[i][j].up = true;
138 |                     pipes[i][j].down = true;
139 |                 }
140 |                 else if( arr[i][j] == 2 )
141 |                 {
142 |                     pipes[i][j].left = false;
143 |                     pipes[i][j].right = false;
144 |                     pipes[i][j].up = true;
145 |                     pipes[i][j].down = true;
146 |                 }
147 |                 else if( arr[i][j] == 3 )
148 |                 {
149 |                     pipes[i][j].left = true;
150 |                     pipes[i][j].right = true;
151 |                     pipes[i][j].up = false;
152 |                     pipes[i][j].down = false;
153 |                 }
154 |                 else if( arr[i][j] == 4 )
155 |                 {
156 |                     pipes[i][j].left = false;
157 |                     pipes[i][j].right = true;
158 |                     pipes[i][j].up = true;
159 |                     pipes[i][j].down = false;
160 |                 }
161 |                 else if( arr[i][j] == 5 )
162 |                 {
163 |                     pipes[i][j].left = false;
164 |                     pipes[i][j].right = true;
165 |                     pipes[i][j].up = false;
166 |                     pipes[i][j].down = true;
167 |                 }
168 |                 else if( arr[i][j] == 6 )
169 |                 {
170 |                     pipes[i][j].left = true;
171 |                     pipes[i][j].right = false;
172 |                     pipes[i][j].up = false;
173 |                     pipes[i][j].down = true;
174 |                 }
175 |                 else if( arr[i][j] == 7 )
176 |                 {
177 |                     pipes[i][j].left = true;
178 |                     pipes[i][j].right = false;
179 |                     pipes[i][j].up = true;
180 |                     pipes[i][j].down = false;
181 |                 }
182 |                 else
183 |                 {
184 |                     pipes[i][j].left = false;
185 |                     pipes[i][j].right = false;
186 |                     pipes[i][j].up = false;
187 |                     pipes[i][j].down = false;
188 |                 }
189 |             }
190 |         }
191 | 
192 |         int ans = bfs(r, c, l);
193 |         cout<<ans<<"\n";
194 |     }
195 |     return 0;
196 | }
197 | 


--------------------------------------------------------------------------------
/SRBD/Find the smallest positive number.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string.h>
 3 | #define MX 10000005
 4 | using namespace std;
 5 | 
 6 | bool vis[MX];
 7 | 
 8 | int main()
 9 | {
10 |     int t;
11 |     cin>>t;
12 | 
13 |     while(t--)
14 |     {
15 |         int n, a;
16 |         cin>>n;
17 | 
18 |         memset(vis, 0, sizeof(vis));
19 |         for(int i=0; i<n; i++)
20 |         {
21 |             cin>>a;
22 |             vis[a] = 1;
23 |         }
24 | 
25 |         int ans = n+1;
26 |         for(int i=1; i<=n; i++)
27 |         {
28 |             if(!vis[i])
29 |             {
30 |                 ans = i; // ans array use for all missing
31 |                 break;// this code for smallest positive
32 |             }
33 |         }
34 |         cout<<ans<<"\n";
35 |     }
36 |     return 0;
37 | }
38 | 


--------------------------------------------------------------------------------
/SRBD/Fishery Gates.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<string.h>
  3 | #include <stdlib.h>
  4 | #include<stdio.h>
  5 | #define MX 1005
  6 | #define INF 99999999
  7 | using namespace std;
  8 | 
  9 | int n, val[4], pos[4];
 10 | int vis[MX], ans;
 11 | 
 12 | int posLeft(int id)
 13 | {
 14 |     for(int i=id-1; i>0; i--)
 15 |         if(vis[i]==0)
 16 |             return i;
 17 |     return INF;
 18 | }
 19 | 
 20 | int posRight(int id)
 21 | {
 22 |     for(int i=id; i<=n; i++)
 23 |         if(vis[i]==0)
 24 |             return i;
 25 |     return INF;
 26 | }
 27 | 
 28 | void solve(int x, int y, int z, int curr, int cost)
 29 | {
 30 |     if(cost > ans)
 31 |         return;
 32 | 
 33 |     if(val[curr]==0)
 34 |     {
 35 |         if(curr==x)
 36 |             curr = y;
 37 |         else if(curr==y)
 38 |             curr = z;
 39 |         else{
 40 |             ans = min(ans, cost);
 41 |             return;
 42 |         }
 43 |     }
 44 | 
 45 |     int l = posLeft(pos[curr]);
 46 |     int r = posRight(pos[curr]);
 47 |     int ll = abs(pos[curr] - l + 1), rr = abs(r - pos[curr] + 1);
 48 | 
 49 |     int dist, tmp = min(ll, rr);
 50 |     if(ll > rr)
 51 |         dist = r;
 52 |     else
 53 |         dist = l;
 54 | 
 55 |     if(val[curr]==1 && rr==ll)
 56 |     {
 57 |         vis[l] = 1;
 58 |         val[curr]--;
 59 |         solve(x, y, z, curr, cost+ll);
 60 |         val[curr]++;
 61 |         vis[l] = 0;
 62 | 
 63 |         vis[r] = 1;
 64 |         val[curr]--;
 65 |         solve(x, y, z, curr, cost+rr);
 66 |         val[curr]++;
 67 |         vis[r] = 0;
 68 |     }
 69 |     else
 70 |     {
 71 |         vis[dist] = 1;
 72 |         val[curr]--;
 73 |         solve(x, y, z, curr, cost+tmp);
 74 |         val[curr]++;
 75 |         vis[dist] = 0;
 76 |     }
 77 | }
 78 | 
 79 | int main()
 80 | {
 81 |     int t=1;
 82 |    // cin>>t;
 83 | 
 84 |     while(t--)
 85 |     {
 86 |         cin>>n;
 87 |         for(int i=1; i<4; i++)
 88 |             cin>>pos[i];
 89 |         for(int i=1; i<4; i++)
 90 |             cin>>val[i];
 91 | 
 92 |         ans = INF;
 93 |         memset(vis, 0, sizeof(vis));
 94 |         solve(1, 2, 3, 1, 0);
 95 |         memset(vis, 0, sizeof(vis));
 96 |         solve(1, 3, 2, 1, 0);
 97 |         memset(vis, 0, sizeof(vis));
 98 |         solve(2, 1, 3, 2, 0);
 99 |         memset(vis, 0, sizeof(vis));
100 |         solve(2, 3, 1, 2, 0);
101 |         memset(vis, 0, sizeof(vis));
102 |         solve(3, 1, 2, 3, 0);
103 |         memset(vis, 0, sizeof(vis));
104 |         solve(3, 2, 1, 3, 0);
105 |         cout<<ans<<"\n";
106 |     }
107 |     return 0;
108 | }
109 | 
110 | /*
111 | inputs
112 | 5
113 | 10
114 | 4 5
115 | 6 2
116 | 10 2
117 | 10
118 | 8 5
119 | 9 1
120 | 10 2
121 | 24
122 | 15 3
123 | 20 4
124 | 23 7
125 | 39
126 | 17 8
127 | 30 5
128 | 31 9
129 | 60
130 | 57 12
131 | 31 19
132 | 38 16
133 | outputs
134 | 18
135 | 25
136 | 57
137 | 86
138 | 339
139 | */
140 | 
141 | 


--------------------------------------------------------------------------------
/SRBD/Flip Columns.CPP:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #define MX 16
 3 | using namespace std;
 4 | 
 5 | int mx = 0;
 6 | int arr[MX][MX];
 7 | 
 8 | void flip(int n, int m, int j)
 9 | {
10 |     for(int i=0; i<n; i++)
11 |     {
12 |         arr[i][j] = 1 - arr[i][j];
13 |     }
14 | }
15 | 
16 | void solve(int n, int m, int k)
17 | {
18 |     if(k == 0)
19 |     {
20 |         int ans = 0;
21 |         for(int i=0; i<n; i++)
22 |         {
23 |             int cnt = 0;
24 |             for(int j=0; j<m; j++)
25 |             {
26 |                 if(arr[i][j]==1)
27 |                     cnt++;
28 |             }
29 |             //cout<<cnt<<endl;
30 |             if(cnt==m)
31 |                ans++;
32 |         }
33 |         //cout<<ans<<endl;
34 |         mx = max(mx, ans);
35 |         return;
36 |     }
37 | 
38 |     for(int i=0; i<m; i++)
39 |     {
40 |         flip(n, m, i);
41 |         //cout<<k<<endl;
42 |         solve(n, m, k-1);
43 |         flip(n, m, i);
44 |     }
45 | }
46 | 
47 | int main()
48 | {
49 |     int n, m, k;
50 |     cin>>n>>m>>k;
51 |     for(int i=0; i<n; i++)
52 |     {
53 |         for(int j=0; j<m; j++)
54 |         {
55 |             cin>>arr[i][j];
56 |         }
57 |     }
58 |     solve(n, m, k);
59 |     cout<<mx<<endl;
60 |     return 0;
61 | }
62 | 


--------------------------------------------------------------------------------
/SRBD/Frog Jump.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string.h>
 3 | #include<queue>
 4 | #define pii pair<int, int>
 5 | #define MX 105
 6 | using namespace std;
 7 | 
 8 | int row, col;
 9 | int vis[MX][MX], adj[MX][MX], level[MX][MX];
10 | 
11 | int dx[] = {0, 1, 0, -1};
12 | int dy[] = {1, 0, -1, 0};
13 | 
14 | bool isValid(int x, int y)
15 | {
16 |     if(x>=0 && x<row && y>=0 && y<col)
17 |         return 1;
18 |     return 0;
19 | }
20 | 
21 | int bfs(int sx, int sy, int ex, int ey)
22 | {
23 |     queue<pii>q;
24 |     q.push({sx, sy});
25 |     vis[sx][sy] = 1;
26 |     level[sx][sy] = 0;
27 | 
28 |     while(!q.empty())
29 |     {
30 |         int x = q.front().first;
31 |         int y = q.front().second;
32 |         q.pop();
33 | 
34 |         if(x==ex && y==ey)
35 |             return level[x][y];
36 | 
37 |         for(int i=0; i<4; i++)
38 |         {
39 |             int xx = x + dx[i];
40 |             int yy = y + dy[i];
41 | 
42 |             if(isValid(xx, yy) && vis[xx][yy]==0)
43 |             {
44 |                 q.push({xx, yy});
45 |                 vis[xx][yy] = 1;
46 | 
47 |                 if(yy==y)
48 |                     level[xx][yy] = level[x][y] + 1;
49 |                 else
50 |                     level[xx][yy] = level[x][y];
51 |             }
52 |         }
53 |     }
54 |     return -1;
55 | }
56 | 
57 | 
58 | int main()
59 | {
60 |     cin>>row>>col;
61 |     for(int i=0; i<row; i++)
62 |         for(int j=0; j<col; j++)
63 |             cin>>adj[i][j];
64 | 
65 |     int sx, sy, ex, ey;
66 |     cin>>sx>>sy>>ex>>ey;
67 | 
68 |     int ans = bfs(sx, sy, ex, ey);
69 |     cout<<ans<<endl;
70 |     return 0;
71 | }
72 | 
73 | 
74 | 


--------------------------------------------------------------------------------
/SRBD/Gasoline and diesel.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | IN COLLABORATION WITH MY FRIEND MOHIT PRESENTS  -> car fueling
  3 | script to generate test cases -> https://ideone.com/9e2nu0
  4 | 
  5 | TEST CASES
  6 | 
  7 | inputs
  8 | 7
  9 | 4
 10 | 1 1 1 1
 11 | 5
 12 | 1 2 1 2 1
 13 | 6
 14 | 1 1 1 2 2 2
 15 | 7
 16 | 1 1 2 1 2 1 1
 17 | 4
 18 | 1 1 1 1
 19 | 3
 20 | 1 2 1
 21 | 8
 22 | 1 2 2 2 1 2 1 1
 23 | outputs
 24 | 8
 25 | 12
 26 | 14
 27 | 22
 28 | 8
 29 | 6
 30 | 32
 31 | */
 32 | 
 33 | #include<iostream>
 34 | using namespace std;
 35 | 
 36 | int n;
 37 | int ans;
 38 | int a[100];
 39 | 
 40 | void solve(int cars, int cost, int index, int type, int fuel)
 41 | {
 42 | 
 43 |     if(cost>ans)return; /* this condition is used to stop the unnecessary recursion */
 44 | 
 45 |     if(cars == n)
 46 |     {
 47 |         ans = min(ans,cost); /* base case when all cars are filled */
 48 |         return;
 49 |     }
 50 | 
 51 |     if(cost > 50)return;  /* this is done to stop the recursion */
 52 | 
 53 |     int temp;
 54 |     temp = (type == 1) ? 1 : -1; /* to check the  direction of robot */
 55 |     int cost2;
 56 |     cost2 = (type == 1) ? index : n-index + 1;
 57 |     int decide;
 58 |     decide = (type == 1) ? 0 : n+1;
 59 | 
 60 |     if(index == 0)
 61 |         solve(cars, cost+1,1, 1,2);
 62 |     else if(index == n+1)
 63 |         solve(cars, cost+1,n, 2,2);
 64 | 
 65 | 
 66 |     else
 67 |     {
 68 |         if(type != a[index])
 69 |         {
 70 |             solve(cars, cost+1, index + temp, type, fuel);
 71 |         }
 72 |         else
 73 |         {
 74 |             if(fuel>0)
 75 |             {
 76 |                 int x  = a[index];
 77 |                 a[index] = 0;
 78 | 
 79 |                 /* fill the car and move in same direction */
 80 |                 solve(cars + 1, cost + 1, index + temp, type, fuel-1);
 81 |                 /* move the car back to same station after filling the car */
 82 |                 solve(cars + 1, cost+cost2, decide, 0, 0);
 83 |                 a[index] = x;
 84 |             }
 85 |             /* else cant be used here this is the heart of recursion
 86 |                if we have fuel and the type is same then also we can
 87 |                chose to move ahead. we can fill the the present cars
 88 |                later. in some test cases it will leads to less
 89 |                final distance covered
 90 |             */
 91 |             solve(cars, cost + 1, index + temp, type, fuel);
 92 |         }
 93 |     }
 94 | 
 95 | }
 96 | 
 97 | int main()
 98 | {
 99 | 
100 |     int t;
101 |     cin>>t;
102 |     while(t--)
103 |     {
104 | 
105 |         cin>>n;
106 |         for(int i = 1; i<=n; i++)cin>>a[i];
107 | 
108 |         ans = 100000;
109 | 
110 |         solve(0,0,0,1,2);
111 |         cout<<ans-1<<endl;
112 |     }
113 |     return 0;
114 | }
115 | 


--------------------------------------------------------------------------------
/SRBD/Graph Coloring.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<stdio.h>
 3 | #include<string.h>
 4 | #define MX 105
 5 | 
 6 | using namespace std;
 7 | 
 8 | int n, m;
 9 | int frnt, rear;
10 | int que[MX], adj[MX][MX], vis[MX];
11 | 
12 | void init()
13 | {
14 |     frnt = rear = 0;
15 |     memset(vis, -1, sizeof(vis));
16 | }
17 | 
18 | void push(int data)
19 | {
20 |     que[rear++] = data;
21 | }
22 | 
23 | int pop()
24 | {
25 |     return que[frnt++];
26 | }
27 | 
28 | bool isempty()
29 | {
30 |     return (frnt==rear);
31 | }
32 | 
33 | int bfs(int s)
34 | {
35 |     push(s);
36 |     vis[s] = 1;
37 | 
38 |     while(!isempty())
39 |     {
40 |         int u = pop();
41 |         for(int i=0; i<n; i++)
42 |         {
43 |             if(vis[i]==-1 && adj[u][i]==1)
44 |             {
45 |                 vis[i] = 1 - vis[u];
46 |                 push(i);
47 |             }
48 |             else if(adj[u][i]==1)
49 |             {
50 |                 if(vis[i]==vis[u])
51 |                     return 0;
52 |             }
53 |         }
54 |     }
55 |     return 1;
56 | }
57 | 
58 | int main()
59 | {
60 |     cin>>n>>m;
61 |     for(int i=0; i<m; i++)
62 |     {
63 |         int a, b;
64 |         scanf("%d%d",&a,&b);
65 |         adj[a][b] = 1;
66 |         adj[b][a] = 1;
67 |     }
68 | 
69 |     init();
70 |     if(bfs(0))
71 |     {
72 |         cout<<"YES\n";
73 |         for(int i=0; i<n; i++)
74 |         {
75 |             if(vis[i] != -1)
76 |                 cout<<i<<" ";
77 |         }
78 |         cout<<"\n";
79 |     }
80 |     else
81 |         cout<<"-1\n";
82 |     return 0;
83 | }
84 | 


--------------------------------------------------------------------------------
/SRBD/K ominos number.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int mp[11] = {0};
 5 | 
 6 | int solve(int num, int times)
 7 | {
 8 |     int cnt = 0;
 9 |     while (num)
10 |     {
11 |         int r = num % 10;
12 |         if (mp[r])
13 |             cnt++;
14 |         num /= 10;
15 |     }
16 | 
17 |     if (cnt >= times)
18 |         return 1;
19 |     return 0;
20 | }
21 | 
22 | int main()
23 | {
24 |     int start, end;
25 |     cin >> start >> end;
26 | 
27 |     int n, a;
28 |     cin >> n;
29 | 
30 |     for (int i = 0; i < n; i++)
31 |     {
32 |         cin >> a;
33 |         mp[a] = 1;
34 |     }
35 | 
36 |     int times;
37 |     cin >> times;
38 | 
39 |     int cnt = 0;
40 |     for (int i = start; i <= end; i++)
41 |     {
42 |         if (solve(i, times))
43 |             cnt++;
44 |     }
45 |     cout << cnt << "\n";
46 |     return 0;
47 | }
48 | 
49 | 


--------------------------------------------------------------------------------
/SRBD/Kim and Refrigerators.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<stdlib.h>
 3 | #define MX 105
 4 | using namespace std;
 5 | 
 6 | struct point{
 7 |     int x, y;
 8 | }adj[MX];
 9 | 
10 | int distance(point a, point b)
11 | {
12 |     int tmp = abs(a.x-b.x) + abs(a.y-b.y);
13 |     return tmp;
14 | }
15 | 
16 | int totalDistance(int n)
17 | {
18 |     int sum = 0;
19 |     for(int i=1; i<n; i++)
20 |         sum += distance(adj[i], adj[i-1]);
21 |     return sum;
22 | }
23 | 
24 | void permutation(int l, int r, point s, point h, int &ans)
25 | {
26 |     if(l==r)
27 |     {
28 |         int tmp = distance(s, adj[0]) + totalDistance(r+1) + distance(h, adj[r]);
29 |         //cout<<ans<<endl;
30 |         ans = min(ans, tmp);
31 |         return;
32 |     }
33 | 
34 |     for(int i=l; i<=r; i++)
35 |     {
36 |         swap(adj[l], adj[i]);
37 |         permutation(l+1, r, s, h, ans);
38 |         swap(adj[l], adj[i]);
39 |     }
40 | }
41 | 
42 | int main()
43 | {
44 |     int t = 10, cas = 0;
45 |     while (t--)
46 |     {
47 |         int q, a, b;
48 |         cin >> q;
49 | 
50 |         point s, h;
51 |         cin >> s.x >> s.y >> h.x >> h.y;
52 | 
53 |         for (int i = 0; i < q; i++)
54 |         {
55 |             cin >> a >> b;
56 |             adj[i].x = a;
57 |             adj[i].y = b;
58 |         }
59 | 
60 |         int ans = distance(s, adj[0]) + totalDistance(q) + distance(h, adj[q - 1]);
61 |         //cout<<ans<<endl;
62 |         permutation(0, q-1, s, h, ans);
63 |         cout <<"# "<< ++cas << " "<<ans << endl;
64 |     }
65 |     return 0;
66 | }
67 | 


--------------------------------------------------------------------------------
/SRBD/LaughingBomb.cpp:
--------------------------------------------------------------------------------
  1 | // Samsung.cpp : This file contains the 'main' function. Program execution begins and ends there.
  2 | //
  3 | 
  4 | #include<iostream>
  5 | #include<stdio.h>
  6 | #include<string.h>
  7 | #define MX 105
  8 | using namespace std;
  9 | 
 10 | int dx[] = { 0, 1, 0, -1 };
 11 | int dy[] = { 1, 0, -1, 0 };
 12 | int n, m, arr[MX][MX];
 13 | 
 14 | int frnt = -1, rear = -1;
 15 | int level[MX][MX];
 16 | 
 17 | struct point {
 18 | 	int x, y;
 19 | }que[MX];
 20 | 
 21 | void push(int a, int b)
 22 | {
 23 | 	if (frnt == -1)
 24 | 		frnt = 0;
 25 | 	rear++;
 26 | 
 27 | 	que[rear].x = a;
 28 | 	que[rear].y = b;
 29 | }
 30 | 
 31 | void pop()
 32 | {
 33 | 	frnt++;
 34 | }
 35 | 
 36 | bool isEmpty()
 37 | {
 38 | 	if (frnt == -1 || rear < frnt)
 39 | 		return 1;
 40 | 	return 0;
 41 | }
 42 | 
 43 | bool isValid(int x, int y)
 44 | {
 45 | 	if (x < m && y < n && x >= 0 && y >= 0)
 46 | 		return 1;
 47 | 	else
 48 | 		return 0;
 49 | }
 50 | 
 51 | int bfs(int sx, int sy)
 52 | {
 53 | 	int ans = 0;
 54 | 	push(sx, sy);
 55 | 	arr[sx][sy] = 1;
 56 | 	level[sx][sy] = 1;
 57 | 
 58 | 	while (!isEmpty())
 59 | 	{
 60 | 		int xx = que[frnt].x;
 61 | 		int yy = que[frnt].y;
 62 | 		pop();
 63 | 
 64 | 		for (int i = 0; i < 4; i++)
 65 | 		{
 66 | 			int ux = xx + dx[i];
 67 | 			int uy = yy + dy[i];
 68 | 
 69 | 			if (isValid(ux, uy) && arr[ux][uy]==1)
 70 | 			{
 71 | 				level[ux][uy] = level[xx][yy] + 1;
 72 | 				arr[ux][uy] = 2;
 73 | 				push(ux, uy);
 74 | 				ans = level[ux][uy];
 75 | 			}
 76 | 		}
 77 | 	}
 78 | 	return ans;
 79 | }
 80 | 
 81 | int main()
 82 | {
 83 | 	int t;
 84 | 	cin >> t;
 85 | 
 86 | 	while (t--)
 87 | 	{
 88 | 		cin >> n >> m;
 89 | 		for (int i = 0; i < m; i++)
 90 | 			for (int j = 0; j < n; j++)
 91 | 				cin >> arr[i][j];
 92 | 
 93 | 		int x, y;
 94 | 		cin >> x >> y;
 95 | 		int ans = bfs(x-1, y-1);
 96 | 		cout << ans << "\n";
 97 | 	}
 98 | 	return 0;
 99 | }
100 | 
101 | // Run program: Ctrl + F5 or Debug > Start Without Debugging menu
102 | // Debug program: F5 or Debug > Start Debugging menu
103 | 
104 | // Tips for Getting Started: 
105 | //   1. Use the Solution Explorer window to add/manage files
106 | //   2. Use the Team Explorer window to connect to source control
107 | //   3. Use the Output window to see build output and other messages
108 | //   4. Use the Error List window to view errors
109 | //   5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
110 | //   6. In the future, to open this project again, go to File > Open > Project and select the .sln file
111 | 


--------------------------------------------------------------------------------
/SRBD/LeargestBST.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class node
 5 | {
 6 | public:
 7 |     int data;
 8 |     node* left;
 9 |     node* right;
10 | 
11 |     node(int data)
12 |     {
13 |         this->data = data;
14 |         this->left = NULL;
15 |         this->right = NULL;
16 |     }
17 | };
18 | 
19 | int isBSTUtil(node* node, int min, int max)
20 | {
21 |     if (node==NULL)
22 |         return 1;
23 | 
24 |     if (node->data < min || node->data > max)
25 |         return 0;
26 | 
27 |     return
28 |         isBSTUtil(node->left, min, node->data-1) && // Allow only distinct values
29 |         isBSTUtil(node->right, node->data+1, max); // Allow only distinct values
30 | }
31 | 
32 | 
33 | int isBST(node* node)
34 | {
35 |     return(isBSTUtil(node, INT_MIN, INT_MAX));
36 | }
37 | 
38 | int sizeOfTree(node* node)
39 | {
40 |     if (node == NULL)
41 |         return 0;
42 |     else
43 |         return(sizeOfTree(node->left) + 1 + sizeOfTree(node->right));
44 | }
45 | 
46 | int largestBST(struct node *root)
47 | {
48 |     if(root == NULL)
49 |         return 0;
50 | 
51 |     if (isBST(root))
52 |         return sizeOfTree(root);
53 |     else
54 |         return max(largestBST(root->left), largestBST(root->right));
55 | }
56 | 
57 | node* insert(int data, node*root)
58 | {
59 |     if(root == NULL)
60 |     {
61 |         node *temp = new node(data);
62 |         return temp;
63 |     }
64 | 
65 |     if(data > root->data) root->right = insert(data, root->right);
66 |     else if(data < root->data) root->left =  insert(data, root->left);
67 |     return root;
68 | }
69 | 
70 | int main()
71 | {
72 |     node *root = new node(4);
73 |     root->left = new node(2);
74 |     root->right = new node(5);
75 |     root->left->left = new node(1);
76 |     root->left->right = new node(3);
77 | 
78 |     root = insert(10, root);
79 | 
80 |     int ans = largestBST(root);
81 |     cout<<ans<<"\n";
82 |     return 0;
83 | }
84 | 
85 | 


--------------------------------------------------------------------------------
/SRBD/Linklist.cpp:
--------------------------------------------------------------------------------
  1 | // Linked list operations in C++
  2 | 
  3 | #include <stdlib.h>
  4 | 
  5 | #include <iostream>
  6 | using namespace std;
  7 | 
  8 | // Create a node
  9 | struct Node {
 10 |   int data;
 11 |   struct Node* next;
 12 | };
 13 | 
 14 | void insertAtBeginning(struct Node** head_ref, int new_data) {
 15 |   // Allocate memory to a node
 16 |   struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
 17 | 
 18 |   // insert the data
 19 |   new_node->data = new_data;
 20 |   new_node->next = (*head_ref);
 21 | 
 22 |   // Move head to new node
 23 |   (*head_ref) = new_node;
 24 | }
 25 | 
 26 | // Insert a node after a node
 27 | void insertAfter(struct Node* prev_node, int new_data) {
 28 |   if (prev_node == NULL) {
 29 |   cout << "the given previous node cannot be NULL";
 30 |   return;
 31 |   }
 32 | 
 33 |   struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
 34 |   new_node->data = new_data;
 35 |   new_node->next = prev_node->next;
 36 |   prev_node->next = new_node;
 37 | }
 38 | 
 39 | // Insert at the end
 40 | void insertAtEnd(struct Node** head_ref, int new_data) {
 41 |   struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
 42 |   struct Node* last = *head_ref; /* used in step 5*/
 43 | 
 44 |   new_node->data = new_data;
 45 |   new_node->next = NULL;
 46 | 
 47 |   if (*head_ref == NULL) {
 48 |   *head_ref = new_node;
 49 |   return;
 50 |   }
 51 | 
 52 |   while (last->next != NULL) last = last->next;
 53 | 
 54 |   last->next = new_node;
 55 |   return;
 56 | }
 57 | 
 58 | // Delete a node
 59 | void deleteNode(struct Node** head_ref, int key) {
 60 |   struct Node *temp = *head_ref, *prev;
 61 | 
 62 |   if (temp != NULL && temp->data == key) {
 63 |   *head_ref = temp->next;
 64 |   free(temp);
 65 |   return;
 66 |   }
 67 |   // Find the key to be deleted
 68 |   while (temp != NULL && temp->data != key) {
 69 |   prev = temp;
 70 |   temp = temp->next;
 71 |   }
 72 | 
 73 |   // If the key is not present
 74 |   if (temp == NULL) return;
 75 | 
 76 |   // Remove the node
 77 |   prev->next = temp->next;
 78 | 
 79 |   free(temp);
 80 | }
 81 | 
 82 | // Search a node
 83 | bool searchNode(struct Node** head_ref, int key) {
 84 |   struct Node* current = *head_ref;
 85 | 
 86 |   while (current != NULL) {
 87 |   if (current->data == key) return true;
 88 |   current = current->next;
 89 |   }
 90 |   return false;
 91 | }
 92 | 
 93 | // Sort the linked list
 94 | void sortLinkedList(struct Node** head_ref) {
 95 |   struct Node *current = *head_ref, *index = NULL;
 96 |   int temp;
 97 | 
 98 |   if (head_ref == NULL) {
 99 |   return;
100 |   } else {
101 |   while (current != NULL) {
102 |     // index points to the node next to current
103 |     index = current->next;
104 | 
105 |     while (index != NULL) {
106 |     if (current->data > index->data) {
107 |       temp = current->data;
108 |       current->data = index->data;
109 |       index->data = temp;
110 |     }
111 |     index = index->next;
112 |     }
113 |     current = current->next;
114 |   }
115 |   }
116 | }
117 | 
118 | // Print the linked list
119 | void printList(struct Node* node) {
120 |   while (node != NULL) {
121 |   cout << node->data << " ";
122 |   node = node->next;
123 |   }
124 | }
125 | 
126 | // Driver program
127 | int main() {
128 |   struct Node* head = NULL;
129 | 
130 |   insertAtEnd(&head, 1);
131 |   insertAtBeginning(&head, 2);
132 |   insertAtBeginning(&head, 3);
133 |   insertAtEnd(&head, 4);
134 |   insertAfter(head->next, 5);
135 | 
136 |   cout << "Linked list: ";
137 |   printList(head);
138 | 
139 |   cout << "\nAfter deleting an element: ";
140 |   deleteNode(&head, 3);
141 |   printList(head);
142 | 
143 |   int item_to_find = 3;
144 |   if (searchNode(&head, item_to_find)) {
145 |   cout << endl << item_to_find << " is found";
146 |   } else {
147 |   cout << endl << item_to_find << " is not found";
148 |   }
149 | 
150 |   sortLinkedList(&head);
151 |   cout << "\nSorted List: ";
152 |   printList(head);
153 | }
154 | 


--------------------------------------------------------------------------------
/SRBD/MR Lee Office.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include<string.h>
 3 | #include <climits>
 4 | #define MAX_N 10
 5 | #define INF 10619567
 6 | using namespace std;
 7 | 
 8 | int w[MAX_N][MAX_N], n;
 9 | int mem[MAX_N][1<<MAX_N];
10 | 
11 | int turnOn(int x, int pos)
12 | {
13 |     return x | (1<<pos);
14 | }
15 | 
16 | bool isOn(int x, int pos)
17 | {
18 |     return (bool)(x & (1<<pos));
19 | }
20 | 
21 | int f(int i, int mask)
22 | {
23 |     if (mask == (1<<n) - 1)
24 |     {
25 |         return w[i][0];
26 |     }
27 | 
28 |     if (mem[i][mask] != -1)
29 |     {
30 |         return mem[i][mask];
31 |     }
32 | 
33 |     int ans = INF;
34 |     for (int j = 0; j < n; j++)
35 |     {
36 |         if (w[i][j] == INF) continue;
37 | 
38 |         if (isOn(mask, j) == 0)
39 |         {
40 |             int result = f(j, turnOn(mask, j)) + w[i][j];
41 |             ans = min(ans, result);
42 |         }
43 |     }
44 |     return mem[i][mask] = ans;
45 | }
46 | 
47 | int main()
48 | {
49 |     int t;
50 |     cin >> t;
51 | 
52 |     while (t--)
53 |     {
54 |         cin>>n;
55 |         cout<< (1<<n) <<endl;
56 | 
57 |         for (int i = 0; i < n; i++)
58 |             for (int j = 0; j < n; j++)
59 |             {
60 |                 cin >> w[i][j];
61 |                 if(w[i][j]==0)
62 |                     w[i][j] = INF;
63 |             }
64 | 
65 |         memset(mem, -1, sizeof(mem));
66 |         int ans = f(0, 1);
67 |         cout << ans << "\n";
68 |     }
69 |     return 0;
70 | }
71 | 
72 | 


--------------------------------------------------------------------------------
/SRBD/Marge Sort.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | void Merge(long long arr[], int l, int m, int h)
 5 | {
 6 |     int i, j, k;
 7 |     int n1 = m - l + 1;
 8 |     int n2 = h - m;
 9 |     long long L[n1], R[n2];
10 | 
11 |     for (i = 0; i < n1; i++) L[i] = arr[l + i];
12 |     for (j = 0; j < n2; j++) R[j] = arr[m + 1 + j];
13 | 
14 |     i = 0, j = 0, k = l;
15 |     while (i < n1 && j < n2)
16 |     {
17 |         if (L[i] <= R[j])
18 |         {
19 |             arr[k] = L[i];
20 |             i++;
21 |         }
22 |         else
23 |         {
24 |             arr[k] = R[j];
25 |             j++;
26 |         }
27 |         k++;
28 |     }
29 | 
30 |     while (i < n1)
31 |     {
32 |         arr[k] = L[i];
33 |         i++;
34 |         k++;
35 |     }
36 | 
37 |     while (j < n2)
38 |     {
39 |         arr[k] = R[j];
40 |         j++;
41 |         k++;
42 |     }
43 | }
44 | 
45 | void mergeSort(long long arr[], int l, int h)
46 | {
47 |     if(l<h)
48 |     {
49 |         int m = l+(h-l)/2;
50 |         mergeSort(arr, l, m);
51 |         mergeSort(arr, m+1, h);
52 |         Merge(arr, l, m, h);
53 |     }
54 | }
55 | 
56 | int main()
57 | {
58 |     int n;
59 |     cin>>n;
60 | 
61 |     long long arr[n];
62 |     for(int i=0; i<n; i++)
63 |     {
64 |         cin>>arr[i];
65 |     }
66 | 
67 |     mergeSort(arr, 0, n);
68 |     for(int i=0; i<n; i++)
69 |         cout<<arr[i]<<" ";
70 |     cout<<endl;
71 | 
72 |     return 0;
73 | }
74 | 


--------------------------------------------------------------------------------
/SRBD/Maze and  Jewels.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<string.h>
  3 | #include<stdio.h>
  4 | #define MX 105
  5 | using namespace std;
  6 | 
  7 | int row, col, mx = 0;
  8 | int ans[MX][MX], adj[MX][MX];;
  9 | 
 10 | int dx[] = {0, 1, 0, -1};
 11 | int dy[] = {1, 0, -1, 0};
 12 | 
 13 | bool isValid(int x, int y)
 14 | {
 15 |     if(x>=0 && x<row && y>=0 && y<col)
 16 |         return 1;
 17 |     return 0;
 18 | }
 19 | 
 20 | int dfs(int sx, int sy, int cnt)
 21 | {
 22 |     if(sx==row-1 && sy==row-1)
 23 |     {
 24 |         if(cnt > mx)
 25 |         {
 26 |             mx = cnt;
 27 |             for(int i=0; i<row; i++)
 28 |             {
 29 |                 for(int j=0; j<col; j++)
 30 |                 {
 31 |                     ans[i][j] = adj[i][j];
 32 |                 }
 33 |             }
 34 |         }
 35 |     }
 36 | 
 37 |     for(int i=0; i<4; i++)
 38 |     {
 39 |         int ux = sx + dx[i];
 40 |         int uy = sy + dy[i];
 41 | 
 42 |         if(isValid(ux, uy) && (adj[ux][uy]==2 || adj[ux][uy]==0))
 43 |         {
 44 |             int check;
 45 |             if(adj[ux][uy]==2)
 46 |                 check = 1;
 47 |             else
 48 |                 check = 0;
 49 | 
 50 |             adj[ux][uy] = 3;
 51 |             dfs(ux, uy, cnt+check);
 52 | 
 53 |             if(check==1)
 54 |                 adj[ux][uy] = 2;
 55 |             else
 56 |                 adj[ux][uy] = 0;
 57 |         }
 58 |     }
 59 | }
 60 | 
 61 | 
 62 | int main()
 63 | {
 64 |     //freopen("input.txt","r",stdin);
 65 |     int t;
 66 |     cin>>t;
 67 | 
 68 |     while(t--)
 69 |     {
 70 |         cin>>row;
 71 |         col = row;
 72 | 
 73 |         for(int i=0; i<row; i++)
 74 |         {
 75 |             for(int j=0; j<col; j++)
 76 |             {
 77 |                 cin>>adj[i][j];
 78 |             }
 79 |         }
 80 | 
 81 |         mx = 0;
 82 |         adj[0][0] = 3;
 83 |         dfs(0,0,0);
 84 | 
 85 |         for(int i=0; i<row; i++)
 86 |         {
 87 |             for(int j=0; j<col; j++)
 88 |             {
 89 |                 cout<<ans[i][j]<<" ";
 90 |             }
 91 |             cout<<"\n";
 92 |         }
 93 |         cout<<mx<<"\n";
 94 |     }
 95 |     return 0;
 96 | }
 97 | 
 98 | /*
 99 | remember the fucking indexing
100 | 2
101 | 5
102 | 0 0 0 2 0
103 | 2 1 0 1 2
104 | 0 0 2 2 0
105 | 0 1 0 1 2
106 | 2 0 0 0 0
107 | 6
108 | 0 1 2 1 0 0
109 | 0 1 0 0 0 1
110 | 0 1 2 1 2 1
111 | 0 2 0 1 0 2
112 | 0 1 0 1 0 1
113 | 2 0 2 1 0 0
114 | 
115 | output:
116 | Case #1
117 | 
118 | 3 0 3 3 3
119 | 3 1 3 1 3
120 | 3 0 3 2 3
121 | 3 1 3 1 3
122 | 3 3 3 0 3
123 | 6
124 | 
125 | Case #2
126 | 
127 | 3 1 2 1 0 0
128 | 3 1 3 3 3 1
129 | 3 1 3 1 3 1
130 | 3 2 3 1 3 2
131 | 3 1 3 1 3 1
132 | 3 3 3 1 3 3
133 | 4
134 | */
135 | 


--------------------------------------------------------------------------------
/SRBD/Mr Kim refrigerators.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include<stdlib.h>
 3 | #define MX 25
 4 | using namespace std;
 5 | 
 6 | struct point {
 7 |     int x, y;
 8 | }adj[MX];
 9 | 
10 | int distance(point a, point b)
11 | {
12 |     return abs(a.x - b.x) + abs(a.y - b.y);
13 | }
14 | 
15 | void Swap(point &a, point &b)
16 | {
17 |     point t = a;
18 |     a = b;
19 |     b = t;
20 | }
21 | 
22 | int totalDistance(int n)
23 | {
24 |     int sum = 0;
25 |     for (int i = 1; i < n; i++)
26 |     {
27 |         sum += distance(adj[i - 1], adj[i]);
28 |     }
29 |     return sum;
30 | }
31 | 
32 | void permutation(point adj[], int l, int r, point s, point h, int &ans)
33 | {
34 |     if (l == r)
35 |     {
36 |         int tmp = distance(s, adj[0]) + totalDistance(r+1) + distance(h, adj[r]);
37 |         //cout<<tmp<<endl;
38 |         ans = min(ans, tmp);
39 |         return;
40 |     }
41 |     else
42 |     {
43 |         for (int i = l; i <= r; i++)
44 |         {
45 |             Swap(adj[l], adj[i]);
46 |             permutation(adj, l + 1, r, s, h, ans);
47 |             Swap(adj[l], adj[i]);
48 |         }
49 |     }
50 | }
51 | 
52 | int main()
53 | {
54 |     //freopen("input.txt","r", stdin);
55 |     int t;
56 |     cin >> t;
57 | 
58 |     while (t--)
59 |     {
60 |         int q, a, b;
61 |         cin >> q;
62 | 
63 |         point s, h;
64 |         cin >> s.x >> s.y >> h.x >> h.y;
65 | 
66 |         for (int i = 0; i < q; i++)
67 |         {
68 |             cin >> a >> b;
69 |             adj[i].x = a;
70 |             adj[i].y = b;
71 |         }
72 | 
73 |         int ans = distance(s, adj[0]) + totalDistance(q) + distance(h, adj[q - 1]);
74 |         permutation(adj, 0, q-1, s, h, ans);
75 |         cout <<"The shortest path has length "<< ans << endl;
76 |     }
77 |     return 0;
78 | }
79 | 


--------------------------------------------------------------------------------
/SRBD/Oil mine.cpp:
--------------------------------------------------------------------------------
 1 | include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int n,c;
 5 | int a[100];
 6 | int b[100];
 7 | int pre[100];
 8 | int dp[100][100][2];
 9 | 
10 | /* fn to precompute the prefix */
11 | void sum()
12 | {
13 |     for(int i=1; i<=n; i++)
14 |         pre[i] = a[i] + pre[i-1];
15 | }
16 | 
17 | int solve()
18 | {
19 |     for(int j = 1; j<=n; j++)
20 |     {
21 |         for(int k = 1; k<=c && k<=j; k++)
22 |         {
23 |             /* Base case */
24 |             if(k == 1)
25 |             {
26 |                 dp[j][k][0] =  pre[j];
27 |                 dp[j][k][1] =  pre[j];
28 |             }
29 |             else
30 |             {
31 |                 int temp = INT_MAX;
32 |                 for(int l = j; l>k-1; l--)
33 |                 {
34 |                     /* magic happens here */
35 |                     int mn = min((pre[j]-pre[l-1]), min(dp[l-1][k-1][0], dp[l-1][k-1][1]));
36 |                     int mx = max((pre[j]-pre[l-1]), max(dp[l-1][k-1][0], dp[l-1][k-1][1]));
37 | 
38 |                     if(mx-mn < temp)
39 |                     {
40 |                         temp = mx - mn;
41 |                         dp[j][k][0] = mn;
42 |                         dp[j][k][1] = mx;
43 |                     }
44 |                 }
45 |             }
46 |         }
47 |     }
48 |     //cout<<dp[2][2][0]<<" "<<dp[2][2][1]<<endl;
49 |     return dp[n][c][1] - dp[n][c][0];
50 | }
51 | 
52 | 
53 | int main()
54 | {
55 |     freopen("input.txt","r",stdin);
56 |     int t;
57 |     cin>>t;
58 |     while(t--)
59 |     {
60 |         cin>>c;
61 |         cin>>n;
62 | 
63 |         for(int i = 1; i<=n; i++)cin>>b[i];
64 |         /* this is done to iterate for every window size of a circular array */
65 |         for(int i = n+1; i<=2*n; i++)b[i] = b[i-n];
66 | 
67 |         int ans = INT_MAX;
68 |         for(int i = 1; i<=n+1; i++)
69 |         {
70 |             int j = i+n-1;
71 |             memset(dp,0,sizeof(dp));
72 |             memset(pre, 0, sizeof(pre));
73 | 
74 |             /* this is done so that we don't have to map the index
75 |              due to this everytime the indexing will be from 1-n */
76 |             int temp  = 1;
77 |             for(int k = i; k<=j; k++)
78 |             {
79 |                 a[temp] = b[k];
80 |                 temp++;
81 |             }
82 | 
83 |             sum();
84 |             ans = min(ans, solve());
85 |         }
86 |         if(c>n)ans = -1;
87 |         cout<<ans<<endl;
88 |     }
89 | }
90 | 


--------------------------------------------------------------------------------
/SRBD/Physical energy.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string.h>
 3 | #include<stdio.h>
 4 | #define MX 105
 5 | #define INF 1000000
 6 | 
 7 | using namespace std;
 8 | 
 9 | int cost[MX], time[MX];
10 | int dp[4040][1010][5];
11 | 
12 | int solve(int h, int d, int n)
13 | {
14 |     if(h < 0 || n==0)
15 |         return INF;
16 | 
17 |     if(d==0)
18 |         return 0;
19 | 
20 |     if (dp[h][d][n] != -1)
21 |         return dp[h][d][n];
22 | 
23 |     return dp[h][d][n] = min(solve(h, d, n-1), time[n-1] + solve(h-cost[n-1], d-1, n));
24 | }
25 | 
26 | int main()
27 | {
28 |     freopen("input.txt","r",stdin);
29 |     int n, h, d;
30 |     cin>>n>>h>>d;
31 | 
32 |     for(int i=0; i<n; i++)
33 |     {
34 |         int c, t;
35 |         cin>>c>>t;
36 |         cost[i] = c, time[i] = t;
37 |     }
38 | 
39 |     memset(dp, -1, sizeof(dp));
40 |     int ans = solve(h, d, n);
41 |     cout<<ans<<"\n";
42 |     return 0;
43 | }
44 | 
45 | /*
46 | you are a marathoner. you want to break previous record.
47 | you have given 5 speed and corresponding stamina loss (ex: Speed1: 3 min 20 sec per unit, stamina loss1: 15).
48 | it is possible switch between speed after one unit interval.
49 | your total stamina H(1<=H<=160), you have to run distance D(1<=D<=40).
50 | find minimum time to finish marathon within your stamina(you can't run with stamina<=0).*/
51 | 


--------------------------------------------------------------------------------
/SRBD/Protein Fat Carbohidrat.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<stdio.h>
  3 | #include<string.h>
  4 | #include<vector>
  5 | #include<algorithm>
  6 | #define MX 1000
  7 | #define pii pair<int, int>
  8 | using namespace std;
  9 | 
 10 | vector<pii> v;
 11 | vector<int> min_ingredients;
 12 | int  p[MX], f[MX], c[MX];
 13 | 
 14 | void solve(int total, int pt, int ft, int ct)
 15 | {
 16 |     int mn = 999999;
 17 |     for(int i=0; i<v.size(); i++)
 18 |     {
 19 |         //cout<<v[i].first<<" "<<v[i].second<<endl;
 20 |         int sum = 0;
 21 |         vector<int> ans;
 22 | 
 23 |         for(int k=i; k<v.size(); k++)
 24 |         {
 25 |             sum += v[k].first;
 26 | 
 27 |             if(sum > total)
 28 |                 sum -= v[k].first;
 29 |             else if(sum < total)
 30 |                 ans.push_back(v[k].second);
 31 |             else
 32 |             {
 33 |                 ans.push_back(v[k].second);
 34 |                 int ck = 0, ppt = 0, fft = 0, cct = 0;
 35 | 
 36 |                 for(int j=0; j<ans.size(); j++)
 37 |                 {
 38 |                     //cout<<ans[j]<<endl;
 39 |                     ppt += p[ans[j]-1];
 40 |                     fft += f[ans[j]-1];
 41 |                     cct += c[ans[j]-1];
 42 |                 }
 43 | 
 44 |                 if(ppt==pt && fft==ft && cct==ct)
 45 |                     ck = 1;
 46 | 
 47 |                 if(ck && mn > ans.size())
 48 |                 {
 49 |                     mn = ans.size();
 50 |                     min_ingredients = ans;
 51 |                     //cout<<mn<<endl;
 52 |                 }
 53 |             }
 54 |         }
 55 |     }
 56 |     return;
 57 | }
 58 | 
 59 | bool cmp(pii a, pii b)
 60 | {
 61 |     if(a.first==b.first)
 62 |         return a.second < b.second;
 63 |     return a.first > b.first;
 64 | }
 65 | 
 66 | int main()
 67 | {
 68 |     freopen("input.txt","r",stdin);
 69 |     int t;
 70 |     cin>>t;
 71 | 
 72 |     while(t--)
 73 |     {
 74 |         int ingredients;
 75 |         cin>>ingredients ;
 76 | 
 77 |         for(int i=0; i<ingredients; i++)
 78 |         {
 79 |             cin>>p[i]>>f[i]>>c[i];
 80 | 
 81 |             int sum = p[i]+f[i]+c[i];
 82 |             v.push_back({sum, i+1});
 83 |         }
 84 | 
 85 |         sort(v.begin(), v.end(), cmp);
 86 | 
 87 |         for(int i=0; i<3; i++)
 88 |         {
 89 |             int pt, ft, ct;
 90 |             cin>>pt>>ft>>ct;
 91 | 
 92 |             int total = pt+ft+ct;
 93 |             solve(total, pt, ft, ct);
 94 | 
 95 |             if(min_ingredients.size())
 96 |             {
 97 |                 sort(min_ingredients.begin(), min_ingredients.end());
 98 |                 for(int i=0; i<min_ingredients.size(); i++)
 99 |                 {
100 |                     cout<<min_ingredients[i]<<" ";
101 |                 }
102 |                 cout<<"\n";
103 |                 min_ingredients.clear();
104 |             }
105 |             else
106 |                 cout<<"-1\n";
107 |         }
108 |     }
109 |     return 0;
110 | }
111 | 


--------------------------------------------------------------------------------
/SRBD/Rare Element.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<string.h>
  3 | #include<stdio.h>
  4 | #define MX 1005
  5 | using namespace std;
  6 | 
  7 | int row, col, element;
  8 | int frnt = 0, rear = 0;
  9 | int vis[MX][MX], adj[MX][MX], level[MX][MX];
 10 | 
 11 | int dx[] = {0, 1, 0, -1};
 12 | int dy[] = {1, 0, -1, 0};
 13 | 
 14 | struct point
 15 | {
 16 | 	int x, y;
 17 | } que[MX], loc[MX];
 18 | 
 19 | void init()
 20 | {
 21 |     frnt = rear = 0;
 22 |     memset(vis, 0, sizeof(vis));
 23 | }
 24 | 
 25 | void push(int a, int b)
 26 | {
 27 | 	que[rear].x = a;
 28 | 	que[rear].y = b;
 29 | 	rear++;
 30 | }
 31 | 
 32 | void pop()
 33 | {
 34 | 	frnt++;
 35 | }
 36 | 
 37 | bool isEmpty()
 38 | {
 39 | 	return (frnt == rear);
 40 | }
 41 | 
 42 | bool isValid(int x, int y)
 43 | {
 44 | 	if(x>=0 && x<row && y>=0 && y<col)
 45 |     	return 1;
 46 | 	return 0;
 47 | }
 48 | 
 49 | int bfs(int sx, int sy, int vx, int vy)
 50 | {
 51 | 	push(sx, sy);
 52 | 	vis[sx][sy] = 1;
 53 | 	level[sx][sy] = 0;
 54 | 
 55 | 	while(!isEmpty())
 56 | 	{
 57 |     	int xx = que[frnt].x;
 58 |     	int yy = que[frnt].y;
 59 |     	pop();
 60 | 
 61 |     	if(xx==vx && yy==vy)
 62 |             return level[xx][yy];
 63 | 
 64 |     	for(int i=0; i<4; i++)
 65 |     	{
 66 |         	int ux = xx + dx[i];
 67 |         	int uy = yy + dy[i];
 68 | 
 69 |         	if(vis[ux][uy]==0 && isValid(ux, uy) && adj[ux][uy]==1)
 70 |         	{
 71 |             	vis[ux][uy] = 1;
 72 |             	push(ux, uy);
 73 |             	level[ux][uy] = level[xx][yy] + 1;
 74 |         	}
 75 |     	}
 76 | 	}
 77 | 	return -1;
 78 | }
 79 | 
 80 | 
 81 | int main()
 82 | {
 83 |     freopen("input.txt","r",stdin);
 84 | 	int t;
 85 | 	cin>>t;
 86 | 
 87 | 	while(t--)
 88 | 	{
 89 |     	cin>>row>>element;
 90 |     	col = row;
 91 | 
 92 |     	for(int i=0; i<element; i++)
 93 |     	{
 94 |         	cin>>loc[i].x>>loc[i].y;
 95 |     	}
 96 | 
 97 |     	for(int i=0; i<row; i++)
 98 |     	{
 99 |         	for(int j=0; j<col; j++)
100 |         	{
101 |             	cin>>adj[i][j];
102 |         	}
103 |     	}
104 | 
105 |     	int mx, ans = 100000;
106 |     	for(int i=0; i<row; i++)
107 |     	{
108 |         	for(int j=0; j<col; j++)
109 |         	{
110 |             	if(adj[i][j]==1)
111 |             	{
112 |             	    mx = 0;
113 |             	    for(int k=0; k<element; k++)
114 |                 	{
115 |                 	    init();
116 |                         mx = max(mx, bfs(i, j, loc[k].x-1, loc[k].y-1));
117 |                         //cout<<mx<<endl;
118 |                 	}
119 |                 	ans = min(ans, mx);
120 |             	}
121 |         	}
122 |     	}
123 |     	cout<<ans<<"\n";
124 | 	}
125 | 	return 0;
126 | }
127 | 
128 | /*
129 | remember the indexing
130 | 5
131 | 5 2
132 | 4 3
133 | 3 4
134 | 1 1 0 0 0
135 | 1 1 0 0 0
136 | 1 1 1 1 1
137 | 1 1 1 0 1
138 | 1 1 1 1 1
139 | 8 2
140 | 5 6
141 | 6 4
142 | 1 1 1 1 1 1 0 0
143 | 1 1 1 1 1 1 1 0
144 | 1 1 0 1 0 1 1 0
145 | 1 1 1 1 0 1 1 0
146 | 1 1 1 1 1 1 1 0
147 | 1 1 1 1 1 1 1 0
148 | 0 0 0 0 0 0 0 0
149 | 0 0 0 0 0 0 0 0
150 | 10 3
151 | 8 2
152 | 5 3
153 | 7 1
154 | 0 0 0 1 1 1 1 1 1 0
155 | 1 1 1 1 1 1 1 1 1 0
156 | 1 0 0 1 0 0 0 0 1 0
157 | 1 1 1 1 1 1 1 1 1 1
158 | 1 1 1 1 0 1 0 0 1 1
159 | 1 1 1 1 0 1 0 0 1 1
160 | 1 1 1 1 0 1 0 0 1 1
161 | 1 1 1 1 1 1 1 1 1 1
162 | 1 1 1 0 0 1 0 0 1 1
163 | 1 1 1 1 1 1 1 1 1 1
164 | 15 4
165 | 11 15
166 | 15 9
167 | 1 2
168 | 14 3
169 | 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
170 | 1 0 1 1 1 1 1 1 1 1 1 1 1 0 1
171 | 1 0 1 0 0 0 1 0 0 0 0 1 1 0 1
172 | 1 0 1 0 0 0 1 0 0 0 0 1 1 0 1
173 | 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1
174 | 1 0 1 0 0 0 1 0 0 0 0 1 1 0 1
175 | 1 0 1 0 0 0 1 1 1 1 1 1 1 1 1
176 | 1 0 1 0 0 0 1 0 0 0 0 1 1 0 1
177 | 1 0 1 0 0 0 1 0 0 0 0 1 1 0 1
178 | 1 0 1 0 0 0 1 0 0 0 0 1 1 0 1
179 | 1 0 1 0 0 0 1 0 0 0 0 1 1 0 1
180 | 1 0 1 0 0 0 1 0 0 0 0 1 1 0 1
181 | 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
182 | 0 0 1 0 0 0 1 1 1 1 1 1 1 0 1
183 | 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1
184 | 20 4
185 | 13 6
186 | 20 4
187 | 1 2
188 | 17 16
189 | 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0
190 | 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0
191 | 1 0 1 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0
192 | 1 0 1 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 0 0
193 | 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0
194 | 1 0 1 0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 0 0
195 | 1 0 1 0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 0 0
196 | 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
197 | 1 0 1 0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 1 1
198 | 1 0 1 0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 1 1
199 | 1 0 1 0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 1 1
200 | 1 0 1 0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 1 1
201 | 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1
202 | 1 0 1 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 1 1
203 | 1 0 1 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 1 1
204 | 1 0 1 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 1 1
205 | 1 0 1 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 1 1
206 | 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
207 | 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
208 | 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0
209 | 
210 | Output
211 | #1 1
212 | #2 2
213 | #3 2
214 | #4 12
215 | #5 15
216 | 
217 | 
218 | */
219 | 


--------------------------------------------------------------------------------
/SRBD/Restroom.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<stdio.h>
 3 | using namespace std;
 4 | 
 5 | void solve(int n, int k, int arr[])
 6 | {
 7 |     for(int i=0; i<k; i++)
 8 |     {
 9 |         int cnt = 0, mx = 0, id = 0;
10 |         for(int j=0; j<n; j++)
11 |         {
12 |             if(arr[j]==0)
13 |                 cnt++;
14 |             else
15 |                 cnt = 0;
16 | 
17 |             if(cnt > mx)
18 |             {
19 |                 mx = cnt;
20 |                 id = j;
21 |             }
22 |         }
23 |         int f = id - mx + 1;
24 |         int mid = (f+id)/2;
25 |         arr[mid] = 1;
26 |     }
27 | }
28 | 
29 | int main()
30 | {
31 |     //freopen("input.txt","r",stdin);
32 |     int t;
33 |     cin>>t;
34 | 
35 |     while(t--)
36 |     {
37 |         int n, k;
38 |         cin>>n>>k;
39 | 
40 |         int arr[n];
41 |         for(int i=0; i<n; i++)
42 |             arr[i] = 0;
43 | 
44 |         solve(n, k, arr);
45 |         for(int i=0; i<n; i++)
46 |             cout<<arr[i];
47 |         cout<<"\n";
48 |     }
49 |     return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/SRBD/Rock climbing.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string.h>
 3 | using namespace std;
 4 | 
 5 | int n,m, l = 0, f = 0;
 6 | int a[15][15], v[15][15];
 7 | 
 8 | void dfs(int i, int j)
 9 | {
10 |     if(i<0 || j<0 || i>=n || j>=m) return;
11 |     if(v[i][j]) return;
12 | 
13 |     v[i][j] = 1;
14 |     if(a[i][j]==3)
15 |     {
16 |         f = 1;
17 |         return;
18 |     }
19 | 
20 |     if(j+1<m && (a[i][j+1]==1 || a[i][j+1]==3) && v[i][j+1]==0)
21 |         dfs(i, j+1);
22 | 
23 |     if(j-1>=0 && (a[i][j-1]==1 || a[i][j-1]==3) && v[i][j-1]==0)
24 |         dfs(i, j-1);
25 | 
26 |     int h = 1;
27 |     for(h=1; h<=l; h++)
28 |         if(h<=l && i-h>=0 && (a[i-h][j]==1 || a[i-h][j]==3) && v[i-h][j]==0)
29 |             dfs(i-h, j);
30 | 
31 |     for(h = 1; h<=l; h++)
32 |         if(h<=l && i+h<n && (a[i+h][j]==1 || a[i+h][j]==3) && v[i+h][j]==0)
33 |             dfs(i+h, j);
34 | }
35 | 
36 | int main()
37 | {
38 |     cin>>n>>m;
39 |     for(int i=0; i<n; i++)
40 |         for(int j=0; j<m; j++)
41 |             cin>>a[i][j];
42 | 
43 |     for(l=0; l<n; l++)
44 |     {
45 |         memset(v, 0, sizeof(v));
46 |         f = 0;
47 |         dfs(n-1, 0);
48 |         if(f)
49 |         {
50 |             cout<<l;
51 |             break;
52 |         }
53 |     }
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/SRBD/Spaceship Bomb.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | // spaceship bomb
 3 | #include<bits/stdc++.h>
 4 | using namespace std;
 5 | #define INT_MIN -1000007
 6 | int ans = INT_MIN;
 7 | 
 8 | void solve(int board[][5], int i, int j, bool bombUsed, int rowValid, int coins){
 9 | 	if(i<0 || j<0 || j>=5){
10 |     	ans = max(ans, coins);
11 |     	return;
12 | 	}
13 | 	if(board[i][j] == 1 || board[i][j] == 0){
14 |     	if(board[i][j] ==1){
15 |         	coins++;
16 |     	}
17 |     	if(bombUsed){
18 |         	rowValid--;
19 |     	}
20 |     	solve(board, i-1, j-1, bombUsed, rowValid, coins);
21 |     	solve(board, i-1, j, bombUsed, rowValid, coins);
22 |     	solve(board, i-1, j+1, bombUsed, rowValid, coins);
23 | 	}
24 | 	else if(board[i][j] ==2){
25 |     	if(bombUsed && rowValid <= 0){
26 |         	ans = max(ans, coins);
27 |         	return;
28 |     	}
29 |     	else if(bombUsed && rowValid > 0){
30 |         	rowValid--;
31 |         	solve(board, i-1, j-1, bombUsed, rowValid, coins);
32 |         	solve(board, i-1, j, bombUsed, rowValid, coins);
33 |         	solve(board, i-1, j+1, bombUsed, rowValid, coins);
34 |     	}
35 |     	else{
36 |         	bombUsed = true;
37 |         	rowValid = 4;
38 |         	solve(board, i-1, j-1, bombUsed, rowValid, coins);
39 |         	solve(board, i-1, j, bombUsed, rowValid, coins);
40 |         	solve(board, i-1, j+1, bombUsed, rowValid, coins);
41 |     	}
42 | 	}
43 | }
44 | 
45 | int main(){
46 | 	int n;
47 | 	cin>>n;
48 | 	int board[n][5];
49 | 	for(int i =0; i<n; i++){
50 |     	for(int j = 0; j<5; j++){
51 |         	cin>>board[i][j];
52 |     	}
53 | 	}
54 | 	solve(board, n-1, 1, false, 0, 0);
55 | 	solve(board, n-1, 2, false, 0, 0);
56 | 	solve(board, n-1, 3, false, 0, 0);
57 | 	cout<<ans<<endl;
58 | 	return 0;
59 | }
60 | 


--------------------------------------------------------------------------------
/SRBD/Spaceship Game.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int a[100][100];
 5 | int n;
 6 | 
 7 | bool valid(int r, int c)
 8 | {
 9 |     if(r<n && r>=0 && c<5 && c>=0)return true;
10 |     return false;
11 | }
12 | 
13 | int solve(int r, int c, int power, int effect)
14 | {
15 |     if(r<0)return 0;
16 |     int ans = 0;
17 |     int p = 0;
18 |     for(int i = -1; i <=1; i++)
19 |     {
20 |         int y = c+i;
21 |         int x = r-1;
22 | 
23 |         if(valid(x,y))
24 |         {
25 |             // enemy
26 |             if(a[x][y] == 2)
27 |             {
28 |                 if(power == 0 && effect >  0)
29 |                 {
30 |                     p = solve(x,y,power,effect -1);
31 |                 }
32 |                 if(power == 1)
33 |                 {
34 |                     p = solve(x,y,power-1,5);
35 |                 }
36 |             }
37 |             // not enemy
38 |             if(a[x][y] == 1 ||a[x][y] == 0)
39 |             {
40 |                 if(power == 0)
41 |                     p = solve(x,y,power,effect-1);
42 |                 else
43 |                     p = solve(x,y,power,5);
44 |             }
45 |         }
46 |         ans = max(ans, p);
47 |     }
48 |     if(a[r][c] == 1)ans++;
49 |     return ans;
50 | }
51 | 
52 | int main()
53 | {
54 |     cin>>n;
55 |     for(int i = 0; i<100; i++)
56 |         for(int j =0; j<100; j++)
57 |             a[i][j] = 0;
58 | 
59 |     for(int i =0; i<n; i++)
60 |     {
61 |         for(int j = 0; j<5; j++)
62 |         {
63 |             cin>>a[i][j];
64 |         }
65 |     }
66 |     cout<<solve(n,2,1,0)<<endl;
67 |     return 0;
68 | }
69 | 


--------------------------------------------------------------------------------
/SRBD/Stockprice.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int a[10] = {5, 3, 1, 4, 2, 7, 6};
 7 | 
 8 |     int mx, mn, ans = 0;
 9 |     mx  = 0;
10 |     mn = 999999;
11 |     for(int i=1; i<7; i++)
12 |     {
13 |         if(a[i-1] < a[i])
14 |         {
15 |             mx = max(mx, a[i]);
16 |             mn = min(mn, a[i-1]);
17 |         }
18 |         ans = max(ans, mx-mn);
19 |     }
20 |     cout<<ans<<endl;
21 |     return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/SRBD/Sum of Nodes in Kth Level.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | 
 4 | int solve(string s, int k)
 5 | {
 6 |     int l = 0, ans = 0;
 7 |     for(int i=0; i<s.size(); i++)
 8 |     {
 9 |         if(s[i]=='(')
10 |             l++;
11 |         else if(s[i]==')')
12 |             l--;
13 |         else if(l==k+1)
14 |         {
15 |             int temp = 0;
16 |             int bit = (s[i] - '0');
17 |             while(bit>=0 && bit<=9)
18 |             {
19 |                 temp = temp * 10 + bit;
20 |                 i++;
21 |                 bit = (s[i] - '0');
22 |             }
23 |             //cout<<temp<<endl;
24 |             ans += temp;
25 |             i--;
26 |         }
27 |     }
28 |     return ans;
29 | }
30 | 
31 | int main()
32 | {
33 |     int k;
34 |     cin>>k;
35 | 
36 |     string s;
37 |     cin>>s;
38 | 
39 |     int ans = solve(s, k);
40 |     cout<<ans<<"\n";
41 |     return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/SRBD/SumAtLevelK.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<stdio.h>
 3 | using namespace std;
 4 | 
 5 | int solve(char str[], int k)
 6 | {
 7 |     int i = 0, l = -1, ans = 0;
 8 |     while(str[i] != '\0')
 9 |     {
10 |         if(str[i]=='(')
11 |             l++;
12 |         else if(str[i]==')')
13 |             l--;
14 |         else if(l==k)
15 |             ans += (str[i]-'0');
16 |         i++;
17 |     }
18 |     return ans;
19 | }
20 | 
21 | int main()
22 | {
23 |     int t;
24 |     cin>>t;
25 | 
26 |     while(t--)
27 |     {
28 |         char str[1005];
29 |         cin>>str;
30 | 
31 |         int n;
32 |         cin>>n;
33 | 
34 |         int ans = solve(str, n);
35 |         cout<<ans<<"\n";
36 |     }
37 |     return 0;
38 | }
39 | 


--------------------------------------------------------------------------------
/SRBD/SuperSale.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include <cstdio>
 3 | #include<string.h>
 4 | #define MX 1005
 5 | using namespace std;
 6 | 
 7 | int dp[MX][35];
 8 | int p[MX], w[MX], mw[MX];
 9 | int n, g;
10 | 
11 | int solve(int i, int sum, int cost)
12 | {
13 |     int left, right;
14 |     if(dp[i][sum] >= 0 )
15 |        return dp[i][sum];
16 | 
17 |     if(i==n)
18 |         return 0;
19 | 
20 |     left = solve(i+1, sum,  cost);
21 | 
22 |     if(sum+w[i] <= cost)
23 |         right = p[i] + solve(i+1, sum+w[i], cost);
24 |     else
25 |         right = 0;
26 |     return dp[i][sum] =  max(left, right);
27 | }
28 | 
29 | int main()
30 | {
31 |     freopen("input.txt", "r", stdin);
32 | 
33 |     int t;
34 |     cin>>t;
35 | 
36 |     while(t--)
37 |     {
38 |         cin>>n;
39 |         for(int i=0; i<n; i++)
40 |         {
41 |             cin>>p[i]>>w[i];
42 |         }
43 |         cin>>g;
44 | 
45 |         long long ans = 0;
46 |         for(int i=0; i<g; i++)
47 |         {
48 |             cin>>mw[i];
49 |             memset(dp, -1, sizeof(dp));
50 |             ans += solve(0, 0,  mw[i]);
51 |         }
52 |         cout<<ans<<"\n";
53 |     }
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/SRBD/Travelling SalesPerson.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string.h>
 3 | #define MX 12
 4 | using namespace std;
 5 | 
 6 | int n, arr[MX][MX];
 7 | int dp[MX][1<<MX];
 8 | 
 9 | int turnOn(int x, int pos)
10 | {
11 |     return x | (1<<pos);
12 | }
13 | 
14 | bool isOn(int x, int pos)
15 | {
16 |     return bool (x & (1<<pos));
17 | }
18 | 
19 | int solve(int i, int mask)
20 | {
21 |     if(mask == (1<<n)-1)
22 |         return arr[i][0];
23 | 
24 |     if(dp[i][mask] != -1)
25 |         return dp[i][mask];
26 | 
27 |     int ans = 99999999;
28 |     for(int j=0; j<n; j++)
29 |     {
30 |          if(isOn(mask, j)==0)
31 |          {
32 |             int tmp = solve(j, turnOn(mask, j)) + arr[i][j];
33 |             ans = min(ans, tmp);
34 |          }
35 |     }
36 |     return dp[i][mask] = ans;
37 | }
38 | 
39 | int main()
40 | {
41 |     int t;
42 |     cin>>t;
43 | 
44 |     while(t--)
45 |     {
46 |         cin>>n;
47 |         for(int i=0; i<n; i++)
48 |         {
49 |             for(int j=0; j<n; j++)
50 |             {
51 |                 cin>>arr[i][j];
52 |             }
53 |         }
54 | 
55 |         memset(dp, -1, sizeof(dp));
56 |         int ans = solve(0, 1);
57 |         cout<<ans<<"\n";
58 |     }
59 |     return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/SRBD/Travelling Salesman.uva.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string.h>
 3 | #define MX 103
 4 | #define INF 9999999
 5 | using namespace std;
 6 | 
 7 | int c, s, e, t;
 8 | int arr[MX][MX], vis[MX];
 9 | int dp[MX][MX*10];
10 | 
11 | int solve(int pos, int rem)
12 | {
13 |     if(rem==0)
14 |     {
15 |         if(vis[pos]==1)
16 |             return 0;
17 |         else
18 |             return -INF;
19 |     }
20 | 
21 |     if(dp[pos][rem] != -1)
22 |         return dp[pos][rem];
23 | 
24 |     int ans = -INF;
25 |     for(int i=0; i<c; i++)
26 |     {
27 |         if(i==pos)
28 |             continue;
29 |         ans = max(ans, arr[pos][i] + solve(i, rem-1));
30 |     }
31 |     //cout<<pos<<" "<<rem<<" "<<ans<<endl;
32 |     return dp[pos][rem] = ans;
33 | }
34 | 
35 | 
36 | int main()
37 | {
38 |     while(cin>>c>>s>>e>>t)
39 |     {
40 |         if(c==0 && s==0 && e==0 && t==0)
41 |             break;
42 | 
43 |         for(int i=0; i<c; i++)
44 |             for(int j=0; j<c; j++)
45 |                 cin>>arr[i][j];
46 | 
47 |         memset(vis, 0, sizeof(vis));
48 |         for(int i=0; i<e; i++)
49 |         {
50 |             int tmp;
51 |             cin>>tmp;
52 |             vis[--tmp] = 1;
53 |         }
54 | 
55 |         memset(dp, -1, sizeof(dp));
56 |         int ans = solve(s-1, t);
57 |         cout<<ans<<"\n";
58 |     }
59 |     return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/SRBD/Unique BST.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string.h>
 3 | #define MX 1005
 4 | using namespace std;
 5 | 
 6 | int dp[MX][MX];
 7 | int solve(int n, int k)
 8 | {
 9 |     if(k==0 || n==k)
10 |         return 1;
11 | 
12 |     if(dp[n][k] >= 0)
13 |         return dp[n][k];
14 | 
15 |     return dp[n][k] = solve(n-1, k-1) + solve(n-1, k);
16 | }
17 | 
18 | int main()
19 | {
20 |     int n;
21 |     cin>>n;
22 | 
23 |     int a[n];
24 |     for(int i=0; i<n; i++)
25 |         cin>>a[i];
26 | 
27 |     memset(dp, -1, sizeof(dp));
28 |     int ans = solve(2*n, n)/(n+1);
29 |     cout<<ans<<endl;
30 | }
31 | 


--------------------------------------------------------------------------------
/SRBD/Urinal problem.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<stdio.h>
 3 | using namespace std;
 4 | 
 5 | void solve(int n, int k, int arr[])
 6 | {
 7 |     for(int i=0; i<k; i++)
 8 |     {
 9 |         int l = 0, cnt = 0, ans = 0;
10 |         for(int j=0; j<n; j++)
11 |         {
12 |             if(arr[j]==0)
13 |                 cnt++;
14 |             else
15 |                 cnt = 0;
16 | 
17 |             if(cnt > ans)
18 |             {
19 |                 ans = cnt;
20 |                 l = j;
21 |             }
22 |         }
23 |         int f = l - ans + 1;
24 |         int mid = (f+l)/2;
25 |         arr[mid] = 1;
26 |     }
27 | }
28 | 
29 | int main()
30 | {
31 |     freopen("input.txt","r",stdin);
32 |     int t;
33 |     cin>>t;
34 | 
35 |     while(t--)
36 |     {
37 |         int n, k;
38 |         cin>>n>>k;
39 | 
40 |         int arr[n];
41 |         for(int i=0; i<n; i++)
42 |             arr[i] = 0;
43 | 
44 |         solve(n, k, arr);
45 |         for(int i=0; i<n; i++)
46 |             cout<<arr[i];
47 |         cout<<"\n";
48 |     }
49 |     return 0;
50 | }
51 | 
52 | /*
53 | It is a well-researched fact that men in a restroom generally prefer to maximize their distance from already occupied stalls, by occupying the middle of the longest sequence of unoccupied places
54 | 
55 | 10
56 | 10 1
57 | 10 2
58 | 10 3
59 | 10 4
60 | 10 5
61 | 10 6
62 | 10 7
63 | 10 8
64 | 10 9
65 | 10 10
66 | output is the following
67 | 
68 | 0000100000
69 | 0000100100
70 | 0100100100
71 | 0100100110
72 | 0100110110
73 | 0110110110
74 | 0110110111
75 | 0110111111
76 | 0111111111
77 | 1111111111
78 | 
79 | VERIFIED AND TESTED
80 | */
81 | 


--------------------------------------------------------------------------------
/SRBD/Warmholes.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<stdlib.h>
 3 | #include<string.h>
 4 | #define MX 50
 5 | using namespace std;
 6 | 
 7 | int dist[MX], vis[MX];
 8 | 
 9 | struct point{
10 |     int sx, sy, dx, dy, t;
11 | }holes[MX];
12 | 
13 | int distance(int x1, int y1, int x2, int y2)
14 | {
15 |     int diff = abs(x1-x2) + abs(y1-y2);
16 |     return diff;
17 | }
18 | 
19 | int findMin(int n)
20 | {
21 |     int mn = 99999999, id = 0;
22 |     for(int i=1; i<=n; i++)
23 |     {
24 |         if(!vis[i] && dist[i] < mn)
25 |         {
26 |             mn = dist[i];
27 |             id = i;
28 |         }
29 |     }
30 |     return id;
31 | }
32 | 
33 | int solve(int n)
34 | {
35 |     for(int i=1; i<=n; i++)
36 |     {
37 |         int u = findMin(n);
38 |         //cout<<u<<" "<<dist[u]<<endl;
39 |         vis[u] = 1;
40 | 
41 |         for(int v=1; v<=n; v++)
42 |         {
43 |             if(v==u)
44 |                 continue;
45 | 
46 |             int tmp1 = dist[u] + distance(holes[u].dx, holes[u].dy, holes[v].sx, holes[v].sy) + holes[v].t;
47 |             int tmp2 = dist[u] + distance(holes[u].dx, holes[u].dy, holes[v].dx, holes[v].dy);
48 |             //cout<<v<<" "<<min(tmp1, tmp2)<<endl;
49 | 
50 |             if(!vis[v] && dist[v] > min(tmp1, tmp2))
51 |                 dist[v] = min(tmp1, tmp2);
52 |         }
53 |     }
54 |     return dist[n];
55 | }
56 | 
57 | int main()
58 | {
59 |     int t;
60 |     cin>>t;
61 | 
62 |     while(t--)
63 |     {
64 |         int n, m;
65 |         cin>>n;
66 | 
67 |         int x0, y0, xn, yn;
68 |         cin>>x0>>y0>>xn>>yn;
69 | 
70 |         m = 2 * n + 1;
71 |         for(int i=1; i<m; i++)
72 |         {
73 |             int a, b, c, d, e;
74 |             cin>>a>>b>>c>>d>>e;
75 | 
76 |             holes[i].sx = a, holes[i].sy = b, holes[i].dx = c, holes[i].dy = d, holes[i].t = e;
77 |             i++;
78 |             holes[i].sx = c, holes[i].sy = d, holes[i].dx = a, holes[i].dy = b, holes[i].t = e;
79 |         }
80 | 
81 |         for(int i=1; i<m; i++)
82 |         {
83 |             int tmp1 = distance(x0, y0, holes[i].sx, holes[i].sy) + holes[i].t;
84 |             int tmp2 = distance(x0, y0, holes[i].dx, holes[i].dy);
85 |             dist[i] = min(tmp1, tmp2);
86 |         }
87 |         holes[m].sx = xn, holes[m].sy = yn, holes[m].dx = xn, holes[m].dy = yn, holes[m].t = 0;
88 |         dist[m] = distance(x0, y0, xn, yn);
89 | 
90 |         memset(vis, 0, sizeof(vis));
91 |         int ans = solve(m);
92 |         cout<<ans<<"\n";
93 |     }
94 |     return 0;
95 | }
96 | 


--------------------------------------------------------------------------------
/TherapBD/Compile time polymorphism.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class Overloading{
 5 | public:
 6 |     int add(int a, int b)
 7 |     {
 8 |         return a+b;
 9 |     }
10 |     double add(double a, double b)
11 |     {
12 |         return a+b;
13 |     }
14 | };
15 | 
16 | int main()
17 | {
18 |     Overloading obj;
19 |     int sum1 = obj.add(5, 3);
20 |     double sum2 = obj.add(5.5, 4.5);
21 |     cout<<sum1<<" "<<sum2<<endl;
22 |     return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/TherapBD/Concat integers.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int concat(int a, int b)
 5 | {
 6 |     int i = 10;
 7 |     while(b >= i){
 8 |         i = i*10;
 9 |     }
10 |     return a*i+b;
11 | }
12 | 
13 | int main()
14 | {
15 |     int arr[5] = {54, 546, 548, 60, 59};
16 |     for(int i=0; i<5; i++)
17 |     {
18 |         for(int j=i+1; j<5; j++)
19 |         {
20 |             if(concat(arr[i], arr[j]) < concat(arr[j], arr[i]))
21 |                 swap(arr[i], arr[j]);
22 |         }
23 |     }
24 | 
25 |     for(int i=0; i<5; i++)
26 |         cout<<arr[i];
27 |     cout<<endl;
28 |     return 0;
29 | }
30 | 


--------------------------------------------------------------------------------
/TherapBD/Delete a element from linklist.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | struct Node
 5 | {
 6 |     int data;
 7 |     struct Node *next;
 8 | };
 9 | 
10 | void insertData(int n, struct Node **head)
11 | {
12 |     struct Node *newnode = (struct Node*) malloc(sizeof(struct Node));
13 |     newnode->data = n;
14 |     newnode->next = NULL;
15 | 
16 |     if(*head==NULL)
17 |     {
18 |         *head = newnode;
19 |         return;
20 |     }
21 | 
22 |     struct Node *cur = *head;
23 |     while(cur->next != NULL)
24 |     {
25 |         cur = cur->next;
26 |     }
27 |     cur->next = newnode;
28 | }
29 | 
30 | void printList(struct Node* node)
31 | {
32 |     while (node != NULL)
33 |     {
34 |         cout << node->data << " ";
35 |         node = node->next;
36 |     }
37 |     cout<<endl;
38 | }
39 | 
40 | struct Node* deleteElement(int n, struct Node *head)
41 | {
42 |     struct Node *cur = head, *prev = NULL;
43 |     if(head->data==n)
44 |     {
45 |         head = head->next;
46 |         free(cur);
47 |         return head;
48 |     }
49 | 
50 |     while(cur != NULL && cur->data != n)
51 |     {
52 |         prev = cur;
53 |         cur = cur->next;
54 |     }
55 |     if(cur != NULL)
56 |     {
57 |          prev->next = cur->next;
58 |          free(cur);
59 |     }
60 |     return head;
61 | };
62 | 
63 | int main()
64 | {
65 |     struct Node *head = NULL;
66 |     for(int i=1; i<10; i++)
67 |         insertData(i, &head);
68 | 
69 |     printList(head);
70 |     head = deleteElement(9, head);
71 |     printList(head);
72 |     return 0;
73 | }
74 | 
75 | 


--------------------------------------------------------------------------------
/TherapBD/Delete a node from bst.cpp:
--------------------------------------------------------------------------------
  1 | #include<bits/stdc++.h>
  2 | using namespace std;
  3 | 
  4 | class node
  5 | {
  6 | public:
  7 |     int data;
  8 |     node* left;
  9 |     node* right;
 10 | 
 11 |     node(int data)
 12 |     {
 13 |         this->data = data;
 14 |         this->left = NULL;
 15 |         this->right = NULL;
 16 |     }
 17 | };
 18 | 
 19 | node* insertBST(int n, node *root)
 20 | {
 21 |     if(root==NULL)
 22 |     {
 23 |         return root = new node(n);
 24 |     }
 25 |     if(root->data > n)
 26 |         root->left = insertBST(n, root->left);
 27 |     else
 28 |         root->right = insertBST(n, root->right);
 29 | }
 30 | 
 31 | void inorder(node *root)
 32 | {
 33 |     if(root==NULL)
 34 |     {
 35 |         cout<<endl;
 36 |         return;
 37 |     }
 38 |     inorder(root->left);
 39 |     cout<<root->data<<" ";
 40 |     inorder(root->right);
 41 | }
 42 | 
 43 | node *minValueNode(node *node)
 44 | {
 45 |   struct node *current = node;
 46 |   while (current && current->left != NULL)
 47 |     current = current->left;
 48 |   return current;
 49 | }
 50 | 
 51 | node* deleteBST(int key, node *root)
 52 | {
 53 |     if(root==NULL)
 54 |         return NULL;
 55 |     if(root->data > key)
 56 |         root->left = deleteBST(key, root->left);
 57 |     else if(root->data < key)
 58 |         root->right = deleteBST(key, root->right);
 59 |     else
 60 |     {
 61 |         if(root->left==NULL && root->right==NULL)
 62 |             return NULL;
 63 |         if(root->left==NULL)
 64 |         {
 65 |             node *tmp = root->right;
 66 |             free(root);
 67 |             return tmp;
 68 |         }
 69 |         else
 70 |         {
 71 |             node *tmp = root->left;
 72 |             free(root);
 73 |             return tmp;
 74 |         }
 75 | 
 76 |         node *tmp = minValueNode(root->right);
 77 |         root->data = tmp->data;
 78 |         root->right = deleteBST(tmp->data, root->right);
 79 |     }
 80 |     return root;
 81 | }
 82 | 
 83 | int main()
 84 | {
 85 |     node *head = NULL;
 86 |     for(int i=1; i<5; i++)
 87 |     {
 88 |         head = insertBST(5-i, head);
 89 |         head = insertBST(5+i, head);
 90 |     }
 91 | 
 92 |     inorder(head);
 93 |     head = deleteBST(6, head);
 94 |     inorder(head);
 95 | 
 96 |     return 0;
 97 | }
 98 | 
 99 | 
100 | 
101 | 


--------------------------------------------------------------------------------
/TherapBD/Delete the elements in an linked list whose sum is equal to zero.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | struct Node
 5 | {
 6 |     int data;
 7 |     struct Node *next;
 8 | };
 9 | 
10 | void insertData(int n, struct Node **head)
11 | {
12 |     struct Node *newnode = (struct Node*) malloc(sizeof(struct Node));
13 |     newnode->data = n;
14 |     newnode->next = NULL;
15 | 
16 |     if(*head==NULL)
17 |     {
18 |         *head = newnode;
19 |         return;
20 |     }
21 | 
22 |     struct Node *cur = *head;
23 |     while(cur->next != NULL)
24 |     {
25 |         cur = cur->next;
26 |     }
27 |     cur->next = newnode;
28 | }
29 | 
30 | struct Node* getList(struct Node *root)
31 | {
32 |     if(root==NULL)
33 |         return NULL;
34 | 
35 |     int sum = 0;
36 |     struct Node *tmp = root;
37 |     root->next = getList(root->next);
38 |     while(tmp != NULL)
39 |     {
40 |         sum += tmp->data;
41 |         if(sum==0)
42 |             root = tmp->next;
43 |         tmp = tmp->next;
44 |     }
45 |     return root;
46 | };
47 | 
48 | void printList(struct Node* node)
49 | {
50 |     while (node != NULL)
51 |     {
52 |         cout << node->data << " ";
53 |         node = node->next;
54 |     }
55 |     cout<<endl;
56 | }
57 | 
58 | int main()
59 | {
60 |     struct Node *head = NULL;
61 |     for(int i=1; i<=10; i++)
62 |     {
63 |         insertData(i, &head);
64 |         insertData(i-10, &head);
65 |     }
66 | 
67 |     printList(head);
68 |     head = getList(head);
69 |     printList(head);
70 |     return 0;
71 | }
72 | 
73 | 


--------------------------------------------------------------------------------
/TherapBD/Detect Loop and remove in linklist.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | struct Node
 5 | {
 6 |     int data;
 7 |     struct Node *next;
 8 | };
 9 | 
10 | void insertData(int n, struct Node **head)
11 | {
12 |     struct Node *newnode = (struct Node*) malloc(sizeof(struct Node));
13 |     newnode->data = n;
14 |     newnode->next = NULL;
15 | 
16 |     if(*head==NULL)
17 |     {
18 |         *head = newnode;
19 |         return;
20 |     }
21 | 
22 |     struct Node *cur = *head;
23 |     while(cur->next != NULL)
24 |     {
25 |         cur = cur->next;
26 |     }
27 |     cur->next = newnode;
28 | }
29 | 
30 | void printList(struct Node* node)
31 | {
32 |     while (node != NULL)
33 |     {
34 |         cout << node->data << " ";
35 |         node = node->next;
36 |     }
37 |     cout<<endl;
38 | }
39 | 
40 | void detectLoop(struct Node *head)
41 | {
42 |     struct Node *slow = head, *fast = head;
43 |     while(fast != NULL && fast->next != NULL)
44 |     {
45 |         slow = slow->next;
46 |         fast = fast->next->next;
47 |         if(slow==fast)
48 |             break;
49 |     }
50 | 
51 |     if(slow==fast)
52 |     {
53 |         cout<<"Loop detected\n";
54 |         slow = head;
55 |         if(slow==fast)
56 |         {
57 |             while(fast->next != slow)
58 |                 fast = fast->next;
59 |         }
60 |         else
61 |         {
62 |             fast = head;
63 |             while(fast->next != slow->next)
64 |             {
65 |                 fast = fast->next->next;
66 |                 slow = slow->next;
67 |             }
68 |         }
69 |         fast->next = NULL;
70 |     }
71 |     else
72 |         cout<<"Loop not detected\n";
73 | }
74 | 
75 | int main()
76 | {
77 |     struct Node *head = NULL, *tmp = NULL;
78 |     for(int i=1; i<=3; i++)
79 |         insertData(i, &head);
80 | 
81 |     head->next->next->next = head;
82 |     detectLoop(head);
83 |     printList(head);
84 |     return 0;
85 | }
86 | 
87 | 


--------------------------------------------------------------------------------
/TherapBD/Digit to Binary.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | string binary(int n)
 5 | {
 6 |     string str = "";
 7 |     while(n)
 8 |     {
 9 |         char ch = (n%2)+'0';
10 |         n = n/2;
11 |         str.push_back(ch);
12 |     }
13 |     reverse(str.begin(), str.end());
14 |     return str;
15 | }
16 | 
17 | int main()
18 | {
19 |     int n;
20 |     cin>>n;
21 | 
22 |     string ans = binary(n);
23 |     cout<<ans<<"\n";
24 |     return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/TherapBD/Dimond shape problem.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class A{
 5 | public:
 6 |     void fun(){
 7 |         cout<<"Class A\n";
 8 |     }
 9 | };
10 | 
11 | class B: virtual public A{
12 | 
13 | };
14 | 
15 | class C: virtual public A{
16 | 
17 | };
18 | 
19 | class D: public B, public C{
20 | 
21 | };
22 | 
23 | int main()
24 | {
25 |     D obj;
26 |     obj.fun();
27 | }
28 | 


--------------------------------------------------------------------------------
/TherapBD/Height of BST.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class node
 5 | {
 6 | public:
 7 |     int data;
 8 |     node* left;
 9 |     node* right;
10 | 
11 |     node(int data)
12 |     {
13 |         this->data = data;
14 |         this->left = NULL;
15 |         this->right = NULL;
16 |     }
17 | };
18 | 
19 | node* insertBST(int n, node *root)
20 | {
21 |     if(root==NULL)
22 |     {
23 |         return root = new node(n);
24 |     }
25 |     if(root->data > n)
26 |         root->left = insertBST(n, root->left);
27 |     else
28 |         root->right = insertBST(n, root->right);
29 | 
30 | }
31 | 
32 | int heightBST(node *root)
33 | {
34 |     if(root==NULL)
35 |         return -1;
36 | 
37 |     int l = heightBST(root->left);
38 |     int r = heightBST(root->right);
39 | 
40 |     return max(l, r) + 1;
41 | }
42 | 
43 | void inorder(node *root)
44 | {
45 |     if(root==NULL)
46 |         return;
47 |     inorder(root->left);
48 |     cout<<root->data<<" ";
49 |     inorder(root->right);
50 | }
51 | 
52 | int main()
53 | {
54 |     node *head = NULL;
55 |     for(int i=1; i<5; i++)
56 |     {
57 |         head = insertBST(5-i, head);
58 |         head = insertBST(5+i, head);
59 |     }
60 | 
61 |     inorder(head);
62 |     cout<<endl<<heightBST(head)<<endl;
63 |     return 0;
64 | }
65 | 
66 | 
67 | 


--------------------------------------------------------------------------------
/TherapBD/Insert and delete into sorted linklist.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | struct Node
 5 | {
 6 |     int data;
 7 |     struct Node *next;
 8 | };
 9 | 
10 | void insertData(int n, struct Node **head)
11 | {
12 |     struct Node *newnode = (struct Node*) malloc(sizeof(struct Node));
13 |     newnode->data = n;
14 |     newnode->next = NULL;
15 | 
16 |     if(*head==NULL)
17 |     {
18 |         *head = newnode;
19 |         return;
20 |     }
21 | 
22 |     struct Node *cur = *head;
23 |     while(cur->next != NULL)
24 |     {
25 |         cur = cur->next;
26 |     }
27 |     cur->next = newnode;
28 | }
29 | 
30 | void insertSortedList(int n, struct Node **head)
31 | {
32 |     struct Node *newnode = (struct Node*) malloc(sizeof(struct Node));
33 |     newnode->data = n;
34 |     newnode->next = NULL;
35 | 
36 |     if(*head==NULL)
37 |     {
38 |         *head = newnode;
39 |         return;
40 |     }
41 | 
42 |     struct Node *cur = *head;
43 |     while(cur->next != NULL)
44 |     {
45 |         if(cur->data <= n && cur->next->data >= n)
46 |         {
47 |             struct Node *tmp = cur->next;
48 |             cur->next = newnode;
49 |             newnode->next = tmp;
50 |             return;
51 |         }
52 |         cur = cur->next;
53 |     }
54 |     cur->next = newnode;
55 | }
56 | 
57 | void printList(struct Node* node)
58 | {
59 |     while (node != NULL)
60 |     {
61 |         cout << node->data << " ";
62 |         node = node->next;
63 |     }
64 |     cout<<endl;
65 | }
66 | 
67 | int main()
68 | {
69 |     struct Node *head = NULL;
70 |     for(int i=1; i<10; i++)
71 |         insertData(i, &head);
72 | 
73 |     printList(head);
74 |     insertSortedList(10, &head);
75 |     printList(head);
76 |     return 0;
77 | }
78 | 
79 | 


--------------------------------------------------------------------------------
/TherapBD/Insert into Linklist.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | struct Node
 5 | {
 6 |     int data;
 7 |     struct Node *next;
 8 | };
 9 | 
10 | void insertData(int n, struct Node **head)
11 | {
12 |     struct Node *newnode = (struct Node*) malloc(sizeof(struct Node));
13 |     newnode->data = n;
14 |     newnode->next = NULL;
15 | 
16 |     if(*head==NULL)
17 |     {
18 |         *head = newnode;
19 |         return;
20 |     }
21 | 
22 |     struct Node *cur = *head;
23 |     while(cur->next != NULL)
24 |     {
25 |         cur = cur->next;
26 |     }
27 |     cur->next = newnode;
28 | }
29 | 
30 | void printList(struct Node* node)
31 | {
32 |     while (node != NULL)
33 |     {
34 |         cout << node->data << " ";
35 |         node = node->next;
36 |     }
37 | }
38 | 
39 | int main()
40 | {
41 |     struct Node *head = NULL;
42 |     for(int i=1; i<10; i++)
43 |         insertData(i, &head);
44 | 
45 |     printList(head);
46 |     return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/TherapBD/Max Sum BST.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class node
 5 | {
 6 | public:
 7 |     int data;
 8 |     node* left;
 9 |     node* right;
10 | 
11 |     node(int data)
12 |     {
13 |         this->data = data;
14 |         this->left = NULL;
15 |         this->right = NULL;
16 |     }
17 | };
18 | 
19 | node* insertBST(int n, node *root)
20 | {
21 |     if(root==NULL)
22 |     {
23 |         return root = new node(n);
24 |     }
25 |     if(root->data > n)
26 |         root->left = insertBST(n, root->left);
27 |     else
28 |         root->right = insertBST(n, root->right);
29 | 
30 | }
31 | 
32 | int maxsumBST(node *root, int &sum)
33 | {
34 |     if(root==NULL)
35 |         return 0;
36 | 
37 |     int l = maxsumBST(root->left, sum);
38 |     int r = maxsumBST(root->right, sum);
39 |     int tmp = max(max(l, r) + root->data, root->data);
40 | 
41 |     int mx = max(tmp, l+r+root->data);
42 |     sum = max(mx, sum);
43 |     return tmp;
44 | }
45 | 
46 | int findMaxSum(Node* root, int &globalMax){
47 |     if(root == NULL)
48 |         return 0;
49 |     int left = findMaxSum(root->left, globalMax);
50 |     int right = findMaxSum(root->right, globalMax);
51 |     int returnMax = max(max(left, right) + root->val, root->val);
52 | 
53 |     int mx = max(returnMax, left + right + root->val);
54 |     if(mx > globalMax)
55 |         globalMax = mx;
56 |     return returnMax;
57 | }
58 | 
59 | void inorder(node *root)
60 | {
61 |     if(root==NULL)
62 |         return;
63 |     inorder(root->left);
64 |     cout<<root->data<<" ";
65 |     inorder(root->right);
66 | }
67 | 
68 | int main()
69 | {
70 |     node *head = NULL;
71 |     for(int i=1; i<=10; i++)
72 |     {
73 |         head = insertBST(5+i, head);
74 |         head = insertBST(5-i, head);
75 |     }
76 | 
77 |     inorder(head);
78 |     int sum = INT_MIN;
79 |     cout<<endl<<maxsumBST(head, sum)<<endl;
80 |     return 0;
81 | }
82 | 
83 | 
84 | 
85 | 


--------------------------------------------------------------------------------
/TherapBD/Max value of BT.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class node
 5 | {
 6 | public:
 7 |     int data;
 8 |     node* left;
 9 |     node* right;
10 | 
11 |     node(int data)
12 |     {
13 |         this->data = data;
14 |         this->left = NULL;
15 |         this->right = NULL;
16 |     }
17 | };
18 | 
19 | node* insertBST(int n, node *root)
20 | {
21 |     if(root==NULL)
22 |     {
23 |         return root = new node(n);
24 |     }
25 |     if(root->data > n)
26 |         root->left = insertBST(n, root->left);
27 |     else
28 |         root->right = insertBST(n, root->right);
29 | }
30 | 
31 | int maxBST(node *root)
32 | {
33 |     if(root==NULL)
34 |         return -1;
35 | 
36 |     int l = maxBST(root->left);
37 |     int r = maxBST(root->right);
38 | 
39 |     return max(root->data, max(l, r));
40 | }
41 | 
42 | void inorder(node *root)
43 | {
44 |     if(root==NULL)
45 |         return;
46 |     inorder(root->left);
47 |     cout<<root->data<<" ";
48 |     inorder(root->right);
49 | }
50 | 
51 | int main()
52 | {
53 |     node *head = NULL;
54 |     for(int i=1; i<=5; i++)
55 |     {
56 |         head = insertBST(10+i, head);
57 |         head = insertBST(10-i, head);
58 |     }
59 | 
60 |     inorder(head);
61 |     cout<<endl<<maxBST(head)<<endl;
62 |     return 0;
63 | }
64 | 
65 | 
66 | 


--------------------------------------------------------------------------------
/TherapBD/Middle Point of linklist.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | struct Node
 5 | {
 6 |     int data;
 7 |     struct Node *next;
 8 | };
 9 | 
10 | void insertData(int n, struct Node **head)
11 | {
12 |     struct Node *newnode = (struct Node*) malloc(sizeof(struct Node));
13 |     newnode->data = n;
14 |     newnode->next = NULL;
15 | 
16 |     if(*head==NULL)
17 |     {
18 |         *head = newnode;
19 |         return;
20 |     }
21 | 
22 |     struct Node *cur = *head;
23 |     while(cur->next != NULL)
24 |     {
25 |         cur = cur->next;
26 |     }
27 |     cur->next = newnode;
28 | }
29 | 
30 | void printList(struct Node* node)
31 | {
32 |     while (node != NULL)
33 |     {
34 |         cout << node->data << " ";
35 |         node = node->next;
36 |     }
37 |     cout<<endl;
38 | }
39 | 
40 | struct Node* middlePoint(struct Node *head)
41 | {
42 |     struct Node *slow = head, *fast = head;
43 |     while(fast != NULL && fast->next != NULL)
44 |     {
45 |         slow = slow->next;
46 |         fast = fast->next->next;
47 |     }
48 |     return slow;
49 | };
50 | 
51 | int main()
52 | {
53 |     struct Node *head = NULL, *middle = NULL;
54 |     for(int i=1; i<=10; i++)
55 |         insertData(i, &head);
56 | 
57 |     printList(head);
58 |     middle = middlePoint(head);
59 |     cout<<middle->data<<endl;
60 |     return 0;
61 | }
62 | 
63 | 


--------------------------------------------------------------------------------
/TherapBD/Pallindrome Check in linklist.cpp:
--------------------------------------------------------------------------------
  1 | #include<bits/stdc++.h>
  2 | using namespace std;
  3 | 
  4 | struct Node
  5 | {
  6 |     int data;
  7 |     struct Node *next;
  8 | };
  9 | 
 10 | void insertData(int n, struct Node **head)
 11 | {
 12 |     struct Node *newnode = (struct Node*) malloc(sizeof(struct Node));
 13 |     newnode->data = n;
 14 |     newnode->next = NULL;
 15 | 
 16 |     if(*head==NULL)
 17 |     {
 18 |         *head = newnode;
 19 |         return;
 20 |     }
 21 | 
 22 |     struct Node *cur = *head;
 23 |     while(cur->next != NULL)
 24 |     {
 25 |         cur = cur->next;
 26 |     }
 27 |     cur->next = newnode;
 28 | }
 29 | 
 30 | struct Node* reverseList(struct Node* head)
 31 | {
 32 |     struct Node *cur = head;
 33 |     struct Node *prev = NULL, *next = NULL;
 34 |     while(cur != NULL)
 35 |     {
 36 |         next = cur->next;
 37 |         cur->next = prev;
 38 |         prev = cur;
 39 |         cur = next;
 40 |     }
 41 |     return prev;
 42 | };
 43 | 
 44 | bool compareLists(struct Node *tmp1, struct Node *tmp2)
 45 | {
 46 |     while(tmp1 && tmp2)
 47 |     {
 48 |         if(tmp1->data != tmp2->data)
 49 |             return 0;
 50 |         tmp1 = tmp1->next;
 51 |         tmp2 = tmp2->next;
 52 |     }
 53 |     return 1;
 54 | }
 55 | 
 56 | struct Node* middlePoint(struct Node *head)
 57 | {
 58 |     struct Node *slow = head, *fast = head;
 59 |     while(fast != NULL && fast->next != NULL)
 60 |     {
 61 |         slow = slow->next;
 62 |         fast = fast->next->next;
 63 |     }
 64 |     return slow;
 65 | };
 66 | 
 67 | void checkPalindrome(struct Node *head)
 68 | {
 69 |     struct Node *tmp1 = head;
 70 |     struct Node *mid = middlePoint(head);
 71 |     struct Node *tmp2 = reverseList(mid);
 72 | 
 73 |     //cout<<tmp1->data<<" "<<tmp2->data<<endl;
 74 |     if(compareLists(tmp1, tmp2))
 75 |         cout<<"Palindrome\n";
 76 |     else
 77 |         cout<<"Not palindrome\n";
 78 | }
 79 | 
 80 | void printList(struct Node* node)
 81 | {
 82 |     while (node != NULL)
 83 |     {
 84 |         cout << node->data << " ";
 85 |         node = node->next;
 86 |     }
 87 |     cout<<endl;
 88 | }
 89 | 
 90 | int main()
 91 | {
 92 |     struct Node *head = NULL;
 93 |     for(int i=1; i<=2; i++)
 94 |         insertData(i, &head);
 95 | 
 96 |     for(int i=3; i>=1; i--)
 97 |         insertData(i, &head);
 98 | 
 99 |     printList(head);
100 |     checkPalindrome(head);
101 |     return 0;
102 | }
103 | 
104 | 
105 | 


--------------------------------------------------------------------------------
/TherapBD/Reverse a linklist.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | struct Node
 5 | {
 6 |     int data;
 7 |     struct Node *next;
 8 | };
 9 | 
10 | void insertData(int n, struct Node **head)
11 | {
12 |     struct Node *newnode = (struct Node*) malloc(sizeof(struct Node));
13 |     newnode->data = n;
14 |     newnode->next = NULL;
15 | 
16 |     if(*head==NULL)
17 |     {
18 |         *head = newnode;
19 |         return;
20 |     }
21 | 
22 |     struct Node *cur = *head;
23 |     while(cur->next != NULL)
24 |     {
25 |         cur = cur->next;
26 |     }
27 |     cur->next = newnode;
28 | }
29 | 
30 | struct Node* reverseList(struct Node* head)
31 | {
32 |     struct Node *cur = head;
33 |     struct Node *prev = NULL, *next = NULL;
34 |     while(cur != NULL)
35 |     {
36 |         next = cur->next;
37 |         cur->next = prev;
38 |         prev = cur;
39 |         cur = next;
40 |     }
41 |     return prev;
42 | };
43 | 
44 | void printList(struct Node* node)
45 | {
46 |     while (node != NULL)
47 |     {
48 |         cout << node->data << " ";
49 |         node = node->next;
50 |     }
51 |     cout<<endl;
52 | }
53 | 
54 | int main()
55 | {
56 |     struct Node *head = NULL;
57 |     for(int i=1; i<10; i++)
58 |         insertData(i, &head);
59 | 
60 |     printList(head);
61 |     head = reverseList(head);
62 |     printList(head);
63 |     return 0;
64 | }
65 | 
66 | 


--------------------------------------------------------------------------------
/TherapBD/Reverse string.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void reverse(string &s, int k)
 5 | {
 6 |     static int i = 0;
 7 |     if(s.size()==k)
 8 |         return;
 9 |     reverse(s, k+1);
10 |     if(i<=k)
11 |         swap(s[i++], s[k]);
12 | }
13 | 
14 | int main()
15 | {
16 |     string str;
17 |     cin>>str;
18 |     reverse(str, 0);
19 |     cout<<str<<endl;
20 |     return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/TherapBD/ReverseString.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void Reverse(string str, int k)
 5 | {
 6 |     if(k==str.size())
 7 |         return;
 8 |     Reverse(str, k+1);
 9 |     cout<<str[k];
10 | }
11 | 
12 | int main()
13 | {
14 |     string str;
15 |     cin>>str;
16 | 
17 |     Reverse(str, 0);
18 |     cout<<endl;
19 |     return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/TherapBD/Runtime polymorphism.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class base{
 5 | public:
 6 |     void virtual print()
 7 |     {
 8 |         cout<<"Base class\n";
 9 |     }
10 | };
11 | 
12 | class derived : public base
13 | {
14 | public:
15 |     void print()
16 |     {
17 |         cout<<"Derived class\n";
18 |     }
19 | };
20 | 
21 | int main()
22 | {
23 |     base *bptr;
24 |     derived d;
25 |     bptr = &d;
26 |     bptr->print();
27 |     return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/TherapBD/String Spilt.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     string str;
 7 |     getline(cin, str);
 8 | 
 9 |     vector<string>word;
10 |     stringstream ss(str);
11 | 
12 |     string s;
13 |     while (getline(ss, s, '-')) {
14 |         word.push_back(s);
15 |         cout<<s<<endl;
16 |     }
17 |     return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/TherapBD/Valid Phone Number2.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | bool valid(string s)
 5 | {
 6 |     if(s.size()==10)
 7 |     {
 8 |         for(int i=0; i<s.size(); i++)
 9 |             if(!isdigit(s[i]))
10 |                 return 0;
11 |         return 1;
12 |     }
13 |     else if(s.size()==12)
14 |     {
15 |         for(int i=0; i<s.size(); i++)
16 |         {
17 |            if(i==3 || i==8)
18 |            {
19 |                if(s[i] != '-')
20 |                   return 0;
21 |            }
22 |            else if(!isdigit(s[i]))
23 |                 return 0;
24 |         }
25 |         return 1;
26 |     }
27 |     else
28 |         return 1;
29 | }
30 | 
31 | int main()
32 | {
33 |     string str;
34 |     cin>>str;
35 | 
36 |     if(valid(str))
37 |         cout<<"Valid Number\n";
38 |     else
39 |         cout<<"Invalid Number\n";
40 |     return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/TherapBD/Valid licence number check.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | map<string, bool> mp;
 5 | 
 6 | bool valid(string s)
 7 | {
 8 |     int cnt = 0;
 9 |     mp["Ka"] = mp["Kha"] = mp["Ga"] = mp["Gha"] = mp["UMA"] = 1;
10 |     string tmp = "";
11 |     for(int i=0; i<s.size(); i++)
12 |     {
13 |         if(s[i]=='-')
14 |         {
15 |             cnt++;
16 |             if(cnt==1 && !mp[tmp])
17 |                 return 0;
18 |             if(cnt==2)
19 |             {
20 |                 int num = 0;
21 |                 for(int j=0; j<tmp.size(); j++)
22 |                 {
23 |                     if(isdigit(tmp[j]))
24 |                         num = num * 10 + (tmp[j]-'0');
25 |                     else
26 |                         return 0;
27 |                 }
28 |                 if(num < 11 || num > 99)
29 |                     return 0;
30 |             }
31 |             tmp = "";
32 |         }
33 |         else
34 |             tmp.push_back(s[i]);
35 |     }
36 | 
37 |     int num = 0;
38 |     for(int j=0; j<tmp.size(); j++)
39 |     {
40 |         if(isdigit(tmp[j]))
41 |             num = num * 10 + (tmp[j]-'0');
42 |         else
43 |             return 0;
44 |     }
45 |     if(cnt != 2 || num > 9999)
46 |         return 0;
47 | 
48 |     return 1;
49 | }
50 | 
51 | int main()
52 | {
53 |     cout<<"Enter Licence number: ";
54 |     string str;
55 |     cin>>str;
56 | 
57 |     if(valid(str))
58 |         cout<<"Valid Number\n";
59 |     else
60 |         cout<<"Invalid Number\n";
61 |     return 0;
62 | }
63 | 
64 | 


--------------------------------------------------------------------------------
/TherapBD/find specifc string.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     map<string, bool> mp;
 7 |     for(int i=0; i<5; i++)
 8 |     {
 9 |         string str;
10 |         cin>>str;
11 |         mp[str] = 1;
12 |     }
13 |     return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/TherapBD/friend function and class.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class A{
 5 |     int x;
 6 | public:
 7 |     friend class B;
 8 |     A(){
 9 |         x = 50;
10 |     }
11 |     friend void show(A f);
12 | };
13 | 
14 | class B{
15 | public:
16 |     void fun(A t)
17 |     {
18 |         cout<<t.x<<endl;
19 |     }
20 | };
21 | 
22 | void show(A f)
23 | {
24 |     cout<<f.x<<endl;
25 | }
26 | 
27 | int main()
28 | {
29 |     A a;
30 |     B b;
31 |     b.fun(a);
32 |     show(a);
33 |     return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/TherapBD/insert into BST.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class node
 5 | {
 6 | public:
 7 |     int data;
 8 |     node* left;
 9 |     node* right;
10 | 
11 |     node(int data)
12 |     {
13 |         this->data = data;
14 |         this->left = NULL;
15 |         this->right = NULL;
16 |     }
17 | };
18 | 
19 | node* insertBST(int n, node *root)
20 | {
21 |     if(root==NULL)
22 |     {
23 |         return root = new node(n);
24 |     }
25 |     if(root->data > n)
26 |         root->left = insertBST(n, root->left);
27 |     else
28 |         root->right = insertBST(n, root->right);
29 | 
30 | }
31 | 
32 | void inorder(node *root)
33 | {
34 |     if(root==NULL)
35 |         return;
36 |     inorder(root->left);
37 |     cout<<root->data<<" ";
38 |     inorder(root->right);
39 | }
40 | 
41 | int main()
42 | {
43 |     node *head = NULL;
44 |     for(int i=1; i<10; i++)
45 |         head = insertBST(i, head);
46 | 
47 |     inorder(head);
48 |     return 0;
49 | }
50 | 
51 | 
52 | 


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