int Solve(vector<vector<pii> >& __ans,int m,vector<int> input){
int tst = input.size(),t = 0,N= 0;
for(int i = 0; i < tst; i++){
int value = input[i];
allocat(N,value);
N += value;
}
solve(m,N);
__ans.resize(col);
for(int i = 0; i < col; i++){
for(int j = 0; j < m; j++){
__ans[i].push_back(ans[i][j]);
}
}
return 1;
}
int Solve(vector<vector<pii> >& __ans,int loc_coln,vector<int> input){
coln = loc_coln;
int t = 0,myn = 0;
base = 0;
int tst = input.size();
for(int i = 0; i < tst; i++){
int value = input[i];
myn += value/2;
// 使用固定轮转法确定比赛
allocat(base,value);
base += value;
}
tight_col = 0;
if(coln < 3) tight_col = 1;
if(coln == 3 && base == 8) tight_col = 1;
cntn = base;
int sum = 0;
for(int i = 0; i < len; i++) sum += ANS[i].size();
tmpn = min(coln,myn);
rown = sum / tmpn + !!(sum % tmpn);
TMP = !!((cntn-1) % coln) * rown;
bool myflag = 0;
for( EPS = 2;; EPS++){
// 逐步放宽EPS值的限制
memset(conf,0,sizeof(conf));
flag = 0;
init();
if(!myflag) best = 10000;
dfs(0,0,0);
if(myflag) break;
if(best != 10000) {
if(flag || best == TMP) break;
else myflag = 1;
}
}
__ans.resize(rown);
for(int i = 0; i < rown; i++){
for(int j = 0; j < coln; j++){
__ans[i].push_back(last_ans[i][j]);
}
}
return 1;
}
int main(int argc, char* argv[])
{
std::shared_ptr<Empty> blank;
std::shared_ptr<Program> prg(new Program());
std::shared_ptr<SharedDecl> shDecl1(new SharedDecl("y", blank));
prg->Add(shDecl1);
std::shared_ptr<Node> initX(new Atom("2"));
std::shared_ptr<SharedDecl> shDecl2(new SharedDecl("x", initX));
prg->Add(shDecl2);
std::shared_ptr<Sub> sub1(new Sub("Main"));
sub1->AddParam("a");
sub1->AddParam("b");
prg->Add(sub1);
std::shared_ptr<Atom> atomA(new Atom("a"));
std::shared_ptr<Atom> atomB(new Atom("b"));
std::shared_ptr<BinaryOp> initRes(new BinaryOp("add", atomA, atomB));
std::shared_ptr<VarDecl> resDecl(new VarDecl("res", initRes));
sub1->Add(resDecl);
std::shared_ptr<Atom> atom3i(new Atom("3"));
std::shared_ptr<Atom> atom5i(new Atom("5"));
std::shared_ptr<BinaryOp> newParam(new BinaryOp("add", atom3i, atom5i));
std::shared_ptr<Allocation> allocat(new Allocation(newParam));
std::shared_ptr<Atom> atomArr(new Atom("arr"));
std::shared_ptr<Assignation> asignNew3(new Assignation(atomArr, allocat));
sub1->Add(asignNew3);
std::shared_ptr<Atom> atomArrBis(new Atom("arr"));
std::shared_ptr<Deallocation> deallocat(new Deallocation(atomArrBis));
sub1->Add(deallocat);
std::shared_ptr<Atom> atomC(new Atom("res"));
std::shared_ptr<BinaryOp> subCsumAB(new BinaryOp("substract", atomC, initRes));
std::shared_ptr<Assignation> incC(new Assignation(atomC, subCsumAB));
sub1->Add(incC);
std::shared_ptr<Atom> atom0(new Atom("0"));
std::shared_ptr<BinaryOp> cond1cond(new BinaryOp("equals", atomC, atom0));
std::shared_ptr<If> cond1(new If(cond1cond, "10", "20"));
sub1->Add(cond1);
std::shared_ptr<Atom> atom1(new Atom("1"));
std::shared_ptr<Atom> atom10(new Atom("10"));
std::shared_ptr<For> for1(new For("i", atom1, atom10, atom1));
sub1->Add(for1);
std::shared_ptr<BinaryOp> addC1(new BinaryOp("add", atomC, atom1));
std::shared_ptr<Assignation> incResActually(new Assignation(atomC, addC1));
for1->Add(incResActually);
std::shared_ptr<Loop> loop1(new Loop(cond1cond));
loop1->Add(for1); // don't double reference ever in practice...
loop1->Add(addC1);
sub1->Add(loop1);
std::shared_ptr<Call> call1(new Call("testFun", ""));
call1->AddParam(atomA);
call1->AddParam(addC1);
sub1->Add(call1);
std::shared_ptr<Return> ret1(new Return(atom0));
sub1->Add(ret1);
XMLDumpVisitor v;
prg->Accept(&v);
return 0;
}
