COMPUTACIÓN I

Unidad 3. Números reales y funciones

EVIDENCIA DE APRENDIZAJE
ALUMNA: YAZMIN GUADALUPE CASTILLO ORTIZ
MATRICULA: ES1821000588

0
 Introducción

La presente actividad consiste en revisar el contenido de la unidad, analizar los ejemplos

programa teorema del Corte Mínimo y Flujo Máximo con su respectivo código, para interpretar
el código de programación y compilarlo

1
 Teorema del Corte Mínimo y Flujo Máximo
Pseudocódigo

Paso 1.
Flujo máximo y corte mínimo.

Paso 2.
Entradas: El número de vértices (vertice) y el número de aristas (aristas), vértice de inicio o fuente “fuente” y
el vértice final, sumidero o destino “destino”, valores de la red: vértices de “p[]” a “q[]”; la capacidad de cada
arista “cap[]”.

Salidas: cantidad de flujo de cada vértice “flujovertice[]”, cantidad de flujo por cada arista “flujoarista[]”,
vértices del corte mínimo “cortemin[]”.

1. Inicio.

2. Inicialización de variables
Cortemin [vertice+1] ← 0
Flujovertice [vertice+1] ← 0
Flujoarista [aristas+aristas+1] ← 0
Primarista [vertice+1] ← 0
Mapeoi [vertice+1] ← 0
Mapeoj [vertice+1] ← 0
flujo← 0, aux← 0, aristas2 ← 0, NY ← 0, i ← 0, j ← 0
entrada← 0, salida ← 0, parm← 0, aristas1 ← 0, cont1 ← 0, cont2 ← 0
fin← 0, NP ← 0, NQ ← 0, NU ← 0, NV ← 0, NW ← 0, NX ← 0
termino←false, A ←false, B ←false, C ←false, G ←false
D ←false, E ←false, F ←false.

3. Se empieza con un preflujo en donde las aristas de la fuente tienen una capacidad residual de cero,
produciendo excesos en los vértices adyacentes a la fuente.

4. Mientras el flujo de entrada sea igual al flujo de salida del vértice Los excesos son conducidos hasta el
destino Si los excesos no alcanzan a llegar al destino, son regresados a la fuente.

5. Si ya no hay excesos. Fin.

6. Fin

Ejemplo

2
Código

/******************************************************************************

Teorema del Corte Mínimo y Flujo Máximo

*******************************************************************************/

package maxflow;

