首先介绍一下数回这个游戏，规则很简单，一个N*M的格子，其中给定一些数字，数字表明这个格子周围有几条边有连续通过，游戏要求画出一条 唯一的，封闭的 曲线，并且满足所有的数字条件，OK了。

这个游戏很有意思，有的很难，解题时要注意有些定式和技巧，特别是注意唯一性这个特定，很多时候可以帮助解题。

mapList=[.........]

execfile( "地图配置.py")

for map in mapList: ............

# -*- coding: utf-8 -*-
"""
Created on Fri Jan 31 18:19:25 2020

MainFrame

use two panel,one place menus ,one place feild.
@author: pc
"""
version="0.1"

import wx
import copy
#-------------------------------------------------------------
from ini import *
import GameMap as gmap

gMapList=[]
gCurrentMapIdx=-1
gCurrentMap=None
gReDraw=False

gMiniNumRect=40
gCurrentNumRect=40          #current number Square side length
gCurrentRectPos=[0,0]       #current map left top point
gCurrentMinSize=minisize
class MPanel(wx.Panel):
def __init__(self,parent,*args,**kwargs):
super(MPanel,self).__init__(parent,*args,**kwargs)
self.parent=parent
self.SetBackgroundColour(wx.WHITE)
#create a combo box
box=wx.BoxSizer(wx.HORIZONTAL)
wid,high=self.GetSize()
self.cbox=wx.ComboBox(self,pos=(wid-200,2))
self.SetSizer(box)
self.Bind(wx.EVT_COMBOBOX, self.OnCombox,self.cbox)

#load game map list to combo box
global gMapList

mapcnt=len(maplist)
self.cbox.Clear()
for lv in maplist:
texts="%d×%d "%(lv.colum,lv.row) + lv.title
self.cbox.Append(texts)

def OnCombox(self,event):
global gCurrentMapIdx, gCurrentMap, gMapList,gReDraw
idx= self.cbox.GetSelection()
#print("cbox select",idx)
if idx!=gCurrentMapIdx:
#change map and redraw
gCurrentMapIdx=idx
gCurrentMap=gMapList[idx]
gReDraw=True
self.parent.Refresh()

# game field panel ======================================================
class FPanel(wx.Panel):
def __init__(self,parent,*args,**kwargs):
super(FPanel,self).__init__(parent,*args,**kwargs)
self.parent=parent
self.bgColour=wx.Colour(232,232,232)
self.SetBackgroundColour(self.bgColour)
self.Bind(wx.EVT_PAINT,self.OnPaint)

#set OnMove and click action
self.MouseItem=[-1,-1,0]  #the mouse position map to squares [row, colum, right|down]
#self.Bind(wx.EVT_MOTION,self.OnMove)
self.Bind(wx.EVT_MOUSE_EVENTS,self.OnMouse,self)

self.MouseDownItem=[None,None]          #the items under the mouse when mouse button  is down [left , right]

def OnMove(self,event):
global gCurrentMapIdx, gCurrentMap, gMapList,gReDraw, gCurrentNumRect,gCurrentRectPos
x,y=event.GetPosition()
left,top=gCurrentRectPos
if gCurrentMap:
row=gCurrentMap.row
colum=gCurrentMap.colum
if x<=left or x>=left+gCurrentNumRect*colum+int(gCurrentNumRect/6) or y<=top or y>=top+gCurrentNumRect*row+int(gCurrentNumRect/6):
self.MouseItem=[-1,-1,0]
else:
squCol=int((x-left)/gCurrentNumRect)
squRow=int((y-top)/gCurrentNumRect)
sx=x-left-squCol*gCurrentNumRect
sy=y-top-squRow*gCurrentNumRect
#diviion a square to 8 part
sx= int(sx*8/gCurrentNumRect)
sy=int(sy*8/gCurrentNumRect)
if sx<2 and 0<sy<7:     #left side
self.MouseItem=[squRow,squCol,2 ]
elif sx>5 and 0<sy<7:   #right side
self.MouseItem=[squRow,squCol+1,2]
elif sy<2 and 0<sx<7:   #top side
self.MouseItem=[squRow,squCol,1]
elif sy>5 and  0<sx<7:   #down side
self.MouseItem=[squRow+1,squCol,1]
else:
self.MouseItem=[squRow,squCol,0]
#print(x,y,squRow,squCol,sx,sy,self.MouseItem)
def OnMouse(self,event):
global gCurrentMapIdx, gCurrentMap, gMapList,gReDraw, gCurrentNumRect,gCurrentRectPos

