Bunch of random CF

Author: arknave

codeforces/1/a.py

@@ -0,0 +1,11 @@
+from math import ceil
+
+def main():
+    n, m, a = map(int, input().split())
+
+    w = int(ceil(n / a))
+    h = int(ceil(m / a))
+
+    print(w * h)
+    
+main()

codeforces/1/b.py

@@ -0,0 +1,49 @@
+import re
+
+def rc(s):
+    valid = re.compile(r'R(\d+)C(\d+)')
+    match = valid.match(s)
+    if match is None:
+        return None, None
+    else:
+        return list(map(int, match.groups()))
+
+def excel_to_int(s):
+    ans = 0
+    for c in s:
+        ans += ord(c) - ord('A')
+        ans += 1
+        ans *= 26
+
+    return ans // 26
+
+def int_to_excel(x):
+    out = []
+    while x:
+        x -= 1
+        out.append(chr(ord('A') + int(x % 26)))
+        x //= 26
+
+    return ''.join(reversed(out))
+
+def main():
+    n = int(input())
+    for _ in range(n):
+        s = input()
+        x, y = rc(s)
+
+        if x is None:
+            row_start = 0
+            while s[row_start] not in '0123456789':
+                row_start += 1
+
+            col_excel = s[:row_start]
+            col = excel_to_int(col_excel)
+            row = s[row_start:]
+
+            print('R{}C{}'.format(row, col))
+        else:
+            col = int_to_excel(y)
+            print('{}{}'.format(col, x))
+
+main()

codeforces/144/d.cpp

@@ -0,0 +1,111 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <utility>
+#include <vector>
+#include <map>
+#include <queue>
+
+using namespace std;
+
+const int MAXN = 100005;
+int n, m, start;
+long long l;
+
+vector<pair<int, long long> > graph[MAXN];
+long long dist[MAXN];
+
+typedef pair<long long, int> state;
+
+void dijkstra() {
+    // find the shortest path from the source to all nodes
+
+    memset(dist, -1, sizeof(dist));
+    priority_queue<state, vector<state>, greater<state> > pq;
+    pq.push(make_pair(0LL, start));
+
+    while (!pq.empty()) {
+        state cur = pq.top();
+        pq.pop();
+
+        long long dist_here = cur.first;
+        int pos = cur.second;
+
+        if (dist[pos] != -1 and dist[pos] <= dist_here)
+            continue;
+
+        dist[pos] = dist_here;
+
+        for (pair<int, long long> edge : graph[pos]) {
+            int next_place = edge.first;
+            long long next_dist = dist_here + edge.second;
+
+            if (dist[next_place] == -1 or dist_here < dist[next_place]) {
+                pq.push(make_pair(next_dist, next_place));
+            }
+        }
+    }
+}
+
+int main() {
+    scanf("%d %d %d", &n, &m, &start);
+
+    int u, v;
+    long long w;
+    for (int i = 0; i < m; ++i) {
+        scanf("%d %d %lld", &u, &v, &w);
+        graph[u].push_back(make_pair(v, w));
+        graph[v].push_back(make_pair(u, w));
+    }
+
+    scanf("%lld", &l);
+
+    dijkstra();
+
+    long long ans = 0;
+    for (u = 1; u <= n; ++u) {
+        // printf("City %d at dist %lld\n", u, dist[u]);
+        if (dist[u] == l) {
+            // printf("Silo at city %d\n", u);
+            ++ans;
+            continue;
+        }
+
+        if (dist[u] > l) {
+            continue;
+        }
+
+        for (pair<int, long long> edge : graph[u]) {
+            v = edge.first;
+            w = edge.second;
+
+            if (dist[u] + w <= l) {
+                continue;
+            }
+
+            // edge case: the distance is the same from either side
+            if (u < v and
+                dist[u] < l and l < dist[u] + w and
+                dist[v] < l and l < dist[v] + w and
+                dist[u] + dist[v] + w == 2 * l) {
+                // printf("Midpoint silo between %d and %d\n", u, v);
+                ++ans;
+            }
+
+            // consider the point coming from u
+            if (dist[u] < l and l < dist[u] + w) {
+                // the point is l - dist[u] away from u
+                long long u_dist = l - dist[u];
+                // the point is dist[v] + w - u_dist away from v
+                if (l < dist[v] + w - u_dist) {
+                    // printf("Silo at distance %lld along edge between %d and %d\n", u_dist, u, v);
+                    ++ans;
+                }
+            }
+        }
+    }
+
+    printf("%lld\n", ans);
+
+    return 0;
+}

codeforces/377/a.cpp codeforces/378/c.cpp

