UNIVERSIDAD CATÓLICA BOLIVIANA “SAN PABLO” ANÁLISIS DE ALGORITMOS

NOMBRE: Camila Lémuz Mujica

JOHNSON EN INSTALCIÓN DE GAS NATURAL

“PROTELGAS”

Resumen:
Se realizó una aplicación en Android que hizo uso del algoritmo de Johnson aplicado
a la instalación de gas natural en hogares de la ciudad de La Paz. Obtando por el camino corto
y económico.
Introducción:
El presente proyecto tiene como objetivo hacer uso del algoritmo de Johnson para
determinar el camino más corto de la instalación de los tubos de gas, de esta manera encontrar
el camino mas barato para el cliente, desde la entrada del hogar, hasta su cocina o calefones.
Para este propósito se realizó la programación de una aplicación en Android.
Problema:
Esta aplicación ayudará a las diferentes empresas de gas a hacer una cotización
instantánea. Obteniendo asi una respuesta mucha más rápida y certera al cliente. Esto ayuda
mucho en terminos de tiempo.

Objetivo General:
Desarrollar una aplicación en Android que permita identificar la instalación de tubos
de gas más corta, para validar mis conceptos adquiridos en la materia análisis de algoritmos.

Objetivos Específicos
 Generar una herramienta útil para resolver un problema de la actualidad.
 Aplicar los conocimientos adquiridos en la materia para demostrar su utilidad y
aplicabilidad
 Crear una aplicación de fácil entendimiento para cualquier usuario.

Marco Teórico

¿Qué es un algoritmo?
Un algoritmo es un conjunto de operaciones que tienen como objetivo encontrar una
solución a un tipo de problema relacionado con las matemáticas, la informática, etc. “Un
algoritmo típico tiene carácter finito, es preciso, tiene tanto una entrada como una salida y es
eficaz en la resolución de un problema”. (Definición ABC, 2016).
¿Qué es el algoritmo de Johnson?
UNIVERSIDAD CATÓLICA BOLIVIANA “SAN PABLO” ANÁLISIS DE ALGORITMOS
NOMBRE: Camila Lémuz Mujica
El algoritmo de Johnson es una forma de encontrar el camino más corto entre todos los
pares de vértices de un grafo dirigido disperso. Permite que las aristas tengan pesos negativos,
si bien no permite ciclos de peso negativo. Funciona utilizando el algoritmo de Bellman-
Ford para hacer una transformación en el grafo inicial que elimina todas las aristas de peso
negativo, permitiendo por tanto usar el algoritmo de Dijkstra en el grafo transformado. Su
nombre viene de Donald B. Johnson, quien fuera el primero en publicar la técnica en 1977.
¿Cómo se aplica?
El algoritmo de Johnson consiste en los siguientes pasos:

1. Primero se añade un nuevo nodo q al grafo, conectado a cada uno de los nodos del
grafo por una arista de peso cero.

2. En segundo lugar, se utiliza el algoritmo de Bellman-Ford, empezando por el nuevo

vértice q, para determinara para cada vértice v el peso mínimo h(v) del camino
de q a v. Si en este paso se detecta un ciclo negativo, el algoritmo concluye.

3. Seguidamente, a las aristas del grafo original se les cambia el peso usando los valores
calculados por el algoritmo de Bellman-Ford: una arista de u a v con tamaño w(u, v),
da el nuevo tamaño w(u, v) + h(u) – h(v)

4. Por último, para cada nodo s se usa el algoritmo de Dijkstra para determinar el camino
más corto entre s y los otros nodos, usando el grafo con pesos modificados.

En el grafo con pesos modificados, todos los caminos entre un par de

