Найти порядок вершин конечного графа G

Я пытался реализовать этот алгоритм в C ++, но у него есть некоторые проблемы. Мне нужен совет, как заставить его работать быстрее и качественнее.

Алгоритм
Как Батагель & Заверсник (2003) описывают, что можно найти порядок вершин конечного графа G, который оптимизирует число раскраски порядка в линейное время, многократно удаляя вершину наименьшей степени.
Более подробно алгоритм работает следующим образом:

• Инициализируйте список вывода L.
• Вычислить число dv для каждой вершины v в G, количество соседей
  из V, которых еще нет в L. Изначально эти числа
  градусы вершин.
• Инициализируйте массив D так, чтобы D [i] содержал список
  вершины v, которых еще нет в L, для которых dv = i.
• Инициализируйте k до 0.

• Повторите n раз:

  1. Сканируйте ячейки массива D [0], D [1], …, пока не найдете i, для которого D [i] непусто.

  2.Установите k на максимум (k, i)

  3.Выберите вершину v из D [i]. Добавьте v в начало L и удалите его из D [i].

  4. Для каждого соседа w ​​из v вычтите единицу из dw и переместите w в ячейку D, соответствующую новому значению dw.

В конце алгоритма k содержит вырождение группы G, а L содержит список вершин в оптимальном порядке для числа раскраски. Я-ядра G — это префиксы L, состоящие из вершин, добавленных в L после того, как k сначала принимает значение, большее или равное i.
Инициализация переменных L, dv, D и k может быть легко выполнена за линейное время. Нахождение каждой последовательно удаляемой вершины v и корректировка ячеек D, содержащих соседей v, требуют времени, пропорционального значению dv на этом шаге; но сумма этих значений — это число ребер графа (каждое ребро вносит вклад в член в сумме для последних двух конечных точек), поэтому общее время является линейным.

Вот мой код (Susedia = Соседи)

    int his_place_inArray(int x,vector<int> A)
{
for(int i=0;i<A.size();i++)
if(*(A.begin()+i)==x) return i;

}

vector<int> vertex_ordering(vector<int> A) {

vector<int> L;
vector<vector<int>> D(100);
vector<int> d(A.size());
vector<int> N;                   //tsusedia

//Compute a number dv for each vertex v in G, the number of neighbors of v
//that are not already in L. Initially, these numbers are just the degrees
//of the vertices.
for (int i = 0; i < A.size(); i++) {
N = susedia(A[i], L);
d[i] = N.size();

//Initialize an array D such that D[i] contains a list of the vertices
//v that are not already in L for which dv = i.

D[d[i]].push_back(A[i]);

}
int i;
int k = 0; //Initialize k to 0.
int chosen;     //chosen
vector<int> chosen_N;   //Neighbors of chosen

for (int j = 0; j < A.size(); j++) {     //for n times

for (i = 0; i < 10; i++) {
if (D[i].empty() == false) {
k = max(k, i);
break;
}
}

chosen = D[i][0];
L.push_back(chosen);
D[i].erase(D[i].begin());
chosen_N = susedia(chosen, L);
int n; //neighbor

//For each neighbor w of v, subtract one from dw and move w to the cell of D corresponding to the new value of dw.
for (int w = 0; w < chosen_N.size(); w++) {

n = chosen_N[w];

int p = his_place_inArray(n,A);       //chosen neighbor place in A

int p_inD = his_place_inArray(n,D[d[p]]);  //chosen neighbor place in DD[d[p]].erase(D[d[p]].begin()+p_inD);
d[p]--;
D[d[p]].push_back(n);
}
}
return L;
}