202303 CSP认证 | 田地丈量 垦田计划 LDAP (bitset)

已于 2024-03-28 20:03:47 修改
阅读量430 收藏 7
点赞数 9
分类专栏： CCF-CSP认证 文章标签： csp认证 c++
于 2024-03-18 22:08:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Canmido/article/details/136822667
版权

田地丈量

#include<bits/stdc++.h>
using namespace std;
int main()
{
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    
    int n, x, y; cin >> n >> x >> y;
    int sum = 0;
    while(n --){
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        if(x1 >= x) continue;
        if(x2 <= 0) continue;
        if(y1 >= y) continue;
        if(y2 <= 0) continue;
        
        int a = max(0, x1), b = min(x, x2);
        int c = max(0, y1), d = min(y, y2);
        
        sum += ((b - a) * (d - c));
    }
    cout << sum;
    return 0;
}

垦田计划
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
unordered_map<int, int> source;
bool cmp(int x, int y)
{
    return x > y;
}
int main()
{
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);

    int n, m, k; cin >> n >> m >> k;
    vector<int> vec;
    for(int i = 1;i <= n;i ++){
        int t, c;
        cin >> t >> c;
        source[t] += c;   //计算每个单位需要的总资源
        vec.push_back(t);
    }
    sort(vec.begin(), vec.end(), cmp);
    vec.erase(unique(vec.begin(), vec.end()), vec.end());
    bool flag = false;
    for(int i = vec[0]; i >= k + 1; i --){
        if(m >= source[i]){
            m -= source[i];
            source[i - 1] += source[i];
        }
        else { cout << i; flag = true; break; }
    }
    if(!flag) cout << k;
    return 0;
}

LDAP
好好好，难度直线上升，是一道又有了字符串处理味道的第三题
第一把写官网40分，acwing TLE且只通过了一道数据…本文是自己这题奋斗过程 的一个记录

先贴个40分的代码：
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;   // key and value pair
int n;

unordered_map<int, unordered_map<string, string> > user;  //每个用户对应一个key and value的映射表
unordered_map<string, unordered_set<int> > key_user;  //i作为key, 表示哪些用户具有属性i

//处理一个基本表达式,检查基本表达式与dn的用户是否匹配
set<int> base_expr(string expr)
{
    int i = 0;
    while(expr[i] != ':' && expr[i] != '~') i ++;
    string arr = expr.substr(0, i);
    string value = expr.substr(i + 1, expr.size() - i - 1);

    set<int> res;

    unordered_set<int> users = key_user[arr];
    if(expr[i] == ':'){
        for(auto x : users){   //遍历每一个用户
            if(user[x][arr] == value){
                res.insert(x);
            }
        }
    }else{
        for(auto x : users){
            if(user[x][arr] != value){
                res.insert(x);
            }
        }
    }

    return res;
}

//处理一个常规的表达式
set<int> handle(string expr)
{
    set<int> ans;

    //括号要成对取出
    if(expr[0] == '&' || expr[0] == '|'){
        stack<char> s; int i = 2;
        set<int> res1, res2;

        s.push('(');
        int cnt = 1;
        while(!s.empty()){
            while(expr[i] != '(' && expr[i] != ')') i ++;
            if(expr[i] == '(') { s.push('('); cnt ++; }  //入栈并进行计数
            else if(expr[i] == ')') s.pop(); //弹出一个栈顶的
            i ++;
        }
        //此时第一个括号提取完毕
        string expr1 = expr.substr(2, i - 3);
        string expr2 = expr.substr(i + 1, expr.size() - i - 2);
        //cout << "两个表达式分别为:\n" << expr1 <<"\n" << expr2 <<"\n";

        if(cnt == 1){   //此时是一个简单表达式
            res1 = base_expr(expr1);
            res2 = base_expr(expr2);
        }
        else{
            res1 = handle(expr1);
            res2 = handle(expr2);
        }


        if(expr[0] == '&'){  //取两个集合的交集
            for(auto x : res1){   //遍历一个集合就可以了
                if(res2.count(x)) ans.insert(x);
            }

        }else{   //取两个集合的并集
            for(auto x : res1) ans.insert(x);
            for(auto x : res2) ans.insert(x);
        }

    }

    else { //若要处理的输入就是一个基本表达式
        ans = base_expr(expr);
    }

    return ans;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> n;
    for(int i = 0;i < n;i ++){
        int dn, x;
        string arr, val;
        cin >> dn >> x;
        while(x --){
            cin >> arr >> val;
            key_user[arr].insert(dn);  //dn具有属性arr
            user[dn][arr] = val;  //dn具有属性arr,且value = val
        }
    }
    int m; cin >> m;
    string line;
    while(m --){
        cin >> line;
        set<int> ans = handle(line);
        for(auto x : ans){
            cout << x <<' ';
        }
        cout << "\n";
    }
    return 0;
}

