06——图的基础

最新推荐文章于 2024-02-20 22:54:22 发布
最新推荐文章于 2024-02-20 22:54:22 发布
阅读量188 收藏 1
点赞数 1
分类专栏： # 【01】方法总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxt_1/article/details/85473744
版权

文章目录

1.图的一种分类：无权图、有权图

在这里插入图片描述

在这里插入图片描述

2.无权图的表示

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

邻接矩阵实现：

// 稠密图

class DenseGraph{
private:
	int n, m; // 节点数和边数
	bool directed; // 是否为有向图
	vector<vector<bool>> g; // 图的具体数据
	
public:
	DenseGraph( int n , bool directed ){
		assert( n >= 0 );
		this->n = n;
		this->m = 0; // 初始化没有任何边
		this->directed = directed;
		// g初始化为n*n的布尔矩阵, 每一个g[i][j]均为false, 表示没有任和边
		//实现方式1：
		g = vector<vector<bool>>(n, vector<bool>(n, false));
		/*实现方式2：
		for(int i=0; i<n; i++)
		    g.push_back(vector<bool>(n,false));
		}
		*/
		
	~DenseGraph(){ }
	int V(){ return n;} // 返回节点个数
	int E(){ return m;} // 返回边的个数
	
	// 向图中添加一个边
	void addEdge( int v , int w ){
		assert( v >= 0 && v < n );
		assert( w >= 0 && w < n );
		if( hasEdge( v , w ) )
			return;
		g[v][w] = true;
		if( !directed )
			g[w][v] = true;
		m ++;
	}
	
	// 验证图中是否有从v到w的边
	bool hasEdge( int v , int w ){
		assert( v >= 0 && v < n );
		assert( w >= 0 && w < n );
		return g[v][w];
	}
};

邻接表实现:



class SparseGraph{
private:
	int n, m; // 节点数和边数
	bool directed; // 是否为有向图
	vector<vector<int>> g; // 图的具体数据
public:
	SparseGraph( int n , bool directed ){
		assert( n >= 0 );
		this->n = n;
		this->m = 0; // 初始化没有任何边
		this->directed = directed;
		// g初始化为n个空的vector, 表示每一个g[i]都为空, 即没有任和边
		//实现方式1:
		g = vector<vector<int>>(n, vector<int>());
		
		/*实现方式2：
		for(int i=0; i<n; i++)
		    g.push_back(vector<int>( ));
		*/
	}
	
	~SparseGraph(){ }
	int V(){ return n;} // 返回节点个数
	int E(){ return m;} // 返回边的个数
	
	// 向图中添加一个边
	void addEdge( int v, int w ){
		assert( v >= 0 && v < n );
		assert( w >= 0 && w < n );
		g[v].push_back(w);
		if( v != w && !directed )
			g[w].push_back(v);
		m ++;
	}
	
	// 验证图中是否有从v到w的边
	bool hasEdge( int v , int w ){
		assert( v >= 0 && v < n );
		assert( w >= 0 && w < n );
		for( int i = 0 ; i < g[v].size() ; i ++ )
			if( g[v][i] == w )
				return true;
		return false;
	}
};

3.无权图的联通分量、最短路径

3.1 深度优先遍历求连通分量

在这里插入图片描述

// 求无权图的联通分量

template <typename Graph>
class Component{
private:
	Graph &G; // 图的引用
	bool *visited; // 记录dfs的过程中节点是否被访问
	int ccount; // 记录联通分量个数
	int *id; // 每个节点所对应的联通分量标记
	
	// 图的深度优先遍历
	void dfs( int v ){
		visited[v] = true;
		id[v] = ccount;
		typename Graph::adjIterator adj(G, v);            //相邻结点迭代器
		for( int i = adj.begin() ; !adj.end() ; i = adj.next() ){
			if( !visited[i] )
				dfs(i);
		}
	}
	
public:
	Component(Graph &graph): G(graph){
	visited = new bool[G.V()];
	id = new int[G.V()];
	ccount = 0;
	for( int i = 0 ; i < G.V() ; i ++ ){
		visited[i] = false;
		id[i] = -1;
	}
	
	// 求图的联通分量
	for( int i = 0 ; i < G.V() ; i ++ )
		if( !visited[i] ){
			dfs(i);
			ccount ++;
		}
	}
	
	~Component(){
		delete[] visited;
		delete[] id;
	}
	
	// 返回图的联通分量个数
	int count(){
		return ccount;
	}
	
