2023“钉耙编程”中国大学生算法设计超级联赛(2)

“钉耙编程"(2)1001 | hdu7287：Alice Game

Alice 和 Bob玩游戏，给定$n$和$k$，初始有$n$个石头排成一排，两人轮流执行以下操作：

1. 选择一段个数$\le k$的石头，直接拿掉
2. 选择一段个数$>k+1$的石头，拿走里面连续的$k$个，要求拿完之后这一段石头变成了两段

先无法操作者输。

SG函数的题，好在还没忘记

根据SG的原理可以知道：

首先$SG[0]=0$。

接下来小于$k$的，$SG[\mathrm{1...}k]=1$。

由于$k+1$无法操作，$SG[k+1]=0$。

对于$>k+1$，有
$$SG[x]=me{x}_{i=1}^{x-k-1}(SG[i]\oplus SG[x-k-i])$$

然后打标找规律，会发现符合$SG[x]=0$的$x$是一个等差数列，公差为$4k+2$

“钉耙编程”(2)1005 | hdu7291：Or

给出长度为$n$的数组$a_i$和$b_i$。现在有$m$组询问$[l,r]$，需要计算：
$$\underset{i=l}{\overset{r}{⨁}}\underset{j=i}{\overset{r}{⨁}}(a_i+\sum _{k=i+1}^j{b}_k)$$
(这里的⊕ 表示OR操作)
数据范围$1\le n\le 10^5,1\le m\le 10^6$

这题十分滴复杂。参考题解的思路来做

如果定下了一个$r$，不断将$l$左移，那么会增加一些新的数，这些数是$a_l,a_l+b_{l+1},a_l+b_{l+1}+b_{l+2},\cdots ,a_l+b_{l+1},a_l+b_{l+2}+\cdots +b_r$。我们知道题目中两个或与枚举全部数或一起是一样的，就是看某一个二进制位在这些数中是不是有$1$。解决或问题的入手点是，找到某一个二进制位下最早出现$1$的位置即可。在代码中用$nxt$数组表示，这里给出代码中$nxt$的定义，$nxt[i][o]$表示第$i$个位置开始往后，在第$o$个二进制位上第一个出现$1$的位置。

所以只要求出了$nxt$，就可以从$[n,n]$开始逐渐向头扩张，每次扩展加入$nxt[l][.]$的信息，用树状数组维护。这个时候如果维护到了$[l,n]$的信息，做一个query(r)，就可以得到$[l,r]$之间的答案了。

现在难点是求nxt。

用前缀和可以改写式子为$a_l+s_r-s_l$，进一步做一个分组$(a_l-s_l)+s_r$。然后就可以按照“套路”来做题了。

如果$y\ge 0$，不妨记$x=s_r,y=s_l-a_l$，接下来考虑$x-y$的情况。目标是判断第$k$位(这里第$k$位从$0$开始数)是不是$1$。首先$x,y$需要对$2^k$取模。如果$x$的第$k$位是$1$，$x\ge y$且$y$的第$k$位是$0$；或者$x<y$且$y$的第$k$位是$1$。如果$x$的第$k$位是$0$，要求$x\ge y$且$y$的第$k$位是$1$；或者$x<y$且$y$的第$k$位是$0$。整理一下，现在需要当$y$的第$k$位是$0$时，需要在$x\ge y$中找第$k$位是$1$的$x$；或者在$x<y$中找第$k$位是$0$的$x$。如果$y$的第$k$为是$1$也类似。

后来悟了，上面说的太具体了，其实就是当考虑第$k$位时，先看看第$k$位之后的数(即对$2^k$取模)谁大，$y$大则表示需要向第$k$位借位，$y$小则不用。如果需要借位，则要求$x$的第$k$位是$0$，$y$是$0$。类似这样推理下去。

