Algoritmos Computacionais http://algoritmos.tiagomadeira.net por Tiago Madeira Sat, 27 Sep 2008 02:53:09 +0000 http://wordpress.org/?v=2.7.1 en hourly 1 Crivo de Eratóstenes http://algoritmos.tiagomadeira.net/crivo-de-eratostenes http://algoritmos.tiagomadeira.net/crivo-de-eratostenes#comments Sun, 17 Jun 2007 13:40:53 +0000 Tiago Madeira http://algoritmos.tiagomadeira.net/crivo-de-eratostenes Encontrar números primos é um problema comum em olimpíadas e maratonas de programação. Até hoje não existe uma maneira fácil de determinar se um número é ou não primo, mas para resolver estes problemas é indispensável o conhecimento de alguns algoritmos clássicos e simples, como o Crivo de Eratóstenes.

O Crivo de Eratóstenes é um método bastante prático para encontrar os primos de 2 até um valor limite, que pode ser feito a mão e é fácil de implementar.

O algoritmo consiste em:

  1. Determinar (ou receber na entrada do programa) o valor limite, isto é, o maior número que desejamos saber se é primo.
  2. Fazer a raiz quadrada do valor limite. Pode-se arredondar para baixo caso a raiz não seja exata (e quase nunca é).
  3. Criar um vetor (lista) com os números de 2 até o valor limite.
  4. Para i=2 até raiz do valor limite, caso o número (i) não esteja riscado insira-o na lista dos primos (ou imprima-o, ou não faça nada, isso depende da utilidade que você quer dar para o crivo) e risque todos os seus múltiplos na lista.

Há várias maneiras de implementar este algoritmo. Eu pseudocodaria (meu pseudocódigo é bem próximo de uma linguagem normal, porque acho que assim é mais fácil de entender e depois implementar) ele assim:

/* Primeiro passo */
recebe valorLimite

/* Segundo passo */
raiz LaTeX: leftarrow LaTeX: sqrt{valorLimite}

/* Terceiro passo */
para i LaTeX: leftarrow 2 até valorLimite
    vetor[i] LaTeX: leftarrow i
fim-para

/* Quarto passo */
para i LaTeX: leftarrow 2 até raiz
    se vetor[i] = i
        imprima "O número " i " é primo."
        para j LaTeX: leftarrow i+i até valorLimite, de i e i
            vetor[j] LaTeX: leftarrow 0
        fim-para
    fim-se
fim-para

Vêem como é simples?

Crivo de Eratóstenes implementado em C

#include <stdio.h>#include <math.h> // necessário para raiz #define NMAX 1000000 // valor máximo para o valor máximo int main() {    int i, j, vetor[NMAX];    int valorMaximo, raiz;     // Primeiro passo    scanf("%d", &valorMaximo);     // Segundo passo    raiz=sqrt(valorMaximo);     // Terceiro passo    for (i=2; i<=valorMaximo; i++) {        vetor[i]=i;    }     // Quarto passo    for (i=2; i<=raiz; i++) {        if (vetor[i]==i) {            printf("%d é primo!n", i);            for (j=i+i; j<=valorMaximo; j+=i) {                vetor[j]=0; // removendo da lista            }        }    }     return 0;}

No USACO Training Program Gateway (programa de treinamento para olimpíadas dos estado-unidenses) há um problema muito interessante (Prime Palindromes) cujo objetivo é determinar palíndromos primos de X a Y. Uma das melhores situações que já encontrei para usar o Crivo e sem dúvidas é um ótimo treinamento. Além de determinar primos, você terá que determinar palíndromos e é outro ótimo exercício lógico-matemático.

Divirtam-se e qualquer dúvida usem os comentários!

]]> http://algoritmos.tiagomadeira.net/crivo-de-eratostenes/feed Escada perfeita (OBI2006) http://algoritmos.tiagomadeira.net/escada-perfeita-obi2006 http://algoritmos.tiagomadeira.net/escada-perfeita-obi2006#comments Fri, 15 Jun 2007 12:38:30 +0000 Tiago Madeira http://algoritmos.tiagomadeira.net/2007/06/15/escada-perfeita-obi2006/ Depois de meses sem postar, resolvi que a partir de agora darei mais atenção pra este blog. Muita gente me manda e-mail e comentários com dúvidas e gostaria de deixar bem claro que eu não faço trabalhos de faculdade pra ninguém, mas que se você tiver uma dúvida real onde eu possa ajudar eu ajudarei de bom grado.

Pensei muito sobre o que postar aqui, tenho rascunhos sobre buscas em grafos e sobre resoluções de problemas de grafos, mas resolvi quebrar toda a ordem e, a partir de um scrap de orkut, acabei me lembrando do problema Escada perfeita, da OBI 2006, e me deu vontade de resolvê-lo aqui.

Por que o problema Escada Perfeita?

A programação deste problema é extremamente simples, mas a sua lógica (matemática pura) é muito inteligente. Tente resolver o problema antes de ver minha solução e, caso não consiga, depois veja como a solução é bonita.

Vamos ao enunciado...

Uma construtora, durante a criação de um parque temático, encontrou no terreno um conjunto de várias pilhas de cubos de pedra. Ao invés de pagar pela remoção dos cubos de pedras, um dos arquitetos da empresa achou interessante utilizar as pedras para decoração do parque, determinando que as pedras fossem rearranjadas no formato de "escada". para isso, os funcionários deveriam mover alguns cubos para formar os degraus das escadas. Só que o arquiteto decidiu que, entre uma pilha e outra de pedras deveria haver exatamente uma pedra de diferença, formando o que ele chamou de escada perfeita. O exemplo abaixo mostra um conjunto de cinco pilhas de pedras encontradas e as cinco pilhas como ficaram após a arrumação em escada perfeita.

Escada perfeita

Tarefa

Dada uma seqüência de pilhas de cubos de pedras com suas respectivas alturas, você deve determinar o número mínimo de pedras que precisam ser movidas para formar uma escada perfeita com exatamente o mesmo número de pilhas de pedras encontrado inicialmente (ou seja, não devem ser criadas ou eliminadas pilhas de pedras). O degrau mais baixo da escada deve sempre estar do lado esquerdo.

Entrada

A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha contém um inteiro n que indica o número de pilhas de pedras. A segunda linha contém N números inteiros que indicam a quantidade de cubos de pedras em cada uma das pilhas, da esquerda para a direita.

Saída

Seu programa deve imprimir, na saída padrão, uma única linha, contendo um inteiro: o número mínimo de cubos de pedras que devem ser movidos para transformar o conjunto de pilhas em uma escada perfeita, conforme calculado pelo seu programa. Caso não seja possível efetuar a transformação em escada perfeita, imprima como resultado o valor -1.

Exemplos

Exemplo 1

Entrada
5
5 4 5 4 2

Saída
5

Exemplo 2

Entrada
6
9 8 7 6 5 4

Saída
9

Exemplo 3

Entrada
2
1 5

Saída
-1

OK. Estão prontos?

Depois de pensar um pouco, conclui-se que:

  1. A escada perfeita é uma PA de razão 1 (aumenta de um em um). Você lembra disso do seu primeiro ano do Ensino Médio? Senão, é bom dar uma relembrada. As fórmulas (simples e facilmente deduzíveis) da PA são:

    Termo geral da PA

    LaTeX: a_{n} = a_{1} + (n-1).r

    Soma de PA

    LaTeX: \displaystyle S_{n} = (a_{1}+a_{n}).\frac{n}{2}

  2. Sabemos quanto vale n (o número de pilhas, número de elementos da PA) e conseguimos calcular a soma de todos os elementos (podemos fazer isso até durante o loop da entrada, certo?)
  3. Sabemos quanto vale a razão (r=1).
  4. Substituindo o que sabemos nas fórmulas conseguimos formar um sistema de equações básico e desta forma torna-se fácil descobrir o valor do primeiro e do último termo da PA (LaTeX: a_{1} e LaTeX: a_{n}). Resumindo um pouco os cálculos, depois de alguma manipulação algébrica você chega a:

    LaTeX: \displaystyle a_{n} = \frac{\frac{2.S_{n}}{n}+n-1}{2}

    LaTeX: \displaystyle a_{1} = 1 + a_{n} - n

  5. Agora que já sabemos onde começa e onde termina a escada basta fazer um loop em cada fila de blocos e adicionar à uma variável movimentos a quantidade de quadradinhos que estão sobrando nesta fileira (por exemplo, na primeira fileira da figura do enunciado está sobrando três quadradinhos para chegar ao LaTeX: a_{1}=2). Ao mesmo tempo, adicionamos à outra variável (moves) a quantidade de quadradinhos que devem ser retirados ou colocados na fileira (porque depois se esta variável não for igual a 0 imprimimos -1). Ficou claro?

Implementação

