relations的vector存储的就是Relation类型的数据，并不是指针，所以relations[i]访问Relation的成员就是直接用.，

但是joins的JoinSql里面存的是指针，并不是实际的数据，所以应当用->来访问其中的成员

结构体当中的SqlNode是它的成员，所以访问这个成员用的是. ；但如果要访问这个成员（指针）所指向的对象的成员，就需要用->了

选择

函数重载要求函数的参数个数不同或者参数类型不同。

因为调用函数的时候无法确认函数的返回类型，所以仅返回类型不同的函数都可以匹配，这样就造成二义性，所以仅仅是返回类型不同是不能重载的，

重载运算符可以保持原运算符的优先级和结合性不变

重载运算符，坚持4个“不”原则: 1)运算符操作数的个数; 2)运算符原有优先级; 3)运算符原有的结合性; 4)运算符原有的语法结构 均不能改变！！！

___________
6-4 2017final友元函数之全班同学的平均绩点

第一次没考虑count==0的情况，就是一开始就是no

会让第一个样例点过不去

加上对count==0的特判后可以过

double averagegrade(student *stu, int count){
    double sum=0.0;//学分绩点之和
    double sumS=0.0;//学分之和
    if(count==0){
        return 0;
    }
    for(int i=0;i<count;i++){
        student cur=stu[i];
        for(int j=0;cur.score[j]!=-1;j++){
            sum+=(cur.score[j]*((cur.grade[j])/10-5));
            sumS+=(cur.score[j]);
        }
    }
    //cout<<sum/sumS<<endl;
    return sum/sumS;
}
//要算每个学生的每门课程的学分绩点
//要累计每个学生的学分数

6-5 2017Final 乐观的中考生

pro1

很抽象的一个错误，原代码当中没有给head初始化，是一个NULL,所以需要特判一下对head为NULL的情况

pro2

在当前结点不满足情况时，没有跳过该结点，填上continue即可

pro3

addBatch的问题

问题出现在这里，一开始的head是空的，但是在循环中，是构建了newTask,然后插入到cur之后的，即每个子链表的head都是空的

但是为什么第一串的head是空，但是打印出来的却没问题？

        空，确实是空的，但并不是NULL，它是有next的，指向下一个实结点，只是自身并没有任何数据

0 1 2 3

从0向后数3个，但实际上是应当要包含0自身的

pro3_real!

指针

这个就是看指针操作，newCur->next指向的位置和cur是一样的，因为newCur和cur都是指针，而并非深拷贝，所以newCur在设next=NULL时，

这个指针操作，设next,并不是去改变指针的指向，如果只是改变指针指向，如newCur的指向的话，怎么改都无所谓，并不会影响其它指针和数据

但是如果通过这个指针，以->的形式去修改其所指向的数据，修改的就不是指针的值，而是修改的指针所指向的数据的值，修改的是内存上的值

即newCur是在栈上的操作，而newCur->next就是在堆上、内存的操作

在newCur->next将next修改之后，下一行cur=cur->next取得的指针就也是NULL了，但如果cur=cur->next在上一行，就是从堆中取出指针值，赋给cur,之后newCur->next再怎么修改，也不会对cur造成影响

Task* getBatch(int m){
    int key;
    cin>>key;
    Task *head=new Task;
    Task *cur=head;
    for(int i=0;i<m;i++){
        Task *newTask=new Task;
        cin>>newTask->ID>>newTask->load;
        newTask->key=key;
        newTask->next=NULL;
        cur->next=newTask;
        cur=cur->next;
    }
    return head;
}
void display(Task *head,int m){
    if(head==NULL){
        cout<<"OK"<<endl;
        return;
    }
    Task *cur=head;
    for(int i=0;i<m;i++){
        if(cur->next==NULL){
            cout<<"OK"<<endl;
            return;
        }
        cur=cur->next;
    }
    cout<<cur->ID<<" "<<cur->key<<" "<<cur->load<<endl;
}//插入到头
//插入到尾/中间，需要知道插入的小链表的头部x1和尾部x2,需要记录原来cur的next
//cur->next=x1;x2->next=原cur->next
Task* addBatch(Task *head,Task *h){
    if(h==NULL){
        return head;
    }
    //获取小链表尾部
    Task *tail=h;
    while(tail){
        if(tail->next==NULL){
            break;
        }
        tail=tail->next;
    }
    //插入到头部的特判
    if((head==NULL)||(h->key<head->key)){
        tail->next=head;
        return h;
    }
    //尾部/中间
    Task *cur=head;
    while(1){
        Task *next=cur->next;//下一个位置
        if(next==NULL){//插入到尾部
            cur->next=h;
            return head;
        }
        if(next->key>h->key){//插入到cur的后面，中间位置
            cur->next=h;
            tail->next=next;
            return head;
        }
        cur=next;
    }
}
Task* study(Task*head, int mi, int ma, int load){
    if(head==NULL){
        return NULL;
    }
    Task *newHead=head;
    Task *newCur=newHead;
    Task *cur=head;//遍历原链表的每个元素
    while(1){
        //不满足条件的情况，直接跳过
        if((cur->load>ma)||(cur->load<mi)){
            newCur->next=cur;
            newCur=newCur->next;
            newCur->next=NULL;
            cur=cur->next;
            continue;
        }
        //做不完了，退出
        if(load<cur->load){
            newCur->next=cur;
            display(newHead,3);
            return newHead;
        }
        //做任务
        load-=cur->load;
        //如果做完了就退出
        Task *next=cur->next;
        if(next==NULL){
            display(newHead,3);
            return newHead;
        }
        cur=next;
    }
}
//每批作业具有相同的优先值（不同批的任务的优先值不一样），由若干个不同的任务组成，每个任务都有唯一的编号
//小林同学会把每批作业先按照编号顺序整理好，然后按照这批作业的优先值，放入活页夹里。接下来，她将按照任务在活页夹的顺序依次把作业完成
//该批作业的第三个任务或者活页夹中的第三个任务,如果任务数少于3个，她会愉快地说一声"OK"

