Oct 12

Author: fireofearth

2019/oct12/20162017-acmicpc-east-central-north-america-regional-contest-ecna-2016-en.pdf

@@ -0,0 +1,2 @@
+2016-2017 ACM-ICPC East Central North America Regional Contest (ECNA 2016)
+<https://codeforces.com/group/L0zlhp0AHw/contest/101196>

2019/oct12/README.md

@@ -0,0 +1,149 @@
+#include <iostream>
+#include <string>
+#include <set>
+#include <queue>
+#include <utility>
+using namespace std;
+
+void debug() {
+    cout << "DEBUG" << endl;
+}
+
+typedef pair<int, int> player_pair;
+
+/*
+Didn't get this one
+
+g++ -std=c++11 b-foosball.cpp -o k
+
+6
+Balaji David Alex Scott Andrew Ravi
+WWBWBBWBW
+
+6
+Amy Jinu Kasey Sarah Sheetal Julia
+BBBBB
+
+10
+a b c d e f g h i j
+WW
+
+10
+a b c d e f g h i j
+WWBB
+
+10
+a b c d e f g h i j
+WBBBW
+
+5
+a b c d e
+B
+o:
+b d
+
+5
+a b c d e
+BW
+o:
+b d
+a e
+
+5
+a b c d e
+BWW
+o:
+a e
+*/
+int main() {
+    queue<int> q;
+    int n, wo, wd, bo, bd, tmp;
+    wo = 0; bo = 1; wd = 2; bd = 3;
+    int wa1, wa2, ba1, ba2;
+    wa1 = 0; wa2 = 2; ba1 = 1; ba2 = 3;
+    player_pair pp;
+    set<player_pair> spp;
+    vector<player_pair> vpp;
+    int k; k = 0; // used to find len of dynasty
+    int acc; acc = 1; // acc to track len of longest dynasty
+    string outcomes;
+
+    cin >> n;
+    string names[n];
+    for(int i = 0; i < n; i++) {
+        cin >> names[i];
+        if(i >= 4) q.push(i);
+    }
+    cin >> outcomes;
+
+    int i = 0;
+    for(; i < outcomes.size(); i++) {
+        if(i > 0 && outcomes[i] != outcomes[i - 1]) {
+            // change dynasty
+            //cout << k << " " << acc << endl;
+            if(k >= acc) {
+                if(outcomes[i - 1] == 'W') // w dynasty record
+                    pp = player_pair(wa1, wa2);
+                else // b dynasty recod
+                    pp = player_pair(ba1, ba2);
+
+                if(k > acc) {
+                    spp = set<player_pair>();
+                    vpp = vector<player_pair>();
+                }
+
+                if(!spp.count(pp)) {
+                    spp.insert(pp);
+                    vpp.push_back(pp);
+                }
+                acc = k;
+            }
+            k = 1;
+        } else {
+            // dynasty continued
+            k++;
+        }
+        if(outcomes[i] == 'W') { // w wins
+            swap(wo, wd);
+            tmp = bd;
+            bd = bo;
+            q.push(tmp);
+            bo = q.front();
+            q.pop();
+            ba1 = bd;
+            ba2 = bo;
+        } else { // b wins
+            swap(bo, bd);
+            tmp = wd;
+            wd = wo;
+            q.push(tmp);
+            wo = q.front();
+            q.pop();
+            wa1 = wd;
+            wa2 = wo;
+        }
+    }
+    
+    if(k >= acc) {
+        if(outcomes[i - 1] == 'W') // w dynasty record
+            pp = player_pair(wa1, wa2);
+        else // b dynasty recod
+            pp = player_pair(ba1, ba2);
+
+        //cout << k << " " << acc << endl;
+        if(k > acc) {
+            spp = set<player_pair>();
+            vpp = vector<player_pair>();
+        }
+
+        if(!spp.count(pp)) {
+            spp.insert(pp);
+            vpp.push_back(pp);
+        }
+    }
+
+    for(const player_pair &ppo : vpp)
+        cout << names[ppo.first] << " " << names[ppo.second] << endl;
+
+    return 0;
+}

2019/oct12/b-foosball.cpp

@@ -0,0 +1,55 @@
+#include <iostream>
+#include <string>
+#include <cctype>
+#include <cmath>
+#include <utility>
+using namespace std;
+
+void debug() {
+    cout << "DEBUG" << endl;
+}
+
+char encode(char ch, int key) {
+    ch = ((ch - 'A') + (key - 'A') + 26 ) % 26;
+    ch += 'A';
+    return ch;
+}
+
+char decode(char ch, char key) {
+    ch = ((ch - 'A') - (key - 'A') + 26 ) % 26;
+    ch += 'A';
+    return ch;
+}
+
+// INV: in.size() <= key.size()
+string decode_substr(string in, string key) {
+    string out;
+    for(int i = 0; i < in.size(); i++) {
+        out += decode(in[i], key[i]);
+    }
+    return out;
+}
+
+/*
+https://stackoverflow.com/questions/522778/caesar-cipher-in-c
+g++ -std=c++11 c-key.cpp -o k
+
+SGZVQBUQAFRWSLC ACM
+SGZVQBUQAFR ACM
+SGZVQBUQ ACM
+SGZ ACM
+*/
+int main() {
+    string in, out, key;
+    int k = 0;
+    cin >> in >> key;
+    int m = key.size();
+    while(k < in.size()) {
+        out += decode_substr(in.substr(k, min(m, (int) in.size() - k)), key);
+        key = out.substr(k, m);
+        k += m;
+    }
+    cout << out << endl;
+
+    return 0;
+}

