1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

int thirdMax(vector<int> &nums)
    {
        // 初始化最大值、中间值和最小值为最小的长整型值
        long long maxNum = LONG_LONG_MIN, midNum = LONG_LONG_MIN, minNum = LONG_LONG_MIN;
        // 遍历数组中的每一个数字
        for (auto n : nums)
        {
            // 如果当前数字大于最大值，则更新最大值、中间值和最小值
            if (n > maxNum)
            {
                minNum = midNum; // 更新最小值为之前的中间值
                midNum = maxNum; // 更新中间值为之前的最大值
                maxNum = n;      // 更新最大值为当前数字
            }
            // 如果当前数字在最大值和中间值之间，则更新中间值和最小值
            else if (n > midNum && n < maxNum)
            {
                minNum = midNum; // 更新最小值为之前的中间值
                midNum = n;      // 更新中间值为当前数字
            }
            // 如果当前数字在中间值和最小值之间，则更新最小值
            else if (n > minNum && n < midNum)
            {
                minNum = n; // 更新最小值为当前数字
            }
        }
        // 如果最小值仍未更新，返回最大值
        if (minNum == LONG_LONG_MIN)
            return maxNum; // 返回最大值
        else
            return minNum; // 返回第三大的数字
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

    bool canPlaceFlowers(vector<int> &flowerbed, int n)
    {
        // 第一版实现
        int rest = 0; // 记录可以种植的花的数量
        // 遍历花坛数组
        for (int i = 0; i < flowerbed.size(); ++i)
        {
            // 如果当前位置已经种植了花，跳过
            if (flowerbed[i] == 1)
            {
                ++i;      // 跳过下一个位置，因为相邻位置不能种花
                continue; // 继续下一个循环
            }
            // 如果当前位置没有种植花
            if (flowerbed[i] == 0)
            {
                // 检查是否是最后一个位置
                if (i == flowerbed.size() - 1)
                {
                    ++rest; // 可以种植一朵花
                    break;  // 结束循环
                }
                // 检查下一个位置是否也为空
                if (flowerbed[i + 1] == 0)
                {
                    flowerbed[i] = 1; // 在当前位置种一朵花
                    ++rest;           // 记录已种植的花的数量
                    ++i;              // 跳过下一个位置
                }
                else
                {
                    continue; // 继续下一个循环
                }
            }
        }
        // 返回是否可以种入n朵花
        return rest >= n ? true : false;
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

    bool canPlaceFlowers(vector<int> &flowerbed, int n)
            int rest = 0;                // 记录可以种植的花的数量
            int size = flowerbed.size(); // 获取花坛的大小
            // 遍历花坛数组
            for (int i = 0; i < size; ++i)
            {
                // 判断当前位置以及相邻的两个位置是否都为空
                if (flowerbed[i] == 0 && (i == 0 || flowerbed[i - 1] == 0) && 
                (i == size - 1 || flowerbed[i + 1] == 0))
                {
                    flowerbed[i] = 1; // 在当前位置种一朵花
                    ++rest;           // 记录已种植的花的数量
                    // 跳过下一个位置，因为相邻位置不能种花
                    ++i;
                }
            }
            // 返回是否可以种入n朵花
            return rest >= n;
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

      bool canPlaceFlowers(vector<int> &flowerbed, int n)
        int rest = 0; // 记录可以种植的花的数量
        // 在花坛的开头和结尾插入0，以简化判断
        flowerbed.insert(flowerbed.begin(), 0);
        flowerbed.push_back(0);
        // 遍历花坛，从第一块到倒数第二块
        for (int i = 1; i < flowerbed.size() - 1; ++i)
        {
            // 判断当前块以及左右相邻块是否都为空
            if (flowerbed[i] == 0 && flowerbed[i - 1] == 0 &&
            flowerbed[i + 1] == 0)
            {
                flowerbed[i] = 1; // 在当前块种一朵花
                ++rest; // 记录已种植的花的数量
            }
        }
        // 判断是否可以种入n朵花
        return rest >= n ? true : false;
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

    int maximumProduct(vector<int> &nums)
    {
        int len = nums.size() - 1;      // 获取数组长度减一
        sort(nums.begin(), nums.end()); // 对数组进行排序
        // 如果数组的最小值非负，或者最大值为负数，返回三个最大的数的乘积
        if (nums[0] >= 0 || nums[len] < 0)
            return nums[len] * nums[len - 1] * nums[len - 2];
        int firstNum = 0, secondNum = 0, thirdNum = 0, Max = INT_MIN; // 初始化变量
        int temp = 1;                                                 // 临时乘积变量
        int n = 0;          // 统计负数的数量
        while (nums[n] < 0) // 寻找数组中负数的个数
        {
            ++n;
        }
        // 分别存储负数部分和正数部分
        vector<int> fushu(nums.begin(), nums.begin() + n);  // 负数部分
        vector<int> zhengshu(nums.begin() + n, nums.end()); // 正数部分
        // 如果负数部分有两个或更多，计算负数与两个最大的正数的乘积
        if (fushu.size() > 1)
        {
            Max = fushu[0] * nums[1] * zhengshu[zhengshu.size() - 1];
        }
        // 遍历已排序的数组，计算三个最大的数的乘积
        for (int i = len - 1; i > 0; --i)
        {
            firstNum = nums[i + 1];                 // 取最大的数
            secondNum = nums[i];                    // 取第二大的数
            thirdNum = nums[i - 1];                 // 取第三大的数
            temp = firstNum * secondNum * thirdNum; // 计算乘积
            // 更新最大乘积
            if (temp > Max)
            {
                Max = temp;
            }
        }
        return Max; // 返回最大乘积
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

    double findMaxAverage(vector<int> &nums, int k)
    {
        // 当数组只有一个元素时，直接返回该元素
        if (nums.size() == 1)
            return nums[0];
        // 当 k 为 1 时，找出数组中的最大元素
        if (k == 1)
        {
            int max = nums[0];  // 初始化最大值为数组的第一个元素
            for (auto n : nums) // 遍历数组
            {
                if (max < n) // 如果找到更大的元素
                    max = n; // 更新最大值
            }
            return max; // 返回最大值
        }
        // 计算初始的 k 个元素的累加和
        double result = static_cast<double>(accumulate(&nums[0], &nums[k], 0));
        double temp = 0; // 临时变量用于存储当前子数组的和
        // 遍历数组以寻找最大平均值
        for (int i = 0, j = k + i - 1; j + 1 < nums.size(); ++i, ++j)
        {
            // 如果下一个元素大于当前的第一个元素
            if (nums[j + 1] > nums[i])
            {
                // 计算新的子数组的和
                temp = static_cast<double>(accumulate(&nums[i + 1], &nums[j + 2], 0));
                // 如果新的子数组和大于当前结果
                if (temp > result)
                    result = temp; // 更新结果
            }
        }
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

    int findLengthOfLCIS(vector<int> &nums)
    {
        int len = 1;    // 记录最长连续递增子序列的长度
        int temp = len; // 用于临时存储当前递增子序列的长度
        // 遍历数组，寻找连续递增的子序列
        for (int i = 0; i < nums.size() - 1; ++i)
        {
            // 如果当前元素小于下一个元素，说明是递增的
            if (nums[i] < nums[i + 1])
            {
                ++temp; // 当前递增子序列长度加1
                // 更新最长子序列的长度
                if (len < temp)
                {
                    len = temp;
                }
            }
            else
            {
                temp = 1; // 如果不是递增，则重置 temp 为 1
            }
        }
        // 如果最长子序列长度为1，则返回当前的 temp 值
        return len == 1 ? temp : len;
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

    int findShortestSubArray(vector<int> &nums)
    {
        int arr[50000] = {};  // 用于存储每个数字出现的频率
        int du = -1;          // 数组的度（最大频率）
        int len = 0;          // 当前计算的长度
        int minlen = INT_MAX; // 最短长度，初始化为最大整数
        vector<int> dus;      // 存储出现次数等于数组度的数字
        vector<int> lens;     // 存储对应的连续子数组的长度
        // 统计每个数字的出现频率
        for (auto n : nums)
        {
            ++arr[n]; // 对数字进行计数
        }
        // 迭代频率数组，找到数组的度和对应数字
        for (int i = 0; i < 50000; ++i)
        {
            if (arr[i] == du) // 如果当前次数等于最大次数
            {
                dus.push_back(i); // 将数字添加到候选数组中
            }
            if (arr[i] > du) // 如果当前次数超过最大次数
            {
                du = arr[i];      // 更新最大次数
                dus.clear();      // 清空候选数组
                dus.push_back(i); // 添加当前数字
            }
        }
        // 计算每个候选数字出现的连续子数组的长度
        for (auto m : dus)
        {
            int temp = du;         // 记录要找到的次数
            int i = 0, first = -1; // first用于记录第一次出现的位置
            for (; i < nums.size(); ++i)
            {
                if (nums[i] == m) // 如果当前数字是候选数字
                {
                    if (first == -1) // 第一次出现
                        first = i;   // 记录位置
                    --temp;          // 次数减1
                }
                if (temp == 0) // 当找到足够的次数时，跳出循环
                    break;
            }
            len = i - first + 1; // 计算连续子数组的长度
            lens.push_back(len); // 记录长度
        }
        // 找到最短的长度
        for (auto s : lens)
        {
            if (minlen >= s) // 如果当前长度小于最小长度
                minlen = s;  // 更新最小长度
        }
        return minlen; // 返回最短长度
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

    bool isOneBitCharacter(vector<int> &bits)
    {
        // 如果只有一个比特，并且是0，说明最后一个字符是一个一比特字符
        if (bits.size() == 1)
            return true;
        bool flag = true;             // 标志变量，初始为true
        bits.insert(bits.begin(), 0); // 在数组开头插入0，以便简化后续处理
        int len = bits.size();        // 获取数组的长度
        // 从倒数第二个元素开始逆向遍历
        for (int i = len - 2; i >= 0; --i)
        {
            if (bits[i] == 0) // 找到一比特字符的起始点
            {
                // 计算从当前位到最后一位的距离，如果是偶数则最后一个字符是一个一比特字符
                flag = (((len - 1) - i) - 1) % 2 == 0 ? true : false;
                break; // 找到后退出循环
            }
        }
        return flag; // 返回结果
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

    int pivotIndex(vector<int> &nums)
    {
        auto beg = nums.begin(); // 数组的起始迭代器
        auto end = nums.end();   // 数组的结束迭代器
        int result = -1;         // 初始化结果为 -1
        int leftSum = 0;         // 左侧元素的和
        int rightSum = 0;        // 右侧元素的和
        // 从后向前遍历数组
        for (int i = nums.size() - 1; i >= 0; --i)
        {
            auto it = nums.begin() + i; // 当前元素的迭代器
            // 计算左侧元素的和
            leftSum = (i == 0) ? 0 : accumulate(beg, it, 0);
            // 计算右侧元素的和
            rightSum = (i == nums.size() - 1) ? 0 : accumulate(it + 1, end, 0);
            // 如果左侧和等于右侧和，则更新结果
            if (leftSum == rightSum)
                result = i; // 找到中心下标
        }
        return result; // 返回找到的中心下标
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

    int dominantIndex(vector<int> &nums)
    {
        vector<int> temp = nums;        // 创建一个副本以保留原始数组
        sort(nums.begin(), nums.end()); // 对数组进行排序
        // 检查最大元素是否至少是第二大元素的两倍
        if (nums[nums.size() - 1] / 2 >= nums[nums.size() - 2])
        {
            int max = nums[nums.size() - 1]; // 获取最大元素
            // 遍历原始数组查找最大元素的下标
            for (int i = 0; i < temp.size(); ++i)
            {
                if (max == temp[i]) // 如果找到了最大元素
                    return i;       // 返回其下标
            }
        }
        return -1; // 如果条件不满足，返回 -1
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

    vector<vector<int>> largeGroupPositions(string s)
    {
        // 如果字符串长度小于 3，或者长度为 3 但三个字符不相同，则返回空结果
        if (s.length() < 3 || (s.length() == 3 && s[0] != s[1]))
            return {};
        // 在字符串末尾添加一个不会出现的字符，便于处理最后一个分组
        s.push_back('0');
        vector<int> temp;           // 用于存储当前较大分组的起始和结束位置
        vector<vector<int>> result; // 存储所有较大分组的结果
        // 遍历字符串的每个字符
        for (int i = 0; i < s.length(); ++i)
        {
            // 如果 temp 不为空且当前字符与 temp 开始字符不同，表示一个分组结束
            if (!temp.empty() && s[i] != s[temp[0]])
            {
                temp.push_back(i - 1);  // 添加当前分组的结束位置
                result.push_back(temp); // 将当前分组添加到结果中
                temp.clear();           // 清空 temp，准备下一个分组
            }
            // 如果 temp 不为空且当前字符与 temp 开始字符相同，继续
            if (!temp.empty() && s[i] == s[temp[0]])
            {
                continue;
            }
            // 检查当前字符是否与后面的两个字符相同
            if (s[i] == s[i + 1] && s[i] == s[i + 2])
            {
                temp.push_back(i); // 记录当前分组的起始位置
                i += 2;            // 跳过后两个相同字符
            }
        }
        return result; // 返回所有的较大分组
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

    vector<int> fairCandySwap(vector<int> &aliceSizes, vector<int> &bobSizes)
    {
        // 计算爱丽丝和鲍勃的糖果总量
        int sumA = accumulate(aliceSizes.begin(), aliceSizes.end(), 0), // 爱丽丝的糖果总和
            sumB = accumulate(bobSizes.begin(), bobSizes.end(), 0),     // 鲍勃的糖果总和
            // 计算糖果数量的差的一半
            Cab = (sumB - sumA) / 2; // 糖果数量差的一半，用于计算交换数量
        int x = 0;       // 临时变量，用于存储需要交换的糖果数量
        vector<int> res; // 存储答案的数组
        // 遍历爱丽丝的每一盒糖果
        for (const auto &m : aliceSizes)
        {
            x = m - Cab; // 计算需要交换的糖果数量
            // 遍历鲍勃的每一盒糖果
            for (const auto &n : bobSizes)
            {
                // 如果爱丽丝的糖果数量减去 Cab 等于鲍勃的某盒糖果数量，则找到解
                if (x == n)
                {
                    return vector<int>{m, n}; // 返回爱丽丝和鲍勃各自要交换的糖果数量
                }
            }
        }
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

    bool hasGroupsSizeX(vector<int> &deck)
    {
        array<int, 10001> arr = {}; // 初始化一个数组，用于记录每个数字出现的次数
        for (const auto v : deck)   // 遍历牌组
        {
            ++arr[v]; // 统计每个数字出现的次数
        }
        sort(arr.begin(), arr.end()); // 对出现次数进行排序
        int i = 0;
        while (arr[i] == 0) // 找到第一个非零的出现次数
        {
            ++i;
        }
        int temp = 0, a = 0, b = 0, result = arr[i]; // 初始化变量，用于后续计算
        // 计算所有出现次数的最大公约数
        for (; i < arr.size(); ++i)
        {
            a = arr[i];
            // 利用辗转相除法计算最大公约数
            while (a != 0)
            {
                temp = a;
                a = result % a; // 计算余数
                result = temp;  // 更新 result
            }
        }
        // 判断最大公约数是否大于等于 2
        if (result >= 2)
            return true; // 可以分组
        else
            return false; // 无法分组
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

    bool validMountainArray(vector<int> &arr)
    {
        // 如果数组的大小小于 3，无法构成山脉
        if (arr.size() < 3)
            return false;
        int i = 0, j = arr.size() - 1; // 初始化两个指针，i 从前往后，j 从后往前
        // 从前往后查找递增的部分
        while (arr[i + 1] > arr[i])
        {
            ++i; // 增加指针 i
            // 如果 i 到达数组的最后一个元素，跳出循环
            if (i + 1 == arr.size())
                break;
        }
        // 从后往前查找递减的部分
        while (arr[j - 1] > arr[j])
        {
            --j; // 减少指针 j
            // 如果 j 到达数组的第一个元素，跳出循环
            if (j - 1 == -1)
                break;
        }
        // 检查两个指针是否相遇，如果相遇且不是在两端，则说明是有效的山脉数组
        return (i == j ? (i == arr.size() - 1 ? false : (j == 0 ? false : true)) : false);
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

    vector<int> addToArrayForm(vector<int> &num, int k)
    {
        vector<int> res;        // 存储结果的数组
        int digit = 0, sum = 0; // digit 用于存储当前的数字，sum 用于存储当前的和
        // 从 num 的末尾开始遍历
        for (int i = num.size() - 1; i >= 0; --i)
        {
            digit = k % 10;       // 获取 k 的最后一位数字
            sum = digit + num[i]; // 计算当前位的和
            k /= 10;              // 将 k 向右移动一位
            // 检查和是否大于 9
            if (sum > 9)
            {
                ++k;            // 如果和大于 9，进位
                sum = sum % 10; // 只保留当前位的数字
            }
            res.push_back(sum); // 将当前位的和添加到结果数组中
        }
        // 如果 k 还有剩余的数字，则继续处理
        while (k > 0)
        {
            res.push_back(k % 10); // 将 k 的最后一位数字添加到结果中
            k /= 10;               // 将 k 向右移动一位
        }
        reverse(res.begin(), res.end()); // 将结果数组反转，使其符合从左到右的顺序
        return res; // 返回最终的结果
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

    int numEquivDominoPairs(vector<vector<int>> &dominoes)
    {
        map<vector<int>, int> count; // 用于存储每种骨牌的出现次数
        int sum = 0;                 // 计数相等骨牌对的数量
        for (auto &v : dominoes) // 遍历每一张骨牌
        {
            if (v[0] > v[1])      // 确保骨牌的顺序为小到大
                swap(v[0], v[1]); // 交换骨牌的两个数字
            ++count[v];           // 增加该骨牌的出现次数
        }
        for (const auto &n : count) // 遍历所有骨牌的计数
        {
            sum += n.second * (n.second - 1) / 2; // 根据组合公式计算等价骨牌对的数量
        }
        return sum; // 返回结果
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

    int maxArea(vector<int> &height)
    {
        int left = 0, right = height.size() - 1, h = 0, // 初始化左右指针和高度变量
            capacity = 0, maxCapacity = 0;              // 容量和最大容量初始化
        while (left != right) // 当左右指针相遇时停止
        {
            h = min(height[left], height[right]); // 取较小的高度作为限制
            capacity = (right - left) * h;        // 计算当前容器的容量
            if (capacity > maxCapacity) // 更新最大容量
                maxCapacity = capacity;
            // 移动指针，选择高度较小的一边进行移动
            if (height[left] < height[right])
                ++left; // 向右移动左指针
            else
                --right; // 向左移动右指针
        }
        return maxCapacity; // 返回最大容量
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

    int findUnsortedSubarray(vector<int> &nums)
    {
        // 如果数组只有一个元素，则不需要排序，直接返回0
        if (nums.size() == 1)
            return 0;
        int maxLeft = nums[0], minRight = nums[nums.size() - 1];
        int left = 0, right = nums.size() - 1;
        // 从左到右遍历数组，找出无序子数组的左边界
        for (int i = 0; i < nums.size(); ++i)
        {
            // 如果当前元素大于等于当前最大值，则更新最大值
            if (nums[i] >= maxLeft)
            {
                maxLeft = nums[i];
            }
            // 否则，更新左边界
            else
            {
                left = i;
            }
        }
        // 从右到左遍历数组，找出无序子数组的右边界
        for (int j = nums.size() - 1; j >= 0; --j)
        {
            // 如果当前元素小于等于当前最小值，则更新最小值
            if (nums[j] <= minRight)
            {
                minRight = nums[j];
            }
            // 否则，更新右边界
            else
            {
                right = j;
            }
        }
        // 返回无序子数组的长度，如果没有无序子数组则返回0
        return left > right ? left - right + 1 : 0;
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

    bool checkPossibility(vector<int> &nums)
    {
        int count = 0;                            // 计数器，用于统计改变的次数
        nums.insert(nums.begin(), INT_MIN);       // 在数组开头插入一个最小值，方便比较
        nums.push_back(INT_MAX);                  // 在数组末尾插入一个最大值，方便比较
        for (int i = 1; i < nums.size() - 1; ++i) // 遍历数组，排除开头和结尾的插入值
        {
            // 如果当前元素小于前一个元素或大于后一个元素，则需要进行处理
            if (nums[i] < nums[i - 1] || nums[i] > nums[i + 1])
            {
                // 如果当前元素小于前一个元素并且大于后一个元素，则无法通过改变一个元素来满足条件
                if (nums[i] < nums[i - 1] && nums[i] > nums[i + 1])
                {
                    return false; // 返回false
                }
                else if (nums[i] < nums[i - 1]) // 如果当前元素小于前一个元素
                {
                    // 如果前一个元素大于后一个元素，改变前一个元素
                    if (nums[i - 1] > nums[i + 1])
                    {
                        nums[i - 1] = nums[i];
                    }
                    else // 否则，改变当前元素
                    {
                        nums[i] = nums[i - 1];
                    }
                    ++count; // 改变次数加1
                    // 检查前两个元素的顺序
                    if (nums[i - 1] < nums[i - 2])
                        return false; // 如果顺序仍然不对，返回false
                }
                else if (nums[i] > nums[i + 1]) // 如果当前元素大于后一个元素
                {
                    // 如果后一个元素大于等于前一个元素，改变当前元素
                    if (nums[i + 1] >= nums[i - 1])
                    {
                        nums[i] = nums[i + 1];
                    }
                    else // 否则，改变后一个元素
                    {
                        nums[i + 1] = nums[i];
                    }
                    ++count; // 改变次数加1
                }
                // 如果改变次数超过1，则返回false
                if (count > 1)
                    return false;
            }
        }
        return true; // 如果变换可以成功返回true
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

    int numMagicSquaresInside(vector<vector<int>> &grid)
    {
        int row = grid.size(); // 获取行数
        int col = grid[0].size(); // 获取列数
        // 如果行数或列数小于3，则无法形成任何3x3的幻方
        if (row < 3 || col < 3)
            return 0;
        // contrast代表每行、列、对角线和应该为15，count用于统计符合条件的幻方个数
        int contrast = 15, count = 0; 
        // 遍历每个可能的3x3子矩阵
        for (int i = 0; i < row - 2; ++i)
        {
            for (int j = 0; j < col - 2; ++j)
            {
                int flag = true; // 标记变量，用于判断当前子矩阵是否合法
                vector<int> nums(10, 0); // 用于记录出现数字的次数（0-15的数字）
                // 遍历3x3子矩阵中的所有元素
                for (int m = i; m < i + 3; ++m)
                {
                    for (int n = j; n < j + 3; ++n)
                    {
                        // 检查数字是否在1-9之间且是否唯一
                        if (grid[m][n] > 9 || nums[grid[m][n]] == 1)
                            flag = false; // 如果不符合条件，设置flag为false
                        else
                            ++nums[grid[m][n]]; // 计数
                        if (flag == false)
                            break; // 提前退出
                    }
                    if (flag == false)
                        break; // 提前退出
                }
                if (flag == false)
                    continue; // 如果当前子矩阵不合法，则跳过
                // 计算3行、3列与2条对角线的和
                int row1 = grid[i][j] + grid[i][j + 1] + grid[i][j + 2],
                    row2 = grid[i + 1][j] + grid[i + 1][j + 1] + grid[i + 1][j + 2],
                    row3 = grid[i + 2][j] + grid[i + 2][j + 1] + grid[i + 2][j + 2],
                    col1 = grid[i][j] + grid[i + 1][j] + grid[i + 2][j],
                    col2 = grid[i][j + 1] + grid[i + 1][j + 1] + grid[i + 2][j + 1],
                    col3 = grid[i][j + 2] + grid[i + 1][j + 2] + grid[i + 2][j + 2],
                    diag1 = grid[i][j] + grid[i + 1][j + 1] + grid[i + 2][j + 2],
                    diag2 = grid[i + 2][j] + grid[i + 1][j + 1] + grid[i][j + 2];
                // 判断是否所有和都等于15
                if (row1 != contrast || row2 != contrast || row3 != contrast ||
                    col1 != contrast || col2 != contrast || col3 != contrast ||
                    diag1 != contrast || diag2 != contrast)
                    continue; // 如果不等于15，则继续
                else
                    ++count; // 如果满足条件，增加幻方计数
            }
        }
        return count; // 返回符合条件的幻方数量
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

    int maxDistToClosest(vector<int> &seats)
    {
        int index = 0;           // 存储离亚历克斯最近人的位置
        int count = 0;           // 当前空座位的计数
        int leftmaxDistance = 0; // 左侧最大距离
        int maxDistance = 0;     // 最大距离
        // 在数组末尾添加一个人以处理边界情况
        seats.push_back(1);
        for (int i = 0; i < seats.size(); ++i)
        {
            if (seats[i] == 1) // 如果当前座位有人
            {
                // 更新最大距离和索引
                if (count > maxDistance)
                {
                    maxDistance = count; // 更新最大距离
                    index = i;           // 更新索引
                }
                // 如果当前座位的左侧全都没有人，即从左至右遍历的过程中遇到的第一个有人座的位置，就更新左侧最大距离(处理左边界)
                if (i - count == 0)
                {
                    leftmaxDistance = count;
                }
                // 如果当前最大距离的一半小于左侧最大距离，更新最大距离(处理非边界情况)
                if (maxDistance / 2 < leftmaxDistance)
                {
                    maxDistance = leftmaxDistance;
                    index = i; // 更新索引
                }
                // 处理最后一个人坐的位置(处理右边界)
                if (i == seats.size() - 1)
                {
                    if (maxDistance / 2 < count && count > leftmaxDistance)
                    {
                        maxDistance = count; // 更新最大距离
                        index = i;           // 更新索引
                    }
                }
                count = 0; // 重置计数
            }
            else
                ++count; // 如果座位为空，计数加一
        }
        // 根据索引和最大距离返回结果
        if (index == seats.size() - 1 || index - maxDistance == 0)
            return maxDistance; // 如果亚历克斯在最后位置或边缘返回最大距离
        else
            return maxDistance % 2 == 0 ? maxDistance / 2 : (maxDistance + 1) / 2; // 根据最大距离的奇偶性返回结果
    }