图论入门算法模板+分析+例题

最新推荐文章于 2025-12-07 21:20:15 发布
原创 最新推荐文章于 2025-12-07 21:20:15 发布 · 297 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#图论 #算法

本文详细介绍了图论中的最短路问题，包括Bellman-Ford算法、Dijkstra算法和Floyd-Warshall算法，讨论了它们的思路、适用条件和时间复杂度。此外，还讲解了最小生成树的Prim算法和Kruskal算法，并提供了例题和模板。

一、最短路问题

单源最短路指的是固定起点和终点，求最短路。
下文中，v表示点的个数，e表示边的个数。

1.1 单源最短路问题1（Bellman-Ford算法）

思路

只要之前有边更新过，就继续遍历所有的边，更新最小值。

适用条件

适用任意情况，可存在负边、可存在负圈。由于一些边不会即使更新，反复检查导致浪费了一些时间，下文会介绍SPFA队列优化。

模板 O ( V E ) O(VE) O(VE)

const int MAX_V=1e5+200,MAX_E=5e5+200;
struct edge{
	int from,to,cost;
};
edge es[MAX_E];

void shortest_path(int s){
	memset(d,0x3f,sizeof d);
	d[s]=0;
	while(true){
		bool update=false;
		for(auto e:es){
			if(d[e.from]!=INF&&d[e.to]>d[e.from]+e.cost){
				d[e.to]=d[e.from]+e.cost;
				update=true;
			}
		}
		if(!update)break;
	}
}

有步数限制的单源最短路

有边数限制的最短路 - AcWing题库

思路

每一次都遍历所有的边，但是要在之前的dis上进行比较和更新，因为本次遍历，上一条边可能对下一条边产生影响，这个影响是通过2步实现的，不符合我们一次遍历代表走一步的预期。所以每次遍历前，要copy dis数组。

代码
#include<bits/stdc++.h>
using namespace std;
const int M=1e4+200;
const int N=1e3;
const int INF=0x3f3f3f3f;
int n,m,k;
struct edge{
    int from,to,cost;
};
edge es[M];
int dis[N],last[N];

void bellman_ford(int s){
    memset(dis,0x3f,sizeof dis);
    dis[s]=0;
    int t=k;
    bool ud=1;
    while(ud&&t--){
        ud=0;
        memcpy(last,dis,sizeof dis);
        for(int i=1;i<=m;++i){
            edge e=es[i];
            if(last[e.from]!=INF&&dis[e.to]>last[e.from]+e.cost){
                dis[e.to]=last[e.from]+e.cost;
                //cout<<"dis["<<e.to<<"]="<<dis[e.to]<<'\n';
                ud=1;
            }
        }
    }
}

int main(){
    cin>>n>>m>>k;
    for(int i=1;i<=m;++i){
        cin>>es[i].from>>es[i].to>>es[i].cost;
    }
    bellman_ford(1);
    if(dis[n]==INF)cout<<"impossible";
    else cout<<dis[n];
    return 0;
}

判断负圈存在

负圈

负圈就是某个环路存在负边，且负边能对最短路的结果确定造成影响，使之能不断减下去。

若负圈存在，则求最短路是没有意义的。
判断是否存在负圈，看一个点到另一个点的最短路边数是否能达到N，因为一共N个点，最多N-1条边能走完，出现N表示有负环。

方法一

遍历所有的边，遍历次数若为N则存在负环

bool find_negative_loop(){
	memset(d,0,sizeof d);//其实初始值不重要（当然在不能越界条件下），判断的是他们的相对值 
	for(int i=1;i<=V;++i){
		for(auto e:es){
			if(d[e.to]>d[e.from]+e.cost){
				d[e.to]=d[e.from]+e.cost;
				if(i==V)return true; //V个点最多循环V-1次确定所有最短路，除非存在负圈 
			}
		}
	}
	return false; 
}
方法二

