├── Module 1
    ├── .gitignore
    ├── adjacency_list.cpp
    ├── adjacency_matrix.cpp
    ├── edge_list.cpp
    └── stl_pair.cpp
├── Module 10
    ├── .gitignore
    └── dsu.cpp
├── Module 11
    ├── .gitignore
    ├── cycle_detection.cpp
    └── mst.cpp
├── Module 13
    ├── .gitignore
    ├── adj_list_to_matrix.cpp
    ├── adj_list_to_matrix_2.cpp
    ├── adjacency_list_to_edge.cpp
    ├── edge_to_adjacency_list.cpp
    ├── edge_to_matrix.cpp
    ├── matrix_to_adjacency_list.cpp
    ├── matrix_to_adjacency_list_2.cpp
    ├── matrix_to_edge_list.cpp
    └── matrix_to_edge_list_2.cpp
├── Module 14
    ├── .gitignore
    ├── Building_Roads.cpp
    ├── C_Dijkstra.cpp
    ├── Message_Route.cpp
    ├── Message_Route_2.cpp
    ├── Romeo_and_Juliet.cpp
    └── mst.cpp
├── Module 15
    ├── .gitignore
    ├── Commandos.cpp
    ├── D_Roads_not_only_in_Berland.cpp
    ├── Guilty_Prince.cpp
    └── sundarban.cpp
├── Module 17
    ├── .gitignore
    ├── factorial.cpp
    ├── fibonacci.cpp
    └── fibonacci_bottom_up.cpp
├── Module 18
    ├── .gitignore
    ├── 0-1_knapsack.cpp
    ├── 0-1_knapsack_bottom_up.cpp
    └── 0-1_knapsack_top_down.cpp
├── Module 19
    ├── .gitignore
    ├── count_of_subset_sum.cpp
    ├── equal_sum.cpp
    ├── minimum_subset_sum_difference.cpp
    ├── subset_sum_bottom_up.cpp
    └── subset_sum_top_down.cpp
├── Module 2
    ├── .gitignore
    ├── bfs_traversal.cpp
    ├── bfs_with_level.cpp
    ├── bfs_with_level_pair.cpp
    └── path_printing.cpp
├── Module 21
    ├── .gitignore
    ├── coin_change_1.cpp
    ├── coin_change_2.cpp
    ├── rod_cutting.cpp
    ├── unbounded_knapsack.cpp
    └── unbounded_knapsack_bottom_up.cpp
├── Module 22
    ├── .gitignore
    ├── lcs_bottom_up.cpp
    ├── lcs_print.cpp
    ├── lcs_top_down.cpp
    └── longest_common_substring.cpp
├── Module 23
    ├── .gitignore
    ├── divide.cpp
    ├── merge.cpp
    └── merge_sort.cpp
├── Module 3
    ├── .gitignore
    ├── bfs_on_2d.cpp
    ├── component.cpp
    ├── dfs.cpp
    └── dfs_on_2d.cpp
├── Module 5
    ├── .gitignore
    ├── cycle_detect_in_directed_graph.cpp
    ├── cycle_detect_using_bfs.cpp
    └── cycle_detect_using_dfs.cpp
├── Module 6
    ├── .gitignore
    ├── dijkstra_naive.cpp
    └── dijkstra_optimized.cpp
├── Module 7
    ├── .gitignore
    ├── bellman_ford.cpp
    ├── detect_negative_cycle.cpp
    └── floyd.cpp
├── Module 9
    ├── .gitignore
    ├── Count_Sub_Islands.cpp
    ├── Find_if_Path_Exists_in_Graph.cpp
    ├── Island Parameter.cpp
    ├── Max_Area_of_Island.cpp
    ├── Number_of_Closed_Islands.cpp
    └── Number_of_Islands.cpp
└── README.md


/Module 1/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 1/adjacency_list.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n, e;
 6 |     cin >> n >> e;
 7 |     vector<int> mat[n];
 8 |     while (e--)
 9 |     {
10 |         int a, b;
11 |         cin >> a >> b;
12 |         mat[a].push_back(b);
13 |         mat[b].push_back(a);
14 |     }
15 |     vector<int> v;
16 |     for (int i = 0; i < mat[3].size(); i++)
17 |     {
18 |         cout << mat[3][i] << " ";
19 |     }
20 |     return 0;
21 | }


--------------------------------------------------------------------------------
/Module 1/adjacency_matrix.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n, e;
 6 |     cin >> n >> e;
 7 |     int mat[n][n];
 8 |     memset(mat, 0, sizeof(mat));
 9 |     while (e--)
10 |     {
11 |         int a, b;
12 |         cin >> a >> b;
13 |         mat[a][b] = 1;
14 |         mat[b][a] = 1;
15 |     }
16 |     if (mat[3][1] == 1)
17 |         cout << "connection ache";
18 |     else
19 |         cout << "connection nai";
20 |     return 0;
21 | }


--------------------------------------------------------------------------------
/Module 1/edge_list.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n, e;
 6 |     cin >> n >> e;
 7 |     vector<pair<int, int>> v;
 8 |     while (e--)
 9 |     {
10 |         int a, b;
11 |         cin >> a >> b;
12 |         v.push_back({a, b});
13 |     }
14 |     // for (int i = 0; i < v.size(); i++)
15 |     // {
16 |     //     cout << v[i].first << " " << v[i].second << endl;
17 |     // }
18 |     for (auto p : v)
19 |     {
20 |         cout << p.first << " " << p.second << endl;
21 |     }
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/Module 1/stl_pair.cpp:
--------------------------------------------------------------------------------
1 | #include <bits/stdc++.h>
2 | using namespace std;
3 | int main()
4 | {
5 |     pair<string, int> p;
6 |     p = make_pair("rahat", 20);
7 |     cout << p.first << " " << p.second << endl;
8 |     return 0;
9 | }


--------------------------------------------------------------------------------
/Module 10/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 10/dsu.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 1e5 + 5;
 4 | int par[N];
 5 | int group_size[N];
 6 | int level[N];
 7 | void dsu_initialize(int n)
 8 | {
 9 |     for (int i = 0; i < n; i++)
10 |     {
11 |         par[i] = -1;
12 |         group_size[i] = 1;
13 |         level[i] = 0;
14 |     }
15 | }
16 | int dsu_find(int node)
17 | {
18 |     if (par[node] == -1)
19 |         return node;
20 |     int leader = dsu_find(par[node]);
21 |     par[node] = leader;
22 |     return leader;
23 | }
24 | void dsu_union(int node1, int node2)
25 | {
26 |     // bad
27 |     int leaderA = dsu_find(node1);
28 |     int leaderB = dsu_find(node2);
29 |     par[leaderA] = leaderB;
30 | }
31 | void dsu_union_by_level(int node1, int node2)
32 | {
33 |     int leaderA = dsu_find(node1);
34 |     int leaderB = dsu_find(node2);
35 |     if (level[leaderA] > level[leaderB])
36 |     {
37 |         par[leaderB] = leaderA;
38 |     }
39 |     else if (level[leaderB] > level[leaderA])
40 |     {
41 |         par[leaderA] = leaderB;
42 |     }
43 |     else
44 |     {
45 |         par[leaderA] = leaderB;
46 |         level[leaderB]++;
47 |     }
48 | }
49 | void dsu_union_by_size(int node1, int node2)
50 | {
51 |     int leaderA = dsu_find(node1);
52 |     int leaderB = dsu_find(node2);
53 |     if (group_size[leaderA] > group_size[leaderB])
54 |     {
55 |         par[leaderB] = leaderA;
56 |         group_size[leaderA] += group_size[leaderB];
57 |     }
58 |     else
59 |     {
60 |         par[leaderA] = leaderB;
61 |         group_size[leaderB] += group_size[leaderA];
62 |     }
63 | }
64 | int main()
65 | {
66 |     dsu_initialize(7);
67 |     dsu_union_by_level(1, 2);
68 |     dsu_union_by_level(2, 3);
69 |     dsu_union_by_level(4, 5);
70 |     dsu_union_by_level(5, 6);
71 |     dsu_union_by_level(1, 4);
72 |     cout << dsu_find(1) << endl;
73 |     cout << dsu_find(4) << endl;
74 |     return 0;
75 | }


--------------------------------------------------------------------------------
/Module 11/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 11/cycle_detection.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 1e5 + 5;
 4 | int parent[N];
 5 | int group_size[N];
 6 | void dsu_initialize(int n)
 7 | {
 8 |     for (int i = 0; i < n; i++)
 9 |     {
10 |         parent[i] = -1;
11 |         group_size[i] = 1;
12 |     }
13 | }
14 | int dsu_find(int node)
15 | {
16 |     if (parent[node] == -1)
17 |         return node;
18 |     int leader = dsu_find(parent[node]);
19 |     parent[node] = leader;
20 |     return leader;
21 | }
22 | void dsu_union_by_size(int node1, int node2)
23 | {
24 |     int leaderA = dsu_find(node1);
25 |     int leaderB = dsu_find(node2);
26 |     if (group_size[leaderA] > group_size[leaderB])
27 |     {
28 |         parent[leaderB] = leaderA;
29 |         group_size[leaderA] += group_size[leaderB];
30 |     }
31 |     else
32 |     {
33 |         parent[leaderA] = leaderB;
34 |         group_size[leaderB] += group_size[leaderA];
35 |     }
36 | }
37 | int main()
38 | {
39 |     int n, e;
40 |     cin >> n >> e;
41 |     dsu_initialize(n);
42 |     bool cycle = false;
43 |     while (e--)
44 |     {
45 |         int a, b;
46 |         cin >> a >> b;
47 |         int leaderA = dsu_find(a);
48 |         int leaderB = dsu_find(b);
49 |         if (leaderA == leaderB)
50 |         {
51 |             cycle = true;
52 |         }
53 |         else
54 |         {
55 |             dsu_union_by_size(a, b);
56 |         }
57 |     }
58 |     if (cycle)
59 |     {
60 |         cout << "Cycle found" << endl;
61 |     }
62 |     else
63 |     {
64 |         cout << "Cycle not found" << endl;
65 |     }
66 |     return 0;
67 | }


--------------------------------------------------------------------------------
/Module 11/mst.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 1e5 + 5;
 4 | int parent[N];
 5 | int group_size[N];
 6 | void dsu_initialize(int n)
 7 | {
 8 |     for (int i = 0; i < n; i++)
 9 |     {
10 |         parent[i] = -1;
11 |         group_size[i] = 1;
12 |     }
13 | }
14 | int dsu_find(int node)
15 | {
16 |     if (parent[node] == -1)
17 |         return node;
18 |     int leader = dsu_find(parent[node]);
19 |     parent[node] = leader;
20 |     return leader;
21 | }
22 | void dsu_union_by_size(int node1, int node2)
23 | {
24 |     int leaderA = dsu_find(node1);
25 |     int leaderB = dsu_find(node2);
26 |     if (group_size[leaderA] > group_size[leaderB])
27 |     {
28 |         parent[leaderB] = leaderA;
29 |         group_size[leaderA] += group_size[leaderB];
30 |     }
31 |     else
32 |     {
33 |         parent[leaderA] = leaderB;
34 |         group_size[leaderB] += group_size[leaderA];
35 |     }
36 | }
37 | class Edge
38 | {
39 | public:
40 |     int u, v, w;
41 |     Edge(int u, int v, int w)
42 |     {
43 |         this->u = u;
44 |         this->v = v;
45 |         this->w = w;
46 |     }
47 | };
48 | bool cmp(Edge a, Edge b)
49 | {
50 |     return a.w < b.w;
51 | }
52 | int main()
53 | {
54 |     int n, e;
55 |     cin >> n >> e;
56 |     dsu_initialize(n);
57 |     vector<Edge> edgeList;
58 |     while (e--)
59 |     {
60 |         int u, v, w;
61 |         cin >> u >> v >> w;
62 |         edgeList.push_back(Edge(u, v, w));
63 |     }
64 |     sort(edgeList.begin(), edgeList.end(), cmp);
65 |     int totalCost = 0;
66 |     for (Edge ed : edgeList)
67 |     {
68 |         int leaderU = dsu_find(ed.u);
69 |         int leaderV = dsu_find(ed.v);
70 |         if (leaderU == leaderV)
71 |         {
72 |             continue;
73 |         }
74 |         else
75 |         {
76 |             dsu_union_by_size(ed.u, ed.v);
77 |             totalCost += ed.w;
78 |         }
79 |     }
80 |     cout << totalCost << endl;
81 |     return 0;
82 | }


--------------------------------------------------------------------------------
/Module 13/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 13/adj_list_to_matrix.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | void convert(int n, vector<int> adj[])
 4 | {
 5 |     int mat[n][n];
 6 |     for (int i = 0; i < n; i++)
 7 |     {
 8 |         for (int j = 0; j < n; j++)
 9 |         {
10 |             mat[i][j] = 0;
11 |             if (i == j)
12 |                 mat[i][j] = 1;
13 |         }
14 |     }
15 |     for (int i = 0; i < n; i++)
16 |     {
17 |         for (int child : adj[i])
18 |         {
19 |             mat[i][child] = 1;
20 |         }
21 |     }
22 |     for (int i = 0; i < n; i++)
23 |     {
24 |         for (int j = 0; j < n; j++)
25 |         {
26 |             cout << mat[i][j] << " ";
27 |         }
28 |         cout << endl;
29 |     }
30 | }
31 | int main()
32 | {
33 |     int n, e;
34 |     cin >> n >> e;
35 |     vector<int> v[n];
36 |     while (e--)
37 |     {
38 |         int a, b;
39 |         cin >> a >> b;
40 |         v[a].push_back(b);
41 |         v[b].push_back(a);
42 |     }
43 |     convert(n, v);
44 |     return 0;
45 | }


