Oct 4

Author: fireofearth

2019/oct4/README.md

@@ -0,0 +1,2 @@
+ICPC North America Qualifier 2019
+<https://naq19.kattis.com/>

2019/oct4/a-circuit.cpp

@@ -0,0 +1,62 @@
+#include<iostream>
+#include<stack>
+#include<string>
+using namespace std;
+
+bool is_gate(char in) {
+    return (in == '*' || in == '+' || in == '-');
+}
+
+
+bool is_binary(char in) {
+    return (in == '*' || in == '+');
+}
+
+/**
+g++ -std=c++11 a-circuit.cpp -o k
+*/
+int main() {
+    stack<bool> s;
+    int n, at_letter, k;
+    at_letter = 0; k = 0;
+    char in;
+    string line;
+    cin >> n;
+    bool b[n];
+    bool o1, o2;
+    for(int i = 0; i < n; i++) {
+        cin >> in;
+        if(in == 'F') b[i] = false;
+        else b[i] = true;
+    }
+
+    cin.ignore();
+    getline(cin, line);
+
+    while(k < line.size()) {
+        in = line[k]; k++;
+        if(in == ' ' || in == '\n')
+            continue;
+
+        if(is_gate(in)) {
+            if(is_binary(in)) {
+                o1 = s.top(); s.pop();
+                o2 = s.top(); s.pop();
+                if(in == '*') { // * AND
+                    s.push(o1 && o2);
+                } else { // + OR
+                    s.push(o1 || o2);
+                }
+            } else { // is singular - NOT
+                o1 = s.top(); s.pop();
+                s.push(!o1);
+            }
+        } else { // A B ... Z
+            s.push(b[at_letter]);
+            at_letter++;
+        }
+    }
+    cout << (s.top() ? 'T' : 'F') << endl;
+
+    return 0;
+}

2019/oct4/b-diagonal-cut.cpp

@@ -0,0 +1,29 @@
+#include<iostream>
+#include<numeric>
+using namespace std;
+
+typedef unsigned long long int mlong;
+
+
+/**
+g++ -std=c++17 b-diagonal-cut.cpp -o k
+1 <= M, N <= 10^18 leads to issues. Need adjustment
+*/
+
+int main() {
+    mlong M, N;
+    cin >> M >> N;
+    mlong g = gcd(M, N);
+    mlong m = M / g;
+    mlong n = N / g;
+    mlong b;
+    if(m == n) {
+        b = n;
+    } else if(m % 2 == n % 2) {
+        b = 1;
+    }
+    mlong f = b * g;
+    printf("%llu", f);
+    cout << endl;
+    return 0;
+}

2019/oct4/c-gerrymandering.cpp

@@ -0,0 +1,62 @@
+#include<iostream>
+#include<string>
+#include<cmath>
+using namespace std;
+
+typedef long long int mlong;
+typedef long double mdouble;
+
+/**
+g++ -std=c++11 c-gerrymandering.cpp -o k
+*/
+
+int main() {
+    int P, D, d;
+    mlong a, b;
+    cin >> P >> D;
+    mlong vA[D];
+    mlong vB[D];
+    mlong wA;
+    mlong wB;
+    mlong wdiff = 0;
+    mlong vtotal = 0;
+    bool Awins;
+    
+    for(int i = 0; i < D; i++) {
+        vA[i] = 0;
+        vB[i] = 0;
+    }
+
+    for(int i = 0; i < P; i++) {
+        cin >> d >> a >> b;
+        vA[d - 1] += a;
+        vB[d - 1] += b;
+        vtotal += a + b;
+    }
+
+//    for(int i = 0; i < D; i++) {
+//        printf("%d %d\n", vA[i], vB[i]);
+//    }
+
+    for(int i = 0; i < D; i++) {
+        if(vA[i] > vB[i]) { // A wins
+            Awins = true;
+            wB = vB[i];
+            wA = vA[i] - ((mlong) floor(((mdouble) vA[i] + vB[i]) / 2.0)) - 1;
+        } else { // B wins
+            Awins = false;
+            wA = vA[i];
+            wB = vB[i] - ((mlong) floor(((mdouble) vA[i] + vB[i]) / 2.0)) - 1;
+        }
+        wdiff += (wA - wB);
+        cout << (Awins ? "A" : "B") << " " << wA << " " << wB << endl;
+    }
+    cout.precision(8);
+    cout << abs((mdouble) wdiff) / ((mdouble) vtotal) << endl;
+
+    return 0;
+}
+
+
+
+

2019/oct4/d-missing.cpp

