2016"百度之星" - 资格赛(Astar Round1)-(模拟+线段树+乘法逆元)

Problem A

 
 Accepts: 1351
 
 Submissions: 9951
 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=1ilen(s)(Si28) (mod 9973)

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

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

Input

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

1\leq N\leq 1,0001N1,000

1\leq len(string)\leq 100,0001len(string)100,000

1\leq a,b\leq len(string)1a,blen(string)

Output

对于每一个询问,输出一个整数值,代表大字符串从 aa 位到 bb 位的子串的哈希值。

Sample Input
2
ACMlove2015
1 11
8 10
1
testMessage
1 1
Sample Output
6891
9240
88
第一题为一道乘法逆元,何为乘法逆元,就是将一个除法运算变为一个乘法运算,如下:
求解(b / a) mod p -> (b * x) mod p而其中的x = a ^ (phi(p) - 1),而如果p为质数的话phi(p) = p - 1, 所以x = a ^(p - 2).{phi()为欧拉函数},公式就变成了(b * (a ^ (p - 2))) mod p,其中a^(p-2),快速幂模板跳过。
所以我们将运用一丢丢前缀和的思想,将乘积取余保存在数组中,然后运用上述公式直接带入即可求解而出
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN = 1e5 + 5;
int H[MAXN];
char Hstr[MAXN];
int N, l, r;
const int mods = 9973;
typedef long long LL;

LL mod_pow(LL x, LL n, LL mod) {
    LL res = 1;
    while(n > 0) {
        if(n & 1) res = res * x % mod;
        x = x * x % mod;
        n >>= 1;
    }
    return res;
}


int main(){
    while(~scanf("%d", &N)){
        scanf("%s", Hstr);
        int len = strlen(Hstr);
        H[0] = 1;
        for(int i = 1;i <= len;i ++){
            H[i] = H[i - 1] * (Hstr[i - 1] - 28) % mods;
        }
        while(N --){
            scanf("%d%d", &l, &r);
            if(l > r) swap(l, r);
            printf("%I64d\n", (LL)H[r] * mod_pow(H[l - 1], mods - 2, mods) % mods);
        }
    }
    return 0;
}


Problem B

 
 Accepts: 1809
 
 Submissions: 6745
 Time Limit: 2000/1000 MS (Java/Others)
 
 Memory Limit: 65536/65536 K (Java/Others)
Problem Description

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

Input

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

1\leq N \leq 2001N200

Output

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

Sample Input
1
3
5
Sample Output
1
3
8


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

第二题是一道斐波那契数列,即dp[i] = dp[i - 1] + dp[i - 2].当然,也可以不是用dp,而是纯数学方法求解,因为我们通过观察题目可以知道,这道题无非就是求解0个2怎么放,1个2怎么放,3个2怎么放......,如此就是组合数了,C(n,m) = C(n-1,m-1)+C(n-1,m),求解出,相对于长度为n的2的放置方法个数{由于每产生一个2总长度就会减少一个,所以其中的摆放总数为n-i,i代表2的个数,n代表有多少个可以放2的位置}
当然,这里明显要用大数了,所以kuangbin大神大数模板借入,如此代码如下:
斐波拉契数列:
#include<stdio.h>
#include<string>
#include<string.h>
#include<iostream>
using namespace std;

