Practise 18-Jul-2020

sureshmangs · sureshmangs · commit 9a187853669e · 2020-06-19T10:52:51.000+05:30
diff --git a/array/connect_ropes_with_min_cost.cpp b/array/connect_ropes_with_min_cost.cpp
@@ -0,0 +1,76 @@
+/*
+There are given N ropes of different lengths, we need to connect these ropes into one rope. The cost to connect two ropes is equal to sum of their lengths. The task is to connect the ropes with minimum cost.
+
+Input:
+The first line of input contains an integer T denoting the number of test cases. The first line of each test case is N where N is the number of ropes. The second line of each test case contains N input L[i],length of ropes.
+
+Output:
+For each testcase, print the minimum cost to connect all the ropes.
+
+Constraints:
+1 ≤ T ≤ 100
+1 ≤ N ≤ 106
+1 ≤ L[i] ≤ 106
+
+Example:
+Input:
+2
+4
+4 3 2 6
+5
+4 2 7 6 9
+
+Output:
+29
+62
+
+Explanation:
+For example if we are given 4 ropes of lengths 4, 3, 2 and 6. We can connect the ropes in following ways.
+1) First connect ropes of lengths 2 and 3. Now we have three ropes of lengths 4, 6 and 5.
+2) Now connect ropes of lengths 4 and 5. Now we have two ropes of lengths 6 and 9.
+3) Finally connect the two ropes and all ropes have connected.
+
+Total cost for connecting all ropes is 5 + 9 + 15 = 29. This is the optimized cost for connecting ropes. Other ways of connecting ropes would always have same or more cost. For example, if we connect 4 and 6 first (we get three strings of 3, 2 and 10), then connect 10 and 3 (we get two strings of 13 and 2). Finally we connect 13 and 2. Total cost in this way is 10 + 13 + 15 = 38
+*/
+
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;
+        int a[n];
+        for(int i=0;i<n;i++) cin>>a[i];
+
+        priority_queue<int, vector<int>, greater<int> > minh; // min heap
+
+        for(int i=0;i<n;i++)
+            minh.push(a[i]);
+
+        long long cost=0;
+        while(minh.size()>=2){
+            int r1=minh.top();
+            minh.pop();
+            int r2=minh.top();
+            minh.pop();
+            cost+=r1+r2;
+            minh.push(r1+r2);
+        }
+
+        cout<<cost<<endl;
+    }
+
+return 0;
+}
diff --git a/array/k_closest_points_to_origin.cpp b/array/k_closest_points_to_origin.cpp
@@ -0,0 +1,73 @@
+/*
+Given a list of points on the 2-D plane and an integer K. The task is to find K closest points to the origin and print them.
+
+Note: The distance between two points on a plane is the Euclidean distance.
+
+Examples:
+
+Input : point = [[3, 3], [5, -1], [-2, 4]], K = 2
+Output : [[3, 3], [-2, 4]]
+Square of Distance of origin from this point is
+(3, 3) = 18
+(5, -1) = 26
+(-2, 4) = 20
+So rhe closest two points are [3, 3], [-2, 4].
+
+Input : point = [[1, 3], [-2, 2]], K  = 1
+Output : [[-2, 2]]
+Square of Distance of origin from this point is
+(1, 3) = 10
+(-2, 2) = 8
+So the closest point to origin is (-2, 2)
+*/
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+vector<vector<int>> kClosest(vector<vector<int>>& points, int k) {
+        int n=points.size();
+        priority_queue<pair<int, pair<int, int> > > maxh;   // max heap
+        for(int i=0;i<n;i++){
+            int x=points[i][0];
+            int y=points[i][1];
+            int dist=x*x+y*y;
+            maxh.push({dist, {x, y} });
+            if(maxh.size()>k) maxh.pop();
+        }
+        int i=0;
+        vector<vector<int> > res;
+        while(!maxh.empty()){
+            pair<int, int> p=maxh.top().second;
+            maxh.pop();
+            int x=p.first;
+            int y=p.second;
+            res.push_back({x, y});
+        }
+        return res;
+    }
+
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;
+        vector<vector<int> > points;
+        for(int i=0;i<n;i++){
+            int x,y;
+            cin>>x>>y;
+            points.push_back({x,y});
+        }
+        int k;
+        cin>>k;
+        vector<vector<int> > res;
+        res=kClosest(points, k);
+        for(int i=0; i<k;i++){
+            cout<<res[i][0]<<" "<<res[i][1]<<endl;
+        }
+    }
+}
diff --git a/array/sum_of_elements_between_k1_k2_th_smallest.cpp b/array/sum_of_elements_between_k1_k2_th_smallest.cpp
@@ -0,0 +1,91 @@
+//*
+Given an array of positive integers and two positive integers K1 and K2. Find sum of all elements greater tha K1th and smaller than K2th smallest elements of array.
+
+Input:
+The first line of input contains an integer T denoting the number of test cases. Then T test cases follow. Each test case contains an integer N, denoting the length of the array. Next line contains N space seperated integers of the array. Third line contains two space seperated integers denoting K1th and K2th smallest elements.
+
+Output:
+For each test case, output the sum of all the elements between K1th and K2th smallest elements.
+
+Constraints:
+1 <= T <= 100
+1 <= N <= 107
+1 <= K1, K2 <= 1014
+
+Example:
+Input
+2
+7
+20 8 22 4 12 10 14
+3 6
+6
+10 2 50 12 48 13
+2 6
+
+Output:
+26
+73
+
+Explanation:
+Test Case 1:
+3rd smallest element is 10
+6th smallest element is 20
+Sum of all element between K1 & K2 is 12 + 14 = 26
+*/
+
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+
+pair<long long, long long> getKthSmall(long long a[], long long n, long long k1, long long k2){
+    priority_queue<int> maxh;  // max heap
+    long long k=max(k1, k2);
+    for(long long i=0;i<n;i++){
+        maxh.push(a[i]);
+        if(maxh.size()>k) maxh.pop();
+    }
+    long long mink=min(k1, k2);
+    long long lg=maxh.top();   // large
+    while(maxh.size()>mink){
+        maxh.pop();
+    };
+    long long sm=maxh.top();   // small
+
+    pair<long long, long long> res;
+    res.first=sm;
+    res.second=lg;
+    return res;
+}
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        long long n, k1, k2;
+        cin>>n;
+        long long a[n];
+        for(long long i=0;i<n;i++) cin>>a[i];
+        cin>>k1>>k2;
+        pair<long long, long long > sk=getKthSmall(a, n, k1, k2);
+        long long sk1=sk.first;   // small
+        long long sk2=sk.second;  // large
+        long long sum=0;
+        for(long long i=0;i<n;i++){
+            if(a[i]>sk1 && a[i]<sk2){
+                sum+=a[i];
+            }
+        }
+        cout<<sum<<endl;
+    }
+
+return 0;
+}
diff --git a/competitive programming/leetcode/2020-June-Challenge/Day-18-H-Index II.cpp b/competitive programming/leetcode/2020-June-Challenge/Day-18-H-Index II.cpp
@@ -0,0 +1,44 @@
+Given an array of citations sorted in ascending order (each citation is a non-negative integer) of a researcher, write a function to compute the researcher's h-index.
+
+According to the definition of h-index on Wikipedia: "A scientist has index h if h of his/her N papers have at least h citations each, and the other N − h papers have no more than h citations each."
+
+Example:
+
+Input: citations = [0,1,3,5,6]
+Output: 3
+Explanation: [0,1,3,5,6] means the researcher has 5 papers in total and each of them had
+             received 0, 1, 3, 5, 6 citations respectively.
+             Since the researcher has 3 papers with at least 3 citations each and the remaining
+             two with no more than 3 citations each, her h-index is 3.
+Note:
+
+If there are several possible values for h, the maximum one is taken as the h-index.
+
+Follow up:
+
+This is a follow up problem to H-Index, where citations is now guaranteed to be sorted in ascending order.
+Could you solve it in logarithmic time complexity?
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    int hIndex(vector<int>& citations) {
+        int n=citations.size();
+        if(!n) return 0;
+        int si=0, ei=n-1, mid;
+        while(si<=ei){
+            mid=si+(ei-si)/2;
+            if(citations[mid]==n-mid) return citations[mid];
+            else if(citations[mid]>n-mid) ei=mid-1;
+            else si=mid+1;
+        }
+        return n-si;
+    }
+};
diff --git a/competitive programming/leetcode/275. H-Index II.cpp b/competitive programming/leetcode/275. H-Index II.cpp
@@ -0,0 +1,44 @@
+Given an array of citations sorted in ascending order (each citation is a non-negative integer) of a researcher, write a function to compute the researcher's h-index.
+
+According to the definition of h-index on Wikipedia: "A scientist has index h if h of his/her N papers have at least h citations each, and the other N − h papers have no more than h citations each."
+
+Example:
+
+Input: citations = [0,1,3,5,6]
+Output: 3
+Explanation: [0,1,3,5,6] means the researcher has 5 papers in total and each of them had
+             received 0, 1, 3, 5, 6 citations respectively.
+             Since the researcher has 3 papers with at least 3 citations each and the remaining
+             two with no more than 3 citations each, her h-index is 3.
+Note:
+
+If there are several possible values for h, the maximum one is taken as the h-index.
+
+Follow up:
+
+This is a follow up problem to H-Index, where citations is now guaranteed to be sorted in ascending order.
+Could you solve it in logarithmic time complexity?
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    int hIndex(vector<int>& citations) {
+        int n=citations.size();
+        if(!n) return 0;
+        int si=0, ei=n-1, mid;
+        while(si<=ei){
+            mid=si+(ei-si)/2;
+            if(citations[mid]==n-mid) return citations[mid];
+            else if(citations[mid]>n-mid) ei=mid-1;
+            else si=mid+1;
+        }
+        return n-si;
+    }
+};
diff --git a/competitive programming/leetcode/973. K Closest Points to Origin.cpp b/competitive programming/leetcode/973. K Closest Points to Origin.cpp
@@ -0,0 +1,61 @@
+We have a list of points on the plane.  Find the K closest points to the origin (0, 0).
+
+(Here, the distance between two points on a plane is the Euclidean distance.)
+
+You may return the answer in any order.  The answer is guaranteed to be unique (except for the order that it is in.)
+
+
+
+Example 1:
+
+Input: points = [[1,3],[-2,2]], K = 1
+Output: [[-2,2]]
+Explanation:
+The distance between (1, 3) and the origin is sqrt(10).
+The distance between (-2, 2) and the origin is sqrt(8).
+Since sqrt(8) < sqrt(10), (-2, 2) is closer to the origin.
+We only want the closest K = 1 points from the origin, so the answer is just [[-2,2]].
+Example 2:
+
+Input: points = [[3,3],[5,-1],[-2,4]], K = 2
+Output: [[3,3],[-2,4]]
+(The answer [[-2,4],[3,3]] would also be accepted.)
+
+
+Note:
+
+1 <= K <= points.length <= 10000
+-10000 < points[i][0] < 10000
+-10000 < points[i][1] < 10000
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<vector<int>> kClosest(vector<vector<int>>& points, int k) {
+        int n=points.size();
+        priority_queue<pair<int, pair<int, int> > > maxh;   // max heap
+        for(int i=0;i<n;i++){
+            int x=points[i][0];
+            int y=points[i][1];
+            int dist=x*x+y*y;
+            maxh.push({dist, {x, y} });
+            if(maxh.size()>k) maxh.pop();
+        }
+        int i=0;
+        vector<vector<int> > res;
+        while(!maxh.empty()){
+            pair<int, int> p=maxh.top().second;
+            maxh.pop();
+            int x=p.first;
+            int y=p.second;
+            res.push_back({x, y});
+        }
+        return res;
+    }
+};
