Class #09

Author: AlonLib

Kattis Closest Pair.cpp

@@ -0,0 +1,65 @@
+//
+// Created by Alon on 02/06/2020.
+//
+
+#include <iostream>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <set>
+#include <stack>
+#include <cassert>
+#include <cfloat>
+#include <cmath>
+#include <iomanip>
+
+using namespace std;
+typedef long long ll;
+
+
+double dist(pair<double, double> p1, pair<double, double> p2) {
+    return hypot(p1.first - p2.first, p1.second - p2.second); 
+}
+
+/// Closest Pair (Uniform) Kattis - closestpair1
+int main() {
+    int n;
+    while (cin >> n && n) {
+        vector<pair<double, double>> axis;
+        while (n--) {
+            pair<double, double> p;
+            cin >> p.first >> p.second;
+            axis.push_back(p);
+        }
+        pair<double, double> p1, p2;
+        double d = 100001, i_to_remove = 0;
+        sort(axis.begin(), axis.end());
+        set<pair<double, double>> ys;
+        for (int i = 0; i < axis.size(); ++i) {
+            pair<double, double> main_p = axis[i];
+            auto it = ys.lower_bound({main_p.second - d, -100001});
+            while (it != ys.end() && (*it).first <= main_p.second + d) {
+                pair<double, double> temp_p = {(*it).second, (*it).first}; // x,y
+                double temp_d = dist(main_p, temp_p);
+                if (temp_d < d) {
+                    d = temp_d;
+                    p1 = temp_p;
+                    p2 = main_p;
+                }
+                it++;
+            }
+            while (i_to_remove < i && axis[i_to_remove].first < axis[i].first - d) {
+                pair<double, double> temp_p = {axis[i_to_remove].second, axis[i_to_remove].first};
+                ys.erase(temp_p);
+                ++i_to_remove;
+            }
+            ys.insert(make_pair(main_p.second, main_p.first));
+        }
+        cout << fixed << setprecision(2)<< p1.first << " " << p1.second << " " << p2.first << " " << p2.second << endl;
+    }
+
+    return 0;
+}

Kattis Platforme.cpp

@@ -0,0 +1,70 @@
+//
+// Created by Alon on 02/06/2020.
+//
+
+#include <iostream>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <set>
+#include <stack>
+#include <cassert>
+
+using namespace std;
+typedef long long ll;
+
+enum edge {END = 0, START = 1};
+struct pillar {
+    int y, x1, x2;
+};
+
+int main() {
+    int N, res = 0;
+    cin >> N;
+    vector<pillar> pillars(N); // Y X1 X2
+//    vector<pair<int, int>> starts(N); // X1 N
+//    vector<pair<int, int>> ends(N); // X2 N
+    vector<pair<int, int>> axis; // X2 N
+    for (int i = 0; i < N; ++i) {
+        cin >> pillars[i].y >> pillars[i].x1 >> pillars[i].x2;
+//        starts[i] = {pillars[i].x1, i};
+//        ends[i] = {pillars[i].x2, i};
+        axis.push_back(make_pair(pillars[i].x1, i)); // start
+        axis.push_back(make_pair(pillars[i].x2, i)); // end
+    }
+//    sort(starts.begin(), starts.end());
+//    sort(ends.begin(), ends.end());
+    sort(axis.begin(), axis.end());
+    set<int> current_heights = { 0 };
+    int i = -1;
+    while (i + 1 < (int)axis.size()) {
+        stack<int> pillar_to_remove;
+        vector<int> pillar_to_add;
+        do {
+            ++i;
+            int number_of_pillar = axis[i].second;
+            if (axis[i].first == pillars[number_of_pillar].x1) { /// begin pillar
+                pillar_to_add.push_back(number_of_pillar);
+            } else { /// end pillar
+                assert(axis[i].first == pillars[number_of_pillar].x2);
+                pillar_to_remove.push(number_of_pillar);
+                int len = pillars[number_of_pillar].y - *(--(current_heights.find(pillars[number_of_pillar].y))); // upper_bound is exclusive
+                res += len;
+            }
+        } while (i + 1 < axis.size() && axis[i].first == axis[i+1].first);
+        while (!pillar_to_remove.empty()) {
+            current_heights.erase(pillars[pillar_to_remove.top()].y);
+            pillar_to_remove.pop();
+        }
+        for (int p : pillar_to_add) current_heights.insert(pillars[p].y);
+        for (int p : pillar_to_add) {
+            int len = pillars[p].y - *(--(current_heights.find(pillars[p].y))); // upper_bound is exclusive
+            res += len;
+        }
+    }
+    cout << res << endl;
+    return 0;
+}