20250112

最近一周重新看完了《围城》，新看了一本关于英伟达创始人的书《黄仁勋的绿皮书，果断买了一点英伟达的股票，开始系统梳理学习AI。趁着周末总结一下，进行一波大脑训练吧。

1. 围城： 这本书其实大学时候，还是刚毕业那会看过一次，记忆不深刻。当时给我的感觉就是婆婆妈妈的很琐碎的事情，但是开辟了一个民国时期的 留学生 的爱情故事，当时focus的点在 方鸿渐如何如何谈恋爱，哎呀。工作了5年之后，重新看感觉还是很不一样的。
   故事结构：方鸿渐家庭背景，父亲是一个老乡绅，这家庭条件应该是当时的社会阶层，其实放在现在，甩开很多人几条街了，所以出国留学 不正经上课好像也是理所当然？浪荡的公子哥，其实年轻的时候舒服了这么一段时间。 当时的社会背景是日本 侵华战争，由于这个他父亲也没有一个风险意识，经过日本大兵的一顿抢劫，家底直接清空了。真实要家庭背景没家庭背景，要本领也没学着一身本领，主要还染上了一堆臭毛病，高不成，低不就，还清高，艾，就这样随着时代的潮流往前走了。 故事再往下走，一个老同学，家庭条件非常好的 苏文纨 看上他了，叫一般人都 愿意上去当上门女婿了，艾，还是太年轻了，后面经过一顿狗血的剧情，勾搭上 苏文纨的表妹了，跟唐晓芙经历了一波刻骨铭心的 拉扯，也没在一起，最后闹的大家都不愉快。 点评： 爱情这个东西，看不上就是看不上，动心了就是动心了。
   再往下跟赵辛楣、孙柔嘉他们出差去高校当老师，算是正式出入社会了，一路上通行5个人，每个人都心怀心思，个有算盘，也算是领略一番人间真相了。 正式入职之后，高校长、各个主任、xx夫人，碰到人多的地方，加上每个人的心思，再加上每个人的大喇叭，使得局面变的更加复杂，职场也不好混啊。 最后稀里糊涂取了 孙柔嘉，职场不顺心，碰到一个能说上话的人，凑合凑合得了。婚姻不是两个人的事情，后面随着两个人生活的碰撞，朋友、亲人 各种琐碎的冲突接踵而来，撞的两个人都懵懵的。故事以一顿争吵冲突结束。
   钱老从一个人的年轻时候的样子->谈了爱情->一路上的算不上朋友的同行人->同事&职场->婚姻。 这一路过来跌跌撞撞。 从方鸿渐一直找赵辛楣大腿上来看，还是觉的尽量靠自己本事吃饭，有求于人，是一定没有前途的，碰到坎坷，困难，一定要自己解决，逃避是没有出路的啊。

2. 黄仁勋：这本自传 从黄仁勋周围xxx人的视角，来剖析的这个人。 从小台湾->泰国->美国乡村。面对暴力，用智慧、坚强的性格对面对，从小就有一股劲。 我想说这个东西生来有就有，没有就没有，冒险家是不能培养的，海明威中的老人与海中的老人的那种精神，生来有就有，没有就别去奢望。不过这种精神，必须要迈出第一步，打败第一个敌人，这样才能有正反馈，不断的享受这波冒险、坚硬带来正向反馈。 解决复杂问题： 1.性格是底色，你愿不愿意解决复杂的问题 2.是能不能的问题，如果你的性格，意志，没有被短暂的困难打倒，我相信，他是有能力去解决复杂问题的。

从英伟达这家公司视角来看：三个创史人中，黄仁勋就是那个主导者，他愿意为了他的信仰，付出一切，同时感染了一帮人，愿意为他赴汤蹈火，减轻老黄的压力。如果你准备做一件事，需要认真的问一下自己，这件事，你认可么？认可程度是多少，这件事的本质是能解决多少人的实际的问题？你认可自己的价值么？如果你真正不为短期利益，而毅然决然的追求自己内心认为有价值的事情，即使短期不被认可，也需要有勇气坚定的坚持下去，老黄坚持了10多年。 外部压力一定有，就看你自己如何看待这件事的价值，不被认可&压力一定是能够被解决的！！！！

作者：1903-1950，1984 是奥威尔最后一本小说，在1948年写的，书名是48的倒过来。
这里只能浅显的讲一下自己的感受了，作者本身处于的时代是比较动荡的，对于其中的历史背景可能还是得再通过其它奥威尔的作品和背景资料去感受。
但是小说中的预言的的确确确 曾经发生过，我怀疑这本书可能被当成过使用手册了…
作品中的主人公：温斯顿、曾经邂逅爱情的对象： 朱莉亚、还有一个内党成员：奥布莱恩

这本政治小说 描绘了一个 极其反乌托邦的世界。 我们想象一下，乌托邦是什么样子的： 人人自由，人人平等，无需法律，无需政府的和谐世界，每个人都有充足的资源，可以不用因为吃穿住行 而发愁，也可以去想去的地方度假。这种社会有个前提： 资源充足、社会和谐。 资源充足代表着这个世界必须使用机器代替人力资源，才能将人类解脱出来，处于乌托邦世界；和谐代表着，这个社会运行的前提是：人性是永远是善良的，人性是不会做恶的。基于这两个前提才可能有一个乌托邦的状态，而且这个状态是转瞬即逝的，不可持久的。
不可持久的原因：从我的理解看，人性是复杂的，对于人性永远善良这个假设太过理想，只要有一刻、一丝对于人性善良的怀疑，这个状态就崩溃了。 所以我们需要法律、公序良序去制约人性，我们每个人需要牺牲一点东西，比如自由，交给可信的一群人 去制定法律，去进行监管，这个时候等级社会就慢慢产生了。 等级社会是世界运行的底色，也是人性博弈后的结果。

小说描绘的这个社会是一个极其 集权的社会，最高统领叫做 “老人家” ，这个社会分成了三等人，上等人、中等人、下等人。 内党核心成员：上等人，外党成员： 中等人，其它人：下等人。主人公温斯顿 和 朱莉亚 都是外党成员员，奥布莱恩是内党核心成员。

描绘的社会中大街上到老人家提出的口号：
战争即和平、
自由即奴役、
无知即力量。

小说开头看到这个口号真是一脸懵逼，这到底是个啥社会。

自由即奴役：反乌托邦的社会是啥样子？ 统治者撕去了为人民谋幸福的 伪装，直接了当，就是为了权力，为了统治人的权利。 其中有一个逻辑： 谁掌握了现在，谁就掌握了过去，谁掌握了过去，谁就掌握了未来。 掌握了现在，所以可以肆意的篡改过去，承载 “过去” 的实体： 文本、音视频、思想。 只要想要篡改的 统统都需要抹去，重置，文本资料通过人力，重新印刷、篡改就可以了。思想如何重置呢？ 这个社会提出了一个叫双重思想的东西，就是 A 发生了，我们知道它发生了，但是某个时间点 告诉 A发生的不对，其实是 B 发生了，这个时候，人的思想必须 抹去A的存在，忠实的承认 B 发生了，这个社会是将 唯心主义普及了一个遍。 在这个社会中如果 你不发自内心的承认B 发生了，而说 A 发生了，那你就有思想罪，需要思想改造，甚至判处死刑。 在这套逻辑下，谁掌握了现在，谁就真正掌握了过去了，无论是历史资料 还是思想方面。 在这个社会，需要管控的是哪类人？ 上等人本身就是 双重思想的制定者，他们也对双重思想深信不疑。 下等人：如果他们有思考能力就不是下等人了，他们对于这个社会根本构不成任何的威胁。 中等人：外党成员 有思想，有能力，自然是重点关照的对象了。 哪一天中等人想要代替上等人构造一个新的社会，那又是什么样子呢？ 等级社会的属性没有变，只是换了一个壳子而已。 所以下等人没有思考能力 反而是最自由的，所以有了那句自由即奴役。

战争即和平： 小说中的国家分成了三个：大洋国、欧亚国、东亚国。 三国分立，实现核子和平的时候，战争就失去了战争的意义了。那战争既然没有输赢，为啥还要战争呢？ 战争只是处理生产资料过剩的一种手段，因为乌托邦世界不是 老人家的目标，权利才是。战争利于国内外稳定，何乐不为呢？

无知即力量： 群众的无知就是社会稳定最强大的力量

小说构造的这个社会消灭了一切人性，包括自由的思想、性欲，人必须要接受思想封印，并且接受思想警察的监督，老人家的目标达到了，但是人已经不是人了。

动物庄园是 奥威尔 1984之前的一本寓言小说，小说的核心观点，其实1984也提到过，但一两句话，远没有一篇寓言故事那么形象。

核心观点: 还如上一篇分析 1984，社会是由人组成的，只要有人的地方，等级社会就不可避免，灵魂发问：乌托邦应该是什么样子的？ 人类的乌托邦，真的能实现么？

