#745825 (PyPy3) No.1439 Let's Compare!!!!

• 問題: No.1439 Let's Compare!!!!
• ユーザー: cozy_sauna
• 提出日時: 2022-03-13 19:15:07
• 言語: PyPy3 (7.3.15)
• 結果: TLE
• 実行時間: -
• コード長: 4,295 bytes
• コンパイル時間: 377 ms
• コンパイル使用メモリ: 82,048 KB
• 実行使用メモリ: 173,056 KB
• 最終ジャッジ日時: 2024-09-19 02:44:41
• 合計ジャッジ時間: 5,167 ms
• ジャッジサーバーID （参考情報）: judge3 / judge1

ファイルパターン	結果
sample	AC * 2
other	AC * 5 TLE * 1 -- * 11

ソースコード

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
from sys import setrecursionlimit, stdin
from collections import defaultdict, deque
from itertools import permutations, combinations, product
from functools import lru_cache
from random import sample, choice, randint, random
from bisect import bisect_left, bisect_right
from heapq import heappush, heappop
from math import factorial, exp
from copy import copy, deepcopy
from time import time
setrecursionlimit(1 << 20)
readline = stdin.readline
# @lru_cache(maxsize = None)
INF = 10 ** 18
MOD = 998244353
# MOD = 1000000007
DYDX = [(-1, 0), (1, 0), (0, -1), (0, 1)]
ALP = 26
''' Input '''
def I(): return int(readline())
def ST(): return readline()[:-1]
def LI(): return list(map(int, readline().split()))
def LII(): return list(map(lambda x: int(x) - 1, readline().split()))
def SPI(): return map(int, readline().split())
def SPII(): return map(lambda x: int(x) - 1, readline().split())
def FIE(x): return [readline()[:-1] for _ in [0] * x]
def NODE(N, edge):
    node = [[] for _ in [0] * N]
    for _ in [0] * edge:
        a, b = map(int, input().split())
        node[a - 1].append(b - 1)
        node[b - 1].append(a - 1)
    return node 
def NODE_W(N, edge):
    node = [[] for _ in [0] * N]
    for _ in [0] * edge:
        a, b, c = map(int, input().split())
        node[a - 1].append((b - 1, c))
        node[b - 1].append((a - 1, c))
    return node
''' Array '''
def cmin(dp, i, x):
    if x < dp[i]: dp[i] = x
def cmax(dp, i, x):
    if x > dp[i]: dp[i] = x
''' Sorted Array '''
# x <= A[i] (minimum i meeting the requirement)
def binary(sortedA, x): return bisect_left(sortedA, x)
# x < A[i] (minimum i meeting the requirement)
def binary2(sortedA, x): return bisect_right(sortedA, x + 1)
# number of x in A
def quantity(sortedA, x): return bisect_right(sortedA, x) - bisect_left(sortedA, x)
''' Alphabet '''
def id_a(s): return ord(s) - ord('a')
def id_A(s): return ord(s) - ord('A')
def st_a(i): return chr(ord('a') + i)
def st_A(i): return chr(ord('A') + i)
''' Other'''
def ranges(*args): return [(i, j) for i in range(args[0]) for j in range(args[-1])]
def nynx(y, x, ly = INF, lx = INF): return [(y + dy, x + dx) for dy, dx in DYDX if 0 <= y + dy < ly and 0 <= x + dx < lx]
def gen(x, *args):
    ret = [x] * args[-1]
    for e in args[:-1][::-1]: ret = [deepcopy(ret) for _ in [0] * e]
    return ret
def is_prime(x):
    if x == 1 or x % 2 == 0: return x == 2
    f = 3
    while f * f <= x:
        if x % f == 0: return False 
        f += 2
    return True 
def gcd(x, y):
    if x == 0: return y
    return gcd(y % x, x)
def lcm(a, b):
    return a // gcd(a,b) * b
''' Output '''
def puts(E):
    for e in E: print(e)
def pprint(E): 
    print()
    for e in E: print(e)
def yn(x): print("Yes" if x else "No")
def YN(x): print("YES" if x else "NO")
def blank(arr): print(" ".join(map(str, arr)))
def link(arr): print(''.join(map(str, arr)))
def debug(*args):
    if DEBUG:
        for e in args: print(e)
DEBUG = False
   
class BIT():
    def __init__(self, N):
        self.size = N
        self.tree = [0] * (N + 1)
 
    def add(self, i, x):
        while i <= self.size:
            self.tree[i] += x
            i += i & -i
    # A[1] + A[2] + ... + A[i]
    def sum(self, i):
        ret = 0
        while i > 0:
            ret += self.tree[i]
            i -= i & -i
        return ret
    # A[i]
    def get(self, i):
        return self.sum(i) - self.sum(i - 1)
###############################################################################################
N = I()
S = list(map(int, input()))
T = list(map(int, input()))
Q = I()
tree = BIT(N + 1)
for i in range(N):
    if S[i] != T[i]: tree.add(i + 1, 1)
for _ in range(Q):
    c, x, y = input().split()
    x = int(x)
    y = int(y)
    if c == 'S': S[x - 1] = y 
    else: T[x - 1] = y 
    now = tree.get(x)
    if S[x - 1] != T[x - 1]: tree.add(x, 1 - now)
    else: tree.add(x, - now)
    tmp = []
    for i in range(N):
        tmp.append(tree.get(i + 1))
    if tree.sum(N + 1) == 0: print("=")
    else:
        bot = 0
        top = N
        while top - bot > 1:
            mid = top + bot >> 1
            if tree.sum(mid) >= 1: top = mid 
            else: bot = mid 
        
        idx = top - 1
        if int(S[idx]) > int(T[idx]): print(">")
        else: print("<")
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX