描述

__ 有一个mn 大小的数据表，你会依次进行以下5种操作：
1.输入m和n ，初始化mn 大小的表格。
2.输入x1,y1,x2,y2,交换坐标在（x1，y1）和（x2，y2）的两个数。
3.输入x ，在第x 行上方添加一行。
4.输入y，在第y列左边添加一列。
5.输入x、y，查找坐标为(x,y)的单元格的值。
请编写程序，判断对表格的各种操作是否合法。

_


详细要求:


 1.数据表的最大规格为9行9列，对表格进行操作时遇到超出规格应该返回错误。
2.对于插入操作，如果插入后行数或列数超过9了则应返回错误。如果插入成功了则将数据表恢复至初始化的mn 大小，多出的数据则应舍弃。
3.所有输入坐标操作，对m*n大小的表格，行号坐标只允许0~m-1，列号坐标只允许0~n-1。超出范围应该返回错误。

本题含有多组样例输入！行列从0开始标号
数据范围：数据组数：1≤t≤5
进阶：时间复杂度：O(1)，空间复杂度：O(1)_


输入描述：

__ 输入数据按下列顺序输入：
1 表格的行列值
2 要交换的两个单元格的行列值
3 输入要插入的行的数值
4 输入要插入的列的数值
5 输入要查询的单元格的坐标

_


输出描述：

__ 输出按下列顺序输出：
1 初始化表格是否成功，若成功则返回0， 否则返回-1
2 输出交换单元格是否成功
3 输出插入行是否成功
4 输出插入列是否成功
5 输出查询单元格数据是否成功

_


示例1

__ 输入：
4 9
5 1 2 6
0
8
2 3
4 7
4 2 3 2
3
3
4 7

输出：
0
-1
0
-1
0
0
-1
0
0
-1

说明：
本组样例共有2组样例输入。
第一组样例：
1.初始化数据表为4行9列，成功
2.交换第5行1列和第2行6列的数据，失败。因为行的范围应该是(0,3)，不存在第5行。
3.在第0行上方添加一行，成功。
4.在第8列左边添加一列，失败。因为列的总数已经达到了9的上限。
5.查询第2行第3列的值，成功。
第二组样例：
1.初始化数据表为4行7列，成功
2.交换第4行2列和第3行2列的数据，失败。因为行的范围应该是(0,3)，不存在第4行。
3.在第3行上方添加一行，成功。
4.在第3列左边添加一列，成功。
5.查询第4行7列的值，失败。因为虽然添加了一行一列，但数据表会在添加后恢复成4行7列的形态，所以行的区间仍然在[0,3]，列的区间仍然在[0,6]，无法查询到(4,7)坐标。

