int array[2][3] = {
    {0, 1, 2},
    {3, 4, 5}
};

0x7ffee4065820 0x7ffee4065824 0x7ffee4065828
0x7ffee406582c 0x7ffee4065830 0x7ffee4065834

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        // target 位于左闭右闭区间 [left, right]
        int right = nums.size() - 1;

        // 当 left == right 时，[left, right] 仍然有效，因此使用 <=
        while (left <= right) {
            // 防止溢出，等同于 (left + right) / 2
            int middle = left + ((right - left) / 2);

            if (nums[middle] > target) {
                // target 位于左区间 [left, middle - 1]
                right = middle - 1;
            } else if (nums[middle] < target) {
                // target 位于右区间 [middle + 1, right]
                left = middle + 1;
            } else {
                // 找到目标值，返回下标
                return middle;
            }
        }

        // 未找到目标值
        return -1;
    }
};

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        // target 位于左闭右开区间 [left, right)
        int right = nums.size();

        // 当 left == right 时，[left, right) 无效，因此使用 <
        while (left < right) {
            int middle = left + ((right - left) >> 1);

            if (nums[middle] > target) {
                // target 位于左区间 [left, middle)
                right = middle;
            } else if (nums[middle] < target) {
                // target 位于右区间 [middle + 1, right)
                left = middle + 1;
            } else {
                // 找到目标值，返回下标
                return middle;
            }
        }

        // 未找到目标值
        return -1;
    }
};

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slowIndex = 0;

        for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {
            if (nums[fastIndex] != val) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }

        return slowIndex;
    }
};

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        int k = A.size() - 1;
        vector<int> result(A.size(), 0);

        // 最后仍需处理 i == j 时的元素，因此使用 <=
        for (int i = 0, j = A.size() - 1; i <= j;) {
            if (A[i] * A[i] < A[j] * A[j]) {
                result[k--] = A[j] * A[j];
                j--;
            } else {
                result[k--] = A[i] * A[i];
                i++;
            }
        }

        return result;
    }
};

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int result = INT32_MAX;
        int sum = 0;        // 滑动窗口内元素之和
        int i = 0;          // 滑动窗口起始位置
        int subLength = 0;  // 滑动窗口长度

        for (int j = 0; j < nums.size(); j++) {
            sum += nums[j];

            // 使用 while 持续更新起始位置，并判断子数组是否符合条件
            while (sum >= s) {
                subLength = j - i + 1;
                result = result < subLength ? result : subLength;
                // 不断变更 i，缩小滑动窗口
                sum -= nums[i++];
            }
        }

        // result 未被更新，说明没有符合条件的子数组
        return result == INT32_MAX ? 0 : result;
    }
};

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0));
        int startx = 0, starty = 0;  // 每一圈的起始位置
        int loop = n / 2;            // 需要循环的圈数
        int mid = n / 2;             // 矩阵中心位置
        int count = 1;               // 当前待填入的数值
        int offset = 1;              // 控制每条边遍历的长度
        int i, j;

        while (loop--) {
            i = startx;
            j = starty;

            // 上边：从左到右（左闭右开）
            for (; j < n - offset; j++) {
                res[i][j] = count++;
            }
            // 右边：从上到下（左闭右开）
            for (; i < n - offset; i++) {
                res[i][j] = count++;
            }
            // 下边：从右到左（左闭右开）
            for (; j > starty; j--) {
                res[i][j] = count++;
            }
            // 左边：从下到上（左闭右开）
            for (; i > startx; i--) {
                res[i][j] = count++;
            }

            startx++;
            starty++;
            offset++;
        }

        // n 为奇数时，单独为矩阵中心赋值
        if (n % 2) {
            res[mid][mid] = count;
        }

        return res;
    }
};

#include <cstdio>
#include <vector>

using namespace std;

int main() {
    int n, a, b;
    scanf("%d", &n);

    vector<int> vec(n);
    vector<int> prefix(n);
    int prefixSum = 0;

    for (int i = 0; i < n; i++) {
        scanf("%d", &vec[i]);
        prefixSum += vec[i];
        prefix[i] = prefixSum;
    }

    while (scanf("%d%d", &a, &b) == 2) {
        int sum = (a == 0) ? prefix[b] : prefix[b] - prefix[a - 1];
        printf("%d\n", sum);
    }

    return 0;
}

#include <algorithm>
#include <climits>
#include <cstdlib>
#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n, m;
    cin >> n >> m;

    int sum = 0;
    vector<vector<int>> vec(n, vector<int>(m, 0));

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> vec[i][j];
            sum += vec[i][j];
        }
    }

    // 统计每行的价值之和
    vector<int> horizontal(n, 0);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            horizontal[i] += vec[i][j];
        }
    }

    // 统计每列的价值之和
    vector<int> vertical(m, 0);
    for (int j = 0; j < m; j++) {
        for (int i = 0; i < n; i++) {
            vertical[j] += vec[i][j];
        }
    }

    int result = INT_MAX;

    int horizontalCut = 0;
    // 分割线必须位于两行之间，因此不枚举最后一行之后的位置
    for (int i = 0; i < n - 1; i++) {
        horizontalCut += horizontal[i];
        result = min(result, abs(sum - 2 * horizontalCut));
    }

    int verticalCut = 0;
    // 分割线必须位于两列之间
    for (int j = 0; j < m - 1; j++) {
        verticalCut += vertical[j];
        result = min(result, abs(sum - 2 * verticalCut));
    }

    cout << result << endl;
    return 0;
}

