bupt summer training for 16 #2 ——计算几何

https://vjudge.net/contest/171368#overview

A.一个签到题，用叉积来判断一个点在一条线的哪个方向

可以二分，数据范围允许暴力

 #include <cstdio>

 struct point {
     int x, y;
 }a[];

 int n, m, x[], y[], c[];

 int _cross(const point &A, const point &B) {
     return A.x * B.y - A.y * B.x;
 }

 int main() {
     while(scanf("%d %d %d %d %d %d", &n, &m, &x[], &y[], &x[], &y[]) != EOF) {
         if(n == ) break;
         c[] = ;
         for(int i = ;i <= n;i ++)
             scanf("%d %d", &a[i].x, &a[i].y), c[i] = ;
         for(int X, Y, l, r, mid, ans, i = ;i <= m;i ++) {
             scanf("%d %d", &X, &Y);
             if(_cross((point){a[].x - a[].y, y[] - y[]}, (point){X - a[].y, Y - y[]}) > ) c[] ++;
             else {
                 l = , r = n;
                 while(l <= r) {
                     mid = (l + r) >> ;
                     if(_cross((point){a[mid].x - a[mid].y, y[] - y[]}, (point){X - a[mid].y, Y - y[]}) < ) ans = mid, l = mid + ;
                     else r = mid - ;
                 }
                 c[ans] ++;
             }
         }
         for(int i = ;i <= n;i ++)
             printf("%d: %d\n", i, c[i]);
         puts("");
     }
 }

B.横边和竖边都与对角线等价，很容易猜到最终的最优路线有等价变形

我们把所有边都等价为斜边，就会得到一个矩形

矩形四条边的斜率绝对值都为1

纵截距可以比较得到

可以发现我们要求的所谓周长

其实等价于最左边点和最右边点的横坐标之差

(或者最上边点与最下面点的纵坐标之差，这俩是相等的)

两个点的横坐标可以用直线联立得到

需要向外拓宽，+4即可

于是就得到了一个很简单又很妙的解法

 n = input()
 a = b = c = d = -6666666
 for i in range(n):
     x, y = map(int, raw_input().split())
     a = max(a, x + y)
     b = max(b, x - y)
     c = max(c, y - x)
     d = max(d, - x - y)
 print a + b + c + d + 4

还有一个没有发现等价的凸包做法

凸包做法作重要的就是如何处理向外拓展

有一个思路就是每个点都拆成上下左右4个点

对这 4*n 个点做凸包再求周长

重点就是点的坐标到1e6，叉积的话，要开long long啊朋友！

 #include <cstdio>
 #include <algorithm>

 using std::max;

 const int maxn = ;

 typedef long long ll;

 struct point {
     ll x, y;
     bool operator < (const point &a) const {
         if(x != a.x) return x < a.x;
         return y < a.y;
     }
     point operator - (const point &a) const {
         return (point){x - a.x, y - a.y};
     }
 }p[maxn], q[maxn];

 int abs(int x, int y) {
     return x > y ? x - y : y - x;
 }

 int dis(const point &a, const point &b) {
     return max(abs(a.x - b.x), abs(a.y - b.y));
 }

 ll _cross(const point &a, const point &b) {
     return a.x * b.y - a.y * b.x;
 }

 int n0, n, N;

 long long ans;

 int convexhull() {
     int m = ;
     std::sort(p, p + n);
     for(int i = ;i < n;i ++) {
         while(m >  && _cross(q[m - ] - q[m - ], p[i] - q[m - ]) <= ) m --;
         q[m ++] = p[i];
     }
     for(int k = m, i = n - ;i >= ;i --) {
         while(m > k && _cross(q[m - ] - q[m - ], p[i] - q[m - ]) <= ) m --;
         q[m ++] = p[i];
     }
     return m - ;
 }

 int main() {
     scanf("%d", &n0);
     for(int x, y, i = ;i < n0;i ++) {
         scanf("%d %d", &x, &y);
         p[n ++] = (point){x + , y};
         p[n ++] = (point){x - , y};
         p[n ++] = (point){x, y + };
         p[n ++] = (point){x, y - };
     }
     N = convexhull(), q[N] = q[];
     for(int i = ;i <= N;i ++) ans += dis(q[i], q[i - ]);
     printf("%lld", ans);
     return ;
 }

