7-35 城市间紧急救援 (25 分)(思路加详解)

总结

上述知识点，囊括了目前互联网企业的主流应用技术以及能让你成为“香饽饽”的高级架构知识，每个笔记里面几乎都带有实战内容。

很多人担心学了容易忘，这里教你一个方法，那就是重复学习。

打个比方，假如你正在学习 spring 注解，突然发现了一个注解@Aspect，不知道干什么用的，你可能会去查看源码或者通过博客学习，花了半小时终于弄懂了，下次又看到@Aspect 了，你有点郁闷了，上次好像在哪哪哪学习，你快速打开网页花了五分钟又学会了。

从半小时和五分钟的对比中可以发现多学一次就离真正掌握知识又近了一步。

人的本性就是容易遗忘，只有不断加深印象、重复学习才能真正掌握，所以很多书我都是推荐大家多看几遍。哪有那么多天才，他只是比你多看了几遍书。

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

}

printf(“\n”);

}

}

void putlu(int u,int v)

{

//通过v结点的上一结点查找到u结点，将路径存到栈s中，最后输出。

int s[60],k,i,l;

k=0;

l=path[v];//将3对应的上一个点1 入栈了 然而3并没有进数组

while(l!=u)//入栈

{

s[k++]=l;

l=path[l];

}

printf("%d ",u);

for(i=k-1;i>=0;i–)

printf("%d ",s[i]);

printf(“%d”,v);//3没有进数组

}

void Dijkstra(PtrGNode G){

int dist[1000];//存路径长度

int cist[1000];//记录人数 一直在变

int rist[1000];//存人数 到达每个顶点的人数不变

int vis[1000]={0};//记录已经遍历的点

int count[1000]; //记录最短路径条数

int i,j;//因为从begin开始的点 也有人数

if(G->Nv==2){//最短路径只有两个顶点

cist[end]=a[0]+a[1];

count[end]=1;

path[1]=0;

}

else

{

for(i=0;iNv;i++){

count[i]=1;

dist[i] = G->GData[begin][i];

if(i != begin)

cist[i] = a[begin]+a[i];

else

cist[i] = a[i];

}

vis[0]=1;

while (1)

{

int mv=-1;

int min=infinite;

for(i=0; iNv; i++){

if(vis[i] != 1 && dist[i] < min){

min=dist[i];

mv=i;

}

}

if(mv==-1)

break;

vis[mv]=1;

for(j=0;jNv;j++){

if(vis[j]!=1 && min+G->GData[mv][j]<dist[j]){

dist[j] = min+G->GData[mv][j];

cist[j] = cist[mv]+a[j];//根据路径长度已经判断 比原来路径短 而其人数必定时增加的

// rist[j]=rist[mv]+a[j];

count[j] = count[mv];

path[j] = mv;

}

else if(vis[j]!=1 && min+G->GData[mv][j] == dist[j]){//处理相同路径长度时 选择人数多的

count[j] += count[mv];

if((cist[mv]+a[j])>cist[j]){

cist[j] = cist[mv]+a[j];

// rist[j]=rist[mv]+a[j]; //更新 已经找到最短路径的那一个顶点 已经确认的到达这个顶点的总人数

path[j] = mv;

}

}

}

}

}

printf(“%d %d”,count[end],cist[end]);

printf(“\n”);

putlu(begin,end);

}

int main(){

PtrGNode G;

G=(PtrGNode)malloc(sizeof(struct GNode));

CreatGNode(G);

Dijkstra(G);

//outprint(G);

}

//2 1 0 1

//20 30

//0 1 2

//6 9 0 3

//10 20 30 40 50 60

//0 1 1

//0 2 3

//0 3 6

//0 4 3

//0 5 2

//1 2 2

//2 3 3

//3 4 3

//4 5 1

四：上超时的码（这是我二刷是做的，上面是第一次做的）

=========================================================================================

但这个超时间。我优化了但还是过去

/**

思路：

这个就是单源点最短路径的变形，这里是出现了到达某个顶点出现相同的最短距离，

只不过是经过的点不一样，每个点给了相应的赋值，我们需要判断每一条路径上经过的

点，他们的值相加（每个点赋值），比较最大的那个就是救援队人数最多的，

选取他们作为救援最优路径

*/

#include<bits/stdc++.h>

using namespace std;

#define infinite 9999

typedef struct GNode* PtrGraph;

