2016百度之星资格赛题解

题目：Problem A

链接：http://acm.hdu.edu.cn/showproblem.php?pid=5685

题意：对于一个字符串，定义一个哈希值 （∏是连乘），给一个字符串s，现有n个操作，每次操作询问下标 l 到 r 之间的子串的哈希值，前缀的思想，先预处理出0到每一位的哈希值gi，现在只涉及到g[r]和g[l-1]，不过因为涉及到取模操作，所以不能直接除，应该找g[l-1]的逆元e，答案便是g[r]*e%9973。

#include<stdio.h>
char s[100010];
int a[100010];
int exGcd(int a,int b,int &x,int &y)
{
  if(b==0)
  {
    x=1;
    y=0;
    return a;
  }
  int r=exGcd(b,a%b,x,y);
  int t=x;
  x=y;
  y=t-a/b*y;
  return r;
}
int main()
{
  int n;
  while(scanf("%d",&n)!=EOF)
  {
    scanf("%s",s+1);
    a[0]=1;
    for(int i=1;s[i];i++)
    {
      a[i]=a[i-1]*(s[i]-28)%9973;
    }
    int x,y;
    while(n--)
    {
      scanf("%d%d",&x,&y);
      int l,r;
      exGcd(a[x-1],9973,l,r);
      l=(l%9973+9973)%9973;
      printf("%d\n",a[y]*l%9973);
    }
  }
  return 0;
}

===========================================

 

题目：Problem B

链接：http://acm.hdu.edu.cn/showproblem.php?pid=5686

题意：有一个只含有1的字符串，现在可以将任意相邻的1变为2，问可以形成多少种不同的字符串。比如111可以变为12,21,111。给你一个n表示1的数量，输出不同字符串的数量。

思路：dp的水题，斐波拉契数列，大数。可以想象11111...可以分成(2)111...与1(1111)...，现在有两种情况：

　　第一个1动：前两个1变为2，后面的111...再变，这种情况的数量是dp[n-2]；

　　第一个1不动：这种情况的数量是dp[n-1]；

注意：n很大，需要大数处理，只需要加法，而且时间限制也不是很紧，随便过。

#include<stdio.h>
#include<string.h>
struct BigNum
{
  int s[1000];
  int so;
  BigNum Add(BigNum b)
  {
    BigNum ret;
    memset(ret.s,0,sizeof(ret.s));
    ret.so=0;
    int i;
    for(i=0;i<so&&i<b.so;i++)
    {
      ret.s[i]+=s[i]+b.s[i];
      if(ret.s[i]>=10)
      {
        ret.s[ret.so]-=10;
        ret.s[++ret.so]=1;
      }
      else ret.so++;
    }
    for(;i<so;i++)
    {
      ret.s[i]=s[i]+ret.s[i];
      if(ret.s[i]>=10)
      {
        ret.s[ret.so]-=10;
        ret.s[++ret.so]=1;
      }
      else ret.so++;
    }
    for(;i<b.so;i++)
    {
      ret.s[i]=b.s[i]+ret.s[i];
      if(ret.s[i]>=10)
      {
        ret.s[ret.so]-=10;
        ret.s[++ret.so]=1;
      }
      else ret.so++;
    }
    if(ret.s[ret.so]!=0) ret.so++;
    return ret;
  }
  void get()
  {
    for(int i=so-1;i>=0;i--)
    {
      printf("%d",s[i]);
    }
  }
};
BigNum dp[210];
int main()
{
  dp[1].so=1;
  dp[1].s[0]=1;
  dp[2].so=1;
  dp[2].s[0]=2;
  for(int i=3;i<201;i++)
  {
    dp[i]=dp[i-1].Add(dp[i-2]);
  }
  int n;
  while(scanf("%d",&n)!=EOF)
  {
    dp[n].get();
    printf("\n");
  }
  return 0;
}

===========================================

 

题目：Problem C

链接：http://acm.hdu.edu.cn/showproblem.php?pid=5687

题意：有三种操作，一是 添加一个单词s ，二是 删除所有前缀是s的单词 ，三是 询问是否存在前缀为s的单词。

思路：字典树，添加单词时，每一个前缀的num++，也就是如果此时sa的num为10，就说明前缀为sa的单词共有10个。删除所有前缀为s的单词时直接把s对应的num置0，要注意三点：

