[SinGuLaRiTy] NOIP模拟题 by liu_runda
【SinGuLaRiTy-1046】 Copyright (c) SinGuLaRiTy 2017. All Rights Reserved.
|
题目名称 |
兔子 |
被子 |
蚊子 |
|
源程序文件名 |
rabbit.cpp |
quilt.cpp |
mosquito.cpp |
|
每个测试点时限 |
1s |
1s |
5s |
|
内存限制 |
512MB |
512MB |
512MB |
|
是否打开O2优化 |
否 |
否 |
否 |
兔子(rabbit)
题目描述
做一只明媚的兔子…
兔子都比较喜欢蹦蹦跳跳.但是蹦蹦跳跳的时候如果一直往高处跳的话就太累了,如果一直往低处跳的话就太无聊了.所以兔子希望跳的时候能够往上跳一步,往下跳一步,往上跳一步,往下跳一步….一共经过n个高度互不相同的位置(只要向上跳和向下跳相间分布就可以了,第一步可以往上跳也可以往下跳).如果下一个位置的高度比前一个位置高,就是往上跳,比前一个位置低,就是往下跳.
兔子今天又蹦蹦跳跳依次经过了n个位置.现在它想知道经过的n个位置的高度有多少种不同的可能.
我们认为n个位置的高度形成了1到n的一个排列,这个排列要么满足奇数项的高度比相邻位置都大, 要么满足偶数项的高度比相邻位置都大.
n=1时,有1种可能,就是这1个位置的高度为1
n=2时,有2种可能,可以是(1,2)或(2,1)
n=3时,有4种可能,(1,3,2) (2,3,1),(2,1,3),(3,1,2)
答案可能很大,只需要输出答案对mod取模的结果.
输入格式
一行两个整数n,mod.
输出格式
一行一个整数ans,表示所有可能的排列数目对mod取模后的结果.
样例数据
| 样例输入1 | 样例输出1 |
|
3 1000000007 |
4 |
| 样例输入2 | 样例输出2 |
|
12 345 |
70 |
| 样例输入3 | 样例输出3 |
|
233 666 |
122 |
| 样例输入4 | 样例输出4 |
|
2000 2000 |
1250 |
<数据范围>
第1,2个测试点,5<=n<=10
第3,4个测试点,11<=n<=13
第5,6,7个测试点,14<=n<=16
第8,9个测试点,100<=n<=200
第10个测试点,n=2000
对于所有测试点,mod在int范围内
解析
听说是某年的省选题......
首先晒一晒DP方程：
f[i][j]=f[i][j-1]+f[i-1][i-j]
f[i][j]表示的是一个长度为i的路径，出发点(强制是高处)取[1,j]的方案数。
在这个状态转移方程中，最重要的就是怎么求出出发点为j时的方案数。
事实上，由于在之前我们已假设出发点为高处，那么我们只需要计算 出发点取[1,j-1]且为低处，路径长度为i-1 时的方案数，这就是g[i-1][j-1]
由于我们在最开始就已经强制出发点为高处，其余的方案都可以通过取反来得到。对于一个长度为i的路径，若将每一个节点ti变为i-ti+1，我们就自然可以得到一个相反的、一一对应的数列。
由此导出f[i][j]=g[i][i-j+1]，于是有g[i-1][j-1]=f[i-1][i-j]。
当然，g[i-1][j-1]=f[i-1][i-j]，这样一个式子中是有可能出现j的，因此我们要稍稍处理一下：将g[i-1][j-1]中大于等于j的数字加1，这样得到的就一定是一个合法的、一一对应的序列。
Code
#include<cstdio> #include<cstring> #include<iostream> using namespace std; int f[2][2010]; int main() { int n,p; scanf("%d%d",&n,&p); if(n==1) { printf("1\n"); return 0; } int now=0; f[0][1]=1; for(int i=2;i<=n;i++) { now^=1; for(int j=1;j<=i;j++) { f[now][j]=f[now][j-1]+f[now^1][i-j]; f[now][j]%=p; } } printf("%d",f[now][n]*2%p); return 0; }
被子(quilt)
题目描述
作为一只明媚的兔子,需要学会叠被子…
被子是方形的,上面有很多小写字母.可以认为被子是一个n*m的字符矩阵
被子能够被叠起来,当且仅当每一行,每一列都是回文串.
兔子可以把同一条被子上任意两个位置的字母交换位置,而且兔子不嫌麻烦,为了把被子叠起来它愿意交换任意多次.但是兔子不能交换两条不同的被子之间的字母.
现在兔子翻箱倒柜找出来了很多被子,请你帮兔子判断每条被子能否被叠起来.
输入格式
第一行一个Q,表示被子的条数
接下来描述Q条被子.
描述每条被子时,第一行输入两个整数n,m表示由n行m列组成
接下来n行每行一个长度为m的字符串.字符串中只含小写字母.
输出格式
Q行,依次输出对每条被子的判断结果.如果可以叠起来,输出一行“Yes”(不包括引号),如果叠不起来,输出一行“No”(不包括引号).
样例数据
| 样例输入 | 样例输出 |
|
5 |
Yes |
<数据范围>
第1,2个测试点,n*m<=10
第3,4个测试点,n=1
第5个测试点,n=2
第6个测试点,n,m均为偶数
第7,8,9,10个测试点,捆绑测试,无特殊限制.只有通过这全部4个测试点才能拿到这4个测试点的分数.
所有测试点,保证Q<=10,n,m<=200
解析
我们可以这样理解这个问题：给出一个表格和每一种字母的数量，我们要将这些字母放到表格里面去，使这个表格满足每行每列对称。
注意到题目中有“交换任意多次”，再结合数据范围(看看这些东西的确有好处)中关于m,n奇偶性的限制，我们可以得到一个大概的方向：若将这块被子分为如Fig.1所示的四块相等的区域，只要每一块里面的同类字母数能够保证相等，我们就能够说这是一块可以被叠起来的被子。
Fig.1
换一种说法，如果每一种字母的数量An都满足An%4==0，那么就可以输出"Yes"了。(因为这是一只勤奋的兔子，它可以无限次地交换字母，我们就可以仅仅考虑字母的数量)
但是，事实上问题还要复杂那么一丢丢~
我们刚刚的思路只是最简单的一种情况，在有些情况下，即使An%4!=0，这块被子也是可以被叠起来的。让我们来更系统地讨论一下：
1>就是我们刚刚讨论的都满足An%4==0的情况，这种情况的答案一定是"Yes"的。
2>若存在An%4==2，当且仅当被子存在一条对称轴，那么我们就可以将这两个多出来的安排在这条对称轴上，使其满足题目的条件，如Fig.2。(当然，如果放满了，那就只有输出"No"了，下同)
Fig.2 容易发现，只要对称轴两边已经对称，那么无论对称轴里面放了什么字母，这一行都一定是对称的，若其它列都已经对称状态，我们只需要保证对称轴本身对称就可以了
3>若存在An%4==1，当且仅当被子存在对称中心，我们就可以将这一个多出来的放在对称中心那里,如Fig.3。
Fig.3
4>若存在An%4==3，当且仅当被子存在对称中心(此时一定有两条对称轴)，我们就可以将一个放在对称中心处，另外两个放在对称轴上，如Fig.3。
Code
#include<cstdio> #include<cstring> #include<iostream> #include<algorithm> #include<cstdlib> using namespace std; char s[210]; int n,m,sta[30]; int Q; int main() { scanf("%d",&Q); while(Q--) { memset(sta,0,sizeof(sta)); scanf("%d%d",&n,&m); bool flag=true; for(int i=1;i<=n;i++) { scanf("%s",s); for(int j=0;j<m;j++) sta[s[j]-'a']+=1; } //Judge the width and the length of this quilt if(n%2==0&&m%2==0) /*If both width and length can be divided by 2,this means that the quilt has no 对称轴 or 对称中心 and each of the letter should appeared for 4(or 8,16,etc) times.*/ { for(int i=0;i<26;i++) if(sta[i]%4!=0) { flag=false; break; } } else if(n%2==0&&m%2==1) /*If the width can be divided by 2,this means that the quilt has one 对称轴, and if there is more of a letter,the letter should be placed here.*/ { int cnt=0,tot=0; for(int i=0;i<26;i++) { tot+=sta[i]%4; if(sta[i]%4==1||sta[i]%4==3) cnt++; } if(cnt>0||tot>n) flag=false; } else if(n%2==1&&m%2==0) /*This kind of situation is totally same as last one. Ctrl+C~*/ { int cnt=0,tot=0; for(int i=0;i<26;i++) { tot+=sta[i]%4; if(sta[i]%4==1||sta[i]%4==3) cnt++; } if(cnt>0||tot>m) flag=false; } else if(n%2==1&&m%2==1) { /*Well ,this kind of situation is similar with last two situations:the only difference is that the container is larger.*/ int cnt=0,tot=0; for(int i=0;i<26;i++) { tot+=sta[i]%4; if(sta[i]%4==1||sta[i]%4==3) cnt++; } if(cnt>1||tot>=m+n) flag=false; } if(flag==true) printf("Yes\n"); else printf("No\n"); } return 0; }
蚊子(mosquito)
题目描述
作为一只明媚的兔子,要会叠被子,又得会打蚊子…
兔子住在兔子洞里.兔子洞可以看成是一棵无根树,有 n 个洞穴,有 n-1 条通道连接着 n 个洞穴.
每天晚上,兔子会在 1 号洞穴里缩成一团,睡一觉.同时,蚊子大军出动,去欺负兔子.
因为蚊子人多势众,所以它们分兵 m*(m-1)路.m 是整个兔子洞中只和一条通道相邻 的洞穴数目.任意两个这样的洞穴 a,b 之间(也就是任意两个叶子节点之间)会有两只蚊 子,一只从 a 飞到 b,一只从 b 飞到 a.它们都沿着 a 到 b 的最短路径移动.蚊子每秒钟可以通过一条通道.所有蚊子都在 0s 时突然出现在起点并开始移动.每只蚊子在到达终点后 的一瞬间都会突然消失.有些蚊子并不会经过兔子所在的 1 号节点,它们起到的是恐吓作用.
又一次满脸是包地醒来后,兔子忍无可忍了,于是它找到 liu_runda 让 liu_runda 去打 蚊子…liu_runda 不知所措,于是去某宝搞了一个灭蚊器…这个灭蚊器被放在 1 号节点.每 个时刻,它都会工作一次,把和灭蚊器距离小于等于 d 范围内的蚊子全部杀死.(d=0 时只 能控制 1 号点一个位置)
遗憾的是,兔子洞尚未通电,兔子只能用爱发电. 因此,每个时刻灭蚊器只有 p/q 的概 率能够正常工作.如果不能正常工作,那么蚊子将不受到任何影响.
灭蚊器无法影响出现之前和消失之后的蚊子.但在蚊子出现在起点和消失在终点的 那个时刻,如果灭蚊器正常工作且蚊子在作用范围内,这只蚊子仍会被杀死.、
兔子对 liu_runda 的诚意表示怀疑…于是它让 liu_runda 算出灭蚊器在一晚上期望能杀死多少蚊子. liu_runda 当然会算了,但是他想考考你.
因为兔子讨厌小数,你需要输出这个期望值模 10^9+7 后的结果.即:如果期望值可以表示成有理数 a/b(a,b 为整数),你需要输出 a*b-1 mod 1000000007(10^9+7)的值.
(如果你算错了,就会被 liu_runda 拿去喂兔子,啊呜~~)
输入格式
第一行一个整数 n,表示兔子洞中洞穴的个数.洞穴编号为 1 到 n 的整数.
接下来 n-1 行,每行两个整数 u,v,表示 u 和 v 两个洞穴之间有一条通道.
接下来一行三个整数 d,p,q,表示灭蚊器的作用范围是 d,每个时刻工作的概率是 p/q.
输出格式
一行一个整数 ans,表示期望模 10^9+7 的值.
样例数据
| 样例输入 | 样例输出 |
|
3 |
750000007 |
<样例解释>
共有 2 只蚊子,一只从 2 飞到 3,一只从 3 飞到 2.灭蚊器的作用范围是 1,那么三个点都在作用范围内,每个蚊子会有三个时刻在作用范围内,那么每只蚊子生还的概率都是 1/8,经过计算,我们期望能够打死 7/4 只蚊子,说明 liu_runda 提供的灭蚊器是比较靠谱的.我们输出 7*4-1mod1000000007 的值 750000007.
<数据范围>
记 m 为叶子节点的个数.
对于第 1 个测试点,n=300
对于第 2,3 个测试点,n=3000
对于第 4 个测试点,d=0,n=100000
对于第 5 个测试点,p/q=1,n=100000
对于第 6,7 个测试点n=5000000,m<=500
对于第 8,9,10 个测试点,n=5000000
对于所有测点,m < n<=5000000,0<=d<=n,1<=p<=q<=10^9+7 保证 1 号节点至少和两条通道相连.
解析
考虑每只蚊子的贡献是1-(1-p/q)^k（k是有效的时间）
我们可以先把后面的(1-p/q)^k的和求出来，最后用m*(m-1)减去那个和就可以了
一条路径可以在LCA处拆成两条，我们考虑如何求出以某个点为LCA的所有路径的贡献之和
一条路径可以拆成两部分，一部分是从一个叶节点走到LCA，另一部分是从LCA走到另一个叶节点，把这两部分看作两条“半路径”
记g[i]为以i为LCA的所有半路径的贡献之和，对于i子树内的每个叶节点x，g[i]+=(1-p/q)^k，k是x到i的半路径上的被控制点的个数。
g[i]可以通过O(n)树形dp得到，接下来我们通过g[i]求出以每个点为LCA的路径的贡献之和。
对于点x,考虑它的所有儿子,每一对儿子(u,v)的贡献是g[u] * g[v] * (1-p/q)。注意，(u,v)和(v,u)都需要算一次。
但是我们很快会发现：直接暴力枚举每一对儿子会超时，关于这点，我们可以通过乘法分配律用O(儿子个数)的时间复杂度算出来。总的时间复杂度仍为O(n)。
Code
#include<cstdio> #include<cstdlib> #include<cstring> #include<iostream> #include<cmath> #define ll long long #define N 5000005 #define mod 1000000007 using namespace std; int pre[N],leaves[N],deep[N]; struct node{ int x,y,nxt; }; node way[N<<1]; int st[N],tot=0,D,Q,P,PQ,q[N],tou,wei,n; bool isleaf[N]; int g[N]; int KSM(int a,int b) { int t=1; a%=mod; while(b) { if(b&1) t=(t%mod*1LL*a%mod)%mod; b>>=1; a=(a%mod*1LL*a%mod)%mod; } return (int)t%mod; } void add(int u,int w) { tot++; way[tot].x=u; way[tot].y=w; way[tot].nxt=st[u]; st[u]=tot; tot++; way[tot].x=w; way[tot].y=u; way[tot].nxt=st[w]; st[w]=tot; } void bfs() { wei=tou=0; q[++wei]=1; deep[1]=0; pre[1]=0; while(tou<wei) { int now=q[++tou]; leaves[now]=1; isleaf[now]=1; for(int i=st[now];i;i=way[i].nxt) if(way[i].y!=pre[now]) { int v=way[i].y; leaves[now]=0; isleaf[now]=0; deep[v]=deep[now]+1; pre[v]=now; q[++wei]=v; } } for(int i=wei;i>1;i--) leaves[pre[q[i]]]+=leaves[q[i]];//统计每棵子树内的叶子数 } void solve() { int m=leaves[1];//叶子数 int ans=m*1LL*(m-1)/2%mod; for(int i=1;i<=n;i++) if(deep[i]==D||(isleaf[i]&&deep[i]<D))//会受影响的最顶端结点 { g[i]=leaves[i]*1LL*PQ%mod;//至少在这一点受到影响 int tmp=0,y; for(int j=st[i];j;j=way[j].nxt) if(way[j].y!=pre[i]) { y=leaves[way[j].y];//我们这里需要去除一些确定影响 ans=(ans-tmp*1LL*y%mod*PQ%mod+mod)%mod;//now的一棵子树与其他所有子树之间的影响 ans=(ans-y*1LL*(y-1)/2%mod+mod)%mod;//now的一棵子树内部的影响 tmp=tmp+y; } } while(wei>1&&deep[q[wei]]>D) wei--;//深度大的我们不考虑 for(int i=wei;i>=1;i--) { int now=q[i]; for(int j=st[now];j;j=way[j].nxt) if (way[j].y!=pre[now]) { ans=(ans-g[now]*1LL*g[way[j].y]%mod+mod)%mod; g[now]=(g[now]+g[way[j].y]*1LL*PQ)%mod;//g的维护 } } printf("%d\n",ans*2LL%mod); } int main() { scanf("%d",&n); for(int i=1;i<n;i++) { int u,w; scanf("%d%d",&u,&w); add(u,w); } scanf("%d%d%d",&D,&P,&Q); PQ=P*1LL*KSM(Q,mod-2)%mod; PQ=(1+mod-PQ)%mod; bfs(); solve(); return 0; }
Time: 2017-11-04
