web-dev-qa-db-ja.com

Java内の任意のセットのデカルト積

2つ（またはそれ以上）のセットのデカルト積を作成できる、きちんとしたJavaライブラリがいくつかありますか？

例：3つのセットがあります。 1つはクラスPersonのオブジェクト、2つ目はGiftクラスのオブジェクト、3つ目はGiftExtensionクラスのオブジェクトです。

可能なすべてのトリプルPerson-Gift-GiftExtensionを含む1つのセットを生成したいと思います。

セットの数は異なる場合があるため、ネストされたforeachループではこれを行うことはできません。条件によっては、アプリケーションでPerson-Giftペアの製品を作成する必要があります。Person-Gift-GiftExtensionが3倍になることもあります。Person-Gift-GiftExtension-GiftSecondExtension-GiftThirdExtensionなどのセットが存在することもあります。

javacartesian-product
42
mgamer

編集：2つのセットの以前のソリューションが削除されました。詳細については編集履歴を参照してください。

これは、任意の数のセットに対して再帰的に行う方法です。

public static Set<Set<Object>> cartesianProduct(Set<?>... sets) {
    if (sets.length < 2)
        throw new IllegalArgumentException(
                "Can't have a product of fewer than two sets (got " +
                sets.length + ")");

    return _cartesianProduct(0, sets);
}

private static Set<Set<Object>> _cartesianProduct(int index, Set<?>... sets) {
    Set<Set<Object>> ret = new HashSet<Set<Object>>();
    if (index == sets.length) {
        ret.add(new HashSet<Object>());
    } else {
        for (Object obj : sets[index]) {
            for (Set<Object> set : _cartesianProduct(index+1, sets)) {
                set.add(obj);
                ret.add(set);
            }
        }
    }
    return ret;
}

返されたセットでジェネリック型情報を保持することは不可能であることに注意してください。積を取りたいセットの数が事前にわかっている場合は、その数の要素を保持する一般的なタプルを定義できます（たとえば、Triple<A, B, C>）ですが、Javaで任意の数のジェネリックパラメーターを持つ方法はありません。

34
Michael Myers

これはかなり古い質問ですが、なぜ Guava's cartesianProduct を使用しないのですか？

23
Martin Andersson

以下のメソッドは、文字列のリストのリストのデカルト積を作成します。

protected <T> List<List<T>> cartesianProduct(List<List<T>> lists) {
    List<List<T>> resultLists = new ArrayList<List<T>>();
    if (lists.size() == 0) {
        resultLists.add(new ArrayList<T>());
        return resultLists;
    } else {
        List<T> firstList = lists.get(0);
        List<List<T>> remainingLists = cartesianProduct(lists.subList(1, lists.size()));
        for (T condition : firstList) {
            for (List<T> remainingList : remainingLists) {
                ArrayList<T> resultList = new ArrayList<T>();
                resultList.add(condition);
                resultList.addAll(remainingList);
                resultLists.add(resultList);
            }
        }
    }
    return resultLists;
}

例：

System.out.println(cartesianProduct(Arrays.asList(Arrays.asList("Apple", "Banana"), Arrays.asList("Red", "Green", "Blue"))));

これをもたらすでしょう：

[[Apple, Red], [Apple, Green], [Apple, Blue], [Banana, Red], [Banana, Green], [Banana, Blue]]
20
Philipp Meister

セットの数は異なる場合があるため、ネストされたforeachループではこれを行うことはできません。

2つのヒント：

  • A x B x C = A x（B x C）
  • 再帰
12
Michael Borgwardt

インデックスベースのソリューション

インデックスを使用することは、高速でメモリ効率がよく、任意の数のセットを処理できる代​​替手段です。 Iterableを実装すると、for-eachループで簡単に使用できます。使用例については、#mainメソッドを参照してください。

public class CartesianProduct implements Iterable<int[]>, Iterator<int[]> {

    private final int[] _lengths;
    private final int[] _indices;
    private boolean _hasNext = true;

    public CartesianProduct(int[] lengths) {
        _lengths = lengths;
        _indices = new int[lengths.length];
    }

    public boolean hasNext() {
        return _hasNext;
    }

    public int[] next() {
        int[] result = Arrays.copyOf(_indices, _indices.length);
        for (int i = _indices.length - 1; i >= 0; i--) {
            if (_indices[i] == _lengths[i] - 1) {
                _indices[i] = 0;
                if (i == 0) {
                    _hasNext = false;
                }
            } else {
                _indices[i]++;
                break;
            }
        }
        return result;
    }

