SDOI 2017 Round1 解题报告

Day 1

T1 数字表格

---

题目大意

· 求\(\prod\limits_{i=1}^n\prod\limits_{j=1}^mFibonacci(\gcd(i,j))\)，\(T\leq1000\)，\(n,m\leq10^6\)

思路

· 一言不合化式子（不失一般性地假设\(n<m\)）$$\begin{aligned}

ans&=\prod_{i=1}^n\prod_{j=1}mf((i,j))\

&=\prod_{d=1}^nf(d){\sum\limits_{i=1}^{n\sum\limits_{j=1}}m[(i,j)=d]}\

&=\prod_{d=1}^nf(d){\sum\limits_{k=1}^{\frac nd}\mu(k)\left\lfloor\frac n{dk}\right\rfloor\left\lfloor\frac m{dk}\right\rfloor}

\end{aligned}$$

· 到这里直接\(O\left(Tn^{\frac 34}\right)\)暴力计算答案，常数压的好就可以通过此题。

· 更神奇的：$$\prod_{d=1}^nf(d){\sum\limits_{k=1}^{\frac nd}\mu(k)\left\lfloor\frac n{dk}\right\rfloor\left\lfloor\frac m{dk}\right\rfloor}=\prod_{T=1}^{n\left(\prod_{d|T}f(d)}{\mu\left(\frac Td\right)}\right)^{\left\lfloor\frac nT\right\rfloor\left\lfloor\frac mT\right\rfloor}$$

· 我们设\(g(n)=\prod\limits_{d|n}f(d)^{\mu\left(\frac nd\right)}\)

· 很类似莫比乌斯反演，\(f(n)=\prod\limits_{d|n}g(n)\)，这个结论没什么意义，不过可以从另一个角度来做这道题。

· 如何预处理\(g(i)\)呢？\(g(i)\)并不是积性函数，但我们可以枚举所有斐波那契数，然后再枚举它们的倍数来计算对\(g(i)\)的贡献，时间复杂度\(O(n\ln n)\)。

· 预处理完成后\(O\left(\left(\sqrt n+\sqrt m\right)\log n\right)\)回答单次询问。

· 时间复杂度\(O\left(n\ln n+T\left(\sqrt n+\sqrt m\right)\log n\right)\)。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;

const int N = 1000003;
const int p = 1000000007;

bool notp[N];
int mu[N], prime[N], num = 0, g[N], nig[N];

int ipow(int a, int b) {
	int r = 1, w = a;
	while (b) {
		if (b & 1) r = 1ll * r * w % p;
		w = 1ll * w * w % p;
		b >>= 1;
	}
	return r;
}

void Euler_shai() {
	mu[1] = 1;
	for (int i = 2; i <= 1000000; ++i) {
		if (!notp[i]) {
			prime[++num] = i;
			mu[i] = -1;
		}

		for (int j = 1, cj; j <= num && (cj = prime[j] * i) <= 1000000; ++j) {
			notp[cj] = true;
			if (i % prime[j] == 0) {
				mu[cj] = 0;
				break;
			}
			mu[cj] = -mu[i];
		}
	}

	for (int i = 0; i <= 1000000; ++i) g[i] = nig[i] = 1;
}

int Fib[N], niFib[N];

int solve(int n, int m) {
	int ret = 1;
	for (int ri, T = 1; T <= n; ++T) {
		ri = min(n / (n / T), m / (m / T));
		ret = 1ll * ret * ipow(1ll * g[ri] * nig[T - 1] % p, 1ll * (n / T) * (m / T) % (p - 1)) % p;
		T = ri;
	}
	return ret;
}

int main() {
	freopen("product.in", "r", stdin);
	freopen("product.out", "w", stdout);

	Euler_shai();

	Fib[0] = 0; Fib[1] = 1; niFib[1] = niFib[0] = 1;
	for (int i = 2; i <= 1000000; ++i) {
		Fib[i] = (Fib[i - 1] + Fib[i - 2]) % p;
		niFib[i] = ipow(Fib[i], p - 2);
	}

	for (int i = 1; i <= 1000000; ++i)
		for (int j = i; j <= 1000000; j += i)
			if (mu[j / i] == 1) {
				g[j] = 1ll * g[j] * Fib[i] % p;
				nig[j] = 1ll * nig[j] * niFib[i] % p;
			} else if (mu[j / i] == -1) {
				g[j] = 1ll * g[j] * niFib[i] % p;
				nig[j] = 1ll * nig[j] * Fib[i] % p;
			}

	for (int i = 2; i <= 1000000; ++i) {
		g[i] = 1ll * g[i] * g[i - 1] % p;
		nig[i] = 1ll * nig[i] * nig[i - 1] % p;
	}

	int T, n, m; scanf("%d", &T);
	while (T--) {
		scanf("%d%d", &n, &m);
		if (n > m) n ^= m ^= n ^= m;
		printf("%d\n", solve(n, m));
	}

	return 0;
}

