笔记 on 鸽巢

html table合并单元格同时合并行列的方法

Sun, 12 Jan 2025 02:30:42 +0800

在html中使用table标签，有时会需要合并单元格。
在单元格标签td中，用于合并单元格的属性：
rowspan=“合并的单元格个数” 合并行
colspan=“合并的单元格个数” 合并列
合并的代码写在参与合并的单元格中，最左侧/最上侧的单元格。最后删掉被合并的单元格。

只合并一行的单元格/只合并一列单元格的一般情况

画一个9x9的表格

    <table border="1" width="200">
        <tr>
            <td>1</td>
            <td>2</td>
            <td>3</td>
        </tr>
        <tr>
            <td>4</td>
            <td>5</td>
            <td>6</td>
        </tr>
        <tr>
            <td>7</td>
            <td>8</td>
            <td>9</td>
        </tr>
    </table>

显示效果

合并列：对2号单元格和3号单元格进行合并在2号单元格的td标签中输入colspan=“2” 并删掉被合并的单元格（3号单元格）删掉之后第一行只剩下两个td标签

合并行：对4号单元格和7号单元格进行合并在4号单元格的td标签中输入rowspan=“2” 并删掉被合并的单元格（7号单元格）删掉之后第三行只剩下两个td标签

	<table border="1" width="200">
        <tr>
            <td>1</td>
            <td colspan="2">2</td>
        </tr>
        <tr>
            <td rowspan="2">4</td>
            <td>5</td>
            <td>6</td>
        </tr>
        <tr>
            <td>8</td>
            <td>9</td>
        </tr>
	</table>

显示效果

同时合并行列的情况

同时合并行列的情况和只合并行/合并列的方法是一样的，可以同时使用rowspan和colspan

还是上面的9x9表格这次要合并4、5、7、8四个单元格在4号单元格中的td标签中输入rowspan=“2” colspan=“2” 删掉5、7、8号单元格删掉后第二行只剩下两个td标签，第三行只剩下一个td标签

    <table border="1" width="200">
        <tr>
            <td>1</td>
            <td>2</td>
            <td>3</td>
        </tr>
        <tr>
            <td rowspan="2" colspan="2">4</td>
            <td>6</td>
        </tr>
        <tr>
            <td>9</td>
        </tr>
    </table>

显示效果

同时合并行列单元格时出现的单元格显示比例异常问题及解决方案

问题描述

到这里都是正常的，但是我发现了一个问题上图的情况，4号单元格是四个单元格合并而来，并且其中是出现了第一、第二列的合并和第二、第三行的合并在这种情况下，如果再出现另一个单元格合并，合并的行列和四号单元格有重叠（即涉及到第一、第二列和第二、第三行），会出现单元格显示比例异常的问题

例如：在上图的基础上，合并2、3号单元格或者合并3、6号单元格，都会出现这样的情况

合并2、3号单元格正常情况下，1号和2号单元格显示比例应该为1：2，但实际显示是接近1：1

    <table border="1" width="200">
        <tr>
            <td>1</td>
            <td colspan="2">2</td>
        </tr>
        <tr>
            <td rowspan="2" colspan="2">4</td>
            <td>6</td>
        </tr>
        <tr>
            <td>9</td>
        </tr>
    </table>

显示效果

合并3、6号单元格正常情况下，3号和9号单元格显示比例应该为2：1，但实际是接近1：1

    <table border="1" width="200">
        <tr>
            <td>1</td>
            <td>2</td>
            <td rowspan="2">3</td>
        </tr>
        <tr>
            <td rowspan="2" colspan="2">4</td>
        </tr>
        <tr>
            <td>9</td>
        </tr>
    </table>

显示效果

解决方案

宽度显示异常时可以给td标签加上宽度高度显示异常时可以给td标签加上高度

修改后的合并2、3号单元格代码 //注意这里删除了上面的代码都有的table标签里的width属性

    <table border="1">
        <tr>
            <td width="100">1</td>
            <td colspan="2" width="200">2</td>
        </tr>
        <tr>
            <td rowspan="2" colspan="2" width="200">4</td>
            <td width="100">6</td>
        </tr>
        <tr>
            <td>9</td>
        </tr>
    </table>

显示效果修改后的合并3、6号单元格代码

    <table border="1" width="200">
        <tr>
            <td height="50">1</td>
            <td>2</td>
            <td rowspan="2" height="100">3</td>
        </tr>
        <tr>
            <td rowspan="2" colspan="2">4</td>
        </tr>
        <tr>
            <td height="50">9</td>
        </tr>
    </table>

显示效果

博弈论-第二章基本假设

Sun, 27 Mar 2022 01:04:49 +0800

博弈基于人的理性

　　认知理性：自我利益的判断者对偏好的认知

　　行为理性：自我利益的追求者利益最大化

不同的参照不同的选择

　　人在做选择的时候总会比较，不同的参照会影响比较的结果，从而影响人的选择

　　当增加了一个印刷版的选项之后，电子版加印刷版一比就像白送电子版。于是，选择电子版加印刷版的人大幅增加。

　　当增加了一个松下微波炉B款之后，松下A款显得价格便宜打折力度还大，选择松下A款的人大幅增加。

　　对于消费者来说，需要的不是便宜，而是占到便宜。

让贵的显得不那么贵

　　2004年杭州市推出100辆奔驰豪华出租车，起步价12元，4公里，而普通的出租车是10元，4公里。

　　10是一个整数，12和10一比较就显得贵了很多，如果把奔驰出租车的起步价修改为10元，3公里，这个价格差距会显得不那么明显。

　　商品价格喜欢定X9，X99也是因为看到这种价格，人会自动和一个整数进行比较，不足这个整数让它显得要相对便宜一点。就像499和501相比，一个是五百不到，一个是五百多，2元之差，感觉却差别很大。

锚定效应

　　维多利亚的秘密推出五百万一件的天价内衣，定下了高端奢侈的基调（锚），之后再买几百一件的内衣，不仅显得合理，甚至是“便宜”。

　　参照系要牢牢掌握在自己手里。

多让别人做选择题，而不是判断题

　　如果不让对方从两个有利于你的选项中挑选，对方就会从有利于你和有利于自己中挑选，自然对方会选择有利于自己。

　　因此，让对方从两个或三个里面做选择，并且，选项之间必须要有明显差异。

　　某同学需要搬东西，但又不想坐车，于是拦下一车，问司机：“你是不是要去xxx？”

　　司机说：“是啊。”

　　同学说：“可以帮我把东西送到那里吗？”

　　司机摇摇头：“不行，那怎么行呢？”

　　同学又问：“那给你五元？”

　　结果，司机同意了。

私以为，这和开天窗先掀屋顶是一个道理。

罗森塞蜈蚣博弈中的理性人

　　上次说到，在该博弈中，要做的就是在对方结束前结束。

　　因此，越是理性的人，会在越前面，甚至是第一轮就结束游戏，反而那些愿意吃亏的人，越容易玩到后面。

　　所以，在正和博弈中，愿意吃亏，然后和更愿意吃亏的人做朋友，和他们，更容易建立良好的合作关系。

合作信号的作用

　　A先进行选择，若A选择不合作，则两人各拿20，若A选择合作，则轮到B选择。若B选择合作，则两人各拿25，否则，A拿15，B拿30。

　　若B在选择之前知道了A的合作选择，B选择合作的概率是65％，但如果B不知道自己的选择机会来源于A的合作选择，则B选择合作的概率是33％。

　　也就是说，让对方看到你的合作信号，对于后续的合作是很有必要的。

共同知识

　　指各参与者在无限递归意义上均知悉的事实。即每个人知道事件E，每个人知道每个人知道事件E，每个人知道每个人知道每个人知道事件E一直到无穷层次。

　　这么一说好像很抽象，举个例子。

AB两个小队在山脚的两端，约定在3点一起攻击山上的敌人，如果只有一队进攻打不过敌人。于是A派人到B那里传递约定时间，B为了让A知道自己知道了，也要派人去A那里通知（有传达失败的可能，比如传信兵被地雷炸死）。 A收到之后，为了让B知道自己知道B已经知道了，也要派人再传确认信息（如果自己不知道B已经知道了，有可能会选择不进攻）　　……就这样无限传信。

　　在信息不对称的情况下，有时候博弈的结果不取决于大家是怎么想的，而是取决于大家认为大家是怎么想的。

本文是该博弈论课程的学习笔记，包含课程内容和部分个人见解：【浙大|耶鲁】博弈论（合61讲）蒋文华本·波拉克(Ben Polak)

博弈论-第一章概述

Thu, 24 Mar 2022 01:21:47 +0800

何为博弈：

　　博：博览全局。

　　弈：对弈棋局。

　　博弈：指在一定的游戏规则约束下，基于直接相互作用的环境条件，各参与人依据所掌握的信息，选择各自的策略（行动），以实现利益最大化的过程。

　　1）首先确定谁是博弈的对手和未来的对手

　　2）博弈中既存在竞争关系，也存在合作关系

一个简单的数字游戏：

　　各位同学写1个介于1与100之间的自然数（整数，包括1与100）在内，然后求出所有数字的平均数，如果你写的数字最接近该平均数的二分之一，那么你将在游戏中胜出。

　　一般来说，能够获胜的数字取决于平均数，平均数取决于其他人写的数字，于是你就会猜测其他人写了什么数字。如果平均数是50，那么能够获胜的数字是25，如果其他人都想到了这一层，写25，那么平均数就是25，能够获胜的数字是12，如果其他人也想到了这一层……推到极致，能够获胜的数字就是1，但其实大多数人并不会想这么多层，所以其实1获胜的概率是很低的，能够获胜的数字在区间[12,25]的可能性比较大。同时，也可能存在一些不想获胜，故意捣乱的人，会写50以上的数字。

　　博弈就是你中有我，我中有你。由于直接相互作用（互动），每个博弈参与者的得益不仅取决于自己的策略（行动），还取决于其他参与者的策略（行动）。博弈的核心在于整体思维基础上的理性换位思考，用他人的得益去推测他人的策略（行动），从而选择最有利于自己的策略（行动）。

罗森塞蜈蚣博弈

　　两人分钱袋子里的钱。　　一开始钱袋子里的钱有50，A的回合，A可以选择直接分钱或继续参与。如果直接分钱，A获得40，B获得10；如果继续游戏，则钱袋子里的钱翻倍。　　此时钱袋子里的钱有100，B的回合，B选择直接分钱则A获得20，B获得80；B选择继续游戏则钱袋子里的钱翻倍。　　此时钱袋子里的钱有200，A的回合，A选择直接分钱则A获得160，B获得40；A选择继续游戏则钱袋子里的钱翻倍。　　此时钱袋子里的钱有400，B的回合，B选择直接分钱则A获得80，B获得320；B选择继续游戏则钱袋子里的钱翻倍。　　此时钱袋子里的钱有800，这是最后的回合，A获得640，B获得160。

　　可以看出，在自己的回合中，如果选择直接分钱，自己获得的钱是对方的四倍（以第一轮为例，A获得40，B获得10），如果选择继续游戏，下一轮对方选择结束，则自己获得的钱变为原来的一半（从40变为20），而和在本轮结束相比（在第一轮结束B获得10），对方可以获得八倍报酬（B在第二轮结束可获得80）。

　　所以其实是要猜测对方在自己的回合中，是选择放弃高报酬让总金额变大，还是会选择结束游戏获得目前金额中的大部分。当然，越往后对方选择结束游戏的可能性越高。

　　以终为始，第五轮游戏结束，A可以分更多的钱，所以可以猜测，如果到了第四轮，B肯定会结束游戏，而如果A预测到这一点，则A肯定会在第三轮结束游戏，所以B很可能会在第二轮选择结束……

　　在对方选择结束前结束，是利益最大化的。而对方结束是因为对方认为我会结束，想让对方继续就得让对方认为我会继续。自己看起来越傻（博傻），对方就越愿意跟我们合作，适当的让利，不要看起来太精明。

又一个简单的数字游戏

　　每位同学写5个大于0的自然数，如果你写数字中有一个是所有同学所写的数字中最小的（且没有重合），那么你将在该游戏中胜出。

　　假设一共有100人参加游戏，那么有5 x 100=500个数字，如果从1开始每一个数字都至少有一个重复，那么不重复的数字从251开始。但事实上这样的概率是非常低的，用计算机进行模拟，数字区间[1,100]，每一个数字的都有重复的概率也是非常低的。

　　1几乎百分百会重复，10以下数字不重复的概率也几乎为零。[20,40]之间是最有可能的，同时写奇数的远比偶数要多，因此偶数胜出的可能性要大得多。在老师经历中10次游戏有8次是偶数，2次是奇数。

　　如果多次进行游戏，数字的分布会越来越分散。　　
　　
　　

选对市场（对手）比选对策略更重要

《说谎者的扑克牌》一书中写道：“那些掌握最充分信息的股票市场经纪人和分析师在市场上选股的成绩，并不比猴子从帽子里抓个名字或把《华尔街日报》钉在墙上向股票投掷飞镖的择股法来得更好！”

　　在充分竞争的市场里，很难获得平均以上的利润。（不要在一个充分竞争的市场去追求成功，进入门槛越低的市场，竞争越充分）

　　在博弈之前，博弈就已经开始了。

学习博弈论的收益

　　1）当局者清：更有利的选择，更快速的反应

　　2）旁观者更清：理解历史与现实，预测未来的发展

　　3）可以提出更好的游戏规则

一些模型

　　1）古诺模型

　　参加博弈的双方以各自在同一时间相互独立的产量作为决策的变量，是一个产量竞争的模型。

　　2）伯川德模型

　　该模型与古诺模型的不同之处在于，企业把其产品的价格而不是产量作为竞争手段和决策变量，通过指定一个最优的销售价格来实现利润最大化。（价格战）

　　3）斯塔克尔伯格模型

　　该模型分析的是这么一种竞争：企业A先决定一个产量，然后企业B可以观察到这个产量，并根据所观察到的产量来决定它自己的产量。

术语解释

　　1）参与人（players）：理性选择的主体。

　　2）信息（information）：参与者有关博弈的知识。

　　3）行动（action）：参与者能够选择的变量。

　　4）策略（strategies）：参与者在行动之前所准备好的一套完整的行动方案（预案）。策略让我们建立起了从信息到行动的快速反应机制，从而能够以最快的速度做出行动选择。

　　-完整性 -多样性 -不可观察性

　　三十六计中的某一计是行动，什么情况用哪一计是策略。

　　5）损益（payoff）：参与者的得与失。

　　6）结果（outcome）：所有参与者选择各自策略的后果。

　　7）均衡（equilibrium）：所有参与者的最优策略组合。

　　8）博弈的规则（rules of the game）：参与者、行动和结果合起来称为博弈的规则。

　　9）博弈论（game theory）：是一种研究人们怎么做策略（行动）选择及其最后的均衡结果会是什么的理论。

博弈的分类

　　1）合作博弈和非合作博弈

　　合作博弈：指参与者能够达成一种具有约束力的协议，在协议范围内选择有利于双方的策略。

　　非合作博弈：指参与者无法达成这样一种协议。

　　2）静态博弈和动态博弈

　　静态博弈：指在博弈中，参与者同时选择，或虽非同时选择，但是在逻辑时间上是同时的。

　　动态博弈：指在博弈中，参与者的行动有先后顺序，且后行动者能够观察到先行动者的行动。

　　3）完全信息博弈与不完全信息博弈

　　完全信息博弈：指在博弈中，每个参与者对其他参与者的类型、策略空间及损益函数都有准确的信息。

　　不完全信息博弈：总有一些信息不是所有参与者都知道的。（信息不对称）

　　完全信息静态博弈：纳什均衡-纳什（本课重点）

　　完全信息动态博弈：子博弈精炼纳什均衡-泽尔腾

　　不完全信息静态博弈：贝叶斯纳什均衡-海萨尼

　　不完全信息动态博弈：精炼贝叶斯纳什均衡-泽尔腾

　　4）零和博弈和非零和博弈

　　零和博弈：指博弈前的损益总和与博弈后的损益总和相等。

　　非零和博弈：指博弈后的损益大于（小于）博弈前的损益总和。（正和或负和）

　　不玩负和游戏，少玩零和游戏，多玩正和游戏。

本文是该博弈论课程的学习笔记，包含课程内容和部分个人见解：【浙大|耶鲁】博弈论（合61讲）蒋文华本·波拉克(Ben Polak)

编写测试用例的方法（1）——等价类划分法和边界值分析法

Tue, 27 Apr 2021 11:41:18 +0800

本文介绍在黑盒测试中常用的等价类划分法和边界值分析法。

等价类划分法：

大家都知道，测试中想要穷举所有可能可以说是不能实现的，所以，测试人员希望可以找到一组可以尽可能代表所有可能的数据，用它们来进行测试。等价类划分法就说解决如何用适当的数据子集来代表整个数据集的问题，通过降低测试的数目去合理的覆盖更多的可能数据。

什么是等价类？

等价类是指某个输入域的一个特定的子集合，在该子集合中各个输入数据对于揭露程序中的错误都是等效的。

（1）有效等价类：指对于程序的规格说明来说是合理的、有意义的输入数据构成的集合。利用有效等价类可检验程序是否实现了规格说明所规定的功能和性能。（即合理的输入）（2）无效等价类：指对程序的规格说明是不合理的或无意义的输入数据所构成的集合。对于具体的问题，无效等价类至少应有一个，也可能多个。（即不合理的输入）

举个例子

现在需要测试一个注册功能，输入条件是：用户名是10位以内数字和大小写字母，密码是16位以内的数字、大小写字母。

这个例子中有两个输入域，分别是用户名和密码。

对于用户名来说 有效等价类有：（1）10位以内数字和大小写字母

无效等价类有：（2）10位以上的数字和大小写字母（3）含有数字和大小写字母以外的字符（4）空

对于密码来说 有效等价类有：（5）16位以内的数字、大小写字母

无效等价类有：（6）16位以上的数字和大小写字母（7）含有数字和大小写字母以外的字符（8）空

使用等价类划分法编写用例的步骤： 1.建立等价类表，列出所有划分的等价类 2.为每一个等价类规定一个唯一的编号

	有效等价类	无效等价类
用户名	（1）10位以内数字和大小写字母	（2）10位以上的数字和大小写字母
		（3）含有数字和大小写字母以外的字符
		（4）空
密码	（5）16位以内数字和大小写字母	（6）16位以上的数字和大小写字母
		（7）含有数字和大小写字母以外的字符
		（8）空

3.设计一个新的测试用例，尽可能多的覆盖尚未覆盖的有效等价类 4.重复步骤3，使得所有有效等价类都被测试用例所覆盖

用例编号	覆盖等价类	操作说明	输入数据	预期结果	实际结果
1	（1）（5）	输入用户名和密码，点击注册	用户名=“abc123” 密码=“abc123”	注册成功

5.设计一个新的测试用例，只覆盖一个无效等价类（除覆盖无效等价类的输入域外其他输入都是有效的） 6.重复步骤4，使得所有无效等价类都被测试用例所覆盖

用例编号	覆盖等价类	操作说明	输入数据	预期结果
2	（2）	输入用户名和密码，点击注册	用户名=“abcdefg1234567” 密码=“abc123”	注册失败
3	（3）	输入用户名和密码，点击注册	用户名=“abc123@！” 密码=“abc123”	注册失败
4	（4）	输入用户名和密码，点击注册	用户名="" 密码=“abc123”	注册失败
5	（6）	输入用户名和密码，点击注册	用户名=“abc123” 密码=“abcdefghi123456789”	注册失败
6	（7）	输入用户名和密码，点击注册	用户名=“abc123” 密码=“abc123_。”	注册失败
7	（8）	输入用户名和密码，点击注册	用户名=“abc123” 密码=""	注册失败

边界值分析法：

实践证明，程序往往在输入输出的边界值上出错。

边界值分析法就是在某个输入输出变量范围的边界上，验证系统功能是否正常运行的测试方法。边界值分析法常被看作等价类划分法的一种补充，常常两者结合在一起使用。

（1）如果输入条件规定了数值的范围，那么取边界值和刚好超出边界的值进行测试，如输入条件规定为1-9，那么测试1、9、0、10 （2）如果输入条件规定了值的个数，那么取最大个数、最小个数、比最大值多一个、比最小值少一个的值进行测试，如上面的用户名输入条件是10位以内的数字和大小写字母，那么测试10位、1位、11位、0位的用户名

计算机的数值运算都是有限制的，有时候会出现溢出的情况，这也是需要检验的。

补充说明，边界值分析法还有三个概念：（1）上点：边界上的点，开区间则上点在区间外，闭区间则上点在区间内（2）内点：区间内任意一点都是内点（3）离点：离边界最近的点，开区间则离点在区间内（边界往里一个点），闭区间则离点在区间外（边界往外一个点）

对于输出域的测试与输入域的类似，也是分析等价类和边界值，区别就在于需要从输出结果倒推输入的数据来编写测试样例。

本文部分参考软件测试方法和技术（第3版）》朱少民主编清华大学出版社百度百科相关词条

软件测试的基本概念

Sat, 24 Apr 2021 02:36:30 +0800

软件产品质量的特性：

1.功能性：达到设计规范以及满足用户需求的程度
2.可靠性：规定时间和条件下，维持正常运行的能力
3.性能：响应速度以及实现功能所需的计算机资源的有效程度
4.容量：系统的接受、容纳程度，或某项功能的最大数据量或最大限度
5.可用性：用户学习的简单程度，适用于不同类型用户的程度
6.可测量性：系统的某些特性可以通过量化数据指标描述
7.可维护性：环境变化、需求变化或出现错误时进行修复改变的难易程度
8.兼容性：在不同的操作系统或环境中可以稳定运行的程度
9.可扩展性：增加新功能、扩充系统的难易程度

软件测试的分类:

按测试层次划分：

（1）底层测试：单元测试
（2）接口层次：集成测试
（3）系统层次：系统测试
（4）用户层次：验收测试

按被测试对象划分：

（1）单元测试，组件测试，模块测试
（2）程序测试
（3）系统测试
（4）文档测试
（5）数据库测试、服务器测试

按测试目的划分：

（1）功能测试：测试每个功能是否按照实现设计的那样运行
（2）压力测试：模拟实际应用的软硬件环境及用户使用过程的系统负荷，长时间或超大负荷地运行测试软件，来测试被测系统的性能、可靠性、稳定性等
（3）性能测试：测定系统在不同负载条件下的系统具体性能指标
（4）可靠性测试：测试系统是否能长期稳定正常运行，如测定系统平均故障间隔时间。可靠性测试包括强壮性（鲁棒性）测试和异常处理测试。
（5）灾难恢复性测试：测试软件在系统崩溃、硬件故障等灾难发生后重新恢复系统和数据的能力
（6）安全性测试：测试系统在应对恶意攻击时的系统防护能力
（7）兼容性测试：测试系统在不同环境下的实际表现
（8）回归测试：测试新的变化是否会对原有功能的正常使用产生影响
（9）安装测试：模拟真实的用户环境，测试系统是否能按照安装说明书成功安装

根据程序是否运行划分：

（1）静态测试
（2）动态测试

根据是否主动发送请求划分：

（1）主动测试：需要设计测试用例，主动发送请求，输入数据，获得系统反馈的数据，一般处于测试环境
（2）被动测试：不需要设计测试用例，只需要监测系统的运行，获取系统运行中产生的数据，一般处于实际运行环境

根据是否知道程序内部划分：

（1）黑盒测试：在完全不考虑程序内部结构和内部特性的情况下，在程序接口进行测试，它只检查程序功能是否按照需求规格说明书的规定正常使用，程序是否能适当地接收输入数据而产生正确的输出信息
（2）白盒测试：按照程序内部的结构测试程序，测试程序内部的变量状态、逻辑结构、运行路径等，检验程序中的每条通路是否都能按照预定要求正确工作，检查程序内部动作或运行是否符合设计规格要求。

软件测试的级别：

1.单元测试：主要采用白盒测试方法，通常要编写驱动程序和桩程序。
2.集成测试：在单元测试的基础上，按照设计要求不断进行集成而进行的测试，目的是发现单元之间的接口问题。通常有两种集成方式：一次性集成方式和渐增式集成方式，但一般要求采用渐增式集成方式。
3.系统测试：在集成测试完成之后，一般采用黑盒测试方法进行功能测试，非功能测试则在实际运行环境或模拟实际运行环境，针对系统的非功能特性进行测试，包括压力测试，性能测试，安全测试等。

本文内容主要参考：《软件测试方法和技术（第3版）》朱少民主编清华大学出版社百度百科相关词条

深度优先搜索（DFS）和广度优先搜索（BFS）

Wed, 08 Jul 2020 06:56:37 +0800

深度优先搜索（DFS）

事实上，深度优先搜索属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次. 从根开始计算，到找到位于某个节点的解，回溯法（深度优先搜索）作为最基本的搜索算法，其采用了一种“一只向下走，走不通就掉头”的思想（体会“回溯”二字），相当于采用了先根遍历的方法来构造搜索树。 ————摘自<深度优先搜索>《百度百科》

从百科的摘要我们可以知道，深度优先搜索（以下简称深搜）的思想其实很简单，就是“不撞南墙不回头”，以下是详细讲述：以一颗树举例。从1出发，1有两个子结点2和3，按顺序来先走到2，2有两个子结点4和5，按顺序来先走到4。 4没有子结点，也就是说已经走到头了，“撞墙”了，所以得回头了。那么我们回到2，寻找下一个未遍历的子结点也就是5，5没有子结点，于是回头。此时2的两个结点都已经走过了，所以要继续回头，回到1…… 因此深搜对该图的遍历顺序应该是： 1 2 4 5 3 6 7 放在二叉树里其实就是先序遍历。

代码实现

用矩阵表示这棵树（这里只是为了方便），t[a][b]指的是b是a的子结点。

#include <iostream>
using namespace std;
int sum;//遍历的点数
int t[8][8];//树
void dfs(int x){
	sum++;//点数+1
	for(int i=1;i<=7;i++){//按顺序遍历子结点
		if(t[x][i]==1)//如过i是x的子结点
			dfs(i);//往下走到i，递归
	}
}
int main(){
	int z;
	for(int i=1;i<=7;i++)//输入树
		for(int j=1;j<=7;j++)
			cin>>t[i][j];
	dfs(1);//深搜
	cout<<sum<<endl;//输出遍历的点数
	return 0;
}

广度优先搜索（BFS）

宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。 BFS，其英文全称是Breadth First Search。 BFS并不使用经验法则算法。从算法的观点，所有因为展开节点而得到的子节点都会被加进一个先进先出的队列中。 ——摘自<广度优先搜索>百度百科

广度优先搜索（后面简称广搜）的思想就像石子丢进湖里以后，从一个点一圈一圈往外扩散的涟漪。还是用这棵树举例。我们从1出发。将1的子结点2和3放到队列里，此时队列里的顺序是： 2 3 从队列里取出一个结点2，将2的两个子结点4和5放进队列里，此时队列里的顺序是： 3 4 5 从队列里取出一个结点3，将3的两个子结点6和7放进队列里，此时队列里的顺序是： 4 5 6 7 从队列里取出一个结点4，它没有子结点，此时队列里的顺序是： 5 6 7 …… 广搜遍历这棵树的顺序是1 2 3 4 5 6 7

代码实现

仍然是用矩阵表示这棵树，t[a][b]指的是b是a的子结点。实现了输入目的结点，输出到达结点的最短步数的功能。

#include <iostream>
#include <queue>
using namespace std;
int z;//目的结点
int t[8][8];//树
struct point
{
	int x,step;//x是结点名，step是走到该点的步数
};
point bfs()
{
	point now,next;//目前的点，下一个点 
	now.x=1,now.step=0; //起始结点
	queue<point> q;//新建队列
	q.push(now);//将初始结点放进队列
	while(!q.empty())
	//如果队列非空，或者说还有结点未到达过
	{
		now=q.front();
		q.pop();//取出队列第一个结点
		if(now.x==z)//如果到达目的结点，结束
			return now;
		for(int i=1;i<=7;i++)
		{
			if(t[now.x][i]==1)//找到当前结点的子结点
			{
				next.x=i;
				next.step=now.step+1;
				//子结点的步数等于当前节点步数+1
				q.push(next);//子结点放进队列
			}
		}
	}
	return now;
}
int main(){
	for(int i=1;i<=7;i++)//输入
		for(int j=1;j<=7;j++)
			cin>>t[i][j];
	cin>>z;
	point end;//终点结点
	end=bfs();
	cout<<end.step<<endl;
	return 0;
}

一般情况下，可以发现，队列中的点的步数不会相差超过1，且必然是排在前面的比排在后面的步数少（按照队列先进先出的原则必定是先处理完步数为n的结点才会轮到步数为n+1的结点），因此广搜可以找到从起点到终点的最短路径。

树状数组

Sat, 28 Mar 2020 06:37:53 +0800

树状数组

树状数组(Binary Indexed Tree(B.I.T), Fenwick Tree)是一个查询和修改复杂度都为log(n)的数据结构。主要用于查询任意两位之间的所有元素之和，但是每次只能修改一个元素的值；经过简单修改可以在log(n)的复杂度下进行范围修改，但是这时只能查询其中一个元素的值(如果加入多个辅助数组则可以实现区间修改与区间查询)。这种数据结构（算法）并没有C++和Java的库支持，需要自己手动实现。在Competitive Programming的竞赛中被广泛的使用。树状数组和线段树很像，但能用树状数组解决的问题，基本上都能用线段树解决，而线段树能解决的树状数组不一定能解决。相比较而言，树状数组效率要高很多。 ——摘自<树状数组>百度百科

设有一数列A{1…n} 用树状数组T[n]进行保存 Tn指数组第n个元素的数值，An指数列的第n个元素如图所示

对于第n个数组元素Tn，它包含的数列元素为2^k个（其中k为n二进制末尾0的个数） 同时Tn被它后面第2^k个数组元素所包含。 比如T1就被它后面第2^k=1个数组元素，也就是T2所包含而T2就被它后面第2^k=2个数组元素，也就是T4所包含

Lowbit函数

Lowbit函数的作用是求2^k 我们知道，二进制数的第n位（从右往左数起）表示的数值是2^(n-1) 当n为0001（十进制1）的时候，k为0，2^k为1 当n为0010（十进制2）的时候，k为1，2^k为2 当n为0011（十进制3）的时候，k为0，2^k为1 当n为0100（十进制4）的时候，k为2，2^k为4 …… 可以发现，2^k的值等于n最低位1所代表的数值 所以，Lowbit函数的作用也是取出n最低位的1

在计算机中，使用补码储存和表示数值补码的负数相当于原码取反再加1 而补码和原码进行按位与运算时（&），得到的结果就是原码最低位1 ps：按位与运算（&）同是1为1，否则为0

因此Lowbit可以这样写

1
2
3

int Lowbit(int x){
	return x&(-x);
}

还有另一种写法这里先给出，但是具体思路还不清楚，只知道作用是相同的

1
2
3

int Lowbit(int x){
	return x&(x^(x-1));//^：按位异或，不同为1，相同为0
}

修改数列元素An的函数Update

若要修改An，必须修改其所有祖先，最坏情况下为修改第一个元素，最多有log2(n)个的祖先由于An被从Tn开始的多个数组元素包含，因此需要循环添加直到树状数组边界上面也有提到，Tn被它后面第2^k个数组元素所包含以下是代码：

void update(int n,int number){//n为修改的数列元素Ax，number为改变数值
	while(n<=along){//along为树状数组长度
		T[n]+=number;
		n+=Lowbit(n);//往后移动到下一个包含Ax的数组元素
	}
}

获得数列A1…An和的函数Getsum

由于A1…An的和被分割为许多块，因此需要一块块加起来才能得到结果上面也有提到，Tn包含的数列元素数为2^k，即Lowbit(n)，而从A1到An一共包含n个数列元素可以这么理解，从Tn开始，每次获得Lowbit(当前格)个元素，因此要向前跨Lowbit(当前格)格，直到走到T1之前（获得所有元素）。以下是代码：

int Getsum(int n){
	int sum=0;//sum为A1…An的和
	while(n>0){
		sum+=T[n];//添加当前的一块
		n-=Lowbit(n);//往前跨Lowbit(n)格
	}
	return sum;
}