public class Test extends Object{

public static void main(String args[]) {

int vertice = 11, aristas = 18;

int fuente = 1, destino = 11;

//para p,q y cap, la cantidad de datos esta dada por: 2*aristas+1

int p[] = {0, 1, 1, 1, 2, 3, 3, 3, 3, 4, 5, 5, 6, 6, 7, 8, 9, 10, 10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

int q[] = {0, 2, 3, 4, 5, 2, 5, 7, 6, 7, 9, 8, 9, 7, 10, 11, 8, 9, 11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

int cap[] = {0, 6, 8, 4, 8, 3, 2, 14, 3, 10, 1, 10, 10, 12, 6, 8, 9, 10, 12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

int cortemin[] = new int[vertice+1];

int flujovertice[] = new int[vertice+1];

int flujoarista[] = new int[aristas+aristas+1];

Maxflow.FlujoMaxCorteMin(vertice,aristas,p,q,cap,fuente,destino,cortemin,flujoarista,flujovertice);

System.out.print("Vértices del corte mínimo: ");

for (int i = 1; i<= vertice; i++)

if (cortemin[i] == 1)

System.out.print(" " + i);

System.out.println("\n\nCantidad de flujo por cada uno de los vértices:" + "\n\n Verticeflujo");

for (int i = 1; i<= vertice; i++)

System.out.printf("%4d%7d\n",i,flujovertice[i]);

System.out.println("\nCantidad de flujo por cada una de las aristas:\n\n de hasta flujo");

3
 for (int i = 1; i<= flujoarista[0]; i++)

System.out.printf("%2d%6d%7d\n",p[i],q[i],flujoarista[i]);

System.out.print("\nNOTA: En aquellas aristas que no aparecen, el flujo es cero (0)");

///////////////////////////////////

//package maxflow;

public class Maxflow {

//valores de retorno

public static void FlujoMaxCorteMin(int vertice, int aristas, int p[],

int q[], int cap[], int fuente, int destino,

int cortemin[], int flujoarista[], int flujovertice[]){

int primarista[] = new int[vertice+1];

int mapeoi[] = new int[vertice+1];

int mapeoj[] = new int[vertice+1];

int flujo, aux, aristas2, NY, i, j;

int entrada = 0, salida = 0, parm = 0, aristas1 = 0, cont1 = 0, cont2 = 0;

int fin = 0, NP = 0, NQ = 0, NU = 0, NV = 0, NW = 0, NX = 0;

boolean termino, A, B, C, G;

boolean D = false, E = false, F = false;

// Creación de aristas sustitutas

j = aristas;

for (i = 1; i<= aristas; i++) {

j++;

p[aristas+i] = q[i];

4
 q[aristas+i] = p[i];

cap[aristas+i] = 0;

aristas = aristas + aristas;

// Inicialización

for (i = 1; i<= vertice; i++)

primarista[i] = 0;

flujo = 0;

for (i = 1; i<= aristas; i++)

flujoarista[i] = 0;

j = p[i];

if (j == fuente)

flujo += cap[i];

primarista[j]++;

flujovertice[fuente] = flujo;

NY = 1;

for (i = 1; i<= vertice; i++)

j = primarista[i];

primarista[i] = NY;

mapeoi[i] = NY;

NY += j;

termino = false;

A = true;

5
// Ordenamiento de aristas en orden lexicográfico

etiqueta1:

while (true)

aux = 0;

B = false;

etiqueta2:

while (true)

if (!B) {

if ((aux < 0) && A) {

if (aux != -1) {

if (NY < 0) NP++;

NQ = cont2;

cont2 = NP;

aux = -1; }

else {

if (NY <= 0) {

if (cont1 > 1) {

cont1--;

cont2 = cont1;

A = false;

continue etiqueta2; }

if (aristas1 == 1)

aux = 0;

else {

NP = aristas1;

6
 aristas1--;

NQ = 1;

aux = 1;

else aux = 2;

else {

if (A)

if (aux > 0) {

if (aux <= 1) cont2 = cont1;

A = false;

if (A) {

aristas1 = aristas;

cont1 = 1 + aristas / 2;

cont1--;

cont2 = cont1;

A = true;

NP = cont2 + cont2;

if (NP < aristas1) {

NQ = NP + 1;

aux = -2;

else {

if (NP == aristas1) {

NQ = cont2;

7
cont2 = NP;

aux = -1;

else {

if (cont1 > 1) {

cont1--;

cont2 = cont1;

A = false;

continue etiqueta2;

if (aristas1 == 1)

aux = 0;

else {

NP = aristas1;

aristas1--;

NQ = 1;

aux = 1;

G = false;

C = false;

if ((aux < 0) && !B) {

NY = p[NP] - p[NQ];

if (NY == 0) NY = q[NP] - q[NQ];

continue etiqueta2; }

else {

8
if ((aux > 0) || B) {

// intercambio de dos aristas

B = false;

NY = p[NP];

p[NP] = p[NQ];

p[NQ] = NY;

flujo = cap[NP];

cap[NP] = cap[NQ];

cap[NQ] = flujo;

NY = q[NP];

q[NP] = q[NQ];

q[NQ] = NY;

flujo = flujoarista[NP];

flujoarista[NP] = flujoarista[NQ];

flujoarista[NQ] = flujo;

if (aux> 0)

continue etiqueta2;

if (aux == 0) {

C = true;

else {

mapeoj[NV] = NQ;

G = true;

else

if (termino)

//Obtención del flujo máximo en cada arista

9
j = 0;

for (i = 1; i<= aristas; i++)

if (flujoarista[i] > 0) {

j++;

p[j] = p[i];

q[j] = q[i];

flujoarista[j] = flujoarista[i];

flujoarista[0] = j;

return;

if (!G && !C) {

//Realiza el cruce de referencias entre aristas

for (i = 1; i<= aristas; i++) {

NV = q[i];

p[i] = mapeoi[NV];

mapeoi[NV]++;

etiqueta3:

while (true) {

if (!G) {

if (!C) {

aux = 0;

for (i = 1; i<= vertice; i++)

if (i != fuente)

flujovertice[i] = 0;

10
mapeoj[i] = aristas + 1;

if (i<vertice) mapeoj[i] = primarista[i + 1];

cortemin[i] = 0;

entrada = 0;

salida = 1;

mapeoi[1] = fuente;

cortemin[fuente] = -1;

while (true)

entrada++;

if (entrada > salida)

break;

NU = mapeoi[entrada];

aristas2 = mapeoj[NU] - 1;

fin = primarista[NU] - 1;

while (true) {

fin++;

if (fin > aristas2)

break;

NV = q[fin];

flujo = cap[fin] - flujoarista[fin];

if ((cortemin[NV] != 0) || (flujo == 0))

continue;

if (NV != destino) {

salida++;

mapeoi[salida] = NV;

cortemin[NV] = -1;

11
}

if (cortemin[destino] == 0)

// Salidas

for (i = 1; i<= vertice; i++)

cortemin[i] = -cortemin[i];

for (i=1; i<=aristas; i++) {

NU = q[p[i]];

if (flujoarista[i] < 0)

flujovertice[NU] -= flujoarista[i];

p[i] = NU;

flujovertice[fuente] = flujovertice[destino];

termino = true;

continue etiqueta1;

cortemin[destino] = 1;

while (true) {

if (!C) {

entrada--;

if (entrada == 0) break;

NU = mapeoi[entrada];

NP = primarista[NU] - 1;

NQ = mapeoj[NU] - 1; }

C = false;

while (NP != NQ) {

NV = q[NQ];

12
if ((cortemin[NV] <= 0) ||(cap[NQ] == flujoarista[NQ])) {

NQ--;

continue;

else {

q[NQ] = -NV;

cap[NQ] -= flujoarista[NQ];

flujoarista[NQ] = 0;

NP++;

if (NP < NQ) {

p[p[NP]] = NQ;

p[p[NQ]] = NP;

B = true;

continue etiqueta2;

break;

if (NP >= primarista[NU])

cortemin[NU] = NP;

NW = 0;

for (i=1; i<=salida; i++)

if (cortemin[mapeoi[i]] > 0) {

NW++;

mapeoi[NW] = mapeoi[i];

// Encuentra el flujo más factible

13
aux = -1;

NX = 1;

etiqueta4:

while (true) {

if (!G) {

if (!F) {

if (!D && !E)

NU = mapeoi[NX];

if ((flujovertice[NU] <= 0) || D || E) {

if (!E) {

D = false;

NX++;

if (NX <= NW) continue etiqueta4;

parm = 0;

E = false;

NX--;

if (NX != 1) {

NU = mapeoi[NX];

if (flujovertice[NU] < 0) {

E = true;

continue etiqueta4;

if (flujovertice[NU] == 0)

//Flujos acumulados

aristas2 = aristas + 1;

if (NU <vertice)

14
aristas2 = primarista[NU + 1];

fin = mapeoj[NU];

mapeoj[NU] = aristas2;

while (true) {

if (fin == aristas2) {

E = true;

continue etiqueta4;

j = p[fin];

flujo = flujoarista[j];

flujoarista[j] = 0;

cap[j] -= flujo;

flujoarista[fin] -= flujo;

fin++;

if (primarista[NU] >cortemin[NU])

fin = mapeoj[NU];

do {

j = p[fin];

flujo = flujoarista[j];

if (flujovertice[NU] < flujo)

flujo = flujovertice[NU];

flujoarista[j] -= flujo;

flujovertice[NU] -= flujo;

NV = q[fin];

flujovertice[NV] += flujo;

fin++;

15
}

while (flujovertice[NU] > 0);

flujovertice[NU] = -1;

E = true; continue etiqueta4;

fin = cortemin[NU] + 1;

F = true; continue etiqueta4;

for (i = 1; i<= aristas; i++)

{ NV = -q[i];

if (NV >= 0) {

q[i] = NV;

j = p[i];

cap[i] -= flujoarista[j];

flujo = flujoarista[i] - flujoarista[j];

flujoarista[i] = flujo;

flujoarista[j] = -flujo;

continue etiqueta3;

// Se da el flujo máximo a la arista saliente del vertice

fin = cortemin[NU] + 1;

while (true) {

if (!G) {

F = false;

fin--;

16
if (fin <primarista[NU])

break;

NV = -q[fin];

if (flujovertice[NV] < 0)

continue;

flujo = cap[fin] - flujoarista[fin];

if (flujovertice[NU] < flujo)

flujo = flujovertice[NU];

flujoarista[fin] += flujo;

flujovertice[NU] -= flujo;

flujovertice[NV] += flujo;

parm = 1;

NP = p[fin];

NQ = mapeoj[NV] - 1;

if (NP < NQ) {

p[p[NP]] = NQ;

p[p[NQ]] = NP;

B = true;

continue etiqueta2;

if (NP == NQ)

mapeoj[NV] = NQ; }

G = false;

if (flujovertice[NU] > 0)

continue;

if (cap[fin] == flujoarista[fin]) fin--;

break;

cortemin[NU] = fin;

17
if (parm != 0) { D = true;

continue etiqueta4;

} //Se eliminan los excesos de flujo entrantes de los vertices

fin = mapeoj[NU];

do { j = p[fin];

flujo = flujoarista[j];

if (flujovertice[NU] < flujo) flujo = flujovertice[NU];

flujoarista[j] -= flujo;

flujovertice[NU] -= flujo;

NV = q[fin];

flujovertice[NV] += flujo; fin++;

while (flujovertice[NU] > 0);

flujovertice[NU] = -1;

E = true;

continue etiqueta4;

18
Problemas de compilación

Nota: He revisado el condigo y lo he compilado en 3 compiladores en línea y me han salido los

siguientes errores

https://www.onlinegdb.com/online_c_compiler

https://www.compilejava.net/

19
https://www.jdoodle.com/online-java-compiler/

He estado revisando sobre los errores que me aparecen yo creo que al tener 2 clases debo tenerlo
en 2 archivos, pero mis compiladores en línea, solo manejan un archivo por ello no están
considerando la otra clase y me marca el error.

Intente bajar el lenguaje de programación JAVA, en mi computadora pero no lo soporta mi equipo. :(

Interpretación:

Entiendo que el programa lo que debe hacer es indicarme

 El peso o flujo que sale de cada uno de los vértices

 el peso de una arista entre un vértice y otro

Bibliografía
 Anonimo. (-- de -- de --). Compilador de Java. Obtenido de https://www.compilejava.net/

 JetBrains. (-- de -- de --). Online Java Compiler IDE. Obtenido de

https://www.jdoodle.com/online-java-compiler/

 OnlineGDB. (2016). OnlineGDB beta. Obtenido de

https://www.onlinegdb.com/online_c_compiler

 UNADM. (-- de -- de --). Informática 1. Unidad 3. Redes. Obtenido de

https://ceit.unadmexico.mx/contenidos/DCEIT/BLOQUE2/MT/04/MCOM1/U3/descargables/
MCOM1_U3_contenido.pdf

20
21