//compare比较函数:相等返回0,大于返回1,小于返回-1
int compare(string str1,string str2)
{
    if(str1.length()>str2.length()) return 1;
    else if(str1.length()<str2.length())  return -1;
    else return str1.compare(str2);
}
//高精度加法
//只能是两个正数相加
string add(string str1,string str2)//高精度加法
{
    string str;

    int len1=str1.length();
    int len2=str2.length();
    //前面补0,弄成长度相同
    if(len1<len2)
    {
        for(int i=1;i<=len2-len1;i++)
           str1="0"+str1;
    }
    else
    {
        for(int i=1;i<=len1-len2;i++)
           str2="0"+str2;
    }
    len1=str1.length();
    int cf=0;
    int temp;
    for(int i=len1-1;i>=0;i--)
    {
        temp=str1[i]-'0'+str2[i]-'0'+cf;
        cf=temp/10;
        temp%=10;
        str=char(temp+'0')+str;
    }
    if(cf!=0)  str=char(cf+'0')+str;
    return str;
}
//高精度减法
//只能是两个正数相减,而且要大减小
string sub(string str1,string str2)//高精度减法
{
    string str;
    int tmp=str1.length()-str2.length();
    int cf=0;
    for(int i=str2.length()-1;i>=0;i--)
    {
        if(str1[tmp+i]<str2[i]+cf)
        {
            str=char(str1[tmp+i]-str2[i]-cf+'0'+10)+str;
            cf=1;
        }
        else
        {
            str=char(str1[tmp+i]-str2[i]-cf+'0')+str;
            cf=0;
        }
    }
    for(int i=tmp-1;i>=0;i--)
    {
        if(str1[i]-cf>='0')
        {
            str=char(str1[i]-cf)+str;
            cf=0;
        }
        else
        {
            str=char(str1[i]-cf+10)+str;
            cf=1;
        }
    }
    str.erase(0,str.find_first_not_of('0'));//去除结果中多余的前导0
    return str;
}
//高精度乘法
//只能是两个正数相乘
string mul(string str1,string str2)
{
    string str;
    int len1=str1.length();
    int len2=str2.length();
    string tempstr;
    for(int i=len2-1;i>=0;i--)
    {
        tempstr="";
        int temp=str2[i]-'0';
        int t=0;
        int cf=0;
        if(temp!=0)
        {
            for(int j=1;j<=len2-1-i;j++)
              tempstr+="0";
            for(int j=len1-1;j>=0;j--)
            {
                t=(temp*(str1[j]-'0')+cf)%10;
                cf=(temp*(str1[j]-'0')+cf)/10;
                tempstr=char(t+'0')+tempstr;
            }
            if(cf!=0) tempstr=char(cf+'0')+tempstr;
        }
        str=add(str,tempstr);
    }
    str.erase(0,str.find_first_not_of('0'));
    return str;
}