C.非常没意思的签到题，水了发Java

发现大多OJ(cf除外)都会要求Java的public类名必须为Main

 import java.util.Scanner;

 public class Main {
     public static void main(String []args) {
         Scanner input = new Scanner(System.in);
         double c, a, i;
         String s;
         while(true) {
             c = input.nextDouble();
             if(c == 0.0) break;
             for(i = 1, a = 0;;i ++) {
                 a += 1 / (i + 1);
                 if(a >= c) {
                     s = String.format("%.0f", i);
                     System.out.println(s + " card(s)");
                     break;
                 }
             }
         }
     }
 }

D.反正就是枚举所有球算出能否接触

需要的时间最短的就是会碰到的那个

重点在于如何求出反射后的方向向量

求向量a关于向量b的对称向量a'的话

可以利用一个性质

假设c为a在b上的投影向量

那有a + a' = 2c

c = ab / b.length / b.length * b

原题OJ挂了评测结果未知，先把Java代码放上来

 import java.util.Scanner;

 public class D {
     static double sqr(double x) {
         return x * x;
     }
     static class point {
         double x, y, z;
         point() {
             x = y = z = 0;
         }
         point(double x_, double y_, double z_) {
             x = x_;
             y = y_;
             z = z_;
         }
         point(point a) {
             x = a.x;
             y = a.y;
             z = a.z;
         }
     };
     static class circle extends point{
         double r;
         circle() {
             x = y = r = z = 0;
         }
     };
     static double length(point a) {
         return Math.sqrt(sqr(a.x) + sqr(a.y) + sqr(a.z));
     }
     public static void main(String []args) {
         Scanner input = new Scanner(System.in);
         int t, n = input.nextInt();
         point s = new point();
         point d = new point();
         point tmp = new point(), nex = new point();
         circle[] a = new circle[100];
         for(int i = 1;i <= n;i ++) {
             a[i] = new circle();
             a[i].x = input.nextDouble();
             a[i].y = input.nextDouble();
             a[i].z = input.nextDouble();
             a[i].r = input.nextDouble();
         }
         s.x = input.nextDouble();
         s.y = input.nextDouble();
         s.z = input.nextDouble();
         d.x = input.nextDouble();
         d.y = input.nextDouble();
         d.z = input.nextDouble();
         double A = sqr(d.x) + sqr(d.y) + sqr(d.z), B, C, test;
         double x, x1, x2, dis;
         int last = -1;
         for(int k = 1;;k ++) {
             if(k > 10) {
                 System.out.println("etc.");
                 break;
             }
             t = -1;
             dis = 0.0;
             for(int i = 1;i <= n;i ++) {
                 if(i == last) continue;
                 B = (d.x * (s.x - a[i].x) + d.y * (s.y - a[i].y) + d.z * (s.z - a[i].z)) * 2;
                 C = sqr(s.x - a[i].x) + sqr(s.y - a[i].y) + sqr(s.z - a[i].z) - sqr(a[i].r);
                 test = sqr(B) - A * C * 4;
                 if(test < 0) continue;
                 else {
                     x1 = (Math.sqrt(test) - B) / (A * 2);
                     x2 = (-Math.sqrt(test) - B) / (A * 2);
                     if(x1 < 0 && x2 < 0) continue;
                     else {
                         if(x2 >= 0) x = x2;
                         else x = x1;
                         if(x < dis || t == -1) {
                             t = i;
                             dis = x;
                             tmp = new point(s.x + d.x * x, s.y + d.y * x, s.z + d.z * x);
                             point tmp1 = new point(tmp.x - d.x - a[i].x, tmp.y - d.y - a[i].y, tmp.z - d.z - a[i].z);
                             point tmp2 = new point(tmp.x - a[i].x, tmp.y - a[i].y, tmp.z - a[i].z);
                             double tmp3 = (tmp1.x * tmp2.x + tmp1.y * tmp2.y + tmp1.z * tmp2.z) / length(tmp2) / length(tmp2);
                             nex = new point(tmp3 * tmp2.x * 2 - tmp1.x - tmp2.x, tmp3 * tmp2.y * 2 - tmp1.y - tmp2.y, tmp3 * tmp2.z * 2 - tmp1.z - tmp2.z);
                         }
                     }
                 }
             }
             if(t == -1) break;
             System.out.printf("%d ", t);
             last = t;
             s = new point(tmp);
             d = new point(nex);
         }
     }
 }

E.这个题...数学方法无从下手

我们可以考虑二分...考虑二分的重点在于

先观察是否满足单调性再看能不能写出judge函数

因为单调性决定了能我们是否应该坚持考虑如何写judge

先确定其中一个圆的半径

再根据与两边和第一个圆相切求另外两圆半径

再判断两圆相切相离相交

单调性是显而易见的，第一个圆半径太大，另外两圆相离

太小则相交

精度正常比要求小数位高2-4位就差不多

二分左边界为0，右边界我开的是内切圆半径

(推得式子太长了，所以写的也又臭又长)

 import java.util.Scanner;

 public class E {
     static class point {
         double x, y;
         point() {
             x = y = 0;
         }
         point(double x_, double y_) {
             x = x_;
             y = y_;
         }
     };
     static final double pi = Math.acos(-1.0);
     static final double eps = 1e-10;
     static point[] p = new point[3];
     static point dec(point a, point b) {
         return new point(a.x - b.x, a.y - b.y);
     }
     static point inc(point a, point b) {
         return new point(a.x + b.x, a.y + b.y);
     }
     static double dot(point a, point b) {
         return a.x * b.x + a.y * b.y;
     }
     static double sqr(double x) {
         return  x * x;
     }
     static double length(point a) {
         return Math.sqrt(dot(a, a));
     }
     static point unitp(point a) {
         double len = length(a);
         return new point(a.x / len, a.y / len);
     }
     static double cross(point a, point b) {
         return a.x * b.y - a.y * b.x;
     }
     static double calc(double A, double B, double C) {
         double test = sqr(B) - A * C * 4;
         if(test < 0) return -1;
         test = Math.sqrt(test);
         double x1 = (- B + test) / (A * 2);
         double x2 = (- B - test) / (A * 2);
         if(x1 > 0) return x1;
         if(x2 > 0) return x2;
         return -1;
     }
     static void Solve(double l, double r) {
         double t1, t2, t3, r1, r2, r3, A, B, C, D, flag;
         point c1, c2, c3, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
         r1 = r2 = r3 = 0;
         c1 = new point();
         for(int tt = 1;tt <= 66;tt ++) {
             r1 = (l + r) / 2;
             flag = 0;
             tmp1 = unitp(dec(p[1], p[0]));
             tmp2 = unitp(dec(p[2], p[0]));
             tmp3 = inc(tmp1, tmp2);
             t3 = Math.acos(dot(tmp1, tmp2) / length(tmp1) / length(tmp2));
             t1 = r1 / (Math.sin(t3 / 2));
             t2 = length(tmp3);
             c1 = inc(p[0], new point(t1 / t2 * tmp3.x, t1 / t2 * tmp3.y));

             tmp1 = unitp(dec(p[0], p[1]));
             tmp2 = unitp(dec(p[2], p[1]));
             tmp3 = inc(tmp1, tmp2);
             tmp4 = dec(c1, p[1]);
             t3 = Math.acos(dot(tmp1, tmp2) / length(tmp1) / length(tmp2));
             t1 = Math.sin(t3 / 2);
             t2 = length(tmp3);
             A = sqr(t1 * t2) - sqr(t2);
             B = (t1 * t2 * r1 + dot(tmp3, tmp4)) * 2;
             C = sqr(r1) - dot(tmp4, tmp4);
             D = calc(A, B, C);
             if(D == -1) flag = 1;
             c2 = inc(p[1], new point(D * tmp3.x, D * tmp3.y));
             r2 = t1 * length(new point(D * tmp3.x, D * tmp3.y));

             tmp1 = unitp(dec(p[0], p[2]));
             tmp2 = unitp(dec(p[1], p[2]));
             tmp3 = inc(tmp1, tmp2);
             tmp4 = dec(c1, p[2]);
             t3 = Math.acos(dot(tmp1, tmp2) / length(tmp1) / length(tmp2));
             t1 = Math.sin(t3 / 2);
             t2 = length(tmp3);
             A = sqr(t1 * t2) - sqr(t2);
             B = (t1 * t2 * r1 + dot(tmp3, tmp4)) * 2;
             C = sqr(r1) - dot(tmp4, tmp4);
             D = calc(A, B, C);
             if(D == -1) flag = 1;
             c3 = inc(p[2], new point(D * tmp3.x, D * tmp3.y));
             r3 = t1 * length(new point(D * tmp3.x, D * tmp3.y));
             if(flag == 1 || sqr(c2.x - c3.x) + sqr(c2.y - c3.y) > sqr(r2 + r3)) r = r1 - eps;
             else l = r1 + eps;
         }
         System.out.printf("%.6f %.6f %.6f\n", r1, r2, r3);
     }
     public static void main(String []args) {
         Scanner input = new Scanner(System.in);
         for(int i = 0;i < 3;i ++) p[i] = new point();
         while(true) {
             for(int i = 0;i < 3;i ++) {
                 p[i].x = input.nextDouble();
                 p[i].y = input.nextDouble();
             }
             if(length(p[0]) == 0 && length(p[1]) == 0 && length(p[2]) == 0) break;
             Solve(0, Math.abs(cross(dec(p[1], p[0]), dec(p[2], p[0]))) / (length(dec(p[1], p[0])) + length(dec(p[2], p[0])) + length(dec(p[1], p[2]))));
         }
     }
 }

