public static <E, C extends Collection<E>> Stream<C> combStreamGreedy(Collection<E> coll,
			Function<Collection<E>, C> combCollFactory, BiPredicate<E, E> condition, int limit) {
		if (coll.isEmpty())
			return Stream.of(combCollFactory.apply(Collections.emptyList()));

		List<E> list = (coll instanceof List) ? (List<E>) coll : new ArrayList<>(coll);

		// 按顺序遍历全部元素，生成冲突元素map和检查点map
		Map<E, Set<E>> conflictsMap = new HashMap<>();
		Map<E, List<E>> checkPoints = new HashMap<>();
		IntStream.range(0, list.size()).forEach(index -> {
			E crtElement = list.get(index);
			// 在右边的元素中找出与之冲突的元素
			List<E> rightConflicts = list.subList(index + 1, list.size()).stream()
					.filter(e -> !condition.test(crtElement, e)).collect(Collectors.toList());

			// 在 当前元素的冲突元素 集合中加入找到的元素
			if (!rightConflicts.isEmpty()) {
				Set<E> conflicts = conflictsMap.get(crtElement);
				if (conflicts == null)
					conflictsMap.put(crtElement, conflicts = new HashSet<>());
				conflicts.addAll(rightConflicts);
			}
			// 在 找到的元素的冲突元素 集合中分别加入当前元素
			rightConflicts.forEach(conflict -> {
				Set<E> conflicts1 = conflictsMap.get(conflict);
				if (conflicts1 == null)
					conflictsMap.put(conflict, conflicts1 = new HashSet<>());
				conflicts1.add(crtElement);
			});

			// 如果找到了冲突元素，则最后一个冲突元素是当前元素的检查点
			if (!rightConflicts.isEmpty()) {
				E checkPoint = rightConflicts.get(rightConflicts.size() - 1);
				List<E> checked = checkPoints.get(checkPoint);
				if (checked == null)
					checkPoints.put(checkPoint, checked = new ArrayList<>());
				checked.add(crtElement);
			}
		});

		// XXX - 带limit的逻辑要优化

		// 进入递归方法，得出没有组合内元素个数限制的流
		Stream<C> lessGreedyStream = combStreamGreedy0(list, limit - 1, combCollFactory, new HashSet<>(), conflictsMap,
				checkPoints);

		if (limit >= coll.size())
			return lessGreedyStream;

		Stream<C> limitStream = combStream(coll, limit, combCollFactory, null, condition);
		return Stream.concat(lessGreedyStream, limitStream);
	}