Flip String to Monotone Increasing LT926

A string of '0's and '1's is monotone increasing if it consists of some number of '0's (possibly 0), followed by some number of '1's (also possibly 0.)

We are given a string S of '0's and '1's, and we may flip any '0' to a '1' or a '1' to a '0'.

Return the minimum number of flips to make S monotone increasing.

Example 1:

Input: "00110"
Output: 1
Explanation: We flip the last digit to get 00111.

Example 2:

Input: "010110"
Output: 2
Explanation: We flip to get 011111, or alternatively 000111.

Example 3:

Input: "00011000"
Output: 2
Explanation: We flip to get 00000000.

Note:

1. 1 <= S.length <= 20000
2. S only consists of '0' and '1' characters.

Idea 1. 由结果推算，if monotonic increasing string is composed of x zeros and (n-x) ones, based on the number of ones on the left and right side of str[x], the number of flips can be calculated as ones[x] + (n-x - (ones[n] - ones[x])), another example to use prefix sum to caculate ones.

flip from '1' -> '0' on the left: ones[x]

flip from '0' -> '1' on the right: n - x - (ones[n] - ones[x]) or scan the array from right to left

仔细corner case, 全部都是'0' or '1' monotonic increasing string.

Time complexity: O(n)

Space complexity: O(n)

 class Solution {
     public int minFlipsMonoIncr(String S) {
         int n = S.length();
         int[] ones = new int[n+1];
         for(int i = 1; i <=n; ++i) {
             ones[i] = ones[i-1] + S.charAt(i-1) - '0';
         }

         int result = Integer.MAX_VALUE;
         for(int i = 0; i <= n; ++i) {
             result = Math.min(result, ones[i] + (n - i) - (ones[n] - ones[i]));
         }

         return result;
     }
 }

Idea 1.b No need to build ones array, the number of ones can be computed while looping the array, just need the total number of ones in advance

Time complexity: O(n)

Space complexity: O(1)

 class Solution {
     public int minFlipsMonoIncr(String S) {
         int n = S.length();
         int totalOnes = 0;
         for(int i = 0; i < S.length(); ++i) {
             totalOnes += S.charAt(i) - '0';
         }
         int ones = 0;

         int result = Integer.MAX_VALUE;
         for(int i = 0; i <= n; ++i) {
             if(i >= 1) {
                 ones += S.charAt(i-1) - '0';
             }
             result = Math.min(result, ones + (n - i) - (totalOnes - ones));
         }

         return result;
     }
 }

稍微简洁一点，把全身1的情况做初始值

 class Solution {
     public int minFlipsMonoIncr(String S) {
         int n = S.length();
         int totalOnes = 0;
         for(int i = 0; i < S.length(); ++i) {
             totalOnes += S.charAt(i) - '0';
         }
         int ones = 0;

         int result = n - totalOnes;
         for(int i = 1; i <= n; ++i) {
             ones += S.charAt(i-1) - '0';
             result = Math.min(result, ones + (n - i) - (totalOnes - ones));
         }

         return result;
     }
 }

Idea 2. Dynamic programming, 网上看到的更赞的方法, let dp[i-1] be the minimum number of flips to make S.substring(0, i) is monotonic increasing, how to extend the solution for S.charAt(i)?

dp[i] = dp[i-1] if S.charAt(i) == '1', nothing needed, as it still satisfy monotonic increasing string.

dp[i] = Math.min(ones[i-1], dp[i-1] + 1), if S.chart(i) == '0' either flip all the previous ones to 0; or flip the current '0' to '1' since S.substring(0, i) is monotonice, add '1' still satisfies the conidtion.

Time complexity: O(n)

Space complexity: O(n)

 class Solution {
     public int minFlipsMonoIncr(String S) {
         int n = S.length();
         int[] dp = new int[n+1];
         int ones = 0;
         for(int i = 1; i <= n; ++i) {
             if(S.charAt(i-1) == '1') {
                 dp[i] = dp[i-1];
                 ++ones;
             }
             else {
                 dp[i] = Math.min(dp[i-1] + 1, ones);
             }
         }

         return dp[n];
     }
 }

Idea 2.b the above formula shows the current dp depends only on the previous number, the array dp[] is not needed

Time complexity: O(n)

Space complexity: O(1)

 class Solution {
     public int minFlipsMonoIncr(String S) {
         int n = S.length();
         int dp = 0;
         int ones = 0;
         for(int i = 1; i <= n; ++i) {
             if(S.charAt(i-1) == '1') {
                 ++ones;
             }
             else {
                 dp = Math.min(dp + 1, ones);
             }
         }

         return dp;
     }
 }