Solved some more problems from an atcoder round I last worked on 2022-03-05

Author: dcclyde

atcoder/2022-03-05_beginner_242/F.cpp

@@ -1,3 +1,11 @@
+40 40 30 30
+
+2 2 1 1
+
+1 2 1 1
+
+
+
 3 3 1 1
 
 2 2 1 1

atcoder/2022-03-05_beginner_242/F.in

@@ -14,4 +14,24 @@ F(R, c, b) * G(R-c', c+c', b') gets added onto F(R,
 F(r, c, b) * G(
 
 
+!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+How many ways to use K rooks on a RxC grid?
+Well...
+
+How many ways to use K rooks and RxC grid while needing every row and col?
+
+H(R, C, K) = bin(R*C, K)
+
+
+
+F(R, C, K) = H(R,C,K) - sum of F(r,c,K) * binom(R,r) * binom(C,c)
+    With K fixed, this should be computable in O(R*C).
+
+
+Then final answer is sum of F(rb, cb, B) * F(rw, cw, W) * binom(R,rb) * binom(R-rb,rc) * binom(C,cb) * binom(C-cb,cw).
+    (rb+rw <= R, cb+cw <= C)
+
+    This part is O(N^4).
+
 .

atcoder/2022-03-05_beginner_242/F.thinking

@@ -0,0 +1,13 @@
+
+I could try segtree with position = person and value = final answer + (state)
+I'd need a lot of state though. Each segment needs a list of unpaired people?
+
+
+
+I could try adding people to the list one at a time.
+Segtree value = answer from here to the end.
+Add kth person of a certain color -->  I need k/2 range updates.
+
+
+
+.

atcoder/2022-03-05_beginner_242/F_old.cpp

@@ -0,0 +1,29 @@
+#! /usr/bin/bash
+set -e  # Halt on error throughout this script (e.g. if diff finds a difference)
+
+if [ $# -ne 1 ]
+then
+    echo "Need exactly 1 argument: (problem name)."
+    exit
+fi
+
+PROBLEM="invalid"
+PROBLEM=$1
+
+# commands needed to prepare the solutions.
+# just comment out if one/both uses Python or otherwise doesn't need prep.
+g++ --std=c++20 "$PROBLEM".cpp -g -O2 -o a.out \
+    -DDCCLYDE_LOCAL
+g++ --std=c++20 -DDCCLYDE_BRUTEFORCE "$PROBLEM".cpp -g -O2 -o b.out \
+    -DDCCLYDE_LOCAL
+
+for((k = 1; k < 100000 ; ++k)); do
+    echo $k
+    pypy3 gen.py > gen.in
+    a.out < gen.in > fast.out \
+        # 2> /dev/null
+    b.out < gen.in > brute.out \
+        # 2> /dev/null
+
+    diff -w fast.out brute.out
+done

atcoder/2022-03-05_beginner_242/G.cpp

@@ -0,0 +1,123 @@
+#region  load template's helpers
+import sys
+sys.path.append("/home/dcclyde/puzzles/code/templates")
+from template import *
+#endregion
+#region  ri, rv
+def ri(q, b=None):
+    if isinstance(b, int):
+        q = (q, b)
+    elif isinstance(q, int):
+        q = (q,q)
+    return random.randint(q[0], q[1])
+
+def rv(q, n):
+    N = ri(n)
+    return [ri(q) for _ in range(N)]
+#endregion
+#region  rgraph
+def rgraph(nr, er, mute=False):
+    N = ri(nr)
+    E = ri(er)
+    E = min(E, N*(N-1)//2)
+    edge_options = [(a, b) for a in range(N) for b in range(a+1, N)]
+    edges = random.sample(edge_options, E)
+
+    if not mute:
+        print(N, E)
+        pvn1(edges)
+    return N, E, edges
+#endregion
+#region  rtree
+#region  DSU
+class DSU:
+    def __init__(self, _N):
+        self.N = _N
+        self.e = [-1] * self.N
+    def get(self, x):
+        if self.e[x] < 0:
+            return x
+        self.e[x] = self.e[self.e[x]]
+        return self.e[x]
+    def sameSet(self, a,b): return self.get(a) == self.get(b)
+    def size(self, x): return -self.e[self.get(x)]
+    def unite(self, x, y):
+        x = self.get(x); y = self.get(y)
+        if (x == y): return False
+        if (self.e[x] > self.e[y]): x,y = y,x
+        self.e[x] += self.e[y]
+        self.e[y] = x
+        return True
+#endregion
+def rtree(nr, mute=False):
+    N = ri(nr)
+    edges = []
+    for a in range(1, N):
+        b = ri((0, a-1))
+        edges.append([a,b])
+        random.shuffle(edges[-1])
+
+    perm = list(range(N))
+    random.shuffle(perm)
+    edges = [[perm[x] for x in q] for q in edges]
+    if not mute:
+        print(N)
+        pvn1(edges)
+    return N, edges
+#endregion
+#region  rtree_rooted
+def rtree_rooted(nr, mute=False):
+    N, edges = rtree(nr, mute=True)
+    G = [[] for _ in range(N)]
+    for a, b in edges:
+        G[a].append(b)
+        G[b].append(a)
+    root = 0
+    parents = [-2] * N
+    parents[root] = -1
+    # traverse.
+    todo = [root]
+    while len(todo) > 0:
+        curr = todo.pop()
+        for o in G[curr]:
+            if parents[o] == -2:
+                parents[o] = curr
+                todo.append(o)
+
+    parents = parents[1:]
+    if not mute:
+        print(N)
+        pv1(parents)
+    return N, parents
+
+def rtree_rooted_v2(nr, mute=False):
+    # this version assumes v's parent will have an index < v.
+    N = ri(nr)
+    parents = [ri((0, k)) for k in range(N-1)]
+    if not mute:
+        print(N)
+        pv1(parents)
+    return N, parents
+#endregion
+
+
+RC_RANGE = (1, 5)
+WB_RANGE = (1, 3)
+
+def gen_test():
+    R, C = rv(RC_RANGE, 2)
+    W, B = rv(WB_RANGE, 2)
+    ps(R, C, B, W)
+
+
+# ! IF RANDOM TESTS PASS:
+# !   * OVERFLOW! Remember pii, FOR, maxi/mini, INF Write an "overflow gen"?
+# !   * RECODE FROM SCRATCH? Maybe in Python?
+# !   * Misunderstanding the problem rules?
+# !   * Brute force wrong - is it sufficiently different?
+# !   * Edge case not buildable in brute forceable inputs (or needs mid size AND pathological)
+#region  past mistakes
+# * Uninitialized variable
+# * I used INF = 1e9 but answer could be bigger
+#endregion
+gen_test()