Day 5 上午
作者：互联网
内容提要
图论QwQ
学好图论的基础：
必须意识到图论 hendanteng
xuehuifangqi（雾
图
G = (V; E)
一般来说，图的存储难度主要在记录边的信息
无向图的存储中，只需要将一条无向边拆成两条即可
邻接矩阵：用一个二维数组 edg[N][N] 表示
edg[i][j] 就对应由 i 到 j 的边信息
edg[i][j] 可以记录 Bool，也可以记录边权
缺点：如果有重边有时候不好处理
空间复杂度 O(V^2)
点度等额外信息也是很好维护的
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
int ideg[N], odeg[N], n, m, edg[N][N];
bool visited[N];
void travel(int u, int distance)
{
cout << u << " " << distance << endl; visited[u] = true;
for (int v = 1; v <= n; v++)
if (edg[u][v] != -1 && !visited[v])//是否已经访问过
travel(v, distance + edg[u][v]); //if there is an edge (u, v) and v has not been visited, then travel(v)
}
int main()
{
cin >> n >> m;
memset(edg, -1, sizeof edg);
memset(visited, false, sizeof visited);
for (int u, v, w, i = 1; i <= m; i++)
cin >> u >> v >> w, edg[u][v] = w, odeg[u]++, ideg[v]++;//出度和入度
for (int i = 1; i <= n; i++)
cout << ideg[i] << " " << odeg[i] << endl;
for (int i = 1; i <= n; i++)
if (!visited[i]) travel(i, 0);
}
/*
Given a graph with N nodes and M unidirectional edges.
Each edge e_i starts from u_i to v_i and weights w_i
Output a travelsal from node 1 and output degree of each node.
*/
邻接表（链式前向星）
对每一个点 u 记录一个 List[u]，包含所有从 u 出发的边
直接用数组实现 List[u]？读入边之前不知道 List[u] 长度
手写链表
用 STL 中的 vector 实现变长数组
只需要 O(V + E) 的空间就能实现图的存储
指针版本（一般不用）
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
struct edge {
int u, v, w; edge *next;//next指针指向
edge(int _u, int _v, int _w, edge *_next):
u(_u), v(_v), w(_w), next(_next) {}
};
edge *head[N]; //List[u] 最前面的节点是谁
int ideg[N], odeg[N], n, m;
bool visited[N];
void add(int u, int v, int w)
{
edge *e = new edge(u, v, w, head[u]);
head[u] = e;
}
void travel(int u, int distance)
{
cout << u << " " << distance << endl; visited[u] = true;
for (edge *e = head[u]; e ; e = e -> next)
if (!visited[e -> v])
travel(e -> v, distance + e -> w); //if there is an edge (u, v) and v has not been visited, then travel(v)
}
int main()
{
cin >> n >> m;
memset(visited, false, sizeof visited);
memset(head, 0, sizeof head);
for (int u, v, w, i = 1; i <= m; i++)
cin >> u >> v >> w, add(u, v, w), odeg[u]++, ideg[v]++;
for (int i = 1; i <= n; i++)
cout << ideg[i] << " " << odeg[i] << endl;
for (int i = 1; i <= n; i++)
if (!visited[i]) travel(i, 0);
}
/*
Given a graph with N nodes and M unidirectional edges.
Each edge e_i starts from u_i to v_i and weights w_i
Output a travelsal from node 1 and output degree of each node.
*/
数组模拟版本：
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
struct edge {
int u, v, w, next;
}edg[N];
int head[N]; //List[u] stores all edges start from u
int ideg[N], odeg[N], n, m, cnt; //cnt: numbers of edges
bool visited[N];
void add(int u, int v, int w)
{
int e = ++cnt;
edg[e] = (edge){u, v, w, head[u]};
head[u] = e;
}
void travel(int u, int distance)
{
cout << u << " " << distance << endl; visited[u] = true;
for (int e = head[u]; e ; e = edg[e].next)
if (!visited[edg[e].v])
travel(edg[e].v, distance + edg[e].w); //if there is an edge (u, v) and v has not been visited, then travel(v)
}
int main()
{
cin >> n >> m; cnt = 0;
memset(visited, false, sizeof visited);
memset(head, 0, sizeof head);
for (int u, v, w, i = 1; i <= m; i++)
cin >> u >> v >> w, add(u, v, w), odeg[u]++, ideg[v]++;
for (int i = 1; i <= n; i++)
cout << ideg[i] << " " << odeg[i] << endl;
for (int i = 1; i <= n; i++)
if (!visited[i]) travel(i, 0);
}
/*
Given a graph with N nodes and M unidirectional edges.
Each edge e_i starts from u_i to v_i and weights w_i
Output a travelsal from node 1 and output degree of each node.
*/
用edg[u][i]表示从u出发第i条信息，但这样还是n^2
但这样很浪费，因为数组不能全部利用
传统的方法要在定义数组是就规定他的大小，但是我们读入之前并不知道从每个点出发的边数
我们可以用vector
一些 vector 的细节
vector 本质就是 c++ 模板库帮我们实现好的变长数组
向一个数组 a 的末尾加入一个元素 x a:push_back(x)
询问数组 a 的长度 a.size()
注意： vector 中元素下标从 0 开始
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
struct edge {
int u, v, w;
};
vector<edge> edg[N]; //edge记录变长数组记录的是什么类型
int ideg[N], odeg[N], n, m, cnt; //cnt: numbers of edges
bool visited[N];
void add(int u, int v, int w)
{
edg[u].push_back((edge){u, v, w});//一个强制类型转换
}
void travel(int u, int distance)
{
cout << u << " " << distance << endl; visited[u] = true;
for (int e = 0; e < edg[u].size(); e++)//遍历边
if (!visited[edg[u][e].v])//以u出发的第e条出边
travel(edg[u][e].v, distance + edg[u][e].w); //if there is an edge (u, v) and v has not been visited, then travel(v)
}
int main()
{
cin >> n >> m; cnt = 0;
memset(visited, false, sizeof visited);
for (int u, v, w, i = 1; i <= m; i++)
cin >> u >> v >> w, add(u, v, w), odeg[u]++, ideg[v]++;
for (int i = 1; i <= n; i++)
cout << ideg[i] << " " << odeg[i] << endl;
for (int i = 1; i <= n; i++)
if (!visited[i]) travel(i, 0);
}
/*
Given a graph with N nodes and M unidirectional edges.
Each edge e_i starts from u_i to v_i and weights w_i
Output a travelsal from node 1 and output degree of each node.
*/
生成树
给定一个连通无向图 G = (V; E)
E′ ⊂ E
G′ = (V; E′) 构成一棵树
G′ 就是 G 的一个生成树
生成树不是唯一的，并且数量是指数级别
问题描述
给定一个 n 个点 m 条边的带权无向图，求一个生成树，使得生成树中最大边权的最小
数据范围： n; m ≤ 10^6
Algorithms for Minimal Spanning Tree
Kruskal
Prim
Kosaraju
并查集
生成树的本质：选取若干条边使得任意两点连通
维护图中任意两点的连通性
查询任意两点连通性
添加一条边，使两个端点所在连通块合并
Kruskal
Intuitive ideas
将原图无向边按照边权从小到大排序
找到当前边权最小的边 e : (u; v)
如果 u 和 v 已经连通，则直接删除这条边(因为形成了环)
如果 u 和 v 已经未连通，将之加入生成树
重复上述过程
证明：
Rigorous proof
消圈算法：
如果原图中有一个环，然后把这个圈中边权最大的去掉，这样不断去掉最后得到的就是最小生成树
但是由于环不好找，所以不用他
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005;
struct edge {
int u, v, w;
}edg[maxn];
int n, m, p[maxn], ans = 0;
bool cmp(edge a, edge b)
{return a.w < b.w;}
int findp(int t)
{return p[t] ? p[t] = findp(p[t]) : t;}
bool merge(int u, int v)
{
u = findp(u); v = findp(v);
if (u == v) return false;
p[u] = v; return true;
}
int main()
{
cin >> n >> m;
for (int i = 1, u, v, w; i <= m; i++)
cin >> u >> v >> w, edg[i] = (edge){u, v, w};
sort(edg + 1, edg + m + 1, cmp);
for (int i = 1; i <= m; i++)
if (merge(edg[i].u, edg[i].v))
ans = max(ans, edg[i]. w);
cout << ans << endl;
}
本蒟蒻的博客：传送门
路径
P = p0; ...; pn 为 u 到 v 的路径
p0 = u， pn = v
对于任意i∈2 [1; n]; 存在e : (pi−1; pi)∈E
P 的长度
length(P) = ∑e∈P length(e)
我们一般考虑简单路径，就是不重复经过一个点的路径
显然它也不一定是惟一的
最短路径问题
给定一个有向图 G，询问 u 到 v 之间最短路径长度
记 d(u，v) 表示 u 到 v 的最短路径长度
为方便起见，不妨规定 u 和 v 不连通时， d(u; v) = +1
Algorithms for Shortest Path Problem
floyd
Bellman-Ford
SPFA
Dijkstra
先介绍一下松弛操作
SSP 算法的本质思想就是不断进行松弛操作
d(u; v) ≤ d(u; w) + d(w; v)
我们算出来了一个d(u,v)但是他不一定是最终的d(u,v),这时如果我们找到了d(u，w) + d(w，v)<当前的d(u,v)，就更新d(u,v)的值
floyd
初始时， d(u; v) 就等于 u 到 v 的边权
用邻接矩阵的形式记录 d
u 和 v 没边， d(u,v) = +∞
u 和 v 有重边，保留最小边权
三层循环枚举 k; i; j，执行松弛操作
d(i,j) = min{d(i,j); d(i,k) + d(k,j)}
代码：
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
const int inf = 1 << 29;
int d[N][N], n, m;
int main()
{
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = inf;
for(int i = 1;i <= n; i++)
d[i][i]=0;
for (int u, v, w, i = 1; i <= m; i++)
cin >> u >> v >> w, d[u][v] = min(d[u][v], w);
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
//必须先枚举中间点
}
本蒟蒻博客：传送门
三层循环枚举 k,i,j，执行松弛操作
d(i,j) = min{d(i,j), d(i,k) + d(k,j)}
任意两点之间的最短路最多经过 n − 1 条有向边
k = 1 的循环结束之后
如果 u --> v 的 最短路径 只经过 1，此时的 d(u,v) 就是真实值
k = 2 的循环结束之后
如果 u --> v 的 最短路径 只经过 1,2，此时的 d(u,v) 就是真实值
k = t 的循环结束之后
如果 u --> v 的 最短路径 只经过 1...t，此时的 d(u,v) 就是真实值
不断有真实值被算出，然后又不断合并
不断枚举松弛操作的中间点 k
算法时间复杂度 O(n^3)
优势：处理出 d 之后，任意两点 SP 能 O(1) 询问
注意：必须先枚举中间点！！！必须先枚举中间点！！！必须先枚举中间点！！！
负权环
如果存在一个环，其边权和为负数，则称为负权环
u --> v 存在一个负权环，d(u,v) = −∞
判断图是否含负权环
floyd 后检查是否存在 d(u，u) < 0，如果存在就说明有负权环
单源最短路
不需要知道图中任意两个点的 SP
只需要知道某一点 u 到其它点的 SP
u 称为源点，单源最短路就是求从 u 出发的最短路
为方便，下面记源点为 S
Bellman-Ford
将 d(S,u) 简写为 d(u)，初始 d(S) = 0， d(u) = +∞
执行 n 次全局松弛操作
枚举图中每条边 e : (u,v,w)
松弛 d(v) = min{d(v),d(u) + w}
证明：
如果目前存在 d(u) 还不是真实值，一定有边能继续松弛
任意最短路经过不超过 n − 1 条边， n - 1 次松弛足矣
优势：算法很直观
算法时间复杂度 O(nm)
判负权环
再多进行一次全局松弛，如果有 d 被更新，一定有负权环
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
const int inf = 1 << 29;
int d[N][N], n, m;
int main()
{
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = inf;
for(int i = 1;i <= n; i++)
d[i][i]=0;
for (int u, v, w, i = 1; i <= m; i++)
cin >> u >> v >> w, d[u][v] = min(d[u][v], w);
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
//必须先枚举中间点
}
如果有一次松弛没有任何边被改变，就说明已经结束了
所以可以做一下小小的优化（常数级别）
#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<iomanip>
#include<cmath>
#include<cstring>
#include<string>
#include<algorithm>
#include<time.h>
#include<queue>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pr;
const double pi=acos(-1);
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,n,a) for(int i=n;i>=a;i--)
#define Rep(i,u) for(int i=head[u];i;i=Next[i])
#define clr(a) memset(a,0,sizeof a)
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
ld eps=1e-9;
ll pp=1000000007;
ll mo(ll a,ll pp){if(a>=0 && a<pp)return a;a%=pp;if(a<0)a+=pp;return a;}
ll powmod(ll a,ll b,ll pp){ll ans=1;for(;b;b>>=1,a=mo(a*a,pp))if(b&1)ans=mo(ans*a,pp);return ans;}
ll read(){
ll ans=0;
char last=' ',ch=getchar();
while(ch<'0' || ch>'9')last=ch,ch=getchar();
while(ch>='0' && ch<='9')ans=ans*10+ch-'0',ch=getchar();
if(last=='-')ans=-ans;
return ans;
}
//head
struct edge{
int u,v,w;
}edg[n];
int d[n],n,m,s;
int main()
{
n=read(),m=read(),s=read()
rep(i,1,n) d[i]=0x7fffffff;
for(int u ,v,w,i=1;i<=m;i++)
{
cin>>u>>v>>w,edg[i]=(edge){u,v,w};
}
d[s]=0;
rep(i,1,n)
{
rep(j,1,m)
{
int u=edg[j].u,v=edg[j].v,w=edg[j].w;
if(d[v]>d[u]+w) d[v]=d[u]+w,tag=true;
}
if(!tag)break;
}
}
SPFA
Intuitive ideas
Bellman-Ford 算法中，如果 d(u) 在上一次全局更新中没有被更新，
那么这一次全局更新中不必松弛 u 的出边（就是不用它更新其他边）
因为这个操作在上一次中已经做过了
在 Bellman-Ford 的基础上改进
维护队列 Queue，记录哪些点的出边有必要松弛
取出 Queue 最前端的点 u
枚举 u 的所有出边 e : (u,v,w)
尝试松弛 e，若 d(v) > d(u) + w，更新 d(v)，同时如果 v 不 在 Queue中,将 v 加入 Queue 中
算法何时终止？
记录每个点加入 Queue 的次数
u 被加入 Queue 一次，意味着 d(u) 被更新了一次
u 最多被更新 n − 1 次，否则肯定有负权环
时间复杂度理论上是O(mn),但肯定不劣于 Bellman-ford，实际远不到 O(nm)
Detail
更新 d(v) 后，如何判断 v 是不是已经在 Queue 里
用一个 Bool 数组记录就行， in/out Queue 的时候标记
怎么记录一个点进入 Queue 的次数
用一个计数数组记录就行， in/out Queue 的时候标记
优势： SPFA 在解决单源最短路问题中很高效
越稀疏越快（网格图会炸）
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int inf = 1 << 29;
struct edge{
int u, v, w;
};
vector<edge> edg[N];
int d[N], n, m, S;
queue<int> Queue;
bool inQueue[N];
int cntQueue[N];
void add(int u, int v, int w)
{
edg[u].push_back((edge){u, v, w});
}
int main()
{
cin >> n >> m >> S;
for (int i = 1; i <= n; i++) d[i] = inf;
for (int u, v, w, i = 1; i <= m; i++)
cin >> u >> v >> w, add(u, v, w);
d[S] = 0; inQueue[S] = true; Queue.push(S);
while (!Queue.empty())
{
int u = Queue.front(); Queue.pop(); inQueue[u] = false;
for (int e = 0; e < edg[u].size(); e++)
{
int v = edg[u][e].v, w = edg[u][e].w;
if (d[v] > d[u] + w)
{
d[v] = d[u] + w;
if (!inQueue[v])
{
Queue.push(v); ++cntQueue[v]; inQueue[v] = true;
if (cntQueue[v] >= n) {cout << "Negative Ring" << endl; return 0;}
}
}
}
}
for (int i = 1; i <= n; i++)
cout << d[i] << endl;
}
本蒟蒻博客：传送门
标签：edg,int,Queue,edge,上午,visited,include,Day 来源： https://www.cnblogs.com/lcezych/p/10801912.html