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 */