维基上有公式，戳这里

l里面是关于这个问题的历史...仍然没有给出推导或者证明...

所以代码去看别人的题解就好了，反正也记不住公式hhh

F.一个很裸的矩形周长并，现场只带了矩形面积并的板子

魔改了好久才改对成周长并的板子...所以重写了一发

重点是数据范围居然支持暴力啊淦！暴力艹正解啦，夭寿啦！

(理解的一个关键在与线段树的叶子节点也都是一个线段！)

 #include <cstdio>
 #include <algorithm>

 #define rep(i, j, k) for(int i = j;i <= k;i ++)

 using namespace std;

 const int maxn = ;

 int n, k1, k2, tot1, tot2;

 int ans, a1[maxn], a2[maxn], sum[maxn], cnt[maxn];

 struct node {
     int x, y, c, d;
     bool operator < (const node &a) const {
         return c < a.c;
     }
 }line1[maxn], line2[maxn];

 void modify1(int o, int l, int r, int s, int t, int k, int p) {
     if(s <= l && r <= t) {
         cnt[o] += k;
         if(cnt[o]) ans += p * (a1[r + ] - a1[l] - sum[o]), sum[o] = a1[r + ] - a1[l];
         else if(l == r) ans += p * (a1[r + ] - a1[l]), sum[o] = ;
         else ans += p * (sum[o] - (sum[o << ] + sum[o <<  | ])), sum[o] = sum[o << ] + sum[o <<  | ];
      }
      else {
          int mid = (l + r) >> ;
          if(cnt[o]) p = ;
          if(s <= mid) modify1(o << , l, mid, s, t, k, p);
          if(t > mid) modify1(o <<  | , mid + , r, s, t, k, p);
          if(!cnt[o]) sum[o] = sum[o << ] + sum[o <<  | ];
      }
 }

 void modify2(int o, int l, int r, int s, int t, int k, int p) {
     if(s <= l && r <= t) {
         cnt[o] += k;
         if(cnt[o]) ans += p * (a2[r + ] - a2[l] - sum[o]), sum[o] = a2[r + ] - a2[l];
         else if(l == r) ans += p * (a2[r + ] - a2[l]), sum[o] = ;
         else ans += p * (sum[o] - (sum[o << ] + sum[o <<  | ])), sum[o] = sum[o << ] + sum[o <<  | ];
      }
      else {
          int mid = (l + r) >> ;
          if(cnt[o]) p = ;
          if(s <= mid) modify2(o << , l, mid, s, t, k, p);
          if(t > mid) modify2(o <<  | , mid + , r, s, t, k, p);
          if(!cnt[o]) sum[o] = sum[o << ] + sum[o <<  | ];
      }
 }

 int main() {
     k1 = k2 = ;
     int l, r, x[], y[];
     scanf("%d", &n);
     rep(i, , n) {
         rep(j, , ) scanf("%d %d", &x[j], &y[j]);
         line1[++ tot1] = (node){x[], x[], y[], }, a1[tot1] = x[];
         line1[++ tot1] = (node){x[], x[], y[],-}, a1[tot1] = x[];
         line2[++ tot2] = (node){y[], y[], x[], }, a2[tot2] = y[];
         line2[++ tot2] = (node){y[], y[], x[],-}, a2[tot2] = y[];
     }
     sort(line1 + , line1 + tot1 + ), sort(a1 + , a1 + tot1 + );
     sort(line2 + , line2 + tot2 + ), sort(a2 + , a2 + tot2 + );
     rep(i, , tot1) {
         if(a1[i] != a1[k1])
             a1[++ k1] = a1[i];
         if(a2[i] != a2[k2])
             a2[++ k2] = a2[i];
     }
     rep(i, , tot1) {
         l = lower_bound(a1 + , a1 + k1 + , line1[i].x) - a1;
         r = lower_bound(a1 + , a1 + k1 + , line1[i].y) - a1 - ;
         modify1(, , k1 - , l, r, line1[i].d, );
     }
     rep(i, , tot2) {
         l = lower_bound(a2 + , a2 + k2 + , line2[i].x) - a2;
         r = lower_bound(a2 + , a2 + k2 + , line2[i].y) - a2 - ;
         modify2(, , k2 - , l, r, line2[i].d, );
     }
     printf("%d", ans);
     return ;
 }

