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

曾经终败给现在 2023-10-05 20:59 1阅读 0赞

##  ##

## 笛卡尔积 ##

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

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

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

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

![带有实例的笛卡尔积][673421883300f8cd27e5af0f6a026f92.png]

在这里，将集合*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）}

![两套笛卡尔积][e5e4eb88a88a02bc2c2c7ee2552d1332.png]

#### 例子＃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;
    	}
    }

[673421883300f8cd27e5af0f6a026f92.png]: https://img-blog.csdnimg.cn/img_convert/673421883300f8cd27e5af0f6a026f92.png
[e5e4eb88a88a02bc2c2c7ee2552d1332.png]: https://img-blog.csdnimg.cn/img_convert/e5e4eb88a88a02bc2c2c7ee2552d1332.png