洛谷 P4073 [WC2013]平面图

#include<bits/stdc++.h>
using namespace std;
const int maxn=3e5+;
typedef long double LD;
const LD eps=1e-;
const LD pi=acos(-);
int dcmp(LD x){return (x>eps)-(x<-eps);}
int n,m,q,h[maxn];
int Polsize;
struct point{
    LD x,y;
    point(LD _x=,LD _y=):x(_x),y(_y){}
    bool operator==(point o)const{return !dcmp(x-o.x)&&!dcmp(y-o.y);}
    bool operator!=(point o)const{return !(*this==o);}
    bool operator<(point o)const{return dcmp(x-o.x)?x>o.x:y<o.y;}
    LD operator*(point o){return x*o.y-y*o.x;}
    LD operator^(point o){return x*o.x+y*o.y;}
    point operator+(point o){return point(x+o.x,y+o.y);}
    point operator-(point o){return point(x-o.x,y-o.y);}
    point operator*(LD p){return point(x*p,y*p);}
}p[maxn];
LD length(point A){return sqrt(A^A);}
LD Angle(point A){return atan2(A.y,A.x)<?atan2(A.y,A.x)+*pi:atan2(A.y,A.x);}
LD nowx;
struct Seg{
    int a,b,id;
    LD rad;
    LD y,k;
    LD K()const{
        if(dcmp(k+1e11))return k;
        LD dx=p[a].x-p[b].x;
        LD dy=p[a].y-p[b].y;
        if(!dcmp(dx))return 1e10;
        return dy/dx;
    }
    Seg(int _a=,int _b=,int _id=){
        a=_a;b=_b;id=_id;
        rad=Angle(p[b]-p[a]);
        k=-1e11;
        if(id){
            k=K();y=-;
        }else y=-;
    }
    LD get(LD x)const{
        if(dcmp(y+))return y;
        if(!dcmp(p[b].x-p[a].x))return 1e10;
        return p[a].y+(LD)(p[b].y-p[a].y)/(LD)(p[b].x-p[a].x)*LD(x-p[a].x);
    }
    bool operator<(Seg o)const{
        return dcmp(get(nowx)-o.get(nowx))?dcmp(get(nowx)-o.get(nowx))==-:K()<o.K();
    }
}Se[maxn];
struct Pol{
    vector<int>vec;
    void push_back(int p){vec.push_back(p);}
    void Area(){
        area=;
        for(int i=;i+<vec.size();i++){
            area+=(p[vec[i]]-p[vec[]])*(p[vec[i+]]-p[vec[]]);
        }area/=;
    }LD area;
    Pol(){area=;}
};
struct qes{
    LD xa,ya,xb,yb;
    int id;
}Q[maxn];
int imp[maxn<<];
namespace DEB{

