- Trending Categories
- Data Structure
- Networking
- RDBMS
- Operating System
- Java
- MS Excel
- iOS
- HTML
- CSS
- Android
- Python
- C Programming
- C++
- C#
- MongoDB
- MySQL
- Javascript
- PHP
- Physics
- Chemistry
- Biology
- Mathematics
- English
- Economics
- Psychology
- Social Studies
- Fashion Studies
- Legal Studies

- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who

# Program to find out if a vertex in an undirected graph has a lesser cost path in Python

Suppose, we are given a weighted, undirected graph. We have to implement a function query that takes two vertices and a cost 'limit' as input and checks if there exists a lower cost path than the cost given as input. We return true if there exists a path or otherwise, we return false.

So, if the input is like

and the queries are (0, 2, 10), (3, 1, 30), (4, 3, 30).

then the output will be

False True True

The result of the first query is False because there is no path between vertex 0 to 2 of cost 10.

The result of the second query is True because there is a path between vertex 3 to 1 of cost 10, that is less than 30.

The result of the third query is True because there is a path between vertex 4 to 3 of cost 30, that is equal to 30.

To solve this, we will follow these steps −

weights := a list containing the different weights in the graph

connections := a list containing the connections for the weights

Define the function query() . This will take p, q, limit

index := the position in weights here limit can be inserted to the left of maintaining the sorted order

if index is same as 0, then

return False

return True if connections[index-1, p] is same as connections[index-1, q]

## Example

Let us see the following implementation to get better understanding −

import bisect class Solution(object): def __init__(self, n, edgeList): def find(node): if parent[node]!=node: parent[node] = find(parent[node]) return parent[node] def union(x,y): parent[find(y)] = find(x) return parent = {i:i for i in range(n)} edgeList.sort(key = lambda x:x[2]) self.connections = [] self.weights = [] for index,(i,j,weight) in enumerate(edgeList): union(i,j) if index!=len(edgeList)-1 and weight == edgeList[index+1][2]: continue self.weights.append(weight) self.connections.append([find(i) for i in parent]) def query(self, p, q, limit): index = bisect.bisect_left(self.weights,limit) if index==0: return False return self.connections[index-1][p] == self.connections[index-1][q] ob = Solution(5, [[0, 1, 10], [0, 2, 20], [1, 4, 10], [0, 3, 10], [1, 2, 20], [2, 3, 10]]) print(ob.query(0, 2, 10)) print(ob.query(3, 1, 30)) print(ob.query(4, 3, 30))

## Input

ob = Solution(5, [[0, 1, 10], [0, 2, 20], [1, 4, 10], [0, 3, 10], [1, 2, 20], [2, 3, 10]]) print(ob.query(0, 2, 10)) print(ob.query(3, 1, 30)) print(ob.query(4, 3, 30))

## Output

False True True