### Wind_Eagle's blog

By Wind_Eagle, 4 weeks ago,

Will we, will you...
Can we, can you, can we change?

1562A - The Miracle and the Sleeper

Hint 1
Hint 2
Solution
Code C++ (Wind_Eagle)

1562B - Scenes From a Memory

Hint 1
Hint 2
Solution
Code C++ (Wind_Eagle)

1562C - Rings

Hint 1
Hint 2
Solution
Code C++ (Wind_Eagle)

1562D1 - Two Hundred Twenty One (easy version)

Hint 1
Hint 2
Hint 3
Solution
Code C++ (Wind_Eagle)

1562D2 - Two Hundred Twenty One (hard version)

Hints 1-3
Hint 4
Hint 5
Solution
Code C++ (Wind_Eagle)
Interesting question

1562E - Rescue Niwen!

Hint 1
Hint 2
Hint 3
Solution
Code C++ (Wind_Eagle)
Interesting question

1562F - Tubular Bells

Hint 1
Hint 2
Hint 3
Hint 4
Hint 5
Solution
Code C++ (Wind_Eagle)

• +158

 » 4 weeks ago, # |   +14 Thanks for the great contest and the fast editorial :)
 » 4 weeks ago, # | ← Rev. 2 →   -39 Wish all div2 contest were like this. Quite standard contest.
•  » » 4 weeks ago, # ^ |   +12 Which problems were standard lol?
•  » » » 4 weeks ago, # ^ |   +52 I think he/she forgot to add "high" before standard.
•  » » » 4 weeks ago, # ^ | ← Rev. 2 →   +16 I mean, everyone in the contest has his level of difficulty to solve but definitely not last 2 problems.
 » 4 weeks ago, # |   0 Can you still provide code for problem F? Even though it might be incomprehensible, it might be used to stress test our solutions. Or maybe you can provide some participant's code which is more readable.
•  » » 4 weeks ago, # ^ |   +1 Well, if you want...
 » 4 weeks ago, # |   +16 Unable to parse markup [type=CF_MATHJAX] error in D1
•  » » 4 weeks ago, # ^ |   +5 Will fix it soon, thank you!
 » 4 weeks ago, # |   +14 Thank you for the nice round! The problems were very interesting, and C's cases using the zeroes was pretty tricky in particular. However, D1's solution was pretty easily noticed by me and some others because of the samples (the observation that all answers were either 0, 1, or 2). Maybe giving less samples would "hide" this fact?Problem statements were clear and concise, and from what I did, problems are roughly in increasing order of difficulty!Again, thanks for the round, and I hope you write another one soon! (pikachu-themed plsssss :D)
•  » » 4 weeks ago, # ^ |   +13 I've thought about that, but left this sample because I have worried about the difficulty of D1. I decided to make it easier doing this.
 » 4 weeks ago, # |   -34 Damn, I found out that in problem D1, there are only 0, 1, 2 but I forgot casting it to abs
 » 4 weeks ago, # |   0 Is D1 visible?
 » 4 weeks ago, # |   0 Unable to parse markup [type=CF_MATHJAX]
•  » » 4 weeks ago, # ^ |   0 I will fix it soon.
•  » » » 4 weeks ago, # ^ |   0 Thank you for the nice round and the fast fixing.Your round and editorial will benefit us a lot !
 » 4 weeks ago, # |   +3 What's more,In D2,the hint was corresponding to "C1" ,which should be D1
•  » » 4 weeks ago, # ^ |   +3 Addition:the Solution We will use the facts already obtained, given in the solution of problem C1.-->D1
 » 4 weeks ago, # |   +1 How will we solve B for , what is the minimum number of digits that can be removed from the number so that the number becomes not prime,
•  » » 4 weeks ago, # ^ |   +24 This task is harder than checking is the number prime.
•  » » 3 weeks ago, # ^ |   0 We could do it by dp , ie. in each step we can either remove a digit or move to next one . 1)If at any recursion we find that the string is now not prime we will return it (BASE COND). 2)We recursively call the function with the modified string after the removal of digit and dont increase the index value
 » 4 weeks ago, # |   0 Can someone help me figure out why my O(n + q*logn) solution failed for D2? The time complexity should be same as the editorial solutionMy approach was a little different from the editorial however 1) While precomputing I store for all prefix sum values v the indices of elements where the prefix sum is equal to v 2) in the binary search phase I calculate the prefix sum of the element to be removed (this will be midpoint of prefix sums of left and right boundary), and then binary search for an index with that prefix sum in the data structure from 1https://codeforces.cc/contest/1562/submission/127124443
•  » » 4 weeks ago, # ^ |   +3 You copied vector, so it's O(n + qn). auto reqv = (some vector) creates NEW vector. Use references to not copy vector.Also, endl is really slow. (It flushes your output — 6*10^5 times in worst case!) Use '\n'.https://codeforces.cc/contest/1562/submission/127153639
•  » » » 4 weeks ago, # ^ |   0 oh wow, really need to be more careful with these details. thank you!
•  » » » 4 weeks ago, # ^ | ← Rev. 2 →   +3 hey man, just wanted to thank you again for digging through my code and finding this- i made the same mistake today but was able to catch it because i remembered your comment! :D
 » 4 weeks ago, # | ← Rev. 2 →   0 why does this solution fail the pretest 2 :( 127132103, Problem C.
•  » » 4 weeks ago, # ^ |   +4 Try this case: Case171110010
•  » » » 4 weeks ago, # ^ | ← Rev. 2 →   +1 oh noooo but thank you an unnecessary for loop
 » 4 weeks ago, # |   +35 Thanks for the great problemset, really liked the fun constructives :D
 » 4 weeks ago, # | ← Rev. 4 →   +58 I have an offline solution for D which works in O(N + Q). Precompute the prefix array as in D1. Then sort on the values by l (by bucket sort i.e. query[l].pb({r, q}), where q is the idx of this query). if sign variable sum is zero, then just continue. Now there are two cases. Case 1: If r-l+1 is odd : We want to find an index idx, such that then the sign variable sum between l and idx-1 and idx+1 to r should be equal. Because when we remove idx, the sum after those elements just alternates. This can be written as pre_sum[idx — 1] — pre_sum[l-1] = pre_sum[r] — pre_sum[idx]. Now, we can rewrite this as pre_sum[l-1] + pre_sum[r] = pre_sum[idx] + pre_sum[idx-1]. So for a given l, r, we can find any idx such that l <= idx <= r and the above condition holds.Case 2: if r-l+1 is even, we can remove r, do r-- and then it becomes case 1. We can create an hash map of vectors to store the adjacent pre_sum's index. i.e. map[pre_sum[i-1] + pre_sum[i]].pb(i);We also create an index hash map which stores for this key what index we are at in the vector hashmap. Then since the queries are sorted by l, we can just do like 2 pointer approach until we find index > l for the key in the vector hashmap. Here the key is sum[l-1] + sum[r]. Upd : added the sortig method to get O(n+Q) complexity.
•  » » 4 weeks ago, # ^ |   +21 Correct me if I'm wrong... But sorting in the very first step will take O(Nlog(N)) time.Until and unless you use some radix sort type of algorithm to sort but I think that would be an overkill.
•  » » » 4 weeks ago, # ^ |   +8 Just put the queries in buckets by $l$. Then loop over the indices and do the same above.I think I have an easier implementation. Let $ps$ be the prefix sum array. Notice that for each query $(l, r)$, we can determine $k$ and need to find some index $x$ such that $l \leq x \leq r$ and $ps_x = k$.Then we can have an offline solution to answer all queries $(l, r, k)$. Put the queries into buckets by $r$. Then loop over $1 \dots N$ and maintain last occurrence of each prefix sum value. Due to the proven existence of our target index, the last occurrence before $r$ must meet our requirement.Since $|ps_x| \leq N$, this solution works in $O(N + Q)$.
•  » » » » 4 weeks ago, # ^ |   0 I think such simplification can not be done.Consider a sequence whose sum is 2m-1, m>0:We not only want $ps_x$ = m-1, $v_x=1$ is also required.
•  » » » » » 4 weeks ago, # ^ | ← Rev. 2 →   0 No, it is possible to solve problem D2 in $O(n + q)$ and I too have discovered the same solution with asymptotics $O(n + q)$ as mentioned aboved. Taking offline queries and storing them in a list of their corresponding $r$ values, can do it.Here's the link to my submission 127266077.Even tho it takes $483 ms$, whereas my $O(n + q.logn)$ takes $358 ms$. This might be because setter didn't included required test cases in the test sets in order to differentiate between the execution time of the two solutions. Or maybe there's some problem with the way I've implemented.
•  » » » » » 4 weeks ago, # ^ |   0 A tricky question.Assume $m > 0$. Actually it can be shown that for the last occurrence where $ps_x = m - 1$, there must be $v_x = 1$, otherwise there will be another position $x < y < r$ such that $ps_y = m - 1$. My in-contest solution made use of this conclusion, besides that I tried to find the first occurrence online.Another way to avoid this discussion, is to find the position where $ps_x + ps_{x+1} = 2m - 1$. This idea is already discussed in this comment, and you can see the implementation in this comment below.
•  » » » » » » 4 weeks ago, # ^ |   0 Yes you are right.I only looked at your first claim, and didn't notice that the trick of finding the last occurrence will account for this.Thanks for the clarification!
•  » » 4 weeks ago, # ^ |   0 Although it's O(N+QlgN), this approach made a very simple online solution :Ohttps://codeforces.cc/contest/1562/submission/127151337
•  » » 4 weeks ago, # ^ |   0 I think you can use an arrary but not a hashmap, that will be faster.
•  » » 4 weeks ago, # ^ |   +8 Thank you for sharing this solution!
 » 4 weeks ago, # |   +4 Loved this contest.
 » 4 weeks ago, # |   +20 It looks like F editorial is slightly overcomplicated. For n > 100 it suffices to iterate with for loop and ask for pairs (1, a[i]) for min(5000, n) pairs. Then take maximum prime number that ever occured as divisor of lcm. Using this get whole array in n operations. Or can you hack it?
