Problem:


問題文

ハコの魔女 H.N.ELLY はとある動画サイトの熱狂的なファンである．ハコの魔女の強さはその時々のその動画サイトからの転送速度に応じて変化するのではないかと美樹さやかは考えた．そこで動画サイトからハコの魔女の持つコンピュータまでの過去の転送速度 (=単位時間あたりのデータの転送量) を調べたい．

初期のインターネットのネットワークの構造とそれ以降のネットワークの構造の変化を表すクエリが与えられるので，各変化について変化した直後の動画サイトからハコの魔女の持つコンピュータまでの転送速度を求めよ．

インターネットは複数の転送装置からなるものと見なし，各々をつなぐ回線は双方向に情報を送ることができ，その転送速度の最大は 1 であるとする．また，ネットワークは常に動画サイトからハコの魔女へ送られるデータの転送速度を最大化するように運ぶものとする．

入力形式

入力は以下の形式で与えられる．

N\ E\ Q\\
F_1\ T_1\\
F_2\ T_2\\
…\\
F_E\ T_E\\
M_1\ A_1\ B_1\\
M_2\ A_2\ B_2\\
...\\
M_Q\ A_Q\ B_Q\\

N は動画サイトとハコの魔女の持つコンピュータを含めた転送装置の数である．番号が 1 である転送装置は動画サイトであり，番号が N である転送装置はハコの魔女の持つコンピュータである．E は初期状態で接続されている転送装置の組み合わせの数であり，Q はインターネットが変化した回数である．初期のインターネットは F_i と T_i が転送速度 1 で双方向に接続されていることを表す．

ネットワークの変化は時系列順に与えられ，j 番目の変化は M_j が 1 であれば A_j,\ B_j 間がつながれたことを表し，M_j が 2 であれば A_j,\ B_j 間の接続が切れたことを表す．

出力形式

各変化の直後における，動画サイトからハコの魔女の持つコンピュータまでの転送速度を出力せよ．

制約

2 \leq N \leq 500

0 \leq E \leq 20,000

1 \leq Q \leq 1,000

1 \leq F_i \leq N,\ 1 \leq T_i \leq N,\ F_i \neq T_i \ (1 \leq i \leq E)

すべての \{F_i, T_i\} のペアは異なる．

1 \leq M_j \leq 2,\ 1 \leq A_j \leq N\ ,\ 1 \leq B_j \leq N\ ,\ A_j \neq B_j (1 \leq j \leq Q)

ネットワークのどの段階においても次のことが成り立つ : どの 2 つの転送装置の間も高々 1 つの回線でしか繋がれていない．

2 つの転送装置の間が既に繋がれている状態でそれらの間を接続するようなクエリが来たり，2 つの転送装置の間が回線で繋がれていない状態でそれらの間の接続を切るようなクエリが来ることはない．

入出力例

入力例 1

2 1 2
1 2
2 1 2
1 2 1

出力例1

0
1

最初の変化の後，ハコの魔女のコンピュータと動画サイトは繋がらなくなっているので転送速度は 0 である．

2 度目の変化の後は両者は直接繋がっており，転送速度は 1 になる．

入力例 2

3 0 4
1 2 3
1 2 1
1 3 1
2 2 3

出力例 2

0
1
2
1

入力例 3

6 4 8
1 2
1 3
4 6
5 6
1 2 4
1 3 5
1 2 5
1 3 4
2 2 4
2 3 5
1 2 4
2 2 1

出力例 3

1
2
2
2
2
2
2
1

入力例 4

12 38 6
1 2
1 3
1 4
1 5
2 3
2 4
2 5
2 6
2 7
2 8
2 12
3 4
3 5
3 6
3 7
3 8
4 5
4 6
4 7
4 8
5 6
5 7
5 8
6 7
6 8
6 9
6 10
6 12
7 8
7 9
7 10
8 9
8 10
9 10
9 11
9 12
10 11
11 12
2 6 12
2 9 12
1 9 12
1 6 12
2 6 12
1 6 12

出力例 4

3
2
3
4
3
4

Problem Setter: Flat35

Sample input:
2 1 2
1 2
2 1 2
1 2 1


Sample output:
0
1

Submission status: Accepted

Solution code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+9
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)

class Flow():
    def __init__(self, e, N):
        self.EE = collections.defaultdict(set)
        for i in range(N):
            self.EE[i] |= e[i]
        self.E = e
        self.N = N
        self.nl = list(range(N))
        self.R = 0

    def max_flow(self, s, t):
        e = self.E
        v = None

        def f(c):
            v[c] = 1
            if c == t:
                return 1
            for i in e[c]:
                if v[i] is None and f(i):
                    # print('flow_remove', c, i)
                    if c in e[i]:
                        e[c].remove(i)
                    else:
                        e[i].add(c)
                    return 1
            return

        while True:
            v = [None] * self.N
            if f(s) is None:
                break
            self.R += 1

        return self.R

    def max_flow_add(self, s, t, u, v):
        self.E[u].add(v)
        self.E[v].add(u)
        self.EE[u].add(v)
        self.EE[v].add(u)
        return self.max_flow(s, t)

    def del_path_st(self, u, v, s, t):
        e = self.E
        vv = [None] * self.N
        def f(c):
            vv[c] = 1
            if c == v:
                return 1
            for i in e[c]:
                if vv[i] is None and f(i):
                    # print('flow_remove_st', c, i)
                    if c in e[i]:
                        e[c].remove(i)
                    else:
                        e[i].add(c)
                    return 1
            return
        if f(u):
            return

        uu = self.del_path_s(u, s)
        tt = self.del_path_s(t, v)
        self.R -= 1

    def del_path_s(self, u, s):
        e = self.E
        ee = self.EE
        v = [None] * self.N
        def f(c):
            if v[c]:
                return
            v[c] = 1
            if c == s:
                return 1
            for i in e[c]:
                if c in e[i]:
                    continue
                if f(i):
                    e[i].add(c)
                    # print('path_s', c, i)
                    return 1
            return
        return f(u)

    def max_flow_del(self, s, t, u, v):
        e = self.E
        ee = self.EE
        ee[u].remove(v)
        ee[v].remove(u)
        if v in e[u] and u in e[v]:
            e[u].remove(v)
            e[v].remove(u)
            # print('dele',[sorted(e[i]) for i in range(1,self.N)])
        elif v in e[u]:
            e[u].remove(v)
            self.del_path_st(v, u, s, t)
            # print('dele',[sorted(e[i]) for i in range(1,self.N)])
        else:
            e[v].remove(u)
            self.del_path_st(u, v, s, t)
            # print('dele',[sorted(e[i]) for i in range(1,self.N)])
        return self.max_flow(s, t)


def main():
    rr = []

    def f(n,e,q):
        ft = [LI() for _ in range(e)]
        mab = [LI() for _ in range(q)]
        e = collections.defaultdict(set)
        for fi,ti in ft:
            e[fi].add(ti)
            e[ti].add(fi)
        fl = Flow(e, n+1)
        r = []
        for m,a,b in mab:
            # print('mab',m,a,b)
            if m == 1:
                r.append(fl.max_flow_add(1,n,a,b))
            else:
                r.append(fl.max_flow_del(1,n,a,b))
            # print('e',[sorted(fl.E[i]) for i in range(1,n+1)])
            # print('ee',[sorted(fl.EE[i]) for i in range(1,n+1)])
            # print('r', r[-1])
        return r

    while 1:
        n,m,l = LI()
        if n == 0:
            break
        rr.extend(f(n,m,l))
        break

    return '\n'.join(map(str, rr))


print(main())