2016 "百度之星" - 资格赛（Astar Round1）

此处有 目录↑

Problem A （前缀积&&乘法逆元）

 Time Limit: 2000/1000 MS (Java/Others)

 

 Memory Limit: 65536/65536 K (Java/Others)

Problem Description

度熊手上有一本字典存储了大量的单词，有一次，他把所有单词组成了一个很长很长的字符串。现在麻烦来了，他忘记了原来的字符串都是什么，神奇的是他竟然记得原来那些字符串的哈希值。一个字符串的哈希值，由以下公式计算得到：

H(s)=\prod_{i=1}^{i\leq len(s)}(S_{i}-28)\ (mod\ 9973)H(s)=∏​i=1​i≤len(s)​​(S​i​​−28) (mod 9973)

S_{i}S​i​​代表 S[i] 字符的 ASCII 码。

请帮助度熊计算大字符串中任意一段的哈希值是多少。

Input

多组测试数据，每组测试数据第一行是一个正整数$N$，代表询问的次数，第二行一个字符串，代表题目中的大字符串，接下来$N$行，每行包含两个正整数$a$和$b$，代表询问的起始位置以及终止位置。

$1\le N\le 1,000$

$1\le len(string)\le 100,000$

$1\le a,b\le len(string)$

Output

对于每一个询问，输出一个整数值，代表大字符串从 $a$ 位到 $b$ 位的子串的哈希值。

Sample Input

2
ACMlove2015
1 11
8 10
1
testMessage
1 1

Sample Output

6891
9240
88

本来第一反应就是想用前缀积+乘法逆元算的，结果非常倔强地相同线段树，就愉快地一直RE了，最终还是用了 前缀积+乘法逆元

后来才知道数据也有毒...

#include <cstdio>
#include <algorithm>

using namespace std;

const int MOD=9973;

char s[100005];
int n,num[100005],l,r;
int inv[9975];

void getInv() {
    inv[0]=0;
    inv[1]=1;
    for(int i=2;i<MOD;++i) {
        inv[i]=(inv[MOD%i]*(MOD-MOD/i))%MOD;
    }
}

int main() {
    getInv();
    while(1==scanf("%d ",&n)) {
        gets(s+1);
        num[0]=1;
        for(int i=1;s[i]!='\0';++i) {
            num[i]=(num[i-1]*(s[i]-28))%MOD;
        }
        while(n-->0) {
            scanf("%d%d",&l,&r);
            if(l>r) {
                swap(l,r);
            }
            printf("%d\n",(num[r]*inv[num[l-1]])%MOD);
        }
    }
    return 0;
}

Problem B （DP）

 Time Limit: 2000/1000 MS (Java/Others)

 

 Memory Limit: 65536/65536 K (Java/Others)

Problem Description

度熊面前有一个全是由1构成的字符串，被称为全1序列。你可以合并任意相邻的两个1，从而形成一个新的序列。对于给定的一个全1序列，请计算根据以上方法，可以构成多少种不同的序列。

Input

这里包括多组测试数据，每组测试数据包含一个正整数$N$，代表全1序列的长度。

$1\le N\le 200$

Output

对于每组测试数据，输出一个整数，代表由题目中所给定的全1序列所能形成的新序列的数量。

Sample Input

1
3
5

Sample Output

1
3
8


    
    

     
     

      
      Hint
     
     
如果序列是：(111)。可以构造出如下三个新序列：(111), (21), (12)。
    
    

设dp[i]表示长度为i的'1'串能构造出的序列个数

则第i个字符不与任何字符组合时，共dp[i-1]种新序列；第i个字符与第i-1个字符组合时，共dp[i-2]种新序列

则可得状态转移方程为：dp[i]=dp[i-1]+dp[i-2]

#include <cstdio>
#include <cstring>
#include <algorithm>

#define LEN 110
#define MOD 100000000

using namespace std;

struct BigInt {
    int len,p[LEN];
    BigInt() {
        memset(p,0,sizeof(p));
        len=0;
    }
}dp[205];

int n,t;

BigInt add(const BigInt& x,const BigInt& y) {
    BigInt cnt;
    t=max(x.len,y.len);
    for(int i=1;i<=t;i++) {
        cnt.p[i]+=x.p[i]+y.p[i];
        cnt.p[i+1]=cnt.p[i]/MOD;
        cnt.p[i]%=MOD;
    }
    if(cnt.p[t+1])
        t++;
    cnt.len=t;
    return cnt;
}

void print(const BigInt& x) {
    printf("%d",x.p[x.len]);
    for(int i=x.len-1;i>=1;i--)
        printf("%08d",x.p[i]);
    printf("\n");
}

int main() {
    dp[0].p[1]=1;
    dp[0].len=1;
    dp[1].p[1]=1;
    dp[1].len=1;
    for(int i=2;i<=204;++i) {
        dp[i]=add(dp[i-1],dp[i-2]);
    }
    while(scanf("%d",&n)==1) {
        print(dp[n]);
    }
    return 0;
}

Problem C （Trie树）

 Time Limit: 2000/1000 MS (Java/Others)

 

 Memory Limit: 131072/131072 K (Java/Others)

