PROYECTO FINAL

FADA Fundamentos de Análisis y Diseño de Algoritmos.

PRESENTADO A: Mauricio López Benítez

José Luis Dorado. Juan Camilo Solarte. Andrés Felipe Trochez. Universidad del Valle Sede Norte del Cauca. Santander de Quilichao. Diciembre 15 del 2015.

Tabla de contenido Pág. 1. INTRODUCCION .....................................................................................................................2

2. PLANTEAMIENTO DEL PROBLEMA. .................................................................................3

3. EJECUCION DEL TRABAJO. ................................................................................................4

3.1. Estructura de Datos. ........................................................................................................4

3.2. Técnicas de Programación. ............................................................................................8

3.3. Tiempo de Ejecución. ......................................................................................................8

4. ANEXOX. ...................................................................................................................................10

1. INTRODUCCION

El presente problema de redes de amistad “Friendship Networks” se refiere a la

manera de verificar si una red de amigos está bien construida de tal manera que el

primer número de la cadena de enteros diga la cantidad de redes de amistad bien

construidas suponiendo que la persona no se podrá ser amigo de sí misma.

Teniendo en cuenta todo esto se recurrió a técnicas de solución algorítmicas ya

conocidas como algoritmo de heapsort-modificado, Teorema de Havel-Hakim,

además de la GUI de java, arreglos “arraysList”, ciclos “while, for” condicionales “if-

else”.

2. PLANTEAMIENTO DEL PROBLEMA.

3. EJECUCION DEL TRABAJO.

3.1. Estructura de Datos.

Para el desarrollo del problema de la maratón nacional de

programación se utilizaron las siguientes estructuras de

programación, lenguaje de programación JAVA, Teorema de

Havel-Hakim y algoritmos de ordenamiento.

JAVA

Java es un lenguaje de programación de propósito

general, concurrente, orientado a objetos que fue diseñado específicamente

para tener tan pocas dependencias de implementación como fuera posible.

Su intención es permitir que los desarrolladores de aplicaciones escriban el

programa una vez y lo ejecuten en cualquier dispositivo (conocido en inglés

como WORA, o "write once, run anywhere"), lo que quiere decir que

el código que es ejecutado en una plataforma no tiene que

ser recompilado para correr en otra

Interfaz Gráfica GUI

Llamamos Interfaz Gráfica GUI (Graphical User Interface) al conjunto de

componentes gráficos que posibilitan la interacción entre el usuario y la

aplicación. Es decir ventnas, botones, combos, listas, cajas de diálogo,

campos de texto, etc.

Primero tenemos que diseñar la aplicación,programarla y por último los

eventos que se generan a medida que el usuario interactua con la Interfaz.

Los componentes son objetos de las clases que heredan de la clase

base componente como Button, List, TextField, TextArea, Label, etc.

En una GUI los componentes son contenidos en Contenedores o containers.

Un Containes es un objeto cuya clase hereda de Container (clase que a su

vez es subclase de Component) y tiene la responsabilidad de contener

Componentes.

Generalmente una GUI se monta sobre un Frame. Esté sera el Container

principal que contendrá a los componentes de la Interfaz Gráfica, un

Container podría contener a otros containers

Arreglos.

ArrayList: La clase ArrayList en Java, es una clase que permite almacenar

datos en memoria de forma similar a los Arrays, con la ventaja de que el

número de elementos que almacena, lo hace de forma dinámica, es decir,

que no es necesario declarar su tamaño como pasa con los Arrays.

Bucles.

While: bucle mientras es una estructura de la mayoría de los lenguajes

de programación estructurados cuyo propósito es repetir un bloque de

código mientras una condición se mantenga verdadera.

For: ciclo for es una estructura de control en la que la PC nos muestra el

cómo programar si es que nosotros queremos programar un robot B-bot,

en este se puede indicar el modo en la que se puede indicar el número

mínimo de iteraciones.

Condicionales.

If-else: se da una condición y si la misma se cumple ejecuta un código X,

en caso de que no se cumpla, ejecuta otro código Y (distinto).

Teorema de Havel-Hakim.

Consiste en ordenar los grados en forma decreciente, tomar el primer

elemento de la secuencia, y usarlo para restar de a 1 a cada uno de los

siguientes (obviamente, lo descartas). Si quedas con 0, es porque es una

secuencia válida de grados

Por ejemplo: 2, 2, 2, 1, 1, 3, 3, 4.

1. Los ordenamos

4, 3, 3, 2, 2, 2, 1, 1

2. Mientras hay algún número mayor que 0, restamos del modo

mencionado y descartamos el primero:

4,3,3,2,2,2,1,1 →"repartimos “el 4 para restar→ (3-1),(3-1),(2-1),(2-1),2,1,1

2,2,1,1,2,1,1 → ordenamos → 2,2,2,1,1,1,1

2,2,2,1,1,1,1 → (2-1),(2-1),1,1,1,1

1,1,1,1,1,1

1,1,1,1,1,1 → (1-1),1,1,1,1

