Comment puis-je résoudre ce problème pour toutes les contraintes

Le fermier John a N vaches dans une lignée (1≤N≤3⋅10^5). Malheureusement, une maladie se propage partout.
Au début, certaines vaches sont infectées au début. Chaque nuit, une vache infectée transmet la maladie aux vaches situées à sa gauche et à sa droite (si elles existent). Une fois qu’une vache est infectée, elle reste infectée.
Après un certain nombre de nuits, le fermier John se rend compte que le problème est devenu incontrôlable, alors il teste ses vaches pour déterminer qui est malade. Trouvez le nombre minimum de vaches qui auraient pu commencer à souffrir de la maladie.
SAISIR:
La première ligne contient N, le nombre de vaches que possède le fermier John.
La ligne suivante contient une chaîne de caractères N composée uniquement de 1 et de 0, où un 1 représente une vache infectée et un 0 représente une vache non infectée après un certain nombre de nuits.
SORTIR:
Afficher un seul entier : le nombre minimum de vaches qui auraient pu commencer à souffrir de la maladie.
EXEMPLE D’ENTRÉE :
5
11111

EXEMPLE DE SORTIE :
1

Supposons que la vache du milieu soit la seule à être infectée au départ. Les vaches seraient alors infectées dans l’ordre suivant :
0 nuit : 00100 (la troisième vache est initialement infectée)
1 nuit : -> 01110 (les deuxième et quatrième vaches sont désormais infectées)
2 nuits : -> 11111 (les première et cinquième vaches sont désormais infectées)
3 nuits : -> 11111 (toutes les vaches étaient déjà infectées, donc aucune vache supplémentaire n’est infectée)
->…

Après deux nuits ou plus, l’état final des vaches ressemblerait à l’entrée. Il existe de nombreux autres états initiaux et nombres de nuits qui auraient pu produire l’état d’entrée, tels que :
0 nuits : 10001
1 nuit : -> 11011
2 nuits : -> 11111

ou:
0 nuits : 01001
1 nuit : -> 11111

ou:
0 nuits : 01000
1 nuit : -> 11100
2 nuits : -> 11110
3 nuits : -> 11111

Tous ces états initiaux contiennent au moins une vache infectée.
EXEMPLE D’ENTRÉE :
6
011101

EXEMPLE DE SORTIE :
4

Ce que j’ai essayé :

J’ai essayé 2 solutions différentes, en passant quelques points de test, certains différents :
1.

#include <iostream>
#include <vector>

int calculate_infected_cows(const std::vector<int>& cow_states) {
    int total_infected = 0;
    int consecutive_ones = 0;

    for (int i = 0; i < cow_states.size(); ++i) {
        if (cow_states[i] == 1) {
            consecutive_ones++;
        } else {
            int current_sequence_length = consecutive_ones;
            consecutive_ones = 0;

            if (current_sequence_length == 1 || current_sequence_length == 2) {
                total_infected += current_sequence_length;
            } else if (current_sequence_length >= 3) {
                if (i + 1 < cow_states.size() && cow_states[i + 1] == 0) {
                    total_infected += (current_sequence_length + 1) / 2; // Adjusted logic
                } else {
                    total_infected += current_sequence_length;
                }
            } else {
                total_infected += current_sequence_length;
            }
        }
    }

    // Consider the last cow
    total_infected += consecutive_ones;

    // If all cows are infected, set total_infected to 1
    if (total_infected == cow_states.size()) {
        total_infected = 1;
    }

    return total_infected;
}

int main() {
    int n;
    std::cin >> n;

    std::vector<int> cow_states(n);
    for (int i = 0; i < n; ++i) {
        char c;
        std::cin >> c;
        cow_states[i] = c - '0';
    }

    int result = calculate_infected_cows(cow_states);
    std::cout << result << std::endl;

    return 0;
}

2.

#include <iostream>
#include <vector>

bool is_consecutive_ones(const std::vector<int>& cow_states, int index) {
    return index >= 2 && cow_states[index - 1] == 1 && cow_states[index - 2] == 1;
}

int calculate_infected_cows(const std::vector<int>& cow_states) {
    int total_infected = 0;
    int consecutive_ones = 0;
    bool override_total = false;

    for (int i = 0; i < cow_states.size(); ++i) {
        if (cow_states[i] == 1) {
            consecutive_ones++;
        } else {
            int current_sequence_length = consecutive_ones;
            consecutive_ones = 0;

            if (current_sequence_length == 1 || current_sequence_length == 2) {
                total_infected += current_sequence_length;
            } else if (current_sequence_length >= 3 && current_sequence_length % 2 == 1) {
                if (i + 1 < cow_states.size() && cow_states[i + 1] == 0) {
                    total_infected++;
                } else if (is_consecutive_ones(cow_states, i)) {
                    total_infected++;
                    override_total = true;
                } else {
                    total_infected += current_sequence_length;
                }
            } else {
                if (current_sequence_length == 3) {
                    if (i - 1 >= 0 && cow_states[i - 1] == 0 && i + 1 < cow_states.size() && cow_states[i + 1] == 0) {
                        total_infected++;
                    } else {
                        total_infected += current_sequence_length;
                    }
                } else {
                    total_infected += current_sequence_length;
                }
            }
        }
    }

    if (override_total) {
        total_infected += consecutive_ones;
    } else {
        total_infected += cow_states.back(); // Consider the last cow
    }

    return total_infected;
}

int main() {
    int n;
    std::cin >> n;

    std::vector<int> cow_states(n);
    for (int i = 0; i < n; ++i) {
        char c;
        std::cin >> c;
        cow_states[i] = c - '0';
    }

    int result = calculate_infected_cows(cow_states);
    std::cout << result << std::endl;

    return 0;
}


This is my basic logic, however I do believe it may be incorrect.

Logic for counting how many cows (n is a constant for a number of 1s):

Middle cases:
If there is a sequence of 1s with only a single 1 (a sequence is a continued string of 1s, separated by 0s from other 1s), count how many 1s there are to find total.
If there is a sequence of 2 1s, count how many 1s there are to find total
If there is a sequence of n 1s, where n is odd and n>=3, use the formula: x=(n+1)/2 to determine the day it is. Then apply the formula n=2x-1 to weed through all sequences of consecutive 1s to determine if the day count is correct.
If it is not correct (a sequence of an even number of consecutive 1s) or (an odd number of 1s not equating to the aforementioned string), count how many 1s there are to find total.
If it is correct and applies to all other sequences, add 1 to the total.

Special cases (on both ends):
If the bitstring starts with 10, erase current total and count how many 1s there are to find correct total.
If the bitstring ends in 01, erase current total and count how many 1s there are to find correct total.
If the bristring starts with 110, there may be 2 original cows, or only 1, depending on the middle sections.
If the bristring ends with 011, there may be 2 original cows, or only 1, depending on the middle sections.
If the bitstring starts with x0 (where z is a bitstring representing the number x of 1s), there may be x original cows or only 1, depending on the middle sections.
If the bitstring starts with 0x (where z is a bitstring representing the number x of 1s), there may be x original cows or only 1, depending on the middle sections.