1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

int c[200200];
vector<int> nbhs[400400];
int visited[200200];
vector<int> cmpnts[200200];

int trnslt;
unordered_map<int, int> trnslts;

unordered_map<ll, bool> sstates[200200];

void dfs(int v, int cmpnt) {
    if(visited[v]) {
        return;
    }
    visited[v] = cmpnt;
    cmpnts[cmpnt].push_back(v);
    trnslts[v] = trnslt++;

    for(auto u: nbhs[v]) {
        dfs(u, cmpnt);
    }
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int n, m;
    cin >> n >> m;

    for(int i = 1; i <= n; i++) {
        cin >> c[i];
    }

    for(int i = 0; i < m; i++) {
        int a, b;
        cin >> a >> b;

        nbhs[a].push_back(b);
        nbhs[b].push_back(a);
    }

    int cmpnt = 1;
    for(int i = 1; i <= n; i++) {
        trnslt = 1;
        if(!visited[i]) {
            dfs(i, cmpnt++);
        }
    }

    ll res = 1;
    deque<ll> states;
    for(int i = 1; i < cmpnt; i++) {
        ll initial_state = 0;
        for(auto v: cmpnts[i]) {
            initial_state <<= 1;
            initial_state += c[v];
        }
        states.push_back(initial_state);
        sstates[i][initial_state] = true;
        sstates[i][~initial_state] = true;

        while(states.size()) {
            for(auto v: cmpnts[i]) {
                for(auto u: nbhs[v]) {
                    ll vs = cmpnts[i].size() - trnslts[v]; 
                    ll us = cmpnts[i].size() - trnslts[u];
                    ll vt = 1<<vs;
                    ll ut = 1<<us;

                    ll new_state = states.front();
                    if(((new_state&vt)>>vs) == ((new_state&ut)>>us)) {
                        new_state ^= (1<<vs)^(1<<us);
                    }

                    if(!sstates[i][new_state]) {
                        sstates[i][new_state] = true;
                        sstates[i][~new_state] = true;
                        states.push_back(new_state);
                    }
                }
            }
            states.pop_front();
        }
        res *= (ll)(sstates[i].size()/2);
        res %= (ll)(1e9+7);
    }
    cout << res << "\n";

    return 0;
}