if event.Moving:        #deal  mouse moving
self.OnMove(event)
if event.LeftDown():
self.MouseDownItem[0]=self.MouseItem[:]
self.MouseDownItem[1]=None
if event.RightDown():
self.MouseDownItem[1]=self.MouseItem[:]
self.MouseDownItem[0]=None
#if have finished ,not change map
if not gCurrentMap or (gCurrentMap.succ and gCurrentMap.finish):
return
if event.LeftUp():
if self.MouseDownItem[0] and self.MouseDownItem[0]==self.MouseItem:
#print ("l click"
row,colum,line=self.MouseItem
if row>=0 and colum>=0 and line>0:
con=gCurrentMap.connected[row][colum]
if line==1:     #right direction
if con&0x10 ==0:    #unlock ,inverse the connect
gCurrentMap.setConnect(row,colum,gCurrentMap.Up,gCurrentMap.INVERSE,gCurrentMap.UNCHANGE)
gReDraw=True
#print(gCurrentMap.connected)
self.Refresh()
#print(self.toDrawAction)
elif line==2:   #down
if con&0x1000==0:   #unlock
gCurrentMap.setConnect(row,colum,gCurrentMap.Left,gCurrentMap.INVERSE,gCurrentMap.UNCHANGE)
gReDraw=True
self.Refresh()
self.MouseDownItem[0]=None
if event.RightUp():
if self.MouseDownItem[1] and self.MouseDownItem[1]==self.MouseItem:
row,colum,line=self.MouseItem
if row>=0 and colum>=0 and line>0:
con=gCurrentMap.connected[row][colum]
if line==1:     #right direction
gCurrentMap.setConnect(row,colum,gCurrentMap.Up,gCurrentMap.UNCHANGE,gCurrentMap.INVERSE)
gReDraw=True
self.Refresh()
elif line==2:   #down
gCurrentMap.setConnect(row,colum,gCurrentMap.Left,gCurrentMap.UNCHANGE,gCurrentMap.INVERSE)
gReDraw=True
self.Refresh()
self.MouseDownItem[1]=None
if gCurrentMap:
if gCurrentMap.succ and not gCurrentMap.finish:
gCurrentMap.finish=True
#print('succeessful finish')
for r in range(gCurrentMap.row+1):
for c in range(gCurrentMap.colum+1):

wx.MessageBox("Congratulations!","Finish",wx.OK)
else:
gCurrentMap.finish=gCurrentMap.succ
#print(self.MouseDownItem)

# draw feild
def OnPaint(self,event):
rect=self.GetClientRect()
global gCurrentMap, gReDraw,gCurrentNumRect,gCurrentRectPos
if gCurrentMap==None:
return

colum =gCurrentMap.colum
row = gCurrentMap.row

#dc=wx.PaintDC(self)
'''bmp=wx.Bitmap(width=rect.width,height=rect.height)
dc=wx.MemoryDC()
dc.SelectObject(bmp)'''
dc=wx.BufferedPaintDC(self)

gbBrush=wx.Brush(self.bgColour)
gbBrush.SetStyle(wx.BRUSHSTYLE_SOLID)
dc.SetBrush( gbBrush)

#print ("fpanel on paint",gReDraw)
if gReDraw:     #need redraw whole map
#calculate size , minist  number Square side length is 40,can zoom up by the rate of client size
#if client size less than the need of minist square ,resize the frame
x=int((rect.width-20)/colum /4)      #must times of 4
y=int((rect.height-200)/row /4)
m=min(x,y)
m<<=2
if m>120:
m=120
if m<gMiniNumRect:
#small than the minist size, need to resize the fame
m=gMiniNumRect
gCurrentMinSize=[m*colum+20,m*row+200]
self.parent.SetSize(gCurrentMinSize)
return

