蓝桥杯JavaB组省赛复盘：从“阶乘求和”到“数组分割”，聊聊我踩过的那些坑和思维误区

weixin_33726313

622人浏览 · 2026-05-28 09:23:18

weixin_33726313 · 2026-05-28 09:23:18 发布

蓝桥杯JavaB组省赛深度复盘：从思维误区到实战突破

去年参加蓝桥杯的经历至今记忆犹新，那些在赛场上绞尽脑汁却不得其解的瞬间，那些赛后恍然大悟的顿悟时刻，都成为了我编程成长路上最宝贵的财富。这篇文章不是简单的真题解析，而是一次彻底的思维解剖，我将以参赛者的第一视角，还原那些让我栽跟头的题目背后的思考过程，以及最终如何跳出思维定式的完整心路历程。

1. 阶乘求和：当完美主义成为绊脚石

面对"S=1!+2!+...+202320232023!求末尾9位数字"这道题，我的第一反应是必须计算出完整的S值。这种追求"完整解"的执念让我陷入了计算深渊：

// 错误思路：试图计算完整阶乘
BigInteger sum = BigInteger.ZERO;
for(int i=1; i<=n; i++){
    BigInteger fact = BigInteger.ONE;
    for(int j=1; j<=i; j++){
        fact = fact.multiply(BigInteger.valueOf(j));
    }
    sum = sum.add(fact);
}

关键思维误区 ：

过度关注问题的表面形式（求和大数）而忽略本质需求（仅需末尾9位）
对模运算的理解停留在表面，未能建立"部分结果即可满足需求"的认知
时间压力下陷入思维固化，无法切换解题视角

突破时刻 ：当意识到40!之后的所有阶乘对末尾9位不再有贡献时，解题方案瞬间明朗：

// 正确解法：实时取模
long MOD = 1000000000L;
long sum = 0;
for(int i=1; i<=40; i++){
    long fact = 1;
    for(int j=1; j<=i; j++){
        fact = (fact * j) % MOD;
    }
    sum = (sum + fact) % MOD;
}

这个教训让我明白： 在算法竞赛中，精确解往往不如合适解，理解问题本质比完整计算更重要 。

2. 幸运数字：当工具思维限制了解题视野

第2023个幸运数字的寻找过程，暴露了我对Java标准库的过度依赖：

// 初始笨拙的进制转换实现
public static int digitSum(int n, int base){
    int sum = 0;
    while(n > 0){
        sum += n % base;
        n /= base;
    }
    return sum;
}

认知盲区 ：

过分依赖 Integer.toString(n, radix) 等现成方法，当需要自定义处理时束手无策
对进制转换的核心原理（除基取余法）理解不深刻
十六进制中字母字符的处理经验不足

优化后的解决方案 ：

// 增强版的进制数字和计算
public static int getDigitSum(int num, int base) {
    int sum = 0;
    while (num > 0) {
        int digit = num % base;
        sum += (digit < 10) ? digit : (digit - 10 + 'a'); // 处理16进制字母
        num /= base;
    }
    return sum;
}

这个题目教会我： 掌握底层原理比记住API更重要，工具应该是思维的延伸而非替代 。

3. 数组分割：当经验成为思维定式

看到"数组分割"这个题目名称，我立即联想到了经典的"数组切分"动态规划问题，这种先入为主的判断导致我陷入了错误方向：

// 错误的DP尝试
int[][] dp = new int[n+1][2]; // dp[i][j]表示前i个元素和为j的奇偶性
dp[0][0] = 1;
for(int i=1; i<=n; i++){
    for(int j=0; j<2; j++){
        dp[i][j] = dp[i-1][j] + dp[i-1][(j-arr[i]+2)%2];
    }
}

误判根源 ：

被题目名称诱导，未深入分析问题特殊性
过度依赖既往解题模式，缺乏灵活变通
没有通过足够多的示例验证思路正确性

组合数学的优雅解法 ：

int evenCount = 0, oddCount = 0;
for(int num : arr){
    if(num % 2 == 0) evenCount++;
    else oddCount++;
}

if(oddCount % 2 != 0){
    return 0; // 无解情况
}

// 有效方案数：2^evenCount * 2^(oddCount-1)
int result = 1;
for(int i=0; i<evenCount; i++){
    result = (result * 2) % MOD;
}
for(int i=0; i<oddCount-1; i++){
    result = (result * 2) % MOD;
}

这个教训尤为深刻： 算法竞赛中，问题表面相似性可能是陷阱，深入分析问题结构才能发现本质解法 。

4. 矩形总面积：当直觉误导计算几何

计算两个轴对齐矩形总面积的问题，暴露了我对计算几何类问题的经验不足：

// 初始的错误区域判断
if(x2<=x3 || x4<=x1 || y2<=y3 || y4<=y1){
    // 无重叠情况
    return (x2-x1)*(y2-y1) + (x4-x3)*(y4-y3);
}else{
    // 错误的重叠区域计算
    int overlapWidth = Math.min(x2,x4) - Math.max(x1,x3);
    int overlapHeight = Math.min(y2,y4) - Math.max(y1,y3);
    return (x2-x1)*(y2-y1) + (x4-x3)*(y4-y3) - overlapWidth*overlapHeight;
}

常见误区 ：

忽略矩形坐标无序性（左下角坐标不一定小于右上角）
重叠区域判断条件不严谨
整数溢出风险未考虑（当坐标值较大时）

健壮的解决方案 ：

// 正确处理坐标无序性和重叠情况
long area1 = Math.abs((long)x2-x1)*Math.abs((long)y2-y1);
long area2 = Math.abs((long)x4-x3)*Math.abs((long)y4-y3);

// 计算重叠区域
long overlapX = Math.min(Math.max(x1,x2), Math.max(x3,x4)) - 
                Math.max(Math.min(x1,x2), Math.min(x3,x4));
long overlapY = Math.min(Math.max(y1,y2), Math.max(y3,y4)) - 
                Math.max(Math.min(y1,y2), Math.min(y3,y4));

long overlapArea = (overlapX >0 && overlapY>0) ? overlapX*overlapY : 0;
return area1 + area2 - overlapArea;

这个题目给我的启示： 计算几何问题需要特别注意边界条件和数值范围，可视化辅助能有效避免逻辑错误 。