// lb-sim-batch
// (c) A.C. Kaporis, L.K. Kirousis, and E.C. Stavropoulos, 2006 
// 
// Purpose: 
//
// Computes the maximum cut of a random generated graph G in G(n,m)
// from average degree dl to average degree du, with step dstep
// n=2^k is the number of nodes of G
// m=d*n/2 is the number of edges of G
//
// Syntax: 
//
// lb-sim-batch [k] [dl] [du] [step] [output file name]
//		k is the exponent of a power of 2, while 
//		dl is the lower value of average degree of G
//		du is the upper value of average degree of G
//		dstep is the value of increasing the average degree of G 
//		The output is directed to output file name (also to the standand output)  
//
// Output format:  
//
// number of nodes, average degree, and the maximum cut of graph G  
//
// Reference paper: 
//
// A.C. Kaporis, L.K. Kirousis, and E.C. Stavropoulos,
// Approximating almost all instances of Max-Cut within a ratio above the H{\aa}stad threshold. 
// In Proc. of ESA 2006, LNCS 4168, pp. 432--443, 2006
//


#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>


#define UNCOLORED -1
#define RED 0
#define BLUE 1
#define MAXVARS 100

typedef struct _Tneigh
{ 
	int who;
	struct _Tneigh *next;
} Tneigh;

typedef struct
{
	Tneigh *neigh;
	int degree;
} Tnode;

typedef struct
{
	int neighcolored[2];
	int mycolor;
} Tnodecolor;

Tnode *nodes;
Tnodecolor *nodecolors;

int k, numofnodes, numofedges;
double c, cl, cu, cstep; 
double d, dl, du, dstep; 

FILE *fp;
int decimation_cut=0; 


void *alloc (size_t n)
{
	void *ret;
	
	ret = malloc(n);
	if (ret == 0) 
	{
		printf ("out of memory! Exiting...\n");
		exit(0);
	}
	return (ret);
}

int randomnumber (int size)
{
	return (rand() % size);
}

void initgraph ()
{
	int i;

	nodes = (Tnode *) alloc (numofnodes*sizeof (Tnode));
	nodecolors = (Tnodecolor *) alloc (numofnodes*sizeof(Tnodecolor));

	for (i=0;i<numofnodes;++i)
	{
		nodes[i].degree = 0;
		nodes[i].neigh = 0;
	}

}

void freegraph ()
{
	int i;
	Tneigh *p, *pnext;

	for (i=0;i<numofnodes;++i)
	{
		p=nodes[i].neigh;
		while (p)
		{
			pnext = p->next;
			free (p);
			p=pnext;
		}
	}

	free (nodes);
	free (nodecolors);
}

void randomgraph ()
{
	int i, distinct, endpoint1, endpoint2;
	Tneigh *p, *prev;

	for (i=0;i<numofedges;++i)
	{
		endpoint1 = randomnumber (numofnodes);
		distinct = 0;
		while (!distinct)
		{
			endpoint2 = randomnumber (numofnodes);
			if (endpoint2 != endpoint1)
				distinct = 1;
		}
		if (nodes[endpoint1].degree == 0)
		{
			nodes[endpoint1].neigh = (Tneigh *) alloc (sizeof(Tneigh));
			nodes[endpoint1].neigh->who = endpoint2;
			nodes[endpoint1].neigh->next = 0;
		}
		else 
		{
			p = nodes[endpoint1].neigh;
			while (p)
			{
				prev = p;
				p = p->next;
			}
			p = (Tneigh *) alloc (sizeof(Tneigh));
			prev->next = p;
			p->who = endpoint2;
			p->next = 0;
		}
		nodes[endpoint1].degree++;

		if (nodes[endpoint2].degree == 0)
		{
			nodes[endpoint2].neigh = (Tneigh *) alloc (sizeof(Tneigh));
			nodes[endpoint2].neigh->who = endpoint1;
			nodes[endpoint2].neigh->next = 0;
		}
		else 
		{
			p = nodes[endpoint2].neigh;
			while (p)
			{
				prev = p;
				p = p->next;
			}
			p = (Tneigh *) alloc (sizeof(Tneigh));
			prev->next = p;
			p->who = endpoint1;
			p->next = 0;
		}
		nodes[endpoint2].degree++;
	}

	for (i=0;i<numofnodes;++i)
	{
		nodecolors[i].mycolor = UNCOLORED;
		nodecolors[i].neighcolored[RED] = 0;
		nodecolors[i].neighcolored[BLUE] = 0;
	}
}

