如何找到最少量的常见集

Question

Given the sets

{1,2,3,4} {2,3,4} {1,4} {1}

What is an easy (and preferably performant) algorithm to find the groups: {1} {2,3} {4}

Since this is the shortest list of sets where:

• all members (1-4) are represented.
• 2 and 3 are grouped together because they always appear together in the original sets.

The real data is a bunch of references, not value types.

EDIT: I don't think summarizing what I've tried does anything to help the question, and only serve as a distraction as there probably is an algorithm in category theory for this, but (for entertainment reasons) here goes:

• I've aggregated on hash sets trying to use union operator.
• I've performed groupedby on aggregate on gethashcode.
• I've iterated over the list using the first entry as a candidate set, seeking to gradually reduce it when comparing against other members. This did not perform well and I'm not sure it ended up with the fewest amount of sets possible.

Answer 1

First off, let's carefully characterize your problem.

A relation is a function that takes two arguments and returns a bool that indicates whether the relation holds or not. For example, "less than" is a relation.

An equivalence relation is a relation that is reflexive -- every item is related to itself -- symmetric -- if A is related to B then B is related to A -- and transitive -- if A is related to B and B is related to C, then A is related to C.

An equivalence relation forms an equivalence partition of a set; that is, a number of subsets where every element in each subset is related to each other. Each subset is called an equivalence class . For example, the equivalence relation on integers "A and B are related if their difference is divisible by 3" forms three equivalence classes:

{0, 3, -3, 6, -6, ... }
{1, 4, -2, 7, -5, ... }
{2, 5, -1, 8, -4, ... }

You wish to form the union of all your sets:

{1, 2, 3, 4} U {2, 3, 4} U {1, 4} U {1} --> {1, 2, 3, 4}

And then partition that set into equivalence classes, where the equivalence relation is "A and B are related if and only if A and B always appear together in each of the original sets".

Start by forming a dictionary that maps each element to its associated equivalence class. As you correctly point out, the worst case is that we have the equivalence partitioning where every equivalence class contains only one element, so let's start with that. (This is the equivalence partitioning for the "A equals B" equivalence relation, incidentally.)

1 --> { 1 }
2 --> { 2 }
3 --> { 3 }
4 --> { 4 }

Now produce the set of all unordered pairs from the union:

{ {1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4} }

Now for each of those unordered pairs, ask the question "does the relation hold for this pair"?

For {1, 2} , {1, 3} , {1, 4} , the relation does not hold.

For {2, 3} the relation does hold, so merge the 2 and 3 buckets together:

1 -->     { 1 }
2 --\ 
     -->  { 2, 3 }
3 --/
4 -->     { 4 }

For {2, 4} and {3, 4} the relation does not hold.

Now you're done, and you have a map from every element to its corresponding equivalence class.

Make sense?

There are a number of ways you can optimize this algorithm once you've got it correct. Get it correct first.

Notice what I did here: I solved your specific problem by solving the general problem of equivalence partitioning . If you're clever about how you write this, you'll be able to re-use the logic to solve any equivalence partitioning problem, not just your specific problem.

Answer 2

Here is one approach that arrives at the same answer you did:

var sets = new [] { new [] {1,2,3,4}, new [] {2,3,4}, new [] {1,4}, new [] {1}};
var results = sets.SelectMany((x,i) => x.Select(y => new { y, i }))
                .GroupBy(x => x.y).Select(x => new { x.Key, g = string.Join("", x.Select(y => y.i).ToArray())})
                .GroupBy(x => x.g).Select(x => x.Select(y => y.Key).ToArray()).ToArray();

I would probably define the result of this query to be the shortest list of smallest sets that can be used to compose the original sets. It uses the indices of the values as a means of grouping them. (1 appears in 0,2,3; 4 appears in 0,1,2 etc) 2 and 3 have the same index arrays so they are grouped together in the final result.

My first approach would not work correctly for the sets {1,2,3,4}, {2,3,4}, {1,4} (Answer should be {1}, {4}, {2,3}). This one will.

Answer 3

Though Eric Lippert correctly described the solution, I didn't see how to create good parallel code for it. I therefore had to use this approach. My solution is as follows

{1,2,3,4} {2,3,4} {1,4} {1}

Let's call the reference to these lists A,B,C and D, respectively.

A :{1,2,3,4}
B: {2,3,4}
C: {1,4}
D: {1}

I performed SelectMany, associating each member with the reference to the list where it came from.

A, 1
A, 2
A, 3
A, 4
B, 2
B, 3
B, 4
C, 1
C, 4
D, 1

Then I grouped them by the member.

1 : {A,C,D}
2 : {A,B}
3 : {A,B}
4 : {A,B,C}

(here we see that the 2 and 3 have similar lists, which is expected since they appear in the same original lists). This is also the key point.

In order to find lists with the same members, I did an Aggregate() by XOR-ing the result of GetHashcode() over the list items. So for "1", I effectively did

var SomeInt = A.GetHashcode()^C.GetHashcode()^D.GetHashcode().

Thus producing an int for each member.

1: SomeIntA
2: SomeIntB
3: SomeIntB
4: SomeIntC.

By Grouping on this. I finally got the desired. {1},{2,3},{4}