Bittijono

#include <bits/stdc++.h>
 
using namespace std;
using ll = long long;
 
ll n;
ll a, b;
 
string in;
string target;
 
bool flips[100001];
 
inline ll mini(ll a, ll b) {
    return a < b ? a : b;
}
 
inline ll maxi(ll a, ll b) {
    return a > b ? a : b;
}
 
ll res = 0;
 
int main() {
    cin.tie(NULL);
    ios_base::sync_with_stdio(false);
 
    cin >> n >> a >> b;
 
    cin >> in >> target;
 
    for (ll i = 0; i < n; i++) {
        flips[i] = in[i] != target[i];
    }
 
    // if b <= a, never flipping a wrong bit is optimal
    // huh? bug in this branch?
    /*if (b <= a) {
        ll bc = 0;
        for (ll i = 0; i < n; i++) {
            if (!flips[i]) continue;
 
            ll j = i;
            while (j < n && flips[j]) j++;
            i = j-1;
            bc++;
        }
 
        cout << b * bc << '\n';
    } else */{
        // now flipping a contiguous section of 1 wrong bit is optimal
        // if a*2 < b then flipping 2 wrong bits is optimal, too
        // if a*n < b then flipping n wrong bits is optimal, too
        ll optimal_wrong_flips = (b)/a;
        ll bc = 0;
        ll ac = 0;
        for (ll i = 0; i < n; i++) {
            if (!flips[i]) continue;
            ll j = i;
            bool do_it = false;
again:
            while (j < n && flips[j]) j++;
            // is the non-flipped section small enough to be optimal?
            do_it = false;
            if ((j - i)*a >= b) {
                for (ll off = 0; off < optimal_wrong_flips; off++) {
                    if (j + off >= n) {
                        do_it = false;
                        break;
                    }

                    if (flips[j+off]) {
                        do_it = true;
                        break;
                    }
                }
            }
            if (do_it && j < n) {
                ll small_flips = 0;
                while (j < n && !flips[j]) {
                    small_flips++;
                    j++;
                }
                if (small_flips * a > b) {
                    bc++;
                } else {
                    ac += small_flips;
                }
                if (j < n) {
                    goto again;
                }
            }
 
            if ((j-i)*a > b) { // one big flip or
                bc++;
            } else {
                ac += j-i; // many small ones?
            }
            i = j-1;
        } 
        //cout << "a: " << ac << ", b: " << bc << '\n';
        cout << a*ac + b*bc << '\n';
    }
 
    return 0;
}

Test 1 (public)

Group: 1, 3

Verdict: WRONG ANSWER

Test 2

Group: 1, 2, 3

Verdict: ACCEPTED

Test 3

Group: 1, 3

Verdict: ACCEPTED

Test 4

Group: 1, 3

Verdict: ACCEPTED

Test 5

Group: 1, 3

Verdict: ACCEPTED

Test 6

Group: 3

Verdict: ACCEPTED

Test 7

Group: 2, 3

Verdict: ACCEPTED

Test 8

Group: 3

Verdict: ACCEPTED

Test 9

Group: 2, 3

Verdict: ACCEPTED

Test 10

Group: 2, 3

Verdict: ACCEPTED

Test 11

Group: 3

Verdict: WRONG ANSWER

Test 12

Group: 2, 3

Verdict: ACCEPTED

Test 13

Group: 3

Verdict: ACCEPTED

Test 14

Group: 3

Verdict: WRONG ANSWER

Test 15

Group: 3

Verdict: WRONG ANSWER

Test 16

Group: 1, 2, 3

Verdict: ACCEPTED

Test 17

Group: 1, 3

Verdict: WRONG ANSWER

Test 18

Group: 1, 3

Verdict: ACCEPTED

Test 19

Group: 3

Verdict: ACCEPTED

Test 20

Group: 3

Verdict: ACCEPTED