Variáveis

  • n: número de degraus (fileiras de blocos)
  • a: LaTeX: a_{1}, número de blocos do primeiro degrau.
  • b: LaTeX: a_{n}, número de blocos do último degrau.
  • soma: LaTeX: S_{n}, soma da PA.
  • pilha[]: vetor de degraus.
  • movimentos e moves: explicados no quinto passo da solução.
  • i e j: variáveis auxiliares para fazer os loops.

Codeado em C

#include <stdio.h>#define PMAX 10001 int main() {	int i, j;	int n;	int soma=0;	int a, b;	int pilha[PMAX];	int moves=0;	int movimentos=0; 	scanf("%d", &n);	for (i=0; i<n; i++) {		scanf("%d", &pilha[i]);		soma+=pilha[i];	} 	b=(((2*soma)/n)+(n-1))/2;	a=1+b-n; 	for (i=0; i<n; i++) {		moves+=(pilha[i]-(i+a));		if (pilha[i]>i+a) {			movimentos+=(pilha[i]-(i+a));		}	} 	if (moves!=0) {		printf("-1n");	} else {		printf("%dn", movimentos);	} 	return 0;}

Prontinho! :) Qualquer dúvida escrevam seus comentários.

]]> http://algoritmos.tiagomadeira.net/escada-perfeita-obi2006/feed Grafos Ponderados http://algoritmos.tiagomadeira.net/grafos-ponderados http://algoritmos.tiagomadeira.net/grafos-ponderados#comments Thu, 26 Jan 2006 11:31:20 +0000 Tiago Madeira http://tiagomadeira.net/?p=98 Um grafo é ponderado quando suas arestas possuem um peso. O que significa isso? Bom... Vamos supor que eu queira ir de um lugar pra outro, mas o mais importante pra mim não seja a distância entre eles mas o pedágio que vou ter que pagar para pegar cada aresta (estrada). Nesse caso, o peso de cada aresta seria o custo que eu tenho pra passar pela estrada. O problema então seria calcular o caminho onde eu pago menos (o caminho que tem a menor soma de preços) e não o menor caminho no grafo "não-ponderado" (onde consideramos aresta=1 e nada=0).

Grafo Ponderado

Neste grafo, por exemplo, o menor caminho de 1 a 3 não é a aresta 1-3, mas sim a aresta 1-2 e depois a aresta 2-3.

Para representar um grafo ponderado usando a matriz de adjacência, onde antes marcávamos "1", marcamos o peso que temos de ir de um vértice para o outro e onde marcávamos "0" marcamos LaTeX: \infty{} (infinito)*.

  1 2 3 4
1 LaTeX: \infty{} 10 40 LaTeX: \infty{}
2 10 LaTeX: \infty{} 20 50
3 40 20 LaTeX: \infty{} 20
4 LaTeX: \infty{} 50 20 LaTeX: \infty{}

* Na verdade, só fazemos isso porque neste caso iríamos querer o menor caminho e o 0 poderia atrapalhar, porque poderíamos ter um caminho sem pedágio, por exemplo, mas isso sempre depende do caso.

Usando listas de adjacência, podemos representar as ligações de cada vértice com dois vetores (um para dizer a qual ele se liga e outro o peso desta ligação) ou com um vetor de structs como:

struct edge {    int destino, peso;};
]]> http://algoritmos.tiagomadeira.net/grafos-ponderados/feed Representando Grafos na Programação http://algoritmos.tiagomadeira.net/representando-grafos-na-programacao http://algoritmos.tiagomadeira.net/representando-grafos-na-programacao#comments Mon, 23 Jan 2006 11:50:15 +0000 Tiago Madeira http://tiagomadeira.net/?p=92 No último artigo, conhecemos a representação chamada "grafo" da seguinte maneira:

Exemplo 1

Como todos sabemos, seria bem difícil trabalhar uma árvore assim na programação! :D Por isso, existem várias maneiras de representar um grafo. Nesta série só vou usar as duas mais populares:

  • Matriz de Adjacência
  • Lista de Adjacência

Poderíamos falar também sobre a Matriz de Incidência, mas eu nunca precisei utilizá-la, então prefiro só entrar nessas duas mesmo.

Cada vértice é um número

Para representar um grafo, cada vértice sempre vai ser um número. No caso de você querer representar amizade entre duas pessoas, como no exemplo do Orkut no último artigo, você cria um vetor chamado nome[] que contém o nome de cada número... :)

Matriz de Adjacência

A matriz de adjacência é uma matriz de N x N (onde N é o número de vértices do grafo). Ela inicialmente é preenchida toda com 0 e quando há uma relação entre o vértice do x (número da coluna) com o do y (número da linha), matriz[x][y] é marcado um 1.

Vamos escrever este grafo aqui usando uma matriz de adjacência:

Matriz Inicial

  1 2 3 4 5
1 0 0 0 0 0
2 0 0 0 0 0
3 0 0 0 0 0
4 0 0 0 0 0
5 0 0 0 0 0

Relações do nosso grafo

Já que o grafo não é orientado, a relação 1-2 significa 2-1 também. :)

  • 1-2 (2-1)
  • 1-3 (3-1)
  • 2-3 (3-2)
  • 2-4 (4-2)
  • 4-5 (5-4)

Essas são as cinco arestas do nosso grafo. Vamos representá-la na matriz de adjacência:

  1 2 3 4 5
1 0 1 1 0 0
2 1 0 1 1 0
3 1 1 0 0 0
4 0 1 0 0 1
5 0 0 0 1 0

Simetria

Uma das características da matriz de adjacência quando o grafo não é orientado é a simetria encontrada na "diagonal". É interessante que se lermos uma coluna de índice v ou uma linha de índice v vamos encontrar a mesma coisa.

Problemas da OBI

Alguns desses programas são complicados, mas isto não entra em questão. Apenas dê uma olhada no recebimento da entrada deles. Todos estão em C. O que eles têm em comum é a utilização de uma matriz de adjacência para guardar o grafo (geralmente nomeada g):

* - Grafo orientado
+ - Grafo ponderado (veremos no próximo artigo)
X - Não queira ver esse problema. Nunca vi solução mais feia. Já estou providenciando uma implementação mais decente... ;)

Descobrir o grau de cada vértice

Eu não disse pra vocês que era fácil conseguir emprego no Orkut? Hehehe... Vamos pensar como podemos descobrir o grau (relembrando... o número de arestas que cada vértice tem OU o número de amigos que cada pessoa tem) na matriz de adjacências. Não basta contar quantos 1s tem na sua linha correspondente? Então façamos isto.

para i LaTeX: leftarrow{} 1 até N, faça
	grau LaTeX: leftarrow{} 0
	para j LaTeX: leftarrow{} 1 até N, faça
		se matriz[i][j] = 1, então
			grau LaTeX: leftarrow{} grau + 1
		fim-se
	fim-para
	imprima "O vértice " i " tem grau " grau "."
fim-para

O custo é LaTeX: \Theta{}(n^{2}) até no melhor caso... Será que não há uma maneira mais simples de fazer isso? Imagina um negócio do tamanho do Orkut. Milhões de pessoas... Não seria bem mais fácil se ao invés de termos que passar por todos os vértices, só passarmos pelos amigos? Não poderíamos colocar somente seus amigos num vetor? É por isto que utilizamos a lista de adjacência.

Lista de Adjacência

A lista de adjacência consiste em criar um vetor para cada vértice. Este vetor contém cada vértice que o vértice "conhece" (tem uma aresta para). Geralmente é representada com uma matriz, porque cada vértice vai precisar de um vetor diferente, não é? Já que eu não vou ser duas vezes "amigo" de ninguém, então podemos fazer uma matriz de NxN.

  1 2 3 4 5
1          
2          
3          
4          
5          

A lista consiste em escrever para cada número de linha (= vértice) seus amigos, da seguinte maneira:

  1. 2, 3
  2. 1, 3, 4
  3. 1, 2
  4. 2, 5
  5. 4

Portanto, na programação seria representado da seguinte maneira:

  1 2 3 4 5
1 2 3      
2 1 3 4    
3 1 2      
4 2 5      
5 4        

O método da lista de adjacências tem várias vantagens: dependendo de como você implementa você não precisa inicializar a lista (zerar), as buscas são bem mais rápidas (você só passa pelos vértices que são "amigos" do atual) e geralmente você já tem o grau do vértice na ponta da língua (eu, pelo menos, sempre uso um vetor cont que contém o número de amigos de cada vértice para ficar mais fácil inserir o próximo elemento na lista - lista[cont[v]++]=w).

Como implementar

Vamos trabalhar com uma entrada de vários x, y, indicando relação entre x-y (y-x) até que x=0 e y=0. O grafo não é orientado.

Matriz de Adjacências

para i LaTeX: leftarrow{} 1 até N, faça
	para j LaTeX: leftarrow{} 1 até N, faça
		matriz[i][j] LaTeX: leftarrow{} 0
	fim-para
fim-para

enquanto (recebe x, y e x LaTeX: neq{} 0), faça
	matriz[x][y] LaTeX: leftarrow{} 1
	matriz[y][x] LaTeX: leftarrow{} 1
