BZOJ4614/UVA1742 Oil 计算几何

传送门

题意：在平面直角坐标系中给出$N$条互不相交的、与$x$轴平行、且在$x$轴上方的线段，每一条线段的价值为其长度。求一条不与$x$轴平行的直线，使得与这条直线相交的线段的价值之和最大，求出这个和。$N \leq 2000 , -10^6 \leq \text{线段两端点横坐标} \leq 10^6 , 1 \leq \text{线段两端点纵坐标} \leq 10^6$

---

首先我们可以想到：必定存在一条最优的直线，它经过某一条线段的左端点和某条线段的右端点，因为如果某条最优的直线不满足这些性质，我们可以通过旋转和平移使其满足条件。基于上面的结论，我们可以很轻松地想到一种算法：枚举直线经过哪一条线段的左端点和哪一条线段的右端点，然后扫一遍所有的线段看其是否被该直线穿过。这样子的复杂度是$O(n^3)$的。

接着我们考虑优化。我们这样考虑：枚举直线经过其左端点的线段，那么某一条线段会产生贡献当且仅当直线的斜率在某一个区间之内。那么我们将所有线段的会产生贡献的区间算出来，问题就转化为了：给定若干区间，每个区间有权值，选择一个点使得包含这个点的区间的权值之和最大。这个问题可以利用尺取法：按照左端点从小到大加入区间，删除与新加入的区间不相交的区间，计算剩余的权值和。这种算法的复杂度就降为了$O(n^2logn)$

一个细节：为了避免区间不连续、斜率不存在的情况，我们可以计算每一个线段产生贡献时，直线斜率的倒数会落在哪一段区间$($我们认为直线的斜率不存在的时候，斜率的倒数为$0)$，这样每一个线段的贡献区间就是连续的，还可以在计算斜率时避免除$0$。

 //一份常数极大的Code
 #include<bits/stdc++.h>
 #define ld long double
 #define eps 1e-12
 using namespace std;

 inline int read(){
     ;
     ;
     char c = getchar();
     while(!isdigit(c)){
         if(c == '-')
             f = ;
         c = getchar();
     }
     while(isdigit(c)){
         a = (a << ) + (a << ) + (c ^ ');
         c = getchar();
     }
     return f ? -a : a;
 }

 struct range{
     ld l , r;
     int ind;
 }now[] , ano[];
 ][];

 inline long long max(long long a , long long b){
     return a > b ? a : b;
 }

 inline void swap(int &a , int &b){
     int t = a;
     a = b;
     b = t;
 }

 inline void swap(ld &a , ld &b){
     ld t = a;
     a = b;
     b = t;
 }

 bool cmp1(range l , range r){
     return l.l < r.l;
 }

 bool cmp2(range l , range r){
     return l.r < r.r;
 }

 inline ld calcK(int x1 , int y1 , int x2 , int y2){
     return (ld)(x1 - x2) / (y1 - y2);
 }

 int main(){
     int N;
     while(scanf("%d" , &N) != EOF){
          ; i <= N ; i++){
             num[i][] = read();
             num[i][] = read();
             num[i][] = read();
             ] < num[i][])
                 swap(num[i][] , num[i][]);
         }
         ;
          ; i <= N ; i++){
             ;
              ; j <= N ; j++)
                 ] != num[j][]){
                     now[++cnt].l = calcK(num[i][] , num[i][] , num[j][] , num[j][]);
                     now[cnt].r = calcK(num[i][] , num[i][] , num[j][] , num[j][]);
                     now[cnt].ind = j;
                     if(now[cnt].l > now[cnt].r)
                         swap(now[cnt].l , now[cnt].r);
                     now[cnt].l -= eps;
                     now[cnt].r += eps;
                     ano[cnt] = now[cnt];
                 }
             sort(now +  , now + cnt +  , cmp1);
             sort(ano +  , ano + cnt +  , cmp2);
             ;
             ] - num[i][];
             maxN = max(maxN , ans);
              ; j <= cnt ; j++){
                 ans += num[now[j].ind][] - num[now[j].ind][];
                 while(ano[p].r < now[j].l){
                     ans -= num[ano[p].ind][] - num[ano[p].ind][];
                     ++p;
                 }
                 maxN = max(maxN , ans);
             }
         }
         printf("%lld\n" , maxN);
     }
     ;
 }