--------------------------------------------------------------------------------
/Module 13/adj_list_to_matrix_2.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | void convert(int n, vector<pair<int, int>> adj[])
 4 | {
 5 |     int mat[n][n];
 6 |     for (int i = 0; i < n; i++)
 7 |     {
 8 |         for (int j = 0; j < n; j++)
 9 |         {
10 |             mat[i][j] = -1;
11 |             if (i == j)
12 |                 mat[i][j] = 0;
13 |         }
14 |     }
15 |     for (int i = 0; i < n; i++)
16 |     {
17 |         for (pair<int, int> child : adj[i])
18 |         {
19 |             int childNode = child.first;
20 |             int cost = child.second;
21 |             mat[i][childNode] = cost;
22 |         }
23 |     }
24 |     for (int i = 0; i < n; i++)
25 |     {
26 |         for (int j = 0; j < n; j++)
27 |         {
28 |             cout << mat[i][j] << " ";
29 |         }
30 |         cout << endl;
31 |     }
32 | }
33 | int main()
34 | {
35 |     int n, e;
36 |     cin >> n >> e;
37 |     vector<pair<int, int>> v[n];
38 |     while (e--)
39 |     {
40 |         int a, b, c;
41 |         cin >> a >> b >> c;
42 |         v[a].push_back({b, c});
43 |     }
44 |     convert(n, v);
45 |     return 0;
46 | }


--------------------------------------------------------------------------------
/Module 13/adjacency_list_to_edge.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | class Edge
 4 | {
 5 | public:
 6 |     int u, v, w;
 7 |     Edge(int u, int v, int w)
 8 |     {
 9 |         this->u = u;
10 |         this->v = v;
11 |         this->w = w;
12 |     }
13 | };
14 | int main()
15 | {
16 |     int n, e;
17 |     cin >> n >> e;
18 |     vector<pair<int, int>> v[n];
19 |     while (e--)
20 |     {
21 |         int a, b, c;
22 |         cin >> a >> b >> c;
23 |         v[a].push_back({b, c});
24 |     }
25 |     vector<Edge> edgeList;
26 |     for (int i = 0; i < n; i++)
27 |     {
28 |         for (pair<int, int> child : v[i])
29 |         {
30 |             int childNode = child.first;
31 |             int cost = child.second;
32 |             edgeList.push_back(Edge(i, childNode, cost));
33 |         }
34 |     }
35 |     for (Edge edge : edgeList)
36 |     {
37 |         cout << edge.u << " " << edge.v << " " << edge.w << endl;
38 |     }
39 |     return 0;
40 | }


--------------------------------------------------------------------------------
/Module 13/edge_to_adjacency_list.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n, e;
 6 |     cin >> n >> e;
 7 |     vector<pair<int, int>> v[n];
 8 |     while (e--)
 9 |     {
10 |         int a, b, c;
11 |         cin >> a >> b >> c;
12 |         v[a].push_back({b, c});
13 |     }
14 |     for (int i = 0; i < n; i++)
15 |     {
16 |         cout << i << " -> ";
17 |         for (pair<int, int> child : v[i])
18 |         {
19 |             cout << "{" << child.first << ", " << child.second << "} ";
20 |         }
21 |         cout << endl;
22 |     }
23 |     return 0;
24 | }


--------------------------------------------------------------------------------
/Module 13/edge_to_matrix.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n, e;
 6 |     cin >> n >> e;
 7 |     int mat[n][n];
 8 |     for (int i = 0; i < n; i++)
 9 |     {
10 |         for (int j = 0; j < n; j++)
11 |         {
12 |             mat[i][j] = -1;
13 |             if (i == j)
14 |                 mat[i][j] = 0;
15 |         }
16 |     }
17 |     while (e--)
18 |     {
19 |         int a, b, c;
20 |         cin >> a >> b >> c;
21 |         mat[a][b] = c;
22 |         mat[b][a] = c;
23 |     }
24 |     for (int i = 0; i < n; i++)
25 |     {
26 |         for (int j = 0; j < n; j++)
27 |         {
28 |             cout << mat[i][j] << " ";
29 |         }
30 |         cout << endl;
31 |     }
32 |     return 0;
33 | }


--------------------------------------------------------------------------------
/Module 13/matrix_to_adjacency_list.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n;
 6 |     cin >> n;
 7 |     int mat[n][n];
 8 |     for (int i = 0; i < n; i++)
 9 |     {
10 |         for (int j = 0; j < n; j++)
11 |         {
12 |             cin >> mat[i][j];
13 |         }
14 |     }
15 |     vector<int> v[n];
16 |     for (int i = 0; i < n; i++)
17 |     {
18 |         for (int j = 0; j < n; j++)
19 |         {
20 |             if (mat[i][j] == 1 && i != j)
21 |             {
22 |                 v[i].push_back(j);
23 |             }
24 |         }
25 |     }
26 |     for (int i = 0; i < n; i++)
27 |     {
28 |         cout << i << " -> ";
29 |         for (int child : v[i])
30 |         {
31 |             cout << child << " ";
32 |         }
33 |         cout << endl;
34 |     }
35 |     return 0;
36 | }


--------------------------------------------------------------------------------
/Module 13/matrix_to_adjacency_list_2.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n;
 6 |     cin >> n;
 7 |     int mat[n][n];
 8 |     for (int i = 0; i < n; i++)
 9 |     {
10 |         for (int j = 0; j < n; j++)
11 |         {
12 |             cin >> mat[i][j];
13 |         }
14 |     }
15 |     vector<pair<int, int>> v[n];
16 |     for (int i = 0; i < n; i++)
17 |     {
18 |         for (int j = 0; j < n; j++)
19 |         {
20 |             if (mat[i][j] > 0)
21 |             {
22 |                 v[i].push_back({j, mat[i][j]});
23 |             }
24 |         }
25 |     }
26 |     for (int i = 0; i < n; i++)
27 |     {
28 |         cout << i << " -> ";
29 |         for (pair<int, int> child : v[i])
30 |         {
31 |             cout << "{" << child.first << ", " << child.second << "} ";
32 |         }
33 |         cout << endl;
34 |     }
35 |     return 0;
36 | }


--------------------------------------------------------------------------------
/Module 13/matrix_to_edge_list.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n;
 6 |     cin >> n;
 7 |     int mat[n][n];
 8 |     for (int i = 0; i < n; i++)
 9 |     {
10 |         for (int j = 0; j < n; j++)
11 |         {
12 |             cin >> mat[i][j];
13 |         }
14 |     }
15 |     vector<pair<int, int>> edgeList;
16 |     for (int i = 0; i < n; i++)
17 |     {
18 |         for (int j = 0; j < n; j++)
19 |         {
20 |             if (mat[i][j] == 1 && i != j)
21 |             {
22 |                 edgeList.push_back({i, j});
23 |             }
24 |         }
25 |     }
26 |     for (pair<int, int> edge : edgeList)
27 |     {
28 |         cout << edge.first << " " << edge.second << endl;
29 |     }
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/Module 13/matrix_to_edge_list_2.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | class Edge
 4 | {
 5 | public:
 6 |     int u, v, w;
 7 |     Edge(int u, int v, int w)
 8 |     {
 9 |         this->u = u;
10 |         this->v = v;
11 |         this->w = w;
12 |     }
13 | };
14 | int main()
15 | {
16 |     int n;
17 |     cin >> n;
18 |     int mat[n][n];
19 |     for (int i = 0; i < n; i++)
20 |     {
21 |         for (int j = 0; j < n; j++)
22 |         {
23 |             cin >> mat[i][j];
24 |         }
25 |     }
26 |     vector<Edge> edgeList;
27 |     for (int i = 0; i < n; i++)
28 |     {
29 |         for (int j = 0; j < n; j++)
30 |         {
31 |             if (mat[i][j] > 0)
32 |             {
33 |                 edgeList.push_back(Edge(i, j, mat[i][j]));
34 |             }
35 |         }
36 |     }
37 |     for (Edge edge : edgeList)
38 |     {
39 |         cout << edge.u << " " << edge.v << " " << edge.w << endl;
40 |     }
41 |     return 0;
42 | }


--------------------------------------------------------------------------------
/Module 14/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 14/Building_Roads.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 1e5 + 5;
 4 | int parent[N];
 5 | int group_size[N];
 6 | void dsu_initialize(int n)
 7 | {
 8 |     for (int i = 1; i <= n; i++)
 9 |     {
10 |         parent[i] = -1;
11 |         group_size[i] = 1;
12 |     }
13 | }
14 | int dsu_find(int node)
15 | {
16 |     if (parent[node] == -1)
17 |         return node;
18 |     int leader = dsu_find(parent[node]);
19 |     parent[node] = leader;
20 |     return leader;
21 | }
22 | void dsu_union_by_size(int node1, int node2)
23 | {
24 |     int leaderA = dsu_find(node1);
25 |     int leaderB = dsu_find(node2);
26 |     if (group_size[leaderA] > group_size[leaderB])
27 |     {
28 |         parent[leaderB] = leaderA;
29 |         group_size[leaderA] += group_size[leaderB];
30 |     }
31 |     else
32 |     {
33 |         parent[leaderA] = leaderB;
34 |         group_size[leaderB] += group_size[leaderA];
35 |     }
36 | }
37 | int main()
38 | {
39 |     int n, e;
40 |     cin >> n >> e;
41 |     dsu_initialize(n);
42 |     while (e--)
43 |     {
44 |         int a, b;
45 |         cin >> a >> b;
46 |         int leaderA = dsu_find(a);
47 |         int leaderB = dsu_find(b);
48 |         if (leaderA != leaderB)
49 |         {
50 |             dsu_union_by_size(a, b);
51 |         }
52 |     }
53 |     vector<int> leader;
54 |     for (int i = 1; i <= n; i++)
55 |     {
56 |         leader.push_back(dsu_find(i));
57 |     }
58 |     sort(leader.begin(), leader.end());
59 |     leader.erase(unique(leader.begin(), leader.end()), leader.end());
60 |     cout << leader.size() - 1 << endl;
61 |     for (int i = 0; i < leader.size() - 1; i++)
62 |     {
63 |         cout << leader[i] << " " << leader[i + 1] << endl;
64 |     }
65 |     return 0;
66 | }


--------------------------------------------------------------------------------
/Module 14/C_Dijkstra.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long
 3 | #define pi pair<ll, ll>
 4 | using namespace std;
 5 | const ll N = 1e5 + 5;
 6 | vector<pi> v[N];
 7 | ll dis[N];
 8 | ll par[N];
 9 | class cmp
10 | {
11 | public:
12 |     bool operator()(pi a, pi b)
13 |     {
14 |         return a.second > b.second;
15 |     }
16 | };
17 | void dijkstra(ll s)
18 | {
19 |     priority_queue<pi, vector<pi>, cmp> pq;
20 |     pq.push({s, 0});
21 |     dis[s] = 0;
22 |     while (!pq.empty())
23 |     {
24 |         pi parent = pq.top();
25 |         pq.pop();
26 |         ll parentNode = parent.first;
27 |         ll parentCost = parent.second;
28 |         for (pi child : v[parentNode])
29 |         {
30 |             ll childNode = child.first;
31 |             ll childCost = child.second;
32 |             if (parentCost + childCost < dis[childNode])
33 |             {
34 |                 dis[childNode] = parentCost + childCost;
35 |                 pq.push({childNode, dis[childNode]});
36 |                 par[childNode] = parentNode;
37 |             }
38 |         }
39 |     }
40 | }
41 | int main()
42 | {
43 |     ll n, e;
44 |     cin >> n >> e;
45 |     while (e--)
46 |     {
47 |         ll a, b, c;
48 |         cin >> a >> b >> c;
49 |         v[a].push_back({b, c});
50 |         v[b].push_back({a, c});
51 |     }
52 |     for (ll i = 1; i <= n; i++)
53 |     {
54 |         dis[i] = 1e18;
55 |         par[i] = -1;
56 |     }
57 |     dijkstra(1);
58 |     if (dis[n] == 1e18)
59 |         cout << -1 << endl;
60 |     else
61 |     {
62 |         ll x = n;
63 |         vector<ll> path;
64 |         while (x != -1)
65 |         {
66 |             path.push_back(x);
67 |             x = par[x];
68 |         }
69 |         reverse(path.begin(), path.end());
70 |         for (ll val : path)
71 |             cout << val << " ";
72 |         cout << endl;
73 |     }
74 |     return 0;
75 | }


