5.AGC01801-19

AGC018

B

题目大意

举办一场运动会，有 $N$ 人， $M$ 个项目，每个人所有项目都有一个排名，会选择参加排名最高且开设的项目，现在要开设若干项目使得人数最多的项目人数尽可能小，求这个最小值。

解题思路

考虑贪心。

一开始，我们不妨开设所有项目，设人数最多的项目为 $x$ 。

如果我们不关闭项目 $x$ ，最大值就不会变，因此我们考虑关闭项目 $x$ ，将原来参加 $x$ 的人分配到他们排名次高的项目（可以用 vector 存储参加这个项目的人）。

于是，又会有新的人数最多的项目，我们重复这个过程，直到只剩下一个项目，期间最大值的最小值即为答案。

注意：在重新分配项目时，不仅要根据次高排名，还要判断这个项目现在是否开设，不开设还要再往后。

时间复杂度： $O (n m)$

代码

#include<bits/stdc++.h>
#define endl "\n"
using namespace std;

const int N = 310;

int n, m, ans;
int a[N][N], b[N][N], sz[N];
vector<int> e[N];
bool vis[N];

inline void add(int u, int v)
{
	e[u].push_back(v);
	sz[u]++;
}

int main()
{
	ios :: sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= m; j++)
		{
			cin >> a[i][j];
			b[i][a[i][j]] = j;
			if (j == 1)
			{
				add(a[i][j], i);
			}
		}
	}
	for (int i = 1; i <= m; i++)
	{
		if (!vis[i])
		{
			ans = max(sz[i], ans);
		}
	}
	for (int i = 1; i < m; i++)
	{
		int x = 0, mx = 0;
		for (int i = 1; i <= m; i++)
		{
			if (!vis[i])
			{
				if (sz[i] > mx)
				{
					mx = sz[i];
					x = i;
				}
			}
		}
		ans = min(mx, ans);
		for (auto it : e[x])
		{
			int v = b[it][x] + 1;
			while (vis[a[it][v]])
			{
				v++;
			}
			add(a[it][v], it);
		}
		vis[x] = 1;
	}
	cout << ans << endl;
	return 0;
}

C

题目大意

有 $x + y + z$ 个人，第 $i$ 个人有 $A_{i}$ 个金币， $B_{i}$ 个银币， $C_{i}$ 个铜币。

要选出 $x$ 个人获得其金币，选出 $y$ 个人获得其银币，选出 $z$ 个人获得其铜币。在不重复选某个人的情况下，求最大的获得的币的总数。

解题思路

考虑反悔贪心。

一开始有三个元素：金币、银币、铜币，较难处理。

考虑反悔机制，直接默认所有人都拿金币，之后把 $y$ 人改成银币，选出 $z$ 个改成铜币即可。

具体地，把金币个数加到答案里，再把每个人的信息改成二元组 $(B_{i} - A_{i}, C_{i} - A_{i})$ ，使得在选金币后再选这两个元素之一和选银币或铜币等价。

记 $D_{i} = B_{i} - A_{i}$ ， $E_{i} = C_{i} - A_{i}$ ，问题转化为在 $N$ 个二元组中选 $y$ 个 $D_{i}$ 收益，选 $z$ 个 $E_{i}$ 收益，求最大的总收益。

考虑何时 $(D_{i}, E_{i})$ 选 $D_{i}$ 、 $(D_{j}, E_{j})$ 选 $E_{j}$ 不比 $(D_{i}, E_{i})$ 选 $E_{i}$ 、 $(D_{j}, E_{j})$ 选 $D_{j}$ 劣。

即 $D_{i} + E_{j} \geq D_{j} + E_{i}$ ，移项得： $D_{i} - E_{i} \geq D_{j} - E_{j}$ 。

于是我们可以按 $(D_{i}, E_{i})$ 从大到小排序，此时前面一段统一选 $D_{i}$ ，后面一段统一选 $E_{i}$ 一定不劣。

然后可以用优先队列维护前缀最大的 $y$ 个 $D_{i}$ 的和 $s [i]$ ，后最大的 $y$ 个 $D_{i}$ 的和 $t [i]$ 。

答案即为：

\sum A + {max}_{i = y}^{n - z} (s [i] + t [i + 1])

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

代码

#include<bits/stdc++.h>
#define endl "\n"
#define ll long long
using namespace std;

const int N = 1e5 + 10;

struct node
{
	int a, b;
} p[N];

int n, x, y, z;
ll ans, s[N], t[N];
priority_queue<ll, vector<ll>, greater<ll> > q;

bool cmp(node x, node y)
{
	return x.a - x.b > y.a - y.b;
}

int main()
{
	ios :: sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> x >> y >> z;
	n = x + y + z;
	for (int i = 1; i <= n; i++)
	{
		int a, b, c;
		cin >> a >> b >> c;
		ans += a;
		p[i].a = b - a, p[i].b = c - a;
	}
	sort(p + 1, p + n + 1, cmp);
	for (int i = 1; i <= n; i++)
	{
		s[i] = s[i - 1] + p[i].a;
		q.push(p[i].a);
		if ((int)q.size() > y)
		{
			s[i] -= q.top();
			q.pop();
		}
	}
	while (!q.empty())
	{
		q.pop();
	}
	for (int i = n; i >= 1; i--)
	{
		t[i] = t[i + 1] + p[i].b;
		q.push(p[i].b);
		if ((int)q.size() > z)
		{
			t[i] -= q.top();
			q.pop();
		}
	}
	ll mx = LONG_LONG_MIN;
	for (int i = y; i <= n - z; i++)
	{
		mx = max(mx, s[i] + t[i + 1]);
	}
	cout << ans + mx << endl;
	return 0;
}

