Aleatorização

class Random

Abaixo temos o arquivo random.hpp que contem a classe Random e herda da classe Scheduler:

#pragma once
#include "scheduler/scheduler.hpp"
class Random : public Scheduler
{
public:
void scheduleMovies();
void generateOutput();
};

Este arquivo conta com todas as funções-membro da super-classe Scheduler e também com as seguintes funções-membro:

  • void scheduleMovies(): função que gera a agenda de filmes com a heurística gulosa misturada com aleatorização.
  • void generateOutput(): função que gera o arquivo de saída com o resultado da heurística gulosa misturada com aleatorização.

A função void scheduleMovies() nesse caso é a função que gera a agenda de filmes com a heurística gulosa misturada com aleatorização.

Para implemantá-la, primeiramente foi criado um unoredered_set que irá conter os indices visitados durante o loop. Após isso iniciamos um while loop para incrementar um contador i, que vai de 0 até a quantidade de filmes que temos. A condição de quebra do loop é a agenda de filmes estar completa e o contador de filmes ultrapassar a quantidade maxima de filmes possiveis de serem vistos em um dia. Feitas as checagens sorteamos um número aleatório de 0 a 99, onde se o número gerado for menor do que 75, iremos aplicar a Heurística Greedy para escolher o filme. Caso contrário, iremos sortear um indíce aleatório dentre os possíveis para escolha de filme e entramos em um loop cuja condição de quebra é caso o índice sorteado já tenha sido visitado e se a agenda já estiver cheia. Caso isso não ocorra fazemos uma checagem se o filme correspondente ao índice gerado é válido ou não. Se o filme for válido, o adicionamos a nossa agenda e atualizamos o nosso unordered_set de indices visitados com o novo índice do filme adicionado, caso contrário, atualizamos o nosso unordered_set de indices visitados com o o que sorteamos e depois geramos um novo índice aleatório e repetimos o processo até que o filme seja válido e até que a agenda esteja cheia.

👀

Confira o código completo abaixo:

#include "random.hpp"
#include <cstdlib>
#include <ctime>
#include <algorithm>
#include <unordered_set>
#include <vector>
#include <iostream>
#include <chrono>
void Random::scheduleMovies()
{
std::srand(std::time(nullptr));
std::unordered_set<int> *visitedIndexes = new std::unordered_set<int>();
int *i = new int(-1);
int *choosenIndex = new int;
while (++*i < *this->movies && this->agendaBitset->count() < 24)
{
if (std::rand() % 100 < 75)
{
if (this->movieIsValid(this->moviesList[*i]) && visitedIndexes->count(*i) == 0)
{
this->addMovieToAgenda(this->moviesList[*i]);
visitedIndexes->insert(*i);
}
}
else
{
*choosenIndex = std::rand() % *this->movies;
do
{
if (this->movieIsValid(this->moviesList[*choosenIndex]))
{
this->addMovieToAgenda(this->moviesList[*choosenIndex]);
visitedIndexes->insert(*choosenIndex);
break;
}
*choosenIndex = std::rand() % *this->movies;
visitedIndexes->insert(*choosenIndex);
} while (visitedIndexes->count(*choosenIndex) == 0 && this->agendaBitset->count() > 0);
}
}
delete choosenIndex;
delete visitedIndexes;
delete i;
}
void Random::generateOutput()
{
this->readMoviesCatalog();
auto start = std::chrono::high_resolution_clock::now();
this->scheduleMovies();
auto finish = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> elapsed = finish - start;
std::cout << 1 << ' ' << *this->movies << ' ' << *this->categories << ' ' << *this->acceptedMoviesCount << ' ' << elapsed.count() << '\n';
}