/* 请在这里填写答案 */
Task* getBatch(int m) {
    if (m < 1) {
        return NULL;
    }
    int key;
    cin >> key;
    Task* head = new Task;
    cin >> head->ID >> head->load;
    head->key = key;
    head->next = NULL;
    Task* cur = head;
    for (int i = 0; i < m-1; i++) {
        Task* newTask = new Task;
        cin >> newTask->ID >> newTask->load;
        newTask->key = key;
        newTask->next = NULL;
        cur->next = newTask;
        cur = cur->next;
    }
    cout << "此时构建的一串的头部是" << head->ID << " " << head->load << endl;
    return head;
}
void display(Task* head, int m) {
    if (head == NULL) {
        cout << "OK" << endl;
        return;
    }
    Task* cur = head;
    for (int i = 0; i < m-1; i++) {
        if (cur->next == NULL) {
            cout << "OK" << endl;
            return;
        }
        cur = cur->next;
    }
    cout << cur->ID << " " << cur->key << " " << cur->load << endl;
}//插入到头
//插入到尾/中间，需要知道插入的小链表的头部x1和尾部x2,需要记录原来cur的next
//cur->next=x1;x2->next=原cur->next
Task* addBatch(Task* head, Task* h) {
    if (h == NULL) {
        cout << "此时要插入的task为空" << endl;
        return head;
    }
    if (head == NULL) {
        cout << "此时头节点为NULL" << endl;
        return h;
    }
    //获取小链表尾部
    Task* tail = h;
    while (1) {
        if (tail->next == NULL) {
            break;
        }
        tail = tail->next;
    }
    cout << "此时插入的一串小链表的尾部是" << tail->ID << " " << tail->load << endl;
    //插入到头部的特判
    if (h->key < head->key) {
        tail->next = head;
        return h;
    }
    //尾部/中间
    Task* cur = head;
    while (1) {
        Task* next = cur->next;//下一个位置
        if (next == NULL) {//插入到尾部
            cur->next = h;
            return head;
        }
        if (next->key > h->key) {//插入到cur的后面，中间位置
            cur->next = h;
            tail->next = next;
            return head;
        }
        cur = next;
    }
}
void printTask(Task* head) {
    Task* cur = head;
    while (1) {
        cout << cur->ID << " ";
        cur = cur->next;
        if (cur == NULL) {
            cout << endl;
            return;
        }
    }
}
Task* study(Task* head, int mi, int ma, int load) {
    if (head == NULL) {
        return NULL;
    }
    //Task* newHead = head;
    Task* newHead = new Task;//不能用上面一行初始化，不然默认最后都会包含第一个结点，此时newHead是空结点
    Task* newCur = newHead;
    Task* cur = head;//遍历原链表的每个元素
    while (1) {
        cout << "在学习时，遍历到的当前结点是 " << cur->ID << endl;
        //不满足条件的情况，直接跳过
        if ((cur->load > ma) || (cur->load < mi)) {
            newCur->next = cur;
            newCur = newCur->next;
            cur = cur->next;
            //newCur->next = NULL;
           // cur = cur->next;
            continue;
        }
        //做不完了，退出
        if (load < cur->load) {
            newCur->next = cur;
            display(newHead->next, 3);
            return newHead;
        }
        //做任务
        load -= cur->load;
        //如果做完了就退出
        Task* next = cur->next;
        if (next == NULL) {
            newCur->next = NULL;
            display(newHead->next, 3);//newHead为空结点，应当从下一个开始遍历
            return newHead;
        }
        cur = next;
    }
}

 pro4

这是因为在当前节点不满足条件时，直接让cur=cur->next了，但是cur->next可能为空，即后几个结点不满足条件

所以需要依据cur->next的情况进行判断，如果不为空，说明还没到头，则continue

如果为空，说明到头了，直接return

Task* getBatch(int m){
    int key;
    cin>>key;
    Task *head=new Task;
    Task *cur=head;
    for(int i=0;i<m;i++){
        Task *newTask=new Task;
        cin>>newTask->ID>>newTask->load;
        newTask->key=key;
        newTask->next=NULL;
        cur->next=newTask;
        cur=cur->next;
    }
    return head->next;
}
void display(Task *head,int m){
    if(head==NULL){
        cout<<"OK"<<endl;
        return;
    }
    Task *cur=head;
    for(int i=0;i<m-1;i++){
        if(cur->next==NULL){
            cout<<"OK"<<endl;
            return;
        }
        cur=cur->next;
    }
    cout<<cur->ID<<" "<<cur->key<<" "<<cur->load<<endl;
}//插入到头
//插入到尾/中间，需要知道插入的小链表的头部x1和尾部x2,需要记录原来cur的next
//cur->next=x1;x2->next=原cur->next
Task* addBatch(Task *head,Task *h){
    if(h==NULL){
        return head;
    }
    //获取小链表尾部
    Task *tail=h;
    while(tail){
        if(tail->next==NULL){
            break;
        }
        tail=tail->next;
    }
    //插入到头部的特判
    if((head==NULL)||(h->key<head->key)){
        tail->next=head;
        return h;
    }
    //尾部/中间
    Task *cur=head;
    while(1){
        Task *next=cur->next;//下一个位置
        if(next==NULL){//插入到尾部
            cur->next=h;
            return head;
        }
        if(next->key>h->key){//插入到cur的后面，中间位置
            cur->next=h;
            tail->next=next;
            return head;
        }
        cur=next;
    }
}
Task* study(Task*head, int mi, int ma, int load){
    if(head==NULL){
        return NULL;
    }
    Task *newHead=new Task;
    Task *newCur=newHead;
    Task *cur=head;//遍历原链表的每个元素
    while(1){
        //不满足条件的情况，直接跳过
        if((cur->load>ma)||(cur->load<mi)){
            newCur->next=cur;
            newCur=newCur->next;
            cur=cur->next;
            continue;
        }
        //做不完了，退出
        if(load<cur->load){
            newCur->next=cur;
            //display(newHead->next,3);
            return newHead->next;
        }
        //做任务
        load-=cur->load;
        //如果做完了就退出
        Task *next=cur->next;
        if(next==NULL){
            //display(newHead->next,3);//并不是在这里面进行打印，是结束后还有一个display
            newCur->next=NULL;
            return newHead->next;
        }
        cur=next;
    }
}
//每批作业具有相同的优先值（不同批的任务的优先值不一样），由若干个不同的任务组成，每个任务都有唯一的编号
//小林同学会把每批作业先按照编号顺序整理好，然后按照这批作业的优先值，放入活页夹里。接下来，她将按照任务在活页夹的顺序依次把作业完成
//该批作业的第三个任务或者活页夹中的第三个任务,如果任务数少于3个，她会愉快地说一声"OK"

