2026-05-14：使二进制字符串卓越的最小资本。用go言语，给定两个长度为 n 的二进制字符串 s 和 t，以及三个正整数 flipCost、swapCost、crossCost。

你不错对 s、t 进行淘气屡次操作（操作礼貌不限），指标是让最终的 s 与 t 王人备相易。

允许的操四肢：

1. 翻转操作：任选一个位置 i，把 s[i] 或 t[i] 的比特取反（0 变 1，1 变 0）。该操作徒然 flipCost。

2. 同串交换：任选两个不同位置 i、j，将 s[i] 与 s[j 对调，或将 t[i] 与 t[j 对调。该操作徒然 swapCost。

3. 跨串交换：任选一个位置 i，交换 s[i] 与 t[i]。该操作徒然 crossCost。

求：使 s 与 t 卓越所需的最小总资本。

n == s.length == t.length。

1

1

输入: s = "01000"， t = "10111"， flipCost = 10， swapCost = 2， crossCost = 2。

输出: 16。

评释注解:

咱们不错施行以下操作：

交换 s[0] 和 s[1]（swapCost = 2）。操作后，s = "10000"，t = "10111"。

交换 s[2] 和 t[2]（crossCost = 2）。操作后，s = "10100"，t = "10011"。

交换 s[2] 和 s[3]（swapCost = 2）。操作后，s = "10010"，t = "10011"。

翻转 s[4]（flipCost = 10）。操作后，s = t = "10011"。

总资本为 2 + 2 + 2 + 10 = 16。

题目来独力扣3800。

分步谨防过程

第一步：统计中枢问题类型（最重要的一步）

咱们的指标是让s和t每一位都王人备相易，最初要逐位对比两个字符串，统计扫数不匹配的位置类型，这是扫数计算的基础。

二进制字符只消0和1，两个字符串对位对比，只会出现4种情况：

1. s[i]=0，t[i]=0：王人备匹配，无需解决

2. s[i]=1，t[i]=1：王人备匹配，无需解决

3. s[i]=0，t[i]=1：界说为类型A不匹配（记总额量为a）

4. s[i]=1，t[i]=0：界说为类型B不匹配（记总额量为b）

代入输入示例统计

输入：s=01000，t=10111

逐位对比：

第0位：0 vs 1 → 类型A

第1位：1 vs 0 → 类型B

第2位：0 vs 1 → 类型A

第3位：0 vs 1 → 类型A

第4位：0 vs 1 → 类型A

最终统计死心：

a=4（4个0→1不匹配），b=1（1个1→0不匹配）

为了概况计算，咱们谐和让a ≤ b，调整后：a=1，b=4

第二步：明确三种中枢树立决议（仅针对不匹配位）

扫数不匹配的位置，只可通过翻转、同串交换、跨串交换三种操作树立。

代码上钩算了三种最优的组合决议资本，最终取最小值即是谜底。

决议1：纯翻转操作（最马虎的暴力决议）

划定：对每一个不匹配的位置，365投注app官方版单独施行翻转操作（改s或改t都不错），直到匹配。

• 总不匹配位数 = a + b

• 总资本 = (a + b) × 翻转资本

代入示例计算：

总不匹配位数=1+4=5，翻转资本=10

总资本=5×10=50

决议2：同串交换 + 剩余翻转

划定：

1. 同串交换：只可树立数目卓越的类型A和类型B不匹配（交换后径直让两组位置都匹配），最多能交换a次（因为a≤b）

2. 剩余不匹配：交换后剩下的b-a个类型B不匹配，只可用翻转操作树立

• 交换资本 = a × 同串交换资本

• 翻转资本 = (b - a) × 翻转资本

• 总资本 = 交换资本 + 翻转资本

代入示例计算：

a=1，b=4，同串交换资本=2，翻转资本=10

交换资本=1×2=2

翻转资本=(4-1)×10=30

总资本=2+30=32

决议3：跨串交换 + 同串交换 + 剩余翻转（最优决议，示例谜底开首）

划定：这是组合操作的最优解，欺诈跨串交换解决成对的不匹配，蚁集同串交换，临了解决剩余单个不匹配：

1. 总不匹配对数：total = a + b

2. 成对解决：用跨串交换+同串交换组合树立total/2对不匹配

3. 剩余单个：淌若总额量是奇数，临了剩1个不匹配，用翻转树立

• 中枢资本 = 成对数目×同串交换资本 + 差值×跨串交换资本

• 剩余资本 = 奇数个时×翻转资本

• 总资本 = 中枢资本 + 剩余资本

代入示例计算：

total=5，成对数目=2，剩余1个；跨串资本=2，同串资本=2，翻转资本=10

中枢资本=2×2 + (2-1)×2 = 4+2=6

剩余资本=1×10=10

总资本=6+10=16

第三步：收用最小资本

咱们得到三种决议的资本：

决议1：50 → 决议2：32 → 决议3：16

最终最小资本=16，和题目示例输出王人备一致。

补充：三种操作的作用交融（辅助交融）

1. 翻转操作：全能操作，单个位置树立，资本固定

2. 同串交换：批量树立一双不同类型的不匹配，比两次翻转更低廉

3. 跨串交换：对位交换s和t的字符，互助交换能高效解决批量不匹配

时辰复杂度 & 脱落空间复杂度

1. 时辰复杂度

• 中枢操作：逐位遍历一次字符串，统计不匹配类型，遍历长度为n

• 后续计算：都是固定次数的数学运算（常数时辰）

• 总时辰复杂度：O(n)

（线性时辰，解决10万长度的字符串也能高效驱动）

2. 脱落空间复杂度

• 仅使用了固定大小的变量：统计用的2×2数组、a/b/res1/res2/res3等变量

• 不管输入字符串长度n是几许，占用的脱落空间都不会变化

• 总脱落空间复杂度：O(1)

（常数空间，险些不占用脱落内存）

回归

1. 中枢历程：统计不匹配类型 → 计算三种操作组结伙本 → 取最小值

2. 示例中通过「交换+跨串交换+翻转」的组合得到最低资本16

3. 时辰复杂度O(n)，空间复杂度O(1)，好意思满适配题目最大数据界限

Go完整代码如下：

package main

import (

"fmt"

)

func minimumCost(s， t string， flipCost， swapCost， crossCost int)int64 {

cnt := [2][2]int{}

for i， ch := range s {

cnt[ch&1][t[i]&1]++

}

a := cnt[0][1]

b := cnt[1][0]

if a > b {

a， b = b， a

}

res1 := (a + b) * flipCost

res2 := a*swapCost + (b-a)*flipCost

avg := (a + b) / 2

res3 := (avg-a)*crossCost + avg*swapCost + (a+b)%2*flipCost

returnint64(min(res1， res2， res3))

}

func main {

s := "01000"

t := "10111"

flipCost := 10

swapCost := 2

crossCost := 2

result := minimumCost(s， t， flipCost， swapCost， crossCost)

fmt.Println(result)

}

Python完整代码如下：

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

def minimumCost(s: str， t: str， flipCost: int， swapCost: int， crossCost: int) -> int:

cnt = [[0， 0]， [0， 0]]

for sc， tc in zip(s， t):

cnt[ord(sc) & 1][ord(tc) & 1] += 1

a = cnt[0][1]

b = cnt[1][0]

if a > b:

a， b = b， a

res1 = (a + b) * flipCost

res2 = a * swapCost + (b - a) * flipCost

avg = (a + b) // 2

res3 = (avg - a) * crossCost + avg * swapCost + (a + b) % 2 * flipCost

return min(res1， res2， res3)

if __name__ == "__main__":

s = "01000"

t = "10111"

flipCost = 10

swapCost = 2

crossCost = 2

result = minimumCost(s， t， flipCost， swapCost， crossCost)

print(result)

C++完整代码如下：

#include

#include

#include

#include

using namespace std;

long long minimumCost(string s， string t， int flipCost， int swapCost， int crossCost) {

int cnt[2][2] = {{0， 0}， {0， 0}};

for (size_t i = 0; i

cnt[s[i] & 1][t[i] & 1]++;

}

int a = cnt[0][1];

int b = cnt[1][0];

if (a > b) {

swap(a， b);

}

long long res1 = (a + b) * flipCost;

long long res2 = a * swapCost + (b - a) * flipCost;

int avg = (a + b) / 2;

long long res3 = (avg - a) * crossCost + avg * swapCost + (a + b) % 2 * flipCost;

return min({res1， res2， res3});

}

int main {

string s = "01000";

string t = "10111";

int flipCost = 10;

int swapCost = 2;

int crossCost = 2;

long long result = minimumCost(s， t， flipCost， swapCost， crossCost);

cout

return0;

}

咱们确信东说念主工智能为等闲东说念主提供了一种“增强器具”，并致力于于共享全主义的AI常识。在这里，您不错找到最新的AI科普著述、器具评测、提拔恶果的诡秘以及行业瞻念察。

接待热枕“福大大架构师逐日一题”BET365下注，发音问可获取口试贵寓，让AI助力您的未来发展。