职业发展的驱动力应该来自自身，工作属于公司，职业生涯属于自己。

第一要务 拥有正确的心态

大多数人形成的错误的心态: 认为在为公司打工，没有把自己的职业生涯当作生意来看待。铭记在心，开始积极主动的管理自己的职业生涯吧。

像企业一样思考

自己能提供什么:自己的能力就是创造软件
自己需要做什么:

• 持续不断地改进和完善自己的产品

• 传达自己的价值，和千万同行的独特之处

一头扎进工作不可能非同凡响，你应该：

• 专注于你正在提供怎样的服务， 以及如何营销这项服务；
• 想方设 提升你的服务；
• 思考你可以专注为哪一 特定类型的客户或行业提供特定的服务；
• 集中精力成为一位专家，专门为某一特定类型的客户提供专业的整体服务（ 记住， 作为一个软件开发 人员， 你 只有真正专注 于一类客户，才能找到非常好的工作）。
• 更好的宣传自己的产品，更好的找到你的客户

第二要务 设定自己的目标

无论因为何种原因你没有为自己的职业生涯设定目标， 现在都是时候设定目标了。 不是明天， 也不是下周， 就是现在。 没有明确的方向， 你走的每一步都是徒劳的。

如何设定目标？

先在心中树立一个大目标，然后分解成多个小目标

追踪你的目标

定期核对自己的目标，必要时还要调整。

人际交往能力

1. 我就喜欢写代码行不行？

如果刚刚投入工作，工作还无法完全胜任，那我的建议是多写写代码，打怪升级完成自己的年度绩效。

如果已经能够胜任当前工作，下一步应该集中在提效上。这一步和之前自己积累的经验和知识密不可分，只有真正了解代码懂代码，才能从同龄人中的“熟练工”脱颖而出，两者的提效虽然结果一样，但是本质却完全不一样。

如果已经摆脱了熟练工的称号，实际上已经完成了自我提效，提前完成自己的本职任务，下一步可以计划推动团队的效率。

如果太过专注技术，专心自己的一亩三分田，相当于给自己设限成毕业两三年的水平。这种人应该被打上不胜任的标签，在寒冬中很容易被优化掉。专注技术还有一个误区，就是容易把“实施细节”和“技术”两者混淆，特别在软件行业“实施细节”很容易随时代改变，基本三年就会大变样，而“技术”类似于“知识”不会过时。看到这里大家可以自己思考下，自己学到的到底是“实施细节”还是真正的“技术”。

2.如何推动团队进步

恭喜你跨过了第一道坎，推动团队进步不是一个人的事，一般推动团队分为两部分：个人影响团队，团队自我驱动。

个人影响团队比较简单，就是把自我提效所积累的经验和知识共享给整个团队，完成的手段可以是博客分享，会议分享，文档分享。

团队自我驱动，实际上我把整个团队拟作了一个人，一个人找出别人的缺点很容易，但是找出一个团队的问题却没那么容易，同时也会受到公司和领导的局限，比如一些项目管理的领导就是二传手，只催你进度的那种，这时候就需要你主动找他讨论。

如何找到团队的缺点？可以通过下面两个大类的套路：管理手段和技术手段。

管理手段可以从知识管理、代码规范、需求分析三处着手：

知识管理： 建立知识库，避免重复的培训，重复的解答问题

代码规范：借助代码缺陷检查工具，具体到负责人提升代码规范

需求分析：避免低效，无效会议，避免各种妥协下产生的需求

技术手段比较简单：

重构升级：弃用老的架构，拥抱新技术，带领团队提升技术

内部造轮子：内部定制工具，帮助团队高效完成任务

找到了团队的缺点接下来可以制定度量，衡量团队的推进程度，可以从两个角度进行度量：

跟自己比较：比如这次做需求提测bug数减少，需求delay少了，满足需求不需要上线只要配置上线，等等

和别的团队比较：这个比较凶残，我也不知道用什么度量比，但是有的大公司就是这样做的。

3.总结与晋升

从发现缺点到最后得到成果完成团队推进目标，是时候写个ppt在领导面前吹一波了，这个就不用我教了。

序言

这次遇到贝壳花名的需求，需要使用最长公共子串对花名做校验。这种算法在面试题中算是必会题，各种四层循环，三层循环，两层循环的代码在我脑中闪过，但是今天就是要带你实现不一样的最长公共子串！

教科书式实现

使用动态规划，两层循环，使用二维数组存储状态，时间复杂度O(n^2^)，空间复杂度O(n^2^)或O(2n)

一张图解释原理：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

                  先 横 向 处 理
         +--------------------------->

           e   a   b   c   b   c   f
  +      +---+---+---+---+---+---+---+
  |    a | 0 | 1 | 0 | 0 | 0 | 0 | 0 |
