Educational Codeforces Round 36 (Rated for Div. 2)

合集 - 日常训练 (CF)(6)

1.Codeforces Round 598 (Div.3 )2023-06-142.Codeforces Round 595 (Div. 3)2023-06-163.Codeforces Round 699 (Div. 2)2023-09-074.Codeforces Round 903 (Div. 3)2023-10-135.CodeCraft-21 and Codeforces Round 711 (Div. 2)2023-11-09

6.Educational Codeforces Round 36 (Rated for Div. 2)2024-04-11

收起

Educational Codeforces Round 36 (Rated for Div. 2)

A

直接枚举即可

#include <bits/stdc++.h>

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, k;

    std::cin >> n >> k;

    int ans = 1e9;

    for (int i = 1; i <= n; i++) {
        int x;
        std::cin >> x;
        if (k % x == 0) {
            ans = std::min(ans, k / x);
        }
    }

    std::cout << ans << '\n';

    return 0;
}

---

B

分类讨论：
注意 $l=1,r=n$ 情况

#include <bits/stdc++.h>

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, pos, l, r;
    std::cin >> n >> pos >> l >> r;

    if (l == 1 && r == n) {
        std::cout << 0 << '\n';
        return 0;
    }

    if (l == 1) {
        std::cout << std::abs(r - pos) + 1 << '\n';
    } else if (r == n) {
        std::cout << std::abs(l - pos) + 1 << '\n';
    } else {
        std::cout << r - l + std::min(std::abs(l - pos), std::abs(r - pos)) + 2 << '\n';
    }

    return 0;
}

---

C

首先特判如果 $a$ 的位数小于 $b$，显然可以直接把 $a$ 的数位从大到小排序即可。

否则就是两个位数一样，我们从高位到地位一次贪心，每次尝试填某个数 $x$，看看填了之后后面所有数都按顺序填，能不能构造出 $a\le b$，如果可行那么这一位就贪心填这个数即可。

---

D

直接枚举断哪条边，复杂度显然是 $O(n^2(n+m)$ 显然是爆炸的，但我们发现，由于只能删一条边，
那么我们必然得删在某一个环上面。

由于 $n\le 500$，所以我们只要随意找一个图中的环，枚举断掉哪条环上的边即可，然后每次检查一次即可，复杂度是 $O(n(n+m)$ 的。

#include <bits/stdc++.h>


const int N = 510;
std::vector<int> g[N];
int st[N], fa[N];
std::vector<int> cir;
bool vis[N][N];

bool dfs(int u) {
	st[u] = 1;
	for (auto v : g[u]) {
		if (!st[v]) {
			fa[v] = u;	
			if (dfs(v)) return true;
		} else if (st[v] == 1) {
			int x = u;
			while (true) {
				cir.push_back(x);
				if (x == v) break;
				x = fa[x];
			}
			return true;
		}
	}
	st[u] = 2;
	return false;
}

bool DFS(int u) {
	st[u] = 1;
	for (auto v : g[u]) {
		if (vis[u][v]) continue;
		if (!st[v]) {
			if (DFS(v)) return true;
		} else if (st[v] == 1) {
			return true;
		}
	}
	st[u] = 2;
	return false;
}


int main(){
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
	
	int n, m;

	std::cin >> n >> m;

	while (m--) {
		int u, v;
		std::cin >> u >> v;
		g[u].push_back(v);
	}	

	bool ok = false;
	for (int i = 1; i <= n; i++) {
		if (!st[i] && dfs(i)) {
			ok = true;
			break;
		}
	}



	if (!ok) {
		std::cout << "YES\n";
		return 0;
	}

	//枚举断掉环上的任意一条边

	for (int i = 0; i < cir.size(); i++) {
		vis[cir[(i + 1) % (int)cir.size()]][cir[i]] = true;
		memset(st, 0, sizeof st);
		bool ok = true;
		for (int j = 1; j <= n; j++) {
			if (!st[j] && DFS(j)) {
				ok = false;
				break;
			}
		}
		if (ok) {
			std::cout << "YES\n";
			return 0;
		}
		vis[cir[(i + 1) % (int)cir.size()]][cir[i]] = false;
	}

	std::cout << "NO\n";


	return 0;
}

---

E

经典的线段树题，我们把询问离散化，注意端点弄成 $r+1$，这样我们任意两个相邻点构成的区间长度就可以写成 $v[x]-v[x-1]$ 了，且是不重不漏的。

然后就变成一个区间推平，区间求和的板子题：

#include <bits/stdc++.h>

const int N = 6e5 + 10;
std::vector<int> v;

int sum[4 * N], tag[4 * N], len[4 * N];

void build(int u, int l, int r) {
    tag[u] = -1;
    if (l == r) {
        sum[u] = len[u] = v[l] - v[l - 1];
        return;
    }
    int mid = (l + r) >> 1;
    build(u << 1, l, mid);
    build(u << 1 | 1, mid + 1, r);
    sum[u] = sum[u << 1] + sum[u << 1 | 1];
    len[u] = len[u << 1] + len[u << 1 | 1];
}

void push(int u) {
    if (tag[u] != -1) {
        sum[u << 1] = len[u << 1] * tag[u];
        sum[u << 1 | 1] = len[u << 1 | 1] * tag[u];
        tag[u << 1] = tag[u];
        tag[u << 1 | 1] = tag[u];
        tag[u] = -1;
    }
}

void modify(int u, int l, int r, int ql, int qr, int t) {
    if (l >= ql && r <= qr) {
        sum[u] = len[u] * t;
        tag[u] = t;
        return;
    }
    push(u);
    int mid = (l + r) >> 1;
    if (ql <= mid) modify(u << 1, l, mid, ql, qr, t);
    if (qr > mid) modify(u << 1 | 1, mid + 1, r, ql, qr, t);
    sum[u] = sum[u << 1] + sum[u << 1 | 1];
}



int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, q;


    std::cin >> n >> q;

    v.push_back(1), v.push_back(n + 1);

    std::vector<std::array<int, 3>> qry(q);

    for (int i = 0; i < q; i++) {
        auto& [k, l, r] = qry[i];
        std::cin >> l >> r >> k;
        if (k == 1) k = 0;
        else k = 1;
        v.push_back(l), v.push_back(++r);
    }

    std::sort(v.begin(), v.end());

    v.erase(std::unique(v.begin(), v.end()), v.end());

    int m = (int)v.size() - 1;

    build(1, 1, m);


    for (int i = 0; i < q; i++) {
        auto [k, l, r] = qry[i];
        l = std::lower_bound(v.begin(), v.end(), l) - v.begin() + 1;
        r = std::lower_bound(v.begin(), v.end(), r) - v.begin();
        modify(1, 1, m, l, r, k);
        std::cout << sum[1] << '\n';
    }

    return 0;
}

---

F

经典的 trick：

• 首先最大值和最小值可以分开求和
• 对于这类求两两路径的东西，且和权值大小有关，我们可以直接排序+并查集即可。

按点权从小到大，每次拿出点 $u$ 查询它所有相邻的边，若 $v$ 也被处理过了，说明 $v$ 所在集合和 $u$ 所在集合任意取两个点，它们的路径都会经过这个目前的最大值的点 $u$，我们只要维护并查集大小，每次合并的时候算贡献即可。

#include <bits/stdc++.h>

typedef long long i64;

int main(){
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
	
	int n;
	std::cin >> n;

	std::vector<int> a(n + 1);
	std::vector<int> q(n + 1);

	for (int i = 1; i <= n; i++) {
		q[i] = i;
	}

	std::vector<std::vector<int>> g(n + 1);

	std::vector<int> p(n + 1), sz(n + 1, 0);

	for (int i = 1; i <= n; i++) {
		p[i] = i, sz[i] = 1;
	}
	

	std::function<int(int)> find = [&](int x) {
		return x == p[x] ? x : p[x] = find(p[x]);
	};

	for (int i = 1; i <= n; i++) {
		std::cin >> a[i];
	}

	for (int i = 1; i < n; i++) {
		int u, v;
		std::cin >> u >> v;
		g[u].push_back(v);
		g[v].push_back(u);
	}

	std::sort(q.begin() + 1, q.end(), [&](int x, int y) {
		return a[x] < a[y];
	});

	std::vector<bool> vis(n + 1, false);

	i64 ans = 0;

	for (int i = 1; i <= n; i++) {
		int u = q[i];
		vis[u] = true;
		for (auto v : g[u]) {
			if (!vis[find(v)]) continue;
			ans += 1LL * sz[find(v)] * sz[find(u)] * a[u];
			sz[find(u)] += sz[find(v)];
			p[find(v)] = find(u);
		}
	}


	for (int i = 1; i <= n; i++) {
		p[i] = i, sz[i] = 1;
		vis[i] = false;
	}



	for (int i = n; i >= 1; i--) {
		int u = q[i];
		vis[u] = true;
		for (auto v : g[u]) {
			if (!vis[find(v)]) continue;
			ans -= 1LL * sz[find(v)] * sz[find(u)] * a[u];
			sz[find(u)] += sz[find(v)];
			p[find(v)] = find(u);
		}
	}

	std::cout << ans << '\n';


	return 0;
}