rect=self.GetClientRect()
left=int( (rect.width- m*colum)/2)
top= int((rect.height - m* row)/2-50)
gCurrentRectPos=[left,top]
gCurrentNumRect=m
#print(rect ,left ,top)
#start to draw map
#print("cls",rect, left,top,m,colum ,row)
dc.Clear()  #clear panel
#draw  points and num
#dc.SetBrush(wx.BLACK_BRUSH)
psize=int(m/20)*2

font=self.GetFont()
font.SetWeight(wx.FONTWEIGHT_BOLD)
font.SetPointSize(m/2)
dc.SetFont(font)
lightPen=wx.Pen(wx.Colour(64,64,64),psize,style=wx.PENSTYLE_SOLID) #use light pen to draw not locked line
dc.SetPen(lightPen)

dc.SetTextForeground(wx.BLUE)

nmap=gCurrentMap.numMap
# if see answer is true , draw the anser------------------------
else:
con=gCurrentMap.connected

for x in range(row+1):
for y in range(colum+1):
dc.DrawRectangle( (left+y*m,top+x*m,psize,psize ))  #draw angle point
tmp=con[x][y]
if tmp&1 !=0:
if tmp&0x10 ==0:        #not lock
dc.DrawLine(left+y*m+psize,top+x*m+int(psize/2), left+y*m+m,top+x*m+int(psize/2) )
else:
dc.DrawRectangle( (left+y*m+psize,top+x*m,m-psize,psize ))
if tmp&0x100 !=0:
if tmp & 0x1000 ==0:
dc.DrawLine(left+y*m+int(psize/2) ,top+x*m+psize ,left+y*m+int(psize/2) , top+x*m+m  )
else:
dc.DrawRectangle( (left+y*m,top+x*m+psize , psize,m-psize ))

for x in range(row):
for y in range(colum):
number=nmap[x][y]
if number>=0:
dc.DrawText(repr(number), left+y*m+m/4+psize, top+x*m +int(m/6)-psize )
# draw locked null connect ,use a red cross
redPen=wx.Pen(wx.Colour(255,32,32),int(psize/2),style=wx.PENSTYLE_SOLID) #use light pen to draw not locked line
dc.SetPen(redPen)
for x in range(row+1):
for y in range(colum+1):
tmp=con[x][y]
if tmp&0xff==0x10:
dc.DrawLine(left+y*m + int(m*3/8)+psize/2, top+x*m - int(m/8) , left+y*m + int(m*5/8)+psize/2, top+x*m + int(m/8)  )
dc.DrawLine(left+y*m + int(m*3/8)+psize/2, top+x*m + int(m/8) , left+y*m + int(m*5/8)+psize/2, top+x*m - int(m/8)  )
if tmp&0xff00==0x1000:
dc.DrawLine(left+y*m - int(m/8), top+x*m + int(m*3/8)+psize/2 , left+y*m + int(m/8), top+x*m + int(m*5/8)+psize/2 )
dc.DrawLine(left+y*m - int(m/8), top+x*m + int(m*5/8)+psize/2 , left+y*m + int(m/8), top+x*m + int(m*3/8)+psize/2  )

if gCurrentMap and gCurrentMap.succ and gCurrentMap.finish:
dc.SetTextForeground(wx.RED)
dc.DrawText("Finished !", int (rect.width/2)-int(1.5*m), 20)
#end of draw map
gReDraw = False
#self.Refresh()
'''dc2=wx.PaintDC(self)
print("blit",left,top)
dc2.Blit(0,0,rect.width,rect.height,dc,0,0)
dc.SelectObject(wx.NullBitmap)'''

#MainFrame ==============================================================
class MFrame(wx.Frame):
def __init__(self,parent,*args,**kwargs):
super(MFrame,self).__init__(parent,*args,**kwargs)

self.id_restart=101

self.mPanel=MPanel(self,size=(initsize[0],toolbarHeight))

#create field panel
self.fPanel= FPanel(self,style=wx.BORDER_DOUBLE,pos=(0,toolbarHeight),size=(initsize[0],initsize[1]-toolbarHeight) )

self.Bind(wx.EVT_SIZE,self.OnResize)

self.Bind(wx.EVT_CLOSE,self.OnClose)

