[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[][];

int main()
{
    int n,p;
    scanf("%d%d",&n,&p);
    if(n==)
    {
        printf("1\n");
        return ;
    }
    int now=;
    f[][]=;
    for(int i=;i<=n;i++)
    {
        now^=;
        for(int j=;j<=i;j++)
        {
            f[now][j]=f[now][j-]+f[now^][i-j];
            f[now][j]%=p;
        }
    }
    printf("%d",f[now][n]*%p);
    return ;
}

被子(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[];
int n,m,sta[];
int Q;

int main()
{
    scanf("%d",&Q);
    while(Q--)
    {
        memset(sta,,sizeof(sta));
        scanf("%d%d",&n,&m);
        bool flag=true;
        for(int i=;i<=n;i++)
        {
            scanf("%s",s);
            for(int j=;j<m;j++)
                sta[s[j]-'a']+=;
        }

        //Judge the width and the length of this quilt
        if(n%==&&m%==)
        /*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=;i<;i++)
                if(sta[i]%!=)
                {
                    flag=false;
                    break;
                }
        }
        else if(n%==&&m%==)
        /*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=,tot=;
            for(int i=;i<;i++)
            {
                tot+=sta[i]%;
                if(sta[i]%==||sta[i]%==)
                    cnt++;
            }
            if(cnt>||tot>n)
                flag=false;
        }
        else if(n%==&&m%==)
        /*This kind of situation is totally same as last one. Ctrl+C~*/
        {
            int cnt=,tot=;
            for(int i=;i<;i++)
            {
                tot+=sta[i]%;
                if(sta[i]%==||sta[i]%==)
                    cnt++;
            }
            if(cnt>||tot>m)
                flag=false;
        }
        else if(n%==&&m%==)
        {
        /*Well ,this kind of situation is similar with last
        two situations:the only difference is that the container is larger.*/
            int cnt=,tot=;
            for(int i=;i<;i++)
            {
                tot+=sta[i]%;
                if(sta[i]%==||sta[i]%==)
                    cnt++;
            }
            if(cnt>||tot>=m+n)
                flag=false;
        }
        if(flag==true)
            printf("Yes\n");
        else
            printf("No\n");
    }
    return ;
}

蚊子(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<<];

int st[N],tot=,D,Q,P,PQ,q[N],tou,wei,n;
bool isleaf[N];
int g[N];

int KSM(int a,int b)
{
    int t=;
    a%=mod;
    while(b)
    {
        if(b&)
           t=(t%mod*1LL*a%mod)%mod;
        b>>=;
        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=;
    q[++wei]=;
    deep[]=;
    pre[]=;
    while(tou<wei)
    {
        int now=q[++tou];
        leaves[now]=;
        isleaf[now]=;
        for(int i=st[now];i;i=way[i].nxt)
            if(way[i].y!=pre[now])
            {
                int v=way[i].y;
                leaves[now]=;
                isleaf[now]=;
                deep[v]=deep[now]+;
                pre[v]=now;
                q[++wei]=v;
            }
    }
    for(int i=wei;i>;i--)
        leaves[pre[q[i]]]+=leaves[q[i]];//统计每棵子树内的叶子数
}

void solve()
{
    int m=leaves[];//叶子数
    int ans=m*1LL*(m-)/%mod;
    for(int i=;i<=n;i++)
        if(deep[i]==D||(isleaf[i]&&deep[i]<D))//会受影响的最顶端结点
        {
            g[i]=leaves[i]*1LL*PQ%mod;//至少在这一点受到影响
            int tmp=,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-)/%mod+mod)%mod;//now的一棵子树内部的影响
                    tmp=tmp+y;
                }
        }
    while(wei>&&deep[q[wei]]>D)
        wei--;//深度大的我们不考虑
    for(int i=wei;i>=;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=;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-)%mod;
    PQ=(+mod-PQ)%mod;
    bfs();
    solve();
    return ;
}

Time: 2017-11-04