风险度量

最新推荐文章于 2020-10-18 12:53:22 发布

SUNbrightness

最新推荐文章于 2020-10-18 12:53:22 发布

阅读量277

点赞数

CC 4.0 BY-SA版权

分类专栏：蓝桥杯

本文链接：https://blog.youkuaiyun.com/SUNbrightness/article/details/80305349

蓝桥杯专栏收录该内容

53 篇文章

订阅专栏

标题：风险度量

X星系的的防卫体系包含 n 个空间站。这 n 个空间站间有 m 条通信链路，构成通信网。
两个空间站间可能直接通信，也可能通过其它空间站中转。

对于两个站点x和y (x != y), 如果能找到一个站点z，使得：
当z被破坏后，x和y不连通，则称z为关于x,y的关键站点。

显然，对于给定的两个站点，关于它们的关键点的个数越多，通信风险越大。

你的任务是：已经网络结构，求两站点之间的通信风险度，即：它们之间的关键点的个数。

输入数据第一行包含2个整数n(2 <= n <= 1000), m(0 <= m <= 2000),分别代表站点数，链路数。
空间站的编号从1到n。通信链路用其两端的站点编号表示。
接下来m行，每行两个整数 u,v (1 <= u, v <= n; u != v)代表一条链路。
最后1行，两个数u,v，代表被询问通信风险度的两个站点。

输出：一个整数，如果询问的两点不连通则输出-1.

例如：
用户输入：
7 6
1 3
2 3
3 4
3 5
4 5
5 6
1 6
则程序应该输出：
2

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 2000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
java选手注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
java选手注意：主类的名字必须是：Main，否则按无效代码处理。

c/c++选手注意: main函数需要返回0
c/c++选手注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
c/c++选手注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>，不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

思路:

第一想到的是，这道题是求，无向图的两点间最短距离。

第一种解决方式：

使用dfs暴力测试的方式去求该点到最后点的最短路径。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class Test {

    public static void main(String[] args){ 
    	Scanner input = new Scanner(System.in);
		//n个顶点 m条连通数据
    	int n = input.nextInt();
    	int m = input.nextInt();
    	
    	//使用map存储图的结构
    	// Map : key(顶点) value(该顶点可以到达的顶点)
    	Map<Integer,List<Integer>> map = new HashMap<Integer,List<Integer>>();
    	
    	for(int i=0;i<m;i++){
    		int left = input.nextInt();
    		int right = input.nextInt();
    		
    		if(!map.containsKey(left)){
    			map.put(left, new ArrayList<Integer>());
    		}
    		
    		if(!map.containsKey(right)){
    			map.put(right, new ArrayList<Integer>());
    		}
    		
    		//A可以连通B
    		//B也可以连通A
    		map.get(left).add(right);
    		map.get(right).add(left);
    	}
    	
    	//开始的点
    	int begin = input.nextInt();
    	//结束的点
    	int end = input.nextInt();
    	//使用set集合防止回路
    	HashSet<Integer> set = new HashSet<Integer>();

    	int min = dfs(map,begin,end,set);
    	
    	System.out.println(min-1);
    	
    }  
    
    
    
    //begin 开始的点  end 结束的点   set防止回路
    public static int dfs(Map<Integer,List<Integer>> map,int begin,int end,Set<Integer> set){
    	//找到结束位置
    	if ( begin==end )return 0;
    	//出现顶点冲突，返回无效值，该试探结束
    	if(set.contains(begin))return Integer.MAX_VALUE-100;
    	
    	//代表我已经踏上了这个顶点，不可以再次踏上
    	set.add(begin);
    	
    	//min 测试该顶点走向最后，那条路最短，
    	int min = Integer.MAX_VALUE-100;
    	
    	//得到所有的一级子顶点
    	List<Integer> list = map.get(begin);
    	
    	for(int i=0;i<list.size();i++){
    		//如果该节不是向回走，就进行dfs
    		if(!set.contains(list.get(i))){
    			//得到走该顶点的路径
    			int res =  dfs(map,list.get(i),end,set);
    			
    			//判断得到最短的路径
    			min = Math.min(min,res+1);
    		}
    	}
    	
    	
    	
    	//已经测试完，该顶点可以到达的所有顶点，回溯下，撤销该定点的不可回路状态
    	set.remove(begin);
    	
    	return min;
    }
}

然而测试用例大部分都过不了。

再次读题。发现这道题并不是求最短路径的。

题目是当破坏某个点后 A 和 B 不连通，这个点才是关键点。

如果是这种结构的话， A:3 B:2 他的关键路径肯定是 4 1 3

换一种结构

关键点就是，只要少了他，A和B 就不能连通了。

重新编程。暴力测试，测试每一个点是不是关键点。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class Test {

    public static void main(String[] args){ 
    	Scanner input = new Scanner(System.in);
		//n个顶点 m条连通数据
    	int n = input.nextInt();
    	int m = input.nextInt();
    	
    	//map 结构在遍历的时候添加和删除元素不方便
    	//换结构
//    	Map<Integer,List<Integer>> map = new HashMap<Integer,List<Integer>>();
    	
    	//数组，下标代表各个节点。
    	List[] map = new List[n+1];
    	for(int i=0;i<n+1;i++){
    		map[i] = new ArrayList();
    	}
    	
    	for(int i=0;i<m;i++){
    		int left = input.nextInt();
    		int right = input.nextInt();
    		//A可以连通B
    		//B也可以连通A
    		map[left].add(right);
    		map[right].add(left);
    	}
    	
    	//开始的点
    	int begin = input.nextInt();
    	//结束的点
    	int end = input.nextInt();
    	

    	//关键点个数
    	int count = 0;
    	//测试除了开始点和结束点，中某一点是不是关键点
    	for(int i=1;i<n+1;i++){
    		List<Integer> list = map[i];
    		//如果为空说明该点没有直接子节点
    		if(list.isEmpty()||list.size()==0||i==begin||i==end)continue;
    		//添加一个空的list 代表该 点已经删除 已经走不通了
    		map[i] = new ArrayList();
    		//使用set集合防止回路
        	HashSet<Integer> set = new HashSet<Integer>();
    		boolean pan = dfs(map,begin,end,set);
    		if(!pan)count++;
    		//测试完毕，将这个点填会原来的数据
    		map[i] = list;
    		
    	}
    	
    	System.out.println(count);
    	
    }  
    
    //看看是否连通
    public static boolean dfs(List[] map,int begin,int end,Set<Integer> set){
    	if(begin==end)return true;
    	
    	set.add(begin);
    	
    	List<Integer> list = map[begin];
    	//这个点已经被删除了,所有直接子节点为空
    	if(list.isEmpty()||list.size()==0)return false;
    	
    	
    	for(int i=0;i<list.size();i++){
    		//没有向回走
    		if(!set.contains(list.get(i))){
    			//如果走到了终点就说明连通了
    			if(dfs(map,list.get(i),end,set)){
    				return true;
    			}
    			
    		}
    		
    	}
    	
    	//回溯
    	set.remove(begin);
    	
    	return false;
    }
    
    
    
}