Skip to content
Related Articles

Related Articles

Assign weights to edges such that longest path in terms of weights is minimized

Improve Article
Save Article
  • Last Updated : 13 Sep, 2022
Improve Article
Save Article

Given the edges of a tree and a sum S. The task is to assign weights to all the edges of the tree such that the longest path in terms of weights is minimized and the total sum of weights assigned should be S and print the longest path’s weight. 

Note: Edges can be assigned any weights in range [0, S] and can be fractional also. 

Examples: 

Input: 
            1
      /     |     \
     2      3      4
S = 3
Output: 2
All the edges can be assigned weights of 1, so 
the longest path will in terms of weight will be 
2--1--4 or 2--1--3 

Input:   1
            /
           2
        /      \ 
       3        4 
              /   \ 
            5      6 
S = 1 
Output: 0.50 
Assign the given below weights to edges. 
1--2: 0.25 
2--3: 0.25 
2--4: 0 
4--5: 0.25 
4--6: 0.25 

Hence the longest path in terms of weight is 1--2--3 
or 1--2--4--5 or 1--2--4--6. 

Approach: The property of a tree that a path can have a maximum of two leaf nodes in it can be used to solve the above problem. So if we assign weights only to the edges connecting the leaf nodes, and assign other edges to 0. Then every edge connecting to the leaf nodes will be assigned s/(number of leaf nodes). Since a path can contain a maximum of two leaf nodes, hence the longest path will be 2 * (s/number of leaf nodes).

Below is the implementation of the above approach: 

C++




// C++ program to assign weights to edges to
// minimize the longest path in terms of weight
#include <bits/stdc++.h>
using namespace std;
 
// Function to add edges
void addEdges(int u, int v, vector<int> adj[])
{
    adj[u].push_back(v);
    adj[v].push_back(u);
}
 
// Function that assigns weights
// and returns the longest path
long double longestPath(vector<int> adj[],
                              int s, int n)
{
    int cnt = 0;
    for (int i = 1; i <= n; i++) {
 
        if (adj[i].size() == 1)
            cnt++;
    }
 
    long double ans =
       2.0 * (long double)(s / (long double)(cnt));
    return ans;
}
 
// Driver Code
int main()
{
    int n = 4;
 
    // Create an adjacency list
    // to store tree
    vector<int> adj[n + 1];
 
    // Add edges
    addEdges(1, 2, adj);
    addEdges(1, 3, adj);
    addEdges(1, 4, adj);
 
    // Given Sum
    int s = 3;
 
    // Function that prints the
    // longest path in terms of weights
    cout << longestPath(adj, s, n);
}

Java




// Java program to assign weights to edges to
// minimize the longest path in terms of weight
import java.util.*;
 
class GFG
{
 
    // Function to add edges
    static void addEdges(int u, int v, Vector<Integer> adj[])
    {
        adj[u].add(v);
        adj[v].add(u);
    }
 
    // Function that assigns weights
    // and returns the longest path
    static double longestPath(Vector<Integer> adj[], int s, int n)
    {
        int cnt = 0;
        for (int i = 1; i <= n; i++)
        {
 
            if (adj[i].size() == 1)
                cnt++;
        }
 
        double ans = 2.0 * (double) (s / (double) (cnt));
        return ans;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int n = 4;
 
        // Create an adjacency list
        // to store tree
        Vector<Integer>[] adj = new Vector[n + 1];
        for (int i = 0; i < n + 1; i++)
            adj[i] = new Vector<Integer>();
 
        // Add edges
        addEdges(1, 2, adj);
        addEdges(1, 3, adj);
        addEdges(1, 4, adj);
 
        // Given Sum
        int s = 3;
 
        // Function that prints the
        // longest path in terms of weights
        System.out.print(longestPath(adj, s, n));
    }
}
 
// This code is contributed by Rajput-Ji

Python3




# Python3 program to assign weights to
# edges to minimize the longest path
# in terms of weight
 
# Function to add edges
def addEdges(u, v, adj):
 
    adj[u].append(v)
    adj[v].append(u)
 
# Function that assigns weights
# and returns the longest path
def longestPath(adj, s, n):
 
    cnt = 0
    for i in range(1, n + 1):
 
        if len(adj[i]) == 1:
            cnt += 1
 
    ans = 2 * (s / cnt)
    return ans
 
# Driver Code
if __name__ == "__main__":
 
    n = 4
 
    # Create an adjacency list
    # to store tree
    adj = [[] for i in range(n + 1)]
 
    # Add edges
    addEdges(1, 2, adj)
    addEdges(1, 3, adj)
    addEdges(1, 4, adj)
 
    # Given Sum
    s = 3
 
    # Function that prints the
    # longest path in terms of weights
    print(longestPath(adj, s, n))
 
# This code is contributed by Rituraj Jain

C#




// C# program to assign weights to edges to
// minimize the longest path in terms of weight
using System;
using System.Collections.Generic;
 
class GFG
{
 
    // Function to add edges
    static void addEdges(int u, int v, List<int> []adj)
    {
        adj[u].Add(v);
        adj[v].Add(u);
    }
 
    // Function that assigns weights
    // and returns the longest path
    static double longestPath(List<int> []adj, int s, int n)
    {
        int cnt = 0;
        for (int i = 1; i <= n; i++)
        {
 
            if (adj[i].Count == 1)
                cnt++;
        }
 
        double ans = 2.0 * (double) (s / (double) (cnt));
        return ans;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int n = 4;
 
        // Create an adjacency list
        // to store tree
        List<int>[] adj = new List<int>[n + 1];
        for (int i = 0; i < n + 1; i++)
            adj[i] = new List<int>();
 
        // Add edges
        addEdges(1, 2, adj);
        addEdges(1, 3, adj);
        addEdges(1, 4, adj);
 
        // Given Sum
        int s = 3;
 
        // Function that prints the
        // longest path in terms of weights
        Console.Write(longestPath(adj, s, n));
    }
}
 
// This code is contributed by Rajput-Ji

Javascript




<script>
 
// JavaScript program to assign weights to edges to
// minimize the longest path in terms of weight
 
// Function to add edges
function addEdges(u, v, adj)
{
    adj[u].push(v);
    adj[v].push(u);
}
 
// Function that assigns weights
// and returns the longest path
function longestPath(adj, s, n)
{
    var cnt = 0;
    for (var i = 1; i <= n; i++) {
 
        if (adj[i].length == 1)
            cnt++;
    }
 
    var ans =
       2.0 * (s / (cnt));
    return ans;
}
 
// Driver Code
 
var n = 4;
// Create an adjacency list
// to store tree
var adj = Array.from(Array(n+1), ()=>Array());
// Add edges
addEdges(1, 2, adj);
addEdges(1, 3, adj);
addEdges(1, 4, adj);
// Given Sum
var s = 3;
// Function that prints the
// longest path in terms of weights
document.write( longestPath(adj, s, n));
 
</script>

Output

2

Complexity Analysis:

  • Time Complexity: O(N), as we are using a loop to traverse N times, where N is the number of nodes in the tree.
  • Auxiliary Space: O(N), as we are using extra space for adj array.

My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!