While I get to the organizers for editorials, here are the short solution outlines which you can refer to for solving the problem.

1.$ ext{KCHESS-}$Create a hash of positions which are near to king- 3*3 matrix. And after that check whether all the positions are attacking or not.

2.PNTWLL- The last paint will definitely exist on the wall. So we just have to find the increasing sequence from reverse and count it.Moreover to keep the colors distinct, we insert the color id in a set stl and at the end print the set size. Another approach can be using stack as suggested by ____(guess who :p) using stack is possible, where we can just push Ai to stack, until you encounter a element greater than it. Once you find Aj, such that Aj> top of stack, pop top of stack until its empty or Aj< top of stack.

3.SLAEL- Thanks to @Arjun Arul for pointed a noteworthy solution - Find and store all indices of elements >K. Say we stored them in array A. Now find longest length between two such values such that there is exactly 1 element >K in between, which, precisely, is A[i+2]-A*. With little modification to above, we cna handle case of multiple maximums in a range- simply dont add the maximum if its equal to top of stack or is equal to most recently inserted maxima.

4. OLDFAR- We are proposing a dynamic programming solution for this problem. For a matrix “mat” with dimensions N*M

a. dp*[j] represents the maximum sum that can be obtained by traversing a ‘L’ shaped path formed from the coordinates, (i,j), (x,j) and (x,M) where (i<= x<=N) , for the submatrix with top-left corner at i,j and bottom right corner at N,M.

b. revCum*[j] represents the sum, mat*[j]+mat*[j+1]+mat*[j+2]...............mat*[M]

c. dp*[j] can be calculated as- dp*[j] = mat*[j] + max(dp[i+1][j],revCum*[j+1])(Base cases can be handled accordingly)

d. After the dp and revCum have been calculated, the matrix can then be traversed and answer can be calculated using

ans=max(ans, revCum*[j]+dp[i+1][j])

5.CTOUR- The problem can be solved using LCA and Kadane’s Algorithm on trees.

**Preprocessing steps:**

Profit from root to all the nodes - profit[n].

For calculating LCA in log(n).

Using kadane’s algorithm (top down), calculate the max profit for each node, if we are at the node and go towards the root and come back - up[n].

Using kadane’s algorithm (bottom-up) calculate the max profit for each node, if we are at the node and go towards downwards and come back - down[n].

**Calculation steps:**

Every query can be answered in O(log(n)).

There are three cases.

a. If LCA(A,B) != A or B. Then we have only one choice- going from A to LCA(A,B), then towards root to some extent and then to B. The total amount we can gain is profit[A] + profit** - 2*profit[LCA(A,B)] + 2*up[LCA(A,B)].

b. If LCA(A,B) = A. Then we have two choices- going upwards from A and back, or going downwards from B and back. The total amount we can gain is profit** - profit[A] + 2*max(up[A],down**).

c. If LCA(A,B) = B. Then we have two choices- going upwards from B and back, or going downwards from A and back. The total amount we can gain is profit[A] - profit** + 2*max(up**,down[A]).