程序设计实践练习题

阅读前请先了解此博客存在的不足与缺陷
博主开始写代码时对c++并未了解太多，头文件由于方便懒 都用的万能头
万能头优点就是简单，不用记太多头文件，缺点就是编译慢。
以及对变量的初始化，不应每次循环都重新定义，应使用循环重新赋值。
ps：存在很多问题，但是不想改了，但是阅读者应该了解。

1262 Fish

Description

钓鱼

题目描述

小明很喜欢钓鱼，现在有n 个池塘可以钓鱼，第i 个池塘首次内能钓到a i 条鱼。 第i 个池塘如果被钓过k 次，那么每次下一次能钓到的鱼的数目为max{0,a i −k×b i } 。 现在小明能钓m 次鱼，请问他最多能钓到多少条鱼？

输入

第一行是一个整数T(1≤T≤100) ，表示样例的个数。
每个样例的第一行是n(1≤n≤1000),m(1≤m≤100000) ；
以后的n行，每行是a i (1≤a i ≤10000),b i (0≤b i ≤10000) 。

输出

每行输出一个样例的结果。

样例输入

2
3 5
3 1
4 2
1 0
2 5
2 1
1 1

样例输出

12
4

样例解释

第一个样例，在第1个池塘钓3次，第2个池塘钓2次，3+2+1+4+2 = 12；
第二个样例，在第1个池塘钓2次，第2个池塘钓1次，2+1+1 = 4。

#include
using namespace std;

struct pond
{
     
    int a;//参数ai
    int b;//参数bi
    int f;//某次钓鱼数量
    int k;//钓的次数
}ponds[1002];

bool cmp(const pond &pond1, const pond &pond2)
{
     
    return pond1.f>pond2.f;
}

int sorts(int n)
{
     
    for(int i = 1; i < n; i++)
    {
     
        if(ponds[i-1].f < ponds[i].f)
            swap(ponds[i-1],ponds[i]);
        else
            break;
    }
    return 0;
}

int main()
{
     
    int T,n,m;
    int fish;
    cin >> T;//T组样例
    while(T--)
    {
     
        fish = 0;
        cin >> n >> m;
        for(int i = 0; i < n; i++)
            cin >> ponds[i].a >> ponds[i].b;
        for(int j = 0; j < n ;j++)
        {
     
            ponds[j].f = ponds[j].a;
            ponds[j].k = 0;
        }
        sort(ponds,ponds+n,cmp);//排序
        /*每次都是ponds[0]被选择以及改变，所以被选择后只需要在排好序列中添加此更改的数据*/
        /*或者采用优先队列*/
        for(int i = 0; i < m; i++)
        {
     
            fish += ponds[0].f;
            ponds[0].k++;
            ponds[0].f = max(0,ponds[0].a - ponds[0].k * ponds[0].b);
            sorts(n);
            if(ponds[0].f == 0)
                break;
        }
        cout << fish <<endl;
    }
    return 0;
}

1271 Color

Description

染色

题目描述

Alice在玩一个游戏，她在一个m×n 的格子里，随机涂黑k 个格子。然后她每次可以把一行或者一列的格子染成红色，但是这一行中不能有黑色的格子。 请问她最多能把多少个格子涂成红色？

输入

第一行是一个整数T(T≤100) ，表示样例的个数。 每个样例的第一行是m(1≤m≤100),n(1≤n≤100),k(0≤k≤m×n) 。 以后的k 行,每行两个整数x(1≤x≤m),y(1≤y≤n) ，表示(x,y) 为黑色格子。

输出

每行输出一个样例的结果。

样例输入

1
3 4 2
1 1
3 3

样例输出

8

提示

样例如

#include
using namespace std;
int main()
{
     
    int T;
    int m,n,k;
    cin >> T;
    while(T--)
    {
     
        int c[102][102] = {
     0};//第0行第0列设置为额外空间
        cin >> m >> n >> k;
        int summ = 0,sumn = 0;
        for(int i = 0; i < k; i++)
        {
     
            int x,y;
            cin >> x >> y;
            c[x][0] = 1;//记录某行或某列被标记
            c[0][y] = 1;
        }
        for(int i = 1; i < m+1; i++)
        {
     
            if(c[i][0] == 0)
                summ++;
        }
        for(int i = 1; i < n+1; i++)
        {
     
            if(c[0][i] == 0)
                sumn++;
        }
        cout << m*sumn+n*summ-sumn*summ << endl;//公式计算
    }
    return 0;
}

1163 ASCII

Description

题目描述

给你一段ASCII编码的文字，输出其每个字符的ASCII码。

输入

一段文字，由ASCII码字符组成。

输出

先输出行号，行号为16进制，占5位，从0开始计数，行号前导为0，然后空一格。 每行最多输出32个字符的ASCII码，每个ASCII码为16进制，占2位，前导为0，中间用空格隔开。 所有16进制使用大写A_F表示1015。最后一行行末无空格，无换行。

样例输入

ACM International Collegiate Programming Contest,
I LOVE YOU
Lotus is a mystic symbol. 

样例输出

00000 41 43 4D 20 49 6E 74 65 72 6E 61 74 69 6F 6E 61
00001 6C 20 43 6F 6C 6C 65 67 69 61 74 65 20 50 72 6F
00002 67 72 61 6D 6D 69 6E 67 20 43 6F 6E 74 65 73 74
00003 2C 0A 49 20 4C 4F 56 45 20 59 4F 55 0A 4C 6F 74
00004 75 73 20 69 73 20 61 20 6D 79 73 74 69 63 20 73
00005 79 6D 62 6F 6C 2E 20 0A

#include
using namespace std;

int main()
{
     
    string str,str1;
    int m = 1;
    while(getline(cin,str1))//获取一行输入
    {
     
        str += str1;//连接字符串
        str +='\n';//加上换行符
    }
    printf("%05X ",m/16);//5位,大写前导0
    for(int i = 0; i < str.length()-1;i++)
    {
     
        printf("%02X",int(str[i]));
        if(m%16 == 0)
        {
     
            cout << endl;
            printf("%05X ",m/16);
        }
        else
            cout<<' ';
        m++;
    }
    printf("%02X",int(str[str.length()-1]));
    return 0;

}

1243 Bob’s Password

Description

Bob’s Password

题目描述

Bob最新购入一款安卓手机，他发现安卓手机密码使用的是画线方式。
一共有9个点，我们按行列顺序依次为1~9。密码要求在点和点之间连线不能有还未曾经过的点。
比如说：从1出发，可以到2，4，5，6，7，8，但是不能到达3，7，9。
但是如果从2出发，先到1，这时因为2已经经过了，所以此时可以到达3。
现在给你一个密码，请问它是否符合密码的这个要求？

输入

第一行是一个整数T(1≤T≤10000) ，表示样例的个数。
一个样例占一行，是一个最短为4位，最长9位，只含1-9的字符串，且1-9最多只有1个。

输出

每个样例输出一行，如果合法输出“Yes”，否则输出“No”。

样例输入

3
16852
213
132

样例输出

Yes
Yes
No

#include
using namespace std;
int main()
{
     
    int T;
    cin >> T;
    int chose[10][10];
    chose[1][3]=1;
    chose[1][7]=1;
    chose[1][9]=1;
    chose[2][8]=1;
    chose[3][1]=1;
    chose[3][9]=1;
    chose[3][7]=1;
    chose[4][6]=1;
    chose[6][4]=1;
    chose[7][1]=1;
    chose[7][3]=1;
    chose[7][9]=1;
    chose[8][2]=1;
    chose[9][1]=1;
    chose[9][3]=1;
    chose[9][7]=1;

    while(T--)
    {
     
        string str;
        int num[10];
        bool chos[10];
        int t = 0;
        for(int i = 0; i < 10; i++)
            chos[i]= false;
        cin >> str;
        for(int i= 0; i < str.length(); i++)
        {
     
            num[i+1] = int(str[i])-48;
        }
        chos[num[1]] = true;
        for(t = 2; t <= str.length(); t++)
        {
     
            if(chose[num[t-1]][num[t]] == 1 && !chos[(num[t-1]+num[t])/2])
            {
     
                cout << "No" << endl;
                break;
            }
            chos[num[t]] = true;
        }
        if(t > str.length())
            cout << "Yes" <<endl;
    }
}

1246 Matrix Transposition

Description

Matrix Transposition

题目描述

矩阵转置就是把原矩阵A的所有元素a ij 转成矩阵B的b ji 。 现实中，大部分的矩阵都是稀疏的,所以,存储矩阵时，我们可以只存储存储每个非零元素的坐标和值，并且按行优先排序。 比如说3×3 矩阵

0 1 0
0 2 3
0 0 0

其转置矩阵为

0 0 0
1 2 0
0 3 0

上面矩阵使用稀疏矩阵的存储方法存(i,j,a ij ) 为

0 1 1
1 1 2
1 2 3

其转置矩阵

1 0 1
1 1 2
2 1 3

输入

第一行是一个整数T,(0 每个样例的第一行是三个整数N,M,K,1≤N,M≤1000,1≤K≤10000 ，分别表示矩阵的行数，列数，非零元素个数。
以后的K行，每行三个整数X,Y,V,0≤X 数据保证输入元素的顺序按行优先有序。

输出

输出每个样例的结果，每个样例输出之后有一个空行。

样例输入

2  
3 3 3  
0 1 1  
1 1 2  
1 2 3  
1 3 1  
0 0 1

样例输出

1 0 1  
1 1 2  
2 1 3

0 0 1

#include
using namespace std;
struct XYV
{
     
    int x;
    int y;
    int v;
}XYVs[10001];
bool cmp(const XYV &xyv1,const XYV &xyv2)
{
     
    if(xyv1.y  == xyv2.y)
        return xyv1.x <xyv2.x;
    else
        return  xyv1.y < xyv2.y;
}
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        int N,M,K;//分别表示矩阵的行数，列数，非零元素个数
        cin >> N >> M >> K;
        for(int i = 0; i < K; i++)
        {
     
            cin >> XYVs[i].x >> XYVs[i].y >> XYVs[i].v;
        }
        sort(XYVs,XYVs+K,cmp);
        for(int i = 0; i < K; i++)
        {
     
            cout << XYVs[i].y << ' ' << XYVs[i].x << ' ' << XYVs[i].v<< endl;
        }
        cout << endl;
    }
    return 0;
}

1248 Alice and Bob

Description

Alice and Bob

题目描述

Alice和Bob在玩骰子游戏，他们用三颗六面的骰子，游戏规则如下：
1.点数的优先级是1点最大，其次是6,5,4,3,2。
2.三个骰子点数相同，称为"豹子"，豹子之间按点数优先级比较大小。
3.如果只有两个骰子点数相同，称为"对子"，对子之间按点数优先级比较大小。
4.其他情况称为"点子"，点子按点数和比较大小。
5.豹子比对子、点子大，对子比点子大，如果对子的点数优先级相同，就看剩余那个骰子的点数优先级。

现在给你Alice和Bob投掷骰子的情况，判断一下胜负情况。

输入

第一行输入一个整数K，表示游戏的次数。 以后每两行表示一个样例，第一行是Alice骰子的点数。第二行是Bob骰子的点数。

输出

如果是Alice赢，输出"Alice",如果是Bob赢，输出"Bob",否则输出"Draw"。

样例输入

3
1 1 1
6 6 6
2 1 2
4 5 4
4 5 6
6 5 4

样例输出

Alice
Bob
Draw

#include
using namespace std;
int Jud(int* A)//以数字大小比较优先级
{
     
    if(A[0] == A[1])
    {
     
        if(A[0] == A[2])
        {
     
            if(A[0] == 1)
                return 100*7;
            else
                return 100*A[0];
        }
        else
        {
     
            if(A[0] == 1)
                return 10*7+A[2];
            else if(A[2] == 1)
                return 10*A[0]+7;
            else
                return 10*A[0]+A[2];
        }
    }
    else if(A[0] == A[2])
    {
     
        if(A[0] == 1)
            return 10*7+A[1];
        else if(A[1] == 1)
            return 10*A[0]+7;
        else
            return 10*A[0]+A[1];
    }
    else if(A[1] == A[2])
    {
     
        if(A[1] == 1)
            return 10*7+A[0];
        else if(A[0] == 1)
            return 10*A[1]+7;
        else
            return 10*A[1]+A[0];
    }
    else
        return A[0]+A[1]+A[2];
}

int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        int A[3];
        int B[3];
        scanf("%d %d %d",&A[0],&A[1],&A[2]);
        scanf("%d %d %d",&B[0],&B[1],&B[2]);
        int dian1 = Jud(A);
        int dian2 = Jud(B);
        if(dian1 > dian2)
            printf("Alice\n");
        else if(dian1 < dian2)
            printf("Bob\n");
        else
            printf("Draw\n");
    }
    return 0;
}

1251 Colombian Number

Description

Colombian Number

题目描述

对于正整数n ,不存在整数k ,使得n 等于k 加上k 的数码累加和，我们称这样的数是哥伦比亚数或者自我数。
比如 11就不是一个哥伦比亚数，因为10加上10的数码累加和1等于11;而20则是一个哥伦比亚数。

输入

第一行是一个整数K(K≤10,000) ，表示样例的个数。
以后每行一个正整数n(1≤n≤1,000,000,000)

输出

每行输出一个样例的结果，如果是哥伦比亚数输出"Yes",否则输出"No"。

样例输入

5
1
2
3
20
21

样例输出

Yes
No
Yes
Yes
No

#include
using namespace std;

int Colnum(int i)
{
     
    int m = i;
    while(i != 0)
    {
     
        m += i%10;
        i /= 10;
    }
    return m;
}
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        int n,i;
        bool flag = true;
        cin >> n;
        for(i = n-1; i > 0 && i > n-81; i--)
        {
     
            if(Colnum(i) == n)
            {
     
                flag = false;
                break;
            }
        }
        if(flag)
            cout << "Yes" << endl;
        else
            cout << "No" << endl;
    }
    return 0;
}

1253 Robot

Description

Robot

题目描述

有N 个任务需要Robot去完成，这个N个任务的地点在一个数轴上，坐标为1 到n 。每个任务需要先完成a i 个任务才能开始去做。Robot可以在直线上左右移动，初始位置位于任务1 的地点，方向朝向数轴正方向。请问Robot最少转换多少次方向可以完成所有的任务。

输入

存在多个样例。
每个样例的第一行是一个整数n(1≤n≤1000) ,
第二行是一个n 个整数a 1 ,a 2 ,⋯,a n (0≤a i 输入数据保证一定能完成任务。

输出

每行输出一个样例的结果

样例输入

3
0 2 0
7
0 3 1 0 5 2 6

样例输出

1
2

#include
using namespace std;
int main()//贪心，贪每次移动都是从一端到另一端
{
     
    int n;
    while(cin >> n)
    {
     
        int sum = 0;
        int tran = 0;
        int m[1001] = {
     0};
        int fin[1001] = {
     0};
        for(int i = 0; i < n; i++)
        {
     
            scanf("%d",&m[i]);
        }
        while(true)
        {
     
            for(int i = 0; i < n; i++)
            {
     
                if(fin[i] == 0)
                {
     
                    if(sum >= m[i])
                    {
     
                        sum++;
                        fin[i] = 1;
                    }
                }
            }
            if(sum >= n)
                break;
            tran++;
            for(int i = n-1; i >= 0;  i--)
            {
     
                if(fin[i] == 0)
                {
     
                    if(sum >= m[i])
                    {
     
                        sum++;
                        fin[i] = 1;
                    }
                }
            }
            if(sum >= n)
                break;
            tran++;
        }
        cout << tran << endl;
    }
    return 0;
}

1252 Matrix Word

Description

Matrix Word

题目描述

一个n×m 的矩阵，矩阵每个元素是一个小写英文字母，如果某个字母所在行或者列不是唯一的，那么我们就删掉这个字符。最后，我们按矩阵的从上到下，从左到右，可以得到一个单词。比如，矩阵为

abb
bca
acb

我们可以发现只有第二行的b和a是所在行和列唯一的，所以最后的单词为ba。

输入

存在多个输入样例，每个样例的第一行是两个整数n 和m (1≤n,m≤100) 。
以后是一个n×m 的矩阵，矩阵每个元素一个小写英文字母。
输入数据保证结果不为空。

输出

每行输出一个样例的结果。

样例输入

3 3
aac
bca
abb
5 5
epero
gerea
emeee
meien
egeee

样例输出

cbca
programming

#include
using namespace std;
int main()
{
     
    int n,m;
    while(cin >> n >> m)
    {
     
       char c[101][101];
       getchar();
       for(int i = 0; i < n; i++)
       {
     
           scanf("%s",c[i]);
       }
       for(int i = 0; i < n; i++)
       {
     
           for(int j = 0; j < m; j++)
           {
     
               int t,k;
               for(t = 0; t < n; t++)
               {
     
                   if(c[i][j] == c[t][j] && i != t)
                   {
     
                       break;
                   }
               }
               for(k = 0; k < m; k++)
               {
     
                   if(c[i][j] == c[i][k] && j != k)
                   {
     
                       break;
                   }
               }
               if(t >= n && k >= m)
               {
     
                   cout << c[i][j];
               }
           }
       }
       cout << endl;
    }
    return 0;
}

1261 Duplicate Elements

Description

Duplicate Elements

题目描述

给你n 个数，祛除其中的重复的数，并保持第一次出现的数原有的相对顺序。比如{3,2,2,3,1} ，那么祛除重复元素以后为{3,2,1} 。

输入

第一行是一个整数K ,K 表示样例的个数，不超过100。
每个样例的第一行是一个整数n(1≤n≤10000。) 表示数的个数；第二行是n 个正整数，其值不超过10 9 。

输出

每行输出一个样例的结果，每个整数之间用一个空格隔开。

样例输入

2
5
3 2 2 3 1
3
1 2 3

样例输出

3 2 1
1 2 3

提示

巨大的输入输出，请使用C风格的输入输出，避免超时。

#include
using namespace std;
int main()
{
     
    int T;
    scanf("%d",&T);
    while(T--)
    {
     
        int m[10001] = {
     0};
        int num[10001][2] = {
     0};
        int n;
        scanf("%d",&n);
        for(int i = 0; i < n; i++)
            scanf("%d",&m[i]);
        int t = 0;//多少个不重复元素
        for(int i = 0; i < n; i++)//遍历m
        {
     
            int j;
            for(j = 0; j <= t; j++)//遍历不重复元素数组，寻找是否有与m[i]相同的数
            {
     
                if(m[i] == num[j][0])//若找到相同的数，令数的个数+1，跳出
                {
     
                    num[j][1]++;
                    break;
                }
            }
            if(j > t)//没有找到，则添加进数组
            {
     
                t++;
                num[t][0] = m[i];
                num[t][1]++;
            }
        }
        for(int i= 1; i < t; i++)
            printf("%d ",num[i][0]);
        printf("%d\n",num[t][0]);
    }


    return 0;
}

1263 矩形面积的并

Description

矩形面积的并

题目描述

给两个边平行于坐标轴的矩形，求两个矩形的面积并。

输入

存在多个样例，每个样例包括2行，每行是一个矩形，为矩形一个对角线端点的坐标x 1 ,y 1 ,x 2 ,y 2 ，0≤x 1 ,y 1 ,x 2 ,y 2 ≤1000。

输出

每行输出一个样例的结果。

样例输入

0 0 1 1
0 0 2 1
0 0 2 2
1 1 3 3
0 0 1 1
2 2 3 3
0 0 2 1
1 1 2 2 

样例输出

2
7
2
3

提示

巨大的输入输出，请使用C风格的输入输出，避免超时。

#include
using namespace std;
int main()
{
     
    int x1,x2,x3,x4,y1,y2,y3,y4;
    while(scanf("%d %d %d %d",&x1,&y1,&x2,&y2) != EOF)
    {
     
        scanf("%d %d %d %d",&x3,&y3,&x4,&y4);
        int l,r,u,d;
        int s = 0;
        l = max(min(x1,x2),min(x3,x4));//相交矩形的四边
        r = min(max(x1,x2),max(x3,x4));
        d = max(min(y1,y2),min(y3,y4));
        u = min(max(y1,y2),max(y3,y4));
        if(l > r || d > u)//不相交
        {
     
            s = abs(x1-x2)*abs(y1-y2)+abs(x3-x4)*abs(y3-y4);
        }
        else
            s = abs(x1-x2)*abs(y1-y2)+abs(x3-x4)*abs(y3-y4)-(r-l)*(u-d);
        cout << s << endl;
    }
    return 0;
}

1268 鞍点

Description

矩阵的鞍点

题目描述

给一个矩阵A n×m ，其元素a ij 我们称其为鞍点，则满足它是第i 行里最大值且第j 列里最小值或者第i 行里最小值且第j 列里最大值。 现在给你一个矩阵，请求出其所有的鞍点。

输入

第一行是一个整数T(1≤T≤100) ，表示样例的个数。 每个样例的第一行是两个整数n,m(1≤n,m≤100) ，表示矩阵的行和列的大小。
以后的n 行，每行m 个整数，表示元素a ij (0≤a ij ≤1000) 。

输出

如果存在鞍点，则先输出一行，鞍点个数，。 然后按行优先原则，输出所有鞍点坐标（坐标从0开始计数）和鞍点的值，每行输出一个。
如果不存在鞍点，则输出“None”。

样例输入

2
3 3
1 2 3
4 5 4
1 4 3
3 3
1 5 2
7 3 6
4 8 9

样例输出

3
0 2 3
1 0 4
1 2 4
None

#include
using namespace std;
priority_queue <int,vector<int>,less<int> > p;//大到小
priority_queue <int,vector<int>,greater<int> > q;//小到大
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        int n,m;
        int flag = 0;
        cin >> n >> m;
        int num[102][102] = {
     0};
        int c[10001][2] = {
     0};
        getchar();
        for(int i = 1; i <= n; i++)
        {
     
            for(int j = 1; j <= m; j++)
            {
     
                scanf("%d",&num[i][j]);
                p.push(num[i][j]);
                q.push(num[i][j]);
            }
            num[i][0] = q.top();//i行最小值
            num[i][m+1] = p.top();//i行最大值
            while(!p.empty())
            {
     
                q.pop();
                p.pop();
            }
        }
        for(int j = 1; j <= m; j++)
        {
     
            for(int i = 1; i <= n; i++)
            {
     
                p.push(num[i][j]);
                q.push(num[i][j]);
            }
            num[0][j] = q.top();//j列最小值
            num[n+1][j] = p.top();//j列最大值
            while(!p.empty())
            {
     
                q.pop();
                p.pop();
            }
        }
        for(int i = 1; i <= n; i++)
        {
     
           for(int j = 1; j <= m; j++)
           {
     
               if((num[i][0]==num[n+1][j]) ||(num[0][j]==num[i][m+1]))
               {
     
                   c[flag][0] = i;
                   c[flag][1] = j;
                   flag++;
               }
           }
        }
        if(flag == 0)
            printf("None\n");
        else
        {
     
            printf("%d\n",flag);
            for(int i = 0; i < flag; i++)
            {
     
                printf("%d %d %d\n",c[i][0]-1,c[i][1]-1,num[c[i][0]][c[i][1]]);
            }
        }
    }
    return 0;
}

