CF 627E

题意

给定一个$R * C$的矩阵，一开始每个位置都是0。然后有$N$个特殊的位置$x_i,y_i$，其权值为$1$。问你可以从这个矩阵中选出多少个子矩阵，满足这个矩阵中有至少$K$个$1$。

数据范围

$1 \leq R,C,N \leq 3000$
$K \leq \min(N,10)$

题解

首先，一个矩阵可以由两个二元组$(x,x_1),(y,y_1)$表示$x$的范围以及$y$的范围。那么假如我们已经枚举了$(x,x_1)$，那么接下来的问题就是如何快速统计有多少合法的$(y,y_1)$了。
考虑一种比较暴力的做法，对于当前的$(x,x_1)$，提取出所有在这个范围内的$1$，并把他们按$y$坐标排序。设总共有$m$个$1$，那么整个$y$区间就被我们分成了$m + 1$段，当然可能有的段为空。接着我们可以维护出每个$1$往后$K$个到了哪个$1$，那么总共可行的$(y,y_1)$就是$\sum_i (S_i - S_{i - 1}) * (C - S_{k_i} + 1)$，$S_i$表示第$i$个$1$的坐标，$k_i$表示其往后跳$K$个到了哪里。
这种做法对于每个$(x,x_1)$的复杂度都是$O(N)$的。接下来我们就要优化这个做法。
我们先对于$(x,R)$做一下这个算法，然后我们就可以得到$k_i$，以及每个$1$的前驱与后驱。接着从$R-1$到$x$枚举$x_1$，枚举每一行时，相当于把上一行的$1$删掉。注意到我们的$k_i$维护的是往后跳$K$步到了哪个$1$，所以我们每删一个$1$，最多只会影响$K$个位置的$k_i$，我们在修改时顺便维护一下$\sum_i (S_i - S_{i - 1}) * (C - S_{k_i} + 1)$就好了。注意在修改前驱后驱时也要维护这个值。
最后总的复杂度就是$O(R^2 + R * N * K)$。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>

using namespace std;

const int MAXN = 3005;
typedef long long LL;

struct Node
{
    int x,y;
}Po[MAXN];

vector<int> All[MAXN],Lk[MAXN];
int R,C,N,K;
int Pre[MAXN],Next[MAXN];

int main()
{
    //freopen("data.in","r",stdin),freopen("data.out","w",stdout);
    scanf("%d%d%d%d", &R, &C, &N, &K);
    for(int i = 1;i <= N;i ++)
    {
        scanf("%d%d", &Po[i].x, &Po[i].y);
        All[Po[i].x].push_back(i);
        Lk[Po[i].y].push_back(i);
    }
    Po[N + 1].y = C + 1;
    LL ans = 0;
    for(int i = 1;i <= R;i ++)
    {
        static int Cur[MAXN],S[MAXN];
        int tot = 0;
        for(int j = 1;j <= C;j ++)
            for(int k = 0;k < Lk[j].size();k ++)
                if (Po[Lk[j][k]].x >= i) Cur[++ tot] = Lk[j][k];
        Cur[tot + 1] = N + 1;
        LL cur = 0;
        for(int j = 1;j <= tot;j ++)
        {
            Pre[Cur[j]] = Cur[j - 1],Next[Cur[j]] = Cur[j + 1];
            if (j + K - 1 <= tot) S[Cur[j]] = Cur[j + K - 1]; else
                S[Cur[j]] = Cur[tot + 1];
            cur += (C - Po[S[Cur[j]]].y + 1) * 1ll * (Po[Cur[j]].y - Po[Cur[j - 1]].y);
        }
        ans += cur;
        for(int j = R;j >= i;j --)
        {
            for(int k = 0;k < All[j].size();k ++)
            {
                int ref = All[j][k];
                int p = Next[ref];
                if (p != N + 1) cur -= (C - Po[S[p]].y + 1) * 1ll * (Po[p].y - Po[Pre[p]].y);
                Pre[Next[ref]] = Pre[ref],Next[Pre[ref]] = Next[ref];
                if (p != N + 1) cur += (C - Po[S[p]].y + 1) * 1ll * (Po[p].y - Po[Pre[p]].y);
                if (S[ref] != N + 1)
                {
                    cur -= (C - Po[S[ref]].y + 1) * 1ll * (Po[ref].y - Po[Pre[ref]].y);
                    for(int p = Pre[ref],c = K - 1;p && c;p = Pre[p],c --)
                    {
                        cur -= (C - Po[S[p]].y + 1) * 1ll * (Po[p].y - Po[Pre[p]].y);
                        S[p] = Next[S[p]];
                        cur += (C - Po[S[p]].y + 1) * 1ll * (Po[p].y - Po[Pre[p]].y);
                    }
                } else
                {
                    tot = 0;
                    for(int p = Next[ref];p;p = Next[p]) Cur[++ tot] = p;
                    reverse(Cur + 1,Cur + tot + 1);
                    for(int p = Pre[ref],c = K - 1;p && c;p = Pre[p],c --)
                    {
                        cur -= (C - Po[S[p]].y + 1) * 1ll * (Po[p].y - Po[Pre[p]].y);
                        Cur[++ tot] = p;
                        if (tot - K + 1 > 0) S[p] = Cur[tot - K + 1]; else S[p] = N + 1;
                        cur += (C - Po[S[p]].y + 1) * 1ll * (Po[p].y - Po[Pre[p]].y);
                    }   
                }
            }
            ans += cur;
        }
    }
    printf("%I64d\n", ans);
    return 0;
}