C++ :

#include <iostream>
#include <string>
#include <algorithm>
#include <string.h>
using namespace std;

const int M = 20;
const int N = 20;

int maze[M][N];

int visited[M][N];


int m, n;
bool dfs(int row, int col, int pre)
{
	if (row == m && col == n + 1)
		return true;
	if (row <1 || row >m || col < 1 || col > n)
		return false;
	if (visited[row][col] == 1)
		return false;

	int cur = maze[row][col];
	if (maze[row][col] == 0)
		return false;

	visited[row][col] = 1;

	if (cur <= 4)
	{
		if (pre == 1 || pre == 3)
		{
			if (dfs(row, col + 1, 2))	return true;
			if (dfs(row, col - 1, 4))	return true;
		}
		if (pre == 2 || pre == 4)
		{
			if (dfs(row - 1, col, 3))	return true;
			if (dfs(row + 1, col, 1))	return true;
		}
	}
	else
	{
		if (pre == 1)
		{
			if (dfs(row + 1, col, pre))	return true;
		}
		if (pre == 2)
		{
			if (dfs(row, col + 1, pre))	return true;
		}
		if (pre == 3)
		{
			if (dfs(row - 1, col, pre))	return true;
		}
		if (pre == 4)
		{
			if (dfs(row, col - 1, pre))	return true;
		}
	}
	visited[row][col] = 0;
	return false;
}


int main()
{
	while (cin >> m >> n)
	{
		for (int i = 1; i <= m; i++)
		{
			for (int j = 1; j <= n; j++)
				cin >> maze[i][j];
		}
		memset(visited, 0, sizeof(visited));

		if (dfs(1, 1, 2))
			cout << "yes" << endl;
		else
			cout << "no way" << endl;

		//cout << ret;
	}

	return 0;
}

Java :

import java.io.BufferedInputStream;
import java.util.Arrays;
import java.util.Scanner;


public class Main{
	public static void main(String[] args) {
		Scanner input = new Scanner(new BufferedInputStream(System.in));
		while(input.hasNext()){
			int M = input.nextInt();
			int N = input.nextInt();
			int[][] arr = new int[M][N];
			for(int i = 0;i < M;i++)
				for(int j = 0;j < N;j++)
					arr[i][j] = input.nextInt();
			boolean[] booleanArr = new boolean[1];
			boolean[][] visitedArr = new boolean[M][N]; 
			booleanArr[0] = false;
			for (boolean[] bs : visitedArr) {
				Arrays.fill(bs, false);
			}
			findWay(arr,0,0,1,booleanArr,visitedArr);
			System.out.println(booleanArr[0] ? "yes" : "no way");
		}
	}
	private static void findWay(int[][] arr,int x,int y,int direction,boolean[] booleanArr,boolean[][] visitedArr){
		if(booleanArr[0])
			return;
		if(x == arr.length - 1 && y == arr[0].length){
			booleanArr[0] = true;
			return;
		}
		if(x < 0 || y < 0 || x >= arr.length || y >= arr[0].length || visitedArr[x][y])
			return;
		visitedArr[x][y] = true;
		switch(arr[x][y]){
		case 1:
		case 2:
		case 3:
		case 4:
			if(direction == 0 || direction == 2){
				findWay(arr,x,y - 1,3,booleanArr,visitedArr);
				findWay(arr,x,y + 1,1,booleanArr,visitedArr);
			}else{
				findWay(arr,x - 1,y,0,booleanArr,visitedArr);
				findWay(arr,x + 1,y,2,booleanArr,visitedArr);
			}
			break;
		case 5:
		case 6:
			if(direction == 0){
				findWay(arr,x - 1,y,direction,booleanArr,visitedArr);
			}else if(direction == 1){
				findWay(arr,x,y + 1,direction,booleanArr,visitedArr);
			}else if(direction == 2){
				findWay(arr,x + 1,y,direction,booleanArr,visitedArr);
			}else if(direction == 3){
				findWay(arr,x,y - 1,direction,booleanArr,visitedArr);
			}
			break;
		default:
		}
		visitedArr[x][y] = false;
	}
}