2019燕山大学程序设计新生赛（二）

你的名字 2023-06-22 05:24 2阅读 0赞

### 2019燕山大学程序设计新生赛（二） ###

*   *   *  绝地武士
         *   *  参考代码
         *  织梦岛
         *   *  参考代码
         *  谍战风云
         *   *  参考代码

### 绝地武士 ###

天赋异禀的绝地武士安纳金·天行者受西斯大帝达斯·西迪厄斯蛊惑，堕入原力黑暗面，随后被派去绝地圣殿进行大清洗。同时西迪厄斯向克隆人军队发出第 66 号命令：杀掉所有绝地武士。克隆人军队的制度，是每支部队由一名绝地武士指挥官率领。于是，许多冲锋在第一线，与独立星系邦联作战正酣的绝地武士，毫无征兆地就被身边下属枪杀了。安纳金也忠实完成任务，在绝地圣殿中屠戮了所有看到的武士和学徒，从老到小赶尽杀绝。由此，绝地武士教团不复存在，共和国被彻底颠覆，银河系进入了黑暗的帝国独裁时期。

为了对抗西斯，仅存的绝地武士开始对绝地学徒进行紧急练习，但是在经历了大屠杀后，绝地武士显得有些人手不够了，我们必须最优化训练的安排

每一个绝地学徒都有一个能力值，在接受了绝地武士培训后的绝地学徒也可以教导能力值比他小的其他绝地学徒

比如说，绝地学徒A的能力值是5600，绝地学徒B的能力值是5200，那么绝地武士在教导完A后，绝地学徒A可以指导绝地学徒B，这样的话，我们只需要一位绝地武士就能完成训练；

若绝地学徒B的能力值也是5600，那么A就不能指导B，我们就需要再安排一名绝地武士来指导绝地学徒B，那么完成训练一共就需要两位绝地武士

请输出完成训练最少需要几位绝地武士  
输入格式:  
输入包含多组测试数据，每组测试数据共包括 n+1 行，每一组的第一行是整数 n （n≤3000) 代表有 n 个待指导的绝地学徒  
接下来n行，每行输入一个数代表绝地学徒的能力值 q （q≤1030 ), 同时注意能力值 q 可能存在前置0，如0030即30

输出格式:  
对于每组测试数据输出一行，输出一个数代表最少需要多少位绝地武士  
输入样例

4
    10
    20
    30
    04
    5
    2
    3
    4
    3
    4

输出样例

1
    2

#### 参考代码 ####

/* 题意要求这些数，哪个数最多，最多为： */
    #include <bits/stdc++.h>
    using namespace std;
    map<string,int> str;
    
    int main()
    { 
        int n;
        while(cin>>n){ 
            string s1;
            str.clear();
            for(int i=0;i<n;++i){ 
                cin>>s1;
                int j;
                for(j=0;j<s1.size();++j){ 
                    if(s1[j]!='0')break;
                }
                s1=s1.substr(j);
                str[s1]++;
            }
            int ans=0;
            for(map<string,int>::iterator it=str.begin();it!=str.end();++it){ 
                if(it->second>ans)ans=it->second;
            }
            printf("%d\n",ans);
        }
    }

### 织梦岛 ###

林克完成“众神的三角力量”的冒险后出海修行，在乘船返回海拉尔的途中遭遇风暴，醒来时发现自己置身一个名叫库洪林的小岛上。村民告诉他如果想要离开这里，须从8个迷宫中获得8件塞壬的乐器，吹响“苏醒之歌”让风之鱼醒来

为此林克踏上了新的冒险，历经千辛万苦终于来到了脸孔神殿的迷宫，并成功取到了其中的乐器珊瑚三角铁，就在这时，迷宫开始崩塌了！林克必须尽快逃出去，请聪明的你来帮林克规划逃跑路线吧

脸孔神殿的迷宫是一个立方体，里面充满了岩石；迷宫一共有h层，每层都可以看作是一个x×y的矩形面，林克只可以向前后左右上下六个方向移动（值得一提的是，林克并没有办法击碎坚硬的岩石），每移动一步需要一秒钟（也就是说每一层一个x×y的矩形面，从一端移动到另一端需要x或者y秒）

除此以外，由于迷宫内机关的变化，林克也有可能会被岩石封住了逃生的道路哦

不同机关的变化会产生不同情况的迷宫，现在我们给出n个迷宫，请聪明的你想一想林克是否能成功逃生？如果能，最快需要多长时间  
输入格式:  
输入的第一行为 h, x, y(h,x,y≤30)h 表示迷宫的层数，x 和 y 表示每层迷宫的大小  
接下来依次输入 h 层迷宫，每层迷宫有 x 行，每行包括 y 个字符（其中’\#‘表示无法通过的岩石，’.'表示可以通行，'S’表示珊瑚三角铁的位置，'E’表示迷宫的逃生出口）  
每层迷宫输入结束后空一行，当h, x, y都等于0时输入结束  
输出格式:  
对于每一个迷宫输出一行，如果林克能够成功逃生则输出最少所需的时间，否则输出"YOU DIED"  
输入样例

3 4 5
    S....
    .###.
    .##..
    ###.#
    
    #####
    #####
    ##.##
    ##...
    
    .####
    ###.#
    #.###
    ####E
    
    1 3 3
    .#S
    #E#
    ###
    
    0 0 0

