结合3组的全套组合

Question

我需要生成组合三个不同子集的完整组合：

• 设置1 ：从13个元素的向量中选择任意4个数字。
• 设置2 ：从3个元素的向量中选择任意2个数字。
• 设置3 ：从9个元素的向量中选择任意2个数字。

示例：对于集合A，来自4的向量的样本3（H = 3和L = 4），对于集合B，H = 2L = 3，对于集合B，H = 2L = 4：

           4    4   4
           3    4   4
           3    3   4
           3    3   3
           2    4   4
           2    3   4
           2    3   3
           2    2   4
Set A =    2    2   3
           2    2   2
           1    4   4
           1    3   4
           1    3   3
           1    2   4
           1    2   3
           1    2   2
           1    1   4
           1    1   3
           1    1   2
           1    1   1

           3    3
           2    3
Set B =    2    2
           1    3
           1    2
           1    1

           4    4
           3    4
           3    3
           2    4
Set C =    2    3
           2    2
           1    4
           1    3
           1    2
           1    1

[Set A] = [20 x 3]，[Set B] = [6 x 2]，[Set C] = [10 x 2]。然后我需要从这三组中获得所有可能的组合：AllComb = [Set A] x [Set B] x [Set C] = [1200 x 8]。 AllComb矩阵将如下所示：

4   4   4   |   3   3   |   4   4
4   4   4   |   3   3   |   3   4
4   4   4   |   3   3   |   3   3
4   4   4   |   3   3   |   2   4
4   4   4   |   3   3   |   2   3
4   4   4   |   3   3   |   2   2
4   4   4   |   3   3   |   1   4
4   4   4   |   3   3   |   1   3
4   4   4   |   3   3   |   1   2
4   4   4   |   3   3   |   1   1
4   4   4   |   2   3   |   4   4
4   4   4   |   2   3   |   3   4
4   4   4   |   2   3   |   3   3
4   4   4   |   2   3   |   2   4
4   4   4   |   2   3   |   2   3
                 .
                 .
                 .
1   1   1   |   1   1   |   1   1

不幸的是我不能使用相同的数字，因为我需要替换这样的数字：

• 对于Set A：1 = 10,2 = 25,3 = 30和4 = 45
• 对于Set B：1 = 5,2 = 20和3 = 35
• 对于Set C：1 = 10,2 = 20,3 = 30和4 = 50

有什么想法吗？真实案例集通常会导致AllComb矩阵〜[491 400 x 8]，因此很快就会接受矢量化解决方案。

注意：每个集合都使用以下代码获得：

a = combnk(1:H+L-1, H);
b = cumsum([a(:,1)  diff(a,[],2) - 1],2);

什么是H和L？

H是MultiheadWeigher（MHW）机器的料斗。我有H=8的MHW，我需要在每个料斗中提供一些材料。如果我只需要提供一种类型的材料，则所有可能的组合都是(L+H-1)!/(H!(L-1)!)，并使用上面的代码（a和b）计算它们。现在，假设有3种不同的产品，那么我们有4个产品A的料斗，2个用于B，2个用于C.产品A在前4个料斗中可以假设值10:10:130，产品B 10:10:30和c 10:10:90。然后步骤数为A L=13，B L=3和C L=9

Answer 1

我想这可以进一步优化，但这会产生AllComb：

H=3;
L=4;
a = combnk(1:H+L-1, H);
b = cumsum([a(:,1)  diff(a,[],2) - 1],2);
H=2;
L=3;
c = combnk(1:H+L-1, H);
d = cumsum([c(:,1)  diff(c,[],2) - 1],2);
H=2;
L=4;
e = combnk(1:H+L-1, H);
f = cumsum([e(:,1)  diff(e,[],2) - 1],2);
u=[];
for k=1:10
u=vertcat(u,d);
end
u=sortrows(u,[1 2]);
v=[];
for k=1:6
v= vertcat(v,f);
end
w= [u,v];
v=[];
for k=1:20
 v= vertcat(v,w);
end
u=[];
for k=1:60
 u = vertcat(u,b);
end
u=sortrows(u,[1 2 3]);
AllComb= [u,v];

此处b,d和f是您的3套。然后我循环遍历d和f中的排列数并复制它们以便构造所有可能性。其中一个是排序的，然后我用新的矩阵w写它们。使用集合A（b）和这个新构造的矩阵重复该过程。最终导致AllComb。

Answer 2

你基本上需要找到

每集
1. Combinations with repetition;
2. 第1阶段结果的“多 - variations”（我不知道这个名称是否正确）。

两个阶段都可以使用here取得的或多或少相同的逻辑来解决。

%// Stage 1, set A
LA = 4;
HA = 3;
SetA = cell(1,HA);
[SetA{:}] = ndgrid(1:LA);
SetA = cat(HA+1, SetA{:});
SetA = reshape(SetA,[],HA);
SetA = unique(sort(SetA(:,1:HA),2),'rows');

%// Stage 1, set B
LB = 3;
HB = 2;
SetB = cell(1,HB);
[SetB{:}] = ndgrid(1:LB);
SetB = cat(HB+1, SetB{:});
SetB = reshape(SetB,[],HB);
SetB = unique(sort(SetB(:,1:HB),2),'rows');

%// Stage 1, set C
LC = 4;
HC = 2;
SetC = cell(1,HC);
[SetC{:}] = ndgrid(1:LC);
SetC = cat(HC+1, SetC{:});
SetC = reshape(SetC,[],HC);
SetC = unique(sort(SetC(:,1:HC),2),'rows');

%// Stage 2
L = 3; %// number of sets
result = cell(1,L);
[result{:}] = ndgrid(1:size(SetA,1),1:size(SetB,1),1:size(SetC,1));
result = cat(L+1, result{:});
result = reshape(result,[],L);
result = [ SetA(result(:,1),:) SetB(result(:,2),:) SetC(result(:,3),:) ];
result = flipud(sortrows(result)); %// put into desired order

这给出了

result =
     4     4     4     3     3     4     4
     4     4     4     3     3     3     4
     4     4     4     3     3     3     3
     4     4     4     3     3     2     4
     4     4     4     3     3     2     3
     4     4     4     3     3     2     2
     4     4     4     3     3     1     4
     4     4     4     3     3     1     3
     4     4     4     3     3     1     2
     4     4     4     3     3     1     1
     4     4     4     2     3     4     4
     4     4     4     2     3     3     4
     4     4     4     2     3     3     3
     4     4     4     2     3     2     4
     4     4     4     2     3     2     3
     4     4     4     2     3     2     2
     4     4     4     2     3     1     4
     4     4     4     2     3     1     3
     4     4     4     2     3     1     2
     ...