leecodecode【面试150】【2026.7.9打卡-java版本】

这个是二维动态集合，基本都是f $i$ $j$ = min/max $i-1$ $j$ / $i$ $j-1$ / $i-1$ $j-1$ + 某个数字

三角形最小路径和

要点：这个是从下到上

java 复制代码

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int n = triangle.size();
        int[][] f = new int[n][n];
        for(int j = 0; j < n; j++){
            f[n-1][j] = triangle.get(n-1).get(j);
        }

        for(int i = n-2; i >= 0; i--){
            for(int j = 0; j <= i; j++){
                f[i][j] = Math.min(f[i+1][j], f[i+1][j+1]) + triangle.get(i).get(j);
            }
        }

        return f[0][0];
        
    }
}

最小路径和

要点：从两个方向过来

java 复制代码

class Solution {
    public int minPathSum(int[][] grid) {
        //二维dp,注意n,m


        int m = grid[0].length;
        int n = grid.length;

        int[][] dp = new int[n][m];


        dp[0][0] = grid[0][0];
        for(int i = 1; i < m; i++){
            dp[0][i] = grid[0][i] + dp[0][i-1];
        }

        for(int j = 1; j <n; j++){
            dp[j][0] =grid[j][0]  + dp[j-1][0];
        }

        for(int i = 1; i < n; i++){
            for(int j = 1; j < m; j++){
                dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
            }
        }

        return dp[n-1][m-1];
        
    }
}

不同路径 II

要点：有个阻碍，阻碍的地方dp=0；

java 复制代码

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
       //二维dp
       int n = obstacleGrid.length;
       int m = obstacleGrid[0].length;
       int[][] dp = new int[n+1][m+1];
        dp[0][1] = 1;
       for(int i = 0; i < n;i++){
        for(int j = 0; j < m; j++){

            if(obstacleGrid[i][j] == 0){
                dp[i+1][j+1] = dp[i][j+1] + dp[i+1][j];
            }
        }
       }

        return dp[n][m];

        
    }
}

最长回文子串

要点：状态转移方程 s $i$ $j$ =字符串相等+s【i-1】【j-1】；

java 复制代码

class Solution {
    public String longestPalindrome(String s) {
        //动态规划dp【i+1】【j+1】 = dp【i】【j】+1；
        int n = s.length();
        int strat = 0;
        boolean[][] dp = new boolean[n][n];
        int max = 0;
        for(int i = 0; i < n; i++){
            dp[i][i] = true;
            max = 1;
            strat = i;
        } 

        for(int i = 0; i < n-1; i++){
            if(s.charAt(i) == s.charAt(i+1)){
                dp[i][i+1] =true;
                max =2;
                strat = i;
            }
        }
        
       
        for(int len = 3 ; len <= n; len++){
            for(int i = 0; i +len-1 < n; i++){
                int j = i + len -1;
                if(s.charAt(i) == s.charAt(j) && dp[i+1][j-1]){
                    dp[i][j] = true;
                    max = len;
                    strat = i;

                }

            }
        }

        return s.substring(strat,strat+max);
    }
}

交错字符串

要点：也是状态转移dp【i] $j$ = dp $i-1$ $j$ || dp $i$ $j-1$ + 字符串相等吗

java 复制代码

class Solution {
    public boolean isInterleave(String s1, String s2, String s3) {
        int n = s1.length(), m = s2.length(), t = s3.length();
        if (n + m != t) return false;
        boolean[][] dp = new boolean[n + 1][m + 1];
        dp[0][0] = true;
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= m; j++) {
                int p = i + j - 1; // s3 当前位置索引
                if (i > 0) {
                    dp[i][j] = dp[i][j] || (dp[i - 1][j] && s1.charAt(i - 1) == s3.charAt(p));
                }
                if (j > 0) {
                    dp[i][j] = dp[i][j] || (dp[i][j - 1] && s2.charAt(j - 1) == s3.charAt(p));
                }
            }
        }
        return dp[n][m];
    }
}

编辑距离

