java数据结构与算法刷题-----LeetCode696. 计数二进制子串

1. 法一：时间复杂度O(n).空间复杂度O(n)

因为字符串只有0和1两个字符，所以我们可以对字符串进行分组

1. 假设有00011100000111这样一个字符串，我们记录每次字符出现次数
2. 0出现3次，1出现3次，0有出现5次，1又出现3次
3. 题目要求我们只要0和1相邻，然后数量一致即可

两个相邻的连续串，比如0001111，这里0有3个，1有4个，题目要求连续且0和1个数相等
那么只能000111.0011,01.正好可以由3种不同0的数量，组成答案。也就是谁少听谁的

class Solution {
    public int countBinarySubstrings(String s) {
        List<Integer> counts = new ArrayList<Integer>();//分组
        int ptr = 0, n = s.length();//ptr为下标，
        while(ptr < n){//如果还有字符串可遍历
            char c = s.charAt(ptr);//获取当前字符
            int count = 0;//记录当前字符连续出现的个数
            while(ptr < n && s.charAt(ptr) == c){//如果当前字符连续出现
                ptr++;count++;//下标后移，count++
            }
            counts.add(count);//当字符连续性中断时，记录当前字符出现次数
        }
        int ans = 0;//输出答案
        //两个相邻的连续串，比如0001111，这里0有3个，1有4个，题目要求连续且0和1个数相等
        //那么只能000111.0011,01.正好可以由3种不同0的数量，组成答案。也就是谁少听谁的
        for(int i = 1;i<counts.size();i++)
            ans += Math.min(counts.get(i), counts.get(i-1));
        return ans;
    }
    
}

2. 法二：时间复杂度O(n).空间复杂度O(1)

法一使用了额外的List存储字符串0和1的分组信息。接下来我们将其优化掉，用一个滚动变量来代替List

class Solution {
    public int countBinarySubstrings(String s) {
        int ptr = 0, n = s.length(), last = 0, ans = 0;//ptr为下标，last为滚动变量，ans保存答案
        while (ptr < n) {//只要有字符可遍历就继续
            char c = s.charAt(ptr);//获取当前字符
            int count = 0;//对本次字符，进行连续个数统计
            while (ptr < n && s.charAt(ptr) == c) {
                ++ptr;
                ++count;
            }
            ans += Math.min(count, last);//ans直接进行处理。而不是存储到List中最后统一处理
            last = count;//滚动变量继续滚动
        }
        return ans;
    }
}

2. 法三：时间复杂度O(n).空间复杂度O(1)

对法二进一步优化流程，每次循环，少了很多条件判断，实际意义不大，仅仅能快个1到2毫秒而已。但是如果你追求超越100%的其它用户，可以尝试。

class Solution {
    public int countBinarySubstrings(String s) {
        char a[] = s.toCharArray();//获取数组
        char last = a[0];//当前分组的第一个字符
        int preCount = 0, curCount = 1;//preCount表示上一个字符出现的次数，curCount的当前字符last的出现次数
        int res = 0;//res保存最终答案
        for (int i = 1, n = s.length(); i < n; i++) {//遍历字符串
            char c = a[i];//获取字符
            if (last != c) {//如果当前字符和第一个last保存的字符不一致了，就说明当前分组统计完成
                res += Math.min(preCount, curCount);//preCount和curCount谁小听谁的
                preCount = curCount;//preCount变为当前curCount，理解为后移操作
                curCount = 0;//cur重新计算下一个last的出现次数
                last = c;//last后移
            }
            curCount++;//如果当前字符和last一致，cur++
        }
        res += Math.min(preCount, curCount);//最终还得额外保存一次
        return res;
    }
}