确定枚举对象、枚举范围和判断条件，并判断条件设立的正确性。
1. 确定枚举对象：枚举对象为公鸡、母鸡、小鸡的只数，那么我们可以用变量 $x$ 、 $y$ 、 $z$ 分别来代表公鸡、母鸡、小鸡的只数。
2. 确定枚举范围：因为总共买了 $100$ 只鸡，所以 $0 \le x, y, z \le 100$ ，则 $x$ 、 $y$ 、 $z$ 的枚举范围为 $[0, 100]$ 。
3. 确定判断条件：根据题意，我们可以列出两个方程式： $5 \times x + 3 \times y + \frac{z}{3} = 100$ ， $x + y + z = 100$ 。在枚举 $x$ 、 $y$ 、 $z$ 的过程中，我们可以根据这两个方程式来判断是否当前状态是否满足题意。

一一枚举可能的情况，并验证是否是问题的解。

根据枚举对象、枚举范围和判断条件，我们可以顺利写出对应的代码。

class Solution:
    def buyChicken(self):
        for x in range(101):
            for y in range(101):
                for z in range(101):
                    if z % 3 == 0 and 5 * x + 3 * y + z // 3 == 100 and x + y + z == 100:
                        print("公鸡 %s 只，母鸡 %s 只，小鸡 %s 只" % (x, y, z))

考虑提高枚举算法的效率。
1. 在上面的代码中，我们枚举了 $x$ 、 $y$ 、 $z$ ，但其实根据方程式 $x + y + z = 100$ ，得知： $z$ 可以通过 $z = 100 - x - y$ 而得到，这样我们就不用再枚举 $z$ 了。
2. 在上面的代码中，对 $x$ 、 $y$ 的枚举范围是 $[0, 100]$ ，但其实如果所有钱用来买公鸡，最多只能买 $20$ 只，同理，全用来买母鸡，最多只能买 $33$ 只。所以对 $x$ 的枚举范围可改为 $[0, 20]$ ， $y$ 的枚举范围可改为 $[0, 33]$ 。
```
class Solution:
    def buyChicken(self):
        for x in range(21):
            for y in range(34):
                z = 100 - x - y
                if z % 3 == 0 and 5 * x + 3 * y + z // 3 == 100:
                    print("公鸡 %s 只，母鸡 %s 只，小鸡 %s 只" % (x, y, z))
```

3. 枚举算法的应用

3.1 两数之和

3.1.1 题目链接

1. 两数之和 - 力扣（LeetCode）

3.1.2 题目大意

描述：给定一个整数数组 $nums$ 和一个整数目标值 $target$ 。

要求：在该数组中找出和为 $target$ 的两个整数，并输出这两个整数的下标。可以按任意顺序返回答案。

说明：

$2 \le nums.length \le 10^4$ 。
$-10^9 \le nums[i] \le 10^9$ 。
$-10^9 \le target \le 10^9$ 。
只会存在一个有效答案。

示例：

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

3.1.3 解题思路

这里说下枚举算法的解题思路。

思路 1：枚举算法

使用两重循环枚举数组中每一个数 $nums[i]$ 、 $nums[j]$ ，判断所有的 $nums[i] + nums[j]$ 是否等于 $target$ 。
如果出现 $nums[i] + nums[j] == target$ ，则说明数组中存在和为 $target$ 的两个整数，将两个整数的下标 $i$ 、 $j$ 输出即可。

思路 1：代码

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)):
            for j in range(i + 1, len(nums)):
                if i != j and nums[i] + nums[j] == target:
                    return [i, j]
        return []

思路 1：复杂度分析

时间复杂度： $O(n^2)$ ，其中 $n$ 为数组 $nums$ 的元素数量。
空间复杂度： $O(1)$ 。

3.2 计数质数

3.2.1 题目链接

204. 计数质数 - 力扣（LeetCode）

3.2.2 题目大意

描述：给定一个非负整数 $n$ 。

要求：统计小于 $n$ 的质数数量。

说明：

$0 \le n \le 5 \times 10^6$ 。

示例：

