2018 CCPC网络赛

Buy and Resell

题目描述：有一种物品，在$n$个地点的价格为$a_i$，现在一次经过这$n$个地点，在每个地点可以买一个这样的物品，也可以卖出一个物品，问最终赚的钱的最大值。

solution

用两个堆来维护，一个堆维护已经找到卖家的，一个堆维护还没找到卖家的。

对于第$i$个地点，在已经找到卖家的堆里找出卖的钱的最小值，如果最小值小于$a_i$，则将卖家换成$i$，然后将原来的卖家放到没找到卖家的那里；如果最小值对于$a_i$，那就在还没找到卖家的那里找出最小值，然后跟$i$配对放到已经找到卖家那个堆。

其实第二个不用堆存也可以，因为它肯定是递减的，所以用栈即可。

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

Congruence equation

Dream

题目描述：重新定义$p$以内的数互相相加的和以及互相相乘的积，使得$\forall m, n<p, (m+n)^p=m^p+n^p$

solution

二项式定理展开，将组合数写成阶乘的形式，发现中间每个组合数都是$p$的倍数，因此只要将加法和乘法定义成模$p$意义下的答案即可。

时间复杂度：$O(p^2)$

Find Integer

题目描述：给定$n, a$，求$a^n+b^n=c^n$的一个解，或无解。

solution

根据费马定理，$n>2$时无解，当$n=2$时，若$a=2n$,则$(2n^2-1)^2+a^2=(2n^2+1)^2$

若$a=2n+1$，则$(2n^2)^2+a^2=(2n^2+1)^2$

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

GuGu Convolution

题目描述：

solution

题目等价于求

\[n!\sum_{i=0 (n-i)为奇数}^{n} \frac{1}{i!(n-i)!}A^i \sqrt{B}^{n-i}
\]

整理一下

\[\sum_{i=0 (n-i)为奇数}^{n} C_n^iA^i \sqrt{B}^{n-i}
\]

如果不管$(n-i)$为奇数，则原式等于$(A+\sqrt{B})^n$，因为只取$(n-i)$为奇数的结果，相当于是求$\sqrt{B}$的系数，因此用一个快速幂来求解即可。

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

Neko's loop

题目描述：有一个环，上面有$n$个点，每个点有一个权值$a_i$。选择一个点当作出发点，每移动一次向前跳$k$个点，每经过一个点可以得到该点的权值（可重复），问最多经过$m$个点时，得到总权值的最大值。

solution

原图被分成了$gcd(n, k)$个环，如果环是正环，则尽量走整个环走，只剩下最后一个整环和剩余的步数（假设为$rest$)，然后把环复制两次，求前缀和，用单调队列求出长度不超过$rest$的区间的和的最大值。

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

Search for Answer

题目描述：给定一个竞赛图，有些边的方向需要确定，确定后，计算图对应的一个价值：对于图中的四个点，如果它们按顺序指向下一个点，则答案加一，若指向是交替的，则答案减一，求答案的最大值。

solution

对于四个点，有以下三种情况：

按顺序指向下一个点，则每个点的出度都是$1$
指向交替，则有两个点的出度为$2$
其它情况，有一个点的出度为$2$

先假设所有的点的四元组都是按顺序指向下一个点的，则答案为$A_n^4$，对于度大于等于$2$的点，从中选择两个点作为它指向的点，然后随便再找一个点凑成一个四元组，这样有$A_{deg}^{2}(n-3)$中选择，这种情况是会使答案不能加一的，如果同一个四元组被选择了两次，就相当于是第二种情况，会使答案减一，所以最后的答案为$A_n^4-\sum A_{deg}^2(n-3)*4$($4$为一个点在四元组中有$4$个位置可以选，一旦选了，其它的点的位置就确定了)

后边的部分可以用费用流来求，可以对$C_{deg}^2$进行差分，每差分一次建一条新边，费用为差分出来的值，又因为差分的值是递增的，所以就能计算$C_{deg}^2$的值。

时间复杂度：$O(费用流)$