spfa判断负环 - AcWing题库
把所有点看成起点，循环遍历。因为题目问的是图中是否存在环，而不是求某点到某点的最短距离。

#include<bits/stdc++.h>
using namespace std;

const int N=2200;
const int M=N*4;
const int INF=0x3f3f3f3f;
int n,m;
struct edge{int to,cost;};
struct node{int id,d;};
bool vis[N];
int cnt[N];
vector<edge>G[N];
int dis[N];

bool SPFA(int s){
    fill(dis,dis+N,INF);
    fill(vis,vis+N,true);
    dis[s]=0;
    queue<node>q;
    for(int i=1;i<=n;++i)q.push({i,dis[i]});
    while(!q.empty()){
        node v=q.front();q.pop();
        vis[v.id]=false;
        for(edge e:G[v.id]){
            if(dis[e.to]>dis[v.id]+e.cost){
                dis[e.to]=dis[v.id]+e.cost;
                cnt[e.to]=cnt[v.id]+1;
                if(cnt[e.to]==N)return false;
                if(!vis[e.to]){
                    vis[e.to]=true;
                    q.push({e.to,dis[e.to]});
                }
            }
        }
    }
    return true;
}
int main(){
    cin>>n>>m;
    for(int i=1;i<=m;++i){
        int u,v,w;cin>>u>>v>>w;
        G[u].push_back({v,w});
    }
    cout<<(SPFA(1)?"No":"Yes");
  
    return 0;
}

SPFA O ( k E ) O(kE) O(kE)

思路

用队列优化bellman-ford写法，k表示每个点平均入队次数。此写法并不稳定，可能会退化成。如果比赛中题目为正边，建议用dijkstra队列优化。

代码

spfa求最短路 - AcWing题库

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+200;
const int INF=0x3f3f3f3f;
int n,m;
struct edge{
    int to,cost;
};
struct node{
    int id,d;
    bool operator<(const node&n)const{
        return d>n.id;
    }
};
vector<edge>G[N];
int dis[N];
void SPFA(int s){
    memset(dis,0x3f,sizeof dis);
    priority_queue<node>q;
    q.push({s,0});
    dis[s]=0;
    while(!q.empty()){
        auto v=q.top();q.pop();
        if(dis[v.id]<v.d)continue;
        for(auto x:G[v.id]){
            if(dis[x.to]>dis[v.id]+x.cost){
                dis[x.to]=dis[v.id]+x.cost;
                q.push({x.to,dis[x.to]});
            }
        }
    }
}
int main(){
    cin>>n>>m;
    for(int i=1;i<=m;++i){
        int u,v,w;cin>>u>>v>>w;
        G[u].push_back({v,w});
    }
    SPFA(1);
    if(dis[n]==INF)cout<<"impossible";
    else cout<<dis[n];
    return 0;
}

总结

我先前在想如何既判断是否有负圈又求最短路，用一个函数实现两个功能，其实灵活变通就好了。因为是否有负圈和求最短路就是两个问题。因为图不一定是联通的。起点和终点在一边，负圈在另一边，哪怕负圈存在，也是存在最短路的。就算负圈不存在，如果起点和终点在两边，最短路也不存在，因为根本就没有从起点到终点的路。所以具体问题具体分析。

1.2 单源最短路问题2（Dijkstra算法）

思路

找到最短距离已经确定的点，然后更新与该点相邻的最短距离，以此循环。

适用条件

由于一旦确定某个点的最短距离，哪怕之后存在负边使得到该点的距离更小，也无法更改。

时间复杂度分析

队列优化dijkstra比bellman-ford高效，但是适用范围小，只能正边。

普通dijkstra时间复杂度,不管是用邻接表还是邻接矩阵都一样。

用邻接表访问边O(E),访问点O(V)

用邻接矩阵访问边O(1),访问点O(VE)

普通Dijkstra O ( E V ) O(EV) O(EV)