int countcut ()
{
	int i,cut;

	cut =0;
	for (i=0;i<numofnodes;++i)
		if (nodecolors[i].mycolor == BLUE)
			cut += nodecolors[i].neighcolored[RED];
	return (cut);
			
}


 //delete edge (endpoint1, endpoint2) where deg(endpoint1)=0
 void delete_edge(int endpoint1, int endpoint2)
 {
	Tneigh *p, *pnext;
	int found=0;
	
	if (nodes[endpoint1].degree == 1)
		nodes[endpoint1].neigh = 0;
	nodes[endpoint1].degree--;

	if (nodes[endpoint2].degree == 1)
		nodes[endpoint2].neigh = 0;
	else{
		if (nodes[endpoint2].neigh->who == endpoint1)
			nodes[endpoint2].neigh = nodes[endpoint2].neigh->next;
		else
		{
			p=nodes[endpoint2].neigh;
			while(!found){
				pnext = p->next;
				if (pnext->who == endpoint1){ 
						found=1;
						p->next = pnext->next;
				}
				else 
					p=p->next;
			}
		}
	}
	nodes[endpoint2].degree--;
}//delete_edge


void decimation()
{
	Tneigh *p;
	int i,j; 

	int endpoint1, endpoint2;
	for (j=0; j<numofnodes; j++)
		for (i=0;i<numofnodes;++i){
			if (nodes[i].degree == 1) {
				endpoint1 = i;
				p=nodes[i].neigh;
				endpoint2 = p->who;
				delete_edge(endpoint1, endpoint2);
				decimation_cut++;
			}
		} 	
} 