要点：f $i$ $j$ = min/max $i-1$ $j$ / $i$ $j-1$ / $i-1$ $j-1$ + 某个数字

java 复制代码

class Solution {
    public int minDistance(String word1, String word2) {
        //二维dp
        int n = word1.length();
        int m = word2.length();

        int[][] dp = new int[n+1][m+1];

        for(int i = 0; i <=n; i++){
            dp[i][0] = i;
        }

        for(int j = 0; j <= m; j++){
            dp[0][j] = j;
        }

        for(int i = 1; i <=n; i++){
            for(int j = 1; j <= m; j++){
                if(word1.charAt(i-1) == word2.charAt(j-1)){
                    dp[i][j] = dp[i-1][j-1];
                }else{
                    dp[i][j] = Math.min(dp[i-1][j], Math.min(dp[i][j-1],dp[i-1][j-1]))+1;
                }
            }
        }

        return dp[n][m];
        
    }
}

最大正方形

要点：min

java 复制代码

class Solution {
    public int maximalSquare(char[][] matrix) {
        //二维dp
        //dp[][] =dp[i-1][j-1]

        int n = matrix.length;
        int m = matrix[0].length;

        int[][] dp = new int[n+1][m+1];
        int ans = 0;
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                if(matrix[i-1][j-1] == '1'){
                    dp[i][j] = Math.min(dp[i-1][j], Math.min(dp[i][j-1], dp[i-1][j-1])) +1;
                    ans = Math.max(ans, dp[i][j]);
                }
            }
        }

        return ans*ans;
        
    }
}

随机知识

🏗️ 模块一：底层架构与推理机理（必考基础）

大厂面试第一题往往从这里切入，考察你是否真的懂"物理运行逻辑"。

本质：基于Transformer的自回归概率模型，核心是预测下一个Token。
Prefill vs Decode（核心考点）：
- Prefill（预填充） ：处理Prompt，全量并行计算，生成KV Cache。耗时决定TTFT（首Token延迟），受算力（FLOPS）瓶颈限制。
- Decode（解码） ：自回归逐个吐字，利用KV Cache增量计算。耗时决定TPS（每秒吞吐量），受显存带宽（Memory Bandwidth）瓶颈限制。
KV Cache本质 ：缓存的是每层Self-Attention的K矩阵和V矩阵 （浮点数张量），不是自然语言文本 。显存占用 = 2 * Layers * Seq_Len * Hidden_Size。

面试话术："超长上下文首字慢，是因为Prefill阶段计算量随长度平方增长；而生成过程靠KV Cache避免重复计算，但显存压力巨大，所以业界才需要PagedAttention（如vLLM）来管理。"

⚙️ 模块二：数据、训练与对齐（算法核心）

考察你是否清楚模型"聪明的来源"和"变乖的过程"。

Tokenizer ：模型不看字，看Token（BPE/SentencePiece）。同一段中文在不同模型Token数不同 ，源于词表合并规则差异。这直接影响成本（计费） 和跨语言表现。
三阶段训练流程：
1. 预训练（Pre-training） ：海量文本，自监督学习，奠定世界知识 和语言分布。Base Model满腹经纶但不会对话。
2. SFT（监督微调） ：用（指令，高质量回答）对，教会模型**"对话格式"** 。数据量门槛：针对单一任务至少500-2000条 ，通用对话需数万+。100条只够做概念验证。
3. RLHF / DPO（偏好对齐） ：通过人类偏好排序，教会模型**"安全与价值观"**。知道什么该答，什么该拒。Constitutional AI试图用规则减少人工标注，寻求Helpful与Harmless的帕累托最优。
对齐的核心目标 ：不是让模型只会拒绝，而是**"该答时有证据地答，该停时停，不确定时明确说不确定"**。

🧠 模块三：核心能力与致命缺陷（认知深度）