int cost[MAX_V][MAX_V];
bool used[MAX_V];
void dijkstra(int s){
	fill(d+1,d+V+1,INF);
	fill(used+1,used+V+1,false);
	d[s]=0;
	while(true){
		int v=-1;
		for(int u=1;u<=V;++u){
			if(!used[u]&&(v==-1||d[u]<d[v]))v=u;
		}
		if(v==-1)break;
		used[v]=true;
		for(int u=1;u<=V;++u){
			d[u]=min(d[u],d[v]+cost[v][u];
		}
	}
}

队列优化Dijkstra O ( E l o g V ) O(ElogV) O(ElogV)

利用priority_queue得到每次更新距离的节点当中最小距离的点

int V,E,s;
vector<edge>G[MAX_V];
int d[MAX_V];
struct edge{int to,cost;};
struct node{
	int id,d;//存储某点的id和到该点的最短距离 
	bool operator<(const node&no)const{
		return d>no.d;
	}
};
void dijkstra(int s){
	priority_queue<node>q;
	fill(d+1,d+V+1,INF);
	d[s]=0;
	q.push({s,0});
	while(!q.empty()){
		node no=q.top();q.pop();
		int v=no.id;
		if(d[v]<no.d)continue;
		for(int i=0;i<G[v].size();++i){
			edge e=G[v][i];
			if(d[e.to]>d[v]+e.cost){
				d[e.to]=d[v]+e.cost;
				q.push({e.to,d[e.to]});
			}
		}
	}
}

1.3 任意两点最短路问题（Floyd-Warshall算法）

Floyd求最短路 - AcWing

思路

利用动态规划求最短路。

dp[k][i][j]表示考虑到第k个点时，以i为起点，j为终点的最短路径。由于都是从上一层状态推导而来，可省略掉一维k。

递推公式为， d p [ i ] [ j ] = m i n ( d p [ i ] [ j ] , d p [ i ] [ k ] + d p [ k ] [ j ] ) dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]) dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j])

全部初始化为最大值，然后dp[i][j]=0，在给边赋值的时候要注意，因为存在重边，所以要取最小值。因为存在自环，所以要判断，如果是到本身这个位置，值为0，如果取负，那就是负环，没有任何意义。

最后的结果如果大于INF/2，则判定最短路不存在。这是因为两个点之间本不存在路径，却因为一条负边值减小了。那么做这类题，就要对数据范围有一个大致的判断。

个人的一点思考，在现实生活中，重边或许还有一定意义，但是自环没有意义。题目中存在自环可能只是因为测试数据是随机的。

模板 O ( V 3 ) O(V^3) O(V3)

#include<bits/stdc++.h>
using namespace std;

const int N=300;
const int M=22000;
const int K=N*N;
const int INF=0x3f3f3f3f;
int n,m,k;
int dp[N][N];
void floyd(){
    for(int k=1;k<=n;++k){
        for(int i=1;i<=n;++i){
            for(int j=1;j<=n;++j){
                dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]);
            }
        }
    }
}

int main(){
    ios::sync_with_stdio(false);
    cin>>n>>m>>k;
    memset(dp,0x3f,sizeof dp);
    for(int i=1;i<=n;++i)dp[i][i]=0;
    for(int i=1;i<=m;++i){
        int u,v,w;cin>>u>>v>>w;
        if(u==v)dp[u][v]=0;
        else dp[u][v]=min(dp[u][v],w);
    }
    floyd();
    while(k--){
        int i,j;cin>>i>>j;
        if(dp[i][j]>INF/2)cout<<"impossible"<<'\n';
        else cout<<dp[i][j]<<'\n';
    }
    return 0;
}

二、最小生成树问题

概念

最小生成树指的是用n-1条边将所有点联通，不存在环，路径最小的树。

2.1 最小生成树问题1（Prim算法）

思路

