CCP-CSP认证考试 201612-3 权限查询 c/c++题解

题目描述

题解：

先声明一下，只完成了60分（有50%的样例是 不带等级权限+不带等级的查询，所以我考虑了带等级的情况，但是没有考虑好）
我的思路：
先来处理输入：

1. 每个权限作为一个 pair<string,int>，string表示权限的名字，int表示权限的等级(如果没有等级就是-1)
2. 角色作为一个结构体数组，每个元素保存了名称、权限数量、具体的权限名称
3. 用户作为一个结构体数组，每个元素保存了名称、角色数量、具体的角色名称
4. 每次输入的用户名和权限名就是string即可
   然后考虑查询过程：
   调用一个 QueryFun(userName,authorization) 函数进行查询，返回值：
   0：表示查询不到对应的权限（没有这个权限 or 对不带等级权限的 带等级查询）
   1：有这个权限（对不带等级权限 的 不带等级查询）

=2：输出权限的等级（对带等级权限的的 带等级查询 or 对带等级权限的 不带等级查询）
再就是实现QueryFun函数的思路：

1. 首先判断查询是否带等级
2. 开循环去遍历：
   遍历所有的用户名，如果连要查询的用户都没有就直接return false

代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cstring>
#include <string>
#include <algorithm>
#include <vector>
#include <deque>
#include <list>
#include <utility>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <bitset>
#include <iterator>
using namespace std;

typedef long long ll;
const int inf = 0x3f3f3f3f;
const ll  INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1.0);
const double E = exp(1.0);
const int MOD = 1e9+7;
const int MAX = 1e2+5;

int p;// 不同的权限类别的数量
pair <string,int> Authorization[MAX];// 不同的p个权限(包括带等级和不带等级的)，权限的等级

int r;// 不同的角色数量
struct Role
{
    string roleName;// 角色的名称
    int authorizationNum;// 角色的权限数量
    vector <string> roleAuthorization;// 角色拥有的具体权限
};
Role role[MAX];

int u;// 不同的用户数量
struct User
{
    string userName;// 用户的名称
    int roleNum;// 用户的角色数量
    vector <string> userRole;// 用户拥有的具体角色
};
User user[MAX];