    public Iterator<int[]> iterator() {
        return this;
    }

    public void remove() {
        throw new UnsupportedOperationException();
    }

    /**
     * Usage example. Prints out
     * 
     * <pre>
     * [0, 0, 0] a, NANOSECONDS, 1
     * [0, 0, 1] a, NANOSECONDS, 2
     * [0, 0, 2] a, NANOSECONDS, 3
     * [0, 0, 3] a, NANOSECONDS, 4
     * [0, 1, 0] a, MICROSECONDS, 1
     * [0, 1, 1] a, MICROSECONDS, 2
     * [0, 1, 2] a, MICROSECONDS, 3
     * [0, 1, 3] a, MICROSECONDS, 4
     * [0, 2, 0] a, MILLISECONDS, 1
     * [0, 2, 1] a, MILLISECONDS, 2
     * [0, 2, 2] a, MILLISECONDS, 3
     * [0, 2, 3] a, MILLISECONDS, 4
     * [0, 3, 0] a, SECONDS, 1
     * [0, 3, 1] a, SECONDS, 2
     * [0, 3, 2] a, SECONDS, 3
     * [0, 3, 3] a, SECONDS, 4
     * [0, 4, 0] a, MINUTES, 1
     * [0, 4, 1] a, MINUTES, 2
     * ...
     * </pre>
     */
    public static void main(String[] args) {
        String[] list1 = { "a", "b", "c", };
        TimeUnit[] list2 = TimeUnit.values();
        int[] list3 = new int[] { 1, 2, 3, 4 };

        int[] lengths = new int[] { list1.length, list2.length, list3.length };
        for (int[] indices : new CartesianProduct(lengths)) {
            System.out.println(Arrays.toString(indices) //
                    + " " + list1[indices[0]] //
                    + ", " + list2[indices[1]] //
                    + ", " + list3[indices[2]]);
        }
    }
}
10
Remko Popma

これは、単純化されたforループを使用できるIterableです。

import Java.util.*;

// let's begin with the demo. Instead of Person and Gift, 
// I use the well known char and int. 
class CartesianIteratorTest {

    public static void main (String[] args) {
        List <Object> lc = Arrays.asList (new Object [] {'A', 'B', 'C', 'D'});
        List <Object> lC = Arrays.asList (new Object [] {'a', 'b', 'c'});   
        List <Object> li = Arrays.asList (new Object [] {1, 2, 3, 4});
            // sometimes, a generic solution like List <List <String>>
            // might be possible to use - typically, a mixture of types is 
            // the common nominator 
        List <List <Object>> llo = new ArrayList <List <Object>> ();
        llo.add (lc);
        llo.add (lC);
        llo.add (li);

        // Preparing the List of Lists is some work, but then ...    
        CartesianIterable <Object> ci = new CartesianIterable <Object> (llo);

        for (List <Object> lo: ci)
            show (lo);
    }

    public static void show (List <Object> lo) {
        System.out.print ("(");
        for (Object o: lo)
            System.out.print (o + ", ");
        System.out.println (")");
    }
}

それはどのように行われますか？単純化されたforループを使用するには、Iterableが必要であり、IteratorはIterableから返される必要があります。オブジェクトのリストを返します-これはリストの代わりにセットになる可能性がありますが、セットにはインデックス付きアクセスがないため、リストの代わりにセットを使用して実装するのは少し複雑になります。汎用的なソリューションの代わりに、Objectは多くの目的に適していましたが、ジェネリックはより多くの制限を可能にします。

class CartesianIterator <T> implements Iterator <List <T>> {

    private final List <List <T>> lilio;    
    private int current = 0;
    private final long last;

    public CartesianIterator (final List <List <T>> llo) {
        lilio = llo;
        long product = 1L;
        for (List <T> lio: lilio)
            product *= lio.size ();
        last = product;
    } 

    public boolean hasNext () {
        return current != last;
    }

    public List <T> next () {
        ++current;
        return get (current - 1, lilio);
    }

    public void remove () {
        ++current;
    }

    private List<T> get (final int n, final List <List <T>> lili) {
        switch (lili.size ())
        {
            case 0: return new ArrayList <T> (); // no break past return;
            default: {
                List <T> inner = lili.get (0);
                List <T> lo = new ArrayList <T> ();
                lo.add (inner.get (n % inner.size ()));
                lo.addAll (get (n / inner.size (), lili.subList (1, lili.size ())));
                return lo;
            }
        }
    }
}

数学的作業は「get」メソッドで行われます。 10要素の2セットについて考えてみます。合計100の組み合わせがあり、00、01、02、... 10、...、99まで列挙されます。5X 10要素の場合50、2 X 3要素の場合6の組み合わせ。サブリストサイズのモジュロは、反復ごとに1つの要素を選択するのに役立ちます。

Iterable iここで最も興味深いこと：

class CartesianIterable <T> implements Iterable <List <T>> {

    private List <List <T>> lilio;  

    public CartesianIterable (List <List <T>> llo) {
        lilio = llo;
    }

    public Iterator <List <T>> iterator () {
        return new CartesianIterator <T> (lilio);
    }
}

For-each種類のループを可能にするIterableを実装するには、iterator（）を実装する必要があり、IteratorにはhasNext（）、next（）、およびremove（）を実装する必要があります。

結果：

(A, a, 1, )
(B, a, 1, )
(C, a, 1, )
(D, a, 1, )
(A, b, 1, )
(B, b, 1, )
(C, b, 1, )
(D, b, 1, )
...
(A, a, 2, )
...
(C, c, 4, )
(D, c, 4, )
3
user unknown

2次元配列のデカルト積を与えるIteratorは次のとおりです。ここで、配列コンポーネントは質問からのセットを表します（実際のSetsは常に配列に変換できます）。

_public class CartesianIterator<T> implements Iterator<T[]> {
    private final T[][] sets;
    private final IntFunction<T[]> arrayConstructor;

    private int count = 0;
    private T[] next = null;

    public CartesianIterator(T[][] sets, IntFunction<T[]> arrayConstructor) {
        Objects.requireNonNull(sets);
        Objects.requireNonNull(arrayConstructor);

        this.sets = copySets(sets);
        this.arrayConstructor = arrayConstructor;
    }

    private static <T> T[][] copySets(T[][] sets) {
        // If any of the arrays are empty, then the entire iterator is empty.
        // This prevents division by zero in `hasNext`.
        for (T[] set : sets) {
            if (set.length == 0) {
                return Arrays.copyOf(sets, 0);
            }
        }
        return sets.clone();
    }

    @Override
    public boolean hasNext() {
        if (next != null) {
            return true;
        }

        int tmp = count;
        T[] value = arrayConstructor.apply(sets.length);
        for (int i = 0; i < value.length; i++) {
            T[] set = sets[i];

            int radix = set.length;
            int index = tmp % radix;

            value[i] = set[index];

            tmp /= radix;
        }

        if (tmp != 0) {
            // Overflow.
            return false;
        }

        next = value;
        count++;

        return true;
    }

    @Override
    public T[] next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }

        T[] tmp = next;
        next = null;
        return tmp;
    }
}
_

基本的な考え方は、countを複数基数として扱うことです（数字iには、i番目の「セット」の長さに等しい独自の基数があります）。 nextを解決する必要があるときはいつでも（つまり、hasNext()が呼び出され、nextがnullであるとき）、数値をこの数字に分解しますマルチ基数。これらの数字は、さまざまなセットから要素を描画するインデックスとして使用されます。

使用例：

_String[] a = { "a", "b", "c"};
String[] b = { "X" };
String[] c = { "r", "s" };

String[][] abc = { a, b, c };

Iterable<String[]> it = () -> new CartesianIterator<>(abc, String[]::new);
for (String[] s : it) {
    System.out.println(Arrays.toString(s));
}
_

出力：

_[a, X, r]
[b, X, r]
[c, X, r]
[a, X, s]
[b, X, s]
[c, X, s]
_

配列が気に入らない場合、コードはコレクションの使用に簡単に変換できます。

これは多かれ少なかれ "user unknown"によって与えられた答えに似ていますが、再帰とコレクションがありません。

3
Halle Knast

はい、あります Functional Java 。

セット（s）の場合：

s.bind（P.p2（）、s）;

1
Tony Morrris

odl.com.google.common18.collect.Setsを使用してSets.cartesianProduct（）メソッドを呼び出す方法

0
Masoud

デカルト積に必要なメモリ（および処理）フットプリントは、すぐに手に負えなくなる可能性があります。素朴な実装はメモリを使い果たし、多くの時間がかかる可能性があります。実装戦略を提案するために、そのようなセットで実行する予定の操作を知っておくと便利です。

いずれにしても、GoogleコレクションでSets.SetViewのようなことを行います。これは、追加されると他のセットによってサポートされるセットです。 their問題のアイデアは、addAll呼び出しを回避することです。 your問題のアイデアは、NxMxKがセットに追加されないようにすることです。

Googleコレクションはここにあります そして言及されたクラスは ここに です

0
H Marcelo Morales