๋Š‘๋Œ€, ์—ผ์†Œ, ์–‘๋ฐฐ์ถ” ๋ฌธ์ œ์˜ ์˜ˆ๋ฅผ ์ด์šฉํ•œ ํ˜•์‹์  ๊ฒ€์ฆ

์ œ ์ƒ๊ฐ์—๋Š” ์ธํ„ฐ๋„ท์˜ ๋Ÿฌ์‹œ์•„์–ด ๋ถ€๋ฌธ์—์„œ๋Š” ๊ณต์‹ ๊ฒ€์ฆ ์ฃผ์ œ๊ฐ€ ์ถฉ๋ถ„ํžˆ ๋‹ค๋ฃจ์–ด์ง€์ง€ ์•Š์•˜๊ณ  ํŠนํžˆ ๊ฐ„๋‹จํ•˜๊ณ  ๋ช…ํ™•ํ•œ ์˜ˆ๊ฐ€ ๋ถ€์กฑํ•ฉ๋‹ˆ๋‹ค.

๋‚˜๋Š” ์™ธ๊ตญ ์ž๋ฃŒ์˜ ์˜ˆ๋ฅผ ์ œ์‹œํ•˜๊ณ  ๋Š‘๋Œ€, ์—ผ์†Œ, ์–‘๋ฐฐ์ถ”๋ฅผ ๊ฐ• ๋ฐ˜๋Œ€ํŽธ์œผ๋กœ ๊ฑด๋„ˆ๋Š” ์ž˜ ์•Œ๋ ค์ง„ ๋ฌธ์ œ์— ๋Œ€ํ•œ ๋‚˜๋งŒ์˜ ํ•ด๊ฒฐ์ฑ…์„ ์ถ”๊ฐ€ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

ํ•˜์ง€๋งŒ ๋จผ์ € ๊ณต์‹ ๊ฒ€์ฆ์ด ๋ฌด์—‡์ธ์ง€, ์™œ ํ•„์š”ํ•œ์ง€์— ๋Œ€ํ•ด ๊ฐ„๋žตํ•˜๊ฒŒ ์„ค๋ช…ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

๊ณต์‹ ๊ฒ€์ฆ์€ ์ผ๋ฐ˜์ ์œผ๋กœ ๋‹ค๋ฅธ ํ”„๋กœ๊ทธ๋žจ์ด๋‚˜ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์‚ฌ์šฉํ•˜์—ฌ ํ•˜๋‚˜์˜ ํ”„๋กœ๊ทธ๋žจ์ด๋‚˜ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ํ™•์ธํ•˜๋Š” ๊ฒƒ์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.

์ด๋Š” ํ”„๋กœ๊ทธ๋žจ์ด ์˜ˆ์ƒ๋Œ€๋กœ ์ž‘๋™ํ•˜๋Š”์ง€ ํ™•์ธํ•˜๊ณ  ๋ณด์•ˆ์„ ๋ณด์žฅํ•˜๋Š” ๋ฐ ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค.

๊ณต์‹ ๊ฒ€์ฆ์€ ์ทจ์•ฝ์ ์„ ์ฐพ๊ณ  ์ œ๊ฑฐํ•˜๋Š” ๊ฐ€์žฅ ๊ฐ•๋ ฅํ•œ ์ˆ˜๋‹จ์ž…๋‹ˆ๋‹ค. ์ด๋ฅผ ํ†ตํ•ด ํ”„๋กœ๊ทธ๋žจ์˜ ๊ธฐ์กด ํ—ˆ์ ๊ณผ ๋ฒ„๊ทธ๋ฅผ ๋ชจ๋‘ ์ฐพ๊ฑฐ๋‚˜ ์กด์žฌํ•˜์ง€ ์•Š์Œ์„ ์ฆ๋ช…ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
๋ณด๋“œ ๋„ˆ๋น„๊ฐ€ 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

