蚂蚁集团发布全员信:薪资大调整。

火山方舟向量数据库大模型

最近蚂蚁集团发布全员信,宣布对薪酬体系进行重大调整!目的是要 提升员工薪酬收入的流动性和激励即时性,进一步优化激励机制。

17级及以下同学,13薪没有了,并入到每月的基本工资中发放, 员工每个月拿到手的钱会更多,增加月度现金流。

此项调整自2025年1月生效,并于2025年3月底发薪开始体现,并补齐1月、2月差额。

18级及以上同学,13薪并入到年终奖, 与绩效激励挂钩 。

自2025年绩效年度起,基于年度考核增加1个月的月薪作为奖金基数,提高整体薪酬中浮动的占比。

我的理解是如果绩效不好的话,是不是13薪也没了?

如果是在职的还好说,13薪并入到基本工资的时候,基本工资相当于涨了一下,对于以后入职的是不是意味着没有13薪了?

picture.image

picture.image

--------------下面是今天的算法题--------------

来看下今天的算法题,这题是LeetCode的第 77题:组合。

问题描述

来源:LeetCode第77题

难度:中等

给定两个整数 n 和 k,返回范围 [1, n] 中所有可能的 k 个数的组合。你可以按任何顺序返回答案。

示例1:

输入

:n = 4, k = 2

输出

[

[2,4],

[3,4],

[2,3],

[1,2],

[1,3],

[1,4],

]

示例2:

输入

:n = 1, k = 1

输出

:[[1]]

  • 1 <= n <= 20

  • 1 <= k <= n

问题分析

这题返回从 1 到 n 中所有 k 个数的组合,所谓的组合也就是从数组中选择 k 个数,这种选择只是其中的一个组合。我们知道排列是有顺序的,但组合是没有顺序的,比如[1,2]和[2,1]只能算一个组合。组合选择的过程我们可以把它看作是一棵树,如下图所示:

picture.image

因为每个数字在每个组合中只能选择一次,所以选择当前数字的时候,下一步只能选择他后面的数字,否则就会出现类似于[1,2]和[2,1]这种重复的组合。当选择个数达到 k 个的时候就不要再往下选了,然后把这个组合添加到最终的集合中,这是一道回溯算法问题,代码非常简单。

JAVA:


                  
                  
                      

                    
 public
 
                     List<List<Integer>> combine(
                    
 int
 
                     n, 
                    
 int
 
                     k) {
                    
   

 
                        List<List<Integer>> ans = 
                    
 new
 
                     ArrayList<>();
                    
   

 
                        dfs(ans, 
                    
 new
 
                     ArrayList<>(k), n, k, 
                    
 1
 
                    );
                    
   

 
                        
                    
 return
 
                     ans;
                    
   

 
                    }
                    
   

 
                    
   

 
                    
 
 private
 
  
 
 void
 
  
 
 dfs
 
 
 (List<List<Integer>> ans, List<Integer> path, 
 
 int
 
  n, 
 
 int
 
  k, 
 
 int
 
  start)
 
  
 
                    {
                    
   

 
                        
                    
 if
 
                     (path.size() == k) {
                    
   

 
                            ans.add(
                    
 new
 
                     ArrayList<>(path));
                    
   

 
                            
                    
 return
 
                    ;
                    
   

 
                        }
                    
   

 
                        
                    
 for
 
                     (
                    
 int
 
                     i = start; i <= n; i++) {
                    
   

 
                            path.add(i);
                    
 // 选择
 
                    
   

 
                            dfs(ans, path, n, k, i + 
                    
 1
 
                    );
                    
 // 递归到下一层
 
                    
   

 
                            path.remove(path.size() - 
                    
 1
 
                    );
                    
 // 撤销选择
 
                    
   

 
                        }
                    
   

 
                    }
                    
   

 
                  
                

