图论
走迷宫
给定一个 n×mn×m 的二维整数数组，用来表示一个迷宫，数组中只包含 00 或 11，其中 00 表示可以走的路，11 表示不可通过的墙壁。
最初，有一个人位于左上角 (1,1)(1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。
请问，该人从左上角移动至右下角 (n,m)(n,m) 处，至少需要移动多少次。
数据保证 (1,1)(1,1) 处和 (n,m)(n,m) 处的数字为 00，且一定至少存在一条通路。
输入格式
第一行包含两个整数 nn 和 mm。
接下来 nn 行，每行包含 mm 个整数（00 或 11），表示完整的二维数组迷宫。
输出格式
输出一个整数，表示从左上角移动至右下角的最少移动次数。
数据范围
1≤n,m≤1001≤n,m≤100
输入样例：
5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
输出样例：
8
题解代码：
'''
此处放置你的题解代码
'''
一、解法一：
#include<bits/stdc++.h>
using namespace std;
const int N=1e2+10;
typedef pair<int , int> PII;//自定义
int dx[4]={0,0,-1,1},dy[4]={1,-1,0,0};//分别{dx[i],dy[i]}分别表示上下左右
int g[N][N],d[N][N];//g存放地图，d为到各点原点距离
int n,m;
int bfs(){
// '''
// 打表
所谓bfs打表,我个人理解为将图所有可行位置全部遍历，进行广度遍历即bfs
// '''
queue< PII > q;//存放路径的队列
q.push({0,0});
memset(d,-1,sizeof(d));
d[0][0]=0;//起点
while(q.size()){
PII t=q.front(); //当前位置
q.pop();//当前位置弹出
for(int i=0;i<4;i++){//四个方位移动
int x=t.first+dx[i];
int y=t.second+dy[i];
if(x>=0&&x<n&&d[x][y]==-1&&y>=0&&y<m&&g[x][y]==0){
//x,y在定义区间内且该点未走过且该点可以走
d[x][y]=d[t.first][t.second]+1;//1、标记该点走过 2、该点与原点距离
q.push({x,y});//将新坐标入队 打表
}
}
}
return d[n-1][m-1];//结果
}
int main(){
cin>>n>>m;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
cin>>g[i][j];
cout<<bfs()<<endl;
}
八数码
在一个 3×33×3 的网格中，1∼81∼8 这 88 个数字和一个 x 恰好不重不漏地分布在这 3×33×3 的网格中。
例如：
1 2 3
x 4 6
7 5 8
在游戏过程中，可以把 x 与其上、下、左、右四个方向之一的数字交换（如果存在）。
我们的目的是通过交换，使得网格变为如下排列（称为正确排列）：
1 2 3
4 5 6
7 8 x
例如，示例中图形就可以通过让 x 先后与右、下、右三个方向的数字交换成功得到正确排列。
交换过程如下：
1 2 3 1 2 3 1 2 3 1 2 3
x 4 6 4 x 6 4 5 6 4 5 6
7 5 8 7 5 8 7 x 8 7 8 x
现在，给你一个初始网格，请你求出得到正确排列至少需要进行多少次交换。
输入格式
输入占一行，将 3×33×3 的初始网格描绘出来。
例如，如果初始网格如下所示：
1 2 3
x 4 6
7 5 8
则输入为：1 2 3 x 4 6 7 5 8
输出格式
输出占一行，包含一个整数，表示最少交换次数。
如果不存在解决方案，则输出 −1−1。
输入样例：
2 3 4 1 5 x 7 6 8
输出样例
19
题解代码：
‘’‘
此处放置你的代码
’‘’
#include<bits/stdc++.h>
using namespace std;
queue<string> q;
unordered_map<string , int> d;
int dx[4]={0,0,1,-1},dy[4]={1,-1,0,0};
const string ed="12345678x";
int bfs(string state){
q.push(state);
d[state]=0;
while(q.size()>0){
auto t=q.front();
q.pop();
int idx=t.find('x');
int a=idx/3,b=idx%3;
int distance=d[t];
if (t==ed)
return d[t];
for(int i=0;i<4;i++){
int x=a+dx[i],y=b+dy[i];
swap(t[idx],t[x*3+y]);
if(x>=0&&x<3&&y>=0&&y<3&&!d[t]){
d[t]=distance+1;
q.push(t);
}
swap(t[idx],t[x*3+y]);
}
}
return -1;
}
int main(){
string state;
char c;
for(int i=0;i<9;i++)
{
cin>>c;
state+=c;
}
cout<<bfs(state)<<endl;
}
树的重心
给定一颗树，树中包含 nn 个结点（编号 1∼n1∼n）和 n−1n−1 条无向边。
请你找到树的重心，并输出将重心删除后，剩余各个连通块中点数的最大值。
重心定义：重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。
输入格式
第一行包含整数 nn，表示树的结点数。
接下来 n−1n−1 行，每行包含两个整数 aa 和 bb，表示点 aa 和点 bb 之间存在一条边。
输出格式
输出一个整数 mm，表示将重心删除后，剩余各个连通块中点数的最大值。
数据范围
1≤n≤1051≤n≤105
输入样例
9
1 2
1 7
1 4
2 8
2 5
4 3
3 9
4 6
输出样例：
4
题解代码：
邻接表算法参考巧妙的邻接表（数组实现） - 阿玛尼迪迪 - 博客园 (cnblogs.com)
‘’‘
参考代码
’‘’
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 1e5 + 10; //数据范围是10的5次方
const int M = 2 * N; //以有向图的格式存储无向图，所以每个节点至多对应2n-2条边
int h[N]; //邻接表存储树，有n个节点，所以需要n个队列头节点
int e[M]; //存储元素
int ne[M]; //存储列表的next值
int idx; //单链表指针
int n; //题目所给的输入，n个节点
int ans = N; //表示重心的所有的子树中，最大的子树的结点数目
bool st[N]; //记录节点是否被访问过，访问过则标记为true
//a所对应的单链表中插入b a作为根
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
// dfs 框架
/*
void dfs(int u){
st[u]=true; // 标记一下，记录为已经被搜索过了，下面进行搜索过程
for(int i=h[u];i!=-1;i=ne[i]){
int j=e[i];
if(!st[j]) {
dfs(j);
}
}
}
*/
//返回以u为根的子树中节点的个数，包括u节点
int dfs(int u) {
int res = 0; //存储 删掉某个节点之后，最大的连通子图节点数
st[u] = true; //标记访问过u节点
int sum = 1; //存储 以u为根的树 的节点数, 包括u，如图中的4号节点
//访问u的每个子节点
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
//因为每个节点的编号都是不一样的，所以 用编号为下标 来标记是否被访问过
if (!st[j]) {
int s = dfs(j); // u节点的单棵子树节点数 如图中的size值
res = max(res, s); // 记录最大联通子图的节点数
sum += s; //以j为根的树 的节点数
}
}
//n-sum 如图中的n-size值，不包括根节点4；
res = max(res, n - sum); // 选择u节点为重心，最大的 连通子图节点数
ans = min(res, ans); //遍历过的假设重心中，最小的最大联通子图的 节点数
return sum;
}
int main() {
memset(h, -1, sizeof h); //初始化h数组 -1表示尾节点
cin >> n; //表示树的结点数
// 题目接下来会输入，n-1行数据，
// 树中是不存在环的，对于有n个节点的树，必定是n-1条边
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
add(a, b), add(b, a); //无向图
}
dfs(1); //可以任意选定一个节点开始 u<=n
cout << ans << endl;
return 0;
}
作者：松鼠爱葡萄
链接：https://www.acwing.com/solution/content/13513/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
‘’‘
此处放置你的代码
’‘’
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
const int M=N*2;
bool st[N];
int ans = N;
int n;
//邻接表
int h[N],e[N*2],ne[N*2],idx;
void add(int a,int b){
e[idx]=b;
ne[idx]=h[a];
h[a]=idx++;
}
int dfs(int u){
int res=0;
st[u]=true;
int sum=1;
for(int i=h[u];i!=-1;i=ne[i]){
int j=e[i];
if(!st[j]){
int s = dfs(j);
res = max(res,s);
sum += s;
}
}
res = max(res,n-sum);
ans = min(ans,res);
return sum;
}
int main(){
memset(h,-1,sizeof(h));
int a,b;
cin>>n;
for(int i=0;i<n-1;i++)
{
cin>>a>>b;
add(a,b),add(b,a);
}
dfs(1);
cout<<ans<<endl;
return 0;
}
邻接表
邻接表实现
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gVEwLwTR-1648554855739)(F:\算法打卡\算法基础课\zjy\imgs\image-20220313154111682.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3tMRxuLi-1648554855741)(F:\算法打卡\算法基础课\zjy\imgs\image-20220313154133502.png)]
图中点的层次
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环。
所有边的长度都是 1，点的编号为 1∼n。
请你求出 1 号点到 n 号点的最短距离，如果从 1 号点无法走到 n 号点，输出 −1。
输入格式
第一行包含两个整数 n 和 m。
接下来 m 行，每行包含两个整数 a 和 b，表示存在一条从 a 走到 b 的长度为 1的边。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
数据范围
1≤n,m≤10^5
输入样例：
4 5
1 2
2 3
3 4
1 3
1 4
输出样例：
1
题解代码：
'''
此处放置你的代码
'''
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int head[N],ne[N*2],ver[N*2],n,m,idx;//邻接表数据结构
int dist[N];//存储距离
int str[N];//标记是否走过
void add(int x,int y){//邻接表存储图
ver[idx]=y;
ne[idx]=head[x];
head[x]=idx++;
}
void bfs(){
memset(dist,0x3f,sizeof(dist));//邻接表存储图
dist[1]=0;//从一号节点开始距离为0
queue<int> q;
q.push(1);
str[1]= 1;//入队设置为1
while(q.size()){//对列非空，就一直往后搜索
int t=q.front();//对列非空，就一直往后搜索
q.pop();
for(int i =head[t]; i != -1 ;i = ne[i]){
//遍历所有t节点能到的点，i为节点索引
int j = ver[i];//遍历所有t节点能到的点，i为节点索引
if(!str[j]){//遍历所有t节点能到的点，i为节点索引
dist[j] = dist[t]+1;//遍历所有t节点能到的点，i为节点索引
q.push(j);//节点入队
str[j] = 1;//入队后标记，已经遍历过了
}
}
}
}
int main(){
memset(head,-1,sizeof(head));
cin>>n>>m;
for(int i=0;i<m;i++){
int a,b;
cin>>a>>b;
add(a,b);//加入邻接表
}
bfs();
//如果到n号节点的距离不是无穷大，输出距离，如果是无穷大，输出-1.
cout<< (dist[n]==0x3f3f3f3f ? -1 : dist[n]);
return 0;
}
有向图的拓扑序列
给定一个 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≤10^5
输入样例：
3 3
1 2
2 3
1 3
输出样例：
1 2 3
题解代码：
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int h[N],e[N],ne[N],idx;
int n,m;
int q[N],d[N];//q队列，d入度
void add(int x,int y){//邻接表
e[idx]=y;
ne[idx]=h[x];
h[x]=idx++;
}
bool topsort(){
int hh=0,tt=-1;
for(int i=1;i<=n;i++){
if(!d[i]){
q[++tt]=i;
}
}
while(hh<=tt){
int t=q[hh++];
for(int i=h[t];i!=-1;i=ne[i]){
int j=e[i];
d[j]--;
if(d[j]==0)
q[++tt]=j;
}
}
return tt==n-1;
}
int main(){
cin>>n>>m;
memset(h,-1,sizeof(h));
for(int i=0;i<m;i++){
int x,y;
cin>>x>>y;
add(x,y);
d[y]++;
}
if(topsort()){
for(int i=0;i<n;i++)
printf("%d ",q[i]);
puts("");
}else puts("-1");
return 0;
}
Dijkstra求最短路 I
给定一个 n个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。
输入格式
第一行包含整数 n和 m。
接下来 m 行每行包含三个整数 x,y,z表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 −1。
数据范围
1≤n≤500,
1≤m≤10^5,
图中涉及边长均不超过10000。
输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3
题解代码:
邻接表实现
#include<bits/stdc++.h>
using namespace std;
const int N=510;
const int M=1e5+10;
int h[N],e[M],ne[M],w[M],idx;//邻接表
int state[N];//存储N个点的状态 是否成为最短路径
int dist[N];//保存原点到各点的距离
int n,m;
void add(int a,int b,int c){
e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
void Dijkstra(){
memset(dist,0x3f,sizeof(dist));
dist[1]=0;//原点距离为0
for(int i=1;i<=n;i++){
//遍历n个点
int t=-1;
for(int j=1;j<=n;j++){
//遍历dist数组
//找到没有确定最短路径的节点中距离源点最近的点t
if(!state[j]&&(t==-1 || dist[j]<dist[t]))
t=j;//最近的点
}
state[t]=1;
for(int j=h[t];j!=-1;j=ne[j]){
int k=e[j];
dist[k] = min(dist[k],dist[t]+w[j]);
//更新dist下一个点的距离
}
}
}
int main(){
memset(h,-1,sizeof(h));
cin>>n>>m;
while(m--){
int a,b,x;
cin>>a>>b>>x;
add(a,b,x);
}
Dijkstra();
if(dist[n]!=0x3f3f3f3f) cout<<dist[n];
else cout<<"-1";
}
邻接矩阵实现
#include<bits/stdc++.h>
using namespace std;
const int N=510,M=1e5+10;
const int INF=0x3f3f;
//使用邻接矩阵则数据点大小不得超过1010
int n,m,G[N][N];//构建邻接矩阵
int dist[N];//用来保存各个点到源点的距离
bool state[N]={false};//初始化状态
void Dijkstra(){
fill(dist,dist+N,INF);//初始化dist距离，慎用memset
dist[1]=0;//源点为0
for(int i=1;i<=n;i++){//遍历n个点
int t=-1,k=INF;//t使dist[t]最小，k存放最小的dist[t]
for(int j=1;j<=n;j++){//遍历n个点
//找到未访问的点中dist距离最小的点
if(!state[j]&&dist[j]<k)
{
t=j;
k=dist[j];
}
}
//找不到小于INF的dist[t],说明剩下的点和源点不通返回
if(t==-1) return;
//找到dist[t]最小的点，确认找到源点到该点的最短距离
state[t]=true;
for(int j=1;j<=n;j++){
//遍历n个点,以t为中介点更迭各个点到源点的距离
if(!state[j]&&G[t][j] != INF && (dist[t]+G[t][j] < dist[j]))
//当j点未被访问 且G[t][j]的点的距离不为无穷大 且 到j点的距离小于中介点t加上t-->j的距离
//则更新dist[j]点的距离
dist[j]=dist[t]+G[t][j];
}
}
}
int main(){
cin>>n>>m;
fill(G[0],G[0]+N*N,INF);
for(int i=0;i<m;i++){
int a,b,c;
cin>>a>>b>>c;
//为什么会加这个判断呢？
//因为题目数据中可能包含自环和重边
//重边时的重复距离可能并不是最短的，但是需要程序取最短的路径
if(G[a][b]==INF)
//如果没有重边时
G[a][b]=c;
else G[a][b]= G[a][b] < c ? G[a][b] : c;
//如果有重边时则取最短的边
}
Dijkstra();
//打印各个点距离，排错
// for(int i=0;i<=n;i++)
// printf("%d ",dist[i]);
if(dist[n]!=INF) cout<<dist[n];
else cout<<"-1";
}
Dijkstra求最短路径II
给定一个 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,m≤1.5×1051≤n,m≤1.5×105,
图中涉及边长均不小于 00，且不超过 1000010000。
数据保证：如果最短路存在，则最短路的长度不超过 109109。
输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3
题解代码：
//打注释代码都是调试代码
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10,INF=1e9+10;
typedef pair<int ,int> PII;
int n,m;
int h[N],e[N],ne[N],w[N],idx;
int dist[N];
bool st[N]={false};
int pre[N];//路径数组
void add(int a,int b,int c){
e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int dijkstra(){
//堆优化版
fill(st,st+N,false);
fill(dist,dist+N,INF);
dist[1]=0;
priority_queue<PII,vector<PII>, greater<PII>> heap;//小根堆
heap.push({0,1});
while(heap.size()){
auto t = heap.top();
heap.pop();
int node = t.second;
// int dis = t.first;
if(st[node]) continue;
st[node] = true;
for(int i=h[node];i!=-1;i=ne[i]){
int j=e[i];
if(dist[j]>dist[node]+w[i]){
dist[j] = dist[node]+w[i];
heap.push({dist[j],j});//距离变小，入堆
pre[j]=node;//调试代码，可打印路径
// if(node>=50)
// printf("%d-->%d dist:%d\n ",j,node,dist[j]);
}
}
}
// printf("\n%lld\n",dist[n]);
if(dist[n]==INF) return -1;
return dist[n];
}
int main(){
cin>>n>>m;
fill(h,h+N,-1);
fill(w,w+N,INF);
while(m--){
int a,b,c;
cin>>a>>b>>c;
add(a,b,c);
}
//路径初始化 调试可以用
for(int i=1;i<=n;i++) {
pre[i]=i;
// cout<<i<<":"<<pre[i]<<endl;
}
cout<<dijkstra()<<endl;
// for(int i=1;i<=n;i++)
// cout<<"dist"<<i<<":"<<dist[n]<<endl;
// cout<<endl;
// for(int i=1;i<=n;i++)
// cout<<i<<":"<<pre[i]<<endl;
}
扫一扫
850
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
