[cf1086F]Forest Fires

记$f(i)$表示时刻$i$时着火的格子数，则答案即$t\cdot f(t)-\sum_{i=0}^{t-1}f(i)$

关于$f(i)$，即对所有点为中心、边长为$2i+1$​的矩形求并，容斥可得
$$
f(i)=\sum_{S\subseteq [1,n],S\ne \empty}(-1)^{|S|-1}\max(2i+1-d_{x}(S),0)\max(2i+1-d_{y}(S),0)
$$
（其中$d_{x/y}(S)$分别表示$S$中所有点$x$或$y$坐标的极差）

注意到可行的$d_{x}(S)$或$d_{y}(S)$均仅有$o(n^{2})$个，因此$f(i)$是一个$o(n^{2})$段的二次函数

对于每一段，仅需求出三个$f(i)$即可得到该函数，且单次（矩形求并）复杂度为$o(n\log n)$

总复杂度为$o(n^{3}\log n)$，可以通过

#include<bits/stdc++.h>
using namespace std;
#define N 60
#define mod 998244353
#define ll long long
#define pii pair<int,int>
#define L (k<<1)
#define R (L+1)
#define mid (l+r>>1)
int T,n,t,ans,x[N],y[N],yl[N],yr[N],tag[N<<3],g[N<<3],f[N<<3];
vector<int>v0,vx,vy;vector<pii>v[N<<1];
int S1(int k){
    return (ll)k*(k+1)%mod*(mod+1>>1)%mod;
}
int S2(int k){
    return (ll)k*(k+1)%mod*((k<<1)+1)%mod*(mod+1)/6%mod;
}
int findx(int k){
    return lower_bound(vx.begin(),vx.end(),k)-vx.begin()+1;
}
int findy(int k){
    return lower_bound(vy.begin(),vy.end(),k)-vy.begin()+1;
}
void update(int k,int l,int r,int x,int y,int z){
    if ((l>y)||(x>r))return;
    if ((x<=l)&&(r<=y)){
        tag[k]+=z,f[k]=(tag[k] ? vy[r]-vy[l-1] : g[k]);
        return;
    }
    update(L,l,mid,x,y,z),update(R,mid+1,r,x,y,z);
    g[k]=f[L]+f[R],f[k]=(tag[k] ? vy[r]-vy[l-1] : g[k]);
}
int calc(int k){
    vx.clear(),vy.clear();
    for(int i=1;i<=(n<<1);i++)v[i].clear();
    for(int i=1;i<=n;i++){
        vx.push_back(x[i]-k),vx.push_back(x[i]+k+1);
        vy.push_back(y[i]-k),vy.push_back(y[i]+k+1);
    }
    sort(vx.begin(),vx.end()),sort(vy.begin(),vy.end());
    for(int i=1;i<=n;i++){
        yl[i]=findy(y[i]-k),yr[i]=findy(y[i]+k+1)-1;
        v[findx(x[i]-k)].push_back(make_pair(i,1));
        v[findx(x[i]+k+1)].push_back(make_pair(i,-1));
    }
    int ans=0;
    for(int i=1;i<=(n<<1);i++){
        for(pii j:v[i])update(1,1,(n<<1)-1,yl[j.first],yr[j.first],j.second);
        if (i<(n<<1))ans=(ans+(ll)(vx[i]-vx[i-1])*f[1])%mod;
    }
    return ans;
}
int calc(int l,int r){
    if (l>r)return 0;
    if (l==r)return calc(l);
    if (l+1==r)return (calc(l)+calc(l+1))%mod;
    int c=calc(l),s1=calc(l+1),s2=calc(l+2);
    s1=(s1-c+mod)%mod,s2=(s2-c+mod)%mod;
    int a=((ll)s2*(mod+1>>1)-s1+mod)%mod,b=(s1-a+mod)%mod;
    return ((ll)a*S2(r-l)+(ll)b*S1(r-l)+(ll)c*(r-l+1))%mod;
}
int main(){
    scanf("%d%d",&n,&t);
    for(int i=1;i<=n;i++)scanf("%d%d",&x[i],&y[i]);
    ans=(ll)t*calc(t)%mod;
    v0.push_back(t);
    for(int i=1;i<=n;i++)
        for(int j=i+1;j<=n;j++)
            v0.push_back(max(abs(x[i]-x[j]),abs(y[i]-y[j]))+1>>1);
    sort(v0.begin(),v0.end());
    int l=0;
    for(int i=0;(i<v0.size())&&(v0[i]<=t);i++)ans=(ans-calc(l,v0[i]-1)+mod)%mod,l=v0[i];
    printf("%d\n",ans);
    return 0;
}

