Блог пользователя vntshh

Автор vntshh, 5 недель назад, По-английски,

768A. Oath of the Night's Watch

Set and Editorial by: vntshh

You just have to find the number of elements greater than the minimum number occurring in the array and less than the maximum number occurring in the array. This can be done in O(n) by traversing the array once and finding the minimum and maximum of the array, and then in another traversal, find the good numbers.

Complexity: O(n)

Code

768B. Code For 1

Set and Editorial by: killer_bee

It is easy to see that the total number of elements in the final list will be . The problem can be solved by locating each element in the list and checking whether it is '1' .The ith element can be located in O(logn) by using Divide and Conquer strategy. Answer is the total number of all such elements which equal '1'.

Complexity : O((r - l + 1) * logn)

Code

768C. Jon Snow and his Favourite Number

Set and Editorial by: vntshh

The range of strengths of any ranger at any point of time can be [0,1023]. This allows us to maintain a frequency array of the strengths of the rangers. Now, the updation of the array can be done in the following way: Make a copy of the frequency array. If the number of rangers having strength less than a strength y is even, and there are freq[y] rangers having strength y, ceil(freq[y] / 2) rangers will be updated and will have strengths y^x, and the remaining will retain the same strength. If the number of rangers having strength less than a strength y is odd,and there are freq[y] rangers having strength y, floor(freq[y] / 2) rangers will be updated and will have strengths y^x, and remaining will have the same strength. This operation has to be done k times, thus the overall complexity is O(1024 * k).

Complexity: O(k * 210)

Code

768D. Jon and Orbs

Set and Editorial by: arnabsamanta

This problem can be solve using inclusion-exclusion principle but precision errors need to be handled. Therefore, we use the following dynamic programming approach to solve this problem.

On n - th day there are two possibilities,
Case-1 : Jon doesn't find a new orb then the probability of it is .
Case-2 : Jon does find a new orb then the probability of it is .

Therefore,
We need to find the minimum n such that
where,
n = number of days Jon waited.
x = number of distinct orbs Jon have till now.
dp[n][x] = probability of Jon having x distinct orbs in n days.
k = Total number of distinct orbs possible.

Code

PS:The ε was added so that the any solution considering the probability in the given range passes the system tests.

768E. Game of Stones

Set and Editorial by: AakashHanda

This problem can be solved using DP with Bitmasks to calculate the grundy value of piles. Let us have a 2-dimensional dp table, dp[i][j], where the first dimension is for number of stones in the pile and second dimension is for bitmask. The bitmask has k-th bit set if we are allowed to remove k + 1 stones from the pile.

Now, to calculate dp[i][j] we need to iterate over all possible moves allowed and find the mex.

Code

Finally for the game, we use the grundy values stored in dp[i][2i - 1] for a pile of size i. We take the xor of grundy values of all piles sizes. If it is 0, then Jon wins, otherwise Sam wins.

The complexity of this solution is . This will not be accepted. We can use the following optimizations for this problem:

  1. Use a top-down approach to calculate the values of dp[i][2i - 1], hence calculating only those values that are required.
  2. Since we can only remove at most i stones from a pile, as stated above, we need to store values from j in range [0, 2i - 1].

So we can rewrite the above code to incorporate these change. Hence, the final solution is as follows

Code

Bonus: Try to find and prove the O(1) formula for grundy values

768F. Barrels and boxes

Set and Editorial by: arnabsamanta, apoorv_kulsh

Every arrangement of stacks can expressed in the form of linear arrangement. In this linear arrangement, every contiguous segment of wine barrels are separated by food boxes. For the arrangement to be liked by Jon each of the f + 1 partitions created by f food boxes must contain either 0 or greater than h wine barrels.

Let u out of f + 1 partitions have non-zero wine barrels then the remaining r + 1 - u partitions must have 0 wine barrels..

Total number of arrangements with exactly u stacks of wine barrels are
is the number of ways of choosing u partitions out of f + 1 partitions.
X is the number of ways to place w wine barrels in these u partitions which is equal to the coefficient of xw in {xh + 1·(1 + x + ...)}u. Finally we sum it up for all u from 1 to f + 1.

So the time complexity becomes O(w) with pre-processing of factorials.

w = 0 was the corner case for which the answer was 1.
We did not anticipate it will cause so much trouble. Not placing it in the pretests was a rookie mistake.

Code


