Atcoder Grand Contest 009&010
009E Eternal Average
题目描述
解法
本题的操作是树形结构，所以我们可以直接去考虑最后的结果而不去考虑过程。
可以把操作看成一棵 \(k\) 叉树，叶子代表初始的数。设权值为 \(1\) 的点深度是 \(x_i\)，权值为 \(0\) 的点的深度是 \(y_i\)，那么根节点的数一定是 \(\sum k^{-x_i}\)，此外这棵树能构造出的充要条件是：\(\sum k^{-x_i}+\sum k^{-y_i}=1\)
原题自动机 \(\tt C202044zxy\) 提醒您，这里有一道结论一模一样的题目：To make 1
那么我们想在合法的基础上求出以 \(\sum k^{-x_i}\) 区分的方案数，这里我们尽量往数位 \(dp\) 的方向靠。主要问题是并不满足 \(0\leq x_i<k\) 的关键条件，我们尝试转化问题把这个关键条件给搞出来。
根据 \(1\) 的个数固定我们可以写出：\(\sum x_i=n\)，那么我们考虑进位之后的 \(x_i'\)，只要满足 \(\sum x_i'\leq n\and \sum x_i'=n\bmod (k-1)\) 就一定对应着一个原来的 \(x\) 序列，这样我们可以很方便的用 \(x\) 去做数位 \(dp\)
根据 \(0\) 的个数固定和总和为 \(1\) 我们可以写出：\(1+\sum_{i=1}^{len}(k-1-x_i)=m\)，设 \(t=(k-1)\cdot len-\sum x_i+1\)，那么做同样的转化可以得到 \(t\leq m\and t=m\bmod (k-1)\)
设 \(f[i][j][0/1]\) 表示考虑到第 \(i\) 位，\(\sum x_i=j\)，\(x_i=0/1\) 的方案数，由于我们要保证 \(len\) 才能判断上述条件，所以我们在保证 \(x_i=1\) 的情况下统计满足上述条件的方案数即可，时间复杂度 \(O(\frac{n^2}{k})\)
总结
这种操作之后除以某个数的题目通常有树形结构，通过树形结构可以导出一些结果向的结论。
本题的转化方便了数位 \(dp\)，这说明可以考虑进位之后的数列有什么性质，在原序列和新序列之间建立等价关系。
#include <cstdio>
const int M = 2005;
const int MOD = 1e9+7;
#define int long long
int read()
{
int x=0,f=1;char c;
while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
return x*f;
}
int n,m,k,ans,f[M<<1][M][2],g[M];
signed main()
{
n=read();m=read();k=read();
f[0][0][0]=1;
for(int i=1,up=(n+m-1)/(k-1);i<=up;i++)
{
g[0]=(f[i-1][0][0]+f[i-1][0][1])%MOD;
for(int j=1;j<=n;j++)
g[j]=(g[j-1]+f[i-1][j][0]+f[i-1][j][1])%MOD;
f[i][0][0]=g[0];
for(int j=1;j<=n;j++)
{
f[i][j][0]=(g[j]-g[j-1])%MOD;
f[i][j][1]=(g[j-1]-(j-k>=0?g[j-k]:0)+MOD)%MOD;
}
for(int j=1;j<=n;j++)
{
int t=1+(k-1)*i-j;
if(j%(k-1)==n%(k-1) && t<=m && t%(k-1)==m%(k-1))
ans=(ans+f[i][j][1])%MOD;
}
}
printf("%lld\n",ans);
}
010E Rearranging
题目描述
解法
这种确定顺序的题，常用的方法是思考不变的相对顺序。
本题我们观察到不互质的数一定不会被后手改变相对顺序，并且考虑到相对顺序通常是用图论来表示的，所以我们把不互质的数之间连一条边，这样会得到一个无向图。
因为互质数的相对顺序是可以任意改变的，先手决定的只有互质的数的相对顺序。考虑先手的功能是给无向图定向（若 \(i\rightarrow j\) 则表示 \(p_i<p_j\)，定向完一定是个拓扑图），后手的功能是给这个无向图定下字典序最大的拓扑序。
先手的定向具有固定策略，首先值最小的点一定作为第一个点，然后我们考虑和它相连边的方向都固定了。然后考虑把下一个位置优先给值更小的点 \(x\) ，发现此时我们可以把 \(x\) 当根，这是一个递归的过程：
void dfs(int u)
{
vis[u]=1;
for(int v=1;v<=n;v++)
if(!vis[v] && b[u][v])
g[u].pb(v),dfs(v);
}
我们只需要保留在 \(\tt dfs\) 树上的边（因为非树边对顺序没有更强的限制），这种方法为什么是正确的呢？我的理解是我们让值小点的位置尽量小，就使他处在偏序关系的上层，但如果子树间无关联那么顺序是任意的。
如果有更加理性的证明请联系我，上面的文字就是我的一些感性理解。
#include <cstdio>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;
const int M = 2005;
#define pb push_back
int read()
{
int x=0,f=1;char c;
while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
return x*f;
}
int n,a[M],b[M][M],vis[M];
priority_queue<int> q;vector<int> g[M],ans;
int gcd(int a,int b) {return !b?a:gcd(b,a%b);}
void dfs(int u)
{
vis[u]=1;
for(int v=1;v<=n;v++)
if(!vis[v] && b[u][v])
g[u].pb(v),dfs(v);
}
void topo()
{
while(!q.empty())
{
int u=q.top();q.pop();ans.pb(u);
for(int v:g[u]) q.push(v);
}
}
signed main()
{
freopen("rearranging.in","r",stdin);
freopen("rearranging.out","w",stdout);
n=read();
for(int i=1;i<=n;i++)
a[i]=read();
sort(a+1,a+1+n);
for(int i=1;i<=n;i++)
for(int j=i+1;j<=n;j++)
b[i][j]=b[j][i]=(gcd(a[i],a[j])>1);
for(int i=1;i<=n;i++) if(!vis[i])
q.push(i),dfs(i);
topo();
for(int x:ans) printf("%d ",a[x]);puts("");
}
009D Uninity
题目描述
解法
首先不难把题目转化为重构一棵点分树（但是并不是传统意义上的按重心划分），使得最大深度最小。因为这东西我都想得出来肯定很简单所以就不证明了，同时我们可以发现一个性质就是答案 \(\leq \log n\)（按传统点分树划分就可以得到上界）
考虑进一步转化，因为我们想在固定结构上规划。考虑点分树是可以和路径表示法互化的，那么我们可以把题意转化成给每个点定一个标号 \(\tt label\)，使得最后任意两个 \(\tt label\) 相等的点树上路径（原树）存在点的 \(\tt label\) 大于它。证明这个转化是很简单的，也就是考虑这两点同层，那么路径一定会过点分树的某个根，而根的 \(\tt label\) 大于它就是合法点分树。
那么可以在原树上规划 \(\tt label\)，设 \(g[u]\) 表示子树 \(u\) 中未解决的 \(\tt label\) 集合状压起来的值（因为答案 \(\leq \log n\) 所以存得下 ），注意这里如果子树内某个点 \(v\) 到 \(u\) 的路径上存在 \(label[x]>label[v]\) 就视为 \(v\) 已解决。
那么我们考虑合并子树的过程中会新增多少限制，发现就是位运算取并，我们再把取并的结果或起来就得到了总的限制。那么首先这个点的 \(\tt label\) 必须要足够大，此外不能和子树中未解决点的 \(\tt label\) 相同（要不然就直接不合法了）
实现就暴力增大 \(\tt label\)，时间复杂度 \(O(n\log n)\)，本题最后的做法本质上是一个树上延迟贪心模型。
总结
规划问题中，把动态结构转化成固定结构可以用标号法，要求 \(\tt label\) 可以充分描述动态结构的性质。
//The second I waste is more than I can take.
#include <cstdio>
#include <iostream>
using namespace std;
const int M = 100005;
int read()
{
int x=0,f=1;char c;
while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
return x*f;
}
int n,tot,ans,f[M],g[M];
struct edge{int v,next;}e[M<<1];
void dfs(int u,int fa)
{
int s=0,dp=0;
for(int i=f[u];i;i=e[i].next)
{
int v=e[i].v;
if(v==fa) continue;
dfs(v,u);s|=g[u]&g[v];g[u]|=g[v];
}
while(s) dp++,s>>=1;
while(g[u]&(1<<dp)) dp++;
g[u]=((g[u]>>dp)|1)<<dp;
ans=max(ans,dp);
}
signed main()
{
n=read();
for(int i=1;i<n;i++)
{
int u=read(),v=read();
e[++tot]=edge{v,f[u]},f[u]=tot;
e[++tot]=edge{u,f[v]},f[v]=tot;
}
dfs(1,0);
printf("%d\n",ans);
}
