@SuppressWarnings("unchecked")
	public static void computeKplex(HashMap<Integer, Integer> res,
			ArrayList<Pair> candidate, HashMap<Integer, Integer> not) {
		// 根据k-plex定义过滤备选集(最多不与k-1个节点相连)
		candidate = filterCandidate(res, candidate, not);
		// int rSize = res.size();
		// int canSizeN = candidate.size();
		// int sum = rSize + canSizeN;
		while (res.size() + candidate.size() >= quasiCliqueSize) {// && sum >=
																	// kPlexSize
			if (candidate.isEmpty()) {
				if (not.isEmpty()) {
					String r = res.keySet().toString();
					System.out.println(r.substring(1, r.length() - 1));
					cliquenum++;
				} else {
					dupnum++;
				}
				return;
			}
			if (judgeKplex2(res, candidate, critnodes))// 是kplex
			{
				if (duplicate(not, res, candidate, critnodes)) {
					dupnum++;
					return;
				}
				// 是clique输出
				String r = res.keySet().toString();
				String c = candidate.toString();
				System.out.println(r.toString().substring(1, r.length() - 1)
						+ ", " + c.substring(1, c.length() - 1));
				return;
			} else {
				Pair y = candidate.get(candidate.size() - 1);// 其他节点，存在策略
				// 子图包含y
				// res中多了y
				HashMap<Integer, Integer> resA = (HashMap<Integer, Integer>) res
						.clone();
				HashSet<Integer> adj = oneLeap.get(y.point);
				for (Entry<Integer, Integer> en : resA.entrySet()) {
					if (!adj.contains(en.getKey())) {
						en.setValue(en.getValue() + 1);
					}
				}
				resA.put(y.point, y.discon);
				// 分裂点y从候选点中删除后,需要更新候选集中点的度数值
				// 这一段正好可以找出度数最小的点
				// Iterator<Pair> iter = candidate.iterator();
				// while(iter.hasNext()){
				// Pair p = iter.next();
				for (Pair p : candidate) {
					if (!adj.contains(p.point)) {
						// //与y不相邻的候选点;y加到结果集中deg--,discon++
						// p.discon++;//y加到结果集后,这个点的disconn当加1
						// if(p.discon>k_plex-1)//超出这个度数不可能成为结果集中的点,直接删除
						// iter.remove();
						p.deg--;// y加到结果集后,这个点和当前candidate的不相邻点应减1
					}
				}
				ArrayList<Pair> canA = new ArrayList<Pair>();
				HashMap<Integer, Integer> notA = new HashMap<Integer, Integer>();
				getT2(canA, notA, y.point, candidate, not);
				levelNumber++;
				// 避免层数过多使得系统栈溢出，当levelNumber过大时(大于levelExtream)，将状态存栈
				// if (levelNumber >= levelExtream) {
				SubGraph sA = new SubGraph();
				sA.setCandidate(canA);
				sA.setResult(resA);
				sA.setNot(notA);
				stack.add(sA);

				candidate.remove(candidate.size() - 1);
				not.put(y.point, y.discon);
				// HashMap<Integer,Integer> resB = (HashMap<Integer, Integer>)
				// res.clone();
				// SubGraph sB = new SubGraph();
				// sB.setCandidate(candidate);

				// sB.setNot(not);
				// sB.setResult(resB);
				// stack.add(sB);
				// return;
				// }
				// // 子图包含y
				// computeKplex(resA, canA, notA);
				// levelNumber--;
				// // resA.remove(resA.size()-1);
				// candidate.remove(candidate.size() - 1);
				// not.put(y.point,y.discon);
				// // 子图不包含y
				// computeKplex(res, candidate, not);
				// levelNumber--;
				// // 维护状态栈层数在合理的大小
				// if (levelNumber <= -10)
				// levelNumber = 0;
			}
		}
	}