P2521 [HAOI2011]防线修建

题目链接：P2521 [HAOI2011]防线修建

题意：给定点集

每次有两种操作：

1. 删除一个点 （除开(0, 0), (n, 0), 与指定首都(x, y)）

2. 询问上凸包长度

至于为什么是上凸包 “三角形任意两边之和大于第三边”就可以证

我们的套路不包括只做删除的在线凸包问题 所以把询问逆序操作

根据套路 只有插入操作的 对答案贡献不独立的凸包问题 我们使用平衡树维护 

其实只用求前驱后继 所以蒟蒻就偷懒用了STL的set

一开始构造最后删完的点集的凸包

每次插入一个点时 

如果它在当前凸包内部或凸包上 那么不影响答案 直接忽略

如果在外部 从近到远询问它前面的点 类似于Andrew一开始插入点的做法

再从近到远询问它后面的点 做法同样

记得维护答案

#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <set>
using namespace std;
const int N = 1e5 + 5;
const int Q = 2e5 + 5;
const double eps = 1e-8;
struct Node{
    int id;
    double x, y;
}node[N], stk[N], nl;
set<Node> st;
int rf[N];
struct Query{
    int x, y;
}q[Q];
double anss[N];
int as;
int n, m, cx, cy, qs;
int top;
double ans;
bool ask[N];

Node operator - (const Node& x, const Node& y){
    return (Node){0, x.x - y.x, x.y - y.y}; 
}

bool operator < (const Node& x, const Node& y){
    if(fabs(x.x - y.x) < eps) return x.y + eps < y.y;
    return x.x + eps < y.x;
}

inline double cross(Node x, Node y){
    return x.x * y.y - x.y * y.x;
}

inline double dis(Node x, Node y){
    return sqrt((y.x - x.x) * (y.x - x.x) 
     + (y.y - x.y) * (y.y - x.y));
}

Node next(Node x){
    set<Node> :: iterator it;
    it = st.upper_bound(x);
    if(it != st.end()) return *it;
    else return nl;
}

Node prev(Node x){
    set<Node> :: iterator it;
    it = st.lower_bound(x);
    if(it != st.begin()) return *(--it);
    else return nl;
}

inline void Andrew(){
    top = 0;
    for(int i = 1; i <= m; i++) if(!ask[node[i].id]){
        while(top > 1 && cross(stk[top] - stk[top - 1], node[i] - stk[top]) > eps){
            ans -= dis(stk[top], stk[top - 1]); 
            top--;
        }
        stk[++top] = node[i];
        if(top > 1) ans += dis(stk[top], stk[top - 1]);
    }    
    for(int i = 1; i <= top; i++)
        st.insert(stk[i]);
} 

inline void init(){
    scanf("%d%d%d%d", &n, &cx, &cy, &m);
    for(int i = 1; i <= m; i++){
        scanf("%lf%lf", &node[i].x, &node[i].y);
        node[i].id = i;
    }
    ++m; node[m] = (Node){m, 0, 0};
    ++m; node[m] = (Node){m, 1.0 * n, 0};
    ++m; node[m] = (Node){m, 1.0 * cx, 1.0 * cy};
    sort(node + 1, node + m + 1);
    for(int i = 1; i <= m; i++){
        rf[node[i].id] = i;
    }
    scanf("%d", &qs);
    for(int i = 1; i <= qs; i++){
        scanf("%d", &q[i].x);
        if(q[i].x == 1){
            scanf("%d", &q[i].y);
            ask[q[i].y] = 1;
        }
        else {
            as++;
            q[i].y = as;    
        }
    }
    Andrew();
}

inline void ins(Node x){
    Node pre = prev(x), pp;
    Node nxt = next(x), nn;
    if(cross(x - pre, nxt - x) > eps){
        return ;
    }
    ans -= dis(pre, nxt);
    while(pre.id != m - 2){
        pp = prev(pre);
        if(cross(pre - pp, x - pre) > eps){
            ans -= dis(pp, pre);
            st.erase(pre);
            pre = pp;
        }
        else break;
    }
    ans += dis(pre, x);
    while(nxt.id != m - 1){
        nn = next(nxt);
        if(cross(nxt - x, nn - nxt) > eps){
            ans -= dis(nxt, nn);
            st.erase(nxt);
            nxt = nn;
        }
        else break;
    }
    ans += dis(x, nxt);
    st.insert(x);
}

int main(){
    init();
    for(int i = qs; i >= 1; i--)
        if(q[i].x == 1)
            ins(node[rf[q[i].y]]);
        else 
            anss[q[i].y] = ans;
    for(int i = 1; i <= as; i++) printf("%.2lf
", anss[i]);
    return 0;    
}

附上代码：