分治分块与计算几何练习 [Cloned]

https://cn.vjudge.net/contest/148706

A

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
int read(){
    int x=,f=;char ch=getchar();
    while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
    while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
    return x*f;
}
const int N=2e5+;
struct node{
    int l,r,t,pos;
    bool operator < (const node &a)const{
        return pos==a.pos?r<a.r:pos<a.pos;
    }
}b[N];
int n,m,l,r,a[N],f[N];
ll res,ans1[N],ans2[N];
ll gcd(ll a,ll b){
    if(!b) return a;
    return gcd(b,a%b);
}
int main(){
    n=read();m=read();
    for(int i=;i<=n;i++) a[i]=read();
    int k=sqrt(n*1.0)+0.5;
    for(int i=;i<=m;i++){
        b[i].l=read();b[i].r=read();
        b[i].t=i;b[i].pos=b[i].l/k;
    }
    sort(b+,b+m+);
    memset(f,,sizeof f);
    l=;r=;res=;
    for(int i=;i<=m;i++){
        while(r>b[i].r){
            res-=(ll)f[a[r]]-;
            f[a[r]]--;
            r--;
        }
        while(r<b[i].r){
            r++;
            f[a[r]]++;
            res+=(ll)f[a[r]]-;
        }
        while(l>b[i].l){
            l--;
            f[a[l]]++;
            res+=(ll)f[a[l]]-;
        }
        while(l<b[i].l){
            res-=(ll)f[a[l]]-;
            f[a[l]]--;
            l++;
        }
        ans1[b[i].t]=res;
        ans2[b[i].t]=(ll)(r-l+)*(r-l)/;
    }
    for(int i=;i<=m;i++){
        if(!ans1[i]){
            puts("0/1");
            continue;
        }
        ll gg=gcd(ans1[i],ans2[i]);
        printf("%lld/%lld\n",ans1[i]/gg,ans2[i]/gg);
        //printf("%I64d/%I64d\n",ans1[i]/gg,ans2[i]/gg);
    }
    return ;
}

B

