Here is my solution in java, javascript, python, C, C++, Csharp HackerRank Far Vertices Problem Solution

Here is Far Vertices problem solution - https://programs.programmingoneonone.com/2021/07/hackerrank-far-vertices-problem-solution.html

PYTHON ACCURATE SOLUTION

import math import os import random import re import sys from collections import Counter

def farVertices(n, k, edges): tree = {} for edge in edges: tree[edge[0],edge[1]] = 1 tree[edge[1],edge[0]] = 1 tree_paths = len(tree) cont_flag = True while cont_flag: for edge in edges: matches = {x:y for x,y in tree.items() if edge[1] == x[0]} for match in matches.keys(): if (edge[0],match[1]) not in tree.keys() and edge[0] != match[1]: tree[edge[0],match[1]] = matches[match] + 1 tree[match[1],edge[0]] = matches[match] + 1 matches = {x:y for x,y in tree.items() if edge[0] == x[1]} for match in matches.keys(): if (edge[1],match[0]) not in tree.keys() and edge[1] != match[0]: tree[edge[1],match[0]] = matches[match] + 1 tree[match[0],edge[1]] = matches[match] + 1 if len(tree) == tree_paths: cont_flag = False tree_paths = len(tree) removed = 0 cont_flag = True while cont_flag: matches = [x[0] for x,y in tree.items() if y>k] if len(matches)==0: cont_flag = False else: removed += 1 match_count = Counter(matches) maxcount = max([y for x,y in match_count.items()]) match_max = [x for x,y in match_count.items() if y==maxcount] remove_node = match_max[0] nodes_to_remove = [x for x in tree.keys() if x[0]==remove_node or x[1]==remove_node] print(nodes_to_remove) for node in nodes_to_remove: del tree[node] return removed

if name == 'main': fptr = open(os.environ['OUTPUT_PATH'], 'w')

first_multiple_input = input().rstrip().split()

n = int(first_multiple_input[0])

k = int(first_multiple_input[1])

edges = []

for _ in range(n - 1):
    edges.append(list(map(int, input().rstrip().split())))

result = farVertices(n, k, edges)

fptr.write(str(result) + '\n')

fptr.close()

Python3 solution

n, k = [int(a) for a in input().split(" ")]
count = 0

class Node(object):
    def __init__(self):
        self.neighbors = []
        self.marked = False

    def set_neighbor(self, neighbor):
        self.neighbors.append(neighbor)

    def mark_dfs(self, depth, root = False):
        global count
        self.marked = True
        count += 1
        if depth == 0:
            children = len(self.neighbors) - 1
            if not root:
                return children
            return min(children, 1)
        num_children = 0
        for neighbor in self.neighbors:
            if not neighbor.marked:
                mc = neighbor.mark_dfs(depth-1)
                if root:
                    num_children = max(num_children,mc)
                else:
                    num_children += mc
        return num_children

nodes = []
for i in range(n):
    node = Node()
    nodes.append(node)

def unmark_all():
    for node in nodes:
        node.marked = False

for i in range(n - 1):
    u, v = [int(a) - 1 for a in input().split(" ")]
    nodes[u].set_neighbor(nodes[v])
    nodes[v].set_neighbor(nodes[u])
max_count = 0
for node in nodes:
    c = node.mark_dfs(k // 2, True)
    if k % 2 == 1:
        count += c
    if count > max_count:
        max_count = count
    unmark_all()
    count = 0  
print(n - max_count)

Let's re-word this question : You're given a graph as input (in the form of pairs of vertices; every pair represents an edge).

"Your task is to mark as small number of vertices as possible, such that, the maximum distance between two unmarked vertices is less than or equal to K."

The above sentence says you need to mark (assume, mark = delete a vertex) so that the remaining number of vertices have atmost K length between them. In other words : find the minimum number of vertices you need to remove so that the remaining tree has path <= K between the vertices. Hint : Use floyd warshall algorithm.