2016年天梯赛初赛题集

知识点：

转换大小写：

自带函数

transform(str.begin(),str.end(),str.begin(),::tolower);

transform(str.begin(),str.end(),str.begin(),::toupper);

或者遍历数组， s[i]=tolower(s[i]); s[i]=toupper(s[i]);

或者自己通过遍历将每个字符+-32来改变大小写。

7-1 到底有多二（15 分）

一个整数“犯二的程度”定义为该数字中包含2的个数与其位数的比值。如果这个数是负数，则程度增加0.5倍；如果还是个偶数，则再增加1倍。例如数字-13142223336是个11位数，其中有3个2，并且是负数，也是偶数，则它的犯二程度计算为：

输入格式：

输入第一行给出一个不超过50位的整数N。

输出格式：

在一行中输出N犯二的程度，保留小数点后两位。

输入样例：

-13142223336

输出样例：

81.82%
思路：
因为数字的位数比较多，而且还需要知道每一位是否是2，所以用字符串比较合适。
1. 遍历字符串每个字符，输出'2'的个数
2. 判断字符串第一个字符是否为'-'
3. 判断最后一个字符c是否为偶数，(c-'0')%2
4. 计算并保留两位小数。
无需注意的知识点。

#include <bits/stdc++.h>
#define N 1000
using namespace std;
int main()
{
    string s;
    int i, n = 0,x;
    double k = 1;
    cin >> s;
    x = s.length();
    for(i = 0;i < s.length();i++)
    {
        if(s[i] == '2')
            n++;
    }
    if(s[0] == '-')
    {
        k+=0.5;
        x-=1;
    }
    if((s[s.length()-1] - '0')%2 == 0)
        k*=2;
    double t = (double)n/x * k * 100;
    printf("%.2f%%",t);
}

7-2 大笨钟（10 分）

微博上有个自称“大笨钟V”的家伙，每天敲钟催促码农们爱惜身体早点睡觉。不过由于笨钟自己作息也不是很规律，所以敲钟并不定时。一般敲钟的点数是根据敲钟时间而定的，如果正好在某个整点敲，那么“当”数就等于那个整点数；如果过了整点，就敲下一个整点数。另外，虽然一天有24小时，钟却是只在后半天敲1~12下。例如在23:00敲钟，就是“当当当当当当当当当当当”，而到了23:01就会是“当当当当当当当当当当当当”。在午夜00:00到中午12:00期间（端点时间包括在内），笨钟是不敲的。

下面就请你写个程序，根据当前时间替大笨钟敲钟。

输入格式：

输入第一行按照hh:mm的格式给出当前时间。其中hh是小时，在00到23之间；mm是分钟，在00到59之间。

输出格式：

根据当前时间替大笨钟敲钟，即在一行中输出相应数量个Dang。如果不是敲钟期，则输出：

Only hh:mm.  Too early to Dang.

其中hh:mm是输入的时间。

输入样例1：

19:05

输出样例1：

DangDangDangDangDangDangDangDang

输入样例2：

07:05

输出样例2：

Only 07:05.  Too early to Dang.

思路：

这个题非常有意思，敲钟只在后半天敲，而且只要过了整点，就会多敲一下。

在这，我是用字符串处理的。主要考虑两个问题：

1. 判断是否需要敲钟

2. 若需要，敲几下

前半天的时间：

第一个字符是不是'0'，如果是'0'，则不用敲；

如果第一个字符是'1'，则判断第二个字符是不是'0'或'1'或'2'（题目已说明，12：00不敲钟）；

如果第一个字符是'1'且第二个字符是'2'，则判断后两个字符是否同时为'0'，若不同时为'0'，则敲一声；

后半天的时间：

13点的时候敲1下，14点敲2下……所以在整点20点以前的时候敲s[1]-'2'下，非整点敲s[1]-'2'+1下

20点及以后，20点敲8下，21点敲9下……，所以整点20-23点，敲s[1]-'0'+8下，非整点敲s[1]-'0'+9下

