其实考虑到 drakeet 的性格我不该在这个东西上纠缠太久（所以我希望他永远不要看到吧，免得难受），可是新内容除了加这里外我不知道该放在哪里了...
我根本无意继续想这个事情，但是我有时候要写点励志（迫真）....
不得不说，他之前的行为真的是很好的负面案例，很难找到第二个啊....

#Docker 🌚 linkdyn FROM scratch

我刚知道如果你的程序是静态编译的话,打包 Docker 镜像时可以直接 FROM scratch 这样不带有任何系统文件..

#KDE #Freedom #Haha 🌚？？？ 你？？？

这翻译我好方

duangsuse 的算法不是很好，我看看会不会 Dijkstra... 这还是个 template 不过直觉还是有的，能够看到 link cost, base cost, 路径回溯 什么的

在使用 Dijkstra 算法的时候，你需要一个输入图 (包含 Map<Node, List<Pair<Cost, Node>>>, 也可以分开来记录 Cost) 和一个起始节点 Node、一个目标节点 Node
这样我通过 get(startPoint) 就可以拿到接下来能走到下一点的路径，对任何一个 Node 都是如此

Dijkstra 是经典的 BFS 广度优先搜索算法（这样就不需要太多栈空间），所以我们需要一个 Queue。
Dijkstra 的思路是对每个节点得到从起点最近的路径，然后倒过来回溯
如果利用栈的话，就可以把最短路径铺平在栈上了，不过这里不得不记录比较...
Dijkstra 算法有效于加权(weighted) DAG(Directed Acyclic Graph)

此外，为了能够完成判断寻最短和路径回溯的任务，还需要
+ 一个 Map<Node, Cost>, 它记录到达节点的最短开销
+ 一个 Map<Node, Node>, 它记录最短开销的前驱(succeeder)节点
当然，其实我应该用 typealias RouteSelect = Map<Node, Pair<Cost, Node>>

+ 开始时，把 startPoint 加进去，它的开销被置为 0
+ 每次从中取出一个 node, 对其所有 target
首先我拿出当前 node 的开销
+ 若 curcost + linkcost(next) < cost(next)，则设置 cost(next) = curcost + linkcost(next)
然后加入 BFS 队列
+ 否则，什么都不干，继续（摒弃掉当前可达的非最短 succeeder）...

完全结束时，回溯出路径即可

— 等等，我好像从书上看到了一个例外... 不能不对非当前最短路径的节点 不搜索

0 >6> A
0 >2> B
A >1> # 
B >5> # 

这样的话 B 的最短路径就没戏了... 理解不够深刻，这是 Dij 不是那种 每次取最短 （我这个 dfs 的设计是错的... 应该取和才对，但是这样就又弱智了，不如 Dij 的）

我不知道 DFS 和 Dijkstra 对节点开销的计算量是不是一致的，累...

书上说，Dij 是对每个可达节点，都确保计算出了它的最小开销，这样就能保证最终回溯的是最小开销的路径

（书是《算法图解》 不准喷为什么不是 《算法导论》）


实现时好像还有一点: 不能扫描已经扫描过的点，这样用 Flag 副作用即可吧...

#JavaScript ES2015 ≠ ES5 = ES6 易混

我花了超过三个小时的时间才可用...（其实主要是因为，《算法图解》那里多了一个可有可无的步骤，我一时不好理解，没能做好准备，另一方面，我写的也和标准模板有点偏差...）

算法实现, 和《算法图解》版本不一样的地方在于，不是 costs.filter { !it.second.walked }.minBy { it.second.cost }, 只有队列自动忽略走过的节点，没有『最便宜』，只是全部队列处理完（虽然在无环的情况下未必得记住哪些已经处理过）

...头疼，现在还有如下问题：

1. 为什么《图解》上的版本，自动寻找当前离 GraphRoot 最近的一个节点作为扫描起始位置
这和使用队列的版本有区别吗？如果随便选择一个还没算 succ 路径的节点而不是『最近节点』会不会有问题？

2. 看起来对于所有节点来说，走过一遍意味着已经确定它余下边链接节点的开销？
还是说它的最廉价路径确定了？这样相对 DFS 枚举路径的版本优化了多少？

3. 这个版本的封装很差劲... 真是...

『假装以后会去学习算法的样子』

但即使以后会一点这种幼稚园算法，也不能达到我想要的高度呢。 看来还需要理解...
—
沉思（迫真）了半个小时后稍微有了点理解，学到了

今天试着去理解了一下，回答之前的几个问题

1. Dijkstra 算法到底是怎么做到的、为什么每次要取没访问过的『最近』节点？如果不取最近的可以吗？

Dijkstra 算法的确就是『简单地遍历一次（不算取最小的遍历）』然后就可以得到任意端 A 到端 B 的最短距离
为什么每次要取最近的节点？因为 Dijkstra 算法从『最终开销和』的侧面看（何况每个最终到达算相邻端点距离后，就不能再次访问了），它必须得取和访问过程最相符的『最近』端点开始

比如，这里有一张图

A >1> B
B >2> C
A >4> C
C >1> D


假设 Dij 算过 A 的目标开销后，每次不是取最近，而是取随便一个端点开始
比如，它取到了 C，然后更新目标们的开销。C 此时的开销是 4（这是个危险信号，注意这不是最小开销！）
Dijkstra 算法遍历过程中有一个很重要的性质：每个被『走过』（也即计算邻端点开销）的点，计算邻边的时候都是自己的『最低开销』
然后取 B，此时 C 的开销被更新了（为 3, 可是 C 已经被走过了，这个值无法再传递给 C 的邻居）