fim-enquanto

Tem vários exemplos implementados em C aqui.

Lista de Adjacências

para i LaTeX: leftarrow{} 1 até N, faça
	grau[i] LaTeX: leftarrow{} 0
fim-para

enquanto (recebe x, y e x LaTeX: neq{} 0), faça
	lista[x][grau[x]++] LaTeX: leftarrow{} y
	lista[y][grau[y]++] LaTeX: leftarrow{} x
fim-enquanto

Para quem não programa em C, o variavel++ significa "incrementar variavel depois da instrução atual".

As duas juntas

para i LaTeX: leftarrow{} 1 até N, faça
	para j LaTeX: leftarrow{} 1 até N, faça
		matriz[i][j] LaTeX: leftarrow{} 0
	fim-para
	grau[i] LaTeX: leftarrow{} 0
fim-para

enquanto (recebe x, y e x LaTeX: neq{} 0), faça
	matriz[x][y] LaTeX: leftarrow{} 1
	matriz[y][x] LaTeX: leftarrow{} 1
	lista[x][grau[x]++] LaTeX: leftarrow{} y
	lista[y][grau[y]++] LaTeX: leftarrow{} x
fim-enquanto

Qual a representação que devo utilizar?

Isso depende totalmente do problema. Em alguns casos, o mais barato é usar as duas representações juntas. As vantagens da lista de adjacências eu já escrevi aqui. A única vantagem da matriz de adjacências é você em tempo constante (não é nem linear) saber se um vértice é amigo de outro. Afinal, basta testar matriz[v][w].

Até maio do ano passado, eu não tinha aprendido isso direito e sempre usava a matriz de adjacências. Por isso muitos dos meus problemas estão resolvidos de forma pouco eficiente... e isso pode ser crucial numa prova. Por isso, saiba usar as duas formas!

]]> http://algoritmos.tiagomadeira.net/representando-grafos-na-programacao/feed Os Grafos e o Orkut http://algoritmos.tiagomadeira.net/os-grafos-e-o-orkut http://algoritmos.tiagomadeira.net/os-grafos-e-o-orkut#comments Sun, 22 Jan 2006 16:43:22 +0000 Tiago Madeira http://tiagomadeira.net/?p=91 Vou neste e nos próximos artigos falar-lhes sobre a Teoria dos Grafos. É uma coisa que poderia ser complicada, então pra facilitar o entendimento eu fiz duas coisas:

  • Eu baixei um programa brasileiro chamado Rox, que foi feito em Java e é disponibilizado sob a GNU/GPL. Ele serve para facilitar o ensino da "Teoria dos Grafos" ajudando-nos a representar grafos e até executando algoritmos conhecidos de grafos no grafo que criamos.
  • Resolvi que trabalharemos sempre com exemplos da "vida real". Neste artigo, vamos trabalhar com o Orkut como base, partindo do princípio que todo mundo sabe o que é o Orkut.

Neste primeiro artigo, só falarei sobre a definição do grafo e sua utilidade. Apresentarei as definições de: vértice, aresta, grau, grafo orientado, grau de entrada e grau de saída. Então, vamos lá!

A definição de grafo é muito simples. Segundo o Professor Cid Carvalho de Souza: Uma forma de representar uma relação binária entre elementos de um conjunto. Bom... É simplesmente uma representação de relações (que chamamos de arestas) entre objetos, que chamamos de vértices. Vamos logo ao exemplo: a amizade no Orkut.

Exemplo - Representação de um Grafo

Estão vendo esta árvore? Esta é a representação que chamamos de grafo. Vamos supor que este é o grafo das amizades do Orkut e as bolinhas nele são as seguintes pessoas:

  1. Eu
  2. João
  3. Maria
  4. José
  5. Pedro

Eu (número 1) tenho dois amigos: o João (número 2) e a Maria (número 3), porque estou ligado a eles. O João (número 2) tem três amigos: eu (número 1), a Maria (número 3) e o José (número 4). E assim podemos fazer com os outros contando as linhas que saem de cada pessoa.

Cada pessoa é um vértice e cada linha (relação entre duas pessoas) é uma aresta. Dizemos que é uma relação binária lá em cima, porque a relação é sempre entre dois vértices.

Os números de amigos que cada pessoa tem (o número de relações que cada vértice tem) é o que chamamos de "grau" de um vértice. Grau dos vértices do exemplo acima:

  1. 2
  2. 3
  3. 2
  4. 2
  5. 1

Pra quê serve o grafo?

Ora, se você consegue contar as arestas que saem de cada vértice na programação (se você sabe fazer algo básico como calcular o grau de um vértice), você pode oferecer seus serviços ao Google e ganhar milhões, pois, como todos sabem, o Orkut não sabe fazer isso direito!

Brincadeiras a parte... Grafos são extremamente úteis porque são representações bastante simples (você teve dificuldade para entender minha árvore ali em cima?) e essa estrutura deles aparece em muitos problemas computacionais. Além disso, existem muitos algoritmos eficientes para problemas complexos que utilizam estas representações.

Definições até agora

Traduzindo os conceitos do Orkut para os grafos:

  • Vértice: Pessoa.
  • Aresta: Amizade entre uma pessoa e outra.
  • Grau de um vértice: Número de amigos de uma pessoa.

Grafos Orientados

Um grafo é orientado quando eu sou seu amigo, mas você não é meu amigo. Você sabe que um grafo é orientado através da representação quando ele tem "setinhas", como o grafo abaixo.

Grafo orientado

Vamos supor que isso aí é um mapa do Brasil. Ele despreza as cidades que não são importantes para o país, levando apenas em consideração portanto: São Paulo, Florianópolis e Itajaí.

  • São Paulo é a bolinha vermelha.
  • Florianópolis é a bolinha amarela.
  • Itajaí é a bolinha azul.

As arestas indicam que há uma estrada para você ir de uma cidade para a outra, mas só dá pra ir no sentido da estrada, que as setas representam. Portanto, você pode ir de São Paulo, de São Paulo a Itajaí e Florianópolis a Itajaí, mas não de Itajaí para qualquer outro lugar.

Grau dos Vértices

Os graus dos vértices neste segundo grafo seriam os seguintes, certo?

  • São Paulo: 2
  • Florianópolis: 2
  • Itajaí: 2

Quase... Porém, nos grafos orientados nós temos dois tipos de grau diferentes. Dizemos que:

  • grau de entrada é o número de arestas que apontam para o vértice; e
  • grau de saída é o número de arestas que saem do vértice.

Portanto, os graus de entrada do nosso grafo são:

  • São Paulo: 0
  • Florianópolis: 1
  • Itajaí: 2

E os graus de saída:

  • São Paulo: 2
  • Florianópolis: 1
  • Itajaí: 0

Onde mais posso utilizar grafos?

Existem vários casos onde você vai querer usar grafos:

  • Mapas
  • Sua árvore genealógica
  • Hierarquia de uma empresa
  • Sistema de amizades do seu sistema de comunidades virtuais
  • ... e muito mais. Na OBI já apareceu até um jogo de dominó como problema de grafos!

Como veremos nos próximos artigos, tem algoritmo pra fazer "tudo" em grafos... Então representar alguma coisa em grafos é muito útil pra poder descobrir uma série de coisas.

A maioria das páginas que eu conheço sobre grafos são muito malignas porque apresentam uns 50 conceitos diferentes de grafos juntos (ex.: grafo conexo, grafo desconexo, caminho, ciclo, etc.). Nos meus artigos, devo tratar um assunto de cada vez para facilitar o entendimento. Então, vou parar por aqui hoje.

No próximo artigo: Como representar um grafo na programação? Você já pode ir pensando nisso...

]]> http://algoritmos.tiagomadeira.net/os-grafos-e-o-orkut/feed Mini-Poker http://algoritmos.tiagomadeira.net/mini-poker http://algoritmos.tiagomadeira.net/mini-poker#comments Fri, 13 Jan 2006 15:58:45 +0000 Tiago Madeira http://tiagomadeira.net/?p=86 Resolvi fazer uma pausa nos algoritmos de ordenação para mostrar como podemos usar os conhecimentos já adquiridos de maneira prática. Vamos neste artigo resolver o problema Mini-Poker, que caiu na prova da Programação Nível 2 (categoria para pessoas até 19 anos ou primeiro ano da faculdade) da Olimpíada Brasileira de Informática de 2005.

Esse post ficou gigante, mas é muito simples. Leia com atenção e acho que você não terá problemas... ;)

Objetivos

Com esta resolução de problema, espero treinar com vocês o conceito de:

  • Interpretação do Probema
  • Entrada e Saída
  • Ordenação por Inserção
  • Pseudocódigo

Acho que será legal para pôrmos em prática o que já estudamos sobre algoritmos.

O problema é bem simples, mas é só pra iniciar. Depois vamos resolvendo problemas cada vez mais difíceis... ;)

Enunciado