	// 查询点v和点w是否联通
	bool isConnected( int v , int w ){
		assert( v >= 0 && v < G.V() );
		assert( w >= 0 && w < G.V() );
		return id[v] == id[w];
	}
};

3.2 广度优先遍历求最短路径

在这里插入图片描述

// 寻找无权图的最短路径
template <typename Graph>
class ShortestPath{

private:
    Graph &G;       // 图的引用
    int s;          // 起始点
    bool *visited;  // 记录dfs的过程中节点是否被访问
    int *from;      // 记录路径, from[i]表示查找的路径上i的上一个节点
    int *ord;       // 记录路径中节点的次序。ord[i]表示i节点在路径中的次序。

public:
    // 寻找无权图graph从s点到其他点的最短路径
    ShortestPath(Graph &graph, int s):G(graph){

        // 算法初始化
        assert( s >= 0 && s < graph.V() );

        visited = new bool[graph.V()];
        from = new int[graph.V()];
        ord = new int[graph.V()];
        for( int i = 0 ; i < graph.V() ; i ++ ){
            visited[i] = false;
            from[i] = -1;
            ord[i] = -1;
        }
        this->s = s;

        // 无向图最短路径算法, 从s开始广度优先遍历整张图
        queue<int> q;

        q.push( s );
        visited[s] = true;
        ord[s] = 0;
        while( !q.empty() ){

            int v = q.front();
            q.pop();

            typename Graph::adjIterator adj(G, v);
            for( int i = adj.begin() ; !adj.end() ; i = adj.next() )
                if( !visited[i] ){
                    q.push(i);
                    visited[i] = true;
                    from[i] = v;
                    ord[i] = ord[v] + 1;
                }
        }

    }
    
    ~ShortestPath(){
        delete [] visited;
        delete [] from;
        delete [] ord;
    }

    // 查询从s点到w点是否有路径
    bool hasPath(int w){
        assert( w >= 0 && w < G.V() );
        return visited[w];
    }

    // 查询从s点到w点的路径, 存放在vec中
    void path(int w, vector<int> &vec){

        assert( w >= 0 && w < G.V() );

        stack<int> s;
        // 通过from数组逆向查找到从s到w的路径, 存放到栈中
        int p = w;
        while( p != -1 ){
            s.push(p);
            p = from[p];
        }

        // 从栈中依次取出元素, 获得顺序的从s到w的路径
        vec.clear();
        while( !s.empty() ){
            vec.push_back( s.top() );
            s.pop();
        }
    }

    // 打印出从s点到w点的路径
    void showPath(int w){

        assert( w >= 0 && w < G.V() );

        vector<int> vec;
        path(w, vec);
        for( int i = 0 ; i < vec.size() ; i ++ ){
            cout<<vec[i];
            if( i == vec.size()-1 )
                cout<<endl;
            else
                cout<<" -> ";
        }
    }

    // 查看从s点到w点的最短路径长度
    int length(int w){
        assert( w >= 0 && w < G.V() );
        return ord[w];
    }
};

4.有权图表示

在这里插入图片描述

在这里插入图片描述

自定义一个Edge类来表示边上权重信息和所连接的节点

template<typename Weight>
class Edge{
private:
    int a,b;    // 边的两个端点
    Weight weight;  // 边的权值

public:
    Edge(int a, int b, Weight weight){
        this->a = a;
        this->b = b;
        this->weight = weight;
    }
    // 空的构造函数, 所有的成员变量都取默认值
    Edge(){}

    ~Edge(){}

    int v(){ return a;} // 返回第一个顶点
    int w(){ return b;} // 返回第二个顶点
    Weight wt(){ return weight;}    // 返回权值

    // 给定一个顶点, 返回另一个顶点
    int other(int x){
        assert( x == a || x == b );
        return x == a ? b : a;
    }

    // 输出边的信息
    friend ostream& operator<<(ostream &os, const Edge &e){
        os<<e.a<<"-"<<e.b<<": "<<e.weight;
        return os;
    }

    // 边的大小比较, 是对边的权值的大小比较
    bool operator<(Edge<Weight>& e){
        return weight < e.wt();
    }
    bool operator<=(Edge<Weight>& e){
        return weight <= e.wt();
    }
    bool operator>(Edge<Weight>& e){
        return weight > e.wt();
    }
    bool operator>=(Edge<Weight>& e){
        return weight >= e.wt();
    }
    bool operator==(Edge<Weight>& e){
        return weight == e.wt();
    }
};

//邻接矩阵实现

// 稠密图 - 邻接矩阵
template <typename Weight>
class DenseGraph{

private:
    int n, m;       // 节点数和边数
    bool directed;  // 是否为有向图
    vector<vector<Edge<Weight> *>> g;   // 图的具体数据

public:
    DenseGraph( int n , bool directed){
        assert( n >= 0 );
        this->n = n;
        this->m = 0;
        this->directed = directed;
        // g初始化为n*n的矩阵, 每一个g[i][j]指向一个边的信息, 初始化为NULL
        //实现1：
        g = vector<vector<Edge<Weight> *>>(n, vector<Edge<Weight> *>(n, NULL));
        /*实现方式2：
		for(int i=0; i<n; i++)
    		g.push_back(vector<Edge<Weight> *>(n,NULL)); }
		*/
    }

    ~DenseGraph(){
        for( int i = 0 ; i < n ; i ++ )
            for( int j = 0 ; j < n ; j ++ )
                if( g[i][j] != NULL )
                    delete g[i][j];
    }

    int V(){ return n;} // 返回节点个数
    int E(){ return m;} // 返回边的个数

