51Testing软件测试论坛

标题: PTA 括号匹配 递归写法 测试用例均不通过 [打印本页]

作者: 测试积点老人    时间: 2022-5-13 11:05
标题: PTA 括号匹配 递归写法 测试用例均不通过
[attach]137970[/attach]
  1. import java.io.*;
  2. import java.util.HashMap;
  3. import java.util.Map;

  4. public class Main {

  5.     private static Map<Character,Character> map;
  6.     //找到最远端的右括号并返回它的索引 c是右括号
  7.     //如果没有找到返回-1
  8.     public static int judge(String str,char c){
  9.         for(int i=str.length()-1;i>0;i--){
  10.             if(str.charAt(i)==c){
  11.                 return i;
  12.             }
  13.         }
  14.         return -1;
  15.     }

  16.     //递归方法 判断每一层嵌套是否合法 c是右括号
  17.     //出口:内层无嵌套/达到最内层
  18.     public static boolean ValidNest(String str,char c){
  19.         //先找出右括号在局部字符串的最远端索引
  20.         int cIndex = judge(str,c);
  21.         //没找到,说明缺了右括号,错的
  22.         if(cIndex==-1){
  23.             return false;
  24.         }
  25.         //出口 下一个就是右括号了 说明这个左括号内部无嵌套 合法
  26.         else if(cIndex==1){
  27.             //如果右括号索引已经是子串结尾,为出口
  28.             if(cIndex==str.length()-1){
  29.                 return true;
  30.             }
  31.             //如果不是子串结尾,说明右方还有平行嵌套
  32.             else{
  33.                 cIndex++;
  34.                 boolean leftFlag;
  35.                 boolean rightFlag;
  36.                 //需要递归判断的子串 这里直接截取到尾部
  37.                 String subString = str.substring(cIndex);
  38.                 //左子串的左括号
  39.                 char leftBracket = map.get(subString.charAt(0));
  40.                 //右子串的左括号 不知道有没有右子串 先放着
  41.                 char rightBracket;
  42.                 //找到左括号在子串中的右括号
  43.                 int leftIndex = judge(subString,leftBracket);
  44.                 //如果右括号索引不为尾索引,说明有平行嵌套
  45.                 if(leftIndex!=subString.length()-1){
  46.                     String leftString = subString.substring(0,leftIndex+1);
  47.                     leftFlag = ValidNest(leftString,leftBracket);
  48.                     rightBracket = map.get(subString.charAt(leftIndex+1));
  49.                     //右子串从左子串右括号的下一个字符到子串尾部
  50.                     String rightString = subString.substring(leftIndex+1);
  51.                     rightFlag = ValidNest(rightString,rightBracket);
  52.                     return leftFlag&&rightFlag;
  53.                 }
  54.                 else{
  55.                     return ValidNest(subString,leftBracket);
  56.                 }
  57.             }
  58.         }
  59.         else{
  60.             //这种情况下,说明右边还有,先递归判断左边嵌套,再递归判断右边嵌套,均正确则返回true
  61.             boolean leftFlag;
  62.             boolean rightFlag;
  63.             //需要递归判断的子串
  64.             String subString = str.substring(1,cIndex);
  65.             //左子串的左括号
  66.             char leftBracket;
  67.             try{
  68.                 leftBracket = map.get(subString.charAt(0));
  69.             }
  70.             catch (Exception e){
  71.                 return false;
  72.             }
  73.             //右子串的左括号 不知道有没有右子串 先放着
  74.             char rightBracket;
  75.             //找到左括号在子串中的右括号
  76.             int leftIndex = judge(subString,leftBracket);
  77.             //如果右括号索引不为尾索引,说明有平行嵌套
  78.             if(leftIndex!=subString.length()-1){
  79.                 String leftString = subString.substring(0,leftIndex+1);
  80.                 leftFlag = ValidNest(leftString,leftBracket);
  81.                 rightBracket = map.get(subString.charAt(leftIndex+1));
  82.                 //右子串从左子串右括号的下一个字符到子串尾部
  83.                 String rightString = subString.substring(leftIndex+1);
  84.                 rightFlag = ValidNest(rightString,rightBracket);
  85.                 return leftFlag&&rightFlag;
  86.             }
  87.             else{
  88.                 return ValidNest(subString,leftBracket);
  89.             }
  90.         }
  91.     }

  92.     public static void main(String[] args) throws IOException {
  93.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  94.         StreamTokenizer st = new StreamTokenizer(br);

  95.         st.nextToken();
  96.         int total = (int)st.nval;

  97.         map = new HashMap<>();
  98.         map.put('{','}'); map.put('[',']'); map.put('(',')');

  99.         for(int i=1;i<=total;i++){
  100.             String brackets = br.readLine();
  101.             char temp = map.get(brackets.charAt(0));
  102.             boolean result=ValidNest(brackets,temp);
  103.             if(result){
  104.                 System.out.println("Yes");
  105.             }
  106.             else{
  107.                 System.out.println("No");
  108.             }
  109.         }
  110.     }
  111. }
复制代码
[attach]137971[/attach]
思路: 递归判断每一层嵌套 每一层嵌套中可能有互相平行的括号,再分别进行递归判断,细节写在注释里了
现在发现一个测试用例是有问题的,为 {}({[]}())。因为在找第一个{的最远端的右括号时找到了后面嵌套里的}。
请问有没有什么改正的方法?
注:请不要贴一个AC代码的链接上来。

作者: qqq911    时间: 2022-5-16 10:32
按顺序找?
作者: bellas    时间: 2022-5-16 10:46
等大神
作者: 海海豚    时间: 2022-5-16 14:16
https://www.csdn.net/tags/MtTagg5sMDA0ODQtYmxvZwO0O0OO0O0O.html 参考这个试试
作者: jingzizx    时间: 2022-5-16 16:27
栈的应用




欢迎光临 51Testing软件测试论坛 (http://bbs.51testing.com/) Powered by Discuz! X3.2