T2 树点涂色

---

题目大意

· 根为1的有根树上初始每个节点都有不同颜色，一条路径的权值为这条路径上点的不同颜色数。

· 修改：把x到根这条链上所有点都涂上一种之前从没出现过的颜色。

· 查询：链的权值和子树内一点到根的路径的权值的最大值。

· \(n\leq10^5,m\leq10^5\)

思路

· 把具有相同颜色的链看成重链，那么重链上相邻的点只可能是父子关系，不可能是兄弟关系。

· 线段树维护dfs序，每个节点维护这个区间内所有点到根路径的权值的最大值，链的权值可以两个端点和lca差分一下求出，子树内一点到根的权值的最大值直接在线段树上查询子树的dfs序区间内的最大值。

· 修改操作类似lct的access操作，每次修改x点，相当于把x到根的这条路径变成重链，同时要相应的断掉以前的一些重链。在重链和轻链变换的时候顺便在线段树上修改即可。

· 时间复杂度\(O(m\log^2n)\)。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 100003;

int n, deep[N], pos[N];

void check_max(int &a, int b) {if (b > a) a = b;}

namespace SegmentTree {
	int ma[N << 2], lazy[N << 2];
	void BuildTree(int rt, int l, int r) {
		if (l == r) {ma[rt] = deep[pos[l]]; return;}
		int mid = (l + r) >> 1;
		BuildTree(rt << 1, l, mid);
		BuildTree(rt << 1 | 1, mid + 1, r);
		ma[rt] = max(ma[rt << 1], ma[rt << 1 | 1]);
	}

	void pushdown(int rt) {
		if (lazy[rt]) {
			int num = lazy[rt];
			lazy[rt << 1] += num;
			ma[rt << 1] += num;
			lazy[rt << 1 | 1] += num;
			ma[rt << 1 | 1] += num;
			lazy[rt] = 0;
		}
	}

	void add(int rt, int l, int r, int L, int R, int num) {
		if (L <= l && r <= R) {lazy[rt] += num; ma[rt] += num; return;}
		int mid = (l + r) >> 1;
		pushdown(rt);
		if (L <= mid) add(rt << 1, l, mid, L, R, num);
		if (R > mid) add(rt << 1 | 1, mid + 1, r, L, R, num);
		ma[rt] = max(ma[rt << 1], ma[rt << 1 | 1]);
	}

	int query(int rt, int l, int r, int L, int R) {
		if (L <= l && r <= R) return ma[rt];
		int mid = (l + r) >> 1, s = 0;
		pushdown(rt);
		if (L <= mid) check_max(s, query(rt << 1, l, mid, L, R));
		if (R > mid) check_max(s, query(rt << 1 | 1, mid + 1, r, L, R));
		return s;
	}
}

struct Enode {int nxt, to;} E[N << 1];
int cnt = 0, point[N], st[N], top;

void ins(int u, int v) {E[++cnt] = (Enode) {point[u], v}; point[u] = cnt;}

int m, L[N], R[N], dfsID = 0, sz[N], fath[N];
bool used[N];

void dfs() {
	st[top = 1] = 1; deep[1] = 1;
	while (top) {
		int u = st[top];
		if (!used[u]) {
			L[u] = ++dfsID; pos[dfsID] = u;
			for (int i = point[u]; i; i = E[i].nxt)
				if (E[i].to != fath[u]) {
					st[++top] = E[i].to;
					fath[E[i].to] = u;
					deep[E[i].to] = deep[u] + 1;
				}
			used[u] = true;
		} else {
			for (int i = point[u]; i; i = E[i].nxt)
				if (E[i].to != fath[u])
					sz[u] += sz[E[i].to];
			R[u] = L[u] + sz[u];
			++sz[u];
			--top;
		}
	}
}

