integration des arbres

Version imprimable

01/03/2013, 09h52
elmouvic

integration des arbres

bonjour tout le monde
voila j'ai une class "listposte" et je veux la créer sous forme d'un arbre.
remarque: cette class est une class des postes vide! pour faire une affectation des individus a ces postes
alors j'aimerai bien savoir comment le faire; et comment elle devient ma class ( je parle de la syntaxe ou l'integration d'une bibliothéque des arbre s'il existe.....)
cordialement
01/03/2013, 10h42
GeantVert13

Bonjour,

Tu as fait quelque chose déjà ? Si on part de rien, ça va être dur de t'aider...
01/03/2013, 10h50
PilloBuenaGente
Bonjour, si c'est pour un arbre tu peux stocker une liste de classe dans une autre :
Code:

1 2 3 4 5 6 7 8 9 10 11 class Employe { public: Employe(){} }; class Patron { public: Parton(){} private: Employe listeEmploye[ 10 ]; };
Je ne sais pas si c'est la meilleur solution cependant elle est simple à gérer.

Si tu parlais de les représenter, koala01 nous avait donné le lien de ce site :http://www.graphviz.org/Home.php
01/03/2013, 10h53
elmouvic

oui ce que j'ai fait.....

Citation:

Envoyé par GeantVert13

Bonjour,

Tu as fait quelque chose déjà ? Si on part de rien, ça va être dur de t'aider...

enfin j'ai un grand travail
j'ai commencé par faire des class "personne" et "poste" "listpersonne" et "listposte".
mon travail consiste a faire une affectation des individus a ces poste là!
j'ai modéliser mon probleme et je coince dans listpost qui est une class vide pour le moment et je dois la faire en tant qu'arbre ! car vous voyez l'hiérarchie des postes; chefs et les subordonnés... et j'espère que j'etais un peu clair
01/03/2013, 10h56
elmouvic

les postes
Citation:
Envoyé par PilloBuenaGente

Bonjour, si c'est pour un arbre tu peux stocker une liste de classe dans une autre :

Code:

1 2 3 4 5 6 7 8 9 10 11 class Employe { public: Employe(){} }; class Patron { public: Parton(){} private: Employe listeEmploye[ 10 ]; };

Je ne sais pas si c'est la meilleur solution cependant elle est simple à gérer.

Si tu parlais de les représenter, koala01 nous avait donné le lien de ce site :http://www.graphviz.org/Home.php
le problem n'est pas dans la class personne ! c'est dans la class "listpost" et ce sont les poste qui sont accessible et vide

"Employe listeEmploye[ 10 ];" Indique qu'il y aura 10 employés pour un patron, dans ces classes tu y rajoutera sans doûte un nom, qui poura être "vide" lorsque le poste sera à pourvoir.
Il est donc facile de retrouver dans un tableau les classes qui contiennent le nom "vide".
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 class Patron { public: Parton( std::string nom= "vide" ){} std::string VoirPatron() const { return nom; } void NouveauPatron(std::string nom) { this->nom = nom; } private: std::string nom; Employe listeEmploye[ 10 ]; } class listpost { public: listpost(); private: Patron patron; };

meercii

Citation:
Envoyé par PilloBuenaGente
"Employe listeEmploye[ 10 ];" Indique qu'il y aura 10 employés pour un patron, dans ces classes tu y rajoutera sans doûte un nom, qui poura être "vide" lorsque le poste sera à pourvoir.
Il est donc facile de retrouver dans un tableau les classes qui contiennent le nom "vide".
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 class Patron { public: Parton( std::string nom= "vide" ){} std::string VoirPatron() const { return nom; } void NouveauPatron(std::string nom) { this->nom = nom; } private: std::string nom; Employe listeEmploye[ 10 ]; } class listpost { public: listpost(); private: Patron patron; };
merciii bcp! je vais essayer avc ce que vous m'avez donné!

01/03/2013, 11h21
GeantVert13

Citation:

Envoyé par elmouvic

