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

#define int long long
#define ull unsigned long long
#define N 100001
#define endl "\n"


/*
vector <bool> prime(N + 1, true) ;
vector <ull> fac(N) ;
vector <ull> inverse_fac(N) ;


bool check_prime(int n){
	if(n == 1)
		return false ;
	if(n % 2 == 0)
		return false ;
	for(int i = 3; i <= sqrt(n); i += 2){
		if(n % i == 0)
			return false ;
	}
	return true ;
}

void SieveOfEratosthenes(int n) {
	prime[0] = false ;
	prime[1] = false ;
	for (int i = 2; i * i <= n; i++) {
		if (prime[i] == true) {
			for (int j = i * i; j <= n; j += i)
				prime[j] = false;
		}
	}
	return ;
}

void calc_fact(ull mod) {
	fac[0] = 1;
	for (int i = 1; i < N; i++)
		fac[i] = (fac[i - 1] * i) % mod;
}

ull mod_expo(ull a, ull n, ull mod) {
	ull res{1} ;
	a = a % mod;
	while (n) {
		if (n & 1)
			res = (res * a) % mod;
		n = n >> 1;
		a = (a * a) % mod ;
	}
	return res % mod;
}

ull modInverse(ull n, ull mod) {
	return mod_expo(n, mod - 2, mod);
}

void calc_inverse_fact(ull mod) {
	inverse_fac[N - 1] = modInverse(fac[N - 1], mod) ;
	for (int i = N - 2; i >= 0; i--) {
		inverse_fac[i] = (inverse_fac[i + 1] * (i + 1)) % mod ;
	}
}


ull nCr_mod_fermat1(ull n, ull r, ull mod) {
	if (n < r)
		return 0;
	if (r == 0)
		return 1;
	ull res{fac[n]} ;
	res = (res * modInverse(fac[r], mod)) % mod ;
	res = (res * modInverse(fac[n - r], mod)) % mod ;
	return res ;
}

ull nCr_mod_fermat2(ull n, ull r, ull mod) {
	if (n < r)
		return 0;
	if (r == 0)
		return 1;
	ull res{fac[n]} ;
	res = (res * inverse_fac[r]) % mod ;
	res = (res * inverse_fac[n - r]) % mod ;
	return res ;
}


int extended_gcd(int a, int b, int *x, int *y) {
	if (a == 0) {
		*x = 0;
		*y = 1;
		return b;
	}
	int x1{}, y1{} ;
	int gcd = extended_gcd(b % a, a, &x1, &y1);
	*x = y1 - (b / a) * x1;
	*y = x1;
	return gcd;
}


vector <int> find_next_greater_element(vector <int> &vec) {
	int n{} ;
	n = vec.size() ;
	vector <int> res(n, -1) ;
	stack <int> st{} ;
	st.push(n - 1);
	for (int i = n - 2; i >= 0; i--) {
		while (!st.empty() && vec[st.top()] <= vec[i])
			st.pop();
		if (!st.empty())
			res[i] = st.top() ;
		st.push(i);
	}
	return res ;
}

vector <int> find_prev_smaller_element(vector <int> &vec) {
	int n{} ;
	n = vec.size() ;
	vector <int> res(n, -1) ;
	stack <int> st{} ;
	st.push(0);
	for (int i = 1; i < n; i++) {
		while (!st.empty() && vec[st.top()] >= vec[i])
			st.pop();
		if (!st.empty())
			res[i] = st.top() ;
		st.push(i);
	}
	return res ;
}

struct custom_hash {
	static uint64_t splitmix64(uint64_t x) {
		x += 0x9e3779b97f4a7c15;
		x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
		x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
		return x ^ (x >> 31);
	}

	size_t operator()(uint64_t x) const {
		static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
		return splitmix64(x + FIXED_RANDOM);
	}
};

// user defined comp for sets etc.
struct comp {
	bool operator()(const pair <int, int> &p1, const pair <int, int> &p2) {
		if (p1.first != p2.first)
			return p1.first < p2.first ;
		return p1.second > p2.second ;
	}
} ;


#define INF 1e18


// Counting no of inversions using a segment tree
vector <int> st(400004) ;              // sum of a segment

void build_st(int si, int ss, int se, vector <int> &vis) {
	if (ss == se) {
		st[si] = vis[ss] ;
		return ;
	}
	int mid{} ;
	mid = (ss + (se - ss) / 2) ;
	build_st(2 * si, ss, mid, vis) ;
	build_st(2 * si + 1, mid + 1, se, vis) ;
	st[si] = st[2 * si] + st[2 * si + 1] ;
}

int query_st(int si, int ss, int se, int qs, int qe, vector <int> &vis) {
	if (qs > se || qe < ss)
		return 0 ;
	else if (qs <= ss && qe >= se)
		return st[si] ;
	int mid{} ;
	mid = ss + (se - ss) / 2 ;
	int l{}, r{} ;
	l = query_st(2 * si, ss, mid, qs, qe, vis) ;
	r = query_st(2 * si + 1, mid + 1, se, qs, qe, vis) ;
	return l + r ;
}

void point_update_st(int si, int ss, int se, int qi, vector <int> &vis) {
	if (ss == se) {
		st[si] = vis[se] ;
		return ;
	}
	int mid{} ;
	mid = ss + (se - ss) / 2 ;
	if (qi <= mid)
		point_update_st(2 * si, ss, mid, qi, vis) ;
	else
		point_update_st(2 * si + 1, mid + 1, se, qi, vis) ;
	st[si] = st[2 * si] + st[2 * si + 1] ;
}
*/



int32_t main() {
#ifndef ONLINE_JUDGE
	freopen("input1.txt", "r", stdin) ;

	freopen("output1.txt", "w", stdout) ;
#endif
	ios_base::sync_with_stdio(false) ;
	cin.tie(NULL) ;
	int t{} ;
	cin >> t ;
	while (t--) {
		int n{}, k{} ;
		cin >> n >> k ;
		vector <int> vec1(k, 0), vec2(k, 0) ;
		for (int i = 0; i < k; i++)
			cin >> vec1[i] ;
		for (int i = 0; i < k; i++)
			cin >> vec2[i] ;
		vector <int> v(n, -1) ;
		for (int i = 0; i < k; i++) {
			v[vec1[i] - 1] = vec2[i] ;
		}
		vector <int> ans(n, LLONG_MAX / 2) ;
		vector <int> left(n, LLONG_MAX / 2), right(n, LLONG_MAX / 2) ;
		for (int i = 0; i < n; i++) {
			if (v[i] != -1)
				ans[i] = v[i] ;
		}
		if (v[0] != -1)
			left[0] = v[0] ;
		for (int i = 1; i < n; i++) {
			left[i] = min(left[i], left[i - 1] + 1) ;
			if (v[i] != -1)
				left[i] = min(left[i], v[i]) ;
		}
		if (v[n - 1] != -1)
			right[n - 1] = v[n - 1] ;
		for (int i = n - 2; i >= 0; i--) {
			right[i] = min(right[i], right[i + 1] + 1) ;
			if (v[i] != -1)
				right[i] = min(right[i], v[i]) ;
		}
		for (int i = 0; i < n; i++) {
			ans[i] = min({ans[i], left[i], right[i]}) ;
		}
		for (auto elem : ans)
			cout << elem << " " ;
		cout << endl ;
	}
	return 0 ;
}