--------------------------------------------------------------------------------
/Module 14/Message_Route.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 1e5 + 5;
 4 | vector<int> v[N];
 5 | bool vis[N];
 6 | int dis[N];
 7 | int parent[N];
 8 | void bfs(int s)
 9 | {
10 |     queue<int> q;
11 |     q.push(s);
12 |     vis[s] = true;
13 |     dis[s] = 0;
14 |     while (!q.empty())
15 |     {
16 |         int par = q.front();
17 |         q.pop();
18 |         for (int child : v[par])
19 |         {
20 |             if (!vis[child])
21 |             {
22 |                 vis[child] = true;
23 |                 q.push(child);
24 |                 dis[child] = dis[par] + 1;
25 |                 parent[child] = par;
26 |             }
27 |         }
28 |     }
29 | }
30 | int main()
31 | {
32 |     int n, e;
33 |     cin >> n >> e;
34 |     while (e--)
35 |     {
36 |         int a, b;
37 |         cin >> a >> b;
38 |         v[a].push_back(b);
39 |         v[b].push_back(a);
40 |     }
41 |     memset(vis, false, sizeof(vis));
42 |     memset(dis, -1, sizeof(dis));
43 |     memset(parent, -1, sizeof(parent));
44 |     bfs(1);
45 |     if (dis[n] == -1)
46 |         cout << "IMPOSSIBLE" << endl;
47 |     else
48 |     {
49 |         int x = n;
50 |         vector<int> path;
51 |         while (x != -1)
52 |         {
53 |             path.push_back(x);
54 |             x = parent[x];
55 |         }
56 |         reverse(path.begin(), path.end());
57 |         cout << path.size() << endl;
58 |         for (int val : path)
59 |             cout << val << " ";
60 |         cout << endl;
61 |     }
62 |     return 0;
63 | }


--------------------------------------------------------------------------------
/Module 14/Message_Route_2.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 1e5 + 5;
 4 | vector<int> v[N];
 5 | bool vis[N];
 6 | int parent[N];
 7 | void bfs(int s)
 8 | {
 9 |     queue<int> q;
10 |     q.push(s);
11 |     vis[s] = true;
12 |     while (!q.empty())
13 |     {
14 |         int par = q.front();
15 |         q.pop();
16 |         for (int child : v[par])
17 |         {
18 |             if (!vis[child])
19 |             {
20 |                 vis[child] = true;
21 |                 q.push(child);
22 |                 parent[child] = par;
23 |             }
24 |         }
25 |     }
26 | }
27 | int main()
28 | {
29 |     int n, e;
30 |     cin >> n >> e;
31 |     while (e--)
32 |     {
33 |         int a, b;
34 |         cin >> a >> b;
35 |         v[a].push_back(b);
36 |         v[b].push_back(a);
37 |     }
38 |     memset(vis, false, sizeof(vis));
39 |     memset(parent, -1, sizeof(parent));
40 |     bfs(1);
41 |     int x = n;
42 |     vector<int> path;
43 |     while (x != -1)
44 |     {
45 |         path.push_back(x);
46 |         x = parent[x];
47 |     }
48 |     reverse(path.begin(), path.end());
49 |     if (path.size() == 1)
50 |         cout << "IMPOSSIBLE" << endl;
51 |     else
52 |     {
53 |         cout << path.size() << endl;
54 |         for (int val : path)
55 |             cout << val << " ";
56 |         cout << endl;
57 |     }
58 |     return 0;
59 | }


--------------------------------------------------------------------------------
/Module 14/Romeo_and_Juliet.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 1e5 + 5;
 4 | vector<int> v[N];
 5 | bool vis[N];
 6 | int dis[N];
 7 | void bfs(int s)
 8 | {
 9 |     queue<int> q;
10 |     q.push(s);
11 |     vis[s] = true;
12 |     dis[s] = 0;
13 |     while (!q.empty())
14 |     {
15 |         int par = q.front();
16 |         q.pop();
17 |         for (int child : v[par])
18 |         {
19 |             if (!vis[child])
20 |             {
21 |                 vis[child] = true;
22 |                 q.push(child);
23 |                 dis[child] = dis[par] + 1;
24 |             }
25 |         }
26 |     }
27 | }
28 | int main()
29 | {
30 |     int n, e;
31 |     cin >> n >> e;
32 |     while (e--)
33 |     {
34 |         int a, b;
35 |         cin >> a >> b;
36 |         v[a].push_back(b);
37 |         v[b].push_back(a);
38 |     }
39 |     memset(vis, false, sizeof(vis));
40 |     memset(dis, -1, sizeof(dis));
41 |     int src, d, k;
42 |     cin >> src >> d >> k;
43 |     bfs(src);
44 |     if (dis[d] != -1 && dis[d] <= k * 2)
45 |         cout << "YES" << endl;
46 |     else
47 |         cout << "NO" << endl;
48 |     return 0;
49 | }


--------------------------------------------------------------------------------
/Module 14/mst.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 1e5 + 5;
 4 | int parent[N];
 5 | int group_size[N];
 6 | void dsu_initialize(int n)
 7 | {
 8 |     for (int i = 0; i < n; i++)
 9 |     {
10 |         parent[i] = -1;
11 |         group_size[i] = 1;
12 |     }
13 | }
14 | int dsu_find(int node)
15 | {
16 |     if (parent[node] == -1)
17 |         return node;
18 |     int leader = dsu_find(parent[node]);
19 |     parent[node] = leader;
20 |     return leader;
21 | }
22 | void dsu_union_by_size(int node1, int node2)
23 | {
24 |     int leaderA = dsu_find(node1);
25 |     int leaderB = dsu_find(node2);
26 |     if (group_size[leaderA] > group_size[leaderB])
27 |     {
28 |         parent[leaderB] = leaderA;
29 |         group_size[leaderA] += group_size[leaderB];
30 |     }
31 |     else
32 |     {
33 |         parent[leaderA] = leaderB;
34 |         group_size[leaderB] += group_size[leaderA];
35 |     }
36 | }
37 | class Edge
38 | {
39 | public:
40 |     int u, v, w;
41 |     Edge(int u, int v, int w)
42 |     {
43 |         this->u = u;
44 |         this->v = v;
45 |         this->w = w;
46 |     }
47 | };
48 | bool cmp(Edge a, Edge b)
49 | {
50 |     return a.w < b.w;
51 | }
52 | int main()
53 | {
54 |     int n, e;
55 |     cin >> n >> e;
56 |     dsu_initialize(n);
57 |     vector<Edge> edgeList;
58 |     while (e--)
59 |     {
60 |         int u, v, w;
61 |         cin >> u >> v >> w;
62 |         edgeList.push_back(Edge(u, v, w));
63 |     }
64 |     sort(edgeList.begin(), edgeList.end(), cmp);
65 |     int totalCost = 0;
66 |     for (Edge ed : edgeList)
67 |     {
68 |         int leaderU = dsu_find(ed.u);
69 |         int leaderV = dsu_find(ed.v);
70 |         if (leaderU == leaderV)
71 |         {
72 |             continue;
73 |         }
74 |         else
75 |         {
76 |             dsu_union_by_size(ed.u, ed.v);
77 |             totalCost += ed.w;
78 |         }
79 |     }
80 |     cout << totalCost << endl;
81 |     return 0;
82 | }


--------------------------------------------------------------------------------
/Module 15/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 15/Commandos.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 105;
 4 | vector<int> v[N];
 5 | int dis_from_src[N];
 6 | int dis_from_des[N];
 7 | bool vis[N];
 8 | void bfs(int s, int track)
 9 | {
10 |     queue<int> q;
11 |     q.push(s);
12 |     if (track == 1)
13 |         dis_from_src[s] = 0;
14 |     else
15 |         dis_from_des[s] = 0;
16 |     vis[s] = true;
17 |     while (!q.empty())
18 |     {
19 |         int par = q.front();
20 |         q.pop();
21 |         for (int child : v[par])
22 |         {
23 |             if (!vis[child])
24 |             {
25 |                 q.push(child);
26 |                 vis[child] = true;
27 |                 if (track == 1)
28 |                     dis_from_src[child] = dis_from_src[par] + 1;
29 |                 else
30 |                     dis_from_des[child] = dis_from_des[par] + 1;
31 |             }
32 |         }
33 |     }
34 | }
35 | int main()
36 | {
37 |     int t;
38 |     cin >> t;
39 |     int cs = 1;
40 |     while (t--)
41 |     {
42 |         int n, e;
43 |         cin >> n >> e;
44 |         while (e--)
45 |         {
46 |             int a, b;
47 |             cin >> a >> b;
48 |             v[a].push_back(b);
49 |             v[b].push_back(a);
50 |         }
51 |         int s, d;
52 |         cin >> s >> d;
53 |         memset(vis, false, sizeof(false));
54 |         memset(dis_from_src, -1, sizeof(dis_from_src));
55 |         bfs(s, 1);
56 |         for (int i = 0; i < n; i++)
57 |         {
58 |             vis[i] = false;
59 |         }
60 |         memset(dis_from_des, -1, sizeof(dis_from_des));
61 |         bfs(d, 2);
62 |         int ans = INT_MIN;
63 |         for (int i = 0; i < n; i++)
64 |         {
65 |             int val = dis_from_src[i] + dis_from_des[i];
66 |             ans = max(ans, val);
67 |         }
68 |         cout << "Case " << cs++ << ": " << ans << endl;
69 |         for (int i = 0; i < n; i++)
70 |         {
71 |             v[i].clear();
72 |         }
73 |     }
74 |     return 0;
75 | }


--------------------------------------------------------------------------------
/Module 15/D_Roads_not_only_in_Berland.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 1e5 + 5;
 4 | int parent[N];
 5 | int group_size[N];
 6 | void dsu_initialize(int n)
 7 | {
 8 |     for (int i = 1; i <= n; i++)
 9 |     {
10 |         parent[i] = -1;
11 |         group_size[i] = 1;
12 |     }
13 | }
14 | int dsu_find(int node)
15 | {
16 |     if (parent[node] == -1)
17 |         return node;
18 |     int leader = dsu_find(parent[node]);
19 |     parent[node] = leader;
20 |     return leader;
21 | }
22 | void dsu_union_by_size(int node1, int node2)
23 | {
24 |     int leaderA = dsu_find(node1);
25 |     int leaderB = dsu_find(node2);
26 |     if (group_size[leaderA] > group_size[leaderB])
27 |     {
28 |         parent[leaderB] = leaderA;
29 |         group_size[leaderA] += group_size[leaderB];
30 |     }
31 |     else
32 |     {
33 |         parent[leaderA] = leaderB;
34 |         group_size[leaderB] += group_size[leaderA];
35 |     }
36 | }
37 | int main()
38 | {
39 |     int n;
40 |     cin >> n;
41 |     dsu_initialize(n);
42 |     vector<pair<int, int>> bad;
43 |     vector<pair<int, int>> create;
44 |     for (int i = 1; i <= n - 1; i++)
45 |     {
46 |         int a, b;
47 |         cin >> a >> b;
48 |         int leaderA = dsu_find(a);
49 |         int leaderB = dsu_find(b);
50 |         if (leaderA == leaderB)
51 |         {
52 |             bad.push_back({a, b});
53 |         }
54 |         else
55 |         {
56 |             dsu_union_by_size(a, b);
57 |         }
58 |     }
59 |     cout << bad.size() << endl;
60 |     for (int i = 2; i <= n; i++)
61 |     {
62 |         int leaderA = dsu_find(1);
63 |         int leaderB = dsu_find(i);
64 |         if (leaderA != leaderB)
65 |         {
66 |             create.push_back({1, i});
67 |             dsu_union_by_size(1, i);
68 |         }
69 |     }
70 |     for (int i = 0; i < bad.size(); i++)
71 |     {
72 |         cout << bad[i].first << " " << bad[i].second << " " << create[i].first << " " << create[i].second << endl;
73 |     }
74 |     return 0;
75 | }


--------------------------------------------------------------------------------
/Module 15/Guilty_Prince.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 25;
 4 | char a[N][N];
 5 | bool vis[N][N];
 6 | int cnt;
 7 | vector<pair<int, int>> d = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
 8 | int n, m;
 9 | bool valid(int ci, int cj)
10 | {
11 |     if (ci >= 0 && ci < n && cj >= 0 && cj < m)
12 |         return true;
13 |     else
14 |         return false;
15 | }
16 | void dfs(int si, int sj)
17 | {
18 |     vis[si][sj] = true;
19 |     cnt++;
20 |     for (int i = 0; i < 4; i++)
21 |     {
22 |         int ci = si + d[i].first;
23 |         int cj = sj + d[i].second;
24 |         if (valid(ci, cj) && !vis[ci][cj] && a[ci][cj] == '.')
25 |         {
26 |             dfs(ci, cj);
27 |         }
28 |     }
29 | }
30 | int main()
31 | {
32 |     int t;
33 |     cin >> t;
34 |     int cs = 1;
35 |     while (t--)
36 |     {
37 |         cin >> m >> n;
38 |         int si, sj;
39 |         for (int i = 0; i < n; i++)
40 |         {
41 |             for (int j = 0; j < m; j++)
42 |             {
43 |                 cin >> a[i][j];
44 |                 if (a[i][j] == '@')
45 |                 {
46 |                     si = i;
47 |                     sj = j;
48 |                 }
49 |             }
50 |         }
51 |         cnt = 0;
52 |         memset(vis, false, sizeof(vis));
53 |         dfs(si, sj);
54 |         cout << "Case " << cs++ << ": " << cnt << endl;
55 |     }
56 |     return 0;
57 | }