namespace LCT {
	struct node *null;
	struct node {
		node *ch[2], *fa; int id, mn;
		void setc(node *r, int c) {ch[c] = r; if (r != null) r->fa = this;}
		bool pl() {return fa->ch[1] == this;}
		bool check() {return fa == null || (fa->ch[0] != this && fa->ch[1] != this);}
		void count() {
			mn = id;
			if (ch[0] != null) if (L[ch[0]->mn] < L[mn]) mn = ch[0]->mn;
			if (ch[1] != null) if (L[ch[1]->mn] < L[mn]) mn = ch[1]->mn;
		}
	} pool[N];

	void init() {
		null = &pool[0]; null->ch[0] = null->ch[1] = null->fa = null;
		node *t;
		for (int i = 1; i <= n; ++i) {
			t = pool + i; t->id = t->mn = i;
			t->ch[0] = t->ch[1] = null;
			t->fa = &pool[fath[i]];
		}
	}

	void rotate(node *r) {
		node *f = r->fa;
		int c = r->pl();
		if (f->check()) r->fa = f->fa;
		else f->fa->setc(r, f->pl());
		f->setc(r->ch[c ^ 1], c);
		r->setc(f, c ^ 1);
		f->count();
	}

	void splay(node *r) {
		for (; !r->check(); rotate(r))
			if (!r->fa->check()) rotate(r->pl() == r->fa->pl() ? r->fa : r);
		r->count();
	}

	void access(node *r) {
		node *y = null;
		while (r != null) {
			splay(r);
			if (r->ch[1] != null) SegmentTree::add(1, 1, n, L[r->ch[1]->mn], R[r->ch[1]->mn], 1);
			r->ch[1] = y; r->count();
			if (y != null) SegmentTree::add(1, 1, n, L[y->mn], R[y->mn], -1);
			y = r; r = r->fa;
		}
	}
}

int F[N][18];

int work(int x, int y) {
	if (deep[x] < deep[y]) x ^= y ^= x ^= y;
	int xx = x, yy = y;
	for (int i = 17; i >= 0; --i)
		if (deep[F[x][i]] >= deep[y])
			x = F[x][i];

	if (x == y)	return SegmentTree::query(1, 1, n, L[xx], L[xx]) - SegmentTree::query(1, 1, n, L[x], L[x]) + 1;

	for (int i = 17; i >= 0; --i)
		if (F[x][i] != F[y][i])
			x = F[x][i], y = F[y][i];

	int numx, numy, numz;
	int ret = SegmentTree::query(1, 1, n, L[xx], L[xx]) - (numx = SegmentTree::query(1, 1, n, L[x], L[x])) + 1
	+ SegmentTree::query(1, 1, n, L[yy], L[yy]) - (numy = SegmentTree::query(1, 1, n, L[y], L[y])) + 1;

	numz = SegmentTree::query(1, 1, n, L[fath[x]], L[fath[x]]);
	if (numz != numx && numz != numy) ++ret;
	return ret;
}

int main() {
	freopen("paint.in", "r", stdin);
	freopen("paint.out", "w", stdout);
	scanf("%d%d", &n, &m);
	int u, v;
	for (int i = 1; i < n; ++i) {
		scanf("%d%d", &u, &v);
		ins(u, v); ins(v, u);
	}

	dfs();
	SegmentTree::BuildTree(1, 1, n);
	LCT::init();

	for (int i = 1; i <= n; ++i) F[i][0] = fath[i];
	for (int j = 1; j <= 17; ++j)
		for (int i = 1; i <= n; ++i)
			F[i][j] = F[F[i][j - 1]][j - 1];

	int x, y, op;
	while (m--) {
		scanf("%d%d", &op, &x);
		if (op == 2) scanf("%d", &y);
		switch (op) {
			case 1:
				LCT::access(&LCT::pool[x]);
			break;
			case 2:
				printf("%d\n", work(x, y));
			break;
			case 3:
				printf("%d\n", SegmentTree::query(1, 1, n, L[x], R[x]));
			break;
		}

//		for (int i = 1; i <= n; ++i) printf("%d ", SegmentTree::query(1, 1, n, L[i], L[i])); puts("");
	}

	return 0;
}

T3 序列计数

---

题目大意

· 长度为\(n\)的序列，满足序列中的数都是不大于\(m\)的正整数，\(n\)个数的和是\(p\)的倍数，而且这\(n\)个数中至少有一个是质数。

· 求满足条件的序列的个数。

· \(1\leq n\leq 10^9,1\leq m \leq 2\times 10^7,1\leq p \leq 100\)

思路

