UVa 169 Xenosemantics

AI 应用开发 × 算法面试题:业务场景实战 12 题【TopK、LRU、RRF 融合、相似度、限流算法,含手撕代码与底层答案】 本文聚焦AI应用岗算法面试新趋势,剖析12道融合业务场景的高频题:从海量日志中挖掘慢查询(分治+小顶堆)、亿级去重(布隆过滤器)、向量与关键词融合排序(RRF)、语义缓存设计(带租户隔离与TTL的LRU)到限流策略(令牌桶+滑动窗口),强调“场景复述→算法选型→手撕代码→生产落地”四步答题框架。突出考察点已从纯算法转向工程权衡、业务理解与系统设计能力,如误判容忍度、实时性与内存预算的平衡,助力开发者应对2026年真实技术挑战。 阅读详情

题目分析

本题是一道字符串处理与逻辑判定相结合的难题。题目设定了一个外星语言的消息格式,要求从一段混合字符中提取出符合特定规则的“真词”。核心难点在于理解并实现这些规则,然后按特定顺序输出结果。

消息格式规则:

  1. 消息是比特流,被分为 888 位一组,但有效部分只包含小写字母。
  2. 单词由分隔字母界定,分隔符在消息中可变,但同一对分隔符界定的单词内部不能包含该分隔符。
  3. 消息首尾被视为通配符(可与任何字母匹配)。
  4. 一个“真词”必须满足:
    • 长度在 222 到 250250250 之间;
    • 在消息中至少出现两次(字母顺序可以重排);
    • 与另一个真词在位置上重叠。

输出要求:

  • 按单词第一次出现的顺序输出,但如果两个单词的第一次出现有重叠,则先结束的单词先输出。
  • 每个消息输出后以 * 结束。

数据规模:消息长度不超过 100010001000 个字母。

解题思路

整个解题过程可以分为以下几个步骤:

1. 数据预处理

输入消息可能跨行,行末的 - 表示下一行继续。我们需要将所有小写字母按顺序收集起来,构成一个连续的字符串 block,并记录每个字母的原始索引(用于重叠判断)。

for (int i = 0; i < line.length(); i++)
    if ('a' <= line[i] && line[i] <= 'z') {
        block += line[i];
        letters.push_back((letter){line[i], block.length() - 1});
    }
2. 候选单词提取

根据规则,单词由相同字母(作为分隔符)界定。我们扫描所有相同字母对 (letters[i],letters[i+1])(letters[i], letters[i+1])(letters[i],letters[i+1]),它们之间的子串(长度 222–250250250)就是候选单词。

此外,由于消息首尾被视为通配符,还需要考虑从开头到第一个字符之间的部分,以及从最后一个字符到末尾的部分。这些部分只要不包含与之相邻的字符(即分隔符)即可。

// 相同字母之间的子串
for (int i = 0; i < letters.size() - 1; i++)
    if (letters[i].character == letters[i + 1].character) {
        int length = letters[i + 1].index - letters[i].index - 1;
        if (length >= 2 && length <= 250)
            words.push_back((word){block.substr(letters[i].index + 1, length), letters[i].index + 1});
    }

// 开头到第一个字符之间的子串
for (int i = 2; i < block.length() && i <= 260; i++) {
    string falseWord = block.substr(0, i);
    if (falseWord.find(block[i]) == falseWord.npos)
        words.push_back((word){falseWord, 0});
}

// 最后一个字符到末尾的子串
for (int i = 2; i < block.length() && i <= 260; i++) {
    int index = block.length() - i;
    string falseWord = block.substr(index, i);
    if (falseWord.find(block[index - 1]) == falseWord.npos)
        words.push_back((word){falseWord, index});
}
3. 候选单词分组

单词是否相同取决于其字母组成(顺序可变)。因此我们将每个单词的字母排序后作为键,相同键的单词放入同一组。这样每组就是一个“可能相同的单词”集合。

