杭电ACM基础题（1720、1785、1799、1859、1862）

朱雀 2023-07-20 05:45 15阅读 0赞

### 文章目录 ###

*   *  1720、A+B Coming\[十六进制数A+B\]
     *  1785、给定(x,y)坐标，比较其与x轴正向夹角
     *  1799、多重for循环，计算程序一共执行了多少次
     *  1859、最小长方形\[长方形框左下坐标，右上坐标\]
     *  1862、EXCEL排序排序

## 1720、A+B Coming\[十六进制数A+B\] ##

**Input**  
Input may contain multiple test cases. Each case contains A and B in one line.  
A, B are hexadecimal number.  
Input terminates by EOF.  
**Output**  
Output A+B in decimal number in one line.  
**Sample Input**

1 9
    A B
    a b

**Sample Output**

10
    21
    21

**Code**  
十六进制数A+B,将A B转化为十进制数，输出十进制A+B的结果

//十六进制数A+B,结果用十进制数表示
    #include<iostream>
    #include<cstring>
    #include<cmath>
    using namespace std;
    
    //将16进制数转化为10进制数
    int convert_ten(char c[]){
        
        int len=strlen(c);
        int num[1000],j=0;
        for(int i=0;i<len;i++){
        
            switch(c[i]){
        
                case 'A':
                    num[j++]=10;break;
                case 'a':
                    num[j++]=10;break;
                case 'B':
                    num[j++]=11;break;
                case 'b':
                    num[j++]=11;break;
                case 'C':
                    num[j++]=12;break;
                case 'c':
                    num[j++]=12;break;
                case 'D':
                    num[j++]=13;break;
                case 'd':
                    num[j++]=13;break;
                case 'E':
                    num[j++]=14;break;
                case 'e':
                    num[j++]=14;break;
                case 'F':
                    num[j++]=15;break;
                case 'f':
                    num[j++]=15;break;
                default:
                    num[j++]=c[i]-'0';break;
            }
        }
        int result=0;
        for(int i=len-1,k=0;i>=0;i--,k++){
        
            result=result+num[i]*pow(16,k);
        }
        return result;
    } 
    
    
    char a[1000],b[1000];
    int main() {
        
        while(cin>>a>>b){
        
            //将十六进制数a和b转化为十进制数 
            int m=convert_ten(a);
            int n=convert_ten(b);
            cout<<m+n<<endl;
        }
    }

## 1785、给定(x,y)坐标，比较其与x轴正向夹角 ##

用原点到该队员所在的点所构成的向量来表示一个队员。如果该向量和X正轴夹角比较小的话，就说他的能力比较高，排名就应该靠前。  
**Input**  
输入数据包含多组测试实例，每个实例的第一行是一个整数n（n<=100）,表示集训队员的人数，紧接着的一行是2\*n个数，表示n个队员的坐标值（x1,y1,x2,y2…xn,yn），n为负数的时候表示输入数据的结束。  
特别说明，所有的y坐标均为正数，并且所有的坐标值都是有一位小数的浮点数。  
**Output**  
对于每个测试实例，请在一行内输出排名后的坐标，坐标之间用一个空格隔开。特别地，你可以假设根据“伪氏排名规则”结果唯一。  
**Sample Input**

3
    5.0 4.0 3.1 0.1 2.0 2.0
    -1

**Sample Output**

3.1 0.1 5.0 4.0 2.0 2.0

**Code:**  
定义结构体数组来存储每位队员的（x,y）以及与x轴正向的夹角的余弦值，利用sort()函数对结构体数组进行排序，按排序结果输出即可

//比较(x,y)与x轴正向夹角，利用结构体存储x,y,以及角度 
    #include<iostream>
    #include<cmath>
    #include<algorithm>
    #include<iomanip>
    using namespace std;
    //利用结构体
    struct Point{
        
        double x;
        double y;
        double value;
    } stu[100];
    
    bool comp(Point x,Point y){
        
        return x.value>y.value;
    } 
    
    int main(){
        
        int n;//(0,100]队员个数 
        while(cin>>n){
        
            if(n<0) return 0;
            for(int i=0;i<n;i++){
        
                cin>>stu[i].x>>stu[i].y;
                //与x轴正方向的夹角余弦值，余弦值越大，与x轴正方向的坐标越小 
                stu[i].value=stu[i].x/sqrt(stu[i].x*stu[i].x+stu[i].y*stu[i].y);
            }
            //利用sort数组对结构体数组进行排序
            sort(stu,stu+n,comp);
            cout<<setiosflags(ios::fixed);
            for(int i=0;i<n;i++){
        
                if(i==0){
        
                    cout<<setprecision(1)<<stu[i].x<<" "<<setprecision(1)<<stu[i].y;
                }
                else{
        
                    cout<<" "<<setprecision(1)<<stu[i].x<<" "<<setprecision(1)<<stu[i].y;
                }
            }
            cout<<endl;
        }
        
    }