秉持着自己的逻辑应该没错但是官网是40分错误的判断，我找了几分代码比对着修改了一下，找到了一个逻辑错误。

在handle函数中我统计了一个cnt用于控制当括号里面的是基础表达式的时候就直接调用base_expr函数，问题就出在这里。
· 第一个问题：我只统计了第一个括号的层数，我默认这两个括号的层级是一样的。这样会导致错误，也就是当前一个括号里是基本表达式而第二个括号里面并不是的时候，此时base_expr并不能解决这样的表达式
· 第二个问题：这里也不算会直接导致错误的原因。在handle函数中，如果发现不是一个逻辑表达式的话，其实有调用base_expr函数的。因此不用重复写，直接一直迭代向下调用handle函数即可。

修改后代码运行超时，逻辑问题变优化问题了，先放个70分的代码（代码几乎没变，就是handle函数体内部改变）
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;   // key and value pair
int n;

unordered_map<int, unordered_map<string, string> > user;  //每个用户对应一个key and value的映射表
unordered_map<string, unordered_set<int> > key_user;  //i作为key, 表示哪些用户具有属性i

//处理一个基本表达式,检查基本表达式与dn的用户是否匹配
set<int> base_expr(string expr)
{
    int i = 0;
    while(expr[i] != ':' && expr[i] != '~') i ++;
    string arr = expr.substr(0, i);
    string value = expr.substr(i + 1, expr.size() - i - 1);

    set<int> res;

    unordered_set<int> users = key_user[arr];
    if(expr[i] == ':'){
        for(auto x : users){   //遍历每一个用户
            if(user[x][arr] == value){
                res.insert(x);
            }
        }
    }else{
        for(auto x : users){
            if(user[x][arr] != value){
                res.insert(x);
            }
        }
    }

    return res;
}

//处理一个常规的表达式
set<int> handle(string expr)
{
    set<int> ans;

    //括号要成对取出
    if(expr[0] == '&' || expr[0] == '|'){
        stack<char> s; int i = 2;
        set<int> res1, res2;

        s.push('(');
        while(!s.empty()){
            while(expr[i] != '(' && expr[i] != ')') i ++;
            if(expr[i] == '(')  s.push('(');    //入栈并进行计数
            else if(expr[i] == ')') s.pop(); //弹出一个栈顶的
            i ++;
        }
        //此时第一个括号提取完毕
        string expr1 = expr.substr(2, i - 3);
        string expr2 = expr.substr(i + 1, expr.size() - i - 2);
        //cout << "两个表达式分别为:\n" << expr1 <<"\n" << expr2 <<"\n";

        res1 = handle(expr1);
        res2 = handle(expr2);

        if(expr[0] == '&'){  //取两个集合的交集
            for(auto x : res1){   //遍历一个集合就可以了
                if(res2.count(x)) ans.insert(x);
            }

        }else{   //取两个集合的并集
            for(auto x : res1) ans.insert(x);
            for(auto x : res2) ans.insert(x);
        }

    }

    else { //若要处理的输入就是一个基本表达式
        ans = base_expr(expr);
    }

    return ans;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> n;
    for(int i = 0;i < n;i ++){
        int dn, x;
        string arr, val;
        cin >> dn >> x;
        while(x --){
            cin >> arr >> val;
            key_user[arr].insert(dn);  //dn具有属性arr
            user[dn][arr] = val;  //dn具有属性arr,且value = val
        }
    }
    int m; cin >> m;
    string line;
    while(m --){
        cin >> line;
        set<int> ans = handle(line);
        for(auto x : ans){
            cout << x <<' ';
        }
        cout << "\n";
    }
    return 0;
}