#------------------------------------------
def OnResize(self,event):
global gReDraw,gCurrentMinSize

wid,high=self.GetSize()
#print("f size",wid,high)
#resize the panels,but not small then minsize
if wid<gCurrentMinSize[0]:
wid=gCurrentMinSize[0]
if high<gCurrentMinSize[1]:
high=gCurrentMinSize[1]

self.SetSize((wid,high))
self.mPanel.SetSize(wid,toolbarHeight)
gReDraw =True
self.fPanel.SetSize(wid,high-toolbarHeight)
#must call fpanel's refresh ,or it will not refresh the panel sometime
self.fPanel.Refresh()

global gCurrentMap, gReDraw
id=event.GetId()
#print(id)
if id==self.id_restart:
if gCurrentMap:
gCurrentMap.clear()
gReDraw=True
self.fPanel.Refresh()
if gCurrentMap:
gReDraw=True
self.fPanel.Refresh()

#on close------------------------------------------
def OnClose(self,event):
global gMapList
if len(gMapList)>0:
gmap.saveLeves(gMapList,savefilepath)
event.Skip()

#Main app=================================================================
class MyApp(wx.App):
def OnInit(self):
self.SetTopWindow(self.frame)

self.frame.Show()

return True

#======================================================================
if __name__=="__main__":
app=MyApp(False)
app.MainLoop()

# -*- coding: utf-8 -*-
"""
Created on Sat Feb  1 16:55:53 2020
@author: pc
"""
import os
import copy
import hashlib
class GameMap():
self.numMap=None   #num define
self.FitMap=None
self.mapHash=''
self.succ=False
self.finish=False
self.title=title
self.difficulty=difficulty
self.connected=None
self.row=0
self.colum=0
#define the direction code and connect action code,used in setConnect function
self.Up=0
self.Left=1
self.Down=2
self.Right=3
self.CONNECT=1
self.DISCONNECT=0
self.INVERSE=-1
self.UNCHANGE=-2

if numMap:
self.setMap(numMap,connected)
#--------------------------------------------------------------------------
def setMap(self, numMap,connected=None):
if numMap:
row=len(numMap)
#check map ,must be a 2D matrix
col=len(numMap[0])
for r in numMap:
if col!=len(r):
return False
else:
for i in r:
if i not in (-1,0,1,2,3):
return False
self.row=row
self.colum=col
self.numMap=numMap
self.clear()
self.calcuHash()
if connected:
succ=True
#check connected map
#connect map is a connected relation of the points
#as a m*n num map ,it will be a (m+1)*(n+1) points matrix
#from left-top to right-down , each point can have tow connections that to right and down
#each line use one byte , lower byte is right direction,upper byte is down direction,
#0 mean not connected ,1 means connected,0x10 means must not be connected ,0x11 means must be connected
conFlag= (0,1,0x10,0x11)
if len(connected)!=self.row+1:
succ=False
else:
for r in connected:
if not succ or len(r)!=self.colum+1:
succ=False
break
else:
for i in r:
if i&0xff not in conFlag or i>>8 not in conFlag:
succ=False
break
if succ :
self.connected=connected
self.checkFit()

else:
self.numMap=None
self.connected=None
self.row=0
self.colum=0

return True
#-----------------------------------------------------------------
def createFitMap(self):
self.FitMap=[]
for i in range(self.row):
a=[0]*(self.colum)
self.FitMap.append(a)
for r in range(self.row+1):
for c in range(self.colum+1):
state=self.connected[r][c]
if state&1 !=0:
if r<self.row:
self.FitMap[r][c]+=1
if r>0:
self.FitMap[r-1][c]+=1
if state&0x100 !=0:
if c < self.colum:
self.FitMap[r][c]+=1
if c>0:
self.FitMap[r][c-1]+=1

