由 k 个连接形成的字符串中 0 的最长子串

给定一个长度为n的二进制字符串和一个整数k 。考虑另一个字符串T，它是通过连接给定的二进制字符串k 次形成的。任务是打印仅包含零的 T 子串的最大大小。
例子：

Input: str = 110010, k = 3 
Output: 2 
str = 110010 T = 110010110010110010(formed after 3 
times concatenating str). So, the maximum size of a 
substring of T(110010110010110010) containing only 
zeroes is 2.
Input: str = 00100110, k = 5 
Output: 3 
Here, str = 00100110, T = 001001100010011000100110 
0010011000100110. So, the maximum size of a substring 
of T containing only zeroes is 3. 
 

一种朴素的方法是连接字符串的 K 个副本并遍历所有元素并计算仅包含零的子字符串的最大大小。
有效的方法：

There is no need to concatenate K copies. 
 

1. If string contains only zeroes then the answer is length_of_string * K.
2. If string is comprised of both zeroes and ones, then the answer is either the maximum length of a substring of string containing only zeroes, or the sum of the length of the prefix of A containing only zeroes and the length of the suffix of string containing only zeroes.
3. One thing to keep note of is that if K=1, then there is no need for prefix and suffix check.

 

C++

// C++ code to find maximum length
// of substring that contains only 0's
#include 
using namespace std;
 
// Function to calculate maximum length
// of substring containing only zero
int subzero(string str, int k)
{
    int ans = 0, curr = 0;
    int len = str.length();
 
    // loop to first calculate longest substring
    // in string
    for (int i = 0; i < len; ++i) {
        if (str[i] == '0')
            curr++;
        else
            curr = 0;
 
        ans = max(ans, curr);
    }
 
    // if all elements in string  are '0'
    if (ans == len)
        return len * k;
 
    // Else, find size of prefix and
    // suffix containing only zeroes
    else {
        int pre = 0, suff = 0;
 
        // Calculate prefix containing only zeroes
        for (int i = 0; i < len; i++) {
            if (str[i] == '0')
                pre++;
            else
                break;
        }
 
        // Calculate suffix containing only zeroes
        for (int i = len - 1; i >= 0; i--) {
            if (str[i] == '0')
                suff++;
            else
                break;
        }
 
        // if k<=1 then there is no need to take
        // prefix + suffix into account
        if (k > 1)
            ans = max(ans, pre + suff);
        return ans;
    }
}
 
// Drivers code
int main()
{
    string str = "00100110";
    int k = 5;
    cout << subzero(str, k);
    return 0;
}

Java

// Java code to find maximum length
// of substring that contains only 0's
import java.io.*;
import java.util.*;
import java.lang.*;
 
class GfG {
     
    // Function to calculate maximum length
    // of substring containing only zero
    public static int subzero(String s, int k)
    {
        int ans = 0, curr = 0;
        int len = s.length();
        char[] str = s.toCharArray();
     
        // loop to first calculate longest
        // substring in string
        for (int i = 0; i < len; ++i) {
            if (str[i] == '0')
                curr++;
            else
                curr = 0;
     
            ans = Math.max(ans, curr);
        }
     
        // if all elements in string are '0'
        if (ans == len)
            return len * k;
     
        // Else, find size of prefix and
        // suffix containing only zeroes
        else {
            int pre = 0, suff = 0;
     
            // Calculate prefix containing
            // only zeroes
            for (int i = 0; i < len; i++) {
                if (str[i] == '0')
                    pre++;
                else
                    break;
            }
     
            // Calculate suffix containing
            // only zeroes
            for (int i = len - 1; i >= 0; i--)
            {
                if (str[i] == '0')
                    suff++;
                else
                    break;
            }
     
            // if k<=1 then there is no need to
            // take prefix + suffix into account
            if (k > 1)
                ans = Math.max(ans, pre + suff);
            return ans;
        }
    }
     
    // Drivers code
    public static void main(String[] args)
    {
        String str = "00100110";
        int k = 5;
        System.out.println(subzero(str, k));
    }
}
 
// This code is contributed by Sagar Shukla

Python

