HAPPY 1 振兴中华

小明参加了学校的趣味运动会，其中的一个项目是：跳格子。

地上画着一些格子，每个格子里写一个字，如下所示：（也可参见p1.jpg）

从我做起振
我做起振兴
做起振兴中
起振兴中华

比赛时，先站在左上角的写着“从”字的格子里，可以横向或纵向跳到相邻的格子里，但不能跳到对角的格子或其它位置。一直要跳到“华”字结束。


要求跳过的路线刚好构成“从我做起振兴中华”这句话。

请你帮助小明算一算他一共有多少种可能的跳跃路线呢？

答案是一个整数，请通过浏览器直接提交该数字。

注意：不要提交解答过程，或其它辅助说明类的内容。

一共有(8分)种可能的跳跃路线

方法一：递归

public class Main {

	private static char[][] a = { { '从', '我', '做', '起', '振' },
			{ '我', '做', '起', '振', '兴' }, { '做', '起', '振', '兴', '中' },
			{ '起', '振', '兴', '中', '华' } };

	private static int count; // 计数变量

	public static void main(String[] args) {
		count = 0;
		char[] b = new char[8];
		jump(0, 0, 0, b);
		System.out.println(count);
	}

	/**
	 * 模拟小明跳跃格子的递归方法
	 * 
	 * @param step
	 *            跳格子经过的步数，范围是0-7
	 * @param x
	 *            向下跳的位置，范围是0-3
	 * @param y
	 *            向右跳的位置，范围是0-4
	 * @param b
	 *            暂存跳过路线的一维数组
	 */
	private static void jump(int step, int x, int y, char[] b) {
		// *******递归出口**********
		if (x > 3) {
			return;
		}

		if (y > 4) {
			return;
		}

		if (step > 7) {
			return;
		}

		// 记录跳过的字
		b[step] = a[x][y];

		if (step == 7) {
			// 刚好走到8个字的位置
			if (check(b)) {
				count++;
			}
			return;
		}

		jump(step + 1, x + 1, y, b); // 向下跳
		jump(step + 1, x, y + 1, b); // 向右跳

	}

	// 检查数组内容是“从我做起振兴中华”
	private static boolean check(char[] b) {
		if ("从我做起振兴中华".equals(String.valueOf(b))) {
			return true;
		} else {
			return false;
		}
	}
}

方法二：

import java.util.*;

public class Main1 {
	
	
	 static int n=5,m=4;
	static int a[][]=new int[6][6];
	 static int vis[][]=new int[6][6];
	 static int cnt=0;
	 static int dir[][]= {{1,0},{0,1},{-1,0},{0,-1}};
	  public static void main(String[] args){
		  solve();
	  }
	 
	  public static void solve() {
		 Scanner sc=new Scanner(System.in);
		 
		
		for(int i=1;i<=4;i++)
			for(int j=1;j<=5;j++)
			{
				a[i][j]=i+j-1;
				vis[i][j]=0;
			}
		dfs(1,1);
		System.out.println(cnt);
	  }
	  public static void dfs(int row,int col)
	  {
		  vis[row][col]=1;
		  if(a[row][col]==8)cnt++;
		  for(int i=0;i<4;i++)  
		    {  
		        int dx=row+dir[i][0];  
		        int dy=col+dir[i][1];  
		        if(dx<1||dy<1||dx>4||dy>5)continue;  
		        else {
		        	if(vis[dx][dy]==0&&a[dx][dy]-a[row][col]==1)
		        	{
		        		vis[dx][dy]=1;
		        		dfs(dx,dy);
		        		vis[dx][dy]=0;
		        	}
		        }
		    }
	  }
}

方法三：

public class Main3 {
	public static void main(String[] args) {
		int[][] a = new int[4][5];
		int i;
		int j;
		for (i = 0; i < 4; i++)
			for (j = 0; j < 5; j++) {
				if (i == 0 || j == 0)
					a[i][j] = 1;
			}
		a[0][0] = 0;
		for (i = 1; i < 4; i++) {
			for (j = 1; j < 5; j++)
				a[i][j] = a[i - 1][j] + a[i][j - 1];
		}
		System.out.println(a[3][4]);
	}
}

方法四：

//递归
public class Main4 {


	public static int digui(int x, int y) {
		if (x == 3 || y == 4)
			return 1;// 因为只要到达边界就只有一条路可走
		return digui(x + 1, y) + digui(x, y + 1);
	}


	public static void main(String[] args) {
		
		System.out.println(digui(0, 0));
	}


}