21-froglike6

[froglike6]

🔗 문제 링크

Cows

✔️ 소요된 시간

예전에 풀었던 문제라 푼 시간이 기억은 나지 않지만, 1시간 정도 걸린 것 같습니다.

✨ 수도 코드

수도 코드

입력 P

점 목록 points를 빈 리스트로 만든다
P번 반복하면서:
    (x, y)를 입력받아
    points에 (x, y)를 추가한다

cross(o, a, b) 함수:
    (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x)를 반환한다

convex_hull(points) 함수:
    points를 정렬하고 중복을 제거한다
    만약 points의 크기가 1 이하라면:
        points를 그대로 반환한다

    lower를 빈 리스트로 만든다
    points를 처음부터 끝까지 순서대로 보면서:
        lower에 점이 두 개 이상 있고
        cross(lower[-2], lower[-1], 현재점) ≤ 0 이라면:
            lower의 마지막 점을 제거한다
        current 점을 lower에 추가한다

    upper를 빈 리스트로 만든다
    points를 끝에서부터 처음까지 역순으로 보면서:
        upper에 점이 두 개 이상 있고
        cross(upper[-2], upper[-1], 현재점) ≤ 0 이라면:
            upper의 마지막 점을 제거한다
        current 점을 upper에 추가한다

    lower의 마지막 점과 upper의 마지막 점(중복)을 제외하고:
        lower와 upper를 이어 붙인 리스트를 반환한다

shoelace_area(polygon) 함수:
    n ← polygon의 점 개수
    area ← 0
    i를 0부터 n-1까지 반복하면서:
        (x1, y1) ← polygon[i]
        (x2, y2) ← polygon[(i + 1) mod n]
        area에 (x1 * y2) - (x2 * y1)를 더한다
    절댓값(area)을 2로 나눈 값을 반환한다