•  » » 4 weeks ago, # ^ | ← Rev. 2 →   +8 I know that there exists very simple solution. Just explain to me please: if we have not the biggest prime number, but a prime number p such that p < r/2, how can we get the whole array using this prime? I really don't know how to do this. But I know that this can be done somehow.
•  » » » 4 weeks ago, # ^ |   0 If n > 5000 it should be clear that we have very high chance of getting at least one prime > r / 2. Else we know all the primes and it is well known that there always exists prime between x and 2x for natural x, so it can't happen that the biggest prime is < r / 2.
•  » » » » 4 weeks ago, # ^ | ← Rev. 3 →   +13 A way to improve your chances more with the same approach is to first assume the permutation is randomly permuted. Than asking query(1,2), query(3,4), ..., query(9999,10000). (Or less, if n<10000)The biggest prime that's a divisor of one these queries is kept, and the pair where it was found. Now this big prime could be at either position i or i+1, we use one extra query to determine which one.Only if all the "big" ( > r/2) primes are not in the first 10000 elements of the permutation this will fail. The number of big primes is always more than $\frac{n}{200}$, because the largest prime gap under the constraints is less than 100. $P(fail) = P(\textrm{All big primes not in first 10000 elements}) \leq (1-\frac{10000}{n})^{n/200}$. For $n \in [10000,100000]$, this probability is always less than $10^{-22}$. (Actual probability is even lower).
•  » » » » » 4 weeks ago, # ^ | ← Rev. 3 →   0 Sorry, stll don't understand why there are more than $\frac{n}{200}$ big primes.
•  » » » » » » 4 weeks ago, # ^ | ← Rev. 3 →   0 Because $n=r-l+1$, $r$ is greater or equal than $n$. So the range where big primes could exist is $r- \frac{r}{2} = \frac{r}{2} \geq \frac{n}{2}$. For all numbers less than 200000, The biggest gap between two adjacent primes is 86. This means that after you move from some number 100 places to the right, you're guaranteed to get at least one prime. So the number of primes in the good region is at least $\frac{n}{2} \cdot \frac{1}{100} = \frac{n}{200}$. For my full solution:For $n<86$ it's not guaranteed that the region [l,r] contains a prime. So for this case, you query all pairs. If you want to know the number on position a_i, you can take $gcd(q_{i,1}, q_{i,2},...,q_{i,n})$. Only for n=3, there's a special case, where this doesn't work.For $n \geq 86$, you query pairs of positions like I described. Then you know the position and the value of a big prime. For all the other a_i's you can just put $a_i = \frac{q_{i,\textrm{position of big prime}}}{\textrm{big prime}}$Submission: AC
•  » » » » » » » 4 weeks ago, # ^ |   +8 Thank you, got it! Very short and nice solution :)
 » 4 weeks ago, # | ← Rev. 3 →   0 Thanks for the nice Round. But in problem F case $100  » 4 weeks ago, # | 0 Excuse me, but how can you prove (in problem D2) that by such binary searching we are always making a right move?  » 4 weeks ago, # | +1 D1 problem was very unfair. Like it was not suitable for D1. So many people are there who could not solve B and C but still solved D1 .Just because it was so evident from the example cases that the answer can only be 0 1 or 2. Rest of the contest was very good but i think some more thought could have been put into D1. D2 was very good.  » 4 weeks ago, # | 0 Thank you so much for fast editorial, the level of difficulty and question was excellent. I hope you will make more contest.  » 4 weeks ago, # | 0 The mathjax renders wrong at the second hint of 1562C. •  » » 4 weeks ago, # ^ | 0 Now it's fixed.  » 4 weeks ago, # | 0 How to prove A as stated in editorial? What I did was simply observing that any segment of length L = (r-l+1), will start giving same result(L-1) for max mod value after certain number. For Example if we consider a segment of length 5, it will always give result as 4 if l>=5. And if l<5 then result corresponding to l=4,3,2,1 is 3,3,2,2 respectively. From this I drawn a formula that for l  » 4 weeks ago, # | +18 I got WA on test 3 of problem F, but the judger said wrong answer The answer is wrong! (test case 300). However it is guaranteed that$ t \leqslant 20 $and the value$ t $of test 3 is$ 20 $. Also I can pass data of test 3 on my own PC.What's the meaning of the judger's comment? •  » » 4 weeks ago, # ^ | 0 Well, this is a bug, checker is showing incorrect test case. •  » » » 4 weeks ago, # ^ | 0 Fine. Thanks a lot.  » 4 weeks ago, # | ← Rev. 2 → +8 I have a little better solution of B, which is less guessy and more easy to come up with.1) Firstly if there is 1,4,6,8,9-> then you already got your answer. 2)Now, your string consists of 2,3,5,7 only. Now, if your string contains repeating characters, we are done since 22,33,55,77->all of them are divisible by 11.3)Now since there are no repeating characters up till now, the maximum length of your string can be at most 4.(since contains only 2,3,5 and 7).So you can brute force to check all possible combinations in 2^4=16 steps. 4) I think this solution is better if there can be cases in the problem in which the answer doesn't exists. •  » » 4 weeks ago, # ^ | 0 You are op sir.Wonderful solution. •  » » 4 weeks ago, # ^ | 0 https://codeforces.cc/contest/1562/submission/127398591 Check this out!  » 4 weeks ago, # | 0 https://codeforces.cc/contest/1562/submission/127156841 can anyone help I m not getting that at which test case my code is failing? •  » » 4 weeks ago, # ^ | 0 Test Case 24- 5 17333Your output — 2 33Correct output - 1 1 •  » » » 4 weeks ago, # ^ | 0 thank you •  » » 4 weeks ago, # ^ | +1 you solution fail for case when {1, 4, 6, 8, 9} is present at 0th index in string for ex: for 15, 47, many more •  » » » 4 weeks ago, # ^ | 0 yes thanks adarsh got it.  » 4 weeks ago, # | 0 Which Okami used string function to solve the E problem ? string function can automatically compare the string in Lexicographic order. So we just run a simple LIS,that will Ok.my code is down to the fourth point, I feel it is correct.The link is as follow : test This is my first asked question in the Codeforces, So maybe somewhere is wrong, %%%%% •  » » 4 weeks ago, # ^ | 0 I don't know where WA is, but your code will get TL sooner or later, as string comparasion works in O(n). •  » » » 4 weeks ago, # ^ | 0 Thank you. I just found out, I always thought it was$O(\log n)$hahaha  » 4 weeks ago, # | 0 127118923 wrong answer Integer 61 violates the range [1, 6] (test case 54) test case please. •  » » 4 weeks ago, # ^ | 0 UPD. I was missing a dam whitespace. ;(  » 4 weeks ago, # | ← Rev. 2 → +17 In problem E, I didn't quite understand the reasoning behind the fact that if the string$[l,r]$is present in the LIS, the following ones ($[l,r+1],\, \dots,\, [l,n]$) must be present too so I want to share the proof that I came up with.Firstly, we can observe that if$[l,r]$and$[l,r+k]$are present, all$[l,r+i],\ i 0 $, since we know that$s_1