    // 向图中添加一个边, 权值为weight
    void addEdge( int v, int w , Weight weight ){
        assert( v >= 0 && v < n );
        assert( w >= 0 && w < n );

        // 如果从v到w已经有边, 删除这条边
        if( hasEdge( v , w  ) ){
            delete  g[v][w];
            if( v != w && !directed )
                delete g[w][v];
            m --;
        }

        g[v][w] = new Edge<Weight>(v, w, weight);
        if( v != w && !directed )
            g[w][v] = new Edge<Weight>(w, v, weight);
        m ++;
    }

    // 验证图中是否有从v到w的边
    bool hasEdge( int v , int w ){
        assert( v >= 0 && v < n );
        assert( w >= 0 && w < n );
        return g[v][w] != NULL;
    }

    // 显示图的信息
    void show(){
        for( int i = 0 ; i < n ; i ++ ){
            for( int j = 0 ; j < n ; j ++ )
                if( g[i][j] )
                    cout<<g[i][j]->wt()<<"\t";
                else
                    cout<<"NULL\t";
            cout<<endl;
        }
    }
};

//邻接列表实现

// 稀疏图 - 邻接表
template<typename Weight>
class SparseGraph{
private:
    int n, m;       // 节点数和边数
    bool directed;  // 是否为有向图
    vector<vector<Edge<Weight> *> > g;   // 图的具体数据

public:
    SparseGraph( int n , bool directed){
        assert(n >= 0);
        this->n = n;
        this->m = 0;    // 初始化没有任何边
        this->directed = directed;
        // g初始化为n个空的vector, 表示每一个g[i]都为空, 即没有任和边
        //实现1：
        g = vector<vector<Edge<Weight> *> >(n, vector<Edge<Weight> *>());
        //实现2：
        /*
        for(int i=0; i<n; i++)
        	g.push_back(vector<Edge<Weight> *>());
		*/
    }

    // 析构函数
    ~SparseGraph(){
        for( int i = 0 ; i < n ; i ++ )
            for( int j = 0 ; j < g[i].size() ; j ++ )
                delete g[i][j];
    }

    int V(){ return n;} // 返回节点个数
    int E(){ return m;} // 返回边的个数

    // 向图中添加一个边, 权值为weight
    void addEdge( int v, int w , Weight weight){
        assert( v >= 0 && v < n );
        assert( w >= 0 && w < n );

        // 注意, 由于在邻接表的情况, 查找是否有重边需要遍历整个链表
        // 我们的程序允许重边的出现

        g[v].push_back(new Edge<Weight>(v, w, weight));
        if( v != w && !directed )
            g[w].push_back(new Edge<Weight>(w, v, weight));
        m ++;
    }

    // 验证图中是否有从v到w的边
    bool hasEdge( int v , int w ){
        assert( v >= 0 && v < n );
        assert( w >= 0 && w < n );
        for( int i = 0 ; i < g[v].size() ; i ++ )
            if( g[v][i]->other(v) == w )
                return true;
        return false;
    }

    // 显示图的信息
    void show(){
        for( int i = 0 ; i < n ; i ++ ){
            cout<<"vertex "<<i<<":\t";
            for( int j = 0 ; j < g[i].size() ; j ++ )
                cout<<"( to:"<<g[i][j]->w()<<",wt:"<<g[i][j]->wt()<<")\t";
            cout<<endl;
        }
    }
};

5.最小生成树

找出图中一棵树，连接所有节点，并且权值之和最小

5.1 切分定理

在这里插入图片描述

在这里插入图片描述

5.2 Prim算法（利用切分定理，从一个点开始，一点点扩散，直至求出最小生成树）

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

。。。
。。。

在这里插入图片描述

//实现：

// 使用Prim算法求图的最小生成树
template<typename Graph, typename Weight>
class LazyPrimMST{
private:
    Graph &G;                   // 图的引用
    MinHeap<Edge<Weight>> pq;   // 最小堆, 算法辅助数据结构
    bool *marked;               // 标记数组, 在算法运行过程中标记节点i是否被访问
    vector<Edge<Weight>> mst;   // 最小生成树所包含的所有边
    Weight mstWeight;           // 最小生成树的权值

    // 访问节点v
    void visit(int v){
        assert( !marked[v] );
        marked[v] = true;

        // 将和节点v相连接的所有未访问的边放入最小堆中
        typename Graph::adjIterator adj(G,v);
        for( Edge<Weight>* e = adj.begin() ; !adj.end() ; e = adj.next() )
            if( !marked[e->other(v)] )
                pq.insert(*e);
    }

public:
    LazyPrimMST(Graph &graph):G(graph), pq(MinHeap<Edge<Weight>>(graph.E())){
        // 算法初始化
        marked = new bool[G.V()];
        for( int i = 0 ; i < G.V() ; i ++ )
            marked[i] = false;
        mst.clear();

        // Lazy Prim
        visit(0);
        while( !pq.isEmpty() ){
            // 使用最小堆找出已经访问的边中权值最小的边
            Edge<Weight> e = pq.extractMin();
            // 如果这条边的两端都已经访问过了, 则扔掉这条边
            if( marked[e.v()] == marked[e.w()] )
                continue;
            // 否则, 这条边则应该存在在最小生成树中
            mst.push_back( e );

            // 访问和这条边连接的还没有被访问过的节点
            if( !marked[e.v()] )
                visit( e.v() );
            else
                visit( e.w() );
        }

        // 计算最小生成树的权值
        mstWeight = mst[0].wt();
        for( int i = 1 ; i < mst.size() ; i ++ )
            mstWeight += mst[i].wt();
    }

