CCF权限查询

问题描述

　　授权 (authorization) 是各类业务系统不可缺少的组成部分，系统用户通过授权机制获得系统中各个模块的操作权限。
　　本题中的授权机制是这样设计的：每位用户具有若干角色，每种角色具有若干权限。例如，用户 david 具有 manager 角色，manager 角色有 crm:2 权限，则用户 david 具有 crm:2 权限，也就是 crm 类权限的第 2 等级的权限。
　　具体地，用户名和角色名称都是由小写字母组成的字符串，长度不超过 32。权限分为分等级权限和不分等级权限两大类。分等级权限由权限类名和权限等级构成，中间用冒号“:”分隔。其中权限类名也是由小写字母组成的字符串，长度不超过 32。权限等级是一位数字，从 0 到 9，数字越大表示权限等级越高。系统规定如果用户具有某类某一等级的权限，那么他也将自动具有该类更低等级的权限。例如在上面的例子中，除 crm:2 外，用户 david 也具有 crm:1 和 crm:0 权限。不分等级权限在描述权限时只有权限类名，没有权限等级（也没有用于分隔的冒号）。
　　给出系统中用户、角色和权限的描述信息，你的程序需要回答多个关于用户和权限的查询。查询可分为以下几类：
　　* 不分等级权限的查询：如果权限本身是不分等级的，则查询时不指定等级，返回是否具有该权限；
　　* 分等级权限的带等级查询：如果权限本身分等级，查询也带等级，则返回是否具有该类的该等级权限；
　　* 分等级权限的不带等级查询：如果权限本身分等级，查询不带等级，则返回具有该类权限的等级；如果不具有该类的任何等级权限，则返回“否”。

输入格式

　　输入第一行是一个正整数 p，表示不同的权限类别的数量。紧接着的 p 行被称为 P 段，每行一个字符串，描述各个权限。对于分等级权限，格式为 <category>:<level>，其中 <category> 是权限类名，<level> 是该类权限的最高等级。对于不分等级权限，字符串只包含权限类名。
　　接下来一行是一个正整数 r，表示不同的角色数量。紧接着的 r 行被称为 R 段，每行描述一种角色，格式为
　　<role> <s> <privilege 1> <privilege 2> ... <privilege s>
　　其中 <role> 是角色名称，<s> 表示该角色具有多少种权限。后面 <s> 个字符串描述该角色具有的权限，格式同 P 段。
　　接下来一行是一个正整数 u，表示用户数量。紧接着的 u 行被称为 U 段，每行描述一个用户，格式为
　　<user> <t> <role 1> <role 2> ... <role t>
　　其中 <user> 是用户名，<t> 表示该用户具有多少种角色。后面 <t> 个字符串描述该用户具有的角色。
　　接下来一行是一个正整数 q，表示权限查询的数量。紧接着的 q 行被称为 Q 段，每行描述一个授权查询，格式为 <user> <privilege>，表示查询用户 <user> 是否具有 <privilege> 权限。如果查询的权限是分等级权限，则查询中的 <privilege> 可指定等级，表示查询该用户是否具有该等级的权限；也可以不指定等级，表示查询该用户具有该权限的等级。对于不分等级权限，只能查询该用户是否具有该权限，查询中不能指定等级。

输出格式

　　输出共 q 行，每行为 false、true，或者一个数字。false 表示相应的用户不具有相应的权限，true 表示相应的用户具有相应的权限。对于分等级权限的不带等级查询，如果具有权限，则结果是一个数字，表示该用户具有该权限的（最高）等级。如果用户不存在，或者查询的权限没有定义，则应该返回 false。

样例输入

3
crm:2
git:3
game
4
hr 1 crm:2
it 3 crm:1 git:1 game
dev 2 git:3 game
qa 1 git:2
3
alice 1 hr
bob 2 it qa
charlie 1 dev
9
alice game
alice crm:2
alice git:0
bob git
bob poweroff
charlie game
charlie crm
charlie git:3
malice game

样例输出

false
true
false
2
false
true
false
true
false

样例说明

　　样例输入描述的场景中，各个用户实际的权限如下：
　　* 用户 alice 具有 crm:2 权限
　　* 用户 bob 具有 crm:1、git:2 和 game 权限
　　* 用户 charlie 具有 git:3 和 game 权限
　　* 用户 malice 未描述，因此不具有任何权限

