CCF-CSP202303C题LDAP【100分】（结构清晰）

已于 2023-05-23 20:06:31 修改
阅读量658 收藏 6
点赞数 3
文章标签： 算法 c++
于 2023-05-23 16:16:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50521245/article/details/130829416
版权

文章目录

非递归写法（栈）

参考了
①CCF-CSP认证 202303 500分题解；
②bitset的基本用法
③表达式求值

自认代码结构相对清晰，给卡在这题的同学参考。

#include <bits/stdc++.h>

using namespace std;

const int N = 2510;
typedef bitset<N> STATE;
typedef pair<int, int> PII;

int n, m;
vector<PII> p;
map<PII, STATE> d;
map<int, STATE> S;

stack<STATE> num;
stack<char> op;

void eval(){
	STATE b = num.top(); num.pop();
	STATE a = num.top(); num.pop();
	char c = op.top(); op.pop();
	
	STATE res;
	if (c == '&') res = a & b;
	else res = a | b;
	num.push(res);
}

STATE solve(string str){
	stack<STATE>().swap(num), stack<char>().swap(op);
	for (int i = 0; i < str.size(); i ++ ){
		char c = str[i];
		if (isdigit(c)){
			int x = 0, j = i;
			while (j < str.size() && isdigit(str[j])) x = x * 10 + str[j] - '0', j ++ ;
			char oper = str[j];
			j ++ ;
			int y = 0;
			while (j < str.size() && isdigit(str[j])) y = y * 10 + str[j] - '0', j ++ ;
			i = j - 1;
			
			if (oper == ':') num.push(d[{x, y}]);
			else num.push(~d[{x, y}] & S[x]);
		}
		else if (c == '(') op.push(c);
		else if (c == ')'){
			while (op.top() != '(') eval();
			op.pop();	
		}
		else{
			while (op.size() && op.top() != '(') eval();
			op.push(c);	
		}
	}
	while (op.size()) eval();
	return num.top();
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	
	cin >> n;
	for (int i = 0; i < n; i ++ ){
		int t;
		cin >> t;
		p.push_back({t, i});
		int cnt;
		cin >> cnt;
		while (cnt -- ){
			int x, y;
			cin >> x >> y;
			d[{x, y}][i] = 1;
			S[x][i] = 1;
		}
	}
	sort(p.begin(), p.end());
	
	cin >> m;	
	while (m -- ){
		string str;
		cin >> str;
		STATE state = solve(str);
		
		vector<int> res;
		for (int i = 0; i < n; i ++ ){
			int x = p[i].first, y = p[i].second;
			if (state[y]) res.push_back(x);
		}
		for (int i = 0; i < res.size(); i ++ ) cout << res[i] << " \n"[i == res.size() - 1];
		if (res.empty()) cout << endl;
	}
		
	return 0;
}

/*
2
1 2 1 2 2 3
2 2 2 3 3 1
4
1:2
3~1
&(1:2)(2:3)
|(1:2)(3:1)
*/

运行时间也还行
运行时间

递归写法

另外，有个很凑巧的递归写法，考场上试出来的。利用了scanf的机制，用%d读字符，会将读取的字符自动退回输入缓冲区，原用于接收的int变量tmp值未改变。
参考C语言使用%d读入字符会发生什么

#include <bits/stdc++.h>

using namespace std;

const int N = 2510;
typedef bitset<N> STATE;
typedef pair<int, int> PII;

int n, m;
vector<PII> p;
map<PII, STATE> d;
map<int, STATE> S;

STATE get(){
    int tmp = 0;
    scanf("%d", &tmp);
    if (tmp){
        int x = tmp, y;
        char op;
        cin >> op >> y;
        if (op == ':') return d[{x, y}];
        else return ~d[{x, y}] & S[x];
    }
    
    char op;
    scanf("%c", &op);
    getchar();
    STATE x = get();
    getchar(); getchar();
    STATE y = get();
    getchar();
    
    if (op == '&') return x & y;
    else return x | y;
}