· 容斥一下，在满足前两个条件的情况下，统计\(n\)个数无质数限制的序列个数再减去\(n\)个数都不是质数的序列个数。

· 设\(f(i,j)\)表示长度为\(i\)，和模\(p\)为\(j\)的序列个数。

· 提前预处理模\(p\)为\(j\)有多少个数，即\(f(1,j)\)。欧拉筛求出\(m\)以内的质数。

· \(f(i,j)=\sum\limits_{k,l}[(k+l)\mod p=j]f(i-1,k)\times f(1,l)\)

· dp可以用倍增优化，时间复杂度\(O\left(m+p^2\log n\right)\)。

· 当然矩乘也是可以的。

#include<cstdio>
#include<bitset>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;

const int N = 20000003;
const int mo = 20170408;

int f[103], g[103], F[103], n, m, p;
int nump = 0, prime[1270608];
bitset <N> notp;

void Euler_shai() {
	notp[1] = 1;
	for (int i = 2; i <= m; ++i) {
		if (!notp[i]) prime[++nump] = i;
		for (int j = 1; j <= nump && prime[j] * i <= m; ++j) {
			notp[prime[j] * i] = 1;
			if (i % prime[j] == 0) break;
		}
	}
}

int main() {
	freopen("count.in", "r", stdin);
	freopen("count.out", "w", stdout);

	scanf("%d%d%d", &n, &m, &p);

	int num = n, tot = 0;
	while (num) {num >>= 1; ++tot;}
	for (int i = 1; i <= m; ++i) ++f[i % p];
	for (int i = 0; i < p; ++i) F[i] = (f[i] %= mo);
	for (int i = tot - 2; i >= 0; --i) {
		memset(g, 0, p << 2);
		for (int j = 0; j < p; ++j)
			for (int k = 0; k < p; ++k)
				(g[(j + k) % p] += 1ll * f[j] * f[k] % mo) %= mo;
		memcpy(f, g, p << 2);

		if ((n >> i) & 1) {
			memset(g, 0, p << 2);
			for (int j = 0; j < p; ++j)
				for (int k = 0; k < p; ++k)
					(g[(j + k) % p] += 1ll * f[j] * F[k] % mo) %= mo;
			memcpy(f, g, p << 2);
		}
	}

	int ans = f[0];

	Euler_shai();
	memset(f, 0, p << 2); memset(F, 0, p << 2);
	for (int i = 1; i <= m; ++i) if (notp[i]) ++f[i % p];
	for (int i = 0; i < p; ++i) F[i] = (f[i] %= mo);
	for (int i = tot - 2; i >= 0; --i) {
		memset(g, 0, p << 2);
		for (int j = 0; j < p; ++j)
			for (int k = 0; k < p; ++k)
				(g[(j + k) % p] += 1ll * f[j] * f[k] % mo) %= mo;
		memcpy(f, g, p << 2);

		if ((n >> i) & 1) {
			memset(g, 0, p << 2);
			for (int j = 0; j < p; ++j)
				for (int k = 0; k < p; ++k)
					(g[(j + k) % p] += 1ll * f[j] * F[k] % mo) %= mo;
			memcpy(f, g, p << 2);
		}
	}

	printf("%d\n", (ans - f[0] + mo) % mo);
	return 0;
}

Day 2

T1 新生舞会

---

题目大意

· \(n\)个男生和\(n\)个女生组成舞伴，第\(i\)个男生和第\(j\)个女生组成舞伴会产生\(a_{ij}\)的喜悦程度和\(b_{ij}\)的不协调程度。

· 有\(n\)个喜悦程度\(a_1',a_2',\dots a_n'\)和不协调程度\(b_1',b_2',\dots b_n'\)，最大化\(C=\frac{a_1'+a_2'+\dots+a_n'}{b_1'+b_2'+\dots+b_n'}\)

· \(1\leq n\leq 100,1\leq a_{ij},b_{ij}\leq 10^4\)，保留6位小数。

思路

· 分数规划，把分母乘到左边， 左边再移向到右边，二分\(C\)的值，通过移项后的式子的最大值来判断\(C\)偏大还是偏小。

· 移项后的式子的最大值可以用最大费用最大流来计算。

· 用数组存边比结构体快一倍！！！

· 把实数乘\(10^7\)变成整数可以减小常数。

· 时间复杂度\(O\left(n^2\sqrt n\log 10^{12}\right)\)。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;

