Departamento de Ciência de Computadores Estruturas de Dados (CC114)

Transcrição

1 1. Cotação de cada pergunta: / / (Total: 100 pontos) 2. Responda às questões de forma clara e concisa nas folhas de exame distribuídas. 1. (Valorização: 32%) Responda às seguintes questões: a) Faça o estudo da complexidade do método f() descrito a seguir: int f(int n) int count = 0; int j = n; while (j>0) { j--; for (int k=0; k<n/2; k++) count++; return count; Os dois ciclos são os que determinam a complexidade deste método: ciclo-j: faz n iterações ciclo-k: faz n/2 iterações Assim, a complexidade da função f() será O(n) O( n 2 ) que podemos simplificar para O(n2 ). b) Indique e justifique qual é a complexidade assimptótica de uma algoritmo de ordenação de n elementos que usa uma heap do seguinte modo: começando com uma heap vazia, cada elemento é adicionado um a um à heap; depois de todos os elementos estarem na heap, cada elemento é retirado um a um da heap. Inserir um elemento na heap: O(log n) (corresponde a realizar a operação upheap()) Retirar um elemento da heap: O(log n) (corresponde a realizar a operação downheap()) Inserir N elementos na heap: O(n) O(log n) i.e. O(n log n) Inserir N elementos + retirar N elementos: O(n log n) c) Considere que existem dois vectores a[] e b[] com n inteiros, sem números repetidos e ordenados por ordem estritatemente crescente. Escreva um método em Java, uniaoordenada(int n, int a[], int b[], int c[]), em que dados os vectores a[] e b[] de dimensão n produza como resultado um vector c[] de dimensão 2*n com os elementos de a[] e b[] ordenados por ordem crescente. Indique, justificando, qual a complexidade do seu método. Para ter o máximo da pontuação, o seu método deve ter complexidade linear, ou seja, O(n). 1

