probably yes :(

It is inertia. If it happens so that the first person downvotes the comment, the others are inclined to do the same. It is also true if the comment gets upvoted first.

This psychological phenomenon clearly manifests itself here and on other internet platforms where people can see how others vote. It is highly exploited in the real life, for example, in advertising or presidential campaigns.

By the way, if you are interested, it is one of the many cognitive biases :).

you can check his profile if you are interested to know

Pretty sure about the fact that every Codeforces Round #xxx type of round has been conducted on Codeforces so far, not exclusively though, like 8VC,Manthan,etc.

How can you see hacks of different people?

Mom, got a camera, i am in a television!!!

Then I supposed we will iterate over all i and find index j with maximum value j*A[i]-sum[j] where sum[j] denoting sum of first j elements for j>i. Similar way for i<j. But that again wasn't enough for anything faster :D

I thought of solving the problem like this. Find maximum value of ri and it's position in input. Then all sortings done before this input will be useless. After this input, check for next largest value of ri and repeat this process. Obviously after finding ri we have to do something in array(I still need to find out more).

My solution is much more easier. I have two sorted arrays (increasing and decreasing order) and taking a look only at elements, that had changed their position. For every position I store will it be sorted at last time int dec or inc order. In first case I am placing in this position first unused element from dec array, in another case first from inc arr. You can take a look at my submission: 16494098 for better understading me. Hope that this will work. P.S. It was the first time when I have submitted three problems less than in one hour :) UPD: Failed. UPD2: Bugged code, but right idea. Some little changes and AC: 16501782

I think your solutions fails for this test : in

I have hacked a similar solution with this test.

N = 200000
K = 200000
print N, K
for i in xrange(N):
   print i + 1,
print
for i in xrange(K):
   if(i % 2 == 0):
      print 1, N — i
   else:
      print 2, N — i

I won't know until system tests are over, but I did the following: EDIT: Failed on test 13. I think the main idea is correct though, so check the last paragraph.

1. If there are n numbers, create an array of size n (orderings) of integers, initialized at 0.

2. Read input numbers and put them in a linked list. Create empty stack too.

3. Read managers. For each manager, set orderings[r] = t (1 or 2).

4. Set sorted = false. For i = n — 1 until 0:

4.1. if (ordering[i] != 0 && !sorted) list.sort(), sorted = true;

4.2. if ordering[i] == 1: pop from the left of the list and push to stack.

4.3. else: pop from the right and push to stack.

1. Pop from the stack and print until empty.

It's not exactly that, because when ordering is 0 you have to look at the last order, unless no sort has been performed yet.

I'm not sure about whether it's right or left for orderings 1 or 2, because I don't remember which one was nonascending/descending, nor the default order of list.sort(). But when ordering is 0 you always pop from the right (if no sort has been done yet, else you follow the previous left-right rule).

The idea is that if the largest sort is n — k elements, the last k are in the initial order. From there, the n — k — 1 indexed element is the biggest/smallest number left (depending on the direction of the last sort of that size), the list is reduced in each step this way, until you get to the empty string.

Yeah, prefix/suffix sums mostly ditch me in contests because I always end up coding segment tree

There can be overflow Input 1 536870911 536870911

Ah I see. I thought there is some tricky case...

WHAT ? :|

    long long int n, k, d, i, j, ans, currA, currB;

    cout << "5000 1 100000\n";
    for (i = 0; i < 100000; i++)
    {
        cout << "2 1 10\n";
    }

This gave me unsuccessful hacking attempt :\