int in() {
	int k = 0; char c = getchar();
	for (; c < '0' || c > '9'; c = getchar());
	for (; c >= '0' && c <= '9'; c = getchar())
		k = k * 10 + (c ^ 48);
	return k;
}

const int N = 103;

int b[N][N], n, S, T;
ll a[N][N], w[N * N * 3];
int nxt[N * N * 3], to[N * N * 3], c[N * N * 3], cnt, point[N << 1];

void ins(int u, int v, int C, ll W) {
	++cnt; nxt[cnt] = point[u]; to[cnt] = v; c[cnt] = C; w[cnt] = W; point[u] = cnt;
	++cnt; nxt[cnt] = point[v]; to[cnt] = u; c[cnt] = 0; w[cnt] = -W; point[v] = cnt;
}

bool inq[N << 1];
ll dis[N << 1];
int qu[100000], pre[N << 1];

bool spfa() {
	memset(dis, 0xc0, (T + 1) << 3);
	int p = 0, q = 1, v;
	ll t;
	qu[1] = S; dis[S] = 0; inq[S] = true;
	while (p != q) {
		++p; if (p == 100000) p = 0;
		int u = qu[p]; inq[u] = false;
		for (int i = point[u]; i; i = nxt[i])
			if (c[i] && (t = dis[u] + w[i]) > dis[v = to[i]]) {
				pre[v] = i;
				dis[v] = t;
				if (!inq[v]) {
					++q; if (q == 100000) q = 0;
					qu[q] = v;
					inq[v] = true;
				}
			}
	}
	return dis[T] != dis[0];
}

ll mcmf(ll C) {
	cnt = 1; memset(point, 0, (T + 1) << 2);
	for (int i = 1; i <= n; ++i) {
		ins(S, i, 1, 0), ins(i + n, T, 1, 0);
		ll *ta = a[i]; int *tb = b[i];
		for (int j = 1; j <= n; ++j) {
			++ta; ++tb;
			ins(i, j + n, 1, *ta - C * *tb);
		}
	}

	ll f = 0;
	while (spfa()) {
		int u = T, e;
		for (u = T, e = pre[u]; u != S; e = pre[u = to[e ^ 1]]) --c[e], ++c[e ^ 1];
		f += dis[T];
	}
	return f;
}

int main() {
	freopen("ball.in", "r", stdin);
	freopen("ball.out", "w", stdout);
	n = in();
	for (int i = 1; i <= n; ++i)
		for (int j = 1; j <= n; ++j)
			a[i][j] = in(), a[i][j] *= 10000000ll;
	for (int i = 1; i <= n; ++i)
		for (int j = 1; j <= n; ++j)
			b[i][j] = in();

	S = (n << 1) + 1; T = S + 1;
	ll left, right, s1 = 0, s2 = 0;
	for (int i = 1; i <= n; ++i)
		s1 += a[i][i], s2 += b[i][i];
	left = s1 / s2 + 1;
	s1 = 0; s2 = 0;
	ll mx;
	for (int i = 1; i <= n; ++i) {
		mx = 0;
		for (int j = 1; j <= n; ++j)
			if (a[i][j] > mx)
				mx = a[i][j];
		s1 += mx;
		mx = 0x7fffffff;
		for (int j = 1; j <= n; ++j)
			if (b[i][j] < mx)
				mx = b[i][j];
		s2 += mx;
	}
	right = s1 / s2;

	ll mid;
	while (left < right) {
		mid = (left + right + 1) >> 1;
		if (mcmf(mid) >= 0) left = mid;
		else right = mid - 1;
	}
	if (left % 10 >= 5) left += 10; left /= 10;
	printf("%I64d.%06I64d\n", left / 1000000, left % 1000000);
	return 0;
}

T2 硬币游戏

---

题目大意

· \(n\)个同学每个同学猜一个长度为\(m\)的HT序列（H表示正面朝上，T表示反面朝上）

· 不断地扔硬币，组成一个HT序列。当某个同学的猜的序列突然出现在扔出来的硬币序列中，则停止扔硬币并且这个同学获胜。

· 问每个同学获胜的概率是多少。

· \(1\leq n,m\leq 300\)

思路

· 这道题我想了一整天，最后问了zyf2000才知道怎么做。

· 某个同学猜的序列在硬币序列中出现的位置肯定是最后。

· 首先设\(f(i,j)\)表示长度为\(i\)的硬币序列，只有第\(i\)个位置和\(m\)个序列中某一个序列匹配，并且这个匹配的序列是第\(j\)个序列的概率。

