这两天临时抱佛脚练了一下代码，深感自己水平不足，等考完研再加强练习。

01 芯片分配 - 2022_1/3

大概题意是一个芯片 10G，A 套餐组装需要 2.5 G，B 套餐组装需要 10G
第一行输入芯片块数 m，第二行输入套参数 n，第三行输入各个套餐的类型
从前往后塞套餐，并编号，输入最后一组套餐芯片所在块号、编号。

#include <iostream>
#include <cstring>
#include <stdlib.h>
#include <math.h>
using namespace std; 

int main(){
    int n,m,i,j,k,flag;
    char c;
    cin >> n;
    cin >> m;
    float Seriese[32][2];
    for(i=0;i<n;i++){
        Seriese[i][0] = 10;
        Seriese[i][1] = 0;
    }
    for(i=0;i<m;i++){
        cin >> c;
//        cout << "c: "<<c<<endl;
        if(c == 'A'){
            flag = 0;
            for(j=0; j<n; j++){
                if(Seriese[j][0] >=2.5){
//                  cout << Seriese[j][0] <<"-2.5= ";
                    Seriese[j][0] -=2.5;
                    Seriese[j][1] ++;
                    flag = 1;
//                    cout << Seriese[j][0] <<endl;
                    if(i==m-1){
                        cout << (j+1) << "\n" << Seriese[j][1];
                        return 0;
                    }
                    break;
                }
            }
            if(flag==0){
                cout << "0\n0";
                return 0;
            }        
        }
        else if(c=='B'){
            flag = 0;
            for(j=0; j<n; j++){
                if(Seriese[j][0] ==10){
                    Seriese[j][0] =0;
                    Seriese[j][1] =1;
                    flag = 1;
                    if(i==m-1){
                        cout << (j+1) << "\n1";
                        return 0;
                    }
                    break;
                }
            }
            if(flag ==0){
                cout << "0\n0";
                return 0;
            }    
        }
    }
    
    return(0);
}

=> 5
=> 6
=> A B A B A A A
1
4

02 迷宫最短路径 - 2022_2/3

给定一个大小为 N×M 的迷宫。迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四格的通道移动。请求出从起点到终点所需的小步数。'#', '.' ,'S' ,'G' 分别表示墙壁，通道，起点，终点。

• DFS 实现（递归）

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

int p0,q0,p1,q1;                                //起点和终点的坐标
char a[100][100];                               //地图数组 
int book[100][100];                             //标记数组
int next[4][2]={{0,1},{1,0},{0,-1},{-1,0}};     //下一步的可能情况 
int mini=10000;                                 //最小路径初值     
int n,m;

void dfs(int x,int y,int step){
    int nx,ny,k; 
    if(x==p1&&y==q1){                           //到达终点 
        if(step<mini)                           
            mini=step;                       
        return;                             
    }
    for(k=0;k<4;k++){                           //四种走向 
        nx=x+next[k][0];
        ny=y+next[k][1];                    
        if(nx<1||nx>n||ny<1||ny>m)              //控制越界 
            continue;
        if(book[nx][ny]==0 && (a[nx][ny]=='.'||a[nx][ny]=='G')){    //若此方向能走通 
            book[nx][ny]=1;                  
            dfs(nx,ny,step+1);
            book[nx][ny]=0;                 
        }
    } 
    return; 
}

int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){                      //地图初始化 
        for(int j=1;j<=m;j++){
            cin>>a[i][j];
            if(a[i][j]=='S'){
                p0=i;
                q0=j;
            }
            if(a[i][j]=='G'){
                p1=i;
                q1=j;
            }
        }
    }
    book[p0][q0]=1;                             //标记起点 
    dfs(p0,q0,0);
    cout<<"shortest path: "<<mini<<endl;
    return 0;
}

• BFS 实现（非递归）

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

char a[100][100];                           //地图数组 
int book[100][100];                         //标记数组 
int sx,sy,gx,gy;                            //起点和终点的坐标
int next[4][2]={{1,0},{0,1},{-1,0},{0,-1}}; //下一步的可能情况
int n,m;

struct node{
    int x,y,step; 
};

int main(){
    int head,tail,i,j,k,tx,ty;
    head=tail=0;                   
    cin>>n>>m;
    for(int i=1;i<=n;i++){                  //地图初始化
        for(int j=1;j<=m;j++){
            cin>>a[i][j];
            if(a[i][j]=='S'){
                sx=i;
                sy=j;
            }
            if(a[i][j]=='G'){
                gx=i;
                gy=j;
            }
        }
    }
    node q[10000];                          //100*100的地图队列
    q[tail].x=sx;                           //将起点压入队列
    q[tail].y=sy;
    q[tail].step=0;  
    book[sx][sy]=1;
    tail++;
    int flag=0; 
    while(head<tail){
        for(k=0;k<4;k++){                           //四种走向 
            tx=q[head].x+next[k][0];
            ty=q[head].y+next[k][1];
            if(tx<1||tx>n||ty<1||ty>m)              //控制越界
                continue;
            if(book[tx][ty]==0&&a[tx][ty]!='#'){    //若此方向能走通 
                q[tail].x=tx;
                q[tail].y=ty;
                q[tail].step=q[head].step+1;
                book[tx][ty]=1;
                tail++;
            }
            if(tx==gx&&ty==gy){                     //到达终点 
                flag=1;
                break;
            } 
        }
        if(flag)    
            break;
        head++;
    }
    cout<<"shortest path: "<<q[tail-1].step<<endl;
    return 0;
}

03 小朋友分组 - 2021_1/3

题目：
幼儿园老师安排小朋友做游戏，现在需要给N个小朋友进行分组，老师让每个同学写一个名字，代表这位小朋友想和谁分到一组。请问老师在满足所有小朋友意愿的情况下，最多可以将班级分成多少组？
输入：
第一行输入N，0<N<=100000
接下来是N行代表每个小朋友希望和谁分到一组，如"John Jack"，代表John希望和Jack分到一组，两个名字之间以空格分割，名字本身不存在空格。
输出：
分组的最多数量。

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

int main(){
    string student[100000][2];
    int N,i,j;
    int TwoPeople=0,other=0;
    cin>>N;
    for(i=0;i<N;i++){
        cin>>student[i][0]>>student[i][1];
    }
    for(i=0;i<N;i++){
        for(j=i+1;j<N;j++){
            if((student[i][1]==student[j][0]) && (student[i][0]==student[j][1])){
                TwoPeople++;
                student[i][0]=student[i][1]=" ";
                student[j][0]=student[j][1]=" ";                
            }
        }
    }
    while(student[0][0]!=" "){
    for(i=0;i<N;i++){
        for(j=0;j<N;j++){
            if((student[i][1]==student[j][0]) && (student[i][1]!="?")){
                student[i][1]=student[j][1];
                student[j][0]=student[j][1]=" ";
            }
        }
    }
    for(i=0;i<N;i++){
        if((student[i][0]==student[i][1]) && (student[i][0]!=" "))
            other++;
        }       
    }           
//  for(int i=0;i<N;i++){
//      cout<<student[i][0]<<" "<<student[i][1]<<endl;
//  }
    cout<<(TwoPeople+other)<<endl;
    return(0);
}

=>6
=>Jack Tom
=>Alice John
=>Jessica Leonie
=>Tom Alice
=>John Jack
=>Leonie Jessica
2

04 路线规划 - 2021_3/3

题目：
设计一条乐园游玩路线，使得：
游玩总时长不超过t，但尽可能接近t
不走回头路，仅向右或向下两个方向，直到出口
乐园是一个row行col列的方格区域，每个区域上都标注了游玩的时长，从[0,0]出发，选择符合上述要求的最佳路线，直到出口[row-1, col-1]。
输入：
首行输入以单个空格分割的三个正整数row、col、t，row为地图行数（0<row<=13），col为列数（0<col<=13），t为规定不能超过的游玩时长。
接下来row行，每一行有col个以空格分割的数字，代表该区域的游玩时长time（0<time<=100）
输出：
输出最佳游玩时长，若不存在，输出-1。

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

int total=0,result=0,row,col,t;


void DFS(int Graph[13][13],int i,int j,int total) {
    if (Graph[i][j] == 0)       //边界返回 
        return;
    total += Graph[i][j];
//  cout <<"Graph["<<i<<"]["<<j<<"]: "<<Graph[i][j]<<" total+=Graph = "<<total<<endl;
    if ((i==row-1) && (j==col-1)){  //终点返回 
        if(((t-total)<(t-result)) && (total<=t))
            result = total;
        total = 0;
        return;
    }
    DFS(Graph,i+1,j,total);
    DFS(Graph,i,j+1,total);
}

int main(){ 
    int Graph[13][13]={0};
    int i,j,k;
    
    cin>>row>>col>>t;
    for(i=0;i<row;i++){
        for(j=0;j<col;j++)
            cin>>Graph[i][j];
    }
    DFS(Graph,0,0,total);

    if(result!=0)
        cout<<result;
    else
        cout<<"-1";
    return 0;
}

=>5 5 30
=>3 5 4 2 3
=>4 5 3 4 3
=>4 3 5 3 2
=>2 5 3 3 5
=>5 3 4 4 1
30

05 HJ_1

描述
计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）
输入描述：
输入一行，代表要计算的字符串，非空，长度小于5000。
输出描述：
输出一个整数，表示输入字符串最后一个单词的长度。

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


int main()
{
    char str[100];
    while((scanf("%s",&str))!=EOF);
    printf("%d",(strlen(str)));
    return 0;
}

06 HJ_2

描述
写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。（不区分大小写字母）
数据范围： 1 \le n \le 1000 \1≤n≤1000
输入描述：
第一行输入一个由字母和数字以及空格组成的字符串，第二行输入一个字符。
输出描述：
输出输入字符串中含有该字符的个数。（不区分大小写字母）

#include <cstring>
#include <iostream>

using namespace std;

int main(){ 
    char c,c2;
    char s[1000]="";
    int n=0,i=0;
    while((c=getchar())!='\n'){
        if(c>=97 && c<=122)
            c-=32;
        s[i++] = c;
    }
    cin>>c2;
    for(i=0;i<strlen(s);i++){
        if((c2==s[i]) || ((c2-32)==s[i]))
            n++;
    }
    cout<<n;
    return 0;
}

07 HJ_5

描述
写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。
数据范围：保证结果在 1 \le n \le 2^{31}-1 \1≤n≤2
31
−1
输入描述：
输入一个十六进制的数值字符串。
输出描述：
输出该数值的十进制字符串。不同组的测试用例用\n隔开。

#include <iostream>
#include <cstring>
#include <math.h>
using namespace std;


int main(){
    char Oxnumber[10];
    int temp[8]={0};
    int Intnumber = 0;
    cin>>Oxnumber;
    int i,j=0,n=0; 
    
    for(i=(strlen(Oxnumber)-1);;i--){
        if(Oxnumber[i]=='x')
            break;
        if(Oxnumber[i]>=65 && Oxnumber[i]<=97)
            temp[j++] = int(Oxnumber[i]-55);
        else
            temp[j++] = int(Oxnumber[i]-48);    
        n++;
    }
    for(i=0;i<n;i++){
//      cout<<"temp["<<i<<"]: "<<temp[i]<<endl;
        Intnumber += temp[i]*pow(16,i);
    }
    cout<<Intnumber;
    return 0;
}

08 HJ_6

描述
功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）
数据范围： 1 \le n \le 2 \times 10^{9} + 14 \1≤n≤2×10 9+14
输入描述：
输入一个整数
输出描述：
按照从小到大的顺序输出它的所有质数的因子，以空格隔开。

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

bool IsThis(int x){
    int i,j,k;
    for(i=2;i<=x/2;i++){
        if(x%i==0)
            return false;
    }
    return true;
}

int main(){
    int N,i,n=0,j=0,temp;
    cin>>N;
    int number[100] = {0}; 
    temp = N;
    
    for(i=2;i<=N/2;){
        if(temp%i==0){
            if(IsThis(i)){
                number[j++] = i;
                temp /= i;
//              cout<<"i: "<<i<<" yes!!!"<<endl;
                n++;
            }
            else{
//              cout<<"i: "<<i<<" nno!!!"<<endl;
                continue;
            }
        }
        else
            i++;
    } 
    if(n==0)
        cout<<N;
    else{
        for(i=0;i<n;i++)
            cout<<number[i]<<" ";
    }
    return 0;
}

09 HJ_8

描述
数据表记录包含表索引index和数值value（int范围的正整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照index值升序进行输出。
提示:
0 <= index <= 11111111
1 <= value <= 100000
输入描述：
先输入键值对的个数n（1 <= n <= 500）
接下来n行每行输入成对的index和value值，以空格隔开
输出描述：
输出合并后的键值对（多行）

/*

这道题当时脑子坏了，写复杂了 

*/ 

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

int B[500][2]={0};

void Solution(int A[500][2],int n){
    int i,j=0,k,n2=0;
    int temp_index,temp_value,min;
    for(i=0;i<n;i++){
        if(A[i][0]!=-1){
            B[j][0] = A[i][0];
            B[j][1] = A[i][1];
            j++;
            n2++;
        }
    }   
    
    for(i=0;i<n2;i++){
        int min_index = B[i][0]; 
        int temp = i;
        for(j=i+1;j<n2;j++){
            if(B[j][0] < min_index){
                min_index = B[j][0];
                temp = j;
            }
        }
        temp_index = B[i][0];
        temp_value = B[i][1];
        B[i][0] = B[temp][0];
        B[i][1] = B[temp][1];
        B[temp][0] = temp_index;
        B[temp][1] = temp_value;
    }
    for(i=0;i<n2;i++)
        cout<<B[i][0]<<" "<<B[i][1]<<endl;
}


int main(){
    int A[500][2]={0};
    int n,i,j,k;
    cin>>n; 
    for(i=0;i<n;i++)
        cin>>A[i][0]>>A[i][1];  

    for(i=0;i<n-1;i++){
        if(A[i][0]!=-1){
            for(j=i+1;j<n;j++){
                if(A[j][0] == A[i][0]){
                    A[i][1] += A[j][1];
                    A[j][0] = A[j][1] = -1;
                }
            }
        }
    }
    Solution(A,n);      
    return 0;
}

0A HJ_14

描述
给定 n 个字符串，请对 n 个字符串按照字典序排列。
数据范围： 1 \le n \le 1000 \1≤n≤1000 ，字符串长度满足 1 \le len \le 100 \1≤len≤100
输入描述：
输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。
输出描述：
数据输出n行，输出结果为按照字典序排列的字符串。

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

int main(){
    char words[100][100];
    char temp[100];
    int i,j,k,n,min;
    cin >> n;
    for(i=0;i<n;i++)
        cin >> words[i];
    for(i=0;i<n-1;i++){
        min = i;
        for(j=i+1;j<n;j++){
            if(strcmp(words[min],words[j]) > 0)
                min = j;
        }
        cout << "words[" <<i<<"] <-> " <<"words[" <<min << "]"<<endl;
        strcpy(temp,words[i]);
        strcpy(words[i],words[min]);
        strcpy(words[min],temp);
    }
    for(i=0;i<n;i++)
        cout << words[i] << endl;       
    return(0);
}

0B HJ_22

描述
某商店规定：三个空汽水瓶可以换一瓶汽水，允许向老板借空汽水瓶（但是必须要归还）。
小张手上有n个空汽水瓶，她想知道自己最多可以喝到多少瓶汽水。
数据范围：输入的正整数满足 1 \le n \le 100 \1≤n≤100
注意：本题存在多组输入。输入的 0 表示输入结束，并不用输出结果。
输入描述：
输入文件最多包含 10 组测试数据，每个数据占一行，仅包含一个正整数 n（ 1<=n<=100 ），表示小张手上的空汽水瓶数。n=0 表示输入结束，你的程序不应当处理这一行。
输出描述：
对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。

#include <iostream>

using namespace std; 

void solution(int x){
    int result=0;
    int s = x;
    int r = 0;
    int temp = r+s;
    while(temp >= 3){
        temp = r+s;
        s = temp/3;
        r = temp%3;
        result += s;
    }
    if(temp == 2)
        cout << (result+1) << endl;
    else 
        cout << result <<endl;
}

int main(){
    int bottle[10];
    int i=0,j,k;
    while(cin>>bottle[i]){
        if(bottle[i] == 0)
            break;
        i++;
    }
    int n = i;
    
    for(i=0;i<n;i++){
        if(bottle[i] == 1)
            cout << "0" << endl;
        else 
            solution(bottle[i]);
    }       
//  for(i=0;i<n;i++)
//      cout << bottle[i] << endl;
    
    return(0);
}

0C HJ_33

描述
原理：ip地址的每段可以看成是一个0-255的整数，把每段拆分成一个二进制形式组合起来，然后把这个二进制数转变成
一个长整数。
举例：一个ip地址为10.0.3.193
每段数字 相对应的二进制数
10 00001010
0 00000000
3 00000011
193 11000001
组合起来即为：00001010 00000000 00000011 11000001,转换为10进制数就是：167773121，即该IP地址转换后的数字就是它了。
数据范围：保证输入的是合法的 IP 序列
输入描述：
1 输入IP地址
2 输入10进制型的IP地址
输出描述：
1 输出转换成10进制的IP地址
2 输出转换后的IP地址

#include <iostream>
#include <cstring>
#include <bitset>
#include <stdlib.h>
using namespace std; 

int main(){
    char c;
    char ip[4][3];
    int IP[4]={0};
    int i=0,j=0,k,count,int_ip=0,int_ip2,temp2;
    
    while((c=getchar())!='\n'){
        if(c!='.')
            ip[i][j++] = c;
        else{
            i++;
            j = 0;
        }
    }
    cin >> int_ip2;
    for(i=0;i<4;i++){
        bitset<32> temp = atoi(ip[i]);      //字符串转十进制转二进制 
        temp = temp << (32-8*(i+1));        //二进制移位 
//      cout << temp << " " << temp.to_ulong()<<endl;
        int_ip += temp.to_ulong();
//      cout << bint << endl;
    }
    cout << int_ip << endl;                         //二进制转十进制 
    
    bitset<32> bin_ip = int_ip2;
//  cout << bin_ip <<endl;
    
    for(i=0;i<4;i++){
        temp2 = ((bin_ip<<(i*8))>>24).to_ulong();   //移位并转十进制
        itoa(temp2,ip[i],10);                       //十进制转字符串 
//      cout << ((bin_ip<<(i*8))>>24) << "->" <<ip[i]<<endl;        
    }   
    for(i=0;i<3;i++)
        cout << ip[i] << ".";
    cout << ip[3];  
    return(0);
}

0D HJ_34

描述
Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过代码解决。
Lily使用的图片使用字符"A"到"Z"、"a"到"z"、"0"到"9"表示。
数据范围：每组输入的字符串长度满足 1 \le n \le 1000 \1≤n≤1000
输入描述：
一行，一个字符串，字符串中的每个字符表示一张Lily使用的图片。
输出描述：
Lily的所有图片按照从小到大的顺序输出

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

int main(){
    char words[1000];
    char c,temp;
    int i=0,j,k,min;
    while((c=getchar())!='\n')
        words[i++] = c;
    int n=i;
    for(i=0; i<n-1; i++){
        min = i;
        for(j=i+1; j<n; j++){
            if(words[j] < words[min])
                min = j;
        }
        temp = words[i];
        words[i] = words[min];
        words[min] = temp;
    }
    for(i=0; i<n; i++)
        cout<<words[i];
    return(0);
}

0E HJ_35

描述
蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。
例如，当输入5时，应该输出的三角形为：
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11
输入描述：
输入正整数N（N不大于100）
输出描述：
输出一个N行的蛇形矩阵。

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

int total(int x){
    int i=1,result =0;
    while(i!=(x+1))
        result += (i++);
    return result;
}

