POJ1228 Grandpa's Estate

 题目：http://acm.pku.edu.cn/JudgeOnline/problem?id=1228

 思路：必须保证凸包的每条边上至少有3个原始点，如果给出的点小于等于5肯定是NO，因为最少的凸边形还需要6个点，最后要判断，如果凸包是一条线，那么还是NO。

 

1. import java.io.BufferedReader;
2. import java.io.IOException;
3. import java.io.InputStreamReader;
5. public class Main {
7.     class Point {
8.         int x;
9.         int y;
11.         public Point(int x, int y) {
12.             this.x = x;
13.             this.y = y;
14.         }
15.     }
17.     public static void main(String[] args) throws NumberFormatException,
18.             IOException {
19.         Main main = new Main();
20.         BufferedReader read = new BufferedReader(new InputStreamReader(
21.                 System.in));
22.         int n = Integer.parseInt(read.readLine());
23.         Point[] p;
24.         Point[] ch;
25.         int x, y;
26.         String[] s;
27.         int len;
28.         int t;
29.         boolean b;
30.         for (int i = 0; i < n; i++) {
31.             int m = Integer.parseInt(read.readLine());
32.             p = new Point[m];
33.             for (int j = 0; j < m; j++) {
34.                 s = read.readLine().split(" ");
35.                 x = Integer.parseInt(s[0]);
36.                 y = Integer.parseInt(s[1]);
37.                 p[j] = main.new Point(x, y);
38.             }
39.             if (m <= 5) {
40.                 System.out.println("NO");
41.             } else {
42.                 ch = new Point[m];
43.                 len = 0;
44.                 len = Graham_scan(p, ch, m);
45.                 b = false;
46.                 t = 0;
47.                 for (int j = 0; j < len - 2; j++) {
48.                     if (!AtOneLine(ch[j], ch[j + 1], ch[j + 2])) {
49.                         b = true;
50.                         break;
51.                     }
52.                 }
53.                 if (b) {
54.                     for (int j = 0; j < len - 1; j++) {
55.                         for (int k = 0; k < m; k++) {
56.                             if (AtOneLine(ch[j], ch[j + 1], p[k])) {
57.                                 t++;
58.                             }
59.                         }
60.                         if (t < 3) {
61.                             b = false;
62.                             break;
63.                         }
64.                         t = 0;
65.                     }
66.                 }
67.                 if (b) {
68.                     System.out.println("YES");
69.                 } else {
70.                     System.out.println("NO");
71.                 }
72.             }
73.         }
74.     }
76.     public static boolean AtOneLine(Point p1, Point p2, Point p3) {
77.         return ((p1.x - p2.x) * (p1.y - p3.y) == (p1.x - p3.x) * (p1.y - p2.y));
78.     }
80.     public static double multiply(Point p1, Point p2, Point p0) {
81.         return ((p1.x - p0.x) * (p2.y - p0.y) - (p2.x - p0.x) * (p1.y - p0.y));
83.     }
85.     public static double distance(Point p1, Point p2) {
86.         return (Math.sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y)
87.                 * (p1.y - p2.y)));
88.     }
90.     public static int Graham_scan(Point[] PointSet, Point[] ch, int n) {
91.         int i, j, k = 0, top = 2;
92.         Point tmp;
93.         for (i = 1; i < n; i++)
94.             if ((PointSet[i].y < PointSet[k].y)
95.                     || ((PointSet[i].y == PointSet[k].y) && (PointSet[i].x < PointSet[k].x)))
96.                 k = i;
97.         tmp = PointSet[0];
98.         PointSet[0] = PointSet[k];
99.         PointSet[k] = tmp;
100.         for (i = 1; i < n - 1; i++) {
101.             k = i;
102.             for (j = i + 1; j < n; j++)
103.                 if ((multiply(PointSet[j], PointSet[k], PointSet[0]) > 0)
104.                         || ((multiply(PointSet[j], PointSet[k], PointSet[0]) == 0) && (distance(
105.                                 PointSet[0], PointSet[j]) < distance(
106.                                 PointSet[0], PointSet[k]))))
107.                     k = j;
108.             tmp = PointSet[i];
109.             PointSet[i] = PointSet[k];
110.             PointSet[k] = tmp;
111.         }
112.         ch[0] = PointSet[0];
113.         ch[1] = PointSet[1];
114.         ch[2] = PointSet[2];
115.         for (i = 3; i < n; i++) {
116.             while (top > 0 && multiply(PointSet[i], ch[top], ch[top - 1]) >= 0)
117.                 top--;
118.             ch[++top] = PointSet[i];
119.         }
120.         return top + 1;
121.     }
123. }