题外思考：我们一直喊的自由，但什么是自由？缺少约束的自由 是自由么？没有约束的自由是还自由么？ 平等？平等又是什么？理想平等的前提是 我们所有的人类是机器人，而且运行程序，输入输出都是一样的机器人，这样无论是感受，还是喜好，或是信仰.. 所有所有的上层想象都是相等的。但人之所以是人，人类文明之所以伟大，就在于绚烂与不同。

关于英特耐雄纳尔能实现么这个问题，作者的底色还是相当悲观的。

小说寓言故事中，动物庄园里的所有动物受到一个智者的影响，开始以赶走庄园主人类，并且解放自己进而实现乌托邦作为目标。动物们成功的将人类赶走了，但是绝大多数动物对于乌托邦没有概念，大多数动物甚至没有文化到 不认识字。 庄园动物赶走了人类，他们真正解放了么？ 把一个群体比做一个人，如果一个群体没有形成 思考用的大脑，传播用的嘴巴，干活用的胳膊，那这个群体就是一盘散沙，很快被其它的群体给pk掉。所以群体中的大脑，可以支配身体协调的运动，让自己变得更健康 强壮，每个角色各司其职，但是别忘了，群体里的大脑并不是个人的大脑，他们是一群人，干的活是思考，支配。 下面都是干活的。所以，即使这个身体非常健康，强壮，协调性特别好，干思考活的人就是比 卖力气的人 有更多资源，于是在一群人中，干思考活动的人资源 比 干宣传的人 资源多一些，干宣传的人的资源，比卖力气的人的资源多一些，那等级就这么慢慢产生了。

大脑还会蛊惑身体的各个部位，让他们按照自己的想法行事，寓言故事中，动物们合力把之前的大脑给赶走了，但是身体的其他部位还是会慢慢滋生一种脑组织，继续支配身体 “自由活动”，继续蛊惑身体的各个部位组织。

石油： 洛克菲勒
铁路：范特比尔特
铁路&钢铁： 卡内基
汽车： 福特
电气&金融： 二代摩根

使命，创造力，激情，智慧 把19世纪的美国，从0开始 建设了 完善的工业体系，带全世界的人类 走上了高速发展的列车。 爱恨情仇，为人类发展贡献的宏伟目标，这些人 的共同点是 看到了 未来人类 发展 需要什么，新兴技术 在未来给人类生活改变了什么，他们为止激动，自豪的点，我深深能感受的到，过程中碰到的 困难 在宏大的目标面前总能化解。
在最后结尾的时候 对于 洛克菲勒 & 卡内基 这两个兄弟 比 捐赠，感到有敬佩，又好笑，洛克菲勒晚年捐赠的 图书馆，学校，为人类的医疗贡献发展 而做的努力，真的 就像他自己感觉的，就是上帝点中了他，作为上帝的选民 来拯救世界的～ respect respect。

从这些人可以学到的一点是： 敏锐发现可以推动人类发展 or 社会发展的苗头，all in 进去， 垄断其实也是 整合 规范市场，我觉得无可厚非，使命感驱动了 这一辈先人 给我们创造了 如今世界的 大的框架。我想他们的思想，胸怀，市场上的杀伐决断，拯救人类的使命感 值得我自己的学习的，从中应该可以 找到自己价值的同时 能够推动 人类往前迈出一小步。

你当像鸟飞往你的山 Educated
https://www.zhihu.com/question/354406357/answer/928711802

– 开始读这本书的时候，并没有带着一些好奇，也没有提前了解一些作者的背景，知道读完了全书，才了解到，全篇表达的深层意义。
塔拉·韦斯特弗 Tara Westover，美国历史学家、作家。1986年生于爱达荷州的山区。十七岁前从未上过学。通过自学考取杨百翰大学，2008年获文学学士学位。随后获得盖茨剑桥奖学金，2009年获剑桥大学哲学硕士学位。2010年获得奖学金赴哈佛大学访学。2014年获 剑桥大学历史学博士学位。2018年出版处女作《你当像鸟飞往你的山》。2019年因此书被《时代周刊》评为“年度影响力人物”。