D

题目大意

给出一棵有 $N$ 个点有边权的无根树，现有一个有 $N$ 个点的完全图，两点间边权即为他们在树上的简单路径长度，求这个图最长的哈密顿路径的长度。

解题思路

先考虑最长哈密顿回路长度。

要使其最长，就需要尽可能多地经过每一条边，考虑树上一条边能做出的最大贡献。

设这条边为 $(u, f a)$ ，由于是哈密顿回路，有出有进且不能重复访问点，可以得到访问次数上界为 $2 min (s i z e_{u}, n - s i z e_{u})$ 。

考虑能否让每条边取到这个上界，假设子树的点数小于子树外点数，可以发现取到上界时不能有路径在子树内部，因为子树点数本来就少，又被自己匹配掉一些，就会使经过这条边的最大次数减少，如果大于同理，也不能有路径完全在子树外。

为了方便讨论，我们不妨钦定重心为树根（如果重心有两个就可以缩点成一个），根据重心的性质，不会有子树点数大于子树外点数的情况，就避免了考虑另一种情况。

于是可以得到：不能有路径在一个子树内部，即每条路径都要经过重心，就可以取到最值（补充：一个重心可以就只在达重心上，两个重心必须经过连接两个重心的边），我们只需将答案加上最值即可。

现在我们考虑哈密顿路径，就是在回路的基础上减去一条最短的路径。

一个重心：此时最小值一定是在终点在重心上，那么就可以钦定连接重心的最小边为最后一条边，删去它损失必定最小
两个重心：由于两个重心必须经过连接两个重心的边，那么最短的路径即恰好为连接两个重心的边。

时间复杂度： $O (n)$

关于讨论区问题的补充：

证明最大哈密顿回路去掉最小边一定是最大哈密顿路径。

如果它不是最大哈密顿回路，即存在在同一棵子树的路径，由于一条路径会匹配掉两个点，那么就会使得经过的连接重心的边的访问次数减 $2$ 。

如图，中间的边少访问了两次：（非原创，侵删）

因为少了两次，而我们的哈密顿路径选取了最小的边，只少一次，因此它的哈密顿回路已经小于最大的哈密顿路径，所以哈密顿路径更小于最大的哈密顿路径。

代码

#include<bits/stdc++.h>
#define endl "\n"
#define ll long long
using namespace std;

const int N = 1e5 + 10;

struct edge
{
	int to, w, next;
} e[N << 1];

ll n, tot, ans, p1, p2;
ll h[N], sz[N], mx[N];

void add(int u, int v, int w)
{
	tot++;
	e[tot].to = v;
	e[tot].w = w;
	e[tot].next = h[u];
	h[u] = tot;
}

void dfs(int u, int fa)
{
	sz[u] = 1;
	for (int i = h[u]; i; i = e[i].next)
	{
		int v = e[i].to;
		if (v == fa)
		{
			continue;
		}
		dfs(v, u);
		sz[u] += sz[v];
		mx[u] = max(mx[u], sz[v]);
		ans += 2 * min(sz[v], n - sz[v]) * e[i].w;
	}
	mx[u] = max(mx[u], n - sz[u]);
}

int main()
{
	ios :: sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> n;
	for (int i = 1; i < n; i++)
	{
		int u, v, w;
		cin >> u >> v >> w;
		add(u, v, w), add(v, u, w);
	}
	dfs(1, 0);
	ll mn = LONG_LONG_MAX;
	for (int i = 1; i <= n; i++)
	{
		mn = min(mn, mx[i]);
	}
	for (int i = 1; i <= n; i++)
	{
		if (mx[i] == mn)
		{
			if (!p1)
			{
				p1 = i;
			}
			else
			{
				p2 = i;
			}
		}
	}
	mn = LONG_LONG_MAX;
	for (int i = h[p1]; i; i = e[i].next)
	{
		int v = e[i].to;
		if (p2 && v != p2)
		{
			continue;
		}
		mn = min(mn, (ll)e[i].w);
	}
	cout << ans - mn << endl;
	return 0;
}

posted @ 2025-01-19 16:07 I_LOVE_MATH 阅读(24) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· AGC008

· ABC243

· AGC018做题笔记

· [AGC018B] Sports Festival

· 2022 CCPC 威海 ACEGJ

阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· DeepSeek 开源周回顾「GitHub 热点速览」
· 记一次.NET内存居高不下排查解决与启示
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· .NET10 - 预览版1新功能体验（一）

公告

昵称： I_LOVE_MATH
园龄： 1个月
粉丝： 1
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

Chtholly

如果幸福有颜色，那一定是被终焉之红染尽的蔚蓝

AGC018

AGC018

B

题目大意

解题思路

代码

C

题目大意

解题思路

代码

D

题目大意

解题思路

代码

公告

搜索

常用链接

最新随笔

积分与排名

合集

随笔分类

随笔档案

阅读排行榜

推荐排行榜