605.种花问题

假设有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花不能种植在相邻的地块上，它们会争夺水源，两者都会死去。

给你一个整数数组 flowerbed 表示花坛，由若干 0 和 1 组成，其中 0 表示没种植花，1 表示种植了花。另有一个数 n ，能否在不打破种植规则的情况下种入 n 朵花？能则返回 true ，不能则返回 false。

示例 1：

输入：flowerbed = [1,0,0,0,1], n = 1
输出：true
示例 2：

输入：flowerbed = [1,0,0,0,1], n = 2
输出：false

class Solution {
public:
    bool canPlaceFlowers(vector<int>& flowerbed, int n) {
        unordered_map<int,int> hash;
        int m=flowerbed.size();
        int zero=0;
        int ans=0;
        if(m==1&&flowerbed[0]==0)
        {
            return true;
        }
        for(int i=0;i<m;i++)
        {
            if(flowerbed[i]==1)
            {
                
                if(hash.count(1)==1)
                {
                    if(zero%2==0&&zero!=0)
                    {
                        ans+=(zero-2)/2;
                    }
                    if(zero%2!=0&&zero!=0)
                    {
                        ans+=(zero-1)/2;
                    }
                    hash[1]=i;


                    
                }
                else
                {
                    if(zero%2==0&&zero!=0)
                    {
                        ans+=zero/2;
                    }
                    if(zero%2!=0&&zero!=0)
                    {
                        ans+=(zero-1)/2;
                    }
                    hash[1]=i;
                    
                }
                zero=0;
            }
            else
            {
                zero++;
            }
             
        }
        if(hash.count(1)==0)
        {
            if(zero%2==0)
            {
                ans+=zero/2;
            }
            else
            {
                ans+=(zero+1)/2;
            }
            if(ans>=n)
            {
                return true;
            }
            else
            {
                return false;
            }
            
        }
        if(hash[1]!=m-1)
        {
            int x=m-1-hash[1];
            if(x%2==0)
            {
                ans+=x/2;
            }
            else
            {
                ans+=(x-1)/2;
            }
        }
        if(ans>=n)
        {
            return true;
        }
        else
        {
            return false;
        }

    }
};

这题可以用线性复杂度解决，
我们思考一下，以1为分割点，看有多少个间隔，里面又包含几个0，奇偶分开讨论，两边也分开讨论，两者相加。这里面就要用到动态更新的方法，每当有一个1，就把1的索引更新到最新，方便以后看1是否是末尾的元素。
并且，如果一直没有1也要分开讨论，只有一个元素0也要讨论，就是特殊情况要顾及，我提交了五六次才完全通过140多个测试样例。