楼房重建 线段树

～～～题面～～～

题解：

一栋楼是否已经被前面的楼房遮挡住，可以利用斜率来判断。

因此将原序列转化为斜率。

然后直接用线段树维护一下每个区间最多能看见多少楼房即可。

在更新区间的时候需要在线段树上二分，因为左区间是肯定可以取的，然后设左区间的最大值为k，

那么右区间的贡献就是大于k的最长上升子序列，二分即可。

建议画画图，还是很好理解的。

注意：这里其实并不是维护的传统意义上的最长递增子序列，因为这里的子序列强制从第一个开始了，所以代码中的注释其实有点问题，，（算法是对的）

#include<bits/stdc++.h>
using namespace std;
#define R register int
#define AC 100100
#define ac 600000
int n, m;
int tree[ac], l[ac], r[ac];//维护最长上升子序列和
double mx[ac];

inline int read()
{
    int x = 0;char c = getchar();
    while(c > '9' || c < '0') c = getchar();
    while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x;
}

int cal(int x, double k)//当前点，大于k的最长上升子序列
{//计算在一段区间内大于k的可以被看见的有多少个
    if(l[x] == r[x]) return mx[x] > k;
    if(mx[x] <= k) return 0;
    if(mx[x * 2] < k) return cal(x * 2 + 1, k);
    else return tree[x] - tree[x * 2] + cal(x * 2, k);
}

void update(int x)
{
    mx[x] = max(mx[x * 2], mx[x * 2 + 1]);
    tree[x] = tree[x * 2] + cal(x * 2 + 1, mx[x * 2]);
}

void build(int x, int ll, int rr)
{
    l[x] = ll, r[x] = rr;
    if(ll == rr) return ;
    int mid = (ll + rr) >> 1;
    build(x * 2, ll, mid);
    build(x * 2 + 1, mid + 1, rr);
}

void change(int x, int w, double t)//当前点，目标点, 改成什么
{//单点修改并维护新值
    if(l[x] == r[x])
    {
        mx[x] = t;
        tree[x] = 1;
        return ;
    }
    int mid = (l[x] + r[x]) >> 1;
    if(w <= mid) change(x * 2, w, t);
    else change(x * 2 + 1, w, t); 
    update(x);
}

void pre()
{
    n = read(), m = read();
    build(1, 1, n);
}

void work()
{
    int a, b;
    for(R i = 1; i <= m; i ++)
    {
        a = read(), b = read();
        change(1, a, (double)b / (double)a);//这个也要用double
        printf("%d
", tree[1]);
    }
}

int main()
{
//    freopen("in.in", "r", stdin);
    pre();
    work();
//    fclose(stdin);
    return 0;
}