#include <bits/stdc++.h>
#define N 1000
using namespace std;
int main()
{
    string s;
    cin >> s;
    if(s[0] == '0' || (s[0] == '1' && s[1] >= '0' && s[1] <= '2'))
    {
        if(s[1] == '2' && (s[3] > '0' || s[4] > '0'))
            cout << "Dang";
        else
            cout << "Only " << s << ".  Too early to Dang.
";
    }
    else
    {
        if(s[0] == '1')
        {
            if(s[3] == '0' && s[4] == '0')
            {
                for(int i = 0;i < s[1]-'2';i++)
                    cout << "Dang";
            }
            else
            {
                for(int i = 0;i < s[1]-'2'+1;i++)
                    cout << "Dang";
            }
        }
        if(s[0] == '2')
        {
            if(s[3] == '0' && s[4] == '0')
            {
                for(int i = 0;i < s[1]-'0'+8;i++)
                    cout << "Dang";
            }
            else
            {
                for(int i = 0;i < s[1]-'0'+9;i++)
                    cout << "Dang";
            }
        }
    }
}

7-3 谁先倒（15 分）

划拳是古老中国酒文化的一个有趣的组成部分。酒桌上两人划拳的方法为：每人口中喊出一个数字，同时用手比划出一个数字。如果谁比划出的数字正好等于两人喊出的数字之和，谁就输了，输家罚一杯酒。两人同赢或两人同输则继续下一轮，直到唯一的赢家出现。

下面给出甲、乙两人的酒量（最多能喝多少杯不倒）和划拳记录，请你判断两个人谁先倒。

输入格式：

输入第一行先后给出甲、乙两人的酒量（不超过100的非负整数），以空格分隔。下一行给出一个正整数N（

甲喊 甲划 乙喊 乙划

其中喊是喊出的数字，划是划出的数字，均为不超过100的正整数（两只手一起划）。

输出格式：

在第一行中输出先倒下的那个人：A代表甲，B代表乙。第二行中输出没倒的那个人喝了多少杯。题目保证有一个人倒下。注意程序处理到有人倒下就终止，后面的数据不必处理。

输入样例：

输出样例：

A
1
思路：
此题在有一个人倒下时，就可return 0；故可设计一个标记，有个人倒下后跳出循环（也就不需要再输入数据）。
na，nb记录A B的酒量，xa,xb记录实际喝的酒量。flag置1；
开始划拳（while(flag)）,输了的酒量加一
  当xa>na || xb>nb时，flag置0，跳出循环。

#include <bits/stdc++.h>
#define N 1000
using namespace std;
int main()
{
    int na, nb, i, n, xa = 0, xb = 0, flag = 1;
    cin >> na >> nb;
    cin >> n;
    int z, x, c, v;
    while(flag)
    {
        cin >> z >> x >> c >> v;
        int temp = z+c;
        if(temp == x && temp != v)
        {
            xa++;
        }
        if(temp == v && temp != x)
        {
            xb++;
        }
        if(xa > na)
        {
            cout << "A
" << xb;
            flag = 0;
        }
        if(xb > nb)
        {
            cout << "B
" << xa;
            flag = 0;
        }
    }
}

7-4 帅到没朋友（20 分）

当芸芸众生忙着在朋友圈中发照片的时候，总有一些人因为太帅而没有朋友。本题就要求你找出那些帅到没有朋友的人。

输入格式：

输入第一行给出一个正整数N（

注意：没有朋友的人可以是根本没安装“朋友圈”，也可以是只有自己一个人在朋友圈的人。虽然有个别自恋狂会自己把自己反复加进朋友圈，但题目保证所有K超过1的朋友圈里都至少有2个不同的人。

输出格式：

按输入的顺序输出那些帅到没朋友的人。ID间用1个空格分隔，行的首尾不得有多余空格。如果没有人太帅，则输出No one is handsome。

注意：同一个人可以被查询多次，但只输出一次。

输入样例1：

