将下列程序改成数组方式的，

// vs2005 Compile

#include "stdafx.h"


#include "iostream"
#include "vector"
#include "string"
#include "algorithm"
using namespace std;

struct node
{
node(string na) : name(na)
{
}

void join(node* oth, int distance)
{
if (find(conjoint_node.begin(), conjoint_node.end(), oth)
!= conjoint_node.end())
return;

conjoint_node.push_back(oth);
conjoint_dist.push_back(distance);
}

string name;
vector<node*> conjoint_node;
vector<int> conjoint_dist;
};

void _find_max_min_path(node* src, node* dst, vector<node*> curr_path, int curr_dist, vector<node*>* max_path, int* max_dist, vector<node*>* min_path, int* min_dist)
{
for (size_t i = 0; i < src->conjoint_node.size(); ++i)
{
node* pnode = src->conjoint_node[i];
int dist = src->conjoint_dist[i];

if (find(curr_path.begin(), curr_path.end(), pnode) != curr_path.end())
continue;

vector<node*> new_curr_path = curr_path;
int new_curr_dist = curr_dist;

new_curr_path.push_back(pnode);
new_curr_dist += dist;

if (pnode == dst)
{
if (new_curr_dist > *max_dist)
{
*max_path = new_curr_path;
*max_dist = new_curr_dist;
}

if (new_curr_dist < *min_dist)
{
*min_path = new_curr_path;
*min_dist = new_curr_dist;
}
}
else
{
_find_max_min_path(pnode, dst, new_curr_path, new_curr_dist, max_path, max_dist, min_path, min_dist);
}
}
}

void find_max_min_path(node* src, node* dst, vector<node*>* max_path, int* max_dist, vector<node*>* min_path, int* min_dist)
{
vector<node*> curr_path;
curr_path.push_back(src);

*max_dist = INT_MIN;
*min_dist = INT_MAX;

_find_max_min_path(src, dst, curr_path, 0, max_path, max_dist, min_path, min_dist);

}

int main()
{
vector<node*> nodes;

node a("a");
node b("b");
node c("c");
node d("d");
node e("e");

nodes.push_back(&a);
nodes.push_back(&b);
nodes.push_back(&c);
nodes.push_back(&d);
nodes.push_back(&e);

a.join(&b, 8);
a.join(&e, 4);

b.join(&a, 8);
b.join(&c, 5);
b.join(&d, 6);

c.join(&b, 5);
c.join(&d, 3);
c.join(&e, 2);

d.join(&b, 6);
d.join(&c, 3);
d.join(&e, 4);

e.join(&a, 4);
e.join(&c, 2);
e.join(&d, 4);

do
{
vector<node*> max_path;
int max_dist = 0;
vector<node*> min_path;
int min_dist = 0;

node* src = NULL;
node* dst = NULL;

string src_name;
string dst_name;

cout<<"tatal has node : "<<a.name<<", "<<b.name<<", "<<c.name<<", "<<d.name<<", "<<e.name<<endl;
cout<<"begin node : ";
cin>>src_name;
cout<<"end node : ";
cin>>dst_name;

for (size_t i = 0; i < nodes.size(); ++i)
{
if (nodes[i]->name == src_name)
src = nodes[i];

if (nodes[i]->name == dst_name)
dst = nodes[i];
}

if (!src || !dst)
{
cout<<"input error, again"<<endl;
continue;
}

find_max_min_path(src, dst, &max_path, &max_dist, &min_path, &min_dist);

cout<<"max path (distance is " <<max_dist<<") : ";
for (size_t i = 0; i < max_path.size(); ++i)
cout<<max_path[i]->name<<((i == max_path.size() - 1) ? "\n" : "->");

cout<<"min path (distance is " <<min_dist<<") : ";
for (size_t i = 0; i < min_path.size(); ++i)
cout<<min_path[i]->name<<((i == min_path.size() - 1) ? "\n" : "->");

string exit_flag;
cout<<endl<<"continue ? (y/n) : ";
cin>>exit_flag;

if (exit_flag == "y" || exit_flag == "Y")
continue;
else
break;

} while (true);

return 0;
}











测试结果

tatal has node : a, b, c, d, e
begin node : a
end node : b
max path (distance is 16) : a->e->d->c->b
min path (distance is 8) : a->b

continue ? (y/n) : y
tatal has node : a, b, c, d, e
begin node : a
end node : e
max path (distance is 20) : a->b->c->d->e
min path (distance is 4) : a->e

continue ? (y/n) : y
tatal has node : a, b, c, d, e
begin node : c
end node : d
max path (distance is 21) : c->b->a->e->d
min path (distance is 3) : c->d

continue ? (y/n) :