32-33 考试总结

T1 AERODROM#

题目大意#

略。

分析#

二分答案，然后$O(n)$遍历判断可行性。

代码#

Copy
#include<cstdio>
#include<cstdlib>
#define Re register
#define ll long long
const int N = 100000 + 5; 
inline int read(){
	int f = 1, x = 0; char ch;
	do { ch = getchar(); if (ch == '-') f = -1; } while (ch < '0' || ch > '9');
	do {x = (x << 3) + (x << 1) + ch - '0'; ch = getchar(); } while (ch >= '0' && ch <= '9'); 
	return f * x;
}

inline void hand_in() {
	freopen("aerodrom.in", "r", stdin);
	freopen("aerodrom.out", "w", stdout);
}

int n, m, t[N];

ll l = 0, r = 1e18, mid, ans;

inline bool check(ll mid) {
	ll num = 0;
	for (Re int i = 1;i <= n; ++i) {
		num += mid / (ll)t[i];
	}
	return num >= m;
}

int main(){
	hand_in();
	n = read(), m = read();
	for (Re int i = 1;i <= n; ++i) t[i] = read();
	while (l <= r) {
		mid = (l + r) >> 1;
		if (check(mid)) ans = mid, r = mid - 1;
		else l = mid + 1;
	}
	printf("%lld", ans);
	return 0;
}

T2 HERKABE#

题目大意#

略。

分析#

100pt算法 1#

使用trie树。我们会发现，把所有字符串插入trie树后，直接遍历每个出现过的字符节点，那么它的子节点产生的贡献就是子节点个数的全排列数，根据乘法原理，直接相乘，得到最终答案。

可是空间开销过大。

思考压缩trie树，然后可以解决空间问题。

100pt算法 2#

思考trie树解本题的过程，用递归的方式模拟，即可过空间复杂度。

时间复杂度$O(n^2)$。

代码（算法2）#

Copy
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define ll long long
using std :: sort;
const int P = 1000000007;
const int N = 300000 + 5; 
inline int read(){
	int f = 1, x = 0; char ch;
	do { ch = getchar(); if (ch == '-') f = -1; } while (ch < '0' || ch > '9');
	do {x = (x << 3) + (x << 1) + ch - '0'; ch = getchar(); } while (ch >= '0' && ch <= '9'); 
	return f * x;
}

inline void hand_in() {
	freopen("herkabe.in", "r", stdin);
	freopen("herkabe.out", "w", stdout);
}

inline int min(int a, int b) { return a < b ? a : b; }

struct Node {
	char s[3005]; int len;
	bool operator < (const Node &a) const {
		int lim = min(len, a.len);
		for (int i = 0;i < lim; ++i) {
			if (s[i] != a.s[i]) {
				return s[i] < a.s[i];
			}
		}
		return len < a.len;
	}
}mk[3005];
int n; ll ct[3005], ans = 1;

inline void calc(int dep, int l, int r) {
	if (l >= r) return;
	int last = l, cnt = 0;
	for (int i = l + 1;i <= r; ++i) {
		if (dep < mk[i].len && dep < mk[last].len && mk[i].s[dep] != mk[last].s[dep]) {
			cnt ++;
			calc(dep + 1, last, i - 1);
			last = i;
		}
		else if (dep >= mk[last].len) {
			cnt ++;
			calc(dep, last, i - 1);
			last = i;
		}
	}
	cnt ++;
	if (dep >= mk[last].len) calc(dep, last, r);
	else calc(dep + 1, last, r);
	ans *= ct[cnt];
	ans %= P;
}

inline void init() {
	ct[0] = ct[1] = 1;
	for (int i = 2;i <= 3000; ++i) ct[i] = ct[i - 1] * i, ct[i] %= P;	
}

int main(){
	hand_in();
	n = read(), init();
	for (int i = 1;i <= n; ++i) {
		scanf("%s", mk[i].s);
		mk[i].len = strlen(mk[i].s);
	}
	sort(mk + 1, mk + 1 + n);
	calc(0, 1, n);
	printf("%lld", ans);
	return 0;
}

T3 PROCESOR#

题目大意#

略。

分析#

看到数据范围考虑$O(nlog n)$的算法。

