删除一个字符后的最长 1 子串

给定一个长度为N的二进制字符串S ，任务是在从字符串删除一个字符后，找到仅存在于字符串中的由‘1’组成的最长子字符串。

例子：

Input: S = “1101”
Output: 3
Explanation: 
Removing S[0], S modifies to “101”. Longest possible substring of ‘1’s is 1.
Removing S[1], S modifies to “101”. Longest possible substring of ‘1’s is 1.
Remoing S[2], S modifies to “111”. Longest possible substring of ‘1’s is 3.
Removing S[3], S modifies to “110”. Longest possible substring of ‘1’s is 2.
Therefore, longest substring of ‘1’s that can be obtained is 3.

Input: S = “011101101”
Output: 5

方法一：思路是遍历字符串，在给定的字符串搜索‘0’ 。对于发现为‘0’ 的每个字符，添加其相邻子串的长度‘1’ 。打印获得的所有此类长度的最大值。

下面是上述方法的实现：

C++

// C++ Program to implement
// the above approach
#include 
using namespace std;
 
// Function to calculate the length of the
// longest substring of '1's that can be
// obtained by deleting one character
int longestSubarray(string s)
{
    // Add '0' at the end
    s += '0';
 
    // Iterator to traverse the string
    int i;
 
    // Stores maximum length
    // of required substring
    int res = 0;
 
    // Stores length of substring of '1'
    // preceding the current character
    int prev_one = 0;
 
    // Stores length of substring of '1'
    // succeeding the current character
    int curr_one = 0;
 
    // Counts number of '0's
    int numberOfZeros = 0;
 
    // Traverse the string S
    for (i = 0; i < s.length(); i++) {
 
        // If current character is '1'
        if (s[i] == '1') {
 
            // Increase curr_one by one
            curr_one += 1;
        }
 
        // Otherwise
        else {
 
            // Increment numberofZeros by one
            numberOfZeros += 1;
 
            // Count length of substring
            // obtained y concatenating
            // preceding and succeeding substrings of '1'
            prev_one += curr_one;
 
            // Store maximum size in res
            res = max(res, prev_one);
 
            // Assign curr_one to prev_one
            prev_one = curr_one;
 
            // Reset curr_one
            curr_one = 0;
        }
    }
 
    // If string contains only one '0'
    if (numberOfZeros == 1) {
        res -= 1;
    }
 
    // Return the answer
    return res;
}
 
// Driver Code
int main()
{
    string S = "1101";
    cout << longestSubarray(S);
    return 0;
}

Java

// Java program to implement
// the above approach
import java.util.Arrays;
  
class GFG{
      
// Function to calculate the length of the
// longest substring of '1's that can be
// obtained by deleting one character
static int longestSubarray(String s)
{
     
    // Add '0' at the end
    s += '0';
     
    // Iterator to traverse the string
    int i;
     
    // Stores maximum length
    // of required substring
    int res = 0;
     
    // Stores length of substring of '1'
    // preceding the current character
    int prev_one = 0;
  
    // Stores length of substring of '1'
    // succeeding the current character
    int curr_one = 0;
  
    // Counts number of '0's
    int numberOfZeros = 0;
  
    // Traverse the string S
    for(i = 0; i < s.length(); i++)
    {
         
        // If current character is '1'
        if (s.charAt(i) == '1')
        {
             
            // Increase curr_one by one
            curr_one += 1;
        }
  
        // Otherwise
        else
        {
             
            // Increment numberofZeros by one
            numberOfZeros += 1;
  
            // Count length of substring
            // obtained y concatenating
            // preceding and succeeding
            // substrings of '1'
            prev_one += curr_one;
  
            // Store maximum size in res
            res = Math.max(res, prev_one);
  
            // Assign curr_one to prev_one
            prev_one = curr_one;
  
            // Reset curr_one
            curr_one = 0;
        }
    }
  
    // If string contains only one '0'
    if (numberOfZeros == 1)
    {
        res -= 1;
    }
     
    // Return the answer
    return res;
}
  
// Driver Code
public static void main (String[] args)
{
    String S = "1101";
     
    System.out.println(longestSubarray(S));
}
}
 
// This code is contributed by code_hunt

Python3

# Python3 program to implement
# the above approach
 