作者的17岁之前一直都是在山里，甚至他们选择住在山上也是他们的父亲、母亲做的一种抉择，塔拉的母亲从小受着公主般的严格教育，这种家庭压迫教育或许是推动它要死死的跟随一个农场主，并且逃离塔拉外祖母安排的生成的社会生活，选择了另一种极端的生活方式；他们的生活和我想象中的中国的山区还是有很大的区别的，他们家拥有整座山，拥有良好的收入，拥有汽车、能买的上想要买的电脑等等，他们在物质上面未曾缺失过什么， 但是偏偏是这种偏僻的地方，却更容易滋生精神上偏执的问题，在精神上与世隔绝，极端的信仰摩门教，偏僻的山区，在政府的管辖范围的边缘，为极端疯狂的教徒提供了方便。
作为一个中国出生的95后，很难想象这种极端的教条，还有塔拉父亲对于教条偏执的态度，塔拉的父亲一直认为山下的“摩门教”被政府洗脑了，不让他们的孩子们上学。。。认为穿着暴露是一种妓女的行为。这也是导致塔拉在上大学的时候，发现自己与这个社会各个不入的原因。17岁的偏执，哥哥的暴力，在塔拉真正接触知识社会的那一刻 快要撕裂了。 最绝的是塔拉的父亲认为它的女儿在接触外界的那一刻，改变自身的那一刻，便被背叛了宗教，也背叛了家庭，在塔拉上了大学之后，他的父母也会劝塔拉，让回重新皈依摩门教，回归家庭，即使她已经拿到了剑桥的学位，在读哈弗的博士。
最终的爆发点或许就是她的哥哥肖恩，一个控制狂，类似于今天的pua，疯狂的pua，折磨家庭的每一个人，最暴力的把塔拉的头塞进马桶，N次，有一次还是在塔拉带着男朋友回家，当着她男朋友的面，这…. 一次姐姐也告诉塔拉曾经收到肖恩的折磨，于是塔拉决定向父母求助。然而。。。肖恩拿着刀子威胁，拿着**威胁。 父母认为肖恩在教会已经收到上帝的洗礼，而塔拉是一个叛徒，全家支持的方向也转向了肖恩。塔拉也与全家决裂了。。。
后来在哈弗读博士的时候，我想塔拉天天颓废的看电视剧的那段时间，应该是精神上面的一个至暗时刻了，她甚至认为外接改变了她，她获取了良好的教育，世俗的认可与家庭的背叛，和家庭的决裂相比，得不偿失，这种情感上的撕裂，需要另一种方法去救赎。没错，是它的上学的博士导师，是教会的主教，是他的那位在中东读书的男朋友，也是17岁之前的经历，让她在读书的时候去思考女权，去思考犹太屠杀，甚至去思考摩门教的深层意义。在思考这些的同时，我想她也救赎了曾经的自己，但是面对从小建立的感情，不管不顾的“背叛”他们，绝对的割裂是否过于残忍？

– 教育的意义在我们认识这个世界，认识到曾经生活地方的一些荒唐的时候，我们有我们理性的思考与选择，在面对外界、历史的时候有一个清醒的认识，但是面对原生家庭对于父母的情感，教育在这一方面是否又真正的救赎了作者呢？

HHKB

中英文； control+ space
大小写 shift +. Or fn + table

上下左右： opt. + ijkl. Or fn + 上下左右
启动台 comand + 0
切换桌面 opt + control + ijkl

删除 control + d or. control + h
跳到行首：control + a 跳到行尾: control + e

google
切换页面 command + control + []

Item
切换页面 command + []

霍乱时期的爱情

https://www.zhihu.com/question/274223889/answer/1617314344

看完了全书，仿佛自己过了 N 遍人生，也仿佛过了一生，仿佛看到了自己，但自己也没有弗洛伦蒂诺 那么守着一生的精神上的童贞，最后我看上面的分享说的挺好的，全书最幸运的一个人，就是女主角费尔明娜，一生都不懂爱情，却被爱情眷顾了一生。

爱情： 是合适的生活？ 获取世俗的安全感？既然合适的在一起不是爱情，那，真正的爱情是什么？ 是那惊鸿一瞥？是那一瞬间的回望，那虚无缥缈的东西，渐渐被神话的了鲜花女神？ 最后，我想 费尔明娜和乌尔比诺医生 的相遇结合，也是挺好的，但是，没有爱的结合，没有爱的驱使，我们靠什么去维持一个家，维护彼此？盲目的责任？ 就像乌尔比诺医生和芭芭拉•林奇小姐的一见倾心，是否也是普罗大众 身在迷宫中的一种探索呢？ 探索自己不敢违背世俗，探索自己内心深处的一颗种子。
我想，每个时代的每个人每个阶段想要的东西不一样，对于爱情的定义也不一样吧，尤其对于普罗大众来说，爱情这种东西好像是可遇不可求的东西？为啥这么说？我想每个人都有每个人自己的答案，但是我觉的霍乱时期的爱情的作者 加西亚•马尔克斯 帮助我们普罗大众把爱情给总结了一下，也不算总结，带我们观摩，参观了一下世间百态的爱情，也许真正的爱情对于我们普罗大众来说 是没有勇气的，世间有几个弗洛伦蒂诺。 况且，在世俗中，我们甘心 做一个精神上的和尚么？在精神上为心爱的等上一辈子？ 这可能也是为啥 普罗大众普通而又平凡并且还会迷茫的原因吧。