有一个集合X，用mincost数组存放，所有点到该集合的最短距离。刚开始放任意一个点到X，然后找出相邻最近的点，放入集合X，更新mincost数组，然后继续在集合X向外辐射的边当中找的最近的点，直到找完左右的点。如果图不连通，显然不存在最小生成树。

适用条件

用prim算法，可存在负边。

例题+模板

Prim算法求最小生成树 - AcWing题库

普通模板 O ( V E ) O(VE) O(VE)
#include<bits/stdc++.h>
using namespace std;
const int INF=0x3f3f3f3f;
const int N=600;
const int M=1e5+200;
int cost[N][N];
int mincost[N];
bool used[N];
int n,m;

void init(){
    memset(cost,0x3f,sizeof cost);
    cin>>n>>m;
    for(int i=1;i<=m;++i){
        int u,v,w;cin>>u>>v>>w;
        cost[v][u]=cost[u][v]=min(cost[u][v],w);
    }
}
int prim(){
    memset(used,0,sizeof used);
    memset(mincost,0x3f,sizeof mincost);
    mincost[1]=0;
    int res=0;
    while(true){
        int t=-1;
        for(int i=1;i<=n;++i){
            if(!used[i]&&(t==-1||mincost[t]>mincost[i]))t=i;
        }
        if(t==-1)break;//遍历完所有的点就退出
        if(mincost[t]==INF)return INF;//剩余的点到最小生成树集合的最小距离为INF，说明不连通，最小生成树不存在。
        res+=mincost[t];
        used[t]=true;
        for(int i=1;i<=n;++i){
            mincost[i]=min(mincost[i],cost[i][t]);
        }
    }
    return res;
}
int main(){
    ios::sync_with_stdio(false);
    init();
    int res=prim();
    if(res==INF)cout<<"impossible";
    else cout<<res;
    return 0;
}
队列优化模板 O ( E l o g V ) O(ElogV) O(ElogV)

类似于dijkstra，可以用优先队列找最小mincost

需要注意的是，如果图不连通，res表示在集合中的最小生出树的值，还有一部分点在外面。因此，我们要统计在集合中的点的数量，小于n就表示图不连通，最小生成树不存在。

#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
const int INF=0x3f3f3f3f;
const int N=600;
const int M=1e5+200;
int cost[N][N];
int mincost[N];
bool used[N];
int n,m;

void init(){
    memset(cost,0x3f,sizeof cost);
    cin>>n>>m;
    for(int i=1;i<=m;++i){
        int u,v,w;cin>>u>>v>>w;
        cost[v][u]=cost[u][v]=min(cost[u][v],w);
    }
}
int prim(){
    priority_queue<P,vector<P>,greater<P> >q;
    memset(mincost,0x3f,sizeof mincost);
    mincost[1]=0;
    q.push({0,1});
    used[1]=true;
    int res=0,cnt=0;
    while(!q.empty()){
        P x=q.top();q.pop();
        int v=x.second;
        if(mincost[v]<x.first)continue;
        used[v]=true,cnt++;
        res+=mincost[v];
        for(int i=1;i<=n;++i){
            if(!used[i]&&mincost[i]>cost[i][v]){
                mincost[i]=cost[i][v];
                q.push({mincost[i],i});
            }
        }
    }
    if(cnt<n)return INF;
    return res;
}
int main(){
    ios::sync_with_stdio(false);
    init();
    int res=prim();
    if(res==INF)cout<<"impossible";
    else cout<<res;
    return 0;
}

2.2 最小生成树问题2（Kruskal算法）

把所有的边按权值从小到大排序，只要边的两个端点不在同一个集合，就加上这条边。在一个集合，就不能加入，否则会形成环。

例题+模板 O ( E l o g V ) O(ElogV) O(ElogV)

Kruskal算法求最小生成树 - AcWing题库

