What went wrong?
Your construction is based on the neat observation

f(A) = (N‑2)·1 + val      with   val = K – (N‑2)

i.e. make every adjacent GCD equal 1 except one special pair
⟨val , 2·val⟩ whose GCD is val.
That idea is perfectly fine, but the loop

cpp
for (int i = n-3; i >= 0; --i) ans[i] = --val;

keeps decrementing val until it reaches 0 or becomes negative whenever
K is close to its minimum possible value N‑1.
Consequently you output zero / negative numbers, and sometimes you even repeat val — both of which violate the statement (“distinct integers between 1 and 10^9”).

A robust construction

1. Impossible case – the smallest sum we can ever obtain is N‑1 (all adjacent GCDs equal 1).
   If K < N‑1 we print ‑1.

2. Exactly the minimum (K = N‑1) – just output consecutive integers 1 … N; every pair is coprime ⇒ sum of GCDs = N‑1.

3. General case (K > N‑1)

text
x = K – (N‑2)   (now x ≥ 2)

[A0 … AN‑3] = BASE, BASE+1, …, BASE+(N‑3)   // BASE = 3'000'003
AN‑2        = 1
AN‑1        = x
AN          = 2·x

• the BASE block is a stretch of consecutive numbers ⇒ every GCD inside it is 1;
• gcd(BASE+(N‑3), 1) = 1;
• gcd(1, x) = 1;
• gcd(x, 2x) = x.

Hence the total is (N‑3 – 1)·1 + 1 + 1 + x = (N‑2)+x = K,
all numbers are positive, distinct and ≤ 10^9 (largest is BASE+(N‑3) < 3.3 &times; 10^6).

Correct code (C++ 17)

cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;

void solve() {
    ll N, K;                  // N up to 2·10^5, K up to 10^6
    cin >> N >> K;

    /* impossible ----------------------------------------------- */
    if (K < N - 1) {
        cout << -1 << '\n';
        return;
    }

    /* N = 2 is a special one‑pair case ------------------------- */
    if (N == 2) {
        cout << K << ' ' << 2 * K << '\n';        // gcd = K
        return;
    }

    /* exactly the minimum sum ---------------------------------- */
    if (K == N - 1) {                            // x would be 1
        for (ll i = 1; i <= N; ++i)
            cout << i << (i == N ? '\n' : ' ');
        return;
    }

    /* general constructive case -------------------------------- */
    ll x = K - (N - 2);                          // x &ge; 2
    const ll BASE = 3'000'003;                   // > 2·10^6, well < 10^9

    vector<ll> a;
    a.reserve(N);

    /* 1) a block whose consecutive elements are pairwise coprime */
    for (ll i = 0; i < N - 3; ++i)
        a.push_back(BASE + i);                   // gcd of neighbours = 1

    /* 2) a bridging 1 so that gcd(… ,1) and gcd(1,x) are both 1  */
    a.push_back(1);

    /* 3) the special pair whose gcd is x                         */
    a.push_back(x);
    a.push_back(2 * x);

    /* output ---------------------------------------------------- */
    for (size_t i = 0; i < a.size(); ++i)
        cout << a[i] << (i + 1 == a.size() ? '\n' : ' ');
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int T;
    cin >> T;
    while (T--)
        solve();
    return 0;
}

This keeps every element within the required range, guarantees pairwise distinctness, and works in O(N) per test‑case — easily fast enough for the given limits.

Below is a drop‑in replacement for your file that keeps your original idea—
only one special pair contributes val to the sum, every other adjacent GCD is 1.
I only fixed the edge cases and the way the first n‑2 numbers are filled.

cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;

void solve() {
    ll n, k;
    cin >> n >> k;

    /* 1.  Impossible when the minimum achievable sum (n‑1) is larger than k */
    if (k < n - 1) {
        cout << -1 << '\n';
        return;
    }

    /* 2.  Trivial minimum‑sum case: consecutive integers 1 … n */
    if (k == n - 1) {
        for (ll i = 1; i <= n; ++i)
            cout << i << (i == n ? '\n' : ' ');
        return;
    }

    /* 3.  General case ------------------------------------------------------ */
    ll val = k - (n - 2);          // gcd of the last pair (val , 2·val)
    if (n == 2) {                  // special when there is only that one pair
        cout << val << ' ' << 2 * val << '\n';
        return;
    }

    vector<ll> a;
    a.reserve(n);

    /* first n‑3 numbers: consecutive integers starting from 3
       (they guarantee gcd=1 with neighbours)                     */
    ll cur = 3;
    for (int i = 0; i < n - 3; ++i) {
        while (cur == val || cur == 2 * val) ++cur;   // keep all values distinct
        a.push_back(cur++);
    }

    /* the final three numbers: 1, val, 2·val
       gcd( … , 1) = 1, gcd(1 , val) = 1, gcd(val , 2·val) = val */
    a.push_back(1);
    a.push_back(val);
    a.push_back(2 * val);

    /* output --------------------------------------------------------------- */
    for (size_t i = 0; i < a.size(); ++i)
        cout << a[i] << (i + 1 == a.size() ? '\n' : ' ');
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t;
    cin >> t;
    while (t--)
        solve();
    return 0;
}

Why this keeps your concept intact

• Your key idea: choose val = K – (N‑2), make the last pair
  ⟨val, 2·val⟩ so that their GCD equals val.
  That part is unchanged.

• Every other adjacent GCD is forced to 1:

  • consecutive integers are always coprime → gcd = 1;
  • gcd(anything, 1) = 1.

• Hence
  f(A) = (N‑3)·1 // between the leading block + 1 // between last block element and the 1 + val // between val and 2·val = N‑2 + val = K.

• All numbers are distinct and far below 10^9
  (k ≤ 10^6 ⇒ 2·val ≤ 2.2 × 10^6 at worst).

So the construction obeys the constraints while following exactly the pattern you originally envisioned.