Problem Description

度熊手上有一本神奇的字典，你可以在它里面做如下三个操作：

1、insert : 往神奇字典中插入一个单词

2、delete: 在神奇字典中删除所有前缀等于给定字符串的单词

3、search: 查询是否在神奇字典中有一个字符串的前缀等于给定的字符串

Input

这里仅有一组测试数据。第一行输入一个正整数$N(1\le N\le 100000)$，代表度熊对于字典的操作次数，接下来$N$行，每行包含两个字符串，中间中用空格隔开。第一个字符串代表了相关的操作（包括： insert, delete 或者 search）。第二个字符串代表了相关操作后指定的那个字符串，第二个字符串的长度不会超过30。第二个字符串仅由小写字母组成。

Output

对于每一个search 操作，如果在度熊的字典中存在给定的字符串为前缀的单词，则输出Yes 否则输出 No。

Sample Input

Copy

5
insert hello
insert hehe
search h
delete he
search hello

Sample Output

Yes
No

第一反应就是在插入新单词时，给路径上的每个节点都+1，然而倔强地想用isEnd表示单词的结束，又WA了好久，最后才发现删除时有问题。。。果断改回去就AC了

#include <cstdio>

using namespace std;

const int MAXN=3000005;

struct Trie {
    int next[MAXN][26];
    int num[MAXN];

    int l;
    const static int root=0;

    Trie() {
        clear();
    }

    int newNode() {
        num[l]=0;
        for(int i=0;i<26;++i) {
            next[l][i]=-1;
        }
        return l++;
    }

    void insert(char *p) {
        int cur=root;
        while((*p)!='\0') {
            if(next[cur][(*p)-'a']==-1) {
                next[cur][(*p)-'a']=newNode();
            }
            cur=next[cur][(*p)-'a'];
            ++num[cur];
            ++p;
        }
    }

    void delet(char *p,int cnt) {
        int cur=root;
        while((*p)!='\0') {
            cur=next[cur][(*p)-'a'];
            num[cur]-=cnt;
            ++p;
        }
        for(int i=0;i<26;++i) {
            next[cur][i]=-1;
        }
    }

    int query(char *p) {
        int cur=root;
        while((*p)!='\0') {
            if(next[cur][(*p)-'a']==-1) {
                return 0;
            }
            cur=next[cur][(*p)-'a'];
            ++p;
        }
        return num[cur];
    }

    void clear() {
        l=root;
        newNode();
    }
}trie;

int main() {
    int n;
    char cmd[35],s[35];
    scanf("%d",&n);
    trie.clear();
    while(n-->0) {
        scanf("%s%s",cmd,s);
        if(cmd[0]=='i') {
            trie.insert(s);
        }
        else if(cmd[0]=='d') {
            int cnt=trie.query(s);
            if(cnt>0) {
                trie.delet(s,cnt);
            }
        }
        else {
            printf("%s\n",trie.query(s)>0?"Yes":"No");
        }
    }
    return 0;
}

Problem D （map）

 Time Limit: 2000/1000 MS (Java/Others)

 

 Memory Limit: 65536/65536 K (Java/Others)

Problem Description

度熊所居住的 D 国，是一个完全尊重人权的国度。以至于这个国家的所有人命名自己的名字都非常奇怪。一个人的名字由若干个字符组成，同样的，这些字符的全排列的结果中的每一个字符串，也都是这个人的名字。例如，如果一个人名字是 ACM，那么 AMC， CAM， MAC， MCA， 等也都是这个人的名字。在这个国家中，没有两个名字相同的人。

度熊想统计这个国家的人口数量，请帮助度熊设计一个程序，用来统计每一个人在之前被统计过多少次。

Input

这里包括一组测试数据，第一行包含一个正整数$N$，接下来的$N$ 行代表了 $N$ 个名字。$N$ 不会超过$100,000$，他们的名字不会超过40位.

Output

对于每输入的一个人名，输出一个整数，代表这个人之前被统计了多少次。

Sample Input

5
ACM
MAC
BBA
ACM
BAB

Sample Output

0
1
0
2
1

第一次用结构体存储每个字符出现的个数，然后再用map，250ms左右

第二次直接对排序后的string用map，460ms左右，看来stl真得少用

#include <iostream>
#include <cstring>
#include <string>
#include <map>

using namespace std;

struct Node {
    int num[26];

    bool operator < (const Node& a) const {
        for(int i=0;i<26;++i) {
            if(num[i]!=a.num[i]) {
                return num[i]<a.num[i];
            }
        }
        return false;
    }
}cur;

int n;
map<Node,int> mp;
char s[45];

int main() {
    cin.sync_with_stdio(false);
    while(cin>>n) {
        while(n-->0) {
            cin>>s;
            memset(cur.num,0,sizeof(cur.num));
            for(int i=0;s[i]!='\0';++i) {
                ++cur.num[s[i]-'A'];
            }
            printf("%d\n",mp[cur]);
            ++mp[cur];
        }
    }
}

第五题感觉就是一道麻烦的模拟题，就不写了...