題目：

在二維空間中有許多球形的氣球。對於每個氣球，提供的輸入是水平方向上，氣球直徑的開始和結束座標。由於它是水平的，所以縱座標並不重要，因此只要知道開始和結束的橫座標就足夠了。開始座標總是小於結束座標。

一支弓箭可以沿著 x 軸從不同點完全垂直地射出。在座標 x 處射出一支箭，若有一個氣球的直徑的開始和結束座標為 xstart，xend， 且滿足 xstart≤ x ≤ xend，則該氣球會被引爆。可以射出的弓箭的數量沒有限制。 弓箭一旦被射出之後，可以無限地前進。我們想找到使得所有氣球全部被引爆，所需的弓箭的最小數量。

給你一個數組 points ，其中 points [i] = [xstart,xend] ，返回引爆所有氣球所必須射出的最小弓箭數。

示例 1：

輸入：points = [[10,16],[2,8],[1,6],[7,12]]
輸出：2
解釋：對於該樣例，x = 6 可以射爆 [2,8],[1,6] 兩個氣球，以及 x = 11 射爆另外兩個氣球

示例 2：

輸入：points = [[1,2],[3,4],[5,6],[7,8]]
輸出：4

示例 3：

輸入：points = [[1,2],[2,3],[3,4],[4,5]]
輸出：2

示例 4：

輸入：points = [[1,2]]
輸出：1

示例 5：

輸入：points = [[2,3],[2,3]]
輸出：1

提示：

0 <= points.length <= 10^4
points[i].length == 2
-2^31 <= xstart <xend <= 2^31 - 1

解答

首先自己的解答（貪心演算法？找相鄰兩個區間的最優解），根據435的思路，先對輸入進行左端升序排序，然後找相鄰兩個區間的重疊區間，然後再判斷重疊區間與下一個區間是否重疊，如果不重疊則num++，修改了bug後提交通過，程式碼如下，

//452-用最少數量的箭引爆氣球
//如果兩個vec重疊，則找到兩個區間重疊的上下邊界;
pair<int, int> getOverlapRange(vector<int>& vec1, vector<int>& vec2)
{
    int downBound = (vec1[0] >= vec2[0]) ? vec1[0
 
] : vec2[0];
    int upBound = (vec1[1] <= vec2[1]) ? vec1[1] : vec2[1];

    return{ downBound, upBound };
}

//先根據下邊界排序，然後判斷是否重疊，如果重疊則找到重疊的區域，然後再判斷下一個與[downBound,upBound]是否重疊
//如果重疊，則更新[downBound,upBound]
//如果不重疊，則num++，然後再重複上面的操作
int findMinArrowShots(vector<vector<int>>& points) 
{
    if (points.size() < 2)
        return points.size();

    auto comp = [](vector<int>& vec1, vector<int>& vec2)->bool
    {
        return vec1[0] < vec2[0];
    };

    auto isOverlap = [](vector<int>& vec1, vector<int>& vec2)->bool
    {
        if (vec2[0] >= vec1[0] && vec2[0] <= vec1[1])
            return true;
        if (vec1[0] >= vec2[0] && vec1[0] <= vec2[1])
            return true;
        return false;
    };

    sort(points.begin(), points.end(), comp);

    cout << "input:" << endl;//
    for (auto val: points)
    {
        cout << val[0] << "\t\t" << val[1] << endl;
    }
    cout << endl;

    int num = 1;
    int downBound = 0, upBound = 0;
    for (int i = 1; i < points.size(); i++)
    {
        if (isOverlap(points[i - 1], points[i]))
        {
            if (downBound == 0 && upBound == 0)
            {
                pair<int, int> pairB = getOverlapRange(points[i - 1], points[i]);
                downBound = pairB.first;
                upBound = pairB.second;

                cout << "Current:\t" << pairB.first << "\t" << pairB.second << endl;
                cout << "bound:\t" << downBound << "\t" << upBound << endl;
                continue;
            }

            vector<int> bound = { downBound, upBound };
            if (isOverlap(points[i], bound))
            {
                pair<int, int> pairB = getOverlapRange(points[i], bound);
                downBound = pairB.first;
                upBound = pairB.second;
            }
            else
            {
                downBound = 0;
                upBound = 0;
                num++;
            }
        }
        else
        {
            downBound = 0;
            upBound = 0;
            num++;
        }
    }

    return num;
}

　　然後看題解，貪婪演算法的思路類似，但是程式碼很簡潔：https://leetcode-cn.com/problems/minimum-number-of-arrows-to-burst-balloons/solution/yong-zui-shao-shu-liang-de-jian-yin-bao-qi-qiu-1-2/

　　還沒細看，待完成。。。