/*
* clique_unweighted_max_weight()
*
* Returns the size of the maximum (sized) clique in g (or 0 if search
* was aborted).
*
* g - the graph
* opts - time printing options
*
* Note: As we don't have an algorithm faster than actually finding
* a maximum clique, we use clique_unweighted_find_single().
* This incurs only very small overhead.
*/
int clique_unweighted_max_weight(graph_t *g, clique_options *opts) {
set_t s;
int size;
ASSERT((sizeof(setelement)*8)==ELEMENTSIZE);
ASSERT(g!=NULL);
s=clique_unweighted_find_single(g,0,0,FALSE,opts);
if (s==NULL) {
/* Search was aborted. */
return 0;
}
size=set_size(s);
set_free(s);
return size;
}
// Computes a maximum clique of the graph g and return its size
// The table list contains the ID of the vertices
int sage_clique_max(graph_t *g,int **list){
sage_reset_global_variables();
quiet++;
set_t s;
int i,l;
clique_options *opts = sage_init_clique_opt();
s=clique_unweighted_find_single(g,/*min_weight*/0,
/*max_weight*/0,/*maximal*/TRUE,
opts);
free(opts);
// Writing the answer into a int [] to be read by Sage
int size=set_size(s);
*list=malloc(sizeof(int)*size);
l=0;
for (i=0; i<SET_MAX_SIZE(s); i++) {
if (SET_CONTAINS(s,i)) {
*((*list)+l)=i;
l++;
}
}
return size;
}
/*
* clique_find_single()
*
* Returns a clique with weight at least min_weight and at most max_weight.
*
* g - the graph
* min_weight - minimum weight of clique to search for. If min_weight==0,
* searches for a maximum weight clique.
* max_weight - maximum weight of clique to search for. If max_weight==0,
* no upper limit is used. If min_weight==0, max_weight must
* also be 0.
* maximal - require returned clique to be maximal
* opts - time printing options
*
* Returns the set of vertices forming the clique, or NULL if a clique
* of requested weight/maximality does not exist in the graph (or if
* opts->time_function() requests abort).
*
* The returned clique is newly allocated and can be freed by set_free().
*
* Note: Does NOT use opts->user_function() or opts->clique_list[].
* Note: Automatically uses clique_unweighted_find_single if all vertex
* weights are the same.
*/
set_t clique_find_single(graph_t *g,int min_weight,int max_weight,
boolean maximal, clique_options *opts) {
int i;
int *table;
set_t s;
ENTRANCE_SAVE();
entrance_level++;
if (opts==NULL)
opts=clique_default_options;
ASSERT((sizeof(setelement)*8)==ELEMENTSIZE);
ASSERT(g!=NULL);
ASSERT(min_weight>=0);
ASSERT(max_weight>=0);
ASSERT((max_weight==0) || (min_weight <= max_weight));
ASSERT(!((min_weight==0) && (max_weight>0)));
ASSERT((opts->reorder_function==NULL) || (opts->reorder_map==NULL));
if ((max_weight>0) && (min_weight>max_weight)) {
/* state was not changed */
entrance_level--;
return NULL;
}
if (clocks_per_sec==0)
clocks_per_sec=sysconf(_SC_CLK_TCK);
ASSERT(clocks_per_sec>0);
/* Check whether we can use unweighted routines. */
if (!graph_weighted(g)) {
min_weight=DIV_UP(min_weight,g->weights[0]);
if (max_weight) {
max_weight=DIV_DOWN(max_weight,g->weights[0]);
if (max_weight < min_weight) {
/* state was not changed */
entrance_level--;
return NULL;
}
}
weight_multiplier = g->weights[0];
entrance_level--;
s=clique_unweighted_find_single(g,min_weight,max_weight,
maximal,opts);
ENTRANCE_RESTORE();
return s;
}
/* Dynamic allocation */
current_clique=set_new(g->n);
best_clique=set_new(g->n);
clique_size=malloc(g->n * sizeof(int));
memset(clique_size, 0, g->n * sizeof(int));
/* table allocated later */
temp_list=malloc((g->n+2)*sizeof(int *));
temp_count=0;
clique_list_count=0;
/* "start clock" */
gettimeofday(&realtimer,NULL);
times(&cputimer);
/* reorder */
if (opts->reorder_function) {
table=opts->reorder_function(g,TRUE);
} else if (opts->reorder_map) {
table=reorder_duplicate(opts->reorder_map,g->n);
} else {
table=reorder_ident(g->n);
}
ASSERT(reorder_is_bijection(table,g->n));
if (max_weight==0)
max_weight=INT_MAX;
if (weighted_clique_search_single(table,min_weight,max_weight,
g,opts)==0) {
/* Requested clique has not been found. */
set_free(best_clique);
best_clique=NULL;
goto cleanreturn;
}
if (maximal && (min_weight>0)) {
maximalize_clique(best_clique,g);
if (graph_subgraph_weight(g,best_clique) > max_weight) {
clique_options localopts;
localopts.time_function = opts->time_function;
localopts.output = opts->output;
localopts.user_function = false_function;
localopts.clique_list = &best_clique;
localopts.clique_list_length = 1;
for (i=0; i < g->n-1; i++)
if ((clique_size[table[i]] >= min_weight) ||
(clique_size[table[i]] == 0))
break;
if (!weighted_clique_search_all(table,i,min_weight,
max_weight,maximal,
g,&localopts)) {
set_free(best_clique);
best_clique=NULL;
}
}
}
cleanreturn:
s=best_clique;
/* Free resources */
for (i=0; i < temp_count; i++)
free(temp_list[i]);
free(temp_list);
temp_list=NULL;
temp_count=0;
free(table);
set_free(current_clique);
current_clique=NULL;
free(clique_size);
clique_size=NULL;
ENTRANCE_RESTORE();
entrance_level--;
return s;
}