　　一：这样删除的话添加单词abcdefg时，如果遇到abc的num为0，说明没有以abc为前缀的单词，所以应该将0向下更新，也就是说如果之前存在过abce，也就是此时abce的num是1，我添加abcdef时应该把abce更新为0，之所以要现在才更新是为了节省时间，不然会超时，注意只需要更新一层就够。

　　二：删除abcd，置abcd的num为0，要向上更新，都减去abcd的num值。

　　三：删除abcd，如果abc的num为0，说明没有abcd的存在，不能再往下进行，因为下面的num值都是假的。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
using namespace std;
struct Node
{
  int num;
  Node *fa;
  Node *next[26];
};
Node root;

void Init()
{
  root.num=0;
  for(int i=0;i<26;i++)
  {
    root.next[i]=NULL;
  }
}

Node *create(Node *fa)
{
  Node *s=(Node*)malloc(sizeof(Node));
  s->fa=fa;
  s->num=0;
  for(int i=0;i<26;i++)
  {
    s->next[i]=NULL;
  }
  return s;
}

void Add(char *s)
{
  Node *p=&root;
  for(int i=0;s[i];i++)
  {
    int pos=s[i]-'a';
    if(p->next[pos]==NULL)
    {
      p->next[pos]=create(p);
    }
    p=p->next[pos];
    if(p->num==0)
    {
      for(int j=0;j<26;j++)
      {
        if(p->next[j]!=NULL)
        {
          p->next[j]->num=0;
        }
      }
    }
    p->num++;
  }
}

void del(char *s)
{
  Node *p=&root;
  for(int i=0;s[i];i++)
  {
    int pos=s[i]-'a';
    if(p->next[pos]==NULL) return ;
    else p=p->next[pos];
    if(p->num==0) return ;
  }
  int tmp=p->num;
  while(p!=&root)
  {
    p->num-=tmp;
    p=p->fa;
  }
}

bool find(char *s)
{
  Node *p=&root;
  for(int i=0;s[i];i++)
  {
    int pos=s[i]-'a';
    if(p->next[pos]==NULL) return false;
    else p=p->next[pos];
    if(p->num==0) return false;
  }
  return true;
}

int main()
{
  int n;
  char s[41],s1[10];
  scanf("%d",&n);
  Init();
  while(n--)
  {
    scanf("%s%s",s1,s);
    if(s1[0]=='i')
    {
      Add(s);
    }
    else if(s1[0]=='s')
    {
      if(find(s)) printf("Yes\n");
      else printf("No\n");
    }
    else
    {
      del(s);
    }
  }
  return 0;
}

===========================================

 

题目：Problem D

链接：http://acm.hdu.edu.cn/showproblem.php?pid=5688

题意：定义ACM和CAM相同，也就是说通过ACM这三个字母全排列出来的所有字符串都相同，也就是只要是由ACM组成的字符串都相同。现在有n个操作，添加字符串s，同时输出这个字符串前面添加过多少次。

思路：字典树，全排列都相同，那么可以先对字符串s进行排序，这样就只需要统计s出现的次数。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
using namespace std;
struct Node
{
  int num;
  Node *next[26];
};
Node root;
void Init()
{
  root.num=0;
  for(int i=0;i<26;i++)
    root.next[i]=NULL;
}
void Add(char *s)
{
  Node *p=&root;
  for(int j=0;s[j];j++)
  {
    int i=s[j]-'A';
    if(p->next[i]==NULL)
    {
      Node *s=(Node *)malloc(sizeof(Node));
      for(int i=0;i<26;i++)
        s->next[i]=NULL;
      s->num=0;
      p->next[i]=s;
    }
    p=p->next[i];
  }
  p->num++;
  printf("%d\n",p->num-1);
}

int main()
{
  int n;
  char s[41];
  scanf("%d",&n);
  while(n--)
  {
    scanf("%s",s);
    sort(s,s+strlen(s));
    Add(s);
  }
  return 0;
}

===========================================

 

题目：Problem E

链接：http://acm.hdu.edu.cn/showproblem.php?pid=5689