评测用例规模与约定

　　评测用例规模：
　　* 1 ≤ p, r, u ≤ 100
　　* 1 ≤ q ≤ 10 000
　　* 每个用户具有的角色数不超过 10，每种角色具有的权限种类不超过 10
　　约定：
　　* 输入保证合法性，包括：
　　1) 角色对应的权限列表（R 段）中的权限都是之前（P 段）出现过的，权限可以重复出现，如果带等级的权限重复出现，以等级最高的为准
　　2) 用户对应的角色列表（U 段）中的角色都是之前（R 段）出现过的，如果多个角色都具有某一分等级权限，以等级最高的为准
　　3) 查询（Q 段）中的用户名和权限类名不保证在之前（U 段和 P 段）出现过
　　* 前 20% 的评测用例只有一种角色
　　* 前 50% 的评测用例权限都是不分等级的，查询也都不带等级

思路：

第一步：用3个结构体数组表示用户、角色、权限的信息，定义如下：

struct Privilege  //定义权限 {string name;int level;};struct Role  //定义角色 {string name;struct Privilege privilege[11];int priviNum;};struct User  //定义用户 {string name;struct Role uRole[11];int roleNum; }; 

第二步：然后就是输入权限、角色、用户的信息。这里要理清关系：一个用户可以有多个角色，一个角色有多个权限

第三步：输入查询信息，开始查询：先查询用户信息，若用户存在，再遍历用户的角色，再遍历每个角色的权限信息，当权限名字相等时，判断查询的种类，根据查询的种类改变标识变量的值。

第四步：根据标识变量输出结果

AC代码（有点多）：

#include<iostream>#include<string>using namespace std;struct Privilege  //定义权限 {string name;int level;};struct Role  //定义角色 {string name;struct Privilege privilege[11];int priviNum;};struct User  //定义用户 {string name;struct Role uRole[11];int roleNum; }; struct User user[101];struct Role role[101];struct Privilege pri[101]; int findRole(string name){int i;for(i = 0; i < 100; i++){if(role[i].name == name){return i;}}return -1;}int findUser(string name){int i;for(i = 0; i < 100; i++){if(name == user[i].name){return i;}}return -1;}struct Privilege getPrivilege(string quanxian){struct Privilege p;if(quanxian.find(":",0) != string::npos)  // 权限带等级 {int pos =  quanxian.find(":",0);p.name = quanxian.substr(0,pos);p.level = quanxian.at(quanxian.length()-1)-'0';}else  //不带等级 {p.name = quanxian;p.level = -1; }return p;}int findPrivilege(string name){int i;for(i = 0; i < 100; i++){if(pri[i].name == name){return i;}}return -1;} int main(){int p,u,r,i,j,q,k;string quanxian;cin>>p; //输入权限for(i = 0; i < p; i++){cin>>quanxian;pri[i] = getPrivilege(quanxian);}cin>>r;//  输入角色for(i = 0; i < r; i++){string username;cin>>role[i].name;cin>>role[i].priviNum;for(j = 0; j < role[i].priviNum; j++)  //输入角色的特权 {string quanxian;cin>>quanxian;role[i].privilege[j] = getPrivilege(quanxian);}} cin>>u;//输入用户for(i = 0; i < u; i++){cin>>user[i].name;cin>>user[i].roleNum;for(j = 0; j < user[i].roleNum; j++){string rolename;cin>>rolename;user[i].uRole[j] = role[findRole(rolename)];}}cin>>q;// 开始查询for(i = 0; i < q; i++){string name;string quanxian;cin>>name>>quanxian;int priviFlag = 0;int maxLevel = -1;if(findUser(name) != -1)  //找到用户 {User u = user[findUser(name)];for(j = 0; j < u.roleNum; j++)  // 遍历用户的角色 {for(k = 0; k < u.uRole[j].priviNum; k++)  //遍历每个角色的特权 {struct Privilege p;p = getPrivilege(quanxian);if (p.name == u.uRole[j].privilege[k].name)  //找到了带权限的用户 { if(p.level == -1 && u.uRole[j].privilege[k].level == -1)  //不分等级权限的不分等级查询  { priviFlag = 1; }else if(p.level == -1 && u.uRole[j].privilege[k].level != -1) //分等级权限的不分等级查询  { if(maxLevel < u.uRole[j].privilege[k].level) { priviFlag = 1; maxLevel = u.uRole[j].privilege[k].level; }  }else if(p.level != -1 && u.uRole[j].privilege[k].level != -1)//分等级权限的分等级查询  { if(p.level <= u.uRole[j].privilege[k].level){ priviFlag = 1;} } }}}}if(priviFlag == 1 && maxLevel != -1){cout<<maxLevel<<endl;}else if(priviFlag == 1 && maxLevel == -1){cout<<"true"<<endl;}else if(priviFlag == 0){cout<<"false"<<endl;}}return 0;} 

