图求最短路径

class DeepTrace
{
public:
    void InitMap(const vector<vector<int> > vMap, const int &portNum)
    {
        m_map = vMap;
        m_portNum = portNum;
        m_traceTree.clear();
    }

    bool GetRule(const int &beginPos, const int &endPos, list<int> &rules)
    {
        if(beginPos <0 || beginPos >= m_portNum)
            return false;
        if(endPos <0 || endPos >= m_portNum)
            return false;

        m_traceTree.clear();
        vector<bool> hasWalk(m_portNum, false);
        queue<int> q; q.push(beginPos);
        m_traceTree.push_back(make_pair(beginPos, -1));
        int nPos = 0;
        while(!q.empty())
        {
            int nowPos = q.front(); q.pop();
            hasWalk[nowPos] = true;
            if(nowPos == endPos)
            {
                print_rule(nPos, rules);
                return true;
            }
            vector<int> tmp = m_map[nowPos];
            vector<int> :: const_iterator pos = tmp.begin();
            const int parent = nPos;//m_traceTree.size() - 1;
            for(;pos != tmp.end(); ++pos)
            {
                if(false == hasWalk[*pos])
                {
                    q.push(*pos);
                    m_traceTree.push_back(make_pair(*pos,parent));
                }
            }
            ++nPos;
        }
        return false;
    }
private://nPos是树的位置， 从树的某个节点开始，回溯到开始节点
    void print_rule(int nPos, list<int> &rules)
    {
        if(nPos < 0 || nPos >= m_traceTree.size())
            return;

        int index = 0;
        do
        {
            rules.push_front(m_traceTree[nPos].first);
            ++index;
            nPos = m_traceTree[nPos].second;
            //for(int i= 0; i < 11; i++)
                //cout<< m_traceTree[i].first << m_traceTree[i].second <<endl;
            //cout<< "npos " << nPos <<endl;;
        }while(index <= m_traceTree.size() && m_traceTree[nPos].second != -1);
        return;
    }
    vector<vector<int> > m_map;
    int m_portNum;
    vector<pair<int, int> > m_traceTree; //valie ,parentindex
};

int main()
{
    vector<int> tmp;
    vector<vector<int > > vMap;
    //0
    tmp.push_back(1);
    tmp.push_back(2);
    vMap.push_back(tmp);

    //1
    tmp.clear();
    tmp.push_back(3);
    tmp.push_back(5);
    vMap.push_back(tmp);


    //2
    tmp.clear();
    tmp.push_back(0);
    tmp.push_back(3);
    vMap.push_back(tmp);


    //3
    tmp.clear();
    tmp.push_back(1);
    tmp.push_back(2);
    tmp.push_back(4);
    tmp.push_back(6);
    vMap.push_back(tmp);


    //4
    tmp.clear();
    tmp.push_back(3);
    tmp.push_back(7);
    vMap.push_back(tmp);


    //5
    tmp.clear();
    tmp.push_back(1);
    tmp.push_back(6);
    vMap.push_back(tmp);


    //6
    tmp.clear();
    tmp.push_back(3);
    tmp.push_back(5);
    tmp.push_back(7);
    vMap.push_back(tmp);


    //7
    tmp.clear();
    tmp.push_back(4);
    tmp.push_back(6);
    vMap.push_back(tmp);

    DeepTrace obj;
    obj.InitMap(vMap, 8);

    list<int> listRules;
    bool findit = obj.GetRule(0, 7, listRules);
    list<int> ::const_iterator pos = listRules.begin();
    cout<< "----------" <<endl;
    for(; pos != listRules.end(); ++pos)
    {
        cout<< *pos << " " <<endl;
    }

图的数据结构组织形式：
vector < vector< int > >
0-》1，2
1-》3,5
2-》0,3
3-》1,2,4,6
4-》3,7
5-》1,6
6-》3,5,7
7-》4,6