Question

C++ In this we introduce direction graphs or digraphs. Digraphs are just like regular graphs except each edge also contains a direction: in other words if you have two vertices a and b, just because a is connected to b doesn't necessarily mean b is connected to a. As a result, we don't just have a degree sequence, each vertex has an in-degree and out-degree. Intuitively, the in-degree is how many edges going into a vertex, an the out-degree is the number of edges leaving the vertex. Note an edge may be leaving and entering at the same time. We would like to extend Havel-Hakimi to the domain of digraphs. The algorithm is very similar however we consider instead of the degree sequence, a sequence of pairs, where each pair is of the form (a, b), with a being the out-degree and b being the in-degree. This sequence is sorted from largest to smallest by the out-degree first, and then in-degree, so consider the graph above. The sequence will be as follows (clockwise starting upper left). {(1, 1), (1, 2), (2, 1)}. If we sort this as described above our sequence becomes {(2, 1), (1, 2), (1, 1)}. The Havel-Hakimi algorithm then sets the out-degree of the first node to 0, whatever number that is, say x, it then subtracts 1 from the next x vertices' in-degree skipping zeros, and then resorts. Again, an empty list results in true, and any list of all 0s results in true. Also again, if the subtraction operation results in 'extra' values not being subtracted (e.g. need to subtract 5 times but the list is only of length 4),that also results in false. An example of the algorithm of the above graph is as follows:

Base case: {(2, 1), (1, 2), (1, 1)}

The out-degree is 2 so after setting the first vertex to 0 we get {(0, 1), (1, 2), (1, 1)}

Subtracting 1 from the next 2 vertices we get: {(0, 1), (1, 1), (1, 0)}

Resort: {(1, 1), (1, 0), (0, 1)}

Repeat the setting of 0, saving the 1: {(0, 1), (1, 0), (0, 1)}

Subtract 1 from the next 1 vertex skipping 0s: {(0, 1), (1, 0), (0, 0)}

Resort: {(1, 0), (0, 1), (0, 0)} {(0, 0), (0, 1), (0, 0)} {(0 0), (0, 0), (0, 0)}

Which leads to an all 0 sequence which is trivially true.

For this homework write a function called havel_hakimi_digraph that takes in a vector<pair<int, int>> and then returns whether or not the graph is graphical.

Answer 1

CODE:

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool com(pair<int, int> x, pair<int, int> y)//comparator to sort the degree list in the required order
{
if(x.first==y.first)return x.second>y.second;
return x.first>y.first;
}
bool havel_hakimi_diagraph(vector <pair<int, int>> v)//function
{
bool res=true;//this will store the result
sort(v.begin(), v.end(), com);//sorting the list
int n=v.size();
while(v[0].first!=0)
{
int val=v[0].first;//doing exactly what said in the problem
v[0].first=0;//setting the highest out degree to zero
for(int i=1;i<n;i++)
{
if(v[i].second)//subtracting 1 if it is possible else skip it
{
v[i].second--;
val--;
}
if(val==0)break;//if it is already done break
}
if(val!=0)//this means there was no vertex with a positive in degree left
{
return false;//so graph is not possible
}
sort(v.begin(), v.end(), com);
}//coming out of the loop
//running the test to check if given graph is graphical
for(int i=0;i<n;i++)
{
if(v[i].first!=0||v[i].second!=0)//this means all the elements of this list must be zero now
{
res=false;//if any of the element is non zero then graph is not possible
break;
}
}
return res;//return the result
}
int main()
{
int n, a, b;
cout<<"Enter number of nodes: ";
cin>>n;//taking the inputs
vector <pair<int, int>> v;
for(int i=0;i<n;i++)
{
cin>>a>>b;
v.push_back(make_pair(a, b));
}
//printing the results
if(havel_hakimi_diagraph(v))
{
cout<<"The given graph is graphical"<<endl;
}
else
{
cout<<"The given graph is not graphical"<<endl;
}
return 0;
}

SCCREENSHOT:

OUTPUT:

NOTE:

PLEASE GIVE ME UP VOTE THANK YOU :)