1272 Robot

Description

Robot

题目描述

机器人一开始站在原点，可以上下左右（分别用“UDLR”表示）移动，每次移动一步。Estrella想知道对于某个指令序列，如果把某一种指令全部替换成另一种指令，新的指令序列可以让机器人回到原点。

输入

存在多个样例，每个样例一行，为一条指令序列，长度不超过200。

输出

每行输出一个样例的结果，可以输出“Yes”，否则输出“No”。

样例输入

LD
LLDDD

样例输出

Yes
No

#include
using namespace std;
int main()
{
     
    string str;
    while(getline(cin,str))
    {
     
        int U = 0,D = 0,L = 0,R = 0;
        for(int i = 0; i < str.length(); i++)
        {
     
            if(str[i] == 'U')
                U++;
            else if(str[i] == 'D')
                D++;
            else if(str[i] == 'L')
                L++;
            else if(str[i] == 'R')
                R++;
        }
        if(U == 0 || D == 0 || L == 0 || R == 0)
        {
     
           if(abs(U-D) == abs(L-R))
            {
     
                cout << "Yes" << endl;
            }
            else
                cout << "No" << endl;
        }
        else
            cout << "No" << endl;
    }
    return 0;
}

1277 Tri-Triangle

Description

Triangle

题目描述

给定一个字母，请输出其对应的字母三角形（最后一行行首，每行末无空格）。 比如输入E，输出

         A
        ABA
       ABCBA 
      ABCDCBA
     ABCDEDCBA
    A         A
   ABA       ABA 
  ABCBA     ABCBA 
 ABCDCBA   ABCDCBA
ABCDEDCBA ABCDEDCBA

输入

存在多个样例，每行输入一个大写字母。

输出

依次输出每个字符对应的字符三角形。

样例输入

A
B
C

样例输出

 A
A A
   A
  ABA
 A   A
ABA ABA
     A
    ABA
   ABCBA
  A     A
 ABA   ABA 
ABCBA ABCBA

#include
using namespace std;
void print1(int n)
{
     
    for(int i  = 0; i < n; i++)
        printf(" ");
}
void print2(int m)
{
     
    for(int i = 0; i < m; i++)
        printf("%c",'A'+i);
    for(int i = 1; i < m; i++)
        printf("%c",'A'+m-i-1);
}
int main()
{
     
    char k;
    while(scanf("%c",&k) != EOF)
    {
     
        int n = int(k-'A');
        for(int i = 0; i < n+1; i++)
        {
     
            print1(2*n+1-i);
            print2(i+1);
            printf("\n");
        }
        for(int i = n; i >= 0; i--)
        {
     
            print1(i);
            print2(n-i+1);
            print1(2*i+1);
            print2(n-i+1);
            printf("\n");
        }
    }
    return 0;
}

1280 String Hash

Description

String Hash

题目描述

把字符串进行Hash，来判断字符串是否相等是一种很常见的技术。 对一个只含英文小写字母字符串进行Hash，一种比较简单的方法是把字符串看成一个26进制的数，a_{z分别表示0}25，获得这个值后对某个素数p取模。但是因为a是0，所以"abc"和"bc"的Hash值肯定是一样的，为了解决这个问题，我们假定在字符串前加入字符b（即26进制数最高位为1）比如p=11，字符串"abc",相当于26进制数"1012"，所以对应的十进制数为17604，所以哈希值为4。
我们假定p=1000000007，请将给定的字符串给出对应的hash值。

输入

存在多个样例。每行一个只含英文小写字母的字符串，长度不超过1000个字符。

输出

每行输出一个样例的结果

样例输入

abc
bc
abcdefghijklmnopqrstuvwxyz

样例输出

17604
704
115471061

#include
using namespace std;

int tran(string s)
{
     
    int n = 0;
    int p=1000000007;
    __int64 d = 1;
    int flag = 0;
	for(int i = s.size()-1;i >= 0; i--)
	{
     
		char t = s[i];
		int c = int(t)-int('a');
		if(flag == 1)
            d = d*26%p;
        n = ((c*d+n))%p;
        flag = 1;
	}
    return n;
}

int main()
{
     
    string str,str1;
    while(getline(cin,str1))
    {
     
        str = 'b';
        str += str1;
        int ans = tran(str);
        printf("%d\n",ans);
    }
    return 0;
}

1281 Cute String

Description

Cute String

题目描述

Alice的记忆力不太好，如果一个句子中含的单词（每个单词之间用一个空格隔开）数量超过10，或者句子中字母种类（不区分大小写）超过10个，她就会记不住。现在给你若干个句子，请写个程序判断一下Alice是否能记住这些句子。

输入

存在多个样例。
每行输入一个字符串，表示句子。字符串长度不超过200，只含英文字母和空格。
输入数据保证每个单词之间只有一个空格，行末没有空格。

输出

对于每个样例，能记住，输出“Yes”，否则输出“No”。

样例输入

Alice is a smart girl
but she is bad in memory
a b c d e f g h i j
A B C D E F G H I J K

样例输出

Yes
No
Yes
No

#include
using namespace std;
int main()
{
     
    string str;
    while(getline(cin,str))
    {
     
        transform(str.begin(),str.end(),str.begin(),::tolower);
        char m[30]= {
     '0'};
        int sum1 = 0,sum2 = 0;
        int flag = 0;
        for(int i = 0; i < str.size(); i++)
        {
     
            if(str[i] == ' ')
                sum1++;
            else
            {
     
                int j;
                for(j = 0; j < sum2; j++)
                {
     
                    if(str[i] == m[j])
                    {
     
                        break;
                    }
                }
                if(j >= sum2)
                {
     
                    m[sum2] = str[i];
                    sum2++;
                }
            }
            if(sum1 > 9 || sum2 >10)
            {
     
                flag = 1;
                break;
            }
        }
        if(flag == 1)
            cout << "No" << endl;
        else
            cout << "Yes" << endl;
    }
    return 0;
}

1284 多项式

Description

多项式

题目描述

求

输入

第一行是一个整数T(1≤T≤1000) ，表示样例的个数。
每个样例的第一行是三个整数n(1≤n≤10)，m(1≤m≤10000)，x(1≤x≤10000) 。
第二行是n+1 个整数{a i ∣i=n,n−1,⋯,0,0≤a i ≤10000} 。

输出

每行输出一个非负整数，即一个样例的结果。

样例输入

2
1 10 2
2 1
1 10 2
1 2

样例输出

5
4

样例解释

第一个样例，表达式为f(x)=2x+1mod10 ,所以f(2)=5 。
第二个样例，表达式为f(x)=x+2mod10 ，所以f(2)=4 。

