solved on 22/10/23

Author: Priyanshu-Ganatra

DynamicMemoryAllocation.cpp

@@ -0,0 +1,82 @@
+#include <iostream>
+
+using namespace std;
+
+void print(int **v, int rows, int cols)
+{
+    for (int i = 0; i < rows; i++)
+    {
+        for (int j = 0; j < cols; j++)
+        {
+            cout << v[i][j] << " ";
+        }
+        cout << endl;
+    }
+}
+
+int main()
+{
+    // // 1. allocate single int
+    // int *intPtr = new int(5);
+
+    // // allocate single int using malloc
+    // int *mptr = (int *)malloc(4);
+    // *mptr = 5;
+
+    // cout << *intPtr << " " << *mptr << endl;
+    // delete intPtr;
+    // free(mptr);
+
+    // // 1D array allocation
+    // int *arrnew = new int[5];
+
+    // // 1D array allocation using malloc
+    // int *arrmalloc = (int *)malloc(5 * sizeof(int));
+
+    // for (int i = 0; i < 5; i++)
+    // {
+    //     int d;
+    //     cin >> d;
+    //     arrnew[i] = arrmalloc[i] = d;
+    // }
+
+    // for (int i = 0; i < 5; i++)
+    // {
+    //     cout << arrnew[i] << " " << arrmalloc[i] << endl;
+    // }
+    // delete[] arrnew;
+    // free(arrmalloc);
+
+    // 2D array allocation
+    int rows = 5, cols = 5;
+    int **ptr2d = new int *[rows];
+
+    // 2D array allocation using malloc
+    for (int i = 0; i < rows; ++i)
+        ptr2d[i] = new int[cols];
+
+    int **ptr2dmalloc = (int **)malloc(sizeof(int *) * rows);
+    for (int i = 0; i < rows; i++)
+        ptr2dmalloc[i] = (int *)malloc(sizeof(int) * cols);
+
+    for (int i = 0; i < rows; i++)
+    {
+        for (int j = 0; j < cols; j++)
+        {
+            ptr2d[i][j] = 7;
+            ptr2dmalloc[i][j] = 8;
+        }
+    }
+
+    print(ptr2d, rows, cols);
+    print(ptr2dmalloc, rows, cols);
+
+    for (int i = 0; i < rows; ++i)
+        delete[] ptr2d[i];
+    delete[] ptr2d;
+
+    for (int i = 0; i < rows; ++i)
+        free(ptr2dmalloc[i]);
+    free(ptr2dmalloc);
+    return 0;
+}

LC_60_HouseRobber2.cpp

@@ -0,0 +1,42 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int solve(vector<int> &nums, int idx, int n)
+{
+    // base case
+    if (idx > n)
+    {
+        return 0;
+    }
+
+    // rob this house
+    int opt1 = nums[idx] + solve(nums, idx + 2, n);
+
+    // don't rob this house
+    int opt2 = 0 + solve(nums, idx + 1, n);
+
+    int ans = max(opt1, opt2);
+    return ans;
+}
+
+// recursive solution, gives TLE on leetcode. we'll use DP to optimize it in future
+// tc: O(2^n) sc: O(n)
+int rob(vector<int> &nums)
+{
+    int n = nums.size();
+    if (n == 1)
+        return nums[0];
+    int opt1 = solve(nums, 0, n - 2);
+    int opt2 = solve(nums, 1, n - 1);
+
+    int ans = max(opt1, opt2);
+    return ans;
+}
+
+int main()
+{
+    vector<int> nums = {1, 2, 3, 1};
+    cout << "Maximum amount that can be robbed: ";
+    cout << rob(nums) << endl;
+    return 0;
+}

LC_61_EditDistance.cpp

