zoukankan      html  css  js  c++  java
  • 病毒&烦人的幻灯片

    《病毒》传送门

    《烦人的幻灯片》传送门

                                       病毒

    描述

        有一天,小y突然发现自己的计算机感染了一种病毒!还好,小y发现这种病毒很弱,只是会把文档中的所有字母替换成其它字母,但并不改变顺序,也不会增加和删除字母。

      现在怎么恢复原来的文档呢!小y很聪明,他在其他没有感染病毒的机器上,生成了一个由若干单词构成的字典,字典中的单词是按照字母顺序排列的,他把这个文件拷贝到自己的机器里,故意让它感染上病毒,他想利用这个字典文件原来的有序性,找到病毒替换字母的规律,再用来恢复其它文档。

      现在你的任务是:告诉你被病毒感染了的字典,要你恢复一个字母串。

    输入virus.in
    第一行为整数K(≤50000),表示字典中的单词个数。
    以下K行,是被病毒感染了的字典,每行一个单词。
    最后一行是需要你恢复的一串字母。
    所有字母均为小写。输出virus.out
    输出仅一行,为恢复后的一串字母。当然也有可能出现字典不完整、甚至字典是错的情况,这时请输出一个0。样例输入

    6
    cebdbac
    cac
    ecd
    dca
    aba
    bac
    cedab

    样例输出

    abcde

     

    思路:首先将每相邻的两个字符串进行比较;遇到不同的字母就建立边;

    最后进行拓扑排序即可;

    只是注意一点不能同时存在两条入度为零的边;

    还有就是注意有多个判错,不要遗漏;

    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<stack>
    #include<cstdlib> 
    #include<cmath>
    const int MAXN=50000;
    using namespace std;
    string a[MAXN];
    int maxnlength;
    struct node
    {
        int u;
        int v;
        int w;
        int next;
    }edge[MAXN];
    int rudu[MAXN];
    int head[MAXN];
    int num=1;
    int ans[10001];//保存拓扑排序的结果 
    int now=1;
    int n;
    int maxnchar=0;
    int map[101][101];
    void topsort()
    {
        stack<int>s;
        for(int i=1;i<=maxnchar;i++)
        {
            if(rudu[i]==0)
            {
                s.push(i);
                ans[now]=i;
                now++;
            }
        }
        int flag=0;
        while(s.size()==1)
        {
            if(s.size()>1)
            {
                cout<<"0"; 
                exit(0);
            }
            int p=s.top();
            s.pop();
            for(int i=head[p];i!=-1;i=edge[i].next)
            {
                rudu[edge[i].v]--;
                if(rudu[edge[i].v]==0)
                {
                    s.push(edge[i].v);
                    ans[now]=edge[i].v;
                    now++;
                }
            }
        }
    }
    
    void ppu()
    {
        edge[num].u=a[j][k]-96;
        edge[num].v=a[i][k]-96;
        edge[num].next=head[edge[num].u];
        head[edge[num].u]=num++;
        rudu[a[i][k]-96]++;
        flag2=1;
        map[a[j][k]-96][a[i][k]-96]=1;
    }
    int main()
    {
        
        scanf("%d",&n);
        for(int i=1;i<=n;i++)head[i]=-1;
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
            if(a[i].length()>maxnlength)
            maxnlength=a[i].length();
            for(int j=1;j<=a[i].length();j++)
            {
                if(a[i][j]-96>maxnchar)
                maxnchar=a[i][j]-96;
            }
        }
        int flag2=0;
        for(int i=2;i<=n;i++)
        {
            int j=i-1;
                for(int k=0;k<=min(a[i].length()-1,a[j].length()-1);k++)
                {
                    if(a[j][k]!=a[i][k])
                    {
                        if(map[a[j][k]-96][a[i][k]-96]==1||map[a[i][k]-96][a[j][k]-96]==1)
                        {
                            printf("0
    ");
                            exit(0);
                        }
                            ppu();
                        break;
                    }
                }
        }
        topsort();
        char sr[101];
        char huiche[1];
        gets(huiche);
        gets(sr);
        int l=strlen(sr);
        for(int i=0;i<=l;i++)
        {
            if(sr[i]-96>maxnchar)
            {
                printf("0
    ");
                exit(0);
            }
        }
        for(int i=0;i<=l;i++)
        {
            for(int j=1;j<=now-1;j++)
            {
                if(ans[j]==sr[i]-96)
                {
                    printf("%c",char(j+96));
                }
            }
        }
        return 0;
    }

                                               烦人的幻灯片

    题目描述

    李教授于今天下午做一个非常重要的演讲。不幸的是他不是一个非常爱整洁的人,他把自己做演讲要用的幻灯片随便堆放在一起。因此,演讲之前他不得不去整理这些幻灯片。做为一个讲求效率的学者,他希望尽可能简单地完成它。情况是这样,教授这次演讲一共要用n张幻灯片(n<=26),这n张幻灯片按照演讲要使用的顺序已经用数字1,2,…,n在上面编上了号。因为幻灯片是透明的,所以我们不能一下子看清每一个数字所对应的幻灯片。

    现在我们用大写字母A,B,C,。。。再次把幻灯片依次编上号,如样例所示,我们可以很快发现编号为A的幻灯片是第4张,把它抽出来后我们又可以确定编号为C的幻灯片是第2张,。。。

    你的任务是编写一个程序,把幻灯片的数字编号和字母编号对应起来,显然这种对应应该是唯一的;若是出现多种对应的情况或是某些数字编号和字母对应不起来,我们就称对应是无法实现的。

    输入格式

    第一行只有一个数n,表示有n张幻灯片,接下来的n行第行包括4个整数Xmin,Xmax,Ymin,Ymax(整数之间用空格分开),为幻灯片的坐标(该区域为幻灯片),这n张幻灯片按其在输入文件中出现的顺序从前到后依次编号为A,B,C,。。。再接下来的n行依次为n个数字编号的坐标X,Y,显然在幻灯片之外是不会有数字的。

    (其实是键盘输入了啦)

    输出格式

    若是对应可以实现,你的输出应该包括n行,每一行为一个字母和一个数字,中间以一个空格隔开,并且各行以字母的升序排列,注意输出的字母要大写并且顶格;反之,若是对应无法实现,在文件的第一行顶格输出None即可。行首行末无多余空格。

    样例输入

    4
    6 22 10 20
    4 18 6 16
    8 20 2 18
    10 24 4 8
    9 15
    19 17
    11 7
    21 11

    #include<cstdio>
    #include<cstring>
    #include<cstdlib>
    #include<iostream>
    using namespace std;
    
    int nb[30],map[30][30],ans[30],q[110],head=1,tail=1,n,i,j;
    struct qop{int ix,ax,iy,ay;}a[30];
    struct qup{int x,y;}b[30];
    
    int wow()
    {
        scanf("%d",&n);
        for(i=1;i<=n;i++)
        {
            scanf("%d%d%d%d",&a[i].ix,&a[i].ax,&a[i].iy,&a[i].ay);//记录每一张幻灯片的范围
        }
        for(i=1;i<=n;i++)
        {
            scanf("%d%d",&b[i].x,&b[i].y);//记录数字坐标
            for(j=1;j<=n;j++)
            {    if(b[i].x>a[j].ix&&b[i].x<a[j].ax&&b[i].y>a[j].iy&&b[i].y<a[j].ay)
                {  nb[i]++;//遍历一遍看看数字是否可能在幻灯片上 一个数字的位置可能有几张幻灯片
                   map[i][j]=1;}}}//顺便个他们打个标记
                   int wq=0;
        for(i=1;i<=n;i++)
        {   if(nb[i]==0)return false;//如果一个数字没有与之对应的 那他在所有的幻灯片之外 就错了
            else if(nb[i]==1)
            {q[tail++]=i;wq=1;}//对应数量唯一 那是确定一一对应的家伙,加进队列    
           // if(wq==0)return false;//如果没有唯一对应的数字与幻灯片 那也错了
        }
         while(head!=tail)
         {
            int u=q[head++],t;
            for(i=1;i<=n;i++)
            {
                if(map[u][i]==1)
                 {
                   ans[i]=u;t=i;//把数字和幻灯片对应起来,t代表第几张幻灯片,u就是数字啦
                 }
             }
            for(i=1;i<=n;i++)
            {
                if(map[i][t]==1)//如果楼上的幻灯片还与其他数字对应,
                                //而幻灯片又被去掉了,就要把其他数字对应幻灯片的数量减一
                {
                    map[i][t]=0;
                    nb[i]--;
                    if(nb[i]==1)q[tail++]=i;//如果有新的数字只有唯一对应 就入队
                }
            }
         }
         for(i=1;i<n-1;i++)if(q[i])return 1;
               else return 0;
    }
    void clean(void)
    {
        memset(nb,0,sizeof(nb));
        memset(ans,0,sizeof(ans));
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        memset(q,0,sizeof(q));
    }
    void out()
    {
        for(i=i;i<=n;i++)
        printf("%c%d
    ",i+64,ans[i]);//强制转换字母
    }
    int main()
    {
        
        clean();
        if(wow())out();
        else printf("NONE");
        return 0;
    }
  • 相关阅读:
    【Python学习之路】——Day20(Django 上)
    【Python学习之路】——WEB本质
    【Python学习之路】——Day16(JavaScript)
    【Python学习之路】——Day14(HTML)
    【Python学习之路】——Day13(Redis and Memcached)
    【Python学习之路】——Day12(python mysql)
    【Python学习之路】——Day11(I/O多路复用)
    【Python学习之路】——Day10(线程、进程)
    【Python学习之路】——Day9(网络编程socket)
    哲学家就餐-同步问题解析-python
  • 原文地址:https://www.cnblogs.com/qdscwyy/p/6719350.html
Copyright © 2011-2022 走看看