· 那么第\(i\)个同学获胜的概率就是\(\sum\limits_{j\geq 1}f(j,i)\)

· 设\(N\)表示没有扔出来和同学猜的序列匹配的硬币序列的概率，这个\(N\)有点抽象，更具体的：\(N=\sum\limits_{j\geq 1}\left(1-\sum\limits_{k=1}^nf(j,k)\right)\)

· 然后假设A同学猜的序列是TTH，B同学猜的序列是HTT，那么可以构造一个以TTH结尾的硬币序列，并且1到序列长度-3的所有位置都不是能匹配A或B的位置，所以匹配位置只可能是序列长度-2

，序列长度-1或序列长度（即最后一个位置）

· 这样就有一个等式了：P(NTTH)=P(A)+P(BTH)+P(BH)

· 很明显吧，如果一个序列的前缀是另一个序列的后缀，那么就会产生贡献。

· 所有同学获胜的概率和为1，\(n+1\)个变元，\(n+1\)个等式，高斯消元即可。

· 时间复杂度\(O(n^3)\)。

#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 703;

int cnt;
double a[N][N], f[N];

void gauss() {
	for (int i = 1; i <= cnt; ++i) {
		int tmp = i;
		for (int j = i + 1; j <= cnt; ++j)
			if (fabs(a[j][i]) > fabs(a[tmp][i]))
				tmp = j;
		if (tmp != i)
			for (int j = i; j <= cnt + 1; ++j)
				swap(a[i][j], a[tmp][j]);

		for (int j = i + 1; j <= cnt; ++j)
			if (a[j][i] != 0) {
				double k = a[j][i] / a[i][i];
				for (int t = i; t <= cnt + 1; ++t)
					a[j][t] -= a[i][t] * k;
			}
	}

	for (int i = cnt; i >= 1; --i) {
		for (int j = i + 1; j <= cnt; ++j)
			a[i][cnt + 1] -= a[i][j] * f[j];
		f[i] = a[i][cnt + 1] / a[i][i];
	}
}

int end[N];
double fac[N];
int n, m, Acnt = 1, ch[N * N][2], fail[N * N], qu[N * N], deep[N * N], to[N * N];
char s[N];

void insert(int id) {
	int tmp = 1;
	for (int i = 1; i <= m; ++i) {
		int v = s[i] == 'H' ? 0 : 1;
		if (ch[tmp][v] == 0) ch[tmp][v] = ++Acnt;
		tmp = ch[tmp][v];
	}
	end[id] = tmp; to[tmp] = id;
}

int dfsID = 0, L[N * N], R[N * N], dfs_a[N * N];
void dfs(int x) {
	L[x] = ++dfsID;
	if (to[x])
		dfs_a[dfsID] = to[x];
	else {
		if (ch[x][0]) dfs(ch[x][0]);
		if (ch[x][1]) dfs(ch[x][1]);
	}
	R[x] = dfsID;
}

void BuildFail() {
	int p = 0, q = 1; qu[1] = 1;
	while (p != q) {
		int u = qu[++p];
		for (int i = 0; i <= 1; ++i)
			if (ch[u][i]) {
				int p = fail[u];
				while (p && ch[p][i] == 0) p = fail[p];
				fail[ch[u][i]] = p ? ch[p][i] : 1;
				deep[ch[u][i]] = deep[u] + 1;
				qu[++q] = ch[u][i];
			}
	}

	dfs(1);
}

void Jump(int id) {
	int p = fail[end[id]];
	while (p != 1) {
		for (int i = L[p]; i <= R[p]; ++i)
			if (dfs_a[i])
				a[dfs_a[i]][id] += fac[m - deep[p]];
		p = fail[p];
	}
}

int main() {
	freopen("game.in", "r", stdin);
	freopen("game.out", "w", stdout);
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; ++i) {
		scanf("%s", s + 1);
		insert(i);
	}

	fac[0] = 1;
	for (int i = 1; i <= m; ++i) fac[i] = fac[i - 1] / 2;

	BuildFail();

	cnt = n + 1;
	for (int i = 1; i <= n; ++i) {
		a[i][i] = 1; a[i][cnt] = -1;
		Jump(i);
	}
	for (int i = 1; i <= n; ++i) a[cnt][i] = 1;
	a[cnt][cnt + 1] = 1;

	gauss();
	for (int i = 1; i <= n; ++i) printf("%.10lf\n", f[i]);

	return 0;
}

T3 相关分析

