图的非指针邻接表表示方法，子树权值计数

邻接表存储稀疏图时占用空间小。
坐在马桶上看算法（9）：巧妙的邻接表
其实这是邻接链表的一种数据形式表示，数组u、v、w用来存储每条边的顶点和权值，first数组实际是起到了表头的作用，表示以该下标为顶点的一条边，数组的值指向第一个边节点存储位置（即u v w数组下标），next数组使用该下标存储表示一条链表中的其余的一个边节点存储位置，然后该位置下标又作为next下标存储下一条边存储位置，有多少条边（u v w元素个数）就有多少个next元素，有多少个顶点就有多少个first元素。
可以看出first、next存储的都是一种“地址”，其实就普通链表中指针的作用，只不过指针的地址数组由我们自己维护和构造，相比直接使用指针可能逻辑上要绕一些，但使用起来还是比较好用的，图的遍历什么的同样可以方便的设计出响应算法。
如果指针变量只有一个int大小的话，感觉上可能指针链表可以更省空间（一个点为起点的所有边只需存储一次，而u v w存储多次）吧，但差别不大，一个数量级。

列出一个计算客的算法题，没有ac，目前没解决，但数据结构和遍历算法采用了以上所说的内容（树可以看作特殊的图），可以参考一下：

题目：子树权值计数

已知一棵包含 n 个顶点的有根树，树根顶点为 1 。每个树中的顶点 i 的权值为 w_iw​i​​ 。对该树进行 m 次询问，每次询问求以顶点 u 作为树根的子树中，有多少不同的顶点的权值刚好出现 k 次。

输入格式

第一行包含两个整数 n k ( 1 ≤ k ≤ n ≤ 100000 ) 。

第二行包含 n 个整数，第 i 个整数 w_iw​i​​ ( 0 ≤ w_iw​i​​ ≤ 10^910​9​​ ) ，表示顶点 i 的权值。

接下来 n-1 行每行包含两个整数 u v ( 1 ≤ u , v ≤ n ) ，表示顶点 u 与顶点 v 之间存在一条边直接相连。

接下来一行包含一个整数 m ( 1 ≤ m ≤ 100000 ) 。

接下来 m 行每行包含一个整数 u ( 1 ≤ u ≤ n ) ，表示 m 次询问。

输出格式

输出 m 行，每行输出一个整数，表示每次询问的结果。

样例输入

4 2
1 2 1 2
1 2
1 3
2 4
3
1
2
3

样例输出

2
1
0

//下面代码的算法时间复杂度不符合要求，所以没有ac，应该是算法的问题。
#include <iostream>
#include <stdlib.h>
#include <memory.h>
#include <map>
#include <deque>
using namespace std;

int nodeNum;
int k;
long weight[100001];
int u[100001];
int v[100001];
int firstUV[100001];
int nextUV[100001];

struct request
{
	int req;
	int answer;
	request* link;
};
request *pRequestHead;

int main()
{
	void FindDifferentWeight(const int &,map<long,int> &);// 声明
	cin>>nodeNum>>k;
	map<long,int> wMap;
	for(int i=1; i<=nodeNum; i++)
		cin>>weight[i];

	for(int i=1; i<=nodeNum; i++)
		firstUV[i]=-1;
	for (int i=1; i<=nodeNum-1; i++)
	{
		cin>>u[i]>>v[i];
		nextUV[i]=firstUV[u[i]];
		firstUV[u[i]]=i;
	}
	int reqNum;
	cin>>reqNum;
	request* lastReq;

	for(int i=0; i<=reqNum-1; i++)
	{
		int req;
		cin>>req;
		request* pReq=new request();
		pReq->req=req;
		pReq->link=NULL;
		if(i==0)
		{
			pRequestHead=pReq;
			lastReq=pReq;
		}
		else
		{
			lastReq->link=pReq;
			lastReq=pReq;
		}
	}

	request* pReqNode=pRequestHead;
	for(int i=0; i<=reqNum-1; i++)
	{
		wMap.clear();
		FindDifferentWeight(pReqNode->req,wMap);
		int times(0);
		map<long,int>::iterator it;
		for(it=wMap.begin(); it!=wMap.end(); it++)
		{
			if(it->second==k)
				times++;
		}
		pReqNode->answer=times;
		cout<<pReqNode->answer<<endl;
		pReqNode=pReqNode->link;
	}
	return 0;
}

void FindDifferentWeight(const int & root,map<long,int> & wMap)
{
	deque<int> myQueue;
	int uvNum=firstUV[root];
	wMap.insert(pair<long,int> (weight[root],1));
// 用队列来实现树的广度优先遍历
// while循环每次压入某一节点的同一层的所有子节点到队列myQueue中，同时从myQueue头部取出一
// 个元素进行访问，这样保证了每次都能取到元素，若该元素为叶节点，则下次循环继续从myQueue取
// 出一个元素，如果不为叶节点，则下次循环将其子女节点压入myQueue。
	while(uvNum!=-1||!myQueue.empty())
	{
		if(uvNum!=-1)
		{
			myQueue.push_back(v[uvNum]);//v[uvNum]表示子节点
			int nextUVChild=nextUV[uvNum];
			while(nextUVChild!=-1)
			{
				myQueue.push_back(v[nextUVChild]);// 压入所有子节点
				nextUVChild=nextUV[nextUVChild];
			}
		}
		if(!myQueue.empty())
		{
			int node=myQueue.front();
			myQueue.pop_front();  // 按压入顺序访问。
			long w=weight[node];
			wMap[w]++;
			uvNum=firstUV[node];// 关键之处，若node为叶节点循环下一次会继续从myQueue取元素。
		}
	}
}