腾讯（校招）二面算法原题全解析

最新推荐文章于 2024-09-15 16:54:15 发布
最新推荐文章于 2024-09-15 16:54:15 发布
阅读量698 收藏 8
点赞数 27
文章标签： 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_33243821/article/details/141142565
版权

KFC 限酱

近日，有网友发现，肯德基开始限酱。

在最新的肯德基外卖袋上显示："您购买的肯德基产品，我们只有薯条和黄金鸡块送一份蘸酱。"

alt

肯德基官方客服表示，这确实是最近一个月新出的规定，除"薯条"和"黄金鸡块"外，其他产品是没有蘸酱的。

其中黄金鸡块给的是甜辣酱和糖醋酱，薯条给的是番茄酱。

对于薯条是否能配鸡块酱，对方表示："没有办法给的，现在薯条标配的是番茄酱。"

有网友表示，自己没点薯条与黄金鸡块，但点了很多其他食品，向店员"软磨硬泡了十几分钟，愣是不给，最后干脆假装听不到，不回应"，最后当自己对着店铺拍照，准备给差评并投诉的时候，店员又追出来表示，可以提供酱料。

显然，一切都是因为成本。

肯德基 2024 年上半年营收 42.44 亿美元，较上年同期的 41.82 亿美元增长 2%，但经营利润 6.36 亿美元，较上年同期的 6.93 亿美元下降 8%：

增收不增利或许是 KFC "动酱"的主要原因。

对此，你怎么看？

...

回归主题。

最近腾讯开始了 2025 届校招，来一道和往年「腾讯（校招）」相关的题目。

同时也借这道题，系统学习一下「最短路」的各种算法以及建图方式。

题目描述

平台：LeetCode

题号：743

有 n 个网络节点，标记为 1 到 n。

给你一个列表 times，表示信号经过有向边的传递时间。

times[i] = (ui, vi, wi)，其中 ui 是源节点，vi 是目标节点，wi 是一个信号从源节点传递到目标节点的时间

现在，从某个节点 K 发出一个信号。需要多久才能使所有节点都收到信号？

如果不能使所有节点收到信号，返回 -1。

示例 1：

alt 
输入：times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2

输出：2

示例 2：

输入：times = [[1,2,1]], n = 2, k = 1

输出：1

示例 3：

输入：times = [[1,2,1]], n = 2, k = 2

输出：-1

提示：

  • 所有 对都 互不相同（即不含重复边）

基本分析

为了方便，我们约定 n 为点数，m 为边数。

根据题意，首先 n 的数据范围只有 100，m 的数据范围为 6000，使用「邻接表」或「邻接矩阵」来存图都可以。

同时求的是「从 k 点出发，所有点都被访问到的最短时间」，将问题转换一下其实就是求「从 k 点出发，到其他点 x 的最短距离的最大值」。

存图方式

在开始讲解最短路之前，我们先来学习三种「存图」方式。

邻接矩阵

这是一种使用二维矩阵来进行存图的方式。

适用于边数较多的「稠密图」使用，当边数量接近点的数量的平方，即 时，可定义为「稠密图」。

// 邻接矩阵数组：w[a][b] = c 代表从 a 到 b 有权重为 c 的边
int[][] w = new int[N][N];

// 加边操作
void add(int a, int b, int c) {
    w[a][b] = c;
}
邻接表

这也是一种在图论中十分常见的存图方式，与数组存储单链表的实现一致（头插法）。

这种存图方式又叫「链式前向星存图」。

适用于边数较少的「稀疏图」使用，当边数量接近点的数量，即 时，可定义为「稀疏图」。

int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
int idx;

void add(int a, int b, int c) {
    e[idx] = b;
    ne[idx] = he[a];
    he[a] = idx;
    w[idx] = c;
    idx++;
}

首先 idx 是用来对边进行编号的，然后对存图用到的几个数组作简单解释：

  • he 数组：存储是某个节点所对应的边的集合（链表）的头结点；
  • e 数组：由于访问某一条边指向的节点；
  • ne 数组：由于是以链表的形式进行存边，该数组就是用于找到下一条边；
  • w 数组：用于记录某条边的权重为多少。