PS：题中的“否”就是指“false”，题目出错了，真是无语，这么大的一个考试，出这种问题，若要输出“否”，在输出结果时候还得判断查询种类

笔记：以后对于这种查询类的题目，最好将查询方法全部用函数封装起来，这样也方便编码，思路更清晰，记得注释代码，每隔一段时间重构一下代码。

在输出结构时要仔细查看题目中给出的不同的限制条件，将条件列出来再解答，不然思路很乱。

最后：测试输入案例居然是可以复制粘贴的 啊啊啊啊啊啊 ！！！

-----------------------------------------------------------------------------------------------2017-03-5再做一次的代码，少了一些--------------------------------------------------------------------------

#include<iostream>#include<string>using namespace std;struct Category{string name;int level;};struct Role{string roleName; struct Category roleCategory[11];int categoryNum;};struct User{string userName;struct Role userRole[11];int roleNum; };struct Category cate[101];struct Role role[101];struct User user[101]; int p,r,u,q;struct Category getCategory(string s){int index;struct Category c;if((index = s.find(":",0))!= string::npos){c.name = s.substr(0,index);c.level = s.at(s.length()-1)-'0';}else{c.name = s;c.level = -1;}return c;} int findUser(string name){int i;for(i = 0; i < u; i++){if(user[i].userName == name){return i;}}return -1;}int findRole(string roleName){int i;for(i = 0; i < r; i++){if(role[i].roleName == roleName){return i;}}return -1;} void findCategory(struct User oneUser,string quanxian){int i,j;string quanxianName;int flag = 0;int level,index,maxLevel = -1;if((index = quanxian.find(":",0))!=string::npos){quanxianName = quanxian.substr(0,index);level = quanxian.at(quanxian.length()-1)-'0';}else{quanxianName = quanxian;level = -1;}for(i = 0; i < oneUser.roleNum; i++){struct Role oneRole = oneUser.userRole[i];for(j = 0; j < oneRole.categoryNum; j++){struct Category oneCategory = oneRole.roleCategory[j];// 不分等级权限的不分等级查询 if(oneCategory.name == quanxianName && oneCategory.level == level && level == -1){flag = 1;}//  分等级权限带等级查询if(oneCategory.name == quanxianName && level != -1 && oneCategory.level >= level){flag = 1;}//  分等级权限不带等级查询if(level == -1 && oneCategory.level != -1 && quanxianName == oneCategory.name){if(oneCategory.level > maxLevel){maxLevel = oneCategory.level;flag = 2;}} }}if(flag == 1){cout<<"true"<<endl;}if(flag == 2){cout<<maxLevel<<endl;}if(flag == 0){cout<<"false"<<endl;}}int main(){int i,j;string s;cin>>p;// 输入权限 for(i = 0; i < p; i++){cin>>s;cate[i] = getCategory(s);}cin>>r;//输入角色 for(i = 0; i < r; i++){cin>>role[i].roleName;cin>>role[i].categoryNum;// 遍历输入角色的每个权限 for(j = 0; j < role[i].categoryNum; j++){cin>>s;role[i].roleCategory[j] = getCategory(s);}}cin>>u;//输入用户 for(i = 0; i < u; i++){cin>>user[i].userName;cin>>user[i].roleNum;int index;for(j = 0; j < user[i].roleNum; j++){cin>>s;if((index = findRole(s))!= -1){user[i].userRole[j] = role[index];}}}cin>>q;//开始查询while(q--){string name;string quanxian;cin>>name>>quanxian; int index;//用户查询if((index = findUser(name))!= -1){//找到用户 struct User oneUser = user[index];findCategory(oneUser,quanxian);}else{cout<<"false"<<endl;} } return 0;}