// 查询函数主体(给定一个用户名和一个权限名，根据题目的要求查询并输出)
int QueryFun(string userName,string authorization)
{
    /*
        输出共 q 行，
        每行为 false、true，或者一个数字。
        false 表示相应的用户不具有相应的权限，
        true 表示相应的用户具有相应的权限。
        对于分等级权限的不带等级查询，如果具有权限，则结果是一个数字，表示该用户具有该权限的（最高）等级。
        如果用户不存在，或者查询的权限没有定义，则应该返回 false。
    */
    /* 百分之五十的用例是无关等级的，我先直接拿一半的分数*/
    int levelNum;
    bool judgeLevel;
    string authorizationName;
    int len = authorization.length();
    if(isdigit(authorization[len - 1]))
    {
        // 带等级的查询
        judgeLevel = true;
        levelNum = authorization[len-1] - '0';
        authorizationName.assign(authorization,0,len-2);
    }
    else
    {
        // 不带等级的查询
        judgeLevel = false;
        levelNum = -1;
        authorizationName.assign(authorization,0,len);
    }

    /* dubug: 输出查询的情况
    if(judgeLevel == true)
    {
        cout << "带等级查询:" << authorization << endl;
        cout << "权限:" << authorizationName << "等级:" << levelNum << endl;;
    }
    else
    {
        cout << "不带等级查询:" << authorization << endl;
        cout << "权限:" << authorizationName << "等级:" << levelNum << endl;;
    }*/

    // 找到指定的用户userName
    for(int i = 1; i <= u; i++)
    {
        if(user[i].userName == userName)
        {
            // 找到这个用户的角色，因为角色会具有一些权限
            for(int j = 0; j < user[i].roleNum; j++)
            {
                for(int k = 1; k <= r; k++)
                {
                    if(role[k].roleName == user[i].userRole[j])
                    {
                        // 找到这个角色的权限
                        for(int m = 0; m < role[k].authorizationNum; m++)
                        {
                            // 不带等级查询
                            if(judgeLevel == false)
                            {
                                // 如果用户的角色有authorization这个权限
                                // 则要判断该权限有无等级
                                // 1.如果是对 带等级权限 的 不带等级查询，则输出最高等级
                                // 2.如果是对 不带等级权限的 的 不带等级查询，则输出true
                                int len = role[k].roleAuthorization[m].length();
                                string tmp;
                                tmp.assign(role[k].roleAuthorization[m],0,len-2);
                                if(isdigit(role[k].roleAuthorization[m][len - 1]))
                                {
                                    if(tmp == authorizationName)
                                    {
                                        //return levelNum;// 不是输出最高等级吗
                                        return (role[k].roleAuthorization[m][len - 1] - '0');
                                    }
                                }
                                if(role[k].roleAuthorization[m] == authorizationName)
                                {
                                    return true;
                                }
                            }
                            else// 带等级查询
                            {
                                // 如果用户的角色有authorization这个权限
                                // 则要判断
                                // 1.如果是对 带等级权限 的 带等级查询，则要判断等级是否一致，如果一致才能输出true
                                // 2.如果是对 不带等级权限的 的 带等级查询，则直接输出false
                                /*
                                if(role[k].roleAuthorization[m] == authorization)
                                {
                                    return true;// 待优化
                                }
                                */
                                int len = role[k].roleAuthorization[m].length();
                                string tmp;
                                tmp.assign(role[k].roleAuthorization[m],0,len-2);
                                if(isdigit(role[k].roleAuthorization[m][len - 1]))
                                {
                                    if(tmp == authorizationName && (role[k].roleAuthorization[m][len - 1] - '0') == levelNum)
                                    {
                                        return true;
                                    }
                                }
                                else
                                {
                                    if(role[k].roleAuthorization[m] == authorizationName)
                                    {
                                        return false;
                                    }
                                }


                            }
                        }
                    }
                }
            }
        }
    }
    // 输入的用户对应的权限(不看等级的)存在，在前面就直接返回true了
    return false;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    string str;
    cin >> p;
    for(int i = 1; i <= p; i++)
    {
        cin >> str;
        int len = str.length();
        /* 带等级的样例*/
        if(isdigit(str[len-1]))
        {
            // 带等级的权限
            Authorization[i].second = str[len-1] - '0';
            Authorization[i].first = str.assign(str,0,len-2);
        }
        else
        {
            // 不带等级的权限
            Authorization[i].second = -1;
            Authorization[i].first = str.assign(str,0,len);
        }

        Authorization[i].second = -1;
        Authorization[i].first = str;
    }
    /* cout << "debug: 权限的情况:" << endl;
    for(int i = 1; i <= p; i++)
    {
        cout << authorization[i].first << endl;
    }*/
    cin >> r;
    for(int i = 1; i <= r; i++)
    {
        cin >> role[i].roleName >> role[i].authorizationNum;
        string authorization;
        for(int j = 1; j <= role[i].authorizationNum; j++)
        {
            cin >> authorization;
            role[i].roleAuthorization.push_back(authorization);
        }
    }
    /* cout << "debug: 角色的情况:" << endl;
    for(int i = 1; i <= r; i++)
    {
        cout << role[i].roleName << " " << role[i].authorizationNum;
        for(auto it = role[i].roleAuthorization.begin(); it != role[i].roleAuthorization.end(); it++)
        {
            cout << " " << *it;
        }
        cout << endl;
    }*/
    cin >> u;
    for(int i = 1; i <= u; i++)
    {
        cin >> user[i].userName >> user[i].roleNum;
        string role;
        for(int j = 1; j <= user[i].roleNum; j++)
        {
            cin >> role;
            user[i].userRole.push_back(role);
        }
    }
    /* cout << "debug: 用户的情况:" << endl;
    for(int i = 1; i <= r; i++)
    {
        cout << user[i].userName << " " << user[i].roleNum;
        for(auto it = user[i].userRole.begin(); it != user[i].userRole.end(); it++)
        {
            cout << " " << *it;
        }
        cout << endl;
    }*/
    int q;// 查询次数，用来查询用户的权限
    cin >> q;
    string userName,authorization;// 用户名称 , 要查询的权限
    for(int i = 1; i <= q; i++)
    {
        cin >> userName >> authorization;
        int res = QueryFun(userName,authorization);
        if(res == 0)
        {
            cout << "false" << endl;
        }
        else
        {
            if(res == 1)
            {
                cout << "true" << endl;
            }
            else
            {
                cout << res << endl;
            }
        }
    }

    return 0;
}