因此当我们想要遍历所有由 a 点发出的边时，可以使用如下方式：

for (int i = he[a]; i != -1; i = ne[i]) {
    int b = e[i], c = w[i]; // 存在由 a 指向 b 的边，权重为 c
}
类

这是一种最简单，但是相比上述两种存图方式，使用得较少的存图方式。

只有当我们需要确保某个操作复杂度严格为 时，才会考虑使用。

具体的，我们建立一个类来记录有向边信息：

class Edge {
    // 代表从 a 到 b 有一条权重为 c 的边
    int a, b, c;
    Edge(int _a, int _b, int _c) {
        a = _a; b = _b; c = _c;
    }
}

通常我们会使用 List 存起所有的边对象，并在需要遍历所有边的时候，进行遍历：

List<Edge> es = new ArrayList<>();

...

for (Edge e : es) {
    ...
}

Floyd（邻接矩阵）

根据「基本分析」，我们可以使用复杂度为 的「多源汇最短路」算法 Floyd 算法进行求解，同时使用「邻接矩阵」来进行存图。

此时计算量约为 1e6，可以过。

跑一遍 Floyd，可以得到「从任意起点出发，到达任意起点的最短距离」。然后从所有 中取 max 即是「从 k 点出发，到其他点 x 的最短距离的最大值」。

alt

代码：

class Solution {
    int N = 110, M = 6010;
    // 邻接矩阵数组：w[a][b] = c 代表从 a 到 b 有权重为 c 的边
    int[][] w = new int[N][N];
    int INF = 0x3f3f3f3f;
    int n, k;
    public int networkDelayTime(int[][] ts, int _n, int _k) {
        n = _n; k = _k;
        // 初始化邻接矩阵
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                w[i][j] = w[j][i] = i == j ? 0 : INF;
            }
        }
        // 存图
        for (int[] t : ts) {
            int u = t[0], v = t[1], c = t[2];
            w[u][v] = c;
        }
        // 最短路
        floyd();
        // 遍历答案
        int ans = 0;
        for (int i = 1; i <= n; i++) {
            ans = Math.max(ans, w[k][i]);
        }
        return ans >= INF / 2 ? -1 : ans;
    }
    void floyd() {
        // floyd 基本流程为三层循环：
        // 枚举中转点 - 枚举起点 - 枚举终点 - 松弛操作        
        for (int p = 1; p <= n; p++) {
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    w[i][j] = Math.min(w[i][j], w[i][p] + w[p][j]);
                }
            }
        }
    }
}
  • 时间复杂度：
  • 空间复杂度：

朴素 Dijkstra（邻接矩阵）

同理，我们可以使用复杂度为 的「单源最短路」算法朴素 Dijkstra 算法进行求解，同时使用「邻接矩阵」来进行存图。

根据题意，k 点作为源点，跑一遍 Dijkstra 我们可以得到从源点 k 到其他点 x 的最短距离，再从所有最短路中取 max 即是「从 k 点出发，到其他点 x 的最短距离的最大值」。

朴素 Dijkstra 复杂度为 ，可以过。

alt

代码：

