Pproblema 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.

1. 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.

2. 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

3. 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”.

4. 2. PLANTEAMIENTO DEL PROBLEMA.

5. 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

6. 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.

7.  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.

8.  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.

9. 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

10. 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)

11. 4. ANEXOX.
Interfaz gráfica del Problema.
Ejecución del programa.

12. 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;

13. 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);

14. 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()){

15. 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

16. 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;

17. /**
*
* @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);

18. }
}
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);
}
}
}