pro5
 

Task* getBatch(int m){
    int key;
    cin>>key;
    Task *head=new Task;
    Task *cur=head;
    for(int i=0;i<m;i++){
        Task *newTask=new Task;
        cin>>newTask->ID>>newTask->load;
        newTask->key=key;
        newTask->next=NULL;
        cur->next=newTask;
        cur=cur->next;
    }
    return head->next;
}
void display(Task *head,int m){
    if(head==NULL){
        cout<<"OK"<<endl;
        return;
    }
    Task *cur=head;
    for(int i=0;i<m-1;i++){
        if(cur->next==NULL){
            cout<<"OK"<<endl;
            return;
        }
        cur=cur->next;
    }
    cout<<cur->ID<<" "<<cur->key<<" "<<cur->load<<endl;
}//插入到头
//插入到尾/中间，需要知道插入的小链表的头部x1和尾部x2,需要记录原来cur的next
//cur->next=x1;x2->next=原cur->next
Task* addBatch(Task *head,Task *h){
    if(h==NULL){
        return head;
    }
    if(head==NULL){
        return h;
    }
    //获取小链表尾部
    Task *tail=h;
    while(tail){
        if(tail->next==NULL){
            break;
        }
        tail=tail->next;
    }
    //插入到头部的特判
    if(h->key<head->key){
        tail->next=head;
        return h;
    }
    //尾部/中间
    Task *cur=head;
    while(1){
        Task *next=cur->next;//下一个位置
        if(next==NULL){//插入到尾部
            cur->next=h;
            return head;
        }
        if(next->key>h->key){//插入到cur的后面，中间位置
            cur->next=h;
            tail->next=next;
            return head;
        }
        cur=next;
    }
}
Task* study(Task*head, int mi, int ma, int load){
    if(head==NULL){
        return NULL;
    }
    Task *newHead=new Task;
    Task *newCur=newHead;
    Task *cur=head;//遍历原链表的每个元素
    while(1){
        //不满足条件的情况，直接跳过
        if((cur->load>ma)||(cur->load<mi)){
            newCur->next=cur;
            newCur=newCur->next;
            //下一个cur可能是空的
            Task *next=cur->next;
            if(next!=NULL){
                cur=next;
                continue;
            }else{
                newCur->next=NULL;
                return newHead->next;
            }
        }
        //做不完了，退出
        if(load<=cur->load){
            newCur->next=cur;
            //display(newHead->next,3);
            return newHead->next;
        }
        //做任务
        load-=cur->load;
        //如果做完了就退出
        Task *next=cur->next;
        if(next==NULL){
            //display(newHead->next,3);//并不是在这里面进行打印，是结束后还有一个display
            newCur->next=NULL;
            return newHead->next;
        }
        cur=next;
    }
}
//每批作业具有相同的优先值（不同批的任务的优先值不一样），由若干个不同的任务组成，每个任务都有唯一的编号
//小林同学会把每批作业先按照编号顺序整理好，然后按照这批作业的优先值，放入活页夹里。接下来，她将按照任务在活页夹的顺序依次把作业完成
//该批作业的第三个任务或者活页夹中的第三个任务,如果任务数少于3个，她会愉快地说一声"OK"

唯一区别就在于做不完的条件，如果是<=就退出，那么此时的结点还是会包含进newHead链表里的，但如果==的话，实际上是可以完成的，所以就错了

把load<=改为<即可AC

7-6

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

int main(){
    string t1,t2;
    cin>>t1>>t2;
    int rt1=stoi(t1);
    int mm=rt1%100;
    int hh=rt1/100;
    int pastmm=stoi(t2);
    mm+=pastmm;
    hh+=mm/60;
    mm=mm%60;
    cout<<hh<<mm<<endl;
    return 0;
}

不要+的，知道原来问题出在哪了，当totalM为60时，最终结果是10

问题关键在于需要保证分钟必须是一个两位的

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

int main(){
    int rt1,pastmm;
    cin>>rt1>>pastmm;
    int mm=rt1%100;
    int hh=rt1/100;
    int totalM=hh*60+mm;
    totalM+=pastmm;
    printf("%d%02d",totalM/60,totalM%60);
    return 0;
}

7-8 正整数A+B

//空格的处理，getline(cin,string)
//如何判断是正整数  isdigit(int c) stoi
#include<iostream>
#include<sstream>
using namespace std;
bool valid(string in){
    if(in.empty()){
        return false;
    }
    for(auto c:in){
        if(!isdigit(c)){
            return false;
        }
    }
    return true;
}
int main(){
    string in;
    getline(cin,in);
    istringstream iss(in);
    string a,b;
    if(getline(iss,a,' ')&&getline(iss,b)){
        if(valid(a)&&valid(b)){
            cout<<a<<" + "<<b<<" = "<<stoi(a)+stoi(b)<<endl;
        }else if(valid(b)){
            cout<<"? + "<<b<<" = ?"<<endl;
        }else if(valid(a)){
            cout<<a<<" + ? = ?"<<endl;
        }else{
            cout<<"? + ? = ?"<<endl;
        }
    }else{
        cout<<" ? + ? = ?"<<endl;
    }
    return 0;
}

需要增加一段对数字处于1，1000以内的判断

此外优化了代码结构

//空格的处理，getline(cin,string)
//如何判断是正整数  isdigit(int c) stoi
#include<iostream>
#include<sstream>
using namespace std;
bool valid(string in){
    if(in.empty()){
        return false;
    }
    for(auto c:in){
        if(!isdigit(c)){
            return false;
        }
    }
    int num=stoi(in);
    if(num<1||num>1000){
        return false;
    }
    return true;
}
int main(){
    string in;
    getline(cin,in);
    istringstream iss(in);
    string a,b;
    getline(iss,a,' ');
    getline(iss,b);
    bool flag=true;
    if(valid(a)){
        cout<<a;
    }else{
        cout<<"?";
        flag=false;
    }
    cout<<" + ";
    if(valid(b)){
        cout<<b;
    }else{
        cout<<"?";
        flag=false;
    }
    cout<<" = ";
    if(flag){
        cout<<stoi(a)+stoi(b)<<endl;
    }else{
        cout<<"?";
    }
    return 0;
}

主要记住sstream、getline,stoi,isdigit的用法

