求解拆分数组成固定组数的拆分方法（函数）

abnerchai · 发表于 2009-7-10 18:41:05

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？欢迎注册

×

一个老问题，但这次没有限制，求全分组。具体如下：
设有1.....30个整数存放入a[1...30]的整数数组中,初始化如下：
int a[30];
for (int i=0;i<30;i++) a[i]= i+1;

现要把此30个数分成10个组，每组固定3个数（不管数的顺序，如1，2，3 和 2， 3，1 算一样的一组）。
1）设计一个函数，打印出该30数组拆分为10组的全部可能的分组情况,每行打印一种拆分方法，以||分开各组。如：
1 2 3 ||4 5 6 ||7 8 9 ||10 11 12 ||13 14 15|| 16 17 18|| 19 20 21|| 22 23 24|| 25 26 27|| 28 29 30|| －－算一种拆分方法
.....
.....
2)该函数返回30个数拆分为10个组的所有的可能拆分数（就是返回上面多少行），这个数应该是固定的，具体多少我还没搞懂。

请指教，谢谢。

shshsh_0510 · 发表于 2009-7-10 22:47:00

2) 取最小的，然后找两个和它一组
f(n)=C(2,n-1)*f(n-3)

abnerchai · 发表于 2009-7-10 22:49:58

没明白版主的意思？能说明白些吗？取最小的是取什么最小的？

abnerchai · 发表于 2009-7-10 23:08:48

我自己写了一个函数，理论上可以实现。但是运算时间太太长了。。。。。。。。。不现实。有人给出意见吗？

＝＝＝＝＝＝＝＝＝＝＝＝Part 1 - Head.h＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
//head.h
#include<iostream>
#include<bitset>
#include<iomanip>
#include<algorithm>
#include<fstream>
#include<cstdlib>
#include<string>
#include<vector>
#include<set>
#include<map>
#include<utility>
#include<cstdlib>
#include<ctime>
#include <sstream>
#include <cmath>
//一个Group (三个数字）
struct Group {
int r1;
int r2;
int r3;
std::set<int> rSet;
void reset() {
r1 = r2 = r3 = 0;
rSet.clear();
}
void setCodes(int num1,int num2,int num3) {
r1 = num1;
r2 = num2;
r3 = num3;
rSet.clear();
rSet.insert(rSet.end(),r1);
rSet.insert(rSet.end(),r2);
rSet.insert(rSet.end(),r3);
}
Group() {
reset();
}
};
//一种折分方法
struct OneDivided{
Group group[10];
void reset() {
for(int i=0;i<10;i++) {
group[i].reset();
}
}
OneDivided(){
reset();
}
};
//求数组a中的n个数的m组合，组合的结果以整数的集合形式放入codesResult中
int
combineCodes(int a[], int n, int m, std::vector<ThreeCodes>& codesResult) const{
codesResult.clear();
//m should smaller or equal n
m = m > n ? n : m;
int* order = new int[m+1];
for(int i=0; i<=m; i++) {
order[i] = i-1; // 注意这里order[0]=-1用来作为循环判断标识
}
int count = 0;
int k = m;
bool flag = true; // 标志找到一个有效组合
while(order[0] == -1) {
if(flag) {
// 输出符合要求的组合
ThreeCodes item;
item.reset();
for(int i=1; i<=m; i++){
//std::cout << a[order[i]] << " ";
if(i==1) {
item.r1 = a[order[1]];
} else if(i==2){
item.r2 = a[order[2]];
} else if(i==3) {
item.r3 = a[order[3]];
}
}
codesResult.push_back(item);
//std::cout << std::endl;
count++;
flag = false;
}
order[k]++; // 在当前位置选择新的数字
if(order[k] == n) // 当前位置已无数字可选，回溯
{
order[k--] = 0;
continue;
}
if(k < m) // 更新当前位置的下一位置的数字
{
order[++k] = order[k-1];
continue;
}
if(k == m) {
flag = true;
}
}
delete[] order;
return count;
}

复制代码

abnerchai · 发表于 2009-7-10 23:12:10

