void backtrack(vector<int>& nums,int k, int n) { if (is_a_solution(nums, k ,n )) process_solution(nums); else { vector<int> cand; construct_cand(nums, k, n, cand); for (int i = 0; i < cand.size(); i++) { nums.push_back(cand.at(i)); backtrack(nums, k, n); nums.pop_back(); } } }
void backtrack(int a[], int k, int input){ int candidates[MAX+1]; int num_candidates = 0; if(correct_solution(a, k, input)) process_solution(a, input); else { k++; construct_candidates(a, k, input, candidates, &num_candidates); int i = 0; for(; i < num_candidates; i++){ a[k-1] = candidates[i]; backtrack(a, k, input); } } }
void backtrack(int a[], int k, int input) { int c[MAXCANDIDATES]; /* candidates for next position */ int ncandidates; /* next position candidate count */ if (is_a_solution(a,k,input)) process_solution(a,k,input); else { k = k+1; construct_candidates(a,k,input,c,ncandidates); for(int i = 0; i < ncandidates; i++) { a[k] = c[i]; backtrack(a,k,input); if (finished) return; /* terminate early */ } } }
void backtrack(int a[], int k, int n,char items[]) { int c[MAXCANDIDATES]; /* candidates for next position */ int ncandidates; /* next position candidate count */ int i; /* counter */ if (is_a_solution(a, k, n)) process_solution(a, k, items); else { k = k+1; construct_candidates(a, k, n, c, &ncandidates); for (i=0; i<ncandidates; i++) { a[k] = c[i]; backtrack(a, k, n,items); } } }
void backtrack(int dms) { int ncandidate, i, tmp; int candidates[SIZE]; if (dms == cnt) process_solution(); else { construct_candidates(dms, candidates, &ncandidate); for (i = 0; i < ncandidate; ++i) { tmp = candidates[i]; solution[dms] = tmp; used[tmp] = 2; /* set */ backtrack(dms + 1); if (finished) return ; used[tmp] = 1; /* unset */ } } }
void backtrack(int a[], int k, int n) { int c[N]; int candidates; if(check_solution(a,k,n)) process_solution(a,k); else{ k=k+1; construct_candidates(a,k,c,&candidates); for(int i=0;i<candidates;i++){ a[k]=c[i]; backtrack(a,k,n); /* if(FALSE) return; */ } } }
static void backtrack(int a[], int k, int n) { int c[CANDIDATES_MAX + 1]; int nr_candidates; int i; if (is_a_solution(a, k, n)) process_solution(a, k); else { k += 1; generate_candidates(a, k, n, c, &nr_candidates); for (i = 0; i < nr_candidates; i++) { a[k] = c[i]; backtrack(a, k, n); if (finished) return; } } }
void backtrack(int a[], int k, int input) { int c[MAXCANDIDATES], ncandidates, i; dprintf("backtrack(k=%d, in=%d)...a[", k, input); for (int i = 1; i <= k; ++i) dprintf("%d, ", a[i]); dprintf("]\n"); if (is_a_solution(a, k, input)) process_solution(a, k); else { k++; construct_candidates(a, k, input, c, &ncandidates); dprintf("process %d candidates\n", ncandidates); for (i = 0; i < ncandidates; i++) { a[k] = c[i]; backtrack(a, k, input); dprintf("after call to backtrack for k = %d, i = %d\n", k, i); if (finished) return; } } }
void backtrack(int a[], int k, int input) { int c[MAXCANDIDATES]; int ncandidates; int i; dbg_log(1, "backtrack - enter k %d\n", k); if (is_a_solution(a, k, input)) process_solution(a, k); else { k++; construct_candidates(a, k, input, c, &ncandidates); dbg_log(1, "process %d candidates\n", ncandidates); for (i = 0; i < ncandidates; i++) { a[k] = c[i]; backtrack(a, k, input); if (finished) return; } } }
void backtrack(int a[], int k, data input) { int c[MAXCANDIDATES]; /* candidates for next position */ int ncandidates; /* next position candidates count */ int i; if (is_a_solution(a, k, input)) process_solution(a, k, input); else { ++k; construct_candidates(a, k, input, c, &ncandidates); for (i=0; i<ncandidates; ++i) { a[k] = c[i]; make_move(a, k, input); backtrack(a, k, input); unmake_move(a, k, input); if (finished) return; } } }
void generate_subsequences(const std::string& from , int index , std::string& to , std::unordered_set<std::string>& subsequences) { if(be_a_solution(from, index)) { process_solution(to, subsequences); } else { //construct_candidates char candidates[2] = {from[index], '\0'}; int sz=to.size(); for(size_t i=0; i<2; ++i) { if(candidates[i]!='\0') to.push_back(candidates[i]); //make_move generate_subsequences(from, index+1, to, subsequences); unmake_move(to, sz); } } }
inline void EnumerationBase::enumerate_recursive( EnumerationBase::opts<kk, kk_start, dualenum, findsubsols, enable_reset>) { enumf alphak = x[kk] - center[kk]; enumf newdist = partdist[kk] + alphak * alphak * rdiag[kk]; if (!(newdist <= partdistbounds[kk])) return; ++nodes; alpha[kk] = alphak; if (findsubsols && newdist < subsoldists[kk]) { subsoldists[kk] = newdist; process_subsolution(kk, newdist); } if (kk == 0) { if (newdist > 0.0 || !is_svp) process_solution(newdist); } else if (enable_reset && kk < reset_depth) // in CVP, below the max GS vector, we reset the partial distance { reset(newdist, kk); return; } else { partdist[kk - 1] = newdist; if (dualenum) { for (int j = center_partsum_begin[kk]; j > kk - 1; --j) center_partsums[kk - 1][j] = center_partsums[kk - 1][j + 1] - alpha[j] * mut[kk - 1][j]; } else { for (int j = center_partsum_begin[kk]; j > kk - 1; --j) center_partsums[kk - 1][j] = center_partsums[kk - 1][j + 1] - x[j] * mut[kk - 1][j]; } if (center_partsum_begin[kk] > center_partsum_begin[kk - 1]) center_partsum_begin[kk - 1] = center_partsum_begin[kk]; center_partsum_begin[kk] = kk; center[kk - 1] = center_partsums[kk - 1][kk]; roundto(x[kk - 1], center[kk - 1]); dx[kk - 1] = ddx[kk - 1] = (((int)(center[kk - 1] >= x[kk - 1]) & 1) << 1) - 1; } while (true) { FPLLL_TRACE("Level k=" << kk << " dist_k=" << partdist[kk] << " x_k=" << x[kk] << " newdist=" << newdist << " partdistbounds_k=" << partdistbounds[kk]); enumerate_recursive(opts<kk - 1, kk_start, dualenum, findsubsols, enable_reset>()); if (partdist[kk] != 0.0) { x[kk] += dx[kk]; ddx[kk] = -ddx[kk]; dx[kk] = ddx[kk] - dx[kk]; enumf alphak2 = x[kk] - center[kk]; enumf newdist2 = partdist[kk] + alphak2 * alphak2 * rdiag[kk]; if (!(newdist2 <= partdistbounds[kk])) return; ++nodes; alpha[kk] = alphak2; if (kk == 0) { if (newdist2 > 0.0 || !is_svp) process_solution(newdist2); } else { partdist[kk - 1] = newdist2; if (dualenum) center_partsums[kk - 1][kk - 1 + 1] = center_partsums[kk - 1][kk - 1 + 1 + 1] - alpha[kk - 1 + 1] * mut[kk - 1][kk - 1 + 1]; else center_partsums[kk - 1][kk - 1 + 1] = center_partsums[kk - 1][kk - 1 + 1 + 1] - x[kk - 1 + 1] * mut[kk - 1][kk - 1 + 1]; if (kk > center_partsum_begin[kk - 1]) center_partsum_begin[kk - 1] = kk; center[kk - 1] = center_partsums[kk - 1][kk - 1 + 1]; roundto(x[kk - 1], center[kk - 1]); dx[kk - 1] = ddx[kk - 1] = (((int)(center[kk - 1] >= x[kk - 1]) & 1) << 1) - 1; } } else { ++x[kk]; enumf alphak2 = x[kk] - center[kk]; enumf newdist2 = partdist[kk] + alphak2 * alphak2 * rdiag[kk]; if (!(newdist2 <= partdistbounds[kk])) return; ++nodes; alpha[kk] = alphak2; if (kk == 0) { if (newdist2 > 0.0 || !is_svp) process_solution(newdist2); } else { partdist[kk - 1] = newdist2; if (dualenum) center_partsums[kk - 1][kk - 1 + 1] = center_partsums[kk - 1][kk - 1 + 1 + 1] - alpha[kk - 1 + 1] * mut[kk - 1][kk - 1 + 1]; else center_partsums[kk - 1][kk - 1 + 1] = center_partsums[kk - 1][kk - 1 + 1 + 1] - x[kk - 1 + 1] * mut[kk - 1][kk - 1 + 1]; if (kk > center_partsum_begin[kk - 1]) center_partsum_begin[kk - 1] = kk; center[kk - 1] = center_partsums[kk - 1][kk - 1 + 1]; roundto(x[kk - 1], center[kk - 1]); dx[kk - 1] = ddx[kk - 1] = (((int)(center[kk - 1] >= x[kk - 1]) & 1) << 1) - 1; } } } }
template <bool dualenum, bool findsubsols, bool enable_reset> void EnumerationBase::enumerate_loop() { if (k >= k_end) return; for (int i = 0; i < k_end; ++i) { center_partsum_begin[i + 1] = k_end - 1; center_partsums[i][k_end] = center_partsum[i]; } partdist[k_end] = 0.0; // needed to make next_pos_up() work properly nodes -= k_end - k; k = k_end - 1; #ifdef FPLLL_WITH_RECURSIVE_ENUM enumerate_recursive_dispatch<dualenum, findsubsols, enable_reset>(k); return; #endif finished = false; while (!finished) { enumf alphak = x[k] - center[k]; enumf newdist = partdist[k] + alphak * alphak * rdiag[k]; FPLLL_TRACE("Level k=" << k << " dist_k=" << partdist[k] << " x_k=" << x[k] << " newdist=" << newdist << " partdistbounds_k=" << partdistbounds[k]); if (newdist <= partdistbounds[k]) { ++nodes; alpha[k] = alphak; if (findsubsols && newdist < subsoldists[k]) { subsoldists[k] = newdist; process_subsolution(k, newdist); } --k; if (k < 0) { if (newdist > 0.0 || !is_svp) process_solution(newdist); finished = !next_pos_up(); continue; } if (enable_reset && k < reset_depth) // in CVP, below the max GS vector, we reset the partial distance { reset(newdist, k); finished = !next_pos_up(); continue; } if (dualenum) { for (int j = center_partsum_begin[k + 1]; j > k; --j) center_partsums[k][j] = center_partsums[k][j + 1] - alpha[j] * mut[k][j]; } else { for (int j = center_partsum_begin[k + 1]; j > k; --j) center_partsums[k][j] = center_partsums[k][j + 1] - x[j] * mut[k][j]; } center_partsum_begin[k] = max(center_partsum_begin[k], center_partsum_begin[k + 1]); center_partsum_begin[k + 1] = k + 1; enumf newcenter = center_partsums[k][k + 1]; center[k] = newcenter; partdist[k] = newdist; roundto(x[k], newcenter); dx[k] = ddx[k] = (((int)(newcenter >= x[k]) & 1) << 1) - 1; } else { finished = !next_pos_up(); } } }