在找满分代码的过程中发现大家的思路总体来说差不多，不同的是在存储中的数据结构设置。
最终修改的满分答案参考了这位博主的：bitset优化，可过

总体来说思路其实是一模一样的，不同的地方在于用了bitset
大家可以去搜一下bitset的用法，其本质上就是连续的01串，可以用bitset<N> s来定义，其中 N 指定大小。在本题中使用bitset的原理是为了让集合的并运算和交运算更为简洁

可以这么理解本题中的bitset：
它就像一个one-hot编码，对应编号为1，则说明该用户存在（于答案中）
在原有的存储方式中，当我对每一个表达式做判断时，我找到符合条件的用户，并存储这些用户的id，也就是dn的值；最后在逻辑运算中，根据逻辑符号的不同，涉及对两个集合的交操作和并操作。
当修改为bitset后有这样一些优化：

  1. 合理性。为什么可以用bitset来做，我认为哈。每位用户的id不同，id的范围到1e9，但是n的范围小多了，最多就是2000个。也就是说我可以不用dn去定位到每一个用户，我可以用他们输入的位置编号来定位用户，在此基础上我只需要将他们的dn存储起来，在输出时取得即可。这样大大减少了范围，这个数量级下我可以用一维数组来存储。例如在本题中，其实我没有用dn去定位每一个用户，而是输入循环中for(int i = 1;i <= n;i ++中的i来定位。pos[i] = 1，意味着i用户符合要求，此时输出user_id[i]即可
  2. 计算更快。在计算交和并操作时，此时只涉及到按位运算，可想而知速度会大大加快；少了集合的遍历，而且位数也不高，就2000位

努力了一下午我终于…看到了100分…
在这里插入图片描述
贴一个修改后的满分代码！！！

//use bitset for better set_union and set_intersection
#include<bits/stdc++.h>
using namespace std;
typedef pair<string, string> PSS;
const int N = 3000;
int n, user[N];  //to store user id(dn)
unordered_map<string, unordered_set<int> > hask;  //哪个用户具有特定的key
map<PSS, unordered_set<int> > haskv;   //哪个用户具有某个特定的key-value对

bitset<N> handle(string expr)
{
    bitset<N> ans;   //最终的答案,若ans[i], 也即user[i]在返回的结果中

    if(expr[0] == '&' || expr[0] == '|'){  //如果为逻辑表达式
        stack<char> s; s.push('(');
        int i = 1;
        while(!s.empty()){  //仍然用栈的方法实现括号匹配
            i ++;
            if(expr[i] == '(') s.push('(');
            else if(expr[i] == ')') s.pop();
        }
        //出循环时expr[i] == ),为第一个括号的最右端

        string expr1 = expr.substr(2, i - 2);
        string expr2 = expr.substr(i + 2, expr.size() - i - 3);

        bitset<N> res1 = handle(expr1);
        bitset<N> res2 = handle(expr2);

        if(expr[0] == '&') ans = res1 & res2;
        else ans = res1 | res2;
        return ans;
    }

    else{  //如果为基础表达式
        int i = 0;
        while(expr[i] != ':' && expr[i] != '~') i ++;
        string key = expr.substr(0, i);
        string value = expr.substr(i + 1, expr.size() - i - 1);

        bool flag = false;  //该操作是否为反断言
        if(expr[i] == '~') flag = true;

        for(auto x : haskv[{key,value}]){
            ans[x] = 1;   //x所对的位置应该是1,也即答案中存在该dn
        }

        if(flag){  //如果为反断言
            for(auto x : hask[key]){
                ans.flip(x);   //flip是取反操作
                //对于拥有该key的，目前只有value值匹配的ans位是为一的
                //现在进行取反操作,这会导致刚刚所取值1的,也就是value值匹配的,都修改为0
                //而其余具有该key的(但value值不相等的), 则会置为1.此时完成了我们的要求
            }
        }

    }
    return ans;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    cin >> n;
    for(int i = 1;i <= n;i ++){
        int dn; cin >> dn;
        user[i] = dn;
        int k; cin >> k;
        while(k --){
            string key, val; cin >> key >> val;
            hask[key].insert(i);
            haskv[{key, val}].insert(i);
        }
    }

    int m; cin >> m;
    string line;

    while(m --){
        cin >> line;
        bitset<N> v = handle(line);
        vector<int> ans;  //存储答案

        for(int i = 1;i <= n;i ++){
            if(v[i]) ans.push_back(user[i]);
        }
        sort(ans.begin(),ans.end());  //排序
        for(auto x : ans){
            cout << x << ' ';
        }
        cout << "\n";
    }
    return 0;
}

与源代码的不同，第一个我保留了我最初的想法：用栈来实现括号匹配
第二个就是，在本题中的key-value我认为没有转化为int类型的必要性，如果只是匹配的话，直接用string存储即可，少了后续的一个转化步骤。
其他的部分是相同的。

有一个bug我改了特别特别久…提交的时候一直显示段错误，其实这也是我对该方法的不理解（最开始）
在代码的71、72行，我最开始的书写是：

hask[key].insert(dn);
haskv[{key, val}].insert(dn);

也就是我最开始仍然在用dn去标识每位用户，这个会导致代码的45行以及50行出错，因为dn的范围远大于n；感觉使用bitset就是在空间和时间上的双重优化。空间上的优化就是一维向量标识压缩了多个数量级（从9到3次方），而时间上的优化主要就是在并操作和交操作上。当然这都是基于0-1向量可表示用户的基础上

203号居民
关注
专栏目录
2023CSP-CCF前三题 田地丈量、垦田计划、LDAP解题分析
weixin_60344133的博客
04-04 1万+
2023.03.19第29次CCF-CSP计算机认证考试前三道题的分析（很详细！）
CCF-CSP 202303-2 垦田计划
m0_64500855的博客
04-06 1421
考虑二分得到的答案x，在函数内统计该答案下所耗费的总资源数sum，即(每块耕地的资源-x)*投入资源数量。如果总资源数sum
CCF-CSP真题202303-2垦田计划(Java满分题解)
m0_74172965的博客
11-07 572
本题来自2023年3月CCF-CSP真题中的第二题《垦田计划》。
CCF-CSP 202303-2 垦田计划 Python
m0_64196951的博客
05-09 441
不知道为什么好像网上的都是二分查找。只拿了70分，不知道为什么。
csp 23-03-1 田地丈量 & 2垦田计划
weixin_45829101的博客
03-05 1772
因为题目给的条件是左下和右上的坐标，我就顺着走了，只考虑了，这两个点，试图把所有情况都分析出来，使用if来判断，点是否在这个区域，然后根据不同的情况，来具体计算面积。一开始的一块地一天的步长试探就不够，其实我已经发现，当时时耗相同时，可以同时考虑，反正最低时耗是取决与最大的，如果不能全都减一，那就是不能减一。博主的思路是，使用一个map，将时耗天数相等的地合并起来，<时耗，-1需要的总资源数>，然后就可以从最大时耗开始多块地一天天的往前试探，减去后，与时耗相同的键值对合并，继续试探，呜呜呜呜效率真的好高。
csp202303-2-垦田计划-超简单题解
qq_52553462的博客
04-27 818
【代码】csp202303-2-垦田计划-超简单题解。
CSP认证2023-03：田地丈量、垦田计划、LDAP，python满分解答代码
qq_53644346的博客
11-24 1030
CSP认证2023-03：田地丈量、垦田计划、LDAP，python满分解答代码
csp 202303-2 垦田计划
nahnah_的博客
03-30 690
哈希思想
CCF-CSP 29次 第一题 【202303-1 田地丈量】
qq_51879318的博客
04-16 945
【代码】CCF-CSP 29次 第一题 【202303-1 田地丈量】
CCF-CSP真题《202303-1 田地丈量》思路+python，c++，java满分题解
热门推荐
weixin_53919192的博客
04-19 1万+
本文为大家题解了CCF-CSP真题《202303-1 田地丈量》，希望对你有帮助~~
CSP认证必学知识点完整版
10-10
**CSP认证必学知识点详解** CSP，全称Contest Software Professional，是中国计算机学会（CCF）举办的NOI（全国青少年信息学奥林匹克竞赛）在线初赛的重要组成部分。这个认证旨在检验参赛者在编程和算法设计上的...
CCF-CSP认证历年真题
03-05
### CCF-CSP认证知识点解析 #### 一、CCF-CSP认证简介 CCF-CSP（Certified Software Professional）认证是由中国计算机学会（CCF）主办的一项软件能力认证项目，旨在客观评价软件开发人员的实际编程能力。通过一...
csp认证真题 202303-1田地丈量（python）总结
2301_79421063的博客
08-28 515
解题思路： 只要求出，落在阴影区域的田地的x1,y1,x2,y2即可。
CCF CSP 202303-2 垦田计划 python 二分法
weixin_49274967的博客
06-06 498
顿顿总共选中了n块区域准备开垦田地，由于各块区域大小不一，开垦所需时间也不尽相同。
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 550
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
青少年编程能力等级测评CPA C++ 四级试卷（2）
最新发布
轻描时光
10-20 415
（3）编程过程中对于程序给定的部分不允许修改，考生仅允许在/****code****/提示行区间内作答。（3）编程过程中对于程序给定的部分不允许修改，考生仅允许在/****code****/提示行区间内作答。CP4_2_13．将A类的成员函数fun()声明为B类的友元函数，则以下叙述中，正确的是（ ）。编程过程中对于程序给定的部分不允许修改，考生仅允许在/****code****/提示行区间内作答。CP4_2_2．若有如下类A的定义，则下列有关类成员访问权限的叙述中，正确的是（ ）。
C++的魔法世界：类和对象的终章
sparrowfart的博客
10-16 1267
详细介绍，C++类和对象中初始化列表、隐式类型转换、匿名对象等相关知识
2023-06 GESP C++三级试卷
ya888g
10-17 916
位同学，每位同学有从 0 到?到达的同学都会报出的编号，不会报出别人的编号，但有的同 学很顽皮，会多次报出。10 如果 a 为 int 类型的变量，且表达式((a | 3) == 3)的值为 true，则说 明 a 在从 0 到 3 之间（可能为 0、可能为 3）3 已知大写字符’A’的 ASCII 编码的十六进制表示为 0x41，则字符’F’的 ASCII 编码的十六进制表示为（ ）12 如果 a 为 int 类型的变量，下列哪个表达式可以正确求出满足“小于等于 a且是 4 的倍数”的整数中最大的（ ）
青少年编程能力等级测评CPA C++（三级）-试卷2
轻描时光
10-20 673
CP3_2_9．已经按升序排列好的一组数“20,40,47,58,62,82,94”，使用二分查找算法在这组数中查找200，判断出200不在这组数中，需要比较的次数是（ ）。CP3_2_3．有数列1，1/1!CP3_2_5．使用选择排序算法（每趟最多交换一次）对一组数“19，28，12，7，66，31，24”进行升序排序，则第三趟结束后，这组数的顺序是（ ）。CP3_2_6．用直接插入排序算法对一组数“100，80，12，66，31，19，28”进行升序排序，则第四趟结束后，这组数的顺序是（ ）。
CCP-CSP认证考试202303-1 田地丈量
05-17
农夫约翰想要丈量他的 N（1≤N≤100,000）个田地的面积。他有一条长为 L（1≤L≤1,000,000）的量尺，可以用来测量在一个平面上的距离。每个田地都是一个矩形，且所有矩形的边都平行于坐标轴。每个矩形的左下角和右上...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值