更新一下七段码的题，获取子集，判断图是否连通

上一篇的七段码纯属是无脑，写的是啥也不是

package graph;

import java.util.ArrayList;

/**
 * 	蓝桥杯七段码
 * @author 楠
 *
 */
public class graphDemo02 {
	
	public static void main(String[] args) {
		creatGrapg();
		getSubsetImpro();
		System.out.println(arrayListImpro.size());
		check();

		
		ArrayList<Integer> list=new ArrayList<>();
		list.add(6);
		list.add(2);
		list.add(1);
		list.add(0);
		isConnBfs(list);
		
		System.out.println(isConnBfs(list));
		
		
	}
	
	/**
	 * 	解题思路：
	 * 		获取顶点的子集
	 * 		判断子集是否构成通路
	 * 	约定：
	 * 		将边抽象成了点
	 * 		给点进行了编号
	 */
	static int[][] edges;//邻接矩阵
	static ArrayList<ArrayList<Integer>> arrayList;//子集的集合
	static ArrayList<ArrayList<Integer>> arrayListImpro;//子集的集合提升版
	
	/**
	 * 	对所有子集进行判断
	 * 	获取七段码的答案
	 */
	public static void check() {
		int count=0;
		for(int i=0;i<arrayListImpro.size();i++) {
			ArrayList<Integer> list = arrayListImpro.get(i);
				if(isConnBfs(list))
					count++;
		}
		System.out.println(count);
	}
	
	
	
	
	/**
	 * 	功能：
	 * 		判断一个子集是否连通
	 * 	思路：
	 * 		广度优先遍历
	 * @param list
	 * @return
	 */
	public static boolean isConnBfs(ArrayList<Integer> list) {
		Integer[] arr = new Integer[list.size()];
		list.toArray(arr);
		boolean[] isVisited =new boolean[arr.length];
		isVisited[0]=true;
		ArrayList<Integer> temp=new ArrayList<>();
		temp.add(arr[0]);
		while (temp.size() != 0) {
			Integer remove = temp.remove(0);
			for (int i = 0; i < arr.length; i++) {
				if (!isVisited[i] && edges[arr[i]][remove] > 0) {
					isVisited[i] = true;
					temp.add(arr[i]);
				}
			}
		}
		
		
		for(int i=0;i<isVisited.length;i++) {
			if(!isVisited[i]) 
				return false;
		}
		return true;
		
	}
	
	
	
	
	/**
	 * 	功能：
	 * 		判断一个子集是否连通
	 * 	思路：
	 * 		深度优先遍历
	 * @param list
	 * @return
	 */
	public static boolean isConnDfs(ArrayList<Integer> list) {
		Integer[] arr = new Integer[list.size()];
		list.toArray(arr);
		boolean[] isVisited=new boolean[arr.length];
		dfs(arr, 0, isVisited);
		for(int i=0;i<isVisited.length;i++) {
			if(!isVisited[i]) 
				return false;
		}
		return true;
	}
	public static void dfs(Integer[] arr,int i,boolean[] isVisited) {
		
		isVisited[i]=true;
		for(int j=0;j<arr.length;j++) {
			if(!isVisited[j]&&edges[arr[i]][arr[j]]>0) {
				dfs(arr, j, isVisited);
			}
		}
		
	}
	
	
	
	//方法二：	获取子集的方法，自底向上（这个方法是比方法一优秀的）
	/**
	 *	 获取子集：
	 *	思路：
	 *		假设当前大集合只有一个元素，那么子集就是子集
	 *		当大集合中新来了一个元素时，那么子集就是原来的子集的基础上加入一个新元素和新来的这个元素
	 *		
	 */
	public static  void getSubsetImpro() {
		arrayListImpro =new ArrayList<ArrayList<Integer>>();
		int[] arr= {0,1,2,3,4,5,6};//抽象的七段码的边
		ArrayList<Integer> list=new ArrayList<Integer>();
		list.add(arr[arr.length-1]);
		arrayListImpro.add(list);
		for(int i=arr.length-2;i>=0;i--) {
			int size=arrayListImpro.size();
			for(int j=0;j<size;j++) {
				ArrayList<Integer> temp=new ArrayList<Integer>();
				temp=(ArrayList<Integer>)arrayListImpro.get(j).clone();//注意这里要使clone的方法，因为=是引用赋值
				temp.add(arr[i]);
				arrayListImpro.add(temp);
			}
			ArrayList<Integer> temp=new ArrayList<Integer>();
			temp.add(arr[i]);
			arrayListImpro.add(temp);
			
		}
		
		return;
	}
	
	
	//方法一：获取子集的方法，这个方法用到了递归和回溯，但是通过分析可以看出来，这个是一个自定向下的分析，
	//当i=0时，遍历结束后，就已经找到了大集合所有的元素，所以这个方法可以改进
	/**
	 * 
	 * 	获取子集
	 * 	思路：
	 * 		每一遍历获取的内容是
	 * 		以arr[i]为第一个元素，长度的j的子集
	 * 		i和j分别表示子集的第一个元素的角标，子集元素的个数
	 * 		
	 * 	约定：
	 * 		从七段码给的题义来说
	 * 		大集合中的元素是不重复的
	 * 		子集是不包括空集的
	 * @return
	 */
	public static void getSubset() {
		arrayList =new ArrayList<ArrayList<Integer>>();
		int[] arr= {0,1,2,3,4,5,6};//抽象的七段码的边
		boolean[] isVisited=new boolean[arr.length];
		for(int i=0;i<arr.length;i++) {
			for(int j=1;j<=arr.length-i;j++) {
				getSubset(arr, i, j, isVisited);
			}
		}
		return ;
		
	}
	
	/**
	 * 	功能：
	 * 		寻找以arr[i]为第一个元素，长度的j的子集
	 * @param arr
	 * @param i
	 * @param j
	 * @param isVisited
	 */
	public static void getSubset(int[] arr,int i,int j,boolean[] isVisited) {
		if(j==1) {
			ArrayList<Integer> list=new ArrayList<Integer>();
			for(int m=0;m<isVisited.length;m++) {
				if(isVisited[m]) {
					list.add(arr[m]);
				}
			}
			list.add(arr[i]);
			arrayList.add(list);
		}
		isVisited[i]=true;
		for(int m=i+1;m<arr.length;m++) {
			getSubset(arr, m, j-1, isVisited);
		}
		isVisited[i]=false;
		
	}
	
	
	
	
	/*
	将七段码的边抽象成图中点 
	  			0
	  		5		1
	  			6
	  		4		2
	  			3
	  		*/
	/**
	 * 	创建图的邻接矩阵
	 * 	约定
	 * 		可以访问为1
	 * 		不可以访问为0
	 * @return
	 */
	public static int[][] creatGrapg() {
		edges= new int[7][7];
		edges[0][1] = 1;
		edges[1][0] = 1;
		edges[0][5] = 1;
		edges[5][0] = 1;
		edges[5][6] = 1;
		edges[6][5] = 1;
		edges[1][6] = 1;
		edges[6][1] = 1;
		edges[4][6] = 1;
		edges[6][4] = 1;
		edges[2][6] = 1;
		edges[6][2] = 1;
		edges[5][4] = 1;
		edges[4][5] = 1;
		edges[1][2] = 1;
		edges[2][1] = 1;
		edges[3][4] = 1;
		edges[4][3] = 1;
		edges[2][3] = 1;
		edges[3][2] = 1;
		return edges;
	}
}