Lawn of the Dead （线段树）

传送门

给定一个n*m的网格，有k个地雷，不能踩到地雷所在格子，从（1，1）出发，只能往左或者往下走，问最多可以到达多少个格子。

由于n，m都是1e5级别，所以我们不能模拟。

我们先观察一个结论，

• 对于第i行，假设有y1,y2两个雷，[y1+1,y2-1]这个区间格子如何能被到达呢？

• 只能从上面下来，所以我们在第i-1行中找到[y1+1,y2-1]这个区间内最左端的可到达的位置idx,那么我们从第i-1行的idx列走下来到达第i行的idx列，所以第i行的[idx,y2-1]这个区间都是可到达的了。

• 如果我们用1代表可到达，0代表不可到达，上面的操作实质就是区间查询，区间覆盖，最后每行的答案就是查询区间和，每行答案累加起来就是最终答案。（除了维护区间和之外，还需要额外维护区间内最左端1的位置）

• 我们考虑对每行都建一个线段树，但是空间不够，我们可以只建两棵，用滚动数组的思想。每次滚动都把区间更新成全是0的情况。

• 枚举到第i行时，每次先假设第i行都是0 ([1,m]的区间覆盖)，然后枚举地雷进行区间更新

• 细节：1、第一行需要特判。2、我们可以假设第0列，第m+1列都是雷，这样可以省略很多特殊情况的判断

#include<bits/stdc++.h>
using namespace std;
//#pragma GCC optimize(2)
#define ull unsigned long long
#define ll long long
#define pii pair<int, int>
const int maxn = 1e5 + 10;
const ll mod = 998244353;
const ll inf = (ll)4e16+5;
const int INF = 1e9 + 7;
const double pi = acos(-1.0);
ll inv(ll b){if(b==1)return 1;return(mod-mod/b)*inv(mod%b)%mod;}
inline ll read()
{
    ll x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct node 
{
    #define lc rt<<1
    #define rc rt<<1|1
    int l,r;
    int idx;//最小的 1所在的列 没有1则记为m+1 1表示可以走
    int sum;//区间和  表示可以走的格子数 每结束一行 求一次区间和 累加答案 
}tree[2][maxn<<2];
int tag[2][maxn<<2];//区间覆盖的lazy 1表示覆盖成1  2表示覆盖成0
int n,m,q;
inline void pushup(int rt,int k) 
{
    tree[k][rt].sum=tree[k][lc].sum + tree[k][rc].sum;
    tree[k][rt].idx=min(tree[k][lc].idx , tree[k][rc].idx);
}
void build(int rt,int l,int r,int k)//刚开始假设全部不能走
{
    tree[k][rt].l=l,tree[k][rt].r=r;
    tag[k][rt]=0;
    if(l==r)
    {
        tree[k][rt].idx=m+1;
        tree[k][rt].sum=0;
        return ;
    }
    int mid=l+r>>1;
    build(lc,l,mid,k);build(rc,mid+1,r,k);
    pushup(rt,k);
}
inline void change(int rt,int v,int k)
{
    tree[k][rt].sum=(tree[k][rt].r-tree[k][rt].l+1)*(v%2);
    if(!tree[k][rt].sum) 
    {
        tree[k][rt].idx=m+1;
    }
    else tree[k][rt].idx=tree[k][rt].l;
    tag[k][rt]=v;
}
inline void pushdown(int rt,int k)
{
    if(tag[k][rt]) 
    {
        change(lc,tag[k][rt],k);
        change(rc,tag[k][rt],k);
        tag[k][rt]=0;
    }
}
void upd(int rt,int vl,int vr,int v,int k)
{
    int l=tree[k][rt].l,r=tree[k][rt].r;
    if(vr<l || vl>r || vr<vl) return ;
    if(vl<=l && r<=vr) 
    {
        change(rt,v,k);
        return ;
    }
    pushdown(rt,k);
    upd(lc,vl,vr,v,k);
    upd(rc,vl,vr,v,k);
    pushup(rt,k);
}
int qry(int rt,int vl,int vr,int k)
{
    int l=tree[k][rt].l,r=tree[k][rt].r;
    if(vr<l || vl>r || vr<vl) return m+1;
    if(vl<=l && r<=vr) 
    {
        return tree[k][rt].idx;
    }
    pushdown(rt,k);
    return min(qry(lc,vl,vr,k) , qry(rc,vl,vr,k));
}
int qry1(int rt,int vl,int vr,int k)
{
    int l=tree[k][rt].l,r=tree[k][rt].r;
    if(vr<l || vl>r || vr<vl) return 0;
    if(vl<=l && r<=vr) 
    {
        return tree[k][rt].sum;
    }
    pushdown(rt,k);
    return qry(lc,vl,vr,k) + qry(rc,vl,vr,k);
}
vector<int> dead[maxn];
int main()
{
    int t;cin>>t;
    while(t--)
    {
        scanf("%d %d %d",&n,&m,&q);
        for(int i=0;i<=n+1;i++) dead[i].clear();
        for(int i=1,x,y;i<=q;i++)
        {
            scanf("%d %d",&x,&y);
            dead[x].push_back(y);
        }
        //不妨假设第0列 m+1列 全是雷
        for(int i=1;i<=n;i++) 
        {
            dead[i].push_back(0);
            dead[i].push_back(m+1);
            sort(dead[i].begin(),dead[i].end());
        }

        build(1,1,m,1);//建树
        build(1,1,m,0);
        ll ans=0;
        //特判第一行
        if((int)dead[1].size() == 2) //除0 m+1列外没有雷
        {
            upd(1,1,m,1,1);
        }
        else upd(1,1,dead[1][1]-1,1,1);//1到第一个雷前一格的这段区间 可以走
        ans+=qry1(1,1,m,1);

        for(int i=2;i<=n;i++)
        {
            upd(1,1,m,2,i%2);//滚动数组 先假设这一行全不能走
            for(int j=0;j<(int)dead[i].size()-1;j++)
            {
                int y1=dead[i][j],y2=dead[i][j+1];
                //第i-1行的线段树中 查询[y1+1,y2-1]区间内 最左端的1
                int left=qry(1,y1+1,y2-1,(i-1)%2);
                if(left == m+1) continue;//都是0
                upd(1,left,y2-1,1,i%2);
            }
            ans+=qry1(1,1,m,i%2);
        }
        printf("%lld\n",ans);
    }
    return 0;
}