結果

問題 No.318 学学学学学
ユーザー BB_Fe3BB_Fe3
提出日時 2022-09-12 12:56:10
言語 PyPy3
(7.3.15)
結果
TLE  
実行時間 -
コード長 3,172 bytes
コンパイル時間 239 ms
コンパイル使用メモリ 82,360 KB
実行使用メモリ 326,088 KB
最終ジャッジ日時 2024-11-29 11:08:26
合計ジャッジ時間 63,455 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge5
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 923 ms
162,320 KB
testcase_01 TLE -
testcase_02 TLE -
testcase_03 TLE -
testcase_04 TLE -
testcase_05 TLE -
testcase_06 TLE -
testcase_07 TLE -
testcase_08 TLE -
testcase_09 TLE -
testcase_10 TLE -
testcase_11 TLE -
testcase_12 TLE -
testcase_13 TLE -
testcase_14 TLE -
testcase_15 TLE -
testcase_16 TLE -
testcase_17 TLE -
testcase_18 TLE -
testcase_19 TLE -
testcase_20 TLE -
testcase_21 AC 36 ms
52,772 KB
testcase_22 AC 36 ms
52,608 KB
testcase_23 AC 35 ms
52,864 KB
testcase_24 AC 37 ms
53,248 KB
testcase_25 AC 36 ms
52,864 KB
testcase_26 AC 36 ms
52,736 KB
testcase_27 AC 37 ms
52,736 KB
testcase_28 AC 36 ms
52,992 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

def seg_func(x,y):
    return ' '.join((x,y))

def composition(m,n):
    if n == None:
        return m
    else:
        return n

def mapping(x,m):
    if m == None:
        return x
    else:
        return ' '.join((m,)*len(x.split()))

seg_id = ''
op_id = None

class LazySegTree():
    def __init__(self,val,seg_func=seg_func,composition=composition,mapping=mapping,seg_id=seg_id,op_id=op_id):
        self.len = len(val)
        self.seg_func = seg_func
        self.composition = composition
        self.mapping = mapping
        self.seg_id = seg_id
        self.op_id = op_id
        self.num = 2**((self.len-1).bit_length())
        self.tree = [self.seg_id for _ in range(2*self.num)]
        self.lazy = [self.op_id for _ in range(2*self.num)]
        for i in range(self.len):
            self.tree[self.num+i] = val[i]
        for i in range(self.num-1,0,-1):
            self.tree[i] = self.seg_func(self.tree[2*i],self.tree[2*i+1])

    def gindex(self,l,r):
        l += self.num
        r += self.num
        lm = l>>(l&-l).bit_length()
        rm = r>>(r&-r).bit_length()
        while r>l:
            if r<=rm:
                yield r
            if l<=lm:
                yield l
            r >>= 1
            l >>= 1
        while l:
            yield l
            l >>= 1

    def propagates(self,*ids):
        for i in reversed(ids):
            m = self.lazy[i]
            if m == self.op_id:
                continue
            self.lazy[i] = self.op_id
            self.lazy[2*i] = self.composition(self.lazy[2*i],m)
            self.lazy[2*i+1] = self.composition(self.lazy[2*i+1],m)
            self.tree[2*i] = self.mapping(self.tree[2*i],m)
            self.tree[2*i+1] = self.mapping(self.tree[2*i+1],m)

    def update(self,l,r,m):
        assert 0 <= l and l < r and r <= self.len
        
        ids = self.gindex(l,r)
        self.propagates(*self.gindex(l,r))
        l += self.num
        r += self.num
        while l<r:
            if l&1:
                self.tree[l] = self.mapping(self.tree[l],m)
                self.lazy[l] = self.composition(self.lazy[l],m)
                l += 1
            if r&1:
                self.tree[r-1] = self.mapping(self.tree[r-1],m)
                self.lazy[r-1] = self.composition(self.lazy[r-1],m)
            l >>= 1
            r >>= 1
        for i in ids:
            self.tree[i] = self.seg_func(self.tree[2*i],self.tree[2*i+1])

    def query(self,l,r):
        assert 0 <= l and l < r and r <= self.len
        
        self.propagates(*self.gindex(l,r))
        l += self.num
        r += self.num
        res1 = self.seg_id
        res2 = self.seg_id
        while l<r:
            if l&1:
                res1 = self.seg_func(res1,self.tree[l])
                l += 1
            if r&1:
                res2 = self.seg_func(self.tree[r-1],res2)
            l >>= 1
            r >>= 1
        return self.seg_func(res1,res2)

n=int(input())
A=list(map(int,input().split()))
A_sorted=sorted(set(A))
A=list(map(str,A))
A_sorted=list(map(str,A_sorted))
s=LazySegTree(['b']*n)
for a in A_sorted:
    l=A.index(a)
    r=n-A[::-1].index(a)
    s.update(l,r,a)
print(s.tree[1])
0