## 1799、多重for循环，计算程序一共执行了多少次 ##

我们知道，在编程中，我们时常需要考虑到时间复杂度，特别是对于循环的部分。例如，  
如果代码中出现  
for(i=1;i<=n;i++) OP ;  
那么做了n次OP运算，如果代码中出现  
fori=1;i<=n; i++)  
for(j=i+1;j<=n; j++) OP;  
那么做了n\*(n-1)/2 次OP 操作。  
现在给你已知有m层for循环操作，且每次for中变量的起始值是上一个变量的起始值＋1（第一个变量的起始值是1），终止值都是一个输入的n，问最后OP有总共多少计算量。  
**Input**  
有T组case，T<=10000。每个case有两个整数m和n，0<m<=2000，0<n<=2000.  
**Output**  
对于每个case，输出一个值，表示总的计算量，也许这个数字很大，那么你只需要输出除1007留下的余数即可。  
**Sample Input**

2
    1 3
    2 3

**Sample Output**

3
    3

**Code:**  
思路：C(n,m)相当于共有n个球，要从中取出m个球，共有多少种组合方式，可等价于—共有n个数，从中取出m个数，有多少种组合方式,–即m重循环，循环截止条件为n的程序执行多少次

/*多重for循环，计算程序一共执行了多少次
    思路：C(n,m)相当于共有n个球，要从中取出m个球，共有多少种组合方式
    可等价于---共有n个数，从中取出m个数，有多少种组合方式 */ 
    #include<iostream>
    using namespace std;
    
    int a[2001][2001]={
        0};
    //计算C(n,m)=C(n-1,m)+C(n-1,m-1);
    //a[n][m]代表C(n,m) 
    void fun_C(void){
        
        a[0][0]=1;
        for(int i=1;i<=2000;i++){
        
            a[i][0]=1;
            for(int j=1;j<=i;j++){
        
                a[i][j]=(a[i-1][j]+a[i-1][j-1])%1007;
            }
        }
    }
    
    int main(){
        
        int t;//t组测试用例[1,10000]
        cin>>t;
        fun_C();
        while(t--){
        
            int m,n;//m重循环，终止条件为n  (0,2000]
            cin>>m>>n;//C(n,m)组合公式 
            cout<<a[n][m]<<endl;
        } 
        return 0;
    }

## 1859、最小长方形\[长方形框左下坐标，右上坐标\] ##

给定一系列2维平面点的坐标(x, y)，其中x和y均为整数，要求用一个最小的长方形框将所有点框在内。长方形框的边分别平行于x和y坐标轴，点落在边上也算是被框在内。  
**Input**  
测试输入包含若干测试用例，每个测试用例由一系列坐标组成，每对坐标占一行，其中|x|和|y|小于 231；一对0 坐标标志着一个测试用例的结束。注意(0, 0)不作为任何一个测试用例里面的点。一个没有点的测试用例标志着整个输入的结束。  
**Output**  
对每个测试用例，在1行内输出2对整数，其间用一个空格隔开。第1对整数是长方形框左下角的坐标，第2对整数是长方形框右上角的坐标。  
**Sample Input**

12 56
    23 56
    13 10
    0 0
    12 34
    0 0
    0 0

**Sample Output**

12 10 23 56
    12 34 12 34

**Code**  
给定一系列2维平面点的坐标(x, y),用一个最小的长方形框将所有点框在内，输出该最小长方形的左下角的坐标，长方形框右上角的坐标。  
思路：输出这一系列点的横坐标的最小值，纵坐标的最小值，横坐标的最大值，纵坐标的最大值

