#include <unordered_map>
#include <algorithm>
#include <iostream>
#include <numeric>
#include <cassert>
#include <vector>
#include <bitset>
#include <bitset>
#include <cstring>
#include <queue>
#include <set>

typedef long long llong;
const int MAXN = 500000 + 10;
const int INTINF = 1e9;
const llong INF = 1e12;

int n, m;
struct Edge
{
    int to;
    llong flow;
    llong cap;
    int rev;
};

std::vector <Edge> g[MAXN];
void addEdge(int x, int y, llong c)
{
    g[x].push_back({y, 0, c, (int)g[y].size()});
    g[y].push_back({x, 0, 0, (int)g[x].size()-1});
}

std::queue <int> q;
int dist[MAXN];
int idx[MAXN];

int source;
int sink;

bool bfs()
{
    std::fill(dist + 1, dist + 5 + n, 0);
    dist[source] = 1;
    q.push(source);

    while (!q.empty())
    {
        int top = q.front();
        q.pop();

        for (auto [to, flow, cap, rev] : g[top])
        {
            if (cap == flow) continue;
            if (dist[to] != 0) continue;
            dist[to] = dist[top] + 1;
            q.push(to);
        }
    }

    return dist[sink] != 0;
}

int dfs(int node, llong incomingFlow)
{
    if (node == sink) return incomingFlow;
    for (int i = idx[node] ; i < g[node].size() ; ++i, ++idx[node])
    {
        auto &[to, flow, cap, rev] = g[node][i];
        if (cap == flow) continue;
        if (dist[node] != dist[to] - 1) continue;
        int res = dfs(to, std::min(incomingFlow, cap - flow));
        if (res != 0)
        {
            flow += res;
            g[to][rev].flow -= res;
            return res;
        }
    }

    return 0;
}

bool vis[MAXN];
std::vector <int> sol;
void firstDFS(int node)
{
    vis[node] = true;
    for (const auto &[to, flow, cap, rev] : g[node])
    {
        if (vis[to] || flow == cap) continue;
        if (to & 1) sol.push_back(to);
        firstDFS(to);
    }
}

int p[MAXN];
void solve()
{ 
    source = n + 1;
    sink = n + 2;

    llong sum = 0;
    for (int i = 1 ; i <= n ; ++i)
    {
        sum += p[i];
    }

    llong maxFlow = 0;
    int currentFlow;
    while (bfs())
    {
        std::fill(idx + 1, idx + 5 + n, 0);
        do
        {
            currentFlow = dfs(source, INF);
            maxFlow += currentFlow;
        } while (currentFlow != 0);
    }

    std::cout << sum - maxFlow << '\n';

    firstDFS(source);
    for (const Edge &curr : g[sink])
    {
        if (!vis[curr.to]) sol.push_back(curr.to);
    }

    std::cout << sol.size() << '\n';
    for (const int &u : sol)
    {
        std::cout << u << ' ';
    }

    std::cout << '\n';
}

void input()
{
    std::cin >> n >> m;
    for (int i = 1 ; i <= n ; ++i) 
    {
        std::cin >> p[i];
        if (i & 1)
        {
            addEdge(n + 1, i, p[i]);
        } else
        {
            addEdge(i, n + 2, p[i]);
        }
    }

    for (int i = 1 ; i <= m ; ++i)
    {
        int u, v;
        std::cin >> u >> v;
        if (v & 1) std::swap(u, v);
        addEdge(u, v, INF);
    }
}

void fastIOI()
{   
    freopen("dodgeball.in", "r", stdin);
    freopen("dodgeball.out", "w", stdout);
    std::ios_base :: sync_with_stdio(0);
    std::cout.tie(nullptr);
    std::cin.tie(nullptr);
}

signed main()
{
    fastIOI();
    input();
    solve();

    return 0;
}