Mini-Poker é o nome do jogo de cartas que é uma simplificação de Poker, um dos mais famosos jogos de cartas do mundo. Mini-Poker é jogado com um baralho normal de 52 cartas, com quatro naipes (copas, paus, espadas e ouro), cada naipe compreendendo treze cartas (Ás, 2, 3, 4, 5, 6, 7, 8, 9, 10, Valete, Dama, Rei).

No início do jogo, cada jogador recebe cinco cartas. O conjunto de cinco cartas vale um certo número de pontos, de acordo com as regras descritas abaixo. Diferentemente do jogo de Poker normal, em Mini-poker o naipe das cartas é desconsiderado. Assim, para simplificar a descrição do jogo, vamos utilizar os números de 1 a 13 para identificar as cartas do baralho, na ordem dada acima. Uma outra diferença é que pode ocorrer empate entre mais de um vencedor; nesse caso os vencedores dividem o prêmio.

As regras para pontuação em Mini-Poker são as seguintes:

  1. Se as cinco cartas estão em seqüência a partir da carta LaTeX: x (ou seja, os valores das cartas são LaTeX: x, LaTeX: x+1, LaTeX: x+2, LaTeX: x+3 e LaTeX: x+4), a pontuação é LaTeX: x+200 pontos. Por exemplo, se as cartas recebidas são 10, 9, 8, 11 e 12, a pontuação é 208 pontos.
  2. Se há quatro cartas iguais LaTeX: x (uma quadra, ou seja, os valores das cartas são LaTeX: x, LaTeX: x, LaTeX: x, LaTeX: x e LaTeX: y), a pontuação é LaTeX: x+180 pontos. Por exemplo, se as cartas recebidas são 1, 1, 1, 10 e 1, a pontuação é 181 pontos.
  3. Se há três cartas iguais LaTeX: x e outras duas cartas iguais LaTeX: y (uma trinca e um par, ou seja, os valores das cartas são LaTeX: x, LaTeX: x, LaTeX: x, LaTeX: y e LaTeX: y), a pontuação é LaTeX: x+160 pontos. Por exemplo, se as cartas recebidas são 10, 4, 4, 10 e 4, a pontuação é 164 pontos.
  4. Se há três cartas iguais LaTeX: x e duas outras cartas diferentes LaTeX: y e LaTeX: z (uma trinca, ou seja, os valores das cartas são LaTeX: x, LaTeX: x, LaTeX: x, LaTeX: y e LaTeX: z), a pontuação é LaTeX: x+140 pontos. Por exemplo, se as cartas recebidas são 2, 3, 2, 2 e 13, a pontuação é 142 pontos.
  5. Se há duas cartas iguais LaTeX: x, duas outras cartas iguais LaTeX: y (LaTeX: x \neq{} y) e uma outra carta distinta LaTeX: z (dois pares, ou seja, os valores das cartas são LaTeX: x, LaTeX: x, LaTeX: y, LaTeX: y e LaTeX: z), a pontuação é LaTeX: 3 \times{} x + 2 \times{} y + 20 pontos, em que LaTeX: x > y. Por exemplo, se as cartas recebidas são 12, 7, 12, 8 e 7, a pontuação é 70 pontos.
  6. Se há apenas duas cartas iguais LaTeX: x e as outras são distintas (um par, ou seja, os valores das cartas são LaTeX: x, LaTeX: x, LaTeX: y, LaTeX: z e LaTeX: t), a pontuação é LaTeX: x pontos. Por exemplo, se as cartas recebidas são 12, 13, 5, 8 e 13, a pontuação é 13 pontos.
  7. Se todas as cartas são distintas, não há pontuação.

Tarefa

Escreva um programa que, fornecidas as cartas dadas a um jogador, calcule a pontuação do jogador naquela jogada.

Entrada

A entrada é composta por vários casos de teste, cada um correspondendo a uma jogada. A primeira linha da entrada contém um número inteiro LaTeX: N que indica o número de casos de teste (LaTeX: 1 \leq{} N \leq{} 100). Cada uma das LaTeX: N linhas seguintes contém cinco números inteiros LaTeX: C_{1}, LaTeX: C_{2}, LaTeX: C_{3}, LaTeX: C_{4} e LaTeX: C_{5}, representando as cinco cartas recebidas por um jogador (LaTeX: 1 \leq{} C_{1}, C_{2}, C_{3}, C_{4}, C_{5} \leq{} 13).

A entrada deve ser lida do dispositivo de entrada padrão (normalmente o teclado).

Saída

Para cada caso de teste da entrada, seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do caso de teste, no formato "Teste n", onde n é numerado seqüencialmente a partir de 1. A segunda linha deve conter a pontuação do jogador considerando as cinco cartas recebidas. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.

A saída deve ser escrita no dispositivo de saída padrã (normalmente a tela).

Restrições

LaTeX: 1 \leq{} N \leq{} 100

LaTeX: 1 \leq{} C_{1}, C_{2}, C_{3}, C_{4}, C_{5} \leq{} 13

Exemplo de Entrada

2
12 3 10 3 12
1 2 3 5 4

Saída para o Exemplo de Entrada

Teste 1
62

Teste 2
201

Comentários sobre os problemas de olimpíadas

Todos os problemas passados em competições de programação tem um enunciado parecido com o desse. São especificados todos os limites (restrições), é dito exatamente como será a entrada e como deve ser a saída e geralmente tem uma historinha no começo... :D

Bom... Todos esses dados são fundamentais. Alguns limites nem vamos usar, não tem importância para a nossa solução, mas pode ter importância para outra pessoa que queira implementar um algoritmo diferente. A sintaxe da entrada e da saída são extremamente importantes. Na prova da Seletiva IOI do ano passado, eu quase perdi 60 pontos (6 casos de teste) na solução de um problema simples porque meu programa desprezava um espaço no início de uma frase quando imprimia uma saída. E mesmo a historinha do começo é fundamental. Ela sempre dá boas dicas e algumas vezes até ilustra o problema (às vezes a gente nem lê o enunciado e já sabe que é um problema de grafos!)

Mas vamos a solução deste problema...

Por onde começar?

Com o tempo você pode decidir fazer um caminho diferente, mas eu sugiro começar sempre pelo recebimento da entrada. Aliás, acho que isto é atípico, porque a maioria das pessoas prefere ler bastante o problema e desenvolver todo o algoritmo a mão antes de botar a mão na massa. Eu acho que depois que a gente recebe a entrada, fica bem mais fácil fazer o resto e a gente pode ir pensando enquanto a gente recebe a entrada! Então, depois que lemos o problema e já entendemos tudo o que ele quer, vamos fazer a entrada!

O problema fala que começa nos dando um número N que será o número de casos de teste que teremos que receber depois. Sem dificuldade podemos escrever o pseudocódigo a seguir:

recebe N
para nteste LaTeX: leftarrow{} 1 até N, faça
fim-para

Já chamo a variável que loopa como nteste, porque já li a saída do problema e sei que vou precisar imprimir o número de caad caso de teste... ;)

Aí o enunciado diz que Cada uma das LaTeX: N linhas seguintes contém cinco números inteiros LaTeX: C_{1}, LaTeX: C_{2}, LaTeX: C_{3}, LaTeX: C_{4} e LaTeX: C_{5}, representando as cinco cartas recebidas por um jogador (LaTeX: 1 \leq{} C_{1}, C_{2}, C_{3}, C_{4}, C_{5} \leq{} 13). Então, vamos receber os cinco números em cada iteração e colocá-los num vetor, é claro!

recebe N
para nteste LaTeX: leftarrow{} 1 até N, faça
	recebe LaTeX: C_{1}, C_{2}, C_{3}, C_{4}, C_{5}
fim-para

E a entrada está pronta.

Desenvolvimento

O programa se baseia em encontrarmos valores iguais nos elementos do vetor. O que podemos fazer para facilitar essa tarefa?

Isso mesmo: A ordenação! :D Se os elementos estiverem ordenados, ficará bem mais fácil para procurarmos quatro números iguais, porque eles não poderão ser qualquer uma das possibilidades, mas somente LaTeX: C_{1}, C_{2}, C_{3}, C_{4} ou LaTeX: C_{2}, C_{3}, C_{4}, C_{5}.

Aí que algoritmos devemos implementar para ordenar? Isso é uma conclusão que vamos chegar no final de nossa série, mas para este algoritmo não tem solução melhor que a Ordenação por Inserção. É um caso pequeno (n=5) e a Ordenação por Inserção é mais rápida que a por Seleção, porque o seu melhor caso é uma função linear. Então, vamos implementar o Insertion Sort no nosso algoritmo:

recebe N
para nteste LaTeX: leftarrow{} 1 até N, faça
	recebe LaTeX: C_{1}, C_{2}, C_{3}, C_{4}, C_{5}
	início da ordenação por inserção
	para j LaTeX: leftarrow{} 2 até 5
		elemento LaTeX: leftarrow{} LaTeX: C_{j}
		i LaTeX: leftarrow{} j-1
		enquanto i > 0 e LaTeX: C_{i} > elemento, faça
			LaTeX: C_{i+1} LaTeX: leftarrow{} LaTeX: C_{i}
			LaTeX: i LaTeX: leftarrow{} LaTeX: C_{i-1}
		fim-enquanto
		LaTeX: C_{i+1} LaTeX: leftarrow{} elemento
	fim-para
	fim da ordenação por inserção
