Overview

This is a problem where you are given two numerical sequences \(A\) and \(B\) of length \(N\), and you need to find the minimum number of operations required to make them completely identical using increment/decrement operations on each element.

Analysis

The key insight of this problem is that “each index \(i\) can be considered independently”.

Consider making \(A_i\) and \(B_i\) equal at some index \(i\). For example, if \(A_i = 3, B_i = 8\), the following methods can be used to make them equal: - Increment \(A_i\) five times - Decrement \(B_i\) five times - Increment \(A_i\) twice and decrement \(B_i\) three times (total of \(5\) operations)

In any case, the required number of operations is the absolute difference between \(A_i\) and \(B_i\), which is \(|A_i - B_i|\). Since each operation can only change the value of \(A_i\) or \(B_i\) by \(1\), it is impossible to make them equal with fewer operations than this value.

Since an operation at index \(i\) does not affect the value at any other index \(j\) (\(i \neq j\)), the minimum number of operations is obtained by computing \(|A_i - B_i|\) for all \(i\) and summing them up.

Algorithm

1. Initialize a variable total_operations to \(0\) to store the answer.
2. For \(i = 1, 2, \dots, N\), repeat the following process:
   • Compute the absolute difference \(|A_i - B_i|\).
   • Add the computed value to total_operations.
3. Output the final value of total_operations.

Complexity

• Time complexity: \(O(N)\)
  • The computation completes in linear time since each element of the sequences of length \(N\) is traversed exactly once.
• Space complexity: \(O(N)\)
  • This is the memory required to store the input sequences \(A, B\).

Implementation Notes

• Handling large inputs: Since \(N\) can be as large as \(2 \times 10^5\), in Python it is faster to read all input at once using sys.stdin.read().split() rather than repeatedly calling input().

• Computing absolute values: In Python, this can be written concisely using abs(a_i - b_i). The same result can also be achieved using conditional branching with an if statement, as shown in the provided code.

• Integer range: The total sum of the answer can become very large (up to approximately \(2 \times 10^{14}\)), but since Python’s integer type automatically handles arbitrary-precision integers, there is no need to worry about overflow.

  Source Code

import sys

def solve():
    # 標準入力からすべてのデータを読み込み、空白で分割してリストにします。
    # これにより、大量の入力データを高速に処理できます。
    input_data = sys.stdin.read().split()
    
    # 入力が空の場合は終了します。
    if not input_data:
        return
    
    # 最初の要素は数値列の長さ N です。
    n = int(input_data[0])
    
    # 高橋君の数値列 A はインデックス 1 から n まで、
    # 青木君の数値列 B はインデックス n+1 から 2n までに格納されています。
    # 各 i について、A_i と B_i を一致させるための最小操作回数は |A_i - B_i| です。
    # 全ての i についてその総和を求めます。
    
    total_operations = 0
    for i in range(n):
        a_i = int(input_data[i + 1])
        b_i = int(input_data[i + 1 + n])
        
        # 差の絶対値を加算します。
        diff = a_i - b_i
        if diff < 0:
            total_operations -= diff
        else:
            total_operations += diff
            
    # 結果を出力します。
    print(total_operations)

if __name__ == "__main__":
    solve()

This editorial was generated by gemini-3-flash-thinking.