3
3 11111 22222 55555
2 33333 44444
4 55555 66666 99999 77777
8
55555 44444 10000 88888 22222 11111 23333 88888

输出样例1：

10000 88888 23333

输入样例2：

3
3 11111 22222 55555
2 33333 44444
4 55555 66666 99999 77777
4
55555 44444 22222 11111

输出样例2：

No one is handsome

思路：
首先，此题五个测试点，sample1等价；sample2等价；最大数据；有朋友圈只有一个人；输出前补0，最小case。
第一次只对了两个等价测试点，第二次最大/小规模，第三次有朋友圈只有一个人。
难点：朋友圈只有一个人（k=1）的情况，（只有一个人即这个人是自己）。
题目中的两个温馨提示：
注意：没有朋友的人可以是根本没安装“朋友圈”，也可以是只有自己一个人在朋友圈的人。
注意：同一个人可以被查询多次，但只输出一次。
我用了两个map，just判断朋友圈的人数是否大于1，a则用于输出的时候标记，以便同一个人只输出一次。
如果朋友圈人数大于1，则输入的每个s，just[s]=1,否则(没安装或朋友圈内只有自己)just[s]为默认值0；
对于待查询名单name[]，遍历(flag用于标记是否存在很帅的人，初始0)
  若此name很帅(just[]==0)且此name第一次出现(a[]==0)，则输出此name，flag=1
若查询完毕后，flag==0，则输出 No one is handsome

#include <bits/stdc++.h>
#define N 10001
using namespace std;
int main()
{
    map <string, int> just, a;
    int n, k, i, j;
    string s, name[N];
    cin >> n;
    for(i = 0;i < n;i++)
    {
        cin >> k;
        if(k > 1)
        {
            for(j = 0;j < k;j++)
            {
                cin >> s;
                just[s] = 1;
            }
        }
        if(k == 1)
            cin >> s;
    }
    cin >> k;
    for(i = 0;i < k;i++)
    {
        cin >> name[i];
    }
    int flag = 0;
    for(i = 0;i < k;i++)
    {
        if(just[name[i]] == 0 && a[name[i]] != 1)
        {
            a[name[i]] = 1;
            if(flag == 0)
                cout << name[i];
            if(flag)
                cout << " " << name[i];
            flag = 1;
        }
    }
    if(!flag)
    {
        cout << "No one is handsome";
    }
}

7-5 重要的话说三遍（5 分）

这道超级简单的题目没有任何输入。

你只需要把这句很重要的话 —— “I'm gonna WIN!”——连续输出三遍就可以了。

注意每遍占一行，除了每行的回车不能有任何多余字符。

#include <bits/stdc++.h>
#define N 1000
using namespace std;
int main()
{
    cout << "I'm gonna WIN!
";
    cout << "I'm gonna WIN!
";
    cout << "I'm gonna WIN!
";
}

7-6 奇偶分家（10 分）

给定N个正整数，请统计奇数和偶数各有多少个？

输入格式：

输入第一行给出一个正整N（

输出格式：

在一行中先后输出奇数的个数、偶数的个数。中间以1个空格分隔。

输入样例：

9
88 74 101 26 15 0 34 22 77

输出样例：

3 6

#include <bits/stdc++.h>
#define N 1010
using namespace std;
int main()
{
    int n, i, even = 0, odd = 0, x;
    cin >> n;
    for(i = 0;i < n;i++)
    {
        cin >> x;
        if(x%2 == 0)
            even++;
        else
            odd++;
    }
    printf("%d %d", odd, even);
}

7-7 输出GPLT （20 分）

给定一个长度不超过10000的、仅由英文字母构成的字符串。请将字符重新调整顺序，按GPLTGPLT....这样的顺序输出，并忽略其它字符。当然，四种字符（不区分大小写）的个数不一定是一样多的，若某种字符已经输出完，则余下的字符仍按GPLT的顺序打印，直到所有字符都被输出。

输入格式：

输入在一行中给出一个长度不超过10000的、仅由英文字母构成的非空字符串。