•  » » 4 weeks ago, # ^ |   0 As your solution,the second situation "if $|s1|<|s2|...$" and maybe "The first character of $s1$ must be smaller than the first character of $s2$." in this situation also is right, so the rest of the prefixes of the suffix $[l_1,n]$ must smaller than $s2$，they can make contributions and not need delete. I understand other parts, It’s very good, it’s easier to understand than the solution, at least I understand it. Please answer my doubts,thanks
•  » » » 4 weeks ago, # ^ |   0 I'm not sure if I understand your doubt correctly but I think there are some things that I could clarify.What we actually want to prove is that there is a LIS of maximum length in which the "initial claim" holds. To do so I can assume that the LIS of maximum length does not fulfil this claim. In that case, I can take that LIS and modify it so that it fulfils the claim. Therefore I have reached a contradiction and there is a LIS of maximum length that fulfils the claim.Keep in mind that there might be other LIS of maximum length that do not follow that structure at all. All we need to know is that there is one that does.
•  » » 4 weeks ago, # ^ |   0 Hi, thank you for taking the time to write such a nice detailed proof. There's a part of your it that I don't understand, I'd really appreciate it if you could explain it to me. If |s1| < |s2|, my understanding is that we get rid of all the prefixes of [l1,r1] that existed in the LIS, so a maximum of r1 — l1 + 1 elements removed from the LIS. Afterwards, we add [l2, r2 + 1], [l2, r2 + 2] ... [l2, n], so n — r2 new elements added in. 1) How do you know that n — r2 > r1 — l1 + 1 ? 2) How do you know that these newly added in elements won't be in conflict with some other elements that came after [l2,r2] in the original LIS, creating the need for more removals. Or maybe I'm misunderstanding your proof. What exactly are you removing from the LIS and what are you replacing each removed element with?
•  » » » 4 weeks ago, # ^ | ← Rev. 2 →   0 Regarding your questions: The fact that $|s1|<|s2|$ should be enough because $r1-l1+1=|p|+|s1|$ and $r2-l2+1 =|p|+|s2|$ (just because of how $a_1$ and $a_2$ were split into the common prefix and "something else"). Now I want to replace all the prefixes of the suffix $[l_1,n]$ with prefixes of $[l_2,n]$ that are smaller than $[l_2,r_2]$. I can pick as many as I need from $[l_2,l_2], [l_2,l_2+1], \dots [l_2,r_2-1]$. All of those are valid since they will be greater than or equal to the corresponding ones from $[l_1,r_1]$ and are smaller than $[l_2,r_2]$. I should have enough because there are at most $r_1-l_1+1$ prefixes of $[l_1,n]$ in the LIS, this list has $r_2-l_2$ elements and $r_1-l_1+1 < r_2-l_2+1 \implies r_1-l_1+1 \le r_2-l_2$. They might be in conflict. If they happen to be I can repeat the process and delete the ones that I added (along with some more). Each time I delete and add elements I will get rid of a position in which there are two adjacent elements in the LIS with a different beginning such that the first one does not reach to the end of the string (does not end at $n$). Therefore we can just keep repeating the process until there are no such positions and then the LIS will adhere to the claim.
•  » » » » 4 weeks ago, # ^ |   0 Why n — r2 + 1 = |p| + |s2|?
•  » » » » » 4 weeks ago, # ^ |   0 Yup, that was wrong. Hopefully, I got it right this time.
•  » » » » » » 4 weeks ago, # ^ |   0 Alright, now I get it! Thanks a lot for the help.
•  » » 4 weeks ago, # ^ | ← Rev. 2 →   0 I didn't understand why you were assuming $a_1$ is strictly less than $a_2$. In LIS, as much as I know, it's enough for elements to be increasing not strictly increasing. So I guess $a_1 \leq a_2$ should be correct.
•  » » » 4 weeks ago, # ^ |   +5 Sure, but if they are equal you can simply replace $a_1$ and all of its prefixes with $a_2$ and all its prefixes since they will all be equal. I was probably thinking of a strictly increasing LIS when I wrote the proof
•  » » » » 4 weeks ago, # ^ |   0 Well, lets say $a_1$ equals c and $a_2$ equals c as well. And notice that there is no force for $l_2$ to be next to $l_1$. So in this case we have had selected $[l_1, l_1 + 1]$ and then $[l_2, l_2 + 1]$ and all of its suffixes. So what should we replace in this case?
•  » » » » » 3 weeks ago, # ^ |   0 Yeah, you’re right. There is no substitution that we can make without decreasing the size of the LIS. But I have revised my submission and the solution in the editorial and the LIS has to be strictly increasing (which I didn’t remember last night when I wrote the previous answer) so we shouldn’t run into this problem.
•  » » » » » » 3 weeks ago, # ^ |   0 Thanks for your response. I do agree that both editorial and your proofs are valid for strictly LIS. However, I see no clue in the problem statement for LIS to be strictly increasing. At this point, my guess is both increasing and strictly increasing LIS will have the same total answer in the problem.
•  » » 3 weeks ago, # ^ |   +5 If $|s_1|\ge |s_2|, \ldots$ If $|s_1|<|s_2|, \ldots$ I think this is confusing and it took me some time to understand it, so can I suggest that you change it to If $|s_1|>0, \ldots$ If $|s_1|=0, \ldots$ This is because as long as $|s_1|>0$, the first character of $s_1$ has to be smaller than the first character of $s_2$, so the only case this doesn't hold is when $s_1$ is an empty string.Thank you!
•  » » » 3 weeks ago, # ^ |   +5 At first I thought that changing the conditions would make it harder to realize why we do not run out of prefixes during the substituion step. But after rewriting that part I think it did end up being easier to understand so... thanks for the suggestion!
 » 4 weeks ago, # |   0 Thanks for the great contest!
