AtCoder Grand Contest 037 简要题解

从这里开始

• 题目目录

Problem A Dividing a String

　　猜想每段长度不超过2。然后dp即可。

　　考虑最后一个长度大于等于3的一段，如果划成$1 + 2$会和后面相同，那么划成$2 + 1$，如果前一段和前面相同，那么把前一段和前面合并。每次操作后段数都不会减少。所以存在一种最优方案使得每段长度不超过2。

Code

#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;

const int N = 2e5 + 5;

template <typename T>
void vmax(T& a, T b) {
	(a < b) && (a = b, 0);
}

int n;
char s[N];
int f[N][2];

int main() {
	scanf("%s", s + 1);
	f[0][0] = 0, f[0][1] = -1e9;
	n = strlen(s + 1);
	for (int i = 1; i <= n; i++) {
		f[i][0] = f[i][1] = -1e9;
		vmax(f[i][0], f[i - 1][1] + 1);
		if (s[i] != s[i - 1])
			vmax(f[i][0], f[i - 1][0] + 1);
		if (i > 1) {
			vmax(f[i][1], f[i - 2][0] + 1);
			if (i > 3 && (s[i] != s[i - 2] || s[i - 1] != s[i - 3])) {
				vmax(f[i][1], f[i - 2][1] + 1);
			}
		}
	}
	printf("%d\n", max(f[n][0], f[n][1]));
	return 0;
}

Problem B RGB Balls

　　假设红绿蓝三种颜色的求按顺序排列后分别为 $r_1, r_2, \cdots, r_n, g_1, g_2, \cdots, g_n, b_1, b_2, \cdots, b_n$。

　　设$m_i = \min\{r_i, b_i, g_i\}, M_i = \max\{r_i, b_i, g_i\}$。猜想答案是$\sum M_i - m_i$。

　　假设每个人拿到的最小标号的球标号递增，证明考虑前$k$个人至多选择前$k$个红球，白球和蓝球，所以第$k + 1$个人拿到的最小标号的球的标号至少为$m_{k + 1}$，所以$m_i$是第$i$个人拿到的最小标号的球的上界。同理可以证明第$i$个人拿到的最大标号的球的下界是$M_i$。

　　然后根据一种球的类型来贪心就行了。

Code

#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;

#define ll long long

void exgcd(int a, int b, int& x, int& y) {
	if (!b) {
		x = 1, y = 0;
	} else {
		exgcd(b, a % b, y, x);
		y -= (a / b) * x;
	}
}

int inv(int a, int n) {
	int x, y;
	exgcd(a, n, x, y);
	return (x < 0) ? (x + n) : (x);
}

const int Mod = 998244353;

template <const int Mod = :: Mod>
class Z {
	public:
		int v;

		Z() : v(0) {	}
		Z(int x) : v(x){	}
		Z(ll x) : v(x % Mod) {	}

		friend Z operator + (const Z& a, const Z& b) {
			int x;
			return Z(((x = a.v + b.v) >= Mod) ? (x - Mod) : (x));
		}
		friend Z operator - (const Z& a, const Z& b) {
			int x;
			return Z(((x = a.v - b.v) < 0) ? (x + Mod) : (x));
		}
		friend Z operator * (const Z& a, const Z& b) {
			return Z(a.v * 1ll * b.v);
		}
		friend Z operator ~(const Z& a) {
			return inv(a.v, Mod);
		}
		friend Z operator - (const Z& a) {
			return Z(0) - a;
		}
		Z& operator += (Z b) {
			return *this = *this + b;
		}
		Z& operator -= (Z b) {
			return *this = *this - b;
		}
		Z& operator *= (Z b) {
			return *this = *this * b;
		}
		friend boolean operator == (const Z& a, const Z& b) {
			return a.v == b.v;
		}
};

Z<> qpow(Z<> a, int p) {
	Z<> rt = Z<>(1), pa = a;
	for ( ; p; p >>= 1, pa = pa * pa) {
		if (p & 1) {
			rt = rt * pa;
		}
	}
	return rt;
}

typedef Z<> Zi;

const int N = 1e5 + 5;

int n;
char s[N * 3];

