试题名称： I’m stuck!

时间限制： 1.0s

内存限制： 256.0MB

问题描述：　

问题描述
　　给定一个R行C列的地图，地图的每一个方格可能是'#', '+', '-', '|', '.', 'S', 'T'七个字符中的一个，分别表示如下意思：
　　'#': 任何时候玩家都不能移动到此方格；
　　'+': 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；
　　'-': 当玩家到达这一方格后，下一步可以向左右两个方向相邻的一个非'#'方格移动一格；
　　'|': 当玩家到达这一方格后，下一步可以向上下两个方向相邻的一个非'#'方格移动一格；
　　'.': 当玩家到达这一方格后，下一步只能向下移动一格。如果下面相邻的方格为'#'，则玩家不能再移动；
　　'S': 玩家的初始位置，地图中只会有一个初始位置。玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；
　　'T': 玩家的目标位置，地图中只会有一个目标位置。玩家到达这一方格后，可以选择完成任务，也可以选择不完成任务继续移动。如果继续移动下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格。
　　此外，玩家不能移动出地图。
　　请找出满足下面两个性质的方格个数：
　　1. 玩家可以从初始位置移动到此方格；
　　2. 玩家不可以从此方格移动到目标位置。
输入格式
　　输入的第一行包括两个整数R 和C，分别表示地图的行和列数。(1 ≤ R, C ≤ 50)。
　　接下来的R行每行都包含C个字符。它们表示地图的格子。地图上恰好有一个'S'和一个'T'。
输出格式
　　如果玩家在初始位置就已经不能到达终点了，就输出“I'm stuck!”（不含双引号）。否则的话，输出满足性质的方格的个数。
样例输入
5 5
--+-+
..|#.
..|##
S-+-T
####.
样例输出
2
样例说明
　　如果把满足性质的方格在地图上用'X'标记出来的话，地图如下所示：
　　--+-+
　　..|#X
　　..|##
　　S-+-T
　　####X
　

解题思路:　

　　　　1、深度遍历，选择队列。

　　　　2、方向和图形符号相互对应。

　　

　　　　