•  » » 4 weeks ago, # ^ |   0 Thank you for participating!
 » 4 weeks ago, # |   0 I can't understand this sentence:then we can «drop» the prefixes of the suffix $[l1 . . n]$Are $[l1,n]$ or $[l1,l1+1],[l1,l1+2],[l1,l1+3]...[l1,n]$ discarded in the solution
•  » » 4 weeks ago, # ^ |   -6 Yes, since $|s_1| \le |s_2|$, we can get a better answer.
•  » » » 4 weeks ago, # ^ |   0 So from what I understand we are trying to prove that If the largest increasing subsequence has a substring [l_2 ... r_2], then it also has a substring [l_2 ... n]. and in this step we move all suffixes of [l_1 ... n] included in a theoretical longest common prefix to [l_2 ... n]. But how do we know that we took the prefix [l_2 ... n]?
•  » » » » 4 weeks ago, # ^ |   0 It just proved this property that if the string $[l,r]$ is present in the LIS, the following ones $([l,r+1], ..., [l,n])$ must be present too.It's proof by contradiction. Assume the optimal answer doesn't meet this condition, we can get a better answer by removing all prefixes of $[l_1, n]$ and adding the prefixes of $[l_2, n]$, so there is a contradiction. Taking the prefixes of $[l_2, n]$ is part of the proof, it doesn't mean we must take prefixes of $[l_2, n]$, or taking prefixes of $[l_2, n]$ can lead to the optimal answer.
•  » » » » » 4 weeks ago, # ^ | ← Rev. 2 →   0 Ok I was still a bit confused so I just tried to write everything up, the main point I was missing was that $s_1$ is a substring of $s_2$ so your method will work. Maybe you were just doing it a different way though since there quite a few different details. Suppose we have two consecutive elements $s_1 = [l_1, r_1]$, $s_2 = [l_2, r_2]$ in a longest increasing sequence (In particular, $s_1 < s_2$ lexicographically) with $l_1\neq l_2, r_1\neq n$. We will show that there is another optimal sequence without this property. If $s_{2}' = [l_1, r_1 + 1] \leq s_2$ lexicographically, we can replace $s_2$ with it to get another LIS. Do this while possible. Thus $s_1 = [l_1, r_1] < s_2 < [l_1, r_1 + 1] = s_2'$. This implies that $s_1$ is a substring of $s_2$. Since $s_1$ is a substring of $s_2$, we can do like you explained and move prefixes of $s_1$ to $s_2$.
 » 4 weeks ago, # |   0 in problem why cannot be b1>0 and bn>0 or b1<0 and bn<0 please explain.
