HDU_6590 Code 【凸包】

一、题目

　　Code

二、分析

　　题目描述了一大堆东西，就是想问二维空间里，能不能确定$d  w_1   w_2$使得函数满足$f(x_1,x_2) = y$，并且$sign(x)$函数是一个信号函数，只取3种值。

　　那么将函数拆开其实就是$d + w_{1}x_{i_1} + w_{2}x_{i_2} = y$，因为$y$给定，发现就是一个二维平面里的直线，我们只需要将所有$y=1$和$y=-1$的点分类，能不能确定$w_1$和$w_2$使得所有点的值都等于$-1$或者$1$，即$<0$或者$>0$而等于$0$的情况相当于就是一条直线，将两类点分开。所以转换一下就是求两个凸包是否相交。

三、AC代码

#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define Min(a,b) ((a)>(b)?(b):(a))
#define Max(a,b) ((a)>(b)?(a):(b))
#define P pair<int, int>
const double EPS = 1e-8;
const int MAXN = 1e2+13;
const int INF = 1e5;

//带误差比较，返回x是否等于y
inline bool dcmp(double x, double y = 0)
{
    return fabs(x - y) <= EPS;
}

//向量
//需要使用一个原点到(x,y)的有向线段表示
typedef struct Vec
{
    double x, y;

    Vec(double x = 0, double y = 0) : x(x),y(y) {}

    //向量相加
    Vec operator+(const Vec &v) const{
        return Vec(x + v.x, y + v.y);
    }

    //向量相减
    Vec operator-(const Vec &v) const{
        return Vec(x - v.x, y - v.y);
    }

    //向量数乘 即向量*数d
    Vec operator*(double d) const{
        return Vec(x * d, y * d);
    }

    Vec operator/(double d) const{
        return Vec(x / d, y / d);
    }
    
    //范数，及长度的平方
    double norm() const{
        return x * x + y * y;
    }
}Pt;

//点乘
double dot(const Vec &a, const Vec &b)
{
    return a.x * b.x + a.y * b.y;
}

//叉乘
//叉乘可以表示四边形的面积
double cross(const Vec &a, const Vec &b)
{
    return a.x * b.y - a.y * b.x;
}

//线段，两个点表示
struct Seg
{
    Pt a, b;

    Seg(const Pt &a, const Pt &b) : a(a), b(b) {}

    //线段包含点(点在线段上)
    //先判断是否叉乘等于 0， 如果等于0表示点在线段所在的直线上
    //再判断点乘是否小于等于0
    //小于0表示两向量夹角为180，刚好在线段内，
    //等于0表示刚好在线段两端
    bool include(const Pt &p) {
        return dcmp(cross(a - p, b - p)) && dot(a - p, b - p) <= 0;
    }
};

//直线，两个点表示
struct Line
{
    Pt a, b;

    Line() {}   //提供一个不需要参数的构造函数
    Line(const Pt &a, Pt &b) : a(a), b(b) {}

    //点在直线上
    bool include(const Pt &p) const {
        return dcmp(cross(a - p, b - p));
    }

    //两直线关系
    //  1 表示两直线相交（1交点）
    //  0 表示两直线平行（0交点）
    // -1 表示两直线重合（无数交点）
    static int relation(const Line &a, const Line &b) {
        if(a.include(b.a) && a.include(b.b))    return -1;
        else if(dcmp(cross(a.b - a.a, b.b - b.a)))  return 0;
        else return 1;
    }

    //求两直线交点(若有一个交点)
    static Pt intersect(const Line &a, const Line &b) {
        double s1 = cross(b.a - a.a, b.b - a.a), s2 = cross(b.b - a.b, b.a - a.b);
        return a.a + (a.b - a.a) * s1 / (s1 + s2);
    }

};

//凸包的交点
int n;
Pt a[MAXN + 1];

//凸包极角比较函数
inline bool compare(const Pt &a, const Pt &b)
{
    //以第一个点为原点的两个向量
    Vec va = a - ::a[1], vb = b - ::a[1];
    double t = cross(va, vb);
    //t>0 表示b的极角大，b在a的逆时针方向
    //t<0 表示a的极角大，b在a的顺时针方向
    //t=0 表示a与b极角相同，则比较长度
    if(!dcmp(t)) return t > 0;
    else return va.norm() < vb.norm();
}

