2019NYIST计科第四次周赛

YZJ的牛肉干

Description

今年的ACM暑期集训队一共有18人，分为6支队伍。其中有一个叫做

YZJ的大佬，在共同的集训生活中，大家建立了深厚的友谊，

YZJ准备做点什么来纪念这段激情燃烧的岁月，想了一想，

YZJ从家里拿来了一块上等的牛肉干，准备在上面刻下一个长度为

n的只由"Y,Z,J"三种字符组成的字符串（可以只有其中一种或两种字符，但绝对不能有其他字符）,

YZJ学长同时禁止在串中出现ZZ相邻的情况，他认为，"

ZZ"看起来就像骂人的话语，影响不好。

YZJ的崇拜者，能帮学长算一下一共有多少种满足要求的不同的字符串吗？

Input

输入数据包含多个测试实例,每个测试实例占一行,由一个整数n组成，(0<n<400<n<40)。

Output

对于每个测试实例，请输出全部的满足要求的涂法，每个实例的输出占一行。

Sample Input 1

1
2

Sample Output 1

3

8

• 思路如下

这题考的 是 递推（只能为递推，如果不是递推 情况太多太复杂了 ），重要的是我们要找到其中各项之间的规律。

我们先观察 第一项为3，第二项为8，第三项的方案数位22，

此时第三项的值为前两项的值的和乘以2。

此时我们猜测规律是 除前两项之外，某项之和等于前两项之和的二倍

• 题解如下

#include<stdio.h>

int main()
{
    long long int ar[45];
    ar[1] = 3;
    ar[2] = 8;
    for(int i = 3;i <40;i++)
    {
        ar[i] = 2*(ar[i-1] + ar[i-2]);
    }

    int n;
    while (~scanf("%d",&n))
    {
        printf("%lld\n",ar[n]);
    }

    return 0;
}

---

签到题它又来了

Description

现在要求按照以下方式排序（默认排序都是从小到大）

现在有很多长方形，每一个长方形都有一个编号，这个编号可以重复；还知道这个长方形的宽和长，编号、长、宽都是整数；现在要求按照一下方式排序（默认排序规则都是从小到大）；

1.按照编号从小到大排序

2.对于编号相等的长方形，按照长方形的长排序；

3.如果编号和长都相同，按照长方形的宽排序；

4.如果编号、长、宽都相同，就只保留一个长方形用于排序,删除多余的长方形；最后排好序按照指定格式显示所有的长方形；

Input

第一行有一个整数

0

<

n

<

10000

0<n<10000,表示接下来有

n

n组测试数据；

每一组第一行有一个整数

0

<

m

<

1000

0<m<1000，表示有

m

m个长方形；

接下来的

m

m行，每一行有三个数 ，第一个数表示长方形的编号，

第二个和第三个数值大的表示长，数值小的表示宽，相等

说明这是一个正方形（数据约定长宽与编号都小于10000）；

Output

顺序输出每组数据的所有符合条件的长方形的 编号 长 宽

Sample Input 1
1
8
1 1 1
1 1 1
1 1 2
1 2 1
1 2 2
2 1 1
2 1 2
2 2 1

Sample Output 1

1 1 1

1 2 1

1 2 2

2 1 1

2 2 1

解题思路

这题 主要是要用结构体去存储各种数据类型，然后用sort函数对结构体进行排序，这题的难点 一是在与编写sort函数所需的比较函数（编写的时候 应该明白 当比较函数 返回值 为 false 是才进行交换），其次是 要对完全相同的数据进行去重操作（只输出一次），要想去重，只需在用for循环输出的时候，室某个元素 与前一个元素进行 比较如果完全相同，就不输出，否则输出。。

题解如下

#include<stdio.h>
#include <algorithm>
using namespace std;

struct Rec
{
    int hao,len,wei;
};
bool cmp_sort(Rec &a,Rec &b)
{

    if(a.hao<b.hao)
    {
        return true;
    }
    else if(a.hao==b.hao&&a.len<b.len)
    {
        return true;
    }
    else if(a.hao==b.hao&&a.len==b.len && a.wei<b.wei)
    {
        return true;
    }

    return false;

}

int main()
{

    int n;
    scanf("%d",&n);
    while (n--)
    {
        int m;
        scanf("%d",&m);
        Rec rec[m+100];
        for(int i=0;i<m;i++)
        {
            int l,w;
            scanf("%d%d%d",&rec[i].hao,&l,&w);
            if(l<w)
            {
                int temp=l;
                l=w;
                w=temp;
            }
            rec[i].len=l;
            rec[i].wei=w;
        }
        sort(rec,rec+m,cmp_sort);
        for(int i = 0; i < m;i++ )
        {
            if(i == 0)
                printf("%d %d %d\n",rec[i].hao,rec[i].len,rec[i].wei);
            else if(rec[i].hao== rec[i-1].hao && rec[i].len == rec[i-1].len && rec[i].wei == rec[i-1].wei)
            {
                //
            }
            else
                printf("%d %d %d\n",rec[i].hao,rec[i].len,rec[i].wei);

        }
    }
printf("\n");

    return 0;
}

---

扫雷

Description

hg学长上程序设计课的时候非常喜欢玩扫雷。

现在

hg学长有一个初始的雷矩阵，他希望聪明的你帮他生成一个扫雷矩阵。

扫雷矩阵的每一行每一列都是一个数字，每个数字的含义是与当前位置相邻的8个方向中，有多少个雷（在下图中，雷用表示）；

如果当前位置就是雷的话，仍输出一个。

比如初始的雷矩阵如下：

…

…**

..

..

对应的数字矩阵为：

0122

13**

44

23

Input

第一行两个整数n,m，代表矩阵有n行m列（1≤n,m≤10001≤n,m≤1000）接下来共n行，每行m个字符

Output

输出共

n

n行

m

m列，为扫雷矩阵。

Sample Input 1

4 4

…

…**

..

..

Sample Output 1

0122

13**

44

23

Sample Input 2

3 4

…

…

..

Sample Output 2

1111

23

23

• [ ]思路如下

这题的思路很明确，就是判断二维数组中某个元素的是否为 '.'符号，如果是就统计这个元素上下左右的 ‘’ 个数，并存到一个相同大小的二维 char数组中，否则就直接把 '’ 存入到二维char数组中。

• [ ]题解如下

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

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    char ar[n][m];
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            cin>>ar[i][j];
        }
    }
    char ans[n][m];
    //printf("\n\n");
    for(int i=0;i<n;i++)  //两层for循环去遍历数组的元素
    {
        for(int j=0;j<m;j++)
        {
            int count=0;
            if(ar[i][j] == '.')
            {
                if(i-1>=0&&ar[i-1][j] == '*')
                    count++;
                if(i+1<n&&ar[i+1][j] == '*')
                    count++;
                if(j-1>=0&&ar[i][j-1] == '*')
                    count++;
                if(j+1<m&&ar[i][j+1] == '*')
                    count++;
                if(i-1>=0&&j-1>=0 &&ar[i-1][j-1] == '*')
                    count++;
                if(i+1<n&&j+1<m&&ar[i+1][j+1] == '*')
                    count++;
                if(i-1>=0&&j+1<m&&ar[i-1][j+1] =='*')
                    count++;
                if(i+1<n&&j-1>=0&&ar[i+1][j-1]=='*')
                    count++;
                //  printf("%d\n",count);
                ans[i][j]=count+'0';
            }
            else
            {
                ans[i][j]='*';
            }

        }
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            printf("%c",ans[i][j]);
        }
        printf("\n");
    }

    return 0;
}

---

万德隆购物

Description

众所周知万德隆超市中有一自动扶梯，一次lly去购物时实验了一下他沿开动上行的自动扶梯走上楼时，数得走了n级，当他用同样的速度相对扶梯沿向下开动的自动扶梯走上楼时，数得走了m级，lly想让你们帮他编程求出当自动扶梯静止时自动扶梯露出的级数是多少。

