GDCPC2016题解 by lby@SYSU | Asiimov
Problem A. ABCD
题目大意
给出一个四边形四条边 AB、CD、AD、BC 及两条对角线 AC、BD 的长度，问这个四边形的顶点能否在一个圆上
算法思路
通过余弦定理考察 ∠ACB 与 ∠ADB 是否相等即可。
时间复杂度: O(1)
代码
/**
* Copyright © 2016 Authors. All rights reserved.
*
* FileName: A.cpp
* Author: Beiyu Li
* Date: 2016-05-09
*/
#include
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define For(i,s,t) for (int i = (s); i <= (t); ++i)
#define foreach(i,c) for (__typeof(c.begin()) i = c.begin(); i != c.end(); ++i)
typedef long long LL;
typedef pair<int, int> Pii;
const int inf = 0x3f3f3f3f;
const LL infLL = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-10;
int sgn(double x) { return x < -eps? -1: x > eps; }
inline double cosf(double a, double b, double c)
{ return (a * a + b * b - c * c) / (2 * a * b); }
int main()
{
int T, cas = 0;
scanf("%d", &T);
while (T--) {
int ab, cd, ad, bc, ac, bd;
scanf("%d%d%d%d%d%d", &ab, &cd, &ad, &bc, &ac, &bd);
printf("Case #%d: %s\n", ++cas, !sgn(cosf(ac, bc, ab)
- cosf(ad, bd, ab))? "Yes": "No");
}
return 0;
} Problem B. Bob’s magical number
题目大意
构造一个 N 个点，每个点度数都为3的无向图
算法思路
N<4 时无解
由于共有 3N2 条边，故 N 为奇数时一定无解
N 为偶数时将所有点连成环，再将对称点连起来即可
时间复杂度: O(N)
代码
/**
* Copyright © 2016 Authors. All rights reserved.
*
* FileName: B.cpp
* Author: Beiyu Li
* Date: 2016-05-09
*/
#include Problem C. Color
题目大意
用K种颜色对长度为N的环涂色，问考虑旋转同构下本质不同的涂色方案有多少种
算法思路
由Pólya定理可知，答案等于 ∑i=1Nkgcd(i,N)
对于 d=gcd(i,N) ， kd 项共有 φ(Nd) 个
所以上式化简为 ∑d|Nφ(Nd)kd
时间复杂度: O(N‾‾√)
代码
/**
* Copyright © 2016 Authors. All rights reserved.
*
* FileName: C.cpp
* Author: Beiyu Li
* Date: 2016-05-09
*/
#include Problem D. Dilettante
题目大意
问用 1×1×1×2 的四维块在可以旋转的情况下填充 2×2×4×n 四维空间的方案数，答案取模 1000000007
算法思路
将最后一维当作时间考虑可以发现，在某一时刻，前三维构成 2×2×4 的 0/1 状态立方体
对于每次转移，要么将两个相邻的0置1，要么将状态取反后到达下一时刻
我们可以先预处理构成某个状态的方案数 f[S]
对于第一种转移， S→T 的转移系数为 f[T−S]
考虑相邻时刻的转移， S→T 的转移系数为 f[T′−S] ，其中 T′ 表示 T 置反
当然，实际情况中我们枚举 S 的补集的子集 t ，由 S 转移到 (S+t)′
上面的DP已经可以算出正确答案，但状态 S 有 216 种，而 n 更是达到 109
考虑对于某个状态，可以通过旋转/对称进行归类
再考察初始状态能到达的状态，我们得到有效状态只有997个，但仍然无法用矩阵快速幂求解
通过某种方式可以证明（然而我并不懂），答案是关于 n 前面 M=921 项的递推式
即 an=k1×an−1+k2×an−2+...+kM×an−M
我们可以用上面的方法暴力算出前 2M 项结果，通过高斯消元得出递推系数
通过 init() 函数打表保留前 M 项答案数组 a[] 及递推系数数组 k[]
后面由于是常系数齐次线性递推关系，可以用叉姐论文《线性递推关系与矩阵乘法》中的方法求解
时间复杂度: O(M2logN)
代码
/**
* Copyright © 2016 Authors. All rights reserved.
*
* FileName: D.cpp
* Author: Beiyu Li
* Date: 2016-05-09
*/
#include if (j < 1 && (~S & (4 << p))) f[S|5<if (i < 1 && (~S & (2 << p))) f[S|3<// calc transfer coefficient of normalized states
rep(i,tot) {
int S = sta[i] ^ ALL;
for (int T = S;; T = (T - 1) & S) {
if (~id[T]) t[i][id[(sta[i]|T)^ALL]] += f[T];
if (!T) break;
}
}
// keep states which can be reached from state 0
vis[0] = true, que[tail++] = 0;
while (head < tail) {
int i = que[head++];
rep(j,tot) if (t[i][j] && !vis[j])
vis[j] = true, que[tail++] = j;
}
// calc coefficient matrix of gauss
g[1][0] = 1;
rep(i,m*2) {
int o = i & 1;
memset(g[o], 0, sizeof(g[o]));
rep(j,tail) rep(k,tail) g[o][j] = (g[o][j] +
(LL)(g[o^1][k] * t[que[k]][que[j]])) % mod;
if (i <= m) {
A[0][i] = g[o][0];
} else {
rep(j,m) A[i-m][j] = A[i-m-1][j+1];
A[i-m][m] = g[o][0];
}
}
assert(~gauss(A, m, r));
FILE *fout = fopen("D.arg", "w");
rep(i,m) fprintf(fout, "%s%d", i? ", ": "int a[] = {", A[0][i]);
fprintf(fout, "};\n");
rep(i,m) fprintf(fout, "%s%d", i? ", ": "int k[] = {", r[m-i-1]);
fprintf(fout, "};\n");
fclose(fout);
}
void multiply(int u[], int v[])
{
static int t[maxm*2];
memset(t, 0, sizeof(t));
rep(i,m) rep(j,m) t[i+j] = (t[i+j] + (LL)u[i] * v[j]) % mod;
for (int i = 2 * m - 2; i >= m; --i) {
rep(j,m) t[i-j-1] = (t[i-j-1] + (LL)k[j] * t[i]) % mod;
t[i] = 0;
}
memcpy(u, t, sizeof(t));
}
int calc(int n)
{
static int u[maxm*2], v[maxm*2];
memset(u, 0, sizeof(u)), u[0] = 1;
for (int p = 1; n; p <<= 1, n >>= 1) {
if (p < m) memset(v, 0, sizeof(v)), v[p] = 1;
else multiply(v, v);
if (n & 1) multiply(u, v);
}
int ret = 0;
rep(i,m) ret = (ret + (LL)u[i] * a[i]) % mod;
return ret;
}
int main()
{
int T, cas = 0;
scanf("%d", &T);
// init();
while (T--) {
int n;
scanf("%d", &n);
printf("Case #%d: %d\n", ++cas, calc(n - 1));
}
return 0;
} Problem E. Expectation
题目大意
对于初始为0的 2×n 矩阵，每次随机选择一个子矩阵置1，问将整个矩阵全部置为1的期望步数
算法思路
首先想到，最终的期望等于每一步失败概率的累加和
考虑用二进制表示当前矩阵的状态，其中全为1的子矩阵个数为k，0的个数为 o
如果要保证该状态不变，则每次只能选择这k个子矩阵中的某个涂色，概率 p=k3n(n+1)/2
由容斥原理，该状态对于失败概率的贡献为 ∑i=1∞pi(−1)o−1=11−p(−1)o−1 ，也是对最后期望的贡献
不难发现，对结果有影响的只有 k 和 o ，可以将状态合并起来
令 f[i][u][v][k][o] 表示前 i 列，第一行末尾有 u 个1，第二行末尾有 v 个1，其中有 k 个全1的子矩阵，0个数奇偶性为 o 的状态有多少个
则向 i+1 列添加0/1时有4种方案，分别转移即可
计算答案时枚举某一列存在0的状态，令后面的列全为1，重新计算 k 的值及概率 p
根据 o 的奇偶性对答案进行贡献即可
时间复杂度: O(n3×3n(n+1)2×8)
代码
/**
* Copyright © 2016 Authors. All rights reserved.
*
* FileName: E.cpp
* Author: Beiyu Li
* Date: 2016-05-10
*/
#include Problem F. Fee
题目大意
有 N 个人，每个人有一定的存款，他们想通过转账让所有人最后的钱相等
转账时银行按比例收取手续费，问最后每个人最多能有多少钱
算法思路
二分答案，考察超过 mid 的钱在交付手续费后能否填补不够 mid 的钱
时间复杂度: O(NlogV)
代码
/**
* Copyright © 2016 Authors. All rights reserved.
*
* FileName: F.cpp
* Author: Beiyu Li
* Date: 2016-05-10
*/
#include Problem G. Game
题目大意
Alice和Bob玩游戏，Bob有一个可以按照设定的概率随机输出 1 到 N 的生成器，而Alice知道设定的概率
如果Alice猜对生成的数，则Alice赢1元钱
如果Alice猜的是生成的数减1，则Bob赢1元钱
问Bob在设置最优的概率，同时Alice选择最优策略的条件下，Alice赢钱的期望为多少
算法思路
若生成器输出 i 的概率为 Pi ，则Alice猜 i 时赢钱的期望为 Pi−Pi+1 ，其中 PN+1 为0
显然Alice会选择概率下降最大的数，而Bob则要最小化这一值
不难发现，当所有概率下降的值相同，即 Pi 数列构成等差数列时，这一值最小
通过方程解得，答案为 2N(N+1)
时间复杂度: O(1)
代码
/**
* Copyright © 2016 Authors. All rights reserved.
*
* FileName: G.cpp
* Author: Beiyu Li
* Date: 2016-05-10
*/
#include
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define For(i,s,t) for (int i = (s); i <= (t); ++i)
#define foreach(i,c) for (__typeof(c.begin()) i = c.begin(); i != c.end(); ++i)
typedef long long LL;
typedef pair<int, int> Pii;
const int inf = 0x3f3f3f3f;
const LL infLL = 0x3f3f3f3f3f3f3f3fLL;
int main()
{
int T, cas = 0;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
printf("Case #%d: %.6f\n", ++cas, 2.0 / n / (n + 1));
}
return 0;
} Problem H. Heresy
题目大意
输入 n 、 m ，求
∑i=1n∑j=1mi2j2gcd(i,j)
取模1000000007的值
算法思路
换个方向思考，先枚举 gcd(i,j) 的值 g ，则上式等于
∑g∑i=1ng∑j=1mgi2j2g5(gcd(i,j)==1)
其中的 gcd(i,j)==1 可使用莫比乌斯函数做容斥，即等于
∑g∑d∑i=1ng×d∑j=1mg×di2j2g5d4μ(d)
令 D=g×d 可得，上式等于
∑D∑d|D∑i=1nD∑j=1mDi2j2D5dμ(d)
提取得
∑DD5∑d|Dμ(d)d∑i=1nDi2∑j=1mDj2
至此，我们可以先对每个 D 进行预处理，得到
fD=D5∑d|Dμ(d)d
对于每组询问，由于 ND 与 MD 的值只有根号级别的个数
可以通过上述值的变化枚举 D ，将 fD 区间和与 i 、 j 平方和的乘积加到答案中即可
时间复杂度: O(NlogN+T×(N‾‾√+M‾‾√))
代码
/**
* Copyright © 2016 Authors. All rights reserved.
*
* FileName: H.cpp
* Author: Beiyu Li
* Date: 2016-05-10
*/
#include Problem I. International Morse Code
题目大意
输入 N 个单词，输出对应摩尔斯电码的按键状态，其中
“点”按1单位时间
“线”按3单位时间
元素间空1个单位
字母间空3个单位
单词间空7个单位
按下输出’=’，空白输出’.’
算法思路
按照上面说的模拟…
时间复杂度: O(N)
代码
/**
* Copyright © 2016 Authors. All rights reserved.
*
* FileName: I.cpp
* Author: Beiyu Li
* Date: 2016-05-10
*/
#include Problem J. Just another binary tree
题目大意
问大小为 N 的堆中序遍历后排第 k 的节点编号
算法思路
DFS
对于某棵子树计算其左子树的大小
与当前的k比较以选择进入的分支
进入右子树时注意更新k的值
时间复杂度: O(log2N)
代码
/**
* Copyright © 2016 Authors. All rights reserved.
*
* FileName: J.cpp
* Author: Beiyu Li
* Date: 2016-05-10
*/
#include
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define For(i,s,t) for (int i = (s); i <= (t); ++i)
#define foreach(i,c) for (__typeof(c.begin()) i = c.begin(); i != c.end(); ++i)
typedef long long LL;
typedef pair<int, int> Pii;
const int inf = 0x3f3f3f3f;
const LL infLL = 0x3f3f3f3f3f3f3f3fLL;
int dfs(int v, int n, int k)
{
int p = 1;
while (p * 2 <= n) p *= 2;
int l = p / 2 - 1 + min(n - (p - 1), p / 2);
if (n == 1 || k == l + 1) return v;
return k <= l? dfs(v * 2, l, k): dfs(v * 2 + 1, n - l - 1, k - l - 1);
}
int main()
{
int T, cas = 0;
scanf("%d", &T);
while (T--) {
int n, k;
scanf("%d%d", &n, &k);
printf("Case #%d: %d\n", ++cas, dfs(1, n, k));
}
return 0;
} Problem K. Kay’s function
题目大意
f[0]=a
f[1]=b
f[n]=f[n−1] xor f[n−2]
输入 a 、 b 、 n ，输出 f[n]
算法思路
显然这个序列由 a,b,a xor b,... 不断循环构成，故输出 f[n mod 3] 即可
时间复杂度: O(1)
代码
/**
* Copyright © 2016 Authors. All rights reserved.
*
* FileName: K.cpp
* Author: Beiyu Li
* Date: 2016-05-10
*/
#include
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define For(i,s,t) for (int i = (s); i <= (t); ++i)
#define foreach(i,c) for (__typeof(c.begin()) i = c.begin(); i != c.end(); ++i)
typedef long long LL;
typedef pair<int, int> Pii;
const int inf = 0x3f3f3f3f;
const LL infLL = 0x3f3f3f3f3f3f3f3fLL;
int main()
{
int T, cas = 0;
scanf("%d", &T);
while (T--) {
int n, f[3];
scanf("%d%d%d", &f[0], &f[1], &n);
f[2] = f[0] ^ f[1];
printf("Case #%d: %d\n", ++cas, f[n%3]);
}
return 0;
}