768G. The Winds of Winter

Set and Editorial by: apoorv_kulsh

We are given a tree. We remove one node from this tree to form a forest. Strength of forest is defined as the size of largest tree in forest. We need to minimize the strength by changing the parent of atmost one node to some other node such that number of components remain same.

To find the minimum value of strength we do a binary search on strength. It is possible to attain Strength S if
1. There is less than one component with size greater than S.
2. There exists a node in maximum component with subtree size Y such that,
M - Y ≤ S (Here M is size of maximum component and m is size of minimum component)
m + Y ≤ S.
Then we can change the parent of this node to some node in smallest component.


The problem now is to store Subtree_size of all nodes in the maximum component and perform binary search on them. We can use Stl Map for this.
Let X be the node which is removed and Xsize be its subtree size There are two cases now -:
1. When max size tree is child of X.
2. When max size tree is the tree which remains when we remove subtree of X from original tree.(We refer to this as outer tree of X).

In the second case the subtree sizes of nodes on path from root to X will change when X is removed. Infact their subtree size will decrease exactly by Xsize. While performing binary search on these nodes there will be an offset of Xsize. So we store them seperately. Now we need to maintain 3 Maps,
where
mapchildren : Stores the Subtree_size of all nodes present in heaviest child of X.
mapparent : Stores the Subtree_size of all nodes on the path from root to X.
mapouter : Stores the Subtree_size of all nodes in outer tree which are not on path from root to X.


