算法刷题技巧：阶乘因子与回文数等经典题型解析

1. 算法刷题笔记：常见编程题型的解题思路与实现

作为一名计算机专业的学生，算法刷题是提升编程能力的必经之路。今天我将分享在准备复试过程中遇到的几道典型编程题目，包括阶乘因子统计、数字串处理、回文数判断等常见题型。这些题目看似基础，但蕴含着许多值得深入探讨的编程技巧和算法思想。

1.1 阶乘中的因子统计问题

1.1.1 问题描述与基础解法

题目要求计算n!（n的阶乘）中末尾有多少个连续的0。这个问题看似简单，但实际上需要理解数学原理才能高效解决。我们知道，末尾的0是由因子10产生的，而10=2×5。在阶乘中，2的因子数量远多于5的因子数量，因此问题转化为计算n!中5的因子个数。

最直观的解法是对每个数从1到n，统计其包含的5的因子数量，然后累加：

cpp复制int countTrailingZeros(int n) {
    int cnt = 0;
    for(int i = 1; i <= n; i++) {
        int temp = i;
        while(temp % 5 == 0) {
            cnt++;
            temp /= 5;
        }
    }
    return cnt;
}

这种方法的时间复杂度是O(nlogn)，对于小规模的n足够使用，但当n很大时效率不高。

1.1.2 优化解法：数学规律应用

更高效的解法是利用数学规律：n!中5的因子数量等于n/5 + n/25 + n/125 + ...，直到n/5^k为0为止。这是因为每隔5个数会出现一个5的倍数，每隔25个数会出现一个25的倍数（贡献两个5因子，但其中一个已经在5的倍数中统计过），以此类推。

优化后的代码如下：

cpp复制int countTrailingZeros(int n) {
    int cnt = 0;
    while(n > 0) {
        n /= 5;
        cnt += n;
    }
    return cnt;
}

这个算法的时间复杂度是O(logn)，效率显著提升。在实际编程竞赛中，这种数学优化往往能带来性能的飞跃。

注意：虽然2的因子数量更多，但统计5的数量已经足够，因为2的数量总是过剩的。如果题目要求的是n!的二进制表示末尾有多少个0，那么就需要统计2的因子数量了。

1.2 数字串中的最长连续数字

1.2.1 问题分析与解法

题目要求找出数组中最长的连续相同数字序列，并返回该数字及其长度。这是一个典型的线性扫描问题，可以使用单次遍历解决。

关键思路是维护两个变量：current记录当前正在统计的数字，cnt记录当前数字的连续长度。同时用res和max_cnt记录最终结果。算法从第二个元素开始遍历，比较当前元素与current：

cpp复制int findLongestConsecutive(const vector<int>& a) {
    if(a.empty()) return -1; // 处理空数组情况
    
    int res = a[0], current = a[0];
    int max_cnt = 1, cnt = 1;
    
    for(int i = 1; i < a.size(); i++) {
        if(current == a[i]) {
            cnt++;
        } else {
            current = a[i];
            cnt = 1;
        }
        
        if(max_cnt < cnt) {
            max_cnt = cnt;
            res = current;
        }
    }
    
    return res; // 返回最长连续数字
    // 如果需要同时返回长度，可以使用pair或结构体
}

1.2.2 边界情况处理

在实际编码中，有几个边界情况需要注意：

1. 空数组输入：应该返回特定值或抛出异常
2. 所有数字都不同：应该返回第一个元素和长度1
3. 多个相同长度的序列：根据题目要求返回第一个或最后一个

这个算法的空间复杂度是O(1)，时间复杂度是O(n)，是最优解法。类似的思路可以应用于许多字符串处理问题，如最长无重复字符子串等。

1.3 回文数判断与数字逆序

1.3.1 回文数判断方法

回文数是指正读反读都相同的数字，如121、1331等。判断一个整数是否是回文数，可以将数字逆序后与原数比较：

cpp复制bool isPalindrome(int n) {
    if(n < 0) return false; // 负数不是回文数
    int reversed = 0, original = n;
    while(n > 0) {
        reversed = reversed * 10 + n % 10;
        n /= 10;
    }
    return original == reversed;
}

1.3.2 数字逆序的实现

数字逆序是一个基础但重要的操作，实现时需要注意：

1. 处理负数：可以先取绝对值再逆序，最后恢复符号
2. 溢出问题：逆序后数字可能超出int范围，需要检查
3. 末尾0的处理：如100逆序后应为1，不是001

改进后的逆序函数：

cpp复制int reverseNumber(int n) {
    int reversed = 0;
    while(n != 0) {
        // 检查溢出
        if(reversed > INT_MAX/10 || reversed < INT_MIN/10) return 0;
        reversed = reversed * 10 + n % 10;
        n /= 10;
    }
    return reversed;
}

1.4 浮点数四舍五入处理

1.4.1 实现方法

题目要求将浮点数保留一位小数并进行四舍五入。利用整数运算的特性可以避免浮点数精度问题：

cpp复制double roundToOneDecimal(double num) {
    int temp = num * 10; // 将小数点后第一位变为整数部分
    double decimal = num * 10 - temp; // 获取小数点后第二位
    
    if(decimal >= 0.5) {
        temp++;
    }
    
    return static_cast<double>(temp) / 10;
}

