// findSolution returns a vector of in-order moves to perform in order to reach // a solution for a given board. std::vector<BoardMove> findSolution(const Board b) { if (isSolution(b)) return std::vector<BoardMove>(); SearchHeap moveList([](float p1, float p2) -> float { return p2 - p1; }); std::set<Board> seen; moveList.insert(0.f, std::make_tuple(b, std::vector<BoardMove>())); while (!moveList.isEmpty()) { auto pair = moveList.removeTuple(); Board board = std::get<0>(pair.value); for (auto bm: board.validMoves()) { Board temp = board.doMove(bm); if (seen.find(temp) != seen.end()) continue; seen.insert(temp); std::vector<BoardMove> moves = std::get<1>(pair.value); moves.push_back(bm); int h = heuristic(temp); if (h == 0) return moves; moveList.insert(pair.priority + (h / 2.f + 0.5f), std::make_tuple(temp, moves)); } } return std::vector<BoardMove>(); }
void recursiveSolve(TreeNode *lexTree, WBCell *cell, int solutionLen, char *solutionSoFar) { // base case - if solution is of correct length and is an actual word, then print it if(strlen(solutionSoFar) == solutionLen){ if(isSolution(lexTree, solutionSoFar)){ printf("%s\n", solutionSoFar); } // else, word isn't long enough yet. Try expanding in all directions } else { int newLetterIndex = strlen(solutionSoFar); for(int i = 0; i < NUM_ADJACENT_CELLS; i++){ WBCell *nextCellPtr = cell->adjacentCells[i]; if(nextCellPtr!=NULL && !nextCellPtr->visited){ solutionSoFar[newLetterIndex]=(*nextCellPtr).value; // if new direction is a valid prefix, mark current cell as visited, // and recurse on next cell with updated solution if(isPrefix(lexTree, solutionSoFar)){ cell->visited = 1; recursiveSolve(lexTree, nextCellPtr, solutionLen, solutionSoFar); } // unwind after returning from recursion cell->visited = 0; solutionSoFar[newLetterIndex] = '\0'; } } } }
/* * By working with the problem, we can express the numbers b and c based on a. * So we go through numbers and try to find an a that makes all other * restrictions fall into place. */ long solution() { //natural numbers, so a=0 isn't an accepted solution. for(long a = 1; ; ++a) { long b = getB(a); long c = getC(a, b); if(isSolution(a, b, c)) return a*b*c; } //if it didn't find a solution return -1 as an indication of error return -1; }
void binaryprog::solveProg(){ long power = pow(2,columns); for(int i = 0; i < power; i++){ int foo[columns]; decimalTObinary(columns, i, foo); dtype sum[rows]; //check foo on feasibility by vector multiplication with the "matrix", i.e. matrix * vector //and then comparing the result with the vector "vector" for(int j = 0; j < rows; j++){ sum[j] = 0; for(int k = 0; k < columns; k++){ sum[j] += foo[k]*matrix[j][k]; } } if(isSolution(sum)) printSolution(foo); } }
//Returns the fitness score for a N calculated from a solution //If the number is a solution, returns the number of correct bits with a higher weight //If the number is not a solution, returns the number of correct bits with a lower weight value //However all weights are higher than the weight for the number of gates added later int Problem::getFitness(bitset<30> num) { if(isSolution(num)) { return (limits[limits.size()]+1)*5; } else { int count=0; for(int i=0;i<30;++i) { if(n[i] && num[i]) { ++count; } } return count*3; } }
int backtracking(short n, short v, short actualPrinters) { int i; /* rejection test */ if ( actualPrinters >= best) return 1; /* base case */ if (isSolution(n) && actualPrinters < best){ best = actualPrinters; return 1; } for(i = v + 1; i < n; i++) { havePrinter[i] = 1; /* mark as visited */ backtracking(n, i, actualPrinters + 1); /* recursive step */ havePrinter[i] = 0; /* mark as unvisited */ } return 0; }
bool SubgraphPlanarizerUML::doSinglePermutation( PlanRepLight &PG, int cc, const EdgeArray<int> *pCost, Array<edge> &deletedEdges, UMLEdgeInsertionModule &inserter, minstd_rand &rng, int &crossingNumber) { PG.initCC(cc); const int nG = PG.numberOfNodes(); const int high = deletedEdges.high(); for(int j = 0; j <= high; ++j) PG.delEdge(PG.copy(deletedEdges[j])); deletedEdges.permute(rng); ReturnType ret = inserter.callEx(PG, deletedEdges, pCost, nullptr); if(isSolution(ret) == false) return false; // no solution found, that's bad... if(pCost == nullptr) crossingNumber = PG.numberOfNodes() - nG; else { crossingNumber = 0; for(node n : PG.nodes) { if(PG.original(n) == nullptr) { // dummy found -> calc cost edge e1 = PG.original(n->firstAdj()->theEdge()); edge e2 = PG.original(n->lastAdj()->theEdge()); crossingNumber += (*pCost)[e1] * (*pCost)[e2]; } } } return true; }
Module::ReturnType PlanarSubgraphModule::callAndDelete( GraphCopy &PG, const List<edge> &preferedEdges, List<edge> &delOrigEdges, bool preferedImplyPlanar) { List<edge> delEdges; ReturnType retValue = call(PG, preferedEdges, delEdges, preferedImplyPlanar); if(isSolution(retValue)) { ListConstIterator<edge> it; for(it = delEdges.begin(); it.valid(); ++it) { edge eCopy = *it; delOrigEdges.pushBack(PG.original(eCopy)); PG.delCopy(eCopy); } } return retValue; }
Module::ReturnType SubgraphPlanarizer::doCall(PlanRep &PG, int cc, const EdgeArray<int> &cost, const EdgeArray<bool> &forbid, const EdgeArray<unsigned int> &subgraphs, int& crossingNumber) { OGDF_ASSERT(m_permutations >= 1); OGDF_ASSERT(!(useSubgraphs()) || useCost()); // ersetze durch exception handling double startTime; usedTime(startTime); if(m_setTimeout) m_subgraph.get().timeLimit(m_timeLimit); List<edge> deletedEdges; PG.initCC(cc); EdgeArray<int> costPG(PG); edge e; forall_edges(e,PG) costPG[e] = cost[PG.original(e)]; ReturnType retValue = m_subgraph.get().call(PG, costPG, deletedEdges); if(isSolution(retValue) == false) return retValue; for(ListIterator<edge> it = deletedEdges.begin(); it.valid(); ++it) *it = PG.original(*it); bool foundSolution = false; CrossingStructure cs; for(int i = 1; i <= m_permutations; ++i) { const int nG = PG.numberOfNodes(); for(ListConstIterator<edge> it = deletedEdges.begin(); it.valid(); ++it) PG.delCopy(PG.copy(*it)); deletedEdges.permute(); if(m_setTimeout) m_inserter.get().timeLimit( (m_timeLimit >= 0) ? max(0.0,m_timeLimit - usedTime(startTime)) : -1); ReturnType ret; if(useForbid()) { if(useCost()) { if(useSubgraphs()) ret = m_inserter.get().call(PG, cost, forbid, deletedEdges, subgraphs); else ret = m_inserter.get().call(PG, cost, forbid, deletedEdges); } else ret = m_inserter.get().call(PG, forbid, deletedEdges); } else { if(useCost()) { if(useSubgraphs()) ret = m_inserter.get().call(PG, cost, deletedEdges, subgraphs); else ret = m_inserter.get().call(PG, cost, deletedEdges); } else ret = m_inserter.get().call(PG, deletedEdges); } if(isSolution(ret) == false) continue; // no solution found, that's bad... if(!useCost()) crossingNumber = PG.numberOfNodes() - nG; else { crossingNumber = 0; node n; forall_nodes(n, PG) { if(PG.original(n) == 0) { // dummy found -> calc cost edge e1 = PG.original(n->firstAdj()->theEdge()); edge e2 = PG.original(n->lastAdj()->theEdge()); if(useSubgraphs()) { int subgraphCounter = 0; for(int i=0; i<32; i++) { if(((subgraphs[e1] & (1<<i))!=0) && ((subgraphs[e2] & (1<<i)) != 0)) subgraphCounter++; } crossingNumber += (subgraphCounter*cost[e1] * cost[e2]); } else crossingNumber += cost[e1] * cost[e2]; } } } if(i == 1 || crossingNumber < cs.weightedCrossingNumber()) { foundSolution = true; cs.init(PG, crossingNumber); } if(localLogMode() == LM_STATISTIC) { if(m_permutations <= 200 || i <= 10 || (i <= 30 && (i % 2) == 0) || (i > 30 && i <= 100 && (i % 5) == 0) || ((i % 10) == 0)) sout() << "\t" << cs.weightedCrossingNumber(); } PG.initCC(cc); if(m_timeLimit >= 0 && usedTime(startTime) >= m_timeLimit) { if(foundSolution == false) return retTimeoutInfeasible; // not able to find a solution... break; } } cs.restore(PG,cc); // restore best solution in PG crossingNumber = cs.weightedCrossingNumber(); PlanarModule pm; OGDF_ASSERT(pm.planarityTest(PG) == true); return retFeasible; }
Module::ReturnType SubgraphPlanarizerUML::doCall( PlanRepUML &pr, int cc, const EdgeArray<int> *pCostOrig, int &crossingNumber) { OGDF_ASSERT(m_permutations >= 1); PlanarSubgraphModule &subgraph = m_subgraph.get(); UMLEdgeInsertionModule &inserter = m_inserter.get(); unsigned int nThreads = min(m_maxThreads, (unsigned int)m_permutations); int64_t startTime; System::usedRealTime(startTime); int64_t stopTime = (m_timeLimit >= 0) ? (startTime + int64_t(1000.0*m_timeLimit)) : -1; // // Compute subgraph // if(m_setTimeout) subgraph.timeLimit(m_timeLimit); pr.initCC(cc); // gather generalization edges, which should all be in the planar subgraph List<edge> preferedEdges; for(edge e : pr.edges) { if (pr.typeOf(e) == Graph::generalization) preferedEdges.pushBack(e); } List<edge> delEdges; ReturnType retValue; if(pCostOrig) { EdgeArray<int> costPG(pr); for(edge e : pr.edges) costPG[e] = (*pCostOrig)[pr.original(e)]; retValue = subgraph.call(pr, costPG, preferedEdges, delEdges); } else retValue = subgraph.call(pr, preferedEdges, delEdges); if(isSolution(retValue) == false) return retValue; const int m = delEdges.size(); for(ListIterator<edge> it = delEdges.begin(); it.valid(); ++it) *it = pr.original(*it); // // Permutation phase // int seed = rand(); minstd_rand rng(seed); if(nThreads > 1) { // // Parallel implementation // ThreadMaster master( pr, cc, pCostOrig, delEdges, seed, m_permutations - nThreads, stopTime); Array<Worker *> worker(nThreads-1); Array<Thread> thread(nThreads-1); for(unsigned int i = 0; i < nThreads-1; ++i) { worker[i] = new Worker(i, &master, inserter.clone()); thread[i] = Thread(*worker[i]); } doWorkHelper(master, inserter, rng); for(unsigned int i = 0; i < nThreads-1; ++i) { thread[i].join(); delete worker[i]; } master.restore(pr, crossingNumber); } else { // // Sequential implementation // PlanRepLight prl(pr); Array<edge> deletedEdges(m); int j = 0; for(ListIterator<edge> it = delEdges.begin(); it.valid(); ++it) deletedEdges[j++] = *it; bool foundSolution = false; CrossingStructure cs; for(int i = 1; i <= m_permutations; ++i) { int cr; bool ok = doSinglePermutation(prl, cc, pCostOrig, deletedEdges, inserter, rng, cr); if(ok && (foundSolution == false || cr < cs.weightedCrossingNumber())) { foundSolution = true; cs.init(prl, cr); } if(stopTime >= 0 && System::realTime() >= stopTime) { if(foundSolution == false) return retTimeoutInfeasible; // not able to find a solution... break; } } cs.restore(pr,cc); // restore best solution in PG crossingNumber = cs.weightedCrossingNumber(); OGDF_ASSERT(isPlanar(pr) == true); } return retFeasible; }