Go through this blog post before reading further (http://codeforces.com/blog/entry/44351).

Maintaining the Maps
mapchildren and mapparent are initialised to empty while mapouter contains Subtree_size of all nodes in the tree.

mapparent : This can be easily maintained by inserting the Subtree_size of node in map when we enter a node in dfs and remove it when we exit it.
mapchildren : mapchildren can be maintained by using the dsu on tree trick mentioned in blogpost.
mapouter : When we insert a node's subtree_size in mapchildern or mapparent we can remove the same from mapouter and similarly when we insert a node's Subtree_size in mapchildern or mapparent we can remove the same from mapouter.


Refer to HLD style implementation in blogpost for easiest way of maintaining mapouter.
Refer to code below for exact point of insertions and deletions into above mentioned 3 maps.

Code


Complexity O(NlogN2)

 
 
 
 
  • Проголосовать: нравится  
  • +32
  • Проголосовать: не нравится  

»
5 недель назад, # |
Rev. 4   Проголосовать: нравится +45 Проголосовать: не нравится
Fast way to solve E
  • »
    »
    5 недель назад, # ^ |
    Rev. 2   Проголосовать: нравится +7 Проголосовать: не нравится

    I don't understand your proof of j being the Grundy number. Taking your example, if you have a pile of 10 and remove 5 you get a pile of 5 and you are allowed to take 1, 2, 3, 4 from it.

    How is that equivalent to removing 2 and 3 from {1, 2, 3, 4}? I mean, in that case you would get {1, 4} and you could remove 1, 4 or 5 stones from it. Am I missing something?

    • »
      »
      »
      5 недель назад, # ^ |
      Rev. 4   Проголосовать: нравится 0 Проголосовать: не нравится

      I didn’t mean to construct a solution.I was only giving an example to give a sense of what i and j mean. For example one could pick {1,4} instead. It’s the amount of present stones in the respective piles that matter.

      By the way this is not a proof.It's just a way to solve the problem.

    • »
      »
      »
      5 недель назад, # ^ |
      Rev. 2   Проголосовать: нравится 0 Проголосовать: не нравится

      Mistaken.

      • »
        »
        »
        »
        5 недель назад, # ^ |
          Проголосовать: нравится +5 Проголосовать: не нравится

        It is not as simple as that. Imagine 2 piles that have infinite stones but you can only take 1, 2, 3 from them. You can also imagine it as initially 2 piles of 21 and both players took 4, 5 and 6 from them so there are 2 piles of 6 stones where you can take 1, 2 and 3. There are 3 numbers from 1...j remaining but the nimber of these stacks is obviously 1 because they will simply waste 3 moves on each stack.

        I solved this problem in a bit more than 6 minutes including reading the statement using this but now that aurinegro said that, I can't really even start a proof of the reason why it works.

        • »
          »
          »
          »
          »
          5 недель назад, # ^ |
          Rev. 2   Проголосовать: нравится 0 Проголосовать: не нравится

          Mistaken.

          • »
            »
            »
            »
            »
            »
            5 недель назад, # ^ |
            Rev. 2   Проголосовать: нравится +5 Проголосовать: не нравится

            A pile of 6 where you can take 1, 2, 3 and a pile of 1 where you can take 1. First player loses. Edit: if it was like you said and "defined on number available moves left from {1,2,..,j}." it should be 1^3=2 and the first player should win. It is way more complex, you can go from lesser state to a greater state, it's not a simple mapping like "taking number greater than j means taking more than one stone".

            • »
              »
              »
              »
              »
              »
              »
              5 недель назад, # ^ |
                Проголосовать: нравится 0 Проголосовать: не нравится

              Thanks. I've understand. I was balled-up by "Imagine 2 piles that have infinite stones but you can only take 1, 2, 3 from them." Example with 21 is concrete contrary instance, I've understood it later.

        • »
          »
          »
          »
          »
          5 недель назад, # ^ |
          Rev. 2   Проголосовать: нравится +16 Проголосовать: не нравится

          I think I got a reasonable proof:

          First, from the definition of Grundy number (as a minimum excluded) it is not hard to see that for a state s such that Grundy(s) = k there must be a path s = sk → sk - 1 → ... → s1 → s0 where Grundy(si) = i. Since the number of stones taken in each step must be different, you have an upper bound for Grundy(n), namely the largest k such that 1 + 2 + ... + k ≤ n. Below, I will denote this k as k(n).

          It is possible to prove equality by induction. Our states will be of the form (n, X) where n is the number of stones and X is the allowed moves (a set of integers) and the inductive hypothesis will be that for any state , Grundy(s) = k(n). You can verify that the base case is true, and for any k' < k(n) it is possible to reach a state with k' = k(n'). This implies that Grundy(s) ≥ k(n) and together with the previous upper bound proves equality.

          • »
            »
            »
            »
            »
            »
            5 недель назад, # ^ |
              Проголосовать: нравится 0 Проголосовать: не нравится

            I've misunderstand proving equality by induction. What is X' ?

            Inductive hypothesis is that for any n'< n and any X', Grundy(n',X')=k(n') ? And we want to prove for any X that Grundy(n,X)=k(n) ?

            • »
              »
              »
              »
              »
              »
              »
              5 недель назад, # ^ |
                Проголосовать: нравится 0 Проголосовать: не нравится

              Well, I agree that my writing wasn't super clear.

              The idea is to prove by induction in k that if 1 + 2 + ... + k ≤ n < 1 + 2 + ... + (n + 1), then the Grundy number of a position with n stones where the moves 1, 2, ..., k are allowed is exactly k. The set X' was used to show that other moves might be allowed as well, it is irrelevant.

              It is not true that Grundy(n, X) = k(n) for any X.

              • »
                »
                »
                »
                »
                »
                »
                »
                5 недель назад, # ^ |
                  Проголосовать: нравится +5 Проголосовать: не нравится

                tfg has wrote above: A pile of 6 where you can take 1, 2, 3 and a pile of 1 where you can take 1. First player loses. If Grandy for first pile is 3 then 1^3=2 and the first player should win.

          • »
            »
            »
            »
            »
            »
            4 недели назад, # ^ |
            Rev. 2   Проголосовать: нравится 0 Проголосовать: не нравится

            Counter example to your proof:s={3,{1,2}}. Grundy value is 0.

»
5 недель назад, # |
  Проголосовать: нравится +17 Проголосовать: не нравится

Some people solved C by finding a cycle in the sequence of arrays of rangers: http://codeforces.com/contest/768/submission/24853717

Can this be hacked, or there is a way to prove that the cycle will never be too long?

  • »
    »
    5 недель назад, # ^ |
      Проголосовать: нравится +14 Проголосовать: не нравится

    This would be very interesting. I solved it using this approach, after I saw that the sequence will run into a cycle pretty quickly. I did a few thousand experiments using random numbers, and in each one I found the cycle after max 5 operations. Although I have no idea how to prove this.

    • »
      »
      »
      5 недель назад, # ^ |
        Проголосовать: нравится 0 Проголосовать: не нравится

      Maybe it's because of how freq[x] could only oscillate between 6 values, and it's also bounded by sum(freq[x], freq[x^x'])? I am still not sure what makes all freq[x] oscillation consonant that east though.

»
5 недель назад, # |
  Проголосовать: нравится +5 Проголосовать: не нравится

B can be done in O(max(r-l, logn)) when I reverse n first and use lsone.

  • »
    »
    5 недель назад, # ^ |
    Rev. 2   Проголосовать: нравится 0 Проголосовать: не нравится
    I got another solution for B (using Pattern):
    Let us convert the no. n into a binary string, reverse the string.
    Then let k denote the indices of the reversed binary string :
    for i=k in binary string(BS):
        start from j=pow(2,k)-1 to j<=r with jumps of pow(2,k+1) ,for all these indices j 
        in "sam's list" the elements will have the same value as that of BS(k)
        (can start the j from a value coming just after l (using Arithmetic Progression) )
    

    24877687 my code

»
5 недель назад, # |
  Проголосовать: нравится +5 Проголосовать: не нравится

In problem D how we can estimate max value of n for given k ?

»
5 недель назад, # |
Rev. 3   Проголосовать: нравится +6 Проголосовать: не нравится

In D, aren't you considering instead of ? Is that correct?

Edit: nevermind, got it.

»
5 недель назад, # |
  Проголосовать: нравится +11 Проголосовать: не нравится

I have no idea why this code can pass problem C. I just Simulate these operations until the timeout or the number of steps exceeds k. QwQ http://codeforces.com/contest/768/submission/24857855

  • »
    »
    5 недель назад, # ^ |
      Проголосовать: нравится +3 Проголосовать: не нравится

    I'm guessing that in all large test cases, the first and last element stop changing, so you can just stop simulation early. This hack should break it, depending on where the sim stops: 99999 99999 7 1 2 2 2 2 .....

»
5 недель назад, # |
  Проголосовать: нравится +6 Проголосовать: не нравится

B can be solved in O(max(log n,log r))

»
5 недель назад, # |
Rev. 6   Проголосовать: нравится +26 Проголосовать: не нравится

Hi, I want to share my O(logn) solution for Problem B.24858905

We can observe some interesting phenomenon:

  1. The list is Palindrome.

  2. Let len(n) means the length of the final list, then len(n) = (1«bitcount(n)) - 1.

  3. There are exactly n 1s in the final list(This can be proved by Mathematical Induction).

let f(n, x) means the number of 1s in the first x elements,so the answer is f(n, r) - f(n, l - 1).

We can calculate it recursively:

  1. if x < len(n / 2), f(n, x) = f(n / 2, x)

  2. if x = len(n / 2) + 1, f(n, x) = (n / 2) + (xmod 2)

  3. if x > len(n / 2) + 1, f(n, x) = (n / 2) + (xmod 2) + f(n / 2, x - len(n / 2) - 1)

Sorry for my bad English ;)

»
5 недель назад, # |
Rev. 2   Проголосовать: нравится 0 Проголосовать: не нравится

HELPPP PLEASE

REGARDING PROBLEM C, I submited three identical solutions but with different results wrong , right1 and right2. The only difference is the vector size (1025, 1024 and 1500 respectively). all should work since the problem uses only the first 1024 slots.

I suppose it is some kind of undefined behaviour, can someone please help me? this is driving me crazy...

  • »
    »
    5 недель назад, # ^ |
      Проголосовать: нравится +6 Проголосовать: не нравится

    for(int i = 0; i<v[ATUAL].size(); i++) .. v[OUTRO][i^x] += ..

    i^x can be greater than size unless size is a power of 2.

»
5 недель назад, # |
Rev. 2   Проголосовать: нравится +3 Проголосовать: не нравится

For problem D editorial, is x/n supposed to be x/k?

»
5 недель назад, # |
  Проголосовать: нравится +1 Проголосовать: не нравится
int is_one(long long int pos,long long int target,long long int num)
{ 
  if(num<2)
    return num;
  if(pos+1==2*target)
  {
    return num%2;
  }
  num/=2;
  pos/=2;   
  if(target>pos+1)
      target-=(pos+1);      
  return is_one(pos,target,num);
}

Can anyone explain how this function works?

  • »
    »
    5 недель назад, # ^ |
      Проголосовать: нравится 0 Проголосовать: не нравится

    Hello bro, did you understand how this function works? If so can you please explain it here? Thanks

»
5 недель назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

Can anyone explain in details X value in F editorial?

»
5 недель назад, # |
  Проголосовать: нравится +3 Проголосовать: не нравится

I solve problem C in the following way: I have a two-dimensional array[1024][100000] which I use to save the state of the array after i operations.I update the array in an easy way: 1) First I sort the elements. 2) Then I iterate through the array and update each element This process takes O(nlgn) time, and I do it 1023 times so my algorithm works in O(nlgn*1023)times in total. after that if k<=1023 I print array[n-1][k] and array[0][k] which are the maximum and minimum values after k operations. otherwise when k>1023 I iterate through the first 1023 states of the array and find a repeated state. Then using this repeated state I find the period of the operation and at last find the state of the array after k times, without doing the operation k times, but only with computing the first 1023 operations. My solution worked and got accepted but I didn't prove that we reach a repeated state after a maximum of 1023 operations. Can anyone prove it for me?

»
5 недель назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

here is my code. Your text to link here...

»
5 недель назад, # |
  Проголосовать: нравится +3 Проголосовать: не нравится

"For the arrangement to be liked by Jon each of the f + 1 partitions created by f food boxes must contain either 0 or greater than h wine barrels"- I don't get the "must contain either 0 or..." part. Is it possible for a stack to be empty?

»
5 недель назад, # |
Rev. 2   Проголосовать: нравится +3 Проголосовать: не нравится

In problem D,

Case-1 : Jon doesn't find a new orb then the probability of it is x/k

Case-2 : Jon does find a new orb then the probability of it is k-x+1/k;

I could not get why it is k-x+1 , shouldn't it be k-x , so that x + (k-x)=k

Got it,Thanks.

  • »
    »
    5 недель назад, # ^ |
      Проголосовать: нравится +6 Проголосовать: не нравится

    The new orb is the xth one. So before finding it he has already x-1 different orbs, and there are k - (x - 1) possible new orbs.

    • »
      »
      »
      5 недель назад, # ^ |
      Rev. 3   Проголосовать: нравится 0 Проголосовать: не нравится

      Thank you for your support.

    • »
      »
      »
      3 недели назад, # ^ |
        Проголосовать: нравится 0 Проголосовать: не нравится

      Then shouldn't probability of finding an old orb be (x-1)/k. Sorry, i am still confused.

      • »
        »
        »
        »
        3 недели назад, # ^ |
          Проголосовать: нравится 0 Проголосовать: не нравится

        No, it should be x/k. We want to compute the probability that we have x orbs after k nights. So either we find a new one in the k-th night (than this is the x-th one => (k - (x - 1)) / k. Or we don't find a new one (so we already have x orbs => x / k).

»
5 недель назад, # |
Rev. 2   Проголосовать: нравится 0 Проголосовать: не нравится

Nevermind.

»
5 недель назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

For Problem B final length should be 2^(1+floor(logN)) -1

»
5 недель назад, # |
  Проголосовать: нравится +10 Проголосовать: не нравится

For problem D, actually there is a solution O(qnlog^2)!!! Which is O(nlog^2) per query! 24861344 Actually c++ make it hard to accept it at contest!

»
5 недель назад, # |
  Проголосовать: нравится +3 Проголосовать: не нравится

Wondering how to use inclusion-exclusion principle to solve D? Already understood the dp solution, but how can it handle the precision error?

»
5 недель назад, # |
  Проголосовать: нравится +5 Проголосовать: не нравится

In problem F will be a solution if w is less than 10^9?Thanks.

»
5 недель назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

Good))

»
5 недель назад, # |
  Проголосовать: нравится -8 Проголосовать: не нравится

The link ("Go through this blog post before reading further http://codeforces.com/blog/entry/44351") is not working, please fix it.

»
5 недель назад, # |
  Проголосовать: нравится +3 Проголосовать: не нравится

My O(r - l) solution for B:

Let x be the number from which we are generating this sequence.

We can see that floor(x / 2) == x >> 1 and is equal to the least significant bit of x (i.e. x & 1). We can also see that x >> p == (x >> p) & 1, where p is the position of the most significant bit of x minus one.

Now let's search for a pattern in the number of bits shifted every time.

Example for x = 7: If k is the number of bits shifted every time to obtain (x >> k) & 1, we can see that k follows this pattern: 3, 2, 3, 1, 3, 2, 3, 0, 3, 2, 3, 1, 3, 2, 3. Here, we can observe that this looks a lot like the binary carry sequence. (See 743B - Chloe and the sequence ) The difference is that if p is the position of the MSB of x minus one, we are computing p - ai, where a is the binary carry sequence. We already know that we can compute any element of this sequence in O(1), therefore the problem is solvable in O(r - l).

Code: 24878823

»
5 недель назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

can someone please tell what is wrong with this solution of problem C
http://codeforces.com/contest/768/submission/24880646

  • »
    »
    5 недель назад, # ^ |
      Проголосовать: нравится 0 Проголосовать: не нравится

    instead of this: else if(c%2==0)cou++;

    change it to this: else if (c % 2 == 0 && fre[i] % 2) cou++;

    If the amount before you is even and your frequency is odd, then you take one more. If your frequency is even you always take only half, no more than that.

»
5 недель назад, # |
Rev. 4   Проголосовать: нравится +5 Проголосовать: не нравится

I want to share my solution to problem B

You can interpret the final list as a full balanced binary tree, because every node that has a element whose x>1 becomes two identical nodes (the children that are x/2) plus the original value is replaced by x mod 2. So you can index each node as shown in the image below for the example of n=10.For every index you can get the final value that is x mod 2 in O(lgN). (you start from the root that is the original value n (and is located in the middel index) and you can easily go to any other node and find its value and index as shown in this code here)

»
5 недель назад, # |
  Проголосовать: нравится +3 Проголосовать: не нравится

Just asking, is it ok to include precalculated values into the code? Just like the grundy values in the problem E one could get an AC solution by calculating the grundy values locally and then submit a solution using a lookup table cropped from it. Is this allowed in CF, or even in ACM?

  • »
    »
    5 недель назад, # ^ |
      Проголосовать: нравится +3 Проголосовать: не нравится

    Why not? Most of the accepted solutions have done this only. Google Code Jam specifically mentions that you should also submit code that you used to generate the pre-computed values, though there is no such restriction on CF and in ACM I think.

»
5 недель назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

I was looking through solutions of A which failed sys tests but wasn't hacked. And I just can't understand why this solutions failed sys tests. Can someone explain?

»
5 недель назад, # |
Rev. 2   Проголосовать: нравится -6 Проголосовать: не нравится

Any ideas why this fails for problem B?

It seems the numbers are too big for long long.

Update: I found my mistake.

»
5 недель назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

Can someone explain why the change bottom up to top down can improve complexity of problem E?

Isn't it the same if all piles has 60 stones?

»
5 недель назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

In problem B use something like Segment Tree Query, knowing that the number n will have n 1's. You can see my code here: http://codeforces.com/contest/768/submission/24840947 Fast and easy to code. :)

»
5 недель назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

My submission for problem B fails at pretest 4. Could anybody please check what is wrong with my submission? 24917320

»
5 недель назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

Can anyone please tell me why are we using these two lines of code? Would be more grateful if someone cares to explain the logic of is_one function in problem B. Thanks in advance

if(target>pos+1) target-=(pos+1);

»
5 недель назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

In problem C, which rangers should be updated?

»
4 недели назад, # |
Rev. 2   Проголосовать: нравится 0 Проголосовать: не нравится

Time Complexity doubt related to Problem C : What I've read is 10^6 to 10^7 are the operations performed per second(in WORST CASE).Time limit for this problem was 4 seconds, that amounts to, say 4*(10^7) operations. Editorial code suggests some order of 10^8 operations. This suggests that passing the questions depends on processor capabilities. Can someone explain me this thing.

Thank you. vntshh

  • »
    »
    3 недели назад, # ^ |
      Проголосовать: нравится 0 Проголосовать: не нравится

    In 1 second, around 108 to 2 * 108 operations are possible. Time limit was set 4 seconds so that, the codes written in JAVA (generally takes the maximum time) also fit within the time limit.

»
2 недели назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

I'm sorry for stupid question, but why in the problem F, f+1 partitions if there is only f boxes???

»
10 дней назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

Can anyone help me Problem C ? I follow the editorial and AC it , but the code so long. I see that everyone just take k = k% 64 (or 512, or 1024..) . And then they just sort() with k times and then update strength easily , but , I just can't understand why we can find out that the period of those updating strength is 64 , 512, 1024 ??

»
8 дней назад, # |
  Проголосовать: нравится 0 Проголосовать: не нравится

i've got a tiny bit quicker way to solve 768A Submission