2025-01-21：使二进制数组全部等于 1 的最少操作次数Ⅰ。用go语言，给定一个二进制数组 nums，你可以进行以下操作任意次数（包括0次）：

选择数组中任意连续的3个元素，并将它们全部反转。反转的操作是将0变为1，或将1变为0。

你的任务是返回将 nums 中所有元素变为1所需的最小操作次数。如果无法将所有元素变为1，则返回 -1。

3 <= nums.length <= 100000。

0 <= nums[i] <= 1。

输入：nums = [0,1,1,1,0,0]。

输出：3。

解释：

我们可以执行以下操作：

选择下标为 0 ，1 和 2 的元素并反转，得到 nums = [1,0,0,1,0,0] 。

选择下标为 1 ，2 和 3 的元素并反转，得到 nums = [1,1,1,0,0,0] 。

选择下标为 3 ，4 和 5 的元素并反转，得到 nums = [1,1,1,1,1,1] 。

大体步骤如下：

1.初始化变量n为数组nums的长度，初始化变量ans为0，用于记录操作次数。

2.遍历数组nums：

2.1.如果当前元素为0：

2.1.1.检查是否到达数组末尾前3个元素，若是则无法完成操作返回-1。

2.1.2.将当前元素及后两个元素进行异或操作，即0变为1，1变为0。

2.1.3.增加操作次数ans。

3.返回操作次数ans作为结果。

总的时间复杂度：

遍历数组一次为O(n)，其中n为nums的长度，每次操作都固定是3个元素，因此可以看作是常数时间复杂度操作。

总的额外空间复杂度：

除了存储输入数组nums外，算法本身并没有使用额外的空间，因此额外空间复杂度为O(1)。

Go完整代码如下：

package main

import (
	"fmt"
)

func minOperations(nums []int) int {
	n := len(nums)
	ans := 0
	for i := 0; i < n; i++ {
		if nums[i] == 0 {
			if i > n-3 {
				return -1
			}
			nums[i] ^= 1
			nums[i+1] ^= 1
			nums[i+2] ^= 1
			ans++
		}
	}
	return ans
}

func main() {
	nums := []int{0, 1, 1, 1, 0, 0}
	result := minOperations(nums)
	fmt.Println(result)
}

Rust完整代码如下：

fn min_operations(nums: &mut Vec<i32>) -> i32 {
    let n = nums.len();
    let mut ans = 0;

    for i in 0..n {
        if nums[i] == 0 {
            if i > n - 3 {
                return -1;
            }
            nums[i] ^= 1;
            nums[i + 1] ^= 1;
            nums[i + 2] ^= 1;
            ans += 1;
        }
    }
    ans
}

fn main() {
    let mut nums = vec![0, 1, 1, 1, 0, 0];
    let result = min_operations(&mut nums);
    println!("{}", result);
}

C完整代码如下：

#include <stdio.h>

int minOperations(int* nums, int n) {
    int ans = 0;

    for (int i = 0; i < n; i++) {
        if (nums[i] == 0) {
            // 如果当前位置 i 超过 n - 3，即剩余数小于 3，无法进行操作
            if (i > n - 3) {
                return -1;
            }
            // 反转当前元素及其后面两个元素
            nums[i] ^= 1;
            nums[i + 1] ^= 1;
            nums[i + 2] ^= 1;
            ans++;
        }
    }
    return ans;
}

int main() {
    int nums[] = {0, 1, 1, 1, 0, 0};
    int size = sizeof(nums) / sizeof(nums[0]);
    int result = minOperations(nums, size);
    printf("%d\n", result);
    return 0;
}

C++完整代码如下：

#include <iostream>
#include <vector>

int minOperations(std::vector<int>& nums) {
    int n = nums.size();
    int ans = 0;

    for (int i = 0; i < n; i++) {
        if (nums[i] == 0) {
            // 如果当前位置 i 超过 n - 3，即剩余数小于 3，无法进行操作
            if (i > n - 3) {
                return -1;
            }
            // 反转当前元素及其后面两个元素
            nums[i] ^= 1;
            nums[i + 1] ^= 1;
            nums[i + 2] ^= 1;
            ans++;
        }
    }
    return ans;
}

int main() {
    std::vector<int> nums = {0, 1, 1, 1, 0, 0};
    int result = minOperations(nums);
    std::cout << result << std::endl;
    return 0;
}

Python完整代码如下：

# -*-coding:utf-8-*-

def min_operations(nums):
    n = len(nums)
    ans = 0

    for i in range(n):
        if nums[i] == 0:
            if i > n - 3:
                return -1
            nums[i] ^= 1
            nums[i + 1] ^= 1
            nums[i + 2] ^= 1
            ans += 1
            
    return ans

if __name__ == "__main__":
    nums = [0, 1, 1, 1, 0, 0]
    result = min_operations(nums)
    print(result)

JavaScript完整代码如下：

function minOperations(nums) {
    const n = nums.length;
    let ans = 0;

    for (let i = 0; i < n; i++) {
        if (nums[i] === 0) {
            if (i > n - 3) {
                return -1;
            }
            nums[i] ^= 1;
            nums[i + 1] ^= 1;
            nums[i + 2] ^= 1;
            ans++;
        }
    }
    return ans;
}

const nums = [0, 1, 1, 1, 0, 0];
const result = minOperations(nums);
console.log(result);

Solidity完整代码如下：

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract MinOperations {
    function minOperations(uint256[] memory nums) public pure returns (int256) {
        uint256 n = nums.length;
        int256 ans = 0;

        for (uint256 i = 0; i < n; i++) {
            if (nums[i] == 0) {
                if (i > n - 3) {
                    return -1; // 如果剩余元素不足以进行操作返回 -1
                }
                // 反转当前元素及其后面两个元素
                nums[i] = nums[i] ^ 1;
                nums[i + 1] = nums[i + 1] ^ 1;
                nums[i + 2] = nums[i + 2] ^ 1;
                ans++;
            }
        }
        return ans;
    }
}