#include
using namespace std;
int main()
{
     
    int T;
    scanf("%d",&T);
    while(T--)
    {
     
        int n,m,x;
        scanf("%d %d %d",&n,&m,&x);
        int ans = 0;
        int xi = 1;
        int a[11] = {
     0};
        for(int i = n; i >= 0; i--)
        {
     
            scanf("%d",&a[i]);
        }
        for(int i = 0; i <= n; i++)
        {
     
            if(i == 0)
                xi = 1;
            else
                xi = xi*x%m;
            ans = (ans+a[i]*xi)%m;
        }
        printf("%d\n",ans);
    }
    return 0;
}

1286 比赛

Description

Contest

题目描述

有n 名选手参加比赛，从1∼n 编号。每场比赛由两位选手对决，失败的被淘汰。为了增加比赛的观赏性，举办方并不想比赛双方实力相差太大的，所以决定，每场比赛的两位选手，之前胜场次数之差不能超过1。同时，鸡贼的举办方又不想冠军选手比赛太少了（严重影响比赛收入），希望冠军选手比赛场次越多越好。作为选手的你，当然不希望夺冠路上比赛场次太多，请问在这个赛制下，冠军最多比赛多少场？

输入

存在不超过10000组样例。每行一个整数n(1≤n≤10 18 ) 。

输出

每行输出一个样例的结果，为一个整数。

样例输入

1
2
3
10
1000000000000000000

样例输出

0
1
2
4
85

样例解释

我们假定冠军是1号。
第3个样例，1号依次击败2和3号。
第4个样例，其中一种比赛路线是1击败2，3击败4，1击败3，5击败6，1击败5，7击败8，9击败10，7击败9，1击败7。

#include
using namespace std;
__int64 m[86];
void test()
{
     
    m[0] = 1;
    m[1] = 2;
    for(int i = 2; i < 86; i++)
    {
     
        m[i] = m[i-1] + m[i-2] + 1;
    }
}
int main()
{
     
    __int64 n;
    test();
    while(scanf("%I64d",&n) != EOF)
    {
     
        for(int i = 0; i < 86; i++)
        {
     
            if(n <= m[i])
            {
     
                cout << i << endl;
                break;
            }
        }
    }
    return 0;
}

1291 Buying Gifts

Description

Buying Gifts

题目描述

快到年末了，Boss Liu准备在年会上发些礼物，由于不想礼物的价格区别太大，Boss Liu希望最好的礼物与最差的礼物价格相差越小越好。 当然，如果存在相同的选择，Boss Liu希望花的钱越少越好。
Boss Liu把这个买礼物的任务给你，你决定写个程序来帮助自己计算一下。

输入

第一行是一个整数K，表示样例的个数。
每个样例的第一行是一个整数n,m(1≤m≤n≤1000) ，分别表示可购买的礼物的个数和实际需要购买的个数。
每个样例的第二行是n个整数x i ,i=1,2,⋯,n(1≤x i ≤100) ，表示n个礼物的价格。

输出

每个样例输出两个整数，分别表示最小的价差以及总的花费，中间用一个空格隔开。

样例输入

2
5 3 
10 5 9 7 2 
5 1 
10 5 9 7 2

样例输出

3 26 
0 2

线索

第一个样例，购买10,9,7的礼物的差值最小为3，总花费是26。
第二个样例，因为只买一样所以差值都是0，最小花费是2。

#include
using namespace std;
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        int n,m;
        int mins = 101;
        int flag = 0;
        int sum = 0;
        int x[10001];
        cin >> n >> m;
        for(int i = 0; i < n; i++)
            scanf("%d",&x[i]);
        sort(x,x+n);
        for(int i = 0; i+m-1 < n; i++)
        {
     
            int minc = x[i+m-1] - x[i];
            if(minc < mins)
            {
     
                mins = minc;
                flag = i;
            }
        }
        for(int i = flag; i < flag+m; i++)
            sum += x[i];
        cout << mins << ' ' << sum << endl;
    }
    return 0;
}

1292 Co-string

Description

Co-String

题目描述

如果一个长度为2n 的字符串(a 1 ,a 2 ,a 3 ,⋯,a 2n ) ，满足a i =a i+n ,i=1,2,⋯,n ，我们称这样的字符串为"co-string"。
现在给你一个只含英文小写字母的字符串，请找出其最长的"co-string"子串的长度。

输入

第一行是一个整数K(K≤100) ，表示样例的个数。
每个样例占一行是一个长度不超过1000的字符串,全是小写英文字母。

输出

依次，每行输出一个样例的结果，如果不存在"co-string"子串，输出0。

样例输入

2
abbab
aaaabbbbbb

样例输出

2
6

线索

第一个样例，只有co-string子串"bb"，所以长度是2。
第二个样例，最长的co-string子串是"bbbbbb",所以长度是6。

#include
using namespace std;
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        char s[1001];
        scanf("%s",s);
        int i,j,k;
        int l = strlen(s);
        for(i = l/2; i >= 0; --i)
        {
     
            for(j = 0; j <= l-2*i; j++)
            {
     
                for(k = j; k < i+j; k++)
                {
     
                    if(s[k] != s[k+i])
                        break;
                }
                if(k >= i+j)
                {
     
                    printf("%d\n",i*2);
                    break;
                }
            }
            if(j <= l-2*i)
                break;
        }
    }
    return 0;
}

1293 Diamond

Description

Diamond

题目描述

根据给出的尺寸n 输出一个字符钻石，比如n=3 时，字符钻石为

  C
 CBC 
CBABC
 CBC
  C 

输入

第一行是整数K，表示样例的个数。
以后每行一个样例，为钻石的尺寸，n(1≤n≤26)

输出

依次输出每个样例的结果，每个样例的行末无空格，行首无多余的空格。

样例输入

3
1
2
3

样例输出

A
 B
BAB
 B
  C
 CBC 
CBABC
 CBC
  C 

#include
using namespace std;
void print1(int n)
{
     
    for(int i  = 0; i < n; i++)
        printf(" ");
}
void print2(int n,int m)
{
     
    for(int i = 0; i < m; i++)
        printf("%c",'A'+n-i-1);
    for(int i = m-1; i > 0; i--)
        printf("%c",'A'+n-i);
    printf("\n");
}
int main()
{
     
    int T,n;
    cin >> T;
    while(T--)
    {
     
        cin >> n;
        for(int i = 0; i < n; i++)
        {
     
            print1(n-i-1);
            print2(n,i+1);
        }
        for(int i = n-2; i >= 0; i--)
        {
     
            print1(n-i-1);
            print2(n,i+1);
        }
    }
    return 0;
}

1294 Enquiry

Description

Enquiry

题目描述

男女同学排成一列，你想知道第i个到第j个同学之间，男女相邻排列的出现次数。

输入

第一行是一个整数K，表示样例的个数。
每个样例的第一行是一个字符串s，其长度len不超过10000，只含字符M和F，M表示男生，F表示女生。
每个样例的第二行是一个整数n(1≤n≤1000) ，表示查询的次数。
以后的N行,每行两个整数i,j(1≤i

输出

每个样例的每次查询输出一个整数。

样例输入

2
MMMMM
3
1 2
1 3
1 5
MFMFM
3
1 5
2 3
3 5

样例输出

0
0
0
4
1
2

#include
using namespace std;
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        string str;
        int n,x,y;
        int ans;
        int s[10000] = {
     0};
        cin >> str;
        for(int i = 1; i < str.size(); i++)
        {
     
            if(str[i-1] != str[i])
                s[i-1] = 1;
        }
        cin >> n;
        for(int i = 0; i < n; i++)
        {
     
            scanf("%d %d",&x,&y);
            ans= 0;
            for(int j = x-1; j < y-1; j++)
                ans += s[j];
            cout << ans <<endl;
        }
    }
    return 0;
}

1296 GCD

Description

GCD

题目描述

a 和b 的最大公约数(Greatest Common Divisor)是最大的d ，d 能整除a 和b 。
如果gcd(a,b)=1 ，我们就称a 和b 是互素的。
给一个区间[a,b] ，求与6 互素的数的个数。
比如区间[1,10] ,与6 互素的数为1,5,7 ,所以一共是3个。

输入

第一行是一个整数K(K≤10,000) ，表示样例的个数。
每个样例占一行,为区间[a,b],(1≤a≤b≤1,000,000,000)

输出

每行输出一个样例的结果

样例输入

2
1 10
1 1000000000

样例输出

3
333333333

#include
using namespace std;
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        int a,b;
        int a1,b1;
        int ans;
        cin >> a >> b;
        a1 = (a-1)/2+(a-1)/3-(a-1)/6;
        b1 = b/2+b/3-b/6;
        ans = b-b1-(a-1-a1);
        cout << ans <<endl;
    }
    return 0;
}

1299 String

Description

String

题目描述

一个字符串，有以下三种操作

现在给你初始字符串和一个指令序列，请执行这个指令序列。

输入

包含不多于100个样例。 每个样例第一行是一个只含英文大写字母的字符串，长度不超过100。 以后是不超过100行的指令序列，如果指令为"END"，表示指令序列的结束。

输出

依次执行指令，输出格式如"x:s"这样的结果，其中x为指令序号（从1开始），s为执行之后的字符串。 每个样例之后输出一个空行。

样例输入

AABBCC
S 2 4 C
T C D
END
AABBCC
T C D
S 2 4 C
END

样例输出

1:ACCCCC
2:ADDDDD

1:AABBDD
2:ACCCDD

#include
using namespace std;
int main()
{
     
    char str[101];
    while(scanf("%s",str) != EOF)
    {
     
        char k[101] = {
     0};
        int n = 0;
        while(scanf("%s",k) != EOF)
        {
     
            int x,y;
            char c[101],d[101];
            if(k[0] == 'E')
                break;
            else if(k[0] == 'S')
            {
     
                scanf("%d %d %s",&x,&y,c);
                for(int i = x-1; i < y; i++)
                    str[i] = c[0];
                n++;
            }
            else if(k[0] == 'T')
            {
     
                scanf("%s %s",c,d);
                for(int i = 0; i < strlen(str); i++)
                {
     
                    if(str[i] == c[0])
                        str[i] = d[0];
                }
                n++;
            }
            cout << n << ":" << str <<endl;
        }
        cout << endl;
    }
    return 0;
}

1300 Dice

Dice

题目描述

六面的骰子

