알고스팟에서 문제 푸는데 (https://algospot.com/judge/problem/read/FORTRESS)

벡터 begin() 받는거는 되는데 그 값을 참조하려고 하면 런타임 오류가 뜨더라고(vector iterators incompatible)

벡터 선언은 vector<node*> children; 로 되있고

문제 일으키는 라인은

for_each(target.children.begin(), target.children.end(), [&travelLen](node *t){

travelLen.push_back(getMaxLength(*t));

});


이렇게 생겼는데 원인을 몰라서 벡터 자체를 레퍼런스로 받아보거나 vector<node>로 고쳐보고 이것 저것 해봤는데 계속 오류만 뜨더라. 그래서 결국 좀 편법으로 해결하긴 했는데 아직도 이거 원인을 모름.

아래는 전체 코드고 혹시 원인 아는 고수형 있으면 댓글 좀 달아줘

#include<iostream>

#include<vector>

#include<tuple>

#include<algorithm>

#include<cmath>(#include<cstring>


using namespace std;


typedef tuple<int, int, int> CIRCLE;

const int X = 0;

const int Y = 1;

const int R = 2;

const int MAX = 100;


class node

{

public :

int num;

CIRCLE info;

node* parent;

vector<node*> children;

node(){};

node(int num, int x, int y, int r) : num(num), info(tie(x, y, r)), parent(NULL){ ; }

~node() { children.clear(); parent = NULL; }

//vector<node*>::const_iterator begin() const{ return children.begin(); }

//vector<node*>::const_iterator end() const{ return children.end(); }

};


inline void input();

void preCal();

int solve();

int getMaxLength(node &target);

bool isParent(node &a, node &b);

double distance(int Ax, int Ay, int Bx, int By);

bool isContain(double dis, double Br);



int N;

int maxLen;

node nodeArr[MAX];

vector<node> castle;

node* root;


int main(void)

{

cin.sync_with_stdio(false);

cout.sync_with_stdio(false);

int testcase;

cin >> testcase;

while (testcase--)

{

input();

preCal();

cout << solve() << '\n';

}

return 0;

}


inline void input()

{

memset(nodeArr, NULL, sizeof(nodeArr));

castle.clear();

maxLen = 0;

cin >> N;

{

int x, y, r;

cin >> x >> y >> r;

nodeArr[0] = node(0, x, y, r);

root = &nodeArr[0];

castle.push_back(nodeArr[0]);

}

for (int i = 1; i < N; ++i)

{

int x, y, r;

cin >> x >> y >> r;

nodeArr[i] = node(i, x, y, r);

castle.push_back(nodeArr[i]);

}

sort(castle.begin(), castle.end(), [](node &a, node &b) -> bool{ 

return get<R>(a.info) < get<R>(b.info);

});

}


int solve()

{

int h = getMaxLength(*root);

return max(h, maxLen);

}


int getMaxLength(node &target)

{

vector<int> travelLen;

int size = target.children.size();

for (int i = 0; i < size; ++i)

{

int tNum = target.children[i]->num;

travelLen.push_back(getMaxLength(nodeArr[tNum]));

}

 

/*for_each(target.children.begin(), target.children.end(), [&travelLen](node *t)

{

travelLen.push_back(getMaxLength(*t));

});*/

if (travelLen.empty())

return 0;


sort(travelLen.begin(), travelLen.end());

if (travelLen.size() >= 2)

maxLen = max(maxLen, *(travelLen.end() -2) + travelLen.back() + 2);

return travelLen.back() + 1;

}


void preCal()

{

for (auto i = castle.begin(); i != castle.end(); ++i)

{

for (auto j = i+1; j != castle.end(); ++j) 

{

if (isParent(*i,*j))

{

node& ch = nodeArr[(*i).num];

node& par = nodeArr[(*j).num];

par.children.push_back(&ch);

ch.parent = &par;

break;

}

}

}

}


bool isParent(node &a, node &b)

{

double dis = distance(get<X>(a.info), get<Y>(a.info), get<X>(b.info), get<Y>(b.info));

if (isContain(dis, static_cast<double>(get<R>(b.info))))

return true;

else

return false;

}


double distance(int Ax, int Ay, int Bx, int By)

{

int x = Ax - Bx;

int y = Ay - By;

double dis = sqrtl(x*x + y*y);

return dis;

}


bool isContain(double dis, double Br)

{

if (dis < Br) 

return true;

else

return false;

}