输出样例

11
    YOU DIED

#### 参考代码 ####

/* 最短路径算法 */
    /* 最短路径算法 */
    #include <bits/stdc++.h>
    using namespace std;
    const int maxn = 33;
    char a[maxn][maxn][maxn];
    int h, x, y;
    int pos[6][3] = { { -1, 0, 0}, { 1, 0, 0}, { 0, 1, 0}, { 0, -1, 0}, { 0, 0, 1}, { 0, 0, -1}};
    int sh, sx, sy; //开始位置
    int eh,ex,ey;//结束位置
    struct node{ 
        int h,x,y,step;
        node(int a,int b,int c,int d):h(a),x(b),y(c),step(d){ }
        node(){ }
    };
    queue<node> q;
    
    int bfs(){ 
        while(!q.empty())q.pop();
        q.push(node(sh,sx,sy,0));
        a[sh][sx][sy]='#'; //这里的起点可能不止一个取读取最后遇到的
        node tmp;
        int nh,nx,ny,ns;
        while(!q.empty()){ 
            tmp=q.front();
            q.pop();
            if(tmp.h==eh&&tmp.x==ex&&tmp.y==ey)return tmp.step;
            ns = tmp.step+1;
            for(int i=0;i<6;++i){ 
                nh = tmp.h+pos[i][0];
                nx = tmp.x+pos[i][1];
                ny = tmp.y+pos[i][2];
                if(nh<0||nh>=h||nx<0||nx>=x||ny<0||ny>=y)continue;//越界
                if(a[nh][nx][ny]!='#'){ 
                    q.push(node(nh,nx,ny,ns));
                    a[nh][nx][ny]='#';//标记被访问过
                }
            }
        }
        return -1;
    }
    
    int main()
    { 
        while (cin >> h >> x >> y && h)
        { 
            for (int i = 0; i < h; ++i)
            { 
                for (int j = 0; j < x; ++j)
                { 
                    for (int t = 0; t < y; ++t)
                    { 
                        cin >> a[i][j][t];
                        if (a[i][j][t] == 'S')
                        { 
                            sh = i;
                            sx=j;
                            sy=t;
                            //a[i][j][t] ='#';//标记被访问过
                        }else if(a[i][j][t]=='E'){ 
                            eh = i;
                            ex = j;
                            ey = t;
                        }//这里的终点可能不止一个取读取最后遇到的
                    }
                }
            }
            int minStep = bfs();
            if(minStep==-1){ 
               cout<<"YOU DIED"<<endl;
            }else { 
                cout<<minStep<<endl;
            }
        }
        return 0;
    }

### 谍战风云 ###

多年的厉兵秣马之后，恩希尔大帝发动了对北方的入侵，第一次北境战争打响。1263年7月，尼弗迦德军队越过阿梅尔山脉直取辛特拉。经过四天的艰苦战斗，帝国军最终攻陷了辛特拉都城，卡兰瑟女王自尽殉国，辛特拉灭亡。北境诸国此时才如梦方醒，派出了大量刺客和间谍潜入尼弗迦德  
恩希尔大帝在宴席上遇刺，但刺客的刀刃还没有来得及捅穿恩希尔大帝的胸膛就被制服了；恩希尔大帝震怒，下令在全国范围内排查缉拿来自北境诸国的卧底，根据已有的情报，卧底们都采用一种特殊的编号来互相识别身份。  
如果编号 q 满足如下情况即是卧底：  
q =  3 a 1   + 3 a  2 + 3 a 3 . . . . . . + 3 a n （ n ≥ 1 ） 3^\{a\_1\}+3^\{a\_2\}+3^\{a\_3\} ...... + 3^\{a\_n\}（n≥1） 3a1\+3a2\+3a3......\+3an（n≥1）; 其中 a 1 , a 2 , . . . a n a\_1,a\_2,...a\_n a1,a2,...an都是整数且各不相等  
如  4 = 3 1 + 3 0 4 = 3^1+3^0 4=31\+30  
输入格式:  
输入的第一行是一个正整数 n (n ⩽ 500)，代表有 n 组测试数据  
接下来 n 行，每行包含一个正整数 q（q ⩽ 10000)  
输入样例

6
    1
    2
    6
    13
    14
    3620

输出样例

1
    3
    9
    13
    27
    6561

#### 参考代码 ####

/* 先将所有的组合情况求出来，（利用2进制思想），然后二分就行 */
    #include <bits/stdc++.h>
    using namespace std;
    const int N=10,maxn=1<<10;
    int q[N];
    int sum[maxn],s,inx;
    
    int main(){ 
        q[0]=1;
        for(int i=1;i<N;++i)q[i]=q[i-1]*3;
        for(int i=1;i<maxn;++i){ 
            s=0;
            for(int j=0;j<N;++j)if((i>>j)&1)s+=q[j];
            sum[inx++]=s;
        }
        sort(sum,sum+inx);
        int d=0;sum[d++]=sum[0];
        for(int i=1;i<inx;++i)if(sum[i]!=sum[i-1])sum[d++]=sum[i];
        inx=d;
        scanf("%d",&s);
        while(s--){ 
            scanf("%d",&d);
            d=lower_bound(sum,sum+inx,d)-sum;
            printf("%d\n",sum[d]);
        }
    }