CHEFSUBA - Editorial

Practice

Contest

Author: Dmytro Berezin

Tester: Pawel Kacprzak and Misha Chorniy

Editorialist: Bhuvnesh Jain

EASY-MEDIUM

Prerequisites

Segment trees, Deque, Rotation trick

Problem

You are given an array A consisting of 0 and 1. You need to perform 2 type of queries of the array.

1. Find the maximum number of 1’s in the array covered by frame having size less than or equal to k
2. Shift the array to the right by 1 element. (circular rotation)

Quick Explanation

Remove the rotation part in problem by duplicating the array. Pre-compute the answer for each window of size less than or equal to k. Use segment trees to answer the maximum in a range.

Explanation

Let us first remove the query regarding rotation from the problem. This is a known trick where we remove the rotation using duplication of the array. To consider this aspect, see this example below :

Let array A be \{1, 0, 0, 1, 1\}. Duplicate this array i.e. \{1, 0, 0, 1, 1, 1, 0, 0, 1, 1\} and call it as B. Now, you can see that we can obtain all the arrays possible after rotation. They are just contiguous sub-arrays of length n in the above array B. For example, after 2 rotations, we can consider the subarray from position 3 to 7 as the required array. (0-based indexing)

Now, for the rotation query, we just need to handle the starting position in the above array B. So, these queries can be handled in O(1)

Once, we have removed the rotations part from the problem, we can pre-compute the number of 1’s in window of size k for all sub-arrays in B. Also, since we want to maximise the number of 1’s in the frame, we can always greedily chose frame of size k only. Doing this in a naive way will take complexity O(n^2), as we will loop over sub-arrays and each sub-array will take O(n) in worst case. We can using sliding window concept here to calculate the number of ones in all frames of size k. The logic behind this is as follows :

First we compute the answer for all positions which are less the k. After that, suppose we want to find the answer for a position starting at, say x and ending at (x+k-1). We see that only one element moves out of the window and only one element enters the windows as we slide it. Thus, these operations can be done in O(n). Below is a pseudo code for it.

``````
sum[0] = 0
for i in 1 to k:
sum[i] = sum[i-1] + b[i]
for i in k+1 to 2*n:
sum[i] = sum[i-1] + b[i] - b[i-k]

``````

For the sample array B given above and choosing k = 3, the sum array will look like \{1, 1, 1, 1, 2, 3, 2, 1, 1, 2\}.

Now, once we have calculated all the above sums, the question just reduces to finding the windows with maximum sum. Now, if the window is of size greater than or equal to the array size, then the answer is always the number of ones in the array else the answer is the maximum sum we can obtain by starting the window from 1 to (n-k+1). These range maximum queries can be easily with segment trees, sparse tables or in this specific cases using deques.

For handling the above minimum queries using segment trees or sparse table, one can refer to this editorial at topcoder . For understanding a better algorithm, which uses deque and works in O(n), one can refer to this problem from Spoj.

Time Complexity

O(n \log{n}), if using segment trees / sparse tables

O(n) if using deques

Setter’s solution

Tester’s solution

Editorialist solution

4 Likes

this was a nice question and definitely not a easy one, I wonder how it got so many submissions,Please check for any cases of plagiarism or cheating.

i used a heap since i didn’t know segmented trees. and initially before rotation two pointers one at k-1(0 based) and n-1, subtract the pointers whenever rotation occurs and add n-1 whenever the become less than 0. Avoids the use of B.

I did exactly as above using segment trees and checked for many cases and it works perfectly

But my solution was getting WA in two tasks of first subtask. When I changed the place of declaration of the segment tree array, I got one AC but for one task it was still giving WA.

Can anyone help in finding what’s wrong. Thanks.

https://www.codechef.com/viewsolution/13602948

I solved this problem without using segment tree, heap, deques, sparse table or any other special data structure. https://www.codechef.com/viewsolution/13623167

1 Like

My segment tree solution was getting TLE. Here is the solution. Could someone please help in pointing out the error. Thanks in advance.

Solution:https://www.codechef.com/viewsolution/13617713
Concept:http://www.geeksforgeeks.org/sliding-window-maximum-maximum-of-all-subarrays-of-size-k/
Time complexity: O(n)
Space complexity: O(n)(dynamic programming) + O(k) (for dequeue where k is frame size)
I converted this problem to one where we have to find maximum in window of size k along with principle of dynamic programming. Main task is you have to generate array containing total one’s in a window. You can see my solution. I got full 100 points.

2 Likes

@pmj642_coder

I think it is wrong because you have not checked the condition when k will be greater than equal to n.Correct me if i am wrong.

This was a great problem. I took the the deque approach after referring to this link. With some minor changes, and a check for k>n, it worked. For some reason though, my sub-task testcases were failing with the deque, so I had to use brute force for n<1000. Here’s my solution.

@devilhector use iterative segment trees recursive calls on such high constraints is not gonna work.
I’ve used the same approach you can view my solution https://www.codechef.com/viewsolution/13613563

https://www.codechef.com/viewsolution/13559652

solve this using priority queue and simple obserations

Thanks

Please check this solution, it doesn’t give the required answer on running!
Used the recursive Segment trees!

I solved this problem by precalculating all the possible answer as there cannot be more than N different answers.

here is my solution.

https://www.codechef.com/viewsolution/13531464
I think it is better Approach !

I did this Question using sliding windows by precompute values and deque to get the maximum value

O(n) solution can be done without deques, using frequency table to get the max. Since values are 0 and 1 only, the max value changes by at most 1.

2 Likes

Here is my solution: https://www.codechef.com/viewsolution/13634699 as same as author solution but I don’t know why my solution got wrong. Please tell me why I got wrong. Thank you.

One question guys!
Is the complexity O(n) for the entire subtask or O(n) for each querie?