Practise 07-Jul-2020

Author: sureshmangs

competitive programming/leetcode/2020-June-Challenge/Day-06-Queue Reconstruction by Height.cpp

@@ -0,0 +1,40 @@
+Suppose you have a random list of people standing in a queue. Each person is described by a pair of integers (h, k), where h is the height of the person and k is the number of people in front of this person who have a height greater than or equal to h. Write an algorithm to reconstruct the queue.
+
+Note:
+The number of people is less than 1,100.
+
+
+Example
+
+Input:
+[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
+
+Output:
+[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]
+
+
+   Hide Hint #1
+What can you say about the position of the shortest person?
+If the position of the shortest person is i, how many people would be in front of the shortest person?
+   Hide Hint #2
+Once you fix the position of the shortest person, what can you say about the position of the second shortest person?
+
+
+
+
+
+class Solution {
+public:
+    static bool comp(vector<int> a, vector<int> b){
+        return (a[0] > b[0] || (a[0]==b[0] && a[1] < b[1]));
+    }
+    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
+
+        sort(people.begin(), people.end(), comp);
+        vector<vector<int> > result;
+        for(auto x: people)
+            result.insert(result.begin() + x[1], x);
+
+        return result;
+    }
+};

competitive programming/leetcode/406. Queue Reconstruction by Height.cpp

@@ -0,0 +1,31 @@
+Suppose you have a random list of people standing in a queue. Each person is described by a pair of integers (h, k), where h is the height of the person and k is the number of people in front of this person who have a height greater than or equal to h. Write an algorithm to reconstruct the queue.
+
+Note:
+The number of people is less than 1,100.
+
+
+Example
+
+Input:
+[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
+
+Output:
+[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]
+
+
+
+class Solution {
+public:
+    static bool comp(vector<int> a, vector<int> b){
+        return (a[0] > b[0] || (a[0]==b[0] && a[1] < b[1]));
+    }
+    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
+
+        sort(people.begin(), people.end(), comp);
+        vector<vector<int> > result;
+        for(auto x: people)
+            result.insert(result.begin() + x[1], x);
+
+        return result;
+    }
+};

competitive programming/leetcode/check_isvalid_bst.cpp

@@ -0,0 +1,33 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+struct node{
+    int data;
+    struct node* left;
+    struct node* right;
+};
+
+struct node* newNode(int value){
+    struct node* temp=(struct node*)malloc(sizeof(struct node));
+    temp->data=value;
+    temp->left=temp->right=NULL;
+    return temp;
+}
+
+bool isValidBST(node *root, long long mini, long long maxi){
+    if(!root) return true;
+    if(root->data<=mini || root->data>=maxi) return false;
+    return isValidBST(root->left, mini, root->data) && isValidBST(root->right, root->data, maxi);
+}
+int main(){
+
+    struct node* root=newNode(5);
+    root->left=newNode(1);
+    root->right=newNode(9);
+    root->right->left=newNode(6);
+    root->right->right=newNode(12);
+    if(isValidBST(root, (long long)INT_MIN-1, (long long)INT_MAX+1)) cout<<"VALID BST"<<endl;
+    else cout<<"INVALID BST"<<endl;
+
+    return 0;
+}

tree/range_sum_query_segment_tree.cpp

@@ -0,0 +1,120 @@
+#include<bits/stdc++.h>
+using namespace std;
+int max_size;
+
+
+// st, si, ss and se are same as getSumUtil()
+// i --> index of the element to be updated
+// diff --> Value to be added to all nodes which have i in range
+
+void updateValueUtil(int *st, int ss, int se, int i, int diff, int si){
+	// Base Case: If the input index lies outside the range of this segment
+	if (i < ss || i > se)
+		return;
+
+	// If the input index is in range of this node, then update the value of the node and its children
+	st[si] = st[si] + diff;
+	if (se != ss){
+		int mid = ss + (se - ss)/2;
+		updateValueUtil(st, ss, mid, i, diff, 2*si + 1);
+		updateValueUtil(st, mid+1, se, i, diff, 2*si + 2);
+	}
+}
+
+
+
+void updateValue(int arr[], int *st, int n, int i, int new_val){
+	// Check for erroneous input index
+	if (i < 0 || i > n-1){
+		cout<<"Invalid Input";
+		return;
+	}
+
+	// Get the difference between new value and old value
+	int diff = new_val - arr[i];
+
+	// Update the value in array
+	arr[i] = new_val;
+
+	// Update the values of nodes in segment tree
+	updateValueUtil(st, 0, n-1, i, diff, 0);
+}
+
+
+
+
+// st --> Pointer to segment tree
+// si --> Index of current node in the segment tree.
+// Initially 0 is passed as root is always at index 0
+// ss & se --> Starting and ending indexes of the segment represented by current node, i.e., st[si]
+// qs & qe --> Starting and ending indexes of query range
+
+int getSumUtil(int *st, int ss, int se, int qs, int qe, int si){
+	// If segment of this node is a part of given range, then return the sum of the segment ( Total Overlap )
+	if (qs <= ss && qe >= se)
+		return st[si];
+
+	// If segment of this node is outside the given range ( No Overlap )
+	if (qe < ss || qs > se)
+		return 0;
+
+	// If a part of this segment overlaps with the given range
+	int mid = ss + (se - ss)/2;
+
+	return getSumUtil(st, ss, mid, qs, qe, 2*si+1) + getSumUtil(st, mid+1, se, qs, qe, 2*si+2);
+}
+
+
+
+int getSum(int *st, int n, int qs, int qe){
+	// Check for erroneous input values
+	if (qs < 0 || qe > n-1 || qs > qe){
+		cout<<"Invalid Input";
+		return -1;
+	}
+	return getSumUtil(st, 0, n-1, qs, qe, 0);
+}
+
+
+
+int constructSTUtil(int arr[], int ss, int se, int *st, int si){ // arr[ss......se]
+
+    // If there is one element in array, store it in current node of segment tree and return
+    if (ss == se){
+		st[si] = arr[ss];
+		return arr[ss];
+	}
+
+	// If there are more than one elements, then recur for left and  right subtrees and store the sum of values in this node
+	int mid = ss + (se - ss)/2;
+
+	st[si] = constructSTUtil(arr, ss, mid, st, 2*si+1) + constructSTUtil(arr, mid+1, se, st, 2*si+2);
+
+	return st[si];
+}
+
+
+
+int *constructST(int arr[], int n){
+    int x = (int)(ceil(log2(n)));     // height of tree
+    max_size = 2*(int)pow(2, x) - 1;    // total number of nodes are 2n-1 but we also need space for dummy nodes
+    int *st = new int[max_size];
+    constructSTUtil(arr, 0, n-1, st, 0);
+    return st;
+}
+
+
+
+
+int main(){
+    int arr[] = {1, 3, 5, 7, 9, 11};
+	int n = sizeof(arr)/sizeof(arr[0]);
+
+	int *st = constructST(arr, n);
+
+	cout<<getSum(st, n, 1, 3)<<endl;  // 15
+	updateValue(arr, st, n, 1, 10);   //arr[1]=10
+	cout<<getSum(st, n, 1, 3)<<endl;  // 22
+
+    return 0;
+}