纵 |      +---------------------------+
向 |    b | 0 | 0 | 2 | 0 | 1 | 0 | 0 |
累 |      +---------------------------+
加 |    c | 0 | 0 | 0 | 3 | 0 | 2 | 0 |
  |      +---------------------------+
  |    d | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
  |      +---------------------------+
  |    e | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
  v      +---+---+---+---+---+---+---+
           e   a   b   c   b   c   f

优化空间复杂度至O(1)

从上图可以发现，在纵向累加时实际只需要左上方的计数器即可, O(n^2^)的空间白白被浪费了,最优的空间复杂度应该是O(1)。那么该如何处理呢？

一张图解释原理：

                                   e   a   b   c   b   c   f
    +---+                        +---+---+---+---+---+---+---+
  a | 0 |                            | 1 | 0 | 0 | 0 | 0 | 0 | a
    +-------+                        +-----------------------+
  b | 0 | 0 |                            | 2 | 0 | 1 | 0 | 0 | b
    +-----------+                        --------------------+
  c | 0 | 0 | 0 |                            | 3 | 0 | 2 | 0 | c
    +---------------+                        ----------------+
  d | 0 | 0 | 0 | 0 |                            | 0 | 0 | 0 | d
    +-------------------+                        +-----------+
  e | 1 | 0 | 0 | 0 | 0 |                            | 0 | 0 | e
    +---+---+---+---+---+-------+                    +---+---+
      e   a   b   c   b   c   f

答案就是沿着等长对着线处理。

有意思的代码抽象

大家可以根据上面思路写一下，一般会把算法分成两部分：处理长方形的左下部分和处理长方形的右上部分，两部分都是双层循环，时间复杂度和空间负载度已经变为了O(n^2^) ，O(1)。

肯定有人已经发现自己的代码处理左下角的代码和处理右上角的代码不能复用，一个是从中间向左下角处理，一个是从中间向右上角处理，明明很类似，但是就是没发合并。

那么有没有方法把这两部分处理抽象成公共代码呢？不卖关子了，直接上图：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

                                                         +
                                                       e |
                                                         +--+
  e   a   b   c   b   c   f                            a | 1|
+---+---+---+---+---+---+---+                            +-----+
    | 1 | 0 | 0 | 0 | 0 | 0 | a                        b | 0| 2|
    +-----------------------+                            +--------+
        | 2 | 0 | 1 | 0 | 0 | b                        c | 0| 0| 3|
        --------------------+         翻      折           +-----------+
            | 3 | 0 | 2 | 0 | c     +------------>     b | 0| 1| 0| 0|
            ----------------+                            +--------------+
                | 0 | 0 | 0 | d                        c | 0| 0| 2| 0| 0|
                +-----------+                            +--------------+
                    | 0 | 0 | e                        f | 0| 0| 0| 0| 0|
                    +---+---+                            +--------------+
                                                           a  b  c  d  e

如果你想使用公共代码同时实现处理左下角和右上角是不可能的了。所以你需要把右上角的三角翻折，然后你就得到了两个三角：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

                                      +
                                    e |
                                      +--+
                                    a | 1|
  +---+                               +-----+
a | 0 |                             b | 0| 2|
  +-------+                           +--------+
b | 0 | 0 |                         c | 0| 0| 3|
  +-----------+                       +-----------+
c | 0 | 0 | 0 |                     b | 0| 1| 0| 0|
  +---------------+                   +--------------+
d | 0 | 0 | 0 | 0 |                 c | 0| 0| 2| 0| 0|
  +-------------------+               +--------------+
e | 1 | 0 | 0 | 0 | 0 |             f | 0| 0| 0| 0| 0|
  +---+---+---+---+---+------         +--------------+
    e   a   b   c   b   c   f           a  b  c  d  e

这样就变成了处理两遍左下角了，代码也可以完美复用！！！

最终实现

我的完整思考过程已经分析完毕，这样沿对着线处理还有一个小小的优点：提前结束搜索。这一点大家可以自行思考，这里不做过多解释。

直接干货上场：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class Solution {
    /**
     * @param A: A string
     * @param B: A string
     * @return: the length of the longest common substring.
     */
    public int longestCommonSubstring(String A, String B) {
        // write your code here
        char[] achars = A.toCharArray(), bchars = B.toCharArray();
        return getMaxLength(bchars, achars, getMaxLength(achars, bchars, 0, 0), 1);
    }
    
    private static int getMaxLength(char[] s1, char[] s2, int maxLength, int startIndex) {
        
        for (int start = startIndex; start < s1.length; start++) {
            int upper = Math.min(s2.length, s1.length - start);
            // if (upper <= maxLength) break; //提前结束搜索
            for (int currentLineLength = 0, x = 0, y = start; x < upper; x++, y++) {
                if (s1[y] == s2[x])
                    maxLength = Math.max(maxLength, ++currentLineLength);
                else {
                    // if (upper - x - 1 <= maxLength) break; //提前结束搜索
                    currentLineLength = 0;
                };
            }
        }
        return maxLength;
    }
}