7-9 个位数统计

#include<iostream>
#include<map>
using namespace std;
int main(){
    string num;
    cin>>num;
    map<char,int>m;
    for(auto c:num){
        m[c]++;
    }
    for(auto item:m){
        cout<<item.first<<":"<<item.second<<endl;
    }
    return 0;
}

主要就是复习map的使用

还有就是map中的元素，就是一个个的数对，并非指针，是实际的数据，直接通过.获取

7-10 考试座位号

#include<iostream>
#include<map>
using namespace std;
struct tmp{
    string id;
    int examId;
};
int main(){
    map<int,tmp>m;
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        tmp* t=new tmp;
        int tryId;
        cin>>t->id>>tryId>>t->examId;
        m[tryId]=*t;
    }
    cin>>n;
    for(int i=0;i<n;i++){
        int query;
        cin>>query;
        cout<<m[query].id<<" "<<m[query].examId<<endl;
    }
    return 0;
}

还是哈希表map,只不过要注意以下键和值，在查找时用的是键，通过键找到值，

要求打印出准考证号和考试号，所以值可以用一个结构体

结构体分配内存是在堆上，在创建时取得的是一个指针，所以在存的时候应当对指针解引用得到指针所指向的实际值

也可以让哈希表不存实际数据，就是存指针，然后修改以下数据访问方式，这样还能更节省一些内存

#include<iostream>
#include<map>
using namespace std;
struct tmp{
    string id;
    int examId;
};
int main(){
    map<int,tmp*>m;
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        tmp* t=new tmp;
        int tryId;
        cin>>t->id>>tryId>>t->examId;
        m[tryId]=t;
    }
    cin>>n;
    for(int i=0;i<n;i++){
        int query;
        cin>>query;
        cout<<m[query]->id<<" "<<m[query]->examId<<endl;
    }
    return 0;
}

7-11 念数字

stoi必须要求参数类型是string,char类型就不行

可以通过string str(1,char)来构造string

也可以通过ASCII码运算得到

#include<iostream>
#include<string>
#include<sstream>
using namespace std;
string arr[11]={"fu","ling","yi","er","san","si","wu","liu","qi","ba","jiu"};
int main(){
    string in;
    cin>>in;
    // for(auto c:in){
    //     if(c=='-'){
    //         cout<<arr[0]<<" ";
    //     }else{
    //         cout<<arr[(c-'0')+1]<<" ";
    //     }
    // }
    for(size_t i=0;i<in.size();i++){
        if(in[i]=='-'){
            cout<<arr[0];
        }else{
            cout<<arr[(in[i]-'0')+1];
        }
        if(i!=in.size()-1){
            cout<<" ";
        }
    }
    return 0;
}

前一种方式会格式错误，就是最后不应该有一个空格

以后面这种方式进行遍历 

也可以用map,代码更精简

map就是两种数据结构之间建立了一个映射关系，通过其中一个就能找到另一个

#include<iostream>
#include<string>
#include<sstream>
#include<map>
using namespace std;
string arr[11]={"fu","ling","yi","er","san","si","wu","liu","qi","ba","jiu"};
int main(){
    string in;
    cin>>in;
    map<char,string>m;
    m['-']="fu";
    m['0']="ling";
    m['1']="yi";
    m['2']="er";
    m['3']="san";
    m['4']="si";
    m['5']="wu";
    m['6']="liu";
    m['7']="qi";
    m['8']="ba";
    m['9']="jiu";
    // for(auto c:in){
    //     if(c=='-'){
    //         cout<<arr[0]<<" ";
    //     }else{
    //         cout<<arr[(c-'0')+1]<<" ";
    //     }
    // }
    for(size_t i=0;i<in.size();i++){
        cout<<m[in[i]];
        if(i!=in.size()-1){
            cout<<" ";
        }
    }
    return 0;
}

7-12 检查密码

测试二过不去的原因就是因为输入的字符串里面有空格

PTA上的题都要注意空格的问题

这是因为吸收了换行符，使其成为了输入的一个密码

应当多一个操作，getchar来消除空格

#include<iostream>
#include<string>
using namespace std;
bool check(string in){
    bool hasNum=false;
    bool hasLet=false;
    for(auto c:in){
        if(((c>='a')&&(c<='z'))||((c>='A')&&(c<='Z'))){
            hasLet=true;
        }else if((c>='0')&&(c<='9')){
            hasNum=true;
        }else if(c=='.'){
            continue;
        }else{
            cout<<"Your password is tai luan le."<<endl;
            return false;
        }
    }
    if(!hasNum){
        cout<<"Your password needs shu zi."<<endl;
        return false;
    }
    if(!hasLet){
        cout<<"Your password needs zi mu."<<endl;
        return false;
    }
    return true;
}
int main(){
    int n;
    cin>>n;
    getchar();
    for(int i=0;i<n;i++){
        string in;
        getline(cin,in);
       // cout<<"此时输入，得到的字符串是"<<in<<endl;
        if(in.size()<6){
            cout<<"Your password is tai duan le."<<endl;
            continue;
        }
        if(check(in)){
            cout<<"Your password is wan mei."<<endl;
        }
    }
    return 0;
}

7-13 谁是赢家

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

int main(){
    int caipan=0;
    int vote1,vote2;
    cin>>vote1>>vote2;
    for(int i=0;i<3;i++){
        int tmp;
        cin>>tmp;
        if(tmp==0){
            caipan++;
        }
    }
    if(caipan==3){
        cout<<"The winner is a: "<<vote1<<" + "<<caipan<<endl;
        return 0;
    }
    if(caipan==0){
        cout<<"The winner is b: "<<vote2<<" + "<<3-caipan<<endl;
        return 0;
    }
    if(vote1>vote2){
        cout<<"The winner is a: "<<vote1<<" + "<<caipan<<endl;
    }else{
        cout<<"The winner is b: "<<vote2<<" + "<<3-caipan<<endl;
    }
    return 0;
}

7-14 不变初心数

就是lambda函数在用的时候，如果需要用到其它的lambda函数，就必须进行捕获

这个auto相当于其类型，是一种函数，不能直接指定为返回值类型

lambda函数的函数名类似于一种变量名

实际上真正的Lambda函数只有【】开始的那部分，前面只是类似于一种函数句柄

如排序时就可以直接定义lambda函数体而无需声明函数名

    std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
        return a > b;
    });

