可以删除的最长子串的长度

给定一个二进制字符串（仅由 0 和 1 组成）。如果字符串中有“100”作为子字符串，那么我们可以删除这个子字符串。任务是找到可以删除的最长子字符串的长度？
例子：

Input  : str = "1011100000100"
Output : 6
// Sub-strings present in str that can be make removed 
// 101{110000}0{100}. First sub-string 110000-->100-->null,
// length is = 6. Second sub-string 100-->null, length is = 3

Input  : str = "111011"
Output : 0
// There is no sub-string which can be make null

我们可以使用容器，如 c++ 中的 vector 或Java中的 ArrayList 来解决这个问题。下面是解决这个问题的算法：

• 取一个pair类型的向量arr。 arr 中的每个元素都存储两个值字符，并且它是字符串中的相应索引。
• 将 pair('@',-1) 作为基础存储在 arr 中。取变量 maxlen = 0 存储最终结果。
• 现在对字符串中的所有字符逐一迭代，制作一对字符及其各自的索引并将其存储在 arr 中。同时检查条件，如果在插入第 i 个字符后，'arr' 的最后三个元素正在生成子字符串“100”。
• 如果子字符串存在，则将其从“arr”中删除。多次重复此循环，直到您在 arr 中获得子字符串“100”，并通过连续删除使其为空。
• 删除后arr中当前存在的第i个字符的索引和最后一个元素的索引的差异给出了通过连续删除子字符串“100”可以使子字符串为空的长度，更新maxlen。

C++

// C++ implementation of program to find the maximum length
// that can be removed
#include
using namespace std;
 
// Function to find the length of longest sub-string that
// can me make removed
// arr  --> pair type of array whose first field store
//          character in string and second field stores
//          corresponding index of that character
int longestNull(string str)
{
    vector > arr;
 
    // store {'@',-1} in arr , here this value will
    // work as base index
    arr.push_back({'@', -1});
 
    int maxlen = 0;   // Initialize result
 
    // one by one iterate characters of string
    for (int i = 0; i < str.length(); ++i)
    {
        // make pair of char and index , then store
        // them into arr
        arr.push_back({str[i], i});
 
        // now if last three elements of arr[]  are making
        // sub-string "100" or not
        while (arr.size()>=3 &&
               arr[arr.size()-3].first=='1' &&
               arr[arr.size()-2].first=='0' &&
               arr[arr.size()-1].first=='0')
        {
            // if above condition is true then delete
            // sub-string "100" from arr[]
            arr.pop_back();
            arr.pop_back();
            arr.pop_back();
        }
 
        // index of current last element in arr[]
        int tmp = arr.back().second;
 
        // This is important, here 'i' is the index of
        // current character inserted into arr[]
        // and 'tmp' is the index of last element in arr[]
        // after continuous deletion of sub-string
        // "100" from arr[] till we make it null, difference
        // of these to 'i-tmp' gives the length of current
        // sub-string that can be make null by continuous
        // deletion of sub-string "100"
        maxlen = max(maxlen, i - tmp);
    }
 
    return maxlen;
}
 
// Driver program to run the case
int main()
{
    cout << longestNull("1011100000100");
    return 0;
}

Java

// Java implementation of program to find
// the maximum length that can be removed
import java.util.ArrayList;
 
public class GFG
{   
    // User defined class Pair
    static class Pair{
        char first;
        int second;
        Pair(char first, int second){
            this.first = first;
            this.second = second;
        }
    }
     
    /* Function to find the length of longest
    sub-string that can me make removed
     arr  --> pair type of array whose first
              field store character in string
              and second field stores
              corresponding index of that character*/
    static int longestNull(String str)
    {
        ArrayList arr = new ArrayList<>();
      
        // store {'@',-1} in arr , here this value
        // will work as base index
        arr.add(new Pair('@', -1));
      
        int maxlen = 0;   // Initialize result
      
        // one by one iterate characters of string
        for (int i = 0; i < str.length(); ++i)
        {
            // make pair of char and index , then
            // store them into arr
            arr.add(new Pair(str.charAt(i), i));
      
            // now if last three elements of arr[]
            // are making sub-string "100" or not
            while (arr.size() >= 3 &&
                   arr.get(arr.size()-3).first=='1' &&
                   arr.get(arr.size()-2).first=='0' &&
                   arr.get(arr.size()-1).first=='0')
            {
                // if above condition is true then
                // delete sub-string "100" from arr[]
                arr.remove(arr.size() - 3);
                arr.remove(arr.size() - 2);
                arr.remove(arr.size() - 1);
            }
      
            // index of current last element in arr[]
            int tmp = arr.get(arr.size() - 1).second;
      
            // This is important, here 'i' is the index
            // of current character inserted into arr[]
            // and 'tmp' is the index of last element
            // in arr[] after continuous deletion of
            // sub-string "100" from arr[] till we make
            // it null, difference of these to 'i-tmp'
            // gives the length of current sub-string
            // that can be make null by continuous
            // deletion of sub-string "100"
            maxlen = Math.max(maxlen, i - tmp);
        }
      
        return maxlen;
    }
      
    // Driver program to run the case
    public static void main(String args[])
    {
        System.out.println(longestNull("1011100000100"));
    }
}
// This code is contributed by Sumit Ghosh

Python3

# Python3 implementation of program to find the maximum length
# that can be removed
 