根据标准代码分析（java）：

　　

  1.  package ccf_text2013_12;
  2.  
  3.  import java.util.*;
  4.  /**
  5.   * I'm stuck!
  6.   * 　　给定一个R行C列的地图，地图的每一个方格可能是'#', '+', '-', '|', '.', 'S', 'T'七个字符中的一个，分别表示如下意思：
  7.  　　'#': 任何时候玩家都不能移动到此方格；
  8.  　　'+': 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；
  9.  　　'-': 当玩家到达这一方格后，下一步可以向左右两个方向相邻的一个非'#'方格移动一格；
  10.  　　'|': 当玩家到达这一方格后，下一步可以向上下两个方向相邻的一个非'#'方格移动一格；
  11.  　　'.': 当玩家到达这一方格后，下一步只能向下移动一格。如果下面相邻的方格为'#'，则玩家不能再移动；
  12.  　　'S': 玩家的初始位置，地图中只会有一个初始位置。玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；
  13.  　　'T': 玩家的目标位置，地图中只会有一个目标位置。玩家到达这一方格后，可以选择完成任务，也可以选择不完成任务继续移动。如果继续移动下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格。
  14.  　　此外，玩家不能移动出地图。
  15.  　　请找出满足下面两个性质的方格个数：
  16.  　　1. 玩家可以从初始位置移动到此方格；
  17.  　　2. 玩家不可以从此方格移动到目标位置。
  18.   * @author Hello stranger
  19.   *
  20.   */
  21.  public class ImStuck2 {
  22.  
  23.      public static void main(String[] args) {
  24.  
  25.          new ImStuck2().run();
  26.      }
  27.  
  28.      public void run() {
  29.  
  30.          Scanner fin = new Scanner(System.in);
  31.  
  32.          int R = fin.nextInt();
  33.  
  34.          int C = fin.nextInt();            //判断图形的行和列
  35.  
  36.          String first = fin.nextLine();   //跳过输入的换行（输入行列之后会打一个换行）
  37.  
  38.          //System.out.println(first);
  39.  
  40.          int[][] board = new int[R + 2][C + 2];
  41.  
  42.          char[][] picture = new char[R][C];  //为了验证计算出的结果是否在图形上显示正确
  43.  
  44.          int rowStart = 0, colStart = 0, rowEnd = 0, colEnd = 0;  //起点和终点所在的行列
  45.  
  46.          for (int i = 1; i <= R; ++i) {    
  47.  
  48.              //读取输入的图形标志，并将图形标志转化为数字标示并保存在数组中,关键在于这些数字
  49.              /**
  50.               *   #   ===   0
  51.               *   -   ===   5
  52.               *   |   ===   0xA   == 10
  53.               *   +   ===   0xF   == 15
  54.               *   S   ===   0xF   == 15
  55.               *   T   ===   0xF   == 15
  56.               *   .   ===   0x8   == 8
  57.               *
  58.               */
  59.              String line = fin.nextLine();
  60.  
  61.              for (int j = 1; j <= C; ++j) {
  62.  
  63.                  char c = line.charAt(j - 1);
  64.  
  65.                  picture[i-1][j-1] = c;
  66.  
  67.                  switch (c) {
  68.  
  69.                  case '#':
  70.  
  71.                      break;    
  72.  
  73.                  case '-':
  74.  
  75.                      board[i][j] = 5;
  76.  
  77.                      break;
  78.  
  79.                  case '|':
  80.  
  81.                      board[i][j] = 0xA;
  82.  
  83.                      break;
  84.  
  85.                  case '+':
  86.  
  87.                  case 'S':
  88.  
  89.                  case 'T':
  90.  
  91.                      board[i][j] = 0xF;
  92.  
  93.                      break;
  94.  
  95.                  case '.':
  96.  
  97.                      board[i][j] = 0x8;
  98.  
  99.                      break;
  100.  
  101.                  default:
  102.  
  103.                      break;
  104.  
  105.                  }
  106.                  if (c == 'S') {
  107.  
  108.                      rowStart = i;
  109.  
  110.                      colStart = j;                //起点所在的行列
  111.  
  112.                  } else if (c == 'T') {
  113.  
  114.                      rowEnd = i;
  115.  
  116.                      colEnd = j;                    //终点所在的行列
  117.                  }
  118.              }
  119.          }
  120.          System.out.println("用户输入的图形为：");
  121.          printCharArray(picture);
  122.          printNumArray(board);
  123.          int[] dr = new int[] { 0, -1, 0, 1 };              //行数  同行、上一行（向上）、 同行、 下一行（向下）
  124.  
  125.          int[] dc = new int[] { 1, 0, -1, 0 };               //列数 下一列（向右）、 同列、上一列（向左）、同列
  126.  
  127.          // Scan 1: find all cells which can reach T
  128.  
  129.          boolean[][] visited = new boolean[R + 2][C + 2];      //默认均为false
  130.  
  131.          boolean[][] canReachT = new boolean[R + 2][C + 2];    //默认均为false
  132.  
  133.          initVisited(visited);                                //数组边框为true，中间为false
  134.  
  135.          canReachT[rowEnd][colEnd] = true;
  136.  
  137.          visited[rowEnd][colEnd] = true;                        //重点的值设为true
  138.  
  139.          Queue<Integer> queue = new LinkedList<Integer>();
  140.  
  141.          queue.add(rowEnd);
  142.  
  143.          queue.add(colEnd);                    //队列有一个特点就是先进先出，这样就可以采用深度优先遍历
  144.  
  145.          while (!queue.isEmpty()) {
  146.  
  147.              int r = queue.remove();
  148.  
  149.              int c = queue.remove();
  150.  
  151.              for (int i = 0; i < 4; ++i) {
  152.  
  153.                  int nr = r + dr[i];
  154.  
  155.                  int nc = c + dc[i];        //判断顺序是 向右，向下，向左，向上(四个方向)
  156.  
  157.                  if (visited[nr][nc])    //边框+已经判定可以到达终点的点
  158.  
  159.                      continue;
  160.  
  161.                  if ((board[nr][nc] & (1 << ((i + 2) % 4))) != 0) {  
  162.  
  163.                      /**
  164.                       *   方向                        右    下    左    上
  165.                       *      i                             0    1    2    3
  166.                       *      t = (i + 2) % 4             2    3    0    1
  167.                       *      x = 1 << t                     4    8    1    2
  168.                       *   #   ===   0x0   ==  0    & x  0    0    0    0
  169.                       *   -   ===   0x5   ==  5    & x  4    0    1    0
  170.                       *   |   ===   0xA   == 10    & x  0    8    0    2
  171.                       *   +   ===   0xF   == 15    & x  4    8    1    2
  172.                       *   S   ===   0xF   == 15    & x  4    8    1    2
  173.                       *   T   ===   0xF   == 15    & x  4    8    1    2
  174.                       *   .   ===   0x8   ==  8    & x  0    8    0    0
  175.                       *
  176.                       */
  177.  
  178.                      //将上下左右和数字表示的图标对应起来，如果在这个方向可以走的话，就执行if语句
  179.  
  180.                      canReachT[nr][nc] = true;   //这个数组里面值为false的即为玩家不可以从此方格移动到目标位置。
  181.  
  182.                      queue.add(nr);
  183.  
  184.                      queue.add(nc);
  185.  
  186.                      visited[nr][nc] = true;
  187.                  }
  188.              }
  189.          }
  190.  
  191.          printBealoonArray(visited);
  192.  
  193.          if (!canReachT[rowStart][colStart]) {
  194.  
  195.              System.out.println("I'm stuck!");
  196.  
  197.              return;
  198.          }
  199.          // Scan 2: get result  同理
  200.  
  201.          boolean[][] rCanReach = new boolean[R + 2][C + 2];
  202.  
  203.          initVisited(visited);
  204.  
  205.          queue.clear();
  206.  
  207.          visited[rowStart][colStart] = true;
  208.  
  209.          rCanReach[rowStart][colStart] = true;
  210.  
  211.          queue.add(rowStart);
  212.  
  213.          queue.add(colStart);
  214.  
  215.          while (!queue.isEmpty()) {
  216.  
  217.              int r = queue.remove();
  218.  
  219.              int c = queue.remove();
  220.  
  221.              for (int i = 0; i < 4; ++i) {
  222.  
  223.                  if ((board[r][c] & (1 << i)) == 0)
  224.  
  225.                      continue;
  226.  
  227.                  int nr = r + dr[i];
  228.  
  229.                  int nc = c + dc[i];
  230.  
  231.                  if (visited[nr][nc])
  232.  
  233.                      continue;
  234.  
  235.                  if (board[nr][nc] == 0)
  236.  
  237.                      continue;
  238.  
  239.                  rCanReach[nr][nc] = true;  //这个数组里面值为true的即为玩家可以从初始位置移动到此方格
  240.  
  241.                  queue.add(nr);
  242.  
  243.                  queue.add(nc);
  244.  
  245.                  visited[nr][nc] = true;
  246.              }
  247.          }
  248.          int result = 0;
  249.  
  250.          //符合两个条件的图所位于的行列
  251.  
  252.          for (int i = 1; i <= R; ++i) {
  253.  
  254.              for (int j = 1; j <= C; ++j) {
  255.  
  256.                  if (rCanReach[i][j] && (!canReachT[i][j])){
  257.  
  258.                      ++result;
  259.  
  260.                      picture[i-1][j-1] = 'X';
  261.  
  262.                  }    
  263.  
  264.              }
  265.          }
  266.  
  267.          System.out.println("经过计算之后的图形为：");
  268.  
  269.          printCharArray(picture);
  270.  
  271.          System.out.println("满足条件的位置有 " + result + " 个。");
  272.      }
  273.  
  274.      /**
  275.       * 预先初始化数组的时候多了边框，因为visited数组默认为false
  276.       * 此函数的目的是使得visited数组边框的默认值变为true
  277.       * 使得visited数组中间的值默认为false
  278.       * @param visited
  279.       */
  280.  
  281.      private void initVisited(boolean[][] visited) {
  282.  
  283.          int R = visited.length - 2;
  284.  
  285.          int C = visited[0].length - 2;
  286.  
  287.          for (int i = 0; i <= R + 1; ++i) {
  288.  
  289.              visited[i][0] = true;
  290.  
  291.              visited[i][C + 1] = true;
  292.          }
  293.          for (int j = 0; j <= C + 1; ++j) {
  294.  
  295.              visited[0][j] = true;
  296.  
  297.              visited[R + 1][j] = true;
  298.          }
  299.          for (int i = 1; i <= R; ++i) {
  300.  
  301.              for (int j = 1; j <= C; ++j) {
  302.  
  303.                  visited[i][j] = false;
  304.  
  305.              }
  306.  
  307.          }
  308.  
  309.      }
  310.      /**
  311.       * 打印数组中保存的值
  312.       * 在此程序中为  输出等价于图形的数字数组
  313.       * @param queue
  314.       */
  315.      public static void printNumArray(int[][] board){
  316.  
  317.          System.out.println("=======================begin int board array=====================");
  318.  
  319.          for (int i = 0; i < board.length; ++i) {    
  320.  
  321.              for (int j = 0; j < board[i].length; ++j) {
  322.  
  323.                  System.out.print(board[i][j]+"\t");
  324.              }
  325.              System.out.println();
  326.          }
  327.          System.out.println("===========================end========================");
  328.      }
  329.  
  330.      /**
  331.       * 打印char数组中保存的值
  332.       * 在此程序中为  输出图形
  333.       * @param queue
  334.       */
  335.      public static void printCharArray(char[][] picture){
  336.  
  337.          System.out.println("=======================begin char picture array=====================");
  338.  
  339.          for (int i = 0; i < picture.length; ++i) {    
  340.  
  341.              for (int j = 0; j < picture[i].length; ++j) {
  342.  
  343.                  System.out.print(picture[i][j]);
  344.              }
  345.              System.out.println();
  346.          }
  347.          System.out.println("===========================end========================");
  348.      }
  349.  
  350.      /**
  351.       * 打印boolean数组中保存的值
  352.       * @param queue
  353.       */
  354.      public static void printBealoonArray(boolean[][] visted){
  355.  
  356.          System.out.println("=======================begin Boolean visted array =====================");
  357.  
  358.          for (int i = 0; i < visted.length; ++i) {    
  359.  
  360.              for (int j = 0; j < visted[i].length; ++j) {
  361.  
  362.                  System.out.print(visted[i][j]+"\t");
  363.              }
  364.              System.out.println();
  365.          }
  366.          System.out.println("===========================end========================");
  367.      }
  368.      /**
  369.       * 打印队列中保存的值
  370.       * @param queue
  371.       */
  372.      public static void  printQueue(Queue<Integer> queue){
  373.  
  374.          Iterator it = queue.iterator();
  375.  
  376.          System.out.println("=======================begin queue=====================");
  377.  
  378.          int i = 0;
  379.  
  380.          while(it.hasNext()){
  381.  
  382.              System.out.print(it.next() + "\t");
  383.  
  384.              if((++i)%2 == 0){
  385.  
  386.                  System.out.println();
  387.              }
  388.          }
  389.          System.out.println("===========================end========================");
  390.      }
  391.  }

