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-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
", 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))