关于图中的环相关问题
判断无向图是否有环：
无向图中当顶点的数量和边的数量很大的时候，使用dfs存在大量的递归，会导致栈溢出。使用下面的方法可以有效的避免。
判断无向图中是否存在回路（环）的算法描述
如果存在回路，则必存在一个子图，是一个环路。环路中所有顶点的度>=2。
算法：
第一步：删除所有度<=1的顶点及相关的边，并将另外与这些边相关的其它顶点的度减一。
第二步：将度数变为1的顶点排入队列，并从该队列中取出一个顶点重复步骤一。
如果最后还有未删除顶点，则存在环，否则没有环。
由于有m条边，n个顶点。如果m>=n，则根据图论知识可直接判断存在环路。 （证明：如果没有环路，则该图必然是k棵树 k>=1。根据树的性质，边的数目m = n-k。k>=1，所以：m<n） 如果m<n 则按照上面的算法每删除一个度为0的顶点操作一次（最多n次），或每删除一个度为1的顶点（同时删一条边）操作一次（最多m次）。这两种操作的总数不会超过m+n。由于m<n，所以算法复杂度为O(n)
判断有向图是否有环：
拓扑排序，将出队元素存入数组，判断存储数组里的元素是否等于 n 。
求无向图的最小环花费：
floyd算法 O (N3)
给出一张无向图，求一个最小环并输出路径。
说说我的感觉：
包含点 i 和点 j 的最小环，我们可以看成是 i 到 j 之间的最短路和次短路的组合，通过 floyd 可求任意两点之间的最短距离，
那么我们只要找到最短路径外的一条最短路来保证 i 和 j 之间可达即可。在做 floyd 循环的同时，我们以 环权值 最小（最短路权值+次短路权值=最小环权值）为标准，
一直更新每个点的前驱，也就是记录 i 到 j 的最短路径，以及，能够松弛 i 和 j 的点 k （k 不在 i 到 j 的最短路径中）中代价最小的那个（也就是 i 到 j 之间的次短路），
然后按环的自然顺序输出即可。
#include<cstdio> #include<cstring> #define find_min(a,b) a<b?a:b const int N = 101; const int INF = 0x7ffffff; int mat[N][N],dist[N][N],pre[N][N],path[N],n; int main() { int i,j,k,m,a,b,c; int num; while(~scanf("%d%d",&n,&m)){ for(i=1;i<=n;i++){ for(j=1;j<=n;j++){ mat[i][j]=dist[i][j]=INF; pre[i][j]=i; } } while(m--){ scanf("%d%d%d",&a,&b,&c); mat[a][b]=mat[b][a]=dist[a][b]=dist[b][a]=find_min(mat[a][b],c); } int min=INF; for(k=1;k<=n;k++){//最短路径外一点将最短路首尾链接,那么就得到一个最小环 for(i=1;i<k;i++){ for(j=i+1;j<k;j++){ //求最小环不能用两点间最短路松弛,因为(i,k)之间的最短路,(k,j)之间的最短路可能有重合的部分 //所以mat[][]其实是不更新的,这里和单纯的floyd最短路不一样 //dist[i][j]保存的是 i 到 j 的最短路权值和 int tmp=dist[i][j]+mat[i][k]+mat[k][j];//这里 k 分别和 i 还有 j 在mat中直接相连 if(tmp<min){ min=tmp; num=0; int p=j; while(p!=i){//回溯 path[num++]=p; p=pre[i][p];//pre[i][j]表示 i 到 j 最短路径上 j 前面的一个点 } path[num++]=i; path[num++]=k; } } } for(i=1;i<=n;i++){ for(j=1;j<=n;j++){ if(dist[i][j]>dist[i][k]+dist[k][j]){ dist[i][j]=dist[i][k]+dist[k][j];//dist[][]保存两点间最短距离 pre[i][j]=pre[k][j]; } } } } if(min==INF)puts("No solution."); else{ printf("%d",path[0]); for(i=1;i<num;i++) printf(" %d",path[i]); puts(""); } } return 0; }
Dijkstra算法 O(M*Mlog)
任意一个环的权值，我们都可以看成两个有边相连的结点i、j的直接距离加上i、j间不包含边(边i->j)的最短路径。求最短路径我们第一个想到的就是Dijkstra算法。
而Dijkstra所求的是一个点到所有点的最短距离。
用Dijkstra所求的i、j的最短距离一定是i、j的直接距离(如果i，j连通)，所以我们需要先将i、j的边从图中删除(若i，j不连通，则不用删除)，
再用Dijkstra求新图中i、j的最短距离即可。所以我们每次在图中选取一条边，把它从图中删掉．
然后对删掉的那条边所对应的2点进行Dijkstra，也就是m次Dijkstra
给出题目：http://acm.hdu.edu.cn/showproblem.php?pid=6005
给你m条边，每条边给你两个城市的坐标，还有两个城市道路之间有成本
让你求一个最小成本的周期，至少包含三个城市。
#include <bits/stdc++.h> #define pii pair<int,int> using namespace std; const int inf = 0x3f3f3f3f; const int maxn = 1e4+15; const int maxm = 8e3+43; int t,cnt,m,x,y,w,u,v,p,res,head[maxm]; struct edge{ int to,nxt,w; }e[maxm<<1]; struct cmp{ bool operator()(const pii a,const pii b){ return a.second > b.second; } }; map<pii,int> vis; inline void add(int x,int y,int _w){ e[++cnt].to = y;e[cnt].w = _w; e[cnt].nxt = head[x];head[x] = cnt; } int dis[maxm]; void init(){ vis.clear(); cnt = 0;res = inf;p = 0; memset(head,0,sizeof(head)); } void dijkstra(int x,int y){ memset(dis,inf,sizeof(dis)); priority_queue<pii,vector<pii>,cmp> q; dis[x] = 0; q.push(pii(x,0)); while(!q.empty()){ pii now = q.top();q.pop(); int uu = now.first; if(uu == y || now.second > res) return ; //剪枝 if(dis[uu] < now.second) continue; for(int i = head[uu];i;i = e[i].nxt){ int vv = e[i].to; if((uu==x&&vv==y)||(uu==y&&vv==x)) continue; //这条边是删除的边 if(dis[vv] > dis[uu]+e[i].w){ dis[vv] = dis[uu] + e[i].w; q.push(pii(vv,dis[vv])); } } } } int main(){ scanf("%d",&t); for(int Case = 1; Case <= t; ++Case){ init(); scanf("%d",&m); for(int i = 1;i <= m; ++i){ scanf("%d %d",&x,&y); if(!vis[pii(x,y)]) u = ++p,vis[pii(x,y)] = u; else u = vis[pii(x,y)]; scanf("%d %d %d",&x,&y,&w); if(!vis[pii(x,y)]) v = ++p,vis[pii(x,y)] = v; else v = vis[pii(x,y)]; add(u,v,w); add(v,u,w); } for(int i = 1;i <= p; ++i){ for(int j = head[i]; j ;j = e[j].nxt){ if(i >= e[j].to) continue; dijkstra(i,e[j].to); res = min(res,dis[e[j].to]+e[j].w); } } printf("Case #%d: %d\n",Case,res==inf ? 0:res); } return 0; }
求有向图的最小环花费：
floyd算法 O (N3) （可以求边带权的）
对于每个i 比较 dist[ i ][ i ] 的大小即可。
#include <iostream> #include <cstring> #include <cstdio> #include <queue> #define mmin(a,b) a<b? a:b using namespace std; const int INF=0x7ffffff; int mp[105][105]; int n,m; int floyd() { int i,j,k; for(k=0; k<n; k++) for(i=0; i<n; i++) for(j=0; j<n; j++) if(mp[i][j] > mp[i][k]+mp[k][j]) mp[i][j]=mp[i][k]+mp[k][j]; } int main() { // printf("%d\n",INF); int cases; scanf("%d",&cases); while(cases--) { int a,b,c; scanf("%d %d",&n,&m); for(int i=0; i<n; i++) for(int j=0; j<n; j++) mp[i][j]=INF; for(int i=0; i<m; i++) { scanf("%d %d %d",&a,&b,&c); if(c<mp[a][b]) mp[a][b]=c; } floyd(); int result=INF; /* for(int i=0; i<n; i++) { for(int j=0; j<n; j++) printf("%d ",mp[i][j]); printf("\n"); }*/ for(int i=0; i<n; i++) { // printf("%d\n",mp[i][i]); if(result>mp[i][i]) result=mp[i][i]; } if(result == INF) printf("-1\n"); else printf("%d\n",result); } return 0; }
带权并查集 O（N）（当n比较大时，且边权为1）
#include<cstdio> #include<iostream> using namespace std; int f[200002],d[200002],n,minn,last; //f保存祖先节点，d保存到其祖先节点的路径长。 int fa(int x) { if (f[x]!=x) //查找时沿途更新祖先节点和路径长。 { int last=f[x]; //记录父节点（会在递归中被更新）。 f[x]=fa(f[x]); //更新祖先节点。 d[x]+=d[last]; //更新路径长（原来连在父节点上）。 } return f[x]; } void check(int a,int b) { int x=fa(a),y=fa(b); //查找祖先节点。 if (x!=y) {f[x]=y; d[a]=d[b]+1;} //若不相连，则连接两点，更新父节点和路径长。 else minn=min(minn,d[a]+d[b]+1); //若已连接，则更新最小环长度。 return; } int main() { int i,t; scanf("%d",&n); for (i=1;i<=n;i++) f[i]=i; //祖先节点初始化为自己，路径长为0。 minn=0x7777777; for (i=1;i<=n;i++) { scanf("%d",&t); check(i,t); //检查当前两点是否已有边相连接。 } printf("%d",minn); return 0; }
拓扑排序 O（N+M） + DFS （可能会爆）（这只是我的口胡而已）
具体做法就是先跑一边拓扑标记，之后跑dfs就好，注意dfs找到环的时候不能直接结束整个dfs，因为需要统计所有环的大小（边权为1
如果带权的话，那么也是一样的，只不过把层数改成了目前经过的权值。
（上述算法应该仅限于每个点只有一条出边的题目。）
spfa 题目链接：https://blog.csdn.net/qq_43408238/article/details/102641472
#include<iostream> #include<cstring> #include<cmath> #include<algorithm> #include<map> #include<cstdio> #include<queue> #include<stack> using namespace std; const int INF = 0x3f3f3f3f; int cost[305][305]; int dis[305]; int n; bool vis[305]; void spfa( int start ){ stack<int> Q; for( int i = 1; i <= n; i++ ){ dis[i] = cost[start][i]; if( i != start ){ Q.push( i ); vis[i] = true; } else{ vis[i] = false; } } dis[start] = INF; while( !Q.empty() ){ int x = Q.top(); Q.pop(); vis[x] = false; for( int y = 1; y <= n; y++ ){ if( x == y ) continue; if( dis[x] + cost[x][y] < dis[y] ){ dis[y] = dis[x] + cost[x][y]; if( !vis[y] ){ vis[y] = true; Q.push( y ); } } } } } int main(){ ios::sync_with_stdio( false ); while( cin >> n ){ for( int i = 1; i <= n; i++ ){ for( int j = 1; j <= n; j++ ){ cin >> cost[i][j]; } } int ans, c1, cn; spfa( 1 ); ans = dis[n]; c1 = dis[1]; spfa( n ); cn = dis[n]; cout << min( ans, c1 + cn ) << endl; } return 0; }
（上述算法应该仅限于每个点只有一条出边的题目。）
求所有环的数量（口胡）
好像只能用暴力dfs，不能用tajan因为不是求强联通分量。
有向图就是裸dfs， 无向图就是需要不能访问fa节点。
O(n(n+m)log