fim-para

O bom desses algoritmos de ordenação é que sua lógica é muito simples e por isso é fácil decorá-los... Ao menos o Insertion Sort e o Selection Sort são algoritmos básicos que todo programador deve conhecer bem. Bom... Acredito que vocês não tenham tido dificuldade pra entender até aqui. A cor vermelha no pseudocódigo eu vou usar daqui pra frente para um comentário, que aliás, é uma excelente prática de boa programação.

O resto do problema precisa calcular quantos pontos o cara fez, baseado em suas cartas, agora já ordenadas. Para isto vamos criar uma função para testar vários se e retornar o resultado.

Eu poderia tirar os se aninhados, mas assim fica mais fácil a compreensão.

Como vamos ver com os pseudocódigos a seguir, é fácil testar cada uma das regras com o vetor ordenado:

Primeira Regra - Seqüência

Se as cinco cartas estão em seqüência a partir da carta LaTeX: x (ou seja, os valores das cartas são LaTeX: x, LaTeX: x+1, LaTeX: x+2, LaTeX: x+3 e LaTeX: x+4), a pontuação é LaTeX: x+200 pontos. Por exemplo, se as cartas recebidas são 10, 9, 8, 11 e 12, a pontuação é 208 pontos.

se LaTeX: C_{1} = C_{2}-1 e LaTeX: C_{2} = C_{3}-1 e LaTeX: C_{3}=C_{4}-1 e LaTeX: C_{4}=C_{5}-1, então
 	retorna LaTeX: C_{1}+200
fim-se

Segunda Regra - Quadra

Se há quatro cartas iguais LaTeX: x (uma quadra, ou seja, os valores das cartas são LaTeX: x, LaTeX: x, LaTeX: x, LaTeX: x e LaTeX: y), a pontuação é LaTeX: x+180 pontos. Por exemplo, se as cartas recebidas são 1, 1, 1, 10 e 1, a pontuação é 181 pontos.

se LaTeX: C_{1} = C_{2} = C_{3} = C_{4} ou LaTeX: C_{2} = C_{3} = C_{4} = C_{5}, então
	retorna LaTeX: C_{2}+180
fim-se

Aqui retornamos LaTeX: C_{2} porque ele será sempre parte da quadra (ela começando em LaTeX: C_{1} ou LaTeX: C_{2}).

Terceira e Quarta Regra - Trinca

Se há três cartas iguais LaTeX: x e outras duas cartas iguais LaTeX: y (uma trinca e um par, ou seja, os valores das cartas são LaTeX: x, LaTeX: x, LaTeX: x, LaTeX: y e LaTeX: y), a pontuação é LaTeX: x+160 pontos. Por exemplo, se as cartas recebidas são 10, 4, 4, 10 e 4, a pontuação é 164 pontos.

se LaTeX: C_{1} = C_{2} = C_{3} ou LaTeX: C_{2} = C_{3} = C_{4} ou LaTeX: C_{3} = C_{4} = C_{5}, então
	se ( LaTeX: C_{1} neq{} C_{3} e LaTeX: C_{1} = C_{2} ) ou ( LaTeX: C_{3} neq{} C_{5} e LaTeX: C_{4} = C_{5} ), então
		retorna LaTeX: C_{3}+160

Se há três cartas iguais LaTeX: x e duas outras cartas diferentes LaTeX: y e LaTeX: z (uma trinca, ou seja, os valores das cartas são LaTeX: x, LaTeX: x, LaTeX: x, LaTeX: y e LaTeX: z), a pontuação é LaTeX: x+140 pontos. Por exemplo, se as cartas recebidas são 2, 3, 2, 2 e 13, a pontuação é 142 pontos.

	senão
		retorna LaTeX: C_{3} + 140
	fim-se
fim-se

Note que aqui retornamos LaTeX: C_{3} porque ele será sempre parte da trinca (o mesmo motivo que retornarmos LaTeX: C_{2} para a quadra).

Quinta Regra - Duas Duplas

Se há duas cartas iguais LaTeX: x, duas outras cartas iguais LaTeX: y (LaTeX: x \neq{} y) e uma outra carta distinta LaTeX: z (dois pares, ou seja, os valores das cartas são LaTeX: x, LaTeX: x, LaTeX: y, LaTeX: y e LaTeX: z), a pontuação é LaTeX: 3 \times{} x + 2 \times{} y + 20 pontos, em que LaTeX: x > y. Por exemplo, se as cartas recebidas são 12, 7, 12, 8 e 7, a pontuação é 70 pontos.

se LaTeX: C_{1} = C_{2} ou LaTeX: C_{2} = C_{3}, então
	se LaTeX: C_{3} = C_{4} ou LaTeX: C_{4} = C_{5}, então
		retorna LaTeX: 3 times{} C_{4} + 2 times{} C_{2} +20
	fim-se
fim-se

LaTeX: C_{2} será sempre elemento da menor dupla e LaTeX: C_{4} será sempre elemento da maior dupla. Por isso usamos eles como LaTeX: y e LaTeX: x, respectivamente.

Sexta Regra - Dupla

Se há apenas duas cartas iguais LaTeX: x e as outras são distintas (um par, ou seja, os valores das cartas são LaTeX: x, LaTeX: x, LaTeX: y, LaTeX: z e LaTeX: t), a pontuação é LaTeX: x pontos. Por exemplo, se as cartas recebidas são 12, 13, 5, 8 e 13, a pontuação é 13 pontos.

se LaTeX: C_{1} = C_{2} ou LaTeX: C_{2} = C_{3}, então
	retorna LaTeX: C_{2}
senão se LaTeX: C_{3} = C_{4} ou LaTeX: C_{4} = C_{5},
então
	retorna LaTeX: C_{4}
fim-se

Separei em dois SEs porque senão não saberíamos que valor retornar.

Sétima Regra

Se todas as cartas são distintas, não há pontuação.

retorna 0

Função Inteira

Juntando todos os SEs, temos:

função pontua (C)

primeira regra
se LaTeX: C_{1} = C_{2}-1 e LaTeX: C_{2} = C_{3}-1 e LaTeX: C_{3}=C_{4}-1 e LaTeX: C_{4}=C_{5}-1, então
 	retorna LaTeX: C_{1}+200
fim-se

segunda regra
se LaTeX: C_{1} = C_{2} = C_{3} = C_{4} ou LaTeX: C_{2} = C_{3} = C_{4} = C_{5}, então
	retorna LaTeX: C_{2}+180
fim-se

terceira e quarta regra
se LaTeX: C_{1} = C_{2} = C_{3} ou LaTeX: C_{2} = C_{3} = C_{4} ou LaTeX: C_{3} = C_{4} = C_{5}, então
	se ( LaTeX: C_{1} neq{} C_{3} e LaTeX: C_{1} = C_{2} ) ou ( LaTeX: C_{3} neq{} C_{5} e LaTeX: C_{4} = C_{5} ), então
		retorna LaTeX: C_{3}+160
	senão
		retorna LaTeX: C_{3} + 140
	fim-se
fim-se

quinta regra
se LaTeX: C_{1} = C_{2} ou LaTeX: C_{2} = C_{3}, então
	se LaTeX: C_{3} = C_{4} ou LaTeX: C_{4} = C_{5}, então
		retorna LaTeX: 3 times{} C_{4} + 2 times{} C_{2} +20
	fim-se
fim-se

sexta regra
se LaTeX: C_{1} = C_{2} ou LaTeX: C_{2} = C_{3}, então
	retorna LaTeX: C_{2}
senão se LaTeX: C_{3} = C_{4} ou LaTeX: C_{4} = C_{5},
então
	retorna LaTeX: C_{4}
fim-se

sétima regra
retorna 0

fim-função

Já que a função retorna assim que encontra um resultado, não há risco de ocorrer nada errado (por exemplo, uma quadra é sempre uma trinca, que é sempre uma dupla). Agora basta colocarmos esta função no nosso código e adaptar para a saída ser igual a que o problema pede.

Saída

Para chegar a saída, basta fazermos o programa imprimir Teste nteste e depois o retorno da função pontua. Com isto, temos:

recebe N
para nteste LaTeX: leftarrow{} 1 até N, faça
	recebe LaTeX: C_{1}, C_{2}, C_{3}, C_{4}, C_{5}
	início da ordenação por inserção
	para j LaTeX: leftarrow{} 2 até 5
		elemento LaTeX: leftarrow{} LaTeX: C_{j}
		i LaTeX: leftarrow{} j-1
		enquanto i > 0 e LaTeX: C_{i} > elemento, faça
			LaTeX: C_{i+1} LaTeX: leftarrow{} LaTeX: C_{i}
			LaTeX: i LaTeX: leftarrow{} LaTeX: C_{i-1}
		fim-enquanto
		LaTeX: C_{i+1} LaTeX: leftarrow{} elemento
	fim-para
	fim da ordenação por inserção

	imprime "Teste "
	imprime linha testen
	imprime linha pontua(C)
	imprime linha
