2025-01-21:使二进制数组全部等于 1 的最少操作次数Ⅰ。用go语言
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 {
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
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
#include
int minOperations(std::vector& 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 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;
}
}在这里插入图片描述