1,1,1,1 → (1-1),1,1

1,1 → (1-1)

0

Algoritmo de Ordenamiento.

Heapsort: La estructura de datos Montículo es un arreglo de objetos que

puede ser visto como un árbol binario con raíz, cuyos nodos pertenecen

a un conjunto totalmente ordenado, y tal que cumple las siguientes dos

propiedades:

Propiedad de orden: La raíz de cada subárbol es mayor o igual que

cualquiera de sus nodos restantes.

Propiedad de forma: La longitud de toda rama es h o h − 1, donde h

es la altura del árbol. Además, no puede existir una rama de longitud

(h) a la derecha de una rama de longitud h-1.

El algoritmo HeapSort:

1 Build-Heap (A)

2 For i ← length[A] down to 2

3 do exchange A[1] ↔ A[i]

4 heap-size [A] ← heap-size [A] − 1

5 Heapify (A, 1)

La información es almacenada de manera que al recorrer un camino desde la raíz

hacia las hojas, los datos se encuentran en orden descendente

Consta de dos etapas:

o Etapa 1: Se organiza el arreglo como un árbol Heap Máximo.

o Etapa 2: Se ubican los elementos en su lugar definitivo, devolviendo

la propiedad del Heap Máximo en cada ocasión.

3.2. Técnicas de Programación.

Para el desarrollo del problema de la maratón nacional de programación se optó

por una programación voraz.

Programación Voraz.

Un algoritmo voraz toma decisiones con rapidez sobre vistas locales ->

toma decisiones óptimas locales. Espera que llegue a una solución óptima

global

Un algoritmo voraz no siempre encuentra la solución óptima global.

3.3. Tiempo de Ejecución.

Análisis de Heapify:

El tiempo de ejecución de Heapify se puede describir por la ecuación de

recurrencia:

T(n) ≤ T (2n/3) + θ (1)

Θ (1) para calcular el mayor + Heapify con 2/3 de los elementos en el peor de los

casos donde n es el número de nodos del árbol.

Por el método maestro:

T(n) ≤ T (2n/3) + θ (1) = O(n^0 lg n) = O (lg n)

Análisis de Build-Heap:

Sencillo

o Cada llamada a Heapify cuenta O(lg n)

o Se hacen O(n) llamados

o Costo total Estimado O(n lg n)

o O(n) es una estimación más precisa

Análisis de HeapSort:

O(n) + (n - 1) O (lg n) = O(n lg n)

4. ANEXOX. Interfaz gráfica del Problema.

Ejecución del programa.

Resultados obtenidos con el algoritmo desarrollado.

Clase ProyectoFada. (Interfaz)

package proyecto.fada; import java.awt.BorderLayout; import java.awt.Container; import java.awt.Dimension; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.KeyAdapter; import java.awt.event.KeyEvent; import java.io.BufferedReader; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.util.ArrayList; import java.util.StringTokenizer; import javax.swing.BorderFactory; import javax.swing.JButton; import javax.swing.JFileChooser; import javax.swing.JFrame; import javax.swing.JOptionPane; import javax.swing.JPanel; import javax.swing.JScrollPane; import javax.swing.JTable;