    ~LazyPrimMST(){
        delete[] marked;
    }

    // 返回最小生成树的所有边
    vector<Edge<Weight>> mstEdges(){
        return mst;
    };

    // 返回最小生成树的权值
    Weight result(){
        return mstWeight;
    };
};
5.2.1 优化
IndexMinHeap:每个heap节点保存的是与该节点 横切边权值最小值

在这里插入图片描述

在这里插入图片描述

。。。
。。。
在这里插入图片描述

//实现

// 使用优化的Prim算法求图的最小生成树
template<typename Graph, typename Weight>
class PrimMST{

private:
    Graph &G;                     // 图的引用
    IndexMinHeap<Weight> ipq;     // 最小索引堆, 算法辅助数据结构
    vector<Edge<Weight>*> edgeTo; // 访问的点所对应的边, 算法辅助数据结构
    bool* marked;                 // 标记数组, 在算法运行过程中标记节点i是否被访问
    vector<Edge<Weight>> mst;     // 最小生成树所包含的所有边
    Weight mstWeight;             // 最小生成树的权值

    // 访问节点v
    void visit(int v){

        assert( !marked[v] );
        marked[v] = true;

        // 将和节点v相连接的未访问的另一端点, 和与之相连接的边, 放入最小堆中
        typename Graph::adjIterator adj(G,v);
        for( Edge<Weight>* e = adj.begin() ; !adj.end() ; e = adj.next() ){
            int w = e->other(v);
            // 如果边的另一端点未被访问
            if( !marked[w] ){
                // 如果从没有考虑过这个端点, 直接将这个端点和与之相连接的边加入索引堆
                if( !edgeTo[w] ){
                    edgeTo[w] = e;
                    ipq.insert(w, e->wt());
                }
                // 如果曾经考虑这个端点, 但现在的边比之前考虑的边更短, 则进行替换
                else if( e->wt() < edgeTo[w]->wt() ){
                    edgeTo[w] = e;
                    ipq.change(w, e->wt());
                }
            }
        }

    }
public:
    // 构造函数, 使用Prim算法求图的最小生成树
    PrimMST(Graph &graph):G(graph), ipq(IndexMinHeap<double>(graph.V())){

        assert( graph.E() >= 1 );

        // 算法初始化
        marked = new bool[G.V()];
        for( int i = 0 ; i < G.V() ; i ++ ){
            marked[i] = false;
            edgeTo.push_back(NULL);
        }
        mst.clear();

        // Prim
        visit(0);
        while( !ipq.isEmpty() ){
            // 使用最小索引堆找出已经访问的边中权值最小的边
            // 最小索引堆中存储的是点的索引, 通过点的索引找到相对应的边
            int v = ipq.extractMinIndex();
            assert( edgeTo[v] );
            mst.push_back( *edgeTo[v] );
            visit( v );
        }

        mstWeight = mst[0].wt();
        for( int i = 1 ; i < mst.size() ; i ++ )
            mstWeight += mst[i].wt();
    }

    ~PrimMST(){
        delete[] marked;
    }

    vector<Edge<Weight>> mstEdges(){
        return mst;
    };

    Weight result(){
        return mstWeight;
    };
};

5.3 Kruskal算法

在这里插入图片描述

在这里插入图片描述

实现：

// Kruskal算法
template <typename Graph, typename Weight>
class KruskalMST{

private:
    vector<Edge<Weight>> mst;   // 最小生成树所包含的所有边
    Weight mstWeight;           // 最小生成树的权值

public:
    // 构造函数, 使用Kruskal算法计算graph的最小生成树
    KruskalMST(Graph &graph){

        // 将图中的所有边存放到一个最小堆中
        MinHeap<Edge<Weight>> pq( graph.E() );
        for( int i = 0 ; i < graph.V() ; i ++ ){
            typename Graph::adjIterator adj(graph,i);
            for( Edge<Weight> *e = adj.begin() ; !adj.end() ; e = adj.next() )
                if( e->v() < e->w() )
                    pq.insert(*e);
        }

        // 创建一个并查集, 来查看已经访问的节点的联通情况
        UnionFind uf = UnionFind(graph.V());
        while( !pq.isEmpty() && mst.size() < graph.V() - 1 ){

            // 从最小堆中依次从小到大取出所有的边
            Edge<Weight> e = pq.extractMin();
            // 如果该边的两个端点是联通的, 说明加入这条边将产生环, 扔掉这条边
            if( uf.isConnected( e.v() , e.w() ) )
                continue;

            // 否则, 将这条边添加进最小生成树, 同时标记边的两个端点联通
            mst.push_back( e );
            uf.unionElements( e.v() , e.w() );
        }

        mstWeight = mst[0].wt();
        for( int i = 1 ; i < mst.size() ; i ++ )
            mstWeight += mst[i].wt();
    }

