Merge pull request #16 from Rishabh0210/Rishabh0210-patch-1

Rishabh0210 patch 1

Author: Rishabh0210

JuneLeetCodingChallenge2020/Coin_Change_2.cpp

@@ -0,0 +1,25 @@
+//https://leetcode.com/explore/challenge/card/june-leetcoding-challenge/539/week-1-june-1st-june-7th/3353/
+
+
+
+class Solution {
+public:
+    int change(int amount, vector<int>& coins) {
+        vector<vector<int>> DP(amount + 1, vector<int>(coins.size() + 1, 0));
+        sort(coins.begin(), coins.end());
+        
+        
+        int i, j;
+        for(i = 0; i <= coins.size(); i++)
+            DP[0][i] = 1;
+        
+        for(i = 1; i <= amount; i++) {
+            for(j = 1; j <= coins.size(); j++) {
+                if(i >= coins[j - 1])
+                    DP[i][j] = DP[i - coins[j - 1]][j];
+                DP[i][j] += DP[i][j - 1];
+            }
+        }
+        return DP[amount][coins.size()];
+    }
+};

JuneLeetCodingChallenge2020/Delete_Node_in_a_Linked_List.cpp

@@ -0,0 +1,23 @@
+//https://leetcode.com/explore/challenge/card/june-leetcoding-challenge/539/week-1-june-1st-june-7th/3348/
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    void deleteNode(ListNode* node) {
+        ListNode* prev = node;
+        while(node -> next != NULL) {
+            node -> val = node -> next -> val;
+            prev = node;
+            node = node -> next;
+        }
+        prev -> next = NULL;
+        // free(node);
+    }
+};

JuneLeetCodingChallenge2020/Invert_Binary_Tree.cpp

@@ -0,0 +1,39 @@
+//https://leetcode.com/explore/challenge/card/june-leetcoding-challenge/539/week-1-june-1st-june-7th/3347/
+
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* invertTree(TreeNode* root) {
+        queue<TreeNode*> q;
+        q.push(root);
+        
+        while(!q.empty()) {
+            TreeNode* node = q.front();
+            q.pop();
+            
+            if(node == NULL)
+                continue;
+            
+            TreeNode* left = node -> left;
+            TreeNode* right = node -> right;
+            
+            node -> right = left;
+            node -> left = right;
+            
+            q.push(left);
+            q.push(right);
+        }
+        return root;
+    }
+};

JuneLeetCodingChallenge2020/Is_Subsequence.cpp

@@ -0,0 +1,16 @@
+//https://leetcode.com/explore/challenge/card/june-leetcoding-challenge/540/week-2-june-8th-june-14th/3355/
+
+class Solution {
+public:
+    bool isSubsequence(string s, string t) {
+        int l1 = s.size();
+        int l2 = t.size();
+        int i = 0, j = 0;
+        while(i < l2 && j < l1) {
+            if(t[i] == s[j])
+                j++;
+            i++;
+        }
+        return j == l1;
+    }
+};

JuneLeetCodingChallenge2020/QueueReconstructionByHeightSolution.cpp

@@ -0,0 +1,30 @@
+//https://leetcode.com/explore/challenge/card/june-leetcoding-challenge/539/week-1-june-1st-june-7th/3352/
+
+class Solution {
+private: 
+    static bool compare(vector<int> v1, vector<int> v2) {
+        return v1[0] < v2[0];
+    }
+public:
+    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
+        sort(people.begin(), people.end(), compare);
+        int n = people.size();
+        vector<vector<int>> ans(n, vector<int>(2, INT_MAX));
+        
+        int i;
+        for(i = 0; i < n; i++) {
+            int person_in_front = people[i][1];
+            int j = 0;
+            for(j = 0; j < n; j++) {
+                if(ans[j][0] == INT_MAX && person_in_front == 0)
+                    break;
+                else if(ans[j][0] == INT_MAX || ans[j][0] == people[i][0])
+                    person_in_front--;
+            }
+            ans[j][0] = people[i][0];
+            ans[j][1] = people[i][1];
+        }
+        
+        return ans;
+    }
+};

