tree *delete_node(tree *t, int val){ if(t == NULL) return NULL; if(val < t -> data) t -> left = delete_node(t -> left, val); else if(val > t -> data) t -> right = delete_node(t -> right, val); else { if(t -> left == NULL) { tree *temp = t -> right; free(t); return temp; } else if(t -> right == NULL) { tree *temp = t -> left; free(t); return temp; } else{ tree *temp = findMinimum(t -> right); t -> data = temp -> data; t -> right = delete_node(t -> right, temp -> data); } } return t; }
/** * Get the label. * @return Current label. */ size_t CompositeCluster::getLabel() const { findMinimum(); if (!m_label.is_initialized()) { throw std::runtime_error( "No child IClusters. CompositeCluster::getLabel() is not supported."); } else { return m_label.get(); // Assumes all are uniform. } }
void findNextPermutation(char str[]) { int i,index1,index2; for(i=strlen(str)-1;i>=0;i--) if(str[i-1]<str[i]) break; index1=i-1; index2=findMinimum(str,index1); swap(str,index1,index2); qsort(str+index1+1,strlen(str)-index1-1,sizeof(char),compare); }
Error_t CDtw::process(float **ppfDistanceMatrix) { if (!m_bIsInitialized) return kNotInitializedError; if (!ppfDistanceMatrix) return kFunctionInvalidArgsError; float fFirstColCost = 0; //!< variable that will only contain the cost of the first column (for the current row to be processed) // initialize CVectorFloat::setZero(m_apfCost[kRowNext], m_aiMatrixDimensions[kCol]); m_apfCost[kRowCurr][0] = ppfDistanceMatrix[0][0]; fFirstColCost = ppfDistanceMatrix[0][0]; m_ppePathIdx[0][0] = kDiag; for (int j = 1; j < m_aiMatrixDimensions[kCol]; j++) { m_apfCost[kRowCurr][j] = m_apfCost[kRowCurr][j-1] + ppfDistanceMatrix[0][j]; m_ppePathIdx[0][j] = kHoriz; } for (int i = 1; i < m_aiMatrixDimensions[kRow]; i++) { m_ppePathIdx[i][0] = kVert; } // compute cost 'matrix' (we only use two rows here) and store backtracking path for (int i = 1; i < m_aiMatrixDimensions[kRow]; i++) { // init the variables we need for the current row (remember the cost in the first column, and then increment it) m_apfCost[kRowCurr][0] = fFirstColCost; fFirstColCost += ppfDistanceMatrix[i][0]; m_apfCost[kRowNext][0] = fFirstColCost; for (int j = 1; j < m_aiMatrixDimensions[kCol]; j++) { m_ppePathIdx[i][j] = static_cast<unsigned char>(findMinimum( m_apfCost[kRowNext][j-1], // horiz m_apfCost[kRowCurr][j], // vert m_apfCost[kRowCurr][j-1], // diag m_apfCost[kRowNext][j])); // minimum cost output m_apfCost[kRowNext][j] += ppfDistanceMatrix[i][j]; } // swap the pointers of our two buffers as we proceed to the next row CUtil::swap(m_apfCost[kRowCurr], m_apfCost[kRowNext]); } // all done m_bWasProcessed = true; return kNoError; }
Rpn::Operand Enumerative::calculate(FunctionCalculator *calculator, QList<Rpn::Operand> actualArguments) { // Initialize algorithm variables m_calculator = calculator; m_functionName = actualArguments.at(0).value.value<QString>(); m_sourceInterval.leftBorder = actualArguments.at(1).value.value<Number>(); m_sourceInterval.rightBorder = actualArguments.at(2).value.value<Number>(); m_iterationsCount = actualArguments.at(3).value.value<Number>(); Rpn::Operand result; result.type = Rpn::OperandNumber; result.value = QVariant::fromValue(findMinimum()); return result; }
int main() { int T,N,S[5002],i,min; scanf("%d",&T); while(T--) { min=1000000000; scanf("%d",&N); for(i=0;i<N;i++) { scanf("%d",&S[i]); min=findMinimum(S,i,min); } printf("%d\n",min); } return 0; }
void bspsieve(){ double time0, time1; ulong *x; // local list of candidates ulong *ks; //place for proc0 to store intermediate ks ulong n, nl, i, iglob; int s, p; ulong k; // the current largest sure-prime n = N+1; // copy global N and increase by 1. (only proc 1 knows this) // this is so the maximum array idx == N bsp_begin(P); p= bsp_nprocs(); /* p = number of processors obtained */ printf("Now we have %d processors.\n", p); s= bsp_pid(); /* s = processor number */ if (s==0){ if(n<0) bsp_abort("Error in input: n is negative"); ks = vecalloculi(p); } bsp_push_reg(&n,SZULL); bsp_sync(); bsp_get(0,&n,0,&n,SZULL); //everyone reads N from proc 0 bsp_sync(); bsp_pop_reg(&n); nl= blockSize(p,s,n); // how big must s block be? printf("P(%d) tries to alloc vec of %lld ulongs", s, nl); printf(", size would be = %lld Mb\n", nl*SZULL/1024/1024); x= vecalloculi(nl); for (i=0; i<nl; i++){ // start by assuming everything is prime, except 1 iglob= globalIdx(p,s,n,i); x[i]= iglob; } if(s==0) x[1]=0; bsp_sync(); time0=bsp_time(); k = 2; // begin work while( k*k <= n ) { bspmarkmultiples(p,s,n,k,x); k = nextPrime(p,s,n,k,x); bsp_push_reg(&k, SZULL); bsp_sync(); if(s==0) { ks[0] = k; // my k for(i=1;i<p; i++) { bsp_get(i, &k, 0, &ks[i], SZULL); } } bsp_sync(); if(s==0) { k = findMinimum(p,ks); } bsp_sync(); //broadcast minimum bsp_get(0,&k,0,&k,SZULL); bsp_sync(); bsp_pop_reg(&k); } // end work bsp_sync(); time1=bsp_time(); ulong primes= 0; //printf("Processor %lld primes: \n", s); for(i = 0; i < blockSize(p,s,n); i++) if( x[i] != 0) primes++; //do not print primes, just count them. printf("proc %d finds %lld primes.\n", s, primes); fflush(stdout); if (s==0){ printf("This took only %.6lf seconds.\n", time1-time0); fflush(stdout); vecfreeuli(ks); } vecfreeuli(x); bsp_end(); } /* end bspsieve */