图:顶点与边的集合。表示为G(V,E)。G表示图,V表示顶点个数(即图中的元素),E表示边的数;图中一定有顶点,边可以没有,任意两个顶点都可能有关系
floyd算法:感觉像是一种动态规划,建立一个二维数组,用来表示两点间的最短路径值,开始的时候是初始化的值,用三个循环,不断判断通过其他顶点的参与,是否有最短路径可取,更新两点间的最短距离
基本代码
#include<bits/stdc++.h>.
using namespace std;
int main()
{
int e[10][10];//所需要构造的最短路径图
int maxx=9999999;//表示无穷大
int n,m;//表示顶点和边的数
cin>>n>>m;
//初始化
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(i==j)
e[i][j]=0;//自身到自身的距离始终为0
else
e[i][j]=maxx;
}
}
//读入边
int t1,t2,t3;//t1是起始点,t2是到达点,t3是距离
for(int i=1;i<=m;i++)
{
cin>>t1>>t2>>t3;
e[t1][t2]=t3;//构造最短路径图
}
for(int k=1;k<=n;k++)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(e[i][j]>e[i][k]+e[k][j])//不断寻找最短路径,然后更新数值
e[i][j]=e[i][k]+e[k][j];
}
}
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
cout<<e[i][j]<<" ";
cout<<endl;
}
}
dijkstra算法:一般用于由一个点出发,找到这个点到其他各点的距离的情况,所以每次我们每次都要找到一个出发点最近的一个顶点,然后以该顶点为中心进行扩展,最终得到最短路径图
基本代码
#include<bits/stdc++.h>
using namespace std;
int e[10001][10001];//用于存储顶点间的关系
int dis[10001];//用于存储源点到其他各点的最短距离
bool book[10001];//用于标记已知最短路径和未知最短路径
int maxx=2147483647;//表示不能到达时候
int main()
{
int n,m,s,t1,t2,t3;
cin>>n>>m>>s;
//初始化
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(i==j)
e[i][j]=0;
else
e[i][j]=maxx;
}
}
//读入边
for(int i=1;i<=m;i++)
{
cin>>t1>>t2>>t3;
e[t1][t2]=t3;
}
//初始化dis数组
for(int i=1;i<=n;i++)
dis[i]=e[s][i];
//初始化book数组
for(int i=1;i<=n;i++)
book[i]=false;
book[s]=true;
int u;
for(int i=1;i<=n-1;i++)//计算源点到n-1个点的权
{
//找到离源点最近的点
int minn=maxx;
for(int j=1;j<=n;j++)
{
if(book[j]==false&&dis[j]<minn)
{
minn=dis[j];
u=j;
}
}
book[u]=1;//确定此点是离源点最近的点,然后从这点开始发散
for(int v=1;v<=n;v++)
{
if(e[u][v]<maxx)//找到这个点可连接的其他点
{
if(dis[v]>dis[u]+e[u][v])//判断是否更新数据
dis[v]=dis[u]+e[u][v];
}
}
}
for(int i=1;i<=n;i++)
cout<<dis[i]<<" ";
return 0;
}
前向星是一种特殊的边集数组,我们把边集数组中的每一条边按照起点从小到大排序,如果起点相同就按照终点从小到大排序,并记录下以某个点为起点的所有边在数组中的起始位置和存储长度,那么前向星就构造好了.
基本代码
struct Edge
{
int next;//下一个同起点的结构体下标
int to;//终点
int w;//权
};
int head[10000];//head初始化为-1,表示此时没有同起点的顶点
void add(int u,int v,int w)//u为起点,v为终点,w为权,cnt初始化为1
{
edge[cnt].w = w;
edge[cnt].to = v;
edge[cnt].next = head[u];//表明同起点的有无情况
head[u] = cnt;//把下标和付给这个起点的head,建立关系
cnt++;
}
1.
这个题的大致题意就是给出图的两点间的值,然后求最短路径值。用的是floyd算法,直接构造一个最短路径图,然后输出图(1,n)的值就好
#include<bits/stdc++.h>.
using namespace std;
int main()
{
int e[300][300];//所需要构造的最短路径图
int maxx=9999999;//表示无穷大
int n,t;
cin>>n;
//初始化
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(i==j)
e[i][j]=0;//自身到自身的距离始终为0
else
e[i][j]=maxx;//表示此路暂时不通
}
}
for(int i=1;i<n;i++)
{
for(int j=i+1;j<=n;j++)
{
cin>>t;
e[i][j]=t;//构造最短路径图
}
}
for(int k=1;k<=n;k++)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(e[i][j]>e[i][k]+e[k][j])//不断寻找最短路径,然后更新数值
e[i][j]=e[i][k]+e[k][j];
}
}
}
cout<<e[1][n];
}
2.
奇了巴怪了这个题,开始看到这个第的时候我用了搜索,逐个枚举每个顶点,然后搜索这个顶点是不是用其他的到达方式,是的话就加一,然后再输出依旧为一的点,但是还是有三个测试点没分,于是我又采用其他方法
我们直接枚举每个铁路被炸的情况,通过并查集连接其他的铁路,此时如果是keyroad的话,这城市就不会连成一整块,也就是说存在有两个城市不相连的情况,这时我们只需要判断两两连续城市是否有相同的老大就行
#include<bits/stdc++.h>
using namespace std;
struct ma//关系结构体
{
int x;
int y;
}a[6000];
int n,m,p[200];
bool pai(ma c,ma d)//结构体排序
{
if (c.x==d.x)//前一个相等时比较后一个
return c.y<d.y;
else
return c.x<d.x;
}
int findd(int q)//找老大
{
while(p[q]!=q)
q=p[q];
return q;
}
void join(int e,int r)//并查集
{
int fx=findd(e),fy=findd(r);
if(fx!=fy)
p[fx]=fy;
}
int main()
{
cin>>n>>m;
for(int i=1;i<=m;i++)
{
cin>>a[i].x>>a[i].y;
if(a[i].x>a[i].y)//把小的放前面,方便排序
swap(a[i].x,a[i].y);
}
sort(a+1,a+1+m,pai);//方便输出
for(int i=1;i<=m;i++)//枚举每条铁路
{
for(int j=1;j<=n;j++)
p[j]=j;//初始化
for(int j=1;j<=m;j++)
{
if(i!=j)
join(a[j].x,a[j].y);
}
for(int j=2;j<=n;j++)
{
if(findd(p[j])!=findd(p[j-1]))//此时如果是keyroad的话,这城市就不会连成一整块,也就是说存在有两个城市不相连的情况,这时我们只需要判断两两城市是否有相同的老大就行
{
cout<<a[i].x<<" "<<a[i].y<<endl;
break;
}
}
}
return 0;
}
3.
这个题目的大致意思是给出你一张有向图所有边的权,然后你根据它给的路线找到一条最短路径,我优先考虑的是floyd算法,毕竟这个代码最简单
然后我们根据给出数据构建一张最短路径图,然后沿着路线将权相加就可以了
#include<bits/stdc++.h>
using namespace std;
int main()
{
int maxx=100009;
int mp[200][200],road[10005],n,m,sum=0;
cin>>n>>m;
for(int i=1; i<=m; i++)
cin>>road[i];//将数据存入路线数组
//初始化
for(int i=1; i<=n; i++)
{
for(int j=1; j<=n; j++)
mp[i][j]=maxx;
}
for(int i=1; i<=n; i++)//构建图
for(int j=1; j<=n; j++)
cin>>mp[i][j];
for(int k=1;k<=n;k++)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(mp[i][j]>mp[i][k]+mp[k][j])//不断寻找最短路径,然后更新数值
mp[i][j]=mp[i][k]+mp[k][j];
}
}
}
for(int i=1;i<m;i++)
{
sum=sum+mp[road[i]][road[i+1]];//此时最短路径图已经更新好了,我们只需要沿着路线将权相加就行
}
cout<<sum;
}
4.
这个题的数据范围较大,如果构建二维数组存图的话就会数据空间超限,所以我们要运用前所讲的链式前向星
#include<bits/stdc++.h>
using namespace std;
struct node
{
int to;//终点
int v;//权
int next;//下一个同起点的结构体下标
} edge[500005];
int maxx=2147483647;//记为无穷大
int book[10005];//用于标记已知最短路径和未知最短路径
int dis[10005];//用于存储源点到其他各点的最短距离
int head[10005];//用于存储同起点边的
int cnt=1;//作为结构体下标
int n,m,s;
// 链式前向星
void uni(int x,int y,int z)
{
edge[cnt].to=y;
edge[cnt].v=z;
edge[cnt].next=head[x];
head[x]=cnt;
cnt++;
}
void dijkstra()
{
int u=s;//从起点开始
for(int i=1;i<=n-1;i++)//计算源点到n-1个点的权
{
book[u]=1;//标记扩展点
for(int k=head[u];k!=-1;k=edge[k].next)
{
int a=u,b=edge[k].to,w=edge[k].v;
if(dis[b]>dis[a]+w)
dis[b]=dis[a]+w;
}
//找到离源点最近的点
int minn=maxx;
for(int j=1;j<=n;j++)
{
if(book[j]==0&&dis[j]<minn)
{
minn=dis[j];
u=j;
}
}
}
}
int main()
{
cin>>n>>m>>s;
//初始化head数组和dis数组
for(int i=1;i<=n;i++)
{
head[i]=-1;//表示此路不通
dis[i]=maxx;
}
dis[s]=0;
//读入边
for(int i=1;i<=m;i++)
{
int t1,t2,t3;
cin>>t1>>t2>>t3;
uni(t1,t2,t3);//建造链式前向星
}
//初始化book数组
for(int i=1;i<=n;i++)
book[i]=0;
dijkstra();
for(int i=1;i<=n;i++)
cout<<dis[i]<<" ";
}
5.
一个dijkstra模板题,直接套用模板就行,有一点要注意就是因为是无向图,所以再构建图的时候,输入边时要使两个顶点互通
#include<bits/stdc++.h>
using namespace std;
int e[2505][2505];//用于存储顶点间的关系
int dis[10001];//用于存储源点到其他各点的最短距离
int book[10001];//用于标记已知最短路径和未知最短路径
int maxx=2e7;//表示不能到达时候
int main()
{
int n,m,s,t1,t2,t3,t;
cin>>n>>m>>s>>t;
//初始化
for(int i=1; i<=n; i++)
{
for(int j=1; j<=n; j++)
{
if(i==j)
e[i][j]=0;
else
e[i][j]=maxx;
}
}
//读入边
for(int i=1; i<=m; i++)
{
cin>>t1>>t2>>t3;
if(e[t1][t2]>t3)// 保留长度最短的重边
{
e[t1][t2]=t3;
e[t2][t1]=t3;
}
}
//初始化dis数组
for(int i=1; i<=n; i++)
dis[i]=e[s][i];
//初始化book数组
for(int i=1; i<=n; i++)
book[i]=0;
book[s]=1;
int u;
for(int i=1; i<=n-1; i++) //计算源点到n-1个点的权
{
//找到离源点最近的点
int minn=maxx;
for(int j=1; j<=n; j++)
{
if(book[j]==0&&dis[j]<minn)
{
minn=dis[j];
u=j;
}
}
book[u]=1;//确定此点是离源点最近的点,然后从这点开始发散
for(int v=1; v<=n; v++)
{
if(e[u][v]<maxx)//找到这个点可连接的其他点
{
if(dis[v]>dis[u]+e[u][v])//判断是否更新数据
dis[v]=dis[u]+e[u][v];
}
}
}
cout<<dis[t];
return 0;
}
6.
这道题用的是floyd算法,因为很明显题中要求出答案需要1到其他个点的距离以及其他各点的距离到1,我们直接将图填出来,然后再进行算术相加就行
#include<bits/stdc++.h>
using namespace std;
int mp[1005][1005];
int maxx=9999999;
int main()
{
int n,m;
cin>>n>>m;
//对mp进行初始化
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
mp[i][j]=maxx;
}
for(int i=1;i<=m;i++)
{
int t1,t2,t3;
cin>>t1>>t2>>t3;
mp[t1][t2]=min(t3,mp[t1][t2]);//构造图
}
for(int k=1;k<=n;k++)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(mp[i][j]>mp[i][k]+mp[k][j])
mp[i][j]=mp[i][k]+mp[k][j];//不断更新最短路径图
}
}
}
int sum=0;
for(int i=2;i<=n;i++)
sum=sum+mp[1][i]+mp[i][1];//求出来回时间的总和
cout<<sum;
return 0;
}