Petrozavodsk WinterTraining 2015

PetrozavodskWinterTraining2015

A - Three Servers

题目描述：有\(n\)个数，将这\(n\)个数分成\(3\)堆，使得\(3\)堆中和的最大值减最小值最小，求方案。

solution

\(f[i][j]\)表示第二堆减第一堆等于\(i\)，第三堆减第二堆等于\(j\)的方案。由于数字比较小，所以可以定\(-100 \leq i, j \leq 100\)，然后将读入数据随机排序，做\(10\)次就可以过了。

时间复杂度：\(O(能过)\)

F - Empty Vessels

题目描述：有\(n\)个水杯，每个水杯的容量为\(a_i\)，现在有\(3\)种操作：

1. 将某个水杯装满水
2. 将某个水杯里的水倒掉
3. 将某个水杯里的水倒到另一个水杯里，直到一个水杯满或一个水杯空
   
   给定一个值\(m\)，问是否通过若干次操作之后某个水杯里的水体积为\(m\)，求出方案。

solution

显然，\(m\)一定要是\(a_i\)的最大公约数的倍数，并且\(m\)要小于\(a_i\)的最大值。

然后将最大的水杯看做剩余系，所有水杯往最大的水杯倒水，相当于水量模最大水杯容量，然后像完全背包那样做即可。

时间复杂度：\(O(最大容量*n)\)

G - Maximum Product

solution

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

typedef long long LL;
const int maxn=30;

LL A, B;
int a[maxn], b[maxn], now[maxn];

void calc(LL num, int *a)
{
	if (num==0) a[a[0]=1]=0;
	a[0]=0;
	while (num)
	{
		a[++a[0]]=num%10;
		num/=10;
	}
}
bool check()
{
	if (now[0]!=a[0]) return now[0]>a[0];
	for (int i=now[0]; i; --i)
		if (now[i]!=a[i]) return now[i]>a[i];
	return true;
}
void solve()
{
	scanf("%lld%lld", &A, &B);
	calc(A, a);
	calc(B, b);

	LL answer=1, ans=B;
	for (int i=1; i<=b[0]; ++i) answer*=b[i];

	for (int i=b[0]; i; --i)
	{
		for (int j=b[0]; j>i; --j) now[j]=b[j];
		now[i]=b[i]-1;
		for (int j=i-1; j; --j) now[j]=9;
		for (int j=i; j<b[0]; ++j)
			if (now[j]<0)
			{
				now[j]+=10;
				now[j+1]--;
			}
			else break;
		now[0]=b[0];
		if (now[0]>1 && now[now[0]]==0) --now[0];
		if (check())
		{
			LL s=1;
			for (int j=1; j<=now[0]; ++j) s*=now[j];
			if (s>answer)
			{
				answer=s;
				ans=0;
				for (int j=now[0]; j; --j) ans=ans*10+now[j];
			}
		}
	}
	printf("%lld\n", ans);
}
int main()
{
	solve();
	return 0;
}

H - Biathlon 2.0

题目描述：分别给定\(n, m\)个向量，对于\(n\)里面的每个向量，在\(m\)中找一个向量，使得两个向量的点乘最小。

solution

根据点乘的意义，相当于是一个向量在另一个向量的投影，因此可以想到只有\(m\)个向量形成的下凸壳，在下凸壳上的点才是答案，将\(n\)个向量极角排序，然后每个向量对应的答案在下凸壳上是单调的。

时间复杂度：\(O(nlogn)\)

I - Archaeological Research

题目描述：有一个未知序列\(a_i\)，给出一些数据，第\(i\)行第\(j\)个数据表示某个数在序列的第\(i+1\)个数后面(包括\(i+1\))第一次出现的位置是\(j\)，找出\(a_i\)的可行解中字典序最小的一个。

solution

题目还可以用另一种方式表达：第\(i\)行第\(j\)个数据表示某个数在序列的第\(i+1\)位到第\(j-1\)位没出现过，进而可以求出\(a_i\)在\([l_i, i-1]\)没出现过，然后只要贪心地从左到右放数，每次取\([1, l_i-1]\)中最小的数，如果\(l_i=1\)，那么新开一个数字给\(a_i\)。

时间复杂度：\(O(nlogn)\)

J - Sockets

题目描述：有一个电源（只有一个插座），\(n\)个排插，分别有\(a_i\)个插座，每个排插可以直接接电源或者插到别的排插上，有\(m\)部手机需要同时充电，每部手机规定到电源之间最多能有\(b_i\)个排插，问最多能有多少部手机同时充电。

solution

将排插按\(a_i\)从大到小排序，手机按\(b_i\)从小到大排序，二分答案，先满足\(b_i\)较小的，其它位置插排插。

时间复杂度：\(O(nlogn)\)

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

typedef long long LL;
const int maxn=int(2e5)+100;