@@ -0,0 +1,55 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int solve(string &word1, string &word2, int i, int j)
+{
+    // base cases
+    // if we reach the end of any of the strings, we return the length of the remaining string
+    if (i >= word1.length())
+    {
+        return word2.length() - j;
+    }
+    if (j >= word2.length())
+    {
+        return word1.length() - i;
+    }
+
+    int ans = 0;
+    if (word1[i] == word2[j]) // if characters are same, no operation is required
+    {
+        ans = 0 + solve(word1, word2, i + 1, j + 1);
+    }
+    else // if characters are not same, we have 3 options: insert, remove, replace (all 3 are equally valid) and we'll take the minimum of all 3 options as our answer for that particular call
+    {
+        // insert
+        int opt1 = 1 + solve(word1, word2, i, j + 1); // we don't increment i because we want to insert the character at jth position of word2 in word1
+        // remove
+        int opt2 = 1 + solve(word1, word2, i + 1, j); // we don't increment j because we want to remove the character at ith position of word1
+        // replace
+        int opt3 = 1 + solve(word1, word2, i + 1, j + 1); // we increment both i and j because we want to replace the character at ith position of word1 with the character at jth position of word2 and then move forward
+        ans = min(opt1, min(opt2, opt3));                 // as required by the question we take the minimum of all 3 options
+    }
+    return ans; // return the answer for that particular call
+}
+
+// recursive solution, gives TLE, we'll use DP to optimize it in future
+// tc: O(3^n) sc: O(n)
+int minDistance(string word1, string word2)
+{
+    int i = 0;
+    int j = 0;
+    int ans = solve(word1, word2, i, j);
+    // horse -> rorse (replace 'h' with 'r')
+    // rorse -> rose (remove 'r')
+    // rose -> ros (remove 'e')
+    return ans;
+}
+
+int main()
+{
+    string word1 = "horse";
+    string word2 = "ros";
+    cout << "Minimum number of operations required to convert word1 to word2: ";
+    cout << minDistance(word1, word2) << endl;
+    return 0;
+}

LC_62_MaximalSquare.cpp

@@ -0,0 +1,52 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int solve(vector<vector<char>> &matrix, int i, int j, int row, int col, int &maxi)
+{
+    // base case
+    if (i >= row || j >= col)
+    {
+        return 0;
+    }
+
+    // explore all 3 directions
+    int right = solve(matrix, i, j + 1, row, col, maxi);
+    int diagnol = solve(matrix, i + 1, j + 1, row, col, maxi);
+    int down = solve(matrix, i + 1, j, row, col, maxi);
+
+    // check can we build sqaure form current position
+    if (matrix[i][j] == '1')
+    {
+        // if yes, we'll take the minimum of all 3 directions and add 1 to it because we can build a square of size 1 from current position
+        int ans = 1 + min(right, min(down, diagnol));
+        // update the maximum square size found so far
+        maxi = max(maxi, ans);
+        return ans; // return the answer for that particular call
+    }
+    else
+    {
+        // if current position is 0, we can't build square from here so we return 0
+        return 0;
+    }
+}
+
+int maximalSquare(vector<vector<char>> &matrix)
+{
+    int i = 0;
+    int j = 0;
+    int row = matrix.size();
+    int col = matrix[0].size();
+    int maxi = 0;
+    int ans = solve(matrix, i, j, row, col, maxi);
+    return maxi * maxi;
+}
+
+int main()
+{
+    vector<vector<char>> matrix = {{'1', '0', '1', '0', '0'},
+                                   {'1', '0', '1', '1', '1'},
+                                   {'1', '1', '1', '1', '1'},
+                                   {'1', '0', '0', '1', '0'}};
+    cout << maximalSquare(matrix) << endl;
+    return 0;
+}

Recursion practice/CountDerangements.cpp

@@ -0,0 +1,30 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int solve(int n)
+{
+
+    // base case
+    if (n == 1)
+    {
+        return 0;
+    }
+    if (n == 2)
+    {
+        return 1;
+    }
+
+    int ans = (n - 1) * (solve(n - 1) + solve(n - 2));
+    return ans;
+}
+
+int main()
+{
+
+    int n;
+    vector<int> v = {0, 1, 2}; // possible derangements: {2, 0, 1} and {1, 2, 0}
+    n = v.size();
+    cout << solve(n) << endl;
+
+    return 0;
+}

Recursion practice/PaintingFenceAlgo.cpp

@@ -0,0 +1,27 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int getPaintWays(int n, int k)
+{
+    // base case
+    if (n == 1)
+    {
+        return k;
+    }
+    if (n == 2)
+    {
+        return k + k * (k - 1);
+    }
+    // k-1 is because we can't have more than 2 consecutive fences of same color in a row
+    int ans = (k - 1) * (getPaintWays(n - 1, k) + getPaintWays(n - 2, k));
+    return ans;
+}
+
+int main()
+{
+    int n = 3;
+    int k = 3;
+    int ans = getPaintWays(n, k);
+    cout << ans << endl;
+    return 0;
+}