改进之后的方案

.bashrc

1
2
3
4
5
6

export _T=${_T//\\//}   # replace backslash to fowardslash
export _T=${_T//\"/}    # 如果目录带中文，传入的目录会在首尾加引号，如果无中文则不会加双引号。这里删除首尾双引号，归一处理
if [[ $_T == "" ]]; then
    export _T="C:\cygwin64\home\xxx"  
fi
cd "$_T"

注册表：HKEY_CLASSES_ROOT\Directory\Background\shell\open in Cygwin\command

1

c:\cygwin64\bin\mintty.exe /bin/env _T="%V/" /bin/bash -l

相关解释

关于export _T=${_T//\"/}

如果目录带中文，传入的目录会在首尾加引号，如果无中文则不会加双引号。这里删除首尾双引号，归一处理。
如果不加处理，在有中文的路径中会提示找不到（带引号的）目录。

关于_T="%V/"

双引号

兼容目录路径有空格的情况

后面的斜杠

为了兼容根目录与非根目录的不同形式。win10中各分区的根目录以反斜杠结尾，非根目录则末尾没有反斜杠。例如在C盘根目录，传入的参数是"C:\"，这样拼接后成了_T="C:\"，末尾的引号会被转义成引号，拼接成了错误命令：/bin/env _T=C:" /bin/bash -l，如图所示。

而非根目录的末尾不会有反斜杠，例如C盘下的子目录cygwin64，传入的参数是"C:\cygwin64"，拼接之后_T="C:\cygwin64"，没问题。

为了归一处理，这里在%V后面加了个正斜杠/，这样做的效果是：
对于根目录情况，例如"C:\"拼接成了"C:\/"，进而被解析成"C:/"。也就是会在后面的反斜线后面加一个正斜线，将正斜杠转义，破坏对后面引号的转义，同时目录后面加一个正斜线不影响目录读取。
对于非根目录情况，例如"C:\cygwin64"拼接成了"C:\cygwin64/"，解析后也是"C:\cygwin64/"，相当于在后面追加一个正斜线，也不会影响目录读取。

手动升级

面对升级版本之间的改动，一种容易想到的方法是纯手动升级。这里有两个案例

1. Hexo 主题快速升级办法-知识沉言

   手动保存主题改动过的文件
   如果你在themes/xxx主题文件有自定义的修改，请自行手动备份一下；如果你是大改的话，我也没有好办法

2. Hexo升级之坑-杨二小

   断断续续折腾了两天，才升级成功。所以，如果有啥感想，那就是：没事别瞎TM升级！当然，如果一定要升级，最好做增量升级：另起炉灶，一项一项地加功能，这样好定位问题，也容易回滚。

看来手动升级不够优雅，容易采坑。

通过git升级

为了避免手动升级，一个思路是采用git仓库管理主题目录，当主题升级时，采用git进行平滑升级。
这看似优雅，却会引入另一个问题：如何在主博客仓库中合理管理一个子主题仓库？NexT Issue #932有很多讨论，也有一些解决方案，这里列出几个：

1 采用数据文件的方式

参考数据文件的介绍和NexT Issue #328。采用数据文件也只能避免_config.yml文件冲突，对于用户修改页面模板情况就没办法了。

2 基于fork + submodule

维护父子两个仓库大大增加了复杂度，还要fork一份冗余的主题仓库，为了不经常有的主题升级增加这样的复杂性，实在没什么必要。

3 同步工具

有用户写了一个hexo同步工具hexo-git-backup，支持博客、主题的同步，支持自定义commit消息。但本质上是个备份工具，需要删除掉主题目录的.git目录，所以也不支持通过git升级主题。

采用git升级的方式，确实能够解放双手，平滑升级，但毕竟还是引入了一定的复杂度。有没有一种既能利用git的平滑升级，又不那么复杂的方案？

暴力但不失优雅的解决方式

由于主题升级的次数相对较少，一般不如用户修改频繁，所以一种简单易行暴力的方式是，git只用来升级，不用来同步，既能利用git进行平滑升级，又避免了引入双层git的复杂情况。

原理

由hexo博客主目录作为git仓库统一管理所有代码，主题目录不设单独git仓库。每次升级主题时，手动将主题目录制作成临时的git仓库，进而以git的方式进行升级，升级过后可以再销毁这个临时git仓库，由博客主仓库管理升级变更。

步骤

1. 记录当前的主题版本tag，版本号在主题目录的package.json中的version字段。
2. 随便找个其他目录，clone最新版本的主题仓库，新建分支temp并checkout，再将temp分支reset –hard到当前版本的tag。
3. 【暴力】确认hexo的主题目录中没有.git目录，如果有，删掉。此时拿到步骤2的temp分支对应的.git文件夹，将其拷贝到hexo的主题目录中。
4. 在主题目录中的temp分支上做一次提交（这次提交代表着在上一个版本基础上对主题目录所做的所有更改）。
5. 在temp分支上merge想要升级到的版本tag，如果有冲突逐一解决掉。
6. 至此升级完成，主题目录下的.git可以删掉了（销毁临时git仓库）。升级完成后记得将主目录做一次提交，主目录会将主题升级的所有改动进行提交。

特殊情况——NexT从v5.1.x升级到v6.0.x

NexT从v5.1.x升级到v6.0.x比较特殊，涉及到代码仓库的更改，代码仓库从iissnan改为theme-next。官方推荐这种方式：Update from NexT v5.1.x，但这种方式治标不治本，保留了iissnan仓库的主题，新建了来自theme-next仓库的主题，做了一个切换而已；而迁移的过程，还是依赖手动，并没有利用类似git merge的平滑升级。
由于本文方法并不强依赖于git提交的连续性，而是只需要临时制作一个git仓库即可，所以天然支持这种更换git仓库的升级。

本文方法稍加改动就可以适用于NexT从v5.1.x升级到v6.0.x，具体步骤：

1. 利用iissnan仓库的.git目录，将主题升级到iissnan仓库的最终版本。
2. 利用theme-next仓库的.git目录，承接后续的升级。

注意

NexT v6.5.0主题仓库的.gitignore默认忽略了lib/里的font-awasome等内容（其他版本没有了解），如下

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

.DS_Store
.idea/
*.log
*.iml
yarn.lock
package-lock.json
node_modules/

# Ignore unused verdors' files
source/lib/fancybox/*
!source/lib/fancybox/source/

source/lib/font-awesome/less/
source/lib/font-awesome/scss/

source/lib/ua-parser-js/*
!source/lib/ua-parser-js/dist/

source/lib/Han/*
!source/lib/Han/dist/

这带来一个问题，如果主题仓库不是fork来的，而是想用主目录统一管理博客源代码，font-awesome等内容将无法推送到远程仓库，导致在其他环境从远程仓库clone时拿不到font-awasome，进而页面显示不正常。所以这里注意一下，主题.gitignore文件里的内容该删的删，该改的改。

有多个相似的类，找到他们的共性，抽象出来，放入公共的抽象父类，作为模板。

策略模式

1.将算法封装成算法类，变抽象为形象（让不同的算法【抽象】，变成一个个算法策略【形象】）
2.将算法选择逻辑与算法本身解耦（由算法内部if-else代码级耦合【难以维护】，变为客户端选择算法类实例的耦合【灵活】）

不用策略模式：

1
2
3
4
5
6

if(客户=="老客户"){
    price*=0.8;
}else if(客户=="大客户"){
    price*=0.9;
}
return price;

用策略模式：

1
2
3
4
5
6
7
8
9
10

class OldCustomer implements Strategy{
    public int getPrice(int price){
        return price*0.8;
    }
}
class BigCustomer implements Strategy{
    public int getPrice(int price){
        return price*0.9;
    }
}

客户端：

1
2
3
4
5
6
7

Strategy strategy;
if(客户=="老客户"){
    strategy = new OldCustomer();
}else if(客户=="大客户"){
    strategy = new BigCustomer();
}
return strategy.getPrice(price);

二者关系

相似点：

没啥太大的相似点，之所以容易混淆，是因为在策略模式中，各个策略比较像，不同的策略类有可能包含同样的方法，这时候可以用模板方法模式构造这些策略类。

不同点：

既然没啥相似点，也不好说不同点。主要比较以下两点：1.实现方式 2.各模式强调了什么。

模板方法模式

1. 用继承，模板是抽象父类
2. 强调一个模板，让相似类有所管理

策略模式

1. 用接口，各算法实现相应的策略接口
2. 强调策略的形象性，不再操作抽象的算法，而是在客户端中根据情况不同直接选用不同策略。改变、扩展策略类，总比修改源代码中的if-else要优雅。

一番试验找到原因，是定义的data格式问题。是我把demo中的randomData()函数改了个格式

1
2
3
4
5

function randomData() {
    var now = new Date();
    var value = 1 + (Math.random() - 0.5) * 2;
    return [now, value*1000]
}

改完虽然能运行，能实时更新数据，但每次插入一个数据，绘图呈现的效果就是重新绘制全图一样，有一个从水平线扩展成折线图的感觉，所以造成了图形不停跳动。当然，demo中并没有这样的跳动，是很稳定的平移。

解决方法：改成以下格式，也就是demo给出的格式

1
2
3
4
5
6
7
8
9
10
11

function randomData() {
    now = new Date();
    value =  Math.random() * 21 - 10;
    return { 
        name :now,
        value: [
            now,
            Math.round(value)
        ]
    }
}

之后便能平滑的移动了。

总结：返回值必须是一个对象，有name属性和value属性。

1. 六个月，能否学好web开发？

   不够，六个月只够学习一门技能。

2. 跟对老板、师傅，能有更多收获，不用重视薪资。

3. 在做普通项目中脱颖而出？

   做好项目本身
   尽量主动，比如重构代码。忌讳让做什么只做什么

4. 如何看源码？

   1.跑起来
   2.看业务

5. Redis集群如何学习

   难以模拟实际应用的大量数据，项目遇到再深挖较好。否则只搭建没用。

6. 为何跳槽？

   不想只做SSH，找喜欢的方向深入（做引擎）

7. 重基础：

   操作系统&网络

8. 大数据：

   建模更重要

9. 如何表述做过的项目？

   1.业务
   2.架构
   3.做的工作

10. JDBC：必会

11. 混合开发能否代替原生APP？

    不能

12. 反射常用吗？

    直接不常用，间接常用（框架中）

13. 需要掌握全部设计模式。

14. 如何学习框架？

    1.书
    2.项目

15. 编译原理：不需深入了解，除非写语言

16. PHP：Facebook，新浪

17. Java：生态繁荣，适合大规模团队协作

18. 数据结构用处？

    锻炼思维，分析算法实现过程，注重效率即可，不需背记复杂数据结构

19. 需要定制Nginx——学C语言的好机会

学习资源

网站：imooc，黑马
群文件：《项目实战之安全基础》
《假如时光能够倒流， 我会这么学习Java》
《小王的架构师之路》
《码农和英语》

2016年11月8日更新：
11月3日下午Github Pages升级了Jekyll,导致了next主题下source/vendors路径下的部分js和css无法访问。
解决：在.deploy_git目录中加入名为.nojekyll的空文件。

原文：

博客用Hexo+GitHub Pages搭建，托管在GitHub的一个仓库中，仓库分两个分支：hexo和master。hexo作为默认分支，存放博客源代码，master分支存放博客生成页面。如何实现多终端同步？

为了筛选出配置文件、主题目录、博文等重要信息，作为需要GItHub管理的文件，配置.gitignore文件如下：

1
2
3
4
5
6
7

.DS_Store
Thumbs.db
db.json
*.log
node_modules/
public/
.deploy*/

需要多机同步时，只需将hexo分支clone到本地，再进入目录安装npm即可。处理命令如下：

1
2
3
4

git clone https://github.com/xiaobai050/xiaobai050.github.io.git
cd xiaobai050.github.io
npm install
hexo s

由于package.json的存在，无需手动添加插件，npm install的时候会根据package.json中的插件列表自动加载相应插件。

至此，本机的同步完成。

版本一

深度优先搜索：
从头至尾遍历石头，从每个石头上分别以k-1,k,k+1的力量向前跳一下，如果这三个力量范围内没有石头，则返回；否则继续先前跳一下……直至到达最后一个石头。

没有记忆功能，每次遍历需全盘重新计算，时间复杂度O(3^n),石头多了会超时。于是加入记忆搜索，有了版本二。

版本二

迭代+记忆搜索：
加入记忆搜索，为每块石头建立一个力量表，每到达一块石头，就把这一跳所用的力度记录在这块石头的力量表中。这样一来，一块石头是否可以到达，取决于这块石头的力量表是否为空。

• 题目要求第一跳力度为k=1，则在石头1上记录力量k=1，然后从第二块石头开始遍历：
• 对于第i个被遍历的石头，判断从石头1到石头(i-1)范围内的每一个石头上，是否存在跳到石头i上的力量，如果存在(代表能跳到石头i上)，则在石头i的力量表中添加这个力量值。
• 所有石头遍历完，判断最后一块石头的力量表是否为空，则得出是否能到达最后。

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

public class Solution {
HashMap<Integer, Boolean> mapTable = new HashMap<Integer, Boolean>();
int[] stones;

public boolean canCross(int[] stones) {

int len = stones.length;
if (len < 2)
return true;
if (stones[1] != 1)
return false;
if (len == 2)
return true;

this.stones = stones;

mapTable.put(0 | 1 << 11, true);
mapTable.put(1 | 1 << 11, true);

return solve(len);
}

private boolean solve(int endPos) {
// 枚举前面所有点，看是否能到这里，如果能，记录跨度k
for (int nowPos = 2; nowPos < endPos; nowPos++)
for (int j = 1; j < nowPos; j++) {
int k = canArriveByK(j, nowPos);
if (k != 0) {
// 在当前位置，记录当前跨度k
if (nowPos == endPos - 1)
return true;
mapTable.put(nowPos | k << 11, true);
}
}
return false;
}

private int canArriveByK(int j, int nowPos) {
int begin = stones[j];
int end = stones[nowPos];
int k = end - begin;

if (mapTable.get(j | k << 11) != null)
return k;
if (mapTable.get(j | (k + 1) << 11) != null)
return k;
if (mapTable.get(j | (k - 1) << 11) != null)
return k;
return 0;
}

}

虽然所有测试用例都可以在时间限制内运行完毕,但时间复杂度O(n^2)，运行时间351ms，只击败了7.82%的用户……这不能忍。

版本三

深度优先+记忆搜索：
将版本一和二结合，将深度优先搜索的结果及时记录在每块石头的力量表中。

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

public class Solution {
int[] stones;
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
HashMap<Integer, Boolean> mapKey = new HashMap<Integer, Boolean>();

public boolean canCross(int[] stones) {

int len = stones.length;
this.stones = stones;

for (int i = 0; i < len; i++)
map.put(stones[i], i);

mapKey.put(0, true);

return solve(1, stones[len - 1], 1);
}

private boolean solve(int pos, int endPos, int k) {

if (k == 0)
return false;

int keyChar = pos << 11 | k ;

if (pos == endPos)
return true;

if (mapKey.get(keyChar) != null)
return false;

if ((pos > endPos) || (map.get(pos) == null)) {
mapKey.put(keyChar, false);
return false;
}

if (solve(pos + k - 1, endPos, k - 1))
return true;
if (solve(pos + k, endPos, k))
return true;
if (solve(pos + k + 1, endPos, k + 1))
return true;

mapKey.put(keyChar, false);
return false;

}

}

时间复杂度小于O(n^2)，运行时间50ms左右。

番外篇

上述版本二与版本三中，都有类似代码：

1

int keyChar = pos << 11 | k ;

这行代码的作用是，将当前石头位置(pos)和当前跳跃力量(k)写进同一个int值，这个int将在后面作为哈希表的键值，建立以二维数组为键值的哈希表。这受启发于博客：安定区：动态规划 DP leetcode403 青蛙过河问题。

为什么是左移11位？

这取决于最远那一颗石头的距离，也就是数组最后一个数字可能的最大值。原题目中说道：

Note:
The number of stones is ≥ 2 and is < 1,100.
Each stone’s position will be a non-negative integer < 2^31.
The first stone’s position is always 0.

石头总数小于1100，根据每次跳跃最多只能比上一次多跳1，可以得知最远的跳跃方案：

0,1,3,6,10,15,…

通项公式为：

f(n)=n*(n+1)/2

最后一块石头最远为1099*1100/2=604450，可以用20位二进制数表示—2^20=1048576。

而石头总数1100可以用11位二进制数表示—-2^11=2,048。

20+11=31位，刚好可以由一个int（32位）容纳。所以，左移11位，将后11位存储力量信息，将前21位存储位置信息。
这样的键值可以无损地模拟数组，并建立哈希表。相比于直接用数组作为键值的哈希表，读写速度得到提升，空间复杂度更小。这都依赖于石头总数小于1100，与其说是巧合，不如说是出题人给出的提示:)

我在LeetCode中答过的题代码全部托管在GitHub：xiaobai050/leetcode

最初在LeetCode上学习在线编程时，由于不熟练，脑中还没有答题的框架，测试用例、待提交代码、入口方法之间的耦合过大，添加、修改测试用例需要修改源代码，导致调试效率过低，不够优雅。

为了尽可能方便调试，高效编辑，分离测试用例和算法实现，改进整理出了自己顺手的答题框架，记录下来。万事开头难，如果能帮助到想我当初一样迷茫的初学者，就更好不过了:)

目录结构：

• LeetCode ——项目名称，方便Eclipse内置Git对代码进行管理和多终端同步
  • pid1 ——题目包，每个题目封装在一个单独的包中，包名用LeetCode题目编号表示
    • Solution.java ——算法类，注意到LeetCode每道题目的代码类名为Solution
    • Main.java ——包含主函数（控制逻辑、测试用例数组）、测试函数（测试结果输出、算法耗时）
  • pid2
    • Solution.java
    • Main.java

以具体题目为例：96. Unique Binary Search Trees

1. 拿到题目，首先在创建题目包pid96;
2. 新建类：Main.java，并创建方法： main 和 test;
3. 新建类：Solution.java，将算法方法代码用题目中原始代码进行替换，并添加默认返回值;
4. 在main方法中新建测试用例数组，并循环调用测试方法test(input);
5. 在test方法中实例化Solution类，执行算法，并在首尾计时统计运行时间。

代码内容如下：

main.java

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
30
31
32
33
34
35
36
37
38
39

package pid96;

/**
 * Unique Binary Search Trees 
 * 
 * Given n, how many structurally unique BST's
 * (binary search trees) that store values 1...n?
 * 
 * For example, Given n = 3, there are a total of 5 unique BST's.
 * 
 *  1         3     3      2      1
 *   \       /     /      / \      \
 *    3     2     1      1   3      2
 *   /     /       \                 \
 *  2     1         2                 3
 *  
 * @author 白
 *
 */
public class Main {
public static void main(String[] args) {
int[] testTable = { 0, 1, 2, 3, 4, 5, 6, 10 };
for (int input : testTable) {
test(input);
}
}

private static void test(int input) {
Solution solution = new Solution();
int output;
long begin = System.currentTimeMillis();
output = solution.numTrees(input);
long end = System.currentTimeMillis();
System.out.println(input + ":output=" + output);
System.out.println();
System.out.println("耗时：" + (end - begin) + "ms");
System.out.println("-------------------");
}
}

Solution.java

1
2
3
4
5
6
7

package pid96;

public class Solution {
    public int numTrees(int n) {
        return 0;
    }
}

接下来开始写算法，全部在Solution.java中完成。

完成后如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package pid96;

public class Solution {
    public int numTrees(int n) {
        
        if(n<=1)return 1;
        if(n==2)return 2;
        
        int [] table= new int[n+1];
        
        table[0]=1;
        table[1]=1;
        table[2]=2;
        
        for(int i=2;i<n;i++){
            for(int j=0;j<=i;j++){
                table[i+1]+=table[i-j]*table[j];                
            }            
        }
        
        return table[n];
    }
}

运行结果：

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
30
31
32

0:output=1

耗时：0ms
-------------------
1:output=1

耗时：0ms
-------------------
2:output=2

耗时：0ms
-------------------
3:output=5

耗时：0ms
-------------------
4:output=14

耗时：0ms
-------------------
5:output=42

耗时：0ms
-------------------
6:output=132

耗时：0ms
-------------------
10:output=16796

耗时：0ms
-------------------

平衡二叉树的特点是，小的值在左边，大的值在右边。

用VisuAlgo画一个简单的平衡二叉树：

再随机生成一个：

可以发现规律：整棵树中，所有节点的值从左至右逐渐增大。

什么是高度平衡(AVL)二叉树？

WiKi解释如下：

在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。

高度平衡树经常涉及到旋转这个概念，简单来说就是高度平衡树插入或删除某个节点可能破坏平衡，这时就需要旋转一些（3个）节点来恢复树的平衡。
旋转哪三个呢？实际上只有四种情况，根据不同情况选择不同的旋转方法。很多人讲得很详细，不搬运了，可以参考这里：高度平衡的二叉搜索树(AVL树)-逝者如斯,不舍昼夜。

AVL树的四种旋转

由于整棵树中，从左至右逐渐增大，旋转可理解为左右顺序不变，垂直映射到

• 循环：循环嵌套层数由代码结构决定，维度不可变。

• 递归：能产生循环嵌套，可以扩展循环层数。

举例：遍历所有组合—— C6取3

[1,2,3] [1,2,4] [1,2,5] [1,2,6] [1,3,4] [1,3,5] [1,3,6] [1,4,5] [1,4,6] [1,5,6]
[2,3,4] [2,3,5] [2,3,6] [2,4,5] [2,4,6] [2,5,6]
[3,4,5] [3,4,6] [3,5,6]
[4,5,6]

• 循环：

  1 2 3 4 5 6 7 8

  for(int i=1;i<=4;i++) for(int j=i;j<=5;j++) for(int k=j;k<=6;k++){ temp.set(0, i); temp.set(1, j); temp.set(2, k); rtn.add(temp); }

  每个数组有三个元素，用三层for循环。

• 递归：

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

  //计算C6取3 //遍历数字范围：start=1，end=6 //小容器容量为3：totle=3 //小容器内计数器从零开始计数：count=0 //综上，调用solve(0,3,1,6); public void solve(int count, int totle, int start, int end) { if (count == totle) { rtn.add(temp); return; } for (int i = start; i <= end; i++) { temp.set(count, i); solve(count + 1, totle, i + 1, end); } }

如果遍历C6取4呢？

• 循环：加一层for循环

  1 2 3 4 5 6 7 8 9 10

  for(int i=1;i<=3;i++) for(int j=i;j<=4;j++) for(int k=j;k<=5;k++) for(int l=k;l<=6;l++){ temp.set(0, i); temp.set(1, j); temp.set(2, k); temp.set(3, l); rtn.add(temp); }

• 递归：只需将入口参数totle由3修改为4即可：
  solve(0,4,1,6);

更一般地，如果遍历Cn取k

• 递归：n和k为变量，递归依然只需更改入口参数：
  solve(0,k ,1, n);

• 循环：呵呵