\\E
#include <bits/stdc++.h>
using namespace std;

// Represents a node in the segment tree containing transition metrics
struct TransitionNode {
    int transition_count = 0;
    long long total_alternating_sum = 0;
    long long alternating_nx_sum = 0;
    long long total_beauty_power = 0;
};

// Custom Segment Tree to dynamically track and update string transitions
class TransitionTree {
private:
    int string_length;
    vector<TransitionNode> tree_nodes;

    // Combines two adjacent segments into a single parent segment
    TransitionNode merge_nodes(const TransitionNode& left, const TransitionNode& right) {
        TransitionNode parent;
        parent.transition_count = left.transition_count + right.transition_count;

        // Update the total local alternating sum based on the right segment's size parity
        if (right.transition_count % 2 == 1) {
            parent.total_alternating_sum = right.total_alternating_sum - left.total_alternating_sum;
        } else {
            parent.total_alternating_sum = right.total_alternating_sum + left.total_alternating_sum;
        }

        // Update the alternating (n - x) sum based on the left segment's size parity
        if (left.transition_count % 2 == 1) {
            parent.alternating_nx_sum = left.alternating_nx_sum - right.alternating_nx_sum;
        } else {
            parent.alternating_nx_sum = left.alternating_nx_sum + right.alternating_nx_sum;
        }

        // Compute the combined power by factoring in the boundary offset impact
        parent.total_beauty_power = left.total_beauty_power + right.total_beauty_power 
                                    - left.total_alternating_sum * right.alternating_nx_sum;
        return parent;
    }

    void modify_transition(int node_idx, int start, int end, int target_pos, bool is_active) {
        if (start == end) {
            if (is_active) {
                tree_nodes[node_idx].transition_count = 1;
                tree_nodes[node_idx].total_alternating_sum = target_pos;
                tree_nodes[node_idx].alternating_nx_sum = string_length - target_pos;
                tree_nodes[node_idx].total_beauty_power = (long long)(string_length - target_pos) * target_pos;
            } else {
                tree_nodes[node_idx] = TransitionNode(); // Reset to empty configuration
            }
            return;
        }

        int midpoint = start + (end - start) / 2;
        if (target_pos <= midpoint) {
            modify_transition(2 * node_idx, start, midpoint, target_pos, is_active);
        } else {
            modify_transition(2 * node_idx + 1, midpoint + 1, end, target_pos, is_active);
        }
        tree_nodes[node_idx] = merge_nodes(tree_nodes[2 * node_idx], tree_nodes[2 * node_idx + 1]);
    }

   public:
    TransitionTree(int n) {
        this->string_length = n;
        tree_nodes.resize(4 * n);
    }

    void update(int position, bool is_active) {
        if (position < 1 || position >= string_length) return;
        modify_transition(1, 1, string_length - 1, position, is_active);
    }

    long long get_current_power() {
        return tree_nodes[1].total_beauty_power;
    }
};

void execute_clean_substrings() {
    int n, q;
    if (!(cin >> n >> q)) return;

    string binary_str;
    cin >> binary_str;

    TransitionTree segment_tree(n);
    // Track transition existence using a boolean status array
    vector<bool> has_transition(n, false);

    for (int i = 1; i < n; ++i) {
        if (binary_str[i - 1] != binary_str[i]) {
            has_transition[i] = true;
            segment_tree.update(i, true);
        }
    }

    // Print the initial power before updates
    cout << segment_tree.get_current_power();

    while (q--) {
        int target_idx;
        cin >> target_idx;
        target_idx--; // Convert to 0-indexed position

        // Invert character status
        binary_str[target_idx] = (binary_str[target_idx] == '0' ? '1' : '0');

        // Check and update left boundary transition
        if (target_idx > 0) {
            has_transition[target_idx] = !has_transition[target_idx];
            segment_tree.update(target_idx, has_transition[target_idx]);
        }
        // Check and update right boundary transition
        if (target_idx + 1 < n) {
            has_transition[target_idx + 1] = !has_transition[target_idx + 1];
            segment_tree.update(target_idx + 1, has_transition[target_idx + 1]);
        }

        cout << " " << segment_tree.get_current_power();
    }
    cout << "\n";
}

int main() {
    // Optimize fast standard I/O streams
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int test_cases;
    if (cin >> test_cases) {
        while (test_cases--) {
            execute_clean_substrings();
        }
    }
    return 0;
}