fim-para

Fiz essa saída assim pra se parecer com Pascal, mas para cada linguagem ela pode ser bem diferente... Vejamos dois exemplos...

C

printf("Teste %dn%dnn", nteste, pontua(C));

PHP

echo "Teste ".$nteste."n".pontua($C)."nn";

Programa Completo

função pontua (C)

primeira regra
se LaTeX: C_{1} = C_{2}-1 e LaTeX: C_{2} = C_{3}-1 e LaTeX: C_{3}=C_{4}-1 e LaTeX: C_{4}=C_{5}-1, então
 	retorna LaTeX: C_{1}+200
fim-se

segunda regra
se LaTeX: C_{1} = C_{2} = C_{3} = C_{4} ou LaTeX: C_{2} = C_{3} = C_{4} = C_{5}, então
	retorna LaTeX: C_{2}+180
fim-se

terceira e quarta regra
se LaTeX: C_{1} = C_{2} = C_{3} ou LaTeX: C_{2} = C_{3} = C_{4} ou LaTeX: C_{3} = C_{4} = C_{5}, então
	se ( LaTeX: C_{1} neq{} C_{3} e LaTeX: C_{1} = C_{2} ) ou ( LaTeX: C_{3} neq{} C_{5} e LaTeX: C_{4} = C_{5} ), então
		retorna LaTeX: C_{3}+160
	senão
		retorna LaTeX: C_{3} + 140
	fim-se
fim-se

quinta regra
se LaTeX: C_{1} = C_{2} ou LaTeX: C_{2} = C_{3}, então
	se LaTeX: C_{3} = C_{4} ou LaTeX: C_{4} = C_{5}, então
		retorna LaTeX: 3 times{} C_{4} + 2 times{} C_{2} +20
	fim-se
fim-se

sexta regra
se LaTeX: C_{1} = C_{2} ou LaTeX: C_{2} = C_{3}, então
	retorna LaTeX: C_{2}
senão se LaTeX: C_{3} = C_{4} ou LaTeX: C_{4} = C_{5},
então
	retorna LaTeX: C_{4}
fim-se

sétima regra
retorna 0

fim-função

recebe N
para nteste LaTeX: leftarrow{} 1 até N, faça
	recebe LaTeX: C_{1}, C_{2}, C_{3}, C_{4}, C_{5}
	início da ordenação por inserção
	para j LaTeX: leftarrow{} 2 até 5
		elemento LaTeX: leftarrow{} LaTeX: C_{j}
		i LaTeX: leftarrow{} j-1
		enquanto i > 0 e LaTeX: C_{i} > elemento, faça
			LaTeX: C_{i+1} LaTeX: leftarrow{} LaTeX: C_{i}
			LaTeX: i LaTeX: leftarrow{} LaTeX: C_{i-1}
		fim-enquanto
		LaTeX: C_{i+1} LaTeX: leftarrow{} elemento
	fim-para
	fim da ordenação por inserção

	imprime "Teste "
	imprime linha testen
	imprime linha pontua(C)
	imprime linha
fim-para

Comentários sobre o problema

Este problema é muito chato. É trivial, mas perdemos um tempo enorme escrevendo ses. Ninguém gosta de um problema como esse, mas quando cai numa olimpíada somos obrigados a resolver... hehehe... Mas, para a felicidade geral de todos, saibam que a maioria dos problemas de olimpíadas não são assim. Exigem mais lógica e menos código. Com o tempo, vamos pegando problemas mais difíceis. Espero só ter cumprido meu objetivo dando uma utilidade pra ordenação, entrada e saída e que vocês tenham entendido tudo.

Espero que tenham gostado da solução. Eu implementei este programa em C há seis meses e se você estiver interessado, sua solução está aqui: poker.c.

Sugiro que quem esteja aprendendo algoritmos com meus artigos e já saiba programar um pouquinho, resolva alguns problemas simples do site da OBI, que separei especialmente pra vocês!

E, gostaria de fixar, mais importante é a interpretação e o seu pensamento... Programar é fácil! :D

]]> http://algoritmos.tiagomadeira.net/mini-poker/feed Ordenação por Seleção http://algoritmos.tiagomadeira.net/ordenacao-por-selecao http://algoritmos.tiagomadeira.net/ordenacao-por-selecao#comments Fri, 13 Jan 2006 10:50:14 +0000 Tiago Madeira http://tiagomadeira.net/?p=84 Hoje vou apresentar mais um algoritmo de ordenação de vetores. É a Ordenação por Seleção (ou Selection Sort). Sem mais papo e antes mesmo da explicação, vamos ao seu pseudocódigo:

1. para i LaTeX: leftarrow{} 1 até tamanho-1, faça
2.	minimo LaTeX: leftarrow{} i
3.	para j LaTeX: leftarrow{} i+1 até tamanho, faça
4.		se vetor[j] < vetor[minimo], então
5.			minimo LaTeX: leftarrow{} j
6.		fim-se
7.	fim-para
8.	temp LaTeX: leftarrow{} vetor[i]
9.	vetor[i] LaTeX: leftarrow{} vetor[minimo]
10.	vetor[minimo] LaTeX: leftarrow{} temp
11. fim-para

tamanho = comprimento do vetor

Funcionamento

A idéia é sempre procurar o menor elemento do vetor e inseri-lo no início do vetor. Procuramos o menor valor do vetor e colocamos ele em vetor[1]. Procuramos o menor valor do vetor excluindo o já colocado e colocamos ele em vetor[2]. E assim vamos indo até termos todo o vetor ordenado.

Partindo sempre a partir do último elemento reordenado (a partir do i), o programa procura o menor elemento no vetor e o substitue pelo elemento i atual.

Exemplo de Funcionamento

O programa recebe o seguinte vetor.

v[1] v[2] v[3] v[4] v[5] v[6]
5 3 7 8 2 5

Aí ele começa com LaTeX: i=1. Vou sempre marcar LaTeX: i com a cor preta e LaTeX: min com a cor cinza.

v[1] v[2] v[3] v[4] v[5] v[6]
5 3 7 8 2 5

Ele marca o próprio índice i como a variável minimo, que é sempre o menor elemento do vetor. Então, ele faz um para de LaTeX: j=2 até o comprimento do vetor, com o objetivo de descobrir qual o menor elemento.

LaTeX: j=2 ... LaTeX: v[j] = 3 < v[minimo] = v[1] = 5, portanto LaTeX: minimo = j = 2.

v[1] v[2] v[3] v[4] v[5] v[6]
5 3 7 8 2 5

LaTeX: j=3 ... LaTeX: v[j] = 7 > v[minimo] = v[2] = 3, portanto não mexemos em nada.

LaTeX: j=4 ... LaTeX: v[j] = 8 > v[minimo] = v[2] = 3, portanto não mexemos em nada.

LaTeX: j=5 ... LaTeX: v[j] = 2 < v[minimo] = v[2] = 3, portanto LaTeX: minimo = j = 5.

v[1] v[2] v[3] v[4] v[5] v[6]
5 3 7 8 2 5

LaTeX: j=6 ... LaTeX: v[j] = 5 > v[minimo] = v[5] = 2, portanto não mexemos em nada.

Agora substituímos o v[minimo] pelo v[i], formando com isto o novo vetor:

v[1] v[2] v[3] v[4] v[5] v[6]
2 3 7 8 5 5

E assim vamos fazendo com os outros elementos até que todo o vetor esteja ordenado.

Custo

Este algoritmo não tem um melhor/pior caso, porque todos os elementos são varridos, sempre. Medir seu custo é simples. Custo de linha por linha...

n = tamanho do vetor

  1. LaTeX: n
  2. LaTeX: n-1
  3. LaTeX: \sum_{j=1}^{n} + n
  4. LaTeX: \sum_{j=1}^{n}
  5. LaTeX: \sum_{j=1}^{n} ???
  6. LaTeX: 0
  7. LaTeX: 0
  8. LaTeX: n-1
  9. LaTeX: n-1
  10. LaTeX: n-1
  11. LaTeX: 0

Você pode estar se perguntando porque eu coloquei este custo para a linha 5. Afinal, a linha 5 diria que este programa tem um melhor/pior caso, porque ela não seria executada se o se retornar falso. Mas o caso é que ela é desprezível. Uma soma como estas para o custo geral do nosso algoritmo não vai influenciar em nada. Quer ver? Vamos somar os custos com esta linha valendo LaTeX: 0 (como se nenhum se entrasse) e depois com ela valendo LaTeX: \sum_{j=1}^{n}.

Primeiro cálculo

