杭电多校第一场7月20日补题记录

H Maximal submatrix

题意：找到最大的连续子矩形，使得每一列都非单调递减。

解法：考虑转化为 01 矩阵。如果当前位比上一位大或等于，则记 $1$，反之为 $0$。则原题转化为找到最大的全 $1$ 矩阵。

考虑使用悬线法。定义以下几个变量：$lef{t}_{i,j}$表示以 $(i,j)$为端点向左延申的最左边界（不遇到障碍），$righ{t}_{i,j}$是 $(i,j)$ 向右延申的最右边界。$heigh{t}_{i,j}$ 表示向上延申的最大高度。我们很容易发现一个简单的递推式：

$$lef{t}_{i,j}\{\begin{array}{ll}lef{t}_{i-1,j}+1,& \text{当前节点是合法节点}\\ 0,& \text{当前节点不合法}\end{array},righ{t}_{i,j}\{\begin{array}{ll}lef{t}_{i+1,j}+1,& \text{当前节点是合法节点}\\ 0,& \text{当前节点不合法}\end{array},heigh{t}_{i,j}\{\begin{array}{ll}heigh{t}_{i,j-1}+1,& \text{当前节点是合法节点}\\ 0,& \text{当前节点不合法}\end{array}$$

在最后统计答案的时候，考虑以 $(i,j)$ 为下端点的矩形。更新 l e f t i , j = max ⁡ { l e f t i , j , l e f t i − 1 , j } left_{i,j}=\max\{left_{i,j},left_{i-1,j}\} lefti,j​=max{lefti,j​,lefti−1,j​}，更新 r i g h t i , j = min ⁡ { r i g h t i , j , r i g h t i + 1 , j } right_{i,j}=\min\{right_{i,j},right_{i+1,j}\} righti,j​=min{righti,j​,righti+1,j​}。此时在 $[lef{t}_{i,j},righ{t}_{i,j}]$ 上矩形始终合法。

模板见下：

    //赋初值
    for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
		{
			left[i][j] = right[i][j] = j;
			height[i][j] = 1;
		}
	//更新left
	for (int i = 1; i <= n; i++)
		for (int j = 2; j <= m; j++)
			if (check(i,j)) //判定是否合法
				left[i][j] = left[i][j - 1];
				
	for (int i = 1; i <= n; i++)
		for (int j = m - 1; j >=1 ; j--)
			if (check(i,j)) 
				right[i][j] = right[i][j + 1];
				
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
			if (i > 1 && check(i,j))
			{
				left[i][j] = max(left[i][j], left[i - 1][j]);
				right[i][j] = min(right[i][j], right[i - 1][j]);
				height[i][j] = height[i - 1][j] + 1;
			}

总体时间复杂度 $O(nm)$。

但是此题有一个局限性在于：当前点为 $0$ 并不代表着当前点不能取得，而是说这个点不能和上一个点一起取得。因而在处理的时候需要一些更特殊的判断。

同时此题卡空间，因而推荐使用单调栈的做法。考虑滚动 $height$ 数组，这样就可以满足题目要求的空间了。

#include <cstdio>
#include <algorithm>
using namespace std;
int height[2005], num[2005][2005];
bool vis[2005][2005];
int que[2005];
int main()
{
    int n, m, t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n;i++)
            for (int j = 1; j <= m;j++)
            {
                scanf("%d", &num[i][j]);
                if(i>1 && num[i][j]>=num[i-1][j])
                    vis[i][j] = 1;
                else
                    vis[i][j] = 0;
            }
        int ans = 0;
        for (int i = 1; i <= n; i++)
        {
            int tot = 0;
            for (int j = 1; j <= m; j++)
                if(vis[i][j])
                    height[j]++;
                else
                    height[j] = 1;
            height[m + 1] = 0;//多压入一个这样可以处理完全部的栈中元素，防止遗漏解
            for (int j = 1; j <= m + 1; j++)
            {
                while(tot && height[que[tot]]>height[j])
                {
                    ans = max(ans, (j - que[tot - 1] - 1) * height[que[tot]]);
                    tot--;
                }
                que[++tot] = j;
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}

J zoto

题意：给定 $xOy$ 平面上的 $n$ 个点 $(i,f(i))$，进行 $m$ 次询问，每次给定一个矩形，问全部位于矩形内的点的不同纵坐标值有多少个。

解法：考虑一个简化的问题。给一个数组，初始所有位置全是 $0$，每次单点加一或减一，询问区间有多少个位置不为 $0$。若使用分块，则修改的复杂度为 $O(1)$，查询的复杂度为 $O(\sqrt{n})$。

考虑离线化询问，使用莫队算法。注意到在 $y$ 维度上就是我们说的这个问题，因而对 $y$ 上对值域进行分块维护，在 $x$ 轴上进行区间的移动。莫队单次移动区间复杂度为 $O(\sqrt{n})$，查询复杂度为 $O(1)$，因而整体复杂度为 $O(m(\sqrt{(}n)+\sqrt{(}N)))$。

#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
int block_x, block_y;
struct node
{
    int left;
    int right;
    int up;
    int down;
    int id;
};
struct node que[100005];
int f[100005];
int num[100005], sum[100005], ans[100005];
bool cmp(node a,node b)
{
    if(a.left/block_x==b.left/block_x)
    {
        if ((a.left/block_x)&1)
            return a.right < b.right;
        else
            return a.right > b.right;
    }
    else
        return a.left / block_x < b.left / block_x;
}
void add(int x)
{
    num[x]++;
    if(num[x]==1)
        sum[x / block_y]++;
}
void sub(int x)
{
    num[x]--;
    if(num[x]==0)
        sum[x / block_y]--;
}
int query(int x)
{
    int ans = 0;
    for (int i = 0; i < x / block_y;i++)
        ans += sum[i];
    for (int i = x / block_y * block_y; i <= x;i++)
        ans += (num[i] >= 1);
    return ans;
}
int main()
{
    int t, n, m;
    block_y = sqrt(100000);
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n;i++)
            scanf("%d", &f[i]);
        block_x = sqrt(n);
        for (int i = 1; i <= m; i++)
        {
            scanf("%d%d%d%d", &que[i].left, &que[i].down, &que[i].right, &que[i].up);
            que[i].id = i;
        }
        sort(que + 1, que + n + 1, cmp);
        int nowleft = que[1].left, nowright = que[1].right;
        for (int i = nowleft; i <= nowright;i++)
            add(f[i]);
        ans[que[1].id] = query(que[1].up) - query(que[1].down - 1);
        for (int i = 2; i <= m;i++)
        {
            while(que[i].left<nowleft)
                add(f[--nowleft]);
            while (que[i].right > nowright)
                add(f[++nowright]);
            while (que[i].left > nowleft)
                sub(f[nowleft++]);
            while (que[i].right < nowright)
                sub(f[nowright--]);
            ans[que[i].id] = query(que[i].up) - query(que[i].down - 1);
        }
        for (int i = 1; i <= m; i++)
            printf("%d\n", ans[i]);
    }
    return 0;
}

K Necklace of Beads

题意：现有一个包含 $n$ 个珠子的圆环，要向这 $n$ 个珠子填红、蓝、绿三色，相同颜色不能相邻，旋转等价，求绿色珠子不超过 $k$ 个的方案总数。

解法：旋转等价考虑使用 Burnside 引理。根据公式，方案总数 $L=\frac{1}{|G|}\sum _{i=1}^{s}D(g_j)$，其中 $s$ 为置换群的大小，即 $|G|$。$D(g_j)$ 表示对于置换 $g_j$，有 $D(g_j)$ 种方案使得经过这个置换后仍为原状。注意到此处的旋转等价表示此处仅有以下的 $n$ 种置换：

$$g_1=\left(\begin{array}{cccccc}1& 2& 3& \cdots & n-1& n\\ 1& 2& 3& \cdots & n-1& n\end{array}\right),g_2=\left(\begin{array}{cccccc}1& 2& 3& \cdots & n-1& n\\ 2& 3& 4& \cdots & n& 1\end{array}\right),g_3=\left(\begin{array}{cccccc}1& 2& 3& \cdots & n-1& n\\ 3& 4& 5& \cdots & 1& 2\end{array}\right),\cdots ,g_n=\left(\begin{array}{cccccc}1& 2& 3& \cdots & n-1& n\\ n& 1& 2& \cdots & n-2& n-1\end{array}\right),$$

一般化的，可以将这种置换表示为：

$$g_k=\left(\begin{array}{cccccc}1& 2& 3& \cdots & n-1& n\\ k& k\mathrm{m}\mathrm{o}\mathrm{d}n+1& (k+1)\mathrm{m}\mathrm{o}\mathrm{d}n+1& \cdots & (k+n-2)\mathrm{m}\mathrm{o}\mathrm{d}n+1& (k+n-1)\mathrm{m}\mathrm{o}\mathrm{d}n+1\end{array}\right),$$

容易证明，$g_k$ 的等价类个数为 $\gcd (k-1,n)$，因而只有循环节长度为等价类个数的涂色方案才在该方案下不变，即不动点。不妨令 $f(n,m)$ 表示在长度为 $n$ 的圆环上插入 $m$ 个绿色珠子且相邻颜色不同的方案总数，那么对于置换 $g_i$，其方案数为$\sum _{j=0}^{\lfloor \frac{kl}{n}\rfloor }g(l,j),l=\gcd (i-1,n)$。因而总的方案数为 $\sum _{i=1}^n\sum _{j=0}^{\lfloor \frac{k\gcd (i-1,n)}{n}\rfloor }g(\gcd (i-1,n),j)$。

考虑 $g(n,m)$ 的求法。不妨枚举这 $m$ 个绿色珠子的放法。由插板法，我们容易得到方案总数为 $\left(\genfrac{}{}{0ex}{}{n-m}{m}\right)+\left(\genfrac{}{}{0ex}{}{n-m-1}{m}\right)$，即绿色珠子是否出现在最后一位与否进行讨论。对于剩下的位置，满足条件的插入红蓝珠子的方案总数只有 $2$ 种，因而这部分有 $2^m$ 种方法。因而 $g(n,m)=2^m((\genfrac{}{}{0ex}{}{n-m}{m})+(\genfrac{}{}{0ex}{}{n-m-1}{m}))$。注意 $g(n,0)=2$。

考虑化简这个式子。一个非常常见的手法是枚举其公约数 $d$ 而非直接枚举 $i$。原式化简为 $\sum _{d|n}\phi (\frac{n}{d})\sum _{j=0}^{\lfloor \frac{kd}{n}\rfloor }g(d,j)$。令 $f(d)={\sum }_{j=0}^{\lfloor \frac{kd}{n}\rfloor }g(d,j)$，此处可以 $O(n)$ 的计算。加入欧拉函数的意义是，公约数 $d$ 在 $[1,n]$ 中会出现 $\phi (\frac{n}{d})$ 次，因而 $f(d)$ 会造成 $\phi (\frac{n}{d})$ 次的贡献。

因而最后化简为 $\sum _{d|n}\phi (\frac{n}{d})f(d)$。