工作区-(暂存区)-本地仓库-远程仓库

1. 基本操作

2. 工作区文件状态转换

• 已追踪状态：纳入版本控制，【已修改/未修改/已暂存】状态
  注： 经克隆下来的仓库处于：【已跟踪(未修改)】状态
• 未追踪状态：未被纳入版本控制。
  注：例如经克隆下来的仓库，在仓库添加一个文件，该文件处于未跟踪
  • 未跟踪的文件经过git add命令转换到【已跟踪】(已暂存)
  • 未修改的文件经过【修改】—>【已修改】
  • 已修改的文件经过git add命令转换到【已暂存】
  • 已暂存的文件经过git commit命令转换到【未修改】
  • 未修改的文件经过git rm 命令转换到【未跟踪】， 文件被删除。

3. 分支相关操作

• Git branch -a 查看所有分支，HEAD指向
• Git checkout 分支名 ，切换分支
• git status 查看当前分支状态
• Git reflog 历史操作s
• Git merge 合并远程和本地仓库的冲突
• git clone -b 分支名 克隆指定仓库的分支到本地

  3.1 克隆指定仓库分支，修改后再上传到该分支

  首先将指定分支克隆下来：

  git clone -b <分支名> <url>.git

  其次新建一个本地分支并与远程分支关联，同时切换到本地分支：

  git checkout -b <本地分支名> origin/<远程分支名>

  此时，开始修改克隆下来的分支文件，修改好以后，将当前目录添加至缓冲区

  git add .  # 添加新增的、修改的文件或者git add -A # 添加新增的、修改的、删除的文件

  接下来将缓存区的目录提交至本地仓库

  git commit -m <"修改的注释">

  最后将本地仓库push到远程仓库：

  git push origin <远程仓库名>

4. Git 撤销commit 方法

• Git revert (还原某个commit， 但留下还原记录)，其基本用法为，其中 -n 表示，表示revert以后需要重新提交一个commit信息再推送，若不使用 -n 则会弹出vim编辑commit注释。

  git revert -n <commit-id>

  假如有一条commit线，

  graph LR;subgraph flowA-->B-->Cend

  上方的revert命令中(可通过git log命令查看)为B的id，则执行以上命令后，commit线变为以下

  graph LR;subgraph flowA-->B-->C-->Dendsubgraph pointerHEAD-->masterendmaster-->D

• Git reset (整段commit还原，不留记录，其修改HEAD指针的指向位置。

  git reset --hard <commit-id>

  变为之前的commit-id对应版本)。适用于只想恢复到之前某个提交的版本，后面的都不要了，用commit图表示如下，还是上面的commit线，假如需要回退到A版本，将上面的commit-id设为A，执行命令后变为如下:

  graph LR;subgraph flowAendsubgraph pointerHEAD-->master-->Aend

对率回归原理及其编程实现

原理

用线性模型解决分类问题，只需找一个单调可微函数将分类任务的标记y与线性回归模型的预测值联系起来。而对数几率函数正是这样的一个常用替代函数：

令$z = \vec{\omega}^T\vec{x}+b$，则可得到：

令 $p(y = 1 | \vec{x}) = y$，则$p(y=0|\vec{x}) = 1-p(y = 1 | \vec{x})$，这里假定为二分类任务，则有：

运用“极大似然法”，则对率回归模型最大似然函数如下：

令$\beta = ({\vec{w};b})$，令$\dot{x} = (\vec{x};1)$，则$\vec{\omega}^T\vec{x}+b = \beta^T\dot{x}$。再令$p_{1}(\dot{x};\beta) = p(y=1|\dot{x};\beta)$，则$p_{0}(\dot{x};\beta)=p(y=0|\dot{x};\beta)=1-p_{1}(\dot{x};\beta)$，则上式为：

最大化上式等价于最小化下式，

上式是关于$\beta$的高阶可导连续凸函数，根据凸优化理论，可用梯度下降法和牛顿法求得其最优解。
这里给出第$t+1$代牛顿迭代法公式：

其中$\ell(\beta)$的一阶，二阶导如下：

代码所用算法与数据结构分析

因为目标函数是凸函数，所以可以直接将数据代入目标函数，用经典最优化算法进行求解。

Python语言实现

可以将格式化后的数据集存入文件（数据集较小），每次运行读取数据放入内存进行迭代最优化求解即可。代码库见我的码云
雨落纷飞

疫情期间，学校要求每天都要提交体温等相关信息（如果不按时提交就会被全院通报😳，为了写脚本付出了仅有的一次），就想着写一个脚本放到服务器上每天定时自动提交，付诸自己好几个月前的想法。在这里记录自己学习、写脚本的过程，同时可怜一下学校的服务器。

写这个脚本用到的技术，经过研究，可以用Python的selenim库或者urllib、requests库，但是后者需要更多的Web相关背景知识，由于我用进废退，脑中残存的Web相关知识只剩那些最基础的了，还是在实践中增长知识吧。

1. 尝试用selenium库

　　这个库的学习成本极其低，一篇博客就可以入门了。selenium教程。看完之后就着手写脚本了。疫情通的整个填报动作分解如下：

登录->获取地理位置->提交->确认提交

但是在脚本写完后却遇到了两个致命的问题，使我不得不转向使用urllib或requests库。

• 问题1：Windows系统获取地理位置信息具有不稳定性，每次脚本运行到获取地理位置时大多数都是要么定位失败，要么定位不准，在这种情况下只能放弃这个方法了。
• 问题2：js里面弹出的确认框wapconfirm并不能被识别，好了，一朝回到解放前。
  

2.尝试用requests库

i. 分析整个表单的提交过程

据我现有的Web知识，从登录界面开始分析：
根据观察，在登录界面点击登录之前该网站下只有1个Cookie，

点击登录后，会将username和password用ajax技术通过post方式提交到验证登录网站，

验证通过后，该网站下的cookies由1个变成了4个，

接着跳转向填报界面，在填报界面根据新增的Cookie，后台获取该用户的前一天的填报信息并填好，留下地理位置需要手动获取。获取位置信息后，将之以post方式提交到服务器。

ii. 大致思路

1)尝试直接复制出整个data包，以post方式提交至目标地址。

经过观察，data包算是解析出来了，但是这个数据命名实在是惨不忍睹（变量每个汉字拼音的首字母，现在是知道了阅读变量命令不清晰的程序的感觉，口吐芬芳）。用Notepad++的Compare插件对比 def（今天要提交的数据） 和 oldInfo（昨天的数据），发现多了后面4行数据，在页面找了一番后无果，索性在处理了一下def数据包，直接提交至目标网址，但服务器响应返回的却是整个填报系统的登录入口页面，说明在提交时，可能服务器还对提交者的身份进行验证，具体应该是通过验证请求头的Cookie，最终还是要进行模拟登录。

2)进行模拟登陆，获取cookies后再提交信息，最后编写接口程序

经过分析，整个脚本流程图绘制如下：

完整代码见我的github明月光

邮箱授权码获取方法如下图：

参考资料：
提取用户昨天提交的信息的正则表达式来自以下大佬博客，自己也该好好学一学正则表达式了。其中发送邮件方法也来自这篇博客，丰富了我的见识：
记一次SCU疫情期间每日健康报送任务的自动化处理（一）

　　最近根据相关法律法规要求：域名在哪个云服务提供商备案就必须将该域名解析到云服务提供商的服务器，这波操作秀啊。这下白嫖了两年的Github Pages服务也用不了了，为了不放弃我这个域名。😐。弱弱地买了一个弱弱的学生(qióngbi)版低配服务器，花了一天时间将博客弱弱的部署到服务器上了。在这里总结一下自己踩的坑。

方法

　　考虑到网上有很多写的不错的将Hexo博客部署到服务器的博客，我就不重复造轮子了。下面是一些我当时参考的博客的链接：

• 带你跳过各种坑，一次性把 Hexo 博客部署到自己的服务器
• 记录Hexo部署到阿里云服务器全过程
• 从零搭建Hexo博客并部署阿里云服务器（奶妈级教学）
• Hexo 博客部署到腾讯云服务器全流程

　　只要一步步仔细跟着教程走，应该不会遇到问题。如果遇到了问题，可以参考博客下面评论区或者在搜索引擎上搜索。最后还是解决不了的话，可以请教周围的大神或者在教程博客评论区留言。感谢互联网，让我能站在巨人的肩膀上。

踩坑->跳出坑

1.安装nginx中间的问题

在解压完 [nginx-1.15.2] 包后执行指令：

./configure --prefix=/usr/local/nginx --with-http_stub_status_module --with-http_ssl_module --with-file-aio --with-http_realip_module

会出现类似于这样的错：

checking for OS + Linux 3.10.0-957.el7.x86_64 x86_64 checking for *** ... not found ./config

中间的*可以是任何软件，此时只需要手动安装那些软件即可，例如：

yum -y install gcc

2.万恶的403错误

　　这个错误应该是相当玄学了，如果没有这个错，我一下午应该就部署好了。反思一下，其实自己一来对linux系统操作不精通，二来对Git操作也不精通，三来对服务器nginx了解也有限…大神的博客也不可能面面俱到，所以在自己知识有限的情况下，只能找寻前人解决的经验了。
　　这个错误，我在试遍了评论区的方法后没有作用，后来不太清楚过程的最终解决了。所以现在只能模糊的猜测当时自己修改的条件。
　　我在修改好本地的配置文件后，运行以下指令：

hexo cl && hexo g -d

在命令运行后并没有发生错误，我登录进服务器发现网站根目录并没有文件，在我用git上传成功的条件下，网站根目录并没有文件，这说明建立的裸露（bare）仓库的钩子(hooks)没有作用，这就有两个原因：

1. 写的钩子，即linux脚本没有作用，可能没有执行权限。
2. 用户git没有博客根目录的权限。

所以，我从这两个角度入手：
将教程中关于这两部分的步骤检查并重新进行了一遍，设置完后让服务器nginx 运行reload指令一下。之后我访问我的服务器的80端口，在失望透底之下竟然出现柳暗花明——访问成功了。

最终解释：写的钩子没有运行，在服务器手动运行一下折衷。还在找解决办法！

找到问题了，表示很无语。原来是那个钩子的名字必须是post-receive，当时自己可能太着急了，把文件名打错了。我错了。

之后的工作就是等域名的证书验证好了配置HTTPS

Ok，HTTPS配置好了，具体没有踩太大的坑。主要参考以下文章：

• 腾讯云服务器申请SSL证书, 配置Nginx, 实现HTTPS
• 腾讯云服务器https证书安装指引

　　最近想吐槽一下当今的软件设计技术还是太死板。且听我举一例：我向某翻译软件上传一个word文件(.docx)（是一篇英文论文，里面图片比较多），翻译好后还是下载的Word(.docx)格式。我打开后开始对照修改，改到中间有部分内容缺失（超过那一页的边界之外），我准备打回车把那部分内容顶到下一页去，结果死活顶不下去。

仔细一看，好家伙，原来那个翻软件给生成了一个表格，只有一个格子，它把整个翻译后的内容放进格子里，那个格子超过了Word纸张大小，只能看见一部分内容。所以你打回车是永远也顶不到下一页，只会在看不见的地方增长格子大小。明白了以后，我就口吐芬芳了一句，从此与这类软件做路人。虽说可以用表格来排版，但是您也要用的标准啊。这样做简直坑人于无形。下面开始本篇主题。

1. 关于设置页码

1.1 从任意页开始设置页码
　　在功能区布局-页面设置-分隔符-分节符-下一页，接着在该页面插入页码，之后双击这一页的页码，在功能区设计-链接到前一节，取消链接到前一节，再删除前一页的页码即可。
1.2 设置奇偶页不同的页眉页脚，再添加连续的页码
　　其实就是分别在第一页添加从1开始的页码、第二页从2开始的页码，但是也要注意，文档内不要有多余的分节符，否则会很麻烦（Word在添加一些比较大的图片时候会自动添加分节符，有他的道理吧）。具体查看分节符的方法：功能区的文件-选项-显示-始终在屏幕上显示这些格式标记-显示所有格式标记，选中它即可。一般分节符长这样子：

想要删除分节符，将光标移至分节符后面，按delete即可

2. 关于Word输入公式

　　按Alt 和 = 键，即可输入Latex公式，且微软支持的很好，渲染的也很漂亮。但是却只支持.docx文件，一般学校都用的是.doc文件。不过在将.docx文件转为.doc文件时，Word会自动将Latex公式转化为图片，支持的很好。欣赏一下Word输入的公式吧。

　　在碎片时间被智能手机APP大肆压榨的时代，我们只能从增强自我管理开始。以上是自己最近的一些思考。欢迎一起来讨论（👉👇）。下面开始本篇主题

算法介绍

基于高斯扰动的粒子群算法(Particle Swarm Optimization based on Ganssian Disturbance, GDPSO)¹，其很巧妙的在标准粒子群算法速度迭代公式基础上增加一个高斯扰动，使得算法收敛速度加快，且既能帮助算法有效跳出局部最优值，又能扩大粒子搜索范围。
具体GDPSO速度迭代公式如下：

其中$\mu = 0，\sigma ^{2} = |p_{id}|$，其它参数与标准粒子群算法一致。
据算法分析，令$c_1 = c_2 = \lambda $，当算法参数满足：

且个体极值、高斯扰动值和全局极值保持不变时，算法在$E[x]^{*}$处渐进稳定

算法进化模式分析

令$c_1 = c_2$， $r_1 = r_2 = r_3 = r$，那么种群所有粒子可分以下情况：

1. 粒子$i$当前位置为其历史最优位置，但不是全局最优位置，即$x_{id} = p_{id}, x_{id} \not= p_{gd}$。
   则算法进化模式为 ： $$v_{id}^{(t+1)} = \omega v_{id}^{(t)} + c_{1}r(p_{id}^{(t)} + rgauss_{id}^{(t)}-x_{id}^{(t)})\\+c_{2}r(p_{gd}^{(t)}-x_{id}^{(t)})\\= \omega v_{id}^{(t)} + c_1r^2gauss_{id}^{(t)} + c_{2}r(p_{gd}^{(t)}-x_{id}^{(t)})$$

此时GDPSO速度增量比PSO更大，其全局搜索能力更强，收敛速度更快，且高斯扰动选项能帮助算法逃离局部最优。

1. 粒子$i$当前位置为其历史最优位置，同时又是全局最优位置，即$x_{id} = p_{id} = p_{gd}$。
   则算法进化模式为：

此时GDPSO速度项比标准PSO增加了一个高斯扰动值，有助于算法跳出当前局部最优解。

1. 粒子$i$当前位置不是其历史最优位置，同时又不是全局最优位置，但是粒子$i$的历史最优位置恰好是全局最优位置，即$x_{id} \not= p_{id}，x_{id} \not= p_{gd}, 且p_{id} = p_{gd}$。
   此时算法的进化模式为： $$v_{id}^{(t+1)} = \omega v_{id}^{(t)} + c_{1}r(p_{id}^{(t)} + rgauss_{id}^{(t)}-x_{id}^{(t)})\\+c_{2}r(p_{gd}^{(t)}-x_{id}^{(t)})\\=\omega v_{id}^{(t)} + 2c_1r(p_{gd}^{(t)} - x_{id}^{(t)} + \frac{1}{2}rgauss_{id}^{(t)})$$

此时，对于PSO，种群中粒子完全向当前全局最优值移动，很容易陷入局部最优值。而GDPSO一方面保证其收敛速度比PSO更快，另一方面由于增加了高斯扰动项，很好的避免了算法陷入局部最优值。

1. 粒子 $i$当前位置不是其历史最优位置，同时又不是全局最优位置，且粒子$i$的历史最优位置不是当前种群全局最优位置，即
   $x_{id} \not= p_{id}，x_{id} \not= p_{gd}，且 p_{id} \not= p_{gd}$ 。算法的进化模式为：

此时相比于PSO的速度项，GDPSO增加了一个高斯扰动项，其可以帮助粒子扩大搜索范围，增强全局寻优能力，且提高了算法收敛速度。

算法实现

1. 选择测试函数
   $Griewank$函数(取值范围为$[一600，600]$，理论最优值为0)： $$f(x) = \frac{1}{4000}\sum_{i=1}^{D}x_i^2 - \prod_{i=1}^{D}cos(\frac{x_i}{\sqrt{i}}) + 1$$
2. 环境
   JetBrains PyCharm + Python3.7
3. 参数设置

W = 0.6  # 惯性权重，根据论文会随着迭代次数改变C1 = 2.0  # 认知C2 = 2.0  # 社会P = []  # 第i个粒子搜索到的历史最优位值Pifitness = []  # 记录第i个粒子搜索到的历史最优值Pg = []  # 整个粒子群搜索到的最优位值Pgfitness = float('inf')  # 记录整个粒子群搜索到的最优值PgfitnessRecord = []intervalMin = -600  # 种群搜索区间下限intervalMax = 600  # 种群搜索区间上限Vmin = -120  # 粒子的速度下限Vmax = 120  # 粒子的速度上限N = 10  # 粒子个数T = 2000  # 迭代次数D = 30  # 粒子的维度

1. 实验结果

GDPSO算法迭代2000次

GDPSO算法迭代20000次

