AGC018
B
题目大意
举办一场运动会，有 \(N\) 人，\(M\) 个项目，每个人所有项目都有一个排名，会选择参加排名最高且开设的项目，现在要开设若干项目使得人数最多的项目人数尽可能小，求这个最小值。
解题思路
考虑贪心。
一开始，我们不妨开设所有项目，设人数最多的项目为 \(x\)。
如果我们不关闭项目 \(x\)，最大值就不会变，因此我们考虑关闭项目 \(x\)，将原来参加 \(x\) 的人分配到他们排名次高的项目（可以用 vector 存储参加这个项目的人）。
于是，又会有新的人数最多的项目，我们重复这个过程，直到只剩下一个项目，期间最大值的最小值即为答案。
注意：在重新分配项目时，不仅要根据次高排名，还要判断这个项目现在是否开设，不开设还要再往后。
时间复杂度：\(O(nm)\)
代码
cpp
#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\ge D_j+E_i\)，移项得：\(D_i-E_i\ge 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)\)
代码
cpp
#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,fa)\)，由于是哈密顿回路，有出有进且不能重复访问点，可以得到访问次数上界为 \(2\min(size_u,n-size_u)\)。
考虑能否让每条边取到这个上界，假设子树的点数小于子树外点数，可以发现取到上界时不能有路径在子树内部，因为子树点数本来就少，又被自己匹配掉一些，就会使经过这条边的最大次数减少，如果大于同理，也不能有路径完全在子树外。
为了方便讨论，我们不妨钦定重心为树根（如果重心有两个就可以缩点成一个），根据重心的性质，不会有子树点数大于子树外点数的情况，就避免了考虑另一种情况。
于是可以得到：不能有路径在一个子树内部，即每条路径都要经过重心，就可以取到最值（补充：一个重心可以就只在达重心上，两个重心必须经过连接两个重心的边），我们只需将答案加上最值即可。
现在我们考虑哈密顿路径，就是在回路的基础上减去一条最短的路径。
- 一个重心：此时最小值一定是在终点在重心上，那么就可以钦定连接重心的最小边为最后一条边，删去它损失必定最小
- 两个重心：由于两个重心必须经过连接两个重心的边，那么最短的路径即恰好为连接两个重心的边。
时间复杂度：\(O(n)\)
关于讨论区问题的补充：
证明最大哈密顿回路去掉最小边一定是最大哈密顿路径。
如果它不是最大哈密顿回路，即存在在同一棵子树的路径，由于一条路径会匹配掉两个点，那么就会使得经过的连接重心的边的访问次数减 \(2\)。
如图，中间的边少访问了两次：（非原创，侵删）
因为少了两次，而我们的哈密顿路径选取了最小的边，只少一次，因此它的哈密顿回路已经小于最大的哈密顿路径，所以哈密顿路径更小于最大的哈密顿路径。
代码
cpp
#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;
}