помоги мне решить задачу по алгоритмам и структура...

Ниже — простой и надёжный способ.

Идея:

1. Чтобы забор был как можно короче и полностью «накрывал» дом, его оптимальная форма — граница выпуклой оболочки того, что нельзя приближать ближе чем на $l$ по манхэттенскому расстоянию.
2. Это то же самое, что $\text{conv}(P) \oplus D_l$, где $P$ — многоугольник дома, $D_l=\{(x,y):|x|+|y|\le l\}$ — «ромб» (единичный шар в $L_1$) радиуса $l$.
3. Периметр такой фигуры равен:

Поэтому достаточно построить выпуклую оболочку вершин дома (алгоритм Эндрю) и к её периметру прибавить $4\sqrt{2}\,l$.

Код (C++20, без глобальных переменных, с отдельными функциями):

cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <iomanip>

struct point_ll {
    long long x;
    long long y;
};

long long cross(const point_ll& a, const point_ll& b, const point_ll& c) {
    long long abx = b.x - a.x;
    long long aby = b.y - a.y;
    long long acx = c.x - a.x;
    long long acy = c.y - a.y;
    return abx * acy - aby * acx; // в пределах int64 при данных ограничениях
}

double euclidean_distance(const point_ll& a, const point_ll& b) {
    return std::hypot(static_cast<double>(a.x - b.x),
                      static_cast<double>(a.y - b.y));
}

std::vector<point_ll> build_convex_hull(std::vector<point_ll> points) {
    // сортируем по x, затем по y
    std::sort(points.begin(), points.end(), [](const point_ll& p1, const point_ll& p2) {
        if (p1.x != p2.x) return p1.x < p2.x;
        return p1.y < p2.y;
    });

    // удалим дубликаты на всякий случай
    points.erase(std::unique(points.begin(), points.end(), [](const point_ll& a, const point_ll& b){
        return a.x == b.x && a.y == b.y;
    }), points.end());

    if (points.size() <= 1) return points;

    std::vector<point_ll> lower, upper;

    for (const auto& p : points) {
        while (lower.size() >= 2 &&
               cross(lower[lower.size() - 2], lower[lower.size() - 1], p) <= 0) {
            lower.pop_back();
        }
        lower.push_back(p);
    }

    for (int i = static_cast<int>(points.size()) - 1; i >= 0; --i) {
        const auto& p = points[i];
        while (upper.size() >= 2 &&
               cross(upper[upper.size() - 2], upper[upper.size() - 1], p) <= 0) {
            upper.pop_back();
        }
        upper.push_back(p);
    }

    // соединяем, убрав последнюю точку каждой половины (она повторяется)
    lower.pop_back();
    upper.pop_back();
    std::vector<point_ll> hull = lower;
    hull.insert(hull.end(), upper.begin(), upper.end());
    return hull;
}

double perimeter_of_polygon(const std::vector<point_ll>& polygon) {
    if (polygon.empty()) return 0.0;
    double per = 0.0;
    for (size_t i = 0; i < polygon.size(); ++i) {
        const point_ll& a = polygon[i];
        const point_ll& b = polygon[(i + 1) % polygon.size()];
        per += euclidean_distance(a, b);
    }
    return per;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int vertices_count;
    long long min_l1_distance;
    if (!(std::cin >> vertices_count >> min_l1_distance)) {
        return 0;
    }

    std::vector<point_ll> house_vertices(vertices_count);
    for (int i = 0; i < vertices_count; ++i) {
        std::cin >> house_vertices[i].x >> house_vertices[i].y;
    }

    std::vector<point_ll> hull = build_convex_hull(house_vertices);
    double hull_perimeter = perimeter_of_polygon(hull);
    double extra = 4.0 * std::sqrt(2.0) * static_cast<double>(min_l1_distance);

    double answer = hull_perimeter + extra;

    std::cout.setf(std::ios::fixed);
    std::cout << std::setprecision(10) << answer << "\n";
    return 0;
}

Почему это работает:

• Выпуклая оболочка даёт кратчайшую границу среди всех фигур, содержащих дом (при $l=0$ это видно из примера 2).
• Запас по манхэттенскому расстоянию $l$ эквивалентен «надуванию» на ромб $D_l$; периметр увеличивается на периметр этого ромба, то есть на $4\sqrt{2}\,l$ (как у кругового оффсета прибавляется $2\pi r$).

Сложность — $O(n\log n)$ из-за построения выпуклой оболочки.