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

using ll = long long;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define rep2(i, l, r) for(ll i = l; i < r; i++)

using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;

/* ---- */
#define all(A) A.begin(), A.end()
#define elif else if
using pii = pair<ll, ll>;

bool chmin(auto &a, const auto &b) {return a > b ? a = b, 1 : 0;}
bool chmax(auto &a, const auto &b) {return a < b ? a = b, 1 : 0;}

struct IOSetup {
  IOSetup() {
    cin.tie(0);
    ios::sync_with_stdio(0);
  }
} iosetup;

template<class T>
void print(vector<T> a) {
  for (auto x : a) cerr << x << ' ';
  cerr << endl;
}

void print(auto x) {
  cerr << x << endl;
}

template<class Head, class... Tail>
void print(Head&& head, Tail&&... tail) {
  cerr << head << ' ';
  print(forward<Tail>(tail)...);
}

struct Line {
  ll a, b;
  Line(ll a, ll b) : a(a), b(b){};
  inline ll get(ll x) const { return a * x + b; }
  inline bool over(const Line &b, const ll &x) { return get(x) < b.get(x); }
};

struct LCTree {
  vll xs;
  vector<Line> seg;
  int sz;
  ll inf = 1LL << 62;

  LCTree(){};

  LCTree(const vll &x) : xs(x) {
    if (xs.size() == 0) xs = {0};
    sort(xs.begin(), xs.end());
    sz = 1;
    while (sz < xs.size()) sz <<= 1;
    while (xs.size() < sz) xs.push_back({xs.back() + 1});
    seg.assign(2 * sz, Line(0, inf));
  }

  void upd(Line L, int k, int l, int r) {
    while (true) {
      int mid = (l + r) >> 1;
      bool f = L.over(seg[k], xs[l]);
      bool g = L.over(seg[k], xs[r - 1]);
      if (f == g) {
        if (f) swap(seg[k], L);
        return;
      }
      bool mov = L.over(seg[k], xs[mid]);
      if (mov) swap(seg[k], L);
      if (f != mov) {
        k = (k << 1), r = mid;
      } else {
        k = (k << 1) + 1, l = mid;
      }
    }
  }

  void add_line(ll a, ll b) {
    Line L(a, b);
    upd(L, 1, 0, sz);
  }

  // segment 用

  void upd(Line L, int i) {
    int ub = __bit_width(i) - 1;
    int l = (sz >> ub) * (i - (1 << ub));
    int r = l + (sz >> ub);
    upd(L, i, l, r);
  }

  void add_segment(ll l, ll r, ll a, ll b) {
    l = lower_bound(xs.begin(), xs.end(), l) - xs.begin() + sz;
    r = lower_bound(xs.begin(), xs.end(), r) - xs.begin() + sz;
    Line L(a, b);
    for (; l < r; l >>= 1, r >>= 1) {
      if (l & 1) upd(L, l++);
      if (r & 1) upd(L, --r);
    }
  }

  // segment 用ここまで

  ll query(ll x) {
    int k = lower_bound(xs.begin(), xs.end(), x) - xs.begin();
    k += sz;
    ll ret = seg[k].get(x);
    while (k > 0) {
      k = k >> 1;
      ret = min(ret, seg[k].get(x));
    }
    return ret;
  }
};

int main(){
  int n,m;
  cin>>n>>m;
  vector<int>in_cost(m),out_cost(m);
  rep(i,m){
    cin>>in_cost[i];
  }
  rep(i,m){
    cin>>out_cost[i];
  }

  map<pair<int,int>,int>dic;
  vector<vector<pair<int,int>>>G(n);
  vector<array<ll,4>>edges;

  int ID=0;
  rep(i,m){
    int p;
    cin>>p;
    int frm;
    cin>>frm;
    frm--;
    rep(j,p-1){
      int d,to;
      cin>>d>>to;
      to--;
      dic[{frm,i}]=ID;
      edges.push_back({frm,to,i,d});
      G[frm].push_back({in_cost[i],ID});
      ID++;
      frm=to;
    }
  }

  vector<LCTree>LCT(n);
  rep(i,n){
    sort(G[i].rbegin(),G[i].rend());
    vll xs;
    for(auto [x,id]:G[i])xs.push_back(x);
    LCT[i]=LCTree(xs);
  }

  ll inf=1LL<<62;
  vector<ll>dp_v(n,inf),dp(ID,inf);

  priority_queue<array<ll,2>,vector<array<ll,2>>,greater<array<ll,2>>>pq;

  auto upd=[&](int v)->void{
    if(G[v].size()==0)return;
    auto [x,id]=G[v].back();
    ll mn=LCT[v].query(x);
    dp[id]=min(dp[id],mn);
    pq.push({mn,id});
  };

  LCT[0].add_line(0,0);
  upd(0);
  dp_v[0]=0;
  vi checked(ID,0);
  while(!pq.empty()){
    auto [mn,id]=pq.top();
    pq.pop();
    if(dp[id]!=mn)continue;
    auto [frm,to,t,d]=edges[id];
    if(checked[id])continue;
    checked[id]=1;
    while(!G[frm].empty()){
      int id2=G[frm].back().second;
      if(checked[id2])G[frm].pop_back();
      else break;
    }
    upd(frm);
    ll len=mn+d;
    dp_v[to]=min(dp_v[to],len);
    LCT[to].add_line(out_cost[t],len);
    upd(to);
    if(dic.find({to,t})!=dic.end()){
      int id2=dic[{to,t}];
      dp[id2]=min(dp[id2],len);
      pq.push({len,id2});
    }
  }
  rep2(v,1,n){
    cout<<dp_v[v]<<" \n"[v+1==n];
  }
}