一个社会学教授，一个体育新闻播报员的学生。社会学教授：母亲很早的去世了，父亲也比较的冷淡的对待家庭，整体上来说是一个挺不幸的一个人，后面也是用其一生去产出爱，维护爱。
作为一个面对死神的一个活泼的、健康的的社会学教授，面对爱情、社会、家庭、感情、原谅、工作、生活是一种什么样的态度？面对社会、面对家庭、面对感情是否要坦诚相对。
一个人在生活的意义是什么？为了事业？为了金钱？为了物欲？为了名声？为了地位？为了？？？短期来看，为了房子？还是为了车子？ 这些东西是否是社会外界压力强制push给你的？这些是你想要的么？花了很多时间，很多钱买的房子就是为了买一个安全感？ 那么一个人真正的安全感是谁给的呢？一个人的内心深处受家庭的爱影响有多大呢？我想抛去了金钱，一个家庭，一个组织，真诚，“爱”才能让彼此感受到真正的安全感，人与人之间的坦诚和爱、或者可以说是善意我想也是人应该作为社会属性应该有的一种东西。
那么我们穷极一生，追寻我们一生挚爱，保护我们一生挚爱，我们穷极一生去履行我们的责任、义务去保护我们相爱的人的时候，其实无形之间成员与成员之间的信任感，互相的爱，我想这才是一个人一生中最值得骄傲的东西，也是在家族历史上，在社会上最坚实的力量（ 物质方面在此面前略显暗淡）；
那么除去爱｜家庭，社会还赋予了我们其他的属性，在社会中的工作，无论是当程序员，还是货代，我们是否找到了我们存在的价值，我们是否认可我们的工作对这个世界是有正向作用的？ 改变世界或许很空洞，什么叫改变世界了？改变别人的生活习惯，让人们生活的更加方便，打压掉一些**内容，让人们生活在一片祥和、安全的社会环境之中； 再或者发布一个足以改变现有规则的一款产品，改变世界的口径或许不需要别人来评价，或许不需要第三视角，只要我们真诚的问一下我们的内心，你今天改变世界了么？ 你的工作是否有意义呢？
除去爱与工作，生活方面是否需要去做点什么呢？ 我们抛去了繁忙的工作，在改变世界之余，是否有点个人的兴趣爱好？ 去做一些让自己真正有肾上腺素的东西，真实激动，兴奋的事情。目前好像没找到，不过，个人挺喜欢读书，和旅行的，后面是否可以拾起学习英语的兴趣呢，兴趣也是可以慢慢培养的嘛，也是为了后面环球旅行做准备呢
……
最后这个教授是以一个马上要死的一个人的视角去讲述的，作为一个将要去世的人，他的内心独白，仍然要把这种“爱”传播给身边的人，愿意和身边亲密的人做一些互动。思考一下，如果处于这个角色中，你来回看你的现在，有什么事情是你非做不可的呢？又有什么事情是你放心不下的呢？你的时间会如何处理呢？

DNS

打开host文件
sudo vim /etc/hosts
加入新的映射关系
140.82.114.4 github.com
sudo killall -HUP mDNSResponder

