Analyst Ben Thompson, on his website Stratechery (link):
Here’s the thing about these safety justifications: I think they work because, to Anthropic, they aren’t justifications. The company really believes that they are the only ones who believe in super intelligence, and thus are the only ones who are sufficiently concerned about the dangers. That excuses decision after decision, policy after policy, and confrontation after confrontation that, to people on the outside, look like a bizarre combination of cynicism and naiveté.
The contrast to OpenAI is massive: I think that one way to understand how and why OpenAI lost its lead is that, in the years following the release of ChatGPT, the company has been at war with itself internally as what used to be a research lab was suddenly seized with the burden of being the accidental consumer tech company; to the extent OpenAI solved that conflict, it was by bleeding huge amounts of talent to Anthropic in particular.
Anthropic, on the other hand, has perfect alignment between talent and mission and business. The company gets to sell to researchers the creation of a machine god, with the mantle of being the sort of person who cares about the dangers and is smart enough to navigate them on behalf of humanity; that every policy change that falls out of that happens to be great for business is the most beautiful coincidence in the world.
I respect this alignment, and I fear it. I respect it because it is so clearly effective; the closest analogy is probably Apple, which has always framed every self-serving action in the guise of doing right by users — and often they were. So it is with Anthropic. What I fear, however, is that it is one thing to have people convinced they know best building a smartphone that I can take or leave; it’s considerably more concerning to have them building superintelligence that has the potential to rival or exceed the power of nation states, or merely massive corporations. The history of brilliant people convinced they know what humanity needs is a sordid one, precisely because they have convinced themselves that their intentions are good, justifying actions that very much are not.
In 2025, amid all the talk about AI threats, slop set a tone that’s less fearful, more mocking. The word sends a little message to AI: when it comes to replacing human creativity, sometimes you don’t seem too superintelligent.
不过，我会避免进入项飙所警告的“悬浮”状态。马年来了，那就以马为譬喻吧：“马不停蹄”是有时候不得不进入的状态，但不是目的。说到这里，我不禁想起在雪夜驻马的 Robert Frost：在“一年中最黑的晚上”，他让他的小马停下来，与他一同感受当下的一切，再去赶那睡觉前要赶的路：
My little horse must think it queer To stop without a farmhouse near Between the woods and frozen lake The darkest evening of the year. … The woods are lovely, dark and deep, But I have promises to keep, And miles to go before I sleep, And miles to go before I sleep. — Robert Frost, Stopping by Woods on a Snowy Evening (1923)
voidShortestPath(Graph G, int v0, ShortestPathTable &D) { final[] = FALSE; final[v0] = TRUE; D[] = G.arcs[v0][]; D[v0] = 0; for (i = 1; i < G.vexnum; ++i) { min = INFINITY; for (w = 0; w < G.vexnum; w++) if (!final[w] && D[w] < min) { min = D[w]; v = w; } final[v] = TRUE; for (w = 0; w < G.vexnum; w++) if (!final[w]) D[w] = min(D[w], min + G.arcs[v][w]); } }
Floyd 算法求全源最短路径: 注意 的意义是只经过 号顶点的路径的最小值.
第 9 章 查找
折半查找 (最坏情形下查找长度 )
1 2 3 4 5 6 7 8 9 10
intSearch_Bin(SSTable ST, KeyType key) { low = 1; high = ST.length; while (low <= high) { mid = (low + high) / 2; if (EQ(key, ST.elem[mid].key)) return mid; if (LT(key, ST.elem[mid].key)) high = mid - 1; else low = mid + 1; } return0; }
intPartition(SqList &L, int low, int high) { L.r[0] = L.r[low]; pivotkey = L.r[low].key; while (low < high) { while (low < high && L.r[high].key >= pivotkey) --high; L.r[low] = L.r[high]; while (low < high && L.r[low].key <= pivotkey) ++low; L.r[high] = L.r[low]; } L.r[low] = L.r[0]; return low; } voidQSort(SqList &L, int low, int high) { if (low < high) { pos = Partition(L, low, high); QSort(L, low, pos - 1); QSort(L, pos + 1, high); } }
选择排序
锦标赛排序
堆排序 (建堆比较次数 , 总比较次数 )
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
typedef SqList HeapType; voidHeapAdjust(HeapType &H, int s, int m) { rc = H.r[s]; for (j = 2 * s; j <= m; j *= 2) { if (j < m && LT(H.r[j].key, H.r[j + 1].key)) ++j; if (LQ(H.r[j].key, rc.key)) break; H.r[s] = H.r[j]; s = j; } H.r[s] = rc; } voidHeapSort(HeapType &H) { for (i = H.length / 2; i > 0; i--) HeapAdjust(H, i, H.length); for (i = H.length; i > 1; i--) { swap(H.r[1], H.r[i]); HeapAdjust(H, 1, i - 1); } }
归并排序 ()
基数排序 ()
稳定性: 选择排序、堆排序、快速排序是不稳定的, 其他是稳定的.
归并排序最坏情况下的比较次数:
1
2
3
4
5
6
7
8
9
10
0
1
3
5
9
11
14
17
25
27
快速选择算法
1 2 3 4 5 6 7 8 9 10 11 12 13 14
// 第 k 小 RcdType QuickSelect(SqList &L, int st, int en, int k) { if (st == en) return L.r[st]; low = st; high = en; pivotkey = L.r[st]; while (low <= high) { while (low <= high && L.r[low].key < pivotkey) low++; while (low <= high && L.r[high].key > pivotkey) high--; if (low <= high) swap(L.r[low++], L.r[high--]); } if (st + k - 1 <= high) return QuickSelect(L, st, high, k); if (st + k - 1 >= low) return QuickSelect(L, low, en, k - (low - st)); return L.r[high + 1]; }