n –= Lowbit(n)实际上等价于将n的二进制的最后一个1减去。而n的二进制里最多有⌈log2(n)⌉（向上取整）个1，所以查询效率是log2(n)的。

============== 以求A1…A7的和为例得出结果为T7+T6+T4只要三个数相加而如果用普通数组直接保存数列A，要求A1…A7的和需要七个数相加；如果普通数组保存A的前n项和，每次修改An都要改动n个数组元素

因此在需要多次求数组某一段的和时，使用树状数组保存可以有效提高效率

图的邻接矩阵

Thu, 24 Oct 2019 22:41:37 +0800

图的邻接矩阵和邻接表

ps：本文主要针对还没有学过数据结构的人群，所以会尽量写得简单易懂，但用词上不一定十分准确。

一般来说，我们保存一个图常用的方法有两种，分别是邻接矩阵和邻接表。下面我们用这张图来做例子：这是一张无向图，无向图指的是通路没有方向的图。也就是说，如果点1和点2之间有通路，那么可以从点1到点2，也能从点2到点1。

有向图则是指通路有方向的图。也就是说，如果点1到点2有一条通路，那么只能从点1到点2，而不能从点2到点1。（当然可以同时存在点1到点2通路和点2到点1的通路，这种情况会构成一个环）比如这样：

1.邻接矩阵

邻接矩阵相对而言更好理解。假设有图有n个顶点，那么我们就建一个大小为（n+1）*（n+1）的二维数组。（注意这里顶点的编号是从1开始所以才需要+1）

现在有五个点，分别叫1 2 3 4 5（也可以用字符类型的名字，方法是用一个char数组存下每个点的名字，数组的下标就是点的编号，其实也就是在数字编号的基础上加一个char类型的名字）

我们建一个大小为6*6的二维数组map[6][6]; 先用循环把二维数组的所有数全部初始化为一个很大的数，比如11111 然后再将图输入一般输入图是这种输入格式：点1 点2 权值（权值不一定有）把上面的例子（无向图）输入就是这样的： 1 2 7 2 3 12 3 4 2 4 5 8 3 5 3 4 1 17 这个图有六条边，所以有六行输入。以输入的第一行为例，我们只要把map[1][2]和map[2][1]都置为7即可（因为是无向图所以可以从1到2也能从2到1，如果没有权值可以置为0），以此类推。如果是有向图则只将map[1][2]置为7（单向通路）这样我们就把图存好了。（没错邻接矩阵就是这么简单，但是它占的空间比较大下面是代码

#include <stdio.h>
int main()
{
	int i,j;
	int point=5,side=6;//点的序号从1开始 ，point是点，side是边 
	int map[point+1][point+1];//建图 
	for(i=0;i<point+1;i++)//初始化为11111 
		for(j=0;j<point+1;j++)
			map[i][j]=11111;
	for(i=0;i<side;i++)//输入图的side条边 
	{
		int p1,p2,weigh;
		scanf("%d%d%d",&p1,&p2,&weigh);
		map[p1][p2]=weigh;
		map[p2][p1]=weigh;//无向图双向 
	}
	for(i=1;i<point+1;i++)//输出 
	{
		for(j=1;j<point+1;j++)
			printf("%d\t",map[i][j]);
		printf("\n");
	}
	return 0;
}

输出效果为：

//本来要和邻接表一起讲的但是我最近头有点凉，让我缓缓……

归并排序

Thu, 10 Oct 2019 21:01:03 +0800

归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序是一种稳定的排序方法。//取自百度百科

思想：分组：将无序的序列从中间分割成两组，直到每组数都只有一个或者两个数。如果一组数只有一个数字，不用进行处理；如果一组数有两个数字，将它们排序。也就是说分组环节会出现三种情况，一组数超过两个数（继续分组）、一组数有两个数（排序）、一组数只有一个数（不用处理）。合并：将这些数每两组每两组合并起来，直到全部合成一组。也就是分组，排序，合并。

代码实现如下由于采用递归，第六、七行代码执行完后对应的组已经排好序，因此直接合并两组即可。

void MergeSort(int a[],int left,int right)//归并排序 
{
	if(left<right-1)//如果该组数字个数大于2 
	{ 
		int mid=(left+right)/2;
		MergeSort(a,left,mid);
		MergeSort(a,mid+1,right);//分割 
		Merge(a,left,right,mid);//合并 
	}
	else if(left==right-1)//如果该组数字个数等于2 
	{
		if(a[left]>a[right])//如果前一个数字比后一个数字大，交换 
		{
			int z=a[left];
			a[left]=a[right];
			a[right]=z;
		}
	}
	//如果该组数字只剩一个，不用处理 
}

合并操作举个例子这里有两个被分割开的组 3 4 9 8 和 2 5 1 经过递归和排序以后它们变成了 3 4 8 9 和 1 2 5 用两个数one和two分别指向第一组和第二组的第一个数也就是one指向3，two指向1

  3 4 8 9          1 2 5
  ↑                ↑
 one              two

对比one和two所指的数的大小，将小的那个数排下来此处是two所指比较小，所以将two所指的1移下来，并将two右移以此类推

  3 4 8 9          1 2 5
  ↑                  ↑
 one                two
 1

  3 4 8 9          1 2 5
  ↑                    ↑
 one                  two
 1 2

  3 4 8 9          1 2 5
    ↑                  ↑
   one                two
 1 2 3

  3 4 8 9          1 2 5
      ↑                ↑
     one              two
 1 2 3 4

  3 4 8 9          1 2 5
      ↑                 ↑
     one               two
 1 2 3 4 5