class Solution {
    int N = 110, M = 6010;
    // 邻接矩阵数组：w[a][b] = c 代表从 a 到 b 有权重为 c 的边
    int[][] w = new int[N][N];
    // dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y
    int[] dist = new int[N];
    // 记录哪些点已经被更新过
    boolean[] vis = new boolean[N];
    int INF = 0x3f3f3f3f;
    int n, k;
    public int networkDelayTime(int[][] ts, int _n, int _k) {
        n = _n; k = _k;
        // 初始化邻接矩阵
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                w[i][j] = w[j][i] = i == j ? 0 : INF;
            }
        }
        // 存图
        for (int[] t : ts) {
            int u = t[0], v = t[1], c = t[2];
            w[u][v] = c;
        }
        // 最短路
        dijkstra();
        // 遍历答案
        int ans = 0;
        for (int i = 1; i <= n; i++) {
            ans = Math.max(ans, dist[i]);
        }
        return ans > INF / 2 ? -1 : ans;
    }
    void dijkstra() {
        // 起始先将所有的点标记为「未更新」和「距离为正无穷」
        Arrays.fill(vis, false);
        Arrays.fill(dist, INF);
        // 只有起点最短距离为 0
        dist[k] = 0;
        // 迭代 n 次
        for (int p = 1; p <= n; p++) {
            // 每次找到「最短距离最小」且「未被更新」的点 t
            int t = -1;
            for (int i = 1; i <= n; i++) {
                if (!vis[i] && (t == -1 || dist[i] < dist[t])) t = i;
            }
            // 标记点 t 为已更新
            vis[t] = true;
            // 用点 t 的「最小距离」更新其他点
            for (int i = 1; i <= n; i++) {
                dist[i] = Math.min(dist[i], dist[t] + w[t][i]);
            }
        }
    }
}
  • 时间复杂度：
  • 空间复杂度：

堆优化 Dijkstra（邻接表）

由于边数据范围不算大，我们还可以使用复杂度为 的堆优化 Dijkstra 算法进行求解。

堆优化 Dijkstra 算法与朴素 Dijkstra 都是「单源最短路」算法。

跑一遍堆优化 Dijkstra 算法求最短路，再从所有最短路中取 max 即是「从 k 点出发，到其他点 x 的最短距离的最大值」。

此时算法复杂度为 ，可以过。

alt

代码：

class Solution {
    int N = 110, M = 6010;
    // 邻接表
    int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
    // dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y
    int[] dist = new int[N];
    // 记录哪些点已经被更新过
    boolean[] vis = new boolean[N];
    int n, k, idx;
    int INF = 0x3f3f3f3f;
    void add(int a, int b, int c) {
        e[idx] = b;
        ne[idx] = he[a];
        he[a] = idx;
        w[idx] = c;
        idx++;
    }
    public int networkDelayTime(int[][] ts, int _n, int _k) {
        n = _n; k = _k;
        // 初始化链表头
        Arrays.fill(he, -1);
        // 存图
        for (int[] t : ts) {
            int u = t[0], v = t[1], c = t[2];
            add(u, v, c);
        }
        // 最短路
        dijkstra();
        // 遍历答案
        int ans = 0;
        for (int i = 1; i <= n; i++) {
            ans = Math.max(ans, dist[i]);
        }
        return ans > INF / 2 ? -1 : ans;
    }
    void dijkstra() {
        // 起始先将所有的点标记为「未更新」和「距离为正无穷」
        Arrays.fill(vis, false);
        Arrays.fill(dist, INF);
        // 只有起点最短距离为 0
        dist[k] = 0;
        // 使用「优先队列」存储所有可用于更新的点
        // 以 (点编号, 到起点的距离) 进行存储，优先弹出「最短距离」较小的点
        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[1]-b[1]);
        q.add(new int[]{k, 0});
        while (!q.isEmpty()) {
            // 每次从「优先队列」中弹出
            int[] poll = q.poll();
            int id = poll[0], step = poll[1];
            // 如果弹出的点被标记「已更新」，则跳过
            if (vis[id]) continue;
            // 标记该点「已更新」，并使用该点更新其他点的「最短距离」
            vis[id] = true;
            for (int i = he[id]; i != -1; i = ne[i]) {
                int j = e[i];
                if (dist[j] > dist[id] + w[i]) {
                    dist[j] = dist[id] + w[i];
                    q.add(new int[]{j, dist[j]});
                }
            }
        }
    }
}
  • 时间复杂度：
  • 空间复杂度：

Bellman Ford（类 & 邻接表）

虽然题目规定了不存在「负权边」，但我们仍然可以使用可以在「负权图中求最短路」的 Bellman Ford 进行求解，该算法也是「单源最短路」算法，复杂度为 。

