字节跳动(校招)算法原题

news/2024/7/25 2:02:21/文章来源:https://blog.csdn.net/weixin_33243821/article/details/139161881

大模型"价格战"越演越烈

昨天的 文章 提到,自从 5 月 15 号,字节跳动发布了击穿行业底价的豆包大模型后,各大厂家纷纷跟进降价,而且都不是普通降价,要么降价 90% 以上,要么直接免费。

今天是豆包发布会过去的第 8 天,价格战还在继续,且越演越烈。

腾讯混元大模型宣布全面降价,其中主力模型之一的混元-lite更是从即日起免费使用。

科大讯飞也宣布讯飞星火 API 永久免费开放。

而在昨天(5 月 22 号)举办的 Baichuan 4 模型产品发布会上,百川智能创始人兼 CEO 王小川也点评了最近的"大模型价格战",其声称:"在中国市场,API 服务其实对创业公司是走不通的"。

...

回归主线。

来一道和「字节跳动(校招)」相关的算法原题。

题目描述

平台:LeetCode

题号:886

给定一组 n 人(编号为 1, 2, ..., n), 我们想把每个人分进任意大小的两组。

每个人都可能不喜欢其他人,那么他们不应该属于同一组。

给定整数 n 和数组 dislikes ,其中   ,表示不允许将编号为  和   的人归入同一组。

当可以用这种方法将所有人分进两组时,返回 true;否则返回 false

示例 1:

输入:n = 4, dislikes = [[1,2],[1,3],[2,4]]

输出:true

解释:group1 [1,4], group2 [2,3]

示例 2:

输入:n = 3, dislikes = [[1,2],[1,3],[2,3]]

输出:false

示例 3:

输入:n = 5, dislikes = [[1,2],[2,3],[3,4],[4,5],[1,5]]

输出:false

提示:

  • dislikes 中每一组都 不同

染色法

无论是从题目描述和对点边的描述,这都是一道「染色法判定二分图」的模板题。

为了方便,我们令 dislikesds,将其长度记为

题目要求我们将 个点划分到两个集合中,同时我们将每个 看做无向边的话,可知集合内部无边,即所有的边必然横跨两个集合之间。

使用 进行建图,并将两个将要划分出的两个集合分别记为 AB,我们可以采用「染色」的方式,尝试将所有点进行划分。

构建一个与点数相等的数组 color,我们人为规定划分到集合 A 的点满足 ,划分到集合 B 的点满足 ,起始有 ,代表该点尚未被划分。

随后我们可以实现 DFS 函数为 boolean dfs(int u, int cur) 含义为尝试将点 ucur 色。根据定义可知,我们除了需要 color[u] = cur 以外,还需要遍历点 u 的所有出边(处理其邻点,将其划分到另一集合上),若在处理过程中发生冲突,则返回 false,若能顺利染色则返回 true

由于我们固定了颜色编号为 12,因此 cur 的对立色可统一为 3 - cur

最终,我们根据能否给所有点染色成功来决定答案。

Java 代码:

class Solution {
    int N = 2010, M = 2 * 10010;
    int[] he = new int[N], e = new int[M], ne = new int[M], color = new int[N];
    int idx;
    void add(int a, int b) {
        e[idx] = b;
        ne[idx] = he[a];
        he[a] = idx++;
    }
    boolean dfs(int u, int cur) {
        color[u] = cur;
        for (int i = he[u]; i != -1; i = ne[i]) {
            int j = e[i];
            if (color[j] == cur) return false;
            if (color[j] == 0 && !dfs(j, 3 - cur)) return false;
        }
        return true;
    }
    public boolean possibleBipartition(int n, int[][] ds) {
        Arrays.fill(he, -1);
        for (int[] info : ds) {
            int a = info[0], b = info[1];
            add(a, b); add(b, a);
        }
        for (int i = 1; i <= n; i++) {
            if (color[i] != 0continue;
            if (!dfs(i, 1)) return false;
        }
        return true;
    }
}

C++ 代码:

class Solution {
public:
    int he[2010], e[2 * 10010], ne[2 * 10010], color[2010], idx = 0;
    void add(int a, int b) {
        e[idx] = b;
        ne[idx] = he[a];
        he[a] = idx++;
    }
    bool dfs(int u, int cur) {
        color[u] = cur;
        for (int i = he[u]; i != -1; i = ne[i]) {
            int j = e[i];
            if (color[j] == cur) return false;
            if (color[j] == 0 && !dfs(j, 3 - cur)) return false;
        }
        return true;
    }
    bool possibleBipartition(int n, vector<vector<int>>& ds) {
        fill(he, he + n + 10-1);
        for (const auto& info : ds) {
            int a = info[0], b = info[1];
            add(a, b); add(b, a);
        }
        for (int i = 1; i <= n; i++) {
            if (color[i] != 0continue;
            if (!dfs(i, 1)) return false;
        }
        return true;
    }
};

Python 代码:

class Solution:
    def possibleBipartition(self, n: int, ds: List[List[int]]) -> bool:
        N, M = 201020010
        he, e, ne, color = [-1] * N, [0] * M, [0] * M, [0] * N
        idx = 0
        def add(a, b):
            nonlocal idx
            e[idx], ne[idx], he[a] = b, he[a], idx
            idx += 1
        def dfs(u, cur):
            color[u] = cur
            i = he[u]
            while i != -1:
                j = e[i]
                if color[j] == cur:
                    return False
                if color[j] == 0 and not dfs(j, 3 - cur):
                    return False
                i = ne[i]
            return True
        for info in ds:
            a, b = info[0], info[1]
            add(a, b)
            add(b, a)
        for i in range(1, n + 1):
            if color[i] != 0:
                continue
            if not dfs(i, 1):
                return False
        return True

TypeScript 代码:

function possibleBipartition(n: number, ds: number[][]): boolean {
    const N = 2010, M = 2 * 10010
    const he = new Array<number>(N).fill(-1), e = new Array<number>(M).fill(0), ne = new Array<number>(M).fill(0), color = new Array<number>(N).fill(0)
    let idx = 0
    function add(a: number, b: number): void {
        e[idx] = b
        ne[idx] = he[a]
        he[a] = idx++
    }
    function dfs(u: number, cur: number): boolean {
        color[u] = cur
        for (let i = he[u]; i != -1; i = ne[i]) {
            const j = e[i];
            if (color[j] == cur) return false
            if (color[j] == 0 && !dfs(j, 3 - cur)) return false
        }
        return true
    }
    for (const info of ds) {
        const a = info[0], b = info[1]
        add(a, b); add(b, a)
    }
    for (let i = 1; i <= n; i++) {
        if (color[i] != 0continue
        if (!dfs(i, 1)) return false
    }
    return true
}
  • 时间复杂度:
  • 空间复杂度:

反向点 + 并查集

我们知道对于 而言,点 a 和点 b 必然位于不同的集合中,同时由于只有两个候选集合,因此这样的关系具有推断性:即对于 可知 ac 位于同一集合。

因此,我们可以对于每个点 x 而言,建议一个反向点 x + n:若点 x 位于集合 A 则其反向点 x + n 位于集合 B,反之同理。

基于此,我们可以使用「并查集」维护所有点的连通性:边维护变检查每个 的联通关系,若 联通,必然是其反向点联通所导致,必然是此前的其他 导致的关系冲突,必然不能顺利划分成两个集合,返回 false,否则返回 true

Java 代码:

class Solution {
    int[] p = new int[4010];
    int find(int x) {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }
    void union(int a, int b) {
        p[find(a)] = p[find(b)];
    }
    boolean query(int a, int b) {
        return find(a) == find(b);
    }
    public boolean possibleBipartition(int n, int[][] ds) {
        for (int i = 1; i <= 2 * n; i++) p[i] = i;
        for (int[] info : ds) {
            int a = info[0], b = info[1];
            if (query(a, b)) return false;
            union(a, b + n); union(b, a + n);
        }
        return true;
    }
}

C++ 代码:

class Solution {
public:
    vector<int> p;
    int find(int x) {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }
    void unionp(int a, int b) {
        p[find(a)] = p[find(b)];
    }
    bool query(int a, int b) {
        return find(a) == find(b);
    }
    bool possibleBipartition(int n, vector<vector<int>>& ds) {
        p.resize(2 * n + 1);
        for (int i = 1; i <= 2 * n; ++i) p[i] = i;
        for (const auto& info : ds) {
            int a = info[0], b = info[1];
            if (query(a, b)) return false;
            unionp(a, b + n);
            unionp(b, a + n);
        }
        return true;
    }
};

Python 代码:

class Solution:
    def possibleBipartition(self, n: int, ds: List[List[int]]) -> bool:
        p = [i for i in range(02 * n + 10)]
        def find(x):
            if p[x] != x:
                p[x] = find(p[x])
            return p[x]
        def union(a, b):
            p[find(a)] = p[find(b)]
        def query(a, b):
            return find(a) == find(b)
        for info in ds:
            a, b = info[0], info[1]
            if query(a, b):
                return False
            else:
                union(a, b + n)
                union(b, a + n)
        return True

TypeScript 代码:

function possibleBipartition(n: number, ds: number[][]): boolean {
    const p = new Array<number>(4010).fill(0)
    function find(x: number): number {
        if (p[x] != x) p[x] = find(p[x])
        return p[x]
    }
    function union(a: number, b: number): void {
        p[find(a)] = p[find(b)]
    }
    function query(a: number, b: number): boolean {
        return find(a) == find(b)
    }
    for (let i = 1; i <= 2 * n; i++) p[i] = i
    for (const info of ds) {
        const a = info[0], b = info[1]
        if (query(a, b)) return false
        union(a, b + n); union(b, a + n)
    }
    return true
}
  • 时间复杂度:
  • 空间复杂度:

最后

给大伙通知一下 📢 :

全网最低价 LeetCode 会员目前仍可用 ~

📅 年度会员:有效期加赠两个月!!; 季度会员:有效期加赠两周!!

🧧 年度会员:获 66.66 现金红包!!; 季度会员:获 22.22 现金红包!!

🎁 年度会员:参与当月丰厚专属实物抽奖(中奖率 > 30%)!!

专属链接:leetcode.cn/premium/?promoChannel=acoier

我是宫水三叶,每天都会分享算法知识,并和大家聊聊近期的所见所闻。

欢迎关注,明天见。

更多更全更热门的「笔试/面试」相关资料可访问排版精美的 合集新基地 🎉🎉

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.luyixian.cn/news_show_1053128.aspx

如若内容造成侵权/违法违规/事实不符,请联系dt猫网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Linux x86_64 UEFI 启动

文章目录 前言一、UEFI二、Disk device compatibility2.1 GPT 磁盘分区表2.1.1 简介2.1.2 Linux 2.2 ESP&#xff08;EFI&#xff09; 文件系统2.2.1 简介2.2.2 LinuxLinux Kernel EFI Boot Stub 三、UEFI GPT grub23.1 简介3.2 引导方式 3.3 BOOTX64.EFI3.4 shimx64.efi3.5 …

Go语言

文章目录 Go语言特点应用领域Go语言和Java语言的对比JavaGo 总结 Go语言安装配置环境变量Hello World Go语言 Go语言全称Golanguage&#xff0c;Go&#xff08;又称 Golang&#xff09;是 Google 的 Robert Griesemer&#xff0c;Rob Pike 及 Ken Thompson 开发的一种静态强类…

CogVLM2: 智谱开源新一代多模态大模型!

节前&#xff0c;我们组织了一场算法岗技术&面试讨论会&#xff0c;邀请了一些互联网大厂朋友、今年参加社招和校招面试的同学。 针对大模型技术趋势、大模型落地项目经验分享、新手如何入门算法岗、该如何准备面试攻略、面试常考点等热门话题进行了深入的讨论。 汇总合集…

三、自定义信号和槽函数(无参和有参)

需求&#xff1a; 下班后&#xff0c;小明说请小红吃好吃的&#xff0c;随便吃&#xff0c;吃啥买啥 无参&#xff1a;小红没有提出吃啥 有参&#xff1a;小红提出自己想吃的东西&#xff0c;吃啥取决于一时兴起&#xff08;emit触发&#xff09; 思路&#xff1a; 1&#xff…

钉钉企业内部H5微应用或小程序之钉消息推送

钉钉简单的推送钉消息 一、钉钉准备工作 首先进入钉钉开放平台 你得有企业内部微应用或者小程序 没有创建的话去看我另一篇文章有说明 钉钉开放平台创建企业内部H5微应用或者小程序-CSDN博客 看不懂话也可以参考官方文档&#xff1a;创建应用 - 钉钉开放平台 二、开发的准备…

微服务项目收获和总结---第5天(定时发布)

延迟任务 目录 延迟任务技术对比&#xff1a; Redis实现定时任务&#xff1a;​编辑新增任务&#xff1a;取消任务&#xff1a;拉取任务&#xff1a;Zset定时刷新数据到List中&#xff1a;分布式锁实现定时任务只刷新一次&#xff1a; 技术对比&#xff1a; Redis实现定时任…

软考数据库系统工程师试题及答案,分享几个实用搜题和学习工具 #媒体#知识分享#知识分享

以下分享的软件提供了各种实用的功能&#xff0c;如数学公式计算、语文阅读辅助等&#xff0c;让大学生们在学习过程中更加高效和便利。 1.众课帮 这是搜题app 一款考试找答案工具 &#xff0c;支持拍照、语音、文字三种搜题方式。拥有海量题库&#xff0c;覆盖了大学生网课…

二零二四充能必读 | 618火热来袭,编程书单助你提升代码力

文章目录 &#x1f4d8; Java领域的经典之作&#x1f40d; Python学习者的宝典&#x1f310; 前端开发者的权威指南&#x1f512; 并发编程的艺术&#x1f916; JVM的深入理解&#x1f3d7; 构建自己的编程语言&#x1f9e0; 编程智慧的结晶&#x1f31f; 代码效率的提升 亲爱的…

Spring系列-02-Bean类型, 作用域, 实例化, 生命周期

Bean类型, 作用域, 实例化, 生命周期 Bean类型 在 SpringFramework 中,对于 Bean 的类型,一般有两种设计: 普通BeanFactoryBean 普通Bean 三种方式 Component注解配置类Beanxml <bean> Component public class Child {}Bean public Child child() {return new Ch…

mars3d实现geojson文件xxx.json格式等实现贴地效果

说明&#xff1a; 1.mars3d.js我们的这个sdk内部参数clampToGround是异步计算贴地效果的&#xff0c;最好的贴地方式是&#xff0c;给json数据准确的带高度的经纬度值。 补充前置知识说明&#xff0c;本身的geojson数据格式每个字段代表的意思需要掌握&#xff0c; GeoJSON …

Java super关键字

super代表父类的引用&#xff0c;用于访问父类的属性、方法和构造器。 1、super的访问不限于直接父类&#xff1a; 若爷爷类和本类有同名的成员&#xff0c;也可以使用super去访问。 若多个上级类都有同名成员&#xff0c;使用super则遵循就近原则。 2、super和this比较&…

弘君资本炒股技巧:股票定向增发是什么意思?是好是坏?

股票定向增发是指已上市的公司向指定的组织或者个人投资者额外发行股份募集资金的融资方法&#xff0c;发行价格为发行前某一阶段的平均价的必定比例&#xff0c;增发的价格不得低于前二十个买卖日股票均价的80&#xff05;。 例如&#xff0c;个股定增前二十个买卖股票平均价为…

Generate Anything Anywhere in Any Scene #论文阅读

URL https://arxiv.org/pdf/2306.17154 TD;DR 2023 年 6 月 Wisconsin 的文章。围绕 ip 保持做的扩展任务&#xff0c;核心目标是对指定 ip 可以生成任意大小的&#xff08;指定 ip&#xff09;、任意背景的图片&#xff0c;同时可以通过 bbox 控制物体位置和多物体生成。主…

外卖系统源码解读:校园外卖APP开发全攻略

外卖系统源码解读&#xff1a;校园外卖APP开发全攻略 今天&#xff0c;小编将深入解读外卖系统的源码&#xff0c;详细介绍如何开发一款功能齐全的校园外卖APP&#xff0c;帮助开发者快速上手&#xff0c;打造出高质量的外卖应用。 一、需求分析 应具备以下基本功能&#xff…

vue中的$nextTick和过渡与动画

一.vue中的$nextTick 简述与用法&#xff1a;这是一个生命周期钩子 1.语法&#xff1a;this.$nextTick(回调函数) 2.作用&#xff1a;在下一次DOM更新结束后执行其指定的回调 3.什么时候用&#xff1a;当修改数据后&#xff0c;要基于更新后的新dom进行某些操作时&#xff0c;…

学习笔记之——2D Gaussian Splatting(2DGS)

3DGS在辐射场重建中取得了巨大的成就&#xff0c;实现高质量的新视图合成和快速渲染。最近新出了3DGS的升级版本&#xff0c;2DGS。写下本博文记录本人学习及测试2DGS的过程&#xff0c;本博文仅为本人学习记录用~ Project WebsiteGithub CodeOriginal paper 原理解读 由于3D…

汽车短视频怎么拍?成都科成博通文化传媒公司

汽车短视频怎么拍&#xff1f; 随着短视频平台的兴起&#xff0c;汽车爱好者们纷纷将自己的汽车生活、驾驶体验以及车辆评测等内容以短视频的形式呈现给大众。汽车短视频不仅满足了观众对汽车文化的好奇心&#xff0c;也为汽车品牌和汽车相关行业提供了宣传和推广的新渠道。那…

【机器学习】机器学习基础概念与初步探索

❀机器学习 &#x1f4d2;1. 引言&#x1f4d2;2. 机器学习概述&#x1f4d2;3. 机器学习基础概念&#x1f389;2.1 机器学习的分类&#x1f389;2.2 数据预处理&#x1f308;数据清洗与整合&#x1f308; 特征选择和特征工程&#x1f308;数据标准化与归一化 &#x1f4d2;4. …

Mesa Gallium框架入门初探

Mesa Gallium框架入门初探 MESA Gallium框架 MESA源码里面有2套架构&#xff0c;现在驱动主要基于Gallium架构。 这里我们重点来看看Gallium架构: 经典架构 Gallium架构 Gallium展开 Gallium中主要包含下面几块&#xff1a; Auxiliary模块&#xff1a;一些公共函数或者辅助…

菜鸟的JavaSE学习之旅5

这是一个目录 面向对象类和对象类对象类的定义一个对象的内存成员变量和局部变量定义位置不同作用范围不同默认值不同内存位置不同生命周期不同 关键字this关键字 构造方法标准的类 面向对象 当需要实现一个功能的时候&#xff0c;不关心具体的步骤&#xff0c;而是找一个具有…