省市区过滤

用例1：
输入：[["SCQ", "ZHSZH"], ["XCQ", "ZHSZH"], ["ZH", "WWS"], ["ZHSZH", "QJS"], ["WWS", "QJS"], ["WW", "XCQ"]] 
     "ZZH"
输出：2

QJS
|-  ZHSZH
     |-  SCQ
     |-  XCQ
          |-  WW
|-  WWS

     |-  ZH

用例2：
输入：[["HA", "A"], ["HC", "A"], ["D", "HA"], ["HD", "D"]]
     "H"

输出：2

A
|-  HA
     |-  D
         |-  HD
|-  HC

#include <unordered_map>
#include <vector>
#include <string>
#include <iostream>

using std::unordered_map;
using std::vector;

struct TreeNode
{
	TreeNode *parent = nullptr;	// 父节点
	std::vector<TreeNode*> children;	// 孩子节点数组
	bool isMatched = false;	// 是否满足匹配地区的条件
};

class Solution
{
private:
	std::unordered_map<char, int>	keyWordMap;	// 关键字的字符个数计数map
	TreeNode *root;
	int count = 0;
public:
	int MatchPaths(const std::vector<std::pair<std::string, std::string>> &areas,
		const std::string &keyword)
	{
		keyWordMap = GetStringMap(keyword);
		root = CreateTree(areas);
		dfs(root, false);
		return count;
	}

	TreeNode* CreateTree(const std::vector<std::pair<std::string, std::string>> &areas)
	{
		// 临时存放treeNode，用于快速构建树
		std::unordered_map<std::string, TreeNode*> tmpMap;
		for (int i = 0; i < areas.size(); i++) {
			// 1. 判断并构建父节点
			auto pParent = tmpMap.find(areas[i].second);
			TreeNode *parentNode = nullptr;
			if (pParent == tmpMap.end()) {
				parentNode = new TreeNode;
				// 判断是否是满足条件的节点
				parentNode->isMatched = ContainKeyword(GetStringMap(areas[i].second));
				tmpMap.insert({ areas[i].second, parentNode });
			} else {
				parentNode = pParent->second;
			}
			// 2. 查找或构建当前节点
			auto current = tmpMap.find(areas[i].first);
			TreeNode *currentNode = nullptr;
			if (current == tmpMap.end()) {
				currentNode = new TreeNode;
				// 判断是否是满足条件的节点
				currentNode->isMatched = ContainKeyword(GetStringMap(areas[i].first));
				tmpMap.insert({ areas[i].first, currentNode });
			} else {
				currentNode = current->second;
			}
			// 3. 构建父子节点关系
			currentNode->parent = parentNode;
			parentNode->children.push_back(currentNode);
		}
		// 4. 查找根节点，注意：根节点的parent父节点为空
		for (auto &item : tmpMap)
		{
			if (item.second->parent == nullptr) {
				return item.second;
			}
		}
		return nullptr;
	}

	// 将字符串转换为map，用于判断是否满足匹配条件
	std::unordered_map<char, int> GetStringMap(const std::string &keyword)
	{
		std::unordered_map<char, int> resultMap;
		for (auto ch : keyword) {
			resultMap[ch]++;
		}
		return resultMap;
	}

	// 查看原map是否包含keyWordMap中的所有字符
	bool ContainKeyword(const std::unordered_map<char, int> &source)
	{
		for (const auto &item : keyWordMap)
		{
			auto iter = source.find(item.first);
			if (iter == source.end() || iter->second < item.second)
			{
				return false;
			}
		}
		return true;
	}

	// 遍历树节点，查找可能存在的路径数量，flag表示父节点中是否存在匹配的节点
	void dfs(TreeNode *root, bool flag)
	{
		if (!root->children.empty())
		{
			for (auto node : root->children)
			{
				dfs(node, flag | root->isMatched);
			}
			return;
		}
		if (root->isMatched | flag)
		{
			count++;
		}
	}

	void Remove(TreeNode *root)
	{
		if (root == nullptr) {
			return;
		}
		if (root->children.empty()) {
			for (auto iter = root->children.begin(); iter != root->children.end();) {
				Remove(*iter);
				iter = root->children.erase(iter);
			}
		}
		delete root;
	}

	virtual ~Solution()
	{
		Remove(root);
	}

};

int main()
{
	// D -> HA
	// BAX -> SHENZHEN
	// HA -> CXQ
	// D -> BAX
	Solution sol;
	std::vector<std::pair<std::string, std::string>> areas = {
		{"HA", "D"},
		{"SHENZHEN", "BAX"},
		{"CXQ", "HA"},
		{"BAX", "D"}
	};
	// D
	//	 |- HA
	//			|- CXQ
	//	 |- BAX
	//			|- SHENZHEN
	std::string keyword = "ZSEE";	// ZSEE 1
	// A 2
	// D 2
	int resultCnt = sol.MatchPaths(areas, keyword);
	std::cout << resultCnt << std::endl;

	return 0;
}