通常为了确保 ，可以单独建一个类代表边，将所有边存入集合中，在 n 次松弛操作中直接对边集合进行遍历（代码见 P1）。

由于本题边的数量级大于点的数量级，因此也能够继续使用「邻接表」的方式进行边的遍历，遍历所有边的复杂度的下界为 ，上界可以确保不超过 （代码见 P2）。

alt

代码：

class Solution {
    class Edge {
        int a, b, c;
        Edge(int _a, int _b, int _c) {
            a = _a; b = _b; c = _c;
        }
    }
    int N = 110, M = 6010;
    // dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y
    int[] dist = new int[N];
    int INF = 0x3f3f3f3f;
    int n, m, k;
    // 使用类进行存边
    List<Edge> es = new ArrayList<>();
    public int networkDelayTime(int[][] ts, int _n, int _k) {
        n = _n; k = _k;
        m = ts.length;
        // 存图
        for (int[] t : ts) {
            int u = t[0], v = t[1], c = t[2];
            es.add(new Edge(u, v, c));
        }
        // 最短路
        bf();
        // 遍历答案
        int ans = 0;
        for (int i = 1; i <= n; i++) {
            ans = Math.max(ans, dist[i]);
        }
        return ans > INF / 2 ? -1 : ans;
    }
    void bf() {
        // 起始先将所有的点标记为「距离为正无穷」
        Arrays.fill(dist, INF);
        // 只有起点最短距离为 0
        dist[k] = 0;
        // 迭代 n 次
        for (int p = 1; p <= n; p++) {
            int[] prev = dist.clone();
            // 每次都使用上一次迭代的结果，执行松弛操作
            for (Edge e : es) {
                int a = e.a, b = e.b, c = e.c;
                dist[b] = Math.min(dist[b], prev[a] + c);
            }
        }
    }
}
class Solution {
    int N = 110, M = 6010;
    // 邻接表
    int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
    // dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y
    int[] dist = new int[N];
    int INF = 0x3f3f3f3f;
    int n, m, k, idx;
    void add(int a, int b, int c) {
        e[idx] = b;
        ne[idx] = he[a];
        he[a] = idx;
        w[idx] = c;
        idx++;
    }
    public int networkDelayTime(int[][] ts, int _n, int _k) {
        n = _n; k = _k;
        m = ts.length;
        // 初始化链表头
        Arrays.fill(he, -1);
        // 存图
        for (int[] t : ts) {
            int u = t[0], v = t[1], c = t[2];
            add(u, v, c);
        }
        // 最短路
        bf();
        // 遍历答案
        int ans = 0;
        for (int i = 1; i <= n; i++) {
            ans = Math.max(ans, dist[i]);
        }
        return ans > INF / 2 ? -1 : ans;
    }
    void bf() {
        // 起始先将所有的点标记为「距离为正无穷」
        Arrays.fill(dist, INF);
        // 只有起点最短距离为 0
        dist[k] = 0;
        // 迭代 n 次
        for (int p = 1; p <= n; p++) {
            int[] prev = dist.clone();
            // 每次都使用上一次迭代的结果，执行松弛操作
            for (int a = 1; a <= n; a++) {
                for (int i = he[a]; i != -1; i = ne[i]) {
                    int b = e[i];
                    dist[b] = Math.min(dist[b], prev[a] + w[i]);
                }
            }
        }
    }
}
  • 时间复杂度：
  • 空间复杂度：

SPFA（邻接表）

SPFA 是对 Bellman Ford 的优化实现，可以使用队列进行优化，也可以使用栈进行优化。

通常情况下复杂度为 ，k 一般为 4 到 5，最坏情况下仍为 ，当数据为网格图时，复杂度会从 退化为 。

alt

代码：