int main() {
	scanf("%d", &n);
	scanf("%s", s + 1);
	int r, g, b, rg, rb, gb;
	r = g = b = 0;
	rg = rb = gb = 0;
	Zi ans = 1;
	for (int i = 1; i <= n; i++)
		ans *= i;
	for (int i = 1; i <= 3 * n; i++) {
		if (s[i] == 'R') {
			if (gb) {
				ans *= gb--;
			} else if (g) {
				ans *= g--;
				rg++;
			} else if (b) {
				ans *= b--;
				rb++;
			} else {
				r++;
			}
		} else if (s[i] == 'G') {
			if (rb) {
				ans *= rb--;
			} else if (r) {
				ans *= r--;
				rg++;
			} else if (b) {
				ans *= b--;
				gb++;
			} else {
				g++;
			}
		} else if (s[i] == 'B') {
			if (rg) {
				ans *= rg--;
			} else if (r) {
				ans *= r--;
				rb++;
			} else if (g) {
				ans *= g--;
				gb++;
			} else {
				b++;
			}
		}
	}
	printf("%d\n", ans.v);
	return 0;
}

Problem C Numbers on a Circle

　　考虑倒着做，操作变成一个数减去两边的和，如果一个数可以操作，那么它两边的数都不能操作。所以要么它达到它目标的值，要么它比两边的数小。

　　不难发现操作1次，要么折半，要么达到目标的值，要么判出无解，所以总时间复杂度$O(n\log V)$。

Code

#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;

const int N = 2e5 + 5;

int n;
int A[N];
int B[N];
boolean inq[N];

boolean check(int p) {
	return B[p] >= B[(p + n - 1) % n] + B[(p + 1) % n];
}

int main() {
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", A + i);
	}
	for (int i = 0; i < n; i++) {
		scanf("%d", B + i);
	}
	queue<int> Q;
	for (int i = 0; i < n; i++) {
		if (check(i)) {
			inq[i] = true;
			Q.push(i);
		}
	}
	long long ans = 0;
	while (!Q.empty()) {
		int p = Q.front();
		Q.pop();
		inq[p] = false;
		int pre = (p + n - 1) % n, suf = (p + 1) % n;
		int sum = B[pre] + B[suf];
		int t = max(0, (B[p] - A[p]) / sum);
		if (!t && B[p] != A[p]) {
			puts("-1");
			return 0;
		}
		ans += t;
		B[p] -= sum * t;
		if (!inq[pre] && check(pre)) {
			inq[pre] = true;
			Q.push(pre);
		}
		if (!inq[suf] && check(suf)) {
			inq[suf] = true;
			Q.push(suf);
		}
	}
	for (int i = 0; i < n; i++) {
		if (A[i] ^ B[i]) {
			puts("-1");
			return 0;
		}
	}
	printf("%lld\n", ans);
	return 0;
}

Problem D Sorting a Grid

　　考虑第一次移动需要达到的条件：属于目标同一行的数不在同一列。

　　问题相当于给这样一个图染色：有$nm$个点，如果$(i,j)$和$(x, y)$有边相邻当且仅当它们属于同一行或者属于目标同一行。

　　它所在的颜色标号等于它被换到的列号。

　　考虑每次标出一种颜色。这个可以转成匹配问题，把原图的每个点看成边，两端点分别是它所在的两个团。

　　这是一个正则二分图，所以必定有解。

Code

#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;

const int inf = (signed) (~0u >> 1);

typedef class Edge {
	public:
		int ed, nx, r;

		Edge() {	}
		Edge(int ed, int nx, int r) : ed(ed), nx(nx), r(r) {	}
} Edge;

typedef class MapManager {
	public:
		int *h;
		vector<Edge> E;

		MapManager() {	}
		MapManager(int n) {
			h = new int[(n + 1)];
			memset(h, -1, sizeof(int) * (n + 1));
		}
		~MapManager() {
			delete[] h;
			E.clear();
		}

		void add_edge(int u, int v, int r) {
			E.emplace_back(v, h[u], r);
			h[u] = (signed) E.size() - 1;
		}
		void add_arc(int u, int v, int r) {
			add_edge(u, v, r);
			add_edge(v, u, 0);
		}
		Edge& operator [] (int p) {
			return E[p];
		}
} MapManager;

typedef class Network {
	public:
		int S, T;
		MapManager g;

		int *d, *h;

		Network(int S, int T) : S(S), T(T), g(T) {
			d = new int[(T + 1)];
			h = new int[(T + 1)];
		}
		~Network() {
			delete[] d;
			delete[] h;
		}

		boolean bfs() {
			queue<int> Q;
			memset(d, -1, sizeof(int) * (T + 1));
			d[S] = 0;
			Q.push(S);
			while (!Q.empty()) {
				int e = Q.front();
				Q.pop();
				for (int i = g.h[e], eu; ~i; i = g[i].nx) {
					eu = g[i].ed;
					if (!g[i].r || ~d[eu])
						continue;
					d[eu] = d[e] + 1;
					Q.push(eu);
				}
			}
			return d[T] != -1;
		}

		int dfs(int p, int mf) {
			if (p == T || !mf)
				return mf;
			int flow = 0, f;
			for (int& i = h[p], j, e; ~i; (i != -1) && (i = g[i].nx)) {
				e = g[i].ed, j = i;
				if (g[i].r && d[e] == d[p] + 1 && (f = dfs(e, min(mf, g[i].r))) > 0) {
					g[j].r -= f;
					g[j ^ 1].r += f;
					flow += f;
					mf -= f;
					if (!mf)
						break;
				}
			}
			return flow;
		}

		int dinic() {
			int rt = 0;
			while (bfs()) {
				for (int i = 0; i <= T; i++)
					h[i] = g.h[i];
				rt += dfs(S, inf);
			}
			return rt;
		}

		void add_edge(int u, int v, int r) {
			g.add_arc(u, v, r);
		}
} Network;

const int N = 105;

int n, m;
int a[N][N];
int b[N][N];
int c[N][N];
int id[N][N];
int col[N][N];

int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			scanf("%d", a[i] + j);
		}
	}
	for (int c = 1, T; c <= m; c++) {
		Network	network (0, T = n + n + 1);
		for (int i = 1; i <= n; i++)
			network.add_edge(0, i, 1);
		for (int i = 1; i <= n; i++)
			network.add_edge(i + n, T, 1);
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= m; j++) {
				if (!col[i][j]) {
					network.add_edge(i, (a[i][j] + m - 1) / m + n, 1);
					id[i][j] = (signed) network.g.E.size() - 1;
				}
			}
		}
		network.dinic();
		MapManager& g = network.g;
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= m; j++) {
				if (!col[i][j] && g[id[i][j]].r) {
					col[i][j] = c;
				}
			}
		}
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			b[i][col[i][j]] = a[i][j];
		}
	}
	for (int i = 1; i <= n; i++, putchar('\n')) {
		for (int j = 1; j <= m; j++) {
			printf("%d ", b[i][j]);
			c[(b[i][j] + m - 1) / m][j] = b[i][j];
		}
	}
	for (int i = 1; i <= n; i++, putchar('\n')) {
		for (int j = 1; j <= m; j++) {
			printf("%d ", c[i][j]);
		}
	}
	return 0;
}

Problem E Reversing and Concatenating

　　假设最小的字符为a，如果末尾有$a$，那么可以是$a$的数量变为之前的$2^{K}$倍，否则要先用一次操作使得它在末尾。

　　你发现使得$a$的长度达到这个长，方案是唯一的。

　　你枚举开始可能的串，这个至多有$O(n)$个。直接计算就行了。

Code

#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;

const int N = 5005;

int n, K;
int mxR[N];
char s[N << 1], t[N], ans[N];

void check(char* s, int k, char min_c) {
	int L = 0, p = n;
	while (s[n - L] == min_c)
		L++, p--;
	L <<= k;
	if (L >= n) {
		for (int i = 1; i <= n; i++)
			putchar(min_c);
		putchar('\n');
		exit(0);
	}
	for (int i = 1; i <= L; i++) {
		t[i] = min_c;
	}
	for (int i = L + 1; i <= n; i++)
		t[i] = s[p--];
	for (int i = 1; i <= n; i++)
		if (t[i] ^ ans[i]) {
			if (t[i] > ans[i]) {
				return;
			}
			break;
		}
	for (int i = 1; i <= n; i++)
		ans[i] = t[i];
}