def checkFit(self):
self.createFitMap()
#print(self.FitMap)
succ=True
for r in range(self.row):
if not succ:
break
for c in range(self.colum):
if self.numMap[r][c]>=0:
if self.numMap[r][c]!=self.FitMap[r][c]:
succ=False
break
#print ("1",succ)
contmp=copy.deepcopy(self.connected)
trace=[]
if succ:
#print(contmp)
for r in range(self.row+1):
for c in range(self.colum+1):
if contmp[r][c]!=0:
break
if contmp[r][c]!=0:
break
#print("2",succ,r,c)
if contmp[r][c]&1 ==0:
succ=False
else:
startpoint=(r,c)
trace.append(startpoint)
direction=self.Right
contmp[r][c]&=0xff00
c+=1
while (r,c)!=startpoint:
#print(100,succ,r,c,direction,contmp[r][c])
if (r,c) in trace:
succ=False
break
trace.append((r,c))
tmp=contmp[r][c]
if direction==self.Right:
if tmp&1 !=0: #go right
contmp[r][c]&=0xff00
direction=self.Right
c+=1
continue
elif tmp&0x100 !=0:  #go down
contmp[r][c]&=0xff
direction=self.Down
r+=1
continue
elif r>0 and contmp[r-1][c]&0x100 !=0: #go up
r-=1
contmp[r][c]&=0xff
direction=self.Up
continue
else:
succ=False
break
elif direction==self.Down:
#print(10,r,c ,contmp[r][c])
if tmp&1 !=0: #go right
#print(11,contmp[r][c])
contmp[r][c]&=0xff00
direction=self.Right
c+=1
continue
elif tmp&0x100 !=0:  #go down
#print(12,contmp[r][c])
contmp[r][c]&=0xff
direction=self.Down
r+=1
continue
elif c>0 and contmp[r][c-1] &1 !=0:  #go left
#print(13,contmp[r][c-1])
c-=1
contmp[r][c]&=0xff00
direction=self.Left
continue
else:
succ=False
break
elif direction==self.Left:
if tmp&0x100 !=0:  #go down
contmp[r][c]&=0xff
direction=self.Down
r+=1
continue
elif c>0 and contmp[r][c-1] &1 !=0:  #go left
c-=1
contmp[r][c]&=0xff00
direction=self.Left
continue
elif r>0 and contmp[r-1][c] &0x100 !=0: # go up
r-=1
contmp[r][c]&=0xff
direction=self.Up
continue
else:
succ=False
break
elif direction==self.Up:
if tmp&1 !=0: #go right
contmp[r][c]&=0xff00
direction=self.Right
c+=1
continue
elif c>0 and contmp[r][c-1] &1 !=0:  #go left
c-=1
contmp[r][c]&=0xff00
direction=self.Left
continue
elif r>0 and contmp[r-1][c] &0x100 !=0: # go up
r-=1
contmp[r][c]&=0xff
direction=self.Up
continue
else:
succ=False
break
#print("3",succ)
if succ:
if (r,c)!=startpoint:
succ=False
else:
for r in range(self.row+1):
if not succ:
break
for c in range(self.colum+1):
if contmp[r][c]!=0:
succ=False
break
#print("4",trace,succ)
self.succ=succ
#print ("final",succ)
return succ

#---------------------------------------------------------------
def setConnect(self,row,colum, direction, state , lock):
# set the connected state of lines , row and colum defind the number ,drection in self.Up,Left,Down,Right
#state in   CONNECT DISCONNECT or INVERSE or UNCHAGE
#lock  in TRUE , FALSE or INVERSE  or UNCHANGE
#adjust direction to up right and right
if not self.connected:
return False
if direction==self.Down:
row+=1
direction=self.Up
elif direction==self.Right:
colum+=1
direction=self.Left

if row>self.row or colum>self.colum:
return False
elif direction not in (0,1):
return False
elif state not in (-2,-1,0,1):
return False
elif lock not in (-2,-1,0,1):
return False
#if change the connect , close answer show
curstate=self.connected[row][colum]
tmp=curstate
if direction==self.Left:
tmp>>=8
else:
tmp&=0xff
if lock!=self.UNCHANGE:
if lock==self.INVERSE:
tmp^=0x10
else:
tmp=(tmp&0xf) |(lock<<4)
if state !=self.UNCHANGE:
if state==self.INVERSE:
tmp^=1
else:
tmp=(tmp&0xf0)|state
if direction==self.Left:
self.connected[row][colum]= (curstate&0xff ) | tmp<<8
else:
self.connected[row][colum]= (curstate&0xff00 ) | tmp
self.checkFit()
return True
#---------------------------------------------------------------------
def clear(self):
self.connected=[]
for i in range(self.row+1):
a=[0]*(self.colum+1)
self.connected.append(a)
self.FitMap=[]
for i in range(self.row):
a=[0]*(self.colum)
self.FitMap.append(a)
self.succ=False
self.finish=False

