TProcuraAdversa.h

Go to the documentation of this file.

#pragma once
#include "../Construtiva/TProcuraConstrutiva.h"
 
enum EParametrosAdversa {
    ORDENAR_SUCESSORES = PARAMETROS_CONSTRUTIVA, 
    PODA_HEURISTICA,      
    PODA_CEGA,           
    HEUR_BASE,           
    PARAMETROS_ADVERSA   
};
 
enum ETipoValor {
    EXATO,      
    LOWER_BOUND, 
    UPPER_BOUND  
};
 
typedef struct SValorEstado {
    int valor;
    int nivel; // 0 - valor heurístico, -1 - inválido
    ETipoValor tipo;
} TValorEstado;
 
typedef struct SResultadoJogo {
    int instancia = 0; // no caso no jogo ter instâncias
    int brancas = 0; // configuração a jogar de brancas
    int pretas = 0; // configuração a jogar de pretas
    int resultado = 0; // -1 derrota, 0 empate, 1 vitória
    int nJogadas = 0; // número de jogadas efetuadas
    double tempoBrancas = 0.0; // tempo total de jogo das brancas
    double tempoPretas = 0.0; // tempo total de jogo das pretas
    TString jogo = ""; // todos os lances do jogo
} TResultadoJogo;
 
 
class TProcuraAdversa :
    public TProcuraConstrutiva
{
public:
    TProcuraAdversa(void);
    ~TProcuraAdversa(void);
 
    bool minimizar;
    static int infinito;
    static bool completo;
    static int nivelOK;
    static int resultadoCompleto;
 
 
    void ResetParametros();
 
    // Retorna verdade caso o estado actual seja um estado objectivo, ou seja, jogo final (atualizar resultadoCompleto)
    bool SolucaoCompleta(void) = 0;
 
    int MiniMax(int nivel = 4);
 
    int MiniMaxAlfaBeta(int nivel = 4, int alfa = -infinito, int beta = +infinito);
 
    // Utilizar para executar testes empíricos
    // Utiliza as configurações existentes, ou parâmetros atuais
    // Efetua um torneio entre configurações
    void TesteEmpirico(TVector<int> instancias, TString ficheiro = "") override;
    void TesteEmpiricoGestor(TVector<int> instancias, TString ficheiro = "") override;
    void TesteEmpiricoTrabalhador(TVector<int> instancias, TString ficheiro = "") override;
 
    void TesteValidacao(TVector<int> instancias, TVector<int> impossiveis, TVector<int> referencias, TString fichSolucoes, TString fichResultados = "") override;
    bool Validar(TVector<TString> solucao) override;
    TString Jogar(TString jogo, int configID);
    void PontuacaoJogos(TVector<TString> &jogos);
    bool CoerenciaJogo(TVector<TString>& jogos, TVector<TString>& anterior);
    void JogoTerminado(TString &jogo);
 
    int ExecutaAlgoritmo();
 
    int Heuristica(void);
 
    // @brief chamar em CSubProblema::Heuristica() para verificar se a heurística já existe, ou precisa de ser calculada
    bool ExisteHeuritica(void);
 
    void Sucessores(TVector<TNo>& sucessores);
 
 
    int MaiorAmeaca(TVector<int>& qMin, TVector<int>& qMax, int maxAmeaca) const;
 
protected:
    int NoFolha(bool nivel);
 
    bool CorteAlfaBeta(int valor, int& alfa, int& beta);
 
    int MetodoIterativo(int alfaBeta);
 
    int Pontos(int resultado) { return resultado < 0 ? -1 : (resultado > 0 ? 1 : 0); }
 
    void ExecutaTarefa(TVector<TResultadoJogo>& resultados,
        int inst, int brancas, int pretas, TVector<TVector<int>>* torneio = NULL);
 
    bool RelatorioCSV(TVector<TResultadoJogo>& resultados, TString ficheiro);
 
    void OrdenarSucessores(TVector<TNo>& sucessores, TVector<int>& id, int nivel);
 
    // hashtable
    void SubstituirHT(int indice); // necessário redefinir para invalidar valorHT 
    bool ExisteHT(); // necessário redefinir par não remover estados (reutilizar o valor)
    static TValorEstado valorHT[TAMANHO_HASHTABLE]; // hashtable / valor e nível obtido
    // índice obtido na HT, se positivo
    int indiceHT;
    bool ValorEstado(TValorEstado& valor, int operacao);
    bool Utilizavel(TValorEstado& valor, int nivel, int alfa, int beta);
 
    static int reutilizadoAvaliacao; // número de vezes que uma avaliação é reutilizada
 
    void DebugChamada(bool noFolha, int alfa = 0, int beta = 0);
 
};