AN(p/q)mn
SOM(p/q)mn
pANT(p/q) pSOMT(p/q) ANT(p/q)
{
START:
change (q, p)
rif < Non {s-ANT(p)i & z-ANT(p)i} > {
move r(m, n) to A(mn) p(m, n)ofANT(p)i }
REST:
delete A(m) pANT(p/q)m pSOMT(p/q)m ANT(p/q)m
get r(a, b)
BINOOL:
if < A(c) c-r(a, b) = p(x, y) > {
if < A(m) reACT(p)m ≠ 1 > {
move 0 to NO
rif < r(i, j) = c-{A(m) reACT(p)m} > {
add 1 to NO }
if < NO = 1 > {
goto HANOOL }}
goto STOP }
HQNOOL:
if < Non reACT(q)n > {
goto OPEN }
move 0 to NO
rif < A(z) z-reACT(q)i ⊆ r(a, b) > {
add reACT(q)i to ANT(q)+ }
if < A(s) s-preACT(p) ⊆ r(a, b) > {
if < NO ≠ 0 > {
if < A(m) reACT(q)m ≠ 1 > {
if < ANT(q)n > {
goto DUOOL }}
goto STOP }}
DUOOL:
if < M ≠ 2 > {
if < r(a,b) ⊆ s-AN(p)mn > {
if < Non ANT(q)n > {
goto OPEN }}}
if < r(a, b) ⊆ s-AN(p)mn > {
if < A(s) s-AN(p)uv = r(a, b) > {
add AN(p/q)uv to ANT(p)+
add A(n) AN(p/q)un to pANT(p/q)+
add A(n) SOM(p/q)un to pSOMT(p/q)+
goto COMP
else goto OPEN }}
if < E(s) s-preACT(p) ⊆ s-preACT(q(x, y)) > {
goto OPEN }
add preACT(p) to ANT(p)+
call MAST(ANT(p)m, ANT(q)n)
if < Non ANT(p)n > {
goto OPEN
else if < A(c) c-r(a, b) ⊆ ANT(q)n > {
goto OPEN }}
rif < ANT(q)i > {
rif < A(s) s-PRE(ANT(q)i)j ⊆ s-preACT(q(x, y)) > {
if < PRE(ANT(q)i)j ⊆ pANT(p)n > {
add PRE(ANT(q)i)j to pANT(p)+ }}}
call MAST(ANT(p)m, ANT(q)n)
rif < pANT(p/q)i > {
rif < RE(pANT(p/q)i)j ⊆ pSOMT(q/p)n > {
add RE(pANT(p/q)i)j to pSOMT(q/p)+ }}
rif < pSOMT(p/q)i ⊆ ANT(p/q)n > {
delete pSOMT(p/q)i }
rif < pSOMT(p/q)i ⊆ AN(p/q)mn > {
add pSOMT(p/q)i to SOM(p/q)++ }
COMP:
if < {preACT(p) ⊆ r(a, b)} Or {r(a, b) ⊆ s-AN(p)mn} > {
if < {A≠(s) s-ANT(p) = r(a, b)} > {
if < n-ANT(p) ≠ n-ANT(q)n > {
goto OPEN }
rif < pSOMT(q/p)i ⊆ SOM(q/p)mn > {
goto OPEN }
goto STOP }}
OPEN:
if < pANT(p)n > {
if < A(s) s-ANT(p) ⊆ r(a, b) > {
move 2 to M }
rif < pANT(p/q)i ⊆ AN(p/q)mn > {
add pANT(p/q)i to AN(p/q)++ }
rif < pSOMT(p/q)i ⊆ SOM(p/q)mn > {
add pSOMT(p/q)i to SOM(p/q)++ }
else if < r(a, b) ⊆ s-AN(p)uv > {
delete A(mn) AN(p/q)mn
delete A(mn) SOM(p/q)mn
move 0 to M }}
EXIT:
move p(a, b) to r(a, b)
display p(a, b)
goto START
STOP:
end
MAST(Q(p)m, Q(q)n)
rif < Q(p)k > {
move 0 to NO
rif < A(z) z-RE(Q(p)k)i ⊆ s-Q(p)k > {
if < A(c) c-RE(Q(p)k)i ⊆ Q(p)k > {
add 1 to NO
else rif < A(c) c-q(m, n)ofRE(Q(p)k)i ⊆ Q(p)n > {
goto MS }
add 1 to NO }
MS: }
if < NO <= 1 > {
rif < A(z) z-RE(Q(p)k)i ⊆ s-Q(p)k > {
add RE(Q(p)k)i to Q(q)+ }
else delete Q(p)k }}}
용어의 정의
p(m, n) : p의 좌표.
r(a, b) : 빈자리의 좌표.
p- possible --- 소문자(자리포함)는 빈자리r(a, b)에 대해서.
P- possible-tree --- 대문자(이음돌둑)는 돌둑tree에 대해서.
re- relation --- 빈자리r(a, b)에 이음관계인.
RE- relation-tree --- 이음관계에 있는 돌둑.
ACT(p) : active-tree ACT(p(x, y)) --- 돌p(x, y)을 포함한 돌둑(p).
reACT(p) : reACT(p:r(a, b)) --- 빈자리r(a, b)에 이음인 돌둑(p).
preACT(p) : preACT(p:r(a, b)) --- 빈자리r(a, b)를 포함한 가능돌둑(p).
preACT(q(x, y)) : preACT(q:r(x, y)) --- 돌q(x, y)을 포함한 가능돌둑(q).
RE(ACT(q)) : relation-tree --- 돌q(x,y)를 포함한 돌둑(q)에 이음인 돌둑(p).
PRE(ACT(q)) : --- 돌q(x,y)를 포함한 돌둑(q)에 이음인 가능돌둑(p).
n-{ } : {자리, 돌둑, 가능돌둑}이 포함하는 자리 수.
s-{ } : {자리, 돌둑, 가능돌둑}에 포함된 빈자리.
z-{ } : {자리, 돌둑, 가능돌둑}에 이음인 이음자리.
c-{ } : {자리, 돌둑, 가능돌둑}과 이음관계에 있는 자리, 돌둑, 가능돌둑.
c-RE(ANT(p)) : {안섬가능돌둑(p)에 이음관계인 돌둑(q)}과 이음관계에 있는.
c-q(m, n)ofRE(ANT(p)) : {RE(ANT(p))의돌q(m, n)}과 이음관계에 있는.
AN(p)mn : 안섬인 돌둑(p)
SOM(p)mn : 둘러섬인 돌둑(p)
A(n) : 모든 n에 대해서
E(n) : 어떤 n에 대해서
ANT(p)+ : ANT(p)m일 때, m을 m+1로 바꾼다.
AN(p)++ : AN(p)mn일 때, m을 m+1로 그리고 n을 n+(1~last)까지.
∿ 이것을 어떻게 프로그래밍한다...
누구 프로그램으로 구현 좀 해줘요... 단, 미완성입니다.
invalid-file
invalid-file'바둑..! > 2008' 카테고리의 다른 글
| ☆ 바둑에서 진행규칙의 순환 (1) | 2008.06.22 |
|---|---|
| ☆ 바둑과 체스(장기) 규칙의 차이 (0) | 2008.06.11 |
| ☆ 바둑의 진행규칙(일반형) (0) | 2008.06.06 |
| ☆ 도대체 바둑에서 규칙이란? (0) | 2008.06.06 |
| ☆ 바둑에서 유효성이란? (0) | 2008.06.06 |