//多边形
struct Poly
{
    std::vector<Pt> pts;
    
    //判断点是否在多边形内
    //射线法，作平行于x轴的线
    bool include(const Pt &p) const {
        int cnt = 0;
        //判断与每条边是否有交点
        for(size_t i = 0; i < pts.size(); i++) {
            //枚举相邻两点
            const Pt &a = pts[i], &b = pts[(i+1)%pts.size()];

            //如果点p在边AB上
            if(Seg(a, b).include(p))    return true;

            double d1 = a.y - p.y, d2 = b.y - p.y, tmp = cross(a - p, b- p);
            //如果tmp >= 0 && d1 >= 0 && d2 <= 0 那么点在多边形内会被标记两次
            //将无法排除点在外面刚好记录两次的情况
            if( (tmp >= 0 && d1 >= 0 && d2 < 0) || (tmp <= 0 && d1 < 0 && d2 >=0)) cnt++;
        }
        //因为点可能刚好在外面与边交于一顶点，那么会判断两次
        //所以根据判断的次数是否为奇数判断
        return cnt % 2 == 1;
    }

    //多边形面积

    bool area() const {
        double res = 0;
        for(size_t i = 0; i < pts.size(); i++) {
            //枚举两个点
            const Pt &a = pts[i], &b = pts[(i+1) % pts.size()];
            res += cross(a, b);
        }
        return res/2;
    }
    
    //求凸包，结果存储在自身pts中
    void convex() {
        int id = 1;
        //找最左下角的点当原点
        for(int i = 1; i <= n; i++) {
            if(a[i].x < a[id].x || (a[i].x == a[id].x && a[i].y < a[id].y))
                id = i;
        }
        if(id != 1) std::swap(a[1], a[id]);

        //极角排序
        std::sort(a + 2, a + n + 1, &compare);

        //扫描
        pts.push_back(a[1]);
        for(int i = 2; i <= n; i++) {
            //比较，如果最后一个点在凸包内，则被弹出
            while(pts.size() >= 2 && cross(a[i] - pts[pts.size() - 2], pts.back() - pts[pts.size() - 2]) >= 0 )
                pts.pop_back();
            pts.push_back(a[i]);
        }
    }
};

bool solve(Poly &a, Poly &b)
{
    for(int i = 0; i < b.pts.size(); i++) {
        if(a.include(b.pts[i]))
            return false;
    }
    for(int i = 0; i < a.pts.size(); i++) {
        if(b.include(a.pts[i]))
            return false;
    }
    return true;
}

Pt c1[MAXN], c2[MAXN];

int main()
{
    freopen("input.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    int T;
    scanf("%d", &T);
    while(T--) {
        int N, x, y, f;
        scanf("%d", &N);
        Poly p1, p2;
        int N1 = 1, N2 = 1;
        for(int i = 0; i < N; i++) {
            scanf("%d%d%d", &x, &y, &f);
            if(f == -1) {
                c1[N1++] = Pt(x+INF, y+INF);
            }
            else {
                c2[N2++] = Pt(x+INF, y+INF);
            }
        }
        for(int i = 1; i < N1; i++) {
            a[i] = c1[i];
        }
        n = N1 - 1;
        p1.convex();
        for(int i = 1; i < N2; i++) {
            a[i] = c2[i];
        }
        n = N2 - 1;
        p2.convex();
        // cout << " py1    " << endl;
        // for(int i = 0; i< p1.pts.size(); i++) {
        //     cout << p1.pts[i].x << " , " << p1.pts[i].y << endl;
        // }
        // cout << " py2    " << endl;
        // for(int i = 0; i< p2.pts.size(); i++) {
        //     cout << p2.pts[i].x << " , " << p2.pts[i].y << endl;
        // }
        if(solve(p1, p2)) {
            puts("Successful!");
        }
        else puts("Infinite loop!");
    }
    return 0;
}