图论 学习笔记

《算法竞赛入门经典（第2版)》
《计算机考研——机试指南（第2版）》

11图论模型与算法

11.1再谈树

11.1.1无根树转有根树
n个结点 n-1条边
存储：邻接矩阵（n^2）—>vector数组

vector<int> G[MAXN];
void read_tree()
{
	int u,v;
	cin>>n;
	for(int i=0; i<n-1; i++)
	{
		cin>>u>>v;
		G[u].push_back(v);
		G[v].push_back(u);
	}
}

void dfs(int u, int father) //以u为根的子树，u的父节点为father
{
	int d = G[u].size();//结点u的相邻点个数
	for(int i=0; i<d; i++)
	{
		int v = G[u][i];
		if(v!=father)
		{
			dfs(v, p[v]=u);//v的父结点设为u，递归转化以v为根的子树
		}
	}
}

主程序
p[root]=-1;
dfs(root, -1);

11.1.2表达式树

11.2最小生成树（Minimal Spanning Tree）

并查集（Union-Find Set）
用途：处理不交集（Disjoint Set）的合并和查询问题。
功能：
1）查询：判断任意两个元素是否属于同一个集合——根结点是否相同（路径压缩：查找某个特定结点的根结点的同时，将其与根结点之间的所有结点都直接指向根结点）
2）合并：按照要求合并不同的集合——将一棵树作为另外一棵树的子树（总是将高度较低的树，作为高度较高的树的子树进行合并）

int Find(int x)
{
	if(x!=father[x])
	{
		father[x]=Find(father[x]);
	}
	return father[x];
}


void Union(int x, int y)
{
	x = Find(x);
	y = Find(y);
	if(x!=y){
		if(height[x]<height[y])
		{
			father[x]=y;
		}
		else if(height[y]<height[x])
		{
			father[y]=x;
		}
		else{
			father[y]=x;
			height[x]++;
		}
	}
	return;
}

Kruskal和Prim算法：
https://haokan.baidu.com/v?pd=wisenatural&vid=13606880642872584625
Kruskal算法
算法步骤：
代码：

struct Edge
{
	int from;
	int to;
	int w;
	bool operator<(const Edge& e)const	{
		return w < e.w;
	}
}

Edge edge[MAXN*MAXN];
int father[MAXN];
int height[MAXN];

int Kruskal(int n, int edgeNumber)
{
	//初始化并查集
	for(int i=0; i<n; i++)
	{
		father[i]=i;
		height[i]=0;
	}
	//边按权值排序
	sort(edge,edge+edgeNumber);
	int sum=0;
	for(int i=0; i<edgeNumber; i++)
	{
		Edge current = edge[i];
		if(Find(current.from)!=Find(current.to))
		{
			Union(current.from, current.to);
			sum+=current.w;
		}
	}
	return sum;
}

买还是建（UVa1151）：Kruskal算法 边的选取

Prim算法
时间复杂度：O(n^2)，适合稠密图

11.3最短路问题

Dijkstra算法
计算正权图上的单源最短路（SSSP），适用于有向图和无向图
O(mlogn)：

struct Edge{
	int to;
	int length;
	Edge(int t, int l): to(t),length(l){}
};

struct Point{
	int number; //点的编号
	int distance; //源点s到点的距离
	Point(int n, int d): number(n), distance(d){}
	bool operator<(const Point& P)const{
		return distance > P.distance; //距离小的优先级高
	}
}

vector<Edge> graph[MAXN]; //图（邻接表）
int dist[MAXN]; //源点到各点的距离

void Dijkstra(int s)
{
	priority_queue<Point> myPQ;
	dist[s]=0;
	myPQ.push(Point(s,dist[s]));
	while(!myPQ.empty())
	{
		int u = myPQ.top().number; //离源点最近的点
		myPQ.pop();
		for(int i=0; i<graph[u].size; i++)
		{
			int v = graph[u][i].to;
			int d = graph[u][j].length;
			if(dist[v]>dist[u]+d)
			{
				dist[v]=dist[u]+d;
				myPQ.push(Point(v,dist[v]));
			}
		}
	}
	return;
}

int main(){//部分代码
	int n,m;
	......
	for(int i=0; i<n; i++) dist[i]=INF;//n点的数目
	while(m--)
	{
		int from, to, length;
		cin>>from>>to>>length;
		graph[from].push_back(Edge(to,length));
		graph[to].push_back(Edge(from,length));
	}
	......

Bellman-Ford算法
如果最短路存在，一定存在一个不含环的最短路。
最短路最多只经过（不包括起点）n-1个结点，可以通过n-1轮松弛操作得到。
适用：
边权可正可负
单源最短路径
有向图&无向图
差分约束系统

https://blog.csdn.net/u011893609/article/details/81232124
1.只有上一次迭代中松弛过的点才有可能参与下一次迭代的松弛操作
2.迭代的实际意义：每次迭代k中，我们找到了经历了k条边的最短路。
3.“没有点能够被松弛”时，迭代结束

Floyd算法

https://www.freesion.com/article/354373291/