int Board::findPath(Crossroad* start, Crossroad* end, std::queue<Crossroad*>* pathfinder, PathType pathType) { if ((end->constructed == FREE || end->constructed == FLAG) && (start->constructed == FLAG || (start->constructed == ROAD && buildingRoad == true))) { clock_t start_time = clock(); int return_value = breadthFirst(start, end, pathfinder, pathType); /* // for a-starish std::priority_queue<Crossroad*, std::vector<Crossroad*>,test> priority; int return_value = aStarish(start, end, &priority, pathType); */ fprintf(stderr, "ms %i \n", timeDiff_ms(start_time)); if (end->previous != NULL) { Crossroad* current = end; while (current != start) { pathfinder->push(current); Crossroad* temp = current->previous; current->previous = NULL; current = temp; } pathfinder->push(start); } return return_value; } else return -1; }
int readGraph(){ int startVertex = 0 ; int n = 0 ; scanf("%d",&startVertex); scanf("%d",&n); int ** matrix = readIn(n); printMatrix(matrix,n); struct queue* q = (struct queue*)malloc(sizeof(struct queue)); init(q); struct stack stk; initialize(&stk); int * visited = (int *) malloc(sizeof(int)*n); int i = 0 ; for ( i = 0 ; i < n ; i++ ) visited[i] = 0 ; printf("\nBreadth First: "); breadthFirst(matrix,startVertex,n,q); printf("\nDepth First: "); depthFirst(matrix,startVertex,n,stk); printf("\nDepth First: "); depthCaller(matrix,n); printf("\n"); free(q); free(visited); free(matrix); return 0 ; }
int Board::breadthFirst(Crossroad* start, Crossroad* end, std::queue<Crossroad*>* pathfinder, PathType pathType) { /*system("pause"); //DEBUG paintThySelf(30); //DEBUG al_flip_display(); //DEBUG*/ fprintf(stderr, "distance %i \n", (int) (start->calculateDistance(end))); if (start == end) { while (!pathfinder->empty()) { Crossroad* temp = pathfinder->front(); temp->visited = false; temp->previous = NULL; pathfinder->pop(); } //start->previous = NULL; start->previous->pathing = true; return start->transportationCost(); } else { const Directions directions[6] = {NORTH_WEST, NORTH_EAST, EAST, SOUTH_EAST, SOUTH_WEST, WEST }; for (int i = 0; i < 6; ++i) { Crossroad *node = start->getNeighbour(directions[i]); if (pathCriteria(pathType, start->roads[i], end, node)) { //fprintf(stderr, "E\n"); //DEBUG //start->east->built = ROAD; //DEBUG node->previous = start; pathfinder->push(node); node->visited = true; } } if (pathfinder->empty()) { return -1; } //paintThySelf(30); //DEBUG //al_flip_display(); //DEGUB Crossroad* current = pathfinder->front(); pathfinder->pop(); int returnvalue = breadthFirst(current, end, pathfinder, pathType); if (start->pathing) { start->pathing = false; if(start->previous != NULL) start->previous->pathing = true; } else start->previous = NULL; current->visited = false; return returnvalue; } }
int maxFlow(struct node * graph[], int from ,int to, int nV) { struct node * resgraph[nV]; struct node * temp; int i, j, temp_weight; int parent[nV]; int max_flow = 0, path_flow; for(i = 0; i < nV; i++) { resgraph[i] = NULL; } for(i = 0; i < nV; i++) { temp = graph[i]; while(temp != NULL) { addEdge(&resgraph[i], temp->toNode, temp->weight); temp = temp->next; } } while(breadthFirst(resgraph, from, to, nV, parent)) { j = to; path_flow = MAX; while(j != from) { i = parent[j]; temp_weight = weight(resgraph, i ,j, nV); j = i; if(path_flow < temp_weight) path_flow = path_flow; else path_flow = temp_weight; } j = to; while(j != from) { i = parent[j]; updateWeight(resgraph, i, j, -path_flow); updateWeight(resgraph, j, i, path_flow); j = i; } max_flow += path_flow; } return max_flow; }
/** * Run multiple test. * @param transaction_list List of itemset and expression value. * @param trans4lcm File name for argument of LCM program. This file is made in this method. * @param threshold The statistical significance threshold. * @param set_method The procedure name for calibration p-value (fisher/u_test). * @param max_comb The maximum arity limit. * @param outlog File name for logging. * @param alternative hypothesis, 1 -> greater, 0 -> two sided, -1 -> less * @param max_lambda Return value of maximum lambda. * @return */ int LampCore::runMultTest(const std::vector<Transaction*>& transaction_list, std::string& trans4lcm, double threshold, std::string& set_method, int max_comb, std::ostream& outlog, int alternative, double max_lambda) { int lam_star = 1; double k = -1; try { if (set_method.compare("fisher") == 0) { func_f = new Functions4fisher(transaction_list, std::abs(alternative)); } else if (set_method.compare("u_test") == 0) { func_f = new Functions4u_test(transaction_list, alternative); } else if (set_method.compare("chi") == 0) { func_f = new Functions4chi(transaction_list, std::abs( alternative)); } else { throw std::string("Error: choose \"fisher\", \"chi\" or \"u_test\" by using -p option."); } double lam = max_lambda; // check a MASL of max_lambda double n1 = 0.0; if (std::find(BINARY_METHODS.begin(), BINARY_METHODS.end(), set_method) != BINARY_METHODS.end()) { n1 = func_f->sumValue(); if (n1 < max_lambda) { max_lambda = int( n1 ); lam = int( n1 ); } } fre_pattern->makeFile4Lem(transaction_list, trans4lcm); // make itemset file for lcm // If Fisher's exact test or chi-square test is used for computing P-value, // LCM-LAMP is run to find optimal lambda. if (set_method == "fisher") { int neg_size = func_f->getAllSize() - func_f->getN1(); n1 = std::min( n1, (double)neg_size ); // # of positives == # of negatives, and two.sided hypothesis test. if (( func_f->getN1() == neg_size ) && (alternative == 0)) { lam_star = depthFirst( trans4lcm, max_comb, n1, 0.5*threshold, 1 ); } else { lam_star = depthFirst( trans4lcm, max_comb, n1, threshold, 1 ); } } else if (set_method == "chi") { int neg_size = func_f->getAllSize() - func_f->getN1(); n1 = std::min( n1, (double)neg_size ); // two-sided hypothesis test if (alternative == 0) { lam_star = depthFirst( trans4lcm, max_comb, n1, 0.5*threshold, 2 ); } // one-sided else { lam_star = depthFirst( trans4lcm, max_comb, n1, threshold, 2 ); } } // If Mann-Whitney U test of Chi-square test is used, // LAMP ver 1. is run for computing the optimal lambda. else { // two-sided hypothesis test if (alternative == 0) { lam_star = breadthFirst( trans4lcm, max_comb, 0.5*threshold, lam, outlog ); } // one-sided hypothesis test else { lam_star = breadthFirst( trans4lcm, max_comb, threshold, lam, outlog ); } } fre_pattern->frequentPatterns( trans4lcm, lam_star, max_comb ); // P_lambda* at line 13 k = fre_pattern->getTotal( lam_star ); } catch (std::string &msg) { throw msg; } catch (...) { throw std::string("Error: An unexpected error occurred while trying multiple test."); } // multiple test by using k and lambda_star outlog << "finish calculation of K: " << k << std::endl; // If lam_star > max_lambda, m_lambda set to max_lambda. // This case cause when optimal solution is found at first step. outlog << lam_star << std::endl; if (max_lambda < lam_star) lam_star = max_lambda; return lam_star; }