【笔试刷题】宇信科技-2026.03.02-改编真题

✅ 春招备战指南 ✅

💡 学习建议：

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

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

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

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

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

宇信科技-2026.03.02

这套题的节奏比较清楚：第一题是判断题热身，第二题是经典构造，第三题才是真正拉开差距的证明题。前两题更像在考基本功和构造直觉，第三题则要求把“子序列不连续”这个条件吃透，才能把问题化成只看每组极值。

题目一：裁布三角样片校验

这题表面是几何题，真正要做的其实只有两步：先判三角形是否合法，再判排好序后的三条边是否同比分。输出分支虽然有三种，但逻辑很干净，主要别在“退化三角形也算三角形吗”这里踩坑。

难度：Low

题目二：演出顺序编排

这是很标准的下降对构造题。只要想到“前面递增、后面递减”这件事，下降次数就能被稳定锁成 $k$ ，而且连接处不会额外制造答案。

难度：Mid

题目三：社团分组波动值

这题最关键的不是写代码，而是先想明白哪些元素真的会影响答案。因为子序列可以不连续，中间元素往哪组塞通常都无所谓，核心只剩每组最小值和最大值；把这个抽象出来后，答案就变成“最大的 $k$ 个数之和减去最小的 $k$ 个数之和”。

难度：High

01. 三角形相似判断

问题描述

给定一个基准三角形的三条边长 a, b, c，以及 q 组询问。

每组询问给出三个正整数 x, y, z，你需要先判断这三条边能否构成一个非退化三角形；如果能，再判断它是否与基准三角形相似。

本题中，非退化三角形满足任意两边之和大于第三边。

输入格式

第一行输入三个正整数 a, b, c（1 ≤ a, b, c ≤ 100），表示基准三角形的三条边。数据保证 a, b, c 一定能构成三角形。

第二行输入一个正整数 q（1 ≤ q ≤ 100），表示询问次数。

接下来 q 行，每行输入三个正整数 x, y, z（1 ≤ x, y, z ≤ 100），表示一次询问中的三条边长。

输出格式

对于每组询问，输出一行结果：

如果不能构成三角形，输出 Cannot form a triangle
如果能构成三角形但不与基准三角形相似，输出 Can form a triangle but not similar
如果与基准三角形相似，输出 similar

样例输入

样例输出

similar
Cannot form a triangle
Can form a triangle but not similar

样例	解释说明
第 1 组询问	`10, 6, 8` 排序后是 `6, 8, 10`，与 `3, 4, 5` 的对应边成相同比例，因此相似
第 2 组询问	`3 + 6 = 9`，只能构成退化三角形，因此不能构成三角形
第 3 组询问	`9, 9, 9` 可以构成三角形，但与 `3, 4, 5` 的三边比例不同，因此不相似

数据范围

1 ≤ a, b, c ≤ 100
a, b, c 保证能构成三角形
1 ≤ q ≤ 100
1 ≤ x, y, z ≤ 100

题解

先将基准三角形的三条边排序，记为 base[0] ≤ base[1] ≤ base[2]。

对于每次询问，也把三条边排序，记为 cur[0] ≤ cur[1] ≤ cur[2]。

第一步先判断能否构成三角形。排序后只需要检查：

cur[0] + cur[1] > cur[2]

如果不成立，就输出 Cannot form a triangle。

第二步判断是否与基准三角形相似。排序后，对应边需要成相同比例。为了避免浮点误差，可以直接交叉相乘判断：

base[0] * cur[1] == base[1] * cur[0]
base[1] * cur[2] == base[2] * cur[1]

两个条件同时成立时，说明三组对应边成相同比例，此时输出 similar；否则输出 Can form a triangle but not similar。

复杂度分析

每次询问只处理 3 条边，排序和判断都是常数时间，因此单次询问时间复杂度为 O(1)，总时间复杂度为 O(q)。

额外空间复杂度为 O(1)。

参考代码

Python

import sys


def solve() -> None:
    # 基准三角形先排序，后面所有询问都按对应边比较比例。
    base = sorted(map(int, sys.stdin.readline().split()))
    q = int(sys.stdin.readline())
    ans = []
    for _ in range(q):
        # 当前询问也排序后处理，避免讨论边的对应关系。
        cur = sorted(map(int, sys.stdin.readline().split()))
        if cur[0] + cur[1] <= cur[2]:
            ans.append("Cannot form a triangle")
        elif base[0] * cur[1] == base[1] * cur[0] and base[1] * cur[2] == base[2] * cur[1]:
            ans.append("similar")
        else:
            ans.append("Can form a triangle but not similar")
    sys.stdout.write("\n".join(ans))


if __name__ == "__main__":
    solve()

Cpp

#include <algorithm>
#include <array>
#include <iostream>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    // 先把基准三角形排序，后面统一按升序边长比较。
    array<int, 3> base;
    cin >> base[0] >> base[1] >> base[2];
    sort(base.begin(), base.end());

    int q;
    cin >> q;
    while (q--) {
        // 当前询问排序后，只要检查三角形合法性和比例关系即可。
        array<int, 3> cur;
        cin >> cur[0] >> cur[1] >> cur[2];
        sort(cur.begin(), cur.end());

        if (cur[0] + cur[1] <= cur[2]) {
            cout << "Cannot form a triangle\n";
        } else if (1LL * base[0] * cur[1] == 1LL * base[1] * cur[0] &&
                   1LL * base[1] * cur[2] == 1LL * base[2] * cur[1]) {
            cout << "similar\n";
        } else {
            cout << "Can form a triangle but not similar\n";
        }
    }

    return 0;
}

Java

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    static class FastScanner {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        String next() throws Exception {
            while (st == null || !st.hasMoreTokens()) {
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }

        int nextInt() throws Exception {
            return Integer.parseInt(next());
        }
    }

    public static void main(String[] args) throws Exception {
        FastScanner fs = new FastScanner();
        // 基准三角形先排序，方便后面按对应边判断相似。
        int[] base = {fs.nextInt(), fs.nextInt(), fs.nextInt()};
        Arrays.sort(base);

        int q = fs.nextInt();
        StringBuilder out = new StringBuilder();
        while (q-- > 0) {
            // 当前询问排序后，先判三角形，再判比例。
            int[] cur = {fs.nextInt(), fs.nextInt(), fs.nextInt()};
            Arrays.sort(cur);

            if (cur[0] + cur[1] <= cur[2]) {
                out.append("Cannot form a triangle\n");
            } else if (1L * base[0] * cur[1] == 1L * base[1] * cur[0]
                    && 1L * base[1] * cur[2] == 1L * base[2] * cur[1]) {
                out.append("similar\n");
            } else {
                out.append("Can form a triangle but not similar\n");
            }
        }
        System.out.print(out);
    }
}