--------------------------------------------------------------------------------
/Module 15/sundarban.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | char a[50][50];
 4 | bool vis[50][50];
 5 | int dis[50][50];
 6 | int n;
 7 | vector<pair<int, int>> d;
 8 | bool valid(int ci, int cj)
 9 | {
10 |     if (ci >= 0 && ci < n && cj >= 0 && cj < n)
11 |         return true;
12 |     else
13 |         return false;
14 | }
15 | void bfs(int si, int sj)
16 | {
17 |     queue<pair<int, int>> q;
18 |     q.push({si, sj});
19 |     dis[si][sj] = 0;
20 |     vis[si][sj] = true;
21 |     while (!q.empty())
22 |     {
23 |         pair<int, int> par = q.front();
24 |         q.pop();
25 |         for (int i = 0; i < 4; i++)
26 |         {
27 |             int ci = par.first + d[i].first;
28 |             int cj = par.second + d[i].second;
29 |             if (valid(ci, cj) && !vis[ci][cj] && a[ci][cj] != 'T')
30 |             {
31 |                 q.push({ci, cj});
32 |                 vis[ci][cj] = true;
33 |                 dis[ci][cj] = dis[par.first][par.second] + 1;
34 |             }
35 |         }
36 |     }
37 | }
38 | int main()
39 | {
40 |     d.push_back({0, 1});
41 |     d.push_back({0, -1});
42 |     d.push_back({-1, 0});
43 |     d.push_back({1, 0});
44 |     while (cin >> n)
45 |     {
46 |         int si, sj;
47 |         int di, dj;
48 |         for (int i = 0; i < n; i++)
49 |         {
50 |             for (int j = 0; j < n; j++)
51 |             {
52 |                 cin >> a[i][j];
53 |                 if (a[i][j] == 'S')
54 |                 {
55 |                     si = i;
56 |                     sj = j;
57 |                 }
58 |                 if (a[i][j] == 'E')
59 |                 {
60 |                     di = i;
61 |                     dj = j;
62 |                 }
63 |             }
64 |         }
65 |         memset(vis, false, sizeof(vis));
66 |         memset(dis, -1, sizeof(dis));
67 |         bfs(si, sj);
68 |         cout << dis[di][dj] << endl;
69 |     }
70 |     return 0;
71 | }


--------------------------------------------------------------------------------
/Module 17/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 17/factorial.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | // O(N)
 4 | int fact(int n)
 5 | {
 6 |     // base case
 7 |     if (n == 0)
 8 |     {
 9 |         return 1;
10 |     }
11 |     int chotoFactorial = fact(n - 1);
12 |     return chotoFactorial * n;
13 | }
14 | int main()
15 | {
16 |     int n;
17 |     cin >> n;
18 |     int ans = 1;
19 |     // O(N)
20 |     for (int i = 1; i <= n; i++)
21 |     {
22 |         ans *= i;
23 |     }
24 |     cout << ans << endl;
25 |     return 0;
26 | }


--------------------------------------------------------------------------------
/Module 17/fibonacci.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long
 3 | using namespace std;
 4 | const ll N = 1e6 + 5;
 5 | ll dp[N];
 6 | ll fibo(ll n)
 7 | {
 8 |     if (n == 0 || n == 1)
 9 |     {
10 |         return n;
11 |     }
12 |     if (dp[n] != -1)
13 |     {
14 |         return dp[n];
15 |     }
16 |     ll ans = fibo(n - 1) + fibo(n - 2);
17 |     dp[n] = ans;
18 |     return ans;
19 | }
20 | int main()
21 | {
22 |     ll n;
23 |     cin >> n;
24 |     memset(dp, -1, sizeof(dp));
25 |     cout << fibo(n) << endl;
26 |     return 0;
27 | }


--------------------------------------------------------------------------------
/Module 17/fibonacci_bottom_up.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n;
 6 |     cin >> n;
 7 |     int a[n];
 8 |     a[0] = 0;
 9 |     a[1] = 1;
10 |     // O(N)
11 |     for (int i = 2; i <= n; i++)
12 |     {
13 |         a[i] = a[i - 1] + a[i - 2];
14 |     }
15 |     cout << a[n] << endl;
16 |     return 0;
17 | }


--------------------------------------------------------------------------------
/Module 18/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 18/0-1_knapsack.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int knapsack(int n, int weight[], int value[], int W)
 4 | {
 5 |     if (n == 0 || W == 0)
 6 |         return 0;
 7 |     if (weight[n - 1] <= W)
 8 |     {
 9 |         // duita option
10 |         // niye dekhbo, na niye dekhbo
11 |         int op1 = knapsack(n - 1, weight, value, W - weight[n - 1]) + value[n - 1];
12 |         int op2 = knapsack(n - 1, weight, value, W);
13 |         return max(op1, op2);
14 |     }
15 |     else
16 |     {
17 |         // ekta option
18 |         // na niyei dekhte hobe
19 |         int op2 = knapsack(n - 1, weight, value, W);
20 |         return op2;
21 |     }
22 | }
23 | int main()
24 | {
25 |     int n;
26 |     cin >> n;
27 |     int weight[n], value[n];
28 |     for (int i = 0; i < n; i++)
29 |     {
30 |         cin >> weight[i];
31 |     }
32 |     for (int i = 0; i < n; i++)
33 |     {
34 |         cin >> value[i];
35 |     }
36 |     int W;
37 |     cin >> W;
38 |     cout << knapsack(n, weight, value, W) << endl;
39 |     return 0;
40 | }


--------------------------------------------------------------------------------
/Module 18/0-1_knapsack_bottom_up.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n;
 6 |     cin >> n;
 7 |     int weight[n], value[n];
 8 |     for (int i = 0; i < n; i++)
 9 |     {
10 |         cin >> weight[i];
11 |     }
12 |     for (int i = 0; i < n; i++)
13 |     {
14 |         cin >> value[i];
15 |     }
16 |     int W;
17 |     cin >> W;
18 |     int dp[n + 1][W + 1];
19 |     for (int i = 0; i <= n; i++)
20 |     {
21 |         for (int j = 0; j <= W; j++)
22 |         {
23 |             if (i == 0 || j == 0)
24 |                 dp[i][j] = 0;
25 |         }
26 |     }
27 |     for (int i = 1; i <= n; i++)
28 |     {
29 |         for (int j = 1; j <= W; j++)
30 |         {
31 |             if (weight[i - 1] <= j)
32 |             {
33 |                 int op1 = dp[i - 1][j - weight[i - 1]] + value[i - 1];
34 |                 int op2 = dp[i - 1][j];
35 |                 dp[i][j] = max(op1, op2);
36 |             }
37 |             else
38 |             {
39 |                 int op2 = dp[i - 1][j];
40 |                 dp[i][j] = op2;
41 |             }
42 |         }
43 |     }
44 |     // for (int i = 0; i <= n; i++)
45 |     // {
46 |     //     for (int j = 0; j <= W; j++)
47 |     //     {
48 |     //         cout << dp[i][j] << " ";
49 |     //     }
50 |     //     cout << endl;
51 |     // }
52 |     cout << dp[n][W] << endl;
53 |     return 0;
54 | }


--------------------------------------------------------------------------------
/Module 18/0-1_knapsack_top_down.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int maxN = 1000;
 4 | const int maxW = 1000;
 5 | int dp[maxN][maxW];
 6 | int knapsack(int n, int weight[], int value[], int W)
 7 | {
 8 |     if (n == 0 || W == 0)
 9 |         return 0;
10 |     if (dp[n][W] != -1)
11 |     {
12 |         return dp[n][W];
13 |     }
14 |     if (weight[n - 1] <= W)
15 |     {
16 |         // duita option
17 |         // niye dekhbo, na niye dekhbo
18 |         int op1 = knapsack(n - 1, weight, value, W - weight[n - 1]) + value[n - 1];
19 |         int op2 = knapsack(n - 1, weight, value, W);
20 |         return dp[n][W] = max(op1, op2);
21 |     }
22 |     else
23 |     {
24 |         // ekta option
25 |         // na niyei dekhte hobe
26 |         int op2 = knapsack(n - 1, weight, value, W);
27 |         return dp[n][W] = op2;
28 |     }
29 | }
30 | int main()
31 | {
32 |     int n;
33 |     cin >> n;
34 |     int weight[n], value[n];
35 |     for (int i = 0; i < n; i++)
36 |     {
37 |         cin >> weight[i];
38 |     }
39 |     for (int i = 0; i < n; i++)
40 |     {
41 |         cin >> value[i];
42 |     }
43 |     int W;
44 |     cin >> W;
45 |     for (int i = 0; i <= n; i++)
46 |     {
47 |         for (int j = 0; j <= W; j++)
48 |         {
49 |             dp[i][j] = -1;
50 |         }
51 |     }
52 |     cout << knapsack(n, weight, value, W) << endl;
53 |     return 0;
54 | }


--------------------------------------------------------------------------------
/Module 19/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 19/count_of_subset_sum.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int dp[1005][1005];
 4 | int subset_sum(int n, int a[], int s)
 5 | {
 6 |     if (n == 0)
 7 |     {
 8 |         if (s == 0)
 9 |             return 1;
10 |         else
11 |             return 0;
12 |     }
13 |     if (dp[n][s] != -1)
14 |         return dp[n][s];
15 |     if (a[n - 1] <= s)
16 |     {
17 |         int op1 = subset_sum(n - 1, a, s - a[n - 1]);
18 |         int op2 = subset_sum(n - 1, a, s);
19 |         return dp[n][s] = op1 + op2;
20 |     }
21 |     else
22 |     {
23 |         return dp[n][s] = subset_sum(n - 1, a, s);
24 |     }
25 | }
26 | int main()
27 | {
28 |     int n;
29 |     cin >> n;
30 |     int a[n];
31 |     for (int i = 0; i < n; i++)
32 |     {
33 |         cin >> a[i];
34 |     }
35 |     int s;
36 |     cin >> s;
37 |     dp[0][0] = true;
38 |     for (int i = 1; i <= s; i++)
39 |     {
40 |         dp[0][i] = 0;
41 |     }
42 |     for (int i = 1; i <= n; i++)
43 |     {
44 |         for (int j = 0; j <= s; j++)
45 |         {
46 |             if (a[i - 1] <= j)
47 |             {
48 |                 dp[i][j] = dp[i - 1][j - a[i - 1]] + dp[i - 1][j];
49 |             }
50 |             else
51 |             {
52 |                 dp[i][j] = dp[i - 1][j];
53 |             }
54 |         }
55 |     }
56 |     for (int i = 0; i <= n; i++)
57 |     {
58 |         for (int j = 0; j <= s; j++)
59 |         {
60 |             cout << dp[i][j] << " ";
61 |         }
62 |         cout << endl;
63 |     }
64 |     return 0;
65 | }


--------------------------------------------------------------------------------
/Module 19/equal_sum.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n;
 6 |     cin >> n;
 7 |     int s = 0;
 8 |     int a[n];
 9 |     for (int i = 0; i < n; i++)
10 |     {
11 |         cin >> a[i];
12 |         s += a[i];
13 |     }
14 |     if (s % 2 == 0)
15 |     {
16 |         int sum = s / 2;
17 |         bool dp[n + 1][sum + 1];
18 |         dp[0][0] = true;
19 |         for (int i = 1; i <= sum; i++)
20 |             dp[0][i] = false;
21 |         for (int i = 1; i <= n; i++)
22 |         {
23 |             for (int j = 0; j <= sum; j++)
24 |             {
25 |                 if (a[i - 1] <= j)
26 |                 {
27 |                     dp[i][j] = dp[i - 1][j - a[i - 1]] || dp[i - 1][j];
28 |                 }
29 |                 else
30 |                 {
31 |                     dp[i][j] = dp[i - 1][j];
32 |                 }
33 |             }
34 |         }
35 |         if (dp[n][sum])
36 |             cout << "YES" << endl;
37 |         else
38 |             cout << "NO" << endl;
39 |     }
40 |     else
41 |     {
42 |         cout << "NO" << endl;
43 |     }
44 |     return 0;
45 | }


--------------------------------------------------------------------------------
/Module 19/minimum_subset_sum_difference.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n;
 6 |     cin >> n;
 7 |     int a[n], s = 0;
 8 |     for (int i = 0; i < n; i++)
 9 |     {
10 |         cin >> a[i];
11 |         s += a[i];
12 |     }
13 |     bool dp[n + 1][s + 1];
14 |     dp[0][0] = true;
15 |     for (int i = 1; i <= s; i++)
16 |         dp[0][i] = false;
17 |     for (int i = 1; i <= n; i++)
18 |     {
19 |         for (int j = 0; j <= s; j++)
20 |         {
21 |             if (a[i - 1] <= j)
22 |             {
23 |                 dp[i][j] = dp[i - 1][j - a[i - 1]] || dp[i - 1][j];
24 |             }
25 |             else
26 |             {
27 |                 dp[i][j] = dp[i - 1][j];
28 |             }
29 |         }
30 |     }
31 |     vector<int> v;
32 |     for (int i = 0; i <= n; i++)
33 |     {
34 |         for (int j = 0; j <= s; j++)
35 |         {
36 |             if (dp[i][j] == 1)
37 |                 v.push_back(j);
38 |         }
39 |     }
40 |     int ans = INT_MAX;
41 |     for (int val : v)
42 |     {
43 |         int s1 = val;
44 |         int s2 = s - s1;
45 |         ans = min(ans, abs(s1 - s2));
46 |     }
47 |     cout << ans << endl;
48 |     return 0;
49 | }


