diff --git a/jdk_21_maven/cs/rest/adoptme/.gitattributes b/jdk_21_maven/cs/rest/adoptme/.gitattributes
new file mode 100644
index 000000000..3b41682ac
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/.gitattributes
@@ -0,0 +1,2 @@
+/mvnw text eol=lf
+*.cmd text eol=crlf
diff --git a/jdk_21_maven/cs/rest/adoptme/.gitignore b/jdk_21_maven/cs/rest/adoptme/.gitignore
new file mode 100644
index 000000000..667aaef0c
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/.gitignore
@@ -0,0 +1,33 @@
+HELP.md
+target/
+.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
diff --git a/jdk_21_maven/cs/rest/adoptme/.mvn/wrapper/maven-wrapper.properties b/jdk_21_maven/cs/rest/adoptme/.mvn/wrapper/maven-wrapper.properties
new file mode 100644
index 000000000..c0bcafe98
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/.mvn/wrapper/maven-wrapper.properties
@@ -0,0 +1,3 @@
+wrapperVersion=3.3.4
+distributionType=only-script
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.11/apache-maven-3.9.11-bin.zip
diff --git a/jdk_21_maven/cs/rest/adoptme/README.md b/jdk_21_maven/cs/rest/adoptme/README.md
new file mode 100644
index 000000000..f2e95969f
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/README.md
@@ -0,0 +1,250 @@
+# 🐶 AdoptMe – Trabajo Práctico Final (Programación 3 – UADE)
+
+Aplicación desarrollada en **Spring Boot + Neo4j**, que simula un sistema de adopción de perros entre refugios y adoptantes.  
+El proyecto incluye lógica de grafos para encontrar caminos entre refugios (BFS) y próximamente otros algoritmos de búsqueda y priorización.
+
+---
+
+## 🚀 Tecnologías utilizadas
+
+- **Java 21**
+- **Spring Boot 3.5.x**
+- **Neo4j 5.x (base de datos de grafos)**
+- **Maven Wrapper (`mvnw`)**
+- **Lombok** (para reducir código repetitivo)
+- **IntelliJ IDEA / VS Code / Eclipse**
+
+---
+
+## 📂 Estructura del proyecto
+
+```
+src/
+ └── main/java/com/programacion3/adoptme
+     ├── AdoptMApplication.java
+     ├── config/
+     │    └── DbSeed.java              # Semilla inicial de la base (Shelters, Dogs, Adopters)
+     ├── controller/                   # Controladores REST
+     ├── domain/                       # Entidades (Shelter, Dog, Adopter)
+     ├── dto/                          # Clases para respuestas personalizadas (PathResponse)
+     ├── repo/                         # Repositorios Neo4j
+     ├── service/                      # Lógica de negocio y algoritmos (BFS, etc)
+     └── util/                         # Clases auxiliares (Edge, etc)
+```
+
+
+---
+
+## ⚙️ Requisitos previos
+
+### 1️⃣ Java y Maven
+Verificar instalación:
+```
+java -version
+mvn -version
+```
+Si no los tenés:
+- Java 21: https://adoptium.net
+- Maven: https://maven.apache.org/download.cgi
+
+---
+
+### 2️⃣ Neo4j Desktop
+
+1. Descargar desde 👉 https://neo4j.com/download/
+2. Crear una base local llamada adoptme
+3. Configurar:
+    - Usuario: neo4j
+    - Contraseña: neo4j123
+    - Puerto Bolt: 7687
+4. Iniciar la base
+5. Abrir Neo4j Browser y probar:
+   RETURN 1 AS ok;
+
+---
+
+## 🔧 Configuración de Spring Boot
+
+Archivo: src/main/resources/application.yml
+```
+spring:
+neo4j:
+uri: bolt://localhost:7687
+authentication:
+username: neo4j
+password: neo4j123
+data:
+neo4j:
+database: neo4j
+
+server:
+port: 8080
+```
+---
+
+## ▶️ Ejecución del proyecto
+
+### En IntelliJ
+1. Abrir el proyecto (File → Open → pom.xml)
+2. Esperar a que Maven descargue dependencias
+3. Verificar que Neo4j esté corriendo
+4. Click derecho sobre AdoptMApplication → Run
+
+### Desde terminal
+```
+./mvnw.cmd spring-boot:run   # Windows
+
+./mvnw spring-boot:run       # Linux/Mac
+```
+---
+
+## 🌱 Base de datos inicial (Seed)
+
+Al iniciar la aplicación, se ejecuta automáticamente la clase DbSeed.java, que:
+
+- Limpia la base (MATCH (n) DETACH DELETE n)
+- Crea refugios (A, B, C) conectados con relaciones :NEAR
+- Crea perros (Luna, Toto, Rex) ubicados en refugios
+- Crea adoptantes (Carla, Leo)
+
+Podés visualizarlo en Neo4j Browser con:
+
+MATCH (n) RETURN n;
+
+---
+
+## 🧪 Endpoints principales
+
+Método | URL | Descripción
+-------|-----|-------------
+GET | /ping | Verifica conexión
+GET | /shelters | Lista los refugios
+GET | /dogs | Lista los perros
+GET | /dogs/sort?criteria=priority&algorithm=mergesort | Ordena perros
+GET | /adopters | Lista los adoptantes
+GET | /graph/reachable?from=A&to=C&method=bfs | Ejecuta BFS/DFS entre refugios
+GET | /routes/shortest?from=A&to=C | Calcula camino más corto (Dijkstra)
+GET | /routes/tsp/bnb?nodes=A,B,C | Calcula ruta TSP óptima
+GET | /network/mst?algorithm=kruskal | Calcula MST (Kruskal/Prim)
+GET | /adoptions/greedy?adopterId=P1 | Matching greedy de perros
+GET | /adoptions/constraints/backtracking | Asignación por backtracking
+GET | /transport/optimal-dp?capacityKg=50 | Optimización de transporte (Knapsack)
+
+Ejemplo de respuesta:
+
+{
+"exists": true,
+"path": ["A", "B", "C"]
+}
+
+---
+
+## 🎨 Frontend Web
+
+El proyecto incluye un **frontend web interactivo** ubicado en la carpeta `/frontend`.
+
+### Características
+- ✅ Interfaz moderna y responsiva (sin color violeta)
+- ✅ Dashboard con estadísticas en tiempo real
+- ✅ Prueba de todos los algoritmos implementados
+- ✅ Datos precargados para testing
+- ✅ Visualización clara de resultados
+
+### Cómo usar el Frontend
+
+1. **Iniciar el backend** (Spring Boot debe estar corriendo en `http://localhost:8080`)
+
+2. **Abrir el frontend** de alguna de estas formas:
+
+   **Opción A - Servidor HTTP Simple (Python):**
+   ```bash
+   cd frontend
+   python3 -m http.server 3000
+   ```
+   Luego abrir: http://localhost:3000
+
+   **Opción B - Directamente en el navegador:**
+   ```bash
+   cd frontend
+   # Abrir index.html con tu navegador preferido
+   ```
+
+   **Opción C - VS Code Live Server:**
+   - Instalar extensión "Live Server"
+   - Click derecho en `index.html` → "Open with Live Server"
+
+3. **Explorar las pestañas:**
+   - **Dashboard**: Ver refugios, perros y adoptantes
+   - **Rutas & Grafos**: BFS, DFS, Dijkstra, TSP
+   - **Redes & MST**: Kruskal, Prim
+   - **Matching**: Greedy, Backtracking
+   - **Ordenamiento**: MergeSort, QuickSort
+   - **Transporte**: Knapsack (Programación Dinámica)
+
+### Datos de Prueba Precargados
+
+El sistema incluye datos de prueba en Neo4j:
+- **4 Refugios**: A, B, C, H (Hub)
+- **6 Perros**: Luna, Toto, Rex, Miranda, Perchita, Lina
+- **3 Adoptantes**: Camila (P1), Lucas (P2), Daniela (P3)
+
+Todos los algoritmos pueden probarse directamente desde la interfaz web.
+
+---
+
+## 🧠 Algoritmos implementados
+
+### Algoritmos de Grafos
+- **BFS (Breadth-First Search)**: Encuentra caminos entre refugios por búsqueda en anchura
+- **DFS (Depth-First Search)**: Encuentra caminos entre refugios por búsqueda en profundidad
+- **Dijkstra**: Calcula el camino más corto considerando distancias ponderadas
+- **TSP Branch & Bound**: Resuelve el Problema del Viajante para encontrar la ruta óptima
+
+### Algoritmos de Redes
+- **Kruskal**: Calcula el Árbol de Expansión Mínima (MST)
+- **Prim**: Calcula el MST usando un enfoque alternativo
+
+### Algoritmos de Asignación
+- **Greedy**: Selección voraz de perros para un adoptante basado en compatibilidad
+- **Backtracking**: Asignación de múltiples perros a múltiples adoptantes con restricciones
+
+### Algoritmos de Ordenamiento
+- **MergeSort (TimSort)**: Ordenamiento eficiente de perros por prioridad, edad o peso
+- **QuickSort**: Ordenamiento divide y conquista
+
+### Programación Dinámica
+- **Knapsack 0/1**: Optimiza el transporte de perros maximizando prioridad dentro de capacidad
+
+---
+
+## 💡 Tips y resolución de errores
+
+- Si la app tira error de conexión a Neo4j:
+    - Verificá que esté corriendo en el puerto 7687
+    - Revisá usuario y contraseña en application.yml
+
+- Si el seed falla:
+    - Borrar manualmente todos los nodos:
+      MATCH (n) DETACH DELETE n;
+    - Luego reiniciar la app
+
+- Si IntelliJ no reconoce lombok:
+    - Instalar el plugin desde Settings → Plugins → Lombok
+    - Habilitar Annotation Processing
+
+---
+
+## 🧍‍♀️ Integrantes del grupo
+
+Nombre | Legajo   
+--------|----------
+Daniela Melian | 198423   
+Lucas Vitale | 1192520 
+Camila Di Laudo| 1193552
+
+---
+
+## 🧾 Licencia
+
+Proyecto académico – Universidad Argentina de la Empresa (UADE)
+Materia: Programación 3 – 2C 2025
diff --git a/jdk_21_maven/cs/rest/adoptme/frontend/app.js b/jdk_21_maven/cs/rest/adoptme/frontend/app.js
new file mode 100644
index 000000000..9061080e6
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/frontend/app.js
@@ -0,0 +1,837 @@
+// API Configuration
+const API_BASE_URL = 'http://localhost:8080';
+
+// Global State
+let appData = {
+    refugios: [],
+    perros: [],
+    adoptantes: []
+};
+
+// ==================== Initialization ====================
+
+document.addEventListener('DOMContentLoaded', () => {
+    initializeTabs();
+    checkConnection();
+    loadDashboardData();
+    populateSelectors();
+});
+
+// ==================== Tab Navigation ====================
+
+function initializeTabs() {
+    const tabButtons = document.querySelectorAll('.tab-button');
+
+    tabButtons.forEach(button => {
+        button.addEventListener('click', () => {
+            const tabId = button.getAttribute('data-tab');
+            switchTab(tabId);
+        });
+    });
+}
+
+function switchTab(tabId) {
+    // Hide all tab contents
+    document.querySelectorAll('.tab-content').forEach(content => {
+        content.classList.remove('active');
+    });
+
+    // Remove active class from all buttons
+    document.querySelectorAll('.tab-button').forEach(button => {
+        button.classList.remove('active');
+    });
+
+    // Show selected tab content
+    document.getElementById(tabId).classList.add('active');
+
+    // Add active class to selected button
+    document.querySelector(`[data-tab="${tabId}"]`).classList.add('active');
+}
+
+// ==================== Connection Check ====================
+
+async function checkConnection() {
+    const statusIndicator = document.querySelector('.status-indicator');
+    const statusText = document.querySelector('.status-text');
+
+    try {
+        const response = await fetch(`${API_BASE_URL}/ping`, { timeout: 5000 });
+
+        if (response.ok) {
+            statusIndicator.classList.add('connected');
+            statusText.textContent = 'Conectado';
+        } else {
+            throw new Error('Connection failed');
+        }
+    } catch (error) {
+        statusIndicator.classList.add('error');
+        statusText.textContent = 'Error de conexión';
+        console.error('Connection error:', error);
+    }
+}
+
+// ==================== Dashboard Data Loading ====================
+
+async function loadDashboardData() {
+    try {
+        showLoading();
+
+        // Load all data in parallel
+        const [refugios, perros, adoptantes] = await Promise.all([
+            fetchAPI('/shelters'),
+            fetchAPI('/dogs'),
+            fetchAPI('/adopters')
+        ]);
+
+        appData.refugios = refugios;
+        appData.perros = perros;
+        appData.adoptantes = adoptantes;
+
+        // Update stats
+        document.getElementById('statsRefugios').textContent = refugios.length;
+        document.getElementById('statsPerros').textContent = perros.length;
+        document.getElementById('statsAdoptantes').textContent = adoptantes.length;
+
+        // Display data
+        displayRefugios(refugios);
+        displayPerros(perros);
+        displayAdoptantes(adoptantes);
+
+        hideLoading();
+    } catch (error) {
+        hideLoading();
+        console.error('Error loading dashboard data:', error);
+        showError('Error al cargar los datos del dashboard');
+    }
+}
+
+function displayRefugios(refugios) {
+    const container = document.getElementById('refugiosList');
+
+    if (refugios.length === 0) {
+        container.innerHTML = '<p>No hay refugios disponibles</p>';
+        return;
+    }
+
+    container.innerHTML = refugios.map(refugio => `
+        <div class="data-item">
+            <strong>${refugio.name || refugio.id}</strong>
+            <p>Capacidad: ${refugio.capacity || 'N/A'} perros</p>
+        </div>
+    `).join('');
+}
+
+function displayPerros(perros) {
+    const container = document.getElementById('perrosList');
+
+    if (perros.length === 0) {
+        container.innerHTML = '<p>No hay perros disponibles</p>';
+        return;
+    }
+
+    container.innerHTML = perros.map(perro => `
+        <div class="data-item">
+            <strong>${perro.name}</strong>
+            <p>
+                Tamaño: ${perro.size} |
+                Peso: ${perro.weight}kg |
+                Edad: ${perro.age} años |
+                Prioridad: ${perro.priority || 'N/A'}
+            </p>
+            <p>Energía: ${perro.energy} | Amigable con niños: ${perro.goodWithKids ? 'Sí' : 'No'}</p>
+        </div>
+    `).join('');
+}
+
+function displayAdoptantes(adoptantes) {
+    const container = document.getElementById('adoptantesList');
+
+    if (adoptantes.length === 0) {
+        container.innerHTML = '<p>No hay adoptantes registrados</p>';
+        return;
+    }
+
+    container.innerHTML = adoptantes.map(adoptante => `
+        <div class="data-item">
+            <strong>${adoptante.name}</strong>
+            <p>
+                Presupuesto: $${adoptante.budget} |
+                Max. perros: ${adoptante.maxDogs}
+            </p>
+            <p>
+                Patio: ${adoptante.hasYard ? 'Sí' : 'No'} |
+                Niños: ${adoptante.hasKids ? 'Sí' : 'No'}
+            </p>
+        </div>
+    `).join('');
+}
+
+// ==================== Graph Algorithms ====================
+
+async function executeBFS() {
+    const from = document.getElementById('bfsFrom').value;
+    const to = document.getElementById('bfsTo').value;
+    const resultBox = document.getElementById('bfsResult');
+
+    if (from === to) {
+        showResult(resultBox, 'error', 'Error', 'El origen y destino deben ser diferentes');
+        return;
+    }
+
+    try {
+        showLoading();
+        const result = await fetchAPI(`/graph/reachable?from=${from}&to=${to}&method=bfs`);
+        hideLoading();
+
+        displayPathResult(resultBox, result, 'BFS');
+    } catch (error) {
+        hideLoading();
+        showResult(resultBox, 'error', 'Error', error.message);
+    }
+}
+
+async function executeDFS() {
+    const from = document.getElementById('bfsFrom').value;
+    const to = document.getElementById('bfsTo').value;
+    const resultBox = document.getElementById('bfsResult');
+
+    if (from === to) {
+        showResult(resultBox, 'error', 'Error', 'El origen y destino deben ser diferentes');
+        return;
+    }
+
+    try {
+        showLoading();
+        const result = await fetchAPI(`/graph/reachable?from=${from}&to=${to}&method=dfs`);
+        hideLoading();
+
+        displayPathResult(resultBox, result, 'DFS');
+    } catch (error) {
+        hideLoading();
+        showResult(resultBox, 'error', 'Error', error.message);
+    }
+}
+
+async function executeDijkstra() {
+    const from = document.getElementById('dijkstraFrom').value;
+    const to = document.getElementById('dijkstraTo').value;
+    const resultBox = document.getElementById('dijkstraResult');
+
+    if (from === to) {
+        showResult(resultBox, 'error', 'Error', 'El origen y destino deben ser diferentes');
+        return;
+    }
+
+    try {
+        showLoading();
+        const result = await fetchAPI(`/routes/shortest?from=${from}&to=${to}`);
+        hideLoading();
+
+        let html = '<h4>✅ Camino Más Corto Encontrado (Dijkstra)</h4>';
+        html += `<div class="result-item">
+            <strong>Camino:</strong> ${result.path.join(' → ')}<br>
+            <strong>Distancia Total:</strong> ${result.totalWeight} km<br>
+            <strong>Número de Saltos:</strong> ${result.steps}
+        </div>`;
+
+        showResult(resultBox, 'success', '', html);
+    } catch (error) {
+        hideLoading();
+        showResult(resultBox, 'error', 'Error', error.message);
+    }
+}
+
+async function executeTSP() {
+    const checkboxes = document.querySelectorAll('input[name="tspNode"]:checked');
+    const nodes = Array.from(checkboxes).map(cb => cb.value);
+    const resultBox = document.getElementById('tspResult');
+
+    if (nodes.length < 2) {
+        showResult(resultBox, 'error', 'Error', 'Debes seleccionar al menos 2 refugios');
+        return;
+    }
+
+    try {
+        showLoading();
+        const result = await fetchAPI(`/routes/tsp/bnb?nodes=${nodes.join(',')}`);
+        hideLoading();
+
+        let html = '<h4>✅ Ruta Óptima TSP Encontrada (Branch & Bound)</h4>';
+        html += `<div class="result-item">
+            <strong>Ruta Óptima:</strong> ${result.route ? result.route.join(' → ') : 'N/A'}<br>
+            <strong>Distancia Total:</strong> ${result.totalDistanceKm || 'N/A'} km<br>
+            <strong>Número de Refugios:</strong> ${result.route ? result.route.length : 0}<br>
+            <strong>Nodos Explorados:</strong> ${result.nodesExplored || 'N/A'}
+        </div>`;
+
+        showResult(resultBox, 'success', '', html);
+    } catch (error) {
+        hideLoading();
+        showResult(resultBox, 'error', 'Error', error.message);
+    }
+}
+
+function displayPathResult(resultBox, result, algorithm) {
+    if (result.exists) {
+        let html = `<h4>✅ Camino Encontrado (${algorithm})</h4>`;
+        html += `<div class="result-item">
+            <strong>Camino:</strong> ${result.path.join(' → ')}<br>
+            <strong>Número de Saltos:</strong> ${result.steps}
+        </div>`;
+        showResult(resultBox, 'success', '', html);
+    } else {
+        const from = result.path && result.path.length > 0 ? result.path[0] : 'origen';
+        const to = 'destino';
+        showResult(resultBox, 'error', 'No Alcanzable', `No existe un camino accesible con ${algorithm}`);
+    }
+}
+
+// ==================== Network Algorithms ====================
+
+async function executeMST(algorithm) {
+    const resultBox = document.getElementById('mstResult');
+
+    try {
+        showLoading();
+        const result = await fetchAPI(`/network/mst?algorithm=${algorithm}`);
+        hideLoading();
+
+        const algorithmName = algorithm === 'kruskal' ? 'Kruskal' : 'Prim';
+
+        let html = `<h4>✅ MST Calculado (${algorithmName})</h4>`;
+        html += `<div class="result-item">
+            <strong>Distancia Total Mínima:</strong> ${result.totalWeight} km<br>
+            <strong>Número de Aristas:</strong> ${result.edges.length}
+        </div>`;
+
+        html += '<h4>Aristas del MST:</h4>';
+        result.edges.forEach(edge => {
+            html += `<div class="result-item">
+                ${edge.from} ↔ ${edge.to}: <strong>${edge.weight} km</strong>
+            </div>`;
+        });
+
+        showResult(resultBox, 'success', '', html);
+    } catch (error) {
+        hideLoading();
+        showResult(resultBox, 'error', 'Error', error.message);
+    }
+}
+
+// ==================== Matching Algorithms ====================
+
+async function executeGreedy() {
+    const adopterId = document.getElementById('greedyAdopter').value;
+    const resultBox = document.getElementById('greedyResult');
+
+    try {
+        showLoading();
+        const result = await fetchAPI(`/adoptions/greedy?adopterId=${adopterId}`);
+        hideLoading();
+
+        let html = '<h4>✅ Selección Voraz Completada</h4>';
+        html += `<div class="result-item">
+            <strong>Adoptante:</strong> ${result.adopterName || adopterId}<br>
+            <strong>Perros Seleccionados:</strong> ${result.assignedDogs ? result.assignedDogs.length : 0}<br>
+            <strong>Score Total:</strong> ${result.totalScore ? result.totalScore.toFixed(2) : 'N/A'}<br>
+            <strong>Costo Total:</strong> $${result.totalCost ? result.totalCost.toFixed(2) : 'N/A'}
+        </div>`;
+
+        if (result.assignedDogs && result.assignedDogs.length > 0) {
+            html += '<h4>Perros Asignados:</h4>';
+            result.assignedDogs.forEach(dog => {
+                html += `<div class="result-item">
+                    <strong>${dog.dogName || dog.dogId}</strong><br>
+                    Costo: $${dog.cost ? dog.cost.toFixed(2) : 'N/A'}
+                </div>`;
+            });
+        }
+
+        showResult(resultBox, 'success', '', html);
+    } catch (error) {
+        hideLoading();
+        showResult(resultBox, 'error', 'Error', error.message);
+    }
+}
+
+async function executeBacktracking() {
+    const resultBox = document.getElementById('backtrackingResult');
+
+    try {
+        showLoading();
+        const result = await fetchAPI('/adoptions/constraints/backtracking');
+        hideLoading();
+
+        let html = '<h4>✅ Asignación por Backtracking Completada</h4>';
+        html += `<div class="result-item">
+            <strong>Score Total:</strong> ${result.totalScore ? result.totalScore.toFixed(2) : 'N/A'}
+        </div>`;
+
+        if (result.assignments) {
+            const assignmentsList = Object.values(result.assignments);
+
+            if (assignmentsList.length > 0) {
+                html += `<div class="result-item">
+                    <strong>Total de Asignaciones:</strong> ${assignmentsList.length}
+                </div>`;
+
+                assignmentsList.forEach(assignment => {
+                    html += `<div class="result-item">
+                        <strong>Adoptante:</strong> ${assignment.adopterName}<br>
+                        <strong>Perros Asignados:</strong> ${assignment.assignedDogs.map(d => d.dogName).join(', ')}<br>
+                        <strong>Cantidad:</strong> ${assignment.assignedDogs.length} perro(s)
+                    </div>`;
+                });
+            } else {
+                html += '<p>No se encontraron asignaciones válidas</p>';
+            }
+        } else {
+            html += '<p>No se encontraron asignaciones válidas</p>';
+        }
+
+        showResult(resultBox, 'success', '', html);
+    } catch (error) {
+        hideLoading();
+        showResult(resultBox, 'error', 'Error', error.message);
+    }
+}
+
+// ==================== Sorting Algorithms ====================
+
+async function executeSort() {
+    const criteria = document.getElementById('sortCriteria').value;
+    const algorithm = document.getElementById('sortAlgorithm').value;
+    const resultBox = document.getElementById('sortResult');
+
+    try {
+        showLoading();
+        const result = await fetchAPI(`/dogs/sort?criteria=${criteria}&algorithm=${algorithm}`);
+        hideLoading();
+
+        const algorithmName = algorithm === 'mergesort' ? 'MergeSort' : 'QuickSort';
+        const dogs = result.dogs || [];
+
+        let html = `<h4>✅ Perros Ordenados (${algorithmName})</h4>`;
+        html += `<div class="result-item">
+            <strong>Criterio:</strong> ${result.criteria || criteria}<br>
+            <strong>Algoritmo:</strong> ${result.algorithm || algorithmName}<br>
+            <strong>Total de Perros:</strong> ${dogs.length}
+        </div>`;
+
+        if (dogs.length > 0) {
+            html += '<h4>Lista Ordenada:</h4>';
+            dogs.forEach((perro, index) => {
+                let value;
+                if (criteria === 'priority') value = perro.priority;
+                else if (criteria === 'age') value = perro.age;
+                else if (criteria === 'weight') value = perro.weight;
+
+                html += `<div class="result-item">
+                    <strong>${index + 1}. ${perro.name}</strong><br>
+                    ${criteria.charAt(0).toUpperCase() + criteria.slice(1)}: ${value} |
+                    Tamaño: ${perro.size} |
+                    Peso: ${perro.weight}kg
+                </div>`;
+            });
+        } else {
+            html += '<p>No hay perros para ordenar</p>';
+        }
+
+        showResult(resultBox, 'success', '', html);
+    } catch (error) {
+        hideLoading();
+        showResult(resultBox, 'error', 'Error', error.message);
+    }
+}
+
+// ==================== Transport Optimization ====================
+
+async function executeKnapsack() {
+    const capacity = document.getElementById('vehicleCapacity').value;
+    const resultBox = document.getElementById('knapsackResult');
+
+    if (!capacity || capacity < 1) {
+        showResult(resultBox, 'error', 'Error', 'Debes ingresar una capacidad válida');
+        return;
+    }
+
+    try {
+        showLoading();
+        const result = await fetchAPI(`/transport/optimal-dp?capacityKg=${capacity}`);
+        hideLoading();
+
+        let html = '<h4>✅ Transporte Optimizado (Knapsack DP)</h4>';
+        html += `<div class="result-item">
+            <strong>Capacidad del Vehículo:</strong> ${result.vehicleCapacityKg || capacity} kg<br>
+            <strong>Peso Total Usado:</strong> ${result.totalWeightKg || 0} kg<br>
+            <strong>Prioridad Total Maximizada:</strong> ${result.totalPriority || 0}<br>
+            <strong>Perros Transportados:</strong> ${result.selectedDogs ? result.selectedDogs.length : 0}
+        </div>`;
+
+        if (result.selectedDogs && result.selectedDogs.length > 0) {
+            html += '<h4>Perros Seleccionados:</h4>';
+            result.selectedDogs.forEach(dog => {
+                html += `<div class="result-item">
+                    <strong>${dog.name}</strong><br>
+                    Peso: ${dog.weightKg}kg |
+                    Prioridad: ${dog.priority} |
+                    Relación P/W: ${(dog.priority / dog.weightKg).toFixed(2)}
+                </div>`;
+            });
+        }
+
+        showResult(resultBox, 'success', '', html);
+    } catch (error) {
+        hideLoading();
+        showResult(resultBox, 'error', 'Error', error.message);
+    }
+}
+
+// ==================== Utility Functions ====================
+
+async function fetchAPI(endpoint) {
+    const response = await fetch(`${API_BASE_URL}${endpoint}`);
+
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Error ${response.status}: ${errorText || response.statusText}`);
+    }
+
+    return await response.json();
+}
+
+function showLoading() {
+    document.getElementById('loadingOverlay').classList.add('active');
+}
+
+function hideLoading() {
+    document.getElementById('loadingOverlay').classList.remove('active');
+}
+
+function showResult(element, type, title, content) {
+    element.className = `result-box visible ${type}`;
+
+    let html = '';
+    if (title) {
+        html += `<h4>${title}</h4>`;
+    }
+
+    if (typeof content === 'string') {
+        html += content;
+    } else {
+        html += `<pre>${JSON.stringify(content, null, 2)}</pre>`;
+    }
+
+    element.innerHTML = html;
+}
+
+function showError(message) {
+    alert(message);
+}
+
+// ==================== Dynamic Selector Population ====================
+
+async function populateSelectors() {
+    try {
+        // Load shelters and adopters
+        const [shelters, adopters] = await Promise.all([
+            fetchAPI('/shelters'),
+            fetchAPI('/adopters')
+        ]);
+
+        // Populate shelter selectors
+        populateShelterSelectors(shelters);
+
+        // Populate TSP checkboxes
+        populateTSPCheckboxes(shelters);
+
+        // Populate adopter selector
+        populateAdopterSelector(adopters);
+    } catch (error) {
+        console.error('Error populating selectors:', error);
+        // Keep static options as fallback
+    }
+}
+
+function populateShelterSelectors(shelters) {
+    if (!shelters || shelters.length === 0) return;
+
+    const shelterIds = ['bfsFrom', 'bfsTo', 'dijkstraFrom', 'dijkstraTo'];
+
+    shelterIds.forEach(selectId => {
+        const select = document.getElementById(selectId);
+        if (!select) return;
+
+        const currentValue = select.value;
+        select.innerHTML = '';
+
+        shelters.forEach((shelter, index) => {
+            const option = document.createElement('option');
+            option.value = shelter.id;
+            option.textContent = shelter.id === 'H'
+                ? `Hub Central (${shelter.id})`
+                : `${shelter.name || 'Refugio ' + shelter.id}`;
+
+            // Set default selections
+            if ((selectId.includes('To') && index === Math.min(shelters.length - 1, 12)) ||
+                (selectId.includes('From') && index === 0)) {
+                option.selected = true;
+            }
+
+            select.appendChild(option);
+        });
+
+        // Restore previous value if it exists
+        if (currentValue && Array.from(select.options).some(opt => opt.value === currentValue)) {
+            select.value = currentValue;
+        }
+    });
+}
+
+function populateTSPCheckboxes(shelters) {
+    if (!shelters || shelters.length === 0) return;
+
+    const container = document.querySelector('.checkbox-group');
+    if (!container) return;
+
+    container.innerHTML = '';
+
+    shelters.forEach((shelter, index) => {
+        const label = document.createElement('label');
+        const checkbox = document.createElement('input');
+        checkbox.type = 'checkbox';
+        checkbox.name = 'tspNode';
+        checkbox.value = shelter.id;
+
+        // Check first 4 by default (A, B, C, H typically)
+        if (index < 4) {
+            checkbox.checked = true;
+        }
+
+        const text = document.createTextNode(
+            shelter.id === 'H'
+                ? ` Hub Central (${shelter.id})`
+                : ` ${shelter.name || 'Refugio ' + shelter.id}`
+        );
+
+        label.appendChild(checkbox);
+        label.appendChild(text);
+        container.appendChild(label);
+    });
+}
+
+function populateAdopterSelector(adopters) {
+    if (!adopters || adopters.length === 0) return;
+
+    const select = document.getElementById('greedyAdopter');
+    if (!select) return;
+
+    const currentValue = select.value;
+    select.innerHTML = '';
+
+    adopters.forEach(adopter => {
+        const option = document.createElement('option');
+        option.value = adopter.id;
+
+        const yard = adopter.hasYard ? '✓' : '✗';
+        const kids = adopter.hasKids ? '✓' : '✗';
+        const budget = adopter.budget ? `$${adopter.budget.toLocaleString('es-AR')}` : 'N/A';
+        const maxDogs = adopter.maxDogs || 1;
+
+        option.textContent = `${adopter.id} - ${adopter.name} (${budget}, Patio ${yard}, Niños ${kids}, Max: ${maxDogs})`;
+
+        select.appendChild(option);
+    });
+
+    // Restore previous value if it exists
+    if (currentValue && Array.from(select.options).some(opt => opt.value === currentValue)) {
+        select.value = currentValue;
+    }
+}
+
+// ==================== TSP Selection Helpers ====================
+
+function selectAllTSP() {
+    const checkboxes = document.querySelectorAll('input[name="tspNode"]');
+    checkboxes.forEach(cb => cb.checked = true);
+}
+
+function clearAllTSP() {
+    const checkboxes = document.querySelectorAll('input[name="tspNode"]');
+    checkboxes.forEach(cb => cb.checked = false);
+}
+
+function selectDefaultTSP() {
+    const checkboxes = document.querySelectorAll('input[name="tspNode"]');
+    checkboxes.forEach((cb, index) => {
+        cb.checked = index < 4; // Select first 4
+    });
+}
+
+// ==================== Helper Functions ====================
+
+function formatDistance(distance) {
+    return `${distance.toFixed(2)} km`;
+}
+
+function formatCurrency(amount) {
+    return `$${amount.toLocaleString('es-AR')}`;
+}
+
+// ==================== Graph Visualization ====================
+
+let cytoscapeInstance = null;
+
+async function showGraphVisualization() {
+    const container = document.getElementById('graphContainer');
+    const canvas = document.getElementById('graphCanvas');
+
+    // Toggle visibility
+    if (container.style.display === 'none') {
+        container.style.display = 'block';
+
+        // Fetch graph data
+        try {
+            const data = await fetchAPI('/network/graph');
+
+            if (!data.nodes || !data.edges) {
+                canvas.innerHTML = '<div style="padding: 20px; text-align: center; color: #e74c3c;"><h3>❌ Error</h3><p>No se pudieron cargar los datos del grafo</p></div>';
+                return;
+            }
+
+            // Prepare nodes for Cytoscape
+            const cytoscapeNodes = data.nodes.map(nodeId => ({
+                data: {
+                    id: nodeId,
+                    label: nodeId
+                }
+            }));
+
+            // Prepare edges for Cytoscape (avoid duplicates for undirected graph)
+            const edgeSet = new Set();
+            const cytoscapeEdges = [];
+
+            data.edges.forEach(edge => {
+                const edgeKey = [edge.from, edge.to].sort().join('-');
+                if (!edgeSet.has(edgeKey)) {
+                    edgeSet.add(edgeKey);
+                    cytoscapeEdges.push({
+                        data: {
+                            source: edge.from,
+                            target: edge.to,
+                            weight: edge.weight,
+                            label: `${edge.weight.toFixed(1)} km`
+                        }
+                    });
+                }
+            });
+
+            // Destroy previous instance if exists
+            if (cytoscapeInstance) {
+                cytoscapeInstance.destroy();
+            }
+
+            // Initialize Cytoscape
+            cytoscapeInstance = cytoscape({
+                container: canvas,
+
+                elements: {
+                    nodes: cytoscapeNodes,
+                    edges: cytoscapeEdges
+                },
+
+                style: [
+                    {
+                        selector: 'node',
+                        style: {
+                            'background-color': '#3498db',
+                            'label': 'data(label)',
+                            'color': '#2c3e50',
+                            'text-valign': 'center',
+                            'text-halign': 'center',
+                            'font-size': '14px',
+                            'font-weight': 'bold',
+                            'width': 50,
+                            'height': 50,
+                            'border-width': 3,
+                            'border-color': '#2980b9',
+                            'text-outline-width': 2,
+                            'text-outline-color': '#ffffff'
+                        }
+                    },
+                    {
+                        selector: 'edge',
+                        style: {
+                            'width': 3,
+                            'line-color': '#95a5a6',
+                            'target-arrow-color': '#95a5a6',
+                            'curve-style': 'bezier',
+                            'label': 'data(label)',
+                            'font-size': '11px',
+                            'color': '#34495e',
+                            'text-background-color': '#ffffff',
+                            'text-background-opacity': 0.8,
+                            'text-background-padding': '3px',
+                            'text-border-width': 1,
+                            'text-border-color': '#bdc3c7',
+                            'text-border-opacity': 0.5
+                        }
+                    },
+                    {
+                        selector: 'node:selected',
+                        style: {
+                            'background-color': '#e74c3c',
+                            'border-color': '#c0392b'
+                        }
+                    },
+                    {
+                        selector: 'edge:selected',
+                        style: {
+                            'line-color': '#e74c3c',
+                            'width': 5
+                        }
+                    }
+                ],
+
+                layout: {
+                    name: 'cose',
+                    idealEdgeLength: 100,
+                    nodeOverlap: 20,
+                    refresh: 20,
+                    fit: true,
+                    padding: 30,
+                    randomize: false,
+                    componentSpacing: 100,
+                    nodeRepulsion: 400000,
+                    edgeElasticity: 100,
+                    nestingFactor: 5,
+                    gravity: 80,
+                    numIter: 1000,
+                    initialTemp: 200,
+                    coolingFactor: 0.95,
+                    minTemp: 1.0
+                },
+
+                wheelSensitivity: 0.2
+            });
+
+            // Add interactivity
+            cytoscapeInstance.on('tap', 'node', function(evt) {
+                const node = evt.target;
+                console.log('Clicked node:', node.id());
+            });
+
+            console.log(`Grafo renderizado: ${data.nodes.length} nodos, ${cytoscapeEdges.length} aristas`);
+
+        } catch (error) {
+            console.error('Error loading graph:', error);
+            canvas.innerHTML = `<div style="padding: 20px; text-align: center; color: #e74c3c;">
+                <h3>❌ Error al cargar el grafo</h3>
+                <p>${error.message}</p>
+                <p style="font-size: 0.9em; color: #7f8c8d;">Verifica que el servidor esté corriendo y reiniciado.</p>
+            </div>`;
+        }
+    } else {
+        container.style.display = 'none';
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/frontend/index.html b/jdk_21_maven/cs/rest/adoptme/frontend/index.html
new file mode 100644
index 000000000..5909b781f
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/frontend/index.html
@@ -0,0 +1,349 @@
+<!DOCTYPE html>
+<html lang="es">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AdoptMe - Sistema de Adopción de Perros</title>
+    <link rel="stylesheet" href="styles.css">
+    <!-- Cytoscape.js para visualización de grafos -->
+    <script src="https://unpkg.com/cytoscape@3.28.1/dist/cytoscape.min.js"></script>
+</head>
+<body>
+    <div class="app-container">
+        <!-- Header -->
+        <header class="header">
+            <div class="header-content">
+                <h1>🐕 AdoptMe</h1>
+                <p class="subtitle">Sistema Inteligente de Adopción de Perros</p>
+                <div class="connection-status" id="connectionStatus">
+                    <span class="status-indicator"></span>
+                    <span class="status-text">Conectando...</span>
+                </div>
+            </div>
+        </header>
+
+        <!-- Navigation Tabs -->
+        <nav class="nav-tabs">
+            <button class="tab-button active" data-tab="dashboard">Dashboard</button>
+            <button class="tab-button" data-tab="graph">Rutas & Grafos</button>
+            <button class="tab-button" data-tab="network">Redes & MST</button>
+            <button class="tab-button" data-tab="matching">Matching</button>
+            <button class="tab-button" data-tab="sorting">Ordenamiento</button>
+            <button class="tab-button" data-tab="transport">Transporte</button>
+        </nav>
+
+        <!-- Main Content -->
+        <main class="main-content">
+            <!-- Dashboard Tab -->
+            <section id="dashboard" class="tab-content active">
+                <div class="welcome-section">
+                    <h2>Bienvenido a AdoptMe</h2>
+                    <p>Sistema de gestión y optimización de adopciones de perros utilizando algoritmos avanzados.</p>
+                </div>
+
+                <div class="stats-grid">
+                    <div class="stat-card">
+                        <h3>Refugios</h3>
+                        <p class="stat-number" id="statsRefugios">-</p>
+                        <p class="stat-label">Total de refugios</p>
+                    </div>
+                    <div class="stat-card">
+                        <h3>Perros</h3>
+                        <p class="stat-number" id="statsPerros">-</p>
+                        <p class="stat-label">Disponibles para adopción</p>
+                    </div>
+                    <div class="stat-card">
+                        <h3>Adoptantes</h3>
+                        <p class="stat-number" id="statsAdoptantes">-</p>
+                        <p class="stat-label">Personas registradas</p>
+                    </div>
+                </div>
+
+                <div class="data-display">
+                    <div class="data-section">
+                        <h3>Refugios Disponibles</h3>
+                        <div id="refugiosList" class="data-list"></div>
+                    </div>
+                    <div class="data-section">
+                        <h3>Perros Disponibles</h3>
+                        <div id="perrosList" class="data-list"></div>
+                    </div>
+                    <div class="data-section">
+                        <h3>Adoptantes Registrados</h3>
+                        <div id="adoptantesList" class="data-list"></div>
+                    </div>
+                </div>
+            </section>
+
+            <!-- Graph Algorithms Tab -->
+            <section id="graph" class="tab-content">
+                <h2>Algoritmos de Rutas y Grafos</h2>
+
+                <!-- BFS/DFS -->
+                <div class="algorithm-section">
+                    <h3>🔍 BFS / DFS - Búsqueda de Caminos</h3>
+                    <p>Encuentra si existe un camino entre dos refugios usando BFS (anchura) o DFS (profundidad).</p>
+                    <div class="input-group">
+                        <label>Refugio Origen:</label>
+                        <select id="bfsFrom">
+                            <option value="A">Refugio A</option>
+                            <option value="B">Refugio B</option>
+                            <option value="C">Refugio C</option>
+                            <option value="D">Refugio D</option>
+                            <option value="E">Refugio E</option>
+                            <option value="F">Refugio F</option>
+                            <option value="G">Refugio G</option>
+                            <option value="H">Hub Central (H)</option>
+                            <option value="I">Refugio I</option>
+                            <option value="J">Refugio J</option>
+                            <option value="K">Refugio K</option>
+                            <option value="L">Refugio L</option>
+                            <option value="M">Refugio M</option>
+                            <option value="N">Refugio N</option>
+                            <option value="O">Refugio O</option>
+                        </select>
+                    </div>
+                    <div class="input-group">
+                        <label>Refugio Destino:</label>
+                        <select id="bfsTo">
+                            <option value="A">Refugio A</option>
+                            <option value="B">Refugio B</option>
+                            <option value="C">Refugio C</option>
+                            <option value="D">Refugio D</option>
+                            <option value="E">Refugio E</option>
+                            <option value="F">Refugio F</option>
+                            <option value="G">Refugio G</option>
+                            <option value="H">Hub Central (H)</option>
+                            <option value="I">Refugio I</option>
+                            <option value="J">Refugio J</option>
+                            <option value="K">Refugio K</option>
+                            <option value="L">Refugio L</option>
+                            <option value="M" selected>Refugio M</option>
+                            <option value="N">Refugio N</option>
+                            <option value="O">Refugio O</option>
+                        </select>
+                    </div>
+                    <div class="button-group">
+                        <button class="btn btn-primary" onclick="executeBFS()">Ejecutar BFS</button>
+                        <button class="btn btn-primary" onclick="executeDFS()">Ejecutar DFS</button>
+                    </div>
+                    <div id="bfsResult" class="result-box"></div>
+                </div>
+
+                <!-- Dijkstra -->
+                <div class="algorithm-section">
+                    <h3>📍 Dijkstra - Camino Más Corto</h3>
+                    <p>Calcula el camino más corto entre dos refugios considerando las distancias.</p>
+                    <div class="input-group">
+                        <label>Refugio Origen:</label>
+                        <select id="dijkstraFrom">
+                            <option value="A" selected>Refugio A</option>
+                            <option value="B">Refugio B</option>
+                            <option value="C">Refugio C</option>
+                            <option value="D">Refugio D</option>
+                            <option value="E">Refugio E</option>
+                            <option value="F">Refugio F</option>
+                            <option value="G">Refugio G</option>
+                            <option value="H">Hub Central (H)</option>
+                            <option value="I">Refugio I</option>
+                            <option value="J">Refugio J</option>
+                            <option value="K">Refugio K</option>
+                            <option value="L">Refugio L</option>
+                            <option value="M">Refugio M</option>
+                            <option value="N">Refugio N</option>
+                            <option value="O">Refugio O</option>
+                        </select>
+                    </div>
+                    <div class="input-group">
+                        <label>Refugio Destino:</label>
+                        <select id="dijkstraTo">
+                            <option value="A">Refugio A</option>
+                            <option value="B">Refugio B</option>
+                            <option value="C">Refugio C</option>
+                            <option value="D">Refugio D</option>
+                            <option value="E">Refugio E</option>
+                            <option value="F">Refugio F</option>
+                            <option value="G">Refugio G</option>
+                            <option value="H">Hub Central (H)</option>
+                            <option value="I">Refugio I</option>
+                            <option value="J">Refugio J</option>
+                            <option value="K">Refugio K</option>
+                            <option value="L">Refugio L</option>
+                            <option value="M" selected>Refugio M</option>
+                            <option value="N">Refugio N</option>
+                            <option value="O">Refugio O</option>
+                        </select>
+                    </div>
+                    <button class="btn btn-primary" onclick="executeDijkstra()">Calcular Ruta Óptima</button>
+                    <div id="dijkstraResult" class="result-box"></div>
+                </div>
+
+                <!-- TSP -->
+                <div class="algorithm-section">
+                    <h3>🗺️ TSP Branch & Bound - Ruta Óptima</h3>
+                    <p>Encuentra la ruta más corta que visita todos los refugios seleccionados (Problema del Viajante). Nota: Seleccionar muchos refugios (>8) puede tomar tiempo.</p>
+                    <div class="input-group">
+                        <label>Selecciona Refugios a Visitar: <span class="helper-text">(Usa Ctrl+Click para múltiples)</span></label>
+                        <div class="button-group" style="margin-bottom: var(--spacing-sm);">
+                            <button class="btn btn-secondary" onclick="selectAllTSP()">Seleccionar Todos</button>
+                            <button class="btn btn-secondary" onclick="clearAllTSP()">Limpiar Todo</button>
+                            <button class="btn btn-secondary" onclick="selectDefaultTSP()">Selección por Defecto</button>
+                        </div>
+                        <div class="checkbox-group">
+                            <label><input type="checkbox" name="tspNode" value="A" checked> Refugio A</label>
+                            <label><input type="checkbox" name="tspNode" value="B" checked> Refugio B</label>
+                            <label><input type="checkbox" name="tspNode" value="C" checked> Refugio C</label>
+                            <label><input type="checkbox" name="tspNode" value="D"> Refugio D</label>
+                            <label><input type="checkbox" name="tspNode" value="E"> Refugio E</label>
+                            <label><input type="checkbox" name="tspNode" value="F"> Refugio F</label>
+                            <label><input type="checkbox" name="tspNode" value="G"> Refugio G</label>
+                            <label><input type="checkbox" name="tspNode" value="H" checked> Hub Central (H)</label>
+                            <label><input type="checkbox" name="tspNode" value="I"> Refugio I</label>
+                            <label><input type="checkbox" name="tspNode" value="J"> Refugio J</label>
+                            <label><input type="checkbox" name="tspNode" value="K"> Refugio K</label>
+                            <label><input type="checkbox" name="tspNode" value="L"> Refugio L</label>
+                            <label><input type="checkbox" name="tspNode" value="M"> Refugio M</label>
+                            <label><input type="checkbox" name="tspNode" value="N"> Refugio N</label>
+                            <label><input type="checkbox" name="tspNode" value="O"> Refugio O</label>
+                        </div>
+                    </div>
+                    <button class="btn btn-primary" onclick="executeTSP()">Calcular Ruta TSP</button>
+                    <div id="tspResult" class="result-box"></div>
+                </div>
+            </section>
+
+            <!-- Network Algorithms Tab -->
+            <section id="network" class="tab-content">
+                <h2>Algoritmos de Redes y MST</h2>
+
+                <!-- Graph Visualization -->
+                <div class="algorithm-section">
+                    <h3>🗺️ Visualización del Grafo de Shelters</h3>
+                    <p>Visualiza la red completa de conexiones entre refugios con sus distancias.</p>
+                    <button class="btn btn-primary" onclick="showGraphVisualization()">Mostrar Grafo de Conexiones</button>
+                    <div id="graphContainer" style="display: none;">
+                        <div id="graphCanvas" style="width: 100%; height: 600px; border: 2px solid #3498db; border-radius: 8px; margin-top: 20px; background: #f8f9fa;"></div>
+                        <div class="graph-legend" style="margin-top: 15px; padding: 15px; background: #e8f4f8; border-radius: 8px;">
+                            <h4 style="margin: 0 0 10px 0;">📋 Leyenda</h4>
+                            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 10px;">
+                                <div><span style="display: inline-block; width: 16px; height: 16px; background: #3498db; border-radius: 50%; vertical-align: middle;"></span> Nodo (Shelter)</div>
+                                <div><span style="display: inline-block; width: 30px; height: 3px; background: #95a5a6; vertical-align: middle;"></span> Conexión NEAR</div>
+                                <div>💡 <strong>Tip:</strong> Arrastra los nodos para reorganizar</div>
+                                <div>🔍 <strong>Peso:</strong> Distancia en kilómetros</div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Kruskal/Prim -->
+                <div class="algorithm-section">
+                    <h3>🌳 MST - Árbol de Expansión Mínima</h3>
+                    <p>Calcula el árbol de expansión mínima para conectar todos los refugios con la menor distancia total.</p>
+                    <div class="button-group">
+                        <button class="btn btn-primary" onclick="executeMST('kruskal')">Algoritmo de Kruskal</button>
+                        <button class="btn btn-primary" onclick="executeMST('prim')">Algoritmo de Prim</button>
+                    </div>
+                    <div id="mstResult" class="result-box"></div>
+                </div>
+            </section>
+
+            <!-- Matching Tab -->
+            <section id="matching" class="tab-content">
+                <h2>Algoritmos de Matching</h2>
+
+                <!-- Greedy -->
+                <div class="algorithm-section">
+                    <h3>🎯 Greedy - Selección Voraz</h3>
+                    <p>Selecciona los mejores perros para un adoptante usando un algoritmo voraz basado en compatibilidad.</p>
+                    <div class="input-group">
+                        <label>Selecciona Adoptante:</label>
+                        <select id="greedyAdopter">
+                            <option value="P1">P1 - Camila ($25,000, Patio ✓, Niños ✓, Max: 2)</option>
+                            <option value="P2">P2 - Lucas ($18,000, Patio ✗, Niños ✗, Max: 1)</option>
+                            <option value="P3">P3 - Daniela ($30,000, Patio ✓, Niños ✗, Max: 3)</option>
+                            <option value="P4">P4 - Martin ($22,000, Patio ✓, Niños ✓, Max: 2)</option>
+                            <option value="P5">P5 - Sofia ($15,000, Patio ✗, Niños ✗, Max: 1)</option>
+                            <option value="P6">P6 - Roberto ($35,000, Patio ✓, Niños ✗, Max: 4)</option>
+                            <option value="P7">P7 - Ana ($20,000, Patio ✓, Niños ✓, Max: 1)</option>
+                            <option value="P8">P8 - Diego ($28,000, Patio ✗, Niños ✗, Max: 2)</option>
+                            <option value="P9">P9 - Julia ($40,000, Patio ✓, Niños ✓, Max: 3)</option>
+                            <option value="P10">P10 - Carlos ($12,000, Patio ✗, Niños ✗, Max: 1)</option>
+                            <option value="P11">P11 - Valeria ($32,000, Patio ✓, Niños ✗, Max: 5)</option>
+                            <option value="P12">P12 - Pedro ($24,000, Patio ✓, Niños ✓, Max: 2)</option>
+                            <option value="P13">P13 - Laura ($16,000, Patio ✗, Niños ✓, Max: 1)</option>
+                            <option value="P14">P14 - Andres ($45,000, Patio ✓, Niños ✗, Max: 4)</option>
+                            <option value="P15">P15 - Monica ($27,000, Patio ✓, Niños ✓, Max: 3)</option>
+                        </select>
+                    </div>
+                    <button class="btn btn-primary" onclick="executeGreedy()">Ejecutar Greedy</button>
+                    <div id="greedyResult" class="result-box"></div>
+                </div>
+
+                <!-- Backtracking -->
+                <div class="algorithm-section">
+                    <h3>🔄 Backtracking - Asignación con Restricciones</h3>
+                    <p>Asigna múltiples perros a múltiples adoptantes respetando todas las restricciones (presupuesto, capacidad, compatibilidad).</p>
+                    <button class="btn btn-primary" onclick="executeBacktracking()">Ejecutar Backtracking</button>
+                    <div id="backtrackingResult" class="result-box"></div>
+                </div>
+            </section>
+
+            <!-- Sorting Tab -->
+            <section id="sorting" class="tab-content">
+                <h2>Algoritmos de Ordenamiento</h2>
+
+                <div class="algorithm-section">
+                    <h3>📊 Ordenar Perros</h3>
+                    <p>Ordena la lista de perros según diferentes criterios usando MergeSort o QuickSort.</p>
+                    <div class="input-group">
+                        <label>Criterio de Ordenamiento:</label>
+                        <select id="sortCriteria">
+                            <option value="priority">Prioridad</option>
+                            <option value="age">Edad</option>
+                            <option value="weight">Peso</option>
+                        </select>
+                    </div>
+                    <div class="input-group">
+                        <label>Algoritmo:</label>
+                        <select id="sortAlgorithm">
+                            <option value="mergesort">MergeSort (TimSort)</option>
+                            <option value="quicksort">QuickSort</option>
+                        </select>
+                    </div>
+                    <button class="btn btn-primary" onclick="executeSort()">Ordenar Perros</button>
+                    <div id="sortResult" class="result-box"></div>
+                </div>
+            </section>
+
+            <!-- Transport Tab -->
+            <section id="transport" class="tab-content">
+                <h2>Optimización de Transporte</h2>
+
+                <div class="algorithm-section">
+                    <h3>📦 Knapsack - Problema de la Mochila</h3>
+                    <p>Optimiza el transporte de perros maximizando la prioridad total dentro de la capacidad del vehículo (Programación Dinámica).</p>
+                    <div class="input-group">
+                        <label>Capacidad del Vehículo (kg):</label>
+                        <input type="number" id="vehicleCapacity" value="50" min="10" max="200">
+                    </div>
+                    <button class="btn btn-primary" onclick="executeKnapsack()">Optimizar Transporte</button>
+                    <div id="knapsackResult" class="result-box"></div>
+                </div>
+            </section>
+        </main>
+
+        <!-- Footer -->
+        <footer class="footer">
+            <p>AdoptMe - Programación III - UADE © 2024</p>
+        </footer>
+    </div>
+
+    <!-- Loading Overlay -->
+    <div id="loadingOverlay" class="loading-overlay">
+        <div class="spinner"></div>
+        <p>Procesando...</p>
+    </div>
+
+    <script src="app.js"></script>
+</body>
+</html>
diff --git a/jdk_21_maven/cs/rest/adoptme/frontend/styles.css b/jdk_21_maven/cs/rest/adoptme/frontend/styles.css
new file mode 100644
index 000000000..295f1baee
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/frontend/styles.css
@@ -0,0 +1,608 @@
+/* Reset and Base Styles */
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+:root {
+    /* Color Palette - NO PURPLE */
+    --primary-blue: #2196F3;
+    --primary-blue-dark: #1976D2;
+    --primary-blue-light: #BBDEFB;
+
+    --success-green: #4CAF50;
+    --success-green-light: #C8E6C9;
+
+    --warning-orange: #FF9800;
+    --warning-orange-light: #FFE0B2;
+
+    --error-red: #F44336;
+    --error-red-light: #FFCDD2;
+
+    --neutral-gray: #757575;
+    --neutral-light: #F5F5F5;
+    --neutral-border: #E0E0E0;
+
+    --background: #FAFAFA;
+    --card-bg: #FFFFFF;
+    --text-primary: #212121;
+    --text-secondary: #757575;
+
+    /* Spacing */
+    --spacing-xs: 0.5rem;
+    --spacing-sm: 1rem;
+    --spacing-md: 1.5rem;
+    --spacing-lg: 2rem;
+    --spacing-xl: 3rem;
+
+    /* Border Radius */
+    --radius-sm: 4px;
+    --radius-md: 8px;
+    --radius-lg: 12px;
+
+    /* Shadows */
+    --shadow-sm: 0 1px 3px rgba(0,0,0,0.12);
+    --shadow-md: 0 4px 6px rgba(0,0,0,0.1);
+    --shadow-lg: 0 10px 20px rgba(0,0,0,0.15);
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    background: var(--background);
+    color: var(--text-primary);
+    line-height: 1.6;
+}
+
+/* App Container */
+.app-container {
+    min-height: 100vh;
+    display: flex;
+    flex-direction: column;
+}
+
+/* Header */
+.header {
+    background: linear-gradient(135deg, var(--primary-blue) 0%, var(--primary-blue-dark) 100%);
+    color: white;
+    padding: var(--spacing-lg) var(--spacing-md);
+    box-shadow: var(--shadow-md);
+}
+
+.header-content {
+    max-width: 1200px;
+    margin: 0 auto;
+    text-align: center;
+}
+
+.header h1 {
+    font-size: 2.5rem;
+    margin-bottom: var(--spacing-xs);
+    font-weight: 700;
+}
+
+.subtitle {
+    font-size: 1.1rem;
+    opacity: 0.95;
+    margin-bottom: var(--spacing-md);
+}
+
+.connection-status {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--spacing-xs);
+    background: rgba(255, 255, 255, 0.2);
+    padding: var(--spacing-xs) var(--spacing-md);
+    border-radius: var(--radius-lg);
+    font-size: 0.9rem;
+}
+
+.status-indicator {
+    width: 10px;
+    height: 10px;
+    border-radius: 50%;
+    background: var(--warning-orange);
+    animation: pulse 2s infinite;
+}
+
+.status-indicator.connected {
+    background: var(--success-green);
+    animation: none;
+}
+
+.status-indicator.error {
+    background: var(--error-red);
+    animation: none;
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.5; }
+}
+
+/* Navigation Tabs */
+.nav-tabs {
+    background: var(--card-bg);
+    border-bottom: 2px solid var(--neutral-border);
+    display: flex;
+    justify-content: center;
+    flex-wrap: wrap;
+    gap: var(--spacing-xs);
+    padding: var(--spacing-sm);
+    position: sticky;
+    top: 0;
+    z-index: 100;
+    box-shadow: var(--shadow-sm);
+}
+
+.tab-button {
+    background: none;
+    border: none;
+    padding: var(--spacing-sm) var(--spacing-md);
+    font-size: 1rem;
+    color: var(--text-secondary);
+    cursor: pointer;
+    border-bottom: 3px solid transparent;
+    transition: all 0.3s ease;
+    font-weight: 500;
+}
+
+.tab-button:hover {
+    color: var(--primary-blue);
+    background: var(--primary-blue-light);
+    border-radius: var(--radius-sm);
+}
+
+.tab-button.active {
+    color: var(--primary-blue);
+    border-bottom-color: var(--primary-blue);
+}
+
+/* Main Content */
+.main-content {
+    flex: 1;
+    max-width: 1200px;
+    width: 100%;
+    margin: 0 auto;
+    padding: var(--spacing-lg);
+}
+
+.tab-content {
+    display: none;
+    animation: fadeIn 0.3s ease-in;
+}
+
+.tab-content.active {
+    display: block;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; transform: translateY(10px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+/* Welcome Section */
+.welcome-section {
+    background: linear-gradient(135deg, var(--success-green) 0%, #388E3C 100%);
+    color: white;
+    padding: var(--spacing-xl);
+    border-radius: var(--radius-lg);
+    margin-bottom: var(--spacing-lg);
+    box-shadow: var(--shadow-md);
+    text-align: center;
+}
+
+.welcome-section h2 {
+    font-size: 2rem;
+    margin-bottom: var(--spacing-sm);
+}
+
+/* Stats Grid */
+.stats-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+    gap: var(--spacing-md);
+    margin-bottom: var(--spacing-lg);
+}
+
+.stat-card {
+    background: var(--card-bg);
+    padding: var(--spacing-lg);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-md);
+    text-align: center;
+    transition: transform 0.2s ease;
+    border-left: 4px solid var(--primary-blue);
+}
+
+.stat-card:hover {
+    transform: translateY(-5px);
+    box-shadow: var(--shadow-lg);
+}
+
+.stat-card:nth-child(2) {
+    border-left-color: var(--success-green);
+}
+
+.stat-card:nth-child(3) {
+    border-left-color: var(--warning-orange);
+}
+
+.stat-card h3 {
+    color: var(--text-secondary);
+    font-size: 0.9rem;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    margin-bottom: var(--spacing-sm);
+}
+
+.stat-number {
+    font-size: 3rem;
+    font-weight: 700;
+    color: var(--primary-blue);
+    margin-bottom: var(--spacing-xs);
+}
+
+.stat-card:nth-child(2) .stat-number {
+    color: var(--success-green);
+}
+
+.stat-card:nth-child(3) .stat-number {
+    color: var(--warning-orange);
+}
+
+.stat-label {
+    color: var(--text-secondary);
+    font-size: 0.9rem;
+}
+
+/* Data Display */
+.data-display {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: var(--spacing-md);
+}
+
+.data-section {
+    background: var(--card-bg);
+    padding: var(--spacing-md);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-md);
+}
+
+.data-section h3 {
+    color: var(--primary-blue);
+    margin-bottom: var(--spacing-md);
+    padding-bottom: var(--spacing-sm);
+    border-bottom: 2px solid var(--neutral-border);
+}
+
+.data-list {
+    max-height: 400px;
+    overflow-y: auto;
+}
+
+.data-item {
+    padding: var(--spacing-sm);
+    margin-bottom: var(--spacing-sm);
+    background: var(--neutral-light);
+    border-radius: var(--radius-md);
+    border-left: 3px solid var(--primary-blue);
+}
+
+.data-item strong {
+    color: var(--primary-blue);
+}
+
+.data-item p {
+    font-size: 0.9rem;
+    color: var(--text-secondary);
+    margin-top: var(--spacing-xs);
+}
+
+/* Algorithm Sections */
+.algorithm-section {
+    background: var(--card-bg);
+    padding: var(--spacing-lg);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-md);
+    margin-bottom: var(--spacing-lg);
+}
+
+.algorithm-section h3 {
+    color: var(--primary-blue-dark);
+    margin-bottom: var(--spacing-sm);
+    font-size: 1.5rem;
+}
+
+.algorithm-section > p {
+    color: var(--text-secondary);
+    margin-bottom: var(--spacing-md);
+    line-height: 1.8;
+}
+
+/* Input Groups */
+.input-group {
+    margin-bottom: var(--spacing-md);
+}
+
+.input-group label {
+    display: block;
+    margin-bottom: var(--spacing-xs);
+    color: var(--text-primary);
+    font-weight: 500;
+}
+
+.helper-text {
+    font-size: 0.85rem;
+    color: var(--text-secondary);
+    font-weight: normal;
+    font-style: italic;
+}
+
+.input-group select,
+.input-group input {
+    width: 100%;
+    padding: var(--spacing-sm);
+    border: 2px solid var(--neutral-border);
+    border-radius: var(--radius-md);
+    font-size: 1rem;
+    transition: border-color 0.2s ease;
+}
+
+.input-group select:focus,
+.input-group input:focus {
+    outline: none;
+    border-color: var(--primary-blue);
+}
+
+/* Checkbox Group */
+.checkbox-group {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
+    gap: var(--spacing-sm);
+    padding: var(--spacing-md);
+    background: var(--neutral-light);
+    border-radius: var(--radius-md);
+    max-height: 300px;
+    overflow-y: auto;
+}
+
+.checkbox-group label {
+    display: flex;
+    align-items: center;
+    gap: var(--spacing-xs);
+    cursor: pointer;
+    padding: var(--spacing-xs);
+    background: white;
+    border-radius: var(--radius-sm);
+    transition: background-color 0.2s ease;
+}
+
+.checkbox-group label:hover {
+    background: var(--primary-blue-light);
+}
+
+.checkbox-group input[type="checkbox"] {
+    width: auto;
+    cursor: pointer;
+}
+
+.checkbox-group input[type="checkbox"]:checked + label,
+.checkbox-group label:has(input[type="checkbox"]:checked) {
+    background: var(--primary-blue-light);
+    font-weight: 500;
+}
+
+/* Buttons */
+.btn {
+    padding: var(--spacing-sm) var(--spacing-lg);
+    border: none;
+    border-radius: var(--radius-md);
+    font-size: 1rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    box-shadow: var(--shadow-sm);
+}
+
+.btn-primary {
+    background: var(--primary-blue);
+    color: white;
+}
+
+.btn-primary:hover {
+    background: var(--primary-blue-dark);
+    transform: translateY(-2px);
+    box-shadow: var(--shadow-md);
+}
+
+.btn-primary:active {
+    transform: translateY(0);
+}
+
+.btn-secondary {
+    background: var(--neutral-light);
+    color: var(--text-primary);
+    border: 2px solid var(--neutral-border);
+    padding: calc(var(--spacing-sm) - 2px) calc(var(--spacing-lg) - 2px);
+}
+
+.btn-secondary:hover {
+    background: var(--neutral-border);
+    border-color: var(--primary-blue);
+    transform: translateY(-2px);
+    box-shadow: var(--shadow-md);
+}
+
+.btn-secondary:active {
+    transform: translateY(0);
+}
+
+.button-group {
+    display: flex;
+    gap: var(--spacing-sm);
+    flex-wrap: wrap;
+    margin-bottom: var(--spacing-md);
+}
+
+/* Result Box */
+.result-box {
+    margin-top: var(--spacing-md);
+    padding: var(--spacing-md);
+    border-radius: var(--radius-md);
+    display: none;
+}
+
+.result-box.visible {
+    display: block;
+    animation: slideDown 0.3s ease;
+}
+
+@keyframes slideDown {
+    from {
+        opacity: 0;
+        transform: translateY(-10px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.result-box.success {
+    background: var(--success-green-light);
+    border-left: 4px solid var(--success-green);
+}
+
+.result-box.error {
+    background: var(--error-red-light);
+    border-left: 4px solid var(--error-red);
+}
+
+.result-box.info {
+    background: var(--primary-blue-light);
+    border-left: 4px solid var(--primary-blue);
+}
+
+.result-box h4 {
+    margin-bottom: var(--spacing-sm);
+    color: var(--text-primary);
+}
+
+.result-box pre {
+    background: rgba(0, 0, 0, 0.05);
+    padding: var(--spacing-sm);
+    border-radius: var(--radius-sm);
+    overflow-x: auto;
+    font-size: 0.9rem;
+}
+
+.result-item {
+    padding: var(--spacing-sm);
+    margin-bottom: var(--spacing-xs);
+    background: rgba(255, 255, 255, 0.7);
+    border-radius: var(--radius-sm);
+}
+
+/* Footer */
+.footer {
+    background: var(--text-primary);
+    color: white;
+    text-align: center;
+    padding: var(--spacing-md);
+    margin-top: var(--spacing-xl);
+}
+
+/* Loading Overlay */
+.loading-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: rgba(0, 0, 0, 0.7);
+    display: none;
+    align-items: center;
+    justify-content: center;
+    flex-direction: column;
+    z-index: 9999;
+}
+
+.loading-overlay.active {
+    display: flex;
+}
+
+.spinner {
+    width: 50px;
+    height: 50px;
+    border: 5px solid rgba(255, 255, 255, 0.3);
+    border-top-color: white;
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+.loading-overlay p {
+    color: white;
+    margin-top: var(--spacing-md);
+    font-size: 1.1rem;
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+    .header h1 {
+        font-size: 2rem;
+    }
+
+    .nav-tabs {
+        justify-content: flex-start;
+        overflow-x: auto;
+    }
+
+    .tab-button {
+        white-space: nowrap;
+    }
+
+    .main-content {
+        padding: var(--spacing-md);
+    }
+
+    .stats-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .data-display {
+        grid-template-columns: 1fr;
+    }
+
+    .button-group {
+        flex-direction: column;
+    }
+
+    .button-group .btn {
+        width: 100%;
+    }
+}
+
+/* Scrollbar Styling */
+::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
+}
+
+::-webkit-scrollbar-track {
+    background: var(--neutral-light);
+}
+
+::-webkit-scrollbar-thumb {
+    background: var(--neutral-gray);
+    border-radius: var(--radius-sm);
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: var(--primary-blue);
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/mvnw b/jdk_21_maven/cs/rest/adoptme/mvnw
new file mode 100644
index 000000000..bd8896bf2
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/mvnw
@@ -0,0 +1,295 @@
+#!/bin/sh
+# ----------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Apache Maven Wrapper startup batch script, version 3.3.4
+#
+# Optional ENV vars
+# -----------------
+#   JAVA_HOME - location of a JDK home dir, required when download maven via java source
+#   MVNW_REPOURL - repo url base for downloading maven distribution
+#   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+#   MVNW_VERBOSE - true: enable verbose log; debug: trace the mvnw script; others: silence the output
+# ----------------------------------------------------------------------------
+
+set -euf
+[ "${MVNW_VERBOSE-}" != debug ] || set -x
+
+# OS specific support.
+native_path() { printf %s\\n "$1"; }
+case "$(uname)" in
+CYGWIN* | MINGW*)
+  [ -z "${JAVA_HOME-}" ] || JAVA_HOME="$(cygpath --unix "$JAVA_HOME")"
+  native_path() { cygpath --path --windows "$1"; }
+  ;;
+esac
+
+# set JAVACMD and JAVACCMD
+set_java_home() {
+  # For Cygwin and MinGW, ensure paths are in Unix format before anything is touched
+  if [ -n "${JAVA_HOME-}" ]; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ]; then
+      # IBM's JDK on AIX uses strange locations for the executables
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+      JAVACCMD="$JAVA_HOME/jre/sh/javac"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+      JAVACCMD="$JAVA_HOME/bin/javac"
+
+      if [ ! -x "$JAVACMD" ] || [ ! -x "$JAVACCMD" ]; then
+        echo "The JAVA_HOME environment variable is not defined correctly, so mvnw cannot run." >&2
+        echo "JAVA_HOME is set to \"$JAVA_HOME\", but \"\$JAVA_HOME/bin/java\" or \"\$JAVA_HOME/bin/javac\" does not exist." >&2
+        return 1
+      fi
+    fi
+  else
+    JAVACMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v java
+    )" || :
+    JAVACCMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v javac
+    )" || :
+
+    if [ ! -x "${JAVACMD-}" ] || [ ! -x "${JAVACCMD-}" ]; then
+      echo "The java/javac command does not exist in PATH nor is JAVA_HOME set, so mvnw cannot run." >&2
+      return 1
+    fi
+  fi
+}
+
+# hash string like Java String::hashCode
+hash_string() {
+  str="${1:-}" h=0
+  while [ -n "$str" ]; do
+    char="${str%"${str#?}"}"
+    h=$(((h * 31 + $(LC_CTYPE=C printf %d "'$char")) % 4294967296))
+    str="${str#?}"
+  done
+  printf %x\\n $h
+}
+
+verbose() { :; }
+[ "${MVNW_VERBOSE-}" != true ] || verbose() { printf %s\\n "${1-}"; }
+
+die() {
+  printf %s\\n "$1" >&2
+  exit 1
+}
+
+trim() {
+  # MWRAPPER-139:
+  #   Trims trailing and leading whitespace, carriage returns, tabs, and linefeeds.
+  #   Needed for removing poorly interpreted newline sequences when running in more
+  #   exotic environments such as mingw bash on Windows.
+  printf "%s" "${1}" | tr -d '[:space:]'
+}
+
+scriptDir="$(dirname "$0")"
+scriptName="$(basename "$0")"
+
+# parse distributionUrl and optional distributionSha256Sum, requires .mvn/wrapper/maven-wrapper.properties
+while IFS="=" read -r key value; do
+  case "${key-}" in
+  distributionUrl) distributionUrl=$(trim "${value-}") ;;
+  distributionSha256Sum) distributionSha256Sum=$(trim "${value-}") ;;
+  esac
+done <"$scriptDir/.mvn/wrapper/maven-wrapper.properties"
+[ -n "${distributionUrl-}" ] || die "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
+
+case "${distributionUrl##*/}" in
+maven-mvnd-*bin.*)
+  MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/
+  case "${PROCESSOR_ARCHITECTURE-}${PROCESSOR_ARCHITEW6432-}:$(uname -a)" in
+  *AMD64:CYGWIN* | *AMD64:MINGW*) distributionPlatform=windows-amd64 ;;
+  :Darwin*x86_64) distributionPlatform=darwin-amd64 ;;
+  :Darwin*arm64) distributionPlatform=darwin-aarch64 ;;
+  :Linux*x86_64*) distributionPlatform=linux-amd64 ;;
+  *)
+    echo "Cannot detect native platform for mvnd on $(uname)-$(uname -m), use pure java version" >&2
+    distributionPlatform=linux-amd64
+    ;;
+  esac
+  distributionUrl="${distributionUrl%-bin.*}-$distributionPlatform.zip"
+  ;;
+maven-mvnd-*) MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ ;;
+*) MVN_CMD="mvn${scriptName#mvnw}" _MVNW_REPO_PATTERN=/org/apache/maven/ ;;
+esac
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+[ -z "${MVNW_REPOURL-}" ] || distributionUrl="$MVNW_REPOURL$_MVNW_REPO_PATTERN${distributionUrl#*"$_MVNW_REPO_PATTERN"}"
+distributionUrlName="${distributionUrl##*/}"
+distributionUrlNameMain="${distributionUrlName%.*}"
+distributionUrlNameMain="${distributionUrlNameMain%-bin}"
+MAVEN_USER_HOME="${MAVEN_USER_HOME:-${HOME}/.m2}"
+MAVEN_HOME="${MAVEN_USER_HOME}/wrapper/dists/${distributionUrlNameMain-}/$(hash_string "$distributionUrl")"
+
+exec_maven() {
+  unset MVNW_VERBOSE MVNW_USERNAME MVNW_PASSWORD MVNW_REPOURL || :
+  exec "$MAVEN_HOME/bin/$MVN_CMD" "$@" || die "cannot exec $MAVEN_HOME/bin/$MVN_CMD"
+}
+
+if [ -d "$MAVEN_HOME" ]; then
+  verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  exec_maven "$@"
+fi
+
+case "${distributionUrl-}" in
+*?-bin.zip | *?maven-mvnd-?*-?*.zip) ;;
+*) die "distributionUrl is not valid, must match *-bin.zip or maven-mvnd-*.zip, but found '${distributionUrl-}'" ;;
+esac
+
+# prepare tmp dir
+if TMP_DOWNLOAD_DIR="$(mktemp -d)" && [ -d "$TMP_DOWNLOAD_DIR" ]; then
+  clean() { rm -rf -- "$TMP_DOWNLOAD_DIR"; }
+  trap clean HUP INT TERM EXIT
+else
+  die "cannot create temp dir"
+fi
+
+mkdir -p -- "${MAVEN_HOME%/*}"
+
+# Download and Install Apache Maven
+verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+verbose "Downloading from: $distributionUrl"
+verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+# select .zip or .tar.gz
+if ! command -v unzip >/dev/null; then
+  distributionUrl="${distributionUrl%.zip}.tar.gz"
+  distributionUrlName="${distributionUrl##*/}"
+fi
+
+# verbose opt
+__MVNW_QUIET_WGET=--quiet __MVNW_QUIET_CURL=--silent __MVNW_QUIET_UNZIP=-q __MVNW_QUIET_TAR=''
+[ "${MVNW_VERBOSE-}" != true ] || __MVNW_QUIET_WGET='' __MVNW_QUIET_CURL='' __MVNW_QUIET_UNZIP='' __MVNW_QUIET_TAR=v
+
+# normalize http auth
+case "${MVNW_PASSWORD:+has-password}" in
+'') MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+has-password) [ -n "${MVNW_USERNAME-}" ] || MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+esac
+
+if [ -z "${MVNW_USERNAME-}" ] && command -v wget >/dev/null; then
+  verbose "Found wget ... using wget"
+  wget ${__MVNW_QUIET_WGET:+"$__MVNW_QUIET_WGET"} "$distributionUrl" -O "$TMP_DOWNLOAD_DIR/$distributionUrlName" || die "wget: Failed to fetch $distributionUrl"
+elif [ -z "${MVNW_USERNAME-}" ] && command -v curl >/dev/null; then
+  verbose "Found curl ... using curl"
+  curl ${__MVNW_QUIET_CURL:+"$__MVNW_QUIET_CURL"} -f -L -o "$TMP_DOWNLOAD_DIR/$distributionUrlName" "$distributionUrl" || die "curl: Failed to fetch $distributionUrl"
+elif set_java_home; then
+  verbose "Falling back to use Java to download"
+  javaSource="$TMP_DOWNLOAD_DIR/Downloader.java"
+  targetZip="$TMP_DOWNLOAD_DIR/$distributionUrlName"
+  cat >"$javaSource" <<-END
+	public class Downloader extends java.net.Authenticator
+	{
+	  protected java.net.PasswordAuthentication getPasswordAuthentication()
+	  {
+	    return new java.net.PasswordAuthentication( System.getenv( "MVNW_USERNAME" ), System.getenv( "MVNW_PASSWORD" ).toCharArray() );
+	  }
+	  public static void main( String[] args ) throws Exception
+	  {
+	    setDefault( new Downloader() );
+	    java.nio.file.Files.copy( java.net.URI.create( args[0] ).toURL().openStream(), java.nio.file.Paths.get( args[1] ).toAbsolutePath().normalize() );
+	  }
+	}
+	END
+  # For Cygwin/MinGW, switch paths to Windows format before running javac and java
+  verbose " - Compiling Downloader.java ..."
+  "$(native_path "$JAVACCMD")" "$(native_path "$javaSource")" || die "Failed to compile Downloader.java"
+  verbose " - Running Downloader.java ..."
+  "$(native_path "$JAVACMD")" -cp "$(native_path "$TMP_DOWNLOAD_DIR")" Downloader "$distributionUrl" "$(native_path "$targetZip")"
+fi
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+if [ -n "${distributionSha256Sum-}" ]; then
+  distributionSha256Result=false
+  if [ "$MVN_CMD" = mvnd.sh ]; then
+    echo "Checksum validation is not supported for maven-mvnd." >&2
+    echo "Please disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  elif command -v sha256sum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | sha256sum -c - >/dev/null 2>&1; then
+      distributionSha256Result=true
+    fi
+  elif command -v shasum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | shasum -a 256 -c >/dev/null 2>&1; then
+      distributionSha256Result=true
+    fi
+  else
+    echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2
+    echo "Please install either command, or disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  fi
+  if [ $distributionSha256Result = false ]; then
+    echo "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised." >&2
+    echo "If you updated your Maven version, you need to update the specified distributionSha256Sum property." >&2
+    exit 1
+  fi
+fi
+
+# unzip and move
+if command -v unzip >/dev/null; then
+  unzip ${__MVNW_QUIET_UNZIP:+"$__MVNW_QUIET_UNZIP"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -d "$TMP_DOWNLOAD_DIR" || die "failed to unzip"
+else
+  tar xzf${__MVNW_QUIET_TAR:+"$__MVNW_QUIET_TAR"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -C "$TMP_DOWNLOAD_DIR" || die "failed to untar"
+fi
+
+# Find the actual extracted directory name (handles snapshots where filename != directory name)
+actualDistributionDir=""
+
+# First try the expected directory name (for regular distributions)
+if [ -d "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" ]; then
+  if [ -f "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain/bin/$MVN_CMD" ]; then
+    actualDistributionDir="$distributionUrlNameMain"
+  fi
+fi
+
+# If not found, search for any directory with the Maven executable (for snapshots)
+if [ -z "$actualDistributionDir" ]; then
+  # enable globbing to iterate over items
+  set +f
+  for dir in "$TMP_DOWNLOAD_DIR"/*; do
+    if [ -d "$dir" ]; then
+      if [ -f "$dir/bin/$MVN_CMD" ]; then
+        actualDistributionDir="$(basename "$dir")"
+        break
+      fi
+    fi
+  done
+  set -f
+fi
+
+if [ -z "$actualDistributionDir" ]; then
+  verbose "Contents of $TMP_DOWNLOAD_DIR:"
+  verbose "$(ls -la "$TMP_DOWNLOAD_DIR")"
+  die "Could not find Maven distribution directory in extracted archive"
+fi
+
+verbose "Found extracted Maven distribution directory: $actualDistributionDir"
+printf %s\\n "$distributionUrl" >"$TMP_DOWNLOAD_DIR/$actualDistributionDir/mvnw.url"
+mv -- "$TMP_DOWNLOAD_DIR/$actualDistributionDir" "$MAVEN_HOME" || [ -d "$MAVEN_HOME" ] || die "fail to move MAVEN_HOME"
+
+clean || :
+exec_maven "$@"
diff --git a/jdk_21_maven/cs/rest/adoptme/mvnw.cmd b/jdk_21_maven/cs/rest/adoptme/mvnw.cmd
new file mode 100644
index 000000000..92450f932
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/mvnw.cmd
@@ -0,0 +1,189 @@
+<# : batch portion
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements.  See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership.  The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License.  You may obtain a copy of the License at
+@REM
+@REM    http://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied.  See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Apache Maven Wrapper startup batch script, version 3.3.4
+@REM
+@REM Optional ENV vars
+@REM   MVNW_REPOURL - repo url base for downloading maven distribution
+@REM   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+@REM   MVNW_VERBOSE - true: enable verbose log; others: silence the output
+@REM ----------------------------------------------------------------------------
+
+@IF "%__MVNW_ARG0_NAME__%"=="" (SET __MVNW_ARG0_NAME__=%~nx0)
+@SET __MVNW_CMD__=
+@SET __MVNW_ERROR__=
+@SET __MVNW_PSMODULEP_SAVE=%PSModulePath%
+@SET PSModulePath=
+@FOR /F "usebackq tokens=1* delims==" %%A IN (`powershell -noprofile "& {$scriptDir='%~dp0'; $script='%__MVNW_ARG0_NAME__%'; icm -ScriptBlock ([Scriptblock]::Create((Get-Content -Raw '%~f0'))) -NoNewScope}"`) DO @(
+  IF "%%A"=="MVN_CMD" (set __MVNW_CMD__=%%B) ELSE IF "%%B"=="" (echo %%A) ELSE (echo %%A=%%B)
+)
+@SET PSModulePath=%__MVNW_PSMODULEP_SAVE%
+@SET __MVNW_PSMODULEP_SAVE=
+@SET __MVNW_ARG0_NAME__=
+@SET MVNW_USERNAME=
+@SET MVNW_PASSWORD=
+@IF NOT "%__MVNW_CMD__%"=="" ("%__MVNW_CMD__%" %*)
+@echo Cannot start maven from wrapper >&2 && exit /b 1
+@GOTO :EOF
+: end batch / begin powershell #>
+
+$ErrorActionPreference = "Stop"
+if ($env:MVNW_VERBOSE -eq "true") {
+  $VerbosePreference = "Continue"
+}
+
+# calculate distributionUrl, requires .mvn/wrapper/maven-wrapper.properties
+$distributionUrl = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionUrl
+if (!$distributionUrl) {
+  Write-Error "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
+}
+
+switch -wildcard -casesensitive ( $($distributionUrl -replace '^.*/','') ) {
+  "maven-mvnd-*" {
+    $USE_MVND = $true
+    $distributionUrl = $distributionUrl -replace '-bin\.[^.]*$',"-windows-amd64.zip"
+    $MVN_CMD = "mvnd.cmd"
+    break
+  }
+  default {
+    $USE_MVND = $false
+    $MVN_CMD = $script -replace '^mvnw','mvn'
+    break
+  }
+}
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+if ($env:MVNW_REPOURL) {
+  $MVNW_REPO_PATTERN = if ($USE_MVND -eq $False) { "/org/apache/maven/" } else { "/maven/mvnd/" }
+  $distributionUrl = "$env:MVNW_REPOURL$MVNW_REPO_PATTERN$($distributionUrl -replace "^.*$MVNW_REPO_PATTERN",'')"
+}
+$distributionUrlName = $distributionUrl -replace '^.*/',''
+$distributionUrlNameMain = $distributionUrlName -replace '\.[^.]*$','' -replace '-bin$',''
+
+$MAVEN_M2_PATH = "$HOME/.m2"
+if ($env:MAVEN_USER_HOME) {
+  $MAVEN_M2_PATH = "$env:MAVEN_USER_HOME"
+}
+
+if (-not (Test-Path -Path $MAVEN_M2_PATH)) {
+    New-Item -Path $MAVEN_M2_PATH -ItemType Directory | Out-Null
+}
+
+$MAVEN_WRAPPER_DISTS = $null
+if ((Get-Item $MAVEN_M2_PATH).Target[0] -eq $null) {
+  $MAVEN_WRAPPER_DISTS = "$MAVEN_M2_PATH/wrapper/dists"
+} else {
+  $MAVEN_WRAPPER_DISTS = (Get-Item $MAVEN_M2_PATH).Target[0] + "/wrapper/dists"
+}
+
+$MAVEN_HOME_PARENT = "$MAVEN_WRAPPER_DISTS/$distributionUrlNameMain"
+$MAVEN_HOME_NAME = ([System.Security.Cryptography.SHA256]::Create().ComputeHash([byte[]][char[]]$distributionUrl) | ForEach-Object {$_.ToString("x2")}) -join ''
+$MAVEN_HOME = "$MAVEN_HOME_PARENT/$MAVEN_HOME_NAME"
+
+if (Test-Path -Path "$MAVEN_HOME" -PathType Container) {
+  Write-Verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"
+  exit $?
+}
+
+if (! $distributionUrlNameMain -or ($distributionUrlName -eq $distributionUrlNameMain)) {
+  Write-Error "distributionUrl is not valid, must end with *-bin.zip, but found $distributionUrl"
+}
+
+# prepare tmp dir
+$TMP_DOWNLOAD_DIR_HOLDER = New-TemporaryFile
+$TMP_DOWNLOAD_DIR = New-Item -Itemtype Directory -Path "$TMP_DOWNLOAD_DIR_HOLDER.dir"
+$TMP_DOWNLOAD_DIR_HOLDER.Delete() | Out-Null
+trap {
+  if ($TMP_DOWNLOAD_DIR.Exists) {
+    try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+    catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+  }
+}
+
+New-Item -Itemtype Directory -Path "$MAVEN_HOME_PARENT" -Force | Out-Null
+
+# Download and Install Apache Maven
+Write-Verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+Write-Verbose "Downloading from: $distributionUrl"
+Write-Verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+$webclient = New-Object System.Net.WebClient
+if ($env:MVNW_USERNAME -and $env:MVNW_PASSWORD) {
+  $webclient.Credentials = New-Object System.Net.NetworkCredential($env:MVNW_USERNAME, $env:MVNW_PASSWORD)
+}
+[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+$webclient.DownloadFile($distributionUrl, "$TMP_DOWNLOAD_DIR/$distributionUrlName") | Out-Null
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+$distributionSha256Sum = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionSha256Sum
+if ($distributionSha256Sum) {
+  if ($USE_MVND) {
+    Write-Error "Checksum validation is not supported for maven-mvnd. `nPlease disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties."
+  }
+  Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash
+  if ((Get-FileHash "$TMP_DOWNLOAD_DIR/$distributionUrlName" -Algorithm SHA256).Hash.ToLower() -ne $distributionSha256Sum) {
+    Write-Error "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised. If you updated your Maven version, you need to update the specified distributionSha256Sum property."
+  }
+}
+
+# unzip and move
+Expand-Archive "$TMP_DOWNLOAD_DIR/$distributionUrlName" -DestinationPath "$TMP_DOWNLOAD_DIR" | Out-Null
+
+# Find the actual extracted directory name (handles snapshots where filename != directory name)
+$actualDistributionDir = ""
+
+# First try the expected directory name (for regular distributions)
+$expectedPath = Join-Path "$TMP_DOWNLOAD_DIR" "$distributionUrlNameMain"
+$expectedMvnPath = Join-Path "$expectedPath" "bin/$MVN_CMD"
+if ((Test-Path -Path $expectedPath -PathType Container) -and (Test-Path -Path $expectedMvnPath -PathType Leaf)) {
+  $actualDistributionDir = $distributionUrlNameMain
+}
+
+# If not found, search for any directory with the Maven executable (for snapshots)
+if (!$actualDistributionDir) {
+  Get-ChildItem -Path "$TMP_DOWNLOAD_DIR" -Directory | ForEach-Object {
+    $testPath = Join-Path $_.FullName "bin/$MVN_CMD"
+    if (Test-Path -Path $testPath -PathType Leaf) {
+      $actualDistributionDir = $_.Name
+    }
+  }
+}
+
+if (!$actualDistributionDir) {
+  Write-Error "Could not find Maven distribution directory in extracted archive"
+}
+
+Write-Verbose "Found extracted Maven distribution directory: $actualDistributionDir"
+Rename-Item -Path "$TMP_DOWNLOAD_DIR/$actualDistributionDir" -NewName $MAVEN_HOME_NAME | Out-Null
+try {
+  Move-Item -Path "$TMP_DOWNLOAD_DIR/$MAVEN_HOME_NAME" -Destination $MAVEN_HOME_PARENT | Out-Null
+} catch {
+  if (! (Test-Path -Path "$MAVEN_HOME" -PathType Container)) {
+    Write-Error "fail to move MAVEN_HOME"
+  }
+} finally {
+  try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+  catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+}
+
+Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"
diff --git a/jdk_21_maven/cs/rest/adoptme/pom.xml b/jdk_21_maven/cs/rest/adoptme/pom.xml
new file mode 100644
index 000000000..73243da6e
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/pom.xml
@@ -0,0 +1,87 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>org.springframework.boot</groupId>
+		<artifactId>spring-boot-starter-parent</artifactId>
+		<version>3.5.6</version>
+		<relativePath/> <!-- lookup parent from repository -->
+	</parent>
+	<groupId>com.programacion3</groupId>
+	<artifactId>adoptme</artifactId>
+	<version>0.0.1-SNAPSHOT</version>
+	<name>AdoptM</name>
+	<description>Trabajo práctico Programación 3 - Sistema de adopciones</description>
+	<url/>
+	<licenses>
+		<license/>
+	</licenses>
+	<developers>
+		<developer/>
+	</developers>
+	<scm>
+		<connection/>
+		<developerConnection/>
+		<tag/>
+		<url/>
+	</scm>
+	<properties>
+		<java.version>21</java.version>
+	</properties>
+	<dependencies>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-data-neo4j</artifactId>
+		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-validation</artifactId>
+		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-web</artifactId>
+		</dependency>
+
+		<dependency>
+			<groupId>org.projectlombok</groupId>
+			<artifactId>lombok</artifactId>
+			<optional>true</optional>
+		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-test</artifactId>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<configuration>
+					<annotationProcessorPaths>
+						<path>
+							<groupId>org.projectlombok</groupId>
+							<artifactId>lombok</artifactId>
+						</path>
+					</annotationProcessorPaths>
+				</configuration>
+			</plugin>
+			<plugin>
+				<groupId>org.springframework.boot</groupId>
+				<artifactId>spring-boot-maven-plugin</artifactId>
+				<configuration>
+					<excludes>
+						<exclude>
+							<groupId>org.projectlombok</groupId>
+							<artifactId>lombok</artifactId>
+						</exclude>
+					</excludes>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+
+</project>
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/AdoptMApplication.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/AdoptMApplication.java
new file mode 100644
index 000000000..7e789e112
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/AdoptMApplication.java
@@ -0,0 +1,12 @@
+package com.programacion3.adoptme;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class AdoptMApplication {
+
+	public static void main(String[] args) {
+		SpringApplication.run(AdoptMApplication.class, args);
+	}
+
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/config/CorsConfig.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/config/CorsConfig.java
new file mode 100644
index 000000000..ee4e15d22
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/config/CorsConfig.java
@@ -0,0 +1,64 @@
+package com.programacion3.adoptme.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
+import org.springframework.web.filter.CorsFilter;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Configuración de CORS para permitir requests desde el frontend
+ */
+@Configuration
+public class CorsConfig {
+
+    @Bean
+    public CorsFilter corsFilter() {
+        CorsConfiguration config = new CorsConfiguration();
+
+        // Permitir credenciales
+        config.setAllowCredentials(true);
+
+        // Permitir orígenes del frontend
+        config.setAllowedOriginPatterns(Arrays.asList(
+            "http://localhost:*",
+            "http://127.0.0.1:*",
+            "http://[::1]:*"
+        ));
+
+        // Permitir todos los headers
+        config.setAllowedHeaders(List.of("*"));
+
+        // Permitir todos los métodos HTTP
+        config.setAllowedMethods(Arrays.asList(
+            "GET",
+            "POST",
+            "PUT",
+            "DELETE",
+            "OPTIONS",
+            "PATCH"
+        ));
+
+        // Exponer headers en la respuesta
+        config.setExposedHeaders(Arrays.asList(
+            "Authorization",
+            "Content-Type",
+            "X-Requested-With",
+            "Accept",
+            "Origin",
+            "Access-Control-Request-Method",
+            "Access-Control-Request-Headers"
+        ));
+
+        // Cachear la respuesta de preflight por 1 hora
+        config.setMaxAge(3600L);
+
+        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+        source.registerCorsConfiguration("/**", config);
+
+        return new CorsFilter(source);
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/config/DbSeed.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/config/DbSeed.java
new file mode 100644
index 000000000..8023b7ca9
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/config/DbSeed.java
@@ -0,0 +1,333 @@
+package com.programacion3.adoptme.config;
+
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.data.neo4j.core.Neo4jClient;
+
+@Configuration
+public class DbSeed {
+
+    @Bean
+    CommandLineRunner seed(Neo4jClient neo4j) {
+        return args -> seedIfEmpty(neo4j);
+    }
+
+    @Transactional
+    void seedIfEmpty(Neo4jClient neo4j) {
+        // Check if data is complete (15 shelters expected)
+        long shelterCount = neo4j.query("MATCH (s:Shelter) RETURN count(s) AS c")
+                .fetchAs(Long.class)
+                .mappedBy((t,r) -> r.get("c").asLong())
+                .one()
+                .orElse(0L);
+
+        long dogCount = neo4j.query("MATCH (d:Dog) RETURN count(d) AS c")
+                .fetchAs(Long.class)
+                .mappedBy((t,r) -> r.get("c").asLong())
+                .one()
+                .orElse(0L);
+
+        long adopterCount = neo4j.query("MATCH (a:Adopter) RETURN count(a) AS c")
+                .fetchAs(Long.class)
+                .mappedBy((t,r) -> r.get("c").asLong())
+                .one()
+                .orElse(0L);
+
+        // Check if database has complete test data
+        boolean hasCompleteData = shelterCount == 15 && dogCount == 40 && adopterCount == 15;
+
+        if (hasCompleteData) {
+            System.out.println("[SEED] Database already has complete test data:");
+            System.out.println("[SEED]   - 15 Shelters ✓");
+            System.out.println("[SEED]   - 40 Dogs ✓");
+            System.out.println("[SEED]   - 15 Adopters ✓");
+            return;
+        }
+
+        // Database is incomplete or empty, re-seed everything
+        System.out.println("[SEED] Database incomplete or empty. Current state:");
+        System.out.println("[SEED]   - Shelters: " + shelterCount + "/15");
+        System.out.println("[SEED]   - Dogs: " + dogCount + "/40");
+        System.out.println("[SEED]   - Adopters: " + adopterCount + "/15");
+        System.out.println("[SEED] Cleaning and re-seeding database...");
+
+        neo4j.query("MATCH (n) DETACH DELETE n").run();
+
+        // ========== SHELTERS (15 total) ==========
+        neo4j.query("""
+CREATE (a:Shelter {id:'A', name:'Refugio A', capacity:20}),
+       (b:Shelter {id:'B', name:'Refugio B', capacity:15}),
+       (c:Shelter {id:'C', name:'Refugio C', capacity:10}),
+       (h:Shelter {id:'H', name:'Central Hub', capacity:40}),
+       (d:Shelter {id:'D', name:'Refugio D', capacity:25}),
+       (e:Shelter {id:'E', name:'Refugio E', capacity:18}),
+       (f:Shelter {id:'F', name:'Refugio F', capacity:12}),
+       (g:Shelter {id:'G', name:'Refugio G', capacity:30}),
+       (i:Shelter {id:'I', name:'Refugio I', capacity:22}),
+       (j:Shelter {id:'J', name:'Refugio J', capacity:16}),
+       (k:Shelter {id:'K', name:'Refugio K', capacity:14}),
+       (l:Shelter {id:'L', name:'Refugio L', capacity:28}),
+       (m:Shelter {id:'M', name:'Refugio M', capacity:20}),
+       (n:Shelter {id:'N', name:'Refugio N', capacity:24}),
+       (o:Shelter {id:'O', name:'Refugio O', capacity:35})
+
+""").run();
+
+        // ========== NETWORK CONNECTIONS (35+ edges) ==========
+        neo4j.query("""
+MATCH (a:Shelter {id:'A'}),(b:Shelter {id:'B'}),(c:Shelter {id:'C'}),(h:Shelter {id:'H'}),
+      (d:Shelter {id:'D'}),(e:Shelter {id:'E'}),(f:Shelter {id:'F'}),(g:Shelter {id:'G'}),
+      (i:Shelter {id:'I'}),(j:Shelter {id:'J'}),(k:Shelter {id:'K'}),(l:Shelter {id:'L'}),
+      (m:Shelter {id:'M'}),(n:Shelter {id:'N'}),(o:Shelter {id:'O'})
+CREATE
+    // Original connections
+    (h)-[:NEAR {distKm:5,  timeMin:10}]->(a),
+    (h)-[:NEAR {distKm:7,  timeMin:15}]->(b),
+    (h)-[:NEAR {distKm:9,  timeMin:18}]->(c),
+    (a)-[:NEAR {distKm:6,  timeMin:12}]->(b),
+    (b)-[:NEAR {distKm:8,  timeMin:16}]->(c),
+    (a)-[:NEAR {distKm:10, timeMin:20}]->(c),
+    (c)-[:NEAR {distKm:14, timeMin:25}]->(h),
+
+    // Hub connections to new shelters
+    (h)-[:NEAR {distKm:8,  timeMin:16}]->(d),
+    (h)-[:NEAR {distKm:12, timeMin:24}]->(g),
+    (h)-[:NEAR {distKm:11, timeMin:22}]->(l),
+    (h)-[:NEAR {distKm:15, timeMin:30}]->(o),
+
+    // Regional cluster 1: A-D-E-I
+    (a)-[:NEAR {distKm:7,  timeMin:14}]->(d),
+    (d)-[:NEAR {distKm:9,  timeMin:18}]->(e),
+    (e)-[:NEAR {distKm:6,  timeMin:12}]->(i),
+    (i)-[:NEAR {distKm:11, timeMin:22}]->(a),
+
+    // Regional cluster 2: B-F-J-K
+    (b)-[:NEAR {distKm:5,  timeMin:10}]->(f),
+    (f)-[:NEAR {distKm:8,  timeMin:16}]->(j),
+    (j)-[:NEAR {distKm:7,  timeMin:14}]->(k),
+    (k)-[:NEAR {distKm:9,  timeMin:18}]->(b),
+
+    // Regional cluster 3: C-G-M-N
+    (c)-[:NEAR {distKm:6,  timeMin:12}]->(g),
+    (g)-[:NEAR {distKm:10, timeMin:20}]->(m),
+    (m)-[:NEAR {distKm:8,  timeMin:16}]->(n),
+    (n)-[:NEAR {distKm:12, timeMin:24}]->(c),
+
+    // Cluster 4: L-O
+    (l)-[:NEAR {distKm:13, timeMin:26}]->(o),
+
+    // Inter-cluster connections
+    (d)-[:NEAR {distKm:15, timeMin:30}]->(g),
+    (e)-[:NEAR {distKm:10, timeMin:20}]->(f),
+    (f)-[:NEAR {distKm:14, timeMin:28}]->(m),
+    (i)-[:NEAR {distKm:16, timeMin:32}]->(j),
+    (j)-[:NEAR {distKm:11, timeMin:22}]->(n),
+    (k)-[:NEAR {distKm:13, timeMin:26}]->(l),
+    (l)-[:NEAR {distKm:9,  timeMin:18}]->(m),
+    (n)-[:NEAR {distKm:17, timeMin:34}]->(o),
+    (e)-[:NEAR {distKm:18, timeMin:36}]->(o),
+
+    // Additional shortcuts
+    (a)-[:NEAR {distKm:20, timeMin:40}]->(g),
+    (d)-[:NEAR {distKm:22, timeMin:44}]->(l)
+""").run();
+        // ========== DOGS (40 total) - varied characteristics for testing ==========
+        neo4j.query("""
+CREATE
+      (d1:Dog {id:'D1', name:'Luna',  size:'SMALL',  weightKg:8,  age:2, energy:'LOW',    goodWithKids:true,  specialNeeds:false, priority:4}),
+      (d2:Dog {id:'D2', name:'Toto',   size:'MEDIUM', weightKg:18, age:3, energy:'HIGH',   goodWithKids:true,  specialNeeds:false, priority:6}),
+      (d3:Dog {id:'D3', name:'Rex', size:'LARGE',  weightKg:25, age:5, energy:'MEDIUM', goodWithKids:false, specialNeeds:true,  priority:8}),
+      (d4:Dog {id:'D4', name:'Miranda',  size:'SMALL',  weightKg:10, age:1, energy:'HIGH',   goodWithKids:true,  specialNeeds:false, priority:5}),
+      (d5:Dog {id:'D5', name:'Perchita',  size:'MEDIUM', weightKg:15, age:4, energy:'MEDIUM', goodWithKids:true,  specialNeeds:false, priority:3}),
+      (d6:Dog {id:'D6', name:'Lina', size:'LARGE',  weightKg:30, age:6, energy:'LOW',    goodWithKids:false, specialNeeds:true,  priority:7}),
+
+      // New dogs for extensive testing
+      (d7:Dog {id:'D7', name:'Buddy', size:'MEDIUM', weightKg:20, age:4, energy:'HIGH',   goodWithKids:true,  specialNeeds:false, priority:6}),
+      (d8:Dog {id:'D8', name:'Max', size:'LARGE',  weightKg:28, age:7, energy:'LOW',    goodWithKids:false, specialNeeds:false, priority:5}),
+      (d9:Dog {id:'D9', name:'Bella', size:'SMALL',  weightKg:7,  age:1, energy:'MEDIUM', goodWithKids:true,  specialNeeds:false, priority:9}),
+      (d10:Dog {id:'D10', name:'Charlie', size:'MEDIUM', weightKg:16, age:3, energy:'HIGH',   goodWithKids:true,  specialNeeds:false, priority:7}),
+      (d11:Dog {id:'D11', name:'Daisy', size:'SMALL',  weightKg:9,  age:2, energy:'LOW',    goodWithKids:true,  specialNeeds:true,  priority:8}),
+      (d12:Dog {id:'D12', name:'Rocky', size:'LARGE',  weightKg:32, age:6, energy:'MEDIUM', goodWithKids:false, specialNeeds:false, priority:4}),
+      (d13:Dog {id:'D13', name:'Lucy', size:'SMALL',  weightKg:6,  age:1, energy:'HIGH',   goodWithKids:true,  specialNeeds:false, priority:10}),
+      (d14:Dog {id:'D14', name:'Cooper', size:'MEDIUM', weightKg:19, age:5, energy:'MEDIUM', goodWithKids:true,  specialNeeds:false, priority:5}),
+      (d15:Dog {id:'D15', name:'Sadie', size:'LARGE',  weightKg:27, age:4, energy:'LOW',    goodWithKids:false, specialNeeds:true,  priority:6}),
+      (d16:Dog {id:'D16', name:'Duke', size:'LARGE',  weightKg:35, age:8, energy:'LOW',    goodWithKids:false, specialNeeds:true,  priority:3}),
+      (d17:Dog {id:'D17', name:'Lola', size:'SMALL',  weightKg:8,  age:2, energy:'MEDIUM', goodWithKids:true,  specialNeeds:false, priority:7}),
+      (d18:Dog {id:'D18', name:'Bailey', size:'MEDIUM', weightKg:17, age:3, energy:'HIGH',   goodWithKids:true,  specialNeeds:false, priority:8}),
+      (d19:Dog {id:'D19', name:'Maggie', size:'SMALL',  weightKg:10, age:6, energy:'LOW',    goodWithKids:true,  specialNeeds:false, priority:4}),
+      (d20:Dog {id:'D20', name:'Bear', size:'LARGE',  weightKg:33, age:7, energy:'MEDIUM', goodWithKids:false, specialNeeds:false, priority:5}),
+      (d21:Dog {id:'D21', name:'Molly', size:'MEDIUM', weightKg:16, age:2, energy:'HIGH',   goodWithKids:true,  specialNeeds:false, priority:9}),
+      (d22:Dog {id:'D22', name:'Jack', size:'SMALL',  weightKg:7,  age:1, energy:'HIGH',   goodWithKids:true,  specialNeeds:false, priority:6}),
+      (d23:Dog {id:'D23', name:'Sophie', size:'MEDIUM', weightKg:18, age:4, energy:'MEDIUM', goodWithKids:true,  specialNeeds:true,  priority:7}),
+      (d24:Dog {id:'D24', name:'Zeus', size:'LARGE',  weightKg:34, age:5, energy:'HIGH',   goodWithKids:false, specialNeeds:false, priority:8}),
+      (d25:Dog {id:'D25', name:'Chloe', size:'SMALL',  weightKg:9,  age:3, energy:'LOW',    goodWithKids:true,  specialNeeds:false, priority:5}),
+      (d26:Dog {id:'D26', name:'Bentley', size:'MEDIUM', weightKg:21, age:4, energy:'MEDIUM', goodWithKids:false, specialNeeds:false, priority:6}),
+      (d27:Dog {id:'D27', name:'Zoe', size:'SMALL',  weightKg:6,  age:1, energy:'HIGH',   goodWithKids:true,  specialNeeds:false, priority:10}),
+      (d28:Dog {id:'D28', name:'Gus', size:'LARGE',  weightKg:29, age:6, energy:'LOW',    goodWithKids:false, specialNeeds:true,  priority:4}),
+      (d29:Dog {id:'D29', name:'Penny', size:'MEDIUM', weightKg:17, age:2, energy:'HIGH',   goodWithKids:true,  specialNeeds:false, priority:8}),
+      (d30:Dog {id:'D30', name:'Milo', size:'SMALL',  weightKg:8,  age:3, energy:'MEDIUM', goodWithKids:true,  specialNeeds:false, priority:7}),
+      (d31:Dog {id:'D31', name:'Ruby', size:'LARGE',  weightKg:26, age:5, energy:'LOW',    goodWithKids:false, specialNeeds:false, priority:5}),
+      (d32:Dog {id:'D32', name:'Oscar', size:'MEDIUM', weightKg:19, age:4, energy:'HIGH',   goodWithKids:true,  specialNeeds:true,  priority:9}),
+      (d33:Dog {id:'D33', name:'Stella', size:'SMALL',  weightKg:7,  age:2, energy:'LOW',    goodWithKids:true,  specialNeeds:false, priority:6}),
+      (d34:Dog {id:'D34', name:'Tucker', size:'LARGE',  weightKg:31, age:7, energy:'MEDIUM', goodWithKids:false, specialNeeds:false, priority:4}),
+      (d35:Dog {id:'D35', name:'Rosie', size:'SMALL',  weightKg:9,  age:1, energy:'HIGH',   goodWithKids:true,  specialNeeds:false, priority:8}),
+      (d36:Dog {id:'D36', name:'Harley', size:'MEDIUM', weightKg:20, age:5, energy:'MEDIUM', goodWithKids:false, specialNeeds:true,  priority:5}),
+      (d37:Dog {id:'D37', name:'Ellie', size:'SMALL',  weightKg:6,  age:2, energy:'LOW',    goodWithKids:true,  specialNeeds:false, priority:7}),
+      (d38:Dog {id:'D38', name:'Leo', size:'LARGE',  weightKg:30, age:6, energy:'HIGH',   goodWithKids:false, specialNeeds:false, priority:6}),
+      (d39:Dog {id:'D39', name:'Lily', size:'MEDIUM', weightKg:18, age:3, energy:'MEDIUM', goodWithKids:true,  specialNeeds:false, priority:8}),
+      (d40:Dog {id:'D40', name:'Ace', size:'LARGE',  weightKg:28, age:4, energy:'LOW',    goodWithKids:false, specialNeeds:true,  priority:7})
+""").run();
+        
+        // ========== SHELTER-DOG ASSIGNMENTS (40 dogs distributed across 15 shelters) ==========
+        neo4j.query("""
+MATCH
+      (a:Shelter {id:'A'}), (b:Shelter {id:'B'}), (c:Shelter {id:'C'}), (h:Shelter {id:'H'}),
+      (d:Shelter {id:'D'}), (e:Shelter {id:'E'}), (f:Shelter {id:'F'}), (g:Shelter {id:'G'}),
+      (i:Shelter {id:'I'}), (j:Shelter {id:'J'}), (k:Shelter {id:'K'}), (l:Shelter {id:'L'}),
+      (m:Shelter {id:'M'}), (n:Shelter {id:'N'}), (o:Shelter {id:'O'}),
+      (d1:Dog {id:'D1'}), (d2:Dog {id:'D2'}), (d3:Dog {id:'D3'}), (d4:Dog {id:'D4'}), (d5:Dog {id:'D5'}),
+      (d6:Dog {id:'D6'}), (d7:Dog {id:'D7'}), (d8:Dog {id:'D8'}), (d9:Dog {id:'D9'}), (d10:Dog {id:'D10'}),
+      (d11:Dog {id:'D11'}), (d12:Dog {id:'D12'}), (d13:Dog {id:'D13'}), (d14:Dog {id:'D14'}), (d15:Dog {id:'D15'}),
+      (d16:Dog {id:'D16'}), (d17:Dog {id:'D17'}), (d18:Dog {id:'D18'}), (d19:Dog {id:'D19'}), (d20:Dog {id:'D20'}),
+      (d21:Dog {id:'D21'}), (d22:Dog {id:'D22'}), (d23:Dog {id:'D23'}), (d24:Dog {id:'D24'}), (d25:Dog {id:'D25'}),
+      (d26:Dog {id:'D26'}), (d27:Dog {id:'D27'}), (d28:Dog {id:'D28'}), (d29:Dog {id:'D29'}), (d30:Dog {id:'D30'}),
+      (d31:Dog {id:'D31'}), (d32:Dog {id:'D32'}), (d33:Dog {id:'D33'}), (d34:Dog {id:'D34'}), (d35:Dog {id:'D35'}),
+      (d36:Dog {id:'D36'}), (d37:Dog {id:'D37'}), (d38:Dog {id:'D38'}), (d39:Dog {id:'D39'}), (d40:Dog {id:'D40'})
+CREATE
+      // Shelter A (3 dogs)
+      (a)-[:HAS_DOG]->(d1),
+      (a)-[:HAS_DOG]->(d2),
+      (a)-[:HAS_DOG]->(d9),
+
+      // Shelter B (3 dogs)
+      (b)-[:HAS_DOG]->(d3),
+      (b)-[:HAS_DOG]->(d10),
+      (b)-[:HAS_DOG]->(d17),
+
+      // Shelter C (3 dogs)
+      (c)-[:HAS_DOG]->(d4),
+      (c)-[:HAS_DOG]->(d11),
+      (c)-[:HAS_DOG]->(d18),
+
+      // Shelter H - Central Hub (4 dogs)
+      (h)-[:HAS_DOG]->(d5),
+      (h)-[:HAS_DOG]->(d6),
+      (h)-[:HAS_DOG]->(d7),
+      (h)-[:HAS_DOG]->(d8),
+
+      // Shelter D (3 dogs)
+      (d)-[:HAS_DOG]->(d12),
+      (d)-[:HAS_DOG]->(d13),
+      (d)-[:HAS_DOG]->(d19),
+
+      // Shelter E (3 dogs)
+      (e)-[:HAS_DOG]->(d14),
+      (e)-[:HAS_DOG]->(d15),
+      (e)-[:HAS_DOG]->(d20),
+
+      // Shelter F (2 dogs)
+      (f)-[:HAS_DOG]->(d16),
+      (f)-[:HAS_DOG]->(d21),
+
+      // Shelter G (3 dogs)
+      (g)-[:HAS_DOG]->(d22),
+      (g)-[:HAS_DOG]->(d23),
+      (g)-[:HAS_DOG]->(d24),
+
+      // Shelter I (3 dogs)
+      (i)-[:HAS_DOG]->(d25),
+      (i)-[:HAS_DOG]->(d26),
+      (i)-[:HAS_DOG]->(d27),
+
+      // Shelter J (2 dogs)
+      (j)-[:HAS_DOG]->(d28),
+      (j)-[:HAS_DOG]->(d29),
+
+      // Shelter K (2 dogs)
+      (k)-[:HAS_DOG]->(d30),
+      (k)-[:HAS_DOG]->(d31),
+
+      // Shelter L (3 dogs)
+      (l)-[:HAS_DOG]->(d32),
+      (l)-[:HAS_DOG]->(d33),
+      (l)-[:HAS_DOG]->(d34),
+
+      // Shelter M (3 dogs)
+      (m)-[:HAS_DOG]->(d35),
+      (m)-[:HAS_DOG]->(d36),
+      (m)-[:HAS_DOG]->(d37),
+
+      // Shelter N (2 dogs)
+      (n)-[:HAS_DOG]->(d38),
+      (n)-[:HAS_DOG]->(d39),
+
+      // Shelter O (2 dogs)
+      (o)-[:HAS_DOG]->(d40),
+      (o)-[:HAS_DOG]->(d1)
+""").run();
+        
+        // ========== ADOPTERS (15 total) - varied profiles for matching algorithms ==========
+        neo4j.query("""
+CREATE
+      (p1:Adopter {id:'P1', name:'Camila', budget:25000, hasYard:true,  hasKids:true,  maxDogs:2}),
+      (p2:Adopter {id:'P2', name:'Lucas', budget:18000, hasYard:false, hasKids:false, maxDogs:1}),
+      (p3:Adopter {id:'P3', name:'Daniela',  budget:30000, hasYard:true,  hasKids:false, maxDogs:3}),
+
+      // New adopters with varied profiles
+      (p4:Adopter {id:'P4', name:'Martin', budget:22000, hasYard:true,  hasKids:true,  maxDogs:2}),
+      (p5:Adopter {id:'P5', name:'Sofia', budget:15000, hasYard:false, hasKids:false, maxDogs:1}),
+      (p6:Adopter {id:'P6', name:'Roberto', budget:35000, hasYard:true,  hasKids:false, maxDogs:4}),
+      (p7:Adopter {id:'P7', name:'Ana', budget:20000, hasYard:true,  hasKids:true,  maxDogs:1}),
+      (p8:Adopter {id:'P8', name:'Diego', budget:28000, hasYard:false, hasKids:false, maxDogs:2}),
+      (p9:Adopter {id:'P9', name:'Julia', budget:40000, hasYard:true,  hasKids:true,  maxDogs:3}),
+      (p10:Adopter {id:'P10', name:'Carlos', budget:12000, hasYard:false, hasKids:false, maxDogs:1}),
+      (p11:Adopter {id:'P11', name:'Valeria', budget:32000, hasYard:true,  hasKids:false, maxDogs:5}),
+      (p12:Adopter {id:'P12', name:'Pedro', budget:24000, hasYard:true,  hasKids:true,  maxDogs:2}),
+      (p13:Adopter {id:'P13', name:'Laura', budget:16000, hasYard:false, hasKids:true,  maxDogs:1}),
+      (p14:Adopter {id:'P14', name:'Andres', budget:45000, hasYard:true,  hasKids:false, maxDogs:4}),
+      (p15:Adopter {id:'P15', name:'Monica', budget:27000, hasYard:true,  hasKids:true,  maxDogs:3})
+""").run();
+        
+        // ========== INITIAL ADOPTIONS (10 adoptions, 30 dogs still available) ==========
+        neo4j.query("""
+MATCH
+      (p1:Adopter {id:'P1'}), (p2:Adopter {id:'P2'}), (p3:Adopter {id:'P3'}),
+      (p4:Adopter {id:'P4'}), (p5:Adopter {id:'P5'}), (p6:Adopter {id:'P6'}),
+      (d1:Dog {id:'D1'}), (d2:Dog {id:'D2'}), (d3:Dog {id:'D3'}), (d4:Dog {id:'D4'}), (d5:Dog {id:'D5'}),
+      (d13:Dog {id:'D13'}), (d22:Dog {id:'D22'}), (d27:Dog {id:'D27'}), (d35:Dog {id:'D35'}), (d9:Dog {id:'D9'})
+CREATE
+      // P1: Camila adopts 2 dogs (has kids, needs goodWithKids dogs)
+      (p1)-[:ADOPTS]->(d1),
+      (p1)-[:ADOPTS]->(d2),
+
+      // P2: Lucas adopts 1 dog (no kids, can handle any)
+      (p2)-[:ADOPTS]->(d3),
+
+      // P3: Daniela adopts 2 dogs (no kids, prefers low maintenance)
+      (p3)-[:ADOPTS]->(d4),
+      (p3)-[:ADOPTS]->(d5),
+
+      // P4: Martin adopts 1 dog (has kids)
+      (p4)-[:ADOPTS]->(d9),
+
+      // P5: Sofia adopts 1 dog (single, small space)
+      (p5)-[:ADOPTS]->(d13),
+
+      // P6: Roberto adopts 3 dogs (large budget, no kids)
+      (p6)-[:ADOPTS]->(d22),
+      (p6)-[:ADOPTS]->(d27),
+      (p6)-[:ADOPTS]->(d35)
+""").run();
+        
+        System.out.println("[SEED] ===== DATABASE SEEDED SUCCESSFULLY =====");
+        System.out.println("[SEED] - 15 Shelters (A-O) with varied capacities");
+        System.out.println("[SEED] - 40 Dogs with diverse characteristics for algorithm testing");
+        System.out.println("[SEED] - 15 Adopters with varied profiles (budget, yard, kids, maxDogs)");
+        System.out.println("[SEED] - 39 NEAR relationships creating a dense shelter network");
+        System.out.println("[SEED] - 40 HAS_DOG relationships distributing dogs across shelters");
+        System.out.println("[SEED] - 10 initial ADOPTS relationships (30 dogs available for matching)");
+        System.out.println("[SEED] =========================================");
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/AdopterController.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/AdopterController.java
new file mode 100644
index 000000000..3ccfb7d55
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/AdopterController.java
@@ -0,0 +1,27 @@
+package com.programacion3.adoptme.controller;
+
+import com.programacion3.adoptme.domain.Adopter;
+import com.programacion3.adoptme.repo.AdopterRepository; // usa 'repo' si ese es tu package
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/adopters")
+@RequiredArgsConstructor
+public class AdopterController {
+
+    private final AdopterRepository adopterRepository;
+
+    @GetMapping
+    public List<Adopter> getAll() {
+        return adopterRepository.findAll();
+    }
+
+
+    @PostMapping
+    public Adopter create(@RequestBody Adopter adopter) {
+        return adopterRepository.save(adopter);
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/AdoptionsController.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/AdoptionsController.java
new file mode 100644
index 000000000..b70bd2859
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/AdoptionsController.java
@@ -0,0 +1,249 @@
+package com.programacion3.adoptme.controller;
+
+import com.programacion3.adoptme.domain.Dog;
+import com.programacion3.adoptme.exception.ResourceNotFoundException;
+import com.programacion3.adoptme.repo.AdopterRepository;
+import com.programacion3.adoptme.repo.DogRepository;
+import com.programacion3.adoptme.service.ScorerService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/adoptions")
+@RequiredArgsConstructor
+public class AdoptionsController {
+
+    private final AdopterRepository adopterRepository;
+    private final DogRepository dogRepository;
+    private final ScorerService scorerService;
+    private final com.programacion3.adoptme.service.BacktrackingService backtrackingService;
+
+    /**
+     * Algoritmo Greedy: Asigna perros a un adoptante maximizando el score
+     * Considera: presupuesto, jardín, niños, energía del perro
+     * GET /adoptions/greedy?adopterId=P1
+     */
+    @GetMapping("/greedy")
+    public ResponseEntity<GreedyResponse> greedyAdoption(
+            @RequestParam String adopterId
+    ) {
+        // Buscar adoptante
+        var adopter = adopterRepository.findById(adopterId)
+                .orElseThrow(() -> new ResourceNotFoundException("Adopter not found: " + adopterId));
+
+        // Obtener todos los perros disponibles
+        List<Dog> allDogs = dogRepository.findAll();
+
+        if (allDogs.isEmpty()) {
+            return ResponseEntity.ok(new GreedyResponse(
+                    "No dogs available for adoption",
+                    adopterId,
+                    adopter.getName(),
+                    List.of(),
+                    0.0,
+                    0.0
+            ));
+        }
+
+        // Convertir a formato del ScorerService
+        List<ScorerService.Dog> candidates = allDogs.stream()
+                .map(d -> new ScorerService.Dog(
+                        d.getId(),
+                        d.getGoodWithKids() != null && d.getGoodWithKids(),
+                        "LARGE".equalsIgnoreCase(d.getSize()), // perros grandes necesitan jardín
+                        mapEnergy(d.getEnergy()),
+                        mapSize(d.getSize()),
+                        estimateCost(d) // costo estimado por adopción
+                ))
+                .collect(Collectors.toList());
+
+        // Ejecutar algoritmo Greedy
+        var result = scorerService.scoreAndAssign(
+                candidates,
+                adopter.getHasKids() != null && adopter.getHasKids(),
+                adopter.getHasYard() != null && adopter.getHasYard(),
+                adopter.getMaxDogs() != null ? adopter.getMaxDogs() : 1,
+                adopter.getBudget() != null ? adopter.getBudget() : 20000.0
+        );
+
+        // Formatear respuesta
+        List<AssignedDog> assigned = result.assigned.stream()
+                .map(d -> new AssignedDog(d.id, findDogName(allDogs, d.id), d.cost))
+                .collect(Collectors.toList());
+
+        return ResponseEntity.ok(new GreedyResponse(
+                "Greedy algorithm executed successfully",
+                adopterId,
+                adopter.getName(),
+                assigned,
+                result.totalScore,
+                result.totalCost
+        ));
+    }
+
+    /**
+     * Algoritmo Backtracking: Asigna múltiples perros a múltiples adoptantes
+     * respetando TODAS las restricciones y maximizando satisfacción total.
+     *
+     * Considera restricciones de:
+     * - Presupuesto
+     * - Capacidad máxima de perros
+     * - Compatibilidad con niños
+     * - Necesidad de jardín
+     * - Preferencia de energía
+     *
+     * GET /adoptions/constraints/backtracking
+     */
+    @GetMapping("/constraints/backtracking")
+    public ResponseEntity<BacktrackingResponse> backtrackingAdoption() {
+        // Obtener todos los perros y adoptantes
+        List<Dog> allDogs = dogRepository.findAll();
+        var allAdopters = adopterRepository.findAll();
+
+        if (allDogs.isEmpty()) {
+            return ResponseEntity.ok(new BacktrackingResponse(
+                    "No dogs available for adoption",
+                    Map.of(),
+                    0.0
+            ));
+        }
+
+        if (allAdopters.isEmpty()) {
+            return ResponseEntity.ok(new BacktrackingResponse(
+                    "No adopters available",
+                    Map.of(),
+                    0.0
+            ));
+        }
+
+        // Convertir perros al formato del servicio
+        List<com.programacion3.adoptme.service.BacktrackingService.Dog> dogs = allDogs.stream()
+                .map(d -> new com.programacion3.adoptme.service.BacktrackingService.Dog(
+                        d.getId(),
+                        d.getGoodWithKids() != null && d.getGoodWithKids(),
+                        "LARGE".equalsIgnoreCase(d.getSize()),
+                        mapEnergy(d.getEnergy()),
+                        estimateCost(d)
+                ))
+                .toList();
+
+        // Convertir adoptantes al formato del servicio
+        List<com.programacion3.adoptme.service.BacktrackingService.Adopter> adopters = allAdopters.stream()
+                .map(a -> new com.programacion3.adoptme.service.BacktrackingService.Adopter(
+                        a.getId(),
+                        a.getName(),
+                        a.getHasKids() != null && a.getHasKids(),
+                        a.getHasYard() != null && a.getHasYard(),
+                        a.getMaxDogs() != null ? a.getMaxDogs() : 1,
+                        a.getBudget() != null ? a.getBudget() : 20000.0,
+                        5 // energía preferida default (media)
+                ))
+                .toList();
+
+        // Ejecutar algoritmo de backtracking
+        var result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Formatear respuesta
+        Map<String, AdopterAssignment> assignments = new HashMap<>();
+
+        for (var adopter : allAdopters) {
+            List<String> dogIds = result.assignments.getOrDefault(adopter.getId(), List.of());
+
+            if (!dogIds.isEmpty()) {
+                List<AssignedDog> assignedDogs = dogIds.stream()
+                        .map(dogId -> {
+                            String dogName = findDogName(allDogs, dogId);
+                            double cost = estimateCost(allDogs.stream()
+                                    .filter(d -> d.getId().equals(dogId))
+                                    .findFirst()
+                                    .orElse(null));
+                            return new AssignedDog(dogId, dogName, cost);
+                        })
+                        .toList();
+
+                assignments.put(adopter.getId(), new AdopterAssignment(
+                        adopter.getId(),
+                        adopter.getName(),
+                        assignedDogs
+                ));
+            }
+        }
+
+        return ResponseEntity.ok(new BacktrackingResponse(
+                "Backtracking algorithm completed successfully",
+                assignments,
+                result.totalScore
+        ));
+    }
+
+    // Métodos auxiliares
+    private int mapEnergy(String energy) {
+        if (energy == null) return 5;
+        return switch (energy.toUpperCase()) {
+            case "LOW" -> 2;
+            case "MEDIUM" -> 5;
+            case "HIGH" -> 8;
+            default -> 5;
+        };
+    }
+
+    private int mapSize(String size) {
+        if (size == null) return 2;
+        return switch (size.toUpperCase()) {
+            case "SMALL" -> 1;
+            case "MEDIUM" -> 2;
+            case "LARGE" -> 3;
+            default -> 2;
+        };
+    }
+
+    private double estimateCost(Dog dog) {
+        // Costo base + extra por tamaño y necesidades especiales
+        double baseCost = 5000.0;
+        double sizeCost = mapSize(dog.getSize()) * 2000.0;
+        double specialNeedsCost = (dog.getSpecialNeeds() != null && dog.getSpecialNeeds()) ? 5000.0 : 0.0;
+        return baseCost + sizeCost + specialNeedsCost;
+    }
+
+    private String findDogName(List<Dog> dogs, String id) {
+        return dogs.stream()
+                .filter(d -> d.getId().equals(id))
+                .map(Dog::getName)
+                .findFirst()
+                .orElse("Unknown");
+    }
+
+    // DTOs
+    record GreedyResponse(
+            String message,
+            String adopterId,
+            String adopterName,
+            List<AssignedDog> assignedDogs,
+            double totalScore,
+            double totalCost
+    ) {}
+
+    record BacktrackingResponse(
+            String message,
+            Map<String, AdopterAssignment> assignments,
+            double totalScore
+    ) {}
+
+    record AdopterAssignment(
+            String adopterId,
+            String adopterName,
+            List<AssignedDog> assignedDogs
+    ) {}
+
+    record AssignedDog(
+            String dogId,
+            String dogName,
+            double cost
+    ) {}
+}
\ No newline at end of file
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/DogController.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/DogController.java
new file mode 100644
index 000000000..e77f905ed
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/DogController.java
@@ -0,0 +1,83 @@
+package com.programacion3.adoptme.controller;
+
+import com.programacion3.adoptme.domain.Dog;
+import com.programacion3.adoptme.repo.DogRepository;
+import com.programacion3.adoptme.service.SortService;
+import org.springframework.web.bind.annotation.*;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/dogs")
+@RequiredArgsConstructor
+public class DogController {
+    private final DogRepository dogRepository;
+    private final SortService sortService;
+
+    /**
+     * Lista todos los perros
+     * GET /dogs
+     */
+    @GetMapping
+    public List<Dog> all() {
+        return dogRepository.findAll();
+    }
+
+    /**
+     * Ordena perros usando MergeSort o QuickSort (Divide y Vencerás)
+     * GET /dogs/sort?criteria=priority&algorithm=quicksort
+     * GET /dogs/sort?criteria=age&algorithm=mergesort
+     * GET /dogs/sort?criteria=weight
+     */
+    @GetMapping("/sort")
+    public ResponseEntity<?> sortDogs(
+            @RequestParam(defaultValue = "priority") String criteria,
+            @RequestParam(defaultValue = "mergesort") String algorithm
+    ) {
+        try {
+            // Obtener todos los perros
+            List<Dog> dogs = dogRepository.findAll();
+
+            if (dogs.isEmpty()) {
+                return ResponseEntity.ok(new SortResponse(
+                        "No dogs found",
+                        criteria,
+                        algorithm,
+                        List.of()
+                ));
+            }
+
+            // Ordenar usando el servicio y algoritmo seleccionado
+            sortService.sortDogs(dogs, criteria, algorithm);
+
+            String algorithmName = "quicksort".equalsIgnoreCase(algorithm) ? "QuickSort" : "MergeSort";
+
+            return ResponseEntity.ok(new SortResponse(
+                    "Dogs sorted by " + criteria + " using " + algorithmName,
+                    criteria,
+                    algorithm,
+                    dogs
+            ));
+
+        } catch (IllegalArgumentException e) {
+            return ResponseEntity.badRequest()
+                    .body(Map.of(
+                            "error", e.getMessage(),
+                            "validCriteria", List.of("priority", "age", "weight"),
+                            "validAlgorithms", List.of("mergesort", "quicksort")
+                    ));
+        }
+    }
+
+    // DTO para respuesta
+    record SortResponse(
+            String message,
+            String criteria,
+            String algorithm,
+            List<Dog> dogs
+    ) {}
+}
\ No newline at end of file
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/GraphController.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/GraphController.java
new file mode 100644
index 000000000..9dc90d679
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/GraphController.java
@@ -0,0 +1,41 @@
+package com.programacion3.adoptme.controller;
+
+import com.programacion3.adoptme.dto.PathResponse;
+import com.programacion3.adoptme.service.GraphService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/graph")
+@RequiredArgsConstructor
+public class GraphController {
+
+    private final GraphService graphService;
+
+    /**
+     * Ejemplo:
+     *  GET /graph/reachable?from=A&to=D
+     *  GET /graph/reachable?from=A&to=D&method=dfs
+     */
+    @GetMapping("/reachable")
+    public ResponseEntity<PathResponse> reachable(
+            @RequestParam String from,
+            @RequestParam String to,
+            @RequestParam(defaultValue = "bfs") String method
+    ) {
+        var m = method.trim().toLowerCase();
+        switch (m) {
+            case "dfs" -> {
+                var path = graphService.dfsPath(from, to);
+                var steps = path.isEmpty() ? 0 : path.size() - 1;
+                return ResponseEntity.ok(new PathResponse(!path.isEmpty(), "DFS", path, steps, 0));
+            }
+            default -> {
+                var path = graphService.bfsPath(from, to);
+                var steps = path.isEmpty() ? 0 : path.size() - 1;
+                return ResponseEntity.ok(new PathResponse(!path.isEmpty(), "BFS", path, steps, 0));
+            }
+        }
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/HealthController.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/HealthController.java
new file mode 100644
index 000000000..77a4219d6
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/HealthController.java
@@ -0,0 +1,12 @@
+package com.programacion3.adoptme.controller;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class HealthController {
+
+    @GetMapping("/ping")
+    public String ping() {
+        return "OK 🐶 AdoptMe funcionando!";
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/NetworkController.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/NetworkController.java
new file mode 100644
index 000000000..c14185b50
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/NetworkController.java
@@ -0,0 +1,125 @@
+package com.programacion3.adoptme.controller;
+
+import com.programacion3.adoptme.service.GraphLoader;
+import com.programacion3.adoptme.service.MSTService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/network")
+@RequiredArgsConstructor
+public class NetworkController {
+
+    private final MSTService mstService;
+    private final GraphLoader graphLoader;
+
+    /**
+     * Obtiene todas las conexiones entre shelters para visualización del grafo
+     * GET /network/graph
+     */
+    @GetMapping("/graph")
+    public ResponseEntity<GraphResponse> getGraph() {
+        // Cargar todos los shelters
+        var shelterIds = graphLoader.loadAllShelterIds();
+
+        if (shelterIds.isEmpty()) {
+            return ResponseEntity.ok(new GraphResponse(
+                    "No shelters found",
+                    List.of(),
+                    List.of()
+            ));
+        }
+
+        // Cargar todas las aristas
+        var edges = graphLoader.loadMSTEdges();
+
+        // Formatear aristas (evitar duplicados para grafo no dirigido)
+        List<EdgeDTO> formattedEdges = edges.stream()
+                .map(e -> new EdgeDTO(e.a, e.b, e.weight))
+                .distinct()
+                .collect(Collectors.toList());
+
+        // Convertir shelterIds a lista
+        List<String> shelterList = List.copyOf(shelterIds);
+
+        return ResponseEntity.ok(new GraphResponse(
+                "Graph data loaded successfully",
+                shelterList,
+                formattedEdges
+        ));
+    }
+
+    /**
+     * Minimum Spanning Tree usando Kruskal o Prim
+     * Conecta todos los refugios con la menor distancia total
+     * GET /network/mst?algorithm=kruskal|prim (default: kruskal)
+     */
+    @GetMapping("/mst")
+    public ResponseEntity<MSTResponse> mst(
+            @RequestParam(defaultValue = "kruskal") String algorithm
+    ) {
+        // Cargar todos los shelters
+        var shelterIds = graphLoader.loadAllShelterIds();
+
+        if (shelterIds.isEmpty()) {
+            return ResponseEntity.ok(new MSTResponse(
+                    "No shelters found",
+                    List.of(),
+                    0.0,
+                    algorithm
+            ));
+        }
+
+        // Cargar aristas
+        var edges = graphLoader.loadMSTEdges();
+
+        // Ejecutar algoritmo seleccionado
+        MSTService.MSTResult result;
+        String algorithmUsed;
+
+        if ("prim".equalsIgnoreCase(algorithm)) {
+            result = mstService.computeWithPrim(shelterIds, edges);
+            algorithmUsed = "Prim";
+        } else {
+            result = mstService.compute(shelterIds, edges);
+            algorithmUsed = "Kruskal";
+        }
+
+        // Formatear respuesta
+        List<EdgeDTO> formattedEdges = result.edges.stream()
+                .map(e -> new EdgeDTO(e.a, e.b, e.weight))
+                .collect(Collectors.toList());
+
+        return ResponseEntity.ok(new MSTResponse(
+                "MST computed using " + algorithmUsed + "'s algorithm",
+                formattedEdges,
+                result.totalWeight,
+                algorithmUsed
+        ));
+    }
+
+    // DTOs para respuesta
+    record GraphResponse(
+            String message,
+            List<String> nodes,
+            List<EdgeDTO> edges
+    ) {}
+
+    record MSTResponse(
+            String message,
+            List<EdgeDTO> edges,
+            double totalWeight,
+            String algorithm
+    ) {}
+
+    record EdgeDTO(
+            String from,
+            String to,
+            double weight
+    ) {}
+}
\ No newline at end of file
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/RoutesController.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/RoutesController.java
new file mode 100644
index 000000000..19558e938
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/RoutesController.java
@@ -0,0 +1,144 @@
+package com.programacion3.adoptme.controller;
+
+import com.programacion3.adoptme.dto.PathResponse;
+import com.programacion3.adoptme.dto.TspResponse;
+import com.programacion3.adoptme.service.GraphLoader;
+import com.programacion3.adoptme.service.ShortestPathService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@RestController
+@RequestMapping("/routes")
+@RequiredArgsConstructor
+public class RoutesController {
+
+    private final ShortestPathService shortestPathService;
+    private final GraphLoader graphLoader;
+    private final com.programacion3.adoptme.service.TSPService tspService;
+
+    /**
+     * Dijkstra - Encuentra el camino más corto considerando distancias
+     * GET /routes/shortest?from=A&to=C
+     */
+    @GetMapping("/shortest")
+    public ResponseEntity<PathResponse> shortestRoute(
+            @RequestParam String from,
+            @RequestParam String to
+    ) {
+        // Validaciones
+        if (from == null || to == null || from.isBlank() || to.isBlank()) {
+            return ResponseEntity.badRequest()
+                    .body(new PathResponse(false, "Dijkstra", null, 0, 0.0));
+        }
+
+        // Cargar aristas con pesos desde Neo4j
+        var edges = graphLoader.loadWeightedEdges();
+
+        // Ejecutar Dijkstra
+        var result = shortestPathService.shortestPath(from, to, edges);
+
+        // Si no hay camino
+        if (result.path.isEmpty() || Double.isInfinite(result.cost)) {
+            return ResponseEntity.ok(new PathResponse(
+                    false,
+                    "Dijkstra",
+                    null,
+                    0,
+                    0.0
+            ));
+        }
+
+        // Respuesta exitosa
+        return ResponseEntity.ok(new PathResponse(
+                true,
+                "Dijkstra",
+                result.path,
+                result.path.size() - 1,
+                result.cost
+        ));
+    }
+
+    /**
+     * TSP (Travelling Salesman Problem) usando Branch & Bound
+     *
+     * Encuentra la ruta más corta para visitar todos los refugios especificados
+     * exactamente una vez y regresar al punto de inicio.
+     *
+     * GET /routes/tsp/bnb?nodes=A,B,C,H
+     * Si no se especifican nodos, usa todos los refugios disponibles.
+     *
+     * @param nodes lista de IDs de nodos separados por comas (opcional)
+     * @return tour óptimo y distancia total
+     */
+    @GetMapping("/tsp/bnb")
+    public ResponseEntity<TspResponse> tspBranchBound(
+            @RequestParam(required = false) String nodes
+    ) {
+        // Determinar qué nodos visitar
+        List<String> nodeList;
+
+        if (nodes != null && !nodes.isBlank()) {
+            // Usar nodos especificados
+            nodeList = Arrays.asList(nodes.split(","));
+            nodeList = nodeList.stream().map(String::trim).toList();
+        } else {
+            // Usar todos los shelters
+            nodeList = new ArrayList<>(graphLoader.loadAllShelterIds());
+        }
+
+        if (nodeList.isEmpty()) {
+            return ResponseEntity.ok(
+                    TspResponse.builder()
+                            .route(List.of())
+                            .totalDistanceKm(0)
+                            .build()
+            );
+        }
+
+        if (nodeList.size() == 1) {
+            return ResponseEntity.ok(
+                    TspResponse.builder()
+                            .route(nodeList)
+                            .totalDistanceKm(0)
+                            .build()
+            );
+        }
+
+        // Cargar aristas con distancias
+        var rawEdges = graphLoader.loadWeightedEdges();
+
+        // Convertir al formato del TSPService
+        List<com.programacion3.adoptme.service.TSPService.Edge> edges = rawEdges.stream()
+                .map(e -> new com.programacion3.adoptme.service.TSPService.Edge(
+                        e.from,
+                        e.to,
+                        e.weight
+                ))
+                .toList();
+
+        // Ejecutar algoritmo de Branch & Bound
+        var result = tspService.solveTSP(nodeList, edges);
+
+        // Verificar si se encontró una solución
+        if (result.route.isEmpty() || Double.isInfinite(result.totalDistance)) {
+            return ResponseEntity.ok(
+                    TspResponse.builder()
+                            .route(null)
+                            .totalDistanceKm(null)
+                            .build()
+            );
+        }
+
+        return ResponseEntity.ok(
+                TspResponse.builder()
+                        .route(result.route)
+                        .totalDistanceKm((int) Math.round(result.totalDistance))
+                        .build()
+        );
+    }
+}
\ No newline at end of file
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/ShelterController.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/ShelterController.java
new file mode 100644
index 000000000..9ddd57560
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/ShelterController.java
@@ -0,0 +1,16 @@
+package com.programacion3.adoptme.controller;
+
+import com.programacion3.adoptme.domain.Shelter;
+import com.programacion3.adoptme.repo.ShelterRepository;
+import org.springframework.web.bind.annotation.*;
+import java.util.List;
+
+@RestController
+@RequestMapping("/shelters")
+public class ShelterController {
+    private final ShelterRepository repo;
+    public ShelterController(ShelterRepository repo) { this.repo = repo; }
+
+    @GetMapping
+    public List<Shelter> all() { return repo.findAll(); }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/TransportController.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/TransportController.java
new file mode 100644
index 000000000..8f7bf52e5
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/controller/TransportController.java
@@ -0,0 +1,101 @@
+package com.programacion3.adoptme.controller;
+
+import com.programacion3.adoptme.domain.Dog;
+import com.programacion3.adoptme.repo.DogRepository;
+import com.programacion3.adoptme.service.TransportService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * Controlador para optimización de transporte de perros.
+ * Usa Programación Dinámica (problema de la mochila 0/1) para seleccionar
+ * el mejor conjunto de perros dado una capacidad de vehículo limitada.
+ */
+@RestController
+@RequestMapping("/transport")
+@RequiredArgsConstructor
+public class TransportController {
+
+    private final TransportService transportService;
+    private final DogRepository dogRepository;
+
+    /**
+     * Optimiza el transporte de perros usando Programación Dinámica (Knapsack).
+     *
+     * Dado un vehículo con capacidad limitada, selecciona el conjunto óptimo
+     * de perros que maximiza la prioridad total sin exceder la capacidad.
+     *
+     * GET /transport/optimal-dp?capacityKg=50
+     *
+     * @param capacityKg capacidad del vehículo en kilogramos
+     * @return conjunto óptimo de perros para transportar
+     */
+    @GetMapping("/optimal-dp")
+    public ResponseEntity<?> optimalTransport(
+            @RequestParam(defaultValue = "50") int capacityKg
+    ) {
+        if (capacityKg <= 0) {
+            return ResponseEntity.badRequest()
+                    .body(new TransportResponse(
+                            "Invalid capacity: must be greater than 0",
+                            capacityKg,
+                            List.of(),
+                            0,
+                            0
+                    ));
+        }
+
+        // Obtener todos los perros disponibles
+        List<Dog> allDogs = dogRepository.findAll();
+
+        if (allDogs.isEmpty()) {
+            return ResponseEntity.ok(new TransportResponse(
+                    "No dogs available for transport",
+                    capacityKg,
+                    List.of(),
+                    0,
+                    0
+            ));
+        }
+
+        // Ejecutar algoritmo de programación dinámica
+        TransportService.KnapsackResult result = transportService.optimizeTransport(allDogs, capacityKg);
+
+        // Convertir perros a DTO simple
+        List<DogDTO> selectedDogs = result.selectedDogs.stream()
+                .map(dog -> new DogDTO(
+                        dog.getId(),
+                        dog.getName(),
+                        dog.getWeight(),
+                        dog.getPriority()
+                ))
+                .toList();
+
+        return ResponseEntity.ok(new TransportResponse(
+                "Optimal transport computed using Dynamic Programming (Knapsack)",
+                capacityKg,
+                selectedDogs,
+                result.totalPriority,
+                result.totalWeight
+        ));
+    }
+
+    // DTOs para respuesta
+    record TransportResponse(
+            String message,
+            int vehicleCapacityKg,
+            List<DogDTO> selectedDogs,
+            int totalPriority,
+            int totalWeightKg
+    ) {}
+
+    record DogDTO(
+            String id,
+            String name,
+            int weightKg,
+            int priority
+    ) {}
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/domain/Adopter.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/domain/Adopter.java
new file mode 100644
index 000000000..2d5e4f20c
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/domain/Adopter.java
@@ -0,0 +1,17 @@
+package com.programacion3.adoptme.domain;
+
+import org.springframework.data.neo4j.core.schema.Id;
+import org.springframework.data.neo4j.core.schema.Node;
+import lombok.*;
+
+@Node("Adopter")
+@Data @NoArgsConstructor @AllArgsConstructor @Builder
+public class Adopter {
+    @Id
+    private String id;
+    private String name;
+    private Integer budget;
+    private Boolean hasYard;
+    private Boolean hasKids;
+    private Integer maxDogs;
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/domain/Dog.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/domain/Dog.java
new file mode 100644
index 000000000..eda662218
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/domain/Dog.java
@@ -0,0 +1,25 @@
+package com.programacion3.adoptme.domain;
+
+import org.springframework.data.neo4j.core.schema.Id;
+import org.springframework.data.neo4j.core.schema.Node;
+import lombok.*;
+
+@Node("Dog")
+@Data @NoArgsConstructor @AllArgsConstructor @Builder
+public class Dog {
+    @Id
+    private String id;
+    private String name;
+    private String size;       // SMALL, MEDIUM, LARGE
+    private Integer weightKg;
+    private Integer age;
+    private String energy;     // LOW, MEDIUM, HIGH
+    private Boolean goodWithKids;
+    private Boolean specialNeeds;
+    private Integer priority;  // Para priorización de adopción
+
+    // Método personalizado para mantener compatibilidad con código existente
+    public Integer getWeight() {
+        return this.weightKg;
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/domain/Shelter.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/domain/Shelter.java
new file mode 100644
index 000000000..c764e6f4a
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/domain/Shelter.java
@@ -0,0 +1,14 @@
+package com.programacion3.adoptme.domain;
+
+import org.springframework.data.neo4j.core.schema.Id;
+import org.springframework.data.neo4j.core.schema.Node;
+import lombok.*;
+
+@Node("Shelter")
+@Data @NoArgsConstructor @AllArgsConstructor @Builder
+public class Shelter {
+    @Id
+    private String id;
+    private String name;
+    private Integer capacity;
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/dto/AdoptionResponse.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/dto/AdoptionResponse.java
new file mode 100644
index 000000000..52812a38e
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/dto/AdoptionResponse.java
@@ -0,0 +1,13 @@
+package com.programacion3.adoptme.dto;
+
+import lombok.*;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class AdoptionResponse {
+    private String adopterId;  
+    private String dogId;      
+    private String message;    
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/dto/PathResponse.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/dto/PathResponse.java
new file mode 100644
index 000000000..798b698d9
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/dto/PathResponse.java
@@ -0,0 +1,11 @@
+package com.programacion3.adoptme.dto;
+
+import java.util.List;
+
+public record PathResponse(
+        boolean exists,
+        String method,
+        List<String> path,
+        int steps,
+        double totalWeight
+) {}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/dto/TspResponse.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/dto/TspResponse.java
new file mode 100644
index 000000000..216548f61
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/dto/TspResponse.java
@@ -0,0 +1,14 @@
+package com.programacion3.adoptme.dto;
+
+import lombok.*;
+
+import java.util.List;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class TspResponse {
+    private List<String> route;     
+    private Integer totalDistanceKm; 
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/exception/ApiExceptionHandler.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/exception/ApiExceptionHandler.java
new file mode 100644
index 000000000..e403678d1
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/exception/ApiExceptionHandler.java
@@ -0,0 +1,54 @@
+package com.programacion3.adoptme.exception;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+
+import java.time.LocalDateTime;
+
+@RestControllerAdvice
+public class ApiExceptionHandler {
+
+    // Maneja recursos no encontrados
+    @ExceptionHandler(ResourceNotFoundException.class)
+    public ResponseEntity<ErrorResponse> handleNotFound(ResourceNotFoundException ex) {
+        return ResponseEntity.status(HttpStatus.NOT_FOUND)
+                .body(new ErrorResponse(LocalDateTime.now(), HttpStatus.NOT_FOUND.value(), ex.getMessage()));
+    }
+
+    // Maneja errores de validación
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public ResponseEntity<ErrorResponse> handleValidation(MethodArgumentNotValidException ex) {
+        String message = ex.getBindingResult().getFieldErrors()
+                .stream()
+                .map(err -> err.getField() + ": " + err.getDefaultMessage())
+                .reduce((m1,m2) -> m1 + "; " + m2)
+                .orElse(ex.getMessage());
+
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
+                .body(new ErrorResponse(LocalDateTime.now(), HttpStatus.BAD_REQUEST.value(), message));
+    }
+
+    // Maneja cualquier error no previsto
+    @ExceptionHandler(Exception.class)
+    public ResponseEntity<ErrorResponse> handleGeneric(Exception ex) {
+        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                .body(new ErrorResponse(LocalDateTime.now(), HttpStatus.INTERNAL_SERVER_ERROR.value(), ex.getMessage()));
+    }
+
+}
+
+// Clase interna para formato de error estandarizado
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+class ErrorResponse {
+    private LocalDateTime timestamp;
+    private int status;
+    private String message;
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/exception/ResourceNotFoundException.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/exception/ResourceNotFoundException.java
new file mode 100644
index 000000000..f2183b8b0
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/exception/ResourceNotFoundException.java
@@ -0,0 +1,7 @@
+package com.programacion3.adoptme.exception;
+
+public class ResourceNotFoundException extends RuntimeException {
+    public ResourceNotFoundException(String msg) {
+        super(msg);
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/repo/AdopterRepository.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/repo/AdopterRepository.java
new file mode 100644
index 000000000..e6abc7be2
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/repo/AdopterRepository.java
@@ -0,0 +1,6 @@
+package com.programacion3.adoptme.repo;
+
+import com.programacion3.adoptme.domain.Adopter;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+
+public interface AdopterRepository extends Neo4jRepository<Adopter, String> {}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/repo/DogRepository.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/repo/DogRepository.java
new file mode 100644
index 000000000..b8b47abf9
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/repo/DogRepository.java
@@ -0,0 +1,6 @@
+package com.programacion3.adoptme.repo;
+
+import com.programacion3.adoptme.domain.Dog;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+
+public interface DogRepository extends Neo4jRepository<Dog, String> {}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/repo/ShelterRepository.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/repo/ShelterRepository.java
new file mode 100644
index 000000000..d8f89102c
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/repo/ShelterRepository.java
@@ -0,0 +1,6 @@
+package com.programacion3.adoptme.repo;
+
+import com.programacion3.adoptme.domain.Shelter;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+
+public interface ShelterRepository extends Neo4jRepository<Shelter, String> {}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/BacktrackingService.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/BacktrackingService.java
new file mode 100644
index 000000000..55f83d939
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/BacktrackingService.java
@@ -0,0 +1,265 @@
+package com.programacion3.adoptme.service;
+
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+
+/**
+ * Servicio que implementa Backtracking para asignar perros a adoptantes
+ * con restricciones de compatibilidad, presupuesto y capacidad.
+ *
+ * Problema: Asignar N perros a M adoptantes de forma que:
+ * - Cada perro se asigna a máximo un adoptante
+ * - Se respetan restricciones de presupuesto, capacidad y compatibilidad
+ * - Se maximiza la satisfacción total
+ */
+@Service
+public class BacktrackingService {
+
+    /**
+     * Información de un perro para asignación
+     */
+    public static class Dog {
+        public final String id;
+        public final boolean goodWithKids;
+        public final boolean needsGarden;
+        public final int energy;
+        public final double cost;
+
+        public Dog(String id, boolean goodWithKids, boolean needsGarden, int energy, double cost) {
+            this.id = id;
+            this.goodWithKids = goodWithKids;
+            this.needsGarden = needsGarden;
+            this.energy = energy;
+            this.cost = cost;
+        }
+    }
+
+    /**
+     * Información de un adoptante
+     */
+    public static class Adopter {
+        public final String id;
+        public final String name;
+        public final boolean hasKids;
+        public final boolean hasGarden;
+        public final int maxDogs;
+        public final double budget;
+        public final int preferredEnergy; // 1-10
+
+        public Adopter(String id, String name, boolean hasKids, boolean hasGarden,
+                       int maxDogs, double budget, int preferredEnergy) {
+            this.id = id;
+            this.name = name;
+            this.hasKids = hasKids;
+            this.hasGarden = hasGarden;
+            this.maxDogs = maxDogs;
+            this.budget = budget;
+            this.preferredEnergy = preferredEnergy;
+        }
+    }
+
+    /**
+     * Asignación: adopterId -> lista de dogIds
+     */
+    public static class Assignment {
+        public final Map<String, List<String>> assignments; // adopterId -> [dogIds]
+        public final double totalScore;
+
+        public Assignment(Map<String, List<String>> assignments, double totalScore) {
+            this.assignments = assignments;
+            this.totalScore = totalScore;
+        }
+    }
+
+    /**
+     * Encuentra la mejor asignación usando backtracking.
+     *
+     * @param dogs lista de perros disponibles
+     * @param adopters lista de adoptantes
+     * @return mejor asignación encontrada
+     */
+    public Assignment findBestAssignment(List<Dog> dogs, List<Adopter> adopters) {
+        if (dogs.isEmpty() || adopters.isEmpty()) {
+            return new Assignment(new HashMap<>(), 0.0);
+        }
+
+        // OPTIMIZATION: Limit to first 20 dogs to keep execution time reasonable
+        // With 30+ dogs and 15 adopters, complexity becomes too high
+        List<Dog> limitedDogs = dogs.size() > 20 ? dogs.subList(0, 20) : dogs;
+
+        // Estado inicial: ningún perro asignado
+        Map<String, List<String>> currentAssignment = new HashMap<>();
+        for (Adopter a : adopters) {
+            currentAssignment.put(a.id, new ArrayList<>());
+        }
+
+        Map<String, Double> currentCost = new HashMap<>();
+        for (Adopter a : adopters) {
+            currentCost.put(a.id, 0.0);
+        }
+
+        // Variables para la mejor solución encontrada
+        BestSolution best = new BestSolution();
+        best.startTime = System.currentTimeMillis();
+        best.timeoutMs = 5000; // 5 second timeout
+
+        // Iniciar backtracking
+        backtrack(0, limitedDogs, adopters, currentAssignment, currentCost, 0.0, best);
+
+        System.out.println("[BACKTRACKING] Explored " + best.nodesExplored + " nodes");
+        System.out.println("[BACKTRACKING] Best score: " + best.score);
+
+        return new Assignment(best.assignments, best.score);
+    }
+
+    /**
+     * Clase auxiliar para mantener la mejor solución
+     */
+    private static class BestSolution {
+        Map<String, List<String>> assignments = new HashMap<>();
+        double score = 0.0;
+        long startTime = 0;
+        long timeoutMs = 5000;
+        int nodesExplored = 0;
+
+        boolean isTimeout() {
+            return System.currentTimeMillis() - startTime > timeoutMs;
+        }
+    }
+
+    /**
+     * Algoritmo de backtracking recursivo.
+     *
+     * @param dogIndex índice del perro actual a asignar
+     * @param dogs lista de perros
+     * @param adopters lista de adoptantes
+     * @param currentAssignment asignación actual
+     * @param currentCost costo acumulado por adoptante
+     * @param currentScore score total actual
+     * @param best mejor solución encontrada hasta ahora
+     */
+    private void backtrack(
+            int dogIndex,
+            List<Dog> dogs,
+            List<Adopter> adopters,
+            Map<String, List<String>> currentAssignment,
+            Map<String, Double> currentCost,
+            double currentScore,
+            BestSolution best
+    ) {
+        // Check timeout
+        if (best.isTimeout()) {
+            return;
+        }
+
+        best.nodesExplored++;
+
+        // Caso base: todos los perros fueron considerados
+        if (dogIndex == dogs.size()) {
+            // Si esta solución es mejor, guardarla
+            if (currentScore > best.score) {
+                best.score = currentScore;
+                best.assignments = deepCopy(currentAssignment);
+            }
+            return;
+        }
+
+        Dog dog = dogs.get(dogIndex);
+
+        // Opción 1: No asignar este perro a nadie (puede quedar sin adoptar)
+        backtrack(dogIndex + 1, dogs, adopters, currentAssignment, currentCost, currentScore, best);
+
+        // Opción 2: Intentar asignar este perro a cada adoptante
+        for (Adopter adopter : adopters) {
+            // Check timeout periodically
+            if (best.nodesExplored % 1000 == 0 && best.isTimeout()) {
+                return;
+            }
+
+            // Verificar si es viable asignar este perro a este adoptante
+            if (canAssign(dog, adopter, currentAssignment, currentCost)) {
+                // Calcular score de esta asignación
+                double score = calculateScore(dog, adopter);
+
+                // Hacer asignación (forward)
+                currentAssignment.get(adopter.id).add(dog.id);
+                currentCost.put(adopter.id, currentCost.get(adopter.id) + dog.cost);
+
+                // Recursión
+                backtrack(dogIndex + 1, dogs, adopters, currentAssignment, currentCost,
+                        currentScore + score, best);
+
+                // Deshacer asignación (backtrack)
+                currentAssignment.get(adopter.id).remove(currentAssignment.get(adopter.id).size() - 1);
+                currentCost.put(adopter.id, currentCost.get(adopter.id) - dog.cost);
+            }
+        }
+    }
+
+    /**
+     * Verifica si se puede asignar un perro a un adoptante respetando restricciones.
+     */
+    private boolean canAssign(
+            Dog dog,
+            Adopter adopter,
+            Map<String, List<String>> currentAssignment,
+            Map<String, Double> currentCost
+    ) {
+        // Restricción 1: No exceder capacidad máxima de perros
+        if (currentAssignment.get(adopter.id).size() >= adopter.maxDogs) {
+            return false;
+        }
+
+        // Restricción 2: No exceder presupuesto
+        if (currentCost.get(adopter.id) + dog.cost > adopter.budget) {
+            return false;
+        }
+
+        // Restricción 3: Si el perro no es bueno con niños y el adoptante tiene niños, no asignar
+        if (adopter.hasKids && !dog.goodWithKids) {
+            return false;
+        }
+
+        // Restricción 4: Si el perro necesita jardín y el adoptante no tiene, no asignar
+        if (dog.needsGarden && !adopter.hasGarden) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Calcula el score de asignar un perro específico a un adoptante específico.
+     */
+    private double calculateScore(Dog dog, Adopter adopter) {
+        double score = 0.0;
+
+        // +5 puntos si es compatible con niños y el adoptante tiene niños
+        if (adopter.hasKids && dog.goodWithKids) {
+            score += 5.0;
+        }
+
+        // +3 puntos si el perro necesita jardín y el adoptante tiene jardín
+        if (dog.needsGarden && adopter.hasGarden) {
+            score += 3.0;
+        }
+
+        // +0 a +5 puntos por compatibilidad de energía (menor diferencia = mejor)
+        int energyDiff = Math.abs(dog.energy - adopter.preferredEnergy);
+        score += Math.max(0, 5.0 - energyDiff);
+
+        return score;
+    }
+
+    /**
+     * Crea una copia profunda del mapa de asignaciones.
+     */
+    private Map<String, List<String>> deepCopy(Map<String, List<String>> original) {
+        Map<String, List<String>> copy = new HashMap<>();
+        for (Map.Entry<String, List<String>> entry : original.entrySet()) {
+            copy.put(entry.getKey(), new ArrayList<>(entry.getValue()));
+        }
+        return copy;
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/GraphLoader.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/GraphLoader.java
new file mode 100644
index 000000000..2cc595b76
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/GraphLoader.java
@@ -0,0 +1,93 @@
+package com.programacion3.adoptme.service;
+
+import com.programacion3.adoptme.service.ShortestPathService.Edge;
+import org.springframework.data.neo4j.core.Neo4jClient;
+import org.springframework.stereotype.Component;
+
+import java.util.*;
+
+/**
+ * Carga la lista de adyacencias y aristas con pesos desde Neo4j
+ */
+@Component
+public class GraphLoader {
+
+    private final Neo4jClient neo4j;
+
+    public GraphLoader(Neo4jClient neo4j) {
+        this.neo4j = neo4j;
+    }
+
+    /**
+     * Carga adyacencias simples (sin pesos) para BFS/DFS
+     */
+    public Map<String, List<String>> loadAdjacency() {
+        String q = """
+            MATCH (a:Shelter)-[r:NEAR]->(b:Shelter)
+            RETURN a.id AS from, b.id AS to
+        """;
+
+        Map<String, List<String>> g = new HashMap<>();
+        neo4j.query(q).fetch().all().forEach(row -> {
+            String from = (String) row.get("from");
+            String to = (String) row.get("to");
+            g.computeIfAbsent(from, k -> new ArrayList<>()).add(to);
+        });
+        return g;
+    }
+
+    /**
+     * Carga aristas con pesos (distKm) para Dijkstra y MST
+     * Crea aristas bidireccionales (grafo no dirigido)
+     */
+    public List<Edge> loadWeightedEdges() {
+        String q = """
+            MATCH (a:Shelter)-[r:NEAR]->(b:Shelter)
+            RETURN a.id AS from, b.id AS to, r.distKm AS weight
+        """;
+
+        List<Edge> edges = new ArrayList<>();
+        neo4j.query(q).fetch().all().forEach(row -> {
+            String from = (String) row.get("from");
+            String to = (String) row.get("to");
+            double weight = ((Number) row.get("weight")).doubleValue();
+
+            // Agregamos la arista en ambas direcciones (grafo no dirigido)
+            edges.add(new Edge(from, to, weight));
+            edges.add(new Edge(to, from, weight));
+        });
+        return edges;
+    }
+
+    /**
+     * Obtiene todos los IDs de shelters para MST
+     */
+    public Set<String> loadAllShelterIds() {
+        String q = "MATCH (s:Shelter) RETURN s.id AS id";
+        Set<String> ids = new HashSet<>();
+        neo4j.query(q).fetch().all().forEach(row -> {
+            ids.add((String) row.get("id"));
+        });
+        return ids;
+    }
+
+    /**
+     * Carga aristas como MSTService.Edge para compatibilidad
+     */
+    public List<MSTService.Edge> loadMSTEdges() {
+        String q = """
+            MATCH (a:Shelter)-[r:NEAR]->(b:Shelter)
+            RETURN a.id AS from, b.id AS to, r.distKm AS weight
+        """;
+
+        List<MSTService.Edge> edges = new ArrayList<>();
+        neo4j.query(q).fetch().all().forEach(row -> {
+            String from = (String) row.get("from");
+            String to = (String) row.get("to");
+            double weight = ((Number) row.get("weight")).doubleValue();
+
+            edges.add(new MSTService.Edge(from, to, weight, "NEAR"));
+        });
+        return edges;
+    }
+}
\ No newline at end of file
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/GraphService.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/GraphService.java
new file mode 100644
index 000000000..9ccae1964
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/GraphService.java
@@ -0,0 +1,70 @@
+package com.programacion3.adoptme.service;
+
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+
+@Service
+public class GraphService {
+
+    private final GraphLoader loader;
+
+    public GraphService(GraphLoader loader) {
+        this.loader = loader;
+    }
+
+    /** Camino más corto en cantidad de pasos (BFS). Devuelve vacío si no hay. */
+    public List<String> bfsPath(String from, String to) {
+        Map<String, List<String>> g = loader.loadAdjacency();
+        if (from == null || to == null || from.isBlank() || to.isBlank()) return List.of();
+        if (from.equals(to)) return List.of(from);
+
+        Queue<String> q = new ArrayDeque<>();
+        Map<String, String> prev = new HashMap<>();
+        Set<String> vis = new HashSet<>();
+
+        q.add(from);
+        vis.add(from);
+
+        while (!q.isEmpty()) {
+            String u = q.poll();
+            if (u.equals(to)) break;
+            for (String v : g.getOrDefault(u, List.of())) {
+                if (!vis.contains(v)) {
+                    vis.add(v);
+                    prev.put(v, u);
+                    q.add(v);
+                }
+            }
+        }
+
+        if (!vis.contains(to)) return List.of(); // no hay camino
+
+        LinkedList<String> path = new LinkedList<>();
+        for (String cur = to; cur != null; cur = prev.get(cur)) path.addFirst(cur);
+        return path;
+    }
+
+    /** DFS: intenta encontrar algún camino; no garantiza mínimo en pasos. */
+    public List<String> dfsPath(String from, String to) {
+        Map<String, List<String>> g = loader.loadAdjacency();
+        List<String> path = new ArrayList<>();
+        Set<String> vis = new HashSet<>();
+        if (dfs(g, from, to, vis, path)) return path;
+        return List.of();
+    }
+
+    private boolean dfs(Map<String, List<String>> g, String u, String to, Set<String> vis, List<String> path) {
+        if (u == null) return false;
+        path.add(u);
+        if (u.equals(to)) return true;
+        vis.add(u);
+        for (String v : g.getOrDefault(u, List.of())) {
+            if (!vis.contains(v)) {
+                if (dfs(g, v, to, vis, path)) return true;
+            }
+        }
+        path.remove(path.size() - 1);
+        return false;
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/MSTService.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/MSTService.java
new file mode 100644
index 000000000..27b15d5bf
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/MSTService.java
@@ -0,0 +1,169 @@
+package com.programacion3.adoptme.service;
+
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+
+
+/*
+ Kruskal simple que opera sobre un subconjunto de nodos (p. ej. shelters/hubs)
+ y aristas filtradas por tipo "NEAR". Devuelve lista de aristas del MST y costo total.
+*/
+@Service
+public class MSTService {
+
+    public static class Edge {
+        public final String a;
+        public final String b;
+        public final double weight;
+        public final String type; // p.ej. "NEAR"
+
+        public Edge(String a, String b, double weight, String type) {
+            this.a = a;
+            this.b = b;
+            this.weight = weight;
+            this.type = type;
+        }
+    }
+
+    public static class MSTResult {
+        public final List<Edge> edges;
+        public final double totalWeight;
+        public MSTResult(List<Edge> edges, double totalWeight) {
+            this.edges = edges; this.totalWeight = totalWeight;
+        }
+    }
+
+    /**
+     * Algoritmo de Kruskal para MST.
+     * Ordena todas las aristas por peso y las agrega greedily evitando ciclos (Union-Find).
+     */
+    public MSTResult compute(Collection<String> nodesOfInterest, Collection<Edge> allEdges) {
+        // Filtrar aristas NEAR que conecten nodos de interés
+        List<Edge> edges = new ArrayList<>();
+        for (Edge e : allEdges) {
+            if (!"NEAR".equalsIgnoreCase(e.type)) continue;
+            if (nodesOfInterest.contains(e.a) && nodesOfInterest.contains(e.b)) edges.add(e);
+        }
+        edges.sort(Comparator.comparingDouble(e -> e.weight));
+        UnionFind uf = new UnionFind(nodesOfInterest);
+        List<Edge> mst = new ArrayList<>();
+        double total = 0.0;
+        for (Edge e : edges) {
+            if (uf.union(e.a, e.b)) {
+                mst.add(e);
+                total += e.weight;
+            }
+        }
+        return new MSTResult(mst, total);
+    }
+
+    /**
+     * Algoritmo de Prim para MST.
+     * Empieza desde un nodo inicial y expande el árbol agregando la arista de menor peso
+     * que conecta un nodo del árbol con uno fuera del árbol.
+     */
+    public MSTResult computeWithPrim(Collection<String> nodesOfInterest, Collection<Edge> allEdges) {
+        if (nodesOfInterest.isEmpty()) {
+            return new MSTResult(new ArrayList<>(), 0.0);
+        }
+
+        // Filtrar aristas NEAR que conecten nodos de interés
+        List<Edge> edges = new ArrayList<>();
+        for (Edge e : allEdges) {
+            if (!"NEAR".equalsIgnoreCase(e.type)) continue;
+            if (nodesOfInterest.contains(e.a) && nodesOfInterest.contains(e.b)) edges.add(e);
+        }
+
+        // Construir lista de adyacencia con pesos
+        Map<String, List<Edge>> adj = new HashMap<>();
+        for (String node : nodesOfInterest) {
+            adj.put(node, new ArrayList<>());
+        }
+        for (Edge e : edges) {
+            adj.get(e.a).add(e);
+            // Agregar arista inversa para grafo no dirigido
+            adj.get(e.b).add(new Edge(e.b, e.a, e.weight, e.type));
+        }
+
+        // Prim: empezar desde un nodo arbitrario
+        String start = nodesOfInterest.iterator().next();
+        Set<String> inMST = new HashSet<>();
+        inMST.add(start);
+
+        // Cola de prioridad de aristas: (peso, arista)
+        PriorityQueue<EdgeWithPriority> pq = new PriorityQueue<>(Comparator.comparingDouble(e -> e.weight));
+
+        // Agregar todas las aristas del nodo inicial
+        for (Edge e : adj.get(start)) {
+            pq.offer(new EdgeWithPriority(e.weight, e));
+        }
+
+        List<Edge> mst = new ArrayList<>();
+        double total = 0.0;
+
+        while (!pq.isEmpty() && inMST.size() < nodesOfInterest.size()) {
+            EdgeWithPriority current = pq.poll();
+            Edge edge = current.edge;
+
+            // Si ambos extremos ya están en el MST, saltar (evita ciclos)
+            if (inMST.contains(edge.b)) {
+                continue;
+            }
+
+            // Agregar arista al MST
+            mst.add(edge);
+            total += edge.weight;
+            inMST.add(edge.b);
+
+            // Agregar todas las aristas del nuevo nodo
+            for (Edge e : adj.get(edge.b)) {
+                if (!inMST.contains(e.b)) {
+                    pq.offer(new EdgeWithPriority(e.weight, e));
+                }
+            }
+        }
+
+        return new MSTResult(mst, total);
+    }
+
+    // Clase auxiliar para la cola de prioridad de Prim
+    private static class EdgeWithPriority {
+        final double weight;
+        final Edge edge;
+
+        EdgeWithPriority(double weight, Edge edge) {
+            this.weight = weight;
+            this.edge = edge;
+        }
+    }
+
+    private static class UnionFind {
+        private final Map<String, String> parent;
+        private final Map<String, Integer> rank;
+
+        UnionFind(Collection<String> nodes) {
+            parent = new HashMap<>();
+            rank = new HashMap<>();
+            for (String n : nodes) { parent.put(n, n); rank.put(n, 0); }
+        }
+
+        String find(String x) {
+            String p = parent.get(x);
+            if (p == null) return x;
+            if (!p.equals(x)) parent.put(x, find(p));
+            return parent.get(x);
+        }
+
+        boolean union(String a, String b) {
+            String ra = find(a), rb = find(b);
+            if (ra.equals(rb)) return false;
+            int rka = rank.getOrDefault(ra, 0), rkb = rank.getOrDefault(rb, 0);
+            if (rka < rkb) parent.put(ra, rb);
+            else if (rka > rkb) parent.put(rb, ra);
+            else { parent.put(rb, ra); rank.put(ra, rka + 1); }
+            return true;
+        }
+    }
+}
+
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/ScorerService.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/ScorerService.java
new file mode 100644
index 000000000..7fd442e8c
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/ScorerService.java
@@ -0,0 +1,80 @@
+// java
+package com.programacion3.adoptme.service;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import org.springframework.stereotype.Service;
+
+
+
+/*
+ Scorer simple: calcula score por perro según criterios (children/garden/energy/size),
+ ordena por score descendente y asigna hasta maxDogs o presupuesto.
+*/
+@Service
+public class ScorerService {
+    public static class Dog {
+        public final String id;
+        public final boolean goodWithKids;
+        public final boolean hasGardenNeeded;
+        public final int energy; // 1..10
+        public final int size;   // 1 small .. 3 large
+        public final double cost; // asumido costo por adopción
+
+        public Dog(String id, boolean goodWithKids, boolean hasGardenNeeded, int energy, int size, double cost) {
+            this.id = id; this.goodWithKids = goodWithKids; this.hasGardenNeeded = hasGardenNeeded;
+            this.energy = energy; this.size = size; this.cost = cost;
+        }
+    }
+
+    public static class AssignmentResult {
+        public final List<Dog> assigned;
+        public final double totalScore;
+        public final double totalCost;
+        public AssignmentResult(List<Dog> assigned, double totalScore, double totalCost) {
+            this.assigned = assigned; this.totalScore = totalScore; this.totalCost = totalCost;
+        }
+    }
+
+    // Scoring configurable simple ejemplo:
+    private double scoreFor(Dog d, boolean adopterHasKids, boolean adopterHasGarden, double weights[]) {
+        double s = 0;
+        if (adopterHasKids && d.goodWithKids) s += weights[0]; // peso niños
+        if (adopterHasGarden && d.hasGardenNeeded) s += weights[1]; // jardín
+        // prefiero energía moderada: penaliza extremos
+        s += weights[2] * (1.0 - Math.abs(d.energy - 5) / 5.0);
+        // tamaño preferencia neutra -> pequeño un poco mejor
+        s += weights[3] * (3.0 - d.size) / 2.0;
+        return s;
+    }
+
+    public AssignmentResult scoreAndAssign(List<Dog> candidates,
+                                           boolean adopterHasKids,
+                                           boolean adopterHasGarden,
+                                           int maxDogs,
+                                           double budget) {
+        double[] weights = {3.0, 2.0, 2.0, 1.0}; // niños, jardín, energía, tamaño
+        List<ScoredDog> scored = candidates.stream()
+                .map(d -> new ScoredDog(d, scoreFor(d, adopterHasKids, adopterHasGarden, weights)))
+                .sorted(Comparator.comparingDouble((ScoredDog sd) -> sd.score).reversed())
+                .collect(Collectors.toList());
+
+        List<Dog> assigned = new ArrayList<>();
+        double totalCost = 0, totalScore = 0;
+        for (ScoredDog sd : scored) {
+            if (assigned.size() >= maxDogs) break;
+            if (totalCost + sd.dog.cost > budget) continue;
+            assigned.add(sd.dog);
+            totalCost += sd.dog.cost;
+            totalScore += sd.score;
+        }
+        return new AssignmentResult(assigned, totalScore, totalCost);
+    }
+
+    private static class ScoredDog {
+        final Dog dog;
+        final double score;
+        ScoredDog(Dog dog, double score) { this.dog = dog; this.score = score; }
+    }
+}
+
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/ShortestPathService.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/ShortestPathService.java
new file mode 100644
index 000000000..e334801b5
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/ShortestPathService.java
@@ -0,0 +1,84 @@
+package com.programacion3.adoptme.service;
+import org.springframework.stereotype.Service;
+import java.util.*;
+/*
+     Minimal Dijkstra que usa PriorityQueue y devuelve costo + camino.
+     Entrada: colección de aristas dirigidas/indirectas (Edge), ids de nodo como String.
+
+*/
+@Service
+public class ShortestPathService {
+
+        public static class Edge {
+            public final String from;
+            public final String to;
+            public final double weight;
+
+            public Edge(String from, String to, double weight) {
+                this.from = from;
+                this.to = to;
+                this.weight = weight;
+            }
+        }
+
+        public static class PathResult {
+            public final double cost;
+            public final List<String> path;
+
+            public PathResult(double cost, List<String> path) {
+                this.cost = cost;
+                this.path = path;
+            }
+        }
+
+        public PathResult shortestPath(String start, String goal, Collection<Edge> edges) {
+            Map<String, List<Edge>> adj = buildAdj(edges);
+            Map<String, Double> dist = new HashMap<>();
+            Map<String, String> prev = new HashMap<>();
+            PriorityQueue<Node> pq = new PriorityQueue<>(Comparator.comparingDouble(n -> n.dist));
+            dist.put(start, 0.0);
+            pq.add(new Node(start, 0.0));
+
+            while (!pq.isEmpty()) {
+                Node cur = pq.poll();
+                if (cur.dist > dist.getOrDefault(cur.id, Double.POSITIVE_INFINITY)) continue;
+                if (cur.id.equals(goal)) break;
+                for (Edge e : adj.getOrDefault(cur.id, Collections.emptyList())) {
+                    double nd = cur.dist + e.weight;
+                    if (nd < dist.getOrDefault(e.to, Double.POSITIVE_INFINITY)) {
+                        dist.put(e.to, nd);
+                        prev.put(e.to, cur.id);
+                        pq.add(new Node(e.to, nd));
+                    }
+                }
+            }
+
+            if (!dist.containsKey(goal)) return new PathResult(Double.POSITIVE_INFINITY, Collections.emptyList());
+            List<String> path = new ArrayList<>();
+            String cur = goal;
+            while (cur != null) {
+                path.add(cur);
+                cur = prev.get(cur);
+            }
+            Collections.reverse(path);
+            return new PathResult(dist.get(goal), path);
+        }
+
+        private Map<String, List<Edge>> buildAdj(Collection<Edge> edges) {
+            Map<String, List<Edge>> adj = new HashMap<>();
+            for (Edge e : edges) {
+                adj.computeIfAbsent(e.from, k -> new ArrayList<>()).add(e);
+                // si el grafo es no dirigido, añadir la inversa:
+                adj.computeIfAbsent(e.to, k -> new ArrayList<>()).add(new Edge(e.to, e.from, e.weight));
+            }
+            return adj;
+        }
+
+        private static class Node {
+            final String id;
+            final double dist;
+            Node(String id, double dist) { this.id = id; this.dist = dist; }
+        }
+    }
+
+
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/SortService.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/SortService.java
new file mode 100644
index 000000000..51f9c74b0
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/SortService.java
@@ -0,0 +1,115 @@
+package com.programacion3.adoptme.service;
+
+import java.util.Comparator;
+import java.util.List;
+import org.springframework.stereotype.Service;
+import com.programacion3.adoptme.domain.Dog;
+
+
+@Service
+public class SortService {
+
+    /**
+     * Ordena perros usando TimSort (default) o QuickSort.
+     * @param dogs lista de perros a ordenar (se modifica in-place)
+     * @param criteria criterio de ordenamiento (priority, age, weight)
+     * @param algorithm algoritmo a usar (mergesort, quicksort)
+     */
+    public void sortDogs(List<Dog> dogs, String criteria, String algorithm) {
+        if (algorithm == null || algorithm.isEmpty()) {
+            algorithm = "mergesort";
+        }
+
+        if ("quicksort".equalsIgnoreCase(algorithm)) {
+            quickSortDogs(dogs, criteria, 0, dogs.size() - 1);
+        } else {
+            // MergeSort (TimSort)
+            Comparator<Dog> comparator = getComparator(criteria);
+            dogs.sort(comparator);
+        }
+    }
+
+    /**
+     * Versión legacy que usa MergeSort por defecto
+     */
+    public void sortDogs(List<Dog> dogs, String criteria) {
+        sortDogs(dogs, criteria, "mergesort");
+    }
+
+    /**
+     * Implementación de QuickSort para perros
+     * Algoritmo divide y vencerás que particiona la lista recursivamente
+     */
+    private void quickSortDogs(List<Dog> dogs, String criteria, int low, int high) {
+        if (low < high) {
+            int pivotIndex = partition(dogs, criteria, low, high);
+            quickSortDogs(dogs, criteria, low, pivotIndex - 1);
+            quickSortDogs(dogs, criteria, pivotIndex + 1, high);
+        }
+    }
+
+    /**
+     * Particiona la lista usando el último elemento como pivote
+     */
+    private int partition(List<Dog> dogs, String criteria, int low, int high) {
+        Dog pivot = dogs.get(high);
+        int i = low - 1;
+
+        for (int j = low; j < high; j++) {
+            if (compare(dogs.get(j), pivot, criteria) <= 0) {
+                i++;
+                swap(dogs, i, j);
+            }
+        }
+
+        swap(dogs, i + 1, high);
+        return i + 1;
+    }
+
+    /**
+     * Compara dos perros según el criterio especificado
+     * @return negativo si a < b, 0 si a == b, positivo si a > b
+     */
+    private int compare(Dog a, Dog b, String criteria) {
+        switch (criteria.toLowerCase()) {
+            case "priority":
+                // Orden ascendente (menor prioridad primero)
+                return Integer.compare(a.getPriority(), b.getPriority());
+            case "age":
+                return Integer.compare(a.getAge(), b.getAge());
+            case "weight":
+                return Integer.compare(a.getWeight(), b.getWeight());
+            default:
+                throw new IllegalArgumentException("Criterio de orden no válido: " + criteria);
+        }
+    }
+
+    /**
+     * Intercambia dos elementos en la lista
+     */
+    private void swap(List<Dog> dogs, int i, int j) {
+        Dog temp = dogs.get(i);
+        dogs.set(i, dogs.get(j));
+        dogs.set(j, temp);
+    }
+
+    /**
+     * Obtiene el comparador para un criterio dado
+     */
+    private Comparator<Dog> getComparator(String criteria) {
+        switch (criteria.toLowerCase()) {
+            case "priority":
+                // Orden ascendente (menor prioridad primero)
+                return Comparator.comparingInt(Dog::getPriority);
+            case "age":
+                return Comparator.comparingInt(Dog::getAge);
+            case "weight":
+                return Comparator.comparingDouble(Dog::getWeight);
+            default:
+                throw new IllegalArgumentException("Criterio de orden no válido: " + criteria);
+        }
+    }
+}
+
+
+
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/TSPService.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/TSPService.java
new file mode 100644
index 000000000..88a6516cc
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/TSPService.java
@@ -0,0 +1,363 @@
+package com.programacion3.adoptme.service;
+
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+
+/**
+ * Servicio que implementa Branch & Bound para el Problema del Viajante (TSP).
+ *
+ * Encuentra la ruta más corta que visita todos los nodos exactamente una vez
+ * y regresa al nodo de inicio.
+ */
+@Service
+public class TSPService {
+
+    /**
+     * Representa una arista con peso
+     */
+    public static class Edge {
+        public final String from;
+        public final String to;
+        public final double weight;
+
+        public Edge(String from, String to, double weight) {
+            this.from = from;
+            this.to = to;
+            this.weight = weight;
+        }
+    }
+
+    /**
+     * Resultado del TSP
+     */
+    public static class TSPResult {
+        public final List<String> route; // Secuencia de nodos en el tour óptimo
+        public final double totalDistance; // Distancia total del tour
+
+        public TSPResult(List<String> route, double totalDistance) {
+            this.route = route;
+            this.totalDistance = totalDistance;
+        }
+    }
+
+    /**
+     * Resuelve TSP usando Branch & Bound
+     *
+     * @param nodes lista de nodos a visitar
+     * @param edges lista de aristas con distancias
+     * @return tour óptimo y su distancia total
+     */
+    public TSPResult solveTSP(List<String> nodes, List<Edge> edges) {
+        if (nodes == null || nodes.isEmpty()) {
+            return new TSPResult(new ArrayList<>(), 0.0);
+        }
+
+        if (nodes.size() == 1) {
+            return new TSPResult(new ArrayList<>(nodes), 0.0);
+        }
+
+        // Construir matriz de distancias
+        Map<String, Map<String, Double>> distMatrix = buildDistanceMatrix(nodes, edges);
+
+        // Verificar si el grafo es conexo
+        if (!isConnected(nodes, distMatrix)) {
+            return new TSPResult(new ArrayList<>(), Double.POSITIVE_INFINITY);
+        }
+
+        // Variables para la mejor solución
+        BestSolution best = new BestSolution();
+        best.cost = Double.POSITIVE_INFINITY;
+
+        // Empezar desde el primer nodo
+        String startNode = nodes.get(0);
+        List<String> currentPath = new ArrayList<>();
+        currentPath.add(startNode);
+
+        Set<String> visited = new HashSet<>();
+        visited.add(startNode);
+
+        // Branch & Bound
+        branchAndBound(startNode, startNode, currentPath, visited, 0.0, nodes, distMatrix, best);
+
+        return new TSPResult(best.route, best.cost);
+    }
+
+    /**
+     * Clase para mantener la mejor solución encontrada
+     */
+    private static class BestSolution {
+        List<String> route = new ArrayList<>();
+        double cost = Double.POSITIVE_INFINITY;
+    }
+
+    /**
+     * Algoritmo de Branch & Bound recursivo
+     *
+     * @param startNode nodo de inicio del tour
+     * @param currentNode nodo actual
+     * @param currentPath camino actual
+     * @param visited conjunto de nodos visitados
+     * @param currentCost costo acumulado
+     * @param allNodes todos los nodos a visitar
+     * @param distMatrix matriz de distancias
+     * @param best mejor solución encontrada
+     */
+    private void branchAndBound(
+            String startNode,
+            String currentNode,
+            List<String> currentPath,
+            Set<String> visited,
+            double currentCost,
+            List<String> allNodes,
+            Map<String, Map<String, Double>> distMatrix,
+            BestSolution best
+    ) {
+        // Caso base: todos los nodos visitados
+        if (visited.size() == allNodes.size()) {
+            // Agregar costo de regresar al inicio
+            double returnCost = getDistance(currentNode, startNode, distMatrix);
+
+            if (returnCost != Double.POSITIVE_INFINITY) {
+                double totalCost = currentCost + returnCost;
+
+                // Si es mejor que la solución actual, actualizarla
+                if (totalCost < best.cost) {
+                    best.cost = totalCost;
+                    best.route = new ArrayList<>(currentPath);
+                    best.route.add(startNode); // Completar el ciclo
+                }
+            }
+            return;
+        }
+
+        // Calcular bound (cota inferior)
+        double bound = currentCost + calculateBound(currentNode, visited, allNodes, distMatrix);
+
+        // Poda: si el bound supera la mejor solución conocida, no explorar esta rama
+        if (bound >= best.cost) {
+            return;
+        }
+
+        // Explorar todos los nodos no visitados
+        for (String nextNode : allNodes) {
+            if (!visited.contains(nextNode)) {
+                double edgeCost = getDistance(currentNode, nextNode, distMatrix);
+
+                if (edgeCost != Double.POSITIVE_INFINITY) {
+                    // Forward
+                    currentPath.add(nextNode);
+                    visited.add(nextNode);
+
+                    // Recursión
+                    branchAndBound(
+                            startNode,
+                            nextNode,
+                            currentPath,
+                            visited,
+                            currentCost + edgeCost,
+                            allNodes,
+                            distMatrix,
+                            best
+                    );
+
+                    // Backtrack
+                    currentPath.remove(currentPath.size() - 1);
+                    visited.remove(nextNode);
+                }
+            }
+        }
+    }
+
+    /**
+     * Calcula una cota inferior (bound) para el costo restante.
+     * Usa la suma de las dos aristas más pequeñas de cada nodo no visitado.
+     */
+    private double calculateBound(
+            String currentNode,
+            Set<String> visited,
+            List<String> allNodes,
+            Map<String, Map<String, Double>> distMatrix
+    ) {
+        double bound = 0.0;
+
+        // 1. Arista mínima desde nodo actual a cualquier no visitado
+        double minFromCurrent = Double.POSITIVE_INFINITY;
+        for (String node : allNodes) {
+            if (!visited.contains(node)) {
+                double dist = getDistance(currentNode, node, distMatrix);
+                minFromCurrent = Math.min(minFromCurrent, dist);
+            }
+        }
+        if (minFromCurrent != Double.POSITIVE_INFINITY) {
+            bound += minFromCurrent;
+        }
+
+        // 2. Costo MST de los nodos no visitados
+        List<String> unvisited = allNodes.stream()
+                .filter(n -> !visited.contains(n))
+                .toList();
+
+        if (unvisited.size() > 1) {
+            bound += calculateMSTCost(unvisited, distMatrix);
+        }
+
+        // 3. Arista mínima desde cualquier no visitado de vuelta al inicio
+        String startNode = allNodes.get(0);
+        if (!visited.contains(startNode) && !unvisited.isEmpty()) {
+            double minToStart = Double.POSITIVE_INFINITY;
+            for (String node : unvisited) {
+                double dist = getDistance(node, startNode, distMatrix);
+                minToStart = Math.min(minToStart, dist);
+            }
+            if (minToStart != Double.POSITIVE_INFINITY) {
+                bound += minToStart;
+            }
+        }
+
+        return bound;
+    }
+
+    // Método auxiliar: Calcular costo MST con algoritmo de Prim
+    private double calculateMSTCost(
+            List<String> nodes,
+            Map<String, Map<String, Double>> distMatrix
+    ) {
+        if (nodes.isEmpty()) return 0.0;
+        if (nodes.size() == 1) return 0.0;
+
+        Set<String> inMST = new HashSet<>();
+        double mstCost = 0.0;
+
+        inMST.add(nodes.get(0));
+
+        while (inMST.size() < nodes.size()) {
+            double minEdge = Double.POSITIVE_INFINITY;
+            String nextNode = null;
+
+            for (String inNode : inMST) {
+                for (String outNode : nodes) {
+                    if (!inMST.contains(outNode)) {
+                        double dist = getDistance(inNode, outNode, distMatrix);
+                        if (dist < minEdge) {
+                            minEdge = dist;
+                            nextNode = outNode;
+                        }
+                    }
+                }
+            }
+
+            if (nextNode != null && minEdge != Double.POSITIVE_INFINITY) {
+                inMST.add(nextNode);
+                mstCost += minEdge;
+            } else {
+                break; // Grafo no conexo
+            }
+        }
+
+        return mstCost;
+    }
+
+    /**
+     * Construye una matriz de distancias a partir de las aristas
+     */
+    private Map<String, Map<String, Double>> buildDistanceMatrix(List<String> nodes, List<Edge> edges) {
+        Map<String, Map<String, Double>> matrix = new HashMap<>();
+
+        // Inicializar con infinito
+        for (String from : nodes) {
+            matrix.put(from, new HashMap<>());
+            for (String to : nodes) {
+                if (from.equals(to)) {
+                    matrix.get(from).put(to, 0.0);
+                } else {
+                    matrix.get(from).put(to, Double.POSITIVE_INFINITY);
+                }
+            }
+        }
+
+        // Llenar con las distancias de las aristas directas (grafo no dirigido)
+        for (Edge edge : edges) {
+            if (matrix.containsKey(edge.from) && matrix.containsKey(edge.to)) {
+                matrix.get(edge.from).put(edge.to, edge.weight);
+                matrix.get(edge.to).put(edge.from, edge.weight);
+            }
+        }
+
+        // ✅ FLOYD-WARSHALL: Calcular caminos más cortos indirectos
+        for (String k : nodes) {
+            for (String i : nodes) {
+                for (String j : nodes) {
+                    double distIK = matrix.get(i).get(k);
+                    double distKJ = matrix.get(k).get(j);
+                    double distIJ = matrix.get(i).get(j);
+
+                    // Si hay un camino más corto vía k, actualizarlo
+                    if (distIK + distKJ < distIJ) {
+                        matrix.get(i).put(j, distIK + distKJ);
+                    }
+                }
+            }
+        }
+
+        return matrix;
+    }
+
+    /**
+     * Obtiene la distancia entre dos nodos
+     */
+    private double getDistance(String from, String to, Map<String, Map<String, Double>> distMatrix) {
+        if (distMatrix.containsKey(from) && distMatrix.get(from).containsKey(to)) {
+            return distMatrix.get(from).get(to);
+        }
+        return Double.POSITIVE_INFINITY;
+    }
+
+    /**
+     * Verifica si el grafo es conexo (todos los nodos son alcanzables)
+     */
+    private boolean isConnected(List<String> nodes, Map<String, Map<String, Double>> distMatrix) {
+        if (nodes.isEmpty()) return true;
+        if (nodes.size() == 1) return true;
+
+        // Construir grafo de adyacencia BASADO en la distMatrix
+        Map<String, Set<String>> adj = new HashMap<>();
+        for (String node : nodes) {
+            adj.put(node, new HashSet<>());
+        }
+
+        // Si existe un camino (distancia finita), son vecinos
+        for (String from : nodes) {
+            for (String to : nodes) {
+                if (!from.equals(to)) {
+                    double dist = getDistance(from, to, distMatrix);
+                    if (dist != Double.POSITIVE_INFINITY) {
+                        adj.get(from).add(to);  // Hay camino → son vecinos
+                    }
+                }
+            }
+        }
+
+        // BFS para verificar conectividad
+        Set<String> visited = new HashSet<>();
+        Queue<String> queue = new LinkedList<>();
+
+        String start = nodes.get(0);
+        queue.offer(start);
+        visited.add(start);
+
+        while (!queue.isEmpty()) {
+            String current = queue.poll();
+
+            // Explorar vecinos REALES del grafo de adyacencia
+            for (String neighbor : adj.get(current)) {
+                if (!visited.contains(neighbor)) {
+                    visited.add(neighbor);
+                    queue.offer(neighbor);
+                }
+            }
+        }
+
+        return visited.size() == nodes.size();
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/TransportService.java b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/TransportService.java
new file mode 100644
index 000000000..4b675f34b
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/java/com/programacion3/adoptme/service/TransportService.java
@@ -0,0 +1,87 @@
+package com.programacion3.adoptme.service;
+
+import com.programacion3.adoptme.domain.Dog;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Servicio para optimizar el transporte de perros usando Programación Dinámica (Knapsack).
+ *
+ * Problema: Dado un vehículo con capacidad limitada en kg, seleccionar el mejor conjunto
+ * de perros para transportar maximizando la prioridad total.
+ */
+@Service
+public class TransportService {
+
+    /**
+     * Resuelve el problema de la mochila 0/1 usando Programación Dinámica.
+     *
+     * @param dogs lista de perros disponibles para transporte
+     * @param capacityKg capacidad del vehículo en kilogramos
+     * @return resultado con perros seleccionados y valor total
+     */
+    public KnapsackResult optimizeTransport(List<Dog> dogs, int capacityKg) {
+        if (dogs == null || dogs.isEmpty() || capacityKg <= 0) {
+            return new KnapsackResult(new ArrayList<>(), 0, 0);
+        }
+
+        int n = dogs.size();
+
+        // Tabla DP: dp[i][w] = máxima prioridad con primeros i perros y capacidad w
+        int[][] dp = new int[n + 1][capacityKg + 1];
+
+        // Llenar tabla usando programación dinámica
+        for (int i = 1; i <= n; i++) {
+            Dog dog = dogs.get(i - 1);
+            int weight = dog.getWeight();
+            int priority = dog.getPriority();
+
+            for (int w = 0; w <= capacityKg; w++) {
+                // Opción 1: No incluir este perro
+                dp[i][w] = dp[i - 1][w];
+
+                // Opción 2: Incluir este perro (si cabe)
+                if (weight <= w) {
+                    int valueWithDog = dp[i - 1][w - weight] + priority;
+                    dp[i][w] = Math.max(dp[i][w], valueWithDog);
+                }
+            }
+        }
+
+        // Reconstruir solución: qué perros fueron seleccionados
+        List<Dog> selectedDogs = new ArrayList<>();
+        int w = capacityKg;
+        int totalWeight = 0;
+
+        for (int i = n; i > 0 && w > 0; i--) {
+            // Si el valor cambió, significa que incluimos este perro
+            if (dp[i][w] != dp[i - 1][w]) {
+                Dog dog = dogs.get(i - 1);
+                selectedDogs.add(dog);
+                w -= dog.getWeight();
+                totalWeight += dog.getWeight();
+            }
+        }
+
+        int totalPriority = dp[n][capacityKg];
+
+        return new KnapsackResult(selectedDogs, totalPriority, totalWeight);
+    }
+
+    /**
+     * Resultado del problema de la mochila
+     */
+    public static class KnapsackResult {
+        public final List<Dog> selectedDogs;
+        public final int totalPriority;
+        public final int totalWeight;
+
+        public KnapsackResult(List<Dog> selectedDogs, int totalPriority, int totalWeight) {
+            this.selectedDogs = selectedDogs;
+            this.totalPriority = totalPriority;
+            this.totalWeight = totalWeight;
+        }
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/resources/application.properties b/jdk_21_maven/cs/rest/adoptme/src/main/resources/application.properties
new file mode 100644
index 000000000..7e45430a4
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/resources/application.properties
@@ -0,0 +1,5 @@
+spring.application.name=AdoptM
+spring.data.neo4j.database=neo4j
+spring.neo4j.authentication.username=neo4j
+spring.neo4j.authentication.password=neo4j123
+spring.neo4j.uri=neo4j://127.0.0.1:7687
\ No newline at end of file
diff --git a/jdk_21_maven/cs/rest/adoptme/src/main/resources/application.yml b/jdk_21_maven/cs/rest/adoptme/src/main/resources/application.yml
new file mode 100644
index 000000000..1385eceac
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/main/resources/application.yml
@@ -0,0 +1,12 @@
+spring:
+  neo4j:
+    uri: bolt://localhost:7687
+    authentication:
+      username: neo4j
+      password: neo4j123
+    data:
+      neo4j:
+        database: neo4j
+
+server:
+  port: 8080
diff --git a/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/AdoptMApplicationTests.java b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/AdoptMApplicationTests.java
new file mode 100644
index 000000000..f7a9b1a01
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/AdoptMApplicationTests.java
@@ -0,0 +1,13 @@
+package com.programacion3.adoptme;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class AdoptMApplicationTests {
+
+	@Test
+	void contextLoads() {
+	}
+
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/BacktrackingServiceTest.java b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/BacktrackingServiceTest.java
new file mode 100644
index 000000000..03c21033d
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/BacktrackingServiceTest.java
@@ -0,0 +1,474 @@
+package com.programacion3.adoptme.service;
+
+import com.programacion3.adoptme.service.BacktrackingService.Dog;
+import com.programacion3.adoptme.service.BacktrackingService.Adopter;
+import com.programacion3.adoptme.service.BacktrackingService.Assignment;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DisplayName("BacktrackingService (Constraint Satisfaction) Unit Tests")
+class BacktrackingServiceTest {
+
+    private BacktrackingService backtrackingService;
+
+    @BeforeEach
+    void setUp() {
+        backtrackingService = new BacktrackingService();
+    }
+
+    private List<Dog> createSimpleDogs() {
+        List<Dog> dogs = new ArrayList<>();
+        dogs.add(new Dog("D1", true, false, 5, 5000.0));   // Good with kids, no garden, moderate energy
+        dogs.add(new Dog("D2", false, true, 7, 8000.0));   // Not good with kids, needs garden
+        dogs.add(new Dog("D3", true, true, 3, 10000.0));   // Good with kids, needs garden, low energy
+        return dogs;
+    }
+
+    private List<Adopter> createSimpleAdopters() {
+        List<Adopter> adopters = new ArrayList<>();
+        adopters.add(new Adopter("A1", "Alice", true, true, 2, 20000.0, 5));  // Has kids, has garden
+        adopters.add(new Adopter("A2", "Bob", false, false, 1, 6000.0, 7));   // No kids, no garden
+        return adopters;
+    }
+
+    // ==================== Basic Assignment Tests ====================
+
+    @Test
+    @DisplayName("Backtracking: Empty dogs returns empty assignment")
+    void testEmptyDogs() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+        List<Adopter> adopters = createSimpleAdopters();
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        assertNotNull(result);
+        assertTrue(result.assignments.isEmpty() || allAssignmentsEmpty(result.assignments));
+        assertEquals(0.0, result.totalScore, 0.01);
+    }
+
+    @Test
+    @DisplayName("Backtracking: Empty adopters returns empty assignment")
+    void testEmptyAdopters() {
+        // Arrange
+        List<Dog> dogs = createSimpleDogs();
+        List<Adopter> adopters = new ArrayList<>();
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        assertNotNull(result);
+        assertTrue(result.assignments.isEmpty());
+        assertEquals(0.0, result.totalScore, 0.01);
+    }
+
+    @Test
+    @DisplayName("Backtracking: Single dog and single adopter")
+    void testSingleDogSingleAdopter() {
+        // Arrange
+        List<Dog> dogs = Arrays.asList(new Dog("D1", true, false, 5, 5000.0));
+        List<Adopter> adopters = Arrays.asList(new Adopter("A1", "Alice", true, true, 2, 10000.0, 5));
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        assertNotNull(result);
+        assertTrue(result.totalScore > 0, "Should find a valid assignment");
+
+        // Check that dog was assigned
+        boolean dogAssigned = false;
+        for (List<String> dogList : result.assignments.values()) {
+            if (dogList.contains("D1")) {
+                dogAssigned = true;
+                break;
+            }
+        }
+        assertTrue(dogAssigned, "Dog should be assigned to adopter");
+    }
+
+    // ==================== Constraint Tests ====================
+
+    @Test
+    @DisplayName("Backtracking: Respects kids constraint")
+    void testKidsConstraint() {
+        // Arrange
+        List<Dog> dogs = Arrays.asList(
+                new Dog("GoodWithKids", true, false, 5, 5000.0),
+                new Dog("NotGoodWithKids", false, false, 5, 5000.0)
+        );
+        List<Adopter> adopters = Arrays.asList(
+                new Adopter("HasKids", "Parent", true, true, 5, 50000.0, 5)
+        );
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        List<String> assignedToParent = result.assignments.get("HasKids");
+        if (assignedToParent != null) {
+            // Should only assign GoodWithKids
+            assertFalse(assignedToParent.contains("NotGoodWithKids"),
+                    "Dog not good with kids should not be assigned to adopter with kids");
+        }
+    }
+
+    @Test
+    @DisplayName("Backtracking: Respects garden constraint")
+    void testGardenConstraint() {
+        // Arrange
+        List<Dog> dogs = Arrays.asList(
+                new Dog("NeedsGarden", true, true, 5, 5000.0),
+                new Dog("NoGardenNeeded", true, false, 5, 5000.0)
+        );
+        List<Adopter> adopters = Arrays.asList(
+                new Adopter("NoGarden", "Bob", false, false, 5, 50000.0, 5)
+        );
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        List<String> assignedToBob = result.assignments.get("NoGarden");
+        if (assignedToBob != null) {
+            // Should not assign dog that needs garden
+            assertFalse(assignedToBob.contains("NeedsGarden"),
+                    "Dog needing garden should not be assigned to adopter without garden");
+        }
+    }
+
+    @Test
+    @DisplayName("Backtracking: Respects maxDogs constraint")
+    void testMaxDogsConstraint() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+        for (int i = 1; i <= 10; i++) {
+            dogs.add(new Dog("D" + i, true, false, 5, 1000.0));
+        }
+
+        List<Adopter> adopters = Arrays.asList(
+                new Adopter("A1", "Alice", true, true, 2, 50000.0, 5)  // Max 2 dogs
+        );
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        List<String> assignedToAlice = result.assignments.get("A1");
+        if (assignedToAlice != null) {
+            assertTrue(assignedToAlice.size() <= 2,
+                    "Should not exceed maxDogs limit of 2");
+        }
+    }
+
+    @Test
+    @DisplayName("Backtracking: Respects budget constraint")
+    void testBudgetConstraint() {
+        // Arrange
+        List<Dog> dogs = Arrays.asList(
+                new Dog("Cheap", true, false, 5, 5000.0),
+                new Dog("Expensive", true, false, 5, 20000.0)
+        );
+        List<Adopter> adopters = Arrays.asList(
+                new Adopter("LowBudget", "Bob", true, true, 5, 6000.0, 5)
+        );
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        List<String> assignedToBob = result.assignments.get("LowBudget");
+        if (assignedToBob != null) {
+            // Calculate total cost
+            double totalCost = 0.0;
+            for (String dogId : assignedToBob) {
+                for (Dog dog : dogs) {
+                    if (dog.id.equals(dogId)) {
+                        totalCost += dog.cost;
+                        break;
+                    }
+                }
+            }
+            assertTrue(totalCost <= 6000.0, "Total cost should not exceed budget");
+
+            // Should not include expensive dog
+            assertFalse(assignedToBob.contains("Expensive"),
+                    "Expensive dog should not be assigned when budget insufficient");
+        }
+    }
+
+    // ==================== Score Maximization Tests ====================
+
+    @Test
+    @DisplayName("Backtracking: Maximizes total score")
+    void testMaximizesScore() {
+        // Arrange
+        List<Dog> dogs = createSimpleDogs();
+        List<Adopter> adopters = createSimpleAdopters();
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        assertTrue(result.totalScore >= 0, "Total score should be non-negative");
+        assertNotNull(result.assignments);
+    }
+
+    @Test
+    @DisplayName("Backtracking: Prefers better matches")
+    void testPrefersBetterMatches() {
+        // Arrange
+        // Dog with kids + garden compatibility
+        List<Dog> dogs = Arrays.asList(
+                new Dog("Perfect", true, true, 5, 5000.0),  // Perfect match
+                new Dog("OK", false, false, 8, 5000.0)      // Poor match
+        );
+
+        // Adopter with kids and garden
+        List<Adopter> adopters = Arrays.asList(
+                new Adopter("A1", "Alice", true, true, 1, 10000.0, 5)
+        );
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        List<String> assignedToAlice = result.assignments.get("A1");
+        if (assignedToAlice != null && !assignedToAlice.isEmpty()) {
+            // Should prefer Perfect match over OK
+            assertTrue(assignedToAlice.contains("Perfect"),
+                    "Should assign better matching dog");
+        }
+    }
+
+    // ==================== Multiple Adopters Tests ====================
+
+    @Test
+    @DisplayName("Backtracking: Distributes dogs among multiple adopters")
+    void testMultipleAdopters() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+        for (int i = 1; i <= 5; i++) {
+            dogs.add(new Dog("D" + i, true, false, 5, 3000.0));
+        }
+
+        List<Adopter> adopters = new ArrayList<>();
+        adopters.add(new Adopter("A1", "Alice", true, true, 2, 10000.0, 5));
+        adopters.add(new Adopter("A2", "Bob", true, true, 2, 10000.0, 5));
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        int totalAssigned = 0;
+        for (List<String> dogList : result.assignments.values()) {
+            totalAssigned += dogList.size();
+        }
+
+        assertTrue(totalAssigned > 0, "Should assign at least some dogs");
+        assertTrue(totalAssigned <= dogs.size(), "Should not assign more dogs than available");
+    }
+
+    @Test
+    @DisplayName("Backtracking: Each dog assigned to at most one adopter")
+    void testNoDuplicateAssignments() {
+        // Arrange
+        List<Dog> dogs = createSimpleDogs();
+        List<Adopter> adopters = createSimpleAdopters();
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        Set<String> allAssignedDogs = new HashSet<>();
+        for (List<String> dogList : result.assignments.values()) {
+            for (String dogId : dogList) {
+                assertFalse(allAssignedDogs.contains(dogId),
+                        "Dog " + dogId + " assigned to multiple adopters");
+                allAssignedDogs.add(dogId);
+            }
+        }
+    }
+
+    // ==================== Energy Compatibility Tests ====================
+
+    @Test
+    @DisplayName("Backtracking: Energy compatibility affects score")
+    void testEnergyCompatibility() {
+        // Arrange
+        List<Dog> dogs = Arrays.asList(
+                new Dog("MatchingEnergy", true, false, 5, 3000.0),  // Energy 5
+                new Dog("MismatchEnergy", true, false, 10, 3000.0)  // Energy 10
+        );
+
+        List<Adopter> adopters = Arrays.asList(
+                new Adopter("A1", "Alice", true, true, 1, 10000.0, 5)  // Prefers energy 5
+        );
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        List<String> assignedToAlice = result.assignments.get("A1");
+        if (assignedToAlice != null && !assignedToAlice.isEmpty()) {
+            // Should prefer matching energy
+            assertTrue(assignedToAlice.contains("MatchingEnergy"),
+                    "Should prefer dog with matching energy level");
+        }
+    }
+
+    // ==================== Performance and Timeout Tests ====================
+
+    @Test
+    @DisplayName("Backtracking: Completes within reasonable time")
+    void testCompletesInReasonableTime() {
+        // Arrange - 10 dogs and 3 adopters
+        List<Dog> dogs = new ArrayList<>();
+        for (int i = 1; i <= 10; i++) {
+            dogs.add(new Dog("D" + i, true, false, 5, 5000.0));
+        }
+
+        List<Adopter> adopters = new ArrayList<>();
+        for (int i = 1; i <= 3; i++) {
+            adopters.add(new Adopter("A" + i, "Adopter" + i, true, true, 5, 50000.0, 5));
+        }
+
+        // Act
+        long start = System.currentTimeMillis();
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+        long duration = System.currentTimeMillis() - start;
+
+        // Assert
+        assertNotNull(result);
+        assertTrue(duration < 10000, "Should complete within 10 seconds");
+    }
+
+    @Test
+    @DisplayName("Backtracking: Handles 20 dogs (service limit)")
+    void testHandles20Dogs() {
+        // Arrange - Exactly 20 dogs (the service's internal limit)
+        List<Dog> dogs = new ArrayList<>();
+        for (int i = 1; i <= 20; i++) {
+            dogs.add(new Dog("D" + i, true, false, 5, 3000.0));
+        }
+
+        List<Adopter> adopters = Arrays.asList(
+                new Adopter("A1", "Alice", true, true, 10, 100000.0, 5)
+        );
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        assertNotNull(result);
+        assertTrue(result.totalScore >= 0);
+    }
+
+    @Test
+    @DisplayName("Backtracking: Limits dogs to 20 when more provided")
+    void testLimitsDogs() {
+        // Arrange - 30 dogs (exceeds service's 20-dog limit)
+        List<Dog> dogs = new ArrayList<>();
+        for (int i = 1; i <= 30; i++) {
+            dogs.add(new Dog("D" + i, true, false, 5, 3000.0));
+        }
+
+        List<Adopter> adopters = Arrays.asList(
+                new Adopter("A1", "Alice", true, true, 30, 100000.0, 5)
+        );
+
+        // Act - Should limit to first 20 dogs internally
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        assertNotNull(result);
+        // Count assigned dogs
+        int totalAssigned = 0;
+        for (List<String> dogList : result.assignments.values()) {
+            totalAssigned += dogList.size();
+        }
+        assertTrue(totalAssigned <= 20, "Service should limit to 20 dogs");
+    }
+
+    // ==================== Edge Cases ====================
+
+    @Test
+    @DisplayName("Backtracking: No valid assignments returns zero score")
+    void testNoValidAssignments() {
+        // Arrange - Dog needs garden, adopter has no garden
+        List<Dog> dogs = Arrays.asList(
+                new Dog("NeedsGarden", true, true, 5, 5000.0)
+        );
+        List<Adopter> adopters = Arrays.asList(
+                new Adopter("NoGarden", "Bob", true, false, 1, 10000.0, 5)
+        );
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        List<String> assignedToBob = result.assignments.get("NoGarden");
+        if (assignedToBob != null) {
+            assertFalse(assignedToBob.contains("NeedsGarden"),
+                    "Should not assign dog needing garden to adopter without garden");
+        }
+    }
+
+    @Test
+    @DisplayName("Backtracking: All dogs too expensive")
+    void testAllDogsTooExpensive() {
+        // Arrange
+        List<Dog> dogs = Arrays.asList(
+                new Dog("Expensive1", true, false, 5, 50000.0),
+                new Dog("Expensive2", true, false, 5, 60000.0)
+        );
+        List<Adopter> adopters = Arrays.asList(
+                new Adopter("LowBudget", "Bob", true, true, 5, 1000.0, 5)
+        );
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        List<String> assignedToBob = result.assignments.get("LowBudget");
+        assertTrue(assignedToBob == null || assignedToBob.isEmpty(),
+                "Should not assign any dogs when all exceed budget");
+    }
+
+    @Test
+    @DisplayName("Backtracking: Adopter maxDogs is zero")
+    void testAdopterMaxDogsZero() {
+        // Arrange
+        List<Dog> dogs = createSimpleDogs();
+        List<Adopter> adopters = Arrays.asList(
+                new Adopter("A1", "Alice", true, true, 0, 50000.0, 5)  // Max 0 dogs
+        );
+
+        // Act
+        Assignment result = backtrackingService.findBestAssignment(dogs, adopters);
+
+        // Assert
+        List<String> assignedToAlice = result.assignments.get("A1");
+        assertTrue(assignedToAlice == null || assignedToAlice.isEmpty(),
+                "Should not assign any dogs when maxDogs is 0");
+    }
+
+    // ==================== Helper Methods ====================
+
+    private boolean allAssignmentsEmpty(Map<String, List<String>> assignments) {
+        for (List<String> dogList : assignments.values()) {
+            if (!dogList.isEmpty()) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/GraphServiceTest.java b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/GraphServiceTest.java
new file mode 100644
index 000000000..9fc8082f7
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/GraphServiceTest.java
@@ -0,0 +1,391 @@
+package com.programacion3.adoptme.service;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+@DisplayName("GraphService Unit Tests")
+class GraphServiceTest {
+
+    private GraphService graphService;
+
+    @Mock
+    private GraphLoader graphLoader;
+
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+        graphService = new GraphService(graphLoader);
+    }
+
+    private Map<String, List<String>> createTestGraph() {
+        /*
+         * Test graph structure:
+         *   A -> B -> C
+         *   |         |
+         *   v         v
+         *   D -> E -> F
+         *   |
+         *   v
+         *   G (isolated: H)
+         */
+        Map<String, List<String>> graph = new HashMap<>();
+        graph.put("A", Arrays.asList("B", "D"));
+        graph.put("B", Arrays.asList("C"));
+        graph.put("C", Arrays.asList("F"));
+        graph.put("D", Arrays.asList("E", "G"));
+        graph.put("E", Arrays.asList("F"));
+        graph.put("F", new ArrayList<>());
+        graph.put("G", new ArrayList<>());
+        graph.put("H", new ArrayList<>()); // Isolated node
+        return graph;
+    }
+
+    private Map<String, List<String>> createComplexGraph() {
+        /*
+         * Complex graph with multiple paths:
+         *   A -> B -> D
+         *   |    |    |
+         *   v    v    v
+         *   C -> E -> F
+         *        |
+         *        v
+         *        G
+         */
+        Map<String, List<String>> graph = new HashMap<>();
+        graph.put("A", Arrays.asList("B", "C"));
+        graph.put("B", Arrays.asList("D", "E"));
+        graph.put("C", Arrays.asList("E"));
+        graph.put("D", Arrays.asList("F"));
+        graph.put("E", Arrays.asList("F", "G"));
+        graph.put("F", new ArrayList<>());
+        graph.put("G", new ArrayList<>());
+        return graph;
+    }
+
+    // ==================== BFS Tests ====================
+
+    @Test
+    @DisplayName("BFS: Simple path A->B")
+    void testBfsSimplePath() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createTestGraph());
+
+        // Act
+        List<String> path = graphService.bfsPath("A", "B");
+
+        // Assert
+        assertNotNull(path);
+        assertEquals(2, path.size());
+        assertEquals("A", path.get(0));
+        assertEquals("B", path.get(1));
+    }
+
+    @Test
+    @DisplayName("BFS: Path A->F (multiple hops)")
+    void testBfsMultipleHops() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createTestGraph());
+
+        // Act
+        List<String> path = graphService.bfsPath("A", "F");
+
+        // Assert
+        assertNotNull(path);
+        assertFalse(path.isEmpty());
+        assertEquals("A", path.get(0));
+        assertEquals("F", path.get(path.size() - 1));
+
+        // BFS should find shortest path (3 hops: A->B->C->F or A->D->E->F)
+        assertEquals(4, path.size());
+    }
+
+    @Test
+    @DisplayName("BFS: No path to isolated node")
+    void testBfsNoPath() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createTestGraph());
+
+        // Act
+        List<String> path = graphService.bfsPath("A", "H");
+
+        // Assert
+        assertNotNull(path);
+        assertTrue(path.isEmpty(), "Should return empty list when no path exists");
+    }
+
+    @Test
+    @DisplayName("BFS: Same source and destination")
+    void testBfsSameNode() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createTestGraph());
+
+        // Act
+        List<String> path = graphService.bfsPath("A", "A");
+
+        // Assert
+        assertNotNull(path);
+        assertEquals(1, path.size());
+        assertEquals("A", path.get(0));
+    }
+
+    @Test
+    @DisplayName("BFS: Null source returns empty")
+    void testBfsNullSource() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createTestGraph());
+
+        // Act
+        List<String> path = graphService.bfsPath(null, "B");
+
+        // Assert
+        assertNotNull(path);
+        assertTrue(path.isEmpty());
+    }
+
+    @Test
+    @DisplayName("BFS: Null destination returns empty")
+    void testBfsNullDestination() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createTestGraph());
+
+        // Act
+        List<String> path = graphService.bfsPath("A", null);
+
+        // Assert
+        assertNotNull(path);
+        assertTrue(path.isEmpty());
+    }
+
+    @Test
+    @DisplayName("BFS: Blank source returns empty")
+    void testBfsBlankSource() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createTestGraph());
+
+        // Act
+        List<String> path = graphService.bfsPath("  ", "B");
+
+        // Assert
+        assertNotNull(path);
+        assertTrue(path.isEmpty());
+    }
+
+    @Test
+    @DisplayName("BFS: Finds shortest path in graph with multiple routes")
+    void testBfsShortestPath() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createComplexGraph());
+
+        // Act
+        List<String> path = graphService.bfsPath("A", "F");
+
+        // Assert
+        assertNotNull(path);
+        assertEquals("A", path.get(0));
+        assertEquals("F", path.get(path.size() - 1));
+
+        // Should find shortest: A->B->D->F (4 nodes) or A->B->E->F (4 nodes)
+        assertEquals(4, path.size());
+    }
+
+    @Test
+    @DisplayName("BFS: Path from intermediate node")
+    void testBfsFromIntermediateNode() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createTestGraph());
+
+        // Act
+        List<String> path = graphService.bfsPath("D", "F");
+
+        // Assert
+        assertNotNull(path);
+        assertEquals("D", path.get(0));
+        assertEquals("F", path.get(path.size() - 1));
+        assertEquals(3, path.size()); // D->E->F
+    }
+
+    // ==================== DFS Tests ====================
+
+    @Test
+    @DisplayName("DFS: Simple path A->B")
+    void testDfsSimplePath() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createTestGraph());
+
+        // Act
+        List<String> path = graphService.dfsPath("A", "B");
+
+        // Assert
+        assertNotNull(path);
+        assertFalse(path.isEmpty());
+        assertEquals("A", path.get(0));
+        assertEquals("B", path.get(path.size() - 1));
+    }
+
+    @Test
+    @DisplayName("DFS: Path A->F (deep search)")
+    void testDfsDeepPath() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createTestGraph());
+
+        // Act
+        List<String> path = graphService.dfsPath("A", "F");
+
+        // Assert
+        assertNotNull(path);
+        assertFalse(path.isEmpty());
+        assertEquals("A", path.get(0));
+        assertEquals("F", path.get(path.size() - 1));
+
+        // DFS finds A path, not necessarily shortest
+        assertTrue(path.size() >= 4); // At least 4 nodes
+    }
+
+    @Test
+    @DisplayName("DFS: No path to isolated node")
+    void testDfsNoPath() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createTestGraph());
+
+        // Act
+        List<String> path = graphService.dfsPath("A", "H");
+
+        // Assert
+        assertNotNull(path);
+        assertTrue(path.isEmpty(), "Should return empty list when no path exists");
+    }
+
+    @Test
+    @DisplayName("DFS: Same source and destination")
+    void testDfsSameNode() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createTestGraph());
+
+        // Act
+        List<String> path = graphService.dfsPath("A", "A");
+
+        // Assert
+        assertNotNull(path);
+        assertEquals(1, path.size());
+        assertEquals("A", path.get(0));
+    }
+
+    @Test
+    @DisplayName("DFS: Null source returns empty")
+    void testDfsNullSource() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createTestGraph());
+
+        // Act
+        List<String> path = graphService.dfsPath(null, "B");
+
+        // Assert
+        assertNotNull(path);
+        assertTrue(path.isEmpty());
+    }
+
+    @Test
+    @DisplayName("DFS: Path from intermediate node")
+    void testDfsFromIntermediateNode() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createTestGraph());
+
+        // Act
+        List<String> path = graphService.dfsPath("D", "G");
+
+        // Assert
+        assertNotNull(path);
+        assertEquals("D", path.get(0));
+        assertEquals("G", path.get(path.size() - 1));
+    }
+
+    @Test
+    @DisplayName("DFS: Finds path in complex graph")
+    void testDfsComplexGraph() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createComplexGraph());
+
+        // Act
+        List<String> path = graphService.dfsPath("A", "G");
+
+        // Assert
+        assertNotNull(path);
+        assertFalse(path.isEmpty());
+        assertEquals("A", path.get(0));
+        assertEquals("G", path.get(path.size() - 1));
+
+        // Verify path is valid (each consecutive pair has edge)
+        Map<String, List<String>> graph = createComplexGraph();
+        for (int i = 0; i < path.size() - 1; i++) {
+            String from = path.get(i);
+            String to = path.get(i + 1);
+            assertTrue(graph.get(from).contains(to),
+                    "Invalid path: no edge from " + from + " to " + to);
+        }
+    }
+
+    @Test
+    @DisplayName("DFS: Empty graph returns empty path")
+    void testDfsEmptyGraph() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(new HashMap<>());
+
+        // Act
+        List<String> path = graphService.dfsPath("A", "B");
+
+        // Assert
+        assertNotNull(path);
+        assertTrue(path.isEmpty());
+    }
+
+    @Test
+    @DisplayName("BFS: Empty graph returns empty path")
+    void testBfsEmptyGraph() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(new HashMap<>());
+
+        // Act
+        List<String> path = graphService.bfsPath("A", "B");
+
+        // Assert
+        assertNotNull(path);
+        assertTrue(path.isEmpty());
+    }
+
+    // ==================== Comparison Tests ====================
+
+    @Test
+    @DisplayName("BFS vs DFS: Both find path but may differ")
+    void testBfsVsDfs() {
+        // Arrange
+        when(graphLoader.loadAdjacency()).thenReturn(createComplexGraph());
+
+        // Act
+        List<String> bfsPath = graphService.bfsPath("A", "F");
+        List<String> dfsPath = graphService.dfsPath("A", "F");
+
+        // Assert
+        assertNotNull(bfsPath);
+        assertNotNull(dfsPath);
+        assertFalse(bfsPath.isEmpty());
+        assertFalse(dfsPath.isEmpty());
+
+        // Both should start at A and end at F
+        assertEquals("A", bfsPath.get(0));
+        assertEquals("F", bfsPath.get(bfsPath.size() - 1));
+        assertEquals("A", dfsPath.get(0));
+        assertEquals("F", dfsPath.get(dfsPath.size() - 1));
+
+        // BFS should find shortest or equal path
+        assertTrue(bfsPath.size() <= dfsPath.size(),
+                "BFS should find shortest path: BFS=" + bfsPath.size() + " vs DFS=" + dfsPath.size());
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/MSTServiceTest.java b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/MSTServiceTest.java
new file mode 100644
index 000000000..3f8face02
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/MSTServiceTest.java
@@ -0,0 +1,465 @@
+package com.programacion3.adoptme.service;
+
+import com.programacion3.adoptme.service.MSTService.Edge;
+import com.programacion3.adoptme.service.MSTService.MSTResult;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DisplayName("MSTService (Kruskal & Prim) Unit Tests")
+class MSTServiceTest {
+
+    private MSTService mstService;
+
+    @BeforeEach
+    void setUp() {
+        mstService = new MSTService();
+    }
+
+    private List<Edge> createSimpleGraph() {
+        /*
+         * Simple graph:
+         *   A --5-- B
+         *   |       |
+         *   10      3
+         *   |       |
+         *   C --2-- D
+         *
+         * MST should be: A-B (5), B-D (3), C-D (2) = 10
+         */
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 5.0, "NEAR"));
+        edges.add(new Edge("A", "C", 10.0, "NEAR"));
+        edges.add(new Edge("B", "D", 3.0, "NEAR"));
+        edges.add(new Edge("C", "D", 2.0, "NEAR"));
+        return edges;
+    }
+
+    private List<Edge> createComplexGraph() {
+        /*
+         * Complex graph:
+         *   A --1-- B --4-- E
+         *   |       |       |
+         *   2       1       2
+         *   |       |       |
+         *   C --3-- D --5-- F
+         *   |               |
+         *   6-------8-------G
+         *
+         * MST edges: A-B(1), B-D(1), A-C(2), E-F(2), C-D(3), C-G(6) = 15
+         * (or similar with same total weight)
+         */
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 1.0, "NEAR"));
+        edges.add(new Edge("A", "C", 2.0, "NEAR"));
+        edges.add(new Edge("B", "D", 1.0, "NEAR"));
+        edges.add(new Edge("B", "E", 4.0, "NEAR"));
+        edges.add(new Edge("C", "D", 3.0, "NEAR"));
+        edges.add(new Edge("C", "G", 6.0, "NEAR"));
+        edges.add(new Edge("D", "F", 5.0, "NEAR"));
+        edges.add(new Edge("E", "F", 2.0, "NEAR"));
+        edges.add(new Edge("F", "G", 8.0, "NEAR"));
+        return edges;
+    }
+
+    private List<Edge> createDisconnectedGraph() {
+        /*
+         * Disconnected graph:
+         *   A --5-- B       C --3-- D
+         *
+         * Can only create MST for connected components
+         */
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 5.0, "NEAR"));
+        edges.add(new Edge("C", "D", 3.0, "NEAR"));
+        return edges;
+    }
+
+    // ==================== Kruskal Tests ====================
+
+    @Test
+    @DisplayName("Kruskal: Simple graph MST")
+    void testKruskalSimpleGraph() {
+        // Arrange
+        List<Edge> edges = createSimpleGraph();
+        Set<String> nodes = Set.of("A", "B", "C", "D");
+
+        // Act
+        MSTResult result = mstService.compute(nodes, edges);
+
+        // Assert
+        assertEquals(10.0, result.totalWeight, 0.01, "Total MST weight should be 10");
+        assertEquals(3, result.edges.size(), "MST should have n-1 edges for n nodes");
+
+        // Verify no cycles (MST property)
+        assertTrue(isValidMST(result.edges, nodes), "Result should be a valid spanning tree");
+    }
+
+    @Test
+    @DisplayName("Kruskal: Complex graph MST")
+    void testKruskalComplexGraph() {
+        // Arrange
+        List<Edge> edges = createComplexGraph();
+        Set<String> nodes = Set.of("A", "B", "C", "D", "E", "F", "G");
+
+        // Act
+        MSTResult result = mstService.compute(nodes, edges);
+
+        // Assert
+        assertEquals(15.0, result.totalWeight, 0.01, "Total MST weight should be 15");
+        assertEquals(6, result.edges.size(), "MST should have 6 edges for 7 nodes");
+        assertTrue(isValidMST(result.edges, nodes), "Result should be a valid spanning tree");
+    }
+
+    @Test
+    @DisplayName("Kruskal: Empty graph")
+    void testKruskalEmptyGraph() {
+        // Arrange
+        List<Edge> edges = new ArrayList<>();
+        Set<String> nodes = new HashSet<>();
+
+        // Act
+        MSTResult result = mstService.compute(nodes, edges);
+
+        // Assert
+        assertEquals(0.0, result.totalWeight, 0.01);
+        assertTrue(result.edges.isEmpty());
+    }
+
+    @Test
+    @DisplayName("Kruskal: Single node")
+    void testKruskalSingleNode() {
+        // Arrange
+        List<Edge> edges = new ArrayList<>();
+        Set<String> nodes = Set.of("A");
+
+        // Act
+        MSTResult result = mstService.compute(nodes, edges);
+
+        // Assert
+        assertEquals(0.0, result.totalWeight, 0.01);
+        assertTrue(result.edges.isEmpty(), "Single node has no edges in MST");
+    }
+
+    @Test
+    @DisplayName("Kruskal: Two nodes connected")
+    void testKruskalTwoNodes() {
+        // Arrange
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 5.0, "NEAR"));
+        Set<String> nodes = Set.of("A", "B");
+
+        // Act
+        MSTResult result = mstService.compute(nodes, edges);
+
+        // Assert
+        assertEquals(5.0, result.totalWeight, 0.01);
+        assertEquals(1, result.edges.size());
+    }
+
+    @Test
+    @DisplayName("Kruskal: Disconnected graph (subset)")
+    void testKruskalDisconnectedSubset() {
+        // Arrange
+        List<Edge> edges = createDisconnectedGraph();
+        Set<String> nodes = Set.of("A", "B"); // Only connected component
+
+        // Act
+        MSTResult result = mstService.compute(nodes, edges);
+
+        // Assert
+        assertEquals(5.0, result.totalWeight, 0.01);
+        assertEquals(1, result.edges.size());
+    }
+
+    @Test
+    @DisplayName("Kruskal: Filters non-NEAR edges")
+    void testKruskalFiltersEdgeTypes() {
+        // Arrange
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 5.0, "NEAR"));
+        edges.add(new Edge("B", "C", 3.0, "OTHER")); // Wrong type, should be ignored
+        edges.add(new Edge("A", "C", 10.0, "NEAR"));
+        Set<String> nodes = Set.of("A", "B", "C");
+
+        // Act
+        MSTResult result = mstService.compute(nodes, edges);
+
+        // Assert
+        // Should use A-B (5) and A-C (10) = 15, ignoring B-C (OTHER type)
+        assertEquals(15.0, result.totalWeight, 0.01);
+        assertEquals(2, result.edges.size());
+    }
+
+    // ==================== Prim Tests ====================
+
+    @Test
+    @DisplayName("Prim: Simple graph MST")
+    void testPrimSimpleGraph() {
+        // Arrange
+        List<Edge> edges = createSimpleGraph();
+        Set<String> nodes = Set.of("A", "B", "C", "D");
+
+        // Act
+        MSTResult result = mstService.computeWithPrim(nodes, edges);
+
+        // Assert
+        assertEquals(10.0, result.totalWeight, 0.01, "Total MST weight should be 10");
+        assertEquals(3, result.edges.size(), "MST should have n-1 edges for n nodes");
+        assertTrue(isValidMST(result.edges, nodes), "Result should be a valid spanning tree");
+    }
+
+    @Test
+    @DisplayName("Prim: Complex graph MST")
+    void testPrimComplexGraph() {
+        // Arrange
+        List<Edge> edges = createComplexGraph();
+        Set<String> nodes = Set.of("A", "B", "C", "D", "E", "F", "G");
+
+        // Act
+        MSTResult result = mstService.computeWithPrim(nodes, edges);
+
+        // Assert
+        assertEquals(15.0, result.totalWeight, 0.01, "Total MST weight should be 15");
+        assertEquals(6, result.edges.size(), "MST should have 6 edges for 7 nodes");
+        assertTrue(isValidMST(result.edges, nodes), "Result should be a valid spanning tree");
+    }
+
+    @Test
+    @DisplayName("Prim: Empty graph")
+    void testPrimEmptyGraph() {
+        // Arrange
+        List<Edge> edges = new ArrayList<>();
+        Set<String> nodes = new HashSet<>();
+
+        // Act
+        MSTResult result = mstService.computeWithPrim(nodes, edges);
+
+        // Assert
+        assertEquals(0.0, result.totalWeight, 0.01);
+        assertTrue(result.edges.isEmpty());
+    }
+
+    @Test
+    @DisplayName("Prim: Single node")
+    void testPrimSingleNode() {
+        // Arrange
+        List<Edge> edges = new ArrayList<>();
+        Set<String> nodes = Set.of("A");
+
+        // Act
+        MSTResult result = mstService.computeWithPrim(nodes, edges);
+
+        // Assert
+        assertEquals(0.0, result.totalWeight, 0.01);
+        assertTrue(result.edges.isEmpty(), "Single node has no edges in MST");
+    }
+
+    @Test
+    @DisplayName("Prim: Two nodes connected")
+    void testPrimTwoNodes() {
+        // Arrange
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 5.0, "NEAR"));
+        Set<String> nodes = Set.of("A", "B");
+
+        // Act
+        MSTResult result = mstService.computeWithPrim(nodes, edges);
+
+        // Assert
+        assertEquals(5.0, result.totalWeight, 0.01);
+        assertEquals(1, result.edges.size());
+    }
+
+    @Test
+    @DisplayName("Prim: Filters non-NEAR edges")
+    void testPrimFiltersEdgeTypes() {
+        // Arrange
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 5.0, "NEAR"));
+        edges.add(new Edge("B", "C", 3.0, "OTHER")); // Wrong type
+        edges.add(new Edge("A", "C", 10.0, "NEAR"));
+        Set<String> nodes = Set.of("A", "B", "C");
+
+        // Act
+        MSTResult result = mstService.computeWithPrim(nodes, edges);
+
+        // Assert
+        assertEquals(15.0, result.totalWeight, 0.01);
+        assertEquals(2, result.edges.size());
+    }
+
+    // ==================== Kruskal vs Prim Comparison ====================
+
+    @Test
+    @DisplayName("Kruskal vs Prim: Same MST weight")
+    void testKruskalVsPrimSameWeight() {
+        // Arrange
+        List<Edge> edges = createComplexGraph();
+        Set<String> nodes = Set.of("A", "B", "C", "D", "E", "F", "G");
+
+        // Act
+        MSTResult kruskalResult = mstService.compute(nodes, edges);
+        MSTResult primResult = mstService.computeWithPrim(nodes, edges);
+
+        // Assert
+        assertEquals(kruskalResult.totalWeight, primResult.totalWeight, 0.01,
+                "Both algorithms should produce MST with same total weight");
+        assertEquals(kruskalResult.edges.size(), primResult.edges.size(),
+                "Both algorithms should have same number of edges");
+    }
+
+    @Test
+    @DisplayName("Kruskal vs Prim: Both produce valid MSTs")
+    void testBothProduceValidMSTs() {
+        // Arrange
+        List<Edge> edges = createSimpleGraph();
+        Set<String> nodes = Set.of("A", "B", "C", "D");
+
+        // Act
+        MSTResult kruskalResult = mstService.compute(nodes, edges);
+        MSTResult primResult = mstService.computeWithPrim(nodes, edges);
+
+        // Assert
+        assertTrue(isValidMST(kruskalResult.edges, nodes), "Kruskal should produce valid MST");
+        assertTrue(isValidMST(primResult.edges, nodes), "Prim should produce valid MST");
+        assertEquals(kruskalResult.totalWeight, primResult.totalWeight, 0.01);
+    }
+
+    // ==================== Weight Tests ====================
+
+    @Test
+    @DisplayName("MST: Selects minimum weight edges")
+    void testSelectsMinimumWeightEdges() {
+        // Arrange - Graph where wrong choice leads to higher weight
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 1.0, "NEAR"));
+        edges.add(new Edge("B", "C", 2.0, "NEAR"));
+        edges.add(new Edge("C", "D", 3.0, "NEAR"));
+        edges.add(new Edge("A", "D", 100.0, "NEAR")); // Expensive shortcut
+        Set<String> nodes = Set.of("A", "B", "C", "D");
+
+        // Act
+        MSTResult kruskalResult = mstService.compute(nodes, edges);
+        MSTResult primResult = mstService.computeWithPrim(nodes, edges);
+
+        // Assert - Should choose 1+2+3=6, not include the 100 edge
+        assertEquals(6.0, kruskalResult.totalWeight, 0.01);
+        assertEquals(6.0, primResult.totalWeight, 0.01);
+    }
+
+    @Test
+    @DisplayName("MST: Handles equal weight edges")
+    void testEqualWeightEdges() {
+        // Arrange - Multiple edges with same weight
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 5.0, "NEAR"));
+        edges.add(new Edge("B", "C", 5.0, "NEAR"));
+        edges.add(new Edge("C", "D", 5.0, "NEAR"));
+        edges.add(new Edge("A", "D", 5.0, "NEAR"));
+        Set<String> nodes = Set.of("A", "B", "C", "D");
+
+        // Act
+        MSTResult result = mstService.compute(nodes, edges);
+
+        // Assert
+        assertEquals(15.0, result.totalWeight, 0.01, "Should select any 3 edges");
+        assertEquals(3, result.edges.size());
+    }
+
+    // ==================== Performance Tests ====================
+
+    @Test
+    @DisplayName("Kruskal: Handles larger graphs")
+    void testKruskalLargerGraph() {
+        // Arrange - Create a complete graph of 10 nodes
+        List<Edge> edges = new ArrayList<>();
+        Set<String> nodes = new HashSet<>();
+        for (int i = 0; i < 10; i++) {
+            nodes.add("N" + i);
+            for (int j = i + 1; j < 10; j++) {
+                edges.add(new Edge("N" + i, "N" + j, i + j + 1.0, "NEAR"));
+            }
+        }
+
+        // Act
+        long start = System.currentTimeMillis();
+        MSTResult result = mstService.compute(nodes, edges);
+        long duration = System.currentTimeMillis() - start;
+
+        // Assert
+        assertEquals(9, result.edges.size(), "Should have n-1 edges for n nodes");
+        assertTrue(result.totalWeight > 0);
+        assertTrue(duration < 1000, "Should complete within 1 second");
+    }
+
+    @Test
+    @DisplayName("Prim: Handles larger graphs")
+    void testPrimLargerGraph() {
+        // Arrange - Create a complete graph of 10 nodes
+        List<Edge> edges = new ArrayList<>();
+        Set<String> nodes = new HashSet<>();
+        for (int i = 0; i < 10; i++) {
+            nodes.add("N" + i);
+            for (int j = i + 1; j < 10; j++) {
+                edges.add(new Edge("N" + i, "N" + j, i + j + 1.0, "NEAR"));
+            }
+        }
+
+        // Act
+        long start = System.currentTimeMillis();
+        MSTResult result = mstService.computeWithPrim(nodes, edges);
+        long duration = System.currentTimeMillis() - start;
+
+        // Assert
+        assertEquals(9, result.edges.size(), "Should have n-1 edges for n nodes");
+        assertTrue(result.totalWeight > 0);
+        assertTrue(duration < 1000, "Should complete within 1 second");
+    }
+
+    // ==================== Helper Methods ====================
+
+    /**
+     * Validates that the result is a valid MST:
+     * - Has exactly n-1 edges for n nodes
+     * - Is connected (all nodes reachable)
+     * - Has no cycles
+     */
+    private boolean isValidMST(List<Edge> edges, Set<String> nodes) {
+        if (nodes.isEmpty()) return edges.isEmpty();
+        if (edges.size() != nodes.size() - 1) return false;
+
+        // Build adjacency list
+        Map<String, List<String>> adj = new HashMap<>();
+        for (String node : nodes) {
+            adj.put(node, new ArrayList<>());
+        }
+        for (Edge e : edges) {
+            adj.get(e.a).add(e.b);
+            adj.get(e.b).add(e.a);
+        }
+
+        // Check connectivity using BFS
+        Set<String> visited = new HashSet<>();
+        Queue<String> queue = new LinkedList<>();
+        String start = nodes.iterator().next();
+        queue.offer(start);
+        visited.add(start);
+
+        while (!queue.isEmpty()) {
+            String current = queue.poll();
+            for (String neighbor : adj.get(current)) {
+                if (!visited.contains(neighbor)) {
+                    visited.add(neighbor);
+                    queue.offer(neighbor);
+                }
+            }
+        }
+
+        return visited.size() == nodes.size();
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/ScorerServiceTest.java b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/ScorerServiceTest.java
new file mode 100644
index 000000000..2229b9635
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/ScorerServiceTest.java
@@ -0,0 +1,453 @@
+package com.programacion3.adoptme.service;
+
+import com.programacion3.adoptme.service.ScorerService.Dog;
+import com.programacion3.adoptme.service.ScorerService.AssignmentResult;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DisplayName("ScorerService (Greedy) Unit Tests")
+class ScorerServiceTest {
+
+    private ScorerService scorerService;
+
+    @BeforeEach
+    void setUp() {
+        scorerService = new ScorerService();
+    }
+
+    private List<Dog> createTestDogs() {
+        List<Dog> dogs = new ArrayList<>();
+
+        // Perfect for adopter with kids and garden
+        dogs.add(new Dog("D1", true, true, 5, 2, 9000.0));  // goodWithKids, needsGarden, moderate energy
+
+        // Not good with kids
+        dogs.add(new Dog("D2", false, false, 7, 1, 7000.0)); // No kids, no garden
+
+        // Needs garden
+        dogs.add(new Dog("D3", true, true, 3, 3, 11000.0)); // goodWithKids, needsGarden, low energy, large
+
+        // High energy
+        dogs.add(new Dog("D4", true, false, 10, 1, 7000.0)); // goodWithKids, high energy
+
+        // Low cost, good all-around
+        dogs.add(new Dog("D5", true, false, 5, 1, 5000.0)); // Cheap, moderate
+
+        return dogs;
+    }
+
+    // ==================== Basic Assignment Tests ====================
+
+    @Test
+    @DisplayName("Greedy: Empty candidates returns empty assignment")
+    void testEmptyCandidates() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+
+        // Act
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 3, 50000.0);
+
+        // Assert
+        assertTrue(result.assigned.isEmpty());
+        assertEquals(0.0, result.totalScore, 0.01);
+        assertEquals(0.0, result.totalCost, 0.01);
+    }
+
+    @Test
+    @DisplayName("Greedy: Single dog within budget")
+    void testSingleDogWithinBudget() {
+        // Arrange
+        List<Dog> dogs = Arrays.asList(
+                new Dog("D1", true, true, 5, 2, 9000.0)
+        );
+
+        // Act
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 3, 10000.0);
+
+        // Assert
+        assertEquals(1, result.assigned.size());
+        assertEquals("D1", result.assigned.get(0).id);
+        assertEquals(9000.0, result.totalCost, 0.01);
+        assertTrue(result.totalScore > 0);
+    }
+
+    @Test
+    @DisplayName("Greedy: Selects highest scoring dogs first")
+    void testSelectsHighestScoring() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+
+        // Act - Adopter with kids and garden
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 5, 50000.0);
+
+        // Assert
+        assertFalse(result.assigned.isEmpty());
+        assertTrue(result.totalCost <= 50000.0, "Should not exceed budget");
+
+        // D1 and D3 should score highest (kids + garden match)
+        List<String> assignedIds = new ArrayList<>();
+        for (Dog dog : result.assigned) {
+            assignedIds.add(dog.id);
+        }
+        assertTrue(assignedIds.contains("D1"), "Should include D1 (perfect match)");
+    }
+
+    // ==================== Budget Constraint Tests ====================
+
+    @Test
+    @DisplayName("Greedy: Respects budget constraint")
+    void testRespectsBudget() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+        double budget = 15000.0;
+
+        // Act
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 10, budget);
+
+        // Assert
+        assertTrue(result.totalCost <= budget, "Total cost should not exceed budget");
+    }
+
+    @Test
+    @DisplayName("Greedy: Zero budget returns empty")
+    void testZeroBudget() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+
+        // Act
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 3, 0.0);
+
+        // Assert
+        assertTrue(result.assigned.isEmpty());
+        assertEquals(0.0, result.totalCost, 0.01);
+    }
+
+    @Test
+    @DisplayName("Greedy: Tight budget selects cheaper dogs")
+    void testTightBudget() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+        dogs.add(new Dog("Cheap1", true, true, 5, 1, 1000.0));
+        dogs.add(new Dog("Cheap2", true, true, 5, 1, 2000.0));
+        dogs.add(new Dog("Expensive", true, true, 5, 1, 50000.0));
+
+        // Act - Budget only allows 2 cheap dogs
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 10, 3000.0);
+
+        // Assert
+        assertEquals(2, result.assigned.size());
+        assertTrue(result.totalCost <= 3000.0);
+    }
+
+    @Test
+    @DisplayName("Greedy: Large budget allows all dogs within maxDogs")
+    void testLargeBudget() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+
+        // Act
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 3, 100000.0);
+
+        // Assert
+        assertEquals(3, result.assigned.size(), "Should assign up to maxDogs limit");
+        assertTrue(result.totalCost > 0);
+    }
+
+    // ==================== MaxDogs Constraint Tests ====================
+
+    @Test
+    @DisplayName("Greedy: Respects maxDogs limit")
+    void testRespectsMaxDogs() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+        int maxDogs = 2;
+
+        // Act
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, maxDogs, 50000.0);
+
+        // Assert
+        assertTrue(result.assigned.size() <= maxDogs, "Should not exceed maxDogs");
+    }
+
+    @Test
+    @DisplayName("Greedy: MaxDogs of zero returns empty")
+    void testMaxDogsZero() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+
+        // Act
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 0, 50000.0);
+
+        // Assert
+        assertTrue(result.assigned.isEmpty());
+    }
+
+    @Test
+    @DisplayName("Greedy: MaxDogs of one selects best dog")
+    void testMaxDogsOne() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+
+        // Act
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 1, 50000.0);
+
+        // Assert
+        assertEquals(1, result.assigned.size());
+        // Should select highest scoring dog that fits budget
+    }
+
+    // ==================== Scoring Criteria Tests ====================
+
+    @Test
+    @DisplayName("Greedy: Kids constraint affects scoring")
+    void testKidsConstraint() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+        dogs.add(new Dog("GoodWithKids", true, false, 5, 2, 9000.0));
+        dogs.add(new Dog("NotGoodWithKids", false, false, 5, 2, 9000.0));
+
+        // Act - Adopter with kids
+        AssignmentResult withKids = scorerService.scoreAndAssign(dogs, true, false, 5, 50000.0);
+
+        // Act - Adopter without kids
+        AssignmentResult withoutKids = scorerService.scoreAndAssign(dogs, false, false, 5, 50000.0);
+
+        // Assert
+        // With kids: should prefer GoodWithKids (higher score)
+        if (!withKids.assigned.isEmpty()) {
+            assertEquals("GoodWithKids", withKids.assigned.get(0).id);
+        }
+
+        // Without kids: both have similar scores, but both should be acceptable
+        assertFalse(withoutKids.assigned.isEmpty());
+    }
+
+    @Test
+    @DisplayName("Greedy: Garden constraint affects scoring")
+    void testGardenConstraint() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+        dogs.add(new Dog("NeedsGarden", true, true, 5, 2, 9000.0));
+        dogs.add(new Dog("NoGarden", true, false, 5, 2, 9000.0));
+
+        // Act - Adopter with garden
+        AssignmentResult withGarden = scorerService.scoreAndAssign(dogs, true, true, 5, 50000.0);
+
+        // Act - Adopter without garden
+        AssignmentResult withoutGarden = scorerService.scoreAndAssign(dogs, true, false, 5, 50000.0);
+
+        // Assert
+        // With garden: should prefer NeedsGarden (higher score)
+        if (!withGarden.assigned.isEmpty()) {
+            assertEquals("NeedsGarden", withGarden.assigned.get(0).id);
+        }
+
+        // Without garden: NoGarden should score higher
+        if (!withoutGarden.assigned.isEmpty()) {
+            assertEquals("NoGarden", withoutGarden.assigned.get(0).id);
+        }
+    }
+
+    @Test
+    @DisplayName("Greedy: Energy preference affects scoring")
+    void testEnergyPreference() {
+        // Arrange - Dogs with different energy levels
+        List<Dog> dogs = new ArrayList<>();
+        dogs.add(new Dog("LowEnergy", true, true, 1, 2, 9000.0));    // Energy 1
+        dogs.add(new Dog("MidEnergy", true, true, 5, 2, 9000.0));    // Energy 5
+        dogs.add(new Dog("HighEnergy", true, true, 10, 2, 9000.0));  // Energy 10
+
+        // Act - All else equal, moderate energy (5) should score best
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 1, 10000.0);
+
+        // Assert
+        assertEquals(1, result.assigned.size());
+        // Moderate energy (5) should be preferred (closest to ideal 5)
+        assertEquals("MidEnergy", result.assigned.get(0).id);
+    }
+
+    // ==================== Size Preference Tests ====================
+
+    @Test
+    @DisplayName("Greedy: Size affects scoring slightly")
+    void testSizePreference() {
+        // Arrange - Dogs with different sizes, all else equal
+        List<Dog> dogs = new ArrayList<>();
+        dogs.add(new Dog("Small", true, true, 5, 1, 7000.0));   // Size 1
+        dogs.add(new Dog("Medium", true, true, 5, 2, 9000.0));  // Size 2
+        dogs.add(new Dog("Large", true, true, 5, 3, 11000.0));  // Size 3
+
+        // Act - With large budget, should prefer smaller (slightly higher score)
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 1, 8000.0);
+
+        // Assert
+        assertEquals(1, result.assigned.size());
+        assertEquals("Small", result.assigned.get(0).id);
+    }
+
+    // ==================== Combined Constraints Tests ====================
+
+    @Test
+    @DisplayName("Greedy: Multiple constraints combined")
+    void testMultipleConstraints() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+
+        // Act - Adopter: has kids, has garden, maxDogs=2, budget=20000
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 2, 20000.0);
+
+        // Assert
+        assertTrue(result.assigned.size() <= 2, "Should respect maxDogs");
+        assertTrue(result.totalCost <= 20000.0, "Should respect budget");
+
+        // Verify all assigned dogs are good with kids
+        for (Dog dog : result.assigned) {
+            assertTrue(dog.goodWithKids, "All assigned dogs should be good with kids");
+        }
+    }
+
+    @Test
+    @DisplayName("Greedy: No kids adopter excludes bad-with-kids dogs in prioritization")
+    void testNoKidsAdopter() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+        dogs.add(new Dog("Perfect1", true, false, 5, 2, 9000.0));
+        dogs.add(new Dog("Perfect2", false, false, 5, 2, 9000.0));
+
+        // Act - Adopter without kids
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, false, false, 5, 50000.0);
+
+        // Assert - Both dogs should be acceptable
+        assertEquals(2, result.assigned.size());
+    }
+
+    // ==================== Score and Cost Validation ====================
+
+    @Test
+    @DisplayName("Greedy: Total cost equals sum of assigned dog costs")
+    void testTotalCostCalculation() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+
+        // Act
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 3, 30000.0);
+
+        // Assert
+        double calculatedCost = 0.0;
+        for (Dog dog : result.assigned) {
+            calculatedCost += dog.cost;
+        }
+        assertEquals(calculatedCost, result.totalCost, 0.01);
+    }
+
+    @Test
+    @DisplayName("Greedy: Total score is positive when dogs assigned")
+    void testTotalScorePositive() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+
+        // Act
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 3, 30000.0);
+
+        // Assert
+        if (!result.assigned.isEmpty()) {
+            assertTrue(result.totalScore > 0, "Total score should be positive when dogs are assigned");
+        }
+    }
+
+    @Test
+    @DisplayName("Greedy: Better match produces higher score")
+    void testBetterMatchHigherScore() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+        dogs.add(new Dog("PerfectMatch", true, true, 5, 1, 5000.0));
+
+        // Act
+        AssignmentResult perfectMatch = scorerService.scoreAndAssign(dogs, true, true, 1, 10000.0);
+        AssignmentResult poorMatch = scorerService.scoreAndAssign(dogs, false, false, 1, 10000.0);
+
+        // Assert
+        assertTrue(perfectMatch.totalScore >= poorMatch.totalScore,
+                "Perfect match should have equal or higher score than poor match");
+    }
+
+    // ==================== Greedy Selection Order Tests ====================
+
+    @Test
+    @DisplayName("Greedy: Selects dogs in descending score order")
+    void testGreedySelectionOrder() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+        dogs.add(new Dog("Best", true, true, 5, 1, 1000.0));     // Highest score
+        dogs.add(new Dog("Good", true, false, 5, 1, 1000.0));    // Medium score
+        dogs.add(new Dog("OK", false, false, 5, 1, 1000.0));     // Lower score
+
+        // Act - With kids and garden, "Best" should be selected first
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 1, 10000.0);
+
+        // Assert
+        assertEquals(1, result.assigned.size());
+        assertEquals("Best", result.assigned.get(0).id);
+    }
+
+    @Test
+    @DisplayName("Greedy: Fills capacity with highest scoring affordable dogs")
+    void testFillsCapacityOptimally() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+        dogs.add(new Dog("D1", true, true, 5, 1, 5000.0));   // High score
+        dogs.add(new Dog("D2", true, true, 5, 1, 5000.0));   // High score
+        dogs.add(new Dog("D3", true, true, 5, 1, 5000.0));   // High score
+        dogs.add(new Dog("D4", false, false, 8, 3, 5000.0)); // Lower score
+
+        // Act - Can afford 3 dogs
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 5, 15000.0);
+
+        // Assert
+        assertEquals(3, result.assigned.size());
+        // Should select D1, D2, D3 (highest scores)
+        List<String> assignedIds = new ArrayList<>();
+        for (Dog dog : result.assigned) {
+            assignedIds.add(dog.id);
+        }
+        assertTrue(assignedIds.contains("D1"));
+        assertTrue(assignedIds.contains("D2"));
+        assertTrue(assignedIds.contains("D3"));
+    }
+
+    // ==================== Edge Cases ====================
+
+    @Test
+    @DisplayName("Greedy: Negative max dogs returns empty")
+    void testNegativeMaxDogs() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+
+        // Act
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, -1, 50000.0);
+
+        // Assert
+        assertTrue(result.assigned.isEmpty());
+    }
+
+    @Test
+    @DisplayName("Greedy: All dogs too expensive")
+    void testAllDogsTooExpensive() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+        dogs.add(new Dog("Expensive1", true, true, 5, 2, 50000.0));
+        dogs.add(new Dog("Expensive2", true, true, 5, 2, 60000.0));
+
+        // Act
+        AssignmentResult result = scorerService.scoreAndAssign(dogs, true, true, 5, 1000.0);
+
+        // Assert
+        assertTrue(result.assigned.isEmpty(), "Should not assign any dogs if all exceed budget");
+        assertEquals(0.0, result.totalCost, 0.01);
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/ShortestPathServiceTest.java b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/ShortestPathServiceTest.java
new file mode 100644
index 000000000..c894e7940
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/ShortestPathServiceTest.java
@@ -0,0 +1,400 @@
+package com.programacion3.adoptme.service;
+
+import com.programacion3.adoptme.service.ShortestPathService.Edge;
+import com.programacion3.adoptme.service.ShortestPathService.PathResult;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DisplayName("ShortestPathService (Dijkstra) Unit Tests")
+class ShortestPathServiceTest {
+
+    private ShortestPathService shortestPathService;
+
+    @BeforeEach
+    void setUp() {
+        shortestPathService = new ShortestPathService();
+    }
+
+    private List<Edge> createSimpleGraph() {
+        /*
+         * Simple graph:
+         *   A --5-- B
+         *   |       |
+         *   10      3
+         *   |       |
+         *   C --2-- D
+         */
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 5.0));
+        edges.add(new Edge("A", "C", 10.0));
+        edges.add(new Edge("B", "D", 3.0));
+        edges.add(new Edge("C", "D", 2.0));
+        return edges;
+    }
+
+    private List<Edge> createComplexGraph() {
+        /*
+         * Complex graph with multiple paths:
+         *   A --1-- B --4-- E
+         *   |       |       |
+         *   2       1       2
+         *   |       |       |
+         *   C --3-- D --5-- F
+         *   |               |
+         *   6-------8-------G
+         */
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 1.0));
+        edges.add(new Edge("A", "C", 2.0));
+        edges.add(new Edge("B", "D", 1.0));
+        edges.add(new Edge("B", "E", 4.0));
+        edges.add(new Edge("C", "D", 3.0));
+        edges.add(new Edge("C", "G", 6.0));
+        edges.add(new Edge("D", "F", 5.0));
+        edges.add(new Edge("E", "F", 2.0));
+        edges.add(new Edge("G", "F", 8.0));
+        return edges;
+    }
+
+    private List<Edge> createDisconnectedGraph() {
+        /*
+         * Disconnected graph:
+         *   A --5-- B
+         *
+         *   C --3-- D
+         */
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 5.0));
+        edges.add(new Edge("C", "D", 3.0));
+        return edges;
+    }
+
+    // ==================== Basic Path Tests ====================
+
+    @Test
+    @DisplayName("Dijkstra: Direct edge A->B")
+    void testDirectPath() {
+        // Arrange
+        List<Edge> edges = createSimpleGraph();
+
+        // Act
+        PathResult result = shortestPathService.shortestPath("A", "B", edges);
+
+        // Assert
+        assertEquals(5.0, result.cost, 0.01);
+        assertEquals(2, result.path.size());
+        assertEquals("A", result.path.get(0));
+        assertEquals("B", result.path.get(1));
+    }
+
+    @Test
+    @DisplayName("Dijkstra: Shortest path A->D (through B, not C)")
+    void testShortestPathChoice() {
+        // Arrange
+        List<Edge> edges = createSimpleGraph();
+
+        // Act
+        PathResult result = shortestPathService.shortestPath("A", "D", edges);
+
+        // Assert
+        // Should choose A->B->D (5+3=8) instead of A->C->D (10+2=12)
+        assertEquals(8.0, result.cost, 0.01);
+        assertEquals(3, result.path.size());
+        assertEquals("A", result.path.get(0));
+        assertEquals("B", result.path.get(1));
+        assertEquals("D", result.path.get(2));
+    }
+
+    @Test
+    @DisplayName("Dijkstra: Same start and goal")
+    void testSameNode() {
+        // Arrange
+        List<Edge> edges = createSimpleGraph();
+
+        // Act
+        PathResult result = shortestPathService.shortestPath("A", "A", edges);
+
+        // Assert
+        assertEquals(0.0, result.cost, 0.01);
+        assertEquals(1, result.path.size());
+        assertEquals("A", result.path.get(0));
+    }
+
+    @Test
+    @DisplayName("Dijkstra: No path to disconnected node")
+    void testNoPath() {
+        // Arrange
+        List<Edge> edges = createDisconnectedGraph();
+
+        // Act
+        PathResult result = shortestPathService.shortestPath("A", "C", edges);
+
+        // Assert
+        assertEquals(Double.POSITIVE_INFINITY, result.cost);
+        assertTrue(result.path.isEmpty(), "Path should be empty when unreachable");
+    }
+
+    // ==================== Complex Graph Tests ====================
+
+    @Test
+    @DisplayName("Dijkstra: Complex graph A->F")
+    void testComplexGraphShortestPath() {
+        // Arrange
+        List<Edge> edges = createComplexGraph();
+
+        // Act
+        PathResult result = shortestPathService.shortestPath("A", "F", edges);
+
+        // Assert
+        // Shortest: A->B->E->F = 1+4+2 = 7
+        // Alternative: A->B->D->F = 1+1+5 = 7
+        // Alternative: A->C->D->F = 2+3+5 = 10
+        assertEquals(7.0, result.cost, 0.01);
+        assertFalse(result.path.isEmpty());
+        assertEquals("A", result.path.get(0));
+        assertEquals("F", result.path.get(result.path.size() - 1));
+    }
+
+    @Test
+    @DisplayName("Dijkstra: Complex graph A->G")
+    void testComplexGraphLongerPath() {
+        // Arrange
+        List<Edge> edges = createComplexGraph();
+
+        // Act
+        PathResult result = shortestPathService.shortestPath("A", "G", edges);
+
+        // Assert
+        // Shortest: A->C->G = 2+6 = 8
+        // Alternative: A->B->E->F->G = 1+4+2+8 = 15
+        assertEquals(8.0, result.cost, 0.01);
+        assertEquals("A", result.path.get(0));
+        assertEquals("G", result.path.get(result.path.size() - 1));
+    }
+
+    @Test
+    @DisplayName("Dijkstra: Path from intermediate node")
+    void testFromIntermediateNode() {
+        // Arrange
+        List<Edge> edges = createComplexGraph();
+
+        // Act
+        PathResult result = shortestPathService.shortestPath("C", "E", edges);
+
+        // Assert
+        // Shortest: C->D->B->E or similar
+        assertFalse(result.path.isEmpty());
+        assertEquals("C", result.path.get(0));
+        assertEquals("E", result.path.get(result.path.size() - 1));
+        assertTrue(result.cost > 0);
+    }
+
+    // ==================== Edge Cases ====================
+
+    @Test
+    @DisplayName("Dijkstra: Empty edge collection")
+    void testEmptyEdges() {
+        // Arrange
+        List<Edge> edges = new ArrayList<>();
+
+        // Act
+        PathResult result = shortestPathService.shortestPath("A", "B", edges);
+
+        // Assert
+        assertEquals(Double.POSITIVE_INFINITY, result.cost);
+        assertTrue(result.path.isEmpty());
+    }
+
+    @Test
+    @DisplayName("Dijkstra: Single node (no edges)")
+    void testSingleNodeNoEdges() {
+        // Arrange
+        List<Edge> edges = new ArrayList<>();
+
+        // Act
+        PathResult result = shortestPathService.shortestPath("A", "A", edges);
+
+        // Assert
+        assertEquals(0.0, result.cost, 0.01);
+        assertEquals(1, result.path.size());
+        assertEquals("A", result.path.get(0));
+    }
+
+    @Test
+    @DisplayName("Dijkstra: Nonexistent start node")
+    void testNonexistentStartNode() {
+        // Arrange
+        List<Edge> edges = createSimpleGraph();
+
+        // Act
+        PathResult result = shortestPathService.shortestPath("Z", "A", edges);
+
+        // Assert
+        assertEquals(Double.POSITIVE_INFINITY, result.cost);
+        assertTrue(result.path.isEmpty());
+    }
+
+    @Test
+    @DisplayName("Dijkstra: Nonexistent goal node")
+    void testNonexistentGoalNode() {
+        // Arrange
+        List<Edge> edges = createSimpleGraph();
+
+        // Act
+        PathResult result = shortestPathService.shortestPath("A", "Z", edges);
+
+        // Assert
+        assertEquals(Double.POSITIVE_INFINITY, result.cost);
+        assertTrue(result.path.isEmpty());
+    }
+
+    // ==================== Weight Tests ====================
+
+    @Test
+    @DisplayName("Dijkstra: Handles different weights correctly")
+    void testDifferentWeights() {
+        // Arrange - Graph with varying weights
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 100.0));
+        edges.add(new Edge("A", "C", 50.0));
+        edges.add(new Edge("C", "D", 20.0));
+        edges.add(new Edge("D", "B", 10.0));
+
+        // Act
+        PathResult result = shortestPathService.shortestPath("A", "B", edges);
+
+        // Assert
+        // Should choose A->C->D->B (50+20+10=80) instead of A->B (100)
+        assertEquals(80.0, result.cost, 0.01);
+        assertEquals(4, result.path.size());
+    }
+
+    @Test
+    @DisplayName("Dijkstra: Handles small decimal weights")
+    void testDecimalWeights() {
+        // Arrange
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 0.5));
+        edges.add(new Edge("B", "C", 0.7));
+        edges.add(new Edge("A", "C", 1.5));
+
+        // Act
+        PathResult result = shortestPathService.shortestPath("A", "C", edges);
+
+        // Assert
+        // Should choose A->B->C (0.5+0.7=1.2) instead of A->C (1.5)
+        assertEquals(1.2, result.cost, 0.01);
+        assertEquals(3, result.path.size());
+    }
+
+    // ==================== Bidirectional Graph Tests ====================
+
+    @Test
+    @DisplayName("Dijkstra: Works bidirectionally (service adds reverse edges)")
+    void testBidirectionalPath() {
+        // Arrange - Only add edges in one direction
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 5.0));
+        edges.add(new Edge("B", "C", 3.0));
+
+        // Act - Try to go backwards
+        PathResult resultForward = shortestPathService.shortestPath("A", "C", edges);
+        PathResult resultBackward = shortestPathService.shortestPath("C", "A", edges);
+
+        // Assert - Should work both ways (service creates bidirectional graph)
+        assertEquals(8.0, resultForward.cost, 0.01);
+        assertEquals(8.0, resultBackward.cost, 0.01);
+        assertFalse(resultForward.path.isEmpty());
+        assertFalse(resultBackward.path.isEmpty());
+    }
+
+    // ==================== Path Validation Tests ====================
+
+    @Test
+    @DisplayName("Dijkstra: Path is valid and continuous")
+    void testPathContinuity() {
+        // Arrange
+        List<Edge> edges = createComplexGraph();
+
+        // Act
+        PathResult result = shortestPathService.shortestPath("A", "F", edges);
+
+        // Assert
+        assertFalse(result.path.isEmpty());
+
+        // Build adjacency for validation (bidirectional)
+        Map<String, Set<String>> adj = new HashMap<>();
+        for (Edge e : edges) {
+            adj.computeIfAbsent(e.from, k -> new HashSet<>()).add(e.to);
+            adj.computeIfAbsent(e.to, k -> new HashSet<>()).add(e.from);
+        }
+
+        // Verify each consecutive pair in path has an edge
+        for (int i = 0; i < result.path.size() - 1; i++) {
+            String from = result.path.get(i);
+            String to = result.path.get(i + 1);
+            assertTrue(adj.containsKey(from) && adj.get(from).contains(to),
+                    "Invalid path: no edge between " + from + " and " + to);
+        }
+    }
+
+    @Test
+    @DisplayName("Dijkstra: Cost matches path edges")
+    void testCostMatchesPath() {
+        // Arrange
+        List<Edge> edges = createSimpleGraph();
+
+        // Act
+        PathResult result = shortestPathService.shortestPath("A", "D", edges);
+
+        // Assert
+        // Build edge weight map (bidirectional)
+        Map<String, Map<String, Double>> weights = new HashMap<>();
+        for (Edge e : edges) {
+            weights.computeIfAbsent(e.from, k -> new HashMap<>()).put(e.to, e.weight);
+            weights.computeIfAbsent(e.to, k -> new HashMap<>()).put(e.from, e.weight);
+        }
+
+        // Calculate cost from path
+        double calculatedCost = 0.0;
+        for (int i = 0; i < result.path.size() - 1; i++) {
+            String from = result.path.get(i);
+            String to = result.path.get(i + 1);
+            calculatedCost += weights.get(from).get(to);
+        }
+
+        assertEquals(result.cost, calculatedCost, 0.01,
+                "Reported cost should match sum of edge weights in path");
+    }
+
+    // ==================== Large Graph Performance ====================
+
+    @Test
+    @DisplayName("Dijkstra: Handles larger graphs efficiently")
+    void testLargerGraph() {
+        // Arrange - Create a chain of 20 nodes
+        List<Edge> edges = new ArrayList<>();
+        for (int i = 0; i < 19; i++) {
+            String from = "N" + i;
+            String to = "N" + (i + 1);
+            edges.add(new Edge(from, to, 1.0));
+        }
+
+        // Act
+        long startTime = System.currentTimeMillis();
+        PathResult result = shortestPathService.shortestPath("N0", "N19", edges);
+        long duration = System.currentTimeMillis() - startTime;
+
+        // Assert
+        assertEquals(19.0, result.cost, 0.01);
+        assertEquals(20, result.path.size());
+        assertEquals("N0", result.path.get(0));
+        assertEquals("N19", result.path.get(19));
+        assertTrue(duration < 1000, "Should complete within 1 second");
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/SortServiceTest.java b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/SortServiceTest.java
new file mode 100644
index 000000000..51f1c62a7
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/SortServiceTest.java
@@ -0,0 +1,256 @@
+package com.programacion3.adoptme.service;
+
+import com.programacion3.adoptme.domain.Dog;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DisplayName("SortService Unit Tests")
+class SortServiceTest {
+
+    private SortService sortService;
+    private List<Dog> testDogs;
+
+    @BeforeEach
+    void setUp() {
+        sortService = new SortService();
+        testDogs = createTestDogs();
+    }
+
+    private List<Dog> createTestDogs() {
+        List<Dog> dogs = new ArrayList<>();
+
+        Dog dog1 = new Dog();
+        dog1.setId("D1");
+        dog1.setName("Luna");
+        dog1.setPriority(5);
+        dog1.setAge(3);
+        dog1.setWeightKg(10);
+        dogs.add(dog1);
+
+        Dog dog2 = new Dog();
+        dog2.setId("D2");
+        dog2.setName("Max");
+        dog2.setPriority(8);
+        dog2.setAge(1);
+        dog2.setWeightKg(25);
+        dogs.add(dog2);
+
+        Dog dog3 = new Dog();
+        dog3.setId("D3");
+        dog3.setName("Bella");
+        dog3.setPriority(3);
+        dog3.setAge(5);
+        dog3.setWeightKg(15);
+        dogs.add(dog3);
+
+        Dog dog4 = new Dog();
+        dog4.setId("D4");
+        dog4.setName("Charlie");
+        dog4.setPriority(10);
+        dog4.setAge(2);
+        dog4.setWeightKg(8);
+        dogs.add(dog4);
+
+        return dogs;
+    }
+
+    @Test
+    @DisplayName("Sort by priority using MergeSort - ascending order")
+    void testSortByPriorityMergeSort() {
+        // Act
+        sortService.sortDogs(testDogs, "priority", "mergesort");
+
+        // Assert
+        assertEquals("D3", testDogs.get(0).getId()); // priority 3
+        assertEquals("D1", testDogs.get(1).getId()); // priority 5
+        assertEquals("D2", testDogs.get(2).getId()); // priority 8
+        assertEquals("D4", testDogs.get(3).getId()); // priority 10
+
+        // Verify ascending order
+        for (int i = 0; i < testDogs.size() - 1; i++) {
+            assertTrue(testDogs.get(i).getPriority() <= testDogs.get(i + 1).getPriority(),
+                    "Dogs should be sorted in ascending order by priority");
+        }
+    }
+
+    @Test
+    @DisplayName("Sort by priority using QuickSort - ascending order")
+    void testSortByPriorityQuickSort() {
+        // Act
+        sortService.sortDogs(testDogs, "priority", "quicksort");
+
+        // Assert
+        assertEquals(3, testDogs.get(0).getPriority());
+        assertEquals(5, testDogs.get(1).getPriority());
+        assertEquals(8, testDogs.get(2).getPriority());
+        assertEquals(10, testDogs.get(3).getPriority());
+
+        // Verify ascending order
+        for (int i = 0; i < testDogs.size() - 1; i++) {
+            assertTrue(testDogs.get(i).getPriority() <= testDogs.get(i + 1).getPriority());
+        }
+    }
+
+    @Test
+    @DisplayName("Sort by age using MergeSort")
+    void testSortByAgeMergeSort() {
+        // Act
+        sortService.sortDogs(testDogs, "age", "mergesort");
+
+        // Assert
+        assertEquals(1, testDogs.get(0).getAge());
+        assertEquals(2, testDogs.get(1).getAge());
+        assertEquals(3, testDogs.get(2).getAge());
+        assertEquals(5, testDogs.get(3).getAge());
+
+        // Verify ascending order
+        for (int i = 0; i < testDogs.size() - 1; i++) {
+            assertTrue(testDogs.get(i).getAge() <= testDogs.get(i + 1).getAge());
+        }
+    }
+
+    @Test
+    @DisplayName("Sort by age using QuickSort")
+    void testSortByAgeQuickSort() {
+        // Act
+        sortService.sortDogs(testDogs, "age", "quicksort");
+
+        // Assert
+        for (int i = 0; i < testDogs.size() - 1; i++) {
+            assertTrue(testDogs.get(i).getAge() <= testDogs.get(i + 1).getAge());
+        }
+    }
+
+    @Test
+    @DisplayName("Sort by weight using MergeSort")
+    void testSortByWeightMergeSort() {
+        // Act
+        sortService.sortDogs(testDogs, "weight", "mergesort");
+
+        // Assert
+        assertEquals(8, testDogs.get(0).getWeight());
+        assertEquals(10, testDogs.get(1).getWeight());
+        assertEquals(15, testDogs.get(2).getWeight());
+        assertEquals(25, testDogs.get(3).getWeight());
+
+        // Verify ascending order
+        for (int i = 0; i < testDogs.size() - 1; i++) {
+            assertTrue(testDogs.get(i).getWeight() <= testDogs.get(i + 1).getWeight());
+        }
+    }
+
+    @Test
+    @DisplayName("Sort by weight using QuickSort")
+    void testSortByWeightQuickSort() {
+        // Act
+        sortService.sortDogs(testDogs, "weight", "quicksort");
+
+        // Assert
+        for (int i = 0; i < testDogs.size() - 1; i++) {
+            assertTrue(testDogs.get(i).getWeight() <= testDogs.get(i + 1).getWeight());
+        }
+    }
+
+    @Test
+    @DisplayName("Sort with invalid criteria throws exception")
+    void testSortWithInvalidCriteria() {
+        // Act & Assert
+        assertThrows(IllegalArgumentException.class, () -> {
+            sortService.sortDogs(testDogs, "invalid", "mergesort");
+        });
+    }
+
+    @Test
+    @DisplayName("Sort empty list does not throw exception")
+    void testSortEmptyList() {
+        // Arrange
+        List<Dog> emptyList = new ArrayList<>();
+
+        // Act & Assert - should not throw
+        assertDoesNotThrow(() -> {
+            sortService.sortDogs(emptyList, "priority", "mergesort");
+        });
+    }
+
+    @Test
+    @DisplayName("Sort single element list")
+    void testSortSingleElement() {
+        // Arrange
+        List<Dog> singleDog = new ArrayList<>();
+        singleDog.add(testDogs.get(0));
+
+        // Act
+        sortService.sortDogs(singleDog, "priority", "quicksort");
+
+        // Assert
+        assertEquals(1, singleDog.size());
+        assertEquals("D1", singleDog.get(0).getId());
+    }
+
+    @Test
+    @DisplayName("Sort maintains stability for equal elements")
+    void testSortStability() {
+        // Arrange - Create dogs with same priority but different names
+        List<Dog> dogs = new ArrayList<>();
+
+        Dog dog1 = new Dog();
+        dog1.setId("D1");
+        dog1.setName("Alpha");
+        dog1.setPriority(5);
+        dogs.add(dog1);
+
+        Dog dog2 = new Dog();
+        dog2.setId("D2");
+        dog2.setName("Beta");
+        dog2.setPriority(5);
+        dogs.add(dog2);
+
+        // Act
+        sortService.sortDogs(dogs, "priority", "mergesort");
+
+        // Assert - MergeSort should maintain original order for equal priorities
+        assertEquals(5, dogs.get(0).getPriority());
+        assertEquals(5, dogs.get(1).getPriority());
+    }
+
+    @Test
+    @DisplayName("Sort large dataset")
+    void testSortLargeDataset() {
+        // Arrange - Create 100 dogs with random priorities
+        List<Dog> largeDogList = new ArrayList<>();
+        for (int i = 0; i < 100; i++) {
+            Dog dog = new Dog();
+            dog.setId("D" + i);
+            dog.setPriority((i * 7) % 20); // pseudo-random priorities
+            dog.setAge((i * 3) % 10);
+            dog.setWeightKg(5 + (i % 30));
+            largeDogList.add(dog);
+        }
+
+        // Act
+        sortService.sortDogs(largeDogList, "priority", "quicksort");
+
+        // Assert - Verify sorted
+        for (int i = 0; i < largeDogList.size() - 1; i++) {
+            assertTrue(largeDogList.get(i).getPriority() <= largeDogList.get(i + 1).getPriority());
+        }
+    }
+
+    @Test
+    @DisplayName("Sort defaults to MergeSort when algorithm not specified")
+    void testDefaultAlgorithm() {
+        // Act
+        sortService.sortDogs(testDogs, "priority");
+
+        // Assert - Should be sorted
+        for (int i = 0; i < testDogs.size() - 1; i++) {
+            assertTrue(testDogs.get(i).getPriority() <= testDogs.get(i + 1).getPriority());
+        }
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/TSPServiceTest.java b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/TSPServiceTest.java
new file mode 100644
index 000000000..18720c1b2
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/TSPServiceTest.java
@@ -0,0 +1,445 @@
+package com.programacion3.adoptme.service;
+
+import com.programacion3.adoptme.service.TSPService.Edge;
+import com.programacion3.adoptme.service.TSPService.TSPResult;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DisplayName("TSPService (Branch & Bound) Unit Tests")
+class TSPServiceTest {
+
+    private TSPService tspService;
+
+    @BeforeEach
+    void setUp() {
+        tspService = new TSPService();
+    }
+
+    private List<Edge> createSimpleTriangle() {
+        /*
+         * Triangle:
+         *   A --5-- B
+         *   |       |
+         *   10      3
+         *   |       |
+         *   C ------+
+         *      7
+         *
+         * Optimal tour: A->B->C->A = 5+3+10 = 18
+         * or A->C->B->A = 10+7+3 = 20
+         */
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 5.0));
+        edges.add(new Edge("B", "C", 3.0));
+        edges.add(new Edge("A", "C", 10.0));
+        return edges;
+    }
+
+    private List<Edge> createSquareGraph() {
+        /*
+         * Square with diagonals:
+         *   A --1-- B
+         *   |   X   |
+         *   2   3   4
+         *   |   X   |
+         *   C --5-- D
+         *
+         * Optimal tour: A->B->D->C->A = 1+4+5+2 = 12
+         */
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 1.0));
+        edges.add(new Edge("B", "D", 4.0));
+        edges.add(new Edge("D", "C", 5.0));
+        edges.add(new Edge("C", "A", 2.0));
+        edges.add(new Edge("A", "D", 10.0)); // Diagonal
+        edges.add(new Edge("B", "C", 8.0)); // Diagonal
+        return edges;
+    }
+
+    private List<Edge> createCompleteGraph4() {
+        /*
+         * Complete graph with 4 nodes
+         */
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 2.0));
+        edges.add(new Edge("A", "C", 3.0));
+        edges.add(new Edge("A", "D", 4.0));
+        edges.add(new Edge("B", "C", 5.0));
+        edges.add(new Edge("B", "D", 6.0));
+        edges.add(new Edge("C", "D", 7.0));
+        return edges;
+    }
+
+    // ==================== Basic TSP Tests ====================
+
+    @Test
+    @DisplayName("TSP: Empty nodes returns empty tour")
+    void testEmptyNodes() {
+        // Arrange
+        List<String> nodes = new ArrayList<>();
+        List<Edge> edges = new ArrayList<>();
+
+        // Act
+        TSPResult result = tspService.solveTSP(nodes, edges);
+
+        // Assert
+        assertTrue(result.route.isEmpty());
+        assertEquals(0.0, result.totalDistance, 0.01);
+    }
+
+    @Test
+    @DisplayName("TSP: Single node returns zero distance")
+    void testSingleNode() {
+        // Arrange
+        List<String> nodes = Arrays.asList("A");
+        List<Edge> edges = new ArrayList<>();
+
+        // Act
+        TSPResult result = tspService.solveTSP(nodes, edges);
+
+        // Assert
+        assertEquals(1, result.route.size());
+        assertEquals("A", result.route.get(0));
+        assertEquals(0.0, result.totalDistance, 0.01);
+    }
+
+    @Test
+    @DisplayName("TSP: Two nodes simple tour")
+    void testTwoNodes() {
+        // Arrange
+        List<String> nodes = Arrays.asList("A", "B");
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 5.0));
+
+        // Act
+        TSPResult result = tspService.solveTSP(nodes, edges);
+
+        // Assert
+        assertFalse(result.route.isEmpty());
+        assertEquals("A", result.route.get(0));
+        assertEquals("A", result.route.get(result.route.size() - 1));
+        assertEquals(10.0, result.totalDistance, 0.01); // A->B->A = 5+5
+    }
+
+    @Test
+    @DisplayName("TSP: Triangle optimal tour")
+    void testTriangleOptimalTour() {
+        // Arrange
+        List<String> nodes = Arrays.asList("A", "B", "C");
+        List<Edge> edges = createSimpleTriangle();
+
+        // Act
+        TSPResult result = tspService.solveTSP(nodes, edges);
+
+        // Assert
+        assertFalse(result.route.isEmpty());
+        assertEquals("A", result.route.get(0));
+        assertEquals("A", result.route.get(result.route.size() - 1));
+
+        // Should find A->B->C->A = 5+3+10 = 18
+        assertEquals(18.0, result.totalDistance, 0.01);
+        assertEquals(4, result.route.size()); // A, B, C, A
+    }
+
+    @Test
+    @DisplayName("TSP: Square optimal tour")
+    void testSquareOptimalTour() {
+        // Arrange
+        List<String> nodes = Arrays.asList("A", "B", "C", "D");
+        List<Edge> edges = createSquareGraph();
+
+        // Act
+        TSPResult result = tspService.solveTSP(nodes, edges);
+
+        // Assert
+        assertFalse(result.route.isEmpty());
+        assertEquals("A", result.route.get(0));
+        assertEquals("A", result.route.get(result.route.size() - 1));
+
+        // Should find A->B->D->C->A = 1+4+5+2 = 12
+        assertEquals(12.0, result.totalDistance, 0.01);
+        assertEquals(5, result.route.size()); // A, B, D, C, A
+    }
+
+    // ==================== Tour Validation Tests ====================
+
+    @Test
+    @DisplayName("TSP: Tour visits all nodes exactly once")
+    void testTourVisitsAllNodes() {
+        // Arrange
+        List<String> nodes = Arrays.asList("A", "B", "C", "D");
+        List<Edge> edges = createSquareGraph();
+
+        // Act
+        TSPResult result = tspService.solveTSP(nodes, edges);
+
+        // Assert
+        Set<String> visitedNodes = new HashSet<>();
+        for (int i = 0; i < result.route.size() - 1; i++) {
+            visitedNodes.add(result.route.get(i));
+        }
+
+        assertEquals(nodes.size(), visitedNodes.size(),
+                "Should visit all nodes exactly once (excluding return)");
+
+        for (String node : nodes) {
+            assertTrue(visitedNodes.contains(node),
+                    "Tour should include node: " + node);
+        }
+    }
+
+    @Test
+    @DisplayName("TSP: Tour returns to start")
+    void testTourReturnsToStart() {
+        // Arrange
+        List<String> nodes = Arrays.asList("A", "B", "C");
+        List<Edge> edges = createSimpleTriangle();
+
+        // Act
+        TSPResult result = tspService.solveTSP(nodes, edges);
+
+        // Assert
+        assertFalse(result.route.isEmpty());
+        assertEquals(result.route.get(0), result.route.get(result.route.size() - 1),
+                "Tour should return to starting node");
+    }
+
+    @Test
+    @DisplayName("TSP: Tour uses valid edges")
+    void testTourUsesValidEdges() {
+        // Arrange
+        List<String> nodes = Arrays.asList("A", "B", "C");
+        List<Edge> edges = createSimpleTriangle();
+
+        // Build edge map (bidirectional)
+        Map<String, Set<String>> edgeMap = new HashMap<>();
+        for (Edge e : edges) {
+            edgeMap.computeIfAbsent(e.from, k -> new HashSet<>()).add(e.to);
+            edgeMap.computeIfAbsent(e.to, k -> new HashSet<>()).add(e.from);
+        }
+
+        // Act
+        TSPResult result = tspService.solveTSP(nodes, edges);
+
+        // Assert
+        for (int i = 0; i < result.route.size() - 1; i++) {
+            String from = result.route.get(i);
+            String to = result.route.get(i + 1);
+            assertTrue(edgeMap.containsKey(from) && edgeMap.get(from).contains(to),
+                    "Invalid edge in tour: " + from + " -> " + to);
+        }
+    }
+
+    // ==================== Distance Calculation Tests ====================
+
+    @Test
+    @DisplayName("TSP: Distance calculation is accurate")
+    void testDistanceCalculation() {
+        // Arrange
+        List<String> nodes = Arrays.asList("A", "B", "C");
+        List<Edge> edges = createSimpleTriangle();
+
+        // Build distance map
+        Map<String, Map<String, Double>> distMap = new HashMap<>();
+        for (Edge e : edges) {
+            distMap.computeIfAbsent(e.from, k -> new HashMap<>()).put(e.to, e.weight);
+            distMap.computeIfAbsent(e.to, k -> new HashMap<>()).put(e.from, e.weight);
+        }
+
+        // Act
+        TSPResult result = tspService.solveTSP(nodes, edges);
+
+        // Assert - Manually calculate distance
+        double calculatedDistance = 0.0;
+        for (int i = 0; i < result.route.size() - 1; i++) {
+            String from = result.route.get(i);
+            String to = result.route.get(i + 1);
+            calculatedDistance += distMap.get(from).get(to);
+        }
+
+        assertEquals(calculatedDistance, result.totalDistance, 0.01,
+                "Reported distance should match calculated distance");
+    }
+
+    // ==================== Disconnected Graph Tests ====================
+
+    @Test
+    @DisplayName("TSP: Disconnected graph returns infinity")
+    void testDisconnectedGraph() {
+        // Arrange
+        List<String> nodes = Arrays.asList("A", "B", "C", "D");
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 5.0));
+        edges.add(new Edge("C", "D", 3.0));
+        // A-B and C-D are disconnected
+
+        // Act
+        TSPResult result = tspService.solveTSP(nodes, edges);
+
+        // Assert
+        assertEquals(Double.POSITIVE_INFINITY, result.totalDistance,
+                "Disconnected graph should return infinity");
+        assertTrue(result.route.isEmpty());
+    }
+
+    @Test
+    @DisplayName("TSP: Null nodes returns empty result")
+    void testNullNodes() {
+        // Arrange
+        List<Edge> edges = createSimpleTriangle();
+
+        // Act
+        TSPResult result = tspService.solveTSP(null, edges);
+
+        // Assert
+        assertTrue(result.route.isEmpty());
+        assertEquals(0.0, result.totalDistance, 0.01);
+    }
+
+    // ==================== Complete Graph Tests ====================
+
+    @Test
+    @DisplayName("TSP: Complete graph 4 nodes")
+    void testCompleteGraph4Nodes() {
+        // Arrange
+        List<String> nodes = Arrays.asList("A", "B", "C", "D");
+        List<Edge> edges = createCompleteGraph4();
+
+        // Act
+        TSPResult result = tspService.solveTSP(nodes, edges);
+
+        // Assert
+        assertFalse(result.route.isEmpty());
+        assertEquals("A", result.route.get(0));
+        assertEquals("A", result.route.get(result.route.size() - 1));
+        assertTrue(result.totalDistance > 0);
+        assertTrue(result.totalDistance < Double.POSITIVE_INFINITY);
+
+        // Should visit all 4 nodes
+        assertEquals(5, result.route.size()); // A, ?, ?, ?, A
+    }
+
+    // ==================== Optimization Tests ====================
+
+    @Test
+    @DisplayName("TSP: Finds truly optimal solution")
+    void testFindsOptimalSolution() {
+        // Arrange - Triangle where two tours are possible
+        List<String> nodes = Arrays.asList("A", "B", "C");
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 1.0));
+        edges.add(new Edge("B", "C", 2.0));
+        edges.add(new Edge("A", "C", 10.0));
+
+        // Act
+        TSPResult result = tspService.solveTSP(nodes, edges);
+
+        // Assert
+        // Optimal: A->B->C->A = 1+2+10 = 13
+        // Worse: A->C->B->A = 10+2+1 = 13 (same due to symmetry)
+        assertEquals(13.0, result.totalDistance, 0.01);
+    }
+
+    @Test
+    @DisplayName("TSP: Avoids suboptimal greedy choice")
+    void testAvoidsGreedyChoice() {
+        // Arrange - Graph where greedy choice is wrong
+        /*
+         * A --1-- B
+         * |       |
+         * 10     2
+         * |       |
+         * D --1-- C
+         *
+         * Greedy from A: A->B(1), B->C(2), C->D(1), D->A(10) = 14
+         * Optimal: A->B(1), B->C(2), but need better route
+         * Actually all tours equal due to symmetry: 1+2+1+10 = 14
+         */
+        List<String> nodes = Arrays.asList("A", "B", "C", "D");
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 1.0));
+        edges.add(new Edge("B", "C", 2.0));
+        edges.add(new Edge("C", "D", 1.0));
+        edges.add(new Edge("D", "A", 10.0));
+
+        // Act
+        TSPResult result = tspService.solveTSP(nodes, edges);
+
+        // Assert
+        assertEquals(14.0, result.totalDistance, 0.01);
+        assertTrue(isValidTour(result, nodes));
+    }
+
+    // ==================== Performance Tests ====================
+
+    @Test
+    @DisplayName("TSP: Completes 5 nodes reasonably fast")
+    void testPerformance5Nodes() {
+        // Arrange - Complete graph with 5 nodes
+        List<String> nodes = Arrays.asList("A", "B", "C", "D", "E");
+        List<Edge> edges = new ArrayList<>();
+        String[] nodeArray = {"A", "B", "C", "D", "E"};
+        for (int i = 0; i < 5; i++) {
+            for (int j = i + 1; j < 5; j++) {
+                edges.add(new Edge(nodeArray[i], nodeArray[j], (i + j + 1.0)));
+            }
+        }
+
+        // Act
+        long start = System.currentTimeMillis();
+        TSPResult result = tspService.solveTSP(nodes, edges);
+        long duration = System.currentTimeMillis() - start;
+
+        // Assert
+        assertFalse(result.route.isEmpty());
+        assertTrue(result.totalDistance > 0);
+        assertTrue(result.totalDistance < Double.POSITIVE_INFINITY);
+        assertTrue(duration < 5000, "Should complete 5 nodes within 5 seconds");
+    }
+
+    @Test
+    @DisplayName("TSP: Branch and bound prunes effectively")
+    void testBranchAndBoundPruning() {
+        // Arrange - Graph where branch and bound should prune many branches
+        List<String> nodes = Arrays.asList("A", "B", "C", "D");
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge("A", "B", 1.0));
+        edges.add(new Edge("B", "C", 1.0));
+        edges.add(new Edge("C", "D", 1.0));
+        edges.add(new Edge("D", "A", 1.0));
+        edges.add(new Edge("A", "C", 100.0)); // Expensive diagonal
+        edges.add(new Edge("B", "D", 100.0)); // Expensive diagonal
+
+        // Act
+        TSPResult result = tspService.solveTSP(nodes, edges);
+
+        // Assert - Should find the cheap tour around the perimeter
+        assertEquals(4.0, result.totalDistance, 0.01);
+    }
+
+    // ==================== Helper Methods ====================
+
+    /**
+     * Validates that the tour is valid:
+     * - Starts and ends at same node
+     * - Visits all nodes exactly once (excluding return)
+     * - Has positive finite distance
+     */
+    private boolean isValidTour(TSPResult result, List<String> nodes) {
+        if (result.route.isEmpty()) return false;
+        if (result.totalDistance >= Double.POSITIVE_INFINITY) return false;
+        if (!result.route.get(0).equals(result.route.get(result.route.size() - 1))) return false;
+
+        Set<String> visited = new HashSet<>();
+        for (int i = 0; i < result.route.size() - 1; i++) {
+            visited.add(result.route.get(i));
+        }
+
+        return visited.size() == nodes.size();
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/TransportServiceTest.java b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/TransportServiceTest.java
new file mode 100644
index 000000000..8659389cd
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/src/test/java/com/programacion3/adoptme/service/TransportServiceTest.java
@@ -0,0 +1,560 @@
+package com.programacion3.adoptme.service;
+
+import com.programacion3.adoptme.domain.Dog;
+import com.programacion3.adoptme.service.TransportService.KnapsackResult;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DisplayName("TransportService (Knapsack DP) Unit Tests")
+class TransportServiceTest {
+
+    private TransportService transportService;
+
+    @BeforeEach
+    void setUp() {
+        transportService = new TransportService();
+    }
+
+    private List<Dog> createTestDogs() {
+        List<Dog> dogs = new ArrayList<>();
+
+        Dog dog1 = new Dog();
+        dog1.setId("D1");
+        dog1.setName("Luna");
+        dog1.setPriority(10);
+        dog1.setWeightKg(8);
+        dogs.add(dog1);
+
+        Dog dog2 = new Dog();
+        dog2.setId("D2");
+        dog2.setName("Max");
+        dog2.setPriority(7);
+        dog2.setWeightKg(15);
+        dogs.add(dog2);
+
+        Dog dog3 = new Dog();
+        dog3.setId("D3");
+        dog3.setName("Bella");
+        dog3.setPriority(5);
+        dog3.setWeightKg(10);
+        dogs.add(dog3);
+
+        Dog dog4 = new Dog();
+        dog4.setId("D4");
+        dog4.setName("Charlie");
+        dog4.setPriority(3);
+        dog4.setWeightKg(6);
+        dogs.add(dog4);
+
+        return dogs;
+    }
+
+    // ==================== Basic Knapsack Tests ====================
+
+    @Test
+    @DisplayName("Knapsack: Empty dogs returns zero")
+    void testEmptyDogs() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+
+        // Act
+        KnapsackResult result = transportService.optimizeTransport(dogs, 50);
+
+        // Assert
+        assertNotNull(result);
+        assertTrue(result.selectedDogs.isEmpty());
+        assertEquals(0, result.totalPriority);
+        assertEquals(0, result.totalWeight);
+    }
+
+    @Test
+    @DisplayName("Knapsack: Null dogs returns empty result")
+    void testNullDogs() {
+        // Act
+        KnapsackResult result = transportService.optimizeTransport(null, 50);
+
+        // Assert
+        assertNotNull(result);
+        assertTrue(result.selectedDogs.isEmpty());
+        assertEquals(0, result.totalPriority);
+        assertEquals(0, result.totalWeight);
+    }
+
+    @Test
+    @DisplayName("Knapsack: Zero capacity returns empty")
+    void testZeroCapacity() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+
+        // Act
+        KnapsackResult result = transportService.optimizeTransport(dogs, 0);
+
+        // Assert
+        assertNotNull(result);
+        assertTrue(result.selectedDogs.isEmpty());
+        assertEquals(0, result.totalPriority);
+        assertEquals(0, result.totalWeight);
+    }
+
+    @Test
+    @DisplayName("Knapsack: Negative capacity returns empty")
+    void testNegativeCapacity() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+
+        // Act
+        KnapsackResult result = transportService.optimizeTransport(dogs, -10);
+
+        // Assert
+        assertNotNull(result);
+        assertTrue(result.selectedDogs.isEmpty());
+        assertEquals(0, result.totalPriority);
+        assertEquals(0, result.totalWeight);
+    }
+
+    @Test
+    @DisplayName("Knapsack: Single dog within capacity")
+    void testSingleDogWithinCapacity() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+        Dog dog = new Dog();
+        dog.setId("D1");
+        dog.setPriority(10);
+        dog.setWeightKg(8);
+        dogs.add(dog);
+
+        // Act
+        KnapsackResult result = transportService.optimizeTransport(dogs, 10);
+
+        // Assert
+        assertEquals(1, result.selectedDogs.size());
+        assertEquals("D1", result.selectedDogs.get(0).getId());
+        assertEquals(10, result.totalPriority);
+        assertEquals(8, result.totalWeight);
+    }
+
+    @Test
+    @DisplayName("Knapsack: Single dog exceeds capacity")
+    void testSingleDogExceedsCapacity() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+        Dog dog = new Dog();
+        dog.setId("D1");
+        dog.setPriority(10);
+        dog.setWeightKg(15);
+        dogs.add(dog);
+
+        // Act
+        KnapsackResult result = transportService.optimizeTransport(dogs, 10);
+
+        // Assert
+        assertTrue(result.selectedDogs.isEmpty());
+        assertEquals(0, result.totalPriority);
+        assertEquals(0, result.totalWeight);
+    }
+
+    // ==================== Optimization Tests ====================
+
+    @Test
+    @DisplayName("Knapsack: Selects optimal subset")
+    void testSelectsOptimalSubset() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+        // D1: 8kg, priority 10
+        // D2: 15kg, priority 7
+        // D3: 10kg, priority 5
+        // D4: 6kg, priority 3
+
+        // Act - Capacity 20kg
+        KnapsackResult result = transportService.optimizeTransport(dogs, 20);
+
+        // Assert
+        // Optimal: D1 (8kg, 10) + D3 (10kg, 5) = 18kg, priority 15
+        // OR: D1 (8kg, 10) + D4 (6kg, 3) = 14kg, priority 13
+        // OR: D2 (15kg, 7) + D4 (6kg, 3) = 21kg > 20kg (invalid)
+        // Best valid: D1 + D3 = priority 15
+
+        assertTrue(result.totalWeight <= 20, "Total weight should not exceed capacity");
+        assertEquals(15, result.totalPriority, "Should maximize priority");
+        assertEquals(18, result.totalWeight);
+    }
+
+    @Test
+    @DisplayName("Knapsack: Prefers higher priority when weights equal")
+    void testPrefersHigherPriority() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+
+        Dog dog1 = new Dog();
+        dog1.setId("HighPriority");
+        dog1.setPriority(10);
+        dog1.setWeightKg(10);
+        dogs.add(dog1);
+
+        Dog dog2 = new Dog();
+        dog2.setId("LowPriority");
+        dog2.setPriority(3);
+        dog2.setWeightKg(10);
+        dogs.add(dog2);
+
+        // Act - Can fit only one
+        KnapsackResult result = transportService.optimizeTransport(dogs, 10);
+
+        // Assert
+        assertEquals(1, result.selectedDogs.size());
+        assertEquals("HighPriority", result.selectedDogs.get(0).getId());
+        assertEquals(10, result.totalPriority);
+    }
+
+    @Test
+    @DisplayName("Knapsack: Chooses multiple small over one large when beneficial")
+    void testChoosesMultipleSmall() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+
+        Dog large = new Dog();
+        large.setId("Large");
+        large.setPriority(10);
+        large.setWeightKg(20);
+        dogs.add(large);
+
+        Dog small1 = new Dog();
+        small1.setId("Small1");
+        small1.setPriority(7);
+        small1.setWeightKg(10);
+        dogs.add(small1);
+
+        Dog small2 = new Dog();
+        small2.setId("Small2");
+        small2.setPriority(7);
+        small2.setWeightKg(10);
+        dogs.add(small2);
+
+        // Act - Capacity 20kg
+        KnapsackResult result = transportService.optimizeTransport(dogs, 20);
+
+        // Assert
+        // Two small dogs (7+7=14) > one large (10)
+        assertEquals(2, result.selectedDogs.size());
+        assertEquals(14, result.totalPriority);
+        assertEquals(20, result.totalWeight);
+    }
+
+    // ==================== Capacity Tests ====================
+
+    @Test
+    @DisplayName("Knapsack: Does not exceed capacity")
+    void testDoesNotExceedCapacity() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+        int capacity = 25;
+
+        // Act
+        KnapsackResult result = transportService.optimizeTransport(dogs, capacity);
+
+        // Assert
+        assertTrue(result.totalWeight <= capacity,
+                "Total weight should not exceed capacity: " + result.totalWeight + " <= " + capacity);
+    }
+
+    @Test
+    @DisplayName("Knapsack: Exact capacity fit")
+    void testExactCapacityFit() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+
+        Dog dog1 = new Dog();
+        dog1.setId("D1");
+        dog1.setPriority(5);
+        dog1.setWeightKg(10);
+        dogs.add(dog1);
+
+        Dog dog2 = new Dog();
+        dog2.setId("D2");
+        dog2.setPriority(5);
+        dog2.setWeightKg(10);
+        dogs.add(dog2);
+
+        // Act - Exact fit
+        KnapsackResult result = transportService.optimizeTransport(dogs, 20);
+
+        // Assert
+        assertEquals(2, result.selectedDogs.size());
+        assertEquals(20, result.totalWeight, "Should use exactly capacity");
+        assertEquals(10, result.totalPriority);
+    }
+
+    @Test
+    @DisplayName("Knapsack: Large capacity includes all dogs")
+    void testLargeCapacity() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+        int totalWeight = dogs.stream().mapToInt(Dog::getWeight).sum();
+
+        // Act
+        KnapsackResult result = transportService.optimizeTransport(dogs, 1000);
+
+        // Assert
+        assertEquals(4, result.selectedDogs.size(), "Should include all dogs");
+        assertEquals(totalWeight, result.totalWeight);
+        assertEquals(25, result.totalPriority); // 10+7+5+3
+    }
+
+    // ==================== Priority Calculation Tests ====================
+
+    @Test
+    @DisplayName("Knapsack: Total priority equals sum of selected dogs")
+    void testTotalPriorityCalculation() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+
+        // Act
+        KnapsackResult result = transportService.optimizeTransport(dogs, 30);
+
+        // Assert
+        int calculatedPriority = result.selectedDogs.stream()
+                .mapToInt(Dog::getPriority)
+                .sum();
+
+        assertEquals(calculatedPriority, result.totalPriority,
+                "Total priority should equal sum of selected dogs' priorities");
+    }
+
+    @Test
+    @DisplayName("Knapsack: Total weight equals sum of selected dogs")
+    void testTotalWeightCalculation() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+
+        // Act
+        KnapsackResult result = transportService.optimizeTransport(dogs, 30);
+
+        // Assert
+        int calculatedWeight = result.selectedDogs.stream()
+                .mapToInt(Dog::getWeight)
+                .sum();
+
+        assertEquals(calculatedWeight, result.totalWeight,
+                "Total weight should equal sum of selected dogs' weights");
+    }
+
+    // ==================== Edge Cases ====================
+
+    @Test
+    @DisplayName("Knapsack: All dogs exceed capacity")
+    void testAllDogsExceedCapacity() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+        for (int i = 1; i <= 3; i++) {
+            Dog dog = new Dog();
+            dog.setId("D" + i);
+            dog.setPriority(10);
+            dog.setWeightKg(20);
+            dogs.add(dog);
+        }
+
+        // Act - Capacity too small for any dog
+        KnapsackResult result = transportService.optimizeTransport(dogs, 10);
+
+        // Assert
+        assertTrue(result.selectedDogs.isEmpty());
+        assertEquals(0, result.totalPriority);
+        assertEquals(0, result.totalWeight);
+    }
+
+    @Test
+    @DisplayName("Knapsack: Dogs with zero priority")
+    void testZeroPriorityDogs() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+
+        Dog dog1 = new Dog();
+        dog1.setId("D1");
+        dog1.setPriority(0);
+        dog1.setWeightKg(5);
+        dogs.add(dog1);
+
+        Dog dog2 = new Dog();
+        dog2.setId("D2");
+        dog2.setPriority(10);
+        dog2.setWeightKg(5);
+        dogs.add(dog2);
+
+        // Act
+        KnapsackResult result = transportService.optimizeTransport(dogs, 5);
+
+        // Assert
+        assertEquals(1, result.selectedDogs.size());
+        assertEquals("D2", result.selectedDogs.get(0).getId(), "Should prefer non-zero priority");
+    }
+
+    @Test
+    @DisplayName("Knapsack: Dogs with zero weight")
+    void testZeroWeightDogs() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+
+        Dog dog1 = new Dog();
+        dog1.setId("D1");
+        dog1.setPriority(10);
+        dog1.setWeightKg(0);
+        dogs.add(dog1);
+
+        Dog dog2 = new Dog();
+        dog2.setId("D2");
+        dog2.setPriority(5);
+        dog2.setWeightKg(10);
+        dogs.add(dog2);
+
+        // Act
+        KnapsackResult result = transportService.optimizeTransport(dogs, 10);
+
+        // Assert
+        // Should include both (zero weight dog is free)
+        assertEquals(2, result.selectedDogs.size());
+        assertEquals(15, result.totalPriority);
+    }
+
+    // ==================== Larger Dataset Tests ====================
+
+    @Test
+    @DisplayName("Knapsack: Handles 20 dogs efficiently")
+    void testLargerDataset() {
+        // Arrange - 20 dogs with varied weights and priorities
+        List<Dog> dogs = new ArrayList<>();
+        for (int i = 1; i <= 20; i++) {
+            Dog dog = new Dog();
+            dog.setId("D" + i);
+            dog.setPriority(i);
+            dog.setWeightKg(i * 2);
+            dogs.add(dog);
+        }
+
+        // Act
+        long start = System.currentTimeMillis();
+        KnapsackResult result = transportService.optimizeTransport(dogs, 50);
+        long duration = System.currentTimeMillis() - start;
+
+        // Assert
+        assertNotNull(result);
+        assertTrue(result.totalWeight <= 50);
+        assertTrue(result.totalPriority > 0);
+        assertTrue(duration < 5000, "Should complete within 5 seconds");
+    }
+
+    @Test
+    @DisplayName("Knapsack: Handles 50 dogs efficiently")
+    void testVeryLargeDataset() {
+        // Arrange - 50 dogs
+        List<Dog> dogs = new ArrayList<>();
+        for (int i = 1; i <= 50; i++) {
+            Dog dog = new Dog();
+            dog.setId("D" + i);
+            dog.setPriority((i % 10) + 1);
+            dog.setWeightKg((i % 15) + 5);
+            dogs.add(dog);
+        }
+
+        // Act
+        long start = System.currentTimeMillis();
+        KnapsackResult result = transportService.optimizeTransport(dogs, 100);
+        long duration = System.currentTimeMillis() - start;
+
+        // Assert
+        assertNotNull(result);
+        assertTrue(result.totalWeight <= 100);
+        assertTrue(result.selectedDogs.size() > 0);
+        assertTrue(duration < 10000, "Should complete within 10 seconds");
+    }
+
+    // ==================== Dynamic Programming Correctness ====================
+
+    @Test
+    @DisplayName("Knapsack: Classic DP test case")
+    void testClassicKnapsackCase() {
+        // Arrange - Classic knapsack problem
+        List<Dog> dogs = new ArrayList<>();
+
+        Dog dog1 = new Dog();
+        dog1.setId("D1");
+        dog1.setWeightKg(10);
+        dog1.setPriority(60);
+        dogs.add(dog1);
+
+        Dog dog2 = new Dog();
+        dog2.setId("D2");
+        dog2.setWeightKg(20);
+        dog2.setPriority(100);
+        dogs.add(dog2);
+
+        Dog dog3 = new Dog();
+        dog3.setId("D3");
+        dog3.setWeightKg(30);
+        dog3.setPriority(120);
+        dogs.add(dog3);
+
+        // Act - Capacity 50
+        KnapsackResult result = transportService.optimizeTransport(dogs, 50);
+
+        // Assert
+        // Optimal: D2 + D3 = 50kg, priority 220
+        // Alternative: All three = 60kg > 50 (invalid)
+        // Alternative: D1 + D3 = 40kg, priority 180
+        assertEquals(220, result.totalPriority, "Should find optimal combination");
+        assertEquals(50, result.totalWeight);
+        assertEquals(2, result.selectedDogs.size());
+    }
+
+    @Test
+    @DisplayName("Knapsack: Fractional capacity not allowed (0/1 knapsack)")
+    void testZeroOneKnapsack() {
+        // Arrange
+        List<Dog> dogs = new ArrayList<>();
+
+        Dog dog1 = new Dog();
+        dog1.setId("Perfect");
+        dog1.setWeightKg(15);
+        dog1.setPriority(100);
+        dogs.add(dog1);
+
+        Dog dog2 = new Dog();
+        dog2.setId("AlmostPerfect");
+        dog2.setWeightKg(14);
+        dog2.setPriority(99);
+        dogs.add(dog2);
+
+        // Act - Capacity 15 (can only fit Perfect, not both)
+        KnapsackResult result = transportService.optimizeTransport(dogs, 15);
+
+        // Assert
+        assertEquals(1, result.selectedDogs.size(), "Should select exactly one dog (0/1 property)");
+        assertEquals("Perfect", result.selectedDogs.get(0).getId());
+        assertEquals(100, result.totalPriority);
+    }
+
+    // ==================== Result Consistency Tests ====================
+
+    @Test
+    @DisplayName("Knapsack: Result is deterministic")
+    void testResultIsDeterministic() {
+        // Arrange
+        List<Dog> dogs = createTestDogs();
+
+        // Act - Run twice
+        KnapsackResult result1 = transportService.optimizeTransport(dogs, 25);
+        KnapsackResult result2 = transportService.optimizeTransport(dogs, 25);
+
+        // Assert
+        assertEquals(result1.totalPriority, result2.totalPriority,
+                "Same input should produce same priority");
+        assertEquals(result1.totalWeight, result2.totalWeight,
+                "Same input should produce same weight");
+        assertEquals(result1.selectedDogs.size(), result2.selectedDogs.size(),
+                "Same input should select same number of dogs");
+    }
+}
diff --git a/jdk_21_maven/cs/rest/adoptme/tests/test-algorithms.sh b/jdk_21_maven/cs/rest/adoptme/tests/test-algorithms.sh
new file mode 100644
index 000000000..419d11e3a
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/tests/test-algorithms.sh
@@ -0,0 +1,238 @@
+#!/bin/bash
+
+# AdoptMe Algorithm Test Suite
+# Tests all algorithms with complex data combinations
+
+API_BASE="http://localhost:8080"
+TEST_LOG="test-results.log"
+PASSED=0
+FAILED=0
+TOTAL=0
+
+# Colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Initialize log
+echo "========================================" > $TEST_LOG
+echo "AdoptMe Algorithm Test Suite" >> $TEST_LOG
+echo "Date: $(date)" >> $TEST_LOG
+echo "========================================" >> $TEST_LOG
+echo "" >> $TEST_LOG
+
+# Helper function to run test
+run_test() {
+    local test_name="$1"
+    local endpoint="$2"
+    local expected_status="${3:-200}"
+    local validation="${4:-}"
+
+    TOTAL=$((TOTAL + 1))
+    echo -e "${BLUE}[TEST $TOTAL]${NC} $test_name"
+    echo "[TEST $TOTAL] $test_name" >> $TEST_LOG
+    echo "Endpoint: $endpoint" >> $TEST_LOG
+
+    # Make request
+    response=$(curl -s -w "\n%{http_code}" "$API_BASE$endpoint" 2>&1)
+    http_code=$(echo "$response" | tail -n1)
+    body=$(echo "$response" | head -n-1)
+
+    echo "HTTP Status: $http_code" >> $TEST_LOG
+    echo "Response: $body" >> $TEST_LOG
+
+    # Check HTTP status
+    if [ "$http_code" != "$expected_status" ]; then
+        echo -e "${RED}✗ FAILED${NC} - Expected status $expected_status, got $http_code"
+        echo "RESULT: FAILED - Status code mismatch" >> $TEST_LOG
+        FAILED=$((FAILED + 1))
+        echo "" >> $TEST_LOG
+        return 1
+    fi
+
+    # Additional validation if provided
+    if [ -n "$validation" ]; then
+        if echo "$body" | grep -q "$validation"; then
+            echo -e "${GREEN}✓ PASSED${NC}"
+            echo "RESULT: PASSED" >> $TEST_LOG
+            PASSED=$((PASSED + 1))
+        else
+            echo -e "${RED}✗ FAILED${NC} - Validation failed (expected: $validation)"
+            echo "RESULT: FAILED - Validation failed" >> $TEST_LOG
+            FAILED=$((FAILED + 1))
+        fi
+    else
+        echo -e "${GREEN}✓ PASSED${NC}"
+        echo "RESULT: PASSED" >> $TEST_LOG
+        PASSED=$((PASSED + 1))
+    fi
+
+    echo "" >> $TEST_LOG
+    sleep 0.5
+}
+
+# Print header
+echo -e "${YELLOW}========================================${NC}"
+echo -e "${YELLOW}AdoptMe Algorithm Test Suite${NC}"
+echo -e "${YELLOW}========================================${NC}"
+echo ""
+
+# Check if server is running
+echo -e "${BLUE}Checking server connection...${NC}"
+if ! curl -s "$API_BASE/ping" > /dev/null 2>&1; then
+    echo -e "${RED}✗ Server is not running at $API_BASE${NC}"
+    echo "Please start the backend server first."
+    exit 1
+fi
+echo -e "${GREEN}✓ Server is running${NC}"
+echo ""
+
+# ==============================================
+# GRAPH TRAVERSAL TESTS (BFS/DFS)
+# ==============================================
+echo -e "${YELLOW}=== Graph Traversal Tests (BFS/DFS) ===${NC}"
+
+run_test "BFS: Simple path A→B" "/graph/reachable?from=A&to=B&method=bfs" 200 '"exists":true'
+run_test "BFS: Complex path A→O (long distance)" "/graph/reachable?from=A&to=O&method=bfs" 200 '"exists":true'
+run_test "BFS: Cross-cluster E→M" "/graph/reachable?from=E&to=M&method=bfs" 200 '"exists":true'
+run_test "BFS: Hub to edge H→N" "/graph/reachable?from=H&to=N&method=bfs" 200 '"exists":true'
+
+run_test "DFS: Simple path A→B" "/graph/reachable?from=A&to=B&method=dfs" 200 '"exists":true'
+run_test "DFS: Complex path A→O" "/graph/reachable?from=A&to=O&method=dfs" 200 '"exists":true'
+run_test "DFS: Cross-cluster E→M" "/graph/reachable?from=E&to=M&method=dfs" 200 '"exists":true'
+run_test "DFS: Multiple paths I→K" "/graph/reachable?from=I&to=K&method=dfs" 200 '"exists":true'
+
+echo ""
+
+# ==============================================
+# DIJKSTRA SHORTEST PATH TESTS
+# ==============================================
+echo -e "${YELLOW}=== Dijkstra Shortest Path Tests ===${NC}"
+
+run_test "Dijkstra: Adjacent nodes H→A" "/routes/shortest?from=H&to=A" 200 '"totalWeight"'
+run_test "Dijkstra: Long path A→M" "/routes/shortest?from=A&to=M" 200 '"totalWeight"'
+run_test "Dijkstra: Cross-cluster E→O" "/routes/shortest?from=E&to=O" 200 '"totalWeight"'
+run_test "Dijkstra: Full network A→N" "/routes/shortest?from=A&to=N" 200 '"totalWeight"'
+run_test "Dijkstra: Hub routing B→L via H" "/routes/shortest?from=B&to=L" 200 '"totalWeight"'
+
+echo ""
+
+# ==============================================
+# TSP BRANCH & BOUND TESTS
+# ==============================================
+echo -e "${YELLOW}=== TSP Branch & Bound Tests ===${NC}"
+
+run_test "TSP: Small (4 nodes) A,B,C,H" "/routes/tsp/bnb?nodes=A,B,C,H" 200 '"totalDistanceKm"'
+run_test "TSP: Medium cluster 1 (5 nodes) A,D,E,I,H" "/routes/tsp/bnb?nodes=A,D,E,I,H" 200 '"totalDistanceKm"'
+run_test "TSP: Medium cluster 2 (5 nodes) B,F,J,K,H" "/routes/tsp/bnb?nodes=B,F,J,K,H" 200 '"totalDistanceKm"'
+run_test "TSP: Large (7 nodes) A,B,C,G,L,M,H" "/routes/tsp/bnb?nodes=A,B,C,G,L,M,H" 200 '"totalDistanceKm"'
+run_test "TSP: Complex (8 nodes) H,A,D,E,F,J,L,O" "/routes/tsp/bnb?nodes=H,A,D,E,F,J,L,O" 200 '"totalDistanceKm"'
+
+echo ""
+
+# ==============================================
+# MST TESTS (Kruskal & Prim)
+# ==============================================
+echo -e "${YELLOW}=== Minimum Spanning Tree Tests ===${NC}"
+
+run_test "MST: Kruskal with full network" "/network/mst?algorithm=kruskal" 200 '"totalWeight"'
+run_test "MST: Prim with full network" "/network/mst?algorithm=prim" 200 '"totalWeight"'
+
+echo ""
+
+# ==============================================
+# SORTING TESTS
+# ==============================================
+echo -e "${YELLOW}=== Sorting Algorithm Tests ===${NC}"
+
+run_test "Sort: 40 dogs by priority (MergeSort)" "/dogs/sort?criteria=priority&algorithm=mergesort" 200 '"dogs"'
+run_test "Sort: 40 dogs by priority (QuickSort)" "/dogs/sort?criteria=priority&algorithm=quicksort" 200 '"dogs"'
+run_test "Sort: 40 dogs by age (MergeSort)" "/dogs/sort?criteria=age&algorithm=mergesort" 200 '"dogs"'
+run_test "Sort: 40 dogs by age (QuickSort)" "/dogs/sort?criteria=age&algorithm=quicksort" 200 '"dogs"'
+run_test "Sort: 40 dogs by weight (MergeSort)" "/dogs/sort?criteria=weight&algorithm=mergesort" 200 '"dogs"'
+run_test "Sort: 40 dogs by weight (QuickSort)" "/dogs/sort?criteria=weight&algorithm=quicksort" 200 '"dogs"'
+
+echo ""
+
+# ==============================================
+# GREEDY MATCHING TESTS
+# ==============================================
+echo -e "${YELLOW}=== Greedy Matching Tests ===${NC}"
+
+run_test "Greedy: High budget adopter P9 (Julia \$40K)" "/adoptions/greedy?adopterId=P9" 200 '"totalScore"'
+run_test "Greedy: High budget adopter P14 (Andres \$45K)" "/adoptions/greedy?adopterId=P14" 200 '"totalScore"'
+run_test "Greedy: Low budget adopter P10 (Carlos \$12K)" "/adoptions/greedy?adopterId=P10" 200 '"totalScore"'
+run_test "Greedy: Medium budget with kids P1 (Camila)" "/adoptions/greedy?adopterId=P1" 200 '"totalScore"'
+run_test "Greedy: No yard adopter P8 (Diego)" "/adoptions/greedy?adopterId=P8" 200 '"totalScore"'
+run_test "Greedy: High capacity P11 (Valeria max:5)" "/adoptions/greedy?adopterId=P11" 200 '"totalScore"'
+
+echo ""
+
+# ==============================================
+# BACKTRACKING TESTS
+# ==============================================
+echo -e "${YELLOW}=== Backtracking Constraint Satisfaction Tests ===${NC}"
+
+run_test "Backtracking: Multi-adopter assignment (15 adopters, 30+ dogs)" "/adoptions/constraints/backtracking" 200 '"totalScore"'
+
+echo ""
+
+# ==============================================
+# KNAPSACK TESTS
+# ==============================================
+echo -e "${YELLOW}=== Knapsack Dynamic Programming Tests ===${NC}"
+
+run_test "Knapsack: Small capacity 30kg" "/transport/optimal-dp?capacityKg=30" 200 '"totalPriority"'
+run_test "Knapsack: Medium capacity 60kg" "/transport/optimal-dp?capacityKg=60" 200 '"totalPriority"'
+run_test "Knapsack: Large capacity 100kg" "/transport/optimal-dp?capacityKg=100" 200 '"totalPriority"'
+run_test "Knapsack: Very large capacity 200kg" "/transport/optimal-dp?capacityKg=200" 200 '"totalPriority"'
+run_test "Knapsack: Extreme capacity 500kg (all dogs)" "/transport/optimal-dp?capacityKg=500" 200 '"totalPriority"'
+
+echo ""
+
+# ==============================================
+# DATA INTEGRITY TESTS
+# ==============================================
+echo -e "${YELLOW}=== Data Integrity Tests ===${NC}"
+
+run_test "Get all shelters (expect 15)" "/shelters" 200
+run_test "Get all dogs (expect 40)" "/dogs" 200
+run_test "Get all adopters (expect 15)" "/adopters" 200
+
+echo ""
+
+# ==============================================
+# SUMMARY
+# ==============================================
+echo -e "${YELLOW}========================================${NC}"
+echo -e "${YELLOW}Test Summary${NC}"
+echo -e "${YELLOW}========================================${NC}"
+echo -e "Total Tests:  ${BLUE}$TOTAL${NC}"
+echo -e "Passed:       ${GREEN}$PASSED${NC}"
+echo -e "Failed:       ${RED}$FAILED${NC}"
+
+PASS_RATE=$((PASSED * 100 / TOTAL))
+echo -e "Pass Rate:    ${BLUE}${PASS_RATE}%${NC}"
+echo ""
+
+# Write summary to log
+echo "========================================" >> $TEST_LOG
+echo "SUMMARY" >> $TEST_LOG
+echo "========================================" >> $TEST_LOG
+echo "Total Tests: $TOTAL" >> $TEST_LOG
+echo "Passed: $PASSED" >> $TEST_LOG
+echo "Failed: $FAILED" >> $TEST_LOG
+echo "Pass Rate: ${PASS_RATE}%" >> $TEST_LOG
+echo "" >> $TEST_LOG
+
+if [ $FAILED -eq 0 ]; then
+    echo -e "${GREEN}✓ All tests passed!${NC}"
+    echo -e "Results saved to: ${BLUE}$TEST_LOG${NC}"
+    exit 0
+else
+    echo -e "${RED}✗ Some tests failed.${NC}"
+    echo -e "Check details in: ${BLUE}$TEST_LOG${NC}"
+    exit 1
+fi
diff --git a/jdk_21_maven/cs/rest/adoptme/tests/test_algorithms_advanced.py b/jdk_21_maven/cs/rest/adoptme/tests/test_algorithms_advanced.py
new file mode 100644
index 000000000..8beb1f35d
--- /dev/null
+++ b/jdk_21_maven/cs/rest/adoptme/tests/test_algorithms_advanced.py
@@ -0,0 +1,435 @@
+#!/usr/bin/env python3
+"""
+AdoptMe Advanced Algorithm Test Suite
+Performs deep validation of algorithm correctness
+"""
+
+import requests
+import json
+import sys
+from typing import Dict, List, Any, Tuple
+from datetime import datetime
+
+API_BASE = "http://localhost:8080"
+
+class Colors:
+    GREEN = '\033[0;32m'
+    RED = '\033[0;31m'
+    YELLOW = '\033[1;33m'
+    BLUE = '\033[0;34m'
+    NC = '\033[0m'
+
+class TestResults:
+    def __init__(self):
+        self.total = 0
+        self.passed = 0
+        self.failed = 0
+        self.results = []
+
+    def add_result(self, test_name: str, passed: bool, message: str = ""):
+        self.total += 1
+        if passed:
+            self.passed += 1
+            status = f"{Colors.GREEN}✓ PASSED{Colors.NC}"
+        else:
+            self.failed += 1
+            status = f"{Colors.RED}✗ FAILED{Colors.NC}"
+
+        self.results.append({
+            'name': test_name,
+            'passed': passed,
+            'message': message
+        })
+
+        print(f"[TEST {self.total}] {test_name}: {status}")
+        if message:
+            print(f"  → {message}")
+
+    def print_summary(self):
+        print(f"\n{Colors.YELLOW}{'='*50}{Colors.NC}")
+        print(f"{Colors.YELLOW}Test Summary{Colors.NC}")
+        print(f"{Colors.YELLOW}{'='*50}{Colors.NC}")
+        print(f"Total Tests:  {Colors.BLUE}{self.total}{Colors.NC}")
+        print(f"Passed:       {Colors.GREEN}{self.passed}{Colors.NC}")
+        print(f"Failed:       {Colors.RED}{self.failed}{Colors.NC}")
+
+        if self.total > 0:
+            pass_rate = (self.passed / self.total) * 100
+            print(f"Pass Rate:    {Colors.BLUE}{pass_rate:.1f}%{Colors.NC}")
+
+        return self.failed == 0
+
+def check_server() -> bool:
+    """Check if server is running"""
+    try:
+        response = requests.get(f"{API_BASE}/ping", timeout=5)
+        return response.status_code == 200
+    except:
+        return False
+
+def api_get(endpoint: str) -> Tuple[int, Any]:
+    """Make API GET request and return status code and JSON"""
+    try:
+        response = requests.get(f"{API_BASE}{endpoint}", timeout=30)
+        return response.status_code, response.json() if response.status_code == 200 else None
+    except requests.exceptions.Timeout:
+        return 408, None
+    except Exception as e:
+        return 500, None
+
+# ==================== VALIDATION FUNCTIONS ====================
+
+def validate_path_exists(data: Dict) -> bool:
+    """Validate BFS/DFS response"""
+    if not isinstance(data, dict):
+        return False
+    if 'exists' not in data:
+        return False
+    if data['exists'] and 'path' not in data:
+        return False
+    if data['exists'] and not isinstance(data.get('path'), list):
+        return False
+    return True
+
+def validate_dijkstra(data: Dict) -> bool:
+    """Validate Dijkstra response has path and positive weight"""
+    if not isinstance(data, dict):
+        return False
+    if 'path' not in data or 'totalWeight' not in data:
+        return False
+    if not isinstance(data['path'], list) or len(data['path']) < 2:
+        return False
+    if data['totalWeight'] <= 0:
+        return False
+    return True
+
+def validate_tsp(data: Dict) -> bool:
+    """Validate TSP response"""
+    if not isinstance(data, dict):
+        return False
+    if 'route' not in data or 'totalDistanceKm' not in data:
+        return False
+    route = data['route']
+    if not isinstance(route, list) or len(route) < 3:
+        return False
+    # TSP should return to start
+    if route[0] != route[-1]:
+        return False
+    if data['totalDistanceKm'] <= 0:
+        return False
+    return True
+
+def validate_mst(data: Dict, expected_nodes: int = 15) -> bool:
+    """Validate MST response"""
+    if not isinstance(data, dict):
+        return False
+    if 'edges' not in data or 'totalWeight' not in data:
+        return False
+    edges = data['edges']
+    if not isinstance(edges, list):
+        return False
+    # MST should have n-1 edges for n nodes
+    if len(edges) != expected_nodes - 1:
+        return False
+    if data['totalWeight'] <= 0:
+        return False
+    return True
+
+def validate_sorted_list(data: Dict, criteria: str) -> bool:
+    """Validate sorting response is actually sorted"""
+    if not isinstance(data, dict):
+        return False
+    if 'dogs' not in data:
+        return False
+    dogs = data['dogs']
+    if not isinstance(dogs, list) or len(dogs) == 0:
+        return False
+
+    # Check if sorted in ascending order
+    for i in range(len(dogs) - 1):
+        current = dogs[i].get(criteria)
+        next_val = dogs[i + 1].get(criteria)
+        if current is None or next_val is None:
+            return False
+        if current > next_val:
+            return False
+
+    return True
+
+def validate_greedy(data: Dict) -> bool:
+    """Validate Greedy matching response"""
+    if not isinstance(data, dict):
+        return False
+    required_fields = ['assignedDogs', 'totalScore', 'totalCost']
+    for field in required_fields:
+        if field not in data:
+            return False
+    if not isinstance(data['assignedDogs'], list):
+        return False
+    if data['totalScore'] < 0 or data['totalCost'] < 0:
+        return False
+    return True
+
+def validate_backtracking(data: Dict) -> bool:
+    """Validate Backtracking response"""
+    if not isinstance(data, dict):
+        return False
+    if 'assignments' not in data or 'totalScore' not in data:
+        return False
+    if not isinstance(data['assignments'], dict):
+        return False
+    if data['totalScore'] < 0:
+        return False
+    return True
+
+def validate_knapsack(data: Dict, capacity: int) -> bool:
+    """Validate Knapsack response"""
+    if not isinstance(data, dict):
+        return False
+    required = ['selectedDogs', 'totalPriority', 'totalWeightKg', 'vehicleCapacityKg']
+    for field in required:
+        if field not in data:
+            return False
+    if not isinstance(data['selectedDogs'], list):
+        return False
+    # Total weight should not exceed capacity
+    if data['totalWeightKg'] > capacity + 0.1:  # Allow small floating point error
+        return False
+    if data['totalPriority'] < 0:
+        return False
+    return True
+
+# ==================== TEST SUITES ====================
+
+def test_graph_algorithms(results: TestResults):
+    """Test BFS and DFS"""
+    print(f"\n{Colors.YELLOW}=== Graph Traversal Tests ==={Colors.NC}")
+
+    tests = [
+        ("BFS: A→B", "/graph/reachable?from=A&to=B&method=bfs"),
+        ("BFS: A→O", "/graph/reachable?from=A&to=O&method=bfs"),
+        ("BFS: E→M", "/graph/reachable?from=E&to=M&method=bfs"),
+        ("DFS: A→B", "/graph/reachable?from=A&to=B&method=dfs"),
+        ("DFS: I→K", "/graph/reachable?from=I&to=K&method=dfs"),
+    ]
+
+    for name, endpoint in tests:
+        status, data = api_get(endpoint)
+        if status == 200 and validate_path_exists(data):
+            path_len = len(data.get('path', []))
+            results.add_result(name, True, f"Path length: {path_len}")
+        else:
+            results.add_result(name, False, f"HTTP {status} or invalid response")
+
+def test_dijkstra(results: TestResults):
+    """Test Dijkstra shortest path"""
+    print(f"\n{Colors.YELLOW}=== Dijkstra Shortest Path Tests ==={Colors.NC}")
+
+    tests = [
+        ("Dijkstra: H→A", "/routes/shortest?from=H&to=A"),
+        ("Dijkstra: A→M", "/routes/shortest?from=A&to=M"),
+        ("Dijkstra: E→O", "/routes/shortest?from=E&to=O"),
+    ]
+
+    for name, endpoint in tests:
+        status, data = api_get(endpoint)
+        if status == 200 and validate_dijkstra(data):
+            distance = data['totalWeight']
+            path = ' → '.join(data['path'])
+            results.add_result(name, True, f"{distance}km via {path}")
+        else:
+            results.add_result(name, False, f"HTTP {status} or invalid response")
+
+def test_tsp(results: TestResults):
+    """Test TSP Branch & Bound"""
+    print(f"\n{Colors.YELLOW}=== TSP Branch & Bound Tests ==={Colors.NC}")
+
+    tests = [
+        ("TSP: 4 nodes", "/routes/tsp/bnb?nodes=A,B,C,H"),
+        ("TSP: 5 nodes", "/routes/tsp/bnb?nodes=A,D,E,I,H"),
+        ("TSP: 7 nodes", "/routes/tsp/bnb?nodes=A,B,C,G,L,M,H"),
+    ]
+
+    for name, endpoint in tests:
+        status, data = api_get(endpoint)
+        if status == 200 and validate_tsp(data):
+            distance = data['totalDistanceKm']
+            route = ' → '.join(data['route'])
+            results.add_result(name, True, f"{distance}km: {route}")
+        else:
+            results.add_result(name, False, f"HTTP {status} or invalid response")
+
+def test_mst(results: TestResults):
+    """Test MST algorithms"""
+    print(f"\n{Colors.YELLOW}=== MST Tests ==={Colors.NC}")
+
+    tests = [
+        ("MST: Kruskal", "/network/mst?algorithm=kruskal"),
+        ("MST: Prim", "/network/mst?algorithm=prim"),
+    ]
+
+    weights = []
+    for name, endpoint in tests:
+        status, data = api_get(endpoint)
+        if status == 200 and validate_mst(data):
+            weight = data['totalWeight']
+            weights.append(weight)
+            edge_count = len(data['edges'])
+            results.add_result(name, True, f"{weight}km total, {edge_count} edges")
+        else:
+            results.add_result(name, False, f"HTTP {status} or invalid response")
+
+    # Both MST algorithms should produce same total weight
+    if len(weights) == 2 and abs(weights[0] - weights[1]) < 0.01:
+        results.add_result("MST: Kruskal == Prim weight", True, f"Both: {weights[0]}km")
+    elif len(weights) == 2:
+        results.add_result("MST: Kruskal == Prim weight", False,
+                          f"Kruskal: {weights[0]}km, Prim: {weights[1]}km")
+
+def test_sorting(results: TestResults):
+    """Test sorting algorithms"""
+    print(f"\n{Colors.YELLOW}=== Sorting Algorithm Tests ==={Colors.NC}")
+
+    tests = [
+        ("Sort: Priority (MergeSort)", "/dogs/sort?criteria=priority&algorithm=mergesort", "priority"),
+        ("Sort: Priority (QuickSort)", "/dogs/sort?criteria=priority&algorithm=quicksort", "priority"),
+        ("Sort: Age (MergeSort)", "/dogs/sort?criteria=age&algorithm=mergesort", "age"),
+        ("Sort: Weight (QuickSort)", "/dogs/sort?criteria=weight&algorithm=quicksort", "weight"),
+    ]
+
+    for name, endpoint, criteria in tests:
+        status, data = api_get(endpoint)
+        if status == 200 and validate_sorted_list(data, criteria):
+            count = len(data['dogs'])
+            first = data['dogs'][0].get(criteria)
+            last = data['dogs'][-1].get(criteria)
+            results.add_result(name, True, f"{count} dogs, range: {first}-{last}")
+        else:
+            results.add_result(name, False, f"HTTP {status} or not properly sorted")
+
+def test_greedy(results: TestResults):
+    """Test Greedy matching"""
+    print(f"\n{Colors.YELLOW}=== Greedy Matching Tests ==={Colors.NC}")
+
+    tests = [
+        ("Greedy: High budget (P9)", "/adoptions/greedy?adopterId=P9"),
+        ("Greedy: Low budget (P10)", "/adoptions/greedy?adopterId=P10"),
+        ("Greedy: With kids (P1)", "/adoptions/greedy?adopterId=P1"),
+    ]
+
+    for name, endpoint in tests:
+        status, data = api_get(endpoint)
+        if status == 200 and validate_greedy(data):
+            dogs = len(data['assignedDogs'])
+            score = data['totalScore']
+            cost = data['totalCost']
+            results.add_result(name, True, f"{dogs} dogs, score: {score:.1f}, cost: ${cost:.0f}")
+        else:
+            results.add_result(name, False, f"HTTP {status} or invalid response")
+
+def test_backtracking(results: TestResults):
+    """Test Backtracking"""
+    print(f"\n{Colors.YELLOW}=== Backtracking Tests ==={Colors.NC}")
+
+    status, data = api_get("/adoptions/constraints/backtracking")
+    if status == 200 and validate_backtracking(data):
+        assignments = len(data['assignments'])
+        score = data['totalScore']
+        results.add_result("Backtracking: Multi-adopter", True,
+                          f"{assignments} adopters matched, score: {score:.1f}")
+    else:
+        results.add_result("Backtracking: Multi-adopter", False,
+                          f"HTTP {status} or invalid response")
+
+def test_knapsack(results: TestResults):
+    """Test Knapsack DP"""
+    print(f"\n{Colors.YELLOW}=== Knapsack DP Tests ==={Colors.NC}")
+
+    tests = [
+        ("Knapsack: 30kg", "/transport/optimal-dp?capacityKg=30", 30),
+        ("Knapsack: 60kg", "/transport/optimal-dp?capacityKg=60", 60),
+        ("Knapsack: 100kg", "/transport/optimal-dp?capacityKg=100", 100),
+        ("Knapsack: 500kg", "/transport/optimal-dp?capacityKg=500", 500),
+    ]
+
+    for name, endpoint, capacity in tests:
+        status, data = api_get(endpoint)
+        if status == 200 and validate_knapsack(data, capacity):
+            dogs = len(data['selectedDogs'])
+            priority = data['totalPriority']
+            weight = data['totalWeightKg']
+            results.add_result(name, True,
+                              f"{dogs} dogs, priority: {priority}, weight: {weight}kg")
+        else:
+            results.add_result(name, False, f"HTTP {status} or invalid response")
+
+def test_data_integrity(results: TestResults):
+    """Test data integrity"""
+    print(f"\n{Colors.YELLOW}=== Data Integrity Tests ==={Colors.NC}")
+
+    # Check shelters
+    status, data = api_get("/shelters")
+    if status == 200 and isinstance(data, list):
+        count = len(data)
+        results.add_result("Data: Shelters count", count == 15, f"Found {count}/15 shelters")
+    else:
+        results.add_result("Data: Shelters count", False, f"HTTP {status}")
+
+    # Check dogs
+    status, data = api_get("/dogs")
+    if status == 200 and isinstance(data, list):
+        count = len(data)
+        results.add_result("Data: Dogs count", count == 40, f"Found {count}/40 dogs")
+    else:
+        results.add_result("Data: Dogs count", False, f"HTTP {status}")
+
+    # Check adopters
+    status, data = api_get("/adopters")
+    if status == 200 and isinstance(data, list):
+        count = len(data)
+        results.add_result("Data: Adopters count", count == 15, f"Found {count}/15 adopters")
+    else:
+        results.add_result("Data: Adopters count", False, f"HTTP {status}")
+
+# ==================== MAIN ====================
+
+def main():
+    print(f"{Colors.YELLOW}{'='*50}{Colors.NC}")
+    print(f"{Colors.YELLOW}AdoptMe Advanced Algorithm Test Suite{Colors.NC}")
+    print(f"{Colors.YELLOW}{'='*50}{Colors.NC}")
+    print(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print()
+
+    # Check server
+    print(f"{Colors.BLUE}Checking server connection...{Colors.NC}")
+    if not check_server():
+        print(f"{Colors.RED}✗ Server is not running at {API_BASE}{Colors.NC}")
+        print("Please start the backend server first.")
+        sys.exit(1)
+    print(f"{Colors.GREEN}✓ Server is running{Colors.NC}")
+
+    # Run all tests
+    results = TestResults()
+
+    test_data_integrity(results)
+    test_graph_algorithms(results)
+    test_dijkstra(results)
+    test_tsp(results)
+    test_mst(results)
+    test_sorting(results)
+    test_greedy(results)
+    test_backtracking(results)
+    test_knapsack(results)
+
+    # Print summary
+    all_passed = results.print_summary()
+
+    if all_passed:
+        print(f"\n{Colors.GREEN}✓ All tests passed!{Colors.NC}")
+        sys.exit(0)
+    else:
+        print(f"\n{Colors.RED}✗ Some tests failed.{Colors.NC}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()