网传长安28岁工程师猝死吐血而亡

编码如写诗

发布于 2026-02-03 17:34:50

2030

文章被收录于专栏：编码如写诗编码如写诗

今天在脉脉上刷到一个让我原地去世的帖子。

一个运营经理爆料：长安网传有一位28岁工程师猝死，叫黄炜杰，2025年6月11日入职长安凯程，今年1月30号周五凌晨吐血而亡。长安方面暂未回应。

28岁，刚入职半年多，人就没了。

帖子下面有61条评论，我翻了翻，几条热评让我心里发凉：

"这年头，28岁就不算年轻了，35岁更是坎。"

"国企也不一定安全，压榨起来一个样。"

"我就想知道，这孩子最后一通电话打给了谁？"

"吐血而亡……这得多累才能累到吐血啊。"

看到这些评论，我第一反应是愤怒。一个28岁的人，刚入职半年就倒下，公司连个像样的说法都没有？这算什么事？

但冷静下来，我觉得这事吧，先分两头看。

从企业角度看，长安凯程是长安汽车的子公司，也算正经车企。如果真因为过度劳累导致员工死亡，按照《工伤保险条例》，这属于工伤，公司必须赔偿。但问题在于，现在没有官方通报，也没有家属发声，所有信息都来自脉脉这个"爆料"，真实性存疑。

从员工角度看，28岁本该是人生最好的年纪，刚入职新公司半年，可能还在转正期，或者刚转正没多久。这个阶段的职场人，谁不想表现好一点？谁不想证明自己？所以可能会主动加班，主动承担责任，主动接更多活。

我认识一个在互联网公司工作的哥们，入职第一年基本是996，他说："刚进去不敢请假，不敢准点下班，怕领导觉得自己不努力。"结果体检发现甲状腺结节，胃也有问题，现在每天得吃一堆药。

从我的角度看，这件事的核心不在于是不是长安，也不在于是不是国企，而在于我们整个职场环境对年轻人的压榨。不管是互联网、制造业还是其他行业，年轻人似乎永远是最好用的"燃料"——精力旺盛、有冲劲、还没家庭负担，用起来不心疼。

但问题是，这些"燃料"也是人啊，也有极限。

我见过太多这样的案例：刚毕业的小伙子，为了证明自己，连续加班一个月，最后晕倒在工位上；刚升职的组长，为了团队业绩，每天只睡4-5个小时，最后得了焦虑症；刚入职的妹子，不敢拒绝领导安排，周末也来加班，最后体检报告一片红。

这些人的共同点是什么？他们都很努力，都很想证明自己，但都忘了——身体才是革命的本钱。

当然，也有人会说："现在的年轻人太娇气了，我们当年更苦。"这种话我听了无数遍，但每次都想说：时代在进步，人的价值观念也在进步，不能用过去的标准来要求现在的人。

更重要的是，职场不是战场，不需要你以命相搏。一份工作而已，不值得你透支健康，更不值得你用命去换。

说回这件事，我真心希望长安能给出一个明确的说法。如果真是因为工作原因导致的过度劳累，该赔偿就赔偿，该追责就追责。如果不是，也该及时澄清，给家属一个交代，给公众一个答案。

但更重要的是，希望看到这篇文章的你，能好好爱惜自己的身体。工作没了可以再找，钱没了可以再赚，但命只有一条。

身体在，一切都在。

好，聊回技术。来各算法题。

算法题：Maximum Subarray

题目理解

给你一个整数数组 nums，找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

举个例子，nums = [-2,1,-3,4,-1,2,1,-5,4]，最大和的子数组是 [4,-1,2,1]，和是6。

这题其实挺有意思的，让我想到一个比喻：找子数组就像在路上走，走到每一步都要决定是继续往前走，还是重新从这一步开始。

思路分析

暴力解法：两层循环枚举所有可能的子数组，计算每个子数组的和，取最大值。时间复杂度是O(n²)，空间复杂度是O(1)。

这个思路简单粗暴，但效率太低。当n很大时，会超时。

优化思路：用动态规划。定义dp[i]表示以nums[i]结尾的子数组的最大和。那么dp[i]要么是nums[i]自己（重新开始），要么是dp[i-1] + nums[i]（延续前面的）。

状态转移方程：dp[i] = max(nums[i], dp[i-1] + nums[i])

最后，dp数组中的最大值就是答案。

进一步优化空间：我们只需要dp[i-1]，不需要整个dp数组，用一个变量记录就行。

复杂度分析

时间复杂度：O(n)，只需要遍历数组一次
空间复杂度：O(1)，只需要常数级别的额外空间

代码实现

package main

import (
    "fmt"
    "math"
)

func maxSubArray(nums []int) int {
    if len(nums) == 0 {
        return 0
    }

    maxSum := nums[0]
    currentSum := nums[0]

    for i := 1; i < len(nums); i++ {
        // 决定是延续前面的子数组，还是重新开始
        currentSum = max(nums[i], currentSum+nums[i])
        // 更新最大和
        maxSum = max(maxSum, currentSum)
    }

    return maxSum
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

// 带边界的版本，处理空数组
func maxSubArraySafe(nums []int) int {
    if len(nums) == 0 {
        return 0
    }

    maxSum := math.MinInt64
    currentSum := 0

    for _, num := range nums {
        currentSum = max(num, currentSum+num)
        maxSum = max(maxSum, currentSum)
    }

    return maxSum
}

// 返回最大和的子数组
func maxSubArrayWithSub(nums []int) (int, []int) {
    if len(nums) == 0 {
        return 0, []int{}
    }

    maxSum := math.MinInt64
    currentSum := 0
    start, end := 0, 0
    tempStart := 0

    for i, num := range nums {
        if currentSum < 0 {
            currentSum = num
            tempStart = i
        } else {
            currentSum += num
        }

        if currentSum > maxSum {
            maxSum = currentSum
            start = tempStart
            end = i
        }
    }

    return maxSum, nums[start : end+1]
}

func main() {
    // 测试用例1
    nums1 := []int{-2, 1, -3, 4, -1, 2, 1, -5, 4}
    fmt.Printf("数组: %v\n", nums1)
    fmt.Printf("最大子数组和: %d\n\n", maxSubArray(nums1))

    // 测试用例2
    nums2 := []int{1}
    fmt.Printf("数组: %v\n", nums2)
    fmt.Printf("最大子数组和: %d\n\n", maxSubArray(nums2))

    // 测试用例3
    nums3 := []int{5, 4, -1, 7, 8}
    fmt.Printf("数组: %v\n", nums3)
    fmt.Printf("最大子数组和: %d\n\n", maxSubArray(nums3))

    // 测试用例4 - 全是负数
    nums4 := []int{-2, -1, -3}
    fmt.Printf("数组: %v\n", nums4)
    fmt.Printf("最大子数组和: %d\n\n", maxSubArray(nums4))

    // 测试子数组返回
    maxSum, sub := maxSubArrayWithSub(nums1)
    fmt.Printf("最大子数组和: %d, 子数组: %v\n", maxSum, sub)
}