杭电oj初体验之 Code

PLA算法：

https://blog.csdn.net/red_stone1/article/details/70866527

The problem:

Analysis:

题目链接可见：https://vjudge.net/contest/313395#problem/M

Reference codes:

 #include <cstdio>
 #include <vector>
 #include <iostream>
 #include <algorithm>
 using namespace std;

 const int N = ;

 int n;

 int sgn(long long x) {
     return (x > ) - (x < );
 }

 struct P {
     long long d[];
     long long& operator[](int x) {
         return d[x];
     }
     P () {}
     P (long long a, long long b, long long c) {
         d[] = a; d[] = b; d[] = c;
     }
 };

 struct node {
     P x;
     int y;
 } p[N];

 P operator+(P a, P b) {
     P c;
     for (int i = ; i < ; i++)
         c[i] = a[i] + b[i];
     return c;
 }

 P operator-(P a, P b) {
     P c;
     for (int i = ; i < ; i++)
         c[i] = a[i] - b[i];
     return c;
 }

 P operator*(int a, P b) {
     P c;
     for (int i = ; i < ; i++)
         c[i] = a * b[i];
     return c;
 }

 bool operator<(P a, P b) {
     return a[] < b[] || (a[] == b[] && a[] < b[]);
 }

 long long operator*(P a, P b) {
     return a[] * b[] - a[] * b[];
 }

 long long operator^(P a, P b) {
     return a[] * b[] + a[] * b[];
 }

 long long det(P a, P b, P c) {
     return (b - a) * (c - a);
 }

 struct L {
     P a, b;
     L () {}
     L (P x, P y) {
         a = x; b = y;
     }
 };

 bool onSeg(P p, L s) {
     return sgn(det(p, s.a, s.b)) ==  && sgn((s.a - p) ^ (s.b - p)) <= ;
 }

 vector<P> convex(vector<P> p) {
     vector<P> ans, S;
     for (int i = ; i < p.size(); i++) {
         while (S.size() >=
                 && sgn(det(S[S.size() - ], S.back(), p[i])) <= )
                     S.pop_back();
         S.push_back(p[i]);
     }
     ans = S;
     S.clear();
     for (int i = (int)p.size() - ; i >= ; i--) {
         while (S.size() >=
                 && sgn(det(S[S.size() - ], S.back(), p[i])) <= )
                     S.pop_back();
         S.push_back(p[i]);
     }
     for (int i = ; i +  < S.size(); i++)
         ans.push_back(S[i]);
     return ans;
 }

 bool PointInPolygon(P p, vector<P> poly) {
     int cnt = ;
     for (int i = ; i < poly.size(); i++) {
         if (onSeg(p, L(poly[i], poly[(i + ) % poly.size()]))) return true;
         int k = sgn(det(poly[i], poly[(i + ) % poly.size()], p));
         int d1 = sgn(poly[i][] - p[]);
         int d2 = sgn(poly[(i + ) % poly.size()][] - p[]);
         if (k >  && d1 <=  && d2 > ) cnt++;
         if (k <  && d2 <=  && d1 > ) cnt--;
     }
     if (cnt != ) return true;
     return false;
 }

 bool SegmentIntersection(L l1, L l2) {
     long long c1 = det(l1.a, l1.b, l2.a), c2 = det(l1.a, l1.b, l2.b);
     long long c3 = det(l2.a, l2.b, l1.a), c4 = det(l2.a, l2.b, l1.b);
     if (sgn(c1) * sgn(c2) <  && sgn(c3) * sgn(c4) < ) return true;
     if (sgn(c1) ==  && onSeg(l2.a, l1)) return true;
     if (sgn(c2) ==  && onSeg(l2.b, l1)) return true;
     if (sgn(c3) ==  && onSeg(l1.a, l2)) return true;
     if (sgn(c4) ==  && onSeg(l1.b, l2)) return true;
     return false;
 }

 bool ConvexHullDivide(vector<P> p1, vector<P> p2) {
     for (int i = ; i < p1.size(); i++)
         if (PointInPolygon(p1[i], p2))
             return false;
     for (int i = ; i < p2.size(); i++)
         if (PointInPolygon(p2[i], p1))
             return false;
     for (int i = ; i < p1.size(); i++)
         for (int j = ; j < p2.size(); j++)
             if (SegmentIntersection(L(p1[i], p1[(i + ) % p1.size()]), L(p2[j], p2[(j + ) % p2.size()])))
                 return false;
     return true;
 }

 bool check() {
     vector<P> p1, p2;
     for (int i = ; i <= n; i++) {
         if (p[i].y == )
             p1.push_back(p[i].x);
         else
             p2.push_back(p[i].x);
     }
     vector<P> c1, c2;
     c1 = convex(p1);
     c2 = convex(p2);
     if (ConvexHullDivide(c1, c2)) return true;
     return false;
 }

 int f(P w, P x) {
     long long sum = ;
     for (int i = ; i < ; i++)
         sum += w[i] * x[i];
     return sgn(sum);
 }

 void PLA() {
     P w = P(, , );
     int i = , cnt = ;
     long long cc = ;
     while (true) {
         cc++;
         if (f(w, p[i].x) != p[i].y) {
             w = w + p[i].y * p[i].x;
             cnt = ;
         }
         else {
             if (++cnt == n) break;
         }
         i = i + ;
         if (i > n) i -= n;
     }
     cout << cc << endl;
 }

 int main() {
     int testcase;
     cin >> testcase;
     while (testcase--) {
         cin >> n;
         for (int i = ; i <= n; i++) {
             cin >> p[i].x[] >> p[i].x[] >> p[i].y;
             p[i].x[] = ;
         }
         if (!check())
             puts("Infinite loop!");
         else {
             puts("Successful!");
         }
     }
     return ;
 }