#include<bits/stdc++.h>
using namespace std;
const int INF=0x3f3f3f3f;
const int N=1e5+200;
const int M=N*2;
int p[N];
int n,m;
struct edge{
    int from,to,cost;
    bool operator<(const edge &a)const{
        return cost<a.cost;
    }
};
edge es[M];

int find(int v){
    if(p[v]!=v)p[v]=find(p[v]);
    return p[v];
}
int kruskal(){
    int cnt=0,res=0;
    sort(es+1,es+m+1);
    for(int i=1;i<=n;++i)p[i]=i;
    for(int i=1;i<=m;++i){
        int f=es[i].from,t=es[i].to;
        if(find(f)!=find(t)){
            res+=es[i].cost;
            p[find(f)]=find(t);
            cnt++;
        }
    }
    if(cnt<n-1)return INF;
    return res;
}
int main(){
    cin>>n>>m;
    for(int i=1;i<=m;++i){
        cin>>es[i].from>>es[i].to>>es[i].cost;
    }
    int res=kruskal();
    if(res==INF)cout<<"impossible";
    else cout<<res;
    return 0;
}

三、二分图判定

例题+模板

染色法判定二分图 - AcWing题库

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+200;
vector<int>G[N];
int n,m;
int color[N];
bool dfs(int i,int c){
    color[i]=c;
    for(int x:G[i]){
        if(color[x]==c)return false;//相邻点颜色相同则false
        if(color[x]==0&&!dfs(x,-c))return false;//没染过则染色
    }
    return true;
}
int main(){
    cin>>n>>m;
    for(int i=1;i<=m;++i){
        int a,b;cin>>a>>b;
        G[a].push_back(b);
        G[b].push_back(a);
    }
    for(int i=1;i<=n;++i){
        if(color[i]==0){
            if(!dfs(i,1)){
                cout<<"No";
                return 0;
            }
        }
    }
    cout<<"Yes";
    return 0;
}

四、匈牙利最大匹配

把两边看成男人和女人，要使匹配数最多，一种形象的描述方法是这样的：如果女人现在喜欢的男人有备胎，就把他绿了选新的男人，如果没有备胎就继续与这个男人在一起，如果没有喜欢的人，就直接牵手成功。

例题+模板

二分图的最大匹配 - AcWing题库

#include<bits/stdc++.h>
using namespace std;
const int N=600;
const int M=1e5+200;

int n1,n2,m;
vector<int>G[N];
bool st[N];
int match[N];
int res;
bool find(int x){//x为男人编号
    for(int i:G[x]){//遍历能匹配的女人
        if(!st[i]){
            st[i]=true;
            if(!match[i]||find(match[i])){
                match[i]=x;
                return true;
            }
        }
    }
    return false;
}

