Minimum Cost of a Path With Special Roads - Problem

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

#define MAX_POSITIONS 100
#define MAX_SPECIAL_ROADS 200

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int manhattan(int x1, int y1, int x2, int y2) {
    return abs_val(x2 - x1) + abs_val(y2 - y1);
}

int min(int a, int b) {
    return a < b ? a : b;
}

typedef struct {
    int x, y;
} Position;

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

void parseSpecialRoads(const char* str, int specialRoads[][5], int* roadCount) {
    *roadCount = 0;
    if (strcmp(str, "[]") == 0) return;
    
    const char* p = str + 1; // Skip first '['
    while (*p && *p != ']') {
        if (*p == '[') {
            p++;
            for (int i = 0; i < 5; i++) {
                while (*p == ' ' || *p == ',') p++;
                specialRoads[*roadCount][i] = (int)strtol(p, (char**)&p, 10);
            }
            (*roadCount)++;
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
        } else {
            p++;
        }
    }
}

int findPositionIndex(Position positions[], int posCount, int x, int y) {
    for (int i = 0; i < posCount; i++) {
        if (positions[i].x == x && positions[i].y == y) {
            return i;
        }
    }
    return -1;
}

int solution(int* start, int* target, int specialRoads[][5], int specialRoadsSize) {
    // Collect all relevant positions
    Position positions[MAX_POSITIONS];
    int posCount = 0;
    
    // Add start and target
    positions[posCount++] = (Position){start[0], start[1]};
    
    int targetIndex = -1;
    if (start[0] != target[0] || start[1] != target[1]) {
        positions[posCount] = (Position){target[0], target[1]};
        targetIndex = posCount;
        posCount++;
    } else {
        targetIndex = 0;
    }
    
    // Add special road endpoints
    for (int i = 0; i < specialRoadsSize; i++) {
        int x1 = specialRoads[i][0], y1 = specialRoads[i][1];
        int x2 = specialRoads[i][2], y2 = specialRoads[i][3];
        
        if (findPositionIndex(positions, posCount, x1, y1) == -1) {
            positions[posCount++] = (Position){x1, y1};
        }
        if (findPositionIndex(positions, posCount, x2, y2) == -1) {
            positions[posCount++] = (Position){x2, y2};
        }
    }
    
    // Dijkstra's algorithm
    int dist[MAX_POSITIONS];
    int visited[MAX_POSITIONS];
    
    for (int i = 0; i < posCount; i++) {
        dist[i] = INT_MAX;
        visited[i] = 0;
    }
    
    int startIndex = findPositionIndex(positions, posCount, start[0], start[1]);
    dist[startIndex] = 0;
    
    for (int processed = 0; processed < posCount; processed++) {
        int currentIndex = -1;
        int minDist = INT_MAX;
        
        // Find unvisited node with minimum distance
        for (int i = 0; i < posCount; i++) {
            if (!visited[i] && dist[i] < minDist) {
                minDist = dist[i];
                currentIndex = i;
            }
        }
        
        if (currentIndex == -1 || minDist == INT_MAX) break;
        
        visited[currentIndex] = 1;
        
        if (currentIndex == targetIndex) {
            return dist[currentIndex];
        }
        
        // Direct movement to all other positions
        for (int i = 0; i < posCount; i++) {
            if (!visited[i]) {
                int newDist = dist[currentIndex] + manhattan(
                    positions[currentIndex].x, positions[currentIndex].y,
                    positions[i].x, positions[i].y
                );
                if (newDist < dist[i]) {
                    dist[i] = newDist;
                }
            }
        }
        
        // Try special roads from current position
        for (int i = 0; i < specialRoadsSize; i++) {
            int x1 = specialRoads[i][0], y1 = specialRoads[i][1];
            int x2 = specialRoads[i][2], y2 = specialRoads[i][3], roadCost = specialRoads[i][4];
            
            if (positions[currentIndex].x == x1 && positions[currentIndex].y == y1) {
                int nextIndex = findPositionIndex(positions, posCount, x2, y2);
                if (nextIndex != -1 && !visited[nextIndex]) {
                    int newDist = dist[currentIndex] + roadCost;
                    if (newDist < dist[nextIndex]) {
                        dist[nextIndex] = newDist;
                    }
                }
            }
        }
    }
    
    return dist[targetIndex];
}

int main() {
    char line[1000];
    int start[2], target[2];
    int specialRoads[MAX_SPECIAL_ROADS][5];
    int specialRoadsSize;
    
    // Read start
    fgets(line, sizeof(line), stdin);
    int startSize;
    parseArray(line, start, &startSize);
    
    // Read target
    fgets(line, sizeof(line), stdin);
    int targetSize;
    parseArray(line, target, &targetSize);
    
    // Read special roads
    fgets(line, sizeof(line), stdin);
    parseSpecialRoads(line, specialRoads, &specialRoadsSize);
    
    int result = solution(start, target, specialRoads, specialRoadsSize);
    printf("%d\n", result);
    return 0;
}