candidates.clear();
for (int i = 0; i < words.size(); i++) {
    string temp = words[i].text;
    sort(temp.begin(), temp.end());
    candidates[temp].push_back(words[i]);
}
4. 真词判定

一个组成为真词的条件:

  • 组内至少有两个不同的出现位置;
  • 该组中至少有一个单词与另一个组的某个单词重叠。

我们用一个布尔数组标记哪些组是真词。遍历所有组,如果某组还未标记,则检查该组内每个单词是否与其它组的任何单词重叠。一旦发现重叠,标记这两个组均为真词。

for (int i = 0; i < trueWords.size(); i++) {
    if (isTrueWord[i]) continue;
    for (int j = 0; j < trueWords[i].size(); j++) {
        bool found = false;
        for (int m = 0; m < trueWords.size(); m++) {
            if (m == i) continue;
            for (int k = 0; k < trueWords[m].size(); k++) {
                if (isOverlapped(trueWords[i][j], trueWords[m][k])) {
                    isTrueWord[i] = true;
                    isTrueWord[m] = true;
                    found = true;
                    break;
                }
            }
            if (found) break;
        }
        if (found) break;
    }
}
5. 重叠判断

两个单词重叠的条件是:它们在原字符串中的区间有交集。我们通过比较起始和结束位置来判断。

bool isOverlapped(word x, word y) {
    int xend = x.start + x.text.length() - 1;
    int yend = y.start + y.text.length() - 1;
    return (x.start >= y.start && x.start <= yend) ||
           (xend >= y.start && xend <= yend) ||
           (y.start >= x.start && y.start <= xend) ||
           (yend >= x.start && yend <= xend);
}
6. 真词排序与输出

我们需要按第一次出现的位置排序,但如果两个单词的第一次出现重叠,则先结束的优先。这个排序规则通过自定义比较函数实现:

bool cmpWord(word x, word y) {
    if (isOverlapped(x, y)) {
        int xend = x.start + x.text.length();
        int yend = y.start + y.text.length();
        if (xend != yend) return xend < yend;
        else return x.start < y.start;
    } else {
        return x.start < y.start;
    }
}

最后,将每个真词组的第一个出现(即最早出现的位置)放入列表,排序后输出,并以 * 结束。

总结

本题的难点在于:

  • 正确理解“单词由分隔符界定”的含义;
  • 实现重叠判断与真词判定;
  • 特殊排序规则的实现。

代码通过预处理、分组、重叠检测和排序等步骤,完整实现了题目要求。由于数据规模较小(≤1000\leq 1000≤1000),这种 O(n3)\texttt{O}(n^3)O(n3) 的暴力方法在时间上是可行的。

完整代码

// Xenosemantics
// UVa ID: 169
// Verdict: Accepted
// Submission Date: 2016-02-19
// UVa Run Time: 0.006s
//
// 版权所有(C)2016,邱秋。metaphysis # yeah dot net

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

struct letter {
    char character;
    int index;
};

struct word {
    string text;
    int start;
};

bool operator<(letter x, letter y) {
    return x.character < y.character;
}

bool operator<(word x, word y) {
    if (x.start == y.start) return x.text.length() < y.text.length();
    else return x.start < y.start;
}

bool isOverlapped(word x, word y) {
    int xend = x.start + x.text.length() - 1;
    int yend = y.start + y.text.length() - 1;
    return x.start >= y.start && x.start <= yend ||
        xend >= y.start && xend <= yend ||
        y.start >= x.start && y.start <= xend ||
        yend >= x.start && yend <= xend;
}

bool cmpWord(word x, word y) {
    if (isOverlapped(x, y)) {
        int xend = x.start + x.text.length();
        int yend = y.start + y.text.length();
        if (xend != yend) return xend < yend;
        else return x.start < y.start;
    } else return x.start < y.start;
}

string block;
vector<letter> letters;
vector<word> words;
map<string, vector<word>> candidates;
vector<vector<word>> trueWords;

