[SinGuLaRiTy] NOIP模拟题 by liu_runda

Posted SinGuLaRiTy2001

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了[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
3 4
aabb
aabb
aacc
2 2
aa
bb
5 1
t
w
e
e
t
2 5
abxba
abyba
1 1
z

Yes
No
Yes
No
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
1 2
1 3
1 1 2

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

以上是关于[SinGuLaRiTy] NOIP模拟题 by liu_runda的主要内容,如果未能解决你的问题,请参考以下文章

[SinGuLaRiTy] NOIP膜你赛-Day 1

Noip模拟By yxj

C. 「NOIP2021模拟赛 By ZJ C」自然溢出 题解

2014-5-10 NOIP模拟赛 by coolyangzc

2017-10-28 noip模拟赛by WISCO 信息组

Noip模拟 Day6.13 By LD T1