Bonjour,
je débute dans la librairie boost graph et j'ai besoin de maîtriser cette librairie pour un travail. J'ai déjà faits quelques codes pour utiliser les algorithmes de Dijkstra et de Belmman-Ford. Mais je vais avoir besoin d'utiliser les visitors et là je bloque.
J'ai regarder les tutos que j'ai trouvé sur le net ainsi que la doc de boostgraph mais tout ça ne me permet pas de m'en sortir.
Je vous appelle donc à l'aide!!

Comme je le dis en titre, je veux utiliser les visitor de bellman ford. J'ai déjà un code qui effectue Bellman ford. Je pensais l'adapter mais je n'y arrive pas du tout. Je bloque sur les structures spécifiques à créer.
Voici mon code de départ:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
using namespace boost;
 
 
struct EdgeProperties {
  int weight;
};
 
int main() {
 
  enum { A, B, C, D, E, F, G, H, I, J, N };
  char name[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J' };
  typedef std::pair < int, int >Ed;
  const int n_edges = 11;
  Ed edge_array[] = { Ed(A,B), Ed(A,C), Ed(A,E), Ed(B,F),
      Ed(C,G), Ed(C,H), Ed(D,H), Ed(E,J), Ed(F,I), Ed(H,J), Ed(I,J) };
  int weight[n_edges] = { 85, 217, 173, 80,  186, 103, 183, 502, 250, 167, 84};
 
  typedef adjacency_list < vecS, vecS, directedS, no_property, EdgeProperties> Graph;
 
 
  Graph g(edge_array, edge_array + n_edges, N);
 
  graph_traits < Graph >::edge_iterator ei, ei_end
 
  property_map<Graph, int EdgeProperties::*>::type weight_pmap;
  weight_pmap = get(&EdgeProperties::weight, g);		
 
  int i = 0;
  for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei, ++i)	
    weight_pmap[*ei] = weight[i];
 
  std::vector<int> distance(N, (std::numeric_limits < short >::max)());
  std::vector<std::size_t> parent(N);
 
  for (i = 0; i < N; ++i)	
    parent[i] = i;
  distance[A] = 0;
 
  bool r = bellman_ford_shortest_paths
    (g, int (N), weight_map(weight_pmap).distance_map(&distance[0]).
     predecessor_map(&parent[0]));
 
  if (r)
    for (i = 0; i < N; ++i){
      std::cout << "distance(" << name[i] << ") = " << distance[i] << ", ";
      std::cout << "parent(" << name[i] << ") = " << name[parent[i]] << std::endl;
    }
 
 
 
  return EXIT_SUCCESS;
}
J'ai vu sur la doc de boost graph qu'il fallait utiliser les fonctions de BinaryFunction::combine, BinaryPredicate::compare, BellmanFordVisitor::v. Mais, je ne vois pas comment m'en sortir.
N'hésitez pas à commenter tout ce que vous trouvez à redire, je suis là pour apprendre.
Je vous remercie et je vous attends pour un échange constructif.

J'ai remarqué un autre problème. Suivant dans quels sens j'enregistre mes arêtes et donc mes poids associés dans weight, le tour fournit comme résultat n'est plus le même. J'ai essayé avec l'algorithme de dijkstra fournit par boost graph et je n'ai eu aucun problème. Donc je reste assez perplexe... j'ai pensée à plusieurs choses mais rien de concret. J'aimerais aussi avoir un avis sur ce problème s'il vous plaît.
Merci d'avance.