diff --git a/Examen_Junio17/include/RedCiudadesExamen.h b/Examen_Junio17/include/RedCiudadesExamen.h
new file mode 100644
index 0000000..596e228
--- /dev/null
+++ b/Examen_Junio17/include/RedCiudadesExamen.h
@@ -0,0 +1,120 @@
+//////////////////////////////////////////////////////////////////////////
+//
+// Metodología de la Programación
+// ETS Informática y Telecomunicaciones
+// Universidad de Granada
+// Autor: Jose Luis Gallego Peña
+//
+// Examen Convocatoria Ordinaria - 14 de Junio de 2017
+// Declaración de la clase RedCiudades
+//
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef REDCIUDADES
+#define REDCIUDADES
+
+#include <iostream>
+#include <fstream>
+#include <cstring>
+using namespace std;
+
+struct InfoCiudad{
+
+   char * nombre; // Nombre
+   int poblacion; // Número de habitantes
+
+};
+
+class RedCiudades{
+
+   private:
+
+      int num_ciudades;    // Número de ciudades
+      InfoCiudad * info;   // info[i]: info de la ciudad i
+      double ** distancia; // distancia[i][j]: distancia
+                           // entre las ciudades i y j
+
+   public:
+
+      /*******************************************************************/
+      // Constructor por defecto: Crea una red vacía
+      RedCiudades();
+
+      /*******************************************************************/
+      // Constructor con un argumento: Recibe el nombre de un fichero de texto
+      // con la información sobre una red
+      RedCiudades(const char *);
+
+      /*******************************************************************/
+      // Constructor de copia
+      RedCiudades(RedCiudades &);
+
+      /*******************************************************************/
+      // Destructor
+      ~RedCiudades();
+
+      /*******************************************************************/
+      // Devuelve el número de ciudades
+      int NumCiudades();
+
+      /*******************************************************************/
+      // Devuelve la distancia entre dos ciudades
+      double Distancia(int, int);
+
+      /*******************************************************************/
+      // Devuelve el nombre de una ciudad (en realidad, la dirección de inicio)
+      char * NombreCiudad(int);
+
+      /*******************************************************************/
+      // Devuelve el número de habitantes de una ciudad
+      int PoblacionCiudad(int);
+
+      /*******************************************************************/
+      // Indica si una red está vacía
+      bool EstaVacia();
+
+      /*******************************************************************/
+      // Actualiza el contenido de una red con los datos de un fichero de texto
+      void LeerRedCiudades(const char *);
+
+      /*******************************************************************/
+      // Guarda el contenido de una red en un fichero de texto
+      void EscribirRedCiudades(const char *);
+
+      /*******************************************************************/
+      // Permite obtener el índice de la ciudad con mayor número de conexiones
+      int CiudadMejorConectada();
+
+      /*******************************************************************/
+      // Dadas dos ciudades no conectadas directamente, devuelve aquella
+      // ciudad intermedia que permita hacer el trayecto de la forma más
+      // económica posible
+      int MejorEscalaEntre(int, int);
+
+      /*******************************************************************/
+      // Sobrecarga del operador de salida << para poder insertar en un flujo
+      // de salida el contenido de una red en formato texto
+      friend ostream & operator << (ostream &, const RedCiudades &);
+
+      /*******************************************************************/
+      // Sobrecarga del operador de entrada >> para poder obtener desde un flujo
+      // de entrada el contenido de un objeto
+      friend istream & operator >> (istream &, RedCiudades &);
+
+   private:
+
+      /*******************************************************************/
+      // Reserva memoria para una red de ciudades
+      void ReservaMemoria();
+
+      /*******************************************************************/
+      // Libera la memoria de una red de ciudades
+      void LiberaMemoria();
+      
+      /*******************************************************************/
+      // Copia una red en otra
+      void CopiaRed(RedCiudades &);
+
+};
+
+#endif
\ No newline at end of file
diff --git a/Examen_Junio17/makefile b/Examen_Junio17/makefile
new file mode 100644
index 0000000..a84f8b0
--- /dev/null
+++ b/Examen_Junio17/makefile
@@ -0,0 +1,97 @@
+#************************************************************************#
+#
+# Metodología de la Programación
+# ETS Informática y Telecomunicaciones
+# Universidad de Granada
+# Autor: Jose Luis Gallego Peña
+#
+# Examen Convocatoria Ordinaria - 14 de Junio de 2017
+# Makefile
+#
+#************************************************************************#
+
+HOME = .
+SRC = $(HOME)/src
+BIN = $(HOME)/bin
+OBJ = $(HOME)/obj
+INCLUDE = $(HOME)/include
+LIB = $(HOME)/lib
+
+all : preambulo \
+		mrproper \
+		ejecutables \
+		$(BIN)/examen \
+		fin-ejecutables \
+		fin
+
+# Main
+
+$(BIN)/examen : $(OBJ)/examen.o $(OBJ)/RedCiudadesExamen.o
+	g++ -o $(BIN)/examen $(OBJ)/examen.o $(OBJ)/RedCiudadesExamen.o
+
+$(OBJ)/examen.o : $(SRC)/examen.cpp $(INCLUDE)/RedCiudadesExamen.h
+	g++ -c -o $(OBJ)/examen.o $(SRC)/examen.cpp -I$(INCLUDE)
+
+# Clases
+
+$(OBJ)/RedCiudadesExamen.o : $(SRC)/RedCiudadesExamen.cpp \
+                             $(INCLUDE)/RedCiudadesExamen.h 
+	g++ -c -o $(OBJ)/RedCiudadesExamen.o $(SRC)/RedCiudadesExamen.cpp \
+	          -I$(INCLUDE)
+
+# Mensajes
+
+preambulo:
+	@echo
+	@echo ------------------------------------------------------------
+	@echo Examen Convocatoria Ordinaria - 14 de Junio de 2017
+	@echo
+	@echo Metodología de la Programación
+	@echo ETS Informática y Telecomunicaciones. Universidad de Granada
+	@echo
+	@echo Autor: Jose Luis Gallego Peña
+	@echo ------------------------------------------------------------
+	@echo
+
+ejecutables:
+	@echo Creando ejecutables...
+
+fin-ejecutables:
+	@echo ...Creados
+	@echo 	
+
+fin :
+	@echo
+	@echo Todo listo
+
+# LIMPIEZA 
+
+clean : clean-objs
+
+clean-objs : 
+	@echo Borrando objetos...
+
+	-rm $(OBJ)/examen.o
+	-rm $(OBJ)/RedCiudadesExamen.o
+
+	@echo ...Borrados
+	@echo 
+
+clean-bins : 
+	@echo Borrando ejecutables...
+
+	-rm $(BIN)/examen
+
+	@echo ...Borrados
+	@echo 	
+
+clean-bak : 
+	@echo Borrando copias antiguas...
+
+	-rm $(SRC)/*.cpp~
+	-rm $(INCLUDE)/*.h~
+
+	@echo ...Borrados
+	@echo 	
+
+mrproper : clean clean-bins clean-bak
\ No newline at end of file
diff --git a/Examen_Junio17/src/RedCiudadesExamen.cpp b/Examen_Junio17/src/RedCiudadesExamen.cpp
new file mode 100644
index 0000000..8872b1a
--- /dev/null
+++ b/Examen_Junio17/src/RedCiudadesExamen.cpp
@@ -0,0 +1,291 @@
+//////////////////////////////////////////////////////////////////////////
+//
+// Metodología de la Programación
+// ETS Informática y Telecomunicaciones
+// Universidad de Granada
+// Autor: Jose Luis Gallego Peña
+//
+// Examen Convocatoria Ordinaria - 14 de Junio de 2017
+// Definición de la clase RedCiudades
+//
+//////////////////////////////////////////////////////////////////////////
+
+#include "RedCiudadesExamen.h"
+
+RedCiudades :: RedCiudades()
+   :num_ciudades(0), info(0), distancia(0)
+{   
+}
+
+RedCiudades :: RedCiudades(RedCiudades & red)
+   :num_ciudades(red.num_ciudades)
+{
+
+   ReservaMemoria();
+   CopiaRed(red);
+
+}
+
+RedCiudades :: RedCiudades(const char * nombre){
+
+   LeerRedCiudades(nombre);
+
+}
+
+RedCiudades :: ~RedCiudades(){
+
+   LiberaMemoria();
+
+}
+
+int RedCiudades :: NumCiudades(){
+
+   return num_ciudades;
+
+}
+
+double RedCiudades :: Distancia(int ciudad1, int ciudad2){
+
+   return distancia[ciudad1][ciudad2];
+
+}
+
+char * RedCiudades :: NombreCiudad(int ciudad){
+
+   return info[ciudad].nombre;
+
+}
+
+int RedCiudades :: PoblacionCiudad(int ciudad){
+
+   return info[ciudad].poblacion;
+
+}
+
+bool RedCiudades :: EstaVacia(){
+
+   return (num_ciudades == 0);   // Una red está vacía si no tiene ciudades 
+
+}
+
+void RedCiudades :: LeerRedCiudades(const char * nombre){
+
+   ifstream fi (nombre);
+   char cadena[100];
+
+   fi >> cadena;
+
+   if (!strcmp(cadena, "RED")){
+
+      fi >> (*this);
+
+   }
+
+}
+
+void RedCiudades :: EscribirRedCiudades(const char * nombre){
+
+   ofstream fo (nombre);
+
+   fo << "RED" << endl;
+   fo << (*this);
+
+}
+
+int RedCiudades :: CiudadMejorConectada(){
+
+   int mayor_conexiones = 0, mayor_ciudad = 0, conexiones = 0;
+
+   for (int i = 0 ; i < num_ciudades ; i++){
+
+      for (int j = 0 ; j < num_ciudades ; j++){
+
+         if (distancia[i][j] > 0){
+
+            conexiones++;
+
+         }
+      }
+
+      if (conexiones > mayor_conexiones){
+
+         mayor_conexiones = conexiones;
+         mayor_ciudad = i;
+         conexiones = 0;
+
+      }
+   }
+
+   return mayor_ciudad;
+
+}
+
+int RedCiudades :: MejorEscalaEntre(int ciudad1, int ciudad2){
+
+   int costo = 0, intermedia = -1, menor_costo = 99999;
+
+   for (int i = ciudad1 ; i < num_ciudades ; i++){
+
+      for (int j = 0 ; j < num_ciudades ; j++){
+
+         if (distancia[i][j] > 0){
+
+            costo = distancia[i][j] + distancia[ciudad2][i];
+
+            if (costo < menor_costo){
+
+               menor_costo = costo;
+               intermedia = j;
+
+            }
+         }
+      }
+   }
+
+   return intermedia;
+
+}
+
+ostream & operator << (ostream & out, const RedCiudades & red){
+
+   out << red.NumCiudades() << endl;
+
+   for (int i = 0 ; i < red.NumCiudades() ; i++){
+
+      out << i << " " << red.NombreCiudad(i) << " " << red.PoblacionCiudad(i);
+      out << endl;
+
+   }
+
+   for (int i = 0 ; i < num_ciudades ; i++){
+
+      for (int j = 0 ; j < num_ciudades ; j++){
+
+         if (red.Distancia[i][j] > 0){
+
+            out << i << " " << j << " " << red.Distancia(i, j) << endl;
+
+         }
+      }
+   }
+
+   return out;
+
+}
+
+istream & operator >> (istream & in, RedCiudades & red){
+
+   red.LiberaMemoria();
+
+   in >> red.num_ciudades;
+
+   red.ReservaMemoria();
+
+   int indice;
+
+   for (int i = 0 ; i < red.NumCiudades() ; i++){
+
+      in >> indice;
+      in >> red.info[indice].nombre;
+      in >> red.info[indice].poblacion;
+
+   }
+
+   int i, j;
+
+   while (in >> i){
+
+      in >> j;
+
+      in >> red.distancia[i][j];
+
+      red.distancia[j][i] = red.distancia[i][j];
+
+   }
+
+   return in;
+
+}
+
+void RedCiudades :: ReservaMemoria(){
+
+   const int MAX_NOMBRE = 50; // Longitud máxima del nombre de la ciudad
+
+   info = new InfoCiudad [num_ciudades];  // Memoria para el vector de info
+
+   // Memoria para los distintos nombres
+   for (int i = 0 ; i < num_ciudades ; i++){
+
+      info[i].nombre = new char [MAX_NOMBRE];
+
+   }
+
+   // Memoria para la matriz de distancias
+   distancia = new double * [num_ciudades];
+
+   for (int i = 0 ; i < num_ciudades ; i++){
+
+      distancia[i] = new double [num_ciudades]; 
+
+      for (int j = 0 ; j < num_ciudades ; j++){
+
+         // Inicializar todas las casillas a 0
+         distancia[i][j] = 0;
+
+      }
+   }
+
+}
+
+void RedCiudades :: LiberaMemoria(){
+
+   if (info != 0){
+
+      for (int i = 0 ; i < num_ciudades ; i++){
+
+         delete [] info.nombre[i];
+
+      }
+
+      delete [] info;
+
+      info = 0;
+
+   }
+
+   if (distancia != 0){
+
+      for (int i = 0 ; i < num_ciudades ; i++){
+
+         delete [] distancia[i];
+
+      }
+
+      delete [] distancia;
+
+      distancia = 0;
+
+   }
+
+   num_ciudades = 0;
+
+}
+
+void RedCiudades :: CopiaRed(RedCiudades & red){
+
+   num_ciudades = red.num_ciudades;
+
+   for (int i = 0 ; i < num_ciudades ; i++){
+
+      info[i].nombre = red.info[i].nombre;
+      info[i].poblacion = red.info[i].poblacion;
+
+   }
+
+   for (int i = 0 ; i < num_ciudades ; i++){
+
+      memcpy(distancia[i], red.distancia[i], num_ciudades*sizeof(double));
+
+   }
+
+}
\ No newline at end of file
diff --git a/Examen_Junio17/src/examen.cpp b/Examen_Junio17/src/examen.cpp
new file mode 100644
index 0000000..1c04be4
--- /dev/null
+++ b/Examen_Junio17/src/examen.cpp
@@ -0,0 +1,42 @@
+//////////////////////////////////////////////////////////////////////////
+//
+// Metodología de la Programación
+// ETS Informática y Telecomunicaciones
+// Universidad de Granada
+// Autor: Jose Luis Gallego Peña
+//
+// Examen Convocatoria Ordinaria - 14 de Junio de 2017
+// Programa principal
+//
+//////////////////////////////////////////////////////////////////////////
+
+#include <iostream>
+#include "RedCiudadesExamen.h"
+using namespace std;
+
+int main(int argc, char ** argv){
+
+   if (argc != 2){
+
+      cerr << "ERROR: Número de argumentos introducidos incorrecto" << endl;
+      exit (1);
+
+   }
+
+   RedCiudades red (argv[1]);
+
+   for (int i = 0 ; i < red.NumCiudades() - 1 ; i++){
+
+      int intermedia = red.MejorEscalaEntre(i, i+1);
+
+      if (intermedia != -1){
+
+         cout << "La mejor escala para las ciudades " << i << " y " << i + 1 
+              << "es la ciudad intermedia: " << intermedia << endl;
+
+      }
+   }
+
+   return 0;
+
+}  
\ No newline at end of file