๋ฌธ์ (์ถ์ฒ: https://www.acmicpc.net/problem/14499)
<์ฃผ์ฌ์ ๊ตด๋ฆฌ๊ธฐ>
๋ฌธ์
ํฌ๊ธฐ๊ฐ N×M์ธ ์ง๋๊ฐ ์กด์ฌํ๋ค. ์ง๋์ ์ค๋ฅธ์ชฝ์ ๋์ชฝ, ์์ชฝ์ ๋ถ์ชฝ์ด๋ค. ์ด ์ง๋์ ์์ ์ฃผ์ฌ์๊ฐ ํ๋ ๋์ฌ์ ธ ์์ผ๋ฉฐ, ์ฃผ์ฌ์์ ์ ๊ฐ๋๋ ์๋์ ๊ฐ๋ค. ์ง๋์ ์ขํ๋ (r, c)๋ก ๋ํ๋ด๋ฉฐ, r๋ ๋ถ์ชฝ์ผ๋ก๋ถํฐ ๋จ์ด์ง ์นธ์ ๊ฐ์, c๋ ์์ชฝ์ผ๋ก๋ถํฐ ๋จ์ด์ง ์นธ์ ๊ฐ์์ด๋ค.
2
4 1 3
5
6
์ฃผ์ฌ์๋ ์ง๋ ์์ ์ ๋ฉด์ด 1์ด๊ณ , ๋์ชฝ์ ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ์ด 3์ธ ์ํ๋ก ๋์ฌ์ ธ ์์ผ๋ฉฐ, ๋์ฌ์ ธ ์๋ ๊ณณ์ ์ขํ๋ (x, y)์ด๋ค. ๊ฐ์ฅ ์ฒ์์ ์ฃผ์ฌ์์๋ ๋ชจ๋ ๋ฉด์ 0์ด ์ ํ์ ธ ์๋ค.
์ง๋์ ๊ฐ ์นธ์๋ ์ ์๊ฐ ํ๋์ฉ ์ฐ์ฌ์ ธ ์๋ค. ์ฃผ์ฌ์๋ฅผ ๊ตด๋ ธ์ ๋, ์ด๋ํ ์นธ์ ์ฐ์ฌ ์๋ ์๊ฐ 0์ด๋ฉด, ์ฃผ์ฌ์์ ๋ฐ๋ฅ๋ฉด์ ์ฐ์ฌ ์๋ ์๊ฐ ์นธ์ ๋ณต์ฌ๋๋ค. 0์ด ์๋ ๊ฒฝ์ฐ์๋ ์นธ์ ์ฐ์ฌ ์๋ ์๊ฐ ์ฃผ์ฌ์์ ๋ฐ๋ฅ๋ฉด์ผ๋ก ๋ณต์ฌ๋๋ฉฐ, ์นธ์ ์ฐ์ฌ ์๋ ์๋ 0์ด ๋๋ค.
์ฃผ์ฌ์๋ฅผ ๋์ ๊ณณ์ ์ขํ์ ์ด๋์ํค๋ ๋ช ๋ น์ด ์ฃผ์ด์ก์ ๋, ์ฃผ์ฌ์๊ฐ ์ด๋ํ์ ๋๋ง๋ค ์๋จ์ ์ฐ์ฌ ์๋ ๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ฃผ์ฌ์๋ ์ง๋์ ๋ฐ๊นฅ์ผ๋ก ์ด๋์ํฌ ์ ์๋ค. ๋ง์ฝ ๋ฐ๊นฅ์ผ๋ก ์ด๋์ํค๋ ค๊ณ ํ๋ ๊ฒฝ์ฐ์๋ ํด๋น ๋ช ๋ น์ ๋ฌด์ํด์ผ ํ๋ฉฐ, ์ถ๋ ฅ๋ ํ๋ฉด ์ ๋๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ง๋์ ์ธ๋ก ํฌ๊ธฐ N, ๊ฐ๋ก ํฌ๊ธฐ M (1 ≤ N, M ≤ 20), ์ฃผ์ฌ์๋ฅผ ๋์ ๊ณณ์ ์ขํ x, y(0 ≤ x ≤ N-1, 0 ≤ y ≤ M-1), ๊ทธ๋ฆฌ๊ณ ๋ช ๋ น์ ๊ฐ์ K (1 ≤ K ≤ 1,000)๊ฐ ์ฃผ์ด์ง๋ค.
๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ์ง๋์ ์ฐ์ฌ ์๋ ์๊ฐ ๋ถ์ชฝ๋ถํฐ ๋จ์ชฝ์ผ๋ก, ๊ฐ ์ค์ ์์ชฝ๋ถํฐ ๋์ชฝ ์์๋๋ก ์ฃผ์ด์ง๋ค. ์ฃผ์ฌ์๋ฅผ ๋์ ์นธ์ ์ฐ์ฌ ์๋ ์๋ ํญ์ 0์ด๋ค. ์ง๋์ ๊ฐ ์นธ์ ์ฐ์ฌ ์๋ ์๋ 10 ๋ฏธ๋ง์ ์์ฐ์ ๋๋ 0์ด๋ค.
๋ง์ง๋ง ์ค์๋ ์ด๋ํ๋ ๋ช ๋ น์ด ์์๋๋ก ์ฃผ์ด์ง๋ค. ๋์ชฝ์ 1, ์์ชฝ์ 2, ๋ถ์ชฝ์ 3, ๋จ์ชฝ์ 4๋ก ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ด๋ํ ๋๋ง๋ค ์ฃผ์ฌ์์ ์ ๋ฉด์ ์ฐ์ฌ ์๋ ์๋ฅผ ์ถ๋ ฅํ๋ค. ๋ง์ฝ ๋ฐ๊นฅ์ผ๋ก ์ด๋์ํค๋ ค๊ณ ํ๋ ๊ฒฝ์ฐ์๋ ํด๋น ๋ช ๋ น์ ๋ฌด์ํด์ผ ํ๋ฉฐ, ์ถ๋ ฅ๋ ํ๋ฉด ์ ๋๋ค.
๋ฌธ์ ํ์ด
- my solution (Python)
import sys
def throw_dice(a,b,c,d,e,f):
temp = [0, 0, 0, 0, 0, 0]
temp[0] = dice[a]
temp[1] = dice[b]
temp[2] = dice[c]
temp[3] = dice[d]
temp[4] = dice[e]
temp[5] = dice[f]
return temp
if __name__=='__main__':
n,m,x,y,k=map(int,sys.stdin.readline().split()) # ์ธ๋ก, ๊ฐ๋ก, ์ฃผ์ฌ์ ์ขํ, ๋ช
๋ น ๊ฐ์
arr=[] # ์ง๋
for i in range(n):
arr.append(list(map(int,sys.stdin.readline().split())))
command=list(map(int,sys.stdin.readline().split())) # ๋ช
๋ น
dice=[0,0,0,0,0,0] # ์ฃผ์ฌ์
for i in command:
flag=False
if i==1: # ๋
if y+1<m:
y+=1
flag=True
dice = throw_dice(0, 4, 2, 5, 3, 1)
elif i==2: # ์
if y-1>=0:
y-=1
flag = True
dice = throw_dice(0, 5, 2, 4, 1, 3)
elif i==3: # ๋ถ
if x-1>=0:
x-=1
flag = True
dice = throw_dice(1, 2, 3, 0, 4, 5)
elif i==4: # ๋จ
if x+1<n:
x+=1
flag = True
dice = throw_dice(3, 0, 1, 2, 4, 5)
if flag==True:
if arr[x][y] == 0: # ์ด๋ํ ์นธ์ ์ฐ์ฌ์๋ ์๊ฐ 0
arr[x][y] = dice[3]
else: # 0์ด ์๋ ๊ฒฝ์ฐ
dice[3] = arr[x][y]
arr[x][y]=0
print(dice[1])
- my solution (JAVA)
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class _14499_์ฃผ์ฌ์๊ตด๋ฆฌ๊ธฐ {
static int[] throw_dice(int dice[], int a, int b, int c, int d, int e, int f){
int temp[]= {0,0,0,0,0,0};
temp[0]=dice[a];
temp[1]=dice[b];
temp[2]=dice[c];
temp[3]=dice[d];
temp[4]=dice[e];
temp[5]=dice[f];
return temp;
}
public static void main(String[] args)throws IOException {
BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
String s=bf.readLine();
int n=Integer.parseInt(s.split(" ")[0]); // ์ธ๋ก
int m=Integer.parseInt(s.split(" ")[1]); // ๊ฐ๋ก
int x=Integer.parseInt(s.split(" ")[2]); // ์ฃผ์ฌ์ ์ขํ
int y=Integer.parseInt(s.split(" ")[3]);
int k=Integer.parseInt(s.split(" ")[4]); // ๋ช
๋ น์ ๊ฐ์
int arr[][]=new int[n][m]; // ์ง๋
for(int i=0; i<n; i++) {
s=bf.readLine();
for(int j=0; j<m; j++) {
arr[i][j]=Integer.parseInt(s.split(" ")[j]);
}
}
int command[]=new int[k]; // ๋ช
๋ น
s=bf.readLine();
for(int i=0; i<k; i++) {
command[i]=Integer.parseInt(s.split(" ")[i]);
}
int dice[]= {0,0,0,0,0,0};
for(int i=0; i<k; i++) {
boolean flag=false;
if(command[i]==1) { // ๋
if(y+1<m) {
y+=1;
flag=true;
dice=throw_dice(dice, 0, 4, 2, 5, 3, 1);
}
}
else if(command[i]==2) { // ์
if(y-1>=0) {
y-=1;
flag=true;
dice=throw_dice(dice, 0, 5, 2, 4, 1, 3);
}
}
else if(command[i]==3) { // ๋ถ
if(x-1>=0) {
x-=1;
flag=true;
dice=throw_dice(dice, 1, 2, 3, 0, 4, 5);
}
}
else if(command[i]==4) { // ๋จ
if(x+1<n) {
x+=1;
flag=true;
dice=throw_dice(dice, 3, 0, 1, 2, 4, 5);
}
}
if(flag==true) {
if(arr[x][y]==0) {
arr[x][y]=dice[3];
}else {
dice[3]=arr[x][y];
arr[x][y]=0;
}
System.out.println(dice[1]);
}
}
}
}
๋, ์, ๋ถ, ๋จ์ผ๋ก ์ฃผ์ฌ์๋ฅผ ๊ตด๋ ธ์ ๋, ์ฃผ์ฌ์์ ์ ๊ฐ๋๊ฐ ์ด๋ํ๋ ์์น๋ฅผ ์ ํ์ ํ๋ฉด ์ฝ๊ฒ ํด๊ฒฐํ ์ ์๋ ๋ฌธ์ ์๋ค.
์ด ๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํ์ฌ ์ฃผ์ฌ์๋ฅผ ์ ๊ฐ๋๋ฅผ ๋ฆฌ์คํธ๋ก ์ ์ฅํ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค.
* ํ์ดํ ๋ฐฉํฅ ์ฃผ์
1. ๋
2. ์
3. ๋ถ
4. ๋จ
- throw_dice
: ๊ฐ ๋ฐฉํฅ์ผ๋ก ์ฃผ์ฌ์๋ฅผ ๊ตด๋ ธ์ ๋ ์ฃผ์ฌ์ ์ ๊ฐ๋๋ฅผ ์ ์ฅํ๊ธฐ ์ํ ํจ์ - Main
: ์ง๋์ ์ธ๋ก, ๊ฐ๋ก, ์ฃผ์ฌ์ ์ขํ, ๋ช ๋ น ๊ฐ์ ์ ๋ ฅ
: arr (์ง๋) ์ ๋ณด ์ ๋ ฅ
: command (๋ช ๋ น) ์ ๋ ฅ
: dice = ์ฃผ์ฌ์ ์ ๊ฐ๋ ์ ๋ณด ์ ์ฅ
: ๋ช ๋ น๋๋ก ์ฃผ์ฌ์๋ฅผ ๊ตด๋ ค ๋, ์, ๋ถ, ๋จ์ผ ๋ ์ขํ๋ฅผ ๊ตฌํ ํ ์ง๋์ ๋ฒ์ ์์ด๋ผ๋ฉด ์ฃผ์ฌ์๊ฐ ๊ตด๋ ค์ง ๋๋ก ์ ๊ฐ๋๋ฅผ ์ ์ฅํด์ฃผ๋ฉฐ ์ด๋ํ ์นธ์ ์ฐ์ฌ์๋ ์๊ฐ 0์ด๋ฉด ์ฃผ์ฌ์์ ๋ฐ๋ฅ๋ฉด์ ์ฐ์ฌ ์๋ ์๋ฅผ ๋ณต์ฌ, 0์ด ์๋๋ฉด ์ง๋์ ์นธ์ ์๋ ์๋ฅผ ์ฃผ์ฌ์ ๋ฐ๋ฅ ๋ฉด์ผ๋ก ๋ณต์ฌ ํ ์นธ์ ์ฐ์ฌ ์๋ ์๋ฅผ 0์ผ๋ก ์ ์ฅ
์๊ฐ๐ค
์ฃผ์ฌ์๋ฅผ ๊ตด๋ ธ์ ๋ ์ ๊ฐ๋๋ฅผ ๊ตฌํ ์ ์๋ค๋ฉด ๊ธ๋ฐฉ ํด๊ฒฐํ ์ ์๋ ๋ฌธ์ ์ด๋ค.
'๐Algorithm > ๐ฅBaekjoon' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Baekjoon] 14891_ํฑ๋๋ฐํด (0) | 2022.05.12 |
---|---|
[Baekjoon] 23288_์ฃผ์ฌ์ ๊ตด๋ฆฌ๊ธฐ 2 (0) | 2022.05.11 |
[Baekjoon] 14503_๋ก๋ด ์ฒญ์๊ธฐ (0) | 2022.05.05 |
[Baekjoon] 2638_์น์ฆ (0) | 2022.04.27 |
[Baekjoon] 1303_์ ์ - ์ ํฌ (0) | 2022.04.26 |