---

题目大意

· \(n\)个二元组\((x,y)\)构成一个序列。

· 修改\([L,R],S,T\)：区间内所有二元组的\(x\)都加上\(S\)，\(y\)都加上\(T\)。

· 修改\([L,R],S,T\)：区间内所有二元组的\(x\)都变为\(S+i\)，\(y\)都变为\(T+i\)，\(i\)为二元组的下标。

· 查询\([L,R]\)：计算\(\frac{\sum\limits_{i=L}^R(x_i-\bar x)(y_i-\bar y)}{\sum\limits_{i=L}^R(x_i-\bar x)^2}\)

· \(1\leq n,m\leq10^5,1\leq L\leq R\leq n,0\leq|S|,|T|\leq10^5,0\leq|x_i|,|y_i|\leq10^5\)

思路

· 线段树维护4个信息:\(\sum x_i,\sum y_i,\sum x_i^2,\sum x_iy_i\)

· 把要计算的式子全拆开，所需要的信息就是上面的4个信息。

· 区间加：\(\sum (x_i+S)^2=\sum(x_i^2+2Sx_i+S^2),\sum (x_i+S)(y_i+T)=\sum(x_iy_i+Tx_i+Sy_i+ST)\)

· 区间覆盖：\(\sum x_i^2\)可以用平方和公式\(\frac {n(n+1)(2n+1)}6\)计算（直接预处理平方和可以减小常数），\(\sum x_iy_i\)同理。

· 维护一个区间加标记和区间覆盖标记就可以了。

· 时间复杂度\(O(m\log n)\)。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;

int in() {
	int k = 0, fh = 1; char c = getchar();
	for (; c < '0' || c > '9'; c = getchar())
		if (c == '-') fh = -1;
	for (; c >= '0' && c <= '9'; c = getchar())
		k = k * 10 + (c ^ 48);
	return k * fh;
}

const int N = 100003;

int n, m, len;
double x[N], y[N], xl, yl;

struct PP {
	double sumx, sumy, sumxx, sumxy;
	PP (double _sumx = 0, double _sumy = 0, double _sumxx = 0, double _sumxy = 0)
		: sumx(_sumx), sumy(_sumy), sumxx(_sumxx), sumxy(_sumxy) {}
	PP operator + (const PP &A) const {
		return PP(sumx + A.sumx, sumy + A.sumy, sumxx + A.sumxx, sumxy + A.sumxy);
	}
};

namespace ST {
	double sum_x[N << 2], sum_y[N << 2], sum_xy[N << 2], sum_xx[N << 2], lazy_x[N << 2], lazy_y[N << 2];
	double cover_x[N << 2], cover_y[N << 2];
	bool cover_mark[N << 2];

	ll getsum(int l, int r) {
		return (1ll * r * (r + 1) * ((r << 1) + 1) - 1ll * (l - 1) * l * (((l - 1) << 1) + 1)) / 6;
	}

	void coverit(int rt, int l, int r, const double &S, const double &T) {
		lazy_x[rt] = lazy_y[rt] = 0;
		cover_x[rt] = S; cover_y[rt] = T; cover_mark[rt] = true;
		len = r - l + 1;
		sum_x[rt] = (S + l + S + r) * len / 2;
		sum_y[rt] = (T + l + T + r) * len / 2;
		sum_xx[rt] = getsum(S + l, S + r);
		sum_xy[rt] = S * T * len + (S + T) * (1ll * (l + r) * len / 2) + getsum(l, r);
	}

	double Slen, Tlen;
	void update(int rt, int l, int r, const double &S, const double &T) {
		if (cover_mark[rt]) {
			if (l != r) {
				int mid = (l + r) >> 1;
				coverit(rt << 1, l, mid, cover_x[rt], cover_y[rt]);
				coverit(rt << 1 | 1, mid + 1, r, cover_x[rt], cover_y[rt]);
			}
			cover_mark[rt] = false;
		}
		lazy_x[rt] += S; lazy_y[rt] += T;
		len = r - l + 1; Slen = S * len; Tlen = T * len;
		sum_xx[rt] += S * 2 * sum_x[rt] + S * Slen;
		sum_xy[rt] += sum_x[rt] * T + sum_y[rt] * S + S * Tlen;
		sum_x[rt] += Slen;
		sum_y[rt] += Tlen;
	}

