TMSLT - Editorial



Author: Shiplu
Tester: Mahbubul Hasan
Editorialist: Jingbo Shang






Given a random sequence of N numbers, a[0…N-1], sort them in order and report the difference between the sum of numbers in odd positions and the sum of numbers in even position.


If a quick sort is directly applied, the time complexity is O(N logN). But the range of numbers is small, within 1,000,000. Therefore, we can use the counting sort, that is,

count[0 .. 999999] = 0
for i = 0 to N-1 do
    count[a[i]] ++;

Go through the count array again, we can get the order. With this algorithm, we can solve this problem in O(X) time, where X is the range of all numbers.


Author’s solution can be found here.
Tester’s solution can be found here.

1 Like

I’d like to ask the community here if questions like

are cheating or not?

I understand that asking a questions is part of learning process, but here (and I’m not telling this is the first case), it’s related to ongoing contest and even such question is kind of hint I think…


Let me tell you another optimization in the problem, As mod is 10^6, It is sure that you will get a cycle in atmost 10^6 iterations, Hence find that cycle and use that to calculate the answer =D

1 Like

I did the same way as suggested by @dpraveen. Guess what, 0.26 secs !

1 Like

@betlista I wouldn’t consider them as cheating. Sorting and searching are commonly known algorithms and these questions are mostly asked by beginners who want to learn. If you look at my answer and other answers they are general answers and not specific to any question. This info is easily available on others sites also. However asking question specific details is certainly unwelcome.


I was able to identify the formation of cycles somewhere within 10^6 iterations, but I still got TLE. I used the STL sort function. Shouldn’t that have done the job?

actually i also used the stl sort function . but here we were supposed to use bucket sort as range of numbers was very less.Hence we got TLE

Oww. Thanks. :slight_smile:

can someone explain this portion ?

	for(int i=0;i<1000000;i++){




1 Like

Me too, fastest java implementation of all. Cycles are very likely to occur much faster than 10^6. Certainly with a MODULO that is not a prime. Which is very good for average complexity.

1 Like


int now = 0;
for(int i=0;i<1000000;i++){


I assume you understood the “sorting” part…

So, now for input

1 2 2 2 4 6

we have in co array values

0 1 3 0 1 0 1

the if(now%2==0) handles, that we are alternating addition of strength to team, you can simply change the algorithm with

        sum1 += (co[i]%2)*i;
        sum2 -= (co[i]%2)*i;

where sum1 is for first team and sum2 is for second, but while we are interested only in difference, we can use one variable and use + for first team an - for second…

1 Like

why following statement are used ?
(co[i]%2)*i and now+=co[i]; ??
where as to alternate the addition and subtraction we could have just toggle a boolean variable or just checked if i%2==0 or not that could have done the job as well?

rest of the part is very clear friend
just not able to understand the use of these two statements.

Thanks in advance and for above explanation . :slight_smile:

1 Like

Can anyone please explain this concept of cycle ?

In Python, for same logic I am getting TLE :frowning:

t = int(raw_input())
while t>0:
    t -= 1
    n, a, b, c, d = map(int, raw_input().split())
    h = [0] * 1000000
    h[d] = 1
    for i in range(n-1):
        d = ( ((d * d * a) % 1000000) + (b*d) + c) % 1000000
        h[d] += 1
    ans = 0
    is_x = True
    for i in range(999999, -1, -1):
        temp = h[i]
        if temp % 2 == 1:
            if is_x:
                ans += i
                is_x = False
                ans -= i
                is_x = True
    print ans

Any idea why is this not working?

Same Approach used

it’s because when you have 2 2 2 in input above, you do not need to add first 2 to first team, second to second team and last to first team… as you can see, if number of elements is even you do not need to add it (because one half belong to one team and another one to another team) and that’s exactly what (co[i]%2)*i is doing…

now is a index for team members, so when you added co[i] members, you need to increment it by co[i]

1 Like

got it brother thanks a lot …

1 Like

Because it is Python :smiley:

No problem, keep interested, keep asking, that’s the proper way to learn things, good luck :wink:

1 Like

It would have been a cakewalk if there was no MOD thingy :stuck_out_tongue:

1 Like