骰子的六个面分别为1,2,3,4,5,6点。

大话骰游戏的规则如下：
1.有6颗骰子
2.你可以说自己有多少个某种点数的骰子，比如说“3个6”，“5个1”。
3.计数的时候，1点可以做任意的点数的骰子。比如说你有2个1点，4个6点，如果你说你有“6个6”说的是真话。

现在知道6颗骰子的点数和说的话，请判断话的真伪（该点数的骰子不够这么多个就是假话，否则为真话）。

输入

第一行是一个整数T(1≤T≤100) ，表示样例的个数。 每个样例的第一行是两个整数，第一个是六位整数，每个位上是数码1∼6 ，表示你的6颗骰子的点数，第二个整数是你说话的数量m(1≤m≤10) 。 以后的m 行，每行两个整数n(1≤n≤6),k(1≤k≤6) ,表示你说的话是“你有n 个k 点骰子”。

输出

依次输出每个样例中对于话真假的判断，输出格式是"x:s ",x 表示话的序号，从1开始，s 表示判断结果，如果是真话，输出true，否则输出false。 每个样例的结尾输出一个空行。

样例输入

2
123456 6
1 1
2 1
1 2
2 3
2 4
3 5
111111 6
6 6
6 5
6 4
6 3
6 2
6 1 

样例输出

1:true
2:false
3:true
4:true
5:true
6:false

1:true
2:true
3:true
4:true
5:true
6:true

#include
using namespace std;
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        char s[10];
        int m[7] = {
     0};
        int n,x,y;
        bool ans = false;
        int ansn = 0;
        scanf("%s %d",s,&n);
        for(int i = 0; i < 6; i++)
        {
     
            if(s[i] == '1')
                m[1]++;
            else if (s[i] == '2')
                m[2]++;
            else if (s[i] == '3')
                m[3]++;
            else if (s[i] == '4')
                m[4]++;
            else if (s[i] == '5')
                m[5]++;
            else if (s[i] == '6')
                m[6]++;
        }
        while(n--)
        {
     
            scanf("%d %d",&x,&y);
            if(y == 1 && m[1] >= x)
            {
     
                ans = true;
                ansn++;
            }
            else if(m[y]+m[1] >= x && y != 1)
            {
     
                ans = true;
                ansn++;
            }
            else
            {
     
                ans = false;
                ansn++;
            }
            if(ans)
                cout << ansn << ":true" << endl;
            else
                cout << ansn << ":false" << endl;
        }
        cout << endl;
    }
    return 0;
}

1301 Zeroes

Description

Zeroes

题目描述

将n 个数排成一个圆圈，每一轮我们进行下面的操作，每个数与自己顺时钟方向的下一个数差的绝对值作为新一轮的数。
经过若干轮后，这些数可能全部都变成0 。比如{2,3,4,5}→{1,1,1,3}→{0,0,2,2}→{0,2,0,2}→{2,2,2,2}→{0,0,0,0} ，经过5轮得到全是0 。
请写一个程序，判断一下给定的数圈是否能在不超过1000 轮之内，迭代变成全0 。

输入

第一行是一个整数T(1≤T≤1000) 表示样例的个数。
每个样例的第一行是整数n(2≤n≤15) ，表示圈中数的个数。
每个样例的第二行是n 个整数，a i ,0≤a i ≤1000,i=1,2,…,n 。

输出

每行输出一个样例的结果，如果不可能变成全0，输出“Impossible”；否则，输出迭代的轮次。

样例输入

2
4
2 3 4 5
3
1 3 5

样例输出

5
Impossible

#include
using namespace std;
int main()
{
     
    int T;
    scanf("%d",&T);
    while(T--)
    {
     
        int n;
        int m[15] = {
     0};
        int flag = 0;
        scanf("%d",&n);
        for(int i = 0; i < n; i++)
        {
     
            scanf("%d",&m[i]);
            flag += m[i];
        }
        int i = 0;
        for(i = 0; i <= 1000; i++)
        {
     
            if(flag == 0)
            {
     
                printf("%d\n",i);
                break;
            }
            int temp = m[0];
            flag = 0;
            for(int j = 1; j < n; j++)
            {
     
                m[j-1] = abs(m[j-1]-m[j]);
                flag += m[j-1];
            }
            m[n-1] = abs(m[n-1]-temp);
            flag += m[n-1];
        }
        if(i > 1000)
            printf("Impossible\n");
    }
    return 0;
}

1305 斐波那契区间

Description

斐波那契区间

题目描述

一个数列a 1 ,a 2 ,⋯,a n ，如果对于区间[L,R],1≤L≤R≤n,∀i(L≤i≤R−2),a i+2 =a i+1 +a i ，那么我们称其为斐波那契区间。求数列中最长的斐波那契区间长度。

输入

第一行是一个整数T(1≤T≤1000) ，表示样例的个数。
每个样例有两行，第一行是数列的元素个数n(2≤n≤10000) 。
第二行是n 个整数a i (0≤a i ≤10 9 ) 。

输出

每行输出一个样例的结果。

样例输入

2
10
1 2 3 5 8 13 21 34 55 89
5
1 1 1 1 1 1

样例输出

10
2

#include
using namespace std;
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        int a[10001] = {
     0};
        int n;
        scanf("%d",&n);
        int ans = 0;
        int L = 2;
        for(int i = 0; i < n; i++)
            scanf("%d",&a[i]);
        for(int i = 2; i < n; i++)
        {
     
            if(a[i] == a[i-1]+a[i-2])
            {
     
                L++;
                ans = max(ans,L);
            }
            else
            {
     
                ans = max(ans,L);
                L = 2;
            }
        }
        cout << ans << endl;
    }
    return 0;
}

1308 比赛

Description

比赛

题目描述

有n个人要进行比赛，比赛规则如下：
1.假设每轮比赛的人是m，取最大的k，k=2 t 且k≤m 。这k个人每2人举行一场比赛，胜利者进入一下轮，失败者被淘汰。
2.余下的m-k个人，不进行比赛，直接进入下一轮
3.直到决出冠军，比赛结束。

比如有5个人参加比赛，第一轮举办2场，剩余3人进入第二轮，第二轮1场，剩余2人进入第三轮，第三轮举办1场决出冠军，所以一共要办4场比赛。 请问一共要举行几轮多少场比赛？

输入

第一行是一个整数K，表示样例的个数。 以后每行一个样例，为n(1≤n≤1000000000)

输出

每行输出两个整数，轮数和比赛场数，中间用一个空格隔开。

样例输入

2
1
5

样例输出

0 0
3 4

#include
using namespace std;
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        int n;
        int k = 1;
        cin >> n;
        int m = 0;
        int ans = 0;
        while(n > 2)
        {
     
            while(k <= n)
                k = k << 1;
            k = k >> 2;
            m += k;
            n -= k;
            ans ++;
        }
        if(n == 2)
        {
     
            ans++;
            m++;
        }
        cout << ans << ' ' << m <<endl;
    }
    return 0;
}

1239 2048

Description

2048

题目描述

2048是大家非常喜欢的一款小游戏，给定一个2048的局面，和下一步的指令，请计算出变化后的局面。 2048的游戏规则如下：
•游戏是一个4×4 的格子
•玩家可以使用上、下、左、右控制数字方格滑动，
•每滑动一次，所有的数字方块都会往滑动的方向靠拢，相同数字的方块在靠拢、相撞时会相加。
•不断的叠加最终拼凑出2048这个数字就算成功
•每次滑动后，会在某个空白格子中出现随机的2或者4，如果不存在空白格子，则游戏结束。

输入

第一行是一个整数K，表示样例的个数。 每个样例的前4行，每行4个整数，如果整数为0表示空白格子，其他为数字。 每个样例的第5行，是指令，指令为"LEFT",“DOWN”,“RIGHT”,“UP”,依次表示滑动的方向。

输出

输出每个样例的结果,每个样例后输出一个空行。

样例输入

3
2 2 0 0
2 0 2 0
2 0 0 2
0 0 2 2
LEFT
2 0 2 0
2 2 2 2
0 2 0 2
4 2 2 0
LEFT
2 4 2 2
0 2 2 0
0 4 4 4
0 0 0 2
LEFT

样例输出

4 0 0 0
4 0 0 0
4 0 0 0
4 0 0 0

4 0 0 0
4 4 0 0
4 0 0 0
4 4 0 0

2 4 4 0
4 0 0 0
8 4 0 0
2 0 0 0