2019/oct12/c-key.cpp

@@ -0,0 +1,186 @@
+#include <iostream>
+#include <vector>
+#include <map>
+#include <queue>
+#include <string>
+using namespace std;
+
+struct Edge {
+    int vertex;
+    Edge *next;
+};
+
+class Graph {
+public:
+    Graph(int n) {
+        if(n <= 0)
+            throw std::invalid_argument( "n must be positive" );
+        size = n;
+        vertices = new Edge*[size];
+        for(int i = 0; i < n; i++) 
+            vertices[i] = NULL;
+    }
+
+    /* destructor */
+    ~Graph() {
+        internal_destructor();
+    }
+
+    /* copy constructor */
+    Graph(const Graph &g) {
+        internal_copy(g);
+    }
+
+    /* assignment operator */
+    Graph& operator=(const Graph &g) {
+        if(this == &g) return *this;
+        internal_destructor();
+        internal_copy(g);
+        return *this;
+    }
+
+    int get_size() { return size; }
+    
+    /* returns true iff edge has been added successfully */
+    bool add_edge(int from, int to) {
+        if(from >= size || to >= size || from < 0 || to < 0)
+            return false;
+        Edge *my_edge = new Edge{to, NULL};
+        if(vertices[from]) {
+            Edge *curr = vertices[from];
+            while(curr->vertex != to && curr->next)
+                curr = curr->next;
+            if(curr->vertex == to)
+                return false;
+            curr->next = my_edge;
+        } else {
+            vertices[from] = my_edge;
+        }
+        return true;
+    }
+
+    /* returns true iff edge has been removed successfully */
+    bool rem_edge(int from, int to) {
+        if(from >= size || to >= size || from < 0 || to < 0)
+            return false;
+        if(vertices[from]) {
+            Edge *curr = vertices[from];
+            if(curr->vertex == to) {
+                vertices[from] = curr->next;
+                delete curr;
+                return true;
+            } else {
+                Edge *tmp;
+                while(curr->next) {
+                    if(curr->next->vertex == to) {
+                        tmp = curr->next;
+                        curr->next = curr->next->next;
+                        delete tmp;
+                        return true;
+                    }
+                    curr = curr->next;
+                }
+            }
+        }
+        return false;
+    }
+
+    Edge* neighbors(int vertex) {
+        if(vertex < 0 || vertex >= size)
+            return NULL;
+        else
+            return vertices[vertex];
+    }
+
+private:
+    int size;
+    Edge **vertices;
+
+    void internal_destructor() {
+        Edge *temp; Edge *curr;
+        for(int i = 0; i < size; i++) {
+            curr = vertices[i];
+            while(curr) {
+                temp = curr; curr = curr->next;
+                delete temp;
+            }
+        }
+        delete[] vertices;
+    }
+
+    void internal_copy(const Graph &g) {
+        size = g.size;
+        Edge *curr;
+        Edge *g_curr;
+        vertices = new Edge*[size];
+        for(int i = 0; i < size; i++) {
+            g_curr = g.vertices[i];
+            if(g_curr) {
+                curr = new Edge{g_curr->vertex, NULL};
+                vertices[i] = curr;
+                while(g_curr->next) {
+                    g_curr = g_curr->next;
+                    curr->next = new Edge{g_curr->vertex, NULL};
+                    curr = curr->next;
+                }
+            } else {
+                vertices[i] = NULL;
+            }
+        }
+    }
+};
+
+bool breadth_first_search(Graph &g, int start, int target) {
+    bool visited[g.get_size()];
+    for(int i = g.get_size() - 1; i >= 0; i--)
+        visited[i] = false;
+    queue<int> q; q.push(start); // current level
+    queue<int> l; // next level
+    Edge *nbr;
+    int curr;
+
+    while(!q.empty() || !l.empty()) {
+        // if q empty, then fetch the next level to visit
+        if(q.empty())
+            while(!l.empty()) {
+                q.push(l.front()); l.pop();
+            }
+
+        // get vertex
+        curr = q.front(); q.pop();
+        // check vertex is visited
+        if(!visited[curr]) {
+            // check vertex is target
+            printf("%d ",curr);
+            if(curr == target) {
+                printf("\n");
+                return true;
+            }
+            visited[curr] = true;
+            // add neighbors to next level
+            nbr = g.neighbors(curr);
+            while(nbr) {
+                l.push(nbr->vertex);
+                nbr = nbr->next;
+            }
+        }
+    }
+
+    printf("\n");
+    return false;
+}
+
+int main() {
+    
+    Graph g = Graph(4);
+    g.add_edge(0, 1);
+    g.add_edge(1, 2);
+    g.add_edge(2, 3);
+    cout << breadth_first_search(g, 0, 3) << endl;
+    g.rem_edge(1, 2);
+    cout << breadth_first_search(g, 0, 3) << endl;
+    g.add_edge(1, 3);
+    cout << breadth_first_search(g, 0, 3) << endl;
+
+    return 0;
+}