_
�

  1. package com.xqny.logtest.nowcoder;
  3. import java.util.Scanner;
  5. /**
  6.  * @author Raint
  7.  * @date 2022年07月11日 14:44
  8.  */
  9. public class Main {
  11.     /**
  12.      描述
  13.      有一个m*n 大小的数据表，你会依次进行以下5种操作：
  14.      1.输入m和n ，初始化m*n 大小的表格。
  15.      2.输入x1,y1,x2,y2,交换坐标在（x1，y1）和（x2，y2）的两个数。
  16.      3.输入x ，在第x 行上方添加一行。
  17.      4.输入y，在第y列左边添加一列。
  18.      5.输入x、y，查找坐标为(x,y)的单元格的值。
  19.      请编写程序，判断对表格的各种操作是否合法。
  21.      详细要求:
  23.      1.数据表的最大规格为9行*9列，对表格进行操作时遇到超出规格应该返回错误。
  24.      2.对于插入操作，如果插入后行数或列数超过9了则应返回错误。如果插入成功了则将数据表恢复至初始化的m*n 大小，多出的数据则应舍弃。
  25.      3.所有输入坐标操作，对m*n大小的表格，行号坐标只允许0~m-1，列号坐标只允许0~n-1。超出范围应该返回错误。
  27.      本题含有多组样例输入！行列从0开始标号
  28.      数据范围：数据组数：1≤t≤5
  29.      进阶：时间复杂度：O(1)，空间复杂度：O(1)
  30.      输入描述：
  31.      输入数据按下列顺序输入：
  32.      1 表格的行列值
  33.      2 要交换的两个单元格的行列值
  34.      3 输入要插入的行的数值
  35.      4 输入要插入的列的数值
  36.      5 输入要查询的单元格的坐标
  38.      输出描述：
  39.      输出按下列顺序输出：
  40.      1 初始化表格是否成功，若成功则返回0， 否则返回-1
  41.      2 输出交换单元格是否成功
  42.      3 输出插入行是否成功
  43.      4 输出插入列是否成功
  44.      5 输出查询单元格数据是否成功
  46.      示例1
  47.      输入：
  48.      4 9
  49.      5 1 2 6
  50.      0
  51.      8
  52.      2 3
  54.      4 7
  55.      4 2 3 2
  56.      3
  57.      3
  58.      4 7
  60.      输出：
  61.      0
  62.      -1
  63.      0
  64.      -1
  65.      0
  67.      0
  68.      -1
  69.      0
  70.      0
  71.      -1
  73.      说明：
  74.      本组样例共有2组样例输入。
  75.      第一组样例：
  76.      1.初始化数据表为4行9列，成功
  77.      2.交换第5行1列和第2行6列的数据，失败。因为行的范围应该是(0,3)，不存在第5行。
  78.      3.在第0行上方添加一行，成功。
  79.      4.在第8列左边添加一列，失败。因为列的总数已经达到了9的上限。
  80.      5.查询第2行第3列的值，成功。
  81.      第二组样例：
  82.      1.初始化数据表为4行7列，成功
  83.      2.交换第4行2列和第3行2列的数据，失败。因为行的范围应该是(0,3)，不存在第4行。
  84.      3.在第3行上方添加一行，成功。
  85.      4.在第3列左边添加一列，成功。
  86.      5.查询第4行7列的值，失败。因为虽然添加了一行一列，但数据表会在添加后恢复成4行7列的形态，所以行的区间仍然在[0,3]，列的区间仍然在[0,6]，无法查询到(4,7)坐标。
  87.      */
  88.     public static void main(String[] args) {
  89.         Scanner sc = new Scanner(System.in);
  90.         int r, c, r1, c1, r2, c2, ri, ci, rt, ct;
  91.         while (sc.hasNext()) {
  92.             r = sc.nextInt();
  93.             c = sc.nextInt();
  94.             r1 = sc.nextInt();
  95.             c1 = sc.nextInt();
  96.             r2 = sc.nextInt();
  97.             c2 = sc.nextInt();
  98.             ri = sc.nextInt();
  99.             ci = sc.nextInt();
  100.             rt = sc.nextInt();
  101.             ct = sc.nextInt();
  103.             // 最大规格为9行*9列
  104.             if (r <= 9 && c <= 9) {
  105.                 System.out.println(0);
  106.             } else {
  107.                 System.out.println(-1);
  108.             }
  109.             // 最大规格为9行*9列，对表格进行操作时遇到超出规格应该返回错误。
  110.             if ((r1 < r && r2 < r) && (c1 < c && c2 < c)) {
  111.                 System.out.println(0);
  112.             } else {
  113.                 System.out.println(-1);
  114.             }
  115.             //插入行和列的时候,要注意,只有在原来的行和列是小于9的情况下才能插入
  116.             //如果插入成功了则将数据表恢复至初始化的m*n 大小，多出的数据则应舍弃。
  117.             if (ri < r && r < 9) {
  118.                 System.out.println(0);
  119.             } else {
  120.                 System.out.println(-1);
  121.             }
  122.             if (ci < c && c < 9) {
  123.                 System.out.println(0);
  124.             } else {
  125.                 System.out.println(-1);
  126.             }
  127.             //无论怎么插入行和列, 表格永远是初始的规格大小
  128.             if (rt < r && ct < c) {
  129.                 System.out.println(0);
  130.             } else {
  131.                 System.out.println(-1);
  132.             }
  133.         }
  134.         sc.close();
  135.     }
  136. }