class Solution {
    int N = 110, M = 6010;
    // 邻接表
    int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
    // dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y
    int[] dist = new int[N];
    // 记录哪一个点「已在队列」中
    boolean[] vis = new boolean[N];
    int INF = 0x3f3f3f3f;
    int n, k, idx;
    void add(int a, int b, int c) {
        e[idx] = b;
        ne[idx] = he[a];
        he[a] = idx;
        w[idx] = c;
        idx++;
    }
    public int networkDelayTime(int[][] ts, int _n, int _k) {
        n = _n; k = _k;
        // 初始化链表头
        Arrays.fill(he, -1);
        // 存图
        for (int[] t : ts) {
            int u = t[0], v = t[1], c = t[2];
            add(u, v, c);
        }
        // 最短路
        spfa();
        // 遍历答案
        int ans = 0;
        for (int i = 1; i <= n; i++) {
            ans = Math.max(ans, dist[i]);
        }
        return ans > INF / 2 ? -1 : ans;
    }
    void spfa() {
        // 起始先将所有的点标记为「未入队」和「距离为正无穷」
        Arrays.fill(vis, false);
        Arrays.fill(dist, INF);
        // 只有起点最短距离为 0
        dist[k] = 0;
        // 使用「双端队列」存储，存储的是点编号
        Deque<Integer> d = new ArrayDeque<>();
        // 将「源点/起点」进行入队，并标记「已入队」
        d.addLast(k);
        vis[k] = true;
        while (!d.isEmpty()) {
            // 每次从「双端队列」中取出，并标记「未入队」
            int poll = d.pollFirst();
            vis[poll] = false;
            // 尝试使用该点，更新其他点的最短距离
            // 如果更新的点，本身「未入队」则加入队列中，并标记「已入队」
            for (int i = he[poll]; i != -1; i = ne[i]) {
                int j = e[i];
                if (dist[j] > dist[poll] + w[i]) {
                    dist[j] = dist[poll] + w[i];
                    if (vis[j]) continue;
                    d.addLast(j);
                    vis[j] = true;
                }
            }
        }
    }
}
  • 时间复杂度：
  • 空间复杂度：

最后

巨划算的 LeetCode 会员优惠通道目前仍可用 ~

使用福利优惠通道 leetcode.cn/premium/?promoChannel=acoier，年度会员 有效期额外增加两个月，季度会员 有效期额外增加两周，更有超大额专属 🧧 和实物 🎁 福利每月发放。

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

欢迎关注，明天见。

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

