#include <iostream.h>
int main(){
unsigned long  k,l,n,sumM=0,i,kk,ll,g1,g2;cin>>k>>l>>n;kk=k;ll=l;
    for(i=0;i<n;i++){
        g1=0;g2=0;
        if(kk>0&&i!=(n-1)){
            g1=1;kk--;
        } else if(i==(n-1)){
            g1=kk;g2=ll;
            //cout<<kk<<" "<<ll<<" "<<i<<endl;
        }
        if(g1>g2){
            sumM+=3;
        } else if(g1==g2) {
            sumM+=1;
        }
    }
    cout<<sumM<<" ";
    /*sumM=0;kk=l;ll=k;
    for(i=0;i<n;i++){
        g1=0;g2=0;
        if(kk>0&&i!=(n-1)){
            g1=1;kk--;
        } else if(i==(n-1)){
            g1=kk;g2=ll;
            //cout<<kk<<" "<<ll<<" "<<i<<endl;
        }
        if(g1<g2){
            sumM+=3;
        } else if(g1==g2) {
            sumM+=1;
        }
    }
    cout<<sumM;*/
    sumM=0;kk=k;ll=l;
    for(i=0;i<n;i++){
        g1=0;g2=0;
        if(kk!=ll&&ll>0&&i!=(n-1)){
            g2=1;ll--;
        } else if(i==(n-1)){
            g1=kk;g2=ll;
            //cout<<kk<<" "<<ll<<" "<<i<<endl;
        }
        if(g1>g2){
            sumM+=3;
        } else if(g1==g2) {
            sumM+=1;
        }
    }
    cout<<sumM;

    return 0;
}

Stupid, stupid task with wrong, wrong tests! Why checkers can go out of a desc, why nobody sad that there could be move after the last 32'th step? Why just not to tell everyone rules of the game in the text of the problem?

Edited by author 08.03.2007 21:35

What is the correct answer for this test:

4
aaaaaa
bbaaaa
bbccaa
bbccdd

Does it contain 3 or 4 words?

What do you mean by:
"
 It is required that at least one of those small parts has edge lengths that are pairwise relatively prime with the corresponding edge lengths of the original parallelepiped. "
and is it allowed to make the following cut in the second example ?
 1 1 3
If we have such a cut (which I think is correct) then we will have two equal cubes(2 3 2) (i.e. this move is correct and the first player can win by it), or I am wrong?

 Rostislav
Thank's

Edited by author 18.02.2007 16:51

Edited by author 18.02.2007 17:24

In the task said "The first line consists of 2N characters and represents the encoded message N bytes long".
But I understood that if we encode the message length of n, we will receive message the same length (n). Whats wrong?

maybe inut files has some extra spaces (surplus)...

what is that test? none of my solutions can pass it. Please give me some hints!!!

I have WA on test 10. Could anybody give me this test.

i can not understud why my program get crash.
But on my computer it works!
this is the source code:
////////////////////////////////////
using System;

class MAIN
{
    public static int Main()
    {
        int a, b;
        a = Int32.Parse(Console.ReadLine());
        b = Int32.Parse(Console.ReadLine());

        Console.WriteLine(a+b);
        return 0;
    }
}
/////////////////////////////

I've passed this problem with time 0.125 ! And the only mathematical conclusion I used is that when x is a square root then (n-x) is also.

I am sure that the mathematical approach to this problem is also interesting (and probably harder than mine) but it was still very interesting for me to find the way to solve this problem without using of deep math knowledge.
It is also interesting that my solution runs faster then some implementing the math approach :-) but still I use much  more memory...

http://acm.timus.ru/status.aspx?space=1&num=1132&author=30467

Thanks to mr. Medvedev for this problem.

var t,c,i,n,k:integer;
begin
read (n,k);
i:=1;

while i<n do
begin
If c<k then c:=c+1;
i:=i+c;
t:=t+1;
end;
If n=-1 then t:=-1;
writeln (t);

end.

Edited by author 12.09.2007 19:47

If one of the dimensions becomes one, do we continue with an (k-1)-dimensional problem, or does every cut remove all blocks?

In either case, can someone give me some sample I/O, since I currently get WA #3 (assuming the first two are the sample cases).

I think, it's a simple recursion.
If N is even, then
f(N)=f(N-1)+f(N/2)
else if N is odd, then
f(N)=f(N-1)
Am I right?

Can somebody give me some tests (hard tests)

In my opinion, the tests for this problem are not good enough, because incorrect solutions pass system tests.

For example, the solution that outputs "4 4" for test "1 1 3"  is succesfully passing systests and have AC, but the correct answer is "4 3"!!!


Sorry for my English :)

Edited by author 05.03.2007 21:11

what is the 8th test? thanks!

I think you gave wrong sample test
for n=4 min is not 1 4 2 3 it is 4 1 2 3
because
1*4+4*2+2*3=18 but 4*1+1*2+2*3=12

thie example:
3 1 2 1
1 1

answer
1 1


if G choose the first ring from the first row, then the first row will be dematerialised, because there is 3 and all numbers of the first row <=3. So S will win in the next move.

WA On Test #16

#include <stdio.h>
#include <memory.h>
#include <stdlib.h>