int main(){
    ios::sync_with_stdio(false);
    cin>>n1>>n2>>m;
    for(int i=1;i<=m;++i){
        int u,v;cin>>u>>v;
        G[u].push_back(v);
    }
  
    for(int i=1;i<=n1;++i){
        memset(st,0,sizeof st);//每一次新的查询，都需要重置。st的作用是为单次find服务的，以防递归死循环。
        if(find(i))res++;
    }
    cout<<res;
    return 0;
}
算法基础14 —— 图论入门之弗洛伊德算法(Floyed + Dijkstra + Bellman-Ford + SPFA)
smallrain6的博客
02-10 4023
入门概念 带权图：如下图所示，我们把边带有权值的图称为带权图 可以将边的权值理解为两点之间的距离 一张图中任意两点间会有不同的路径相连 最短路径：最短路径就是指连接两点的这些路径中最短的一条 Floyed、Dijkstra、Bellman-Ford、SPFA可以有效地解决最短路径问题。 需要注意的是：边的权值可以为负。当出现负边权时，有些算法不适用 最短路径问题是图论中典型的问题，多数模型可以归结为一下三种 管道铺设 线路安装 地图规划 问题引入 国庆期间，7535寝室计划去旅行。在出发前，寝室长
图论专题（各类算法和蓝桥杯真题例题）
weixin_52261094的博客
05-04 1841
介绍了图论相关知识，图论涉及到的一些基本算法，Floyd，Bellman-Ford，SPFA，Dijstra，最小生成树算法
一些图论、网络流入门题总结、汇总
04-18 4587
一些图论、网络流入门题总结、汇总2008-09-03 11:43最短路问题此类问题类型不多，变形较少POJ 2449 Remmarguts Date(中等)http://acm.pku.edu.cn/JudgeOnline/problem?id=2449题意：经典问题：K短路解法：dijkstra+A*(rec)，方法很多相关：http://acm.pku.e
Floyd+限制路径步数（快速幂优化）
Bryce1010's Blog
05-23 697
POJ 3613 Cow Relays 最短路可以采用Floyd来计算，但是限制时间在1s内，估计直接写会超时，所以要用到快速幂来优化。 快速幂的思想是：xy=xy/2∗2xy=xy/2∗2 x^y=x^{y /2*2} 所以每次划分下去寻找最短路 （其实我也没完全想清楚，就不讲太清楚了，怕讲错） //STATUS:C++_AC_125MS_1204K...
FZU 2271 X （Floyd）（第七届福建省大学生程序设计竞赛）
Darkarts
07-19 991
XProblem Description X is a fully prosperous country, especially known for its complicated transportation networks. But recently, for the sake of better controlling by the government, the president Fa
floyd
ailinyingai的博客
10-02 406
public class floyd { static int max = 66666;// 别Intege.max 两个相加越界为负 public static void main(String[] args) { int dist[][] = { { 0, 2, 3, 6, max, max }, { 2, 0, max, max,4, 6 }, { 3, ...
图论基础算法
weixin_44272266的博客
11-27 1706
labuladong算法学习笔记 （公众号：labuladong） 图 —— 高级的多叉树 1. 图的实现 2. 图的遍历 /* 多叉树遍历框架 */ void traverse(TreeNode root) { if (root == null) return; for (TreeNode child : root.children) traverse(child); } /* 图遍历框架 */ Graph graph; boolean[] visited; vo
倍增算法入门 超详细解答+LCA+RMQ(ST表)+例题剖析
热门推荐
繁凡さん的博客
04-03 1万+
目录一、倍增算法二、倍增算法的应用：求LCA（最近公共祖先）附模板题三、倍增算法的应用：RMQ 问题（ST表）附模板题 一、倍增算法 要了解倍增之前，建议先看一下大佬的博客：【白话系列】倍增算法 看完以后相信你已经对倍增有了大致初步的了解，下面给出倍增的定义 （其实没什么用，好长一段话建议不看） 倍增 从字面的上意思看就是成倍的增长 ,这是指我们在进行递推时,如果状态空间很大,通常的线性递推无法满...
算法基础14 —— 图论入门之迪杰斯特拉算法(Dijkstra)
smallrain6的博客
02-11 1782
回顾 Floyed算法可以求任意两点之间的最短路径，但是Dijkstra算法只能求一个结点到另一个结点的最短路径，它是一个单源的最短路径算法 Floyed算法的时间复杂度为O(n^3)，故一般情况下数据范围要求在100以内 Dijkstra算法描述 设起点为s，dis[v]表示从s到v的最短路径长度， 如dis[3] = 6表示从起点到3号结点的最短路径为6 pre[v]为v的前驱节点，用来输出路径 初始化： dis[v] = ∞(v ≠ s);//初始时路径为无穷 dis[s] = 0;//s
CSP 复赛入门组高频算法：典型例题、代码模板与实战题号
温情亿度网络科技
10-02 781
该文档围绕CSP入门组图论基础，阐述DFS和BFS核心思路、典型例题，附完整代码模板，还给出实战题号及教学复习建议，助力学习应用。
图论理论基础（5）
weixin_52423494的博客
12-06 928
dijkstra,prim,bellman_ford,spfa,floyd,A*及相关变式
C语言图论：有向图基础
2503_92860243的博客
12-07 641
本文为C语言学习者系统介绍了有向图的基础知识。文章首先明确了有向图的基本概念，阐述了其与无向图的本质区别，并定义了入度、出度等核心术语。随后，详细讲解了邻接矩阵和邻接表两种适用于有向图的存储结构及其C语言实现。在算法层面，不仅覆盖了深度优先搜索（DFS）和广度优先搜索（BFS）这两种基础遍历方法，还重点探讨了有向图特有的关键算法，包括对有向无环图进行排序的拓扑排序、查找极大连通子图的强连通分量（Kosaraju算法），以及计算单源最短路径的Dijkstra算法，为理解更复杂的图论问题奠定了基础。
C语言图论：无向图基础
2503_92860243的博客
12-07 295
本文系统介绍了无向图的基础知识，从基本概念入手，解释了顶点、边、度数和连通图等核心术语。详细讲解了邻接矩阵和邻接表两种存储方式的C语言实现，并对比了它们的特点和适用场景。接着，阐述了深度优先搜索（DFS）和广度优先搜索（BFS）两种核心遍历算法。最后，探讨了连通分量查找、无权图最短路径以及最小生成树（Prim算法）等基础算法，为读者理解图论提供了清晰的入门指南。
如何基于C#读取.dot图论文件并和QuickGraph联动
qq_40581805的博客
12-07 172
上图中，依赖库FSharpx.Core（1.8.41）是依赖库DotParser运行所需要的，但是VS平台上没有相关版本，只能通过网上搜索下载后再一次利用NuGet安装本地库的方式安装。1. 在Visual Studio平台（版本越新越好）新建一个C#项目，然后利用NuGet程序库中分别下载并安装以下四个依赖包。DotParser读取dot文件时，要求文本内不应出现/、<等特殊字符，如果存在则需要删除后重新读取。> 💡 基于C#语言，获取dot文件内图谱所包含的节点、边等信息。
电脑病毒感染-图论
用来自己学习，复习
12-04 485
相连接的电脑距离不一样，所以感染时间不一样，感染时间用t表示。其中网络内一台电脑被病毒感染，求其感染网络内所有的电脑最少需要多长时间。如果最后有电脑不会感染，则返回-1。给定一个数组times表示一台电脑把相邻电脑感染所用的时间。path[i]={i, j, t}表示：电脑i->j，电脑i上的病毒感染j，需要时间t。接下来M行,每行输入为i,j,t。表示电脑ì感染电脑j需要时间t。第一行输入一个整数N，表示局域网内电脑个数N，1≤N≤200;输出最少需要多少时间才能感染全部电脑，如果不存在输出-1。
图论理论基础（4）
weixin_52423494的博客
12-05 1018
拓扑排序 kahn算法（bfs） dfs
如何识别图论问题：从关键词到思维模式
六六哥的博客
12-03 186
判断"这是图"的关键，是从题目里读出"对象 + 关系/连接"，而且这些关系会一层层传递、形成路径或环。可以刻意练一个"图模式识别"的习惯。
练题100天——DAY21：统计奇数个数+合并有序数组
最新发布
2301_81099859的博客
12-07 218
今天写了两道题，难度，并更新了之前的DAY13的冒泡排序+二进制求和、DAY14全排列的思路。
欧几里得距离算法-相似度
weixin_45609702的博客
12-04 193
本文介绍了一个计算欧几里得距离的Java方法。该方法接收两个Double数组作为输入，通过计算对应元素差值的平方和再开方，返回两个数组之间的欧几里得距离值。当输入数组长度不一致时，方法会返回0作为默认值。欧几里得距离算法常用于比较两个数组之间的相似度，是数据分析和机器学习中的基础距离度量方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值