int main(){ 
    int i,j,k,N;
    cin >> N;
    int Graph[100][100] = {0};
    for(j=0; j<N; j++){
        Graph[0][j] = total(j+1);
        cout << Graph[0][j] << " ";
    }
    cout << endl; 
    for(i=1; i<N; i++){
        for(j=0; j<N-i; j++){
//          cout << " j= "<< j<<" ";
//          cout << "Graph["<<i<<"]["<<j<<"]= "<<Graph[i][j]<<" Graph["<<(i-1)<<"]["<<j<<"]= "<<Graph[i-1][j]<<" 后者再加（i+j）= ";
            Graph[i][j] = Graph[i-1][j]+j+i; 
//          cout <<Graph[i][j] << endl;
            cout << Graph[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

0F HJ_37

描述
有一种兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子。
例子：假设一只兔子第3个月出生，那么它第5个月开始会每个月生一只兔子。
假如兔子都不死，问第n个月的兔子总数为多少？
数据范围：输入满足 1 \le n \le 31 \1≤n≤31
输入描述：
输入一个int型整数表示第n个月
输出描述：
输出对应的兔子总数

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

int main(){
    int n,i,j,index=1;
    cin >> n;
    int rabbit[10000000];
    rabbit[0] = 1;  
    
    for(i=1; i<=n; i++){
        j = 0;
        while(rabbit[j]){
            if((i-rabbit[j]) >=2){
//              cout << "i: " << i << " rabbit[" << j <<"]: " << rabbit[j] <<endl;
//              cout << "第 " << i <<"月生了一只兔子。"<<endl; 
                rabbit[index++] = i;
            }
            j++;
        }
    }
    cout << index;
    return(0);
}

10 HJ_53

以上三角形的数阵，第一行只有一个数1，以下每行的每个数，是恰好是它上面的数、左上角数和右上角的数，3个数之和（如果不存在某个数，认为该数就是0）。
求第n行第一个偶数出现的位置。如果没有偶数，则输出-1。例如输入3,则输出2，输入4则输出3，输入2则输出-1。
数据范围： 1 \le n \le 10^9 \1≤n≤10 9
输入描述：
输入一个int整数
输出描述：
输出返回的int值

#include <iostream>
#include <cstring>
#include <bitset>
#include <stdlib.h>
using namespace std; 

int main(){
    int i,j,k,n;
    int triangle[100][200];
    triangle[0][0] = triangle[1][0] = triangle[1][1] = triangle[1][2] = 1;
    cin >> n;
    if(n==1 || n==2){
        cout << "-1";
        return 0;
    }
    for(i=2;i<n;i++){
        
        triangle[i][0] = 1;
        triangle[i][1] = triangle[i-1][1]+1;
        for(j=2;j<2*i-1;j++){ 
            //也可以利用对称性 
            triangle[i][j] = triangle[i-1][j]+triangle[i-1][j-1]+triangle[i-1][j-2];
        }
        triangle[i][2*i-1] = triangle[i-1][2*i-3]+1;
        triangle[i][2*i] = 1;
    }
    for(j=1;j<2*(n-1);j++){
        if(triangle[n-1][j]%2==0){
            cout << (j+1);
            break;
        }
    }
    if(j==2*(n-1))
        cout <<"-1";
    return(0);
}

11 HJ_94

描述
请实现一个计票统计系统。你会收到很多投票，其中有合法的也有不合法的，请统计每个候选人得票的数量以及不合法的票数。
（注：不合法的投票指的是投票的名字不存在n个候选人的名字中！！）
数据范围：每组输入中候选人数量满足 1 \le n \le 100 \1≤n≤100 ，总票数量满足 1 \le n \le 100 \1≤n≤100
输入描述：
第一行输入候选人的人数n，第二行输入n个候选人的名字（均为大写字母的字符串），第三行输入投票人的人数，第四行输入投票。
输出描述：
按照输入的顺序，每行输出候选人的名字和得票数量（以" : "隔开，注：英文冒号左右两边都有一个空格！），最后一行输出不合法的票数，格式为"Invalid : "+不合法的票数。

#include <iostream>
#include <cstring>
#include <bitset>
#include <stdlib.h>
using namespace std; 

int main(){
    int n1,n2,i,j,flag;
    int invalid = 0;
    char temp[100];
    cin >> n1;
    char names[100][100];
    int notes[100]={0};
    
    
    for(i=0;i<n1;i++)
        cin >> names[i];        
        
    cin >> n2;
    for(i=0;i<n2;i++){
        cin >> temp;
        flag = 0;
        for(j=0;j<n1;j++){
            if(strcmp(names[j],temp)==0){
                notes[j] ++;
                flag = 1;
            }
        }
        if(flag==0)
            invalid++;
    }
    for(i=0;i<n1;i++){
        cout << names[i] <<" : "<< notes[i] <<endl;
    }
    cout << "Invalid : "<<invalid;
    return(0);
}

12 NOJ_1

给定一个整数，判断它能否被3，5，7整除，并输出以下信息：
1、能同时被3，5，7整除（直接输出3 5 7，每个数中间一个空格）；
2、只能被其中两个数整除（输出两个数，小的在前，大的在后。例如：3 5或者 3 7或者5 7,中间用空格分隔）；
3、只能被其中一个数整除（输出这个除数）；
4、不能被任何数整除，输出小写字符‘n’,不包括单引号。

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

int main(){
    int x;
    scanf("%d",&x);
    if(x%105==0)
        printf("3 5 7\n");
    else if(x%15==0)
        printf("3 5\n");
    else if(x%21==0)
        printf("5 7\n");
    else if(x%35==0)
        printf("5 7\n");
    else
        printf("n\n");  
    return 0;
} 

13 NOJ_2

在我们现在使用的日历中, 闰年被定义为能被4整除且不能被100整除的年份，或者是能被400整除的年份。例如：1700, 1800, 1900 和 2100 不是闰年，而 1600, 2000 和 2400 是闰年。
给定一系列可能重复的年份，判断这些年份是否是闰年。

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

int main(){
    int T;
    while(T<1||T>1000000){
        scanf("%d",&T);
    }
    int year[T]={0};
    char* flag[T]={""};
    for(int i=0;i<T;i++){
AG:     scanf("%d",&year[i]);   
        if(year[i]<1 || year[i]>9999)
            goto AG;
        if(year[i]%400==0)
            flag[i]="Yes";
        else if(year[i]%4==0 && year[i]%100!=0)
            flag[i]="Yes";
        else
            flag[i]="No";
    }
    for(int i=0;i<T;i++){
        printf("%s\n",flag[i]);
    }
    return 0;
} 

14 NOJ_3

每一本正式出版的图书都有一个ISBN号码与之对应，ISBN码包括9位数字、1位识别码和3位分隔符，其规定格式如“x-xxx-xxxxx-x”，其中符号“-”就是分隔符（键盘上的减号），最后一位是识别码，例如0-670-82162-4就是一个标准的ISBN码。ISBN码的首位数字表示书籍的出版语言，例如0代表英语；第一个分隔符“-”之后的三位数字代表出版社，例如670代表维京出版社；第二个分隔符后的五位数字代表该书在该出版社的编号；最后一位为识别码。
Input:
输入只有一行，是一个字符序列，表示一本书的ISBN号码（保证输入符合ISBN号码的格式要求）。
Output:
输出共一行，假如输入的ISBN号码的识别码正确，那么输出“Right”，否则，按照规定的格式，输出正确的ISBN号码（包括分隔符“-”）。

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

int main(){
    char s[13];
    int a[9],i=0,j=0;
    scanf("%s",&s);
    while(s[i])
        a[j++]=s[i++]-'0';
    int x=a[0]*1+a[2]*2+a[3]*3+a[4]*4+a[6]*5+a[7]*6+a[8]*7+a[9]*8+a[10]*9;
    x%=11;
    if(a[12]==x)
        printf("Right\n");
    else{
        for(i=0;i<12;i++)
            printf("%c",char(a[i]+'0'));
        printf("%d",x);
    }
    return(0);
}

15 NOJ_4

Input:
第一行分别为矩阵的行数m和列数n（m < 100，n < 100），两者之间以一个空格分开。
接下来输入的m行数据中，每行包含n个整数，整数之间以一个空格分开。
Output:
输出对应矩阵的边缘元素和

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

int main(){
    int m,n,i,j;
    scanf("%d %d",&m,&n);
    int a[m][n]={0};
    for(i=0;i<m;i++){
        for(j=0;j<n;j++)
            scanf("%d",&a[i][j]);
    }
    int x=0;
    for(j=0;j<n;j++){
        x+=a[0][j];
        x+=a[m-1][j];
    }
    for(i=1;i<m-1;i++){
        x+=a[i][0];
        x+=a[i][n-1];
    }       
    printf("%d ",x);        
//  for(i=0;i<m;i++){
//      for(j=0;j<n;j++)
//          printf("%d ",a[i][j]);
//      printf("\n",a[i][j]);
//  }
    return(0);
}

16 NOJ_5（※）

BanG Dream!（バンドリ！）是一个以电视动画、手机音乐游戏、漫画、轻小说、广播、声优参与的现实演唱会和舞台活动等形式展开的次世代少女乐队计划。BanG Dream! 少女乐团派对!（BanG Dream! Girls Band Party）是由 Craft Egg 开发的一款Android / iOS / Nintendo Switch 音乐节奏类的社交手机卡牌网络游戏，游戏官方简称为 ガルパ(Garupa)，国内玩家简称 “邦多利” 或 “邦邦”。
在邦邦的卡牌系统中，所有出现的卡牌都会被分配一种属性，属性有 Powerful、Happy、Cool、Pure四种（分别简称为红、橙、蓝、绿属性），输入中使用 R/O/B/G 来表示。每张卡牌还具有三种能力值：演出力（Performance），技巧力（Technique），形象力（Visual），三种能力值总和称为卡牌的综合力。
邦邦中还可以选择一种杂志和一种区域道具来提升卡牌的综合力：杂志能够提升所有卡牌三种能力值其一，而特定区域的道具设置可以提升某种属性所有卡牌的综合力。
杂志和区域道具的效果列表如下：

在游戏中，你可以任意选择具有五张不同的卡牌组成队伍进行游戏，全队所有卡牌综合力之和即为队伍的综合力，综合力更高的队伍能够在游戏中得到更高的分数。
现在珂朵莉已经组好了一个队伍，并把卡牌的信息（属性、三种能力值）告诉了你，并且还告诉你了她选择使用的杂志以及区域道具，请你计算一下她组好的队伍综合力是多少。
Input:
第一行输入两个用空格分开的大写字母，代表珂朵莉选择的杂志和区域道具种类。
下面 5 行，每行先输入一个大写字母，表示卡牌的属性，然后输入三个正整数 p t v，分别表示卡牌的 演出力（Performance），技巧力（Technique）和 形象力（Visual）。（1≤p,t,v≤105）
Output:
一个正整数，珂朵莉组成的队伍的综合力。

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

char zz[3]={'P','T','V'};
char qy[4]={'R','O','B','G'};

char color[5];
int input[5][3];
float output[5];

void F(int Input[5][3],int i,int j){
    if(color[i]==qy[j])
        output[i]=1.12*(Input[i][0]+Input[i][1]+Input[i][2]);
    else
        output[i]=Input[i][0]+Input[i][1]+Input[i][2];
    for(int k=0;k<3;k++){
        switch(zz[k]){
            case 'P':
                output[i]+=Input[i][0]*0.16;
                break;  
            case 'T':
                output[i]+=Input[i][1]*0.16;
                break;  
            case 'V':
                output[i]+=Input[i][2]*0.16;
                break;                  
        }
    }
}

int main(){
    int i,j;
    char ZZ,QY;
    scanf("%c %c",&ZZ,&QY);
    for(i=0;i<3;i++){
        if(ZZ!=zz[i])
            zz[i]='?';
    }
    for(i=0;i<4;i++){
        if(QY!=qy[i])
            qy[i]='?';
    }
    
//  for(i=0;i<3;i++)
//      printf("%c ",zz[i]);
//  printf("\n");
//  for(i=0;i<4;i++)
//      printf("%c ",qy[i]);
//  printf("\n");
    
    for(i=0;i<5;i++)
        scanf(" %c %d %d %d",&color[i],&input[i][0],&input[i][1],&input[i][2]);
    
//  for(i=0;i<5;i++){
//      printf("%c %d %d %d\n",color[i],input[i][0],input[i][1],input[i][2]);
    
    for(i=0;i<5;i++){
        switch(color[i]){
            case 'R':
                F(input,i,0);
                break;
            case 'O':
                F(input,i,1);
                break;
            case 'B':
                F(input,i,2);
                break;
            case 'G':
                F(input,i,3);
                break;      
        }
    }   
    float result=0;
    for(i=0;i<5;i++){
        result+=output[i];
//      printf("%lf\n",output[i]);
    }
    printf("%d",(int)result);       
    return(0);
}

17 NOJ_6

在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。
每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。
因为还要花大力气把这些果子搬回家，所以多多在合并果子时要尽可能地节省体力。假定每个果子重量都为1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使多多耗费的体力最少，并输出这个最小的体力耗费值。
例如有3种果子，数目依次为1，2，9。可以先将1、2堆合并，新堆数目为3，耗费体力为3。接着，将新堆与原先的第三堆合并，又得到新的堆，数目为12，耗费体力为12。所以多多总共耗费体力=3+12=15。可以证明15为最小的体力耗费值。
Input:
输入包括两行，第一行是一个整数n(1<＝n<=10000)，表示果子的种类数。第二行包含n个整数，用空格分隔，第i个整数ai(1<＝ai<=20000)是第i种果子的数目。
Output:
输出包括一行，这一行只包含一个整数，也就是最小的体力耗费值。输入数据保证这个值小于2^31。

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

void bubleSort(int data[], int n) {
    int i,j,temp;
    for(j=0;j<n-1;j++) {
        for(i=0;i<n-j-1;i++) {
            if(data[i]>data[i+1]) {
                temp = data[i];
                data[i] = data[i+1];
                data[i+1] = temp;
            }
        }
    }  
}

int main(){
    int n,i,j;
    scanf("%d",&n);
    int a[n];
    for(i=0;i<n;i++)
        scanf("%d",&a[i]);
    bubleSort(a,n); 
//  for(i=0;i<n;i++)
//      printf("%d ",a[i]); 
//  printf("\n");
    int result=0;
    for(i=1;i<n;i++){
        int x=0;
        for(j=0;j<=i;j++)
            x+=a[j];
        result+=x;
    }
    printf("%d",result);    
    return(0);
   }

18 NOJ_7 华强的瓜田（※）

大概题意是输入方形瓜田的边长 n，再输入k个洒水器，输入洒水半径 r，问华强能洒水的瓜的个数。

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

void water(int fruit[100][100],int x, int y, int r, int n) {
    for (int i = 0; i <= r; i++) {
        for (int j = 0; j <= r; j++) {
            if((x + i) <= n && (y + j) <= n){
                if(sqrt(i*i+j*j)<=r){
                    fruit[x + i -1][y + j - 1] = 1;
                    fruit[x + i -1][y - j - 1] = 1;
                    fruit[x - i -1][y + j - 1] = 1;
                    fruit[x - i -1][y - j - 1] = 1;
//                  printf("%d^2+%d^2 = %lf^2\n",i,j,sqrt(i^2+j^2));                    
                }
            }
        }
    }
}

int main(){
    int n, k, r;
    int x, y;
    scanf("%d %d %d", &n, &k, &r);
    int fruit[100][100] = { {0} };
    for (int i = 0; i < k; i++) {
        scanf("%d %d", &x, &y);
        water(fruit, x, y, r, n);
    }
    int total = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if(fruit[i][j] == 1)
                total++;
        }
    }
    printf("%d\n",total);
    
//  for (int i = 0; i < n; i++) {
//      for (int j = 0; j < n; j++) 
//          printf("%d ", fruit[i][j]);
//      printf("\n");
//  }
    
    return 0;
}