Java蓝桥杯复习，七段码，求集合的子集的个数，求集合的非空子集，并返回

蓝桥杯
七段码的问题描述

正确答案是80

第一个要讲的问题是求一个子集的个数

/**
 * 求一个集合（元素唯一）的子串的个数
 * 
 * @author 楠
 *
 */
public class Test02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		char[] arr = { 'a', 'b', 'c' };
		int dfs = dfs(arr);
		System.out.println(dfs);

	}

	/**
	 * 
	 * @param arr       集合
	 * @param isVisited 用于判断集合内元素是否被访问过
	 * @param i         从集合中哪个元素开始获取子集
	 * @param j         子集内元素的个数
	 * @return 返回从i元素为第一个元素的子集，子集元素为j个的集合的个数
	 * 		也可以发现对于集合来说有没有boolean[] isVisited这个数组是不影响结果的，但是对于图来说就是不一样的
	 */
	public static int dfs(char[] arr, boolean[] isVisited, int i, int j) {
		int count = 0;

		if (j == 1) {
			return 1;
		}
		isVisited[i] = true;
		for (int m = i + 1; m < arr.length; m++) {
			if (!isVisited[m]) {
				count = count + dfs(arr, isVisited, m, j - 1);
			}
		}
		isVisited[i] = false;

		return count;
	}
	
	/**
	 * 
	 * @param arr集合
	 * @return 返回集合非空子串的个数
	 */
	public static int dfs(char[] arr) {
		boolean[] isVisited = new boolean[arr.length];
		int count = 0;
		for (int i = 0; i < arr.length; i++) {
			for (int j = 1; j <= arr.length; j++) {
				count = count + dfs(arr, isVisited, i, j);
			}
		}
		return count;
	}

}

七段码
解题思路

1. 将边抽象成点，构造图
2. 对点进行编号
3. 获取点的组合
4. 对每一个组合进行判断，是否连通，连通就是一种情况
5. 返回和 的 值

import java.util.ArrayList;
import java.util.List;

public class Demo04 {

	public static void main(String[] args) {
		graph();
//		t();
		
		graph();
		int count = 0;
		int a1 = 0;
		int a2 = 0, a3 = 0, a4 = 0, a5 = 0, a6 = 0, a7 = 0;
		
		ArrayList<ArrayList<Integer>> subset = getSubset();
		System.out.println("子集的个数" + subset.size());
		while (subset.size() != 0) {
			ArrayList<Integer> remove = subset.remove(0);
			int size = remove.size();
			for (int n = 0; n < remove.size(); n++) {
				System.out.print(remove.get(n) + " ");
			}
			System.out.print("\t");
			if (isConnected(remove)) {
				System.out.println("连通");
				switch (size) {
				case 1:
					a1++;
					break;
				case 2:
					a2++;
					break;
				case 3:
					a3++;
					break;
				case 4:
					a4++;
					break;
				case 5:
					a5++;
					break;
				case 6:
					a6++;
					break;
				case 7:
					a7++;
					break;

				}
				count++;
			} else {
				System.out.println("no");
			}

		}
		System.out.println(count);
		System.out.println();
		System.out.println(a1);
		System.out.println(a2);
		System.out.println(a3);
		System.out.println(a4);
		System.out.println(a5);
		System.out.println(a6);
		System.out.println(a7);
		
		
		
		
	}

	public static ArrayList<ArrayList<Integer>> getSubset() {
		ArrayList<ArrayList<Integer>> list = 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; j++) {
				getSubset(arr, i, j, list, isVisited);
			}
		}
		return list;
	}

	/**
	 * 
	 * @param arr 集合
	 * @param i   以i为开始的子集
	 * @param j   子集元素的个数 return 将子集存储在list集合中
	 * 
	 */
	public static void getSubset(int[] arr, int i, int j, ArrayList<ArrayList<Integer>> list, boolean[] isVisited) {
		if (j == 1) {
			ArrayList<Integer> arrayList = new ArrayList<Integer>();
			for (int n = 0; n < isVisited.length; n++) {
				if (isVisited[n]) {
					arrayList.add(arr[n]);
				}
			}
			arrayList.add(arr[i]);
			list.add(arrayList);
		}
		isVisited[i] = true;
		for (int m = i + 1; m < arr.length; m++) {
			getSubset(arr, m, j - 1, list, isVisited);
		}
		isVisited[i] = false;

	}

	/**
	 * 
	 * @param list 给定图中的点的集合
	 * @return 返回list集合中的点是否连通
	 * 
	 */
	public static boolean isConnected(List<Integer> list) {
		if (list.size() == 1) {
			return true;
		}
		ArrayList<Integer> arrayList = new ArrayList<Integer>();
		arrayList.add(list.remove(0));
		
		for (int i = 0; i < arrayList.size();) {
			boolean point=false;
			for (int j = 0; j < list.size(); j++) {
				if (edgs[arrayList.get(i)][list.get(j)] > 0) {
					arrayList.add(list.remove(j));
					point=true;
					break;
				}			
			}
			if(point) {
				i=0;
			}else {
				i++;
			}
		}
		if (list.size() == 0) {
			return true;
		} else {
			return false;
		}
	}

	static int[][] edgs = null;// 图的邻接矩阵
	static boolean[] isVisited = null;// 用来表述图的点是否被访问
	static int n = 0;// 表示图有几个点

	/**
	 * 构建图 将七段码的边抽象成图中点 
	 * 			0
	 * 		5		1
	 * 			6
	 * 		4		2
	 * 			3
	 * 
	 */
	public static void graph() {// 构造图
		edgs = new int[7][7];
		isVisited = new boolean[edgs.length];
		n = 7;
		edgs[0][1] = 1;
		edgs[1][0] = 1;
		edgs[0][5] = 1;
		edgs[5][0] = 1;
		edgs[5][6] = 1;
		edgs[6][5] = 1;
		edgs[1][6] = 1;
		edgs[6][1] = 1;
		edgs[4][6] = 1;
		edgs[6][4] = 1;
		edgs[2][6] = 1;
		edgs[6][2] = 1;
		edgs[5][4] = 1;
		edgs[4][5] = 1;
		edgs[1][2] = 1;
		edgs[2][1] = 1;
		edgs[3][4] = 1;
		edgs[4][3] = 1;
		edgs[2][3] = 1;
		edgs[3][2] = 1;
	}
	
	public static void t() {
		ArrayList<Integer> list= new ArrayList<Integer>();
		list.add(0);
		list.add(1);
		list.add(5);
		boolean connected = isConnected(list);
		System.out.println(connected);
	}
}