	void pushdown(int rt, int l, int r) {
		if (lazy_x[rt] || lazy_y[rt]) {
			int mid = (l + r) >> 1;
			update(rt << 1, l, mid, lazy_x[rt], lazy_y[rt]);
			update(rt << 1 | 1, mid + 1, r, lazy_x[rt], lazy_y[rt]);
			lazy_x[rt] = lazy_y[rt] = 0;
		}
		if (cover_mark[rt]) {
			int mid = (l + r) >> 1;
			coverit(rt << 1, l, mid, cover_x[rt], cover_y[rt]);
			coverit(rt << 1 | 1, mid + 1,r, cover_x[rt], cover_y[rt]);
			cover_mark[rt] = false;
		}
	}

	void pushup(int rt) {
		sum_x[rt] = sum_x[rt << 1] + sum_x[rt << 1 | 1];
		sum_y[rt] = sum_y[rt << 1] + sum_y[rt << 1 | 1];
		sum_xx[rt] = sum_xx[rt << 1] + sum_xx[rt << 1 | 1];
		sum_xy[rt] = sum_xy[rt << 1] + sum_xy[rt << 1 | 1];
	}

	void build(int rt, int l, int r) {
		if (l == r) {
			xl = x[l]; yl = y[l];
			sum_x[rt] = xl; sum_y[rt] = yl;
			sum_xx[rt] = xl * xl;
			sum_xy[rt] = xl * yl;
			cover_mark[rt] = false;
			return;
		}
		int mid = (l + r) >> 1;
		build(rt << 1, l, mid);
		build(rt << 1 | 1, mid + 1, r);
		pushup(rt);
	}

	void add(int rt, int l, int r, int L, int R, const double &S, const double &T) {
		if (L <= l && r <= R) {
			update(rt, l, r, S, T);
			return;
		}
		int mid = (l + r) >> 1;
		pushdown(rt, l, r);
		if (L <= mid) add(rt << 1, l, mid, L, R, S, T);
		if (R > mid) add(rt << 1 | 1, mid + 1, r, L, R, S, T);
		pushup(rt);
	}

	void cover(int rt, int l, int r, int L, int R, const double &S, const double &T) {
		if (L <= l && r <= R) {
			coverit(rt, l, r, S, T);
			return;
		}
		int mid = (l + r) >> 1;
		pushdown(rt, l, r);
		if (L <= mid) cover(rt << 1, l, mid, L, R, S, T);
		if (R > mid) cover(rt << 1 | 1, mid + 1, r, L, R, S, T);
		pushup(rt);
	}

	PP getans(int rt, int l, int r, int L, int R) {
		if (L <= l && r <= R) return PP(sum_x[rt], sum_y[rt], sum_xx[rt], sum_xy[rt]);
		PP tl, tr;
		int mid = (l + r) >> 1;
		pushdown(rt, l, r);
		if (L <= mid) tl = getans(rt << 1, l, mid, L, R);
		if (R > mid) tr = getans(rt << 1 | 1, mid + 1, r, L, R);
		return tl + tr;
	}
}

int main() {
	freopen("relative.in", "r", stdin);
	freopen("relative.out", "w", stdout);

	n = in(); m = in(); //scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; ++i) scanf("%lf", x + i);
	for (int i = 1; i <= n; ++i) scanf("%lf", y + i);
	ST::build(1, 1, n);

	int L, R, op; double S, T, xb, yb, fz, fm;
	PP r;
	while (m--) {
		op = in(); //scanf("%d", &op);
		if (op == 1) {
			L = in(); R = in();//scanf("%d%d", &L, &R);
			r = ST::getans(1, 1, n, L, R);
			xb = r.sumx / (R - L + 1);
			yb = r.sumy / (R - L + 1);
			fz = r.sumxy - r.sumy * xb - r.sumx * yb + xb * yb * (R - L + 1);
			fm = r.sumxx - r.sumx * 2 * xb + xb * xb * (R - L + 1);
			printf("%.10lf\n", fz / fm);
		} else if (op == 2) {
			L = in(); R = in();
			scanf("%lf%lf", &S, &T);
			ST::add(1, 1, n, L, R, S, T);
		} else {
			L = in(); R = in();
			scanf("%lf%lf", &S, &T);
			ST::cover(1, 1, n, L, R, S, T);
		}
		/*
		for (int i = 1; i <= n; ++i) {
			PP r = ST::getans(1, 1, n, i, i);
			printf("(%.3lf, %.3lf) ", r.sumx, r.sumy);
		}
		puts("");*/
	}
	return 0;
}