void findTrueWord() {
    if (block.length() <= 3) {
        cout << "*\n";
        return;
    }
    stable_sort(letters.begin(), letters.end());
    words.clear();
    for (int i = 0; i < letters.size() - 1; i++)
        if (letters[i].character == letters[i + 1].character) {
            int length = letters[i + 1].index - letters[i].index - 1;
            if (length < 2 || length > 250) continue;
            string something = block.substr(letters[i].index + 1, length);
            words.push_back((word){something, letters[i].index + 1});
        }

    for (int i = 2; i < block.length() && i <= 260; i++) {
        string falseWord = block.substr(0, i);
        if (falseWord.find(block[i]) != falseWord.npos) continue;
        words.push_back((word){falseWord, 0});
    }
    
    for (int i = 2; i < block.length() && i <= 260; i++) {
        int index = block.length() - i;
        string falseWord = block.substr(index, i);
        if (falseWord.find(block[index - 1]) != falseWord.npos) continue;
        words.push_back((word){falseWord, index});
    }
    sort(words.begin(), words.end());
    candidates.clear();
    for (int i = 0; i < words.size(); i++) {
        string temp = words[i].text;
        sort(temp.begin(), temp.end());
        if (candidates.count(temp) == 0) {
            vector < word > list;
            list.push_back(words[i]);
            candidates[temp] = list;
        } else candidates[temp].push_back(words[i]);
    }

    trueWords.clear();
    for (map<string, vector<word>>::iterator it = candidates.begin(); it != candidates.end(); it++)
        if ((*it).second.size() > 1)
            trueWords.push_back((*it).second);

    vector < bool > isTrueWord;
    for (int i = 0; i < trueWords.size(); i++)
        isTrueWord.push_back(false);

    for (int i = 0; i < trueWords.size(); i++) {
        if (isTrueWord[i]) continue;
        for (int j = 0; j < trueWords[i].size(); j++) {
            bool found = false;
            for (int m = 0; m < trueWords.size(); m++) {
                if (m == i) continue;
                found = false;
                for (int k = 0; k < trueWords[m].size(); k++) {
                    if (isOverlapped(trueWords[i][j], trueWords[m][k])) {
                        isTrueWord[i] = true;
                        isTrueWord[m] = true;
                        found = true;
                        break;
                    }
                }
                if (found) break;
            }
            if (found) break;
       }
    }

    words.clear();
    for (int i = 0; i < trueWords.size(); i++)
        if (isTrueWord[i])
            words.push_back(trueWords[i][0]);
    
    sort(words.begin(), words.end(), cmpWord);
    for (int i = 0; i < words.size(); i++)
        cout << words[i].text << "\n";
    cout << "*\n";
}

int main() {
    cin.tie(0);
    cout.sync_with_stdio(false);
    
    string line;
    bool ended = false;
    while (getline(cin, line), line != "#") {
        for (int i = 0; i < line.length(); i++)
            if ('a' <= line[i] && line[i] <= 'z') {
                block += line[i];
                letters.push_back((letter){line[i], (int)block.length() - 1});
            }

        ended = line[line.length() - 1] != '-';

        if (ended) {
            findTrueWord();
            letters.clear();
            block.clear();
            ended = false;
        }
    }
    
	return 0;
}
信创环境下,软件测试如何破局? 毕竟,在自主可控的道路上,每一行通过测试的代码,都在为信创产业的未来添砖加瓦。未来,测试工程师不仅要验证软件在信创环境的可用性,更要基于国产软硬件的特性,推动软件进行 “原生设计”—— 例如,针对国产 CPU 的多核架构优化代码,基于国产数据库的索引机制提升查询效率。某政务云平台的测试数据显示,在 “飞腾芯片 + 麒麟操作系统” 环境下,系统的并发处理能力较传统环境下降约 15%,测试团队通过优化软件的线程调度逻辑,最终将性能损失控制在 5% 以内 —— 这正是信创性能测试的价值所在。 阅读详情

相关推荐

伪距单点定位算法原理以及利用最小二乘法计算实例