•  » » 4 weeks ago, # ^ |   0 let's define f(l,r) = a[l] — a[l + 1] + ... -1 ^ (r — l) * a[r] then b1 = f(2 , n) , bn = f(1, n — 1) since we know that n is odd, that means that the last element in f(2,n) will be with a — in front of it, sob1 = f(2, n- 1) — a[n] bn = a[1] — f(2 , n — 1)to make typing easier, f(2 , n — 1) = xcase 1) we say a[1] = -a[n], in which case b1 * bn = (a[1] — x) * (a[1] + x) = a[1] ^ 2 — x ^ 2 = 1 — x ^ 2 and since we know that x can't be even, that means b1 * bn will be either 0 or negative. If it's 0, then either b1 or bn are 0, and if it's negative that means that b1 and bn have opposing signs. case 2) we say a[1] = a[n] then: b1 = x — a[1] bn= a[1] — x b1 = -bnI hope this helped!
 » 4 weeks ago, # |   0 Thanks for the code!!
 » 4 weeks ago, # |   0 Alternative in F to find a big prime. Pick a random triple x,y,z. Find gcd(Query(x,y), Query(x,z)). Call the gcd g. If g is prime and g>n/2 do Query(y,z). Then $a_{x}=g$ if g does not divide Query(y,z).
 » 4 weeks ago, # | ← Rev. 2 →   0 I thought Wind_Eagle's contest would be easier than that of tourist but I was brutally wrong:(
 » 4 weeks ago, # |   0 The second question is brutally brute force.
 » 4 weeks ago, # |   0 In problem D1 editorial "Then it is easy to see that bi=f(1,i−1)±ai+1∓f(i+2,n), and bi+1=f(1,i)∓f(i+2,n). Hence, if we consider the two cases (ai+1=1 and ai+1=−1), we see that |bi−bi+1|=2." how do we get " |bi−bi+1|=2 "?Can anyone explain?
 » 4 weeks ago, # |   0 this is my solution for B... I don't know my mistake as it is showing wrong answer for test case 2. 127122518 https://codeforces.cc/contest/1562/submission/127122518
 » 4 weeks ago, # |   0 This types of the editorial are best, as they consist of hints 1 and hints 2 before the actual solution, so it helps contestants to now think after taking a small hint rather than seeing the full solution.Hope to see such type of editorials in future contest.
 » 4 weeks ago, # |   0 Loved Dream Theater references
 » 4 weeks ago, # |   0 Can anyone explain why I'm getting TLE in E? https://codeforces.cc/contest/1562/submission/127401115
