🚀 13-Oct-2020

sureshmangs · sureshmangs · commit 4801355e8d14 · 2020-10-13T22:47:55.000+05:30
diff --git a/competitive programming/leetcode/148. Sort List.cpp b/competitive programming/leetcode/148. Sort List.cpp
@@ -0,0 +1,85 @@
+Given the head of a linked list, return the list after sorting it in ascending order.
+
+Follow up: Can you sort the linked list in O(n logn) time and O(1) memory (i.e. constant space)?
+
+
+
+Example 1:
+
+
+Input: head = [4,2,1,3]
+Output: [1,2,3,4]
+Example 2:
+
+
+Input: head = [-1,5,3,4,0]
+Output: [-1,0,3,4,5]
+Example 3:
+
+Input: head = []
+Output: []
+
+
+Constraints:
+
+The number of nodes in the list is in the range [0, 5 * 104].
+-105 <= Node.val <= 105
+
+
+
+
+
+
+
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+
+    ListNode* merge(ListNode* a, ListNode* b){
+        if(!a) return b;
+        if(!b) return a;
+
+        ListNode *result=NULL;
+
+        if(a->val <= b->val){
+            result=a;
+            result->next=merge(a->next, b);
+        } else {
+            result=b;
+            result->next=merge(a, b->next);
+        }
+
+        return result;
+    }
+
+    ListNode* getMiddle(ListNode* head){
+        ListNode *slow=head, *fast=head, *prev=NULL;
+        while(fast!=NULL && fast->next!=NULL){
+            prev=slow;
+            slow=slow->next;
+            fast=fast->next->next;
+        }
+        if(prev) prev->next=NULL;
+        return slow;
+    }
+
+    ListNode* sortList(ListNode* head) {
+        if(head==NULL || head->next==NULL) return head;
+
+        ListNode* mid=getMiddle(head);
+        ListNode* left=sortList(head);
+        ListNode* right=sortList(mid);
+
+        return merge(left, right);
+    }
+};
diff --git a/competitive programming/leetcode/1614. Maximum Nesting Depth of the Parentheses.cpp b/competitive programming/leetcode/1614. Maximum Nesting Depth of the Parentheses.cpp
@@ -0,0 +1,57 @@
+A string is a valid parentheses string (denoted VPS) if it meets one of the following:
+
+It is an empty string "", or a single character not equal to "(" or ")",
+It can be written as AB (A concatenated with B), where A and B are VPS's, or
+It can be written as (A), where A is a VPS.
+We can similarly define the nesting depth depth(S) of any VPS S as follows:
+
+depth("") = 0
+depth(A + B) = max(depth(A), depth(B)), where A and B are VPS's
+depth("(" + A + ")") = 1 + depth(A), where A is a VPS.
+For example, "", "()()", and "()(()())" are VPS's (with nesting depths 0, 1, and 2), and ")(" and "(()" are not VPS's.
+
+Given a VPS represented as string s, return the nesting depth of s.
+
+
+
+Example 1:
+
+Input: s = "(1+(2*3)+((8)/4))+1"
+Output: 3
+Explanation: Digit 8 is inside of 3 nested parentheses in the string.
+Example 2:
+
+Input: s = "(1)+((2))+(((3)))"
+Output: 3
+Example 3:
+
+Input: s = "1+(2*3)/(2-1)"
+Output: 1
+Example 4:
+
+Input: s = "1"
+Output: 0
+
+
+Constraints:
+
+1 <= s.length <= 100
+s consists of digits 0-9 and characters '+', '-', '*', '/', '(', and ')'.
+It is guaranteed that parentheses expression s is a VPS.
+
+
+
+
+class Solution {
+public:
+    int maxDepth(string s) {
+        int open=0;
+        int maxi=0;
+        for(auto &ch:s){
+            if(ch=='(') open++;
+            else if(ch==')') open--;
+            if(open>maxi) maxi=open;
+        }
+        return maxi;
+    }
+};
diff --git a/competitive programming/leetcode/1615. Maximal Network Rank.cpp b/competitive programming/leetcode/1615. Maximal Network Rank.cpp
@@ -0,0 +1,79 @@
+There is an infrastructure of n cities with some number of roads connecting these cities. Each roads[i] = [ai, bi] indicates that there is a bidirectional road between cities ai and bi.
+
+The network rank of two different cities is defined as the total number of directly connected roads to either city. If a road is directly connected to both cities, it is only counted once.
+
+The maximal network rank of the infrastructure is the maximum network rank of all pairs of different cities.
+
+Given the integer n and the array roads, return the maximal network rank of the entire infrastructure.
+
+
+
+Example 1:
+
+
+
+Input: n = 4, roads = [[0,1],[0,3],[1,2],[1,3]]
+Output: 4
+Explanation: The network rank of cities 0 and 1 is 4 as there are 4 roads that are connected to either 0 or 1. The road between 0 and 1 is only counted once.
+Example 2:
+
+
+
+Input: n = 5, roads = [[0,1],[0,3],[1,2],[1,3],[2,3],[2,4]]
+Output: 5
+Explanation: There are 5 roads that are connected to cities 1 or 2.
+Example 3:
+
+Input: n = 8, roads = [[0,1],[1,2],[2,3],[2,4],[5,6],[5,7]]
+Output: 5
+Explanation: The network rank of 2 and 5 is 5. Notice that all the cities do not have to be connected.
+
+
+Constraints:
+
+2 <= n <= 100
+0 <= roads.length <= n * (n - 1) / 2
+roads[i].length == 2
+0 <= ai, bi <= n-1
+ai != bi
+Each pair of cities has at most one road connecting them.
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    int maximalNetworkRank(int n, vector<vector<int>>& roads) {
+        vector<vector<bool> > grid(n, vector<bool> (n, false));
+        for(auto &it: roads){
+            grid[it[0]][it[1]]=true;
+            grid[it[1]][it[0]]=true;
+        }
+
+        vector<int> edges(n, 0);
+
+        for(int i=0;i<n;i++){
+            for(int j=0;j<n;j++){
+                if(grid[i][j]==1)
+                    edges[i]++;
+            }
+        }
+
+        int maxi=0;
+
+
+        for(int i=0;i<n;i++){
+            for(int j=i+1;j<n;j++){
+                if(grid[i][j]==1)
+                    maxi=max(maxi, edges[i]+edges[j]-1);
+                else maxi=max(maxi, edges[i]+edges[j]);
+            }
+        }
+
+        return maxi;
+    }
+};
diff --git a/competitive programming/leetcode/2020-October-Challenge/Day-13-Sort List.cpp b/competitive programming/leetcode/2020-October-Challenge/Day-13-Sort List.cpp
@@ -0,0 +1,85 @@
+Given the head of a linked list, return the list after sorting it in ascending order.
+
+Follow up: Can you sort the linked list in O(n logn) time and O(1) memory (i.e. constant space)?
+
+
+
+Example 1:
+
+
+Input: head = [4,2,1,3]
+Output: [1,2,3,4]
+Example 2:
+
+
+Input: head = [-1,5,3,4,0]
+Output: [-1,0,3,4,5]
+Example 3:
+
+Input: head = []
+Output: []
+
+
+Constraints:
+
+The number of nodes in the list is in the range [0, 5 * 104].
+-105 <= Node.val <= 105
+
+
+
+
+
+
+
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+
+    ListNode* merge(ListNode* a, ListNode* b){
+        if(!a) return b;
+        if(!b) return a;
+
+        ListNode *result=NULL;
+
+        if(a->val <= b->val){
+            result=a;
+            result->next=merge(a->next, b);
+        } else {
+            result=b;
+            result->next=merge(a, b->next);
+        }
+
+        return result;
+    }
+
+    ListNode* getMiddle(ListNode* head){
+        ListNode *slow=head, *fast=head, *prev=NULL;
+        while(fast!=NULL && fast->next!=NULL){
+            prev=slow;
+            slow=slow->next;
+            fast=fast->next->next;
+        }
+        if(prev) prev->next=NULL;
+        return slow;
+    }
+
+    ListNode* sortList(ListNode* head) {
+        if(head==NULL || head->next==NULL) return head;
+
+        ListNode* mid=getMiddle(head);
+        ListNode* left=sortList(head);
+        ListNode* right=sortList(mid);
+
+        return merge(left, right);
+    }
+};