运行结果如下：

　　

　　

标准代码如下（java）：

　　

  1.  package ccf_text2013_12;
  2.  
  3.  import java.util.*;
  4.  /**
  5.   * I'm stuck!
  6.   * 　　给定一个R行C列的地图，地图的每一个方格可能是'#', '+', '-', '|', '.', 'S', 'T'七个字符中的一个，分别表示如下意思：
  7.  　　'#': 任何时候玩家都不能移动到此方格；
  8.  　　'+': 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；
  9.  　　'-': 当玩家到达这一方格后，下一步可以向左右两个方向相邻的一个非'#'方格移动一格；
  10.  　　'|': 当玩家到达这一方格后，下一步可以向上下两个方向相邻的一个非'#'方格移动一格；
  11.  　　'.': 当玩家到达这一方格后，下一步只能向下移动一格。如果下面相邻的方格为'#'，则玩家不能再移动；
  12.  　　'S': 玩家的初始位置，地图中只会有一个初始位置。玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；
  13.  　　'T': 玩家的目标位置，地图中只会有一个目标位置。玩家到达这一方格后，可以选择完成任务，也可以选择不完成任务继续移动。如果继续移动下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格。
  14.  　　此外，玩家不能移动出地图。
  15.  　　请找出满足下面两个性质的方格个数：
  16.  　　1. 玩家可以从初始位置移动到此方格；
  17.  　　2. 玩家不可以从此方格移动到目标位置。
  18.   * @author Hello stranger
  19.   *
  20.   */
  21.  public class ImStuck {
  22.      public static void main(String[] args) {
  23.          new ImStuck().run();
  24.      }
  25.  
  26.      public void run() {
  27.          Scanner fin = new Scanner(System.in);
  28.          int R = fin.nextInt();
  29.          int C = fin.nextInt();
  30.          fin.nextLine();
  31.          int[][] board = new int[R + 2][C + 2];
  32.          int rowStart = 0, colStart = 0, rowEnd = 0, colEnd = 0;
  33.          for (int i = 1; i <= R; ++i) {
  34.              String line = fin.nextLine();
  35.              for (int j = 1; j <= C; ++j) {
  36.                  char c = line.charAt(j - 1);
  37.                  switch (c) {
  38.                  case '#':
  39.                      break;
  40.                  case '-':
  41.                      board[i][j] = 5;
  42.                      break;
  43.                  case '|':
  44.                      board[i][j] = 0xA;
  45.                      break;
  46.                  case '+':
  47.                  case 'S':
  48.                  case 'T':
  49.                      board[i][j] = 0xF;
  50.                      break;
  51.                  case '.':
  52.                      board[i][j] = 0x8;
  53.                      break;
  54.                  default:
  55.                      break;
  56.                  }
  57.                  if (c == 'S') {
  58.                      rowStart = i;
  59.                      colStart = j;
  60.                  } else if (c == 'T') {
  61.                      rowEnd = i;
  62.                      colEnd = j;
  63.                  }
  64.              }
  65.          }
  66.          int[] dr = new int[] { 0, -1, 0, 1 };
  67.          int[] dc = new int[] { 1, 0, -1, 0 };
  68.          // Scan 1: find all cells which can reach T
  69.          boolean[][] visited = new boolean[R + 2][C + 2];
  70.          boolean[][] canReachT = new boolean[R + 2][C + 2];
  71.          initVisited(visited);
  72.          canReachT[rowEnd][colEnd] = true;
  73.          visited[rowEnd][colEnd] = true;
  74.          Queue<Integer> queue = new LinkedList<Integer>();
  75.          queue.add(rowEnd);
  76.          queue.add(colEnd);
  77.          while (!queue.isEmpty()) {
  78.              int r = queue.remove();
  79.              int c = queue.remove();
  80.              for (int i = 0; i < 4; ++i) {
  81.                  int nr = r + dr[i];
  82.                  int nc = c + dc[i];
  83.                  if (visited[nr][nc])
  84.                      continue;
  85.                  if ((board[nr][nc] & (1 << ((i + 2) % 4))) != 0) {
  86.                      canReachT[nr][nc] = true;
  87.                      queue.add(nr);
  88.                      queue.add(nc);
  89.                      visited[nr][nc] = true;
  90.                  }
  91.              }
  92.          }
  93.          /*
  94.           * for (int i = 1; i <= R; ++i) { for (int j = 1; j <= C; ++j) { if
  95.           * (canReachT[i][j]) { System.out.println("i = " + i + ", j = " + j); }
  96.           * } }
  97.           */
  98.          if (!canReachT[rowStart][colStart]) {
  99.              System.out.println("I'm stuck!");
  100.              return;
  101.          }
  102.          // Scan 2: get result
  103.          boolean[][] rCanReach = new boolean[R + 2][C + 2];
  104.          initVisited(visited);
  105.          queue.clear();
  106.          visited[rowStart][colStart] = true;
  107.          rCanReach[rowStart][colStart] = true;
  108.          queue.add(rowStart);
  109.          queue.add(colStart);
  110.          while (!queue.isEmpty()) {
  111.              int r = queue.remove();
  112.              int c = queue.remove();
  113.              for (int i = 0; i < 4; ++i) {
  114.                  if ((board[r][c] & (1 << i)) == 0)
  115.                      continue;
  116.                  int nr = r + dr[i];
  117.                  int nc = c + dc[i];
  118.                  if (visited[nr][nc])
  119.                      continue;
  120.                  if (board[nr][nc] == 0)
  121.                      continue;
  122.                  rCanReach[nr][nc] = true;
  123.                  queue.add(nr);
  124.                  queue.add(nc);
  125.                  visited[nr][nc] = true;
  126.              }
  127.          }
  128.          int result = 0;
  129.          for (int i = 1; i <= R; ++i) {
  130.              for (int j = 1; j <= C; ++j) {
  131.                  /*
  132.                   * if (rCanReach[i][j]) { System.out.println("i = " + i +
  133.                   * ", j = " + j); }
  134.                   */
  135.                  if (rCanReach[i][j] && (!canReachT[i][j]))
  136.                      ++result;
  137.              }
  138.          }
  139.          System.out.println(result);
  140.      }
  141.  
  142.      private void initVisited(boolean[][] visited) {
  143.          int R = visited.length - 2;
  144.          int C = visited[0].length - 2;
  145.          for (int i = 0; i <= R + 1; ++i) {
  146.              visited[i][0] = true;
  147.              visited[i][C + 1] = true;
  148.          }
  149.          for (int j = 0; j <= C + 1; ++j) {
  150.              visited[0][j] = true;
  151.              visited[R + 1][j] = true;
  152.          }
  153.          for (int i = 1; i <= R; ++i) {
  154.              for (int j = 1; j <= C; ++j) {
  155.                  visited[i][j] = false;
  156.  
  157.              }
  158.  
  159.          }
  160.  
  161.      }
  162.  }