# Python code calculate maximum length of substring
# containing only zero
def subzero(str, k):
    ans = 0
    curr = 0
    n = len(str)
 
    # loop to calculate longest substring in string
    # containing 0's
    for i in str:
        if (i =='0'):
            curr+= 1
     
        else:
            curr = 0
        ans = max(ans, curr)
    # if all elements in string a are '0'
    if (ans == n):
        print(n * k)
        return
     
    # Else, find prefix and suffix containing
    # only zeroes
    else:
        pre = suff = 0
         
        # Calculate length of the  prefix containing
        # only zeroes
        for i in str:
            if(i =='0'):
                pre+= 1
            else:
                break
                 
        # Calculate length of the suffix containing
        # only zeroes
        for i in range(n-1, -1, -1):
            if(str[i]=='0'):
                suff+= 1
            else:
                break
                 
    # if k<= 1, no need to take suffix + prefix
    # into account
    if (k > 1):
        ans = max(ans, pre + suff)
    print(ans)
    return
     
# Driver program to test above function
k = 5
str ='00100110'
subzero(str, k)

C#

// C# code to find maximum length
// of substring that contains only 0's
using System;
 
class GFG
{
 
// Function to calculate maximum length
// of substring containing only zero
public static int subzero(String s, int k)
{
    int ans = 0, curr = 0;
    int len = s.Length;
    char[] str = s.ToCharArray();
 
    // loop to first calculate longest
    // substring in string
    for (int i = 0; i < len; ++i)
    {
        if (str[i] == '0')
            curr++;
        else
            curr = 0;
 
        ans = Math.Max(ans, curr);
    }
 
    // if all elements in string are '0'
    if (ans == len)
        return len * k;
 
    // Else, find size of prefix and
    // suffix containing only zeroes
    else
    {
        int pre = 0, suff = 0;
 
        // Calculate prefix containing
        // only zeroes
        for (int i = 0; i < len; i++)
        {
            if (str[i] == '0')
                pre++;
            else
                break;
        }
 
        // Calculate suffix containing
        // only zeroes
        for (int i = len - 1; i >= 0; i--)
        {
            if (str[i] == '0')
                suff++;
            else
                break;
        }
 
        // if k<=1 then there is no need to
        // take prefix + suffix into account
        if (k > 1)
            ans = Math.Max(ans, pre + suff);
        return ans;
    }
}
 
// Driver code
public static void Main()
{
    String str = "00100110";
    int k = 5;
    Console.Write(subzero(str, k));
}
}
 
// This code is contributed by PrinciRaj1992

PHP

= 0; $i--)
        {
            if ($str[$i] == '0')
                $suff++;
            else
                break;
        }
 
        // if k<=1 then there is no need to take
        // prefix + suffix into account
        if ($k > 1)
            $ans = max($ans, $pre + $suff);
        return $ans;
    }
}
 
// Driver code
$str = "00100110";
$k = 5;
echo subzero($str, $k);
 
// This code is contributed by ita_c
?>

Javascript

// Javascript code to find maximum length
// of substring that contains only 0's
     
    // Function to calculate maximum length
    // of substring containing only zero
    function subzero(s,k)
    {
        let ans = 0, curr = 0;
        let len = s.length;
        let str = s.split("");
       
        // loop to first calculate longest
        // substring in string
        for (let i = 0; i < len; ++i) {
            if (str[i] == '0')
                curr++;
            else
                curr = 0;
       
            ans = Math.max(ans, curr);
        }
       
        // if all elements in string are '0'
        if (ans == len)
            return len * k;
       
        // Else, find size of prefix and
        // suffix containing only zeroes
        else {
            let pre = 0, suff = 0;
       
            // Calculate prefix containing
            // only zeroes
            for (let i = 0; i < len; i++) {
                if (str[i] == '0')
                    pre++;
                else
                    break;
            }
       
            // Calculate suffix containing
            // only zeroes
            for (let i = len - 1; i >= 0; i--)
            {
                if (str[i] == '0')
                    suff++;
                else
                    break;
            }
       
            // if k<=1 then there is no need to
            // take prefix + suffix into account
            if (k > 1)
                ans = Math.max(ans, pre + suff);
            return ans;
        }
    }
     
    // Drivers code
    let str = "00100110";
    let k = 5;
    document.write(subzero(str, k));
     
     
     
    // This code is contributed by avanitrachhadiya2155

输出：

3

时间复杂度： O(n)