这样 C 通过一个非最新的开销 4 达到了 D（5），算法终止

如果『随便』取到了一个当时没有算出路径到达的节点就更 NB 了 — 它所有邻端的距离都被『锁定』为 Infinity，并且如果这个节点是邻端们唯一的前驱，它们就永远“不可达”了 🌚

2. 之前的算法有啥问题？

其实 Dijkstra 算法利用副作用（也可以不用，主要是给每个端点维护『最低开销』）不是不可以使用递归来写
Dijkstra 算法是从『距离』的角度看路径计算，有时候你也可以感觉到它应用了类似快速排序里的『传递』

算法里每次只算一个『最近』端点，更新可达目标的开销，但是通过回溯的思路想，这是在所有『可用前驱』里选择一个（本身开销+链接开销）开销最小的，最终得到的就是整个问题的最优解
这也是算法每次取『最近』（『开销最小的前驱』）端点更新它所有目标开销的原因，如果随便取就炸了

算法『传递』的是路径的开销大小，它使用的『开销』数据得提供一个『加法』操作一个『比较』操作，依此来指导路径开销的选择 — 取最小的
只有所有最近的可达路径被尝试完了，端点才被『访问』，锁定了它邻边的开销（因为端点的『距离』，肯定是比它的前驱们要远的，即便已经有了一个可用路径也是一样）

之前的算法针对 (1) 里的问题也无法得到正确的解，因为它没有使用『最低开销』传递的操作 — 选择所有邻端点访问，并且走过也不能再走
顺序很重要 — 如果第一次走过的时候（确认了以当前端点为前驱的所有节点当前最小开销）该节点本身的开销不是最小的呢？

因为它只是 BFS 而已，所以遇到节点本身被更新的情况，也无法传递下去，也炸了... #Algorithm

https://github.com/lensh/vue-qq #China #dev

ECMAScript + Vue 的 QQ-like IM 实现

技术栈有标明

== 客户端
Vue2
Vuex — 组件状态共享
Vue-Router — 单页路由库
localStorage — 本地持久化存储
== 界面
Vueg — 转场特效
IScroll — 仿『原生』滚动效果
=== 开发工具
Webpack — Web 打包
CSS3(Flex)/SCSS — CSS Preprocessor
ES2015 & Babel — ES6 特性支持（如 async、Promise）

== 传输层
Axios — requests
Socket.io — WebSocket::IO 平等即时传输
jsonp — 跨域请求数据
== 服务端
Express/Koa — HTTP 服务框架
MySQL — 现代关系型数据库 给的附注是比 Mongo 好，因为关系复杂文档型数据库不能胜任
== 部署层
pm2 — process service manager/monitor
nginx — 转发什么的

#Android https://github.com/LineageOS/android_frameworks_base/tree/cm-14.1/packages/SystemUI/src/com/android/systemui/egg 膜

我数学很菜，而且不懂物理，写不出公式
虽然可以做一点编程，但是写在一个文件里，还那么多动画什么的 一个框架也不用 做不到

赏析（使用了后来的 M Land，因为这个版本的逻辑不如后来的清晰） #CG

private static float 

luma

(int bgcolor) {
  return 0.2126f * (float) (bgcolor & 0xFF0000) / 0xFF0000
  + 0.7152f * (float) (bgcolor & 0xFF00) / 0xFF00
  + 0.0722f * (float) (bgcolor & 0xFF) / 0xFF;
}

灰度函数

private void 

realignPlayers

() {
  final int N = mPlayers.size();
  float x = (mWidth - (N-1) * PARAMS.PLAYER_SIZE) / 2;
  for (int i=0; i<N; i++) {
    final Player p = mPlayers.get(i);
    p.setX(x);
    x += PARAMS.PLAYER_SIZE;
  }
}

放置 play

public static final float lerp(float x, float a, float b) {
return (b - a) * x + a;
}

public static final float rlerp(float v, float a, float b) {
return (v - a) / (b - a);
}

public static final float clamp(float f) {
return f < 0f ? 0f : f > 1f ? 1f : f;
}

好像是算加速角度的数学函数

public void 

step

(long t_ms, long dt_ms, float t, float dt) {

单步

#dev 2019 八月新安排

#GeekApk Prototype Project 组成，其中很大一部分（比方说，Literate Kotlin）我都已经打过不少实现稿了（就拿上面那个来说，我都考虑过怎么解析 .kt 文件跨模块引用和拿到其他模块的 html 地址了，也考虑过如何使用 TokenizerRangeMap 进行高亮和加引用/id、多个<code> 如何『视作一起』解析如何『分开来』高亮引用处理操作，staging-intro 主要的内容和布局也想好了）

#Android 最终可行答案：

val gesturedet = GestureDetector(object : GestureDetector.OnGestureListener {
override fun onDown(m: MotionEvent) = true
override fun onSingleTapUp(m: MotionEvent) = false
override fun onShowPress(m: MotionEvent) = Unit
override fun onLongPress(m: MotionEvent) = Unit
override fun onScroll(m0: MotionEvent, m1: MotionEvent, dx: Float, dy: Float) = false
override fun onFling(m0: MotionEvent, m1: MotionEvent, vx: Float, vy: Float) = false
})
backcontainer.setOnTouchListener { v, mot ->
v.performClick()
return gesturedet.onTouchEvent(mot)
};