def calcuHash(self):
s=""
for r in self.numMap:
for num in r:
s=s+repr(num)
#print(s)
m=hashlib.md5(s.encode('utf-8'))
self.mapHash=m.hexdigest()
#print (s,"\nhash=",self.mapHash)
if os.path.isfile(defFile):
with open(defFile,'r') as f:
#  this code is very important,if not this code ,when call exec in a function,
# it will not see the variables in current environment
loc=locals()
Levels=loc["Levels"]
#or you can use a global dic as a parameters when call exec like this
'''a=1

loc={'a':a}
glb={}
Levels=loc["Levels"]'''

try:
for lv in Levels:
if "field" in lv:
nummap=lv["field"]
if "title" in lv:
title=lv["title"]
else:
title=""
if "difficulty" in lv:
diff=lv["difficulty"]
else:
diff=0
else:
if "connected" in lv:
con = lv["connected"]
else:
con=None

if gmap.numMap:
tarList.append(gmap)
except:
if savefile and os.path.isfile(savefile):
with open(savefile,'r') as sf:
loc=locals()
saves=loc["saves"]
try:
for sv in saves:
for gmap in tarList:
if gmap.mapHash==sv["hash"]:
if  "connected" in sv:
gmap.connected=sv["connected"]
gmap.checkFit()
gmap.finish=gmap.succ
break
except:

def saveLeves(tarList, savefile):
if len(tarList)>0:
f=open(savefile,'w')
f.write("saves=[ \n")
for gmap in tarList:
f.write( "{'hash':'%s' ,\n"% gmap.mapHash)
if gmap.title:
f.write("'title': '")
f.write(gmap.title)
f.write(" ' ,\n")
f.write("'connected' :")
f.write( repr(gmap.connected))
f.write("\n},\n")
f.write("]\n")
f.close()

if __name__=="__main__":
lvs=[]
loadLeves(lvs,".\levels.py")            


initsize=(800,1000)
minisize=(600,800)
toolbarHeight=30

mapfilepath=".\levels.py"
savefilepath=".\saves.py"

# -*- coding: utf-8 -*-
n=-1
Levels=[
{"size":[7,10],
"title":"test 1",
"difficulty":1,
"field":[[2,n,1,1,0,1,n],
[n,n,1,n,n,n,n],
[2,n,n,1,n,0,1],
[n,n,3,n,n,2,n],
[n,n,2,n,n,n,n],
[n,n,n,n,3,n,n],
[n,0,n,n,0,n,n],
[3,2,n,3,n,n,3],
[n,n,n,n,0,n,n],
[n,3,2,2,2,n,3]]
},
{"size":[3,3],
"title":"test 2",
"difficulty":1,
"field":[[3,n,3],
[3,n,3],
[3,n,3]]
}
]

最后是在线存盘文件saves.py，可以在线生成

saves=[
'title': 'test 1 ' ,
'connected' :[[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]],
'answer':[[257, 1, 256, 0, 0, 0, 0, 0], [256, 257, 0, 257, 256, 257, 1, 256], [256, 256, 0, 256, 1, 0, 0, 256], [256, 256, 257, 0, 257, 256, 0, 256], [256, 256, 1, 1, 0, 1, 256, 256], [256, 1, 1, 256, 257, 256, 256, 256], [256, 0, 0, 1, 0, 1, 0, 256], [1, 256, 257, 1, 256, 0, 257, 0], [257, 0, 256, 257, 0, 0, 1, 256], [1, 256, 256, 256, 0, 257, 256, 256], [0, 1, 0, 1, 1, 0, 1, 0]]
},
{'hash':'c5dd983b8c34f667a89585c914998a0c' ,
'title': 'test 2 ' ,
'connected' :[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]],
'answer':[[257, 1, 1, 256], [1, 256, 257, 0], [257, 0, 1, 256], [1, 1, 1, 0]]
},
]


©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客