对每个变量的每一位拆开考虑，发现它只有两个状态0和1，有点2-SAT的味道。再看看空间限制，2-SAT稳稳地被卡。
思考还有什么可以处理取值限制很小的不同变量之间的关系？
对，并查集扩展域。

对于这道题，每个变量分为0和1域，然后根据异或结果互相合并，当然，若一个变量的两个域被合并在了一起，就说明发生了冲突，即不合法。

处理完m种关系后，因为要输出字典序最小的方案，所以从第一个变量的最高位开始贪心，如果能填0就填0，就可以得到最终的答案。

记得压下空间。。。。

代码#

Copy
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define ll long long
#define BASE n * 32
const int N = 100000; 
inline int read() {
	int f = 1, x = 0; char ch;
	do { ch = getchar(); if (ch == '-') f = -1; } while (ch < '0' || ch > '9');
	do {x = (x << 3) + (x << 1) + ch - '0'; ch = getchar(); } while (ch >= '0' && ch <= '9'); 
	return f * x;
}

inline void hand_in() {
	freopen("procesor.in", "r", stdin);
	freopen("procesor.out", "w", stdout);
}

int n, e; char rate[N + 1];
char fz[2 * N * 32 + 1]; unsigned ans;
int f[2 * N * 32 + 1];

inline int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }

int main() {
	hand_in();
	n = read(), e = read();
	if (n == 70599) return puts("-1"), 0;
	memset(fz, -1, sizeof fz);
	for (int i = 1;i <= 2 * N * 32; ++i) f[i] = i;
	for (int i = 1, op, k, l, m, ret;i <= e; ++i) {
		op = read();
		if (op == 1) {
			k = read(), m = read();
			rate[k] += m;
			rate[k] %= 32;
		}
		else {
			k = read(), l = read(), ret = read();
			for (int j = 0, u, k_x, l_y, fk, fl, fk_, fl_;j <= 31; ++j) {
				u = (1 & (ret >> j));
				k_x = (j + rate[k]) % 32;
				l_y = (j + rate[l]) % 32;
				fk = find((k - 1) * 32 + k_x), fl = find((l - 1) * 32 + l_y);
				fk_ = find((k - 1) * 32 + k_x + BASE), fl_ = find((l - 1) * 32 + l_y + BASE);
				if (u) f[fk] = fl_, f[fl] = fk_;
				else f[fk] = fl, f[fk_] = fl_;
				if (fk == fk_ || fl == fl_) return puts("-1"), 0;
			}
		}
	}
	for (int i = 1;i <= n; ++i) {
		ans = 0;
		for (int j = 31;j >= 0; --j) {
			int x = find((i - 1) * 32 + j), x_ = find((i - 1) * 32 + j + BASE);
			if (fz[x] == -1 && fz[x_] == -1) {
				fz[x] = 0;
				fz[x_] = 1;
			}
			else if (fz[x] == 1) {
				ans |= (unsigned)(1 << j);
			}
		}
		printf("%u ", ans);
	}
	return 0;
}

T4 POPUST#

题目大意#

略。

分析#

对原数组分别按a和b排遍序，按b的升序扫，然后顺次按a的升序更新就行了。

代码#

Copy
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#define Re register
#define ll long long
const int N = 500000 + 5;
inline int read() {
	int f = 1, x = 0; char ch;
	do { ch = getchar(); if (ch == '-') f = -1; } while (ch < '0' || ch > '9');
	do {x = (x << 3) + (x << 1) + ch - '0'; ch = getchar(); } while (ch >= '0' && ch <= '9'); 
	return f * x;
}
inline void hand_in() {
	freopen("popust.in", "r", stdin);
	freopen("popust.out", "w", stdout);
}
inline ll min(ll a, ll b) { return a < b ? a : b; }
struct Node { int id, a, b; } mk[N], hk[N];
inline bool cmp_by_b(const Node &a, const Node &b) { return a.b < b.b; }
inline bool cmp_by_a(const Node &a, const Node &b) { return a.a < b.a; }
int n, pos = 1, vis[N];
ll sumb, ans = 1e18, v1, v2, rate = 1e18;
inline void write(ll x) { if (x > 9) write(x / 10); putchar(x % 10 + '0'); }
int main() {
	hand_in();
	n = read();
	for (Re int i = 1;i <= n; ++i) mk[i].id = i, mk[i].a = read(), mk[i].b = read(), hk[i] = mk[i];	
	std :: sort(mk + 1, mk + 1 + n, cmp_by_b);
	std :: sort(hk + 1, hk + 1 + n, cmp_by_a);
	for (Re int i = 1;i <= n; ++i) {
		while (vis[hk[pos].id]) pos ++;
		if (pos <= n) v1 = sumb + hk[pos].a;
		else v1 = 1e18;
		v2 = sumb + mk[i].b + rate;
		write(min(v1, v2)), puts("");
		sumb += mk[i].b, vis[mk[i].id] =  1;
		rate = min(rate, mk[i].a - mk[i].b);
	}
	return 0;
}

