博弈算法

Ⅰ 计算博弈理论改变着谁的思考方式

计算思维
一．计算思维的定义
计算思维是运用计算机科学的基础概念进行问题求解、系统设计、以及人类行为理解等涵盖计算机科学之广度的一系列思维活动。
进一步地定义为：
1．通过约简、嵌入、转化和仿真等方法，把一个看来困难的问题重新阐释成一个我们知道问题怎样解决的方法；
2．是一种递归思维，是一种并行处理，是一种把代码译成数据又能把数据译成代码，是一种多维分析推广的类型检查方法；
3．是一种采用抽象和分解来控制庞杂的任务或进行巨大复杂系统设计的方法，是基于关注分离的方法（S oc方法）；
4．是一种选择合适的方式去陈述一个问题，或对一个问题的相关方面建模使其易于处理的思维方法；
5．是按照预防、保护及通过冗余、容错、纠错的方式，并从最坏情况进行系统恢复的一种思维方法；
6．是利用启发式推理寻求解答，也即在不确定情况下的规划、学习和调度的思维方法；
7．是利用海量数据来加快计算，在时间和空间之间，在处理能力和存储容量之间进行折衷的思维方法。
计算思维吸取了问题解决所采用的一般数学思维方法，现实世界中巨大复杂系统的设计与评估的一般工程思维方法，以及复杂性、智能、心理、人类行为的理解等的一般科学思维方法。
二．计算思维的深层次理解
1．计算思维的优点
计算思维建立在计算过程的能力和限制之上，由人由机器执行。计算方法和模型使我们敢于去处理那些原本无法由个人独立完成的问题求解和系统设计。
2．计算思维的内容
计算思维最根本的内容，即其本质（Essence）是抽象（Abstraction）和自动化（Automation）。计算思维中的抽象完全超越物理的时空观，并完全用符号来表示，其中，数字抽象只是一类特例。与数学和物理科学相比，计算思维中的抽象显得更为丰富，也更为复杂。数学抽象的最大特点是抛开现实事物的物理、化学和生物学等特性，而仅保留其量的关系和空间的形式，而计算思维中的抽象却不仅仅如此。操作模式 计算思维建立在计算过程的能力和限制之上，由人由机器执行。计算方法和模型使我们敢于去处理那些原本无法由任何个人独自完成的问题求解和系统设计。
3．计算思维用途
计算思维是每个人的基本技能，不仅仅属于计算机科学家。我们应当使每个孩子在培养解析能力时不仅掌握阅读、写作和算术（Reading, writing, and arithmetic——3R），还要学会计算思维。正如印刷出版促进了3R的普及，计算和计算机也以类似的正反馈促进了计算思维的传播。
计算思维是运用计算机科学的基础概念去求解问题、设计系统和理解人类的行为。它包括了涵盖计算机科学之广度的一系列思维活动。
当我们必须求解一个特定的问题时，首先会问：解决这个问题有多么困难？怎样才是最佳的解决方法？计算机科学根据坚实的理论基础来准确地回答这些问题。表述问题的难度就是工具的基本能力，必须考虑的因素包括机器的指令系统、资源约束和操作环境。
为了有效地求解一个问题，我们可能要进一步问：一个近似解是否就够了，是否可以利用一下随机化，以及是否允许误报（false positive）和漏报（false negative）。计算思维就是通过约简、嵌入、转化和仿真等方法，把一个看来困难的问题重新阐释成一个我们知道怎样解决的问题。
4．计算思维是一种递归思维
它是并行处理。它是把代码译成数据又把数据译成代码。它是由广义量纲分析进行的类型检查。对于别名或赋予人与物多个名字的做法，它既知道其益处又了解其害处。对于间接寻址和程序调用的方法，它既知道其威力又了解其代价。它评价一个程序时，不仅仅根据其准确性和效率，还有美学的考量，而对于系统的设计，还考虑简洁和优雅。
5．抽象和分解
来迎接庞杂的任务或者设计巨大复杂的系统。它是关注的分离（SOC方法）。它是选择合适的方式去陈述一个问题，或者是选择合适的方式对一个问题的相关方面建模使其易于处理。它是利用不变量简明扼要且表述性地刻画系统的行为。它使我们在不必理解每一个细节的情况下就能够安全地使用、调整和影响一个大型复杂系统的信息。它就是为预期的未来应用而进行的预取和缓存。计算思维是按照预防、保护及通过冗余、容错、纠错的方式从最坏情形恢复的一种思维。它称堵塞为“死锁”，称约定为“界面”。计算思维就是学习在同步相互会合时如何避免“竞争条件”（亦称“竞态条件”）的情形。计算思维利用启发式推理来寻求解答，就是在不确定情况下的规划、学习和调度。它就是搜索、搜索、再搜索，结果是一系列的网页，一个赢得游戏的策略，或者一个反例。计算思维利用海量数据来加快计算，在时间和空间之间，在处理能力和存储容量之间进行权衡。
计算思维将渗透到我们每个人的生活之中，到那时诸如算法和前提条件这些词汇将成为每个人日常语言的一部分，对“非确定论”和“垃圾收集”这些词的理解会和计算机科学里的含义驱近，而树已常常被倒过来画了。
6．计算思维在其他学科中的影响
例如，机器学习已经改变了统计学。就数学尺度和维数而言，统计学习用于各类问题的规模仅在几年前还是不可想象的。各种组织的统计部门都聘请了计算机科学家。计算机学院（系）正在与已有或新开设的统计学系联姻。
计算机学家们对生物科学越来越感兴趣，因为他们坚信生物学家能够从计算思维中获益。计算机科学对生物学的贡献决不限于其能够在海量序列数据中搜索寻找模式规律的本领。最终希望是数据结构和算法（我们自身的计算抽象和方法）能够以其体现自身功能的方式来表示蛋白质的结构。计算生物学正在改变着生物学家的思考方式。类似地，计算博弈理论正改变着经济学家的思考方式，纳米计算改变着化学家的思考方式，量子计算改变着物理学家的思考方式。
这种思维将成为每一个人的技能组合成分，而不仅仅限于科学家。普适计算之于今天就如计算思维之于明天。普适计算是已成为今日现实的昨日之梦，而计算思维就是明日现实。
计算机科学是计算的学问——什么是可计算的，怎样去计算。计算机科学不是计算机编程。像计算机科学家那样去思维意味着远不止能为计算机编程，还要求能够在抽象的多个层次上思维。
7．计算思维是根本的，不是刻板的技能
根本技能是每一个人为了在现代社会中发挥职能所必须掌握的。刻板技能意味着机械的重复。具有讽刺意味的是，当计算机像人类一样思考之后，思维可就真的变成机械的了。
8．计算思维是人的，不是计算机的思维方式
计算思维是人类求解问题的一条途径，但决非要使人类像计算机那样地思考。计算机枯燥且沉闷，人类聪颖且富有想象力。是人类赋予计算机激情。配置了计算设备，我们就能用自己的智慧去解决那些在计算时代之前不敢尝试的问题，实现“只有想不到，没有做不到”的境界。
9．计算思维是数学和工程思维的互补与融合
计算机科学在本质上源自数学思维，因为像所有的科学一样，其形式化基础建筑于数学之上。计算机科学又从本质上源自工程思维，因为我们建造的是能够与实际世界互动的系统，基本计算设备的限制迫使计算机学家必须计算性地思考，不能只是数学性地思考。构建虚拟世界的自由使我们能够设计超越物理世界的各种系统。

Ⅱ 博弈算法里的剪枝怎么用（具体的）

极大极小过程，以及阿尔法-贝塔剪纸。极小极大搜索方法是博弈树搜索的基本方法，现在博弈树搜索中最常用的α-β剪枝搜索方法，就是从这一方法发展而来的。
首先假定，有一个评价函数可以对所有的棋局进行评估。当评价函数值大于0时，表示棋局对我方有利，对对方不利。当评价函数小于0时，表示棋局对我方不利，对对方有利。而评价函数值越大，表示对我方越有利。当评价函数值等于正无穷大时，表示我方必胜。评价函数值越小，表示对我方越不利。当评价函数值等于负无穷大时，表示对方必胜。假设双方都是对弈高手，在只看一步棋的情况下，我方一定走评价函数值最大的一步棋，而对方一定走评价函数值最小的一步棋。会下棋的读者都知道，在只看一步的情况下最好的棋，从全局来说不一定就好，还可能很不好。因此为了走出好棋，必须多看几步，从多种可能状态中选择一步好棋。
想一想人是如何下棋的呢？人实际上采用的是一种试探性的方法。首先假定走了一步棋，看对方会有那些应法，然后再根据对方的每一种应法，看我方是否有好的回应......这一过程一直进行下去，直到若干步以后，找到了一个满意的走法为止。初学者可能只能看一、两个轮次，而高手则可以看几个，甚至十几个轮次。
极小极大搜索方法，模拟的就是人的这样一种思维过程。当轮到我方走棋时，首先按照一定的搜索深度生成出给定深度d以内的所有状态，计算所有叶节点的评价函数值。然后从d-1层节点开始逆向计算：对于我方要走的节点（用MAX标记，称为极大节点）取其子节点中的最大值为该节点的值（因为我方总是选择对我方有利的棋）；对于对方要走的节点（用MIN标记，称为极小节点）取其子节点中的最小值为该节点的值（对方总是选择对我方不利的棋）。一直到计算出根节点的值为止。获得根节点取值的那一分枝，即为所选择的最佳走步。
在图3.5所示的例子中，假定搜索深度为2，D～J是7个叶节点，在它们下边括号中的数字是这些节点的评价函数值（假定可以计算得到）。A、B、C是三个极小节点，它们分别取各自子节点最小值为自己的值，得到三个节点的值分别为-6、-2和-4。s是极大节点，从A、B、C三个节点的值中取最大值，得到-2。由于-2来自于节点B，所以搜索的结果是应选择B作为我方的走步。对于我方来说，-2并不是一个好的结果，但却是在对方不犯错误的情况下，对我方最有利的结果。因为从图中可以看出，如果选择A为我方的走步，如果对方回应D的话，我方可以得到评价值9，固然对我方有利。但是如果对方是一个高手的话，他一定回选择E，而不是D。在这种情况下，我方只能得到-6，结果岂不是更差。因此，极小极大过程是一种假定对手每次回应都正确的情况下，如何从中找出对我方最有利的走步的搜索方法。
值得注意的是，不管设定的搜索深度是多少层，经过一次搜索以后，只决定了我方一步棋的走法。等到对方回应一步棋之后，需要在新的棋局下重新进行搜索，来决定下一步棋如何走。极小极大搜索策略是考虑双方对弈若干步之后，从可能的走步中选一步相对好棋的着法来走，即在有限的搜索深度范围内进行求解。为此要定义一个静态估计函数f，以便对棋局的势态（节点）作出优劣估值，这个函数可根据势态优劣特征来定义（主要用于对端节点的"价值"进行度量）。一般规定有利于MAX的势态，f（p）取正值，有利于MIN的势态，f（p）取负值，势均力敌的势态，f（p）取0值。若f（p）＝＋∞，则表示MAX赢，若f（p）＝－∞，则表示MIN赢。下面的讨论规定：顶节点深度d＝0，MAX代表程序方，MIN代表对手方，MAX先走。
图3.5是一个表示考虑两步棋的例子，图中端节点给出的数字是用静态函数f（p）计算得到，其他节点不用f（p）估计，因为不够精确，而应用倒推的办法取值。例如A、B、C是MIN走步的节点，MAX应考虑最坏的情况，故其估值应分别取其子节点f（p）估值中最小者，而s是MAX走步的节点，可考虑最好的情况，故估值应取A、B、C值中的最大者。这样求得f（s）＝－2，依此确定了相对较优的走步应是走向B，因为从B出发，对手不可能产生比f（s）＝－2更差的效果。实际上可根据资源条件，考虑更多层次的搜索过程，从而可得到更准确的倒推值，供MAX选取更正确的走步。当用端节点的静态估计函数f（p）求倒推值时，两位选手应采取不同的策略，从下往上逐层交替使用极小和极大的选值方法，故称极小极大过程。

Ⅲ 高层博弈是什么意思

博弈圣经着作人在《概言》中描述的博弈
竞争就是博弈，博弈是经济学。
经济学是自私的学说，使人的行为私下勾结，在理性地尊重事物之后，便腐蚀家庭和所有人的行为，所以，一直被人咒骂。
经济学是掠夺和救济的游戏，两对手之间主导着人类的不同行为价值，不管你是否愿意要，一定会得到前所未有的那一部分。
经济学是一个二特性竞争结构，也是人与自然的博弈进程。里面的非物质文化思想，它的美妙之处在于大自然可以分开为每一个人单独运行，又不会产生竞争性，它可以一次次地重复使用而不会降低效用。
这是一个无声的世界，可以感知、可以思想，不能触摸，诱发创造。假如这个与竞争基本对立的文化思想能被所有的人接受，它将会繁荣整个世界。
摘自《博弈圣经》概言

《博弈圣经》里《博弈文化盛宴》一文中说:“领导人的行为一半是道德,一半是博弈。博弈是决策优先,道德是对抗默认。超智慧的领导人知道多少忍让,又何时竞争...

博弈圣经着作人给出了领导的定义；我们把指向‘私湍’或指向“实体”权威的信息，看成领导。

优先预测悲剧后作出的忍让是道德.摘自“博弈文化盛宴”
优先预测胜利前作出的竞争是博弈.摘自“博弈文化盛宴”
竞争与忍让基本对立,博弈与道德基本对立.赢在博弈,就缺失道德,赢得道德,就缺少博弈.摘自“博弈文化盛宴”

《博弈圣经》中《人类未知的蓝色档案》一文中写道：“谁能让现代的博弈行为接近野蛮，谁能让友善与凶残之间的距离大到令人不解，谁就在博弈中取胜。”

《博弈圣经》中《人类未知的蓝色档案》一文中写道：赢的定义；赢不是大小、不是多少、不是均衡平衡、不是战略战术，而是在未来国正论的随机状态中，一粒期望的粒子优先达成。

赢也不是福，输也不是罪，输赢与均衡属于第三空地论的内容。

博弈圣经着作人的经典文段；
战略是大自然的计谋，它是所有事件的总括。战略是一个博弈体系，它与战术对应着。
《博弈圣经》上说：
战略是寻找连续正理、科学的文明实体。
战术是达成局部真理、文明的文化性质。
战略的六法则：寻找、连续、正理、科学、文明、实体。
战术的六性质：达成、局部、真理、文明、文化、性质。
战略的六法则对应战术的六性质：
寻找—达成、连续—局部、正理—真理、科学—文明、文明—文化、实体—性质。
战略体系中的每一项内容都可构成战略和战术的元素。
战略和战术是用国正论非绝对对立性，区分出了哪是实体、哪是性质。战略的唯一性不可复制，无限宽广，又有万能的理性。战略不会直接呈现在大脑中，它是通过对博弈实体的区分，才给出计划、判断、执行的种种行为的观念。其实，一切输赢、大小、多少、好坏的选择，一切欲望的达成，以及一切真理的实现都是一种区分。
《博弈圣经》上说：“战略的定义范式是检验国家战略、军事战略、经济战略、企业战略的模块，这是领导人博弈对抗战胜对手的六法则，可以检验出战略策略的缺陷，也可以检验战略家的能力，罪犯创造的罪恶只包含在战术中。战术的六性质是对创新结果的挑战。
如果没有国正论的非绝对对立的哲学，怎么解释战略和战术的关系、上级和下级的关系、中央和地方的关系、国家和人民的关系？在博弈实体里，一个人与博弈实体的关系是相伴相生的。《博弈圣经》上说：“实体一元论在数目上的同一性，发生的因果次序不属于个人的部分本性，这种属性是实体的性质。”这种复杂的实体关系用矛盾论解释不了。矛盾论看似沿着一条无懈可击的路走下去，最后却出现了包容，出现了悖论。所谓矛盾论的主要矛盾和次要矛盾的思维方式，根本无法应付未来博弈实体中的一切经济问题。
“战略的特征是发现智谋的纲领，战术的特征是创造实在的行为。

《博弈圣经》战略的定义：战略是寻找连续正理、科学的文明实体。
《博弈圣经》战术的定义：战术是达成局部真理、文明的文化性质。

Ⅳ 非完全信息博弈，有什么经典的算法

参见张维迎的博弈论与信息经济学

Ⅳ 关于C#博弈树算法

首先，C#可以实现任何C++可以实现的算法。我不想讨论关于博弈树的问题，因为对于初学者来说，学习较常见的算法和数据结构，对学习语言和算法本身都有益。学习编程不能好高骛远，如果对算法本身很了解，又有C#基础，不愁写不出来。

Ⅵ 博弈算法会什么要考虑对方走最差

如果是两台计算机博弈的话，那么都是程序计算得出的走子策略，既然是程序那么对方就有可能走出当前局面下最差的棋；即便是人与计算机博弈，那么受到各方面因素的影响，人也有可能走出最差的棋，但概率极小。

Ⅶ c语言 五子棋 博弈树算法 叶子节点的分值是如何计算的

其实这个不是难点的，那个分数是当前落子后所形成的以这个棋子为中心的9x9矩阵中所形成的棋型，计算其他地方的棋型显然没有什么意义，再有就是不是C语言才可以写算法的，对于极大极小原理，博弈树和alpha-beta剪枝算法都是基于这个原理的，如果你是刚学编程不久，而且没有数据结构的基础是写不出来运用博弈树算法的五子棋的，先把基础打好再说。。

Ⅷ 谢谢，各位大神啊~~简述博弈论与最优化理论的不同之处

我的理解，就经济学来说，博弈论是方法，最优化是方法的方法。博弈论有具体含义，应用于特定情况；最优化作为一个更为根本的分枝，其应用范围更大更广。我的博弈论老师就是数学系研究最优化算法出身，他经常用最优化里面的方法来求解博弈论。至于重复博弈中的“收敛到均衡点”与最优化方法中的“收敛到最优解”的关系，我理解，使前者达到均衡点的“策略”类比于使后者达到最优解的“算法”，并且都可能不是唯一的。

Ⅸ c语言的五子棋代码（博弈算法）

#include<stdio.h>
#include<bios.h>
#include<ctype.h>
#include<conio.h>
#include<dos.h>
#defineCROSSRU0xbf/*右上角点*/
#defineCROSSLU0xda/*左上角点*/
#defineCROSSLD0xc0/*左下角点*/
#defineCROSSRD0xd9/*右下角点*/
#defineCROSSL0xc3/*左边*/
#defineCROSSR0xb4/*右边*/
#defineCROSSU0xc2/*上边*/
#defineCROSSD0xc1/*下边*/
#defineCROSS0xc5/*十字交叉点*/

/*定义棋盘左上角点在屏幕上的位置*/
#defineMAPXOFT5
#defineMAPYOFT2

/*定义1号玩家的操作键键码*/
#definePLAY1UP0x1157/*上移--'W'*/
#definePLAY1DOWN0x1f53/*下移--'S'*/
#definePLAY1LEFT0x1e41/*左移--'A'*/
#definePLAY1RIGHT0x2044/*右移--'D'*/
#definePLAY1DO0x3920/*落子--空格键*/

/*定义2号玩家的操作键键码*/
#definePLAY2UP0x4800/*上移--方向键up*/
#definePLAY2DOWN0x5000/*下移--方向键down*/
#definePLAY2LEFT0x4b00/*左移--方向键left*/
#definePLAY2RIGHT0x4d00/*右移--方向键right*/
#definePLAY2DO0x1c0d/*落子--回车键Enter*/

/*若想在游戏中途退出,可按Esc键*/
#defineESCAPE0x011b

/*定义棋盘上交叉点的状态,即该点有无棋子*/
/*若有棋子,还应能指出是哪个玩家的棋子*/
#defineCHESSNULL0/*没有棋子*/
#defineCHESS1'O'/*一号玩家的棋子*/
#defineCHESS2'X'/*二号玩家的棋子*/

/*定义按键类别*/
#defineKEYEX99v0/*退出键*/
#defineKEYFALLCHESS1/*落子键*/
#defineKEYMOVECURSOR2/*光标移动键*/
#defineKEYINVALID3/*无效键*/

/*定义符号常量:真,假---真为1,假为0*/
#defineTRUE1
#defineFALSE0

/**********************************************************/
/*定义数据结构*/

/*棋盘交叉点坐标的数据结构*/
structpoint
{
intx,y;
};


或者下面这个：
#include<graphics.h>
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#defineN15
#defineB7
#defineSTOP-10000
#defineOK1
#defineNO0
#defineUP328
#defineDOWN336
#defineLEFT331
#defineRIGHT333

inta[N+1][N+1];
intzx,zy;
intwrite=1,biaoji=0;
structzn{
longsum;

inty;

intx;

}w[N+1][N+1],max,max1;


voidcbar(inti,intx,inty,intr);
voidmap(inta[][]);
intgetkey();
intkey();
voidzuobiao(intx,inty,inti);
inttu(inta[][],intwrite);
intwtu(inta[][],intwrite);
intneng(inta[][]);
intzh5(inty,intx,inta[][]);
longzzh5(intb[][],inti);
main()
{
inti,j;
intgdriver=DETECT;
intgmode;
initgraph(&gdriver,&gmode,"");
zx=(N+1)/2;
zy=(N+1)/2;
for(i=1;i<=N;i++)
for(j=1;j<=N;j++)
a[i][j]=0;
map(a);
i=1;
while(i)
{
intk,n;
k=wtu(a,write);
if(k==STOP)gotoend;
map(a);
n=neng(a);
if(n==STOP)gotoend;
map(a);
}
end:
;
}


intneng(inta[N+1][N+1])

{
inti,j;
intk;
max.sum=-1;

for(i=0;i<=N;i++)
for(j=0;j<+N;j++)

{
w[i][j].sum=0;
w[i][j].x=i;
w[i][j].y=j;
}
for(i=1;i<=N-4;i++)
for(j=1;j<=N-4;j++)
{
k=zh5(i,j,a);
if(k==STOP)return(STOP);
}

for(i=1;i<=N;i++)
for(j=1;j<=N;j++)
{

if(max.sum<w[i][j].sum)
{

max.sum=w[i][j].sum;
max.y=i;
max.x=j;
}

elseif(max.sum==w[i][j].sum)
{

if(((max.y-zy)*(max.y-zy)+(max.x-zx)*(max.x-zx))>((i-zy)*(i-zy)+(j-zx)*(j-zx)))
max.sum=w[i][j].sum;
max.y=i;
max.x=j;
}
}
if(a[max.y][max.x]==0)

{
a[max.y][max.x]=-1;
zy=max.y;
zx=max.x;
}

}


