Be careful in the precision of Double

When i used ---sqrt(2)/2--- whith 10 numbers i got WA3
With 12 -Wa7
And with 16- i finally got AC
d=0.7071067811865475;-16 numbers

Same to me. Here's my code:

#include <iostream.h>
void main()
{
    int N;
    cin >> N;
    long mas[4]={10,760,55252,4816030};
    N/=2;
    cout << mas[N-1];
}

It never occured to me, there was a bug in the old solution.

thanks... I got AC...

Edited by author 21.02.2008 13:51

Unfortunately, I should join to the previous speaker =(
Some measures should be taken: to empower equipment or to increase difficulty of the problems...

The same. I'm wasted my time for waiting and in result I didn't have enough few minutes to correct my mistake((

The meaning of the problem wasn't clearly.
too many user got Wrong Answer and they submit program one by one.

Problems with slow judging isn't new for us. We've already planned to set up a new server for judging. Unfortunately we hadn't have it in time. But it will be set up before next contest.

 I used float in c++ and
  don't have any problem.

Hi test #3 10 !

Your helper about this problem probably may be MSDN
because the problem has short simple code

using System;
using System.Collections;

namespace граф_1
{

    class Class1
    {

        [STAThread]
        static void Main(string[] args)

            {
                //читаем
                int n = int.Parse(Console.ReadLine());
                int m = int.Parse(Console.ReadLine());
                int[,] graf = new int[n,n];
                for (int i = 0; i < n; i++)
                    for (int j = 0; j < n; j++)
                        graf[i, j] = 0;
                for (int i = 0; i < m; i++)
                {
                    string s = Console.ReadLine();
                    string[] s1 = s.Split(' ');
                    graf[int.Parse(s1[0]) - 1, int.Parse(s1[1]) - 1] = 1;
                    graf[int.Parse(s1[1]) - 1, int.Parse(s1[0]) - 1] = 1;
                }
                //Обходим все вершины
                int[] part = new int[n];
                Queue q = new Queue(n);
                bool[] discovered = new bool[n];
                for (int i = 0; i < n; i++)
                {
                    part[i] = 0;
                    discovered[i] = false;
                }
                part[0] = 1;
                bool b = true;
                //определяем, к какой доле они принадлежат
                q.Enqueue(0);
                discovered[0] = true;
                while(q.Count != 0)
                {
                    int v = (int) q.Dequeue();
                    for(int i = 0; i < n; i++)
                    {
                        if(graf[v,i] == 1)
                        {
                            if (!discovered[i])
                            {
                                discovered[i] = true;
                                q.Enqueue(i);
                            }
                            if (part[i] != part[v])
                                part[i] = -part[v];
                            else
                                b = false;
                        }
                    }
                    if (!b)
                        break;
                }
                if (b)
                {
                    for (int i = 0; i < n; i++)
                        if(part[i]==1)
                            Console.WriteLine(i+1);
                }
                else
                    Console.WriteLine(0);

            }
        }
    }

There algorithm more complex

Edited by author 28.02.2008 08:35