============Part2---------main.cpp==============================
#include "head.h"
//求把30个数的数组分解为10个Group的算法
//思量是：先将30个数组合3，一共有4060个3组合。
//然后再在这4060个组合里面依次选出第1个Group，第2个Group....第10个Group
//选择的范围就是在上面组合出来的4060个3组合里面选，选第n＋1个Group的时候排除掉和
//第1 － n组合3有重复的3组合（就是只选前面没有出现的Group)来保证各个Group是互相独立的
//没有交集。
long Get30Group10(void) const {
long total = 0;
std::vector<ThreeCodes> threeCodeResult;
int howManyThreeCodeResult = 0;
int a[30];
for(int i=0;i<30;i++) a[i] = i+1;
//howManyThreeCodeResult is 4060
howManyThreeCodeResult = combineCodes(a,30,3,threeCodeResult);
std::set<int> reSet;
std::set<int> tmpSet;
std::set<int>::iterator reIter;
for(int i=0;i<howManyThreeCodeResult;i++){
//求一种分拆方式，分拆的10个Group放入oneDivided中
OneDivided oneDivided;
//选择Group0
oneDivided.group[0].setCodes(threeCodeResult[i].r1,
threeCodeResult[i].r2,
threeCodeResult[i].r3);
for(int j=0;j<howManyThreeCodeResult;j++) {
tmpSet.clear();
tmpSet.insert(tmpSet.begin(),threeCodeResult[j].r1);
tmpSet.insert(tmpSet.begin(),threeCodeResult[j].r2);
tmpSet.insert(tmpSet.begin(),threeCodeResult[j].r3);
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[0].redSet.begin(),oneDivided.group[0].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
if(reSet.size() > 0) {
//有相同
continue;
}
//选择Group1, 在选择Group1之前，先排除和Group0有重复的元素，下面其他类似
oneDivided.group[1].setCodes(threeCodeResult[j].r1,
threeCodeResult[j].r2,threeCodeResult[j].r3);
for(int k=0;k<howManyThreeCodeResult;k++) {
tmpSet.clear();
tmpSet.insert(tmpSet.begin(),threeCodeResult[k].r1);
tmpSet.insert(tmpSet.begin(),threeCodeResult[k].r2);
tmpSet.insert(tmpSet.begin(),threeCodeResult[k].r3);
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[0].redSet.begin(),oneDivided.group[0].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size0 = reSet.size();
if(size0 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[1].redSet.begin(),oneDivided.group[1].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size1 = reSet.size();
if(size1 > 0) {
//有相同
continue;
}
oneDivided.group[2].setCodes(threeCodeResult[k].r1,
threeCodeResult[k].r2,threeCodeResult[k].r3);
for(int m=0;m<howManyThreeCodeResult;m++) {
tmpSet.clear();
tmpSet.insert(tmpSet.begin(),threeCodeResult[m].r1);
tmpSet.insert(tmpSet.begin(),threeCodeResult[m].r2);
tmpSet.insert(tmpSet.begin(),threeCodeResult[m].r3);
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[0].redSet.begin(),oneDivided.group[0].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size0 = reSet.size();
if(size0 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[1].redSet.begin(),oneDivided.group[1].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size1 = reSet.size();
if(size1 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[2].redSet.begin(),oneDivided.group[2].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size2 = reSet.size();
if(size2 > 0) {
continue;
}
oneDivided.group[3].setCodes(threeCodeResult[m].r1,
threeCodeResult[m].r2,threeCodeResult[m].r3);
for(int n=0;n<howManyThreeCodeResult;n++) {
tmpSet.clear();
tmpSet.insert(tmpSet.begin(),threeCodeResult[n].r1);
tmpSet.insert(tmpSet.begin(),threeCodeResult[n].r2);
tmpSet.insert(tmpSet.begin(),threeCodeResult[n].r3);
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[0].redSet.begin(),oneDivided.group[0].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size0 = reSet.size();
if(size0 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[1].redSet.begin(),oneDivided.group[1].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size1 = reSet.size();
if(size1 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[2].redSet.begin(),oneDivided.group[2].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size2 = reSet.size();
if(size2 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[3].redSet.begin(),oneDivided.group[3].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size3 = reSet.size();
if(size3 > 0) {
continue;
}
oneDivided.group[4].setCodes(threeCodeResult[n].r1,
threeCodeResult[n].r2,threeCodeResult[n].r3);
for(int o=0;o<howManyThreeCodeResult;o++) {
tmpSet.clear();
tmpSet.insert(tmpSet.begin(),threeCodeResult[o].r1);
tmpSet.insert(tmpSet.begin(),threeCodeResult[o].r2);
tmpSet.insert(tmpSet.begin(),threeCodeResult[o].r3);
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[0].redSet.begin(),oneDivided.group[0].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size0 = reSet.size();
if(size0 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[1].redSet.begin(),oneDivided.group[1].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size1 = reSet.size();
if(size1 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[2].redSet.begin(),oneDivided.group[2].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size2 = reSet.size();
if(size2 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[3].redSet.begin(),oneDivided.group[3].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size3 = reSet.size();
if(size3 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[4].redSet.begin(),oneDivided.group[4].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size4 = reSet.size();
if(size4 > 0) {
continue;
}
oneDivided.group[5].setCodes(threeCodeResult[o].r1,
threeCodeResult[o].r2,threeCodeResult[o].r3);
for(int p=0;p<howManyThreeCodeResult;p++) {
tmpSet.clear();
tmpSet.insert(tmpSet.begin(),threeCodeResult[p].r1);
tmpSet.insert(tmpSet.begin(),threeCodeResult[p].r2);
tmpSet.insert(tmpSet.begin(),threeCodeResult[p].r3);
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[0].redSet.begin(),oneDivided.group[0].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size0 = reSet.size();
if(size0 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[1].redSet.begin(),oneDivided.group[1].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size1 = reSet.size();
if(size1 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[2].redSet.begin(),oneDivided.group[2].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size2 = reSet.size();
if(size2 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[3].redSet.begin(),oneDivided.group[3].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size3 = reSet.size();
if(size3 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[4].redSet.begin(),oneDivided.group[4].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size4 = reSet.size();
if(size4 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[5].redSet.begin(),oneDivided.group[5].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size5 = reSet.size();
if(size5 > 0) {
continue;
}
oneDivided.group[6].setCodes(threeCodeResult[p].r1,
threeCodeResult[p].r2,threeCodeResult[p].r3);
for(int s=0;s<howManyThreeCodeResult;s++) {
tmpSet.clear();
tmpSet.insert(tmpSet.begin(),threeCodeResult[s].r1);
tmpSet.insert(tmpSet.begin(),threeCodeResult[s].r2);
tmpSet.insert(tmpSet.begin(),threeCodeResult[s].r3);
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[0].redSet.begin(),oneDivided.group[0].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size0 = reSet.size();
if(size0 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[1].redSet.begin(),oneDivided.group[1].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size1 = reSet.size();
if(size1 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[2].redSet.begin(),oneDivided.group[2].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size2 = reSet.size();
if(size2 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[3].redSet.begin(),oneDivided.group[3].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size3 = reSet.size();
if(size3 > 0) {
continue;
}
//===================================Part 2 End ===============================//
//见下面（由于帖子长度有限制）

复制代码

abnerchai · 发表于 2009-7-10 23:12:36

//===================================Part 3 Start ================//
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[4].redSet.begin(),oneDivided.group[4].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size4 = reSet.size();
if(size4 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[5].redSet.begin(),oneDivided.group[5].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size5 = reSet.size();
if(size5 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[6].redSet.begin(),oneDivided.group[6].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size6 = reSet.size();
if(size6 > 0) {
continue;
}
oneDivided.group[7].setCodes(threeCodeResult[s].r1,
threeCodeResult[s].r2,threeCodeResult[s].r3);
for(int t=0;t<howManyThreeCodeResult;t++) {
tmpSet.clear();
tmpSet.insert(tmpSet.begin(),threeCodeResult[t].r1);
tmpSet.insert(tmpSet.begin(),threeCodeResult[t].r2);
tmpSet.insert(tmpSet.begin(),threeCodeResult[t].r3);
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[0].redSet.begin(),oneDivided.group[0].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size0 = reSet.size();
if(size0 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[1].redSet.begin(),oneDivided.group[1].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size1 = reSet.size();
if(size1 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[2].redSet.begin(),oneDivided.group[2].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size2 = reSet.size();
if(size2 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[3].redSet.begin(),oneDivided.group[3].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size3 = reSet.size();
if(size3 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[4].redSet.begin(),oneDivided.group[4].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size4 = reSet.size();
if(size4 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[5].redSet.begin(),oneDivided.group[5].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size5 = reSet.size();
if(size5 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[6].redSet.begin(),oneDivided.group[6].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size6 = reSet.size();
if(size6 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[7].redSet.begin(),oneDivided.group[7].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size7 = reSet.size();
if(size7 > 0) {
continue;
}
oneDivided.group[8].setCodes(threeCodeResult[t].r1,
threeCodeResult[t].r2,threeCodeResult[t].r3);
for(int u=0;u<howManyThreeCodeResult;u++) {
tmpSet.clear();
tmpSet.insert(tmpSet.begin(),threeCodeResult[u].r1);
tmpSet.insert(tmpSet.begin(),threeCodeResult[u].r2);
tmpSet.insert(tmpSet.begin(),threeCodeResult[u].r3);
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[0].redSet.begin(),oneDivided.group[0].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size0 = reSet.size();
if(size0 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[1].redSet.begin(),oneDivided.group[1].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size1 = reSet.size();
if(size1 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[2].redSet.begin(),oneDivided.group[2].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size2 = reSet.size();
if(size2 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[3].redSet.begin(),oneDivided.group[3].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size3 = reSet.size();
if(size3 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[4].redSet.begin(),oneDivided.group[4].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size4 = reSet.size();
if(size4 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[5].redSet.begin(),oneDivided.group[5].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size5 = reSet.size();
if(size5 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[6].redSet.begin(),oneDivided.group[6].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size6 = reSet.size();
if(size6 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[7].redSet.begin(),oneDivided.group[7].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size7 = reSet.size();
if(size7 > 0) {
continue;
}
reSet.clear();
reIter = reSet.begin();
set_intersection(oneDivided.group[8].redSet.begin(),oneDivided.group[8].redSet.end(),
tmpSet.begin(), tmpSet.end(),
inserter(reSet, reIter));
int size8 = reSet.size();
if(size8 > 0) {
continue;
}
oneDivided.group[9].setCodes(threeCodeResult[u].r1,
threeCodeResult[u].r2,threeCodeResult[u].r3);
for(int rr=0;rr<10;rr++) {
std::cout << oneDivided.group[rr].r1 << " "
<< oneDivided.group[rr].r2 << " "
<< oneDivided.group[rr].r3 << " "
<< "||";
}
total++;
}//end for(u)
}//end for(t)
}//end for(s)
}//end for(p);
}//end for(o)
}//end for(n)
}//end for(m)
} //end for(k)
}//end for(j)
}//end for (i)
return total;
}
void main(void) {
long total = Get30Group10();
std::cout << "Total: " << total;
}

复制代码

abnerchai · 发表于 2009-7-10 23:15:55

以上程序在gcc＋STL下面正确编译并运行。但是发现运算时间太长太长了。。。。。。。。。。。。。。。。

求帮助。。。。。。。。。。。

shshsh_0510 · 发表于 2009-7-12 10:43:24

1-30，最小的是1，先将1与某两个元素分为一组，需要从剩下的29个中取两个，故有C(2,29)种方法。
接下来需要将其他的27个分组。
于是f(30)=C(2,29)*f(27)=C(2,29)*C(2,26)*f(24)=...=C(2,29)*C(2,26)*...*C(2,5)*C(2,2)=1208883745669600000
如果你的程序每秒输出1000种的话,你需要大约40万个世纪

northwolves · 发表于 2009-7-15 16:29:58

30!/10!/(3!)^10=1208883745669600000

数学星空 · 发表于 2009-7-15 17:21:56

northwolves分析正确,shshsh_0510还需要在结果上除以10!

账号		自动登录	找回密码
密码			欢迎注册

[讨论] 求解拆分数组成固定组数的拆分方法（函数）

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。