int main(){
    scanf("%d", &n);
	for (int i = 0; i < n; i ++ ){
		int t;
		scanf("%d", &t);
		p.push_back({t, i});
		int cnt;
		scanf("%d", &cnt);
		while (cnt -- ){
			int x, y;
			scanf("%d %d", &x, &y);
			d[{x, y}][i] = 1;
			S[x][i] = 1;
		}
	}
	sort(p.begin(), p.end());
	
	scanf("%d", &m);
	while (m -- ){
		STATE state = get();
		getchar();
		
		vector<int> res;
		for (int i = 0; i < n; i ++ ){
			int x = p[i].first, y = p[i].second;
			if (state[y]) res.push_back(x);
		}
		for (int i = 0; i < res.size(); i ++ ) printf(" %d" + !i, res[i]);
		puts("");
	}
		
	return 0;
}

/*
2
1 2 1 2 2 3
2 2 2 3 3 1
4
1:2
3~1
&(1:2)(2:3)
|(1:2)(3:1)
*/

时间慢了1s
运行时间
更正常一点的写法

#include <bits/stdc++.h>

using namespace std;

const int N = 2510;
typedef bitset<N> STATE;
typedef pair<int, int> PII;

int n, m;
vector<PII> p;
map<PII, STATE> d;
map<int, STATE> S;

string str;
STATE state;

int get(int u){
    if (isdigit(str[u])){
        int x = 0, y = 0;
        while (u < str.size() && isdigit(str[u])) x = x * 10 + str[u] - '0', u ++ ;
        char op = str[u]; u ++ ;
        while (u < str.size() && isdigit(str[u])) y = y * 10 + str[u] - '0', u ++ ;
        
        if (op == ':') state = d[{x, y}];
        else state = ~d[{x, y}] & S[x];
        return u;
    }
    
    char op = str[u];
    u ++ ;
    u = get(u + 1);
    STATE x = state;
    u ++ ;
    u = get(u + 1);
    STATE y = state;
    
    if (op == '&') state =  x & y;
    else state = x | y;
    
    return u + 1;
}

int main(){
    scanf("%d", &n);
	for (int i = 0; i < n; i ++ ){
		int t;
		scanf("%d", &t);
		p.push_back({t, i});
		int cnt;
		scanf("%d", &cnt);
		while (cnt -- ){
			int x, y;
			scanf("%d %d", &x, &y);
			d[{x, y}][i] = 1;
			S[x][i] = 1;
		}
	}
	sort(p.begin(), p.end());
	
	scanf("%d", &m);
	while (m -- ){
	    cin >> str;
		get(0);
		
		vector<int> res;
		for (int i = 0; i < n; i ++ ){
			int x = p[i].first, y = p[i].second;
			if (state[y]) res.push_back(x);
		}
		for (int i = 0; i < res.size(); i ++ ) printf(" %d" + !i, res[i]);
		puts("");
	}
		
	return 0;
}

/*
2
1 2 1 2 2 3
2 2 2 3 3 1
4
1:2
3~1
&(1:2)(2:3)
|(1:2)(3:1)
*/

可能更好想到的做法，属性值直接存储，每位单独进行判断。不用unorder_map则70分。

#include <bits/stdc++.h>

using namespace std;

const int N = 2510;
typedef pair<int, int> PII;

int n, m;
vector<PII> p;
unordered_map<int, int> v[N];

string str;
bool flag;
int aim;
int get(int u){
    if (isdigit(str[u])){
        int x = 0, y = 0;
        while (u < str.size() && isdigit(str[u])) x = x * 10 + str[u] - '0', u ++ ;
        char op = str[u]; u ++ ;
        while (u < str.size() && isdigit(str[u])) y = y * 10 + str[u] - '0', u ++ ;
        
        if (!v[aim].count(x)) flag = false;
        else if (op == ':' && v[aim][x] == y) flag = true;
        else if (op == '~' && v[aim][x] != y) flag = true;
        else flag = false;
        
        return u;
    }
    
    char op = str[u];
    u ++ ;
    u = get(u + 1);
    bool x = flag;
    u ++ ;
    u = get(u + 1);
    bool y = flag;
    
    if (op == '&') flag = x && y;
    else flag = x || y;
    
    return u + 1;
}

