Ejemplo n.º 1
0
 /**
 * Return first path found from start vertex to end vertex
 * as a vector of edges, or NULL of no such path is found.
 */
 bool findDfsVertexPathMarking(vector<Vertex*> &path, Vertex *start, const Vertex *end)
 {
     mMarks.clear();
     path.clear();
     if (mEdges.find(start) != mEdges.end()) {
         mMarks.insert(start);
         path.push_back(start);
         return findDfsVertexPathMarkingRec(path, end);
     }
     return false;
 }
Ejemplo n.º 2
0
VertSet Vert::one_ring() {
    VertSet result = VertSet();

    Edge *e = edge;
    do {
        result.insert(e->pair->vert);
        e = e->pair->prev;
    } while(e != edge);

    return result;
}
Ejemplo n.º 3
0
 /**
 *  Add an edge if both vertices are non-NULL and distinct
 */
 bool addEdge(Vertex *vertA, Vertex *vertB) 
 {
     if (vertA == NULL || vertB == NULL || vertA == vertB)
         return false;                   // no side effects on failure
     addVertex(vertA);
     addVertex(vertB);
     if (mEdges.find(vertA) == mEdges.end()) {
         mEdges.insert(EdgeMap::value_type(vertA, new VertSet()));
     }
     VertSet *nexts = mEdges.at(vertA);
     return   nexts->insert(vertB).second;
 }
Ejemplo n.º 4
0
VertSet Vert::two_ring() {
    VertSet result = VertSet();

    VertSet first_ring = edge->vert->one_ring();

    for (VertSet_IT it = first_ring.begin(); it != first_ring.end(); it++) {
        VertSet temp_ring = (*it)->edge->vert->one_ring();
        for (VertSet_IT it = temp_ring.begin(); it != temp_ring.end(); it++) {
            result.insert(*it);
        }
    }

    return result;
}
Ejemplo n.º 5
0
    bool findDfsVertexPathRec(vector<Vertex*> &path, const Vertex *end) const
    {
        Vertex *lastVert = path.back();
        if (lastVert == end)
            return  true;

        if (mEdges.find(lastVert) != mEdges.end()) {
            VertSet *nexts = mEdges.at(lastVert);
            for (auto it = nexts->begin(); it != nexts->end(); ++it) {                
                path.push_back(*it);
                bool found = findDfsVertexPathRec(path, end);
                if ( found )
                    return found;
                else
                    path.pop_back();
            }
        }
        return false;
    }
Ejemplo n.º 6
0
void Network::Reset(int n,int s,int t)
{
    _V.resize(n);
    _E.clear();
    for (_s = 0;_s < n;_s++)
    {
        _V[_s].e = _V[_s].l = _V[_s].o = -1;
    }
    _s = s,_t = t;
}
Ejemplo n.º 7
0
void TimeSliceObservableCDT::process(const std::vector<Vertex*>& state) {
    // define a timelike direction that is the future
    Vertex* cur = state[0];
    Vertex* future = cur->getNeighbouringVertex();
    Triangle *f, *p;
    Vertex::getAdjacentTriangles(cur, future, &f, &p);
    if (!f->isTimelike(cur, future)) future = f->getThirdVertex(cur, future);

    for (unsigned int t = 0; t < T; t++) {
        unsigned int count = 0;

        // find spacelike loop at cur
        Vertex::getAdjacentTriangles(cur, future, &f, &p);
        VertSet n = cur->getSectorVertices(f, future, false);
        BOOST_ASSERT(n.size() == 1); // CDT constraint

        Vertex* prev = *n.begin();
        Vertex* lc = cur;
        do {
            VertSet sec = lc->getOtherSectorVertices(prev);
            BOOST_ASSERT(sec.size() == 1); // CDT constraint
            prev = lc;
            lc = *sec.begin();
            count++;
        } while (lc != cur);

        Vertex* newfut = *future->getOtherSectorVertices(cur).begin();
        cur = future;
        future = newfut;

        volumeProfile[t] = count;
    }
}
Ejemplo n.º 8
0
    bool DVGraph::findDfsVertexPathMarkingRec(vector<Vertex*> &path, const Vertex *end)
    {
        Vertex *lastVert = path.back();
        if (lastVert == end)
            return  true;

        if (mEdges.find(lastVert) != mEdges.end()) {
            VertSet *nexts = mEdges.at(lastVert);
            for (VertSet::iterator it = nexts->begin(); it != nexts->end(); ++it) {
                Vertex *vert = *it;
                if (mMarks.find(vert) == mMarks.end()) {
                    mMarks.insert(vert);
                    path.push_back(vert);
                    bool found = findDfsVertexPathMarkingRec(path, end);
                    if ( found )
                        return found;
                    else
                        path.pop_back();
                }
            }
        }
        return false;
    }
Ejemplo n.º 9
0
VertSet intersection(const VertSet &set1, const VertSet &set2) {
    VertSet result = VertSet();
    for (VertSet_const_IT it = set1.begin(); it != set1.end(); it++) {
        if (set2.find(*it) != set2.end()) {
            result.insert(*it);
        }
    }
    return result;
}
Ejemplo n.º 10
0
 bool addVertex(Vertex *vert) 
 {
     return mVerts.insert(vert).second;
 }
Ejemplo n.º 11
0
int Network::Dinic()
{
    int maxflow = 0;
    int u,v,e,ee,f;
    IntArray q;
    _E.resize(_E.size()+1);
    _E.back().v = _s;
    while (true)
    {
        for (u = 0;u < _V.size();u++)
            _V[u].l = -1;
        _V[_s].l = f = 0;
        _V[_s].o = _V[_s].e;
        q.clear();
        q.push_back(_s);
        while (f < (int)q.size())
        {
            u = q[f++];
            for (e = _V[u].e;e != -1;e = _E[e].n)
            {
                v = _E[e].v;
                if (_V[v].l == -1 && _E[e].c > 0)
                {
                    _V[v].o = _V[v].e;
                    _V[v].l = _V[u].l+1;
                    q.push_back(v);
                }
            }
        }
        if (_V[_t].l == -1) break;
        q.clear();
        q.push_back(_E.size()-1);
        while (!q.empty())
        {
            u = _E[q.back()].v;
            if (u == _t)
            {
                for (f = INT_MAX,e = 1;e < (int)q.size();e++)
                    if (_E[q[e]].c < f)
                        f = _E[q[e]].c,u = e;
                for (e = 1;e < q.size();e++)
                {
                    _E[q[e]].c -= f;
                    _E[q[e]^1].c += f;
                }
                maxflow += f;
                q.resize(u);
            }
            else
            {
                for (e = _V[u].o;e != -1;e = _E[e].n)
                {
                    if (_V[_E[e].v].l < 0 || _E[e].c < 1)
                        continue;
                    if (_V[_E[e].v].l == _V[u].l+1)
                        break;
                }
                if ((_V[u].o = e) != -1)
                    q.push_back(e);
                else
                {
                    q.pop_back();
                    _V[u].l = -1;
                }
            }
        }
    }
    return maxflow;
}