【问题描述】
        小蓝在玩一个叫质数行者的游戏。
        游戏在一个 n × m × w 的立体方格图上进行,从北到南依次标号为第 1 行到第 n 行,从西到东依次标号为第 1 列到第 m 列,从下到上依次标号为第 1 层到第 w 层。
        小蓝要控制自己的角色从第 1 行第 1 列第 1 层移动到第 n 行第 m 列第 w层。每一步,他可以向东走质数格、向南走质数格或者向上走质数格。每走到一个位置,小蓝的角色要稍作停留。
        在游戏中有两个陷阱,分别为第 r 1 行第 c 1 列第 h 1 层和第 r 2 行第 c 2 列第h 2 层。这两个陷阱的位置可以跨过,但不能停留。也就是说,小蓝不能控制角色某一步正好走到陷阱上,但是某一步中间跨过了陷阱是允许的。
        小蓝最近比较清闲,因此他想用不同的走法来完成这个游戏。所谓两个走法不同,是指小蓝稍作停留的位置集合不同。
        请帮小蓝计算一下,他总共有多少种不同的走法。
        提示：请注意内存限制,如果你的程序运行时超过内存限制将不得分。

【输入格式】
输入第一行包含两个整数 n, m, w,表示方格图的大小。
第二行包含 6 个整数,r 1 , c 1 , h 1 , r 2 , c 2 , h 2 ,表示陷阱的位置。

【输出格式】
输出一行,包含一个整数,表示走法的数量。答案可能非常大,请输出答案除以 1000000007 的余数。

【样例输入】
5 6 1
3 4 1 1 2 1

【样例输出】
11

【样例说明】
用 (r, c, h) 表示第 r 行第 c 列第 h 层,可能的走法有以下几种:

1. (1, 1, 1) − (1, 3, 1) − (1, 6, 1) − (3, 6, 1) − (5, 6, 1)。
2. (1, 1, 1) − (1, 3, 1) − (3, 3, 1) − (3, 6, 1) − (5, 6, 1)。
3. (1, 1, 1) − (1, 3, 1) − (3, 3, 1) − (5, 3, 1) − (5, 6, 1)。
4. (1, 1, 1) − (3, 1, 1) − (3, 3, 1) − (3, 6, 1) − (5, 6, 1)。
5. (1, 1, 1) − (3, 1, 1) − (3, 3, 1) − (5, 3, 1) − (5, 6, 1)。
6. (1, 1, 1) − (3, 1, 1) − (5, 1, 1) − (5, 3, 1) − (5, 6, 1)。
7. (1, 1, 1) − (3, 1, 1) − (5, 1, 1) − (5, 4, 1) − (5, 6, 1)。
8. (1, 1, 1) − (1, 4, 1) − (1, 6, 1) − (3, 6, 1) − (5, 6, 1)。
9. (1, 1, 1) − (1, 6, 1) − (3, 6, 1) − (5, 6, 1)。
10. (1, 1, 1) − (3, 1, 1) − (3, 6, 1) − (5, 6, 1)。
11. (1, 1, 1) − (3, 1, 1) − (5, 1, 1) − (5, 6, 1)。
【评测用例规模与约定】
对于 30% 的评测用例 1 ≤ n, m, w ≤ 50。
对于 60% 的评测用例 1 ≤ n, m, w ≤ 300。
对于所有评测用例,1 ≤ n, m, w ≤ 1000,1 ≤ r 1 , r 2 ≤ n, 1 ≤ c 1 , c 2 ≤ m, 1 ≤ h 1 , h 2 ≤ w,陷阱不在起点或终点,两个陷阱不同。
【思路与分析】

        题目中已经友好地提示了：请注意内存限制,如果你的程序运行时超过内存限制将不得分。因此，使用常规的笨办法进行遍历是绝对要被淘汰的。那么如何进行优化呢？

        我想到的是：使用欧拉筛，筛出所有能够走到的质数步。然后新建一个二维数组，存储从任何非陷阱位置能够通过质数步走到的坐标。最后，输出即可。

        但该题通过上述思路并不能达到满分，只能OJ40%，剩下的测试用例都是计算超时，拿不到满分。测试用例的规模实在是太大了。

        苦于实在无法更进一步，于是学习了同站大佬红目香薰的代码。确实是思路清晰又很精干的代码，但是阅读量却很是惨淡，在此po出给有需要的小伙伴参考。

蓝桥杯官网 试题 PREV-253 历届真题 质数行者【第十一届】【决赛】【研究生组】【C++】【Java】两种解法_红目香薰的博客-CSDN博客

【代码：红目香薰大佬（满分）】

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
 
public class Main {
	public boolean bushu(int a, List<Integer> list) {
		boolean q = true;
		if (!list.contains(a)) {
			for (int i = 0; i < list.size(); i++) {
				int b = list.get(i);
				if (a % b == 0) {
					q = false;
					break;
				}
			}
		}
		if (q) {
			list.add(a);
		}
		return q;
	}
	public long niyuan(long a, long x,long mod)     //这里边做快速幂边取模
	{
		long ans = 1;
		while(x>0) 
		{
			if((x&1)!=0) 
				ans = (ans * a) %mod;
			a = (a * a) %mod;
			x >>= 1;
		}
		return ans;
	}
	public long all(int x,int y,int z,long[][] dp,long mod,long jiechen[],long niyuan[]) {
		long[] tmp=new long[x+y+z+1];
		long all=0;
		for(int i=1;i<=x;i++) {
			for(int j=1;j<=y;j++) {
				long bs=dp[x][i]*dp[y][j]%mod*jiechen[i+j]%mod*niyuan[i]%mod*niyuan[j]%mod;
				if(bs!=0) {
					tmp[i+j]=(tmp[i+j]+bs)%mod;
					all=all+tmp[i+j];
				}
			}
		}
		long ans=0;
		for(int i=0;i<=z;i++) {
			for(int j=0;j<=x+y;j++) {
				ans=ans+dp[z][i]*tmp[j]%mod*jiechen[i+j]%mod*niyuan[i]%mod*niyuan[j]%mod;
				ans=ans%mod;
			}
		}
		return ans;
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		long[][] dp;
		int xj[][]= new int[2][3];
		int zhishu[]=new int[169];
		long mod=1000000007;
		List<Integer> list = new ArrayList<Integer>();
		Main s=new Main();
		int i1=1;
		for (int i = 2; i < 1000; i++) {
			if (s.bushu(i, list)) {
				zhishu[i1++] = i;
			}
		}
		Scanner in = new Scanner(System.in);
		int x,y,z;
		x = in.nextInt();
		y = in.nextInt();
		z = in.nextInt();
		for (int i = 0; i < 2; i++) {
			for (int j = 0; j < 3; j++) {
				xj[i][j] = in.nextInt();
			}
		}
		int max=Math.max(x,Math.max(y, z));
		long[] jiechen=new long[max*3+1];
		long[] niyuan=new long[max*3+1];
		jiechen[1]=1;
		jiechen[0]=1;
		niyuan[1]=1;
		niyuan[0]=1;
		for(int i=2;i<max*3+1;i++) {
				jiechen[i]=(jiechen[i-1]*i)%mod;
		}
		for(int i=2;i<max*3+1;i++) {
			niyuan[i]=s.niyuan(jiechen[i],mod-2, mod);
		}
		dp=new long[max+1][max+1];
		dp[1][0]=1;
		for(int i=3;i<=max;i++) {
			for(int j=1;j<=i;j++) {
				for(int k=1;k<=168&&zhishu[k]<i;k++) {
					dp[i][j]=(dp[i][j]+dp[i-zhishu[k]][j-1])%mod;
				}
			}
		}
		long ans=s.all(x, y, z, dp, mod, jiechen,niyuan);
		ans=(ans-s.all(xj[0][0],xj[0][1],xj[0][2],dp, mod, jiechen,niyuan)*s.all(x-xj[0][0]+1, y-xj[0][1]+1, z-xj[0][2]+1, dp, mod, jiechen,niyuan)%mod+mod)%mod;
		ans=(ans-s.all(xj[1][0],xj[1][1],xj[1][2],dp, mod, jiechen,niyuan)*s.all(x-xj[1][0]+1, y-xj[1][1]+1, z-xj[1][2]+1, dp, mod, jiechen,niyuan)%mod+mod)%mod;
		if(xj[0][0]<=xj[1][0]&&xj[0][1]<=xj[1][1]&&xj[0][2]<=xj[1][2]) {
			ans=(ans+s.all(xj[0][0], xj[0][1],xj[0][2], dp, mod, jiechen,niyuan)*s.all(xj[1][0]-xj[0][0]+1, xj[1][1]-xj[0][1]+1,xj[1][2]-xj[0][2]+1, dp, mod, jiechen,niyuan)%mod*s.all(x-xj[1][0]+1, y-xj[1][1]+1,z-xj[1][2]+1, dp, mod, jiechen,niyuan)%mod)%mod;
		}
		if(xj[0][0]>=xj[1][0]&&xj[0][1]>=xj[1][1]&&xj[0][2]>=xj[1][2]) {
			ans=(ans+s.all(xj[1][0], xj[1][1],xj[1][2], dp, mod, jiechen,niyuan)*s.all(xj[0][0]-xj[1][0]+1, xj[0][1]-xj[1][1]+1,xj[0][2]-xj[1][2]+1, dp, mod, jiechen,niyuan)%mod*s.all(x-xj[0][0]+1, y-xj[0][1]+1,z-xj[0][2]+1, dp, mod, jiechen,niyuan)%mod)%mod;
		}
		System.out.println(ans);
	}
}

【代码：OJ率40%】

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int m = in.nextInt();
		int w = in.nextInt();
		int r1 = in.nextInt();
		int c1 = in.nextInt();
		int h1 = in.nextInt();
		int r2 = in.nextInt();
		int c2 = in.nextInt();
		int h2 = in.nextInt();
		
		long Max = 1000000007 ;
		
		long[][][] arr = new long[n+1][m+1][w+1];
		
		int max = n;
		max = Math.max(max, m);
		max = Math.max(max, w);
    int cnt = 0;
    int[] p = new int[max+1];
    int[] f = new int[max+1];
    for(int i=2;i<=max;i++) {
    	if(f[i]==0) p[cnt++] = i;
    	for(int j=0;j<cnt&&i*p[j]<=max;j++) {
    		f[i*p[j]]=1;
    		if(i%p[j]==0) break;
    	}
    }
   
    arr[1][1][1]=1;
    for(int i=1;i<=n;i++) {
    	for(int j=1;j<=m;j++) {
    		for(int k=1;k<=w;k++) {
    			for(int l=0;l<cnt;l++) {
    				if(i==r1&&j==c1&&k==h1) continue;
    				if(i==r2&&j==c2&&k==h2) continue;
    				//按题意进行输出
    				if(i-p[l]>=1) arr[i][j][k]=(arr[i][j][k]+arr[i-p[l]][j][k])%Max;
    				if(j-p[l]>=1) arr[i][j][k]=(arr[i][j][k]+arr[i][j-p[l]][k])%Max;
    				if(k-p[l]>=1) arr[i][j][k]=(arr[i][j][k]+arr[i][j][k-p[l]])%Max;
    			}
    		}
    	}
    }
    System.out.println(arr[n][m][w]);
	}
}