Java：リストのリストのデカルト積
本当に一般的なプログラミングの質問のような問題がありますが、私の実装はJavaで行われているので、そのように例を示します。
私はこのようなクラスを持っています：
public class Foo {
LinkedHashMap<String, Vector<String>> dataStructure;
public Foo(LinkedHashMap<String, Vector<String>> dataStructure){
this.dataStructure = dataStructure;
}
public String[][] allUniqueCombinations(){
//this is what I need to do
}
}
LHM内のすべての値のすべての一意の組み合わせを表すLinkedHashMapからネストされた配列を生成する必要があります。たとえば、私のLHMが次のようになっている場合（擬似コードですが、アイデアは得られると思います。）：
{"foo" => ["1","2","3"], "bar" => ["3","2"], "baz" => ["5","6","7"]};
その場合、私のString [] []は次のようになります。
{
{"foo","bar","baz"},
{"1","3","5"},
{"1","2","5"},
{"1","3","6"},
{"1","2","6"},
{"1","3","7"},
{"1","2","7"},
{"2","3","5"},
{"2","2","5"},
{"2","3","6"},
{"2","2","6"},
{"2","3","7"},
{"2","2","7"},
{"3","3","5"},
{"3","2","5"},
{"3","3","6"},
{"3","2","6"},
{"3","3","7"},
{"3","2","7"},
}
それがすべてだと思います。手動で（明らかに）作成したので、セットを見逃したかもしれませんが、これは私がやろうとしていることを示していると思います。すべての一意の組み合わせが存在する限り、各セットの順序は関係ありません。また、明確にするために、LHMに含まれる要素の数も、後続の各ベクトルに含まれる要素の数もわかりません。単一の配列内のすべての要素のすべての一意の組み合わせが必要な場合に一致する答えを見つけましたが、これに正確に適合するものはありません。ただし、これが質問と完全に重複している場合は、回答にリンクを入れてください。質問を閉じます。
pdate-実際の例は実際には文字列であるため、タイプを文字列に変更しました。例を読みやすくするために整数を使用しようとしましたが、これまでに得た答えは文字列にうまく変換されません。つまり、これらは数字ですが、私の実際の場合、この特定のアプリケーションを使用する人以外にはあまり意味のない文字列になります。したがって、これは単なる抽象化です。
次のようなものを試してください。
public static void generate(int[][] sets) {
int solutions = 1;
for(int i = 0; i < sets.length; solutions *= sets[i].length, i++);
for(int i = 0; i < solutions; i++) {
int j = 1;
for(int[] set : sets) {
System.out.print(set[(i/j)%set.length] + " ");
j *= set.length;
}
System.out.println();
}
}
public static void main(String[] args) {
generate(new int[][]{{1,2,3}, {3,2}, {5,6,7}});
}
印刷されます：
1 3 5
2 3 5
3 3 5
1 2 5
2 2 5
3 2 5
1 3 6
2 3 6
3 3 6
1 2 6
2 2 6
3 2 6
1 3 7
2 3 7
3 3 7
1 2 7
2 2 7
3 2 7
私は、クヌースの [〜＃〜] taocp [〜＃〜] 本の1つに基づいて上記のアルゴリズムを実装しました（コメントでは、@ chikitinにはより具体的な参照があります：それは???????????? ???????? PRE FASCICLE2Aセクション7.2.1.1Knuth、AddisonWesleyによるTheArt Of ComputerProgrammingのすべてのn-Tupleの生成）。
配列にsetという名前を付けましたが、もちろん、一意の要素を保持する必要はありません。私がそれを使用したとき、それらはユニークな要素を含んでいたので、その名前が付けられました。
編集
これはほぼ1対1の翻訳です。
import Java.util.Arrays;
import Java.util.LinkedHashMap;
import Java.util.Vector;
public class Foo {
private LinkedHashMap<String, Vector<String>> dataStructure;
public Foo(LinkedHashMap<String, Vector<String>> dataStructure){
this.dataStructure = dataStructure;
}
public String[][] allUniqueCombinations(){
int n = dataStructure.keySet().size();
int solutions = 1;
for(Vector<String> vector : dataStructure.values()) {
solutions *= vector.size();
}
String[][] allCombinations = new String[solutions + 1][];
allCombinations[0] = dataStructure.keySet().toArray(new String[n]);
for(int i = 0; i < solutions; i++) {
Vector<String> combination = new Vector<String>(n);
int j = 1;
for(Vector<String> vec : dataStructure.values()) {
combination.add(vec.get((i/j)%vec.size()));
j *= vec.size();
}
allCombinations[i + 1] = combination.toArray(new String[n]);
}
return allCombinations;
}
public static void main(String[] args) {
LinkedHashMap<String, Vector<String>> data = new LinkedHashMap<String, Vector<String>>();
data.put("foo", new Vector<String>(Arrays.asList("1", "2", "3")));
data.put("bar", new Vector<String>(Arrays.asList("3", "2")));
data.put("baz", new Vector<String>(Arrays.asList("5", "6", "7")));
Foo foo = new Foo(data);
for(String[] combination : foo.allUniqueCombinations()) {
System.out.println(Arrays.toString(combination));
}
}
}
上記のクラスを実行すると、次のように出力されます。
[foo, bar, baz]
[1, 3, 5]
[2, 3, 5]
[3, 3, 5]
[1, 2, 5]
[2, 2, 5]
[3, 2, 5]
[1, 3, 6]
[2, 3, 6]
[3, 3, 6]
[1, 2, 6]
[2, 2, 6]
[3, 2, 6]
[1, 3, 7]
[2, 3, 7]
[3, 3, 7]
[1, 2, 7]
[2, 2, 7]
[3, 2, 7]
怠惰に製品を生成するのはどうですか、すなわち。タプルにアクセスしているときにのみ作成しますか？
/**
* A random access view of tuples of a cartesian product of ArrayLists
*
* Orders tuples in the natural order of the cartesian product
*
* @param T the type for both the values and the stored tuples, ie. values of the cartesian factors are singletons
* While the type of input sets is List<T> with elements being treated as singletons
*
*/
abstract public class CartesianProductView<T> extends AbstractList<T> {
private final List<List<T>> factors;
private final int size;
/**
* @param factors the length of the factors (ie. the elements of the factors argument) should not change,
* otherwise get may not return all tuples, or throw exceptions when trying to access the factors outside of range
*/
public CartesianProductView(List<List<T>> factors) {
this.factors = new ArrayList<>(factors);
Collections.reverse(this.factors);
int acc = 1;
for (Iterator<List<T>> iter = this.factors.iterator(); iter.hasNext(); ) {
acc *= iter.next().size();
}
this.size = acc;
}
@Override
public T get(int index) {
if (index < 0 || index >= size()) {
throw new IndexOutOfBoundsException(String.format("index %d > size() %d", index, size()));
}
T acc = null;
for (Iterator<List<T>> iter = factors.iterator(); iter.hasNext();) {
List<T> set = iter.next();
acc = makeTupleOrSingleton(set.get(index % set.size()), acc);
index /= set.size();
}
return acc;
}
@Override
public int size() {
return size;
}
private T makeTupleOrSingleton(T left, T right) {
if (right == null) {
return left;
}
return makeTuple(left, right);
}
/**
*
* @param left a singleton of a value
* @param right a Tuple of values taken from the cartesian product factors, with null representing the empty set
* @return the sum of left and right, with the value of left being put in front
*/
abstract protected T makeTuple(T left, T right);
}
このように使用します
final List<List<String>> l1 = new ArrayList<List<String>>() {{ add(singletonList("a")); add(singletonList("b")); add(singletonList("c")); }};
final List<List<String>> l2 = new ArrayList<List<String>>() {{ add(singletonList("X")); add(singletonList("Y")); }};
final List<List<String>> l3 = new ArrayList<List<String>>() {{ add(singletonList("1")); add(singletonList("2")); add(singletonList("3")); add(singletonList("4")); }};
List<List<List<String>>> in = new ArrayList<List<List<String>>>() {{ add(l1); add(l2); add(l3); }};
List<List<String>> a = new CartesianProductView<List<String>>(in) {
@Override
protected List<String> makeTuple(final List<String> left, final List<String> right) {
return new ArrayList<String>() {{ add(left.get(0)); addAll(right); }};
}
};
System.out.println(a);
結果：
[[a, X, 1], [a, X, 2], [a, X, 3], [a, X, 4], [a, Y, 1], [a, Y, 2], [a, Y, 3], [a, Y, 4], [b, X, 1], [b, X, 2], [b, X, 3], [b, X, 4], [b, Y, 1], [b, Y, 2], [b, Y, 3], [b, Y, 4], [c, X, 1], [c, X, 2], [c, X, 3], [c, X, 4], [c, Y, 1], [c, Y, 2], [c, Y, 3], [c, Y, 4]]
追加のボーナスとして、文字列をすべて結合して使用できます。
final List<String> l1 = new ArrayList<String>() {{ add("a"); add("b"); add("c"); }};
final List<String> l2 = new ArrayList<String>() {{ add("X"); add("Y"); }};
final List<String> l3 = new ArrayList<String>() {{ add("1"); add("2"); add("3"); add("4"); }};
List<List<String>> in = new ArrayList<List<String>>() {{ add(l1); add(l2); add(l3); }};
List<String> a = new CartesianProductView<String>(in) {
@Override
protected String makeTuple(String left, String right) {
return String.format("%s%s", left, right);
}
};
System.out.println(a);
結果：
[aX1, aX2, aX3, aX4, aY1, aY2, aY3, aY4, bX1, bX2, bX3, bX4, bY1, bY2, bY3, bY4, cX1, cX2, cX3, cX4, cY1, cY2, cY3, cY4]
答えが必要になったのはかなり後のことですが、少なくともJavaアプリケーションの一部では、Groovyに切り替えて、ラッパークラスを作成できることに気付くのを控えることはできません。このような順列のGroovyコードは次のとおりです。
myListOfLists.combinations()
JavaアプリケーションでGroovyを使い始めて以来、それらを作成する方がはるかに高速で、デバッグ/プロファイリングするのがはるかに興味深いです（ええと...）
次の2つの方法を見てください、それらはあなたが要求したことを正確に実行します。私はそれらを一般的なものとして書きました。リストの長さやマップに存在するキーの数は関係ありません。生成される組み合わせは正しいです。
以下のコードは、直積を計算するためのPythonの itertools.product() 関数のアルゴリズムに基づくiterativeです。リストのリストの。
public String[][] allUniqueCombinations() {
List<String> labels = new ArrayList<String>();
List<List<String>> lists = new ArrayList<List<String>>();
for (Map.Entry<String, Vector<String>> entry : dataStructure.entrySet()) {
labels.add(entry.getKey());
lists.add(entry.getValue());
}
List<List<String>> combinations = product(lists);
int m = combinations.size() + 1;
int n = labels.size();
String[][] answer = new String[m][n];
for (int i = 0; i < n; i++)
answer[0][i] = labels.get(i);
for (int i = 1; i < m; i++)
for (int j = 0; j < n; j++)
answer[i][j] = combinations.get(i-1).get(j);
return answer;
}
private List<List<String>> product(List<List<String>> lists) {
List<List<String>> result = new ArrayList<List<String>>();
result.add(new ArrayList<String>());
for (List<String> e : lists) {
List<List<String>> tmp1 = new ArrayList<List<String>>();
for (List<String> x : result) {
for (String y : e) {
List<String> tmp2 = new ArrayList<String>(x);
tmp2.add(y);
tmp1.add(tmp2);
}
}
result = tmp1;
}
return result;
}
私は質問の例でそれらをテストしました：
LinkedHashMap<String, Vector<String>> sample =
new LinkedHashMap<String, Vector<String>>();
Vector<String> v1 = new Vector<String>();
v1.add("1"); v1.add("2"); v1.add("3");
Vector<String> v2 = new Vector<String>();
v2.add("3"); v2.add("2");
Vector<String> v3 = new Vector<String>();
v3.add("5"); v3.add("6"); v3.add("7");
sample.put("foo", v1);
sample.put("bar", v2);
sample.put("baz", v3);
Foo foo = new Foo(sample);
String[][] ans = foo.allUniqueCombinations();
for (String[] row : ans)
System.out.println(Arrays.toString(row));
印刷される答えは予想されたものです（組み合わせは異なる順序で表示されますが）：
[foo, bar, baz]
[1, 3, 5]
[1, 3, 6]
[1, 3, 7]
[1, 2, 5]
[1, 2, 6]
[1, 2, 7]
[2, 3, 5]
[2, 3, 6]
[2, 3, 7]
[2, 2, 5]
[2, 2, 6]
[2, 2, 7]
[3, 3, 5]
[3, 3, 6]
[3, 3, 7]
[3, 2, 5]
[3, 2, 6]
[3, 2, 7]
Guavaには、指定されたセットのリストのデカルト積を返すユーティリティメソッドがあります： Sets.cartesianProduct 。
Functional Java's List monad ：を使用して、これを非常に簡単に解決することもできます。
import fj.data.List;
public class cartesian {
public static void main(String[] args) {
List<String> foo = List.list("a", "b");
List<Integer> bar = List.list(1,2,3);
List<Float> baz = List.list(0.2f,0.4f,0.3f);
List<P3<String, Integer, Float>>
// the Cartesian product is assembled into a list of P3's
result = foo.bind(bar, baz, P.<String, Integer, Float>p3());
String out = Show.listShow(Show.p3Show(Show.stringShow, Show.intShow, Show.floatShow))
.showS(result);
System.out.println(out);
}
}
パーティーに遅れましたが、塩見のリンクをたどって関数をJavaに翻訳しました。その結果、アルゴリズムを理解しやすくなります（Bart Kiersのソリューションを理解するのに苦労したため、少し遅いかもしれません）。
ここにあります（キーはintであり、Stringへの置き換えは簡単です）：
使用法
public void testProduct(){
Map<Integer, List<String>> data = new LinkedHashMap<Integer, List<String>>(){{
put(0, new ArrayList<String>(){{
add("John"); add("Sarah");
}});
put(1, new ArrayList<String>(){{
add("Red"); add("Green"); add("Blue"); add("Orange");
}});
put(2, new ArrayList<String>(){{
add("Apple"); add("Tomatoe"); add("Bananna");
}});
}};
List<String[]> product = GetCrossProduct(data);
for(String[] o : product)
System.out.println(Arrays.toString(o));
}
結果
[John, Red, Apple]
[John, Red, Tomatoe]
[John, Red, Bananna]
[John, Green, Apple]
[John, Green, Tomatoe]
[John, Green, Bananna]
[John, Blue, Apple]
[John, Blue, Tomatoe]
[John, Blue, Bananna]
[John, Orange, Apple]
[John, Orange, Tomatoe]
[John, Orange, Bananna]
[Sarah, Red, Apple]
[Sarah, Red, Tomatoe]
[Sarah, Red, Bananna]
[Sarah, Green, Apple]
[Sarah, Green, Tomatoe]
[Sarah, Green, Bananna]
[Sarah, Blue, Apple]
[Sarah, Blue, Tomatoe]
[Sarah, Blue, Bananna]
[Sarah, Orange, Apple]
[Sarah, Orange, Tomatoe]
[Sarah, Orange, Bananna]
デカルト積関数
public static List<String[]> GetCrossProduct(Map<Integer, List<String>> lists)
{
List<String[]> results = new ArrayList<String[]>();
GetCrossProduct(results, lists, 0, new String[(lists.size())]);
return results;
}
private void GetCrossProduct(List<String[]> results, Map<Integer, List<String>> lists, int depth, String[] current)
{
for (int i = 0; i < lists.get(depth).size(); i++)
{
current[depth] = lists.get(depth).get(i);
if (depth < lists.keySet().size() - 1)
GetCrossProduct(results, lists, depth + 1, current);
else{
results.add(Arrays.copyOf(current,current.length));
}
}
}
これが link 、そのc＃ですが、それで作業できると確信しています！
文字列のベクトルのLinkedHashMapは...-面倒です。ソリューションを使用するための変換に多くの時間を費やす必要がありましたが、最終的にはArrayOfArraysではなく、リストのリストを作成し、最後のステップを読者に提供します。
import Java.util.*;
/**
CartesianProductLHM
*/
public class CartesianProductLHM
{
LinkedHashMap <String, Vector<String>> dataStructure;
public CartesianProductLHM (final String[] data) {
dataStructure = new LinkedHashMap <String, Vector<String>> ();
for (String str : data)
{
String [] kv = str.split (":");
String [] values = kv[1].split (",");
Vector <String> v = new Vector <String> ();
for (String s: values) {
v.add (s);
// System.out.print (s);
}
// System.out.println ("\n---");
dataStructure.put (kv[0], v);
}
// System.out.println (" --- --- ---");
}
List <String> getCombiFor (final int i, final List <List <String>> livs)
{
List <String> ls = new ArrayList <String> ();
if (! livs.isEmpty ()) {
List <String> vs = livs.remove (0);
int idx = i % vs.size ();
String elem = vs.get (idx);
ls.add (elem);
ls.addAll (getCombiFor (i / vs.size (), livs));
}
return ls;
}
List <String> getOuterCombiFor (int i, List <List <String>> coll)
{
List <String> ls = new ArrayList <String> ();
if (! coll.isEmpty ()) {
List <List <String>> livs = new ArrayList <List <String>> ();
for (List<String> li : coll)
{
livs.add (li);
}
ls.addAll (getCombiFor (i, livs));
}
return ls;
}
public List <List <String>> allUniqueCombinations () {
Collection <Vector <String>> li = dataStructure.values ();
List <List <String>> lls = new ArrayList <List <String>> ();
for (Vector <String> vs : li) {
List <String> l = new ArrayList <String> ();
for (String s : vs) {
l.add (s);
}
lls.add (l);
}
int count = 1;
for (Vector <String> vec: li) {
count *= vec.size ();
}
List <List <String>> result = new ArrayList <List <String>> ();
for (int i = 0; i < count; ++i)
{
List <String> l = getOuterCombiFor (i, lls);
result.add (l);
}
return result;
}
public static void main (String args[])
{
String[] arr = {"foo:1,2,3", "bar:a,b", "baz:5,6,7"};
CartesianProductLHM cp = new CartesianProductLHM (arr);
List <List <String>> lls = cp.allUniqueCombinations ();
for (List <String> ls : lls)
{
for (String s : ls)
System.out.print (s + "\t");
System.out.println ();
}
}
}
ええと-はい、そして私はいくつかのテストデータを解析します。
主なアイデアは、いくつかのリスト（abc、12、defg、...）があり、位置0に3つの可能性、位置1に2、位置3に4など、3 * 2 * 4の組み合わせがあるということです。これまでのところ。
0から23までの数字から、モジュロを使用して各サブリストから選択し、残りの数字を前のリストのサイズで割った値と残りのリストを、リストがなくなるまで再帰的にプロシージャに渡します。
再帰的ソリューション：
public <T> List<List<T>> cartesianProduct(int i, List<T>... a) {
if(i == a.length ) {
List<List<T>> result = new ArrayList<>();
result.add(new ArrayList());
return result;
}
List<List<T>> next = cartesianProduct(i+1, a);
List<List<T>> result = new ArrayList<>();
for(int j=0; j < a[i].size(); j++) {
for(int k=0; k < next.size(); k++) {
List<T> concat = new ArrayList();
concat.add(a[i].get(j));
concat.addAll(next.get(k));
result.add(concat);
}
}
return result;
}
組み合わせを再帰的に生成できます。
public class Main {
public static void main(String[] args) {
int[][] arr = new int[][] { { 1, 2, 3 }, { 3, 2 }, { 5, 6, 7 } };
cartesianProduct(arr, 0, new int[arr.length]);
}
private static void cartesianProduct(int[][] arr, int level, int[] cp) {
if (level == arr.length) {
for (int x : cp)
System.out.print(x + " ");
System.out.println();
return;
}
for (int i = 0; i < arr[level].length; i++) {
cp[level] = arr[level][i];
cartesianProduct(arr, level + 1, cp);
}
}
}
出力：
1 3 5
1 3 6
1 3 7
1 2 5
1 2 6
1 2 7
2 3 5
2 3 6
2 3 7
2 2 5
2 2 6
2 2 7
3 3 5
3 3 6
3 3 7
3 2 5
3 2 6
3 2 7