2019 HL SC day4

　　自闭场本来 以为 顶多一些不太会 结果发现 一堆不太会 。

树状数组  感觉 好久没看 了有点遗忘 不过还好 现在我来了。莅临之神将会消灭一切知识点哦。

今天说点不一样东西 树状数组 hh 很有用的东西 现在想想常数可谓是非常的小的吧 因为 查询的时候log 基本上市跑不满的 况且增加的时候log 也很少跑满。

先说构造 构造是最体现水平的东西------lrj 我特别信服这句话 关键不是会用这个东西而是把更深层次的东西挖掘出来，显然的是 发明这个东西比会使用这个东西 来的更难。

构造 树状数组一般采用下标来存储 当然 也是有权值树状数组 那个是后话了。原理 话 我必须得提一下 因为曾经我有一个鬼畜的想法也是正确。

如今 只能靠我自己填坑了 。 一个数字 按照自己的编号lowbit 上去 然后 从一个位置 lowbit 减过去为什么是正确的呢？这点 我想是有必要证明。

因为 考虑 lowbit 上去 你做的一些事情 首先来说不断地二进制位往上进然后 为什么倒着可以累加上去呢 我们感性思考一下(大不了 丢坑

可以证明每个数字我们被我们至多累加一次 且不会漏掉任何一个数字 只要能证明出来这个那么树状数组的原理就是正确的。

首先对于我们最大的二进制位 一个数字下标如果不超过这个二进制位那么 它一定在 我们减剩下 最大的二进制位的时候 被我们累加一次然后结束 累加一次且没漏掉一切这种类型的数字。

然后是对于一个数字的下表没有超过了这个二进制位且大小不超过我们查询下标的大小 那么 此时 显然有这个数字下标不断逐位扩大 扩大至我们当前这个数字二进制位的某一位。也就是这个数字二进制位表示是我们查询的二进制数的子集 这样显然我们询问那个数字在减的同时 一定能到达其子集 如果证明其不会重复呢 这个还是要分两种情况讨论 一个是我们刚好达到累加这个数字起点之时 那么显然一个减一个加 不会再有交集。考虑我们遇到的不是起点而是中间时刻某个点 接下来会不会继续遇到这个问题 仔细思考我们发现中间时刻某点 一定满足x>x1 那么此时我们减去lowbit x这一位 这也同时意味着不可能再有x1这个二进制位了 如果有那么lowbit 的将会是它 但是考虑lowbit的是它下次是否会lowbit x 这位 这显然也是不可能完成累加的因为在上一步想要累加上去必然存在两个数字想等然后一个+一个- 自然不可能出现交集。

证毕。

你是否听说过逆序树状数组的存在 讲操作颠倒的那种 加值得时候向下累加 统计的时候向上统计。这个操作有兴趣 的话可以去研究一下 非常的流弊正序求逆序对。

例题：

bzoj 1878 求区间本质不同的数的个数。离线处理 维护右端点单调递增 然后遇到一个数字当前位置数字 贡献+1 上一次出现这个数字贡献-1 满足贪心的原理 故这个做法是正确的。

//#include<bits/stdc++.h>
#include<iomanip>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<deque>
#include<cmath>
#include<ctime>
#include<cstdlib>
#include<stack>
#include<algorithm>
#include<vector>
#include<cctype>
#include<utility>
#include<set>
#include<bitset>
#include<map>
#define INF 10000000000000000ll
#define ll long long
#define min(x,y) ((x)>(y)?(y):(x))
#define max(x,y) ((x)>(y)?(x):(y))
#define RI register ll
#define db double
#define EPS 1e-8
using namespace std;
char buf[1<<15],*fs,*ft;
inline char getc()
{
    return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?0:*fs++;
}
inline int read()
{
    int x=0,f=1;char ch=getc();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getc();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getc();}
    return x*f;
}
const int MAXN=200010,maxn=50010,MAX=1000010;
int n,m;
int c[maxn],a[maxn],ans[MAXN];
int pre[maxn],last[MAX];
struct wy
{
    int l,r;
    int id;
    int friend operator <(const wy a,const wy b){return a.r<b.r;}
}t[MAXN];
inline void add(int x,int y)
{
    while(x<=n)
    {
        c[x]+=y;
        x+=x&(-x);
    }
}
inline int ask(int x)
{
    int cnt=0;
    while(x)
    {
        cnt+=c[x];
        x-=x&(-x);
    }
    return cnt;
}
int main()
{
    //freopen("1.in","r",stdin);
    n=read();
    for(int i=1;i<=n;++i)
    {
        a[i]=read();
        pre[i]=last[a[i]];
        last[a[i]]=i;
    }
    m=read();
    for(int i=1;i<=m;++i)
    {
        int x,y;
        x=read();y=read();
        t[i]=(wy){x,y,i};
    }
    int flag=1;
    sort(t+1,t+1+m);
    for(int i=1;i<=n;++i)
    {
        add(i,1);
        if(pre[i])add(pre[i],-1);
        while(t[flag].r==i)
        {
            ans[t[flag].id]=ask(t[flag].r)-ask(t[flag].l-1);
            ++flag;
        }
    }
    for(int i=1;i<=m;++i)printf("%d\n",ans[i]);
    return 0;
}

然后其他的应用学长讲的很鬼畜 回来再说。

线段树：主要学习了一下标记永久化 因为下传标记 会是一件很麻烦的事情 所以考虑标记不下传等到访问的时候获得标记的价值即可。

bzoj 4636 蒟蒻数列 

//#include<bits/stdc++.h>
#include<iomanip>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<deque>
#include<cmath>
#include<ctime>
#include<cstdlib>
#include<stack>
#include<algorithm>
#include<vector>
#include<cctype>
#include<utility>
#include<set>
#include<bitset>
#include<map>
#define INF 1000000000
#define ll long long
#define min(x,y) ((x)>(y)?(y):(x))
#define max(x,y) ((x)>(y)?(x):(y))
#define RI register ll
#define db double
#define EPS 1e-8
#define l(p) t[p].l
#define r(p) t[p].r
#define mx(p) t[p].mx
using namespace std;
char buf[1<<15],*fs,*ft;
inline char getc()
{
    return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?0:*fs++;
}
inline int read()
{
    int x=0,f=1;char ch=getc();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getc();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getc();}
    return x*f;
}
const int MAXN=40010;
int n,root,cnt;
struct wy
{
    int l,r;
    int mx;
}t[MAXN*33];
inline void modify(int &p,int l,int r,int L,int R,int z)
{
    if(!p)p=++cnt;
    if(L<=l&&R>=r){mx(p)=max(mx(p),z);return;}
    int mid=(l+r)>>1;
    if(L<=mid)modify(l(p),l,mid,L,R,z);
    if(R>mid)modify(r(p),mid+1,r,L,R,z);
}
inline ll ask(int p,int l,int r,int x)
{
    if(!p)return 0;
    int mid=(l+r)>>1;
    ll sum=0;
    mx(p)=max(mx(p),x);
    if(!l(p))sum+=(ll)mx(p)*(mid-l+1);
    if(!r(p))sum+=(ll)mx(p)*(r-mid);
    sum+=ask(l(p),l,mid,mx(p));
    sum+=ask(r(p),mid+1,r,mx(p));
    return sum;
}
signed main()
{
    //freopen("1.in","r",stdin);
    n=read();
    for(int i=1;i<=n;++i)
    {
        int a,b,k;
        a=read();b=read()-1;k=read();
        if(a>b)continue;
        modify(root,1,INF,a,b,k);
    }
    printf("%lld\n",ask(root,1,INF,0));
    return 0;
}

其实不需要标记永久化应该也是可以写的不过比较繁琐，支持标记永久化就是支持未来。。