题意：有n个集合，每个集合由一个字符串表示，字符串表示分为复合条件和简单条件，简单条件就是由 变量 + 比较符 + 数字组成，复合条件就是通过逗号将简单条件并在一起，比如a<100,a>20，最终a的区间就是（20,100），现在问前i-1条（每一条）和第i条的交集是否为空，如果都为空就输出unique，否则就从小到大输出有交集的集合的编号。判断两个集合是否有交集就是说是否有相同变量的区间有重叠，比如第一条是a<100，第二条是a>50，那么这两个集合由交集。

坑：如果第一条是a<100，第二条里没有出现a的限制，那么有交集。。。题目设定

坑：如果第一条是a<100，第二条是a<10,b<100,b==100，第二条是空集，因为不存在合法的b，所以两条集合也没有交集。。。

思路：记录每一条记录的每一个变量的左右区间就行，时间很松。完全可以1000*1000*30*log(30)，就是对每一个集合遍历前面所有的集合，再遍历每一个变量，判断是否有交集，用map记录，不然比较变量名会花很多时间。（题目理清楚，写下去就很简单了）

#include<stdio.h>
#include<string.h>
#include<map>
#include<string>
using namespace std;

struct Node
{
  char s[35];
  int l,r;
  bool flag;
};

Node a[1010][35];
int ao[1010];
bool ff[1010];
map<string,int> m[1010];

int mo;
void solve(int pos,char *s)
{
  for(int i=0;s[i];i++)
  {
    if(s[i]<='z'&&s[i]>='a')
    {
      char t[35];
      int j;
      for(j=i;s[j];j++)
      {
        if(s[j]<='z'&&s[j]>='a') t[j-i]=s[j];
        else break;
      }
      t[j-i]=0;
      int to;
      if(m[pos].find(t)==m[pos].end())
      {
        m[pos][t]=++mo;
        strcpy(a[pos][mo].s,t);
        a[pos][mo].l=-10000;
        a[pos][mo].r=10000;
        a[pos][mo].flag=1;
        to=mo;
        ao[pos]=mo;
      }
      else to=m[pos][t];
      int flag=0;
      for(;s[j];j++)
      {
        if(s[j]=='<'&&s[j+1]=='=') flag=2;
        else if(s[j]=='<') flag=1;
        else if(s[j]=='>'&&s[j+1]=='=') flag=4;
        else if(s[j]=='>') flag=3;
        else if(s[j]=='='&&s[j+1]=='=') flag=5;
        if(flag!=0) break;
      }
      int k=0,fu=1;
      for(j++;s[j];j++)
      {
        if(s[j]=='-')
        {
          fu=-1;
        }
        else if(s[j]<='9'&&s[j]>='0')
        {
          k=k*10+s[j]-'0';
        }
        else if(s[j]==',') break;
      }
      k=k*fu;
      if(flag==1) k--;
      else if(flag==3) k++;
      if(flag==1||flag==2)
      {
        a[pos][to].r=min(k,a[pos][to].r);
      }
      else if(flag==3||flag==4)
      {
        a[pos][to].l=max(k,a[pos][to].l);
      }
      else if(flag==5)
      {
        if(a[pos][to].l>k||a[pos][to].r<k) a[pos][to].flag=0;
        else
        {
          a[pos][to].l=k;
          a[pos][to].r=k;
        }
      }
      if(a[pos][to].l>a[pos][to].r) a[pos][to].flag=0;
      if(a[pos][to].flag==0) ff[pos]=1;
      i=j-1;
    }
  }
}

int main()
{
  int n;
  char s[100];
  while(scanf("%d",&n)!=EOF)
  {
    getchar();
    memset(ff,0,sizeof(ff));
    for(int i=0;i<n;i++)
    {
      mo=0;
      gets(s);
      solve(i,s);
    }
    for(int i=0;i<n;i++)
    {
      bool flag=0;
      for(int u=0;u<i;u++)
      {
        if(ff[i]==1) continue;
        if(ff[u]==1) continue;
        int j;
        for(j=1;j<=ao[i];j++)
        {
          if(a[i][j].flag==0) break;
          int pos=m[u][a[i][j].s];
          if(pos==0) break;
          if(a[i][j].r<a[u][pos].l||a[i][j].l>a[u][pos].r);
          else break;
        }
        if(j>ao[i]);
        else
        {
          if(flag==1) printf(" ");
          flag=1;
          printf("%d",u+1);
        }
      }
      if(flag==0) printf("unique\n");
      else printf("\n");
    }
  }
  return 0;
}