void novoFinal(node* Fila)
{
node* novoItem = (node*) malloc(sizeof(node));
if(!novoItem)
{
puts("\nNão há memória suficiente!");
exit(1);
}
else
{
printf("\nInsira o número: "); scanf("%d", &novoItem->num);
if(vazia(Fila))
Fila->prox = novoItem;
else
{
node* tmp = Fila->prox;
while(tmp->prox != NULL)
tmp = tmp->prox;
tmp->prox = novoItem;
}
}
}
int retirar (TFila *fila){
PEDIDO elemento;
int i;
if (!vazia(*fila)){
elemento = fila->vetFila[fila->inicio];
printf("****Elemento Retirado****\n");
printf("Nome da Instituição: %s\n", elemento.Nome);
printf("Tipo de Reparo: %d\n", elemento.TipoReparo);
printf("Numero do protocolo: %d\n\n", elemento.Protocolo);
for (i = 0; i < fila->fim - 1; i++)
{
fila->vetFila[i] = fila->vetFila[i+1];
}
fila->fim--;
fila->contador--;
return 1;
}
else{
printf("fila cheia");
return -1;
}
}
void exibe(no_t *p,aluno_t *y)
{
if(vazia(p))
{
printf("Lista vazia!\n\n");
}
if(y->prox==NULL)
printf("Lista vazia!\n\n");
no_t *tmp;
aluno_t *tmp1;
tmp = p->prox;
tmp1 = y->prox;
while(tmp != NULL && tmp1 != NULL)
{
printf("%s: %.2f",tmp1->nome,tmp->nota);
tmp = tmp->prox;
tmp1=tmp1->prox;
printf("\n");
}
}
void bfs(grafo *g,int s,Fila *f){
int u,i;
g->cor[s]=cinza;
g->dist[s]=0;
esvazia(f);
insere(f,s);
while(!vazia(f)){
u=retira(f);
for(i=0;i<g->tam;i++){
if(g->A[u][i]!=0 && g->cor[i]==branco){
g->cor[i]=cinza;
g->dist[i]=g->dist[u]+1;
g->pred[i]=u;
insere(f,i);
}
}
g->cor[u]=preto;
}
}
void insereFim(Categoria *listCat)
{
Categoria *novo=(Categoria *) malloc(sizeof(Categoria));
if(!novo){
printf("Sem memoria disponivel!\n");
exit(1);
}
//preenche categoria
cadCategoria(novo);
novo->proximo = NULL;
if(vazia(listCat))
listCat->proximo=novo;
else{
Categoria *tmp = listCat->proximo;
while(tmp->proximo != NULL)
tmp = tmp->proximo;
tmp->proximo = novo;
}
}
int remover_item(LISTA_LIGADA *lista, int chave) {
if(lista != NULL) {
if(!vazia(lista)) {
NO *paux = lista->sentinela;
while(paux->proximo->item->chave != chave) {
paux = paux->proximo;
}
if(paux != lista->sentinela) {
NO *prem = paux->proximo;
paux->proximo = prem->proximo;
if(prem == lista->fim) lista->fim = paux;
apagar_no(prem);
lista->tamanho--;
return 1;
}
}
}
return 0;
}
int preenche(int i, int j, int k)
{
int l, t;
ini = fim = 0;
insere(i,j);
t = 0;
comp[i][j] = k;
while(!vazia()){
retira(&i, &j);
t++;
/*fprintf(stderr, "Visitei %d %d\n", i, j);*/
l = castelo[i][j];
if(l % 2 == 0 && comp[i][j-1] == 0){
comp[i][j-1] = k;
insere(i, j-1);
}
l = l >> 1;
if(l % 2 == 0 && comp[i-1][j] == 0){
comp[i-1][j] = k;
insere(i-1, j);
}
l = l >> 1;
if(l % 2 == 0 && comp[i][j+1] == 0){
comp[i][j+1] = k;
insere(i, j+1);
}
l = l >> 1;
if(l % 2 == 0 && comp[i+1][j] == 0){
comp[i+1][j] = k;
insere(i+1, j);
}
}
return t;
}
//Nome: MatrizAdjacenciaBuscaProfund
//Função: Realiza uma busca em profundidade em um grafo a partir de um nó, para descobrir se é conexo
//Entrada: Ponteiro para a estrutura de um grafo, nó inicial
//Saída: Retorna TRUE se o grafo é conexo e FALSE caso contrário
int MatrizAdjacenciaBuscaProfund(GrafoAdj *grafo, int valor){
int marca = 1;
int i, no;
int compConex = FALSE;
Pilha *p = cria();
visitados = (int*) malloc(sizeof(int) * grafo->vertices);
for (i = 0; i < grafo->vertices; i++) visitados[i] = 0;
visitados[valor-1] = marca;
empilha(p, valor-1);
//while (compConex == TRUE){
while (!vazia(p)){
no = desempilha(p);
visitados[no] = marca;
for (i = 0; i < grafo->vertices; i++){
if (grafo->matrizAdj[no][i] != 0){
if(visitados[i] == 0)
empilha(p, i);
}
}
}
compConex = TRUE;
//marca++;
for (i = 0; i < grafo->vertices; i++){
if (visitados[i] == 0) {
compConex = FALSE;
break;
}
}
//if (compConex == TRUE) empilha(p, i);
//}
free(visitados);
destroi(p);
return compConex;
}
//Exibe Pilha
void exibe(tpilha *PILHA)
{
if(vazia(PILHA)){
printf("\nPilha vazia!\n\n");
return ;
}
tpilha *aux;
aux = PILHA->prox;
system("cls");
printf("PILHA:\n");
printf("-----------------------------------------------------------------\n");
printf("|| ||\n");
printf("||");
while( aux != NULL){
printf("%d", aux->num);
if(aux->prox!=NULL)printf(", ");
else printf(" ->");
aux = aux->prox;
}
printf("\n|| ||\n");
printf("-----------------------------------------------------------------\n");
/*printf("\n ");
int count;
for(count=0 ; count < tam ; count++)
printf(" ^ ");
printf("\nOrdem:");
for(count=0 ; count < tam ; count++)
printf("%5d", count+1); */
printf("\n\n");
}
void insere(apontador local, tipoItem item, tipoLista* lista){
if(lista->tamanho <= 1024){
if(vazia(*lista)){
apontador aux = (apontador)malloc(sizeof(celula));
aux->item = item;
lista->primeiro->prox = aux;
aux->anterior = lista->primeiro;
lista->ultimo = aux;
aux->prox = NULL;
}
else if(local == NULL){
apontador aux = (apontador)malloc(sizeof(celula));
aux->item = item;
aux->anterior = lista->ultimo;
lista->ultimo->prox = aux;
lista->ultimo = aux;
aux->prox = NULL;
}
else{
apontador aux = (apontador)malloc(sizeof(celula));
aux->item = item;
aux->prox = local;
local->anterior->prox = aux;
aux->anterior = local->anterior;
local->anterior = aux;
}
lista->tamanho++;
}
}
//proc. que insere no----------------------------------------------------------------------------------
parvore insere_no(parvore *raiz, tcod cod) {
parvore ant, atual;
if (vazia(*raiz)) {
*raiz = cria_no(cod);
(*raiz) -> pai = NULL; // a raiz da arvore possui "pai = NULL "
return((*raiz));
}
else {
atual = (*raiz);
while (atual != NULL) {
if (cod == atual -> cod) {
printf(" O valor e chave ja existe na arvore ");
return (NULL);
}
else {
ant = atual;
if (maior(atual -> cod, cod))
atual = atual -> esq;
else
atual = atual -> dir;
}
}
if ( maior(ant -> cod, cod) ) {
ant -> esq = cria_no(cod);
ant -> esq -> pai = ant;
return ( ant -> esq);
}
else {
ant -> dir = cria_no(cod);
ant -> dir -> pai = ant;
return (ant -> dir);
}
}
}
/**
* Calcula média de acessos as chaves inseridas
*/
void media_acessos() {
float count_jumps = 0, qtd_chaves = 0;
// int count_jumps = 0, qtd_chaves = 0;
node *LISTA = (node *) malloc(sizeof (node));
if (!LISTA) {
exit(1);
} else {
inicia(LISTA);
}
if ((arquivo_hashing = fopen(ARQUIVO, "rb+")) == NULL) {
printf("\nErro ao abrir arquivo!");
return;
}
// int i;
// contar as chaves inseridas, salvar em uma lista e consultar até o final da lista
for (int i = 0; i < TAMANHO_ARQUIVO; i++) {
fseek(arquivo_hashing, ((i + 1) * sizeof (struct REGISTRO)), SEEK_SET);
fread(&tabela_h, sizeof (struct REGISTRO), 1, arquivo_hashing);
// insere todas as chaves do arquivo na lista
if (tabela_h.chave != -1) {
insereFim(LISTA, tabela_h.chave, tabela_h.nome, tabela_h.idade);
qtd_chaves++;
}
}
if (vazia(LISTA)) {
// return;
}
node *tmp;
tmp = LISTA->prox;
//loop para contar os acessos
while (tmp != NULL) {
int indice_elemento = consultar(tmp->chave, 1);
int exit = 0;
// retirar depois
// printf("Chave: %d %s %d\n", tmp->chave, tmp->nome, tmp->idade);
// consultar todos os pais
while (exit == 0) {
fseek(arquivo_hashing, (indice_elemento + 1) * sizeof (struct REGISTRO), SEEK_SET);
fread(&tabela_h, sizeof (struct REGISTRO), 1, arquivo_hashing);
// fprintf(stderr, "jumps %f\n", count_jumps);
//saída do loop dos pais
if (tabela_h.index_father == -1) {
exit = 1;
// fprintf(stderr, "cj %d", count_jumps);
} else
indice_elemento = tabela_h.index_father;
// incrementa contador
count_jumps++;
}
// seleciona próximo da lista
tmp = tmp->prox;
}
if (qtd_chaves != 0) {
float media_acessos = count_jumps / qtd_chaves;
fprintf(stderr, "%.1f", media_acessos);
} else {
fprintf(stderr, "0.0");
}
// media = acessos / TAMANHO_ARQUIVO
fclose(arquivo_hashing);
}
bool pop(stFila *qual)
{
if (vazia(*qual)) return false;
qual->inicio++;
return true;
}
int analisadorSintatico(FILE* codigo, char** TABGRAFO, char*** TABT, char*** TABNT, char*** ANASIN, int linhasTabNT, int** automato, Hash tab, FILE* tabVar, Hash tabProc){
char nomeArquivo[20];
int* flag1 = (int *)malloc(sizeof(int));;
*flag1 = 0;
FILE* codigoIntermediario;
//Inicializa as Pilhas
Pilha* cadeia = inicializarPilha(cadeia);
Pilha* naoTerminais = inicializarPilha(naoTerminais);
push(naoTerminais,"progrm",10,0);
char* cadCaracteres = (char *)malloc(50*sizeof(char));
char* cadTerminais = (char *)malloc(50*sizeof(char));
char* p = (char *)malloc(50*sizeof(char));
//Isso sera alterado quando comecarmos a ler strings ao inves de caracteres
char* caracter = (char *)malloc(50*sizeof(char));
int numeroLinha = 0;
int aux=0;
int aux2=0;
int flag = 0;
char** vetor = (char **)malloc(4*sizeof(char *));
int i;
for(i=0;i<4;i++){
vetor[i] = (char *)malloc(20*sizeof(char));
}
int* posicaoArquivo = (int *)malloc(sizeof(int));
int* linhaArquivo = (int *)malloc(sizeof(int));
*linhaArquivo = 1;
*posicaoArquivo = 0;
while(executaAnalisador(codigo, automato, 34, 7, tab, posicaoArquivo, vetor, tabProc, variaveis, linhaArquivo)) {
strcpy(caracter, vetor[1]);
printf("\n\nLinha %d | Lexema: \"%s\"\n", aux+1, caracter);
if(aux==-1){
printf("\n\n!! Cadeia nao aceita !!\n\n\n");
//printf("\n\nErro na linha %d\n\n",*linhaArquivo);
return 0;
}
while(1){
// para aux == -2
while(aux==-2 && !vaziaNTerminais(naoTerminais)){
//imprimirPilha(naoTerminais);
aux = atoi(ANASIN[buscaNoTopo(naoTerminais)][4])-1;
printf("Voltando para linha %d.\n", aux+1);
if(aux==-1) aux = -2;
if(aux!=-2){
while(aux!=-1 && strcmp(ANASIN[aux][1],caracter)!=0){ //Verifica os nos alternativos para procurar o caracter
aux = atoi(ANASIN[aux][3])-1;
printf("Voltando novamente, para linha %d.\n", aux+1);
// trick para tratar alternativo igual a -1
if(aux==-2) aux = -1;
}
if(aux==-1) aux = -2;
}
// printf("%s\n",caracter);
// printf("O Nao Terminal abaixo eh pai de: ");
// imprimePilhaPosicaoAteTopo(cadeia, buscaPosicaoReconhecida(naoTerminais));
desempilhaDaPosicaoAteTopo(cadeia,buscaPosicaoReconhecida(naoTerminais)); //Adicionar uma especie de fila aqui
strcpy(p, pop(naoTerminais));
push(cadeia,p,0,0);
// printf("Desempilha o nao terminal %s\n",p);
}
if(vaziaNTerminais(naoTerminais) && aux==-2){
printf("\n\n!! Cadeia nao aceita !!\n\n\n");
// printf("Linha %d - Lexema \"%s\" encontrado.\n", numeroLinha, caracter);
return 0;
}
// Para um Terminal encontrado
if(strcmp(ANASIN[aux][0],"T")==0){
// para caracter lido reconhecido
if(strcmp(ANASIN[aux][1],caracter)==0){
strcpy(cadCaracteres,ANASIN[aux][1]);
push(cadeia,cadCaracteres,0,0); //Insere na pilha o caracter reconhecido
aplicaAcoesSemanticas(codigoIntermediario, atoi(ANASIN[aux][5]),vetor, nomeArquivo, flag1);
printf("TO AQUI %s\n",ANASIN[aux][5]);
//imprimirPilha(cadeia);
aux = atoi(ANASIN[aux][4])-1; //Aux recebe a linha correspondente ao sucessor do no encontrado
printf("Lexema aceito. O sucessor é a linha: %d\n", aux+1);
//printf("%s - %d\n", cadCaracteres, atoi(ANASIN[aux][5]));
if(aux==-1) {
aux=-2;
printf("Linha sucessora é 0, ou seja, Chegamos ao fim dessa cadeia não terminal.\n");
}
break;
}
// para caracter não reconhecido
else {
aux = atoi(ANASIN[aux][3])-1; //Aux recebe a posicao do no alternativo
//Caso nao haja mais nenhum no alternativo
if(aux==-2){
printf("\n\n!! Cadeia nao aceita !!\n\n\n");
//printf("\n\nErro na linha %d\n\n",*linhaArquivo);
return 0;
}
printf("Não reconhecido. Alternativo na linha: %d\n", aux+1);
}
}
// para um não terminal encontrado
else if(strcmp(ANASIN[aux][0],"N")==0){ //Encontra um Nao Terminal
strcpy(cadTerminais,ANASIN[aux][1]);
aplicaAcoesSemanticas(codigoIntermediario, atoi(ANASIN[aux][5]),vetor, nomeArquivo, flag1);
push(naoTerminais,cadTerminais,atoi(ANASIN[aux][2])-1,topo(cadeia)); //Empilha o nao terminal na pilha de nao naoTerminais
printf("Não terminal encontrado: \"%s\". Devemos empilha-lo.\n",cadTerminais);
printf("Ao finalizar esse não terminal devemos voltar na linha: %d. ", atoi(ANASIN[aux][4]));
aux = verificaLinhaTerminal(TABNT,linhasTabNT,cadTerminais); //Aux vai para a linha correspondente ao grafo do nao terminal
printf("Vai para a linha: %d\n", aux+1);
// imprimirPilha(naoTerminais);
}
}
numeroLinha = aux;
strcpy(vetor[0], "");
strcpy(vetor[1], "");
strcpy(vetor[2], "");
}
imprimirPilha(naoTerminais);
while(!vazia(naoTerminais)){
// printf("O Nao Terminal Abaixo é pai de: ");
// imprimePilhaPosicaoAteTopo(cadeia, buscaPosicaoReconhecida(naoTerminais));
desempilhaDaPosicaoAteTopo(cadeia,buscaPosicaoReconhecida(naoTerminais));
strcpy(p,pop(naoTerminais));
// printf("Desempilhando o %s\n",p);
push(cadeia,p,0,0);
}
printf("\n\n!! Cadeia reconhecida !!\n\n\n");
return 1;
}
int main (){
printf("Software de Fila Circular\n\n");
printf("Para limpar a tela durante a execucao do programa, digite '9'\n\nPara alternar entre Fila Circular Simples e Merge, digite '0'\n\nPara limpar o Merge, digite '8'\n\n");
printf("PRESSIONE ENTER");
fflush(stdin);
getchar();
system("cls");
//Decisão para Fila Circular simples ou Merge de 2 Filas Circulares
int menu = 3;
int tamanho;
int decisao;
int valor;
int aux;
while (menu != 1 && menu != 2){
printf("1 - Fila Circular Simples\t 2 - Merge\tOpcao: ");
scanf("%d", &menu);
system("cls");
}
if (menu == 1){
fila f;
printf("Entre com o tamanho da fila: ");
scanf("%d", &tamanho);
criafila(&f, tamanho);
system("cls");
while (menu == 1){
printf("\n");
printf("1 - Inserir\t2 - Remover\t3 - Imprimir\n4 - Vazia\t5 - Cheia\tOpcao: ");
scanf("%d", &decisao);
//INICIO SWITCH
switch(decisao){
case 1:{
if(cheia(&f) == 1){
printf("\nFila Cheia\n");
}
else{
printf("Inserir valor: ");
scanf("%d", &valor);
inserir(valor, &f);
}
break;
}
case 2:{
if(vazia(&f) == 1)
printf("\nFila Vazia\n");
else{
remove(&f);
printf("\nRemovido\n");
}
break;
}
case 3:{
if(vazia(&f) == 1)
printf("\nFila Vazia\n");
else{
imprime(&f);
}
break;
}
case 4:{
if(vazia(&f) == 1)
printf("\nFila Vazia\n");
else printf("\nFila Nao Vazia\n");
break;
}
case 5:{
if(cheia(&f) == 1)
printf("\nFila Cheia\n");
else printf("\nFila Nao Cheia\n");
break;
}
case 0:{
menu = 2;
system("cls");
break;
}
case 9:{
system("cls");
break;
}
}
// FIM SWITCH
}
}
int verifica = 0;
while (menu == 2){
fila f1, f2, merge;
int tam1, tam2;
int decfila = 3;
if (verifica == 0){
printf("Digite o tamanho da primeira fila: ");
scanf("%d", &tam1);
printf("Digite o tamanho da segunda fila: ");
scanf("%d", &tam2);
criafila(&f1, tam1);
criafila(&f2, tam2);
criafila(&merge, tam1 + tam2);
verifica = 9;
}
while (decfila != 1 && decfila != 2){
printf("Qual fila deseja modificar? ");
scanf ("%d", &decfila);
}
while (decfila == 1){
while(decfila == 1){
printf("\n");
printf("1 - Inserir\t2 - Remover\t3 - Imprimir\t4 - Vazia\n5 - Cheia\t6 - Mudar Fila\t7 - Merge\tOpcao: ");
scanf("%d", &decisao);
switch(decisao){
case 1:{
if(cheia(&f1) == 1){
printf("\nFila Cheia\n");
}
else{
printf("Inserir valor: ");
scanf("%d", &valor);
inserir(valor, &f1);
}
break;
}
case 2:{
if(vazia(&f1) == 1)
printf("\nFila Vazia\n");
else{
remove(&f1);
printf("\nRemovido\n");
}
break;
}
case 3:{
if(vazia(&f1) == 1)
printf("\nFila Vazia\n");
else{
imprime(&f1);
}
break;
}
case 4:{
if(vazia(&f1) == 1)
printf("\nFila Vazia\n");
else printf("\nFila Nao Vazia\n");
break;
}
case 5:{
if(cheia(&f1) == 1)
printf("\nFila Cheia\n");
else printf("\nFila Nao Cheia\n");
break;
}
case 6:{
decfila = 3;
system("cls");
while (decfila != 1 && decfila != 2){
printf("Qual fila deseja modificar? ");
scanf ("%d", &decfila);
}
system("cls");
break;
}
case 7:{
faz_merge(&f1, &f2, &merge);
imprime(&merge);
break;
}
case 8: {
while(vazia(&merge) == 0){
remove(&merge);
}
if(vazia(&merge)==1)
printf("Merge Limpo");
break;
}
case 9: {
system("cls");
break;
}
}
}
}
while(decfila == 2){
while(decfila == 2){
printf("\n");
printf("1 - Inserir\t2 - Remover\t3 - Imprimir\t4 - Vazia\n5 - Cheia\t6 - Mudar Fila\t7 - Merge\tOpcao: ");
scanf("%d", &decisao);
switch(decisao){
case 1:{
if(cheia(&f2) == 1){
printf("\nFila Cheia\n");
}
else{
printf("Inserir valor: ");
scanf("%d", &valor);
inserir(valor, &f2);
}
break;
}
case 2:{
if(vazia(&f2) == 1)
printf("\nFila Vazia\n");
else{
remove(&f2);
printf("\nRemovido\n");
}
break;
}
case 3:{
if(vazia(&f2) == 1)
printf("\nFila Vazia\n");
else{
imprime(&f2);
}
break;
}
case 4:{
if(vazia(&f2) == 1)
printf("\nFila Vazia\n");
else printf("\nFila Nao Vazia\n");
break;
}
case 5:{
if(cheia(&f2) == 1)
printf("\nFila Cheia\n");
else printf("\nFila Nao Cheia\n");
break;
}
case 6:{
system("cls");
decfila = 3;
if (decfila != 1 && decfila != 2){
printf("Qual fila deseja modificar? ");
scanf ("%d", &decfila);
}
system("cls");
break;
}
case 7:{
faz_merge(&f1, &f2, &merge);
imprime(&merge);
break;
}
case 8:{
while(vazia(&merge) == 0){
remove(&merge);
}
if(vazia(&merge)==1)
printf("Merge Limpo");
break;
}
case 9: {
system("cls");
break;
}
}
}
}
}
fflush(stdin);
getchar();
return 0;
}
int main()
{
int i, j;
int infi;
int max;
FILE *fin = fopen("maze1.in", "r");
FILE *fout = fopen("maze1.out", "w");
int w, h;
fscanf(fin, " %d %d", &w, &h);
infi = 10000;
for(i=0; i<2*h+1; i++){
for(j=0; j<2*w+1; j++){
do{
labirinto[i][j] = getc(fin);
}while(labirinto[i][j] == '\n');
dist[i][j] = infi;
}
}
ini = fim = 0;
for(i=0; i<2*h+1; i++){
if(labirinto[i][0] == ' '){
dist[i][1] = 1;
insere(i, 1);
}
if(labirinto[i][2*w] == ' '){
dist[i][2*w-1] = 1;
insere(i, 2*w-1);
}
}
for(j=0; j<2*w+1; j++){
if(labirinto[0][j] == ' '){
dist[1][j] = 1;
insere(1, j);
}
if(labirinto[2*h][j] == ' '){
dist[2*h-1][j] = 1;
insere(2*h-1, j);
}
}
while(!vazia()){
retira(&i, &j);
if(i < 2*h-1 && labirinto[i+1][j] == ' ' && labirinto[i+2][j] == ' '
&& dist[i][j] + 1 < dist[i+2][j])
{
dist[i+2][j] = dist[i][j] + 1;
insere(i+2, j);
}
if(i > 1 && labirinto[i-1][j] == ' ' && labirinto[i-2][j] == ' '
&& dist[i][j] + 1 < dist[i-2][j])
{
dist[i-2][j] = dist[i][j] + 1;
insere(i-2, j);
}
if(j < 2*w-1 && labirinto[i][j+1] == ' ' && labirinto[i][j+2] == ' '
&& dist[i][j] + 1 < dist[i][j+2])
{
dist[i][j+2] = dist[i][j] + 1;
insere(i, j+2);
}
if(j > 1 && labirinto[i][j-1] == ' ' && labirinto[i][j-2] == ' '
&& dist[i][j] + 1 < dist[i][j-2])
{
dist[i][j-2] = dist[i][j] + 1;
insere(i, j-2);
}
}
max = 0;
for(i=0; i<2*h+1; i++){
for(j=0; j<2*w+1; j++){
if(dist[i][j] < infi && dist[i][j] > max)
max = dist[i][j];
}
}
fprintf(fout,"%d\n", max);
return 0;
}