2 void uniaoordenada(int n, int a[], int b[], int c[]) { int i, j, k; i = j = k = 0; while (i<n && j<n) { if (a[i] < b[j]) { c[k] = a[i]; i++; k++; else { c[k] = b[j]; j++; k++; while (i<n) { c[k] = a[i]; i++; k++; while (j<n) { c[k] = b[j]; j++; k++; ou, uma versão mais compacta do mesmo método: void uniaoordenada(int n, int a[], int b[], int c[]) { int i, j, k; i = j = k = 0; while (i<n && j<n) { if (a[i] < b[j]) c[k++] = a[i++]; else c[k++] = b[j++]; while (i<n) c[k++] = a[i++]; while (j<n) c[k++] = b[j++]; d) Considere que recebe os seguintes números por esta ordem: Suponha que vai inserir os elementos numa heap, um a um, mantendo sempre a condição de heap. Desenhe o estado da heap depois de cada inserção. Supondo que a heap guarda o máximo na raíz. Os novos valores são sempre inseridos na primeira posição livre mais à esquerda no último nível não completo e depois é aplicada o método upheap() que repõe a condição de Heap / / \ / \ / \ / \ / \ / / \ / \ / / \ /\

3 2. (Valorização: 36%) Listas Num concurso de programação existem várias equipas a tentar resolver np problemas, numerados de 0 a np 1. Cada Equipa é identificada pelo seu nome, universidade e país. Ao longo do concurso as equipas submetem código para tentar resolver um problema, com estas tentativas a serem chamadas de submissões. Cada Submissao é identificada pela equipa que a fez, o número do problema que estão a tentar resolver, o tempo da submissão (em minutos) e o resultado da submissão (correcta ou errada). Pode assumir que cada equipa terá no máximo uma submissão certa por problema. No final a classificação é feita tendo em conta quantos problemas cada equipa resolveu, e quanto tempo gastou. Para calcular o tempo gasto de uma equipa, deve somar-se o tempo de cada uma das suas submissões correctas, acrescido de 20 minutos de penalização por cada submissão errada num problema que a equipa acertou (se a equipa não chegar a acertar o problema, as submissões erradas não penalizam). a) Escreva as classes Equipa e Submissao, necessárias para representar a informação, incluindo pelo menos um construtor para cada uma delas. Ignorando o uso de declarações de atributos privados e de gets e sets como seria de fazer normalment, temos: class Equipa { String nome; String univ; String pais; int erradas[]; // vector de contadores de tentativas por problema int certos; // número de problemas certos int tempo; // tempo em minutos para os problemas ja acertados Equipa(String n, String u, String p, int np) { nome = n; univ = u; pais = p; erradas = new int[np]; tempo = certos = 0; class Submissao { Equipa equipa; // referencia para o objecto equipa que fez a submissao int prob; // numero de problema para o qual submeteu int tempo; // tempo em minutos da submissao boolean acertou; // resultado da submissao (acertou / nao acertou) Submissao(Equipa e, int p, int t, boolean a) { equipa = e; prob = p; tempo = t; acertou = a;

4 b) Para gerir o concurso, será usada uma fila de submissões, ordenadas de forma crescente pelo tempo. Escreva uma classe Fila<E> que implementa filas com genéricos. Escreva os atributos, construtor(es), e apenas as assinaturas dos métodos habituais. Implemente ainda o método para retirar o primeiro elemento da fila. Nota: pode também apresentar uma implementação sem genéricos, mas terá uma penalização de 15%. Ignorando o uso de declarações de atributos privados e de gets e sets como seria de fazer normalmelment, temos: class No<E> { E val; No<E> next; No(E v, No<E> n) { val = v; next = n; class Fila<E> { int size; No<E> first; No<E> last; Fila() { size = 0; first = last = null; public boolean isempty() { public int size() { public void addlast(e v) { public E removefirst() throws EmptyQueueException { if (isempty()) throw new EmptyQueueException("Fila vazia"); E aux = first.val; first = first.next; size--; if (first==null) last = null; return aux; embora no exame não fosse necessário incluir a classe que permite gerar a excepção, ela seria: class EmptyQueueException extends RuntimeException { public EmptyQueueException(String err) {super(err); c) Escreva um método void atualizapontuacoes(fila<submissao> f), parte duma classe principal Concurso, que será invocado no final para processar as submissões. Este método deverá percorrer a lista de submissões e deve calcular para cada equipa o 4

5 número de problemas resolvidos e o tempo total gasto pela equipa, tal como atrás descrito. Nota: implemente um método void pontuacao(int problema, int tempo, boolean acertou) na classe Equipa que permite atualizar o número de tentativas erradas da equipa para um dado problema, se acertou for false, ou atualizar o número de problemas resolvidos e o tempo gasto, se acertou for true. Assumindo que depois de acertar, as equipas nao enviam mais submissoes para o mesmo problema: class Equipa { void pontuacao(int prob, int t, boolean acertou) { if (acertou) { certos++; // num probs certos tempo += t + 20*erradas[prob]; // tempo de acerto else // se nao acertou, contabiliza mais uma tentativa erradas[prob]++; class Concurso { void atualizapontuacoes(fila<submissao> f) { Submissao sub; while (!f.isempty()) { sub = f.removefirst(); // proxima submissao da fila sub.equipa.pontuacao(sub.prob, sub.tempo, sub.acertou); d) Para ordenar no final as equipas vai-se usar o método sort() da API do Java. Para isso é necessário implementar o método int compareto(equipa outra) na classe Equipa. Escreva uma implementação para este método, considerando que a equipa em primeiro lugar deve ser a que tenha maior número de problemas resolvidos e em caso de empate deve vir primeiro a equipa que gastou menos tempo. Se ainda assim se verificar um empate, devem vir por ordem alfabética do seu nome. 5

6 Assumindo que depois de acertar, as equipas nao enviam mais submissoes para o mesmo problema: class Equipa { // this refere-se à equipa que chama o metodo // o uso de this nao era necessario, mas ajuda a compreensao int compareto(equipa e) { if (this.certos > e.certos) return -1; if (this.certos < e.certos) return +1; if (this.tempo < e.tempo) return -1; if (this.tempo > e.tempo) return +1; return this.nome.compareto(e.nome); 3. (Valorização: 32%) Árvores Considerem-se árvores binárias completas em que cada nó tem, além das ligações para os filhos esquerdo e direito, um valor inteiro positivo e um valor booleano. Os números inteiros são consecutivos e dados de cima para baixo, da esquerda para a direita. Os valores booleanos indicam o que fazer num percurso de descida: se o valor for true seguese pela esquerda, se for false, segue-se pela direita. Inicialmente todos os booleanos estão colocados true e de cada vez que se percorre a árvore, muda-se o valor dos nós percorridos para o valor inverso. A figura seguinte ilustra uma árvore com 7 nós e o que acontece nos primeiros 4 percursos (indicados a cinzento), que terminam respectivamente nas folhas com números 4, 6, 5 e 7. a) Defina árvore binária completa e desenvolva estruturas de dados necessárias (classes) que implementem o tipo de árvores necessárias para este problema, incluindo todos os atributos necessários e pelo menos um construtor por classe. 6

7 Uma árvore binária completa é uma árvore binária onde todos os níveis, com possível excepção do último, estão preenchidos, e todos os nós-folha do último nível estão o mais à esquerda possível. A definição seguinte é para uma árvore específica para resolver este problema: class BTNode { int num; boolean val; BTNode left; BTNode right; BTNode (int n, boolean v) { num = n; val = v; left = right = null; class BTree { BTNode root; BTree() { root = null; b) Escreva um método void criaarvore(int n), da classe que implementa a árvore, que, começando na raíz, cria uma árvore completa com n níveis como atrás descrito, com os números preenchidos e todos os valores booleanos como true. A solução mais simples resulta de se verificar que a numeração de nós é a mesma que se usa nas heaps e portanto temos a relação de que o filho esquerdo do nó-j é o 2J e o da direita o 2j+1. class BTree { BTNode root; void criaarvore_v1(int n) { root = cria_v1(1, n); BTNode cria_v1(int num, int depth) { BTNode aux = new BTNode(num, true); if (depth>1) { aux.left = cria_v1(num*2, depth-1); aux.right = cria_v1(num*2+1, depth-1); return aux; A solução mais óbvia, uma vez que temos uma numeração consecutiva por níveis, seria criar a árvore usando um percurso em largura, i.e. com o auxílio de uma fila. Notar que se temos n níveis, temos 2 n 1. 7

8 class BTree { void criaarvore_v2(int n) { BTNode aux; LinkedList<BTNode> fila = new LinkedList<BTNode>(); root = new BTNode(1, true); fila.addlast(root); int pos = 2; int limit = (int)math.pow(2,n); while (!fila.isempty()) { aux = bfs.removefirst(); if (pos < limit) { aux.left = new BTNode(pos++, true); fila.addlast(aux.left); aux.right = new BTNode(pos++, true); fila.addlast(aux.right); c) Escreva um método int ondecai(int k) que diz em que nó folha (valor inteiro do nó) termina o k-esimo percurso a partir da raíz. Neste caso, o método ondecai() é chamado k vezes e só nos interessa saber o valor final da última chamada. De cada vez, executa um método cai() que a partir da ráiz faz a simulação de percorrer a árvore até a um nó folha, mudando o estado dos nós na passagem. class BTree { BTNode root; int ondecai(int k) { int aux = 0; for (int i=0; i<k; i++) aux = cai(root); return aux; int cai(btnode n) { n.val =!n.val; if (n.left == null) return n.num; else if (n.val) return cai(n.right); else return cai(n.left); 8