--------------------------------------------------------------------------------
/Module 19/subset_sum_bottom_up.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n;
 6 |     cin >> n;
 7 |     int a[n];
 8 |     for (int i = 0; i < n; i++)
 9 |     {
10 |         cin >> a[i];
11 |     }
12 |     int s;
13 |     cin >> s;
14 |     bool dp[n + 1][s + 1];
15 |     dp[0][0] = true;
16 |     for (int i = 1; i <= s; i++)
17 |     {
18 |         dp[0][i] = false;
19 |     }
20 |     for (int i = 1; i <= n; i++)
21 |     {
22 |         for (int j = 0; j <= s; j++)
23 |         {
24 |             if (a[i - 1] <= j)
25 |             {
26 |                 dp[i][j] = dp[i - 1][j - a[i - 1]] || dp[i - 1][j];
27 |             }
28 |             else
29 |             {
30 |                 dp[i][j] = dp[i - 1][j];
31 |             }
32 |         }
33 |     }
34 |     for (int i = 0; i <= n; i++)
35 |     {
36 |         for (int j = 0; j <= s; j++)
37 |         {
38 |             if (dp[i][j])
39 |                 cout << "T ";
40 |             else
41 |                 cout << "F ";
42 |         }
43 |         cout << endl;
44 |     }
45 |     // if (dp[n][s])
46 |     //     cout << "YES" << endl;
47 |     // else
48 |     //     cout << "NO" << endl;
49 |     return 0;
50 | }


--------------------------------------------------------------------------------
/Module 19/subset_sum_top_down.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int dp[1005][1005];
 4 | bool subset_sum(int n, int a[], int s)
 5 | {
 6 |     if (n == 0)
 7 |     {
 8 |         if (s == 0)
 9 |             return true;
10 |         else
11 |             return false;
12 |     }
13 |     if (dp[n][s] != -1)
14 |         return dp[n][s];
15 |     if (a[n - 1] <= s)
16 |     {
17 |         bool op1 = subset_sum(n - 1, a, s - a[n - 1]);
18 |         bool op2 = subset_sum(n - 1, a, s);
19 |         return dp[n][s] = op1 || op2;
20 |     }
21 |     else
22 |     {
23 |         return dp[n][s] = subset_sum(n - 1, a, s);
24 |     }
25 | }
26 | int main()
27 | {
28 |     int n;
29 |     cin >> n;
30 |     int a[n];
31 |     for (int i = 0; i < n; i++)
32 |     {
33 |         cin >> a[i];
34 |     }
35 |     int s;
36 |     cin >> s;
37 |     for (int i = 0; i <= n; i++)
38 |     {
39 |         for (int j = 0; j <= s; j++)
40 |         {
41 |             dp[i][j] = -1;
42 |         }
43 |     }
44 |     if (subset_sum(n, a, s))
45 |     {
46 |         cout << "YES" << endl;
47 |     }
48 |     else
49 |     {
50 |         cout << "NO" << endl;
51 |     }
52 |     return 0;
53 | }


--------------------------------------------------------------------------------
/Module 2/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 2/bfs_traversal.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | vector<int> v[1005];
 4 | bool vis[1005];
 5 | void bfs(int src)
 6 | {
 7 |     queue<int> q;
 8 |     q.push(src);
 9 |     vis[src] = true;
10 |     while (!q.empty())
11 |     {
12 |         int par = q.front();
13 |         q.pop();
14 |         cout << par << endl;
15 |         for (int child : v[par])
16 |         {
17 |             if (vis[child] == false)
18 |             {
19 |                 q.push(child);
20 |                 vis[child] = true;
21 |             }
22 |         }
23 |     }
24 | }
25 | int main()
26 | {
27 |     int n, e;
28 |     cin >> n >> e;
29 |     while (e--)
30 |     {
31 |         int a, b;
32 |         cin >> a >> b;
33 |         v[a].push_back(b);
34 |         v[b].push_back(a);
35 |     }
36 |     int src;
37 |     cin >> src;
38 |     memset(vis, false, sizeof(vis));
39 |     bfs(src);
40 |     return 0;
41 | }


--------------------------------------------------------------------------------
/Module 2/bfs_with_level.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | vector<int> v[1005];
 4 | bool vis[1005];
 5 | int level[1005];
 6 | void bfs(int src)
 7 | {
 8 |     queue<int> q;
 9 |     q.push(src);
10 |     vis[src] = true;
11 |     level[src] = 0;
12 |     while (!q.empty())
13 |     {
14 |         int par = q.front();
15 |         q.pop();
16 |         for (int child : v[par])
17 |         {
18 |             if (vis[child] == false)
19 |             {
20 |                 q.push(child);
21 |                 vis[child] = true;
22 |                 level[child] = level[par] + 1;
23 |             }
24 |         }
25 |     }
26 | }
27 | int main()
28 | {
29 |     int n, e;
30 |     cin >> n >> e;
31 |     while (e--)
32 |     {
33 |         int a, b;
34 |         cin >> a >> b;
35 |         v[a].push_back(b);
36 |         v[b].push_back(a);
37 |     }
38 |     int src;
39 |     cin >> src;
40 |     memset(vis, false, sizeof(vis));
41 |     memset(level, -1, sizeof(level));
42 |     bfs(src);
43 |     for (int i = 0; i < n; i++)
44 |     {
45 |         cout << i << " " << level[i] << endl;
46 |     }
47 |     return 0;
48 | }


--------------------------------------------------------------------------------
/Module 2/bfs_with_level_pair.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | vector<int> v[1005];
 4 | bool vis[1005];
 5 | void bfs(int src, int des)
 6 | {
 7 |     queue<pair<int, int>> q;
 8 |     q.push({src, 0});
 9 |     vis[src] = true;
10 |     bool paisi = false;
11 |     while (!q.empty())
12 |     {
13 |         pair<int, int> p = q.front();
14 |         q.pop();
15 |         int par = p.first;
16 |         int level = p.second;
17 |         // cout << par << endl;
18 |         if (par == des)
19 |         {
20 |             cout << level << endl;
21 |             paisi = true;
22 |         }
23 |         for (int child : v[par])
24 |         {
25 |             if (vis[child] == false)
26 |             {
27 |                 q.push({child, level + 1});
28 |                 vis[child] = true;
29 |             }
30 |         }
31 |     }
32 |     if (paisi == false)
33 |     {
34 |         cout << -1 << endl;
35 |     }
36 | }
37 | int main()
38 | {
39 |     int n, e;
40 |     cin >> n >> e;
41 |     while (e--)
42 |     {
43 |         int a, b;
44 |         cin >> a >> b;
45 |         v[a].push_back(b);
46 |         v[b].push_back(a);
47 |     }
48 |     int src;
49 |     cin >> src;
50 |     memset(vis, false, sizeof(vis));
51 |     bfs(src, 9);
52 |     return 0;
53 | }


--------------------------------------------------------------------------------
/Module 2/path_printing.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | vector<int> v[1005];
 4 | bool vis[1005];
 5 | int level[1005];
 6 | int parent[1005];
 7 | void bfs(int src)
 8 | {
 9 |     queue<int> q;
10 |     q.push(src);
11 |     vis[src] = true;
12 |     level[src] = 0;
13 |     while (!q.empty())
14 |     {
15 |         int par = q.front();
16 |         q.pop();
17 |         for (int child : v[par])
18 |         {
19 |             if (vis[child] == false)
20 |             {
21 |                 q.push(child);
22 |                 vis[child] = true;
23 |                 level[child] = level[par] + 1;
24 |                 parent[child] = par;
25 |             }
26 |         }
27 |     }
28 | }
29 | int main()
30 | {
31 |     int n, e;
32 |     cin >> n >> e;
33 |     while (e--)
34 |     {
35 |         int a, b;
36 |         cin >> a >> b;
37 |         v[a].push_back(b);
38 |         v[b].push_back(a);
39 |     }
40 |     int src, des;
41 |     cin >> src >> des;
42 |     memset(vis, false, sizeof(vis));
43 |     memset(level, -1, sizeof(level));
44 |     memset(parent, -1, sizeof(parent));
45 |     bfs(src);
46 |     int x = des;
47 |     vector<int> path;
48 |     while (x != -1)
49 |     {
50 |         path.push_back(x);
51 |         x = parent[x];
52 |     }
53 |     reverse(path.begin(), path.end());
54 |     for (int val : path)
55 |     {
56 |         cout << val << " ";
57 |     }
58 |     return 0;
59 | }


--------------------------------------------------------------------------------
/Module 21/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 21/coin_change_1.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n;
 6 |     cin >> n;
 7 |     int w[n];
 8 |     for (int i = 0; i < n; i++)
 9 |     {
10 |         cin >> w[i];
11 |     }
12 |     int s;
13 |     cin >> s;
14 |     int dp[n + 1][s + 1];
15 |     dp[0][0] = 1;
16 |     for (int i = 1; i <= s; i++)
17 |         dp[0][i] = 0;
18 |     for (int i = 1; i <= n; i++)
19 |     {
20 |         for (int j = 0; j <= s; j++)
21 |         {
22 |             if (w[i - 1] <= j)
23 |             {
24 |                 dp[i][j] = dp[i][j - w[i - 1]] + dp[i - 1][j];
25 |             }
26 |             else
27 |             {
28 |                 dp[i][j] = dp[i - 1][j];
29 |             }
30 |         }
31 |     }
32 |     cout << dp[n][s] << endl;
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/Module 21/coin_change_2.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n;
 6 |     cin >> n;
 7 |     int w[n];
 8 |     for (int i = 0; i < n; i++)
 9 |     {
10 |         cin >> w[i];
11 |     }
12 |     int s;
13 |     cin >> s;
14 |     int dp[n + 1][s + 1];
15 |     dp[0][0] = 0;
16 |     for (int i = 1; i <= s; i++)
17 |         dp[0][i] = INT_MAX - 1;
18 |     for (int i = 1; i <= n; i++)
19 |     {
20 |         for (int j = 0; j <= s; j++)
21 |         {
22 |             if (w[i - 1] <= j)
23 |             {
24 |                 dp[i][j] = min(1 + dp[i][j - w[i - 1]], dp[i - 1][j]);
25 |             }
26 |             else
27 |             {
28 |                 dp[i][j] = dp[i - 1][j];
29 |             }
30 |         }
31 |     }
32 |     // for (int i = 0; i <= n; i++)
33 |     // {
34 |     //     for (int j = 0; j <= s; j++)
35 |     //     {
36 |     //         cout << dp[i][j] << " ";
37 |     //     }
38 |     //     cout << endl;
39 |     // }
40 |     if (dp[n][s] == INT_MAX - 1)
41 |         cout << "Not Possible" << endl;
42 |     else
43 |         cout << dp[n][s] << endl;
44 |     return 0;
45 | }


--------------------------------------------------------------------------------
/Module 21/rod_cutting.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int dp[1005][1005];
 4 | int unbounded_knapsack(int n, int s, int val[], int w[])
 5 | {
 6 |     if (n == 0 || s == 0)
 7 |         return 0;
 8 |     if (dp[n][s] != -1)
 9 |         return dp[n][s];
10 |     if (w[n - 1] <= s)
11 |     {
12 |         int ch1 = val[n - 1] + unbounded_knapsack(n, s - w[n - 1], val, w);
13 |         int ch2 = unbounded_knapsack(n - 1, s, val, w);
14 |         return dp[n][s] = max(ch1, ch2);
15 |     }
16 |     else
17 |     {
18 |         return dp[n][s] = unbounded_knapsack(n - 1, s, val, w);
19 |     }
20 | }
21 | int main()
22 | {
23 |     int n;
24 |     cin >> n;
25 |     int val[n], w[n];
26 |     for (int i = 0; i <= n; i++)
27 |     {
28 |         for (int j = 0; j <= n; j++)
29 |         {
30 |             dp[i][j] = -1;
31 |         }
32 |     }
33 |     for (int i = 0; i < n; i++)
34 |     {
35 |         cin >> val[i];
36 |         w[i] = i + 1;
37 |     }
38 |     cout << unbounded_knapsack(n, n, val, w) << endl;
39 |     return 0;
40 | }


--------------------------------------------------------------------------------
/Module 21/unbounded_knapsack.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int dp[1005][1005];
 4 | int unbounded_knapsack(int n, int s, int val[], int w[])
 5 | {
 6 |     if (n == 0 || s == 0)
 7 |         return 0;
 8 |     if (dp[n][s] != -1)
 9 |         return dp[n][s];
10 |     if (w[n - 1] <= s)
11 |     {
12 |         int ch1 = val[n - 1] + unbounded_knapsack(n, s - w[n - 1], val, w);
13 |         int ch2 = unbounded_knapsack(n - 1, s, val, w);
14 |         return dp[n][s] = max(ch1, ch2);
15 |     }
16 |     else
17 |     {
18 |         return dp[n][s] = unbounded_knapsack(n - 1, s, val, w);
19 |     }
20 | }
21 | int main()
22 | {
23 |     int n, s;
24 |     cin >> n >> s;
25 |     int val[n], w[n];
26 |     for (int i = 0; i <= n; i++)
27 |     {
28 |         for (int j = 0; j <= s; j++)
29 |         {
30 |             dp[i][j] = -1;
31 |         }
32 |     }
33 |     for (int i = 0; i < n; i++)
34 |     {
35 |         cin >> val[i];
36 |     }
37 |     for (int i = 0; i < n; i++)
38 |     {
39 |         cin >> w[i];
40 |     }
41 |     cout << unbounded_knapsack(n, s, val, w);
42 |     return 0;
43 | }


