Max_points_on_line/

120.Triangle.cpp

@@ -0,0 +1,89 @@
+
+
+
+
+//1. Recursion
+
+
+ // Recursion *** Will Give TLE ***
+
+
+	int solve(int i, int j, int n, vector<vector<int>>&triangle) {
+		if(i == n - 1)
+			return triangle[i][j];
+		int bottom = triangle[i][j] + solve(i+1, j, n, triangle);
+		int  bottom_right = triangle[i][j] + solve(i+1, j+1, n, triangle);
+		return min(bottom, bottom_right);
+	}
+	int minimumTotal(vector<vector<int>>& triangle) {
+		int n = triangle.size();
+		return solve(0, 0, n, triangle);
+	}
+
+
+//2. Memoization
+
+
+ // Memoization
+	int solve(int i, int j, int n, vector<vector<int>>&triangle, vector<vector<int>>&dp) {
+		if(i == n - 1)
+			return triangle[i][j];
+		if(dp[i][j] != -1)
+			return dp[i][j];
+		int bottom = triangle[i][j] + solve(i+1, j, n, triangle, dp);
+		int  bottom_right = triangle[i][j] + solve(i+1, j+1, n, triangle, dp);
+		return dp[i][j] = min(bottom, bottom_right);
+	}
+	int minimumTotal(vector<vector<int>>& triangle) {
+		int n = triangle.size();
+		vector<vector<int>>dp(n, vector<int>(n, -1));
+		return solve(0, 0, n, triangle, dp);
+
+    }
+
+
+// 3. Tabulation
+
+ // Tabulation
+	int minimumTotal(vector<vector<int>>& triangle) {
+		int n = triangle.size();
+		vector<vector<int>>dp(n, vector<int>(n, -1));
+		for(int i = 0; i < n; i++) 
+			dp[n-1][i] = triangle[n-1][i];
+		for(int i = n-2; i >= 0; i--) {
+			for(int j = i; j >= 0; j--) {
+				int up = triangle[i][j] + dp[i+1][j];
+				int up_left = triangle[i][j] + dp[i+1][j+1];
+				dp[i][j] = min(up, up_left);
+			}
+		}
+		return dp[0][0];
+	}
+
+
+//4. Space Optimal
+
+// Space Optimization
+	int minimumTotal(vector<vector<int>>& triangle) {
+		int n = triangle.size();
+		vector<int>next(n);
+		for(int i = n-1; i >= 0; i--) {
+			vector<int>curr(n);
+			for(int j = i; j >= 0; j--) {
+				if(i == n-1)
+					curr[j] = triangle[i][j];
+				else {
+					int up = triangle[i][j] + next[j];
+					int up_left = triangle[i][j] + next[j+1];
+					curr[j] = min(up, up_left);
+				}
+			}
+			next = curr;
+		}
+		return next[0];
+	}
+
+
+
+
+

140.-Word-Break-II.java

@@ -0,0 +1,29 @@
+public class Solution {
+    HashMap<Integer, List<String>> dp = new HashMap<>();
+
+    public List<String> wordBreak(String s, Set<String> wordDict) {
+        int maxLength = -1;
+        for(String ss : wordDict) maxLength = Math.max(maxLength, ss.length());
+        return addSpaces(s, wordDict, 0, maxLength);
+    }
+
+    private List<String> addSpaces(String s, Set<String> wordDict, int start, int max){
+        List<String> words = new ArrayList<>();
+        if(start == s.length()) {
+            words.add("");
+            return words;
+        }
+        for(int i = start + 1; i <= max + start && i <= s.length(); i++){
+            String temp = s.substring(start, i);
+            if(wordDict.contains(temp)){
+                List<String> ll;
+                if(dp.containsKey(i)) ll = dp.get(i);
+                else ll = addSpaces(s, wordDict, i, max);
+                for(String ss : ll) words.add(temp + (ss.equals("") ? "" : " ") + ss);
+            }
+
+        }
+        dp.put(start, words);
+        return words;
+    }
+}

140_Word_Break_II.cpp