如果$y<0$，记$x=s_r,y=-s_l+a_l$，接下来考虑$x+y$的情况。借用上面的思路，对$2^{k+1}$取模，如果$2^k\le x+y<2^{k+1}$或者$x+y\ge 2^{k+1}+2^k$，则$x+y$的第$k$位有$1$。(很明显的，有$2^k$就是第$k$位上有$1$嘛)

上面这两种情况都可以用线段树维护，每一位都做三棵线段树，都是求的区间最小值。

时间复杂度是$\mathcal{O}(n{\log }^{2}n+m\log n)$

#include <bits/stdc++.h>
//#define rt root, 0, L
#define ltree lc[x], l, mid
#define rtree rc[x], mid + 1, r
using namespace std;
//typedef long long ll;
const int N = 1e5 + 10, M = 1e6 + 10;
const int L = 1e9; // 设定线段树的上限
const int INF = 1e9;

int n, m;
int a[N], b[N], s[N];
int nxt[N][30];

int ans[M];
vector<pair<int, int>> Q[N]; // 记录、整理询问区间

namespace calc_ans
{ 
	const int base = 233;
	const int p = 998244353;
	inline int add(int x, int y) { return (x += y) >= p ? x - p : x; } 
	inline int mul(int x, int y) { return 1ll * x * y % p; }

	int calc() 
	{
		int res = 0, t = 1; 
		for (int i = 1; i <= m; ++i)
		{
			t = mul(t, base);
			res = add(res, mul(t, ans[i]));
		}
		return res;
	}
}



struct SegmentTree
{
	int rt;
	int top, lc[N * 30], rc[N * 30], mn[N * 30]; // 动态开点

	void init()
	{
		rt = top = 0;
		mn[0] = INF;
	}

	void change(int &x, int l, int r, int p, int v)
	{
		if(!x)
		{
			x = ++top;
			lc[x] = rc[x] = 0;
			mn[x] = INF;
		}
		if(l == r) return mn[x] = min(mn[x], v), void();
		int mid = l + r >> 1;
		if(p <= mid) change(ltree, p, v);
		else change(rtree, p, v);
		mn[x] = min(mn[lc[x]], mn[rc[x]]);
	}

	//int query(int x, int l, int r, int ql, int qr)  debug：没有去除掉非法情况(e.g. ql, qr = -2, 0)
	//{
	//	if(!x) return INF;
	//	if(l == ql && r == qr) return mn[x];
	//	int mid = l + r >> 1;
	//	if(qr <= mid) return query(ltree, ql, qr);
	//	else if(mid < ql) return query(rtree, ql, qr);
	//	else return min(query(ltree, ql, mid), query(rtree, mid + 1, qr));
	//}

	int query(int x, int l, int r, int ql, int qr)
	{
		if(l > qr || r < ql || !x) return INF;
		if(ql <= l && r <= qr) return mn[x];
		int mid = l + r >> 1;
		return min(query(lc[x], l, mid, ql, qr), query(rc[x], mid + 1, r, ql, qr));
	}
}T[2], S;

// 求最终答案部分
int Bit[N];
inline int lowbit(int x) { return x & -x; }
void add(int x, int v)
{
	for(int i = x; i <= n; i += lowbit(i)) Bit[i] |= v;
}
int query(int x)
{
	int ret = 0;
	for(int i = x; i >= 1; i -= lowbit(i)) ret |= Bit[i];
	return ret;
}

