3

First of all: no, this is not homework! This fits into a solver I'm writing for a game. I just reduced the problem to this concise statement:

Given a set of sets S, find and remove any elements of S which are subsets of other elements of S.

Domain

1 <= |S| <= C^K

1 <= |Si| <= K

2 <= C <= 10

10 <= K <= 500

Details

Si is a subset of [0, K)

min(|Si|) >= logC(|S|)

My current approach is to keep each set inside S sorted via what I call a "NatSet" which is simply a bool[K]. I then sort S by |Si| and do a O(|S|^2) search to find elements which are subsets of other elements. This, unfortunately, is too slow for my target values C=6 and K=16*9.

Gabriel Garcia
  • 1,000
  • 10
  • 11
  • Hmmm, well, if you're checking a particular element `A`, then the only elements of `S` that could possibly have `A` as a subset are those with size at least `A`. So, that might narrow your search field a bit. You can also start with the largest set in S (or list of sets if there are multiple sets with maximum size), and search the rest of the sets in S to see which are a subset of the largest set in question. Discard any that are and move on with the second smallest set (or collection of sets with second-smallest size), etc. –  Jan 24 '15 at 02:38
  • Can you arrange(sort) the elements of your sets (the inner ones) by some criteria? – Alexandru Barbarosie Jan 24 '15 at 03:43
  • What is larger, |S| or K? – cleros Jan 24 '15 at 04:57
  • How did you get the set? Can you filter when adding `Si`? – Tony Jan 24 '15 at 06:46
  • @Tony I'm considering opening a new question with full detail as to what I'm trying to do. Either way, I get the set by doing a DFS over a C-ary tree of possible moves. S is a whole level of the tree. The question I ask here is my strategy to prune some branches. – Gabriel Garcia Jan 24 '15 at 14:08

2 Answers2

2

Considering I can't try it (the input of set S is invisible for me) and decide whether the following are helpful, I can only call them some tips for you:

  1. When comparing two set: 'diminished' binary search: when you compare whether set A (x1...xn) is the subset of set B( y1...ym ), suppose you find yk = x1 (n <= m)

        y1, y2, ...,yk, yk+1 ... ym
                |
               x1

    then you can search x2 in the range of [yk+1, ym]. And the other are the same.

  2. When choosing two sets to compare: Choose the large one(ie, s1 and sk, then s1 and sk-1), you said you sort it by size and the large one is more likely to contain it.
  3. Sort Si? I am not sure whether sort S can improve your performance and you can try without sorting or using a max-heap (see tip 4)
  4. Using max-heap: compare the leaf with root and one of root's son... as the graph show).

enter image description here

If leaf doesn't removed (ie, isn't the subset of it's father), just remove it from heap and you can swap it to the place where the leaf is removed. (as following show)

enter image description here

Notice: Using heap can't guarantee all subset are removed.

  1. How to sort?: In your case, it seems that the counting sort is a suitable way to sort which is a linear sorting.

More:

1.And you said you are pruning tree, do you want Alpha–beta pruning ?

2.Efficient list intersection algorithm

Hope this can be helpful.

Community
  • 1
  • 1
Tony
  • 5,972
  • 2
  • 39
  • 58
0

The inherent issue here is that given two sets, one with p elements and the other with q elements (without loss of generality, we can say p < q), the fastest way you can get a Union of the two is O(p). This is because if you use HashSets you can reduce your lookup to O(1).

As I understand it, you are doing an O(K^2) search so you get a total run of O((n^2)*(K^2)), where n is the number of elements of S. You could reduce it to O((n^2)K) using the HashSet approach. Here's a link to Java http://docs.oracle.com/javase/7/docs/api/java/util/HashSet.html and almost all major languages have some implementation in their standard libraries. Although if your set S is anywhere near n= 6^(16*9) then I don't think this will help much (I'm not even sure if you can fit any relevant data in modern computers of that size).

If you could drive k down to <= 64 (or 32 in 32 bit systems) you could use bit maps to store each set inside S and parallel bit operations to reduce your time down to O(n^2). It would be equivalent to your current approach but you would just do a bitwise or and check if it equals the same number : ((a1 | a2) == a1) || ((a1 | a2) == a2). This way you get a union operation in constant time.

ArtisanV
  • 511
  • 4
  • 14