C++ graph_t::size方法代码示例

dists_t dijkstra_shortest_path(graph_t g, vert_t s) {
    set<pair<dist_t, vert_t> > q; // implicit ordering by distance
    
    // ps_t ps(g.size(), -1);
    
    dists_t dists(g.size(), dist_infty);
    dists[s] = 0;
    
    q.insert(make_pair(dists[s], s));
    while( !q.empty() ) {
        dist_t dist = q.begin()->first;
        vert_t v = q.begin()->second;
        q.erase( q.begin() ); // pop first
        
        for(int i=0; i<g[v].size(); i++) {
            vert_t t = g[v][i].to;
            dist_t d_with = dist + g[v][i].len;
            
            if( d_with < dists[t] ) { // relax
                q.erase( make_pair(dists[t], t) );
                q.insert( make_pair(d_with, t) );
                dists[t] = d_with;
                // ps[t] = v;
            }
        }
    }
    
    return dists;
}

path_ps_t bfs( graph_t g, capmat_t caps, vert_t s, vert_t t ) {
    path_ps_t ps( g.size(), -1 ); // parents
    ps[s] = s;
    queue<vert_t> q;
    q.push(s);
    while( !q.empty() ) {
        vert_t u = q.front(); q.pop();
        if( u == t ) return ps;
        for( int i=0; i<g[u].size(); i++ ) {
            vert_t v = g[u][i];
            if( ps[v] < 0 && caps[u][v] > 0 ) {
                ps[v] = u;
                q.push(v);
            }
        }
    }
}

// solve minimun cost flow problem from s to t to flow f
double min_cost_flow(graph_t &graph, int s, int t, int f, bool display_progress)
{
    int V = graph.size(); // number of vertices
    vector<double> h(V, 0); // potential
    vector<double> dist(V, INF); // minimum distance from s
    vector<int> prevv(V, 0); // previous vertex
    vector<int> preve(V, 0); // previous edge

    double ret = 0;

    Progress progress(f, display_progress);
    while (f > 0)
    {
        if (Progress::check_abort())
            return RET_ABORTED;

        // Dijkstra algorithm
        priority_queue<Pair, vector<Pair>, greater<Pair> > que;
        fill(dist.begin(), dist.end(), INF);
        dist[s] = 0;
        que.push(Pair(0, s));
        while (!que.empty())
        {
            Pair p = que.top();
            int v = p.second;
            double d = p.first;
            que.pop();
            if (dist[v] < d)
                continue;
            for (int i = 0; i < (int)graph[v].size(); i++)
            {
                edge_t &e = graph[v][i];
                d = dist[v] + e.cost + h[v] - h[e.to];
                if (dist[v] > d) d = dist[v]; // for rounding error
                if (e.capacity > 0 && dist[e.to] > d)
                {
                    dist[e.to] = d;
                    prevv[e.to] = v;
                    preve[e.to] = i;
                    que.push(Pair(dist[e.to], e.to));
                }
            }
        }

        // no solution
        if (dist[t] == INF)
            return RET_NO_SOLUTION;

        // update potential
        for (int v = 0; v < V; v++)
            h[v] += dist[v];

        int d = f;
        for (int v = t; v != s; v = prevv[v])
            d = min(d, graph[prevv[v]][preve[v]].capacity);
        f -= d;
        progress.increment(d);

        ret += d * h[t];
        for (int v = t; v != s; v = prevv[v])
        {
            edge_t &e = graph[prevv[v]][preve[v]];
            e.capacity -= d;
            graph[v][e.rev].capacity += d;
        }
    }
    return ret;
}

int DFA::allocPoint()
{
    int newNode = m_graph.size();
    m_graph.emplace_back();
    return newNode;
}