#include<iostream>
#include<string>
using namespace std;
//暴力：获取数的每位数字，进行相加
//然后乘，重复这一过程
int check(int num){
    auto getSum=[](int num)->int{
        int sum=0;
        int cur=num;
        while(cur){
            sum+=(cur%10);
            cur/=10;
        }
        return sum;
    };
    int sum=getSum(num);
    auto subCheck=[getSum](int newNum,int sum)->bool{
        return getSum(newNum)==sum;
    };
    for(int i=2;i<=9;i++){
        if(!subCheck(i*num,sum)){
            return -1;
        }
    }
    return sum;
}
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        int num;
        cin>>num;
        int res=check(num);
        if(res==-1){
            cout<<"NO"<<endl;
        }else{
            cout<<res<<endl;
        }
    }
    return 0;
}

7-15 新胖子公式

应该就是考察格式化输出，直接用printf即可

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

int main(){
    double a,b;
    cin>>a>>b;
    double res=a/(b*b);
    printf("%0.1f\n",res);
    if(res>25){
        cout<<"PANG"<<endl;
    }else{
        cout<<"Hai Xing"<<endl;
    }
    return 0;
}

7-16 幸运彩票

太抽象了，写着写着蒙了，都忘了输入了

#include<iostream>
#include<string>
using namespace std;
bool check(string num){
    int sum1=0;
    int sum2=0;
    for(int i=0;i<3;i++){
        //cout<<"num[i]为"<<num[i]<<endl;
        sum1+=(num[i]-'0');
    }
    for(int i=3;i<6;i++){
        sum2+=(num[i]-'0');
    }
    //cout<<"此时sum1是  "<<sum1<<"sum2是  "<<sum2<<endl;
    return sum1==sum2;
}
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        string num;
        cin>>num;
        if(check(num)){
            cout<<"You are lucky!"<<endl;
        }else{
            cout<<"Wish you good luck."<<endl;
        }
    }
    return 0;
}

7-17 降价提醒机器人

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

int main(){
    int n;
    double m,t;
    cin>>n>>m;
    for(int i=0;i<n;i++){
        cin>>t;
        if(t<m){
            printf("On Sale! %.1f\n",t);
        }
    }
    return 0;
}

7-18 胎压监测

#include<iostream>
#include<string>
using namespace std;
//如果所有轮胎的压力值与它们中的最大值误差在一个给定阈值内，并且都不低于系统设定的最低报警胎压，则说明情况正常，不报警；
int main(){
    int s[4];
    int low,bias;
    for(int i=0;i<4;i++){
        cin>>s[i];
    }
    cin>>low>>bias;
    int maxS=max(max(s[0],s[1]),max(s[2],s[3]));//对于数组应该有更优雅的方式
    int cnt=0,index=0;
    for(int i=0;i<4;i++){
        if((abs(s[i]-maxS)>bias)||(s[i]<low)){
            cnt++;
            index=i;
        }
        if(cnt>=2){
            cout<<"Warning: please check all the tires!"<<endl;
            return 0;
        }
    }
    if(cnt==1){
        printf("Warning: please check #%d!\n",index+1);
    }else{
        cout<<"Normal"<<endl;
    }
    return 0;
}

一个更优雅的版本

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;

int main() {
    vector<int> pressures(4);
    int low, bias;

    // 读取输入
    for (int i = 0; i < 4; ++i) {
        cin >> pressures[i];
    }
    cin >> low >> bias;

    // 找到最大胎压值
    int maxPressure = *max_element(pressures.begin(), pressures.end());

    // 统计需要报警的轮胎数量
    int count = count_if(pressures.begin(), pressures.end(), [maxPressure, bias, low](int p) {
        return abs(p - maxPressure) > bias || p < low;
    });

    // 输出结果
    if (count >= 2) {
        cout << "Warning: please check all the tires!" << endl;
    } else if (count == 1) {
        auto it = find_if(pressures.begin(), pressures.end(), [maxPressure, bias, low](int p) {
            return abs(p - maxPressure) > bias || p < low;
        });
        int index = distance(pressures.begin(), it) + 1;
        cout << "Warning: please check #" << index << "!" << endl;
    } else {
        cout << "Normal" << endl;
    }

    return 0;
}

7-19 大笨钟的心情

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

int main(){
    int arr[24];
    for(int i=0;i<24;i++){
        cin>>arr[i];
    }
    int query;
    cin>>query;
    if(query<1||query>24){
        return 0;
    }
    while(1){
        cout<<arr[query]<<" "<<(arr[query]>50?"Yes":"No");
        cin>>query;
        if(query>=1&&query<=24){
            cout<<endl;
        }else{
            return 0;
        }
    }
    return 0;
}

这个完全是因为没有审题，query是要0和23之间，自己写的是1和24之间，修改完即可

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

int main(){
    int arr[24];
    for(int i=0;i<24;i++){
        cin>>arr[i];
    }
    int query;
    cin>>query;
    if(query<0||query>23){
        return 0;
    }
    while(1){
        cout<<arr[query]<<" "<<(arr[query]>50?"Yes":"No");
        cin>>query;
        if(query>=0&&query<=23){
            cout<<endl;
        }else{
            return 0;
        }
    }
    return 0;
}

7-20 统计工龄

#include<iostream>
#include<string>
#include<map>
using namespace std;
int main(){
    int n;
    cin>>n;
    map<int,int>m;
    for(int i=0;i<n;i++){
        int tmp;
        cin>>tmp;
        m[tmp]++;
    }
    for(auto item:m){
        cout<<item.first<<":"<<item.second<<endl;
    }
    return 0;
}

完全是map的题

7-22 符号配对

pro1

如何处理/*?这东西要占俩次识别

就是遇到/和*后，连着后面进行一次判断，然后让i++跳过这个整体，以免重复识别如/*/就行了

pro2

 

byd的switch，break是只能跳出switch的，跳不出包含switch的while和for

这点确实难用，不如if,else；

要直接改的话就加个flag,但是注意需要在while和for里一起加，不然会强制读完一行，可能会打出两个NO（如上所示）

#include <iostream>
#include <string>
#include <stack>
using namespace std;