typedef struct GNode{

int Nv;

int Ne;

int Date[501][501];

}gnode;

int N,M,S,D;

map<int,int>m;//用map容器进行储存每个结点的救援队数量

int path[501] = { S };//将路径的初始值设为开始的那个点

//邻接矩阵储存图

void createGraph(PtrGraph G){

cin >> N >> M >> S >> D;

G->Nv = N;

G->Ne = M;

for( int i = 0; i < N; i++ ){

int temp;

cin >> temp;

m[i] = temp;

}

//矩阵初始化

for( int i = 0; i < G->Nv; i++ ){

for( int j = 0; j < G->Nv; j++ ){

if( i == j )

G->Date[i][j] = 0;

else

G->Date[i][j] = infinite;

}

}

//矩阵赋值

for( int i = 0; i < G->Ne; i++ ){

int a,b,c;

cin >> a >> b >> c;

G->Date[a][b] = c;

G->Date[b][a] = c;

}

}

//输出矩阵

void outPutGNode(PtrGraph G){

int i,j;

for(i=0; iNv; i++){

for(j=0;jNv;j++){

if(G->Date[i][j] == infinite||G->Date[j][i] == infinite)

printf(“∞”);

else

cout << G->Date[i][j] << ’ ';

}

printf(“\n”);

}

}

//求路径上救援队数量

int PathSum( int x ){

int sum = m[x];

while( path[x] != x ){

x = path[x];

sum+=m[x];

}

return sum;

}

//求路径

void PathWay(int x){

stacks;

s.push(x);

while(path[x] != x ){

x = path[x];

s.push(x);

}

while( !s.empty() ){

if( s.size() != 1 )

cout << s.top() << ’ ';

else

cout << s.top();

s.pop();

}

}

//单源点最短路径

void dij(PtrGraph G){

int dist[501] = {0};

int visited[501] = {0};

int vis[501] = {0};

// int path[501] = { S };//将路径的初始值设为开始的那个点

int count[501];//记录路数

for( int i = 0; i < G->Nv; i++ ){

count[i] = 1;//初始化为1，即开始点到每个点的路数为1条

dist[i] = G->Date[S][i];//将开始的那一行赋值给dist

}

visited[S] = 1;

vis[S] = 1;

while(1){

int m = -1;

int min = infinite;

//求取最小值

for(int i = 0; i < G->Nv; i++ ){

if( dist[i] < min && visited[i] != 1){

min = dist[i];

m = i;

}

}

//说明没找到最小值 即代表访问完了，即便图是不连通的 那也求不出最小值了

if( m == -1 ){

break;

}

visited[m] = 1;

//更新

for( int i = 0; i < G->Nv; i++ ){

if( visited[i] != 1 && dist[m] + G->Date[m][i] < dist[i] ){

dist[i] = dist[m] = G->Date[m][i];

path[i] = m;

count[i] = count[m];//如果从开始的点S到 m 有两条路，那么在更新最短路径时

//需要经过m的话，那么m的路数将赋值给 更新的结点

}

}

}

//这个循环主要是处理相同的最短路径

while(1){

int m = -1;

int min = infinite;

//求取最小值

for(int i = 0; i < G->Nv; i++ ){

if( dist[i] < min && vis[i] != 1){

min = dist[i];

m = i;

}

}

//说明没找到最小值 即代表访问完了，即便图是不连通的 那也求不出最小值了

if( m == -1 ){

break;

}

vis[m] = 1;

//出现相同的路径

for( int i = 0; i < G->Nv; i++ ){

if( vis[i] != 1 && dist[m] + G->Date[m][i] == dist[i] ){

本次面试答案，以及收集到的大厂必问面试题分享：

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

while(1){

int m = -1;

int min = infinite;

//求取最小值

for(int i = 0; i < G->Nv; i++ ){

if( dist[i] < min && vis[i] != 1){

min = dist[i];

m = i;

}

}

//说明没找到最小值 即代表访问完了，即便图是不连通的 那也求不出最小值了

if( m == -1 ){

break;

}

vis[m] = 1;

//出现相同的路径

for( int i = 0; i < G->Nv; i++ ){

if( vis[i] != 1 && dist[m] + G->Date[m][i] == dist[i] ){

本次面试答案，以及收集到的大厂必问面试题分享：

[外链图片转存中…(img-a3aPmb3c-1715800401623)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取