[Algorithm] ๐๋ฐฑ์ค 1600 ๋ง์ด ๋๊ณ ํ ์์ญ์ด
0. ๋ฌธ์ 
๋๋ฌผ์์์ ๋ง ํ์ถํ ์์ญ์ด ํ ๋ง๋ฆฌ๊ฐ ์ธ์๊ตฌ๊ฒฝ์ ํ๊ณ ์๋ค. ๊ทธ ๋ ์์ ๋ง(Horse)์ด ๋๊ธฐ๋ฅผ ๊ฐ์ ํ ์ํ๋ค. ๊ทธ๋์ ๊ทธ๋ ๋ง์ ์์ง์์ ์ ์ฌํ ์ดํด๋ณด๊ณ ๊ทธ๋๋ก ๋ฐ๋ผ ํ๊ธฐ๋ก ํ์๋ค. ๋ง์ ๋ง์ด๋ค. ๋ง์ ๊ฒฉ์ํ์์ ์ฒด์ค์ ๋์ดํธ์ ๊ฐ์ ์ด๋๋ฐฉ์์ ๊ฐ์ง๋ค. ๋ค์ ๊ทธ๋ฆผ์ ๋ง์ ์ด๋๋ฐฉ๋ฒ์ด ๋ํ๋์๋ค. xํ์ํ ๊ณณ์ผ๋ก ๋ง์ด ๊ฐ ์ ์๋ค๋ ๋ป์ด๋ค. ์ฐธ๊ณ ๋ก ๋ง์ ์ฅ์ ๋ฌผ์ ๋ฐ์ด๋์ ์ ์๋ค.
๊ทผ๋ฐ ์์ญ์ด๋ ํ ๊ฐ์ง ์ฐฉ๊ฐํ๊ณ ์๋ ๊ฒ์ด ์๋ค. ๋ง์ ์ ๋ ๊ฒ ์์ง์ผ ์ ์์ง๋ง ์์ญ์ด๋ ๋ฅ๋ ฅ์ด ๋ถ์กฑํด์ ์ด K๋ฒ๋ง ์์ ๊ฐ์ด ์์ง์ผ ์ ์๊ณ , ๊ทธ ์ธ์๋ ๊ทธ๋ฅ ์ธ์ ํ ์นธ์ผ๋ก๋ง ์์ง์ผ ์ ์๋ค. ๋๊ฐ์ ๋ฐฉํฅ์ ์ธ์ ํ ์นธ์ ํฌํจ๋์ง ์๋๋ค.
์ด์  ์์ญ์ด๋ ๋จธ๋๋จผ ์ฌํ๊ธธ์ ๋ ๋๋ค. ๊ฒฉ์ํ์ ๋งจ ์ผ์ชฝ ์์์ ์์ํด์ ๋งจ ์ค๋ฅธ์ชฝ ์๋๊น์ง ๊ฐ์ผํ๋ค. ์ธ์ ํ ๋ค ๋ฐฉํฅ์ผ๋ก ํ ๋ฒ ์์ง์ด๋ ๊ฒ, ๋ง์ ์์ง์์ผ๋ก ํ ๋ฒ ์์ง์ด๋ ๊ฒ, ๋ชจ๋ ํ ๋ฒ์ ๋์์ผ๋ก ์น๋ค. ๊ฒฉ์ํ์ด ์ฃผ์ด์ก์ ๋, ์์ญ์ด๊ฐ ์ต์ํ์ ๋์์ผ๋ก ์์์ง์ ์์ ๋์ฐฉ์ง์ ๊น์ง ๊ฐ ์ ์๋ ๋ฐฉ๋ฒ์ ์์๋ด๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ ์ K๊ฐ ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์ ๊ฒฉ์ํ์ ๊ฐ๋ก๊ธธ์ด W, ์ธ๋ก๊ธธ์ด H๊ฐ ์ฃผ์ด์ง๋ค. ๊ทธ ๋ค์ H์ค์ ๊ฑธ์ณ W๊ฐ์ ์ซ์๊ฐ ์ฃผ์ด์ง๋๋ฐ, 0์ ์๋ฌด๊ฒ๋ ์๋ ํ์ง, 1์ ์ฅ์ ๋ฌผ์ ๋ปํ๋ค. ์ฅ์ ๋ฌผ์ด ์๋ ๊ณณ์ผ๋ก๋ ์ด๋ํ ์ ์๋ค. ์์์ ๊ณผ ๋์ฐฉ์ ์ ํญ์ ํ์ง์ด๋ค. W์ H๋ 1์ด์ 200์ดํ์ ์์ฐ์์ด๊ณ , K๋ 0์ด์ 30์ดํ์ ์ ์์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์์ญ์ด์ ๋์์์ ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค. ์์์ ์์ ๋์ฐฉ์ ๊น์ง ๊ฐ ์ ์๋ ๊ฒฝ์ฐ์ -1์ ์ถ๋ ฅํ๋ค.
1. ์์ด๋์ด
๐ก ๋ง์ฒ๋ผ ์ด๋ํ ํ์๋ฅผ ์ ์ฅํ๋ k์ ์ต์ ํ์๋ฅผ ์ ์ฅํ๋ cnt๋ฅผ ํฌํจํ Node class ์์ฑ
๐ก k๋ฅผ ๋ช๋ฒ ์ฌ์ฉํ๋์ง๋ฅผ ์ ์ฅํ๋ visited[][][]๋ฅผ ์ฌ์ฉ
๐ก k๋ฅผ ๋์ง ์์ผ๋ฉด, ๋ง์ฒ๋ผ ์ด๋
๐ก ๊ธฐ๋ณธ์ ์ผ๋ก ์์ญ์ด์ฒ๋ผ ์ด๋
๐ก ๋ง์ง๋ง ์นธ์ ๋๋ฌํ๋ฉด queue์์ pollํ cnt๊ฐ์ ์ถ๋ ฅํจ
2. ํต์ฌ ํ์ด
- ๋ง์ฒ๋ผ ์ด๋ํ ํ์๋ฅผ ์ ์ฅํ๋ k์ ์ต์ ํ์๋ฅผ ์ ์ฅํ๋ cnt๋ฅผ ํฌํจํ Node class ์์ฑ
static class Node{
	int x;
	int y;
	int cnt;
	int k;
	Node(int x, int y, int cnt, int k){
		this.x = x;
		this.y = y;
		this.cnt = cnt;
		this.k = k;
	}
}- k๋ฅผ ๋ช๋ฒ ์ฌ์ฉํ๋์ง๋ฅผ ์ ์ฅํ๋ visited[][][]๋ฅผ ์ฌ์ฉ
static boolean[][][] visited;- k๋ฅผ ๋์ง ์์ผ๋ฉด, ๋ง์ฒ๋ผ ์ด๋
if(now.k < k) {
	for(int i=0; i<8; i++) {
		int nx = now.x + dx1[i];
		int ny = now.y + dy1[i];
					
		if(nx >= h || ny >= w || nx<0 || ny<0)
			continue;
					
		if(board[nx][ny] != 1 && visited[nx][ny][now.k+1] == false) {
			q.add(new Node(nx, ny, now.cnt+1, now.k+1));
			visited[nx][ny][now.k+1] = true;
		}
	}
}- ๊ธฐ๋ณธ์ ์ผ๋ก ์์ญ์ด์ฒ๋ผ ์ด๋
for(int i=0; i<4; i++) {
	int nx = now.x + dx2[i];
	int ny = now.y + dy2[i];
				
	if(nx >= h || ny >= w || nx < 0 || ny < 0)
		continue;
				
	if(board[nx][ny] != 1 && visited[nx][ny][now.k] == false) {
		q.add(new Node(nx, ny, now.cnt+1, now.k));
		visited[nx][ny][now.k] = true;
	}
}- ๋ง์ง๋ง ์นธ์ ๋๋ฌํ๋ฉด queue์์ pollํ cnt๊ฐ์ ์ถ๋ ฅํจ
if(now.x == h-1 && now.y == w-1) {
	res = now.cnt;
	break;
}
...
System.out.println(res);3. ์ฝ๋
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Queue;
import java.util.LinkedList;
public class Bruteforce_5 {
	static int[] dx1 = {-1,1,-2,2,-2,2,-1,1};
	static int[] dx2 = {0,0,-1,1};
	static int[] dy1 = {2,2,1,1,-1,-1,-2,-2};
	static int[] dy2 = {-1,1,0,0};
	static int[][] board;
	static boolean[][][] visited; 
	static int k,w,h;
	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		k = Integer.parseInt(br.readLine());
		
		String[] s = br.readLine().split(" ");
		w = Integer.parseInt(s[0]);
		h = Integer.parseInt(s[1]);
		
		board = new int[h][w];
		visited = new boolean[h][w][k+1];
		
		for(int i=0; i<h; i++) {
			s = br.readLine().split(" ");
			for(int j=0; j<w; j++) {
				board[i][j] = Integer.parseInt(s[j]);
			}
		}
		
		bfs();
	}
	
	static void bfs() {
		Queue<Node> q = new LinkedList<>();
		int res = -1;
		q.add(new Node(0,0,0,0));
		visited[0][0][0] = true;
		
		while(!q.isEmpty()) {
			Node now = q.poll();
			
			if(now.x == h-1 && now.y == w-1) {
				res = now.cnt;
				break;
			}
			
			if(now.k < k) {
				for(int i=0; i<8; i++) {
					int nx = now.x + dx1[i];
					int ny = now.y + dy1[i];
					
					if(nx >= h || ny >= w || nx<0 || ny<0)
						continue;
					
					if(board[nx][ny] != 1 && visited[nx][ny][now.k+1] == false) {
						q.add(new Node(nx, ny, now.cnt+1, now.k+1));
						visited[nx][ny][now.k+1] = true;
					}
				}
			}
			
			for(int i=0; i<4; i++) {
				int nx = now.x + dx2[i];
				int ny = now.y + dy2[i];
				
				if(nx >= h || ny >= w || nx < 0 || ny < 0)
					continue;
				
				if(board[nx][ny] != 1 && visited[nx][ny][now.k] == false) {
					q.add(new Node(nx, ny, now.cnt+1, now.k));
					visited[nx][ny][now.k] = true;
				}
			}
		}
		
		System.out.println(res);
	}
	
	static class Node{
		int x;
		int y;
		int cnt;
		int k;
		Node(int x, int y, int cnt, int k){
			this.x = x;
			this.y = y;
			this.cnt = cnt;
			this.k = k;
		}
	}
}4. ๊ฒฐ๊ณผ


์ฑ๊ณตโจ
Author And Source
์ด ๋ฌธ์ ์ ๊ดํ์ฌ([Algorithm] ๐๋ฐฑ์ค 1600 ๋ง์ด ๋๊ณ ํ ์์ญ์ด), ์ฐ๋ฆฌ๋ ์ด๊ณณ์์ ๋ ๋ง์ ์๋ฃ๋ฅผ ๋ฐ๊ฒฌํ๊ณ ๋งํฌ๋ฅผ ํด๋ฆญํ์ฌ ๋ณด์๋ค https://velog.io/@kha0318/Algorithm-๋ฐฑ์ค-1600-๋ง์ด-๋๊ณ ํ-์์ญ์ด์ ์ ๊ท์: ์์์ ์ ๋ณด๊ฐ ์์์ URL์ ํฌํจ๋์ด ์์ผ๋ฉฐ ์ ์๊ถ์ ์์์ ์์ ์ ๋๋ค.
                                
                                
                                
                                
                                
                                ์ฐ์ํ ๊ฐ๋ฐ์ ์ฝํ
์ธ  ๋ฐ๊ฒฌ์ ์ ๋
                                (Collection and Share based on the CC Protocol.)
                            
์ข์ ์นํ์ด์ง ์ฆ๊ฒจ์ฐพ๊ธฐ
๊ฐ๋ฐ์ ์ฐ์ ์ฌ์ดํธ ์์ง
๊ฐ๋ฐ์๊ฐ ์์์ผ ํ ํ์ ์ฌ์ดํธ 100์ ์ถ์ฒ ์ฐ๋ฆฌ๋ ๋น์ ์ ์ํด 100๊ฐ์ ์์ฃผ ์ฌ์ฉํ๋ ๊ฐ๋ฐ์ ํ์ต ์ฌ์ดํธ๋ฅผ ์ ๋ฆฌํ์ต๋๋ค