GrayCode虾扯蛋

想到了GrayCode的应用方法。嗯，我们，

举个栗子：吏部尚书之子何文新失手砸死了文远伯之子邱泽，吏部尚书何敬中求太子出手相助，太子手下的季师爷指出可以先承认罪责，让高升可以办事。待案子移交到刑部二审时，便可以由刑部尚书齐敏官官相护。

真棒！！！那么我们有：吏部（L），文远伯（W），太子（T），京兆府尹（J），刑部（X）。

我们还有以下关系：{敌对 E| 吏部，文远伯-杀子之仇}，{官官相护 P | 太子，吏部-太子的吏部；文远伯，刑部-文远伯求誉王的刑部； 京兆府尹，太子-京兆府尹不想得罪太子； 京兆府尹，文远伯-京兆府尹也不想得罪文远伯（高升，哈哈笑死我了）}

我们将关系E,P和部门L,W,T,J,X合并到一起做如下处理：

吏部（L），文远伯（W），太子（T），京兆府尹（J），刑部（X） |  杀子之仇（E），官官相护（P）

L   W   T    J    X  |  E    P

1    1    0    0    0  |  1    0      {L,W,E}        吏部和文远伯 搞事情

1    0    1    0    0  |  0    1      {L,T,P}          太子、京兆府尹官官相护

1    0    1    1    0  |  0    1      {L,T,J,P}       太子、吏部、京兆府尹官官相护

也就是说构造了以下element：{L,W,T,J,X,E,P}将部门、部门之间的管理关系写入一个集合u。这里用到了GrayCode可以表示一个集合的所有子集的特性。使用element={L,W,T,J,X 部门集合}+{E,P 部门关系集合} 共同构造全集。针对部门之间潜在的的交叉管理、协同工作的需求，使用二进制的GrayCode处理复杂的部门交叉管理业务。比如使用1010001表示太子、京兆府尹官官相护。我们可以使用GrayCode建立一个大梁关系网。

额，这个管GrayCode什么事情，用普通的二进制也是一样的啊。额，好像也GrayCode没有什么事情，这个事情和苏兄无关。只不过博主是看到GrayCode后联想的到。主意是苏兄出的，和我没关系。GrayCode：there is exactly one change! 所以，邱泽之死，是GrayCode的锅。

GrayCode?我去别个家博客CopyCopy哦：（感谢博主：**找不着了）

十进制数	二进制数	格雷码
0	0000	0000
1	0001	0001
2	0010	0011
3	0011	0010
4	0100	0110
5	0101	0111
6	0110	0101
7	0111	0100
8	1000	1100
9	1001	1101
10	1010	1111
11	1011	1110
12	1100	1010
13	1101	1011
14	1110	1001
15	1111	1000

那么GrayCode的构造过程，我只写一点哦，博主要去吃饭了：

0     ∅ 1     {x}

0     |     0     ∅ 1     |     0     {x} --------------------- 1     |     1     {x, y} 0     |     1     {y}

0      0     |     0     ∅ 1      0     |     0     {x} 1      1     |     0     {x,y} 0      1     |     0     {y} -------------------------------- 0      0     |     1     {z} 1      0     |     1     {x,z} 1      1     |     1     {x,y,z} 0      1     |     1     {y,z}

额，java实现方法，我去别人的博客上找找：（感谢博主：https://blog.csdn.net/tanga842428/article/details/52153551）

public class N_gray {


	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		String s = sc.nextLine();
		int i = Integer.parseInt(s);
		StringBuffer[] sb = n_gray(i);
		for(int j=0;j<sb.length;j++){
			if(j>0){
				System.out.print(",");
			}
			System.out.print(sb[j]);
		}

	}

	public static StringBuffer[] n_gray(int n){
		int length = (int)Math.pow(2, n);	//根据n的值计算格雷码的个数
		StringBuffer[] sbArray = new StringBuffer[length];
		if(n==1){
			sbArray[0] = new StringBuffer("0");
			sbArray[1] = new StringBuffer("1");
		}else{
			StringBuffer[] temp = n_gray(n-1);<span style="white-space:pre">	</span>//递归调用n-1时的格雷码
			for(int i=0;i<length;i++){
				if(i<length/2){
					sbArray[i] = new StringBuffer(temp[i]);
					sbArray[i].insert(0, "0");//StringBuffer[]中前半部分的格雷码最高位插入0
				}else{
					sbArray[i] = new StringBuffer(temp[length-i-1]);
					sbArray[i].insert(0, "1");//StringBuffer[]中后半部分的格雷码最高位插入1
				}
			}
		}

		return sbArray;
	}



}

 Java 集合的交并补（感谢博主：https://blog.csdn.net/mlweixiao/article/details/40657353）

package Set;
 
import java.util.HashSet;
import java.util.Set;
 
public class Sets {
	public  static <T> Set<T> intersection(Set<T> s1, Set<T> s2) {
		Set<T> result = new HashSet<T>(s1);
		result.retainAll(s2);
		return result;
	}
 
	public  static <T> Set<T> union(Set<T> s1, Set<T> s2) {
		Set<T> result = new HashSet<T>(s1);
		result.addAll(s2);
		return result;
	}
	
	//Subtract subset from superset
	public  static <T> Set<T> difference (Set<T> superset, Set<T> subset) {
		Set<T> result = new HashSet<T>(superset);
		result.addAll(subset);
		return result;
	}
	
	//Reflexive --everything not in their intersection
	public static <T> Set<T> complement(Set<T>s1,Set<T> s2){
		return difference(union(s1,s2),intersection(s1,s2));
	}
}

说点什么结尾呢，本博主懒得很，只作可行性说明，如果实现上有什么问题，概不负责。**我的饭饭！！