#include <cstdio>
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <iostream>
//#include <gtest/gtest.h>

using std::cin;
using std::cout;
using std::endl;
using std::max;
using std::vector;

struct Table {
	int numberOfRows;
	int setID;

	Table(int numberOfRows, int setID) :
			numberOfRows(numberOfRows), setID(setID) {
	}
};

int maximumNumberOfRows = -1;
vector<int> parent;
vector<int> rank;
vector<Table> tables;

int find(int i) {
	if (i != parent[i])
		parent[i] = find(parent[i]);
	return parent[i];
}

void unite(int destination, int source) {
	int destination_id = find(destination);
	int source_id = find(source);
	if (destination_id == source_id)
		return;
	if (rank[destination_id] > rank[source_id])
		parent[source_id] = destination_id;
	else {
		parent[destination_id] = source_id;
		if (rank[destination_id] == rank[source_id])
			rank[source_id] = rank[source_id] + 1;
	}
}

void merge(int destination, int source) {
	int d = find(destination);
	int s = find(source);
	Table* realDestination = &tables[d];
	Table* realSource = &tables[s];
	if (d == s) {
		return;
	}
	maximumNumberOfRows = max(maximumNumberOfRows,
			tables[realDestination->setID].numberOfRows + tables[realSource->setID].numberOfRows);
	realDestination->numberOfRows = tables[realDestination->setID].numberOfRows
			+ tables[realSource->setID].numberOfRows;
	realSource->numberOfRows = 0;
	realSource->setID = d;
	realDestination->setID = d;
	unite(destination, source);
}

int main() {
	int n, m;
	cin >> n >> m;

	parent.resize(n);
	rank.resize(n);
//	tables.resize(n);
	for (int i = 0; i < n; i++) {
		int numberOfRows;
		cin >> numberOfRows;
		tables.push_back(Table(numberOfRows, i));
//		tables[i] = Table(numberOfRows, i);
		parent[i] = i;
		rank[i] = 0;
		maximumNumberOfRows = max(maximumNumberOfRows, numberOfRows);
	}

	for (int i = 0; i < m; i++) {
		int destination, source;
		cin >> destination >> source;
		--destination;
		--source;

		merge(destination, source);
		cout << maximumNumberOfRows << endl;
	}

	return 0;
}

//TEST(MergingTables, t) {
//    maximumNumberOfRows = 1;
//    rank = {0, 0, 0, 0, 0};
//    parent = {0, 1, 2, 3, 4};
//    tables = {Table(1, 0), Table(1, 1), Table(1, 2), Table(1, 3), Table(1, 4)};
//
//    merge(2, 4);
//    ASSERT_EQ(2, maximumNumberOfRows);
//
//    merge(1, 3);
//    ASSERT_EQ(2, maximumNumberOfRows);
//
//    merge(0, 3);
//    ASSERT_EQ(3, maximumNumberOfRows);
//
//    merge(4, 3);
//    ASSERT_EQ(5, maximumNumberOfRows);
//
//    merge(4, 2);
//    ASSERT_EQ(5, maximumNumberOfRows);
//}
//
//TEST(MergingTables, t1) {
//    maximumNumberOfRows = 10;
//    rank = {0, 0, 0, 0, 0, 0};
//    parent = {0, 1, 2, 3, 4, 5};
//    tables = {Table(10, 0), Table(0, 1), Table(5, 2), Table(0, 3), Table(3, 4), Table(3, 5)};
//
//    merge(5, 5);
//    ASSERT_EQ(10, maximumNumberOfRows);
//
//    merge(5, 4);
//    ASSERT_EQ(10, maximumNumberOfRows);
//
//    merge(4, 3);
//    ASSERT_EQ(10, maximumNumberOfRows);
//
//    merge(3, 2);
//    ASSERT_EQ(11, maximumNumberOfRows);
//}