交换求和顺序，答案也即$\sum_{S\subseteq [1,n],S\ne \empty}(-1)^{|S|-1}F(d_{x}(S),d_{y}(S))$

其中$F(x,y)$为后式的总贡献（带系数），简单推导后可以$o(1)$计算

将所有点按$x$坐标排序（相同时任意），并枚举$S$（在序列中）最左和最右两点

此时已经确定$x$坐标的两个极值，并考虑枚举$y$坐标的两个极值，从而确定$d_{x/y}(S)$

四个极值即构成一个矩形，并注意到以下性质：

若矩形内除上下边界和选定的两点外存在其余的点，该点并不影响$d_{x/y}(S)$，进而使得贡献抵消

换言之，上下边界均至多"拓展"一次，总共仅有$2\times 2=4$种可能

具体实现中，可以倒序枚举右侧的点，并用链表维护两者之间的点（$y$坐标）即可

另外，关于$S$的$(-1)^{|S|-1}$之和，可以通过全体（为0）减去上/下边界全不选的情况

总复杂度为$o(n^{2})$，可以通过

#include<bits/stdc++.h>
using namespace std;
#define N 60
#define mod 998244353
#define ll long long
#define fi first
#define se second
int T,n,t,ans,b[N],cnt[N],pre[N],nex[N];
pair<int,int>a[N];
int S1(int k){
    return (ll)k*(k+1)%mod*(mod+1>>1)%mod;
}
int S2(int k){
    return (ll)k*(k+1)%mod*((k<<1)+1)%mod*(mod+1)/6%mod;
}
int calc(int x,int y){
    x=(t<<1)+1-x,y=(t<<1)+1-y;
    if ((x<0)||(y<0))return 0;
    int d=(min(x,y)>>1),ans=(ll)t*x%mod*y%mod;
    ans=(ans-4LL*S2(d)%mod+mod)%mod;
    ans=(ans+2LL*S1(d)*(x+y))%mod;
    ans=(ans-(ll)d*x%mod*y%mod+mod)%mod;
    return ans;
}
int main(){
    scanf("%d%d",&n,&t);
    for(int i=1;i<=n;i++){
        scanf("%d%d",&a[i].fi,&a[i].se);
        b[i]=a[i].se;
    }
    sort(a+1,a+n+1),sort(b+1,b+n+1);
    for(int i=1;i<=n;i++)a[i].se=lower_bound(b+1,b+n+1,a[i].se)-b;
    ans=(ll)n*calc(0,0)%mod;
    for(int i=1;i<=n;i++){
        memset(cnt,0,sizeof(cnt));
        for(int j=i;j<=n;j++)cnt[a[j].se]++;
        int lst=0;
        for(int j=1;j<=n;j++)
            if (cnt[j])pre[j]=lst,nex[lst]=j,lst=j;
        pre[0]=lst,nex[lst]=0;
        for(int j=n;j>i;j--){
            int k=a[j].se;
            if (--cnt[k]>(k==a[i].se))continue;
            if (cnt[a[i].se]==1){
                int l=a[j].fi-a[i].fi,x=a[i].se,y=a[j].se;
                if (x>y)swap(x,y);
                if ((x==y)||(nex[x]==y)){
                    ans=(ans-calc(l,b[y]-b[x])+mod)%mod;
                    if (pre[x])ans=(ans+calc(l,b[y]-b[pre[x]]))%mod;
                    if (nex[y])ans=(ans+calc(l,b[nex[y]]-b[x]))%mod;
                    if ((pre[x])&&(nex[y]))ans=(ans-calc(l,b[nex[y]]-b[pre[x]])+mod)%mod;
                }
            }
            if (!cnt[k])pre[nex[k]]=pre[k],nex[pre[k]]=nex[k];
        }
    }
    printf("%d\n",ans);
    return 0;
}