메인 로직:
    hull ← convex_hull(points)
    pasture_area ← shoelace_area(hull)
    answer ← 정수 부분만 취한 (pasture_area // 50)
    answer를 출력한다

목초지에 나무와 소들이 있습니다. 울타리를 심어야 하지만 기둥을 박기 귀찮기 때문에, 심겨진 나무들로 울타리 기둥을 대신하려 합니다. 이 때 가능한 최대 넓이의 목초지를 일단 구하는 것이 목표입니다. 소들은 한 마리당 50제곱미터의 목초지가 필요하므로, 키울 수 있는 소의 최대 마리수를 출력하는게 이 문제의 정답입니다.

---

나무가 점처럼 심겨 있다고 가정합시다. 당연히 다음과 같은 상황일 때 최대 넓이가 됩니다.

이 바깥 점들을 어떻게 구해야 할까요? 바로 Convex Hull이라는 알고리즘을 통해 구하게 됩니다. 그 중에서도 저는 Monotone chain이라는 방법을 사용했습니다.

Monotone Chain 방법은 점 3개를 선택하여 외적을 한 후, 그 부호로 가장 바깥에 있는 점을 선택하여 볼록껍질을 $\mathcal{O}(n log n)$만에 찾는 방법입니다.

이 움직이는 사진을 보면, 현재 선택된 점에서 다음 점(X값 기준)을 선택하고 외적을 했을 때의 결과를 기준으로 판별하는 것을 알 수 있습니다. 외적한 값이 음수라면 오목다각형이 되기 때문에, 그 값을 제거하고 다른 점을 선택하여 이 과정을 반복하게 됩니다.

처음 시작할 때 X값을 기준으로 오름차순 정렬하고 시작하기 때문에, 스택을 사용하여 구현하면 됩니다. 외적에 관한 내용은 이미 #65 에 잘 설명되어 있습니다 ㅎㅎㅎ.

이 방식으로 아래쪽 부분을 구하고, 역순탐색으로 위쪽 부분을 구하여 둘을 이어주면 볼록껍질이 완성됩니다. 그런 다음 그 넓이를 신발끈으로 구하고, 50으로 나눈 몫을 출력하면 정답입니다!!

📚 새롭게 알게된 내용

[dohyeondol1]

몇주전에 못풀었던 문제인디 다시 도전해봐야겠네요 ㅎㅎ

[dohyeondol1]

저는 볼록껍질을 그레이엄 스캔(Graham Scan) 알고리즘으로 배워서 이 풀이는 처음 읽어보았습니다.
방식이 되게 독특하네요..!!
다음에 쉬운 볼록껍질 문제를 풀어볼 때 적용해봐야겠습니다.

그냥 볼록껍질 문제를 이전에 풀었던 기억이 나서.. 풀었던 코드를 가지고 다시 풀었습니다.

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <iomanip>
using namespace std;

struct Point {
    long long x, y;
    int idx;
};

Point base;

long long crossProduct(const Point& a, const Point& b, const Point& c) {
    return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
}

long long distanceSquared(const Point& a, const Point& b) {
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}

bool angleSort(const Point& a, const Point& b) {
    long long cross = crossProduct(base, a, b);
    if (cross != 0) return cross > 0;
    return distanceSquared(base, a) < distanceSquared(base, b);
}

double calculateArea(const vector<Point>& hull) {
    int n = hull.size();
    if (n < 3) return 0.0;
    
    long long area = 0;
    for (int i = 0; i < n; i++) {
        int j = (i + 1) % n;
        area += hull[i].x * hull[j].y;
        area -= hull[j].x * hull[i].y;
    }
    
    return abs(area) / 2.0;
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    
    int N;
    cin >> N;
    
    vector<Point> points(N);
    for(int i = 0; i < N; ++i) {
        cin >> points[i].x >> points[i].y;
        points[i].idx = i;
    }

    int baseIdx = 0;
    for(int i = 1; i < N; ++i) {
        if(points[i].y < points[baseIdx].y || (points[i].y == points[baseIdx].y && points[i].x < points[baseIdx].x))
            baseIdx = i;
    }
    
    swap(points[0], points[baseIdx]);
    base = points[0];

    sort(points.begin() + 1, points.end(), angleSort);
    
    vector<Point> hull;
    for(int i = 0; i < N; ++i) {
        while(hull.size() >= 2) {
            if(crossProduct(hull[hull.size()-2], hull[hull.size()-1], points[i]) <= 0)
                hull.pop_back();
            else
                break;
        }
        hull.push_back(points[i]);
    }

    double area = calculateArea(hull);
    double result = area / 50.0;

    cout << (long long)result << '\n';
    return 0;
}

[Fnhid]

저는 수도코드를 보면서 코드를 짜보았습니다.

convex_hull()에서 점들의 중복을 제거하기 위해 std::unique()를 사용했는데, pair<int, int>에서 x, y를 비교할 때 람다함수를 사용해 보았습니다.
요즘 함수형 프로그래밍을 공부하고 있는데 여기서 사용하니 반갑네요.

#include <iostream>
#include <vector>
#include <algorithm>


using namespace std;
using Point = pair<int, int>;

#define X first
#define Y second


int cross(const Point& o, const Point& a, const Point& b) {
    return (a.X - o.X) * (b.Y - o.Y) - (a.Y - o.Y) * (b.X - o.X);
}

bool compare(const Point& a, const Point& b) {
    if (a.X == b.X) return a.Y < b.Y;
    return a.X < b.X;
}


vector<Point> convex_hull(vector<Point> p) {
    sort(p.begin(), p.end(), compare);
    auto it = unique(p.begin(), p.end(), [](const Point& a, const Point& b) {
        return a.X == b.X && a.Y == b.Y;
    });
    p.erase(it, p.end());

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

    vector<Point> lP;
    for (const auto& p : p) {
        while (lP.size() >= 2 && cross(lP[lP.size() - 2], lP.back(), p) <= 0) {
            lP.pop_back();
        }
        lP.push_back(p);
    }

    vector<Point> uP;
    for (auto it = p.rbegin(); it != p.rend(); ++it) {
        const auto& p = *it;
        while (uP.size() >= 2 && cross(uP[uP.size() - 2], uP.back(), p) <= 0) {
            uP.pop_back();
        }
        uP.push_back(p);
    }

    lP.pop_back();
    uP.pop_back();

    lP.insert(lP.end(), uP.begin(), uP.end());
    return lP;
}

double shoelace_area(const vector<Point>& polygon) {
    int n = polygon.size();
    double area = 0.0;
    for (int i = 0; i < n; ++i) {
        int x1 = polygon[i].X;
        int y1 = polygon[i].Y;
        int x2 = polygon[(i + 1) % n].X;
        int y2 = polygon[(i + 1) % n].Y;
        area += (x1 * y2) - (x2 * y1);
    }
    return abs(area) / 2.0;
}

int main() {
    int n;
    cin >> n;
    vector<Point> p;
    for (int i = 0; i < n; ++i) {
        int x, y;
        cin >> x >> y;
        p.push_back({x, y});
    }

    vector<Point> hull = convex_hull(p);
    double pasture_area = shoelace_area(hull);
    int answer = static_cast<int>(pasture_area) / 50;  
    cout << answer << endl;

    return 0;
}