具有相等的连续 0 和 1 的子串的计数

给定只有0和1 的二进制字符串str 。任务是计算字符串str的子串总数，使每个子串中的连续0和1 的数量相等。
例子

Input: str = “010011” 
Output: 4 
Explanation: 
The substrings with consecutive 0’s and 1’s are “01”, “10”, “0011”, “01”. Hence, the count is 4. 
Note: 
The two “01” are at different positions: [0, 1] and [3, 4]. 
“010011” has the same number of 0’s and 1’s but they are not consecutive.
Input: str = “0001110010” 
Output: 7 
Explanation: 
The substrings with consecutive 0’s and 1’s are “000111”, “0011”, “01”, “1100”, “10”, “01”, “10”.
 

方法：

• 从字符串的开头计算连续的 0(或 1)的数量。
• 然后从字符串str中 0(或 1)的计数结束的位置开始计算连续的 1(或 0)的数量。
• 连续0和1的子串总数是上述两步找到的连续0和1个数中的最小值。
• 重复上述步骤直到字符串str结束。

下面是上述方法的实现：

C++

// C++ implementation of the
// above approach
#include 
using namespace std;
 
// Function to find the count
// of substrings with equal no.
// of consecutive 0's and 1's
int countSubstring(string& S, int& n)
{
    // To store the total count
    // of substrings
    int ans = 0;
 
    int i = 0;
 
    // Traversing the string
    while (i < n) {
 
        // Count of consecutive
        // 0's & 1's
        int cnt0 = 0, cnt1 = 0;
 
        // Counting subarrays of
        // type "01"
        if (S[i] == '0') {
 
            // Count the consecutive
            // 0's
            while (i < n && S[i] == '0') {
                cnt0++;
                i++;
            }
 
            // If consecutive 0's
            // ends then check for
            // consecutive 1's
            int j = i;
 
            // Counting consecutive 1's
            while (j < n && S[j] == '1') {
                cnt1++;
                j++;
            }
        }
 
        // Counting subarrays of
        // type "10"
        else {
 
            // Count consecutive 1's
            while (i < n && S[i] == '1') {
                cnt1++;
                i++;
            }
 
            // If consecutive 1's
            // ends then check for
            // consecutive 0's
            int j = i;
 
            // Count consecutive 0's
            while (j < n && S[j] == '0') {
                cnt0++;
                j++;
            }
        }
 
        // Update the total count
        // of substrings with
        // minimum of (cnt0, cnt1)
        ans += min(cnt0, cnt1);
    }
 
    // Return answer
    return ans;
}
 
// Driver code
int main()
{
    string S = "0001110010";
    int n = S.length();
 
    // Function to print the
    // count of substrings
    cout << countSubstring(S, n);
    return 0;
}

Java

// Java implementation of the
// above approach
class GFG{
 
    // Function to find the count
    // of substrings with equal no.
    // of consecutive 0's and 1's
    static int countSubstring(String S, int n)
    {
        // To store the total count
        // of substrings
        int ans = 0;
     
        int i = 0;
     
        // Traversing the string
        while (i < n) {
     
            // Count of consecutive
            // 0's & 1's
            int cnt0 = 0, cnt1 = 0;
     
            // Counting subarrays of
            // type "01"
            if (S.charAt(i) == '0') {
     
                // Count the consecutive
                // 0's
                while (i < n && S.charAt(i) == '0') {
                    cnt0++;
                    i++;
                }
     
                // If consecutive 0's
                // ends then check for
                // consecutive 1's
                int j = i;
     
                // Counting consecutive 1's
                while (j < n && S.charAt(j) == '1') {
                    cnt1++;
                    j++;
                }
            }
     
            // Counting subarrays of
            // type "10"
            else {
     
                // Count consecutive 1's
                while (i < n && S.charAt(i) == '1') {
                    cnt1++;
                    i++;
                }
     
                // If consecutive 1's
                // ends then check for
                // consecutive 0's
                int j = i;
     
                // Count consecutive 0's
                while (j < n && S.charAt(j) == '0') {
                    cnt0++;
                    j++;
                }
            }
     
            // Update the total count
            // of substrings with
            // minimum of (cnt0, cnt1)
            ans += Math.min(cnt0, cnt1);
        }
     
        // Return answer
        return ans;
    }
     
    // Driver code
    static public void main(String args[])
    {
        String S = "0001110010";
        int n = S.length();
     
        // Function to print the
        // count of substrings
        System.out.println(countSubstring(S, n));
    }
}
 
// This code is contributed by Yash_R

Python3

# Python3 implementation of the
# above approach
 
