void findCities(graph<int>& g, LList<int>& cities, int cityId, int p){
elem_link1<int>* start = g.point(cityId);
int dist[100]; // 100???
bool visited[100]; // 100??? - nikoi ne garantira, che id-tata na cities shte sa posledovatelni chisla pod 100
memset(dist, -1, 100);
memset(visited, 0, 100);
if (start){
visited[start->inf] = true;
dist[start->inf] = 0;
queue<int> q;
q.push(start->inf);
while (!q.empty()){
int current = q.front();
q.pop();
elem_link1<int>* p = g.point(current);
p = p->link;
while (p){
if (!visited[p->inf]){
visited[p->inf] = true;
dist[p->inf] = dist[current] + 1;
q.push(p->inf);
}
p = p->link;
}
}
for (int i = 0; i < 100; i++){
if (dist[i] >= 0 && dist[i] <= p){
cities.toEnd(i);
}
}
}
}
void path(town start, graph<town>& g, int p, LList<town> &visited){
if (g.empty())return;
int count = 0;
queue<town> q;
q.push(start);
visited.toEnd(start);
elem_link1<town> * f = g.point(start);
f = f->link;
while (!q.empty()){
town t;
q.pop(t);
while (f){
if (p == count)return;
else if (!member(visited, f->inf)){
q.push(f->inf);
visited.toEnd(f->inf);
count++;
}
f = f->link;
}
}
}
LList<T> neighbours(graph<T> g, T e) {
if (!g.top(e)) {
return LList<T>();
}
elem<T> * glist = g.point(e);
LList<T> neighbours;
while (glist->link != NULL) {
neighbours.ToEnd(glist->link->inf);
glist = glist->link;
}
return neighbours;
}
LList<int> townLessThan(int start, graph<int> towns, LList<int> &visited, int p)
{
LList<int> vert = towns.vertexes();
int n = vert.length();
//masiv, v koito shte pazim razstoianiata ot s da vs dr grad
int dist[100]; // Защо 100?
//inicializirame s -1 (ako niama put si ostava)
for (int i = 0; i < n; i++)
{
dist[i] = -1;
}
//BFS
queue<int> q;
visited.toEnd(start);
dist[start] = 0;
q.push(start);
while (!q.empty())
{
int x;
q.pop(x);
elem_link1<int> * p = towns.point(x);
p = p->link;
while (p)
{
if (!member(p->inf, visited))
{
visited.toEnd(p->inf);
q.push(p->inf);
dist[x] += 1; // vsichki stoinosti shte badat 0!
}
p = p->link;
}
}
//v masiva dist imame razstoianiata ot start do vs gradove
LList<int> result;
for (int i = 0; i < n; i++)
{
if (dist[i] <= p && dist[i] != -1)
result.toEnd(i);
}
return result;
}
void notFurtherThan(int& dist, int& start, graph<int>& g, LList<int>& visited, LList<int>& cities)
{
if (contains(visited, cities)) return; // ??? should be contains(visited, start)
if (dist < 0) return;
if (!g.top(start)) return;
visited.ToEnd(start);
cities.ToEnd(start);
elem<int>* q = g.point(start);
q = q->link;
while (q)
{
int distance = dist - 1;
notFurtherThan(distance, q->inf, g, visited, cities);
q = q->link;
}
}