窗口、标签快捷键
0、⌘ + n 打开新窗口
1、⌘ + Shift + w 关闭当前窗口
2、⌘ + Option + 向左箭头键 跳转到上一个打开的标签页
3、⌘ + t 打开新的标签页，并跳转到该标签页
4、⌘ + Shift + t 重新打开最后关闭的标签页，并跳转到该标签页
5、⌘ + [ 或 ⌘ + 向左箭头键 打开当前标签页浏览记录中记录的上一个页面
6、⌘ + w 关闭当前标签页或弹出式窗口
7、⌘ + q 退出 Google Chrome

chrome 快捷键

1、⌘ + Option + b 打开书签管理器
2、⌘ + , 在新标签页中打开“设置”页
3、⌘ + y 在新标签页中打开“历史记录”页
4、⌘ + Shift + j 在新标签页中打开“下载内容”页

ref: https://www.jianshu.com/p/75adf667f61a

Iterm:

iTerm2设置及使用

Git:

Sumery:
1、撤销修改
场景1：当你改乱了工作区某个文件的内容，想直接丢弃工作区的修改时，用命令git checkout file
场景2：当你不但改乱了工作区某个文件的内容，还添加到了暂存区时，想丢弃修改，分两步，第一>步用命令git reset HEAD file，就回到了场景1，第二步按场景1操作。
（git reset命令既可以回退版本，也可以把暂存区的修改回退到工作区。当我们用HEAD时，表示最>新的版本。）
2、 soft hard mixed区别

1、初始化
git init //创建
git clone /path/to/repository //检出
git config –global user.email “you@example.com“ //配置email
git config –global user.name “Name” //配置用户名
git remote add origin url

2、操作
git add // 文件添加，A → B
git add . // 所有文件添加，A → B
git commit -m “代码提交信息” //文件提交，B → C
git commit –amend //与上次commit合并, *B → C
git push origin master //推送至master分支, C → D
git pull //更新本地仓库至最新改动， D → A
git fetch //抓取远程仓库更新， D → C
git log //查看提交记录
git status //查看修改状态
git diff//查看详细修改内容
git show//显示某次提交的内容

3、撤销操作
git reset //某个文件索引会回滚到最后一次提交， C → B
git reset//索引会回滚到最后一次提交， C → B
git reset –hard // 索引会回滚到最后一次提交， C → B → A
git checkout // 从index复制到workspace， B → A
git checkout – files // 文件从index复制到workspace， B → A
git checkout HEAD – files // 文件从local repository复制到workspace， C → A

4、分支
git checkout -b branch_name //创建名叫“branch_name”的分支，并切换过去
git checkout master //切换回主分支
git branch -d branch_name // 删除名叫“branch_name”的分支
git push origin branch_name //推送分支到远端仓库
git merge branch_name // 合并分支branch_name到当前分支(如master)
git rebase //衍合，线性化的自动， D → A

5、冲突处理
git diff //对比workspace与index
git diff HEAD //对于workspace与最后一次commit
git diff <source_branch> <target_branch> //对比差异
git add //修改完冲突，需要add以标记合并成功

Sumery:
1、撤销修改
场景1：当你改乱了工作区某个文件的内容，想直接丢弃工作区的修改时，用命令git checkout file
场景2：当你不但改乱了工作区某个文件的内容，还添加到了暂存区时，想丢弃修改，分两步，第一步用命令git reset HEAD file，就回到了场景1，第二步按场景1操作。
（git reset命令既可以回退版本，也可以把暂存区的修改回退到工作区。当我们用HEAD时，表示最新的版本。）
2、 soft hard mixed区别

1、自定义键盘快捷键：文件->首选项->键盘快捷方式 常见的快捷键

给定两个字符串 s1 和 s2，写一个函数来判断 s2 是否包含 s1 的排列。
换句话说，第一个字符串的排列之一是第二个字符串的子串。
示例1:
输入: s1 = “ab” s2 = “eidbaooo”
输出: True
解释: s2 包含 s1 的排列之一 (“ba”).
示例2:
输入: s1= “ab” s2 = “eidboaoo”
输出: False

经典滑动窗口：

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

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
        if (s1.size() > s2.size()) {
            return false;
        }
        int windowsize = s1.size();                         
        vector<int> hashmap1(26, 0);
        vector<int> hashmap2(26, 0);
        for (int i = 0; i < windowsize; i++) {
            hashmap1[s1[i] - 'a']++;
            hashmap2[s2[i] - 'a']++;
        }
        for (int i = windowsize; i < s2.size(); i++) {
            if (hashmap1 == hashmap2) {
                return 1;
            }
            hashmap2[s2[i - windowsize] - 'a']--;               //窗口右移
            hashmap2[s2[i] - 'a']++;
        }
        return hashmap1 == hashmap2;
    }
};

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例 1：
输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。
示例 2：
输入: “cbbd”
输出: “bb”

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

class Solution {
public:
    int getNum(string s, int i, int j) {
        while (i >= 0 && j < s.size() && s[i] == s[j]) {
            i--;
            j++;
        }
        return j - i - 1;
    }
    string longestPalindrome(string s) {
         if (s.size() == 0)
            return s;
        int st = 0, e = 0;
        for (int i = 0; i < s.size() - 1; i++) {
            int len1 = getNum(s, i, i);
            int len2 = getNum(s, i, i+1);
            int len = max(len1, len2);
            if (len > e - st) {
                st = i - (len - 1) / 2;
                e = i + len / 2;
            }
        }
        return s.substr(st, e - st + 1);
    }
    
};

应用场景

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

