阿里附加题记录

题目一

• 1.题目要求
  
• 2.分析
  这就是一个简单的堆栈应用，求后缀表达式的值，不过需要注意的是分隔符为一个或多个空格。可以使用String类的split方法，该方法支持正则表达式，正则表达式 \s 表示匹配任何空白字符，+表示匹配一次或多次。所以这样既可：
  String[] paras = expr.split("\\s+");
  前面的 \ 表示转义
• 3.代码

/*一个对于一个单行的逆波兰表达式，由如下元素构成：
数字：十进制数字字符构成的正整数，比如 223
运算符：支持三种运算符^+和*，分别代表自增，加法和乘法
分隔符：一个或者多个空格
例如下面的字符串就是个逆波兰表达式
2 3  4 * ^ 5 +
逆波兰表达式在一个基于栈的虚拟机中求解，虚拟机的栈能保存16个整数，虚拟机从左向右扫描表达式，遇到整数就压栈，
遇到表达式则从栈顶弹出若干个整数进行计算，计算结果重新压回栈中。其中运算符^从栈顶弹出一个整数，增加1之后压栈；运算符+和*从栈顶弹出两个整数，
分别做相加和相乘运算后压栈。如果遇到运算符的时候，栈内没有足够的整数，称为下溢出，返回-1；
把整数压栈的时候，如果栈没有足够的空间，称为上溢出，返回-2；如果整个计算过程中没有发生溢出，在整个表达式求解完成后，返回栈顶的整数。*/

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main1 {

    public static void main(String[] args) {

        ArrayList<Integer> inputs = new ArrayList<Integer>();
        Scanner in = new Scanner(System.in);
        String line = in.nextLine();
        if(line != null && !line.isEmpty()) {
            int res = resolve(line.trim());
            System.out.println(String.valueOf(res));
        }
    }

    // write your code here
    public static int resolve(String expr) {
        int size = 16;
        String[] stack = new String[size];
        int top = -1;

        String[] paras = expr.split("\\s+");
        for(String para: paras){
            if(para.equals("^")){
                if(top < 0){
                    return -1;
                }
                int tmp = Integer.parseInt(stack[top--]);
                tmp++;
                stack[++top] = String.valueOf(tmp);
            }else if(para.equals("*")){
                if(top < 1){
                    return -1;
                }
                int tmp1 = Integer.parseInt(stack[top--]);
                int tmp2 = Integer.parseInt(stack[top--]);
                int tmp3 = tmp1*tmp2;
                stack[++top] = String.valueOf(tmp3);
            }else if(para.equals("+")){
                if(top < 1){
                    return -1;
                }
                int tmp1 = Integer.parseInt(stack[top--]);
                int tmp2 = Integer.parseInt(stack[top--]);
                int tmp3 = tmp1+tmp2;
                stack[++top] = String.valueOf(tmp3);
            }else {
                if(top==15){
                    return -2;
                }
                stack[++top] = para;
            }
        }

        return Integer.parseInt(stack[top]);

    }
}

我这个代码提交之后显示通过了。

题目二

• 1.题目要求
  
  大概意思就是进行模式匹配。
  其中 * 表示可以匹配任意个字符
  ? 表示匹配一个字符

如字符串是

200-trade-done

模式为

2*trade?done

这样则匹配成功，应该输出1

再如,字符串:

100-trade-fail

模式为

200?*trade-fail

这样则匹配失败，应该输出0。

输入:
第一行，需要过滤的字符串 第二行，匹配模式
输出:
匹配结果，匹配成功返回1，匹配失败返回0

• 2.分析
  我觉得这个可以一个个字符去看，用模式来和字符串进行一步步的匹配。
  分别用来个“指针”，开始时分别指向字符串和模式的首字符，然后判断模式的字符。

---

如果是“?”，则不需要比较，两个指针直接往后挪一位

---

如果是“*”，则在字符串中依次往后查找，直到找到某个字符和模式中的下一个字符相同为止。

---

如果是其他字符，则比较模式和字符串当前位置的字符是否相同，相同则继续往后挪，不同则终止。

---