stack<int> st;
bool exitFlag = false; // 标志变量，用于控制外部 while 循环的退出
bool check() {
    // 检查栈是否为空，确保所有左括号都有匹配的右括号
    if (!st.empty()) {
        cout << "NO" << endl;
        int value =st.top();
        switch (value) {
            case 1: cout << "/*-?"; break;
            case 2: cout << "(-?"; break;
            case 3: cout << "[-?"; break;
            case 4: cout << "{-?"; break;
        }
        cout << endl;
        return false;
    }
    return true;
}
void anotherP(int choice){
    switch(choice){
            case 1: cout << "/*-?"; break;
            case 2: cout << "(-?"; break;
            case 3: cout << "[-?"; break;
            case 4: cout << "{-?"; break;
    }
}
//入栈进行判断
//遇到右括号，得到栈顶
//如果栈内无元素，就报缺失左符号
//如果有元素，和右括号进行判断，如果不同，报缺失右符号
//最后检查栈是否为空，不为空就报此时栈顶的左符号缺失
int main() {
    string text;
    while (!exitFlag) { // 使用标志变量控制 while 循环
        getline(cin, text);
        //cout << "此次读取到的一行数据是" << text << endl;
        for (size_t i = 0; i < text.size()&&!exitFlag; i++) {
            switch (text[i]) {
            case '/':
                if ((i != text.size() - 1) && (text[i + 1] == '*')) {
                    st.push(1);
                    i++;
                }
                break;
            case '(':
                st.push(2);
                break;
            case '[':
                st.push(3);
                break;
            case '{':
                st.push(4);
                break;
            case '*':
                if ((i != text.size() - 1) && (text[i + 1] == '/')) {
                    if (st.size() > 0) {
                        int value = st.top();
                        st.pop();
                        if (value != 1) {
                            cout << "NO" << endl;
                            //cout << "/*-?" << endl;
                            anotherP(value);
                            exitFlag = true; // 设置标志变量，跳出外部 while 循环
                        }
                    }
                    else { // 栈内无值，说明右过剩了
                        cout << "NO" << endl;
                        cout << "?-*/" << endl;
                        exitFlag = true; // 设置标志变量，跳出外部 while 循环
                    }
                    i++;
                }
                break;
            case ')':
                if (st.size() > 0) {
                    int value = st.top();
                    st.pop();
                    if (value != 2) {
                        cout << "NO" << endl;
                        anotherP(value);
                        exitFlag = true; // 设置标志变量，跳出外部 while 循环
                    }
                }
                else {
                    cout << "NO" << endl;
                    cout << "?-)" << endl;
                    exitFlag = true; // 设置标志变量，跳出外部 while 循环
                }
                break;
            case ']':
                if (st.size() > 0) {
                    int value = st.top();
                    st.pop();
                    if (value != 3) {
                        cout << "NO" << endl;
                        anotherP(value);
                        exitFlag = true; // 设置标志变量，跳出外部 while 循环
                    }
                }
                else {
                    cout << "NO" << endl;
                    cout << "?-]" << endl;
                    exitFlag = true; // 设置标志变量，跳出外部 while 循环
                }
                break;
            case '}':
                if (st.size() > 0) {
                    int value = st.top();
                    st.pop();
                    if (value != 4) {
                        cout << "NO" << endl;
                        anotherP(value);
                        exitFlag = true; // 设置标志变量，跳出外部 while 循环
                    }
                }
                else {
                    cout << "NO" << endl;
                    cout << "?-}" << endl;
                    exitFlag = true; // 设置标志变量，跳出外部 while 循环
                }
                break;
            case '.':
                if (text.size() == 1) {
                    if (check()) {
                        cout << "YES" << endl;
                    }
                    exitFlag = true; // 设置标志变量，跳出外部 while 循环
                    break;
                }
            }
        }
    }



    return 0;
}

上面代码能过，但确实太屎山了，不想改了，就这样吧

7-23 栈操作的合法性

#include<iostream>
#include<string>
using namespace std;
int m;
bool check(string str){
    int cnt=0;
    for(auto c:str){
        if(c=='S'){
            if(cnt==m){
                return false;
            }
            cnt++;
        }
        if(c=='X'){
            if(cnt<=0){
                return false;
            }
            cnt--;
        }
    }
    if(cnt==0){
        return true;
    }else{
        return false;
    }
}
int main(){
    int n;
    cin>>n>>m;
    for(int i=0;i<n;i++){
        string s;
        cin>>s;
        if(check(s)){
            cout<<"YES"<<endl;
        }else{
            cout<<"NO"<<endl;
        }
    }
    return 0;
}

7-24 链表去重

pro1

#include<iostream>
#include<string>
#include<map>
#include<set>
using namespace std;
struct node {
    string add;//还是保留着吧，因为最后打印要地址
    int key;
    string nextAdd;
};
int main() {
    map<string, node*>m;//记录地址与对应结点的映射
    set<int>hasKey;
    string beginAdd;
    int n;
    cin >> beginAdd >> n;
    //构造地址和结点的映射表
    for (int i = 0; i < n; i++) {
        int key;
        string tmp, add;
        cin >> add >> key >> tmp;
        node* nod = new node;
        nod->key = key;
        nod->nextAdd = tmp;
        nod->add = add;
        m[add] = nod;
    }
    //串起所有结点形成链表
    node* head = m[beginAdd];
    node* deleteH = new node;
    node* dcur = deleteH;
    node* cur = head;
    hasKey.insert(abs(cur->key));
    while (1) {
        string nextAdd = cur->nextAdd;
        if (nextAdd == "-1") {
            break;
        }
        node* next = m[nextAdd];
        //依据键值情况，决定怎么加
        if (hasKey.find(abs(next->key)) != hasKey.end()) {//键值已经有了,加入到删除链表当中
            dcur->nextAdd = next->add;
            cur->nextAdd = next->nextAdd;//调整cur->next为被删除结点的下一个位置
            dcur = m[dcur->nextAdd];//此时dcur指向的是被删除结点，与cur->next无关
            dcur->nextAdd = "-1";
        }else {//加入到链表当中
            cur->nextAdd = next->add;
            hasKey.insert(abs(next->key));
            cur = m[cur->nextAdd];//向后移动链表结点
        }
    }
    //调回头部,准备打印
    cur = head;
    dcur = m[deleteH->nextAdd];
    auto display = [&m](node* list) {
        while (1) {
            string nextAdd = list->nextAdd;
            cout << list->add << " " << list->key << " " << nextAdd << endl;
            if (nextAdd == "-1") {
                break;
            }
            else {
                list = m[nextAdd];
            }
        }
        };
    display(cur);
    display(dcur);
    return 0;
}

