✅ 春招备战指南 ✅

💡 学习建议：

• 先尝试独立解题
• 对照解析查漏补缺

🧸 题面描述背景等均已深度改编，做法和题目本质基本保持一致。

🍹 感谢各位朋友们的订阅，你们的支持是我们创作的最大动力

🌸 目前本专栏已经上线200+套真题改编解析，后续会持续更新的

春秋招笔试机考招合集 -> 互联网必备刷题宝典🔗

小红书-2026.04.05

小红书-2026.04.05

这场还是历史原题复用，不过题目组合和 3 月 29 日那套不一样。第一题换成了 冲突约束，后两题分别是 强迫症 和 每日一题plus。

题目一：冲突约束

数组排完序以后，真正能保留下来的点会沿着数轴一格一格往后挑。主体是一个从左往右的贪心，收尾还要补一次奇偶性判断，因为删除操作必须成对进行。

难度：Mid

题目二：强迫症

把所有对称位置里的失配点单独拎出来看，一次区间翻转能处理掉其中一整段。最后数一数这些失配点在左半边分成了多少段，答案就出来了。

难度：Mid

题目三：每日一题plus

先把 26 个字母最终各自能留多少个定下来，再回到原串里按配额去拿字典序最小的结果。难点不在计数，而在“删得最少”的前提下把结果压到尽量小。

难度：High

1. 冲突约束

问题描述

本题是小红书 2025.08.17 第 1 题的原题。

小红书生态团队在评论审核中，需要对得分接近的评论判定观点相近，这一判断逻辑可以帮助团队灵活地调整评论区的观点统一性/观点多样性。

现在，特模型简化如下：给定长度为 的整数数组 和一个整数 。若 ，则称 与 观点相近。

一次操作可以选择一对元素，并将其同时从数组中删除（数组长度减少 ）。

经过若干操作后，需要保证数组中不含任何观点相近的元素，且希望保留的元素数量尽可能多。

请你计算，经过若干操作后，最终保留下来的最大元素数量。

输入格式

每个测试文件均包含多组测试数据。第一行输入一个整数 （）代表数据组数，每组测试数据描述如下：

第一行输入两个整数 和 （），表示数组长度、观点相近的阈值。

第二行输入 个整数 （），表示数组元素。

除此之外，保证单个测试文件的 之和不超过 。

输出格式

对于每组测试数据，新起一行输出一个整数，表示最终保留下来的最大元素数量。

样例输入

2
5 2
1 2 4 7 9
4 0
1 1 2 5

样例输出

3
2

样例	解释说明
样例1	保留分数为 的评论，它们两两之间的差值都大于 ，无法再删除，最终剩 条评论。
样例2	两个分数为 的评论互为冲突，必须同时删除，最后只能保留分数为 和 的评论，共 条。

数据范围

• 
• 
• 
• 
• 单个测试文件的 之和不超过

题解

这道题本质上是一个图论中的最大独立集问题，但由于特殊的约束条件，我们可以用贪心策略来解决。

核心思路：

1. 将所有评论按情感分数排序
2. 相邻分数差值不超过 的评论之间存在"冲突边"
3. 每次删除操作必须删除2条评论，因此被删除的评论总数必须是偶数
4. 最终保留的评论数量与原总数 必须具有相同的奇偶性

算法步骤：

1. 排序：将所有评论按分数升序排列
2. 贪心构造独立集：从左到右扫描，采用"能选就选"的策略：
   • 选择当前最小的未被禁止的分数
   • 跳过所有与它差值 ≤ 的后续分数
3. 奇偶性调整：
   • 如果独立集大小与 奇偶性相同，直接输出
   • 否则需要再删除1个元素，输出独立集大小-1

为什么贪心策略有效： 在一维数轴上，"最左能选就选"的贪心策略能够保证得到最大的独立集。这是因为选择更小的数不会影响后续更大数字的选择机会，而且能为后续选择留下更多空间。

时间复杂度：，主要消耗在排序上 空间复杂度：，用于存储数组

参考代码

• Python

import sys
input = lambda: sys.stdin.readline().strip()

def solve():
    n, d = map(int, input().split())
    a = list(map(int, input().split()))
    
    # 对评论分数进行排序
    a.sort()
    
    # 贪心构造最大独立集
    cnt = 0
    i = 0
    while i < n:
        cnt += 1  # 选择当前分数
        limit = a[i] + d  # 计算冲突范围上界
        i += 1
        # 跳过所有可能产生冲突的分数
        while i < n and a[i] <= limit:
            i += 1
    
    # 奇偶性调整：保证删除的评论数为偶数
    if (n - cnt) % 2 == 1:
        cnt -= 1
    
    return cnt

T = int(input())
for _ in range(T):
    print(solve())

• Cpp

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

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int T;
    cin >> T;
    
    while (T--) {
        int n;
        long long d;
        cin >> n >> d;
        
        vector<long long> a(n);
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }
        
        // 对评论分数进行排序
        sort(a.begin(), a.end());
        
        // 贪心构造最大独立集
        int cnt = 0;
        int i = 0;
        while (i < n) {
            cnt++;  // 选择当前分数
            long long limit = a[i] + d;  // 计算冲突范围上界
            i++;
            // 跳过所有可能产生冲突的分数
            while (i < n && a[i] <= limit) {
                i++;
            }
        }
        
        // 奇偶性调整：保证删除的评论数为偶数
        if ((n - cnt) & 1) {
            cnt--;
        }
        
        cout << cnt << '\n';
    }
    
    return 0;
}

• Java

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int T = Integer.parseInt(br.readLine());
        
        while (T-- > 0) {
            String[] line1 = br.readLine().split(" ");
            int n = Integer.parseInt(line1[0]);
            long d = Long.parseLong(line1[1]);
            
            String[] line2 = br.readLine().split(" ");
            long[] a = new long[n];
            for (int i = 0; i < n; i++) {
                a[i] = Long.parseLong(line2[i]);
            }
            
            // 对评论分数进行排序
            Arrays.sort(a);
            
            // 贪心构造最大独立集
            int cnt = 0;
            int i = 0;
            while (i < n) {
                cnt++;  // 选择当前分数
                long limit = a[i] + d;  // 计算冲突范围上界
                i++;
                // 跳过所有可能产生冲突的分数
                while (i < n && a[i] <= limit) {
                    i++;
                }
            }
            
            // 奇偶性调整：保证删除的评论数为偶数
            if ((n - cnt) % 2 == 1) {
                cnt--;
            }
            
            System.out.println(cnt);
        }
    }
}

2. 强迫症

问题描述

本题是小红书 2026.03.15 第 2 题的原题。

在小红书首页的两列中，小红薯独爱第一列。她将第一列每条的点赞状态从上到下用一个二进制字符串表示，其中：

• 字符表示用户已点赞第条；
• 字符表示用户未点赞第条。

小红薯定义一轮点赞行为如下：

• 选择索引对；
• 从第条开始，到第条结束，进行一次重复点赞行为。这会使得原本未点赞的变为已点赞，原本已点赞的变为未点赞。

小红薯希望使得这一列的点赞状态调整为一个回文串，即第一条和最后一条的点赞状态相同，第二条和倒数第二条的点赞状态相同，以此类推。

请计算她最少需要进行的点赞行为轮数。

输入格式

每个测试文件均包含多组测试数据。第一行输入一个整数代表数据组数，每组测试数据描述如下：

第一行输入一个整数，表示数量；

第二行输入一个长度为、由字符0和1构成的字符串，表示点赞状态。

除此之外，保证单个测试文件的之和不超过。

输出格式

对于每一组测试数