#define max(a, b) (a) > (b) ? (a) : (b)

bool link[101][101];
int n;

int main(void){
    memset(link, false, sizeof(link));

    scanf("%d", &n);
    for (int i = 1; i <= n; i++){
        int next; scanf("%d", &next);
        while (next != 0){
              link[i][next] = true;
              scanf("%d", &next);
        }
    }

    for (int i = 1; i <= n; i++){
        for (int j = i + 1; j <= n; j++){
            if (!link[i][j] || !link[j][i]){
               link[i][j] = link[j][i] = true;
            }  else {
               link[i][j] = link[j][i] = false;
            }
        }
    }

    bool vis[101]; memset(vis, false, sizeof(vis));
    int blocks[101][101][2], blocks_size[101][2], blocks_count = -1;
    for (int i = 1; i <= n; i++){
        for (int j = i + 1; j <= n; j++){  //???????????
            if (link[i][j] && !vis[i]){
               int queue[2][101], queue_size[2], head[2];
               queue_size[0] = queue_size[1] = 0;
               head[0] = head[1] = 0;
               queue[1][0] = i; vis[i] = true;
               queue[0][0] = j; vis[j] = true;
               while (head[0] <= queue_size[0] || head[1] <= queue_size[1]){
                     if (head[0] <= queue_size[0]){
                        int point = queue[0][head[0]];
                        for (int k = 1; k <= n; k++){
                            if (link[point][k] && !vis[k]){
                               queue[1][++queue_size[1]] = k;
                               vis[k] = true;
                            }
                        }
                        head[0]++;
                     }

                     if (head[1] <= queue_size[1]){
                        int point = queue[1][head[1]];
                        for (int k = 1; k <= n; k++){
                            if (link[point][k] && !vis[k]){
                               queue[0][++queue_size[0]] = k;
                               vis[k] = true;
                            }
                        }
                        head[1]++;
                     }
               }

               for (int k = 0; k <= queue_size[0]; k++){
                   for (int l = k + 1; l <= queue_size[0]; l++){
                       if (link[queue[0][k]][queue[0][l]]){
                          printf("No solution\n");
                          getchar(); getchar(); getchar(); getchar();
                          return 0;
                       }
                   }
               }

               for (int k = 0; k <= queue_size[1]; k++){
                   for (int l = k + 1; l <= queue_size[1]; l++){
                       if (link[queue[1][k]][queue[1][l]]){
                          printf("No solution\n");
                          getchar(); getchar(); getchar(); getchar();
                          return 0;
                       }
                   }
               }

               blocks_count++;
               blocks_size[blocks_count][0] = queue_size[0];
               blocks_size[blocks_count][1] = queue_size[1];
               for (int k = 0; k <= queue_size[0]; k++) blocks[blocks_count][k][0] = queue[0][k];
               for (int k = 0; k <= queue_size[1]; k++) blocks[blocks_count][k][1] = queue[1][k];
            }
        }
    }

    for (int i = 1; i <= n; i++){
        if (!vis[i]){
           blocks_count++;
           blocks_size[blocks_count][0] = 0;
           blocks_size[blocks_count][1] = -1;
           blocks[blocks_count][0][0] = i;
           vis[i] = true;
        }
    }

    bool status[101], status_x[101];
    bool way[101][101], way_x[101][101];
    memset(way, false, sizeof(way));
    memset(status, false, sizeof(status));
    status[0] = true;
    for (int i = 0; i <= blocks_count; i++){
        memset(way_x, false, sizeof(way_x));
        memset(status_x, false, sizeof(status_x));
        for (int j = 0; j <= n / 2; j++){
            if (status[j]){
               if (!status_x[j + blocks_size[i][0] + 1] && j + blocks_size[i][0] + 1 <= n / 2){
                     status_x[j + blocks_size[i][0] + 1] = true;
                  memcpy(way_x[j + blocks_size[i][0] + 1], way[j], sizeof(way_x[j + blocks_size[i][0] + 1]));
                     for (int k = 0; k <= blocks_size[i][0]; k++){
                            way_x[j + blocks_size[i][0] + 1][blocks[i][k][0]] = true;
                  }
               }

               if (!status_x[j + blocks_size[i][1] + 1] && j + blocks_size[i][1] + 1 <= n / 2){
                     status_x[j + blocks_size[i][1] + 1] = true;
                  memcpy(way_x[j + blocks_size[i][1] + 1], way[j], sizeof(way_x[j + blocks_size[i][1] + 1]));
                     for (int k = 0; k <= blocks_size[k][1]; k++){
                            way_x[j + blocks_size[i][1] + 1][blocks[i][k][1]] = true;
                     }
               }
            }
        }
        memcpy(way, way_x, sizeof(way_x));
        memcpy(status, status_x, sizeof(status_x));
    }

    for (int i = n / 2; i >= 1; i--){
        if (status[i]){
           printf("%d", i);
           for (int j = 1; j <= n; j++){
                  if (way[i][j]) printf(" %d", j);
           }

           printf("\n%d", n - i);
           for (int j = 1; j <= n; j++){
                  if (!way[i][j]) printf(" %d", j);
           }
        }

        break;
    }

    getchar(); getchar(); getchar(); getchar();
}