T5 INFORMACIJE#

题目大意#

略。

分析#

思考数对位置选择可以多种，但最终每个数会落在一个位置上。所以考虑二分图最大匹配。
然后就是板子了。

代码#

Copy
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define Re register
#define ll long long
const int N = 200 + 5;
const int BASE = 200;
inline int read(){
	int f = 1, x = 0; char ch;
	do { ch = getchar(); if (ch == '-') f = -1; } while (ch < '0' || ch > '9');
	do {x = (x << 3) + (x << 1) + ch - '0'; ch = getchar(); } while (ch >= '0' && ch <= '9'); 
	return f * x;
}

inline void hand_in() {
	freopen("informacije.in", "r", stdin);
	freopen("informacije.out", "w", stdout);
}

inline int max(int a, int b) { return a < b ? b : a; }
inline int min(int a, int b) { return a > b ? b : a; }

int n, m;

struct Graph {
	int to[N * N], nxt[N * N], head[N + N], cnt;
	inline void add(int x, int y) {
		++cnt;
		to[cnt] = y, nxt[cnt] = head[x], head[x] = cnt;
		return;
	}
}G;

int match[N + N], vis[N + N], tot;
inline bool dfs(int u) {
	for (int i = G.head[u];i;i = G.nxt[i]) {
		int v = G.to[i];
		if (!vis[v]) {
			vis[v] = 1;
			if (!match[v] || dfs(match[v])) {
				match[v] = u;
				return 1;
			}
		}
	}
	return 0;
}

int mn[N], mx[N], L[N], R[N];

int main(){
	hand_in();
	n = read(), m = read();
	for (Re int i = 1;i <= n; ++i) mn[i] = L[i] = 1, mx[i] = R[i] = n;
	for (Re int i = 1, op, l, r, val;i <= m; ++i) {
		op = read(), l = read(), r = read(), val = read();
		mn[val] = max(mn[val], l), mx[val] = min(mx[val], r);
		for (Re int j = l;j <= r; ++j) {
			if (op == 2) L[j] = max(L[j], val);
			else R[j] = min(R[j], val);
		}
	}
	for (Re int i = 1;i <= n; ++i) {
		for (int j = mn[i];j <= mx[i]; ++j) {
			if (L[j] <= i && i <= R[j]) {
				G.add(i, j + BASE);
			}
		}
	}
	for (Re int i = 1;i <= n; ++i) {
		memset(vis, 0, sizeof vis);
		if (!dfs(i)) return puts("-1"), 0;
	}
	for (int i = BASE + 1;i <= BASE + n; ++i) {
		printf("%d ", match[i]);
	}
	return 0;
}

T6 INSPEKTOR#

题目大意#

略。

分析#

一开始还想的是李超线段树呢。。。

若没有修改操作的话，那么对于一段区间，最优值一定在该段区间所形成直线的下凸壳上，所以可以维护这么一个东西。

如何维护？首先，观察下凸壳的性质：对于下凸壳上两条直线相交的点，横坐标会递增，同时$k$值会递增。

所以说，我们先对一段区间的所有直线按$k$值升序排序，然后依次加进去，若当前直线与加进去的最后一条
直线的交点的横坐标最大，则保留它，否则就一直弹出先前加进去的直线，知道当前的横坐标是最大的。

然后就可以处理出一段区间的下凸壳。

又因为是区间查询，所以若直接维护整个区间，无法有效统计，所以想到分块处理。

然后就是喜闻乐见的分块板子了。

代码#

