Implementation of Dijkstra's algorithm to find the shortest path in graph
This is a bad idea:
class Vertex
{
public:
    int m_id;
    &gt;&gt;&gt; unsigned int m_cost;
    &gt;&gt;&gt; bool m_isVisited;

You are conflating two things into a single class. The concept of a vertex and the concept of performing Dijkstra's algorithm on the node. You should separate the two issues into their own classes.
The main problem with this technique is that you need to reset the graph before use. ie. you can not run your algorithm twice in a row. You must reset the state of the whole graph before it can be re-used. Look up the visitor pattern.
You really want a constructor that does no initialization?
Vertex()
{           
}

The POD members will be left in an undefined state.
Your have void findMinDistance(std::vector&lt;Vertex&gt;&amp;); in the vertex? Find min distance to where?
Use the new C++ range based for:
for(std::map&lt;int,unsigned int&gt;::iterator iter = m_edgeList.begin();
    iter!=m_edgeList.end(); iter++)

// can be rewritten as:
for(auto&amp; edge: m_edgeList)

Overall I don't think you are actually implement Dijkstra's algorithm.
Dijkstra algorithm
The algorithm should look like this (this is pseudo code).
The classic part is the frontier list (I called it boundryList) and the set of vertex we have found the shortest route to.
 RouteCostObject findRout(Graph&amp; g, Vertex&amp; start, Vectex&amp; end)
 {
      OrderedListByDistance    boundryList;
      SetOfVertex              foundVertixes;

      boundryList.push_back([start, 0, []]);

      while(!boundryList.empty())
      {
          // Remove the top items from the list.
          (vertex, cost, route) = boundryList.top();       // Note: boundryList is sorted
          boundryList.pop();

          // If we have reached the end.
          // This is the shortest route.
          if (vertex == end)
          {    return [cost, route];
          }


          // Check if we have already found the shortest distance
          // to this vertex.
          if (foundVertixes.find(vertex) != vertex.end())
          {
              continue;
          }
          foundVertixes.insert(vertex);

          // Add all edges to the boundary list.
          for(auto&amp; edge: vertex.edges)
          {
              boundryList.push_back([edge.dst, cost + edge.cost, route + edge]);
          }
      }
      // No route from start to end
      return [infinity, []];
 }