二进制字符串中零和一的最大差

给定二进制字符串0s和1s。任务是找到子串的长度，该子串的最大差值为0s和1s(0s – 1s)。如果全为1，则打印-1。

例子：

Input : S = "11000010001"
Output : 6
From index 2 to index 9, there are 7
0s and 1 1s, so number of 0s - number
of 1s is 6.

Input : S = "1111"
Output : -1

想法是使用动态编程来解决该问题。
在此之前，我们将给定的二进制字符串转换为值为1s和-1s的整数数组，例如arr []。这可以通过遍历给定的二进制字符串轻松完成，并且如果ith索引包含“ 0”，则在数组的相应位置中使-1。同样，如果第一个索引包含“ 1”，则在数组中加1。
现在，在每个索引i处，我们都需要决定是否接受它或跳过它。因此，声明一个大小为nx 2的2D数组，其中n是给定二进制字符串的长度，例如dp [n] [2]。

dp[i][0] define the maximum value upto 
         index i, when we skip the i-th
         index element.
dp[i][1] define the maximum value upto 
         index i after taking the i-th
         index element.

Therefore, we can derive dp[i][] as:
dp[i][0] = max(dp[i+1][0], dp[i+1][1] + arr[i])
dp[i][1] = max(dp[i+1][1] + arr[i], 0)

对于所有这些，我们都会明确检查这种情况。

C++

// CPP Program to find the length of
// substring with maximum difference of
// zeroes and ones in binary string.
#include 
#define MAX 100
using namespace std;
  
// Return true if there all 1s
bool allones(string s, int n)
{
    // Checking each index is 0 or not.
    int co = 0;
    for (int i = 0; i < s.size(); i++)
        co += (s[i] == '1');
  
    return (co == n);
}
  
// Find the length of substring with maximum
// difference of zeroes and ones in binary 
// string
int findlength(int arr[], string s, int n, 
              int ind, int st, int dp[][3])
{
    // If string is over.
    if (ind >= n)
        return 0;
  
    // If the state is already calculated.
    if (dp[ind][st] != -1)
        return dp[ind][st];
  
    if (st == 0)
        return dp[ind][st] = max(arr[ind] + 
          findlength(arr, s, n, ind + 1, 1, dp),
          findlength(arr, s, n, ind + 1, 0, dp));
  
    else
        return dp[ind][st] = max(arr[ind] +
       findlength(arr, s, n, ind + 1, 1, dp), 0);
}
  
// Returns length of substring which is 
// having maximum difference of number
// of 0s and number of 1s 
int maxLen(string s, int n)
{
    // If all 1s return -1.
    if (allones(s, n)) 
        return -1;    
  
    // Else find the length.
    int arr[MAX] = { 0 };
    for (int i = 0; i < n; i++) 
        arr[i] = (s[i] == '0' ? 1 : -1);    
  
    int dp[MAX][3];
    memset(dp, -1, sizeof dp);
    return findlength(arr, s, n, 0, 0, dp);
}
  
// Driven Program
int main()
{
    string s = "11000010001";
    int n = 11;
    cout << maxLen(s, n) << endl;
    return 0;
}

Java

// Java Program to find the length of
// substring with maximum difference of
// zeroes and ones in binary string.
import java.util.Arrays;
  
class GFG
{
static final int MAX=100;
  
// Return true if there all 1s
static boolean allones(String s, int n)
{
    // Checking each index is 0 or not.
    int co = 0;
    for (int i = 0; i < s.length(); i++)
        if(s.charAt(i) == '1')
            co +=1;     
  
    return (co == n);
}
  
// Find the length of substring with maximum
// difference of zeroes and ones in binary 
// string
static int findlength(int arr[], String s, int n, 
                     int ind, int st, int dp[][])
{
    // If string is over.
    if (ind >= n)
        return 0;
  
    // If the state is already calculated.
    if (dp[ind][st] != -1)
        return dp[ind][st];
  
    if (st == 0)
        return dp[ind][st] = Math.max(arr[ind] + 
                             findlength(arr, s, n, 
                                   ind + 1, 1, dp),
                             findlength(arr, s, n, 
                                   ind + 1, 0, dp));
  
    else
        return dp[ind][st] = Math.max(arr[ind] +
                             findlength(arr, s, n, 
                               ind + 1, 1, dp), 0);
}
  
// Returns length of substring which is 
// having maximum difference of number
// of 0s and number of 1s 
static int maxLen(String s, int n)
{
    // If all 1s return -1.
    if (allones(s, n)) 
        return -1; 
  
    // Else find the length.
    int arr[] = new int[MAX];
    for (int i = 0; i < n; i++) 
        arr[i] = (s.charAt(i) == '0' ? 1 : -1); 
  
    int dp[][] = new int[MAX][3];
    for (int[] row : dp)
            Arrays.fill(row, -1);
    return findlength(arr, s, n, 0, 0, dp);
}
  
// Driver code 
public static void main (String[] args)
{
    String s = "11000010001";
    int n = 11;
    System.out.println(maxLen(s, n));
}
}
  