# Function to calculate the length of the
# longest substring of '1's that can be
# obtained by deleting one character
def longestSubarray(s):
     
    # Add '0' at the end
    s += '0'
 
    # Iterator to traverse the string
    i = 0
 
    # Stores maximum length
    # of required substring
    res = 0
 
    # Stores length of substring of '1'
    # preceding the current character
    prev_one = 0
 
    # Stores length of substring of '1'
    # succeeding the current character
    curr_one = 0
 
    # Counts number of '0's
    numberOfZeros = 0
 
    # Traverse the string S
    for i in range(len(s)):
         
        # If current character is '1'
        if (s[i] == '1'):
             
            # Increase curr_one by one
            curr_one += 1
 
        # Otherwise
        else:
             
            # Increment numberofZeros by one
            numberOfZeros += 1
 
            # Count length of substring
            # obtained y concatenating
            # preceding and succeeding
            # substrings of '1'
            prev_one += curr_one
 
            # Store maximum size in res
            res = max(res, prev_one)
 
            # Assign curr_one to prev_one
            prev_one = curr_one
 
            # Reset curr_one
            curr_one = 0
 
    # If string contains only one '0'
    if (numberOfZeros == 1):
        res -= 1
 
    # Return the answer
    return res
 
# Driver Code
if __name__ == '__main__':
     
    S = "1101"
     
    print(longestSubarray(S))
 
# This code is contributed by ipg2016107

C#

// C# program to implement
// the above approach
using System;
class GFG
{
      
// Function to calculate the length of the
// longest substring of '1's that can be
// obtained by deleting one character
static int longestSubarray(String s)
{
     
    // Add '0' at the end
    s += '0';
     
    // Iterator to traverse the string
    int i;
     
    // Stores maximum length
    // of required substring
    int res = 0;
     
    // Stores length of substring of '1'
    // preceding the current character
    int prev_one = 0;
  
    // Stores length of substring of '1'
    // succeeding the current character
    int curr_one = 0;
  
    // Counts number of '0's
    int numberOfZeros = 0;
  
    // Traverse the string S
    for(i = 0; i < s.Length; i++)
    {
         
        // If current character is '1'
        if (s[i] == '1')
        {
             
            // Increase curr_one by one
            curr_one += 1;
        }
  
        // Otherwise
        else
        {
             
            // Increment numberofZeros by one
            numberOfZeros += 1;
  
            // Count length of substring
            // obtained y concatenating
            // preceding and succeeding
            // substrings of '1'
            prev_one += curr_one;
  
            // Store maximum size in res
            res = Math.Max(res, prev_one);
  
            // Assign curr_one to prev_one
            prev_one = curr_one;
  
            // Reset curr_one
            curr_one = 0;
        }
    }
  
    // If string contains only one '0'
    if (numberOfZeros == 1)
    {
        res -= 1;
    }
     
    // Return the answer
    return res;
}
  
// Driver Code
public static void Main(String[] args)
{
    String S = "1101";
     
    Console.WriteLine(longestSubarray(S));
}
}
 
 
// This code is contributed by shikhasingrajput

Javascript

// javascript program to implement
// the above approach
 
// Function to calculate the length of the
// longest substring of '1's that can be
// obtained by deleting one character
function longestSubarray(s)
{
      
    // Add '0' at the end
    s += '0';
      
    // Iterator to traverse the string
    let i;
      
    // Stores maximum length
    // of required substring
    let res = 0;
      
    // Stores length of substring of '1'
    // preceding the current character
    let prev_one = 0;
   
    // Stores length of substring of '1'
    // succeeding the current character
    let curr_one = 0;
   
    // Counts number of '0's
    let numberOfZeros = 0;
   
    // Traverse the string S
    for(i = 0; i < s.length; i++)
    {
          
        // If current character is '1'
        if (s[i] == '1')
        {
              
            // Increase curr_one by one
            curr_one += 1;
        }
   
        // Otherwise
        else
        {
              
            // Increment numberofZeros by one
            numberOfZeros += 1;
   
            // Count length of substring
            // obtained y concatenating
            // preceding and succeeding
            // substrings of '1'
            prev_one += curr_one;
   
            // Store maximum size in res
            res = Math.max(res, prev_one);
   
            // Assign curr_one to prev_one
            prev_one = curr_one;
   
            // Reset curr_one
            curr_one = 0;
        }
    }
   
    // If string contains only one '0'
    if (numberOfZeros == 1)
    {
        res -= 1;
    }
      
    // Return the answer
    return res;
}
 
// Driver code
     let S = "1101";
    document.write(longestSubarray(S));
    
   // This code is contributed by splevel62.

输出：

3

时间复杂度： O(N)
辅助空间： O(N)

方法二：另一种解决问题的方法是使用滑动窗口技术，找出删除单个字符后只包含‘1’的子串的最大长度。请按照以下步骤解决问题：

