Algorithm

Start by defining a queue that will store pairs of {stops, {node, dist}}. Here, 'dist' represents the distance from the source to the current node, and 'stops' keeps track of the number of nodes visited so far.
Initialize a distance array with very large values (∞) for each node, except for the source node, which is set to 0, indicating that the source node has no distance to itself.
Define the source and destination nodes, as these will be used to determine the start and end points of the search.
Create an adjacency list to store all the neighbors for each node. This list will help to easily find the nodes that can be reached from a given node.
Initialize the queue by adding the source node with a distance of 0 and a stop count of 0. This represents the starting point of the search.
Begin the algorithm by popping the front element from the queue, which contains the current node along with the number of stops and the current distance from the source.
Look at all the adjacent nodes of the current node (i.e., its neighbors).
For each adjacent node, check if the new distance through the current node is smaller than the previously stored distance in the distance array and if the number of stops taken so far is less than the maximum allowed stops (K).
If the new distance is smaller, update the distance in the array and push the adjacent node into the queue with the updated distance and incremented stop count.
Repeat this process, popping the node with the smallest distance from the queue, checking its neighbors, and updating distances as necessary.
Once the destination node is reached, return the calculated distance as the result.
If the queue becomes empty and the destination node has not been reached, return -1, indicating that there is no valid path from the source to the destination within the allowed number of stops.