此时第二个数组的数已经全部排下去而第一个数组却还有剩余由于剩余的数有序且必定比此时排在下面的最大的数要大因此直接把剩余的数全部排下去即可

  3 4 8 9          1 2 5
         ↑               ↑
        one             two
 1 2 3 4 5 8 9

合并的代码如下

void Merge(int a[],int left,int right,int mid)//合并两组数字 
{
	int j,i=0;//循环，计数用 
	int one=left;
	int two=mid+1;//one two分别指向第一 第二组数的第一个数字 
	int temp[right-left+1];//用来存排序数的临时数组，长度为两组数字个数总和 
	while(one<=mid&&two<=right)//当两组数字都未全部移入临时数组 
	{
		if(a[one]>a[two])//如果one所指数大于two所指的数 
			temp[i++]=a[two++];//将two所指的数移入临时数组，two右移 
		else
			temp[i++]=a[one++];
	} 
	while(one<=mid)//当第一个数组中还有数未移入临时数组 
		temp[i++]=a[one++];
	while(two<=right) 
		temp[i++]=a[two++];
	i=0;
	for(j=left;j<=right;j++)//将临时数组的数移入原数组 
		a[j]=temp[i++];
}

以下是全部代码

#include <stdio.h>
void Merge(int a[],int left,int right,int mid)//合并两组数字 
{
	int j,i=0;//循环，计数用 
	int one=left;
	int two=mid+1;//one two分别指向第一 第二组数的第一个数字 
	int temp[right-left+1];//用来存排序数的临时数组，长度为两组数字个数总和 
	while(one<=mid&&two<=right)//当两组数字都未全部移入临时数组 
	{
		if(a[one]>a[two])//如果one所指数大于two所指的数 
			temp[i++]=a[two++];//将two所指的数移入临时数组，two右移 
		else
			temp[i++]=a[one++];
	} 
	while(one<=mid)//当第一个数组中还有数未移入临时数组 
		temp[i++]=a[one++];
	while(two<=right) 
		temp[i++]=a[two++];
	i=0;
	for(j=left;j<=right;j++)//将临时数组的数移入原数组 
		a[j]=temp[i++];
} 

void MergeSort(int a[],int left,int right)//归并排序 
{
	if(left<right-1)//如果该组数字个数大于2 
	{ 
		int mid=(left+right)/2;
		MergeSort(a,left,mid);
		MergeSort(a,mid+1,right);//分割 
		Merge(a,left,right,mid);//合并 
	}
	else if(left==right-1)//如果该组数字个数等于2 
	{
		if(a[left]>a[right])//如果前一个数字比后一个数字大，交换 
		{
			int z=a[left];
			a[left]=a[right];
			a[right]=z;
		}
	}
	//如果该组数字只剩一个，不用处理 
} 

int main()
{
	int n;//序列长度/数的个数
	int i;//循环用 
	while(~scanf("%d",&n))
	{
		if(n==0)
			break;//输入0退出
		int a[n];
		for(i=0;i<n;i++)
			scanf("%d",&a[i]);//输入序列
		MergeSort(a,0,n-1);//归并排序 
		for(i=0;i<n;i++)//输出排序后序列 
			printf("%d ",a[i]);
		printf("\n"); 
	} 
	return 0;
}

//经过大佬的指点我做了一点修改分组的那一块，可以分两种情况：只剩一个数和大于一个数在合并的时候排序，这样就少了一种情况，代码也短一点修改后：

void MergeSort(int a[],int left,int right)//归并排序 
{
	if(left<right)//如果该组数字个数大于1
	{ 
		int mid=(left+right)/2;
		MergeSort(a,left,mid);
		MergeSort(a,mid+1,right);//分割 
		Merge(a,left,right,mid);//合并 
	}
	//如果该组数字只剩一个，不用处理 
}

笔记 on 鸽巢

html table合并单元格同时合并行列的方法

只合并一行的单元格/只合并一列单元格的一般情况

同时合并行列的情况

同时合并行列单元格时出现的单元格显示比例异常问题及解决方案

问题描述

解决方案

博弈论-第二章 基本假设

博弈基于人的理性

不同的参照 不同的选择

让贵的显得不那么贵

锚定效应

多让别人做选择题，而不是判断题

罗森塞蜈蚣博弈中的理性人

合作信号的作用

共同知识

博弈论-第一章 概述

何为博弈：

一个简单的数字游戏：

罗森塞蜈蚣博弈

又一个简单的数字游戏

选对市场（对手）比选对策略更重要

学习博弈论的收益

一些模型

术语解释

博弈的分类

编写测试用例的方法（1）——等价类划分法和边界值分析法

等价类划分法：

什么是等价类？

举个例子

边界值分析法：

软件测试的基本概念

软件产品质量的特性：

软件测试的分类:

按测试层次划分：

按被测试对象划分：

按测试目的划分：

根据程序是否运行划分：

根据是否主动发送请求划分：

根据是否知道程序内部划分：

软件测试的级别：

深度优先搜索（DFS）和广度优先搜索（BFS）

深度优先搜索（DFS）

代码实现

广度优先搜索（BFS）

代码实现

树状数组

树状数组

Lowbit函数

修改数列元素An的函数Update

获得数列A1…An和的函数Getsum

图的邻接矩阵

图的邻接矩阵和邻接表

1.邻接矩阵

归并排序

归并排序

博弈论-第二章基本假设

不同的参照不同的选择

博弈论-第一章概述