蓝桥杯——5

• 迷宫

  L向左，R向右，U向下，D向上
  有多少玩家会走出迷宫

  public class Main {
      public static void main(String[] args) {
          int ans=0;
          for(int i=0;i<10;i++)
              for(int j=0;j<10;j++)
                  if(ok(i,j))
                      ans++;
  
          System.out.println(ans);
      }
  
      static char[][] ch = new char[][] {
              "UDDLUULRUL".toCharArray(),
              "UURLLLRRRU".toCharArray(),
              "RRUURLDLRD".toCharArray(),
              "RUDDDDUUUU".toCharArray(),
              "URUDLLRRUU".toCharArray(),
              "DURLRLDLRL".toCharArray(),
              "ULLURLLRDU".toCharArray(),
              "RDLULLRDDD".toCharArray(),
              "UUDDUDUDLL".toCharArray(),
              "ULRDLUURRR".toCharArray()};
  
      static boolean ok(int x,int y) {
          int t = 25;
          while (t-- > 0) {
              if (x < 0 || x >= 10 || y < 0 || y >= 10)
                  return true;
              if (ch[x][y] == 'U')
                  x--;
              else if (ch[x][y] == 'D')
                  x++;
              else if (ch[x][y] == 'L')
                  y--;
              else if (ch[x][y] == 'R')
                  y++;
          }
          return false;
      }
  }
  
  

• 9数算式

  9213 x 85674 = 789314562
  左边的乘数和被乘数正好用到了1~9的所有数字，每个1次。
  而乘积恰好也是用到了1~9的所有数字，并且每个1次。
  请你借助计算机的强大计算能力，找出满足如上要求的9数算式一共有多少个？

  public class Main {
      static int[] book = new int[10];//下边有注释
      static int[] result = new int[10];//下边也有注释
      static int count = 0;//计数
      //将dfs生成的10位数全排列序列转成字符串
      static String getString(){
          StringBuilder stringBuilder = new StringBuilder();
          /*当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。StringBuilder 类在 Java 5 中被提出它和 StringBuffer之间的最大不同在于StringBuilder的方法不是线程安全的（不能同步访问）。由于 StringBuilder相较于 StringBuffer有速度优势所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下则必须使用 StringBuffer 类。*/
          for (int i = 0; i < result.length; i++) {//result.length返回长度（字符数）
              stringBuilder.append(String.valueOf(result[i]));
              //append将指定的字符串追加到此字符序列;String.valueOf(int i):将int变量i转换成字符串
          }
          return stringBuilder.toString();//返回此序列中数据的字符串表示形式
      }//把结果变成字符串
  
      //判断这个数是否由不重复的数组成
      static boolean check(int num){
  
          if (String.valueOf(num).length()!=9 || String.valueOf(num).indexOf("0")!=-1) {
              //int indexOf(String str): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
              return false;
          }
  
          //哈希表判重，如果重复会插不进去
          Set<Integer> set = new HashSet<Integer>();//创建set储存整数
          char[] charArray = String.valueOf(num).toCharArray();//toCharArray() 方法将字符串转换为字符数组。
          //等式右边的含义：先把num这个整数转换成字符串，再把num转换成的字符串转换成字符数组
          //charArray字符数组储存num转换成的字符数组
          //所以下一行的charArray.length的含义就是num转换成的字符数组charArray的长度
          for (int i = 0; i < charArray.length; i++) {
              if (set.add((int) charArray[i])==false) {//add()向集合中添加元素，不能添加重复的（重复的添加不了）
                  return false;
              }
          }
          return true;
      }
  
      //dfs枚举0-9的全排列，看是否符合条件
      static void dfs(int deep){//deep当前是第几位
  
          for (int i = 0; i <=9; i++) {
              if (book[i]==0) {//标记i有没有用过
                  book[i] = 1;
                  result[deep] = i;//储存deep位是什么
                  dfs(deep+1);
                  book[i] = 0;
              }
          }
  
          if (deep==10) {//十位数都放好了
              String string = getString();//将全排列数组转成字符串
              //接下来以0为标志，进行分割，0看成乘号，不能在首位
              if (string.charAt(0)=='0' || string.charAt(9)=='0') {//charAt()方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1
                  return;
              }
              //对0进行分割，左边是乘数右边是被乘数
              String[] split = string.split("0");//定义字符串数组split，split()方法根据匹配给定的正则表达式来拆分字符串；并储存在字符串数组中
              int num1 = Integer.valueOf(split[0]);//"0"左边的是split[0]
              int num2 = Integer.valueOf(split[1]);//"0"右边的是split[1]
              if (check(num1*num2)) {//判断乘积是否由不同的数组成
                  System.out.println(num1 + " X " + num2 + " = " + num1*num2 );//如果由不同的组成，输出
                  count++;//计数
              }
              return;
          }
      }
  
      public static void main(String[] args) {
          dfs(0);
          System.out.println(count/2);//因为被乘数和乘数位置互换算一种，所以除以2
      }
  }
  