#include
using namespace std;
void LEFT(int m[4][4]);
void RIGHT(int m[4][4]);
void DOWN(int m[4][4]);
void UP(int m[4][4]);
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        int m[4][4] = {
     0};
        char n[6] = {
     0};
        for(int i = 0; i < 4; i++)
            for(int j = 0; j < 4; j++)
                scanf("%d",&m[i][j]);
        scanf("%s",n);
        if(strcmp(n,"LEFT") == 0)//左滑
            LEFT(m);
        else if(strcmp(n,"RIGHT") == 0)//右滑
            RIGHT(m);
        else if(strcmp(n,"DOWN") == 0)//下滑
            DOWN(m);
        else if(strcmp(n,"UP") == 0)//上滑
            UP(m);
    }
    return 0;
}
void LEFT(int m[4][4])
{
     
    int x,y;//合并的值,位置
    for(int i = 0; i < 4; i++)
    {
     
        x = 0, y = 0;
        for(int j = 0; j < 4; j++)
        {
     
            if(m[i][j] != 0 && x == 0)
            {
     
                x = m[i][j];
                m[i][j] = 0;
                m[i][y] = x;
            }
            else if(m[i][j] != 0 && x != 0)
            {
     
                if(m[i][j] == x)
                {
     
                    m[i][j] = 0;
                    m[i][y] = 2*x;
                    y++;
                    x = 0;
                }
                else
                {
     
                    y++;
                    x = m[i][j];
                    m[i][j] = 0;
                    m[i][y] = x;
                }
            }
        }
    }
    for(int i = 0; i < 4; i++)
    {
     
        for(int j = 0; j < 3; j++)
            printf("%d ",m[i][j]);
        printf("%d\n",m[i][3]);
    }
    cout << endl;
}
void RIGHT(int m[4][4])
{
     
    int x,y;//合并的值,位置
    for(int i = 0; i < 4; i++)
    {
     
        x = 0, y = 3;
        for(int j = 3; j >= 0; j--)
        {
     
            if(m[i][j] != 0 && x == 0)
            {
     
                x = m[i][j];
                m[i][j] = 0;
                m[i][y] = x;
            }
            else if(m[i][j] != 0 && x != 0)
            {
     
                if(m[i][j] == x)
                {
     
                    m[i][j] = 0;
                    m[i][y] = 2*x;
                    y--;
                    x = 0;
                }
                else
                {
     
                    y--;
                    x = m[i][j];
                    m[i][j] = 0;
                    m[i][y] = x;
                }
            }
        }
    }
    for(int i = 0; i < 4; i++)
    {
     
        for(int j = 0; j < 3; j++)
            printf("%d ",m[i][j]);
        printf("%d\n",m[i][3]);
    }
    cout << endl;
}
void UP(int m[4][4])
{
     
    int x,y;//合并的值,位置
    for(int j = 0; j < 4; j++)
    {
     
        x = 0, y = 0;
        for(int i = 0; i < 4; i++)
        {
     
            if(m[i][j] != 0 && x == 0)
            {
     
                x = m[i][j];
                m[i][j] = 0;
                m[y][j] = x;
            }
            else if(m[i][j] != 0 && x != 0)
            {
     
                if(m[i][j] == x)
                {
     
                    m[i][j] = 0;
                    m[y][j] = 2*x;
                    y++;
                    x = 0;
                }
                else
                {
     
                    y++;
                    x = m[i][j];
                    m[i][j] = 0;
                    m[y][j] = x;
                }
            }
        }
    }
    for(int i = 0; i < 4; i++)
    {
     
        for(int j = 0; j < 3; j++)
            printf("%d ",m[i][j]);
        printf("%d\n",m[i][3]);
    }
    cout << endl;
}
void DOWN(int m[4][4])
{
     
    int x,y;//合并的值,位置
    for(int j = 0; j < 4; j++)
    {
     
        x = 0, y = 3;
        for(int i = 3; i >= 0; i--)
        {
     
            if(m[i][j] != 0 && x == 0)
            {
     
                x = m[i][j];
                m[i][j] = 0;
                m[y][j] = x;
            }
            else if(m[i][j] != 0 && x != 0)
            {
     
                if(m[i][j] == x)
                {
     
                    m[i][j] = 0;
                    m[y][j] = 2*x;
                    y--;
                    x = 0;
                }
                else
                {
     
                    y--;
                    x = m[i][j];
                    m[i][j] = 0;
                    m[y][j] = x;
                }
            }
        }
    }
    for(int i = 0; i < 4; i++)
    {
     
        for(int j = 0; j < 3; j++)
            printf("%d ",m[i][j]);
        printf("%d\n",m[i][3]);
    }
    cout << endl;
}

1264 字符不重复子串

Description

字符不重复子串

题目描述

给一个只含英文小写的字符串，求其最长的字符不重复的子串。比如字符串"abcabc"，最长字符不重复子串长度为3，最长字符不重复子串为"abc",“bca”,“cab”；字符串"aaaaa"，最长字符不重复子串长度为1，字符串为"a"。

输入

存在多个样例，每行输入一个字符串，串长不超过10000。

输出

每个样例先输出最长的字符不重复子串的长度，然后按字典序输出这些不重复子串，每个子串输出一行。

样例输入

abcabc
aaaaa

样例输出

3
abc
bca
cab
1
a

#include
using namespace std;
int main()
{
     
    string s;
    int c[256];//记录是否出现
    int w[256];//记录出现位置
    int maxl;//最大长度
    int l[10000];//l[i]为s[i]结尾的长度
    while(getline(cin,s))
    {
     
        maxl = 1;
        l[0] = 1;
        //memset(c,0,sizeof(c));
        for(int i = 0; i < 256; i++)
        {
     
            c[i] = 0;
            w[i] = 0;
        }
        for(int i = 1; i < 10000; i++)
        {
     
            l[i] = 0;
        }
        for(int i = 0; i < s.size(); i++)
        {
     
            if(c[s[i]] == 0 || w[s[i]] < i-l[i-1])//未出现,之前出现位置在左端前相当于没出现
            {
     
                w[s[i]] = i;//更新出现坐标
                c[s[i]] = 1;//更新出现状态
                if(i != 0)
                {
     
                    l[i] = l[i-1]+1;//目前串长度+1
                    maxl = max(l[i],maxl);
                }
            }
            else//出现在串中
            {
     
                l[i] = i-w[s[i]];
                w[s[i]] = i;//更新出现坐标
            }
        }
        set<string> sets;//去重
        string str;
        for(int i = 0; i < s.size(); i++)
        {
     
            if(l[i] == maxl)
            {
     
                for(int j = i-maxl+1; j < i+1; j++)
                    str+=s[j];
                sets.insert(str);
                str = "";
            }
        }
        printf("%d\n",maxl);
        set<string>::iterator i;
        for(i = sets.begin(); i != sets.end(); i++)
        {
     
            cout<<*i<<endl;
        }
    }
    return 0;
}

1273 Set

Description

集合

题目描述

对于包含整数多值集合A={a 1 ,a 2 ,⋯,a n } ，执行以下两步操作
1.将某些元素加上整数x
2.将某些元素减掉整数y

请问能否使得A 的元素全部相等？

输入

第一行是一个整数K(1≤K≤100) ，表示样例的个数。
每个样例的第一行是一个整数n(1≤n≤100,000) 。
第二行是{a i |i=1,2,⋯n},0≤a i ≤1,000,000,000 。

输出

每行输出一个样例的结果，如果可以使得元素全部相等输出"Yes",否则输出"No"

样例输入

2
5
2 1 2 1 3
5
1 2 3 4 5

样例输出

Yes
No

#include
using namespace std;
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        int n;
        int m = 0,sum = 1,j = 0;
        int c[10] = {
     0};
        cin >> n;
        scanf("%d",&m);
        c[0] = m;
        for(int i = 1; i < n; i++)
        {
     
            scanf("%d",&m);
            if(sum <= 4)
            {
     
                for(j = 0; j < sum; j++)
                {
     
                    if(m == c[j])
                        break;
                }
                if(j >= sum)
                {
     
                    c[sum] = m;
                    sum++;
                }
            }
        }
        if(sum <= 3)
            printf("Yes\n");
        else if(sum == 4)
        {
     
            if((c[0]+c[1] == c[2]+c[3]) || (c[0]+c[2] == c[1]+c[3]) || (c[0]+c[3]==c[1]+c[2]))
                printf("Yes\n");
            else
                printf("No\n");
        }
        else
            printf("No\n");
    }
    return 0;
}

1274 Matrix

Description

矩阵

题目描述

我们把1∼N 2 按下面矩阵的规律进行排列：

请求第一列的累加和。

输入

每行一个整数N(1≤N≤10 9 ) ，如果N=0 表示输入结束，这个样例不需要处理。

输出

每行输出一个样例的结果，因为这个值可能很大，请将其对1,000,000,007 取模。

样例输入

1
2
3
1000000000
0

样例输出

1
5
10
499999881

#include
using namespace std;
int main()
{
     
    unsigned __int64 n;
    while(scanf("%I64d",&n) && n != 0)
    {
     
        int k = 0;
        unsigned __int64 sum = 0,t = 0;
        int p = 1000000007;
        k = n%2;
        t = n/2;
        unsigned __int64 m;
        if(k == 0)
        {
     
            t = t-1;
            if(2*t%3 == 0 || (t+1)%3 == 0)
                m =((((2*t)*(t+1))/3%p*(2*t+1)))%p;
            else
                m =((((2*t+1)*(t+1))/3%p*(2*t)))%p;
            sum = ((m*2)+t+1+(n*n)%p)%p;
        }
        else
        {
     
            if(2*t%3 == 0 || (t+1)%3 == 0)
                m =((((2*t)*(t+1))/3%p*(2*t+1)))%p;
            else
                m =((((2*t+1)*(t+1))/3%p*(2*t)))%p;
            sum = ((m*2)%p+t+1)%p;
        }
        cout << sum << endl;
    }
    return 0;
}

1275 Exam Schedule

Description

考试安排

题目描述

Eric每次考试最头痛的就是安排考试时间，需要找合适的空闲时间安排考试真的是件很费神的事情。
Eric希望你能帮他算一下能哪些时间可以考试，当然Eric并不想周末进行考试，所以你只需要计算周1到周5的时间就可以了。 我们假设每天有11节课的时间，上午1到4节，下午5-8节，晚上9-11节。Eric已经拿到了参加考试的班级的课表，以及考试需要的时长。注意：考试只能安排在上午、下午、晚上时段，不能跨区间。

输入

第一行是一个整数K(1≤K≤100) ，表示样例的个数
每个样例的第一行是两个整数N(1≤N≤100),T(2≤T≤4) ，分别表示这些班级课表的条目数和考试所需的课程节数。为了简化问题，Eric只留下了课表条目的上课时间。
以后的N行，每行一个课程的时间，为三个值，D(D∈{Mon,Tue,Wen,Thur,Fri,Sat,Sun}),S,E(1≤S≤E≤11) ，分别表示上课时间为星期D 的第S 节到第E 节。

输出

每个样例先输出一行，为每个样例合适考试的不同时间段的个数。 然后按时间先后顺序，每行输出一个时间段，分别为S,D,E ，中间用一个空格隔开。

样例输入

1
10 3
Mon 1 2
Tue 1 2
Wen 1 2
Thur 1 2
Fri 1 2
Mon 5 6
Tue 5 6
Wen 5 6
Thur 5 6
Fri 5 6

样例输出

5
Mon 9 11
Tue 9 11
Wen 9 11
Thur 9 11
Fri 9 11

