【总结】COCI2016-2017#4

2021/7/15

T1 ：Bridž

水，略

T2 ：Kartomat

建个 Trie 树跑一波，不过这么小的数据范围貌似不用

T3：Kas

不难发现就是将 \(N\) 个数分成 \(3\) 堆，前两堆大小相同，使得第三堆最小。

定义状态 \(f[i][j][k]\) 表示前面 \(i\) 个数，第 \(1\) 堆大小为 \(j\)，第 \(2\) 堆大小为 \(k\) ，是否可行，直接转移，貌似可以 bitset 优化做到 \(\mathcal{O}(\dfrac{N(\sum c)^2}{w})\)。

比较套路的做法，对后两个维度作差，定义状态 \(f[i][j]\) 表示前 \(i\) 个数，前两堆差为 \(j\) 时，第 \(1\) 堆可以达到的最大重量时多少。

直接转移 \(\mathcal{O}(N\sum c)\) 已经可以通过。

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define pre(i,a,b) for(int i=a;i>=b;i--)
#define N 100005
using namespace std;
int f[N << 1], n, g[N << 1];
inline void ck(int &x,int y){if(y > x)x = y;}
int main(){
	scanf("%d", &n);
	int sum = 0;
	memset(f, 0xcf, sizeof(f));
	int bas = N - 5;
	f[bas] = 0;
	rep(i, 1, n){
		memset(g, 0xcf, sizeof(g));
		int x;scanf("%d", &x);
		rep(j, -sum, sum)
			ck(g[j + bas], f[j + bas]), 
			ck(g[j + x + bas], f[j + bas] + x), 
			ck(g[j - x + bas], f[j + bas]);
		sum += x;rep(j, -sum, sum)f[j + bas] = g[j + bas];
	}
	printf("%d\n", sum - f[bas]);
	return 0;
}

T4：Rekonstruiraj

感觉是个错题啊，像 \(\frac{1}{3}\) 这样无限小数怎么处理精度啊。

考虑逆向思维，我们要将最终集合的数一一删去。

显然最小的数只能被不大于它的数删去，那么我们枚举整个数。

而这个数一定是最小的数除以一个正整数倍率，我们从小到大枚举倍率，同时判断在这个倍率下，区间\([A,B]\) 中是否有删除了没有的元素。

由于 \(K\) 很小，所以判断和删除都是 \(\mathcal{O}(K)\) 级别的，所以复杂度是 \(\mathcal{O}(K^2)\) ？感觉挺玄学的。

另外赛时发现 luogu 的 spj 全是锅，直接 Hack spj 就能过。

T5：Rima

挺有意思的题。

刚开始看非常没有思路就先开 T6 了。

先想到可能是 DAG 求最长路，发现不大可做。

观察一下这个 \(LCS \ge Len - 1\) 的条件。两个串长度不相等，一定一个是另一个的前缀且长度相差 \(1\) ，否则一定两个串最后以为一定不相等。

所以长度相等的串且前缀相等大概是两两连边，然后不等的串连边是唯一的。感觉也不是很可做。

但是把这个连边放到 Trie 树上乱搞，发现这就是一个走 \(Trie\) 树的过程。我们要找的是是一条路径，使得路径长度加上与路径直接相连的边的长度之和最大。

直接树上 DP 即可，时间复杂度 \(\mathcal{O}(N + \sum|S|)\)，需要注意的是 Trie 的空间，大概得用 vector 维护以时间换空间。

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define pre(i,a,b) for(int i=a;i>=b;i--)
#define N 3000005
using namespace std;
int n, idx, ed[N];
vector<pair<int,int>>ch[N];
char s[N];
int get(int x,int y){
	for(auto z:ch[x])if(z.first == y)return z.second;
	return 0;
}
int f[N], ans;
void dfs(int x){
	f[x] = ed[x];
	int mx = 0, nxt = 0, sz = 0;
	for(auto y:ch[x]){
		dfs(y.second);
		if(ed[y.second]){
			sz++, nxt = max(nxt, f[y.second]);
			if(nxt > mx)swap(nxt, mx);
		}
	}ans = max(ans, nxt + mx + f[x] + max(0, sz - 2));
	f[x] += mx + max(0, sz - 1);
}
int main(){
	scanf("%d", &n);
	rep(i, 1, n){
		scanf("%s", s + 1);
		int m = strlen(s + 1), cur = 0;
		pre(j, m, 1){
			int now = get(cur, s[j] - 'a');
			if(!now)
				ch[cur].push_back(make_pair(s[j] - 'a', ++idx)), cur = idx;
			else cur = now;
		}
		ed[cur] = 1;
		//cout<<"ww "<<cur<<endl;
	}
	dfs(0);printf("%d\n", ans);
	return 0;
}

T6：Osmosmjerka

求概率输出准确值还不用取模，显然是直接枚举所有可能（

显然这个无限矩阵就是以给定的子矩阵为元不断循环，如果我们固定一个方向，那么以 \((i,j)\)为起点的串，和以 \((i+an, j+bm),\ a,b\in \mathcal{Z}\) 为起点的串一定相同。

所以我们只用枚举起点在 \((i, j), i\in[0, n - 1], j\in[0,m -1]\) 的串即可，然后就是求这个串的哈希值。

这个字符串开始和结束的几个单独拎出来，中间不断循环。开始和结束的哈希值可以预处理，中间的是个等比数列，可以直接通项公式爆算。

