ccsp/src/CSP/A202303/A3/Main.java

package CSP.A202303.A3;

import java.util.*;

/**
 * @Projectname: LeetCode
 * @Filename: CSP.A202303.A3.CSP.A202212.A3.CSP.temp.A1.CSP.temp.A2.CSP.temp.A3.CSP.temp.A4.CSP.temp.A5.Main
 * @Author: 杨逸
 * @Data:2023/8/31 20:40
 * @Description: LDAP-第二题
 */
public class Main {
    private final static Scanner input = new Scanner(System.in);
    private final static Map<Integer, User> users = new HashMap<>();
    private final static List<List<Integer>> result = new ArrayList<>();
    private static int n;
    private static int m;

    public static void main(String[] args) {
        n = input.nextInt();
        for (int i = 0; i < n; i++) {
            int code = input.nextInt();
            //根据编号创建用户
            User user = new User(code);
            users.put(code, user);
            int count = input.nextInt();
            for (int j = 0; j < count; j++) {
                //设置用户的属性
                user.attribute.put(input.nextInt(), input.nextInt());
            }
        }

        //输入查询数量
        m = input.nextInt();
        //创建结果列表
        for (int i = 0; i < m; i++) {
            result.add(new ArrayList<>());
        }
        //进行查询
        StringBuilder temp = new StringBuilder();
        for (int i = 0; i < m; i++) {
            String sentence = input.next();
            List<Integer> list = result.get(i);
            //将查询字符串分割为多个基础表达式
            temp.delete(0, temp.length());
            int left = 0;
            //判断是否有两个组合的逻辑表达式
            int index = -1;
            for (int j = 1; j < sentence.length(); j++) {
                if ((sentence.charAt(j-1)=='&' && sentence.charAt(j)=='&') || (sentence.charAt(j-1)=='&' && sentence.charAt(j)=='|') ||
                        (sentence.charAt(j-1)=='|' && sentence.charAt(j)=='&') || (sentence.charAt(j-1)=='|' && sentence.charAt(j)=='|')){
                    index = j-1;
                    break;
                }
            }
            if (index != -1){
                //存在两个组合逻辑表达式
                List<Integer> list1 = f2(sentence.substring(0, index));
                List<Integer> list2 = f2(sentence.substring(index+1, sentence.length()));
                //根据组合逻辑进行集合运算
                if (sentence.charAt(index)=='|'){
                    //进行或操作
                    for (Integer integer : list1) {
                        if (!list2.contains(integer))list2.add(integer);
                    }
                    for (Integer integer : list2) {
                        list.add(integer);
                    }
                }else {
                    //进行与操作
                    for (Integer integer : list1) {
                        if (list2.contains(integer))list.add(integer);
                    }
                }
            }else{
                //只有一个逻辑表达式
                List<Integer> list1 = f2(sentence);
                //保存到结果集合
                for (Integer integer : list1) {
                    list.add(integer);
                }
            }

        }

        //对查询结果进行排序
        for (List<Integer> list : result) {
            list.sort((v1, v2) -> v1 - v2);
        }
        //输出查询结果

        for (List<Integer> list : result) {
            for (Integer integer : list) {
                System.out.print(integer + " ");
            }
            System.out.println();
        }
    }

    //传进一个原子表达式,返回操作符以及属性以及属性值
    private static int[] f(String str) {
        int left = 0;
        StringBuilder temp = new StringBuilder();
        while (left < str.length() && str.charAt(left) != ':' && str.charAt(left) != '~') {
            temp.append(str.charAt(left++));
        }
        int attr = Integer.valueOf(temp.toString());
        temp.delete(0, temp.length());
        //操作符,true为 ":",false为 "~"
        int operate = str.charAt(left++) == ':' ? 1 : 0;
        //值
        //拼接值编号
        while (left < str.length()) {
            temp.append(str.charAt(left++));
        }
        int val = Integer.valueOf(temp.toString());
        //
        return new int[]{operate, attr, val};
    }

