[Contest on 2021.10.9] 说好的 100kb 呢？

目录

• 牛表
  • 题目描述
  • 解法
  • 代码
• 矩阵学说
  • 题目描述
  • 解法
    • $ ext{Subtask 1}$：$nle 500$
    • $ ext{Subtask 2}$：$nle 1500$
  • 代码
• 牛牛和数组操作
  • 题目描述
  • 解法
  • 代码
• 与巨
  • 题目描述
  • 解法
    • $ ext{Subtask 1}$：打表
    • $ ext{Subtask 2}$：非打表
  • 代码

牛表

题目描述

给出三个整数 (x, y, P(1 ≤ x, y < P))，(P) 为素数。可以重复对 (x) 执行如下操作： 选择一个整数 (z ∈ [1, P − 1])，花费 (∣ x − z ∣) 的牛币，使得 (x = x cdot z mod P)。

最小需要花费多少牛币才能使得 (x = y)? 设 (ans(i, j)) 为 当 (x = i, y = j) 时的答案，为了减少输出，你需要输出 (sum_{i=1}^{P-1}sum_{i=1}^{P-1} ans(i,j)cdot t^{(i-1)cdot (P-1)+j-1}mod 998244353)。

(2le Ple 2000,1le tle 5000)。

解法

首先可以 (mathcal O(n^3)) 做 ( m Floyd)。打表可知，(ans(i,j)le 17)，这就意味着边数不会超过 (35n)。用堆优化 ( m Dijkstra) 可以做到 (mathcal O(35n^2log n))。

不过复杂度可以优化到更优。

还是由于 (ans(i,j)le 17)，所以边权范围很小，令其为 (D)。可以开 (D) 个队列，复杂度是 (mathcal O(n^2D)) 的。这完全等于没讲。

考虑 ( m Dijkstra) 需要重复入队和优先队列维护的原因是边权不同，可能原来更劣的解加上新的边权就更优了。开 (D) 个队列，哪种边就塞进哪个队列就规避了这个问题。具体更新过程：找到 (D) 个队列中当前离 (s)（源点）最近的点，枚举 (2D) 种边权来扩展，塞入对应边权的队列。

可以证明从队列中取出的点的最短路一定是递增的。可以用归纳法，先开始最短路是递增的，据此可以证明每个队列的值是递增的，反过来就可以证明原命题。

所以每个点只被更新一次（可以被入队多次），只用最优值来更新即可。每个点拓展一次，拓展复杂度 (mathcal O(D))，所以总共是 (mathcal O(n^2D)) 的。

在神仙学弟的代码上改了改：( m Link.)

代码

#include <cstdio>
#define print(x,y) write(x),putchar(y)

template <class T>
inline T read(const T sample) {
	T x=0; char s; bool f=0;
	while((s=getchar())>'9' or s<'0')
		f |= (s=='-');
	while(s>='0' and s<='9')
		x = (x<<1)+(x<<3)+(s^48),
		s = getchar();
	return f?-x:x;
}

template <class T>
inline void write(const T x) {
	if(x<0) {
		putchar('-');
		write(-x);
		return;
	}
	if(x>9) write(x/10);
	putchar(x%10^48);
}

#include <queue>
#include <iostream>
using namespace std;

const int inf = 5e6;
const int maxn = 2005;
const int mod = 998244353;

int p,t,head[maxn],cnt;
int dis[maxn];
bool vis[maxn];
struct edge {
	int nxt,to,w;
} e[maxn*20];
struct node {
	int u,w;
	node() {}
	node(int U,int W):u(U),w(W) {}
	
	bool operator < (const node &t) const {
		return w>t.w;
	}
};
priority_queue <node> q;

inline int Abs(int x) {
	return x>0?x:-x;
}

inline int inc(int x,int y) {
	return x+y>=mod?x+y-mod:x+y;
}

void addEdge(int u,int v,int w) {
	e[++cnt].to=v;
	e[cnt].nxt=head[u];
	e[cnt].w=w;
	head[u]=cnt;
}

void Dijkstra(int x) {
	for(int i=1;i<p;++i)
		dis[i]=0x3f3f3f3f,vis[i]=0;
	q.push(node(x,0));
	dis[x]=0;
	while(!q.empty()) {
		node t=q.top(); q.pop();
		if(vis[t.u] or (t.w^dis[t.u]))
			continue;
		vis[t.u]=1;
		for(int i=head[t.u];i;i=e[i].nxt) {
			int v=e[i].to;
			if(dis[v]>dis[t.u]+e[i].w) {
				dis[v]=dis[t.u]+e[i].w;	
				q.push(node(v,dis[v]));
			}
		}
	}
}

