2023面试高手

这个屌丝很懒，什么也没留下！

热门标签

杭电的oj_c++ 464在5*5的图像里,你可以选择点一下其中任意一格:第x行第y列。此时和这个格子

作者：2023面试高手 | 2024-03-28 09:30:18

踩

c++ 464在5*5的图像里,你可以选择点一下其中任意一格:第x行第y列。此时和这个格子

杭电oj的c++版本网站：

2000.ASCII码排序 333

#include<stdio.h>

void ASCIISort(){
	char c1,c2,c3,temp;
	while(scanf("%c%c%c",&c1,&c2,&c3)!=EOF){
		//缓冲Enter产生的字符
		getchar();
		if(c1>c2){
			temp=c1;
			c1=c2;
			c2=temp;
		}
		if(c1>c3){
			temp=c1;
			c1=c2;
			c2=temp;
		}
		if(c2>c3){
			temp=c2;
			c2=c3;
			c3=temp;
		}
		printf("%c %c %c\n",c1,c2,c3);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2001 计算两点间的距离 333

#include <stdio.h>
#include <math.h>//为了使用开根函数

int main(){
	double x1,y1,x2,y2;//首先要注意题目中说明了输入数据会是实数
	double distance = 0;
	while(scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2)!=EOF){
		distance = sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
		printf("%.2lf\n",distance);//注意保留两位小数的写法
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

2002 计算球体积 3333

三分之四pai r的立方
#include <stdio.h>
#define PI 3.1415927
int main(){
	double r;
	double tiji;//英文学的不好，体积是啥自己查
	while(scanf("%lf",&r)!=EOF){
		tiji = 4 * PI * r * r * r / 3.0;//这里为了以防万一我用的3.0来求精度
		printf("%.3lf\n",tiji);
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

2003 求绝对值 333

#include <stdio.h>

int main(){
	double x;
	while ((scanf("%lf", &x))!= EOF)
		printf("%.2f\n", (x > 0) ? x : -x);
	return 0;
}

1
2
3
4
5
6
7
8
9

2004 成绩转换

#include <stdio.h>

int main(){
	int score;
	while(scanf("%d",&score)!=EOF){
		if(score >= 90 && score <= 100){
			printf("A\n");
		}else if(score >= 80 && score <= 89){
			printf("B\n");
		}else if(score >= 70 && score <= 79){
			printf("C\n");
		}else if(score >= 60 && score <= 69){
			printf("D\n");
		}else if(score >= 0 && score <= 59){
			printf("E\n");
		}else {
			printf("Score is error!\n");
		}
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2005 第几天？ 333

#include <stdio.h>

int main(){
	int day[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
	int year,month,date;
	int num = 0;
	while(scanf("%d/%d/%d",&year,&month,&date)!=EOF){//输入要随机应变
		num = 0;
		if((year % 400 == 0) || ((year % 100 != 0) && (year % 4 == 0))){
			day[1] = 29;
		}else{
			day[1] = 28;
		}
		for(int i = 0;i < month - 1;i++){//要计算到前一个月
			num += day[i];
		}
		num += date;//加上本月的天数
		printf("%d\n",num);
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2006 求奇数的乘积 333

#include <stdio.h>

void OddMul(){
	int n,result,i,temp;
	while(scanf("%d",&n)!=EOF){
		result=1;
		for(i=0;i<n;i++){
			scanf("%d",&temp);
			if(temp%2!=0) result*=temp;
		}
		printf("%d\n",result);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

2007.平方和与立方和 333

#include <stdio.h>

void SumOFSquareAndCubic(){
	int n,m,sum1,sum2,i,temp;
	while(scanf("%d%d",&n,&m)!=EOF){
		if(n>m){
			temp=n;
			n=m;
			m=temp;
		}
		sum1=sum2=0;
		for(i=n;i<=m;i++){
			if(i%2==0){
				sum1+=i*i;
			}else{
				sum2+=i*i*i;
			}
		}
		printf("%d %d\n",sum1,sum2);
	}
} 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2008.数值统计 333

#include <stdio.h>

void NumStatistics(){
	double num;
	int n,count1,count2,count3;
	while(scanf("%d%d",&n)!=EOF && n){
		count1=count2=count3=0;
		//统计数值 
		while(n--){
			scanf("%lf",&num);
			if(num<0){
				count1++;
			}else if(num==0){
				count2++;
			}else{
				count3++;
			}
		}
		printf("%d %d %d\n",count1,count2,count3);
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2009.求数列的和 333

#include <stdio.h>
#include <math.h>

void SumOfSeries(){
	int n,m,i;
	double sum,num;
	while(scanf("%d%d",&n,&m)!=EOF){
		sum=0;
		//将n转化为double型，并且赋值给num 
		num=(double)n;
		//求该数列的前m项和
		for(i=0;i<m;i++){
			sum+=num;
			num=sqrt(num);
		}
		printf("%.2lf\n",sum);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2010 水仙花数 333

#include <stdio.h>

int main(){
	int m,n;
	while(scanf("%d%d",&m,&n)!=EOF){
		bool flag = false;//来判断是否是第一个数据，由此判断什么时候输出空格
		for(int i = m;i <= n;i++){
			int gewei = i%10;//个位上的数
			int shiwei = i/10%10;//十位上的数
			int baiwei = i/100%10;//百位上的数
			int temp = gewei*gewei*gewei+shiwei*shiwei*shiwei+baiwei*baiwei*baiwei;
			if(i == temp){
				if(flag == false){//是第一个数据则直接输出
					printf("%d",i);
				}else{//不是第一个数据要先输出一个空格再输出结果
					printf(" %d",i);
				}
				flag = true;
			}
		}
		if(flag == false){//没有修改过说明没有水仙花数
			printf("no\n");
		}else{
			printf("\n");
		}
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

2011.多项式求和 222

#include <stdio.h>

void Polynomial(){
	int n,m,i;
	double arr[1000],j;
	arr[1]=1;
	//arr[i]表示该多项式的前i项和 (1<=i<1000)
	for(i=2;i<1000;i++){
		j=1.0/i;
		if(i%2!=1){
			arr[i]=arr[i-1]-j;
		}else{
			arr[i]=arr[i-1]+j;
		}
	}
	scanf("%d",&m);
	while(m--){
		scanf("%d",&n);
		printf("%.2lf\n",arr[n]);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2012 素数判定 2

#include <iostream>

using namespace std;

int check_prime_num(int arg)
{
    if(arg<=0)return 0;
    else if(arg==1) return 0;
    else if(arg==2)return 1;
    else
    {
        for(int j=2; j<arg; j++)
        {
            if(arg%j==0) return 0;
        }
        return 1;
    }
}

int main(void)
{
    int x,y,temp,flag=0;
    while(cin>>x>>y)
    {
        if(x==0&&y==0)break;
        for(int i=x; i<=y; i++)
        {
            temp=i*i+i+41;
            if(check_prime_num(temp)==1)
                ++flag;
        }
        if(flag==(y-x+1))cout<<"OK"<<endl;
        else cout<<"Sorry"<<endl;
        flag=0;
    }
    return 0;
}


//
#include <stdio.h>
int main()
{
    int x,y,i,j;
    while (scanf("%d%d",&x,&y)!=EOF&&(x!=0||y!=0))
    {
        int g=0,flag=0; //每组数据进行初始化
        for (i=x;i<=y;i++)
           {    g=i*i+i+41; //n^2+n+41
                for (j=2;j<g;j++)  //判定范围内是否都为素数
                {
                        if(g%j==0)
                        {
                        flag=1;
                        break;
                        }
                }
           }
        if(flag==0)
        printf("OK\n");
       else printf("Sorry\n");
     }
     return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

2013 蟠桃记 3333

#include <stdio.h>

int main(){
	int n;
	while ((scanf("%d",&n))!=EOF){
		int sum = 1;
		for (int i = n-1; i != 0; --i){
			sum = (sum + 1) * 2;
		}
		printf("%d\n",sum);
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

2014 青年歌手大奖赛_评委会打分 333

#include <stdio.h>

int main(){
	double result;
	int n = 0;
	double score;
	double max = 0,min = 100;
	while(scanf("%d",&n)!=EOF){
		result = 0;
		max = 0;min = 100;
		for(int i = 0;i < n;i++){
			scanf("%lf",&score);
			result += score;
			if(score > max){
				max = score;
			}
			if(score < min){
				min = score;
			}
		}
		result = (double)(result - max - min)/(n - 2);
		printf("%.2lf\n",result);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2015 偶数求和 222

题目的意思是给定一个有序的递增偶数序列，从第二个数开始，要求按照给定的间隔m，计算每个间隔内的平均值序列。如果最后一组的数量不足m个，则取实际数量求平均值。

举个例子，假设给定的序列为：

2, 4, 6, 8, 10, 12, 14, 16, 18, 20

如果间隔m为3，则计算出的平均值序列为：

(2 + 4 + 6) / 3 = 4

(8 + 10 + 12) / 3 = 10

(14 + 16 + 18) / 3 = 16

20 (最后一组不足3个数，直接取平均值为20)

因此，程序的输入是给定的递增偶数序列和间隔m，输出是计算出的平均值序列。
------
Problem Description
有一个长度为n(n<=100)的数列，该数列定义为从2开始的递增有序偶数，现在要求你按照顺序每m个
数求出一个平均值，如果最后不足m个，则以实际数量求平均值。编程输出该平均值序列。
Input
输入数据有多组，每组占一行，包含两个正整数n和m，n和m的含义如上所述。
Output
对于每组输入数据，输出一个平均值序列，每组输出占一行。
Sample Input
3 2
4 2
Sample Output
3 6
3 7

以下是用C++实现的代码示例：

#include<iostream>
#include<cstdio>
using namespace std;

int main(){
    int n, m, i;
    while(cin >> n >> m){
        for(i = 1; i + m <= n; i += m){
            printf("%d ", 2*i + m - 1);
        }
        printf("%d\n",n + i);
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

2016 数据的交换输出 222

Problem Description
输入n(n<100)个数，找出其中最小的数，将它与最前面的数交换后输出这些数。
Input
输入数据有多组，每组占一行，每行的开始是一个整数n，表示这个测试实例的数值的个数，跟着就是
n个整数。n=0表示输入的结束，不做处理。
Output
对于每组输入数据，输出交换后的数列，每组输出占一行。
Sample Input
4 2 1 3 4
5 5 4 3 2 1
0
Sample Output
1 2 3 4
1 4 3 2 5
最佳
#include <stdio.h>

void ExchangePrintf(){
	int n,i,temp,index;
	int arr[100];
	while(scanf("%d",&n)!=EOF){
		if(n==0) break;
		if(n<0 || n>=100){
			printf("n的取值范围为[0,100)之间的整数！请重新输入！\n");
			continue;
		}
		//将输入的n个数存到arr数组中
		for(i=0;i<n;i++) {
			scanf("%d",&arr[i]);
		}
		temp=arr[0];
		//index用来记录最小元素的数组下标 
		index=0;
		for(i=1;i<n;i++){
			if(arr[i]<temp){
				temp=arr[i];
				index=i;
			}
		}
		//将最小值与arr[0]交换
		temp=arr[index];
		arr[index]=arr[0];
		arr[0]=temp;
		for(i=0;i<n;i++){
			printf("%d ",arr[i]);
		}
		printf("\n");
	}
}
----

int main(){
	int n;
	int temp[100] = {0};
	int min = 10000000;
	int xiabiao = 0;
	scanf("%d",&n);
	while(n){
		min = 10000000;
		xiabiao = 0;
        falg=0；
		for(int i = 0;i < n;i++){
			scanf("%d",&temp[i]);
			if(min > temp[i]){
				xiabiao = i;
				min = temp[i];
                flag=1；
			}
		}
		if(flag){//交换
			int t = temp[xiabiao];
			temp[xiabiao] = temp[0];
			temp[0] = t;
		}
		for(int i = 0;i < n;i++){//输出
			if(i == 0)
				printf("%d",temp[i]);
			else
				printf(" %d",temp[i]);
		}
		printf("\n");
		scanf("%d",&n);
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

2017 字符串统计 333

#include<stdio.h>
#include<string.h>
int main(){
	int n;
	scanf("%d",&n);
	char string[1000];
	while(n--){
		scanf("%s",&string);
		int length=strlen(string);
		int count=0;
		for(int i=0;i<length;i++){
			if(string[i]>='0'&&string[i]<='9'){
				count++;
			}
		}
		printf("%d\n",count);
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2018 母牛的故事 1111

#include<iostream>
using namespace std;
 Problem Description
有一头母牛，它每年年初生一头小母牛。每头小母牛从第四个年头开始，每年年初也生一头小母牛。
请编程实现在第n年的时候，共有多少头母牛？
Input
输入数据由多个测试实例组成，每个测试实例占一行，包括一个整数n(0<n<55)，n的含义如题目中
描述。
n=0表示输入数据的结束，不做处理。
Output
对于每个测试实例，输出在第n年的时候母牛的数量。
每个输出占一行。
Sample Input
2
4
5
0
Sample Output
2
4
6
--
int main()
{
	int big,one,two,three;
	int n;
	while(cin >> n,n != 0)
	{
		big = 1;
		one = 0;
		two = 0;
		three = 0;
		//big 4岁母牛 three 3岁母牛 two 2岁母牛 one 1岁母牛
		for(int i = 1;i < n;i++)
		{
			big += three;	//3岁的牛变成了可以生育的母牛
			three = two;	//2岁长大成3岁母牛
			two = one;		//1岁长大成2岁母牛
			one = big;		//可生育母牛生下了big头一岁小母牛
		}
		cout << big + three + two + one << endl;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

2019 数列有序333

Problem Description
有n(n<=100)个整数，已经按照从小到大顺序排列好，现在另外给一个整数m，请将该数插入到序列
中，并使新的序列仍然有序。
Input
输入数据包含多个测试实例，每组数据由两行组成，第一行是n和m，第二行是已经有序的n个数的数
列。n和m同时为0标示输入数据的结束，本行不做处理。
Output
对于每个测试实例，输出插入新的元素后的数列。
Sample Input
3 3
1 2 4
0 0
Sample Output
1 2 3 4

#include<stdio.h>
int main(){
    int n,m;
    while(~ scanf("%d %d",&n,&m)&&n&&m) {
        int t[100];
        for(int i=0; i<n; i++) {
            scanf("%d",&t[i]);
        }
        t[n]=m;
        int k;
        for(int i=0; i<=n; i++) {
            for(int j=0; j<=n-i-1; j++) {
                if(t[j]>t[j+1]) {
                    k=t[j];
                    t[j]=t[j+1];
                    t[j+1]=k;
                }
            }
        }
        for(int i=0; i<=n; i++) {
            if(i==n)
            printf("%d\n",t[i]);
            else
            printf("%d ",t[i]);
        }
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

2020 绝对值排序 333

#include <stdio.h>
#include <math.h>
Problem Description
输入n(n<=100)个整数，按照绝对值从大到小排序后输出。题目保证对于每一个测试实例，所有的数
的绝对值都不相等。
Input
输入数据有多组，每组占一行，每行的第一个数字为n,接着是n个整数，n=0表示输入数据的结束，不
做处理。
Output
对于每个测试实例，输出排序后的结果，两个数之间用一个空格隔开。每个测试实例占一行。
Sample Input
3 3 -4 2
4 0 1 2 -3
0
Sample Output
-4 3 2
-3 2 1 0

                        
原文链接：https://blog.csdn.net/weixin_43004044/article/details/112303665
int main(){
	int n;
	int num[100] = {0};
	scanf("%d",&n);
	while(n){
		for(int i = 0;i < n;i++){
			scanf("%d",&num[i]);
		}
		for(int k = 0;k < n;k++){
			for(int j = 0;j < n - k - 1;j++){
				if(abs(num[j]) < abs(num[j + 1])){
					int temp = num[j];
					num[j] = num[j + 1];
					num[j + 1] = temp;
				}
			}
		}
		for(int i = 0;i < n;i++){
			if(i==0)
				printf("%d",num[i]);
			else
				printf(" %d",num[i]);
		}
		printf("\n");
		scanf("%d",&n);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

2021 发工资咯 2222

#include <stdio.h>

int main(){
	int n;
	int money,num;
	int i;
	scanf("%d",&n);
	while(n){
		num = 0;
		for(i = 0;i < n;i++){
			scanf("%d",&money);
			int hundred = money / 100;
			int wushi = (money-hundred*100)/50;
			int shi = (money-hundred*100-wushi*50)/10;
			int wu = (money-hundred*100-wushi*50-shi*10)/5;
			int er = (money-hundred*100-wushi*50-shi*10-wu*5)/2;
			int yi = money-hundred*100-wushi*50-shi*10-wu*5-er*2;
			num += hundred+wushi+shi+wu+er+yi;
		}
		printf("%d\n",num);
		scanf("%d",&n);
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2022 海选女主角 222

#include <stdio.h>
#include <math.h>
Problem Description
potato老师虽然很喜欢教书，但是迫于生活压力，不得不想办法在业余时间挣点外快以养家糊口。
“做什么比较挣钱呢？筛沙子没力气，看大门又不够帅...”potato老师很是无奈。
“张艺谋比你还难看，现在多有钱呀，听说还要导演奥运开幕式呢！你为什么不去娱乐圈发展
呢？”lwg在一旁出主意。
嗯，也是，为了生存，就委屈点到娱乐圈混混吧，马上就拍一部激光电影《杭电记忆——回来我的
爱》。
说干就干，马上海选女主角（和老谋子学的，此举可以吸引媒体的眼球，呵呵），并且特别规定，演
员必须具有ac的基本功，否则直接out!
由于策划师风之鱼（大师级水王）宣传到位，来应聘的MM很多，当然包括nit的蛋糕妹妹等呼声很高
的美女，就连zjut的jqw都男扮女装来应聘（还好被安全顾问hdu_Bin-Laden认出，给轰走了），
看来娱乐圈比acm还吸引人哪...
面试那天，刚好来了m*n个MM，站成一个m*n的队列，副导演Fe(OH)2为每个MM打了分数，分数都是
32位有符号整数。
一开始我很纳闷：分数怎么还有负的？Fe(OH)2解释说，根据选拔规则，头发染成黄色、化妆太浓、
穿的太少等等都要扣分数的，扣的多了就可能是负分了，当然，如果发现话语中夹有日语，就直接
给-2147483648分了。
分数送上来了，是我做决定的时候了，我的一个选拔原则是，要选一个面试分数绝对值（必须还是32
位整数）最大的MM。
特别说明：如果不幸选中一个负分的MM,也没关系，因为我觉得，如果不能吸引你，那要想法恶心
你。
Input
输入数据有多组，每组的第一行是两个整数m和n，表示应聘MM的总共的行列数，然后是m行整数，每
行有n个，m和n的定义见题目的描述。
Output
对于每组输入数据，输出三个整数x,y和s，分别表示选中的MM的行号、列号和分数。
note:行号和列号从一开始，如果有多个MM的分数绝对值一样，那么输出排在最前面的一个（即行号
最小的那个，如果行号相同则取列号最小的那个）。
Sample Input
2 3
1 4 -3
-7 3 0
Sample Output
2 1 -7


void LeadingLady(){
	int i,j,n,m,x,y,temp;
	while(scanf("%d%d",&m,&n)!=EOF){
		if(n<=0 || m<=0){
			printf("输入的行数和列数应为正整数!\n");
			continue;
		}
		//动态申请m行n列的二维数组 
		int (*arr)[n];
		arr=(int (*)[n])malloc(m*n*sizeof(int));
		for(i=0;i<m;i++){
			for(j=0;j<n;j++){
				scanf("%d",&arr[i][j]);
			}
		}
		x=y=temp=0;
		for(i=0;i<m;i++){
			for(j=0;j<n;j++){
				if(fabs(arr[i][j])>fabs(temp)){
					temp=arr[i][j];
					x=i;
					y=j;
				}
			}
		}
		printf("%d %d %d\n",x+1,y+1,arr[x][y]);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

2023 求平均成绩 222

#include <stdio.h>
Problem Description
假设一个班有n(n<=50)个学生，每人考m(m<=5)门课，求每个学生的平均成绩和每门课的平均成绩，并输出各科成绩均大于等于平均成绩的学生数量。
Input
输入数据有多个测试实例，每个测试实例的第一行包括两个整数n和m，分别表示学生数和课程数。然后是n行数据，每行包括m个整数（即：考试分数）。
Output
对于每个测试实例，输出3行数据，第一行包含n个数据，表示n个学生的平均成绩，结果保留两位小数；第二行包含m个数据，表示m门课的平均成绩，结果保留两位小数；第三行是一个整数，表示该班级中各科成绩均大于等于平均成绩的学生数量。
每个测试实例后面跟一个空行。
Sample Input
2 2
5 10
10 20
Sample Output
7.50 15.00
7.50 15.00
1

#include <stdio.h>

void AverScore(){
	//arr[i][j]表示第i个学生第j们课程的成绩 
	int arr[50][50];
	//averstu[i]表示第i个学生的平均成绩 
	//avercou[i]表示i门课程的平均成绩
	double x,y,averstu[50],avercou[50],sum;
	//n为学生数量，m为课程数量 
	int i,j,n,m,count,flag;
	while(scanf("%d%d",&n,&m)!=EOF){
		if(n<=0 || n>50){
			printf("n的取值范围为[1,50]之间的整数！\n");
			continue;
		}
		if(m<=0 || m>5){
			printf("m的取值范围为[1,5]之间的整数！\n");
			continue;
		}
		//记录每个学生每门课程得到成绩 
		for(i=0;i<n;i++){
			for(j=0;j<m;j++){
				scanf("%d",&arr[i][j]);
			}
		}
		//计算每个同学的平均成绩
		for(i=0;i<n;i++){
			sum=0;
			for(j=0;j<m;j++){
				sum+=arr[i][j];
			}
			averstu[i]=sum/m;
		} 
		//计算每门课程的平均成绩
		for(i=0;i<m;i++){
			sum=0;
			for(j=0;j<n;j++){
				sum+=arr[j][i];
			}
			avercou[i]=sum/n;
		} 
		//计算各科成绩均大于等于平均成绩的学生数量
		count=0;
		for(i=0;i<n;i++){
			flag=1;
			for(j=0;j<m;j++){
				if(arr[i][j]<avercou[j]){
					flag=0;
					break;
				}
			}
			if(flag) count++;
		}
		//输出结果 
		for(i=0;i<n;i++){
			printf("%.2lf ",averstu[i]);
		}
		printf("\n");
		for(i=0;i<m;i++){
			printf("%.2lf ",avercou[i]);
		}
		printf("\n");
		printf("%d\n\n",count);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

2024 C语言合法标识符 222

#include <stdio.h>
#include <string.h>
Problem Description
输入一个字符串，判断其是否是C的合法标识符。
Input
输入数据包含多个测试实例，数据的第一行是一个整数n,表示测试实例的个数，然后是n行输入数据，每行是一个长度不超过50的字符串。
Output
对于每组输入数据，输出一行。如果输入数据是C的合法标识符，则输出"yes"，否则，输出“no”。
Sample Input
3
12ajf
fi8x_a
ff  ai_2
Sample Output
no
yes
no
-----------------------
int main(){
	int n;
	char input[50];
	bool flag;
	scanf("%d",&n);
	getchar();
	while(n--){
		flag = true;
		gets(input);
		int length = strlen(input);
		for(int i = 0;i < length;i++){
			if(i == 0){
				if(input[i]!='_'&&!(input[i]>='a'&&input[i]<='z')&&!(input[i]>='A'&&input[i]<='Z')){
					flag = false;
					break;
				}
			}else{
				if((input[i]>='a'&&input[i]<='z')||(input[i]>='A'&&input[i]<='Z')&&||(input[i]>='0'&&input[i]<='9')||input[i]!='_'){
					flag = false;
					break;
				}
			}
		}
		if(flag)
			printf("yes\n");
		else
			printf("no\n");
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

2025 查找最大元素 111

putchar() 函数用于将单个字符输出到标准输出（屏幕）。它接受一个整数作为参数，该整数表示要输出的字符的 ASCII 值。它会将该字符输出到控制台，并将其作为无符号字符返回。

#include<stdio.h>
#include<string.h>
Problem Description
对于输入的每个字符串，查找其中的最大字母，在该字母后面插入字符串“(max)”。
Input
输入数据包括多个测试实例，每个实例由一行长度不超过100的字符串组成，字符串仅由大小写字母构成。
Output
对于每个测试实例输出一行字符串，输出的结果是插入字符串“(max)”后的结果，如果存在多个最大的字母，就在每一个最大字母后面都插入"(max)"。
Sample Input
abcdefgfedcba
xxxxx
Sample Output
abcdefg(max)fedcba
x(max)x(max)x(max)x(max)x(max)
-------------
int main(){
	char c[100];
	while(scanf("%s",c)!=EOF){
		char max='A';
		for(int i=1;i<=strlen(c);i++){
			if(c[i-1]>=max) max=c[i-1];
		}
		for(int i=1;i<=strlen(c);i++){
			putchar(c[i-1]);
			if(c[i-1]==max) printf("(max)");
		}
		printf("\n");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

2026 首字母变大写 333

#include<iostream>
#include<string>
#include<cstring>
using namespace std;
Problem Description
输入一个英文句子，将每个单词的第一个字母改成大写字母。
Input
输入数据包含多个测试实例，每个测试实例是一个长度不超过100的英文句子，占一行。
Output
请输出按照要求改写后的英文句子。
Sample Input
i like acm
i want to get an accepted
Sample Output
I Like Acm
I Want To Get An Accepted

==
int main()
{
	char str[100];
    //getline用法
	while(scanf("%s",str)!=EOF){
	    cout<<str[0]-32;
		str[0]=(char)(str[0]-32);
	
		for(int i=1;i<str.size();i++)
		{
			if(str[i]==' ')
			str[i+1]=(char)(str[i+1]-32);
		}
		cout<<str<<endl;
		
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

2027 统计元音 333

#include <stdio.h>
#include <string.h>
Problem Description
统计每个元音字母在字符串中出现的次数。
Input
输入数据首先包括一个整数n，表示测试实例的个数，然后是n行长度不超过100的字符串。
Output
对于每个测试实例输出5行，格式如下：
a:num1
e:num2
i:num3
o:num4
u:num5
多个测试实例之间由一个空行隔开。
请特别注意：最后一块输出后面没有空行：）
Sample Input
2
aeiou
my name is ignatius
Sample Output
a:1
e:1
i:1
o:1
u:1

a:2
e:1
i:3
o:0
u:1
void StatisticVowels(){
	char str[100];
	char temp;
	//用num数组来存储每个元音字母在字符串中出现的次数
	int i,length,n,num[5];
	scanf("%d",&n);
	getchar();
	while(n--){
		//将数组num中的内容全部初始化为0 
		memset(num,0,sizeof(num));
		gets(str);
		length=strlen(str);
		for(i=0;i<length;i++){
			switch(str[i]){
				case 'a': num[0]++; break;
				case 'e': num[1]++; break;
				case 'i': num[2]++; break;
				case 'o': num[3]++; break;
				case 'u': num[4]++; break;
			}
		}
		printf("a:%d\n",num[0]);
        printf("e:%d\n",num[1]);
        printf("i:%d\n",num[2]);
        printf("o:%d\n",num[3]);
        printf("u:%d\n",num[4]);
		if(n!=0){
			printf("\n");
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

2028 Lowest Common Multiple Plus 11111

求n个数的最小公倍数

#include <iostream>

using namespace std;
Problem Description
求n个数的最小公倍数。
Input
输入包含多个测试实例，每个测试实例的开始是一个正整数n，然后是n个正整数。
Output
为每组测试数据输出它们的最小公倍数，每个测试实例的输出占一行。你可以假设最后的输出是一个32位的整数。
Sample Input
2 4 6
3 2 5 7
Sample Output
12
70

// 计算两个数的最大公约数
int gcd(int a, int b) {
    if (b == 0) {
        return a;
    }
    return gcd(b, a % b);
}

// 计算两个数的最小公倍数
int lcm(int a, int b) {
    return a * b / gcd(a, b);
}

int main() {
    int n;
    while (cin >> n) {
        int result = 1;
        for (int i = 0; i < n; ++i) {
            int num;
            cin >> num;
            result = lcm(result, num);
        }
        cout << result << endl;
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

2029 Palindromes _easy version

#include <stdio.h>
#include <string.h>
int main(){
	int n;
	scanf("%d\n",&n);
	char input[1024];
	bool flag;
	while(n--){
		flag = true;
		gets(input);
		for(int i = 0;i < strlen(input)/2.0;i++){
			if(input[i] != input[strlen(input)-1-i]){
				printf("no\n");
				flag = false;
				break;
			}
		}
		if(flag)
			printf("yes\n");
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2030 汉字统计 11 111

#include<stdio.h>
#include<string.h>
int main(){
    int n,m=0,i,len;
    char a[10000];
    scanf("%d",&n);
    getchar();   //接收换行
    while(n--){
        m=0;
        gets(a); 
        len=strlen(a);        
        for(i=0;i<len;i++){
            if(a[i]<0)
                m++;
        }
        printf("%d\n",m/2);  
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2031 进制转换 222

#include<stdio.h>
#include<math.h>   // abs，你懂我也懂。 
Problem Description
输入一个十进制数N，将它转换成R进制数输出。
Input
输入数据包含多个测试实例，每个测试实例包含两个整数N(32位整数)和R（2<=R<=16, R<>10）。
Output
为每个测试实例输出转换后的数，每个输出占一行。如果R大于10，则对应的数字规则参考16进制
（比如，10用A表示，等等）。
Sample Input
7 2
23 12
-4 3
Sample Output
111
1B
-11

int main()
{
	int a[100];   // 开个数组存余数
	int N,R;
	while(~scanf("%d%d",&N,&R)) 这里这个取反有问题
	{	
		if(N<0)printf("-");  //负数先输出负号 
		N=abs(N);            //然后转正 
		int a[1000],i=0;
		for(;N>0;i++)
		{
			a[i]= N % R;
			N = N / R;
		}
		i--;//因为循环结束i已经跑到末尾+1去了 

		for(;i>=0;i--)
			if(a[i]>9) printf("%c",a[i]+'A'-10);
			else printf("%d",a[i]);
		putchar('\n');
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

2032 杨辉三角 111

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
using namespace std;
Problem Description
还记得中学时候学过的杨辉三角吗？具体的定义这里不再描述，你可以参考以下的图形：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
Input
输入数据包含多个测试实例，每个测试实例的输入只包含一个正整数n（1<=n<=30），表示将要输出
的杨辉三角的层数。
Output
对应于每一个输入，请输出相应层数的杨辉三角，每一层的整数之间用一个空格隔开，每一个杨辉三
角后面加一个空行。
Sample Input
2 3
Sample Output
1
1 1

1
1 1
1 2 1

int main() {
  int n;  
    while(cin>>n){
      for (int i = 0; i < n; i++) {
          int num = 1;
          for (int j = 0; j <= i; j++) {
              cout << num << " ";
              num = num * (i - j) / (j + 1);
          }
          cout << endl;
      }
   }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

2033 人见人爱A+B 3333

#include<iostream>
using namespace std;
 Problem Description
HDOJ上面已经有10来道A+B的题目了，相信这些题目曾经是大家的最爱，希望今天的这个A+B能给大
家带来好运，也希望这个题目能唤起大家对ACM曾经的热爱。
这个题目的A和B不是简单的整数，而是两个时间，A和B 都是由3个整数组成，分别表示时分秒，比
如，假设A为34 45 56，就表示A所表示的时间是34小时 45分钟 56秒。
Input
输入数据有多行组成，首先是一个整数N，表示测试实例的个数，然后是N行数据，每行有6个整数
AH,AM,AS,BH,BM,BS，分别表示时间A和B所对应的时分秒。题目保证所有的数据合法。
Output
对于每个测试实例，输出A+B，每个输出结果也是由时分秒3部分组成，同时也要满足时间的规则
（即：分和秒的取值范围在0~59），每个输出占一行，并且所有的部分都可以用32位整数表示。
Sample Input
2
1 2 3 4 5 6
34 45 56 12 23 34
Sample Output
5 7 9
47 9 30

int main(){
    int n;
    cin>>n;
    while(n--){
        int AH,AM,AS,BH,BM,BS,RH,RM,RS;
        cin>>AH>>AM>>AS>>BH>>BM>>BS;
        RS = (AS+BS)%60;
        RM = (AM+BM+(AS+BS)/60)%60;
        RH = AH+BH+(AM+BM+(AS+BS)/60)/60;
        cout<<RH<<" "<<RM<<" "<<RS<<endl;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

2034 人见人爱A-B 3333

指针的数组写法和排序
int *a_arr = new int[n];
int *b_arr = new int[m];
int *c_arr = new int[n];

int *tie = (int*)malloc(n * sizeof(int));//需要强转，但是new的不需要强转

int a[100]={0};

sort(a_arr,a_arr+n);
sort(b_arr,b_arr+m);
//
#include<iostream>
#include<algorithm>
using namespace std;
 Problem Description
参加过上个月月赛的同学一定还记得其中的一个最简单的题目，就是{A}+{B}，那个题目求的是两个
集合的并集，今天我们这个A-B求的是两个集合的差，就是做集合的减法运算。（当然，大家都知道
集合的定义，就是同一个集合中不会有两个相同的元素，这里还是提醒大家一下）
呵呵，很简单吧？
Input
每组输入数据占1行,每行数据的开始是2个整数n(0<=n<=100)和m(0<=m<=100),分别表示集合A和
集合B的元素个数，然后紧跟着n+m个元素，前面n个元素属于集合A，其余的属于集合B. 每个元素为
不超出int范围的整数,元素之间有一个空格隔开.
如果n=0并且m=0表示输入的结束，不做处理。
Output
针对每组数据输出一行数据,表示A-B的结果,如果结果为空集合，则输出“NULL”,否则从小到大输出
结果,为了简化问题，每个元素后面跟一个空格.
Sample Input
3 3 1 2 3 1 4 7
3 7 2 5 8 2 3 4 5 6 7 8 
0 0
Sample Output
2 3 
NULL
==============
int main(){
    int n,m;
    while(cin>>n>>m){
        if(n==0&&m==0)
            break;
        //存A、B集合以及它们差集的元素
        int *a_arr = new int[n];
        int *b_arr = new int[m];
        int *c_arr = new int[n];
        int c_size = 0;
        for(int i=0;i<n;i++)
            cin>>a_arr[i];
        for(int i=0;i<m;i++)
            cin>>b_arr[i];
        sort(a_arr,a_arr+n);
        sort(b_arr,b_arr+m);
        //计算A-B，结果存入c_arr
        for(int i=0;i<n;i++){
            bool f=true;
            for(j=0;j<m;j++)
                if(a_arr[i]==b_arr[j])
                	f=false;
                    break;
            if(f)
                c_arr[c_size++] = a_arr[i];
        }
        //输出差集
        if(c_size == 0)
            cout<<"NULL"<<endl;
        else{
            for(int i = 0;i < c_size;i++)
                cout<<c_arr[i]<<" ";
            cout<<endl;
        }
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

2035 人见人爱A^B 33333

#include<iostream>
using namespace std;
 Problem Description
求A^B的最后三位数表示的整数。
说明：A^B的含义是“A的B次方”
Input
输入数据包含多个测试实例，每个实例占一行，由两个正整数A和B组成（1<=A,B<=10000），如果
A=0, B=0，则表示输入数据的结束，不做处理。
Output
对于每个测试实例，请输出A^B的最后三位表示的整数，每个输出占一行。
Sample Input
2 3
12 6
6789 10000
0 0
Sample Output
8
984
1
===
int main(){
    int num1,num2;
    while(cin>>num1>>num2){
        if(num1==0&&num2==0)
            break;
        if(num1==0){
            cout<<"0"<<endl;
            continue;
        }
        if(num2==0){
            cout<<"1"<<endl;
            continue;
        }
        int result = 1;
        for(int i=0;i<num2;i++)
            result = (result*num1)%1000;
        cout<<result<<endl;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

2036.改革春风吹满地 11111

Problem Description

话说部分学生心态极好，每天就知道游戏，这次考试如此简单的题目，也是云里雾里，而且，还竟然
来这么几句打油诗。
好呀，老师的责任就是帮你解决问题，既然想种田，那就分你一块。
这块田位于浙江省温州市苍南县灵溪镇林家铺子村，多边形形状的一块地，原本是linle 的，现在就
准备送给你了。不过，任何事情都没有那么简单，你必须首先告诉我这块地到底有多少面积，如果回
答正确才能真正得到这块地。
发愁了吧？就是要让你知道，种地也是需要AC知识的！以后还是好好练吧...
Input
输入数据包含多个测试实例，每个测试实例占一行，每行的开始是一个整数n(3<=n<=100)，它表示
多边形的边数（当然也是顶点数），然后是按照逆时针顺序给出的n个顶点的坐标（x1, y1, x2, 
y2... xn, yn）,为了简化问题，这里的所有坐标都用整数表示。
输入数据中所有的整数都在32位整数范围内，n=0表示数据的结束，不做处理。
Output
对于每个测试实例，请输出对应的多边形面积，结果精确到小数点后一位小数。
每个实例的输出占一行。
Sample Input
3 0 0 1 0 0 1
4 1 0 0 1 -1 0 0 -1
0
Sample Output
0.5
2.0
#include <stdio.h>
#include <math.h>

void Area(){
	//(x[i],y[i])表示第i个顶点的坐标 
	int x[100],y[100];
	//n表示边数（同时也表示顶点个数） 
	int n,i,x1,x2,y1,y2;
	double res;
	while(scanf("%d",&n)!=EOF) {
		if(n==0){
			break;
		}
		if(n<3 || n>100){
			printf("顶点个数n的取值范围为[3,100]之间的整数！\n");
			continue;
		}
		//将顶点坐标存入数组x和数组y中 
		for(i=0;i<n;i++){
			scanf("%d%d",&x[i],&y[i]);
		}
		res=0;
		//对于向量A=(x1,y1)、向量B=(x2,y2),向量A和向量B叉乘的模的绝对值表示以A和B为两边所形成的平行四边形的面积
		for(i=1;i<n-1;i++){
			x1=x[i]-x[0];
			y1=y[i]-y[0];
			x2=x[i+1]-x[0];
			y2=y[i+1]-y[0];
			res+=(double)fabs((x1*y2-x2*y1))/2;
		}
		printf("%.1lf\n",res);
	}	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

2037 今年暑假不AC 111 1

tle

#include <bits/stdc++.h>
using namespace std;
Problem Description
“今年暑假不AC？”
“是的。”
“那你干什么呢？”
“看世界杯呀，笨蛋！”
“@#$%^&*%...”
贪心算法
确实如此，世界杯来了，球迷的节日也来了，估计很多ACMer也会抛开电脑，奔向电视了。
作为球迷，一定想看尽量多的完整的比赛，当然，作为新时代的好青年，你一定还会看一些其它的节目，比如新闻联播（永远不要忘记关心国家大事）、非常6+7、超级女生，以及王小丫的《开心辞典》等等，假设你已经知道了所有你喜欢看的电视节目的转播时间表，你会合理安排吗？（目标是能看尽量多的完整节目）
Input
输入数据包含多个测试实例，每个测试实例的第一行只有一个整数n(n<=100)，表示你喜欢看的节目的总数，然后是n行数据，每行包括两个数据Ti_s,Ti_e (1<=i<=n)，分别表示第i个节目的开始和结束时间，为了简化问题，每个时间都用一个正整数表示。n=0表示输入结束，不做处理。
Output
对于每个测试实例，输出能完整看到的电视节目的个数，每个测试实例的输出占一行。
Sample Input
12
1 3
3 4
0 7
3 8
15 19
15 20
10 15
8 18
6 12
5 10
4 14
2 9
0
Sample Output
5
====
int main()
{
	int n, i,j,temp,sum;
// 	cin>>n;
    // scanf("%d", &n);
	while(scanf("%d",&n)!=EOF && n)
	{
	 
		sum = 1;
		int *tie = (int*)malloc(n * sizeof(int));
		int *tis = (int*)malloc(n * sizeof(int));
		for (i = 0; i < n; i++)
			scanf("%d %d", &tis[i], &tie[i]);
		for (i = 0; i < n; i++)
			for (j = 1; j < n-i; j++)
				if (tie[j - 1] > tie[j])
				{
					temp = tie[j - 1], tie[j - 1] = tie[j], tie[j] = temp;
					temp = tis[j - 1], tis[j - 1] = tis[j], tis[j] = temp;
				}
		for(i=0;i<n;i++)
			for(j=i+1;j<n;j++)
				if (tie[i] <= tis[j])
				{
					sum++; i = j;
				}
		printf("%d\n", sum);
	}
	return 0;
}
法2：
#include <stdio.h>

struct program{
	int start;		//开始时间 
	int finish;		//结束时间 
};

void NoAC(){
	int n,i,j,count,tf;
	struct program programs[100],temp; 
	while(scanf("%d",&n)!=EOF && n){
		if(n<0 || n>100){
			printf("节目总数的取值范围为[0,100]之间的整数！\n");
			continue;
		}
		count=1; 
		for(i=0;i<n;i++){
			scanf("%d%d",&programs[i].start,&programs[i].finish);
		}
		//使用简单交换排序，按照每个节目的结束时间从小到大进行排序
		for(i=0;i<n-1;i++){
			for(j=i+1;j<n;j++){
				if(programs[i].finish>programs[j].finish){
					temp=programs[j];
					programs[j]=programs[i];
					programs[i]=temp;
				}
			}
		}
		tf=programs[0].finish;
		for(i=1;i<n;i++){
			if(programs[i].start>=tf){
				count++;
				tf=programs[i].finish;
			}
		}
		printf("%d\n",count);
	}
}

法3 ：深搜 dfs
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>

using namespace std;
typedef pair<int, int> PII;
PII a[101];
int ans;
int n;

void dfs(int u, int res, int end) // 第几个节目，已经看了几个节目，现在的时间
{
  if (res > ans)
    ans = res;
  if (u >= n)
    return;
  if (a[u].first >= end) {            // 如果有时间看这个节目
    dfs(u + 1, res + 1, a[u].second); // 选择看这个节目
    dfs(u + 1, res, end);             // 选择不看这个节目
  } else {
    dfs(u + 1, res, end); // 没有时间看这个节目，跳过
  }
}

int main() {
  while (cin >> n) {
    if (n == 0)
      break;
    ans = 0;
    int start, end;
    for (int i = 0; i < n; i++) {
      cin >> start >> end;
      a[i] = {start, end};
    }
    sort(a, a + n); // 按开始时间排序
    dfs(0, 0, -1);
    cout << ans << endl;
  }

  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

结构体贪心排序外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

2038没题目

2039 三角形 3333

#include <stdio.h>

void IsTriangle(){
	int n;
	double a,b,c;
	scanf("%d",&n);
	while(n--){
		scanf("%lf%lf%lf",&a,&b,&c);
		if(a<=0 || b<=0 || c<=0){
			printf("三角形的三条边都为正数！\n");
			continue;
		}
		if(a+b>c && a+c>b && b+c>a){
			printf("YES\n");
		}else{
			printf("NO\n");
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2040 亲和数 3333

#include <stdio.h>

int main(){
	int M,A,B;
	int total;
	bool flag;
	scanf("%d",&M);
	while(M--){
		total = 1;
		flag = true;
		scanf("%d%d",&A,&B);
		for(int i= 2;i < A;i++){
			if(A % i == 0)
				total += i;
		}
		if(total != B){
			printf("NO\n");
			continue;
		}else{
			total = 1;
			for(int i= 2;i < B;i++){
				if(B % i == 0)
					total += i;
			}
			if(total != A){
				printf("NO\n");
			}else{
				printf("YES\n");
			}
		}

	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

2041.超级楼梯 2222

#include <iostream>
#include <vector>

using namespace std;
Problem Description
有一楼梯共M级，刚开始时你在第一级，若每次只能跨上一级或二级，要走上第M级，共有多少种走
法？
Input
输入数据首先包含一个整数N，表示测试实例的个数，然后是N行数据，每行包含一个整数
M（1<=M<=40）,表示楼梯的级数。
Output
对于每个测试实例，请输出不同走法的数量
Sample Input
2
2
3
Sample Output
1
2
===
递推公式
// 计算走上第n级楼梯的走法数量
int countWays(int n) {
    // 如果楼梯级数小于等于2，直接返回对应的走法数量
    if (n <= 2) {
        return n;
    }

    // 初始化走法数组，初始状态下走到第1级和第2级的走法数量都是已知的
    vector<int> ways(n + 1, 0);
    ways[1] = 1;//从第一级向上走1级有1种走法
    ways[2] = 2;//从第一级向上走2级有1种走法

    // 从第3级楼梯开始逐级计算走法数量
    for (int i = 3; i <= n; ++i) {
        // 走到第i级楼梯的走法数量等于走到第i-1级楼梯的走法数量加上走到第i-2级楼梯的走法数量
        ways[i] = ways[i - 1] + ways[i - 2];
    }

    // 返回走到第n级楼梯的走法数量，向上走n-1级别。
    return ways[n-1];
}

int main() {
    int N;
    cin >> N; // 输入测试实例个数

    for (int i = 0; i < N; ++i) {
        int M;
        cin >> M; // 输入楼梯的级数

        // 计算走上第M级楼梯的走法数量并输出
        cout << countWays(M) << endl;
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

2042 不容易系列之二 3333

#include <stdio.h>
由于徐老汉没钱，收费员就将他的羊拿走一半，看到老汉泪水涟涟，犹豫了一下，又还给老汉一只。
巧合的是，后面每过一个收费站，都是拿走当时羊的一半，然后退还一只，等到老汉到达市场，就只
剩下3只羊了。
你,当代有良知的青年，能帮忙算一下老汉最初有多少只羊吗？
Input
输入数据第一行是一个整数N，下面由N行组成，每行包含一个整数a(0<a<=30),表示收费站的数
量。
Output
对于每个测试实例，请输出最初的羊的数量,每个测试实例的输出占一行。
Sample Input
2
1
2
Sample Output
4
6
void SheepNum(){
	int n,a,res;
	scanf("%d",&n);
	while(n--){
		res=3;
		//a表示收费站的数量
		scanf("%d",&a);
		if(a<=0 || a>30){
			printf("a的取值范围为(0,30]之间的整数!\n");
			continue;
		}
		while(a--){
			res-=1;
			res*=2;
		}
		printf("%d\n",res);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

2043.密码 33333

#include <stdio.h>
#include <string.h>
Problem Description
网上流传一句话:"常在网上飘啊，哪能不挨刀啊～"。其实要想能安安心心地上网其实也不难，学点
安全知识就可以。
首先，我们就要设置一个安全的密码。那什么样的密码才叫安全的呢？一般来说一个比较安全的密码
至少应该满足下面两个条件：
(1).密码长度大于等于8，且不要超过16。
(2).密码中的字符应该来自下面“字符类别”中四组中的至少三组。
这四个字符类别分别为：
1.大写字母：A,B,C...Z;
2.小写字母：a,b,c...z;
3.数字：0,1,2...9;
4.特殊符号：~,!,@,#,$,%,^;
给你一个密码，你的任务就是判断它是不是一个安全的密码。
Input
输入数据第一行包含一个数M，接下有M行，每行一个密码（长度最大可能为50），密码仅包括上面的
四类字符。
Output
对于每个测试实例，判断这个密码是不是一个安全的密码，是的话输出YES，否则输出NO。
Sample Input
3
a1b2c3d4
Linle@ACM
^~^@^@!%
Sample Output
NO
YES
NO


void Password(){
	char psw[50];
	int i,M,length;
	int flag1,flag2,flag3,flag4,flag;
	scanf("%d",&M);
	while(M--){
		scanf("%s",psw);
		length=strlen(psw);
		if(length<8 || length>16){
			printf("NO\n");
			continue;
		}
		flag1=flag2=flag3=flag4=0;
		for(i=0;i<length;i++){
			if(psw[i]>=65 && psw[i]<=90){
				//A~Z的ASCII值为65~90
				flag1=1; 
			}else if(psw[i]>=97 && psw[i]<=122){
				//a~z的ASCII值为97~122
				flag2=1; 
			}else if(psw[i]>=48 && psw[i]<=57){
				//0~9的ASCII值为97~122
				flag3=1; 
			}else if(psw[i]=='~'  ||  psw[i]=='!'  ||  
					 psw[i]=='@'  ||  psw[i]=='#'  ||  
					 psw[i]=='$'  ||  psw[i]=='%'  ||  
					 psw[i]=='^'){
				//~,!,@,#,$,%,^
				flag4=1;
			}
		}
		flag=flag1+flag2+flag3+flag4;
		if(flag>=3){
			printf("YES\n");
		}else{
			printf("NO\n");
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

2044.一只小蜜蜂… 1111

#include <stdio.h>

void Honeybee(){
	int hive[50];
	int i,n,a,b;
	hive[1]=1;
	hive[2]=2;
	for(i=3;i<50;i++){
		hive[i]=hive[i-1]+hive[i-2];
	}
	while(scanf("%d",&n)!=EOF){
		while(n--){
			scanf("%d%d",&a,&b);
			if(a<=0 || a>=50 || b<=0 || b>=50){
				printf("0<a<b<50，且均为整数！\n");
				continue;
			}
			//若a>b，则交换a、b的值 
			if(a>b){
				a=a+b;
				b=a-b;
				a=a-b;
			}
			printf("%d\n",hive[b-a]);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

2045.不容易系列之(3)—— LELE的RPG难题 1111

递推公式

#include <stdio.h>
Problem Description
人称“AC女之杀手”的超级偶像LELE最近忽然玩起了深沉，这可急坏了众多“Cole”（LELE的粉丝,即"可乐"）,经过多方打探，某资深Cole终于知道了原因，原来，LELE最近研究起了著名的RPG难题:
有排成一行的ｎ个方格，用红(Red)、粉(Pink)、绿(Green)三色涂每个格子，每格涂一色，要求任何相邻的方格不能同色，且首尾两格也不同色．求全部的满足要求的涂法.
以上就是著名的RPG难题.
如果你是Cole,我想你一定会想尽办法帮助LELE解决这个问题的;如果不是,看在众多漂亮的痛不欲生的Cole女的面子上,你也不会袖手旁观吧?
Input
输入数据包含多个测试实例,每个测试实例占一行,由一个整数N组成，(0<n<=50)。
Output
对于每个测试实例，请输出全部的满足要求的涂法，每个实例的输出占一行。
Sample Input
1
2
Sample Output
3
6
===
void RPG(){
	//s[i]表示有i个方格时满足要求的涂法
	long long s[51]={0,3,6,6,18};
	int i,n;
	for(i=5;i<=50;i++){
		s[i]=s[i-1]+2*s[i-2];
	}
	while(scanf("%I64d",&n)!=EOF){
		if(n<=0 || n>50){
			printf("n的取值范围为(0,50]之间的整数!\n");
			continue;
		}
		printf("%I64d\n",s[n]);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

2046.骨牌铺方格 1111

递推公式

https://blog.csdn.net/weixin_43004044/article/details/112505506
#include <stdio.h>

void Dominoes(){
	//dom[i]表示在2xi的一个长方形方格铺放方案的总数
	__int64 dom[51];
	int i,n;
	dom[0]=0;
	dom[1]=1;
	dom[2]=2;
	for(i=3;i<=50;i++){
		dom[i]=dom[i-1]+dom[i-2];
	}
	while(scanf("%I64d",&n)!=EOF){
		if(n<=0 || n>50){
			printf("n的取值范围为(0,50]之间的整数!\n");
			continue;
		}
		printf("%I64d\n",dom[n]);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2047 阿牛的EOF牛肉串 111 递推公式

递推公式

//
//  main.c
//  杭州电子科技大学
//
//  Created by yonuyeung on 2021/10/20.
//经过分析可知，该题涉及递推，其递推关系式为Tn=2*(T(n-1)+T(n-2))
#include<stdio.h>
int main()
{
    int n;
    long long a[45]={0,3,8};
    for(int i=3;i<45;i++)
    {
        a[i]=2*(a[i-1]+a[i-2]);
    }
    
    while(scanf("%d",&n)!=EOF)
    {
        printf("%lld\n",a[n]);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2048.神、上帝以及老天爷

递推公式错排公式

#include <stdio.h>
错排公式
void LuckDraw(){
	int C,n,i;
	__int64 draw[21]={0,0,1,2};//下标就是n，n个元素，共有这么多种错排
	__int64 sum;
	for(i=4;i<=20;i++) {
		draw[i]=(i-1)*(draw[i-1]+draw[i-2]);
	}
	scanf("%d",&C);
	while(C--){
		sum=1;
		scanf("%d",&n);
		for(i=1;i<=n;i++){
			sum*=i;//n个元素，共有n的阶层排列
		}
		printf("%.2lf%\n",(draw[n]*1.0/sum)*100);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2049.不容易系列之(4)——考新郎

#include <iostream>
using namespace std;
Problem Description
国庆期间,省城HZ刚刚举行了一场盛大的集体婚礼,为了使婚礼进行的丰富一些,司仪临时想出了有一个有意思的节目,叫做"考新郎",具体的操作是这样的:
首先,给每位新娘打扮得几乎一模一样,并盖上大大的红盖头随机坐成一排;
然后,让各位新郎寻找自己的新娘.每人只准找一个,并且不允许多人找一个.
最后,揭开盖头,如果找错了对象就要当众跪搓衣板...
看来做新郎也不是容易的事情...
假设一共有N对新婚夫妇,其中有M个新郎找错了新娘,求发生这种情况一共有多少种可能.
Input
输入数据的第一行是一个整数C,表示测试实例的个数，然后是C行数据，每行包含两个整数N和M(1<M<=N<=20)。
Output
对于每个测试实例，请输出一共有多少种发生这种情况的可能，每个实例的输出占一行。
Sample Input
2
2 2
3 2
Sample Output
1
3
==
int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

int combination(int n, int m) {
    return factorial(n) / (factorial(m) * factorial(n - m));
}

int main() {
    int C;
    cin >> C;
    
    while (C--) {
        int N, M;
        cin >> N >> M;
        
        int possibilities = combination(N, M);
        cout << possibilities << endl;
    }
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

2050 折线分割平面递推公式111

递推公式
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

#include <stdio.h>

void FoldLine(){
	int n,line;
	scanf("%d",&n);
	while(n--){
		scanf("%d",&line);
		if(line<=0 || line>10000){
			printf("折线数量的取值范围为(0,10000]之间的整数！\n");
			continue;
		}
		printf("%d\n",2*line*line-line+1);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2051.Bitset 33333

#include <stdio.h>

void TenToTwo(){
	int n,two[11],i,j;
	while(scanf("%d",&n)!=EOF){
		if(n<=0 || n>=1000) {
			printf("n的取值范围为(0,1000)之间的整数！\n");
			continue;
		}
		i=0;
		while(n>0){
			two[i]=n%2;
			n/=2;
			i++;
		}
		for(j=i-1;j>=0;j--){
			printf("%d",two[j]);
		}
		printf("\n");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

常用库函数

C++中常用的标准库头文件有很多，这些头文件包含了各种函数、类和数据类型的声明，以及宏定义等，用于支持不同的程序功能。

以下是一些常见的C++标准库头文件及其用途：

1. **<iostream>**：提供输入输出流的定义，如`cin`和`cout`，用于控制台的输入输出操作。
2. **<stdio.h>**：虽然这个头文件来源于C语言标准库，但在C++中也常用，它提供了传统的输入输出函数，如`printf`和`scanf`。
3. **<string>**：定义了`std::string`类，用于处理字符串操作。
4. **<cstring>**：包含C风格的字符串处理函数，如`strcpy`、`strlen`等。
5. **<vector>**：定义了向量（动态数组）类，支持随机访问和动态大小调整。
6. **<list>**：提供了双向链表的实现。
7. **<map>**：定义了一个关联容器，它存储的是键值对形式的元素。
8. **<queue>**：定义了一个队列容器，支持先进先出的元素管理。
9. **<stack>**：定义了一个栈容器，支持后进先出的元素管理。
10. **<algorithm>**：包含了一系列的算法，如排序和搜索算法。
11. **<math.h>** 或 **<cmath>**：包含数学函数，如`sqrt`、`sin`、`cos`等。
12. **<stdlib.h>**：包含了一些通用工具函数，如`malloc`、`calloc`、`realloc`、`free`等。
13. **<time.h>**：提供了时间和日期处理的函数。
14. **<stddef.h>**：包含了一些标准定义，如`size_t`类型等。

总的来说，在现代C++开发中，为了编写更加C++风格的代码，建议优先使用C++的头文件（如`<iostream>`），而不是C语言的头文件（如`<stdio.h>`）。同时，C++标准库中的许多功能都可以通过`<bits/stdc++.h>`这一头文件来一次性包含，但这种做法在实际开发中并不推荐，因为它会导致编译时间增加，并且代码的可移植性会降低。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2052.Picture 3333


#include <iostream>

using namespace std;

#include<stdio.h>
int n,m;
int main(){
	while(scanf("%d %d",&n,&m)!=EOF){
		for(int i =0;i<=m+1;i++){
			for(int j =0;j<=n+1;j++){
				if((j==0&&i==0)||((j==n+1)&&i==(m+1))||((j==n+1)&&i==0)||((j==0)&&i==(m+1))){
					printf("+");
				}else if(i==0&&(j>0&&j<n+1)||i==m+1&&(j>0&&j<n+1)){
					printf("-");
				}else if(j==0&&(i>0&&i<m+1)||j==n+1&&(i>0&&i<m+1)){
					printf("|");
				}else{
					printf(" ");
				}
			} 
			printf("\n");
		}
		printf("\n");
	}
	return 0;
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

2053.Switch Game 1111

#include <stdio.h>

void SwitchGame(){
	int i,n,count;
	while(scanf("%d",&n)!=EOF){
		count=0;
		for(i=1;i<=n;i++){
			if(n%i==0){
				count++;
			}
		}
		printf("%d\n",count%2);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2054.A == B ? 33333

#include <iostream>
using namespace std;

int main() {
    int A, B;
    while (cin >> A >> B) {
        if (A == B) {
            cout << "YES" << endl;
        } else {
            cout << "NO" << endl;
        }
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2055.An easy problem 3333

#include <stdio.h>
问题描述：
我们定义 f(A) = 1, f(a) = -1, f(B) = 2, f(b) = -2, ... f(Z) = 26, f(z) = -26;
给你一个字母 x 和一个数字 y，你应该输出 y+f(x) 的结果。
输入：
第一行包含一个数字 T。然后是 T 行，每行是一个案例。每个案例包含一个字母和一个数字。
输出：
对于每个案例，你应该在一行中输出 y+f(x) 的结果。
示例输入：
6
R 1
P 2
G 3
r 1
p 2
g 3
示例输出：
19
18
10
-17
-14
-4
=====
void EasyProblem(){
	int x,n,res;
	char y;
	scanf("%d",&n);
	while(n--){
		getchar();
		scanf("%c%d",&y,&x);
		if(y>='A' && y<='Z'){
			res=y-'A'+1;
		}else{
			res='a'-y-1;
		}
		res+=x;
		printf("%d\n",res);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

2056 Rectangles 111111

=== 这4个点。每2个点是从左上到右下的对角线

#include <stdio.h>
问题描述
给定两个矩形和每个矩形对角线上的两个点的坐标，你需要计算两个矩形相交部分的面积。它的边平行于OX和OY。
输入
输入的第一行是8个正数，表示四个必须在每个对角线上的点的坐标。这8个数是x1,y1,x2,y2,x3,y3,x4,y4。也就是说，第一个矩形上的两个点是(x1,y1),(x2,y2)；第二个矩形上的另外两个点是(x3,y3),(x4,y4)。
输出
输出对于每种情况，以单行输出它们的相交部分的面积。精确到小数点后2位。
样例输入
===  这4个点。每2个点是从左下到右上的对角线
1.00 1.00 3.00 3.00 2.00 2.00 4.00 4.00
5.00 5.00 13.00 13.00 4.00 4.00 12.50 12.50
样例输出
1.00
56.25
===
//交换两个数的值 
void swap(double *a,double *b){
	double temp;
	temp=*a;
	*a=*b;
	*b=temp;
}

void Rectangles(){
	double x1,y1,x2,y2,x3,y3,x4,y4;
	double a,b,c,d;
	while(scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&x1,&y1,&x2,&y2,&x3,&y3,&x4,&y4)!=EOF){
		//将矩形的对角线坐标统一转换为左下——右上，便于后面的分情况计算
		if(x1>x2) swap(&x1,&x2);
		if(y1>y2) swap(&y1,&y2);
		if(x3>x4) swap(&x3,&x4);
		if(y3>y4) swap(&y3,&y4);
		//相离
		if(x3>=x2 || y3>=y2 || x4<=x1 || y4<=y1){
			printf("0.00\n");
			continue;
		}
		//包含或相交 
		a=(x1<=x3)?x3:x1;
		b=(x2<=x4)?x2:x4;
		c=(y1<=y3)?y3:y1;
		d=(y2<=y4)?y2:y4;
		printf("%.2lf\n",(b-a)*(d-c));
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

2057.A + B Again 11111

#include <stdio.h>
问题描述
在我们的HDOJ中，一定有许多A + B问题，现在又来了一个。
给你两个十六进制整数，你的任务是计算它们的和，并以十六进制打印出来。
简单吗？AC它！
输入
输入包含多个测试用例，请处理到文件末尾。
每个用例由一行中的两个十六进制整数A和B组成，它们之间用空格分隔。
A和B的长度小于15。
输出
对于每个测试用例，以一行的形式打印出A和B的十六进制和。
样例输入
+A -A
+1A 12
1A -9
-1A -12
1A -AA
样例输出
0
2C
11
-2C
-90
int main(){
	long long a,b;
	while(scanf("%llx%llx",&a,&b)!=EOF){
		printf("%I64X---",a+b);
		//以16进制形式输出 
		if(a+b<0){
			printf("-%llx\n",-(a+b));
		}else{
			printf("%llx\n",a+b);
		}
	}
} 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

2058.The sum problem 3333

#include <stdio.h>
#include <math.h>

//思路1
void SumProblem1(){
	__int64 n,m,i,j,sum;
	while(scanf("%I64d %I64d",&n,&m)!=EOF){
		if(n==0 && m==0){
			break;
		}
		if(n<1 || n>1000000000 || m<1 || m>1000000000){
			printf("n和m的取值范围为[1,1000000000]之间的整数！\n");
			continue;
		}
		for(i=1;i<=n;i++){
			sum=0;
			for(j=i;j<=n;j++){
				sum+=j;
				if(sum==m){
					printf("[%lld,%lld]\n",i,j);
				}
				if(sum>m){
					break;
				}
			}
		}
		printf("\n");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

2059.龟兔赛跑 dp 111

#include <stdio.h>

void Race(){
	/*
		L:赛道长度  
		N:供电站个数 
		C:电动车冲满电以后能行驶的距离  
		T:电动车每次充电所需要的时间
		VR:兔子跑步的速度
		VT1:乌龟开电动车的速度
		VT2:乌龟脚蹬电动车的速度
	*/
	int L,C,T,N,VR,VT1,VT2,i,j;
	//dis[i]表示第i个充电站离跑道起点的距离 
	int dis[102];
	//dp[i]表示乌龟从起点到第i个充电站的最小时间
	double dp[102];
	//假设INF为本程序中的无穷大
	const double INF=0xFFFFFFFF;
	int length;
	double time;
	while(scanf("%d",&L)!=EOF) {
		scanf("%d%d%d",&N,&C,&T);
		scanf("%d%d%d",&VR,&VT1,&VT2);
		if(N<=0 || N>100){
			printf("充电站的个数的取值范围为[1,100]之间的整数！\n");
			continue;
		}
		//输入各个充电站离道起点的距离
		for(i=1;i<=N;i++){
			scanf("%d",&dis[i]);
		}
		//将终点设为第N+1个充电站
		dis[N+1]=L;
		//将起点设为第0个充电站
		dis[0]=0;
		//起点到起点最小耗费时间为0
		dp[0] =0;
		for(i=1;i<=N+1;i++){
			//由于目前到第i个充电站的最小耗费时间未知，所以暂时设置为无穷大 
			dp[i]=INF;
			for(j=0;j<i;j++){
				//从第j个加电站到第i个加电站的距离
				length=dis[i]-dis[j];
				//如果该距离大于电动车冲满电后能行驶的最大距离
				if(length>C){
					//把电动车行驶的时间加上乌龟用脚踏的时间
					time=C*1.0/VT1+(length-C)*1.0/VT2;
				}else{
					//直接加上这段距离除于电动车的速度所得的时间
					time=length*1.0/VT1;
				}
				time+=dp[j];
				if(j>0){
					//j>0表示乌龟不是从起点出发，走完上述的路程后，电动车需要充电 
					time+=T;
				}
				//修改乌龟到第i个充电站的最短时间
				dp[i]=(dp[i]<time)?dp[i]:time;
			}
		}
		//将兔子到达终点的时间与乌龟到达终点的时间进行比较 
		if((L*1.0/VR)>dp[N+1]){
			printf("What a pity rabbit!\n");
		}else{
			printf("Good job,rabbit!\n");
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

2060.Snooker 222

#include <stdio.h>
问题描述：
背景：
菲利普喜欢在想要放松的时候玩QQ游戏斯诺克，尽管他只是一只小菜鸟。也许你还没有玩过这个游戏，没关系，我先为你介绍一下规则。
游戏中有21个目标球，包括15个红球和6个彩球：黄、绿、棕、蓝、粉、黑。
玩家应该使用一个白色的主球来使目标球滚入洞中，他让球进洞的固定值之和就是玩家的得分。玩家首先应该让一个红球进洞，之后他获得红球的分值（1分），然后他有机会击打彩球，交替进行。直到所有红球都进洞后，才能取出彩球。换句话说，如果只剩下彩球在台面上，玩家应该按照这个顺序击打球：黄（2分）、绿（3分）、棕（4分）、蓝（5分）、粉（6分）、黑（7分），球被击入洞后不会再次出现，当台面上没有球时，游戏结束，得分更高的玩家赢得比赛。注意：红球一旦进洞就不会再出来。
我只是说明了可能用到的规则，如果你想了解更多细节，请访问http://sports.tom.com/snooker/。

例如，如果台面上有12个红球（如果还有红球留在台面上，可以确定所有的彩球也一定在台面上）。所以假设Philp可以连续击球进洞，他可以获得的最高分数是
12 * 1（一次击入12个红球）+ 7 * 12（击入一个红球后，最有价值的黑球应该是目标）+ 2 + 3 + 4 + 5 + 6 + 7（没有红球时，让所有彩球进洞）。
现在，你的任务是在告诉你台面上的情况（还剩下多少球没有进洞，以及对手的得分）时，判断Philip是否应该做出放弃的决定。如果Phil仍然有机会赢，就打印"Yes"，否则打印"No"。（注意：如果他在台面上能获得的最高分数加上他当前的得分等于对手的当前得分，仍然输出"Yes"）
输入
第一行包含一个数字N，表示总共有多少种情况。然后是N行，每行由三个整数组成：
Ball_Left P_Score O_Score 表示台面上剩下的球数，Philip的当前得分，以及对手的当前得分。
所有输入值都在32位整数范围内。
输出
你应该计算Philip能获得的最高分数，并判断他是否有可能赢。
样例输入
2
12 1 1
1 30 39
样例输出
Yes
No
===
void Snooker(){
	/*
		Ball_Left:球台上剩余的球数 
		P_Score:Philp当前得分 
		O_Score:对手的得分 
	*/
	int Ball_Left,P_Score,O_Score;
	int n,sum,i; 
	int s[6]={7,6,5,4,3,2};
	//n个案例 
	while(n--){
		scanf("%d%d%d",&Ball_Left,&P_Score,&O_Score);
		if(Ball_Left>6){
			//球台上还有红球，为了获得最多的分数，每一次打进红球后都选择打黑球
			sum=(Ball_Left-6)*8+2+3+4+5+6+7;
		}else{
			//剩余的球均为彩色球
			sum=0;
			for(i=0;i<Ball_Left;i++){
				sum+=s[i];
			}
		}
		if(sum+P_Score>=O_Score){
			printf("Yes\n");
		}else{
			printf("No\n");
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

2061.Treasure the new start, freshmen! 333

#include <stdio.h>
问题描述：
背景：
新的学期开始了，杭州电子科技大学（HDU）也迎来了它的50岁生日。无论你的专业是什么，我想告诉你的唯一一件事是：“珍惜大学生活，抓住时光。”大多数人认为大学生活应该是多彩的，压力较小。但实际上，大学生活也是忙碌而艰苦的。如果你想掌握书本上学到的知识，大量的空闲时间应该用于个人学习和实践，尤其是后者。我认为你们每个人都应该像在高中时一样保持学习态度。“没有付出就没有收获”，HDU也有奖学金，谁能赢得它？这主要取决于学生获得的GPA（绩点平均值）。现在，我要告诉你规则，你的任务是编写程序来计算GPA。
如果有K(K > 0)门课程，第i门课程有学分Ci，你的分数为Si，那么结果GPA为：
GPA = (C1 * S1 + C2 * S2 +……+Ci * Si……) / (C1 + C2 + ……+ Ci……) (1 <= i <= K, Ci != 0)
如果存在0 <= Si < 60，则GPA总是不存在的。

输入：
第一个数字N表示有N个测试用例(N <= 50)。在每个用例中，有一个数字K（总课程数），然后是K行，每一行遵循格式：课程名称（长度<= 30），学分（<= 10），分数（<= 100）。
注意：课程名称中没有空格。所有输入都是合法的。
输出：
按照上述描述输出每个用例的GPA，如果GPA不存在，则输出："Sorry!"，否则只输出四舍五入到小数点后两位的GPA值。两个测试用例之间有一个空行。

样例输入：
2
3
Algorithm 3 97
DataStruct 3 90
softwareProject 4 85
2
Database 4 59
English 4 81

样例输出：
90.10
Sorry!
===
void WeightedAverageScore(){
	int n,k,flag;
	//credit:每门课程的学分
	double creditSum,scoreSum,score,credit;
	char courseName[60];
	scanf("%d",&n);
	if(n<0 || n>50){
		printf("n的取值范围为[0,50]之间的整数！\n");
		return;
	}
	//n个测试用例 
	while(n--){
		//k门课程 
		scanf("%d",&k);
		scoreSum=creditSum=0;
		while(k--){
			scanf("%s",courseName);
			scanf("%lf%lf",&credit,&score);
			if(score<60){
				flag=1;
			}		
			scoreSum+=credit*score;
			creditSum+=credit;
		}
		if(flag){
			printf("Sorry!\n");
		}else{
			printf("%.2lf\n",scoreSum/creditSum);
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

2062.Subset sequence 1111

递推公式

==详细版答案：https://blog.csdn.net/a939682389/article/details/79273354 =
https://blog.csdn.net/qq_46582929/article/details/117753594

问题描述：
考虑集合An = {1, 2, …， n}。例如，A1={1}，A3={1,2,3}。子集序列定义为非空子集的数组。按字典顺序对所有子集序列进行排序。你的任务是找到第m个。

输入：
输入包含几个测试用例。每个测试用例由两个数字n和m组成（0<n<=20，0<m<=An的子集序列总数）。

输出：
对于每个测试用例，你应该在一行中输出An的第m个子集序列。

示例输入：
1 1
2 1
2 2
2 3
2 4
3 10

示例输出：
1
1
1 2
2
2 1
2 3 1
==
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

1


有一个大容器，现在向其中加入若干铅锤的木板,每个木板的顶端坐标记为 (i,yi)，如下图
先输入n，表示有个木板 (1<=n<1000)，接下来输入n个数字表示加入的n个木板的高度，每个高度
用空格隔开，输出该容器最大能装多少体积的水（容器不允许倾斜）
Sample Input
8 1 8 6 4 5 3 7 2
Sample Output
35


                        
原文链接：https://blog.csdn.net/weixin_43004044/article/details/114628329

#include <iostream>
#include <math.h>

using namespace std;

void MaxWater(){
	int n,maxW=0;
	cin>>n;
	int *p = new int[n];
	for(int i=0;i<n;i++){
		cin>>p[i];
	}
	for(int i=0;i<n;i++){
		for(int j=i+1;j<n;j++){
			int temp=min(p[i],p[j])*(j-i);
			maxW=max(temp,maxW);
		}
	}
	cout<<maxW<<endl;
	delete [] p;
} 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

2063.过山车 1111

匈牙利算法

#include <stdio.h>
#include <string.h>

//k:可能匹配数
//m:女生数
//n:男生数
int k,m,n;
//map[i][j]==1:男生i和女生j之间有意愿组成搭档
//boy[i]==j:男生i与女生j已经组成搭档
//girl[i]==j:女生i与男生j已经组成搭档
//partner[i]==1:标记递归过程中暂时被拆散的女生i,使得此轮递归被拆散的男生不能
//再选择这个女生而是选择其他有组成搭档意愿并且没有被标记的女生 
int map[1001][1001],boy[501],girl[501],partner[501];

int find(int x){
	int i;
	//遍历每个女生
	for(i=1;i<=n;i++){
		//一对男女生之间有意愿组成搭档，并且该女生目前还未被标记过 
		if(map[x][i] && partner[i]==0){
			//暂时标记该女生 
			partner[i]=1;
			//girl[i]==-1:女生i目前没有和其他男生组成搭档
			//find(girl[i])==1:已经与女生i组成搭档的男生girl[i]可以与其他的
			//女生组成搭档(即男生girl[i]将女生i"让给"男生x) 
			if(girl[i]==-1 || find(girl[i])){
				boy[x]=i;
				girl[i]=x;
				return 1;
			}
		}
	}
	return 0;
}

void RollerCoaster(){
	//cnt:记录最大匹配数
	int i,j,cnt;
	while(scanf("%d%d%d",&k,&m,&n)==3 && k){
		cnt=0;
		memset(boy,-1,sizeof(boy));//cx数组记录与x匹配的y点
		memset(girl,-1,sizeof(girl));
		memset(map,0,sizeof(map));
		
		//保存输入的组合关系 
		for(i=1;i<=k;i++){
			int a,b;
			scanf("%d%d",&a,&b);
			map[a][b]=1;
		}
		
		//遍历每个男生 
		for(i=1;i<=m;i++){
			//男生i没有搭档 
			if(boy[i]==-1){
				memset(girl,0,sizeof(girl));
				cnt+=find(i);//来找每一条增广路，可使得匹配加1；
			}
		}
		printf("%d\n",cnt);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

2064.汉诺塔 111

Problem Description
约19世纪末，在欧州的商店中出售一种智力玩具，在一块铜板上有三根杆，最左边的杆上自上而下、
由小到大顺序串着由64个圆盘构成的塔。目的是将最左边杆上的盘全部移到右边的杆上，条件是一次
只能移动一个盘，且不允许大盘放在小盘的上面。
现在我们改变游戏的玩法，不允许直接从最左(右)边移到最右(左)边(每次移动一定是移到中间杆或
从中间移出)，也不允许大盘放到小盘的上面。
Daisy已经做过原来的汉诺塔问题和汉诺塔II，但碰到这个问题时，她想了很久都不能解决，现在请
你帮助她。现在有N个圆盘，她至少多少次移动才能把这些圆盘从最左边移到最右边？
 
Input
包含多组数据，每次输入一个N值(1<=N=35)。
 
Output
对于每组数据，输出移动最小的次数。
 
Sample Input
1
3
12
 
Sample Output
2
26
531440
=====
正确思路：
//设n个盒子从a到c柱移动需要f(n)步，那么
//n-1个先a->c需要，f(n-1)步；
//然后第n个从a->b，1步；
//再是n-1个从c->a,f(n-1)步;
//然后是第n个从b->c,1步；
//最后就是将n-1个从a-c,f(n-1)步；
//将上述加起来得递归公式： f(n) = 3*f(n-1)+2

#include <stdio.h>
void Hanoi3(){
	//hanoi[i]表示i个圆盘从最左边移到最右边至少需要的次数 
	__int64 hanoi[36]={0,2};
	int i,n;
	for(i=2;i<=35;i++){
		hanoi[i]=3*hanoi[i-1]+2;	
	}
	while(scanf("%d",&n)!=EOF){
		if(n<=0 || n>35){
			printf("圆盘个数的取值范围为[1,35]之间的整数！\n");
			continue;
		}
		printf("%I64d\n",hanoi[n]);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

2065."红色病毒"问题 333

递归，推式子

#include <stdio.h>
Problem Description
医学界发现的新病毒因其蔓延速度和Internet上传播的"红色病毒"不相上下,被称为"红色病毒",经
研究发现,该病毒及其变种的DNA的一条单链中,胞嘧啶,腺嘧啶均是成对出现的。
现在有一长度为N的字符串,满足一下条件:
(1) 字符串仅由A,B,C,D四个字母组成;
(2) A出现偶数次(也可以不出现);
(3) C出现偶数次(也可以不出现);
计算满足条件的字符串个数.
当N=2时,所有满足条件的字符串有如下6个:BB,BD,DB,DD,AA,CC.
由于这个数据肯能非常庞大,你只要给出最后两位数字即可.
 
Input
每组输入的第一行是一个整数T,表示测试实例的个数,下面是T行数据,每行一个整数N(1<=N<2^64),当T=0时结束.
 
Output
对于每个测试实例,输出字符串个数的最后两位,每组输出后跟一个空行.
 
Sample Input
4
1
4
20
11
3
14
24
6
0
 
Sample Output
Case 1: 2
Case 2: 72
Case 3: 32
Case 4: 0

Case 1: 56
Case 2: 72
Case 3: 56
=====
//二分求幂
int power(int a, long long n){
    if(n==0){
    	return 1;
	} 
    int res = 1;
    while(n){
        if(n & 1){
        	res=(res*a)%100;
		}   
        a*=a;//a的基从2变到4
        a%=100;
        //右移一位比直接除以二更高效
        n>>=1;
    }
    return res;
}

void RedVirus(){
    int t,i;
    long long n;
    while(scanf("%d",&t)!=EOF && t){
        i=1;
        while(t--){
            scanf("%lld",&n);
            printf("Case %d: %d\n",i++,(power(4,n-1)+power(2,n-1))%100);
        }
        printf("\n");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

2066.一个人的旅行 111

最短路径：https://blog.csdn.net/better_space/article/details/52135755

https://blog.csdn.net/better_space/article/details/52135755
Problem Description
虽然草儿是个路痴（就是在杭电待了一年多，居然还会在校园里迷路的人，汗~),但是草儿仍然很喜
欢旅行，因为在旅途中 会遇见很多人（白马王子，^0^），很多事，还能丰富自己的阅历，还可以看
美丽的风景……草儿想去很多地方，她想要去东京铁塔看夜景，去威尼斯看电影，去阳明山上看海芋，
去纽约纯粹看雪景，去巴黎喝咖啡写信，去北京探望孟姜女……眼看寒假就快到了，这么一大段时间，
可不能浪费啊，一定要给自己好好的放个假，可是也不能荒废了训练啊，所以草儿决定在要在最短的
时间去一个自己想去的地方！因为草儿的家在一个小镇上，没有火车经过，所以她只能去邻近的城市

坐火车（好可怜啊~）。
 
Input
输入数据有多组，每组的第一行是三个整数T，S和D，表示有T条路，和草儿家相邻的城市的有S个，
草儿想去的地方有D个；
接着有T行，每行有三个整数a，b，time,表示a,b城市之间的车程是time小时；(1=<(a,b)
<=1000;a,b 之间可能有多条路)
接着的第T+1行有S个数，表示和草儿家相连的城市；
接着的第T+2行有D个数，表示草儿想去地方。
 
Output
输出草儿能去某个喜欢的城市的最短时间。
 
Sample Input
6 2 3
1 3 5
1 4 7
2 8 12
3 8 4
4 9 12
9 10 2
1 2
8 9 10
 
Sample Output
9
======
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#define INF 0x7FFFFFFF
using namespace std;
const int N = 1111;
int map[N][N],dis[N],vis[N],mud[N];//map是地图，dis是原点到其他点的最短距离，vis代表当前点是否访问
int maxn;
void dijkstra() {
	memset(vis,0,sizeof(vis));
	for(int i=0; i<=maxn; i++) {
		dis[i]=INF;
	}
	dis[0]=0;
	for(int i=0; i<=maxn; i++) {
		int tp=INF,k;
		for(int j=0; j<=maxn; j++) {
			if(!vis[j]&&tp>dis[j]) {
				tp=dis[j];
				k=j;
			}
		}
		//printf("%d--\n",dis[k]);
		vis[k]=1;
		for(int l=0; l<=maxn; l++) {
			if(!vis[l]&&dis[l]>dis[k]+map[k][l])
				dis[l]=dis[k]+map[k][l];
		}
	}
}
int main() {
	int T,S,D,ans;
	while(scanf("%d%d%d",&T,&S,&D)!=EOF) {
		for(int i=0; i<=N; i++)
			for(int j=1; j<=N; j++) {
				map[i][j]=i==j?0:INF;
			}
		int a,b,c,t;
		maxn=0;
		for(int i=0; i<T; i++) {
			scanf("%d%d%d",&a,&b,&c);
			int temp=max（a，b）；
			maxn=max(maxn,temp);
			if(map[a][b]>c)
				map[a][b]=map[b][a]=c;
		}
		//	printf("%d===\n",maxn);
		for(int i=0; i<S; i++) {
			scanf("%d",&t);
			map[0][t]=map[t][0]=0;
		}
		dijkstra();
		ans=INF;
		for(int i=0; i<D; i++) {
			scanf("%d",&t);
			ans=min(dis[t],ans);
		}
		printf("%d\n",ans);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

正确解法：

#include <stdio.h>
#include <string.h>
#define N 1100

int map[N][N],d[N],n,lovenum[N];
void shortdjstl(int v0){
    int min,i,v,w,visited[N];
    memset(visited,0,sizeof(visited));
    for(v=0;v<=n;v++)
        d[v]=map[v0][v];//这里先初始化距离，是因为直接从0开始了，0本图的点属于，而董老师是从哨兵0开始，哨兵不属于点，更新的是在==这里更新距离的
    d[v0]=0;//v0等于0
    visited[v0]=1;//出圈了
    for(i=1;i<=n;i++){
        min=0x7FFFFFFF;
        for(w=0;w<=n;w++)
            if(visited[w]==0&&d[w]<min)
            {
                v=w;
                min=d[w];
            }
        visited[v]=1;//出圈了
        for(w=0;w<=n;w++)================
            if(visited[w]==0&&d[v]<d[w]-map[v][w])
                d[w]=min+map[v][w];
    }
}

int main(){
	int i,j,s,t,destination,a,b,time,num,min;
    while(scanf("%d %d %d",&s,&t,&destination)!=EOF){
        for(i=0;i<=N;i++)
            for(j=0;j<=N;j++)
            {
                 if(i==j) map[i][j]=0;
			     else map[i][j]=map[j][i]=0x7FFFFFFF;
            }
        for(i=1,n=0;i<=s;i++){
            scanf("%d %d %d",&a,&b,&time);
            int temp=max（a，b）；
			n=max(maxn,temp);
            if(time<map[a][b]) map[a][b]=map[b][a]=time;
        }
        for(i=1;i<=t;i++){
            scanf("%d",&num);
            map[0][num]=map[num][0]=0;
        }
        for(i=1;i<=destination;i++)
            scanf("%d",&lovenum[i]);
        shortdjstl(0);
        for(i=1,min=0x7FFFFFFF;i<=destination;i++)
            if(d[lovenum[i]]<min) 
                min=d[lovenum[i]];
        printf("%d\n",min);
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

2067.小兔的棋盘 222

卡特兰数

#include <stdio.h>

__int64 Combination(int n,int m){
	int i;
	__int64 res1=1,res2=1;
	for(i=1;i<=m;i++){
		res1*=(n-i+1);
		res2*=i;
	}
	return res1/res2;
}

void Chessboard(){
	__int64 Catalan[36]={0};
	int i,n,index=1;
	for(i=1;i<=35;i++){
		Catalan[i]=Combination(2*i,i)-Combination(2*i,i-1);
	}
	while(scanf("%d",&n)!=EOF){
		if(n==-1){
			break;
		}
		if(n<=0 || n>=36){
			printf("coin的取值范围为[1,35]之间的整数！\n");
			continue;
		}	
		printf("%d %d %I64d\n",index++,n,Catalan[n]*2);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

2068.RPG的错排 111

https://blog.csdn.net/qq_39880604/article/details/104843955

#include <stdio.h>
Problem Description
今年暑假杭电ACM集训队第一次组成女生队,其中有一队叫RPG,但做为集训队成员之一的野骆驼竟然不知道RPG三个人具体是谁谁。RPG给他机会让他猜猜，第一次猜：R是公主，P是草儿，G是月野兔；第二次猜：R是草儿，P是月野兔，G是公主；第三次猜：R是草儿，P是公主，G是月野兔；…可怜的野骆驼第六次终于把RPG分清楚了。由于RPG的带动，做ACM的女生越来越多，我们的野骆驼想都知道她们，可现在有N多人，他要猜的次数可就多了，为了不为难野骆驼，女生们只要求他答对一半或以上就算过关，请问有多少组答案能使他顺利过关。

Input
输入的数据里有多个case,每个case包括一个n，代表有几个女生，（n<=25）, n = 0输入结束。

Output
对应每个case能顺利过关的组数。

解题思路
本题是有关“完全错排”和“部分错排”的题目，“完全错排”在之前的2048题已经讲解过了。而“部分错排”也是利用了“完全错排”的思想，比如“求5个人中3个人错排的情况数”，每个人选对自己的情况只有一种，所以5个人选对2个人的情况有C 5 2 C_5^2C 
5
2

 种，所以原问题就相当于“C 5 2 × C_5^2\timesC 
5
2

 ×求3个人‘完全错排’的情况数”。回归到本题，把满足“答对一半或以上”的情况数累加起来就得到了最后能顺利过关的组数。

//组合数公式，C(n,m)=P(n,m)/m!=n!/((n-m!)*m!) 
__int64 Combination(int n,int m){
	int i;
	__int64 res1=1,res2=1;
	for(i=1;i<=m;i++){
		res1*=(n-i+1);
		res2*=i;
	}
	return res1/res2;
}

void RGP(){
	//girl[i]表示i个女生的错排总数 
	__int64 girl[26]={0,0,1};
	__int64 sum;
	int i,n;
	for(i=3;i<=25;i++){
		//错排公式
		girl[i]=(i-1)*(girl[i-1]+girl[i-2]);
	}
	while(scanf("%d",&n)!=EOF && n){
		if(n<0 || n>25){
			printf("n的取值范围为[1,25]之间的整数！\n");
			continue;
		}
		if(n==1 || n==2 || n==3){
			printf("1");
			continue;
		}
		sum=0;
		for(i=n/2;i>=1;i--){
			sum+=Combination(n,i)*girl[i];
		}
		//加上原本序列的一种
		printf("%I64d\n",sum+1);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

2069.Coin Change 111

完全背包：动态规划

动态规划：https://www.bilibili.com/video/BV1e64y1P7MQ/?spm_id_from=333.337.search-card.all.click&vd_source=401678fc4d2670e6377f413dcd59e784

#include <stdio.h>
问题描述：假设有5种硬币：50分，25分，10分，5分和1分。我们想要用这些硬币为给定的金额找零。
例如，如果我们有11分，那么我们可以用一个10分硬币和一个1分硬币，或者两个5分硬币和一个1分硬币，或者一个5分硬币和六个1分硬币，或者十一个1分硬币来找零。所以，对于11分，有四种找零的方法。注意，我们认为有一种方法可以找零零分。

编写一个程序来找到用上述硬币为任意金额的钱找零的不同方式的总数。您的程序应该能够处理高达100分的情况。

输入：输入文件包含任意数量的行，每行包含一个数字（≤250），表示钱的金额（以分为单位）。

输出：对于每个输入行，输出一行，包含使用上述5种硬币进行找零的不同方式的数量。

示例输入：11
26

示例输出：4
13


void CoinChange(){
	int coin,cnt;
	int i,j,k,l,m;
	while(scanf("%d",&coin)!=EOF){
		if(coin<0 || coin>250){
			printf("coin的取值范围为[0,250]之间的整数！\n");
			continue;
		}
		if(coin==0){
			printf("1\n");
			continue;
		}
		cnt=0;
		#include<bits/stdc++.h>
using namespace std;

int slove() {
	int ans = 0;
	// 10 元张数
	for(int i = 0; i <= 10; i++) {
		// 5 元张数
		for(int j = 0; j <= 20; j++) {
			// 1 元张数
			for(int k = 0; k <= 100; k++) {
				int cur = i*10 + j*5 + k*1;
				if(cur == 100) {
					ans++;
				}
			}
		}
	}
	return ans;
}

int main()
{
	cout<<slove();
}

		printf("%d\n",cnt);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

2070.Fibbonacci Number 333

#include <stdio.h>

void Fibbonacci(){
	__int64 fib[51]={0,1};
	int i,n;
	for(i=2;i<=50;i++){
		fib[i]=fib[i-1]+fib[i-2];
	}
	while(scanf("%d",&n)!=EOF && n!=-1){
		if(n>=0 && n<=50){
			printf("%I64d\n",fib[n]);
		}	
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2071.Max Num 3333

#include <stdio.h>

void MaxNum(){
	int t,n;
	double max,h;
	while(scanf("%d",&t)!=EOF){
		//t个案例 
		while(t--){
			scanf("%d",&n);
			max=0;
			//n个学生的身高 
			while(n--){
				scanf("%lf",&h);
				if(h>max){
					max=h;
				}
			}	
			printf("%.2lf\n",max);	
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2072.单词数 1111

#include <stdio.h>
#include <string.h>
Problem Description
lily的好朋友xiaoou333最近很空，他想了一件没有什么意义的事情，就是统计一篇文章里不同单词的总数。下面你的任务是帮助xiaoou333解决这个问题。

Input
有多组数据，每组一行，每组就是一篇小文章。每篇小文章都是由小写字母和空格组成，没有标点符号，遇到#时表示输入结束。

Output
每组只输出一个整数，其单独成行，该整数代表一篇文章里不同单词的总数。

Sample Input
you are my friend
#

Sample Output
4
===
#include <set>
#include <cstdio>
#include <string>
#include <iostream>

using namespace std;

int main(void)
{
    set <string> st;
    
    char c;

    while ((c = getchar()) &&c!= '#')
    {   string s = "";
        s += c;
        while (c != '\n')
        {
            while ((c = getchar()) != ' ' && c != '\n')
                s += c;
            if (s.length()) st.insert(s);
            s = "";
        }
        cout << st.size() << endl;
        st.clear();
    }

    return 0;
}
			
			
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

2073.无限的路 111

#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;

double dis(int, int);			// 从起点到参数点所走的距离
==
Problem Description
甜甜从小就喜欢画图画，最近他买了一支智能画笔，由于刚刚接触，所以甜甜只会用它来画直线，于是他就在平面直角坐标系中画出如下的图形：

甜甜的好朋友蜜蜜发现上面的图还是有点规则的，于是他问甜甜：在你画的图中，我给你两个点，请你算一算连接两点的折线长度（即沿折线走的路线长度）吧。

Input
第一个数是正整数N（≤100）。代表数据的组数。
每组数据由四个非负整数组成x1，y1，x2，y2；所有的数都不会大于100。

Output
对于每组数据，输出两点(x1,y1),(x2,y2)之间的折线距离。注意输出结果精确到小数点后3位。

Sample Input
5
0 0 0 1
0 0 1 0
2 3 3 1
99 99 9 9
5 5 5 5

Sample Output
1.000
2.414
10.646
54985.047
0.000
==
int main()
{
	int N, i, x1, y1, x2, y2;
	double res_temp1, res_temp2, res;
	cin >> N;
	for (i = 0; i < N; i++) {
		cin >> x1 >> y1 >> x2 >> y2;
		res_temp1 = dis(x1, y1);
		res_temp2 = dis(x2, y2);
		res = abs(res_temp1 - res_temp2);
		cout << setiosflags(ios::fixed) << setprecision(3) << res << endl;
	}
	return 0;
}

double dis(int a, int b)
{
	// 记录模拟路线的坐标
	int x, y;
	// 记录每次从左上坐标到右下坐标所走“根号2”的个数
	int count = 0;
	double res;
	// 初始化模拟路线的坐标，从原点开始
	x = y = 0;
	// 模拟路线的点与参数点重合，结算距离
	if (a == x && b == y) {
		res = 0;
	}
	else {
		// 从原点走到（0， 1）
		y++;
		// 模拟路线的点与参数点重合，结算距离
		if (a == x && b == y) {
			res = 1;
		}
		else {
			res = 1;
			while (!x) {
				// 从左上坐标到右下坐标每次横坐标加1，纵坐标减1
				// 所以每次走的路程是一个“根号2”
				while (y != 0) {
					count++;
					x++;
					y--;
					// 每次坐标改变都要检查模拟路线的点是否与参数点重合
					if (a == x && b == y) {
						break;
					}
				}
				// 走到纵坐标为0时结算此过程走了几个“根号2”
				res += count * sqrt(2.0);
				// 把计数器清零
				count = 0;
				// 每次坐标改变都要检查模拟路线的点是否与参数点重合
				if (a == x && b == y) {
					break;
				}
				else {
					// 再从右下坐标走到下一个左上坐标
					res += sqrt(pow(x, 2.0) + pow(x + 1, 2.0));
					y = x + 1;
					x = 0;
					// 检查模拟路线的点是否与参数点重合
					if (a == x && b == y) {
						break;
					}
				}
			}
		}
	}
	return res;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

2074.叠筐 111

#include <stdio.h>
Problem Description
需要的时候，就把一个个大小差一圈的筐叠上去，使得从上往下看时，边筐花色交错。这个工作现在要让计算机来完成，得看你的了。
 
Input
输入是一个个的三元组，分别是，外筐尺寸n（n为满足0<n<80的奇整数），中心花色字符，外筐花色字符，后二者都为ASCII可见字符；
 
Output
输出叠在一起的筐图案，中心花色与外筐花色字符从内层起交错相叠，多筐相叠时，最外筐的角总是被打磨掉。叠筐与叠筐之间应有一行间隔。
 
Sample Input
11 B A
5 @ W
 
Sample Output
 AAAAAAAAA 
ABBBBBBBBBA
ABAAAAAAABA
ABABBBBBABA
ABABAAABABA
ABABA-B-ABABA
ABABAAABABA
ABABBBBBABA
ABAAAAAAABA
ABBBBBBBBBA
 AAAAAAAAA 

 @@@ 
@WWW@
@W@W@
@WWW@
 @@@ 

void FoldingBasket(){
	char pic[100][100];
	int n,i,center,j,count=0;
    char in,out;
    while(scanf("%d",&n)!=EOF){
        getchar();
        in=getchar();
        getchar();
        out=getchar();
        if(count>0) printf("\n");
        i=1;
        center=(n+1)/2;
        pic[center][center]=in;//中心;
        while(center>=i+1){
            int p=center-i,q=center+i;//顶点;
            for(j=0;j<2*i+1;j++){
            	pic[p][p+j]=i&1?out:in;//右;
                pic[p+j][p]=i&1?out:in;//下;
                pic[q][q-j]=i&1?out:in;//左;
                pic[q-j][q]=i&1?out:in;//上;
            }
            i++;
        }
        //四个角用空格代替 
        if(n!=1){
        	pic[1][1]=' ',pic[1][n]=' ',pic[n][1]=' ',pic[n][n]=' ';
        }      
        for(i=1;i<=n;i++){
            for(j=1;j<=n;j++){
            	 printf("%c",pic[i][j]);
            }
            printf("\n");
        }
        count++;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

2076.夹角有多大 333

Problem Description
时间过的好快，一个学期就这么的过去了，xhd在傻傻的看着表，出于对数据的渴望，突然他想知道这个表的时针和分针的夹角是多少。现在xhd知道的只有时间，请你帮他算出这个夹角。

注：夹角的范围[0，180]，时针和分针的转动是连续而不是离散的。

Input
输入数据的第一行是一个数据T，表示有T组数据。
每组数据有三个整数h(0 <= h < 24)，m(0 <= m < 60)，s(0 <= s < 60)分别表示时、分、秒。
 
Output
对于每组输入数据，输出夹角的大小的整数部分。
 
Sample Input
2
8 3 17
5 13 30
 
Sample Output
138
75
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2077.汉诺塔 111

#include <stdio.h>

void Hanoi4(){
	//hanio[i]:将i个盘子移动到相邻杆子最少需要的次数 
	__int64 hanoi[21]={0,1};
	int i,T,n;
	for(i=2;i<=20;i++){
		hanoi[i]=hanoi[i-1]*3+1;
	}
	//有T组数据 
	scanf("%d",&T);
	while(T--){
		scanf("%d",&n);
		if(n<1 || n>20){
			printf("n的取值范围为[1,20]之间的整数!\n");
			continue;
		}
		printf("%I64d\n",2*hanoi[n-1]+2);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2078.复习时间 333

#include <stdio.h>

void review(){
	int T,n,m,a,efficiency;
	scanf("%d",&T);
	//有T组数据 
	while(T--){
		//这学期选了n门课，但是一晚上最多只能复习m门课
		scanf("%d%d",&n,&m);
		efficiency=100;
		while(n--){
			//a表示这门课的难度值 
			scanf("%d",&a);
			if(efficiency>a){
				efficiency=a;
			}
		}
		printf("%d\n",(100-efficiency)*(100-efficiency));
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2079.选课时间 111

https://blog.csdn.net/ding_hai_long/article/details/20119497

#include <cstdio>
#include <iostream>
#include <cstring>
 
using namespace std;
 
int cnt[10];  // cnt[i] 表示学分为i的课的数量 
int ans, score;
 
void DFS(int sum, int cur)
{
    if(sum == score)
    {
        ++ans;
        return;
    }
    if(sum > score || cur > 8)//学分最多是 8 分 
        return;
    for(int i = 0; i <= cnt[cur]; ++i)
        DFS(sum+cur*i, cur+1);
}
 
int main()
{
    int T, k, a, b;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &score, &k);
        memset(cnt, 0, sizeof(cnt));
        ans = 0; 
        for(int i = 0; i < k; ++i)
        {
            scanf("%d%d", &a, &b);
            cnt[a] = b; 
        } 
        DFS(0, 0); 
        printf("%d\n", ans);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

2080.夹角有多大II 333

#include <stdio.h>
#include <math.h>

void IncludedAngle(){
	int T;
	double x1,y1,x2,y2;
	double res;
	scanf("%d",&T);
	//有T组数据 
	while(T--){
		scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
		//利用向量的夹角公式，并且用acos(-1)代替π 
		res=(x1*x2+y1*y2)/(sqrt(x1*x1+y1*y1)*sqrt(x2*x2+y2*y2));
		printf("%.2lf\n", acos(res)*180/acos(-1));
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2081.手机短号 333

#include <stdio.h>

void Cornet(){
	int N,i;
	char number[11]; 
	scanf("%d",&N);
	//有N个数据 
	while(N){
		getchar();
		scanf("%s",number);
		printf("6");
		for(i=6;i<=10;i++){
			printf("%c",number[i]);
		}
		printf("\n");
		N--;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2082.找单词 333

dp问题

#include <stdio.h>

void FindWords(){
	int N,count;
	int i,j,k; 
	//dp[i][j]表示使用前i个字母进行组合时(A算作第一个字母、B算作第2个，以此类推)时， 可以找到的价值<=j的单词数量 
	int dp[30][60];
	//保存x1...x26，即x[i]=xi 
	int x[30];
	scanf("%d",&N);
	//有N个实例 
	while(N--){
		memset(x,0,sizeof(x));
        memset(dp,0,sizeof(dp));
        dp[0][0]=1;
        for(i=1;i<=26;i++){
        	scanf("%d",&x[i]);
        	dp[i][0]=1;
        }
        //count用来记录单词数
        count=0;
        for(i=1;i<=26;i++){
        	for(j=1;j<=50;j++){
        		for(k=0;k<=x[i];k++){
        			if(j-i*k>=0){
        				dp[i][j]+=dp[i-1][j-i*k];
        			}
        		}
        		if(i==26){
        			count+=dp[i][j];
        		}
        	}
        }
        printf("%d\n",count);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

2083.简易版之最短距离 111

#include<stdio.h>
#include<math.h>
int a[520];
int main() {
    int T;
    scanf("%d",&T);
    while(T--) {
        int n;
        scanf("%d",&n);
        for(int i=0; i<n; i++)
            scanf("%d",&a[i]);
        int res=99999999;
        for(int i=0; i<n; i++) {
            int sum=0;
            for(int j=0; j<n; j++)
                sum+=abs(a[j]-a[i]);
            if(res>sum)
                res=sum;
        }
        printf("%d\n",res);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2084.数塔 11

https://www.bilibili.com/video/BV1Rk4y1173p/?spm_id_from=333.999.0.0&vd_source=401678fc4d2670e6377f413dcd59e784
import java.util.Scanner;
 
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();
		while (t-- > 0) {
			int n = sc.nextInt();// 层数
			int[][] arr = new int[n + 2][n + 2];
			for (int i = 1; i <= n; i++) {
				for (int j = 1; j <= i; j++) {
					arr[i][j] = sc.nextInt();
				}
			}
			for (int i = n; i >= 1; i--) {// 行
				for (int j = 1; j <= i; j++) {// 每行的元素
					arr[i][j] += Math.max(arr[i + 1][j], arr[i + 1][j + 1]);
				}
			}
			System.out.println(arr[1][1]);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2085.核反应堆 333

#include <stdio.h>

void NuclearReactor(){
	int n,i;
	__int64 high,low,temp;
	while(scanf("%d",&n)!=EOF && n!=(-1) && (n>=0 && n<=33)){
		//0微妙时，只有一个高能质子 
		high=1;
		low=0;
		for(i=1;i<=n;i++){
			temp=high;
			high=3*high+2*low;
			low+=temp;
		}
		printf("%I64d, %I64d\n",high,low);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2086.A1 = ? 111

#include <iostream>
#include <cstdio>
using namespace std;
 
int main()
{
	int n;
	double Ao, An;
	double num[3005];
	while(scanf("%d", &n) != EOF)
	{
		scanf("%lf%lf", &Ao, &An);
		for(int i = 1; i <= n; i++)
			scanf("%lf", &num[i]);
		double ans = double(n) / double(n + 1) * Ao + 1.0 / (n + 1) * An;
		double k = double(n) * 2.0;
		for(int j = 1; j <= n; j++)
		{
			ans -= k / (n + 1) * num[j];
			k -= 2.0;
		}
		printf("%.2lf\n", ans);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2087.剪花布条

2088.Box of Bricks 333

#include <stdio.h>

void BoxofBricks(){
	//n:栈的个数
	int n,sum,bricks[101]={0},count;
	int i;
	while(scanf("%d",&n)!=EOF && n){
		sum=0;
		for(i=0;i<n;i++){
			scanf("%d",&bricks[i]);
			sum+=bricks[i];
		}
		count=0;
		sum/=n;
		for(i=0;i<n;i++){
			if(sum>bricks[i]){
				count+=(sum-bricks[i]);
			}
		}
		printf("%d\n",count);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2089.不要62 2222

#include <stdio.h>

//判断是否为不吉利数字，若是则返回1，否则返回0 
int Check(int n){
	int temp;
	while(n){
		temp=n%10;
		if(temp%10==4){
			return 1;
		}else if(temp==2 && (n%100)/10==6){
			return 1;
		}
		n/=10;
	}
	return 0;
}

void No62(){
	int n,m,i,count;
	while(scanf("%d %d",&n,&m)!=EOF){
		if(n==0 && m==0){
			break;
		}
		count=0;
		for(i=n;i<=m;i++){
			if(Check(i)==0){
				count++;
			}
		}
		printf("%d\n",count);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

2090.算菜价 333

#include <stdio.h>

void Price(){
	char name[10];
	double p,n;
	double res=0;
	while(scanf("%s%lf%lf",name,&p,&n)!=EOF){
		//总价=单价*数量 
		res+=p*n;
	}
	printf("%.1lf\n",res);
}

1
2
3
4
5
6
7
8
9
10
11
12
13

2091.空心三角形 222

#include <stdio.h>

int main(){
	char c;
	int n,i,j;
	while(scanf("%c%d",&c,&n)!=EOF && c!='@'){
		if(n<=0 || n>=41){
			printf("n的取值范围为(0,41)之间的整数！\n");
			continue;
		}
		for(i=1;i<=n;i++){ 
			//打印第一层
			if(i==1){
				for(j=1;j<=n-1;j++){
					printf(" ");
				}
				printf("%c\n",c);
				continue;
			}		
			//打印最后一层
			if(i==n){
				for(j=1;j<=2*n-1;j++){
					printf("%c",c);
				}
				printf("\n");
				continue;
			}
			//打印中间层
			for(j=1;j<=n-i;j++){
				printf(" ");
			}
			printf("%c",c);
			for(j=1;j<=2*i-3;j++){
				printf(" ");
			}
			printf("%c\n",c);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

2092.整数解 2222

#include <stdio.h>
#include <math.h>

void IntegerSolution(){
	int n,m;
	double x;
	while(scanf("%d%d",&n,&m)!=EOF){
		if(n==0 && m==0){
			break;
		}
		x=((double)n+(double)sqrt((double)(n*n-4*m)))/2;
		if(x==(int)x){
			printf("Yes\n");
		}else{
			printf("No\n");
		}
	}
}

法2：枚举
#include <stdio.h>

void IntegerSolution(){
    int n, m;
    while(scanf("%d%d", &n, &m) != EOF){
        if(n == 0 && m == 0){
            break;
        }
        int found = 0; // 标记是否找到符合条件的整数对
        for(int x = -9999; x < 10000; x++){ // 遍历所有可能的 x
            for(int y = -9999; y < 10000; y++){ // 遍历所有可能的 y
                if(x + y == n && x * y == m){ // 检查是否满足条件
                    found = 1; // 找到符合条件的整数对
                    break;
                }
            }
            if(found){ // 如果找到符合条件的整数对，则结束循环
                break;
            }
        }
        if(found){ // 输出结果
            printf("Yes\n");
        }else{
            printf("No\n");
        }
    }
}

int main(){
    IntegerSolution();
    return 0;
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

2093.考试排名111

#include <stdio.h>
#include <string.h>
#include <cstdlib>
// 学生结构体       结构体比较
typedef struct Student {
    char name[11];  // 学生姓名
    int solved;     // 做出的题数
    int time;       // AC所耗时间
    int penalty;    // 错误提交次数
}Student;

// 比较函数：按照排名规则比较两个学生
int compare(const void *a, const void *b) {
     Student *student1 = (Student *)a;
     Student *student2 = (Student *)b;
    
    // 按照题数多少降序排列
    if (student1->solved != student2->solved) {
        return student2->solved - student1->solved;
    }
    
    // 题数相同时，按照时间少的升序排列
    if (student1->time != student2->time) {
        return student1->time - student2->time;
    }
    
    // 题数和时间都相同时，按照名字的字典序升序排列
    return    strcmp(student1->name, student2->name);
}

int main() {
    int n, m; // 题数和单位罚分数
    scanf("%d %d", &n, &m);
    
    // 定义学生数组
    struct Student students[100];
    
    // 输入每个学生的答题情况
    for (int i = 0; i < 100; i++) {
        // 读取学生姓名
        scanf("%s", students[i].name);
        
        // 初始化学生答题情况
        students[i].solved = 0;
        students[i].time = 0;
        students[i].penalty = 0;
        
        // 读取学生答题详情
        for (int j = 0; j < n; j++) {
            int val;
            scanf("%d", &val);
            
            // 判断是否为AC或错误提交
            if (val > 0) {
                students[i].solved++; // 题数加一
                students[i].time += val; // 累加AC所耗时间
            } else if (getchar()=='(') {
                scanf("%d",&val);
				getchar();
                students[i].penalty++; // 错误提交次数加一
                students[i].time += m*val; // 累加错误提交的罚分
            }
        }
    }
    
    // 对学生数组按照排名规则进行排序
    qsort(students, 100, sizeof(Student), compare);
    
    // 输出排名
    for (int i = 0; i < 100; i++) {
        if (students[i].solved > 0) {
            printf("%-10s %2d %4d\n", students[i].name, students[i].solved, students[i].time);
        }
    }
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

2094.产生冠军 111

最近很喜欢用map
把成功者、失败者都存起来
然后在成功者里把曾经失败的划掉
最后成功者里如果只剩一个人，冠军产生，否则不产生
#include <iostream>
#include <string>
#include <map>
using namespace std;

int main()
{
    map<string,bool> m1;
    string lose[1000];
    int n;
    while(cin>>n && n)
    {
        m1.erase(m1.begin(), m1.end());

        string a;
        for(int i=0; i<n; i++)
        {
            cin>>a>>lose[i];
            m1[a]=true;
        }
        for(int i=0; i<n; i++)
        {
            if(m1.find(lose[i])!=m1.end())
            {
                m1.erase(lose[i]);
            }
        }
        if(m1.size()==1)
        {
            cout<<"Yes"<<endl;
        }
        else
        {
            cout<<"No"<<endl;
        }
    }
    return 0;
}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

2095.find your present (2) 222


分析：本题实质是找出只出现一次的数。又由于异或具有以下性质：
（1）任何数和0异或为其本身
（2）相同的数异或，其结果为0
（3）异或满足交换律
所以根据以上的性质，可以得出，若在一组数中，除了某个数只出现一次，其余的数均出现了不为0的偶数次。那么这些数异或之后的结果就是那个只出现了1次的数。根据这个规律编写代码即可

#include <stdio.h>

void Present(){
	int n,a,b;
	while(scanf("%d",&n)!=EOF && n){
		//有n个数 
		a=0;
		while(n--){
			scanf("%d",&b);
			//任何数和0异或为其本身，相同的数异或为0，且异或满足交换律 
			a^=b;
		}
		printf("%d\n",a);
	}
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2096.小明A+B 333

#include <stdio.h>

void AAddB(){
	int T,A,B;
	scanf("%d",&T);
	//有T组数据
	while(T--){
		scanf("%d%d",&A,&B);
		if(A<0 || B<0){
			printf("输入的数应为非负整数！\n");
			continue;
		}
		A%=100;
		B%=100;
		printf("%d\n",(A+B)%100);
	} 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2097.Sky数 222

进制转换

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<fstream>
using namespace std;
int main(){
    int n;
    char s[100];
    while(cin>>n){
        int cnt=0;
        do{
            s[cnt++]=n%8+'0';
            n/=8;
        }while(n);
        for(int i=cnt-1;i>=0;i--)
            cout<<s[i];
        cout<<endl;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include <stdio.h>

int ScaleConvertSum(int n,int r){
	//n表示要被转换的数，r表示要转换成的进制数 
	int i,temp,sum=0;
	if(r<2 || r>16) {
		printf("r的取值范围为[2,16]之间的整数！\n");
	}
	i=0;  
	while(n>0){
		temp=n%r;
		sum+=temp;
		i++;
		n/=r;
	}
	return sum;
}

void Sky(){
	int n;
	while(scanf("%d",&n)!=EOF && n){
		if(n<0){
			printf("请输入非负整数！\n");
			continue;
		}
		if(ScaleConvert(n,10)==ScaleConvert(n,12) && ScaleConvert(n,10)==ScaleConvert(n,16)){
			printf("%d is a Sky Number.\n",n);
		}else{
			printf("%d is not a Sky Number.\n",n);
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

2098.分拆素数和 222

#include <stdio.h>
#include <math.h>

//判断一个数是否为素数，若为素数返回1，否则返回0 
int IsPrime(int n){
    int i;
    for(i=2;i<=sqrt(n);i++){
    	if(n%i==0){
    		return 0;
    	}
    }  
    return 1;
}

void PrimeSum(){
	int n,count,i;
	while(scanf("%d",&n)!=EOF && n){
		count=0;
		for(i=2;i<n/2;i++){
			if(IsPrime(i) && IsPrime(n-i)){
				count++;
			}
		}
		printf("%d\n",count);
	}	 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

2099.整除的尾数 222

#include <stdio.h>

void Mantissa(){
	int a,b,i,j,count;
	int res[200];
	while(scanf("%d%d",&a,&b)!=EOF){
		if(a==0 && b==0){
			break;
		}
		a=a*100;
		count=0;
		for(i=0;i<=9;i++){
			for(j=0;j<=9;j++){
				if((a+i*10+j)%b==0){
					res[count]=i;
					res[count+1]=j;
					count+=2;
				}
			}
		}
		for(i=0;i<count;i+=2){
			printf("%d%d",res[i],res[i+1]);
			//当前的结果不是最后一个 
			if((i+2)!=count){
				printf(" ");
			}
		}
		printf("\n");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

不会

2074.叠筐 111

#include <stdio.h>

void FoldingBasket(){
	char pic[100][100];
	int n,i,center,j,count=0;
    char in,out;
    while(scanf("%d",&n)!=EOF){
        getchar();
        in=getchar();
        getchar();
        out=getchar();
        if(count>0) printf("\n");
        i=1;
        center=(n+1)/2;
        pic[center][center]=in;//中心;
        while(center>=i+1){
            int p=center-i,q=center+i;//顶点;
            for(j=0;j<2*i+1;j++){
            	pic[p][p+j]=i&1?out:in;//右;
                pic[p+j][p]=i&1?out:in;//下;
                pic[q][q-j]=i&1?out:in;//左;
                pic[q-j][q]=i&1?out:in;//上;
            }
            i++;
        }
        //四个角用空格代替 
        if(n!=1){
        	pic[1][1]=' ',pic[1][n]=' ',pic[n][1]=' ',pic[n][n]=' ';
        }      
        for(i=1;i<=n;i++){
            for(j=1;j<=n;j++){
            	 printf("%c",pic[i][j]);
            }
            printf("\n");
        }
        count++;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

2073.无限的路 111

#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;

double dis(int, int);			// 从起点到参数点所走的距离

int main()
{
	int N, i, x1, y1, x2, y2;
	double res_temp1, res_temp2, res;
	cin >> N;
	for (i = 0; i < N; i++) {
		cin >> x1 >> y1 >> x2 >> y2;
		res_temp1 = dis(x1, y1);
		res_temp2 = dis(x2, y2);
		res = abs(res_temp1 - res_temp2);
		cout << setiosflags(ios::fixed) << setprecision(3) << res << endl;
	}
	return 0;
}

double dis(int a, int b)
{
	// 记录模拟路线的坐标
	int x, y;
	// 记录每次从左上坐标到右下坐标所走“根号2”的个数
	int count = 0;
	double res;
	// 初始化模拟路线的坐标，从原点开始
	x = y = 0;
	// 模拟路线的点与参数点重合，结算距离
	if (a == x && b == y) {
		res = 0;
	}
	else {
		// 从原点走到（0， 1）
		y++;
		// 模拟路线的点与参数点重合，结算距离
		if (a == x && b == y) {
			res = 1;
		}
		else {
			res = 1;
			while (!x) {
				// 从左上坐标到右下坐标每次横坐标加1，纵坐标减1
				// 所以每次走的路程是一个“根号2”
				while (y != 0) {
					count++;
					x++;
					y--;
					// 每次坐标改变都要检查模拟路线的点是否与参数点重合
					if (a == x && b == y) {
						break;
					}
				}
				// 走到纵坐标为0时结算此过程走了几个“根号2”
				res += count * sqrt(2.0);
				// 把计数器清零
				count = 0;
				// 每次坐标改变都要检查模拟路线的点是否与参数点重合
				if (a == x && b == y) {
					break;
				}
				else {
					// 再从右下坐标走到下一个左上坐标
					res += sqrt(pow(x, 2.0) + pow(x + 1, 2.0));
					y = x + 1;
					x = 0;
					// 检查模拟路线的点是否与参数点重合
					if (a == x && b == y) {
						break;
					}
				}
			}
		}
	}
	return res;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

2072.单词数 1111

#include <stdio.h>
#include <string.h>

void NumberWords() {
    char words[100][1000]; // 二维数组用于存储单词
    char word[1000] = ""; // 用于存储当前正在读取的单词
    char c; // 用于存储输入字符
    int i, j, count, k; // 循环计数器和单词数量计数器

    // 循环读取输入，直到遇到 #
    while ((c = getchar()) != '#') {
        word[0] = c; // 将当前字符作为单词的第一个字符
        j = count = 0; // 初始化单词数量计数器和行数计数器
        k = 1; // 初始化字符位置指示器

        // 循环读取每个单词
        while (c != '\n') {
            // 将一个完整的单词保存到word中
            while ((c = getchar()) != ' ' && c != '\n') {
                word[k++] = c; // 逐个字符地添加到word中
            }
            word[k] = '\0'; // 添加字符串结束符

            // 将刚输入的一个完整的单词与之前输入的单词进行比较
            for (i = 0; i < j; i++) {
                if (strcmp(words[i], word) == 0) {
                    break; // 如果已经存在相同的单词，则跳出循环
                }
            }

            // 若刚输入的单词是新单词，则将其保存到words中
            if (i >= j && strlen(word)) {
                strcpy(words[j], word); // 将新单词拷贝到words中
                count++; // 单词数量加一
                j++; // 行数加一
            }

            k = 0; // 重置字符位置指示器
        }
        printf("%d\n", count); // 输出不同单词的数量
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

2066.一个人的旅行 111

https://blog.csdn.net/better_space/article/details/52135755

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#define INF 1<<30
using namespace std;
const int N = 1111;
int map[N][N],dis[N],vis[N],mud[N];
int maxn;
void dijkstra() {
    memset(vis,0,sizeof(vis));
    for(int i=0; i<=maxn; i++) {
        dis[i]=INF;
    }
    dis[0]=0;
    for(int i=0; i<=maxn; i++) {
        int tp=INF,k;
        for(int j=0; j<=maxn; j++) {
            if(!vis[j]&&tp>dis[j]) {
                tp=dis[j];
                k=j;
            }
        }
        //printf("%d--\n",dis[k]);
        vis[k]=1;
        for(int l=0; l<=maxn; l++) {
            if(!vis[l]&&dis[l]>dis[k]+map[k][l])
                dis[l]=dis[k]+map[k][l];
        }
    }
}
int main() {
    int T,S,D,ans;
    while(scanf("%d%d%d",&T,&S,&D)!=EOF) {
        for(int i=0; i<=N; i++)
            for(int j=1; j<=N; j++) {
                map[i][j]=i==j?0:INF;
            }
        int a,b,c,t;
        maxn=0;
        for(int i=0; i<T; i++) {
            scanf("%d%d%d",&a,&b,&c);
            maxn=max(max(maxn,a),b);
            if(map[a][b]>c)
                map[a][b]=map[b][a]=c;
        }
        //  printf("%d===\n",maxn);
        for(int i=0; i<S; i++) {
            scanf("%d",&t);
            map[0][t]=map[t][0]=0;
        }
        dijkstra();
        ans=INF;
        for(int i=0; i<D; i++) {
            scanf("%d",&t);
            ans=min(dis[t],ans);
        }
        printf("%d\n",ans);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

2062.Subset sequence 1111

https://blog.csdn.net/a939682389/article/details/79273354

2059.龟兔赛跑 111

#include <stdio.h>

void Race(){
	/*
		L:赛道长度  
		N:供电站个数 
		C:电动车冲满电以后能行驶的距离  
		T:电动车每次充电所需要的时间
		VR:兔子跑步的速度
		VT1:乌龟开电动车的速度
		VT2:乌龟脚蹬电动车的速度
	*/
	int L,C,T,N,VR,VT1,VT2,i,j;
	//dis[i]表示第i个充电站离跑道起点的距离 
	int dis[102];
	//dp[i]表示乌龟从起点到第i个充电站的最小时间
	double dp[102];
	//假设INF为本程序中的无穷大
	const double INF=0xFFFFFFFF;
	int length;
	double time;
	while(scanf("%d",&L)!=EOF) {
		scanf("%d%d%d",&N,&C,&T);
		scanf("%d%d%d",&VR,&VT1,&VT2);
		if(N<=0 || N>100){
			printf("充电站的个数的取值范围为[1,100]之间的整数！\n");
			continue;
		}
		//输入各个充电站离道起点的距离
		for(i=1;i<=N;i++){
			scanf("%d",&dis[i]);
		}
		//将终点设为第N+1个充电站
		dis[N+1]=L;
		//将起点设为第0个充电站
		dis[0]=0;
		//起点到起点最小耗费时间为0
		dp[0] =0;
		for(i=1;i<=N+1;i++){
			//由于目前到第i个充电站的最小耗费时间未知，所以暂时设置为无穷大 
			dp[i]=INF;
			for(j=0;j<i;j++){
				//从第j个加电站到第i个加电站的距离
				length=dis[i]-dis[j];
				//如果该距离大于电动车冲满电后能行驶的最大距离
				if(length>C){
					//把电动车行驶的时间加上乌龟用脚踏的时间
					time=C*1.0/VT1+(length-C)*1.0/VT2;
				}else{
					//直接加上这段距离除于电动车的速度所得的时间
					time=length*1.0/VT1;
				}
				time+=dp[j];
				if(j>0){
					//j>0表示乌龟不是从起点出发，走完上述的路程后，电动车需要充电 
					time+=T;
				}
				//修改乌龟到第i个充电站的最短时间
				dp[i]=(dp[i]<time)?dp[i]:time;
			}
		}
		//将兔子到达终点的时间与乌龟到达终点的时间进行比较 
		if((L*1.0/VR)>dp[N+1]){
			printf("What a pity rabbit!\n");
		}else{
			printf("Good job,rabbit!\n");
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

2022 海选女主角 1111111

#include<iostream>
#include<cmath>
#include<vector>
using namespace std;
int main(){
    int m, n;
    while (cin >> m >> n && m && n){
        vector<vector<int> > mm(m);

        for(int i = 0; i < m; ++ i)
            mm[i].resize(n);
        
        int row, col, maxs;
        row = col = maxs = 0;
        for(int i = 0; i < mm.size(); ++ i)
            for(int j = 0; j < (mm[0].size()); ++ j){
                cin >> mm[i][j];
                if(abs(mm[i][j]) > abs(maxs)){
                    maxs = mm[i][j];
                    row = i;
                    col = j;
                }
            }
        mm.clear();
        cout << row + 1 << ' ' << col + 1 << ' ' << maxs << endl;
    }
    return 0;  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

2104 hide handkerchief 1

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
long long gcd(long long n, long long m) {
	long long c;
	while (m != 0) {
		c = n % m;
		n = m;
		m = c;
	}
	return n;
}
int main() {
	long long n, m;
	while (cin >> n >> m) {
		if (n == -1 && m == -1)
			break;
		else
		{
			if (gcd(n, m) == 1)
				cout << "YES" << endl;
			else
				cout << "POOR Haha"<<endl;
		}
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

1170 Balloon Comes! 3

这个问题描述了一个简单的计算器程序。给定一个运算符（+，-，*，/ 分别表示加法、减法、乘法、除法）和两个正整数，你的任务是输出计算结果。

你可以按照以下步骤来实现这个程序：

读取输入，获取测试用例的数量。
对于每个测试用例，读取运算符和两个整数。
根据给定的运算符执行相应的计算。
输出结果，如果结果不是整数，则保留两位小数。
你可以使用C++编程语言来实现这个程序。以下是一个简单的示例代码：

#include <iostream>
#include <iomanip> // For setprecision
using namespace std;

int main() {
    int T;
    cin >> T; // Read the number of test cases

    while (T--) {
        char op;
        int A, B;
        cin >> op >> A >> B; // Read the operator and two integers

        double result;
        switch (op) {
            case '+':
                result = A + B;
                break;
            case '-':
                result = A - B;
                break;
            case '*':
                result = A * B;
                break;
            case '/':
                if (B == 0) {
                    cout << "Divisor cannot be zero!" << endl;
                    continue; // Skip this test case
                }
                result = (double)A / B;
                break;
            default:
                cout << "Invalid operator!" << endl;
                continue; // Skip this test case
        }

        // Output the result with 2 decimal places if it's not an integer
        if (result == (int)result) {
            cout << (int)result << endl;
        } else {
            cout << fixed << setprecision(2) << result << endl;
        }
    }

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

1197 Specialized Four-Digit Numbers


这个问题描述了寻找满足特定条件的四位数的过程。满足条件的数是指，其十进制表示的各位数字之和等于其十六进制表示和十二进制表示的各位数字之和。

你可以按照以下步骤来解决这个问题：

循环遍历所有可能的四位数，从1000到9999。
对于每个四位数，计算其各位数字之和。
将该四位数转换为十六进制，并计算各位数字之和。
将该四位数转换为十二进制，并计算各位数字之和。
如果三种表示法的各位数字之和相等，则将该四位数输出。
你可以使用C++编程语言来实现这个程序。以下是一个简单的示例代码：
#include<iostream>
using namespace std;

int main(){
    int i;
    int thousand[3],hundred[3],ten[3],num[3],sum[3];
    for(i=1000;i<10000;i++){

        thousand[0]=i/1000;
        hundred[0]=i/100-10*thousand[0];
        ten[0]=(i%100)/10;
        num[0]=i%10;

        thousand[1]=i/1728;
        hundred[1]=i/144-12*thousand[1];
        ten[1]=(i%144)/12;
        num[1]=i%12;

        thousand[2]=i/4096;
        hundred[2]=i/256-16*thousand[2];
        ten[2]=(i%256)/16;
        num[2]=i%16;

        sum[0]=thousand[0]+hundred[0]+ten[0]+num[0];
        sum[1]=thousand[1]+hundred[1]+ten[1]+num[1];
        sum[2]=thousand[2]+hundred[2]+ten[2]+num[2];


        if(sum[0]==sum[1]&&sum[0]==sum[2])
            cout<<i<<endl;      
    } 
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

2629 Identity Card

2036 改革春风吹满 1111

#include<iostream>
#include<iomanip>
using namespace std;
int main(){
    int n;
    while(cin>>n){
        if(n==0)
            break;
        int x[n],y[n];
        for(int i=0;i<n;i++){
            cin>>x[i]>>y[i];
        }
        double s=0;
        for(int i=0;i<n;i++){
            if(i+1==n){
                x[i+1]=x[0];
                y[i+1]=y[0];
            }
            s+=x[i]*y[i+1]-x[i+1]*y[i];
        }
        s*=0.5;
        cout.setf(ios::fixed);
          cout<<setprecision(1)<<s<<endl;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2045.不容易系列之(3)—— LELE的RPG难题 1111

#include <stdio.h>

void RPG(){
	//s[i]表示有i个方格时满足要求的涂法
	__int64 s[51]={0,3,6,6,18};
	int i,n;
	for(i=5;i<=50;i++){
		s[i]=s[i-1]+2*s[i-2];
	}
	while(scanf("%I64d",&n)!=EOF){
		if(n<=0 || n>50){
			printf("n的取值范围为(0,50]之间的整数!\n");
			continue;
		}
		printf("%I64d\n",s[n]);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2047 阿牛的EOF牛肉串 111

//
//  main.c
//  杭州电子科技大学
//
//  Created by yonuyeung on 2021/10/20.
//经过分析可知，该题涉及递推，其递推关系式为Tn=2*(T(n-1)+T(n-2))
#include<stdio.h>
int main()
{
    int n;
    long long a[45]={0,3,8};
    for(int i=3;i<45;i++)
    {
        a[i]=2*(a[i-1]+a[i-2]);
    }
    
    while(scanf("%d",&n)!=EOF)
    {
        printf("%lld\n",a[n]);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

1088–简单的HTML浏览器

详细版本的题目：https://blog.csdn.net/i_love_cet6/article/details/105716696?spm=1001.2014.3001.5502

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(){
    int cnt=0,len;
    char str[100];
    while(scanf("%s",str)!=EOF){
        if(strcmp(str,"<br>")==0){  //如果输入是<br>则换行
            printf("\n");
            cnt=0;
        }
        else if(strcmp(str,"<hr>")==0){  //如果输入是<hr>则输出80个'-'
            if(cnt!=0) printf("\n");
            for(int i=0;i<80;i++)
                printf("-");
            printf("\n");
            cnt=0;
        }
        else{  //输出文字
            if(cnt+strlen(str)+1<=80){  //长度小于80
                if(cnt==0) printf("%s",str);
                else {
                    printf(" %s",str);
                    cnt++;
                }
                cnt+=strlen(str);
            }
            else{ //长度大于80
                printf("\n%s",str);
                cnt=strlen(str);
            }
        }
    }
    printf("\n");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

板子

求最大公约数

// 计算两个数的最大公约数
int gcd(int a, int b) {
    if (b == 0) {
        return a;
    }
    return gcd(b, a % b);
}
1
2
3
4
5
6
7

最小公倍数

// 计算两个数的最小公倍数
int lcm(int a, int b) {
    return a * b / gcd(a, b);
}

1
2
3
4
5

判断一个数是否为素数

bool is_prime(int n) {
    if (n <= 1) return false;
    if (n == 2) return true;
    if (n % 2 == 0) return false;
    for (int i = 3; i <= sqrt(n); i += 2) {
        if (n % i == 0) return false;
    }
    return true;
}

版本二：
//判断一个数是否为素数，若为素数返回1，否则返回0 
int IsPrime(int n){
    int i;
    for(i=2;i<=sqrt(n);i++){
    	if(n%i==0){
    		return 0;
    	}
    }  
    return 1;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

结构体的比较函数

// 按照节目的结束时间进行升序排序的比较函数
int compare(const void *a, const void *b) {
    Program *programA = (Program *)a;
    Program *programB = (Program *)b;
    return programA->end - programB->end;
}
1
2
3
4
5
6

错排公式

draw[n]=(n-1)*(draw[n-1]+draw[n-2])。
1

语法

string str;
while(getline(cin,str)
1
2

1 需要注意的一点是，C++的cin输入，默认将空格和回车作为输入流的终止符。根据题意，我们不能把空格作为终止符，而是要当作正常的字符输入，因此需要用到getline()函数，具体用法见代码。
2 数组的创建

3 getchar() 函数用于从标准输入（键盘）读取一个字符，并返回该字符的 ASCII 值。它通常用于逐个读取输入的字符，直到遇到换行符 \n 或文件结束符 EOF 为止。

4 gets() 函数用于从标准输入（键盘）读取一行字符串，并将其存储到指定的字符数组中。它读取输入直到遇到换行符 \n 或文件结束符 EOF，然后将换行符替换为字符串结束符 \0

5 putchar() 函数用于将单个字符输出到标准输出（屏幕）。它接受一个整数作为参数，该整数表示要输出的字符的 ASCII 值。它会将该字符输出到控制台，并将其作为无符号字符返回。

6 getline(cin,str)   gets 和 getline 都是用于从输入流中读取一行数据的函数，但它们有以下区别：gets 函数无法读取空行，因为空行被视为结束符，会导致函数返回。getline 函数可以读取空行，并将空行存储为一个空字符串。

7. qsort(programs, n, sizeof(Program), compare); 调用 qsort 函数，可以根据给定的比较函数对数组进行排序。

8 define的使用：    
#include <stdio.h>
#define MAX_CITY 1001
#define INF 0x7fffffff

9 typedef long long ll

10 strcpy(a, b) 函数的作用是将字符串 b 中的内容复制到字符串 a 中，直到遇到空字符 \0 为止，包括空字符；

11 创建数组	int *p = new int[n];  

12 读文件fstream in;
	//记录学生的人数 
	int cnt=0;
	in.open("stuGrades1.txt",ios::in);
	char line[1000];
    in.getline(line,1000);//处理掉第一行的数据 
	//读取文件中的信息 
	while(in>>stus[cnt].name>>stus[cnt].stuId
			>>stus[cnt].English>>stus[cnt].Chinese
			>>stus[cnt].math>>stus[cnt].science){
		  	cnt++;
	}
	sort(stus,stus+cnt,cmp);

13. int h1=atoi(t1.substr(0,2).c_str()); 字符数组、字符串转成整数

14  cin >> staff[i].id >> staff[i].in >> staff[i].out;
        sscanf(staff[i].in.c_str(), "%d:%d:%d", &h, &m, &s);
        intime = h * 60 * 60 + m * 60 + s;
        sscanf(staff[i].out.c_str(), "%d:%d:%d", &h, &m, &s);
        outtime = h * 60 * 60 + m * 60 + s;

15  fill(d,d+maxv,INF); memset(pre,-1/0,sizeof(pre));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

cmp 结构体的比较函数

int cmp(const void *a, const void *b);
比较函数应返回一个整数值，其含义如下：
如果返回值小于0，则a排在b之前。
如果返回值等于0，则a和b的相对位置不变。
如果返回值大于0，则b排在a之前。
根据这个规则，如果想要实现从小到大排序，比较函数应该返回a - b，如果想要实现从大到小排序，比较函数应该返回b - a。

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<fstream>
#define MaxSize 1010

using namespace std;

struct stuInfo{
    char name[101];
    int id;
    int Chinese;
    int math;
    int English;
}stus[MaxSize];

bool cmp(stuInfo a,stuInfo b){
    int suma=a.Chinese+a.English+a.math;
    int sumb=b.Chinese+b.English+b.math;
    if(suma==sumb)//分数相同选择学号小的 
        return a.id<b.id;
    else
        return suma>sumb;//分数不同选择分数大的 
}
int main(){
    fstream in;
    in.open("data.txt",ios::in);
    char line[1000];
    in.getline(line,1000);//处理掉第一行的数据 
    int cnt=0;
    while(in>>stus[cnt].name>>stus[cnt].id>>stus[cnt].Chinese>>stus[cnt].math>>stus[cnt].English)
        cnt++;//逐行录入该文件每一行的内容 
    sort(stus,stus+cnt,cmp);//进行排序
    for(int i=0;i<cnt;i++)
        cout<<stus[i].name<<" "
        <<stus[i].id<<" "
        <<stus[i].Chinese<<" "
        <<stus[i].math<<" "
        <<stus[i].English<<" "
        <<endl; 
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

面试

Good morning, dear professors。I am glad to be here for this
interview.My name is Pang Lihao ,I am from  Dazhou,Sichuan Province. This summer I will graduate from Tianfu College of Southwest University of Finance and Economics in Computer Science and Technology.
早上好，亲爱的教授们。我很高兴来到这里
面试。我叫庞立浩，来自四川达州。今年夏天，我将从西南财经大学天府学院计算机科学与技术专业毕业。

In the past three years,my GPA was3.23，I passed CET-4,I won the academic scholarships three times.Moreover,I have a good grip on computer-aided software like AutoCAD,CATIA,andSolidworks，which are necessary tools for the major of Software Engineering。

Last year, I participated in a competition project，titled  AI tongue diagnosis system of Chinese medicine based on deep learning，In that project our team designed anautomatic battery replacement device for new vehicles，And I conducted the mechanical structure designin that team，Our project stood out and won National third prize。Personally I'm very outgoing and I have a strong thirst for knowledge，If I have the chance to studyin this university，I will spare no effort to advance my theoretical knowledge and skills and put them into practice，That's all for myself  introduction，Thank you for your attention

thanks your question
1
2
3
4
5
6
7
8
9
10

英文面试

最终：
Good morning, dear professors。I am glad to be here for this
interview.My name is Pang Lihao ,I am from  Dazhou,Sichuan Province. This summer I will graduate from Tianfu College of Southwest University of Finance and Economics majoring in Computer Science and Technology.Next，I will introduce myself from the following aspects。

firstly，During my undergraduate studies,I passed CET-4 and won the scholarship three times 。When I was a sophomore , I participated in a software design competition and won the first prize in school.I am mainly responsible for Java Back-end development and data processing。This experience has  improved my cooperation and communication skills. last summer,I participated in a competition project，titled  AI tongue diagnosis system of Chinese medicine based on deep learning ，during which I won the National third prize and learned a lot of scientific research methods and ways of thinking. 

secondly,I am a persistent and positive person，During my undergraduate studies,I gradually realized that the knowledge and skills I acquired in college would not be enough for me to fulfill my personal goals . In addition,I hope that I can learn more about this field.（Therefore,it is necessary for me to further my study instead of going to work after graduation.）

in the  end，if I have a chance to pass the exam,I will concentrate on scientific research and participate in teachers projects。I will work diligently to enhance my professional knowledge, practical abilities, and collaborative skills。
====
早上好，亲爱的教授们。我很高兴来到这里
面试。我的名字叫庞立浩，我来自四川省达州。今年夏天，我将从西南财经大学天府学院计算机科学与技术专业毕业。接下来，我将从以下几个方面介绍我自己。

本科期间，我通过了大学英语四级考试，在校期间三次获得奖学金。在大二的时候，我参加了一个软件设计比赛，并获得了学校的第一名。我主要负责Java后端开发和数据处理。这段经历提高了我的合作和沟通能力。去年夏天，我参加了一个名为《基于深度学习的中医AI舌诊系统》的竞赛项目，获得了国家三等奖，学到了很多科研方法和思维方式。

其次，我是一个坚持不懈的人。在本科期间，我逐渐意识到我在大学获得的知识和技能不足以实现我的个人目标。此外，我希望我能更多地了解这个领域。因此，我有必要继续深造，而不是毕业后去工作。

最后，如果我有机会通过考试，我将专注于科学研究和参与老师的项目。我将努力提高自己的专业知识、实践能力和协作能力。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Good morning, dear professors。I am glad to be here for this
interview.My name is Pang Lihao ,I am from  Dazhou,Sichuan Province. This summer I will graduate from Tianfu College of Southwest University of Finance and Economics in Computer Science and Technology.Next，I will introduce myself from the following aspects。

During my undergraduate studies,I passed CET-4 and won the scholarship three times （in school）。When I was a sophomore（sa fu more）, I participated in a software design competition and won the first prize in school.(I am mainly responsible for Java Back-end development and data processing),This experience has  improved my cooperation and communication skills.Last summer,I participated in a competition project，titled  AI tongue diagnosis system of Chinese medicine based on deep learning ，during which I won the National third prize and learned a lot of scientific research methods (and ways of thinking). 

secondly,I am a persistent person，During my undergraduate studies,I gradually realized that the knowledge and skills I acquired in college would not be enough for me to fulfill my personal goals in society. In addition,I hope that I can learn more about this field.Therefore, it is necessary for me to further my study instead of going to work after graduation.

in the  end，if I have a chance to pass the exam,I will concentrate on the study and scientific research，participate in teachers projects。I will work diligently to enhance my professional knowledge, practical abilities, and collaborative skills。

--------
above is myself introduction，thank you for your listening。
I'm sorry. I don catch that. Can you repeat it?
------
早上好，亲爱的教授们。我很高兴来到这里
面试。我的名字叫庞立浩，我来自四川省达州。今年夏天，我将从西南财经大学天府学院计算机科学与技术专业毕业。接下来，我将从以下几个方面介绍我自己。

本科期间，我通过了大学英语四级考试，在校期间三次获得奖学金。在大二的时候，我参加了一个软件设计比赛，并获得了学校的第一名。我主要负责Java后端开发和数据处理，这段经历提高了我的合作和沟通能力。去年夏天，我参加了一个名为“基于深度学习的中医AI舌诊系统”的竞赛项目，在这个项目中，我学到了很多科研方法和思维方式。

其次，我是一个执着的人。在本科期间，我逐渐意识到我在大学里获得的知识和技能不足以让我在社会上实现我的个人目标。此外，我希望我能更多地了解这个领域。因此，我觉得有必要继续深造，而不是毕业后去工作。

最后，如果我有机会通过考试，我将集中精力学习和科研，参加老师的项目。我会努力学习，提高自己的专业知识、实践能力和合作能力。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Good morning, dear professors。I am glad to be here for this
interview.My name is Pang Lihao ,I am from  Dazhou,Sichuan Province. This summer I will graduate from Tianfu College of Southwest University of Finance and Economics in Computer Science and Technology.（My major is Computer Science and Technology，In the past three years，my gpa was 3.28）

1. I will introduce myself from three aspects.Firstly，my undergraduate studies.Secondly,my research and project experience。 And finally,the reason why I want to attend a postgraduate program and my postgraduate plan.

2.Firstly，During my undergraduate studies,I passed CET-4 and won academic scholarships
本科学习期间，我学习了数据结构、数据库、操作系统，形成了系统的计算机科学知识体系。我通过了CET-4的测试。

3.Secondly, When I was a sophomore , I participated in a software design competition and won the first prize in school.I am mainly responsible for Java Back-end development and data processing,This experience has  improved my cooperation and communication skills.In last summer,I participated in a competition project，titled  AI tongue diagnosis system of Chinese medicine based on deep learning ，during which I learned a lot of scientific research methods and ways of thinking. 
在我大二的时候，我参加了一个软件设计比赛，并在学校获得了二等奖。我主要负责Java后端开发和数据处理，这段经历大大提高了我的合作和沟通能力。去年夏天，我参加了一个名为“基于深度学习的中医AI舌诊系统”的竞赛项目，在这个项目中，我学到了很多科研方法和思维方式。


4.  And finally,During my undergraduate studies,I gradually realized that the knowledge and skills I acquired in college would not be enough for me to fulfill my personal goals in society. In addition,I hope that I can learn more about this field.Therefore,I feel it is necessary for me to further my study instead of going to work after graduation.
在本科学习期问，我逐渐意识到我在大学获得的知识和技能不足以让我在社会上实现我的个人目标。此外，我希望我能更多地了解这个领域。因此，我觉得我有必要继续深造，而不是毕业后去工作。

5 If I have a chance to pass the exam,I will concentrate on the study and research 。I will work hard to learn professional knowledge to lay a solid foundation for my further study;Second,I would like to do some practical work with the help of my supervisor and classmates.And through this,I can get some skills that cannot be acquired from the textbooks.I hope that in the next two years,I can improve my ability of learning and independent thinking and have valuable academic outputs.

如果有机会在杭州电子科技大学学习，我会专心学习这个领域。首先，我会努力学习理论知识，为我的进一步学习打下坚实的基础；其次，我想在导师和同学的帮助下做一些实际工作。通过这个，我可以获得一些从教科书中无法获得的技能。我希望在接下来的三年里，我能提高自己的学习能力和独立思考能力，并有宝贵的学术成果。
6.   After study，I like listenning to music，if I have a chance to pass the exam ，I will study hard and improve my professional knowledge、practical ability and cooperation ability ，thank you for listening


--------
I'm sorry. I don catch that. Can you repeat it?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

中文面试

面带微笑

1 各位老师上午好，（面带微笑），很荣幸参加贵校本次研究生复试考试（实验室面试）。我的名字叫XXX，来自四川达州，本科就读于西南财经大学天府学院，我的本科专业是计算机科学与技术。初始分数，我目前的研究意向是生物医学工程方向，通过AI技术来诊断病人症状，进行医学辅助。接下来我将从学习经历，实践经历和个人兴趣爱好/学习规划等方面介绍自己。
2 首先，在本科学习阶段，我积极认真，刻苦学习，曾获得过三次校级奖学金。并且顺利通过了英语CET4考试。在学科竞赛方面，在校内参加了企业信息化管理大赛，并成功获得了校级一等奖，参加了三创赛，获得了三等奖。参加了互联网+大赛，获得了三等奖。参加了四川省华迪杯大赛，并获得了省级三等奖。参加了四川省大学生标准化实践大赛，获得了省级三等奖，参加了中国大学生计算机设计大赛，获得了国家三等奖。
3 其次是我的实践经历，在大二暑假期间，参加过国信安企业的夏令营，参观了一些企业，得到了企业老师的授课培训和并和他们交流实战的项目经验。
  我还加入了学校的创新班学习俱乐部，这是一个学生自主管理的团队，我担任了俱乐部的IT小组的负责人，每一学期我们小组成员都会一起交流学习和做项目，参加比赛，（并将每月的总结和学习报告以新闻稿在学校官网进行展示。）
4 我个人的兴趣爱好，在平时学习之余，我喜欢锻炼跑步，听听音乐。
5 最后，如果我能够顺利通过本次研究生复试/面试。我会在接下来的研究生2年半里，对研究生阶段的专业相关课程进行深入和系统学习，与此同时，我也会去阅读大量的期刊文献和代码，期望尽能够早在期刊上发表学术论文。多阅读，多思考，多动手实践，多和同学们和老师一起交流，以提升自己的专业水平。  以上就是我的个人自我介绍，感谢各位老师的聆听。
1
2
3
4
5
6

项目

项目介绍：项目的目的、使用技术，所获奖项，自己完成的部分
----
实体，实体和实体之间的关系，
首先，这个项目是对病人的舌头的识别诊断，进而来判断病人的病情，给出一些疾病描述和推荐使用的治疗食谱。 前期我们是先从网上，各个搜索引擎里，公众号去爬取公开的常见舌头形状的图片，然后自己对数据集进行训练，我主要是参与的图片的爬取收集，前端框架的设计，使用大屏展示界面展示系统的详情页面，病情可视化，病情诊断描述和推荐的治疗食谱的建议，后台使用neo4j图形化数据库的搭建，（将文本数据提取成实体，通过实体关系建立成图模型，建立好实体和实体之间的关系。在医疗中进行辅助决策。）导入了各个病情数据信息。 这个项目获得了中国大学生计算机设计大赛的三等奖。

其次就是这个疫情管理系统，这个系统是我们IT学习小组内部进行使用的，通过全国当时每天通报的实时疫情数据，第一时间的通知到小组成员，提醒他们做好防护和带好口罩。

在大二时，做了一个外卖管理系统，采用的是MVC架构设计模式，后端使用的spring全家桶+Mybatis进行完全开发的，前端使用的是Vue和element ui和微信小程序，脚手架进行快速的搭建。使用jwt进行用户的权限验证，使用阿里云oss作为图片存储服务，使用springtask来完成对订单的定时消息的发送以及更新订单状态。使用redis中间件作为数据库的缓存，采用的nginx实现反向代理和负载均衡，整个系统是使用docker来实现环境的快速搭建。

通过百度AI的图像识别技术，实现车辆入库的智能归类。记录用户车辆的入库和出库时间。

 4 .文字识别ocr
    
创新班机器学习体验平台：
项目描述：该项目是一款俱乐部内部的使用项目，该项目主要提供一些常见的人工智能工具供俱乐部成员进行使用，目前工具已经集成了图像识别、文字识别、自然语言处理、语音识别、人脸识别等A工具。
项目技术：项目主要以Java语言作为后端语言，前端使用vue+Element-UI实现，Al方面主要使用的是百度PaddlePaddle提供的Al能力，使用Git进行版本管理。  
主要负责：前期技术调研工作，以及图像识别及文字识别模块的开发。 
    
原理：OCR识别提取图片中文字原理：主要有三个步骤
1. 预处理：对包含文字的图像进行处理以便后续进行特征提取，这个过程的主要目的是减少图像中的无用信息。这个步骤通常有：灰度化（如果是彩色图像）、降噪、二值化，经过二值化后，图像只剩下两种颜色，即黑和白，其中一个是图像背景，另一个颜色就是要识别的文字了。还有就是降噪处理，让图片变得更干净。归一化处理则是将单个文字图像调整到同样的大小。
2.特征提取和降维：特征是用来识别文字的关键信息，每个不同的文字都能通过特征来和其他文字进行区分。如果特征的维数太高了的话，就会影响分类器的效率。所以需要降维。
3. 后处理：后处理是用来对分类结果进行优化的。


瑞吉外卖：
2023.01-2022.03	“讯磊餐饮”管理系统网站的开发
项目介绍：项目是一款专门为餐饮企业定制的软件产品，它包括两部分业务场景：商家管理端和用户端，即系统管理后台和小程序端应用。
工作内容：“讯磊餐饮”网站前后端的开发，使用微信小程序实现前端的搭建和编写，基于Spring Boot技术的后端编写，使用websocket实现定时发送消息，使用Redis将序列化后的菜品等数据进行缓存与预热，提高查询速率，以及使用Nginx的流服务器的搭建以及部署。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

1. 感谢老师的提问。我选择贵校的原因，首先我结合我自己的自身实际情况，在众多的学校当中，杭州电子科技大学不仅地理位置上，最终从老师资源上和以及学长学姐们的就业情况以及报告上面，我得到了学，得到各老师们，他们的教学质量非常优秀，然后学校的资源非常丰富，能够给学生提供很多的面试经验与机会。此外。我还希望在杭州电子科技大学能够完成我的研究生的3年学习。在此，我可以。嗯，获得很多的，在此在老师的指导下可以发表论文，努力学习，完成实验。

缺点是我紧张的时候，就容易说话说不出来，表达就不是很好。所以我需要克服自己的紧张。
1
2
3

获得的知识和技能不足以让我在社会上实现我的个人目标。此外，我希望我能更多地了解这个领域。因此，我觉得有必要继续深造，而不是毕业后去工作。

最后，如果我有机会通过考试，我将集中精力学习和科研，参加老师的项目。我会努力学习，提高自己的专业知识、实践能力和合作能力。




```c++
Good morning, dear professors。I am glad to be here for this
interview.My name is Pang Lihao ,I am from  Dazhou,Sichuan Province. This summer I will graduate from Tianfu College of Southwest University of Finance and Economics in Computer Science and Technology.（My major is Computer Science and Technology，In the past three years，my gpa was 3.28）

1. I will introduce myself from three aspects.Firstly，my undergraduate studies.Secondly,my research and project experience。 And finally,the reason why I want to attend a postgraduate program and my postgraduate plan.

2.Firstly，During my undergraduate studies,I passed CET-4 and won academic scholarships
本科学习期间，我学习了数据结构、数据库、操作系统，形成了系统的计算机科学知识体系。我通过了CET-4的测试。

3.Secondly, When I was a sophomore , I participated in a software design competition and won the first prize in school.I am mainly responsible for Java Back-end development and data processing,This experience has  improved my cooperation and communication skills.In last summer,I participated in a competition project，titled  AI tongue diagnosis system of Chinese medicine based on deep learning ，during which I learned a lot of scientific research methods and ways of thinking. 
在我大二的时候，我参加了一个软件设计比赛，并在学校获得了二等奖。我主要负责Java后端开发和数据处理，这段经历大大提高了我的合作和沟通能力。去年夏天，我参加了一个名为“基于深度学习的中医AI舌诊系统”的竞赛项目，在这个项目中，我学到了很多科研方法和思维方式。


4.  And finally,During my undergraduate studies,I gradually realized that the knowledge and skills I acquired in college would not be enough for me to fulfill my personal goals in society. In addition,I hope that I can learn more about this field.Therefore,I feel it is necessary for me to further my study instead of going to work after graduation.
在本科学习期问，我逐渐意识到我在大学获得的知识和技能不足以让我在社会上实现我的个人目标。此外，我希望我能更多地了解这个领域。因此，我觉得我有必要继续深造，而不是毕业后去工作。

5 If I have a chance to pass the exam,I will concentrate on the study and research 。I will work hard to learn professional knowledge to lay a solid foundation for my further study;Second,I would like to do some practical work with the help of my supervisor and classmates.And through this,I can get some skills that cannot be acquired from the textbooks.I hope that in the next two years,I can improve my ability of learning and independent thinking and have valuable academic outputs.

如果有机会在杭州电子科技大学学习，我会专心学习这个领域。首先，我会努力学习理论知识，为我的进一步学习打下坚实的基础；其次，我想在导师和同学的帮助下做一些实际工作。通过这个，我可以获得一些从教科书中无法获得的技能。我希望在接下来的三年里，我能提高自己的学习能力和独立思考能力，并有宝贵的学术成果。
6.   After study，I like listenning to music，if I have a chance to pass the exam ，I will study hard and improve my professional knowledge、practical ability and cooperation ability ，thank you for listening


--------
I'm sorry. I don catch that. Can you repeat it?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

[外链图片转存中…(img-KUuWBoIW-1710769876073)]

中文面试

面带微笑

1 各位老师上午好，（面带微笑），很荣幸参加贵校本次研究生复试考试（实验室面试）。我的名字叫XXX，来自四川达州，本科就读于西南财经大学天府学院，我的本科专业是计算机科学与技术。初始分数，我目前的研究意向是生物医学工程方向，通过AI技术来诊断病人症状，进行医学辅助。接下来我将从学习经历，实践经历和个人兴趣爱好/学习规划等方面介绍自己。
2 首先，在本科学习阶段，我积极认真，刻苦学习，曾获得过三次校级奖学金。并且顺利通过了英语CET4考试。在学科竞赛方面，在校内参加了企业信息化管理大赛，并成功获得了校级一等奖，参加了三创赛，获得了三等奖。参加了互联网+大赛，获得了三等奖。参加了四川省华迪杯大赛，并获得了省级三等奖。参加了四川省大学生标准化实践大赛，获得了省级三等奖，参加了中国大学生计算机设计大赛，获得了国家三等奖。
3 其次是我的实践经历，在大二暑假期间，参加过国信安企业的夏令营，参观了一些企业，得到了企业老师的授课培训和并和他们交流实战的项目经验。
  我还加入了学校的创新班学习俱乐部，这是一个学生自主管理的团队，我担任了俱乐部的IT小组的负责人，每一学期我们小组成员都会一起交流学习和做项目，参加比赛，（并将每月的总结和学习报告以新闻稿在学校官网进行展示。）
4 我个人的兴趣爱好，在平时学习之余，我喜欢锻炼跑步，听听音乐。
5 最后，如果我能够顺利通过本次研究生复试/面试。我会在接下来的研究生2年半里，对研究生阶段的专业相关课程进行深入和系统学习，与此同时，我也会去阅读大量的期刊文献和代码，期望尽能够早在期刊上发表学术论文。多阅读，多思考，多动手实践，多和同学们和老师一起交流，以提升自己的专业水平。  以上就是我的个人自我介绍，感谢各位老师的聆听。
1
2
3
4
5
6

项目

项目介绍：项目的目的、使用技术，所获奖项，自己完成的部分
----
实体，实体和实体之间的关系，
首先，这个项目是对病人的舌头的识别诊断，进而来判断病人的病情，给出一些疾病描述和推荐使用的治疗食谱。 前期我们是先从网上，各个搜索引擎里，公众号去爬取公开的常见舌头形状的图片，然后自己对数据集进行训练，我主要是参与的图片的爬取收集，前端框架的设计，使用大屏展示界面展示系统的详情页面，病情可视化，病情诊断描述和推荐的治疗食谱的建议，后台使用neo4j图形化数据库的搭建，（将文本数据提取成实体，通过实体关系建立成图模型，建立好实体和实体之间的关系。在医疗中进行辅助决策。）导入了各个病情数据信息。 这个项目获得了中国大学生计算机设计大赛的三等奖。

其次就是这个疫情管理系统，这个系统是我们IT学习小组内部进行使用的，通过全国当时每天通报的实时疫情数据，第一时间的通知到小组成员，提醒他们做好防护和带好口罩。

在大二时，做了一个外卖管理系统，采用的是MVC架构设计模式，后端使用的spring全家桶+Mybatis进行完全开发的，前端使用的是Vue和element ui和微信小程序，脚手架进行快速的搭建。使用jwt进行用户的权限验证，使用阿里云oss作为图片存储服务，使用springtask来完成对订单的定时消息的发送以及更新订单状态。使用redis中间件作为数据库的缓存，采用的nginx实现反向代理和负载均衡，整个系统是使用docker来实现环境的快速搭建。

通过百度AI的图像识别技术，实现车辆入库的智能归类。记录用户车辆的入库和出库时间。

 4 .文字识别ocr
    
创新班机器学习体验平台：
项目描述：该项目是一款俱乐部内部的使用项目，该项目主要提供一些常见的人工智能工具供俱乐部成员进行使用，目前工具已经集成了图像识别、文字识别、自然语言处理、语音识别、人脸识别等A工具。
项目技术：项目主要以Java语言作为后端语言，前端使用vue+Element-UI实现，Al方面主要使用的是百度PaddlePaddle提供的Al能力，使用Git进行版本管理。  
主要负责：前期技术调研工作，以及图像识别及文字识别模块的开发。 
    
原理：OCR识别提取图片中文字原理：主要有三个步骤
1. 预处理：对包含文字的图像进行处理以便后续进行特征提取，这个过程的主要目的是减少图像中的无用信息。这个步骤通常有：灰度化（如果是彩色图像）、降噪、二值化，经过二值化后，图像只剩下两种颜色，即黑和白，其中一个是图像背景，另一个颜色就是要识别的文字了。还有就是降噪处理，让图片变得更干净。归一化处理则是将单个文字图像调整到同样的大小。
2.特征提取和降维：特征是用来识别文字的关键信息，每个不同的文字都能通过特征来和其他文字进行区分。如果特征的维数太高了的话，就会影响分类器的效率。所以需要降维。
3. 后处理：后处理是用来对分类结果进行优化的。


瑞吉外卖：
2023.01-2022.03	“讯磊餐饮”管理系统网站的开发
项目介绍：项目是一款专门为餐饮企业定制的软件产品，它包括两部分业务场景：商家管理端和用户端，即系统管理后台和小程序端应用。
工作内容：“讯磊餐饮”网站前后端的开发，使用微信小程序实现前端的搭建和编写，基于Spring Boot技术的后端编写，使用websocket实现定时发送消息，使用Redis将序列化后的菜品等数据进行缓存与预热，提高查询速率，以及使用Nginx的流服务器的搭建以及部署。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

1. 感谢老师的提问。我选择贵校的原因，首先我结合我自己的自身实际情况，在众多的学校当中，杭州电子科技大学不仅地理位置上，最终从老师资源上和以及学长学姐们的就业情况以及报告上面，我得到了学，得到各老师们，他们的教学质量非常优秀，然后学校的资源非常丰富，能够给学生提供很多的面试经验与机会。此外。我还希望在杭州电子科技大学能够完成我的研究生的3年学习。在此，我可以。嗯，获得很多的，在此在老师的指导下可以发表论文，努力学习，完成实验。

缺点是我紧张的时候，就容易说话说不出来，表达就不是很好。所以我需要克服自己的紧张。
1
2
3

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/329225

杭电的oj_c++ 464在5*5的图像里,你可以选择点一下其中任意一格:第x行第y列。此时和这个格子

杭电oj的c++版本网站：

2000.ASCII码排序 333

2001 计算两点间的距离 333

2002 计算球体积 3333

2003 求绝对值 333

2004 成绩转换

2005 第几天？ 333

2006 求奇数的乘积 333

2007.平方和与立方和 333

2008.数值统计 333

2009.求数列的和 333

2010 水仙花数 333

2011.多项式求和 222

2012 素数判定 2

2013 蟠桃记 3333

2014 青年歌手大奖赛_评委会打分 333

2015 偶数求和 222

2016 数据的交换输出 222

2017 字符串统计 333

2018 母牛的故事 1111

2019 数列有序333

2020 绝对值排序 333

2021 发工资咯 2222

2022 海选女主角 222

2023 求平均成绩 222

2024 C语言合法标识符 222

2025 查找最大元素 111

2026 首字母变大写 333

2027 统计元音 333

2028 Lowest Common Multiple Plus 11111

2029 Palindromes _easy version

2030 汉字统计 11 111

2031 进制转换 222

2032 杨辉三角 111

2033 人见人爱A+B 3333

2034 人见人爱A-B 3333

2035 人见人爱A^B 33333

2036.改革春风吹满地 11111

2037 今年暑假不AC 111 1

2038没题目

2039 三角形 3333

2040 亲和数 3333

2041.超级楼梯 2222

2042 不容易系列之二 3333

2043.密码 33333

2044.一只小蜜蜂… 1111

2045.不容易系列之(3)—— LELE的RPG难题 1111

2046.骨牌铺方格 1111

2047 阿牛的EOF牛肉串 111 递推公式

2048.神、上帝以及老天爷

2049.不容易系列之(4)——考新郎

2050 折线分割平面 递推公式111

2051.Bitset 33333

常用库函数

2052.Picture 3333

2053.Switch Game 1111

2054.A == B ? 33333

2055.An easy problem 3333

2056 Rectangles 111111

2057.A + B Again 11111

2058.The sum problem 3333

2059.龟兔赛跑 dp 111

2060.Snooker 222

2061.Treasure the new start, freshmen! 333

2062.Subset sequence 1111

1

2063.过山车 1111

2064.汉诺塔 111

2065."红色病毒"问题 333

2066.一个人的旅行 111

2067.小兔的棋盘 222

2068.RPG的错排 111

2069.Coin Change 111

2070.Fibbonacci Number 333

2071.Max Num 3333

2072.单词数 1111

2073.无限的路 111

2074.叠筐 111

2076.夹角有多大 333

2050 折线分割平面递推公式111