Question

Suppose I have a set of tuples like this (each tuple will have 1,2 or 3 items):

Master Set:

 {(A) (A,C) (B,C,E)}

and suppose I have another set of tuples like this:

Real Set: {(BOB) (TOM) (ERIC,SALLY,CHARLIE) (TOM,SALLY) (DANNY) (DANNY,TOM) (SALLY) (SALLY,TOM,ERIC) (BOB,SALLY) }

What I want to do is to extract all subsets of Tuples from the Real Set where the tuple members can be substituted to become the same as the Master Set.

In the example above, two sets would be returned:

{(BOB) (BOB,SALLY) (ERIC,SALLY,CHARLIE)}

(let BOB=A,ERIC=B,SALLY=C,CHARLIE=E)

and

{(DANNY) (DANNY,TOM) (SALLY,TOM,ERIC)}

(let DANNY=A,SALLY=B,TOM=C,ERIC=E)

Its sort of pattern matching, sort of combinatorics I guess. I really don’t know how to classify this problem and what common plans of attack there are for it. What would the stackoverflow experts suggest?

Answer 1

Seperate your tuples into sets by size. Within each set, create a data structure that allows you to efficiently query for tuples containing a given element. The first part of this structure is your tuples as an array (so that each tuple has a cannonical index). The second set is: Map String (Set Int). This is somewhat space intensive but hopefully not prohibative.

Then, you, essentially, brute force it. For all assignments to the first master set, restrict all assignments to other master sets. For all remaining assignments to the second, restrict all assignments to the third and beyond, etc. The algorithm is basically inductive.

I should add that I don’t think the problem is NP-complete so much as just flat worst-case exponential. It’s not a decision problem, but an enumeration problem. And it’s fairly easy to imagine scenarios of inputs that blow up exponentially.