| **Note: This is the harder version of [Chapter 1](https://www.facebook.com/codingcompetitions/hacker-cup/2022/round-2/problems/A1). This version involves an array of integers instead of a string, and the array may change with updates.** | |
| An array is *perfectly balanced* if its length is even, and the first half of the array can be shuffled to make the array a palindrome. For example, \([15,2,15,2]\) and \([7,5,5,7]\) are perfectly balanced, but \([7,5,3,1,3,5,7]\) and \([3,1,1,3,2,3]\) are not. | |
| An array is *almost perfectly balanced* if you can delete exactly one element from it to make it perfectly balanced. Some examples are \([1, 2, 3, 4, 4, 5, 1, 3, 2]\), \([1]\), and \([2, 2, 2, 3, 2]\). | |
| {{PHOTO_ID:532712048616543|WIDTH:700}} | |
| You are given a larger template array \(A_1 ... A_N\) of length \(N\), along with \(Q\) events, the \(i\)th of which is one of the following two formats: | |
| - \(1\) \(X_i\) \(Y_i\): set \(A_{X_i}\) to \(Y_i\). | |
| - \(2\) \(L_i\) \(R_i\): check whether the subarray \(A_{L_i..R_i}\) is almost perfectly balanced. | |
| For how many type-2 queries is the subarray almost perfectly balanced? | |
| # Constraints | |
| \(1 \le T \le 85\) | |
| \(1 \le N \le 10^6\) | |
| \(1 \le A_i \le 10^6\) | |
| \(1 \le Q \le 10^6\) | |
| \(1 \le X_i \le N\) | |
| \(1 \le Y_i \le 10^6\) | |
| \(1 \le L_i \le R_i \le N\) | |
| The sum of \(N\) across all test cases is at most \(4{,}000{,}000\). | |
| The sum of \(Q\) across all test cases is at most \(4{,}000{,}000\). | |
| # Input Format | |
| Input begins with a single integer \(T\), the number of test cases. For each test case, there is first a line containing a single integer \(N\). Then, there is a line containing \(N\) space-separated integers \(A_1, ..., A_N\). Then, there is a line containing a single integer \(Q\). Then, \(Q\) lines follow, the \(i\)th of which contains three space-separated integers, either "\(1\) \(X_i\) \(Y_i\)" or "\(2\) \(L_i\) \(R_i\)". | |
| # Output Format | |
| For the \(i\)th test case, output a single line containing `"Case #i: "`, followed by a single integer: the number of queries which are an almost perfectly balanced subarray. | |
| # Sample Explanation | |
| In the first case, the template array is \([2,1,5,1,5,1]\). | |
| For the first query, the subarray is \([1,5,1,5,1]\). You can delete the second \(1\) to get \([1,5,5,1]\), which is a palindrome. Thus, \([1,5,1,5,1]\) is an almost perfectly balanced subarray. | |
| For the second query, the subarray is \([2,1,5,1,5]\). You can delete the \(2\) to get \([1,5,1,5]\) then reorder the first half of the array to get \([5,1,1,5]\), which is a palindrome. Thus, \([2,1,5,1,5]\) is an almost perfectly balanced subarray. | |
| For the third query, the subarray is \([2,1,5]\). You cannot delete any element to get an almost perfectly balanced subarray. | |
| The next two events are updates, after which the template array is \([5, 5, 5, 1, 5, 1]\). | |
| For the fourth query, the subarray is \([5,5,5]\). You can delete any element to get \([5,5]\), which is a palindrome. Thus, \([5,5,5]\) is an almost perfectly balanced subarray. | |
| The fifth, sixth, eighth, and tenth queries are also almost perfectly balanced subarrays, so the final answer is \(7\). | |