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

最新推荐文章于 2022-10-31 19:31:38 发布

原创最新推荐文章于 2022-10-31 19:31:38 发布 · 849 阅读

3 ·

CC 4.0 BY-SA版权

算法同时被 2 个专栏收录

15 篇文章

订阅专栏

C++

13 篇文章

订阅专栏

本文介绍邻接表作为一种高效的数据结构用于存储稀疏图，并通过一个具体的算法题实例展示了如何利用邻接表实现树的遍历及子树权值计数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

邻接表存储稀疏图时占用空间小。
坐在马桶上看算法（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_i$ 。对该树进行 m 次询问，每次询问求以顶点 u 作为树根的子树中，有多少不同的顶点的权值刚好出现 k 次。

输入格式

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

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

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

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

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

输出格式

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

样例输入

样例输出

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取元素。
		}
	}
}