CCF系列之I’m stuck!(201312-5)的更多相关文章

  1. CCF系列奖获奖名单公布，鲍虎军、周志华获CCF王选奖 | CNCC 2017

    本文讲的是CCF系列奖获奖名单公布,鲍虎军.周志华获CCF王选奖 | CNCC 2017, 由中国计算机学会(CCF)主办,福州市人民政府.福州大学承办,福建师范大学.福建工程学院协办的2017中国计 ...

  2. CCF系列之最优灌溉(201412-4)

    试题编号:201412-4试题名称:最优灌溉时间限制: 1.0s内存限制: 256.0MB 问题描述 雷雷承包了很多片麦田,为了灌溉这些麦田,雷雷在第一个麦田挖了一口很深的水井,所有的麦田都从这口井来 ...

  3. CCF系列之模板生成系统( 201509-3 )

    试题名称: 模板生成系统 试题编号: 201509-3 时间限制: 1.0s 内存限制: 256.0MB 问题描述 成成最近在搭建一个网站,其中一些页面的部分内容来自数据库中不同的数据记录,但是页面的 ...

  4. CCF系列之门禁系统(201412-1)

    试题编号:201412-1试题名称:门禁系统时间限制: 2.0s内存限制: 256.0MB 问题描述 涛涛最近要负责图书馆的管理工作,需要记录下每天读者的到访情况.每位读者有一个编号,每条记录用读者的 ...

  5. CCF系列之Z字形扫描(201412-2)

    试题编号:201412-2试题名称:Z字形扫描时间限制: 2.0s内存限制: 256.0MB 问题描述 在图像编码的算法中,需要将一个给定的方形矩阵进行Z字形扫描(Zigzag Scan).给定一个n ...

  6. CCF系列之字符串匹配(201409-3)

    试题编号:201409-3试题名称:字符串匹配时间限制: 1.0s内存限制: 256.0MB 问题描述 给出一个字符串和多行文字,在这些文字中找到字符串出现的那些行.你的程序还需支持大小写敏感选项:当 ...

  7. CCF系列之画图(201409-2)

    试题编号: 201409-2试题名称: 画图时间限制: 1.0s内存限制: 256.0MB问题描述: 问题描述 在一个定义了直角坐标系的纸上,画一个(x1,y1)到(x2,y2)的矩形指将横坐标范围从 ...

  8. CCF系列之数位之和(201512-1)

    试题编号: 201512-1试题名称: 数位之和时间限制: 1.0s内存限制: 256.0MB问题描述: 问题描述 给定一个十进制整数n,输出n的各位数字之和. 输入格式 输入一个整数n. 输出格式 ...

  9. CCF系列之窗口(201403-2)

    试题编号: 201403-2时间限制: 1.0s 内存限制: 256.0MB 问题描述 在某图形操作系统中,有 N 个窗口,每个窗口都是一个两边与坐标轴分别平行的矩形区域.窗口的边界上的点也属于该窗口 ...

