2020十一届蓝桥杯国赛二等奖Java B组

最新推荐文章于 2024-05-16 00:13:46 发布

置顶 Motongxue

最新推荐文章于 2024-05-16 00:13:46 发布

阅读量2.6k

点赞数 10

分类专栏：算法文章标签： java 蓝桥杯真题十一届国赛

本文链接：https://blog.csdn.net/crazymooo/article/details/109683186

版权

算法专栏收录该内容

8 篇文章 1 订阅

订阅专栏

大家觉得写还可以，可以点赞、收藏、关注一下吧！
也可以到我的个人博客参观一下，估计近几年都会一直更新！和我做个朋友吧！https://motongxue.cn

文章目录

参考博客https://blog.csdn.net/qq_43449564/article/details/109703534
2020十一届蓝桥杯国赛二等奖Java B组

参考博客https://blog.csdn.net/qq_43449564/article/details/109703534

2020十一届蓝桥杯国赛二等奖Java B组

#A 美丽的 2

本题总分：5 分

问题描述

小蓝特别喜欢 2 ，今年是公元 2020年，他特别高兴。
他很好奇，在公元 1 年到公元 2020 年（包含）中，有多少个年份的数位中包含数字 2 ？

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

563

分析

跟省赛的第一题超像，不过比省赛的第一题简单，就一个枚举判断。

下面是一种思路；
第二种思路也可以把整数转为字符串，然后利用字符串的indexOf函数直接判断是否为-1即可

代码

public class A {
    public static void main(String[] args) {
        int res = 0;
        for (int i = 1; i <= 2020; i++)
              if (check(i)) {
                  res++;
              }
        System.out.println(res);
    }

    static boolean check(int n) {
        while(n!=0){
            if(n%10==2)
                return true;
            n/=10;
        }
        return false;
    }
}

#B 扩散

本题总分：5 分

问题描述

小蓝在一张无限大的特殊画布上作画。
这张画布可以看成一个方格图，每个格子可以用一个二维的整数坐标表示。
小蓝在画布上首先点了一下几个点：(0 , 0 )，(2020 , 11 )，(11 , 14 )，(2000 , 2000 )。只有这几个格子上有黑色，其它位置都是白色的。
每过一分钟，黑色就会扩散一点。具体的，如果一个格子里面是黑色，它就会扩散到上、下、左、右四个相邻的格子中，使得这四个格子也变成黑色（如果原来就是黑色，则还是黑色）。
请问，经过 2020 分钟后，画布上有多少个格子是黑色的。

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

20312088

分析

注意，由于每分钟扩散一次，如果按照所给坐标直接定义的话，经过2020分钟，数组会越界，所以

需要将每个下标至少加上2020（数值自己可选，我自己选择2500）防止越界。
然后就是BFS模板按步数走下去。
最终每个点都扩散完了，需要一个扫描，看总共有多少个点为黑色。

代码


/*
* @Author: motongxue
* @LastEditTime: 2020-11-15 21:04:04
* @Blog: https://motongxue.cn
* @Description: 
*/
import java.util.LinkedList;

public class B {
    static int[][] dir = new int[][] { 
        { 1, 0 }, 
        { -1, 0 }, 
        { 0, 1 }, 
        { 0, -1 } };
    static boolean[][] vis;
    static boolean[][] realAns = new boolean[7500][7500];   // 记录最终答案，必须新开一个答案数组。而不能直接放在标记数组中
    static int[][] arr = new int[][] { 
        { 0 + 2500, 0 + 2500 }, 
        { 2020 + 2500, 11 + 2500 }, 
        { 11 + 2500, 14 + 2500 },
        { 2000 + 2500, 2000 + 2500 } };

    static void bfs(int x, int y) {
        LinkedList<Integer> qx = new LinkedList<>();
        LinkedList<Integer> qy = new LinkedList<>();
        vis  = new boolean[7500][7500]; //  每次重置标记数组
        qx.addLast(x);
        qy.addLast(y);
        vis[x][y] = true;
        realAns[x][y] = true;
        int step = 2020;    //  步数
        while (qx.size() != 0) {
            int len = qx.size();
            for (int k = 0; k < len; k++) {
                int tx = qx.removeFirst();
                int ty = qy.removeFirst();
                for (int i = 0; i < 4; i++) {
                    int dx = tx + dir[i][0];
                    int dy = ty + dir[i][1];
                    // 由于我们扩大了数组，所以不需要判断数组越界
                    if (!vis[dx][dy]) {
                        realAns[dx][dy] = true;
                        vis[dx][dy] = true;
                        qx.addLast(dx);
                        qy.addLast(dy);
                    }
                }
            }
            if(--step==0)return;
        }
    }
    public static void main(String[] args) {
        for (int i = 0; i < arr.length; i++)
            bfs(arr[i][0], arr[i][1]);
        long res = 0;
        for (int i = 0; i < realAns.length; i++)
            for (int j = 0; j < realAns[0].length; j++)
                if (realAns[i][j])
                    res++;
        System.out.println(res);
    }
}

写完代码才发现，题目需要灵活变化的点还挺多的。

我们队列qx、qy每次都需要重新初始化，因为当2020分钟结束后，队列不可能为空
一开始我以为直接用一个vis数组标记就行，记录最终答案即可，然后发现，当我前一个点走过后，第二个点开始扩散时，会因为第一个点标记vis[dx][dy]=true而不走这个点，所以需要创建一个全局变量realAns[][]存每次的答案，并且每次新的扩散点，vis[][]需要重新初始化。我大E了
测试第1、2个分钟时，数据正确，是因为分钟太小了，导致他们不会重叠，不会出现第2点的情况

#C 阶乘约数

本题总分：10 分

问题描述

定义阶乘 n ! = 1 × 2 × 3 × ⋅ ⋅ ⋅ × n 。

请问 100 ! （100 的阶乘）有多少个约数。

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

39001250856960000

分析

数学方面的不会，有模板，要是没学过就真的不会

代码

import java.math.BigInteger;

public class C {

    public static void main(String[] args) {
        BigInteger num = BigInteger.ONE;
        for (int i = 1; i <= 100; i++)
            num = num.multiply(new BigInteger(String.valueOf(i)));
        long res = 1;
        for (BigInteger i = new BigInteger("2"); i.multiply(i).compareTo(num) <= 0; i = i.add(BigInteger.ONE)) {
            long cnt = 1;
            while (num.mod(i).compareTo(BigInteger.ZERO) == 0) {
                num = num.divide(i);
                cnt++;
            }
            if (cnt > 1)
                res *= cnt;
        }
        if (num.compareTo(BigInteger.ONE) > 0) res <<= 1;
        System.out.println(res);
    }
}

算术基本定理求约数个数

public class Test {

    public static void main(String[] args) { System.out.println(factors(100)); }

    static int factors(long n) {
        int res = 1, now;
        for (int i = 2; i * i <= n; i++) {
            now = 1;
            while (n % i == 0) {
                n /= i;
                now++;
            }
            if (now > 1)
                res *= now;
        }
        return n > 1? res << 1 : res;
    }
}

#D 本质上升序列

本题总分：10 分

问题描述

小蓝特别喜欢单调递增的事物。
在一个字符串中，如果取出若干个字符，将这些字符按照在字符串中的顺序排列后是单调递增的，则成为这个字符串中的一个单调递增子序列。
例如，在字符串 lanqiao 中，如果取出字符 n 和 q，则 nq 组成一个单调递增子序列。类似的单调递增子序列还有 lnq、i、ano 等等。
小蓝发现，有些子序列虽然位置不同，但是字符序列是一样的，例如取第二个字符和最后一个字符可以取到 ao，取最后两个字符也可以取到 ao。小蓝认为他们并没有本质不同。
对于一个字符串，小蓝想知道，本质不同的递增子序列有多少个？
例如，对于字符串 lanqiao，本质不同的递增子序列有 21 个。它们分别是 l、a、n、q、i、o、ln、an、lq、aq、nq、ai、lo、ao、no、io、lnq、anq、lno、ano、aio。
请问对于以下字符串（共 200 个小写英文字母，分四行显示）：（如果你把以下文字复制到文本文件中，请务必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 inc.txt，内容与下面的文本相同）

