int
main(int argc,char *argv[])
{
int *g;
int *new_g;
int gsize;
int count;
int i;
int j;
int best_count;
int best_i;
int best_j;
int best_x;
int best_y;
void *taboo_list;
srand (time(NULL));
/*
* start with graph of size 8
*/
gsize = 54;
g = (int *)malloc(gsize*gsize*sizeof(int));
if(g == NULL) {
exit(1);
}
/*
* make a fifo to use as the taboo list
*/
taboo_list = FIFOInitEdge(TABOOSIZE);
if(taboo_list == NULL) {
exit(1);
}
/*
* start out with all zeros
*/
memset(g,0,gsize*gsize*sizeof(int));
ReadGraph(g,gsize);
/*
int ns=gsize+10;
new_g = (int *)malloc((ns)*(ns)*sizeof(int));
//CopyGraph(g,gsize,new_g,ns);
GoodCopy(g,gsize,new_g,ns);
PrintGraph(new_g,ns);
count = CliqueCount(new_g,ns);
printf("%d\n",count);
return ;
*/
/*
* while we do not have a publishable result
*/
int flag=1;
int lastcount=IMAX;
while(gsize < 102)
{
/*
* find out how we are doing
*/
count = CliqueCount(g,gsize);
/*
* if we have a counter example
*/
if(count == 0)
{
printf("Eureka! Counter-example found!\n");
PrintGraph(g,gsize);
WriteGraph(g,gsize);
/*
* make a new graph one size bigger
*/
new_g = (int *)malloc((gsize+1)*(gsize+1)*sizeof(int));
if(new_g == NULL)
exit(1);
/*
* copy the old graph into the new graph leaving the
* last row and last column alone
*/
//CopyGraph(g,gsize,new_g,gsize+1);
GoodCopy(g,gsize,new_g,gsize+1);
/*
* zero out the last column and last row
for(i=0; i < (gsize+1); i++)
{
new_g[i*(gsize+1) + gsize] = 0; // last column
new_g[gsize*(gsize+1) + i] = 0; // last row
}
*/
/*
* throw away the old graph and make new one the
* graph
*/
free(g);
g = new_g;
gsize = gsize+1;
/*
* reset the taboo list for the new graph
*/
taboo_list = FIFOResetEdge(taboo_list);
/*
* keep going
*/
continue;
}
/*
* otherwise, we need to consider flipping an edge
*
* let's speculative flip each edge, record the new count,
* and unflip the edge. We'll then remember the best flip and
* keep it next time around
*
* only need to work with upper triangle of matrix =>
* notice the indices
*/
int x,y;
best_count = BIGCOUNT;
for(x=0; x < gsize*gsize; x++)
{
for(y=x; y < gsize*gsize; y++)
{
if(y%gsize < x%gsize)
continue;
// swap
if(g[x]==g[y] && x!=y)
continue;
swap(g,x,y);
count = CliqueCount(g,gsize);
// * is it better and the i,j,count not taboo?
if((count < best_count) &&
!FIFOFindEdge(taboo_list,x,y))
// !FIFOFindEdgeCount(taboo_list,i,j,count))
{
best_count = count;
best_x = x;
best_y = y;
}
// * flip it back
swap(g,x,y);
}
}
/*
best_count = BIGCOUNT;
for(i=0; i < gsize; i++)
{
for(j=i+1; j < gsize; j++)
{
// flip it
g[i*gsize+j] = 1 - g[i*gsize+j];
count = CliqueCount(g,gsize);
// * is it better and the i,j,count not taboo?
if((count < best_count) &&
!FIFOFindEdge(taboo_list,i,j))
// !FIFOFindEdgeCount(taboo_list,i,j,count))
{
best_count = count;
best_i = i;
best_j = j;
}
// * flip it back
g[i*gsize+j] = 1 - g[i*gsize+j];
}
}
*/
if(best_count == BIGCOUNT) {
printf("no best edge found, terminating\n");
exit(1);
}
/*
* keep the best flip we saw
*/
//g[best_i*gsize+best_j] = 1 - g[best_i*gsize+best_j];
swap(g,best_x,best_y);
/*
* taboo this graph configuration so that we don't visit
* it again
*/
count = CliqueCount(g,gsize);
// FIFOInsertEdge(taboo_list,best_i,best_j);
FIFOInsertEdgeCount(taboo_list,best_i,best_j,count);
// FIFOInsertEdge(taboo_list,best_x,best_y);
/*
printf("ce size: %d, best_count: %d, swap: (%d,%d)\n",
gsize,
best_count,
best_x,
best_y
);
*/
/*
printf("ce size: %d, best_count: %d, best edge: (%d,%d), new color: %d\n",
gsize,
best_count,
best_i,
best_j,
g[best_i*gsize+best_j]);
*/
/*
* rinse and repeat
*/
}
FIFODeleteGraph(taboo_list);
return(0);
}
int
main(int argc,char *argv[])
{
int *g;
int *new_g;
int gsize;
int count;
int i;
int j;
int best_count;
int best_i;
int best_j;
int best_k;
void *taboo_list;
int val,iter,jter;
char fname[255];
FILE *fp;
char bc[255];
int fd;
/*
* start with graph of size 8
*/
if (argc < 2) {
gsize = 8;
g = (int *)malloc(gsize*gsize*sizeof(int));
if(g == NULL) {
exit(1);
}
/*
* start out with all zeros
*/
memset(g,0,gsize*gsize*sizeof(int));
val = 0, iter = 0, jter=0;
for( iter=0; iter<gsize; iter++){
for( jter = 0; jter< gsize; jter++){
g[iter*gsize + jter] = val;
val = 1 - val;
}
}
// PrintGraph(g, gsize);
} else if (argc == 2) {
gsize = atoi(argv[1]);
g = (int *)malloc(gsize*gsize*sizeof(int));
if(g == NULL) {
exit(1);
}
g = PaleyGraph(gsize);
}
else {
char graphfile[256];
strcpy(graphfile, argv[2]);
gsize = atoi(argv[1]);
//printf("gsize=%d", gsize);
g = (int *)malloc(gsize*gsize*sizeof(int));
ReadGraph(graphfile, &g, &gsize);
printf("\nStarting from given graph of size %d\n.", gsize);
fflush(stdout);
}
/*
*make a fifo to use as the taboo list
*/
taboo_list = FIFOInitEdge(TABOOSIZE);
if(taboo_list == NULL) {
exit(1);
}
/*
* while we do not have a publishable result
*/
while(gsize < 206)
{
/*
* find out how we are doing
*/
count = CliqueCount(g,gsize);
/*
* if we have a counter example
*/
if(count == 0)
{
// printf("Eureka! i Counter-example found!\n");
sprintf(fname,"solutions/CE-%d.txt",gsize);
fp = fopen(fname,"w");
char *key;
(void)MakeGraphKey(g,gsize,&key);
PrintGraph(g,gsize,fp, key);
fclose(fp);
/*
if(gsize == 31)
{
FILE *fp;
char buf[100];
bzero(buf, 100);
sprintf(buf, "graph_%d.state", gsize);
printf("Filename: %s", buf);
fp = fopen(buf, "w+");
PrintGraphToFile(g, gsize, fp);
fclose(fp);
}
*/
free(key);
/*
* make a new graph one size bigger
*/
new_g = (int *)malloc((gsize+1)*(gsize+1)*sizeof(int));
if(new_g == NULL)
exit(1);
/*
* copy the old graph into the new graph leaving the
* last row and last column alone
*/
CopyGraph(g,gsize,new_g,gsize+1);
/*
* zero out the last column and last row
*/
for(i=0; i < (gsize+1); i++)
{
if(drand48() > 0.5) {
new_g[i*(gsize+1) + gsize] = 0; // last column
new_g[gsize*(gsize+1) + i] = 0; // last row
}
else
{
new_g[i*(gsize+1) + gsize] = 1; // last column
new_g[gsize*(gsize+1) + i] = 1; // last row
}
}
/*
* throw away the old graph and make new one the
* graph
*/
free(g);
g = new_g;
gsize = gsize+1;
/*
* reset the taboo list for the new graph
*/
taboo_list = FIFOResetEdge(taboo_list);
/*
* keep going
*/
continue;
}
/*
* otherwise, we need to consider flipping an edge
*
* let's speculative flip each edge, record the new count,
* and unflip the edge. We'll then remember the best flip and
* keep it next time around
*
* only need to work with upper triangle of matrix =>
* notice the indices
*/
best_count = BIGCOUNT;
for(i=0; i < gsize; i++)
{
for(j=i+1; j < gsize; j++)
{
/*
* flip two edges (i,j), (i,random(j) + 1)
*/
int k = getRandomJ(gsize);
g[i*gsize+j] = 1 - g[i*gsize+j];
if (k == j)
k = j + 1;
g[i*gsize + k] = 1 - g[i*gsize + k];
count = CliqueCount(g,gsize);
/*
* is it better and the i,j,count not taboo?
*/
if((count < best_count) &&
// !FIFOFindEdge(taboo_list,i,j))
!FIFOFindEdgeCount(taboo_list,i,j,count) &&
!FIFOFindEdgeCount(taboo_list,i,k, count))
{
/* no need to store j + 1 */
best_count = count;
best_i = i;
best_j = j;
best_k = k;
}
/*
* flip it back
*/
g[i*gsize+j] = 1 - g[i*gsize+j];
g[i*gsize+k] = 1 - g[i*gsize+k];
}
}
if(best_count == BIGCOUNT) {
printf("no best edge found, terminating\n");
exit(1);
}
/*
* keep the best flip we saw
*/
g[best_i*gsize+best_j] = 1 - g[best_i*gsize+best_j];
g[best_i*gsize + best_k] = 1 - g[best_i*gsize + best_k];
/*
* taboo this graph configuration so that we don't visit
* it again
*/
count = CliqueCount(g,gsize);
// FIFOInsertEdge(taboo_list,best_i,best_j);
FIFOInsertEdgeCount(taboo_list,best_i,best_j,count);
FIFOInsertEdgeCount(taboo_list,best_i,best_k,count);
/*
printf("ce size: %d, best_count: %d, best edges: (%d,%d) (%d,%d), new colors: %d %d\n",
gsize,
best_count,
best_i,
best_j,
best_i,
best_k,
g[best_i*gsize+best_j],
g[best_i*gsize+best_k]);
*/
/* write update to file */
sprintf(fname,"solutions/CE-%d-upd.txt",gsize);
sprintf(bc,"%d",best_count);
fp = fopen(fname, "w+");
if (fp == NULL) {
printf("\n Ah file error ? \n");
exit(0);
}
fd = fileno(fp);
ftruncate(fd, 0);
PrintGraph(g,gsize,fp, bc);
fclose(fp);
/*
* rinse and repeat
*/
}
FIFODeleteGraph(taboo_list);
return(0);
}
int
main(int argc,char *argv[])
{
signal(SIGINT, sig_handler);
signal(SIGTERM, sig_handler);
int *g;
int *new_g;
int gsize;
long count;
long count_1;
long count_2;
long count_3;
int i;
int j;
int k;
long best_count;
long prev_best_count;
int best_i;
int best_j;
int best_k;
int best_l;
void *taboo_list;
int* taboo_array;
int val,iter,jter;
int multi = 0;
/*
* start with graph of size 8
*/
if (argc < 2) {
gsize = 8;
g = (int *)malloc(gsize*gsize*sizeof(int));
if(g == NULL) {
exit(1);
}
/*
* start out with all zeros
*/
memset(g,0,gsize*gsize*sizeof(int));
val = 0, iter = 0, jter=0;
for( iter=0; iter<gsize; iter++){
for( jter = 0; jter< gsize; jter++){
g[iter*gsize + jter] = val;
val = 1 - val;
}
}
PrintGraph(g, gsize);
} else if (argc == 2) {
gsize = atoi(argv[1]);
g = (int *)malloc(gsize*gsize*sizeof(int));
if(g == NULL) {
exit(1);
}
g = PaleyGraph(gsize);
int* row = (int *)malloc(gsize*sizeof(int));
memcpy(row, g, gsize*sizeof(int));
create_sgraph(&g, gsize, row);
taboo_array = (int*)malloc(sizeof(int)*gsize);
memset(taboo_array, 0, gsize*sizeof(int));
printf("Starting from Paley graph of size %d\n.", gsize);
fflush(stdout);
free(row);
}
else {
gsize = atoi(argv[1]);
g = (int *)malloc(gsize*gsize*sizeof(int));
ReadGraph(argv[2], &g, &gsize);
count = CliqueCount(g,gsize);
if (count == 0)
{
printf("Eureka! Sym Counter-example found!\n");
PrintGraph(g,gsize);
fflush(stdout);
new_g = (int *)malloc((gsize+1)*(gsize+1)*sizeof(int));
if(new_g == NULL)
exit(1);
int* row = (int *)malloc((gsize+1)*sizeof(int));
memcpy(row, g, gsize*sizeof(int));
free(g);
gsize = gsize+1;
create_sgraph(&new_g, gsize, row);
free(row);
//CopyGraph(g,gsize,new_g,gsize+1);
set_sedge(&new_g, gsize, gsize-1, 0);
long count0 = CliqueCount(new_g, gsize);
set_sedge(&new_g, gsize, gsize-1, 1);
long count1 = CliqueCount(new_g, gsize);
if(count0 < count1)
set_sedge(&new_g, gsize, gsize-1, 0);
taboo_array = (int*) malloc(sizeof(int)*gsize);
memset(taboo_array, 0, sizeof(int)*gsize);
g = new_g;
}
else
{
int* row = (int *)malloc(gsize*sizeof(int));
memcpy(row, g, gsize*sizeof(int));
create_sgraph(&g, gsize, row);
taboo_array = (int*)malloc(sizeof(int)*gsize);
memset(taboo_array, 0, gsize*sizeof(int));
printf("Starting from given graph of size %d\n.", gsize);
fflush(stdout);
free(row);
}
}
/*
*make a fifo to use as the taboo list
*/
taboo_list = FIFOInitEdge(TABOOSIZE);
if(taboo_list == NULL) {
exit(1);
}
/*
* while we do not have a publishable result
*/
while(gsize<206)
{
best_count = BIGCOUNT;
while(gsize < 206)
{
best_j = -1;
count = CliqueCount(g,gsize);
if(count == 0)
{
printf("Eureka! Sym Counter-example found!\n");
PrintGraph(g,gsize);
fflush(stdout);
/*
* make a new graph one size bigger
*/
new_g = (int *)malloc((gsize+1)*(gsize+1)*sizeof(int));
if(new_g == NULL)
exit(1);
int* row = (int *)malloc((gsize+1)*sizeof(int));
memcpy(row, g, gsize*sizeof(int));
free(g);
gsize = gsize+1;
create_sgraph(&new_g, gsize, row);
free(row);
//CopyGraph(g,gsize,new_g,gsize+1);
set_sedge(&new_g, gsize, gsize-1, 0);
long count0 = CliqueCount(new_g, gsize);
set_sedge(&new_g, gsize, gsize-1, 1);
long count1 = CliqueCount(new_g, gsize);
if(count0 < count1)
set_sedge(&new_g, gsize, gsize-1, 0);
taboo_array = (int*) malloc(sizeof(int)*gsize);
memset(taboo_array, 0, sizeof(int)*gsize);
g = new_g;
best_count = BIGCOUNT;
/*
* reset the taboo list for the new graph
*/
//taboo_list = FIFOResetEdge(taboo_list);
free(taboo_array);
taboo_array = (int*) malloc(sizeof(int)*gsize);
memset(taboo_array, 0, sizeof(int)*gsize);
continue;
}
//best_count = BIGCOUNT;
prev_best_count = best_count;
if(multi<5){
for(i=0; i < gsize; i++)
{
flip_sedge(&g, gsize, i);
count = CliqueCount(g,gsize);
if(count<best_count && !taboo_array[i]){
//if(count<best_count ){
best_count = count;
best_i = i;
}
flip_sedge(&g, gsize, i);
}
}
else{
for(i=0; i<gsize; i++){
for(j=i+1; j<gsize; j++){
flip_sedge(&g, gsize, i);
flip_sedge(&g, gsize, j);
count = CliqueCount(g,gsize);
if(count<best_count){
best_count = count;
best_i = i;
best_j = j;
}
flip_sedge(&g, gsize, i);
flip_sedge(&g, gsize, j);
}
}
}
if(best_count == BIGCOUNT || best_count==prev_best_count) {
if(multi>=5)
{
printf("no best edge found, continuing with taboo\n");
fflush(stdout);
break;
}
else
{
printf("single flip exhausted. starting singleflip again.", multi);
fflush(stdout);
memset(taboo_array, 0, sizeof(int)*gsize);
multi ++;
continue;
}
//flip_sedge(g, gsize, i);
}
flip_sedge(&g, gsize, best_i);
count = best_count;
if(multi)
flip_sedge(&g, gsize, best_j);
taboo_array[best_i] = 1;
printf("sym ce size: %d, best_count: %ld, best edge(s): (%d), (%d)\n", gsize, best_count, best_i, best_j);
g_latest = g;
g_size_latest = gsize;
g_count_latest = count;
fflush(stdout);
}
while(gsize < 206)
{
/*
* if we have a counter example
*/
if(count == 0)
{
printf("Eureka! Counter-example found!\n");
PrintGraph(g,gsize);
fflush(stdout);
/*
* make a new graph one size bigger
*/
new_g = (int *)malloc((gsize+1)*(gsize+1)*sizeof(int));
if(new_g == NULL)
exit(1);
/*
* copy the old graph into the new graph leaving the
* last row and last column alone
*/
CopyGraph(g,gsize,new_g,gsize+1);
/*
* zero out the last column and last row
*/
for(i=0; i < (gsize+1); i++)
{
if(drand48() > 0.5) {
new_g[i*(gsize+1) + gsize] = 0; // last column
new_g[gsize*(gsize+1) + i] = 0; // last row
}
else
{
new_g[i*(gsize+1) + gsize] = 1; // last column
new_g[gsize*(gsize+1) + i] = 1; // last row
}
}
/*
* throw away the old graph and make new one the
* graph
*/
free(g);
g = new_g;
gsize = gsize+1;
/*
* reset the taboo list for the new graph
*/
taboo_list = FIFOResetEdge(taboo_list);
/*
* keep going
*/
//continue;
break; //Go to first while loop
}
/*
* otherwise, we need to consider flipping an edge
*
* let's speculative flip each edge, record the new count,
* and unflip the edge. We'll then remember the best flip and
* keep it next time around
*
* only need to work with upper triangle of matrix =>
* notice the indices
*/
best_count = BIGCOUNT;
for(i=0; i < gsize; i++)
{
for(j=i+1; j < gsize; j++)
{
/*
* flip two edges (i,j), (i,random(j) + 1)
*/
int k = getRandomJ(gsize);
int l = getRandomJ(gsize);
g[i*gsize+j] = 1 - g[i*gsize+j];
count_1 = CliqueCount(g,gsize);
if (k == j)
k = j + 1;
g[i*gsize + k] = 1 - g[i*gsize + k];
count_2 = CliqueCount(g,gsize);
if (l == j)
l = j + 1;
if (l == k)
l = (k + 1) % gsize;
g[i*gsize + l] = 1 - g[i*gsize + l];
count_3 = CliqueCount(g,gsize);
count = (count_1 < count_2) ? count_1 : count_2 ;
count = (count_3 < count) ? count_3 : count ;
/*
* is it better and the i,j,count not taboo?
*/
if(count < best_count){
if(count == count_1
//#ifdef USE_TABOO
&& !FIFOFindEdgeCount(taboo_list,i,j,count)
//#endif
)
{
best_count = count;
best_i = i;
best_j = j;
best_k = best_l = -1;
}
else if(count == count_2
//#ifdef USE_TABOO
&& (!FIFOFindEdgeCount(taboo_list,i,j,count)
|| !FIFOFindEdgeCount(taboo_list,i,k, count))
//#endif
)
{
best_count = count;
best_i = i;
best_j = j;
best_k = k;
best_l = -1;
}
else if(count == count_3
//#ifdef USE_TABOO
&& (!FIFOFindEdgeCount(taboo_list,i,j,count)
|| !FIFOFindEdgeCount(taboo_list,i,k, count)
|| !FIFOFindEdgeCount(taboo_list,i,l, count))
//#endif
)
{
best_count = count;
best_i = i;
best_j = j;
best_k = k;
best_l = l;
}
}
/*
* flip it back
*/
g[i*gsize+j] = 1 - g[i*gsize+j];
g[i*gsize+k] = 1 - g[i*gsize+k];
g[i*gsize+l] = 1 - g[i*gsize+l];
}
}
if(best_count == BIGCOUNT) {
printf("no best edge found, terminating\n");
exit(1);
}
/*
* keep the best flip we saw
*/
g[best_i*gsize + best_j] = 1 - g[best_i*gsize + best_j];
if (best_k != -1)
g[best_i*gsize + best_k] = 1 - g[best_i*gsize + best_k];
if (best_l != -1)
g[best_i*gsize + best_l] = 1 - g[best_i*gsize + best_l];
/*
* taboo this graph configuration so that we don't visit
* it again
*/
//count = CliqueCount(g,gsize);
count = best_count;
//#ifdef USE_TABOO
// FIFOInsertEdge(taboo_list,best_i,best_j);
FIFOInsertEdgeCount(taboo_list,best_i,best_j,count);
if (best_k != -1)
FIFOInsertEdgeCount(taboo_list,best_i,best_k,count);
if (best_l != -1)
FIFOInsertEdgeCount(taboo_list,best_i,best_l,count);
//#endif
printf("ce size: %d, best_count: %ld, best edges: (%d,%d) (%d,%d) (%d,%d), new colors: %d %d\n",
gsize,
best_count,
best_i,
best_j,
best_i,
best_k,
best_i,
best_l,
g[best_i*gsize+best_j],
g[best_i*gsize+best_k]);
fflush(stdout);
g_latest = g;
g_size_latest = gsize;
g_count_latest = count;
/*
* rinse and repeat
*/
}
}
FIFODeleteGraph(taboo_list);
return(0);
}
int main(int argc,char *argv[])
{
printf("Setting up signals \n");
signal(SIGINT, sig_handler);
signal(SIGTERM, sig_handler);
int *g;
int *new_g;
int gsize;
int count;
int i;
int j;
int best_count;
int best_i;
int best_j;
void *taboo_list;
int val,iter,jter;
int gt[2];
int t=INITEM;
int sock = -1;
char Fname[255];
char c;
int ilim = 8;
while((c = getopt(argc,argv,ARGS)) != EOF)
{
switch(c)
{
case 'f':
strncpy(Fname,optarg,sizeof(Fname));
break;
case 'l':
printf("optarg: %s", optarg);
ilim = atoi(optarg);
break;
default:
fprintf(stderr,
"test_clique_count unrecognized argument: %c\n",c);
fflush(stderr);
break;
}
}
if(!ReadGraph(Fname,&g,&gsize))
{
gsize = ilim;
g = PaleyGraph(ilim);
}
/*
* make a fifo to use as the taboo list
*/
taboo_list = FIFOInitEdge(TABOOSIZE);
if(taboo_list == NULL) {
exit(1);
}
int best_clique = INITEM;
int flag = 0; int min_count = BIGCOUNT;
//int term = atoi(argv[1]);
/*
* while we do not have a publishable result
*/
while(gsize <= ilim)
{
printf("Graph size is %d\n", gsize);
/*
* find out how we are doing
*/
count = CliqueCount(g,gsize);
int * cliques = (int*)malloc( (gsize)* (gsize) *sizeof(int));
memset (cliques,INICLI,(gsize)* (gsize));
/*
* if we have a counter example
*/
if(count == 0)
{
printf("Eureka! Counter-example found!\n");
min_count = BIGCOUNT;
FILE *fp;
//printf("Filename: %s", buf);
fp = fopen("result.state", "w");
PrintGraphToFile(g, gsize, fp);
fclose(fp);
//socket_upload_2(sock, -1, -1, count, gsize, g);
/*
* make a new graph one size bigger
*/
new_g = (int *)malloc((gsize+1)*(gsize+1)*sizeof(int));
if(new_g == NULL)
exit(1);
/*
* copy the old graph into the new graph leaving the
* last row and last column alone
*/
CopyGraph(g,gsize,new_g,gsize+1);
/*
* zero out the last column and last row
*/
for(i=0; i < (gsize+1); i++)
{
if(drand48() > 0.5) {
new_g[i*(gsize+1) + gsize] = 0; // last column
new_g[gsize*(gsize+1) + i] = 0; // last row
}
else
{
new_g[i*(gsize+1) + gsize] = 1; // last column
new_g[gsize*(gsize+1) + i] = 1; // last row
}
}
/*
* throw away the old graph and make new one the
* graph
*/
free(g);
g = new_g;
gsize = gsize+1;
/*
* reset the taboo list for the new graph
*/
taboo_list = FIFOResetEdge(taboo_list);
/*
* keep going
*/
continue;
}
/*
* otherwise, we need to consider flipping an edge
*
* let's speculative flip each edge, record the new count,
* and unflip the edge. We'll then remember the best flip and
* keep it next time around
*
* only need to work with upper triangle of matrix =>
* notice the indices
*/
best_clique = INICLI;
time_t tim;
srand((unsigned) time(&tim));
// Introducing randomization into system
int choice = rand() % 10;
printf("choice: %d \n", choice);
if (choice == 0){
i=rand()%gsize;
j=rand()%gsize;
while (FIFOFindEdge(taboo_list,i,j)){
i=rand()%gsize;
j=rand()%gsize;
}
gt[0]=i;
gt[1]=j;
g[gt[0]*gsize+gt[1]] = 1 - g[gt[0]*gsize+gt[1]];
// Getting clique count of edges on flipping - assuming random move is best
best_clique=CliqueCount_D(g,gsize,gt[0],gt[1], 0);
g[gt[0]*gsize+gt[1]] = 1 - g[gt[0]*gsize+gt[1]];
}
else{
for(i=0; i < gsize; i++)
{
for(j=i+1; j < gsize; j++)
{
if(!FIFOFindEdge(taboo_list,i,j)){
// Clique Count without flip
int old_clique = CliqueCount_D(g,gsize,i,j, 0);
// Clique Count with flip
int new_clique = CliqueCount_D(g,gsize,i,j, 1);
// Improvement with flip
cliques[i*gsize+j] = count + new_clique - old_clique;
}
}
}
// Finding edges in clique
for(i=0; i < gsize; i++)
{
for(j=i+1; j < gsize; j++)
{
if(!FIFOFindEdge(taboo_list,i,j) )
{
if(cliques[i*gsize+j] < best_clique )
{
best_clique = cliques[i*gsize+j];
gt[0] = i;
gt[1] = j;
}
}
}
}
}
printf("2\n");
if(min_count > count)
{
min_count = count;
}
if (best_clique <= count){
g[gt[0]*gsize+gt[1]] = 1 - g[gt[0]*gsize+gt[1]];
if( CliqueCount(g, gsize) > count)
{
g[gt[0]*gsize+gt[1]] = 1 - g[gt[0]*gsize+gt[1]];
}
}
printf("3\n");
FIFOInsertEdge(taboo_list,gt[0],gt[1]);
printf("4\n");
t-=DTEM;
if (t==0){
t=INITEM;
}
printf("5\n");
//socket_upload_2(sock, gt[0], gt[1], count, gsize, g);
printf("size: %d, temperature: %d, count: %d, best_clique: %d\n", gsize, t, count, best_clique);
free(cliques);
g_latest = g;
g_size_latest = gsize;
g_count_latest = count;
}
FIFODeleteGraph(taboo_list);
return(0);
}
int
main(int argc,char *argv[])
{
int *g;
int *new_g;
int *new_edges;
int seed = 1;
int gsize;
int count;
int i;
int j;
int k;
int best_count;
int best_i;
int best_j;
void *taboo_list;
/*
* start with graph of size 15
*/
gsize = 15;
g = (int *)malloc(gsize*gsize*sizeof(int));
if(g == NULL) {
exit(1);
}
/*
* make a fifo to use as the taboo list
*/
taboo_list = FIFOInitEdge(TABOOSIZE);
if(taboo_list == NULL) {
exit(1);
}
/*
* start out with half 1 and half 0.
*/
InitGraph(g, gsize, seed);
/*
* while we do not have a publishable result
*/
while(gsize < 102)
{
/*
* find out how we are doing
*/
count = CliqueCount(g,gsize);
/*
* if we have a counter example
*/
if(count == 0)
{
printf("Eureka! Counter-example found!\n");
PrintGraph(g,gsize);
OutputGraph(g,gsize, seed);
/*
* make a new graph one size bigger
*/
new_g = (int *)malloc((gsize+1)*(gsize+1)*sizeof(int));
if(new_g == NULL)
exit(1);
/*
* copy the old graph into the new graph leaving the
* last row and last column alone
*/
CopyGraph(g,gsize,new_g,gsize+1);
/*
* half-half the last column and zero out the last row
*/
new_edges = (int *)malloc(gsize*sizeof(int));
InitEdges(new_edges, gsize, seed);
k = 0;
for(i=0; i < gsize; i++)
{
new_g[i*(gsize+1) + gsize] = new_edges[k]; // last column
new_g[gsize*(gsize+1) + i] = 0; // last row
k ++;
}
new_g[(gsize+1)*(gsize+1)] = 0;
free(new_edges);
/*
* throw away the old graph and make new one the
* graph
*/
free(g);
g = new_g;
gsize = gsize+1;
/*
* reset the taboo list for the new graph
*/
taboo_list = FIFOResetEdge(taboo_list);
/*
* keep going
*/
continue;
}
/*
* otherwise, we need to consider flipping an edge
*
* let's speculative flip each edge, record the new count,
* and unflip the edge. We'll then remember the best flip and
* keep it next time around
*
* only need to work with upper triangle of matrix =>
* notice the indices
*/
best_count = BIGCOUNT;
for(i=0; i < gsize; i++)
{
for(j=i+1; j < gsize; j++)
{
/*
* flip it
*/
g[i*gsize+j] = 1 - g[i*gsize+j];
//printf("The best count is %d, and the count is %d.", best_count, count);
count = CliqueCount_EA(g,gsize,best_count);
//count = CliqueCount(g, gsize);
/*
* is it better and the i,j,count not taboo?
*/
if((count < best_count) &&
// !FIFOFindEdge(taboo_list,i,j))
!FIFOFindEdgeCount(taboo_list,i,j,count))
{
best_count = count;
best_i = i;
best_j = j;
}
/*
* flip it back
*/
g[i*gsize+j] = 1 - g[i*gsize+j];
}
}
if(best_count == BIGCOUNT) {
printf("no best edge found, terminating\n");
exit(1);
}
/*
* keep the best flip we saw
*/
g[best_i*gsize+best_j] = 1 - g[best_i*gsize+best_j];
/*
* taboo this graph configuration so that we don't visit
* it again
*/
count = CliqueCount(g,gsize);
// FIFOInsertEdge(taboo_list,best_i,best_j);
FIFOInsertEdgeCount(taboo_list,best_i,best_j,count);
printf("ce size: %d, best_count: %d, best edge: (%d,%d), new color: %d\n",
gsize,
best_count,
best_i,
best_j,
g[best_i*gsize+best_j]);
/*
* rinse and repeat
*/
}
FIFODeleteGraph(taboo_list);
return(0);
}