@@ -0,0 +1,31 @@
+class Solution {
+public:
+
+    void f(int i, int j, string s, vector<string>&wordDict, int n, vector<string>&ans, map<string, bool>&m, string &temp) {
+
+        if(i>=n && j>=n) {
+            ans.push_back(temp);
+            return;
+        }
+        if(j>=n) return;
+        string str = s.substr(i, j-i+1);
+        if(m.find(str)!=m.end()) {
+            string st = temp;
+            temp+=str;
+            if(j!=n-1) temp+=" ";
+            f(j+1, j+1, s, wordDict, n, ans, m, temp);
+            temp = st;
+        }
+        f(i, j+1, s, wordDict, n, ans, m, temp);
+    }
+
+    vector<string> wordBreak(string s, vector<string>& wordDict) {
+        int n = s.size();
+        map <string, bool> m;
+        for(int i=0; i<wordDict.size(); i++) m[wordDict[i]]=1;
+        vector<string> ans;
+        string temp="";
+        f(0, 0, s, wordDict, n, ans, m, temp);
+        return ans;
+    }
+};

146_LRU_Cache.cpp

@@ -0,0 +1,69 @@
+class LRUCache {
+public:
+    class node{
+        public:
+        int k;
+        int v;
+        node *prev;
+        node *next;
+        node(int kk,int vv){
+            k=kk;
+            v=vv;
+        }
+    };
+
+    node* head=new node(-1,-1);
+    node* tail=new node(-1,-1);
+
+
+    int cap;
+    unordered_map<int,node*> m;
+
+    LRUCache(int capacity) {
+        cap=capacity;
+        head->next=tail;
+        tail->prev=head;
+    }
+
+    void insertNode(node* newNode){
+        node* temp=head->next;
+        newNode->next=temp;
+        newNode->prev=head;
+        head->next=newNode;
+        temp->prev=newNode;
+    }
+
+    void deleteNode(node* delNode){
+        node* delPrev=delNode->prev;
+        node* delNext=delNode->next;
+        delPrev->next=delNext;
+        delNext->prev=delPrev;
+    }
+
+    int get(int key) {
+        if(m.find(key)!=m.end()){
+            node* resNode=m[key];
+            int res=resNode->v;
+            m.erase(key);
+            deleteNode(resNode);
+            insertNode(resNode);
+            m[key]=head->next;
+            return res;
+        }
+        return -1;
+    }
+
+    void put(int key, int value) {
+        if(m.find(key)!=m.end()){
+            node* exitingNode = m[key];
+            m.erase(key);
+            deleteNode(exitingNode);
+        }
+        if(m.size() == cap){
+            m.erase(tail->prev->k);
+            deleteNode(tail-> prev);
+        }
+        insertNode(new node(key,value));
+        m[key]=head->next;
+    }
+};

1695.Maximum_Erasure_Value.cpp

@@ -0,0 +1,27 @@
+class Solution {
+public:
+    int maximumUniqueSubarray(vector<int>& nums) {
+        int curr_sum=0, res=0;
+
+		//set to store the elements
+        unordered_set<int> st;
+
+        int i=0,j=0;
+        while(j<nums.size()) {
+            while(st.count(nums[j])>0) {
+				//Removing the ith element untill we reach the repeating element
+                st.erase(nums[i]);
+                curr_sum-=nums[i];
+                i++;
+            }
+			//Add the current element to set and curr_sum value
+            curr_sum+=nums[j];
+            st.insert(nums[j++]);
+
+			//res variable to keep track of largest curr_sum encountered till now...
+            res = max(res, curr_sum);
+        }
+
+        return res;
+    }
+};

33. Search in Rotated Sorted Array.py

@@ -0,0 +1,19 @@
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        l,r = 0,len(nums)-1
+        while(l<=r):
+            mid = (l+r)//2
+            if target == nums[mid]:
+                return mid
+
+            if nums[l]<=nums[mid]:
+                if target > nums[mid] or target < nums[l]:
+                    l = mid + 1
+                else:
+                    r = mid - 1
+            else:
+                if target < nums[mid] or target > nums[r]:
+                    r = mid - 1
+                else:
+                    l = mid + 1
+        return -1

Combination Sum II/combination_sum_II.c

