多数组求笛卡尔积

/*--------------------------------------
 *+多数组求笛卡尔积
 *--------------------------------------
 */
  笛卡尔(Descartes)乘积又叫直积。设A、B是任意两个集合,在集合A中任意取一个元素x,在集合B中任意取一个元素y,组成一个有序对(x,y),把这样的有序对作为新的元素,他们的全体组成的集合称为集合A和集合B的直积,记为A×B,即A×B={(x,y)|x∈A且y∈B}。

function Descartes() {
    $t = func_get_args();
    if(func_num_args() == 1){
        return call_user_func_array( __FUNCTION__, $t[0] );
    }
    $a = array_shift($t);
    if(! is_array($a)){
        $a = array($a);
    }
    $a = array_chunk($a, 1);
    do {
        $r = array();
        $b = array_shift($t);
        if(! is_array($b)){
            $b = array($b);
        }
        foreach($a as $p){
            foreach(array_chunk($b, 1) as $q){
                $r[] = array_merge($p, $q);
            }
        }
        $a = $r;
    }while($t);

    return $r;
}

//示例
$arr = array(
    array(‘a1‘,‘a2‘,‘a3‘),
    ‘b‘,
    array(‘c1‘,‘c2‘),
    array(‘d1‘,‘d2‘,‘d3‘),
    //......省略其它元素(也可以是数组),
);
$r = Descartes( $arr );

var_dump($r);exit;
/*array(18) {
  [0]=>
  array(4) {
    [0]=>
    string(2) "a1"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c1"
    [3]=>
    string(2) "d1"
  }
  [1]=>
  array(4) {
    [0]=>
    string(2) "a1"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c1"
    [3]=>
    string(2) "d2"
  }
  [2]=>
  array(4) {
    [0]=>
    string(2) "a1"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c1"
    [3]=>
    string(2) "d3"
  }
  [3]=>
  array(4) {
    [0]=>
    string(2) "a1"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c2"
    [3]=>
    string(2) "d1"
  }
  [4]=>
  array(4) {
    [0]=>
    string(2) "a1"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c2"
    [3]=>
    string(2) "d2"
  }
  [5]=>
  array(4) {
    [0]=>
    string(2) "a1"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c2"
    [3]=>
    string(2) "d3"
  }
  [6]=>
  array(4) {
    [0]=>
    string(2) "a2"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c1"
    [3]=>
    string(2) "d1"
  }
  [7]=>
  array(4) {
    [0]=>
    string(2) "a2"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c1"
    [3]=>
    string(2) "d2"
  }
  [8]=>
  array(4) {
    [0]=>
    string(2) "a2"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c1"
    [3]=>
    string(2) "d3"
  }
  [9]=>
  array(4) {
    [0]=>
    string(2) "a2"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c2"
    [3]=>
    string(2) "d1"
  }
  [10]=>
  array(4) {
    [0]=>
    string(2) "a2"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c2"
    [3]=>
    string(2) "d2"
  }
  [11]=>
  array(4) {
    [0]=>
    string(2) "a2"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c2"
    [3]=>
    string(2) "d3"
  }
  [12]=>
  array(4) {
    [0]=>
    string(2) "a3"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c1"
    [3]=>
    string(2) "d1"
  }
  [13]=>
  array(4) {
    [0]=>
    string(2) "a3"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c1"
    [3]=>
    string(2) "d2"
  }
  [14]=>
  array(4) {
    [0]=>
    string(2) "a3"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c1"
    [3]=>
    string(2) "d3"
  }
  [15]=>
  array(4) {
    [0]=>
    string(2) "a3"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c2"
    [3]=>
    string(2) "d1"
  }
  [16]=>
  array(4) {
    [0]=>
    string(2) "a3"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c2"
    [3]=>
    string(2) "d2"
  }
  [17]=>
  array(4) {
    [0]=>
    string(2) "a3"
    [1]=>
    string(1) "b"
    [2]=>
    string(2) "c2"
    [3]=>
    string(2) "d3"
  }
}
*/
时间: 2024-11-03 22:36:41