宫水三叶的刷题日记
关注
2024腾讯校招后端面试真题汇总及其解答（三）
十年互联网开发老兵，陪你一起学技术
09-05 1069
例如字符类型的’9’转换成int的9： ‘9’ - ‘0’ = 9。还有就是相加时要注意进位的问题。花里胡哨的，直接用两个指针来修改相邻两个节点之间的连接关系就好了。两个字符串的数字相加，核心点考的是ASCII码和相加进位的问题。，请反转链表，并返回反转后的链表的头节点。在退层回溯时修改节点之间的连接关系。如下图所示，题目要求将链表反转。时间复杂度 O(n)空间复杂度 O(n)时间复杂度 O(n)空间复杂度 O(n)时间复杂度 O(n)空间复杂度 O(1)
2019腾讯校园招聘开发岗面经（一面+二面+HR面），已拿offer
热门推荐
weixin_39142112的博客
11-01 3万+
2019腾讯校园招聘开发岗面经（一面+二面+HR面） 背景： 华为实习结束前两天，突然接到腾讯的邮件，邀请我现场面试，但面试前需要我做道题，这道题的回答内容将作为一面时的沟通话题（当时整个人是懵的，咋还有这操作）。暑期实习投的腾讯是安卓岗，华为实习期间是软件开发岗，最后拿到腾讯offer的岗位是专项技术测试开发（我以为和软件测试岗一样，看到题目以及最后和面试官的沟通才发现这根本就是开发，为啥呢？慢...
腾讯2020校园招聘 1. [编程题]压缩算法
xuliwei950318的博客
06-24 686
public static void main(String[] args){ Scanner sc = new Scanner(System.in); String s = sc.nextLine(); Stack<Integer> numStack = new Stack<>(); Stack<String> strStack = new Stack<>(); int n...
解码
qq_45472111的博客
03-18 113
腾讯在线笔试题解答 小Q想要给他的朋友发送一个神秘字符串，但是他发现字符串的过于长了，于是小Q发明了一种压缩算法对字符串中重复的部分进行了压缩，对于字符串中连续的m个相同字符串S将会压缩为m|S，例如字符串ABCABCABC将会被压缩为[3|ABC]，现在小Q的同学收到了小Q发送过来的字符串，你能帮助他进行解压缩么？ #include <iostream> #include <stack> #include <string> #include <sstream&gt
[腾讯校招] 算法基础-字符移位
Achiberx
01-17 373
小Q最近遇到了一个难题：把一个字符串的大写字母放到字符串的后面，各个字符的相对位置不变，且不能申请额外的空间。 你能帮帮小Q吗？输入描述: 输入数据有多组，每组包含一个字符串s，且保证:1<=s.length<=1000. 输出描述: 对于每组数据，输出移位后的字符串。输入例子: AkleBiCeilD输出例子: kleieilABCD#include <iostream> #inclu
记录腾讯算法校招实习一面经验
weixin_43129146的博客
03-16 272
文章目录问题 问题 一.算法题 1.一万大小数组和一亿大小数组交集 几种方法 时间复杂度 2.给定数组求和为sum的两个元素 手撕代码 二.机器学习 1.GBDT的机制 2.GBDT为什么比LR好 3.L1正则化和L2正则化的区别 4.Kmeans的流程和时间复杂度 5.Xgboost调参经验 6.对搜索引擎有什么理解 三.CNN 1.池化层的作用 2.对CNN的理解 四.语言 1.C++和pyt...
腾讯2015实习校招-整形长度算法思路实现
图乐
05-08 789
题意在不使用sizeof()函数的情况下，取出本机的整形所占位数，如32位、64位等。分析我看到题目后的第一思路就是统计二进制中1的个数。但是位数不确定啊，我用了0取反，然后保存的二进制就是N个1了，现在发现-1就行。用unsigned int保存，移位操作统计就好，一个字节8位，所以每次左移8位。
腾讯校招面试解析.zip
08-15
在“腾讯校招面试解析.zip”这个压缩包中，我们可以预见到它包含了关于腾讯公司针对校园招聘面试的相关资料。这份资料对于即将参加腾讯面试的应聘者来说，无疑是宝贵的准备资源。接下来，我们将深入探讨其中可能涉及...
腾讯校招面试笔试题
03-19
腾讯校招笔试题通常会包含编程基础题目，如数据结构（数组、链表、栈、队列、树、图等）、算法（排序、搜索、动态规划、贪心算法等）。例如，可能会要求你实现快速排序或二分查找，或者解决一个与图遍历相关的问题。...
腾讯2017校招开发工程师笔试试题（二）.docx
07-17
- **银行家算法** 是一种预防死锁的算法，而不是检测死锁。 - **剥夺死锁进程的所有资源** 是一种解决死锁的方法之一。 **正确答案：** a. 有序分配锁资源可以预防死锁 c. 剥夺死锁进程的所有资源可以解除死锁 ###...
腾讯校招技术笔试题
04-17
根据提供的标题、描述以及部分内容，我们可以总结出这是关于腾讯校招技术笔试题的相关知识点。下面将详细解析其中涉及的关键概念和技术细节。 ### 腾讯校招技术笔试题概述 腾讯作为中国乃至全球知名的互联网公司之...
腾讯春招后端一面（算法篇）
qq_51118755的博客
03-15 1422
哈喽大家好，前段时间在小红书和牛客上发了面试的经验贴，很多同学留言问算法的具体解法，今天就详细写个帖子回复大家。因为csdn是写的比较详细，所以更新比较慢，大家见谅~~就题目而言，前两题是平时刷题常见的，第三题没有见过，需要认真思考下最后，希望找工作的同学都能收获心仪的offer。
2021年腾讯校招季，各事业部算法题 TOP 10，你能手撕几道？
Web_boom的博客
08-17 694
前言 腾讯校招开始了，不知道大家投了吗？这里为大家整理了腾讯6大事业群校招常问算法题TOP 10 算法题榜，希望能帮助到正在准备面试腾讯校招的同学们。 腾讯共有 6 大事业群： 云与智慧产业事业群 ( CSIG ) 互动娱乐事业群 ( IEG ) 平台与内容事业群 ( PCG ) 技术工程事业群 ( TEG ) 企业发展事业群 ( CDG ) 微信事业群 ( WXG ) 下面列出腾讯各大事业群 Top 10 算法题 声明：以下数据来自 CodeTop，题目编号可以在leetcode上搜索原题。 CS
后续学习规划 ----含我个人的学习路线，经历及感受
最新发布
Yluciud的博客
09-15 1451
规划已经完成了，再接再厉吧。今天主要是规划一下，然后休息了。明天再休息一天。后天开始执行计划。希望再后续可以获得比苍穹外卖时候更好的学习状态。希望可以继续进步，尽快达到可以实习的水平，在今年寒假找到一个后端开发实习。感兴趣的朋友，可以看下我主页置顶的，苍穹外卖学习日志。苍穹外卖学习日志记录了我每天学习的进度和状态，希望也可以帮到正在学习的朋友们。
解决ruoyi-vue-pro-master框架引入报错，启动报错问题
xnian_的博客
09-13 310
以yudao-ui-admin-vue3-master为例，第一次先安装node_modules执行npm -i,然后npm run dev启动项目。如：后端接口：localhost:48080/admin-api/product/brand/page。3.后台启动后，模块启用yudao-server下的pom.xml文件将需要的模块注释去掉。1.以yudao-module-mall模块为例，maven报错情况。2.yudao下面的pom.xml 下引入的modules放开。
零基础5分钟上手亚马逊云科技-利用API网关管理API
m0_66628975的博客
09-12 1422
亚马逊云科技API网关（Amazon API Gateway）是一种完全托管的云原生服务，允许开发者轻松创建、发布、维护、监控和保护API。它可以帮助开发者将后端服务（如AWS Lambda、Amazon EC2等）与客户端（如网页、移动应用）进行安全、可靠的连接。
企业客户|基于springboot的企业客户管理系统设计与实现(附项目源码+论文+数据库）
2301_76166241的博客
09-13 814
本论文主要论述了如何使用JAVA语言开发一个企业客户管理系统，本系统将严格按照软件开发流程进行各个阶段的工作，采用B/S架构，面向对象编程思想进行项目开发。在引言中，作者将论述企业客户管理系统的当前背景以及系统开发的目的，后续章节将严格按照软件开发流程，对系统进行各个阶段分析设计。企业客户管理系统的主要使用者分为管理员和员工，实现功能包括管理员：首页、个人中心员工管理客户信息管理、行业类型管理、项目信息管理、项目类型管理、项目收益管理员工。
前后端分离项目--下载功能
2302_80244686的博客
09-15 426
前后端分离项目中下载与其他接口的使用不同，一般下载不走node，不通过代理服务器，而是直接在前台发送请求，又因为前端使用的是代理服务器，会出现跨域问题，需要后端协助，允许下载文件接口跨域。如果用node，浏览器端还需要判断下载文件类型，从而添加对应的content-type和拓展名，如果后端返的全是200，还可能出现没有文件，下载下来是下图这样的。blob表示二进制的大对象。在数据库管理系统中，将二进制数据存储为一个单一个体的集合。属性用于表示数据的大小（以字节为单位），
腾讯校招面试题解析：二叉树遍历与算法
"企业-腾讯校招面试题真题（20题）-新增.pdf" 这篇文档包含的是腾讯校园招聘面试的真题集，涉及到的数据结构和算法相关的问题，特别是与二叉树遍历、数据结构性能分析以及排序算法有关的知识点。 首先，问题1讨论...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值