[线段树] 「JOI Open Contest 2017」Bulldozer

最新推荐文章于 2022-04-03 13:13:37 发布

LowestJN

最新推荐文章于 2022-04-03 13:13:37 发布

阅读量686

点赞数

分类专栏：线段树

本文链接：https://blog.csdn.net/coldef/article/details/78704583

版权

线段树专栏收录该内容

50 篇文章 0 订阅

订阅专栏

老早以前的坑了

题意大概是，给定平面内 $n(\le 2000)$ 个点，每个点有个可正可负的点权，求两条平行的直线，使得所在在这两条直线之间的点权和最大

首先，如果我们知道这两条直线的斜率，假设这条线没有把这些点分成两个点集，那么可以把点按照距离直线的距离排序，记排序后的数列为A。

转动直线，那么会有一些点对交换在A中的位置，总共有 $O(n^2)$ 次交换，把这些交换按极角排序，依次处理就好。

然后点权的最大值就是经典的最大字段和，因为在线，所以可以用线段树维护

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <assert.h>

using namespace std;

typedef long long ll;

const int N=5010;

int n,cnt,b[N],c[N];
ll ans;
struct node{
  ll x,y,g,w;
  node(ll _x=0,ll _y=0){x=_x,y=_y;}
  friend bool operator <(node a,node b){
    return a.x<b.x || (a.x==b.x && a.y<b.y);
  }
  friend ll operator *(node a,node b){
    return (ll)a.x*b.y-(ll)a.y*b.x;
  }
  friend node operator -(node a,node b){
    return node(b.x-a.x,b.y-a.y);
  }
}p[N],a[N];

struct SWAP{
  int x,y,p;
  SWAP(int _x=0,int _y=0,int _p=0):x(_x),y(_y),p(_p){}
  friend bool operator <(SWAP A,SWAP B){
    if(A==B) return A.p>B.p;
    return (a[A.y]-a[A.x])*(a[B.y]-a[B.x])>0;
  }
  friend bool operator ==(SWAP A,SWAP B){
    return (a[A.y]-a[A.x])*(a[B.y]-a[B.x])==0;
  }
}s[N*N];

ll mx[N<<2],mn[N<<2],tag[N<<2],tmx[N<<2];

inline char nc(){
  static char buf[100000],*p1=buf,*p2=buf;
  return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}

inline void rea(ll &x){
  char c=nc(); x=0; int f=1;
  for(;c>'9'||c<'0';f=c=='-'?-f:f,c=nc());for(;c>='0'&&c<='9';x=x*10+f*(c-'0'),c=nc());
}

inline void rea(int &x){
  char c=nc(); x=0; int f=1;
  for(;c>'9'||c<'0';f=c=='-'?-f:f,c=nc());for(;c>='0'&&c<='9';x=x*10+f*(c-'0'),c=nc());
}

inline void add(int g,ll x){
  mx[g]+=x; mn[g]+=x; tag[g]+=x;
}

inline void Push(int g){
  if(!tag[g]) return ;
  add(g<<1,tag[g]); add(g<<1|1,tag[g]);
  tag[g]=0;
}

inline void Up(ll g){
  tmx[g]=max(max(tmx[g<<1],tmx[g<<1|1]),mx[g<<1|1]-mn[g<<1]);
  mx[g]=max(mx[g<<1],mx[g<<1|1]);
  mn[g]=min(mn[g<<1],mn[g<<1|1]);
}

void Add(int g,int L,int R,int l,int r,ll x){
  if(L==l && r==R) return add(g,x);
  int mid=L+R>>1; Push(g);
  if(r<=mid) Add(g<<1,L,mid,l,r,x);
  else if(l>mid) Add(g<<1|1,mid+1,R,l,r,x);
  else Add(g<<1,L,mid,l,mid,x),Add(g<<1|1,mid+1,R,mid+1,r,x);
  Up(g);
}

int main(){
  rea(n);
  for(int i=1;i<=n;i++)
    rea(p[i].x),rea(p[i].y),rea(p[i].w),p[i].g=i,a[i]=p[i];
  sort(p+1,p+1+n);
  memset(tmx,-0x7f,sizeof(tmx));
  for(int i=1;i<=n;i++)
    b[p[i].g]=i,c[i]=p[i].g,Add(1,0,n,i,n,p[i].w);
  for(int i=1;i<=n;i++)
    for(int j=i+1;j<=n;j++){
      s[++cnt]=SWAP(p[i].g,p[j].g,max(i,j));
    }
  sort(s+1,s+1+cnt);
  ll mn=0,pre=0;
  for(int i=1;i<=n;i++){
    pre+=p[i].w;
    if(p[i].x==p[i+1].x && i!=n) continue;
    mn=min(mn,pre); ans=max(pre-mn,ans);
  }
  for(int i=1;i<=cnt;i++){
    if(b[s[i].x]>b[s[i].y]) continue;
    swap(c[b[s[i].x]],c[b[s[i].y]]);
    Add(1,0,n,b[s[i].x],b[s[i].y]-1,a[s[i].y].w-a[s[i].x].w);
    swap(b[s[i].x],b[s[i].y]);
    if(s[i]==s[i+1] && i!=cnt) continue;
    ans=max(ans,tmx[1]);
  }
  printf("%lld\n",max(ans,0LL));
  return 0;
}