pro2

#include<iostream>
#include<string>
#include<map>
#include<set>
using namespace std;
struct node {
    string add;//还是保留着吧，因为最后打印要地址
    int key;
    string nextAdd;
};
int main() {
    map<string, node*>m;//记录地址与对应结点的映射
    set<int>hasKey;
    string beginAdd;
    int n;
    cin >> beginAdd >> n;
    //构造地址和结点的映射表
    for (int i = 0; i < n; i++) {
        int key;
        string tmp, add;
        cin >> add >> key >> tmp;
        node* nod = new node;
        nod->key = key;
        nod->nextAdd = tmp;
        nod->add = add;
        m[add] = nod;
    }
    //串起所有结点形成链表
    node* head = m[beginAdd];
    node* deleteH = new node;
    node* dcur = deleteH;
    node* cur = head;
    hasKey.insert(abs(cur->key));
    while (1) {
        string nextAdd = cur->nextAdd;
        if (nextAdd == "-1") {
            break;
        }
        node* next = m[nextAdd];
        //依据键值情况，决定怎么加
        if (hasKey.find(abs(next->key)) != hasKey.end()) {//键值已经有了,加入到删除链表当中
            dcur->nextAdd = next->add;
            cur->nextAdd = next->nextAdd;//调整cur->next为被删除结点的下一个位置
            dcur = m[dcur->nextAdd];//此时dcur指向的是被删除结点，与cur->next无关
            dcur->nextAdd = "-1";
        }else {//加入到链表当中
            cur->nextAdd = next->add;
            hasKey.insert(abs(next->key));
            cur = m[cur->nextAdd];//向后移动链表结点
        }
    }
    //调回头部,准备打印
    cur = head;
    dcur = m[deleteH->nextAdd];
    auto display = [&m](node* list) {
        while (1) {
            string nextAdd = list->nextAdd;
            cout << list->add << " " << list->key << " " << nextAdd << endl;
            if (nextAdd == "-1") {
                break;
            }
            else {
                list = m[nextAdd];
            }
        }
        };
    display(cur);
    display(dcur);
    return 0;
}

就是在打印的时候，如果（被删除）列表如果是空的话，就没有考虑，添上后即可

#include<iostream>
#include<string>
#include<map>
#include<set>
using namespace std;
struct node {
    string add;//还是保留着吧，因为最后打印要地址
    int key;
    string nextAdd;
};
int main() {
    map<string, node*>m;//记录地址与对应结点的映射
    set<int>hasKey;
    string beginAdd;
    int n;
    cin >> beginAdd >> n;
    //构造地址和结点的映射表
    for (int i = 0; i < n; i++) {
        int key;
        string tmp, add;
        cin >> add >> key >> tmp;
        node* nod = new node;
        nod->key = key;
        nod->nextAdd = tmp;
        nod->add = add;
        m[add] = nod;
    }
    //串起所有结点形成链表
    node* head = m[beginAdd];
    node* deleteH = new node;
    node* dcur = deleteH;
    node* cur = head;
    hasKey.insert(abs(cur->key));
    while (1) {
        string nextAdd = cur->nextAdd;
        if (nextAdd == "-1") {
            break;
        }
        node* next = m[nextAdd];
        //依据键值情况，决定怎么加
        if (hasKey.find(abs(next->key)) != hasKey.end()) {//键值已经有了,加入到删除链表当中
            dcur->nextAdd = next->add;
            cur->nextAdd = next->nextAdd;//调整cur->next为被删除结点的下一个位置
            dcur = m[dcur->nextAdd];//此时dcur指向的是被删除结点，与cur->next无关
            dcur->nextAdd = "-1";
        }
        else {//加入到链表当中
            cur->nextAdd = next->add;
            hasKey.insert(abs(next->key));
            cur = m[cur->nextAdd];//向后移动链表结点
        }
    }
    //调回头部,准备打印
    cur = head;
    dcur = m[deleteH->nextAdd];
    auto display = [&m](node* list) {
        if (list == NULL) {
            return;
        }
        while (1) {
            string nextAdd = list->nextAdd;
            cout << list->add << " " << list->key << " " << nextAdd << endl;
            if (nextAdd == "-1") {
                break;
            }
            else {
                list = m[nextAdd];
            }
        }
        };
    display(cur);
    display(dcur);
    return 0;
}

7-25 愿天下有情人都是失散多年的兄妹

因为没有考虑到-1的情况

找到原因了，一个致命的问题是，输入的那些人的父母，可能就没有构成一个person加入到map表当中，就是它们的id只是出现在子女的person行当中，但是自己却并不存在，有的可能存在

#include<iostream>
#include<string>
#include<map>
using namespace std;
struct person {
    string id;
    char sex;
    string fid;
    string mid;
};
map<string, person*>m;
bool check(person* a, person* b, int dep) {//父母为1，祖父母为2，曾祖父母为3，高祖父母为4
    // cout << "此时检查的俩人是" << a->id << " " << b->id <<"它们的父id分别是"<<a->fid<<" b:"<<b->fid<<endl;
    // cout << "开始递归检查，此时深度为" << dep << endl;
    if (dep >= 5) {
        return true;
    }
    //如果不可考的话，那么相应性别的就不再进行检查,并且不再继续往上追溯
    //     //只要双方父亲有一个是-1，就无法再追溯
    if ((a->fid == "-1") || (b->fid == "-1") /* || (a->mid == -1) || (b->mid == -1)*/) {
        return true;
    }
    //检查爸爸
    if ((a->fid != "-1") && (a->fid == b->fid)) {
        return false;
    }
    //检查妈妈
    if ((a->mid != "-1") && (a->mid == b->mid)) {
        return false;
    }
    //对于不存在的人，也无法继续追溯，只好允许了
    if ((m.find(a->fid) == m.end()) || (m.find(b->fid) == m.end())) {
        return true;
    }
    return check(m[a->fid], m[b->fid], dep + 1);
}
int main() {
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        person* p = new person;
        string id, fid, mid;
        char sex;
        cin >> id >> sex >> fid >> mid;
        p->id = id;
        p->fid = fid;
        p->mid = mid;
        p->sex = sex;
        m[id] = p;
    }
    cin >> n;
    for (int i = 0; i < n; i++) {
        string a, b;
        cin >> a >> b;
        if (m[a]->sex == m[b]->sex) {
            cout << "Never Mind" << endl;
            continue;
        }
        if (check(m[a], m[b], 1)) {
            cout << "Yes" << endl;
        }
        else {
            cout << "No" << endl;
        }
    }
    return 0;
}

