import
java.io.*;
import
java.util.ArrayList;
import
java.util.Arrays;
import
java.util.Collections;
import
java.util.Comparator;
import
java.util.LinkedHashSet;
import
java.util.List;
import
java.util.Set;
public
class
GFG {
interface
Filter<T> {
boolean
matches(T t);
}
private
static
<T> Set<T>
shortcombo(Filter<Set<T> > filter, List<T> sets)
{
final
int
size = sets.size();
if
(size >
20
)
throw
new
IllegalArgumentException(
"Too many Combinations"
);
int
comb =
1
<< size;
List<Set<T> > possible =
new
ArrayList<Set<T> >();
for
(
int
i =
0
; i < comb; i++) {
Set<T> combination =
new
LinkedHashSet<T>();
for
(
int
j =
0
; j < size; j++) {
if
(((i >> j) &
1
) !=
0
)
combination.add(sets.get(j));
}
possible.add(combination);
}
Collections.sort(
possible,
new
Comparator<Set<T> >() {
public
int
compare(Set<T> a1, Set<T> a2)
{
return
a1.size() - a2.size();
}
});
for
(Set<T> possibleSol : possible) {
if
(filter.matches(possibleSol))
return
possibleSol;
}
return
null
;
}
public
static
void
main(String[] args)
{
Integer[][] all = {
{
1
,
2
}, {
3
,
4
}, {
8
,
9
},
{
10
,
7
}, {
5
,
8
}, {
11
,
6
},
{
4
,
5
}, {
6
,
7
}, {
10
,
11
},
};
Integer[] solution
= {
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
,
10
,
11
};
List<Set<Integer> > sets
=
new
ArrayList<Set<Integer> >();
for
(Integer[] array : all)
sets.add(
new
LinkedHashSet<Integer>(
Arrays.asList(array)));
final
Set<Integer> sol =
new
LinkedHashSet<Integer>(
Arrays.asList(solution));
Filter<Set<Set<Integer> > > filter
=
new
Filter<Set<Set<Integer> > >() {
public
boolean
matches(
Set<Set<Integer> > integers)
{
Set<Integer> union
=
new
LinkedHashSet<Integer>();
for
(Set<Integer> ints : integers)
union.addAll(ints);
return
union.equals(sol);
}
};
Set<Set<Integer> > firstSol
= shortcombo(filter, sets);
System.out.println(
"The short combination was : "
+ firstSol);
}
}