@@ -0,0 +1,24 @@
+from collections import defaultdict
+
+def main():
+    home = input()
+    away = input()
+    num_fouls = int(input())
+
+    players = defaultdict(int)
+    banned = set()
+    for _ in range(num_fouls):
+        minute, team, player, card = input().split()
+        team_name = home if team == 'h' else away
+
+        if card == 'y':
+            players[(team_name, player)] += 1
+        else:
+            players[(team_name, player)] = 2
+
+        if (team_name, player) not in banned and players[(team_name, player)] >= 2:
+            print(team_name, player, minute)
+            banned.add((team_name, player))
+        
+
+main()

codeforces/493/a.py

@@ -0,0 +1,24 @@
+def main():
+    n = int(input())
+
+    p1, p2 = [], []
+
+    last = 1
+    for _ in range(n):
+        move = int(input())
+
+        if move > 0:
+            p1.append(move)
+            last = 1
+        else:
+            p2.append(-move)
+            last = 2
+
+    if sum(p1) != sum(p2):
+        print('first' if sum(p1) > sum(p2) else 'second')
+    elif p1 != p2:
+        print('first' if p1 > p2 else 'second')
+    else:
+        print('first' if last == 1 else 'second')
+
+main()

codeforces/493/b.py

@@ -0,0 +1,59 @@
+def lte(n, a, d):
+    # count the number of values in a <= d
+    if a[0] > d:
+        return 0
+    if a[-1] <= d:
+        return n
+    else:
+        lo = 0
+        hi = n - 1
+        while lo + 1 < hi:
+            mid = (lo + hi) // 2
+            if a[mid] <= d:
+                lo = mid
+            else:
+                hi = mid
+        return lo + 1
+
+def score(n, m, a, b, d):
+    ca = lte(n, a, d)
+    cb = lte(m, b, d)
+
+    a_score = 2 * ca + 3 * (n - ca)
+    b_score = 2 * cb + 3 * (m - cb)
+
+    return a_score, b_score
+
+
+def main():
+    n = int(input())
+    a = list(map(int, input().split()))
+
+    m = int(input())
+    b = list(map(int, input().split()))
+
+    a.sort()
+    b.sort()
+
+    factor = 2 if 2 * (n - m) > 3 * (n - m) else 3
+    best_diff = factor * (n - m)
+    best_a = factor * n
+    out = str(factor * n) + ':' + str(factor * m)
+
+    mega = set(a + b)
+
+    for d in mega:
+        if d <= 0: 
+            continue
+
+        a_score, b_score = score(n, m, a, b, d)
+        diff = a_score - b_score
+
+        if diff > best_diff or (diff == best_diff and a_score > best_a):
+            best_diff = diff
+            best_a = a_score
+            out = str(a_score) + ':' + str(b_score)
+
+    print(out)
+
+main()

codeforces/493/c.py

@@ -0,0 +1,6 @@
+n = int(input())
+if n % 2 == 0:
+    print("white")
+    print("1 2")
+else:
+    print("black")

codeforces/493/d.py

@@ -0,0 +1,85 @@
+#include <cstdio>
+#include <cstring>
+#include <algorithm>
+#include <utility>
+#include <vector>
+
+using namespace std;
+
+const int MAXA = 26;
+const int MAXN = 102;
+
+int n;
+vector<int> graph[MAXA];
+
+char strings[MAXN][2 * MAXN];
+int in_degree[MAXA];
+char out[MAXA + 1];
+
+int main() {
+    scanf("%d", &n);
+    for (int i = 0; i < n; ++i) {
+        scanf("%s", strings[i]);
+    }
+
+    bool impossible = false;
+    memset(in_degree, 0, sizeof(in_degree));
+    for (int i = 1; i < n; ++i) {
+        // find the first character that differs between s[i - 1] and s[i]
+        int a = strlen(strings[i - 1]);
+        int b = strlen(strings[i]);
+        int j = 0;
+        while (j < a and j < b and strings[i - 1][j] == strings[i][j]) {
+            ++j;
+        }
+
+        // abcd
+        // ab
+
+        // no alphabet can fix this 
+
+        if (j >= b and j < a) {
+            impossible = true;
+        } else if (j < a and j < b) {
+            // create an edge
+            char before = strings[i - 1][j];
+            char after  = strings[i][j];
+
+            // printf("Edge between %c and %c\n", before, after);
+            graph[before - 'a'].push_back(after - 'a');
+            ++in_degree[after - 'a'];
+        }
+    }
+
+    for (int i = 0; i < MAXA; ++i) {
+        // find a node with 0 in degree
+        bool found = false;
+        for (int j = 0; j < MAXA; ++j) {
+            if (in_degree[j] == 0) {
+                in_degree[j] = -1;
+                out[i] = j + 'a';
+                found = true;
+
+                // printf("%d %c\n", i, out[i]);
+                for (int k : graph[j]) {
+                    --in_degree[k];
+                }
+
+                break;
+            }
+        }
+
+        if (!found) {
+            impossible = true;
+            break;
+        }
+    }
+
+    if (impossible) {
+        puts("Impossible");
+    } else {
+        printf("%s\n", out);
+    }
+
+    return 0;
+}