int main(){
    scanf("%d", &n);
	for (int i = 0; i < n; i ++ ){
		int t;
		scanf("%d", &t);
		p.push_back({t, i});
		int cnt;
		scanf("%d", &cnt);
		while (cnt -- ){
			int x, y;
			scanf("%d %d", &x, &y);
			v[i][x] = y;
		}
	}
	sort(p.begin(), p.end());
	
	scanf("%d", &m);
	while (m -- ){
	    cin >> str;
		
		vector<int> res;
		for (int i = 0; i < n; i ++ ){
			int x = p[i].first, y = p[i].second;
			aim = y;
			get(0);
			if (flag) res.push_back(x);
		}
		for (int i = 0; i < res.size(); i ++ ) printf(" %d" + !i, res[i]);
		puts("");
	}
		
	return 0;
}

/*
2
1 2 1 2 2 3
2 2 2 3 3 1
4
1:2
3~1
&(1:2)(2:3)
|(1:2)(3:1)
*/

时间慢了很多
运行时间

日向远
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
CCF CSP 202303-3 LDAP题解
aaicy64的博客
05-12 692
一道很简单的题，主要是看到BNF文法我就想写Parser，看见逻辑运算符就想写短路运算。然后浪费了很多时间。使用了类似解释器的结构，好像比一般用集合运算写快，但是时间有14s，所有没有任何作用。
CCF-CSP【202303-3 LDAP】C++
weixin_40502018的博客
03-24 1242
CCF-CSP【202303-3 LDAP】C++
CSP认证202303-3:LDAP (超详细题解)
ewoifuoi的博客
03-23 5134
对于一个逻辑操作表达式的前后两个部分, 我们发现他们无论怎么嵌套, 每个部分的括号一定是匹配的, 可以维护一个括号栈, 遍历字符串直到括号栈空, 此时字符串的位置 (本文为。原子操作分为匹配和剔除, 匹配满足条件(属性名为相应属性值)的用户集合可以直接从刚才的map里找到, 作为答案, 而剔除时需要注意,) ,可以考虑维护以属性名和属性值为索引, 对应值为符合条件的用户的set 的一个map。逻辑操作主要是符合条件的用户集合的交和并, 以及逻辑操作的嵌套, 这里用两个set。来暂存符合条件的用户。
CCF-CSP 29次 第三题【202303-3 LDAP】
qq_51879318的博客
04-17 3983
本来是奔着解决前40分的，没想到拿到了100分，但由于非常暴力，运行时间达到了10s多。
ccf-csp 第二十九次第三题-LDAP（满分python）
m0_56621633的博客
05-10 779
python 100分
CSP-202303-3 LDAP
CodeArhat的专栏
05-24 996
CSP认证2023年3月份第3题：LDAP
CCF-CSP认证历年真题
03-05
### CCF-CSP认证知识点解析 #### 一、CCF-CSP认证简介 CCF-CSP（Certified Software Professional）认证是由中国计算机学会（CCF）主办的一项软件能力认证项目，旨在客观评价软件开发人员的实际编程能力。通过一...
2019CCF-CSP-J初赛试题与解析.doc
10-08
2019CCF-CSP-J初赛试题与解析，提供给需要复习和练习的学生和家长老师等 2019CCF-CSP-J初赛试题与解析，提供给需要复习和练习的学生和家长老师等 2019CCF-CSP-J初赛试题与解析，提供给需要复习和练习的学生和家长...
CCF-CSP认证考试历年真题
最新发布
03-31
ccfcsp历年考试真题解答 不含答案
CSP202303-03 LDAP
shandiandwb的博客
03-24 296
3.——>本人学到的点，输出结果要求什么格式，本题我忽略了结果间要排序，导致最后不知道为什么错误。终端测试输入合不合要求，这样之后debug比较省时间。一类原子式，一类多项式，多项式利用到原子式。1.确定好新造的数据结构。
CSP-202303-3-LDAP
fzy2003的博客
02-22 854
是 C++ 标准库中的一种关联容器，它提供了基于键值对的高效查找、插入和删除操作。在这里，使用快速查找的查找时间复杂度是 O(1)，本题可以用于根据属性名和属性值查找对应的DN。高效插入和删除的插入和删除操作同样是O(1)级别的。键值对的唯一性中的键是唯一的，这符合属性名-属性值对应用户集合的关系，每个键对应一个用户集合。无序性中的键值对是无序存储的，但对于属性名-属性值对应用户集合的映射关系而言，这通常是没有问题的，因为我们是通过属性名和属性值来进行查找，而不是关心它们的顺序。
2023CSP-CCF C题 LDAP
qwiudfbqi的博客
09-17 111
用户 1 具有属性 1 和属性 2，且属性 1 的值为 2，属性 2 的值为 3；用户 2 具有属性 2 和属性 3，且属性 2 的值为 3，属性 3 的值为 1；接下来 � 行，每行包含空格分隔的若干个正整数，第一个正整数表示该用户的 DN，第二个正整数表示该用户具有的属性个数，此后的每两个正整数表示该用户具有的一个属性及其值。一个匹配表达式可以是一个属性的值，也可以是多个匹配表达式的逻辑组合。输出 � 行，每行包含零个或多个正整数，用空格分隔，表示与对应的匹配表达式相匹配的用户的 DN，由小到大排序。
CCF-CSP真题《202303-3 LDAP》思路+python，c++满分题解
weixin_53919192的博客
07-05 6041
本文为大家用c++满分题解CCF-CSP真题《202303-3 LDAP》，希望对你有帮助
LDAP题解csp
m0_64652057的博客
03-20 237
这道题要注意表达式中还可能嵌套表达式，主要有两种情况，一种是原子表达式，只需通过find函数查找：或者~符号，然后截取相应的子串，遍历每个用户的属性数组看对应key下的val是否相等；另一种是表达式形式，需运用递归思想，只要str[0]是数字（即这是一个原子表达式）就直接返回原子表达式处理结果，否则查找最中间的）（或者（ ），将字符串一分为二，分别求其结果。另外就是这道题很容易超时。最好用unordered_map而不是map，以及加上ios::sync_with_stdio(false)。
2023CSP-CCF前三题 田地丈量、垦田计划、LDAP解题分析
weixin_60344133的博客
04-04 9895
2023.03.19第29次CCF-CSP计算机认证考试前三道题的分析（很详细！）
CCF-CSP 202303(持续更新)
m0_74087709的博客
05-26 171
蓝色的矩形长算出来是负的，不能算进去。
CCF201903-2二十四点【字符串栈处理】
weixin_46134673的博客
12-01 188
CCF201903-2二十四点 字符串栈处理
CCF-CSP 201903-2 二十四点 模拟 栈 计算表达式
weixin_45448563的博客
03-11 131
题目链接 #include<iostream> using namespace std; #include<stack> #include<string> #include<unordered_map> stack<char> op; stack<int> num; unordered_map<char,int> grades; int n; void eval() //注意对于'/' C++和java是向0取整，p
CCF 201903-2 二十四点 用栈模拟简单计算器
RPG_Zero的博客
09-07 469
二十四点 来源：CCF 背景 二十四点是一款著名的纸牌游戏，其游戏的目标是使用 3 个加减乘除运算使得 4张纸牌上数字的运算结果为 24。 题目 定义每一个游戏由 4 个从 1-9 的数字和 3 个四则运算符组成，保证四则运算符将数字两两隔开，不存在括号和其他字符，运算顺序按照四则运算顺序进行。其中加法用符号 + 表示，减法用符号 - 表示，乘法用小写字母 x 表示，除法用符号 / 表示。在游戏...
ccf-csp20230504
10-01
ccf-csp20230504是CCF(CCF(Calculus Competition Foundation))举办的CSP(Computer Science Proficiency)考试的日期，即2023年5月4日。在这个考试中，对于CSP认证的知识要求包括数据结构中的线性表、树、集合和映射等内容，还包括一些算法问题，比如背包问题（动态规划）等。具体的考试题型可能包括一般的水题，以及C语言的相关题目。希望这个回答对您有帮助！
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值