最后判断两个指针是否都过了最末尾，如果都过了，说明匹配成功了。如果没到，说明匹配失败了。

package alibaba;
import java.util.Scanner;
public class Main3 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        String pattern = in.nextLine();
        //System.out.println(pattern.length());
        int strIndex = 0, patternIndex = 0;
        while(strIndex<str.length() && patternIndex<pattern.length()){
            if(pattern.charAt(patternIndex) == '?'){
                strIndex++;
                patternIndex++;
            }else if (pattern.charAt(patternIndex) == '*') {
                while((patternIndex+1)<pattern.length() && strIndex<str.length() && pattern.charAt(patternIndex+1) != str.charAt(strIndex)){
                    strIndex++;
                }
                patternIndex++;
            }else {
                if(pattern.charAt(patternIndex) == str.charAt(strIndex)){
                    strIndex++;
                    patternIndex++;
                }else {
                    break;
                }
            }
        }

        if(strIndex==str.length() && patternIndex==pattern.length()){
            System.out.println(1);
        }else {
            System.out.println(0);
        }
    }

}

但我这样的想法是错的，如输入：
200 - trade- - -done
200*-done
应该是匹配成功，正确的输出是1。
但我的输出是0。

• 我也不知道该怎么样处理了。难点就在于如何实现 *匹配任意多个字符。
• 我百度了一下，也没有找到相应的解决方案。有一个文字写了，但我不是太懂，实现一个正则表达式匹配算法，.匹配任意一个字符，*匹配0个或者多个前导字符

在牛客网上看到了一个类似的题目，从他人的回答中 披萨大叔的回答 我找到了一些灵感。我觉得可以用递归的方法去进行*的匹配，这样就可以实现了。直接上代码，我觉得从代码中就可以看清其中的思想。

package alibaba;
import java.util.Scanner;

public class Main4 {
    public static boolean match(char[] str, char[] pattern){
        int strIndex = 0;
        int patternIndex = 0;
        return match(str, strIndex,pattern,patternIndex);
    }

    public static boolean match(char[] str, int strIndex, char[] pattern, int patternIndex){

        //两个都匹配到了最后位置之后,说明已经全部匹配了，返回true
        if(patternIndex==pattern.length && strIndex==str.length){
            return true;
        }

        //模式串到达了最后，但是源字符串还未匹配完，返回false
        if(patternIndex==pattern.length && strIndex<str.length){
            return false;
        }

        //源字符串到达了最后，但是模式串还未匹配完，则继续看模式串的字符，如果不是*，则一定是false；否则有可能匹配成功，要继续看模式串后面的字符
        if(patternIndex<pattern.length && strIndex==str.length){
            if(pattern[patternIndex] != '*')    return false;
            else {
                return match(str, strIndex,pattern,patternIndex+1);
            }
        }

        //模式串和源字符串都还未匹配完，要根据模式串的字符进行判断
        if(patternIndex<pattern.length && strIndex<str.length){
            if(pattern[patternIndex] == '?'){// ？则直接都往后判断
                return match(str, strIndex+1,pattern,patternIndex+1);
            }else if (pattern[patternIndex] == '*') {// *有两种情况，一种是*代表0个匹配字符，模式串往后移动一个；另一种是代表一个任意字符，*保持，源字符串继续往后
                return match(str, strIndex,pattern,patternIndex+1) || match(str, strIndex+1,pattern,patternIndex);
            }else {// 其他字符则比较模式串字符和源字符串字符是否相同，相同继续往后比较，不同直接返回false
                if(pattern[patternIndex] == str[strIndex]){
                    return match(str, strIndex+1,pattern,patternIndex+1);
                }else {
                    return false;
                }
            }
        }
        return true;
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String srcStr = in.nextLine();
        String srcPattern = in.nextLine();

        char[] str = srcStr.toCharArray();
        char[] pattern = srcPattern.toCharArray();

        boolean isMatch =  match(str, pattern);
        if(isMatch){
            System.out.println(1);
        }else {
            System.out.println(0);
        }
    }
}

我在本地运行之后测试了题目中的例子全部通过，但我也不确定是不是完全正确。。。我觉得思想应该是对的。。