enfin j'ai un grand travail
j'ai commencé par faire des class "personne" et "poste" "listpersonne" et "listposte".
mon travail consiste a faire une affectation des individus a ces poste là!
j'ai modéliser mon probleme et je coince dans listpost qui est une class vide pour le moment et je dois la faire en tant qu'arbre ! car vous voyez l'hiérarchie des postes; chefs et les subordonnés... et j'espère que j'etais un peu clair

Donc si je comprends bien ta question, c'est comment implémenter un arbre en C++ ?

http://lmgtfy.com/?q=c%2B%2B+tree+implementation

Citation:
Envoyé par PilloBuenaGente
"Employe listeEmploye[ 10 ];" Indique qu'il y aura 10 employés pour un patron, dans ces classes tu y rajoutera sans doûte un nom, qui poura être "vide" lorsque le poste sera à pourvoir.
Il est donc facile de retrouver dans un tableau les classes qui contiennent le nom "vide".
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class Patron { public: Parton( std::string nom= "vide" ){} std::string VoirPatron() const { return nom; } void NouveauPatron(std::string nom) { this->nom = nom; } private: std::string nom; Employe listeEmploye[ 10 ]; } class listpost { public: listpost(); private: Patron patron; };
donc pour votre conseil: je rajoute la class patron a mes 4 classqui sont ( personne listpersonne et poste et listposte)?? et la class employe c la class personne je pense

01/03/2013, 13h05
PilloBuenaGente

Ops.. Si tu n'a que: "personne listpersonne et poste et listposte" il n'est pas question d'arbre, l'arbre aurait servit à gérer une hiérarchie par exemple, un simple std::map ou dans le genre pourrait suffire à mettre en relation les postes aux personnes !

Citation:

Envoyé par PilloBuenaGente

Ops.. Si tu n'a que: "personne listpersonne et poste et listposte" il n'est pas question d'arbre, l'arbre aurait servit à gérer une hiérarchie par exemple, un simple std::map ou dans le genre pourrait suffire à mettre en relation les postes aux personnes !

j'ai pas bien compris ce que vous m'avez dit!
au fete j'ai 4 class :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
class personne
public:
	  personne(){affecte=0;};
	  ~personne(){};
	  void afficherP();
      void intialiserP(int matPersonne,char *nom , int gra,int Comp);
	  int getmat();
	  int getetat();
	  void nonSatefe();
	  void ajouter_comp(poste *po,int niv_comp);
	  void affecte_pers(poste *po);
	  poste *poste_pers; //le poste
 private:
	 int matP;
     char *nomP;
     vector <competance> comp_pers;// Niveau de competance
	 int cod_gra; // code grade
	 int affecte;// 0 non Affecte 1 pour Affecte -1 Affecte non satesfe 
class poste
{
  public:
	  poste(){post_occupe=0;}; 
	  ~poste(){};
	 int get_numpost();
	 char get_postratt();
	 void set_num_post(int n);
  private:
	 int num_post;
     char desi_post;
     char post_ratt;
	 int capacite;
	 int post_occupe;
};
class listpersonne
{
  public:
	  listpersonne(){};
	  ~listpersonne();
	  int CalculerCCout();
	  void Ajouterpersonne(personne p,int position);
	  void Retirerpersonne(personne p);
      void affichel();
	  int nombrpersnonsatisfai();
	  personne *getpersonne(int i);
 private:
	 int num;
     int n;
	 vector <personne> personneaffecte;
};

et je veux une class listposte ??? voila ce que j'ai fait en résumé

01/03/2013, 14h13
ternel

Code:

class list_post {}

Prends le problème à l'endroit: quels services doit rendre cette classe?

parce que sinon, une simple std::list<poste> pourrait suffire
01/03/2013, 14h28
elmouvic

Citation:

Envoyé par leternel

Code:

class list_post {}

Prends le problème à l'endroit: quels services doit rendre cette classe?

parce que sinon, une simple std::list<poste> pourrait suffire

je vais vous repondre:
alors je suis dans un probleme d'affectation du personnel:
je veux attribuer des employé a des poste selon des competance et des preferences! alors j'avais vraiment un obstacle pour demarrer! alors j'ai pensé de faire ces classe ! car j'ai pensé qu'elles serai utile pour le reste du problem: puisque e vais implementer l'algorithme tabou dans mon pb d'affectation aprés !
alors si vous voyez une autre methode plus simple et plus utiles! ou bien une modelisation des class dont je l'utilise vraiment vous me le proposez ! merci

