1、树与图的宽度优先遍历-图中点的层次
给定一个n个点m条边的有向图，图中可能存在重边和自环。所有边的长度都是1，点的编号为1~n。请你求出1号点到n号点的最短距离，如果从1号点无法走到n号点，输出-1。
给定一个n个点m条边的有向图，图中可能存在重边和自环。
所有边的长度都是1，点的编号为1~n。
请你求出1号点到n号点的最短距离，如果从1号点无法走到n号点，输出-1。
输入格式
第一行包含两个整数n和m。
接下来m行，每行包含两个整数a和b，表示存在一条从a走到b的长度为1的边。
输出格式
输出一个整数，表示1号点到n号点的最短距离。
数据范围
1≤n,m≤1051≤n,m≤105
输入样例：
4 5
1 2
2 3
3 4
1 3
1 4
输出样例：
1//步骤：使用队列来存距离，包括d[N]存储搜索到的距离，q[N]存每个点的距离，然后就是链表定义
//队列/距离初始化-》每次取队头，遍历如果该队头下的链表上的j没有扩展过（d[j] == -1），则更新距离d[j] = d[t] + 1;q[++tt] = j;
//return d[n];//返回最后一个点搜到的距离
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 100010;
int n, m;
int h[N], e[N], ne[N], idx;
int d[N], q[N];
//插入操作
void add(int a, int b)
{
e[idx] = b;
ne[idx] = h[a];
h[a] = idx ++;
}
int bfs()
{
int hh = 0, tt = 0;//队头队尾
q[0] = 1;//第一个元素是起点
memset (d, -1, sizeof d);//初始化距离
d[1] = 0;//最开始只有第一个点被遍历过，距离是0
while(hh <= tt)
{
int t = q[hh ++];//取队头
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (d[j] == -1)//如果j没有扩展过
{
//扩展j
d[j] = d[t] + 1;
//将j加入队列
q[++tt] = j;
}
}
}
return d[n];//返回最后一个点搜到的距离
}
int main()
{
cin >> n >> m;
memset(h, -1, sizeof h);
for (int i = 0; i < m; i ++)//i < m
{
int a, b;
cin >> a >> b;
add(a, b);
}
cout << bfs() <<endl;
return 0;
}2、拓扑排序-有向图的拓扑排序
给定一个n个点m条边的有向图，点的编号是1到n，图中可能存在重边和自环。
请输出任意一个该有向图的拓扑序列，如果拓扑序列不存在，则输出-1。
若一个由图中所有点构成的序列A满足：对于图中的每条边(x, y)，x在A中都出现在y之前，则称A是该图的一个拓扑序列。
输入格式
第一行包含两个整数n和m
接下来m行，每行包含两个整数x和y，表示存在一条从点x到点y的有向边(x, y)。
输出格式
共一行，如果存在拓扑序列，则输出拓扑序列。
否则输出-1。
数据范围
1≤n,m≤1051≤n,m≤105
输入样例：
3 3
1 2
2 3
1 3
输出样例：
1 2 3#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010;
int n, m;
int h[N], e[N], ne[N], idx;
int q[N], d[N];
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
bool topsort()
{
int hh = 0, tt = -1;
//d[i] 存储点i的入度
for (int i = 1; i <= n; i ++)
if (!d[i])
q[++ tt] = i;//入队
while (hh <= tt)
{
int t = q[hh ++];
//枚举t的所有出边
for(int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
d[j] --;//删除j
if (d[j] == 0) q[++ tt] = j;//删除完将j插入队列
}
}
return tt == n - 1;
}
int main()
{
cin >> n >> m;
memset(h, -1, sizeof h);
for (int i = 0; i < m; i ++)
{
int a, b;
cin >> a >> b;
add(a, b);
d[b] ++;
}
if (topsort())
{
for (int i = 0; i < n; i ++) printf("%d ", q[i]);
puts("");
}
else puts("-1");
return 0;
}3、Dijkstra求最短路径
给定一个n个点m条边的有向图，图中可能存在重边和自环，所有边权均为正值。请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出-1。
给定一个n个点m条边的有向图，图中可能存在重边和自环，所有边权均为正值。
请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出-1。
输入格式
第一行包含整数n和m。
接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。
输出格式
输出一个整数，表示1号点到n号点的最短距离。
如果路径不存在，则输出-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 <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
//使用邻接矩阵来写
const int N = 510;
int n, m;
int g[N][N];
int dist[N];//dist[N]狄杰斯特拉的距离，表示从1号点到其他点的最短距离是多少。
bool st[N];//st[]每个点最短路是否确定
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);// 初始化
dist[1] = 0;//1、第一个点初始化为0
//2、循环遍历,迭代n次
for (int i = 0; i < n; i ++)
{
//未确定点最短路径
int t = -1;
for (int j = 1; j <= n; j ++)
//未确定点最短路径，当前t不是最短的
if (!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
st[t] = true;
//用t来更新点的距离
for (int j = 1; j <= n; j ++)
dist[j] = min(dist[j], dist[t] + g[t][j]);//判断从1->2->3与1->3求最小值
}
//如果dist == 正无穷，表示不存在最短路径，返回-1
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];//否则返回最短路径
}
int main()
{
scanf("%d%d", &n, &m);
memset(g, 0x3f, sizeof g);
while (m --)//输入m条边
{
//包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
g[a][b] = min(g[a][b], c);//留下最小值
}
int t = dijkstra();
printf("%d\n", t);
return 0;
}4、优化版-Dijkstra求最短路径
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
//用堆来维护最短路径
typedef pair<int, int> PII;
//使用邻接矩阵来写
const int N = 100010;
int n, m;
int h[N], w[N], e[N], ne[N], idx;//链表
int dist[N];//dist[N]狄杰斯特拉的距离，表示从1号点到其他点的最短距离是多少。
bool st[N];//st[]每个点最短路是否确定
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
int dijktra()
{
memset(dist, 0x3f, sizeof dist);// 初始化
dist[1] = 0;//1、第一个点初始化为0
//用优先队列来维护最短路径距离
priority_queue<PII, vector<PII>, greater<PII>> heap;
heap.push({0, 1});//把起点放进去
while (heap.size())//队列最多m条边
{
auto t = heap.top();//每次取出来当前最小的点
heap.pop();
int ver = t.second, distance = t.first;
if (st[ver]) continue;//如果当前点被更新过,这个点，continue
//否则用这个点来更新其他点
for (int i = h[ver]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > distance + w[i])
{
dist[j] = distance + w[i];
heap.push({dist[j], j});//如果更新成功就把新的点放到队列里去
}
}
}
//如果dist == 正无穷，表示不存在最短路径，返回-1
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];//否则返回最短路径
}
int main()
{
scanf("%d%d", &n, &m);
//堆初始化
memset(h, -1, sizeof h);
while (m --)//输入m条边
{
//包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);//留下最小值
}
int t = dijktra();
printf("%d\n", t);
return 0;
}