G.有多种图形，一个比较蠢的思路就是给每个图形造一个类...

但是思考一下，判断不同的图形相交，其实还是在判断边相交

所以都转换成判断线段相交就好了...

(附:如果使用scanf的格式化读入的话，一定要和读入的格式完全相同

因为用格式化读入的话，就不会忽略空格了...

 #include <cstdio>
 #include <vector>
 #include <iostream>
 #include <algorithm>

 using namespace std;

 #define pr pair<double, double>
 #define f(p) p.first
 #define s(p) p.second
 #define mp make_pair
 #define pb push_back

 struct node {
     string m;
     vector<pr> a;
     bool operator < (const node &a) const {
         return m < a.m;
     }
 };

 int n;

 char s[];

 node tmp;

 pr temp[];

 vector<node> h;

 vector<string> ans[];

 double cross(pr p1, pr p2) {
     return f(p1) * s(p2) - f(p2) * s(p1);
 }

 bool line_cross(pr p1, pr p2, pr p3, pr p4) {
     double t1 = cross(mp(f(p2) - f(p1), s(p2) - s(p1)), mp(f(p3) - f(p1), s(p3) - s(p1)));
     double t2 = cross(mp(f(p2) - f(p1), s(p2) - s(p1)), mp(f(p4) - f(p1), s(p4) - s(p1)));
     double t3 = cross(mp(f(p4) - f(p3), s(p4) - s(p3)), mp(f(p1) - f(p3), s(p1) - s(p3)));
     double t4 = cross(mp(f(p4) - f(p3), s(p4) - s(p3)), mp(f(p2) - f(p3), s(p2) - s(p3)));
     if(!(1ll * t1 * t2 <  || ((t1 ==  || t2 == ) && (t1 + t2 != )))) return ;
     if(!(1ll * t3 * t4 <  || ((t3 ==  || t4 == ) && (t3 + t4 != )))) return ;
     return ;
 }

 int main() {
     while(scanf("%s", s)) {
         if(s[] == '.') return ;
         if(s[] == '-') {
             sort(h.begin(), h.end());
             for(int i = ;i < h.size();i ++) {
                 ans[i].clear();
                 for(int j = ;j < h.size();j ++) {
                     if(i == j) continue;
                     int x = ;
                     for(int p = ;p <  h[i].a.size();p ++) {
                         for(int q = ;q < h[j].a.size();q ++) {
                             if(line_cross(h[i].a[p - ], h[i].a[p], h[j].a[q - ], h[j].a[q])) x = ;
                             if(x) break;
                         }
                         if(x) break;
                     }
                     if(x) ans[i].pb(h[j].m);
                 }
                 switch(ans[i].size()) {
                     case :cout << h[i].m << " has no intersections" <<endl;
                         break;
                     case :cout << h[i].m << " intersects with " << ans[i][] << endl;
                         break;
                     case :cout << h[i].m << " intersects with " << ans[i][] <<  " and " << ans[i][] <<endl;
                         break;
                     default:{
                         cout << h[i].m << " intersects with ";
                         for(int j = ;j +  < ans[i].size();j ++)
                             cout << ans[i][j] << ", ";
                         cout << "and " << ans[i][ans[i].size() - ] << endl;
                         break;
                     }
                 }
             }
             h.clear();
             puts("");
         }
         else {
             tmp.a.clear();
             tmp.m = s;
             scanf("%s", s);
             switch(s[]) {
                 case 'l':{
                     scanf(" (%lf,%lf)", &f(temp[]), &s(temp[]));
                     scanf(" (%lf,%lf)", &f(temp[]), &s(temp[]));
                     tmp.a.pb(temp[]);
                     tmp.a.pb(temp[]);
                     break;
                 }
                 case 't':{
                     scanf(" (%lf,%lf)", &f(temp[]), &s(temp[]));
                     scanf(" (%lf,%lf)", &f(temp[]), &s(temp[]));
                     scanf(" (%lf,%lf)", &f(temp[]), &s(temp[]));
                     tmp.a.pb(temp[]);
                     tmp.a.pb(temp[]);
                     tmp.a.pb(temp[]);
                     break;
                 }
                 case 'p' :{
                     cin >> n;
                     for(int i = ;i < n;i ++) {
                         scanf(" (%lf,%lf)", &f(temp[i]), &s(temp[i]));
                         tmp.a.pb(temp[i]);
                     }
                     break;
                 }
                 case 'r':{
                     scanf(" (%lf,%lf)", &f(temp[]), &s(temp[]));
                     scanf(" (%lf,%lf)", &f(temp[]), &s(temp[]));
                     scanf(" (%lf,%lf)", &f(temp[]), &s(temp[]));
                     tmp.a.pb(temp[]);
                     tmp.a.pb(temp[]);
                     tmp.a.pb(temp[]);
                     temp[] = mp(f(temp[]) + f(temp[]) - f(temp[]), s(temp[]) + s(temp[]) - s(temp[]));
                     tmp.a.pb(temp[]);
                     break;
                 }
                 case 's':{
                     scanf(" (%lf,%lf)", &f(temp[]), &s(temp[]));
                     scanf(" (%lf,%lf)", &f(temp[]), &s(temp[]));
                     f(temp[]) = (f(temp[]) + f(temp[])) / ;
                     s(temp[]) = (s(temp[]) + s(temp[])) / ;
                     tmp.a.pb(temp[]);
                     tmp.a.pb(mp(f(temp[]) - s(temp[]) + s(temp[]), s(temp[]) + f(temp[]) - f(temp[])));
                     tmp.a.pb(temp[]);
                     tmp.a.pb(mp(f(temp[]) + s(temp[]) - s(temp[]), s(temp[]) - f(temp[]) + f(temp[])));
                     break;
                 }
             }
             tmp.a.pb(tmp.a[]);
             h.pb(tmp);
         }
     }
 }

H.

占坑