Commit 18d85d4f authored by nogzer's avatar nogzer

Init

parents
# escape
Find the shortest path to escape in a map indicated in a formatted text file. Cities can have gas station and our vehicule has an autonomy depending on its constructor (cheap or super) and its type (car, pick-up, fourgon).
#ifndef DEF_GRAPHE
#define DEF_GRAPHE
#include "sommet.h"
struct Chemin {
std::string chemin;
int niveau;
int cout;
};
class Graphe{
public :
Graphe();
// Setters
void putSommet(Sommet* s);
// Getters
Sommet* getById(std::string id);
Sommet* minimum();
std::string afficher();
Chemin dijkstra(std::string idDepart, std::string idArrivee, int conso);
// Cleaners
void pop(Sommet* s);
void release();
void clear();
private :
std::vector<Sommet*> sommets;
};
#endif
#include <cstdio>
#include <fstream>
#include "graphe.h"
/*!
*
* \file main.cpp
* \brief Programme à exécuter
* \author Badr El Berdaï, Gergi Younis, Matthieu Nogatchewsky
* \version 1.0
* \date Dimanche 4 Mars 2018
*
*/
using namespace std;
/*!
* \fn vector<std::string> split(std::string str, char c)
* \brief Coupe une chaîne par un caractère
* \param str Chaîne à découper
* \param c Caractère qui sépare les morceaux
* \return Renvoie le tableau des morceaux de chaînes
*/
vector<string> split(string str,char c);
/*!
* \fn void creerGraphe()
* \brief Crée un graphe à partir d'un fichier texte
* Demande le chemin d'un fichier texte à l'utilisateur
*/
void creerGraphe();
/*!
* \fn void lireGraphe()
* \brief Affiche le graphe global dans la console
*/
void lireGraphe();
/*!
* \fn int plusCourtChemin()
* \brief Affiche le meilleur compromis pour le braquage
* \return 0 - Braquage impossible ; 1 - Compromis trouvé
*/
int plusCourtChemin();
/*!
* \enum Type
* \brief Associe le choix de l'utilisateur au type du véhicule choisi
*/
enum Type {
FOURGON, /*!< fourgon choisi */
PICK_UP, /*!< pick_up choisi */
VOITURE /*!< voiture choisie */
};
/*!
* \enum Champ
* \brief Associe le choix de l'utilisateur à la prochaine procédure à suivre
*/
enum Champ {
MISE_A_JOUR, /*!< Mise à jour de la carte */
PLUS_COURT_CHEMIN, /*!< Détermination du plus court chemin */
QUITTER /*!< Quitter le programme */
};
/*!
* \struct Conso
* \brief Différentes consommations pour chacun des types de véhicules
* et suivant les marques "Cheap" et "Super"
*/
struct Conso {
int cheap; /*!< Consommation pour la marque "Cheap" */
int super; /*!< Consommation pour la marque "Super" */
} fourgon = {8,6}, pick_up = {7,4}, voiture = {5,3};
/*!
* \var g
* \brief Graphe global du programme
*/
Graphe* g = new Graphe();
/*!
* \fn int main(void)
* \brief Entrée du programme
* \return 0 - Arrêt du programme
*/
int main(){
bool executer = true;
while(executer){
string champ;
// Affichage du menu
cout << "\n\n";
cout << "1 -> Mettre à jour la carte\n";
cout << "2 -> Déterminer le plus court chemin\n";
cout << "3 -> Quitter le programme" << endl;
cin >> champ;
switch((Champ) (atoi(champ.c_str())-1)){
case MISE_A_JOUR:
creerGraphe();
break;
case PLUS_COURT_CHEMIN :
plusCourtChemin();
break;
case QUITTER :
executer = false;
break;
default:
cout << "Votre choix est invalide." << endl;
break;
}
}
// Fin du programme
g->clear();
delete g;
return 0;
}
vector<string> split(string str,char c){
vector<string> tableau;
string tampon("");
char ctampon;
for(unsigned int i = 0; i < str.size(); i++){
ctampon = str.at(i);
if(ctampon == c){
tableau.push_back(tampon);
tampon.clear();
}else{
tampon = tampon + ctampon;
}
}
tableau.push_back(tampon);
return tableau;
}
void creerGraphe(){
g->clear();
Sommet* s1;
Sommet* s2;
string dir;
cout << "Donner le chemin vers le fichier contenant la carte :" << endl;
cin >> dir;
ifstream carte(dir.c_str());
int mode = 1;
if(carte){
string ligne;
vector<string> infos;
while(getline(carte,ligne)){
if(ligne==string("")){
mode = 2;
getline(carte,ligne);
}
infos = split(ligne,',');
switch(mode){
case 1:
g->putSommet(new Sommet((string("point") + infos[0])
,((infos[1] == string("1")) ? true : false))
);
break;
case 2:
s1 = g->getById("point"+infos[0]);
s2 = g->getById("point"+infos[1]);
s1->putVoisin(s2,infos[2]);
s2->putVoisin(s1,infos[2]);
break;
default :
break;
}
}
lireGraphe();
carte.close();
}else{
cout << "Erreur à l'ouverture de la carte" << endl;
}
}
void lireGraphe(){
cout << g->afficher() << endl;
}
int plusCourtChemin(){
Conso conso;
string id1(""), id2(""), type("");
cout << "Donner le numéro du sommet de départ : ";
cin >> id1;
cout << "Donner le numéro du sommet d'arrivée : ";
cin >> id2;
cout << "Choisissez le type de votre véhicule : \n";
cout << " 1 -> Fourgon \n 2 -> Pick-up \n 3 -> Voiture \n";
cin >> type;
switch((Champ) (atoi(type.c_str())-1)){
case FOURGON:
conso = fourgon;
break;
case PICK_UP:
conso = pick_up;
break;
case VOITURE:
conso = voiture;
break;
default:
cout << "Type de véhicule invalide" << endl;
return 0;
break;
}
string idDepart("point"+id1), idArrivee("point"+id2);
Chemin chemin = g->dijkstra(idDepart,idArrivee,conso.cheap);
if(chemin.cout == infini){
chemin = g->dijkstra(idDepart,idArrivee,conso.super);
if(chemin.cout == infini){
cout << "Braquage impossible !" << endl;
return 0;
}else{
cout << "Compagnie choisie : Super Car " << endl;
}
}else{
cout << "Compagnie choisie : Cheap Car " << endl;
}
cout << " Chemin : " << chemin.chemin << "\n";
cout << " Temps de parcourt : " << chemin.cout << "h\n";
cout << " Niveau d'essence final : " << chemin.niveau << endl;
return 1;
}
CXX = g++
CXXFLAGS = -Wall -Wextra
SRC = *.cpp
EXEC = braquage.exe
$(EXEC) : $(SRC)
$(CXX) $(CXXFLAGS) -o $@ $^
#include "sommet.h"
using namespace std;
/*!
*
* \file sommet.cpp
* \brief Implémentation de la classe Sommet
* \author Badr El Berdaï, Gergi Younis, Matthieu Nogatchewsky
* \version 1.0
* \date Dimanche 4 Mars 2018
*
*/
Sommet::Sommet(string identifiant, bool station){
this->identifiant = identifiant;
this->station = station;
this->voisins = vector<Arc<Sommet*> >();
this->niveau = 100;
this->cout = infini;
this->chemin = identifiant;
this->traite = false;
this->enTraitement = false;
}
// ******************** SETTERS *************************
void Sommet::putVoisin(Sommet* sommet, std::string duree){
if(sommet != NULL){
Arc<Sommet*> a = {sommet,duree};
this->voisins.push_back(a);
}
}
void Sommet::setChemin(string str){
this->chemin = str;
}
void Sommet::setNiveau(int niveau){
this->niveau = niveau;
}
void Sommet::setCout(double cout){
this->cout = cout;
}
void Sommet::setTraite(){
this->traite = true;
}
void Sommet::setEnTraitement(){
this->enTraitement = true;
}
// ********************** GETTERS **********************
string Sommet::getId(){
return this->identifiant;
}
bool Sommet::getStation(){
return this->station;
}
vector<Arc<Sommet*> > Sommet::getVoisins(){
return voisins;
}
int Sommet::getNiveau(){
return this->niveau;
}
double Sommet::getCout(){
return this->cout;
}
string Sommet::getChemin(){
return this->chemin;
}
bool Sommet::getTraite(){
return this->traite;
}
bool Sommet::getEnTraitement(){
return this->enTraitement;
}
string Sommet::afficher(){
string chaine("");
chaine = chaine + "{" + this->identifiant + ",{";
for(unsigned int i = 0 ; i < voisins.size() ; i++){
chaine = chaine + "(" + voisins.at(i).sommet->getId() + "," + voisins.at(i).duree + ")";
chaine = chaine + ",";
}
chaine = chaine.substr(0,chaine.size()-1) + "}}";
return chaine;
}
// ***************** CLEANERS ********************
void Sommet::release(){
this->niveau = 100;
this->cout = infini;
this->chemin = this->identifiant;
this->traite = false;
this->enTraitement = false;
}
#include "outils.hpp"
using namespace std;
/*!
*
* \file sommet.cpp
* \brief Implémentation de la classe Sommet
* \author Badr El Berdaï, Gergi Younis, Matthieu Nogatchewsky
* \version 1.0
* \date Dimanche 4 Mars 2018
*
*/
Sommet::Sommet(string identifiant, bool station){
this->identifiant = identifiant;
this->station = station;
this->voisins = vector<Arc<Sommet*> >();
this->niveau = 100;
this->cout = infini;
this->chemin = identifiant;
this->traite = false;
this->enTraitement = false;
this->index = 0;
}
// ******************** SETTERS *************************
void Sommet::putVoisin(Sommet* sommet, std::string duree){
if(sommet != NULL){
Arc<Sommet*> a = {sommet,duree};
this->voisins.push_back(a);
}
}
void Sommet::setChemin(string str){
this->chemin = str;
}
void Sommet::setNiveau(int niveau){
this->niveau = niveau;
}
void Sommet::setCout(double cout){
this->cout = cout;
}
void Sommet::setTraite(){
this->traite = true;
}
void Sommet::setEnTraitement(){
this->enTraitement = true;
}
void Sommet::setIndex(int i){
this->index = i;
}
// ********************** GETTERS **********************
string Sommet::getId(){
return this->identifiant;
}
bool Sommet::getStation(){
return this->station;
}
vector<Arc<Sommet*> > Sommet::getVoisins(){
return voisins;
}
int Sommet::getNiveau(){
return this->niveau;
}
double Sommet::getCout(){
return this->cout;
}
string Sommet::getChemin(){
return this->chemin;
}
bool Sommet::getTraite(){
return this->traite;
}
bool Sommet::getEnTraitement(){
return this->enTraitement;
}
int Sommet::getIndex(){
return this->index;
}
string Sommet::afficher(){
string chaine("");
chaine = chaine + "{" + this->identifiant + ",{";
for(unsigned int i = 0 ; i < voisins.size() ; i++){
chaine = chaine + "(" + voisins.at(i).sommet->getId() + "," + voisins.at(i).duree + ")";
chaine = chaine + ",";
}
chaine = chaine.substr(0,chaine.size()-1) + "}}";
return chaine;
}
// ***************** CLEANERS ********************
void Sommet::release(){
this->niveau = 100;
this->cout = infini;
this->chemin = this->identifiant;
this->traite = false;
this->enTraitement = false;
this->index = 0;
}
#ifndef DEF_SOMMET
#define DEF_SOMMET
#include <vector>
#include <limits>
#include <iostream>
#include <cstdlib>
#include <string>
#define infini 90000
template <typename T> struct Arc{
T sommet;
std::string duree;
};
class Sommet
{
public :
Sommet(std::string identifiant, bool station);
// Setters
void putVoisin(Sommet* sommet, std::string duree);
void setChemin(std::string str);
void setNiveau(int niveau);
void setCout(double cout);
void setTraite();
void setEnTraitement();
// Getters
std::string getId();
bool getStation();
std::vector<Arc<Sommet*> > getVoisins();
int getNiveau();
double getCout();
bool getTraite();
bool getEnTraitement();
std::string getChemin();
std::string afficher();
// Cleaners
void release();
private :
std::string identifiant;
bool station;
std::vector<Arc<Sommet*> > voisins;
int niveau;
double cout;
std::string chemin;
bool traite;
bool enTraitement;
};
#endif
#include "outils.hpp"
using namespace std;
/*!
*
* \file graphe.cpp
* \brief Implémentation de la classe Graphe
* \author Badr El Berdaï, Gergi Younis, Matthieu Nogatchewsky
* \version 1.0
* \date Dimanche 4 Mars 2018
*
*/
Graphe::Graphe(){
this->sommets = vector<Sommet*>();
}
/******* Setters **************/
void Graphe::putSommet(Sommet* s){
this->sommets.push_back(s);
}
/******* Getters **************/
Sommet* Graphe::getById(string id){
Sommet* tampon;
for(unsigned int i = 0 ; i < sommets.size() ; i++){
tampon = sommets.at(i);
if(tampon->getId() == id){
return tampon;
}
}
return NULL;
}
string Graphe::afficher(){
string chaine("");
for(unsigned int i = 0 ; i < sommets.size() ; i++){
chaine = chaine + sommets.at(i)->afficher();
chaine = chaine + "\n";
}
return chaine;
}
Chemin Graphe::dijkstra(Sommet* depart, Sommet* arrivee, int conso){
// Algorithme de Dijkstra
Sommet* e = depart;
e->setCout(0);
Tas* v = new Tas(e);
vector<Arc<Sommet*> > voisins = vector<Arc<Sommet*> >();
Arc<Sommet*> a; Sommet* voisin; int duree;
double niveauTemp, coutTemp;