--------------------------------------------------------------------------------
/Module 21/unbounded_knapsack_bottom_up.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n, s;
 6 |     cin >> n >> s;
 7 |     int val[n], w[n];
 8 |     int dp[n + 1][s + 1];
 9 |     for (int i = 0; i <= n; i++)
10 |     {
11 |         for (int j = 0; j <= s; j++)
12 |         {
13 |             if (i == 0 || j == 0)
14 |                 dp[i][j] = 0;
15 |         }
16 |     }
17 |     for (int i = 0; i < n; i++)
18 |     {
19 |         cin >> val[i];
20 |     }
21 |     for (int i = 0; i < n; i++)
22 |     {
23 |         cin >> w[i];
24 |     }
25 |     for (int i = 1; i <= n; i++)
26 |     {
27 |         for (int j = 1; j <= s; j++)
28 |         {
29 |             if (w[i - 1] <= j)
30 |             {
31 |                 dp[i][j] = max(val[i - 1] + dp[i][j - w[i - 1]], dp[i - 1][j]);
32 |             }
33 |             else
34 |             {
35 |                 dp[i][j] = dp[i - 1][j];
36 |             }
37 |         }
38 |     }
39 |     cout << dp[n][s] << endl;
40 |     return 0;
41 | }


--------------------------------------------------------------------------------
/Module 22/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 22/lcs_bottom_up.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     string a, b;
 6 |     cin >> a >> b;
 7 |     int n = a.size(), m = b.size();
 8 |     int dp[n + 1][m + 1];
 9 |     for (int i = 0; i <= n; i++)
10 |     {
11 |         for (int j = 0; j <= m; j++)
12 |         {
13 |             if (i == 0 || j == 0)
14 |                 dp[i][j] = 0;
15 |         }
16 |     }
17 |     for (int i = 1; i <= n; i++)
18 |     {
19 |         for (int j = 1; j <= m; j++)
20 |         {
21 |             if (a[i - 1] == b[j - 1])
22 |             {
23 |                 dp[i][j] = dp[i - 1][j - 1] + 1;
24 |             }
25 |             else
26 |             {
27 |                 dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
28 |             }
29 |         }
30 |     }
31 |     cout << dp[n][m] << endl;
32 |     return 0;
33 | }


--------------------------------------------------------------------------------
/Module 22/lcs_print.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     string a, b;
 6 |     cin >> a >> b;
 7 |     int n = a.size(), m = b.size();
 8 |     int dp[n + 1][m + 1];
 9 |     for (int i = 0; i <= n; i++)
10 |     {
11 |         for (int j = 0; j <= m; j++)
12 |         {
13 |             if (i == 0 || j == 0)
14 |                 dp[i][j] = 0;
15 |         }
16 |     }
17 |     for (int i = 1; i <= n; i++)
18 |     {
19 |         for (int j = 1; j <= m; j++)
20 |         {
21 |             if (a[i - 1] == b[j - 1])
22 |             {
23 |                 dp[i][j] = dp[i - 1][j - 1] + 1;
24 |             }
25 |             else
26 |             {
27 |                 dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
28 |             }
29 |         }
30 |     }
31 |     int i = n, j = m;
32 |     string ans;
33 |     while (i != 0 && j != 0)
34 |     {
35 |         if (a[i - 1] == b[j - 1])
36 |         {
37 |             ans += a[i - 1];
38 |             i--;
39 |             j--;
40 |         }
41 |         else
42 |         {
43 |             if (dp[i][j - 1] > dp[i - 1][j])
44 |             {
45 |                 j--;
46 |             }
47 |             else
48 |             {
49 |                 i--;
50 |             }
51 |         }
52 |     }
53 |     reverse(ans.begin(), ans.end());
54 |     cout << ans << endl;
55 |     return 0;
56 | }


--------------------------------------------------------------------------------
/Module 22/lcs_top_down.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int dp[1005][1005];
 4 | int lcs(string a, int n, string b, int m)
 5 | {
 6 |     if (n == 0 || m == 0)
 7 |         return 0;
 8 |     if (dp[n][m] != -1)
 9 |         return dp[n][m];
10 |     if (a[n - 1] == b[m - 1])
11 |     {
12 |         int ans = lcs(a, n - 1, b, m - 1);
13 |         return dp[n][m] = ans + 1;
14 |     }
15 |     else
16 |     {
17 |         int ans1 = lcs(a, n - 1, b, m);
18 |         int ans2 = lcs(a, n, b, m - 1);
19 |         return dp[n][m] = max(ans1, ans2);
20 |     }
21 | }
22 | int main()
23 | {
24 |     string a, b;
25 |     cin >> a >> b;
26 |     // memset(dp, -1, sizeof(dp));
27 |     for (int i = 0; i <= a.size(); i++)
28 |     {
29 |         for (int j = 0; j <= b.size(); j++)
30 |         {
31 |             dp[i][j] = -1;
32 |         }
33 |     }
34 |     cout << lcs(a, a.size(), b, b.size());
35 |     return 0;
36 | }


--------------------------------------------------------------------------------
/Module 22/longest_common_substring.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     string a, b;
 6 |     cin >> a >> b;
 7 |     int n = a.size(), m = b.size();
 8 |     int dp[n + 1][m + 1];
 9 |     for (int i = 0; i <= n; i++)
10 |     {
11 |         for (int j = 0; j <= m; j++)
12 |         {
13 |             if (i == 0 || j == 0)
14 |                 dp[i][j] = 0;
15 |         }
16 |     }
17 |     for (int i = 1; i <= n; i++)
18 |     {
19 |         for (int j = 1; j <= m; j++)
20 |         {
21 |             if (a[i - 1] == b[j - 1])
22 |             {
23 |                 dp[i][j] = dp[i - 1][j - 1] + 1;
24 |             }
25 |             else
26 |             {
27 |                 dp[i][j] = 0;
28 |             }
29 |         }
30 |     }
31 |     int mx = 0;
32 |     int ci, cj;
33 |     for (int i = 0; i <= n; i++)
34 |     {
35 |         for (int j = 0; j <= m; j++)
36 |         {
37 |             if (dp[i][j] > mx)
38 |             {
39 |                 mx = dp[i][j];
40 |                 ci = i;
41 |                 cj = j;
42 |             }
43 |         }
44 |     }
45 |     string ans;
46 |     while (ci != 0 && cj != 0)
47 |     {
48 |         if (a[ci - 1] == b[cj - 1])
49 |         {
50 |             ans += a[ci - 1];
51 |             ci--;
52 |             cj--;
53 |         }
54 |         else
55 |         {
56 |             break;
57 |         }
58 |     }
59 |     reverse(ans.begin(), ans.end());
60 |     cout << ans << endl;
61 |     return 0;
62 | }


--------------------------------------------------------------------------------
/Module 23/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 23/divide.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | void divide(int a[],int l, int r)
 4 | {
 5 |     for(int i=l;i<=r;i++)
 6 |     {
 7 |         cout<<a[i]<<" ";
 8 |     }
 9 |     cout<<endl;
10 |     if(l<r)
11 |     {
12 |         int mid=(l+r)/2;
13 |         divide(a,l,mid);
14 |         divide(a,mid+1,r);
15 |     }
16 | }
17 | int main()
18 | {
19 |     int n; 
20 |     cin>>n;
21 |     int a[n];
22 |     for(int i=0;i<n;i++)
23 |     {
24 |         cin>>a[i];
25 |     }
26 |     divide(a,0,n-1);
27 |     return 0;
28 | }


--------------------------------------------------------------------------------
/Module 23/merge.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | void merge(int a[],int l,int m,int r)
 4 | {
 5 |     int leftSize = m-l+1;
 6 |     int rightSize = r-m;
 7 |     int L[leftSize],R[rightSize];
 8 |     int k=0;
 9 |     for(int i=l;i<=m;i++)
10 |     {
11 |         L[k]=a[i];
12 |         k++;
13 |     }
14 |     k=0;
15 |     for(int i=m+1;i<=r;i++)
16 |     {
17 |         R[k]=a[i];
18 |         k++;
19 |     }
20 |     int i=0,j=0;
21 |     int cur=l;
22 |     while(i<leftSize && j<rightSize)
23 |     {
24 |         if(L[i] <= R[j])
25 |         {
26 |             a[cur]=L[i];
27 |             i++;
28 |         }
29 |         else 
30 |         {
31 |             a[cur]=R[j];
32 |             j++;
33 |         }
34 |         cur++;
35 |     }
36 | 
37 |     while(i<leftSize)
38 |     {
39 |         a[cur]=L[i];
40 |         i++;
41 |         cur++;
42 |     }
43 | 
44 |     while(j<rightSize)
45 |     {
46 |         a[cur]=R[j];
47 |         j++;
48 |         cur++;
49 |     }
50 | }
51 | int main()
52 | {
53 |     int n;
54 |     cin>>n;
55 |     int a[n];
56 |     for(int i=0;i<n;i++)
57 |     {
58 |         cin>>a[i];
59 |     }
60 |     merge(a,0,3,n-1);
61 |     for(int i=0;i<n;i++)
62 |     {
63 |         cout<<a[i]<<" ";
64 |     }
65 |     return 0;
66 | }


--------------------------------------------------------------------------------
/Module 23/merge_sort.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | void merge(int a[],int l,int m,int r)
 4 | {
 5 |     int leftSize = m-l+1;
 6 |     int rightSize = r-m;
 7 |     int L[leftSize],R[rightSize];
 8 |     int k=0;
 9 |     for(int i=l;i<=m;i++)
10 |     {
11 |         L[k]=a[i];
12 |         k++;
13 |     }
14 |     k=0;
15 |     for(int i=m+1;i<=r;i++)
16 |     {
17 |         R[k]=a[i];
18 |         k++;
19 |     }
20 |     int i=0,j=0;
21 |     int cur=l;
22 |     while(i<leftSize && j<rightSize)
23 |     {
24 |         if(L[i] <= R[j])
25 |         {
26 |             a[cur]=L[i];
27 |             i++;
28 |         }
29 |         else 
30 |         {
31 |             a[cur]=R[j];
32 |             j++;
33 |         }
34 |         cur++;
35 |     }
36 | 
37 |     while(i<leftSize)
38 |     {
39 |         a[cur]=L[i];
40 |         i++;
41 |         cur++;
42 |     }
43 | 
44 |     while(j<rightSize)
45 |     {
46 |         a[cur]=R[j];
47 |         j++;
48 |         cur++;
49 |     }
50 | }
51 | void merge_sort(int a[],int l,int r)
52 | {
53 |     if(l<r)
54 |     {
55 |         int mid=(l+r)/2;
56 |         merge_sort(a,l,mid);
57 |         merge_sort(a,mid+1,r);
58 |         merge(a,l,mid,r);
59 |         // cout<<"This"<<endl;
60 |         // for(int i=l;i<=mid;i++)
61 |         // {
62 |         //     cout<<a[i]<<" ";
63 |         // }
64 |         // cout<<endl;
65 |         // for(int i=mid+1;i<=r;i++)
66 |         // {
67 |         //     cout<<a[i]<<" ";
68 |         // }
69 |         // cout<<endl;
70 | 
71 |     }
72 | }
73 | int main()
74 | {
75 |     int n; 
76 |     cin>>n;
77 |     int a[n];
78 |     for(int i=0;i<n;i++)
79 |     {
80 |         cin>>a[i];
81 |     }
82 |     merge_sort(a,0,n-1);
83 |     // for(int i=0;i<n;i++)
84 |     // {
85 |     //     cout<<a[i]<<" ";
86 |     // }
87 |     return 0;
88 | }
89 | 


--------------------------------------------------------------------------------
/Module 3/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 3/bfs_on_2d.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | bool vis[20][20];
 4 | int dis[20][20];
 5 | vector<pair<int, int>> d = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
 6 | int n, m;
 7 | char a[20][20];
 8 | bool valid(int i, int j)
 9 | {
10 |     if (i < 0 || i >= n || j < 0 || j >= m)
11 |         return false;
12 |     return true;
13 | }
14 | 
15 | void bfs(int si, int sj)
16 | {
17 |     queue<pair<int, int>> q;
18 |     q.push({si, sj});
19 |     vis[si][sj] = true;
20 |     dis[si][sj] = 0;
21 |     while (!q.empty())
22 |     {
23 |         pair<int, int> par = q.front();
24 |         int a = par.first, b = par.second;
25 |         q.pop();
26 |         for (int i = 0; i < 4; i++)
27 |         {
28 |             int ci = a + d[i].first;
29 |             int cj = b + d[i].second;
30 |             if (valid(ci, cj) == true && vis[ci][cj] == false)
31 |             {
32 |                 q.push({ci, cj});
33 |                 vis[ci][cj] = true;
34 |                 dis[ci][cj] = dis[a][b] + 1;
35 |             }
36 |         }
37 |     }
38 | }
39 | int main()
40 | {
41 |     cin >> n >> m;
42 |     for (int i = 0; i < n; i++)
43 |     {
44 |         for (int j = 0; j < m; j++)
45 |         {
46 |             cin >> a[i][j];
47 |         }
48 |     }
49 |     int si, sj;
50 |     cin >> si >> sj;
51 |     memset(vis, false, sizeof(vis));
52 |     memset(dis, -1, sizeof(dis));
53 |     bfs(si, sj);
54 |     cout << dis[2][3];
55 |     return 0;
56 | }


