小妈妈找蝌蚪

题目描述

        青蛙妈妈最近很不放心把蝌蚪宝宝送到幼儿园，但当她买菜回家时，却发现可爱的孩子小蝌蚪走丢了。
        小池塘里有很多石头，青蛙家在其中标号为s的石头上。小蝌蚪会移动k分钟，每分钟会出现在任意石头旁边，甚至多次出现在一块石头旁边。但k分钟之后，蝌蚪宝宝就游不动了。
        青蛙妈妈第0秒从家所在的石头出发，每分钟移动一次，可以留在原地，也可以跳跃到一块当前可跳跃到的石头上(只能在特定的石头间双向跳跃)。

输入描述:

多组数据。

第一行输入石头个数n，青蛙妈妈可以跳跃的石头对数m，蝌蚪宝宝的活动时间k，青蛙家所在的石头s。

之后输入k个数，其中第i个数代表第i分钟蝌蚪宝宝的位置，编号从i=1开始。
接下来输入m行，每行包括两个数ui，vi，表示青蛙妈妈可以在第ui个和vi个石头间双向跳跃。

输出描述:

请输出青蛙妈妈最少几分钟发现蝌蚪宝宝。

输入

3 2 2 1
2 1
1 2
1 3
5 5 3 5
3 1 4
1 2
2 3
2 4
3 4
4 5

输出

1
3

备注:

1≤n≤100000,
1≤m≤2∗n,
1≤k≤100000,
1≤s≤n,
1≤u,v≤n,
无重边，无自环，保证联通,
数据不多于

#include<iostream>
#include<algorithm>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
const int N=1e6+10;
int dist[N];
bool st[N];
vector<int>v[N];
int a[N];
int n,m,k,s;
void bfs()
{
    memset(st,0,sizeof st);
    memset(dist,0x3f,sizeof dist);
    queue<int>q;
    q.push(s);
    st[s]=1;
    dist[s]=0;
    while(q.size())
    {
        int t=q.front();
        q.pop();
        for(int i=0;i<v[t].size();i++)
        {
            int x=v[t][i];
            if(st[x]) continue;
            st[x]=1;
            dist[x]=dist[t]+1;
            q.push(x);
        }
    }
}
int main()
{
    while(cin>>n>>m>>k>>s)
    {
        for(int i=1;i<=n;i++) v[i].clear();
        for(int i=1;i<=k;i++)
        {
            cin>>a[i];
        }
        for(int i=1;i<=m;i++)
        {
            int a,b;cin>>a>>b;
            v[a].push_back(b);
            v[b].push_back(a);
        }
        bfs();
        int num=0;
        for(int i=1;i<=k;i++)
        {
            if(dist[a[i]]<=i) 
            {
                num=i;
                break;
            }
        }
        if(num!=0) cout<<num<<endl;
        else cout<<dist[a[k]]<<endl;
    }
    return 0;
}

//宽度搜索没别的  就是要注意一层层的搜索时如何处理一些之前可能处理过的点  和 更新一些点       
#include <bitsdc++.h>
#define int long long  
using namespace std ;
const int N = 1e5+10 ;
vector<int>g[N],w[N] ;
struct Node
{
    int num,dist ;
    //优先按照层数进行排序 层数小的优先 如果层数相同优先距离处理 
    bool operator<(Node b)const
    {
        if(num!=b.num)
        return num < b.num ;
        else
        return dist<b.dist ;
    }
 }dis[N] ; //重载了结构体之间比较的  <  
int n , m ;
signed main()
{
    ios::sync_with_stdio(false) ;
    cin.tie(nullptr) ;
    cin >> n >> m;
    for(int i = 1 ; i <= m ; i++)
    {
        int x ,y ,c;
        cin >> x >> y >>c ;
        g[x].push_back(y) ;
        g[y].push_back(x) ;
        w[x].push_back(c) ;
        w[y].push_back(c) ;
     }
     queue<int> q ;//负责处理每层该处理的点 
     q.push(1) ;
     for(int i = 2 ; i <= n ; i++)
     dis[i].num = 0x3f3f3f3f ;
     dis[1] = {1,0} ;
     bool flag = false ;
     while(q.size())
     {
        int u = q.front() ;
        q.pop() ;
        //非常妙 
        for(int i = 0 ; i < g[u].size() ; i++)
        {
            int v = g[u][i],c=w[u][i] ; 
             Node ne = {dis[u].num+1,dis[u].dist+c} ;//这个暂时 记录下一层的点 的层数和到1号点的距离 
             if(ne < dis[v]) //这里的小于号是结构体重新重载后的小于号 保证之前层当中的点不会被更新并且下一层的点最后存储的是该点到1号点的最近距离 
             {
                dis[v] = ne ;//更新 v 点
                if(v == n)
                flag == 1 ;
                if(!flag) 
                q.push(v) ;
             }
         }
      }
      cout << dis[n].num << " " << dis[n].dist << endl ; 
    return  0 ;
 }