From e1081022e6666368f3911012b7b070b8d43ed45c Mon Sep 17 00:00:00 2001 From: thinklive1 <469631989@qq.com> Date: Sun, 21 Jul 2024 23:31:11 +0800 Subject: [PATCH] Site updated: 2024-07-21 23:31:10 --- about/index.html | 4 +- archives/2023/09/index.html | 4 +- archives/2023/11/index.html | 4 +- archives/2023/index.html | 4 +- archives/2024/01/index.html | 24 +- archives/2024/01/page/2/index.html | 28 +- archives/2024/01/page/3/index.html | 20 +- archives/2024/03/index.html | 4 +- archives/2024/04/index.html | 4 +- archives/2024/06/index.html | 4 +- archives/2024/07/index.html | 4 +- archives/2024/index.html | 12 +- archives/2024/page/2/index.html | 20 +- archives/2024/page/3/index.html | 40 +-- archives/index.html | 12 +- archives/page/2/index.html | 20 +- archives/page/3/index.html | 40 +-- archives/page/4/index.html | 4 +- atom.xml | 54 +-- categories/index.html | 4 +- .../index.html" | 4 +- .../index.html" | 4 +- .../black-souls/index.html" | 12 +- .../index.html" | 12 +- .../\347\247\230\345\257\206/index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 12 +- .../page/2/index.html" | 16 +- .../web\345\274\200\345\217\221/index.html" | 4 +- .../\345\205\266\344\273\226/index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 12 +- .../index.html" | 4 +- .../\350\256\241\347\273\204/index.html" | 4 +- .../index.html" | 12 +- guestbook/index.html | 4 +- index.html | 46 +-- page/2/index.html | 42 +-- page/3/index.html | 40 +-- page/4/index.html | 56 +-- photos/index.html | 4 +- search.xml | 321 +++++++++--------- sitemap.txt | 24 +- sitemap.xml | 54 +-- steamgames/index.html | 4 +- tags/408/index.html | 4 +- tags/JAVA/index.html | 4 +- tags/black-souls/index.html | 12 +- tags/c/index.html | 12 +- tags/hexo/index.html | 4 +- tags/icarus/index.html | 4 +- tags/index.html | 4 +- tags/java/index.html | 4 +- tags/linux/index.html | 4 +- tags/next/index.html | 4 +- tags/pandas/index.html | 4 +- tags/python/index.html | 4 +- tags/vim/index.html | 4 +- tags/webstack/index.html | 4 +- "tags/web\345\274\200\345\217\221/index.html" | 4 +- tags/wrpg/index.html | 4 +- .../index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 4 +- "tags/\345\267\253\345\270\2102/index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 12 +- .../index.html" | 4 +- .../index.html" | 12 +- "tags/\347\240\224distance/index.html" | 4 +- "tags/\347\247\230\345\257\206/index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 4 +- "tags/\350\256\241\347\273\204/index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 16 +- .../page/2/index.html" | 8 +- .../index.html" | 12 +- .../index.html" | 4 +- .../index.html" | 4 +- thanks/index.html | 4 +- thinklive/11069/index.html | 8 +- thinklive/11086/index.html | 12 +- thinklive/14434/index.html | 16 +- thinklive/15197/index.html | 20 +- thinklive/15575/index.html | 8 +- thinklive/16615/index.html | 20 +- thinklive/19859/index.html | 12 +- thinklive/22586/index.html | 16 +- thinklive/23089/index.html | 6 +- thinklive/24155/index.html | 12 +- thinklive/24757/index.html | 10 +- thinklive/25833/index.html | 8 +- thinklive/26286/index.html | 8 +- thinklive/27780/index.html | 12 +- thinklive/28549/index.html | 8 +- thinklive/28990/index.html | 16 +- thinklive/2910/index.html | 8 +- thinklive/29916/index.html | 16 +- thinklive/30989/index.html | 12 +- thinklive/33908/index.html | 12 +- thinklive/36218/index.html | 23 +- thinklive/3852/index.html | 8 +- thinklive/39056/index.html | 12 +- thinklive/3998/index.html | 12 +- thinklive/40355/index.html | 6 +- thinklive/42594/index.html | 8 +- thinklive/44607/index.html | 8 +- thinklive/47457/index.html | 8 +- thinklive/48368/index.html | 16 +- thinklive/48468/index.html | 20 +- thinklive/52285/index.html | 8 +- thinklive/54551/index.html | 8 +- thinklive/59126/index.html | 12 +- thinklive/59610/index.html | 16 +- thinklive/59735/index.html | 8 +- thinklive/8605/index.html | 8 +- 125 files changed, 846 insertions(+), 824 deletions(-) diff --git a/about/index.html b/about/index.html index edc3677d9..2fa6b978a 100644 --- a/about/index.html +++ b/about/index.html @@ -309,14 +309,14 @@

about 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/2023/09/index.html b/archives/2023/09/index.html index 01662c61c..b52cf898f 100644 --- a/archives/2023/09/index.html +++ b/archives/2023/09/index.html @@ -361,14 +361,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/2023/11/index.html b/archives/2023/11/index.html index bd4c4a616..a32094876 100644 --- a/archives/2023/11/index.html +++ b/archives/2023/11/index.html @@ -361,14 +361,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/2023/index.html b/archives/2023/index.html index 80120fcc2..ef4356b2f 100644 --- a/archives/2023/index.html +++ b/archives/2023/index.html @@ -421,14 +421,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/2024/01/index.html b/archives/2024/01/index.html index 17155d0eb..32838993e 100644 --- a/archives/2024/01/index.html +++ b/archives/2024/01/index.html @@ -345,8 +345,8 @@

thinklive

-
@@ -365,8 +365,8 @@

thinklive

-
@@ -385,8 +385,8 @@

thinklive

-
@@ -405,8 +405,8 @@

thinklive

-
@@ -425,8 +425,8 @@

thinklive

-
@@ -504,14 +504,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/2024/01/page/2/index.html b/archives/2024/01/page/2/index.html index aef537002..1043b94b7 100644 --- a/archives/2024/01/page/2/index.html +++ b/archives/2024/01/page/2/index.html @@ -365,8 +365,8 @@

thinklive

-
@@ -385,8 +385,8 @@

thinklive

-
@@ -405,8 +405,8 @@

thinklive

-
@@ -425,8 +425,8 @@

thinklive

-
@@ -445,8 +445,8 @@

thinklive

-
@@ -465,8 +465,8 @@

thinklive

-
@@ -504,14 +504,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/2024/01/page/3/index.html b/archives/2024/01/page/3/index.html index ff08306ee..14fe90099 100644 --- a/archives/2024/01/page/3/index.html +++ b/archives/2024/01/page/3/index.html @@ -285,8 +285,8 @@

thinklive

-
@@ -325,8 +325,8 @@

thinklive

-
@@ -345,8 +345,8 @@

thinklive

-
@@ -365,8 +365,8 @@

thinklive

-
@@ -404,14 +404,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/2024/03/index.html b/archives/2024/03/index.html index 020252770..09e16ecdf 100644 --- a/archives/2024/03/index.html +++ b/archives/2024/03/index.html @@ -321,14 +321,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/2024/04/index.html b/archives/2024/04/index.html index 67de401a5..fab7ae899 100644 --- a/archives/2024/04/index.html +++ b/archives/2024/04/index.html @@ -321,14 +321,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/2024/06/index.html b/archives/2024/06/index.html index 4972fbd66..ad5c5a8d2 100644 --- a/archives/2024/06/index.html +++ b/archives/2024/06/index.html @@ -341,14 +341,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/2024/07/index.html b/archives/2024/07/index.html index b8402d1b4..9c9f20129 100644 --- a/archives/2024/07/index.html +++ b/archives/2024/07/index.html @@ -321,14 +321,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/2024/index.html b/archives/2024/index.html index 593fdae93..655a27fb0 100644 --- a/archives/2024/index.html +++ b/archives/2024/index.html @@ -445,8 +445,8 @@

thinklive

-
@@ -465,8 +465,8 @@

thinklive

-
@@ -504,14 +504,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/2024/page/2/index.html b/archives/2024/page/2/index.html index 6bdea7387..94407f40c 100644 --- a/archives/2024/page/2/index.html +++ b/archives/2024/page/2/index.html @@ -285,8 +285,8 @@

thinklive

-
@@ -305,8 +305,8 @@

thinklive

-
@@ -325,8 +325,8 @@

thinklive

-
@@ -465,8 +465,8 @@

thinklive

-
@@ -504,14 +504,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/2024/page/3/index.html b/archives/2024/page/3/index.html index 7e299ba49..e0fd9c858 100644 --- a/archives/2024/page/3/index.html +++ b/archives/2024/page/3/index.html @@ -285,8 +285,8 @@

thinklive

-
@@ -305,8 +305,8 @@

thinklive

-
@@ -325,8 +325,8 @@

thinklive

-
@@ -345,8 +345,8 @@

thinklive

-
@@ -365,8 +365,8 @@

thinklive

-
@@ -385,8 +385,8 @@

thinklive

-
@@ -425,8 +425,8 @@

thinklive

-
@@ -445,8 +445,8 @@

thinklive

-
@@ -465,8 +465,8 @@

thinklive

-
@@ -504,14 +504,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/index.html b/archives/index.html index 1d753cd58..44c528342 100644 --- a/archives/index.html +++ b/archives/index.html @@ -445,8 +445,8 @@

thinklive

-
@@ -465,8 +465,8 @@

thinklive

-
@@ -504,14 +504,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/page/2/index.html b/archives/page/2/index.html index 47d7cfcc1..017121621 100644 --- a/archives/page/2/index.html +++ b/archives/page/2/index.html @@ -285,8 +285,8 @@

thinklive

-
@@ -305,8 +305,8 @@

thinklive

-
@@ -325,8 +325,8 @@

thinklive

-
@@ -465,8 +465,8 @@

thinklive

-
@@ -504,14 +504,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/page/3/index.html b/archives/page/3/index.html index 000e4a88b..dd93f462e 100644 --- a/archives/page/3/index.html +++ b/archives/page/3/index.html @@ -285,8 +285,8 @@

thinklive

-
@@ -305,8 +305,8 @@

thinklive

-
@@ -325,8 +325,8 @@

thinklive

-
@@ -345,8 +345,8 @@

thinklive

-
@@ -365,8 +365,8 @@

thinklive

-
@@ -385,8 +385,8 @@

thinklive

-
@@ -425,8 +425,8 @@

thinklive

-
@@ -445,8 +445,8 @@

thinklive

-
@@ -465,8 +465,8 @@

thinklive

-
@@ -504,14 +504,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/archives/page/4/index.html b/archives/page/4/index.html index 14abd4a59..051997c34 100644 --- a/archives/page/4/index.html +++ b/archives/page/4/index.html @@ -424,14 +424,14 @@

thinklive

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/atom.xml b/atom.xml index 586025356..fc61304c3 100644 --- a/atom.xml +++ b/atom.xml @@ -6,7 +6,7 @@ - 2024-07-21T06:07:05.047Z + 2024-07-21T15:25:28.788Z https://thinklive1.github.io/ @@ -21,9 +21,9 @@ https://thinklive1.github.io/thinklive/36218/ 2024-07-06T03:26:40.508Z - 2024-07-21T06:07:05.047Z + 2024-07-21T15:25:28.788Z - 本文是对游戏杂谈的一个汇总

thinklive的游戏簿

|表示同系列续作/dlc

神作

神作的认定标准为同时满足以下123条件或者满足4条件：

  1. 有非常吸引本人，或非常引发本人共鸣的某种或某些特质
  2. 除了1.提及的特质以外，以当时同类型业界的普遍研发水平来说，没有过于明显的短板
  3. 制作组在制作和发行游戏的时刻不应当违反普世道德，发行后则不受此条管辖
  4. 如果有颠覆整个业界级别的功绩，或者有历史上及其特殊的地位，可以无视以上规定

一句话简评环节：

  1. 质量效应2：高质量的队友塑造和任务，最后的自杀任务也非常经典，可谓rpg史上电影化叙事的殿堂作
  2. 异域镇魂曲：有趣的世界观，丰富的文本量，让人牵挂的史诗故事，尽管后期完成度欠佳，但仍有个令人回味的结局
  3. 极乐迪斯科：写给数据删除的一曲哀歌，在这个时代回望别有一番风味
  4. 去月球 || 寻找天堂：探讨人心的作品，正是欲望和缺憾塑成了现在的我们
  5. 瓦尔哈拉：科技下的末世是如此冰冷，但人心因此显得更加温暖
  6. 龙腾世纪起源：自由度，队友塑造，战斗系统，世界观铺陈都几乎无可挑剔的西式魔幻神作
  7. 猎魔人 2 || 3：choice and consequence，选择与后果式rpg的杰出代表
  8. black souls 1 || 2：献给挚爱的你的不可思议的梦之国度的故事
  9. 不予播出：荒诞，新奇，充满娱乐性的英式政治讽刺喜剧
  10. 史丹利寓言——艾迪芬奇的记忆：什么是游戏，什么是交互，什么是叙事？探讨游戏本质的游戏的游戏
  11. 诺科：迷幻的来自失落故乡的旧梦
  12. 428被封锁的涩谷：在4月28日的涩谷，扮演一天的命运女神，将命运纺织起来吧
  13. 隐迹渐现：深入历史其中，然后体会自己的无力
  14. 寒蝉鸣泣之时：没有什么比未经过真金火炼的道德更脆弱，相反的是，经过鲜血试炼的善良才会产生真正的善行
  15. 海猫鸣泣之时：啊啊啊，吾最爱的魔女，贝阿朵莉切…………
  16. ever17(可可线)：打越式诡叙与整个电子游戏界诡叙的最高水平代表，虽然这么说，但前中期实在难熬，只有解谜篇值回票价，根据4.规则破例只将诡计和解谜部分算为神作
  17. remember11:推理的公平性上略逊于e17,一口气抛出来一堆科幻设定比较仓促，没有解谜篇也比较麻烦，大部分人设不讨喜，但悬疑感的塑造远超e17,trick的震撼程度，应该说疯狂程度可以算是所有avg大类的top级
  18. 冥界狂想曲：娓娓道来似醇香的拿铁，适合在黄金般的午后享用这个以死亡为表，以生命为底的作品
  19. 恩达瑞尔：结合了杯赛与黑曜石等经典rpg所长而诞生的洞悉了rpg精髓的作品，尽管在引导上依旧有不少问题
  20. 命运石之门:综合来看优秀的人设，文笔，节奏，以及核心谜题的想象力
  21. There Is No Game: Wrong Dimension:天马行空的谜题，剧情和玩法，可以看出作者对游戏的热爱，游戏的游戏也首先是一款游戏，这或许就是作者想表达的
  22. 装甲恶鬼村正:恶即是恶，恶无大小

佳作

佳作的认定只需要同时满足以下条件：

  1. 有比较优秀且能吸引本人或引发本人共鸣的某种或某些特质
  2. 制作组在制作和发行游戏的时刻不应当违反普世道德

一句话简评环节：

  1. 不可思议的幻想乡:抛开同人作的身份也是完成度很高的肉鸽like
  2. 红弦俱乐部:探讨虚假的幸福与真实的痛苦的作品中比较有趣的一部
  3. 幻想乡萃夜祭：精美的像素美术风格
  4. 东方年代记:在开始后结束，又在结束后引来开始
  5. 赛博朋克2077：在电影化+脚本演出式方面投入不菲，对rpg未来的一种探讨
  6. 生化奇兵无限：很疯狂但有趣的剧本，但受限于不适合叙事的fps题材
  7. 武士0：叙事节奏，完成度很不错的像素游戏
  8. 遗忘之城：完成度尚可的时空轮回式故事
  9. 新手指南：探讨游戏，作者以及评论者的关系
  10. 旁观者1 || 2：完成度尚可的反乌托邦作品
  11. 亲爱的艾斯特：节奏尚可的实验性步行模拟器
  12. 不要喂食猴子：玩法上有创新之处的反乌托邦作品
  13. 无主之地2:fps和rpg的融合代表，人设和演出就fps来说相当不错
  14. 战神4:不错的动作系统和演出效果
  15. GTA4 || 5：荒诞而黑色的犯罪演绎
  16. 杀手三部曲：no one is untouchable.
  17. 空洞骑士: 完整度相当不错的恶魔城like
  18. 影子工厂:价值观很积极向上的探讨虚无主义的作品
  19. 龙脉常歌：清新的冒险向叙事游戏，恋爱要素略多但不会显得喧宾夺主
  20. 荒野大镖客：完整且波澜壮阔地展示西部题材
  21. 天壤的暴风雨：打击感很不错的东方act小品
  22. 王权的陨落：典型猎魔人式的苦涩选择，打牌玩法不错，但后期太重复了
  23. 东方月神夜
  24. 伊森卡特的消失
  25. 逆转裁判三部曲 || 大逆转裁判2
  26. 僚机计划:扮演天空之王，尽情地捕猎，撕碎眼前的猎物
  27. 东方冰之勇者
  28. 渎神
  29. 女神异闻录4
  30. 赤痕夜之仪式
  31. 月圆之夜
  32. 悲情法典；内容和机制极其丰富的地牢rougelike
  33. 无敌号
  34. 看火人
  35. 纪念碑谷
  36. 极限脱出
  37. Ai梦境档案
  38. 控制
  39. 疯人院
  40. 海沙风云
  41. 行尸走肉第一季
  42. 漫长的旅途
  43. 史莱姆少女
  44. 来自边境
  45. yes my lord
  46. 遗迹余痕
  47. npc之梦
  48. 与狼同行
  49. 犹格索托斯的庭院
  50. 兔耳冒险谭
  51. 梅卡妮卡
  52. 人狼村之谜
  53. 红色警戒3
  54. 无声尖啸
  55. hello hello world | noir noah:用真实创造了虚假，又用虚假谱写真实
  56. 艾尔登法环
  57. 剧透过于激烈的RPG：利用设定来诡叙的杰出代表
  58. 枪声与钻石:谈判部分作为重点有接近逆转系列的紧张激烈感，搜查部分由于主角作为警方权限更高，信息量也很大，非常优秀的(泛)推理游戏
  59. one shot
  60. 巫师2——白狼的告别
  61. 辐射 新维加斯
  62. 巴别号漫游指南
  63. 命运石之门0 | 线性拘束的表征图
  64. 梦灯花
  65. 莱拉是谁
  66. 闪避刺客
  67. 海市蜃楼之馆 | 纯真安魂曲
  68. 六角疑云
  69. 邪恶冥刻
  70. 装甲恶鬼村正

To Do List

  1. baldr force | sky | heart(?)
  2. rabi ribi(?)
  3. muvluv
  4. 秽翼的尤斯蒂娅
  5. off(?)
  6. king exit(?)
  7. 混沌之脑 | 混沌之子
  8. 永恒之柱 1|2
  9. 博德之门2
  10. 斯坦达尔警戒者(?)
  11. 超时空之轮

出必入

  1. Not For Broadcast: The Timeloop
  2. Just A To the Moon Series Beach Episode
  3. .45 PARABELLUM BLOODHOUND
  4. BS2同人DLC：风与追忆之旅

期待

  1. 晕晕电波症候群
  2. Avowed
  3. 神罪降临 Uberich: Advent Sinners

龙腾世纪

dao

你可能曾因为好奇去搜过cdpr的发家史，也就是从卖盗版游戏到引进游戏并本土化赚到了第一桶金，这个引进的游戏是博德之门，博德之门的开发商是生软。
这里插一句，波兰人的首秀巫师一在开发阶段几乎遇到了一个新游戏能想到的所有问题，这时生软仗义地扶了波兰人一把，才有了巫师一的面世，遂成rpg界一段佳话，不过后来二者先后拉了（
龙腾世纪本来在定位上是博德之门的替代品，因为版权问题生软不能继续开发博德之门，于是便做出了龙腾世纪起源，这一项目立项在02年，但直到07年得到了EA的支持才在09年把这一“神作”做了出来，直到这时EA还是带善人的形象，并没有露出狰狞的獠牙，而在生软的黄金时代打磨了7年的起源，我可以毫不夸张地说，哪怕今年推出这款游戏，它依然是年度最佳候选级别的神作。
我先说说，我为什么要做这个视频，其实在一开始，dao在我的心中的地位还没有要我做一个视频出来的程度，但在玩了龙腾世纪的后两作后，DAO在我心中地位飙升，可见对比的力量，这个杂谈系列会讲完我对龙腾世纪整个系列的感受，当然是纯个人感受，我不是什么rpg遗老，只是一个当代rpg爱好者而已，如有不同意之处，反正我也不会改的。

当你打开dao建立存档时，你可以选择三个种族，三个职业，在种族内甚至有平民和贵族的区别，根据职业和种族的不同，光开头剧情就有六种，由此开始，玩家就能感受到dao的超高自由度。
当然，对于rpg来说，自由度并不是什么稀奇的东西，但dao的自由度是有其独特之处的，以自由度出名的上古卷轴五，它的自由度体现于扮演的角色的多样性，龙裔，战友团成员，冬堡法师等等，这几种身份并没有交集，是独立的，而起源的自由度体现在行为的自由，自由度再高的游戏也不能完全模拟现实，但高自由度的游戏只需要模拟到玩家一时间能想到或者能让他们觉得有趣的所有选项就够了，DAO做到了这点，举例来说，当你接到了调查黑恶势力的任务，你可以当个正义的使者把邪恶势力端了，也可以接受贿赂，甚至可以献祭奴隶来提高自己的力量，你可以与邪教合作玷污圣物，也可以屠杀邪教，杀死恶龙，扮演被选召的勇士，很多时候当你背叛道德时得到的奖励反而更好，高道德的行为除了增加部分队友的好感度并没有太多作用，与巫师类似，起源遵循着成人的价值观，尽管选择大部分时候不像巫师那么残酷，而且起源中后悔也是很容易的一件事，相对削弱了选择的分量。

我们再来说说提高起源代入感的另一个设计——队友系统，独身在一个苍茫浩瀚的魔幻世界冒险难免会感到孤独，巫师的解决方式是让杰洛特和爱人与亲友保持时不时的联系，上古卷轴的解决方式，嗯，我没感到有什么解决方式，至少本体没有，当然如果装了随从mod肯定就完全不一样了。在龙腾世纪起源中你绝不会感到孤独，相比其他知名rpg，生软最显著的优点应该就是队友塑造了，dao的队友大部分有着讨喜且有深度的人设，这是由海量的工作量撑起来的，在冒险时会随机出现队友间的闲聊，几乎所有队友两两组合都有为数不少的对话，或八卦，或正经或取笑，这让人感到队友都是活生生的人，同时也可想而知其中的工作量，单个角色的对话文字量往往都要以万为单位，此外，在营地和队友闲聊也能通过一些选项增减好感度，所有队友都有为数不少的对话树，并且随着好感度的增减还会解锁额外选项。
队友间除了友情也能发展出爱情，这就不得不提我认为在魔幻rpg中最有魅力的女角色——莫瑞甘，她是个荒野女巫的女儿，，价值观完全是混乱中立甚至偏邪恶的，你做好事她嫌你磨叽，做坏事说不定夸你有魄力，好感度低时会邀请你滚床单并声明只是玩玩，好感度高起来了反而不愿继续亲近——“明明说了只是玩玩，怎么你当真了呢”在游戏的结局莫瑞甘会不可避免地离去，而在一个（拿感情骗钱的）的dlc里沃顿却能不远万里追踪到正欲逃走的她，最终让莫瑞甘也承认了爱情的存在，不得不说我真被这段爱情所感动了，这种细腻的感情戏其实不输我们以感情线为特色的双剑系列（当然续作就没这么顶了）
代入感之外，起源的战斗系统也是极有意思的，多有意思呢，大概比巫师三好几十个上古卷轴五吧（不是）起源的系统在今天看也不算过时，采用一种可以随时暂停的即时战斗系统，同时可以为队友ai设置战术，选项极为详细，大佬光靠设置ai应该就可以全自动战斗，我这种咸鱼打boss还是要几步一暂停，很明显这是一种重策略轻即时的系统，不设技能栏上限让法师成为了团队灵魂，控制，辅助，aoe，单体爆发应有尽有，可以说带够蓝药，法师就是无敌的（大部分Boss远程攻击弱于近战），即便职业平衡不是那么好，但队友是可以随意搭配的，丰富的技能树，转职，加点策略，装备系统让起源的战斗和养成充满乐趣，当然大型迷宫各种怪潮难免会腻烦，不过比起后面两作真的是让我体验最好的战斗系统了。
最后我们来说说起源的剧情和任务设计，大恶魔苏醒，黑潮突起，作为临危受命的灰袍守护者，沃顿利用古老盟约集结联军，手刃大恶魔，可以说是一个很俗套的故事，怎么把这种看起来很俗的故事讲好呢，答案是独立的小故事相加辅以大量填充细节和设定，起源的几条线，法师，矮人，精灵，伯爵都是相对独立的故事，套路很简单：求援——当地陷入危机——解决危机——得到援助，期间夹杂背叛者洛根使绊的故事线，每个地方引出了一部分的世界观设定，起源有着极其繁杂的文本，尽管套路类似，但每条线提供的信息量都是复杂且独特的，同时也有着世界观内各个势力特有的风貌，安教的圣洁，矮人的森严都得到了体现，即使很想比较，龙腾世纪的世界观也是独特且复杂的，当然，相比起源的主线，支线反而比较一般，不乏收集的填充式支线，当然，队友的支线还是很有趣的，也有一些补充世界观的有趣支线。
说了这么多，应该基本说完了起源的特点，当然也有很多具体内容我并没有提及，事实上起源并不是没有缺点，比如优化太差，自带防沉迷，玩几个小时就会卡顿到没完继续，只能重启，此外，敌人种类稀缺，也存在强行推动剧情而忽略合理性的情节，甚至有手刃大恶魔实力的主角有的时候莫名其妙就当垫脚石了，但起源仍然是神作，作为一个玩惯了10年后游戏的人，我玩起源没有感到任何系统在恶心我，可见制作组对玩家体验的重视，这是龙腾世纪的续作都未能做到的，，这也是我为龙腾世纪和生软感到可惜的原因，下一期我会叙述我对两部续作的看法，当然批评为主，，，
出道即巅峰的起源全平台销量不过470w，或许正是这样的销量驱使着生软不惜与老玩家对立也要向着主机倾斜，只可惜了龙腾世纪成为了开幕即巅峰，出场即绝唱的一个悲剧……

da2

今天我们来说说龙腾世纪二，，龙腾世纪二是系列中一部很，额，很独特的作品，他刚发售时的风评，作为后来人我不是很清楚，不过就现在来看，da2的风评呈现一种两极分化的形势。
这里插一句奥，我个人感觉rpg游戏的受众是个很宽容的群体，我这种认为2077是款好游戏的人放一些地方可能被叫孝子了，但对现在龙腾世纪的粉丝来说这可能都不算事，举个例子吧，写文案的这天龙腾世纪吧有个直接辱骂起源人气角色的，甚至没什么人骂回去，这放在其他单机游戏圈子里是难以想象的，所以对于龙腾世纪二这样极其赶工的，大部分玩家评价起来基本没什么戾气，当然事实上我很喜欢这一点，也是这点造成了da2并没有招致较为深入的批评，今天我会详细地阐述这部作品的缺点，当然是以我的角度，同时我也不会带有什么负面情绪，我个人其实很喜欢这个系列，二代我也不是那么讨厌，但它的问题确实是露骨的，毕竟太温和往往就意味着圈子的自净能力不够，对一些问题往往就不能看的那么透彻。
我之前说了da2是一部赶工明显的作品，有多赶工呢，2077和它相比那都不算事，生软甚至没有给二代一个后缀名……
我们先从系统性的问题说起
首先作为一个rpg游戏，da2从头到尾（一共三章）几乎一直在重复利用十几个地图，一样的别墅，一样的山洞（还Tm贼亮）等等，这也是所有玩家都承认的一个问题，考虑到14个月的工期，这点可能也是难以避免的，不过这个问题实际上并不止这么简单，因为地图的数量太少，各种任务线又要在不停阶段换来换去，这就给玩家造成了一个两难的问题——如果按任务线推不得不忍受一个又一个重复度极高的地图，如果以最高效率的原则一个地点一个地点地清，又会错失现状的任务叙事，这种矛盾是稀缺的地图造成的，也是da2在叙事上的一个根本性的缺点
然后，整个战斗系统可以说在da2迎来了史诗性的大改，或许是制作组没有力气做大规模的技能，所以被官方钦定为法师的霍克技能远远没有一代多，对一个技能你要投至少两个点数进去才能强化到底，更别提一个系的被动build需要投入更多，法师的技能树相比战士盗贼完全没有优势，还有那个攻击动作，法师舞得和金箍棒似的，搞act化不能这么搞啊，怕不是设计师想起自己做《翡翠帝国》（生软以前的东方题材rpg）曾经看过的西游记，把法杖当金箍棒设计……然后是二代的刷兵机制，科克沃是个小城市，但在本作中你可以看到如同下饺子一样天降的敌人杂兵——分批次有顺序地入场，先不说不集结优势兵力在战术上有多不明智，二代的aoe法术是大削过的，我基本上要带两个输出法师才能确保范围伤害足够…… 然后是Boss战的秘之设计，堆血加流程化战斗，什么意思呢，举个例子，在最后一章有个杀龙的支线，Boss血贼厚，而且打一会它就会飞走留一堆小杂兵，自己在打不到的高台上放冷箭，有一说一，不难打，但确实恶心，我记得贴吧有个最高难度的老哥打了一小时，我估计啊，制作组对赶工做的boss没信心，所以用这种机制来给玩家提供“紧张感”
本作队友的战术槽给得更多了，这是个好事，但相应的队友的装备系统反而被砍了（武器能换）也就是当霍克捡到非自己职业的装备时，这就是垃圾，还有本作的dlc装备，又多又杂……steam上的全dlc装备过了100件，而且大多是毕业装备的水平，当然本来装备系统也没什么收集的乐趣，dlc出了应该也是破罐子破摔……
当然成功的革新也不是没有，队友的感情线是得到了深化的，高对立和高友好都能得到buff和对应技能树，这有利于玩家不顾及队友好感度地遵循本心去做选择，也增加了build的多样性以及跨职业的连击，不过相应的礼物系统和营地闲聊也砍了……（但我个人还是更喜欢起源的策略性战斗）……
随后的一大麻烦就是剧情，da的小格局剧情在魔幻rpg中应该算少见，虽然这种选择多半也是因为无奈，很多玩家或许是因为新奇而觉得这样的叙事很有意思，确实，不能说da2的故事无聊，但是缺点和漏洞也很明显，我们先把剧情大纲给复习一遍。
枯潮来袭，叛教法师之子霍克与家人逃难到科克沃，在一次矮人矿坑冒险中发家致富，几年后解决了库纳利人的叛乱成为捍卫者，最终面临圣法矛盾的激烈化，并在安德斯的一次恐怖袭击后解决了发布灭法师环令的圣殿骑士领导者梅疯子，圣法大战的时代就此拉开序幕。
只看大纲其实生软的编剧还是有点东西的，有转折，有历史大势，有多方势力的牵扯，看起来很好，是吧，但如果你抛开糟糕的跑任务体验去仔细审视这个故事，你就会发现很难立得住脚。
我猜想啊，14个月的工期一给，编剧拍脑子一想，咱做个小格局故事，矛盾层层激化，来点刺激的，然后开始考虑怎么让角色对号入座，为什么这么说呢，因为da2的故事是典型的情节推动型，霍克从始至终跟着情节走，不是说这么不好，不过da2处理得相对不太行，同年的巫师二也是分三章的小格局叙事，但他们着眼点是主角，杰洛特的立场很明确，找老婆顺便寻回过去记忆，政治那是附带的，他被牵着走，被逼着站队，很合理，互相利用嘛；da2有所不同，霍克从始至终都是城里有排面的人物，就是第一章也是和城里卫队小队长有裙带关系的王牌佣兵，他不能一直被动吧，你da招牌式的自由度呢？
我们来按顺序捋一下故事线，第一章用一些小任务引出了血法师与激进派圣殿骑士两大毒瘤作为引子其实还行，不过霍克听了瓦里克几句忽悠就要下坑道了略显仓促，当然瓦叔是一代口才点满那种人物，系列里忽悠谁谁信，不过下坑道不带安德斯霍克的弟弟就会死着实是个离谱的安排，奥尔加过后大家应当都知道对一个重要人物的出退场不能那么仓促，但奥尔加死的仓促是因为不这么做编不下去，da2是图什么？沃顿和队友杀了不知道多少暗裔，就没受过伤？怎么就你卡沃毒抗负数，你要说是为了霍克成长也不现实，da这种强调主角就是自己的游戏是不会有主角成长的需要的，只能说这段是真的迷惑，除了让卡沃有机会当沃顿没有任何意义
然后进入第二章，这一章的主线是库纳利人线，这段剧情其实写得不错，库纳利人的塑造很有趣，但问题在于二代本就是个内容不足的游戏，着力想展现的圣法之争和库纳利人一点关系也没有，这段想抬升霍克地位的意图实在是明显过头了，再加上一大段剧情给了库纳利人，分散了玩家注意力不说，让圣法大战本就不足的铺垫和描写雪上加霜，当然第二章也有支线，支线讲了什么呢，全讲了血法师是怎么毒害大众的，事实上本作除了第一章有几个法师卖惨，其他的戏份几乎全给了血法师以及安德斯这种激进派，这就导致了一个很搞笑的问题，你说法师不能迫害，但梅疯子一开始也没杀人，你这城市逢一个法师十有八九练血魔法不管你管谁呢？其实圣法之争的核心问题很简单——法师到底多容易堕落，在一代中一个法师用血魔法能屠大半个法环，很危险，但召唤恶魔者本来就是个危险分子，血魔法对他来说只是工具，你要说恶魔诱惑法师有多容易就很难说，同是老血法师的莫姐不就啥事没有，这个问题不挑明，法师的存废很难有定论。
我们再来说说全游戏的高潮——第三章，da2的剧情呈现一个很神奇的现象，你要说层层递进那确实是这样，但递进的未免比较太快了，纵观全游戏你基本看不到什么温和派——无论圣法，对编剧来说激进派确实好用啊，超快节奏推剧情，但对玩家就会感到憋屈。全游戏最激进的梅疯子，她疯吧，但面对霍克这个叛教法师之子，公然的血魔法使用者她一点也不刁难你，霍克还有个顶着精灵和血法师双重debuff的梅丽尔，她也不管，霍克既然这么有面子，那联合一下城里的势力反对她不难吧，结果没给选项，更神奇的是圣殿和法师还有有识之士站出来想把梅疯子杀了，这时候编剧又觉得梅疯子真被保守派刀了结局没得放了，于是让这些人绑架了霍克的家人，这也算了，真密会了还有血法师跳出来把温和派圣殿杀了，你们搞秘密集会成员审查就这水平？放进来个血法师不说还在关键时刻内讧，真的可以，事实上你在游戏里遇到的法师不是莫名其妙疯了就是几乎没有塑造，情节推着所有角色在走，再举一个例子，蕾莉安娜这种间谍头子怎么着也是雷厉风行的实战派了吧，科城的局势像在火上烤，教皇把蕾莉安娜这种重量级角色派来，你猜派来做什么，派来劝现任主教快走，那科克沃怎么办呢，蕾妹连句懂得都懂都没和霍克说
几边都这么随波逐流，主线怎么推进呢，于是安德斯直接开始搞起来恐怖袭击，不得不说这段真的是异常生硬，安德斯前几章还一副弱受的样子没一点铺垫直接搞恐怖主义了，而且搞完还一副为大义牺牲的样子，问题的根源不解决，法师永远会被歧视，这样的情节有什么意义呢，要在魔幻世界观谈政治本就是件很难圆的事情，更别提生软还处理得这么生硬
可能有人会说这样神转折也很震撼啊，但正如我之前说的，奥尔加之死也是神转折，但没有足够铺垫的生硬转折在剧本创作里肯定是要避免的，可以说二代编剧本来应该想写出霍克身为科克沃捍卫者也对历史大势卷携着无能为力的剧本，但实际效果呢，是各路代表不了大势的牛鬼蛇神作死，而我们的霍日天在一边看着准备收拾残局。
我一直坚持在文艺创作领域风格和水平要分开看，就比如我知道二代有很多拥护者，但他们可能大部分是喜欢这种以小见大的叙事风格，而不是充满漏洞的叙事水平，da2虽然我说了他的很多缺点，但生软的剧本虽然很难跻身一流，但保持二流水平还是可以的，剧情演出的信息量能淹没很多人对不合理处的关注便是明证。
Da2故事上的失败很大部分要归因于赶工和工期的匮乏，这一游戏的大部分问题皆来自于此，至于一个世界观宏大的rpg讲小格局故事是否明智，从后见之明的角度看，da2在作为da3的引子方面还算是成功的，但无可否认da2在设定上根本没什么进展，我们要知道dao在世界观构建上只是刚刚展开，还没到成熟的地步，直接在这种半成品框架下讲故事对完善世界观有所期待的玩家肯定不会满意
大部分da2的玩家应该都为这款游戏感到可惜，如果再有一年的时间可能以上的问题能解决个大半，但奈何生软摊上ea这么一个急功近利的老板，而在下一作，生软带给我的就更多是愤怒，而不是惋惜了……to be continued
以下是个人的碎碎念
一代赶路神技加速术居然砍成限时Buff了,而且这游戏强调同性恋是不是有点过了，安德斯动不动一脸弱受的样子，而且那啥院居然还有不问你性取向直接调情的男妓……这算性骚扰了吧，伊莎贝拉一代可没那么黑啊，这是在海上漂了几十年人种都换了？生软搞zzzq真的由来已久

dai

今天我们要介绍的这款游戏，于2014年以压倒性优势赢得了tga年度最佳，没有任何一个竞争者是与它同一个量级的，gta5，最后生还者为了避其锋芒不得不选择在13年发售，巫师三被吓得跳票到15年，在得知14年有这款游戏后，宫崎英高慌得只得把黑魂三继续打磨到16年，它就是古往今来最强的rpg游戏——龙腾世纪审判！！！
对审判的评价有个很神奇的现象，刚推出的年份似乎风评尚可，但随着时间推移，评价越来越差，这似乎意味着这是一款开创先河的游戏，无论是填充式的开放世界，还是泛滥的政治正确，都在这款14年的游戏中得到了体现，当然我不怀疑生软的目的，毕竟制作组高层就有同性恋，甚至现在看来惨不忍睹的开放世界当初的生软可能真的觉得很好（虽然被第二年的巫师三干碎了）
审判在我心中一直是一部很独特的作品，如果你让我说明da系列的优点，一代的优点不胜枚举，二代我至少可以说风格很独特，三代就比较神奇，它的优点，额，藏得比较深
那我们不妨就先说说它的优点，审判在世界观和时间上的推进上有巨大的建树，我的意思是，填了几个坑的同时挖了更多的坑，生软在下一盘很大的棋，无论是揭开奥莱斯的帷幕，教会的黑暗过去，亦或是把古代精灵的设定全部推倒，都能让我们感受到生软在剧本上的用心，确实，理论上讲，dai的剧情是很有看头的，但生软把自己的缺点推向台前，把优点深藏幕后，让我在玩的时候频频破防，也是真的厉害
我们还是先从系统问题说起，不知道是什么给了制作组勇气，本作的引擎换成了做战地的寒霜，这个引擎对rpg的适配性极差，为了实现存档生软就不得不对其做了大量魔改，乃至系列核心功能的存档继承还要通过一个网站实现（没有中文支持哦），不知道是不是为了照顾主机，即时演算cg还是锁30帧的，配合僵硬的人物动作，让我感觉在看ppt，审判还有一种极为奇妙的油腻效果，你要用在植被景物上我就当做油画风格了，但奈何人物也是这个样子，个个都像青春期几个月不洗脸一样满脸反光，在这里我澄清一下啊，有黑子造谣叫索拉斯“蛋头”，索拉斯什么时候配碰瓷我们鸡蛋了，你家鸡蛋反光到这种程度？
审判主打一个开放世界，什么叫开放世界呢，每个地图给你一堆无聊的收集式支线，跑断腿去吧，此外，除了某些装备词条，审判官没有任何提高那慢的像残废一样的移速的手段，偏偏生软还恶趣味地把地图做的很大，收集式支线的收集品路线拉得很长，如果不修改游戏速度，或者有什么特殊癖好我觉得是撑不下去的，顺便一提也基本没有什么像样的奖励，生软不会真的觉得这种任务能留得住玩家吧，就算14年大家还没有被育碧的填充式开放世界搞得审美疲劳，也不会对这种设计甘之若饴吧
当然了，也有人反驳，又没有强迫你做，不喜欢大可不做，首先呢，为了推主线总归是要做支线积攒势力点的，其次，这也涉及到游戏设计的一个问题，一个叙事向游戏，最根本的是什么，我认为就是像玩家提供信息，一个优秀的的叙事游戏必须在游玩过程中高密度同时高质量的提供给玩家信息，同时这个过程必须是有导向性的，要将玩家的注意力导向最能给予他们信息的方向，因此任务日志里主线永远要在c位，即使是巫师三这种支线质量领先业界的作品，也有粗制滥造纯跑腿的任务，但这些任务流程不会长，也就是，虽然提供不了什么和世界观塑造或者叙事相关的信息，但由于时间短，这段时间的信息密度并没有低到无法忍受，我们看看dai是怎么处理的，首先支线在基本没有信息量的同时，极度磨叽，当然这也就算了，毕竟不喜欢可以不玩嘛，但制作组自作聪明地把这些制作水平极度粗糙的支线，给塞在了日志里，一打开日志界面就是密密麻麻的0/X，我相信但凡是个正常人都会感到烦躁，这就是很失败的一点，它将玩家的注意力导向了最错误的方向，是个极度离谱的设计
同样是为了照顾主机，本作的技能栏进一步精简到了8个技能，8个技能，战士和盗贼都没有过这么吃紧的技能栏，你让法师玩什么？虽然是个人喜好问题，但这种革新是不是有点太过分了一点呢？说实话dai我是一点玩法师的欲望也没有，不是说强度有多少削弱，而是策略选择的灵活性没有了，说到策略，本作更迷惑的一点是取消了战术设定，可以说是向即时act全面转进，da系列每代都有极大的革新，我也不知道是图个什么，我们就当是因为商业利益不得不妥协了吧。
再说剧情和人设的问题，只看大纲，审判的剧情和一代很像，都是主角临危受命杀死大魔王拯救世界的故事，区别也是有点，审判的格局宏大的多，看得出编剧很有野心，一代的费罗登和仅仅提及过的奥莱斯都是本作的舞台，但问题在于呈现的方式，极度草率，我之前说dai是开放世界，其实这不完全准确，因为只有地图和任务是开放的，能去的地方其实就几个，而且大多是荒郊野外，根本不足以展示末日将临下两国的反应，当然生软也想了个办法，就是决策桌系统，说实话这就是个挂机文字游戏，而且频繁进出还很浪费时间，尽管事件很丰富，但寥寥几语文字提供不了多少信息量，一代通过支线我起码看出了点费罗登人应对枯潮的绝望与恐惧，审判恕我直言，完全没什么感觉，当然我不否认主线的几个大事件做的不错，但相应的小格局叙事的空缺让我感觉到这场灾难的苍白，试想一下，审判团之外判官直接接触过什么组织什么人，没几个，是吧。
再说人物，本作的大反派，考爷，不得不说异常苍白，一代的反派洛根虽然傲慢愚蠢但至少性格是有几个侧面的，考爷有什么呢，纯粹的邪恶与野心，其实这样也行，我一向认为刻画人物有两条路，一条是通过各种细节展示其多面性或者成长与突变，一种就是把一个性格特质发挥到极致，比如jojo福音的田最环，就是个坏人，但他诡计多端会演戏，文能严刑逼供心理施压，武能压着吉良和仗助打，这就是把恶这一性格写到极致，但考爷两边都不沾，风头全被我们男判官的好兄弟，女判官的好情人索光头抢走了，真的是惨。
反观入侵者dlc可以说才是真的点睛之笔，回过头来想想，几乎整个审判本体都在给这个dlc作铺垫，不得不说这个dlc确实让我感受到了生软最后的实力
再说队友，其实dai的队友一直给我一种神奇的疏离感，但本着科学严谨的态度，我思考了好一阵为什么会有这种感觉，在这里和大家分享一下
首先是身份上的疏离，一二代的队友都各有各的不同，但总归是人类，精灵，矮人三个基本分类，而且归属上都是费罗登的人，审判就比较神奇，铁牛是库纳利人，科尔是个灵体，其他队友从费罗登奥莱斯两对头，到遥不可及的德凡特，都有，当然这只是最浅显的一点，但身份的疏离明显加大了队友间的隔阂
其次，考虑一下一二代与三代主角的不同，一二代都是有所谓初始剧情的，因此他们都有自己的死忠与初始势力，一代的沃顿初始有同事A哥和受了母亲命令的莫姐两大死忠才开始招募队友的旅程，二代的霍克不仅有弟弟/妹妹还有艾芙琳的支持，更重要的是，加入的队友大部分是孤家寡人，都是孤身投奔梁山的类型，而审判就不同了，初始就有自己势力的卡姐，率部投奔的萨拉，间谍铁牛，法师领袖薇薇安，瓦里克还是霍克的死忠（十年老交情不可能完全站在判官这边）导致判官严格来说甚至没有可以信任的亲信，相反，还要应付各怀异心的队友
最后，对于角色的塑造来说，一共有三个过程，不成熟，成熟，升华，举例来说，一代鲜有不成熟的角色，成熟的利己人格莫姐最后接纳了爱情这是对其人设的升华，成熟的温奶最后决定牺牲自己造福世人，这也是一种升华，一代是不缺少有自己成熟价值观的人物的，看着傻白甜的蕾妹实际上早就身经百战了，而三代不成熟人格就多起来了，卡姐看着霸气，实际上被瓦里克骗了很久，而且天真的没有意识到圣殿骑士膨胀的权力必然导致的对法师的压迫，科尔更不必说，黑墙直到赎罪后才形成了成熟的人格
再说一些其他方面的问题，我是指，政治正确，不知何时起gayware的游戏已经成了同性恋人群的狂欢处了，在尊重同性恋的同时我能请生软尊重一下异性恋吗，队友里能推的只有卡姐？生软塑造女性角色的功底可以说在倒退了，相反的，光头倒颇有一代莫姐的风采，然后是黑人姐姐薇薇安，据我所知龙腾世纪并没有任何关于人种肤色的设定，但我们的薇薇安姐姐就这么不羁地出现在我们眼前，似乎不认为自己在满世界的白皮人中有任何特殊之处，更神奇的是这位姐姐的人设还是交际高手，我很好奇奥莱死的权贵们难道真能把薇薇安当同族看待？据我所知一个明显与交际圈所有人都不同的人，被排挤才是正常操作吧，而我们的薇薇安姐，不仅顶着异于常人的肤色，还有着其貌不扬的一张脸，能成为帝国圈内炙手可热的交际花也是相当励志了。顺便一提，有人说叠buff拿年度最佳是美末二首创，其实是dai玩剩下的，从这点看可以说是非常有创造性的一作了
总的来说，虽然定位上dai是一部中兴之作，但这部作品在最底层的设计逻辑上存在很大的问题，整个路都走错了，如果生软把做开放地图和低质量支线的精力拿来做出一代那种不乏少数有趣支线的线性地图，把决策桌换成各种小任务，那么呈现出的效果必然会好很多，同时，恼人的政治正确，油光满面的建模，浮夸的网游式特效，让审判在外观上都显得不讨喜，我由衷的希望da4里生软能认清自己，摆脱这些乱七八糟的问题。

巫师

熟悉我的朋友都知道，我本人是巫师系列的死忠，如果让我给rpg游戏做一个排行，我会把巫师放在第一位，有的人可能会说，巫师固然是rpg佳作，但在浩如烟海，名作辈出的rpg里可未必排的上号，又有的人可能会说，说这么多不过是“情怀党”的矫情而已。
不错，巫师系列对我来说不只是一个游戏，如果说每个人最大的爱好都有一个启蒙物，那么可以说正是巫师，将我带进了那些着重于叙事的游戏的坑。不过与大部分人不同的是，我初次接触巫师系列是巫师的二代。
那是一个普通的暑假，我费力地思考着，家里残破的笔记本电脑到底能玩点什么游戏，这时我突然想到，听说有个叫巫师三的游戏挺有名，我不如试试它的前作好了。就这样我搜到了巫师一二，巫师一画面陈旧，操作蹩脚，我毫不犹豫地排除了它，但二代却有着在那个年代来说不错的画质，于是我找到了它的资源，试着玩了起来。
听到这里可能大家觉得我无非在说一些陈词滥调，但我想说的是，巫师二即使以我现在不知道涨了多少的阅历来看，依旧是一款特立独行的游戏。在此之前我也玩过不少游戏，但我从来没有见过一个没有政治诉求纯粹为了自己的利益行动的主角，我从来没有见过一个每个人都栩栩如生，有自己行事逻辑的世界，我从来都没有见过，一个以阴暗的政治冲突，种族歧视为背景的游戏，即使以rpg来说，巫师二也是个很有勇气的游戏，在巫师二不长的序章过后，就会面临两个截然不同的分歧，并且这两条分支路线的重复内容并不多，如此大的分支毫无疑问是不多见的。现在回想起来，巫师二可能是我唯一一个一点也没有碰支线的rpg游戏，固然因为当时我懵懂无知，但其波澜壮阔的主线确实无比吸引我，
是的，这是一个非常有突破性的游戏，可谓是cdpr写政治戏码的巅峰，但是，很神奇的是，这又是一个被遗忘的游戏，不仅是被引流来的巫师三玩家遗忘，就连cdpr好像也忘了它，巫师三和二代基本没有什么关系，可能有人会反驳我，巫师三的开头就要模拟二代抉择，但事实上，对一个强调选择的rpg游戏来说，重要的不仅是选择，更是选择带来的后果，而巫师二那些惊心动魄的选择，在三代中几乎都成了定局，无论上亚甸是否赢得了独立，最后的区别不过是沦陷在亨赛特的军队下还是尼弗嘉德军队下而已。无论是否救回泰莫利亚最后的王室血脉，罗契都只能带着他的兄弟们再度流亡。更神奇的是二代最成功的女性角色，龙女居然不知所踪，事实上龙女和伊欧菲斯在巫师三曾有过一个现在沦为废案的任务，但因为赶工期被砍掉了。我们对比一下同样三部曲的龙腾世纪，一代的诸多队友都会在二代亮相，甚至还能在三代中当重要角色。而巫师三部间的关联则少得可怜，一代的女主角夏妮在石之心才出场，也就雷索与罗契在三代的戏份多一点，这无疑大大削弱了巫师中选择的分量。当然，我也能理解cdpr，三代是系列中唯一重启主线的一部，与更像外传的一二部有着极大的区别，并且这一作有着不小的制作规模，必须放弃前作壁垒，放低身段吸引新玩家，种种考量下，三代注定是相对独立的一作，更何况在二代一番精心算计下，事线固然优秀，但已经形成了逻辑闭环，也很难找到延续的办法。而三代为了种种考量，强行让南北形成均势，更破坏了延续巫师二剧情的可能性，尽管可惜，但巫师二作为一个完整的故事，也可以称得上优秀。
接下来我们就来讨论一下一款游戏。
首先，依照惯例，巫师二的系统，巫师二的画面在当年算得上不错，但毕竟此时的cdpr并没有太大经验，因此整部游戏的一些地方仍然显得很生涩，比如说，巫师二是没有跳跃功能的，只能让玩家去寻找攀爬点才能上下移动，而这些攀爬点则都做的很隐蔽，配合拙劣的导路功能，跑图体验难言理想，随后巫师二的战斗相比巫师三繁琐不少，同样分为三种流派，近战，炼金和法印，法印有单独的储备槽，能随着时间恢复，这点有点像dnd，近战则有和三代近似华丽但破绽很大的剑术，并且翻滚是没有无敌帧的，也就是说翻滚途中被攻击打断是常用的事。药剂和炸弹都是一次性用品，众所周知，rpg游戏的一次性用品就是不打最终boss能不用就不用的东西，因此虽然炼金流算得上强力，但由于合成的琐碎以及造价昂贵，走这条线的并不算多。总的来说巫师的战斗系统基本都是在及格线上徘徊的水平，实在没有多少意思。
而论起剧情，就很有的说了
巫师二的叙事有什么特点呢？
第一，选择
巫师二依旧采取了巫师系列道德困境式的抉择，有不少人批评说这种列车难题式的道德抉择千篇一律，然而，我很好奇的是，他们指望在一个商业游戏里看到怎么样的抉择设定呢？巫师的抉择可能算不上精巧，但在rpg可以说是独树一帜的有分量，重要人物的生死，一个王国的命运，巫师二充斥着各种意义上的抉择，甚至包括第二章两个截然不同的路线。放眼整个rpg史，我敢说有如此大主线分歧的也是寥寥无几，而这样独特的设计，其实与巫师二的剧情结构有不少关系。
第二，双线叙事
我们的杰洛特一向对政治敬而远之，而巫师二构思巧妙之处在于，让一个对政治最没有兴趣的人成了北境局势的关键人物，在游戏中，双线并进的结构被广泛的运用。杰洛特的态度是模糊的，归根到底他不过是想洗脱罪名并寻回自己的记忆，这两大主线目标，前者为主线后者为暗线，都被牵扯到了同一个人身上——雷索。而对于雷索的刺杀行动而言，女术士集会所的阴谋浮现在明处，而隐藏最深的则是尼弗伽德入侵的阴谋。对于游戏中涉及的北境势力而言，两大对抗者，上亚甸和科德温，杰洛特在游戏中任选其一作为明线，另一方便会成为暗线穿插其中。几条剧情路线互相交叉，且彼此间都有说不清道不明的关系，可以说巫师二颇有些戏剧的风格，重要人物算不上多，但却有着极为复杂的人物关系，整个故事都十分耐人寻味。
第三，演出水平
巫师在剧情演出上向来不遗余力，这点倒是颇有生软的师传，巫师二增强版的开场cg对一个11年的游戏来说可以说无比华丽，而在随后的剧情中，也有不少制作不错的cg的即时演出，更有趣的是，不知道是不是为了赶时髦，巫师二还做了两个系列中少有的巨型boss战，在11年来说，这样的演出效果可以说相当不错了，说到这里不得不佩服cdpr的勇气，只做过一部巫师一就敢砸这么多钱到一个前景不明的项目去。
第四，政治阴谋
大部分宫廷政治故事都是肮脏的，巫师二也不例外，开篇我们就能看到为了自己和妹妹的私生子发动王国内战的妹控王，要说这妹控王也是个有勇有谋之辈，但把自己荒淫无度的行径公开到整个国家民众面前的行为，着实是让人叹为观止。如果你觉得这已经很毁三观了，那么我可以负责任地告诉你说，福尔泰斯特在北境执政者里是道德楷模级别的存在，整部游戏里你碰到的政治家，浮港的总督是个没有下限的人渣，亨赛特是个粗暴蛮横的野心家，此时看上去正常的拉多维德对待自己的恩师也是“无微不至”，就连浓眉大眼的斯坦尼斯王子，都能为了上位一脸坦荡地毒害龙女。
当然了，也有萨奇亚这种浑身坦荡的完美领袖，上亚甸是巫师中难得直接描写非人种族抗争的一段剧情，十分正能量和主旋律，算是难得地调剂了巫师阴暗冷酷的风格，巫师对“义军”的描写并没有落入俗套，龙女一身正气但是并不迂腐，伊欧菲斯虽然仇恨人类，但并不是不择手段之辈，他会对萨奇亚动心，会对救了他的命的杰洛特予以回报，矮人往往看上去豪放，却不失狡诈和算计，而义军中也有斯坦尼斯王子和菲丽芭这种野心家。Cdpr对上亚甸线是很上了些功夫的，多种族混杂的特点被个性迥异的npc完美地体现了出来。可以说，在有政治戏码的rpg中，巫师二绝对是一部水准上的作品。
稍微扯开一点话题，巫师二的最终boss雷索，我个人认为是rpg游戏设计得最成功的反派人物之一，雷索的人物志在b站就有，在此不做赘述，纵观其生平，不得不说无论是公事还是私德上，雷索都是一个近乎完美的角色，公事上为了复兴自己的学派，雷索完美执行了恩希尔大帝的命令，他的刺杀行动无不是计划周详，下手果断，善后的处理的也无可挑剔，甚至面对女术士集会所的谋划，将计就计把北境的大部分术士架上了火刑架，要知道，让术士吃这种大亏，这恐怕是猎魔人历史上都没几个人能做的壮举，更可贵的是雷索在做这些事的时候完全秉持公事公办，各为其主的态度，他没有因为杰洛特是福尔泰斯特的护卫就下手迟疑，也没有把自己兄弟的死记在杰洛特头上，他始终清楚地认识到自己不过是尼弗伽德的一把刀这个事实，即使三代中被恩希尔背刺了一刀，也很难说他会有多么吃惊，而在私德方面，为了答谢杰洛特的救命之恩，他跟着杰洛特去迎战几乎没有胜机的狂猎大军，保护叶奈法，甚至在最后把特莉丝从大屠杀中救了出来，而在整场游戏中，他一次也没有对杰洛特下死手。这种文能算计整个北境的术士，武能压制失忆期杰洛特的全能型人才，实在是比工具人白狼不知道高到哪里去了。可能每个巫师系列的粉丝都对巫师四有自己的想法，不过如果是我的话，我是很希望能有以雷索为主角的一部游戏，这个人设实在是太强了。
上述是我个人认为巫师二的优点，不过如果你要问我有没有缺点，那我也可以很明确的说，有的，而且还很明显，并且这个缺点贯穿了整个巫师系列。
我们知道，rpg的意思就是角色扮演游戏，意思就是可以让玩家扮演一个虚拟角色在一个虚拟世界中做出种种行为，巫师系列是21世纪rpg的一大系列，但巫师却并不是一个完全标准的rpg，为什么呢？因为杰洛特是有性格的，杰洛特大体的性格是，外冷内热，自尊心强，外表冷酷无情，内心深处其实是一个傲娇老好人，这样问题就来了，你杰洛特都有性格了，那玩家怎么做选择，cdpr的回答是，尽量把所有选择都做成两难式的，即使是杰洛特本人来选也会犹豫的那种，这也是为什么cdpr总是喜欢这种两难抉择的原因，但还有问题，总有一些真正的杰洛特不会犹豫的选择，比如说真正的杰洛特必然是椰奶的舔狗，而面对这种选择，玩家只能扮演自己，这就让巫师的剧情流程也有了一种割裂感，你是要扮演杰洛特还是扮演自己，这是在你打开巫师游戏前要先做出的选择。当然，两种选择都无可厚非，但这也必然会造成一些矛盾性的情况，像巫师二里，无论哪条线路，不去救特莉丝都会都会对游戏的重要角色大有益处，作为玩家，如果你查了攻略，你就会知道好兄弟雷索会帮你把萌特救出来，然而如果真让杰洛特选他绝对不会放弃自己的情人，也就意味着，要么玩家放弃选择权，要么就要忍受杰洛特的ooc（人设崩塌）。
我个人觉得这是个不大不小的问题，只要做好心理准备还是能忍受的，毕竟一个小说改游戏，碰到这种问题也是难免的，cdpr其实已经把平衡性做的挺好了，没必要太苛求。额，如果这也算孝子那就算吧，不狡辩。
回过头去看，巫师二确实是一部难得的rpg佳作，但它未必是一个合格的承上启下之作，巫师二讲了一个太过精彩的故事，导致接下来不怎么好编了，尼国平推北方顺理成章却很无趣，北方反攻又是天方夜谭，导致巫师三的政治形势显得十分强行，迪胖和拉多维德其实都像开了挂一样，要知道，历史是没有个人英雄主义的，区区一个统治者就能逆转尼弗伽德和北方天堑一般的差距吗？这多少有点机械降神了。这么说来巫师二某种意义上近乎把故事讲死了，不过如果我是cdpr估计也会很无奈，小说基本已经写到恩希尔大帝快一统天下的地步了，巫师由于以杰洛特这种政治无关人士作为主角，搞点宫廷刺杀已经是政治戏的极限了，还能怎么编呢？
写到这突然想到，巫师三里曾经对雷索喊打喊杀的杰洛特也成了“国王刺客”，这可真是，人终将活成自己最讨厌的样子。

影子工厂

我本以为影子工厂会如简介说的一样，会是杂糅诸多风格的悬疑风，故事的一开始也的确如此，时间穿越配合豪宅血腥谋杀的经典模式别有一番风味，不过结合前传一贯的发展，不难想象出而在这之后又回到了我们熟悉的时间轴环节，比较特殊的是，这次高瞰老师罕见地采用了正叙的方式，而且此次的故事出奇的平淡，尽管感情上依旧无比细腻，但几乎没有什么出乎意料地发展。
而事实上，高瞰老师擅长的叙事诡计只是换了一种方式呈现在我们面前，这是一个一位身患绝症的女性在生活和事业中苦苦挣扎，在经历了孩子的夭折后，最后选择了事业的故事，尽管这个故事占了整部游戏大半的流程，但其实它本身并不是重点，因为在开头，影子工厂的主线就被堂而皇之地摆在了我们的面前，豪宅层出不穷的死亡案件，于是，在历览了女主的人生后，真相的追寻才真正开始，当然了，故事如何这里就不赘述了。
当然，相比前两作选材的独特，和层出不穷的叙事诡计，影子工厂显得平淡的多，正如lynri所说，昆西相比两位博士不过是一个观察者而已，他对于挚爱的lynri无能为力，面对自己不过是模拟的数据也无能为力，他的一生没有什么狂乱幻想，也没有多么丰富的内心世界，尽管他的内心是强大的，不过依旧没有什么意思。当昆西历览lynri的记忆时，我们会发现相比博士的聒噪，大部分时候他不过沉默地接受着，评价这一环节是在这段记忆中缺少的。而让这段记忆，一个不是最重要的故事占据叙事的大部分是可以的，但问题在于这一部分必须要穿插主线，否则会产生严重的割裂感，而就影子工厂来说，很难说这一部分和主线有着多大的关系，是否手术的分歧导致了之后的一切，但要拼凑出真相，我们需要知道的除了这个世界不是真实的以外，还有分歧点在于保大还是保小，以及lynri的姓氏，而这两点都没有结合进这个过程。抛开叙事结构，如果我们只看这个故事本身，昆西的爱情故事虽然不能说不好，但比起前作的惊艳未免显得俗套。可以说，如果把这个故事大刀阔斧地砍几笔，也不会有多大的差别，当然，就故事的首尾而言依旧是很有趣的。
不过即便如此，我也要说影子工厂是一部水准上的作品，它有着层层递归的脑洞，优秀的人物塑造，最重要的是，它还展示了高瞰老师填坑的一点点意愿，虽然到最后我们也不会知道两位博士之后到底会怎么发展。而对于系列中虽然重要但没有认真探讨过的记忆编辑技术，影子工厂也表明了一种态度，就是尽管这可能看上去虚无的，但就我们个人所及的知识与眼见来看，只有有过美好的时刻，它就是有意义的，这是一种积极向上的态度，尽管这只是一种态度，但对于虚无与否的讨论大部分时候都只能取决于我们的态度。能以合适的形式传达出这样的观点，就是一部很好的作品了。

不予播出

吉姆哈克：当一个国家走在下坡路上，必须有一个给它踩一脚油门。
你生活在一个贫富差距分化严重，外部国家敌意渐升的民主国家，而在此危难关头，一个名为先进党的政党，凭借集体主义的价值观，以及消灭富人扶持穷人的竞选纲领上了台，时代变换的帷幕在你面前缓缓拉开，这时，你能做什么呢？
这大概就是不予播出想呈现的故事，这个游戏是我认为近年zz题材最出彩的一部独立游戏。
我们先从游戏的形式说起
它选取了一个很少见的视角——电视台导播，也就是在电视内容被播放前负责镜头切换与简单后期音效处理的一个职位，这是一个虽然默默无名却十分重要的职位，制作组对此的选择非常高明，在这个位置上你能接收到一切媒体信息，同时决定哪些内容会被最后播出。
游戏的背景设定是魔改版的80年代英国，想想就知道在这个电视台的黄金时代这个职位意味着什么。
在我们这个娱乐至死的年代，恐怕我们的印象中很难会有什么凭良心的办事的媒体人，但在游戏中，随着举足轻重的影响力而来的同样还有巨大的责任，我们可以看到游戏的封面是一个被操控的提线木偶端坐于导播台前，这似乎预示着你不过是政党口中的喉舌，事实上，面对zz大势，大部分时候你确实是无力的，但总有一些事是你可以做的。游戏中，你能做的包括切换各种机位设置，添加后期音效这些普通的工作，你也可以转而接收反对党的信号，甚至在暗中支持他们。
可以说这样的玩法绝对算不上丰富，但是，为了这些内容制作组拍摄了极为大量的采访，节目，等等实景拍摄，这些作品的文案，演出水平都极为突出，也就是说，让你去观看这些节目，决定他们如何被呈现于观众面前，才是它的核心玩法。
于是，我们可以说说它的剧情了。
我为不予播出的剧情概括了一些特点，首先是荒谬性
国家晚间新闻，是一家有不少zz性的电台，在游戏的一开始，作为新上任的导播，我们的第一次工作就见证了前文提到的先进党的上台，在游戏的一开始我们能感受到强烈的荒谬感，就拿先进党举例，该党的带头人是一对夫妇，丈夫粗俗不堪，而妻子却圆滑世故，这样一对其貌不扬的夫妇在自己上任的第一天就大声向“富人”宣战，我们知道，如果对这些拥有大量资产的人过于苛刻就会造成大量资产外流，对此这对夫妇甚至采用强制手法禁止他们出境，这对一个“民主”国家而言恐怕很难想象，更为魔幻的是这样的举措确实赢得了大众为他们叫好，收归民有资产为国有，强制推行福利政策，提倡集体主义，一副宏伟的蓝图就这样在我们面前展开，即使对民粹主义者来说，这样狂野的改革恐怕也有些吓人，而这些种种举措以极快的速度在游戏中发生了，并且让你切实的体会到厉害之处——也就是游戏中各种惊慌失措的小资产阶级。如果你问大资产阶级咋样了，就有限的情报来说，似乎他们在与国家合作后过得很好。
这是一家很有煽动性的政党，但如果你细细去看他们做了什么，建立国家养老机构（把老人送进去就可以不管了）成立青少年队伍（洗脑从娃娃抓起）半强制推行政党性而不是国家性的身份卡（很明显，只是后续动作的开始）甚至把反对的国家的个别城市用特工安置的核弹统统炸上天。
很荒谬，不是吗？但这些事情确实如此发生了。

如果你很好奇对此的政治评论是怎样的，那么我们很快就会见识到该游戏另一个厉害之处——现实性的缺席。
在游戏的一开始国家晚间新闻是一家较为严肃的新闻频道，但随着游戏的进程，娱乐性的报道和节目越来越多（而且不乏先进党资助的无聊作品），这次过程中有着不少精妙的讽刺，例如领着先进党资助大搞政治正确的校园舞台剧组合，光明正大搞热水器的女明星等等，此时在早期的一些政治性节目中，也有不少让人啼笑皆非的人物，例如奉行白人至上主义，热爱sm的警察局局长，似乎几个小丑粉墨登场就能谈起国家大事。作为理应为公众揭露真相的媒体，自己就陷入了娱乐至死的泥潭
不过他们又能怎么办呢？对于一个奉行强权政治的政党，让一个电视台说不了真话简直太容易了。所以我们在游戏中看到的趋势是，节目变得越来越无聊，又臭又长，当批评声变得刺耳，那么连赞扬得不够卖力也成了罪责。
但游戏中依然有着保存着良心的媒体人，杰里米的爆发大概处于游戏中期，他挟持了摄像头，指责所有人都失去了说话的勇气，随后自绝于心爱的镜头前。这段的演出可以说全游戏最大的一个亮点，荒诞的现实与理想的缺席构成了极大的对比，将游戏荒谬而现实的矛盾感体现得极为突出。
然后，我们要说到极端意识形态题材作品的一体两面——压迫与反抗
哪里有压迫，哪里就有反抗，对于极端意识形态题材而言，对其的呈现与对反抗的呈现是一枚硬币的两面，与其他反乌托邦作品伟光正的反抗者不同，不予播出的反对者仅仅是走向了另一个极端。在游戏中有一个明确的反对者——打断组织，这个组织是什么样的呢？很大程度上可能由一些小资产阶级与无产阶级组成，面对集权，他们选择了暴力，游行，破坏，暴动甚至军事政变，我们很难说打断是一个多好的选择，事实上他们根本没有提出什么解决方案，似乎只是因为自己的利益受到了侵犯而已，在游戏的结局我们可以看到打断组织不过是军方扶持的傀儡，用完即扔。
再说回先进党，这一党派在游戏的中期收到全世界的敌视与孤立，不得不进行完全的内循环经济，究其原因，或许是对有产阶级的镇压并不符合经济全球化的要求，从而招致了其他国家的敌视，随后，他们向全世界部分国家的城市引爆核弹，建立起核威慑。 试问，如果你是一位普通人，你能做出什么样的选择呢？
说到这里，就不得不说不予播出另一个有趣的机制——在导播工作的间隙你将以视觉小说的形式看到作为普通人的自己如何在政治的漩涡中生活。与电视上光鲜亮丽的报道不同，即使作为被济的穷人，你也不过是从一贫如洗走向负债累累而已。
恐怕根本没有什么更好的选择。
最后，我们应该回归这部游戏贯穿始终的特点——讽刺性和娱乐性
可以说，这部游戏最终呈现的是一个荒谬的世界，在政治领域极端，疯狂，暴力构成了它的底色，这也是我称其为极端意识形态大乱斗的原因
你要问这样的构建是否过于疯狂而丢失了真实性，而且想要展现这样的世界观一个导播的视角也远远不够，可能的确是这样，但我认为这样极端之间的碰撞反而能增加不少的戏剧性。
可能根本不会有这么极端的政党，可能如此极端的政党根本得不到如此多的武力支持，或许吧，但说到底，这不过是个讽刺性游戏而已，用夸张的手法实属正常。
而在政治以外的社会领域呢？滑稽，疯癫，娱乐才是它的主题，你可以看到收藏大粪为乐的清洁工，无法控制肠道蠕动放出气体的“病患”等等极为魔幻的人物登上荧幕，可以说，游戏中所有的人物都是经过夸张化和娱乐化的，即使抛开政治性，你也可以当笑话看。这是我很欣赏不予播出的一点，它并不完全正经，但绝对有趣。

最后，做一个总结吧，根据关键节点的选择不同，游戏一共有14种结局，有一家独大，有天下大乱，也有非极端派兴起，这些结局有的因你而起，有的不过是大势所趋。不予播出从一个导播的小人物视角出发，呈现了一个极端意识形态偏向的荒谬社会的百态，有戏剧性的加工，也有对真实世界的化用与讽刺。
说实话，政治讽刺题材的乐趣不正是在此吗？

步行模拟器

步行模拟器，在本视频中取操作只局限于步行和一些简单动作，主要获取信息的途径为阅读和观察的游戏，这是一种颇为先锋，也颇为小众的游戏类型，在其中有一些火到出圈的佳作，也有缺点明细的庸作，但都有着共性在其中，今天，我就用一个业余爱好者的身份来浅析一下这类游戏。
我们先从步行模拟器的历史说起，由于我不是专业人士，也不是什么老玩家，所以只能大概地说说。
溯及这类游戏的根源是一件很难且没有必要的事情，所以我们只把目光放在本世纪好了，在2007年，一个传奇的年份，当时的游戏界见证了巫师一，质量效应一，刺客信条一等传奇系列首作的诞生，也有一些人注意到一款名为《亲爱的艾斯特》的奇异游戏，对一个原教旨主义者来说它可能算不上游戏，玩家操控着一位失去妻子的男人在孤岛上步行，整部游戏唯一的信息来源就是沿途的风景，壁画，以及男人的自言自语，某种意义上这带来了一种推理小说式的体验，你需要在文本中领略事件的来龙去脉，同时体验它压抑深沉的环境氛围。
亲爱的艾斯特取得了意想不到的小范围成功，本作为免费游戏的它在12年发布了付费版，并取得了80万的销量，可以说，近十年的步行模拟器很大程度上是由它启蒙的。
因此，以12年为分水岭，逐渐涌现出不少的步行模拟器游戏。
13年亮相的是著名的meta游戏史丹利的寓言和较为平庸的到家（gone home）
14年问世的是解密风的伊森卡特的消失
15年艾斯特的工作室发行了同类型的万众狂欢
16年则有看火人与弗吉尼亚出现
而在17年，此类型的集大成者，艾迪芬奇的记忆横空出世，成为了此类型至今为止的最优者
可能不少对此类游戏毫无兴趣的玩家会好奇，步行模拟器的卖点到底在哪?
在这个媒体资源空前丰富的时代，每个人都能输出自己的思想，因此思想的输出变得极为廉价，而接受者的地位却会被拔高，因此，门槛越高的思想输出方式就有着越大的不被接受的风险，导致晦涩隐喻的内容就会不受待见。尽管如此，这些晦涩的思想与表达依旧是存在的，步行模拟器就是一种方式。
事实上，接受他人的思想表达一直都有很大的风险，只要作者多加一点私货，或者在莫名其妙的地方整个活，接受者的思想就会收到极大的冲击，例子我就不举了，懂得都懂。所以很多人都会倾向于不去接受，晦涩的作品他们根本不会碰，也有的人沉迷于此类快感，不顾风险地追寻自己认为好的输出者，这两种选择没有高下之分，但体现在游戏上，我们就会发现后者经常会成为所谓的小众游戏爱好者，这并不意味着他们很优越，相反，他们可能已经踩过不知道多少雷了。
为此前的论述做一个总结，步行模拟器可以作为一个高门槛的思想输出方法，因此能吸引一些喜欢此类体验的玩家。事实上，它和同样强调探索的avg可能存在一些关系，但由于我对此没有足够的知识，就不献丑了。
在此基础上，我们来分析此类游戏的一些特性。
首先，第一个问题是，为什么要用步行模拟器这种形式，毫无疑问这种游戏的互动性基本不是很强，也没有刺激官能的要素，然而，正是因为这种自断一臂式的操作，让它能够把自己的叙事能力提高到大部分游戏所不能及的程度，玩法单一也就意味着玩家的注意力会完全集中于一点，制作者只要专注于此方面，就能高频度地向玩家提供信息，而不会让人一头雾水，因为这样的特点，相比大部分游戏，步行模拟器可以聚焦于很多与众不同的题材，可以选用不同的叙事方式，
另一个优点是，较小的游戏规模与如今相对成熟的游戏工业，让制作者能以较为低廉的成本做出不同的场景，美术效果和环境在步行模拟器中有很大的作用，我之所以这么说，不仅是因为它有着渲染气氛的作用，在很多此类游戏中，环境本身就承担着叙事的任务，尤其以艾迪芬奇的记忆而言，环境在这款游戏中达到了当代游戏的新高度，不同的房间布置在无言中传达了房间主人的个性，甚至在一些细节中暗示了主人的命运。可以这么说，在很多步行模拟器中，环境有着超越装饰的作用
步行模拟器还有一个特点，那就是它是第一人称的，你可能单纯地觉得这是为了提高代入感，但事实上，因为互动性的匮乏，步行模拟器往往更趋向于探索和体验，而不是扮演，更形象的说法是，在步行模拟器中看到的是别人的故事，因此在我看来，第一人称更多的意义是类似侦探小说的叙述主体，也就是说，以这个故事而言，第一人称对应的角色就是最适合展现故事全貌的人，同时，这个主体具体的身份也可以是一个谜题，伊森卡特的消失，艾迪芬奇的记忆都在这方面上做了文章，非常有趣。
上述特点事实上还是很笼统的，实际上的步行模拟器在风格和题材上都是各具特色，特点也不尽相同，但由于到目前为止出名的步行模拟器实在不多，所以我们就用穷举的方法来说说这些步行模拟器。
先从最早的亲爱的艾斯特说起
在所有步行模拟器中，艾斯特应该是互动性最低的一个，你能做的只有控制一个喃喃自语的男人在孤岛上乱走，然而，艾斯特依然是一部很优秀的游戏，优秀的文本质量和环境建模完美地融合在了一起，配合迷雾重重的故事，与四个风格迥异的场景与种种细节，成功营造出了一种哀伤中透着迷幻的气氛。虽然选取了悼念亡妻的题材，但艾斯特并没有直接表现哀伤，叙事主体的男子呈现的态度是思辨的，其文本很有些深度，艾斯特的氛围塑造与文本水平，我个人认为是步行模拟器中最优秀的之一，并没有被后来者超越，甚至也没有被他们自己超越。
史丹利的寓言
这游戏很难归类，它更为众人所熟悉的标签是meta游戏，举个不恰当的例子，meta游戏和游戏的区别就像文学批评和文学的区别，很难说史丹利的目的是对游戏这一创作形式进行批判还是呈现一段故事。
这游戏几乎是靠作者一个人的天才撑起来的，即便在meta游戏中有史丹利寓言这么强烈批判属性的游戏，据我所知也是不存在的，它很有创设性的给予了游戏四个视角两个阵营，呈现者阵营的游戏系统（游戏作者？）与旁白，接受者阵营的史丹利与玩家本人，史丹利的故事几乎都是两个阵营间不同角色的互动，它实现了大部分游戏都做不到的一点，即让玩家直接与游戏的底层逻辑对话。
现代游戏互动性的本质是什么，无非不过是选择而已，拟真度高的游戏也不过是多提供了一些选项，史丹利抓住了这个底层逻辑，因此哪怕是步行模拟器这一形式只要用好“选择”，就不会缺少互动性。
这样的策略让史丹利显得不是那么“步行模拟器”，但实际上这还是一部叙事游戏，只不过它的故事千变万化，且富有批判意味，而且它的叙事有着“选择”的成分，因此它包含了十几个不同的故事。
归家
归家是一部很有实验意义的作品，如果你情商比较高的话，应该就知道我的意思是这游戏有着不少的缺点，归家的故事发生在20世纪末的一个美国家庭，一个暴风雨之夜，家中的姐姐回到家中，发现妹妹离家出走，于是开始寻找原因，归家的核心机制是拾取/查看物体触发回忆，核心谜题则是揭开妹妹的下落，然而这游戏的故事非常简单，简单到什么程度呢？在触发前三个回忆后你基本上就能猜到故事的梗概了——没错，一个俗套的恋爱被父母反对然后私奔的故事，稍微有些不同的是，主角是两位女同性恋，此外，游戏中有一些不怎么明显的机关且缺乏提示的机关，总体感觉实在是索然无味，尽管某种意义上它为有核心谜题的步行模拟器树了一个榜样，但论其素质十分乏善可陈，最大的优点可能是还算有20世纪风格的家居布置。
值得一提的是ign给了归家9.5的超高分，对ign来说这种分数是很少见的，我们之前提到的艾斯特得到了8分，史丹利寓言得到了8.8分，而品质平平的到家则得到了9.5分的超高评价，并且编辑的评论是没有缺点，联系其故事题材，此件原因令人深思，因为涉及敏感话题，我就不多说了
伊森卡特的消失
这是一部很有风格的作品，在场景建模上制作组创作性的采用了结合实景照片的做法，因此画质显得极为真实，配合微恐怖的风格，代入感极强，游戏的内容是一个有着回溯犯罪现场能力的侦探应伊斯卡特的邀请调查一个据说有着不可名状怪物的地区的系列凶杀案，抛开几乎为0的地图指引，游玩过程中你会觉得这似乎就是一个普通的解谜游戏，虽有称道之处，但综合来看质量一般，然而，这款游戏最值得称道的一点是，制作组为了一个有极大反转的结局在流程中埋了不少伏笔，因此伊森卡特的结局在我看来在叙事游戏中算最优秀的一档，当然实际上这也是见仁见智的一件事，或许也有不少人觉得铺垫不足。
在步行模拟器中悬疑风格的作品伊斯卡特应该可以说是最成功的。
万众狂欢
这是一部和亲爱的艾斯特风格迥异的作品，它没有叙事主体，玩家以超然的眼光去回顾一座村庄全员蒸发的惨剧，我认为这是一部失败的作品，为什么呢。作为一个拼凑出故事全貌的游戏，万众狂欢很不幸的选择了把最大的悬念放在开头——凶手是形似光球的不可名状生物，而游戏的过程则是目睹居民怎么一步步迈向死亡，整个过程中的互动，只有不如不做的触发回忆过程有——跟着手柄按QTE。具体到故事，恕我直言是很无聊的，寥寥几语的场景中大部分缺少让人身临其境的氛围营造，整部游戏有着浓郁的宗教风格，因此部分场景会有种神圣感，但也就仅此而已了，没有悬念，没有细腻的情感，没有复杂精彩的故事，更没有氛围的营造，万众狂欢在我看来是一部平庸的游戏
看火人
在众多步行模拟器中，看火人是极其冷门的纯写实题材，它选取了森林看护员这一冷门的职业视角来叙述故事，然而它的美术风格却是抽象的大色块风格，这造就了看火人实中有虚的奇妙质感，不论看火人的故事如何，这样的题材与美术创新是优秀的且值得鼓励的。
主角亨利在爱妻患病后心灰意冷，因为酗酒被妻子家人排挤的他最后来到了荒无人烟的森林公园成为了火情瞭望员，我们可以看到，游戏的主题几乎已经确定为心灵的救赎，但看火人的呈现方式是特别的，因为职业的特殊性，从始至终能与亨利交流的只有一位名为黛利拉的女性，在一片孤独的瞭望塔中这似乎是亨利唯一的情感支柱，事实上，看火人最大的优点就是情感的细腻，整个游戏几乎就是亨利与黛利拉互相的情感激励与救赎，最后这场类似柏拉图之恋的关系随着因为火情观察员撤离而收尾。
值得一提的是，看火人神奇的在游戏中夹杂了不少悬疑的成分，这让看火人的基调显得有些奇怪，由一开始的悠闲巡逻转到紧张的解密，随后又在急转直下后收尾，尽管不算无聊，但前后依旧有割裂感。
尽管如此，凭借细腻的情感描写，看火人依旧是一部优秀的游戏。
弗吉尼亚
这是一款很奇特的游戏，即使在步行模拟器里，它也是交互性最差的一类，它使用了一种极为抽象的风格，整个游戏由很多不明所以，充斥着象征的片段组成，而将这些片段串联到一起不过是一些点触的操作，坦白的说，我只能分离地去欣赏这些场景，单从象征的角度来说这些场景单独拿出来还挺有意思的，但你很难把这些片段连起来，事实上不让你把他们连起来可能正是这游戏的目的，此外，该游戏使用了很罕见的古典风格配乐，配合上本就很魔幻的内容产生了一种难以言喻的奇特的氛围。总的来说，这真的是一个很难评价的游戏，如果你有些猎奇心的话倒可以尝试一下
艾迪芬奇的记忆
艾迪芬奇的记忆是一款很优秀的游戏，但它的意义不仅如此，可以说在对互动性的新尝试方面，艾迪芬奇是游戏界最前沿的一个，游戏在叙事上最大的优势就是互动性，大部分游戏选择了剧情分支，qte之类的通解，而艾迪芬奇的记忆则在此基础上作出了创新，单论最简单的字幕，往往只被放置在屏幕底部用于阐释信息，而艾迪芬奇则将它放置在了场景之中，伴随着主角的前进逐渐浮现在路边，如此一来字幕甚至兼任了指引的作用。
依我看来，艾迪芬奇的主基调可以用魔幻二字来概括。随着艾迪依次探索旧宅，我们进入了一个个家族成员死前的景象中，但我们透过屏幕看到的不仅仅是一个个纪录片式的景象，还有情绪的具象化，例如令人啧啧称奇的操纵漫画中的角色一段，操纵角色在悬疑漫画的分镜中行走，这是一种崭新且绝妙的传递恐惧感的方式，艾迪芬奇的互动形式总是新颖的，角色伴随着开罐头喃喃自语，在切鱼的流水线上展开与工作融为一体的幻想，手柄的两遥感分别控制现实与幻想世界，此类新颖的设想，艾迪芬奇有近十种，可以这是一款极为奢侈的堆砌创意的游戏。
艾迪芬奇的家族大都耽于幻想，他们的幻想往往与现实融为一体，以此呈现出的情景显得分外的魔幻，以游戏的形式来叙述这样的故事，这一模式提供了一种特别的审视真实世界与内心世界的视角，这样类似魔幻现实主义的创作手法可以说极为前卫和有趣。
毫无疑问艾迪芬奇的互动性与创意是它最耀眼的闪光点，在此的映衬下，艾迪芬奇的剧情似乎显得暧昧不清，多个家庭成员的死亡都没有得到明确交代，尽管在一个个情景中我们能在画面中感知到情绪的具象化，尽管艾迪芬奇家族一向有着早死的诅咒，但艾迪芬奇没有，至少没有直接透露任何家庭成员对于死亡的看法，在一部探讨死亡的作品中这点显得很奇怪，似乎它只想将死亡本身呈现出来，却不想对此发表任何议论，我们很难说艾迪芬奇有什么主旨，在死亡这个主题上，制作组显得分外的冷漠，只留下玩家在原地回味。Steam上艾迪芬奇的商店页面有这样一句差评，艾迪芬奇的记忆有着美化死亡的嫌疑，这对那些有自杀倾向的人来说似乎太不友好了。这并不是没有道理。
总结
步行模拟器始终是个小众的品类，它固然有着一些创作上的优点，但成本和受众的因素始终制约着这一类型，导致作品寥寥无几，但在步行模拟器其实不乏对游戏这一创作形式的革新，作为新时代的叙事向avg游戏与独立游戏的一大阵营，步行模拟器的身上其实或多或少蕴含着电子游戏未来的一大方向，即作为有才能的作者表达自己的一种方式，对此我报以极大的期待。

杀手47

2022年一月份，杀手3将解除一周年的独占，登录steam，而早在21年初，杀手3就成了一款有点话题性的游戏，这是因为游戏的一张重庆的地图，这一地图因为缝合了赛博朋克，老大哥等元素被指责有乳制品嫌疑。
在仔细讨论这件事前，让我们先来看看这是一个什么样的游戏。平心而论，作为一个系列续作，杀手3可以说还算合格，虽然刺杀方式上有缩水，但看得出制作组在氛围营造上投入了不少努力，有很多截一帧就是壁纸的远景或者特写。杀手系列可以说是一个好游戏，甚至可以说是刺杀游戏这一细分品类的霸主，但ioi是纯纯的懒狗，犯下了版本混乱，高价低质量dlc，违背承诺种种重大错误，ioi并不是一个好开发商，如果你骂ioi，我举双手赞成，但对杀手三3有没有乳，我认为还是要谨慎讨论。
我所好奇的是，杀手是不是一个拟真的游戏？
我想只要你玩过这个游戏，你就会知道答案是否定的，即便是游戏的核心——刺杀系统，也有很多方案并不具有现实可行性。，如果说起其他设定，就更没有真实性了，杀手三部曲的反派是一个势力遍及全球，由“社会精英”组成的阴谋论组织，我并不认为这样的组织有什么现实可行性，如果我们这种普通人都能知道这样的组织，那只有两个可能，1这样的组织情报保密工作很烂，那它早该被拿下来了2它故意泄露的，实际上我们对它一无所知，那就让我们一切的想法都成了臆测，阴谋论是一些无法质疑的假设，这样的假设我可以提出几百个。
当然，我们没必要对一个游戏上纲上线，即便涉及到阴谋论，也只能说杀手并不是一个拟真的游戏。那么，作为一个涉及到多个国家刺杀目标的游戏，杀手对其中的国家是怎么描写的呢？
摩洛哥在杀手里被描绘成政府软弱无能被军阀控制，甚至准备发动政变，我们且不论这是不是真的，无论如何这都不是什么很友好的描写，我们提到过的阴谋论组织的一位高层在法国有一个大葡萄酒厂，很符合我们对法国的刻板印象吧，然而这位律师有私人武装，甚至包括一队直接听命的狙击手，我想法国不会放任私人权利到这个地步。孟买的街头扛着步枪的武装士兵到处走，北欧的高端别墅区一栋不算特别大的别墅有十几个全副武装的保镖，这些对我一个中国人来说都觉得不合理，可见杀手这个系列根本没有多少写实性。
我们可以做一个总结了，无论从什么角度看杀手都不是一个贴近现实的游戏，特别是在zz方面，尤其口无遮拦，什么都编的得出来。
那让我们再看看重庆这张图，这张图有什么呢，赛博朋克+老大哥，大量的监控摄像头，华人街一样的街道和餐馆，秘密暗杀组织的不人道实验，改造人类街头的流浪汉，我们之前也说了，杀手的地图里编的成分很大，更何况设定上ICA最重要的实验室就在这里，与其说ioi想还原什么地方，倒不如说估计是他们看到一些关于重庆很赛博朋克的新闻，然后觉得可以蹭一下人设。试问这些元素有多少是真正不合适的呢，脑子正常的人都不会觉得现在有技术能操控人的思想或者改造人类吧，既然你不会觉得这些情节是真的，你为什么会觉得这座城市是真的这样呢？
当然，事实上这样的论述也是有模糊性的，你可以说不够还原就是不够尊重，也可以说法国，美国的图比中国的还原是歧视，在国际矛盾激化的今天，会在这样的事上比较敏感可以理解，但我想说，我希望并呼吁大家在至少在文娱领域多一些宽容，不要泛政治化，能疑罪从无就不要恶意去揣测。
47的目标有很多罪不至死，为了一己私欲杀死无罪者，这难道不是宣传不良价值观吗？但恐怕没人这么批评，为什么我们会在道德上对文娱作品这么宽容，在政治上却那么草木皆兵呢？
我很希望大家能多一些宽容，我也希望文娱作品无论何时都应该是一片不被zz过分染指的净土

408被封锁的涩谷

希腊神话将命运女神履行职能的过程写作织网，这无疑是一种极为贴切的比喻，对网状结构来说，在中心处的轻轻一拨，边缘处就是极大的震动，越是深入核心，就越是复杂，但所有分支无论看上去多么没有规律，最后都会收束到中心网点，我想这就是428的编剧想实现的叙事结构。 这样的结构需要极致的严谨和巨大的工作量，正如正统的本格派推理一样丝丝入扣，同时还要维持各个部分的信息量尽量均布，各个网点处都有关键悬念留待读者，但，他们做到了，7位主角的命运与城市里大大小小配角的命运，就这样纠缠在一起，并收束到了一个巨大的阴谋上，更令人称奇的是，尽管使用了这样的结构，制作组仍然做到了悬念的均布，几乎没有出现信息量失衡的情况。
于是，玩家得以在4月28日的涩谷当一天的命运女神，只要在一个个节点上轻轻拨正些许紊乱的蛛丝，蛛丝就会自然而然地化为网状，事实上没有我说的这么轻松，因为这些命运的线条起初似乎是绕成一团，理清它们的过程也少不了误解和错误。
为了确保这个过程的顺畅，85个bad end大部分都有提示，以每一小时为节点，只有理清一小时内的所有事件，命运才能向前推进，起初似乎是一些不成规律的线，但逐渐就开始交错，纠缠，而作为有着神力的玩家，只需要制造一些偶然，改变一两个小小的决定就能够造成一连串的蝴蝶效应。
对这种操控命运的讨论很容易回到一些宿命论的思潮上来，幸运的是428的编剧在这个方面却有着很积极的态度，于是在结局，命运的线条汇聚在一起，无数偶然交错下，产生的必然却孕育着希望，尽管多少有些日式的大团圆味道，但流露出的价值观确实积极的。
如果说这样精巧的叙事结构有没有问题，那么当然也是有的，叙事必须依靠逻辑的支撑，如此庞大的网状结构，逻辑当然不可能天衣无缝，事实上依然有很多巧合和偶然，为了配合结构的需要，甚至部分主角也免不了当工具人，但你很难对此苛责什么，通过有限的角色实现如此复杂的剧本，不免要让一些角色承担过多的推进剧情的作用，相对来说编剧已经做得很不错了。
此外的问题是大部分日式游戏难免的幼稚气，叙事结构是精巧且充满悬念的，但一些抒情节点，以及一些过度夸张以至于模板化的人物性格，依然为其减色不少。不过我也能理解编剧，毕竟这种精密的结构确实很难填补完全恰如其分的内容
总的来说428在叙事结构方面可以说是当今电子游戏的最高峰水平，尽管它的其他部分可能只是优秀或者不错的程度，依旧是一款剧情类的神作

the longest journey

​无尽的旅途是一部好游戏，限于时代演出不是那么优秀，但在我看来这是一个堪比dao的开始，嗯，或许稍微差一点，但梦陨就比较令人无语，这游戏似乎试图用超过十小时的游戏时间做一个预告片，你可能觉得这时长对avg来说不算少，但如果我告诉你这游戏大胆地用了三个主角，并且交织得并不紧密呢？
顺便一提，这三个主角，其中一个是大杀四方的前作主角，但这作一直在低迷期，最后没顿悟出什么来还疑似4了，其中一个是半路插进来的肌肉兄贵，戏份比较迷的同时，最后的高光戏决定背叛自己的邪恶阵营，结果当场被关进大牢了，最后一个是戏份最多的本作主角，最后成为植物人，她的主线任务寻找前男友和阻止大boss一个也没完成，前作结尾的坑一点没填，又挖出了两三个新坑，甚至开头到结果贯彻始终，类似于where is alice 这样的主线问题都没回答
如果这还不能让你深恶痛绝的话，最后还有一个事实，续作在10年后，而且结尾不算高明(据说)
总之，我很怀疑avg能不能用好类似rpg的宏大世界观与对应的多线叙事，因为avg的核心是冒险，或者说类似的线性叙事结构的故事，你一般不会想在冒险的时候读上几十万字的设定文档，顺便卷进一个无数分叉的复杂故事线，就算有天才编剧能兼顾冒险感与宏大复杂的世界观，开发经费也未必能支持这个想法，最后，很可能的结果是，做一个大型预告片出来

冥界狂想曲

在某种程度上，冥界狂想曲一直作为avg的代表与异域镇魂曲齐名，当然说实话古早的操作和谜题对我来说着实难适应，所以我只是云了一下，但也幸好，古早的avg大部分是单线叙事，因此不是自己玩在剧情上也没什么区别。
总之，游戏的开场对我来说就很有意思，这指的是贯彻始终的颇有异域风味的冥界，我听说这是墨西哥的神话？先不管这个，虽然主题是死亡，但冥界狂想曲一直保持了一直诙谐的幻想风格，就连这些死者的再一次死亡也是用了开花这种充满生命力的方式表现，这给了整个游戏一种独特的风味或者说氛围，更不用说风趣且很有领导魅力的曼尼，与他同样有趣的哥们了。 一点小小的遗憾是，我想相对于主角二人组的丰满，反派npc的塑造就比较呆板，还有女主也没什么存在感，不知道怎么就开始感情线了。但其实其他npc倒也很风趣，所以总得来说，在角色塑造上是可以说优秀的。
此外，剧情不是那么严肃，但结构工整，伏笔与回收上也很巧妙，虽然涉及了一些政治戏码，但表现得方式是揶揄讽刺而不是说教，这很好，可以看出编剧无意在此深入，而是停留在一种人文主义上的关于善良与勇气的故事，这丝毫无损冥界狂想曲的格调，一个让人沉迷其中的好故事，作为玩家不应该要求其他的东西。
总得来说，我认为冥界狂想曲确实可以和异域镇魂曲同台竞技，它就像一部醇香的老电影，没有rpg式的沉浸扮演与纠结的选择，但作为一个故事就很精彩，游戏的形式也不是完全多余的，额，至少对喜欢解谜的人来说不算，其实，我倒认为gameplay上的乐趣主要是这个有趣的世界观。
rpg的乐趣来自于选择和扮演，以一个角色的立场自己去选择，然后承担后果，这很好，但avg则有所不同，avg的重心是体验，这个故事一直在那里，只是你能以某种方式见证它的开始的结束，这种微妙的差别恐怕在当代已经接近消失了，但在avg的黄金时代，这种不同还是很明显的，你可能会觉得这就是个故事绘本，毕竟去参加还是不参加，故事都会以一样的方式开始与结束，但一个好的故事总是会有为之入迷的听众，正如冥界狂想曲的结局曼尼所言
Nobody knows what's gonna happen at the end of the line, so you might as well enjoy the trip.

hello hello world

我很喜欢hello hello world对循环的处理，打比方的话就像是莫比乌斯环，通过正面来到了背面，又通过背面来到了正面，有点像年代记的true end，用真实创造了虚假，又用虚假谱写真实，这样的感觉

海沙风云

​rpg游戏的主角是什么人呢，是可以死无数次的人，又或者是可以做出无数次选择的人，我们都知道现实生活中你报了土木然后录取了，是不可能后悔，改去报汉皇法帝的，但游戏就不算事，回个档就行了，当然也有不让存档的，但归根到底，只要是跑在冯诺依曼架构计算机上的游戏，就要存储数据才能执行程序，要么在硬盘要么在内存，而有存储就能sl大法，众所周知，不受此限制的什么量子计算机，生物计算机就是造出来了，现在也没开发商能在这些架构上做游戏
这样我们就能得到一个有趣的结论，主角不是人，也不是角色，他是若干有不同命运角色的集合，这取决于游戏给了多少选项，要是一个游戏每个角色都可以被操作，那么主角就是游戏角色的全集
如此立论，主角必然是一定程度上模糊的，不透明的，但有意思的是，虽然我这么说，但玩家选项构成的主角又必然是主角的子集，但对玩家来说这就是主角，这样有意思的地方就出现了，这个子集可以只有一个元素，也就是说主角对玩家可以是单个角色
说来说去好像这只是选择不同，但我发这些议论的原因在于，这种选择也可以是一种叙事，意思是，有的开发商会耍小聪明，他说所有世界线的主角都是一个人，他在不同时间线跳来跳去，最后回归到一个true end，就像用一个递归函数去解决问题，解决中用到了复数个函数，但这些函数都是一个函数，因此其实只用了一个函数，这样一来主角又是复数的又是单数了，让游戏分类学的爱好者们头疼不已(当然这个学说是我瞎编的)

​我和制作组一样对国产极乐迪斯科的说法不太认同，至少目前不太认同，首先很明显迪斯科的完成度高的多，而海沙虽然还不能盖棺定论，但某些不可言说的原因就觉得了制作组不可能在内核上有和迪斯科重合的地方，如果有人不同意以上观点，请比较一下两款游戏的开场画面文本不同之处
港式警匪片也没什么不好的，我的建议是商业作品大家乐呵乐呵得了，要是哪个东欧哥一看chinese disco?玩了发现别说xx,xx尺度都没到，这多尴尬

海猫与推理avg

在我看来巧舟是个有着很明显才气的作者，但是这种才气并不能支撑他到完美的地步，这就是说逆转里bug和牵强的地方不少，但1-4部总得来说打完还是会觉得不错，大逆转里这种特点就更明显了，主角团和很多角色都很有意思，但前期的法庭部分依旧无聊，此外，就悬疑作品来说，巧舟在平衡谜题和人物塑造上做得很好，这也是逆转系列目前有不小同人热度的原因
打越我只玩过极限脱出和梦境档案那两部，在我看来就像一个以奇取胜的作者，并且在这点上非常偏执，揭晓谜底的时候确实很震撼，但倒过去看人物行为怎么看怎么不对，巧舟笔下的人物大部分是有可以理解目的的，现实人物也可能做一样的事，打越笔下的人物，配合那些神神叨叨的设定，就非常的，难以理解，甚至有前作主角在续作打酱油的神秘操作
小高我懒得评价，我只能说他的诡计等设置只有在浓度比较高的二次元才成立，客观来说谜题还行，但玩小游戏推理太逆天了
然后就是最近接触的龙骑士07，这位很难说写的是不是推理剧，毕竟以上三位不会让你在主角视角看到幻觉，最多掩盖一些主角能看到的事情，但寒蝉和海猫确实是可以推理的，就像海猫明说的一样，你要迎合出题者的规则和提示去推理，并且重点也不完全是推理，否则真相都知道了，打败真凶大部分作品都是结局几笔的事，不会像07一样化身爱的战士来个全员大决战，我觉得07的意图是这样的，大部分我这样的观众对how和who都非常关注，因此用这部分把我引进来，然后对我灌输why才是最重要的这个大道理，总的来说我对此持保留态度，我承认海猫的世界观下why比较重要，但现实世界还得who和how，这种太明显的说教，我不是很喜欢，但考虑到综合质量，海猫还是可以评个佳作起步的
这个世界有王道，就会有邪道，随后会有看似邪道的王道和看似王道的邪道，总的来说，王道的意思是，在地狱中奋战寻求生路这样一路向上的故事，为什么可以看似邪道，就是说这个地狱可以奇形怪状，像克苏鲁神话之类的故弄玄虚，但最后依旧是一路奋战到达某个终点，或者壮烈成仁
​邪道就是非王道，比较典型的就是原来都是一场梦式的结局，海猫无疑可以说是看似王道的邪道，因为大部分笔墨大书特书推理剧，诺克斯十戒，伪装成王道的寻求真相的推理故事，随后急转直下，原来是人格分裂+身份诡计，意思是百分之80的玩家视角都是虚假，这个角度讲，无疑是失败的推理剧

​但作为推理的推理倒是很有趣，也就是推理这个故事到底值不值得推理，是不是能推理，什么是推理，视读者评价的是推理部分还是推理的推理部分，评价就会两极分化，这无疑也是作者那么喜欢猫箱理论的缘由

天问

PST是一种少见的天问式游戏，从头到尾都在复读那句“什么可以改变人的本质?”，理所当然的这个问题没有答案，根据游戏流程来看，答案可能是痛苦，悔恨，爱，没有答案……这些选项中的一个，但其实重要的是回答问题的人，而不是答案
这可以说就是废话和故弄玄虚，也是我觉得pst不能说是什么哲理游戏的原因，并且很明显，这种天问如果没有令人满意的解答，整个剧本就完蛋了，因此很少有游戏敢用天问
当然也还是有的，bs2的“爱丽丝在哪?”多少有点天问的意思，但不完全是，爱丽丝是个存在，这是具体的，因此这多少是个具体的问题
生化奇兵无限的抛硬币也让我有这种感觉，正面，还是反面?这个问题很抽象，但非常模糊，让人对怎么回答毫无头绪，更像是对平行世界的引子,此外，我没记错的话，这个问题也没有问到海葬
最后一个候选者是巫师三的石之心，石之心没有问题，但我觉得结合浮士德原著，可以概括出一个问题:“灵魂可以出卖吗？”这个问题由杰洛特卖了自己开始，由镜子大师收取代价而结束，问欧吉尔德，问爱丽丝，也问杰洛特和玩家，卖出灵魂是一场豪赌，这种快感让一切都变得无趣，即使面对不公的命运，这种堕落也是值得的吗？最后的选择权交给了玩家，这就是一场标准的天问
2077的无名小卒和名扬天下似乎也首尾呼应，但到了dlc才给了无名小卒选项，未免拉得太长，所以也不行

十三机兵

​十三机兵的trick，虽然好像也不怎么想藏，和零时困境倒颇有相似之处，不过剧情的复杂度和合理性上水平很高，虽然我对青春校园题材实在没什么兴趣，但十三个人物交织的处理着实是多线叙事和网状叙事的教科书
其实最后搞点大逆转也不错，虽然有13个视角确实很难藏点东西到最后，总得来说这部作品的故事线像在炫技，但揭露真相却无比老实，因此离r11e17这种所谓神作差了点野心，所以说悬疑题材的爱好者是一种很神奇的生物，越是骗他们感情的作品就捧得越高，像r11的结局就像给玩家闷头一棍——你以为结束了，其实才开始，你以为你在玩游戏，其实游戏在玩你；从开始到结束的所有努力都是无用的，不过是个陷阱罢了，所谓的神作气质莫过于此
说回13机兵，其实这部作品和428也很有相似之处，都是一团乱麻逐渐理出来主线，只不过这游戏有13条主线，这是夸张的说法，其实基本每对cp有一样的目的，所以可能就六七条主线，这种结构有一个技巧，逐渐理出头绪时是最有意思的，一股绳了就无聊了，因此需要一个简短有力的结局，以及逐渐加速的节奏；但是十三机兵这个战棋玩法着实拖时间，还有日系游戏经典的数值深坑，这是十三机兵离神作最远的地方

古诺西亚

先说结论：部分人设比较有意思，结局挺让人感动的，但过程太折磨了，总得来说建议玩个开头熟悉一下流程，然后云到结局
以下是对缺点的详细阐述：

  1. 玩法创新是有的，但整个系统和ai支撑不起合格的狼人杀体验，人物条目的解释条件过于苛刻，可以说完全就是拖时间，看了一些评测和流程视频都在100loop以上才能进真结局，其实纯剧情流程也就最多50个loop上下
  2. 剧情有些水平，但基于1，节奏可以说一塌糊涂，和同类，例如人狼村比，完全没有紧张刺激感，，而且文本量，估算的话最多已经人狼村的一半，个人体验上最多和人狼村打平
  3. 第二点是说的主线流程，但本作有15个人物，大部分和主线无关，而且文本量太小，例如一个角色条目和其教育经历有关，那么这个教育体系有什么特点，和这个人物现在的性格有什么关系，都没有拓展，此外，真结局其实只涉及个位人物，却需要解锁所有角色条目，这个条件虽然和某个设定有关，但还是很强行

总的来说，这个游戏剧本质量是有的，但体量和完整度上过于匮乏，在我看来80%左右的好评率是更合理的

be

有一种典型的be或者ne是：奋战后什么也没有改变
这个类型也有细分，比如最后虽然功败垂成，但主角得到了救赎，这种属于be中的he,还有最后不过是回到了原点，这种是ne，还有奋战后结果更差的，这种属于搞人心态的be中的be
第一种其实还挺多的，例如jojo6，当然新世界大概也算改变……
第二种的例子是jojo7，最后乔尼不过是回到了原点，或者极乐迪斯科，到头来除了金的友谊，不过也是回到糟糕的原点；以及东方年代记的te，从幻想乡的毁灭回到幻想乡的诞生，而且这两者其实是一回事
第三种例子就很难找，个人观点me3的绿光结局应该算，全银河系变成融合怪，还不如毁灭了；又或者东方年代记的ce，苟延残喘还不如来个痛苦；蝴蝶效应应该也算，或者说蝴蝶效应的结局很难这么分

辐射:新维加斯

新维加斯的网状叙事和蝴蝶效应，确实是rpg史上的奇迹，不过这样让我非常患得患失，也就是典型的过高的自由会让人无所适从，这也是为什么近年的rpg不会这么强调网状了，能树状就不错了
话说结局是字面意义上的ppt也是挺难绷的，还不能跳过人生，这也是个微妙的点，要是后果太强，就会影响整个所谓的开放世界，要是没有后果，那选择就没有意义，因此只能用ppt这种微妙的展示方法显示选择的影响，信使的选择到底有影响吗，如有
当我们讨论rp时，我们在讨论什么？
在大部分rpg游戏里，把口才点满，可以与大部分没完全疯的boss交涉，嘴炮避免战斗，把逻辑或者感知点满，就可以观察到绝大部分角色的明显谎言或者自相矛盾，我们称之为rp，因为我们选择了把角色培养成演讲家，侦探……我们必然得到这样的后果
但是，过程在哪里呢？福尔摩斯是怎么推理出矛盾的，口才大师是怎么挑选言辞的，这些很难展现，就算展现了也没什么人会买，这么一来文本量能翻一倍
同理，我们在black souls把能看到的npc全图了，这是结果，为什么图，用什么方式图，则无法控制
这是一个本质性的矛盾，玩家不等于角色，你捏一个大侦探出来，现实里没几个推理小说能猜到凶手，所以我们要rp一个在rp的玩家，这才是rp的本质 辐射可能是近年唯一一个集齐两个“大厂”的ip，你可能想说博德之门，但博得12早没几个人知道了，当代生软和老生软也完全不是一回事，并且博得12没那么多变性人和男女同性恋，和现在的生软死忠粉不重合
这就导致一个很幽默的现象，你不能用辐射粉这个标签定义这个ip的受众，因为可分为三个阵营，遗老，黑曜石正统派和杯赛正统派，如果你问可不可以都喜欢，很遗憾，由于大家最爱的Mr陶德把fnv的设定一口吃了，阵营选择上前两派和杯赛派完全是水深火热之势
更有意思的是什么呢，这两个b字头厂现在都在微软旗下，也就是说他们应该，大概，是一家人，结果演了一出典中典的兄弟内斗,应了那句经典的
wars, wars never change
我的猜测是这样的，微软虽然财大气粗，但在游戏界只是小打小闹，经费就那么多，陶德要去追他的nasa朋克梦，就得要微软大爹出米，大家都是旗下工作室，零和博弈，那不给黑曜石这边踩一脚，毕竟不说商业上不错的辐射4，76居然实现了玩家一边骂一边抢着掏钱的神秘现象，陶德的口才点了多少想必不用多说，拿捏个办公室政治简直手到擒来，遗老随便骂吧，骂完辐射76别忘了氪金，星空dlc别忘了买

巴别号

我不知道该不该这么说，优秀到初步印象不会觉得是国产的独游，因为在我印象里国游很少有天马行空的幻想世界观，要么是武侠修仙这种成熟题材，要么有什么现实原型，或者新瓶装旧酒，巴别号初步印象对我来说就像日本近年很火的新本格在游戏上的体现；话说上一个让我怀疑是不是国产的还是帕斯卡契约，不过类魂毕竟也是个成熟类型，而巴别号几乎没有先行者，玩法是经典avg，有点微创新，而设定上我是想不到类似的前辈，这种独游基本是奔着大亏去的，国内毕竟发展中国家，这种纯为了理想的独游很难不支持

陶德

​老滚5的某个纪念版叫特别版，为什么不叫一些更具体的名字呢，我猜是陶德这小子也拉不下脸了，因为你会发现这个版本只有一种特别——bug特别多
大概一两个重要支线卡进度无法触发，你可能会说还有万能的控制台，然而我在贴吧搜到了同款bug，然后学着试了试控制台调进度或者重置，还是没用，npc像4了一样一动不动，很难想象一个纪念版会有这种情况
近年bug出名的游戏有什么呢，无疑是首发2077，但2077我还真没遇到重要支线无法触发的bug，大部分bug体现在显示层面，要是分开客观打分，我会说2077初版完成度更高，至少我能体验完所有主支线，而这，就是我们世纪神厂杯赛的含金量，我不是说游戏不行，但态度太差了，甚至至今steam的天际特别版都没有官中和创意工坊，人家恩达瑞尔还要单开个游戏页面

命运石之门

“欺骗世界”确实是e17首创，而且在我看来揭晓答案的一瞬间比石头门还惊艳，但缺点是白开水一样的节奏以及人设，石头门我看评论都说什么前期节奏慢，但对经历e17洗礼的我来说前期简直跌宕起伏
但不说这些了，毕竟做e17的时候经费和年代限制比较大，单论诡计的话，毫无疑问的e17更加复杂精巧，登场角色几乎人人一个trick，但在时间线的复杂度上石头门无意抓住了“欺骗世界”这个点进行了拓展，e17里“欺骗世界”是灵机一动想出来的，一个出彩的收尾，但在石头门里是贯穿全剧本的主线，有无数的铺垫，无数次苦苦求索，跨越了无数次的牺牲和努力，情感力度上远超e17这个前辈
这算一种微妙的差别，打完e17会有一种惊艳感，石头门没有那么多惊艳感，我以前都吐槽打越式伪科学，这波科学adv着实更胜一筹，如果是e17里是新本格式的设定式推理，石头门就是探讨规则或者说设定的纯实验，因为不知道完全的规则，推理无从谈起，取而代之的是一种感动，这种感动一是历经劫波终于he的感动，二是做了那么多次实验，终于理清了世界线理论是个什么东西
不过我不是搞科研的，至少还没开始搞，所以应该胸针寻找跳线的方法应该类比我debu更感同身受，这点来说确实是"科学adv”，科研里痛苦和快乐的比例大概正如凶真经历的be世界线和he世界线比例

梦

如何反驳“这一切都是xx角色的一场梦”之类的说法
其实很无聊，因为延续下去可以说“这个世界也是我的一场梦，其他所有人都是我幻想出来的”，然后双方都无法证否对方的说法，陷入死循环，计算机学科里叫循环等待

一切都是梦，这是个假说，不具备可证伪性，也就是恶魔的证明，这样的命题我可以提一千个，但是没有意义，不可证伪的命题不是科学，非科学的讨论只是浪费时间，因为讨论就是为了说服对方，而且是用逻辑上的证明，无法证明就无法讨论

文字游戏

我玩文字游戏基本都在快进，比较典型的是石头门，不啰嗦，但大部分是平铺直叙，很好猜人物行为，加上lab全是老面孔，看到发生什么事就能猜到人物行为了
比较啰嗦的是寒蝉和海猫，出题篇还好，只有一些日常要量子速读，解题就麻烦了，07的核心诡计就一两个，差不多猜到之后就只能快进了，寒蝉后期初中生大战雇佣兵，海猫则是大段感情戏，和文字描写的魔法大战……有点汗颜了。还有十三机兵，节奏其实挺快，但我实在不想看高中生谈恋爱……
处理的比较好的是打越巧舟，巧舟不说了，除了搜查部分节奏都飞快，打越好在谜题层出不穷，除了e17也没有日常，坏处是玩起来很累，但基本不用快进，解题部分还得想半天，但最近的ai系列又开始卖人设了，特别是涅槃那部，实在太old school，梦回上世纪的gal人设，可以说从头快进到尾。人狼村也不错，男主油滑又聪明，基本每步都是最优解。
最教科书的是428，基本每一个小时都有反转或者小高潮，堪称节奏控制之王，感情戏也不长，几乎没用跳过，但文字显示速度感人，ce开了三倍速

梦灯花

优缺点很明显的作品
优点:美术质量高，世界观有新意且较为完整，没有日式二次元不死人的团团圆圆风气，基调偏严肃，故事总体是完整的，现在史低+捆绑包50块还送设定集，畅玩15-20小时左右，性价比可以

缺点:战斗系统充其量4399水平，战力也很奇妙，此夜说是普通光使出身，好像天赋也不如绚夜，怎么回到现实后还是第一梯队战力，没人奇怪吗，至少可以提一嘴祝福之花吧
角色太多，塑造不够虽然立绘好看，但明显戏份不够分，有最后支线草草了事的，又用来关键时刻死掉渲染气氛的工具人，最后下来我没几个印象深刻的角色，而且主角组个人感觉也塑造一般，对比前作科罗莎行动力超强，每条线都在c，主角组大部分时间用在光使内斗和找各种人帮忙上，战力和前辈基本是平手或者略胜，贤者是不如的，智谋上也没多大体现，总不能烧点粮草就智将了吧，那你们为什么能当主角呢？当然如果你打完了，就会发现最难忍的是绽夜的塑造，主塔官僚主义固然不对，但绽夜自己也毫无建树，还和同门姐妹内斗，暗兽潮来了还满脑子内斗，完全就是匹夫之勇
部分发展强行，篇幅分配不当比如黑辉夜，封面c位，怎么也该和白辉夜差不多戏份吧，结果现实篇失踪了，无夜立绘这么精美，结果就一两句台词，古光使是什么社会形态，为什么社会矛盾不可调和了呢？现实篇里白辉夜的心路历程是怎样的，四个古代贤者的过去都是咋样的，塑造都很少，根本原因是这个任务机制过于割裂了，把剧情切得很碎，难以长篇大论地讲宏大的东西，角色又多，完全来不及一个个塑造，这点比起海沙绝对是退步的
最后稍微提一下虐主问题，核心视角是此夜这是肯定的，而此夜可以说是最惨角色之一了，姐姐保护过度，被逼放弃梦想泯然众人，天赋又比不上绚夜，现实里两边都背叛了，里外不是人，说是双人组但其实她不过是队长的“搭档”，也就是陪衬人，我是此夜也想着入梦了，她身边的人也太不做人了，绚夜不是好朋友吗，至少为此夜正个名，说此夜不只是“搭档”啊，玩下来想代入的人肯定非常痛苦，说实话，我打的最爽结局就是黑化
说是轻百，事实上就像东方的秘封组一样轻，就是说完全打不了lgbtq的tag，河豚倒也没必要冲着这个来……

装甲恶鬼村正

英雄篇的主旨就像巫师三的猎杀怪物cg，evil is evil，杀一个救100个人并不比杀100个人救一个人更善良，都是邪恶，恶无大小
然而杰洛特还是选择了杀一个人来救更多的人，所以他从不会把自己当做英雄
经常有人说，只要杀人都是恶，这种想法三观不正
不过还有更好的方法吗？杀了一个人的人就必须死?如果过失杀人呢？故意杀人必须死?如果被杀人曾害杀人者妻离子散呢？没有仇怨杀人必须死?如果被杀者身上有传染病，不烧掉尸体就会让周边化为地狱呢？杀好人必须死?如果好人只是伪装，私底下男盗女娼呢？
无论如何都很难归纳出绝对正确的可以杀人的场合，因此只能这么说，只要行动，就会有犯下罪孽的可能性，即使什么都不做也是一样，归根到底，道德议题都会是虚无的，只有圈定一个前提，才能讨论一个局部解，那么不同群体的局部解又会不同
因此，只要杀人都是罪，这种观点未必对也未必错，无法证实也无法证伪，只是一个观点，如果说这种观点错，同样也可以否定其他观点，这就是为什么人类文明发展到现在也依旧有无数的罪恶

]]> + 本文是对游戏杂谈的一个汇总

thinklive的游戏簿

|表示同系列续作/dlc

神作

神作的认定标准为同时满足以下123条件或者满足4条件：

  1. 有非常吸引本人，或非常引发本人共鸣的某种或某些特质
  2. 除了1.提及的特质以外，以当时同类型业界的普遍研发水平来说，没有过于明显的短板
  3. 制作组在制作和发行游戏的时刻不应当违反普世道德，发行后则不受此条管辖
  4. 如果有颠覆整个业界级别的功绩，或者有历史上及其特殊的地位，可以无视以上规定

一句话简评环节：

  1. 质量效应2：高质量的队友塑造和任务，最后的自杀任务也非常经典，可谓rpg史上电影化叙事的殿堂作
  2. 异域镇魂曲：有趣的世界观，丰富的文本量，让人牵挂的史诗故事，尽管后期完成度欠佳，但仍有个令人回味的结局
  3. 极乐迪斯科：写给数据删除的一曲哀歌，在这个时代回望别有一番风味
  4. 去月球 || 寻找天堂：探讨人心的作品，正是欲望和缺憾塑成了现在的我们
  5. 瓦尔哈拉：科技下的末世是如此冰冷，但人心因此显得更加温暖
  6. 龙腾世纪起源：自由度，队友塑造，战斗系统，世界观铺陈都几乎无可挑剔的西式魔幻神作
  7. 猎魔人 2 || 3：choice and consequence，选择与后果式rpg的杰出代表
  8. black souls 1 || 2：献给挚爱的你的不可思议的梦之国度的故事
  9. 不予播出：荒诞，新奇，充满娱乐性的英式政治讽刺喜剧
  10. 史丹利寓言——艾迪芬奇的记忆：什么是游戏，什么是交互，什么是叙事？探讨游戏本质的游戏的游戏
  11. 诺科：迷幻的来自失落故乡的旧梦
  12. 428被封锁的涩谷：在4月28日的涩谷，扮演一天的命运女神，将命运纺织起来吧
  13. 隐迹渐现：深入历史其中，然后体会自己的无力
  14. 寒蝉鸣泣之时：没有什么比未经过真金火炼的道德更脆弱，相反的是，经过鲜血试炼的善良才会产生真正的善行
  15. 海猫鸣泣之时：啊啊啊，吾最爱的魔女，贝阿朵莉切…………
  16. ever17(可可线)：打越式诡叙与整个电子游戏界诡叙的最高水平代表，虽然这么说，但前中期实在难熬，只有解谜篇值回票价，根据4.规则破例只将诡计和解谜部分算为神作
  17. remember11:推理的公平性上略逊于e17,一口气抛出来一堆科幻设定比较仓促，没有解谜篇也比较麻烦，大部分人设不讨喜，但悬疑感的塑造远超e17,trick的震撼程度，应该说疯狂程度可以算是所有avg大类的top级
  18. 冥界狂想曲：娓娓道来似醇香的拿铁，适合在黄金般的午后享用这个以死亡为表，以生命为底的作品
  19. 恩达瑞尔：结合了杯赛与黑曜石等经典rpg所长而诞生的洞悉了rpg精髓的作品，尽管在引导上依旧有不少问题
  20. 命运石之门:综合来看优秀的人设，文笔，节奏，以及核心谜题的想象力
  21. There Is No Game: Wrong Dimension:天马行空的谜题，剧情和玩法，可以看出作者对游戏的热爱，游戏的游戏也首先是一款游戏，这或许就是作者想表达的
  22. 装甲恶鬼村正:恶即是恶，恶无大小

佳作

佳作的认定只需要同时满足以下条件：

  1. 有比较优秀且能吸引本人或引发本人共鸣的某种或某些特质
  2. 制作组在制作和发行游戏的时刻不应当违反普世道德

一句话简评环节：

  1. 不可思议的幻想乡:抛开同人作的身份也是完成度很高的肉鸽like
  2. 红弦俱乐部:探讨虚假的幸福与真实的痛苦的作品中比较有趣的一部
  3. 幻想乡萃夜祭：精美的像素美术风格
  4. 东方年代记:在开始后结束，又在结束后引来开始
  5. 赛博朋克2077：在电影化+脚本演出式方面投入不菲，对rpg未来的一种探讨
  6. 生化奇兵无限：很疯狂但有趣的剧本，但受限于不适合叙事的fps题材
  7. 武士0：叙事节奏，完成度很不错的像素游戏
  8. 遗忘之城：完成度尚可的时空轮回式故事
  9. 新手指南：探讨游戏，作者以及评论者的关系
  10. 旁观者1 || 2：完成度尚可的反乌托邦作品
  11. 亲爱的艾斯特：节奏尚可的实验性步行模拟器
  12. 不要喂食猴子：玩法上有创新之处的反乌托邦作品
  13. 无主之地2:fps和rpg的融合代表，人设和演出就fps来说相当不错
  14. 战神4:不错的动作系统和演出效果
  15. GTA4 || 5：荒诞而黑色的犯罪演绎
  16. 杀手三部曲：no one is untouchable.
  17. 空洞骑士: 完整度相当不错的恶魔城like
  18. 影子工厂:价值观很积极向上的探讨虚无主义的作品
  19. 龙脉常歌：清新的冒险向叙事游戏，恋爱要素略多但不会显得喧宾夺主
  20. 荒野大镖客：完整且波澜壮阔地展示西部题材
  21. 天壤的暴风雨：打击感很不错的东方act小品
  22. 王权的陨落：典型猎魔人式的苦涩选择，打牌玩法不错，但后期太重复了
  23. 东方月神夜
  24. 伊森卡特的消失
  25. 逆转裁判三部曲 || 大逆转裁判2
  26. 僚机计划:扮演天空之王，尽情地捕猎，撕碎眼前的猎物
  27. 东方冰之勇者
  28. 渎神
  29. 女神异闻录4
  30. 赤痕夜之仪式
  31. 月圆之夜
  32. 悲情法典；内容和机制极其丰富的地牢rougelike
  33. 无敌号
  34. 看火人
  35. 纪念碑谷
  36. 极限脱出
  37. Ai梦境档案
  38. 控制
  39. 疯人院
  40. 海沙风云
  41. 行尸走肉第一季
  42. 漫长的旅途
  43. 史莱姆少女
  44. 来自边境
  45. yes my lord
  46. 遗迹余痕
  47. npc之梦
  48. 与狼同行
  49. 犹格索托斯的庭院
  50. 兔耳冒险谭
  51. 梅卡妮卡
  52. 人狼村之谜
  53. 红色警戒3
  54. 无声尖啸
  55. hello hello world | noir noah:用真实创造了虚假，又用虚假谱写真实
  56. 艾尔登法环
  57. 剧透过于激烈的RPG：利用设定来诡叙的杰出代表
  58. 枪声与钻石:谈判部分作为重点有接近逆转系列的紧张激烈感，搜查部分由于主角作为警方权限更高，信息量也很大，非常优秀的(泛)推理游戏
  59. one shot
  60. 巫师2——白狼的告别
  61. 辐射 新维加斯
  62. 巴别号漫游指南
  63. 命运石之门0 | 线性拘束的表征图
  64. 梦灯花
  65. 莱拉是谁
  66. 闪避刺客
  67. 海市蜃楼之馆 | 纯真安魂曲
  68. 六角疑云
  69. 邪恶冥刻
  70. 装甲恶鬼村正

To Do List

  1. baldr force | sky | heart(?)
  2. rabi ribi(?)
  3. muvluv
  4. 秽翼的尤斯蒂娅
  5. off(?)
  6. king exit(?)
  7. 混沌之脑 | 混沌之子
  8. 永恒之柱 1|2
  9. 博德之门2
  10. 斯坦达尔警戒者(?)
  11. 超时空之轮

出必入

  1. Not For Broadcast: The Timeloop
  2. Just A To the Moon Series Beach Episode
  3. .45 PARABELLUM BLOODHOUND
  4. BS2同人DLC：风与追忆之旅

期待

  1. 晕晕电波症候群
  2. Avowed
  3. 神罪降临 Uberich: Advent Sinners

龙腾世纪

dao

你可能曾因为好奇去搜过cdpr的发家史，也就是从卖盗版游戏到引进游戏并本土化赚到了第一桶金，这个引进的游戏是博德之门，博德之门的开发商是生软。
这里插一句，波兰人的首秀巫师一在开发阶段几乎遇到了一个新游戏能想到的所有问题，这时生软仗义地扶了波兰人一把，才有了巫师一的面世，遂成rpg界一段佳话，不过后来二者先后拉了（
龙腾世纪本来在定位上是博德之门的替代品，因为版权问题生软不能继续开发博德之门，于是便做出了龙腾世纪起源，这一项目立项在02年，但直到07年得到了EA的支持才在09年把这一“神作”做了出来，直到这时EA还是带善人的形象，并没有露出狰狞的獠牙，而在生软的黄金时代打磨了7年的起源，我可以毫不夸张地说，哪怕今年推出这款游戏，它依然是年度最佳候选级别的神作。
我先说说，我为什么要做这个视频，其实在一开始，dao在我的心中的地位还没有要我做一个视频出来的程度，但在玩了龙腾世纪的后两作后，DAO在我心中地位飙升，可见对比的力量，这个杂谈系列会讲完我对龙腾世纪整个系列的感受，当然是纯个人感受，我不是什么rpg遗老，只是一个当代rpg爱好者而已，如有不同意之处，反正我也不会改的。

当你打开dao建立存档时，你可以选择三个种族，三个职业，在种族内甚至有平民和贵族的区别，根据职业和种族的不同，光开头剧情就有六种，由此开始，玩家就能感受到dao的超高自由度。
当然，对于rpg来说，自由度并不是什么稀奇的东西，但dao的自由度是有其独特之处的，以自由度出名的上古卷轴五，它的自由度体现于扮演的角色的多样性，龙裔，战友团成员，冬堡法师等等，这几种身份并没有交集，是独立的，而起源的自由度体现在行为的自由，自由度再高的游戏也不能完全模拟现实，但高自由度的游戏只需要模拟到玩家一时间能想到或者能让他们觉得有趣的所有选项就够了，DAO做到了这点，举例来说，当你接到了调查黑恶势力的任务，你可以当个正义的使者把邪恶势力端了，也可以接受贿赂，甚至可以献祭奴隶来提高自己的力量，你可以与邪教合作玷污圣物，也可以屠杀邪教，杀死恶龙，扮演被选召的勇士，很多时候当你背叛道德时得到的奖励反而更好，高道德的行为除了增加部分队友的好感度并没有太多作用，与巫师类似，起源遵循着成人的价值观，尽管选择大部分时候不像巫师那么残酷，而且起源中后悔也是很容易的一件事，相对削弱了选择的分量。

我们再来说说提高起源代入感的另一个设计——队友系统，独身在一个苍茫浩瀚的魔幻世界冒险难免会感到孤独，巫师的解决方式是让杰洛特和爱人与亲友保持时不时的联系，上古卷轴的解决方式，嗯，我没感到有什么解决方式，至少本体没有，当然如果装了随从mod肯定就完全不一样了。在龙腾世纪起源中你绝不会感到孤独，相比其他知名rpg，生软最显著的优点应该就是队友塑造了，dao的队友大部分有着讨喜且有深度的人设，这是由海量的工作量撑起来的，在冒险时会随机出现队友间的闲聊，几乎所有队友两两组合都有为数不少的对话，或八卦，或正经或取笑，这让人感到队友都是活生生的人，同时也可想而知其中的工作量，单个角色的对话文字量往往都要以万为单位，此外，在营地和队友闲聊也能通过一些选项增减好感度，所有队友都有为数不少的对话树，并且随着好感度的增减还会解锁额外选项。
队友间除了友情也能发展出爱情，这就不得不提我认为在魔幻rpg中最有魅力的女角色——莫瑞甘，她是个荒野女巫的女儿，，价值观完全是混乱中立甚至偏邪恶的，你做好事她嫌你磨叽，做坏事说不定夸你有魄力，好感度低时会邀请你滚床单并声明只是玩玩，好感度高起来了反而不愿继续亲近——“明明说了只是玩玩，怎么你当真了呢”在游戏的结局莫瑞甘会不可避免地离去，而在一个（拿感情骗钱的）的dlc里沃顿却能不远万里追踪到正欲逃走的她，最终让莫瑞甘也承认了爱情的存在，不得不说我真被这段爱情所感动了，这种细腻的感情戏其实不输我们以感情线为特色的双剑系列（当然续作就没这么顶了）
代入感之外，起源的战斗系统也是极有意思的，多有意思呢，大概比巫师三好几十个上古卷轴五吧（不是）起源的系统在今天看也不算过时，采用一种可以随时暂停的即时战斗系统，同时可以为队友ai设置战术，选项极为详细，大佬光靠设置ai应该就可以全自动战斗，我这种咸鱼打boss还是要几步一暂停，很明显这是一种重策略轻即时的系统，不设技能栏上限让法师成为了团队灵魂，控制，辅助，aoe，单体爆发应有尽有，可以说带够蓝药，法师就是无敌的（大部分Boss远程攻击弱于近战），即便职业平衡不是那么好，但队友是可以随意搭配的，丰富的技能树，转职，加点策略，装备系统让起源的战斗和养成充满乐趣，当然大型迷宫各种怪潮难免会腻烦，不过比起后面两作真的是让我体验最好的战斗系统了。
最后我们来说说起源的剧情和任务设计，大恶魔苏醒，黑潮突起，作为临危受命的灰袍守护者，沃顿利用古老盟约集结联军，手刃大恶魔，可以说是一个很俗套的故事，怎么把这种看起来很俗的故事讲好呢，答案是独立的小故事相加辅以大量填充细节和设定，起源的几条线，法师，矮人，精灵，伯爵都是相对独立的故事，套路很简单：求援——当地陷入危机——解决危机——得到援助，期间夹杂背叛者洛根使绊的故事线，每个地方引出了一部分的世界观设定，起源有着极其繁杂的文本，尽管套路类似，但每条线提供的信息量都是复杂且独特的，同时也有着世界观内各个势力特有的风貌，安教的圣洁，矮人的森严都得到了体现，即使很想比较，龙腾世纪的世界观也是独特且复杂的，当然，相比起源的主线，支线反而比较一般，不乏收集的填充式支线，当然，队友的支线还是很有趣的，也有一些补充世界观的有趣支线。
说了这么多，应该基本说完了起源的特点，当然也有很多具体内容我并没有提及，事实上起源并不是没有缺点，比如优化太差，自带防沉迷，玩几个小时就会卡顿到没完继续，只能重启，此外，敌人种类稀缺，也存在强行推动剧情而忽略合理性的情节，甚至有手刃大恶魔实力的主角有的时候莫名其妙就当垫脚石了，但起源仍然是神作，作为一个玩惯了10年后游戏的人，我玩起源没有感到任何系统在恶心我，可见制作组对玩家体验的重视，这是龙腾世纪的续作都未能做到的，，这也是我为龙腾世纪和生软感到可惜的原因，下一期我会叙述我对两部续作的看法，当然批评为主，，，
出道即巅峰的起源全平台销量不过470w，或许正是这样的销量驱使着生软不惜与老玩家对立也要向着主机倾斜，只可惜了龙腾世纪成为了开幕即巅峰，出场即绝唱的一个悲剧……

da2

今天我们来说说龙腾世纪二，，龙腾世纪二是系列中一部很，额，很独特的作品，他刚发售时的风评，作为后来人我不是很清楚，不过就现在来看，da2的风评呈现一种两极分化的形势。
这里插一句奥，我个人感觉rpg游戏的受众是个很宽容的群体，我这种认为2077是款好游戏的人放一些地方可能被叫孝子了，但对现在龙腾世纪的粉丝来说这可能都不算事，举个例子吧，写文案的这天龙腾世纪吧有个直接辱骂起源人气角色的，甚至没什么人骂回去，这放在其他单机游戏圈子里是难以想象的，所以对于龙腾世纪二这样极其赶工的，大部分玩家评价起来基本没什么戾气，当然事实上我很喜欢这一点，也是这点造成了da2并没有招致较为深入的批评，今天我会详细地阐述这部作品的缺点，当然是以我的角度，同时我也不会带有什么负面情绪，我个人其实很喜欢这个系列，二代我也不是那么讨厌，但它的问题确实是露骨的，毕竟太温和往往就意味着圈子的自净能力不够，对一些问题往往就不能看的那么透彻。
我之前说了da2是一部赶工明显的作品，有多赶工呢，2077和它相比那都不算事，生软甚至没有给二代一个后缀名……
我们先从系统性的问题说起
首先作为一个rpg游戏，da2从头到尾（一共三章）几乎一直在重复利用十几个地图，一样的别墅，一样的山洞（还Tm贼亮）等等，这也是所有玩家都承认的一个问题，考虑到14个月的工期，这点可能也是难以避免的，不过这个问题实际上并不止这么简单，因为地图的数量太少，各种任务线又要在不停阶段换来换去，这就给玩家造成了一个两难的问题——如果按任务线推不得不忍受一个又一个重复度极高的地图，如果以最高效率的原则一个地点一个地点地清，又会错失现状的任务叙事，这种矛盾是稀缺的地图造成的，也是da2在叙事上的一个根本性的缺点
然后，整个战斗系统可以说在da2迎来了史诗性的大改，或许是制作组没有力气做大规模的技能，所以被官方钦定为法师的霍克技能远远没有一代多，对一个技能你要投至少两个点数进去才能强化到底，更别提一个系的被动build需要投入更多，法师的技能树相比战士盗贼完全没有优势，还有那个攻击动作，法师舞得和金箍棒似的，搞act化不能这么搞啊，怕不是设计师想起自己做《翡翠帝国》（生软以前的东方题材rpg）曾经看过的西游记，把法杖当金箍棒设计……然后是二代的刷兵机制，科克沃是个小城市，但在本作中你可以看到如同下饺子一样天降的敌人杂兵——分批次有顺序地入场，先不说不集结优势兵力在战术上有多不明智，二代的aoe法术是大削过的，我基本上要带两个输出法师才能确保范围伤害足够…… 然后是Boss战的秘之设计，堆血加流程化战斗，什么意思呢，举个例子，在最后一章有个杀龙的支线，Boss血贼厚，而且打一会它就会飞走留一堆小杂兵，自己在打不到的高台上放冷箭，有一说一，不难打，但确实恶心，我记得贴吧有个最高难度的老哥打了一小时，我估计啊，制作组对赶工做的boss没信心，所以用这种机制来给玩家提供“紧张感”
本作队友的战术槽给得更多了，这是个好事，但相应的队友的装备系统反而被砍了（武器能换）也就是当霍克捡到非自己职业的装备时，这就是垃圾，还有本作的dlc装备，又多又杂……steam上的全dlc装备过了100件，而且大多是毕业装备的水平，当然本来装备系统也没什么收集的乐趣，dlc出了应该也是破罐子破摔……
当然成功的革新也不是没有，队友的感情线是得到了深化的，高对立和高友好都能得到buff和对应技能树，这有利于玩家不顾及队友好感度地遵循本心去做选择，也增加了build的多样性以及跨职业的连击，不过相应的礼物系统和营地闲聊也砍了……（但我个人还是更喜欢起源的策略性战斗）……
随后的一大麻烦就是剧情，da的小格局剧情在魔幻rpg中应该算少见，虽然这种选择多半也是因为无奈，很多玩家或许是因为新奇而觉得这样的叙事很有意思，确实，不能说da2的故事无聊，但是缺点和漏洞也很明显，我们先把剧情大纲给复习一遍。
枯潮来袭，叛教法师之子霍克与家人逃难到科克沃，在一次矮人矿坑冒险中发家致富，几年后解决了库纳利人的叛乱成为捍卫者，最终面临圣法矛盾的激烈化，并在安德斯的一次恐怖袭击后解决了发布灭法师环令的圣殿骑士领导者梅疯子，圣法大战的时代就此拉开序幕。
只看大纲其实生软的编剧还是有点东西的，有转折，有历史大势，有多方势力的牵扯，看起来很好，是吧，但如果你抛开糟糕的跑任务体验去仔细审视这个故事，你就会发现很难立得住脚。
我猜想啊，14个月的工期一给，编剧拍脑子一想，咱做个小格局故事，矛盾层层激化，来点刺激的，然后开始考虑怎么让角色对号入座，为什么这么说呢，因为da2的故事是典型的情节推动型，霍克从始至终跟着情节走，不是说这么不好，不过da2处理得相对不太行，同年的巫师二也是分三章的小格局叙事，但他们着眼点是主角，杰洛特的立场很明确，找老婆顺便寻回过去记忆，政治那是附带的，他被牵着走，被逼着站队，很合理，互相利用嘛；da2有所不同，霍克从始至终都是城里有排面的人物，就是第一章也是和城里卫队小队长有裙带关系的王牌佣兵，他不能一直被动吧，你da招牌式的自由度呢？
我们来按顺序捋一下故事线，第一章用一些小任务引出了血法师与激进派圣殿骑士两大毒瘤作为引子其实还行，不过霍克听了瓦里克几句忽悠就要下坑道了略显仓促，当然瓦叔是一代口才点满那种人物，系列里忽悠谁谁信，不过下坑道不带安德斯霍克的弟弟就会死着实是个离谱的安排，奥尔加过后大家应当都知道对一个重要人物的出退场不能那么仓促，但奥尔加死的仓促是因为不这么做编不下去，da2是图什么？沃顿和队友杀了不知道多少暗裔，就没受过伤？怎么就你卡沃毒抗负数，你要说是为了霍克成长也不现实，da这种强调主角就是自己的游戏是不会有主角成长的需要的，只能说这段是真的迷惑，除了让卡沃有机会当沃顿没有任何意义
然后进入第二章，这一章的主线是库纳利人线，这段剧情其实写得不错，库纳利人的塑造很有趣，但问题在于二代本就是个内容不足的游戏，着力想展现的圣法之争和库纳利人一点关系也没有，这段想抬升霍克地位的意图实在是明显过头了，再加上一大段剧情给了库纳利人，分散了玩家注意力不说，让圣法大战本就不足的铺垫和描写雪上加霜，当然第二章也有支线，支线讲了什么呢，全讲了血法师是怎么毒害大众的，事实上本作除了第一章有几个法师卖惨，其他的戏份几乎全给了血法师以及安德斯这种激进派，这就导致了一个很搞笑的问题，你说法师不能迫害，但梅疯子一开始也没杀人，你这城市逢一个法师十有八九练血魔法不管你管谁呢？其实圣法之争的核心问题很简单——法师到底多容易堕落，在一代中一个法师用血魔法能屠大半个法环，很危险，但召唤恶魔者本来就是个危险分子，血魔法对他来说只是工具，你要说恶魔诱惑法师有多容易就很难说，同是老血法师的莫姐不就啥事没有，这个问题不挑明，法师的存废很难有定论。
我们再来说说全游戏的高潮——第三章，da2的剧情呈现一个很神奇的现象，你要说层层递进那确实是这样，但递进的未免比较太快了，纵观全游戏你基本看不到什么温和派——无论圣法，对编剧来说激进派确实好用啊，超快节奏推剧情，但对玩家就会感到憋屈。全游戏最激进的梅疯子，她疯吧，但面对霍克这个叛教法师之子，公然的血魔法使用者她一点也不刁难你，霍克还有个顶着精灵和血法师双重debuff的梅丽尔，她也不管，霍克既然这么有面子，那联合一下城里的势力反对她不难吧，结果没给选项，更神奇的是圣殿和法师还有有识之士站出来想把梅疯子杀了，这时候编剧又觉得梅疯子真被保守派刀了结局没得放了，于是让这些人绑架了霍克的家人，这也算了，真密会了还有血法师跳出来把温和派圣殿杀了，你们搞秘密集会成员审查就这水平？放进来个血法师不说还在关键时刻内讧，真的可以，事实上你在游戏里遇到的法师不是莫名其妙疯了就是几乎没有塑造，情节推着所有角色在走，再举一个例子，蕾莉安娜这种间谍头子怎么着也是雷厉风行的实战派了吧，科城的局势像在火上烤，教皇把蕾莉安娜这种重量级角色派来，你猜派来做什么，派来劝现任主教快走，那科克沃怎么办呢，蕾妹连句懂得都懂都没和霍克说
几边都这么随波逐流，主线怎么推进呢，于是安德斯直接开始搞起来恐怖袭击，不得不说这段真的是异常生硬，安德斯前几章还一副弱受的样子没一点铺垫直接搞恐怖主义了，而且搞完还一副为大义牺牲的样子，问题的根源不解决，法师永远会被歧视，这样的情节有什么意义呢，要在魔幻世界观谈政治本就是件很难圆的事情，更别提生软还处理得这么生硬
可能有人会说这样神转折也很震撼啊，但正如我之前说的，奥尔加之死也是神转折，但没有足够铺垫的生硬转折在剧本创作里肯定是要避免的，可以说二代编剧本来应该想写出霍克身为科克沃捍卫者也对历史大势卷携着无能为力的剧本，但实际效果呢，是各路代表不了大势的牛鬼蛇神作死，而我们的霍日天在一边看着准备收拾残局。
我一直坚持在文艺创作领域风格和水平要分开看，就比如我知道二代有很多拥护者，但他们可能大部分是喜欢这种以小见大的叙事风格，而不是充满漏洞的叙事水平，da2虽然我说了他的很多缺点，但生软的剧本虽然很难跻身一流，但保持二流水平还是可以的，剧情演出的信息量能淹没很多人对不合理处的关注便是明证。
Da2故事上的失败很大部分要归因于赶工和工期的匮乏，这一游戏的大部分问题皆来自于此，至于一个世界观宏大的rpg讲小格局故事是否明智，从后见之明的角度看，da2在作为da3的引子方面还算是成功的，但无可否认da2在设定上根本没什么进展，我们要知道dao在世界观构建上只是刚刚展开，还没到成熟的地步，直接在这种半成品框架下讲故事对完善世界观有所期待的玩家肯定不会满意
大部分da2的玩家应该都为这款游戏感到可惜，如果再有一年的时间可能以上的问题能解决个大半，但奈何生软摊上ea这么一个急功近利的老板，而在下一作，生软带给我的就更多是愤怒，而不是惋惜了……to be continued
以下是个人的碎碎念
一代赶路神技加速术居然砍成限时Buff了,而且这游戏强调同性恋是不是有点过了，安德斯动不动一脸弱受的样子，而且那啥院居然还有不问你性取向直接调情的男妓……这算性骚扰了吧，伊莎贝拉一代可没那么黑啊，这是在海上漂了几十年人种都换了？生软搞zzzq真的由来已久

dai

今天我们要介绍的这款游戏，于2014年以压倒性优势赢得了tga年度最佳，没有任何一个竞争者是与它同一个量级的，gta5，最后生还者为了避其锋芒不得不选择在13年发售，巫师三被吓得跳票到15年，在得知14年有这款游戏后，宫崎英高慌得只得把黑魂三继续打磨到16年，它就是古往今来最强的rpg游戏——龙腾世纪审判！！！
对审判的评价有个很神奇的现象，刚推出的年份似乎风评尚可，但随着时间推移，评价越来越差，这似乎意味着这是一款开创先河的游戏，无论是填充式的开放世界，还是泛滥的政治正确，都在这款14年的游戏中得到了体现，当然我不怀疑生软的目的，毕竟制作组高层就有同性恋，甚至现在看来惨不忍睹的开放世界当初的生软可能真的觉得很好（虽然被第二年的巫师三干碎了）
审判在我心中一直是一部很独特的作品，如果你让我说明da系列的优点，一代的优点不胜枚举，二代我至少可以说风格很独特，三代就比较神奇，它的优点，额，藏得比较深
那我们不妨就先说说它的优点，审判在世界观和时间上的推进上有巨大的建树，我的意思是，填了几个坑的同时挖了更多的坑，生软在下一盘很大的棋，无论是揭开奥莱斯的帷幕，教会的黑暗过去，亦或是把古代精灵的设定全部推倒，都能让我们感受到生软在剧本上的用心，确实，理论上讲，dai的剧情是很有看头的，但生软把自己的缺点推向台前，把优点深藏幕后，让我在玩的时候频频破防，也是真的厉害
我们还是先从系统问题说起，不知道是什么给了制作组勇气，本作的引擎换成了做战地的寒霜，这个引擎对rpg的适配性极差，为了实现存档生软就不得不对其做了大量魔改，乃至系列核心功能的存档继承还要通过一个网站实现（没有中文支持哦），不知道是不是为了照顾主机，即时演算cg还是锁30帧的，配合僵硬的人物动作，让我感觉在看ppt，审判还有一种极为奇妙的油腻效果，你要用在植被景物上我就当做油画风格了，但奈何人物也是这个样子，个个都像青春期几个月不洗脸一样满脸反光，在这里我澄清一下啊，有黑子造谣叫索拉斯“蛋头”，索拉斯什么时候配碰瓷我们鸡蛋了，你家鸡蛋反光到这种程度？
审判主打一个开放世界，什么叫开放世界呢，每个地图给你一堆无聊的收集式支线，跑断腿去吧，此外，除了某些装备词条，审判官没有任何提高那慢的像残废一样的移速的手段，偏偏生软还恶趣味地把地图做的很大，收集式支线的收集品路线拉得很长，如果不修改游戏速度，或者有什么特殊癖好我觉得是撑不下去的，顺便一提也基本没有什么像样的奖励，生软不会真的觉得这种任务能留得住玩家吧，就算14年大家还没有被育碧的填充式开放世界搞得审美疲劳，也不会对这种设计甘之若饴吧
当然了，也有人反驳，又没有强迫你做，不喜欢大可不做，首先呢，为了推主线总归是要做支线积攒势力点的，其次，这也涉及到游戏设计的一个问题，一个叙事向游戏，最根本的是什么，我认为就是像玩家提供信息，一个优秀的的叙事游戏必须在游玩过程中高密度同时高质量的提供给玩家信息，同时这个过程必须是有导向性的，要将玩家的注意力导向最能给予他们信息的方向，因此任务日志里主线永远要在c位，即使是巫师三这种支线质量领先业界的作品，也有粗制滥造纯跑腿的任务，但这些任务流程不会长，也就是，虽然提供不了什么和世界观塑造或者叙事相关的信息，但由于时间短，这段时间的信息密度并没有低到无法忍受，我们看看dai是怎么处理的，首先支线在基本没有信息量的同时，极度磨叽，当然这也就算了，毕竟不喜欢可以不玩嘛，但制作组自作聪明地把这些制作水平极度粗糙的支线，给塞在了日志里，一打开日志界面就是密密麻麻的0/X，我相信但凡是个正常人都会感到烦躁，这就是很失败的一点，它将玩家的注意力导向了最错误的方向，是个极度离谱的设计
同样是为了照顾主机，本作的技能栏进一步精简到了8个技能，8个技能，战士和盗贼都没有过这么吃紧的技能栏，你让法师玩什么？虽然是个人喜好问题，但这种革新是不是有点太过分了一点呢？说实话dai我是一点玩法师的欲望也没有，不是说强度有多少削弱，而是策略选择的灵活性没有了，说到策略，本作更迷惑的一点是取消了战术设定，可以说是向即时act全面转进，da系列每代都有极大的革新，我也不知道是图个什么，我们就当是因为商业利益不得不妥协了吧。
再说剧情和人设的问题，只看大纲，审判的剧情和一代很像，都是主角临危受命杀死大魔王拯救世界的故事，区别也是有点，审判的格局宏大的多，看得出编剧很有野心，一代的费罗登和仅仅提及过的奥莱斯都是本作的舞台，但问题在于呈现的方式，极度草率，我之前说dai是开放世界，其实这不完全准确，因为只有地图和任务是开放的，能去的地方其实就几个，而且大多是荒郊野外，根本不足以展示末日将临下两国的反应，当然生软也想了个办法，就是决策桌系统，说实话这就是个挂机文字游戏，而且频繁进出还很浪费时间，尽管事件很丰富，但寥寥几语文字提供不了多少信息量，一代通过支线我起码看出了点费罗登人应对枯潮的绝望与恐惧，审判恕我直言，完全没什么感觉，当然我不否认主线的几个大事件做的不错，但相应的小格局叙事的空缺让我感觉到这场灾难的苍白，试想一下，审判团之外判官直接接触过什么组织什么人，没几个，是吧。
再说人物，本作的大反派，考爷，不得不说异常苍白，一代的反派洛根虽然傲慢愚蠢但至少性格是有几个侧面的，考爷有什么呢，纯粹的邪恶与野心，其实这样也行，我一向认为刻画人物有两条路，一条是通过各种细节展示其多面性或者成长与突变，一种就是把一个性格特质发挥到极致，比如jojo福音的田最环，就是个坏人，但他诡计多端会演戏，文能严刑逼供心理施压，武能压着吉良和仗助打，这就是把恶这一性格写到极致，但考爷两边都不沾，风头全被我们男判官的好兄弟，女判官的好情人索光头抢走了，真的是惨。
反观入侵者dlc可以说才是真的点睛之笔，回过头来想想，几乎整个审判本体都在给这个dlc作铺垫，不得不说这个dlc确实让我感受到了生软最后的实力
再说队友，其实dai的队友一直给我一种神奇的疏离感，但本着科学严谨的态度，我思考了好一阵为什么会有这种感觉，在这里和大家分享一下
首先是身份上的疏离，一二代的队友都各有各的不同，但总归是人类，精灵，矮人三个基本分类，而且归属上都是费罗登的人，审判就比较神奇，铁牛是库纳利人，科尔是个灵体，其他队友从费罗登奥莱斯两对头，到遥不可及的德凡特，都有，当然这只是最浅显的一点，但身份的疏离明显加大了队友间的隔阂
其次，考虑一下一二代与三代主角的不同，一二代都是有所谓初始剧情的，因此他们都有自己的死忠与初始势力，一代的沃顿初始有同事A哥和受了母亲命令的莫姐两大死忠才开始招募队友的旅程，二代的霍克不仅有弟弟/妹妹还有艾芙琳的支持，更重要的是，加入的队友大部分是孤家寡人，都是孤身投奔梁山的类型，而审判就不同了，初始就有自己势力的卡姐，率部投奔的萨拉，间谍铁牛，法师领袖薇薇安，瓦里克还是霍克的死忠（十年老交情不可能完全站在判官这边）导致判官严格来说甚至没有可以信任的亲信，相反，还要应付各怀异心的队友
最后，对于角色的塑造来说，一共有三个过程，不成熟，成熟，升华，举例来说，一代鲜有不成熟的角色，成熟的利己人格莫姐最后接纳了爱情这是对其人设的升华，成熟的温奶最后决定牺牲自己造福世人，这也是一种升华，一代是不缺少有自己成熟价值观的人物的，看着傻白甜的蕾妹实际上早就身经百战了，而三代不成熟人格就多起来了，卡姐看着霸气，实际上被瓦里克骗了很久，而且天真的没有意识到圣殿骑士膨胀的权力必然导致的对法师的压迫，科尔更不必说，黑墙直到赎罪后才形成了成熟的人格
再说一些其他方面的问题，我是指，政治正确，不知何时起gayware的游戏已经成了同性恋人群的狂欢处了，在尊重同性恋的同时我能请生软尊重一下异性恋吗，队友里能推的只有卡姐？生软塑造女性角色的功底可以说在倒退了，相反的，光头倒颇有一代莫姐的风采，然后是黑人姐姐薇薇安，据我所知龙腾世纪并没有任何关于人种肤色的设定，但我们的薇薇安姐姐就这么不羁地出现在我们眼前，似乎不认为自己在满世界的白皮人中有任何特殊之处，更神奇的是这位姐姐的人设还是交际高手，我很好奇奥莱死的权贵们难道真能把薇薇安当同族看待？据我所知一个明显与交际圈所有人都不同的人，被排挤才是正常操作吧，而我们的薇薇安姐，不仅顶着异于常人的肤色，还有着其貌不扬的一张脸，能成为帝国圈内炙手可热的交际花也是相当励志了。顺便一提，有人说叠buff拿年度最佳是美末二首创，其实是dai玩剩下的，从这点看可以说是非常有创造性的一作了
总的来说，虽然定位上dai是一部中兴之作，但这部作品在最底层的设计逻辑上存在很大的问题，整个路都走错了，如果生软把做开放地图和低质量支线的精力拿来做出一代那种不乏少数有趣支线的线性地图，把决策桌换成各种小任务，那么呈现出的效果必然会好很多，同时，恼人的政治正确，油光满面的建模，浮夸的网游式特效，让审判在外观上都显得不讨喜，我由衷的希望da4里生软能认清自己，摆脱这些乱七八糟的问题。

巫师

熟悉我的朋友都知道，我本人是巫师系列的死忠，如果让我给rpg游戏做一个排行，我会把巫师放在第一位，有的人可能会说，巫师固然是rpg佳作，但在浩如烟海，名作辈出的rpg里可未必排的上号，又有的人可能会说，说这么多不过是“情怀党”的矫情而已。
不错，巫师系列对我来说不只是一个游戏，如果说每个人最大的爱好都有一个启蒙物，那么可以说正是巫师，将我带进了那些着重于叙事的游戏的坑。不过与大部分人不同的是，我初次接触巫师系列是巫师的二代。
那是一个普通的暑假，我费力地思考着，家里残破的笔记本电脑到底能玩点什么游戏，这时我突然想到，听说有个叫巫师三的游戏挺有名，我不如试试它的前作好了。就这样我搜到了巫师一二，巫师一画面陈旧，操作蹩脚，我毫不犹豫地排除了它，但二代却有着在那个年代来说不错的画质，于是我找到了它的资源，试着玩了起来。
听到这里可能大家觉得我无非在说一些陈词滥调，但我想说的是，巫师二即使以我现在不知道涨了多少的阅历来看，依旧是一款特立独行的游戏。在此之前我也玩过不少游戏，但我从来没有见过一个没有政治诉求纯粹为了自己的利益行动的主角，我从来没有见过一个每个人都栩栩如生，有自己行事逻辑的世界，我从来都没有见过，一个以阴暗的政治冲突，种族歧视为背景的游戏，即使以rpg来说，巫师二也是个很有勇气的游戏，在巫师二不长的序章过后，就会面临两个截然不同的分歧，并且这两条分支路线的重复内容并不多，如此大的分支毫无疑问是不多见的。现在回想起来，巫师二可能是我唯一一个一点也没有碰支线的rpg游戏，固然因为当时我懵懂无知，但其波澜壮阔的主线确实无比吸引我，
是的，这是一个非常有突破性的游戏，可谓是cdpr写政治戏码的巅峰，但是，很神奇的是，这又是一个被遗忘的游戏，不仅是被引流来的巫师三玩家遗忘，就连cdpr好像也忘了它，巫师三和二代基本没有什么关系，可能有人会反驳我，巫师三的开头就要模拟二代抉择，但事实上，对一个强调选择的rpg游戏来说，重要的不仅是选择，更是选择带来的后果，而巫师二那些惊心动魄的选择，在三代中几乎都成了定局，无论上亚甸是否赢得了独立，最后的区别不过是沦陷在亨赛特的军队下还是尼弗嘉德军队下而已。无论是否救回泰莫利亚最后的王室血脉，罗契都只能带着他的兄弟们再度流亡。更神奇的是二代最成功的女性角色，龙女居然不知所踪，事实上龙女和伊欧菲斯在巫师三曾有过一个现在沦为废案的任务，但因为赶工期被砍掉了。我们对比一下同样三部曲的龙腾世纪，一代的诸多队友都会在二代亮相，甚至还能在三代中当重要角色。而巫师三部间的关联则少得可怜，一代的女主角夏妮在石之心才出场，也就雷索与罗契在三代的戏份多一点，这无疑大大削弱了巫师中选择的分量。当然，我也能理解cdpr，三代是系列中唯一重启主线的一部，与更像外传的一二部有着极大的区别，并且这一作有着不小的制作规模，必须放弃前作壁垒，放低身段吸引新玩家，种种考量下，三代注定是相对独立的一作，更何况在二代一番精心算计下，事线固然优秀，但已经形成了逻辑闭环，也很难找到延续的办法。而三代为了种种考量，强行让南北形成均势，更破坏了延续巫师二剧情的可能性，尽管可惜，但巫师二作为一个完整的故事，也可以称得上优秀。
接下来我们就来讨论一下一款游戏。
首先，依照惯例，巫师二的系统，巫师二的画面在当年算得上不错，但毕竟此时的cdpr并没有太大经验，因此整部游戏的一些地方仍然显得很生涩，比如说，巫师二是没有跳跃功能的，只能让玩家去寻找攀爬点才能上下移动，而这些攀爬点则都做的很隐蔽，配合拙劣的导路功能，跑图体验难言理想，随后巫师二的战斗相比巫师三繁琐不少，同样分为三种流派，近战，炼金和法印，法印有单独的储备槽，能随着时间恢复，这点有点像dnd，近战则有和三代近似华丽但破绽很大的剑术，并且翻滚是没有无敌帧的，也就是说翻滚途中被攻击打断是常用的事。药剂和炸弹都是一次性用品，众所周知，rpg游戏的一次性用品就是不打最终boss能不用就不用的东西，因此虽然炼金流算得上强力，但由于合成的琐碎以及造价昂贵，走这条线的并不算多。总的来说巫师的战斗系统基本都是在及格线上徘徊的水平，实在没有多少意思。
而论起剧情，就很有的说了
巫师二的叙事有什么特点呢？
第一，选择
巫师二依旧采取了巫师系列道德困境式的抉择，有不少人批评说这种列车难题式的道德抉择千篇一律，然而，我很好奇的是，他们指望在一个商业游戏里看到怎么样的抉择设定呢？巫师的抉择可能算不上精巧，但在rpg可以说是独树一帜的有分量，重要人物的生死，一个王国的命运，巫师二充斥着各种意义上的抉择，甚至包括第二章两个截然不同的路线。放眼整个rpg史，我敢说有如此大主线分歧的也是寥寥无几，而这样独特的设计，其实与巫师二的剧情结构有不少关系。
第二，双线叙事
我们的杰洛特一向对政治敬而远之，而巫师二构思巧妙之处在于，让一个对政治最没有兴趣的人成了北境局势的关键人物，在游戏中，双线并进的结构被广泛的运用。杰洛特的态度是模糊的，归根到底他不过是想洗脱罪名并寻回自己的记忆，这两大主线目标，前者为主线后者为暗线，都被牵扯到了同一个人身上——雷索。而对于雷索的刺杀行动而言，女术士集会所的阴谋浮现在明处，而隐藏最深的则是尼弗伽德入侵的阴谋。对于游戏中涉及的北境势力而言，两大对抗者，上亚甸和科德温，杰洛特在游戏中任选其一作为明线，另一方便会成为暗线穿插其中。几条剧情路线互相交叉，且彼此间都有说不清道不明的关系，可以说巫师二颇有些戏剧的风格，重要人物算不上多，但却有着极为复杂的人物关系，整个故事都十分耐人寻味。
第三，演出水平
巫师在剧情演出上向来不遗余力，这点倒是颇有生软的师传，巫师二增强版的开场cg对一个11年的游戏来说可以说无比华丽，而在随后的剧情中，也有不少制作不错的cg的即时演出，更有趣的是，不知道是不是为了赶时髦，巫师二还做了两个系列中少有的巨型boss战，在11年来说，这样的演出效果可以说相当不错了，说到这里不得不佩服cdpr的勇气，只做过一部巫师一就敢砸这么多钱到一个前景不明的项目去。
第四，政治阴谋
大部分宫廷政治故事都是肮脏的，巫师二也不例外，开篇我们就能看到为了自己和妹妹的私生子发动王国内战的妹控王，要说这妹控王也是个有勇有谋之辈，但把自己荒淫无度的行径公开到整个国家民众面前的行为，着实是让人叹为观止。如果你觉得这已经很毁三观了，那么我可以负责任地告诉你说，福尔泰斯特在北境执政者里是道德楷模级别的存在，整部游戏里你碰到的政治家，浮港的总督是个没有下限的人渣，亨赛特是个粗暴蛮横的野心家，此时看上去正常的拉多维德对待自己的恩师也是“无微不至”，就连浓眉大眼的斯坦尼斯王子，都能为了上位一脸坦荡地毒害龙女。
当然了，也有萨奇亚这种浑身坦荡的完美领袖，上亚甸是巫师中难得直接描写非人种族抗争的一段剧情，十分正能量和主旋律，算是难得地调剂了巫师阴暗冷酷的风格，巫师对“义军”的描写并没有落入俗套，龙女一身正气但是并不迂腐，伊欧菲斯虽然仇恨人类，但并不是不择手段之辈，他会对萨奇亚动心，会对救了他的命的杰洛特予以回报，矮人往往看上去豪放，却不失狡诈和算计，而义军中也有斯坦尼斯王子和菲丽芭这种野心家。Cdpr对上亚甸线是很上了些功夫的，多种族混杂的特点被个性迥异的npc完美地体现了出来。可以说，在有政治戏码的rpg中，巫师二绝对是一部水准上的作品。
稍微扯开一点话题，巫师二的最终boss雷索，我个人认为是rpg游戏设计得最成功的反派人物之一，雷索的人物志在b站就有，在此不做赘述，纵观其生平，不得不说无论是公事还是私德上，雷索都是一个近乎完美的角色，公事上为了复兴自己的学派，雷索完美执行了恩希尔大帝的命令，他的刺杀行动无不是计划周详，下手果断，善后的处理的也无可挑剔，甚至面对女术士集会所的谋划，将计就计把北境的大部分术士架上了火刑架，要知道，让术士吃这种大亏，这恐怕是猎魔人历史上都没几个人能做的壮举，更可贵的是雷索在做这些事的时候完全秉持公事公办，各为其主的态度，他没有因为杰洛特是福尔泰斯特的护卫就下手迟疑，也没有把自己兄弟的死记在杰洛特头上，他始终清楚地认识到自己不过是尼弗伽德的一把刀这个事实，即使三代中被恩希尔背刺了一刀，也很难说他会有多么吃惊，而在私德方面，为了答谢杰洛特的救命之恩，他跟着杰洛特去迎战几乎没有胜机的狂猎大军，保护叶奈法，甚至在最后把特莉丝从大屠杀中救了出来，而在整场游戏中，他一次也没有对杰洛特下死手。这种文能算计整个北境的术士，武能压制失忆期杰洛特的全能型人才，实在是比工具人白狼不知道高到哪里去了。可能每个巫师系列的粉丝都对巫师四有自己的想法，不过如果是我的话，我是很希望能有以雷索为主角的一部游戏，这个人设实在是太强了。
上述是我个人认为巫师二的优点，不过如果你要问我有没有缺点，那我也可以很明确的说，有的，而且还很明显，并且这个缺点贯穿了整个巫师系列。
我们知道，rpg的意思就是角色扮演游戏，意思就是可以让玩家扮演一个虚拟角色在一个虚拟世界中做出种种行为，巫师系列是21世纪rpg的一大系列，但巫师却并不是一个完全标准的rpg，为什么呢？因为杰洛特是有性格的，杰洛特大体的性格是，外冷内热，自尊心强，外表冷酷无情，内心深处其实是一个傲娇老好人，这样问题就来了，你杰洛特都有性格了，那玩家怎么做选择，cdpr的回答是，尽量把所有选择都做成两难式的，即使是杰洛特本人来选也会犹豫的那种，这也是为什么cdpr总是喜欢这种两难抉择的原因，但还有问题，总有一些真正的杰洛特不会犹豫的选择，比如说真正的杰洛特必然是椰奶的舔狗，而面对这种选择，玩家只能扮演自己，这就让巫师的剧情流程也有了一种割裂感，你是要扮演杰洛特还是扮演自己，这是在你打开巫师游戏前要先做出的选择。当然，两种选择都无可厚非，但这也必然会造成一些矛盾性的情况，像巫师二里，无论哪条线路，不去救特莉丝都会都会对游戏的重要角色大有益处，作为玩家，如果你查了攻略，你就会知道好兄弟雷索会帮你把萌特救出来，然而如果真让杰洛特选他绝对不会放弃自己的情人，也就意味着，要么玩家放弃选择权，要么就要忍受杰洛特的ooc（人设崩塌）。
我个人觉得这是个不大不小的问题，只要做好心理准备还是能忍受的，毕竟一个小说改游戏，碰到这种问题也是难免的，cdpr其实已经把平衡性做的挺好了，没必要太苛求。额，如果这也算孝子那就算吧，不狡辩。
回过头去看，巫师二确实是一部难得的rpg佳作，但它未必是一个合格的承上启下之作，巫师二讲了一个太过精彩的故事，导致接下来不怎么好编了，尼国平推北方顺理成章却很无趣，北方反攻又是天方夜谭，导致巫师三的政治形势显得十分强行，迪胖和拉多维德其实都像开了挂一样，要知道，历史是没有个人英雄主义的，区区一个统治者就能逆转尼弗伽德和北方天堑一般的差距吗？这多少有点机械降神了。这么说来巫师二某种意义上近乎把故事讲死了，不过如果我是cdpr估计也会很无奈，小说基本已经写到恩希尔大帝快一统天下的地步了，巫师由于以杰洛特这种政治无关人士作为主角，搞点宫廷刺杀已经是政治戏的极限了，还能怎么编呢？
写到这突然想到，巫师三里曾经对雷索喊打喊杀的杰洛特也成了“国王刺客”，这可真是，人终将活成自己最讨厌的样子。

影子工厂

我本以为影子工厂会如简介说的一样，会是杂糅诸多风格的悬疑风，故事的一开始也的确如此，时间穿越配合豪宅血腥谋杀的经典模式别有一番风味，不过结合前传一贯的发展，不难想象出而在这之后又回到了我们熟悉的时间轴环节，比较特殊的是，这次高瞰老师罕见地采用了正叙的方式，而且此次的故事出奇的平淡，尽管感情上依旧无比细腻，但几乎没有什么出乎意料地发展。
而事实上，高瞰老师擅长的叙事诡计只是换了一种方式呈现在我们面前，这是一个一位身患绝症的女性在生活和事业中苦苦挣扎，在经历了孩子的夭折后，最后选择了事业的故事，尽管这个故事占了整部游戏大半的流程，但其实它本身并不是重点，因为在开头，影子工厂的主线就被堂而皇之地摆在了我们的面前，豪宅层出不穷的死亡案件，于是，在历览了女主的人生后，真相的追寻才真正开始，当然了，故事如何这里就不赘述了。
当然，相比前两作选材的独特，和层出不穷的叙事诡计，影子工厂显得平淡的多，正如lynri所说，昆西相比两位博士不过是一个观察者而已，他对于挚爱的lynri无能为力，面对自己不过是模拟的数据也无能为力，他的一生没有什么狂乱幻想，也没有多么丰富的内心世界，尽管他的内心是强大的，不过依旧没有什么意思。当昆西历览lynri的记忆时，我们会发现相比博士的聒噪，大部分时候他不过沉默地接受着，评价这一环节是在这段记忆中缺少的。而让这段记忆，一个不是最重要的故事占据叙事的大部分是可以的，但问题在于这一部分必须要穿插主线，否则会产生严重的割裂感，而就影子工厂来说，很难说这一部分和主线有着多大的关系，是否手术的分歧导致了之后的一切，但要拼凑出真相，我们需要知道的除了这个世界不是真实的以外，还有分歧点在于保大还是保小，以及lynri的姓氏，而这两点都没有结合进这个过程。抛开叙事结构，如果我们只看这个故事本身，昆西的爱情故事虽然不能说不好，但比起前作的惊艳未免显得俗套。可以说，如果把这个故事大刀阔斧地砍几笔，也不会有多大的差别，当然，就故事的首尾而言依旧是很有趣的。
不过即便如此，我也要说影子工厂是一部水准上的作品，它有着层层递归的脑洞，优秀的人物塑造，最重要的是，它还展示了高瞰老师填坑的一点点意愿，虽然到最后我们也不会知道两位博士之后到底会怎么发展。而对于系列中虽然重要但没有认真探讨过的记忆编辑技术，影子工厂也表明了一种态度，就是尽管这可能看上去虚无的，但就我们个人所及的知识与眼见来看，只有有过美好的时刻，它就是有意义的，这是一种积极向上的态度，尽管这只是一种态度，但对于虚无与否的讨论大部分时候都只能取决于我们的态度。能以合适的形式传达出这样的观点，就是一部很好的作品了。

不予播出

吉姆哈克：当一个国家走在下坡路上，必须有一个给它踩一脚油门。
你生活在一个贫富差距分化严重，外部国家敌意渐升的民主国家，而在此危难关头，一个名为先进党的政党，凭借集体主义的价值观，以及消灭富人扶持穷人的竞选纲领上了台，时代变换的帷幕在你面前缓缓拉开，这时，你能做什么呢？
这大概就是不予播出想呈现的故事，这个游戏是我认为近年zz题材最出彩的一部独立游戏。
我们先从游戏的形式说起
它选取了一个很少见的视角——电视台导播，也就是在电视内容被播放前负责镜头切换与简单后期音效处理的一个职位，这是一个虽然默默无名却十分重要的职位，制作组对此的选择非常高明，在这个位置上你能接收到一切媒体信息，同时决定哪些内容会被最后播出。
游戏的背景设定是魔改版的80年代英国，想想就知道在这个电视台的黄金时代这个职位意味着什么。
在我们这个娱乐至死的年代，恐怕我们的印象中很难会有什么凭良心的办事的媒体人，但在游戏中，随着举足轻重的影响力而来的同样还有巨大的责任，我们可以看到游戏的封面是一个被操控的提线木偶端坐于导播台前，这似乎预示着你不过是政党口中的喉舌，事实上，面对zz大势，大部分时候你确实是无力的，但总有一些事是你可以做的。游戏中，你能做的包括切换各种机位设置，添加后期音效这些普通的工作，你也可以转而接收反对党的信号，甚至在暗中支持他们。
可以说这样的玩法绝对算不上丰富，但是，为了这些内容制作组拍摄了极为大量的采访，节目，等等实景拍摄，这些作品的文案，演出水平都极为突出，也就是说，让你去观看这些节目，决定他们如何被呈现于观众面前，才是它的核心玩法。
于是，我们可以说说它的剧情了。
我为不予播出的剧情概括了一些特点，首先是荒谬性
国家晚间新闻，是一家有不少zz性的电台，在游戏的一开始，作为新上任的导播，我们的第一次工作就见证了前文提到的先进党的上台，在游戏的一开始我们能感受到强烈的荒谬感，就拿先进党举例，该党的带头人是一对夫妇，丈夫粗俗不堪，而妻子却圆滑世故，这样一对其貌不扬的夫妇在自己上任的第一天就大声向“富人”宣战，我们知道，如果对这些拥有大量资产的人过于苛刻就会造成大量资产外流，对此这对夫妇甚至采用强制手法禁止他们出境，这对一个“民主”国家而言恐怕很难想象，更为魔幻的是这样的举措确实赢得了大众为他们叫好，收归民有资产为国有，强制推行福利政策，提倡集体主义，一副宏伟的蓝图就这样在我们面前展开，即使对民粹主义者来说，这样狂野的改革恐怕也有些吓人，而这些种种举措以极快的速度在游戏中发生了，并且让你切实的体会到厉害之处——也就是游戏中各种惊慌失措的小资产阶级。如果你问大资产阶级咋样了，就有限的情报来说，似乎他们在与国家合作后过得很好。
这是一家很有煽动性的政党，但如果你细细去看他们做了什么，建立国家养老机构（把老人送进去就可以不管了）成立青少年队伍（洗脑从娃娃抓起）半强制推行政党性而不是国家性的身份卡（很明显，只是后续动作的开始）甚至把反对的国家的个别城市用特工安置的核弹统统炸上天。
很荒谬，不是吗？但这些事情确实如此发生了。

如果你很好奇对此的政治评论是怎样的，那么我们很快就会见识到该游戏另一个厉害之处——现实性的缺席。
在游戏的一开始国家晚间新闻是一家较为严肃的新闻频道，但随着游戏的进程，娱乐性的报道和节目越来越多（而且不乏先进党资助的无聊作品），这次过程中有着不少精妙的讽刺，例如领着先进党资助大搞政治正确的校园舞台剧组合，光明正大搞热水器的女明星等等，此时在早期的一些政治性节目中，也有不少让人啼笑皆非的人物，例如奉行白人至上主义，热爱sm的警察局局长，似乎几个小丑粉墨登场就能谈起国家大事。作为理应为公众揭露真相的媒体，自己就陷入了娱乐至死的泥潭
不过他们又能怎么办呢？对于一个奉行强权政治的政党，让一个电视台说不了真话简直太容易了。所以我们在游戏中看到的趋势是，节目变得越来越无聊，又臭又长，当批评声变得刺耳，那么连赞扬得不够卖力也成了罪责。
但游戏中依然有着保存着良心的媒体人，杰里米的爆发大概处于游戏中期，他挟持了摄像头，指责所有人都失去了说话的勇气，随后自绝于心爱的镜头前。这段的演出可以说全游戏最大的一个亮点，荒诞的现实与理想的缺席构成了极大的对比，将游戏荒谬而现实的矛盾感体现得极为突出。
然后，我们要说到极端意识形态题材作品的一体两面——压迫与反抗
哪里有压迫，哪里就有反抗，对于极端意识形态题材而言，对其的呈现与对反抗的呈现是一枚硬币的两面，与其他反乌托邦作品伟光正的反抗者不同，不予播出的反对者仅仅是走向了另一个极端。在游戏中有一个明确的反对者——打断组织，这个组织是什么样的呢？很大程度上可能由一些小资产阶级与无产阶级组成，面对集权，他们选择了暴力，游行，破坏，暴动甚至军事政变，我们很难说打断是一个多好的选择，事实上他们根本没有提出什么解决方案，似乎只是因为自己的利益受到了侵犯而已，在游戏的结局我们可以看到打断组织不过是军方扶持的傀儡，用完即扔。
再说回先进党，这一党派在游戏的中期收到全世界的敌视与孤立，不得不进行完全的内循环经济，究其原因，或许是对有产阶级的镇压并不符合经济全球化的要求，从而招致了其他国家的敌视，随后，他们向全世界部分国家的城市引爆核弹，建立起核威慑。 试问，如果你是一位普通人，你能做出什么样的选择呢？
说到这里，就不得不说不予播出另一个有趣的机制——在导播工作的间隙你将以视觉小说的形式看到作为普通人的自己如何在政治的漩涡中生活。与电视上光鲜亮丽的报道不同，即使作为被济的穷人，你也不过是从一贫如洗走向负债累累而已。
恐怕根本没有什么更好的选择。
最后，我们应该回归这部游戏贯穿始终的特点——讽刺性和娱乐性
可以说，这部游戏最终呈现的是一个荒谬的世界，在政治领域极端，疯狂，暴力构成了它的底色，这也是我称其为极端意识形态大乱斗的原因
你要问这样的构建是否过于疯狂而丢失了真实性，而且想要展现这样的世界观一个导播的视角也远远不够，可能的确是这样，但我认为这样极端之间的碰撞反而能增加不少的戏剧性。
可能根本不会有这么极端的政党，可能如此极端的政党根本得不到如此多的武力支持，或许吧，但说到底，这不过是个讽刺性游戏而已，用夸张的手法实属正常。
而在政治以外的社会领域呢？滑稽，疯癫，娱乐才是它的主题，你可以看到收藏大粪为乐的清洁工，无法控制肠道蠕动放出气体的“病患”等等极为魔幻的人物登上荧幕，可以说，游戏中所有的人物都是经过夸张化和娱乐化的，即使抛开政治性，你也可以当笑话看。这是我很欣赏不予播出的一点，它并不完全正经，但绝对有趣。

最后，做一个总结吧，根据关键节点的选择不同，游戏一共有14种结局，有一家独大，有天下大乱，也有非极端派兴起，这些结局有的因你而起，有的不过是大势所趋。不予播出从一个导播的小人物视角出发，呈现了一个极端意识形态偏向的荒谬社会的百态，有戏剧性的加工，也有对真实世界的化用与讽刺。
说实话，政治讽刺题材的乐趣不正是在此吗？

步行模拟器

步行模拟器，在本视频中取操作只局限于步行和一些简单动作，主要获取信息的途径为阅读和观察的游戏，这是一种颇为先锋，也颇为小众的游戏类型，在其中有一些火到出圈的佳作，也有缺点明细的庸作，但都有着共性在其中，今天，我就用一个业余爱好者的身份来浅析一下这类游戏。
我们先从步行模拟器的历史说起，由于我不是专业人士，也不是什么老玩家，所以只能大概地说说。
溯及这类游戏的根源是一件很难且没有必要的事情，所以我们只把目光放在本世纪好了，在2007年，一个传奇的年份，当时的游戏界见证了巫师一，质量效应一，刺客信条一等传奇系列首作的诞生，也有一些人注意到一款名为《亲爱的艾斯特》的奇异游戏，对一个原教旨主义者来说它可能算不上游戏，玩家操控着一位失去妻子的男人在孤岛上步行，整部游戏唯一的信息来源就是沿途的风景，壁画，以及男人的自言自语，某种意义上这带来了一种推理小说式的体验，你需要在文本中领略事件的来龙去脉，同时体验它压抑深沉的环境氛围。
亲爱的艾斯特取得了意想不到的小范围成功，本作为免费游戏的它在12年发布了付费版，并取得了80万的销量，可以说，近十年的步行模拟器很大程度上是由它启蒙的。
因此，以12年为分水岭，逐渐涌现出不少的步行模拟器游戏。
13年亮相的是著名的meta游戏史丹利的寓言和较为平庸的到家（gone home）
14年问世的是解密风的伊森卡特的消失
15年艾斯特的工作室发行了同类型的万众狂欢
16年则有看火人与弗吉尼亚出现
而在17年，此类型的集大成者，艾迪芬奇的记忆横空出世，成为了此类型至今为止的最优者
可能不少对此类游戏毫无兴趣的玩家会好奇，步行模拟器的卖点到底在哪?
在这个媒体资源空前丰富的时代，每个人都能输出自己的思想，因此思想的输出变得极为廉价，而接受者的地位却会被拔高，因此，门槛越高的思想输出方式就有着越大的不被接受的风险，导致晦涩隐喻的内容就会不受待见。尽管如此，这些晦涩的思想与表达依旧是存在的，步行模拟器就是一种方式。
事实上，接受他人的思想表达一直都有很大的风险，只要作者多加一点私货，或者在莫名其妙的地方整个活，接受者的思想就会收到极大的冲击，例子我就不举了，懂得都懂。所以很多人都会倾向于不去接受，晦涩的作品他们根本不会碰，也有的人沉迷于此类快感，不顾风险地追寻自己认为好的输出者，这两种选择没有高下之分，但体现在游戏上，我们就会发现后者经常会成为所谓的小众游戏爱好者，这并不意味着他们很优越，相反，他们可能已经踩过不知道多少雷了。
为此前的论述做一个总结，步行模拟器可以作为一个高门槛的思想输出方法，因此能吸引一些喜欢此类体验的玩家。事实上，它和同样强调探索的avg可能存在一些关系，但由于我对此没有足够的知识，就不献丑了。
在此基础上，我们来分析此类游戏的一些特性。
首先，第一个问题是，为什么要用步行模拟器这种形式，毫无疑问这种游戏的互动性基本不是很强，也没有刺激官能的要素，然而，正是因为这种自断一臂式的操作，让它能够把自己的叙事能力提高到大部分游戏所不能及的程度，玩法单一也就意味着玩家的注意力会完全集中于一点，制作者只要专注于此方面，就能高频度地向玩家提供信息，而不会让人一头雾水，因为这样的特点，相比大部分游戏，步行模拟器可以聚焦于很多与众不同的题材，可以选用不同的叙事方式，
另一个优点是，较小的游戏规模与如今相对成熟的游戏工业，让制作者能以较为低廉的成本做出不同的场景，美术效果和环境在步行模拟器中有很大的作用，我之所以这么说，不仅是因为它有着渲染气氛的作用，在很多此类游戏中，环境本身就承担着叙事的任务，尤其以艾迪芬奇的记忆而言，环境在这款游戏中达到了当代游戏的新高度，不同的房间布置在无言中传达了房间主人的个性，甚至在一些细节中暗示了主人的命运。可以这么说，在很多步行模拟器中，环境有着超越装饰的作用
步行模拟器还有一个特点，那就是它是第一人称的，你可能单纯地觉得这是为了提高代入感，但事实上，因为互动性的匮乏，步行模拟器往往更趋向于探索和体验，而不是扮演，更形象的说法是，在步行模拟器中看到的是别人的故事，因此在我看来，第一人称更多的意义是类似侦探小说的叙述主体，也就是说，以这个故事而言，第一人称对应的角色就是最适合展现故事全貌的人，同时，这个主体具体的身份也可以是一个谜题，伊森卡特的消失，艾迪芬奇的记忆都在这方面上做了文章，非常有趣。
上述特点事实上还是很笼统的，实际上的步行模拟器在风格和题材上都是各具特色，特点也不尽相同，但由于到目前为止出名的步行模拟器实在不多，所以我们就用穷举的方法来说说这些步行模拟器。
先从最早的亲爱的艾斯特说起
在所有步行模拟器中，艾斯特应该是互动性最低的一个，你能做的只有控制一个喃喃自语的男人在孤岛上乱走，然而，艾斯特依然是一部很优秀的游戏，优秀的文本质量和环境建模完美地融合在了一起，配合迷雾重重的故事，与四个风格迥异的场景与种种细节，成功营造出了一种哀伤中透着迷幻的气氛。虽然选取了悼念亡妻的题材，但艾斯特并没有直接表现哀伤，叙事主体的男子呈现的态度是思辨的，其文本很有些深度，艾斯特的氛围塑造与文本水平，我个人认为是步行模拟器中最优秀的之一，并没有被后来者超越，甚至也没有被他们自己超越。
史丹利的寓言
这游戏很难归类，它更为众人所熟悉的标签是meta游戏，举个不恰当的例子，meta游戏和游戏的区别就像文学批评和文学的区别，很难说史丹利的目的是对游戏这一创作形式进行批判还是呈现一段故事。
这游戏几乎是靠作者一个人的天才撑起来的，即便在meta游戏中有史丹利寓言这么强烈批判属性的游戏，据我所知也是不存在的，它很有创设性的给予了游戏四个视角两个阵营，呈现者阵营的游戏系统（游戏作者？）与旁白，接受者阵营的史丹利与玩家本人，史丹利的故事几乎都是两个阵营间不同角色的互动，它实现了大部分游戏都做不到的一点，即让玩家直接与游戏的底层逻辑对话。
现代游戏互动性的本质是什么，无非不过是选择而已，拟真度高的游戏也不过是多提供了一些选项，史丹利抓住了这个底层逻辑，因此哪怕是步行模拟器这一形式只要用好“选择”，就不会缺少互动性。
这样的策略让史丹利显得不是那么“步行模拟器”，但实际上这还是一部叙事游戏，只不过它的故事千变万化，且富有批判意味，而且它的叙事有着“选择”的成分，因此它包含了十几个不同的故事。
归家
归家是一部很有实验意义的作品，如果你情商比较高的话，应该就知道我的意思是这游戏有着不少的缺点，归家的故事发生在20世纪末的一个美国家庭，一个暴风雨之夜，家中的姐姐回到家中，发现妹妹离家出走，于是开始寻找原因，归家的核心机制是拾取/查看物体触发回忆，核心谜题则是揭开妹妹的下落，然而这游戏的故事非常简单，简单到什么程度呢？在触发前三个回忆后你基本上就能猜到故事的梗概了——没错，一个俗套的恋爱被父母反对然后私奔的故事，稍微有些不同的是，主角是两位女同性恋，此外，游戏中有一些不怎么明显的机关且缺乏提示的机关，总体感觉实在是索然无味，尽管某种意义上它为有核心谜题的步行模拟器树了一个榜样，但论其素质十分乏善可陈，最大的优点可能是还算有20世纪风格的家居布置。
值得一提的是ign给了归家9.5的超高分，对ign来说这种分数是很少见的，我们之前提到的艾斯特得到了8分，史丹利寓言得到了8.8分，而品质平平的到家则得到了9.5分的超高评价，并且编辑的评论是没有缺点，联系其故事题材，此件原因令人深思，因为涉及敏感话题，我就不多说了
伊森卡特的消失
这是一部很有风格的作品，在场景建模上制作组创作性的采用了结合实景照片的做法，因此画质显得极为真实，配合微恐怖的风格，代入感极强，游戏的内容是一个有着回溯犯罪现场能力的侦探应伊斯卡特的邀请调查一个据说有着不可名状怪物的地区的系列凶杀案，抛开几乎为0的地图指引，游玩过程中你会觉得这似乎就是一个普通的解谜游戏，虽有称道之处，但综合来看质量一般，然而，这款游戏最值得称道的一点是，制作组为了一个有极大反转的结局在流程中埋了不少伏笔，因此伊森卡特的结局在我看来在叙事游戏中算最优秀的一档，当然实际上这也是见仁见智的一件事，或许也有不少人觉得铺垫不足。
在步行模拟器中悬疑风格的作品伊斯卡特应该可以说是最成功的。
万众狂欢
这是一部和亲爱的艾斯特风格迥异的作品，它没有叙事主体，玩家以超然的眼光去回顾一座村庄全员蒸发的惨剧，我认为这是一部失败的作品，为什么呢。作为一个拼凑出故事全貌的游戏，万众狂欢很不幸的选择了把最大的悬念放在开头——凶手是形似光球的不可名状生物，而游戏的过程则是目睹居民怎么一步步迈向死亡，整个过程中的互动，只有不如不做的触发回忆过程有——跟着手柄按QTE。具体到故事，恕我直言是很无聊的，寥寥几语的场景中大部分缺少让人身临其境的氛围营造，整部游戏有着浓郁的宗教风格，因此部分场景会有种神圣感，但也就仅此而已了，没有悬念，没有细腻的情感，没有复杂精彩的故事，更没有氛围的营造，万众狂欢在我看来是一部平庸的游戏
看火人
在众多步行模拟器中，看火人是极其冷门的纯写实题材，它选取了森林看护员这一冷门的职业视角来叙述故事，然而它的美术风格却是抽象的大色块风格，这造就了看火人实中有虚的奇妙质感，不论看火人的故事如何，这样的题材与美术创新是优秀的且值得鼓励的。
主角亨利在爱妻患病后心灰意冷，因为酗酒被妻子家人排挤的他最后来到了荒无人烟的森林公园成为了火情瞭望员，我们可以看到，游戏的主题几乎已经确定为心灵的救赎，但看火人的呈现方式是特别的，因为职业的特殊性，从始至终能与亨利交流的只有一位名为黛利拉的女性，在一片孤独的瞭望塔中这似乎是亨利唯一的情感支柱，事实上，看火人最大的优点就是情感的细腻，整个游戏几乎就是亨利与黛利拉互相的情感激励与救赎，最后这场类似柏拉图之恋的关系随着因为火情观察员撤离而收尾。
值得一提的是，看火人神奇的在游戏中夹杂了不少悬疑的成分，这让看火人的基调显得有些奇怪，由一开始的悠闲巡逻转到紧张的解密，随后又在急转直下后收尾，尽管不算无聊，但前后依旧有割裂感。
尽管如此，凭借细腻的情感描写，看火人依旧是一部优秀的游戏。
弗吉尼亚
这是一款很奇特的游戏，即使在步行模拟器里，它也是交互性最差的一类，它使用了一种极为抽象的风格，整个游戏由很多不明所以，充斥着象征的片段组成，而将这些片段串联到一起不过是一些点触的操作，坦白的说，我只能分离地去欣赏这些场景，单从象征的角度来说这些场景单独拿出来还挺有意思的，但你很难把这些片段连起来，事实上不让你把他们连起来可能正是这游戏的目的，此外，该游戏使用了很罕见的古典风格配乐，配合上本就很魔幻的内容产生了一种难以言喻的奇特的氛围。总的来说，这真的是一个很难评价的游戏，如果你有些猎奇心的话倒可以尝试一下
艾迪芬奇的记忆
艾迪芬奇的记忆是一款很优秀的游戏，但它的意义不仅如此，可以说在对互动性的新尝试方面，艾迪芬奇是游戏界最前沿的一个，游戏在叙事上最大的优势就是互动性，大部分游戏选择了剧情分支，qte之类的通解，而艾迪芬奇的记忆则在此基础上作出了创新，单论最简单的字幕，往往只被放置在屏幕底部用于阐释信息，而艾迪芬奇则将它放置在了场景之中，伴随着主角的前进逐渐浮现在路边，如此一来字幕甚至兼任了指引的作用。
依我看来，艾迪芬奇的主基调可以用魔幻二字来概括。随着艾迪依次探索旧宅，我们进入了一个个家族成员死前的景象中，但我们透过屏幕看到的不仅仅是一个个纪录片式的景象，还有情绪的具象化，例如令人啧啧称奇的操纵漫画中的角色一段，操纵角色在悬疑漫画的分镜中行走，这是一种崭新且绝妙的传递恐惧感的方式，艾迪芬奇的互动形式总是新颖的，角色伴随着开罐头喃喃自语，在切鱼的流水线上展开与工作融为一体的幻想，手柄的两遥感分别控制现实与幻想世界，此类新颖的设想，艾迪芬奇有近十种，可以这是一款极为奢侈的堆砌创意的游戏。
艾迪芬奇的家族大都耽于幻想，他们的幻想往往与现实融为一体，以此呈现出的情景显得分外的魔幻，以游戏的形式来叙述这样的故事，这一模式提供了一种特别的审视真实世界与内心世界的视角，这样类似魔幻现实主义的创作手法可以说极为前卫和有趣。
毫无疑问艾迪芬奇的互动性与创意是它最耀眼的闪光点，在此的映衬下，艾迪芬奇的剧情似乎显得暧昧不清，多个家庭成员的死亡都没有得到明确交代，尽管在一个个情景中我们能在画面中感知到情绪的具象化，尽管艾迪芬奇家族一向有着早死的诅咒，但艾迪芬奇没有，至少没有直接透露任何家庭成员对于死亡的看法，在一部探讨死亡的作品中这点显得很奇怪，似乎它只想将死亡本身呈现出来，却不想对此发表任何议论，我们很难说艾迪芬奇有什么主旨，在死亡这个主题上，制作组显得分外的冷漠，只留下玩家在原地回味。Steam上艾迪芬奇的商店页面有这样一句差评，艾迪芬奇的记忆有着美化死亡的嫌疑，这对那些有自杀倾向的人来说似乎太不友好了。这并不是没有道理。
总结
步行模拟器始终是个小众的品类，它固然有着一些创作上的优点，但成本和受众的因素始终制约着这一类型，导致作品寥寥无几，但在步行模拟器其实不乏对游戏这一创作形式的革新，作为新时代的叙事向avg游戏与独立游戏的一大阵营，步行模拟器的身上其实或多或少蕴含着电子游戏未来的一大方向，即作为有才能的作者表达自己的一种方式，对此我报以极大的期待。

杀手47

2022年一月份，杀手3将解除一周年的独占，登录steam，而早在21年初，杀手3就成了一款有点话题性的游戏，这是因为游戏的一张重庆的地图，这一地图因为缝合了赛博朋克，老大哥等元素被指责有乳制品嫌疑。
在仔细讨论这件事前，让我们先来看看这是一个什么样的游戏。平心而论，作为一个系列续作，杀手3可以说还算合格，虽然刺杀方式上有缩水，但看得出制作组在氛围营造上投入了不少努力，有很多截一帧就是壁纸的远景或者特写。杀手系列可以说是一个好游戏，甚至可以说是刺杀游戏这一细分品类的霸主，但ioi是纯纯的懒狗，犯下了版本混乱，高价低质量dlc，违背承诺种种重大错误，ioi并不是一个好开发商，如果你骂ioi，我举双手赞成，但对杀手三3有没有乳，我认为还是要谨慎讨论。
我所好奇的是，杀手是不是一个拟真的游戏？
我想只要你玩过这个游戏，你就会知道答案是否定的，即便是游戏的核心——刺杀系统，也有很多方案并不具有现实可行性。，如果说起其他设定，就更没有真实性了，杀手三部曲的反派是一个势力遍及全球，由“社会精英”组成的阴谋论组织，我并不认为这样的组织有什么现实可行性，如果我们这种普通人都能知道这样的组织，那只有两个可能，1这样的组织情报保密工作很烂，那它早该被拿下来了2它故意泄露的，实际上我们对它一无所知，那就让我们一切的想法都成了臆测，阴谋论是一些无法质疑的假设，这样的假设我可以提出几百个。
当然，我们没必要对一个游戏上纲上线，即便涉及到阴谋论，也只能说杀手并不是一个拟真的游戏。那么，作为一个涉及到多个国家刺杀目标的游戏，杀手对其中的国家是怎么描写的呢？
摩洛哥在杀手里被描绘成政府软弱无能被军阀控制，甚至准备发动政变，我们且不论这是不是真的，无论如何这都不是什么很友好的描写，我们提到过的阴谋论组织的一位高层在法国有一个大葡萄酒厂，很符合我们对法国的刻板印象吧，然而这位律师有私人武装，甚至包括一队直接听命的狙击手，我想法国不会放任私人权利到这个地步。孟买的街头扛着步枪的武装士兵到处走，北欧的高端别墅区一栋不算特别大的别墅有十几个全副武装的保镖，这些对我一个中国人来说都觉得不合理，可见杀手这个系列根本没有多少写实性。
我们可以做一个总结了，无论从什么角度看杀手都不是一个贴近现实的游戏，特别是在zz方面，尤其口无遮拦，什么都编的得出来。
那让我们再看看重庆这张图，这张图有什么呢，赛博朋克+老大哥，大量的监控摄像头，华人街一样的街道和餐馆，秘密暗杀组织的不人道实验，改造人类街头的流浪汉，我们之前也说了，杀手的地图里编的成分很大，更何况设定上ICA最重要的实验室就在这里，与其说ioi想还原什么地方，倒不如说估计是他们看到一些关于重庆很赛博朋克的新闻，然后觉得可以蹭一下人设。试问这些元素有多少是真正不合适的呢，脑子正常的人都不会觉得现在有技术能操控人的思想或者改造人类吧，既然你不会觉得这些情节是真的，你为什么会觉得这座城市是真的这样呢？
当然，事实上这样的论述也是有模糊性的，你可以说不够还原就是不够尊重，也可以说法国，美国的图比中国的还原是歧视，在国际矛盾激化的今天，会在这样的事上比较敏感可以理解，但我想说，我希望并呼吁大家在至少在文娱领域多一些宽容，不要泛政治化，能疑罪从无就不要恶意去揣测。
47的目标有很多罪不至死，为了一己私欲杀死无罪者，这难道不是宣传不良价值观吗？但恐怕没人这么批评，为什么我们会在道德上对文娱作品这么宽容，在政治上却那么草木皆兵呢？
我很希望大家能多一些宽容，我也希望文娱作品无论何时都应该是一片不被zz过分染指的净土

408被封锁的涩谷

希腊神话将命运女神履行职能的过程写作织网，这无疑是一种极为贴切的比喻，对网状结构来说，在中心处的轻轻一拨，边缘处就是极大的震动，越是深入核心，就越是复杂，但所有分支无论看上去多么没有规律，最后都会收束到中心网点，我想这就是428的编剧想实现的叙事结构。 这样的结构需要极致的严谨和巨大的工作量，正如正统的本格派推理一样丝丝入扣，同时还要维持各个部分的信息量尽量均布，各个网点处都有关键悬念留待读者，但，他们做到了，7位主角的命运与城市里大大小小配角的命运，就这样纠缠在一起，并收束到了一个巨大的阴谋上，更令人称奇的是，尽管使用了这样的结构，制作组仍然做到了悬念的均布，几乎没有出现信息量失衡的情况。
于是，玩家得以在4月28日的涩谷当一天的命运女神，只要在一个个节点上轻轻拨正些许紊乱的蛛丝，蛛丝就会自然而然地化为网状，事实上没有我说的这么轻松，因为这些命运的线条起初似乎是绕成一团，理清它们的过程也少不了误解和错误。
为了确保这个过程的顺畅，85个bad end大部分都有提示，以每一小时为节点，只有理清一小时内的所有事件，命运才能向前推进，起初似乎是一些不成规律的线，但逐渐就开始交错，纠缠，而作为有着神力的玩家，只需要制造一些偶然，改变一两个小小的决定就能够造成一连串的蝴蝶效应。
对这种操控命运的讨论很容易回到一些宿命论的思潮上来，幸运的是428的编剧在这个方面却有着很积极的态度，于是在结局，命运的线条汇聚在一起，无数偶然交错下，产生的必然却孕育着希望，尽管多少有些日式的大团圆味道，但流露出的价值观确实积极的。
如果说这样精巧的叙事结构有没有问题，那么当然也是有的，叙事必须依靠逻辑的支撑，如此庞大的网状结构，逻辑当然不可能天衣无缝，事实上依然有很多巧合和偶然，为了配合结构的需要，甚至部分主角也免不了当工具人，但你很难对此苛责什么，通过有限的角色实现如此复杂的剧本，不免要让一些角色承担过多的推进剧情的作用，相对来说编剧已经做得很不错了。
此外的问题是大部分日式游戏难免的幼稚气，叙事结构是精巧且充满悬念的，但一些抒情节点，以及一些过度夸张以至于模板化的人物性格，依然为其减色不少。不过我也能理解编剧，毕竟这种精密的结构确实很难填补完全恰如其分的内容
总的来说428在叙事结构方面可以说是当今电子游戏的最高峰水平，尽管它的其他部分可能只是优秀或者不错的程度，依旧是一款剧情类的神作

the longest journey

​无尽的旅途是一部好游戏，限于时代演出不是那么优秀，但在我看来这是一个堪比dao的开始，嗯，或许稍微差一点，但梦陨就比较令人无语，这游戏似乎试图用超过十小时的游戏时间做一个预告片，你可能觉得这时长对avg来说不算少，但如果我告诉你这游戏大胆地用了三个主角，并且交织得并不紧密呢？
顺便一提，这三个主角，其中一个是大杀四方的前作主角，但这作一直在低迷期，最后没顿悟出什么来还疑似4了，其中一个是半路插进来的肌肉兄贵，戏份比较迷的同时，最后的高光戏决定背叛自己的邪恶阵营，结果当场被关进大牢了，最后一个是戏份最多的本作主角，最后成为植物人，她的主线任务寻找前男友和阻止大boss一个也没完成，前作结尾的坑一点没填，又挖出了两三个新坑，甚至开头到结果贯彻始终，类似于where is alice 这样的主线问题都没回答
如果这还不能让你深恶痛绝的话，最后还有一个事实，续作在10年后，而且结尾不算高明(据说)
总之，我很怀疑avg能不能用好类似rpg的宏大世界观与对应的多线叙事，因为avg的核心是冒险，或者说类似的线性叙事结构的故事，你一般不会想在冒险的时候读上几十万字的设定文档，顺便卷进一个无数分叉的复杂故事线，就算有天才编剧能兼顾冒险感与宏大复杂的世界观，开发经费也未必能支持这个想法，最后，很可能的结果是，做一个大型预告片出来

冥界狂想曲

在某种程度上，冥界狂想曲一直作为avg的代表与异域镇魂曲齐名，当然说实话古早的操作和谜题对我来说着实难适应，所以我只是云了一下，但也幸好，古早的avg大部分是单线叙事，因此不是自己玩在剧情上也没什么区别。
总之，游戏的开场对我来说就很有意思，这指的是贯彻始终的颇有异域风味的冥界，我听说这是墨西哥的神话？先不管这个，虽然主题是死亡，但冥界狂想曲一直保持了一直诙谐的幻想风格，就连这些死者的再一次死亡也是用了开花这种充满生命力的方式表现，这给了整个游戏一种独特的风味或者说氛围，更不用说风趣且很有领导魅力的曼尼，与他同样有趣的哥们了。 一点小小的遗憾是，我想相对于主角二人组的丰满，反派npc的塑造就比较呆板，还有女主也没什么存在感，不知道怎么就开始感情线了。但其实其他npc倒也很风趣，所以总得来说，在角色塑造上是可以说优秀的。
此外，剧情不是那么严肃，但结构工整，伏笔与回收上也很巧妙，虽然涉及了一些政治戏码，但表现得方式是揶揄讽刺而不是说教，这很好，可以看出编剧无意在此深入，而是停留在一种人文主义上的关于善良与勇气的故事，这丝毫无损冥界狂想曲的格调，一个让人沉迷其中的好故事，作为玩家不应该要求其他的东西。
总得来说，我认为冥界狂想曲确实可以和异域镇魂曲同台竞技，它就像一部醇香的老电影，没有rpg式的沉浸扮演与纠结的选择，但作为一个故事就很精彩，游戏的形式也不是完全多余的，额，至少对喜欢解谜的人来说不算，其实，我倒认为gameplay上的乐趣主要是这个有趣的世界观。
rpg的乐趣来自于选择和扮演，以一个角色的立场自己去选择，然后承担后果，这很好，但avg则有所不同，avg的重心是体验，这个故事一直在那里，只是你能以某种方式见证它的开始的结束，这种微妙的差别恐怕在当代已经接近消失了，但在avg的黄金时代，这种不同还是很明显的，你可能会觉得这就是个故事绘本，毕竟去参加还是不参加，故事都会以一样的方式开始与结束，但一个好的故事总是会有为之入迷的听众，正如冥界狂想曲的结局曼尼所言
Nobody knows what's gonna happen at the end of the line, so you might as well enjoy the trip.

hello hello world

我很喜欢hello hello world对循环的处理，打比方的话就像是莫比乌斯环，通过正面来到了背面，又通过背面来到了正面，有点像年代记的true end，用真实创造了虚假，又用虚假谱写真实，这样的感觉

海沙风云

​rpg游戏的主角是什么人呢，是可以死无数次的人，又或者是可以做出无数次选择的人，我们都知道现实生活中你报了土木然后录取了，是不可能后悔，改去报汉皇法帝的，但游戏就不算事，回个档就行了，当然也有不让存档的，但归根到底，只要是跑在冯诺依曼架构计算机上的游戏，就要存储数据才能执行程序，要么在硬盘要么在内存，而有存储就能sl大法，众所周知，不受此限制的什么量子计算机，生物计算机就是造出来了，现在也没开发商能在这些架构上做游戏
这样我们就能得到一个有趣的结论，主角不是人，也不是角色，他是若干有不同命运角色的集合，这取决于游戏给了多少选项，要是一个游戏每个角色都可以被操作，那么主角就是游戏角色的全集
如此立论，主角必然是一定程度上模糊的，不透明的，但有意思的是，虽然我这么说，但玩家选项构成的主角又必然是主角的子集，但对玩家来说这就是主角，这样有意思的地方就出现了，这个子集可以只有一个元素，也就是说主角对玩家可以是单个角色
说来说去好像这只是选择不同，但我发这些议论的原因在于，这种选择也可以是一种叙事，意思是，有的开发商会耍小聪明，他说所有世界线的主角都是一个人，他在不同时间线跳来跳去，最后回归到一个true end，就像用一个递归函数去解决问题，解决中用到了复数个函数，但这些函数都是一个函数，因此其实只用了一个函数，这样一来主角又是复数的又是单数了，让游戏分类学的爱好者们头疼不已(当然这个学说是我瞎编的)

​我和制作组一样对国产极乐迪斯科的说法不太认同，至少目前不太认同，首先很明显迪斯科的完成度高的多，而海沙虽然还不能盖棺定论，但某些不可言说的原因就觉得了制作组不可能在内核上有和迪斯科重合的地方，如果有人不同意以上观点，请比较一下两款游戏的开场画面文本不同之处
港式警匪片也没什么不好的，我的建议是商业作品大家乐呵乐呵得了，要是哪个东欧哥一看chinese disco?玩了发现别说xx,xx尺度都没到，这多尴尬

海猫与推理avg

在我看来巧舟是个有着很明显才气的作者，但是这种才气并不能支撑他到完美的地步，这就是说逆转里bug和牵强的地方不少，但1-4部总得来说打完还是会觉得不错，大逆转里这种特点就更明显了，主角团和很多角色都很有意思，但前期的法庭部分依旧无聊，此外，就悬疑作品来说，巧舟在平衡谜题和人物塑造上做得很好，这也是逆转系列目前有不小同人热度的原因
打越我只玩过极限脱出和梦境档案那两部，在我看来就像一个以奇取胜的作者，并且在这点上非常偏执，揭晓谜底的时候确实很震撼，但倒过去看人物行为怎么看怎么不对，巧舟笔下的人物大部分是有可以理解目的的，现实人物也可能做一样的事，打越笔下的人物，配合那些神神叨叨的设定，就非常的，难以理解，甚至有前作主角在续作打酱油的神秘操作
小高我懒得评价，我只能说他的诡计等设置只有在浓度比较高的二次元才成立，客观来说谜题还行，但玩小游戏推理太逆天了
然后就是最近接触的龙骑士07，这位很难说写的是不是推理剧，毕竟以上三位不会让你在主角视角看到幻觉，最多掩盖一些主角能看到的事情，但寒蝉和海猫确实是可以推理的，就像海猫明说的一样，你要迎合出题者的规则和提示去推理，并且重点也不完全是推理，否则真相都知道了，打败真凶大部分作品都是结局几笔的事，不会像07一样化身爱的战士来个全员大决战，我觉得07的意图是这样的，大部分我这样的观众对how和who都非常关注，因此用这部分把我引进来，然后对我灌输why才是最重要的这个大道理，总的来说我对此持保留态度，我承认海猫的世界观下why比较重要，但现实世界还得who和how，这种太明显的说教，我不是很喜欢，但考虑到综合质量，海猫还是可以评个佳作起步的
这个世界有王道，就会有邪道，随后会有看似邪道的王道和看似王道的邪道，总的来说，王道的意思是，在地狱中奋战寻求生路这样一路向上的故事，为什么可以看似邪道，就是说这个地狱可以奇形怪状，像克苏鲁神话之类的故弄玄虚，但最后依旧是一路奋战到达某个终点，或者壮烈成仁
​邪道就是非王道，比较典型的就是原来都是一场梦式的结局，海猫无疑可以说是看似王道的邪道，因为大部分笔墨大书特书推理剧，诺克斯十戒，伪装成王道的寻求真相的推理故事，随后急转直下，原来是人格分裂+身份诡计，意思是百分之80的玩家视角都是虚假，这个角度讲，无疑是失败的推理剧

​但作为推理的推理倒是很有趣，也就是推理这个故事到底值不值得推理，是不是能推理，什么是推理，视读者评价的是推理部分还是推理的推理部分，评价就会两极分化，这无疑也是作者那么喜欢猫箱理论的缘由

天问

PST是一种少见的天问式游戏，从头到尾都在复读那句“什么可以改变人的本质?”，理所当然的这个问题没有答案，根据游戏流程来看，答案可能是痛苦，悔恨，爱，没有答案……这些选项中的一个，但其实重要的是回答问题的人，而不是答案
这可以说就是废话和故弄玄虚，也是我觉得pst不能说是什么哲理游戏的原因，并且很明显，这种天问如果没有令人满意的解答，整个剧本就完蛋了，因此很少有游戏敢用天问
当然也还是有的，bs2的“爱丽丝在哪?”多少有点天问的意思，但不完全是，爱丽丝是个存在，这是具体的，因此这多少是个具体的问题
生化奇兵无限的抛硬币也让我有这种感觉，正面，还是反面?这个问题很抽象，但非常模糊，让人对怎么回答毫无头绪，更像是对平行世界的引子,此外，我没记错的话，这个问题也没有问到海葬
最后一个候选者是巫师三的石之心，石之心没有问题，但我觉得结合浮士德原著，可以概括出一个问题:“灵魂可以出卖吗？”这个问题由杰洛特卖了自己开始，由镜子大师收取代价而结束，问欧吉尔德，问爱丽丝，也问杰洛特和玩家，卖出灵魂是一场豪赌，这种快感让一切都变得无趣，即使面对不公的命运，这种堕落也是值得的吗？最后的选择权交给了玩家，这就是一场标准的天问
2077的无名小卒和名扬天下似乎也首尾呼应，但到了dlc才给了无名小卒选项，未免拉得太长，所以也不行

十三机兵

​十三机兵的trick，虽然好像也不怎么想藏，和零时困境倒颇有相似之处，不过剧情的复杂度和合理性上水平很高，虽然我对青春校园题材实在没什么兴趣，但十三个人物交织的处理着实是多线叙事和网状叙事的教科书
其实最后搞点大逆转也不错，虽然有13个视角确实很难藏点东西到最后，总得来说这部作品的故事线像在炫技，但揭露真相却无比老实，因此离r11e17这种所谓神作差了点野心，所以说悬疑题材的爱好者是一种很神奇的生物，越是骗他们感情的作品就捧得越高，像r11的结局就像给玩家闷头一棍——你以为结束了，其实才开始，你以为你在玩游戏，其实游戏在玩你；从开始到结束的所有努力都是无用的，不过是个陷阱罢了，所谓的神作气质莫过于此
说回13机兵，其实这部作品和428也很有相似之处，都是一团乱麻逐渐理出来主线，只不过这游戏有13条主线，这是夸张的说法，其实基本每对cp有一样的目的，所以可能就六七条主线，这种结构有一个技巧，逐渐理出头绪时是最有意思的，一股绳了就无聊了，因此需要一个简短有力的结局，以及逐渐加速的节奏；但是十三机兵这个战棋玩法着实拖时间，还有日系游戏经典的数值深坑，这是十三机兵离神作最远的地方

古诺西亚

先说结论：部分人设比较有意思，结局挺让人感动的，但过程太折磨了，总得来说建议玩个开头熟悉一下流程，然后云到结局
以下是对缺点的详细阐述：

  1. 玩法创新是有的，但整个系统和ai支撑不起合格的狼人杀体验，人物条目的解释条件过于苛刻，可以说完全就是拖时间，看了一些评测和流程视频都在100loop以上才能进真结局，其实纯剧情流程也就最多50个loop上下
  2. 剧情有些水平，但基于1，节奏可以说一塌糊涂，和同类，例如人狼村比，完全没有紧张刺激感，，而且文本量，估算的话最多已经人狼村的一半，个人体验上最多和人狼村打平
  3. 第二点是说的主线流程，但本作有15个人物，大部分和主线无关，而且文本量太小，例如一个角色条目和其教育经历有关，那么这个教育体系有什么特点，和这个人物现在的性格有什么关系，都没有拓展，此外，真结局其实只涉及个位人物，却需要解锁所有角色条目，这个条件虽然和某个设定有关，但还是很强行

总的来说，这个游戏剧本质量是有的，但体量和完整度上过于匮乏，在我看来80%左右的好评率是更合理的

be

有一种典型的be或者ne是：奋战后什么也没有改变
这个类型也有细分，比如最后虽然功败垂成，但主角得到了救赎，这种属于be中的he,还有最后不过是回到了原点，这种是ne，还有奋战后结果更差的，这种属于搞人心态的be中的be
第一种其实还挺多的，例如jojo6，当然新世界大概也算改变……
第二种的例子是jojo7，最后乔尼不过是回到了原点，或者极乐迪斯科，到头来除了金的友谊，不过也是回到糟糕的原点；以及东方年代记的te，从幻想乡的毁灭回到幻想乡的诞生，而且这两者其实是一回事
第三种例子就很难找，个人观点me3的绿光结局应该算，全银河系变成融合怪，还不如毁灭了；又或者东方年代记的ce，苟延残喘还不如来个痛苦；蝴蝶效应应该也算，或者说蝴蝶效应的结局很难这么分

辐射:新维加斯

新维加斯的网状叙事和蝴蝶效应，确实是rpg史上的奇迹，不过这样让我非常患得患失，也就是典型的过高的自由会让人无所适从，这也是为什么近年的rpg不会这么强调网状了，能树状就不错了
话说结局是字面意义上的ppt也是挺难绷的，还不能跳过人生，这也是个微妙的点，要是后果太强，就会影响整个所谓的开放世界，要是没有后果，那选择就没有意义，因此只能用ppt这种微妙的展示方法显示选择的影响，信使的选择到底有影响吗，如有
当我们讨论rp时，我们在讨论什么？
在大部分rpg游戏里，把口才点满，可以与大部分没完全疯的boss交涉，嘴炮避免战斗，把逻辑或者感知点满，就可以观察到绝大部分角色的明显谎言或者自相矛盾，我们称之为rp，因为我们选择了把角色培养成演讲家，侦探……我们必然得到这样的后果
但是，过程在哪里呢？福尔摩斯是怎么推理出矛盾的，口才大师是怎么挑选言辞的，这些很难展现，就算展现了也没什么人会买，这么一来文本量能翻一倍
同理，我们在black souls把能看到的npc全图了，这是结果，为什么图，用什么方式图，则无法控制
这是一个本质性的矛盾，玩家不等于角色，你捏一个大侦探出来，现实里没几个推理小说能猜到凶手，所以我们要rp一个在rp的玩家，这才是rp的本质 辐射可能是近年唯一一个集齐两个“大厂”的ip，你可能想说博德之门，但博得12早没几个人知道了，当代生软和老生软也完全不是一回事，并且博得12没那么多变性人和男女同性恋，和现在的生软死忠粉不重合
这就导致一个很幽默的现象，你不能用辐射粉这个标签定义这个ip的受众，因为可分为三个阵营，遗老，黑曜石正统派和杯赛正统派，如果你问可不可以都喜欢，很遗憾，由于大家最爱的Mr陶德把fnv的设定一口吃了，阵营选择上前两派和杯赛派完全是水深火热之势
更有意思的是什么呢，这两个b字头厂现在都在微软旗下，也就是说他们应该，大概，是一家人，结果演了一出典中典的兄弟内斗,应了那句经典的
wars, wars never change
我的猜测是这样的，微软虽然财大气粗，但在游戏界只是小打小闹，经费就那么多，陶德要去追他的nasa朋克梦，就得要微软大爹出米，大家都是旗下工作室，零和博弈，那不给黑曜石这边踩一脚，毕竟不说商业上不错的辐射4，76居然实现了玩家一边骂一边抢着掏钱的神秘现象，陶德的口才点了多少想必不用多说，拿捏个办公室政治简直手到擒来，遗老随便骂吧，骂完辐射76别忘了氪金，星空dlc别忘了买

巴别号

我不知道该不该这么说，优秀到初步印象不会觉得是国产的独游，因为在我印象里国游很少有天马行空的幻想世界观，要么是武侠修仙这种成熟题材，要么有什么现实原型，或者新瓶装旧酒，巴别号初步印象对我来说就像日本近年很火的新本格在游戏上的体现；话说上一个让我怀疑是不是国产的还是帕斯卡契约，不过类魂毕竟也是个成熟类型，而巴别号几乎没有先行者，玩法是经典avg，有点微创新，而设定上我是想不到类似的前辈，这种独游基本是奔着大亏去的，国内毕竟发展中国家，这种纯为了理想的独游很难不支持

陶德

​老滚5的某个纪念版叫特别版，为什么不叫一些更具体的名字呢，我猜是陶德这小子也拉不下脸了，因为你会发现这个版本只有一种特别——bug特别多
大概一两个重要支线卡进度无法触发，你可能会说还有万能的控制台，然而我在贴吧搜到了同款bug，然后学着试了试控制台调进度或者重置，还是没用，npc像4了一样一动不动，很难想象一个纪念版会有这种情况
近年bug出名的游戏有什么呢，无疑是首发2077，但2077我还真没遇到重要支线无法触发的bug，大部分bug体现在显示层面，要是分开客观打分，我会说2077初版完成度更高，至少我能体验完所有主支线，而这，就是我们世纪神厂杯赛的含金量，我不是说游戏不行，但态度太差了，甚至至今steam的天际特别版都没有官中和创意工坊，人家恩达瑞尔还要单开个游戏页面

命运石之门

“欺骗世界”确实是e17首创，而且在我看来揭晓答案的一瞬间比石头门还惊艳，但缺点是白开水一样的节奏以及人设，石头门我看评论都说什么前期节奏慢，但对经历e17洗礼的我来说前期简直跌宕起伏
但不说这些了，毕竟做e17的时候经费和年代限制比较大，单论诡计的话，毫无疑问的e17更加复杂精巧，登场角色几乎人人一个trick，但在时间线的复杂度上石头门无意抓住了“欺骗世界”这个点进行了拓展，e17里“欺骗世界”是灵机一动想出来的，一个出彩的收尾，但在石头门里是贯穿全剧本的主线，有无数的铺垫，无数次苦苦求索，跨越了无数次的牺牲和努力，情感力度上远超e17这个前辈
这算一种微妙的差别，打完e17会有一种惊艳感，石头门没有那么多惊艳感，我以前都吐槽打越式伪科学，这波科学adv着实更胜一筹，如果是e17里是新本格式的设定式推理，石头门就是探讨规则或者说设定的纯实验，因为不知道完全的规则，推理无从谈起，取而代之的是一种感动，这种感动一是历经劫波终于he的感动，二是做了那么多次实验，终于理清了世界线理论是个什么东西
不过我不是搞科研的，至少还没开始搞，所以应该胸针寻找跳线的方法应该类比我debu更感同身受，这点来说确实是"科学adv”，科研里痛苦和快乐的比例大概正如凶真经历的be世界线和he世界线比例

梦

如何反驳“这一切都是xx角色的一场梦”之类的说法
其实很无聊，因为延续下去可以说“这个世界也是我的一场梦，其他所有人都是我幻想出来的”，然后双方都无法证否对方的说法，陷入死循环，计算机学科里叫循环等待

一切都是梦，这是个假说，不具备可证伪性，也就是恶魔的证明，这样的命题我可以提一千个，但是没有意义，不可证伪的命题不是科学，非科学的讨论只是浪费时间，因为讨论就是为了说服对方，而且是用逻辑上的证明，无法证明就无法讨论

文字游戏

我玩文字游戏基本都在快进，比较典型的是石头门，不啰嗦，但大部分是平铺直叙，很好猜人物行为，加上lab全是老面孔，看到发生什么事就能猜到人物行为了
比较啰嗦的是寒蝉和海猫，出题篇还好，只有一些日常要量子速读，解题就麻烦了，07的核心诡计就一两个，差不多猜到之后就只能快进了，寒蝉后期初中生大战雇佣兵，海猫则是大段感情戏，和文字描写的魔法大战……有点汗颜了。还有十三机兵，节奏其实挺快，但我实在不想看高中生谈恋爱……
处理的比较好的是打越巧舟，巧舟不说了，除了搜查部分节奏都飞快，打越好在谜题层出不穷，除了e17也没有日常，坏处是玩起来很累，但基本不用快进，解题部分还得想半天，但最近的ai系列又开始卖人设了，特别是涅槃那部，实在太old school，梦回上世纪的gal人设，可以说从头快进到尾。人狼村也不错，男主油滑又聪明，基本每步都是最优解。
最教科书的是428，基本每一个小时都有反转或者小高潮，堪称节奏控制之王，感情戏也不长，几乎没用跳过，但文字显示速度感人，ce开了三倍速

梦灯花

优缺点很明显的作品
优点:美术质量高，世界观有新意且较为完整，没有日式二次元不死人的团团圆圆风气，基调偏严肃，故事总体是完整的，现在史低+捆绑包50块还送设定集，畅玩15-20小时左右，性价比可以

缺点:战斗系统充其量4399水平，战力也很奇妙，此夜说是普通光使出身，好像天赋也不如绚夜，怎么回到现实后还是第一梯队战力，没人奇怪吗，至少可以提一嘴祝福之花吧
角色太多，塑造不够虽然立绘好看，但明显戏份不够分，有最后支线草草了事的，又用来关键时刻死掉渲染气氛的工具人，最后下来我没几个印象深刻的角色，而且主角组个人感觉也塑造一般，对比前作科罗莎行动力超强，每条线都在c，主角组大部分时间用在光使内斗和找各种人帮忙上，战力和前辈基本是平手或者略胜，贤者是不如的，智谋上也没多大体现，总不能烧点粮草就智将了吧，那你们为什么能当主角呢？当然如果你打完了，就会发现最难忍的是绽夜的塑造，主塔官僚主义固然不对，但绽夜自己也毫无建树，还和同门姐妹内斗，暗兽潮来了还满脑子内斗，完全就是匹夫之勇
部分发展强行，篇幅分配不当比如黑辉夜，封面c位，怎么也该和白辉夜差不多戏份吧，结果现实篇失踪了，无夜立绘这么精美，结果就一两句台词，古光使是什么社会形态，为什么社会矛盾不可调和了呢？现实篇里白辉夜的心路历程是怎样的，四个古代贤者的过去都是咋样的，塑造都很少，根本原因是这个任务机制过于割裂了，把剧情切得很碎，难以长篇大论地讲宏大的东西，角色又多，完全来不及一个个塑造，这点比起海沙绝对是退步的
最后稍微提一下虐主问题，核心视角是此夜这是肯定的，而此夜可以说是最惨角色之一了，姐姐保护过度，被逼放弃梦想泯然众人，天赋又比不上绚夜，现实里两边都背叛了，里外不是人，说是双人组但其实她不过是队长的“搭档”，也就是陪衬人，我是此夜也想着入梦了，她身边的人也太不做人了，绚夜不是好朋友吗，至少为此夜正个名，说此夜不只是“搭档”啊，玩下来想代入的人肯定非常痛苦，说实话，我打的最爽结局就是黑化
说是轻百，事实上就像东方的秘封组一样轻，就是说完全打不了lgbtq的tag，河豚倒也没必要冲着这个来……

装甲恶鬼村正

英雄篇的主旨就像巫师三的猎杀怪物cg，evil is evil，杀一个救100个人并不比杀100个人救一个人更善良，都是邪恶，恶无大小
然而杰洛特还是选择了杀一个人来救更多的人，所以他从不会把自己当做英雄
经常有人说，只要杀人都是恶，这种想法三观不正
不过还有更好的方法吗？杀了一个人的人就必须死?如果过失杀人呢？故意杀人必须死?如果被杀人曾害杀人者妻离子散呢？没有仇怨杀人必须死?如果被杀者身上有传染病，不烧掉尸体就会让周边化为地狱呢？杀好人必须死?如果好人只是伪装，私底下男盗女娼呢？
无论如何都很难归纳出绝对正确的可以杀人的场合，因此只能这么说，只要行动，就会有犯下罪孽的可能性，即使什么都不做也是一样，归根到底，道德议题都会是虚无的，只有圈定一个前提，才能讨论一个局部解，那么不同群体的局部解又会不同
因此，只要杀人都是罪，这种观点未必对也未必错，无法证实也无法证伪，只是一个观点，如果说这种观点错，同样也可以否定其他观点，这就是为什么人类文明发展到现在也依旧有无数的罪恶

复仇篇的发展远比英雄篇好猜，正义，英雄，这种概念是人类社会出现后才慢慢成型的事物，复仇则在更早之前就会出现
证据就是，我小时候收养了流浪狗，不服管教被我妈追着打过，因此它一看到我妈就夹着尾巴，这是恐惧，畏惧，但到了适当的时候就会产生仇恨，仇恨就是这样一种原始的感情，例如农村的狗对着闯进领地的人狂叫，也是对侵占领地这种行为的“复仇”
复仇只要伴随着生物本能就可以完成，这样的简单粗暴让其很多时候都不符合道德标准，正义更无从谈起，但作为人性中残留的兽性，这是必不可少的
因此，复仇没什么好绕的，只要去杀戮就行了，但为什么哈姆雷特这样的人会犹豫呢?这不过是因为他当了太久的人，忘了怎么当裸猿，也就是说复仇很简单，复不复仇才是麻烦的地方，脱下人皮经典，再穿上又难了

我是很不擅长阅读理解的那类人，语文很难考到平均分，因此我一般也看不出作者有什么私货，除了硬塞lgbt，黑龙也是龙这种太夸张的，因为我懒得猜作者到底什么意思，所以反而是最宽容的一类读者，对我来说作者写完的一瞬间，作品的解释权就被我这个读者垄断了，作者想要解释作品也只能以一个读者的身份来
因此我倒不觉得村正反战败，我看出的是反杀人，杀任何人都有可能杀错，所以不要杀比较好，这种说法很极端，因为别人打不过了的话难道不反抗吗？所以这个说法还有补丁，心怀大爱的人就不要反抗，以肉饲鹰，没有这么高尚的人以牙还牙也无所谓，只是不要觉得自己就是对的。这样说完了还是很极端，难道世界上不存在正义的战争，怎么就不能觉得自己是正义的?但是还有补丁，这是从宏观视角看的，因为缺少前提的情况下，恶人的一命和善人的一命没有方法裁量，善与恶也难以分辨，这个前提取决于不同的人和不同的价值观，也就是换一个朴素正义感的视角，善人杀恶人就是天经地义的正义。
这就绕了个大圈子回到了现实世界，为什么要这么麻烦呢，或者说为什么要这么极端呢？因为村正是为了醋包饺子，世界观下平民几乎没有半点希望，单人的武力可以灭国，毫无节制的强，你杀我我杀你，没几轮地球上就没人了，在这种特定情况下，很难说需不需要社会的存在，也很难说什么是道德准则，武力的使用会产生冲突，稍微多冲突几次地球就没人了，你以一个平民的视角看，不要使用任何武力也是个不错的结果，平民和那些超能力者已经不是同类了
绕到这种程度还是很极端，为什么就要因噎废食，说不定在地球没人前，正义的超人们把邪恶方杀完了，又可以建立一个天国。这当然也可以，唯一的问题是会死人，死掉很多无辜的人，也未必能成功，对那些，比如流弹打死的人来说，正义又成了邪恶
到最后我们就会发现一个朴素的道理，好人一次也不能出错，否则就成了恶人，村正部分角色的观点是，好人难做，那就什么都不做好了，或者以当恶人的觉悟去做好事
论证到这个结论，还是很极端，因为好心干了坏事的好人也可以认为还是好人，好人战斗死的人很可能比不战斗死的人少，更何况可能真的有超人，永远好心干好事，这样的论证逐渐开始虚无了，因为这样的假设可以无数次做下去
因此以上的一切只会是观点，无法像数学证明题一样完美的QED，同理，认为有私货的人也只是观点，我也可以假设作者的所想和我这些观点一样几乎等于什么都没说，因为换个类似现实的世界观一切就不同了

]]> <p>本文是对游戏杂谈的一个汇总</p> @@ -1012,30 +1012,28 @@ A.L.I.C.E(原曲：不可思议之国的爱丽丝)<br /> - 基于斯坦福cs106b的c++数据结构笔记 - - https://thinklive1.github.io/thinklive/16615/ + 基于c++ primer plus的读书笔记 + + https://thinklive1.github.io/thinklive/15197/ 2024-01-20T11:53:48.573Z 2023-11-27T12:47:59.687Z - 一些查找和排序算法

二分查找法 图片 最坏情况：log2n 寻找最小排序 图片 向前插入算法 图片

合并算法接受两个排序的 列出并将它们组合成一个 排序列表。 ● 虽然两个列表都是非空的，但比较它们的 第一要素。 删除较小的元素 并将其附加到输出。 ● 一旦一个列表为空，添加所有元素 另一个列表输出。 ● 它运行时间为 O(n)，其中 n 是总数 合并的元素数量。 图片 无限递归后的合并算法 图片 复杂度：nlog2n

容器类

set（集合）：无序不允许重复的容器类，可以添加删除元素 You can add a value to a Set by writing set += value; s. ● You can remove a value from a Set by writing set -= value; ● You can check if a value exists in a Set by writing set.contains(value)map(键值对的集合) 如果没有对应key的value，返回默认值（见定义文件） `vector vector的remove根据移除元素的索引有1-n的复杂度，移除尾部为O(1)，如果不在意索引，可以交换要移除元素和尾部元素再移除

哈希表

哈希表的负载因子α表示元素和表格键数量的比，决定了查找速度

检查表中是否存在元素

● 计算元素的散列码。 ● 跳转到表格中的那个位置。 ● 向前扫描——必要时环绕——直到项目或一个 发现空插槽。

将元素插入表中

● 如果项目已经存在，什么也不做。 ● 否则，跳转到元素哈希码给定的槽。 向前走——必要时环绕——直到一个空白点或 找到墓碑插槽。 然后，将项目放在那里。

从表中删除一个元素

● 跳转到由元素的散列码给定的槽。 ● 向前走——必要时环绕——直到物品或 发现空插槽。 如果找到该项目，请将其替换为 墓碑。

“罗宾汉哈希表”

  • 如果插入的值比其将插入的位置的值距离索引更远，则替换插入值和当前值
  • 删除值时，将后其离原键远的元素前移
  • ★ 罗宾汉哈希一览 ★
  • 检查表中是否存在元素：
  • ● 跳转到表中由元素的散列码给出的位置。
  • ● 向前扫描——如有必要环绕——记录有多少步 你拿走了。 当您找到该项目、找到一个空白槽或找到一个 离家更近的空位比你走的步数还多。
  • 将元素插入表中：
  • ● 如果该元素已在表中，则什么也不做。
  • ● 跳转到由元素的散列码给出的表槽。 向前扫描 - 换行 如有必要，四处走走——记录所走的步数。 如果你找到一个 空插槽，将元素放在那里。 否则，如果当前插槽已满并且 比您插入的元素更靠近家，将要插入的项目放在那里， 替换那个位置的元素，然后继续插入，就好像你 正在插入被置换的元素。
  • 从表中删除一个元素：
  • ● 跳转到由元素的散列码给定的槽。
  • ● 向前走——如有必要，环绕——直到物品或空槽被放置 成立。 如果找到该项目，请将其删除。 然后，继续前进——包裹 around as necessary – 将表中的元素向后移动一个槽位，直到 找到空插槽或位于其原始位置的项目

string类

str::npos表示容器的最后一个成员位置 if (s.find("e") != string::npos) //find函数找不到时返回npos if s in str: string obj; obj.substr(int pos) //pos为要包含的第一个字符串的位置 std::string a = "0123456789abcdefghij";

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

    // count is npos, returns [pos, size())
    [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub1 = a.substr(10);
    [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub1 << '\n';

    // both pos and pos+count are within bounds, returns [pos, pos+count)
    [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub2 = a.substr(5, 3);
    [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub2 << '\n';

    // pos is within bounds, pos+count is not, returns [pos, size())
    [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub4 = a.substr(a.size()-3, 50);
    // this is effectively equivalent to
    // std::string sub4 = a.substr(17, 3);
    // since a.size() == 20, pos == a.size()-3 == 17, and a.size()-pos == 3

    [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub4 << '\n';

    try {
        // pos is out of bounds, throws
        [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub5 = a.substr(a.size()+3, 50);
        [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub5 << '\n';
    } catch(const [std::out_of_range](http://en.cppreference.com/w/cpp/error/out_of_range)& e) {
        [std::cout](http://en.cppreference.com/w/cpp/io/cout) << "pos exceeds string size\n";
    }
}
输出：
abcdefghij
567
hij
pos exceeds string size

`replace和insert str1.insert(start, str2) str1.replace(start, length, str2)

一些实现

优先队列

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
# include "HeapPQueue.h"
using namespace std;

HeapPQueue::HeapPQueue() {
    elems = new DataPoint[INITIAL_SIZE] {};
    for (int i=0;i<INITIAL_SIZE;i++)
    {
        elems[i].weight=0;
    }
    allocatedSize=INITIAL_SIZE;
}

HeapPQueue::~HeapPQueue() {
    delete [] elems;
}

int HeapPQueue::size() const {
    return logicalSize;
}

bool HeapPQueue::isEmpty() const {
    return logicalSize==0;
}

void HeapPQueue::enqueue(const DataPoint& data) {
    if (logicalSize+1<allocatedSize)
    {
        if (logicalSize==0)
        {
            elems[1]=data;
            logicalSize++;
        }
        else
        {
            logicalSize++;
            int i=1;
            while (data.weight>elems[i].weight && i<=logicalSize && elems[i].weight!=0)
            {
                i++;
            }
            if (i<logicalSize)
            {
                DataPoint temp=elems[i];
                elems[i]=data;
                for(i;i<logicalSize;i++)
                {
                    DataPoint temp_plus=elems[i+1];
                    elems[i+1]=temp;
                    temp=temp_plus;

                }
            }
            else
            {
                elems[i]=data;
            }

        }
    }
}

DataPoint HeapPQueue::peek() const {
    return elems[logicalSize];
}

DataPoint HeapPQueue::dequeue() {
    DataPoint to_return=elems[1];
    if(!isEmpty())
    {

        for (int i=1;i<logicalSize;i++)
        {
            elems[i]=elems[i+1];
        }
        elems[logicalSize]={};
        logicalSize--;
    }
    return to_return;
}

计数排序

首先算出最大值，然后用一个数组的索引存储待排序数组的成员，其索引对应值存储出现次数，然后用两个同步的for循环和递增的next参数表示排序中的索引值来进行排序（也就是重新赋值）

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
53
54
/* Given a Vector<int>, returns the largest number in that Vector. */
int maxOf(const Vector<int>& values) {
    /* Bounds-check inputs. */
    if (values.isEmpty()) {
        error("Can't find the maximum of no values.");
    }
    
    int result = values[0];
    for (int i = 1; i < values.size(); i++) {
        result = max(result, values[i]);
    }
    return result;
}

/* Given a list of numbers, creates a histogram from those numbers. */
Vector<int> histogramFor(const Vector<int>& values) {
    /* Create a histogram with the right number of slots. Initially, all values
     * in the histogram will be zero.
     */
    Vector<int> histogram(maxOf(values) + 1);
    
    /* Scan across the input vector, incrementing the histogram values. */
    for (int value: values) {
        histogram[value]++;
    }
    
    return histogram;
}

void countingSort(Vector<int>& values) {
    /* Edge Case: If the array is empty, then it's already sorted. This is
     * needed because we can't take the maximum value of an empty vector.
     */
    if (values.isEmpty()) {
        return;
    }
    
    /* Form the histogram. */
    auto histogram = histogramFor(values);
    
    /* Scan across the histogram writing out the appropriate number of copies
     * of each value. We track the index of the next free spot to write to,
     * as it varies based on how many items we've written out so far.
     */
    int next = 0;
    for (int value = 0; value < histogram.size(); value++) {
        /* Write out the right number of copies. */
        for (int copy = 0; copy < histogram[value]; copy++) {
            values[next] = value;
            next++;    
        }
    }
}

错题集

递归的效率优化

每次递归都会创造所有变量的临时复制 基于递归的这种性质，它会需要巨大的时间和空间来完成任务，并且会造成算力上的浪费。 通过记忆表机制能部分解决这个问题，方法是每次递归的返回值都会按索引存入一个表格，并且每次递归前查询表格中是否有结果，这样可以让每个临时副本的运算结果能被所有函数共享。

递归计算给定元素的不同结构哈夫曼树的数量

对每个给定元素集来说，首先要做到是确定根节点元素是第几个大的元素，确定之后，左子树和右子树的元素数也随之确定，在此之后分别对左节点和右节点作为根节点做同样的递归

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

int numBSTsOfSize(int n) {

  /* Base case: There’s only one tree of size 0, namely, the empty BST. */
  if (n == 0) return 1;
  
  /* Recursive case: Imagine all possible ways to choose a root and build the
   * left and right subtrees.
  */
  int result = 0;
  
  /* Put the the nodes at indices 0, 1, 2, ..., n-1 up at the root. */
  for (int i = 0; i < n; i++) {
    /* Each combination of a BST of i elements and a BST of n - 1 - i elements
     * can be used to build one BST of n elements. The number of pairs of
     * trees we can make this way is given by the product of the number of
     * trees of each type.
     */
     result += numBSTsOfSize(i) * numBSTsOfSize(n - 1 - i);
  }
  
  return result;
}

递归解决吃巧克力问题

求出吃法数量

1
2
3
4
5
6
7
8
9
10
11
12
if (numSquares<0)
{
    error("输入数据不能为负数");
}
else if (numSquares<=1)
{
    return 1;
}
else
{
    return numWaysToEat(numSquares-1)+numWaysToEat(numSquares-2);
}

打印每种吃法

`需要一个辅助向量储存历史记录

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
/* Print all ways to eat numSquares more squares, given that we've
 * already taken the bites given in soFar.
 */
void printWaysToEatRec(int numSquares, const Vector<int>& soFar) {
    /* Base Case: If there are no squares left, the only option is to use
     * the bites we've taken already in soFar.
     */
    if (numSquares == 0) {
        cout << soFar << endl;
    }
    /* Base Case: If there is one square lfet, the only option is to eat
     * that square.
     */
    else if (numSquares == 1) {
        cout << soFar + 1 << endl;
    }
    /* Otherwise, we take take bites of size one or of size two. */
    else {
        printWaysToEatRec(numSquares - 1, soFar + 1);
        printWaysToEatRec(numSquares - 2, soFar + 2);
    }
}

void printWaysToEat(int numSquares) {
    if (numSquares < 0) {
        error("You owe me some chocolate!");
    }

    /* We begin without having made any bites. */
    printWaysToEatRec(numSquares, {});
}

递归解决翻煎饼问题

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
bool isSorted(Stack<double> pancakes) {
    double last = -1; // No pancakes have negative size;

    while (!pancakes.isEmpty()) {
        /* Check the next pancake. */
        double next = pancakes.pop();
        if (next < last) {
            return false;
        }

        last = next;
    }

    /* Pancakes are in increasing order! */
    return true;
}

/* Given a stack of pancakes and a flip size, flips that many pancakes
 * on the top of the stack.
 */
Stack<double> flip(Stack<double> pancakes, int numToFlip) {
    /* Take the top pancakes off the stack and run them into a queue.
     * This preserves the order in which they were removed.
     */
    Queue<double> buffer;
    for (int i = 0; i < numToFlip; i++) {
        buffer.enqueue(pancakes.pop());
    }

    /* Move the pancakes back. */
    while (!buffer.isEmpty()) {
        pancakes.push(buffer.dequeue());
    }

    return pancakes;
}

Optional<Vector<int>> sortStack(Stack<double> pancakes, int numFlips) {
    /* Base Case: If the stack is sorted, great! We're done, and no flips
     * were needed.
     */
    if (isSorted(pancakes)) {
        return { }; // No flips
    }
    /* Base Case: If the stack isn't sorted and we're out of flips, then
     * there is no way to sort things.
     */
    else if (numFlips == 0) {
        return Nothing;
    }
    /* Recursive Case: The stack isn't sorted and we still have flips left.
     * The next flip could flip 1, 2, 3, ..., or all N of the pancakes.
     * Try each option and see whether any of them work.
     */
    for (int numToFlip = 1; numToFlip <= pancakes.size(); numToFlip++) {
        /* Make the flip and see if it works. */
        auto result = sortStack(flip(pancakes, numToFlip), numFlips - 1);
        if (result != Nothing) {
            /* The result holds all the remaining flips but doesn't know about
             * the flip we just did. Insert that flip at the beginning.
             */
            result.value().insert(0, numToFlip);
            return result;
        }
    }

    /* If we're here, then no matter which flip we make first, we cannot
     * get the pancakes sorted. Give up.
     */
    return Nothing;
}

递归解决天平问题

1
2
3
4
5
6
7
8
9
10
11
12
13
bool isMeasurableRec(int amount, const Vector<int>& weights, int index) {
  if (index == weights.size()) {
      return amount == 0;
  } else {
      return isMeasurableRec(amount,                  weights, index + 1) ||
             isMeasurableRec(amount + weights[index], weights, index + 1) ||
             isMeasurableRec(amount - weights[index], weights, index + 1);
  }
}

bool isMeasurable(int amount, const Vector<int>& weights) {
    return isMeasurableRec(amount, weights, 0);
}

想象一下，我们首先将要测量的数量（称为 n ）放在天平的左侧。 这使得规模上的不平衡等于 n 。 想象一下，有某种方法可以测量 n 。 如果我们一次将一个重量放在秤上，我们可以查看第一个重量的放置位置（假设它的重量为 w ）。 它必须：

  • 向左走，使规模上的净不平衡 n + w ，或
  • 向右走，使规模上的净不平衡 n – w ，或
  • 根本不习惯，留下净不平衡 n 。

如果确实有可能测量 n ，那么这三个选项之一必须是实现它的方法，即使我们不知道它是哪一个。 然后我们要问的问题是，是否有可能使用剩余的权重来衡量新的净失衡——我们可以递归地确定！ 另一方面，如果无法测量 n ，那么无论我们选择哪个选项，我们都会发现没有办法使用剩余的权重来使一切平衡！

如果我们递归地进行，我们在这里，我们需要考虑我们的基本情况。 我们可以选择的选项有很多。 一个简单的方法如下：假设我们根本没有任何重量，我们被要求查看是否可以不使用重量来测量某些重量。 在什么情况下我们可以这样做？ 好吧，如果我们称重的东西有一个非零重量，我们就不可能测量它——把它放在秤上会使它倾斜到某一边，但这并不能告诉我们它有多少重量。 另一方面，如果我们称量的东西是完全失重的，那么把它放在秤上也不会导致它倾斜，让我们相信它确实是失重的！ 因此，作为我们的基本情况，我们会说当我们减少到没有剩余权重时， ，我们可以精确测量n 如果 n = 0 。 考虑到这一点，这是我们的代码：

递归解决找零问题

不使用记忆的情况

`从第一个硬币开始遍历，并穷举它的所有枚数，将其作为下一枚硬币的参数传递

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
int fewestCoinsFor(int cents, const Set<int>& coins) {
    /* Can't have a negative number of cents. */
    if (cents < 0) {
        error("You owe me money, not the other way around!");
    }
    /* Base case: You need no coins to give change for no cents. */
    else if (cents == 0) {
        return 0;
    }
    /* Base case: No coins exist. Then it's not possible to make the
     * amount. In that case, give back a really large value as a
     * sentinel.
     */
    else if (coins.isEmpty()) {
        return cents + 1;
    }
    /* Recursive case: Pick a coin, then try using each distinct number of
     * copies of it that we can.
     */
    else {
        /* The best we've found so far. We initialize this to a large value so
         * that it's replaced on the first iteration of the loop. Do you see
         * why cents + 1 is a good choice?
         */
        int bestSoFar = cents + 1;
        /* Pick a coin. */
        int coin = coins.first();
        /* Try all amounts of it. */
        for (int copies = 0; copies * coin <= cents; copies++) {
            /* See what happens if we make this choice. Once we use this
             * coin, we won't use the same coin again in the future.
             */
            int thisChoice = copies + fewestCoinsFor(cents - copies * coin,
                                                     coins - coin);
          /* Is this better than what we have so far? */
            if (thisChoice < bestSoFar) {
                bestSoFar = thisChoice;
            }
        }
        /* Return whatever worked best. */
        return bestSoFar;
    }
}

使用记忆进行优化

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
/* How few coins are needed to make the total, given that we can only use
 * coins from index startIndex and onward?
 */
int fewestCoinsRec(int cents, const Vector<int>& coins, int startIndex,Grid<int>& memo) {
    /* Base case: You need no coins to give change for no cents. */
    if (cents == 0) {
        return 0;
    }
    /* Base case: No coins exist. Then it's not possible to make the
     * amount. In that case, give back a really large value as a
     * sentinel.
     */
    else if (startIndex == coins.size()) {
        return cents + 1;
    }
    /* Base case: We already know the answer. */
    else if (memo[cents][startIndex] != -1) {
        return memo[cents][startIndex];
    }
    /* Recursive case: Pick a coin, then try using each distinct number of
     * copies of it that we can.
     */
    else {
        /* The best we've found so far. We initialize this to a large value so
         * that it's replaced on the first iteration of the loop. Do you see
         * why cents + 1 is a good choice?
         */
        int bestSoFar = cents + 1;

        /* Pick a coin. */
        int coin = coins[startIndex];

        /* Try all amounts of it. */
        for (int copies = 0; copies * coin <= cents; copies++) {
            /* See what happens if we make this choice. Once we use this
             * coin, we won't use the same coin again in the future.
             */
            int thisChoice = copies + fewestCoinsRec(cents - copies * coin,
                                                     coins, startIndex + 1,
                                                     memo);

            /* Is this better than what we have so far? */
            if (thisChoice < bestSoFar) {
                bestSoFar = thisChoice;
            }
        }

        /* Return whatever worked best. */
        memo[cents][startIndex] = bestSoFar;
        return bestSoFar;
    }
}

int fewestCoinsFor(int cents, const Set<int>& coins) {
    /* Can't have a negative number of cents. */
    if (cents < 0) {
        error("You owe me money, not the other way around!");
    }

    /* Convert from a Set<int> to a Vector<int> so we have a nice ordering
     * on things.
     */
    Vector<int> coinVec;
    for (int coin: coins) {
        coinVec += coin;
    }

    /* Build our memoization table. Since the number of cents left ranges from
     * 0 to cents, we need cents+1 rows. Since the start index of the coin
     * ranges from 0 to coins.size(), we make coins.size() + 1 columns.
     *
     * -1 is used as a sentinel to indicate "nothing has been computed here
     * yet."
     */
    Grid<int> memo(cents + 1, coins.size() + 1, -1);

    /* Now ask how many coins are needed to make the total, using any coins
     * from index 0 onward.
     */
    return fewestCoinsRec(cents, coinVec, 0, memo);
}

递归穷举付账单

递归机制：对第一个人来说，0-total所有金额都会付一遍，随后传递给下一个人，当只有一人时，付清所有余额并打印账单 传递参数：string,int的映射存储目前为止的账单，string集合存储所有付账者

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
void listPossiblePaymentsRec(int total, const Set<string>& people,const Map<string, int>& payments) {
    /* Base case: if there's one person left, they have to pay the whole bill. */
    if (people.size() == 1) {
        Map<string, int> finalPayments = payments;
        finalPayments[people.first()] = total;
        cout << finalPayments << endl;
    }
    /* Recursive case: The first person has to pay some amount between 0 and the
     * total amount. Try all of those possibilities.
     */
    else {
        for (int payment = 0; payment <= total; payment++) {
            /* Create a new assignment of people to payments in which this first
             * person pays this amount.
             */
            Map<string, int> updatedPayments = payments;
            updatedPayments[people.first()] = payment;
            listPossiblePaymentsRec(total - payment, people - people.first(),updatedPayments);
        }
    }
}
void listPossiblePayments(int total, const Set<string>& people) {
    /* Edge cases: we can't pay a negative total, and there must be at least one
     * person.
     */
    if (total < 0) error("Guess you're an employee?");
    if (people.isEmpty()) error("Dine and dash?");
 listPossiblePaymentsRec(total, people, {});
}

递归寻找完全平方数列

主要参数为sofar——用于存储目前的序列和一个set用于存储还没放入数列的数字，`确保这两者同时被传递，且其并集为所有数字

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
Optional<Vector<int>> findSquareSequence(int n) {
    /*Validate input.*/
    if (n < 0) {
        error("Don't be so negative!");
    }

    /* Build a set of the numbers 1, 2, 3, ..., n. */
    Set<int> options;
    for (int i = 1; i <= n; i++) {
        options += i;
    }
    return findSequenceRec(options, { });
}

Optional<Vector<int>> findSequenceRec(const Set<int>& unused,
                                      const Vector<int>& soFar) {
    /*Base Case: If all numbers are used, we have our sequence!*/
    if (unused.isEmpty()) {
        return soFar;
    }

    /* Recursive Case: Some number comes next. Try each of them and see which
     * one we should pick.
     */
    for (int next: unused) {
        /* We can use this if either
         *
         * 1. the sequence is empty, so we're first in line, or
         * 2. the sequence is not empty, but we sum to a perfect square
         *    with the previous term.
         */
        if (soFar.isEmpty() ||
            isPerfectSquare(next + soFar[soFar.size() - 1])) {
            /* See what happens if we extend with this number. */
            auto result = findSequenceRec(unused - next, soFar + next);
            if (result != Nothing) {
                return result;
            }
        }
    }

    /* Tried all options and none of them worked. Oh well! */
    return Nothing;
}

汉诺塔递归

假设有三座汉诺塔，start ,temp ,finish 对n层的汉诺塔问题，先考虑n-1层的，随后考虑n-2层，到最后只需要考虑两层问题，两层的汉诺塔非常容易解决，起点为start,终点是temp,临时塔为finish，最后我们得到temp上的两层汉诺塔 这时将start的3移动到finish塔，这时只要将两层汉诺塔转移到finish则完成了三层汉诺塔，这个过程中的起点为temp,终点是finish,临时塔是start 以此类推，四层塔基于三层塔，n层塔基于n-1塔，汉诺塔问题解决

1
2
3
4
5
6
7
8
9
10
11
int moveTower(int numDisks, char start, char finish, char temp) {
    if (numDisks == 0) {
        return 0;
    } else {
        int movesOne = moveTower(numDisks - 1, start, temp, finish);
        moveSingleDisk(start, finish);
        int movesTwo = moveTower(numDisks - 1, temp, finish, start);

        return 1 + movesOne + movesTwo;
    }
}
]]> + c语言部分

基本函数构成

将数组传递为函数参数

1
int fcname(int arg[],int n)

基本输入输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
- cin及其衍生函数返回一个iostream函数的引用，即支持
cin,get().get()
iostream的其他成员
- cout.put()显示字符
- cout.write()显示字符串
- cout<<flush刷新缓冲区
- cout<<endl刷新缓冲区并提供换行符
- dec,hex,oct控制输出数制
hex(cout)控制cout为16进制
- int width()返回字段宽度当前设置
 int width(int i)设置字段宽度，返回以前字段宽度 
 只影响下一次输出
 - fill()设置填充用字符
 - precision()设置精度，即保留几位小数
 - setf()设置各种输出格式
 - 流状态stream_state(eof,fail,bad)
 - cin.get(ch)读取下一个字符，跳过换行符和空白
 - cin.get()读取空白和换行符
 - cin.get()get的基础上读取到换行符并丢弃
 - cin.read()读取内容，但不会在末尾加空字符
 - cin.peek()读取输入流下一个字符但不抽取
 - cin.putback(ch)把一个字符放到输入流最前

文件输入输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
写入文件
ofstream fout;//ofstream继承ostream
fout.open("hello.txt");
fout << "i'm adding sth"
|| ofstream fout("hello.txt");
读取文件也类似
fin >> ch||string
关闭流
fout.close()
fin.close()
检测文件是否打开
if (!fin.is_open())
设置文件输入输出格式
ios_base::

基本逻辑运算符

break打断循环 continue，跳到更新表达式前开始执行 非const引用的函数不接受const参数

基本数据类型

结构数组

stname;
1
2
3
4
5
6
7
8
9
10
11
stname stobj\[int x] =
{
{}
{}
}
union(类似结构，但相同数据类型只存一种)
每个指针需要一个*用于初始化
int * intlist=new int [10]
delete-new
delete []-new []
typedef typename aliasname

名称空间

1
2
3
4
5
#ifndef HNAME_H
#define HNAME_H


#endif

如果在遇到另一个定义HNAME_H的头文件时，将他忽略

作用域： 1默认情况下，函数中声明的变量作用域位于代码块内，如果函数内外都声明一个同名变量，运行至内部代码块使用内部，离开代码块使用外部 2静态变量存在于整个程序运行周期，脱离作用域后只是无法使用并不消失 代码块外声明且不带static关键字：链接性外部，可以在其他程序使用 代码块外声明，且使用static：链接性内部，可以在整个程序使用 代码块内声明，且使用static：作用域于代码块内，但始终存在//由于静态变量只可以定义一次，所以即使离开代码块后变量依旧存在，且值不变，直到下一次修改 3运算符::放置于变量前时，使用同名变量（如果有）的全局版本 4namespace{

} 无法放置于代码块内，因此默认为全局名称，可以囊括声明和定义，可以随时添加 定义于类声明的函数自动成为内联函数

c++特性

class

1声明构造函数时，尽量使用explicit(显性转换)前缀，防止隐性转换带来的问题 mutable(摆动的)前缀声明变量，表示这些变量可能在const成员函数内被更改 用const_cast<>和static_cast<>与this指针可以实现const成员函数向非const的转变，反之则是错误的

2class初始化成员时，按构造函数声明变量的顺序，因此初始化成员时最好也以此顺序初始化 如果不希望class有copy和赋值(=)操作，则应该在private里定义copy和=运算符

3基类引用可以指向派生类对象，无需进行强制类型转换

4定义于类声明的函数自动成为内联函数

5类的函数对所有对象共用，但数据则各自私有

6要创造类对象数组，该类必须有默认构造函数

7只有一个构造函数参数的构造函数可以用于类的自动转换 classname t; t=20; 如果想禁止这种转换，可以声明explicit给构造函数

8类声明中可定义对于某种基本类型的转换函数 operator int();//可声明为显式转换，尽量避免过多的转换造成二义性

9如果定义类成员参数为static，则它在程序中只有一个地址，可以被所有类成员共享 但通过static实现共享成员时，需要重新定义复制和赋值函数来避免问题

动态类的注意事项

*构造函数中如果用new初始化指针成员，则应该在析构函数中使用delete new对应delete,new[]对应delete[] 对多个构造函数，应用和析构函数兼容的new来初始化成员 重构复制和赋值运算符来实现深复制

10对于使用new创建的类，使用delete时其析构函数才会被调用 如果在使用new时，将对象地址赋予一个指针时，如果删除指针，则对应的对象会调用自己的析构函数 对与使用定位new创建的类对象，需要显式调用析构函数 object->~classname(); 且应该以创建顺序的相反顺序调用，因为后创建的对象可能依赖于前者

类继承

公有继承

class sonclassname: public fatherclassname 派生类继承了基类的公有接口和数据 但只能用基类public和protected函数访问基类私有数据 派生类可添加函数和数据成员 派生类需要自己的构造函数，并由于权限问题，其构造函数必须包括基类构造函数，并且同样可以使用成员初始化列表 指针 基类指针和引用可以在不显式转化的情况下指向派生类对象反过来却不行 虚函数

  • 对于基类和派生类的同名函数： 如果函数通过引用或指针调用，将确定使用哪种方法 ￥如果没有使用关键字virual，将根据引用类型或指针类型选择方法。 如果使用了关键字virtual，将根据引用或指针指向对象的类型选择方法
  • 构造函数不能为虚函数
  • 析构函数应当为虚函数
  • 友元函数并非类成员，但可以使用虚函数
  • **重新定义继承方式（虚实）并非重载，会覆盖掉原先的虚函数定义，如果必须重新定义，则需要重新定义使用基类虚函数

纯虚函数 virual typename func() const=0; 含有虚函数的类不能创建实例，只能用作基类

访问控制（protected） 派生类成员函数可以访问protected成员，不能访问private成员

私有继承

使用私有继承，基类的公有成员和保护成员都成为派生类的私有成员，只可以在派生类的成员函数中使用，可以实现has_a关系 私有继承访问基类方法时需要调动基类的命名空间 访问基类对象 如果要直接访问基类对象，则需要调用强制类型转化将派生类转化为基类

保护继承

保护继承时，基类的公有和保护成员都成为派生类的保护成员，基类接口在派生类中可用

通过using指令可以让私有函数被当前作用域可用

命令行参数

int main(int argc,char* argv[]) argc为参数个数 argv为参数组成的字符串

字符输入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
cin >> ***(读取输入中的结束字符为结束标志，会将换行符留在输入流)
getline(stringname,length)通过换行符确定输入结束点
cin.get()读取到换行符之前，不带参数则读取下一个字符(用于清除换行符)
cin.clear()清空输入流
<string>
重载符号+实现拼接
str.size()
输入字符串使用getline(cin,str)
结构数组
struct stname;
stname stobj[int x] =
{
{}
{}
}
字符函数库<cctype>
isspace(ch)测试是否空白
isalpha(ch)是否字符
isdigit()是否数字
ispunct()是否标点

1
2
3
4
cin >> ***(读取输入中的结束字符为结束标志，会将换行符留在输入流)
getline(stringname,length)通过换行符确定输入结束点
cin.get()读取到换行符之前，不带参数则读取下一个字符(用于清除换行符)
cin.clear()清空输入流

<string> 重载符号+实现拼接 str.size() 输入字符串使用getline(cin,str) 结构数组 struct stname; stname stobj[int x] = { {} {} } 字符函数库<cctype> isspace(ch)测试是否空白 isalpha(ch)是否字符 isdigit()是否数字 ispunct()是否标点

指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1，c++没有溢出检测机制，
char name[]="hello";
char c =name[10]导致未定义行为
2，用一个常量指针指向常量需要两次const
const char* const name="hhh"
如果需要一个class专属常量，则使用
static const ***
实现文件中，const int classname:: ***
对于宏：
template <typename T>
inline functionname
3,const 出现在*左侧表示被指物为常量，右侧表示指针为常量指针
4,函数名就是函数的地址
double pam(int);
double(*pt)(int);
pt即为函数指针
如果需要一个函数以相同相同返回值和参数的函数为一个参数，则可以考虑函数指针
5，内联函数不能递归
6,引用容器时，如果迭代器不引用，仍然传递临时副本o
7,函数传递指针时按值传递，当向函数传递指针时，指针是按值传递的！这意味着你可以改变被指向的数组内容，因为在调用函数时，这些元素不会被复制！这意味着你可以改变被指向的数组的内容，因为这些元素在函数被调用时并没有被复制。另一方面，如果你改变了所指向的数组，这种改变在函数之外不会持续，因为你只改变了指针的拷贝，而不是原来的指针本身。

智能指针

auto_ptr<string> 和<unique_ptr>指针采用所有权模型，对特定对象只有一个智能指针可以拥有它，只有拥有它的指针可以删除它 shared_ptr<string>追踪引用对象的智能指针数量，最后一个指针过期时才会调用delete 使用new分配内存才能使用auto_ptr,unique_ptr

异常

try_catch

1
2
3
4
5
6
7
8
9
10
11
try{
 func();
}
catch(errortype e1){

}
func()
{
 do sth;
 throw(error_type e1);8
}

栈解退 假设try块没有直接调用引发异常的函数，而是调用对引发异常的函数进行调用的函数，则程序从引发异常的函数跳到包含try块和处理程序的函数（追踪到一个地址位于try块的返回地址） 其他异常特性

  • throw-catch类似函数参数和返回，但函数返回语句将控制器交给调用函数的函数，但throw语句将控制权向上返回到第一个这样的函数，包含能捕获相应异常的try-catch组合
  • throw语句总是生成副本，但catch参数使用基类引用能捕获所有派生类的异常对象

exception类

exception类可作为其他异常类的基类，用what的虚函数（返回一个字符串）重载来指示错误类型 失败时返回空指针的语法

1
int * pi= new (std::nothrow) int;

未捕获异常

未捕获的异常会使程序调用函数terminate(),默认情况下，terminate()调用abort()函数，可以指定terminate()调用的函数来修改其行为

一些新特性

关键字

关键字nullptr表示空指针

RTTI(运行阶段类型识别)

dynamic——cast

danamic_cast<type *> (pt) 如果可以安全将pt转化为type*指针，返回对象地址，否则返回空指针 如果对引用使用，错误时返回bad_cast异常

typeid和type_info

typeid返回对type_info对象的引用，type_ifo是定义在typeinfo的类，重载==和!=预算符，例如 typeid(obj1)==typeid(obj2)

类型转换运算符

  • dynamic_cast
  • const_cast
  • static_cast
1
2
//用于执行各种类型的数值转换static_cast <typename> (expression)
//转换是允许隐式转换时才能通过（派生类和基类可以互相转换）
  • reinterpret_cast /执行危险的转换

移动语义 通过指针转移右值的地址给新对象 或通过std::move()将左值转化为右值

someclass()=default default关键字显式声明编译器创建默认构造函数，复制构造函数 delete用于禁止类中的函数

关键字override可用于覆盖虚函数定义

匿名函数

返回类型编译器自动确定，可直接作为函数指针使用

1
[] (double x) {return x%3==0;}

可以返回类型后置

1
[] (double x)-> double{int y = x;return y-x;}

可以给匿名函数命名

]]> - <h2 id="一些查找和排序算法">一些查找和排序算法</h2> -<p>二分查找法 <img src="/images/obsidian/20230226101843.png" title="image" alt="图片" /> 最坏情况：log2n + <h1 id="c语言部分">c语言部分</h1> +<h2 id="基本函数构成">基本函数构成</h2> +<p>将数组传递为函数参数</p> +<figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">int fcname(int arg[],int n)</span><br></pre></td></tr></table></figure> - - - - + - - + @@ -1064,37 +1062,39 @@ A.L.I.C.E(原曲：不可思议之国的爱丽丝)<br /> - - + + - 基于c++ primer plus的读书笔记 - - https://thinklive1.github.io/thinklive/15197/ + 基于斯坦福cs106b的c++数据结构笔记 + + https://thinklive1.github.io/thinklive/16615/ 2024-01-20T11:53:48.573Z 2023-11-27T12:47:59.687Z - c语言部分

基本函数构成

将数组传递为函数参数

1
int fcname(int arg[],int n)

基本输入输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
- cin及其衍生函数返回一个iostream函数的引用，即支持
cin,get().get()
iostream的其他成员
- cout.put()显示字符
- cout.write()显示字符串
- cout<<flush刷新缓冲区
- cout<<endl刷新缓冲区并提供换行符
- dec,hex,oct控制输出数制
hex(cout)控制cout为16进制
- int width()返回字段宽度当前设置
 int width(int i)设置字段宽度，返回以前字段宽度 
 只影响下一次输出
 - fill()设置填充用字符
 - precision()设置精度，即保留几位小数
 - setf()设置各种输出格式
 - 流状态stream_state(eof,fail,bad)
 - cin.get(ch)读取下一个字符，跳过换行符和空白
 - cin.get()读取空白和换行符
 - cin.get()get的基础上读取到换行符并丢弃
 - cin.read()读取内容，但不会在末尾加空字符
 - cin.peek()读取输入流下一个字符但不抽取
 - cin.putback(ch)把一个字符放到输入流最前

文件输入输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
写入文件
ofstream fout;//ofstream继承ostream
fout.open("hello.txt");
fout << "i'm adding sth"
|| ofstream fout("hello.txt");
读取文件也类似
fin >> ch||string
关闭流
fout.close()
fin.close()
检测文件是否打开
if (!fin.is_open())
设置文件输入输出格式
ios_base::

基本逻辑运算符

break打断循环 continue，跳到更新表达式前开始执行 非const引用的函数不接受const参数

基本数据类型

结构数组

stname;
1
2
3
4
5
6
7
8
9
10
11
stname stobj\[int x] =
{
{}
{}
}
union(类似结构，但相同数据类型只存一种)
每个指针需要一个*用于初始化
int * intlist=new int [10]
delete-new
delete []-new []
typedef typename aliasname

名称空间

1
2
3
4
5
#ifndef HNAME_H
#define HNAME_H


#endif

如果在遇到另一个定义HNAME_H的头文件时，将他忽略

作用域： 1默认情况下，函数中声明的变量作用域位于代码块内，如果函数内外都声明一个同名变量，运行至内部代码块使用内部，离开代码块使用外部 2静态变量存在于整个程序运行周期，脱离作用域后只是无法使用并不消失 代码块外声明且不带static关键字：链接性外部，可以在其他程序使用 代码块外声明，且使用static：链接性内部，可以在整个程序使用 代码块内声明，且使用static：作用域于代码块内，但始终存在//由于静态变量只可以定义一次，所以即使离开代码块后变量依旧存在，且值不变，直到下一次修改 3运算符::放置于变量前时，使用同名变量（如果有）的全局版本 4namespace{

} 无法放置于代码块内，因此默认为全局名称，可以囊括声明和定义，可以随时添加 定义于类声明的函数自动成为内联函数

c++特性

class

1声明构造函数时，尽量使用explicit(显性转换)前缀，防止隐性转换带来的问题 mutable(摆动的)前缀声明变量，表示这些变量可能在const成员函数内被更改 用const_cast<>和static_cast<>与this指针可以实现const成员函数向非const的转变，反之则是错误的

2class初始化成员时，按构造函数声明变量的顺序，因此初始化成员时最好也以此顺序初始化 如果不希望class有copy和赋值(=)操作，则应该在private里定义copy和=运算符

3基类引用可以指向派生类对象，无需进行强制类型转换

4定义于类声明的函数自动成为内联函数

5类的函数对所有对象共用，但数据则各自私有

6要创造类对象数组，该类必须有默认构造函数

7只有一个构造函数参数的构造函数可以用于类的自动转换 classname t; t=20; 如果想禁止这种转换，可以声明explicit给构造函数

8类声明中可定义对于某种基本类型的转换函数 operator int();//可声明为显式转换，尽量避免过多的转换造成二义性

9如果定义类成员参数为static，则它在程序中只有一个地址，可以被所有类成员共享 但通过static实现共享成员时，需要重新定义复制和赋值函数来避免问题

动态类的注意事项

*构造函数中如果用new初始化指针成员，则应该在析构函数中使用delete new对应delete,new[]对应delete[] 对多个构造函数，应用和析构函数兼容的new来初始化成员 重构复制和赋值运算符来实现深复制

10对于使用new创建的类，使用delete时其析构函数才会被调用 如果在使用new时，将对象地址赋予一个指针时，如果删除指针，则对应的对象会调用自己的析构函数 对与使用定位new创建的类对象，需要显式调用析构函数 object->~classname(); 且应该以创建顺序的相反顺序调用，因为后创建的对象可能依赖于前者

类继承

公有继承

class sonclassname: public fatherclassname 派生类继承了基类的公有接口和数据 但只能用基类public和protected函数访问基类私有数据 派生类可添加函数和数据成员 派生类需要自己的构造函数，并由于权限问题，其构造函数必须包括基类构造函数，并且同样可以使用成员初始化列表 指针 基类指针和引用可以在不显式转化的情况下指向派生类对象反过来却不行 虚函数

  • 对于基类和派生类的同名函数： 如果函数通过引用或指针调用，将确定使用哪种方法 ￥如果没有使用关键字virual，将根据引用类型或指针类型选择方法。 如果使用了关键字virtual，将根据引用或指针指向对象的类型选择方法
  • 构造函数不能为虚函数
  • 析构函数应当为虚函数
  • 友元函数并非类成员，但可以使用虚函数
  • **重新定义继承方式（虚实）并非重载，会覆盖掉原先的虚函数定义，如果必须重新定义，则需要重新定义使用基类虚函数

纯虚函数 virual typename func() const=0; 含有虚函数的类不能创建实例，只能用作基类

访问控制（protected） 派生类成员函数可以访问protected成员，不能访问private成员

私有继承

使用私有继承，基类的公有成员和保护成员都成为派生类的私有成员，只可以在派生类的成员函数中使用，可以实现has_a关系 私有继承访问基类方法时需要调动基类的命名空间 访问基类对象 如果要直接访问基类对象，则需要调用强制类型转化将派生类转化为基类

保护继承

保护继承时，基类的公有和保护成员都成为派生类的保护成员，基类接口在派生类中可用

通过using指令可以让私有函数被当前作用域可用

命令行参数

int main(int argc,char* argv[]) argc为参数个数 argv为参数组成的字符串

字符输入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
cin >> ***(读取输入中的结束字符为结束标志，会将换行符留在输入流)
getline(stringname,length)通过换行符确定输入结束点
cin.get()读取到换行符之前，不带参数则读取下一个字符(用于清除换行符)
cin.clear()清空输入流
<string>
重载符号+实现拼接
str.size()
输入字符串使用getline(cin,str)
结构数组
struct stname;
stname stobj[int x] =
{
{}
{}
}
字符函数库<cctype>
isspace(ch)测试是否空白
isalpha(ch)是否字符
isdigit()是否数字
ispunct()是否标点

1
2
3
4
cin >> ***(读取输入中的结束字符为结束标志，会将换行符留在输入流)
getline(stringname,length)通过换行符确定输入结束点
cin.get()读取到换行符之前，不带参数则读取下一个字符(用于清除换行符)
cin.clear()清空输入流

<string> 重载符号+实现拼接 str.size() 输入字符串使用getline(cin,str) 结构数组 struct stname; stname stobj[int x] = { {} {} } 字符函数库<cctype> isspace(ch)测试是否空白 isalpha(ch)是否字符 isdigit()是否数字 ispunct()是否标点

指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1，c++没有溢出检测机制，
char name[]="hello";
char c =name[10]导致未定义行为
2，用一个常量指针指向常量需要两次const
const char* const name="hhh"
如果需要一个class专属常量，则使用
static const ***
实现文件中，const int classname:: ***
对于宏：
template <typename T>
inline functionname
3,const 出现在*左侧表示被指物为常量，右侧表示指针为常量指针
4,函数名就是函数的地址
double pam(int);
double(*pt)(int);
pt即为函数指针
如果需要一个函数以相同相同返回值和参数的函数为一个参数，则可以考虑函数指针
5，内联函数不能递归
6,引用容器时，如果迭代器不引用，仍然传递临时副本o
7,函数传递指针时按值传递，当向函数传递指针时，指针是按值传递的！这意味着你可以改变被指向的数组内容，因为在调用函数时，这些元素不会被复制！这意味着你可以改变被指向的数组的内容，因为这些元素在函数被调用时并没有被复制。另一方面，如果你改变了所指向的数组，这种改变在函数之外不会持续，因为你只改变了指针的拷贝，而不是原来的指针本身。

智能指针

auto_ptr<string> 和<unique_ptr>指针采用所有权模型，对特定对象只有一个智能指针可以拥有它，只有拥有它的指针可以删除它 shared_ptr<string>追踪引用对象的智能指针数量，最后一个指针过期时才会调用delete 使用new分配内存才能使用auto_ptr,unique_ptr

异常

try_catch

1
2
3
4
5
6
7
8
9
10
11
try{
 func();
}
catch(errortype e1){

}
func()
{
 do sth;
 throw(error_type e1);8
}

栈解退 假设try块没有直接调用引发异常的函数，而是调用对引发异常的函数进行调用的函数，则程序从引发异常的函数跳到包含try块和处理程序的函数（追踪到一个地址位于try块的返回地址） 其他异常特性

  • throw-catch类似函数参数和返回，但函数返回语句将控制器交给调用函数的函数，但throw语句将控制权向上返回到第一个这样的函数，包含能捕获相应异常的try-catch组合
  • throw语句总是生成副本，但catch参数使用基类引用能捕获所有派生类的异常对象

exception类

exception类可作为其他异常类的基类，用what的虚函数（返回一个字符串）重载来指示错误类型 失败时返回空指针的语法

1
int * pi= new (std::nothrow) int;

未捕获异常

未捕获的异常会使程序调用函数terminate(),默认情况下，terminate()调用abort()函数，可以指定terminate()调用的函数来修改其行为

一些新特性

关键字

关键字nullptr表示空指针

RTTI(运行阶段类型识别)

dynamic——cast

danamic_cast<type *> (pt) 如果可以安全将pt转化为type*指针，返回对象地址，否则返回空指针 如果对引用使用，错误时返回bad_cast异常

typeid和type_info

typeid返回对type_info对象的引用，type_ifo是定义在typeinfo的类，重载==和!=预算符，例如 typeid(obj1)==typeid(obj2)

类型转换运算符

  • dynamic_cast
  • const_cast
  • static_cast
1
2
//用于执行各种类型的数值转换static_cast <typename> (expression)
//转换是允许隐式转换时才能通过（派生类和基类可以互相转换）
  • reinterpret_cast /执行危险的转换

移动语义 通过指针转移右值的地址给新对象 或通过std::move()将左值转化为右值

someclass()=default default关键字显式声明编译器创建默认构造函数，复制构造函数 delete用于禁止类中的函数

关键字override可用于覆盖虚函数定义

匿名函数

返回类型编译器自动确定，可直接作为函数指针使用

1
[] (double x) {return x%3==0;}

可以返回类型后置

1
[] (double x)-> double{int y = x;return y-x;}

可以给匿名函数命名

]]> + 一些查找和排序算法

二分查找法 图片 最坏情况：log2n 寻找最小排序 图片 向前插入算法 图片

合并算法接受两个排序的 列出并将它们组合成一个 排序列表。 ● 虽然两个列表都是非空的，但比较它们的 第一要素。 删除较小的元素 并将其附加到输出。 ● 一旦一个列表为空，添加所有元素 另一个列表输出。 ● 它运行时间为 O(n)，其中 n 是总数 合并的元素数量。 图片 无限递归后的合并算法 图片 复杂度：nlog2n

容器类

set（集合）：无序不允许重复的容器类，可以添加删除元素 You can add a value to a Set by writing set += value; s. ● You can remove a value from a Set by writing set -= value; ● You can check if a value exists in a Set by writing set.contains(value)map(键值对的集合) 如果没有对应key的value，返回默认值（见定义文件） `vector vector的remove根据移除元素的索引有1-n的复杂度，移除尾部为O(1)，如果不在意索引，可以交换要移除元素和尾部元素再移除

哈希表

哈希表的负载因子α表示元素和表格键数量的比，决定了查找速度

检查表中是否存在元素

● 计算元素的散列码。 ● 跳转到表格中的那个位置。 ● 向前扫描——必要时环绕——直到项目或一个 发现空插槽。

将元素插入表中

● 如果项目已经存在，什么也不做。 ● 否则，跳转到元素哈希码给定的槽。 向前走——必要时环绕——直到一个空白点或 找到墓碑插槽。 然后，将项目放在那里。

从表中删除一个元素

● 跳转到由元素的散列码给定的槽。 ● 向前走——必要时环绕——直到物品或 发现空插槽。 如果找到该项目，请将其替换为 墓碑。

“罗宾汉哈希表”

  • 如果插入的值比其将插入的位置的值距离索引更远，则替换插入值和当前值
  • 删除值时，将后其离原键远的元素前移
  • ★ 罗宾汉哈希一览 ★
  • 检查表中是否存在元素：
  • ● 跳转到表中由元素的散列码给出的位置。
  • ● 向前扫描——如有必要环绕——记录有多少步 你拿走了。 当您找到该项目、找到一个空白槽或找到一个 离家更近的空位比你走的步数还多。
  • 将元素插入表中：
  • ● 如果该元素已在表中，则什么也不做。
  • ● 跳转到由元素的散列码给出的表槽。 向前扫描 - 换行 如有必要，四处走走——记录所走的步数。 如果你找到一个 空插槽，将元素放在那里。 否则，如果当前插槽已满并且 比您插入的元素更靠近家，将要插入的项目放在那里， 替换那个位置的元素，然后继续插入，就好像你 正在插入被置换的元素。
  • 从表中删除一个元素：
  • ● 跳转到由元素的散列码给定的槽。
  • ● 向前走——如有必要，环绕——直到物品或空槽被放置 成立。 如果找到该项目，请将其删除。 然后，继续前进——包裹 around as necessary – 将表中的元素向后移动一个槽位，直到 找到空插槽或位于其原始位置的项目

string类

str::npos表示容器的最后一个成员位置 if (s.find("e") != string::npos) //find函数找不到时返回npos if s in str: string obj; obj.substr(int pos) //pos为要包含的第一个字符串的位置 std::string a = "0123456789abcdefghij";

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

    // count is npos, returns [pos, size())
    [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub1 = a.substr(10);
    [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub1 << '\n';

    // both pos and pos+count are within bounds, returns [pos, pos+count)
    [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub2 = a.substr(5, 3);
    [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub2 << '\n';

    // pos is within bounds, pos+count is not, returns [pos, size())
    [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub4 = a.substr(a.size()-3, 50);
    // this is effectively equivalent to
    // std::string sub4 = a.substr(17, 3);
    // since a.size() == 20, pos == a.size()-3 == 17, and a.size()-pos == 3

    [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub4 << '\n';

    try {
        // pos is out of bounds, throws
        [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub5 = a.substr(a.size()+3, 50);
        [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub5 << '\n';
    } catch(const [std::out_of_range](http://en.cppreference.com/w/cpp/error/out_of_range)& e) {
        [std::cout](http://en.cppreference.com/w/cpp/io/cout) << "pos exceeds string size\n";
    }
}
输出：
abcdefghij
567
hij
pos exceeds string size

`replace和insert str1.insert(start, str2) str1.replace(start, length, str2)

一些实现

优先队列

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
# include "HeapPQueue.h"
using namespace std;

HeapPQueue::HeapPQueue() {
    elems = new DataPoint[INITIAL_SIZE] {};
    for (int i=0;i<INITIAL_SIZE;i++)
    {
        elems[i].weight=0;
    }
    allocatedSize=INITIAL_SIZE;
}

HeapPQueue::~HeapPQueue() {
    delete [] elems;
}

int HeapPQueue::size() const {
    return logicalSize;
}

bool HeapPQueue::isEmpty() const {
    return logicalSize==0;
}

void HeapPQueue::enqueue(const DataPoint& data) {
    if (logicalSize+1<allocatedSize)
    {
        if (logicalSize==0)
        {
            elems[1]=data;
            logicalSize++;
        }
        else
        {
            logicalSize++;
            int i=1;
            while (data.weight>elems[i].weight && i<=logicalSize && elems[i].weight!=0)
            {
                i++;
            }
            if (i<logicalSize)
            {
                DataPoint temp=elems[i];
                elems[i]=data;
                for(i;i<logicalSize;i++)
                {
                    DataPoint temp_plus=elems[i+1];
                    elems[i+1]=temp;
                    temp=temp_plus;

                }
            }
            else
            {
                elems[i]=data;
            }

        }
    }
}

DataPoint HeapPQueue::peek() const {
    return elems[logicalSize];
}

DataPoint HeapPQueue::dequeue() {
    DataPoint to_return=elems[1];
    if(!isEmpty())
    {

        for (int i=1;i<logicalSize;i++)
        {
            elems[i]=elems[i+1];
        }
        elems[logicalSize]={};
        logicalSize--;
    }
    return to_return;
}

计数排序

首先算出最大值，然后用一个数组的索引存储待排序数组的成员，其索引对应值存储出现次数，然后用两个同步的for循环和递增的next参数表示排序中的索引值来进行排序（也就是重新赋值）

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
53
54
/* Given a Vector<int>, returns the largest number in that Vector. */
int maxOf(const Vector<int>& values) {
    /* Bounds-check inputs. */
    if (values.isEmpty()) {
        error("Can't find the maximum of no values.");
    }
    
    int result = values[0];
    for (int i = 1; i < values.size(); i++) {
        result = max(result, values[i]);
    }
    return result;
}

/* Given a list of numbers, creates a histogram from those numbers. */
Vector<int> histogramFor(const Vector<int>& values) {
    /* Create a histogram with the right number of slots. Initially, all values
     * in the histogram will be zero.
     */
    Vector<int> histogram(maxOf(values) + 1);
    
    /* Scan across the input vector, incrementing the histogram values. */
    for (int value: values) {
        histogram[value]++;
    }
    
    return histogram;
}

void countingSort(Vector<int>& values) {
    /* Edge Case: If the array is empty, then it's already sorted. This is
     * needed because we can't take the maximum value of an empty vector.
     */
    if (values.isEmpty()) {
        return;
    }
    
    /* Form the histogram. */
    auto histogram = histogramFor(values);
    
    /* Scan across the histogram writing out the appropriate number of copies
     * of each value. We track the index of the next free spot to write to,
     * as it varies based on how many items we've written out so far.
     */
    int next = 0;
    for (int value = 0; value < histogram.size(); value++) {
        /* Write out the right number of copies. */
        for (int copy = 0; copy < histogram[value]; copy++) {
            values[next] = value;
            next++;    
        }
    }
}

错题集

递归的效率优化

每次递归都会创造所有变量的临时复制 基于递归的这种性质，它会需要巨大的时间和空间来完成任务，并且会造成算力上的浪费。 通过记忆表机制能部分解决这个问题，方法是每次递归的返回值都会按索引存入一个表格，并且每次递归前查询表格中是否有结果，这样可以让每个临时副本的运算结果能被所有函数共享。

递归计算给定元素的不同结构哈夫曼树的数量

对每个给定元素集来说，首先要做到是确定根节点元素是第几个大的元素，确定之后，左子树和右子树的元素数也随之确定，在此之后分别对左节点和右节点作为根节点做同样的递归

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

int numBSTsOfSize(int n) {

  /* Base case: There’s only one tree of size 0, namely, the empty BST. */
  if (n == 0) return 1;
  
  /* Recursive case: Imagine all possible ways to choose a root and build the
   * left and right subtrees.
  */
  int result = 0;
  
  /* Put the the nodes at indices 0, 1, 2, ..., n-1 up at the root. */
  for (int i = 0; i < n; i++) {
    /* Each combination of a BST of i elements and a BST of n - 1 - i elements
     * can be used to build one BST of n elements. The number of pairs of
     * trees we can make this way is given by the product of the number of
     * trees of each type.
     */
     result += numBSTsOfSize(i) * numBSTsOfSize(n - 1 - i);
  }
  
  return result;
}

递归解决吃巧克力问题

求出吃法数量

1
2
3
4
5
6
7
8
9
10
11
12
if (numSquares<0)
{
    error("输入数据不能为负数");
}
else if (numSquares<=1)
{
    return 1;
}
else
{
    return numWaysToEat(numSquares-1)+numWaysToEat(numSquares-2);
}

打印每种吃法

`需要一个辅助向量储存历史记录

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
/* Print all ways to eat numSquares more squares, given that we've
 * already taken the bites given in soFar.
 */
void printWaysToEatRec(int numSquares, const Vector<int>& soFar) {
    /* Base Case: If there are no squares left, the only option is to use
     * the bites we've taken already in soFar.
     */
    if (numSquares == 0) {
        cout << soFar << endl;
    }
    /* Base Case: If there is one square lfet, the only option is to eat
     * that square.
     */
    else if (numSquares == 1) {
        cout << soFar + 1 << endl;
    }
    /* Otherwise, we take take bites of size one or of size two. */
    else {
        printWaysToEatRec(numSquares - 1, soFar + 1);
        printWaysToEatRec(numSquares - 2, soFar + 2);
    }
}

void printWaysToEat(int numSquares) {
    if (numSquares < 0) {
        error("You owe me some chocolate!");
    }

    /* We begin without having made any bites. */
    printWaysToEatRec(numSquares, {});
}

递归解决翻煎饼问题

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
bool isSorted(Stack<double> pancakes) {
    double last = -1; // No pancakes have negative size;

    while (!pancakes.isEmpty()) {
        /* Check the next pancake. */
        double next = pancakes.pop();
        if (next < last) {
            return false;
        }

        last = next;
    }

    /* Pancakes are in increasing order! */
    return true;
}

/* Given a stack of pancakes and a flip size, flips that many pancakes
 * on the top of the stack.
 */
Stack<double> flip(Stack<double> pancakes, int numToFlip) {
    /* Take the top pancakes off the stack and run them into a queue.
     * This preserves the order in which they were removed.
     */
    Queue<double> buffer;
    for (int i = 0; i < numToFlip; i++) {
        buffer.enqueue(pancakes.pop());
    }

    /* Move the pancakes back. */
    while (!buffer.isEmpty()) {
        pancakes.push(buffer.dequeue());
    }

    return pancakes;
}

Optional<Vector<int>> sortStack(Stack<double> pancakes, int numFlips) {
    /* Base Case: If the stack is sorted, great! We're done, and no flips
     * were needed.
     */
    if (isSorted(pancakes)) {
        return { }; // No flips
    }
    /* Base Case: If the stack isn't sorted and we're out of flips, then
     * there is no way to sort things.
     */
    else if (numFlips == 0) {
        return Nothing;
    }
    /* Recursive Case: The stack isn't sorted and we still have flips left.
     * The next flip could flip 1, 2, 3, ..., or all N of the pancakes.
     * Try each option and see whether any of them work.
     */
    for (int numToFlip = 1; numToFlip <= pancakes.size(); numToFlip++) {
        /* Make the flip and see if it works. */
        auto result = sortStack(flip(pancakes, numToFlip), numFlips - 1);
        if (result != Nothing) {
            /* The result holds all the remaining flips but doesn't know about
             * the flip we just did. Insert that flip at the beginning.
             */
            result.value().insert(0, numToFlip);
            return result;
        }
    }

    /* If we're here, then no matter which flip we make first, we cannot
     * get the pancakes sorted. Give up.
     */
    return Nothing;
}

递归解决天平问题

1
2
3
4
5
6
7
8
9
10
11
12
13
bool isMeasurableRec(int amount, const Vector<int>& weights, int index) {
  if (index == weights.size()) {
      return amount == 0;
  } else {
      return isMeasurableRec(amount,                  weights, index + 1) ||
             isMeasurableRec(amount + weights[index], weights, index + 1) ||
             isMeasurableRec(amount - weights[index], weights, index + 1);
  }
}

bool isMeasurable(int amount, const Vector<int>& weights) {
    return isMeasurableRec(amount, weights, 0);
}

想象一下，我们首先将要测量的数量（称为 n ）放在天平的左侧。 这使得规模上的不平衡等于 n 。 想象一下，有某种方法可以测量 n 。 如果我们一次将一个重量放在秤上，我们可以查看第一个重量的放置位置（假设它的重量为 w ）。 它必须：

  • 向左走，使规模上的净不平衡 n + w ，或
  • 向右走，使规模上的净不平衡 n – w ，或
  • 根本不习惯，留下净不平衡 n 。

如果确实有可能测量 n ，那么这三个选项之一必须是实现它的方法，即使我们不知道它是哪一个。 然后我们要问的问题是，是否有可能使用剩余的权重来衡量新的净失衡——我们可以递归地确定！ 另一方面，如果无法测量 n ，那么无论我们选择哪个选项，我们都会发现没有办法使用剩余的权重来使一切平衡！

如果我们递归地进行，我们在这里，我们需要考虑我们的基本情况。 我们可以选择的选项有很多。 一个简单的方法如下：假设我们根本没有任何重量，我们被要求查看是否可以不使用重量来测量某些重量。 在什么情况下我们可以这样做？ 好吧，如果我们称重的东西有一个非零重量，我们就不可能测量它——把它放在秤上会使它倾斜到某一边，但这并不能告诉我们它有多少重量。 另一方面，如果我们称量的东西是完全失重的，那么把它放在秤上也不会导致它倾斜，让我们相信它确实是失重的！ 因此，作为我们的基本情况，我们会说当我们减少到没有剩余权重时， ，我们可以精确测量n 如果 n = 0 。 考虑到这一点，这是我们的代码：

递归解决找零问题

不使用记忆的情况

`从第一个硬币开始遍历，并穷举它的所有枚数，将其作为下一枚硬币的参数传递

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
int fewestCoinsFor(int cents, const Set<int>& coins) {
    /* Can't have a negative number of cents. */
    if (cents < 0) {
        error("You owe me money, not the other way around!");
    }
    /* Base case: You need no coins to give change for no cents. */
    else if (cents == 0) {
        return 0;
    }
    /* Base case: No coins exist. Then it's not possible to make the
     * amount. In that case, give back a really large value as a
     * sentinel.
     */
    else if (coins.isEmpty()) {
        return cents + 1;
    }
    /* Recursive case: Pick a coin, then try using each distinct number of
     * copies of it that we can.
     */
    else {
        /* The best we've found so far. We initialize this to a large value so
         * that it's replaced on the first iteration of the loop. Do you see
         * why cents + 1 is a good choice?
         */
        int bestSoFar = cents + 1;
        /* Pick a coin. */
        int coin = coins.first();
        /* Try all amounts of it. */
        for (int copies = 0; copies * coin <= cents; copies++) {
            /* See what happens if we make this choice. Once we use this
             * coin, we won't use the same coin again in the future.
             */
            int thisChoice = copies + fewestCoinsFor(cents - copies * coin,
                                                     coins - coin);
          /* Is this better than what we have so far? */
            if (thisChoice < bestSoFar) {
                bestSoFar = thisChoice;
            }
        }
        /* Return whatever worked best. */
        return bestSoFar;
    }
}

使用记忆进行优化

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
/* How few coins are needed to make the total, given that we can only use
 * coins from index startIndex and onward?
 */
int fewestCoinsRec(int cents, const Vector<int>& coins, int startIndex,Grid<int>& memo) {
    /* Base case: You need no coins to give change for no cents. */
    if (cents == 0) {
        return 0;
    }
    /* Base case: No coins exist. Then it's not possible to make the
     * amount. In that case, give back a really large value as a
     * sentinel.
     */
    else if (startIndex == coins.size()) {
        return cents + 1;
    }
    /* Base case: We already know the answer. */
    else if (memo[cents][startIndex] != -1) {
        return memo[cents][startIndex];
    }
    /* Recursive case: Pick a coin, then try using each distinct number of
     * copies of it that we can.
     */
    else {
        /* The best we've found so far. We initialize this to a large value so
         * that it's replaced on the first iteration of the loop. Do you see
         * why cents + 1 is a good choice?
         */
        int bestSoFar = cents + 1;

        /* Pick a coin. */
        int coin = coins[startIndex];

        /* Try all amounts of it. */
        for (int copies = 0; copies * coin <= cents; copies++) {
            /* See what happens if we make this choice. Once we use this
             * coin, we won't use the same coin again in the future.
             */
            int thisChoice = copies + fewestCoinsRec(cents - copies * coin,
                                                     coins, startIndex + 1,
                                                     memo);

            /* Is this better than what we have so far? */
            if (thisChoice < bestSoFar) {
                bestSoFar = thisChoice;
            }
        }

        /* Return whatever worked best. */
        memo[cents][startIndex] = bestSoFar;
        return bestSoFar;
    }
}

int fewestCoinsFor(int cents, const Set<int>& coins) {
    /* Can't have a negative number of cents. */
    if (cents < 0) {
        error("You owe me money, not the other way around!");
    }

    /* Convert from a Set<int> to a Vector<int> so we have a nice ordering
     * on things.
     */
    Vector<int> coinVec;
    for (int coin: coins) {
        coinVec += coin;
    }

    /* Build our memoization table. Since the number of cents left ranges from
     * 0 to cents, we need cents+1 rows. Since the start index of the coin
     * ranges from 0 to coins.size(), we make coins.size() + 1 columns.
     *
     * -1 is used as a sentinel to indicate "nothing has been computed here
     * yet."
     */
    Grid<int> memo(cents + 1, coins.size() + 1, -1);

    /* Now ask how many coins are needed to make the total, using any coins
     * from index 0 onward.
     */
    return fewestCoinsRec(cents, coinVec, 0, memo);
}

递归穷举付账单

递归机制：对第一个人来说，0-total所有金额都会付一遍，随后传递给下一个人，当只有一人时，付清所有余额并打印账单 传递参数：string,int的映射存储目前为止的账单，string集合存储所有付账者

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
void listPossiblePaymentsRec(int total, const Set<string>& people,const Map<string, int>& payments) {
    /* Base case: if there's one person left, they have to pay the whole bill. */
    if (people.size() == 1) {
        Map<string, int> finalPayments = payments;
        finalPayments[people.first()] = total;
        cout << finalPayments << endl;
    }
    /* Recursive case: The first person has to pay some amount between 0 and the
     * total amount. Try all of those possibilities.
     */
    else {
        for (int payment = 0; payment <= total; payment++) {
            /* Create a new assignment of people to payments in which this first
             * person pays this amount.
             */
            Map<string, int> updatedPayments = payments;
            updatedPayments[people.first()] = payment;
            listPossiblePaymentsRec(total - payment, people - people.first(),updatedPayments);
        }
    }
}
void listPossiblePayments(int total, const Set<string>& people) {
    /* Edge cases: we can't pay a negative total, and there must be at least one
     * person.
     */
    if (total < 0) error("Guess you're an employee?");
    if (people.isEmpty()) error("Dine and dash?");
 listPossiblePaymentsRec(total, people, {});
}

递归寻找完全平方数列

主要参数为sofar——用于存储目前的序列和一个set用于存储还没放入数列的数字，`确保这两者同时被传递，且其并集为所有数字

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
Optional<Vector<int>> findSquareSequence(int n) {
    /*Validate input.*/
    if (n < 0) {
        error("Don't be so negative!");
    }

    /* Build a set of the numbers 1, 2, 3, ..., n. */
    Set<int> options;
    for (int i = 1; i <= n; i++) {
        options += i;
    }
    return findSequenceRec(options, { });
}

Optional<Vector<int>> findSequenceRec(const Set<int>& unused,
                                      const Vector<int>& soFar) {
    /*Base Case: If all numbers are used, we have our sequence!*/
    if (unused.isEmpty()) {
        return soFar;
    }

    /* Recursive Case: Some number comes next. Try each of them and see which
     * one we should pick.
     */
    for (int next: unused) {
        /* We can use this if either
         *
         * 1. the sequence is empty, so we're first in line, or
         * 2. the sequence is not empty, but we sum to a perfect square
         *    with the previous term.
         */
        if (soFar.isEmpty() ||
            isPerfectSquare(next + soFar[soFar.size() - 1])) {
            /* See what happens if we extend with this number. */
            auto result = findSequenceRec(unused - next, soFar + next);
            if (result != Nothing) {
                return result;
            }
        }
    }

    /* Tried all options and none of them worked. Oh well! */
    return Nothing;
}

汉诺塔递归

假设有三座汉诺塔，start ,temp ,finish 对n层的汉诺塔问题，先考虑n-1层的，随后考虑n-2层，到最后只需要考虑两层问题，两层的汉诺塔非常容易解决，起点为start,终点是temp,临时塔为finish，最后我们得到temp上的两层汉诺塔 这时将start的3移动到finish塔，这时只要将两层汉诺塔转移到finish则完成了三层汉诺塔，这个过程中的起点为temp,终点是finish,临时塔是start 以此类推，四层塔基于三层塔，n层塔基于n-1塔，汉诺塔问题解决

1
2
3
4
5
6
7
8
9
10
11
int moveTower(int numDisks, char start, char finish, char temp) {
    if (numDisks == 0) {
        return 0;
    } else {
        int movesOne = moveTower(numDisks - 1, start, temp, finish);
        moveSingleDisk(start, finish);
        int movesTwo = moveTower(numDisks - 1, temp, finish, start);

        return 1 + movesOne + movesTwo;
    }
}
]]> - <h1 id="c语言部分">c语言部分</h1> -<h2 id="基本函数构成">基本函数构成</h2> -<p>将数组传递为函数参数</p> -<figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">int fcname(int arg[],int n)</span><br></pre></td></tr></table></figure> + <h2 id="一些查找和排序算法">一些查找和排序算法</h2> +<p>二分查找法 <img src="/images/obsidian/20230226101843.png" title="image" alt="图片" /> 最坏情况：log2n - + + + + + - + diff --git a/categories/index.html b/categories/index.html index 75896e3a8..dc4caf565 100644 --- a/categories/index.html +++ b/categories/index.html @@ -314,14 +314,14 @@

categories 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/categories/\345\244\207\345\277\230\345\275\225/index.html" "b/categories/\345\244\207\345\277\230\345\275\225/index.html" index 53bb64b07..f0363fe35 100644 --- "a/categories/\345\244\207\345\277\230\345\275\225/index.html" +++ "b/categories/\345\244\207\345\277\230\345\275\225/index.html" @@ -321,14 +321,14 @@

备忘录 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/categories/\345\273\272\347\253\231\347\273\217\351\252\214/index.html" "b/categories/\345\273\272\347\253\231\347\273\217\351\252\214/index.html" index 4a9aa180d..aae2aed54 100644 --- "a/categories/\345\273\272\347\253\231\347\273\217\351\252\214/index.html" +++ "b/categories/\345\273\272\347\253\231\347\273\217\351\252\214/index.html" @@ -321,14 +321,14 @@

建站经验 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/categories/\346\270\270\346\210\217\346\235\202\350\260\210/black-souls/index.html" "b/categories/\346\270\270\346\210\217\346\235\202\350\260\210/black-souls/index.html" index 5fec34a83..571bed9aa 100644 --- "a/categories/\346\270\270\346\210\217\346\235\202\350\260\210/black-souls/index.html" +++ "b/categories/\346\270\270\346\210\217\346\235\202\350\260\210/black-souls/index.html" @@ -306,8 +306,8 @@

black souls

-
@@ -326,8 +326,8 @@

black souls
-
@@ -361,14 +361,14 @@

black souls 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git "a/categories/\346\270\270\346\210\217\346\235\202\350\260\210/index.html" "b/categories/\346\270\270\346\210\217\346\235\202\350\260\210/index.html" index 7cb119b33..1e1143db7 100644 --- "a/categories/\346\270\270\346\210\217\346\235\202\350\260\210/index.html" +++ "b/categories/\346\270\270\346\210\217\346\235\202\350\260\210/index.html" @@ -326,8 +326,8 @@

游戏杂谈

-
@@ -346,8 +346,8 @@

游戏杂谈
-
@@ -381,14 +381,14 @@

游戏杂谈 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git "a/categories/\347\247\230\345\257\206/index.html" "b/categories/\347\247\230\345\257\206/index.html" index 8fdb97134..41881619e 100644 --- "a/categories/\347\247\230\345\257\206/index.html" +++ "b/categories/\347\247\230\345\257\206/index.html" @@ -321,14 +321,14 @@

秘密 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/categories/\350\200\203\347\240\224\347\254\224\350\256\260/index.html" "b/categories/\350\200\203\347\240\224\347\254\224\350\256\260/index.html" index d6b0b6de8..e2501f688 100644 --- "a/categories/\350\200\203\347\240\224\347\254\224\350\256\260/index.html" +++ "b/categories/\350\200\203\347\240\224\347\254\224\350\256\260/index.html" @@ -424,14 +424,14 @@

考研笔记 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/index.html" "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/index.html" index 5b542e527..60b51d471 100644 --- "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/index.html" +++ "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/index.html" @@ -326,8 +326,8 @@

课程笔记

-
@@ -366,8 +366,8 @@

课程笔记
-
@@ -504,14 +504,14 @@

课程笔记 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/page/2/index.html" "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/page/2/index.html" index c3b0decec..b67475ac6 100644 --- "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/page/2/index.html" +++ "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/page/2/index.html" @@ -306,8 +306,8 @@

课程笔记

-
@@ -326,8 +326,8 @@

课程笔记
-
@@ -346,8 +346,8 @@

课程笔记
-
@@ -464,14 +464,14 @@

课程笔记 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/web\345\274\200\345\217\221/index.html" "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/web\345\274\200\345\217\221/index.html" index c2e2f3f2d..14f992cd2 100644 --- "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/web\345\274\200\345\217\221/index.html" +++ "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/web\345\274\200\345\217\221/index.html" @@ -321,14 +321,14 @@

web开发 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\345\205\266\344\273\226/index.html" "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\345\205\266\344\273\226/index.html" index 233ef9a6c..12bae79dc 100644 --- "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\345\205\266\344\273\226/index.html" +++ "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\345\205\266\344\273\226/index.html" @@ -341,14 +341,14 @@

其他 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\346\223\215\344\275\234\347\263\273\347\273\237/index.html" "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\346\223\215\344\275\234\347\263\273\347\273\237/index.html" index c9c3bbcf5..e8d74c3b4 100644 --- "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\346\223\215\344\275\234\347\263\273\347\273\237/index.html" +++ "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\346\223\215\344\275\234\347\263\273\347\273\237/index.html" @@ -381,14 +381,14 @@

操作系统 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\346\225\260\346\215\256\347\247\221\345\255\246/index.html" "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\346\225\260\346\215\256\347\247\221\345\255\246/index.html" index 5a4b8ef65..d91987e9a 100644 --- "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\346\225\260\346\215\256\347\247\221\345\255\246/index.html" +++ "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\346\225\260\346\215\256\347\247\221\345\255\246/index.html" @@ -361,14 +361,14 @@

数据科学 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/index.html" "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/index.html" index 6a4c74b94..73239e3d7 100644 --- "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/index.html" +++ "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/index.html" @@ -326,8 +326,8 @@

数据结构与算法

-
@@ -346,8 +346,8 @@

数据结构与算法
-
@@ -421,14 +421,14 @@

数据结构与算法 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234/index.html" "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234/index.html" index 9cfe1df89..38f6305e1 100644 --- "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234/index.html" +++ "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234/index.html" @@ -321,14 +321,14 @@

计算机网络 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\350\256\241\347\273\204/index.html" "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\350\256\241\347\273\204/index.html" index 278a5495e..eaaa6ce13 100644 --- "a/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\350\256\241\347\273\204/index.html" +++ "b/categories/\350\257\276\347\250\213\347\254\224\350\256\260/\350\256\241\347\273\204/index.html" @@ -321,14 +321,14 @@

计组 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/categories/\350\277\252\347\221\236\345\205\213\346\213\211/index.html" "b/categories/\350\277\252\347\221\236\345\205\213\346\213\211/index.html" index de605d68e..fc3de1c81 100644 --- "a/categories/\350\277\252\347\221\236\345\205\213\346\213\211/index.html" +++ "b/categories/\350\277\252\347\221\236\345\205\213\346\213\211/index.html" @@ -286,8 +286,8 @@

迪瑞克拉

-
@@ -306,8 +306,8 @@

迪瑞克拉
-
@@ -364,14 +364,14 @@

迪瑞克拉 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/guestbook/index.html b/guestbook/index.html index 93763ce77..3fce29369 100644 --- a/guestbook/index.html +++ b/guestbook/index.html @@ -316,14 +316,14 @@

请于此留下你的思想

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/index.html b/index.html index 5fbbe6546..bed0a990d 100644 --- a/index.html +++ b/index.html @@ -312,14 +312,14 @@

本文字数： - 1.8k + 1.4k 阅读时长 ≈ - 2 分钟 + 5 分钟

@@ -420,7 +420,7 @@

更新于 - + @@ -439,14 +439,14 @@

本文字数： - 39k + 36k 阅读时长 ≈ - 35 分钟 + 2:11 @@ -551,14 +551,14 @@

本文字数： - 1.1k + 721 阅读时长 ≈ - 1 分钟 + 3 分钟 @@ -660,14 +660,14 @@

本文字数： - 48k + 38k 阅读时长 ≈ - 43 分钟 + 2:17 @@ -769,14 +769,14 @@

本文字数： - 3.4k + 3k 阅读时长 ≈ - 3 分钟 + 11 分钟 @@ -895,14 +895,14 @@

本文字数： - 92k + 26k 阅读时长 ≈ - 1:24 + 1:34 @@ -1004,14 +1004,14 @@

本文字数： - 47k + 39k 阅读时长 ≈ - 42 分钟 + 2:21 @@ -1113,14 +1113,14 @@

本文字数： - 20k + 18k 阅读时长 ≈ - 18 分钟 + 1:04 @@ -1222,14 +1222,14 @@

本文字数： - 9k + 4k 阅读时长 ≈ - 8 分钟 + 14 分钟 @@ -1332,14 +1332,14 @@

本文字数： - 55k + 44k 阅读时长 ≈ - 50 分钟 + 2:39 @@ -1402,14 +1402,14 @@

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/page/2/index.html b/page/2/index.html index 70fa8d85c..e7f4790b1 100644 --- a/page/2/index.html +++ b/page/2/index.html @@ -325,14 +325,14 @@

本文字数： - 6.6k + 4.2k 阅读时长 ≈ - 6 分钟 + 15 分钟

@@ -443,14 +443,14 @@

本文字数： - 7.6k + 7k 阅读时长 ≈ - 7 分钟 + 25 分钟 @@ -547,7 +547,7 @@

本文字数： - 0 + 5 @@ -656,14 +656,14 @@

本文字数： - 2.9k + 2.6k 阅读时长 ≈ - 3 分钟 + 9 分钟 @@ -772,14 +772,14 @@

本文字数： - 27k + 19k 阅读时长 ≈ - 24 分钟 + 1:08 @@ -898,14 +898,14 @@

本文字数： - 7k + 6.2k 阅读时长 ≈ - 6 分钟 + 23 分钟 @@ -1028,14 +1028,14 @@

本文字数： - 51k + 7.7k 阅读时长 ≈ - 46 分钟 + 28 分钟 @@ -1147,14 +1147,14 @@

本文字数： - 14k + 13k 阅读时长 ≈ - 13 分钟 + 47 分钟 @@ -1261,14 +1261,14 @@

本文字数： - 18k + 6.4k 阅读时长 ≈ - 16 分钟 + 23 分钟 @@ -1380,14 +1380,14 @@

本文字数： - 51k + 19k 阅读时长 ≈ - 46 分钟 + 1:09 @@ -1461,14 +1461,14 @@

算法性质

 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/page/3/index.html b/page/3/index.html index 69b7e5988..1a1fc9cc2 100644 --- a/page/3/index.html +++ b/page/3/index.html @@ -321,7 +321,7 @@

本文字数： - 1.8k + 674 @@ -436,7 +436,7 @@

本文字数： - 2k + 531 @@ -549,14 +549,14 @@

本文字数： - 43k + 20k 阅读时长 ≈ - 39 分钟 + 1:12

@@ -672,14 +672,14 @@

本文字数： - 20k + 3.9k 阅读时长 ≈ - 18 分钟 + 14 分钟 @@ -824,14 +824,14 @@

本文字数： - 14k + 3.3k 阅读时长 ≈ - 13 分钟 + 12 分钟 @@ -944,14 +944,14 @@

本文字数： - 4.6k + 827 阅读时长 ≈ - 4 分钟 + 3 分钟 @@ -1067,14 +1067,14 @@

本文字数： - 3.7k + 2.5k 阅读时长 ≈ - 3 分钟 + 9 分钟 @@ -1183,14 +1183,14 @@

本文字数： - 8.6k + 1.9k 阅读时长 ≈ - 8 分钟 + 7 分钟 @@ -1298,14 +1298,14 @@

本文字数： - 33k + 16k 阅读时长 ≈ - 30 分钟 + 59 分钟 @@ -1413,14 +1413,14 @@

本文字数： - 20k + 12k 阅读时长 ≈ - 18 分钟 + 44 分钟 @@ -1489,14 +1489,14 @@

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/page/4/index.html b/page/4/index.html index 70227034d..27e1d62b1 100644 --- a/page/4/index.html +++ b/page/4/index.html @@ -321,14 +321,14 @@

本文字数： - 2.4k + 2.1k 阅读时长 ≈ - 2 分钟 + 8 分钟

@@ -435,14 +435,14 @@

本文字数： - 21k + 7.7k 阅读时长 ≈ - 20 分钟 + 28 分钟 @@ -491,7 +491,7 @@

函数

- +

- +

@@ -539,7 +539,7 @@

， - + @@ -550,14 +550,14 @@

本文字数： - 22k + 3.2k 阅读时长 ≈ - 20 分钟 + 12 分钟

@@ -570,11 +570,13 @@

-

一些查找和排序算法

-

二分查找法 图片 最坏情况：log2n +

c语言部分

+

基本函数构成

+

将数组传递为函数参数

+
1
int fcname(int arg[],int n)
- + 阅读全文 »
@@ -664,14 +666,14 @@

本文字数： - 3.3k + 1.4k 阅读时长 ≈ - 3 分钟 + 5 分钟

@@ -720,7 +722,7 @@

c++特性

- +

- +

@@ -768,7 +770,7 @@

， - + @@ -779,14 +781,14 @@

本文字数： - 5.9k + 4.2k 阅读时长 ≈ - 5 分钟 + 15 分钟

@@ -799,13 +801,11 @@

-

c语言部分

-

基本函数构成

-

将数组传递为函数参数

-
1
int fcname(int arg[],int n)
+

一些查找和排序算法

+

二分查找法 图片 最坏情况：log2n

- + 阅读全文 »
@@ -895,14 +895,14 @@

本文字数： - 19k + 12k 阅读时长 ≈ - 18 分钟 + 43 分钟

@@ -970,14 +970,14 @@

简介

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/photos/index.html b/photos/index.html index c3dd68d7d..43984f296 100644 --- a/photos/index.html +++ b/photos/index.html @@ -335,14 +335,14 @@

2024年贺图

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/search.xml b/search.xml index f9aa93db7..76ec208d7 100644 --- a/search.xml +++ b/search.xml @@ -512,6 +512,17 @@ wars, wars never change
不过还有更好的方法吗？杀了一个人的人就必须死?如果过失杀人呢？故意杀人必须死?如果被杀人曾害杀人者妻离子散呢？没有仇怨杀人必须死?如果被杀者身上有传染病，不烧掉尸体就会让周边化为地狱呢？杀好人必须死?如果好人只是伪装，私底下男盗女娼呢？
无论如何都很难归纳出绝对正确的可以杀人的场合，因此只能这么说，只要行动，就会有犯下罪孽的可能性，即使什么都不做也是一样，归根到底，道德议题都会是虚无的，只有圈定一个前提，才能讨论一个局部解，那么不同群体的局部解又会不同
因此，只要杀人都是罪，这种观点未必对也未必错，无法证实也无法证伪，只是一个观点，如果说这种观点错，同样也可以否定其他观点，这就是为什么人类文明发展到现在也依旧有无数的罪恶

+

复仇篇的发展远比英雄篇好猜，正义，英雄，这种概念是人类社会出现后才慢慢成型的事物，复仇则在更早之前就会出现
+证据就是，我小时候收养了流浪狗，不服管教被我妈追着打过，因此它一看到我妈就夹着尾巴，这是恐惧，畏惧，但到了适当的时候就会产生仇恨，仇恨就是这样一种原始的感情，例如农村的狗对着闯进领地的人狂叫，也是对侵占领地这种行为的“复仇”
+复仇只要伴随着生物本能就可以完成，这样的简单粗暴让其很多时候都不符合道德标准，正义更无从谈起，但作为人性中残留的兽性，这是必不可少的
+因此，复仇没什么好绕的，只要去杀戮就行了，但为什么哈姆雷特这样的人会犹豫呢?这不过是因为他当了太久的人，忘了怎么当裸猿，也就是说复仇很简单，复不复仇才是麻烦的地方，脱下人皮经典，再穿上又难了

+

我是很不擅长阅读理解的那类人，语文很难考到平均分，因此我一般也看不出作者有什么私货，除了硬塞lgbt，黑龙也是龙这种太夸张的，因为我懒得猜作者到底什么意思，所以反而是最宽容的一类读者，对我来说作者写完的一瞬间，作品的解释权就被我这个读者垄断了，作者想要解释作品也只能以一个读者的身份来
+因此我倒不觉得村正反战败，我看出的是反杀人，杀任何人都有可能杀错，所以不要杀比较好，这种说法很极端，因为别人打不过了的话难道不反抗吗？所以这个说法还有补丁，心怀大爱的人就不要反抗，以肉饲鹰，没有这么高尚的人以牙还牙也无所谓，只是不要觉得自己就是对的。这样说完了还是很极端，难道世界上不存在正义的战争，怎么就不能觉得自己是正义的?但是还有补丁，这是从宏观视角看的，因为缺少前提的情况下，恶人的一命和善人的一命没有方法裁量，善与恶也难以分辨，这个前提取决于不同的人和不同的价值观，也就是换一个朴素正义感的视角，善人杀恶人就是天经地义的正义。
+这就绕了个大圈子回到了现实世界，为什么要这么麻烦呢，或者说为什么要这么极端呢？因为村正是为了醋包饺子，世界观下平民几乎没有半点希望，单人的武力可以灭国，毫无节制的强，你杀我我杀你，没几轮地球上就没人了，在这种特定情况下，很难说需不需要社会的存在，也很难说什么是道德准则，武力的使用会产生冲突，稍微多冲突几次地球就没人了，你以一个平民的视角看，不要使用任何武力也是个不错的结果，平民和那些超能力者已经不是同类了
+绕到这种程度还是很极端，为什么就要因噎废食，说不定在地球没人前，正义的超人们把邪恶方杀完了，又可以建立一个天国。这当然也可以，唯一的问题是会死人，死掉很多无辜的人，也未必能成功，对那些，比如流弹打死的人来说，正义又成了邪恶
+到最后我们就会发现一个朴素的道理，好人一次也不能出错，否则就成了恶人，村正部分角色的观点是，好人难做，那就什么都不做好了，或者以当恶人的觉悟去做好事
+论证到这个结论，还是很极端，因为好心干了坏事的好人也可以认为还是好人，好人战斗死的人很可能比不战斗死的人少，更何况可能真的有超人，永远好心干好事，这样的论证逐渐开始虚无了，因为这样的假设可以无数次做下去
+因此以上的一切只会是观点，无法像数学证明题一样完美的QED，同理，认为有私货的人也只是观点，我也可以假设作者的所想和我这些观点一样几乎等于什么都没说，因为换个类似现实的世界观一切就不同了

]]> 游戏杂谈 @@ -11758,160 +11769,6 @@ Inexpensive Disk）由美国加州大学伯克利分校提出。
数据结构与算法 - - 基于斯坦福cs106b的c++数据结构笔记 - /thinklive/16615/ - 一些查找和排序算法

-

二分查找法 图片 最坏情况：log2n 寻找最小排序 图片 向前插入算法 图片

-

合并算法接受两个排序的 列出并将它们组合成一个 排序列表。 ● 虽然两个列表都是非空的，但比较它们的 第一要素。 删除较小的元素 并将其附加到输出。 ● 一旦一个列表为空，添加所有元素 另一个列表输出。 ● 它运行时间为 O(n)，其中 n 是总数 合并的元素数量。 图片 无限递归后的合并算法 图片 复杂度：nlog2n

-

容器类

-

set（集合）：无序不允许重复的容器类，可以添加删除元素 You can add a value to a Set by writing set += value; s. ● You can remove a value from a Set by writing set -= value; ● You can check if a value exists in a Set by writing set.contains(value)map(键值对的集合) 如果没有对应key的value，返回默认值（见定义文件） `vector vector的remove根据移除元素的索引有1-n的复杂度，移除尾部为O(1)，如果不在意索引，可以交换要移除元素和尾部元素再移除

-

哈希表

-

哈希表的负载因子α表示元素和表格键数量的比，决定了查找速度

-

检查表中是否存在元素

-

● 计算元素的散列码。 ● 跳转到表格中的那个位置。 ● 向前扫描——必要时环绕——直到项目或一个 发现空插槽。

-

将元素插入表中

-

● 如果项目已经存在，什么也不做。 ● 否则，跳转到元素哈希码给定的槽。 向前走——必要时环绕——直到一个空白点或 找到墓碑插槽。 然后，将项目放在那里。

-

从表中删除一个元素

-

● 跳转到由元素的散列码给定的槽。 ● 向前走——必要时环绕——直到物品或 发现空插槽。 如果找到该项目，请将其替换为 墓碑。

-

“罗宾汉哈希表”

- -

string类

-

str::npos表示容器的最后一个成员位置 if (s.find("e") != string::npos) //find函数找不到时返回npos if s in str: string obj; obj.substr(int pos) //pos为要包含的第一个字符串的位置 std::string a = "0123456789abcdefghij";

-

    // count is npos, returns [pos, size())
    [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub1 = a.substr(10);
    [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub1 << '\n';

    // both pos and pos+count are within bounds, returns [pos, pos+count)
    [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub2 = a.substr(5, 3);
    [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub2 << '\n';

    // pos is within bounds, pos+count is not, returns [pos, size())
    [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub4 = a.substr(a.size()-3, 50);
    // this is effectively equivalent to
    // std::string sub4 = a.substr(17, 3);
    // since a.size() == 20, pos == a.size()-3 == 17, and a.size()-pos == 3

    [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub4 << '\n';

    try {
        // pos is out of bounds, throws
        [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub5 = a.substr(a.size()+3, 50);
        [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub5 << '\n';
    } catch(const [std::out_of_range](http://en.cppreference.com/w/cpp/error/out_of_range)& e) {
        [std::cout](http://en.cppreference.com/w/cpp/io/cout) << "pos exceeds string size\n";
    }
}
输出：
abcdefghij
567
hij
pos exceeds string size
-

`replace和insert str1.insert(start, str2) str1.replace(start, length, str2)

-

一些实现

-

优先队列

-
# include "HeapPQueue.h"
using namespace std;

HeapPQueue::HeapPQueue() {
    elems = new DataPoint[INITIAL_SIZE] {};
    for (int i=0;i<INITIAL_SIZE;i++)
    {
        elems[i].weight=0;
    }
    allocatedSize=INITIAL_SIZE;
}

HeapPQueue::~HeapPQueue() {
    delete [] elems;
}

int HeapPQueue::size() const {
    return logicalSize;
}

bool HeapPQueue::isEmpty() const {
    return logicalSize==0;
}

void HeapPQueue::enqueue(const DataPoint& data) {
    if (logicalSize+1<allocatedSize)
    {
        if (logicalSize==0)
        {
            elems[1]=data;
            logicalSize++;
        }
        else
        {
            logicalSize++;
            int i=1;
            while (data.weight>elems[i].weight && i<=logicalSize && elems[i].weight!=0)
            {
                i++;
            }
            if (i<logicalSize)
            {
                DataPoint temp=elems[i];
                elems[i]=data;
                for(i;i<logicalSize;i++)
                {
                    DataPoint temp_plus=elems[i+1];
                    elems[i+1]=temp;
                    temp=temp_plus;

                }
            }
            else
            {
                elems[i]=data;
            }

        }
    }
}

DataPoint HeapPQueue::peek() const {
    return elems[logicalSize];
}

DataPoint HeapPQueue::dequeue() {
    DataPoint to_return=elems[1];
    if(!isEmpty())
    {

        for (int i=1;i<logicalSize;i++)
        {
            elems[i]=elems[i+1];
        }
        elems[logicalSize]={};
        logicalSize--;
    }
    return to_return;
}

-

计数排序

-

首先算出最大值，然后用一个数组的索引存储待排序数组的成员，其索引对应值存储出现次数，然后用两个同步的for循环和递增的next参数表示排序中的索引值来进行排序（也就是重新赋值）

-
/* Given a Vector<int>, returns the largest number in that Vector. */
int maxOf(const Vector<int>& values) {
    /* Bounds-check inputs. */
    if (values.isEmpty()) {
        error("Can't find the maximum of no values.");
    }
    
    int result = values[0];
    for (int i = 1; i < values.size(); i++) {
        result = max(result, values[i]);
    }
    return result;
}

/* Given a list of numbers, creates a histogram from those numbers. */
Vector<int> histogramFor(const Vector<int>& values) {
    /* Create a histogram with the right number of slots. Initially, all values
     * in the histogram will be zero.
     */
    Vector<int> histogram(maxOf(values) + 1);
    
    /* Scan across the input vector, incrementing the histogram values. */
    for (int value: values) {
        histogram[value]++;
    }
    
    return histogram;
}

void countingSort(Vector<int>& values) {
    /* Edge Case: If the array is empty, then it's already sorted. This is
     * needed because we can't take the maximum value of an empty vector.
     */
    if (values.isEmpty()) {
        return;
    }
    
    /* Form the histogram. */
    auto histogram = histogramFor(values);
    
    /* Scan across the histogram writing out the appropriate number of copies
     * of each value. We track the index of the next free spot to write to,
     * as it varies based on how many items we've written out so far.
     */
    int next = 0;
    for (int value = 0; value < histogram.size(); value++) {
        /* Write out the right number of copies. */
        for (int copy = 0; copy < histogram[value]; copy++) {
            values[next] = value;
            next++;    
        }
    }
}

-

错题集

-

递归的效率优化

-

每次递归都会创造所有变量的临时复制 基于递归的这种性质，它会需要巨大的时间和空间来完成任务，并且会造成算力上的浪费。 通过记忆表机制能部分解决这个问题，方法是每次递归的返回值都会按索引存入一个表格，并且每次递归前查询表格中是否有结果，这样可以让每个临时副本的运算结果能被所有函数共享。

-

递归计算给定元素的不同结构哈夫曼树的数量

-

对每个给定元素集来说，首先要做到是确定根节点元素是第几个大的元素，确定之后，左子树和右子树的元素数也随之确定，在此之后分别对左节点和右节点作为根节点做同样的递归

-

int numBSTsOfSize(int n) {

  /* Base case: There’s only one tree of size 0, namely, the empty BST. */
  if (n == 0) return 1;
  
  /* Recursive case: Imagine all possible ways to choose a root and build the
   * left and right subtrees.
  */
  int result = 0;
  
  /* Put the the nodes at indices 0, 1, 2, ..., n-1 up at the root. */
  for (int i = 0; i < n; i++) {
    /* Each combination of a BST of i elements and a BST of n - 1 - i elements
     * can be used to build one BST of n elements. The number of pairs of
     * trees we can make this way is given by the product of the number of
     * trees of each type.
     */
     result += numBSTsOfSize(i) * numBSTsOfSize(n - 1 - i);
  }
  
  return result;
}
-

递归解决吃巧克力问题

-

求出吃法数量

-
if (numSquares<0)
{
    error("输入数据不能为负数");
}
else if (numSquares<=1)
{
    return 1;
}
else
{
    return numWaysToEat(numSquares-1)+numWaysToEat(numSquares-2);
}
-

打印每种吃法

-

`需要一个辅助向量储存历史记录

-
/* Print all ways to eat numSquares more squares, given that we've
 * already taken the bites given in soFar.
 */
void printWaysToEatRec(int numSquares, const Vector<int>& soFar) {
    /* Base Case: If there are no squares left, the only option is to use
     * the bites we've taken already in soFar.
     */
    if (numSquares == 0) {
        cout << soFar << endl;
    }
    /* Base Case: If there is one square lfet, the only option is to eat
     * that square.
     */
    else if (numSquares == 1) {
        cout << soFar + 1 << endl;
    }
    /* Otherwise, we take take bites of size one or of size two. */
    else {
        printWaysToEatRec(numSquares - 1, soFar + 1);
        printWaysToEatRec(numSquares - 2, soFar + 2);
    }
}

void printWaysToEat(int numSquares) {
    if (numSquares < 0) {
        error("You owe me some chocolate!");
    }

    /* We begin without having made any bites. */
    printWaysToEatRec(numSquares, {});
}
-

递归解决翻煎饼问题

-
bool isSorted(Stack<double> pancakes) {
    double last = -1; // No pancakes have negative size;

    while (!pancakes.isEmpty()) {
        /* Check the next pancake. */
        double next = pancakes.pop();
        if (next < last) {
            return false;
        }

        last = next;
    }

    /* Pancakes are in increasing order! */
    return true;
}

/* Given a stack of pancakes and a flip size, flips that many pancakes
 * on the top of the stack.
 */
Stack<double> flip(Stack<double> pancakes, int numToFlip) {
    /* Take the top pancakes off the stack and run them into a queue.
     * This preserves the order in which they were removed.
     */
    Queue<double> buffer;
    for (int i = 0; i < numToFlip; i++) {
        buffer.enqueue(pancakes.pop());
    }

    /* Move the pancakes back. */
    while (!buffer.isEmpty()) {
        pancakes.push(buffer.dequeue());
    }

    return pancakes;
}

Optional<Vector<int>> sortStack(Stack<double> pancakes, int numFlips) {
    /* Base Case: If the stack is sorted, great! We're done, and no flips
     * were needed.
     */
    if (isSorted(pancakes)) {
        return { }; // No flips
    }
    /* Base Case: If the stack isn't sorted and we're out of flips, then
     * there is no way to sort things.
     */
    else if (numFlips == 0) {
        return Nothing;
    }
    /* Recursive Case: The stack isn't sorted and we still have flips left.
     * The next flip could flip 1, 2, 3, ..., or all N of the pancakes.
     * Try each option and see whether any of them work.
     */
    for (int numToFlip = 1; numToFlip <= pancakes.size(); numToFlip++) {
        /* Make the flip and see if it works. */
        auto result = sortStack(flip(pancakes, numToFlip), numFlips - 1);
        if (result != Nothing) {
            /* The result holds all the remaining flips but doesn't know about
             * the flip we just did. Insert that flip at the beginning.
             */
            result.value().insert(0, numToFlip);
            return result;
        }
    }

    /* If we're here, then no matter which flip we make first, we cannot
     * get the pancakes sorted. Give up.
     */
    return Nothing;
}
-

递归解决天平问题

-
bool isMeasurableRec(int amount, const Vector<int>& weights, int index) {
  if (index == weights.size()) {
      return amount == 0;
  } else {
      return isMeasurableRec(amount,                  weights, index + 1) ||
             isMeasurableRec(amount + weights[index], weights, index + 1) ||
             isMeasurableRec(amount - weights[index], weights, index + 1);
  }
}

bool isMeasurable(int amount, const Vector<int>& weights) {
    return isMeasurableRec(amount, weights, 0);
}
-

想象一下，我们首先将要测量的数量（称为 n ）放在天平的左侧。 这使得规模上的不平衡等于 n 。 想象一下，有某种方法可以测量 n 。 如果我们一次将一个重量放在秤上，我们可以查看第一个重量的放置位置（假设它的重量为 w ）。 它必须：

- -

如果确实有可能测量 n ，那么这三个选项之一必须是实现它的方法，即使我们不知道它是哪一个。 然后我们要问的问题是，是否有可能使用剩余的权重来衡量新的净失衡——我们可以递归地确定！ 另一方面，如果无法测量 n ，那么无论我们选择哪个选项，我们都会发现没有办法使用剩余的权重来使一切平衡！

-

如果我们递归地进行，我们在这里，我们需要考虑我们的基本情况。 我们可以选择的选项有很多。 一个简单的方法如下：假设我们根本没有任何重量，我们被要求查看是否可以不使用重量来测量某些重量。 在什么情况下我们可以这样做？ 好吧，如果我们称重的东西有一个非零重量，我们就不可能测量它——把它放在秤上会使它倾斜到某一边，但这并不能告诉我们它有多少重量。 另一方面，如果我们称量的东西是完全失重的，那么把它放在秤上也不会导致它倾斜，让我们相信它确实是失重的！ 因此，作为我们的基本情况，我们会说当我们减少到没有剩余权重时， ，我们可以精确测量n 如果 n = 0 。 考虑到这一点，这是我们的代码：

-

递归解决找零问题

-

不使用记忆的情况

-

`从第一个硬币开始遍历，并穷举它的所有枚数，将其作为下一枚硬币的参数传递

-
int fewestCoinsFor(int cents, const Set<int>& coins) {
    /* Can't have a negative number of cents. */
    if (cents < 0) {
        error("You owe me money, not the other way around!");
    }
    /* Base case: You need no coins to give change for no cents. */
    else if (cents == 0) {
        return 0;
    }
    /* Base case: No coins exist. Then it's not possible to make the
     * amount. In that case, give back a really large value as a
     * sentinel.
     */
    else if (coins.isEmpty()) {
        return cents + 1;
    }
    /* Recursive case: Pick a coin, then try using each distinct number of
     * copies of it that we can.
     */
    else {
        /* The best we've found so far. We initialize this to a large value so
         * that it's replaced on the first iteration of the loop. Do you see
         * why cents + 1 is a good choice?
         */
        int bestSoFar = cents + 1;
        /* Pick a coin. */
        int coin = coins.first();
        /* Try all amounts of it. */
        for (int copies = 0; copies * coin <= cents; copies++) {
            /* See what happens if we make this choice. Once we use this
             * coin, we won't use the same coin again in the future.
             */
            int thisChoice = copies + fewestCoinsFor(cents - copies * coin,
                                                     coins - coin);
          /* Is this better than what we have so far? */
            if (thisChoice < bestSoFar) {
                bestSoFar = thisChoice;
            }
        }
        /* Return whatever worked best. */
        return bestSoFar;
    }
}

-

使用记忆进行优化

-
/* How few coins are needed to make the total, given that we can only use
 * coins from index startIndex and onward?
 */
int fewestCoinsRec(int cents, const Vector<int>& coins, int startIndex,Grid<int>& memo) {
    /* Base case: You need no coins to give change for no cents. */
    if (cents == 0) {
        return 0;
    }
    /* Base case: No coins exist. Then it's not possible to make the
     * amount. In that case, give back a really large value as a
     * sentinel.
     */
    else if (startIndex == coins.size()) {
        return cents + 1;
    }
    /* Base case: We already know the answer. */
    else if (memo[cents][startIndex] != -1) {
        return memo[cents][startIndex];
    }
    /* Recursive case: Pick a coin, then try using each distinct number of
     * copies of it that we can.
     */
    else {
        /* The best we've found so far. We initialize this to a large value so
         * that it's replaced on the first iteration of the loop. Do you see
         * why cents + 1 is a good choice?
         */
        int bestSoFar = cents + 1;

        /* Pick a coin. */
        int coin = coins[startIndex];

        /* Try all amounts of it. */
        for (int copies = 0; copies * coin <= cents; copies++) {
            /* See what happens if we make this choice. Once we use this
             * coin, we won't use the same coin again in the future.
             */
            int thisChoice = copies + fewestCoinsRec(cents - copies * coin,
                                                     coins, startIndex + 1,
                                                     memo);

            /* Is this better than what we have so far? */
            if (thisChoice < bestSoFar) {
                bestSoFar = thisChoice;
            }
        }

        /* Return whatever worked best. */
        memo[cents][startIndex] = bestSoFar;
        return bestSoFar;
    }
}

int fewestCoinsFor(int cents, const Set<int>& coins) {
    /* Can't have a negative number of cents. */
    if (cents < 0) {
        error("You owe me money, not the other way around!");
    }

    /* Convert from a Set<int> to a Vector<int> so we have a nice ordering
     * on things.
     */
    Vector<int> coinVec;
    for (int coin: coins) {
        coinVec += coin;
    }

    /* Build our memoization table. Since the number of cents left ranges from
     * 0 to cents, we need cents+1 rows. Since the start index of the coin
     * ranges from 0 to coins.size(), we make coins.size() + 1 columns.
     *
     * -1 is used as a sentinel to indicate "nothing has been computed here
     * yet."
     */
    Grid<int> memo(cents + 1, coins.size() + 1, -1);

    /* Now ask how many coins are needed to make the total, using any coins
     * from index 0 onward.
     */
    return fewestCoinsRec(cents, coinVec, 0, memo);
}
-

递归穷举付账单

-

递归机制：对第一个人来说，0-total所有金额都会付一遍，随后传递给下一个人，当只有一人时，付清所有余额并打印账单 传递参数：string,int的映射存储目前为止的账单，string集合存储所有付账者

-
void listPossiblePaymentsRec(int total, const Set<string>& people,const Map<string, int>& payments) {
    /* Base case: if there's one person left, they have to pay the whole bill. */
    if (people.size() == 1) {
        Map<string, int> finalPayments = payments;
        finalPayments[people.first()] = total;
        cout << finalPayments << endl;
    }
    /* Recursive case: The first person has to pay some amount between 0 and the
     * total amount. Try all of those possibilities.
     */
    else {
        for (int payment = 0; payment <= total; payment++) {
            /* Create a new assignment of people to payments in which this first
             * person pays this amount.
             */
            Map<string, int> updatedPayments = payments;
            updatedPayments[people.first()] = payment;
            listPossiblePaymentsRec(total - payment, people - people.first(),updatedPayments);
        }
    }
}
void listPossiblePayments(int total, const Set<string>& people) {
    /* Edge cases: we can't pay a negative total, and there must be at least one
     * person.
     */
    if (total < 0) error("Guess you're an employee?");
    if (people.isEmpty()) error("Dine and dash?");
 listPossiblePaymentsRec(total, people, {});
}
-

递归寻找完全平方数列

-

主要参数为sofar——用于存储目前的序列和一个set用于存储还没放入数列的数字，`确保这两者同时被传递，且其并集为所有数字

-
Optional<Vector<int>> findSquareSequence(int n) {
    /*Validate input.*/
    if (n < 0) {
        error("Don't be so negative!");
    }

    /* Build a set of the numbers 1, 2, 3, ..., n. */
    Set<int> options;
    for (int i = 1; i <= n; i++) {
        options += i;
    }
    return findSequenceRec(options, { });
}

Optional<Vector<int>> findSequenceRec(const Set<int>& unused,
                                      const Vector<int>& soFar) {
    /*Base Case: If all numbers are used, we have our sequence!*/
    if (unused.isEmpty()) {
        return soFar;
    }

    /* Recursive Case: Some number comes next. Try each of them and see which
     * one we should pick.
     */
    for (int next: unused) {
        /* We can use this if either
         *
         * 1. the sequence is empty, so we're first in line, or
         * 2. the sequence is not empty, but we sum to a perfect square
         *    with the previous term.
         */
        if (soFar.isEmpty() ||
            isPerfectSquare(next + soFar[soFar.size() - 1])) {
            /* See what happens if we extend with this number. */
            auto result = findSequenceRec(unused - next, soFar + next);
            if (result != Nothing) {
                return result;
            }
        }
    }

    /* Tried all options and none of them worked. Oh well! */
    return Nothing;
}

-

汉诺塔递归

-

假设有三座汉诺塔，start ,temp ,finish 对n层的汉诺塔问题，先考虑n-1层的，随后考虑n-2层，到最后只需要考虑两层问题，两层的汉诺塔非常容易解决，起点为start,终点是temp,临时塔为finish，最后我们得到temp上的两层汉诺塔 这时将start的3移动到finish塔，这时只要将两层汉诺塔转移到finish则完成了三层汉诺塔，这个过程中的起点为temp,终点是finish,临时塔是start 以此类推，四层塔基于三层塔，n层塔基于n-1塔，汉诺塔问题解决

-
int moveTower(int numDisks, char start, char finish, char temp) {
    if (numDisks == 0) {
        return 0;
    } else {
        int movesOne = moveTower(numDisks - 1, start, temp, finish);
        moveSingleDisk(start, finish);
        int movesTwo = moveTower(numDisks - 1, temp, finish, start);

        return 1 + movesOne + movesTwo;
    }
}
-]]> - - 课程笔记 - 数据结构与算法 - - - 课程笔记 - 数据结构与算法 - 斯坦福 - c++ - - - - 基于斯坦福cs106l的c++编程规范笔记 - /thinklive/48468/ - c++特性 - -

C++与其兄弟C的最大区别在于_数据抽象_,程序执行的方式可以与程序执行的方式分开 程序员谈论那个程序。

- -

. 面向对象编程是一种完全不同的方式考虑程序设计，可以极大地简化复杂的软件系统。 钥匙 面向对象背后的概念很简单，但要真正体会到面向对象的力量 编程，您将需要一次又一次地看到它的运行情况。 这部分课程 读者探索了面向对象编程中的主要概念以及如何在 C++ 中实现它继承和多态。

- -

泛型编程是一种编程风格，旨在构建可以解决一系列远远超出最初设想的问题的软件
-履行。 虽然泛型编程的完整处理远远超出了介绍性的范围C++ 编程课，泛型编程的许多思想都可以访问并且可以从根本上改变了您对 C++ 编程的看法。

-

const

-

Can’t declare non-const reference to const variable Can’t declare non-const reference to const vari

-

图片 图片

-

模板

-

图片 函数指针：将函数作为对象传递

-

stl

-

sequence:线性，有顺序 associative:不一定线性，有索引机制(map)

-

vector:有顺序的相同类型的数据集合，大小可控制 ---子属性：size:元素数量 ---capacity:单个元素大小 图片 vector最常用，deque用于首部插入场合，list用于多种列表

-

associative(关联数组):有顺序的需要有比较方法，无序的需要哈希函数（更快） iterators（迭代器）：用于访问容器中的所有数据 --常用函数，begin(),end(),iter++,*(pointer),== !=,=（赋值,复制）, 图片 图片 图片

-

输入输出流

-

First call to std::cin >> creates a command line
-prompt that allows the user to type until they hit enter

- -

hashmap的c++实现

-

相关函数

-
构造函数HashMap():
接受参数count(值的个数),hash function(有默认值)

参数(typename fitst,typename last,bucket_count,H)
//用一个容器首尾指针初始化hashmap
eg.
hashmap<k,m> map{vec.begin(),vec.end()}

参数(init_list init,bucket_count,H)
//用容器直接初始化hashmap
eg.
HashMap<char, int> map{{'a', 3}, {'b', 5}, {'c', 7}};

public:
key-键
mapped-被加密的值(int)
H-哈希函数
bucket_count(存储的键值对数组容量)
load_factor(内联函数，返回size/bucket_count，即实际储存值的键值对)
contains(参数const K& key判断是否存在改键，返回bool值)
at(参数k，返回mapped的引用)
clear(清空键值对)
insert(参数为键值对引用，返回一对pair<iterator,bool>,iter指向改键值对，无论是否已存在，bool表示是否成功添加，如为false则已存在该键值对)
erase(key为参数，返回bool值)
earse(iter为参数，返回该指针下一个位置)
rehash(size_t为参数，重新哈希为给出的新的指针数组大小)
begin(根据hashmap是否为const给出iter或const iter)
end(返回伪指针)
debug(打印所有哈希键值对以及哈希表所有参数，注意，必须基于重载<<运算符的基础)

符号重载：
M& [](const key& ,返回insert(key)的返回pair的first成员的second成员，即mapped值)
//用于给key对应的value(mapped)赋值

private:
node(struct，包含next指针和value)
nodepair(前后node的pair)
findnode(参数key，返回指针对<prev,curr>)
first_not_empty_bucket()
make_iterator(参数node*curr)
_bucket_array(vector<node*>,其中一个node*为ptr,则ptr->value为<key ,mapped>)

//指针构造

_bucket_array：由指针组成的数组,每个成员都是一个指针
储存的值为next指针和一个pair<key,mapped>
operator-> is a bit of an odd-ball. When you write p->m, it is interpreted as (p.operator->())->m.

- This means operator-> should return a pointer to the object that has the field m.
-

涉及的c++特性

-

匿名函数 基本lambda语法 基本形式如下： 【capture】（parameters）->return-type {body}

-

typename function() return {x,y,z} 即用{}的参数初始化原函数返回的类型

-

ptrdiff_t:用于储存两个指针的差

-

conditional_t<func,x,y>如果func为true则x，为false则y

-

forward_iterator_tag：单方向迭代器（可读写） ++iter，iter+=1随后返回对自身的引用 iter++，先返回一个对自身的复制，随后iter+=1

-

std::move并不能移动任何东西，它唯一的功能是将一个左值强制转化为右值引用，继而可以通过右值引用使用该值，以用于移动语义。从实现上讲，std::move基本等同于一个类型转换：static_cast<T&&>(lvalue);

-

ate：从文件尾部开始 strsub(start,length) 移动语义(c++11新特性) clss(classname &&) 利用右值引用的部分数据直接初始化新的类，并在初始化之后将右值删除，可以通过std::move()强制转化左值为右值。

-]]> - - 课程笔记 - 数据结构与算法 - - - 课程笔记 - 斯坦福 - c++ - - 基于c++ primer plus的读书笔记 /thinklive/15197/ @@ -12021,8 +11878,162 @@ used the next time std::cin >> is called
其他 - c++ 读书笔记 + c++ + + + + 基于斯坦福cs106l的c++编程规范笔记 + /thinklive/48468/ + c++特性 + +

C++与其兄弟C的最大区别在于_数据抽象_,程序执行的方式可以与程序执行的方式分开 程序员谈论那个程序。

+ +

. 面向对象编程是一种完全不同的方式考虑程序设计，可以极大地简化复杂的软件系统。 钥匙 面向对象背后的概念很简单，但要真正体会到面向对象的力量 编程，您将需要一次又一次地看到它的运行情况。 这部分课程 读者探索了面向对象编程中的主要概念以及如何在 C++ 中实现它继承和多态。

+ +

泛型编程是一种编程风格，旨在构建可以解决一系列远远超出最初设想的问题的软件
+履行。 虽然泛型编程的完整处理远远超出了介绍性的范围C++ 编程课，泛型编程的许多思想都可以访问并且可以从根本上改变了您对 C++ 编程的看法。

+

const

+

Can’t declare non-const reference to const variable Can’t declare non-const reference to const vari

+

图片 图片

+

模板

+

图片 函数指针：将函数作为对象传递

+

stl

+

sequence:线性，有顺序 associative:不一定线性，有索引机制(map)

+

vector:有顺序的相同类型的数据集合，大小可控制 ---子属性：size:元素数量 ---capacity:单个元素大小 图片 vector最常用，deque用于首部插入场合，list用于多种列表

+

associative(关联数组):有顺序的需要有比较方法，无序的需要哈希函数（更快） iterators（迭代器）：用于访问容器中的所有数据 --常用函数，begin(),end(),iter++,*(pointer),== !=,=（赋值,复制）, 图片 图片 图片

+

输入输出流

+

First call to std::cin >> creates a command line
+prompt that allows the user to type until they hit enter

+ +

hashmap的c++实现

+

相关函数

+
构造函数HashMap():
接受参数count(值的个数),hash function(有默认值)

参数(typename fitst,typename last,bucket_count,H)
//用一个容器首尾指针初始化hashmap
eg.
hashmap<k,m> map{vec.begin(),vec.end()}

参数(init_list init,bucket_count,H)
//用容器直接初始化hashmap
eg.
HashMap<char, int> map{{'a', 3}, {'b', 5}, {'c', 7}};

public:
key-键
mapped-被加密的值(int)
H-哈希函数
bucket_count(存储的键值对数组容量)
load_factor(内联函数，返回size/bucket_count，即实际储存值的键值对)
contains(参数const K& key判断是否存在改键，返回bool值)
at(参数k，返回mapped的引用)
clear(清空键值对)
insert(参数为键值对引用，返回一对pair<iterator,bool>,iter指向改键值对，无论是否已存在，bool表示是否成功添加，如为false则已存在该键值对)
erase(key为参数，返回bool值)
earse(iter为参数，返回该指针下一个位置)
rehash(size_t为参数，重新哈希为给出的新的指针数组大小)
begin(根据hashmap是否为const给出iter或const iter)
end(返回伪指针)
debug(打印所有哈希键值对以及哈希表所有参数，注意，必须基于重载<<运算符的基础)

符号重载：
M& [](const key& ,返回insert(key)的返回pair的first成员的second成员，即mapped值)
//用于给key对应的value(mapped)赋值

private:
node(struct，包含next指针和value)
nodepair(前后node的pair)
findnode(参数key，返回指针对<prev,curr>)
first_not_empty_bucket()
make_iterator(参数node*curr)
_bucket_array(vector<node*>,其中一个node*为ptr,则ptr->value为<key ,mapped>)

//指针构造

_bucket_array：由指针组成的数组,每个成员都是一个指针
储存的值为next指针和一个pair<key,mapped>
operator-> is a bit of an odd-ball. When you write p->m, it is interpreted as (p.operator->())->m.

- This means operator-> should return a pointer to the object that has the field m.
+

涉及的c++特性

+

匿名函数 基本lambda语法 基本形式如下： 【capture】（parameters）->return-type {body}

+

typename function() return {x,y,z} 即用{}的参数初始化原函数返回的类型

+

ptrdiff_t:用于储存两个指针的差

+

conditional_t<func,x,y>如果func为true则x，为false则y

+

forward_iterator_tag：单方向迭代器（可读写） ++iter，iter+=1随后返回对自身的引用 iter++，先返回一个对自身的复制，随后iter+=1

+

std::move并不能移动任何东西，它唯一的功能是将一个左值强制转化为右值引用，继而可以通过右值引用使用该值，以用于移动语义。从实现上讲，std::move基本等同于一个类型转换：static_cast<T&&>(lvalue);

+

ate：从文件尾部开始 strsub(start,length) 移动语义(c++11新特性) clss(classname &&) 利用右值引用的部分数据直接初始化新的类，并在初始化之后将右值删除，可以通过std::move()强制转化左值为右值。

+]]> + + 课程笔记 + 数据结构与算法 + + + 课程笔记 + c++ + 斯坦福 + + + + 基于斯坦福cs106b的c++数据结构笔记 + /thinklive/16615/ + 一些查找和排序算法 +

二分查找法 图片 最坏情况：log2n 寻找最小排序 图片 向前插入算法 图片

+

合并算法接受两个排序的 列出并将它们组合成一个 排序列表。 ● 虽然两个列表都是非空的，但比较它们的 第一要素。 删除较小的元素 并将其附加到输出。 ● 一旦一个列表为空，添加所有元素 另一个列表输出。 ● 它运行时间为 O(n)，其中 n 是总数 合并的元素数量。 图片 无限递归后的合并算法 图片 复杂度：nlog2n

+

容器类

+

set（集合）：无序不允许重复的容器类，可以添加删除元素 You can add a value to a Set by writing set += value; s. ● You can remove a value from a Set by writing set -= value; ● You can check if a value exists in a Set by writing set.contains(value)map(键值对的集合) 如果没有对应key的value，返回默认值（见定义文件） `vector vector的remove根据移除元素的索引有1-n的复杂度，移除尾部为O(1)，如果不在意索引，可以交换要移除元素和尾部元素再移除

+

哈希表

+

哈希表的负载因子α表示元素和表格键数量的比，决定了查找速度

+

检查表中是否存在元素

+

● 计算元素的散列码。 ● 跳转到表格中的那个位置。 ● 向前扫描——必要时环绕——直到项目或一个 发现空插槽。

+

将元素插入表中

+

● 如果项目已经存在，什么也不做。 ● 否则，跳转到元素哈希码给定的槽。 向前走——必要时环绕——直到一个空白点或 找到墓碑插槽。 然后，将项目放在那里。

+

从表中删除一个元素

+

● 跳转到由元素的散列码给定的槽。 ● 向前走——必要时环绕——直到物品或 发现空插槽。 如果找到该项目，请将其替换为 墓碑。

+

“罗宾汉哈希表”

+ +

string类

+

str::npos表示容器的最后一个成员位置 if (s.find("e") != string::npos) //find函数找不到时返回npos if s in str: string obj; obj.substr(int pos) //pos为要包含的第一个字符串的位置 std::string a = "0123456789abcdefghij";

+

    // count is npos, returns [pos, size())
    [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub1 = a.substr(10);
    [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub1 << '\n';

    // both pos and pos+count are within bounds, returns [pos, pos+count)
    [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub2 = a.substr(5, 3);
    [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub2 << '\n';

    // pos is within bounds, pos+count is not, returns [pos, size())
    [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub4 = a.substr(a.size()-3, 50);
    // this is effectively equivalent to
    // std::string sub4 = a.substr(17, 3);
    // since a.size() == 20, pos == a.size()-3 == 17, and a.size()-pos == 3

    [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub4 << '\n';

    try {
        // pos is out of bounds, throws
        [std::string](http://en.cppreference.com/w/cpp/string/basic_string) sub5 = a.substr(a.size()+3, 50);
        [std::cout](http://en.cppreference.com/w/cpp/io/cout) << sub5 << '\n';
    } catch(const [std::out_of_range](http://en.cppreference.com/w/cpp/error/out_of_range)& e) {
        [std::cout](http://en.cppreference.com/w/cpp/io/cout) << "pos exceeds string size\n";
    }
}
输出：
abcdefghij
567
hij
pos exceeds string size
+

`replace和insert str1.insert(start, str2) str1.replace(start, length, str2)

+

一些实现

+

优先队列

+
# include "HeapPQueue.h"
using namespace std;

HeapPQueue::HeapPQueue() {
    elems = new DataPoint[INITIAL_SIZE] {};
    for (int i=0;i<INITIAL_SIZE;i++)
    {
        elems[i].weight=0;
    }
    allocatedSize=INITIAL_SIZE;
}

HeapPQueue::~HeapPQueue() {
    delete [] elems;
}

int HeapPQueue::size() const {
    return logicalSize;
}

bool HeapPQueue::isEmpty() const {
    return logicalSize==0;
}

void HeapPQueue::enqueue(const DataPoint& data) {
    if (logicalSize+1<allocatedSize)
    {
        if (logicalSize==0)
        {
            elems[1]=data;
            logicalSize++;
        }
        else
        {
            logicalSize++;
            int i=1;
            while (data.weight>elems[i].weight && i<=logicalSize && elems[i].weight!=0)
            {
                i++;
            }
            if (i<logicalSize)
            {
                DataPoint temp=elems[i];
                elems[i]=data;
                for(i;i<logicalSize;i++)
                {
                    DataPoint temp_plus=elems[i+1];
                    elems[i+1]=temp;
                    temp=temp_plus;

                }
            }
            else
            {
                elems[i]=data;
            }

        }
    }
}

DataPoint HeapPQueue::peek() const {
    return elems[logicalSize];
}

DataPoint HeapPQueue::dequeue() {
    DataPoint to_return=elems[1];
    if(!isEmpty())
    {

        for (int i=1;i<logicalSize;i++)
        {
            elems[i]=elems[i+1];
        }
        elems[logicalSize]={};
        logicalSize--;
    }
    return to_return;
}

+

计数排序

+

首先算出最大值，然后用一个数组的索引存储待排序数组的成员，其索引对应值存储出现次数，然后用两个同步的for循环和递增的next参数表示排序中的索引值来进行排序（也就是重新赋值）

+
/* Given a Vector<int>, returns the largest number in that Vector. */
int maxOf(const Vector<int>& values) {
    /* Bounds-check inputs. */
    if (values.isEmpty()) {
        error("Can't find the maximum of no values.");
    }
    
    int result = values[0];
    for (int i = 1; i < values.size(); i++) {
        result = max(result, values[i]);
    }
    return result;
}

/* Given a list of numbers, creates a histogram from those numbers. */
Vector<int> histogramFor(const Vector<int>& values) {
    /* Create a histogram with the right number of slots. Initially, all values
     * in the histogram will be zero.
     */
    Vector<int> histogram(maxOf(values) + 1);
    
    /* Scan across the input vector, incrementing the histogram values. */
    for (int value: values) {
        histogram[value]++;
    }
    
    return histogram;
}

void countingSort(Vector<int>& values) {
    /* Edge Case: If the array is empty, then it's already sorted. This is
     * needed because we can't take the maximum value of an empty vector.
     */
    if (values.isEmpty()) {
        return;
    }
    
    /* Form the histogram. */
    auto histogram = histogramFor(values);
    
    /* Scan across the histogram writing out the appropriate number of copies
     * of each value. We track the index of the next free spot to write to,
     * as it varies based on how many items we've written out so far.
     */
    int next = 0;
    for (int value = 0; value < histogram.size(); value++) {
        /* Write out the right number of copies. */
        for (int copy = 0; copy < histogram[value]; copy++) {
            values[next] = value;
            next++;    
        }
    }
}

+

错题集

+

递归的效率优化

+

每次递归都会创造所有变量的临时复制 基于递归的这种性质，它会需要巨大的时间和空间来完成任务，并且会造成算力上的浪费。 通过记忆表机制能部分解决这个问题，方法是每次递归的返回值都会按索引存入一个表格，并且每次递归前查询表格中是否有结果，这样可以让每个临时副本的运算结果能被所有函数共享。

+

递归计算给定元素的不同结构哈夫曼树的数量

+

对每个给定元素集来说，首先要做到是确定根节点元素是第几个大的元素，确定之后，左子树和右子树的元素数也随之确定，在此之后分别对左节点和右节点作为根节点做同样的递归

+

int numBSTsOfSize(int n) {

  /* Base case: There’s only one tree of size 0, namely, the empty BST. */
  if (n == 0) return 1;
  
  /* Recursive case: Imagine all possible ways to choose a root and build the
   * left and right subtrees.
  */
  int result = 0;
  
  /* Put the the nodes at indices 0, 1, 2, ..., n-1 up at the root. */
  for (int i = 0; i < n; i++) {
    /* Each combination of a BST of i elements and a BST of n - 1 - i elements
     * can be used to build one BST of n elements. The number of pairs of
     * trees we can make this way is given by the product of the number of
     * trees of each type.
     */
     result += numBSTsOfSize(i) * numBSTsOfSize(n - 1 - i);
  }
  
  return result;
}
+

递归解决吃巧克力问题

+

求出吃法数量

+
if (numSquares<0)
{
    error("输入数据不能为负数");
}
else if (numSquares<=1)
{
    return 1;
}
else
{
    return numWaysToEat(numSquares-1)+numWaysToEat(numSquares-2);
}
+

打印每种吃法

+

`需要一个辅助向量储存历史记录

+
/* Print all ways to eat numSquares more squares, given that we've
 * already taken the bites given in soFar.
 */
void printWaysToEatRec(int numSquares, const Vector<int>& soFar) {
    /* Base Case: If there are no squares left, the only option is to use
     * the bites we've taken already in soFar.
     */
    if (numSquares == 0) {
        cout << soFar << endl;
    }
    /* Base Case: If there is one square lfet, the only option is to eat
     * that square.
     */
    else if (numSquares == 1) {
        cout << soFar + 1 << endl;
    }
    /* Otherwise, we take take bites of size one or of size two. */
    else {
        printWaysToEatRec(numSquares - 1, soFar + 1);
        printWaysToEatRec(numSquares - 2, soFar + 2);
    }
}

void printWaysToEat(int numSquares) {
    if (numSquares < 0) {
        error("You owe me some chocolate!");
    }

    /* We begin without having made any bites. */
    printWaysToEatRec(numSquares, {});
}
+

递归解决翻煎饼问题

+
bool isSorted(Stack<double> pancakes) {
    double last = -1; // No pancakes have negative size;

    while (!pancakes.isEmpty()) {
        /* Check the next pancake. */
        double next = pancakes.pop();
        if (next < last) {
            return false;
        }

        last = next;
    }

    /* Pancakes are in increasing order! */
    return true;
}

/* Given a stack of pancakes and a flip size, flips that many pancakes
 * on the top of the stack.
 */
Stack<double> flip(Stack<double> pancakes, int numToFlip) {
    /* Take the top pancakes off the stack and run them into a queue.
     * This preserves the order in which they were removed.
     */
    Queue<double> buffer;
    for (int i = 0; i < numToFlip; i++) {
        buffer.enqueue(pancakes.pop());
    }

    /* Move the pancakes back. */
    while (!buffer.isEmpty()) {
        pancakes.push(buffer.dequeue());
    }

    return pancakes;
}

Optional<Vector<int>> sortStack(Stack<double> pancakes, int numFlips) {
    /* Base Case: If the stack is sorted, great! We're done, and no flips
     * were needed.
     */
    if (isSorted(pancakes)) {
        return { }; // No flips
    }
    /* Base Case: If the stack isn't sorted and we're out of flips, then
     * there is no way to sort things.
     */
    else if (numFlips == 0) {
        return Nothing;
    }
    /* Recursive Case: The stack isn't sorted and we still have flips left.
     * The next flip could flip 1, 2, 3, ..., or all N of the pancakes.
     * Try each option and see whether any of them work.
     */
    for (int numToFlip = 1; numToFlip <= pancakes.size(); numToFlip++) {
        /* Make the flip and see if it works. */
        auto result = sortStack(flip(pancakes, numToFlip), numFlips - 1);
        if (result != Nothing) {
            /* The result holds all the remaining flips but doesn't know about
             * the flip we just did. Insert that flip at the beginning.
             */
            result.value().insert(0, numToFlip);
            return result;
        }
    }

    /* If we're here, then no matter which flip we make first, we cannot
     * get the pancakes sorted. Give up.
     */
    return Nothing;
}
+

递归解决天平问题

+
bool isMeasurableRec(int amount, const Vector<int>& weights, int index) {
  if (index == weights.size()) {
      return amount == 0;
  } else {
      return isMeasurableRec(amount,                  weights, index + 1) ||
             isMeasurableRec(amount + weights[index], weights, index + 1) ||
             isMeasurableRec(amount - weights[index], weights, index + 1);
  }
}

bool isMeasurable(int amount, const Vector<int>& weights) {
    return isMeasurableRec(amount, weights, 0);
}
+

想象一下，我们首先将要测量的数量（称为 n ）放在天平的左侧。 这使得规模上的不平衡等于 n 。 想象一下，有某种方法可以测量 n 。 如果我们一次将一个重量放在秤上，我们可以查看第一个重量的放置位置（假设它的重量为 w ）。 它必须：

+ +

如果确实有可能测量 n ，那么这三个选项之一必须是实现它的方法，即使我们不知道它是哪一个。 然后我们要问的问题是，是否有可能使用剩余的权重来衡量新的净失衡——我们可以递归地确定！ 另一方面，如果无法测量 n ，那么无论我们选择哪个选项，我们都会发现没有办法使用剩余的权重来使一切平衡！

+

如果我们递归地进行，我们在这里，我们需要考虑我们的基本情况。 我们可以选择的选项有很多。 一个简单的方法如下：假设我们根本没有任何重量，我们被要求查看是否可以不使用重量来测量某些重量。 在什么情况下我们可以这样做？ 好吧，如果我们称重的东西有一个非零重量，我们就不可能测量它——把它放在秤上会使它倾斜到某一边，但这并不能告诉我们它有多少重量。 另一方面，如果我们称量的东西是完全失重的，那么把它放在秤上也不会导致它倾斜，让我们相信它确实是失重的！ 因此，作为我们的基本情况，我们会说当我们减少到没有剩余权重时， ，我们可以精确测量n 如果 n = 0 。 考虑到这一点，这是我们的代码：

+

递归解决找零问题

+

不使用记忆的情况

+

`从第一个硬币开始遍历，并穷举它的所有枚数，将其作为下一枚硬币的参数传递

+
int fewestCoinsFor(int cents, const Set<int>& coins) {
    /* Can't have a negative number of cents. */
    if (cents < 0) {
        error("You owe me money, not the other way around!");
    }
    /* Base case: You need no coins to give change for no cents. */
    else if (cents == 0) {
        return 0;
    }
    /* Base case: No coins exist. Then it's not possible to make the
     * amount. In that case, give back a really large value as a
     * sentinel.
     */
    else if (coins.isEmpty()) {
        return cents + 1;
    }
    /* Recursive case: Pick a coin, then try using each distinct number of
     * copies of it that we can.
     */
    else {
        /* The best we've found so far. We initialize this to a large value so
         * that it's replaced on the first iteration of the loop. Do you see
         * why cents + 1 is a good choice?
         */
        int bestSoFar = cents + 1;
        /* Pick a coin. */
        int coin = coins.first();
        /* Try all amounts of it. */
        for (int copies = 0; copies * coin <= cents; copies++) {
            /* See what happens if we make this choice. Once we use this
             * coin, we won't use the same coin again in the future.
             */
            int thisChoice = copies + fewestCoinsFor(cents - copies * coin,
                                                     coins - coin);
          /* Is this better than what we have so far? */
            if (thisChoice < bestSoFar) {
                bestSoFar = thisChoice;
            }
        }
        /* Return whatever worked best. */
        return bestSoFar;
    }
}

+

使用记忆进行优化

+
/* How few coins are needed to make the total, given that we can only use
 * coins from index startIndex and onward?
 */
int fewestCoinsRec(int cents, const Vector<int>& coins, int startIndex,Grid<int>& memo) {
    /* Base case: You need no coins to give change for no cents. */
    if (cents == 0) {
        return 0;
    }
    /* Base case: No coins exist. Then it's not possible to make the
     * amount. In that case, give back a really large value as a
     * sentinel.
     */
    else if (startIndex == coins.size()) {
        return cents + 1;
    }
    /* Base case: We already know the answer. */
    else if (memo[cents][startIndex] != -1) {
        return memo[cents][startIndex];
    }
    /* Recursive case: Pick a coin, then try using each distinct number of
     * copies of it that we can.
     */
    else {
        /* The best we've found so far. We initialize this to a large value so
         * that it's replaced on the first iteration of the loop. Do you see
         * why cents + 1 is a good choice?
         */
        int bestSoFar = cents + 1;

        /* Pick a coin. */
        int coin = coins[startIndex];

        /* Try all amounts of it. */
        for (int copies = 0; copies * coin <= cents; copies++) {
            /* See what happens if we make this choice. Once we use this
             * coin, we won't use the same coin again in the future.
             */
            int thisChoice = copies + fewestCoinsRec(cents - copies * coin,
                                                     coins, startIndex + 1,
                                                     memo);

            /* Is this better than what we have so far? */
            if (thisChoice < bestSoFar) {
                bestSoFar = thisChoice;
            }
        }

        /* Return whatever worked best. */
        memo[cents][startIndex] = bestSoFar;
        return bestSoFar;
    }
}

int fewestCoinsFor(int cents, const Set<int>& coins) {
    /* Can't have a negative number of cents. */
    if (cents < 0) {
        error("You owe me money, not the other way around!");
    }

    /* Convert from a Set<int> to a Vector<int> so we have a nice ordering
     * on things.
     */
    Vector<int> coinVec;
    for (int coin: coins) {
        coinVec += coin;
    }

    /* Build our memoization table. Since the number of cents left ranges from
     * 0 to cents, we need cents+1 rows. Since the start index of the coin
     * ranges from 0 to coins.size(), we make coins.size() + 1 columns.
     *
     * -1 is used as a sentinel to indicate "nothing has been computed here
     * yet."
     */
    Grid<int> memo(cents + 1, coins.size() + 1, -1);

    /* Now ask how many coins are needed to make the total, using any coins
     * from index 0 onward.
     */
    return fewestCoinsRec(cents, coinVec, 0, memo);
}
+

递归穷举付账单

+

递归机制：对第一个人来说，0-total所有金额都会付一遍，随后传递给下一个人，当只有一人时，付清所有余额并打印账单 传递参数：string,int的映射存储目前为止的账单，string集合存储所有付账者

+
void listPossiblePaymentsRec(int total, const Set<string>& people,const Map<string, int>& payments) {
    /* Base case: if there's one person left, they have to pay the whole bill. */
    if (people.size() == 1) {
        Map<string, int> finalPayments = payments;
        finalPayments[people.first()] = total;
        cout << finalPayments << endl;
    }
    /* Recursive case: The first person has to pay some amount between 0 and the
     * total amount. Try all of those possibilities.
     */
    else {
        for (int payment = 0; payment <= total; payment++) {
            /* Create a new assignment of people to payments in which this first
             * person pays this amount.
             */
            Map<string, int> updatedPayments = payments;
            updatedPayments[people.first()] = payment;
            listPossiblePaymentsRec(total - payment, people - people.first(),updatedPayments);
        }
    }
}
void listPossiblePayments(int total, const Set<string>& people) {
    /* Edge cases: we can't pay a negative total, and there must be at least one
     * person.
     */
    if (total < 0) error("Guess you're an employee?");
    if (people.isEmpty()) error("Dine and dash?");
 listPossiblePaymentsRec(total, people, {});
}
+

递归寻找完全平方数列

+

主要参数为sofar——用于存储目前的序列和一个set用于存储还没放入数列的数字，`确保这两者同时被传递，且其并集为所有数字

+
Optional<Vector<int>> findSquareSequence(int n) {
    /*Validate input.*/
    if (n < 0) {
        error("Don't be so negative!");
    }

    /* Build a set of the numbers 1, 2, 3, ..., n. */
    Set<int> options;
    for (int i = 1; i <= n; i++) {
        options += i;
    }
    return findSequenceRec(options, { });
}

Optional<Vector<int>> findSequenceRec(const Set<int>& unused,
                                      const Vector<int>& soFar) {
    /*Base Case: If all numbers are used, we have our sequence!*/
    if (unused.isEmpty()) {
        return soFar;
    }

    /* Recursive Case: Some number comes next. Try each of them and see which
     * one we should pick.
     */
    for (int next: unused) {
        /* We can use this if either
         *
         * 1. the sequence is empty, so we're first in line, or
         * 2. the sequence is not empty, but we sum to a perfect square
         *    with the previous term.
         */
        if (soFar.isEmpty() ||
            isPerfectSquare(next + soFar[soFar.size() - 1])) {
            /* See what happens if we extend with this number. */
            auto result = findSequenceRec(unused - next, soFar + next);
            if (result != Nothing) {
                return result;
            }
        }
    }

    /* Tried all options and none of them worked. Oh well! */
    return Nothing;
}

+

汉诺塔递归

+

假设有三座汉诺塔，start ,temp ,finish 对n层的汉诺塔问题，先考虑n-1层的，随后考虑n-2层，到最后只需要考虑两层问题，两层的汉诺塔非常容易解决，起点为start,终点是temp,临时塔为finish，最后我们得到temp上的两层汉诺塔 这时将start的3移动到finish塔，这时只要将两层汉诺塔转移到finish则完成了三层汉诺塔，这个过程中的起点为temp,终点是finish,临时塔是start 以此类推，四层塔基于三层塔，n层塔基于n-1塔，汉诺塔问题解决

+
int moveTower(int numDisks, char start, char finish, char temp) {
    if (numDisks == 0) {
        return 0;
    } else {
        int movesOne = moveTower(numDisks - 1, start, temp, finish);
        moveSingleDisk(start, finish);
        int movesTwo = moveTower(numDisks - 1, temp, finish, start);

        return 1 + movesOne + movesTwo;
    }
}
+]]> + + 课程笔记 + 数据结构与算法 + + + 课程笔记 + 数据结构与算法 + c++ + 斯坦福 diff --git a/sitemap.txt b/sitemap.txt index 648ce9986..5aff88471 100644 --- a/sitemap.txt +++ b/sitemap.txt @@ -32,9 +32,9 @@ https://thinklive1.github.io/thinklive/28990/ https://thinklive1.github.io/thinklive/33908/ https://thinklive1.github.io/thinklive/14434/ https://thinklive1.github.io/thinklive/28549/ -https://thinklive1.github.io/thinklive/16615/ -https://thinklive1.github.io/thinklive/48468/ https://thinklive1.github.io/thinklive/15197/ +https://thinklive1.github.io/thinklive/48468/ +https://thinklive1.github.io/thinklive/16615/ https://thinklive1.github.io/thinklive/11069/ https://thinklive1.github.io/categories/index.html https://thinklive1.github.io/about/index.html @@ -49,9 +49,9 @@ https://thinklive1.github.io/tags/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E% https://thinklive1.github.io/tags/JAVA/ https://thinklive1.github.io/tags/%E6%B8%B8%E6%88%8F%E6%9D%82%E8%B0%88/ https://thinklive1.github.io/tags/black-souls/ -https://thinklive1.github.io/tags/%E6%96%AF%E5%9D%A6%E7%A6%8F/ -https://thinklive1.github.io/tags/c/ https://thinklive1.github.io/tags/%E8%AF%BB%E4%B9%A6%E7%AC%94%E8%AE%B0/ +https://thinklive1.github.io/tags/c/ +https://thinklive1.github.io/tags/%E6%96%AF%E5%9D%A6%E7%A6%8F/ https://thinklive1.github.io/tags/java/ https://thinklive1.github.io/tags/web%E5%BC%80%E5%8F%91/ https://thinklive1.github.io/tags/%E6%95%B0%E6%8D%AE%E7%A7%91%E5%AD%A6/ @@ -60,7 +60,6 @@ https://thinklive1.github.io/tags/%E9%BA%BB%E7%9C%81%E7%90%86%E5%B7%A5/ https://thinklive1.github.io/tags/%E5%8C%97%E4%BA%AC%E5%A4%A7%E5%AD%A6/ https://thinklive1.github.io/tags/linux/ https://thinklive1.github.io/tags/%E7%BC%96%E7%A8%8B%E5%B7%A5%E5%85%B7/ -https://thinklive1.github.io/tags/%E7%B3%BB%E7%BB%9F%E7%AE%A1%E7%90%86/ https://thinklive1.github.io/tags/vim/ https://thinklive1.github.io/tags/wrpg/ https://thinklive1.github.io/tags/%E9%BE%99%E8%85%BE%E4%B8%96%E7%BA%AA/ @@ -69,30 +68,31 @@ https://thinklive1.github.io/tags/408/ https://thinklive1.github.io/tags/%E5%BD%B1%E5%AD%90%E5%B7%A5%E5%8E%82/ https://thinklive1.github.io/tags/%E4%B8%8D%E4%BA%88%E6%92%AD%E5%87%BA/ https://thinklive1.github.io/tags/%E6%AD%A5%E8%A1%8C%E6%A8%A1%E6%8B%9F%E5%99%A8/ +https://thinklive1.github.io/tags/%E7%B3%BB%E7%BB%9F%E7%AE%A1%E7%90%86/ +https://thinklive1.github.io/tags/%E8%8B%8F%E5%B7%9E%E5%A4%A7%E5%AD%A6/ +https://thinklive1.github.io/tags/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/ +https://thinklive1.github.io/tags/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BB%84%E6%88%90/ https://thinklive1.github.io/tags/hexo/ https://thinklive1.github.io/tags/next/ https://thinklive1.github.io/tags/webstack/ https://thinklive1.github.io/tags/icarus/ -https://thinklive1.github.io/tags/%E8%8B%8F%E5%B7%9E%E5%A4%A7%E5%AD%A6/ -https://thinklive1.github.io/tags/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/ -https://thinklive1.github.io/tags/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BB%84%E6%88%90/ https://thinklive1.github.io/tags/%E7%A7%98%E5%AF%86/ https://thinklive1.github.io/tags/%E8%AE%A1%E7%BB%84/ -https://thinklive1.github.io/tags/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/ https://thinklive1.github.io/tags/%E4%B8%AD%E5%9B%BD%E7%A7%91%E5%AD%A6%E6%8A%80%E6%9C%AF%E5%A4%A7%E5%AD%A6/ +https://thinklive1.github.io/tags/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/ https://thinklive1.github.io/tags/%E8%BF%AA%E7%91%9E%E5%85%8B%E6%8B%89/ https://thinklive1.github.io/categories/%E8%80%83%E7%A0%94%E7%AC%94%E8%AE%B0/ https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/ https://thinklive1.github.io/categories/%E6%B8%B8%E6%88%8F%E6%9D%82%E8%B0%88/ -https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/ https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/%E5%85%B6%E4%BB%96/ +https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/ https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/web%E5%BC%80%E5%8F%91/ https://thinklive1.github.io/categories/%E6%B8%B8%E6%88%8F%E6%9D%82%E8%B0%88/black-souls/ https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/%E6%95%B0%E6%8D%AE%E7%A7%91%E5%AD%A6/ https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/ -https://thinklive1.github.io/categories/%E5%BB%BA%E7%AB%99%E7%BB%8F%E9%AA%8C/ https://thinklive1.github.io/categories/%E5%A4%87%E5%BF%98%E5%BD%95/ https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/%E8%AE%A1%E7%BB%84/ +https://thinklive1.github.io/categories/%E5%BB%BA%E7%AB%99%E7%BB%8F%E9%AA%8C/ https://thinklive1.github.io/categories/%E7%A7%98%E5%AF%86/ -https://thinklive1.github.io/categories/%E8%BF%AA%E7%91%9E%E5%85%8B%E6%8B%89/ https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/ +https://thinklive1.github.io/categories/%E8%BF%AA%E7%91%9E%E5%85%8B%E6%8B%89/ diff --git a/sitemap.xml b/sitemap.xml index e6a75bb78..449985c64 100644 --- a/sitemap.xml +++ b/sitemap.xml @@ -308,7 +308,7 @@ - https://thinklive1.github.io/thinklive/16615/ + https://thinklive1.github.io/thinklive/15197/ 2023-11-27 @@ -326,7 +326,7 @@ - https://thinklive1.github.io/thinklive/15197/ + https://thinklive1.github.io/thinklive/16615/ 2023-11-27 @@ -445,7 +445,7 @@ - https://thinklive1.github.io/tags/%E6%96%AF%E5%9D%A6%E7%A6%8F/ + https://thinklive1.github.io/tags/%E8%AF%BB%E4%B9%A6%E7%AC%94%E8%AE%B0/ 2024-07-21 weekly 0.2 @@ -459,7 +459,7 @@ - https://thinklive1.github.io/tags/%E8%AF%BB%E4%B9%A6%E7%AC%94%E8%AE%B0/ + https://thinklive1.github.io/tags/%E6%96%AF%E5%9D%A6%E7%A6%8F/ 2024-07-21 weekly 0.2 @@ -521,13 +521,6 @@ 0.2 - - https://thinklive1.github.io/tags/%E7%B3%BB%E7%BB%9F%E7%AE%A1%E7%90%86/ - 2024-07-21 - weekly - 0.2 - - https://thinklive1.github.io/tags/vim/ 2024-07-21 @@ -585,49 +578,56 @@ - https://thinklive1.github.io/tags/hexo/ + https://thinklive1.github.io/tags/%E7%B3%BB%E7%BB%9F%E7%AE%A1%E7%90%86/ 2024-07-21 weekly 0.2 - https://thinklive1.github.io/tags/next/ + https://thinklive1.github.io/tags/%E8%8B%8F%E5%B7%9E%E5%A4%A7%E5%AD%A6/ 2024-07-21 weekly 0.2 - https://thinklive1.github.io/tags/webstack/ + https://thinklive1.github.io/tags/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/ 2024-07-21 weekly 0.2 - https://thinklive1.github.io/tags/icarus/ + https://thinklive1.github.io/tags/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BB%84%E6%88%90/ 2024-07-21 weekly 0.2 - https://thinklive1.github.io/tags/%E8%8B%8F%E5%B7%9E%E5%A4%A7%E5%AD%A6/ + https://thinklive1.github.io/tags/hexo/ 2024-07-21 weekly 0.2 - https://thinklive1.github.io/tags/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/ + https://thinklive1.github.io/tags/next/ 2024-07-21 weekly 0.2 - https://thinklive1.github.io/tags/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BB%84%E6%88%90/ + https://thinklive1.github.io/tags/webstack/ + 2024-07-21 + weekly + 0.2 + + + + https://thinklive1.github.io/tags/icarus/ 2024-07-21 weekly 0.2 @@ -648,14 +648,14 @@ - https://thinklive1.github.io/tags/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/ + https://thinklive1.github.io/tags/%E4%B8%AD%E5%9B%BD%E7%A7%91%E5%AD%A6%E6%8A%80%E6%9C%AF%E5%A4%A7%E5%AD%A6/ 2024-07-21 weekly 0.2 - https://thinklive1.github.io/tags/%E4%B8%AD%E5%9B%BD%E7%A7%91%E5%AD%A6%E6%8A%80%E6%9C%AF%E5%A4%A7%E5%AD%A6/ + https://thinklive1.github.io/tags/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/ 2024-07-21 weekly 0.2 @@ -692,14 +692,14 @@ - https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/ + https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/%E5%85%B6%E4%BB%96/ 2024-07-21 weekly 0.2 - https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/%E5%85%B6%E4%BB%96/ + https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/ 2024-07-21 weekly 0.2 @@ -734,21 +734,21 @@ - https://thinklive1.github.io/categories/%E5%BB%BA%E7%AB%99%E7%BB%8F%E9%AA%8C/ + https://thinklive1.github.io/categories/%E5%A4%87%E5%BF%98%E5%BD%95/ 2024-07-21 weekly 0.2 - https://thinklive1.github.io/categories/%E5%A4%87%E5%BF%98%E5%BD%95/ + https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/%E8%AE%A1%E7%BB%84/ 2024-07-21 weekly 0.2 - https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/%E8%AE%A1%E7%BB%84/ + https://thinklive1.github.io/categories/%E5%BB%BA%E7%AB%99%E7%BB%8F%E9%AA%8C/ 2024-07-21 weekly 0.2 @@ -762,14 +762,14 @@ - https://thinklive1.github.io/categories/%E8%BF%AA%E7%91%9E%E5%85%8B%E6%8B%89/ + https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/ 2024-07-21 weekly 0.2 - https://thinklive1.github.io/categories/%E8%AF%BE%E7%A8%8B%E7%AC%94%E8%AE%B0/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/ + https://thinklive1.github.io/categories/%E8%BF%AA%E7%91%9E%E5%85%8B%E6%8B%89/ 2024-07-21 weekly 0.2 diff --git a/steamgames/index.html b/steamgames/index.html index 09622bb94..f0de46a8f 100644 --- a/steamgames/index.html +++ b/steamgames/index.html @@ -6305,14 +6305,14 @@

Steam游戏库 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/tags/408/index.html b/tags/408/index.html index 3e9d5e4a3..b00a89a8b 100644 --- a/tags/408/index.html +++ b/tags/408/index.html @@ -321,14 +321,14 @@

408 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git a/tags/JAVA/index.html b/tags/JAVA/index.html index 3535f4cd0..665e5c70a 100644 --- a/tags/JAVA/index.html +++ b/tags/JAVA/index.html @@ -321,14 +321,14 @@

JAVA 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git a/tags/black-souls/index.html b/tags/black-souls/index.html index 443b2d205..238144fe5 100644 --- a/tags/black-souls/index.html +++ b/tags/black-souls/index.html @@ -306,8 +306,8 @@

black souls

-
@@ -326,8 +326,8 @@

black souls
-
@@ -361,14 +361,14 @@

black souls 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/tags/c/index.html b/tags/c/index.html index 274c8a36b..b3fdea309 100644 --- a/tags/c/index.html +++ b/tags/c/index.html @@ -286,8 +286,8 @@

c++

-
@@ -326,8 +326,8 @@

c++
-
@@ -361,14 +361,14 @@

c++ 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/tags/hexo/index.html b/tags/hexo/index.html index 7637de58f..c2fa827b9 100644 --- a/tags/hexo/index.html +++ b/tags/hexo/index.html @@ -321,14 +321,14 @@

hexo 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git a/tags/icarus/index.html b/tags/icarus/index.html index b092f872a..2ac9d8d3a 100644 --- a/tags/icarus/index.html +++ b/tags/icarus/index.html @@ -321,14 +321,14 @@

icarus 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git a/tags/index.html b/tags/index.html index 083550ed0..2cef7d3f2 100644 --- a/tags/index.html +++ b/tags/index.html @@ -314,14 +314,14 @@

tags 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git a/tags/java/index.html b/tags/java/index.html index 232383f7e..3d5894041 100644 --- a/tags/java/index.html +++ b/tags/java/index.html @@ -321,14 +321,14 @@

java 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git a/tags/linux/index.html b/tags/linux/index.html index 42ea07c45..3f4a65c20 100644 --- a/tags/linux/index.html +++ b/tags/linux/index.html @@ -361,14 +361,14 @@

linux 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git a/tags/next/index.html b/tags/next/index.html index 8523a947c..020845b37 100644 --- a/tags/next/index.html +++ b/tags/next/index.html @@ -321,14 +321,14 @@

next 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git a/tags/pandas/index.html b/tags/pandas/index.html index 5195812a6..f0476a43e 100644 --- a/tags/pandas/index.html +++ b/tags/pandas/index.html @@ -341,14 +341,14 @@

pandas 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git a/tags/python/index.html b/tags/python/index.html index e067a2fe2..43f8df910 100644 --- a/tags/python/index.html +++ b/tags/python/index.html @@ -381,14 +381,14 @@

python 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git a/tags/vim/index.html b/tags/vim/index.html index 7da40a5a0..ceb40cc71 100644 --- a/tags/vim/index.html +++ b/tags/vim/index.html @@ -321,14 +321,14 @@

vim 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git a/tags/webstack/index.html b/tags/webstack/index.html index 26c0de670..d10bf66ef 100644 --- a/tags/webstack/index.html +++ b/tags/webstack/index.html @@ -321,14 +321,14 @@

webstack 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/web\345\274\200\345\217\221/index.html" "b/tags/web\345\274\200\345\217\221/index.html" index ff2d81204..a8cd13b9d 100644 --- "a/tags/web\345\274\200\345\217\221/index.html" +++ "b/tags/web\345\274\200\345\217\221/index.html" @@ -321,14 +321,14 @@

web开发 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git a/tags/wrpg/index.html b/tags/wrpg/index.html index 0e0324c3a..134b41f12 100644 --- a/tags/wrpg/index.html +++ b/tags/wrpg/index.html @@ -321,14 +321,14 @@

wrpg 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\344\270\215\344\272\210\346\222\255\345\207\272/index.html" "b/tags/\344\270\215\344\272\210\346\222\255\345\207\272/index.html" index af1d2075e..4d987a666 100644 --- "a/tags/\344\270\215\344\272\210\346\222\255\345\207\272/index.html" +++ "b/tags/\344\270\215\344\272\210\346\222\255\345\207\272/index.html" @@ -321,14 +321,14 @@

不予播出 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\344\270\255\345\233\275\347\247\221\345\255\246\346\212\200\346\234\257\345\244\247\345\255\246/index.html" "b/tags/\344\270\255\345\233\275\347\247\221\345\255\246\346\212\200\346\234\257\345\244\247\345\255\246/index.html" index 5a8a0bc86..41feff02a 100644 --- "a/tags/\344\270\255\345\233\275\347\247\221\345\255\246\346\212\200\346\234\257\345\244\247\345\255\246/index.html" +++ "b/tags/\344\270\255\345\233\275\347\247\221\345\255\246\346\212\200\346\234\257\345\244\247\345\255\246/index.html" @@ -321,14 +321,14 @@

中国科学技术大学 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\344\274\257\345\205\213\345\210\251/index.html" "b/tags/\344\274\257\345\205\213\345\210\251/index.html" index b63fa1f2e..020c1533d 100644 --- "a/tags/\344\274\257\345\205\213\345\210\251/index.html" +++ "b/tags/\344\274\257\345\205\213\345\210\251/index.html" @@ -401,14 +401,14 @@

伯克利 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\345\214\227\344\272\254\345\244\247\345\255\246/index.html" "b/tags/\345\214\227\344\272\254\345\244\247\345\255\246/index.html" index 6eb41d8ed..ee1fa3272 100644 --- "a/tags/\345\214\227\344\272\254\345\244\247\345\255\246/index.html" +++ "b/tags/\345\214\227\344\272\254\345\244\247\345\255\246/index.html" @@ -341,14 +341,14 @@

北京大学 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\345\267\253\345\270\2102/index.html" "b/tags/\345\267\253\345\270\2102/index.html" index 25e1d7e97..5fdcb5404 100644 --- "a/tags/\345\267\253\345\270\2102/index.html" +++ "b/tags/\345\267\253\345\270\2102/index.html" @@ -321,14 +321,14 @@

巫师2 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\345\275\261\345\255\220\345\267\245\345\216\202/index.html" "b/tags/\345\275\261\345\255\220\345\267\245\345\216\202/index.html" index eb36ac427..8b2ac46fb 100644 --- "a/tags/\345\275\261\345\255\220\345\267\245\345\216\202/index.html" +++ "b/tags/\345\275\261\345\255\220\345\267\245\345\216\202/index.html" @@ -321,14 +321,14 @@

影子工厂 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\346\223\215\344\275\234\347\263\273\347\273\237/index.html" "b/tags/\346\223\215\344\275\234\347\263\273\347\273\237/index.html" index f94d65eb6..fa96d99ad 100644 --- "a/tags/\346\223\215\344\275\234\347\263\273\347\273\237/index.html" +++ "b/tags/\346\223\215\344\275\234\347\263\273\347\273\237/index.html" @@ -344,14 +344,14 @@

操作系统 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\346\225\260\346\215\256\347\247\221\345\255\246/index.html" "b/tags/\346\225\260\346\215\256\347\247\221\345\255\246/index.html" index 5a42d5662..c7c2698c6 100644 --- "a/tags/\346\225\260\346\215\256\347\247\221\345\255\246/index.html" +++ "b/tags/\346\225\260\346\215\256\347\247\221\345\255\246/index.html" @@ -361,14 +361,14 @@

数据科学 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/index.html" "b/tags/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/index.html" index 3c1461713..393636305 100644 --- "a/tags/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/index.html" +++ "b/tags/\346\225\260\346\215\256\347\273\223\346\236\204\344\270\216\347\256\227\346\263\225/index.html" @@ -424,14 +424,14 @@

数据结构与算法 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\346\226\257\345\235\246\347\246\217/index.html" "b/tags/\346\226\257\345\235\246\347\246\217/index.html" index 5ccf61628..1b679364e 100644 --- "a/tags/\346\226\257\345\235\246\347\246\217/index.html" +++ "b/tags/\346\226\257\345\235\246\347\246\217/index.html" @@ -286,8 +286,8 @@

斯坦福

-
@@ -306,8 +306,8 @@

斯坦福
-
@@ -341,14 +341,14 @@

斯坦福 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git "a/tags/\346\255\245\350\241\214\346\250\241\346\213\237\345\231\250/index.html" "b/tags/\346\255\245\350\241\214\346\250\241\346\213\237\345\231\250/index.html" index 9140b5997..b59583357 100644 --- "a/tags/\346\255\245\350\241\214\346\250\241\346\213\237\345\231\250/index.html" +++ "b/tags/\346\255\245\350\241\214\346\250\241\346\213\237\345\231\250/index.html" @@ -321,14 +321,14 @@

步行模拟器 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\346\270\270\346\210\217\346\235\202\350\260\210/index.html" "b/tags/\346\270\270\346\210\217\346\235\202\350\260\210/index.html" index d8320aa7b..09d2f3f2e 100644 --- "a/tags/\346\270\270\346\210\217\346\235\202\350\260\210/index.html" +++ "b/tags/\346\270\270\346\210\217\346\235\202\350\260\210/index.html" @@ -326,8 +326,8 @@

游戏杂谈

-
@@ -346,8 +346,8 @@

游戏杂谈
-
@@ -381,14 +381,14 @@

游戏杂谈 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git "a/tags/\347\240\224distance/index.html" "b/tags/\347\240\224distance/index.html" index 4117cba6a..685625ce3 100644 --- "a/tags/\347\240\224distance/index.html" +++ "b/tags/\347\240\224distance/index.html" @@ -364,14 +364,14 @@

研distance 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\347\247\230\345\257\206/index.html" "b/tags/\347\247\230\345\257\206/index.html" index 53c96e27e..436891d64 100644 --- "a/tags/\347\247\230\345\257\206/index.html" +++ "b/tags/\347\247\230\345\257\206/index.html" @@ -404,14 +404,14 @@

秘密 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\347\263\273\347\273\237\347\256\241\347\220\206/index.html" "b/tags/\347\263\273\347\273\237\347\256\241\347\220\206/index.html" index 0cfc1c51b..199b096e7 100644 --- "a/tags/\347\263\273\347\273\237\347\256\241\347\220\206/index.html" +++ "b/tags/\347\263\273\347\273\237\347\256\241\347\220\206/index.html" @@ -321,14 +321,14 @@

系统管理 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\347\274\226\347\250\213\345\267\245\345\205\267/index.html" "b/tags/\347\274\226\347\250\213\345\267\245\345\205\267/index.html" index c1232f667..9a1a4db89 100644 --- "a/tags/\347\274\226\347\250\213\345\267\245\345\205\267/index.html" +++ "b/tags/\347\274\226\347\250\213\345\267\245\345\205\267/index.html" @@ -361,14 +361,14 @@

编程工具 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\350\213\217\345\267\236\345\244\247\345\255\246/index.html" "b/tags/\350\213\217\345\267\236\345\244\247\345\255\246/index.html" index c09741090..1e710a60a 100644 --- "a/tags/\350\213\217\345\267\236\345\244\247\345\255\246/index.html" +++ "b/tags/\350\213\217\345\267\236\345\244\247\345\255\246/index.html" @@ -381,14 +381,14 @@

苏州大学 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220/index.html" "b/tags/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220/index.html" index c393cba83..1bc574e90 100644 --- "a/tags/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220/index.html" +++ "b/tags/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220/index.html" @@ -321,14 +321,14 @@

计算机组成 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234/index.html" "b/tags/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234/index.html" index bd0363426..16517d298 100644 --- "a/tags/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234/index.html" +++ "b/tags/\350\256\241\347\256\227\346\234\272\347\275\221\347\273\234/index.html" @@ -341,14 +341,14 @@

计算机网络 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\350\256\241\347\273\204/index.html" "b/tags/\350\256\241\347\273\204/index.html" index 82ca850b8..fa9d4ce16 100644 --- "a/tags/\350\256\241\347\273\204/index.html" +++ "b/tags/\350\256\241\347\273\204/index.html" @@ -321,14 +321,14 @@

计组 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\350\257\273\344\271\246\347\254\224\350\256\260/index.html" "b/tags/\350\257\273\344\271\246\347\254\224\350\256\260/index.html" index 6fff76549..bdb0e6e71 100644 --- "a/tags/\350\257\273\344\271\246\347\254\224\350\256\260/index.html" +++ "b/tags/\350\257\273\344\271\246\347\254\224\350\256\260/index.html" @@ -321,14 +321,14 @@

读书笔记 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\350\257\276\347\250\213\347\254\224\350\256\260/index.html" "b/tags/\350\257\276\347\250\213\347\254\224\350\256\260/index.html" index f880275ab..440d90dc2 100644 --- "a/tags/\350\257\276\347\250\213\347\254\224\350\256\260/index.html" +++ "b/tags/\350\257\276\347\250\213\347\254\224\350\256\260/index.html" @@ -326,8 +326,8 @@

课程笔记

-
@@ -346,8 +346,8 @@

课程笔记
-
@@ -466,8 +466,8 @@

课程笔记
-
@@ -504,14 +504,14 @@

课程笔记 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git "a/tags/\350\257\276\347\250\213\347\254\224\350\256\260/page/2/index.html" "b/tags/\350\257\276\347\250\213\347\254\224\350\256\260/page/2/index.html" index a720372cb..dee2e0d63 100644 --- "a/tags/\350\257\276\347\250\213\347\254\224\350\256\260/page/2/index.html" +++ "b/tags/\350\257\276\347\250\213\347\254\224\350\256\260/page/2/index.html" @@ -286,8 +286,8 @@

课程笔记

-
@@ -404,14 +404,14 @@

课程笔记 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git "a/tags/\350\277\252\347\221\236\345\205\213\346\213\211/index.html" "b/tags/\350\277\252\347\221\236\345\205\213\346\213\211/index.html" index 0b48f4470..90ce40855 100644 --- "a/tags/\350\277\252\347\221\236\345\205\213\346\213\211/index.html" +++ "b/tags/\350\277\252\347\221\236\345\205\213\346\213\211/index.html" @@ -286,8 +286,8 @@

迪瑞克拉

-
@@ -306,8 +306,8 @@

迪瑞克拉
-
@@ -364,14 +364,14 @@

迪瑞克拉 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git "a/tags/\351\272\273\347\234\201\347\220\206\345\267\245/index.html" "b/tags/\351\272\273\347\234\201\347\220\206\345\267\245/index.html" index 95bb7d01f..8ba98bced 100644 --- "a/tags/\351\272\273\347\234\201\347\220\206\345\267\245/index.html" +++ "b/tags/\351\272\273\347\234\201\347\220\206\345\267\245/index.html" @@ -381,14 +381,14 @@

麻省理工 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git "a/tags/\351\276\231\350\205\276\344\270\226\347\272\252/index.html" "b/tags/\351\276\231\350\205\276\344\270\226\347\272\252/index.html" index 45331eb6a..25509a1ac 100644 --- "a/tags/\351\276\231\350\205\276\344\270\226\347\272\252/index.html" +++ "b/tags/\351\276\231\350\205\276\344\270\226\347\272\252/index.html" @@ -321,14 +321,14 @@

龙腾世纪 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22

diff --git a/thanks/index.html b/thanks/index.html index 1b609759f..50eaa80f5 100644 --- a/thanks/index.html +++ b/thanks/index.html @@ -316,14 +316,14 @@

And you

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/thinklive/11069/index.html b/thinklive/11069/index.html index e2ab16156..6c8f501b5 100644 --- a/thinklive/11069/index.html +++ b/thinklive/11069/index.html @@ -344,14 +344,14 @@

本文字数： - 19k + 12k 阅读时长 ≈ - 18 分钟 + 43 分钟

@@ -731,14 +731,14 @@

还有更多的 Vim 小窍门吗？ 站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/thinklive/11086/index.html b/thinklive/11086/index.html index ea08aeb7e..2941006c4 100644 --- a/thinklive/11086/index.html +++ b/thinklive/11086/index.html @@ -344,14 +344,14 @@

本文字数： - 3.7k + 2.5k 阅读时长 ≈ - 3 分钟 + 9 分钟

@@ -469,8 +469,8 @@

进阶

-
@@ -504,14 +504,14 @@

进阶

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/thinklive/14434/index.html b/thinklive/14434/index.html index f8fde1b22..a788604e8 100644 --- a/thinklive/14434/index.html +++ b/thinklive/14434/index.html @@ -333,14 +333,14 @@

本文字数： - 2.4k + 2.1k 阅读时长 ≈ - 2 分钟 + 8 分钟

@@ -424,13 +424,13 @@

度量

-
-
@@ -464,14 +464,14 @@

度量

站点总字数： - 723k + 386k 站点阅读时长 ≈ - 10:58 + 23:22
diff --git a/thinklive/15197/index.html b/thinklive/15197/index.html index 6b29350f2..3f2a316d6 100644 --- a/thinklive/15197/index.html +++ b/thinklive/15197/index.html @@ -32,8 +32,8 @@ - + @@ -338,14 +338,14 @@

本文字数： - 5.9k + 3.2k 阅读时长 ≈ - 5 分钟 + 12 分钟

@@ -466,8 +466,8 @@

匿名函数