订购一组，维护多个定义的分组

Question

Since its hard for me to describe what I want in general, I try it with an example:

Given a set {x,y,z,d} and subsets {x,z}, {d,y} and {x,y}, I would like to order the first set {x,y,z,d} so that the small sets dont get torn apart (the permutation in each set is not important, so {x,y} or {y,x} is the same}.

The length of the example sets can be larger than what is given here. The small sets are always real subsets of the largest set.

I think it would be nice to have a way to say ok this part of the set has to stay in this configuration (x has to be next to y), but this part is arbitrary. Any recommendation how to do it? I tried to do it with a tree, but I am completely failing with this problem:(

Answer 1

I don't think a brute force solution lacks elegance, but it will certainly try many options that aren't worth considering:

from itertools import permutations


def find_ordering(main, subsets):
    for p in permutations(main):
        if all(any(set(p[i:i+len(s)]) == s 
                   for i in range(len(main) - len(s) + 1)) 
               for s in subsets):
            return p


print(find_ordering({1, 2, 3, 4}, [{1, 3}, {4, 2}, {1, 2}]))

Result:

(3, 1, 2, 4)

Edit: OK, that was a tough nut to crack, but here's a smarter solution:

from functools import reduce
from itertools import permutations


def shove(xs: set, yss: list[set]) -> list[set]:
    # move n up to the first part of yss that's not or only partially contained in xs
    # this works because there's no duplicates members among any members of yss
    n = 0
    while n < len(yss) and yss[n] <= xs:
        xs = xs - yss[n]
        n += 1
    # if xs could be shoved into yss entirely
    if not xs:
        return yss
    # if xs covers yss entirely, and some is left over
    elif n >= len(yss):
        return [xs] + yss
    else:
        # h, i, t = xs - yss[n], xs & yss[n], yss[n] - xs
        h, t = xs - (i := yss[n] & xs), yss[n] - i
        # avoid returning empty sets as part of the solution
        return ([h] if h else []) + yss[:n] + ([i] if i else []) + ([t] if t else []) + yss[n+1:]


def find_ordering(main: set, subsets: list[set]) -> list | None:
    # ensure there are no elements in subsets that are not in main
    if not set(reduce(set.union, subsets, set())) <= main:
        return None
    for p in permutations(subsets):
        solution = []
        solution_set = set()
        # try to shove subsets into each other, in order p
        for subset in p:
            solution = shove(subset, solution)
            # if new solution[0] contains elements in the prev solution, there's now duplicates
            if solution[0] & solution_set:
                break
            solution_set = solution_set.union(solution[0])
        else:
            # if all subsets could be shoved together, it's a solution, stop looking and return
            return [x for xs in solution for x in xs]


print(find_ordering({1, 2, 3, 4}, [{1, 3}, {4, 2}, {1, 2}]))
print(find_ordering({1, 2, 3, 4, 5, 6, 7}, [{1, 3}, {4, 2}, {1, 2}, {4, 5, 6}, {3, 7}]))
print(find_ordering({1, 2, 3, 4, 5, 6, 7}, [{1, 6}, {2, 1, 4}, {7, 3}, {3, 4}, {5, 6}]))

Result:

[4, 2, 1, 3]
[7, 3, 1, 2, 4, 5, 6]
[5, 6, 1, 2, 4, 3, 7]

The approach hinges on the idea of shoving subsets into each other. If you shove {1, 2} into [{2, 3, 4}] , the outcome is [{1}, {2}, {3, 4}] - ie a fixed ordering of sets that still contains the groupings in the original sets. 3 and 4 can still change places and the ordering will hold, but none of the sets can change place or the ordering is broken. The shove() function performs this operation. When shoving, it never changes the order of the sets in the list, but it ignores the order of elements in the sets for matching (as expected).

The find_ordering() function uses shove to try and shove subsets into each other in every possible order (using permutations of the subsets).

If the first set in an expanded solution (after a shove) contains any elements that were already in the solution, it means there's now a duplicate in the solution and it won't work, so it moves on to the next permutation.

Before starting find_ordering() , it checks if the subsets actually solely consist of elements of main , because otherwise it would try them all while a solution is impossible. In that case, or if no permutation works, the function returns None .

That was a fun question, thanks. If you see any issue with this solution, do let me know.

Edit: you correctly identified a problem with the solution - turns out there were 3 problems, but I think this is better. Don't drink and code, kids.