//扫描线考精度，没什么技术含量
#include<cstdio>
#include<cmath>
#include<algorithm>
#define eps 1e-8
using namespace std;
int n,tot,cnt;
double last,ans,pos[];
struct P{double x,y;}p[][];
struct L{P a,b;}l[][];
struct seg{double l,r;}f[];
inline P operator -(P a,P b){return (P){a.x-b.x,a.y-b.y};}
inline double operator *(P a,P b){return a.x*b.y-a.y*b.x;}//叉积
inline double operator /(P a,P b){return a.x*b.x+a.y*b.y;}//点积
inline P inter(L l1,L l2){
    double k1=(l2.b-l1.a)*(l1.b-l1.a),k2=(l1.b-l1.a)*(l2.a-l1.a),t=k1/(k1+k2);
    return (P){l2.b.x+(l2.a.x-l2.b.x)*t,l2.b.y+(l2.a.y-l2.b.y)*t};
}
inline bool judge(L l1,L l2){
    return fabs((l1.b.y-l1.a.y)*(l2.b.x-l2.a.x)-(l1.b.x-l1.a.x)*(l2.b.y-l2.a.y))>eps;
}
inline bool cmp(seg a,seg b){
    return fabs(a.l-b.l)<=eps?a.r<b.r:a.l<b.l;
}
inline double dcmp(double x){
    if(fabs(x)<=eps) return ;
    else return x<?-:;
}
inline bool cross(P a1,P a2,P b1,P b2){
    double c1=(a2-a1)*(b1-a1),c2=(a2-a1)*(b2-a1),c3=(b2-b1)*(a1-b1),c4=(b2-b1)*(a2-b1);
    return dcmp(c1)*dcmp(c2)<&&dcmp(c3)*dcmp(c4)<;
}
inline double calc(double x){
    L ln=(L){(P){x,},(P){x,}};
    int num;cnt=;
    double y[],h,ret=;
    for(int i=;i<=n;i++){
        double mn=min(p[i][].x,min(p[i][].x,p[i][].x)),mx=max(p[i][].x,max(p[i][].x,p[i][].x));
        if(x<mn+eps||x>mx-eps) continue;
        num=;
        for(int j=;j<=;j++){
            if(judge(l[i][j],ln)){
                P tmp=inter(l[i][j],ln);
                if((l[i][j].a-tmp)/(l[i][j].b-tmp)>-eps) continue;
                y[++num]=tmp.y;
            }
        }
        if(num>) f[++cnt]=(seg){y[],y[]};
    }
    for(int i=;i<=cnt;i++){
        if(f[i].l>f[i].r){
            swap(f[i].l,f[i].r);
        }
    }
    sort(f+,f+cnt+,cmp);
    for(int i=;i<=cnt;i++){
        if(i==||f[i].l>h+eps) ret+=f[i].r-f[i].l,h=f[i].r;
        else if(f[i].r>h+eps) ret+=f[i].r-h,h=f[i].r;
    }
    return ret;
}
int main(){
    scanf("%d",&n);
    for(int i=;i<=n;i++){
        for(int j=;j<=;j++){
            scanf("%lf%lf",&p[i][j].x,&p[i][j].y),pos[++tot]=p[i][j].x;
        }
    }
    for(int i=;i<=n;i++){
        l[i][]=(L){p[i][],p[i][]},
            l[i][]=(L){p[i][],p[i][]},
            l[i][]=(L){p[i][],p[i][]};
    }
    for(int i=;i<n;i++){
        for(int j=i+;j<=n;j++){
            for(int k1=;k1<=;k1++){
                for(int k2=;k2<=;k2++){
                    if(cross(l[i][k1].a,l[i][k1].b,l[j][k2].a,l[j][k2].b)){
                        pos[++tot]=inter(l[i][k1],l[j][k2]).x;
                    }
                }
            }
        }
    }
    sort(pos+,pos+tot+);
    last=pos[];
    for(int i=;i<=tot;i++){
        if(fabs(pos[i]-last)>eps){
            ans+=calc((pos[i]+last)/)*(pos[i]-last);
            last=pos[i];
        }
    }
    ans-=eps;//eps!
    printf("%.2lf\n",ans);
    return ;
}

C

//题意：n场考试中分别答对a_i题，总题数分别为b_i，允许去掉k场考试，求能达到的最高准确率。
//二分比0/1分数规划慢，然而后者并不会
#include<cstdio>
#include<algorithm>
#define eps 1e-7
using namespace std;
const int N=;
int n,k;
double sum,a[N],b[N],t[N];
int main(){
    while(scanf("%d%d",&n,&k)==){
        if(!n) break;
        for(int i=;i<n;i++) scanf("%lf",&a[i]);
        for(int i=;i<n;i++) scanf("%lf",&b[i]);
        double l=0.0,r=1.0,mid;
        while(r-l>eps){
            mid=(l+r)/2.0;
            for(int i=;i<n;i++) t[i]=a[i]-mid*b[i];
            sort(t,t+n);sum=;
            for(int i=k;i<n;i++) sum+=t[i];
            if(sum>) l=mid;
            else r=mid;
        }
        printf("%.0f\n",mid*);//g++，坑
    }
    return ;
}

D

