/*
** maxc.c
*/
/*
**  April 22, 1998
**  this program implements Algorithm 4.19
**  for solving Problem 4.5  Maximum Clique
*/
/*
**  Compile with:
**	gcc -O    -c   maxc.c
**	gcc -O    -c   setlib0.c
**	gcc -O      maxc.o setlib0.o  -omaxc
**
**    or use the makefile  with  "make maxc"
**
**  Run with:
**	maxc {NZSG} fname
**	
**	maxc help     ----  for instructions
**	
**	maxc labels   ----  for labels
**
**
**     fname is the name of a file that contains a
**     list of m edges of the n-element
**     vertex set {0,1,2,...,n-1}.
**
**     For example here is how the file should look
**     like for m=3 edges from the n=6 vertex set
**     {0,1,2,3,4,5}
**
**      3 6
**       1 5
**       2 3
**       5 4
**
*/

#include <stdlib.h>
#include <stdio.h>
#include "defs.h"
#include "setlib0.h"
#define false 0
#define true 1
#define BOUNDSIZE (boundtype?OptSize:OptWeight)
#define WHICHBOUND(L,start) (boundtype?BOUND(L,start):WTBOUND(L,start))
 typedef set * graph;

 int NODES;
 int n;
 graph A;
 setlist D,C,B,N;
 int * X;
 FILE *f;
 int * OptClique;
 int * Color;
 set Uncolored;
 set used;
 setlist ColorClass;
 int NumColors;
 int OptSize;
 int (*BOUND)();
 float (*WTBOUND)();
 set R,T;
 char WBOUND[30];

 /***** RICHARD STUFF *****/
 float* weights;
 float cliqueWeight;
 float OptWeight;
 int boundtype;
 /***** END RICHARD *****/

void help()
{
 printf("maxc bound sort fname\n");
 printf("\n");
 printf("fname is the name of a file that\n");
 printf("contains a list of m edges of the\n");
 printf("n-element vertex set {0,1,2,...,n-1}.\n");
 printf("For example here is how the file should\n");
 printf("look like for m=3 edges from the n=6\n");
 printf("vertex set {0,1,2,3,4,5}\n");
 printf("\n");
 printf("	3 6\n");
 printf("	 1 5 \n");
 printf("	 2 3 \n");
 printf("	 5 4 \n");
 printf("\n");
 printf("Bound is the type of bounding method to use:\n");
 printf("\n");
 printf("Suppose that there are ell vertices\n");
 printf("     x_0,x_1,x_2, ... , x_{ell-1}\n");
 printf("chosen in the clique so far,\n");
 printf("then the set of next poss. vertices is\n");
 printf("C[ell]={u in C[ell-1]:{u,x_ell} is an edge }\n");
 printf("\n");
 printf("  (N)one - no bounding function used.\n");
 printf("\n");
 printf("   Si(z)eBound    - if |C[v]|+ell < OptSize, then prune.\n");
 printf("\n");
 printf("  (S)amplingBound - greedily color one time the vertices of the\n");
 printf("  		     that graph at the beginning of execution.\n");
 printf("  		     let k be the number of distinct colors \n");
 printf("  		     among the vertices of C[ell].\n");
 printf("  		     If k+ell < OptSize, then prune.\n");
 printf("\n");
 printf("\n");
 printf("  (G)reedyBound   - greedily color the vertices of C[ell] with \n");
 printf("                    say k colors. If k+ell < OptSize, then prune.\n");
 printf("\n");
 printf("\n");
 printf("  (W)eighted - prepend the bound name with a W or w to use the\n");
 printf("               version for weighted vertices.\n");
}
/****************************************************/

int NoBound(  )
{
 return(n);
}

// This should never actually be used
float WNoBound( )
{
 return(0);
}

int SizeBound( int L )
/*
**  Algorithm 4.15
*/
{
 int k;
 k=SetOrder(C[L]);
 return(k+L);
}

float WSizeBound( int L )
/*
 * Algorithm 4.15 with weights
 */
{
 int i;
 int max = FindLargestElement(C[L]);
 float w = 0;
 for (i = 0; i <= max; i++)
  if (MemberOfSet(i,C[L]))
   w += weights[i];
 w += cliqueWeight;
 return w;
}