tocyjkdzcieoiodfpbgcncsrjbhmugdnojjddhllnofawllbhfiadgdcdjstemphmnjihecoapdjjrprrqnhgccevdarufmliqijgihhfgdcmxvicfauachlifhafpdccfseflcdgjncadfclvfmadvrnaaahahndsikzssoywakgnfjjaihtniptwoulxbaeqkqhfwl

本质不同的递增子序列有多少个？

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

3616159

分析

当时的思路是采用最暴力的组合函数。求出从n个数中取出k个。然后直接判断是否满足递增。然而，组合函数给忘了怎么写，导致这道题没写出来。下面是别人的思路。

代码

import java.io.IOException;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;

public class Test {

    public static void main(String[] args) throws IOException {
        System.setIn(new FileInputStream("inc.txt"));
        String str = new BufferedReader(new InputStreamReader(System.in)).readLine();
        Set set = new HashSet();
        dfs(0, '\0', str, new StringBuilder(), set);
        set.remove("");
        System.out.println(set.size());
    }

    static void dfs(int cur, char last, String str, StringBuilder buff, Set<String> set) {
        if (cur == str.length()) set.add(buff.toString());
        else {
            dfs(cur + 1, last, str, buff, set);
            if (str.charAt(cur) > last) {
                int tmp = buff.length();
                buff.append(str.charAt(cur));
                dfs(cur + 1, str.charAt(cur), str, buff, set);
                buff.deleteCharAt(tmp);
            }
        }
    }
}

看了下数据规模，就直接开个线程暴搜了

讲武德的一般都上动规

import java.io.IOException;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class Test {

    public static void main(String[] args) throws IOException {
        System.setIn(new FileInputStream("inc.txt"));
        String str = new BufferedReader(new InputStreamReader(System.in)).readLine();
        int[][] dp = new int[201][27];
        for (int i = 0; i < 200; i++)
            dp[i + 1][str.charAt(i) - 'a' + 1] = 1;
        for (int i = 1; i <= 200; i++) {
            int now =  str.charAt(i - 1) - 'a' + 1;
            for (int j = 1; j <= 26; j++)
                 dp[i][j] = dp[i - 1][j];
            dp[i][now] = 1;
            for (int j = 1; j < now; j++)
              dp[i][now] += dp[i - 1][j];
        }
        long res = 0;
        for (int i = 1; i <= 26; i++)
            res += dp[200][i];
        System.out.println(res);
    }
}

#E 玩具蛇

本题总分：15 分

问题描述

小蓝有一条玩具蛇，一共有 16 节，上面标着数字 1 至 16 。每一节都是一个正方形的形状。相邻的两节可以成直线或者成 90 度角。
小蓝还有一个 4 × 4 的方格盒子，用于存放玩具蛇，盒子的方格上依次标着字母 A 到 P 共 16 个字母。
小蓝可以折叠自己的玩具蛇放到盒子里面。他发现，有很多种方案可以将玩具蛇放进去。
下图给出了两种方案：
在这里插入图片描述
请帮小蓝计算一下，总共有多少种不同的方案。如果两个方案中，存在玩
具蛇的某一节放在了盒子的不同格子里，则认为是不同的方案。

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

552

分析

不出意外就是一个暴力DFS而已。答案也跟网上大多数相同，一开始忘了mp[i][j] = true;mp[i][j] = false;憨憨了。。。

答案

/*
* @Author: motongxue
 * @LastEditTime: 2020-11-15 21:26:35
 * @Blog: https://motongxue.cn
 * @Description: 
 */

public class E {
    static boolean[][] mp = new boolean[4][4];
    static long cnt = 0;