class Trie {
public:
    /** Initialize your data structure here. */
    Trie* next[26] = {NULL};
    bool isLeaf;
    Trie() {
        isLeaf = false;
    }
    
    /** Inserts a word into the trie. */
    void insert(string word) {
        Trie* node = this;
        for (char c : word) {
            int i = int(c - 'a');
            if (node->next[i] == NULL) {
                node->next[i] = new Trie();
            }
            node = node->next[i];
        }
        node->isLeaf = true;
        return;
    }
    
    /** Returns if the word is in the trie. */
    bool search(string word) {
        Trie* node = this;
        for (char c : word) {
            int i = int(c - 'a');
            if (node->next[i]) {
                node = node->next[i];
            } else {
                return 0;
            }
        }                      
        if (node->isLeaf) {
            return 1;
        }
        return 0;
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    bool startsWith(string prefix) {
        Trie* node = this;
        for (char c : prefix) {
            int i = int(c - 'a');
            if (node->next[i]) {
                node = node->next[i];
            } else {
                return 0;
            }
        }
     
        return 1;
    }           
};

一个有符号的有序数组,问这些数平方之后有多少个不重复的数?

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

#include<bits/stdc++.h>
using namespace std;
int func(vector<int> a) {
	int num = 1;
	int pre = abs(a[0]);
	int n = a.size();
	int i = 0, j = n-1;
	while (i < j) {
		if (a[i] > a[j]) {
			if (pre != abs(a[i])) {
				pre = abs(a[i]);
				num++;
			}
			i++;
		} else {
			if (pre != abs(a[j])) {
				pre = abs(a[j]);
				num++;
			}
			j--;
		}
	}
	return num;
}
int main()
{
	int v[] =  {-5,-3,-1,1,1,2};
  	vector<int> a (v, v + 6);
	int num = func(a);
	cout<<num<<endl;
}

两种方法：
1.dp 时间复杂度O（n^2）
2.贪心 + 二分 时间复杂度 O(n*log(n))

1.dp

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

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        vector<int> b;
        b.push_back(1);
        int maxx = 1;
        for (int i = 1; i < nums.size(); i++) {
            int m = 0;
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i] && b[j] > m) {
                    m = b[j];
                }
            }
            b.push_back(m+1);
            maxx = max(b[i], maxx);
        }
        return maxx;
    }
};

2.贪心 + 二分
a[i]表示第i个数据。
dp[i]表示表示长度为i+1的LIS结尾元素的最小值。
利用贪心的思想，对于一个上升子序列，显然当前最后一个元素越小，越有利于添加新的元素，这样LIS长度自然更长。
因此，我们只需要维护dp数组，其表示的就是长度为i+1的LIS结尾元素的最小值，保证每一位都是最小值，

这样子dp数组的长度就是LIS的长度。

dp数组具体维护过程同样举例讲解更为清晰。
同样对于序列 a(1, 7, 3, 5, 9, 4, 8)，dp的变化过程如下：

dp[0] = a[0] = 1，长度为1的LIS结尾元素的最小值自然没得挑，就是第一个数。 （dp = {1}）
对于a[1]=7，a[1]>dp[0]，因此直接添加到dp尾，dp[1]=a[1]。（dp = {1, 7}）
对于a[2]=3，dp[0]< a[2]< dp[1]，因此a[2]替换dp[1]，令dp[1]=a[2]，因为长度为2的LIS，结尾元素自然是3好过于7，因为越小这样有利于后续添加新元素。 （dp = {1, 3}）
对于a[3]=5，a[3]>dp[1]，因此直接添加到dp尾，dp[2]=a[3]。 （dp = {1, 3, 5}）
对于a[4]=9，a[4]>dp[2]，因此同样直接添加到dp尾，dp[3]=a[9]。 （dp = {1, 3, 5, 9}）
对于a[5]=4，dp[1]< a[5]< dp[2]，因此a[5]替换值为5的dp[2]，因此长度为3的LIS，结尾元素为4会比5好，越小越好嘛。（dp = {1, 3, 4, 9}）
对于a[6]=8，dp[2]< a[6]< dp[3]，同理a[6]替换值为9的dp[3]，道理你懂。 （dp = {1, 3, 5, 8}）
这样子dp数组就维护完毕，所求LIS长度就是dp数组长度4。
通过上述求解，可以发现dp数组是单调递增的，因此对于每一个a[i]，先判断是否可以直接插入到dp数组尾部，

即比较其与dp数组的最大值即最后一位；如果不可以，则找出dp中第一个大于等于a[i]的位置，用a[i]替换之。
这个过程可以利用二分查找，因此查找时间复杂度为O(logN)，所以总的时间复杂度为O(N*logN)

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

