1851

Author: mkmark

leetcode/1851/1.in

@@ -0,0 +1,2 @@
+[[1,4],[2,4],[3,6],[4,4]]
+[2,3,4,5]

leetcode/1851/2.in

@@ -0,0 +1,2 @@
+[[2,3],[2,5],[1,8],[20,25]]
+[2,19,5,22]

leetcode/1851/34.in

@@ -0,0 +1,2 @@
+[[63,93],[65,86],[7,39],[55,59],[2,45],[97,98],[51,73],[21,46],[100,100],[53,71],[31,33],[95,95],[33,67],[29,77],[49,57],[69,79],[93,93],[6,72],[93,99],[1,3],[49,87],[53,92],[41,99],[86,99],[3,41],[45,73],[55,85],[72,82],[56,70],[50,51],[31,57],[73,78],[6,46],[67,67],[84,85],[1,77],[41,41],[23,41],[43,73],[29,48],[73,91],[41,61],[74,74],[68,74],[17,88],[13,63],[31,80],[25,65],[26,32],[78,78],[9,37],[45,45],[73,98],[41,59],[24,92],[1,11],[47,69],[80,80],[97,99],[10,83],[53,59],[27,91],[80,98],[59,95],[40,50],[33,41],[61,81],[18,42],[49,77],[41,41],[53,87],[83,95],[23,56],[67,95],[65,79],[3,49],[27,61],[71,71],[50,70],[53,83],[21,87],[77,77],[1,91],[12,37],[1,50],[12,16],[39,76],[85,93],[5,70],[9,84],[65,75],[81,93],[61,93],[61,81],[51,73],[1,61],[45,69],[13,61],[41,41],[37,37]]
+[96,37,17,75,29,19,41,25,62,87,25,73,45,11,32,61,17,30,59,33,45,21,73,96,31,45,97,1,73,41,19,61,25,54,83,1,96,35,77,39,57,1,61,37,86,7,77,97,11,74,93,55,29,21,63,21,41,55,87,61,86,8,51,1,27,49,61,53,49,61,81,77,21,1,43,48,76,11,51,41,84,65,51,91,84,67,2,93,61,59,93,11,5,51,34,99,61,18,58,99]

leetcode/1851/34x.in

@@ -0,0 +1,39 @@
+/*
+author: [email protected]
+*/
+
+#include <bits/stdc++.h>
+#include "../../lib/LeetCodeInput.hpp"
+#include "solution-4.cpp"
+using namespace std;
+
+int main()
+{
+    LeetCodeInput li("2.in");
+
+    vector<vector<int>> mat_1 = li.get_vvi(0);
+    vector<int> arr_1 = li.get_vi(1);
+    // int num_1 = li.get_i(0);
+    // string s_1 = li.get_s(0);
+
+    chrono::steady_clock::time_point begin = chrono::steady_clock::now();
+    Solution solution;
+    auto output = solution.minInterval(mat_1, arr_1);
+    chrono::steady_clock::time_point end = chrono::steady_clock::now();
+    cout << "Time difference = " << chrono::duration_cast<chrono::microseconds> (end - begin).count() << "µs" << endl;
+
+    // cout << output << endl;
+
+    for (int i: output){
+        cout << i << ' ';
+    }
+
+    // for (auto i: output){
+    //     for (int j: i){
+    //         cout << j << ' ';
+    //     }
+    //     cout << '\n';
+    // }
+
+    return 0;
+}

leetcode/1851/40.in

@@ -0,0 +1,76 @@
+/*
+author: [email protected]
+time: O()
+space: O()
+
+Runtime: 
+Memory Usage: 
+*/
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define all(x) begin(x), end(x)
+typedef vector<int> vi;
+typedef vector<vector<int>> vvi;
+
+class Solution {
+public:
+    vector<int> minInterval(vector<vector<int>>& itvs, vector<int>& qris) {
+        int n = size(qris);
+        int m = size(itvs);
+
+        int idx_qry[n];
+        iota(idx_qry, idx_qry+n, 0);
+        sort(idx_qry, idx_qry+n, [&qris](int & i, int & j){return qris[i] < qris[j];});
+
+        sort(all(itvs));
+
+        /// sorted by r-l+1, distinguished by additional nonduplicate index
+        set<long long> s;
+        /// track the iterator of element in s with least r
+        /// sorted by r, distinguished by additional nonduplicate index
+        map<long long, set<long long>::iterator> it_s;
+
+        vi res(n);
+        
+        int idx;
+        int num;
+        int cur_idx_itv = 0;
+        vi * cur_itv = &itvs[cur_idx_itv];
+        int l = (*cur_itv)[0];
+        long long r = (*cur_itv)[1];
+        for (int i=0; i<n; ++i){
+            idx = idx_qry[i];
+            num = qris[idx];
+            while (!it_s.empty() && ((*it_s.begin()).first>>32) < num){
+                s.erase((*it_s.begin()).second);
+                it_s.erase(it_s.begin());
+            }
+            while (l <= num){
+                if (r >= num){
+                    it_s.insert({(r<<32) + cur_idx_itv, s.insert(((r - l + 1)<<32) + cur_idx_itv).first});
+                }
+                ++cur_idx_itv;
+                if (cur_idx_itv >= m) break;
+                cur_itv = &itvs[cur_idx_itv];
+                l = (*cur_itv)[0];
+                r = (*cur_itv)[1];
+            }
+            if (s.empty()){
+                res[idx] = -1;
+            } else {
+                res[idx] = (*s.begin())>>32;
+            }
+        }
+        return res;
+    }
+};
+
+const static auto initialize = [] {
+    std::ios::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+    std::cout.tie(nullptr);
+    return nullptr;
+}();

