#!/bin/python3

INF = float("inf")


class Dinic:
    def __init__(self, n):
        self.lvl = [0] * n
        self.ptr = [0] * n
        self.q = [0] * n
        self.adj = [[] for _ in range(n)]

    def add_edge(self, a, b, c, rcap=0):
        self.adj[a].append([b, len(self.adj[b]), c, 0])
        self.adj[b].append([a, len(self.adj[a]) - 1, rcap, 0])

    def dfs(self, v, t, f):
        if v == t or not f:
            return f

        for i in range(self.ptr[v], len(self.adj[v])):
            e = self.adj[v][i]
            if self.lvl[e[0]] == self.lvl[v] + 1:
                p = self.dfs(e[0], t, min(f, e[2] - e[3]))
                if p:
                    self.adj[v][i][3] += p
                    self.adj[e[0]][e[1]][3] -= p
                    return p
            self.ptr[v] += 1

        return 0

    def calc(self, s, t):
        flow, self.q[0] = 0, s
        for l in range(31):  # l = 30 maybe faster for random data
            while True:
                self.lvl, self.ptr = [0] * len(self.q), [0] * len(self.q)
                qi, qe, self.lvl[s] = 0, 1, 1
                while qi < qe and not self.lvl[t]:
                    v = self.q[qi]
                    qi += 1
                    for e in self.adj[v]:
                        if not self.lvl[e[0]] and (e[2] - e[3]) >> (30 - l):
                            self.q[qe] = e[0]
                            qe += 1
                            self.lvl[e[0]] = self.lvl[v] + 1

                p = self.dfs(s, t, INF)
                while p:
                    flow += p
                    p = self.dfs(s, t, INF)

                if not self.lvl[t]:
                    break

        return flow

n, m = map(int, input().split())
adj = [set() for _ in range(n)]
for _ in range(m):
    u, v = map(int, input().split())
    adj[u-1].add(v-1)
    adj[v-1].add(u-1)

s = input()

flow = Dinic(2*n + 2)
a = 2*n 
b = a + 1

for i in range(n):
    if s[i] == '0':
        v0 = i
        v1 = n + i
        flow.add_edge(a, v0, 2)
        flow.add_edge(v1, b, 1)
        flow.add_edge(v0, v1, int(1e8))
    else:
        v0 = n + i
        v1 = i
        flow.add_edge(a, v1, 1)
        flow.add_edge(v0, b, 2)
        flow.add_edge(v1, v0, int(1e8))
    for x in adj[i]:
        if s[x] == '0':
            vx0 = x
            vx1 = n + x
            flow.add_edge(vx0, v0, int(1e8))
            flow.add_edge(v1, vx1, int(1e8))
        else:
            vx0 = n + x
            vx1 = x
            flow.add_edge(v0, vx0, int(1e8))
            flow.add_edge(vx1, v1, int(1e8))

mvc = flow.calc(a, b)
mis = 3*n - mvc
out = 2*n - mis
print(out)