//////////////////////////////////////////////////////////////////////////////
///////////////////////// Coloring Algorithm /////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
void color_ESA2006 ()
{
	int i,j,n;
	int discrepancy;
	int max_discrepancy = -1;
	int uncolored_degree;
	int min_uncolored_degree = numofedges;
	int numofcolorednodes = 0;

	Tneigh *p;

	for (i=0;i<numofnodes;++i)
	{
		nodecolors[i].mycolor = UNCOLORED;
		nodecolors[i].neighcolored[RED] = 0;
		nodecolors[i].neighcolored[BLUE] = 0;
	}

	while (numofcolorednodes < numofnodes) 
	{

		//color all nodes with uncolored_degree=0
		for (j=0;j<numofnodes;++j) 
		{
			if (nodecolors[j].mycolor == UNCOLORED )  
			{
				uncolored_degree = nodes[j].degree - nodecolors[j].neighcolored[BLUE] - nodecolors[j].neighcolored[RED]; 
				if (uncolored_degree == 0) //color it now
				{ 
					n = j;
					numofcolorednodes++;
					//printf("%d \t color node %d with uncolored_degree %d \n", numofcolorednodes, n, uncolored_degree);
					if (nodecolors[n].neighcolored[RED] > nodecolors[n].neighcolored[BLUE])
					{
						nodecolors[n].mycolor = BLUE;
						p=nodes[n].neigh;
						while (p)
						{	
							nodecolors[p->who].neighcolored[BLUE]++;
							p=p->next;
						}
					}
					else if (nodecolors[n].neighcolored[RED] < nodecolors[n].neighcolored[BLUE])
					{
						nodecolors[n].mycolor = RED;
						p=nodes[n].neigh;
						while (p)
						{
							nodecolors[p->who].neighcolored[RED]++;
							p=p->next;
						}
					}
					else
					{
						nodecolors[n].mycolor = randomnumber (2);
						p=nodes[n].neigh;
						while (p)
						{
							nodecolors[p->who].neighcolored[nodecolors[n].mycolor]++;
							p=p->next;
						}
					}
				}
			}
		}


		// find an uncolored node with max discrepancy 
		max_discrepancy = -1;
		for (j=0;j<numofnodes;++j)
		{
			if (nodecolors[j].mycolor == UNCOLORED && nodes[j].degree > 1)
			{
				discrepancy = abs(nodecolors[j].neighcolored[BLUE]-nodecolors[j].neighcolored[RED]);
				if (discrepancy > max_discrepancy)
				{
					n = j;
					max_discrepancy = discrepancy;
				}
			}
		}

		//find an uncolored node with max_discrepancy having the minimun number of uncolored neighbors
		min_uncolored_degree = numofedges; 
		for (j=0;j<numofnodes;++j)
		{
			if (nodecolors[j].mycolor == UNCOLORED && nodes[j].degree > 1)
			{
				discrepancy = abs(nodecolors[j].neighcolored[BLUE]-nodecolors[j].neighcolored[RED]);
				if (discrepancy == max_discrepancy)
				{
					uncolored_degree = 	nodes[j].degree-nodecolors[j].neighcolored[RED]-nodecolors[j].neighcolored[BLUE];
					if (uncolored_degree < min_uncolored_degree)
					{
						min_uncolored_degree = uncolored_degree;
						n = j;
					}
				}

			}
		}

		//color node n 
		if (nodecolors[n].mycolor == UNCOLORED && nodes[n].degree > 1)
		{
			numofcolorednodes++; 
			if (nodecolors[n].neighcolored[RED] > nodecolors[n].neighcolored[BLUE])
			{
				nodecolors[n].mycolor = BLUE;
				p=nodes[n].neigh;
				while (p)
				{
					nodecolors[p->who].neighcolored[BLUE]++;
					p=p->next;
				}
			}
			else if (nodecolors[n].neighcolored[RED] < nodecolors[n].neighcolored[BLUE])
			{
				nodecolors[n].mycolor = RED;
				p=nodes[n].neigh;
				while (p)
				{
					nodecolors[p->who].neighcolored[RED]++;
					p=p->next;
				}
			}
			else
			{
				nodecolors[n].mycolor = randomnumber (2);
				p=nodes[n].neigh;
				while (p)
				{
					nodecolors[p->who].neighcolored[nodecolors[n].mycolor]++;
					p=p->next;
				}
			}
		}
	}
}




//////////////////////////////////////////////////////////////////////////////
////////////////////////////////// MAIN //////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
int main(int argc,char *argv[])
{

	if (argc != 6) {
       	printf("Syntax: lb-sim [k] [dl] [du] [dstep] [output file name] \n"); 
		exit(1);
	}

	srand( (unsigned)time( NULL ) );
		
	k = atoi(argv[1]);
	numofnodes = (int) pow(2,k);

	dl = atof(argv[2]);
	cl = 0.5*dl;

	du = atof(argv[3]);
	cu = 0.5*du;
	
	dstep = atof(argv[4]);
	cstep = 0.5*dstep;

	d = dl;
	c = 0.5*d;
	
	
	while (c < cu + cstep)
	{
		numofedges = (int) (c*numofnodes); 
	
		initgraph ();

		randomgraph ();

		decimation_cut=0; 
		decimation ();  

		color_ESA2006 ();

		printf ("n=%d \t d=%4.1f \t cut=%10.8f \n", 
			numofnodes, 2.0*c, (double) (countcut()+ decimation_cut) / (double) numofedges);

		fp = fopen(argv[5], "a");

		fprintf (fp, "n=%d \t d=%4.1f \t cut=%10.8f \n", 
			numofnodes, 2.0*c, (double) (countcut()+ decimation_cut) / (double) numofedges);

		fclose(fp);

		freegraph();
		
		c = c + cstep;
	}
		
	return 0;	
}//main