int main()
{
int h;
int i, j;
double m, t;
for(h = 1; ; h++){
scanf(" %d", &n);
if(n == 0)
break;
for(i = 0; i < n; i++)
scanf(" %d %d", &pt[i].x, &pt[i].y);
for(i = 0; i < n; i++)
for(j = 0; j < n; j++)
memoriza[i][j] = -1.0;
m = minimo(1, n-1) + dist(1, n-1);
for(i = 1; i < n; i++){
t = minimo((i + 1)%n, i - 1) + dist((i+1)%n, i-1);
if(t < m)
m = t;
}
printf("Instancia %d\n", h);
printf("%.2f\n\n", m);
}
return 0;
}
/*
* step3 algoritmo
* trova cammino all'indietro e incrementa flusso
*/
void incrementa_flusso() {
int passo = 0;
int k;
int flusso;
int continua = 1;
elemento_coda_t *elem_coda_temp;
/*ricostruisco cammino all'indietro*/
fprintf(fout, "ricostruisco cammino : fine <-");
reset_coda(&ingresso_coda_cammino, &uscita_coda_cammino);
k = t;
flusso = minimo(a[s], b[t]);
for (passo = 0; continua; passo++)
/* destinazione */
if (passo % 2 == 0) {
metti_in_coda(&uscita_coda_cammino, &ingresso_coda_cammino, pd[k] - 1, k);
fprintf(fout, "[%d-%d]", pd[k], k + 1);
k = pd[k] - 1;
if (k == s) continua = 0;
} else {
metti_in_coda(&uscita_coda_cammino, &ingresso_coda_cammino, ps[k] - 1, k);
fprintf(fout, "[%d-%d]", ps[k], k + 1);
flusso = minimo(flusso, X[k][ps[k] - 1]);
k = ps[k] - 1;
}
fprintf(fout, "<- inizio \nflusso minimo=%d\n", flusso);
/*aggiorno partenza e origine*/
a[s] -= flusso;
b[t] -= flusso;
/*aggiorno flussi nel cammino*/
for (passo = 0; !is_coda_vuota(uscita_coda_cammino, ingresso_coda_cammino); passo++) {
elem_coda_temp = togli_da_coda(&uscita_coda_cammino, &ingresso_coda_cammino);
/*printf("[%d,%d]", elem_coda_temp->indice_k +1 , elem_coda_temp->direzione +1);*/
if (passo % 2 == 0) {
X[elem_coda_temp->indice_k][elem_coda_temp->direzione] += flusso;
} else {
X[elem_coda_temp->direzione][elem_coda_temp->indice_k] -= flusso;
}
}
fprintf(fout, "flussi aggiornati.\n");
reset_etichette();
}
NoAVL<T>* remover(NoAVL<T>* arv, const T& dado) {
NoAVL<T> *aux, *filho;
if (arv == NULL) {
return arv;
}
else {
if (dado < *arv->getDado()) {
arv->esquerda = remover(arv->getEsquerda(), dado);
arv = verificarBalanceamento(arv, *(maximo(arv))->getDado());
atualizarAltura(arv);
return arv;
}
else {
if (dado > *arv->getDado()) {
arv->direita = remover(arv->getDireita(), dado);
arv->verificarBalanceamento(arv, *(minimo(arv))->getDado());
atualizarAltura(arv);
return arv;
}
else {
if (arv->getDireita() != NULL && arv->getEsquerda() != NULL) {
aux = minimo(arv->getDireita());
arv->dado = new T(*(aux->dado));
arv->direita = remover(arv->getDireita(), *arv->getDado());
arv = verificarBalanceamento(arv, *(minimo(arv))->getDado());
atualizarAltura(arv);
return arv;
}
else {
if (arv->getDireita() != NULL) {
filho = arv->getDireita();
return filho;
}
else {
if (arv->getEsquerda() != NULL) {
filho = arv->getEsquerda();
return filho;
}
else {
arv->~NoAVL();
return NULL;
}
}
}
}
}
}
}
/**
* @brief Procuramos o dado a ser deletado na árvore. Quando acharmos,
* o dado, verificamos se ele possui filhos ou não.Se ele tiver
* filhos, fazemos o ajuste de ponteiros, deletemos o dado e
* faremos uma verificação para ver se as propriedades da
* árvore como coloração e balanceamento foram mantidos.
*
* @param arv Raiz da árvore que será verificada
* @param data Dado que será deletado
*/
NoRB<T>* remover(NoRB<T>* arv, const T& data) {
if (arv == nullptr) {
throw std::runtime_error("Dado não está na árvore");
} else {
if (data < *arv->getDado()) {
arv->esquerda = remover(arv->getEsquerda(), data);
} else if (data > *arv->getDado()) {
arv->direita = remover(arv->getDireita(), data);
} else if (arv->getEsquerda() != nullptr &&
arv->getDireita() != nullptr) {
*arv->dado = *minimo(arv->getDireita())->getDado();
arv->direita = remover(arv->getDireita(), *arv->getDado());
} else if (arv->getEsquerda() == nullptr &&
arv->getDireita() == nullptr) {
delete arv;
return nullptr;
} else {
NoRB<T> *tmp = arv;
if (arv->getEsquerda() != nullptr) {
arv = arv->getEsquerda();
} else {
arv = arv->getDireita();
}
arv->pai = tmp->getPai();
tmp->esquerda = nullptr;
tmp->direita = nullptr;
delete tmp;
return arv;
}
return fixViolation(arv);
}
}
int main()
{
int i, j;
while((!feof(stdin)) && scanf(" %d", &voltas) > 0)
{
scanf(" %lf %lf", &t0, &tad);
scanf(" %lf %lf", &c0, &cad);
scanf(" %lf %lf", &p0, &pad);
printf("%d %.3f %.3f %.3f %.3f %.3f %.3f\n",
voltas, t0, tad, c0, cad, p0, pad);
for(i = 1; i <= voltas; i++)
pits[i] = -1;
memoriza[0] = 0.0;
abastece[0] = 0.0;
pits[0] = 0;
inicializa(voltas);
minimo(voltas);
printf("%.3f %.3f %d\n",memoriza[voltas],abastece[voltas],pits[voltas]);
j = prox[voltas];
while(j != -1){
printf("%d %.3f\n", voltas - j, abastece[j]);
j = prox[j];
}
}
return 0;
}
double minimo(int v)
{
double rt, tt; /*resposta tempo, tempo temp*/
double ra; /* resposta abastece */
int rp; /*resposta pits*/
int i;
if(pits[v] != -1)
return memoriza[v];
rt = demora(v);
if(v != voltas)
rt += p0 + pad*necessario[v];
ra = necessario[v];
rp = 0;
prox[v] = -1;
for(i = 1; i < v; i++){
tt = demora(i) + minimo(v - i);
if(v != voltas)
tt += p0 + pad*necessario[i];
if(tt < rt){
rt = tt;
ra = necessario[i];
rp = pits[v - i] + 1;
prox[v] = v - i;
}
}
memoriza[v] = rt;
abastece[v] = ra;
pits[v] = rp;
return rt;
}
/**
* @brief Método para encontrar o nodo com menor valor
* de dado na árvore.
*
* @param nodo Árvore que será verificada.
*/
NoRB<T>* minimo(NoRB<T>* nodo) {
if (nodo->getEsquerda() == nullptr) {
return nodo;
} else {
return minimo(nodo->getEsquerda());
}
}
/*!
* @brief método para retirar um dado da arvore.
* @param ponteiro que indica a subarvore/arvore para procurar o dado.
* @param endereço do dado que se quer adicionar.
* @return ponteiro de um nodo generico.
*/
NoBinario<T>* remover(NoBinario<T>* arv, const T& dado) {
NoBinario<T>* temp, *filho;
if (arv == nullptr) {
return arv;
} else {
if (dado < *arv->getDado()) {
arv->esquerda = remover(arv->getEsquerda(), dado);
return arv;
} else if (dado > *arv->getDado()) {
arv->direita = remover(arv->getDireita(), dado);
return arv;
} else {
if (arv->getDireita() != nullptr &&
arv->getEsquerda() != nullptr) {
temp = minimo(arv->getDireita());
arv->dado = temp->getDado();
arv->direita = remover(arv->getDireita(), *arv->getDado());
return arv;
} else {
temp = arv;
if (arv->getDireita() != nullptr) {
filho = arv->getDireita();
return filho;
} else if (arv->getEsquerda() != nullptr) {
filho = arv->getEsquerda();
return filho;
} else {
delete arv;
return nullptr;
}
}
}
}
}
int main()
{
int n;
int i, j, k;
int min;
scanf(" %d", &n);
while(n > 0){
for(i=0; i<5; i++)
scanf(" %d", &chamados[i]);
scanf(" %d %d", &x, &y);
for(i=0; i< 5; i++){
for(k=0; k<x; k++){
for(j=0; j<5; j++){
do{
padroes[k][i][j] = getchar();
}while(padroes[k][i][j] != 'O' && padroes[k][i][j] != 'X');
}
}
}
ncmb = 0;
geracombi(y, 0, 0);
/*printf("%d %d\n", x, y);*/
/*printf("%d\n", ncmb);*/
/*
for(k=0; k<ncmb; k++){
for(i=0; i<5; i++){
for(j=0; j<5; j++)
printf("%c ", vencs[k][i][j]);
putchar('\n');
}
putchar('\n');
}
putchar('\n');
*/
min = minimo(0);
for(i=1; i<ncmb; i++){
k = minimo(i);
if(k < min)
min = k;
}
printf("%d\n", min);
n--;
}
return 0;
}
NoAVL<T>* remover(NoAVL<T>* arv, const T& dado) {
if (!arv) {
return nullptr;
}
if (dado < *arv->dado) {
arv->esquerda = remover(arv->esquerda, dado);
} else if (dado > *arv->dado) {
arv->direita = remover(arv->direita, dado);
} else {
NoAVL<T>* temp;
if (arv->esquerda && arv->direita) {
temp = minimo(arv->direita);
*arv->dado = *temp->dado;
arv->direita = remover(arv->direita, *arv->dado);
} else {
if (arv->direita) {
temp = arv->direita;
return temp;
}
if (arv->esquerda) {
temp = arv->esquerda;
return temp;
}
delete arv;
return nullptr;
}
}
if (!arv) {
return nullptr;
}
arv->atualizaAltura();
int balanceamento = fatorDeBalanceamento(arv);
if (balanceamento > 1) {
if (fatorDeBalanceamento(arv->esquerda) < 0) {
arv->esquerda = rotacaoSimplesEsq(arv->esquerda);
}
return rotacaoSimplesDir(arv);
}
if (balanceamento < -1) {
if (fatorDeBalanceamento(arv->direita) > 0) {
arv->direita = rotacaoSimplesDir(arv->direita);
}
return rotacaoSimplesEsq(arv);
}
return arv;
}
double minimo(int a, int b)
{
int i;
double r, t;
if(memoriza[a][b] >= 0)
return memoriza[a][b];
if(a == b || (a + 1) % n == b || (a+2) % n == b)
return 0.0;
r = 1000000.0; /*infi*/
for(i = (a+1)%n; i != b; i = (i+1)%n){
t = minimo(a, i) + minimo(i, b) + dist(a, i) + dist(i, b);
if(t < r)
r = t;
}
memoriza[a][b] = r;
return r;
}
int main(void)
{
int dias;
ler_numero_de_dias(&dias);
int *estoque = (int *) malloc(dias*sizeof(int));
ler_estoque(estoque, dias);
printf("Media: %.02f\n", media(estoque, dias));
printf("Menor estoque: %d\n", minimo(estoque, dias));
printf("Maior estoque: %d\n", maximo(estoque, dias));
free(estoque);
}
/**
* Creo soluzione iniziale duale con minimi di riga e colonna. Miglioro soluzione rp
*/
void soluzione_iniziale_duale() {
int min, i, j;
/*per ogni riga*/
for (i = 0; i < m; i++) {
/*cerco il minimo di riga*/
min = MCosti[i][0];
for (j = 1; j < n; j++)
if (MCosti[i][j] < min) min = MCosti[i][j];
/*scrivo il minimo nel vettore u^*/
u_duale[i] = min;
/*tolgo minimo alla riga*/
for (j = 0; j < n; j++)
MCosti[i][j] = MCosti[i][j] - min;
}
/*per ogni colonna*/
for (j = 0; j < n; j++) {
/*cerco il minimo di colonna*/
min = MCosti[0][j];
for (i = 1; i < m; i++)
if (MCosti[i][j] < min) min = MCosti[i][j];
/*scrivo il minimo nel vettore v^*/
v_duale[j] = min;
/*tolgo minimo alla colonna*/
for (i = 0; i < m; i++)
MCosti[i][j] = MCosti[i][j] - min;
}
fprintf(fout, "RP con costi = Cij-Uij-Vij:\n");
stampa();
stampa_soluz_duale();
/* miglioro soluzione PR */
for (i = 0; i < m; i++)
for (j = 0; j < n; j++)
if (MCosti[i][j] == 0) {
min = minimo(a[i], b[j]);
X[i][j] = min;
a[i] -= min;
b[j] -= min;
}
fprintf(fout, "Soluzione iniziale di RP");
stampa();
}
int main()
{
int m;
int resp;
int h = 1;
while(!feof(stdin) && scanf(" %d %d", &n, &m) > 0){
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++)
mat[i][j] = INFI;
foi[i] = 0;
}
for(int k = 0; k < m; k++){
int i, j, c;
scanf(" %d %d %d", &i, &j, &c);
i--; j--;
if(mat[i][j] > c)
mat[i][j] = mat[j][i] = c;
}
foi[0] = 1;
for(int i = 1; i < n; i++)
dist[i] = mat[0][i];
resp = 0;
for(int k = 2; k < n; k++){
int i = minimo();
printf("%d\n", i);
foi[i] = 1;
resp += dist[i];
for(int j = 1; j < n; j++)
if(mat[i][j] < dist[j])
dist[j] = mat[i][j];
}
printf("Instancia %d\n%d\n\n", h++, resp + dist[minimo()]);
}
return 0;
}
int main(){
int a;
int b;
printf("Ingrese el numero: ");
scanf("%d",&a);
printf("Ingrese el numero: ");
scanf("%d",&b);
printf("El máximo entre %d y %d es: %d\n", a, b, maximo(a,b));
printf("El mínimo entre %d y %d es: %d\n", a, b, minimo(a,b));
}
int main()
{
char ch;
read_slice();
maximo();
minimo();
printf("\n Do you desire a small file (dim 256*256) ? y/n ");
scanf("%c", &ch);
if (ch == 'y') { rescale_reduce() ; }
else { rescale(); }
fclose(in_file);
fclose(out_file);
return 0;
}
/*
*Algoritmo que realiza la conversion de RGB a HSV
*/
void RGB_to_HSV( int RGB[], int *H, float *S, float *V){
int col_max;
int col_min;
float val_max = maximo(RGB, &col_max);
float val_min = minimo(RGB, &col_min);
if(col_max == RED){
*H = 60 * (RGB[GREEN] - RGB[BLUE])/(val_max - val_min);
if(RGB[GREEN] < RGB[BLUE]){
*H = *H + 360;
}
}else if(col_max == GREEN){
*H = 60 * (RGB[BLUE] - RGB[RED])/(val_max - val_min) + 120;
}else if(col_max == BLUE){
*H = 60 * (RGB[RED] - RGB[GREEN])/(val_max - val_min) + 240;
}
if(val_max == 0){
*S = 0;
}else{
*S = 1.0 - val_min/val_max;
}
*V = val_max/255.0;
}
NoBinario<T>* remover(NoBinario<T>* arv, const T& dado) {
NoBinario<T> *aux, *filho;
if (arv == NULL) {
return arv;
} else {
if (dado < *arv->getDado()) {
arv->esquerda = remover(arv->getEsquerda(), dado);
return arv;
} else {
if (dado > *arv->getDado()) {
arv->direita = remover(arv->getDireita(), dado);
return arv;
} else {
if (arv->getDireita() != NULL &&
arv->getEsquerda() != NULL) {
aux = minimo(arv->getDireita());
arv->dado = aux->getDado();
arv->direita = remover(arv->getDireita(),
*arv->getDado());
return arv;
} else {
aux = arv;
if (arv->getDireita() != NULL) {
filho = arv->getDireita();
return filho;
} else {
if (arv->getEsquerda() != NULL) {
filho = arv->getEsquerda();
return filho;
} else {
delete arv;
return NULL;
}
}
}
}
}
}
}
unsigned int process_block(struct hpcap_handle * hp,int fd, u_int32_t remain)
{
u_int32_t aux;
unsigned int ready = minimo(remain, hp->avail);
#ifdef OWRITE
/* escribir bloque a bloque */
if( (hp->rdoff + ready ) > HPCAP_BUF_SIZE )
{
aux = HPCAP_BUF_SIZE - hp->rdoff;
/* hay que hacerlo en dos transferencias */
write( fd, &hp->buf[ hp->rdoff ], aux);
write( fd, hp->buf, ready-aux);
}
else
{ /* se hace en una transferencia */
write( fd, &hp->buf[ hp->rdoff ], ready);
}
#else
#endif
return ready;
}
NoAVL<T>* minimo(NoAVL<T>* nodo) {
return nodo->esquerda ? minimo(nodo->esquerda) : nodo;
}
int main()
{
int casos, h;
int m;
int i, j;
int o, d;
int sai, demora, chega;
char buf[40];
Rota *r;
int novo, espera;
scanf(" %d", &casos);
inicializa();
for(h = 1; h <= casos; h++){
n = 0;
scanf(" %d", &m);
while(m--){
scanf(" %s", buf);
i = acha(buf);
if(i == n){
strcpy(cidade[i].nome, buf);
cidade[i].visitado = 0;
cidade[i].min = INFI;
cidade[i].prox = NULL;
n++;
}
scanf(" %s", buf);
j = acha(buf);
if(j == n){
strcpy(cidade[j].nome, buf);
cidade[j].visitado = 0;
cidade[j].min = INFI;
cidade[j].prox = NULL;
n++;
}
scanf(" %d %d", &sai, &demora);
chega = (sai + demora) % 24;
if((6 <= sai && sai < 18) || demora > 12 ||(6 < chega && chega <= 18))
continue;
r = aloca();
r->d = j;
r->sai = sai % 24;
r->demora = demora;
r->prox = cidade[i].prox;
cidade[i].prox = r;
}
/*
for(i = 0; i< n; i++){
printf("%s | ", cidade[i].nome);
for(r = cidade[i].prox; r != NULL; r = r->prox){
printf("%s ", cidade[r->d].nome);
}
printf("\n");
}
*/
scanf(" %s", buf);
o = acha(buf);
scanf(" %s", buf);
d = acha(buf);
cidade[o].min = 18;
while(1){
i = minimo();
if(i == n || i == d)
break;
cidade[i].visitado = 1;
for(r = cidade[i].prox; r != NULL; r = r->prox){
espera = r->sai - (cidade[i].min % 24);
if(espera < 0)
espera += 24;
espera %= 24;
novo = cidade[i].min + espera + r->demora;
if(novo < cidade[r->d].min)
cidade[r->d].min = novo;
}
}
/*
for(i = 0; i< n; i++)
printf("%s - %d\n", cidade[i].nome, cidade[i].min);
printf("\n");
*/
printf("Test Case %d.\n", h);
if(cidade[d].min == INFI)
printf("There is no route Vladimir can take.\n");
else
printf("Vladimir needs %d litre(s) of blood.\n", (cidade[d].min - 12)/24);
for(i = 0 ; i < n; i++)
destroi(cidade[i].prox);
}
return 0;
}
int main(){
int numeros[10] = {-2, 1, 10, 2, 200, 100, -133, 0, 9, 4};
printf("El menor número del vector es %d", minimo(numeros, 10));
return 0;
}
NoAVL<T>* remover(NoAVL<T>* arv, const T& dado) {
if (!arv)
throw ERROARVNULA;
if (dado < *arv->dado) {
if (!arv->esquerda)
throw ERROARVNULA;
arv->esquerda = remover(arv->esquerda, dado);
}
if (dado > *arv->dado) {
if (!arv->direita)
throw ERROARVNULA;
arv->direita = remover(arv->direita, dado);
}
NoAVL<T>* temp;
if (dado == *arv->dado) {
if (!arv->esquerda && !arv->direita) {
delete arv;
return NULL;
}
NoAVL<T>* temp;
if (!arv->esquerda && arv->direita) {
temp = arv->direita;
delete arv;
DefinirAltura(temp);
return temp;
}
if (arv->esquerda && !arv->direita) {
temp = arv->esquerda;
delete arv;
DefinirAltura(temp);
return temp;
}
temp = minimo(arv->direita);
if (temp->dado != arv->direita->dado) {
temp->direita = arv->direita;
temp->direita->esquerda = NULL;
}
temp->esquerda = arv->esquerda;
delete arv;
if (temp->direita)
temp->direita = BalancearArv(temp->direita);
if (temp->esquerda)
temp->esquerda = BalancearArv(temp->esquerda);
temp->altura = DefinirAltura(temp);
return BalancearArv(temp);
}
arv->altura = DefinirAltura(arv);
switch (definirTipoGira(arv)) {
case tpGiroDireita: {
if ((FatorFilhoGiroDireita(arv)) < 0)
arv->esquerda = girar(arv->esquerda, false);
arv = girar(arv, true);
break;
}
case tpGiroEsquerda:
if ((FatorFilhoGiroEsquerda(arv)) > 0)
arv->direita = girar(arv->direita, true);
arv = girar(arv, false);
break;
default:
break;
}
return arv;
}