示例 1：

输入 n = 10
输出 4
解释 小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7。

示例 2：

输入：n = 1
输出：0

3.2.3 解题思路

这里说下枚举算法的解题思路（注意：提交会超时，只是讲解一下枚举算法的思路）。

思路 1：枚举算法（超时）

对于小于 $n$ 的每一个数 $x$ ，我们可以枚举区间 $[2, x - 1]$ 上的数是否是 $x$ 的因数，即是否存在能被 $x$ 整除的数。如果存在，则该数 $x$ 不是质数。如果不存在，则该数 $x$ 是质数。

这样我们就可以通过枚举 $[2, n - 1]$ 上的所有数 $x$ ，并判断 $x$ 是否为质数。

在遍历枚举的同时，我们维护一个用于统计小于 $n$ 的质数数量的变量 $cnt$ 。如果符合要求，则将计数 $cnt$ 加 $1$ 。最终返回该数目作为答案。

考虑到如果 $i$ 是 $x$ 的因数，则 $\frac{x}{i}$ 也必然是 $x$ 的因数，则我们只需要检验这两个因数中的较小数即可。而较小数一定会落在 $[2, \sqrt x]$ 上。因此我们在检验 $x$ 是否为质数时，只需要枚举 $[2, \sqrt x]$ 中的所有数即可。

利用枚举算法单次检查单个数的时间复杂度为 $O(\sqrt{n})$ ，检查 $n$ 个数的整体时间复杂度为 $O(n \sqrt{n})$ 。

思路 1：代码

class Solution:
    def isPrime(self, x):
        for i in range(2, int(pow(x, 0.5)) + 1):
            if x % i == 0:
                return False
        return True

    def countPrimes(self, n: int) -> int:
        cnt = 0
        for x in range(2, n):
            if self.isPrime(x):
                cnt += 1
        return cnt

思路 1：复杂度分析

时间复杂度： $O(n \times \sqrt{n})$ 。
空间复杂度： $O(1)$ 。

3.3 统计平方和三元组的数目

3.3.1 题目链接

1925. 统计平方和三元组的数目 - 力扣（LeetCode）

3.3.2 题目大意

描述：给你一个整数 $n$ 。

要求：请你返回满足 $1 \le a, b, c \le n$ 的平方和三元组的数目。

说明：

平方和三元组：指的是满足 $a^2 + b^2 = c^2$ 的整数三元组 $(a, b, c)$ 。
$1 \le n \le 250$ 。

示例：

示例 1：

输入 n = 5
输出 2
解释 平方和三元组为 (3,4,5) 和 (4,3,5)。

示例 2：

输入：n = 10
输出：4
解释：平方和三元组为 (3,4,5)，(4,3,5)，(6,8,10) 和 (8,6,10)。

3.3.3 解题思路

思路 1：枚举算法

我们可以在 $[1, n]$ 区间中枚举整数三元组 $(a, b, c)$ 中的 $a$ 和 $b$ 。然后判断 $a^2 + b^2$ 是否小于等于 $n$ ，并且是完全平方数。

在遍历枚举的同时，我们维护一个用于统计平方和三元组数目的变量 $cnt$ 。如果符合要求，则将计数 $cnt$ 加 $1$ 。最终，我们返回该数目作为答案。

利用枚举算法统计平方和三元组数目的时间复杂度为 $O(n^2)$ 。

注意：在计算中，为了防止浮点数造成的误差，并且两个相邻的完全平方正数之间的距离一定大于 $1$ ，所以我们可以用 $\sqrt{a^2 + b^2 + 1}$ 来代替 $\sqrt{a^2 + b^2}$ 。

思路 1：代码

class Solution:
    def countTriples(self, n: int) -> int:
        cnt = 0
        for a in range(1, n + 1):
            for b in range(1, n + 1):
                c = int(sqrt(a * a + b * b + 1))
                if c <= n and a * a + b * b == c * c:
                    cnt += 1
        return cnt

思路 1：复杂度分析

时间复杂度： $O(n^2)$ 。
空间复杂度： $O(1)$ 。