[BZOJ 1805] Sail 船帆

Link：

BZOJ 1805 传送门

Solution：

一道思路比较巧的线段树的题目

首先可以发现，答案和顺序是没有关系的，都是$\sum_{i=1}^n {H_i∗(H_i−1)/2}$。

那么可以比较容易得得到以下的贪心策略：

对于第$i$个船帆，对前$H_i$层中的前$K_i$小的数加1

感性证明：最优方案肯定是每层上数量尽量接近，那么每次放在当前数量最少的层上一定不会使答案变差

此题的难点还是在实现上，

为了对于每个$i$都能区间+1，序列一定要具有单调性

又由于$H_i$是从小到大排序的，每次区间加时注意维护序列从大到小递减即可

但每次对$[H_i-K_i+1,H_i]$+1是不一定能保证单调的，

于是我们找到$seg[H_i-K_i+1]$第一个出现的位置$posr$和结束的位置$posl$，

由于$seg[posl]$更小，我们先尽量选取$[posl,H_i]$，再从$posr$开始选取从而保证单调性

Code：

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
typedef pair<int,int> P;
#define mid ((l+r)>>1)
#define lc k<<1,l,mid
#define rc k<<1|1,mid+1,r
#define F first
#define S second

const int MAXN=1e5+;
const int INF=<<;
int n,maxk=;
ll res=;
P dat[MAXN];

int seg[MAXN<<],tag[MAXN<<];

void push_up(int k){seg[k]=min(seg[k<<],seg[k<<|]);}
void push_down(int k)
{
    if(!tag[k]) return;
    seg[k<<]+=tag[k];seg[k<<|]+=tag[k];
    tag[k<<]+=tag[k];tag[k<<|]+=tag[k];
    tag[k]=;
}

void build(int k,int l,int r)
{
    if(l==r)
    {
        if(l==maxk) seg[k]=-INF;  //要增加最后一位！
        else seg[k]=;
        return;
    }
    build(lc);build(rc);
    push_up(k);
}

int find_val(int x,int k,int l,int r)
{
    if(l==r) return seg[k];
    push_down(k);
    if(x<=mid) return find_val(x,lc);
    else return find_val(x,rc);
}

int find_pos(int x,int k,int l,int r)
{
    if(l==r) return l;
    push_down(k);
    if(seg[k<<]<=x) return find_pos(x,lc);
    else return find_pos(x,rc);
}

void Update(int a,int b,int k,int l,int r)
{
    if(a<=l && r<=b)
    {
        seg[k]++;tag[k]++;
        return;
    }
    push_down(k);
    if(a<=mid) Update(a,b,lc);
    if(b>mid) Update(a,b,rc);
    push_up(k);
}

void cnt(int k,int l,int r)
{
    if(l==maxk) return;
    if(l==r)
    {
        res+=1ll*seg[k]*(seg[k]-)/;
        return;
    }
    push_down(k);
    cnt(lc);cnt(rc);
}

int main()
{
    scanf("%d",&n);
    for(int i=;i<=n;i++)
        scanf("%d%d",&dat[i].F,&dat[i].S),maxk=max(maxk,dat[i].F);
    sort(dat+,dat+n+);maxk++;
    build(,,maxk);

    for(int i=;i<=n;i++)
    {
        int num=find_val(dat[i].F-dat[i].S+,,,maxk); //当前位置
        int posl=find_pos(num-,,,maxk); //第一个小于num的的数的位置
        int posr=find_pos(num,,,maxk);  //第一个等于num的数的位置

        if(posl<=dat[i].F) Update(posl,dat[i].F,,,maxk);
        Update(posr,posr+min(dat[i].S,posl-(dat[i].F-dat[i].S+))-,,,maxk);
    }

    cnt(,,maxk);
    printf("%lld",res);
    return ;
}

Review：

1、如果序列单调，则可用线段树查询的方式找出第一个小于/大于/等于$x$的数

2、对边界问题还是要敏感些啊，

此题中如果不添加最后一位，并将$seg[maxk]=-INF$，则可能出现$posl=(dat[i].F-dat[i].S+1)$，导致溢出

3、算是又了解了一种在线段树上维护单调性的方法吧，

要先找到这个数第一个出现的位置$pos$，再从$pos$开始操作即可