✅ 字节跳动春招备战指南 ✅

💡 学习建议：

• 先尝试独立解题（建议用时：90分钟/套）
• 对照解析查漏补缺
• 配套练习题库

互联网必备刷题宝典🔗

📢 字节跳动技术岗笔试重要信息速览

⏰ 笔试时间安排

• 常规场次：每周六交替进行
  • 上午场 10:00~12:00
  • 晚间场 19:00~21:00
• 通知时间：提前2天通过邮箱发送考试链接

🧩 笔试题型分布

⚙️ 考试设置要点

• 考试平台：牛客网（ACM模式）
• 监考要求：
  • 必须开启笔记本前置摄像头
  • 禁止使用手机（需小程序锁定）
  • 允许使用本地IDE
• 编程规范：
  • 严格遵循输入输出格式
  • 注意时间复杂度控制（通常1s对应1e8次运算）

📚 笔试经验贴

（所有展示题面均已进行改编处理，保留核心考点）

本题库收录整理自：

1. 互联网公开的笔试真题回忆版（经网友投稿）
2. 各大技术社区公开讨论的经典题型
3. 历年校招考生提供的解题思路

🔍 题库特点：

• 100%真实笔试场景还原
• 包含高频考点题型
• 提供多语言实现参考
• 持续更新2024届最新真题

⚠️ 注意事项：

1. 所有题目均来自公开渠道，已进行改编脱敏处理
2. 实际笔试可能出现题型变化，请以官方通知为准

🚀 春招备战指南

金三银四求职季即将到来！这里整理了最新字节跳动真题及解析，助你快速掌握笔试套路。建议重点突破以下题型：

1. 动态规划/状态压缩
2. 树形结构应用
3. 字符串模式匹配
4. 滑动窗口/双指针

（👇 下附最新笔试真题及详细解析 👇）

题目一：基环树的连边方案

题目描述

定义基环树为 个点、 条边且不包含重边和自环的无向连通图。形象化地描述，基环树可以由一棵树再添加一条边后形成（不能是树上已存在的边）。现在小基拿到了一个无向图，他想连一条边使得这个无向图变成基环树。

小基想知道，有多少种不同的连边方案？

输入描述

第一行输入两个正整数 ，代表无向图的点数和边数。

接下来的 行，每行输入两个正整数 ，代表节点 和节点 有一条边连接。保证给定的无向图不包含重边和自环。

输出描述

输出一个整数，代表添加边的方案数。

样例1

输入：

4 4
1 2
1 3
2 3
2 4

输出：

0

说明：本身该无向图已经是基环树，因此方案数为 。

样例2

输入：

4 3
1 2
1 3
2 3

输出：

3

说明：

• 第一个方案：连接 和
• 第二个方案：连接 和
• 第三个方案：连接 和

题解

首先添加一条边变成基环树，基环树中恰好有 条边，因此初始的 才可能有合法方案。

之后考虑只能添加一条边，最多只能有两个连通块：

1. 一个连通块：这个连通块就是一棵树，那么不能连出一条自环，答案就是
2. 两个连通块：此时两个连通块必然是一棵树和一棵基环树，大小为 和 ，答案为

时间复杂度：

参考代码

C++:

#include<bits/stdc++.h>
using namespace std;

const int N = 1e5+10;
int pre[N];

int find(int x) {
    if(pre[x] != x) {
        pre[x] = find(pre[x]);
    }
    return pre[x];
}

int main() {
    int n, m;
    cin >> n >> m;
    if(m != n-1) {
        cout << 0 << endl;
        return 0;
    }
    
    for(int i = 0; i < n; i++) {
        pre[i] = i;
    }
    
    for(int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;
        u--; v--;
        int fu = find(u);
        int fv = find(v);
        if(fu != fv) {
            pre[fu] = fv;
        }
    }
    
    map<int,int> sizes;
    for(int i = 0; i < n; i++) {
        sizes[find(i)]++;
    }
    
    if(sizes.size() > 2) {
        cout << 0 << endl;
    } else if(sizes.size() == 1) {
        cout << 1LL * n * (n-1) / 2 - (n-1) << endl;
    } else {
        long long ans = 1;
        for(auto [k,v] : sizes) {
            ans *= v;
        }
        cout << ans << endl;
    }
    return 0;
}

Python:

class DisjointSet:
    def __init__(self, n):
        self.pa = list(range(n))
        
    def find(self, x):
        if self.pa[x] != x:
            self.pa[x] = self.find(self.pa[x])
        return self.pa[x]
        
    def union(self, x, y):
        px = self.find(x)
        py = self.find(y)
        if px != py:
            self.pa[px] = py

n, m = map(int, input().split())
if m != n-1:
    print(0)
    exit()

ds = DisjointSet(n)
for _ in range(m):
    u, v = map(int, input().split())
    ds.union(u-1, v-1)

sizes = {}
for i in range(n):
    root = ds.find(i)
    sizes[root] = sizes.get(root, 0) + 1

if len(sizes) > 2:
    print(0)
elif len(sizes) == 1:
    print(n * (n-1) // 2 - (n-1))
else:
    ans = 1
    for v in sizes.values():
        ans *= v
    print(ans)

Java:

import java.util.*;

public class Main {
    static int[] parent;
    
    static int find(int x) {
        if(parent[x] != x) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }
    
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int m = scan.nextInt();
        
        if(m != n-1) {
            System.out.println(0);
            return;
        }
        
        parent = new int[n];
        for(int i = 0; i < n; i++) {
            parent[i] = i;
        }
        
        for(int i = 0; i < m; i++) {
            int u = scan.nextInt() - 1;
            int v = scan.nextInt() - 1;
            int pu = find(u);
            int pv = find(v);
            if(pu != pv) {
                parent[pu] = pv;
            }
        }
        
        Map<Integer,Integer> sizes = new HashMap<>();
        for(int i = 0; i < n; i++) {
            int root = find(i);
            sizes.put(root, sizes.getOrDefault(root, 0) + 1);
        }
        
        if(sizes.size() > 2) {
            System.out.println(0);
        } else if(sizes.size() == 1) {
            System.out.println(1L * n * (n-1) / 2 - (n-1));
        } else {
            long ans = 1;
            for(int size : sizes.values()) {
                ans *= size;
            }
            System.out.println(ans);
        }
    }
}

题目二：魔法糖果

题目描述

小基有 颗糖果，每颗糖果的编号为 。小基给自己定下的目标是，第 天必须吃编号为 的糖果。现在小基有一个魔法，可以选择一颗糖果，将其编号翻倍。小基最多只能释放一次魔法。他希望自己连续尽可能多的天数都能吃到糖果，请你求出最多的连续天数。

输入描述

第一行输入一个正整数 ，代表糖果数量。

第二行输入 个正整数 ，代表每个糖果的编号。

输出描述

一个正整数，代表最多能吃到糖果的连续天数。

样例1

输入：

4
1 1 3 5

输出：

3

说明：选择第一个糖果，将其编号变成 2，那么第 1、2、3 天都能吃到糖果，最多连续3天。

样例2

输入：

5
4 2 5 3 6

输出：

5

说明：不需要使用魔法，从第 2 天到第 6 天都可以吃到糖果。

题解

考虑预处理出连续区间，只能使用至多一次翻倍操作。这里的连续区间是指，这个区间内的数从小到大排序后，相邻元素的差至多为 2。

考虑每两个相邻的连续区间是否可以连在一块，如果可以则更新答案。需要注意一个边界情况：区间 [3,5] 和 [7,100]，如果将 [3,5] 的 3 翻倍为 6，那么可以得到 [4,5], [6], [7,100]，形成一个 [4,100] 的连续区间。

参考代码

C++:

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int> nums(n);
    for(int& x : nums) cin >> x;
    
    sort(nums.begin(), nums.end());
    int ans = 0;
    
    for(int i = 0; i < n; i++) {
        int j = i;
        while(j+1 < n && nums[j+1] - nums[j] <= 2) j++;
        
        int len = j-i+1;
        ans = max(ans, len);
        
        if(j+1 < n) {
            for(int k = i; k <= j; k++) {
                if(nums[k]*2 >= nums[j+1]-2 && nums[k]*2 <= nums[n-1]) {
                    ans = max(ans, n-k);
                }
            }
        }
        i = j;
    }
    
    cout << ans << endl;
    return 0;
}

Python:

n = int(input())
arr = sorted(list(map(int, input().split())))
ans = 0

i = 0
while i < n:
    j = i
    while j+1 < n and arr[j+1] - ar