    static void dfs(int x, int y, int step) {
        if (x > 0 && !mp[x - 1][y]) {
            mp[x - 1][y] = true;
            dfs(x - 1, y, step + 1);
            mp[x - 1][y] = false;
        }
        if (y > 0 && !mp[x][y - 1]) {
            mp[x][y - 1] = true;
            dfs(x, y - 1, step + 1);
            mp[x][y - 1] = false;
        }
        if (x < 3 && !mp[x + 1][y]) {
            mp[x + 1][y] = true;
            dfs(x + 1, y, step + 1);
            mp[x + 1][y] = false;
        }
        if (y < 3 && !mp[x][y + 1]) {
            mp[x][y + 1] = true;
            dfs(x, y + 1, step + 1);
            mp[x][y + 1] = false;
        }
        // 四个方向都遍历完了之后
        if (step == 16)
            cnt++;
    }

    public static void main(String[] args) {
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                mp[i][j] = true;
                dfs(i,j,1);
                mp[i][j] = false;
            }
        }
        System.out.println(cnt);
    }
}

#F 蓝肽子序列

时间限制: 1.0s 内存限制: 512.0MB 本题总分：15 分

问题描述

L 星球上的生物由蛋蓝质组成，每一种蛋蓝质由一类称为蓝肽的物资首尾连接成一条长链后折叠而成。
生物学家小乔正在研究 L 星球上的蛋蓝质。她拿到两个蛋蓝质的蓝肽序列，想通过这两条蓝肽序列的共同特点来分析两种蛋蓝质的相似性。
具体的，一个蓝肽可以使用 1 至 5 个英文字母表示，其中第一个字母大写，后面的字母小写。一个蛋蓝质的蓝肽序列可以用蓝肽的表示顺序拼接而成。
在一条蓝肽序列中，如果选取其中的一些位置，把这些位置的蓝肽取出，并按照它们在原序列中的位置摆放，则称为这条蓝肽的一个子序列。蓝肽的子序列不一定在原序列中是连续的，中间可能间隔着一些未被取出的蓝肽。
如果第一条蓝肽序列可以取出一个子序列与第二条蓝肽序列中取出的某个子序列相等，则称为一个公共蓝肽子序列。
给定两条蓝肽序列，找出他们最长的那个公共蓝肽子序列的长度。

输入格式

输入两行，每行包含一个字符串，表示一个蓝肽序列。字符串中间没有空格等分隔字符。

输出格式

输出一个整数，表示最长的那个公共蓝肽子序列的长度。

测试样例1

Input：
LanQiaoBei
LanTaiXiaoQiao

Output：
2

Explanation：
最长的公共蓝肽子序列为 LanQiao，共两个蓝肽。
123456789

评测用例规模与约定

对于 20 2020% 的评测用例，两个字符串的长度均不超过 20 。
对于 50 5050% 的评测用例，两个字符串的长度均不超过 100 。
对于所有评测用例，两个字符串的长度均不超过 1000 。

分析

分析出来的结果是从蓝肽序列组成的最长公共子序列，区别是，此时最小单位不再是字符，而是字符串，那么我们可以算出字符串的hashCode，存进int[]，不就可以把问题转化为我们常见的最长公共子序列，然后套模板就可以开开心心水题了。😝

考场上的做法是

将每个由大写单词开头的单词组成一个蓝肽序列存进String[]中，即String[] ss = {"Lan","Qiao","Bei"};
通过String的hashCode方法算出每个字符串代表的哈希值
最后通过哈希值，算出最长公共子序列

代码

这道题中，如果你熟悉最长公共子序列的模板（应该熟悉吧？前几面真题都是填空题来着，应该熟悉吧？应该？），
最难的应该是将字符串截取成String[] ss = {"Lan","Qiao","Bei"};
截取完通过hashCode转为int[]字符串，套模板就求出来了，时间复杂度看起来是稳过的

#G 皮亚诺曲线距离

时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分

问题描述

皮亚诺曲线是一条平面内的曲线。
下图给出了皮亚诺曲线的 1 11 阶情形，它是从左下角出发，经过一个 3 × 3 3 × 33×3 的方格中的每一个格子，最终到达右上角的一条曲线。
在这里插入图片描述
下图给出了皮亚诺曲线的 2 22 阶情形，它是经过一个 3 2 × 3 2 3^{2} × 3^{2}32×32 的方格中的每一个格子的一条曲线。它是将 1 11 阶曲线的每个方格由 1 11 阶曲线替换而成。

