#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>

#define MAX_NODES 1000

typedef struct {
    int to, weight;
} Edge;

int minimumDistance(int n, int** edges, int edgesSize, int* edgesColSize, int s, int* marked, int markedSize) {
    // Build adjacency list
    Edge graph[MAX_NODES][MAX_NODES];
    int graphSize[MAX_NODES] = {0};
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0];
        graph[u][graphSize[u]++] = (Edge){edges[i][1], edges[i][2]};
    }
    
    // Create marked set
    bool isMarked[MAX_NODES] = {false};
    for (int i = 0; i < markedSize; i++) {
        isMarked[marked[i]] = true;
    }
    
    // Dijkstra's algorithm with early termination
    int dist[MAX_NODES];
    bool visited[MAX_NODES] = {false};
    
    for (int i = 0; i < n; i++) {
        dist[i] = INT_MAX;
    }
    dist[s] = 0;
    
    for (int i = 0; i < n; i++) {
        // Find minimum distance unvisited node
        int u = -1;
        for (int j = 0; j < n; j++) {
            if (!visited[j] && (u == -1 || dist[j] < dist[u])) {
                u = j;
            }
        }
        
        if (dist[u] == INT_MAX) break;
        
        // Early termination: first marked node we reach is closest
        if (isMarked[u]) {
            return dist[u];
        }
        
        visited[u] = true;
        
        // Update distances to neighbors
        for (int j = 0; j < graphSize[u]; j++) {
            int v = graph[u][j].to;
            int w = graph[u][j].weight;
            if (dist[u] + w < dist[v]) {
                dist[v] = dist[u] + w;
            }
        }
    }
    
    return -1; // No marked destination reachable
}