Update

Author: phumipatc

Data_Structure/queue_fifo.cpp

@@ -0,0 +1,88 @@
+/*
+	Task		: Queue
+	Author		: Lalit Chaudhary
+	Language	: C++
+	Explanation	: Implement a queue using a linked list and perform 5 enqueue operations, one dequeue operation, anmd display the elements
+*/
+
+#include <iostream>
+using namespace std;
+struct node {
+    int data;
+    wwxstruct node *next;
+};
+struct node* front = NULL;
+struct node* rear = NULL;
+struct node* temp;
+void Insert() {
+int val;
+    cout<<"Insert the element in queue : "<<endl;
+    cin>>val;
+    if (rear == NULL) {
+        rear = (struct node *)malloc(sizeof(struct node));
+        rear->next = NULL;
+        rear->data = val;
+        front = rear;
+    } else {
+      temp=(struct node *)malloc(sizeof(struct node));
+        rear->next = temp;
+        temp->data = val;
+        temp->next = NULL;
+        rear = temp;
+    }
+}
+void Delete() {
+    temp = front;
+    if (front == NULL) {
+        cout<<"Underflow"<<endl;
+            return;
+    }
+    else
+    if (temp->next != NULL) {
+        temp = temp->next;
+        cout<<"Element deleted from queue is : "<<front->data<<endl;
+        free(front);
+        front = temp;
+    } else {
+        cout<<"Element deleted from queue is : "<<front->data<<endl;
+        free(front);
+        front = NULL;
+        rear = NULL;
+    }
+}
+void Display() {
+    temp = front;
+    if ((front == NULL) && (rear == NULL)) {
+        cout<<"Queue is empty"<<endl;
+        return;
+    }
+    cout<<"Queue elements are: ";
+    while (temp != NULL) {
+        cout<<temp->data<<" ";
+        temp = temp->next;
+    }
+    cout<<endl;
+}
+int main() {
+    int ch;
+    cout<<"1) Insert element to queue"<<endl;
+    cout<<"2) Delete element from queue"<<endl;
+    cout<<"3) Display all the elements of queue"<<endl;
+    cout<<"4) Exit"<<endl;
+    do {
+        cout<<"Enter your choice : "<<endl;
+        cin>>ch;
+        switch (ch) {
+            case 1: Insert();
+            break;
+            case 2: Delete();
+            break;
+            case 3: Display();
+            break;
+            case 4: cout<<"Exit"<<endl;
+            break;
+            default: cout<<"Invalid choice"<<endl;
+        }
+    } while(ch!=4);
+    return 0;
+}

Divide_and_Conquer/Mod_of_Power.cpp

@@ -3,6 +3,7 @@
 	Author	: Phumipat C. [MAGCARI]
 	School	: RYW
 	Language: C++
+	Explanation Link : https://www.geeksforgeeks.org/modular-exponentiation-power-in-modular-arithmetic/
 	Created	: 03 May 2021 [15:15]
 */
 #include<bits/stdc++.h>
@@ -17,4 +18,4 @@ LL mod_of_power(LL a,LL b,LL c = MOD){	// pow(a,b)%c
 	LL now = mod_of_power(a,b/2,c);
 	if(b&1)	return (((now*now)%c)*(a%c))%c;
 	else	return (now*now)%c;
-}
+}

Divide_and_Conquer/multiply_two_polynomials.cpp

@@ -0,0 +1,50 @@
+/*
+	Task	: Mod_of_Power
+	Author	: Phumipat C. [MAGCARI]
+	School	: RYW
+	Language: C++
+	Explanation Link : https://www.geeksforgeeks.org/multiply-two-polynomials-2/
+	Created	: 03 May 2021 [15:15]
+*/
+
+
+#include<bits/stdc++.h>
+#define all(x) begin(x),end(x)
+#define sz(x) (int)(x).size()
+#define MOD (LL )(1e9+7)
+using namespace std;
+using LL = long long;
+using PII = pair<int ,int >;
+using PLL = pair<long long ,long long >;
+const int dir4[2][4] = {{1,-1,0,0},{0,0,1,-1}};
+const int dir8[2][8] = {{-1,-1,-1,0,1,1,1,0},{-1,0,1,1,-1,0,1,-1}};
+
+
+
+int *multiply(int A[], int B[], int m, int n)
+{
+   int *prod = new int[m+n-1];
+  
+   for (int i = 0; i<m+n-1; i++)
+     prod[i] = 0;
+
+   for (int i=0; i<m; i++)
+   {
+     for (int j=0; j<n; j++)
+         prod[i+j] += A[i]*B[j];
+   }
+  
+   return prod;
+}
+
+void printPoly(int poly[], int n)
+{
+    for (int i=0; i<n; i++)
+    {
+       cout << poly[i];
+       if (i != 0)
+        cout << "x^" << i ;
+       if (i != n-1)
+       cout << " + ";
+    }
+}

Greedy/Job_sequencing.cpp

@@ -0,0 +1,64 @@
+/*
+	Task		: Job_sequencing
+	Author		: PunnyOz2
+	Language	: C++
+	Explanation	: 
+	Created		: 01 October 2022 [15:39]
+*/
+#include<bits/stdc++.h>
+using namespace std;
+
+// A structure to represent a job
+struct Job {
+   
+    char id; // Job Id
+    int dead; // Deadline of job
+    int profit; // Profit earned if job is completed before
+                // deadline
+    bool operator<(const Job &o) const{
+        return profit > o.profit;
+    }
+};
+
+vector<Job> jobSequencingResult(vector<Job> arr, int n) {
+    sort(arr.begin(), arr.end(), [](Job a, Job b) { return a.dead < b.dead; });
+    priority_queue<Job> pq;
+    vector<Job> ans;
+    for (int i = n - 1; i >= 0; i--) {
+        int slot_available;
+        if (pq.empty()) {
+            slot_available = arr[i].dead;
+        } else {
+            slot_available = arr[i].dead - arr[i-1].dead;
+        }
+        pq.push(arr[i]);
+        while(!slot_available && !pq.empty()) {
+            ans.push_back(pq.top());
+            pq.pop();
+            slot_available--;
+        }
+    }
+    sort(ans.begin(), ans.end(), [&](Job a, Job b) { return a.dead < b.dead; });
+    return ans;
+}
+
+int jobSequencingProfitSum(vector<Job> arr, int n) {
+    sort(arr.begin(), arr.end(), [](Job a, Job b) { return a.dead < b.dead; });
+    priority_queue<Job> pq;
+    int ans = 0;
+    for (int i = n - 1; i >= 0; i--) {
+        int slot_available;
+        if (pq.empty()) {
+            slot_available = arr[i].dead;
+        } else {
+            slot_available = arr[i].dead - arr[i-1].dead;
+        }
+        pq.push(arr[i]);
+        while(!slot_available && !pq.empty()) {
+            ans += pq.top().profit;
+            pq.pop();
+            slot_available--;
+        }
+    }
+    return ans;
+}

Greedy/Minimum_Coin_Change.cpp

@@ -0,0 +1,48 @@
+/*
+        Task		: Minimum Coin Change
+        Author		: Naravit N. [ADNCRICH]
+        School		: Chulalongkorn University
+        Language	: C++
+        Explanation	: https://www.geeksforgeeks.org/quick-sort/
+        Created		: 01 Oct 2022 [15:37]
+*/
+#include <bits/stdc++.h>
+#define all(x) begin(x), end(x)
+#define sz(x) (int)(x).size()
+#define MOD (LL)(1e9 + 7)
+using namespace std;
+using LL = long long;
+using PII = pair<int, int>;
+using PLL = pair<long long, long long>;
+const int dir4[2][4] = {{1, -1, 0, 0}, {0, 0, 1, -1}};
+const int dir8[2][8] = {{-1, -1, -1, 0, 1, 1, 1, 0}, {-1, 0, 1, 1, -1, 0, 1, -1}};
+const int N = 1000000, M = 10000;
+
+int dp[N + 20], coins[M + 20];
+
+void minimum_coin_change(int n) {
+    for (int i = 0; i < n; i++) cin >> coins[i];
+    memset(dp, -1, sizeof(dp));
+    dp[0] = 0;
+    for (int i = 1; i <= N; i++) {
+        for (int j = 0; j < n; j++) {
+            if (i - coins[j] >= 0 && dp[i - coins[j]] != -1) {
+                if (dp[i] == -1)
+                    dp[i] = dp[i - coins[j]] + 1;
+                else
+                    dp[i] = min(dp[i], dp[i - coins[j]] + 1);
+            }
+        }
+    }
+}
+
+int main() {
+    int n, q, i;
+    cin >> n >> q;
+    minimum_coin_change(n);
+    while (q--) {
+        int x;
+        cin >> x;
+        cout << dp[x] << "\n";
+    }
+}