输出格式：

在一行中按题目要求输出排序后的字符串。题目保证输出非空。

输入样例：

pcTclnGloRgLrtLhgljkLhGFauPewSKgt

输出样例：

GPLTGPLTGLTGLGLL

思路：
这个题对我来说一开始有点儿困难了，虽然满分20分。不知道怎样按照G、P、L、T的顺序输出。
此题用栈或队列比较合适，但由于将字母按一定顺序存入容器中，输出的时候是“先进先出”，故选择队列。
将字符串的字母转换大小写的函数：
transform(s.begin(), s.end(), s.begin(), ::toupper);
后来总算开了窍，之前总是想着在字符串遍历的同时进行一系列操作，并输出GPLT。
其实我们可以换一种思路，字符串遍历记录下G、P、L、T各自的数量（我们不作为，只记录），然后按照顺序压入队列。
压完后，再循环队列，从队头开始输出。这样简单多了。

#include <bits/stdc++.h>
#define N 10001
using namespace std;
int main()
{
    string s;
    int i, g = 0, p = 0, l = 0, t = 0;
    cin >> s;
    transform(s.begin(), s.end(), s.begin(), ::toupper);for(i = 0;i < s.length();i++)
    {
        if(s[i] == 'G')
            g++;
        else if(s[i] == 'P')
            p++;
        else if(s[i] == 'L')
            l++;
        else if(s[i] == 'T')
            t++;
    }
    i = 1;
    queue<char> q;
    while(i <= g || i <= p || i <= l || i <= t)
    {
        if(i <= g)
            q.push('G');
        if(i <= p)
            q.push('P');
        if(i <= l)
            q.push('L');
        if(i <= t)
            q.push('T');
        i++;
    }
    while(!q.empty())
    {
        cout << q.front();
        q.pop();
    }
}

7-8 后天（5 分）

如果今天是星期三，后天就是星期五；如果今天是星期六，后天就是星期一。我们用数字1到7对应星期一到星期日。给定某一天，请你输出那天的“后天”是星期几。

输入格式：

输入第一行给出一个正整数D（1

输出格式：

在一行中输出D天的后天是星期几。

输入样例：

输出样例：

#include <bits/stdc++.h>
#define N 1000
using namespace std;
int main()
{
    int n;
    cin >> n;
    switch(n)
    {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        cout << n+2 << endl;
        break;
    case 6:
        cout << 1 << endl;
        break;
    case 7:
        cout << 2 << endl;
        break;
    }
}

7-9 抢红包（25 分）

没有人没抢过红包吧…… 这里给出

输入格式：

输入第一行给出一个正整数

其中

输出格式：

按照收入金额从高到低的递减顺序输出每个人的编号和收入金额（以元为单位，输出小数点后2位）。每个人的信息占一行，两数字间有1个空格。如果收入金额有并列，则按抢到红包的个数递减输出；如果还有并列，则按个人编号递增输出。

输入样例：

10
3 2 22 10 58 8 125
5 1 345 3 211 5 233 7 13 8 101
1 7 8800
2 1 1000 2 1000
2 4 250 10 320
6 5 11 9 22 8 33 7 44 10 55 4 2
1 3 8800
2 1 23 2 123
1 8 250
4 2 121 4 516 7 112 9 10

输出样例：

思路：
这个题没什么好说的，不知道为什么会25分，难道是因为用了结构体和排序规则？
每个人编号，抢到红包就给这个人加相应的钱数，红包个数也加一。
对每行数据，第i行为编号为i的人发红包，记录发的红包总额，此人的money减去相应钱数。
随后sort，print就行了，注意单位转换。

