#include <bits/stdc++.h>

const int N = 2e5 + 5;

struct edge {
    int next, to;
} e[N << 1];
int ecnt, ehead[N];

std::string cl;
int dfn[N], low[N], bel[N], dep[N];
bool vis[N], bridge[N];

int fa[N][18];
int n, m;

inline void AddEdge(const int u, const int v) {
    e[++ecnt] = {ehead[u], v}, ehead[u] = ecnt;
    e[++ecnt] = {ehead[v], u}, ehead[v] = ecnt;
}

void init() {
    ecnt = 1;
    memset(ehead, 0, sizeof(int) * (n + 1));
    memset(dfn, 0, sizeof(int) * (n + 1));
    memset(low, 0, sizeof(int) * (n + 1));
    memset(bel, 0, sizeof(int) * (n + 1));
    memset(bridge, 0, sizeof(bool) * (m + 1));
}

void dfs(const int u) {
    for (int i = 1; i < 18; ++i) {
        fa[u][i] = fa[fa[u][i - 1]][i - 1];
    }

    dfn[u] = low[u] = ++dfn[0];
    vis[u] = true;
    for (int i = ehead[u]; i; i = e[i].next) {
        int v = e[i].to;
        if (dfn[v] == 0) {
            fa[v][0] = u;
            dep[v] = dep[u] + 1;
            dfs(v);
            low[u] = std::min(low[u], low[v]);
            if (low[v] > dfn[u]) {
                bridge[i / 2] = true;
            }
        } else if (vis[v]) {
            low[u] = std::min(low[u], dfn[v]);
        }
    }
    vis[u] = false;
}

void shrink(const int u) {
    bel[u] = bel[0];
    for (int i = ehead[u]; i; i = e[i].next) {
        auto v = e[i].to;
        if (bel[v] == 0 && !bridge[i / 2]) {
            shrink(v);
        }
    }
}

void tarjan() {
    dep[1] = 1;
    memset(fa[1], 0, sizeof(fa[1]));
    dfs(1);
    for (int i = 1; i <= n; ++i) {
        if (bel[i] == 0 && dfn[i] != 0) {
            ++bel[0];
            shrink(i);
        }
    }
}

int GetLca(int u, int v) {
    if (dep[u] > dep[v]) {
        std::swap(u, v);
    }
    for (int i = 17; i >= 0; --i)
        if (dep[fa[v][i]] >= dep[u])
            v = fa[v][i];
    if (u == v) {
        return u;
    }
    for (int i = 17; i >= 0; --i)
        if (fa[u][i] != fa[v][i])
            u = fa[u][i], v = fa[v][i];
    return fa[u][0];
}

int main() {
    // freopen("in", "r", stdin);
    int ttt;
    std::cin >> ttt;
    while (ttt--) {
        std::vector<std::pair<int,int>> diff;
        std::cin >> n >> m;
        std::cin >> cl;
        init();
        for (int i = 0, u, v; i < m; ++i) {
            std::cin >> u >> v;
            if (cl[u] == cl[v]) {
                diff.emplace_back(u, v);
            } else {
                AddEdge(u, v);
            }
        }
        tarjan();
        bool flag = false;
        for (auto &[u, v]: diff) {
            if (dfn[u] == 0 || dfn[v] == 0) {
                continue;
            }
            int w = GetLca(u, v);
            if (w == u || w == v) {
                flag = true;
                break;
            }
            if (bel[fa[w][0]] == bel[u] && bel[fa[w][0]] == bel[v]) {
                flag = true;
                break;
            }
        }
        if (flag) {
            std::cout << "yes\n";
        } else {
            std::cout << "no\n";
        }
    }
    return 0;
}