1.4.2 浮点数处理注意事项

处理浮点数时常见问题：

1. 精度损失：浮点数运算可能存在微小误差
2. 负数处理：上述代码对负数也适用，因为-1.56*10=-15.6，转为int是-15，decimal是-0.6
3. 边界情况：如恰好为0.5时的处理规则（银行家舍入法）

更健壮的实现可以考虑使用标准库函数：

cpp复制#include <cmath>
#include <iomanip>

double roundStandard(double num) {
    return std::round(num * 10) / 10;
}

// 输出时控制精度
std::cout << std::fixed << std::setprecision(1) << num;

1.5 黑色星期五问题

1.5.1 问题描述与解法

题目要求计算在n年中，每个月的13号落在星期一到星期日的次数，特别是落在星期五的次数（黑色星期五）。这是一个典型的日期计算问题，需要处理闰年和月份天数。

核心算法思路：

1. 已知1900年1月1日是星期一
2. 对于每一年，计算每个月的13日是星期几
3. 根据当前月份的天数，更新下个月1日是星期几

实现代码：

cpp复制#include <vector>
#include <iostream>

using namespace std;

bool isLeap(int year) {
    return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
}

int getDaysInMonth(int year, int month) {
    if(month == 2) return isLeap(year) ? 29 : 28;
    if(month == 4 || month == 6 || month == 9 || month == 11) return 30;
    return 31;
}

vector<int> countBlackFridays(int n) {
    vector<int> counts(7, 0); // 0-6对应周日到周六
    int firstDay = 1; // 1900-01-01是周一(1)
    
    for(int y = 1900; y < 1900 + n; y++) {
        for(int m = 1; m <= 12; m++) {
            int thirteenthDay = (firstDay + 12) % 7;
            counts[thirteenthDay]++;
            
            firstDay = (firstDay + getDaysInMonth(y, m)) % 7;
        }
    }
    
    return counts;
}

1.5.2 日期计算技巧

处理日期相关问题时的常用技巧：

1. 使用Zeller公式可以直接计算某一天是星期几
2. 对于固定起始日期的问题，可以预先计算基准日
3. 注意闰年的判断规则（能被4整除但不能被100整除，或能被400整除）
4. 月份天数可以用数组预先存储，避免重复计算

1.6 树木统计问题

1.6.1 问题分析与解法

题目描述：一条路上有编号0到L的树，给出若干区间需要移走这些区间的树，最后计算剩下的树的数量。有两种解法：

方法一：使用pair存储区间，排序后合并重叠区间

cpp复制#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

int remainingTrees(int L, const vector<pair<int, int>>& ranges) {
    vector<pair<int, int>> sortedRanges = ranges;
    sort(sortedRanges.begin(), sortedRanges.end());
    
    int removed = 0;
    int start = sortedRanges[0].first;
    int end = sortedRanges[0].second;
    
    for(const auto& range : sortedRanges) {
        if(range.first <= end) { // 有重叠
            end = max(end, range.second);
        } else { // 无重叠
            removed += end - start + 1;
            start = range.first;
            end = range.second;
        }
    }
    removed += end - start + 1; // 最后一段
    
    return L + 1 - removed; // 总树数是L+1
}

方法二：使用unordered_set记录所有被移除的树

cpp复制#include <unordered_set>

int remainingTreesWithSet(int L, const vector<pair<int, int>>& ranges) {
    unordered_set<int> removedTrees;
    
    for(const auto& range : ranges) {
        for(int i = range.first; i <= range.second; i++) {
            removedTrees.insert(i);
        }
    }
    
    return L + 1 - removedTrees.size();
}

1.6.2 算法选择考量

两种方法各有优劣：

1. pair排序法：

   • 优点：空间复杂度O(m)，m是区间数量
   • 缺点：需要排序，时间复杂度O(mlogm)
   • 适合区间数量少但范围大的情况

2. unordered_set法：

   • 优点：实现简单，时间复杂度O(n)，n是移除的树总数
   • 缺点：空间复杂度O(n)，当n很大时会消耗大量内存
   • 适合区间密集但范围小的情况

在实际应用中，应根据问题规模选择合适的算法。如果L很大（如1e9），但区间数量少（如1e5），则第一种方法更优；如果L较小（如1e6），则第二种方法可能更简单直接。

1.7 算法学习心得与技巧

在刷题过程中，我总结了一些有用的技巧：

1. 数学思维很重要：许多看似复杂的问题都有数学规律可循，如阶乘末尾零的问题
2. 边界条件测试：空输入、极值、负数等特殊情况要特别注意
3. 空间换时间：合理使用哈希表等数据结构可以简化问题
4. 代码复用：像isLeapYear、reverseNumber这样的函数可以积累成工具库
5. 调试技巧：对于复杂逻辑，可以添加中间输出验证算法正确性

算法能力的提升需要持续练习和总结。每解决一个问题，不仅要写出代码，更要理解背后的思想和可能的变种。例如，学会了统计阶乘中的因子5，可以扩展到统计任意质因子的数量；掌握了最长连续数字的解法，可以推广到最长递增序列等问题。