Problem B: 平行

Problem B: 平行
Special Judge

Time Limit: 1000 ms Memory Limit: 512 MB

Submit Solution

Description

【题目描述】

二维直角坐标系中有N个点，它们的横、纵坐标的绝对值都不超过10。

一次操作，你可以选择某3个不共线的点A、B、C。然后以AB为对角线、C为另一顶点绘制平行四边形ABCD，然后用点D替换点C（即删去点C保留点A、B、D）。则D是确定并且唯一的。

最初，N个点的坐标互不相同。操作过程中这些点的坐标可以重合。但是，要求所有新点的坐标的绝对值不超过109。

请你判断：能否在2500次操作以内，使得所有N个点都出现在第一象限？即，通过若干次操作使得所有点的横、纵坐标非负。如果可以，请给出一个方案。

注意：本题有Special Judge。

【输入格式】

  第一行，一个整数N。

接下来N行，每行两个整数Xi, Yi，表示一个点的横、纵坐标。

保证N个点的最初坐标均不相同。

【输出格式】

如果无解，请输出-1；

否则，第一行输出一个整数M，表示进行多少次操作。接下来M行，每行输出三个不同的整数A、B、C，表示一次操作。每次操作后，点A、B的坐标不变，点C的坐标会根据题目描述中的规则进行变换。

【样例输入1】

4

5 0

0 5

-2 -2

-3 2

【样例输出1】

2

1 2 3

1 2 4

【数据规模与约定】

对于40%的数据， N ≤ 10.

 对于100%的数据，3 ≤ N ≤ 400, -10 ≤ Xi, Yi ≤ 10.

Submit Solution

考虑横纵坐标绝对值范围只有10，那么如果有三个不共线得点横纵坐标均大于5，那么一定可以把所有点都移到一象限…
那么找到一个三角形，然后可以发现他沿着两条边操作两次可以变成平移，然后再考虑他的移动的向量，然后找到两种平移方式就一定可以构成两个单位向量，然后操作即可…
细节见代码.
c++代码如下：

#include<bits/stdc++.h>
#define rep(i,x,y) for(register int i = x ;i <= y;++ i)
#define repd(i,x,y) for(register int i = x ; i >= y;-- i)
using namespace std;
typedef long long ll;
template<typename T>inline void read(T&x)
{
    x = 0;char c;int sign = 1;
    do { c = getchar(); if(c == '-') sign =- 1; }while(!isdigit(c));
    do { x = x * 10  + c - '0'; c = getchar(); }while(isdigit(c));
    x *= sign;
}

const int N = 501;
int n,a,b,c,K = 15;
struct Point { int x,y; }p[N];
struct Q{ int x,y,z; };
vector<Q> ans; bool vis[N];
inline int cross(Point a,Point b) { return a.x * b.y - b.x * a.y; }
Point operator - (Point a,Point b){ return (Point){a.x - b.x,a.y - b.y}; }
Point operator + (Point a,Point b){ return (Point){a.x + b.x,a.y + b.y}; }
inline bool check(Point a) { return a.x > K && a.y > K; }

inline void modify(int a,int b,int c)
{
    Point d = p[a] - p[c];
    p[c] = p[b] + d;
    ans.push_back((Q){a,b,c});
}

inline void update(int a,int b,int c)
{
    modify(a,b,c); modify(a,c,b);
    modify(b,c,a); modify(a,c,b);
}

inline void rev_update(int a,int b,int c)
{
    modify(a,c,b); modify(b,c,a);
    modify(a,c,b); modify(a,b,c);
}

inline void solve()
{
    Point D = p[a]; update(a,b,c); Point d = p[a] - D;
    Point E = p[a]; update(b,c,a); Point e = p[a] - E;
    if(n == 3) K = 0;
    if(d.x * e.x < 0)
    {
        if(d.y * abs(e.x) + e.y * abs(d.x) < 0)
        {
            while(p[a].y <= K || p[b].y <= K || p[c].y <= K)
            {
                rep(i,1,abs(e.x)) rev_update(a,b,c);                    
                rep(i,1,abs(d.x)) rev_update(b,c,a);
            }
        }
        else
        {
            while(p[a].y <= K || p[b].y <= K || p[c].y <= K)
            {
                rep(i,1,abs(e.x)) update(a,b,c);        
                rep(i,1,abs(d.x)) update(b,c,a);
            }
        }
    }else
    {
        Point D = p[a]; rev_update(a,b,c); Point d = p[a] - D;update(a,b,c);
        if(d.y * abs(e.x) + e.y * abs(d.x) < 0)
        {
            while(p[a].y <= K || p[b].y <= K || p[c].y <= K)
            {
                rep(i,1,abs(e.x)) update(a,b,c);
                rep(i,1,abs(d.x)) rev_update(b,c,a);
            }
        }
        else
        {
            while(p[a].y <= K || p[b].y <= K || p[c].y <= K)
            {
                rep(i,1,abs(e.x)) rev_update(a,b,c);        
                rep(i,1,abs(d.x)) update(b,c,a);
            }
        }

    }

    D = p[a]; update(a,b,c); d = p[a] - D; rev_update(a,b,c);

    if(d.y * e.y < 0)
    {
        if(d.x * abs(e.y) + e.x * abs(d.y) < 0)
        {
            while(p[a].x <= K || p[b].x <= K || p[c].x <= K)
            {
                rep(i,1,abs(e.y)) rev_update(a,b,c);
                rep(i,1,abs(d.y)) rev_update(b,c,a);
            }
        }
        else
        {
            while(p[a].x <= K || p[b].x <= K || p[c].x <= K)
            {
                rep(i,1,abs(e.y)) update(a,b,c);                    
                rep(i,1,abs(d.y)) update(b,c,a);
            }
        }
    }else
    {
        Point D = p[a]; rev_update(a,b,c); Point d = p[a] - D;update(a,b,c);
        if(d.x * abs(e.y) + e.x * abs(d.y) < 0)
        {
            while(p[a].x <= K || p[b].x <= K || p[c].x <= K)
            {
                rep(i,1,abs(e.y)) update(a,b,c);            
                rep(i,1,abs(d.y)) rev_update(b,c,a);
            }
        }
        else
        {
            while(p[a].x <= K || p[b].x <= K || p[c].x <= K)
            {
                rep(i,1,abs(e.y)) rev_update(a,b,c);
                rep(i,1,abs(d.y)) update(b,c,a);
            }
        }
    }
}

int main()
{
    read(n);
    rep(i,1,n) { read(p[i].x); read(p[i].y); }

    rep(i,1,n)
        rep(j, i + 1,n)
            rep(k,j +1,n)
                if(cross(p[j] - p[i],p[k] - p[i]) != 0)
                {
                    a = i; b = j; c = k;
                    vis[a] = vis[b] = vis[c] = 1;

                    solve();
                    rep(z,1,n)
                        if(!vis[z])
                        {
                            if(cross(p[a] - p[z],p[a] - p[b]) != 0) ans.push_back((Q){a,b,z});
                            else ans.push_back((Q){a,c,z});
                        }

                    printf("%d\n",ans.size());
                    rep(z,0,((int)ans.size())-1)
                    {
                        printf("%d %d %d\n",ans[z].x,ans[z].y,ans[z].z);
                    }
                    exit(0);
                }

    puts("-1");
    return 0;
}