leetcode中的状态机类型的题目

1 总结

一般是涉及到多个状态之间的转换，需要定义一个具有多个枚举值的变量，各个状态之间通过各种条件互相变化

2 LC57. 插入区间

2.1 解析

先是要确定新区间插入到哪一个位置（也有可能），插入后需要确定这个区间是否涉及到合并问题。
所以我们可以设计一个flag变量，确定区间是否插入，插入完成则进行到区间合并阶段。

2.2 代码：beat 95% commits in time complexity

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        int n=intervals.length;

        List<int[]>ans=new ArrayList<>();
        boolean f=false;//表示现待处理新区间的插入状态，f=true则表示处理完成，开启合并区间的状态
        for(int i=0;i<n;){
            int[] interval=intervals[i];
            if(!f){
                if(interval[1]<newInterval[0]){
                    ans.add(interval);
                    i++;
                }else if(interval[1]>=newInterval[0]&&interval[1]<=newInterval[1]){
                    int[]ni=new int[]{Math.min(interval[0],newInterval[0]),Math.max(interval[1], newInterval[1])};
                    ans.add(ni);
                    f=true;
                    i++;
                }else if(interval[0]>newInterval[1]){
                    ans.add(newInterval);
                    f=true;
                }else if(interval[0]<=newInterval[0]&&interval[1]>=newInterval[1]){
                    ans.add(interval);
                    f=true;
                    i++;
                }else if(interval[0]>=newInterval[0]&&interval[0]<=newInterval[1]){
                    ans.add(new int[]{newInterval[0],interval[1]});
                    f=true;
                    i++;
                }
            }else {
                // 转换为合并区间问题
                int[]li=ans.get(ans.size()-1);
                if(li[1]<interval[0]){
                    ans.add(interval);
                }else if(li[1]>=interval[0]){
                    int[]newi=new int[]{Math.min(li[0],interval[0]),Math.max(li[1],interval[1])};
                    ans.remove(ans.size()-1);
                    ans.add(newi);
                }
                i++;
                
            }
        }
        // 如果f一直是false，则说明新区间加在末尾
        if(!f){
            ans.add(newInterval);
        }
        int[][]res=new int[ans.size()][2];
        for(int i=0;i<ans.size();i++){
            res[i]=ans.get(i);
        }
        return res;
    }
}

3 LC722. 删除注释【2024滴滴国际化外卖部门秋招后端面试题】

3.1 分析

这道题的状态机的状态稍多，题目稍复杂

3.2 代码：beat 100% commits in time complexity

    // 假设注释内有了
    public List<String> removeComments(String[] source) {

        List<String>res=new ArrayList<>();
        StringBuilder sb=new StringBuilder();
        // 0:初始状态，1：行注释，2：块注释，3：引号
        // 1->0, 2->0, 

        int flag=0;
        int n=source.length;
        for(int i=0;i<n;i++){
            String str=source[i];
            char cs[]=str.toCharArray();
            int m=cs.length;

            for(int j=0;j<m;){
                // 只能在初始状态转为行注释状态
                if(j<m-1&&flag==0&&cs[j]=='/'&&cs[j+1]=='/'){
                    String addStr=sb.toString();
                    if(!"".equals(addStr)&&addStr!=null){
                        res.add(addStr);
                    }
                    sb=new StringBuilder();
                    flag=1;
                    j+=2;
                    break;
                }
                // 只能在初始状态转为多行注释状态
                if(j<m-1&&flag==0&&cs[j]=='/'&&cs[j+1]=='*'){

                    flag=2;
                    j+=2;
                    continue;
                }
                // 在多行注释的状态下转换为初始状态
                if(j<m-1&&flag==2&&cs[j]=='*'&&cs[j+1]=='/'){

                    flag=0;
                    j+=2;
                    continue;
                }
                // 开启引号状态
                if(j<m-1&&flag==0&&cs[j]=='"'){
                    flag=3;
                }
                // 关闭引号状态
                if(j<m-1&&flag==3&&cs[j]=='"'){
                    flag=0;
                }

                //处于引号或者初始状态的字符都可以被加入
                if(flag==0||flag==3){
                    sb.append(cs[j]);
                    j++;
                    continue;
                }
                j++;
            }
            // 当正常状态时，每一次换行都需要添加到res结果集中
            if(flag==0){
                String addStr=sb.toString();
                if(!"".equals(addStr)&&addStr!=null){
                    res.add(addStr);
                }
                sb=new StringBuilder();
            }
            // 当换行时，行注释状态自动回到初始状态
            if(flag==1){
                sb=new StringBuilder();
                flag=0;
            }
        }
        return res;
    }

4 LC6. Z 字形变换

4.1 使用一个状态变量记录当前的打印方向，当碰到边界时，自动换到另一个状态

class Solution {
    public String convert(String s, int numRows) {
        if(numRows==1)return s;
        int n=s.length();
        int curR=0;
        int i=0;
        List<StringBuilder>ans=new ArrayList<>();
        for(int j=0;j<numRows;j++){
            ans.add(new StringBuilder());
        }
        // 设置状态变量，f为true表示向下打印，f为false则表示相反
        boolean f=true;
        while(true){
            if(i==n){
                break; 
            }
            char c=s.charAt(i);
            ans.get(curR).append(c);    
            if(curR==numRows-1){
                f=false;
            }
            if(curR==0){
                f=true;
            }
            curR=f?curR+1:curR-1;
            i++;
        }
        StringBuilder sb=new StringBuilder();
        for(StringBuilder ss:ans){
            sb.append(ss);
        }
        return sb.toString();
    }
}