（一）題目要求

參考一篇C語言實現的博文，用java實現，經測試，結果正確，若有沒考慮到的地方，請各位博友指正

問題描述
　　授權 (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 段，每行一個字串，描述各個許可權。對於分等級許可權，格式為 :，其中 是許可權類名， 是該類許可權的最高等級。對於不分等級許可權，字串只包含許可權類名。
　　接下來一行是一個正整數 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% 的評測用例許可權都是不分等級的，查詢也都不帶等級

（二）java程式實現

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;

class Authority{
    String name;
    Map<String,Integer> authorities = new HashMap<>();
    public void setAuth(Map<String,Integer> authorities){
        this.authorities = authorities;
    }
}

class User extends Authority{
    public User(String name){
        this.name = name;
    }
}

class Role extends Authority{
    public Role(String name){
        this.name = name;
    }
}

public class Main {
    public static void main(String[] args) {
        int n;
        Scanner sc = new Scanner(System.in);
        String str;
        n = sc.nextInt();
        //輸入許可權,此處只為滿足測試要求
        for (int i = 0; i < n; i++) {
            str = sc.next();
        }
        //輸入角色描述
        n = sc.nextInt();
        Role[] roles = new Role[n];
        int nn;
        for (int i = 0; i < n; i++) {
            Role role = new Role(sc.next());
            nn = sc.nextInt();
            Map<String, Integer> authorities = role.authorities;
            for (int j = 0; j < nn; j++) {
                str = sc.next();
                String[] auth = str.split(":");
                Integer newLevel = null;
                if(auth.length==2){
                    newLevel = Integer.parseInt(auth[1]);
                    Integer level = authorities.get(auth[0]);
                    if(level != null){
                        newLevel = level>newLevel?level:newLevel;
                    }
                }
                authorities.put(auth[0], newLevel);
            }
            role.setAuth(authorities);
            roles[i] = role;
        }
        //輸入使用者描述
        n = sc.nextInt();
        User[] users = new User[n];
        for (int i = 0; i < n; i++) {
            User user = new User(sc.next());
            Map<String, Integer> authorities = user.authorities;
            nn = sc.nextInt();
            for (int j = 0; j < nn; j++) {
                String roleName = sc.next();
                //判斷此角色是否存在
                int k = 0;
                int len = roles.length;
                while(k<len){
                    if(roleName.equals(roles[k].name)){
                        break;
                    }
                    k++;
                }
                //如果此角色存在，則把其下的所有許可權，賦給使用者
                if(k != len){
                    Map<String, Integer> authoritiesRole = roles[k].authorities;
                    Set<Entry<String, Integer>> entrySet = authoritiesRole.entrySet();
                    for (Entry<String, Integer> entry : entrySet) {
                        String key = entry.getKey();
                        Integer newLevel = entry.getValue();
                        Integer level = authorities.get(key);
                        //若重複，保留許可權大的
                        if(level != null){
                            newLevel = level>newLevel?level:newLevel;
                        }
                        authorities.put(key,newLevel);
                    }
                }
            }
            user.setAuth(authorities);
            users[i] = user;
        }
        //最後，對輸入的使用者，許可權進行檢查
        n = sc.nextInt();
        String[] results = new String[n];
        for (int i = 0; i < n; i++) {
            String userName = sc.next();
            str = sc.next();
            String flag = "false";
            for (User user : users) {
                if(userName.equals(user.name)){
                    //判定該使用者是否有輸入的許可權
                    Map<String, Integer> authorities = user.authorities;
                    String[] auth = str.split(":");
                    Set<Entry<String, Integer>> entrySet = authorities.entrySet();
                    for (Entry<String, Integer> entry : entrySet) {
                        if(auth[0].equals(entry.getKey())){
                            flag = "true";
                            Integer oweLevel = entry.getValue();
                            if(auth.length==2){
                                int level = Integer.parseInt(auth[1]);
                                if(oweLevel!=null && level<=oweLevel){
                                    flag = "true";
                                }else flag = "false";
                            }else{
                                if(oweLevel!=null){
                                    flag = oweLevel.toString();
                                }
                            }
                        }
                    }
                }
            }
            results[i] = flag;
        }
        sc.close();
        //列印判斷結果
        for (String result : results) {
            System.out.println(result);
        }
    }
}