Partially ordered sequence

// Topological sort:
// Given a set of edges and vertices
// in the form of "A<B", "B<C", "B<D" etc
// returns partially ordered sequence of vertices "A<B<C<D"
// C++11

#include <vector>
#include <queue>
#include <unordered_map>
#include <string>
#include <algorithm>
#include <functional>

using namespace std;

typedef pair<string, string> edge_t;

vector<string> GetSorted(const vector<edge_t> &edges)   // first string < second string
{
    unordered_multimap<string, string> G;
    unordered_map<string, int> VertexDegree;
    priority_queue<string, vector<string>, greater<string> > Q;

    vector<string> res;

    for (auto it = edges.begin(); it != edges.end(); ++it)
    {
        const string & vertex1 = it->first;
        const string & vertex2 = it->second;

        G.insert(edge_t(vertex1, vertex2));

        if (VertexDegree.find(vertex2) == VertexDegree.end())
        {
            VertexDegree[vertex2] = 0;
        }

        if (VertexDegree.find(vertex1) == VertexDegree.end())
        {
            VertexDegree[vertex1] = 0;
        }

        ++VertexDegree[vertex2];
    }

    for(auto it = VertexDegree.begin(); it != VertexDegree.end(); ++it)
    {
        if (VertexDegree[it->first] == 0)
            Q.push(it->first);
    }

    while (!Q.empty())
    {
        string min = Q.top();
        Q.pop();
        res.push_back(min);

        typedef unordered_multimap<string,string>::iterator map_pos_t;
        pair<map_pos_t, map_pos_t> range;

        range = G.equal_range(min);

        for (auto it = range.first; it != range.second; ++it)
        {
            const string & vertex = it->second;
            VertexDegree[vertex] = VertexDegree[vertex] - 1;
            if (VertexDegree[vertex] == 0)
            {
                Q.push(vertex);
            }
        }
    }

    return res;
}

int main()
{
    vector<edge_t> edges;
    edges.push_back(edge_t("a", "b"));
    edges.push_back(edge_t("a", "c"));
    edges.push_back(edge_t("b", "c"));
    edges.push_back(edge_t("d", "f"));
    edges.push_back(edge_t("a", "f"));

    vector<string> res = GetSorted(edges);
    return 0;
}