随机推荐

  1. vue2.0表单事件的绑定

    v-model 1.input type="text" <template> <div id="app"> <label for= ...

  2. robotframework的学习笔记（十二）------DatabaseLibrary 库

    1.安装DatabaseLibrary库 DatabaseLibrary 下载地址:https://pypi.python.org/pypi/robotframework-databaselibrar ...

  3. [js高手之路]原型式继承与寄生式继承

    一.原型式继承本质其实就是个浅拷贝,以一个对象为模板复制出新的对象 function object( o ){ var G = function(){}; G.prototype = o; retur ...

  4. JS 对象API之修改、删除对象的属性

    无论是修改还是删除对象的属性,我们首先要清楚:自有属性.共有属性的处理方法肯定是不同的: 先创建一个对象实例 var obj = { name: '小马扎', age: }; Object.proto ...

  5. 建造者模式(Builder)-宏观的使用角度

    建造者模式(Builder) 建造者模式是用来解决产品对象的创建过程是由多个零件组成的情况,这些零件与产品本身是组合关系,也就是部分与整体,这些零件的创建顺序,还有一些创建中的逻辑,都是稳定的,可以封 ...

  6. uC/OS-II 内存管理

    UC/OS-II  内存管理 1. 简介    uC/OS-II 不使用ANSI编译器的malloc(), free(),因为内存碎片,很可能获取不到一块连续的内存, 这在嵌入式系统中是很危险的.同时 ...

  7. Minfilter过滤框架

    Minfilter过滤框架 优势 与传统的Sfilter过滤驱动相比,有这样几个优势 1. Minfilter加载顺序更易控制,Sfilter加载是随意的,也就是说它在IO设备栈上的顺序是根据其创建的 ...

  8. Python文章相关性分析---金庸武侠小说分析

    百度到<金庸小说全集 14部>全(TXT)作者:金庸 下载下来,然后读取内容with open('names.txt') as f: data = [line.strip() for li ...

  9. js最常用正则表达式集合

    常用正则表达式合集:验证数字:^[0-9]*$验证n位的数字:^\d{n}$验证至少n位数字:^\d{n,}$验证m-n位的数字:^\d{m,n}$验证零和非零开头的数字:^(0|[1-9][0-9] ...

  10. 3DES加密

    本文介绍了3DES加密特性,加密特点,3DES是对称加密,用一个密钥对内容进行加密,必须使用相同的密钥进行解密, 密钥必须配置,而且长度为24位,不足24位,用0位进行补全,本文也顺带介绍了其它加密算 ...