Make a tree with n vertices , d diameter and at most vertex degree k
Given three integers N, D and K. The task is to check whether it is possible to make a tree with exactly N vertices, D diameter (the number of edges in the longest path between any two vertices), and degree of each vertex must be at most K. If it is possible then print all the possible edges otherwise print No.
Examples:
Input: N = 6, D = 3, K = 4
Output:
1 2
2 3
3 4
5 2
6 2
Input: N = 6, D = 2, K = 4
Output: N0
Approach: Let’s construct the tree with the following algorithm: If (d > n – 1), print “No” and terminate the program. Otherwise, let’s keep the array deg of the length n which will represent degrees of vertices.
The first step is to construct the diameter of the tree. Let the first (d + 1) vertices form it.
Let’s add d edges to the answer and increase degrees of vertices corresponding to these edges, and if some vertex has degree greater than k, print “No” and terminate the program.
The second (and the last) step is to attach the remaining (n – d – 1) vertices to the tree. Let’s call the vertex free if its degree is less than k. Also, let’s keep all free vertices forming the diameter in some data structure which allows us to take the vertex with the minimum maximal distance to any other vertex and remove such vertices. It can be done by, for example, set of pairs (distv, v), where distv is the maximum distance from the vertex v to any other vertex. Now let’s add all the vertices starting from the vertex (d + 1) (0-indexed) to the vertex n?1, let the current vertex be u. One can get the vertex with the minimum maximal distance to any other vertex, let it be v. Now increase the degree of vertices u and v, add the edge between them, and if v still be free, return it to the data structure, otherwise remove it. The same with the vertex u (it is obvious that its maximal distance to any other vertex will be equal to (distv + 1).
If at any step our data structure will be empty or the minimum maximal distance will equal d, the answer is “No”. Otherwise, we can print the answer.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void Make_tree( int n, int d, int k)
{
if (d > n - 1) {
cout << "No" ;
return ;
}
vector< int > deg(n);
vector<pair< int , int > > ans;
set<pair< int , int > > q;
for ( int i = 0; i < d; ++i) {
++deg[i];
++deg[i + 1];
if (deg[i] > k || deg[i + 1] > k) {
cout << "NO" << endl;
return ;
}
ans.push_back(make_pair(i, i + 1));
}
for ( int i = 1; i < d; ++i)
q.insert(make_pair(max(i, d - i), i));
for ( int i = d + 1; i < n; ++i) {
while (!q.empty() && deg[q.begin()->second] == k)
q.erase(q.begin());
if (q.empty() || q.begin()->first == d) {
cout << "No" ;
return ;
}
++deg[i];
++deg[q.begin()->second];
ans.push_back(make_pair(i, q.begin()->second));
q.insert(make_pair(q.begin()->first + 1, i));
}
for ( int i = 0; i < n - 1; ++i)
cout << ans[i].first + 1 << " "
<< ans[i].second + 1 << endl;
}
int main()
{
int n = 6, d = 3, k = 4;
Make_tree(n, d, k);
return 0;
}
|
Java
import java.util.*;
class Main {
static void Make_tree( int n, int d, int k) {
if (d > n - 1 ) {
System.out.println( "No" );
return ;
}
int [] deg = new int [n];
ArrayList< int []> ans = new ArrayList< int []>();
HashMap< int [], Integer> q = new HashMap< int [], Integer>();
for ( int i = 0 ; i < d; i++) {
deg[i]++;
deg[i + 1 ]++;
if (deg[i] > k || deg[i + 1 ] > k) {
System.out.println( "No" );
return ;
}
int [] edge = {i, i + 1 };
ans.add(edge);
}
for ( int i = 1 ; i < d; i++) {
int [] key = {Math.max(i, d - i), i};
q.put(key, 1 );
}
for ( int i = d + 1 ; i < n; i++) {
ArrayList< int []> arr = new ArrayList< int []>(q.keySet());
while (q.size() > 0 && deg[arr.get( 0 )[ 1 ]] == k) {
q.remove(arr.get( 0 ));
arr.remove( 0 );
}
if (q.size() == 0 || arr.get( 0 )[ 0 ] == d) {
System.out.println( "No" );
return ;
}
deg[i]++;
deg[arr.get( 0 )[ 1 ]]++;
int [] edge = {i, arr.get( 0 )[ 1 ]};
ans.add(edge);
int [] key = {arr.get( 0 )[ 0 ] + 1 , i};
q.put(key, 1 );
}
for ( int i = 0 ; i < n - 1 ; i++) {
System.out.println((ans.get(i)[ 0 ] + 1 ) + " " + (ans.get(i)[ 1 ] + 1 ));
}
}
public static void main(String[] args) {
int n = 6 , d = 3 , k = 4 ;
Make_tree(n, d, k);
}
}
|
Python3
def Make_tree(n, d, k):
if (d > n - 1 ):
print ( "No" )
return
deg = [ 0 ] * (n)
ans = []
q = {}
for i in range (d):
deg[i] + = 1
deg[i + 1 ] + = 1
if (deg[i] > k or deg[i + 1 ] > k):
print ( "NO" )
return
ans.append((i, i + 1 ))
for i in range ( 1 , d):
q[( max (i, d - i), i)] = 1
for i in range (d + 1 , n):
arr = list (q.keys())
while ( len (q) > 0 and deg[arr[ 0 ][ 1 ]] = = k):
del q[arr[ 0 ]]
if ( len (q) = = 0 or arr[ 0 ][ 0 ] = = d):
print ( "No" )
return
deg[i] + = 1
deg[arr[ 0 ][ 1 ]] + = 1
ans.append((i, arr[ 0 ][ 1 ]))
q[(arr[ 0 ][ 0 ] + 1 , i)] = 1
for i in range (n - 1 ):
print (ans[i][ 0 ] + 1 , ans[i][ 1 ] + 1 )
if __name__ = = '__main__' :
n, d, k = 6 , 3 , 4
Make_tree(n, d, k)
|
C#
using System;
using System.Collections.Generic;
class MainClass {
public static void MakeTree( int n, int d, int k) {
if (d > n - 1) {
Console.WriteLine( "No" );
return ;
}
List< int > deg = new List< int >( new int [n]);
List<Tuple< int , int >> ans = new List<Tuple< int , int >>();
SortedSet<Tuple< int , int >> q = new SortedSet<Tuple< int , int >>();
for ( int i = 0; i < d; ++i) {
++deg[i];
++deg[i + 1];
if (deg[i] > k || deg[i + 1] > k) {
Console.WriteLine( "NO" );
return ;
}
ans.Add(Tuple.Create(i, i + 1));
}
for ( int i = 1; i < d; ++i)
q.Add(Tuple.Create(Math.Max(i, d - i), i));
for ( int i = d + 1; i < n; ++i) {
while (q.Count > 0 && deg[q.Min.Item2] == k)
q.Remove(q.Min);
if (q.Count == 0 || q.Min.Item1 == d) {
Console.WriteLine( "No" );
return ;
}
++deg[i];
++deg[q.Min.Item2];
ans.Add(Tuple.Create(i, q.Min.Item2));
q.Add(Tuple.Create(q.Min.Item1 + 1, i));
}
for ( int i = 0; i < n - 1; ++i)
Console.WriteLine(ans[i].Item1 + 1 + " " + (ans[i].Item2 + 1));
}
public static void Main( string [] args) {
int n = 6, d = 3, k = 4;
MakeTree(n, d, k);
}
}
|
Javascript
<script>
function Make_tree(n, d, k)
{
if (d > n - 1)
{
document.write( "No" );
return ;
}
let deg = new Array(n);
for (let i = 0; i < n; i++)
{
deg[i] = 0;
}
let ans = [];
let q = new Set();
for (let i = 0; i < d; ++i)
{
++deg[i];
++deg[i + 1];
if (deg[i] > k || deg[i + 1] > k)
{
document.write( "NO<br>" );
return ;
}
ans.push([i, i + 1]);
}
for (let i = 1; i < d; ++i)
q.add([(Math.max(i, d - i), i)]);
for (let i = d + 1; i < n; ++i)
{
let arr = Array.from(q);
while (q.size != 0 && deg[arr[0][1]] == k)
q. delete (arr[0]);
if (q.size == 0 || arr[0][0] == d)
{
document.write( "No<br>" )
return ;
}
++deg[i];
++deg[arr[0][1]];
ans.push([i, arr[0][1]]);
q.add([arr[0][0] + 1, i]);
}
for (let i = 0; i < n - 1; ++i)
document.write((ans[i][0] + 1) + " " +
(ans[i][1] + 1) + "<br>" );
}
let n = 6, d = 3, k = 4;
Make_tree(n, d, k);
</script>
|
Output:
1 2
2 3
3 4
5 2
6 2
Time Complexity: O(N)
Auxiliary Space: O(N)
Last Updated :
24 Mar, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...