intzh5(inty,intx,inta[N+1][N+1])
{

inti,j;
intb[6][6];
longc[13];

longd[6][6];
longtemp;
for(i=y;i<=y+4;i++)
for(j=x;j<=x+4;j++)
b[i+1-y][j+1-x]=a[i][j];
c[1]=b[1][1]+b[1][2]+b[1][3]+b[1][4]+b[1][5];
c[2]=b[2][1]+b[2][2]+b[2][3]+b[2][4]+b[2][5];
c[3]=b[3][1]+b[3][2]+b[3][3]+b[3][4]+b[3][5];
c[4]=b[4][1]+b[4][2]+b[4][3]+b[4][4]+b[4][5];
c[5]=b[5][1]+b[5][2]+b[5][3]+b[5][4]+b[5][5];
c[6]=b[1][1]+b[2][1]+b[3][1]+b[4][1]+b[5][1];
c[7]=b[1][2]+b[2][2]+b[3][2]+b[4][2]+b[5][2];
c[8]=b[1][3]+b[2][3]+b[3][3]+b[4][3]+b[5][3];
c[9]=b[1][4]+b[2][4]+b[3][4]+b[4][4]+b[5][4];
c[10]=b[1][5]+b[2][5]+b[3][5]+b[4][5]+b[5][5];
c[11]=b[1][1]+b[2][2]+b[3][3]+b[4][4]+b[5][5];
c[12]=b[1][5]+b[2][4]+b[3][3]+b[4][2]+b[5][1];


for(i=1;i<=12;i++)
{
switch(c[i])

{

case5:biaoji=1;return(STOP);

case-5:biaoji=-1;return(STOP);

case-4:c[i]=100000;break;

case4:c[i]=100000;break;

case-3:c[i]=150;break;

case3:c[i]=150;break;

case-2:c[i]=120;break;

case2:c[i]=100;break;

case-1:c[i]=1;break;

case1:c[i]=1;break;

default:c[i]=0;

}

}

for(i=1;i<=12;i++)

{

if(c[i]==150)

c[i]+=zzh5(b,i);

}

for(i=1;i<=5;i++)

for(j=1;j<=5;j++)

d[i][j]=0;

for(i=1;i<=5;i++)

for(j=1;j<=5;j++)

{

if(i==j)d[i][j]+=c[11];

if((i+j)==6)d[i][j]+=c[12];

d[i][j]+=c[i]+c[j+5];

}

for(i=1;i<=5;i++)

for(j=1;j<=5;j++)

{

if(b[i][j]!=0)

d[i][j]=-2;

}

max1.sum=-1;

max1.y=0;

max1.x=0;

for(i=1;i<=5;i++)

for(j=1;j<=5;j++)

{

if(max1.sum<d[i][j])

{

max1.sum=d[i][j];

max1.y=i;

max1.x=j;

w[i+y-1][j+x-1].sum+=max1.sum;

}

elseif(max1.sum==d[i][j])

{

if(((i+y-1-zy)*(i+y-1-zy)+(j+x-1-zx)*(j+x-1-zx))>((max1.y+y-1-zy)*(max1.y+y-1-zy)+(max1.x+x-1-zx)*(max1.x+x-1-zx)))

{

max1.sum=d[i][j];

max1.y=i;

max1.x=j;

}

}

}

}

longzzh5(intb[6][6],intn)

{

inti,j,k,l,m;

switch(n)

{

case1:i=b[1][1];j=b[1][2];k=b[1][3];l=b[1][4];m=b[1][5];break;

case2:i=b[2][1];j=b[2][2];k=b[2][3];l=b[2][4];m=b[2][5];break;

case3:i=b[3][1];j=b[3][2];k=b[3][3];l=b[3][4];m=b[3][5];break;

case4:i=b[4][1];j=b[4][2];k=b[4][3];l=b[4][4];m=b[4][5];break;

case5:i=b[5][1];j=b[5][2];k=b[5][3];l=b[5][4];m=b[5][5];break;

case6:i=b[1][1];j=b[2][1];k=b[3][1];l=b[4][1];m=b[5][1];break;

case7:i=b[1][2];j=b[2][2];k=b[3][2];l=b[4][2];m=b[5][2];break;

case8:i=b[1][3];j=b[2][3];k=b[3][3];l=b[4][3];m=b[5][3];break;

case9:i=b[1][4];j=b[2][4];k=b[3][4];l=b[4][4];m=b[5][4];break;

case10:i=b[1][5];j=b[2][5];k=b[3][5];l=b[4][5];m=b[5][5];break;

case11:i=b[1][1];j=b[2][2];k=b[3][3];l=b[4][4];m=b[5][5];break;

case12:i=b[1][5];j=b[2][4];k=b[3][3];l=b[4][2];m=b[5][1];break;

}

if((i==0&&j==1&&k==1&&l==1&&m==0))

return(900);

if((i==0&&j==-1&&k==-1&&l==-1&&m==0))

return(1000);

if((i==0&&j==0&&k==1&&l==1&&m==1)||(i==1&&j==1&&k==1&&l==0&&m==0))

return(20);

if((i==0&&j==0&&k==-1&&l==-1&&m==-1)||(i==-1&&j==-1&&k==-1&&l==0&&m==0))

return(20);

if((i==-1&&j==1&&k==1&&l==1&&m==1)||(i==1&&j==-1&&k==1&&l==1&&m==1)||(i==1&&j==1&&k==-1&&l==1&&m==1)||(i==1&&j==1&&k==1&&l==-1&&m==1)||(i==1&&j==1&&k==1&&l==1&&m==-1))

return(-60);

if((i==1&&j==-1&&k==-1&&l==-1&&m==-1)||(i==-1&&j==1&&k==-1&&l==-1&&m==-1)||(i==-1&&j==1&&k==-1&&l==-1&&m==-1)||(i==-1&&j==-1&&k==-1&&l==1&&m==-1)||(i==-1&&j==-1&&k==-1&&l==-1&&m==1))

return(-60);

}