// 单链表节点
struct ListNode {
    int val;        // 节点中存储的元素
    ListNode* next; // 指向下一个节点

    ListNode(int x) : val(x), next(nullptr) {}
};

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // 连续删除值等于 val 的头节点，注意这里使用 while 而非 if
        while (head != nullptr && head->val == val) {
            ListNode* tmp = head;
            head = head->next;
            delete tmp;
        }

        // 删除非头节点
        ListNode* cur = head;
        while (cur != nullptr && cur->next != nullptr) {
            if (cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }

        return head;
    }
};

ListNode* dummyHead = new ListNode(0);
dummyHead->next = head;
ListNode* cur = dummyHead;

class MyLinkedList {
public:
    struct LinkedNode {
        int val;
        LinkedNode* next;

        LinkedNode(int val) : val(val), next(nullptr) {}
    };

    MyLinkedList() {
        _dummyHead = new LinkedNode(0);
        _size = 0;
    }

    ~MyLinkedList() {
        while (_dummyHead != nullptr) {
            LinkedNode* tmp = _dummyHead;
            _dummyHead = _dummyHead->next;
            delete tmp;
        }
    }

    int get(int index) {
        if (index < 0 || index >= _size) {
            return -1;
        }

        LinkedNode* cur = _dummyHead->next;
        while (index--) {
            cur = cur->next;
        }

        return cur->val;
    }

    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }

    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;

        while (cur->next != nullptr) {
            cur = cur->next;
        }

        cur->next = newNode;
        _size++;
    }

    void addAtIndex(int index, int val) {
        if (index > _size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }

        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;

        while (index--) {
            cur = cur->next;
        }

        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }

    void deleteAtIndex(int index) {
        if (index < 0 || index >= _size) {
            return;
        }

        LinkedNode* cur = _dummyHead;
        while (index--) {
            cur = cur->next;
        }

        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        _size--;
    }

private:
    LinkedNode* _dummyHead;
    int _size;
};

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;

        while (cur != nullptr) {
            // 保存下一个节点，避免改变 cur->next 后丢失后续链表
            ListNode* temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }

        return pre;
    }
};

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;

        ListNode* fast = dummyHead;
        ListNode* slow = dummyHead;

        // 让 slow 最终停在待删除节点的前一个节点
        for (int i = 0; i <= n; i++) {
            fast = fast->next;
        }

        while (fast != nullptr) {
            fast = fast->next;
            slow = slow->next;
        }

        ListNode* tmp = slow->next;
        slow->next = tmp->next;
        delete tmp;

        ListNode* newHead = dummyHead->next;
        delete dummyHead;
        return newHead;
    }
};

class Solution {
public:
    ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0;
        int lenB = 0;

        while (curA != nullptr) {
            lenA++;
            curA = curA->next;
        }
        while (curB != nullptr) {
            lenB++;
            curB = curB->next;
        }

        curA = headA;
        curB = headB;

        // 保证 curA 指向较长链表，lenA 为较大长度
        if (lenB > lenA) {
            swap(lenA, lenB);
            swap(curA, curB);
        }

        // 将两个链表按末尾对齐
        int gap = lenA - lenB;
        while (gap--) {
            curA = curA->next;
        }

        while (curA != nullptr) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }

        return nullptr;
    }
};

class Solution {
public:
    ListNode* detectCycle(ListNode* head) {
        ListNode* fast = head;
        ListNode* slow = head;

        while (fast != nullptr && fast->next != nullptr) {
            slow = slow->next;
            fast = fast->next->next;

            // 快慢指针相遇，说明链表中存在环
            if (slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;

                // 从相遇点和头节点同时出发，再次相遇处就是环入口
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }

                return index2;
            }
        }

        return nullptr;
    }
};

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = {0};

        for (char ch : s) {
            // 只需计算字符相对 'a' 的偏移量
            record[ch - 'a']++;
        }
        for (char ch : t) {
            record[ch - 'a']--;
        }

        for (int count : record) {
            if (count != 0) {
                return false;
            }
        }

        return true;
    }
};

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> numsSet(nums1.begin(), nums1.end());
        unordered_set<int> resultSet;

        for (int num : nums2) {
            if (numsSet.find(num) != numsSet.end()) {
                resultSet.insert(num);
            }
        }

        return vector<int>(resultSet.begin(), resultSet.end());
    }
};

unordered_set<int> numsSet(nums.begin(), nums.end());