    ~KruskalMST(){ }

    // 返回最小生成树的所有边
    vector<Edge<Weight>> mstEdges(){
        return mst;
    };

    // 返回最小生成树的权值
    Weight result(){
        return mstWeight;
    };
};

5.4 时间复杂度

在这里插入图片描述

6.最短路径

最短路径问题：从一个节点到另一个节点的最短距离
（本节为单源最短路径）

6.1 dijkstra算法

前提：图中不能有负权边
一轮操作;

在这里插入图片描述
在这里插入图片描述

二轮操作:

在这里插入图片描述
在这里插入图片描述

三轮操作：

在这里插入图片描述

四轮操作：

在这里插入图片描述

实现：

// Dijkstra算法求最短路径
template<typename Graph, typename Weight>
class Dijkstra{

private:
    Graph &G;                   // 图的引用
    int s;                      // 起始点
    Weight *distTo;             // distTo[i]存储从起始点s到i的最短路径长度
    bool *marked;               // 标记数组, 标记是否求得到节点i最短距离
    vector<Edge<Weight>*> from; // from[i]记录最短路径中, 到达i点的边是哪一条
                                // 可以用来恢复整个最短路径

public:
    // 构造函数, 使用Dijkstra算法求最短路径
    Dijkstra(Graph &graph, int s):G(graph){

        // 算法初始化
        assert( s >= 0 && s < G.V() );
        this->s = s;
        distTo = new Weight[G.V()];
        marked = new bool[G.V()];
        for( int i = 0 ; i < G.V() ; i ++ ){
            distTo[i] = Weight();
            marked[i] = false;
            from.push_back(NULL);
        }

        // 使用索引堆记录当前找到的到达每个顶点的最短距离
        IndexMinHeap<Weight> ipq(G.V());

        // 对于起始点s进行初始化
        distTo[s] = Weight();
        from[s] = new Edge<Weight>(s, s, Weight());
        ipq.insert(s, distTo[s] );
        marked[s] = true;
        while( !ipq.isEmpty() ){
            int v = ipq.extractMinIndex();

            // distTo[v]就是s到v的最短距离
            marked[v] = true;

            // 对v的所有相邻节点进行更新
            typename Graph::adjIterator adj(G, v);
            for( Edge<Weight>* e = adj.begin() ; !adj.end() ; e = adj.next() ){
                int w = e->other(v);
                // 如果从s点到w点的最短路径还没有找到
                if( !marked[w] ){
                    // 如果w点以前没有访问过,
                    // 或者访问过, 但是通过当前的v点到w点距离更短, 则进行更新
                    if( from[w] == NULL || distTo[v] + e->wt() < distTo[w] ){
                        distTo[w] = distTo[v] + e->wt();
                        from[w] = e;
                        if( ipq.contain(w) )
                            ipq.change(w, distTo[w] );
                        else
                            ipq.insert(w, distTo[w] );
                    }
                }
            }
        }
    }

    // 析构函数
    ~Dijkstra(){
        delete[] distTo;
        delete[] marked;
        delete from[0];
    }

    // 返回从s点到w点的最短路径长度
    Weight shortestPathTo( int w ){
        assert( w >= 0 && w < G.V() );
        assert( hasPathTo(w) );
        return distTo[w];
    }

    // 判断从s点到w点是否联通
    bool hasPathTo( int w ){
        assert( w >= 0 && w < G.V() );
        return marked[w];
    }

    // 寻找从s到w的最短路径, 将整个路径经过的边存放在vec中
    void shortestPath( int w, vector<Edge<Weight>> &vec ){

        assert( w >= 0 && w < G.V() );
        assert( hasPathTo(w) );

        // 通过from数组逆向查找到从s到w的路径, 存放到栈中
        stack<Edge<Weight>*> s;
        Edge<Weight> *e = from[w];
        while( e->v() != this->s ){
            s.push(e);
            e = from[e->v()];
        }
        s.push(e);

        // 从栈中依次取出元素, 获得顺序的从s到w的路径
        while( !s.empty() ){
            e = s.top();
            vec.push_back( *e );
            s.pop();
        }
    }