// This code is contributed by Anant Agarwal.

Python3

# Python Program to find the length of
# substring with maximum difference of
# zeroes and ones in binary string.
MAX = 100
  
# Return true if there all 1s
def allones(s, n):
      
    # Checking each index
    # is 0 or not.
    co = 0
      
    for i in s:
        co += 1 if i == '1' else 0
  
    return co == n
  
# Find the length of substring with 
# maximum difference of zeroes and 
# ones in binary string
def findlength(arr, s, n, ind, st, dp):
      
    # If string is over
    if ind >= n:
        return 0
  
    # If the state is already calculated.
    if dp[ind][st] != -1:
        return dp[ind][st]
  
    if not st:
        dp[ind][st] = max(arr[ind] + 
           findlength(arr, s, n, ind + 1, 1, dp), 
            (findlength(arr, s, n, ind + 1, 0, dp)))
    else:
        dp[ind][st] = max(arr[ind] +
         findlength(arr, s, n, ind + 1, 1, dp), 0)
           
    return dp[ind][st]
  
# Returns length of substring which is 
# having maximum difference of number
# of 0s and number of 1s 
def maxLen(s, n):
      
    # If all 1s return -1.
    if allones(s, n):
        return -1 
  
    # Else find the length.
    arr = [0] * MAX
    for i in range(n):
        arr[i] = 1 if s[i] == '0' else -1
  
    dp = [[-1] * 3 for _ in range(MAX)]
    return findlength(arr, s, n, 0, 0, dp)
  
# Driven Program
s = "11000010001"
n = 11
print(maxLen(s, n))
  
# This code is contributed by Ansu Kumari.

C#

// C# Program to find the length of 
// substring with maximum difference of 
// zeroes and ones in binary string. 
using System; 
  
class GFG 
{ 
    static int MAX = 100; 
      
    // Return true if there all 1s 
    public static bool allones(string s, int n) 
    { 
        // Checking each index is 0 or not. 
        int co = 0; 
        for (int i = 0; i < s.Length; i++) 
            co += (s[i] == '1' ? 1 : 0); 
  
        return (co == n); 
    } 
      
    // Find the length of substring with maximum 
    // difference of zeroes and ones in binary 
    // string 
    public static int findlength(int[] arr, string s, 
                    int n, int ind, int st, int[,] dp) 
    { 
        // If string is over. 
        if (ind >= n) 
            return 0; 
      
        // If the state is already calculated. 
        if (dp[ind,st] != -1) 
            return dp[ind,st]; 
      
        if (st == 0) 
            return dp[ind,st] = Math.Max(arr[ind] + 
            findlength(arr, s, n, ind + 1, 1, dp), 
            findlength(arr, s, n, ind + 1, 0, dp)); 
      
        else
            return dp[ind,st] = Math.Max(arr[ind] + 
        findlength(arr, s, n, ind + 1, 1, dp), 0); 
    } 
      
    // Returns length of substring which is 
    // having maximum difference of number 
    // of 0s and number of 1s 
    public static int maxLen(string s, int n) 
    { 
        // If all 1s return -1. 
        if (allones(s, n)) 
            return -1;     
      
        // Else find the length. 
        int[] arr = new int[MAX];
              
        for (int i = 0; i < n; i++) 
            arr[i] = (s[i] == '0' ? 1 : -1);     
      
        int[,] dp = new int[MAX,3]; 
        for(int i = 0; i < MAX; i++)
            for(int j = 0; j < 3; j++)
                dp[i,j] = -1;
  
        return findlength(arr, s, n, 0, 0, dp); 
    } 
      
    // Driven Program
      
    static void Main() 
    { 
        string s = "11000010001"; 
        int n = 11; 
        Console.Write(maxLen(s, n)); 
    }
    // This code is contributed by DrRoot_
}

输出 ：

6

二进制字符串中零和一的最大差|设定2(O(n)时间)