技术标签： js
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>五子棋</title>
<style type="text/css">
canvas {
display: block;
margin: 50px auto;
box-shadow: -2px -2px 2px #EFEFEF, 5px 5px 5px #B9B9B9;
cursor: pointer;
}
.btn-wrap {
display: flex;
flex-direction: row;
justify-content: center;
}
.btn-wrap div {
margin: 0 10px;
}
div>span {
display: inline-block;
padding: 10px 20px;
color: #FFFFFF;
background-color: #EE82EE;
border-radius: 5px;
cursor: pointer;
}
div.unable span {
background: #D6D6D4;
color: #ADACAA;
}
#result-wrap {
text-align: center;
}
</style>
</head>
<body>
<h3 id="result-wrap">--益智五子棋--</h3>
<canvas id="chess" width="450px" height="450px"></canvas>
<div id="btn-wrap">
<div id="restart" class="restart">
<span>重新开始</span>
</div>
<div id="goback" class="goback unable">
<span>悔棋</span>
</div>
<div id="return" class="return unable">
<span>撤销悔棋</span>
</div>
</div>
<script type="text/javascript">
var over = false;
var me = true; //我
var _nowi = 0, _nowj = 0; //记录自己下棋的坐标
var _compi = 0, _compj = 0; //记录计算机当前下棋的坐标
var _myWin = [], _compWin = []; //记录我，计算机赢的情况
var backAble = false, returnAble = false;
var resultTxt = document.getElementById("result-wrap");
var chressBord = []; //棋盘
for (var i = 0; i < 15; i++) {
chressBord[i] = [];
for (var j = 0; j < 15; j++) {
chressBord[i][j] = 0;
}
}
//赢法的统计数组
var myWin = [];
var computerWin = [];
//赢法数组
var wins = [];
for (var i = 0; i < 15; i++) {
wins[i] = [];
for (var j = 0; j < 15; j++) {
wins[i][j] = [];
}
}
var count = 0; //赢法总数
//横线赢法
for (var i = 0; i < 15; i++) {
for (var j = 0; j <11; j++) {
for (var k = 0; k < 5; k++) {
wins[i][j+k][count] = true;
}
count++;
}
}
//竖线赢法
for (var i = 0; i < 15; i++) {
for (var j = 0; j <11; j++) {
for (var k = 0; k < 5; k++) {
wins[j+k][i][count] = true;
}
count++;
}
}
//正斜线赢法
for (var i = 0; i < 11; i++) {
for (var j = 0; j <11; j++) {
for (var k = 0; k < 5; k++) {
wins[i+k][j+k][count] = true;
}
count++;
}
}
//反斜线赢法
for (var i = 0; i < 11; i++) {
for (var j = 14; j > 3; j--) {
for (var k = 0; k < 5; k++) {
wins[i+k][j-k][count] = true;
}
count++;
}
}
// debugger;
for (var i = 0; i < count; i++) {
myWin[i] = 0;
_myWin[i] = 0;
computerWin[i] = 0;
_compWin[i] = 0;
}
var chess = document.getElementById("chess");
var context = chess.getContext('2d');
context.strokeStyle = '#bfbfbf'; //边框颜色
var backbtn = document.getElementById("goback");
var returnbtn = document.getElementById("return");
window.onload = function() {
drawChessBoard(); // 画棋盘
}
document.getElementById("restart").onclick = function(){
window.location.reload();
}
// 我，下棋
chess.onclick = function(e){
if(over){
return;
}
if(!me){
return;
}
// 悔棋功能可用
backbtn.className = backbtn.className.replace(new
RegExp("(\\s|^)unable(\\s|$)")," ");
var x = e.offsetX;
var y = e.offsetY;
var i = Math.floor(x / 30);
var j = Math.floor(y / 30);
_nowi = i;
_nowj = j;
if(chressBord[i][j] == 0){
oneStep(i,j,me);
chressBord[i][j] = 1; //我，已占位置
for (var k = 0; k < count; k++) { // 将可能赢的情况都加1
if(wins[i][j][k]){
// debugger;
myWin[k]++;
_compWin[k] = computerWin[k];
computerWin[k] = 6; //这个位置对方不可能赢了
if(myWin[k] == 5){
// window.alert('你赢了');
resultTxt.innerHTML = '恭喜，你赢了！';
over = true;
}
}
}
if(!over){
me = !me;
computerAI();
}
}
}
// 悔棋
backbtn.onclick = function(e){
if(!backAble) { return;}
over = false;
me = true;
// resultTxt.innerHTML = 'o(╯□╰)o，悔棋中';
// 撤销悔棋功能可用
returnbtn.className = returnbtn.className.replace( new
RegExp("(\\s|^)unable(\\s|$)")," ");
// 我，悔
chressBord[_nowi][_nowj] = 0; //我，已占位置 还原
minusStep(_nowi, _nowj); //销毁棋子
for (var k = 0; k < count; k++) { // 将可能赢的情况都减1
if(wins[_nowi][_nowj][k]){
myWin[k]--;
computerWin[k] = _compWin[k]; //这个位置对方可能赢
}
}
// 计算机相应的悔棋
chressBord[_compi][_compj] = 0; //计算机，已占位置 还原
minusStep(_compi, _compj);//销毁棋子
for (var k = 0; k < count; k++) {// 将可能赢的情况都减1
if(wins[_compi][_compj][k]){
computerWin[k]--;
myWin[k] = _myWin[i];//这个位置对方可能赢
}
}
resultTxt.innerHTML = '--益智五子棋--';
returnAble = true;
backAble = false;
}
// 撤销悔棋
returnbtn.onclick = function(e){
if(!returnAble){ return;}
// 我，撤销悔棋
chressBord[_nowi][_nowj] = 1;//我，已占位置
oneStep(_nowi,_nowj,me);
for (var k = 0; k < count; k++) {
if(wins[_nowi][_nowj][k]){
myWin[k]++;
_compWin[k] = computerWin[k];
computerWin[k] = 6;//这个位置对方不可能赢
}
if(myWin[k] == 5){
resultTxt.innerHTML = '恭喜，你赢了！';
over = true;
}
}
// 计算机撤销相应的悔棋
chressBord[_compi][_compj] = 2;//计算机，已占位置
oneStep(_compi,_compj,false);
for (var k = 0; k < count; k++) {// 将可能赢的情况都减1
if(wins[_compi][_compj][k]){
computerWin[k]++;
_myWin[k] = myWin[k];
myWin[k] = 6;//这个位置对方不可能赢
}
if(computerWin[k] == 5){
resultTxt.innerHTML = 'o(╯□╰)o，计算机赢了，继续加油哦！';
over = true;
}
}
returnbtn.className += '' + 'unable';
returnAble = false;
backAble = true;
}
// 计算机下棋
var computerAI = function(){
var myScore = [];
var computerScore = [];
var max = 0;
var u =0, v = 0;
for (var i = 0; i < 15; i++) {
myScore[i] = [];
computerScore[i] = [];
for (var j = 0; j < 15; j++) {
myScore[i][j] = 0;
computerScore[i][j] = 0;
}
}
for (var i = 0; i < 15; i++) {
for (var j = 0; j < 15; j++) {
if(chressBord[i][j] == 0){
for (var k = 0; k < count; k++) {
if(wins[i][j][k]){
if(myWin[k] == 1){
myScore[i][j] += 200;
}else if(myWin[k] == 2){
myScore[i][j] += 400;
}
else if(myWin[k] == 3){
myScore[i][j] += 2000;
}
else if(myWin[k] == 4){
myScore[i][j] += 10000;
}
if(computerWin[k] == 1){
computerScore[i][j] += 220;
}else if(computerWin[k] == 2){
computerScore[i][j] += 420;
}
else if(computerWin[k] == 3){
computerScore[i][j] += 2100;
}
else if(computerWin[k] == 4){
computerScore[i][j] += 20000;
}
}
}
if(myScore[i][j] > max){
max = myScore[i][j];
u = i;
v = j;
}else if(myScore[i][j] == max){
if(computerScore[i][j]>computerScore[u][v]){
u = i;
v = j;
}
}
if(computerScore[i][j] > max){
max = computerScore[i][j];
u = i;
v = j;
}else if(computerScore[i][j] == max){
if(myScore[i][j]>myScore[u][v]){
u = i;
v = j;
}
}
}
}
}
_compi = u;
_compj = v;
oneStep(u,v,false);chressBord[u][v] = 2; //计算机占据位置
for (var k = 0; k < count; k++) {
if(wins[u][v][k]){
computerWin[k]++;
_myWin[k] = myWin[k];
myWin[k] = 6; //这个位置对方不可能赢了
if(computerWin[k] == 5){
resultTxt.innerHTML = 'o(╯□╰)o，计算机赢了，继续加油哦！';
over = true;
}
}
}
if(!over){
me = !me;
}
backAble = true;
returnAble = false;
var hasClass = new RegExp('unable').test('' +
returnbtn.className + '');
if(hasClass) {
returnbtn.className += '' + 'unable';
}
}
//绘画棋盘
var drawChessBoard = function(){
for (var i = 0; i < 15; i++) {
context.moveTo(15 + i * 30 , 15);
context.lineTo(15 + i * 30 , 435);
context.stroke();
context.moveTo(15 , 15 + i * 30);
context.lineTo(435 , 15 + i * 30);
context.stroke();
}
}
//画棋子
var oneStep = function(i,j,me) {
context.beginPath();
context.arc(15 +i * 30, 15 + j * 30, 13, 0, 2 * Math.PI);// 画圆
context.closePath();
//渐变
var gradient = context.createRadialGradient(15 + i * 30
+ 2, 15 + j * 30 - 2, 13, 15 + i * 30 + 2, 15 + j * 30 -
2, 0);
if(me){
gradient.addColorStop(0,'#0a0a0a');
gradient.addColorStop(1,'#636766');
}else{
gradient.addColorStop(0,'#d1d1d1');
gradient.addColorStop(1,'#f9f9f9')
}
context.fillStyle = gradient;
context.fill();
}
//销毁棋子
var minusStep = function(i,j){
//擦除该圆
context.clearRect((i) * 30, (j) * 30, 30, 30);
// 重画该圆周围的格子
context.beginPath();
context.moveTo(15+i*30, j*30);
context.lineTo(15+i*30, j*30 + 30);
context.moveTo(i*30, j*30+15);
context.lineTo((i+1)*30, j*30+15);
context.stroke();
}
</script>
</body>
</html>
【前言】动态规划：与分治法相似，即通过组合子问题来求解原问题，不同的是分治法是将问题划分为互不相交的子问题，递归求解子问题，再将他们组合起来求出原问题的解。动态规划则应用于子问题重叠的情况，通常用来求解最优化问题。这类问题可以有很多可行解，每个解都有一个值，我们希望寻找最优值的解。通常有4个步骤来设计动态规划算法：1.刻画一个最优解的结构特征。2.递归地定义最优解的值。3.计算
求同时整除两个数的数的和 =&gt; 等同于求GCD(X,Y)的约数和
SE(J2SE)，standard edition，标准版，是我们通常用的一个版本，从JDK 5.0开始，改名为Java SE。 EE(J2EE)，enterprise edition，企业版，使用这种JDK开发J2EE应用程序，从JDK 5.0开始，改名为Java EE。 ME(J2ME)，micro edition，主要用于移动设备、嵌入式设备上的j...
函数指针：是指向函数的指针变量，在C编译时，每一个函数都有一个入口地址，那么这个指向这个函数的函数指针便指向这个地址。函数指针的用途是很大的，主要有两个作用：用作调用函数和做函数的参数。函数指针的声明方法：数据类型标志符 （指针变量名） （形参列表）；一般函数的声明为: int func ( int x );而一个函数指针的声明方法为：int (*func) (
key.c#include "key.h"/* 函数名称： 函数功能： 函数参数： 函数返回值：*/void KEY_Init(void){ //1.打开时钟 PA PE RCC->APB2ENR |=(1<<2)|(1<<6); //2.配置IO工作模式：浮空输入 GPIOA->CRL &=~ (0xf<<0)...
示例代码：<html><head><!--http://www.jb51.net/article/64662.htm --><style type="text/css"> body{ margin:0px; <!--这两句必写，避免在不同浏览器中显示时发生错位--> padding:...
1. 从官网下载 mysql-5.7.13-linux-glibc2.5-x86_64.tar.gz官网： http://dev.mysql.com/downloads/mysql/我是下到了windows本地，然后通过winscp工具上传到centos6服务器上，我一般喜欢给文件赋权限，chmod a+x mysql-5.7.13-linux-glibc2.5-x86_6...
在做深度学习任务时，我是做图像目标检测，用tensorflow或者keras或者pytorch训练完模型，然后就是做预测，发现无论是用GPU还是CPU都非常慢，然后百度了好久都没有解决问题。无论是不是配置低，如果我们要做成品，一定要部署。我每个函数都去用time.time()去计算耗时，最后发现调用模型的时候耗时最多，也是罪魁祸首。无论你是调用ssd或者yolo模型，在这里的调用都非常耗时。系统有初始化，每次你去预测一张图片，系统都要重新调用一次模型，初始化一次模型，加载一次模型，这样就很慢了，我们
word插入参考文献毕业论文插入参考文献欢迎使用Markdown编辑器你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。新的改变我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客...
这篇文章主要是对之前一段时间里接触到的 循环神经网络 的相关知识进行一些总结，包括个人觉得初学难理解或者需要注意的问题和如何使用Pytorch的相关函数。由于这些经典结构网上资料很多，所以一些通识不再陈述，偏重代码部分。文章目录1.RNN2.LSTM3. GRU4. Multi-Layers-LSTM4. Bi-LSTM5.参考1.RNN很多问题都归结于序列信息的处理，例如 speech r...
作者 | 宋天龙，大数据技术专家，触脉咨询合伙人兼副总裁，前Webtrekk中国区技术和咨询负责人（Webtrekk，德国的在线数据分析服务提供商）。擅长数据挖掘、建模、...
JavaScript对象和数组前言正文总结前言JavaScript对象和数组是非常经常用到接收和保存数据的工具，他们都可以进行遍历，数组还自带了很多操作数组方法，下面就来大致介绍一下他们的用法。提示：以下是本篇文章正文内容，下面案例可供参考正文对象：对象是JS中的引用数据类型，可以保存多个不同数据类型（基本数据类型、数组、函数）的属性- 创建对象：var obj = {};- 添加属性：对象.属性名 = 属性值; 对象[“属性名”] = 属性值;- 读取属性：对象.属性名;对象[“属