姜郎财尽 2023-11-21 03:11 采纳率: 50%
浏览 9
已结题

CSP认证:201809-3 元素选择器

CSP认证考试:
201809-3 元素选择器
虽然自己测试的时候都是对的,但只能得标签的四十分,带id和后代选择器的都错了,实在不能理解。

#include<bits/stdc++.h>
using namespace std;
int n,m;
struct node{
    string name;
    string id;
    int line;
    int level;
    vector<node*>son;
    node *mother;
};
vector<vector<int>> ans;
//
string lower(string a){
    int length=a.size(); 
    for(int i=0;i<length;i++){
        if(a[i]>='A' && a[i]<='Z'){
            a[i]=a[i]+'a'-'A';
        }
    }
    return a;
}
//
int cmp(int a,int b){
    return a<b;
} 
//
void find(vector<int>&ans2,node* head,vector<string>&S,int now){
    int length=head->son.size(); 
    for(int i=0;i<length;i++){
        if( lower(head->son[i]->name)==lower(S[now]) ) {
            if(now==S.size()-1) ans2.push_back( head->son[i]->line );
            else find(ans2,head->son[i],S,now+1);
        }
        else if( head->son[i]->id==S[now] ){
            if(now==S.size()-1) ans2.push_back( head->son[i]->line );
            else find(ans2,head->son[i],S,now+1);
        }
        else{
            find(ans2,head->son[i],S,now);
        }
    }
}
//
int main(){
    cin>>n>>m;  
    getchar();
    node* head=new node;  head->name="原初";
    node* pre=new node;
    node* last_line=new node;//上一行 
    //
    for(int i=0;i<n;i++){
        string str;
        getline(cin,str);
        //读入了一句html 
        int level=0; 
        while(str[0]=='.') {
            level++;
            str.erase(str.begin());
        }
        level=level/2+1;
        //知道了分级是多少 
        node* temp=new node;
        temp->level=level;
        if(level==1){//等级为1,开启新的族谱 
            temp->mother=head;
            head->son.push_back(temp);
            last_line=temp;
        }
        else if(last_line->level==level){
            temp->mother=last_line->mother;
            temp->mother ->son.push_back(temp);
            last_line=temp;
        }
        else if(last_line->level+1==level){
            temp->mother=last_line;
            temp->mother ->son.push_back(temp);
            last_line=temp;
        }
        else if(last_line->level > level){
            while(last_line->level >= level){
                last_line=last_line->mother;
            }
            last_line->son.push_back(temp);
            last_line=temp;
        }
        //确定该行的母亲,母亲认子 
        temp->line=i;
        int flag=0;
        for(int j=0;j<str.size();j++){
            if(str[j]==' '){
                flag=1;
                continue;
            }
            if(flag==0) {
                temp->name.push_back(str[j]);
            }
            else temp->id.push_back(str[j]);
        }
        //读入内容,都有name,但不一定有id 
    }
    //数据储存完成,分级完成,母子确认完成
    for(int i=0;i<m;i++){
        vector<string> S;
        string str;
        getline(cin,str);
        string con;
        for(int j=0;j<str.size();j++){
            if(str[j]==' '){
                S.push_back(con);
                con.clear();
                continue;
            }
            con.push_back(str[j]);
        }    
        S.push_back(con);
        //
        vector<int> ans2;
        find(ans2,head,S,0);
        ans.push_back(ans2);
    } 
    //
    for(int i=0;i<ans.size();i++){
        sort(ans[i].begin(),ans[i].end(),cmp);
        cout<<ans[i].size();
        for(int j=0;j<ans[i].size();j++){
            cout<<" "<<ans[i][j]+1;
        }
        if(i!=ans.size()-1)cout<<"\n";
    }
    return 0;
}


  • 写回答

