2022-6-18 真题练习

MT15 病毒传播  

描述

给出一个图 G(V,E) ，图上有 n 个点，m 条边，所有的边都是无向边。

最开始，也就是第 0 天的时候，这 n 个点中有一个点 v 感染了病毒，之后的每一天，凡是感染病毒的点都会向它的邻居点传播病毒。经过了 t 天之后，得到了感染病毒的点集 S 。要求找出第 0 天感染病毒的点 v 。如果 v 有很多不同的答案，把它们都找出来。   数据范围： 1 \le n,m \le 1000 \1≤n,m≤1000 ， 1 \le k \le n \1≤k≤n  ，1 \le t \le 10^9 \1≤t≤109 

输入描述：

第一行两个数n，m，接下来有m行，每行两个数u，v，表示点u，v之间有一条无向边。接下来一行两个数k，t，其中k表示集合S的大小。最后一行k个数，集合S中的元素。输入的图可能有自环和重边，输入保证S中的数互不相同。

输出描述：

输出一行，如果不存在这样的v，输出-1。
否则输出所有可能的v，按照从小到大的顺序输出，数字之间用空格隔开，不要在行末输出多余的空格。

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int[][] dist=new int[n][n];
        for (int i=0;i){
            Arrays.fill(dist[i],Integer.MAX_VALUE);
        }
        for (int i=0;i){
            int p=sc.nextInt();
            int q=sc.nextInt();
            // 自环
            if (p!=q){
                dist[p-1][q-1]=1;
                dist[q-1][p-1]=1;
            }
        }
        List> graph=buildgraph(dist);
        int k=sc.nextInt();
        int t=sc.nextInt();
        Set set=new HashSet<>();
        for (int i=0;i){
            int temp=sc.nextInt();
            set.add(temp);
        }
        // bfs计算记录
        List ans=new ArrayList<>();
        for (int i=0;i){
            //Set temp=BFS(graph,i,t);
            Set temp=Dijkstra(dist,graph,i,t);
            if (set.size()!=temp.size()) continue;
            boolean flag=true;
            for (int x:set){
                if (!temp.contains(x)){
                    flag=false;
                    break;
                }
            }
            if (flag) ans.add(i);
        }
        if (ans.size()==0){
            System.out.println(-1);
        }else{
            for (int i=0;i);
            System.out.println(ans.get(ans.size()-1)+1);
        }
    }


    public static List> buildgraph(int[][] dist){
        List> graph=new ArrayList<>();
        int n=dist.length;
        for (int i=0;i){
            graph.add(new ArrayList<>());
        }
        for (int i=0;i){
            for (int j=i+1;j){
                if (dist[i][j]==1){
                    graph.get(i).add(j);
                    graph.get(j).add(i);
                }
            }
        }
        return graph;
    }

    public static Set BFS(List> graph,int start,int time){
        Set res=new HashSet<>();
        Queue queue=new LinkedList<>();
        boolean[] visited=new boolean[graph.size()];
        int[] dist=new int[graph.size()];
        Arrays.fill(dist,Integer.MAX_VALUE);
        dist[start]=0;
        visited[start]=true;
        queue.offer(start);
        int dis=0;
        while (!queue.isEmpty()){
            int len=queue.size();
            for (int i=0;i){
                int node=queue.poll();
                dist[node]=dis;
                for (int x:graph.get(node)){
                    if (!visited[x]){
                        queue.offer(x);
                        visited[x]=true;
                    }
                }
            }
            dis++;

        }
        for (int i=0;i){
            if (dist[i]<=time){
                res.add(i+1);
            }
        }
        return res;
    }

    public static Set Dijkstra(int[][] dist,List> graph,int start,int time){
        // int[] node,dis
        PriorityQueue<int[]> queue=new PriorityQueue<>((a,b)->(a[1]-b[1]));
        Set res=new HashSet<>();
        queue.add(new int[]{start,0});
        int[] dis=new int[graph.size()];
        Arrays.fill(dis,Integer.MAX_VALUE);
        dis[start]=0;
        while (!queue.isEmpty()){
            int[] temp=queue.poll();
            int curNode=temp[0];
            int curdis=temp[1];
            if (dis[curNode]continue;
            for (int x:graph.get(curNode)){
                if (curdis+dist[curNode][x]<dis[x]){
                    dis[x]=curdis+dist[curNode][x];
                    queue.offer(new int[]{x,dis[x]});
                }
            }
        }
        for (int i=0;i){
            if (dis[i]<=time) res.add(i+1);
        }
        return res;
     }
}

思路：两种方法求不同节点到其他节点的距离。因为权重都是1可以用BFS的方法遍历，也可以用Dijkstra方法计算。再比较两个集合。