细节比较多。注意斜的，横的，竖的的循环节可能都不相同，斜的循环节和 \(n,m\) 的最大公约数有关，不过我们可以直接对整个子矩阵遍历一遍避免过多讨论。

另外建议双哈希，赛时随机了一个\(10^9\) 左右的质数 \(934567889\) 被卡了 \(40\) 分，然后又随了两个质数还是挂了，查了半天还以为是哪里挂了，后来才发现原来是卡了哈希，估计出题人把 \(10^9\) 左右的模数都卡了。

后来找到 \(bas = 229, P = 10^9 + 97\) 没有卡（

时间复杂度 \(\mathcal{O}(NM\log)\) ，实现较丑还排了序。

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define pre(i,a,b) for(int i=a;i>=b;i--)
#define N 505
#define P 1000000097
#define bas 229
using namespace std;
int n, m, k, v[N][N], mat[N][N], idx, f[N][N], pw[N * N];
vector<int>c[N];
char s[N][N], cp[N][N];
void ins(int x,int y){
	v[x][y] = ++idx;mat[x][y] = 0;
	c[idx].push_back(s[x][y]);
	while(true){
		x = (x + 1) % n;
		y = (y + 1) % m;
		if(v[x][y])break ;
		v[x][y] = idx, 
		mat[x][y] = c[idx].size(), 
		c[idx].push_back(s[x][y]);
	}
	int w = c[idx].size();
	//cout<<"init " <<w<<endl;
	rep(i, 1, w - 1)c[idx][i] = (1LL * c[idx][i - 1] * bas + c[idx][i]) % P;
}
void init(){
	rep(i, 0, n - 1){
		f[i][0] = s[i][0];
		rep(j, 1, m - 1)
			f[i][j] = (1LL * f[i][j - 1] * bas + s[i][j]) % P;
	}
	rep(i, 0, n - 1)rep(j, 0, m - 1)if(!v[i][j])ins(i, j);
}
vector<int>w;
int Pow(int x,int y){
	int now = 1;
	for(;y;y >>= 1, x = 1LL * x * x % P)if(y & 1)now = 1LL * now * x % P;
	return now;
}
inline int g(int x,int y){
	if(x == 1)return y + 1;
	return 1LL * (Pow(x, y + 1) - 1) * Pow(x - 1, P - 2) % P;
}
int calc(int x,int bs,int cnt){return 1LL * x * g(bs, cnt - 1) % P;}
int row(int x,int y){
	int res = k, pr = 0, cur = 0;
	if(y)pr = f[x][y - 1];
	if(m - y >= res)return (f[x][y + res - 1] - 1LL * pr * pw[res] % P + P) % P;
	cur = (f[x][m - 1] - 1LL * pr * pw[m - y] % P + P) % P, res -= m - y;
	if(res <= m)return (1LL * pw[res] * cur + f[x][res - 1]) % P;
	int cc = res / m; res %= m;
	cur = 1LL * cur * Pow(bas, cc * m) % P;
	cur = (cur + calc(f[x][m - 1], pw[m], cc)) % P;
	if(!res)return cur;
	return (1LL * pw[res] * cur + f[x][res - 1]) % P;
}
int col(int x,int y){
	int t = v[x][y]; 
	y = mat[x][y], x = t;
	int w = c[x].size(), res = k, pr = 0, cur = 0;
	if(y)pr = c[x][y - 1];
	if(w - y >= res)return (c[x][y + res - 1] - 1LL * pr * pw[res] % P + P) % P;
	cur = (c[x][w - 1] - 1LL * pr * pw[w - y] % P + P) % P, res -= w - y;
	if(res <= w)return (1LL * pw[res] * cur + c[x][res - 1]) % P;
	int cc = res / w; res %= w;
	cur = 1LL * cur * Pow(bas, cc * w) % P;
	cur = (cur + calc(c[x][w - 1], pw[w], cc)) % P;
	if(!res)return cur;
	return (1LL * pw[res] * cur + c[x][res - 1]) % P;
}
void rotate(){
	rep(i, 0, n - 1)rep(j, 0, m - 1)cp[j][n - 1 - i] = s[i][j];
	swap(n, m);
	rep(i, 0, n - 1)rep(j, 0, m - 1)s[i][j] = cp[i][j];
}
long long gcd(long long x,long long y){return y ? gcd(y, x % y) : x;}
signed main(){
	scanf("%d%d%d", &n, &m, &k);
	pw[0] = 1;rep(i, 1, n * m)pw[i] = 1LL * pw[i - 1] * bas % P;
	rep(i, 0, n - 1)scanf("%s", s[i]);
	rep(op, 0, 3){
		memset(v, 0, sizeof(v));
		rep(i, 1, idx)c[i].clear();
		idx = 0;init();
		rep(i, 0, n - 1)rep(j, 0, m - 1)
			w.push_back(row(i, j)), 
			w.push_back(col(i, j));
		rotate();
	}
	sort(w.begin(), w.end());int sum = 0, pr = ~0;long long ans = 0;
	for(int x : w){
		if(pr != x)ans += 1LL * sum * sum, sum = 0, pr = x;
		sum++;
	}ans += 1LL * sum * sum;//cout<<endl;
	long long fac = 1LL * w.size() * w.size();
	long long cur = gcd(ans, fac);
	printf("%lld/%lld\n", ans / cur, fac / cur);
	return 0;
}