    //传进表达式和保存结果的列表,返回结果列表
    private static List<Integer> f2(String sentence){
        List<Integer> list = new ArrayList<>();
        StringBuilder temp = new StringBuilder();
        int left = 0;
        if (sentence.charAt(0)=='&' || sentence.charAt(0)=='|'){
            //逻辑表达式
            //判断是否与还是或
            if (sentence.charAt(left++)=='&'){
                //与操作
                //先用户中选出满足条件一的

                while(sentence.charAt(left) != ')' && left < sentence.length()){
                    if (sentence.charAt(left)=='('){
                        left++;
                        continue;
                    }
                    temp.append(sentence.charAt(left++));
                }
                int[] f = f(temp.toString());
                temp.delete(0,temp.length());
                boolean flag = f[0]==1;
                int attr = f[1];
                int val = f[2];

                //将满足条件的加入
                ArrayList<Integer> list1 = new ArrayList<>();
                for (Integer integer : users.keySet()) {
                    User user = users.get(integer);
                    if (flag && user.attribute.containsKey(attr) && user.attribute.get(attr)==val){
                        list1.add(user.code);
                    }else if (!flag && user.attribute.containsKey(attr) && user.attribute.get(attr)!=val){
                        list1.add(user.code);
                    }
                }
                //筛选满足剩余条件的
                while(left < sentence.length()-1){
                    left++;
                    while(sentence.charAt(left) != ')' && left < sentence.length()){
                        if (sentence.charAt(left)=='('){
                            left++;
                            continue;
                        }
                        temp.append(sentence.charAt(left++));
                    }
                    f = f(temp.toString());
                    temp.delete(0,temp.length());
                    flag = f[0]==1;
                    attr = f[1];
                    val = f[2];

                    for (Integer integer : list1) {
                        User user = users.get(integer);
                        if (flag && user.attribute.containsKey(attr) && user.attribute.get(attr)==val){
                            //满足条件,不进行操作
                        }else if (!flag && user.attribute.containsKey(attr) && user.attribute.get(attr)!=val){
                            //满足条件,不进行操作
                        }else{
                            //不满足条件删除
                            list1.remove(Integer.valueOf(integer));
                        }
                    }
                }
                //保存最后的结果
                for (Integer integer : list1) {
                    list.add(integer);
                }
            }else {
                //或操作
                //将所有满足条件的用户加入结果
                while(left < sentence.length()-1){
                    left++;
                    while(sentence.charAt(left) != ')' && left < sentence.length()){
                        if (sentence.charAt(left)=='('){
                            left++;
                            continue;
                        }
                        temp.append(sentence.charAt(left++));
                    }
                    int[] f = f(temp.toString());
                    temp.delete(0,temp.length());
                    boolean flag = f[0]==1;
                    int attr = f[1];
                    int val = f[2];

                    //到哈希表中查找
                    for (Integer integer : users.keySet()) {
                        User user = users.get(integer);
                        if (flag && user.attribute.containsKey(attr) && user.attribute.get(attr)==val){
                            if (!list.contains(Integer.valueOf(user.code)))list.add(user.code);
                        }else if (!flag && user.attribute.containsKey(attr) && user.attribute.get(attr)!=val){
                            if (!list.contains(Integer.valueOf(user.code)))list.add(user.code);
                        }
                    }
                }
            }
        }else{
            //原子表达式
            //属性
            //拼接属性编号
            int[] f = f(sentence);
            boolean flag = f[0]==1;
            int attr = f[1];
            int val = f[2];

            //到哈希表中查找
            for (Integer integer : users.keySet()) {
                User user = users.get(integer);
                if (flag && user.attribute.containsKey(attr) && user.attribute.get(attr)==val){
                    if (!list.contains(Integer.valueOf(user.code)))list.add(user.code);
                }else if (!flag && user.attribute.containsKey(attr) && user.attribute.get(attr)!=val){
                    if (!list.contains(Integer.valueOf(user.code)))list.add(user.code);
                }
            }
        }
        return list;
    }

}
class User {
    //用户类
    int code;
    Map<Integer, Integer> attribute = new HashMap<>();

    public User(int code) {
        this.code = code;
    }
}