leetcode 587. Erect the Fence 最短围栏 + 凸包优化

最新推荐文章于 2024-05-07 12:10:04 发布

JackZhangNJU

最新推荐文章于 2024-05-07 12:10:04 发布

阅读量1.3k

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/JackZhang_123/article/details/78839647

leetcode For C++ 同时被 3 个专栏收录

551 篇文章

订阅专栏

leetcode For Java

502 篇文章

订阅专栏

需要好好想一下的题目

355 篇文章

订阅专栏

本文介绍了一种解决围栏问题的方法，即如何用最短的绳子包围二维花园中的所有树木坐标点。通过构建凸包算法，实现了寻找构成围栏边界上的树木坐标，确保了所有树木被有效包围。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

There are some trees, where each tree is represented by (x,y) coordinate in a two-dimensional garden. Your job is to fence the entire garden using the minimum length of rope as it is expensive. The garden is well fenced only if all the trees are enclosed. Your task is to help find the coordinates of trees which are exactly located on the fence perimeter.

Example 1:
Input: [[1,1],[2,2],[2,0],[2,4],[3,3],[4,2]]
Output: [[1,1],[2,0],[4,2],[3,3],[2,4]]
Explanation:
这里写图片描述

Example 2:
Input: [[1,2],[2,2],[4,2]]
Output: [[1,2],[2,2],[4,2]]
Explanation:
这里写图片描述

Even you only have trees in a line, you need to use rope to enclose them.
Note:

All trees should be enclosed together. You cannot cut the rope to enclose trees that will separate them in more than one group.
All input integers will range from 0 to 100.
The garden has at least one tree.
All coordinates are distinct.
Input points have NO order. No order required for output.

本题题意很简单，就是寻找一个凸多边形来找到包含所有节点的，这个是经典的问题，这个是参考这个教程的做法[LeetCode] Erect the Fence 竖立栅栏

代码如下：

#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <climits>
#include <algorithm>
#include <sstream>
#include <functional>
#include <bitset>
#include <numeric>
#include <cmath>

using namespace std;

/*
struct Point 
{
     int x;
     int y;
     Point() : x(0), y(0) {}
     Point(int a, int b) : x(a), y(b) {}
};
*/

class Solution
{
public:
    vector<Point> outerTrees(vector<Point>& points) 
    {
        vector<Point> res;
        Point first = points[0];
        int firstIdx = 0, n = points.size();
        for (int i = 1; i < n; ++i) 
        {
            if (points[i].x < first.x) 
            {
                first = points[i];
                firstIdx = i;
            }
        }
        res.push_back(first);

        Point cur = first;
        int curIdx = firstIdx;
        while (true) 
        {
            Point next = points[0];
            int nextIdx = 0;
            for (int i = 1; i < n; ++i)
            {
                if (i == curIdx) continue;
                int cross = crossProduct(cur, points[i], next);
                if (nextIdx == curIdx || cross > 0 || (cross == 0 && dist(points[i], cur) > dist(next, cur)))
                {
                    next = points[i];
                    nextIdx = i;
                }
            }
            for (int i = 0; i < n; ++i) 
            {
                if (i == curIdx) continue;
                int cross = crossProduct(cur, points[i], next);
                if (cross == 0)
                {
                    if (check(res, points[i])) res.push_back(points[i]);
                }
            }
            cur = next;
            curIdx = nextIdx;
            if (curIdx == firstIdx) 
                break;
        }
        return res;
    }

    int crossProduct(Point A, Point B, Point C)
    {
        int BAx = A.x - B.x;
        int BAy = A.y - B.y;
        int BCx = C.x - B.x;
        int BCy = C.y - B.y;
        return BAx * BCy - BAy * BCx;
    }

    int dist(Point A, Point B)
    {
        return (A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y);
    }

    bool check(vector<Point>& res, Point p)
    {
        for (Point r : res) 
        {
            if (r.x == p.x && r.y == p.y)
                return false;
        }
        return true;
    }
};