leetcode/1851/42.in

@@ -0,0 +1,82 @@
+/*
+author: [email protected]
+time: O()
+space: O()
+
+Runtime: 748 ms, faster than 79.22% of C++ online submissions for Minimum Interval to Include Each Query.
+Memory Usage: 144.6 MB, less than 20.04% of C++ online submissions for Minimum Interval to Include Each Query.
+*/
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define all(x) begin(x), end(x)
+typedef vector<int> vi;
+typedef vector<vector<int>> vvi;
+
+class Solution {
+public:
+    vector<int> minInterval(vector<vector<int>>& itvs, vector<int>& qris) {
+        int n = size(qris);
+        int m = size(itvs);
+
+        int idx_qry[n];
+        iota(idx_qry, idx_qry+n, 0);
+        sort(idx_qry, idx_qry+n, [&qris](int & i, int & j){return qris[i] < qris[j];});
+
+        sort(all(itvs));
+
+        auto cmp = [](pair<int, int> a, pair<int, int> b) { 
+            if (a.first == b.first){
+                return a.second < b.second;
+            }
+            return a.first < b.first; 
+        };
+        /// sorted by r-l+1, distinguished by additional nonduplicate index
+        set<pair<int, int>, decltype(cmp)> s(cmp);
+        /// track the iterator of element in s with least r
+        /// sorted by r, distinguished by additional nonduplicate index
+        map<pair<int, int>, set<pair<int, int>, decltype(cmp)>::iterator, decltype(cmp)> it_s(cmp);
+
+        vi res(n);
+        
+        int idx;
+        int num;
+        int cur_idx_itv = 0;
+        vi * cur_itv = &itvs[cur_idx_itv];
+        int l = (*cur_itv)[0];
+        int r = (*cur_itv)[1];
+        for (int i=0; i<n; ++i){
+            idx = idx_qry[i];
+            num = qris[idx];
+            while (!it_s.empty() && (*it_s.begin()).first.first < num){
+                s.erase((*it_s.begin()).second);
+                it_s.erase(it_s.begin());
+            }
+            while (l <= num){
+                if (r >= num){
+                    it_s.insert({{r, cur_idx_itv}, s.insert({r - l + 1, cur_idx_itv}).first});
+                }
+                ++cur_idx_itv;
+                if (cur_idx_itv >= m) break;
+                cur_itv = &itvs[cur_idx_itv];
+                l = (*cur_itv)[0];
+                r = (*cur_itv)[1];
+            }
+            if (s.empty()){
+                res[idx] = -1;
+            } else {
+                res[idx] = (*s.begin()).first;
+            }
+        }
+        return res;
+    }
+};
+
+const static auto initialize = [] {
+    std::ios::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+    std::cout.tie(nullptr);
+    return nullptr;
+}();

leetcode/1851/main.cpp

@@ -0,0 +1,74 @@
+/*
+author: [email protected]
+time: O()
+space: O()
+
+Runtime: 496 ms, faster than 99.44% of C++ online submissions for Minimum Interval to Include Each Query.
+Memory Usage: 109.3 MB, less than 98.14% of C++ online submissions for Minimum Interval to Include Each Query.
+*/
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define all(x) begin(x), end(x)
+typedef vector<int> vi;
+typedef vector<vector<int>> vvi;
+
+class Solution {
+public:
+    vector<int> minInterval(vector<vector<int>>& itvs, vector<int>& qris) {
+        int n = size(qris);
+        int m = size(itvs);
+
+        int idx_qry[n];
+        iota(idx_qry, idx_qry+n, 0);
+        sort(idx_qry, idx_qry+n, [&qris](int & i, int & j){return qris[i] < qris[j];});
+
+        sort(all(itvs));
+        
+        auto cmp = [](pair<int, int> &a, pair<int, int> &b){
+            return a.second > b.second;
+        };
+        /// r, r-l+1
+        priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(cmp)> pq(cmp);
+
+        vi res(n);
+
+        int idx;
+        int num;
+        int cur_idx_itv = 0;
+        int l = itvs[0][0];
+        int r = itvs[0][1];
+
+        for (int i=0; i<n; ++i){
+            idx = idx_qry[i];
+            num = qris[idx];
+            while(l <= num) {
+                pq.push({r, r - l + 1});
+                cur_idx_itv++;
+                if (cur_idx_itv >= m) break;
+                l = itvs[cur_idx_itv][0];
+                r = itvs[cur_idx_itv][1];
+            }
+            /// not all are poped, but current top guarantees num in range
+            while(!pq.empty() && pq.top().first < num){
+                pq.pop();
+            }
+
+            if (pq.empty()){
+                res[idx] = -1;
+            } else {
+                res[idx] = pq.top().second;
+            }
+        }
+        return res;
+    }
+};
+
+const static auto initialize = [] {
+    std::ios::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+    std::cout.tie(nullptr);
+    return nullptr;
+}();