Как напечатать вывод 8 после интернирования образца ввода?

Я знаю логику, стоящую за этим, но я не знаю, как применить это, чтобы закончить мой код для вывода 8.

Способ получить 8 — сложить кратчайшие пути к каждой вершине графа. Кратчайший путь — это путь с наименьшим количеством вершин. Если есть галстук, то вы используете вес пути в качестве прерывателя связи.

Может кто-нибудь помочь мне завершить мой код для вывода 8 после ввода образца ввода, как показано ниже?

Входные данные:

4 6

Женщины Консерваторы Неоконсерваторы Ветераны

Трамп Женщины 1

Трамп Консерваторы 1

Трамп Неоконс 5

Женщины неоконсерваторы 1

Неоконсерваторы Ветераны 5

Консерваторы Ветераны 1

Выход:

8

Найдите изображение ниже для графика
Вот мой код:

#include <iostream>
#include <vector>
#include <climits>
#include <cstdio>

using namespace std;

int min( int a,int b);
int getIndexOfVertex(string vertices[], int numberOfVertices,string name);
string extractMinVertex(bool visited[], string vertices[], int distanceFromStart[],int numberOfVertices);
void relaxEdges(string vertex, vector< vector<string> > &graph, vector< vector<int> > &weights, int distanceFromStart[], string vertices[], int);
void Dijkstra( int distanceFromStart[], string vertices[], vector< vector<string> > &graph, vector< vector<int> > &weights, int numberOfVertices );

bool pathExists( int u,int v, vector< vector<string> > &graph,int numberOfVertices,string vertices[]);
void dfs( int i, vector< vector<string> > &graph, bool visited[],int numberOfVertices,string vertices[] );

int main()
{
///freopen("input.txt","r",stdin);
/// to store the number of vertices and the number of edges
int numberOfVertices = 0;
int numberOfEdges = 0;

cin >> numberOfVertices;
cin >> numberOfEdges;

/// array to store the vertices. Number of vertices is 1 + numberOfVertices, since "Trump" is the first vertex
numberOfVertices++;
string vertices[ numberOfVertices];

/// first vertex is Trump. From him, speeches have to be communicated to all groups
vertices[0] = "Trump";

for( int i=1; i<numberOfVertices; i++)
{
string name;
cin >> name;

vertices[i] = name;
}

/// graph is an adjacency list here. This graph vector stores the edges
/// for each vertex, we store the list of vertices names, as a vector
vector< vector<string> > graph( numberOfVertices );

/// corresponding to the adjacency list, is this weight vector, that stores the weight of an edge
vector< vector<int> > weights( numberOfVertices );

for( int i=0; i<numberOfEdges; i++)
{
string u,v;
int weight;

cin >> v >> u >> weight;

int uIndex = getIndexOfVertex( vertices, numberOfVertices, u );
graph.at(uIndex).push_back( v );
weights.at(uIndex).push_back( weight );
}

/*for (int i=0; i<numberOfVertices; i++)
{
cout << "Vertex " << vertices[i] << " : ";
for( int j=0; j<graph[i].size(); j++)
cout << graph[i][j] << " , ";

cout << endl;
cout << "Vertex " << vertices[i] << " : ";
for( int j=0; j<weights[i].size(); j++)
cout << weights[i][j] << " , ";
cout << endl;
}*/

/// an array storing the distanc of vertices from the start
int distanceFromStart[ numberOfVertices ];
distanceFromStart[0] = 0;

for (int i=1; i<numberOfVertices; i++)
distanceFromStart[i] = INT_MAX;

Dijkstra( distanceFromStart, vertices, graph, weights, numberOfVertices);
int distance = 0;

for( int i=1; i<numberOfVertices; i++)
distance += distanceFromStart[i];

cout << distance << endl;
return 0;

}

/*bool pathExists( int u,int v, vector< vector<string> > &graph, int numberOfVertices, string vertices[])
{
bool visited[ numberOfVertices ];
for( int i=0; i<numberOfVertices; i++)
visited[i] = false;

dfs( u,graph,visited,numberOfVertices );

return visited[v];
}
void dfs( int i, vector< vector<string> > &graph, bool visited[],int numberOfVertices , string vertices[])
{
visited[i] = true;

for( int j=0; j<graph[i].size(); j++)
{
if( !visited[ getIndexOfVertex(vertices,numberOfVertices,graph[i][j]) ] )
dfs( getIndexOfVertex(vertices,numberOfVertices,graph[i][j]), graph, visited, numberOfVertices, vertices );
}
}
*/

void Dijkstra( int distanceFromStart[], string vertices[], vector< vector<string> > &graph, vector< vector<int> > &weights, int numberOfVertices )
{
bool visited[ numberOfVertices ];
for( int i=0; i<numberOfVertices; i++)
visited[i] = false;

string vertex = extractMinVertex(visited, vertices, distanceFromStart, numberOfVertices);

while( vertex.length() != 0  )
{
visited[ getIndexOfVertex( vertices, numberOfVertices, vertex ) ] = true;
relaxEdges( vertex, graph, weights, distanceFromStart, vertices, numberOfVertices);

vertex = extractMinVertex(visited, vertices, distanceFromStart, numberOfVertices);
}

}

void relaxEdges(string vertex, vector< vector<string> > &graph, vector< vector<int> > &weights, int distanceFromStart[], string vertices[], int numberOfVertices)
{
int uIndex = getIndexOfVertex( vertices, numberOfVertices, vertex );

for( int i=0; i<graph[uIndex].size(); i++ )
{
int vIndex = getIndexOfVertex(  vertices, numberOfVertices,graph[uIndex][i] );
distanceFromStart[ vIndex ] = min( distanceFromStart[vIndex], distanceFromStart[uIndex] + weights[ uIndex ][ i ]  );
}
}

string extractMinVertex(bool visited[], string vertices[], int distanceFromStart[],int numberOfVertices)
{
string ret = "";
for( int i=0; i<numberOfVertices; i++)
{
if( !visited[i] && ret.length() == 0)
ret = vertices[i];
else if( !visited[i] )
{
if( distanceFromStart[ getIndexOfVertex( vertices,numberOfVertices,ret) ] < distanceFromStart[ getIndexOfVertex( vertices,numberOfVertices,vertices[i] )] )
{
ret = vertices[i];
}
}
}
return ret;
}

int min( int a,int b)
{
if( a<b )
return a;
return b;
}

int getIndexOfVertex(string vertices[], int numberOfVertices,string name)
{
for( int i=0; i<numberOfVertices; i++)
{
if( vertices[i].compare(name) == 0 )
return i;
}
return -1;
}

КЛИКНИТЕ СЮДА