#include
using namespace std;
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        int N,K;
        char s[5];
        int num[5][12] = {
     0};
        int ans[5][11] = {
     0};
        int x,y;
        char D[5][5] = {
     "Mon","Tue","Wen","Thur","Fri"};
        int a = 0;
        scanf("%d %d",&N,&K);
        for(int i = 0; i < N; i++)//记录周一到周五课表
        {
     
            scanf("%s %d %d",s,&x,&y);
            if(strcmp(s,"Mon") == 0)
            {
     
                for(int j = x; j <= y; j++)
                    num[0][j] = 1;
            }
            else if(strcmp(s,"Tue") == 0)
            {
     
                for(int j = x; j <= y; j++)
                    num[1][j] = 1;
            }
            else if(strcmp(s,"Wen") == 0)
            {
     
                for(int j = x; j <= y; j++)
                    num[2][j] = 1;
            }
            else if(strcmp(s,"Thur") == 0)
            {
     
                for(int j = x; j <= y; j++)
                    num[3][j] = 1;
            }
            else if(strcmp(s,"Fri") == 0)
            {
     
                for(int j = x; j <= y; j++)
                    num[4][j] = 1;
            }
        }
        for(int i = 0; i < 5; i++)
        {
     
            int sum = 0,m = 0;
            for(int j = 1; j < 5; j++)//上午1-4节课
            {
     
                if(num[i][j] == 0)//如果没课
                {
     
                    sum++;//空时间+1
                    if(sum >= K)
                    {
     
                        ans[i][m] = j-sum+1;//记录空时间开始时间
                        m++;//这一天适合考试的时间数+1
                        sum--;
                        a++;//总适合考试时间数+1
                    }
                }
                else
                {
     
                    sum = 0;
                }
            }
            sum = 0;
            for(int j = 5; j < 9; j++)
            {
     
                if(num[i][j] == 0)
                {
     
                    sum++;
                    if(sum >= K)
                    {
     
                        ans[i][m] = j-sum+1;
                        m++;
                        sum--;
                        a++;
                    }
                }
                else
                {
     
                    sum = 0;
                }
            }
            sum = 0;
            for(int j = 9; j <12; j++)
            {
     
                if(num[i][j] == 0)
                {
     
                    sum++;
                    if(sum >= K)
                    {
     
                        ans[i][m] = j-sum+1;
                        m++;
                        sum--;
                        a++;
                    }
                }
                else
                {
     
                    sum = 0;
                }
            }
        }
        printf("%d\n",a);
        for(int i = 0; i < 5; i++)
        {
     
            for(int j = 0; j < 11; j++)
            {
     
                if(ans[i][j] != 0)
                    printf("%s %d %d\n",D[i],ans[i][j],ans[i][j]+K-1);
            }
        }
    }
    return 0;
}

1170 ICPC

Description

题目描述

ACM/ICPC比赛涉及的知识点非常多，一个队伍三个人需要能够互补。一个队伍某个知识点的高度是三个人中水平最高的那个人决定。现在给你三个人的每个知识点的水平情况，请计算一下这个队伍的水平。

输入

存在多个样例。每个样例的第一行是一个整数N(3≤N≤100)，表示所有知识点的个数。 以后三行为每个人每个知识点的水平情况。水平用A到E表示，一共5级，A最强，E最弱，依次递减。

输出

每个样例输出两行，第一行为一个字符串，一个队伍的各个知识点的水平情况。第二行是5个整数，表示5个级别知识点的个数,每个整数之间有一个空格。

样例输入

3
ABC
BBB
AAE
4
DDBD
DEDC
CDDE
0

样例输出

AAB
2 1 0 0 0
CDBC
0 1 2 1 0

#include
using namespace std;
void Ju(int* m,char* s,int n)
{
     
    for(int i = 0; i < n; i++)
    {
     
        if(s[i] == 'A')
            m[0]++;
        else if(s[i] == 'B')
            m[1]++;
        else if(s[i] == 'C')
            m[2]++;
        else if(s[i] == 'D')
            m[3]++;
        else if(s[i] == 'E')
            m[4]++;
    }
}
int main()
{
     
    int n;
    while(scanf("%d",&n) != EOF)
    {
     
        if(n == 0)
            break;
        char s1[101],s2[101],s3[101],s[101];
        int m[5] = {
     0};
        scanf("%s",s1);
        scanf("%s",s2);
        scanf("%s",s3);
        for(int i = 0; i < n; i++)
        {
     
            if(s1[i] <= s2[i] && s1[i] <= s3[i])
                s[i] = s1[i];
            else if(s2[i] <= s1[i] && s2[i] <= s3[i])
                s[i] = s2[i];
            else if(s3[i] <= s2[i] && s3[i] <= s2[i])
                s[i] = s3[i];
        }
        Ju(m,s,n);
        for(int i = 0; i < n; i++)
            printf("%c",s[i]);
        printf("\n");
        for(int i = 0; i < 4; i++)
            printf("%d ",m[i]);
        printf("%d\n",m[4]);
    }
    return 0;
}

1249 Alice’s Prime

Description

Alice’s Prime

题目描述

Alice非常喜欢素数，她发现有些素数非常有意思。比如239，它是个素数；把239的最后一位去掉是23，也是个素数；把23的最后一位去掉是2，也是个素数。但是Alice不太善于计算，她请你帮她计算出所有满足这样条件的素数。

输入

无

输出

按素数大小依次输出，每行先输出序号，然后输出符合条件的素数,中间用空格隔开。

样例输入

样例输出

1 2
2 3
3 5
4 7
5 23
...

线索

这样的素数只有83个，且不会超过32位int的表示范围。

#include
using namespace std;
int m[100] = {
     2,3,5,7};
int n = 4;
int prime(unsigned int x)
{
     
    unsigned int k,i;
    k = (int)sqrt((double)x);
    for(i = 2; i <= k; i++)
    {
     
        if(x%i==0)
            break;
    }
    if(i > k)
        return 1;
    else
        return 0;
}
void dfs(string str)
{
     
    string str1 = "13579";
    string str2;
    for(int i = 0; i < str1.size(); i++)
    {
     
        str2=str+str1[i];
        unsigned int x = atoi(str2.c_str());
        int flag = prime(x);
        if(flag && x < INT_MAX)
        {
     
            m[n] = x;
            n++;
            dfs(str2);
        }
    }
}
int main()
{
     
    dfs("2");
    dfs("3");
    dfs("5");
    dfs("7");
    sort(m,m+n);
    for(int i = 0; i < n; i++)
        printf("%d %d\n",i+1,m[i]);
     return 0;
}

1266 RGB

RGB

题目描述

你有r 颗红球，g 颗绿球，b 颗蓝球，它们排成一个直线。你想它们按红绿蓝顺序分成三个颜色区域，你每次可以任意交换两个球的位置，请问至少需要交换多少次？

输入

每行输入一个字符串表示开始时球的序列，使用RGB分别表示红绿蓝三色球，字符串长度不超过10000。

输出

每行输出一个样例的结果。

样例输入

RRGGBB
RGBRGB

样例输出

0
2

#include
using namespace std;
int main()
{
     
    char s[10001];
    while(scanf("%s",s) != EOF)
    {
     
        int r = 0, g = 0, b = 0;
        int rgb[3][2] = {
     0};//rgb[0][0]表示前r个g的数量，rgb[0][1]表示b的数量
        int sum = 0;
        for(int i = 0; i < strlen(s); i++)
        {
     
            if(s[i] == 'R')
                r++;
            else if(s[i] == 'G')
                g++;
            else if(s[i] == 'B')
                b++;
        }
        for(int i = 0; i < r; i++)
        {
     
            if(s[i] == 'G')
                rgb[0][0]++;
            else if(s[i] == 'B')
                rgb[0][1]++;
        }
        for(int i = r; i < r+g; i++)
        {
     
            if(s[i] == 'R')
                rgb[1][0]++;
            else if(s[i] == 'B')
                rgb[1][1]++;
        }
        for(int i = r+g; i < r+g+b; i++)
        {
     
            if(s[i] == 'R')
                rgb[2][0]++;
            else if(s[i] == 'G')
                rgb[2][1]++;
        }
        sum = min(rgb[0][0],rgb[1][0]) + min(rgb[0][1],rgb[2][0]) + min(rgb[1][1],rgb[2][1]);
        sum += abs(rgb[0][0]-rgb[1][0]) + abs(rgb[0][1]-rgb[2][0]);
        cout << sum << endl;
    }
    return 0;
}

1267 Matrix

Description

Matrix

题目描述

一个矩阵A n×m ,矩阵按行依次为1∼nm 。若干种指令，指令集如下： (以3×3 的初始矩阵为例，结果矩阵列中为初始矩阵执行这条指令后的矩阵结果)

现在给你一个合法的指令序列（条数不超过1000，矩阵行列最大不超过10），请执行对应指令。

输入

每行输入一条指令。

输出

对于每个PR命令，输出矩阵。矩阵元素之间有一个空格，行末无空格，最后输出一个空行。

样例输入

IN 3 3
SR 1 2
PR
SC 1 2
TR
PR
FR 
FC 
PR

样例输出

4 5 6
1 2 3
7 8 9

5 2 8
4 1 7
6 3 9

9 3 6
7 1 4
8 2 5

#include
using namespace std;
int nm[101][101] = {
     0};