在这里插入图片描述
下图给出了皮亚诺曲线的 3 33 阶情形，它是经过一个 3 3 × 3 3 3^{3} × 3^{3}33×33 的方格中的每一个格子的一条曲线。它是将 2 22 阶曲线的每个方格由 1 11 阶曲线替换而成。

皮亚诺曲线总是从左下角开始出发，最终到达右上角。
我们将这些格子放到坐标系中，对于 k 阶皮亚诺曲线，左下角的坐标是
(0 , 0 )，右上角坐标是 ( $3^{k} − 1$ , $3^{k} − 1$ )，右下角坐标是 ( $3^{k} − 1$ , 0 )，左上角坐标是(0 , $3^{k} − 1$ )。
给定 k 阶皮亚诺曲线上的两个点的坐标，请问这两个点之间，如果沿着皮亚诺曲线走，距离是到少？

输入格式

输入的第一行包含一个正整数 k ，皮亚诺曲线的阶数。
第二行包含两个整数 x 1 , y 1 ，表示第一个点的坐标。
第三行包含两个整数 x 2 , y 2 ，表示第二个点的坐标。

输出格式

输出一个整数，表示给定的两个点之间的距离。

测试样例1

Input：
1
0 0
2 2

Output：
8

测试样例2

Input：
2
0 2
0 3

Output：
13

评测用例规模与约定
对于 30 % 的评测用例，0 ≤ k ≤ 10 。
对于 50 % 的评测用例，0 ≤ k ≤ 20 。
对于所有评测用例，0 ≤ k ≤ 100 , 0 ≤ x1 , y1 , x2 , y2 < 3 ^k , x 1 , y 1 , x 2 , y 2 ≤ 1 0¹⁸。
数据保证答案不超过 1 0¹⁸。

分析

我不行，看到这种题完全没心思做，你肯定可以！加油鸭😭

代码

#H 画廊

时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分

问题描述

小蓝办了一个画展，在一个画廊左右两边陈列了他自己的作品。为了使画展更有意思，小蓝没有等距陈列自己的作品，而是按照更有艺术感的方式陈列。
在画廊的左边陈列了 L 幅作品，在画廊的右边陈列了 R 幅作品，左边的作品距离画廊的起点依次为 u1, u2, · · · , uL，右边的作品距离画廊起点依次为 v1, v2, · · · , vR。
每周，小蓝要整理一遍自己的每一幅作品。整理一幅作品的时间是固定的，但是要带着沉重的工具。从一幅作品到另一幅作品之间的距离为直线段的长度。
小蓝从画廊的起点的正中央（左右两边的中点）出发，整理好每一幅画，最终到达画廊的终点的正中央。已知画廊的宽为 w 。
请问小蓝最少带着工具走多长的距离？

输入格式

输入的第一行包含四个整数 L , R , d , w，表示画廊左边和右边的作品数量，
以及画廊的长度和宽度。
第二行包含 L 个正整数 u1, u2, · · · , uL，表示画廊左边的作品的位置。
第三行包含 R 个正整数 v1, v2, · · · , vR，表示画廊右边的作品的位置。

输出格式

输出一个实数，四舍五入保留两位小数，表示小蓝最少带着工具走的距离。

测试样例1

Input：
3 3 10 2
1 3 8
2 4 6

Output：
14.71

Explanation：
小蓝从起点开始，首先到达左边第一幅作品（走动距离 √2），然后到达左
边第二幅作品（走动距离 2），然后到达右边第一幅作品（走动距离 √5），然后
到达右边第二幅和第三幅作品（走动距离 2 和 2），然后到达左边第三幅作品（走动距离 2√2），最后到达画廊终点（走动距离 √5）。
总共距离为 √2 + 2 + √5 + 2 + 2 + 2 √2 + √5 ≈ 14.71。

评测用例规模与约定