Optimization_Technique/2D_Range_Minimum_Query.cpp

@@ -0,0 +1,58 @@
+/*
+	Task		: 2D Range Minimum Query
+	Author		: Borworntat D. [Hydrolzed~]
+	School		: RYW
+	Language	: C++
+	Explanation	: https://codeforces.com/blog/entry/45485
+	Created		: 01 October 2022 [12:31]
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+
+const int MxN = 1010;
+const int LgN = 16;
+int sparse_table[LgN][LgN][MxN][MxN],  lg[MxN];
+
+void init(std::vector<std::vector<int>> arr){
+	int n = arr.size();
+	for(int state=2; state<MxN; ++state){
+		lg[state] = lg[state >> 1] + 1;
+	}
+	memset(sparse_table, 0x3f, sizeof sparse_table);
+	// base case
+	for(int i=0; i<n; ++i){
+		for(int j=0; j<n; ++j){
+			sparse_table[0][0][i][j] = arr[i][j];
+		}
+	}
+	// precompute
+	for(int state_i=0; state_i<LgN; ++state_i){
+		for(int state_j=0; state_j<LgN; ++state_j){
+			if(state_i + state_j == 0){
+				continue;
+			}
+			for(int i=0; i+(1 << state_i)<=n; ++i){
+				for(int j=0; j+(1 << state_j)<=n; ++j){
+					if(state_i == 0){
+						sparse_table[state_i][state_j][i][j] = min(sparse_table[state_i][state_j - 1][i][j], sparse_table[state_i][state_j - 1][i][j + (1 << (state_j - 1))]);
+					}
+					else{
+						sparse_table[state_i][state_j][i][j] = min(sparse_table[state_i - 1][state_j][i][j], sparse_table[state_i - 1][state_j][i + (1 << (state_i - 1))][j]);
+					}
+				}
+			}
+		}
+	}
+}
+
+int query(int a, int b, int c, int d){
+	swap(c, b);
+	c++, d++;
+	int state_i = lg[c - a], state_j = lg[d - b];
+	int A = sparse_table[state_i][state_j][a][b];
+	int B = sparse_table[state_i][state_j][c - (1 << state_i)][b];
+	int C = sparse_table[state_i][state_j][a][d - (1 << state_j)];
+	int D = sparse_table[state_i][state_j][c - (1 << state_i)][d - (1 << state_j)];
+	return min({A, B, C, D});
+}

Searching/Exponential_Search.cpp

@@ -0,0 +1,59 @@
+/*
+	Task		: Exponential_Search.cpp
+	Author		: sumit-awasthi
+	Language	: C++
+	Explanation	:
+*/
+#include <bits/stdc++.h>
+#define all(x) begin(x), end(x)
+#define sz(x) (int)(x).size()
+#define MOD (LL)(1e9 + 7)
+
+#include<iostream>
+
+using namespace std;
+const int dir4[2][4] = {{1, -1, 0, 0}, {0, 0, 1, -1}};
+const int dir8[2][8] = {{-1, -1, -1, 0, 1, 1, 1, 0}, {-1, 0, 1, 1, -1, 0, 1, -1}};
+
+int binarySearch(int array[], int start, int end, int key) {
+   if(start <= end) {
+      int mid = (start + (end - start) /2); 
+      if(array[mid] == key)
+         return mid;
+      if(array[mid] > key)
+         return binarySearch(array, start, mid-1, key);
+         return binarySearch(array, mid+1, end, key);
+   }
+   return -1;
+}
+
+int exponentialSearch(int array[], int start, int end, int key){
+   if((end - start) <= 0)
+      return -1;
+      int i = 1; // as 2^0 = 1
+      while(i < (end - start)){
+         if(array[i] < key)
+            i *= 2; 
+         else
+            break; 
+   }
+   return binarySearch(array, i/2, i, key); 
+}
+
+int main() {
+   int n, searchKey, loc;
+   cout << "Enter number of items: ";
+   cin >> n;
+   int arr[n];
+   cout << "Enter items: " << endl;
+   for(int i = 0; i< n; i++) {
+      cin >> arr[i];
+   }
+   cout << "Enter search key to search in the list: ";
+   cin >> searchKey;
+   if((loc = exponentialSearch(arr, 0, n, searchKey)) >= 0)
+      cout << "Item found at Index= " << loc << endl;
+   else
+      cout << "Item is not found in the list." << endl;
+  return 0;
+}