{

using namespace boost;

using Graph = adjacency_list< vecS, vecS, undirectedS, no_property,

property< edge_weight_t, int, property< edge_weight2_t, int > > >;

constexpr int V = 10;

using Edge = std::pair< int, int >;

constexpr Edge edge_array[] = { Edge(0, 1), Edge(1, 2), Edge(2, 3),

Edge(1, 4), Edge(2, 5), Edge(3, 6), Edge(4, 5), Edge(5, 6), Edge(4, 7),

Edge(5, 8), Edge(6, 9), Edge(7, 8), Edge(8, 9) };

constexpr std::size_t E = sizeof(edge_array) / sizeof(Edge);

Graph g(edge_array, edge_array + E, V);

property_map< Graph, edge_weight_t >::type w = get(edge_weight, g);

constexpr int weights[] = { 99, 12, 12, 4, 99, 12, 4, 99, 2, 4, 2, 99, 12 };

const int* wp = weights;

graph_traits< Graph >::edge_iterator e, e_end;

for (boost::tie(e, e_end) = edges(g); e != e_end; ++e)

w[*e] = *wp++;

std::vector< int > d(V, (std::numeric_limits< int >::max)());

int D[V][V];

johnson_all_pairs_shortest_paths(g, D, distance_map(&d[0]));

constexpr int expected[V][V] = {

{ 0, 99, 111, 123, 103, 107, 125, 105, 111, 123 },

{ 99, 0, 12, 24, 4, 8, 26, 6, 12, 24 },

{ 111, 12, 0, 12, 16, 20, 24, 18, 24, 26 },

{ 123, 24, 12, 0, 28, 30, 12, 30, 26, 14 },

{ 103, 4, 16, 28, 0, 4, 22, 2, 8, 20 },

{ 107, 8, 20, 30, 4, 0, 18, 6, 4, 16 },

{ 125, 26, 24, 12, 22, 18, 0, 24, 14, 2 },

{ 105, 6, 18, 30, 2, 6, 24, 0, 10, 22 },

{ 111, 12, 24, 26, 8, 4, 14, 10, 0, 12 },

{ 123, 24, 26, 14, 20, 16, 2, 22, 12, 0 },

};

for (int i = 0; i < V; ++i)

for (int j = 0; j < V; ++j)

BOOST_TEST_EQ(D[i][j], expected[i][j]);

return boost::report_errors();