即该公式:建立下列代价函数满足最佳估值的条件为:即:可解得未知参数 X 的最佳估值由于每个可见卫星观测量的精度可能不一样,这时,需要对不同观测量赋予一个权重系数,称为加权。

qq_43381998的博客 1万+

UVa OJ 题解索引

寂静山林 789

嵌入式面试|MCU+RTOS技术栈——面试八股文整理3:STM32

stm32

weixin_44800059的博客 1921

UVa Problem 10252 Common Permutation (公共排列)

// Common Permutation (公共排列) // PC/UVa IDs: 110303/10252, Popularity: A, Success rate: average Level: 1 // Verdict: Accepted // Submission D

寂静山林 4140

LEF文件介绍及其生成

介绍LEF文件及其生成方法

weixin_43249158的博客 3万+

基于Java的高校校园点餐系统

本文介绍了一个基于Java技术开发的高校校园点餐系统,该系统以B/S结构为基础,采用MySQL作为数据库,实现了一个高效、便捷的在线点餐平台。系统主要面向三类用户:管理员、用户和食堂工作人员,提供包括用户管理、食堂管理、菜单管理、订单管理等在内的多项功能。通过系统的具体测试,验证了其可行性和有效性,为高校师生提供了一个科学化、系统化的点餐服务。高校校园点餐系统的开发和实现,不仅提高了校园餐饮服务的效率和质量,也为师生提供了一个更加便捷的点餐体验。

a632341031的博客 844

UVa Problem 123 - Searching Quickly

// UVa Problem 123 - Searching Quickly // Verdict: Accepted // Submission Date: 2012-01-04 // UVa Run Time: 0.016s // // 版权所有(C)2012,邱秋。metaphysis # yeah dot net // // [解题方法] // 简单的字符串处理和排序题。

寂静山林 3808

Open Interpreter利用Code Interpreter实现本地化

作为一个可以在本地环境中运行的工具,Open Interpreter可以访问互联网,没有文件大小和运行时间的限制,并且可以利用任何包或库。去年7月,OpenAI发布了一个强大的插件,名为Code Interpreter(代码解释器),它可以根据用户的自然语言需求生成并执行代码解决方案,帮助完成各种任务,如数据分析、图表创建和文件编辑等。Open Interpreter不仅是一个编码解释器,它还是一个强大的工具,专注于处理复杂任务,将GPT-4代码解释器的强大功能与本地开发环境的灵活性完美结合在一起。

DigitalChina_DCG的博客 1797

UVa Problem 850 Crypt Kicker II (解密 II)

// Crypt Kicker II (解密 II) // PC/UVa IDs: 110304/850, Popularity: A, Success rate: average Level: 2 // Verdict: Accepted // Submission Date:

寂静山林 3544

阿里云CDN HTTPS 证书配置流程

可以使用HTTPS方式访问资源,如果浏览器中URL旁边出现锁的HTTPS标识,表示HTTPS安全加速已生效。: 证书配置完成后,需要留意证书过期时间并在证书过期前手动配置新的证书。注意 ⚠️ 一定是需要复制 以下标识之间的内容。如果已在阿里云数字证书管理服务中购买了证书,请选择。,该证书将在阿里云数字证书管理服务中保存。如果使用第三方服务商签发的证书,请选择。第四步,在指定域名的左侧导航栏,单击。第二步,在左侧导航栏,单击。开关,并配置证书相关参数。页面,找到目标域名,单击。中选择已购买的证书。

w风雨无阻w的专栏 2217

第六部分:VTK进阶(第182章 体素化与隐式建模)

本文系统介绍了基于点云构建有符号距离场(SDF)的核心原理与VTK实现方法。主要内容包括:1)SDF的基本概念与算法原理,通过体素网格隐式表达几何表面;2)关键参数配置指南,如体素分辨率、边界范围和影响半径的选择;3)点云法向估计、SDF计算与等值面提取的完整工作流程;4)常见问题解决方案与性能优化建议。文中提供了详细的C++代码示例,展示从随机点云生成SDF并重建曲面的完整过程,特别强调了法向估计、参数调优和后处理等关键环节。该方法适用于点云表面重建、几何处理等应用场景。

