[HaBo]

%Haus: [k(a,b), k(a,c), k(a,d), k(b,d),k(b,c),k(c,d),k(e,c),k(e,d)]
%      e
%     /\
%    /  \
%  c/____\d
%   |\  /|
%   | \/ |
%   | /\ |
%   |/__\|
%   a     b

haus(X,[],[X]).                                                                 %wenn alle Knoten abgearbeitet wurden - fertig
haus(X,Knotenliste,[X|Sol]):-select(k(Y,X),Knotenliste,Rest),haus(Y,Rest,Sol).  %sonst, suche einen Knoten raus, der mit X verbunden ist
haus(X,Knotenliste,[X|Sol]):-select(k(X,Y),Knotenliste,Rest),haus(Y,Rest,Sol).

sel(X,[X|Tail],Tail).                                                     %wurde ein Element gefunden - fertig
sel(X,[K|Tail],[K|DeltaTail]) :- sel(X,Tail,DeltaTail).                   %sonst gehe die Liste durch:

haus(X,[],[X]).                                                              %wenn alle Knoten abgearbeitet wurden - fertig
haus(X,Knotenliste,[X|Erg]):-sel(k(X,Y),Knotenliste,Rest),haus(Y,Rest,Erg);  %sonst, suche einen Knoten raus, der mit X verbunden ist
                             sel(k(Y,X),Knotenliste,Rest),haus(Y,Rest,Erg).  %für beide Richtungen (von X nach Y und Y nach X)

Anfrage nach Lösungen:
65 ?- haus(_,[k(a, b), k(a, c), k(a, d), k(b, d), k(b, c), k(c, d), k(e, c), k(e, d)],Loesung).

Ausgabe:
Loesung = [a, b, d, a, c, d, e, c, b] ;
Loesung = [a, b, d, a, c, e, d, c, b] ;
Loesung = [a, b, d, c, a, d, e, c, b]

Haus=[k(a,b), k(a,c), k(a,d), k(b,d),k(b,c),k(c,d),k(e,c),k(e,d)],
|    findall(Loesung,haus(_,Haus,Loesung),Loesungenliste),length(Loesungenliste,Anzahl).
Ausgabe:
Loesungenliste = [[a, b, d, a, c, d, e, c|...], [a, b, d, a, c, e, d|...] ...],
Anzahl = 88.

#include <iostream>
#include <list>

using namespace std;

class hvn
{
private:
	struct edge
	{
		int a, b, c;
		edge(int _a, int _b) : a(_a), b(_b), c(-1) {}
		edge(edge _e, int _c) : a(_e.a), b(_e.b), c(_c) {}
	};
	list<edge> edges, way;
	list<int> vertices;
	int num;
	void printway(int cur)
	{
		cout << ++num << ". ";
		for (list<edge>::reverse_iterator it = way.rbegin(); it != way.rend(); ++it)
			cout << it->c << "-";
		cout << cur << endl;
	}
	void nextstep(int cur)
	{
		if (way.size() == edges.size())
			printway(cur);
		for (list<edge>::iterator it = edges.begin(); it != edges.end(); ++it) {
			if (it->a == cur || it->b == cur) {
				bool valid = true;

				list<edge>::iterator it2;
				for (it2 = way.begin(); it2 != way.end(); ++it2) {
					if (it->a == it2->a && it->b == it2->b) {
						valid = false;
						break;
					}
				}

				if (valid) {
					way.push_front(edge(*it,cur));
					nextstep((it->a == cur)?it->b:it->a);
					way.pop_front();
				}
			}
		}
	}
public:
	void addEdge(int a, int b)
	{
		edges.push_front(edge(a, b));
		vertices.push_front(a);
		vertices.push_front(b);
	}
	void calc()
	{
		vertices.sort();
		vertices.unique();
		num = 0;
		for (; !vertices.empty(); vertices.pop_front())
			nextstep(vertices.front());
		cout << num << " Loesungen." << endl;
	}
};

int main()
{
	cout << "Das \"Haus vom Nikolaus\" und seine Verwandten." << endl;

	hvn x;

	for (;;) {
		cout << "Jeweils zwei Punkte (Zahlen), die mit einer Linie verbunden sind (Strg-D für Ende):" << endl;
		int a, b;
		if (! (cin >> a >> b))
			break;
		x.addEdge(a, b);
	}
	x.calc();
}

solveNikohaus([], Location, Way, Acc):- Acc = [Location|Way].
solveNikohaus(LeftList, Location, Way, Acc):-
    (select(con(Location, Dest), LeftList, RestList);
     select(con(Dest, Location), LeftList, RestList)),
    solveNikohaus(RestList, Dest, [Location|Way], Acc).

solve(Solution):-
    Knodes = [con(a, b), con(b, d), con(d, e), con(e, c), con(c, a),  con(a, d), con(d, c), con(c, b)],
    solveNikohaus(Knodes, _, [], Solution).

solve(Start, Solution):-
    Knodes = [con(a, b), con(b, d), con(d, e), con(e, c), con(c, a),  con(a, d), con(d, c), con(c, b)],
    solveNikohaus(Knodes, Start, [], Solution).

?- solve(R).

R = [b, c, d, a, c, e, d, b, a] ;

R = [b, c, a, d, c, e, d, b, a] ;

R = [b, c, e, d, a, c, d, b, a] ;

R = [b, c, a, d, e, c, d, b, a]