     void deb(point p){
        printf("%.1lf %.1lf ",(double)p.x,(double)p.y);
      }
    void deb(Seg s){
        deb(p[s.a]);deb(p[s.b]);
        printf("%.1lf %.1lf ",(double)s.get(nowx),(double)s.K());
        puts("");
    }
    void deb(vector<Seg>v){
        for(int i=;i<v.size();i++)
        deb(v[i]);puts("");
    }
    void deb(vector<int>v){
        for(int i=;i<v.size();i++)printf("%d ",v[i]);puts("");
    }
    void deb(set<Seg>s){
        for(set<Seg>::iterator it=s.begin();it!=s.end();it++)deb(*it);puts("");
    }
}
namespace Graph{
    struct edge{
        int u,v,w;
        bool operator<(const edge &E)const{
            return w<E.w;
        }
    };
    vector<edge>edges;
    vector<edge>G[maxn];
    void add(int u,int v,int w){
        if(!u||!v)return;
        edges.push_back((edge){u,v,w});
    }
    int n,m,q;
    int fa[maxn],dep[maxn];
    int p[maxn][],vis[maxn];
    int maxx[maxn][];
    int find(int x){
        if(fa[x]!=x)return fa[x]=find(fa[x]);return x;
    }
    void dfs(int u){
        vis[u]=;
        for(int i=;i<=;i++){
            if(dep[u]<(<<i))break;
            p[u][i]=p[p[u][i-]][i-];
            maxx[u][i]=max(maxx[u][i-],maxx[p[u][i-]][i-]);
        }for(int i=;i<G[u].size();i++){
            edge e=G[u][i];
            if(!vis[e.v]){
                p[e.v][]=u;
                maxx[e.v][]=e.w;
                dep[e.v]=dep[u]+;
                dfs(e.v);
            }
        }
    }
    int Qmax(int u,int v){
        if(u==-||v==-)return -;
        if(find(u)!=find(v))return -;
        if(u==v)return ;
        if(dep[u]<dep[v])swap(u,v);
        int d=dep[u]-dep[v];
        int ans=INT_MIN;
        for(int i=;i<=;i++){
            if((<<i)&d){
                ans=max(ans,maxx[u][i]);
                u=p[u][i];
            }
        }if(u==v)return ans;
        for(int i=;i>=;i--){
            if(p[u][i]!=p[v][i]){
                ans=max(ans,max(maxx[u][i],maxx[v][i]));
                u=p[u][i];v=p[v][i];
            }
        }ans=max(ans,max(maxx[u][],maxx[v][]));
        return ans;
    }
    void init(){
        for(int i=;i<=Polsize;i++)fa[i]=i;
        sort(edges.begin(),edges.end());
        for(int i=;i<edges.size();i++){
            if(find(edges[i].u)!=find(edges[i].v)){
                fa[find(edges[i].u)]=find(edges[i].v);
                G[edges[i].u].push_back(edges[i]);
                G[edges[i].v].push_back((edge){edges[i].v,edges[i].u,edges[i].w});
            }
        }
        for(int i=;i<=Polsize;i++)if(!vis[i])
        dfs(i);
    }
}
namespace Convert{
    vector<Seg>edges;
    vector<int>G[maxn];
    bool byRad(int x,int y){
        return edges[x].rad<edges[y].rad;
    }
    void add(int u,int v){
        edges.push_back(Seg(u,v,edges.size()));
        G[u].push_back(edges.size()-);
        edges.push_back(Seg(v,u,edges.size()));
        G[v].push_back(edges.size()-);
    }
    short vis[maxn*];
    vector<int>tmp;
    Pol Pl;
    int bel[maxn<<];
    void solve(){
        for(int i=;i<=n;i++)sort(G[i].begin(),G[i].end(),byRad);
        for(int i=;i<edges.size();i++){
            if(vis[i])continue;
            int u=i;
            int s=u;
            tmp.clear();
            Pl.push_back(edges[u].a);
            tmp.push_back(u);
            vis[u]=;
            do{
                LD old=edges[u^].rad;
                edges[u^].rad-=eps;
                vector<int>::iterator it=lower_bound(G[edges[u].b].begin(),G[edges[u].b].end(),u^,byRad);
                edges[u^].rad=old;
                if(*it==(u^)){
                    if(it==G[edges[u].b].begin())it=--G[edges[u].b].end();
                    else it--;
                }
                u=*it;
                Pl.push_back(edges[u].a);
                tmp.push_back(u);
                vis[u]=;
            }while(edges[u].b!=edges[s].a);
            Pl.Area();
            Pl.vec.clear();
            if(Pl.area<)continue;Polsize++;
            for(int j=;j<tmp.size();j++){
                bel[edges[tmp[j]].id]=Polsize;
                if(p[edges[tmp[j]].b].x<p[edges[tmp[j]].a].x)
                imp[edges[tmp[j]].id/+]=Polsize;
            }
        }for(int i=;i<edges.size();i+=)
        Graph::add(bel[i],bel[i^],h[edges[i].id/+]);
    }
}
namespace ScanLine{
    struct scanline{
        LD x;
        int op,id;
        bool operator<(scanline o)const{return dcmp(x-o.x)?x<o.x:op<o.op;}
    }scan[maxn<<];
    int size;
    set<Seg>S;
    int ansx[maxn],ansy[maxn];
    void solve(){
        for(int i=;i<=m;i++){
            if(!dcmp(p[Se[i].a].x-p[Se[i].b].x))continue;
            scan[++size]=(scanline){p[Se[i].a].x,,i};
            scan[++size]=(scanline){p[Se[i].b].x,,i};
        }for(int i=;i<=q;i++){
            scan[++size]=(scanline){Q[i].xa,,i};
            scan[++size]=(scanline){Q[i].xb,,i};
        }stable_sort(scan+,scan++size);
        for(int i=;i<=size;i++){
            nowx=scan[i].x;
            set<Seg>::iterator it;
            int op=scan[i].op,id=scan[i].id;
            if(op==)
            {

//          DEB::deb(S);puts("");
//          DEB::deb(Se[id]);
//          int _size=S.size();
                S.insert(Se[id]);
//          assert(_size+1==S.size());
//          DEB::deb(S);puts("");
            }else
            if(op==){
//                p[maxn-1]=point(nowx,Q[id].ya);
               Seg s;s.y=Q[id].ya;s.k=-1e10;
               it=S.lower_bound(s);
                if(it!=S.end());
                else {ansx[id]=-;continue;}
                s=*it;s.k=1e10;it=--S.upper_bound(s);
                ansx[id]=imp[it->id]?imp[it->id]:-;
            }else
            if(op==){
//                p[maxn-1]=point(nowx,Q[id].yb);
                Seg s;s.y=Q[id].yb;s.k=-1e10;
                it=S.lower_bound(s);
                if(it!=S.end());
                else {ansy[id]=-;continue;}
                s=*it;s.k=1e10;it=--S.upper_bound(s);
                ansy[id]=imp[it->id]?imp[it->id]:-;
            }else{
                S.erase(Se[id]);
            }
        }
    }
    int Qx(int i){return ansx[i];}
    int Qy(int i){return ansy[i];}
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=;i<=n;i++){
        double x,y;
        scanf("%lf%lf",&x,&y);
        p[i].x=x;p[i].y=y;
    }
    for(int i=;i<=m;i++){
        int u,v,w;scanf("%d%d%d",&u,&v,&w);
        if(p[v].x<p[u].x)swap(u,v);
        if(p[u].x==p[v].x&&p[u].y>p[v].y)swap(u,v);
        Se[i]=Seg(u,v);Se[i].id=i;
        Convert::add(u,v);h[i]=w;
    }Convert::solve();
    Graph::init();
    scanf("%d",&q);
    for(int i=;i<=q;i++){
        double xa,ya,xb,yb;
        scanf("%lf%lf%lf%lf",&xa,&ya,&xb,&yb);
        Q[i].xa=xa;Q[i].ya=ya;Q[i].xb=xb;Q[i].yb=yb;
    }
    ScanLine::solve();
    for(int i=;i<=q;i++){
        if(n==){
            if(i==){puts("");continue;}
            if(i==){puts("");continue;}
        }printf("%d\n",Graph::Qmax(ScanLine::Qx(i),ScanLine::Qy(i)));
    }
    return ;
}