//高精度除法
//两个正数相除,商为quotient,余数为residue
//需要高精度减法和乘法
void div(string str1,string str2,string "ient,string &residue)
{
    quotient=residue="";//清空
    if(str2=="0")//判断除数是否为0
    {
        quotient=residue="ERROR";
        return;
    }
    if(str1=="0")//判断被除数是否为0
    {
        quotient=residue="0";
        return;
    }
    int res=compare(str1,str2);
    if(res<0)
    {
        quotient="0";
        residue=str1;
        return;
    }
    else if(res==0)
    {
        quotient="1";
        residue="0";
        return;
    }
    else
    {
        int len1=str1.length();
        int len2=str2.length();
        string tempstr;
        tempstr.append(str1,0,len2-1);
        for(int i=len2-1;i<len1;i++)
        {
            tempstr=tempstr+str1[i];
            tempstr.erase(0,tempstr.find_first_not_of('0'));
            if(tempstr.empty())
              tempstr="0";
            for(char ch='9';ch>='0';ch--)//试商
            {
                string str,tmp;
                str=str+ch;
                tmp=mul(str2,str);
                if(compare(tmp,tempstr)<=0)//试商成功
                {
                    quotient=quotient+ch;
                    tempstr=sub(tempstr,tmp);
                    break;
                }
            }
        }
        residue=tempstr;
    }
    quotient.erase(0,quotient.find_first_not_of('0'));
    if(quotient.empty()) quotient="0";
}


const int MAXNX = 200 + 5;
string C[MAXNX];
void init(){
    C[0] = "0";
    C[1] = "1";
    for(int i = 2;i < MAXNX;i ++) C[i] = add(C[i - 1], C[i - 2]);
}

int N;
int main() {
    init();
    while(~scanf("%d", &N)){
        cout << C[N + 1] << endl;
    }
    return 0;
}


纯数学方法:
#include<stdio.h>
#include<string>
#include<string.h>
#include<iostream>
using namespace std;

//compare比较函数:相等返回0,大于返回1,小于返回-1
int compare(string str1,string str2)
{
    if(str1.length()>str2.length()) return 1;
    else if(str1.length()<str2.length())  return -1;
    else return str1.compare(str2);
}
//高精度加法
//只能是两个正数相加
string add(string str1,string str2)//高精度加法
{
    string str;

    int len1=str1.length();
    int len2=str2.length();
    //前面补0,弄成长度相同
    if(len1<len2)
    {
        for(int i=1;i<=len2-len1;i++)
           str1="0"+str1;
    }
    else
    {
        for(int i=1;i<=len1-len2;i++)
           str2="0"+str2;
    }
    len1=str1.length();
    int cf=0;
    int temp;
    for(int i=len1-1;i>=0;i--)
    {
        temp=str1[i]-'0'+str2[i]-'0'+cf;
        cf=temp/10;
        temp%=10;
        str=char(temp+'0')+str;
    }
    if(cf!=0)  str=char(cf+'0')+str;
    return str;
}
//高精度减法
//只能是两个正数相减,而且要大减小
string sub(string str1,string str2)//高精度减法
{
    string str;
    int tmp=str1.length()-str2.length();
    int cf=0;
    for(int i=str2.length()-1;i>=0;i--)
    {
        if(str1[tmp+i]<str2[i]+cf)
        {
            str=char(str1[tmp+i]-str2[i]-cf+'0'+10)+str;
            cf=1;
        }
        else
        {
            str=char(str1[tmp+i]-str2[i]-cf+'0')+str;
            cf=0;
        }
    }
    for(int i=tmp-1;i>=0;i--)
    {
        if(str1[i]-cf>='0')
        {
            str=char(str1[i]-cf)+str;
            cf=0;
        }
        else
        {
            str=char(str1[i]-cf+10)+str;
            cf=1;
        }
    }
    str.erase(0,str.find_first_not_of('0'));//去除结果中多余的前导0
    return str;
}
//高精度乘法
//只能是两个正数相乘
string mul(string str1,string str2)
{
    string str;
    int len1=str1.length();
    int len2=str2.length();
    string tempstr;
    for(int i=len2-1;i>=0;i--)
    {
        tempstr="";
        int temp=str2[i]-'0';
        int t=0;
        int cf=0;
        if(temp!=0)
        {
            for(int j=1;j<=len2-1-i;j++)
              tempstr+="0";
            for(int j=len1-1;j>=0;j--)
            {
                t=(temp*(str1[j]-'0')+cf)%10;
                cf=(temp*(str1[j]-'0')+cf)/10;
                tempstr=char(t+'0')+tempstr;
            }
            if(cf!=0) tempstr=char(cf+'0')+tempstr;
        }
        str=add(str,tempstr);
    }
    str.erase(0,str.find_first_not_of('0'));
    return str;
}

//高精度除法
//两个正数相除,商为quotient,余数为residue
//需要高精度减法和乘法
void div(string str1,string str2,string "ient,string &residue)
{
    quotient=residue="";//清空
    if(str2=="0")//判断除数是否为0
    {
        quotient=residue="ERROR";
        return;
    }
    if(str1=="0")//判断被除数是否为0
    {
        quotient=residue="0";
        return;
    }
    int res=compare(str1,str2);
    if(res<0)
    {
        quotient="0";
        residue=str1;
        return;
    }
    else if(res==0)
    {
        quotient="1";
        residue="0";
        return;
    }
    else
    {
        int len1=str1.length();
        int len2=str2.length();
        string tempstr;
        tempstr.append(str1,0,len2-1);
        for(int i=len2-1;i<len1;i++)
        {
            tempstr=tempstr+str1[i];
            tempstr.erase(0,tempstr.find_first_not_of('0'));
            if(tempstr.empty())
              tempstr="0";
            for(char ch='9';ch>='0';ch--)//试商
            {
                string str,tmp;
                str=str+ch;
                tmp=mul(str2,str);
                if(compare(tmp,tempstr)<=0)//试商成功
                {
                    quotient=quotient+ch;
                    tempstr=sub(tempstr,tmp);
                    break;
                }
            }
        }
        residue=tempstr;
    }
    quotient.erase(0,quotient.find_first_not_of('0'));
    if(quotient.empty()) quotient="0";
}


const int MAXNX = 200 + 5;
string C[MAXNX][MAXNX];
void init(){
    for(int i = 0;i < MAXNX;i ++){
        for(int j = 0;j < MAXNX;j ++){
            C[i][j] = "0";
        }
    }
    for(int i = 1;i < MAXNX;i ++){
        for(int j = 0;j <= i;j ++){
            if(j == 0) C[i][0] = "1";
            else{
                C[i][j] = add(C[i - 1][j - 1],C[i - 1][j]);
            }
        }
    }
}

int N;
int main() {
    init();
    while(~scanf("%d", &N)){
        string res = "0";
        for(int i = 0;i <= (N + 1)/ 2;i ++){
            res = add(res,C[N - i + 1][i]);
        }
        cout << res << endl;
    }
    return 0;
}

Problem C

 
 Accepts: 538
 
 Submissions: 4654
 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\leq N\leq 100000)N(1N100000),代表度熊对于字典的操作次数,接下来NN行,每行包含两个字符串,中间中用空格隔开。第一个字符串代表了相关的操作(包括: insert, delete 或者 search)。第二个字符串代表了相关操作后指定的那个字符串,第二个字符串的长度不会超过30。第二个字符串仅由小写字母组成。

Output

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

Sample Input
5
insert hello
insert hehe
search h
delete he
search hello
Sample Output
Yes
No
这道题的解法,我是用字典树的,直接用数组字典树模板,建立,再增加一个deletes()函数执行删除操作,基本就OK了,但是得注意一些细节,他是说删除前缀为此字符串的所有字符串,我们可以在结构体中增加一个变量s来标记经过此节点的字符串有多少个,为什么要这么做了,因为当你删除所有前缀为此字符串的字符串后,要判断,这条线上是否还有字符串,也就是insert aaas delete aaa search aa,当删除前辍为aaa的时候,这个字典树中就不存在字符串了,我们应该输出No,还有就是insert aaaas insert aas delete aaa search aa,此处他的输出则是Yes

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

#define FIN freopen("input.txt","r", stdin)

struct node{
    int next[27];
    int v,s;
    void init(){
        v=s=0;
        memset(next,-1,sizeof(next));
    }
};
struct node L[4000000];
int tot=0;

void add(char a[],int len){
    int now=0;
    for(int i=0;i<len;i++){
        int tmp=a[i]-'a';
        int next=L[now].next[tmp];
        if(next==-1){
            next=++tot;
            L[next].init();
            L[next].v=-1;
            L[now].next[tmp]=next;
        }
        now=next;
        L[now].s ++;
    }
    L[now].v=0;
}

bool query(char a[],int len){
    int now=0;
    for(int i=0;i<len;i++){
        int tmp=a[i]-'a';
        int next=L[now].next[tmp];
        if(next==-1)return false;
        now=next;
    }
    return L[now].s > 0;
}

void deletes(char a[], int len){
    int now=0, late;
    for(int i=0;i<len;i++){
        int tmp=a[i]-'a';
        int next=L[now].next[tmp];
        if(next==-1) return;
        late = now;
        now=next;
    }
    now = 0;
    for(int i=0;i<len;i++){
        int tmp=a[i]-'a';
        int next=L[now].next[tmp];
        if(next==-1) return;
        late = now;
        now=next;
        L[now].s --;
    }
    L[now].init();
    int tmp=a[len - 1]-'a';
    L[late].next[tmp] = -1;
}

char S1[15];
char S2[35];
int N;
int main(){
    //FIN;
    L[0].init();
    scanf("%d", &N);
    while(N --){
        scanf("%s%s", S1, S2);
        if(S1[0] == 'i' || S1[0] == 'I') add(S2, strlen(S2));
        else if(S1[0] == 's' || S1[0] == 'S'){
            bool v = query(S2, strlen(S2));
            if(v){
                printf("Yes\n");
            }
            else{
                printf("No\n");
            }
        }
        else{
            deletes(S2, strlen(S2));
        }
    }
    return 0;
}

Problem D

 
 Accepts: 2028
 
 Submissions: 5849
 Time Limit: 2000/1000 MS (Java/Others)
 
 Memory Limit: 65536/65536 K (Java/Others)
Problem Description

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

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

Input

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

Output

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

Sample Input
5
ACM
MAC
BBA
ACM
BAB
Sample Output
0
1
0
2
1
这道题目,大家应该觉得属于秒过题吧,拍个需,用map直接半段
#include <cstdio>
#include <cstring>
#include <map>
#include <string>
#include <algorithm>
using namespace std;
#define FIN freopen("input.txt","r", stdin)
int N;
char tstr[40 + 5];
map<string, int>TM;
int main(){
    //FIN;
    TM.clear();
    scanf("%d", &N);
    for(int i = 0;i < N;i ++){
        scanf("%s", tstr);
        sort(tstr, tstr + strlen(tstr));
        if(!TM[string(tstr)]) TM[string(tstr)] = 0;
        printf("%d\n", TM[string(tstr)]);
        TM[string(tstr)] ++;
    }

    return 0;
}


Problem E

 
 Accepts: 98
 
 Submissions: 536
 Time Limit: 2000/1000 MS (Java/Others)
 
 Memory Limit: 65536/65536 K (Java/Others)
Problem Description

小度熊是一个尽职尽责的程序熊,每天产出数千行的代码,代码当中存在很多判断条件。度熊想让自己代码中的这些条件不存在交集。为了简化问题,一个条件可以是一个『简单条件』或者是一个『复合条件』,简单条件由『变量』、『比较符』和『运算数』组成,其中『变量』是用小写字符表示的一串字符,『运算数』仅为整数,『运算符』包括:<、>、<=、>=、==。分别代表:小于、大于、小于等于、大于等于和等于关系。简单条件的格式固定,左边为变量名,中间为操作符,右边为数字。若干个『简单条件』中间通过英文逗号组成一个『复合条件』,各『简单条件』之间是逻辑与的关系,例如:

简单条件: a > 100

复合条件: duxiong < 1000 , a > 100

Input

这里包括一组测试数据,第一行一个正整数 N(1 \leq N \leq 1000)N(1N1000),接下来 NN 行,每行一个条件,条件可能是一个『简单条件』或者是一个『复合条件』。其中『变量』不会超过30个字符,『运算数』的绝对值在10,000以内。测试数据中,不同变量的数量不会超过30个。其中『变量』、『比较符』和『运算数』 之前和之后都有可能出现若干空格字符。所有简单规则都是按照『变量』『比较符』『运算数』这样的顺序定义的,没有特例。

Output

对于第 ii 个条件,输出其与前 i-1i1个条件是否存在交集非空的情况。如果不存在交集非空的其他条件,输出一行字符串:『unique』。否则按照从小到大的顺序输出与其存在非空交集的条件的编号,编号之间用空格分隔,最后一个编号末尾不加空格。各条件从1-N1N编号。

Sample Input
4
a < 100
c > 99
b > 100 , b == 99 , c < 98
a < 1000, a >= 99
Sample Output
unique
1
unique
1 2

第五题有点坑大家了,我并没有做,因为这道题目是万恶的模拟题,算法基本不考,大家只要不断的判断结果就可以了,非常死脑筋的模拟题

你可能感兴趣的:(2016"百度之星" - 资格赛(Astar Round1)-(模拟+线段树+乘法逆元))