多数组求笛卡尔积的相关文章

ZOJ-2386 Ultra-QuickSort 【树状数组求逆序数+离散化】

Description In this problem, you have to analyze a particular sorting algorithm. The algorithm processes a sequence of n distinct integers by swapping two adjacent sequence elements until the sequence is sorted in ascending order. For the input seque

POJ2985 The k-th Largest Group[树状数组求第k大值 并查集]

The k-th Largest Group Time Limit: 2000MS   Memory Limit: 131072K Total Submissions: 8807   Accepted: 2875 Description Newman likes playing with cats. He possesses lots of cats in his home. Because the number of cats is really huge, Newman wants to g

树状数组求逆序对

给定n个数,要求这些数构成的逆序对的个数.除了用归并排序来求逆序对个数,还可以使用树状数组来求解.树状数组求解的思路:开一个能大小为这些数的最大值的树状数组,并全部置0.从头到尾读入这些数,每读入一个数就更新树状数组,查看它前面比它小的已出现过的有多少个数sum,然后用当前位置减去该sum,就可以得到当前数导致的逆序对数了.把所有的加起来就是总的逆序对数.题目中的数都是独一无二的,这些数最大值不超过999999999,但n最大只是500000.如果采用上面的思想,必然会导致空间的巨大浪费,而且由

树状数组求区间最值

树状数组求区间最值 树状数组(Binary Index Tree)利用二进制的一些性质巧妙的划分区间,是一种编程,时间和空间上都十分理想的求区间和的算法,同样我们可以利用树状数组优美的区间划分方法来求一个序列的最值 约定以 num[]  表示原数组, 以 idx[] 表示索引数组, Lowbit(x)=x&(-x) 树状数组求和时通过构造数组 idx[] 使 idx[k]=sum(num[tk]), tk [k-Lowbit(k)+1,k], 使用同样的方法构造最值索引数组: 以最大值为例, 先

[nowCoder] 两个不等长数组求第K大数

给定两个有序数组arr1和arr2,在给定一个整数k,返回两个数组的所有数中第K小的数.例如:arr1 = {1,2,3,4,5};arr2 = {3,4,5};K = 1;因为1为所有数中最小的,所以返回1: arr1 = {1,2,3};arr2 = {3,4,5,6};K = 4;因为3为所有数中第4小的数,所以返回3: 要求:如果arr1的长度为N,arr2的长度为M,时间复杂度请达到O(log(min{M,N})). 这题目的难度在于时间复杂度请达到O(log(min{M,N})),参

HDU 5249 离线树状数组求第k大+离散化

KPI Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 1160    Accepted Submission(s): 488 Problem Description 你工作以后, KPI 就是你的全部了. 我开发了一个服务,取得了很大的知名度.数十亿的请求被推到一个大管道后同时服务从管头拉取请求.让我们来定义每个请求都有一个重要值.我的

树状数组求逆序数

poj 2299 树状数组求逆序数题目链接:http://poj.org/problem?id=2299 1 #include <stdio.h> 2 #include <string.h> 3 #include <iostream> 4 #include <algorithm> 5 #include <vector> 6 #include <queue> 7 #include <stack> 8 #include <

HDU 1394 Minimum Inversion Number (树状数组求逆序数)

Minimum Inversion Number Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 13942    Accepted Submission(s): 8514 Problem Description The inversion number of a given number sequence a1, a2, ..., a

一维数组求最大子数组(解决溢出问题)

一.题目要求 题目:返回一个整数数组中最大子数组的和. 要求: 要求程序必须能处理1000 个元素: 每个元素是int32 类型的: 输入一个整形数组,数组里有正数也有负数. 数组中连续的一个或多个整数组成一个子数组,每个子数组都有一个和. 求所有子数组的和的最大值.要求时间复杂度为O(n). 二.设计思想 程序在宏里面定义出了数组长度的大小,在长度超过100万的时候程序直接崩溃,其实这并不是因为结果太大导致的数值溢出,而是因为内存溢出,我们的数组是定义在程序内部的,属于局部变量,存放位置在栈上