完整实验代码见我的Github

¹. 通讯作者：孙辉，邮箱: sunhui@nit.edu.cn ↩

　　最近在用Python实现粒子群算法时，我要用列表记录粒子群算法迭代时种群的情况，但是却发生了一些问题。调试浪费了一些时间，故在此记录下来。

背景

这段Python代码:

>>> list1 = []>>> list2 = [1,2,3]>>> list1.append(list2) # 将list2追加到list1尾部>>> print(list1)[[1, 2, 3]]>>> list2[1] = 0        # 改变list2第二个值>>> print(list1)[[1, 0, 3]]

　　问题是：我将list2加入到list1后面，再去改变list2第2个元素值，结果list1中对应索引位置元素也发生改变。想想粒子群算法迭代30次寻到最优值后，但种群却一直没变，诡异至极。

深入剖析

继续看这段代码：

>>> id(list2) == id(list1[0])True

　　这表明list2在内存中的起始位置与list1[0]在内存中的位置是一样的。实际上列表list1的append()方法是将list2进行浅拷贝，把list2引用直接赋值给list1[0], list2直接作为一个对象追加到list1[0]上。这样改变list2也会改变list1[0]，这就很危险了。

解决方案

　　导入copy模块，对list2进行深拷贝再追加到list1尾部即可：

>>> import copy>>> list1 = []>>> list2 = [1,2,3]>>> list1.append(copy.deepcopy(list2))>>> list1[[1, 2, 3]]>>> list2[0] = 0>>> list1[[1, 2, 3]]>>> list2[0, 2, 3]

　　深拷贝即是为list2创建一个副本再追加到list1尾部，这样list2与list1[0]就不再是同一个引用了。

　　最近想更新一下博客sidebar里面音乐插件的歌单，遇到一些问题，在以前遇到过，但是却忘了。故以防以后再忘，写下博客以记录。

1.关于如何创建网易云音乐歌单外链播放器

1. 打开网页版网易云音乐，登上自己账号，并找到自己想要制作外链播放器的歌单，按以下流程来：
   

单曲外链播放器也类似。进入制作外链播放器后就按照官方教程走即可。

2. 其中最需谨记的就是歌单里面的歌曲必须有版权可以用来制作外链播放器，如果忽视了这个，那么会产生以下两个问题：

• 不能制作外链播放器，提示没有版权。
• 就算制作成功了，但不能进行播放。最难受的就是你点击播放时，播放器不会进行提示。百思不得其解之时，忽然想起以前遇到这个问题。但是也浪费了好多时间。

艾子游于郊外，弟子通、执二子从焉，渴甚，使执子乞浆于田舍。有老父映门观书，执子揖而请，老父指卷中“真”字问曰：“识此字，馈汝浆。”执子曰：“‘真’字也。”父怒不与，执子反以告。
艾子曰：“执也未达，通也当往。”通子见父，父如前示之。通子曰：“此‘直’‘八’两字也。”父喜，出家酿之美者与之，艾子饮而甘之，曰：“通也智哉！使复如执之认真，一勺水吾将不得吞矣。”

今日在读一本书时忽的想起了这篇故事，故事即是启迪人们智慧的。而我当时读书心有所感，在这番境地下，再忆起这个故事竟然对生而为人充满了悲哀。每个人从出生到长大都经历了迥然而异而又如许多的故事，这千千万万的故事又造就了每个人不同的内心。我们总是苦于怎样才能将内心真实的想法情感表达出来，而又限于语言这一有限工具。到现在才真是体会到了“高山流水”这一千古绝唱。还记得刘慈欣在《乡村教师》中这样描述地球交流方式：

“他们基本特征是什么？”舰队统帅问。

“您想知道哪些方面？”蓝84210号上的值勤军官问。

“比如，这个行星上生命体记忆遗传的等级是多少？”

“他们没有记忆遗传，所有记忆都是后天取得的。”

“那么，他们的个体相互之间的信息交流方式是什么？”

“极其原始，也十分罕见。他们身体内有一种很薄的器官，这种器官在这个行星以氧氮为主的大气中振动时可产生声波，同时把要传输的信息调制到声波之中，接收方也用一种薄膜器官从声波中接收信息。”

“这种方式信息传输的速率是多大？”

“大约每秒1至10比特。”

“什么？！”旗舰上听到这话的所有人都大笑起来。

“真的是每秒1至10比特，我们开始也不相信，但反复核实过。”

“上尉，你是个白痴吗？！”舰队统帅大怒，“你是想告诉我们，一种没有记忆遗传，相互间用声波进行信息交流，并且是以令人难以置信的每秒1至10比特的速率进行交流的物种，能创造出5B级文明？！而且这种文明是在没有任何外部高级文明培植的情况下自行进化的？！”
……　　　　

　　作者也在感叹人类的交流效率如此之低。尽管人类为了解决这个问题做了很多努力，比如发明了数学——这种充满理性与逻辑的语言，精妙而准确，从中甚至能抽象出一个人，乃至整个宇宙。但是到了什么时候数学也能准确地表达人类的情感呢？或许这是永远也达不到的白月光。这又凸显了心有灵犀的弥足珍贵。当能有一个人与你产生共鸣时，你就能体会到当年“伯牙绝弦”的一半决绝。我们皆感叹“落花有意，流水无情”，倒不如在心里默数十秒，为他人展现一片耐心，也让自己能更多感受对方的处境。这也是我希望自己能做到的，坚冰既融，温暖何穷？

　　又或许正是这样，我们才有了爱恨情仇呢？进化路上的风景精彩纷呈，每一帧图像都会让人流连忘返。你我又能贡献出怎样的故事呢？

接上一篇问题，运用标准粒子群算法进行求解分析:

求函数$y=1-cos(3x)e^{-x}$在$[0,4]$上的最大值

下面是算法的参数与需要的数据结构：

# 标准粒子群算法参数W = 1               # 惯性权重C1 = 2.8            # 认知C2 = 1.3            # 社会Pi = []             # 第i个粒子搜索到的历史最优位值Pifitness = []      # 记录第i个粒子搜索到的历史最优值Pg = 0              # 整个粒子群搜索到的最优位值Pgfitness = 0       # 记录整个粒子群搜索到的最优值intervalMin = 0     # 种群搜索区间下限intervalMax = 4     # 种群搜索区间上限Vmin = -0.001       # 粒子的速度下限Vmax = 0.001        # 粒子的速度上限swam = []           # 种群ParFitness = []     # 种群适应值ParVelocity = []    # 记录粒子i速度N = 3               # 粒子个数T = 30              # 迭代次数record = []         # 记录粒子群每一代粒子群table = []          # 记录每一代粒子群最优适应值

用三个一维粒子进行迭代，若粒子位置或速度超过边界，则对其重新进行初始化。下面对结果进行分析：

迭代10次

　　可见迭代10次，局部搜索还未能进一步发现最优值，增加迭代次数看看。

迭代20次

　　迭代20次粒子对局部最优进一步挖掘，得到了更好的解。

迭代30次

　　效果对比迭代20次并没有多大提升。当然由于目标函数太过简单，所以粒子个数及粒子的维数并不大，算法复杂度也不高。其实这样也很好，初学时从简单一点的问题着手，一点一点在解决问题中深化认识。

总结

在编程过程中对算法理解加深了一个层次，对优化算法而言，在设计实现时要按照以下流程来：

1. 确定算法需要的参数及其数值
2. 确定算法所用的数据结构以及输出
3. 设计实现算法时需要的接口
4. 算法主程序
5. 调参
6. 分析结果

　　在这里分析还是做的不是多么好，但是因为问题比较简单，没有分析价值，所以只将结果进行对比即可。整个实现的Python代码见我的GitHub

　　粒子群算法（ Particle Swarm Optimization, PSO）是由Eberhart和Kennedy于1995年提出，它的基本概念源于对鸟群觅食行为的研究。设想这样一个场景:一群鸟在随机搜寻食物，在这个区域里只有一块食物，所有的鸟都不知道食物在哪里，但是它们知道当前的位置离食物还有多远。那么找到食物的最优策略是什么呢?最简单有效的就是搜寻目前离食物最近的鸟的周围区域。

　　PSO算法就从这种生物种群行为特性中得到启发并用于求解优化问题。在PSO中，每个优化问题的潜在解都可以想象成d维搜索空间上的一个点，我们称之为“粒子”（Particle），所有的粒子都有一个被目标函数决定的适应值(Fitness Value )，每个粒子还有一个速度决定他们飞翔的方向和距离，然后粒子们就追随当前的最优粒子在解空间中搜索。随着位置更新（迭代次数）增加，粒子最终在搜索空间上收敛于最优值（理想状态下）。

标准粒子群算法（全局版本）

　　例如，求函数$y=1-cos(3x)e^{-x}$在$[0,4]$上的最大值，并在[0,4]之间放置了两个随机的点，假设为$x_1=1.5,x_2=2.5$，则$x_1,x_2$为标量。对于高维情况，比如二维，求$z=2x_1+{x_2}^{2}$，此时每个粒子都是二维的，记

这里$n$为粒子群群体规模，也是粒子个数，每个粒子维数为2。更一般的粒子维数为q，则这个种群中有n个粒子，每个粒子为q维。
　　对由n个粒子组成的Q维空间进行搜索，第i个粒子表示$xi=(x{i1},x{i2},…,x{iq}), i=1,2,…,n$，其在各个维度上速度表示为$vi=(v{i1},v{i2},…,v{iq})$，每个粒子在搜索时考虑以下两个因素：

1. 自己搜索到的历史最优值$pi, p_i=(p{i1},p{i2},…,p{iq}),i=1,2,…,n$
2. 全部粒子搜索到的最优值$pg, p_g=(p{g1},p{g2},…,p{gn}), i=1,2…,n$
   下面是粒子在搜索时位置速度更新公式： $$v_{id}^{k+1}=\omega v_{id}^{k}+c_1(p_{id}^{k}-x_{id}^{k})\\　　+c_2(p_{gd}^{k}-x_{id}^{k})$$ $$x_{id}^{k+1}=x_{id}^k+rv_{id}^{k+1}$$ 其中的参数：

• $w$为保持原来速度的系数，即惯性权重，其值非负。当值较大时，全局寻优能力强，局部寻优也就弱了；其值较小时，局部寻优能力强，全局寻优能力弱。
• $c_1$是跟踪自己历史最优值的权重系数，表示粒子自身的认识，所以叫“认知”，通常设置为2
• $c_2$是粒子跟踪群体最优值的权重系数，表示粒子对整个群体知识的认识，叫“社会知识”，经常叫做“社会”，通常设置为2
• r 是对位置更新的时候在速度前面加的一个系数，这个系数被称为约束因子，通常设置为1
  　　这就是一个标准的粒子群算法
  　
  其中终止条件可以为适应值到达一定数值或循环一定的次数。因这里的粒子同时跟踪自己的历史最优值和群体最优值来改变自己的位置预速度，所以又叫做全局版本的标准粒子群优化算法。

标准粒子群算法（局部版本）

如果改变全局版本的速度更新公式，让每个粒子位置速度更新根据：

• 粒子自己搜索到的历史最优值$p_i$
• 粒子邻域内搜索搜索到的最佳值$pn_{k}$
  其余保持不变，则就成了局部版本的粒子群算法。
  　　一般一个粒子$p_i$的邻域随着迭代次数增加，第一次迭代时，其邻域为0，随着迭代次数邻域线性变大，最后扩展到整个粒子群，这时就变成了全局版本的粒子群算法了。实践证明：
  全局版本的粒子群算法收敛速度较快，但容易陷入局部最优解；而局部版本的收敛速度慢，但是不容易陷入局部最优。故现在粒子群优化算法大都在收敛速度与摆脱局部最优之间做权衡。

  静态邻域：

  按照粒子的编号取粒子的邻域
• 环形
• 随机环形
• 轮形
• 随机轮形
  　

• 环形取法如上图1中:
  　　对编号为1的粒子来说，当粒子邻域个数k为0时，则邻域是其本身；粒子邻域个数k为1时，则其邻域为{2,8};粒子邻域个数k为2时，其邻域为{2,8,7,3}…当邻域个数为4时，粒子的邻域就为整个粒子群了。
• 轮形取法如上图3
  　　对于指定粒子i，其位于邻域中心，其它粒子以一定规则与粒子i相连。只有中心粒子与其它相连粒子进行信息交换，中心粒子通过比较邻域中所有粒子携带信息而向其中最优粒子靠近。同时，邻域内最优信息通过中心粒子的性能改善而传播到种群的其它粒子。因此，中心个体令较好信息在种群中的传播速度变慢而增大了全局搜索能力，不至于早收敛。

  动态邻域

• 按照粒子的欧式距离取粒子的邻域
  　　记录任何两个粒子间最大距离为$d_m$,对每一粒子按照$\frac{||x_a - x_b||}{d_m}$,其中$||x_a-x_b||$为粒子a与粒子b的欧氏距离。而选择阈值$frac$根据迭代次数而变化，当另一粒子b满足$\frac{||x_a-x_b||}{d_m} < frac$，认为b是当前粒子的邻域内。由于要计算所有粒子之间的距离，计算量大且需要很多额外的存储空间，所以该方法不常用。
  参考文献：
• [1]李丽,牛奔.[M]粒子群优化算法.北京:冶金工业出版社,2009
• 感谢这位前辈13年前的博客niuyongjie引我入门。

　　DFS活络思维一下。

As an emergency rescue team leader of a city, you are given a special map of your country.
The map shows several scattered cities connected by some roads.
Amount of rescue teams in each city and the length of each road between any pair of cities
are marked on the map. When there is an emergency call to you from some other city,
your job is to lead your men to the place as quickly as possible, and at the mean time, call up as many hands on the way as possible.

Input Specification:Each input file contains one test case.For each test case, the first line contains 4 positive integers:N (≤500) - the number of cities (and the cities are numbered from 0 to N−1),M - the number of roads, C1 and C2- the cities that you are currently in and that you must save,respectively. The next line contains N integers, where the i-th integer is the number of rescue teams in the i-th city.Then M lines follow, each describes a road with three integers c1, c2 and L,which are the pair of cities connected by a road and the length of that road, respectively.It is guaranteed that there exists at least one path from C1 to C2.Output Specification:For each test case, print in one line two numbers:the number of different shortest paths between C1 and C2,and the maximum amount of rescue teams you can possibly gather.All the numbers in a line must be separated by exactly one space, and there is no extra space allowed at the end of a line.Sample Input:5 6 0 21 2 1 5 30 1 10 2 20 3 11 2 12 4 13 4 1   Sample Output:2 4  作者: CHEN, Yue单位: 浙江大学时间限制: 400 ms内存限制: 64 MB

思路提点:
　　考虑DFS，从指定城市$c_1$出发，依次访问邻接城市，直到目标城市$c_2$。用$LL$记录到达目标城市最短路径长度，$L$记录当前长度；$gather$记录最短路径最多的援救队，$gt$记录当前路径援救队，shortest记录最短路径条数。每次访问到目标城市就对$LL,gather,shortest$进行更新。之后进行回溯继续搜索。C++代码如下：

#include<iostream>#include<array>using namespace std;const int INF=0x3fffffff;array<array<int,507>,507> pic;array<int,503> team;array<int, 507> vis;// 结果int shortest,gather=0;// DFS信息int LL=INF;    //int L=0;int gt;void DFS(int v, int d, int n){    if(v == d)    {        if(L < LL)        // 找到比之前路径更短路径，最短路径条数置1，更新最短路径长度        {                // 更新最多搜救队数目            shortest = 1;            LL = L;            gather = gt;        }        else if(L == LL)    // 不止一条最短路径，更新最多搜救队数目        {            shortest++;            gather=max(gather, gt);        }        return;                // 返回    }    vis[v]=1;   //置访问标记    for(int i=0; i<n; ++i)    {        if(pic[v][i]!=INF && vis[i] == 0)        {            L += pic[v][i];            gt += team[i];            DFS(i, d, n);            gt -= team[i];            L -= pic[v][i];        }    }    vis[v]=0;   // 回溯取消标记}int main(){    ios::sync_with_stdio(0);    int n, m, c1, c2;    cin>>n>>m>>c1>>c2;    for(int i=0; i<n; ++i)        cin>>team[i];    for(int i=0; i<n; ++i)        pic[i].fill(INF);    int t1,t2,s;    for(int i=0; i<m; ++i)    {        cin>>t1>>t2>>s;        pic[t1][t2]=pic[t2][t1]=s;    // 无向图！    }    vis.fill(0);    gt = team[c1];            // 源城市援救队数目    DFS(c1,c2,n);    cout<<shortest<<' '<<gather<<endl;    return 0 ;}

　　20190317-20191222，一段历程，一点感动。新近读了刘慈欣的《球状闪电》，里面提到了一种人生观，让我衷心的赞同。人这一生有一种活法，就是从始至终对某种事物着迷，也就是这种东西值得自己一生为之付出而不求有所收获。我应当是寻找到了。只需要再具体一些，将之化成无数的计划和目标。
　　辩证唯物主义告诉我们，要有目的有计划的活着，才能在这个客观世界活得游刃有余。

　　在过去的308天里，在我的认识里，我应该是全身心的投入到了这件事中，不管结果如何，这只是自己应得的(deserve it)。下面的总结分为两部分，一部分是知识，一部分是认识。对应学与思。

学

​ 总结也就是“背目录”了，但是背目录也不仅仅是背目录，而是无限的回忆目录项下的知识细节，形成体系。古语“将一本书学薄”即是此道理。但是还是实践出真知。

高数部分

1. 高等数学
   • 函数（初等函数，性质（定义域，值域，对应法则.映射，周期，奇偶） 极限（无穷小，无穷大，等价、同阶、高阶无穷小，单调有界、夹逼定理） 连续定义（间断点第一类、第二类）
   • 一元函数微分学（导数和微分关系，$\Delta y=f^\prime(x)\Delta x+o(\Delta (x))$，常用函数微分，高阶导）
   • 一元函数积分学（积分定义，不定积分，定积分，牛-莱公式，积分上限函数，多重积分，几种坐标系（极坐标系，柱面坐标系，球面坐标系））
   • 空间解析几何（向量，向量内积、外积，混合积，空间直线、平面及其表示方式，旋转曲面）
   • 多元函数微分学（多重极限，微分形式不变性，隐函数存在定理，梯度，多元函数极值（AC-$B^2$），条件极值（拉格朗日函数，在SVM公式推导中有运用）)
   • 正项级数（正项级数，阿贝尔定理，级数判敛(级数收敛的必要条件)，正负交错级数(莱布尼茨定理)，将函数展开成幂级数，求正项级数和函数，傅里叶级数，狄利克雷定理）
   • 微分方程（一阶线性微分方程，齐次方程，贝努利微分方程，欧拉微分方程，高阶微分方程）
2. 线性代数
   • 行列式（行列式性质六条，行列式求值，克拉默法则）
   • 矩阵与向量(组)（矩阵性质、运算，初等变换，分块矩阵，矩阵的伴随，矩阵的逆，向量组线性无关相关，极大无关组，向量组的秩，向量组等价，矩阵秩，矩阵等价）
   • 线性方程组（齐次方程组及其解的结构，非齐次方程组及其解的结构，同解方程，方程的公共解，方程的解空间，解空间的基，正交基）
   • 特征值与特征向量（$AP = \lambda P$，正交变换，矩阵相似及相似对角化，矩阵相似的四个必要条件，实对称矩阵，向量的坐标及过渡矩阵）
   • 二次型（二次型概念(令二次型系数矩阵为A，令$\vec x = (x_1,x_2,x_3,…,x_n)^T,f(x)=\vec x^TA\vec x$)，正负惯性指数，二次型合同，二次型正定的充分条件）
3. 概率论与数理统计
   • 古典概型，全概率公式(先验)，贝叶斯公式(后验)
   • 随机变量函数（随机变量函数性质，离散型常用随机变量函数(两点分布，二项分布，几何分布，超几何分布，泊松分布)，连续型常用随机变量函数(均匀分布 ，指数分布，正态分布)，多位随机变量函数）
   • 数理统计基础（数字变量的基本特征(期望、方差、协方差、相关系数$\rho$)，n阶中心矩，n阶原点矩）
   • 参数估计（矩估计，最大似然估计，区间估计(1-$\alpha$置信区间)）
   • 假设检验(弃真，纳伪假设)

专业课部分

1. 数据结构{逻辑结构{线性结构，非线性结构}，存储结构{顺序，链式，索引，散列存储结构}}
   • 线性表(分别只有一个前驱和后继，对应的存储结构就是顺序表和链表，对顺序表和链表的操作，以及对应时、空间复杂度)
   • 栈和队列（其是一种逻辑结构，其中栈对元素的添加和删除仅能在一端进行，队列是只能在一端进另一端出。其存储结构可以用顺序表和链表实现）
   • 串(主要是KMP算法)（其本质就是线性表，但是其每一个元素都是字符，对串的各种操作，以及串的模式匹配）
   • 树（一个前驱，多个后继，树的性质，树的存储结构-顺序表、二叉链表，主要是二叉树，二叉树的遍历{递归，非递归}，线索树(将树线索化，可以对树逻辑上进行线性结构的访问元素)，哈夫曼树）
   • 图（有多个前驱，多个后继，图的性质，图的存储结构-邻接矩阵、邻接表，对图的遍历，图的最小生成树{Prim算法(加点、适合稠密图)、Kruskal算法(加边、适合稀疏图)}，最短路径算法(Dijkstral算法，Floyd算法)）
   • 排序（算法基本性质{确定性&可行性&有穷性&输入&输出}，时空复杂度，插入类{插入排序，希尔排序}，交换类{冒泡排序、快速排序}，选择类{选择排序、堆排序}，归并排序，基数排序，外排序(最小归并树，败者树)）
   • 查找(二叉查找树，二叉平衡树{LL,RR,LR,RL旋转}，哈希查找{建表、冲突避免(线性探测法/平方探测法/二次散列法/链地址法)}，B树(k叉平衡树))
2. 操作系统
   • 操作系统的更迭{单道批处理->多道批处理->分时操作系统->实时操作系统->分布式操作系统{重在协作解决问题，负载均衡}->网络操作系统{重在资源共享}}
   • 处理机管理{进程定义，PCB，状态转换图，三级调度{高级调度/作业调度、中级调度/进程对换、低级调度/进程调度}、线程{CPU调度的最小单位/共享进程空间}、多线程模型{用户级线程、内核级线程}}
   • 内存管理{内存管理意义、局部性原理{贯穿计算机科学始终，分为空间局部和时间局部}，程序的编译执行过程{源代码编译->链接->装入(程序逻辑地址形成)->运行}，内存分配方式{①连续和②非连续}，①(单一连续分配{效率低，仅支持单进程系统}，固定分区分配，动态分区分配)，②(分页式分配，分段式分配，段页式分配)，虚拟存储器{逻辑上扩充内存空间，配合请求分页式内存管理}（对换性，多次性，虚拟性），页置换算法{最佳置换算法，FIFO算法，LRU算法，CLOCK算法，内存块分配策略{固定分配局部置换，可变分配全局置换，可变分配局部置换}，页工作集(驻留集){为在某一段时间间隔内，进程要访问的页面集合}}
   • 文件管理{文件的逻辑结构(顺序文件，索引文件，索引顺序文件)，文件目录(一级目录、二级目录、树形目录)，文件共享方式{索引节点(硬链接)}，文件物理结构(连续文件，链接文件，索引文件)，文件访问控制{基于角色模型访问控制}，文件管理系统{分层}，磁盘管理{磁盘调度算法}，}
   • 设备管理{功能{用户层，设备无关层，驱动层，硬件层}，I/O缓冲技术{单缓冲，双缓冲，循环缓冲}，I/O子系统{总线型，通道型，控制器型}，虚拟设备{其就是在独占型设备与进程之间增加一个共享型设备作为过渡。即进程在占用CPU时尽可能减少等待I/O的时间。SPOOLing系统{对虚拟设备技术的应用，在磁盘开辟一个独立空间暂存数据，等设备空闲再将数据送给设备。输入设备->假脱机输入程序->输入井(管理程序)->逻辑设备管理->用户进程->逻辑设备管理模块->输出井(管理程序)->假脱机输出程序->通道->输出设备}}}
3. 计算机网络
   • OSI参考模型、TCP/IP参考模型{计算机网络基本功能-数据通信、资源共享，服务，协议，接口定义以及之间关系，OSI自顶向下{应用层->表示层->会话层->传输层->网络层->数据链路层->物理层}，TCP/IP{应用层->传输层->网际层->数据链路层}，分层既明确了分工，又简化了协议设计。各层通过访问下一层的SAP获得下一层的服务。}
   • 物理层{与传输介质无关，该层为设备之间数据通信提供传输媒体与互连设备，为数据链路层提供一条稳定的传输比特流线路。其接口特性是机械的(接口形状尺寸)、电气的(接口电缆电压范围)，功能的(对应电平的电压的意义)，规程的(不同功能的可能事件的时序)，物理层设备{放大器，hub(一个冲突域)}}
   • 数据链路层{访问物理层的服务为网络层提供服务，定义数据如何传输，功能:帧定界{字节计数，字符/比特填充首尾定界符，违规编码法}，差错控制{奇偶校验，循环冗余，海明码}，流量控制{因为发送时接收方处理速度和缓冲区有限，若发送方发送过快会而接收方不能以同样速度接收，则不能正确的传输数据，所以要进行流量控制，即控制发送速度。滑动窗口协议(停-等协议、后退N帧、选择重传)}，链路管理{为面向连接的服务提供链路管理}，局域网{网络拓扑逻辑上是总线型结构，其代表即是以太网的应用}，LLC子层和MAC子层{主要是MAC子层，在传输介质时涉及对传输介质的访问，以避免产生冲突。ALOHA协议，纯ALOHA协议，时隙ALOHA，CSMA协议，CSMA/CD(应用有线网)，CSMA/CA(应用于无线网)，二进制指数退避算法}，数据链路层协议有PPP协议、HDLC协议，以太网协议等。数据链路层设备{透明网桥、源路由网桥，交换机}，数据链路层设备仅能分割冲突域}
   • 网络层{网络层提供主机到主机服务，异构网络，自治系统，IPV4/IPV6，网络前缀/路由聚合，子网划分，路由转发原理，动态路由算法{距离向量算法(RIP协议，BGP协议)，链路状态路由算法(OSPF协议)}，网络层协议{IP，ARP/RARP，ICMP}，网络层设备{路由器，分为存储转发式和直通式}，网络层设备可以分割冲突域和广播域}
   • 传输层{传输层提供端到端服务，其功能主要有分用和复用。复用{在发送端多个应用可共用传输层服务}，分用{在接收端，传输层会根据端口号将数据分给不同应用}，UDP协议{面向无连接，所以其提供的服务是不可靠的，传输单位是报文，其中头部开销为8字节，数据不会进行拆分和合并}，TCP协议{面向连接，其头部至少20字节，提供可靠交付服务，其是面向字节流的，狭义上其为数据包中每个字节编号。提供全双工通信}，TCP拥塞控制{慢开始算法，拥塞避免算法，快重传算法{接收方收到失序报文段就立即向发送方发送一个ACK，告诉发送方自己收到一个失序报文并告诉对方自己需要接收的sep}，快恢复算法{连续收到同一分组的3个确认应答}}，}
   • 应用层{其直接为应用程序提供常见的网络应用服务，DNS{提供域名解析成IP地址服务，递归解析，迭代解析}，FTP{在传输层TCP上，在主动模式下，用熟知端口20作为数据端口，端口21作为控制端口，这样将数据和控制分开可以简化协议的设计}，SMTP{简单邮件传输协议，通过Push操作使用SMTP将邮件发送至邮件服务器，邮件服务器解析接收方邮件服务器地址，再通过SMTP将邮件发送至对方邮件服务器地址，接收方再通过Pull操作使用POP协议获取邮件}，HTTP{基于传输层TCP，其是一个简单的、无状态的、面向对象的请求-响应协议，请求方式主要有GET和POST,消息头部都由ASCII形式给出}}

思

　　在我沉浸在早出晚归这段日子里，唯孤单作陪，幸有音乐为伴。总是以为自己在想象之中，却不知世事总是发展至意料之外。我以为自己能一天精力高度集中学习14h+，以为自己在对知识宏观把握之后能无限推导细节，以为逻辑推导能代替死记硬背…大错特错。

1. 应试教育里，你不仅要对这个知识点熟练到无以复加，其中的一些推导也必须要烂熟于心，而不是考试现场推导，在考场短短几小时里，已经不允许自己去推导回忆知识点。此错误一。
2. 我总是疏于对细节知识的熟练掌握，总是想在宏观层次掌握，企图总结一条更加抽象的逻辑贯穿其中。殊不知宏观的认识是建立在对细节知识掌握之后的，类似于无限风光在险峰。在半山腰是永远也无法领略到山顶的风光的。
3. 总是给自己找借口说服自己，妥协。久而久之就习惯了。有些事可以找理由说服自己，有些则不然。关键是认识到不到位。
4. 不要低估自己，也更不要高估自己。

结合课程实验和课程设计，时间跨度为一个月，完成预处理，词法分析器。(词法分析器已作为JavaSwing项目上传至GitHub。)

预处理程序

#include<cstdio>#include<iostream>#include<fstream>using namespace std;void processSpace(ifstream &fin, const char);    // 处理空格void processMargin(ifstream &fin, const char);    // 处理注释void processCrLf(ifstream &fin, const char);    // 处理回车换行int main(){    ifstream fin("F:\\CompilerPrinciple\\Test1\\demo.cpp", ios::in);    // 预处理源代码文件    freopen("F:\\CompilerPrinciple\\Test1\\out.cpp","w",stdout);    // 输出结果文件    char now, last;    fin.get(last);    while(!fin.eof() && isspace(last))    // 一个字符测试空文件        fin.get(last);    fin.unget();    while(!fin.eof())    {        fin.get(now);        switch(now)        {        case ' ':            processSpace(fin, last);            fin.unget();    // 超前搜索回退            break;        case '/':            processMargin(fin, last);            break;        case '\n':          // 只存在Mac和windows下\r\n,\r            processCrLf(fin, last);            last = '\n';            break;        case '\t': break;        default:            putchar(now);        }        last = now;    }    return 0;}void processSpace(ifstream &fin, const char st){    /*         一.去多余空格:    *            1.判定当前字符，是空格则转第二步；否则输出    *            2.判定记录的上一个字符，如果是换行符，则是行首空格，不输出；    *                   如果是赋值号，则是多余空格，不输出    *                   继续判定下一个字符，如果是斜线，则是行末与注释间的空格，不输出    *                   如果是分号，则是行末多余字符，不输出。    *                   如果是空格，则是多余空格，不输出    */    char next;    fin.get(next);    while(!fin.eof() && isspace(next))  // 去多个连续空格        fin.get(next);    if(st != '\n' && st != '='        && next != '/' && next != ';' && next != '=')        putchar(' ');}void processCrLf(ifstream &fin, const char st){    /* 二. 去回车换行    *    1.超前搜索：如果下一个字符不是换行符，为Mac下源文件，回退文件指针，输出一个空格。否则    *      不回退，输出一个空格    *   考虑到兼容性，windows下\r\n，unix下 \n ，Mac下是 \r，过滤    */    char next;    if(!fin.eof())    {        fin.get(next);        if(next != '\n')            fin.unget();        putchar(' ');    }}void processMargin(ifstream &fin, const char st){    /*          三. 去注释    *             1.判定当前字符是否为  / ，是则进入第2步；否则输出    *             2.超前搜索下一个字符是否为  / ，是则为单行注释，直接结束本行；否则转第3步    *             3.超前搜索下一个字符是否为  * ，进入下一次循环，转第4步    *             4.判定当前字符是否为  *  ，是则进入第5步；否则放弃当前字符，进入下一次循环    *             5.超前搜索下一个字符是否为 '/'，是则结束循环退出子程序；    *               否则进入下一次循环，转第4步    */    char next, now;    fin.get(next);    if(!fin.eof())    {        if(next == '/')     // 单行注释        {            while(!fin.eof())            {                fin.get(now);                if(now == '\r' || now == '\n')                    break;            }            if(now == '\n')     // 不是回车换行符，回退                fin.unget();        }        else if(next == '*')    //多行注释        {            while(!fin.eof())            {                fin.get(next);                if(next == '*')                {                    fin.get(next);                    if(next == '/')                        break;                }            }        }    }}

　　 初学汇编语言，自己便许下了用汇编实现冒泡排序算法的“宏愿”，现在也终于实现了一部分。用高级编程语言的思想指导低级编程语言来实现算法，在过去算奢侈，现在可能是一种妥协。我会随着课程的深入来改正这个程序。在这里记录历程。

版本1

include vcIO.inc; 过程功能：冒泡排序.data; set data segmentarr dd 10,2,3,2,5,21,32,12,43,12,33,43,54,66,87,89,00,4,2,6; 待排序数组len1 byte ? ; 数组长度len2 byte ? ;内层循环边界fmt byte '%d ',0.codemain proc    mov len1,lengthof arr    mov ebx,offset arr    mov al,0h    ;外层循环变量    ;外层循环体lp:    cmp al,len1    jnb done; 结束循环    ; 内层循环体    mov ah, 1h; 内层循环变量inner:    ;内层循环判断索引部分    mov cl,len1    mov len2,cl    sub len2,al    cmp ah,len2    jnb last    movsx esi,ah    ;得到待比较的两个元素索引    mov bl,ah    sub bl,1    movsx edi,bl    mov ecx, arr[(type arr)*esi]    mov edx, arr[(type arr)*edi]    cmp ecx,edx    jnb follow        ;交换元素    mov edx,arr[(type arr)*esi]    xchg edx,arr[(type arr)*edi]    xchg edx,arr[(type arr)*esi]follow:    inc ah        ;内层循环更新    jmp innerlast:    inc al        ;外层变量更新    jmp lpdone:    xor ecx,ecx    mov al,len1prt:    movsx ebx,al    cmp ecx,ebx    jnb fina    mov edx, arr[(type arr)*ecx]    pushad        invoke printf,offset fmt,edx    popad    inc ecx    jmp prtfina:    ret        ; return to windowsmain endp    ; (insert additional procedures here)end  main    ; end of assembly

版本2(子程序版)

　　知道和运用之间总是隔着一个三维宇宙😁，这次更新带比例的的相对基址变址寻址，这样就不用单纯的通过改变索引（还是高级语言编程的习惯）来访问数组元素了。

include vcIO.inc;过程功能;主程序验证 ，子程序冒泡排序，通过堆栈传递参数.dataarr dword 10, 2, 3, 2, 5, 21, 32, 12, 43, 12, 33, 43, 54, 66, 87, 89, 00, 4, 2, 6; 待排序数组fmt byte '%d ',0.codemain proc    push lengthof arr ;数组长度压栈    push offset arr      ;数组首地址压栈    call bubbleSort    add esp,8    ;堆栈平衡    ; 打印结果    mov ecx,lengthof arr    mov ebx,offset arr    xor esi,esiagain:    mov eax,[ebx+4*esi]    pushad        invoke printf,offset fmt,eax    popad    inc esi    loop againbubbleSort proc    push ebp    ;保护ebp内容    mov ebp,esp ;取得最低地址堆栈指针    push eax    push ebx    push ecx    push edx    push edi    push esi    mov ebx,[ebp + 8]    ;取出数组偏移地址    mov ecx,[ebp + 12] ; 取出数组长度    xor esi,esi    ;外层循环变量outer:    cmp esi,ecx    jnb done    ;排序结束跳转    push ecx    sub ecx,esi    ;内层循环边界    mov eax,ecx    pop ecx    xor edi,edi    ;内层循环变量    inc edi        ;内层从1开始，比较arr[i]和arr[i-1]inner:    cmp edi,eax    jnb next    ;内层循环结束    push ecx    ; 交换准备    ;待修改块    ;带比例的基址变址寻址    ;mov edx, [ebx + 4 * edi]    ;dec edi    ;mov ecx, [ebx + 4 * edi]    ;inc edi    ;带比例的相对基址变址寻址    mov edx, [ebx + 4 * edi]    mov ecx, [ebx + 4 * edi - 4]    cmp edx, ecx    jnb beyond    ; 交换数据(待修改块)    ;dec edi    ;xchg edx, [ebx + 4 * edi]    ;inc edi    ;xchg edx, [ebx + 4 * edi]    ;带比例的相对基址变址寻址    xchg edx, [ebx + 4 * edi - 4]    xchg edx, [ebx + 4 * edi]beyond:    pop ecx    inc edi    jmp innernext:    inc esi    jmp outerdone:    pop esi    pop edi    pop edx    pop ecx    pop ebx    pop eax    pop ebp    retbubbleSort endp    retmain endpend main

　　数学的确是人们从感性认知世界到理性度量世界的巨大的转变，既然历史已经走到了这里，那我们可以称它为是一种进步。So，我在这里观叹“上帝创造”的公式——欧拉公式（又称为欧拉恒等式）。

$e^{\pi i}+1=0$

这个公式将复数单位——i，圆周率——$\pi$，自然对数的底数——e，整数的单位——1以及人类最伟大的发明——0，联系在了一起，并由此产生了无限的可能。比如，我们可以解出类似于$x^{2}=-1$方程的解（$i^2=-1$)。也可以将对数函数的定义域扩展到全体实数（扩展这个词是借鉴复数将实数所在的一维数轴扩展成具有实轴和虚轴的二维复平面），例如

