/*****************************************************************************
* Le caractere por caractere no arquivo, fazendo toda
* a logica necessaria para insercao nas pilhas
*****************************************************************************/
int leArquivoConfigurandoPilhas(Pilha* pilhas[], FILE *arquivo, unsigned short int linhaInicial, unsigned short int linhaFinal, unsigned short int tamLinha){
// Linha do arquivo = coluna no jogo.
// 3 colunas no arquivo = carta (linha) no jogo.
unsigned int short linha, coluna;
for(linha = linhaInicial-1; linha < linhaFinal; linha++){
for(coluna = 0; coluna < tamLinha; coluna++){
char numeroCarta[2];
char naipeCarta;
numeroCarta[0] = fgetc(arquivo);
coluna++;
if((int)numeroCarta[0] > 64){
if(numeroCarta[0] == 'A'){
numeroCarta[0] = '0';
numeroCarta[1] = '1';
coluna++;
}
else if(numeroCarta[0] == 'J'){
numeroCarta[0] = '1';
numeroCarta[1] = '1';
coluna++;
}
else if(numeroCarta[0] == 'Q'){
numeroCarta[0] = '1';
numeroCarta[1] = '2';
coluna++;
}
else if(numeroCarta[0] == 'K'){
numeroCarta[0] = '1';
numeroCarta[1] = '3';
coluna++;
}
} else {
numeroCarta[1] = fgetc(arquivo);
coluna++;
}
naipeCarta = fgetc(arquivo);
Carta carta = criaCarta((unsigned short int)atoi(numeroCarta), naipeCarta);
inserePilha(pilhas[linha], carta);
}
// Essas duas lidas ridiculas sao para consumir o '\n'
// e o '\0' do final de cada linha
char nada;
nada = fgetc(arquivo);
// Porem, o '\0' aparentemente so existe no Linux, entao
// no Windows nao eh necessario ler duas vezes
#ifndef __WIN32
nada = fgetc(arquivo);
#endif
}
}
/*****************************************************************************
* Movimenta uma carta de [W-Z] para [A-H]
*****************************************************************************/
void movimentaSuperiorEsquerdaParaNormal(Carta cartasSuperiorEsquerda[], Pilha* pilhasNormais[], unsigned short int indiceColunaOrigem, unsigned short int indiceColunaDestino, char mensagemErro[], unsigned short int *jogadaJogador){
Carta cartaColunaOrigem = cartasSuperiorEsquerda[indiceColunaOrigem];
unsigned short int corCartaColunaOrigem = checaCorNaipe(cartaColunaOrigem.naipe);
Carta cartaColunaDestino = topoPilha(pilhasNormais[indiceColunaDestino]);
unsigned short int corCartaColunaDestino = checaCorNaipe(cartaColunaDestino.naipe);
if(corCartaColunaDestino != corCartaColunaOrigem){
if(cartaColunaOrigem.numero == cartaColunaDestino.numero-1 || pilhasNormais[indiceColunaDestino]->qntd == 0){
inserePilha(pilhasNormais[indiceColunaDestino], cartasSuperiorEsquerda[indiceColunaOrigem]);
inicializaCartaComValorPadrao(&(cartasSuperiorEsquerda[indiceColunaOrigem]));
(*jogadaJogador)++;
} else {
strcpy(mensagemErro, "Voce so pode agrupar cartas em ordem decrescente.");
}
} else{
strcpy(mensagemErro, "Voce so pode agrupar cartas cujos naipes tenham cores diferentes.");
}
}
/*****************************************************************************
* Movimenta uma carta de [A-H] para [0-3]
*****************************************************************************/
void movimentaNormalParaSuperiorDireita(Pilha* pilhasNormais[], Pilha* pilhasSuperiorDireita[], unsigned short int indiceColunaOrigem, unsigned short int indiceColunaDestino, char mensagemErro[], unsigned short int *jogadaJogador, unsigned short int *colunasFormadas){
Carta cartaColunaOrigem = topoPilha(pilhasNormais[indiceColunaOrigem]);
Carta cartaColunaDestino = topoPilha(pilhasSuperiorDireita[indiceColunaDestino]);
if(cartaColunaOrigem.naipe == cartaColunaDestino.naipe || pilhasSuperiorDireita[indiceColunaDestino]->qntd == 0){
if(cartaColunaOrigem.numero == cartaColunaDestino.numero+1 || pilhasSuperiorDireita[indiceColunaDestino]->qntd == 0 && cartaColunaOrigem.numero == 1){
(*jogadaJogador)++;
inserePilha(pilhasSuperiorDireita[indiceColunaDestino], cartaColunaOrigem);
removePilha(pilhasNormais[indiceColunaOrigem]);
if(cartaColunaOrigem.numero == MAIOR_VALOR_CARTA){
colunasFormadas++;
}
} else {
strcpy(mensagemErro, "Nas colunas [0-3], voce so pode agrupar cartas em ordem crescente.");
}
} else {
strcpy(mensagemErro, "Nas colunas [0-3], as cartas precisam ser sempre do mesmo naipe.");
}
}
/*****************************************************************************
* Movimenta uma carta de [W-Z] para [0-3]
*****************************************************************************/
void movimentaSuperiorEsquerdaParaSuperiorDireita(Carta cartasSuperiorEsquerda[], Pilha* pilhasSuperiorDireita[], unsigned short int indiceColunaOrigem, unsigned short int indiceColunaDestino, char mensagemErro[], unsigned short int *jogadaJogador, unsigned short int *colunasFormadas){
Carta cartaColunaOrigem = cartasSuperiorEsquerda[indiceColunaOrigem];
Carta cartaColunaDestino = topoPilha(pilhasSuperiorDireita[indiceColunaDestino]);
if(cartaColunaOrigem.naipe == cartaColunaDestino.naipe || pilhasSuperiorDireita[indiceColunaDestino]->qntd == 0){
if(cartaColunaOrigem.numero == cartaColunaDestino.numero+1 || pilhasSuperiorDireita[indiceColunaDestino]->qntd == 0 && cartaColunaOrigem.numero == 1){
inserePilha(pilhasSuperiorDireita[indiceColunaDestino], cartaColunaOrigem);
inicializaCartaComValorPadrao(&(cartasSuperiorEsquerda[indiceColunaOrigem]));
(*jogadaJogador)++;
// Se a carta a ser inserida eh a ultima (13), entao a coluna esta formada
if(cartaColunaOrigem.numero == MAIOR_VALOR_CARTA){
colunasFormadas++;
}
} else {
strcpy(mensagemErro, "Nas colunas [0-3], voce so pode agrupar cartas em ordem crescente.");
}
} else {
strcpy(mensagemErro, "Nas colunas [0-3], as cartas precisam ser sempre do mesmo naipe.");
}
}
void coloracaoGulosa(Grafo g, int k)
{
/*Cria um grafo de backup*/
GBsalvaGrafo(g,"guardaGrafo.txt");
Grafo grafo = GGcarregaGrafo("guardaGrafo.txt");
remove("guardaGrafo.txt");
/*Declaracao de variaveis e EDs*/
int i, corVizinho, vertice, menorGrau, aresta, encontrouMenor,menorCor, verticeVizinho, tamanho = GInumeroVertices(grafo);
Pilha pilha = criaPilha();
VetVertice vertices = (VetVertice) malloc(sizeof(struct vetVertice)*tamanho);
vertice = GVprimeiroVertice(grafo);
/*Colore como neutro todos os vertices*/
vertices[0].idVertice = vertice;
vertices[0].cor = 0;
for(i = 1; i < tamanho; i++)
{
vertices[i].idVertice = GVproximoVertice(grafo,vertice);
vertices[i].cor = 0;
vertice = GVproximoVertice(grafo,vertice);
}
/*Definicao da ordem de coloracao*/
while(GInumeroVertices(grafo) != 0)
{
menorGrau = INT_MAX;
for(i = GVprimeiroVertice(grafo); i != 0; i = GVproximoVertice(grafo,i))
{
if(GIpegaGrau(grafo,i) < menorGrau)
{
menorGrau = GIpegaGrau(grafo,i);
vertice = i;
}
}
GVdestroiVertice(grafo,vertice);
inserePilha(pilha,vertice);
}
GGdestroiGrafo(grafo);
/*Colore os vertices*/
while(!vaziaPilha(pilha))
{
vertice = retirarPilha(pilha);
if(GIpegaGrau(g,vertice) >= k)
{
printf("Não existe solução\n");
return;
}
encontrouMenor = 0;
menorCor = 1;
int achouIgual = 0;
while(!encontrouMenor)
{
achouIgual = 0;
for(aresta = GAprimaAresta(g,vertice); aresta != 0; aresta = GAproxAresta(g,vertice,aresta))
{
verticeVizinho = GVvizinho(g,aresta,vertice);
corVizinho = pegaCorVertice(vertices,tamanho,verticeVizinho);
if(menorCor == corVizinho)
{
achouIgual = 1;
}
}
if(achouIgual)
{
menorCor++;
}
else
{
encontrouMenor = 1;
}
}
coloreVertice(vertices,tamanho,vertice,menorCor);
}
for(i = 0; i < tamanho; i++)
{
printf("Vertice %d possui a cor %d\n", vertices[i].idVertice, vertices[i].cor);
}
}
void infixToPostfix(char expr[], Pilha *p, char post[]) {
int i = 0;
int count = 0;
int abriuParentesis = 0; // flag para indicar se abriu parentesis
// limpar o post
post[0] = '\0';
// para evitar: a+b+
char ultimo = expr[strlen(expr) - 1];
// Garante que a string possui somente caracteres validos
i = 0;
while (i < MAX && expr[i] != '\0' && expr[i] != '\n') {
if (!operadorValido(expr[i])) {
strcpy(post,"Lexical Error!");
return;
}
i++;
}
i = 0;
while (i < MAX && expr[i] != '\0' && expr[i] != '\n') {
// do infix to postfix
if (simbolo(expr[i])) {
// para evitar: aa+bb, a(b+c)
if (i+1 != MAX && (simbolo(expr[i + 1]) || expr[i + 1] == '(')) {
strcpy(post,"Syntax Error!");
return;
}
// concatena o na string posfixa
post[count] = expr[i];
post[count + 1] = '\0';
count++;
} else {
// para evitar: a++b
if (expr[i]=='(' && !simbolo(expr[i+1]) || (expr[i]!='(' && expr[i]!=')') && (expr[i+1]!='(' && expr[i+1]!=')') && !simbolo(expr[i+1]) ) {
strcpy(post,"Syntax Error!");
return;
}
if (pilhaVazia(p) || expr[i]=='(' || abriuParentesis) {
inserePilha(p, expr[i]);
abriuParentesis = expr[i] == '(' ? 1 : 0;
} else if (expr[i] == ')') {
while (!pilhaVazia(p) && topo(p) != '(') {
// remove da pilha e insere na string
post[count] = removePilha(p);
post[count + 1] = '\0';
count++;
}
// caso encontre o '(' remove da pilha
if (pilhaVazia(p)) {
strcpy(post,"Syntax Error!");
return;
} else {
removePilha(p);
abriuParentesis = 0;
}
} else {
if (temPrecedencia(topo(p), expr[i])) {
do {
post[count] = removePilha(p);
post[count + 1] = '\0';
count++;
} while (!pilhaVazia(p) && temPrecedencia(topo(p), expr[i]));
inserePilha(p, expr[i]);
} else {
inserePilha(p, expr[i]);
}
}
}
i++;
}
if (operadorValido(ultimo) && !simbolo(ultimo) && ultimo != ')') {
strcpy(post,"Syntax Error!");
return;
}
while(!(pilhaVazia(p))) {
post[count] = removePilha(p);
post[count + 1] = '\0';
count++;
}
// verifica se faltou fechar algum parentesis
for (i = 0; i < count; i++) {
if (post[i] == '(') {
strcpy(post,"Syntax Error!");
return;
}
}
}
