結果

問題 No.3265 地元に帰れば天才扱い！
コンテスト
ユーザー kazuppa
提出日時 2025-08-09 11:32:21
言語 Python3
(3.13.1 + numpy 2.2.1 + scipy 1.14.1)
結果
RE  
実行時間 -
コード長 2,541 bytes
コンパイル時間 281 ms
コンパイル使用メモリ 12,288 KB
実行使用メモリ 107,216 KB
最終ジャッジ日時 2025-09-06 12:32:03
合計ジャッジ時間 15,020 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge4
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample WA * 1 RE * 3
other RE * 21
権限があれば一括ダウンロードができます

ソースコード

diff # 

import sys

# Fast input tokens
data = sys.stdin.buffer.read().split()
it = iter(data)
def ni():
    return int(next(it))

class BIT:
    # 1-indexed Fenwick tree for point add, prefix sum
    def __init__(self, n):
        # allocate a bit larger for safety (match original C++ generous sizing)
        self.n = n + 5
        self.bit = [0] * (self.n)

    def add(self, i, x):
        # i is 1-indexed
        n = self.n
        while i < n:
            self.bit[i] += x
            i += i & -i

    def sum(self, i):
        # sum of [1..i]
        s = 0
        while i > 0:
            s += self.bit[i]
            i -= i & -i
        return s

class Lazy_BIT:
    # Range add [l, r) and prefix-sum query using two BIT arrays (1-indexed)
    def __init__(self, n):
        # internal size similar to C++: n_ + 1 => keep some margin
        self.n = n + 5
        self.bit0 = [0] * (self.n)
        self.bit1 = [0] * (self.n)

    def _add_sub(self, bit, i, x):
        n = self.n
        while i < n:
            bit[i] += x
            i += i & -i

    def add(self, l, r, x):
        # add x to [l, r) (1-indexed, r may be n+1)
        # mirror C++: add_sub(0, l, -x*(l-1)); add_sub(0, r, x*(r-1)); add_sub(1, l, x); add_sub(1, r, -x);
        self._add_sub(self.bit0, l, -x * (l - 1))
        self._add_sub(self.bit0, r, x * (r - 1))
        self._add_sub(self.bit1, l, x)
        self._add_sub(self.bit1, r, -x)

    def _sum_sub(self, bit, i):
        s = 0
        while i > 0:
            s += bit[i]
            i -= i & -i
        return s

    def sum(self, i):
        # prefix sum at i: sum_sub(0,i) + sum_sub(1,i) * i
        return self._sum_sub(self.bit0, i) + self._sum_sub(self.bit1, i) * i

def solve():
    n = ni()
    a = [0] + [ni() for _ in range(n)]  # 1-indexed
    # Following C++ sizing: BIT<it> b1(n+1); Lazy_BIT<int> b2(n);
    b1 = BIT(n + 1)
    b2 = Lazy_BIT(n)
    for i in range(1, n + 1):
        b1.add(i, a[i])

    q = ni()
    ans = 0
    out_lines = []
    for _ in range(q):
        x = ni(); y = ni(); l = ni(); r = ni()
        # ans += b1.sum(r)-b1.sum(l-1);
        ans += b1.sum(r) - b1.sum(l - 1)
        # b2.add(l,r+1,1);
        b2.add(l, r + 1, 1)
        # ans += (y-a[x])*(b2.sum(x)-b2.sum(x-1));
        times_at_x = b2.sum(x) - b2.sum(x - 1)
        ans += (y - a[x]) * times_at_x
        # b1.add(x,y-a[x]); a[x]=y;
        b1.add(x, y - a[x])
        a[x] = y
        out_lines.append(str(ans))

    sys.stdout.write("\n".join(out_lines))

if __name__ == "__main__":
    solve()
0