C++ Graph::GetVertex方法代码示例

//==============================================================================
//
// main
//
//==============================================================================
int main(int argc, char **argv)
{
    int numDisks = GetNextInt();
    int numPegs = GetNextInt();
    std::vector<int> startState;
    std::vector<int> endState;

    for (int i = 0; i < numDisks; i++)
    {
        startState.push_back(GetNextInt()-1);
    }

    for (int i = 0; i < numDisks; i++)
    {
        endState.push_back(GetNextInt()-1);
    }

    Graph *graph = new Graph(numDisks, numPegs);

    int numMoves = graph->BuildAndExplore(startState, endState);
    std::cout << "num moves = " << numMoves << std::endl;

    Graph::Vertex *vtx = graph->GetVertex(endState);
    std::list<Graph::Vertex *> forwardList;
    for (int i = 0; i < numMoves; i++)
    {
        forwardList.push_front(vtx);
        vtx = vtx->predecessor;
    }

    std::cout << numMoves << std::endl;
    std::list<Graph::Vertex *>::iterator iter;
    for (iter = forwardList.begin(); iter != forwardList.end(); iter++)
    {
        PrintMove(*iter); 
    }

    delete graph;

    return 0;
}

void Viterbi(const Graph& graph, const SparseVector& weights, float bleuWeight, const ReferenceSet& references , size_t sentenceId, const std::vector<FeatureStatsType>& backgroundBleu,  HgHypothesis* bestHypo)
{
    BackPointer init(NULL,kMinScore);
    vector<BackPointer> backPointers(graph.VertexSize(),init);
    HgBleuScorer bleuScorer(references, graph, sentenceId, backgroundBleu);
    vector<FeatureStatsType> winnerStats(kBleuNgramOrder*2+1);
    for (size_t vi = 0; vi < graph.VertexSize(); ++vi) {
//    cerr << "vertex id " << vi <<  endl;
        FeatureStatsType winnerScore = kMinScore;
        const Vertex& vertex = graph.GetVertex(vi);
        const vector<const Edge*>& incoming = vertex.GetIncoming();
        if (!incoming.size()) {
            //UTIL_THROW(HypergraphException, "Vertex " << vi << " has no incoming edges");
            //If no incoming edges, vertex is a dead end
            backPointers[vi].first = NULL;
            backPointers[vi].second = kMinScore;
        } else {
            //cerr << "\nVertex: " << vi << endl;
            for (size_t ei = 0; ei < incoming.size(); ++ei) {
                //cerr << "edge id " << ei << endl;
                FeatureStatsType incomingScore = incoming[ei]->GetScore(weights);
                for (size_t i = 0; i < incoming[ei]->Children().size(); ++i) {
                    size_t childId = incoming[ei]->Children()[i];
                    //UTIL_THROW_IF(backPointers[childId].second == kMinScore,
                    //  HypergraphException, "Graph was not topologically sorted. curr=" << vi << " prev=" << childId);
                    incomingScore = max(incomingScore + backPointers[childId].second, kMinScore);
                }
                vector<FeatureStatsType> bleuStats(kBleuNgramOrder*2+1);
                // cerr << "Score: " << incomingScore << " Bleu: ";
                // if (incomingScore > nonbleuscore) {nonbleuscore = incomingScore; nonbleuid = ei;}
                FeatureStatsType totalScore = incomingScore;
                if (bleuWeight) {
                    FeatureStatsType bleuScore = bleuScorer.Score(*(incoming[ei]), vertex, bleuStats);
                    if (isnan(bleuScore)) {
                        cerr << "WARN: bleu score undefined" << endl;
                        cerr << "\tVertex id : " << vi << endl;
                        cerr << "\tBleu stats : ";
                        for (size_t i = 0; i < bleuStats.size(); ++i) {
                            cerr << bleuStats[i] << ",";
                        }
                        cerr << endl;
                        bleuScore = 0;
                    }
                    //UTIL_THROW_IF(isnan(bleuScore), util::Exception, "Bleu score undefined, smoothing problem?");
                    totalScore += bleuWeight * bleuScore;
                    //  cerr << bleuScore << " Total: " << incomingScore << endl << endl;
                    //cerr << "is " << incomingScore << " bs " << bleuScore << endl;
                }
                if (totalScore >= winnerScore) {
                    //We only store the feature score (not the bleu score) with the vertex,
                    //since the bleu score is always cumulative, ie from counts for the whole span.
                    winnerScore = totalScore;
                    backPointers[vi].first = incoming[ei];
                    backPointers[vi].second = incomingScore;
                    winnerStats = bleuStats;
                }
            }
            //update with winner
            //if (bleuWeight) {
            //TODO: Not sure if we need this when computing max-model solution
            if (backPointers[vi].first) {
                bleuScorer.UpdateState(*(backPointers[vi].first), vi, winnerStats);
            }

        }
//    cerr  << "backpointer[" << vi << "] = (" << backPointers[vi].first << "," << backPointers[vi].second << ")" << endl;
    }

    //expand back pointers
    GetBestHypothesis(graph.VertexSize()-1, graph, backPointers, bestHypo);

    //bleu stats and fv

    //Need the actual (clipped) stats
    //TODO: This repeats code in bleu scorer - factor out
    bestHypo->bleuStats.resize(kBleuNgramOrder*2+1);
    NgramCounter counts;
    list<WordVec> openNgrams;
    for (size_t i = 0; i < bestHypo->text.size(); ++i) {
        const Vocab::Entry* entry = bestHypo->text[i];
        if (graph.IsBoundary(entry)) continue;
        openNgrams.push_front(WordVec());
        for (list<WordVec>::iterator k = openNgrams.begin(); k != openNgrams.end();  ++k) {
            k->push_back(entry);
            ++counts[*k];
        }
        if (openNgrams.size() >=  kBleuNgramOrder) openNgrams.pop_back();
    }
    for (NgramCounter::const_iterator ngi = counts.begin(); ngi != counts.end(); ++ngi) {
        size_t order = ngi->first.size();
        size_t count = ngi->second;
        bestHypo->bleuStats[(order-1)*2 + 1] += count;
        bestHypo->bleuStats[(order-1) * 2] += min(count, references.NgramMatches(sentenceId,ngi->first,true));
    }
    bestHypo->bleuStats[kBleuNgramOrder*2] = references.Length(sentenceId);
}