是不是打开了新世界的大门？本来在实数集上，$y=lnx$的定义域为$D_{f}={x|x\gt 0}$，而当扩展到了复数集时，ln(-5)就有意义了。再多说一点，既然复数能扩展到二维复平面，那么它还能不能扩展到更多的维度呢？答案是可以的，比如四元组。
下面我以证明欧拉公式为目的，从泰勒公式开始总结：

泰勒公式

　　我们知道当$x→0$时，会存在一些等价无穷小，例如$sin(x)$~$x,tan(x)$~$x$。而采用等价无穷小后，会方便我们对一些函数的性态做研究。一方面，我们令$P(n)$为$f(x)$在$x_{0}$处的等价的多项式，它与$f(x)$之间相差一个无穷小。

可以想象一下我们拟合曲线时的操作，尽量让拟合的曲线的走势与被拟合的函数一致，说到曲线的趋势，我们必会提到导数。所以，设

即是

所以多项式对应的系数已求出，将之代入(*)式，得到$f(x)$的在$x=x_0$处的泰勒展开式：

因为本文目的是证明欧拉公式，所以这里就不讨论误差。
下面是用Octave画出y=sinx在x=0处展开3，5阶麦克劳林公式并与y=sinx对比的图像，

欧拉公式

由上面定义，我们可以得到三个关键函数在$x=0$处的省略余项的麦克劳林公式:

正式开始证明欧拉公式：
在$e^{x}$的展开式中把$x$换成$±ix$，

所以

分开写得到：

(1)-(2)得到:

(1)+(2)得到：

上两式也称为欧拉公式。
对于（1）式，取$x=\pi$，得到欧拉公式：

$e^{\pi i}+1=0$

　　关于动态规划(Dynamic Programming)算法，我在算法设计课上理解得并不是多么深刻。所以自己还是下来查找资料，多方对比学习，以期有所获。在这里谈一下心路历程与总结。

　　动态规划是运筹学中求解决策过程中的最优化数学方法。在计算机科学中，它也是一种程序算法设计技术。这就是基础科学在计算机科学中的一种应用。在这里我们只关注它作为算法设计技术的特性。

LV1-初识

　　一开始，课本上就扔出几个术语，最优子结构、重叠子问题，对于初学者来说的确是高深莫测，只有真的勇士才敢逆流而上，去一步一步剖析这些特性，最终能够领略它的独特风光。这里我们就逐个击破这些术语，揭开DP的面纱…

最优子结构

下面我们直接看经典的数塔问题:

从数塔顶部开始往下走，每次往下走只能选一个节点，一直到最底层，使走过的所有节点的数字之和最大，求这个最大和。假设顶部为第一层，以此类推。
数组$number[i][j]$表示数塔第i层左起第j个元素。

我们假定:
$dp[i][j]$表示从位置$(i,j)$到达数塔的最底层所经过路径的最大值。
我们要得到该最大值，就必须得到分别从位置$(i+1,j+1)$和$(i,j+1)$这两个节点出发，到达最底层时，所经过的数字的最大值。
此时，它们的关系为:

dp[i][j]=max(dp[i][j+1],dp[i+1][j+1])+number[i][j]

例如对于图中节点数字9

dp[1][1]=max(dp[2][1],dp[2][2])+9

这样我们得到的一般的等式就称为状态转移方程。

• 其中$dp[i][j]$表示一个状态，它的值总是来自于从子问题：$dp[i+1][j]$与$dp[i+1][j+1]$中选取一个较大值与当前节点数字相加，
  之后对于节点$dp[i+1][j]$，它的值来自$dp[i+2][j]$与dp$[i+2][j+1]$中较大值与当前节点$number[i][j]$的和；$dp[i+1][j+1]$亦然。
  这就是最优子结构性质，每一个问题都划分为两个子问题，然后在两个子问题中选择最优的(也就是所经过的数字之和最大)，得到母问题的最优解(当然是最优的)。
• 最终到了数塔最底层，此时已没有子问题，所以
  假设数塔有n层，第n层有m个元素，
  则$dp[n][j]=number[n][j]（1\leq j \leq m）$，这就称为递推边界。
  从递推边界开始，根据状态转移方程，最终得到最优解$dp[1][1]$。
  下面是C++代码:

  #include<iostream>#include<array>#define ROW 4#define COL 4using namespace std;int main(){  array<array<int, ROW+1>, COL+1> tower;  array<array<int, ROW+1>, COL+1> dp;  for(int i = 0; i < ROW; i++)      tower[i].fill(0);  for(int i = 1; i <= ROW; i++)      for(int j = 1; j <= i; j++)          cin >> tower[i][j];  for(int i = 1; i <= ROW; i++)         // 递推边界      dp[ROW][i] = tower[ROW][i];  for(int i = ROW - 1; i >= 1; i--)  {      for(int j = 1; j <= i; j++)      {          dp[i][j] = max(dp[i + 1][j], dp[i +  1][j + 1]) + tower[i][j];  // 状态转移方程递推      }  }  cout << dp[1][1] << endl;  return 0;}

  总结分析过程

1. 我们一开始提出用$dp[i][j]$表示从u数塔位置$(i,j)$到最底层，这就是它的意义所在，我们需要找到一个递推关系，也就是动态转移方程。所以我们在使用动态规划算法设计程序时，首先要明确$dp[i][j]$这个状态的意义。当然，这肯定是一个艰难的过程。
2. 在我们明白这个$dp[i][j]$所表示的意义时，就要通过正推或者逆推得到状态转移方程。步骤1、2我这里分开是便于叙述，在思考时是万万不能分开的。要根据问题，怎样设计出合理的$dp[i][j]$表示的状态，得到状态转移方程。
3. 最后，在前两步完成的情况下，思考出递推边界情况，可以通过正推状态转移方程也可以逆推状态转移方程得出边界。

上面的数塔问题包含最优子结构性质，下面再解析重叠子问题。

经典问题

求解斐波那契数列的第n项。

我们很容易写出递归式:

int f(int n){    if(n < 0)        return -1;    if(n == 1 || n == 2)        return 1;    return f(n-1) + f(n-2);}

对于该递归我们可以得到一棵二叉树:

图中，我们在对$f(5)$递归求解时调用了两次$f(3)$，我们明明可以只用求解一次然后将答案记录下来，再用时直接访问答案就可以了。这就是重叠子问题。
这里就要提一下备忘录方法了，这其实是动态规划的变形，并且它将计算过的子问题都会保存到数组中，下一次遇见相同的子问题直接调用即可。

• 我们用$dp[n]$表示第$n$项斐波那契数列，不难得到其动态转移方程为

  dp[n]=dp[n-1]+dp[n-2]

• 其递归边界dp[1]=1,dp[2]=1，所以我们可以写出使用自顶向下的备忘录方法求解斐波那契数列

  array < int, 100> dp = {0};int f(int n){  if(n < 0)      return -1;  if(dp[n])      return dp[n];  if(n == 1 || n == 2)      return dp[1] = dp[2] = 1;  return dp[n] = f(n - 1) + f(n - 2);}

  当然我们也可以写成动态规划形式，假设求第$n$项斐波那契数列:

  array < int, 47> dp = {0};        // 整形范围内，第47项斐波那契数列溢出dp[1]=dp[2]=1;for(int i=3;i<=n;i++){  dp[i]=dp[i-1]+dp[i-2];}

  可以观察到在求解$dp[n]$的过程中，只有$dp[n-1]$和$dp[n-2]$有效，比如$dp[3]=dp[2]+dp[1]，dp[4]=dp[3]+dp[2]$，而$dp[1]$已经没有用处了。所以我们完全可以不用数组，只用两个变量$a,b$：

  int f(int n){  if(n < 0)      return -1;  if(n == 1 || n == 2)      return 1;  int a = 1, b = 1, ans = 0;  for(int i = 3; i <= n; i++)  {      ans = a + b;      a = b;      b = ans;  }  return ans;}

  空间复杂度由$O(n)$下降到$O(1)$，不得不说这是一个巨大的飞跃。所以根据动态规划的递推式，我们可以通过观察来一定程度优化空间复杂度，这都是后话了。

  综述

  　　关于动态规划算法，我这里展示的只是冰山一角。每个人都会有其独特的理解，有人认为它是在填矩阵，有人认为它是一种拓扑排序（想来的确如此），如《哈姆雷特》一般。
  对于我们普通人来说，不可能一次就完完全全的领悟。需要一段时间的沉淀，需要不断地总结、练习，以更上一层楼。
  推荐阅读：
  https://mp.weixin.qq.com/s/3h9iqU4rdH3EIy5m6AzXsg

　　亲爱的您既然来看这道题的题解，那么您很有可能落入了一个题目的陷阱，在这里，我建议亲再仔仔细细的回去读一下题目呢，也好给自己留一个深刻的教训。

这是题链接，

• 注意到题面

  如果结果的实部或者虚部为0，则不输出。如果结果为0，则输出0.0。

  注意一个词，结果！也就是打印时，等号左边和右边不是一个规则：