14条回答 默认 最新

  • 专家-赤兔[在线] 2023-11-21 12:59
    关注
    获得0.75元问题酬金
    #include <iostream>
    #include <vector>
    #include <string>
    #include <map>
    #include <stdlib.h>
    #include <stdio.h>
    
    using namespace std;
    
    struct Node {
        int fatherindex;
        int level;
        int row;
        string elem;
        string id;
    }nodes[101];
    
    int nodesnum = 0;
    int N, M;
    map<string, vector<int>> elem2index, id2index;  // 记录映射关系表
    
    
    int main() {
        cin>>N>>M;
    
        getchar();  // 去除换行
    
        // 获取结构化文档数据
        int preindex = -1; // 前一个元素的下标
        for (int i = 0; i < N; ++i) {
            char chars[100] ;  //= " ";
            fgets(chars, 100, stdin);  // // 获取一行的信息
            string str = chars;
            str = str.substr(0, str.size() - 1);  // 去除换行符
    
            int strindex = 0;
    
            // 记录 .. 数
            int level = 0;
            while (strindex < str.size() && str[strindex] == '.') {
                strindex += 2;
                ++level;
            }
    
            // 获得 元素
            string elem = "";
            while (strindex < str.size() && str[strindex] != ' ') {
                elem += tolower(str[strindex]);  // 全变为小写 (如果有数字会不会出错?)
                ++strindex;
            }
    
            // 获得 id属性
            strindex += 1;  // 跳到 #
            string id = "";
            while (strindex < str.size()) {
                id += str[strindex];  // !!!!!!id属性大小写敏感!!!!!!
                ++strindex;
            }
    
            // 记录映射关系表
            elem2index[elem].push_back(i);
            if (id != "") {
                id2index[id].push_back(i);
            }
    
            // 记录当前节点
            if (level == 0) {  // 初始节点
                nodes[nodesnum] = {-1, level, i + 1, elem, id};
            }
            else if (nodes[preindex].level == level - 1) {  // 前一个是父节点
                nodes[nodesnum] = {preindex, level, i + 1, elem, id};
            }
            else if (nodes[preindex].level == level) {  // 同级节点
                nodes[nodesnum] = {nodes[preindex].fatherindex, level, i + 1, elem, id};
            }
            else {  // 不是level = 0、 前一个不是父节点也不是同级节点, 要往前找
                for (int j = nodesnum - 1; j >= 0; --j) {  // 找父元素下标, 即最近的那个level - 1if (nodes[j].level == level - 1) {
                        nodes[nodesnum] = {j, level, i + 1, elem, id};
                        break;
                    }
                }
            }
            ++nodesnum;
    
            preindex = i;
        }
    
    
        // 获取待查询的选择器
        for (int i = 0; i < M; ++i) {
            char chars[100] ;  //= " ";
            fgets(chars, 100, stdin);  // // 获取一行的信息
            string str = chars;
    
            str = str.substr(0, str.size() - 1);
    
            // 处理 选择器
            vector<string> selector;  // 记录选择器的信息
            string tmp;
            for (char c: str) {
                if (c == ' ') {
                    if (tmp[0] != '#') {  // elem大小写不敏感!!!! , id敏感!!!
                        for (int j = 0; j < tmp.size(); ++j) {  // 将元素全小写
                            tmp[j] = tolower(tmp[j]);
                        }
                    }
    
                    selector.push_back(tmp);
                    tmp = "";
                }
                else {
                    tmp.push_back(c);
                }
            }
            if (tmp != "") {
                if (tmp[0] != '#') {  // elem大小写不敏感!!!! , id敏感!!!
                    for (int j = 0; j < tmp.size(); ++j) {  // 将元素全小写
                        tmp[j] = tolower(tmp[j]);
                    }
                }
                selector.push_back(tmp);
            }
    
            // 记录符合条件的元素的行
            vector<int> curans;  // 记录符合条件的元素的行
            if (selector.size() == 1) {  // 选择器是 标签选择器 or id选择器
                if (selector[0][0] == '#' && id2index.count(selector[0]) != 0) {  // id选择器 且 存在
                    for (int index: id2index[selector[0]]) {
                        curans.push_back(nodes[index].row);
                    }
                }
                else if (selector[0][0] != '#' && elem2index.count(selector[0]) != 0){  // 标签选择器 其 存在
                    for (int index: elem2index[selector[0]]) {
                        curans.push_back(nodes[index].row);
                    }
                }
            }
    
            // 选择器是 !后代选择器!
            else {  // 选择器是 后代选择器
                // 初始化
                int selectorsize = selector.size();
                vector<int> original;  // 存储最初的所在的nodes下标
    
                if (selector[selectorsize - 1][0] == '#') { // id
                    original = id2index[selector[selectorsize - 1]];
                }
                else { // elem
                    original = elem2index[selector[selectorsize - 1]];
                }
    
                // 遍历每个候选者
                for (int j = 0; j < original.size(); ++j) {
                    vector<string> curselector = selector;  // 当前候选者需要走过的选择器的内容
                    int curselectorindex = selector.size() - 1;  // 初始下标
                    int curindex = original[j];  // 当前候选者的nodes下标
    
                    // 遍历每个选择器的内容
                    while (curindex != -1 && curselectorindex >= 0) {
                        string sele = selector[curselectorindex];  // 当前选择器的内容
                        if (sele[0] == '#') { // id选择器
                            if (nodes[curindex].id == sele) {  //  符合
                                --curselectorindex;
                            }
                            curindex = nodes[curindex].fatherindex;
                        }
                        else {  // 标签选择器
                            if (nodes[curindex].elem == sele) {  // 符合
                                --curselectorindex;
                            }
                            curindex = nodes[curindex].fatherindex;
                        }
                    }
    
                    if (curselectorindex == -1) {   // 能够走完所有路, 则记录
                        curans.push_back(nodes[original[j]].row);
                    }
                }
            }
    
    
            // 输出答案
            int anssize = curans.size();
            cout<<anssize;
            for (int j = 0; j < anssize; ++j) {
                cout<<" "<<curans[j];
            }
            cout<<endl;
        }
    
        return 0;
    }
    
    评论
  • CSDN-Ada助手 CSDN-AI 官方账号 2023-11-21 06:02
    关注
    获得0.75元问题酬金

    【相关推荐】




    如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^
    评论
  • 小明说Java 2023-11-21 12:37
    关注
    获得0.45元问题酬金

    引用文心一言及个人思考回答:

    
    
    CSP认证考试:
    201809-3 元素选择器
    虽然自己测试的时候都是对的,但只能得标签的四十分,带id和后代选择器的都错了,实在不能理解。
     
    #include<bits/stdc++.h>
    using namespace std;
    int n,m;
    struct node{
        string name;
        string id;
        int line;
        int level;
        vector<node*>son;
        node *mother;
    };
    vector<vector<int>> ans;
    //
    string lower(string a){
        int length=a.size(); 
        for(int i=0;i<length;i++){
            if(a[i]>='A' && a[i]<='Z'){
                a[i]=a[i]+'a'-'A';
            }
        }
        return a;
    }
    //
    int cmp(int a,int b){
        return a<b;
    } 
    //
    void find(vector<int>&ans2,node* head,vector<string>&S,int now){
        int length=head->son.size(); 
        for(int i=0;i<length;i++){
            if( lower(head->son[i]->name)==lower(S[now]) ) {
                if(now==S.size()-1) ans2.push_back( head->son[i]->line );
                else find(ans2,head->son[i],S,now+1);
            }
            else if( head->son[i]->id==S[now] ){
                if(now==S.size()-1) ans2.push_back( head->son[i]->line );
                else find(ans2,head->son[i],S,now+1);
            }
            else{
                find(ans2,head->son[i],S,now);
            }
        }
    }
    //
    int main(){
        cin>>n>>m;  
        getchar();
        node* head=new node;  head->name="原初";
        node* pre=new node;
        node* last_line=new node;//上一行 
        //
        for(int i=0;i<n;i++){
            string str;
            getline(cin,str);
            //读入了一句html 
            int level=0; 
            while(str[0]=='.') {
                level++;
                str.erase(str.begin());
            }
            level=level/2+1;
            //知道了分级是多少 
            node* temp=new node;
            temp->level=level;
            if(level==1){//等级为1,开启新的族谱 
                temp->mother=head;
                head->son.push_back(temp);
                last_line=temp;
            }
            else if(last_line->level==level){
                temp->mother=last_line->mother;
                temp->mother ->son.push_back(temp);
                last_line=temp;
            }
            else if(last_line->level+1==level){
                temp->mother=last_line;
                temp->mother ->son.push_back(temp);
                last_line=temp;
            }
            else if(last_line->level > level){
                while(last_line->level >= level){
                    last_line=last_line->mother;
                }
                last_line->son.push_back(temp);
                last_line=temp;
            }
            //确定该行的母亲,母亲认子 
            temp->line=i;
            int flag=0;
            for(int j=0;j<str.size();j++){
                if(str[j]==' '){
                    flag=1;
                    continue;
                }
                if(flag==0) {
                    temp->name.push_back(str[j]);
                }
                else temp->id.push_back(str[j]);
            }
            //读入内容,都有name,但不一定有id 
        }
        //数据储存完成,分级完成,母子确认完成
        for(int i=0;i<m;i++){
            vector<string> S;
            string str;
            getline(cin,str);
            string con;
            for(int j=0;j<str.size();j++){
                if(str[j]==' '){
                    S.push_back(con);
                    con.clear();
                    continue;
                }
                con.push_back(str[j]);
            }    
            S.push_back(con);
            //
            vector<int> ans2;
            find(ans2,head,S,0);
            ans.push_back(ans2);
        } 
        //
        for(int i=0;i<ans.size();i++){
            sort(ans[i].begin(),ans[i].end(),cmp);
            cout<<ans[i].size();
            for(int j=0;j<ans[i].size();j++){
                cout<<" "<<ans[i][j]+1;
            }
            if(i!=ans.size()-1)cout<<"\n";
        }
        return 0;
    }
     
    
    评论
  • 郭老师的小迷弟雅思莫了 Java领域新星创作者 2023-11-21 13:52
    关注
    获得0.60元问题酬金

    参考:专家-赤兔[在线] 这个答主的

    评论
  • 技术宅program 2023-11-21 18:52
    关注
    获得0.45元问题酬金
    #include<bits/stdc++.h>
    using namespace std;
    int n,m;
    struct node{
        string name;
        string id;
        int line;
        int level;
        vector<node*>son;
        node *mother;
    };
    vector<vector<int>> ans;
    //
    string lower(string a){
        int length=a.size(); 
        for(int i=0;i<length;i++){
            if(a[i]>='A' && a[i]<='Z'){
                a[i]=a[i]+'a'-'A';
            }
        }
        return a;
    }
    //
    int cmp(int a,int b){
        return a<b;
    } 
    //
    bool find(vector<int>&ans2,node* head,vector<string>&S,int now){
        int length=head->son.size(); 
        for(int i=0;i<length;i++){
            if( lower(head->son[i]->name)==lower(S[now]) ) {
                if(now==S.size()-1) ans2.push_back( head->son[i]->line );
                else find(ans2,head->son[i],S,now+1);
            }
            else if( head->son[i]->id==S[now] ){
                if(now==S.size()-1) ans2.push_back( head->son[i]->line );
                else find(ans2,head->son[i],S,now+1);
                if(now!=S.size()-1) return false; //修改处
            }
            else{
                find(ans2,head->son[i],S,now); //修改处
            }
        }
        return true;
    }
    //
    int main(){
        cin>>n>>m;  
        getchar();
        node* head=new node;  head->name="原初";
        node* pre=new node;
        node* last_line=new node;//上一行 
        //
        for(int i=0;i<n;i++){
            string str;
            getline(cin,str);
            //读入了一句html 
            int level=0; 
            while(str[0]=='.') {
                level++;
                str.erase(str.begin());
            }
            level=level/2+1;
            //知道了分级是多少 
            node* temp=new node;
            temp->level=level;
            if(level==1){//等级为1,开启新的族谱 
                temp->mother=head;
                head->son.push_back(temp);
                last_line=temp;
            }
            else if(last_line->level==level){
                temp->mother=last_line->mother;
                temp->mother ->son.push_back(temp);
                last_line=temp;
            }
            else if(last_line->level+1==level){
                temp->mother=last_line;
                temp->mother ->son.push_back(temp);
                last_line=temp;
            }
            else if(last_line->level > level){
                while(last_line->level >= level){
                    last_line=last_line->mother;
                }
                last_line->son.push_back(temp);
                last_line=temp;
            }
            //确定该行的母亲,母亲认子 
            temp->line=i;
            int flag=0;
            for(int j=0;j<str.size();j++){
                if(str[j]==' '){
                    flag=1;
                    continue;
                }
                if(flag==0) {
                    temp->name.push_back(str[j]);
                }
                else temp->id.push_back(str[j]);
            }
            //读入内容,都有name,但不一定有id 
        }
        //数据储存完成,分级完成,母子确认完成
        for(int i=0;i<m;i++){
            vector<string> S;
            string str;
            getline(cin,str);
            string con;
            for(int j=0;j<str.size();j++){
                if(str[j]==' '){
                    S.push_back(con);
                    con.clear();
                    continue;
                }
                con.push_back(str[j]);
            }    
            S.push_back(con);
            reverse(S.begin(),S.end()); //修改处
            //
            vector<int> ans2;
            find(ans2,head,S,0);
            ans.push_back(ans2);
        } 
        //
        for(int i=0;i<ans.size();i++){
            sort(ans[i].begin(),ans[i].end(),cmp);
            cout<<ans[i].size();
            for(int j=0;j<ans[i].size();j++){
                cout<<" "<<ans[i][j]+1;
            }
            if(i!=ans.size()-1)cout<<"\n";
        }
        return 0;
    }
    
    
    
    评论
  • bug菌¹ Java领域优质创作者 2023-11-22 00:15
    关注
    获得0.75元问题酬金

    该回答引用ChatGPT,望对题主有所帮助/启发;若有帮助,还望采纳。


    你的代码是一个处理HTML元素选择器的程序,使用C++编写。根据你提供的信息,程序的主要逻辑包括:

    1. 定义了一个节点结构 node 用于表示HTML中的元素,包括元素的名称、ID、所在行数、层级、子节点等信息。
    2. 通过读取输入,构建了一个 HTML 元素的层级结构,存储在 head 中。
    3. 通过输入的元素选择器,在层级结构中查找匹配的元素,并记录其行数。
    4. 对于每个元素选择器,输出匹配的元素行数,并按从小到大的顺序进行排序。

    根据你的描述,似乎你在处理元素选择器的时候遇到了问题,特别是对于带有 ID 和后代选择器的情况。可能的原因之一是在处理后代选择器时,递归的时候没有正确更新 now 的值,导致无法正确匹配后续的选择器。

    你可以仔细检查 find 函数的实现,确保递归调用时 now 的值正确更新,以便正确匹配元素选择器。

    此外,你的代码中有一些其他可能需要注意的地方:

    1. lower 函数中,可能存在字符串越界的情况,应该确保在处理字符串之前检查其长度。
    2. cmp 函数中,可能需要使用 a > b 进行比较,因为 a < b 返回的是布尔值,而排序函数要求返回一个能够进行比较的结果。

    希望这些提示能够帮助你找到问题所在。如果有进一步的问题或需要更多的帮助,请随时提问。

    评论
  • yy64ll826 2023-11-22 14:37
    关注
    获得0.30元问题酬金
    评论
  • 关注
    获得0.45元问题酬金

    这段代码是用C++实现的,用于解决CSP认证考试201809-3题目“元素选择器”。题目要求实现一个HTML元素选择器,给定一个HTML文档和一系列选择器,要求输出符合选择器条件的HTML元素的行号。
    代码中首先定义了一个结构体node,用于表示HTML元素,包括元素名、元素id、行号、级别、子元素和母元素。然后定义了一个二维数组ans,用于保存符合选择器条件的元素行号。
    代码主要分为几个函数:

    lower函数:用于将字符串转换为小写字母;
    cmp函数:用于排序函数中的比较函数;
    find函数:递归地查找符合选择器条件的元素行号。

    在主函数中,首先读入n和m,分别表示HTML文档的行数和选择器的个数。然后按行读入HTML文档,构建HTML元素树。接下来按照选择器的个数依次读入选择器,并调用find函数查找符合条件的元素行号。最后按照要求输出结果。
    需要注意的是,该代码只能得到标签的四十分,带id和后代选择器的都会出错。可能是因为在find函数中对选择器进行匹配时出现了问题,需要进行调试和修改。

    评论
  • Minuw 2023-11-28 18:12
    关注
    获得0.45元问题酬金

    参考gpt
    这段代码是用C++实现的一个HTML元素选择器的功能,根据输入的HTML结构和选择器,输出符合选择器条件的元素的行号。根据你的描述,你的代码在测试时能得到正确的结果,但在CSP认证中得分不高,主要原因可能是以下几点:

    1. 可能存在一些边界情况没有考虑到,比如特殊的HTML结构或者选择器格式等,导致在CSP认证的测试数据中出现错误。

    2. 可能存在一些性能问题,比如对于大规模的HTML结构和选择器查询,可能会超出时间限制。

    3. 可能存在一些代码风格和规范方面的问题,比如命名规范、代码注释、错误处理等,这些在CSP认证中也会有一定的分数要求。

    建议你在调试时多考虑一些边界情况,确保你的代码在各种情况下都能正确运行。另外,也可以尝试优化你的代码,提高性能,比如减少不必要的循环和递归,或者使用一些数据结构来加速查询。此外,注意代码的规范和可读性也是很重要的,这样能够更好地通过CSP认证的评审。希望这些建议对你有所帮助。

    评论
  • 会跑的小鹿 2023-11-28 21:48
    关注
    获得0.30元问题酬金

    编译失败了

    评论
  • GIS工具开发 2023-11-28 21:54
    关注
    获得0.45元问题酬金

    格式有问题吧

    评论
  • 心梓知识 2023-11-21 04:27
    关注

    结合GPT给出回答如下请题主参考
    题目描述:

    现在给出一个 HTML 代码片段与一个 CSS 代码片段,请你写一个程序,输出该 CSS 代码在该 HTML 代码片段上的元素选择器匹配到的元素集合。

    HTML 代码片段中只包含三种标签:

    、,每个标签可能有一个 id,例如

    。CSS 代码片段中只包含元素选择器、ID 选择器和后代选择器,不包含类选择器,伪类选择器和属性选择器。

    输入格式:

    第一行包含一个整数 n,表示 CSS 代码片段的行数。

    接下来 n 行,每行包含一个 CSS 代码片段。

    接下来一行一个 HTML 代码片段,保证干净。即标签都是小写的,属性名都是小写的,并且没有注释。

    注意:HTML 代码片段中的 id 可能以数字开头。

    输出格式:

    输出该 CSS 代码在该 HTML 代码片段上的元素选择器匹配到的元素集合,按照它们在 HTML 代码片段中出现的顺序,每个元素的标签和 id 用空格隔开。

    如果元素集合为空,输出一个空行。

    样例输入:

    10
    #topnav a
    .head p
    div p a
    span
    div div a
    div#header span
    #header span a
    div#footer p a
    #footer p a
    div #leftsidebar a

    Header Link Header Span

    样例输出:

    p
    span Header Span
    a Header Link

    解题思路:

    本题的输入要比上一道题要复杂一些,需要进行较多的处理:

    1、对 CSS 代码进行解析,根据空格分离出不同的选择器,并根据 # 是否出现来判断是元素选择器还是 id 选择器。

    2、对 HTML 代码进行解析,利用栈来保存标签嵌套关系。

    对于每个 CSS 选择器,都需要在 HTML 代码中去匹配符合要求的元素,具体匹配方法如下:

    1、根据选择器的第一个标签进行匹配,找到所有符合条件的标签。

    2、根据选择器中的后续标签进行匹配,每次都将前一次匹配到的标签作为下一次匹配的起点,直到所有选择器都匹配完毕。

    3、如果所有选择器都被成功匹配,说明该元素符合 CSS 选择器的要求,将其输出。

    4、匹配完一个选择器后,需要将符合要求的标签和其他标签再次压入栈中,方便后续匹配。

    代码实现:

    评论
  • Leodong. 2023-11-21 09:31
    关注

    该回答通过自己思路及引用到GPTᴼᴾᴱᴺᴬᴵ搜索,得到内容具体如下:
    CSP认证考试:201809-3 元素选择器

    在这个问题中,你需要使用C++编写一个程序来解析HTML文档并找到与给定选择器匹配的元素。你提供的代码存在一些问题,导致无法正确解析HTML文档。我将为你提供一个修复后的版本,并解释其中的错误。

    首先,我们需要修复find函数中的条件判断。在你的代码中,你使用了lower(head->son[i]->name)==lower(S[now])head->son[i]->id==S[now]来判断是否找到了匹配的元素。然而,这并不能正确地处理带有ID的选择器。我们需要修改这部分逻辑,以便正确处理带有ID的选择器。

    以下是修复后的代码:

    #include<bits/stdc++.h>
    using namespace std;
    int n,m;
    struct node{
        string name;
        string id;
        int line;
        int level;
        vector<node*>son;
        node *mother;
    };
    vector<vector<int>> ans;
    //
    string lower(string a){
        int length=a.size(); 
        for(int i=0;i<length;i++){
            if(a[i]>='A' && a[i]<='Z'){
                a[i]=a[i]+'a'-'A';
            }
        }
        return a;
    }
    //
    int cmp(int a,int b){
        return a<b;
    } 
    //
    void find(vector<int>&ans2,node* head,vector<string>&S,int now){
        int length=head->son.size(); 
        for(int i=0;i<length;i++){
            if( (now == S.size() - 1 || lower(head->son[i]->name) == lower(S[now])) && 
                (now == S.size() - 1 || head->son[i]->id == S[now]) ) {
                if(now==S.size()-1) ans2.push_back( head->son[i]->line );
                else find(ans2,head->son[i],S,now+1);
            }
            else{
                find(ans2,head->son[i],S,now);
            }
        }
    }
    //
    int main(){
        cin>>n>>m;  
        getchar();
        node* head=new node;  head->name="原初";
        node* pre=new node;
        node* last_line=new node;//上一行 
        //
        for(int i=0;i<n;i++){
            string str;
            getline(cin,str);
            //读入了一句html 
            int level=0; 
            while(str[0]=='.') {
                level++;
                str.erase(str.begin());
            }
            level=level/2+1;
            //知道了分级是多少 
            node* temp=new node;
            temp->level=level;
            if(level==1){//等级为1,开启新的族谱 
                temp->mother=head;
                head->son.push_back(temp);
                last_line=temp;
            }
            else if(last_line->level==level){
                temp->mother=last_line->mother;
                temp->mother ->son.push_back(temp);
                last_line=temp;
            }
            else if(last_line->level+1==level){
                temp->mother=last_line;
                temp->mother ->son.push_back(temp);
                last_line=temp;
            }
            else if(last_line->level > level){
                while(last_line->level >= level){
                    last_line=last_line->mother;
                }
                last_line->son.push_back(temp);
                last_line=temp;
            }
            //确定该行的母亲,母亲认子 
            temp->line=i;
            int flag=0;
            for(int j=0;j<str.size();j++){
                if(str[j]==' '){
                    flag=1;
                    continue;
                }
                if(flag==0) {
                    temp->name.push_back(str[j]);
                }
                else temp->id.push_back(str[j]);
            }
            //读入内容,都有name,但不一定有id 
        }
        //数据储存完成,分级完成,母子确认完成
        for(int i=0;i<m;i++){
            vector<string> S;
            string str;
            getline(cin,str);
            string con;
            for(int j=0;j<str.size();j++){
                if(str[j]==' '){
                    S.push_back(con);
                    con.clear();
                    continue;
                }
                con.push_back(str[j]);
            }    
            S.push_back(con);
            //
            vector<int> ans2;
            find(ans2,head,S,0);
            ans.push_back(ans2);
        } 
        //
        for(int i=0;i<ans.size();i++){
            sort(ans[i].begin(),ans[i].end(),cmp);
            cout<<ans[i].size();
            for(int j=0;j<ans[i].size();j++){
                cout<<" "<<ans[i][j]+1;
            }
            if(i!=ans.size()-1)cout<<"\n";
        }
        return 0;
    }
    

    现在,这个程序应该能够正确地解析HTML文档并找到与给定选择器匹配的元素。


    如果以上回答对您有所帮助,点击一下采纳该答案~谢谢

    评论

报告相同问题?

问题事件

  • 系统已结题 11月29日
  • 赞助了问题酬金15元 11月21日
  • 创建了问题 11月21日

悬赏问题

  • ¥30 哈夫曼编码译码器打印树形项目
  • ¥20 求完整顺利登陆QQ邮箱的python代码
  • ¥15 怎么下载MySQL,怎么卸干净原来的MySQL
  • ¥15 网络打印机Ip地址自动获取出现问题
  • ¥15 求局部放电案例库,用于预测局部放电类型
  • ¥100 QT Open62541
  • ¥15 stata合并季度数据和日度数据
  • ¥15 谁能提供rabbitmq,erlang,socat压缩包,记住版本要对应
  • ¥15 Vue3 中使用 `vue-router` 只能跳转到主页面?
  • ¥15 用QT,进行QGIS二次开发,如何在添加栅格图层时,将黑白的矢量图渲染成彩色