@@ -0,0 +1,66 @@
+/* Sorts the array in ascending order */
+int sortFunc(const void* a, const void* b) {
+    return *((int*)a) - *((int*)b);
+}
+
+void helper(int* candidates, int candidatesSize, int target, int index, int* current, int currentLength, int* returnSize, int** returnColumnSizes, int*** answer) {
+    /* Track the previous candidate to avoid duplicate solutions*/
+    int prevCan = 0;
+
+    /* Loop through all possible candidates to add to the solution */
+    for (int i = index; i < candidatesSize; i++) {
+
+        /* If the candidate matches the target, add to the answer */
+        if (candidates[i] == target) {
+            (*returnSize)++;
+
+            /* Allocate memory for new answer */
+            *answer = (int**)realloc(*answer, (*returnSize) * sizeof(int*));
+            (*answer)[(*returnSize) - 1] = (int*)malloc((currentLength+1) * sizeof(int));
+
+            /* Copy data into new answer */
+            memcpy((*answer)[(*returnSize) - 1], current, currentLength * sizeof(int));
+            (*answer)[(*returnSize) - 1][currentLength] = candidates[i];
+
+            /* Update the returnColumnSizes array */
+            (*returnColumnSizes) = (int*)realloc((*returnColumnSizes), (*returnSize) * sizeof(int));
+            (*returnColumnSizes)[(*returnSize) - 1] = currentLength + 1;
+
+            /* Break to avoid duplicate answers */
+            /* Since the candidates are sorted, any next candidates will be too large */
+            break;
+        }
+
+        /* If the candidate could possibly work, add it to the current answer and recursively call the helper */
+        else if (candidates[i] <= (target / 2) && candidates[i] != prevCan) {
+            current[currentLength] = candidates[i];
+            helper(candidates, candidatesSize, target - candidates[i], i + 1, current, currentLength + 1, returnSize, returnColumnSizes, answer);
+            prevCan = candidates[i];
+        }
+
+        /* Since the list is sorted, break once the candidate is too large */
+        else if (candidates[i] > target) break;
+    }
+}
+
+int** combinationSum2(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes){
+
+    /* Sort the candidates to group duplicates together */
+    qsort(candidates, candidatesSize, sizeof(int), sortFunc);
+
+    /* Array to store the current solution */
+    int* current = (int*)malloc(100*sizeof(int));
+    int currentLength = 0;
+
+    /* Allocate initial memory to answer and returnColumnSizes */
+    int** answer = (int**)malloc(sizeof(int*));
+    (*returnColumnSizes) = (int*)malloc(sizeof(int));
+
+    (*returnSize) = 0;
+
+    /* Call the helper with our initial conditions */
+    helper(candidates, candidatesSize, target, 0, current, currentLength, returnSize, returnColumnSizes, &answer);
+
+    free(current);
+    return answer;
+}

Delete-Operation-for-Two-Strings/CPP Solution.cpp

@@ -0,0 +1,33 @@
+#include<bits/stdc++.h>
+
+using namespace std;
+
+class Solution {
+public:
+    int minDistance(string word1, string word2) {
+        // Bottom up approach
+        int m, n;
+        m = word1.length();
+        n = word2.length();
+        int dp[m + 1][n + 1];
+
+        for (int i = 0; i <= m; i++) {
+            for (int j = 0; j <= n; j++) {
+                // we have to add all the remaining char in word2
+                if (i == 0)
+                    dp[i][j] = j; 
+                // We have to delete all the remaining characters from word 1
+                else if (j == 0)
+                    dp[i][j] = i; 
+                // If in the memo dict return the val
+                else if (word1[i - 1] == word2[j - 1])
+                    dp[i][j] = dp[i - 1][j - 1];
+
+                else
+                    dp[i][j] = 1 + min(dp[i][j - 1], dp[i - 1][j]);
+            }
+        }
+
+        return dp[m][n];
+    }
+};

Delete-Operation-for-Two-Strings/Delete-Operation-for-Two-Strings Delete-Operation-for-Two-Strings.py

@@ -0,0 +1,19 @@
+class Solution:
+  def minDistance(self, word1: str, word2: str) -> int:
+    m = len(word1)
+    n = len(word2)
+    dp = [0] * (n + 1)
+
+    for j in range(n + 1):
+      dp[j] = j
+
+    for i in range(1, m + 1):
+      newDp = [i] + [0] * n
+      for j in range(1, n + 1):
+        if word1[i - 1] == word2[j - 1]:
+          newDp[j] = dp[j - 1]
+        else:
+          newDp[j] = min(newDp[j - 1], dp[j]) + 1
+      dp = newDp
+
+    return dp[n]