#include <bits/stdc++.h>
#define N 10001
using namespace std;
typedef struct
{
    int x;
    int money = 0;
    int pack = 0;
}People;
bool cmp(People p1, People p2)
{
    if(p1.money != p2.money)
        return p1.money > p2.money;
    else if(p1.pack != p2.pack)
        return p1.pack > p2.pack;
    else
        return p1.x < p2.x;
}
int main()
{
    int n, i, k, w, m, j, money = 0;
    cin >> n;
    People p[n+1];
    for(i = 1;i <= n;i++)
    {
        money = 0;
        p[i].x = i;
        cin >> k;
        for(j = 0;j < k;j++)
        {
            cin >> w >> m;
            money+=m;
            p[w].money+=m;
            p[w].pack++;
        }
        p[i].money-=money;
    }
    sort(p+1,p+n+1,cmp);
    for(i = 1;i <= n;i++)
    {
        printf("%d %.2f
", p[i].x, p[i].money*0.01);
    }
}

7-10 排座位（25 分）

布置宴席最微妙的事情，就是给前来参宴的各位宾客安排座位。无论如何，总不能把两个死对头排到同一张宴会桌旁！这个艰巨任务现在就交给你，对任何一对客人，请编写程序告诉主人他们是否能被安排同席。

输入格式：

输入第一行给出3个正整数：N（

这里假设朋友的朋友也是朋友。但敌人的敌人并不一定就是朋友，朋友的敌人也不一定是敌人。只有单纯直接的敌对关系才是绝对不能同席的。

输出格式：

对每个查询输出一行结果：如果两位宾客之间是朋友，且没有敌对关系，则输出No problem；如果他们之间并不是朋友，但也不敌对，则输出OK；如果他们之间有敌对，然而也有共同的朋友，则输出OK but...；如果他们之间只有敌对关系，则输出No way。

输入样例：

输出样例：

No problem
OK
OK but...
No way

思路：
此题用到并查集（朋友的朋友也是朋友），并查集已经百度了很多，也理解了大概意思。（自己再用可能还会费点劲）
1代表朋友关系，-1代表敌对关系，0既不是朋友，也不是敌对关系。p[][]代表两位宾客的关系。宾客从1编号。
对于朋友关系，设每个人的祖先(fri[])都是0，若两个人之间是朋友关系且祖先(通过father函数求祖先)不同，则fri[a]=b（两队合为一队）。
注意fri[]（表示某人的祖先是谁的数组）需要设成全局变量。

对于每次查询：
若是朋友关系，则 No problem ；
若是敌对关系且祖先不同，则 No way ；
若是0，则 OK ；
若是敌对关系且祖先相同，则 OK but... 。

#include <bits/stdc++.h>
#define N 101
using namespace std;
int fri[N] = {0};
int father(int x);
int main()
{
    int n, m, k, i, j, p[N][N] = {0}, a, b, c;
    cin >> n >> m >> k;
    for(i = 0;i < m;i++)
    {
        cin >> a >> b >> c;
        p[a][b] = p[b][a] = c;
        if(c == 1)
        {
            int x = father(a);
            int y = father(b);
            if(x != y)
                fri[x] = y;
        }
    }
    for(i = 0;i < k;i++)
    {
        cin >> a >> b;
        if(p[a][b] == -1 && father(a) != father(b))
        {
            cout << "No way
";
            continue;
        }
        else if(p[a][b] == 1)
        {
            cout << "No problem
";
            continue;
        }
        else if(p[a][b] == -1 && father(a) == father(b))
        {
            cout << "OK but...
";
            continue;
        }
        else if(p[a][b] == 0)
        {
            cout << "OK
";
            continue;
        }
    }
}
int father(int x)
{
    int t = x;
    while(true)
    {
        if(fri[t] == 0)
            return t;
        t = fri[t];
    }
}

此博文为作者原创，转载请注明来源：https://www.cnblogs.com/zcl843264327/p/10461240.html

相关阅读:
【Opencv】直方图函数 calchist()
【Lintcode】070.Binary Tree Level Order Traversal II
【C++】*p++ = *p不同环境下操作不同
 【Python】String 字符串
 【Python】File IO
栈和队列
 链表
 printf 的格式
 Linux的基本指令--
机器人的运动范围
原文地址：https://www.cnblogs.com/zcl843264327/p/10461240.html