经典图算法

拓扑排序

Leetcode 207 课程表

代码

// An highlighted block
var foo = 'bar';

Leetcode 210 课程表2

代码

// An highlighted block
var foo = 'bar';

Leetcode 310 最小高度树

代码

class Solution {
public:
    vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
        //拓扑排序变形
        //构建入度表
        //构建邻接表
        //入度为1的节点依次进入Queue，但只剩下两个或者一个节点时返回
        
        if(n==1)
            return {0};

        //入度表
        vector<int> indegree(n);
        //邻接表
        vector<vector<int>> m;
        m.resize(n);
        //结果
        vector<int> res;

        for(auto p:edges){//无向边
            int u=p[0];
            int v=p[1];
            //入度表更新
            indegree[u]++;
            indegree[v]++;
            //邻接表更新
            m[u].push_back(v);
            m[v].push_back(u);
        }

        //定义一个队列
        queue<int> Q;
        
        //将度为1的节点全部进队列
        for(int i=0;i<n;i++){
            if(indegree[i]==1){
                Q.push(i);
            }
        }

        int num=n;
        //依次删除节点 直至只剩下1个或者2个
        while(num>2){
            int sz = Q.size();
            for(int i=0;i<sz;i++){
                int pre = Q.front();
                Q.pop();
                num--;
                indegree[pre]--;
                for(auto cur:m[pre]){
                    indegree[cur]--;
                    if(indegree[cur]==1){
                        Q.push(cur);
                    }
                }
            }
        }

        while(!Q.empty()){
            res.push_back(Q.front());
            Q.pop();
        }

        return res;
    }
};

最短路径

1.广度优先搜索(无权重)

伪代码

//Pusedocode

void Graph::unweight(Vertex s) //输入初始顶点
{
	//利用队列实现广度优先搜索
	Queue<Vertex> q;
	
	for each Vertex v
		v.dist = INFINITY //初始化节点可到达的距离为无穷(不可达)
	s.dist=0;//初始化为0
	q.enqueue(s);
	
	while(!q.isEmpty())//依次操作
	{
		Vertex v = q.dequeue();//出队列
		//邻接节点的信息
		for each Vertex w adjacent to v
			if(w.dist == INFINITY) //如果不可达则更新
			{
				w.dist = v,dist+1;
				w.path=v;//w的上一个节点为v
				q.enqueue(w);//入队列
			}
	}
}

2. Dijkstra算法

伪代码

PSEUDOCODE

struct Vertex
{
	List adj;//邻接表
	bool known;//是否访问过
	DistType dist;//路径长度
	Vertex path;//上一个节点
}

void Graph::dijkstra(Vertex s)
{
	//使用贪心算法
	//初始化节点
	for each Vertex v	
	{
		v.dist =INTINITY;
		v.known.false;
	}
	
	s.dist=0;
	for(;;)
	{
		Vertex v = smallest unknown distance vertex; 不知道距离的节点的最小值
		if(v== NOT_A_VERTEX)//不是边停止
			break;
		v.known=true;//标记为已经访问过
		
		for each Vertex w adjacent to v
			if(!w.known){
				if(v.dist+cvw<w.dist)
				{
					//Update w
					decreace(w.dist to v.dist+cvw)
					w.path = v;
				}
			}
	}
}

3.A星算法

原理

1.open列表:记录下所有被考虑来寻找最短路径的方块
2.closed列表:记录下不会再被考虑的方块
3.路径增量
G:从开始点到当前方块的移动量
H:从当前方块到目标点的移动估算值
4.重复以下路径来找到最短路径
4.1将方块添加到open列表，该列表有最小的和值(S)。
4.2将S从open列表移除，然后添加S到closed列表
4.3对于与S相邻的每一块可通过的方块T:
	 如果T在closed列表中:不管它
	 如果T不在open列表中:添加它然后计算出它的和值
	 如果T已经在open列表中：当我们用当前的路径到达那里时，检查F和值是否更小。

最小生成树

Prim算法——让一棵小树慢慢长大

Kruskal算法

欧拉回路

DFS搜索

Hamilton回路

旅行商问题