# Function to find the count
# of substrings with equal no.
# of consecutive 0's and 1's
def countSubstring(S, n) :
 
    # To store the total count
    # of substrings
    ans = 0;
 
    i = 0;
 
    # Traversing the string
    while (i < n) :
 
        # Count of consecutive
        # 0's & 1's
        cnt0 = 0; cnt1 = 0;
 
        # Counting subarrays of
        # type "01"
        if (S[i] == '0') :
 
            # Count the consecutive
            # 0's
            while (i < n and S[i] == '0') :
                cnt0 += 1;
                i += 1;
 
            # If consecutive 0's
            # ends then check for
            # consecutive 1's
            j = i;
 
            # Counting consecutive 1's
            while (j < n and S[j] == '1') :
                cnt1 += 1;
                j += 1;
 
        # Counting subarrays of
        # type "10"
        else :
 
            # Count consecutive 1's
            while (i < n and S[i] == '1') :
                cnt1 += 1;
                i += 1;
 
            # If consecutive 1's
            # ends then check for
            # consecutive 0's
            j = i;
 
            # Count consecutive 0's
            while (j < n and S[j] == '0') :
                cnt0 += 1;
                j += 1;
 
        # Update the total count
        # of substrings with
        # minimum of (cnt0, cnt1)
        ans += min(cnt0, cnt1);
 
    # Return answer
    return ans;
 
# Driver code
if __name__ == "__main__" :
    S = "0001110010";
    n = len(S);
 
    # Function to print the
    # count of substrings
    print(countSubstring(S, n));
     
# This code is contributed by Yash_R

C#

// C# implementation of the
// above approach
using System;
 
class GFG{
 
    // Function to find the count
    // of substrings with equal no.
    // of consecutive 0's and 1's
    static int countSubstring(string S, int n)
    {
        // To store the total count
        // of substrings
        int ans = 0;
     
        int i = 0;
     
        // Traversing the string
        while (i < n) {
     
            // Count of consecutive
            // 0's & 1's
            int cnt0 = 0, cnt1 = 0;
     
            // Counting subarrays of
            // type "01"
            if (S[i] == '0') {
     
                // Count the consecutive
                // 0's
                while (i < n && S[i] == '0') {
                    cnt0++;
                    i++;
                }
     
                // If consecutive 0's
                // ends then check for
                // consecutive 1's
                int j = i;
     
                // Counting consecutive 1's
                while (j < n && S[j] == '1') {
                    cnt1++;
                    j++;
                }
            }
     
            // Counting subarrays of
            // type "10"
            else {
     
                // Count consecutive 1's
                while (i < n && S[i] == '1') {
                    cnt1++;
                    i++;
                }
     
                // If consecutive 1's
                // ends then check for
                // consecutive 0's
                int j = i;
     
                // Count consecutive 0's
                while (j < n && S[j] == '0') {
                    cnt0++;
                    j++;
                }
            }
     
            // Update the total count
            // of substrings with
            // minimum of (cnt0, cnt1)
            ans += Math.Min(cnt0, cnt1);
        }
     
        // Return answer
        return ans;
    }
     
    // Driver code
    static public void Main ()
    {
        string S = "0001110010";
        int n = S.Length;
     
        // Function to print the
        // count of substrings
        Console.WriteLine(countSubstring(S, n));
    }
}
 
// This code is contributed by Yash_R

Javascript

 
// Javascript implementation of the
// above approach    
 
    // Function to find the count
    // of substrings with equal no.
    // of consecutive 0's and 1's
    function countSubstring( S , n)
    {
        // To store the total count
        // of substrings
        var ans = 0;
 
        var i = 0;
 
        // Traversing the string
        while (i < n) {
 
            // Count of consecutive
            // 0's & 1's
            var cnt0 = 0, cnt1 = 0;
 
            // Counting subarrays of
            // type "01"
            if (S.charAt(i) == '0') {
 
                // Count the consecutive
                // 0's
                while (i < n && S.charAt(i) == '0')
                {
                    cnt0++;
                    i++;
                }
 
                // If consecutive 0's
                // ends then check for
                // consecutive 1's
                var j = i;
 
                // Counting consecutive 1's
                while (j < n && S.charAt(j) == '1')
                {
                    cnt1++;
                    j++;
                }
            }
 
            // Counting subarrays of
            // type "10"
            else {
 
                // Count consecutive 1's
                while (i < n && S.charAt(i) == '1')
                {
                    cnt1++;
                    i++;
                }
 
                // If consecutive 1's
                // ends then check for
                // consecutive 0's
                var j = i;
 
                // Count consecutive 0's
                while (j < n && S.charAt(j) == '0')
                {
                    cnt0++;
                    j++;
                }
            }
 
            // Update the total count
            // of substrings with
            // minimum of (cnt0, cnt1)
            ans += Math.min(cnt0, cnt1);
        }
 
        // Return answer
        return ans;
    }
 
    // Driver code
        var S = "0001110010";
        var n = S.length;
 
        // Function to print the
        // count of substrings
        document.write(countSubstring(S, n));
 
// This code contributed by umadevi9616
 

输出：

7

时间复杂度： O(N)，其中 N =字符串的长度。

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live