Code:

import java.util.ArrayList;
public class AoRAlgo30 {
static int[] S = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,
20,21,22,23,24,25,26,27,28,29};
static ArrayList<ArrayList<Integer>> C;
static boolean foundError = false;
@SuppressWarnings("unchecked")
public static void main(String[] args) {
/* ~~~~~~~ test 1 ~~~~~~~ */
System.out.println("Test 1: Do nothing inside the loop.");
long t = time();
int i, stop = 1 << 30;
for(i = 0; i < stop; i++)
;
System.out.println();
System.out.println("Elapsed: " + (time() - t) / 1000.0 + " s");
/* ~~~~~~~ test 2 ~~~~~~~ */
System.out.println();
System.out.println("Test 2: Implement AoR algo with 30 components.");
System.out.println();
t = time();
ArrayList<Integer> a0 = make(1,5,8);
ArrayList<Integer> a1 = make(3,6);
ArrayList<Integer> a2 = make();
ArrayList<Integer> a3 = make(3);
ArrayList<Integer> a4 = make();
ArrayList<Integer> a5 = make();
ArrayList<Integer> a6 = make();
ArrayList<Integer> a7 = make();
ArrayList<Integer> a8 = make(17);
ArrayList<Integer> a9 = make();
ArrayList<Integer> a10 = make(4);
ArrayList<Integer> a11 = make(22,23,24);
ArrayList<Integer> a12 = make();
ArrayList<Integer> a13 = make();
ArrayList<Integer> a14 = make();
ArrayList<Integer> a15 = make(4);
ArrayList<Integer> a16 = make();
ArrayList<Integer> a17 = make(20);
ArrayList<Integer> a18 = make();
ArrayList<Integer> a19 = make(5);
ArrayList<Integer> a20 = make(8);
ArrayList<Integer> a21 = make(29);
ArrayList<Integer> a22 = make();
ArrayList<Integer> a23 = make();
ArrayList<Integer> a24 = make(12);
ArrayList<Integer> a25 = make();
ArrayList<Integer> a26 = make(5);
ArrayList<Integer> a27 = make();
ArrayList<Integer> a28 = make(4,22);
ArrayList<Integer> a29 = make(27);
C = make2(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,
a10,a11,a12,a13,a14,a15,a16,a17,a18,a19,
a20,a21,a22,a23,a24,a25,a26,a27,a28,a29);
parseSubsets(0, new ArrayList<Integer>());
if(foundError) System.out.println();
System.out.println("Elapsed: " + (time() - t) / 1000.0 + " s");
}
static void parseSubsets(int x, ArrayList<Integer> list) {
if(x==S.length) {
if(!list.isEmpty())
checkAoR(list);
return;
}
ArrayList<Integer> option1 = new ArrayList<Integer>(list);
parseSubsets(x+1, option1);
ArrayList<Integer> option2 = new ArrayList<Integer>(list);
option2.add(S[x]);
parseSubsets(x+1, option2);
}
static void checkAoR(ArrayList<Integer> list) {
int i, j;
for(i = 0; i < list.size(); i++) {
ArrayList<Integer> sublist = C.get(list.get(i));
boolean disjoint = true;
for(j = 0; j < sublist.size(); j++)
if(list.contains(sublist.get(j))) {
disjoint = false;
break;
}
if(disjoint) return;
}
foundError = true;
System.out.println("Problematic set of components: " + list);
}
static ArrayList<Integer> make(int... nums) {
ArrayList<Integer> ret = new ArrayList<Integer>();
for(int i : nums)
ret.add(i);
return ret;
}
static ArrayList<ArrayList<Integer>> make2(ArrayList<Integer>... lists) {
ArrayList<ArrayList<Integer>> ret = new ArrayList<ArrayList<Integer>>();
for(ArrayList<Integer> i : lists)
ret.add(i);
return ret;
}
static long time() {
return System.currentTimeMillis();
}
}

Output: Code:

Test 1: Do nothing inside the loop.
Elapsed: 0.0040 s
Test 2: Implement AoR algo with 30 components.
Problematic set of components: [8, 17, 20]
Problematic set of components: [3]
Problematic set of components: [3, 8, 17, 20]
Problematic set of components: [1, 3]
Problematic set of components: [1, 3, 8, 17, 20]
Problematic set of components: [0, 8, 17, 20]
Problematic set of components: [0, 3, 8, 17, 20]
Problematic set of components: [0, 1, 3]
Problematic set of components: [0, 1, 3, 8, 17, 20]
Elapsed: 253.699 s

Another algorithm to generate the subsets would be to rely on the bijection between binary numbers and the elements of the power set.