結果

問題 No.1867 Partitions and Inversions
ユーザー lam6er
提出日時 2025-04-09 20:56:07
言語 PyPy3
(7.3.15)
結果
TLE  
実行時間 -
コード長 2,826 bytes
コンパイル時間 464 ms
コンパイル使用メモリ 82,416 KB
実行使用メモリ 161,604 KB
最終ジャッジ日時 2025-04-09 20:56:15
合計ジャッジ時間 7,873 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge3
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample -- * 3
other AC * 2 TLE * 1 -- * 62
権限があれば一括ダウンロードができます

ソースコード

diff # 

def main():
    import sys
    input = sys.stdin.read
    data = input().split()
    
    N = int(data[0])
    P = list(map(int, data[1:N+1]))
    
    # Precompute the original number of inversions (S)
    class FenwickTree:
        def __init__(self, size):
            self.size = size
            self.tree = [0] * (self.size + 1)
        
        def update(self, idx, delta=1):
            while idx <= self.size:
                self.tree[idx] += delta
                idx += idx & -idx
        
        def query(self, idx):
            res = 0
            while idx > 0:
                res += self.tree[idx]
                idx -= idx & -idx
            return res
    
    max_val = N
    ft = FenwickTree(max_val)
    original_inversions = 0
    for i in reversed(range(N)):
        original_inversions += ft.query(P[i] - 1)
        ft.update(P[i])
    S = original_inversions
    
    # Precompute inv[j][i] which is inversions in P[j..i] (0-based)
    inv = [[0] * N for _ in range(N)]
    for i in range(N):
        ft = FenwickTree(max_val)
        current_inversions = 0
        for j in range(i, -1, -1):
            current_inversions += ft.query(P[j] - 1)
            inv[j][i] = current_inversions
            ft.update(P[j])
    
    # Convert to 1-based for the DP
    # dp[k][i]: maximum sum when partition first i elements into k segments
    dp_prev = [0] * (N + 2)
    for i in range(N):
        dp_prev[i+1] = inv[0][i]
    
    for k in range(2, N+1):
        dp_curr = [-1] * (N + 2)
        for i in range(k, N+1):
            max_val = 0
            for j in range(k-1, i):
                current = dp_prev[j] + inv[j][i-1] if j < i else 0
                if current > max_val:
                    max_val = current
            dp_curr[i] = max_val
        dp_prev, dp_curr = dp_curr, dp_prev
    
    # Prepare the answers
    for k in range(1, N+1):
        if k == 1:
            print(S - inv[0][N-1])
        else:
            # Compute max for partitioning into k segments
            max_sum = 0
            if k <= N:
                # Recalculate dp_prev for the given k
                dp = [[-1] * (N+1) for _ in range(k+1)]
                for i in range(N):
                    dp[1][i+1] = inv[0][i]
                for t in range(2, k+1):
                    for i in range(t, N+1):
                        max_val = 0
                        for j in range(t-1, i):
                            current = dp[t-1][j] + inv[j][i-1] if j < i else 0
                            if current > max_val:
                                max_val = current
                        dp[t][i] = max_val
                max_sum = dp[k][N] if k <= N else 0
            else:
                max_sum = 0
            res = S - max_sum
            print(res)

if __name__ == '__main__':
    main()
0