对于 40 % 的评测用例，1 ≤ L , R ≤ 10 , 1 ≤ d ≤ 100 , 1 ≤ w ≤ 100 。
对于 70 % 的评测用例，1 ≤ L , R ≤ 100 , 1 ≤ d ≤ 1000 , 1 ≤ w ≤ 1000 。
对于所有评测用例，1 ≤ L , R ≤ 500 , 1 ≤ d ≤ 100000 , 1 ≤ w ≤ 100000 ,0≤ u1＜ u2 < ⋅ ⋅ ⋅ < uL ≤ d , 0≤ v1 < v2 < ⋅ ⋅ ⋅ < vR ≤ d 。

分析

考场上没读懂题😥是我太菜了，别骂了别骂了

代码

#I 补给

时间限制: 1.0s 内存限制: 512.0MB 本题总分：25 分

问题描述

小蓝是一个直升飞机驾驶员，他负责给山区的 n 个村庄运送物资。每个月，他都要到每个村庄至少一次，可以多于一次，将村庄需要的物资运送过去。每个村庄都正好有一个直升机场，每两个村庄之间的路程都正好是村庄之间的直线距离。
由于直升机的油箱大小有限，小蓝单次飞行的距离不能超过 D 。每个直升机场都有加油站，可以给直升机加满油。
每个月，小蓝都是从总部出发，给各个村庄运送完物资后回到总部。如果方便，小蓝中途也可以经过总部来加油。
总部位于编号为 1 的村庄。
请问，要完成一个月的任务，小蓝至少要飞行多长距离？

输入格式

输入的第一行包含两个整数 n , D ，分别表示村庄的数量和单次飞行的距离。
接下来 n 行描述村庄的位置，其中第 i 行两个整数 xi,yi，表示编号为 i 的村庄的坐标。村庄 i 和村庄 j 之间的距离为 $\sqrt{(x_{i} − x_{j})^{2} + (y_{i} − y_{j})^{2}}$ 。

输出格式

输出一行，包含一个实数，四舍五入保留正好 2 22 位小数，表示答案。

测试样例1

Input：
4 10
1 1
5 5
1 5
5 1

Output：
16.00

Explanation：
四个村庄形成一个正方形的形状。

测试样例2

Input：
4 6
1 1
4 5
8 5
11 1

Output：
28.00

Explanation：
补给顺序为 1 → 2 → 3 → 4 → 3 → 2 → 1。

评测用例规模与约定

对于所有评测用例， $1 ≤ n ≤ 20, 1 ≤ x_{i}, y_{i} ≤ 10^{4}, 1 ≤ D ≤ 10^{5}$ 。

分析

#J 质数行者

时间限制: 10.0s 内存限制: 512.0MB 本题总分：25 分

问题描述

小蓝在玩一个叫质数行者的游戏。
游戏在一个 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 的余数。

测试样例1

Input：
5 6 1
3 4 1 1 2 1

Output：
11

Explanation：
用 (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$ ，陷阱不在起点或终点，两个陷阱不同。

分析

代码

2020年11月14日更

大家觉得写还可以，可以点赞、收藏、关注一下吧！
也可以到我的个人博客参观一下，估计近几年都会一直更新！和我做个朋友吧！https://motongxue.cn

Motongxue

关注

10
点赞
踩
29

收藏

觉得还不错? 一键收藏
21
评论
2020十一届蓝桥杯国赛二等奖Java B组

大家觉得写还可以，可以点赞、收藏、关注一下吧！也可以到我的个人博客参观一下，估计近几年都会一直更新！和我做个朋友吧！https://motongxue.cn文章目录2020十一届蓝桥杯国赛Java B组先占坑，比完赛来填坑????求关注，写着写着没粉丝没动力了呜呜呜????2020十一届蓝桥杯国赛Java B组先占坑，比完赛来填坑????求关注，写着写着没粉丝没动力了呜呜呜????2020年11月14日更大家觉得写还可以，可以点赞、收藏、关注一下吧！也可以到我的个人博客参观一下，估计近几
复制链接

扫一扫

专栏目录