    // 打印出从s点到w点的路径
    void showPath(int w){

        assert( w >= 0 && w < G.V() );
        assert( hasPathTo(w) );

        vector<Edge<Weight>> vec;
        shortestPath(w, vec);
        for( int i = 0 ; i < vec.size() ; i ++ ){
            cout<<vec[i].v()<<" -> ";
            if( i == vec.size()-1 )
                cout<<vec[i].w()<<endl;
        }
    }
};
6.1.1 优化：Bellman-Ford算法
前提：图中不能有负权环
负权环：

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

// 使用BellmanFord算法求最短路径
template <typename Graph, typename Weight>
class BellmanFord{

private:
    Graph &G;                   // 图的引用
    int s;                      // 起始点
    Weight* distTo;             // distTo[i]存储从起始点s到i的最短路径长度
    vector<Edge<Weight>*> from; // from[i]记录最短路径中, 到达i点的边是哪一条
                                // 可以用来恢复整个最短路径
    bool hasNegativeCycle;      // 标记图中是否有负权环

    // 判断图中是否有负权环
    bool detectNegativeCycle(){

        for( int i = 0 ; i < G.V() ; i ++ ){
            typename Graph::adjIterator adj(G,i);
            for( Edge<Weight>* e = adj.begin() ; !adj.end() ; e = adj.next() )
                if( from[e->v()] && distTo[e->v()] + e->wt() < distTo[e->w()] )
                    return true;
        }

        return false;
    }

public:
    // 构造函数, 使用BellmanFord算法求最短路径
    BellmanFord(Graph &graph, int s):G(graph){

        this->s = s;
        distTo = new Weight[G.V()];
        // 初始化所有的节点s都不可达, 由from数组来表示
        for( int i = 0 ; i < G.V() ; i ++ )
            from.push_back(NULL);

        // 设置distTo[s] = 0, 并且让from[s]不为NULL, 表示初始s节点可达且距离为0
        distTo[s] = Weight();
        from[s] = new Edge<Weight>(s, s, Weight()); // 这里我们from[s]的内容是new出来的, 注意要在析构函数里delete掉

        // Bellman-Ford的过程
        // 进行V-1次循环, 每一次循环求出从起点到其余所有点, 最多使用pass步可到达的最短距离
        for( int pass = 1 ; pass < G.V() ; pass ++ ){

            // 每次循环中对所有的边进行一遍松弛操作
            // 遍历所有边的方式是先遍历所有的顶点, 然后遍历和所有顶点相邻的所有边
            for( int i = 0 ; i < G.V() ; i ++ ){
                // 使用我们实现的邻边迭代器遍历和所有顶点相邻的所有边
                typename Graph::adjIterator adj(G,i);
                for( Edge<Weight>* e = adj.begin() ; !adj.end() ; e = adj.next() )
                    // 对于每一个边首先判断e->v()可达
                    // 之后看如果e->w()以前没有到达过， 显然我们可以更新distTo[e->w()]
                    // 或者e->w()以前虽然到达过, 但是通过这个e我们可以获得一个更短的距离, 即可以进行一次松弛操作, 我们也可以更新distTo[e->w()]
                    if( from[e->v()] && (!from[e->w()] || distTo[e->v()] + e->wt() < distTo[e->w()]) ){
                        distTo[e->w()] = distTo[e->v()] + e->wt();
                        from[e->w()] = e;
                    }
            }
        }

        hasNegativeCycle = detectNegativeCycle();
    }

    // 析构函数
    ~BellmanFord(){

        delete[] distTo;
        delete from[s];
    }

    // 返回图中是否有负权环
    bool negativeCycle(){
        return hasNegativeCycle;
    }

    // 返回从s点到w点的最短路径长度
    Weight shortestPathTo( int w ){
        assert( w >= 0 && w < G.V() );
        assert( !hasNegativeCycle );
        assert( hasPathTo(w) );
        return distTo[w];
    }

    // 判断从s点到w点是否联通
    bool hasPathTo( int w ){
        assert( w >= 0 && w < G.V() );
        return from[w] != NULL;
    }

    // 寻找从s到w的最短路径, 将整个路径经过的边存放在vec中
    void shortestPath( int w, vector<Edge<Weight>> &vec ){

        assert( w >= 0 && w < G.V() );
        assert( !hasNegativeCycle );
        assert( hasPathTo(w) );

        // 通过from数组逆向查找到从s到w的路径, 存放到栈中
        stack<Edge<Weight>*> s;
        Edge<Weight> *e = from[w];
        while( e->v() != this->s ){
            s.push(e);
            e = from[e->v()];
        }
        s.push(e);

        // 从栈中依次取出元素, 获得顺序的从s到w的路径
        while( !s.empty() ){
            e = s.top();
            vec.push_back( *e );
            s.pop();
        }
    }