强项：In-context Learning（上下文学习） ------给几个例子就能模仿；通用模式归纳------极强的泛化推理能力。
命门（工业界最头疼）：
- 幻觉：模型是"概率分布"而非"知识库"，会编造不存在的事实。
- 过时：知识截断，无法感知训练截止后的新事件。
- 格式不稳定：概率采样导致JSON、结构化输出偶尔崩坏。

面试话术 ："本质原因是它存储的是Token间的统计规律，而非显式数据库。因此，绝不能把LLM当作搜索引擎，只能当作'推理引擎'。"

🔧 模块四：工程落地与增强（大厂生存技能）

面试官最看重这一块，看你如何把"有缺陷的模型"变成"可靠的产品"。

提示词工程（结构化） ：优秀Prompt = 角色锚定 + 清晰指令 + 输入上下文 + 格式约束（JSON Schema）+ 兜底策略。本质是压缩概率空间，消除歧义。
RAG（检索增强生成） ：解决幻觉和过时的外挂知识库 。核心Prompt原则："仅基于以下参考资料回答，禁止使用预训练知识"。
Agent（工具调用） ：赋予模型"手"和"脚"。关键在于设计决策路由------让模型决定何时调用API（查天气/算数），何时直接回答。
解码约束（工程捷径） ：固定格式（如JSON）不一定要靠SFT硬学，可用Guidance / JSON Mode在解码层强制约束，性价比极高。

🚀 模块五：大厂面试的"升维打击"认知（定薪分水岭）

如果你能在基础之上，说出下面这几点前沿商业洞察，这就是你拿SSP Offer的资本：

Scaling Law（规模法则） ：模型能力与参数量、数据量、算力呈幂律关系。但大厂现在已从"盲目堆参数"转向 "MoE（混合专家）" ------用稀疏激活降低推理成本。
长上下文的工程代价 ：上下文从128K扩展到1M，KV Cache显存呈线性增长 。这是为什么大厂狂卷 Multi-Query Attention (MQA) 和 Grouped-Query Attention (GQA) 的原因------为了压榨显存。
Post-Training（后训练）的重要性 ：基座模型决定上限，后训练（SFT+RLHF）决定下限和产品体验。大厂算法团队80%的人力其实不在预训练，而在构造SFT数据和RLHF偏好对。
成本意识（面试必杀技） ：落地时，能用Prompt解决的绝不微调，能用小模型（如7B）解决的绝不用大模型（如70B）。

🎯 终极面试腹稿（串联所有模块）

面试官："请谈谈你对大模型的理解。"

标准满分回答框架 ：

"面试官，我认为大语言模型本质上是一个基于Transformer的通用推理引擎。

在原理上，它通过自回归 预测下一个Token，推理分为Prefill （建立KV Cache）和Decode（逐字生成）两阶段，前者制约首字延迟，后者受限于显存带宽。

在能力构建上，它经历了**预训练（注入知识）→ SFT（学习对话格式）→ RLHF/DPO（对齐人类偏好）**三步。需要特别强调的是，SFT解决'会不会答'，RLHF解决'该不该答'，两者不能混淆。

落地时，它存在幻觉和知识过时 的天然缺陷，所以不能裸用，必须结合RAG 补充实时知识，通过结构化提示词 强制输出格式，必要时辅以工具调用处理精确计算。

最后，作为工程师，我的核心考量是成本与效果的权衡：能用System Prompt约束的，绝不用微调；能用7B MoE模型承载的，绝不调用70B稠密模型。"

碎碎念：后续会更新每天学习的八股和算法题，开始准备秋招的第60天。努力连续更新100天！以后每天就按，秋招项目【java +agent】，科研，必做项目，算法，八股，锻炼身体来总结。

总结：60天了，唯一的收获应该就是不怕看代码了，相信自己

1.算法面试150 133/150 2h

2.秋招项目，【java 项目】，

【agent 项目】，

3.科研要跑一下，

4.实习；7h

6.背八股，2h

7.锻炼身体，

总结：今天看来大模型的八股，继续加油，继续整理项目的内容【这周周末加油看看能不能来个大总结吧，也得抓紧时间总结出个完整版应对秋招了】