#include <bits/stdc++.h>
using namespace std;

#define forn(i, n) for(int i=0; i<(n); i++)
#define readVec(v) forn(i, v.size()){cin >> v[i];}
#define printArr(arr, n) forn(i, n){if (i) cout << " "; cout << arr[i];} cout << endl;
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define f first
#define s second

typedef long long ll;
typedef double ld;
typedef long double lld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<bool> vb;
typedef vector<pii> vpi;
typedef vector<pll> vpl;
typedef vector<vi> vii;

//Printing pairs and vectors
template<typename A, typename B> ostream& operator<<(ostream &cout, pair<A, B> const &p) { return cout << "(" << p.f << ", " << p.s << ")"; }
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v) {
  cout << "["; for(int i = 0; i < v.size(); i++) {if (i) cout << ", "; cout << v[i];} return cout << "]";
}

//2 147 483 647 int max
//9 223 372 036 854 775 807 ll max
void fast_io(){
   ios_base::sync_with_stdio(0);
   cin.tie(NULL);
   cout.tie(NULL);
}
void file_io(string taskname){
   string fin = taskname + ".in";
   string fout = taskname + ".out";
   const char* FIN = fin.c_str();
   const char* FOUT = fout.c_str();
   freopen(FIN, "r", stdin);
   freopen(FOUT, "w", stdout);
   fast_io();
}

template <class F, class C> struct MCMF {
    struct Edge { int to; F flow, cap; C cost; };

    int n;
    std::vector<C> p, dist;
    std::vector<int> pre;
    std::vector<Edge> edges;
    std::vector<std::vector<int>> adj;

    const C INF  = std::numeric_limits<C>::max();

    void init(int n_) {
        n = n_;
        p.assign(n, 0);
        dist.assign(n, 0);
        pre.assign(n, 0);
        adj.clear(); adj.resize(n);
        edges.clear();
    }

    void ae(int u, int v, F cap, C cost) {
        assert(cap >= 0);
        adj[u].push_back((int)edges.size());
        edges.push_back({v, 0, cap, cost});
        adj[v].push_back((int)edges.size());
        edges.push_back({u, 0, 0, -cost});
    }

    bool path(int s, int t) {
        for (int i = 0; i < n; i++)
            dist[i] = INF;
        using T = std::pair<C, int>;
        std::priority_queue<T, std::vector<T>, std::greater<T>> todo;
        todo.push({dist[s] = 0, s});
        while (!todo.empty()) {
            T x = todo.top();
            todo.pop();
            if (x.first > dist[x.second])
                continue;
            for (auto& eid : adj[x.second]) {
                const Edge& e = edges[eid];
                if (e.flow < e.cap && dist[e.to] > x.first + e.cost + p[x.second] - p[e.to]) {
                    dist[e.to] = x.first + e.cost + p[x.second] - p[e.to];
                    pre[e.to] = eid;
                    todo.push({dist[e.to], e.to});
                }
            }
        }
        return dist[t] != INF;
    }

    std::pair<F, C> calc(int s, int t) {
        assert(s != t);
        for (int unused = 0; unused < n; unused++)
            for (int eid = 0; eid < (int)edges.size(); eid++) {
                const Edge& e = edges[eid];
                if (e.cap)
                    p[e.to] = std::min(p[e.to], p[edges[eid ^ 1].to] + e.cost);
            }
        F total_flow = 0;
        C total_cost = 0;
        while (path(s, t)) {
            for (int i = 0; i < n; i++)
                p[i] += dist[i];
            F df = std::numeric_limits<F>::max();
            for (int x = t; x != s; x = edges[pre[x] ^ 1].to) {
                const Edge& e = edges[pre[x]];
                df = std::min(df, e.cap - e.flow);
            }
            total_flow += df;
            total_cost += (p[t] - p[s]) * df;
            for (int x = t; x != s; x = edges[pre[x] ^ 1].to)
                edges[pre[x]].flow += df, edges[pre[x] ^ 1].flow -= df;
        }
        return {total_flow, total_cost};
    }
};

const int N = 500;
int g[N][N];

int main() {
    int n;
    cin >> n;
    vii adj1(n+1), adj2(n+1);
    vi v1(n+1), v2(n+1);
    vi indeg1(n+1), indeg2(n+1);
    int root1, root2;

    forn(i, n-1){
      int x, y;
      cin >> x >> y;
      adj1[x].pb(y);
      indeg1[y]++;
    }
    forn(i, n){
      cin >> v1[i+1];
    }
    forn(i, n-1){
      int x, y;
      cin >> x >> y;
      adj2[x].pb(y);
      indeg2[y]++;
    }
    forn(i, n){
      cin >> v2[i+1];
    }

    vi incap(n+1);
    function<int(int)> dfs1 = [&](int u){
      int x = 1;
      for(int oth: adj1[u]){
        x += dfs1(oth);
      }
      incap[u] = x - v1[u];
      return x;
    };
    forn(i, n){
      if(indeg1[i+1]==0){
        dfs1(i+1);
        root1 = i+1;
        break;
      }
    }

    vi outf(n+1);
    ll totoutf = 0;
    function<int(int)> dfs2 = [&](int u){
      int x = 0;
      for(int oth: adj2[u]){
        x += dfs2(oth);
      }
      outf[u] = max(v2[u], x)-x;
      totoutf += outf[u];
      return max(x, v2[u]);
    };
    forn(i, n){
      if(indeg2[i+1]==0){
        dfs2(i+1);
        root2 = i+1;
        break;
      }
    }

    MCMF<int, int> M;
    M.init(4*n+2);
    for(int u=1; u<=n; u++){
      M.ae(0, u, 1, 0);
      M.ae(u, n+u, 1, 0);
      M.ae(u, 2*n+u, 1, 0);
      M.ae(2*n+u, 3*n+u, incap[u], 0);
      for(int oth: adj1[u]){
        M.ae(3*n+oth, 2*n+u, 100, 0);
      }
      for(int oth: adj2[u]){
        M.ae(n+oth, n+u, 100, 0);
      }
      M.ae(n+u, 4*n+1, outf[u], 0);
      M.ae(3*n+root1, 4*n+1, 100, 199);
      M.ae(n+root2, 4*n+1, 100, 200);
    }
    auto res = M.calc(0, 4*n+1);
    // cout << "max flow " << res.first << "\n";
    // cout << totoutf << "tof \n";
    for (int i = 1; i <= 2 * n; i++) {
        for (auto& j : M.adj[i]) {
            auto& E = M.edges[j];
            int to = E.to;
            int flow = E.flow;
            if (i < to) g[i][to] += flow;
            else g[i][to] -= flow;
        }
    }
    cout << (res.second - 199*(n-totoutf) + totoutf) << '\n';
    for (int i = 1; i <= n; i++) {
        if (g[i][i + n] > 0) {
            cout << i << " ";
        }
    }
    cout << '\n';
    //For each edge from u to n+u that is used, print u
    return 0;
}