#include<iostream>
#include<ctime>
#include<fstream>
using namespace std;
struct nodes;
struct adj
{
    int ndnm;
    int nmed;
    nodes *next;
};
struct nodes
{
    int ndnm;
    int edln;
    nodes *next;
};
int edc=0; // counts no of nodes hving atleast 3 edges
int randomed(int a,int b);
void checknd(nodes *t,adj *list,int u, int v, int edlength);
void disp(adj *list,int n);
int main()
{
 
    t=time(0);
    srand((unsigned int) t);
    cout<<"\nEnter the number of nodes ... :";
    int n;
    cin>>n;
    adj *list=new adj[n+1];
    int i=0;
    for(i=0;i<=n;i++)
    {
        list[i].ndnm=i;
        list[i].nmed=0;
        list[i].next=NULL;
    }
    cout<<"Adjacency List Initialization Formation finished.\n";
 /*
    for(i=0;i<=n;i++)
    {
        cout<<"Node Num :"<<list[i].ndnm<<"\n";
        cout<<"Number of edges :"<<list[i].nmed<<"\n";
        cout<<"Address Stored in *next :"<<list[i].next<<"\n";
    }
*/
    int n1,n2;
    cout<<"\nEnter Edge Length Limit :\n";
    cout<<"\nEnter lower bound :";
    cin>>n1;
    cout<<"\nEnter upper bound :";
    cin>>n2;
 
    int count=0,edlength;        // Counts the no. of nodes having atleast 3 edges.
    int u=0,v=0;                //Stores the Node number .... Randomy generated
    nodes *temp,*temp2;
    while(edc!=n)
    {
        u=rand()%n+1;
        v=rand()%n+1;
        if(u!=v)
        {
            if(list[u].nmed<7 && list[v].nmed<7)
            {
                edlength=randomed(n1,n2);
                if(list[u].nmed==0)
                {
                    list[u].next=new nodes;
                    temp=list[u].next;
                    temp->ndnm=v;
                    temp->edln=edlength;
                    temp->next=NULL;
                    list[u].nmed++;
                }
                else
                {
                    checknd(list[u].next,list,u,v,edlength);
                }
                if(list[v].nmed==0)
                {
                    list[v].next=new nodes;
                    temp2=list[v].next;
                    temp2->ndnm=u;
                    temp2->edln=edlength;
                    temp2->next=NULL;
                    list[v].nmed++;
                }
                else
                {
                    checknd(list[v].next,list,v,u,edlength);
                }
 
            }
        }
    }
    disp(list,n);
    cin.ignore();
 
    return 0;
}
 
//Now the code of the function which shall generate the length of the edges. randomly
int randomed(int a, int b)
{
    return (a+rand()%(b-a)+1);
}
 
//Function which checks the adjacency list of each node and finds whether
//an edge exist to the node , if not then adds the edge. :)
void checknd(nodes *t,adj *list,int u,int v,int edlength)
{
    int flag=0;
    nodes *t2; // Stores the Node which Has next as NULL;
    do
    {
        if(t->ndnm==v)
        {
            flag=1;
        }
        if(t->next==NULL)
            t2=t;
        t=t->next;
    }
    while(t!=NULL);
    t=t2;
    if(flag==0)
    {
        t->next=new nodes;
        t=t->next;
        t->next=NULL;
        t->ndnm=v;
        list[u].nmed++;
        if(list[u].nmed==3)
        {
            edc++;            // Here the no. of nodes having 3 edges atleast are incremented. Global edc.
        }
        t->edln=edlength;
    }
}
 
void disp(adj *list, int n)    // Function which displays the output to a File.
{
    ofstream file;
    file.open("d:\\illusionist\\node.txt");
    int i=0;
    nodes *temp;
    for(i=1;i<=n;i++)
    {
        temp=list[i].next;
        file<<"\n"<<list[i].ndnm<<"\t---->";
        do
        {
            file<<" "<<temp->ndnm<<"-";
            temp=temp->next;
        }
        while(temp);
    }
}