    // 打印出从s点到w点的路径
    void showPath(int w){

        assert( w >= 0 && w < G.V() );
        assert( !hasNegativeCycle );
        assert( hasPathTo(w) );

        vector<Edge<Weight>> vec;
        shortestPath(w, vec);
        for( int i = 0 ; i < vec.size() ; i ++ ){
            cout<<vec[i].v()<<" -> ";
            if( i == vec.size()-1 )
                cout<<vec[i].w()<<endl;
        }
    }
};

6.2 时间复杂度

在这里插入图片描述

神秘的火柴人
关注
专栏目录
DAY 06 冲击蓝桥杯——Python基础06python元组
f1220684378的博客
01-27 1283
文章目录7.1 元组的一些概念7.1.1 元组的基本定义7.1.2 元组的长度7.1.2 数据类型7.2 元组的“查”7.2.1 正常访问7.2.2 负索引7.2.3 范围性索引7.3 元组的“改”7.3.1 替换7.3.2 添加项目值7.3.3 删除项目7.3.4 解包元组7.4 循环元组7.4.1 遍历元组7.5 元组合并7.5.1 合并用+连接7.5.2 重复元组内容可以使用* 运算符：7.5.3 count函数用于返回指定值次数：7.5.4 index()找出指定值并返回它的位置：练习题 7.1 元
6. 图的基础
weixin_41207499的博客
11-16 204
一. 图的表示 邻接矩阵(Adjacency Matrix) 无向图: 0 - 1 / | 3 - 2 邻接矩阵: 0 1 2 3 ...
有权图
扬俊的小屋
09-18 6174
目录                                                             有权图 前言 带权图的数据结构 边Edge的结构设计 邻接矩阵的结构改造 邻接表的结构改造 完整代码获取 博客文章版权说明                                                                 ...
算法学习——图之有权图
Talk is cheap, show me the code!
03-11 3313
前言 上一篇文章我们讲到了图的基础，相信有了无权图的基础很快就能理解有权图了。有权图其实也是符合我们生活实际情况的，距离最短并不说明这条路线是最佳的路线，因为可能会堵车。这时候，有权图就可以帮助我们解决问题，每条道路都有一定的代价，我们的代价最小时，这条路就是最优的。 有权图 邻接矩阵 稠密图我们依然使用邻接矩阵，不过和无权图不同的是我们就不是0、1表示了，而是使用权重进行代替。 ...
【数据结构】图的基础概念介绍
一个写湿的程序猿
03-22 719
图的基础概念数据结构回顾图（Graph）有向图（Directed Graph）出度、入度无向图（Undirected Graph）混合图（Mixed Graph）简单图、多重图无向完全图（Undirected Complete Graph）有向完全图（Directed Complete Graph）有权图（Weighted Graph）连通图（Connected Graph）连通分量（Connected Component） 数据结构回顾 线性结构：数组、链表、栈、队列、哈希表(底层数组) 树形结构：二叉树
无权图的最短路径
wat1r的博客
08-07 1472
无权图的最短路径 Approach： 一种解决方案是使用Bellman-Ford算法在 O(VE) 时间内求解。 如果没有负权重环的话，那么可以使用Dijkstra 算法在 O(E + VLogV) 时间内求解。 由于图是无权的，可以在 O(V + E) 时间内解决这个问题。这个想法是使用广度优先搜索的修改版本，其中我们在进行广度优先搜索时继续存储给定顶点的predecessor。即使图中存在负权重环，该算法也可以完成。 我们首先初始化一个数组 dist[0, 1, …, v-1] ，使得 dist[i
图的表示（无权图和有权图）
weixin_44316314的博客
05-01 4690
图是一种很重要的数据结构，首先要怎么表示它呢 两种方法：邻接矩阵和邻接表 两种方式的应用及优点： 邻接矩阵：一般用于表示稠密图，若并非稠密图时，复杂度较高，空间浪费严重 邻接表 ： 一般用于表示稀疏图，节约空间，较于邻接矩阵复杂度低 邻接矩阵非常简单就不放代码了。对于无权图，两个点有边置1，没边置0。对于有权图，两个点有边置为权值，没边置为0 邻接表表示一张无权图： #include <io...
06hadoop基础架构——好程序
01-07
hadoop是什么 apache hadoop是apache旗下的一套开源的软件平台。 hadoop是一套高可靠的、可扩展的、分布式的计算开源软件。hadoop软件库是一个框架，使用简单的编程模型跨计算机集群分布式处理大型的数据集（海量...
图——图的基础
jefferent2008的专栏
06-08 246
1. 前言     图是一种非线性数据结构，是一种更为复杂的数据结构，在图中，数据元素之间时多对多的关系，即一个数据元素对应多个直接前驱和多个直接后继元素。图的应用领域十分广泛，如化学分析，工程设计、遗传学、人工智能等。 2. 图的定义和相关概念     图是一种数据元素间为多对多关系的数据结构，加上一组基本操作构成的抽象数据类型。     数据对象V ：V是具有相同特性的数据元素的集合，...
Python深入06——python的内存管理详解
09-21
引用计数是Python内存管理的基础机制之一。每个对象都有一个引用计数，表示有多少个引用指向它。当对象的引用计数变为0时，Python会自动回收该对象的内存。`sys.getrefcount()`函数可以用来查看对象的引用计数，但要...
算法之图论(二)有权最短路
释怀°Believe的博客
03-25 1130
文章目录一、Floyd算法（多源）二、Dijkstra算法（单源） 有权图：我们把带有权值的称为有权图。 边权：可以理解为两点之间的距离或费用。 最短路径： 从源点到终点之间的所有路径中，边权之和最小的那一条路径，称为这两点之间的最短路径。 （1）多源最短路径问题：求任意两点之间的最短路径。Floyd算法 （2）单源最短路径问题：从某固定源点出发，求其到所有其他顶点的最短路径。 常用有Dijkstra算法，Ford算法，SPFA算法。 一、Floyd算法（多源） 需要利用邻接矩阵存储图, 例如,对于上图
数据结构——图
帆的博客
08-22 1185
有的关系是有方向的，比如父子关系，师生关系，微博的关注关系，A是B的爸爸，但B肯定不是A的爸爸，A关注B，B不一定关注A。边表示的是顶点之间的关系，有的关系是双向的，比如同学关系，A是B的同学，那么B也肯定是A的同学，那么在表示A和B的关系时，就不用关注方向，用不带箭头的边表示，这样的图就是无向图。对于一个关系，如果我们既关心关系的有无，也关心关系的强度，比如描述地图上两个城市的关系，需要用到距离，那么就用带权图来表示，带权图中的每一条边一个数值表示权值，代表关系的强度。图在我们日常生活中的例子很多！
【LeetCode】无权图的最短路精选7题——单源、多源
最新发布
Qiuhan_909的博客
02-20 597
LeetCode 无权图的最短路精选7题（包含单源、多源） 详解
有权图的读取
大漠知秋的加油站
07-07 346
之前使用邻接矩阵实现的稠密图、无权图如下：在一个 n * n 的二维数组中表示两点相连即为 1(true)，不连则为 0(false)。这在无权图中好使，但是如果是有权图，比如下：这中间已经不止存在着连接关系了，还有权值，这里的权值如：3.6、3.8、2.9、1.8。这些权值可能表示着距离、时间等等，在复杂点可能不是数字，而是一个对象，所以不能再像无权图那样简单的使用 0、1 表示。单独抽象出来一个 ，起名 ，属性包含了 、，权重使用模板，具体是什么类型让使用者决定。 有权图的邻接矩阵 在增加了 Edge
有权图——最小生成树、最短路径
qq_34731182的博客
04-06 831
有权图 文章目录有权图有权图的表示最小生成树Minimum Span Tree生成树切分定理Cut PropertyLazy PrimPrimKruskal最短路径松弛操作RelaxationDijkstra算法Bellman-Ford算法最短路径算法总结 有权图的表示 邻接矩阵表示有权图： 邻接表表示有权图： 边的表示： // 边 template<typename Weight> class Edge{ private: int a,b; //
强化学习基础06——小结
qq_40694497的博客
01-28 2049
目录 1.术语总结 2.强化学习的目的 3.强化学习具体是要学什么？ 1.术语总结 agent就是会做动作这样一个东西，比如超级玛丽中的Mario就是agent。 agent可以跟环境Environment交互,超级玛丽中的环境就是游戏本身,Agent做出动作action,环境就会更新状态State，并且给出一个奖励reward。 可以认为State就是当前屏幕上显示的画面,游戏玩家会根据这个画面进行操作,如果状态、动作、奖励等变量被观测到，就用小写字母表示,如果没观测到他们就是.
图的基础
NinoSun的博客
11-08 219
文章目录简介图的存储方式图的连通性无权图的遍历和寻路 简介 图（Graph）是一种数据类型。主要包含顶点（Vertex）和边（Edge）。 图G(V, E)是由一个非空有限顶点集合V和有限边集合E组成。 本篇文章主要是对图的基础知识做一个学习总结。具体内容包括图的存储方式，图的连通性和无权图的遍历和寻路。 图的存储方式 图一般通过邻接矩阵或邻接表的方式存储。 邻接矩阵顾名思义是将顶点间的连通关系存...
有权图的表示和存储
段渣渣推轮子的飙车场
08-02 566
有权图的表示和存储 带权图的存储于无全图的存储差别在于边上，这里将边作为一个类存储。 Edge类 package MinimumSpanTrees; /** * @ Description: 图的边 类 * @ Date: Created in 07:47 2018/8/2 * @ Author: Anthony_Duan */ public class Edge&lt;Wei...
有权图的单源最短路算法
拉风小宇的博客
12-08 1719
有权图的单源最短路亦被称为Dijkstra算法（单源最短路径），首先要声明这个算法无法解决含有负值圈的图 算法步骤如下： G={V,E} 1. 初始时令 S={V0},T=V-S={其余顶点}，T中顶点对应的距离值 若存在，d(V0,Vi)为弧上的权值 若不存在，d(V0,Vi)为∞ 2. 从T中选取一个与S中顶点有关联边且权值最小的顶点W，加入到S中 3. 对其余T中顶点的距离
C++(数据结构与算法):56---无权图与有权图的编码实现
董哥的黑板报
03-12 1010
无权图和有权图的描述方法有：邻接矩阵、邻接链表、邻接数组。已经在前一篇文章讲述了（https://blog.csdn.net/qq_41453285/article/details/104464760），本文是编码的实现 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值