int n, m;
int a[maxn], b[maxn];

void read()
{
	scanf("%d%d", &n, &m);
	for (int i=1; i<=n; ++i) scanf("%d", &a[i]);
	for (int i=1; i<=m; ++i) scanf("%d", &b[i]);
}
bool check(int num)
{
	LL rest=1;
	for (int i=1, level=0; i<=n && num; ++level)
	{
		int k=num;
		while (k && b[k]==level) --k;
		if (num-k>rest) return false;
		LL tmp=(rest-=(num-k));
		num=k;
		while (i<=n && (tmp--)) rest+=a[i++]-1;
	}
	return rest>=num;
}
void solve()
{
	sort(a+1, a+1+n, greater<int>());
	sort(b+1, b+1+m, greater<int>());

	int L=0, R=m+1;
	while (L+1<R)
	{
		int mid=(L+R)>>1;
		if (check(mid)) L=mid;
		else R=mid;
	}
	printf("%d\n", L);
}
int main()
{
	read();
	solve();
	return 0;
}

K - Toll Roads

题目描述：给定一棵树，边权为\(1\)，现在可以选择一条长度不超过\(m\)的链，将链上的边权全改为\(0\)，使得树的直径最小，求方案。

solution

思路挺好想的，就是枚举一端作为树根，然后类似树形\(dp\)算出当另一端某个点时，树的直径是多少。

时间复杂度：\(O(n^2)\)

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

const int maxn=5010;

int n, m, root;
vector<int> out[maxn];
int idx[maxn];
pair<int, int> le[maxn], ri[maxn];
int radle[maxn], radri[maxn];
int fa[maxn], f[maxn], g[maxn], h[maxn];
int rad[maxn], deep[maxn];
pair<int, int> ans, solu;

void read()
{
	scanf("%d%d", &n, &m);
	for (int i=0; i<n; ++i) out[i].clear();
	for (int i=1; i<n; ++i)
	{
		int u, v;
		scanf("%d%d", &u, &v);
		out[u].push_back(v);
		out[v].push_back(u);
	}
}
void dfs1(int cur, int _fa)
{
	rad[cur]=0;
	f[cur]=0;
	fa[cur]=_fa;
	if (_fa==-1) deep[cur]=0;
	else deep[cur]=deep[_fa]+1;
	for (auto &to:out[cur])
	if (to!=_fa)
	{
		dfs1(to, cur);
		rad[cur]=max(rad[cur], max(rad[to], f[cur]+f[to]+1));
		f[cur]=max(f[cur], f[to]+1);
	}
}
void dfs2(int cur, int past, int chain)
{
	if (deep[cur]>m) return;
	int s=max(past, max(rad[cur], chain+f[cur]));
	if (make_pair(s, deep[cur])<ans)
	{
		ans=make_pair(s, deep[cur]);
		solu=make_pair(root, cur);
	}
	int cnt=0;
	for (auto &to:out[cur])
		if (to!=fa[cur]) idx[++cnt]=to;
	le[1]=make_pair(0, 0);
	radle[1]=0;
	for (int i=2; i<=cnt; ++i)
	{
		le[i]=le[i-1];
		radle[i]=max(radle[i-1], rad[idx[i-1]]);
		if (f[idx[i-1]]+1>le[i].first)
		{
			le[i].second=le[i].first;
			le[i].first=f[idx[i-1]]+1;
		}
		else le[i].second=max(le[i].second, f[idx[i-1]]+1);
	}
	ri[cnt]=make_pair(0, 0);
	radri[cnt]=0;
	for (int i=cnt-1; i>0; --i)
	{
		ri[i]=ri[i+1];
		radri[i]=max(radri[i+1], rad[idx[i+1]]);
		if (f[idx[i+1]]+1>ri[i].first)
		{
			ri[i].second=ri[i].first;
			ri[i].first=f[idx[i+1]]+1;
		}
		else ri[i].second=max(ri[i].second, f[idx[i+1]]+1);
	}
	for (int i=1; i<=cnt; ++i)
	{
		g[idx[i]]=max(le[i].first, ri[i].first);
		h[idx[i]]=max(le[i].first+ri[i].first, max(le[i].first+le[i].second, ri[i].first+ri[i].second));
		h[idx[i]]=max(h[idx[i]], max(radle[i], radri[i]));
	}
	for (auto &to:out[cur])
		if (to!=fa[cur]) dfs2(to, max(past, max(h[to], chain+g[to])), max(chain, g[to]));
}
void solve()
{
	ans=make_pair(n*2, 0);
	for (int i=0; i<n; ++i)
	{
		root=i;
		dfs1(i, -1);
		dfs2(i, 0, 0);
	}
	printf("%d\n%d\n", ans.first, ans.second);
	if (ans.second) printf("%d %d\n", solu.first, solu.second);
}
int main()
{
	read();
	solve();
	return 0;
}