Ou alors c'est peut-être dût au fait que tu as trop de classes. (tes deux listes peuvent être gérées par la même classe, ce sera d'autant plus facile)
Code:

1 2 3 4 5 6 7 8 9 class RelationEmployePoste {//Une classe regroupant la liste de postes et la liste d'employés RelationEmployePoste() {} //La création, comparaison, destruction d'employé ou de poste... ce fera ici //Les fonctions viendrons sans doute plus logiquement private: std::vector <Personne> listeDePersonne; std::vector <Poste> listeDePoste; };
(Au fait, on ce tutoie ici !!) :D

Premièrement, corrigeons ton code:

Choisir une langue et bien la parler. Je propose le français.
Utiliser les concepts C++ à bon escient (enum, bool, std::string)
Ne pas suffixer les membres avec l'initiale de la classe, c'est de l'information inutile et parasite
utiliser un constructeur correct, et ne pas avoir de init()
séparer les descripteurs des éléments algorithmiques: une personne est affectée si elle est à une place
utiliser une classe pour représenter les données algorithmiques.
séparer les informations. le poste n'est pas une partie de la personne, par contre, il y a des paires {poste, personne}
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 //ai pas bien compris ce que vous m'avez dit! //au fete j'ai 4 class : enum grade_t {Agent, Chef, GrandChef, PDG}; class personne { private: const std::string m_nom; int m_matricule; map<competance, int> m_competences;// Niveau de competance grade_t m_grade; // code grade public: void personne(int mat, std::string const& nom , grade_t grade, std::map<competence, int> competences): m_matricule(mat), m_nom(nom), m_grade(grade), m_competences(competences){ } ~personne(){}; void afficher(std::ostream& flux); int matricule() const {return m_matricule;} int matricule() const {return m_matricule;} int matricule() const {return m_matricule;} }; class poste { private: const int m_numero; const std:string m_designation; const char m_post_ratt;//hein? const int m_capacite; std::vector<personne*> occupants public: poste(int numero, std::string const& m_designation, char post_ratt, int capacite): m_numero(numero), m_designation(designation), m_post_ratt(post_ratt), m_capacite(capacite){ occupants.reserve(capacity); } ~poste(){}; int numero() const {return m_numero;} char postratt() const {return m_post_ratt;}//hein? bool contient(const personne* p) const; //ajoute une personne à ce poste, si possible bool ajouter(const personne* p) { if (occupants.size() == m_capacite) return false; occupants.push_back(p); return true; } private://vraiment? //retire une personne de ce poste bool retirer(const personne* p); //en exercice public: //cherche le plus malheureux. const personne* malheureux() const; //calcul la somme des niveaux de bonheur des gens dans ce poste int bonheur() const; //calcul la somme des niveaux de bonheur des gens dans ce poste si p y était ajouté int bonheurAvec(const personne* p) const; //calcul la somme des niveaux de bonheur des gens dans ce poste si p en était enlevé int bonheurSans(const personne* p) const; bool transfererMalheureuxVers(poste& autre) { const personne* lui = malheureux(); if (autre.ajouter(lui)) return retirer(lui); return false; } };
il te faudra bien sur une fonction (libre) pour calculer le bonheur d'une personne en fonction de son poste.

Ceci étant fait, il te reste à créer deux ensembles de postes et de gens, et à travailler avec.
Pour cela tu auras besoin d'une fonction qui prennent l'ensemble des postes, et teste s'il contient une personne

PS: D'ailleurs, ce ne sont pas des postes, mais des bureaux

Citation:
Envoyé par leternel
Premièrement, corrigeons ton code:

Choisir une langue et bien la parler. Je propose le français.
Utiliser les concepts C++ à bon escient (enum, bool, std::string)
Ne pas suffixer les membres avec l'initiale de la classe, c'est de l'information inutile et parasite
utiliser un constructeur correct, et ne pas avoir de init()
séparer les descripteurs des éléments algorithmiques: une personne est affectée si elle est à une place
utiliser une classe pour représenter les données algorithmiques.
séparer les informations. le poste n'est pas une partie de la personne, par contre, il y a des paires {poste, personne}
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 //ai pas bien compris ce que vous m'avez dit! //au fete j'ai 4 class : enum grade_t {Agent, Chef, GrandChef, PDG}; class personne { private: const std::string m_nom; int m_matricule; map<competance, int> m_competences;// Niveau de competance grade_t m_grade; // code grade public: void personne(int mat, std::string const& nom , grade_t grade, std::map<competence, int> competences): m_matricule(mat), m_nom(nom), m_grade(grade), m_competences(competences){ } ~personne(){}; void afficher(std::ostream& flux); int matricule() const {return m_matricule;} int matricule() const {return m_matricule;} int matricule() const {return m_matricule;} }; class poste { private: const int m_numero; const std:string m_designation; const char m_post_ratt;//hein? const int m_capacite; std::vector<personne*> occupants public: poste(int numero, std::string const& m_designation, char post_ratt, int capacite): m_numero(numero), m_designation(designation), m_post_ratt(post_ratt), m_capacite(capacite){ occupants.reserve(capacity); } ~poste(){}; int numero() const {return m_numero;} char postratt() const {return m_post_ratt;}//hein? bool contient(const personne* p) const; //ajoute une personne à ce poste, si possible bool ajouter(const personne* p) { if (occupants.size() == m_capacite) return false; occupants.push_back(p); return true; } private://vraiment? //retire une personne de ce poste bool retirer(const personne* p); //en exercice public: //cherche le plus malheureux. const personne* malheureux() const; //calcul la somme des niveaux de bonheur des gens dans ce poste int bonheur() const; //calcul la somme des niveaux de bonheur des gens dans ce poste si p y était ajouté int bonheurAvec(const personne* p) const; //calcul la somme des niveaux de bonheur des gens dans ce poste si p en était enlevé int bonheurSans(const personne* p) const; bool transfererMalheureuxVers(poste& autre) { const personne* lui = malheureux(); if (autre.ajouter(lui)) return retirer(lui); return false; } };
il te faudra bien sur une fonction (libre) pour calculer le bonheur d'une personne en fonction de son poste.

Ceci étant fait, il te reste à créer deux ensembles de postes et de gens, et à travailler avec.
Pour cela tu auras besoin d'une fonction qui prennent l'ensemble des postes, et teste s'il contient une personne

PS: D'ailleurs, ce ne sont pas des postes, mais des bureaux
vous avez cité deux classe au lieu 4
merci ! mais a partir de la ligne 47 de votre code proposé! le private et le public qui suivent sont pour quelle classe!?
-mais comment l'initialisation d'un groupe d'employé se fait ?
j'ai une proposition pour ça: je fait un chargement d'un fichier XML qui contient les infos. mais comment ?
-la différence entre les 3 fonctions du bonheur?
-comment tester

03/03/2013, 10h30
ternel
les privacités sont utilisables plusieurs fois, si tu as plusieurs bloc logiques dans ta classe.

Ici, c'était le cas de poste.

L'idée derrière les trois fonctions de bonheurs sont pour les calculs dans un algorithme évolutionnaire.

L'objectif étant de minimiser une action, au sens du principe de moindre action et du formalisme lagrangien (ah, les maths…), il faut avoir pouvoir obtenir deux types d'informations: la quantité d'action avant changement, et celle après changement.
L'atome de changement étant le déplacement d'une personne.

Il suffit donc de représenter les choses suivantes:
- Une situation donnée
- Le calcul de l'action
- Le mécanisme de modification de la situation
J'ai choisi de répartir la situation en trois blocs: une classe décrivant une personne, une classe de "position" où placer les personnes, et une paire d'ensemble pour assembler une situation (dont la situation initiale).
D'ailleurs, je recommande de constituer un bureau spécial pour les gens non-affectés.

Pour l'action, il y a les différentes fonctions de bonheur.
Pour le mécanisme de modification, il y a poste::transfert.

Ne reste donc qu'a choisir et coder l'algorithme de minimisation: génétique? évolutionnaire? exploration systématique? arbre de décision?
Pour cela, regarde du coté de l'IA et de la prise de décision.