Modify Graph Edge Weights

Modify Graph Edge Weights - Problem

You are given an undirected weighted connected graph containing n nodes labeled from 0 to n - 1, and an integer array edges where edges[i] = [ai, bi, wi] indicates that there is an edge between nodes ai and bi with weight wi.

Some edges have a weight of -1 (wi = -1), while others have a positive weight (wi > 0).

Your task is to modify all edges with a weight of -1 by assigning them positive integer values in the range [1, 2 * 10⁹] so that the shortest distance between the nodes source and destination becomes equal to an integer target. If there are multiple modifications that make the shortest distance between source and destination equal to target, any of them will be considered correct.

Return an array containing all edges (even unmodified ones) in any order if it is possible to make the shortest distance from source to destination equal to target, or an empty array if it's impossible.

Note: You are not allowed to modify the weights of edges with initial positive weights.

Input & Output

Example 1 — Basic Graph with One -1 Edge

$ Input: n = 5, edges = [[4,1,-1],[2,0,-1],[0,3,-1],[4,3,-1]], source = 0, destination = 1, target = 5

› Output: [[4,1,1],[2,0,1],[0,3,3],[4,3,1]]

💡 Note: Set the unknown edge weights so that the shortest path from node 0 to node 1 equals exactly 5. One possible solution is to set edge (0,3) to weight 3, keeping others at minimum weight 1.

Example 2 — Impossible Target

$ Input: n = 3, edges = [[0,1,-1],[0,2,5]], source = 0, destination = 2, target = 6

› Output: []

💡 Note: There's a direct edge from 0 to 2 with weight 5, so the shortest path is already 5. We cannot make it longer to reach target 6.

Example 3 — Multiple -1 Edges

$ Input: n = 4, edges = [[1,0,4],[1,2,-1],[2,3,-1]], source = 0, destination = 3, target = 7

› Output: [[1,0,4],[1,2,1],[2,3,2]]

💡 Note: Path 0→1→2→3 with weights 4+1+2=7. Set edge (1,2) to 1 and (2,3) to 2 to achieve target distance.

Constraints

1 ≤ n ≤ 100
0 ≤ edges.length ≤ n × (n - 1) / 2
edges[i].length == 3
0 ≤ a_i, b_i < n
w_i = -1 or 1 ≤ w_i ≤ 10⁷
0 ≤ source, destination < n
source ≠ destination
1 ≤ target ≤ 2 × 10⁹
The graph is connected

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 32 M Microsoft 28 A Apple 22

The key insight is to use Dijkstra's algorithm with binary search on edge weights. First check if the target is achievable by setting all -1 edges to minimum (1) and maximum (2×10⁹) weights. Then use binary search to find the exact weight for one critical edge that makes the shortest path equal to target. Best approach is Dijkstra + Binary Search: Time O(log(2×10⁹) × (V+E) log V), Space O(V+E).

Common Approaches

✓ Brute Force with All Combinations

⏱️ Time: O((2×10⁹)^k × (V + E) log V) Space: O(V + E)

For each edge with weight -1, try all possible values from 1 to 2*10⁹. For each combination, run Dijkstra's algorithm to check if the shortest path equals the target.

Dijkstra with Binary Search

⏱️ Time: O(log(2×10⁹) × (V + E) log V) Space: O(V + E)

First run Dijkstra with all -1 edges set to 1 to get minimum possible distance. If it's already greater than target, return empty. Then use binary search to adjust one critical edge weight to achieve exact target distance.

Brute Force with All Combinations — Algorithm Steps

Identify all edges with weight -1
Generate all possible weight combinations
For each combination, run Dijkstra's algorithm
Return first combination that achieves target distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify -1 Edges

Find all edges that need weight assignment

Generate Combinations

Try different weight values for each -1 edge

Run Dijkstra

Calculate shortest path for each combination

Check Target

Return first combination that matches target distance

Code -

solution.c — C

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

#define MAX_N 100
#define MAX_EDGES 1000
#define INF INT_MAX

int n, source, destination, target;
int edges[MAX_EDGES][3];
int graphEdges[MAX_EDGES][3];
int negEdges[MAX_EDGES];
int numEdges, numNegEdges;

int dijkstra() {
    int dist[MAX_N];
    int visited[MAX_N] = {0};
    
    for (int i = 0; i < n; i++) {
        dist[i] = INF;
    }
    dist[source] = 0;
    
    for (int count = 0; count < n; count++) {
        int u = -1;
        for (int i = 0; i < n; i++) {
            if (!visited[i] && (u == -1 || dist[i] < dist[u])) {
                u = i;
            }
        }
        
        if (dist[u] == INF) break;
        visited[u] = 1;
        
        for (int i = 0; i < numEdges; i++) {
            int a = graphEdges[i][0], b = graphEdges[i][1], w = graphEdges[i][2];
            if ((a == u && dist[u] + w < dist[b])) {
                dist[b] = dist[u] + w;
            }
            if ((b == u && dist[u] + w < dist[a])) {
                dist[a] = dist[u] + w;
            }
        }
    }
    
    return dist[destination];
}

int tryWeights(int idx) {
    if (idx == numNegEdges) {
        if (dijkstra() == target) {
            return 1;
        }
        return 0;
    }
    
    int weights[] = {1, 2, (target < 1000) ? target : 1000};
    for (int i = 0; i < 3; i++) {
        graphEdges[negEdges[idx]][2] = weights[i];
        if (tryWeights(idx + 1)) {
            return 1;
        }
    }
    return 0;
}

int main() {
    scanf("%d", &n);
    
    char line[10000];
    scanf(" %[^\n]", line);
    
    // Simple parsing for edges array
    numEdges = 0;
    numNegEdges = 0;
    char *ptr = line + 1; // Skip opening bracket
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            int a, b, w;
            sscanf(ptr, "%d,%d,%d", &a, &b, &w);
            edges[numEdges][0] = a;
            edges[numEdges][1] = b;
            edges[numEdges][2] = w;
            
            if (w == -1) {
                negEdges[numNegEdges++] = numEdges;
                graphEdges[numEdges][0] = a;
                graphEdges[numEdges][1] = b;
                graphEdges[numEdges][2] = 1;
            } else {
                graphEdges[numEdges][0] = a;
                graphEdges[numEdges][1] = b;
                graphEdges[numEdges][2] = w;
            }
            numEdges++;
        }
        ptr++;
    }
    
    scanf("%d", &source);
    scanf("%d", &destination);
    scanf("%d", &target);
    
    if (tryWeights(0)) {
        printf("[");
        for (int i = 0; i < numEdges; i++) {
            if (i > 0) printf(",");
            printf("[%d,%d,%d]", graphEdges[i][0], graphEdges[i][1], graphEdges[i][2]);
        }
        printf("]\n");
    } else {
        printf("[]\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((2×10⁹)^k × (V + E) log V)

k is number of -1 edges, each can have 2×10⁹ values, Dijkstra runs in O((V+E) log V)

⚡ Linearithmic

Space Complexity

O(V + E)

Graph storage and priority queue for Dijkstra's algorithm

✓ Linear Space

23.5K Views

Medium Frequency

~35 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler