rt

#include <bits/stdc++.h>
using namespace std;
int n, vis[100010], b[100010], flag = 0;
vector <int> e[100010];
vector <int> huan;
stack <int> s;
double k, p[100010], dp[100010][2], hdp[100010][2], ans = 0;
void dfs(int l, int u)
{
	if(flag)
	{
		return;
	}
	if(vis[u] == 1)
	{
		while(1)
		{
			int v = s.top();
			s.pop();
			huan.push_back(v);
			b[v] = 1;
			if(v == u)
			{
				flag = 1;
				return;
			}
		}
	}
	vis[u] = 1;
	s.push(u);
	for(int i = 0; i < e[u].size(); ++i)
	{
		int v = e[u][i];
		if(v == l)
		{
			continue;
		}
		dfs(u, v);
	}
	s.pop();
}
void dfs2(int l, int u)
{
	double max0 = 0, max1 = 0;
	dp[u][1] = p[u];
	for(int i = 0; i < e[u].size(); ++i)
	{
		int v = e[u][i];
		if(b[v] || v == l)
		{
			continue;
		}
		dfs2(u, v);
		max0 = max(max0, dp[v][0]);
		max1 = max(max1, dp[v][1]);
	}
	dp[u][1] += max0;
	dp[u][0] = max(max1, max0);
}
int main()
{
	cin >> n;
	for(int i = 1; i <= n; ++i)
	{
		cin >> p[i];
	}
	for(int i = 1; i <= n; ++i)
	{
		int u, v;
		cin >> u >> v;
		++u;
		++v;
		e[u].push_back(v);
		e[v].push_back(u);
	}
	cin >> k;
	
	dfs(-1, 1);
	
	for(int i = 0; i < huan.size(); ++i)
	{
		int u = huan[i];
		dfs2(-1, u);
	}
	
	memset(hdp, -0x3f, sizeof(hdp));
	hdp[0][0] = dp[huan[0]][0];
	for(int i = 1; i < huan.size(); ++i)
	{
		hdp[i][1] = hdp[i - 1][0] + dp[huan[i]][1];
		hdp[i][0] = max(hdp[i - 1][1], hdp[i - 1][0]) + dp[huan[i]][0];
	}
	ans = max(hdp[huan.size() - 1][0], hdp[huan.size() - 1][1]);
	
	memset(hdp, -0x3f, sizeof(hdp));
	hdp[0][1] = dp[huan[0]][1];
	for(int i = 1; i < huan.size(); ++i)
	{
		hdp[i][1] = hdp[i - 1][0] + dp[huan[i]][1];
		hdp[i][0] = max(hdp[i - 1][1], hdp[i - 1][0]) + dp[huan[i]][0];
	}
	ans = max(ans, hdp[huan.size() - 1][0]);
	
	printf("%.1f", ans * k);
	return 0;
}