• 方格分割

  6x6的方格，沿着格子的边线剪开成两部分。
  要求这两部分的形状完全相同。

  public class Main {
      static int[][] a = new int[6][6];
      static boolean[][] vis = new boolean[10][10];
      static int[][] dir = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
      static int cnt = 0;
      public static void main(String[] args) {
          vis[3][3] = true;
          f(3, 3);
          System.out.println(cnt/4);
      }
      private static void f(int x, int y) {
          // TODO Auto-generated method stub
          if (x == 0 || x == 6 || y == 0 || y == 6) {
              cnt++;
              return;
          }
          for (int i = 0; i < 4; i++) {
              int dx = x + dir[i][0];
              int dy = y + dir[i][1];
              // 找到一条线，可以分成两半
              if (vis[dx][dy] == false) {
                  vis[dx][dy] = true;
                  vis[6-dx][6-dy] = true;
                  f(dx, dy);
                  vis[6-dx][6-dy] = false;
                  vis[dx][dy] = false;
              }
          }
      }
  }
  

• 正则问题

  例如 ((xx|xxx)x|(x|xx))xx 能接受的最长字符串是： xxxxxx，长度是6。

  public class Main {
      static int len = 0;
      static String[] arr;
      public static void main (String args[]) {
          Scanner sc = new Scanner(System.in);
          arr = sc.nextLine().split("");
  
          int re = dfs();
          System.out.println(re);
      }
      
      // dfs对于每一次（）来说
      static int dfs() {
          int result = 0, num = 0;
  
          while(len < arr.length) {
              if (arr[len].equals("(")) {
                  len ++;
                  // 递归之前需要做的事情
                  num = num + dfs();
              }
              // 递归之后需要做的事情，result是|之后的最大值
              else if (arr[len].equals("|")) {
                  len ++;
                  result = Math.max(num, result);
                  num = 0;
              }
              // 代表递归的任务完成
              else if (arr[len].equals(")")) {
                  len ++;
                  break;
              } else {
                  len ++;
                  num ++;
              }
          }
          // 当递归到最后一个（的时候，计算|后面的值
          result = Math.max(num, result);
          return result;
      }
  }
  

• 包子凑数

  第一行是下面数字的个数
  下面是可以使用的数字
  使用这些数字凑数，输出凑不出来的数字，如果有无数个，输出INF

  public class Main {
      public static void main(String[] args) {
          Scanner sc = new Scanner(System.in);
          int n = sc.nextInt();
          int a[] = new int[101];
  
          for (int i = 1; i <= n; i++)
              a[i] = sc.nextInt();
          int yueshu = a[1];
          // 辗转相除法求最大公约数
          for (int i = 2; i <= n; i++) {
              yueshu = yue(yueshu, a[i]);
          }
          if (yueshu != 1) {
              System.out.println("INF");
          } else {
              boolean dp[] = new boolean[10010];
              dp[0] = true;
              for (int i = 1; i <= n; i++) {
                  for (int j = 0; j + a[i] <= 10000; j++) {
                      if (dp[j]) {
                          dp[j + a[i]] = true;
                      }
                  }
              }
              int sum = 0;
              for (int i = 0; i <= 10000; i++)
                  if (dp[i] == false)
                      sum++;
              System.out.println(sum);
          }
      }
  
      private static int yue(int x, int y) {
          if (y == 0)
              return x;
          else
              return yue(y, x % y);
      }
  }