• 用0初始化 3 个整数变量i, j ，用1初始化k
• 迭代字符串S的字符。
  • 对于遍历的每个字符，检查它是否为“0” 。如果发现为真，则将k减1 。
  • 如果k <0且字符在^第i^个索引是“0”，增量k和i增加1
  • 将j增加1 。
• 最后，在完全遍历字符串后打印长度j – i – 1 。

下面是上述方法的实现：

C++

// C++ Program to implement
// the above approach
#include 
using namespace std;
 
// Function to calculate the length of the
// longest substring of '1's that can be
// obtained by deleting one character
int longestSubarray(string s)
{
    // Initializing i and j as left and
    // right boundaries of sliding window
    int i = 0, j = 0, k = 1;
 
    for (j = 0; j < s.size(); ++j) {
 
        // If current character is '0'
        if (s[j] == '0')
 
            // Decrement k by one
            k--;
 
        // If k is less than zero and character
        // at ith index is '0'
        if (k < 0 && s[i++] == '0')
            k++;
    }
 
    // Return result
    return j - i - 1;
}
 
// Driver Code
int main()
{
    string S = "011101101";
    cout << longestSubarray(S);
 
    return 0;
}

Java

// Java Program to implement
// the above approach
 
import java.util.*;
 
class GFG{
 
// Function to calculate the length of the
// longest subString of '1's that can be
// obtained by deleting one character
static int longestSubarray(String s)
{
    // Initializing i and j as left and
    // right boundaries of sliding window
    int i = 0, j = 0, k = 1;
 
    for (j = 0; j < s.length(); ++j)
    {
 
        // If current character is '0'
        if (s.charAt(j) == '0')
 
            // Decrement k by one
            k--;
 
        // If k is less than zero and character
        // at ith index is '0'
        if (k < 0 && s.charAt(i++) == '0')
            k++;
    }
 
    // Return result
    return j - i - 1;
}
 
// Driver Code
public static void main(String[] args)
{
    String S = "011101101";
    System.out.print(longestSubarray(S));
 
}
}
 
// This code contributed by gauravrajput1

蟒蛇3

# Python3 program to implement
# the above approach
 
# Function to calculate the length of the
# longest substring of '1's that can be
# obtained by deleting one character
def longestSubarray(s):
     
    # Initializing i and j as left and
    # right boundaries of sliding window
    i = 0
    j = 0
    k = 1
 
    for j in range(len(s)):
         
        # If current character is '0'
        if (s[j] == '0'):
 
            # Decrement k by one
            k -= 1
 
        # If k is less than zero and character
        # at ith index is '0'
        if (k < 0 ):
            if s[i] == '0':
                k += 1
                 
            i += 1
             
    j += 1
 
    # Return result
    return j - i - 1
 
# Driver Code
if __name__ == "__main__" :
 
    S = "011101101"
     
    print(longestSubarray(S))
 
# This code is contributed by AnkThon

C＃

// C# program to implement
// the above approach
using System;
 
class GFG{
 
// Function to calculate the length of the
// longest subString of '1's that can be
// obtained by deleting one character
static int longestSubarray(string s)
{
     
    // Initializing i and j as left and
    // right boundaries of sliding window
    int i = 0, j = 0, k = 1;
 
    for(j = 0; j < s.Length; ++j)
    {
         
        // If current character is '0'
        if (s[j] == '0')
         
            // Decrement k by one
            k -= 1;
 
        // If k is less than zero and character
        // at ith index is '0'
        if (k < 0 && s[i++] == '0')
            k++;
    }
 
    // Return result
    return j - i - 1;
}
 
// Driver Code
public static void Main(string[] args)
{
    string S = "011101101";
     
    Console.Write(longestSubarray(S));
}
}
 
// This code is contributed by AnkThon

Javascript

 
// Javascript Program to implement
// the above approach
 
// Function to calculate the length of the
// longest substring of '1's that can be
// obtained by deleting one character
function longestSubarray(s)
{
    // Initializing i and j as left and
    // right boundaries of sliding window
    var i = 0, j = 0, k = 1;
 
    for (j = 0; j < s.length; ++j) {
 
        // If current character is '0'
        if (s[j] == '0')
 
            // Decrement k by one
            k--;
 
        // If k is less than zero and character
        // at ith index is '0'
        if (k < 0 && s[i++] == '0')
            k++;
    }
 
    // Return result
    return j - i - 1;
}
 
// Driver Code
var S = "011101101";
document.write( longestSubarray(S));
 

输出：

5

时间复杂度： O(N)
辅助空间： O(N)

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