///cria um grafo com arestas somente entre os objetos menores que uma distancia randomizada
void PreClusterizacao(float VetoresMenores[], float MatrizNVAdjacente[][NUM_OBJETOS], float MatrizDistancias[][NUM_OBJETOS]){
float media= CalculaMediaVetor(VetoresMenores);
srand( (unsigned)time(NULL) ); //criar o alfa randomico; srand é fundamental para que a função rand traga valores aleatórios diferentes a cada rodada de execução
float randomico, limite;
int i,j;
for(i=0;i<NUM_OBJETOS;i++){
for(j=0;j<NUM_OBJETOS;j++){
randomico= rand() % 101;
randomico=(randomico/100);//randomico tem valor entre 0 e 1
if(randomico==0)
j--;
else{
limite=randomico*media;
// printf("limite= %f e media= %f",limite, media);
// printf("MAT[%d][%d]=%f\n", i, j, MatrizDistancias[i][j]);
if(MatrizDistancias[i][j]<=limite && i!=j && MatrizNVAdjacente[i][j]!=1){
MatrizNVAdjacente[i][j]=1;
MatrizNVAdjacente[j][i]=1;
printf("\nA distancia do objeto %d ao objeto %d eh %.3f e eh menor que o limite %.3f\n", i,j, MatrizDistancias[i][j], limite);
}
}
}
}
printf(("\nA NV_Adjacente foi atualizada para: \n"));
ImprimeMatriz(MatrizNVAdjacente);
}
///cria um grafo com arestas somente entre os objetos mais próximos
void AtribuiMatrizAdjacente(float Matriz_distancias[][NUM_OBJETOS],float Matriz_adjacente[][NUM_OBJETOS], float Vetor_menores[]){
int i,j;
for(i=0;i<NUM_OBJETOS;i++){
for(j=0;j<NUM_OBJETOS;j++){
if(Matriz_distancias[i][j]==Vetor_menores[j]){
Matriz_adjacente[i][j]=1;
}
}
}
printf("\nA matriz adjacente foi atualizada para:\n");
ImprimeMatriz(Matriz_adjacente);
}
IniciarJogo(int **mat1,int **mat2,int **mat3, int lin, int col){
//FUNÇÂO para inicio do jogo chamando outras funções
do{
ContarVizinhos(mat1, mat2, lin, col);
RegrasDoJogo(mat1, mat2, lin, col);
AtualizacaooDeMatrizes(mat1, mat3, lin, col);
ImprimeMatriz(mat1, lin, col);
CopiarMatriz(mat1, mat3, lin, col);
ZerarMatDois(mat2, lin, col);
//Condição para parar o jogo!
}while (AtualizacaooDeMatrizes(mat1, mat3, lin, col) != 1);
}
void EmbaralhaMatrizExemplo(int sudokuExemplo[SIZE][SIZE])
{
int x;
srand(time(NULL));
x = rand()%2;
switch (x)
{
case 0:
TrocaColunaLinha (sudokuExemplo);
ImprimeMatriz (sudokuExemplo);
break;
case 1:
TrocaLinhaVertical (sudokuExemplo);
ImprimeMatriz (sudokuExemplo);
break;
case 2:
TrocaLinhaHorizontal (sudokuExemplo);
ImprimeMatriz (sudokuExemplo);
break;
}
}
///atribui as distancias de todos os objetos na matriz de distancia e atribui como zero as duas outras matrizes
void AtribuiDistanciaZeraResto(struct ListaObjetos* ListaObjetos, float Distancias[][NUM_OBJETOS], float Adjacente[][NUM_OBJETOS], float NV_Adjacente[][NUM_OBJETOS]){
int i,j;
struct ListaObjetos* ListaObjAux1= ListaObjetos;
struct ListaObjetos* ListaObjAux2= ListaObjetos;
for(i=0;i<NUM_OBJETOS;i++){
for(j=0;j<NUM_OBJETOS;j++){
Distancias[i][j]= calculaDistanciaEuclidiana(ListaObjAux1->objeto,ListaObjAux2->objeto);
ListaObjAux2=ListaObjAux2->prox;
Adjacente[i][j]=0;
NV_Adjacente[i][j]=0;
}
ListaObjAux2=ListaObjetos;
ListaObjAux1=ListaObjAux1->prox;
}
// printf("\nMatriz Adjacente:\n");
// ImprimeMatriz(Adjacente);
// printf("\nMatriz NV Adjacente:\n");
// ImprimeMatriz(NV_Adjacente);
printf("\nMatriz de Distancias:\n");
ImprimeMatriz(Distancias);
}
int main(int argc, char *argv[])
{
char nomeArquivoMatrizA[] = "in1.txt";
char nomeArquivoMatrizB[] = "in2.txt";
char nomeArquivoSaida[] = "out.txt";
int metadadosA[2],metadadosB[2];
int qtdProcessos = atoi(argv[1]);
int i,j,k;
if(LerMetadadosMatriz(&nomeArquivoMatrizA,metadadosA) && LerMetadadosMatriz(&nomeArquivoMatrizB,metadadosB))
{
if(metadadosA[1] != metadadosB[0]){
printf("Erro de entrada - Numero de colunas da primeira matriz eh diferente do numero de linhas da segunda matriz.\n");
return 0;
}
if(metadadosA[0] < qtdProcessos){
printf("Erro de entrada - Numero de processos/threads nao pode ser maior que o numero de linhas da matriz resultante.\n");
return 0;
}
int **matrizA = malloc(sizeof(int)*metadadosA[0]*metadadosA[1]);
int **matrizB = malloc(sizeof(int)*metadadosB[0]*metadadosB[1]);
//Criando espaco de memoria compartilhada
int md = shmget(IPC_PRIVATE, sizeof(int)*metadadosA[0]*metadadosB[1], IPC_CREAT|0666);
//Pai se anexa a essa memoria compartilhada tambem
int **matrizResultante = (int*)shmat(md, NULL, 0);
//Limpando garbage
bzero(matrizResultante, sizeof(int)*metadadosA[0]*metadadosB[1]);
if(LerMatrizes(&nomeArquivoMatrizA,metadadosA[0],metadadosA[1],matrizA) && LerMatrizes(&nomeArquivoMatrizB,metadadosB[0],metadadosB[1],matrizB))
{
int* linhas[qtdProcessos];
divideLinhas(linhas,metadadosA[0],qtdProcessos);
for(i=0; i<qtdProcessos; i++){
pid_t pid = fork();
//Se sou processo filho
if(pid == 0){
for(j=linhas[i][0];j<=linhas[i][1];j++){
computaLinha(metadadosA, metadadosB, matrizA, matrizB, j, matrizResultante);
}
return 0;
}
}
//Pai espera o final de todos os processos para executar
for (i = 0; i < qtdProcessos; ++i)
{
waitpid(0, NULL, 0);
}
ImprimeMatriz(nomeArquivoSaida,metadadosA[0],metadadosB[1],matrizResultante);
for (i = 0; i < qtdProcessos; ++i)
{
free(linhas[i]);
}
//Liberando memoria compartilhada
shmctl(md, IPC_RMID, NULL);
}
else
{
printf("Erro ao tentar ler matrizes");
}
}
else
{
printf("Erro ao tentar ler os metadados");
}
return 0;
}
int main( int argc , char const *argv[] )
{
int validacao; //Armazena o retorno de verificação da posição inicial
int opcao; //Armazena a opção selecionada do menu
int dimensao; //Armazena a dimensao do labirinto
int *matrizLabirinto; //Matriz em forma de vetor para armazenar o labirinto
FILE *entrada; //Ponteiro para leitura do labirinto
FILE *saida; //Ponteiro para criação do arquivo de saida do labirinto
tPontoLabirinto *posicaoInicial; //Posição inicial informada pelo usuario x e y
system( "cls || clear" ); //Limpa tela no Linux/Windows
printf( "Bem Vindo ao Busca Saida 3000!\nAutor:Gabriel Rodrigues dos Santos\n\n" );
//Print de boas vindas
do{ //Inicio da criação do menu
opcao = CriaInterface( 0 ); //Chamada da função de criação do menu
switch ( opcao ) { //Seleciona as opções do menu
case 1: //Caso "Carregar arquivo de labirinto e achar saida"
system( "cls || clear" ); //Limpa tela no Linux/Windows
if ( ( entrada = fopen ( "Labirinto.txt" , "r" ) ) == NULL ) //Abertura do labirinto
{
printf ( "Arquivo 'Labirinto.txt' nao foi encontrado ou nao pode ser aberto. Leia as Instrucoes\n" );
break;
}//Fim do if entrada
posicaoInicial = AlocaPonto ( ); //Aloca ponto
//Atribuição de valores ao ponto
fscanf ( entrada , "%d %d\n" , &( posicaoInicial->y ) , &( posicaoInicial->x ) ); //Leitura do ponto na primeira linha do arquivo
posicaoInicial->x--; /* "Normaliza" os pontos para trabalhar na matriz corretamente */
posicaoInicial->y--;
fscanf( entrada , "%d\n" , &dimensao ); //Leitura da dimensao da matriz na segunda linha do arquivo
matrizLabirinto = AlocaMatriz( &dimensao ); //Chamda para alocação da matriz
LeMatriz( entrada , matrizLabirinto , &dimensao ); //Chamada de leitura da matriz
//validação da localização inicial
validacao = VerificacaoInicial( posicaoInicial , matrizLabirinto , &dimensao );
if ( validacao == 1 ) //Se localização for verdade chama as funções de funcionamento
{
ChecagemETroca( posicaoInicial , matrizLabirinto , &dimensao ); //Chamada da função de procura do labirinto
if ( semSaida == 1 ) //Caso não haja saida do labirinto
{
printf ( "Labirinto Sem Saida!\n\n" );
semSaida = 0;
break;
}//Fim do if semSaida
matrizLabirinto[ posicaoInicial->x * dimensao + posicaoInicial->y ] = 3; //Coloca ultimo passo dado para sair do labirinto
LimpaCaminho ( matrizLabirinto , &dimensao ); //Chama função de limpar caminho sem saida
if ( ( saida = fopen ( "SaidaLabirinto.txt" , "w" ) ) == NULL ) //Criação do arquivo de saida do labirinto
{
printf( "Arquivo 'SaidaLabirinto.txt' nao pode ser criado. Verifique se o usuario tem permissao para criar arquivos no local.\n\n" );
break;
}//Fim do if saida
ImprimeMatriz ( matrizLabirinto , &dimensao , saida ); //Chama função de impressão
LimpaTudo ( posicaoInicial , matrizLabirinto , entrada , saida ); //Chama funcao de limpeza
printf("Saida encontrada com sucesso, procure o arquivo 'SaidaLabirinto.txt' na pasta raiz do programa\n\n");
}
/*Fim do if validação*/
break; //Fim do caso 1
case 2: //Caso "Sobre e Instrucoes"
opcao = CriaInterface( 1 ); //Chama funcao para escrever o sobre e já seta para o menu inicial
break; //Fim do caso 2
case 3: //Caso "Sair"
system( "cls || clear" ); //Limpa tela no Linux/Windows
exit( -1 );//Sai do programa
default: //Caso usuario digite uma opção invalida
system( "cls || clear" ); //Limpa tela no Linux/Windows
printf( "Digite uma opcao valida!\n\n" );
} //Fim do Switch case opcao
}while( opcao != 3 ); //Fim do Do While opcao
return 0;
} /*Fim da função main*/
