unsigned int grau(vertice v, int direcao, grafo g) {
if( !g ) return 0;
switch( direcao ){
case 0 : return tamanho_lista(v->arestas_saida);
case 1 : return tamanho_lista(v->arestas_saida);
case -1 : return tamanho_lista(v->arestas_entrada);
}
return 0; // evita warning
}
int clique(lista l, grafo g){
unsigned int removed = 0;
for (no n=primeiro_no(l); n!=NULL; n=proximo_no(n)) {
vertice v = conteudo(n);
if(v->removido == 0){
lista vizinhos = vizinhanca(v,0,g);
unsigned int todos_nos = tamanho_lista(l) - removed - 1;
for (no auxN=primeiro_no(vizinhos); auxN!=NULL; auxN=proximo_no(auxN)) {
if(todos_nos == 0)
break;
vertice auxV = conteudo(auxN);
if(auxV->removido == 0){
for (no verifiyNode=primeiro_no(l); verifiyNode!=NULL; verifiyNode=proximo_no(verifiyNode)) {
vertice verifyVertice = conteudo(verifiyNode);
if(verifyVertice->removido == 0){
if(strcmp(verifyVertice->nome,auxV->nome) == 0){
todos_nos--;
break;
}
}
}
}
}
if(todos_nos != 0){
return 0;
}
}
else{
removed ++;
}
}
return 1;
}
int sao_isomorfos(grafo g, grafo f)
{
int i = 0;
int j, k;
int iso = 0;
int tam = g.n_vertices;
int *tmp = (int*) malloc(sizeof(int));
int v[tam], t_perm = 0;
lista *perm;
perm = constroi_lista();
for(i=0; i < tam; i++)
{
v[i] = i;
}
if((g.n_vertices != f.n_vertices) || (g.arestas != f.arestas)
|| (!iguais(g, f)))
return iso;
perm = nova_permuta(perm, v, 0, tam);
t_perm = tamanho_lista(perm);
for(i=0; i < t_perm; i++)
{
tmp = (int*) remove_lista(perm);
//mostre(tmp, tam);
iso = 1;
for(j=0; j < tam; j++)
{
for(k=0; k < tam; k++)
{
if(g.matriz[j][k] != f.matriz[tmp[j]][tmp[k]])
{
iso = 0;
/*printf("Nao e isomorfo - ");
mostre(tmp, tam);*/
break;
}
}
if(!iso)
break;
}
if(iso)
{
/*printf("E isomorfo - ");
mostre(tmp, tam);*/
destroi_lista(perm);
return 1;
}
}
destroi_lista(perm);
return 0;
}
void ordena_tarefas(lista_enc_t* lista_tarefas)
{
tarefa_t* p_tarefa;
tarefa_t* p_tarefa_next;
no_t* p_no;
int tamanho, i;
for(tamanho = tamanho_lista(lista_tarefas); tamanho>1; tamanho--){
p_no = obter_cabeca(lista_tarefas);
for(i=0; i<(tamanho-1); i++){
p_tarefa = (tarefa_t*) obter_dado(p_no);
p_no = obtem_proximo(p_no);
p_tarefa_next = (tarefa_t*) obter_dado(p_no);
if(tarefa_get_periodo(p_tarefa) > tarefa_get_periodo(p_tarefa_next)){
swap_nos(lista_tarefas, obtem_anterior(p_no));
}
}
}
}
//------------------------------------------------------------------------------
//
static grafo grafo_emparelhamento(grafo g) {
grafo e = malloc(sizeof(struct grafo));
if( !e ) return NULL;
e->nome = malloc(sizeof(char) * strlen(g->nome)+1);
strcpy(e->nome, g->nome);
e->direcionado = g->direcionado;
e->ponderado = g->ponderado;
e->vertices = constroi_lista();
for( no nv = primeiro_no(g->vertices); nv; nv = proximo_no(nv) ){
vertice ve = malloc(sizeof(struct vertice));
vertice vg = conteudo(nv);
ve->nome = malloc(sizeof(char) * strlen(nome_vertice(vg))+1);
strcpy(ve->nome, nome_vertice(vg));
ve->visitado = 0;
ve->coberto = vg->coberto;
ve->arestas_saida = constroi_lista();
ve->arestas_entrada = constroi_lista();
insere_lista(ve, e->vertices);
}
e->n_vertices = tamanho_lista(e->vertices);
e->n_arestas = 0;
for( no nv = primeiro_no(e->vertices); nv; nv = proximo_no(nv) ){
vertice ve = conteudo(nv);
vertice vg = busca_vertice(g->vertices, nome_vertice(ve));
for( no na = primeiro_no(vg->arestas_saida); na; na = proximo_no(na) ){
aresta ag = conteudo(na);
if (ag->origem != vg) continue;
if( ag->coberta ){
aresta ae = copia_aresta( ag, e );
insere_lista(ae, ae->destino->arestas_saida);
insere_lista(ae, ae->origem->arestas_saida);
e->n_arestas++;
}
}
}
return e;
}
void ganntNomenclatura(FILE *fp, lista_enc_t* lista_tarefas)
{
tarefa_t* p_tarefa;
no_t* p_no;
int tamanho, i;
fprintf(fp, "\t%% Nomenclatura das tarefas\n");
tamanho = tamanho_lista(lista_tarefas);
fprintf(fp, "\t\\RowLabel{%d}{CPU}\n", tamanho+1);
p_no = obter_cabeca(lista_tarefas);
for(i = 0; i < tamanho; i++){
p_tarefa = (tarefa_t*) obter_dado(p_no);
fprintf(fp, "\t\\RowLabel{%d}{$\\tau_%d$}\n", i+1, tarefa_get_id(p_tarefa));
p_no = obtem_proximo(p_no);
}
fprintf(fp, "\n");
}
/*----------------------------------------------------------------------------*/
int vazia_lista(lista *l) { return tamanho_lista(l) == 0; }