仰望星空的博客 531

UVa Problem 10082 WERTYU (WERTYU 键盘)

// WERTYU (WERTYU 键盘) // PC/UVa IDs: 110301/10082, Popularity: A, Success rate: high Level: 1 // Verdict: Accepted // Submission Date: 2011-

寂静山林 3424

chembl_webresource_client 包数据接口下载chembl数据库;ZINC数据库下载、simles获取

点击进去https://zinc.docking.org/subclasses/kinase/predictions/,然后下载sdf模式,这里可以转化simles格式,如果下载csv里面没有包含simles。参考:https://github.com/chembl/chembl_webresource_client/blob/master/demo_wrc.ipynb。参考:https://zinc.docking.org/这是网页搜索查看,16条数据。这个数据这下载特别慢。

weixin_42357472的博客 3056

UVa Problem 10010 Where’s Waldorf?(寻找单词)

// Where’s Waldorf? (序找单词) // PC/UVa IDs: 110302/10010, Popularity: B, Success rate: average Level: 2 // Verdict: Accepted // Submission Dat

寂静山林 2661

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

UVa Problem 10132 File Fragmentation (文件碎片)

// File Fragmentation (文件碎片) // PC/UVa IDs: 110306/10132, Popularity: C, Success rate: average Level: 2 // Verdict: Accepted // Submission D

寂静山林 2619

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

UVa Problem 10188 Automated Judge Script (自动评测脚本)

// Automated Judge Script (自动评测脚本) // PC/UVa IDs: 110305/10188, Popularity: B, Success rate: average Level: 1 // Verdict: Accepted // Submis

寂静山林 2441

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

UVa Problem 848 Fmt (Fmt 程序)

// Fmt (Fmt 程序) // PC/UVa IDs: 110308/848, Popularity: C, Success rate: low Level: 2 // Verdict: Accepted // Submission Date: 2011-05-22 //

寂静山林 2198

UVa 10580 Ransom Note

本文研究了如何通过剪贴报纸字母制作勒索信的最优解问题。给定勒索信和报纸文本,忽略大小写和标点符号,要求使用最少剪贴片段拼出勒索信。核心算法采用后缀数组技术,通过构建连接字符串的后缀数组和高度数组,实现高效的贪心匹配。每次从当前位置寻找报纸中最长的连续匹配片段,确保总片段数最少。预处理阶段将文本转换为小写并去除标点,构建后缀数组的时间复杂度为O(n log n),匹配阶段利用高度数组快速查找最长公共前缀。实验证明该方法能高效解决大规模输入问题,样例运行时间为0.05秒。

寂静山林 1075

UVa 11732 strcmp() Anyone

题目要求计算所有字符串对在strcmp()比较时的总字符比较次数。关键点在于strcmp()的机制:逐个字符比较直到出现差异或结束符。直接两两比较效率低(O(N²L)),需优化。采用Trie树高效统计公共前缀: Trie构建:存储字符串并记录节点访问次数和结束次数。 比较次数计算:通过BFS遍历Trie,对每个节点分两种情况: 分叉节点:比较次数为2d+1(d为深度)。 结束节点:比较次数为2d+2。 优化公式:利用组合数计算节点贡献,避免重复计算。 此方法将复杂度降至O(NL),适用于大规模数据。

寂静山林 1063

UVa 10234 Frequent Substrings

本文讨论如何统计字符串中出现频率最高的指定长度子串(N-Gram)。核心思路包括将字符串统一转为小写、枚举所有可能子串并用map统计频率,最后选择出现次数最多且字典序最小的子串。算法复杂度为O(L·N logL),适用于长度不超过1000的字符串。实现时需注意处理输入输出细节,如换行符和大小写转换。该问题考察了字符串处理、频率统计和字典序比较的综合能力。

寂静山林 1058