void solve()
{
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
	for(int i = 1; i <= n; i++)
	{
		scanf("%d", &b[i]);
		s[i] = s[i - 1] + b[i];
	}
	
	for(int o = 0; o < 30; o++)
	{
		T[0].init();
		T[1].init();
		S.init();
		for(int i = n; i >= 1; i--)
		{
			int d = s[i] >> o & 1; // s[i]第o位的值是几
			int v1 = s[i] & (1 << o) - 1; // s[i]对2^o取模
			int v2 = s[i] & (1 << o + 1) - 1; // s[i]对2^(o+1)取模
			T[d].change(T[d].rt, 0, L, v1, i);
			S.change(S.rt, 0, L, v2, i);
			if(s[i] >= a[i])
			{
				int d = (s[i] - a[i]) >> o & 1; // s[i]-a[i]的第o位
				int v = (s[i] - a[i]) & ((1 << o) - 1); // 对2^o取模
				nxt[i][o] = min(T[d].query(T[d].rt, 0, L, 0, v - 1), T[d ^ 1].query(T[d ^ 1].rt, 0, L, v, L));
			}
			else // s[i] < a[i]
			{
				int v = (a[i] - s[i]) & ((1 << o + 1) - 1);
				nxt[i][o] = min(S.query(S.rt, 0, L, (1 << o) - v, (1 << o + 1) - v - 1),
								S.query(S.rt, 0, L, (1 << o) + (1 << o + 1) - v, L));
			}
		}
	}

	for(int i = 1; i <= m; i++)
	{
		int l, r;
		scanf("%d%d", &l, &r);
		Q[l].push_back({r, i});
	}
	for(int l = n; l >= 1; l--)
	{
		for(int o = 0; o < 30; o++)
			if(nxt[l][o] != INF) add(nxt[l][o], 1 << o);
		for(auto q : Q[l]) ans[q.second] = query(q.first);
	}
	printf("%d\n", calc_ans::calc());

	for(int i = 1; i <= n; i++) Q[i].clear(), Bit[i] = 0;
}

int main()
{
	int T;
	scanf("%d", &T);
	while(T--) solve();
}

“钉耙编程"(2)1010 | hdu7296：Klee likes making friends

可莉找朋友，有$n$个朋友，找每一个朋友需要花费$a[i]$的代价。由于可莉是一个乐于交友的人，在任意$m$个连续的人中，至少要有$2$个可莉的朋友。请给出最少代价。$(2\le n\le 20000,2\le m\le 2000,m\le n)$

算法是DP应该不难看出

状态设$f[i][j]$最后两个朋友是$i$和$j$时的最小代价，则有转移方程:

$$f[j][k]=\underset{k-m+1\le i\le j-1}{\min }f[i][j]+a[k]$$

挺显然的，目标就是让i最后三个朋友$i,j,k$的分布能满足题意

接下里考虑时间复杂度，如果直接枚举转移会产生$\mathcal{O}(nm\ast m)$的复杂度。$nm$是状态量，$m$是每个状态转移的复杂度。显然时间复杂度是不可接受的，我们需要优化转移的时间复杂度

转移的过程中我们需要找到一个在区间范围内的i，让f[i][j]最小。i和k之间的变化是一个线性变化，所以可以很轻松的记录一个区间的最小值来解决这个问题。

留意到空间要开$\mathcal{O}(n^2)$太大了，但实际上用到的f只有$\mathcal{O}(m^2)$，所以不妨让i和j都对m取模，做一个循环。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e4 + 10, M = 2e3 + 10;
const ll INF = 1e18;

int n, m;
ll a[N], f[M][M];

void solve()
{
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++)
    {
        scanf("%lld", &a[i]);
    }
    for(int i = 1; i < m; i++)
        f[0][i] = a[i];
    for(int j = 1; j <= n; j++)
    {
        ll mn = INF;
        int i = j; // debug i = j - 1 初始未导入
        for(int k = min(n, j + m - 1); k > j; k--)
        {
            while(i > 0 && k - i < m) 
            {
                i--;
                mn = min(mn, f[i % m][j % m]);
                // printf("%d %d\n", i, mn);
            }
            f[j % m][k % m] = mn + a[k]; // debug 忘记加a[k]
            // printf("%d %d %d\n", j, k, mn);
        }
    }
    ll ans = INF;
    for(int i = n - m + 1; i <= n; i++)
        for(int j = i + 1; j <= n; j++)
            ans = min(ans, f[i % m][j % m]);
    printf("%lld\n", ans);
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--) solve();
}