# Function to find the length of longest sub-string that
# can me make removed
# arr --> pair type of array whose first field store
#         character in and second field stores
#         corresponding index of that character
def longestNull(S):
 
    arr=[]
 
    # store {'@',-1} in arr , here this value will
    # work as base index
    arr.append(['@', -1])
 
    maxlen = 0 # Initialize result
 
    # one by one iterate characters of String
    for i in range(len(S)):
        # make pair of char and index , then store
        # them into arr
        arr.append([S[i], i])
 
        # now if last three elements of arr[] are making
        # sub-string"100" or not
        while (len(arr)>=3 and
            arr[len(arr)-3][0]=='1' and
            arr[len(arr)-2][0]=='0' and
            arr[len(arr)-1][0]=='0'):
 
            # if above condition is true then delete
            # sub-string"100" from arr[]
            arr.pop()
            arr.pop()
            arr.pop()
 
        # index of current last element in arr[]
        tmp = arr[-1]
        # This is important, here 'i' is the index of
        # current character inserted into arr[]
        # and 'tmp' is the index of last element in arr[]
        # after continuous deletion of sub-String
        # "100" from arr[] till we make it null, difference
        # of these to 'i-tmp' gives the length of current
        # sub-string that can be make null by continuous
        # deletion of sub-string"100"
        maxlen = max(maxlen, i - tmp[1])
 
 
    return maxlen
 
 
# Driver code
 
print(longestNull("1011100000100"))
 
# This code is contributed by mohit kumar 29

C#

// C# implementation of program to find
// the maximum length that can be removed
using System;
using System.Collections.Generic;
 
class GFG
{
    // User defined class Pair
    class Pair
    {
        public char first;
        public int second;
        public Pair(char first, int second)
        {
            this.first = first;
            this.second = second;
        }
    }
     
    /* Function to find the length of longest
    sub-string that can me make removed
    arr --> pair type of array whose first
            field store character in string
            and second field stores
            corresponding index of that character*/
    static int longestNull(String str)
    {
        List arr = new List();
     
        // store {'@',-1} in arr , here this value
        // will work as base index
        arr.Add(new Pair('@', -1));
     
        int maxlen = 0; // Initialize result
     
        // one by one iterate characters of string
        for (int i = 0; i < str.Length; ++i)
        {
            // make pair of char and index , then
            // store them into arr
            arr.Add(new Pair(str[i], i));
     
            // now if last three elements of []arr
            // are making sub-string "100" or not
            while (arr.Count >= 3 &&
                arr[arr.Count-3].first=='1' &&
                arr[arr.Count-2].first=='0' &&
                arr[arr.Count-1].first=='0')
            {
                // if above condition is true then
                // delete sub-string "100" from []arr
                arr.RemoveAt(arr.Count - 3);
                arr.RemoveAt(arr.Count - 2);
                arr.RemoveAt(arr.Count - 1);
            }
     
            // index of current last element in []arr
            int tmp = arr[arr.Count - 1].second;
     
            // This is important, here 'i' is the index
            // of current character inserted into []arr
            // and 'tmp' is the index of last element
            // in []arr after continuous deletion of
            // sub-string "100" from []arr till we make
            // it null, difference of these to 'i-tmp'
            // gives the length of current sub-string
            // that can be make null by continuous
            // deletion of sub-string "100"
            maxlen = Math.Max(maxlen, i - tmp);
        }
     
        return maxlen;
    }
     
    // Driver code
    public static void Main(String []args)
    {
        Console.WriteLine(longestNull("1011100000100"));
    }
}
 
// This code is contributed by PrinciRaj1992

Javascript

// Javascript implementation of program to find
// the maximum length that can be removed
 
    /* Function to find the length of longest
    sub-string that can me make removed
     arr  --> pair type of array whose first
              field store character in string
              and second field stores
              corresponding index of that character*/
    function longestNull(str)
    {
        let arr = [];
        
        // store {'@',-1} in arr , here this value
        // will work as base index
        arr.push(['@', -1]);
        
        let maxlen = 0;   // Initialize result
        
        // one by one iterate characters of string
        for (let i = 0; i < str.length; ++i)
        {
            // make pair of char and index , then
            // store them into arr
            arr.push([str[i],i]);
        
            // now if last three elements of arr[]
            // are making sub-string "100" or not
            while (arr.length >= 3 &&
                   arr[arr.length-3][0]=='1' &&
                   arr[arr.length-2][0]=='0' &&
                   arr[arr.length-1][0]=='0')
            {
                // if above condition is true then
                // delete sub-string "100" from arr[]
                arr.pop();
                arr.pop();
                arr.pop();
            }
        
            // index of current last element in arr[]
            let tmp = arr[arr.length-1][1];
        
            // This is important, here 'i' is the index
            // of current character inserted into arr[]
            // and 'tmp' is the index of last element
            // in arr[] after continuous deletion of
            // sub-string "100" from arr[] till we make
            // it null, difference of these to 'i-tmp'
            // gives the length of current sub-string
            // that can be make null by continuous
            // deletion of sub-string "100"
            maxlen = Math.max(maxlen, i - tmp);
        }
        
        return maxlen;
    }
     
    // Driver program to run the case
    document.write(longestNull("1011100000100"));
 
     
    // This code is contributed by unknown2108

输出：

6