nodos s y t tienen la misma cantidad h(s) – h(t) añadida a cada uno de ellos, así que un camino
que sea el más corto en el grafo original también es el camino más corto en el grafo
modificado y viceversa. Sin embargo, debido al modo en el que los valores h(v) son
computados, todos los pesos modificados de las aristas son no negativos, asegurando
entonces la optimalidad de los caminos encontrados por el algoritmo de Dijkstra. Las
distancias en el grafo original pueden ser calculadas a partir de las distancias calculadas por
el algoritmo de Dijkstra en el grafo modificado invirtiendo la transformación realizada en el
grafo.
Marco Práctico

¿Qué software se usó?

Para el desarrollo de la aplicación se utilizó el entorno de desarrollo integrado
UNIVERSIDAD CATÓLICA BOLIVIANA “SAN PABLO” ANÁLISIS DE ALGORITMOS
NOMBRE: Camila Lémuz Mujica
Android Studio, que es el IDE oficial para desarrollo de aplicaciones en Android.

¿Qué herramientas se utilizaron?

Android Studio ofrece una amplia gama de herramientas para los desarrolladores, por
ejemplo:

“Sistema de compilación flexible basado en Gradle, un emulador rápido con varias funciones, un
entorno unificado en el que puedes realizar desarrollos para todos los dispositivos Android,
Instant Run, para aplicar cambios mientras tu app se ejecuta sin la necesidad de compilar un
nuevo APK, Integración de plantillas de código y GitHub, para ayudarte a compilar funciones
comunes de las apps e importar ejemplos de código, Gran cantidad de herramientas y
frameworks de prueba, Herramientas Lint para detectar problemas de rendimiento, uso,
compatibilidad de versión, Compatibilidad con C++ y NDK, Soporte integrado para Google Cloud
Platform, que facilita la integración de Google Cloud Messaging y App Engine.“ (Studio, 2016)

Código Fuente

Para la creación del nodo.

import android.os.Parcel; this.ni=ni;

import android.os.Parcelable; this.nom=nom;