int main() {
	scanf("%d%d", &n, &K);
	scanf("%s", s + 1);
	for (int i = 1; i <= n; i++)
		s[2 * n - i + 1] = s[i];
	char x = 'z', y = 'a';
	for (int i = 1; i <= n; i++) {
		x = min(x, s[i]);
		y = max(y, s[i]);
	}
	if (K >= 20 || x == y) {
		for (int i = 1; i <= n; i++)
			putchar(x);
		putchar('\n');
		return 0;
	}
	ans[1] = 'z' + 1;
	if (s[n] == x)
		check(s, K, x);
	int mxL = 0;
	for (int i = 1, j = 1; i <= n; i = j) {
		if (s[i] != x) {
			j++;
			continue;
		}
		while (s[j] == s[i])
			j++;
		mxR[i] = j - i;
		mxL = max(mxL, mxR[i]);
	}
	for (int i = 1; i <= n; i++) {
		if (mxR[i] == mxL) {
			check(s + (n - i + 1), K - 1, x);
		}
	}
	puts(ans + 1);
	return 0;
}

Problem F Counting of Subarrays

　　可以先把问题转化成，你可以选择至少$l$个数，将它们合成一个数，问有多少个区间能合成一个数。

　　考虑如何判断一个区间是否可行：

• 取最小的元素$x$的连续段，假设长度为$L$，那么至多可以合成$\lfloor L / l \rfloor$个$x + 1$。
• 递归执行。

　　考虑怎么计算数量，考虑一个区间在它被合成一个可能的最小的数的时候计算。

　　假设当前序列中最小的数位$x$，每次计算能合成的最小数为$x + 1$的区间个数，然后把$x$的连续段缩成若干个$x + 1$。

　　要计算合成的数位$x + 1$的区间个数，只用求选择的连续至少$l$或者$1$个$x$的方案数。

　　缩数后为了保证不算重，相当于要求每次选择的区间不能被这个连续段包含。把被包含的方案数减去。然后计算这个连续段内产生$k$个$x + 1$的可能的左端点数和右端点数。

　　时间复杂度$O(n\log n)$

Code

#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;

const int N = 2e5 + 5;

#define pii pair<int, int>
#define ll long long

typedef class Segment {
	public:
		int l, r, x, y;

		Segment() {	}
		Segment(int l, int r, int x, int y) : l(l), r(r), x(x), y(y) {	}

		boolean operator < (Segment b) const {
			return l < b.l;
		}
} Segment;

int n, L;
int a[N];
pii b[N];

ll calc(vector<pii>& a) {
	ll ret = 0, sum = 0;
	for (int l = 0, r = L - 1; r < (signed) a.size(); l++, r++) {
		ret += (sum += a[l].first) * a[r].second;
	}
	return ret;
}

ll ans = 0;
int main() {
	scanf("%d%d", &n, &L);
	for (int i = 1; i <= n; i++) {
		scanf("%d", a + i);
		b[i] = pii(a[i], i);
	}
	ans = n;
	sort(b + 1, b + n + 1);
	int pos = 1, val;
	vector<Segment> vcur, vnxt, vadd;
	while (true) {
		if (!vcur.size()) {
			if (pos > n) {
				break;
			} else {
				val = b[pos].first;
			}
		} else {
			val++;
		}
//		cerr << pos << " " << val << '\n';
		vadd.clear();
		while (pos <= n && b[pos].first == val)
			vadd.emplace_back(b[pos].second, b[pos].second, 1, 1), pos++;
		vnxt.resize(vcur.size() + vadd.size());
		merge(vcur.begin(), vcur.end(), vadd.begin(), vadd.end(), vnxt.begin());
		swap(vcur, vnxt);
		vnxt.clear();
		int num = vcur.size();
		for (int i = 0, j = 0; i < num; i = ++j) {
			while (j < num - 1 && vcur[j].r + 1 == vcur[j + 1].l)
				j++;
			int len = j - i + 1, cnt = len / L;
			if (cnt) {
				vector<pii> tmp;
				for (int k = i; k <= j; k++)
					tmp.emplace_back(vcur[k].x, vcur[k].y);
				ans += calc(tmp);
				tmp.clear();
				tmp.resize(cnt, pii(0, 0));
				for (int k = L - 1; k < len; k++) {
					tmp[cnt - (k - L + 1) / L - 1].first += vcur[j - k].x;
				}
				for (int k = L - 1; k < len; k++) {
					tmp[(k - L + 1) / L].second += vcur[i + k].y;
				}
				ans -= calc(tmp);
				for (int k = 0; k < cnt; k++)
					vnxt.emplace_back(vcur[i].l + k, vcur[i].l + k, tmp[k].first, tmp[k].second);
				vnxt.back().r = vcur[j].r;
			}
		}
		swap(vcur, vnxt);
		vnxt.clear();
	}
	printf("%lld\n", ans);
	return 0;
}