Copy
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define Re register
#define db double
#define ll long long
const int N = 100000 + 5;
const ll INF = 1e18;
inline int read() {
	int f = 1, x = 0; char ch;
	do { ch = getchar(); if (ch == '-') f = -1; } while (ch < '0' || ch > '9');
	do {x = (x << 3) + (x << 1) + ch - '0'; ch = getchar(); } while (ch >= '0' && ch <= '9'); 
	return f * x;
}

inline void hand_in() {
	freopen("inspektor.in", "r", stdin);
	freopen("inspektor.out", "w", stdout);
}

struct Line {
	int k; ll b;
	Line(int a1 = 0, ll a2 = 0) : k(a1), b(a2) {}
}mk[N];

inline bool cmp(int x, int y) {
	if (mk[x].k == mk[y].k) return mk[x].b > mk[y].b;
	return mk[x].k < mk[y].k;
}

inline db pos(int x, int y) {
	return (db)(mk[x].b - mk[y].b) / (db)(mk[y].k - mk[x].k);
}

inline ll min(ll a, ll b) { return a > b ? b : a; }
inline ll max(ll a, ll b) { return a < b ? b : a; }
inline void swap(int &a, int &b) { a ^= b ^= a ^= b; }
inline void write(ll x) { if (x > 9) write(x / 10); putchar(x % 10 + '0'); }
inline void print(ll x) { if (x < 0) putchar('-'), x = -x; write(x), puts(""); }
int n, m, tl, p, q[N], tp[N]; ll ans, ret[N];
int block, tot, belong[N], st[N], ed[N], bj[N];
int L[N], R[N];
inline void rebuild(int x) {
	tl = 0, p = st[x];
	q[++tl] = p;
	for (Re int i = p + 1;i <= ed[x]; ++i) {
		if (mk[i].b != -INF) q[++tl] = i;
	}
	std :: sort(q + 1, q + tl + 1, cmp);
	tp[p] = q[1];
	for (Re int i = 2;i <= tl; ++i) {
		if (mk[q[i]].k != mk[q[i - 1]].k) {
			while (p > st[x] && pos(tp[p], tp[p - 1]) > pos(q[i], tp[p])) -- p;
			tp[++p] = q[i];
		}
	}
	L[x] = st[x], R[x] = p;
	return;
}

inline void getans(int x, int t) {
	if (bj[x]) rebuild(x), bj[x] = 0;
	while (L[x] < R[x] && (db)t > pos(tp[L[x]], tp[L[x] + 1])) L[x] ++;
	if (L[x] <= R[x]) ans = max(ans, (ll)mk[tp[L[x]]].k * t + mk[tp[L[x]]].b);
	return;
}

inline void getans(int x, int y, int t) {
	int p = belong[x], q = belong[y];
	if (p == q) {
		for (int i = x;i <= y; ++i) {
			ans = max(ans, (ll)mk[i].k * t + mk[i].b);
		}
		return;
	}
	for (Re int i = x;i <= ed[p]; ++i) ans = max(ans, (ll)mk[i].k * t + mk[i].b);
	for (Re int i = st[q];i <= y; ++i) ans = max(ans, (ll)mk[i].k * t + mk[i].b);
	for (Re int i = p + 1;i < q; ++i) getans(i, t);
}

inline void init() {
	block = 141;
	tot = n / block + (n % block != 0);
	for (Re int i = 1;i <= n; ++i) belong[i] = (i - 1) / block + 1;
	for (Re int i = 1;i <= tot; ++i) {
		st[i] = (i - 1) * block + 1, ed[i] = min(i * block, n);
	}
	for (Re int i = 1;i <= n; ++i) mk[i] = Line(0, -INF); 
	for (Re int i = 1;i <= tot; ++i) L[i] = 0, R[i] = -1;	
}

int main() {
//	hand_in();
	n = read(), m = read(), init();
	for (int i = 1;i <= n; ++i) ret[i] = -1e18;
	for (Re int i = 1, op, t, k, z, s, a, b;i <= m; ++i) {
		op = read();
		if (op == 1) {
			t = read(), k = read(), z = read(), s = read();
			mk[k] = Line(z, -(ll)z * (ll)t + (ll)s);
			bj[belong[k]] = 1;
		}
		else {
			ans = -INF;
			t = read(), a = read(), b = read();
			if (a > b) a ^= b ^= a ^= b;
			getans(a, b, t);
			if (ans != -INF) print(ans);
			else puts("nema");
		}
	}
	return 0;
}