tabuleiro *resolver(tabuleiro *tab){
char tmp[100][100];
int lin,col;
tabuleiro *f, *w, *z, *x;
do{
for(lin=0;lin!=tab->tamanho[0];lin++)
for(col=0;col!=tab->tamanho[1];col++)
tmp[lin][col]=tab->quadro[lin][col];
f=aloca(tab);
w=verigual(tab,estra1(f));
f=aloca(w);
z=verigual(w,estra2(f));
f=aloca(z);
x=verigual(z,estra3(f));
f=aloca(x);
tab=verigual(x,estra4(f));
}while(changes(tmp,tab) && verifica(tab)!=2);
if(verifica(tab)==2);
else tab=aleatorio(tab,0);
return tab;
}
int main (void){
lista<string> l1;
l1.begin = NULL;
l1.end = NULL;
push_back(l1,new string ("R"));
push_back(l1,new string ("A"));
push_back(l1,new string ("D"));
push_back(l1,new string ("A"));
push_back(l1,new string ("R"));
imprime(l1);
verifica(l1);
lista<string> l2;
l2.begin = NULL;
l2.end = NULL;
push_back(l2,new string ("R"));
push_back(l2,new string ("A"));
push_back(l2,new string ("D"));
push_back(l2,new string ("A"));
push_back(l2,new string ("E"));
imprime(l2);
verifica(l2);
}
int main()
{
int matriz[9][9],j,i;
for (i=0;i<9;i++)
{
for(j=0;j<9;j++)
{
scanf("%d ",&matriz[i][j]);
}
}
verifica(matriz);
/*for (i=0;i<9;i++)
{
for(j=0;j<9;j++)
{
if(matriz[i][j]==0)
{
verifica(i,j,matriz);
}
}
}
*/
system("pause");
return 0;
}
int main () {
/* Declara as variaveis da funcao 'main' */
int i, j, ocorrencias = 0;
int n_linhas, m_colunas;
char palavra[PMAX], caca[LMAX][CMAX], final_caca[LMAX][CMAX];
/* Obtem as informacoes e a propria matriz do caca palavras e a palavra a ser procurada */
scanf ("%d %d %s", &n_linhas, &m_colunas, palavra);
/* Escreve "." em todas posicoes uteis da matriz de saida */
for (i = 0; i < n_linhas; i++){
scanf ("%s", caca[i]);
for (j = 0; j < m_colunas; j++)
final_caca[i][j] = '.';
}
/* Verifica se cada caracter da matriz corresponde ao primeiro da palavra, se sim, invoca
* a funcao que verifica a correspondencia completa da palavra */
for (i = 0; i < n_linhas; i++)
for (j = 0; j < m_colunas; j++)
if ((caca[i][j] == palavra[0]) || (caca[i][j] == '_') ||
((caca[i][j] == '#') && (testa_vogal(palavra[0]))) ||
((caca[i][j] == '%') && !(testa_vogal(palavra[0]))))
ocorrencias += verifica (i, j, palavra, caca, final_caca);
/* Imprime a palavra procurada, a quantidade de ocorrencias e a matriz final com as ocorrencias */
printf ("%s %d\n", palavra, ocorrencias);
for (i = 0; i < n_linhas; i++, printf("\n"))
for (j = 0; j < m_colunas; j++)
printf ("%c", final_caca[i][j]);
return 0;
}
//Palíndromo
int verifica( char str[], int len){
if (len <= 1 ) return 1;
else {
if (str[0] != str[len-1] )return 0;
return verifica(str + 1, len - 2 );
}
}
void main(){
for(int i = 1000; i <= 9999; i++){
if(verifica(i)){
printf("%d\n", i);
}
}
}
void retira(Fila *p)
{
if (p->fim > -1 && p->inicio < p->fim)
{
p->fila[p->inicio] = 0;
p->inicio++;
return;
}
verifica(p);
return;
}
void insere(Fila *p, int v)
{
if (p->fim >= TAMANHO - 1)
{
verifica(p);
return;
}
p->fim++;
p->fila[p->fim] = v;
return;
}
int main()
{
int n1,n2,n3;
scanf("%d%d%d",&n1,&n2,&n3);
while(n1 != 0)
{
verifica(n1,n2,n3);
scanf("%d%d%d",&n1,&n2,&n3);
}
return 0;
}
int main(void) {
char pal[100];
gets(pal);
int tam = strlen(pal);
printf("%d", verifica(pal, tam));
return EXIT_SUCCESS;
}
int busca_binaria(int inf, int sup)
{
int aux = verifica((inf+sup)/2);
//printf("%d %d\n", inf, sup );
if(inf >= sup)
return sup;
if(!aux)
return busca_binaria((inf+sup)/2+1, sup);
else if(aux)
return busca_binaria(inf, (sup+inf)/2);
}
int main()
{
char string1[tam], string2[tam];
printf("string1: ");
gets(string1);
printf("string2: ");
gets(string2);
verifica(string1, string2);
recebe();
system("pause");
return 0;
}
void imprime_fila(Fila *p)
{
if(p->fim > -1 && p->inicio == p->fim)
{
verifica(p);
return;
}
printf("Conteudo da fila\n");
for (int i = p->inicio; i <= p->fim; i++)
printf("posicao %d valor %d \n", i, p->fila[i]);
return;
}
int main()
{
int T;
scanf("%d ", &T);
for (int caso = 1; caso <= T; caso++)
{
bool tem_ponto = false;
printf("Case #%d: ", caso);
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
scanf("%c", &tab[i][j]);
if (tab[i][j] == '.')
tem_ponto = true;
}
getchar(); // \n
}
/* DEBUG
putchar('\n');
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
printf("%c ", tab[i][j]);
putchar('\n');
}
*/
switch (verifica())
{
case 'X':
printf("X won\n"); break;
case 'O':
printf("O won\n"); break;
case 'Z':
if (tem_ponto)
printf("Game has not completed\n");
else
printf("Draw\n");
}
getchar(); // \n
}
return 0;
}
int main(int argc, char *argv[]){
// Inicializa matriz e a posição central do cursor
textbackground(CORFUNDO);
inicializaMatriz(m);
posLin = (int)TAM_MATRIZ/2;
posCol = (int)TAM_MATRIZ/2;
int tecla;
// Inicia a lógica do jogo
while(1){
imprimeMatriz(m);
destaca(posLin,posCol);
imprimeStatus();
if(pontuacao == 1)
imprimeFimdejogo;
if(fimDeJogo)
imprimeFimdejogo();
tecla = getch();
if(tecla == DIRECIONAL){
switch(getch()){
case CIMA: moveCursor(CIMA); break;
case DIREITA: moveCursor(DIREITA); break;
case BAIXO: moveCursor(BAIXO); break;
case ESQUERDA: moveCursor(ESQUERDA); break;
}
}
else {
switch(tecla){
case ENTER: verifica(); break;
case ESPACO: sugestao(); break;
case ESC: return;
}
}
gotoxy(TAM_MATRIZ*2+1,TAM_MATRIZ);
}
return 0;
}
main(){
char palavra[TAM];
FILE *fp;
fp = fopen("texto.txt", "r");
while(!feof(fp)){
fscanf(fp,"%s", palavra);
if(strcmpi(palavra, "") != 0)
verifica(palavra);
strcpy(palavra,"");//Pra nao correr o risco de inserir lixo de memoria..
} // ..a variavel palavra é "zerada"
em_ordem(raiz);
getch();
}
int influencias (int **matriz, int linha, int num_parlamentares,int size, int
*temp) {
int i, aux = 1, tem;
for (i = 0; i < num_parlamentares; i++)
if (matriz[linha - 1][i] == 1) {
tem = verifica(temp, size + 1, i + 1);
if (tem == 0) {
temp[++size] = i + 1;
aux++;
}
}
return aux;
}
int main()
{
int numero;
int resultado;
printf("\nDigite um numero: ");
scanf("%d", &numero);
resultado = verifica(numero);
if(resultado == 1){
printf("\nO numero que você digitou é par!\n");
} else {
printf("\nO numero que você digitou é impar!\n");
}
return 0;
}
//L� AS COORDENADAS E VERIFICA SE � VALIDO
int leitura (void)
{
scan = verifica();
//PAR�METROS PARA SER V�LIDO
if(scan!=3 || x<=0 || y<=0)
{
msg(1);
}
else
{
mover(x, y, sentido);
}
return 0;
}
// menu
void menu ()
{
int opcao = 0;
system("cls");
printf("|------------------------MENU------------------------|\n");
printf("| 1 - CADASTRO DE BARCOS |\n");
printf("| 2 - CADASTRO DE REGATAS |\n");
printf("| 3 - CADASTRO DE PARTICIPACAO DE REGATAS |\n");
printf("| 4 - RELACAO DE REGATAS REALIZADAS |\n");
printf("| 5 - RELACAO DE PARTICIPACAO EM REGATAS |\n");
printf("|----------------------------------------------------|\n");
printf("|DIGITE A OPCAO DESEJADA.: |\n");
printf("|----------------------------------------------------|\n");
gotoxy(strlen("DIGITE A OPCAO DESEJADA.:")+3,8);
scanf("%d",&opcao);
verifica(opcao);
}
void FiatShamir::on_ejecutar_clicked() //proceso de autentificacion
{
int acepta;
QMessageBox msgBox;
if(ui->xw->isEnabled() == 0) { //si se han metido datos en la entrada de datos se ejecuta el proceso
v=(s.toInt()*s.toInt())%n; //v es la clave publica de A que guarda en entidad de confianza T
ui->nw->setText(QString::number(n)); //llenamos las cajas de la ventana
ui->vw->setText(QString::number(v));
for(int i=0;i<iteracion.toInt();i++){ //calculamos las distintas iteraciones
a=(arrayx[i]*arrayx[i])%n;
if(arraye[i]==0){ //si e es igual a cero
y=arrayx[i]%n; //y=x(mod n) //lo que A envia a B como respuesta a B
}
else if(arraye[i]==1){ //si e es igual a uno
y=(arrayx[i]*s.toInt())%n; //y=xs(mod n) //lo que A envia a B como respuesta a B
}
//EN B COMPROBAR SI ACEPTA O DENIEGA LA INDENTIFICACION
acepta=verifica(arraye[i]);
if(acepta==1){
resultado.append("ACEPTADA: ");
}
else{
resultado.append("DENEGADA: ");
}
resultado.append(QString::number(i+1)+"ª iteracion: "+" a= "+QString::number(a)+" Comprobar "+QString::number(y)+"^2= ");
if(arraye[i] == 0) {
resultado.append(QString::number(int(a))+"(mod"+QString::number(n)+")\n");
}
else if(arraye[i] == 1) {
resultado.append(QString::number(int(a))+"*"+QString::number(int(v))+"(mod"+QString::number(n)+")\n");
}
ui->resultadosw->setText(resultado);
ui->resultadosw->show();
}
}
else {
msgBox.information(this,"ERROR","Recuerde, debe completar la entrada de datos antes de ejecutar.");
msgBox.exec();
}
}
void autentication_server(int fd){
int nread;
char username[SHORT_STRING];
char password[SHORT_STRING];
nread = read(fd, username, SHORT_STRING-1);
fflush(stdout);
username[nread]='\0';
nread = read(fd, password, SHORT_STRING-1);
fflush(stdout);
password[nread]='\0';
if(verifica(username, password)==1){
write(fd, "1", strlen("1") + 1);
fflush(stdin);
process_client(fd);
}
else{
write(fd, "0", strlen("0") + 1);
fflush(stdin);
}
}
void combinacoes(int **matriz, int *custos, int num_parlamentares, int
tam_partido, int temp[], int next, int size, int
*preco_total) {
int i;
int tem, influenciados;
if (size >= tam_partido) {
*preco_total = 0;
for (i = 0; i < tam_partido; i++)
printf("%d ", temp[i]);
printf("preco total = %d\n", *preco_total);
}
for (i = next; i <= num_parlamentares; i++) {
/* Verifica se o parlamentar ja esta no partido */
tem = verifica (temp, size, i);
/* Caso o parlamentar ainda nao esteja no partido ... */
if (tem == 0) {
/* ... insere ele no vetor */
temp[size] = i;
/* Veririca quantos e quais parlamentares ele influencia */
influenciados = influencias(matriz, i, num_parlamentares, size,
temp);
if (size + influenciados <= tam_partido)
combinacoes(matriz, custos, num_parlamentares, tam_partido,
temp, i + 1, size + influenciados, preco_total);
}
/* Caso o parlamentar a ja estivesse no partido */
else {
combinacoes(matriz, custos, num_parlamentares, tam_partido, temp,
i + 1, size, preco_total);
}
}
}
int main()
{
int sudoku[9][9], //matriz que recebe os numeros do sudoku
i, //contador
j, //contador
teste = 0; //flag
/* chamada da funcao que le a matriz do jogo*/
le(sudoku);
/* chamada da funcao que procura os espacos em branco na matriz */
verifica(sudoku);
/* loop que verifica se o sudoku tem solucao */
for(i = 0; i < 9; i++)
{
for(j = 0; j < 9; j++)
{
if(sudoku[i][j] == 0)
{
teste = 1;
}
}
}
//if(teste == 0)
//{
imprime(sudoku);
//}
//else
//{
// printf("nao tem solucao\n");
//}
system("pause");
return 0;
}
int main() {
int num,fn,interv,aux,cont = 0;
long int i,f;
scanf("%ld %ld",&i,&f);
interv = f - i;
fn = i;
while(interv >= 0) {
aux = fn;
/* printf("\n Fazedno %d\n ",fn); */
while(aux != 1) {
aux = verifica(aux);
/*printf("%d\n", aux); */
cont ++;
}
printf("%d \n",cont);
fn++;
interv --;
cont = 0;
}
return 0;
}
/* Funcao resolve verifica as possibilidades do numero passado da verifica,quando houver apenas uma possibilidade ele preenche
a posicao com o numero adequado*/
void resolve(int t[9][9], int i , int j)
{
int num[10],k ,l,m,cont=0;//vetor para verificacao dos numeros possiveis e contadores dos loops
/*loop que zera o vetor antes de comecar a verificar*/
for(k = 1; k <= 9; k++)
{
num[k] = 0;
}
/*percorre a linha e a coluna da posicao e se o numero for diferente de 0 ele preenche o vetor do numero com o mesmo*/
for(l = 0; l < 9; l++)
{
/*preenche o vetor que nao eh zero*/
if(t[i][l] != 0)
{
num[t[i][l]] = t[i][l];
}
if(t[l][j] != 0)
{
num[t[l][j]] = t[l][j];
}
}
/*percorre a coluna 3 por 3 da posicao preenchendo o vetor com os numeros diferentes de 0*/
for(l =(3*(i/3)); l <= (2+(3*(i/3))); l++)
{
for(m = (3*(j/3)); m <= (2+(3*(j/3))); m++)
{
if(t[l][m] != 0)
{
num[t[l][m]] = t[l][m];
}
}
}
/*loop que verifica quantas posicoes do vetor nao foi preenchida*/
for(l = 1;l <= 9; l++)
{
/*significa que o vetor da posicao ele nao foi encontrado nas buscas e este eh uma possibilidade*/
if (num[l] == 0)
{
cont++;
}
}
/*se o cont for 1 , significa que para aquela posicao ha apenas uma possibilidade de numero e este sera preenchido*/
if(cont == 1)
{
for(l = 1; l <= 9; l++)
{
if (num[l] == 0)
{
t[i][j]=l;
}
}
/*se o contador for 1 , significa que a posicao da matriz principal foi preenchida entao ele volta a funcao verifica do comeco ,
pois se este nao for preenchido ele passara para o proximo numero do loop do verifica e continuara para frente, quando preenche um ,
este volta a verificar desde o comeco pois numeros ja verificados talvez possam agora ser preenchidos*/
verifica(t);
}
}
void ordenarCurso(char *nomefichI,char *nomefichF,char *cso, int n)
{
alunos *aux;
FILE *fich1,*fich2;
int i=0,j=0,k,neg=0,soma=0;;
char str[200];
char nu1[4],nu2[4];
infor texto;
if(!verifica(nomefichF))
strcat(nomefichF,".xml");
fich1=fopen(nomefichI,"r");
fich2=fopen(nomefichF,"w");
if(fich1==NULL)
{
printf("O ficheiro não existe ou esta danificado");
return;
}
while(!feof(fich1))
{
j=texto.maior=0;texto.menor=20;
fgets(str,200,fich1);
if(str[0]!='')
{
while(str[i]!=';')
{
texto.curso[j]=str[i];
i++;
j++;
}
texto.curso[j]='\0';
j=0;i++;
while(str[i]!=';')
{
nu1[j]=str[i];
i++;
j++;
}
nu1[j]='\0';
texto.num=atoi(nu1);
j=0;i++;
while(str[i]!=';')
{
texto.datanasc[j]=str[i];
i++;
j++;
}
texto.datanasc[j]='\0';
j=0;i++;
while(str[i]!=';')
{
texto.nome[j]=str[i];
i++;
j++;
}
texto.nome[j]='\0';
j=0;i++;
while(str[i]!=';')
{
nu2[j]=str[i];
i++;
j++;
}
nu2[j]='\0';
texto.notas[0]=atoi(nu2);
for(k=1;k<=texto.notas[0];k++)
{
j=0;i++;
while(str[i]!=';')
{
nu2[j]=str[i];
i++;
j++;
}
nu2[j]='\0';
texto.notas[k]=atoi(nu2);
soma=soma+texto.notas[k];
if(texto.maior<texto.notas[k])
texto.maior=texto.notas[k];
if(texto.menor>texto.notas[k])
texto.menor=texto.notas[k];
if(texto.notas[k]<10)
neg++;
}
texto.media=soma/texto.notas[0];
if(neg>2)
strcpy(texto.estado,"reprovado");
else
strcpy(texto.estado,"aprovado");
if (n<3)
colocarlista(texto);
else
colocarlistaordenada(texto);
i=soma=neg=0;
}}
if(n==1)
criafichcurso(nomefichF,cso);
if(n==2)
criafichaluno(nomefichF,atoi(cso));
if(n==3)
criafichtotal(nomefichF);
}
int main(){
FILE *fp;
Cidade *listaCidades = criaListaCidade();
Gerador *listaGeradores = criaListaGerador();
Interconexao *listaInterconexoes = criaListaInterconexao();
Adaptador *listaAdaptadores = criaListaAdaptador();
Relatorio relatorio;
int i, tempoSimulacao = 2;
char arquivo[100];
char str[100]; //!< String auxiliar para obter registros
printf("Rede de distribuicao\n");
do{
//! AE: o nome do arquivo nao eh valido
printf("Digite o caminho para o arquivo (a partir de ./app/src):\n");
scanf("%s",arquivo);
getchar();
fp = fopen(arquivo,"r");//!< Abre arquivo de entrada
} while(fp == NULL);
//! AE: o nome do arquivo eh valido
printf("Digite o tempo desejado de simulacao\n");
scanf("%d",&tempoSimulacao);
do{
//! AE: o arquivo nao chegou ao fim
if(fgets(str,100,fp)!=NULL){
//! AE: a linha (registro) obtido do arquivo possui conteudo
switch (str[0]) {
case 'C':
//! AE: O registro obtido eh do tipo Cidade
listaCidades = insereCidade(str,listaCidades);
break;
case 'G':
//! AE: O registro obtido eh do tipo Gerador
listaGeradores = insereGerador(str,listaGeradores);
break;
case 'I':
//! AE: O registro obtido eh do tipo Interconexao
listaInterconexoes = insereInterconexao(str,listaInterconexoes);
break;
case 'A':
//! AE: O registro obtido eh do tipo Adaptador
listaAdaptadores = insereAdaptador(str,listaAdaptadores);
break;
default:
break;
}
}
//! AS: a linha (registro) obtido do arquivo nao possui conteudo, ou seja, o arquivo chegou ao fim
} while(!feof(fp));
//! AS: o arquivo chegou ao fim
fclose(fp);
//! Comentarios de argumentacao
/**
* Conectando e verificando as listas
**/
conecta(listaCidades,listaGeradores,listaInterconexoes,listaAdaptadores);
verifica(listaCidades,listaGeradores,listaInterconexoes,listaAdaptadores);
inicializa(listaGeradores,listaInterconexoes,listaAdaptadores,listaCidades);
//! Comentarios de argumentacao
/**
* Iniciando a interface
**/
mvprintw(0,0,"Pressione enter para comecar!");
getch();
mvprintw(0,0," ");
srand(1);
for(i=0;i<tempoSimulacao;i++){
// AE: tempo de simulacao nao chegou ao fim
start_color();
init_pair(1, COLOR_GREEN, COLOR_BLACK);
attron(COLOR_PAIR(1));
mvprintw(1,100,"%d segundos", i);
zerarCidades(listaCidades);
zerarAdaptadores(listaAdaptadores);
zerarInterconexoes(listaInterconexoes);
gerenciaFalhas(listaInterconexoes);
mandarRecursoProduzido(listaGeradores);
defineDistribuicao(listaAdaptadores);
mandarRecursoAdaptado(listaAdaptadores);
gerenciaRecursoRecebido(listaCidades);
atualizaCidades(listaCidades);
atualizaInterconexoes(listaInterconexoes);
atualizaGeradores(listaGeradores);
atualizaAdaptadores(listaAdaptadores);
getch();
}
// AS: tempo de simulacao chegou ao fim
mvprintw(0,0," ");
mvprintw(1,0," ");
mvprintw(0,0,"Pressione enter para finalizar!");
getch();
endwin();
//! Comentarios de argumentacao
/**
* Finalizando a interface
**/
//! Comentarios de argumentacao
/**
* Imprimindo as listas obtidas a partir do arquivo de entrada
**/
printf("\nLista de cidades:\n");imprimeListaCidade(listaCidades);
printf("\nLista de geradores:\n");imprimeListaGerador(listaGeradores);
printf("\nLista de interconexões:\n");imprimeListaInterconexao(listaInterconexoes);
printf("\nLista de adaptadores:\n");imprimeListaAdaptador(listaAdaptadores);
//! Comentarios de argumentacao
/**
* Preenchimento do relatorio
**/
fp = fopen("../../RELATORIO.txt","w");//!< Abre arquivo de entrada
fprintf(fp,"Relatório:\n\n");
printf("Relatório:\n\n");
relatorio.tempoTotalSimulacao = tempoSimulacao;
fprintf(fp,"Tempo total da simulação: %d segundos\n", relatorio.tempoTotalSimulacao);
printf("Tempo total da simulação: %d segundos\n", relatorio.tempoTotalSimulacao);
relatorio.custoTotalSimulacao = custoGeradores(listaGeradores)*tempoSimulacao + custoGastoComConserto(listaInterconexoes);
fprintf(fp,"Custo total na simulação: %d\n", relatorio.custoTotalSimulacao);
printf("Custo total na simulação: %d\n", relatorio.custoTotalSimulacao);
relatorio.totalGeradores = numeroGeradores(listaGeradores);
fprintf(fp,"Total de geradores: %d\n", relatorio.totalGeradores);
printf("Total de geradores: %d\n", relatorio.totalGeradores);
relatorio.energiaTotalGerada = recursoProduzidoTotal(listaGeradores) * tempoSimulacao;
fprintf(fp,"Energia total gerada: %d\n", relatorio.energiaTotalGerada);
printf("Energia total gerada: %d\n", relatorio.energiaTotalGerada);
relatorio.totalCidades = numeroCidades(listaCidades);
fprintf(fp,"Total de cidades: %d\n", relatorio.totalCidades);
printf("Total de cidades: %d\n", relatorio.totalCidades);
relatorio.energiaGastaCidades = recursoGastoTotal(listaCidades);
fprintf(fp,"Energia total gasta pelas cidades: %d\n", relatorio.energiaGastaCidades);
printf("Energia total gasta pelas cidades: %d\n", relatorio.energiaGastaCidades);
relatorio.tamanhoTotalInterconexoes = tamanhoTotalConexao(listaInterconexoes);
fprintf(fp,"Tamanho total das interconexões: %.2f\n", relatorio.tamanhoTotalInterconexoes);
printf("Tamanho total das interconexões: %.2f\n", relatorio.tamanhoTotalInterconexoes);
relatorio.numeroFalhaInterconexoes = numeroTotalFalhas(listaInterconexoes);
fprintf(fp,"Número de falhas nas interconexões: %d\n", relatorio.numeroFalhaInterconexoes);
printf("Número de falhas nas interconexões: %d\n", relatorio.numeroFalhaInterconexoes);
relatorio.numeroCidadesNegativadas = numeroCidadesNegativadas(listaCidades);
fprintf(fp,"Número de cidades que ficaram com menos recurso que o necessário: %d\n",relatorio.numeroCidadesNegativadas);
printf("Número de cidades que ficaram com menos recurso que o necessário: %d\n",relatorio.numeroCidadesNegativadas);
relatorio.tempoSemRecurso = tempoSemRecursoNecessario(listaCidades);
fprintf(fp,"Tempo que ficaram sem recurso: %d\n",relatorio.tempoSemRecurso);
printf("Tempo que ficaram sem recurso: %d\n",relatorio.tempoSemRecurso);
relatorio.numeroCidadesNoVermelho = numeroCidadesNoVermelho(listaCidades);
fprintf(fp,"Número de cidades que ficaram com menos de 30%% dos recursos: %d\n",relatorio.numeroCidadesNoVermelho);
printf("Número de cidades que ficaram com menos de 30%% dos recursos: %d\n",relatorio.numeroCidadesNoVermelho);
relatorio.tempoCidadesNoVermelho = tempoCidadesNoVermelho(listaCidades);
fprintf(fp,"Tempo que ficaram com menos de 30%% dos recurso: %d\n", relatorio.tempoCidadesNoVermelho);
printf("Tempo que ficaram com menos de 30%% dos recurso: %d\n", relatorio.tempoCidadesNoVermelho);
fclose(fp);
printf("\n\nRelatório gerado!\n\n");
//! Comentarios de argumentacao
/**
* Desalocando as listas obtidas
**/
liberaListaCidade(listaCidades);
liberaListaGerador(listaGeradores);
liberaListaInterconexao(listaInterconexoes);
liberaListaAdaptador(listaAdaptadores);
getchar();
return 0;
}
int main(void)
{
int u;
for(u=0;;u++)
{
int n, i, j, cont=0, k, x, maior=0;
scanf("%d", &n);
if(n==0)break;
int nentra[n+1], relatorio[n+1][n+2], estao[n+1], maiores[n+1], maiores2[n+1];
memset(nentra, 0, sizeof(nentra));
memset(estao, 0, sizeof(estao));
memset(maiores, 0, sizeof(maiores));
memset(maiores2, 0, sizeof(maiores2));
for(i=1;i<=n;i++)
{
for(j=1;;j++)
{
scanf("%d", &relatorio[i][j]);
if(relatorio[i][j]==0)break;
}
}
for(k=1;k<=n;k++)
{
for(x=k,i=1;i<=n;i++,x--)
{
if(x==0)x=n;
if(nentra[x]!=1 && verifica(relatorio[x], estao)!=1)
{
estao[x]=1;
cont++;
for(j=1;;j++)
{
if(relatorio[x][j]==0)break;
else nentra[(relatorio[x][j])]=1;
}
}
}
if(cont>maior)maior=cont;
cont=0;
memset(nentra, 0, sizeof(nentra));
memset(estao, 0, sizeof(estao));
for(x=k,i=1;i<=n;i++,x++)
{
if(x==(n+1))x=1;
if(nentra[x]!=1 && verifica(relatorio[x], estao)!=1)
{
estao[x]=1;
cont++;
for(j=1;;j++)
{
if(relatorio[x][j]==0)break;
else nentra[(relatorio[x][j])]=1;
}
}
}
if(cont>maior)maior=cont;
cont=0;
memset(nentra, 0, sizeof(nentra));
memset(estao, 0, sizeof(estao));
}
printf("Teste %d\n", u+1);
printf("%d\n", maior);
printf("\n");
}
return 0;
}
tabuleiro *aleatorio(tabuleiro *tab,int before){
int lin,col,i,l,com=0,barexist,barconess, posicoes;
int linhas[100],comb[100];
char tmp[100][100],local[100][100];
tabuleiro *f, *w, *z, *x;
for(lin=0;lin!=tab->tamanho[0];lin++){
barexist=0;
posicoes=0;
for(col=0;col!=tab->tamanho[1];col++){
if(caniboat(tab,lin,col)) posicoes++;
else if(tab->quadro[lin][col]!='~' && tab->quadro[lin][col]!='.') barexist++;
}
barconess=tab->linhas[lin]-barexist;
comb[lin]=combinacoes(posicoes,barconess);
}
for(i=0;i!=tab->tamanho[0];i++)
linhas[i]=i;
ordena(comb,linhas,0,tab->tamanho[0]);
for(i=0;comb[i]==0;i++);
l=linhas[i];
com=0;
for(lin=0;lin!=tab->tamanho[0];lin++)
for(col=0;col!=tab->tamanho[1];col++)
tmp[lin][col]=tab->quadro[lin][col];
do{
if(verifica(tab)==2) ;
else if(verifica(tab)==0){
for(lin=0;lin!=tab->tamanho[0];lin++)
for(col=0;col!=tab->tamanho[1];col++)
tab->quadro[lin][col]=tmp[lin][col];
++com;
if(com>=comb[i]) {com=0; l=linhas[++i];}
tab=aleoaux(tab,l,com);
}
else if(verifica(tab)==1){
++com;
if(com>=comb[i]) {com=0; l=linhas[++i];}
tab=aleoaux(tab,l,com);
}
do{
for(lin=0;lin!=tab->tamanho[0];lin++)
for(col=0;col!=tab->tamanho[1];col++)
local[lin][col]=tab->quadro[lin][col];
f=aloca(tab);
w=verigual(tab,estra1(f));
f=aloca(w);
z=verigual(w,estra2(f));
f=aloca(z);
x=verigual(z,estra3(f));
f=aloca(x);
tab=verigual(x,estra4(f));
}while(changes(local,tab) && verifica(tab)!=2);
if(verifica(tab)==0){
for(lin=0;lin!=tab->tamanho[0];lin++)
for(col=0;col!=tab->tamanho[1];col++)
tmp[lin][col]=tab->quadro[lin][col];
}
if(before==1){
for(lin=0;lin!=tab->tamanho[0];lin++)
for(col=0;col!=tab->tamanho[1];col++)
tmp[lin][col]=tab->quadro[lin][col];
return tab;
}
else if(verifica(tab)!=2 && i+1==tab->tamanho[0]) tab=aleatorio(tab,1);
if(dots(tab) || verifica(tab)!=2) {
for(lin=0;lin!=tab->tamanho[0];lin++)
for(col=0;col!=tab->tamanho[1];col++)
tmp[lin][col]=tab->quadro[lin][col];
return tab;
}
}while(verifica(tab)!=2);
return tab;
}
