์ ์๊ฐ์๋ ์ธํฐ๋ท์ ๋ฌ์์์ด ๋ถ๋ฌธ์์๋ ๊ณต์ ๊ฒ์ฆ ์ฃผ์ ๊ฐ ์ถฉ๋ถํ ๋ค๋ฃจ์ด์ง์ง ์์๊ณ ํนํ ๊ฐ๋จํ๊ณ ๋ช ํํ ์๊ฐ ๋ถ์กฑํฉ๋๋ค.
๋๋ ์ธ๊ตญ ์๋ฃ์ ์๋ฅผ ์ ์ํ๊ณ ๋๋, ์ผ์, ์๋ฐฐ์ถ๋ฅผ ๊ฐ ๋ฐ๋ํธ์ผ๋ก ๊ฑด๋๋ ์ ์๋ ค์ง ๋ฌธ์ ์ ๋ํ ๋๋ง์ ํด๊ฒฐ์ฑ ์ ์ถ๊ฐํ๊ฒ ์ต๋๋ค.
ํ์ง๋ง ๋จผ์ ๊ณต์ ๊ฒ์ฆ์ด ๋ฌด์์ธ์ง, ์ ํ์ํ์ง์ ๋ํด ๊ฐ๋ตํ๊ฒ ์ค๋ช ํ๊ฒ ์ต๋๋ค.
๊ณต์ ๊ฒ์ฆ์ ์ผ๋ฐ์ ์ผ๋ก ๋ค๋ฅธ ํ๋ก๊ทธ๋จ์ด๋ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ์ฌ ํ๋์ ํ๋ก๊ทธ๋จ์ด๋ ์๊ณ ๋ฆฌ์ฆ์ ํ์ธํ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
์ด๋ ํ๋ก๊ทธ๋จ์ด ์์๋๋ก ์๋ํ๋์ง ํ์ธํ๊ณ ๋ณด์์ ๋ณด์ฅํ๋ ๋ฐ ํ์ํฉ๋๋ค.
๊ณต์ ๊ฒ์ฆ์ ์ทจ์ฝ์ ์ ์ฐพ๊ณ ์ ๊ฑฐํ๋ ๊ฐ์ฅ ๊ฐ๋ ฅํ ์๋จ์
๋๋ค. ์ด๋ฅผ ํตํด ํ๋ก๊ทธ๋จ์ ๊ธฐ์กด ํ์ ๊ณผ ๋ฒ๊ทธ๋ฅผ ๋ชจ๋ ์ฐพ๊ฑฐ๋ ์กด์ฌํ์ง ์์์ ์ฆ๋ช
ํ ์ ์์ต๋๋ค.
๋ณด๋ ๋๋น๊ฐ 8์ ๊ณฑ์ธ 1000๊ฐ์ ํธ ๋ฌธ์ ์ ๊ฐ์ด ์ด๋ค ๊ฒฝ์ฐ์๋ ์ด๊ฒ์ด ๋ถ๊ฐ๋ฅํ๋ค๋ ์ ์ ์ฃผ๋ชฉํ ๊ฐ์น๊ฐ ์์ต๋๋ค. ๋ชจ๋ ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ์ ๋ณต์ก์ฑ์ด๋ ์ค์ง ๋ฌธ์ ๋ก ๊ท๊ฒฐ๋ฉ๋๋ค.
๊ทธ๋ฌ๋ ์ด๋ค ๊ฒฝ์ฐ์๋ ํ๋ก๊ทธ๋จ์ด ์ ํํ๊ฑฐ๋, ํ๋ฆฌ๊ฑฐ๋, ๋ต์ ๊ณ์ฐํ ์ ์๋ค๋ ์ธ ๊ฐ์ง ๋ต๋ณ ์ค ํ๋๊ฐ ์์ ๋ฉ๋๋ค.
๋ต์ ์ฐพ๋ ๊ฒ์ด ๋ถ๊ฐ๋ฅํ ๊ฒฝ์ฐ ๊ตฌ์ฒด์ ์ธ ์ ๋๋ ์๋์ ๋ต์ ์ป๊ธฐ ์ํด ํ๋ก๊ทธ๋จ์ ๋ช ํํ์ง ์์ ๋ถ๋ถ์ ์ฌ์์ ํ์ฌ ์๊ณ ๋ฆฌ์ฆ์ ๋ณต์ก์ฑ์ ์ค์ด๋ ๊ฒ์ด ๊ฐ๋ฅํ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค.
์๋ฅผ ๋ค์ด Windows ์ปค๋ ๋ฐ Darpa ๋๋ก ์ด์ ์ฒด์ ์์๋ ์ต๋ ์์ค์ ๋ณดํธ๋ฅผ ๋ณด์ฅํ๊ธฐ ์ํด ๊ณต์ ๊ฒ์ฆ์ด ์ฌ์ฉ๋ฉ๋๋ค.
์ฐ๋ฆฌ๋ ์๋ํ๋ ์ ๋ฆฌ ์ฆ๋ช ๊ณผ ๋ฐฉ์ ์ ํ์ด๋ฅผ ์ํ ๋งค์ฐ ๊ฐ๋ ฅํ ๋๊ตฌ์ธ Z3Prover๋ฅผ ์ฌ์ฉํ ๊ฒ์ ๋๋ค.
๋ํ Z3์ ๋ฐฉ์ ์์ ํ๊ณ ๋ฌด์ฐจ๋ณ ๋์
์ ์ฌ์ฉํ์ฌ ํด๋น ๊ฐ์ ์ ํํ์ง ์์ต๋๋ค.
์ด๋ 10^100๊ฐ์ ์
๋ ฅ ์ต์
์กฐํฉ์ด ์๋ ๊ฒฝ์ฐ์๋ ๋ต์ ์ฐพ์ ์ ์์์ ์๋ฏธํฉ๋๋ค.
๊ทธ๋ฌ๋ ์ด๋ Integer ์ ํ์ ์ ๋ ฅ ์ธ์๊ฐ 12๊ฐ ์ ๋์ ๋ถ๊ณผํ๋ฉฐ ์ค์ ๋ก๋ ์์ฃผ ์ ํ๊ฒ ๋ฉ๋๋ค.
8๋ช
์ ์ฌ์์ ๊ดํ ๋ฌธ์
# We know each queen must be in a different row.
# So, we represent each queen by a single integer: the column position
Q = [ Int('Q_%i' % (i + 1)) for i in range(8) ]
# Each queen is in a column {1, ... 8 }
val_c = [ And(1 <= Q[i], Q[i] <= 8) for i in range(8) ]
# At most one queen per column
col_c = [ Distinct(Q) ]
# Diagonal constraint
diag_c = [ If(i == j,
True,
And(Q[i] - Q[j] != i - j, Q[i] - Q[j] != j - i))
for i in range(8) for j in range(i) ]
solve(val_c + col_c + diag_c)
Z3๋ฅผ ์คํํ๋ฉด ๋ค์๊ณผ ๊ฐ์ ํด๊ฒฐ์ฑ ์ ์ป์ ์ ์์ต๋๋ค.
[Q_5 = 1,
Q_8 = 7,
Q_3 = 8,
Q_2 = 2,
Q_6 = 3,
Q_4 = 6,
Q_7 = 5,
Q_1 = 4]
์ฌ์ ๋ฌธ์ ๋ ์ฌ์ 8๋ช ์ ์ขํ๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์ ์ฌ์์ด ์๋ก ์ด๊ธธ์ง ์ฌ๋ถ์ ๋ํ ๋ต์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ๊ณผ ๋น์ทํฉ๋๋ค.
ํ์ ๊ฒ์ฆ์ ์ฌ์ฉํ์ฌ ๊ทธ๋ฌํ ํ๋ก๊ทธ๋จ์ ํด๊ฒฐํ๋ ค๋ฉด ๋ฌธ์ ์ ๋น๊ตํ์ฌ ํ๋ก๊ทธ๋จ ์ฝ๋๋ฅผ ๋ฐฉ์ ์์ผ๋ก ๋ณํํ๋ ํํ๋ก ํ ๋จ๊ณ๋ง ๋ ์ํํ๋ฉด ๋ฉ๋๋ค. ์ด๋ ๋ณธ์ง์ ์ผ๋ก ์ฐ๋ฆฌ์ ๊ฒ๊ณผ ๋์ผํ ๊ฒ์ผ๋ก ํ๋ช ๋ฉ๋๋ค( ๋ฌผ๋ก , ํ๋ก๊ทธ๋จ์ด ์ฌ๋ฐ๋ฅด๊ฒ ์์ฑ๋์๋ค๋ฉด ๋ง์ด์ฃ ).
์ทจ์ฝ์ ์ ๊ฒ์ํ๋ ๊ฒฝ์ฐ์๋ ๊ฑฐ์ ๋์ผํ ์ผ์ด ๋ฐ์ํฉ๋๋ค. ์๋ฅผ ๋ค์ด ๊ด๋ฆฌ์ ๋น๋ฐ๋ฒํธ์ ๊ฐ์ด ํ์ํ ์ถ๋ ฅ ์กฐ๊ฑด์ ์ค์ ํ๊ณ ์์ค ๋๋ ๋์ปดํ์ผ๋ ์ฝ๋๋ฅผ ๊ฒ์ฆ์ ์ ํฉํ ๋ฐฉ์ ์์ผ๋ก ๋ณํํ ๋ค์ ๋ฌด์์ ๋ํ ๋ต๋ณ์ ์ป์ต๋๋ค. ๋ชฉํ๋ฅผ ๋ฌ์ฑํ๋ ค๋ฉด ๋ฐ์ดํฐ๊ฐ ์ ๋ ฅ์ผ๋ก ์ ๊ณต๋์ด์ผ ํฉ๋๋ค.
์ ์๊ฐ์๋ ๋๋, ์ผ์, ์๋ฐฐ์ถ์ ๊ดํ ๋ฌธ์ ๋ ํจ์ฌ ๋ ํฅ๋ฏธ๋กญ์ต๋๋ค. ์๋ํ๋ฉด ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ค๋ฉด ์ด๋ฏธ ๋ง์ (7) ๋จ๊ณ๊ฐ ํ์ํ๊ธฐ ๋๋ฌธ์ ๋๋ค.
์ฌ์ ๋ฌธ์ ๊ฐ ๋จ์ผ GET ๋๋ POST ์์ฒญ์ ์ฌ์ฉํ์ฌ ์๋ฒ์ ์นจํฌํ ์ ์๋ ๊ฒฝ์ฐ์ ๋น๊ตํ ์ ์๋ค๋ฉด ๋๋, ์ผ์ ๋ฐ ์๋ฐฐ์ถ๋ ํจ์ฌ ๋ ๋ณต์กํ๊ณ ๊ด๋ฒ์ํ ๋ฒ์ฃผ์ ์๋ฅผ ๋ณด์ฌ์ค๋๋ค. ์ฌ๋ฌ ์์ฒญ์ผ๋ก.
์๋ฅผ ๋ค์ด ์ด๋ SQL ์ฃผ์ ์ ์ฐพ์์ ์ด๋ฅผ ํตํด ํ์ผ์ ์์ฑํ ๋ค์ ๊ถํ์ ๋์ด๊ณ ๋น๋ฐ๋ฒํธ๋ฅผ ๋ฐ์์ผ ํ๋ ์๋๋ฆฌ์ค์ ๋น์ทํฉ๋๋ค.
๋ฌธ์ ์ ์กฐ๊ฑด๊ณผ ํด๊ฒฐ ๋ฐฉ๋ฒ๋๋ถ๋ ๋๋, ์ผ์, ์๋ฐฐ์ถ๋ฅผ ๊ฐ ๊ฑด๋ํธ์ผ๋ก ์ด๋ฐํด์ผ ํฉ๋๋ค. ๋๋ถ๋ ์์ ์ธ์ ๋จ ํ๋์ ๋ฌผ๊ฑด๋ง ์์ฉํ ์ ์๋ ๋ฐฐ๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค. ๋๋ถ๊ฐ ์๋ฐฐ์ถ๋ฅผ ๋ฐฉ์นํ๋ฉด ๋๋๊ฐ ์ผ์๋ฅผ ๋จน๊ณ , ์ผ์๋ ์๋ฐฐ์ถ๋ฅผ ๋จน์ต๋๋ค.
ํด๊ฒฐ์ฑ
์ 4๋จ๊ณ์์ ๋๋ถ๊ฐ ์ผ์๋ฅผ ๋ค์ ๊ฐ์ ธ๊ฐ์ผ ํ๋ค๋ ๊ฒ์
๋๋ค.
์ด์ ํ๋ก๊ทธ๋๋ฐ ๋ฐฉ์์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด ๋ณด๊ฒ ์ต๋๋ค.
๋๋ถ, ๋๋, ์ผ์, ์๋ฐฐ์ถ๋ฅผ 4 ๋๋ 0์ ๊ฐ๋ง์ ๊ฐ์ง๋ 1๊ฐ์ ๋ณ์๋ก ํ์ํด๋ณด์. XNUMX์ ์ผ์ชฝ ๋์ ์๋ค๋ ๋ป์ด๊ณ , XNUMX์ ์ค๋ฅธ์ชฝ ๋์ ์๋ค๋ ๋ป์ด๋ค.
import json
from z3 import *
s = Solver()
Num= 8
Human = [ Int('Human_%i' % (i + 1)) for i in range(Num) ]
Wolf = [ Int('Wolf_%i' % (i + 1)) for i in range(Num) ]
Goat = [ Int('Goat_%i' % (i + 1)) for i in range(Num) ]
Cabbage = [ Int('Cabbage_%i' % (i + 1)) for i in range(Num) ]
# Each creature can be only on left (0) or right side (1) on every state
HumanSide = [ Or(Human[i] == 0, Human[i] == 1) for i in range(Num) ]
WolfSide = [ Or(Wolf[i] == 0, Wolf[i] == 1) for i in range(Num) ]
GoatSide = [ Or(Goat[i] == 0, Goat[i] == 1) for i in range(Num) ]
CabbageSide = [ Or(Cabbage[i] == 0, Cabbage[i] == 1) for i in range(Num) ]
Side = HumanSide+WolfSide+GoatSide+CabbageSide
Num์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐ ํ์ํ ๋จ๊ณ ์์ ๋๋ค. ๊ฐ ๋จ๊ณ๋ ๊ฐ, ๋ณดํธ ๋ฐ ๋ชจ๋ ๊ฐ์ฒด์ ์ํ๋ฅผ ๋ํ๋ ๋๋ค.
์ง๊ธ์ ๋ฌด์์๋ก ์ ํํ๊ณ ์ฌ์ ๋ฅผ ๋๊ณ 10์ ์ ํํ๊ฒ ์ต๋๋ค.
๊ฐ ์ํฐํฐ๋ 10๊ฐ์ ๋ณต์ฌ๋ณธ์ผ๋ก ํ์๋ฉ๋๋ค. ์ด๋ ๊ฐ 10๋จ๊ณ์ ๊ฐ์ ๋๋ค.
์ด์ ์์๊ณผ ๋์ ์กฐ๊ฑด์ ์ค์ ํด ๋ณด๊ฒ ์ต๋๋ค.
Start = [ Human[0] == 0, Wolf[0] == 0, Goat[0] == 0, Cabbage[0] == 0 ]
Finish = [ Human[9] == 1, Wolf[9] == 1, Goat[9] == 1, Cabbage[9] == 1 ]
๊ทธ๋ฐ ๋ค์ ๋๋๊ฐ ์ผ์๋ฅผ ๋จน๊ฑฐ๋ ์ผ์๊ฐ ์๋ฐฐ์ถ๋ฅผ ๋จน๋ ์กฐ๊ฑด์ ๋ฐฉ์ ์์ ์ ์ฝ ์กฐ๊ฑด์ผ๋ก ์ค์ ํฉ๋๋ค.
(๋๋ฏผ์ด ์์ผ๋ฉด ๊ณต๊ฒฉ์ด ๋ถ๊ฐ๋ฅํฉ๋๋ค)
# Wolf cant stand with goat, and goat with cabbage without human. Not 2, not 0 which means that they are one the same side
Safe = [ And( Or(Wolf[i] != Goat[i], Wolf[i] == Human[i]), Or(Goat[i] != Cabbage[i], Goat[i] == Human[i])) for i in range(Num) ]
๊ทธ๋ฆฌ๊ณ ๋ง์ง๋ง์ผ๋ก ๊ทธ๊ณณ์ ๊ฑด๋๊ฑฐ๋ ๋์์ฌ ๋ ๋๋ถ๊ฐ ํ ์ ์๋ ๋ชจ๋ ํ๋์ ์ ์ํ๊ฒ ์ต๋๋ค.
๊ทธ๋ ๋๋, ์ผ์ ๋๋ ์๋ฐฐ์ถ๋ฅผ ๋ฐ๋ฆฌ๊ณ ๊ฐ ์๋ ์๊ณ , ๋๊ตฌ๋ ๋ฐ๋ ค๊ฐ์ง ์์ ์๋ ์๊ณ , ์๋ฌด๋ฐ๋ ํญํดํ์ง ์์ ์๋ ์์ต๋๋ค.
๋ฌผ๋ก ๋๋ถ ์์ด๋ ๋๊ตฌ๋ ๊ฑด๋ ์ ์์ต๋๋ค.
์ด๋ ๊ฐ, ๋ณดํธ ๋ฐ ๊ฐ์ฒด์ ๊ฐ ํ์ ์ํ๊ฐ ์๊ฒฉํ๊ฒ ์ ํ๋ ๋ฐฉ์์ผ๋ก๋ง ์ด์ ์ํ์ ๋ค๋ฅผ ์ ์๋ค๋ ์ฌ์ค๋ก ํํ๋ฉ๋๋ค.
๋๋ถ๋ ํ ๋ฒ์ ํ๋์ ๊ฐ์ฒด๋ง ์ ์กํ ์ ์๊ณ ๋ชจ๋ ๊ฐ์ฒด๋ฅผ ํจ๊ป ๋ ์๋ ์์ผ๋ฏ๋ก 2๋นํธ๋ฅผ ๋์ง ์์ผ๋ฉฐ ๋ค๋ฅธ ๋ง์ ์ ํ์ด ์์ต๋๋ค.
Travel = [ Or(
And(Human[i] == Human[i+1] + 1, Wolf[i] == Wolf[i+1] + 1, Goat[i] == Goat[i+1], Cabbage[i] == Cabbage[i+1]),
And(Human[i] == Human[i+1] + 1, Goat[i] == Goat[i+1] + 1, Wolf[i] == Wolf[i+1], Cabbage[i] == Cabbage[i+1]),
And(Human[i] == Human[i+1] + 1, Cabbage[i] == Cabbage[i+1] + 1, Wolf[i] == Wolf[i+1], Goat[i] == Goat[i+1]),
And(Human[i] == Human[i+1] - 1, Wolf[i] == Wolf[i+1] - 1, Goat[i] == Goat[i+1], Cabbage[i] == Cabbage[i+1]),
And(Human[i] == Human[i+1] - 1, Goat[i] == Goat[i+1] - 1, Wolf[i] == Wolf[i+1], Cabbage[i] == Cabbage[i+1]),
And(Human[i] == Human[i+1] - 1, Cabbage[i] == Cabbage[i+1] - 1, Wolf[i] == Wolf[i+1], Goat[i] == Goat[i+1]),
And(Wolf[i] == Wolf[i+1], Goat[i] == Goat[i+1], Cabbage[i] == Cabbage[i+1])) for i in range(Num-1) ]
์๋ฃจ์ ์ ์คํํด ๋ณด๊ฒ ์ต๋๋ค.
solve(Side + Start + Finish + Safe + Travel)
๊ทธ๋ฆฌ๊ณ ์ฐ๋ฆฌ๋ ๋ต์ ์ป์ต๋๋ค!
Z3์ ๋ชจ๋ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์ผ๊ด๋ ์ํ ์งํฉ์ ์ฐพ์์ต๋๋ค.
์ผ์ข
์ 4์ฐจ์ ์๊ณต๊ฐ ์บ์คํธ์
๋๋ค.
๋ฌด์จ ์ผ์ด ์ผ์ด๋ฌ๋์ง ์์๋ด ์๋ค.
์ฐ๋ฆฌ๋ ๊ฒฐ๊ตญ ๋ชจ๋๊ฐ ๊ฑด๋๊ณ ์ฒ์์๋ ๋๋ถ๊ฐ ํด์์ ์ทจํ๊ธฐ๋ก ๊ฒฐ์ ํ๊ณ ์ฒ์ 2 ๋จ๊ณ์์๋ ์๋ฌด๋ฐ๋ ์์ํ์ง ์๋๋ค๋ ๊ฒ์ ์ ์ ์์ต๋๋ค.
Human_2 = 0
Human_3 = 0
์ด๋ ์ฐ๋ฆฌ๊ฐ ์ ํํ ์ํ์ ์๊ฐ ๊ณผ๋ํ๊ณ 8๊ฐ๋ฉด ์ถฉ๋ถํ๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
์ฐ๋ฆฌ์ ๊ฒฝ์ฐ ๋๋ถ๋ ์ด๋ ๊ฒ ํ์ต๋๋ค. ์์ํ๊ณ , ์ฌ๊ณ , ์ฌ๊ณ , ์ผ์๋ฅผ ๊ฑด๋๊ณ , ๋ค๋ก ๊ฑด๋๊ณ , ์๋ฐฐ์ถ๋ฅผ ๊ฑด๋๊ณ , ์ผ์์ ํจ๊ป ๋์์ค๊ณ , ๋๋๋ฅผ ๊ฑด๋๊ณ , ํผ์ ๋์์์ ์ผ์๋ฅผ ๋ค์ ๋ฐฐ๋ฌํ์ต๋๋ค.
๊ทธ๋ฌ๋ ๊ฒฐ๊ตญ ๋ฌธ์ ๋ ํด๊ฒฐ๋์์ต๋๋ค.
#ะกัะฐัั.
Human_1 = 0
Wolf_1 = 0
Goat_1 = 0
Cabbage_1 = 0
#ะคะตัะผะตั ะพัะดัั
ะฐะตั.
Human_2 = 0
Wolf_2 = 0
Goat_2 = 0
Cabbage_2 = 0
#ะคะตัะผะตั ะพัะดัั
ะฐะตั.
Human_3 = 0
Wolf_3 = 0
Goat_3 = 0
Cabbage_3 = 0
#ะคะตัะผะตั ะพัะฒะพะทะธั ะบะพะทั ะฝะฐ ะฝัะถะฝัะน ะฑะตัะตะณ.
Human_4 = 1
Wolf_4 = 0
Goat_4 = 1
Cabbage_4 = 0
#ะคะตัะผะตั ะฒะพะทะฒัะฐัะฐะตััั.
Human_5 = 0
Wolf_5 = 0
Goat_5 = 1
Cabbage_5 = 0
#ะคะตัะผะตั ะพัะฒะพะทะธั ะบะฐะฟัััั ะฝะฐ ะฝัะถะฝัะน ะฑะตัะตะณ.
Human_6 = 1
Wolf_6 = 0
Cabbage_6 = 1
Goat_6 = 1
#ะะปััะตะฒะฐั ัะฐััั ะพะฟะตัะฐัะธะธ: ัะตัะผะตั ะฒะพะทะฒัะฐัะฐะตั ะบะพะทั ะพะฑัะฐัะฝะพ.
Human_7 = 0
Wolf_7 = 0
Goat_7 = 0
Cabbage_7 = 1
#ะคะตัะผะตั ะพัะฒะพะทะธั ะฒะพะปะบะฐ ะฝะฐ ะดััะณะพะน ะฑะตัะตะณ, ะณะดะต ะพะฝ ัะตะฟะตัั ะฝะฐั
ะพะดะธััั ะฒะผะตััะต ั ะบะฐะฟัััะพะน.
Human_8 = 1
Wolf_8 = 1
Goat_8 = 0
Cabbage_8 = 1
#ะคะตัะผะตั ะฒะพะทะฒัะฐัะฐะตััั ะทะฐ ะบะพะทะพะน.
Human_9 = 0
Wolf_9 = 1
Goat_9 = 0
Cabbage_9 = 1
#ะคะตัะผะตั ะฟะพะฒัะพัะฝะพ ะดะพััะฐะฒะปัะตั ะบะพะทั ะฝะฐ ะฝัะถะฝัะน ะฑะตัะตะณ ะธ ะทะฐะฒะตััะฐัั ะฟะตัะตะฟัะฐะฒั.
Human_10 = 1
Wolf_10 = 1
Goat_10 = 1
Cabbage_10 = 1
์ด์ ์กฐ๊ฑด์ ๋ณ๊ฒฝํ์ฌ ํด๊ฒฐ์ฑ ์ด ์์์ ์ฆ๋ช ํด ๋ณด๊ฒ ์ต๋๋ค.
์ด๋ฅผ ์ํด ์ฐ๋ฆฌ๋ ๋๋์๊ฒ ์ด์๋๋ฌผ์ ์ฃผ๊ณ ๋๋๋ ์๋ฐฐ์ถ๋ฅผ ๋จน๊ณ ์ถ์ดํ ๊ฒ์
๋๋ค.
์ด๋ ์ฐ๋ฆฌ์ ๋ชฉํ๊ฐ ์ ํ๋ฆฌ์ผ์ด์
๋ณด์์ด๊ณ ํ์ ์ด ์๋์ง ํ์ธํด์ผ ํ๋ ๊ฒฝ์ฐ์ ๋น๊ตํ ์ ์์ต๋๋ค.
Safe = [ And( Or(Wolf[i] != Goat[i], Wolf[i] == Human[i]), Or(Goat[i] != Cabbage[i], Goat[i] == Human[i]), Or(Wolf[i] != Cabbage[i], Goat[i] == Human[i])) for i in range(Num) ]
Z3๋ ๋ค์๊ณผ ๊ฐ์ ์๋ต์ ์ ๊ณตํ์ต๋๋ค.
no solution
์ ๋ง ํด๊ฒฐ์ฑ ์ด ์๋ค๋ ๋ป์ด๋ค.
๋ฐ๋ผ์ ์ฐ๋ฆฌ๋ ๋๋ถ์ ์์ค ์์ด ์ก์์ฑ ๋๋์ ๊ต๋ฐฐํ๋ ๊ฒ์ด ๋ถ๊ฐ๋ฅํ๋ค๋ ๊ฒ์ ํ๋ก๊ทธ๋๋ฐ ๋ฐฉ์์ผ๋ก ์ฆ๋ช ํ์ต๋๋ค.
์ฒญ์ค์ด ์ด ์ฃผ์ ์ ํฅ๋ฏธ๋ฅผ ๋๋๋ค๋ฉด ํฅํ ๊ธฐ์ฌ์์๋ ์ผ๋ฐ์ ์ธ ํ๋ก๊ทธ๋จ์ด๋ ํจ์๋ฅผ ํ์์ ๋ฐฉ๋ฒ๊ณผ ํธํ๋๋ ๋ฐฉ์ ์์ผ๋ก ๋ณํํ๊ณ ํด๊ฒฐํ์ฌ ๋ชจ๋ ํฉ๋ฒ์ ์ธ ์๋๋ฆฌ์ค์ ์ทจ์ฝ์ ์ ๋ชจ๋ ๋๋ฌ๋ด๋ ๋ฐฉ๋ฒ์ ์๋ ค ๋๋ฆฌ๊ฒ ์ต๋๋ค. ์ฒซ์งธ, ๋์ผํ ์์ ์ ๋ํด ํ๋ก๊ทธ๋จ ํํ๋ก ์ ์๋ ๋ค์ ์ ์ฐจ ๋ณต์กํด์ง๊ณ ์ํํธ์จ์ด ๊ฐ๋ฐ ์ธ๊ณ์ ํ์ฌ ์ฌ๋ก๋ก ์ด๋ํฉ๋๋ค.
๋ค์ ๊ธฐ์ฌ๋ ์ด๋ฏธ ์ค๋น๋์ด ์์ต๋๋ค.
์ฌ๊ธฐ์ ๋๋ ๋ฌธ์ ์ ๊ณต์ ๊ฒ์ฆ์์ ํ๋ก๊ทธ๋จ์ผ๋ก ์ด๋ํ๊ณ ์ค๋ช
ํฉ๋๋ค.
์ด๋ป๊ฒ ์๋์ผ๋ก ๊ณต์ ๊ท์น ์์คํ
์ผ๋ก ๋ณํํ ์ ์์ต๋๊น?
์ถ์ฒ : habr.com