二.字符串（19）696. 计数二进制子串

696. 计数二进制子串

给定一个字符串 s，统计并返回具有相同数量 0 和 1 的非空（连续）子字符串的数量，并且这些子字符串中的所有 0 和所有 1 都是成组连续的。

重复出现（不同位置）的子串也要统计它们出现的次数。

 
示例 1：

输入：s = "00110011"
输出：6
解释：6 个子串满足具有相同数量的连续 1 和 0 ："0011"、"01"、"1100"、"10"、"0011" 和 "01" 。
注意，一些重复出现的子串（不同位置）要统计它们出现的次数。
另外，"00110011" 不是有效的子串，因为所有的 0（还有 1 ）没有组合在一起。
示例 2：

输入：s = "10101"
输出：4
解释：有 4 个子串："10"、"01"、"10"、"01" ，具有相同数量的连续 1 和 0 。
 

提示：

1 <= s.length <= 105
s[i] 为 '0' 或 '1'

官方题解：

方法一：按字符分组
思路与算法

我们可以将字符串 s 按照 0 和 1 的连续段分组，存在 counts 数组中，例如 s = 00111011，可以得到这样的 counts 数组：counts={2,3,1,2}。

这里 counts 数组中两个相邻的数一定代表的是两种不同的字符。假设counts 数组中两个相邻的数字为 u 或者 v，它们对应着 u 个 0 和 v 个 1，或者 u 个 1 和 v 个 0。它们能组成的满足条件的子串数目为min{u,v}，即一对相邻的数字对答案的贡献。

我们只要遍历所有相邻的数对，求它们的贡献总和，即可得到答案。

不难得到这样的实现：

func countBinarySubstrings(s string) int {
    counts := []int{}//存放连续的0和1 的数量的数组
    ptr, n := 0, len(s)//ptr表示下标，n表示字符串长度
    for ptr < n{//遍历字符串
        c := s[ptr]//取出下标对应处的字符
        count := 0//初始化连续数量为0
        for ptr < n && s[ptr] == c{
            ptr++
            count++
        }
        counts = append(counts,count)
    }
    ans := 0
    for i := 1; i < len(counts); i++{
        ans += min(counts[i], counts[i - 1])
    }
    return ans
}
func min(x, y int) int{
    if x < y{
        return x
    }
    return y
}

这个实现的时间复杂度和空间复杂度都是 O(n)。

对于某一个位置i，其实我们只关心 i−1 位置的counts 值是多少，所以可以用一个 last 变量来维护当前位置的前一个位置，这样可以省去一个 counts 数组的空间。

func countBinarySubstrings(s string) int {
    var ptr, last, ans int
    n := len(s)
    for ptr < n {
        c := s[ptr]
        count := 0
        for ptr < n && s[ptr] == c {
            ptr++
            count++
        }
        ans += min(count, last)
        last = count
    }

    return ans
}

func min(x, y int) int {
    if x < y {
        return x
    }
    return y
}