Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » ADA » calcular numero de caminos

ADA - calcular numero de caminos

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil

calcular numero de caminos

Publicado por Tania (1 intervención) el 16/12/2013 11:20:09
Necesito calcular el numero de caminos entre dos nodos de un árbol. Para esto me dan un fichero con siguientes datos :
(por ejemplo)
4 -- num_nodos. No supera 50
1 2 1 --nodoOrigen nodoDestino ancho de banda
1 3 2
2 4 3
3 4 4

Alguien me podría ayudar hacer el código en ADA, por favor.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Cálculo del número de caminos entre dos nodos en un árbol

Publicado por Alejandro (155 intervenciones) el 03/07/2023 17:24:17
A continuación, te proporcionaré un ejemplo de código en ADA para calcular el número de caminos entre dos nodos de un árbol, utilizando los datos proporcionados en el fichero:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
with Ada.Text_IO;
use Ada.Text_IO;
 
procedure Caminos is
   type Nodo is range 1 .. 50;
   type Ancho_Banda is new Integer;
 
   subtype Num_Nodos is Nodo range 1 .. 50;
   type Lista_Adyacencia is array (Nodo) of Ada.Containers.Vectors.Vector (1 .. Num_Nodos);
   type Matriz_Adjacencia is array (Nodo, Nodo) of Ancho_Banda;
 
   procedure Leer_Datos (F : in File_Type; Num_Nodos : out Num_Nodos; Lista : out Lista_Adyacencia; Matriz : out Matriz_Adjacencia);
   procedure Calcular_Caminos (Origen, Destino : in Nodo; Lista : in Lista_Adyacencia; Matriz : in Matriz_Adjacencia; Caminos : out Integer);
 
   F : File_Type;
   Num_Nodos : Num_Nodos;
   Lista : Lista_Adyacencia;
   Matriz : Matriz_Adjacencia;
   Origen, Destino : Nodo;
   Num_Caminos : Integer;
begin
   -- Abrir el fichero de datos
   Open (F, In_File, "ruta_del_fichero");
 
   -- Leer los datos del fichero
   Leer_Datos (F, Num_Nodos, Lista, Matriz);
 
   -- Cerrar el fichero
   Close (F);
 
   -- Obtener los nodos de origen y destino
   Put ("Ingrese el nodo de origen: ");
   Get (Origen);
   Put ("Ingrese el nodo de destino: ");
   Get (Destino);
 
   -- Calcular el número de caminos entre los nodos
   Calcular_Caminos (Origen, Destino, Lista, Matriz, Num_Caminos);
 
   -- Mostrar el resultado
   Put ("El número de caminos entre los nodos ");
   Put (Origen);
   Put (" y ");
   Put (Destino);
   Put (" es: ");
   Put (Num_Caminos);
   New_Line;
 
exception
   when others =>
      Put_Line ("Ocurrió un error al procesar el archivo.");
end Caminos;
 
procedure Leer_Datos (F : in File_Type; Num_Nodos : out Num_Nodos; Lista : out Lista_Adyacencia; Matriz : out Matriz_Adjacencia) is
   Nodo_Origen, Nodo_Destino : Nodo;
   Ancho : Ancho_Banda;
begin
   -- Leer el número de nodos
   Get (F, Num_Nodos);
   Skip_Line (F);
 
   -- Inicializar la lista de adyacencia y matriz de adyacencia
   for I in Num_Nodos loop
      Lista (I) := Ada.Containers.Vectors.Empty_Vector (1 .. Num_Nodos);
      for J in Num_Nodos loop
         Matriz (I, J) := 0;
      end loop;
   end loop;
 
   -- Leer los datos de las conexiones
   while not End_Of_File (F) loop
      Get (F, Nodo_Origen);
      Get (F, Nodo_Destino);
      Get (F, Ancho);
      Skip_Line (F);
 
      Lista (Nodo_Origen).Append (Nodo_Dest
 
ino);
      Matriz (Nodo_Origen, Nodo_Destino) := Ancho;
   end loop;
end Leer_Datos;
 
procedure Calcular_Caminos (Origen, Destino : in Nodo; Lista : in Lista_Adyacencia; Matriz : in Matriz_Adjacencia; Caminos : out Integer) is
   function Contar_Caminos (Nodo_Actual : Nodo) return Integer is
      Resultado : Integer := 0;
   begin
      if Nodo_Actual = Destino then
         return 1;
      else
         for I in Lista (Nodo_Actual)'Range' loop
            Resultado := Resultado + Contar_Caminos (Lista (Nodo_Actual)(I));
         end loop;
         return Resultado;
      end if;
   end Contar_Caminos;
begin
   Caminos := Contar_Caminos (Origen);
end Calcular_Caminos;
 
begin
   Caminos;
end;

Asegúrate de reemplazar `"ruta_del_fichero"` en el programa con la ubicación y el nombre de tu fichero de datos.

Este código implementa una solución recursiva para calcular el número de caminos entre dos nodos en un árbol. La función `Contar_Caminos` utiliza una estrategia de recorrido en profundidad para contar los caminos posibles desde el nodo actual hasta el nodo de destino.

Espero que este ejemplo te ayude a resolver tu problema.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar