图
定义：
1.图是由一个顶点的集合V和一个顶点间关系间的集合E组成：记作G=（V,E）.V：顶点的有限非空集合.
E：顶点间关系的有限集合（边集）.存在一个节点V，可能含有多个前驱结点和后继节点.
2.无向图：
在图G=（V，E）中，如果对于任意的顶点a，b∈V，当(a，b)∈E时，必有（b，a）∈E（即关系
R对称），此图称为无向图。无向图中用不带箭头的边表示顶点的关系.
有向图：如果对于任意的顶点a，b∈V，当(a，b)∈E时 ，(b，a)∈E未必成立，则称此图为有向图.
在有向图中，通常用带箭头的边连接两个有关联的结点.
3.
在无向图中：
顶点v的度是指与顶点v相连的边的数目D(v)。D(2)=3
在有向图中：
入度——以该顶点为终点的边的数目和。ID(3)=2
出度——以该顶点为起点的边的数目和。OD(3)=1
度数为奇数的顶点叫做奇点，度数为偶数的点叫做偶点。
度：等于该顶点的入度与出度之和。
4.带权图：
一般的图边上没有数字，边仅表示两个顶点的相连接关系。
图中的边可以加上表示某种含义的数值，数值称为边的权，此图称为带权图。也称为网。
图的相关算法（最短路）：
分类：
1.Floyd.
2.Dijkstra.
3.Bellmanford.
4.spfa.
例题：
1342：【例4-1】最短路径问题
时间限制: 1000 ms 内存限制: 65536 KB
【题目描述】
平面上有n个点（n<=100），每个点的坐标均在-10000~10000之间。其中的一些点之间有连线。
若有连线，则表示可从一个点到达另一个点，即两点间有通路，通路的距离为两点间的直线距离。现在的任务是找出从一点到另一点之间的最短路径。
【输入】
共n+m+3行，其中:
第一行为整数n。
第2行到第n+1行（共n行） ，每行两个整数x和y，描述了一个点的坐标。
第n+2行为一个整数m，表示图中连线的个数。
此后的m 行，每行描述一条连线，由两个整数i和j组成，表示第i个点和第j个点之间有连线。
最后一行：两个整数s和t，分别表示源点和目标点。
【输出】
一行，一个实数（保留两位小数），表示从s到t的最短路径长度。
【输入样例】
5
0 0
2 0
2 2
0 2
3 1
5
1 2
1 3
1 4
2 5
3 5
1 5【输出样例】
3.41【代码】
#include<bits/stdc++.h>
using namespace std;
const int N=105;
int a[N][2];
double d[N][N],c[N];
bool f[N];
double maxx=1e30;
int main(){
int m,n,s,e;
cin>>n;
for(int i=1;i<=n;i++){
scanf("%d%d",a[i],a[i]+1);
}
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
d[i][j]=maxx;
cin>>m;
while(m--){
int x,y;
scanf("%d%d",&x,&y);
d[x][y]=d[y][x]=sqrt(pow(a[x][0]-a[y][0],2)+pow(a[x][1]-a[y][1],2));
}
cin>>s>>e;
for(int i=1;i<=n;i++) c[i]=d[s][i];
memset(f,false,sizeof(f));
f[s]=true;
c[s]=0;
for(int i=1;i<n;i++){
double minn=maxx;
int k=0;
for(int j=1;j<=n;j++){
if(!f[j]&&c[j]<minn){
minn=c[j];
k=j;
}
}
if(!k)break;
f[k]=true;
for(int j=1;j<=n;j++)
c[j]=min(c[j],c[k]+d[k][j]);
}
printf("%.2lf",c[e]);
return 0;
}1344：【例4-4】最小花费
时间限制: 1000 ms 内存限制: 65536 KB
【题目描述】
在n个人中，某些人的银行账号之间可以互相转账。这些人之间转账的手续费各不相同。给定这些人之间转账时需要从转账金额里扣除百分之几的手续费，请问A最少需要多少钱使得转账后B收到100元。
【输入】
第一行输入两个正整数n,m，分别表示总人数和可以互相转账的人的对数。
以下m行每行输入三个正整数x,y,z，表示标号为x的人和标号为y的人之间互相转账需要扣除z%的手续费 (z<100)。
最后一行输入两个正整数A,B。数据保证A与B之间可以直接或间接地转账。
【输出】
输出A使得B到账100元最少需要的总费用。精确到小数点后8位。
【输入样例】
3 3
1 2 1
2 3 2
1 3 3
1 3【输出样例】
103.07153164【提示】
【数据规模】
1<=n<=2000
【代码】：
#include<bits/stdc++.h>
using namespace std;
double a[2001][2001],dis[2001],minn;
int f[2001],n,m,k,x,y;
void read(){
int xx,yy,zz;
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++){
scanf("%d%d",&xx,&yy);
scanf("%lf",&a[xx][yy]);
a[xx][yy]=(100-a[xx][yy])/100;
a[yy][xx]=a[xx][yy];
}
cin>>x>>y;
}
void dijkstra(int x){
for(int i=1;i<=n;i++)
dis[i]=a[x][i];
dis[x]=1;
f[x]=1;
for(int i=1;i<=n-1;i++){
minn=0;
for(int j=1;j<=n;j++)
if(f[j]==0&&dis[j]>minn){
k=j;
minn=dis[j];
}
f[k]=1;
if(k==y) break;
for(int j=1;j<=n;j++)
if(f[j]==0&&dis[k]*a[k][j]>dis[j]) dis[j]=dis[k]*a[k][j];
}
}
int main(){
read();
dijkstra(x);
printf("%.8lf",100/dis[y]);
return 0;
}这里再给大家更新一下四种算法的模板：
Dijkstra.
Dijkstra求最短路
给定一个 nn 个点 mm 条边的有向图，图中可能存在重边和自环，所有边权均为正值。
请你求出 11 号点到 nn 号点的最短距离，如果无法从 11 号点走到 nn 号点，则输出 −1−1。
输入格式
第一行包含整数 nn 和 mm。
接下来 mm 行每行包含三个整数 x,y,zx,y,z，表示存在一条从点 xx 到点 yy 的有向边，边长为 zz。
输出格式
输出一个整数，表示 11 号点到 nn 号点的最短距离。
如果路径不存在，则输出 −1−1。
数据范围
1≤n≤5001≤n≤500,
1≤m≤1051≤m≤105,
图中涉及边长均不超过10000。
输入样例：
3 3
1 2 2
2 3 1
1 3 4输出样例：
3#include<bits/stdc++.h>
using namespace std;
const int N = 510;
int n, m;
int g[N][N];
int dist[N];
bool st[N];
int dijkstra(){
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
for (int i = 0; i < n - 1; i ++ ){
int t = -1;
for (int j = 1; j <= n; j ++ )
if (!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
for (int j = 1; j <= n; j ++ )
dist[j] = min(dist[j], dist[t] + g[t][j]);
st[t] = true;
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
int main(){
scanf("%d%d", &n, &m);
memset(g,0x3f,sizeof g);
while (m--){
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
g[a][b] = min(g[a][b], c);
}
printf("%d\n", dijkstra());
return 0;
}Bellman-Ford：
有边数限制的最短路
给定一个 nn 个点 mm 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出从 11 号点到 nn 号点的最多经过 kk 条边的最短距离，如果无法从 11 号点走到 nn 号点，输出 impossible。
注意：图中可能 存在负权回路 。
输入格式
第一行包含三个整数 n,m,kn,m,k。
接下来 mm 行，每行包含三个整数 x,y,zx,y,z，表示存在一条从点 xx 到点 yy 的有向边，边长为 zz。
点的编号为 1∼n1∼n。
输出格式
输出一个整数，表示从 11 号点到 nn 号点的最多经过 kk 条边的最短距离。
如果不存在满足条件的路径，则输出 impossible。
数据范围
1≤n,k≤5001≤n,k≤500,
1≤m≤100001≤m≤10000,
1≤x,y≤n1≤x,y≤n，
任意边长的绝对值不超过 1000010000。
输入样例：
3 3 1
1 2 1
2 3 1
1 3 3输出样例：
3#include<bits/stdc++.h>
using namespace std;
const int N = 510, M = 10010;
struct Edge{
int a, b, c;
}edges[M];
int n, m, k;
int dist[N];
int last[N];
void bellman_ford(){
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
for (int i = 0; i < k; i ++ ){
memcpy(last, dist, sizeof dist);
for (int j = 0; j < m; j ++ ){
auto e = edges[j];
dist[e.b] = min(dist[e.b], last[e.a] + e.c);
}
}
}
int main(){
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i ++ ){
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
edges[i] = {a, b, c};
}
bellman_ford();
if (dist[n] > 0x3f3f3f3f / 2) puts("impossible");
else printf("%d\n", dist[n]);
return 0;
}spfa：
spfa求最短路
给定一个 nn 个点 mm 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出 11 号点到 nn 号点的最短距离，如果无法从 11 号点走到 nn 号点，则输出 impossible。
数据保证不存在负权回路。
输入格式
第一行包含整数 nn 和 mm。
接下来 mm 行每行包含三个整数 x,y,zx,y,z，表示存在一条从点 xx 到点 yy 的有向边，边长为 zz。
输出格式
输出一个整数，表示 11 号点到 nn 号点的最短距离。
如果路径不存在，则输出 impossible。
数据范围
1≤n,m≤1051≤n,m≤105,
图中涉及边长绝对值均不超过 1000010000。
输入样例：
3 3
1 2 5
2 3 -3
1 3 4输出样例：
2#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];
void add(int a, int b, int c){
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}
int spfa(){
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
queue<int> q;
q.push(1);
st[1] = true;
while (q.size()){
int t = q.front();
q.pop();
st[t] = false;
for (int i = h[t]; i != -1; i = ne[i]){
int j = e[i];
if (dist[j] > dist[t] + w[i]){
dist[j] = dist[t] + w[i];
if (!st[j]){
q.push(j);
st[j] = true;
}
}
}
}
return dist[n];
}
int main(){
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
while (m -- ){
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
int t = spfa();
if (t == 0x3f3f3f3f) puts("impossible");
else printf("%d\n", t);
return 0;
}Floyd：
Floyd求最短路
给定一个 nn 个点 mm 条边的有向图，图中可能存在重边和自环，边权可能为负数。
再给定 kk 个询问，每个询问包含两个整数 xx 和 yy，表示查询从点 xx 到点 yy 的最短距离，如果路径不存在，则输出 impossible。
数据保证图中不存在负权回路。
输入格式
第一行包含三个整数 n,m,kn,m,k。
接下来 mm 行，每行包含三个整数 x,y,zx,y,z，表示存在一条从点 xx 到点 yy 的有向边，边长为 zz。
接下来 kk 行，每行包含两个整数 x,yx,y，表示询问点 xx 到点 yy 的最短距离。
输出格式
共 kk 行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出 impossible。
数据范围
1≤n≤2001≤n≤200,
1≤k≤n21≤k≤n2
1≤m≤200001≤m≤20000,
图中涉及边长绝对值均不超过 1000010000。
输入样例：
3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3输出样例：
impossible
1#include <bits/stdc++.h>
using namespace std;
const int N = 210, INF = 1e9;
int n, m, Q;
int d[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 ++ )
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
int main(){
scanf("%d%d%d", &n, &m, &Q);
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= n; j ++ )
if (i == j) d[i][j] = 0;
else d[i][j] = INF;
while (m -- ){
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
d[a][b] = min(d[a][b], c);
}
floyd();
while (Q -- ){
int a, b;
scanf("%d%d", &a, &b);
int t = d[a][b];
if (t > INF / 2) puts("impossible");
else printf("%d\n", t);
}
return 0;
}