•  » » 4 weeks ago, # ^ |   +9 std::string.substr() works in O(n).
•  » » » 4 weeks ago, # ^ |   0 Thanks! Never thought about it :)
 » 4 weeks ago, # |   +5 what is NOC in solution of problem F? To do this, we ask all the NOCs of the number p and the other numbers.
•  » » 3 weeks ago, # ^ | ← Rev. 3 →   0 Sorry, it is a bad translation from Russian.In Russian НОК (наименьшее общее кратное) is lcm (least common multiple).
 » 4 weeks ago, # | ← Rev. 2 →   0
 » 3 weeks ago, # |   +8 I found another solution for D2:Let $P_i$ be the prefix sign variable sum up to $i$. Let the answer to an odd-sized query $[l, r]$ be $m$. The old sign-variable sum of $[l, r]$ is $\pm(P_r - P_{l-1})$ and after removing $m$, the new sign-variable sum is $\pm(P_{m-1} - P_{l-1} + P_m - P_r)$. So, $m$ needs to satisfy $P_{m-1} + P_{m} = P_{l-1} + P_r$, and it can be located by maintaining a std::set of all possible $m$ for each value of $P_{m-1} + P_m$ and using lower_bound.
 » 3 weeks ago, # |   0 My explanation for F (which I feel is simpler) :- we can actually find any index in 20 queries so we find 5000/20 = 250 numbers and then the probability that some number > (l+r)/2 and is prime is fairly high. my submission
•  » » 3 weeks ago, # ^ |   +8 Nice solution :)
 » 3 weeks ago, # |   0 Thank you very much, it helps me a lot.
 » 3 weeks ago, # |   0 "The parity of the length of the segment and the parity of the number of elements to be removed from it are the same." The above line isn't clear to me yet. It ll be very kind if someone can explain this to me with few examples.
•  » » 3 weeks ago, # ^ |   0 I got it. ":)
 » 8 days ago, # |   0 i'm not good at coding :")