Input

输入n,mn,m（1≤n≤m≤4001≤n≤m≤400）

Output

输出包含一个整数(答案向下取整:比如你计算结果为24.2要输出24)

Sample Input 1

16 48

Sample Output 1

24

Sample Input 2

16 400

Sample Output 2

30

这题是可以说是初中物理题，分析lly 再上楼与下楼的时候，lly相对楼梯的速度是相同的，而路程是相同，所以lly上楼的时间与下楼的时间只比为n 比 m ，由于人 上下楼梯的路程是相同的，所以建立方程求解：

• [ ]题解如下

#include<cstdio>
int main() {
   double n,m;
scanf("%lf%lf",&n,&m);
double ans=2*m*n/(m+n); printf("%d\n",int(ans));//强制转换自动向下取整 return 0;
}

---

卖火柴的lly
Description
继去年的
riba2534的拷问(1)riba2534的拷问(2)llylly也想和zj哥riba2534riba2534一样强，所以llylly仿照riba2534的拷问riba2534的拷问给你n根火柴棍，问你可以拼出多少个形如“A+B=C”的等式？等式中的A、B、C是用火柴棍拼出的整数（若该数非零，则最高位不能是0）。
用火柴棍拼数字0-9的拼法如图所示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jEwrGNch-1573733533486)(evernotecid://2C354EAE-828A-4D61-888B-9453DC360564/appyinxiangcom/25418762/ENResource/p321)]

注意：加号与等号各自需要两根火柴棍如果A≠B，则A+B=C与B+A=C视为不同的等式（A、B、C>=0）nn根火柴棍必须全部用上Input
共一行，有一个整数n（0≤n≤24）n（0≤n≤24）。
Output
共一行，表示能拼成的不同等式的数目。
Sample Input 1
14
>Sample Output 1
>2
>Sample Input 2
>18
>Sample Output 29
Hint
对于样例1:
2个等式为:
0+1=1和1+0=1。
对于样例2:
9个等式为：
0+4=4
0+11=11
1+10=11
2+2=4
2+7=9
4+0=4
7+2=9
10+1=11
11+0=11。

**思路如下**
>这题，既然是要找出形如A+B=C这样的等式，那最简单的办法就是分别枚举A，B，C。接下来的问题就是: A，B，C的枚举范围是什么呢?我们只需要在0~1111之间枚举就可以了。为什么呢?因为题目中最多 只有24根火柴棒即m<=24。除去“+”和“-”占用的4根火柴棍，那么最多剩下20根火柴棍。而0-9这十个数 字中，1需要用到的火柴棍最少，只需要2根火柴棍。而20根火柴棍最多能组成10个1。因此A+B=C这个 等式中A,B,C中任意一个数都不能超过1111。接下来就暴力求解就阔以了。
* [ ]**题解如下**
```c
#include<stdio.h>
/* 方法一：这是最暴力的方法
我们一开始先用一个数组去存储除 每个数字所用的火彩棒数，用了 9层for循环，每三层for循环 表示一个数，而每一个数的开头不能是0，我们先假设 开头一开始可以为零，例如我们通过 a,b,c 表示一个整数，若a为0，我们最后把a为零所占用的 火柴棒的数量去掉（另外两个数 也同理可以表示出来），最后通过两个等式同时成立 1.所用的火柴棒数==所给的火柴棒数，并且 前两个数字之和 ==第三个。*/

int main()
{
    int n;
    scanf("%d",&n);
    n=n-4;
    int ar[10];
    ar[0]=6;
    ar[1]=2;
    ar[2]=5;
    ar[3]=5;
    ar[4]=4;
    ar[5]=5;
    ar[6]=6;
    ar[7]=3;
    ar[8]=7;
    ar[9]=6;
    int sum_count=0;

    for(int i=0;i<=7;i++)
    {
        if(i!=3&&i!=5&&i!=6&&i!=8&&i!=9)
        for(int j=0;j<=9;j++)
        {
            for(int k=0;k<=9;k++)
            for(int a=0;a<=7;a++)
            {
                if(a!=3&&a!=5&&a!=6&&a!=8&&a!=9)
                for(int b=0;b<=9;b++)
                {
                    for(int c=0;c<=9;c++)
                    for(int x=0;x<=7;x++)
                    {
                        if(x!=3&&x!=5&&x!=6&&x!=8&&x!=9)
                        for(int y=0;y<=9;y++)
                        {
                            for(int z=0;z<=9;z++)
                            if(i*100+j*10+k+a*100+b*10+c==x*100+y*10+z)
                            {
                                int count_zero=0;
                                if(i==0)
                                {
                                    count_zero++;
                                    if(j==0)
                                    {
                                        count_zero++;
                                    }
                                }
                                if(a==0)
                                {
                                    count_zero++;
                                    if(b==0)
                                    {
                                        count_zero++;
                                    }
                                }
                                if(x==0)
                                {
                                    count_zero++;
                                    if(y==0)
                                    {
                                        count_zero++;
                                    }
                                }
                                if(ar[i]+ar[j]+ar[k]+ar[a]+ar[b]+ar[c]+ar[x]+ar[y]+ar[z]-6*count_zero==n)
                                {
                                    sum_count++;
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    printf("%d",sum_count);

    return 0;
}

/*方法二：看似不那么暴力*/
#include <cstdio>
int fun(int x) {
    int ans=0,f[10]= {6,2,5,5,4,5,6,3,7,6};  //存储给每个数字所用的火柴数
    while(x/10!=0) {       //把每一位进行分割
        ans+=f[x%10];      //并把分割出来的这一位数 作为f数组下标，
        x=x/10; }          //这里的 ans 是表示某个数 占用火柴棒的总数
    ans+=f[x];
    return ans; }
int main() {
    int a,b,c,m,ans=0;
    scanf("%d",&m);
    for (a = 0; a<= 1111; a++) {
        for(b=0; b<= 1111; b++) {   //两层for循环去遍历所 a b的取值
            c=a+b;
            if((fun(a)+fun(b)+fun(c))==m-4) {    //等式成立方案数加1
                ans++;
            } }
    }
    printf("%d\n",ans);
    return 0;
}

---

进位
Description
很多小学生在学习加法时，发现“进位”特别容易出错。你的任务是计算两个三位数在相加时需要多少次进位。你编制的程序应当可以连续处理多组数据，直到读到两个0（这是输入结束标记）。

Input
输入两个正整数
m,n.(m,n,都是三位数)

Output
输出
m,n,相加时需要进位多少次。

Sample Input 1
123 456
555 555
123 594
0 0
Sample Output 1
0
3
1
Hint

• [ ]思路如下

这题 已经明确是两个 三位数，是否进位我们要看，对应位相加是否大于9.

一种思路是我们 一字符串的方式输入到一个char 数组中，然后两个char数组对应转存到，两个int数组中，对应相加，看着一位是否大于9，如果大于 方案数加1，并把下一位的值加1.

• [ ]题解如下

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

int main()
{
    char ar[10],br[10];

    scanf("%s%s",ar,br);
    int LEN_ar=(int)strlen(ar);
    int LEN_br=(int)strlen(br);
    while (ar[0]!='0'&&br[0]!='0'&&LEN_ar!=1&&LEN_br!=1)
    {
    int temp[100];
    for(int i=1;i<=3;i++)
    {
        temp[i]=ar[3-i]-'0'+br[3-i]-'0';
    }
    int digit=3;
    int jin_wei=0;
    for(int i=1;i<digit;i++)
    {
        if(temp[i]>9)
        {
            jin_wei++;
            temp[i+1]+=temp[i]/10;
            temp[i]%=10;

        }
    }
    while (temp[digit]>9)
    {
        jin_wei++;
        temp[digit+1]=temp[digit]/10;
        temp[digit]%=10;
        digit++;
    }
    printf("%d\n",jin_wei);
        scanf("%s%s",ar,br);
    }

    return 0;
}

---

\最直接的题

Description

众所周知lly最喜欢出题面长而题意绕的题，这是lly出的最直接的一题lly给你n个数，让你求使这n个数完全相等的最小代价，现在你有两个可以选择的操作：选择一个数，让这个数减1或者加1，代价为1。

选择一个数，让这个数减2或者加2，代价为0。

Input

输入一个n，表示第二行有

n个数(1≤n1061≤n≤10 6 )。

第二行有

n

n个不大于10510 5 的正整数。

Output

输出包含一个整数作为答案。

Sample Input 1

3

1 2 3

Sample Output 1

1

Hint

样例解释：

全部变成3

1 + 2 = 3 代价为0

2 + 1 = 3 代价为1

全部变成1

2 - 1 = 1 代价为1

3 - 2 = 3 代价为0

这两种方案总代价都是最小的，最小总代价为1

另外：你可以选择暴力，但是一定会返回时间超限。

• 思路如下

这题很简单，只要明白，奇数与奇数、偶数与偶数之间的相互转化是不耗费代价的，奇数与偶数之间转化一定耗费代价（且，最少都耗费一个 代价）

那么我们就有两种选择 要么把所有的 奇数变为偶数，或 把所有的偶数转化为奇数。要想耗费最少

应该 转化的最少。实际上这题就变成了 统计 n个树中 奇数与偶数的个数分别是多少！！！

• 题解如下

#include<stdio.h>
#include<algorithm>
using namespace std;

int main()
{

    long long int n;
    scanf("%lld",&n);
    long long int ar[n];
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&ar[i]);
    }
    //sort(ar,ar+n);
    long long int count_ji=0;
    for(int i=0;i<n;i++)
    {
        if(ar[i]%2!=0)
        {
            count_ji++;
        }
    }
    if(count_ji>n-count_ji)
    {
        printf("%lld",n-count_ji);

    }
    else
        printf("%lld",count_ji);

    return 0;
}

---

淘宝盖楼

Description

又是疯狂的双十一前兆，

lly学长每天都会收到很多小姐姐的淘宝盖楼助力，YY小姐姐就是其中的一个，YY小姐姐每天会找很多人助力，但是YY小姐姐很在意别人的等级，如果某个人等级太低了的话YY小姐姐则不会浪费时间去找此人帮助，现在YY小姐姐依次询问n个人的等级，请问你能算出在这n个人中YY小姐姐能收获到多少级的助力吗，值得一提的是，YY小姐姐是不会选择等级低于自己所选择过的任何一个人的。另外，因为在这之前YY小姐姐没有得到任何人的助力，所以YY小姐姐一定会选择第一个人为自己助力。

要声明的是，现实生活中就算你等级再低也不会被嫌弃，因为1级也有可能在最后时刻翻盘QAQ。

Input

第一行给定一个n，表示询问n个人的等级（

1≤n≤1061≤n≤10 6 ）。

第二行依次给定n个数，分别表示所询问的第i个人的等级ai

​

(1≤ai≤1051≤a i​ ≤10 5)。

Output

输出包含一个整数作为答案。

Sample Input 1

5

3 3 2 4 6

Sample Output 1

16

Source

nuoyanli

• [ ]题解如下

#include<stdio.h>
                    //当前最大，就取这个值，并且更新最大值，否则按上一个最大，
int main()
{

    long long int n;
    scanf("%lld",&n);
    long long int ar[n];
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&ar[i]);
    }
    long long int count=ar[0];
    long long int last_count=ar[0];
    for(int i=1;i<n;i++)
    {
        if(ar[i]>=last_count)
        {
            count+=ar[i];
            last_count=ar[i];
        }
    }
    printf("%lld",count);

    return 0;
}

货车

Description

有一个大货车，负责把物品从

A

A仓库运往

B

B仓库，先把

A

A仓库的货物按从小到大顺序装上车。

然后运输途中有很多商店，在货车经过商店的时候，有两种操作：

把物品放到车厢里面。

把车厢里面物品拿出来一个。

货车的仓库是非常狭窄的，先放进去的货物只能等后放进去的货物移走之后才能搬出来。

当货车到达

B

B仓库的时候，把物品全部搬出。

Input

第一行输入n和m，n表示在A仓库的货物的数量(物品编号1~n

n)，m表示

A——

B途中商店的数量。（1≤n≤100,5≤m≤1001≤n≤100,5≤m≤100)接下来m行，一个数表示操作类别1或2（对应题目操作）。若操作类别为1，后面还会有一个被操作的物品编号k（1≤k≤1001≤k≤100)。

（可能会有编号相同的物品）。

Output

输出一行，表示物品在到达

B

B仓库的时候的搬出顺序（有多个物品用空格隔开）。

若到达

B

B仓库没有货，则输出“NO”（没有引号）。

Sample Input 1

10 7

1 13

2

1 2

1 4

2

2

1 5

Sample Output 1

5 10 9 8 7 6 5 4 3 2 1

Source

hg

//无脑 模拟题，这题 会用 stack 以及它的STL函数 enmpy（）、top（）、pop（）、push（）。就可以模拟这个过程
#include<stdio.h>
#include<iostream>
#include<stack>
using namespace std;

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    stack<int> sta;
    for(int i=1;i<=n;i++)
    {
        sta.push(i);
    }
    for(int i=0;i<m;i++)
    {
        int lei_xing;
        scanf("%d",&lei_xing);
        if(lei_xing == 1)
        {
            int hao;
            scanf("%d",&hao);
            sta.push(hao);

        }
        else
        {
            sta.pop();
        }
    }
        if(!sta.empty())
        {
            while (!sta.empty())
            {
                printf("%d",sta.top());
                sta.pop();
                printf(" ");
            }
        }
        else
        {
            printf("NO");

        }

    return 0;
}

---

Description

白河的河风轻轻地唱着歌唤醒了水上的涟漪，秋日的月光把河水映照了银白。

河边散步的

l

l

y

lly突然发现了一个石碑，上面刻着“LINANYOU”，下面还写着一个古老的年份。

l

l

y

lly不由得想起了自己的ID：nuoyanli

“这个ID也太像我了吧？难道我曾经来过这个世界，那个年份就是上一世的我降临或者离去的时间？”

l

l

y

lly不由得思考了起来。

“就算没有白浅夜华三生三世的爱情，有一个三生三世的灵魂也能羡煞众人啊！”单身十九年的lly想。

lly认为，如果某一个ID是他的ID的全排列的一种，且和他的ID不一样，

便认为这个ID是他的前世，现在告诉你这个ID和lly的ID，请你帮忙判断，这个ID是不是他的前世。

Input

输入的第一行包含一个整数n，代表字符串ID的长度。(1≤n≤2∗105)(1≤n≤2∗10 5 )接下来两行分别给出一个长度为n的字符串，可能包含所有大写字母及小写字母，先给lly的ID，下一行给出需要判断的ID。

Output

输出yes代表这个ID是lly的前世，no代表不是。

Sample Input 1

5

ACMnb

nbACM

Sample Output 1

yes

Sample Input 2

10

hgandllynb

hgandllynb

Sample Output 2

no

//这一题思路 很简单 首先判读   用 strcmpo（）函数判断
//字符串是否完全相等，如相等，就是 no ，否则在判断 用sort（）对两个字符数组进行排序，看 ，然后再看两个数组是否完全相同，如果完全相同 就是 yes
#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;

int main()
{
    int n;
    scanf("%d",&n);
    char ar[n],br[n];
    scanf("%s%s",ar,br);
    int same=0;
    if(strcmp(ar,br)==0)
    {
        same=1;
    }
    sort(ar,ar+n);
    sort(br,br+n);
    int flag=1;
    for(int i=0;i<n;i++)
    {
        if(ar[i]!=br[i])
        {
            flag=0;
        }
    }
    if(flag==1&&same==0)
    {
        printf("yes");
    }
    else
        printf("no");

    return 0;
}