【Leetcode】605. 种花问题——数组一次遍历与内存优化（击败100%时间 + 89%内存）

---

题目

• 假设你有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花卉不能种植在相邻的地块上，它们会争夺水源，两者都会死去。
• 给定一个花坛（表示为一个数组包含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

注意:

1. 数组内已种好的花不会违反种植规则。
2. 输入的数组长度范围为 [1, 20000]。
3. n 是非负整数，且不会超过输入数组的大小。

---

分析

• 由题目可知，在不打破种植规则的情况下在花坛内种入 n 朵花，也就是求当前期望种植的花数小于等于当前情况下最大种植数量。
• 那么，我们就可以从贪心的角度来考虑，即：在不打破种植规则的情况下种入尽可能多的花，然后判断可以种入的花的最多数量是否大于或等于 n。
• 下面开始对整个数组从头开始遍历，对每个位置的元素分两种情况讨论：

1. 当前位置有花（flowerbed[i] = 1）：
   由种花规则可知，当前位置的下一个位置不能种花，只能从当前位置的后两格才有可能种花，因此i = i + 2。
2. 当前位置无花（flowerbed[i] = 0）：
   由种花规则可知，当前位置可能可以种花，但还需要看当前位置的下一个位置是否有花（flowerbed[i + 1] == 1，注意判断下标是否越界）。
   • 如果有（flowerbed[i + 1] = 1），则当前位置不能种植，i = i + 1，又因为i + 1位置有花，由情况1知i = i + 2，因此i = i + 3。
   • 如果没有（flowerbed[i + 1] = 0），则当前位置可以种花，计数器count += 1。当前位置种下花后，当前位置就满足了情况1，因此i = i + 2。

• 遍历完成之后，由第一条分析的结论可知，此时只需计数器count >= n，就说明此时想要种n棵花的期望可以被满足；反之则说明不可以。

---

代码

将上述的分析过程转化为代码：

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        int count = 0;
        for (int i = 0; i < flowerbed.length;) {
            if (flowerbed[i] == 1) {
                i += 2;
            } else if (flowerbed[i] == 0 && i + 1 < flowerbed.length && flowerbed[i + 1] == 1) {
                i += 3;
            } else {
                i += 2;
                count++;
            }
        }
        return count >= n;
    }
}

• 时间复杂度：O(n)，其中 n 是数组flowerbed的长度，需要遍历数组一次。
• 空间复杂度：O(1)，额外使用的空间为常数。

---

第一次提交

---

优化

第一次提交的结果中，内存消耗的排名不太满意，因此考虑减少内存的使用。

1. 由题目的限制条件2可知，数组最大长度为20000，小于short类型的最大值32767，因此可以将循环变量i的类型改为short。

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        int count = 0;
        for (short i = 0; i < flowerbed.length;) {
            if (flowerbed[i] == 1) {
                i += 2;
            } else if (flowerbed[i] == 0 && i + 1 < flowerbed.length && flowerbed[i + 1] == 1) {
                i += 3;
            } else {
                i += 2;
                count++;
            }
        }
        return count >= n;
    }
}

2. count变量是在函数中创建的临时变量，因此可以考虑优化。由分析过程可知，在循环过程中不断累加count，当count大于等于n时就说明满足条件。那么也可以反过来想，即在循环过程中不断减少n，当n小于等于0时就说明满足条件。这样就能够节省临时变量count的空间使用。

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        for (short i = 0; i < flowerbed.length;) {
            if (flowerbed[i] == 1) {
                i += 2;
            } else if (flowerbed[i] == 0 && i + 1 < flowerbed.length && flowerbed[i + 1] == 1) {
                i += 3;
            } else {
                i += 2;
                n--;
            }
        }
        return n <= 0;
    }
}

3. 既然当n小于等于0以后就说明满足条件了，那么当n==0的时候就已经满足条件了，没有必要继续执行循环，可直接退出。

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        if (n == 0) {
            return true;
        }
        for (short i = 0; i < flowerbed.length;) {
            if (flowerbed[i] == 1) {
                i += 2;
            } else if (flowerbed[i] == 0 && i + 1 < flowerbed.length && flowerbed[i + 1] == 1) {
                i += 3;
            } else {
                i += 2;
                n--;
                if (n == 0) {
                    return true;
                }
            }
        }
        return false;
    }
}

---

第二次提交

可见，优化后的提交中，内存的消耗有了很明显的改善。