--------------------------------------------------------------------------------
/Module 3/component.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 1e5 + 5;
 4 | vector<int> v[N];
 5 | bool vis[N];
 6 | 
 7 | void dfs(int src)
 8 | {
 9 |     cout << src << endl;
10 |     vis[src] = true;
11 |     for (int child : v[src])
12 |     {
13 |         if (vis[child] == false)
14 |             dfs(child);
15 |     }
16 | }
17 | int main()
18 | {
19 |     int n, e;
20 |     cin >> n >> e;
21 |     while (e--)
22 |     {
23 |         int a, b;
24 |         cin >> a >> b;
25 |         v[a].push_back(b);
26 |         v[b].push_back(a);
27 |     }
28 |     memset(vis, false, sizeof(vis));
29 |     int c = 0;
30 |     for (int i = 0; i < n; i++)
31 |     {
32 |         if (vis[i] == false)
33 |         {
34 |             dfs(i);
35 |             c++;
36 |         }
37 |     }
38 |     cout << "component - " << c << endl;
39 |     return 0;
40 | }


--------------------------------------------------------------------------------
/Module 3/dfs.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 1e5 + 5;
 4 | vector<int> v[N];
 5 | bool vis[N];
 6 | 
 7 | void dfs(int src)
 8 | {
 9 |     cout << src << endl;
10 |     vis[src] = true;
11 |     for (int child : v[src])
12 |     {
13 |         if (vis[child] == false)
14 |             dfs(child);
15 |     }
16 | }
17 | int main()
18 | {
19 |     int n, e;
20 |     cin >> n >> e;
21 |     while (e--)
22 |     {
23 |         int a, b;
24 |         cin >> a >> b;
25 |         v[a].push_back(b);
26 |         v[b].push_back(a);
27 |     }
28 |     memset(vis, false, sizeof(vis));
29 |     dfs(0);
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/Module 3/dfs_on_2d.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | char a[20][20];
 4 | bool vis[20][20];
 5 | vector<pair<int, int>> d = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
 6 | int n, m;
 7 | bool valid(int i, int j)
 8 | {
 9 |     if (i < 0 || i >= n || j < 0 || j >= m)
10 |         return false;
11 |     return true;
12 | }
13 | void dfs(int si, int sj)
14 | {
15 |     cout << si << " " << sj << endl;
16 |     vis[si][sj] = true;
17 |     for (int i = 0; i < 4; i++)
18 |     {
19 |         int ci = si + d[i].first;
20 |         int cj = sj + d[i].second;
21 |         if (valid(ci, cj) == true && vis[ci][cj] == false)
22 |         {
23 |             dfs(ci, cj);
24 |         }
25 |     }
26 | }
27 | int main()
28 | {
29 |     cin >> n >> m;
30 |     for (int i = 0; i < n; i++)
31 |     {
32 |         for (int j = 0; j < m; j++)
33 |         {
34 |             cin >> a[i][j];
35 |         }
36 |     }
37 |     int si, sj;
38 |     cin >> si >> sj;
39 |     memset(vis, false, sizeof(vis));
40 |     dfs(si, sj);
41 |     return 0;
42 | }


--------------------------------------------------------------------------------
/Module 5/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 5/cycle_detect_in_directed_graph.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 1e5 + 5;
 4 | bool vis[N];
 5 | bool pathVisit[N];
 6 | vector<int> adj[N];
 7 | bool ans;
 8 | void dfs(int parent)
 9 | {
10 |     vis[parent] = true;
11 |     pathVisit[parent] = true;
12 |     for (int child : adj[parent])
13 |     {
14 |         if (pathVisit[child])
15 |         {
16 |             ans = true;
17 |         }
18 |         if (!vis[child])
19 |         {
20 |             dfs(child);
21 |         }
22 |     }
23 |     // kaj sesh
24 |     pathVisit[parent] = false;
25 | }
26 | int main()
27 | {
28 |     int n, e;
29 |     cin >> n >> e;
30 |     while (e--)
31 |     {
32 |         int a, b;
33 |         cin >> a >> b;
34 |         adj[a].push_back(b);
35 |         // adj[b].push_back(a);
36 |     }
37 |     memset(vis, false, sizeof(vis));
38 |     memset(pathVisit, false, sizeof(pathVisit));
39 |     ans = false;
40 |     for (int i = 0; i < n; i++)
41 |     {
42 |         if (!vis[i])
43 |         {
44 |             dfs(i);
45 |         }
46 |     }
47 |     if (ans)
48 |         cout << "Cycle detected";
49 |     else
50 |         cout << "Cycle not detected";
51 |     return 0;
52 | }


--------------------------------------------------------------------------------
/Module 5/cycle_detect_using_bfs.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 1e5 + 5;
 4 | bool vis[N];
 5 | vector<int> adj[N];
 6 | int parentArray[N];
 7 | bool ans;
 8 | void bfs(int s)
 9 | {
10 |     queue<int> q;
11 |     q.push(s);
12 |     vis[s] = true;
13 |     while (!q.empty())
14 |     {
15 |         int parent = q.front();
16 |         // cout << parent << endl;
17 |         q.pop();
18 |         for (int child : adj[parent])
19 |         {
20 |             if (vis[child] == true && parentArray[parent] != child)
21 |             {
22 |                 ans = true;
23 |             }
24 |             if (vis[child] == false)
25 |             {
26 |                 vis[child] = true;
27 |                 parentArray[child] = parent;
28 |                 q.push(child);
29 |             }
30 |         }
31 |     }
32 | }
33 | int main()
34 | {
35 |     int n, e;
36 |     cin >> n >> e;
37 |     while (e--)
38 |     {
39 |         int a, b;
40 |         cin >> a >> b;
41 |         adj[a].push_back(b);
42 |         adj[b].push_back(a);
43 |     }
44 |     memset(vis, false, sizeof(vis));
45 |     memset(parentArray, -1, sizeof(parentArray));
46 |     ans = false;
47 |     for (int i = 0; i < n; i++)
48 |     {
49 |         if (!vis[i])
50 |         {
51 |             bfs(i);
52 |         }
53 |     }
54 |     if (ans)
55 |     {
56 |         cout << "Cycle found";
57 |     }
58 |     else
59 |     {
60 |         cout << "Cycle not found";
61 |     }
62 |     return 0;
63 | }


--------------------------------------------------------------------------------
/Module 5/cycle_detect_using_dfs.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 1e5 + 5;
 4 | bool vis[N];
 5 | vector<int> adj[N];
 6 | int parentArray[N];
 7 | bool ans;
 8 | void dfs(int parent)
 9 | {
10 |     vis[parent] = true;
11 |     // cout << parent << endl;
12 |     for (int child : adj[parent])
13 |     {
14 |         if (vis[child] == true && child != parentArray[parent])
15 |         {
16 |             ans = true;
17 |             // cout << parent << " " << child << " " << parentArray[parent] << endl;
18 |         }
19 |         if (vis[child] == false)
20 |         {
21 |             parentArray[child] = parent;
22 |             dfs(child);
23 |         }
24 |     }
25 | }
26 | int main()
27 | {
28 |     int n, e;
29 |     cin >> n >> e;
30 |     while (e--)
31 |     {
32 |         int a, b;
33 |         cin >> a >> b;
34 |         adj[a].push_back(b);
35 |         adj[b].push_back(a);
36 |     }
37 |     memset(vis, false, sizeof(vis));
38 |     memset(parentArray, -1, sizeof(parentArray));
39 |     ans = false;
40 |     for (int i = 0; i < n; i++)
41 |     {
42 |         if (!vis[i])
43 |         {
44 |             dfs(i);
45 |         }
46 |     }
47 |     if (ans)
48 |         cout << "Cycle detected";
49 |     else
50 |         cout << "Cycle not detected";
51 |     return 0;
52 | }


--------------------------------------------------------------------------------
/Module 6/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 6/dijkstra_naive.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 100;
 4 | vector<pair<int, int>> v[N];
 5 | int dis[N];
 6 | void dijkstra(int src)
 7 | {
 8 |     queue<pair<int, int>> q;
 9 |     q.push({src, 0});
10 |     dis[src] = 0;
11 |     while (!q.empty())
12 |     {
13 |         pair<int, int> parent = q.front();
14 |         q.pop();
15 |         int node = parent.first;
16 |         int cost = parent.second;
17 |         for (pair<int, int> child : v[node])
18 |         {
19 |             int childNode = child.first;
20 |             int childCost = child.second;
21 |             if (cost + childCost < dis[childNode])
22 |             {
23 |                 // path relax
24 |                 dis[childNode] = cost + childCost;
25 |                 q.push({childNode, dis[childNode]});
26 |             }
27 |         }
28 |     }
29 | }
30 | int main()
31 | {
32 |     int n, e;
33 |     cin >> n >> e;
34 |     while (e--)
35 |     {
36 |         int a, b, c;
37 |         cin >> a >> b >> c;
38 |         v[a].push_back({b, c});
39 |         v[b].push_back({a, c});
40 |     }
41 |     for (int i = 0; i < n; i++)
42 |     {
43 |         dis[i] = INT_MAX;
44 |     }
45 |     dijkstra(0);
46 |     for (int i = 0; i < n; i++)
47 |     {
48 |         cout << i << "-> " << dis[i] << endl;
49 |     }
50 |     return 0;
51 | }


--------------------------------------------------------------------------------
/Module 6/dijkstra_optimized.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | const int N = 100;
 4 | vector<pair<int, int>> v[N];
 5 | int dis[N];
 6 | class cmp
 7 | {
 8 | public:
 9 |     bool operator()(pair<int, int> a, pair<int, int> b)
10 |     {
11 |         return a.second > b.second;
12 |     }
13 | };
14 | void dijkstra(int src)
15 | {
16 |     priority_queue<pair<int, int>, vector<pair<int, int>>, cmp> pq;
17 |     pq.push({src, 0});
18 |     dis[src] = 0;
19 |     while (!pq.empty())
20 |     {
21 |         pair<int, int> parent = pq.top();
22 |         pq.pop();
23 |         int node = parent.first;
24 |         int cost = parent.second;
25 |         for (pair<int, int> child : v[node])
26 |         {
27 |             int childNode = child.first;
28 |             int childCost = child.second;
29 |             if (cost + childCost < dis[childNode])
30 |             {
31 |                 // path relax
32 |                 dis[childNode] = cost + childCost;
33 |                 pq.push({childNode, dis[childNode]});
34 |             }
35 |         }
36 |     }
37 | }
38 | int main()
39 | {
40 |     int n, e;
41 |     cin >> n >> e;
42 |     while (e--)
43 |     {
44 |         int a, b, c;
45 |         cin >> a >> b >> c;
46 |         v[a].push_back({b, c});
47 |         v[b].push_back({a, c});
48 |     }
49 |     for (int i = 0; i < n; i++)
50 |     {
51 |         dis[i] = INT_MAX;
52 |     }
53 |     dijkstra(0);
54 |     for (int i = 0; i < n; i++)
55 |     {
56 |         cout << i << "-> " << dis[i] << endl;
57 |     }
58 |     return 0;
59 | }


--------------------------------------------------------------------------------
/Module 7/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 7/bellman_ford.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | class Edge
 4 | {
 5 | public:
 6 |     int u, v, c;
 7 |     Edge(int u, int v, int c)
 8 |     {
 9 |         this->u = u;
10 |         this->v = v;
11 |         this->c = c;
12 |     }
13 | };
14 | const int N = 1e5 + 5;
15 | int dis[N];
16 | int main()
17 | {
18 |     int n, e;
19 |     cin >> n >> e;
20 |     vector<Edge> EdgeList;
21 |     while (e--)
22 |     {
23 |         int u, v, c;
24 |         cin >> u >> v >> c;
25 |         EdgeList.push_back(Edge(u, v, c));
26 |     }
27 |     for (int i = 0; i < n; i++)
28 |     {
29 |         dis[i] = INT_MAX;
30 |     }
31 |     dis[0] = 0;
32 |     for (int i = 1; i <= n - 1; i++)
33 |     {
34 |         for (Edge ed : EdgeList)
35 |         {
36 |             int u, v, c;
37 |             u = ed.u;
38 |             v = ed.v;
39 |             c = ed.c;
40 |             if (dis[u] < INT_MAX && dis[u] + c < dis[v])
41 |             {
42 |                 dis[v] = dis[u] + c;
43 |             }
44 |         }
45 |     }
46 |     for (int i = 0; i < n; i++)
47 |         cout << i << " -> " << dis[i] << endl;
48 |     return 0;
49 | }


--------------------------------------------------------------------------------
/Module 7/detect_negative_cycle.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | class Edge
 4 | {
 5 | public:
 6 |     int u, v, c;
 7 |     Edge(int u, int v, int c)
 8 |     {
 9 |         this->u = u;
10 |         this->v = v;
11 |         this->c = c;
12 |     }
13 | };
14 | const int N = 1e5 + 5;
15 | int dis[N];
16 | int main()
17 | {
18 |     int n, e;
19 |     cin >> n >> e;
20 |     vector<Edge> EdgeList;
21 |     while (e--)
22 |     {
23 |         int u, v, c;
24 |         cin >> u >> v >> c;
25 |         EdgeList.push_back(Edge(u, v, c));
26 |     }
27 |     for (int i = 0; i < n; i++)
28 |     {
29 |         dis[i] = INT_MAX;
30 |     }
31 |     dis[0] = 0;
32 |     for (int i = 1; i <= n - 1; i++)
33 |     {
34 |         for (Edge ed : EdgeList)
35 |         {
36 |             int u, v, c;
37 |             u = ed.u;
38 |             v = ed.v;
39 |             c = ed.c;
40 |             if (dis[u] < INT_MAX && dis[u] + c < dis[v])
41 |             {
42 |                 dis[v] = dis[u] + c;
43 |             }
44 |         }
45 |     }
46 |     bool cycle = false;
47 |     for (Edge ed : EdgeList)
48 |     {
49 |         int u, v, c;
50 |         u = ed.u;
51 |         v = ed.v;
52 |         c = ed.c;
53 |         if (dis[u] < INT_MAX && dis[u] + c < dis[v])
54 |         {
55 |             cycle = true;
56 |             break;
57 |         }
58 |     }
59 |     if (cycle)
60 |     {
61 |         cout << "Cycle found. No answer" << endl;
62 |     }
63 |     else
64 |     {
65 |         for (int i = 0; i < n; i++)
66 |             cout << i << " -> " << dis[i] << endl;
67 |     }
68 |     return 0;
69 | }


--------------------------------------------------------------------------------
/Module 7/floyd.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | #define ll long long int
 3 | using namespace std;
 4 | int main()
 5 | {
 6 |     ll n, e;
 7 |     cin >> n >> e;
 8 |     ll adj[n][n];
 9 |     for (int i = 0; i < n; i++)
10 |     {
11 |         for (int j = 0; j < n; j++)
12 |         {
13 |             adj[i][j] = INT_MAX;
14 |             if (i == j)
15 |                 adj[i][j] = 0;
16 |         }
17 |     }
18 |     while (e--)
19 |     {
20 |         int a, b, c;
21 |         cin >> a >> b >> c;
22 |         adj[a][b] = c;
23 |     }
24 |     for (int k = 0; k < n; k++)
25 |     {
26 |         for (int i = 0; i < n; i++)
27 |         {
28 |             for (int j = 0; j < n; j++)
29 |             {
30 |                 if (adj[i][k] + adj[k][j] < adj[i][j])
31 |                 {
32 |                     adj[i][j] = adj[i][k] + adj[k][j];
33 |                 }
34 |             }
35 |         }
36 |     }
37 |     // cout << "AFTER" << endl;
38 |     // for (int i = 0; i < n; i++)
39 |     // {
40 |     //     for (int j = 0; j < n; j++)
41 |     //     {
42 |     //         if (adj[i][j] == INT_MAX)
43 |     //             cout << "INF ";
44 |     //         else
45 |     //             cout << adj[i][j] << " ";
46 |     //     }
47 |     //     cout << endl;
48 |     // }
49 | 
50 |     for (int i = 0; i < n; i++)
51 |     {
52 |         if (adj[i][i] < 0)
53 |         {
54 |             cout << "Cycle detected" << endl;
55 |             break;
56 |         }
57 |     }
58 |     return 0;
59 | }


--------------------------------------------------------------------------------
/Module 9/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 9/Count_Sub_Islands.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class Solution
 5 | {
 6 | public:
 7 |     int n, m;
 8 |     bool vis[505][505];
 9 |     vector<pair<int, int>> d = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
10 |     bool valid(int ci, int cj)
11 |     {
12 |         if (ci >= 0 && ci < n && cj >= 0 && cj < m)
13 |             return true;
14 |         else
15 |             return false;
16 |     }
17 |     bool flag;
18 |     void dfs(int si, int sj, vector<vector<int>> &grid1, vector<vector<int>> &grid2)
19 |     {
20 |         vis[si][sj] = true;
21 |         if (grid1[si][sj] == 0)
22 |             flag = false;
23 |         for (int i = 0; i < 4; i++)
24 |         {
25 |             int ci = si + d[i].first;
26 |             int cj = sj + d[i].second;
27 |             if (valid(ci, cj) && !vis[ci][cj] && grid2[ci][cj] == 1)
28 |             {
29 |                 dfs(ci, cj, grid1, grid2);
30 |             }
31 |         }
32 |     }
33 |     int countSubIslands(vector<vector<int>> &grid1, vector<vector<int>> &grid2)
34 |     {
35 |         memset(vis, false, sizeof(vis));
36 |         n = grid2.size();
37 |         m = grid2[0].size();
38 |         int ans = 0;
39 |         for (int i = 0; i < n; i++)
40 |         {
41 |             for (int j = 0; j < m; j++)
42 |             {
43 |                 if (!vis[i][j] && grid2[i][j] == 1)
44 |                 {
45 |                     flag = true;
46 |                     dfs(i, j, grid1, grid2);
47 |                     if (flag == true)
48 |                         ans++;
49 |                 }
50 |             }
51 |         }
52 |         return ans;
53 |     }
54 | };


--------------------------------------------------------------------------------
/Module 9/Find_if_Path_Exists_in_Graph.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class Solution
 5 | {
 6 | public:
 7 |     vector<int> v[200005];
 8 |     bool vis[200005];
 9 |     void dfs(int s)
10 |     {
11 |         vis[s] = true;
12 |         for (int child : v[s])
13 |         {
14 |             if (!vis[child])
15 |             {
16 |                 dfs(child);
17 |             }
18 |         }
19 |     }
20 |     bool validPath(int n, vector<vector<int>> &edges, int source, int d)
21 |     {
22 |         memset(vis, false, sizeof(vis));
23 |         for (int i = 0; i < edges.size(); i++)
24 |         {
25 |             int a = edges[i][0];
26 |             int b = edges[i][1];
27 |             v[a].push_back(b);
28 |             v[b].push_back(a);
29 |         }
30 |         dfs(source);
31 |         return vis[d];
32 |     }
33 | };


--------------------------------------------------------------------------------
/Module 9/Island Parameter.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class Solution
 5 | {
 6 | public:
 7 |     bool vis[105][105];
 8 |     int ans;
 9 |     vector<pair<int, int>> d = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
10 |     int n, m;
11 |     bool valid(int ci, int cj)
12 |     {
13 |         if (ci >= 0 && ci < n && cj >= 0 && cj < m)
14 |             return true;
15 |         else
16 |             return false;
17 |     }
18 |     void dfs(int si, int sj, vector<vector<int>> &grid)
19 |     {
20 |         vis[si][sj] = true;
21 |         for (int i = 0; i < 4; i++)
22 |         {
23 |             int ci = si + d[i].first;
24 |             int cj = sj + d[i].second;
25 |             if (valid(ci, cj))
26 |             {
27 |                 if (grid[ci][cj] == 0)
28 |                     ans++;
29 |             }
30 |             else
31 |             {
32 |                 ans++;
33 |             }
34 |             if (valid(ci, cj) && !vis[ci][cj] && grid[ci][cj] == 1)
35 |             {
36 |                 dfs(ci, cj, grid);
37 |             }
38 |         }
39 |     }
40 |     int islandPerimeter(vector<vector<int>> &grid)
41 |     {
42 |         memset(vis, false, sizeof(vis));
43 |         ans = 0;
44 |         n = grid.size();
45 |         m = grid[0].size();
46 |         for (int i = 0; i < n; i++)
47 |         {
48 |             for (int j = 0; j < m; j++)
49 |             {
50 |                 if (!vis[i][j] && grid[i][j] == 1)
51 |                 {
52 |                     dfs(i, j, grid);
53 |                 }
54 |             }
55 |         }
56 |         return ans;
57 |     }
58 | };


--------------------------------------------------------------------------------
/Module 9/Max_Area_of_Island.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class Solution
 5 | {
 6 | public:
 7 |     bool vis[55][55];
 8 |     int ans;
 9 |     int n, m;
10 |     vector<pair<int, int>> d = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
11 |     bool valid(int ci, int cj)
12 |     {
13 |         if (ci >= 0 && ci < n && cj >= 0 && cj < m)
14 |             return true;
15 |         else
16 |             return false;
17 |     }
18 |     void dfs(int si, int sj, vector<vector<int>> &grid)
19 |     {
20 |         vis[si][sj] = true;
21 |         ans++;
22 |         for (int i = 0; i < 4; i++)
23 |         {
24 |             int ci = si + d[i].first;
25 |             int cj = sj + d[i].second;
26 |             if (valid(ci, cj) && !vis[ci][cj] && grid[ci][cj] == 1)
27 |             {
28 |                 dfs(ci, cj, grid);
29 |             }
30 |         }
31 |     }
32 |     int maxAreaOfIsland(vector<vector<int>> &grid)
33 |     {
34 |         memset(vis, false, sizeof(vis));
35 |         n = grid.size();
36 |         m = grid[0].size();
37 |         int mx = 0;
38 |         for (int i = 0; i < n; i++)
39 |         {
40 |             for (int j = 0; j < m; j++)
41 |             {
42 |                 if (!vis[i][j] && grid[i][j] == 1)
43 |                 {
44 |                     ans = 0;
45 |                     dfs(i, j, grid);
46 |                     mx = max(mx, ans);
47 |                 }
48 |             }
49 |         }
50 |         return mx;
51 |     }
52 | };


--------------------------------------------------------------------------------
/Module 9/Number_of_Closed_Islands.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class Solution
 5 | {
 6 | public:
 7 |     int n, m;
 8 |     bool vis[105][105];
 9 |     vector<pair<int, int>> d = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
10 |     bool valid(int ci, int cj)
11 |     {
12 |         if (ci >= 0 && ci < n && cj >= 0 && cj < m)
13 |             return true;
14 |         else
15 |             return false;
16 |     }
17 |     bool flag;
18 |     void dfs(int si, int sj, vector<vector<int>> &grid)
19 |     {
20 |         vis[si][sj] = true;
21 |         if (si == 0 || si == n - 1 || sj == 0 || sj == m - 1)
22 |             flag = false;
23 |         for (int i = 0; i < 4; i++)
24 |         {
25 |             int ci = si + d[i].first;
26 |             int cj = sj + d[i].second;
27 |             if (valid(ci, cj) && !vis[ci][cj] && grid[ci][cj] == 0)
28 |             {
29 |                 dfs(ci, cj, grid);
30 |             }
31 |         }
32 |     }
33 |     int closedIsland(vector<vector<int>> &grid)
34 |     {
35 |         memset(vis, false, sizeof(vis));
36 |         n = grid.size();
37 |         m = grid[0].size();
38 |         int ans = 0;
39 |         for (int i = 0; i < n; i++)
40 |         {
41 |             for (int j = 0; j < m; j++)
42 |             {
43 |                 if (!vis[i][j] && grid[i][j] == 0)
44 |                 {
45 |                     flag = true;
46 |                     dfs(i, j, grid);
47 |                     if (flag == true)
48 |                     {
49 |                         ans++;
50 |                     }
51 |                 }
52 |             }
53 |         }
54 |         return ans;
55 |     }
56 | };


--------------------------------------------------------------------------------
/Module 9/Number_of_Islands.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | class Solution
 5 | {
 6 | public:
 7 |     int n, m;
 8 |     bool vis[305][305];
 9 |     vector<pair<int, int>> d = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
10 |     bool valid(int ci, int cj)
11 |     {
12 |         if (ci >= 0 && ci < n && cj >= 0 && cj < m)
13 |             return true;
14 |         else
15 |             return false;
16 |     }
17 |     void dfs(int si, int sj, vector<vector<char>> &grid)
18 |     {
19 |         vis[si][sj] = true;
20 |         for (int i = 0; i < 4; i++)
21 |         {
22 |             int ci = si + d[i].first;
23 |             int cj = sj + d[i].second;
24 |             if (valid(ci, cj) && !vis[ci][cj] && grid[ci][cj] == '1')
25 |             {
26 |                 dfs(ci, cj, grid);
27 |             }
28 |         }
29 |     }
30 |     int numIslands(vector<vector<char>> &grid)
31 |     {
32 |         n = grid.size();
33 |         m = grid[0].size();
34 |         memset(vis, false, sizeof(vis));
35 |         int ans = 0;
36 |         for (int i = 0; i < n; i++)
37 |         {
38 |             for (int j = 0; j < m; j++)
39 |             {
40 |                 if (!vis[i][j] && grid[i][j] == '1')
41 |                 {
42 |                     dfs(i, j, grid);
43 |                     ans++;
44 |                 }
45 |             }
46 |         }
47 |         return ans;
48 |     }
49 | };


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Batch-4-Introduction-to-Algorithms
2 | 


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