Java实现笛卡尔积List＜String＞ cartesianProduct(List＜List＜String＞＞ wordLists)

 

 

笛卡尔积

两套甲和乙的笛卡尔乘积甲和乙通过表示甲×乙并定义为：

A×B = {（a，b）| aϵA和bϵB}

 

笛卡尔乘积是两个集合的乘积，以形成所有有序对的集合。有序对的第一个元素属于第一组，第二对则属于第二组。举个例子

假设A = {狗，猫}
         B = {肉，牛奶}然后， 
         A×B = {（狗，肉），（猫，牛奶），（狗，奶），（猫，肉）}

在这里，将集合A和B相乘得到笛卡尔积A×B。的第一个元素A×B是一个有序对（狗，肉），其中狗属于集合甲。类似地，有序对的第二个元素Meat属于集合B。这对于A×B的所有元素（有序对）都是如此。

笛卡尔积示例

例1：笛卡尔积的实际例子

如果X是x平面上的点集合，而Y 是y平面上的点集合，则X ×Y表示XY平面上的点。

范例＃2

假设两组A = {a，b}和B = {1,2,3}。找到A×B和B×A。

这里，
A = {a，b}
B = {1,2,3}
现在，
A×B = {（a，1），（a，2），（a，3），（b，1），（b，2），（b，3）}
B×A = {（1，a），（1，b），（2，a），（2，b），（3，a），（3，b）}

例子＃3

如果A×B = {（x，1），（x，2），（x，3），（y，1），（y，2），（y，3）}。查找A和B。

由于集合A仅包含每个有序对的第一个元素，

A = {x，y}

由于集合B仅包含有序对的第二个元素，

B = {1,2,3}

 

我们在两个集合中都排除重复元素（因为集合只能包含唯一元素）。

3套的笛卡尔积

对于三组A， 乙和Ç，的笛卡儿积A， 乙和Ç由表示甲×乙× Ç并定义为：

A×B×C = {（p，q，r）| pϵA和qϵB和rϵC}

例子＃4

假设两组A = {-1，-2}，B = {1，2}和C = {0}。找出A×B×C。

这里，
A = {-1，-2}
B = {1，2}
C = {0}
现在，
A×B = {（-1,1,0），（-1,2,0），（-2,1,0），（-2,2,0）}

笛卡尔积的要点

空集的笛卡尔积

如果两个集合中的任何一个为空，则这两个集合的笛卡尔积也为空。

如果A = {1，2}并且B = ϕ。然后，A×B ＝ ϕ和B×A ＝ ϕ。

非交换性

对于两个唯一且非空的集合A和B，A×B不等于B×A。

如果A = {a，b}且B = {1,2,3} ，

A×B = {（a，1），（a，2），（a，3），（b，1），（b，2），（b，3）}
B×A = {（1，a），（1，b），（2，a），（2，b），（3，a），（3，b）}

在这里，A×B≠B×A

交换性的条件

对于两个集合A和B，如果满足以下任一条件，则两个集合A×B和B×A的笛卡尔积相等：

• 两组中的任何一个为空
• 两组相等

如果A = {1，2}并且B = ϕ。然后，

       A×B = ϕ 
       B×A = ϕ
因此， A×B = B×A

如果A = B = {1，2}， 那么，

A×B = {（1,2 ,,（2,2），（2,1），（2,2）}
B×A = {（1,2 ,,（2,2），（2,1），（2,2）}
A×A = A 2 = {（1,2 ,,（2,2），（2,1），（2,2）}
B×B = B 2 = {（1,2），（2,2），（2,1），（2,2）}

因此， A×B = B×A = A 2 = B 2

 

 

 

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class CartesianProductDemo2 {

	public static void main(String[] args) {
		List<List<String>> wl = new ArrayList<List<String>>();
		List<String> colorList = Arrays.asList("A", "B", "C");
		wl.add(colorList);
		List<String> sizeList = Arrays.asList("1", "2");
		wl.add(sizeList);
		List<String> placeList = Arrays.asList("#", "$");
		wl.add(placeList);

		List<String> descartesList = cartesianProduct(wl);
		descartesList.forEach(System.out::println);
	}

	public static List<String> cartesianProduct(List<List<String>> wordLists) {

		List<String> cp = wordLists.get(0);

		for (int i = 1; i < wordLists.size(); i++) {
			List<String> secondList = wordLists.get(i);
			List<String> combinedList = cp.stream().flatMap(s1 -> secondList.stream().map(s2 -> s1 + s2))
					.collect(Collectors.toList());
			cp = combinedList;

		}
		return cp;
	}
}