版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/AivenZhong/article/details/83515809
题目很长，大家自行去官网看。
第三题还是一如既往的是大模拟，模拟css元素选择器，有接触过前端的同学对此不陌生了吧。
以前学css的时候就想过层叠样式表的实现，但是也没细究。ccf第三题有出过markdown转html的，我就预测ccf还会再出前端类的题目，那时候猜可能会是css，没想到真的出了。这些题外话了，还是讲回题目吧，这题难度不算高，但是细节决定成败。
思路：
结点类：
包含该结点的行数，标签名，id名，父结点（前继结点，存储父结点的意义是为了后面的查询，从后往前找，比从前往后找好，你想想每个结点有多个子节点，但只有唯一父结点，从前往后要找出对应的序列得嵌套多少次循环啊）和子节点列表
1.整理输入：先把输入的结构化文档由结点连成一棵树，每个结点要脸上树，就看前面有多少个点（点数/2==往下的级数），从根节点出发找到对应的父结点再连上
2.查找：每个查询都进行一次树的遍历（我用的是层次遍历），找到对应的选择器就开始往上找父元素。注意，选择器从后往前匹配，比如 div a h1, 就在遍历的时候找h1元素，从h1开始匹配，再往上找父元素a， div。再注意，这里的父元素，是所有祖先元素，往上一级找不到就继续往上一级找，直到选择器组都匹配完就记录这个结点的行数，次数加1。
3.细节：标签在结构化文档中和查询的选择器中大小写都有可能，而标签名大小写不敏感，所以遇到标签要化为小写。
新改动：
之前代码有个很难找的BUG，才90，现在终于找到问题所在了，终于AC100。这还得感谢我的一个朋友。
问题出在我的根结点，我的根结点的标签是“root”，理论上这个root不应该被匹配到，而且刚刚好ccf的测试用例的选择器也有root，所以选择上了。答案应该是0才对。解决方法：把根节点的标签（label）名换一个就是了，干脆空字符串"".
Java代码：
import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.Scanner;
public class 元素选择器 {
static Scanner input = new Scanner(System.in);
//static Node root = new Node(0, null, "root", ""); 修改前 90
static Node root = new Node(0, null, "", ""); //修改后 100
public static void main(String[] args) {
int n = input.nextInt();
int m = input.nextInt();
//接收结构化文档，并整理好结构
input.nextLine();
getDateToTree(n);
//对每个选择器进行匹配，输出匹配结果
printAns(m);
}
//接收结构化文档，并整理成树结构
public static void getDateToTree(int n) {
for (int i = 0; i < n; i++) {
String[] line = input.nextLine().split(" ");
int dotCount = 0;
int idx = 0;
for (int j = 0; j < line[0].length() && line[0].charAt(j) == '.'; j++) {
dotCount++;
idx++;
}
//把标签转为小写
String label = line[0].substring(idx, line[0].length()).toLowerCase();
String id = line.length == 2 ? line[1] : "";
//指针每次从根结点开始找，找dotCount/2次
Node pointer = root;
for (int j = 0; j < dotCount / 2; j++)
pointer = pointer.subNodes.get(pointer.subNodes.size() - 1);
pointer.subNodes.add(new Node(i + 1, pointer, label, id));
}
}
//对每个选择器进行匹配，输出匹配结果
public static void printAns(int m) {
for (int i = 0; i < m; i++) {
//该列表存储的是选择器匹配到的标签们在结构化文档中的行数
ArrayList<Integer> lineNums = new ArrayList<>();
String[] line = input.nextLine().split(" ");
match(lineNums, line);
lineNums.sort(Comparator.comparing(Integer::byteValue));
System.out.print(lineNums.size());
for (int lineNum : lineNums)
System.out.print(" " + lineNum);
System.out.println();
}
}
//选择器匹配，层次遍历结构树，对每个结点进行匹配
public static void match(ArrayList<Integer> lineNums, String[] line) {
LinkedList<Node> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
Node tem = queue.poll();
//从选择器最底端开始匹配
//如果选择器是标签就改为小写
String seleter = line[line.length - 1].charAt(0) == '#' ?
line[line.length - 1] : line[line.length - 1].toLowerCase();
if (seleter.equals(tem.label) || seleter.equals(tem.id)) {
int lineIdx = line.length - 2;
Node pointer = tem.preNode;
//从最下级开始往上找父元素
while (pointer != null && lineIdx >= 0) {
//如果选择器是标签就改为小写
seleter = line[lineIdx].charAt(0) == '#' ?
line[lineIdx] : line[lineIdx].toLowerCase();
if (pointer.label.equals(seleter) ||
pointer.id.equals(seleter)) {
lineIdx--;
}
pointer = pointer.preNode;
}
if (lineIdx == -1)
lineNums.add(tem.lineNum);
}
//子结点入队
for (Node val : tem.subNodes)
queue.offer(val);
}
}
}
//标签元素结点类
class Node {
int lineNum;//元素所在的行数
Node preNode;
ArrayList<Node> subNodes = new ArrayList<>();//子结点列表
String label;
String id;
Node(int lineNum, Node preNode, String label, String id) {
this.lineNum = lineNum;
this.preNode = preNode;
this.label = label;
this.id = id;
}
}
python代码：
# 标签元素结点类
class Node:
def __init__(self, lineNum, preNode, label, id):
self.lineNum = lineNum # 元素所在的行数
self.preNode = preNode # 父节点
self.label = label # 标签
self.id = id # id
self.subNodes = [] # 子结点列表
# 接收结构化文档，并整理成树结构
def get_date_to_tree(n, root):
for i in range(n):
line = input().split()
dotCount = 0
idx = 0
for j in range(len(line[0])):
if line[0][j] == '.':
dotCount += 1
else:
idx = j
break
# 把标签转为小写
label = line[0][idx:len(line[0])].lower()
id = line[1] if len(line) == 2 else ""
# 指针每次从根结点开始找，找dotCount/2次
pointer = root
for j in range(int(dotCount / 2)):
pointer = pointer.subNodes[len(pointer.subNodes) - 1]
pointer.subNodes.append(Node(i + 1, pointer, label, id))
# 对每个选择器进行匹配，输出匹配结果
def print_ans(m, root):
for i in range(m):
# 该列表存储的是选择器匹配到的标签们在结构化文档中的行数
lineNums = []
line = input().split()
match(lineNums, line, root)
print(len(lineNums), end=' ')
for lineNum in sorted(lineNums):
print(lineNum, end=' ')
print()
# 选择器匹配，层次遍历结构树，对每个结点进行匹配
def match(lineNums, line, root):
queue = []
queue.append(root)
while queue:
tem = queue.pop(0)
# 从选择器最底端开始匹配
# 如果选择器是标签就改为小写
seleter = line[len(line) - 1] if line[len(line) - 1][0] == '#' else \
line[len(line) - 1].lower()
if seleter == tem.label or seleter == tem.id:
lineIdx = len(line) - 2
pointer = tem.preNode
# 从最下级开始往上找父元素
while (pointer != None and lineIdx >= 0):
# 如果选择器是标签就改为小写
seleter = line[lineIdx] if line[lineIdx][0] == '#' else \
line[lineIdx].lower()
if (pointer.label == seleter or
pointer.id == seleter):
lineIdx -= 1
pointer = pointer.preNode
if (lineIdx == -1):
lineNums.append(tem.lineNum)
# 子节点入队
for val in tem.subNodes:
queue.append(val)
# 主程序逻辑
# root = Node(0, None, "root", "") 修改前 90
root = Node(0, None, "", "") # 修改后 100
n, m = [int(val) for val in input().split()]
# 接收结构化文档，并整理好结构
get_date_to_tree(n, root)
# 对每个选择器进行匹配，输出匹配结果
print_ans(m, root)