セットのすべてのパーティションを見つける方法
明確な値のセットがあります。このセットのすべてのパーティションを生成する方法、つまり、セットをサブセットに分割するすべての可能な方法を探しています。
たとえば、セット{1, 2, 3}には次のパーティションがあります。
{ {1}, {2}, {3} },
{ {1, 2}, {3} },
{ {1, 3}, {2} },
{ {1}, {2, 3} },
{ {1, 2, 3} }.
これらは数学的な意味でのセットであるため、順序は関係ありません。たとえば、{1, 2}, {3}は{3}, {2, 1}と同じであり、個別の結果であってはなりません。
セットパーティションの完全な定義は Wikipedia にあります。
簡単な再帰的解決策を見つけました。
まず、より単純な問題を解決しましょう。正確に2つの部分で構成されるすべてのパーティションを見つける方法です。 n要素セットの場合、intを0から（2 ^ n）-1まで数えることができます。これにより、すべてのnビットパターンが作成され、各ビットは1つの入力要素に対応します。ビットが0の場合、要素を最初の部分に配置します。 1の場合、要素は2番目の部分に配置されます。これには1つの問題が残ります。パーティションごとに、2つの部分が交換された場合に重複する結果が得られます。これを修正するために、常に最初の要素を最初の部分に配置します。次に、0から（2 ^（n-1））-1まで数えて、残りのn-1要素のみを分配します。
セットを2つの部分に分割できるようになったので、残りの問題を解決する再帰関数を記述できます。関数は元のセットから開始し、2つの部分からなるすべてのパーティションを検索します。これらのパーティションのそれぞれについて、2番目の部分を2つの部分に分割するすべての方法を再帰的に見つけて、3つの部分のパーティションすべてを生成します。次に、これらの各パーティションの最後の部分を分割して、4つの部分からなるすべてのパーティションを生成します。
以下はC＃での実装です。呼び出し
Partitioning.GetAllPartitions(new[] { 1, 2, 3, 4 })
収量
{ {1, 2, 3, 4} },
{ {1, 3, 4}, {2} },
{ {1, 2, 4}, {3} },
{ {1, 4}, {2, 3} },
{ {1, 4}, {2}, {3} },
{ {1, 2, 3}, {4} },
{ {1, 3}, {2, 4} },
{ {1, 3}, {2}, {4} },
{ {1, 2}, {3, 4} },
{ {1, 2}, {3}, {4} },
{ {1}, {2, 3, 4} },
{ {1}, {2, 4}, {3} },
{ {1}, {2, 3}, {4} },
{ {1}, {2}, {3, 4} },
{ {1}, {2}, {3}, {4} }.
using System;
using System.Collections.Generic;
using System.Linq;
namespace PartitionTest {
public static class Partitioning {
public static IEnumerable<T[][]> GetAllPartitions<T>(T[] elements) {
return GetAllPartitions(new T[][]{}, elements);
}
private static IEnumerable<T[][]> GetAllPartitions<T>(
T[][] fixedParts, T[] suffixElements)
{
// A trivial partition consists of the fixed parts
// followed by all suffix elements as one block
yield return fixedParts.Concat(new[] { suffixElements }).ToArray();
// Get all two-group-partitions of the suffix elements
// and sub-divide them recursively
var suffixPartitions = GetTuplePartitions(suffixElements);
foreach (Tuple<T[], T[]> suffixPartition in suffixPartitions) {
var subPartitions = GetAllPartitions(
fixedParts.Concat(new[] { suffixPartition.Item1 }).ToArray(),
suffixPartition.Item2);
foreach (var subPartition in subPartitions) {
yield return subPartition;
}
}
}
private static IEnumerable<Tuple<T[], T[]>> GetTuplePartitions<T>(
T[] elements)
{
// No result if less than 2 elements
if (elements.Length < 2) yield break;
// Generate all 2-part partitions
for (int pattern = 1; pattern < 1 << (elements.Length - 1); pattern++) {
// Create the two result sets and
// assign the first element to the first set
List<T>[] resultSets = {
new List<T> { elements[0] }, new List<T>() };
// Distribute the remaining elements
for (int index = 1; index < elements.Length; index++) {
resultSets[(pattern >> (index - 1)) & 1].Add(elements[index]);
}
yield return Tuple.Create(
resultSets[0].ToArray(), resultSets[1].ToArray());
}
}
}
}
ベル番号 を参照してください。この問題について簡単に説明します。
n要素のセットをm個の空でないセットに分割するものとしてf（n、m）を検討してください。
たとえば、3つの要素のセットのパーティションは次のようになります。
1）セットサイズ1：{{1,2,3}、} <-f（3,1）
2）セットサイズ2：{{1,2}、{3}}、{{1,3}、{2}}、{{2,3}、{1}} <-f （3,2）
3）セットサイズ3：{{1}、{2}、{3}} <-f（3,3）
それでは、f（4,2）を計算しましょう。
f（4,2）を作成する方法は2つあります。
A.セットをf（3,1）に追加します。これにより、{{1,2,3}、}から{{1,2,3}、{4}}に変換されます。
B。 f（3,2）のセットのいずれかに4を追加します。これは、
{{1,2}、{3}}、{{1,3}、{2}}、{{2,3}、{1}}
に
{{1,2,4}、{3}}、{{1,2}、{3,4}}
{{1,3,4}、{2}}、{{1,3}、{2,4}}
{{2,3,4}、{1}}、{{2,3}、{1,4}}
したがって、f(4,2) = f(3,1) + f(3,2)*2
結果はf(n,m) = f(n-1,m-1) + f(n-1,m)*m
セットのすべてのパーティションを取得するためのJavaコード：
import Java.util.ArrayList;
import Java.util.List;
public class SetPartition {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
for(int i=1; i<=3; i++) {
list.add(i);
}
int cnt = 0;
for(int i=1; i<=list.size(); i++) {
List<List<List<Integer>>> ret = helper(list, i);
cnt += ret.size();
System.out.println(ret);
}
System.out.println("Number of partitions: " + cnt);
}
// partition f(n, m)
private static List<List<List<Integer>>> helper(List<Integer> ori, int m) {
List<List<List<Integer>>> ret = new ArrayList<>();
if(ori.size() < m || m < 1) return ret;
if(m == 1) {
List<List<Integer>> partition = new ArrayList<>();
partition.add(new ArrayList<>(ori));
ret.add(partition);
return ret;
}
// f(n-1, m)
List<List<List<Integer>>> prev1 = helper(ori.subList(0, ori.size() - 1), m);
for(int i=0; i<prev1.size(); i++) {
for(int j=0; j<prev1.get(i).size(); j++) {
// Deep copy from prev1.get(i) to l
List<List<Integer>> l = new ArrayList<>();
for(List<Integer> inner : prev1.get(i)) {
l.add(new ArrayList<>(inner));
}
l.get(j).add(ori.get(ori.size()-1));
ret.add(l);
}
}
List<Integer> set = new ArrayList<>();
set.add(ori.get(ori.size() - 1));
// f(n-1, m-1)
List<List<List<Integer>>> prev2 = helper(ori.subList(0, ori.size() - 1), m - 1);
for(int i=0; i<prev2.size(); i++) {
List<List<Integer>> l = new ArrayList<>(prev2.get(i));
l.add(set);
ret.add(l);
}
return ret;
}
}
そして結果は次のとおりです。[[[1, 2, 3]]] [[[1, 3], [2]], [[1], [2, 3]], [[1, 2], [3]]] [[[1], [2], [3]]] Number of partitions: 5
楽しみのために、これはより短い純粋な反復バージョンです：
public static IEnumerable<List<List<T>>> GetAllPartitions<T>(T[] elements) {
var lists = new List<List<T>>();
var indexes = new int[elements.Length];
lists.Add(new List<T>());
lists[0].AddRange(elements);
for (;;) {
yield return lists;
int i,index;
for (i=indexes.Length-1;; --i) {
if (i<=0)
yield break;
index = indexes[i];
lists[index].RemoveAt(lists[index].Count-1);
if (lists[index].Count>0)
break;
lists.RemoveAt(index);
}
++index;
if (index >= lists.Count)
lists.Add(new List<T>());
for (;i<indexes.Length;++i) {
indexes[i]=index;
lists[index].Add(elements[i]);
index=0;
}
}
ここでテスト： https://ideone.com/EccB5n
そして、より単純な再帰バージョン：
public static IEnumerable<List<List<T>>> GetAllPartitions<T>(T[] elements, int maxlen) {
if (maxlen<=0) {
yield return new List<List<T>>();
}
else {
T elem = elements[maxlen-1];
var shorter=GetAllPartitions(elements,maxlen-1);
foreach (var part in shorter) {
foreach (var list in part.ToArray()) {
list.Add(elem);
yield return part;
list.RemoveAt(list.Count-1);
}
var newlist=new List<T>();
newlist.Add(elem);
part.Add(newlist);
yield return part;
part.RemoveAt(part.Count-1);
}
}
これが非再帰的な解決策です
class Program
{
static void Main(string[] args)
{
var items = new List<Char>() { 'A', 'B', 'C', 'D', 'E' };
int i = 0;
foreach (var partition in items.Partitions())
{
Console.WriteLine(++i);
foreach (var group in partition)
{
Console.WriteLine(string.Join(",", group));
}
Console.WriteLine();
}
Console.ReadLine();
}
}
public static class Partition
{
public static IEnumerable<IList<IList<T>>> Partitions<T>(this IList<T> items)
{
if (items.Count() == 0)
yield break;
var currentPartition = new int[items.Count()];
do
{
var groups = new List<T>[currentPartition.Max() + 1];
for (int i = 0; i < currentPartition.Length; ++i)
{
int groupIndex = currentPartition[i];
if (groups[groupIndex] == null)
groups[groupIndex] = new List<T>();
groups[groupIndex].Add(items[i]);
}
yield return groups;
} while (NextPartition(currentPartition));
}
private static bool NextPartition(int[] currentPartition)
{
int index = currentPartition.Length - 1;
while (index >= 0)
{
++currentPartition[index];
if (Valid(currentPartition))
return true;
currentPartition[index--] = 0;
}
return false;
}
private static bool Valid(int[] currentPartition)
{
var uniqueSymbolsSeen = new HashSet<int>();
foreach (var item in currentPartition)
{
uniqueSymbolsSeen.Add(item);
if (uniqueSymbolsSeen.Count <= item)
return false;
}
return true;
}
}
これがRubyの約20行の長さの解決策です：
def copy_2d_array(array)
array.inject([]) {|array_copy, item| array_copy.Push(item)}
end
#
# each_partition(n) { |partition| block}
#
# Call the given block for each partition of {1 ... n}
# Each partition is represented as an array of arrays.
# partition[i] is an array indicating the membership of that partition.
#
def each_partition(n)
if n == 1
# base case: There is only one partition of {1}
yield [[1]]
else
# recursively generate the partitions of {1 ... n-1}.
each_partition(n-1) do |partition|
# adding {n} to a subset of partition generates
# a new partition of {1 ... n}
partition.each_index do |i|
partition_copy = copy_2d_array(partition)
partition_copy[i].Push(n)
yield (partition_copy)
end # each_index
# Also adding the set {n} to a partition of {1 ... n}
# generates a new partition of {1 ... n}
partition_copy = copy_2d_array(partition)
partition_copy.Push [n]
yield(partition_copy)
end # block for recursive call to each_partition
end # else
end # each_partition
（私はRubyに甘んじようとしているのではなく、このソリューションが一部の読者にとって理解しやすいかもしれないと思っただけです。）
Matlabのすべてのパーティションを一覧表示するDonaldKnuthの非常に優れたAlgorithHを実装しました
https://uk.mathworks.com/matlabcentral/fileexchange/62775-allpartitions--s--http://www-cs-faculty.stanford.edu/~knuth/ fasc3b.ps.gz
function [ PI, RGS ] = AllPartitions( S )
%% check that we have at least two elements
n = numel(S);
if n < 2
error('Set must have two or more elements');
end
%% Donald Knuth's Algorith H
% restricted growth strings
RGS = [];
% H1
a = zeros(1,n);
b = ones(1,n-1);
m = 1;
while true
% H2
RGS(end+1,:) = a;
while a(n) ~= m
% H3
a(n) = a(n) + 1;
RGS(end+1,:) = a;
end
% H4
j = n - 1;
while a(j) == b(j)
j = j - 1;
end
% H5
if j == 1
break;
else
a(j) = a(j) + 1;
end
% H6
m = b(j) + (a(j) == b (j));
j = j + 1;
while j < n
a(j) = 0;
b(j) = m;
j = j + 1;
end
a(n) = 0;
elementsd
%% get partitions from the restricted growth stirngs
PI = PartitionsFromRGS(S, RGS);
end
N人のメンバーのセットに使用したトリック。 1. 2 ^ Nを計算します。2。1からNまでの各数値を2進数で書き込みます。 3.それぞれ長さNの2 ^ Nの2進数を取得し、各数値はセットをサブセットAとBに分割する方法を示します。k番目の桁が0の場合は、k番目の要素をセットAに入れます。セットBにあります。
def allPossiblePartitions(l): # l is the list whose possible partitions have to be found
# to get all possible partitions, we consider the binary values from 0 to 2**len(l))//2-1
"""
{123} --> 000 (0)
{12} {3} --> 001 (1)
{1} {2} {3} --> 010 (2)
{1} {23} --> 011 (3) --> (0 to (2**3//2)-1)
iterate over each possible partitions,
if there are partitions>=days and
if that particular partition contains
more than one element then take max of all elements under that partition
ex: if the partition is {1} {23} then we take 1+3
"""
for i in range(0,(2**len(l))//2):
s = bin(i).replace('0b',"")
s = '0'*(len(l)-len(s)) + s
sublist = []
prev = s[0]
partitions = []
k = 0
for i in s:
if (i == prev):
partitions.append(l[k])
k+=1
else:
sublist.append(partitions)
partitions = [l[k]]
k+=1
prev = i
sublist.append(partitions)
print(sublist)