Wyszukiwanie cyklu Eulera dla każdego wierzchołka

#include<iostream>
#include <ctime>
#include <list>
#include <stack>
#include <queue>
#include <time.h>
#include <fstream>
#include <stdlib.h>
#include <unordered_set>
#include <string.h>
#include <vector>

using namespace std;

const size_t n = 20;
int counter = 0;
int lp = 0;
int E = 0.3*(n*(n - 1))/2;
bool tp[n];
vector<int> result;
int was[n][n];


void path(unordered_set<size_t> P[],int v){
    while(!P[v].empty()){
        auto v1 = P[v].begin();
        P[v].erase(*v1);
        P[*v1].erase(v);
        if(was[v][*v1] == 0){
            was[v][*v1] = 1;
            was[*v1][v] = 1;
            path(P, *v1);
            result.push_back(v);
        }
    }
}

void generate(unordered_set<size_t> L[]){
    int x,y;
    list<int> odd;
    for(int i = 0; i < n; i++){
        tp[i] = 1;
    }

    if(E < n-1) E = n-1;
    for(int i = 1; i < E; i++){
        if(i < n){
            x = rand() %i;
            y = i;
        }
        else{
            x = rand() %n;
            y = rand() %(n-1);
            y += (y >= x);
        }
        L[x].insert(y);
        L[y].insert(x);
        counter++;
    }
    for(int i = 0; i < n; i++){
        if(L[i].size() %2){
            odd.push_back(i);
            tp[i]=0;
            lp++;
        }
    }
    while(!odd.empty()){
        x = odd.front();
        odd.pop_front();
        y = odd.front();
        odd.pop_front();
        unordered_set<size_t>::const_iterator got = L[x].find (y);
        if(got==L[x].end()){
            L[x].insert(y);
            L[y].insert(x);
            counter++;
        }
        else{
            L[x].erase(y);
            L[y].erase(x);
            counter--;
        }
    }
    for(int i = 0; i < n; i++){
        if(L[i].size() %2 == 0){
            tp[i] = 1;
        }
    }
}

void print(unordered_set<size_t> L[]){
    for (int i = 0; i < n; i++){
        cout << i << ". ";
        for (auto it = L[i].begin(); it != L[i].end(); it++)
            cout << ' ' << *it;
        cout << "\n";
        cout << "parzysty: " << tp[i] << "\n";
    }
    cout << "odchylenie: " << lp << "\n";
}

void resultato(){
    for(int i = 0 ; i < counter; i++){
        cout << result.back() << " ";
        result.pop_back();
    }
}

int main(){
    unordered_set<size_t> L[n];
    unordered_set<size_t> pom[n];
    cout << "dla: " << n << "\n";

    generate(L);

    for(int i = 0; i < n; i++){
        pom[i] = L[i];
    }
    print(L);
    print(pom);
    for(int i=0; i<n; i++){
    path(pom,i);
    cout << "0" << "n. \n";
    resultato();
    print(pom);

    resultato();
    for(int j = 0; j < n; j++){
        pom[j] = L[j];
           }
    }
    return 0;
}
 

Ktoś może wie, dlaczego się program krzaczy i daje niepoprawny wynik?