int GreedyColor( set U, int a )
/*
**  Algorithm 4.16
*/
{
 int h,i,k;
 k=0;
 for(i=a;i<n;i++)
 {
  if( MemberOfSet(i,U) ) /* Color vertex i */
  {
   h=0;
   while ( (h<k) && IntersectTest(A[i],ColorClass[h]))
    h=h+1;
   if(h==k) 
   {
    k=k+1;
    GetEmptySet(ColorClass[h]);
   }
   SetInsert(i,ColorClass[h]);
   Color[i]=h;
  }
 }
 return(k);
}

int SamplingBound( int L , int a)
/*
**  Algorithm 4.17
*/
{
 int u,k;
 if(L==0) return NumColors;
 GetEmptySet(used);
 for(u=a;u<n;u++)
  if(MemberOfSet(u,C[L])) SetInsert(Color[u],used);
 k=SetOrder(used);
 return(k+L);
}

float WSamplingBound( int L , int a)
/*
 * Algorithm 4.17 with weights
 */
{
 int u,i;
 float k;
 if(L==0) return NumColors;
 float* maxWeights = (float*)calloc(NumColors,sizeof(float));
 GetEmptySet(used);
 for(u=a;u<n;u++)
 {
  if(MemberOfSet(u,C[L]))
  {
   SetInsert(Color[u],used);
   if (weights[u] > maxWeights[Color[u]])
    maxWeights[Color[u]] = weights[u];
  }
 }
 k=0;
 for (i=0; i < NumColors; i++)
  k += maxWeights[i];
 return(k+cliqueWeight);
}

int GreedyBound( int L , int a)
/*
**  Algorithm 4.18
*/
{
 return(GreedyColor(C[L],a)+L);
}

float WGreedyBound( int L, int a )
/*
 * Algorithm 4.18 with weights
 */
{
 int k = GreedyColor(C[L],a);
 float* maxWeights = (float*)calloc(k,sizeof(float));
 float maxWeight = 0;
 int i;

 for (i = a; i < n; i++)
 {
 fprintf(stderr,"before %d %d\n",L,a);
 fprintf(stderr,"weights[%d]==%f\n",i,weights[i]);
  if (weights[i] > maxWeights[Color[i]])
  {
 fprintf(stderr,"inside %d %d\n",L,a);
   maxWeights[Color[i]] = weights[i];
  }
 fprintf(stderr,"after %d %d\n",L,a);
 }
 for (i = 0; i < k; i++)
  maxWeight += maxWeights[i];

 return(maxWeight+cliqueWeight);
}
/****************************************************/
void WMaxClique2( int L )
/*
**  Algorithm 4.19 with weighted vertices
*/
{
 int start,i,x;
 NODES++;
 if (L==0)
 {
  GetSet(C[L],V);
  start=0;
 }
 else
 {
  for(i=0;i<WORDS;i++) 
   C[L][i]=A[X[L-1]][i]&B[X[L-1]][i]&C[L-1][i];
  start=X[L-1]+1;
 }
 for(x=start;x<n;x++)
 {
  if(MemberOfSet(x,C[L]))
  {
   if ( WHICHBOUND(L,start) <= BOUNDSIZE /*OptSize*/  ) ;
   else
   {
    cliqueWeight+=weights[x];
    X[L]=x;
	// CHANGE ME!
    if (L+1 > OptSize || (L+1 == OptSize && cliqueWeight > OptWeight))
    {
     OptSize=L+1;
	 OptWeight=cliqueWeight;
     for(i=0;i<=L;i++) OptClique[i]=X[i];
    }
    WMaxClique2(L+1);
    cliqueWeight-=weights[x];
   }
  }
 }
}

/****************************************************/

graph NewGraph(int n)
/*
**  Allocate storage for a graph on order n
*/
{
  int i;
  graph A;
  A = (graph)calloc(n, sizeof(set));
  for(i=0;i<n;i++)
  {
    A[i] = NewSet();
  }
  return(A);
}

void FreeGraph(int n, graph A)
/*
**  Allocate storage for a graph on order n
*/
{
  int i;
  for(i=0;i<n;i++) FreeSet(&A[i]);
  free(A);
}

void ReadGraphEdges(FILE *F, graph *A, int  *n)
/*
**  Read and allocate storage for a graph from the file
e
**  F which contains a list of edges. The order of the
 graph
**  is returned in n.
*/
{
  int i,u,v,m;
  fscanf(F,"%d %d", &m, n);
  ComputeWords(*n);
  *A=NewGraph(*n);
  for(i=0;i<m;i++)
  {
     fscanf(F," %d %d",&u,&v);
     SetInsert(u,(*A)[v]);
     SetInsert(v,(*A)[u]);
  }
}

