Ejercicio N 111

pgina 314 problema propuesto 6.1.

int hayCiclo(Grafo g,int v)
//indica indica si existe algn ciclo que parta del vertice v

/*clase grafo
*@autor Ivan
*@vercion 1
*/
package edatB;

// esta clase trabaja con grafos dirijidos y con arreglos para su almacenamiento

public class Grafo {

protected Vertice vertices[];
protected Arco arcos[];
protected int orden;
protected final int MAX=10;

public Grafo(){
vertices=new Vertice[MAX];
arcos=new Arco[MAX*MAX];
orden=0;
}
public void insVertice(int V){
Vertice vertice=new Vertice(V);
vertices[this.orden]=vertice;
this.orden++;
}
public void insArco(int V1,int V2,int costo){
Arco arco=new Arco(V1,V2,costo);
int i=0;
while(!(arcos[i]==null)){
++i;
}
arcos[i]=arco;
}
public void elimArco(int V1,int V2){
for(int i=0;i<this.arcos.length||this.arcos[i]==null;i++){
if(arcos[i].Vn.pos==V1&&arcos[i].Vn1.pos==V2){
for(int j=i;j<this.arcos.length-1||this.arcos[j]==null;++j){
arcos[j]=arcos[j+1];
}
break;
}
}
}

public int costArco(int V1,int V2){
int costo=-1;
for(int i=0;i<this.arcos.length||this.arcos[i]==null;i++){
if(arcos[i].Vn.pos==V1&&arcos[i].Vn1.pos==V2){
costo=arcos[i].costo;
}else return -1;
}
return costo;
}
public Lista sucesores(int V1){
Lista vertices=new Lista();
int ver=0;
for(int i=0;i<this.arcos.length||this.arcos[i]==null;i++){
if(arcos[i].Vn.pos==V1){
ver=arcos[i].Vn1.pos;
Nodo nodo=new Nodo(ver);
vertices.insertar(nodo);
}
}
return vertices;
}
public void infoVertice(){
//falta este codigo
}
public int ordenGrafo(){
return this.orden;
}
public void destruirGrafo(){
this.vertices=new Vertice[MAX];
this.arcos=new Arco[MAX*MAX];
this.orden=0;
}

}
//clase arco
public class Arco {

public Vertice Vn;
public Vertice Vn1;
public int costo;

public Arco() {
Vn=new Vertice();
Vn1=new Vertice();
costo=0;
}

public Arco(int Vn,int Vn1,int costo){
this.Vn=new Vertice(Vn);
this.Vn1=new Vertice(Vn1);
this.costo=costo;
}
public String toString(){
return Vn+" "+Vn1+" "+costo;
}
}



//Clase vertice
public class Vertice {
//pos ====>pocicion
public int pos;

public Vertice(){
pos=0;
}
public Vertice(int pos){
this.pos=pos;
}
public String toString(){
return pos+" ";
}
}


V
n
1
V
n
// clase test grafo
public class testGrafos {

public static void main (String arr[]){

Grafo grafo=new Grafo();

grafo.insVertice(1);
grafo.insVertice(2);
grafo.insVertice(3);
grafo.insVertice(4);

grafo.insArco(1,2,5);
grafo.insArco(4,3,5);
grafo.insArco(2,4,5);
grafo.insArco(3,1,5);
int resp=hayCiclo(grafo,2);
System.out.println("hay ciclo ?: "+resp);
}
//problema 111 pagina 314 tema:grafos

//recibe un grafo y una pocicion;retorna 1 en caso de ser verdadero y -1 en caso de ser falso
public static int hayCiclo(Grafo g,int V){
Vertice []v=g.vertices;
Arco []a=g.arcos;
int estate=0;
int i=0,tem=V;
for(i=0;a[i]!=null;i++){
if(a[i].Vn.pos==tem){
tem=a[i].Vn1.pos;
i=-1;
estate++;
if(tem==V){
estate=1;
break;
}
if(estate>g.orden){
estate=-1;
break;
}
}
}
return estate;
}

}

Ejercicio 121


public static Lista frontera2(Grafo g,int v, int l)
// retorna una lista del grafo con todas los vertices del grafo a los cuales existe un camino simple de longitud menor o igual
que parte del vertice v
// clase test grafo
public class testGrafos {

public static void main (String arr[]){

Grafo grafo=new Grafo();

grafo.insVertice(1);
grafo.insVertice(2);
grafo.insVertice(3);
grafo.insVertice(4);
grafo.insVertice(5);

grafo.insArco(4,3,5);
grafo.insArco(2,4,5);
grafo.insArco(1,2,5);
grafo.insArco(3,1,5);
grafo.insArco(2,3,5);
grafo.insArco(1,3,5);

Lista lis=frontera2(grafo,2,11);
System.out.println("se tienen los vertices "+lis.toString()+" ");
}

//problema 121 pgina 315
//
private static Lista frontera2(Grafo g, int v, int l) {
Lista list=new Lista();
Nodo nodo=new Nodo(0);
Arco []a=g.arcos;
int tem=0;

int lo=0;
for(int j=0;a[j]!=null;j++){
if(a[j].Vn.pos==v&&a[j].costo<=l){
tem=a[j].Vn1.pos;
nodo=new Nodo(tem);
list.insertar(nodo);
}
}
return list;
}

}

Ejercicio 122
private static int existeMayor(Grafo g, int v1, int v2, int l) {
//Imforma si existe un camino que lleve de v1 a v2 con una longitud mayor a l
public class testGrafos {

public static void main (String arr[]){

Grafo grafo=new Grafo();

grafo.insVertice(1);
grafo.insVertice(2);
grafo.insVertice(3);
grafo.insVertice(4);
grafo.insVertice(5);

grafo.insArco(4,3,5);
grafo.insArco(2,4,5);
grafo.insArco(1,2,5);
grafo.insArco(3,1,5);
grafo.insArco(2,3,5);
grafo.insArco(1,3,5);
int v=existeMayor(grafo,1,3,14);

System.out.println("la longitud es de "+v);
}



//problema propuesto 122 pag 315
//problema propuesto 6.12
//recive el grafo , el de inicio y el vertice al que se tiene que llegar
retorna la longitud del camino si este es mayor que l, caso contrario retorna 0
private static int existeMayor(Grafo g, int v1, int v2, int l) {

Arco []a=g.arcos;
int tem=v1;
int lo=0;
for(int i=0;a[i]!=null;i++){

if(a[i].Vn.pos==tem){
tem=a[i].Vn1.pos;
lo+=a[i].costo;
i=-1;
}
if(tem==v2){
break;
}

}
if(lo>l)
return lo;
else return 0;
}

Ejercicio 126
public Lista predecesores(int V1){
//Retorna la lisa de predecesores del vertice v

//problema propuesto 126 pag 322
//problema propuesto 6.16
//Recive el vertice a analisar

public Lista predecesores(int V1){
Lista vertices=new Lista();
Nodo nodo=new Nodo();
int ver=0;
for(int i=0;i<this.arcos.length||this.arcos[i]!=null;i++){
if(arcos[i].Vn1.pos==V1){
ver=arcos[i].Vn.pos;
nodo=new Nodo(ver);
vertices.insertar(nodo);
}
}
return vertices;
}