UVa 12012 Detection of Extraterrestrial

本文研究了如何检测字符串中由X个相同子串拼接而成的最长连续子串。给定长度为N的字符串,对每个X∈[1,N],找出能表示为X个相同块拼接的子串的最大长度。通过预处理字符串哈希,枚举所有可能的块长度和起点,统计连续相同块的数量,从而高效更新答案。算法利用哈希比较优化,将理论复杂度从O(N^4)降至O(N^3),实际运行效率较高。代码实现采用自然溢出哈希技术,正确处理边界情况,确保结果正确性。测试样例验证了算法能准确识别周期性重复模式,如输入"noonnoonnoon"时,正确输出X=2

寂静山林 1056

UVa 1127 Word Puzzles

本文提出了一种利用Trie树优化矩阵单词搜索的算法。给定L×C字母矩阵和W个单词,需要找出每个单词首次出现的起始位置和方向(8种)。传统暴力搜索时间复杂度太高,而本文方法通过构建Trie树,从每个矩阵位置出发沿8个方向在Trie树上匹配单词,显著提高了效率。算法时间复杂度为O(L×C×8×maxLen),空间复杂度为O(总单词长度×26)。代码实现中采用方向数组处理8种移动,利用foundCount变量提前终止搜索,确保只记录首次出现位置。该方法在UVa 1127题目中表现优异,运行时间仅0.300s。

寂静山林 1045

UVa 13088 Lexicographically Smallest FPIS

题目要求将给定的FPIS(频率和排列不敏感字符串)转换为字典序最小的版本。FPIS的特性允许任意字符排列和频率调整,只需保持总长度不变且包含所有原字符类型。解题思路是:首先统计字符串中的字符种类并按字典序排序,然后通过贪心算法,尽可能多地放置当前最小字符,同时为后续字符预留最少位置。最终输出按此规则构造的字符串。例如输入"aabb"会输出"aaab",因为优先放置最多'a'后保留一个'b'。算法复杂度为O(n·k),适用于题目给定的数据范围。

寂静山林 1044

UVa 11539 Another Word Game

本文探讨了一个字符串分段决策问题,旨在通过动态规划和字典树优化求解最大得分。给定一个单词字典和字符串S,需要将S分割为连续不重叠子串,匹配字典单词加分,否则按长度扣分。算法采用Trie树存储字典以加速查询,动态规划状态dp[i]表示处理前i个字符的最大得分。状态转移时枚举所有可能子串,分别处理匹配加分和强制扣分情况,时间复杂度为O(|S|×100)。最终输出dp[|S|]作为答案。代码实现展示了Trie构建、动态规划转移和结果计算过程,适用于大规模数据。

寂静山林 1036

P14361 [CSP-S 2025] 社团招新 解题报告

本题的核心是带限制的贪心。先忽略限制得到理想最优解,再利用反悔机制修正超员部门:将超员部门中“转出损失最小”的成员改派到其他部门。由于总人数为nnn最多只有一个部门会超员,因此只需对该部门进行修正。使用优先队列可以高效地选出损失最小的成员,总复杂度Onlog⁡nOnlogn。

weixin_45254471的博客 320

算法:全景梳理前端项目开发中常用算法合集

本文系统梳理前端高频算法场景,按业务分类汇总10类核心算法:基础查找(哈希、二分)、排序(Timsort、归并)、树结构(DFS/BFS、LCA)、滑动窗口、字符串匹配(正则为主)、节流防抖、虚拟滚动、图算法(Dijkstra、A*)、随机哈希及贪心动态规划。强调前端算法重点在于性能优化与交互流畅,非单纯追求复杂度,推荐优先使用内置方法与成熟库,关键掌握哈希查找、防抖节流、LRU缓存、区间合并、虚拟滚动等必会技能,确保页面不卡顿、响应快。

snow的博客 635
上一篇: UVa 168 Theseus and the Minotaur
下一篇: UVa 170 Clock Patience
寂静山林
博客等级 码龄22年 648粉丝 2077原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址