//给定一系列2维平面点的坐标(x, y),用一个最小的长方形框将所有点框在内。
    //输出是长方形框左下角的坐标，长方形框右上角的坐标。
    #include<iostream>
    #include<algorithm>
    using namespace std;
    
    int x_arry[1000],y_arry[1000];
    int main(){
        
        while(cin>>x_arry[0]>>y_arry[0]){
        
            if(x_arry[0]==0&&y_arry[0]==0){
        
                return 0;
            }
            int i=1;
            while(cin>>x_arry[i]>>y_arry[i]){
        
                if(x_arry[i]==0&&y_arry[i]==0) break;
                i++;
            }
            
            //对x_arry[] y_arry[]进行排序
            sort(x_arry,x_arry+i);
            sort(y_arry,y_arry+i);
            //输出最小的横坐标 最小的纵坐标 最大的横坐标 最大的纵坐标 
            cout<<x_arry[0]<<" "<<y_arry[0]<<" "<<x_arry[i-1]<<" "<<y_arry[i-1]<<endl; 
        }
    }

## 1862、EXCEL排序排序 ##

Excel可以对一组纪录按任意指定列排序。现请你编写程序实现类似功能。  
**Input**  
测试输入包含若干测试用例。每个测试用例的第1行包含两个整数 N (<=100000) 和 C，其中 N 是纪录的条数，C 是指定排序的列号。以下有 N  
行，每行包含一条学生纪录。每条学生纪录由学号（6位数字，同组测试中没有重复的学号）、姓名（不超过8位且不包含空格的字符串）、成绩（闭区间\[0, 100\]内的整数）组成，每个项目间用1个空格隔开。当读到 N=0 时，全部输入结束，相应的结果不要输出。  
**Output**  
对每个测试用例，首先输出1行“Case i:”，其中 i 是测试用例的编号（从1开始）。随后在 N 行中输出按要求排序后的结果，即：当 C=1 时，按学号递增排序；当 C=2时，按姓名的非递减字典序排序；当 C=3  
时，按成绩的非递减排序。当若干学生具有相同姓名或者相同成绩时，则按他们的学号递增排序。  
**Sample Input**

3 1
    000007 James 85
    000010 Amy 90
    000001 Zoe 60
    4 2
    000007 James 85
    000010 Amy 90
    000001 Zoe 60
    000002 James 98
    4 3
    000007 James 85
    000010 Amy 90
    000001 Zoe 60
    000002 James 90
    0 0

**Sample Output**

Case 1:
    000001 Zoe 60
    000007 James 85
    000010 Amy 90
    Case 2:
    000010 Amy 90
    000002 James 98
    000007 James 85
    000001 Zoe 60
    Case 3:
    000001 Zoe 60
    000007 James 85
    000002 James 90
    000010 Amy 90

**Code**  
对结构体数组按指定的方式进行排序

//按指定方式排序
    #include<iostream>
    #include<cstring>
    #include<algorithm>
    using namespace std;
    
    struct Student{
        
        char id[7];//学号
        char name[8];
        int score;//分数 
    } stu[100000];
    
    bool comp_id(Student x,Student y){
        
        if(strcmp(x.id,y.id)<0) return true;
        else return false;
    }
    
    bool comp_name(Student x,Student y){
        
        if(strcmp(x.name,y.name)==0){
        
            return strcmp(y.id,x.id)>0;
        }else{
        
            if(strcmp(x.name,y.name)<0) return true;
            else return false;
        }
    }
    
    bool comp_score(Student x,Student y){
        
         if(x.score==y.score){
        
             return strcmp(y.id,x.id)>0;
        }
        else{
        
            return x.score<y.score;
        } 
    } 
    
    int main(){
        
        int i=0;//测试用例的编号
        int n,c;
        while(cin>>n>>c){
        
            if(n==0) return 0;
            i++;
            for(int j=0;j<n;j++){
        
                cin>>stu[j].id>>stu[j].name>>stu[j].score;
            }
            //按何种顺序进行排序 
            switch(c){
        
                case 1://按学号递增排序
                    sort(stu,stu+n,comp_id);
                    break;
                case 2://按姓名非递减排序--按学号递增排序 
                    sort(stu,stu+n,comp_name);
                    break;
                case 3://按成绩的非递减排序--按学号递增排序 
                    sort(stu,stu+n,comp_score);
                    break; 
            }
            cout<<"Case "<<i<<":"<<endl;
            for(int k=0;k<n;k++){
        
                cout<<stu[k].id<<" "<<stu[k].name<<" "<<stu[k].score<<endl;
            } 
        }
    }