/***** RICHARD STUFF *****/
void ReadVertexWeights(FILE* F, float** ws, int n)
{
	float w;
	int i;
	*ws = (float*)calloc(n,sizeof(float));
	for (i = 0; i < n; i++)
	{
		// ERROR HERE
		fscanf(F," %d",&w);
		(*ws)[i] = w;
	}
}
/***** END RICHARD *****/


/****************************************************/
int main(int ac, char *av[])
{
 int v;
 if(ac==2) 
 {
  if( (av[1][0]=='H') || (av[1][0]=='h') ) help();
  if( (av[1][0]=='L') || (av[1][0]=='l') ) 
  {
   printf("       ");
   sprintf(WBOUND,"%s","Bounding fn. ");
   printf(" %s & ",WBOUND);
   printf("OptSize & ");
   printf("Num. Nodes & ");
   printf("OptWeight");
   printf("\n");
   exit(1);
  }
 }
 if(ac!=3) 
 {
  fprintf(stderr,"%s [W]{NZSG} fname\n\n",av[0]);
  fprintf(stderr,
   "%s help     ----  for instructions\n\n",av[0]);
  fprintf(stderr,
   "%s labels   ----  for labels\n\n",av[0]);
  exit(1);
 }
 if((f=fopen(av[2],"r"))==NULL)
 {
  fprintf(stderr,"%s cannot read %s\n",av[0],av[3]);
  exit(1);
 }
 ReadGraphEdges(f,&A,&n);
 /***** RICHARD STUFF *****/
 ReadVertexWeights(f,&weights,n);
 cliqueWeight = 0;
 OptWeight = 0;
 /***** END RICHARD *****/
 fclose(f);
 SetInit(n);

 B=NewSetList(n);
 N=NewSetList(n+1);
 C=NewSetList(n);
 D=NewSetList(n);
 R=NewSet();
 T=NewSet();
 Uncolored=NewSet();
 used=NewSet();
 ColorClass=NewSetList(n);
 X=(int *)calloc(n,sizeof(int));
 OptClique=(int *)calloc(n,sizeof(int));
 Color=(int *)calloc(n,sizeof(int));
 boundtype=true;
 BOUND=NoBound;
 WTBOUND=WNoBound;
 switch(av[1][0])
 {
  case 'N': 
  case 'n': 
   sprintf(WBOUND,"%s","None         ");
   BOUND=NoBound;
  break;
  case 'Z': 
  case 'z': 
   sprintf(WBOUND,"%s","Size         ");
   BOUND=SizeBound; 
  break;
  case 'G': 
  case 'g': 
   sprintf(WBOUND,"%s","Greedy       ");
   BOUND=GreedyBound; 
  break;
  case 'S':
  case 's':
   sprintf(WBOUND,"%s","Sampling     ");
   NumColors=GreedyColor(V,0);
   BOUND=SamplingBound;
  break;
  case 'W':
  case 'w':
   boundtype=false;
   switch(av[1][1])
   {
    case 'N': 
    case 'n': 
     sprintf(WBOUND,"%s","WNone        ");
     BOUND=NoBound;
	 boundtype=true;
    break;
    case 'Z': 
    case 'z': 
     sprintf(WBOUND,"%s","WSize        ");
     WTBOUND=WSizeBound;
    break;
    case 'G': 
    case 'g': 
     sprintf(WBOUND,"%s","WGreedy      ");
     WTBOUND=WGreedyBound; 
    break;
    case 'S':
    case 's':
     sprintf(WBOUND,"%s","WSampling    ");
     NumColors=GreedyColor(V,0);
     WTBOUND=WSamplingBound;
    break;
    default:
     printf("Illegal sort method\n");
     exit(1);
    break;
   }
  break;
  default:
   printf("Illegal sort method\n");
   exit(1);
  break;
 }
 GetSet(B[0],V);
 SetDelete(0,B[0]);
 for (v=1;v<n;v++)
 {
  GetSet(B[v],B[v-1]);
  SetDelete(v,B[v]);
 }
 NODES=0; 
 WMaxClique2(0);
 printf("n=%3d ",n);
 printf("& %s & ",WBOUND);
 printf("%7d & ",OptSize);
 printf("%10d & ",NODES);
 // ERROR HERE
 printf("%15d",OptWeight);
 printf("	Max. Clique = [");
 for(v=0;v<OptSize;v++) printf(" %d",OptClique[v]);
 printf(" ] ");
 printf("\n");
 return(0);
}