#include <bits/stdc++.h>

using namespace std;

const int maxn=205;

const int inf=0x3fffffff;

struct LINK

{

	int id, next, flow, cost;

};

int n, now, TT;

int ans;

int degree[maxn], cnt[maxn];

int h[maxn*2];

LINK t[maxn*maxn*8];

int f[maxn*2], fa[maxn*2], q[maxn*2];

bool vis[maxn*2];

void join(int u, int v, int fl, int c)

{

	t[now].id=v; t[now].next=h[u]; t[now].cost=c; t[now].flow=fl; h[u]=now++;

	t[now].id=u; t[now].next=h[v]; t[now].cost=-c; t[now].flow=0; h[v]=now++;

}

void build()

{

	scanf("%d", &n);

	now=0;

	for (int i=0; i<=n; ++i)

	{

		h[i]=-1;

		degree[i]=cnt[i]=0;

	}

	TT=n;

	for (int i=1; i<=n; ++i)

		for (int j=1; j<=n; ++j)

		{

			int d;

			scanf("%1d", &d);

			if (d==1) ++degree[j];

			else if (d==2 && i<j)

			{

				++cnt[i];

				++cnt[j];

				h[++TT]=-1;

				join(TT, i, 1, 0);

				join(TT, j, 1, 0);

			}

		}

	for (int i=n+1; i<=TT; ++i) join(0, i, 1, 0);

	h[++TT]=-1;

	ans=0;

	for (int i=1; i<=n; ++i)

	{

		ans+=degree[i]*(degree[i]-1)/2;

		for (int j=1; j<=cnt[i]; ++j)

			join(i, TT, 1, degree[i]+j-1);

	}

}

bool SPFA()

{

	int head=0, tail=0;

	for (int i=0; i<=TT; ++i)

	{

		vis[i]=false;

		f[i]=inf;

		fa[i]=-1;

	}

	q[0]=0;

	f[0]=0;

	while (head<=tail)

	{

		int cur=q[(head++)%(TT+1)];

		vis[cur]=false;

		for (int i=h[cur]; i>-1; i=t[i].next)

			if (t[i].flow && f[cur]+t[i].cost<f[t[i].id])

			{

				f[t[i].id]=f[cur]+t[i].cost;

				fa[t[i].id]=i;

				if (!vis[t[i].id])

				{

					vis[t[i].id]=true;

					q[(++tail)%(TT+1)]=t[i].id;

				}

			}

	}

	return (f[TT]<inf);

}

void modify()

{

	ans+=f[TT];

	int cur=TT;

	while (cur)

	{

		t[fa[cur]].flow--;

		t[fa[cur]^1].flow++;

		cur=t[fa[cur]^1].id;

	}

}

void solve()

{

	while (SPFA()) modify();

	ans=n*(n-1)*(n-2)*(n-3)-ans*(n-3)*8;

	printf("%d\n", ans);

}

int main()

{

	int casesum;

	scanf("%d", &casesum);

	while (casesum--)

	{

		build();

		solve();

	}

	return 0;

}

Tree and Permutation

题目描述：给定一个树，有$n$个点，对于每一个$n$排列，求出排列中相邻两个数在树上的距离的和，作为排列的值，求所有排列的值的和。

solution

可知每个数对在所有排列中共出现$(n-1)!$次，所以每个数对的距离贡献了$(n-1)!$次。问题转化为求树上两两之间的距离的和。可以算出每条边对答案的贡献，贡献为这条边分割的两部分互相配对形成的点对数。

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

YJJ's Salesman

题目描述：在一个二维平面，有一些点$(x, y)$拥有开心值，当从$(x-1, y-1)$走到$(x, y)$时，就能拿到这个点的开心值，现在从原点出发，每次只能从$(x, y)$走到$(x+1, y), (x, y+1), (x+1, y+1)$，问能获得的总的开心值的最大值。

solution

$dp$，按$x$坐标对点排序，从小到大进行$dp$，$y$坐标用树状数组维护对应的最大值。

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