LaTeX: T(n) LaTeX: = LaTeX: (n) LaTeX: + LaTeX: (n-1) LaTeX: + LaTeX: (\sum_{j=1}^{n} + n) LaTeX: + LaTeX: (\sum_{j=1}^{n}) LaTeX: + LaTeX: (0) LaTeX: + LaTeX: (0) LaTeX: + LaTeX: (0) LaTeX: + LaTeX: (n-1) LaTeX: + LaTeX: (n-1) LaTeX: + LaTeX: (n-1) LaTeX: + LaTeX: (0)

LaTeX: T(n) = n^{2} + 6n -3

LaTeX: \Theta{}(n^{2}) = f(n)

Segundo cálculo

LaTeX: T(n) LaTeX: = LaTeX: (n) LaTeX: + LaTeX: (n-1) LaTeX: + LaTeX: (\sum_{j=1}^{n} + n) LaTeX: + LaTeX: (\sum_{j=1}^{n}) LaTeX: + LaTeX: (\sum_{j=1}^{n}) LaTeX: + LaTeX: (0) LaTeX: + LaTeX: (0) LaTeX: + LaTeX: (n-1) LaTeX: + LaTeX: (n-1) LaTeX: + LaTeX: (n-1) LaTeX: + LaTeX: (0)

LaTeX: T(n) = 1,5 n^{2} + 6,5 n - 3

LaTeX: \Theta{}(n^{2}) = f(n)

Conclusão

Como vocês puderam ver, não faz diferença alguma o LaTeX: \frac{n^{2} + n}{2} que aquela somatória nos proporciona. Já que todo o cálculo de algoritmos é baseado apenas no maior expoente de n e desprezamos todas as constantes (inclusive as que multiplicam o n de maior expoente, muitos passos são desprezíveis.

]]> http://algoritmos.tiagomadeira.net/ordenacao-por-selecao/feed Ordenação por Inserção http://algoritmos.tiagomadeira.net/ordenacao-por-insercao http://algoritmos.tiagomadeira.net/ordenacao-por-insercao#comments Wed, 11 Jan 2006 20:32:04 +0000 Tiago Madeira http://tiagomadeira.net/?p=82 Também conhecida como Insertion Sort, a Ordenação por Inserção consiste em inserir um elemento LaTeX: n num vetor já ordenado de LaTeX: n-1 elementos. Neste artigo, apresento-lhes este simples algoritmo para ordenação de vetores.

O pseudocódigo da ordenação por inserção é o seguinte:

1. para j LaTeX: leftarrow{} 2 até comprimento do vetor, faça
2.	elemento LaTeX: leftarrow{} vetor[j]
3.	i LaTeX: leftarrow{} j - 1
4.	enquanto i > 0 e vetor[i] > elemento, faça
5.		vetor[i + 1] LaTeX: leftarrow{} vetor[i]
6.		i LaTeX: leftarrow{} i - 1
7.	fim-enquanto
8.	vetor[i + 1] LaTeX: leftarrow{} elemento
9. fim-para

Para explicar eu vou fazer uma coisa que sempre faço para corrigir meus algoritmos, fingir que sou o programa, executando cada passo manualmente (claro que geralmente faço mais rápido, porque não preciso escrever tudo que faço). Vamos iniciar com o seguinte vetor v.

v[1] v[2] v[3] v[4] v[5] v[6]
5 3 7 8 2 5

Aí o código me manda começar com LaTeX: j=2 e iterar até o comprimento do vetor (6). A primeira ordem que ele me dá é para armazenar o elemento LaTeX: a[j] (LaTeX: a[2]) na variável elemento. Para facilitar toda a explicação eu vou sempre pintar de cinza o LaTeX: v[j] onde eu estou (no caso, o segundo elemento do vetor, 3) e de preto o vetor ainda não ordenado (elementos LaTeX: \geq{}j).

v[1] v[2] v[3] v[4] v[5] v[6]
5 3 7 8 2 5

Então ele me diz que LaTeX: i \leftarrow{} j-1. Portanto, LaTeX: i=1. E agora ele me faz um enquanto (que poderia ser substituído por para) onde meu i deverá ir diminuindo. Vamos entrar no loop...

Bom, meu LaTeX: i =1 é maior que 0. LaTeX: v[1]=5 é maior que o LaTeX: elemento=3? Sim, então vamos entrar no corpo do enquanto... Aqui ele me manda fazer um LaTeX: vetor[i+1] = vetor[i], que nesse caso é fazer um LaTeX: v[2]=v[1]=5.

v[1] v[2] v[3] v[4] v[5] v[6]
5 5 7 8 2 5

E agora subtrae de i um valor. Portanto, LaTeX: i=0. Ele retorna ao enquanto, mas agora não satisfazemos a condição LaTeX: i>0, por isso saímos do enquanto. Então ele pede para LaTeX: vetor[i+1]=elemento (LaTeX: v[1]=elemento). Portanto, o vetor fica assim:

v[1] v[2] v[3] v[4] v[5] v[6]
3 5 7 8 2 5

E incrementamos o j, agora LaTeX: j=3.

v[1] v[2] v[3] v[4] v[5] v[6]
3 5 7 8 2 5

LaTeX: elemento = 7

LaTeX: i = 3-1 = 2

LaTeX: i > 0 ... E LaTeX: 5 > 7? Não! Portanto, não entramos no enquanto.

LaTeX: v[3] = elemento (nenhuma mudança)

E lá vamos para LaTeX: j=4 e continuando até que vamos ter o vetor ordenado:

v[1] v[2] v[3] v[4] v[5] v[6]
2 3 5 5 7 8

Qual a lógica?

Como eu já disse na introdução, mas lá sem grandes explicações, a Ordenação por Inserção divide o vetor em dois. O primeiro (de elementos LaTeX: <j) contém todos seus valores ordenados e o segundo (de elementos LaTeX: \geq{}j) contém os valores que devem ser inseridos no primeiro vetor já ordenado (por isso ele se chama Algoritmo de Inserção).

A chave do algoritmo é o enquanto que acontece para ir deslocando todos os elementos para seu índice LaTeX: +1 enquanto o elemento for menor que eles (para depois o elemento ser colocado onde parou).

A variável elemento só serve para não perdermos o valor de LaTeX: v[j] (porque depois fazemos LaTeX: v[i+1]=v[i] quando LaTeX: i=j-1)

Acredito que não tenham restado dúvidas. Dê mais uma olhada no algoritmo e tente implementar. Se tiver dificulade, coloque mensagens de debug estratégicas para entender o algoritmo. (ex.: no início do para coloque para imprimir o valor de j e no início de cada enquanto coloque para imprimir os valores elemento, i e v[i])

Custo

Você deve ter percebido que este algoritmo não tem um custo fixo. Se todo o vetor estiver ordenado, ele nunca precisará iterar o LaTeX: i e portanto será executado bem mais rápido do que se o vetor estiver inteiro em ordem decrescente (quando ele sempre precisará iterar LaTeX: i até o fim - 0). Então, neste artigo, gostaria-lhes de apresentar a análise de algoritmos baseada em casos. Para este programa, dizemos que:

  • Melhor caso é quando todos os elementos já estão ordenados. Custo: LaTeX: \Theta{}(n)
  • Pior caso é quando os elementos estão em ordem decrescente. Custo: LaTeX: \Theta{}(n^{2})

Em alguns programas o caso médio é importante também, mas não é o caso da ordenação por inserção. Vemos que há uma diferença bem grande entre o custo dos dois casos. Por isso, precisamos conhecer onde que nosso algoritmo será implementado e quais as chances de ele ser o melhor ou pior caso. Em geral, o pior caso é o mais comum... Por isso, diremos que o custo deste algoritmo é LaTeX: \Theta{}(n^{2}).

]]> http://algoritmos.tiagomadeira.net/ordenacao-por-insercao/feed Introdução à Ordenação de Vetores http://algoritmos.tiagomadeira.net/ordenacao http://algoritmos.tiagomadeira.net/ordenacao#comments Mon, 09 Jan 2006 23:52:10 +0000 Tiago Madeira http://tiagomadeira.net/?p=81 O que é um vetor?

Vetor é uma estrutura de dados que serve para substituir várias variáveis. Para um problema pequeno onde desejo armazenar dois inteiros e tirar o MMC deles eu posso usar duas variáveis: n1 e n2. Mas existem casos em que seria um número muito grande de variáveis (e em alguns deles nem sabemos ao certo, porque faremos uma alocação a partir de um número que o usuário pedir), por isso vetores são extremamente úteis.

No que consiste a ordenação?

Os algoritmos de ordenação tem como objetivo permutar uma seqüência LaTeX: n_{1}, n_{2}, n_{3}, \ldots{} de forma que LaTeX: n_{1} \leq{} n_{2} \leq{} n_{3} \leq{} \ldots{}. A ordenação não precisa ser exatamente de um vetor, mas vetor é geralmente a estrutura que usamos para guardar uma lista de números para podermos ordená-los.

Por que ordenar?