class Solution {
public:
    int binary(vector<int> v, int x) {
        int i = 0, j = v.size() - 1;
        while (i < j) {
            int mid = i + (j - i) / 2;
            if (v[mid] >= x) {
                j = mid;
            } else {
                i = mid + 1;
            }
           
        }
        
        return i;
    }
    
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        int len = 0;
        vector<int> dp;
        dp.push_back(nums[0]);
        for (int i = 1; i < n; i++) {
            if (nums[i] > dp[len]) {
                dp.push_back(nums[i]);
                len++;
            } else {
                int id = binary(dp, nums[i]);
                dp[id] = nums[i];
                
            }
        }
        return len + 1;
    }
};

给定一个二叉树，找到其中最大的二叉搜索树（BST）子树，其中最大指的是子树节点数最多的。
输入: [10,5,15,1,8,null,7]

10
/ \
5 15
/ \ \
1 8 7
其中最大的BTS子树是 5 1 8

1.判断是不是BTS：

1
2
3
4
5
6
7
8
9
10

bool bst(TreeNode* root) {
        return pd(root, INT_MIN, INT_MAX);
}
bool pd(TreeNode*root, int low, int high) {
        if (root == NULL) return 1;
        if (root->val > low && root->val <high) {
            return pd (root->left, low, root->val) && pd(root->right, root->val, high);
        }
        return 0;
}

2.统计某个树的结点数量：

1
2
3
4
5
6

int num(TreeNode* root) {
        if (root == NULL) return 0;
        int left = num(root->left);
        int right = num(root->right);
        return left + right + 1;
}

3.实现：

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

int largestBSTSubtree(TreeNode* root) {
      if (root == NULL) {
          return 0;
      }
      if (bst(root)) {
          return  num(root);
      }
      int left = largestBSTSubtree(root->left);
      int right = largestBSTSubtree(root->right);
      
      return max(left, right);
  }

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
简单分析：
假设给出一个字符串： abcdechjil
第一个重复字符是c, 然而如果是简单暴力的话， 第一次从a开始找，找到第一个重复字符c，break，然后下一次要从b开始找
但是发现一个问题，因为b在 c的左边， 所以无论怎么样 无重复字符最长字串长度 都不会大于 从a开始遍历的长度。
所以，下一次直接从重复字符c的下一个字符d开始遍历就ok。

1
2
3
4
5

//暴力伪代码
for (int i = 0; i < n； i++)
{   
    for (int j = i + 1; j < n; j++)  
}

1.没用队列

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

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if (s.size() == 1) return 1;
        map<char,int> m;
        int n = s.size();
        int maxx = 0;
        int j = 0;
        for (int i = 0; i < n; i++) {  
            if (m.find(s[i]) != m.end()) {                                  //找到了
                int id = m[s[i]];
                for (int z = j; z < id; z++) {
                    m.erase(s[z]);
                }
                maxx = max(maxx, i - j);
                j = id + 1;
                // flag = 1;
            } else {
                maxx = max(maxx, i - j + 1);
            }
            m[s[i]] = i;
        }
        return maxx;
    }
};

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

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        queue<int> q;
        map<char, int> m;
        int maxx = 0;
        for (int i = 0; i < s.size(); i++) {
            if (m.find(s[i]) == m.end()) {
                q.push(s[i]);
                m[s[i]] = 1;
                int size = q.size();
                maxx = max(maxx, size);
            } else {
                while (!q.empty() && q.front() != s[i]) {
                    char c = q.front();
                    q.pop();
                    m.erase(c);
                }
                q.pop();
                q.push(s[i]);
            }
        }
        return maxx;
        
    }
};

给定一个树，按中序遍历重新排列树，使树中最左边的结点现在是树的根，并且每个结点没有左子结点，只有一个右子结点。
示例 ：

输入：[5,3,6,2,4,null,8,1,null,null,null,7,9]

   5
  / \
3    6

/ \ \
2 4 8
/ / \
1 7 9

输出：[1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]

1
\
2
\
3
\
4
\
5
\
6
\
7
\
8
\
9

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

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    
    
    TreeNode* increasingBST(TreeNode* root) {
        if (root == NULL) return root;
        root->right = increasingBST(root->right);
        if (root->left) {
            TreeNode* left = root->left;
            root->left = NULL;
            TreeNode* node = left;
            while (node->right) {
                node = node->right;
            }
            node->right = root;
            return increasingBST(left);
         }
        return root;
        
    }
};