intwtu(inta[N+1][N+1],intwrite)

{

inti=1;

map(a);

zuobiao(zx,zy,1);

while(i)

{

intk;

k=tu(a,write);

if(k==OK)i=0;

if(k==STOP)return(STOP);

}

}


intgetkey()

{

intkey,lo,hi;

key=bioskey(0);

lo=key&0x00ff;

hi=(key&0xff00)>>8;

return((lo==0)?hi+256:lo);

}


intkey()

{

intk;

k=getkey();

switch(k)

{

case27:return(STOP);

case13:

case'':return(OK);

case328:return(UP);

case336:return(DOWN);

case331:return(LEFT);

case333:return(RIGHT);

default:return(NO);

}

}


voidzuobiao(intx,inty,inti)

{

intr;

if(i!=0)

{

setcolor(GREEN);

for(r=1;r<=5;r++)

circle(75+25*x,25+25*y,r);


}

else

{

if(a[zy][zx]==1)

{

setcolor(8);

for(r=1;r<=5;r++)

circle(75+25*x,25+25*y,r);

}

elseif(a[zy][zx]==-1)

{

setcolor(WHITE);

for(r=1;r<=5;r++)

circle(75+25*x,25+25*y,r);

}

else

{

setcolor(B);

for(r=1;r<=5;r++)

circle(75+25*x,25+25*y,r);

setcolor(RED);line(75+25*zx-5,25+25*zy,75+25*x+5,25+25*zy);

line(75+25*zx,25+25*zy-5,75+25*zx,25+25*zy+5);

}

}

}


inttu(inta[N+1][N+1],intwrite)

{

intk;

re:

k=key();

if(k==OK)

{

if(a[zy][zx]==0)

{

a[zy][zx]=write;

}

else

gotore;

}

if(k==STOP)return(STOP);

if(k==NO)gotore;

if(k==UP)

{

inti,j;

if(zy==1)j=zy;

elsej=zy-1;

zuobiao(zx,zy,0);

zuobiao(zx,j,1);

zy=j;

gotore;

}

if(k==DOWN)

{

inti,j;

if(zy==N)j=zy;

elsej=zy+1;

zuobiao(zx,zy,0);

zuobiao(zx,j,1);

zy=j;

gotore;

}

if(k==LEFT)

{

inti,j;

if(zx==1)i=zx;

elsei=zx-1;

zuobiao(zx,zy,0);

zuobiao(i,zy,1);

zx=i;

gotore;

}

if(k==RIGHT)

{

inti,j;

if(zx==N)i=zx;

elsei=zx+1;

zuobiao(zx,zy,0);

zuobiao(i,zy,1);

zx=i;

gotore;

}

}


voidcbar(inti,intx,inty,intr)

{

if(i!=0)

{

if(i==1)

setcolor(8);

elseif(i==-1)

setcolor(WHITE);

for(i=1;i<=r;i++)

{

circle(x,y,i);

}

}

}


voidmap(inta[N+1][N+1])

{

inti,j;

cleardevice();

setbkcolor(B);

setcolor(RED);

for(i=0;i<N;i++)

{

line(100,50+25*i,75+N*25,50+25*i);

line(100+25*i,50,100+25*i,25+N*25);

}

for(i=1;i<=N;i++)

for(j=1;j<=N;j++)

cbar(a[i][j],75+25*j,25+25*i,10);

}