如果==-1的判断发生在下一层的话，会导致递归不好进行

所以不如把==-1的判断转移到本层

原因就是我自己写的是map,如果把==-1直接移到开始的话，会在递归的时候，在map当中根本找不到对应指针，从而报错

 就是它最后查询的时候，可能会查询一开始压根就没插入的元素，那些人是只能在输入的时候被动创建的

一个自认为比较优雅的代码

#include<iostream>
#include<string>
#include<map>
using namespace std;
struct person {
    char sex;
    int fid, mid;
    person() :sex('x'), fid(-1), mid(-1) {}
}p[100000];
bool check(int a, int b, int dep) {//父母为1，祖父母为2，曾祖父母为3，高祖父母为4//判断父母相等在0
    //cout << "此时检查的俩人是" << a << " " << b << "它们的父id分别是" << p[a].fid << " b:" << p[b].fid << endl;
    //cout << "开始递归检查，此时深度为" << dep << endl;
    if ((a == -1) || (b == -1)) { return true; }//检查此层的人是否存在,把==-1的逻辑转移到每层的开始
    if (dep >= 4) { return true; }
    //检查此层人是否通亲
    if ((p[a].fid != -1) && (p[a].fid == p[b].fid)) { 
        //cout << "父亲相同，为" << a << "和" << b << "a的父亲为" << p[a].fid << "b的父亲为" << p[b].fid << endl;
        return false; }//检查爸爸
    if ((p[a].mid != -1) && (p[a].mid == p[b].mid)) { return false; }//检查妈妈
    return check(p[a].fid, p[b].fid, dep + 1) && check(p[a].fid, p[b].mid, dep + 1) && check(p[a].mid, p[b].fid, dep + 1) && check(p[a].mid, p[b].mid, dep + 1);
}
int main() {
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        int id;
        char sex;
        int fid, mid;
        cin >> id >> sex >> fid >> mid;
        p[id].sex = sex;
        p[id].fid = fid;
        if(fid!=-1){p[fid].sex='M';}
        p[id].mid = mid;
        if(mid!=-1){p[mid].sex='F';}
        //cout << "接收到的id是" << id << " 它的信息为" << p[id].sex << " " << p[id].fid << " " << p[id].mid << endl;
    }
    cin >> n;
    for (int i = 0; i < n; i++) {
        int a, b;
        cin >> a >> b;
        if (p[a].sex == p[b].sex) {
            cout << "Never Mind" << endl;
            continue;
        }
        if (check(a, b, 0)) {//必须从自己开始，不然会在一开始就丢情况
            cout << "Yes" << endl;
        }
        else {
            cout << "No" << endl;
        }
    }
    return 0;
}

7-26 深入虎穴

一开始想的就是出口是1号门，然后从1号门开始bfs

#include<iostream>
#include<vector>
#include<queue>
#include<climits>
using namespace std;
// int arr[100005];//记录的是每扇门所能到达的最远位置
// //
int main(){
    vector<vector<int>>graph;
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        int m,p;
        vector<int>node;
        cin>>m;
        for(int j=0;j<m;j++){
            cin>>p;
            node.push_back(p);
        }
        graph.push_back(node);
    }
    vector<int>dis(n+1,INT_MAX);
    queue<int>q;
    // for(auto gate:graph[0]){
    //     q.push(gate);
    // }
    //int maxnum=1;
    dis[1]=0;
    q.push(1);
    while(q.size()!=0){
        int cur=q.front();
        for(auto gate:graph[cur-1]){
            q.push(gate);
            if(dis[gate]==INT_MAX){
                dis[gate]=dis[cur]+1;
            }
        }
        //maxnum+=1;
        //cout<<"当前到达的编号是"<<cur<<endl;
        // if(q.size()==1){
        //     cout<<cur<<endl;
        //     break;
        // }
        q.pop();
    }
    int maxnum=0;
    int index=1;
    for(int i=1;i<=n;i++){
        if(dis[i]>maxnum){
            maxnum=dis[i];
            index=i;
        }
    }
    cout<<index<<endl;
    //cout<<maxnum;
    return 0;
}

如果有多个出口？没指定出口？

就是输入的时候的索引是从1开始的，但是存的时候是从0开始的

vector<int>n()就是动态分配内存

就是在原来的基础上，加一个入度，完成对入口的判断就行了

#include<iostream>
#include<vector>
#include<queue>
#include<climits>
using namespace std;
int n;
struct node {
    int in;
    vector<int>adj;
    int dis;
    node() :in(0), dis(-1) {}
};
int main() {
    cin >> n;
    vector<node>graph(n+1);
    for (int i = 0; i < n; i++) {
        int m, p;
        cin >> m;
        for (int j = 0; j < m; j++) {
            cin >> p;
            graph[i+1].adj.push_back(p);
            graph[p].in++;
        }
    }
    queue<int>q;
    //遍历所有结点，
    for (int i = 1; i <= n; i++) {
        if (graph[i].in == 0) {
            q.push(i);
            graph[i].dis = 0;
            break;
        }
    }
    while (q.size() != 0) {
        int cur = q.front();
        for (int gate : graph[cur].adj) {
            q.push(gate);
            if (graph[gate].dis == -1) {
                graph[gate].dis = graph[cur].dis + 1;
            }
        }
        q.pop();
    }
    int maxnum = -1;
    int index = 0;
    for (int i = 1; i <= n; i++) {
        //cout << "此时结点的距离为" << graph[i].dis << endl;
        if (graph[i].dis > maxnum) {
            maxnum = graph[i].dis;
            index = i;
        }
    }
    cout << index << endl;
    //cout<<maxnum;
    return 0;
}

考试&评价

每个人题不一样

考试机子上比较抽象的一点是在遍历vector的时候不能直接用int

可能是c++版本的问题？按照编译器信息，用long unsigned int遍历即可

byd三年考三次pta,大一程序设计，大二数据结构，大三换皮叫做专业能力测试（byd这叫专业能力？）

无敌了