Now I get an AC
Just change "if(!y)" into "if(!y||!x)"

where are you from?

I get TLE in #6 too , can you explain in detail？

Well, I checked my solution and it didn't seem that could exceed the time limit... Weird... I've got TLE #6 too.

Can you explain in detail??I'm afraid i can't understand.....

oh,now I get AC.Just a little mistakes.

Many Thanks!

I guess this test is incorrect, because of statement:
" any biparous branch splits up to exactly two new branches", but node 3 has only one branch.

As I can see here is 2 possible trees.
1 and 3 can be root
   6
    \
  5  3
   \ /
4  2
 \ /
  1

   4
    \
  5  1
   \ /
6  2
 \ /
  3

Edited by author 20.12.2015 15:47

Thank you for your data

убери переменную 'c'.

Edited by author 14.02.2018 23:36

Edited by author 14.02.2018 23:36

n = int(input())
a = []
summ = 0
for i in range(n):
    a.append(int(input()))
b = list(set(a))
for i in range(len(b)):
    c=a.count(b[i])
    if c > 3:
        summ+=c//4
print(summ)

(std::numeric_limits< float >::epsilon() / 2) is absolute accuracy needed overall. You can invent twofold float-then-double algorithm to sieve bad points beforehand. For single precision algorithm part you have to use 20.1f (20 + small constant) "epsilon" to compare squared distances in case if you use <= or >= operator (say, vcmpge_oqps or vcmple_oqps instructions) and 28.2f (28 + small constant) in case of strict inequality. Surely you can invent adaptive algorithm to infer relative accuracy needed in particular test case, which takes into account max abs differences of input point coordinates.

[code]

    for s := 1; s <= S; s++ {
        for l := 2; l <= 9; l++ {
            for d := 0; d < 10 && s - d > 0; d++ {
                if dp[s - d][l - 1] == 0 {
                    continue
                }

                dp[s][l] += dp[s - d][l - 1]

                if d == 0 {
                    dp[s][l]++
                }
            }
        }
    }
[/code]

Here is the solution
http://xoptutorials.com/index.php/2017/01/01/timus1353/

It said not more than 10 cans...
thus there could be less than 10 cans

Once Harry and Larry shoot a common can...
you gotta consider that too...

Simple tests:

1)
5 2
2 2
?????
ans:XX.XX

2)
4 2
2 2
????
ans:Impossible

3)
15 3
2 1 2
??X?.?.......X?
ans:.?X?.X.......XX

4)
15 5
2 1 2 1 2
??X?.?.X.?.?.X?
ans:Impossible

5)
5 0

XXXXX
ans:Impossible

6)
5 3
1 1 1
X.X.X
ans:X.X.X

7)
5 2
1 1
.?.?.
ans:.X.X.

8)
18 5
3 1 1 3 1
.???.X?.??..?XX?.?
ans:.XXX.X..??..?XX?.X

It turns out, that there are possible two way to solve this problem (both M*N) in addition to naïve one (1400ms).
1.) Read all sites, then for each query point do find all the preliminary neighbours using float coordinates (it is almost two time faster in terms of membory bandwitdth, then if use double). This is a "float" sieve. Then for all sites passed "float" sieve perform similar "double" sieve. It get about 500ms (for me from 1.45s to 950ms). Test #16 is still hardest. Prefetch instructions in long runs gain up to 100ms.
First loop (precalc of squared float distances) can be unfolded 4 times by query points (vbroadcastss from fixed memory location works fast in loop, you should not occupy dedicated ymm register for these). Second loop, where squared distances compared against least distance (+ eps of course), found in previous loop, can be unfolded 4 times (you can occupy all 32 bit of some register using bit shift (ror, rol) after vmovmskps). I think it allow to better utilize branch prediction mechanism.
This approach can be beaten by simple test: cloud of sites in one corner in 10x10 square and cloud of query points in opposite aslo in 10x10 square both in general position (not matters much). Or wiser: query points placed on quarter of circle with center in one corner and radius of 20000, sites on another quarter of circle with center in the same corner and small radius or vice versa. Or even: two distant strait lines: one with query points and another with sites.
2.) You can solve the problem in single loop using just doubles with randomization. If your random numbers hit right sites, then you can probably make even fastest solution (but it is too improbably). I can't find counterexample for this randomized approach.

I am very interested in Progbeat's solution details. It seems (by memory consumed) he used approach very similar to mine. It would be great if we'll exchange our solutions somehow =).