public class Nodo implements Parcelable{ public int getNd() {

int x,y,ni,nd; return nd;

String nom; }

public Nodo(int x,int y,int ni,int nd,String

nom){
public int getNi() {
this.x=x;
return ni;
this.y=y;
}
this.nd=nd;
UNIVERSIDAD CATÓLICA BOLIVIANA “SAN PABLO” ANÁLISIS DE ALGORITMOS
NOMBRE: Camila Lémuz Mujica

x = in.readInt();

public int getX() { y = in.readInt();

return x; nom = in.readString();

} ni=in.readInt();

nd=in.readInt();

public int getY() { }

return y;

@Override

public String getNom() { public int describeContents() {

return nom; return 0;

} }
@Override

public void writeToParcel(Parcel dest, int

public void setNd(int nd) {
flags) {
this.nd = nd;
dest.writeInt(x);
}
dest.writeInt(y);

dest.writeString(nom);
public void setNi(int ni) {
dest.writeInt(ni);
this.ni = ni;
dest.writeInt(nd);
}
}
//genera el parce para mandar a otro
@SuppressWarnings("unused")
activity http://www.parcelabler.com/
public static final
protected Nodo(Parcel in) {
Parcelable.Creator<Nodo> CREATOR = new
UNIVERSIDAD CATÓLICA BOLIVIANA “SAN PABLO” ANÁLISIS DE ALGORITMOS
NOMBRE: Camila Lémuz Mujica
Parcelable.Creator<Nodo>() { x2,int y2,String nom2,int atributo){

@Override this.x1=x1;

public Nodo createFromParcel(Parcel this.x2=x2;

in) {
this.y1=y1;
return new Nodo(in);
this.y2=y2;
}
this.atributo=atributo;

this.nom1=nom1;
@Override
this.nom2=nom2;
public Nodo[] newArray(int size) {
holgura=0;
return new Nodo[size];
}
}

};
public int getX1(){return x1;}
}
public int getY1(){return y1;}
Para la arista
public int getX2(){return x2;}
import android.os.Parcel;
public int getY2(){return y2;}
import android.os.Parcelable;
public int getAtributo(){return atributo;}
import
public String getNom1(){return nom1;}
android.support.annotation.AttrRes;
public String getNom2(){return nom2;}

public int getHolgdura() {

public class Arista implements Parcelable{
return holgura;
private int x1,y1,y2,x2,atributo;
}
private String nom1,nom2;

private int holgura;

public void setHolgura(int hondura) {
public Arista(int x1,int y1,String nom1,int
UNIVERSIDAD CATÓLICA BOLIVIANA “SAN PABLO” ANÁLISIS DE ALGORITMOS
NOMBRE: Camila Lémuz Mujica

this.holgura = hondura; public Arista createFromParcel(Parcel

in) {
}
return new Arista(in);

@Override
//genera el parce para mandar a otro
activity http://www.parcelabler.com/ public Arista[] newArray(int size) {

protected Arista(Parcel in) { return new Arista[size];

x1 = in.readInt(); }

y1 = in.readInt(); };

x2 = in.readInt(); @Override

y2 = in.readInt(); public int describeContents() {

atributo = in.readInt(); return 0;

nom1 = in.readString(); }

nom2 = in.readString();

holgura=in.readInt(); @Override

public void writeToParcel(Parcel dest, int

flags) {
}
dest.writeInt(x1);

dest.writeInt(y1);

dest.writeInt(x2);

dest.writeInt(y2);
public static final Creator<Arista>
CREATOR = new Creator<Arista>() { dest.writeInt(atributo);

@Override dest.writeString(nom1);
UNIVERSIDAD CATÓLICA BOLIVIANA “SAN PABLO” ANÁLISIS DE ALGORITMOS
NOMBRE: Camila Lémuz Mujica

dest.writeString(nom2); }

dest.writeInt(holgura); }

Para aplicar Johnson

import android.content.DialogInterface; private int vector[]=new int [2];//las

posiciones (i) de los nodos selecionados
import android.content.Intent;
private int con=0;//contador del vector
import android.os.Bundle;
@Override
import android.support.v7.app.AlertDialog;
protected void onCreate(Bundle
import
savedInstanceState) {
android.support.v7.app.AppCompatActivity;
super.onCreate(savedInstanceState);
import android.view.MotionEvent;

import android.view.View;
setContentView(R.layout.activity_jhonson);
import android.widget.EditText;
init();
import android.widget.RelativeLayout;
}
import android.widget.Toast;
private void init(){

//Declaracion de lienzo, nodo y arista

import java.util.ArrayList;
lamina=(RelativeLayout)
findViewById(R.id.laminaDibujo);

public class Jhonson extends lamina.setOnTouchListener(this);

AppCompatActivity implements
aristas=new ArrayList<>();
View.OnTouchListener {
nodos=new ArrayList<>();
private RelativeLayout lamina;
}
private ArrayList<Arista> aristas;
//Accion boton matriz
private ArrayList<Nodo> nodos;
public void llama(View v){
public static final int RADIO=50;
Intent intent=new
private int x1,x2,y1,y2;
Intent(this,Adyacente.class);
private String cajaArista="0";

private String nomPelota=""; intent.putParcelableArrayListExtra("listaPelot

a",nodos);
private int x,y;
UNIVERSIDAD CATÓLICA BOLIVIANA “SAN PABLO” ANÁLISIS DE ALGORITMOS
NOMBRE: Camila Lémuz Mujica
public void onClick(DialogInterface
intent.putParcelableArrayListExtra("listaLine dialog, int which) {
a",aristas);
try{
startActivity(intent);

} cajaArista=caja.getText().toString().trim();

int
aux=Integer.parseInt(cajaArista);
@Override

public boolean onTouch(View v,

Toast.makeText(getApplicationContext(),"Se
MotionEvent event) {
ingreso el valor
switch (v.getId()) { "+aux,Toast.LENGTH_SHORT).show();

case R.id.laminaDibujo: //Dibuja y guarda en el nodo

x = (int) event.getX(); aristas.add(new

Arista(x1,y1,nodos.get(vector[0]).getNom(),x
y = (int) event.getY(); 2,y2,nodos.get(vector[1]).getNom(),Integer.p
creaUnion(); arseInt(cajaArista)));

break; lamina.addView(new
DibujaArista(getApplicationContext(),x1,y1,x
} 2,y2,cajaArista));
return super.onTouchEvent(event);

//Alerta para ingresar atributos }catch (NumberFormatException ex){

public void ingresaValor(){

AlertDialog.Builder ventana=new Toast.makeText(getApplicationContext(),"De

AlertDialog.Builder(this); be ingresar un
numero",Toast.LENGTH_SHORT).show();
ventana.setMessage("Ingrese el valor");
}
ventana.setTitle("Valor de la Arista");
}
final EditText caja=new EditText(this);
});
ventana.setView(caja);

ventana.setPositiveButton("Aceptar", /*ventana.setNegativeButton("Cancelar",
new DialogInterface.OnClickListener() { new DialogInterface.OnClickListener() {
@Override @Override
UNIVERSIDAD CATÓLICA BOLIVIANA “SAN PABLO” ANÁLISIS DE ALGORITMOS
NOMBRE: Camila Lémuz Mujica
public void onClick(DialogInterface }
dialog, int which) {

public void creaUnion(){

}
boolean pr=false;
});*/
for (int i=0;i<nodos.size();i++){
ventana.show();

} if(Verifica(x,y,nodos.get(i).getX(),nodos.get(i)
.getY())){
public void nuevoNodo(){
vector[con]=i;
AlertDialog.Builder ventana=new
AlertDialog.Builder(this);
Toast.makeText(getApplicationContext(),"Sel
ventana.setMessage("Ingrese el Nombre
eciono:
del Nodo");
"+nodos.get(i).getNom(),Toast.LENGTH_SHO
ventana.setTitle("Nombre del Nodo"); RT).show();

final EditText caja=new EditText(this); con++;

ventana.setView(caja); pr=true;

ventana.setPositiveButton("Aceptar", break;
new DialogInterface.OnClickListener() {
}
@Override
}
public void onClick(DialogInterface
dialog, int which) {
if (con==2){

con=0;

nomPelota=caja.getText().toString().trim(); x1=nodos.get(vector[0]).getX();

nodos.add(new y1=nodos.get(vector[0]).getY();
Nodo(x,y,0,0,nomPelota));
x2=nodos.get(vector[1]).getX();
lamina.addView(new
y2=nodos.get(vector[1]).getY();
DibujaNodo(getApplicationContext(),x,y,RADI
O,nomPelota));

// dibujaPelota(nomPelota); //Ingresamos el valor de la arista

} ingresaValor();
});

ventana.show();
UNIVERSIDAD CATÓLICA BOLIVIANA “SAN PABLO” ANÁLISIS DE ALGORITMOS
NOMBRE: Camila Lémuz Mujica
}else if(!pr){ }

nuevoNodo();

//Verificacion de Existencia del punto (x,y)

en la lista

public boolean Verifica(int x,int y,int xx,int

yy){

double dis=Math.sqrt((Math.pow((xx-
x),2))+(Math.pow((yy-y),2)));

if(dis>(RADIO+RADIO))

return false;

else

return true;

public boolean VerificaLinea(){

for(int i=0;i<aristas.size();i++){

if((aristas.get(i).getX1()==x1 &&
aristas.get(i).getY1()==y1 &&
aristas.get(i).getX2()==x2 &&
aristas.get(i).getY2()==y2) /*||
(listaLinea.get(i).getX1()==x2 &&
listaLinea.get(i).getY1()==y2 &&
listaLinea.get(i).getX2()==x1 &&
listaLinea.get(i).getY2()==y1)*/){

// posicion=i;

return false;

return true;