int main() {
	p=read(9),t=read(9);
	for(int i=1;i<p;++i) {
		int l=max(1,i-18);
		int r=min(p-1,i+18);
		for(int j=l;j<=r;++j) 
			addEdge(i,1ll*i*j%p,Abs(i-j));
	}
	int tmp=1,ans=0; 
	for(int i=1;i<p;++i) {
		Dijkstra(i);
		for(int j=1;j<p;++j)
			ans = inc(ans,1ll*dis[j]*tmp%mod),
			tmp = 1ll*tmp*t%mod;
	}
	print(ans,'
');
	return 0;
}

矩阵学说

题目描述

给定 (n imes m) 的矩阵 (a)。求其中包含的恰好含 (k) 个不同整数个数的正方形。

(1le n,mle 1500,1le a_ile 100)。

解法

( ext{Subtask 1})：(nle 500)

枚举左上角和正方形边长。用两个 ( ext{long long}) 或 ( m bitset) 来维护边长增加时添加的数字。

( ext{Subtask 2})：(nle 1500)

对于固定的左上角，正方形包含数字种类是单调的嗄！二分边长，可以用二维 ( m st) 表预处理（( m bitset)），复杂度 (mathcal O left(n^2log ncdot frac{a_i}{w} ight))。

需要注意的是二维 ( m st) 表只适用于边长相等的情况。

代码

#pragma GCC optimize(2)
#pragma GCC optimize(Ofast)
#include <cstdio>
#define print(x,y) write(x),putchar(y)


template <class T>
inline T read(const T sample) {
	T x=0; char s; bool f=0;
	while((s=getchar())>'9' or s<'0')
		f |= (s=='-');
	while(s>='0' and s<='9')
		x = (x<<1)+(x<<3)+(s^48),
		s = getchar();
	return f?-x:x;
}

template <class T>
inline void write(const T x) {
	if(x<0) {
		putchar('-');
		write(-x);
		return;
	}
	if(x>9) write(x/10);
	putchar(x%10^48);
}

#include <bitset>
#include <iostream>
using namespace std;

const int maxn = 1505;

int n,m,K,lg[maxn],lim;
bitset <100> f[12][maxn][maxn];

void init() {
	for(int k=1;k<=lg[lim];++k)
		for(int i=1;i+(1<<k)-1<=n;++i)
			for(int j=1;j+(1<<k)-1<=m;++j)
				f[k][i][j] = (
					f[k-1][i][j]|
					f[k-1][i+(1<<k-1)][j]|
					f[k-1][i][j+(1<<k-1)]|
					f[k-1][i+(1<<k-1)][j+(1<<k-1)]
				);
}

int ask(int u,int d,int l,int r) {
	int dis=lg[r-l+1];
	return (
		f[dis][u][l]|
		f[dis][u][r-(1<<dis)+1]|
		f[dis][d-(1<<dis)+1][l]|
		f[dis][d-(1<<dis)+1][r-(1<<dis)+1]
	).count();
}

int calc(int x) {
	int ret=0;
	for(int i=1;i<=n;++i)
		for(int j=1;j<=m;++j) {
			int l=0,r=min(n-i,m-j)+1,mid;
			while(l<r) {
				mid=l+r+1>>1;
				if(ask(i,i+mid-1,j,j+mid-1)<=x)
					l=mid;
				else r=mid-1;
			}
			ret += l;
		}
	return ret;
}

int main() {
	n=read(9),m=read(9),K=read(9);
	lim = max(n,m);
	for(int i=2;i<=lim;++i)
		lg[i]=lg[i>>1]+1;
	for(int i=1;i<=n;++i)
		for(int j=1;j<=m;++j)
			f[0][i][j][read(9)-1]=1;
	init();
	print(calc(K)-calc(K-1),'
');
	return 0;
}

牛牛和数组操作

题目描述

给定长度为 (n) 的数列 (a)。你需要做 (n) 次操作，每次操作为以下形式：

• 选择一个整数 (x) 满足 (a_x ≠ 0)，将 (a_x) 变成 (0)，令 (l,r) 分别为离 (x) 向左/右最近的 (a) 为 (0) 的下标，此次操作的花费为 (max{a_l, a_{l+1}, . . . , a_{x−1}} + max{a_{x+1}, a_{x+2}, . . . , a_{r}}) 牛币。

问有多少不同的操作方式使得操作花费的牛币最少，两种操作不同当且仅当两种操作的操作序列不同。答案对 (998244353) 取模。

(1le nle 2000,1le a_ile n)。

解法

很难想象正解时间复杂度是 (mathcal O(n^3))。

首先可以发现，一次操作会将一个区间分成互不干扰的两半，这提醒我们区间 (mathtt{dp})。不过似乎我们并不需要 (mathtt{dp}) 得出最少花费，可以感性理解每次选择区间 (max) 作为划分点是最优的。

合并两个区间时贡献就是 (dp_{i,k-1}cdot dp_{k+1,j}cdot inom{j-i}{k-i})，就是两个长度为 (k-i,j-k) 的序列保留各自顺序进行合并。

另外讲一个小 ( m trick)？发现区间 (max) 如果相邻，它们的总贡献相当于是其中之一的贡献乘二。感觉没啥用。

代码

#pragma GCC optimize(2)
#include <cstdio>
#define print(x,y) write(x),putchar(y)

template <class T>
inline T read(const T sample) {
	T x=0; char s; bool f=0;
	while((s=getchar())>'9' or s<'0')
		f |= (s=='-');
	while(s>='0' and s<='9')
		x = (x<<1)+(x<<3)+(s^48),
		s = getchar();
	return f?-x:x;
}

template <class T>
inline void write(const T x) {
	if(x<0) {
		putchar('-');
		write(-x);
		return;
	}
	if(x>9) write(x/10);
	putchar(x%10^48);
}

const int maxn = 2005;
const int mod = 998244353;

int pos[maxn][maxn];
int n,a[maxn],dp[maxn][maxn];
int fac[maxn],ifac[maxn];

inline int inc(int x,int y) {
	return x+y>=mod?x+y-mod:x+y;
}

inline int inv(int x,int y=mod-2) {
	int r=1;
	while(y) {
		if(y&1) r=1ll*r*x%mod;
		x=1ll*x*x%mod; y>>=1;
	}
	return r;
}

void init() {
	fac[0]=1;
	for(int i=1;i<=n;++i) {
		pos[i][i]=i;
		dp[i][i]=dp[i][i-1]=dp[i+1][i]=1;
		for(int j=i+1;j<=n;++j)
			if(a[pos[i][j-1]]<a[j])
				pos[i][j]=j;
			else pos[i][j]=pos[i][j-1];
		fac[i]=1ll*fac[i-1]*i%mod;
	}
	ifac[n]=inv(fac[n]);
	for(int i=n-1;i>=0;--i)
		ifac[i]=1ll*ifac[i+1]*(i+1)%mod;
}

inline int C(int n,int m) {
	if(n<m or n<0 or m<0)
		return 0;
	return 1ll*fac[n]*ifac[m]%mod*ifac[n-m]%mod;
}

int main() {
	n=read(9);
	for(int i=1;i<=n;++i)
		a[i]=read(9);
	init(); int F;
	for(int len=2;len<=n;++len)
		for(int i=1;i+len-1<=n;++i) {
			int j=i+len-1,mx=a[pos[i][j]];
			for(int k=pos[i][j];k<=j;k=pos[k+1][j]) {
				if(a[k]^mx) break;
				F = (k==i or k==j)?1:C(len-1,k-i);
				dp[i][j] = inc(dp[i][j],1ll*dp[i][k-1]*dp[k+1][j]%mod*F%mod);
				if(k==j) break;
			}
		}
	print(dp[1][n],'
');
	return 0;

与巨

题目描述

定义无穷序列 (f)：(f_1=1,f_n=f_{n-1}cdot 2+1)，函数 (G(x)=min_{f_ige x}f_i)。

定义 (dp_{c,0}=0)，递推式：

[dp_{c,i}=max{dp_{c,i-1},[(ic & G(i))=i]cdot i} ]

求 (sum_{i=0}^n dp_{c,i}mod 998244353)。

(1le |n|le 10^7,1le cle 10^{18})。

解法

( ext{Subtask 1})：打表

对于 (|n|le 30,1le cle 50)。

有一个结论：(dp_{c,i}) 在 (c) 为偶数时恒为 (0)。这里感谢 ( ext{Emm_titan}) 送出的证明！

• (i=0)。此时值为零。
• (i eq 0)。找到 (i) 最低位的 (1) 的位置 (j)，乘上一个偶数相当于 (j) 上的 (1) 出现了偶数次！所以第 (j) 位就变成 (0) 了，而且前面的位都不会更改它了。

因此就只有 (25) 个有用的 (c)。可以对 (dp_{c_i,kcdot 10^6}) 的前缀和进行打表。由于 (n) 在 (10^9) 范围，先找到离 (n) 最近的 (k)，再 (mathcal O(10^6)) 地暴算。

( ext{Subtask 2})：非打表

我直呼 ( m gelivable)！非常地 ( m niubility)！

首先发现 (G(i)=2^{t+1}-1)，(t) 为二进制最高位。那么 (x ext{ and }G(x)=xmod 2^{t+1})！

所以条件可以转化为 (icdot (c-1)mod 2^{t+1}=0)。将 (c-1) 表示为 (qcdot 2^p)（(gcd(q,2)=1)），那么 (i) 必须被 (2^{t+1-p}) 整除。

由于 (t) 至多只到 (|n|-1)，我们枚举 (t)。

• (t<|n|-1)。

  此时 ([2^t,2^{t+1})) 之内的数都在 (n) 之内，令 (g=t+1-p)，那么 (i) 被 (2^g) 整除意味着 (i) 的低 (g) 位全为零。

  那么满足条件的数实际上是 (2^t,2^t+2^g,...,2^t+kcdot 2^g)。其中 (k=2^{t-g})。而且每一项都贡献了 (2^g) 次，实际上对于 (2^t) 就是 ([2^t,2^t+2^g))。

• (t=|n|-1)。

  和上面类似，只是此时 (k=left lfloor frac{n}{2^g} ight floor+2^{t-g})。最后一项的贡献次数也多算了，需要减去。

代码

咕咕咕…