Citando o Cormen:

  • Às vezes, a necessidade de ordenar informações é inerente a uma aplicação. Por exemplo, para preparar os extratos de clientes, os bancos precisam ordenar os cheques pelo número do cheque.
  • Os algoritmos freqüentemente usam a ordenação como uma sub-rotina chave. Por exemplo, um programa que apresenta objetos gráficos dispostos em camadas uns sobre os outros talvez tenha de ordenar os objetos de acordo com uma relação "acima", de forma a poder desenhar esses objetos de baixo para cima.
  • Existe uma ampla variedade de algoritmos de ordenação, e eles empregam um rico conjunto de técnicas. De fato, muitas técnicas importantes usadas ao longo do projeto de algoritmos são representadas no corpo de algoritmos de ordenação que foram desenvolvidos ao longo dos anos. Desse modo, a ordenação também é um problema de interesse histórico.

Algoritmos de ordenação

Você encontra nos links a esquerda, logo abaixo do título deste post (Introdução à Ordenação de Vetores)

]]> http://algoritmos.tiagomadeira.net/ordenacao/feed Recursão http://algoritmos.tiagomadeira.net/algoritmos-recursivos http://algoritmos.tiagomadeira.net/algoritmos-recursivos#comments Sun, 08 Jan 2006 20:38:18 +0000 Tiago Madeira http://tiagomadeira.net/?p=80 A recursão é uma das técnicas mais simples e úteis que existem para usarmos em nossos algoritmos. Consiste em uma função (denominada recursiva) chamar a si mesmo, até que o retorno seja trivial. Resolvi abordá-la aqui porque alguns algoritmos que estudaremos mais para frente usam funções recursivas.

Gostaria de, antes de falar sobre o assunto, contar um pouco da minha história com recursão, porque foi meu início no mundo dos algoritmos.

Junho de 2004, tinha eu 13 anos e fui premiado com medalha de ouro na modalidade iniciação da Olimpíada de Informática. Fui convidado para o curso de introdução a programação na UNICAMP e, extremamente geek como eu era (e ainda sou), falei para os professores que já programava em C e então eles sugeriram que eu fosse para o curso de programação avançada.

No entanto, eu ainda achava muito complicado os algoritmos da modalidade de programação da OBI, por isso pedi pra ficar num "meio-termo". Eles toparam numa boa e com isso passei a ter aulas com um monitor excelente (aluno da UNICAMP) chamado Ribamar. Esse cara foi extremamente importante para minha iniciação na programação de verdade.

Na primeira tarde que tive aula com ele, ele perguntou se eu sabia o que era recursão. Respondi que não e, a partir daquele dia e depois de ele me ensinar também de grafos e programação dinâmica, além de me apresentar o Slackware, me tornei um amante de algoritmos. A recursão, portanto, mesmo sendo algo simples, é um assunto especial pra mim porque representa a mudança de "nível".

Então, mãos à obra!

Em matemática, o número fatorial de LaTeX: n é igual a: LaTeX: n \times{} n-1 \times{} n-2 \times{} \ldots{} 2 \times{} 1.

Logo, por exemplo, LaTeX: 5! (cinco fatorial) seria igual a: LaTeX: 5 \times{} 4 \times{} 3 \times{} 2 \times{} 1 = 120.

Um exemplo bom e simples de recursão é um algoritmo para determinar números fatoriais:

1. função fatorial (n)
2.	se LaTeX: n = 1, então
3.		retorna LaTeX: 1
4.	senão
5.		retorna LaTeX: n times{} fatorial(n-1)
6.	fim-se
7. fim-função

Domínio de nossa função: LaTeX: n \in{} \mathbf{N} / n \geq{} 1.

Qual o custo desse algoritmo?

Vamos abrir um grande parênteses aqui até a próxima linha horizontal para descobrir qual o custo do nosso algoritmo antes de continuar com a conversa sobre recursão e relembrar/reforçar o post sobre Análise de Algoritmos. Vou colocar o número de vezes que cada instrução é executada, usando o esquema que será o padrão para as próximas vezes que veremos custos:

Número da linha: Número de vezes que é executada..

  1. LaTeX: n
  2. LaTeX: n-1
  3. LaTeX: 1
  4. LaTeX: n-1
  5. LaTeX: n-1

LaTeX: T(n) = (n) + (n-1) + (1) + (n-1) + (n-1) = 4n - 2

Uma função linear, o tipo de algoritmo mais simples que podemos encontrar, com excessão dos que são uma função constante. Mas o parênteses na verdade não serviu só pra isso. Eu queria aproveitar pra escovar uns bits de nosso código. Você percebeu que o primeiro condicional é executado LaTeX: n-1 vezes, mas só entramos nele uma vez? Então vamos inverter nosso condicional.

1. função fatorial (n)
2.	se LaTeX: n > 1, então
3.		retorna LaTeX: n times{} fatorial(n-1)
4.	senão
5.		retorna LaTeX: 1
6.	fim-se
7. fim-função

Novo custo

  1. LaTeX: n
  2. LaTeX: n-1
  3. LaTeX: n-1
  4. LaTeX: 1
  5. LaTeX: 1

LaTeX: T(n) = (n) + (n-1) + (n-1) + (1) + (1) = 3n

Claro que continua uma função linear, não houve nenhuma grande mudança. Os dois continuam com a mesma ordem de crescimento e tal... LaTeX: 4n+2 comparado com LaTeX: 3n é uma diferença pequena, mas essa solução ficou bem mais elegante. ;) Poxa, diminuímos o custo do algoritmo em LaTeX: \frac{1}{4}! Hehehe...

Agora, antes de continuar, só vamos definir a notação assintótica desse nosso novo custo!

A fórmula do LaTeX: \Theta{} é: LaTeX: 0 \leq{} c_{1} g(n) \leq{} f(n) \leq{} c_{2} g(n)

Substituindo pela nossa função, temos: LaTeX: c_{1}n \leq{} 3n \leq{} c_{2}n. É trivial, que podemos escolher para as duas constantes LaTeX: c_{1}=c_{2}=3 e para LaTeX: n_{0}=0. Com isso pretendi mostrar-lhes uma conclusão óbvia que no outro artigo não tinha mostrado para não complicar muito: uma função reta (linear) pertence sempre a notação LaTeX: \Theta{}(n) e uma função quadrática pertence sempre a notação LaTeX: \Theta{}(n^{2}) (ora, façam um gráfico das funções e vejam se isso não é óbvio!). Mas vamos aprendendo mais sobre análise de algoritmos com o tempo...

Bom... Continuando com a recursão... Nossa função cria um loop consigo mesma, ao invés de usar um para (for) ou enquanto (while). Ela se repete diminuindo um de LaTeX: n a cada iteração, até que chegue ao valor mínimo LaTeX: 1 aonde a resposta é trivial: LaTeX: 1.

O que é necessário para criarmos uma recursão? Apenas um ponto de parada! Temos que tomar cuidado para não criarmos loops infinitos cuidando sempre com cada entrada que o usuário pode colocar. Nesse caso, eu determinei que o domínio da função é LaTeX: n \in{} \mathbf{N} / n \geq{} 1. Se o cara colocasse LaTeX: n=0, minha função iria diminuindo infinitamente... e nunca iria retornar nada!

Para fazer a recursão portanto, precisamos analisar o domínio de nossa função e mais: precisamos conhecer um valor (que vai ser o limite; no caso do fatorial, o valor que sabíamos é que LaTeX: 1! = 1).

Acredito que vocês tenham achado tudo simples e que não tenham problema com isso. Funções recursivas vão ser extremamente úteis para nós nos próximos artigos. Vou finalizar mostrando-lhes alguns casos básicos de algoritmos em que podemos usar a recursão:

Números de Fibonacci

1. função fibonacci (n)
2.	se LaTeX: n geq{} 3, então
3.		retorna LaTeX: fibonacci(n-1) + fibonacci(n-2)
4.	senão
5.		retorna LaTeX: 1
6.	fim-se
7. fim-função

Domínio de fibonacci(n): LaTeX: n \in{} N / n \geq{} 1

Depois descobriremos como calcular os números de Fibonacci mais rápido, mas por enquanto nosso objetivo é a recursão!

Substituir um loop

Vamos supor que você quer imprimir os números de n a 1 e esqueceu a sintaxe do para... :D 

1. função imprime_ate (n)
2.	imprima LaTeX: n
3.	se LaTeX: n>1, então
4.		imprime_ate(n-1)
5.	fim-se
6. fim-função

Domínio de imprime_ate(n): LaTeX: n \in{} N / n \geq{} 1

Todo loop pode ser uma recursão e tem alguns que ficam bem mais fáceis se forem! Nesse caso, é claro que seria mais simples usarmos um para!

Outros exemplos, para concluir

  • Ordenação por Intercalação (Merge Sort)
  • Busca em Profundidade (Depth-First Search) em Grafos
  • Union/Find
  • ... entre vários outros casos!
]]> http://algoritmos.tiagomadeira.net/algoritmos-recursivos/feed