int n,m;
void IN();
void SR();
void SC();
void TR();
void FR();
void FC();
void PR();
int main()
{
     
    char s[3];
    char c[7][3] = {
     "IN","SR","SC","TR","FR","FC","PR"};
    while(scanf("%s",s) != EOF)
    {
     
        if(strcmp(s,c[0]) == 0)
            IN();
        else if(strcmp(s,c[1]) == 0)
            SR();
        else if(strcmp(s,c[2]) == 0)
            SC();
        else if(strcmp(s,c[3]) == 0)
            TR();
        else if(strcmp(s,c[4]) == 0)
            FR();
        else if(strcmp(s,c[5]) == 0)
            FC();
        else if(strcmp(s,c[6]) == 0)
            PR();
    }
    return 0;
}
void IN()
{
     
    scanf("%d %d",&n,&m);
    for(int i = 0; i < n; i++)
        for(int j = 0; j < m; j++)
            nm[i][j] = i*m+j+1;
}
void SR()
{
     
    int x,y;
    scanf("%d %d",&x,&y);
    for(int i = 0; i < m; i++)
        swap(nm[x-1][i],nm[y-1][i]);
}
void SC()
{
     
    int x,y;
    scanf("%d %d",&x,&y);
    for(int i = 0; i < n; i++)
        swap(nm[i][x-1],nm[i][y-1]);
}
void TR()
{
     
    if(n >= m)
    {
     
        swap(n,m);
        for(int i = 0; i < n; i++)
            for(int j = i; j < m; j++)
                swap(nm[i][j],nm[j][i]);
    }
    else
    {
     
        swap(n,m);
        for(int i = 0; i < m; i++)
            for(int j = i; j < n; j++)
                swap(nm[j][i],nm[i][j]);
    }
}
void FR()
{
     
    for(int i = 0; i < n/2; i++)
        for(int j = 0; j < m; j++)
            swap(nm[i][j],nm[n-i-1][j]);
}
void FC()
{
     
    for(int i = 0; i < m/2; i++)
        for(int j = 0; j < n; j++)
            swap(nm[j][i],nm[j][m-i-1]);
}
void PR()
{
     
    for(int i = 0; i < n; i++)
    {
     
        for(int j = 0; j < m-1; j++)
            printf("%d ",nm[i][j]);
        printf("%d\n",nm[i][m-1]);
    }
    printf("\n");
}

1279 Dual Prime

Description

Dual Prime

题目描述

如果一个合数x=p⋅q,p,q是素数且p≠q ，我们称x 是双素数。 现给你一个区间[a,b] ，求区间内的的双素数个数。

输入

第一行是一个整数T(1≤T≤30000) ，为样例的数目。 以后每行一个样例，为两个整数a,b(1≤a≤b≤10 6 )

输出

依次每行输出一个样例的结果。

样例输入

3
1 10
1 100
1 1000000

样例输出

2
30
209867

#include
using namespace std;

#define N 1000000
int h=0;
bool p[N];
int prime[N];
int Dual[N+1];
int Dua[N+1];
void db()
{
     
	memset(p,true,sizeof(p));
	for(int i=2;i<N;i++)
	{
     
		if(p[i]==true)
		{
     
			prime[h++]=i;
		}
		for(int j=0;j<h&&i*prime[j]<N;j++)
		{
     
			p[i*prime[j]]=false;
			if(i%prime[j]==0)  break;
		}
	}
}
int main()
{
     
    db();
    Dua[0] = 0;
    int i,j;
    for(i = 0; i < h-1;i++)
    {
     
        if(prime[i]*prime[i] > 1000000)
            break;
        for(j = i+1; j < h; j++)
        {
     
            if( prime[i] * prime[j] > 1000000)
                break;
            else
            {
     
                Dual[prime[i] * prime[j]] = 1;
            }
        }
    }
    for(int i = 1; i < N+1;i++)
        Dua[i] = Dua[i-1]+Dual[i];
    int T;
    int a,b;
    cin >> T;
    while(T--)
    {
     
        scanf("%d %d",&a,&b);
        printf("%d\n",Dua[b]-Dua[a-1]);
    }
    return 0;
}

1283 Good Number

Description

Good Number

题目描述

如果一个数的（无前导0）二进制表示中数码1的个数比数码0的个数多，我们称其为"好数"。 求n 位无前导0的二进制数中好数的个数。

输入

每行输入一个整数n(1≤n≤64)

输出

每行输出一个样例的结果。

样例输入

1
64

样例输出

1
4611686018427387904

#include
using namespace std;

const int MAXN = 63;
__int64 C[MAXN+1][MAXN+1];
void Initial()
{
     
    int i,j;
    for(i=0; i<=MAXN; ++i)
    {
     
        C[0][i] = 0;
        C[i][0] = 1;
    }
    for(i=1; i<=MAXN; ++i)
    {
     
        for(j=1; j<=MAXN; ++j)
        C[i][j] = C[i-1][j] + C[i-1][j-1];
    }
}

 int main()
 {
     
    Initial();
    int n;
    __int64 ans;
    while(scanf("%d",&n) != EOF)
    {
     
        ans = 0;
        if((n-1)%2 == 0)
        {
     
            for(int i = (n-1)/2; i <= n-1;i++)
                ans+=C[n-1][i];
        }
        else
        {
     
            for(int i = n/2;i <= n-1;i++)
                ans+=C[n-1][i];
        }
        printf("%I64d\n",ans);
    }
    return 0;
 }

1295 Flawless Prime

Description

Flawless Prime

题目描述

如果一个素数，依次去掉最高位得到一个数，这个数无前导0，并仍是素数的话，我们称其为“无瑕素数”。
比如317是素数，去掉最高位3得到17仍然是素数，再去掉最高位1得到7，仍然是素数，所以317是“无瑕素数”。
比如虽然107是素数，去掉最高位1得到7也是素数，但是因为存在前导0，所以这不是无瑕素数。
请写一个程序，判断某个素数是不是无瑕的。

输入

第一行是一个整数K ，表示样例的个数。 以后每行一个整数n(2≤n≤1,000,000,000) 。

输出

如果是无瑕素数，输出“Yes”，否则输出“No”。

样例输入

3
3
107
317

样例输出

Yes
No
Yes

#include
using namespace std;
int prime(int x);
int jun(int n);
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        int n;
        scanf("%d",&n);
        int x = jun(n);
        if(x == 1)
            cout << "Yes" <<endl;
        else
            cout << "No" <<endl;
    }
    return 0;
}
int prime(int x)
{
     
    unsigned int k,i;
    k = (int)sqrt((double)x);
    for(i = 2; i <= k; i++)
    {
     
        if(x%i==0)
            break;
    }
    if(i > k)
        return 1;
    else
        return 0;
}
int jun(int n)
{
     
    int k = 0,t = 0;
    int s = 0;
    while(n != 0)
    {
     
        k = n%10;
        n /= 10;
        if(t == 0)
            t = 1;
        else
            t = t*10;
        if(k == 0)
            return 0;
        else
        {
     
            s = s + t*k;
            if((s != 2 && prime(s) == 0 && s != 1) || s == 1 )
                return 0;
        }
    }
    return 1;
}

1304 ZUMA!

Description

ZUMA!

题目描述

Zuma是一个非常流行的小游戏，你有n 颗不同颜色的珠子从左到右排成一行。如果你把一颗新的珠子加入到行中的某个位置，使得出现连续3颗或以上的同颜色珠子，那么这些连续的同颜色珠子就会消失；这个规则可以重复多次，直到没有连续的3颗或者以上的同颜色珠子为止。现在给你初始一行珠子和一颗新的珠子，问你最多可以使得多少颗珠子消失。

输入

第一行是一个整数T(1≤T≤1000) ，表示样例的个数。
每个样例占两行，第一行是两个整数n(1≤n≤100),c(1≤c≤10) ，表示有n 颗珠子，新珠子的颜色为c 。
第二行是n 个整数c i ,i=1,2,⋯,n,1≤c i ≤10 ，表示从左到右珠子的颜色。
输入数据保证初始状态不会出现3颗或以上的连续同颜色珠子。

输出

每行输出一个样例的结果。

样例输入

2
6 2
1 1 2 2 1 1
5 1
1 2 3 4 5

样例输出

6
0

#include
#include
using namespace std;
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        int n,c;
        int m[101];
        scanf("%d %d",&n,&c);
        int w[50] = {
     0};//记录两个c出现的开始位置
        int flag = 0;//判断是否第二次出现
        int a = 0,sum = 0;
        int l = 0,r = 0;//消除后的左右位置
        int x,y;
        int maxsum = 0;
        for(int i = 0; i < n; i++)
        {
     
            scanf("%d",&m[i]);
            if(m[i] == c)//记录两个c出现位置
            {
     
                if(flag == 1)//当出现一次后再次出现
                {
     
                    w[a] = i-1;//记录第一个出现位置
                    a++;
                }
                else
                    flag = 1;//出现一次
            }
            else
                flag = 0;//重置出现次数
        }
        for(int i = 0; i < a; i++)
        {
     
            sum = 2;
            if(w[i]-1 >= 0 && w[i]+2 < n)
            {
     
                l = w[i] - 1;
                r = w[i] + 2;
            }
            else
            {
     
                maxsum = max(maxsum,sum);
                continue;
            }
            while(m[l] == m[r])
            {
     
                x = 1,y = 1;
                if(l-x >= 0)
                {
     
                    if(m[l-x] != m[l])
                        x = 0;
                }
                else
                    x = 0;
                if(r+y < n)
                {
     
                    if(m[r+y] != m[r])
                        y = 0;
                }
                else
                    y = 0;
                if(x+y > 0)
                {
     
                    sum = sum+2+x+y;
                }
                else
                    break;
                if(l-x-1 >= 0 && r+y+1 < n)
                {
     
                    l = l-x-1;
                    r = r+y+1;
                }
                else
                    break;
            }
            maxsum = max(maxsum,sum);
        }
        cout << maxsum << endl;
    }
}

1309 唯一的子串

Description

唯一的子串

题目描述

给一个字符串，求长度为m的所有不重复的子串。 比如字符串"aaab",我们求长度为2的子串，那么依次为"aa",“aa”,“ab”，那么不重复的子串为"aa",“bb”

输入

第一行是一个整数K，表示样例的个数。 每个样例的第一行是一个整数m，表示所求子串的长度。 第二行是一个字符串，字符串全部由小写英文字母组成，长度不超过100。

输出

按字典序输出所有不重复子串，每个样例最后输出一个空行。

样例输入

2
2
aaab
3
aaab

样例输出

aa
ab

aaa
aab

#include
using namespace std;
int main()
{
     
    int T;
    cin >> T;
    while(T--)
    {
     
        int l;
        string str,str1;
        set<string> sets;
        scanf("%d",&l);
        getchar();
        getline(cin,str);
        for(int i = 0; i < str.size()-l+1; i++)
        {
     
            str1 = str.substr(i,l);
            sets.insert(str1);
        }
        set<string>::iterator i;
        for(i = sets.begin(); i != sets.end(); i++)
        {
     
            cout<<*i<<endl;
        }
        cout << endl;
    }
    return 0;
}