#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <bits/stdc++.h>
using namespace std;

class Graph
{
public:
    int V;    // No. of vertices
 
    // Pointer to an array containing adjacency lists
    list<int> *adj;
 
    Graph(int );  // Constructor
 
    void addEdge(int, int);
 
    vector<int> BFS(int, int, int []);
};
 
Graph::Graph(int V)
{
    this->V = V;
    adj = new list<int>[V+1];
}
 
void Graph::addEdge(int u, int v)
{
    adj[u].push_back(v); 
    adj[v].push_back(u); 
}
 
vector<int> Graph::BFS(int componentNum, int src,
                                    int visited[])
{
    // Mark all the vertices as not visited
    // Create a queue for BFS
    queue<int> queue;
 
    queue.push(src);
 
    visited[src] = componentNum;
    vector<int> reachableNodes;
 
    while(!queue.empty())
    {

        int u = queue.front();
        queue.pop();
 
        reachableNodes.push_back(u);
 
        // Get all adjacent vertices of the dequeued
        // vertex u. If a adjacent has not been visited,
        // then mark it visited and enqueue it
        for (auto itr = adj[u].begin();
                itr != adj[u].end(); itr++)
        {
            if (!visited[*itr])
            {
                // Assign Component Number to all the
                // reachable nodes
                visited[*itr] = componentNum;
                queue.push(*itr);
            }
        }
    }
    return reachableNodes;
}
 
void displayReachableNodes(int n,
            unordered_map <int, vector<int> > m)
{
    vector<int> temp = m[n];
    for (int i=0; i<temp.size(); i++)
        cout << temp[i] << " ";
 
    cout << endl;
}
 

void findReachableNodes(Graph g, int arr[], int n)
{
    
    int V = g.V;
 
    // Take a integer visited array and initialize
    // all the elements with 0
    int visited[V+1];
    memset(visited, 0, sizeof(visited));
 
    // Map to store list of reachable Nodes for a
    // given node.
    unordered_map <int, vector<int> > m;
 
    // Initialize component Number with 0
    int componentNum = 0;
 
    // For each node in arr[] find reachable
    // Nodes
    for (int i = 0 ; i < n ; i++)
    {
        int u = arr[i];
 
        // Visit all the nodes of the component
        if (!visited[u])
        {
            componentNum++;
 
            // Store the reachable Nodes corresponding to
            // the node 'i'
            m[visited[u]] = g.BFS(componentNum, u, visited);
        }
 
        displayReachableNodes(visited[u], m);
    }
}
 

int main()
{
    int n,m;
    cin>>n>>m;
    Graph g(n);
    int arr[n];
    for(int i=0;i<n;i++) arr[i]=i;
    while(n--)
    {int i; cin>>i;}
    while(m--)
    {
       int u,v;
        cin>>u>>v;
        g.addEdge(u, v);     
    }
    findReachableNodes(g, arr, n);
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

//==========================================================

int findMaxWeight( const vector< vector<int> > &graph, const vector<int> &weight, vector<int> &maxWeight, int i )
{
   if ( maxWeight[i] >= 0 ) return maxWeight[i];    // Already dealt with
   int result = weight[i];
   for ( int j : graph[i] ) result = max( result, findMaxWeight( graph, weight, maxWeight, j ) );
   maxWeight[i] = result;
   return result;
}

//==========================================================

int main()
{
   istringstream in();
   int n, m;
   cin >> n >> m;
   vector< vector<int> > graph( n );        // Collection of direct successors for each node
   vector<int> weight( n );                 // Weights
   vector<int> maxWeight( n, -1 );          // Maximum weight of node or successors (-1 implies unvisited)

   for ( int i = 0; i < n; i++ ) cin >> weight[i];

   for ( int i = 0; i < m; i++ )
   {
      int a, b;
      cin >> a >> b;
      graph[a].push_back( b );              // One-way relationship (directed graph)
   }

   for ( int i = 0; i < n; i++ ) findMaxWeight( graph, weight, maxWeight, i );

   for ( int i = 0; i < n; i++ ) cout << maxWeight[i] << ' ';
   cout << '\n';
}

#include <cstdio> 
#include <vector> 
#include <iostream>
#include <algorithm> 
using namespace std;
struct Node
{
    int weight;
    std::vector<int> successors;
};
int main() {
    int n, m;
    cin >> n >> m;
    std::vector<Node> nodes;
    nodes.resize(n);
    for (int i = 0; i < n; ++i)
    {
        int w;
        cin >> w;
        nodes[i].weight = w;
    }
    for (int i = 0; i < m; ++i)
    {
        int l, r;
        cin >> l >> r;
        nodes[l].successors.push_back(r);
    }
    for (int i = 0; i < n; ++i)
    {
        int maxWeight = nodes[i].weight;
        for (int j = 0; j < nodes[i].successors.size(); ++j)
        {
            if (maxWeight < nodes[nodes[i].successors[j]].weight)
            {
                maxWeight = nodes[nodes[i].successors[j]].weight;
            }
        }
        cout << maxWeight;
        if (i != n - 1)cout << " ";
    }
    return 0;
}