성벽 포함 관계를 무방향 그래프로 나타냈습니다.
표현은 인접 리스트로 표현했습니다.

주요 알고리즘은 간선이 하나뿐인 정점들에서 bfs를 돌려서 최대값을 받아내고
그 최대값들 중 최대값을 다시 추리는 방식입니다.

제가 접근을 잘못한건가요?
아니면 코드에 문제가 있나요?ㅠㅠ

책에 트리로 되어있어서 다르게 풀고싶어서 이렇게 했는데 어느 부분이 틀렸는지 감도 안잡히네요.

코드입니다.

~~~c++
const int INF = 123456789;
vector > positions;
vector countEdge;
vector > graph;

int bfs(int start,int n ){
vector val(n, INF);
queue que;

val[start] = 0;
que.push(start);

while (!que.empty()){
    int here = que.front();
    que.pop();

    int sz = graph[here].size();
    for (int there = 0; there < sz; there++){
        if (val[here] + 1 < val[graph[here][there]]){
            val[graph[here][there]] = val[here] + 1;
            que.push(graph[here][there]);
        }
    }
}

int maxx = 0;
for (int i = 0; i<n; i++)
{
    if (val[i] > maxx)
        maxx = val[i];
}
return maxx;

}

int main(){
#ifdef _HONG

freopen("input.txt", "r", stdin);
// freopen("output.txt","w+", stdout);
#endif
int tc;
cin >> tc;
while (tc--){
int n;
cin >> n;
int a, b, c;

    positions = vector<vector<int> >();
    countEdge = vector<int>(n,0);
    graph = vector<vector<int> >(n);
    vector<pair<int, int> > orderDis;
    vector<int> wall(5);// xh, xl, yh, yl, wall;


    enum{ xh = 0, xl, yh, yl, dis };

    for (int i = 0; i < n; i++)
    {
        cin >> a >> b >> c;
        wall[xh] = a + c;
        wall[xl] = a - c;
        wall[yh] = b + c;
        wall[yl] = b - c;
        wall[dis] = c;
        positions.push_back(wall);
        orderDis.push_back(make_pair(c, i));
    }

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

    for (int i = 0; i < n; i++){
        int smaller = orderDis[i].second;
        for (int j = i + 1; j < n; j++){
            int bigger = orderDis[j].second;
            if (positions[smaller][xh] < positions[bigger][xh] &&
                positions[smaller][xl] > positions[bigger][xl] &&
                positions[smaller][yh] < positions[bigger][yh] &&
                positions[smaller][yl] > positions[bigger][yl]){

                graph[smaller].push_back(bigger);
                graph[bigger].push_back(smaller);

                countEdge[smaller] += 1;
                countEdge[bigger] += 1;
                break;
            }
        }
    }

    vector<int> oneEdges; //최대길이는 어느 한쪽이든 하나는 잎
    for (int i = 0; i < n; i++)
    {
        if (countEdge[i] == 1)
            oneEdges.push_back(i);
    }

    int sz = oneEdges.size();
    int maxx = 0;

    for (int i = 0; i<sz; i++){
        int res = bfs(oneEdges[i],n);
            if (maxx < res)
                maxx = res;
    }
    cout << maxx << endl;

    positions.clear();
    countEdge.clear();
    graph.clear();
}
return 0;

}
~~~