import javax.swing.JTextArea; import javax.swing.filechooser.FileFilter; import javax.swing.filechooser.FileNameExtensionFilter; import javax.swing.table.DefaultTableModel; /** * * @author Kronos */ public class ProyectoFADA extends JFrame { Container contenedor; JPanel Pnorte, Pcentro, PnEste; JButton Baceptar, Blimpiar, Bexaminar; JTextArea textAreaE; JTable table; Networks algoritmo; ArrayList<String> lista; File archivo; FileReader fr; BufferedReader br; public ProyectoFADA() { algoritmo = new Networks(); contenedor = getContentPane(); Pnorte = new JPanel(); Pcentro = new JPanel(); PnEste = new JPanel(); textAreaE = new JTextArea(6,30); table = new JTable(); Baceptar = new JButton("Aceptar"); Blimpiar = new JButton("Limpiar"); Bexaminar = new JButton("Examinar"); JScrollPane scrollAreaE = new JScrollPane(textAreaE); JScrollPane scrollAreaR = new JScrollPane(table); PnEste.setLayout(new GridLayout(3, 1)); PnEste.add(Blimpiar); PnEste.add(Bexaminar); PnEste.add(Baceptar); Pnorte.setBorder(BorderFactory.createTitledBorder("Ingrese Datos")); Pnorte.setLayout(new BorderLayout()); Pnorte.add(scrollAreaE, BorderLayout.CENTER);

Pnorte.add(PnEste, BorderLayout.EAST); Pcentro.setBorder(BorderFactory.createTitledBorder("Resultado")); Pcentro.setLayout(new BorderLayout()); Pcentro.setPreferredSize(new Dimension(500, 250)); Pcentro.add(scrollAreaR, BorderLayout.CENTER); contenedor.setLayout(new BorderLayout()); contenedor.add(Pnorte, BorderLayout.NORTH); contenedor.add(Pcentro, BorderLayout.CENTER); Action action = new Action(); Blimpiar.addActionListener(action); Bexaminar.addActionListener(action); Baceptar.addActionListener(action); validarNum(textAreaE); this.setTitle("Proyecto FADA"); this.setResizable(false); this.setLocationRelativeTo(null); this.setDefaultCloseOperation(EXIT_ON_CLOSE); this.pack(); this.setVisible(true); } public void seleccionarArchivo() { JFileChooser buscar = new JFileChooser(); FileFilter filtro = new FileNameExtensionFilter("txt", "TXT"); buscar.setFileFilter(filtro); int estado = buscar.showOpenDialog(this); if(estado == JFileChooser.CANCEL_OPTION){} if(estado == JFileChooser.APPROVE_OPTION){ archivo = buscar.getSelectedFile(); textAreaE.setText(""); cargarArchivo(); } } public void cargarLista() { String cadena = textAreaE.getText(); StringTokenizer token = new StringTokenizer(cadena, "\n"); lista = new ArrayList<>(); while(token.hasMoreTokens()){

lista.add(token.nextToken()); } } private void cargarArchivo() { try{ fr = new FileReader(archivo); int caracter; while((caracter = fr.read()) != -1){ char c = (char) caracter; if(Character.isDigit(c) || c == ' ' || c == '\n'){ textAreaE.append(String.valueOf(c)); } } }catch(FileNotFoundException e){ String title = "Archivo Invalido"; String message = "Error al abrir archivo: " + e.getMessage(); int type = JOptionPane.ERROR_MESSAGE; JOptionPane.showMessageDialog(null, message, title, type); } catch (IOException ex) { }finally{ try { fr.close(); } catch (IOException ex) { } } } private void validarNum(JTextArea text){ text.addKeyListener(new KeyAdapter() { @Override public void keyTyped(KeyEvent e){ char c = e.getKeyChar(); if(!(Character.isDigit(c)) && c != ' '){ e.consume(); } } }); } /** * @param args the command line arguments */ public static void main(String[] args) { // TODO code application logic here

ProyectoFADA fada = new ProyectoFADA(); } class Action implements ActionListener { @Override public void actionPerformed(ActionEvent e) { if(e.getSource() == Blimpiar){ textAreaE.setText(""); } if(e.getSource() == Bexaminar){ seleccionarArchivo(); } if(e.getSource() == Baceptar){ cargarLista(); String[] columnas = {"Sample input", "Output for the sample input"}; DefaultTableModel modelo = new DefaultTableModel(null, columnas); for(String next: lista){ String datos = next; if(!(datos.trim().length() == 0)){ StringTokenizer tokens=new StringTokenizer(datos, " "); ArrayList<Integer> elemnts = new ArrayList<>(); while(tokens.hasMoreTokens()){ elemnts.add(Integer.parseInt(tokens.nextToken())); } String[] datosFila = { elemnts.toString(), String.valueOf(algoritmo.isNetwork(elemnts)), }; modelo.addRow(datosFila); } } table.setModel(modelo); } } } }

Clase Networks. (Logica) import static java.lang.Math.floor; import java.util.ArrayList;

/** * * @author Kronos */ public class Networks { public Networks() {} public boolean isNetwork(ArrayList<Integer> list) { boolean result = false; int n = list.get(0); if((2 <= n && n <= 1000) && (list.size()-1 == n)){ list.set(0, 0); HeapSort(list, false); list.remove(n); if(list.get(n-1) > 0 && list.get(0) < n){ while(!(list.isEmpty())){ int nodo = list.get(0); list.set(0, 0); if(nodo <= list.size()-1){ for(int i=1; i<=nodo; i++){ list.set(i, list.get(i)-1); } HeapSort(list, true); if(list.get(0) == 0) list.remove(0); } else break; } result = list.isEmpty(); } } return result; } private static void HeapSort(ArrayList<Integer> A, boolean removeZeros){ int heapSize = A.size()-1; BuildMinHeap(A); for(int i = (A.size()-1); i>=1; i--){ int auxI = A.get(0); A.set(0, A.get(i)); A.set(i, auxI); heapSize--; if(auxI == 0 && removeZeros == true) A.remove(i); MinHeapPify(A, 0, heapSize);

} } private static void BuildMinHeap(ArrayList<Integer> A){ int heapSize = A.size()-1; for(int i = (int) floor((heapSize-1)/2); i>=0; i--){ MinHeapPify(A, i, heapSize); } } private static void MinHeapPify(ArrayList<Integer> A, int i, int heapSize){ int izq = i*2+1; int der = i*2+2; int posMin = i; if(izq <= heapSize && A.get(izq) < A.get(posMin)) posMin = izq; if(der <= heapSize && A.get(der) < A.get(posMin)) posMin = der; if(posMin != i){ int auxI = A.get(i); A.set(i, A.get(posMin)); A.set(posMin, auxI); MinHeapPify(A, posMin, heapSize); } } }