JuneLeetCodingChallenge2020/Random_Pick_with_weight.cpp

@@ -0,0 +1,39 @@
+//https://leetcode.com/explore/challenge/card/june-leetcoding-challenge/539/week-1-june-1st-june-7th/3351/
+
+class Solution {
+public:
+    vector<int> cumWeight;
+    Solution(vector<int>& w) {
+        int sum = 0;
+        for(int i = 0; i < w.size(); i++) {
+            sum += w[i];
+            cumWeight.push_back(sum);
+        }
+    }
+    
+    int pickIndex() {
+        int upper_limit = cumWeight[cumWeight.size() - 1];
+        int target = rand() % upper_limit;
+        int mid, ans, high, low;
+        high = cumWeight.size() - 1;
+        low = 0;
+        ans = -1;
+        
+        while(low <= high) {
+            mid = (low + (high - low)/2);
+            if(target < cumWeight[mid]) {
+                ans = mid;
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+        return ans;
+    }
+};
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * Solution* obj = new Solution(w);
+ * int param_1 = obj->pickIndex();
+ */

JuneLeetCodingChallenge2020/Reverse_String.cpp

@@ -0,0 +1,19 @@
+//https://leetcode.com/explore/challenge/card/june-leetcoding-challenge/539/week-1-june-1st-june-7th/3350/
+
+class Solution {
+public:
+    void reverseString(vector<char>& s) {
+        int i, j;
+        i = 0;
+        j = s.size() - 1;
+        
+        while(i < j) {
+            char temp = s[i];
+            s[i] = s[j];
+            s[j] = temp;
+            
+            i++;
+            j--;
+        }
+    }
+};

JuneLeetCodingChallenge2020/Search_Insert_Position.cpp

@@ -0,0 +1,18 @@
+//https://leetcode.com/explore/challenge/card/june-leetcoding-challenge/540/week-2-june-8th-june-14th/3356/
+
+class Solution {
+public:
+    int searchInsert(vector<int>& nums, int target) {
+        int l = 0, h = nums.size() - 1;
+        while(l <= h) {
+            int mid = l + (h - l)/2;
+            if(nums[mid] == target)
+                return mid;
+            else if(nums[mid] < target)
+                l = mid + 1;
+            else
+                h = mid - 1;
+        }
+        return l;
+    }
+};

JuneLeetCodingChallenge2020/Two_City_Scheduling.cpp

@@ -0,0 +1,48 @@
+//https://leetcode.com/explore/challenge/card/june-leetcoding-challenge/539/week-1-june-1st-june-7th/3349/
+
+class Solution {
+private:
+    static bool compare(pair<pair<int, int>, int> p1, pair<pair<int, int>, int> p2) {
+        return p1.second > p2.second;
+    }
+public:
+    int twoCitySchedCost(vector<vector<int>>& costs) {
+        vector<pair<pair<int, int>, int>> weight;
+        
+        int i, n = costs.size();
+        
+        for(i = 0; i < n; i++) {
+            pair<int, int> p1 = make_pair(costs[i][0], costs[i][1]);
+            
+            int diff = abs(costs[i][0] - costs[i][1]);
+            
+            pair<pair<int, int>, int> p2 = make_pair(p1, diff);
+            weight.push_back(p2);
+        }
+        
+        sort(weight.begin(), weight.end(), compare);
+        
+        int A = n/2, B = n/2;
+        int ans = 0;
+        for(i = 0; i < n; i++) {
+            pair<int, int> p = weight[i].first;
+            
+            if(A > 0 && B > 0) {
+                if(p.first < p.second) {
+                    A--;
+                    ans += p.first;
+                } else {
+                    B--;
+                    ans += p.second;
+                }
+            } else if (A > 0) {
+                A--;
+                ans += p.first;
+            } else {
+                B--;
+                ans += p.second;
+            }
+        }
+        return ans;
+    }
+};