GFG

Author: harshit2608

GeeksForGeeks/Job Sequencing Problem.cpp

@@ -0,0 +1,36 @@
+class Solution
+{
+public:
+    // Function to find the maximum profit and the number of jobs done.
+    static bool comp(Job a, Job b)
+    {
+        return a.profit > b.profit;
+    }
+
+    vector<int> JobScheduling(Job arr[], int n)
+    {
+        sort(arr, arr + n, comp);
+        int jcount = 0, jprofit = 0;
+        int md = arr[0].dead;
+        for (int i = 1; i < n; ++i)
+        {
+            md = max(md, arr[i].dead);
+        }
+        int slot[md + 1];
+        memset(slot, -1, sizeof(slot));
+        for (int i = 0; i < n; ++i)
+        {
+            for (int j = arr[i].dead; j > 0; --j)
+            {
+                if (slot[j] == -1)
+                {
+                    slot[j] = i;
+                    jcount++;
+                    jprofit += arr[i].profit;
+                    break;
+                }
+            }
+        }
+        return {jcount, jprofit};
+    }
+};

GeeksForGeeks/LCS of three strings.cpp

@@ -0,0 +1,26 @@
+int LCSof3(string A, string B, string C, int n1, int n2, int n3)
+{
+    int dp[n1 + 1][n2 + 1][n3 + 1];
+    for (int i = 0; i <= n1; ++i)
+    {
+        for (int j = 0; j <= n2; ++j)
+        {
+            for (int k = 0; k <= n3; ++k)
+            {
+                if (i == 0 || j == 0 || k == 0)
+                {
+                    dp[i][j][k] = 0;
+                }
+                else if (A[i - 1] == B[j - 1] && A[i - 1] == C[k - 1])
+                {
+                    dp[i][j][k] = 1 + dp[i - 1][j - 1][k - 1];
+                }
+                else
+                {
+                    dp[i][j][k] = max({dp[i - 1][j][k], dp[i][j - 1][k], dp[i][j][k - 1]});
+                }
+            }
+        }
+    }
+    return dp[n1][n2][n3];
+}

GeeksForGeeks/Longest Increasing Subsequence.cpp

@@ -0,0 +1,37 @@
+class Solution
+{
+public:
+    // Function to find length of longest increasing subsequence.
+    int dp[100001];
+    int lis(int n, int *a, int &ans)
+    {
+        if (n == 1)
+        {
+            return dp[n] = 1;
+        }
+
+        if (dp[n] != -1)
+        {
+            return dp[n];
+        }
+        int res = 0, maxi = 1;
+        for (int i = 1; i < n; ++i)
+        {
+            res = lis(i, a, ans);
+            if (a[i - 1] < a[n - 1])
+            {
+                maxi = max(maxi, res + 1);
+            }
+        }
+        ans = max(ans, maxi);
+        return dp[n] = maxi;
+    }
+
+    int longestSubsequence(int n, int a[])
+    {
+        int ans = 1;
+        memset(dp, -1, sizeof(dp));
+        lis(n, a, ans);
+        return ans;
+    }
+};

GeeksForGeeks/Longest Palindromic Substring.cpp

@@ -0,0 +1,41 @@
+class Solution
+{
+public:
+    string longestPalindrome(string S)
+    {
+        string T = string(S.rbegin(), S.rend());
+        int maxi = 0;
+        string res;
+        int n = S.length();
+        int dp[n + 1][n + 1];
+        for (int i = 0; i <= n; ++i)
+        {
+            for (int j = 0; j <= n; ++j)
+            {
+                if (i == 0 || j == 0)
+                {
+                    dp[i][j] = 0;
+                }
+                else if (S[i - 1] == T[j - 1])
+                {
+                    dp[i][j] = 1 + dp[i - 1][j - 1];
+                    if (dp[i][j] > maxi)
+                    {
+                        string temp = S.substr(i - dp[i][j], dp[i][j]);
+                        string rev = string(temp.rbegin(), temp.rend());
+                        if (temp == rev)
+                        {
+                            res = temp;
+                            maxi = dp[i][j];
+                        }
+                    }
+                }
+                else
+                {
+                    dp[i][j] = 0;
+                }
+            }
+        }
+        return res;
+    }
+};

GeeksForGeeks/Longest subsequence-1 .cpp

@@ -0,0 +1,27 @@
+class Solution
+{
+public:
+    int longestSubsequence(int N, int A[])
+    {
+        int res = 0;
+
+        int dp[N] = {0};
+
+        for (int i = 0; i < N; i++)
+        {
+            dp[i] = 1;
+
+            for (int j = 0; j < i; j++)
+            {
+                if (abs(A[j] - A[i]) == 1)
+                {
+                    dp[i] = max(dp[i], dp[j] + 1);
+                }
+            }
+
+            res = max(res, dp[i]);
+        }
+
+        return res;
+    }
+};

GeeksForGeeks/Maximum path sum in matrix.cpp

@@ -0,0 +1,25 @@
+class Solution
+{
+public:
+    int maximumPath(int N, vector<vector<int>> mat)
+    {
+        int dp[N + 1][N + 1];
+        int ans = 0;
+        for (int i = 0; i <= N; ++i)
+        {
+            for (int j = 0; j <= N; ++j)
+            {
+                if (i == 0 || j == 0)
+                {
+                    dp[i][j] = 0;
+                }
+                else
+                {
+                    dp[i][j] = mat[i - 1][j - 1] + max({dp[i - 1][j - 1], dp[i - 1][j], dp[i - 1][j + 1]});
+                }
+                ans = max(dp[i][j], ans);
+            }
+        }
+        return ans;
+    }
+};

GeeksForGeeks/N meetings in one room.cpp

@@ -0,0 +1,31 @@
+class Solution
+{
+public:
+    // Function to find the maximum number of meetings that can
+    // be performed in a meeting room.
+    int maxMeetings(int start[], int end[], int n)
+    {
+        vector<pair<int, int>> vec;
+        for (int i = 0; i < n; ++i)
+        {
+            vec.push_back({start[i], end[i]});
+        }
+        sort(vec.begin(), vec.end(),
+             [](const pair<int, int> &a, const pair<int, int> &b)
+             {
+                 return a.second < b.second;
+             });
+
+        int ans = 1;
+        int prev = vec[0].second;
+        for (int i = 1; i < n; ++i)
+        {
+            if (vec[i].first > prev)
+            {
+                ans++;
+                prev = vec[i].second;
+            }
+        }
+        return ans;
+    }
+};