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

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, b, a) for(int i = (b) - 1; i >= (a); i--)
#define SZ(a) (int)a.size()
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef pair<int, int> PII;
typedef double db;

const int INF = 1e9; 
const LL LINF = 1e18; 


struct FewikMin
{
	int n;
	VL t;
	void init(int _n)
	{
		n = _n;
		t.resize(n, LINF);
	}
	void upd(int pos, LL val)
	{
		for(;pos < n; pos |= pos + 1)
			t[pos] = min(t[pos], val);
	}
	LL query(int pos)
	{
		LL res = LINF;
		for(;pos >= 0; pos = (pos & (pos + 1)) - 1)
			res = min(res, t[pos]);
		return res;
	}
};
struct FewikMax
{
	int n;
	VL t;
	void init(int _n)
	{
		n = _n;
		t.resize(n, -LINF);
	}
	void upd(int pos, LL val)
	{
		for(;pos < n; pos |= pos + 1)
			t[pos] = max(t[pos], val);
	}
	LL query(int pos)
	{
		LL res = -LINF;
		for(;pos >= 0; pos = (pos & (pos + 1)) - 1)
			res = max(res, t[pos]);
		return res;
	}
};


vector<pair<LL, LL>> recalc(const vector<LL>& pref, const vector<LL>& spref, int n, LL M)
{
	int sz = n + 7;
	FewikMax Tmax;
	Tmax.init(sz);
	FewikMin Tmin;
	Tmin.init(sz);
	
	vector<pair<LL, LL>> ans(n + 1);
	
	FOR(i, 0, n + 1)
	{
		if(i != 0)
		{
			//pref[i] - pref[j] <= M -> pref[j] >= pref[i] - M
			int pos = lower_bound(ALL(spref), pref[i] - M) - spref.begin();
			//max[pos, n + 1] = Tmax[0, n + 1 - pos]
			//cout << i << " " << pos << endl;
			
			ans[i].F = Tmin.query(sz - 1 - pos) + 1;
			ans[i].S = Tmax.query(sz - 1 - pos) + 1;
		}
		
		int pos = lower_bound(ALL(spref), pref[i]) - spref.begin();
		//cout << i << " " << pos << " " << ans[i].F << " " << ans[i].S << endl;

		Tmin.upd(sz - 1 - pos, ans[i].F);
		Tmax.upd(sz - 1 - pos, ans[i].S);
	}
	return ans;
}
namespace BRUTE
{
	const int N = 2000;
	LL dp[N][N];
	int from[N][N];
	
	void solve(int n, int k, VI a)
	{
		assert(n < N - 1);
		vector<LL> pref(n + 1);
		FOR(i, 0, n)	
		{
			pref[i + 1] = pref[i] + a[i];
		}
		
		FOR(i, 1, n + 1)
			fill(dp[i], dp[i] + n + 1, LINF);
		fill(dp[0], dp[0] + n + 1, LINF);
		dp[0][0] = -LINF;
		
		FOR(i, 1, n + 1)
		{
			FOR(cnt, 1, k + 1)
			{
				FOR(j, 0, i)
				{
					LL val = max(pref[i] - pref[j], dp[j][cnt - 1]);
					if(dp[i][cnt] >= val)
					{
						dp[i][cnt] = val;
						from[i][cnt] = j;
					}
				}
			}
		}
		VI ans;
		int v = n;
		while(v != 0)
		{
			ans.PB(v - from[v][k]);
			v = from[v][k];
			k--;
		}
		assert(k == 0);
		reverse(ALL(ans));
		
		FOR(i, 0, SZ(ans))
		{
			if(i)
				cout << " ";
			cout << ans[i];
		}
		cout << "\n";
	}
}


void solve()
{
	int n, k;
	cin >> n >> k;
	VI a(n);
	vector<LL> pref(n + 1, 0);
	FOR(i, 0, n)
	{
		cin >> a[i];
		pref[i + 1] = pref[i] + a[i];
	}
	if(1 || n < 200)
	{
		BRUTE::solve(n, k, a);
		return;
	}
	
	vector<LL> spref = pref;
	sort(ALL(spref));
	spref.resize(unique(ALL(spref)) - spref.begin());
	
	LL L = -LINF, R = LINF;
	while(R - L > 1)
	{
		LL M = (L + R) / 2;
		
		auto res = recalc(pref, spref, n, M);
		if(res.back().F <= k && k <= res.back().S)
			R = M;
		else
			L = M;
	}
	auto res = recalc(pref, spref, n, R);
	int last = n;
	VI ans;
	RFOR(i, n, 0)
	{
		if(pref[last] - pref[i] > R)
			continue;
		if(res[i].F <= k - 1 && k - 1 <= res[i].S)
		{
			k--;
			ans.PB(last - i);
			last = i;
		}
	}
	reverse(ALL(ans));
	
	assert(k == 0);
	assert(last == 0);
	int pos = 0;
	FOR(i, 0, SZ(ans))
	{
		//cout << pos << " " << pos + ans[i] << " " << pref[pos + ans[i]] << " " << pref[pos] << endl;
		assert(pref[pos + ans[i]] - pref[pos] <= R);
		pos += ans[i];
	}
	
	
	FOR(i, 0, SZ(ans))
	{
		if(i)
			cout << " ";
		cout << ans[i];
	}
	cout << "\n";
}



int main()
{
	ios::sync_with_stdio(0); 
	cin.tie(0);
	cout << fixed << setprecision(15);
	
	int t;
	cin >> t;
	while(t--)
		solve();
	
	
	
	return 0;
}