@@ -0,0 +1,44 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+
+typedef unsigned long long int mlong;
+
+
+/**
+g++ -std=c++11 d-missing.cpp -o k
+4
+3
+4
+5
+8
+*/
+
+int main() {
+    int n, c, d;
+    vector<int> v;
+    cin >> n;
+    int last;
+    bool skipped = false;
+    for(int i = 0; i < n; i++) {
+        cin >> c;
+        if(i == 0) {
+            // check if c == 1
+            for(int j = 1; j < c; j++)
+                v.push_back(j);
+        } else {
+            for(int j = last + 1; j < c; j++)
+                v.push_back(j);
+        }
+        last = c;
+    }
+    if(v.empty()) {
+        cout << "good job" << endl;
+        return 0;
+    }
+    for(int i : v) {
+        cout << i << endl;
+    }
+    return 0;
+}
+

2019/oct4/i-slow-leak.cpp

@@ -0,0 +1,39 @@
+#include<iostream>
+#include<string>
+#include<unordered_set>
+using namespace std;
+
+/**
+g++ -std=c++11 k-summer.cpp -o k
+*/
+int main() {
+    unordered_set<char> s = unordered_set<char>(); // charaters visited at each i
+    //unordered_set<char> s; // charaters visited at each i
+    string in;
+    cin >> in;
+    int count = 0;
+    for(int i = 0; i < in.size(); i++) {
+        s = unordered_set<char>();
+        for(int j = i + 1; j < in.size(); j++) {
+            if(in[i] == in[j])
+                break;
+            else {
+                if(s.count(in[j]) > 0) {
+                    // don't count this one
+                } else {
+                    count++;
+                    s.insert(in[j]);
+                    // print the good itinerary
+                    // for(int k = i; k <= j; k++) {
+                    //     printf("%c", in[k]);
+                    // }
+                    // cout << endl;
+                }
+            }
+        }
+    }
+    
+    cout << count << endl;
+    return 0;
+}
+

2019/oct4/k-summer.cpp

@@ -0,0 +1,72 @@
+#include<iostream>
+#include<algorithm>
+#include<cmath>
+using namespace std;
+
+typedef unsigned long long int mlong;
+
+double pow2(double x) {
+    return pow(x, 2.0);
+}
+
+double f(double x, double w, double g, double h) {
+    return sqrt(pow2(g) + pow2(x)) + sqrt(pow2(h) + pow2(w - x));
+}
+
+double df(double x, double w, double g, double h) {
+    return (x / sqrt(pow2(g) + pow2(x))) + ((x - w) / sqrt(pow2(h) + pow2(w - x)));
+}
+
+double bsearch(double w, double g, double h) {
+    double left = 0;
+    double right = w;
+    double x, dfx;
+    int i = 0;
+    while(abs(left - right) > pow(10.0, -6) / 1.10) {
+        //cout << "iter " << i << " " << abs(left - right) << endl;
+        i++;
+        if(i > 1000) break;
+        x = (left + right) / 2;
+        dfx = df(x, w, g, h);
+        if(dfx == 0.0)
+            break;
+        else if(dfx < 0.0)
+            left = x;
+        else // (x > 0.0)
+            right = x;
+    }
+    return f(x, w, g, h);
+}
+
+/**
+g++ -std=c++17 m-zipline.cpp -o k
+*/
+double getmin(double w, double g, double h) {
+    double x = abs(g - h);
+    return sqrt(pow2(x) + pow2(w));
+}
+
+int main() {
+    int n, w, g, h, r;
+    cin >> n;
+    double l[n];
+    double L[n];
+
+    for(int i = 0; i < n; i++) {
+        cin >> w >> g >> h >> r;
+        // compute minimum
+        l[i] = getmin((double) w, (double) g, (double) h);
+        g = g - r;
+        h = h - r;
+        // compute maximum
+        L[i] = bsearch((double) w, (double) g, (double) h);
+    }
+
+    cout.precision(17);
+    for(int i = 0; i < n; i++) {
+        cout << l[i] << " " << L[i] << endl;
+    }
+
+    return 0;
+}
+

2019/oct4/m-zipline.cpp

@@ -213,6 +213,9 @@ g++ -std=c++11 g-graduation3.cpp -o k
 11 3
 0 1 1 2 2 2 2 3 3 3 3
 
+8 2
+0 1 2 3 0 5 5 5
+
 8 3
 2 0 2 0 4 4 2 5 6
 

2019/sept21/g-graduation3.cpp

@@ -1,7 +1,6 @@
 #include <iostream>
 #include <set>
 #include <string>
-#include <stack>
 #include <queue>
 #include <vector>
 using namespace std;