C++:


                  
                  
                      

                    
 public
 
                    :
                    
   

 
                        
                    
 
 vector
 
 <
 
 vector
 
 <
 
 int
 
 >> 
 
 combine
 
 
 (
 
 int
 
  n, 
 
 int
 
  k)
 
  
 
                    {
                    
   

 
                            
                    
 vector
 
                    <
                    
 vector
 
                    <
                    
 int
 
                    >> ans;
                    
   

 
                            
                    
 vector
 
                    <
                    
 int
 
                    > path;
                    
   

 
                            dfs(ans, path, n, k, 
                    
 1
 
                    );
                    
   

 
                            
                    
 return
 
                     ans;
                    
   

 
                        }
                    
   

 
                    
   

 
                        
                    
 
 void
 
  
 
 dfs
 
 
 (
 
 vector
 
 <
 
 vector
 
 <
 
 int
 
 >> &ans, 
 
 vector
 
 <
 
 int
 
 > &path, 
 
 int
 
  n, 
 
 int
 
  k, 
 
 int
 
  start)
 
  
 
                    {
                    
   

 
                            
                    
 if
 
                     (path.size() == k) {
                    
   

 
                                ans.emplace\_back(path);
                    
   

 
                                
                    
 return
 
                    ;
                    
   

 
                            }
                    
   

 
                            
                    
 for
 
                     (
                    
 int
 
                     i = start; i <= n; i++) {
                    
   

 
                                path.emplace\_back(i);
                    
 // 选择
 
                    
   

 
                                dfs(ans, path, n, k, i + 
                    
 1
 
                    );
                    
 // 递归到下一层
 
                    
   

 
                                path.pop\_back();
                    
 // 撤销选择
 
                    
   

 
                            }
                    
   

 
                        }
                    
   

 
                  
                

Python:


                  
                  
                      

                    
 
 def
 
  
 
 combine
 
 
 (self, n: int, k: int)
 
  -> List[List[int]]:
 
                    
   

 
                        ans = []
                    
   

 
                        path = []
                    
   

 
                    
   

 
                        
                    
 
 def
 
  
 
 dfs
 
 
 (start: int)
 
 :
 
                    
   

 
                            
                    
 if
 
                     len(path) == k:
                    
   

 
                                ans.append(path[:])
                    
   

 
                                
                    
 return
 
                    
   

 
                            
                    
 for
 
                     i 
                    
 in
 
                     range(start, n + 
                    
 1
 
                    ):
                    
   

 
                                path.append(i)  
                    
 # 选择
 
                    
   

 
                                dfs(i + 
                    
 1
 
                    )  
                    
 # 递归到下一层
 
                    
   

 
                                path.pop()  
                    
 # 撤销选择
 
                    
   

 
                    
   

 
                        dfs(
                    
 1
 
                    )
                    
   

 
                        
                    
 return
 
                     ans
                    
   

 
                  
                

picture.image

最后欢迎 加入苏三的星球 ,你将获得:苏三AI项目、 商城微服务实战、商城系统实战、秒杀系统实战 、秒杀系统实战、代码生成工具、系统设计、性能优化、技术选型、底层原理、Spring源码解读、工作经验分享、痛点问题、面试八股文等多个优质专栏。

还有1V1答疑、修改简历、职业规划、送书活动、技术交流。

送给大家一张40元优惠券,扫描下方二维码,即可加入星球:

picture.image

目前星球已经更新了5200+篇优质内容,还在持续爆肝中.....

星球已经被官方推荐了3次,收到了小伙伴们的一致好评。戳我加入学习,已有1600+小伙伴加入学习。

picture.image

0
0
0
0
关于作者
关于作者

文章

0

获赞

0

收藏

0

相关资源
高性能存储虚拟化方案 NVMe over Fabric 在火山引擎的演进
在云计算中,虚拟化存储扮演着重要角色,其中 iSCSI 协议在业界开放、流行多年。近年来,拥有更优性能的 NVMe over Fabrics 协议也得到了发展。本次分享介绍了 NVMe over Fabrics 在云原生和虚拟化方向的演进工作和成果。
相关产品
评论
未登录
看完啦,登录分享一下感受吧~
暂无评论