//simpson自适应公式
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<iostream>
using namespace std;
#define sqr(x) ((x)*(x))
typedef double DB;
const int maxn=;const DB zero=1e-;
int n;DB alp,h,x[maxn],R[maxn],fx1[maxn],fx2[maxn],fy1[maxn],fy2[maxn];
DB f(DB X){
    DB s=;
    for(int i=;i<=n;++i){
        if(fabs(x[i]-X)<R[i]) s=max(s,sqrt(sqr(R[i])-sqr(x[i]-X)));
        if(x[i+]-x[i]>fabs(R[i+]-R[i]) && fx1[i]<X && X<fx2[i])
            s=max(s,(fy2[i]-fy1[i])/(fx2[i]-fx1[i])*(X-fx1[i])+fy1[i]);
    }
    return s;
}
DB simpson(DB a,DB b,DB fa,DB fb,DB fm){return (b-a)/*(fa+*fm+fb);}//不知道怎么积出来的辛普森
DB area(DB l,DB fl,DB m,DB fm,DB r,DB fr,DB pre){
    DB ls=(l+m)/,rs=(m+r)/,fls=f(ls),frs=f(rs);
    DB la=simpson(l,m,fl,fm,fls),ra=simpson(m,r,fm,fr,frs);
    return fabs(la+ra-pre)<zero? pre:area(l,fl,ls,fls,m,fm,la)+area(m,fm,rs,frs,r,fr,ra);
}
int main(){
    scanf("%d%lf",&n,&alp);alp=/tan(alp);
    for(int i=;i<n+;++i) scanf("%lf",&x[i]),h+=x[i],x[i]=h*alp;
    DB l=x[n+],r=l;
    for(int i=;i<n+;++i)
        scanf("%lf",&R[i]),l=l<x[i]-R[i]? l:x[i]-R[i],r=r>x[i]+R[i]? r:x[i]+R[i];
    for(int i=;i<n+;++i)
        fx1[i]=x[i]+R[i]*(R[i]-R[i+])/(x[i+]-x[i]),fy1[i]=sqrt(sqr(R[i])-sqr(fx1[i]-x[i])),
        fx2[i]=x[i+]+R[i+]*(R[i]-R[i+])/(x[i+]-x[i]),fy2[i]=sqrt(sqr(R[i+])-sqr(fx2[i]-x[i+]));
    DB m=(l+r)/,fm=f(m),fl=f(l),fr=f(r);
    printf("%.2lf",*area(l,fl,m,fm,r,fr,simpson(l,r,fl,fr,fm)));
    return ;
}

E

//求图的绝对中心(这个点到所有点的最短距离的最大值最小)
//reference：http://blog.csdn.net/crazy_ac/article/details/8816877
#include<cstdio>
#include<iostream>
using namespace std;
const int N=;
const int inf=0x3f3f3f3f;
int n,m,d[N][N],di[N][N],rk[N][N];
int main(){
    scanf("%d%d",&n,&m);
    for(int i=;i<=n;i++){
        d[i][i]=di[i][i]=;
        for(int j=i+;j<=n;j++){
            d[i][j]=d[j][i]=inf;
            di[i][j]=di[j][i]=inf;
        }
    }
    for(int i=,x,y,z;i<=m;i++){
        scanf("%d%d%d",&x,&y,&z);
        d[x][y]=d[y][x]=z;
        di[x][y]=di[y][x]=z;
    }
    for(int k=;k<=n;k++){
        for(int i=;i<=n;i++){
            for(int j=;j<=n;j++){
                d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
            }
        }
    }
    for(int i=;i<=n;i++){
        for(int j=;j<=n;j++) rk[i][j]=j;
        for(int j=;j<=n;j++){
            for(int k=j+;k<=n;k++){
                if(d[i][rk[i][j]]>d[i][rk[i][k]]){
                    swap(rk[i][j],rk[i][k]);
                }
            }
        }
    }
    int ans=inf;
    for(int i=;i<=n;i++){
        for(int j=;j<=n;j++){
            if(i==j) continue;
            ans=min(ans,d[i][rk[i][n]]<<);
            ans=min(ans,d[j][rk[j][n]]<<);
            for(int cmp=n,t=n-;t>=;t--){
                if(d[j][rk[i][t]]>d[j][rk[i][cmp]]){
                    ans=min(ans,d[i][rk[i][t]]+d[j][rk[i][cmp]]+di[i][j]);
                    cmp=t;
                }
            }
        }
    }
    printf("%.2lf\n",(double)ans/);
    return ;
}