1. Assign a unique random number to each element. Then, "number of subarrays such that every element in subarray appears even times" = "number of subarrays with XOR 0".
2. Compute the hash of each string, and the hash of its reverse.
3. Does biggestDigit mean most significant digit or the one with the highest value?
4. First of all, look up "Chebyshev distance". What does the set of all points at a distance  ≥ D look like? Once you've figured that out, try to answer queries of this type: "Is there an element smaller than A_x, y at a distance  ≥ D"?

First task can be done with hashing.

First you need to make all numbers in range [1, N]. Than you can save binary string S with length N for each prefix of array : S_i = 1 if we have odd amount of numbers i in current prefix, otherwise S_i = 0. Now for current prefix and binary string S we add amount of same strings in smaller prefixes. This looks as O(n²) time complexity and memory (or even worse) — but we can use hashing. We can save hash values for all prefix strings instead of whole string and this will save our memory space. Also we should notice that string for prefix x and string for prefix x + 1 are different only at one position, so we do not need to hash whole string again, just need to change hash value for that position. Total complexity O(n).

1. It may be hard to solve if you've never seen the idea before.

First compress the array to [1, 5*10^5], after that imagine binary array of pairness of the compressed length for every prefix. For example if the array was [1 2 2 1], pairness array would be:

   - for prefix [1] : [1 0];
   - for prefix [2] : [1 1];
   - for prefix [3] : [1 0];
   - for prefix [4] : [0 0];

Now, string [s_i, s_i + 1, ...s_j] is "good" for the task iff pariness arrays for prefix[i-1] and prefix[j] are equal. Now since those two arrays may be hard to compare for every [i, j], it would be good to hash them.

With generated hashes of those "binary strings" it should be easy to solve the task. Generating those hashes should take O(N(logN+F)), where F is for Hashing.

Problem 2: The order of concatenation matters (for example, b and bc).

1. For each string, compute the suffixes that are palindrome (using hashing, manacher, etc).
   
2. Add the strings in a trie. And for each node, store the number of strings where this position is followed by palindrome suffix (for example in the string, abdkkmkk the nodes for positions 3, 6, 7 and 8 (1-indexing) are followed by palindrome suffixes).
   
3. For each string, match and find the node of its reverse and add the answer.
   Note: this solution will calculate strings abc, and cba twice but will count abdkkmkk and dba once because of the order of concatenation. We can, however, avoid double counting if necessary.
   

Problem 4:

1. Transform every point (X, Y) to (X + Y, X - Y). This changes the distance metric from Manhattan to Chebyshev (i.e. D = max(Δ X, Δ Y) instead of D = Δ X + Δ Y).
   
2. Create a segment tree for the N rows and a segment tree for the N columns, where each node store the minimum value in the rows (or columns) between [L, R]. Also a segment tree for each row and for each column where each node contain the minimum value in the range [L, R] in the corresponding row (or column).
   
3. For the second query, update the corresponding row and column segment tree. Then update the segment tree for the rows and the other for the columns.
   
4. For the first query, binary search on the distance D. The candidate points are in a range of rows [0, X - D] and [X + D, N] or the range of columns [0, Y - D] and [Y + D, N]. Find the minimum and check that it's less than A[X][Y].
   Note: we can add constant C to X - Y to avoid negative array indices.