์ •๋ง ํ•ด๊ฒฐ์ฑ…์ด ์—†๋‹ค๋Š” ๋œป์ด๋‹ค.

๋”ฐ๋ผ์„œ ์šฐ๋ฆฌ๋Š” ๋†๋ถ€์˜ ์†์‹ค ์—†์ด ์žก์‹์„ฑ ๋Š‘๋Œ€์™€ ๊ต๋ฐฐํ•˜๋Š” ๊ฒƒ์ด ๋ถˆ๊ฐ€๋Šฅํ•˜๋‹ค๋Š” ๊ฒƒ์„ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๋ฐฉ์‹์œผ๋กœ ์ฆ๋ช…ํ–ˆ์Šต๋‹ˆ๋‹ค.

์ฒญ์ค‘์ด ์ด ์ฃผ์ œ์— ํฅ๋ฏธ๋ฅผ ๋Š๋‚€๋‹ค๋ฉด ํ–ฅํ›„ ๊ธฐ์‚ฌ์—์„œ๋Š” ์ผ๋ฐ˜์ ์ธ ํ”„๋กœ๊ทธ๋žจ์ด๋‚˜ ํ•จ์ˆ˜๋ฅผ ํ˜•์‹์  ๋ฐฉ๋ฒ•๊ณผ ํ˜ธํ™˜๋˜๋Š” ๋ฐฉ์ •์‹์œผ๋กœ ๋ณ€ํ™˜ํ•˜๊ณ  ํ•ด๊ฒฐํ•˜์—ฌ ๋ชจ๋“  ํ•ฉ๋ฒ•์ ์ธ ์‹œ๋‚˜๋ฆฌ์˜ค์™€ ์ทจ์•ฝ์ ์„ ๋ชจ๋‘ ๋“œ๋Ÿฌ๋‚ด๋Š” ๋ฐฉ๋ฒ•์„ ์•Œ๋ ค ๋“œ๋ฆฌ๊ฒ ์Šต๋‹ˆ๋‹ค. ์ฒซ์งธ, ๋™์ผํ•œ ์ž‘์—…์— ๋Œ€ํ•ด ํ”„๋กœ๊ทธ๋žจ ํ˜•ํƒœ๋กœ ์ œ์‹œ๋œ ๋‹ค์Œ ์ ์ฐจ ๋ณต์žกํ•ด์ง€๊ณ  ์†Œํ”„ํŠธ์›จ์–ด ๊ฐœ๋ฐœ ์„ธ๊ณ„์˜ ํ˜„์žฌ ์‚ฌ๋ก€๋กœ ์ด๋™ํ•ฉ๋‹ˆ๋‹ค.

๋‹ค์Œ ๊ธฐ์‚ฌ๋Š” ์ด๋ฏธ ์ค€๋น„๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค.
์ฒ˜์Œ๋ถ€ํ„ฐ ๊ณต์‹ ๊ฒ€์ฆ ์‹œ์Šคํ…œ ๋งŒ๋“ค๊ธฐ: PHP ๋ฐ Python์—์„œ ๊ธฐํ˜ธํ˜• VM ์ž‘์„ฑ

์—ฌ๊ธฐ์„œ ๋‚˜๋Š” ๋ฌธ์ œ์˜ ๊ณต์‹ ๊ฒ€์ฆ์—์„œ ํ”„๋กœ๊ทธ๋žจ์œผ๋กœ ์ด๋™ํ•˜๊ณ  ์„ค๋ช…ํ•ฉ๋‹ˆ๋‹ค.
์–ด๋–ป๊ฒŒ ์ž๋™์œผ๋กœ ๊ณต์‹ ๊ทœ์น™ ์‹œ์Šคํ…œ์œผ๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๊นŒ?

์ถœ์ฒ˜ : habr.com

์ฝ”๋ฉ˜ํŠธ๋ฅผ ์ถ”๊ฐ€