E. Modular Sequence

题意

对于一个长度为 $n$ 的数组 $a$，定义它是 $good$ 的当且仅当：

• $a_1=x$
• $a_i=a_{i-1}+y$ 或 $a_i=a_{i-1}modyi\ge 2$

给定 $n、x、y、S$，问能否构造出一个和为 $S$ 的长度为 $n$ 的 $good$ 数组

思路

注意到后面每个放置的 $a_i$，它们模除 $y$ 的值都是一样的，因为自从 $a_1=x$ 后，后面每次变化都是同余 $y$ 的。

定义 $r=xmody$，那么我们先将数组的 $n$ 个位置填成：$a_i=r$，$a_1=x$，先计算一下这样子最小的数组和是否超过 $S$，超过的话显然没有答案。对于没有超过 $S$ 的时候，我们后面肯定是要在 $r$ 的基础上放置若干个 $y$，那么剩余要放置的和应该能被 $y$ 整除 才行。

假设要放置 $\frac{leftSum}{y}$ 个 $y$，我们就一定要尽可能用最短的长度构造出来这么多个 $y$ 的放置方式，考虑 $DP$，用 $d{p}_k$ 表示要从空序列开始放置 $k$ 个物品，最短需要的长度，那么转移我们可以枚举最后使用的完整上升长度 $len$，这个上升长度必须从 $0$ 开始，长度为 $len$，例如：$....,0,1,2,...,len-1$ 这样一个结尾方式，那么它的子状态就是：$dp[k-\frac{len\cdot (len-1)}{2}]$，因为最后这一段上升序列的贡献是 $\frac{len\cdot (len-1)}{2}$，长度为 $len$，我们取 $min$ 值就可以

对于多组样例，我们只需要关心最后要放置多少个 $y$，所以我们可以预计算 $dp$ 数组

我们先枚举一开始是否需要先跟着 $x$ 递增一段长度，然后再从 $0$ 开始构造答案，因为我们的 $dp$ 数组是从 $0$ 开始构造答案的最短长度，假设一开始从 $x$ 开始递增了 $k$ 次（不包含 $a_1$ ），也就是数组开头为：$x,x+y,x+2y,...,x+ky$，这样子的形式，我们得先确保这个 $preSum$ 不会超过 $S$，然后在此基础上计算后面还需要放置的和的余量 $leftSum=S-preSum$，当然这个余量要先预算一下后面每个位置放一个 $r$ 的花销，$leftSum-=r\times (n-1-k)$，最后的这个 $leftSum$ 不能为负数，并且要能被 $y$ 整除，还要要求 $dp[\frac{leftSum}{y}]$ 的值小于等于 $n-1-k$，意思是我们剩余的位置必须要足够放置这么多个 $y$，我们才能在这个基础上构造答案

如果上述条件都符合，我们现在中间多余的用不上的位置 $[k+1,n-dp[\frac{leftSum}{y}]]$ 先填补上 $r$，然后从 $n-dp[\frac{leftSum}{y}]+1$ 这个位置开始构造答案，我们用一个 $len$ 数组来暂存一下我们的答案构造的上升长度序列，枚举转移的路径即可

时间复杂度：$O(S\sqrt{S})$

#include<bits/stdc++.h>
#define fore(i,l,r)	for(int i=(int)(l);i<(int)(r);++i)
#define fi first
#define se second
#define endl '\n'
#define ull unsigned long long
#define ALL(v) v.begin(), v.end()
#define Debug(x, ed) std::cerr << #x << " = " << x << ed;

const int INF=0x3f3f3f3f;
const long long INFLL=1e18;

typedef long long ll;

const int N = 200050;

int dp[N];

void solve(){
    int n;
    ll x, y, S;
    std::cin >> n >> x >> y >> S;
    fore(k, 0, n){ //除了首项x外，后面还跟着递增了k次
        ll preSum = (k + 1) * x + k * (k + 1) / 2 * y; //前缀和
        if(preSum > S) continue;
        ll leftSum = S - preSum; //后面需要构造的和
        leftSum -= (n - 1 - k) * (x % y); //先减去模数 x % y
        if(leftSum < 0 || leftSum % y) continue;
        
        int needSum = leftSum / y; //后面需要多少个y
        if(dp[needSum] > n - k - 1) continue; //长度不够构造
        
        std::vector<int> a(n);
        a[0] = x; //首项
        fore(i, 1, k + 1) a[i] = a[i - 1] + y; //起初跟着长度为k的一个递增
        fore(i, k + 1, n - dp[needSum]) a[i] = x % y; //中间这里用不上，我们在 n - dp[needSum] -> n - 1构造

        int idx = n - dp[needSum];

        std::vector<int> len;
        while(needSum){
            for(int l = 2; l * (l - 1) / 2 <= needSum; ++l)
                if(dp[needSum] == dp[needSum - l * (l - 1) / 2] + l){ //这是一个最短长度的转移
                    len.push_back(l); //记录构成最短长度的转移
                    needSum -= l * (l - 1) / 2; //剩余需要放置的y的数量
                    break;
                }
        }

        for(auto l : len) //按照答案转移放置y
            fore(j, 0, l) //从0开始放置，放 l 次
                a[idx++] = x % y + j * y; //记住底是 x % y
        
        std::cout << "YES\n";

        for(auto el : a) std::cout << el << ' ';
        std::cout << endl;
        return;
    }

    std::cout << "NO\n";
}

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

    fore(i, 1, N) dp[i] = INF;
    fore(k, 1, N)   //dp[i] 表示要放 i 个 y 需要的最短长度是多长
        for(int len = 2; len * (len - 1) / 2 <= k; ++len) //这里len是从0开始放的，所以最后一位是len - 1，长度为len
            dp[k] = std::min(dp[k], dp[k - len * (len - 1) / 2] + len);

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