• 对于结果，实部或者虚部为0，则不输出；然而，对于算式也就是等式右边，实部或者虚部为0，则 还 是 需 要 进 行 输 出
• 哈哈哈😆😆555😭😭~

  深刻的反思

  由于我过早的考虑代码复用，就把等式左右两边打印复数用了同一套规则，结果一时错，一时爽；一直错，一直爽…被折磨了两小时。
  一开始打印部分我是这样写的:

  void printExp(double a, double b, bool flag){  if(abs(a) < 0.05 && abs(b) < 0.05)  {      printf("0.0");  }  else  {      if(flag)          printf("(");      // 实部      if(abs(a) >= 0.05)      {          printf("%.1lf", a);      }      // 虚部      if(abs(b) >= 0.05)      {          // 虚部的 + 符号          if(b > 0 && abs(a) >= 0.05)              printf("+");          printf("%.1lfi", b);      }      if(flag)          printf(")");  }}void printExpTotal(double a1, double b1, double a2, double b2, char x){  printExp(a1, b1, 1);  printf(" %c ", x);  printExp(a2, b2, 1);  printf(" = ");}

  后来我是这样写的:

  void printExp(double a, double b){  if(abs(a) < 0.05 && abs(b) < 0.05)  {      printf("0.0");  }  else  {      // 实部      if(abs(a) >= 0.05)      {          printf("%.1lf", a);      }      // 虚部      if(abs(b) >= 0.05)      {          // 虚部的 + 符号          if(b > 0 && abs(a) >= 0.05)              printf("+");          printf("%.1lfi", b);      }  }}void printExpTotal(double a1, double b1, double a2, double b2, char x){  printf("(%.1lf", a1);  if(b1 >= 0)      printf("+");  printf("%.1lfi)", b1);  printf(" %c ", x);  printf("(%.1lf", a2);  if(b2 >= 0)      printf("+");  printf("%.1lfi)", b2);  printf(" = ");}

  果断捧回AC
  完整代码见我的Github
  过早优化是万恶之源，不看清、想清题目要求就想着优化则是万恶源之源！

　　这是一道比较麻烦的模拟题，思路和方式决定着代码量😏。原题链接，可以先去做一下😀。

　　经历了一些小挫折以后还是AC了，题面就不搬了，开始分析:

1. 可以用一个数组保存相应位的单位，这样就不用分心考虑单位了，而只考虑各个位数字之间的关系。
   为了相应的下标与其单位保持一致，整体后移一位。

   array<char, 10> base = {0, 'S', 'B', 'Q', 'W', 'S', 'B', 'Q', 'Y'};

2. 接下来讨论数字之间的关系。

• 可以将数字拆开放进一个数组，这样就完成了单位的映射。

  int total=0;while(n){  s[total++] = n % 10;  n /= 10;}

• 最高位一定不是0，用pre记录前一位数字。
  1). 如果当前位为0，且pre也为0，结束本次循环；特别的，当数字的万位也就是当前索引是4时，在前面的条件下，要输出一个W。
  2). 如果当前位不为0，但pre为0，这就是中间的0了，只用输出一次0，然后再输出本位数字和单位，例如100010。
  3). 如果末尾全是0，则不用进行输出，在之前非0的那一位已经输出了。
  下面是C++代码:

#include<bits/stdc++.h>using namespace std;typedef long long LL;int main(){    array<int, 9> s = {-1};    array<char, 10> num;    array<char, 10> base = {0, 'S', 'B', 'Q', 'W', 'S', 'B', 'Q', 'Y'};    int n, total = 0;    for(int i = 0; i < 10; i++)        // 数字与小写字母的映射        num[i] = 'a'+ i;    cin >> n;    if(n == 0)        // 单独处理0        cout << num[0];    else    {        while(n)        {            s[total++] = n % 10;    // 将数字拆出来            n /= 10;        }        int pre = -1;        for(int i = total - 1; i >= 0 ; i--)    // 从高到低位        {            if(s[i])            {                if(pre == 0)                    cout << num[0];        // 中间的0，只输出一次                cout << num[s[i]] << base[i];    // 输出数字与单位            }            else            {                if(i == 4)                    cout << base[4];    // 中间的0里面有万位，另外输出                if(pre == 0)    // 中间0，跳过处理                    continue;            }            pre = s[i];        }    }    cout << '\n';    return 0;}

反思:
在做比较麻烦的模拟题时，千万不要顺着思路去模拟，要时常跳出思维，要自己制定规则，
怎么方便怎么来。有时候顺着写，枚举特例，不仅大大增加了代码量，而且枚举时可能会漏掉某些条件，最终功败垂成。

　　自己早已对机器学习观望已久，现在不入门，更待何时？在找到Coursera时，发现教学方法很对胃口，于是开始ML之旅…现在在这里总结一下机器学习之线性回归。

　　机器学习有很多种方式，比如监督学习，半监督学习，无监督学习等。它们区别于训练集的种类，比如监督学习的训练集其每一个训练样本都有正确的答案，而无监督学习则没有，只能通过算法自动分类。而半监督学习，顾名思义，一部分是监督学习，一部分是无监督学习。

监督学习

　　监督学习又分为聚类和回归。其中聚类是预测连续值，回归是预测离散值。例如垃圾邮件识别，网页类别划分等是聚类。预测房价、股票涨跌等是回归。
下面总结一下线性回归。

线性回归

线性回归模型

截取自Coursera课程课件

数据集1
以下为一些字母的含义：

对应于线性回归的假设函数(hypothesis function)为

其中$\theta$为参数
对应的代价函数(cost function)(其图像为一个凹函数)为

这个方程有什么意义呢？
下面是一个散点图:

所有误差的和即为

要想得到拟合最好的效果，我们必须要让误差和最小。但是通常我们都用平均每个训练样本的误差的一半来表示。也即代价函数：

此时得到的参数$\theta{0},\theta{1}$为最合适的参数。

梯度下降算法(Gradient Descent Algorithm)

其中$\theta$表示参数，$\alpha(\geq0)$表示学习效率，后面表示$\theta{j}$的偏导。
为了叙述方便，下面令$\theta{0}=0$，此时$J({\theta{1}})$只有一个参数$\theta{1}$，令$J(\theta)$最小值对应于$\theta_{min}$

• 假如$\theta{1}>\theta{min}$，则该点切线斜率大于等于0，即$\frac{dJ(\theta{1})}{d\theta{1}}\geq 0$(因为只有一个参数，所以退化为求微分)，所以$\theta_{1}=\theta_{1}-\alpha\frac{dJ(\theta_{1})}{d\theta_{1}}$，$\theta{1}$减去一个正数，$\theta{1}$减小，则$\theta{1}$更靠近$\theta{min}$
• $\theta{1}<\theta{min}$分析方法类似

梯度下降算法在线性回归中的应用

　　将之前的代价函数带入梯度下降算法里，得到(其实就是复合函数求导，可以手动算一下):

多元线性回归

有数据集如下:

数据集2
PS:为了$\theta{i}$与$x{j}$下标一致，所以多加一列，其所有值都为1

补充字母含义:

此时,假设函数为:

代价函数:

也等价于

则梯度下降算法对应的偏导为:

加快梯度下降算法收敛方法

1. 特征缩放(feature scaling)
   　保证每个特征量范围都在$-1\geq x_{i}\geq 1$，每个特征值除以该特征范围。
2. 均值归一化(mean normalization)
   　保证特征变量在$-0.5\geq x_{i} \geq 0.5$，令 $$x_{i}=\frac{x_{i}-\mu_{i}}{s_{i}}$$ 其中，$\mu{i}$表示$i^{th}$特征的均值，$s{i}$表示表示$i^{th}$特征的范围或标准差。
3. 调整学习效率$\alpha$
   　$\alpha$必须足够小，且$J(\theta)$必须在每一次迭代后减小，可以以每次为原来的3倍来调整$\alpha$。
   • 当$\alpha$太小，算法收敛过慢。
   • 当$\alpha$太大，$J(\theta)$可能在迭代若干次后开始增加，最终算法不能收敛。

多项式线性回归

　当假设函数不再是线性时，可以通过平方，立方，开平方来进行多项式拟合。
e.g
$h{\theta}(x)=\theta{0}+\theta{1}x{1}$
对于数据集1，可以令

1. $h{\theta}(x)=\theta{0}+\theta{1}x{1}^{2}$
   此函数为二次函数，根据实际情况，房价不可能随面积增大而减小。
2. $h{\theta}(x)=\theta{0}+\theta{1}x+\theta{1}x{1}^{2}+\theta{2}x{1}^{3}$
   此函数中，令$x{2}=x{1}^{2}，x{3}=x^{3}_{1}$，此时，三个特征范围相差过大，对于特征值归一化有不利影响。
3. $h{\theta}(x)=\theta{0}+\theta{1}x{1}+\theta{2}\surd{x{1}}$
   此时较符合模型。运用此方法 ，特征缩放很重要，而且特征之间关联程度要小。

正规方程(Normal Equation)

　对于训练样本数为m，特征数为n，
令矩阵

其中$(1\leq i \leq m)$，X为m*(n+1)阶矩阵。

有正规方程，在数学上可证明其正确性:

最终$\theta$为1*(n+1)阶矩阵

梯度下降算法与正规方程比较

注: 当n大于10000时，考虑用梯度下降算法

正规方程不可逆

1. 存在多余的特征，即存在关联程度很大的特征，此时可以分析特征，删去关联程度大的特征中一个。
2. 特征值太多，例如$m<n$。此时可以删去存在关联的特征，或进行正则化。

夜已深，就总结到这里，接下来准备做一个小项目。晚安~

　　关于二分算法想必大家也是耳熟能详,但是在实施算法时，往往在细节方面由于没有考虑周全而抓耳挠腮，百思不得其解。这很正常。因为当年在学术界，第一个正确的二分算法写出来就花了20年；又不正常。现在，对于二分算法无论是理论研究还是实际运用都已经很纯熟了，我们既然可以站在巨人的肩膀上，那又何乐而不为呢？

　　这里总结一下一些常用的二分算法的写法。

一、二分查找

　　查找序列为严格递增序列，元素所在区间为[0,n-1]。当元素存在重复时，它不保证返回序列中第一个该元素的索引，故待查找序列不应存在重复元素。

int binarySearch(int l, int r, int x){    int mid;    while(l <= r)            /* 若此时l==r，还要进行一次查找*/    {                        /* 当l>r时，查找失败，退出循环*/        mid = (l + r) / 2;    /* 备注1 */        if(s[mid] == x)        /* 返回元素所在序列的索引*/            return mid;        if(s[mid] > x)            r = mid - 1;    /* 此时目标元素x存在区间为[l,mid - 1]*/        else            l = mid + 1;    /* 此时目标元素x存在区间为[mid + 1,r]*/    }    return -1;                /* 没有找到，返回-1*/}

备注1：此处可能存在 l + r 溢出int范围，所以可以用 l + (r-l)/2避免溢出

二、解析STL中lower_bound和upper_bound

lower_bound(求序列中第一个大于等于目标元素x的索引)

　　查找序列为非递减序列，初始区间为[1,n]——(因为x可能大于序列中所有的元素，此时满足条件的元素就是其本身，此时返回值为n)，

int lower_bound(int l, int r, int x){    int mid;    while(l < r)            /* 当l==r时，该位置唯一，循环结束*/    {        mid = l + (r - l) / 2;        if(s[mid] >= x)        /* 第一个大于等于x的索引在[l, mid]里 */            r = mid;        else            l = mid + 1;    /* 第一个大于等于x的索引在[mid+1, r]里 */    }    return l;}

upper_bound(求序列中第一个大于目标元素x的索引)

　　查找序列为非递减序列，代码与与上面类似。

int lower_bound(int l, int r, int x){    int mid;    while(l < r)            /* 当l==r时，该位置唯一，即是目标位置，循环结束*/    {        mid = l + (r - l) / 2;        if(s[mid] > x)        /* 第一个大于x的索引在[l, mid]里 */            r = mid;        else            l = mid + 1;    /* 第一个大于x的索引在[mid+1, r]里 */    }    return l;}

三、二分思想运用

看一道经典题:

给出N个线段长度，试将它们头尾相接组合成一个凸多边形，使凸多边形的外接圆（多边形每个顶点都在圆上）的半径最大，求该最大半径。其中N<=10^5，线段长度均不超过100，要求算法中不涉及坐标的计算。

分析:

思路1

首先，因为圆心不确定，想涉及坐标计算也无能为力啊😂。
其次，考验数学时候来啦。我们可以确定当圆是凸多边形外接圆时，该多边形内角和为$π*(n-2)$，对于每一条弦（题中线段），与两条半径组成等腰三角形，解该等腰三角形其底角为

则凸多边形内角和为$\sum{i=0}^{n-1}α{i}$。此时则可以二分$r$，当内角和小于误差限时，即得到最大半径。

思路2

换一个角度，一条线段(弦)对应的圆心角为

而当r确定，所有的弦对应的圆心角和$\sum{i=0}^{n-1}α{i}=2π$，此时可以二分$r$，当内角和小于误差限时，即得到最大半径。
思路1和2，C++代码链接：二分思想题解

　　一道题把排序算法复习了个遍😂，最终复习到了堆排序。快到碗里来👇。

题面

原题链接(要不先去做一下？😏)，题面如下，

本题要求实现一个函数，求N个集合元素A[]的中位数，即序列中第⌊N/2+1⌋大的元素。其中集合元素的类型为自定义的ElementType。
函数接口定义：
ElementType Median( ElementType A[], int N );
其中给定集合元素存放在数组A[]中，正整数N是数组元素个数。该函数须返回N个A[]元素的中位数，其值也必须是ElementType类型。
裁判测试程序样例：

#include <stdio.h>#define MAXN 10typedef float ElementType;ElementType Median( ElementType A[], int N );int main (){    ElementType A[MAXN];    int N, i;    scanf("%d", &N);    for ( i=0; i<N; i++ )        scanf("%f", &A[i]);    printf("%.2f\n", Median(A, N));    return 0;}/* 你的代码将被嵌在这里 */输入样例：312.3 34 -5输出样例：12.30

分析

　　首先，因为题目给定中位数位置为序列中第⌊N/2+1⌋大，所以不用考虑序列长度为奇为偶。
　　其次，因为涉及到排序，而又不能直接调用库里面的排序算法，so,就自己手写排序代码。

• 第一次尝试冒泡排序😀，最后一组数据，大N超时🤔
  

  (PS:强迫症表示很难受。)

• 第二次快速排序，结果如上上上，给的数据是反快速排序的😓
• 第三次堆排序，AC😉😆
  具体代码请转移至我的Github。

下面复习(反正review和preview有个p的区别😏)一下堆排序

　　堆是一种数据结构，它是一颗完全二叉树，并且具备以下性质:

• 每个节点的值都大于或等于其左右子节点，称为大顶堆;
• 每个节点的值都小于或等于其左右子节点，称为小顶堆。

比如小顶堆

堆排序算法描述如下:

1. 将无序序列构造成小顶堆(最终数组为非严格降序排列，大顶堆反之)，如上图。
   • 具体构造过程如下:
   • 对每个根节点进行判定，如果其不满足小顶堆定义，则交换元素，直至满足$(1)$
2. 将第一个元素与最后一个元素交换，将最小元素下沉到数组最后，调整堆结构，使其满足定义。
3. 反复执行2过程，直到数组有序。

代码实现

C++代码实现：

void HeapAdjust(ElementType A[], int x, int len){    ElementType temp = A[x];        // 保存根节点x    // 从x节点的左子节点开始    for(int j = 2 * x + 1; j < len; j = 2 * j + 1)        {        if(j + 1 < len && A[j] > A[j + 1])    // ，滑向值小的节点            j++;        if(temp < A[j])            // 如果当前根节点小于子节点，则跳出循环            break;        A[x] = A[j];            // 子节点覆盖根节点        x = j;                    // 此时子节点j变成根节点    }    A[x] = temp;                // 将x节点放在最终位置}ElementType HeapSort( ElementType A[], int N ){    // 构建初始堆，从第一个非叶子节点自底向上调整堆    for(int i = N / 2 - 1; i >= 0; i--)    {        HeapAdjust(A, i, N);    }    // 堆调整、交换元素    for(int i = N - 1; i > 0; i--)    {        // 元素下沉操作            ElementType temp = A[0];        A[0] = A[i];        A[i] = temp;        // 调整整个堆        HeapAdjust(A, 0, i);    }}

时间复杂度

初始化堆

　　因为初始化堆是自底向上的，从最后一个非叶子节点开始调整堆(叶子节点不用调整😅)。可证明完全二叉树的最后一个非叶子节点的编号为$n/2-1$（$n$表示堆的元素总数量），这样从下至上，从右至左调整堆。
假设在第i层，二叉树高度为K,该层的节点数为$2^{i-1}$,调整该层需要的比较次数为$k-i$,
最后一个非叶子节点所在层数为$k-1$,则i的区间为$[1,k-1]$,每一层的比较次数:

所以初始化堆总的比较次数为：

该等式两边$\ast$2，得：

上两式$②　　-　①$ 得：

由等比数列公式$\frac{a_{1}(q^{n}-1)}{q-1}$得

k为二叉树的高度，$k=logn,2^{k}=2^{logn}=n$(对数恒等式),得到$S=n-logn-1$，所以初始化堆的时间复杂度为$O(n)$

调整堆

　　下沉元素时，每一次调整堆都是从根节点调整的，也就是从第1层到k-1层，比较次数$log(i)$,而一共要进行n-1次，所以总的比较次数$(n-1)logn$(可以参考一下https://www.programiz.com/dsa/heap-sort)，即$nlogn-logn$。所以调整堆的时间复杂度为$O(nlogn)$

空间复杂度

　　作为原地排序(原地排序指在排序过程中不申请多余的存储空间，只利用原来存储待排数据的存储空间进行比较和交换的数据排序)的一员，其空间复杂度为$O(1)$。

　　学习算法，就我看来，其实就是学习解决问题的一种思想或者方法，应该是一种体验过程的学习，在过程中感悟与升华，最终把它吸收转化成自己的独特的思想；在学习中感受与惊叹先贤的解决问题的思想，未尝不是一种乐趣?这不也昭示了学习本身就是快乐的过程吗？如果连学习都体验不到快乐，那还有什么能体验到快乐呢？
　　本文是可以作为遗传算法介绍性文章，是关于一次简单、浅显的利用遗传算法来解决函数优化问题的介绍性文章。

要解决的问题

求解函数 $f(x)=x*sin(10\pi +x)+1.0$ 在区间$[-1，2]$的最大值。

知识准备

　　首先列举一下遗传算法的构成要素

1.染色体的编码以及编码方法

　　我们要把问题的解空间进行编码，以便于遗传算法能进行操作。编码方式主要有二进制编码，浮点数编码，格雷码等。

二进制编码

　　假设参数范围为$[A,B] (A<B)$,我们有长度为a的二进制串来编码，则共有$2^a$种不同编码，可以将$[A,B]$分成$2^a-1$份，等分长度为$α$，

因为当二进制串长度过长时会影响遗传算法的运行效率，所以这类问题就要重新考虑编码方式了。

浮点数编码

　　对于函数优化问题，例如本题，浮点数编码则更合适了。浮点数编码就是用在一定范围内的浮点数表示每个个体的染色体。

格雷码

　　其是一种绝对编码的格式，是具有反射特性和循环特性的单步自补码。这些特性保证了它不会出现重大错误。因为它的每次变化都只有相邻两位发生变化，即每次变化与上一次都只有一位不相同。而自然二进制串在向高位进位时却至少有$1$位不同。相比于改变多位，明显格雷码的改变一位更稳定些，且出错几率也更小些。其构造方法：

以二进制$0$为第$0$项，第$1$项改变最右边的位，第二项改变右起第一位非$0$的位的左边那一位，第三项改变最右边的位…如此反复，即可得到$n$位的Gray code.

2.群体初始化以及计算个体适应度

　　适应度函数是评估个体的适应性的唯一标准，也是后面选择个体阶段的唯一标准。对于很多问题可以直接将目标函数作为适应度函数。遗传算法的目标函数不受连续可微的约束且定义域可以是任意集合。但对适应度函数有一个要求：针对输入可以计算出的、能加以比较的结果，必须是非负的。

3.遗传算子(操作算子)

选择

　　根据个体的适应度选择进入下一代的个体，个体的适应度越大，则其越有可能被选入下一代。选择机制有轮盘赌方法，最佳个体保存法、期望值方法、排序选择方法、联赛选择方法、排挤方法等。一般都采用轮盘赌方法。下面描述一下轮盘赌算法：

1.设种群数量为n，先计算出种群内所有个体适应度$f(x_{i})$，
再计算出种群总适应度$sum=\sum\limits_{i=0}^{n-1}f(x_{i})$，
个体适应度与种群总适应度的比值得到个体选择概率$\large p(x_{i})=\frac{f(x_{i})}{sum}$。
积累概率$q_{i}=\sum\limits_{j=0}^{n-1}p(x_{i})$表示从第一个个体的选择概率累加，累加到某项即为相应染色体的积累概率。
2.生成一个随机数$r$，若$r\leq q_{0}$,则选中$0$号染色体;
3.若$q_{i-1}<r\le q_{i}(1\leq i<n)$，则$i$号染色体被选中。
对于积累概率，如下图先给出个体选中概率:

交叉

　　交叉算子即把两个亲代个体的部分结构进行替换重组而生成新子代个体的操作。其两个特点：

• 设计的交叉算子必须保证亲代的优良性状能在子代个体中得到遗传和继承。
• 交叉算子的设计与问题的编码是相互协调的，即编码-交叉设计。
• 对于二进制串编码，交叉算子主要有一点交叉，两点交叉，多点交叉，一致交叉。其中一点交叉的操作如下：

假设从左起第$5$位开始进行一点交叉，得到

进行一点交叉后得到两个新个体，

这样就完成了一次一点交叉运算。

• 对于实数编码，主要采用算术交叉算子。假设存在个体$P{1}$、$P{2}$，对于它们进行算术交叉后得到新个体$P{1}’$、$P{2}’$的运算如下,其中伪随机数$\lambda$$\in$[0,1]：

$\large P{1}’=\lambda P{1}+(1-\lambda) P{2}$
$\large P{2}’=(1-\lambda) P{1}+\lambda P{2}$

变异

引入变异算子有两个目的：

• 使遗传算法具备局部搜索能力。当遗传算子通过交叉算子接近最优解领域时，变异算子可以使遗传算法快速向最优解收敛。在这种情况下，变异概率应取较小的值。
• 使种群具备较好的群体多样性，防止遗传算法出现未成熟收敛情况。此时，比那一概率应取较大的值。

1.对于二进制编码，其变异方式为随机的选择某些基因位，对这些基因位进行概率性的翻转变异，即$0$变为$1$,$1$变为$0$。
2.对于实数编码，其变异方式为随机变异。使变异个体变量分量加上一个伪随机数，该随机数为均匀分布或高斯分布。
变异方式还有逆转变异算子，自适应变异算子等。

遗传算子的性质

　　交叉算子具备良好的全局搜索能力，是遗传算法的主要操作算子；变异算子具备局部搜索能力，是遗传算法的辅助操作算子。交叉和变异使遗传算法具备均衡的全局搜索能力和局部搜索能力。

回到上面的问题，

　　对于这个问题，我采取浮点数编码，下面是遗传算法的运行参数：

const double PI = 3.1415927;                 // π#define N 50                                  // 群体规模#define T 100                               // 进化代数#define PC  0.75                              // 参加交配概率#define PM 0.0875                            // 变异概率

完整实现代码请移至我的Github

　　说一下感想，对于解决问题的范式，无外乎就是从所有可能解决问题的方法中将这个方法找出来，也即搜索。最开始我们有广度搜索和深度搜索，它们都可能在有限时间内搜索到问题的解决方法。但是，它们是盲目搜索，在今天的计算机条件下，一来计算机能表示的状态空间有限，二来其运行速度对一些状态空间稍微大一些的问题，往往要花大量的时间去计算。所以睿智的前人就发明了启发式搜索，通过预先设置一些方法，引导搜索的方向，使它能更快速的进行搜索，得到更满意的答案。根据达尔文进化论，物竞天择，适者生存，不适者淘汰。我们有一种思想叫做类比，既然大自然能淘汰掉不适合生存其中的物种，保留适合的物种，那我们是否可以借鉴这种方式，淘汰掉不合适的搜索路径，留下适合的搜索路径，这样最后得到的就是最佳解决路径了。这就是遗传算法的本质了。这里只是见到了它的冰山一角而已。就当做领略风光了。

另外，在这里总结一下c语言获取伪随机数方法

1.先设置伪随机数种子

srand((int)time(0));

2.其次，获取随机数，假如要在子函数里生成随机数，则只能在主函数里设置随机数种子。也就是只用在主函数最开始设置一次种子就可以了。
下面是获取伪随机数的一般形式：

rand()%y + x

表示生成$[x,y+x)$的伪随机整数。
如果需要闭区间$[x,y+x]$的话，可以再给y加个1，即

rand()%(y+1) + x

最近在做操作系统上机实验。有一个关于页置换算法的实验，实验所给的代码是先进先出调页算法，一时手痒就想着自己模拟一下LRU调页算法，就作为一个小开始吧。

1.关于LRU算法

　　算法步骤描述如下:

1. 为所有的页添加一个计数器并置0。
2. 若系统访问的页存在于内存中，为该页的计数器加一，并对内存中所有的页按计数器大小降序排列；否则执行第三步。
3. 判断系统内存页数是否已满，是则将内存中排序最后一页置换为系统访问的页，并为该页初始化计数器；否则将系统访问的页加入内存，并初始化计数器。

2.关于数据结构

　　1. 页类型可用如下结构体表示

struct page{    int pageNum = -1;    // 系统访问页码,默认-1为空    int time = 0;       // 系统在内存访问总次数，默认为0次    page() {}                                       // 空无参构造    page(const int p): pageNum(p) {}                // 构造函数    friend bool operator<(page &p1, page &p2)       // 排序比较器    {        return p1.time < p2.time;    }};

　　2. 可用一个最大空间为3的vector模拟内存

#define CAPACITY 3std::vector<pageNode> mainMem;

3.调页函数

void foldPage(int page, std::vector<pageNode> &mainMem){    if(CAPACITY == mainMem.size())              /* 内存存放的页满,置换最后一页*/    {        mainMem.back().pageNum = page;        mainMem.back().time = 0;    }    else    {        mainMem.emplace_back(page);             /* emplace_back()直接调用其构造函数，并加在vector最后。*/    }}

测试结果

模拟访问页面走向4, 3, 2, 1, 4, 3, 5, 4, 3, 2, 1, 5, 1, 4, 3-------------------------------------时间  访问页   内存状态  缺页中断 调入页0        1       4        4           +      42       3        4 3         +      33       2        4 3 2       +      24       1        4 3 1       +      15       4        4 3 16       3        4 3 17       5        4 3 5       +      58       4        4 3 59       3        4 3 510      2        4 3 2       +      211      1        4 3 1       +      112      5        4 3 5       +      513      1        4 3 1       +      114      4        4 3 115      3        4 3 1缺页中断次数为9缺页率9/15=60.00%%

完整测试代码见我的Github。

————————————————————————————————————————————————我是分割线——————————————————————————-
更新于2020.2.28

上面的构想还是学生时代初期的构想，太过于理想化，只考虑到了模拟，其它一概不考虑。真是一颗傲娇的心。

最近在LeetCode上刷题，遇到了一道关于设计实现LRU算法的题，才发现当年写的LRU算法真是只有当年才能写出来。
　　真正在页置换算法应用实现中是根本不会为页设置访问次数属性并由该属性进行排序的，这效率低且浪费内存。光时间复杂度就高达O(nlogn)，更别提空间复杂度了。
下面开始分析优化：
　　在页置换算法中，没有必要对工作集内的页进行按访问次数排序，从而得到最近最少访问次数。而是因为我们只要求得到最近最少访问的页，只用将经常访问的页放到页表首部，则每次都能以O(1)的时间复杂度访问；而当调入新的页时，若OS为进程分配的页帧已用完，采用LRU算法，应删除最近最少访问的页，也就是页表尾部页；若页帧没有用完，则直接将新页加入到页表首部。这里这样描述是因为这个LRU算法实现基本就是这个思想。
由以上，要以O(1)删除尾部元素，以O(1)插入元素到表首，以O(1)查找某元素(hash)，且有顺序(list)。综上分析，形成了新的数据结构——哈希链表。
　　当时在LeetCode上接触这道题时，感觉思维被打乱了，甚至没读懂题意。后来看了题解才恍然大悟。也触摸到了分析这种题的一些诀窍。下面是cpp代码：

#include<iostream>#include<list>#include<unordered_map>using namespace std;// 哈希链表class LRUCache{public:    LRUCache(int capacity):_capacity(capacity) {}    int get(int key)    {        auto it = mp.find(key);                 // C++11中迭代器类似于指针        if(it == mp.end())            return -1;        int val = it->second->second;           // 取出key对应的value        cache.erase(it->second);                //从cache中删除k-v        cache.push_front(make_pair(key,val));   // 重新构造k-v放入cache头        mp[key] = cache.begin();                // 更新该key hash映射的迭代器        return val;    }    void put(int key, int value)    {        auto it = mp.find(key);        if(mp.end() == it)                      // k-v不存在        {            if(cache.size() == _capacity)       // cache 已满，删除尾部，清理出空间            {                auto temp = cache.back();                cache.pop_back();                mp.erase(temp.first);           // 删除尾部的key在hash中对应的结点            }        }        else   cache.erase(mp[key]);            // k-v存在,更新value,并放入cache头        cache.push_front(make_pair(key,value)); // 将结点直接加入头部        mp[key] = cache.begin();                // 更新该key对应的迭代器    }private:    unsigned int _capacity;    list<pair<int,int>> cache;                  // 模拟cache双链表    unordered_map<int,list<pair<int,int>>::iterator> mp;    // hash表};int main(){    LRUCache cache(2);    cache.put(1, 1);    cache.put(2, 2);    cout<<cache.get(1)<<endl;       // 返回  1    cache.put(3, 3);    // 该操作会使得密钥 2 作废    cout<<cache.get(2)<<endl;       // 返回 -1 (未找到)    cache.put(4, 4);    // 该操作会使得密钥 1 作废    cout<<cache.get(1)<<endl;       // 返回 -1 (未找到)    cout<<cache.get(3)<<endl;       // 返回  3    cout<<cache.get(4)<<endl;       // 返回  4    return 0;}

　　学而不思则罔，思而不学则殆。不会反思自己的人思想总是不会太深刻，而太过沉溺于幻想之中只会徒增失落。低头前进，全凭一身锐气，不撞南墙不回头；不如与知音进行一次彻夜长谈，回顾过去，展望未来。目极远眺，若许人或在招手。

　　回顾整场考试，节奏把握的还是不错的。但其中的三大问题，令人唏嘘：

* 1.第二题没有仔细分析条件，再加上给的样例，直接将思想带偏到了预定的方向;* 2.第三题题目比较长，在看题的时候没有标注一个重要条件，导致在写代码时将其忽略;* 3.心里没有B Tree，幻想着能在第四，五题得一些分(竟然不是把在一个小时内将4，5题* 　做出来，看来也不是没有B Tree)。

下面展开进行分析，

第二题

问题描述试题编号：201809-2试题名称：买菜时间限制：1.0s内存限制：256.0MB问题描述：问题描述　　小H和小W来到了一条街上，两人分开买菜，他们买菜的过程可以描述为，    去店里买一些菜然后去旁边的一个广场把菜装上车，两人都要买n种菜，    所以也都要装n次车。具体的，    对于小H来说有n个不相交的时间段[a1,b1],[a2,b2]...[an,bn]在装车，    对于小W来说有n个不相交的时间段[c1,d1],[c2,d2]...[cn,dn]在装车。    其中，一个时间段[s, t]表示的是从时刻s到时刻t这段时间，时长为t-s。　　由于他们是好朋友，他们都在广场上装车的时候会聊天，他们想知道他们可以聊多长时间。输入格式　　输入的第一行包含一个正整数n，表示时间段的数量。　　接下来n行每行两个数ai，bi，描述小H的各个装车的时间段。　　接下来n行每行两个数ci，di，描述小W的各个装车的时间段。输出格式　　输出一行，一个正整数，表示两人可以聊多长时间。样例输入41 35 69 1314 152 45 710 1113 14样例输出3数据规模和约定　　对于所有的评测用例，1 ≤ n ≤ 2000, ai < bi < ai+1，ci < di < ci+1,    对于所有的i(1 ≤ i ≤ n)有，1 ≤ ai, bi, ci, di ≤ 1000000。

关注数据规模和约定这一句

ai < bi < ai+1，ci < di < ci+1

当时的我处在看完样例之后再看这个条件，而且是在我已经有思路的情况下，于是顺理成章的没有认认真真、仔仔细细地再去分析这个条件，按照错误的思路写出了错误的只过了样例的代码，本来还想再造一些样例的，但是此时信心爆棚的我哪还有心思…事后和室友聊了一下，听他用了两个队列做的（我此时心里是带一点慌的），我向他解释我的方法，而且我着重向他介绍我没有认认真真、仔仔细细分析过的那个条件。如果没有这个条件，那么我的思路就是错的，但是由于当时没有题面，语言表述又有限，便作罢…过了两天出成绩，冲动的惩罚来了——只得了样例的分，而此时的我竟然还没有意识到错误解读条件…看来我还挺偏执…
所以考试的时候没有仔仔细细的分析条件，那就只能下来分析了，晚矣晚矣~

ai < bi < ai+1，ci < di < ci+1

分析一下，也就是数据规格符合逻辑而已，输入的小H、小W休息时间分别不会重叠。满分代码已我放在我的Github。

第三题

题面比较长，就不搬来了，链接，其中有个条件：id属性大小写不敏感，coding时的确忘了这个条件，得了80分…不得不说运气还挺好…
在这里记录一下解决这道题中 后代选择器的思路：

* 第一步，用一个数组记录每一行文档的**层级**(累加每一行文档前面“.”的个数)。* 第二步，将要查询的标签解析分开存在一个vector里，遍历查找vector中每一个标签，* 查找算法步骤如下：    * 第一步，按照解析后的标签的层级从低到高，开始在文档中查找；    * 第二步，每次查找遵循贪心原则，只保存找到的标签的最大的层级数，找到则进    * 行下一步，没找到查找结束；    * 第三步，继续查找下一层标签，但是找到的最大的标签的层数必须是小于上一层    * 找到的标签层数，如是往复。    **题目给的提示绝对是很重要的。贪心，是个好算法。**

　　一瞬间的失神，可能决定着沧海桑田，望三思而后行。

像往常一样，每周几题。今天这道题(最少交换次数)让我做了一次发散性的思考，先把题面搬过来，有收获的小伙伴可以进原题链接练练手。

最少交换次数序号：#8难度：非常难时间限制：1000ms内存限制：10M描述给出一个无序数列，每次只能交换相邻两个元素，  求将原数列变成递增数列的最少交换次数。   如：数列：2,3,1，交换3和1后变成：2,1,3；交换1和2之后变成：1,2,3。总共交换2次。输入逗号隔开的正整数数列输出正整数输入样例2,3,1输出样例2

当时看到题面的第一个念头就是用归并排序求逆序对(多了解一些准没错)，但是仔细一看题面，只能交换相邻元素，归并排序，pass。转念一想，还有交换(冒泡)排序呀，每次只交换相邻元素，这是完全符合题意要求的。我的代码如下：

#include<bits/stdc++.h>#define LARGE_IOusing namespace std;vector<int> split(const string &t){    vector<int> out;    stringstream tstream(t);    int temp;    while(tstream>>temp)    {        out.push_back(temp);        tstream.ignore(1);    }    return out;}int bubbleSort(vector<int> &p){    int len = p.size(),cnt=0;    for(int i = 0; i < len - 1; i++)              // 控制趟数    {        for(int j = 1; j < len - i; j++)          // 控制比较元素        {            if(p[j-1] > p[j])            {                swap(p[j-1],p[j]);                // <algorithm>算法库自带                cnt++;            }        }    }    return cnt;}int main(){#ifdef    LARGE_IO    ios::sync_with_stdio(0);#endif    string inputStr;    vector<int> p;    while(getline(cin,inputStr))    {        p = split(inputStr);        cout<<bubbleSort(p)<<endl;    }    return 0;}

关于冒泡排序，有一个优化：
设想一个场景，数组[1,0,2,3,4,5,6,7,8,9]，第一趟只进行了一次有用的比较，数组就有序了，后面的比较都是枉然的。所以考虑加一个flag，只要存在交换，冒泡排序就继续进行下一趟，反之，排序结束。请读者自行完成代码。

当然，，，，，不可能。

int bubbleSort(vector<int> &p){    int len = p.size(),cnt=0;    bool flag=1;                                // 交换标记    for(int i = 0; i < len - 1&& flag; i++)      // 控制趟数    {        flag = 0;        for(int j = 1; j < len - i; j++)          // 控制比较元素        {            if(p[j-1] > p[j])            {                swap(p[j-1],p[j]);                cnt++;                flag = 1;                        // 存在交换置 真            }        }    }    return cnt;}

总结:

* 认真仔细看题面。失之毫厘，差之千里。* 先不要急于思考代码的实现这种细节，而是思考算法与数据结构(深度思考)。* 完成后考虑举一反三，一题多解，锻炼发散性思维(广度思考)。

字符串分割函数split,将一个字符串按给定的定界符delim分割成字符串数组。实现的方式多种多样，由浅入深，从易到难，开始分割…

实现的方式有以下3种:

• 用cstring 库中的strtok函数实现
• string类对字符串直接处理实现
• 正则表达式结合STL实现

用strtok函数实现

std::vector<std::string> split0(const std::string &str, const std::string &deli){    std::vector<std::string> out;    if(str.empty())    {        return out;    }    if(deli.empty())    {        out.emplace_back(str);        return out;    }    // c_str()返回当前string对象的c 风格常量字符串,即const char *    const char *del=deli.c_str();    // 将str重新放入流中，再用char数组读取    std::stringstream ot(str);    char strTemp[str.size()+1];    ot>>strTemp;    char *p=strtok(strTemp,del);    while(p != nullptr)    {        out.emplace_back(p);        p = strtok(nullptr,del);    }    return out;}

用string类实现

std::vector<std::string> split1(const std::string &str, const std::string &deli){    std::vector<std::string> out;    if(str.empty())    {        return out;    }    if(deli.empty())    {        out.emplace_back(str);        return out;    }    // 直接处理字符串    std::string p=str;    p+=deli;                                // 保证结尾有一个定界符    size_t cur;                             // 记录处理过的子串    while((cur = p.find(deli)) != std::string ::npos)    {        out.emplace_back(p.substr(0,cur));  // 截取分割子串        p=p.substr(cur+deli.size());        // 向后滑动    }    return out;}

用std::regex实现

std::vector<std::string> split2(const std::string &str, const std::string &deli){    std::vector<std::string> out;    if(str.empty())    {        return out;    }    if(deli.empty())    {        out.emplace_back(str);        return out;    }    // 构造定界符正则    std::regex re(deli);    // 获取匹配该定界符的串的前缀    std::sregex_token_iterator p(str.begin(), str.end(), re, -1);    std::sregex_token_iterator end;    while (p != end)    {        out.emplace_back(*p++);    }    return out;}

完整测试代码见我的Github
参考资料:
C++ Reference
几种c++字符串split 函数实现的比较

小米OJ里的题有一个独特的数据输入方式，迫使我不得不去掌握一些高效处理字符串的方法，从正则开始。

知其所以然，请跳转　正则表达式之基本原理。

std::regex

　　其常用函数(类)如下

• regex_match() ，全词匹配。
• regex_search()，搜索匹配。
• regex_replace()，搜索匹配并替换。
• std::regex_iterator，不分组多次全词匹配，可获取整个正则结果。

regex_match（全词匹配）用法

#include<iostream>#include<string>#include<regex>using std::cin;using std::cout;using std::endl;int main(){    std::string s("122  622");    std::regex e("(\\d+)(\\s+)(\\d+)");        // 两边各最少一个数字，中间至少一个空格    // 是否全词匹配成功    if (std::regex_match (s,e))    {        cout << "the match is successful!";    }    else    {        cout<<"the match is failed!"<<endl;    }    // 捕获匹配内容    //std::match_results<const char *> cm;    std::cmatch cm;             // 同于std::match_results<const char *>    std::regex_match (s.c_str(),cm,e);    cout << "string literal with " << cm.size() << " matches\n";    for(auto y:cm)        cout<<"["<<y<<"]"<<endl;    return 0;}

注:捕获的结果中，第一条一般都是字符串本身
运行结果:

the match is successful!string literal with 4 matches[122   622][122][   ][622]

regex_search（搜索匹配）用法

#include<iostream>#include<string>#include<regex>using std::cin;using std::cout;using std::endl;int main(){    std::string s("sss666  333ff");    std::regex e("(\\d+)(\\s+)(\\d+)");    // 是否搜索匹配成功    if (std::regex_search(s,e))    {        cout<<"the match is successful!"<<endl;        // 捕获匹配内容        std::cmatch cm;             // 同于std::match_results<const char *>        std::regex_search(s.c_str(),cm,e);        for(auto y:cm)            cout<<"["<<y<<"]"<<endl;        }    else    {        cout<<"the match is failed!"<<endl;    }    return 0;}

运行结果:

the match is successful![666  333][666][  ][333]

regex_replace（搜索匹配并替换）用法

#include<iostream>#include<string>#include<regex>using std::cin;using std::cout;using std::endl;int main(){    // Flags used to control how rgx is matched and how fmt is formatted.    std::regex_constants::match_flag_type fonly =        std::regex_constants::format_first_only;    std::string s("  sss666  333ffF  d32132  ");    // 由一个及以上的空格开始，接下来是1~3个数字或字母的组合    std::regex rgx("(\\s+[a-z0-9]{1,3})");    std::string fmt="";    cout<<"flags: "<<std::regex_replace(s,rgx,fmt,fonly)<<endl;    cout<<"default: "<<std::regex_replace(s,rgx,fmt)<<endl;    return 0;}

运行结果:

flags: 666  333ffF  d32132default: 666ffF132

std::regex_iterator （不分组多次全词匹配）

#include<iostream>#include<string>#include<regex>using std::cin;using std::cout;using std::endl;int main(){   std::string s="31234a,333sss,3435ss.dwa";    // 匹配以任意符号开始，接下来是一个及以上的数字与2个及以上小写字母的组合    std::regex rgx("(\\d+[a-z]{2,})");    // std::sregex_iterator == std::regex_iterator<std::string::const_iterator>    std::regex_iterator<std::string::const_iterator> cbegin(s.begin(),s.end(),rgx);    std::sregex_iterator cend;    while(cbegin != cend)    {        cout<<cbegin->str()<<endl;        cbegin++;    }    return 0;}

运行结果:

333sss3435ss

参考资料:
Cplusplus reference
Cpp标准库之 std::regex 类的使用

最近计算机网络课需要我们做一个图片传输程序，在客户端上传输图片至服务器，要求服务器能过滤文件并展示客户端上传的图片，我带着亲爱的“C++”，开着“百度”，开始畅游“网络”，并在这里写下总结。

TCP与UDP都是OSI(Open System Interconnection 开放式系统互联)参考模型下第四层——传输层协议，在这里总结一下它们的特点。

TCP

TCP(Transmission Control Protocol 传输控制协议)，是面向连接的。交互双方都建立一个流式套接字，服务器需要等待客户端连接，一旦连接上就立即返回一个新的套接字描述符，通过描述符调用数据传输函数与客户端进行数据的收发。

• 优点：可靠、稳定。
• 缺点：速度慢、效率低、占用系统资源多、易被攻击。
• 适合场景：网络通讯质量要求高的地方。

UDP

UDP(User Datagram Protocol 用户数据报协议)，是面向无连接的。双方建立的都是数据报套接字，服务器与客户端在进行传描数据之前不需要进行连接的申请和建立，可随时向对方发送消息。

• 优点：速度快、比TCP稍安全
• 缺点：不可靠，不稳定
• 使用场合：网络通讯质量要求不高、速度快的场所。

TCP/IP三次握手

这里有一段生动地描述，我摘抄如下:

主机A向主机B发出连接请求数据包：“我想给你发数据，可以吗？”，这是第一次对话；主机B向主机A发送同意连接和要求同步（同步就是两台主机一个在发送，一个在接收，协调工作）的数据包：“可以，你什么时候发？”，这是第二次对话；主机A再发出一个数据包确认主机B的要求同步：“我现在就发，你接着吧！”，这是第三次对话。三次“对话”的目的是使数据包的发送和接收同步，经过三次“对话”之后，主机A才向主机B正式发送数据。

摘自百度百科TCP/UDP协议。经过这样三次对话，TCP才能建立稳定、可靠的连接，保证发送数据的正确性。

C++实现TCP/IP三次握手，并在传输文件后关闭连接

运行环境: VS 2017

服务器端

#include "pch.h"#include <iostream>#include <WinSock2.h>#include <string>#include <fstream>#define _WINSOCK_DEPRECATED_NO_WARNINGS#pragma comment(lib, "ws2_32.lib")        // 导入动态链接库SOCKET sockSrv;void RecvFile();int main(int argc, CHAR* argv[]){    WSADATA wsaData;    int port = 8800;    // 加载套接字    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)    {        std::cout<<"加载套接字失败: "<< WSAGetLastError()<<"......\n";        return 1;    }     sockSrv = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);    //    TCP/IP协议     // 初始化IP和端口信息    SOCKADDR_IN addrSrv;    addrSrv.sin_family = AF_INET;    addrSrv.sin_port = htons(port);                            // 1024以上的端口号    addrSrv.sin_addr.S_un.S_addr = INADDR_ANY;    // bind()    if (bind(sockSrv, (LPSOCKADDR)&addrSrv, sizeof(SOCKADDR_IN)) == SOCKET_ERROR)    {        std::cout<<"套接字绑定失败："<< WSAGetLastError()<<"......\n";        return 1;    }    // listen()    if (listen(sockSrv, 1) == SOCKET_ERROR)    {        std::cout<<"套接字监听失败："<<WSAGetLastError()<<"......\n";        return 1;    }    // 客户端信息    SOCKADDR_IN addrClient;    int len = sizeof(SOCKADDR);    // 开始监听    std::cout<<"服务端启动成功......开始监听...\n";    while (1)    {        // 等待客户请求到来          sockSrv = accept(sockSrv, (SOCKADDR *)&addrClient, &len);        if (sockSrv == SOCKET_ERROR) {            std::cout<<"建立连接失败："<<WSAGetLastError()<<"......\n";            break;        }        std::cout<<"与客户端建立连接......IP："<<inet_ntoa(addrClient.sin_addr)<<std::endl;        std::cout << "开始接受数据..." << std::endl;        RecvFile();        std::cout << "接受完毕" << std::endl;        // 关闭套接字        closesocket(sockSrv);    }    WSACleanup();    system("pause");    return 0;}void RecvFile() {    const int bufferSize = 1024;    char buffer[bufferSize] = { 0 };    int readLen = 0;    std::string desFileName = "E:\\demo.jpg";   // 打开我的E盘的一个图片文件    std::ofstream desFile;    desFile.open(desFileName.c_str(), std::ios::binary);    // 以二进制文件方式，不然图片会乱码    do {                            readLen = recv(sockSrv, buffer, bufferSize, 0);        if (readLen == 0)                            // 循环接受文件，直到发送的文件为 EOF        {            break;        }        else        {            desFile.write(buffer, readLen);        }    } while (true);    desFile.close();                    // 莫忘关闭文件}

客户端

#include "pch.h"#include <iostream>#include <WinSock2.h>#include <string>#include <fstream>#pragma comment(lib, "ws2_32.lib")SOCKET sockClient;void SendFile() {    std::streamsize haveSend = 0;    const int bufferSize = 1024;    char buffer[bufferSize] = {0};    std::streamsize readLen=0;    std::string srcFileName = "E:\\upload\\universe.jpg";        // 打开E盘的一个图片文件    std::ifstream srcFile;    srcFile.open(srcFileName.c_str(), std::ios::binary);        // 以二进制文件打开    while (!srcFile.eof()) {                                    // 当读到结尾时会多循环一次，以作为发送结束标志        srcFile.read(buffer, bufferSize);        readLen = srcFile.gcount();        send(sockClient, buffer, readLen, 0);        haveSend += readLen;    }    srcFile.close();}int main(int argc, CHAR* argv[]){    WSADATA wsaData;    int port = 8800;    // 加载套接字    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)    {        std::cout << "加载套接字失败：" << WSAGetLastError() << "......"<<std::endl;        system("pause");        return 1;    }    // 初始化IP和端口信息    SOCKADDR_IN addrSrv;    addrSrv.sin_family = AF_INET;    addrSrv.sin_port = htons(port);    addrSrv.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");    // socket()    sockClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);    if (SOCKET_ERROR == sockClient)     {        std::cout << "创建套接字失败:" << WSAGetLastError() << "......" << std::endl;        system("pause");        return 2;    }    // 向服务器发出连接请求    if (connect(sockClient, (struct sockaddr*)&addrSrv, sizeof(addrSrv)) == INVALID_SOCKET)    {        std::cout << "连接服务器失败：" << WSAGetLastError() << "......" << std::endl;        system("pause");        return 3;    }    else    {        std::cout << "连接成功!\n\n" << std::endl;        std::cout << "开始发送" << std::endl;        SendFile();        std::cout << "\n发送成功!" << std::endl;    }    // 关闭套接字    closesocket(sockClient);    WSACleanup();    system("pause");    return 0;}

考虑在发送图片文件之前，给服务器发送一些该文件的信息，如名称，大小等，这样服务器可以精确的保存图片文件，诸如此类。
参考资料:
windows环境下使用C++&Socket实现文件传输

二叉搜索树(Binary Search Tree)又名二叉查找树、二叉排序树，它要么是一棵空树，要么满足以下条件:

• 若其左子树不为空，则左子树所有节点的值小于根节点的值；
• 若其右子树不为空，则其右子树所有节点值均大于他的根节点的值；
• 其左右子树也为二叉查找树。

  一、 特点

  　　通过中序遍历二叉搜索树可以得到一个有序的序列。另一方面，通过对一个序列构造二叉搜索树可以将其变为有序，构造构造过程即为排序过程。

  优点

  　　如果BST左右子树的节点数目保持平衡，即所有非叶子节点的左右子树数目差不多，则它的搜索性能堪比二分查找；二分查找应用于以连续内存空间存储且有序的数组，而以树这种数据结构存储时，对于插入节点和删除节点则比数组这种数据结构高效很多，甚至能达到常数时间。

  缺点

  　　如果构造二叉搜索树时，没有选好根节点那么构造的二叉搜索树可能会成为这个样子，
  
  这样的结构则完全失去了二叉搜索树的优势。所以要尽量让二叉搜索树保持平衡，关于保持平衡就要涉及平衡二叉搜索树(AVL)，红黑树(RBT)等数据结构，本文先不介绍。

  二、实践

  　　以一个公司职员管理系统为例，其底层数据结构用二叉搜索树实现，具备增加加节点，删除节点，修改节点，搜索节点基本功能，主要是实践出真知。二叉树的一个节点也为一个职员，其节点类型如下：

  typedef struct Node{  struct Node *left = nullptr;            // 左子树指针  struct Node *right = nullptr;            // 右子树指针  string name;                        // 职员姓名  string gender;                        // 职员性别  string num;                            // 节点的关键字，为社保号，唯一  string date;                            // 入职日期  int salary = 0;                        // 薪资  static int total;                        // 静态变量记录公司职员总人数。  Node() {}  Node(string na, string gen, string number, string da, int s)        // 构造方法  {      name.assign(na);      gender.assign(gen);      num.assign(number);      date.assign(da);      salary = s;      total++;                            // 每构造一个对象总数加一  }  ~Node() {}} Staff;int Staff::total = 0;

  下面是增、删、改、查的一些成员函数，分别用递归和非递归实现:

  增加节点

  　　即二叉搜索树增加节点，逻辑清晰：

1. 判定二叉搜索树是否为空，是则直接加入新节点。否则执行第二步
2. 将新节点的关键字与根节点的关键字相比，小于则进入左子树继续比较以寻找叶子节点并加入新节点，大于则进入右子树寻找加入新节点的位置，

• 递归

  void addStaff(Staff **r, string m[])        // 传递指针的指针，可在任何地方修改指针指向的地址的内容而不用返回被改变的根节点。{   if(nullptr == (*r))                     // 如果二叉搜索树或节点为空，直接添加新节点。       {       *r = new Staff(m, m[1], m[2], m[3], atoi(m[4].c_str()));       cout << "添加职员成功！" << endl;       return;   }   if(m[2] < (*r)->num)            // 关键字值小于根节点的关键字，新节点加在左子树里面   {       addStaff(&(*r)->left, m);   }   else                            // 关键字值大于根节点的关键字，新节点加在右子树里面   {       addStaff(&(*r)->right, m);   }}

• 非递归

  void addStaff(Staff **r, string m[])      // 传递指针的指针，可在任何地方修改指针指向的地址的内容而不用返回。{  if(r == nullptr)                    // 二叉搜索树为空，直接加入节点。  {          *r = new Staff(m[0], m[1], m[2], m[3], atoi(m[4].c_str()));      cout<<"添加成功!"<<endl;      return;  }  while(r != nullptr)                  {     if(m[2] < (*r)->num)            // 新节点关键字小于根节点，进入左子树寻找      {          r = &(*r)->left;      }      else                            // 进入右子树寻找位置      {          r = &(*r)->right;      }      if(nullptr == (*r))                      {          *r = new Staff(m[0], m[1], m[2], m[3], atoi(m[4].c_str()));          cout<<"添加成功!"<<endl;          break;      }  }}

  删除节点

  　　删除节点情况稍微复杂一些，考虑一下：
• 要删除的节点只有左子树或右子树，或都没有：考虑删除的节点只有左子树，直接将其左子树赋给该节点：反之将右子树赋给该节点。如果删除的是叶子节点，则直接删除该节点(亦左子树或右子树都可以赋给它)。
• 要删除的节点既有左子树又有右子树，找出其右子树最小节点数据覆盖被删除的节点信息，并删除该最小节点。
• 递归

  int deleteStaff(Staff *&r,string num){  if(nullptr == r)        // BST为空  {      return -1;  }  if(r->num > num)        // 搜索左子树  {      return deleteStaff(r->left,num);  }  else if(r->num < num)   // 搜索右子树  {      return deleteStaff(r->right,num);  }  else  {      if(r->left == nullptr || r->right == nullptr)       // 删除的节点只有左子树或右子树      {          r = (r->left != nullptr)?r->left:r->right;          return 1;      }      else      {          Staff *temp = r->right;      // 从右子树找一个最小节点并用它来代替被删除的节点，再删除该最小节点。          while(temp->left != nullptr)          {              temp = temp->left;          }          // 覆盖信息          r->name = temp->name;          r->gender = temp->gender;          r->num = temp->num;          r->date = temp->date;          r->salary = temp->salary;          // 删除最小节点          deleteStaff(r->right,temp->num);          return 1;      }  }  return -1;}

  修改节点和查询节点

  　　其原理和遍历二叉搜索树相似，直接介绍递归与非递归的中序遍历。

  中序遍历二叉搜索树

• 递归

  void inOrderTraverse(Staff *r )      // 中序遍历BST{       if(r == nullptr)      {          return;      }  if(r != nullptr)   {          // 递归中序遍历BST      inOrderTraverse(r->left);      cout << r->name << "\t" << r->gender << "\t" << r->num << "\t" << r->date << "\t" << r->salary << endl;      inOrderTraverse(r->right);      }}

• 非递归

  void inOrderTraverse(Staff *r )      //非递归 中序遍历BST{    if(r == nullptr)  {          return;  }  stack<Staff*> s;  Staff *p=r;  while(p != nullptr || !s.empty())   // 到叶子节点或栈空  {      while(p != nullptr)                // 先放入相对根节点，次放其左子树，直到左子树空      {          s.push(p);          p = p->left;      }                              if(!s.empty())                    // 访问节点：左、根、右      {          p = s.top();          cout << p->name << "\t" << p->gender << "\t" << p->num << "\t" << p->date << "\t" << p->salary << endl;           s.pop();          p = p->right;      }  }}

  完整职员管理系统请转移至我的Github。如果有错误，万望能帮我指出来，不胜感激。

在《算法基础》书中，并查集又被称为不相交集结构：假设有1到N个对象，希望将这些对象分成不相交的集合，在任意给定时间里，每个对象都恰好在一个集合里。对于每个集合，选择一个成员作为集合的标签。例如决定用最小的对象作为标签，可以用“集合2”来表示集合{2,5,7,10}。 抽象结束。

作为一个受益者，我强烈建议先看这篇　超有爱的并查集~ 。　虽不能说是后无来者，但绝对是前无古人，能将知识讲得如此活泼有趣，清晰透彻。望洋兴叹，心向往之。所以在这里只谈一些总结。
先看题，原题链接

当芸芸众生忙着在朋友圈中发照片的时候，总有一些人因为太帅而没有朋友。  本题就要求你找出那些帅到没有朋友的人。  输入格式：  输入第一行给出一个正整数N（≤100），是已知朋友圈的个数；  随后N行，每行首先给出一个正整数K（≤1000）,  为朋友圈中的人数，  然后列出一个朋友圈内的所有人——为方便起见，  每人对应一个ID号，为5位数字  （从00000到99999），ID间以空格分隔；  之后给出一个正整数M（≤10000），为待查询的人数；  随后一行中列出M个待查询的ID，以空格分隔。  注意：没有朋友的人可以是根本没安装“朋友圈”，  也可以是只有自己一个人在朋友圈的人。  虽然有个别自恋狂会自己把自己反复加进朋友圈，  但题目保证所有K超过1的朋友圈里都至少有2个不同的人。    输出格式：  按输入的顺序输出那些帅到没朋友的人。ID间用1个空格分隔，  行的首尾不得有多余空格。如果没有人太帅，  则输出No one is handsome。  注意：同一个人可以被查询多次，但只输出一次。  输入样例1：  3  3 11111 22222 55555  2 33333 44444  4 55555 66666 99999 77777  8  55555 44444 10000 88888 22222 11111 23333 88888  输出样例1：  10000 88888 23333  输入样例2：  3  3 11111 22222 55555  2 33333 44444  4 55555 66666 99999 77777  4  55555 44444 22222 11111    输出样例2：  No one is handsome

这一题考虑用并查集做，现在考虑算法，可以将列举的每一个朋友圈的第一个人作为标签，并将这些标签加入set集合,以便于进行查询。另外再开一个数组为每一个ID置0，默认为未访问标记，查询过的标记置1,如是往复，直到查询结束，因为此题有大量查询语句，所以路径压缩是必须的。且这道题有一个细节：虽然ID号为5位数，但是输入与输出不处理的话，就不满足为5位数，例如00000，存入int型变量输出就会成为0（1位数），所以要固定占位5位，不足5位用0补足。下面是代码：

#include<bits/stdc++.h>using namespace std;int pre[100003];int visit[100003] = {0};set<int> p;int finder(int x){    int r = x;    while(pre[r] != r)        r = pre[r];    int y = x,z;    while(pre[y]!= r){  // 路径压缩        z = pre[y];        pre[y] = r;        y = z;    }    return r;}void join(int x, int y){    int fx = finder(x);    int fy = finder(y);    if(fx != fy)  pre[fx] = fy;}int main(){    ios::sync_with_stdio(false);    // 初始化前导节点    for(int i = 0;i<100003;i++)        pre[i] = i;    // 数据    int n,m,k,id,rt;    bool flag = true;    cin>>n;    while(n--){        cin>>m>>rt;          //指定根节点        for(int i = 1;i<m;i++){            cin>>id;            join(rt,id);    // 连接该id与根节点。        }        if(m != 1)            p.insert(finder(pre[rt]));// 保存根节点    }    cin>>k;    for(int i = 0;i<k;i++){        cin>>id;        if(!visit[id]){            visit[id] = 1;            int res = finder(pre[id]);            auto sig = p.find(res);            if(sig == p.end()) {    // 没有在某个朋友圈里                if(!flag) cout<<' ';                cout<<setw(5)<<setfill('0')<<id;                flag = 0;            }        }    }    if(flag) cout<<"No one is handsome"<<'\n';    else cout<<'\n';    return 0;}

对于并查集，

• 需要对根节点操作时，可以在录入数据时，指定某个点为为根节点，并将该节点加入set(红黑树)中，以备查找。
• 当题目存在大量节点查询时，此时路径压缩算法能起到很大的作用，而题目并没有大量查询时，路径压缩算法作用则不明显，反而会有额外时间开销。

　　前段时间用Java的BigInteger类做了一道题，于是便萌生了自己用C++实现一个BigInteger类的想法，顺带了解并掌握其底层算法。
　　准备阶段，我查阅了一下Java的BigInteger类的源代码(毕竟是轮子)，嗯，只是看了一下 ，然后开工。

　　首先我们分析一下BigInteger类成员变量以及成员函数 :

成员变量

• 大整数数串（bigInteger）
• 大整数位数（length）
• 大整数的正负（signum）

成员函数

• 加法+
• 减法-
• 乘法*
• 除法/
• 取余%

下面，我们一步一步的实现…

第一步：建立头文件 BigInteger.h 声明 BigInteger类

　　这里我们用vector来存储大数，可以灵活的配置空间。

#ifndef BIGINTEGER_H_INCLUDED#define BIGINTEGER_H_INCLUDED#include<iostream>#include<vector>#include<string>class BigInteger {private:    std::vector<int> bigInteger;        /* 保存大整数字串    */    size_t length;                      /* 表示大整数长度    */    int signum;                         /* 表示大整数正负 -1为负数 0表示数字0 1表示正数 */public:    // 构造函数    BigInteger();                       /* 空无参构造函数    */    BigInteger(const BigInteger &);     /* 拷贝构造函数      */    BigInteger(const std::string &);    /* 字符串构造大整数  */    // 成员函数    friend std::ostream& operator<<(std::ostream&, BigInteger &);    friend std::istream& operator>>(std::istream&, BigInteger &);    void setLength(const int&);    void setSignum(const int&);    int getLength();    int getSignum();    bool operator==(const BigInteger &);    bool operator>(const BigInteger &);    void operator=(const BigInteger &);    BigInteger operator+(const BigInteger &);    BigInteger operator-(const BigInteger &);    BigInteger operator*(const BigInteger &);    BigInteger operator/(const BigInteger &);    BigInteger operator%(const BigInteger &);};#endif // BIGINTEGER_H_INCLUDED

第二步：实现功能（这里只详解主要功能，其它略）

　　我们先来看两个常数：

const int LIMIT = 4;const int CARRY = 1e4;

LIMIT是bigInteger (vector)每个元素存的整数的位数，因为vector每个元素都存一个范围为
-2^31 至2^31 - 1的整数，最大的数位数为9位，考虑到最大的4位数相乘,也只有8位，故不会溢出int，所以选择存储4位数。
而CARRY则是vector的每个元素的基数，到10000就进位。

1.加法

　　加法应该是最好实现的，只用从低位开始加，加完判断进位即可。
PS: 代码块可左右滑动

BigInteger BigInteger::operator+(const BigInteger &tmp){    BigInteger t = *this, q = tmp;    size_t len1, len2;    if(t > q)  swap(t, q);                          /* 前面重载了 > 、= 和 == 运算符，选择位数多的加*/    len1 = t.bigInteger.size();                     /* 位数少的，再更新它的属性。将其作为返回值。*/    len2 = q.bigInteger.size();    bool flag = false;    for(size_t i = 0; i < len2; i++) {              /* 索引小的为低位，大的为高位        */        if(i < len1)                                /* 防止越界            */            q.bigInteger[i] += t.bigInteger[i];        if(q.bigInteger[i] >= CARRY) {            if(i == len2 - 1) {                      /* 最高位进位为q扩容并加入1 */                q.bigInteger.push_back(1);           /* 进1                 */                q.bigInteger[i] -= CARRY;                flag = true;            } else {                                /* 高位进位          */                q.bigInteger[i + 1]++;                q.bigInteger[i] -= CARRY;           /* 保存本位           */            }        }    }    if(flag) q.length++;                            /* 最高位有进位       */    return q;}

2.减法

　　虽然减法不能交换两个数的位置，但是交换后对结果处理一下符号也可以。所以如果被减数大于减数，则直接进行减法；
如果被减数小于减数，则交换它们的位置，再相减，并为结果添上负号。减的时候如果结果小于零，此时需要向高位借位。

BigInteger BigInteger::operator-(const BigInteger &tmp){    BigInteger q = *this, t = tmp;    size_t len1, len2;    if(q == t) {                                    /*两数相等则直接返回0*/        BigInteger r("0");        return r;    }    if(q > t) {        len1 = q.bigInteger.size();        len2 = t.bigInteger.size();        for(size_t i = 0; i < len1; i++) {            if(i < len2)                            /*防止越界          */                q.bigInteger[i] -= t.bigInteger[i];            if(q.bigInteger[i] < 0) {               /* 本位所减的结果小于0则向高位借位 */                q.bigInteger[i + 1]--;                q.bigInteger[i] += CARRY;           /*  更新本位        */            }        }        // 高位去0        for(int i = len1 - 1; i >= 0; i--) {        /* 因为q的最高位 只能大于等于t的最高位，         */            if(q.bigInteger[i] == 0) {              /* 当它们最高位相等时,此时最高位为0，用此算法    */                q.length -= LIMIT;                  /* 把高位的0去掉                                 */                q.bigInteger.pop_back();            } else break;                           /* 从最高位开始扫描，遇到第一个不为0的数则跳出   */        }        // 更新大数的长度        q.length = (q.bigInteger.size() - 1) * LIMIT;   /* 重新计算最高位的位数                   */        int k = q.bigInteger.back();        while(k) {                                  /*  计算位数        */            k /= 10;            q.length++;        }        return q;    } else {        len1 = t.bigInteger.size();        len2 = q.bigInteger.size();        for(size_t i = 0; i < len1; i++) {            if(i < len2)                t.bigInteger[i] -= q.bigInteger[i];            if(t.bigInteger[i] < 0) {                t.bigInteger[i + 1]--;                t.bigInteger[i] += CARRY;            }        }        // 大数符号        t.signum = -1;                              /*  反过来减，结果为负数*/        // 高位去0        for(int i = len1 - 1; i >= 0; i--) {            if(t.bigInteger[i] == 0) {                t.length -= LIMIT;                t.bigInteger.pop_back();            } else break;        }        t.length = (t.bigInteger.size() - 1) * LIMIT;        int k = t.bigInteger.back();        while(k) {            k /= 10;            t.length++;        }        return t;    }}

加减只支持无符号大整数运算,因为在算的时候可以灵活的加括号与换符号

3.乘法

　　乘法依照竖式算法，被乘数的每一位和乘数的每一位相乘并将结果保存到相应的位置，且该相应位置应加上上一位的进位与本位值。

BigInteger BigInteger::operator*(const BigInteger &tmp){    BigInteger t = *this, q = tmp, r;    int carry;    size_t i, j;    size_t len1 = t.bigInteger.size(), len2 = q.bigInteger.size();    vector<int> T(len1+len2, 0);    for(i = 0; i < len1; i++) {        carry = 0;        for(j = 0; j < len2; j++) {            int temp = t.bigInteger[i] * q.bigInteger[j] + T[i + j] + carry;  /* 保存第i位与第j位的乘积，并加上本位与进位值*/            if(temp >= CARRY) {                carry = temp / CARRY;                                         /* 保存进位值 */                T[i + j] = temp - temp / CARRY * CARRY;                       /* 更新本位值 */            } else {                carry = 0;                T[i + j] = temp;            }        }        if(carry != 0)         T[i + j] = carry;                                      /* 最高位进位 */    }    // 处理符号    if(t.signum < 0 && q.signum < 0)        r.signum = 1;    else {        if(t.signum < 0 || q.signum < 0)            q.signum = -1;        else if(t.signum == 0 || q.signum == 0) {            r.signum = 0;        } else {            r.signum = 1;        }    }    // 处理长度    if(r.signum != 0) {                                                      /* 先判断结果的符号 */        //  高位去0        for(int i = T.size() - 1; i >= 0; i--) {            if(T[i] == 0) {                T.pop_back();            } else {                break;            }        }        // 数字串长度        r.length = (T.size() - 1) * LIMIT;        int k = T.back();        while(k) {            k /= 10;            r.length++;        }        r.bigInteger = T;    } else {        r.length = 1;        T.resize(1);        r.bigInteger = T;    }    return r;}

4.除法

　　判定大小，如果被除数等于除数，返回1；如果被除数小于除数，返回0；如果被除数大于除数，则进入除法，最简单的就是反复的做减法，看能减多少个除数。这里只介绍最基础的
法。还有一种将这种方法优化一些的算法，完整版见我的Github 明月光。

BigInteger BigInteger::operator/(const BigInteger &tmp)     // 最基础的算法，效率上可能有不足{    BigInteger q = *this , t = tmp, ans, ZERO("0");    assert(!(t == ZERO));                       /* 除数不为0                */    if(q == ZERO) return ZERO;                  /* 被除数为0返回0           */    if(q == t) {                                /* 两数相等则直接返回1      */        ans.signum = 1;        ans.length = 1;        ans.bigInteger.push_back(1);    } else {        if(q > t) {                             /* 被除数大于除数，开始整除 */            vector<int> T(100, 0);            int index = 0, maxl = 0;            while(true) {                q = q - t;                if(ZERO > q) {                    if(!(ZERO == q)) break;     /* 直到减到q小于零，当能整除的时候要将商加1 */                }                T[index]++;                if(T[index] >= CARRY) {         /*判定进位              */                    T[index] = 0;                    T[++index]++;                    maxl = max(maxl, index);                    for(int i = index; i < maxl; i++) {                        if(T[i] >= CARRY) {                            T[i + 1]++;                            T[i] = 0;                        }                    }                    index = 0;                  /* 重回最低位累加      */                }            }            T.resize(maxl + 1);                 /* 缩放空间             */            if(q.signum < 0 && t.signum < 0)                q.signum = 1;            else {                if(q.signum < 0 || t.signum < 0)                     q.signum = -1;                else {                    q.signum = 1;                }            }            ans.bigInteger = T;        } else {            ans = ZERO;        }    }    return ans;}

5.取余

　　最简单的方法，代码如下2333333…

BigInteger BigInteger::operator%(const BigInteger &tmp){    BigInteger q = *this, t = tmp, ZERO("0"), m;    assert(!(q==ZERO));    assert(!(t==ZERO));    m = q / t;    return q - (m * t);}

　　这里还有另一种模拟取余的方法，

long long BigInteger::operator%(const long long &tmp){    BigInteger q = *this;    long long mod = 0, len = q.bigInteger.size();    for(int i = len - 1; i >= 0; i--) {        mod = ((mod * CARRY)%tmp + q.bigInteger[i]) % tmp;    }    return mod;}

下面是一些测试:

开始测试p:1234567890123456789q:123456789012345678p - q = 1111111101111111111p + q = 1358024679135802467p * q = 152415787532388366390794098763907942p / q = 10p % q = 9p % 1234567890 = 123456789结束测试

参考资料：

• 【算法】大数乘法问题及其高效算法
• C++大数模板

白云一片去悠悠，青枫浦上不胜愁。谁家今夜扁舟子，何处相思明月楼。——张若虚

重定义

古希腊阿波罗神殿门楣的石板上刻着这样一行字: 认识你自己。这寥寥几个字从人类文明发祥伊始，至现代，一直是一个长久不衰的话题。而我们又如何去认识自己呢？
问题的答案如同一千个人眼中的《哈姆雷特》，各有千秋。坚守自己的“哈姆雷特”让独特欲盖弥彰。

在威斯敏斯特大教堂地下室的墓碑林中，有一块闻名于世的墓碑。
它普通而又不平凡。普通是因为它周围都是诸如狄更斯、达尔文等世界名人的装饰华丽的墓碑，而它却只是粗糙的花岗岩质地，造型也一般，甚至连墓志铭都没有——是一块无名氏墓碑；
不平凡是因为每一位到过这里的人，他们可以不去拜谒世界名人，但是定会来到这座墓碑前，进而被它深深地震撼。因为这座墓碑上刻着这样一段碑文：

When I was young and free and my imagination had no limits, I dreamed of changing the world. As I grew older and wiser, I discovered the world would not change, so I shortened my sights somewhat and decided to change my country. But it, too, seemed immovable. As I grew into my twilight years, in one last desperate attempt, I settled for changing only my family, those closest to me. But alas, they would have none of it. And now, as I lie on my bed, I suddenly realize:If I had only changed myself first, then by example I would have changed my family. From their inspiration and encouragement, I would then have been able to better my country, and who knows I may have even change the world.