The coordinates are given in the traversal order.

One of them was found on the forum, too.

4
0 0
0 1
1 1
1 0
YES

5
0,654508 0,0244717
0,0954915 0,206107
0,0954915 0,793893
0,654508 0,975528
1 0,5
YES

5
1 0,5
0,654508 0,975528
0,0954915 0,793893
0,0954915 0,206107
0,654508 0,0244717
YES

12
-0,1 0,3
0,1 0,3
0,1 0,1
0,3 0,1
0,3 -0,1
0,1 -0,1
0,1 -0,3
-0,1 -0,3
-0,1 -0,1
-0,3 -0,1
-0,3 0,1
-0,1 0,1
NO

8
0 0
0 -1
1 -1
1 0
0 0
0 1
1 1
1 0
NO

My algo is to check that:
1) all spins done in same side
2) all sides are equal
3) all angles are equal
4) in any comparsions precision equals 0.000001 (I tried many variants of precision but got WA12 in any case)

It's hard for me to find tests in this problem :(
What the hell is 12 test?

Edited by author 04.10.2012 12:13

If WA 37 then add this code( check: if there exist equal points ):
//////////////////////
void no(){
    puts("NO");
    exit(0);
}
//////////////////////
inline bool equal_lf( const double x, const double y ){
    return fabs(x-y)<=EPS;
    return fabs(x-y) <= EPS*max( fabs(x),fabs(y) );
}

//////////////////////
int main(){
///////////lalalalalalalal

    for( short i = 0; i < n; ++i ){
        for( short j = i+1; j < n; ++j ){
            if( equal_lf(p[i].x,p[j].x) && equal_lf(p[i].y,p[j].y) ) no();
        }
    }

I've tried many times, what's wrong?
All eps between 1e-10 and 1e-5 have given this. Any ideas?
I use a trivial algo, maybe another one exists?

your 8h test is incorrect, the answer is ALWAYS NO if n != 4
if u contact me, I'll give you the prove

If some points coincide, then the answer is yes or no?

Who can tell me what is wrong?

// Geometry.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <queue>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>

using namespace std;

#define sz(a)    (a.size())
#define all(a)   (a.begin(),a.end())
#define Sort(a)  (sort(all(a)))
#define pb       (push_back)
#define dump(x)    cerr<<#x<<" = "<<(x)<<endl;
#define debug(x)  cerr<<#x<<" = "<<(x)<<" (L"<< __LINE__ <<")"<<" "<< __FILE__ <<endl;
#define eps 1e-7
int sign (double x)  { return ((x)>eps?1:((x)<-eps?2:0));}


const double PI=acos(-1.0);
const int INF=2100000000;
struct point {
    double x;
    double y;
};
struct line {
    point a;
    point b;
};
double mult(point p1,point p2,point p0){
    return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);
}
double sqrdist(point a,point b){
    return ((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
int is_convex(int n,point *p){
    int i,s[3]={1,1,1};
    for(i=0;i<n && s[1]|s[2];i++){
        double x=(mult(p[(i+1)%n],p[(i+2)%n],p[i]));
        s[sign(x)]=0;
    }
    return s[1]|s[2];
}
bool dist(int n,point *p){
    double dis=sqrdist(p[0],p[1]);
    int i;
    for(i=0;i<n;i++){
        if(fabs(dis-sqrdist(p[i],p[(i+1)%n]))>=eps){
            return (false);
        }
    }
    return (true);
}
double distance1(point a,point b){
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
double getangle(point a,point b,point c){
    double sq=((a.x-b.x)*(a.y-c.y)-(a.x-c.x)*(a.y-b.y));
    double ab=distance1(a,b);
    double bc=distance1(b,c);
    double sinphi=(ab*bc)/sq;
    return asin(sinphi);
}
bool isangles(int n,point *p){
    double sinphi=getangle(p[0],p[1],p[2]);
    int i;
    for(i=0;i<n;i++){
        if(fabs(sinphi-getangle(p[i],p[(i+1)%n],p[(i+2)%n]))>eps){
            return (false);
        }
    }
    return (true);
}
bool isRight(int n,point *p){
    if(dist(n,p) && is_convex(n,p) && isangles(n,p)){
        return (true);
    }
    return (false);
}
int main(){
    int n;
    int i;
    cin>>n;
    point *p=new point [n];
    for(i=0;i<n;i++){
        cin>>p[i].x;
        cin>>p[i].y;
    }
    (isRight(n,p))?(puts("YES")):(puts("NO"));
    return (0);
}

What the fucking test is it? I failed on it many times, using every possible precision in calculations!

OH I've found my mistake!!!!!

Edited by author 19.04.2010 17:58

Edited by author 19.04.2010 17:59

It could be proven that for n != 4 there is always 'NO' answer.
Is it right for each test?

What is test 18?

Can the polygon vertices be given in clockwise order and the answer still be yes?
Can I have coinciding points and the answer still be yes (so do I aim for regular exactly n gon?)