结尾

怎么样，经历这次优化过程是否感觉自己对最长公共子串的认识又更深了一步呢？虽然不能保证是首创（也可能是首创？），但是这次一步一步真切思考优化直到获得成果让我无比兴奋。

说了这么多，我就是要给我们贝壳招聘开发组打个广告>_>，期待更多爱思考优秀的同学加入！


1. 问题背景

权限系统现状

UC权限系统基于角色访问控制技术RBAC（Role Based Access Control） 。具体来说，就是赋予用户某个角色，角色给与角色对应的权限能访问及操作不同范围的资源。

什么是数据权限

代表一个角色对应某个权限所能操作的数据范围，比如gitlab组管理员能看到组下的所有项目代码，我们可以这样配置：

1. 创建组管理员
2. 分配给组管理员查看项目代码的权限
3. 查看项目代码权限设置约束条件，约束为自己组下的项目

实际产生遇到的问题

对绝大多数简单的系统来说一个用户对应一个系统只会有一个角色，一个角色只有一个数据权限范围（即使有多个，也可以合并成一个）。但是随着产品的功能迭代，用户的变更和系统设计的原因，总有一些特殊且重要的用户在同一个系统中拥有多个角色。在多角色和数据权限的组合下，一个用户可以拥有复数的数据权限范围。

考虑到实现复杂性，大多数系统选择使用角色切换的手段简化系统实现，同时对用户暴露出了他们不熟悉的角色这一概念，造成这些用户在系统使用中的各种不便。

本文重点讨论在避免角色切换的前提下，进行多角色数据范围查询的一种思路。

具体需要解决的需求

我们的数据报表后台，不同的角色拥有不同的数据查看范围（不同角色所能看到的员工数据字段也各不相同），例如：

• 薪酬管理员：查看非高职级员工数据
• 高级薪酬管理员： 查看高职级员工数据
• 长期激励管理员：查看有长期激励员工数据
• 等等

简单来说，拥有长期激励管理员和高级薪酬管理员的用户能否直接看到高职级员工数据和长期激励员工数据？至少在直觉上是可行的。

2.多角色数据范围查询

直觉的做法

单角色单数据范围可以使用一句sql查询出结果，那多角色多数据范围是不是使用多句sql查询出结果合并就可以了？

深入思考 多角色数据范围对行的影响

1. 查询条件合并还是结果合并？ —-结果合并
2. 如何排序？ —–外部排序，或先内部排序,limit,再外部排序
3. 有重复数据怎么办？ —-使用groupby去重
4. 查询性能有影响吗？—-有

具体体现：

1
2
3
4
5
6
7

select * from (
(select id, sortvalue from table_1 where t_name = 'a' order by sortvalue desc limit 20)  -- 先内部排序,limit
union all -- 结果合并
(select id, sortvalue from table_1 where t_name = 'b' order by sortvalue desc limit 20)  -- 先内部排序,limit
order by sortvalue desc  -- 外部排序
) a group by id -- 使用groupby去重
limit 10, 10

深入思考 多角色数据范围对列的影响

• 薪酬管理员： 查看员工薪酬字段
• 长期激励管理员：查看员工长期激励字段

如何解决？方法有很多！

综合思考，给出一种解决方案

1
2
3

graph LR
   A(查询行及角色信息) --> B(根据角色查询对应列字段)
   B --> C(结果) 

步骤：

1. 查询多角色数据范围下的数据，附带角色信息

1
2
3
4
5
6
7

select id, GROUP_CONCAT(a.role) as roles from (
(select id, 'role_a' as role from table_1 where sortvalue > 10 order by `sortvalue` desc limit 2)
union all
(select id, 'role_b' as role from table_1 where sortvalue > 20 order by `sortvalue` desc limit 2) 
order by `sortvalue` desc 
) a group by id
limit 0, 2

结果：

2. 根据每一行不同的角色，查询出可见的字段，例如id=1的行只能查看ROLE_B对应字段，而id=5的行可以看到ROLE_A,ROLE_B对应的两个角色的字段

3.总结和延伸

多角色数据范围写操作？

遍历角色直到找到满足条件的权限即可。

收获

自己不行动，等于等着被别人安排哈哈

还有疑问？

自己想。还可以点这里