【比赛】2021牛客寒假算法基础集训营4 题解 【更新中……】

比赛链接

---

点击此处进入比赛

A 九峰与签到题

---

签到题
不多说，直接上代码

AC代码

---

#include
using namespace std;

#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % 1000000007
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int N = 20 + 10;
bool vis[N];
int st[N];

int main()
{
     
#ifdef LOCAL
	freopen("data.in", "r", stdin);
#endif
	ios::sync_with_stdio(false);
	cout.tie(0);
	cin.tie(0);
	
	int n, m;
	cin >> m >> n;

	while (m--)
	{
     
		int t;
		string op;
		cin >> t >> op;
		if (op == "AC") st[t]++;
		else st[t]--;

		if (st[t] < 0) vis[t] = true;
	}

	_rep(i, 1, n) if (!vis[i]) cout << i << " ";
	cout << endl;
	
	return 0;
}

B 武辰延的字符串

---

这个题目在比赛的时候做了我好久，就是那种感觉可以做出来，但是就是做不出来的那种感觉。
实际上还差很远，错因： 模拟的时候没有经过严格的证明，数据点没找出来，随意的给运行剪枝，导致答案不对。
对于数据点没找出来这个问题，需要在看题的时候将所有限制条件列出来，然后给自己出各种情况的数据点，这个能力有待提高！

这个题目考点就是字符串哈希 + 二分。
对于匹配字符串好用的就是字符串哈希或者KMP了，这个题目范围有点大，所以个人偏向于哈希，感觉快一些。
对于公式 ： $s_i+s_j=t_{i+j}$ 如果两边的前缀$s_i$相同的话，那么可以同时减去$s_i$，那么剩下来的就是我们需要的答案了，有多长就代表在以$s_i$为前缀的情况下的所有结果。
接下来就是求最大匹配长度的问题了，看到最大，然可以根据字符串哈希值比较大小条件可以划分为两个不同的部分，这时候我们就要想到二分了。
如果两边的字符串哈希值是一样的，那么就说明还可以往右边取，如果不一样就说明要往左边移动。

			主要是没有想到将公式变形一下找到相同的，就直接模拟了，模拟前也没有好好分析题目。 这个毛病要改！！！

AC代码

---

#include
#include
using namespace std;

#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % 1000000007
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef unsigned long long ull;

const int N = 100000 + 10, P = 131;
ull ha[N], hb[N], p[N];
char a[N], b[N];
int sza, szb;
unordered_map<ll, bool> vis;

ull get(int l, int r, ull h[])
{
     
	return h[r] - h[l - 1] * p[r - l + 1];
}

int main()
{
     
#ifdef LOCAL
	freopen("data.in", "r", stdin);
#endif
	ios::sync_with_stdio(false);
	cout.tie(0);
	cin.tie(0);

	cin >> a + 1 >> b + 1;
	sza = strlen(a + 1), szb = strlen(b + 1);

	p[0] = 1;
	int n = max(sza, szb), m = min(sza, szb);
	_rep(i, 1, n)
	{
     
		if (sza <= n) ha[i] = ha[i - 1] * P + a[i];
		if (szb <= n) hb[i] = hb[i - 1] * P + b[i];
		p[i] = p[i - 1] * P;
	}

	ll ans = 0;
	_rep(i, 1, m) if (get(1, i, ha) == get(1, i, hb))
	{
     
		int l = 0, r = min(sza, szb - i);
		while (l < r)
		{
     
			int mid = l + r + 1 >> 1;
			if (get(1, mid, ha) == get(i + 1, mid + i, hb)) l = mid;
			else r = mid - 1;
		}
		ans += l;
	}
	cout << ans << endl;
	return 0;
}

D 温澈滢的狗狗

---

这个题目看了我好久，，（主要是太菜了）
做题的时候想到了用二分，但是不知道怎么去定义它的性质。
两两不同颜色的狗之间会产生亲密度，对每一对有亲密度的狗按照关键词进行排序，求第k对狗的下标。
如果模拟的话肯定会超时，所以要往快速找到第k对狗的方向想，会想到使用二分思想。
想到用二分思想就要想能不能找到一个能够二分的条件。
第一关键词是按照亲密度去的，所以想想能不能以亲密度去划分。
我们假设第k对的亲密度为x，那么就说明 $>x$ 的部分是不需要的，所以就有明显的二分性。

知道了以亲密度作为判断条件，那么接下来的步骤就是完善细节，计算每个$\le x$亲密度的个数。
只有颜色不同才会有亲密度，直接求有点麻烦，时间复杂度也会比较高，直接求不行，那么就试试间接的求法：
$异色点对数=总点对数-同色点对数（O(n)）$

设x为亲密度，我们将同色点都放到同一个下标的数组中。
总点对数 ： $(n-x)\ast x+x\ast (x-1)/2$
我们知道亲密度了，（亲密度是下标距离）那么从下标1开始到(n - x) 分别做区间，每个区间都可以取x个数与区间第一个点形成对，有（n - x ）个区间，所以就为$(n-x)\ast x$, 后部分区间不能延长了，到达总下标的末端了，所以可取值分别为$x-1、x-2、x-3\dots \dots x-(x-1)$,等差数列求和就得出了 $x\ast (x-1)/2$ 。
同色点数利用双指针求解即可（这个不知道怎么用语言讲，待会看代码吧。）

二分具体条件出来了，那么就可以求出来最大亲密度为 $l$ 总对数小于 $k$ 的 $l$值。
所以第k对狗的亲密度为$l+1$。
亲密度知道了，直接for循环找即可。

AC 代码

#include
using namespace std;

#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % MOD
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int N = 100000 + 10;
int c[N], n;
ll k;
vi same[N];

ll cal(ll x)
{
     
	ll tot = (n - x) * x + x * (x - 1) / 2;
	_rep(i, 1, n)
	{
     
		int r = 0, sz = same[i].size();
		_for (j, 0, sz)
		{
     
			while (r < sz && same[i][r] - same[i][j] <= x) ++r;
			tot -= r - j - 1;
		}
	}
	return tot;
}

int main()
{
     
#ifdef LOCAL
	freopen("data.in", "r", stdin);
#endif
	ios::sync_with_stdio(false);
	cout.tie(0);
	cin.tie(0);
	
	cin >> n >> k;
	_rep(i, 1, n)
	{
     
		cin >> c[i];
		same[c[i]].push_back(i);
	}

	if (cal(n) < k) return puts("-1"), 0;

	int l = 0, r = n;
	while (l < r)
	{
     
		int mid = l + r + 1 >> 1;
		if (cal(mid) < k) l = mid;
		else r = mid - 1;
	}

	int dist = l + 1;
	ll cnt = cal(l);
	_rep(i, 1, n - dist) if (c[i] != c[i + dist])
	{
     
		cnt++;
		if (cnt == k)
		{
     
			cout << i << " " << i + dist << endl;
			break;
		}
	}
	
	return 0;
}

E 九峰与子序列

---

很明显的动态规划题目，但是我就是想不到，我想到以子序列为dp的目标，但是没有想到以字符串k为dp目标。

							多尝试不同的条件，说不定就能碰出火花，不能懒！

记住，动态规划不是一步就达到答案的，是一步一步转化之后才到达答案的。
$f[i][j]$表示前i个定序列匹配到字符串k第j位的所有合法方案， 所以分为取和不取两种选择，这就类似于01背包了，但是比01背包多了一个点就是取之前需要判断它是否能拼接成字符串k。

所以状态转移方程为 ：
$f[i][j]=f[i-1][j-len[i]]\ast check(ha[j],j-len[i]+1,j)+f[i-1][j]$
利用滚动数组，将状态转移方程进一步转化为 ：
$f[j]=f[j-len[i]]\ast check(ha[i],j-len[i]+1,j)+f[j]$
使用之前的值，所以别忘记了是逆序遍历。

AC代码

---

#include
using namespace std;

#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % 1000000007
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int N = 5000000 + 10, P = 131, M = 50;
ull p[N], h[N], ha[M];
ll f[N];
int n, len[M];
char k[N], a[M][N];

bool check(ull hash, int l, int r)
{
     
	return hash == h[r] - h[l - 1] * p[r - l + 1];
}

int main()
{
     
#ifdef LOCAL
	freopen("data.in", "r", stdin);
#endif
	ios::sync_with_stdio(false);
	cout.tie(0);
	cin.tie(0);

	cin >> n >> k + 1;

	int sz = strlen(k + 1);
	p[0] = 1;
	_rep(i, 1, 5e6) {
     
		p[i] = p[i - 1] * P;
		if (i <= sz) h[i] = h[i - 1] * P + k[i];
	}

	_rep(i, 1, n)
	{
     
		cin >> a[i] + 1;
		len[i] = strlen(a[i] + 1);
		_rep(j, 1, len[i]) ha[i] = ha[i] * P + a[i][j];
	}

	f[0] = 1;
	_rep(i, 1, n) For(j, sz, len[i]) f[j] += f[j - len[i]] * check(ha[i], j - len[i] + 1, j);
	cout << f[sz] << endl;
	return 0;
}

F 魏迟燕的自走棋

---

这个题目就差一点点就做出来了，太遗憾了，我只是将权值排序了，但是没有将他的下标所连接的点做出改变。
对匈牙利算法还不够熟练！

										审题很重要，重视！

AC 代码

---

#include
using namespace std;

#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % 1000000007
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int N = 100000 + 10;
int match[N];
int n, m;
int st[N];

struct Node
{
     
	int k, a[3], w;

	bool operator < (const Node& t) const
	{
     
		return w > t.w;
	}
}alls[N];

bool find(int x)
{
     
	_for (i, 0, alls[x].k)
	{
     
		int j = alls[x].a[i];
		if (!st[j])
		{
     
			st[j] = true;
			if (match[j] == 0 || find(match[j]))
			{
     
				match[j] = x;
				st[j] = false;
				return true;
			}
		}
	}
	return false;
}

int main()
{
     
#ifdef LOCAL
	freopen("data.in", "r", stdin);
#endif
	ios::sync_with_stdio(false);
	cout.tie(0);
	cin.tie(0);
	
	cin >> n >> m;
	_rep(i, 1, m)
	{
     
		cin >> alls[i].k;
		_for(j, 0, alls[i].k) cin >> alls[i].a[j];
		cin >> alls[i].w;
	}

	sort(alls + 1, alls + m + 1);
	_rep(i, 1, m) find(i);

	ll ans = 0;
	_rep(i, 1, n) if (match[i]) ans += alls[match[i]].w;
		
	cout << ans << endl;
	return 0;
}

G 九峰与蛇形填数

---

这个题目直接暴力就可以了，不需要用啥线段树。
每个点每次取值肯定是最后一个覆盖到它区域的值，所以直接取那个数即可。
然后还有一个细节就是剪枝，预处理区域的大小，如果这个点不在这个区域直接break。不用赋值了。

AC代码 （有bug）

---

#include
using namespace std;

#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % MOD
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int N = 3000 + 10, M = 2010, INF = 0x3f3f3f3f;
int n, m;
int x[N], y[N], k[N],g[M][M];

bool inside(int t, int a, int b)
{
     
	return a <= t && t <= b;
}

int main()
{
     
#ifdef LOCAL
	freopen("data.in", "r", stdin);
#endif
	ios::sync_with_stdio(false);
	cout.tie(0);
	cin.tie(0);

	cin >> n >> m;
	int x1 = INF, y1 = INF, x2 = 0, y2 = 0;
	_rep(i, 1, m)
	{
     
		cin >> x[i] >> y[i] >> k[i];
		x1 = min(x1, x[i]);
		y1 = min(y1, y[i]);
		x2 = max(x2, x[i] + k[i] - 1);
		y2 = max(y2, y[i] + k[i] - 1);
	}
		
	_rep(i, 1, n) _rep(j, 1, n) For(l, m, 1)
	{
     
		if (!inside(i, x1, x2) || !inside(j, y1, y2)) break;
		if (inside(i, x[l], x[l] + k[l] - 1) && inside(j, y[l], y[l] + k[l] - 1))
		{
     
			g[i][j] = k[l] * (i - x[l]);
			if (i - x[l] & 1) g[i][j] += y[l] + k[l] - j;
			else g[i][j] += j - y[l] + 1;
			break;
		}
	}

	_rep(i, 1, n) _rep(j, 1, n) printf("%d%s", g[i][j], j == n ? "\n" : " ");
	
	return 0;
}

----------------------------------------------------------2020、2、20---------------------------------------------------------------------
惨遭hack！还是老老实实用正规做法做吧！后面补上正规做法。感谢榜一大佬及时提醒！

看完线段树的题解之后感觉并没有想象中的那么难，都是围绕着取某个点最后一次覆盖做优化。
这里建议使用线段树求解，虽然雨巨说这个写法有点毛病，但是标算就是用线段树，出题人的意思就是让我们巩固一下线段树知识，写的每一个题总得有反思和提高，如果投机取巧，使用的还是以前会的东西，那这个题目对于你来说意义不大。

核心：找到每个点最后一次被覆盖的矩阵下标。
对于需要快速的对区间或者点的修改查询的题，我们就要想到线段树之类的知识点。
因为是矩阵，所以要用二维去维护。

维护的是每个点最后一次被覆盖的矩阵下标，每次都修改肯定是超时的，所以需要使用懒标记。

线段树的变形感觉有好多，现在又看到一种，，

AC代码 （标算）

#include
using namespace std;

#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % MOD
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int N = 2000 + 10, M = 3010;
int n, m;

struct Node
{
     
	struct point
	{
     
		int l, r, lz;
	}tr[N << 2];

	void push_down(int u){
     
		auto& t = tr[u];
		if (t.lz)
		{
     
			tr[u << 1].lz = t.lz;
			tr[u << 1 | 1].lz = t.lz;
			t.lz = 0;
		}
	}

	void build(int u, int l, int r)  
	{
     
		tr[u] = {
      l, r, 0 };
		if (l != r)
		{
     
			int mid = l + r >> 1;
			build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
		}
	}

	void modify(int u, int l, int r, int k)
	{
     
		auto& t = tr[u];
		if (l <= t.l && t.r <= r) t.lz = k;
		else
		{
     
			int mid = t.l + t.r >> 1;
			push_down(u);
			if (r <= mid) modify(u << 1, l, r, k);
			else if (l > mid) modify(u << 1 | 1, l, r, k);
			else modify(u << 1, l, mid, k), modify(u << 1 | 1, mid + 1, r, k);
		}
	}

	int query(int u, int l)
	{
     
		auto& t = tr[u];
		if (t.l == t.r) return t.lz;
		int mid = t.l + t.r >> 1;
		push_down(u);
		if (l <= mid) return query(u << 1, l);
		return query(u << 1 | 1, l);
	}
}g[N];

struct Mat
{
     
	int x, y, k;
}mat[M];

int cal(int x, int y, int k, int i, int j)
{
     
	if (i - x & 1) return k * (i - x) + y + k - j;
	return k * (i - x) + j - y + 1;
}

int main()
{
     
#ifdef LOCAL
	freopen("data.in", "r", stdin);
#endif
	ios::sync_with_stdio(false);
	cout.tie(0);
	cin.tie(0);
	
	cin >> n >> m;
	_rep(i, 1, n) g[i].build(1, 1, n);
	_rep(i, 1, m) {
     
		cin >> mat[i].x >> mat[i].y >> mat[i].k;
		_rep(j, mat[i].x, mat[i].x + mat[i].k - 1)
			g[j].modify(1, mat[i].y, mat[i].y + mat[i].k - 1, i);
	}
	
	_rep(i, 1, n) _rep(j, 1, n)
	{
     
		int v = g[i].query(1, j);
		if (!v) cout << 0;
		else
		{
     
			auto& t = mat[v];
			cout << cal(t.x, t.y, t.k, i, j);
		}
		cout << (j == n ? "\n" : " ");
	}
	
	return 0;
}

H 吴楚月的表达式

---

这个题目只要把dfs的参数搞清楚了，就差不多了。

我们对运算进行分析可以发现，只要对前一个数进行优先级运算就可以了：

• $+:(a+b)+w[j]$
• $-:(a+b)-w[j]$
• $\ast :a+b\ast w[j]$
• $/:a+b\ast w[j{]}^{-1}$

因为是从根节点出发，所以只需要三个变量$a、b、v$就可以了， $v$记录当前位置。

AC代码

---

#include
using namespace std;

#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % MOD
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int N = 100000 + 10, MOD = 1e9 + 7;
int n, w[N], fa[N], h[N], ne[N], e[N], idx;
ll ans[N];
char op[N];

void add(int a, int b)
{
     
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

ll qmi(int a, int b)
{
     
	ll res = 1, t = a;	
	while (b)
	{
     
		if (b & 1) res = mod(res * t);
		t = mod(t * t);
		b >>= 1;
	}
	return res;
}

void dfs(ll a, ll b, int v)
{
     
	ans[v] = mod(a + b);
	for (int i = h[v]; ~i; i = ne[i])
	{
     
		int j = e[i];
		switch (op[j])
		{
     
		case '+':
			dfs(a + b, w[j], j);
			break;
		case '-':
			dfs(a + b, MOD - w[j], j);
			break;
		case '*':
			dfs(a, mod(b * w[j]), j);
			break;
		default:
			dfs(a, mod(b * qmi(w[j], MOD - 2)), j);
		}
	}
}

int main()
{
     
#ifdef LOCAL
	freopen("data.in", "r", stdin);
#endif
	ios::sync_with_stdio(false);
	cout.tie(0);
	cin.tie(0);

	memset(h, -1, sizeof h);
	cin >> n;
	_rep(i, 1, n) cin >> w[i];
	add(0, 1);
	_rep(i, 2, n) cin >> fa[i], add(fa[i], i);
	cin >> op + 2;
	op[1] = '+';

	dfs(0, 0, 0);

	_rep(i, 1, n) cout << ans[i] << " ";
	cout << endl;
	
	return 0;
}

J 邬澄瑶的公约数

---

这个题目气死我了，WA了几发，看错题了，把他按照最大公倍数去算了。晕死。
这个题目只要找到所有数字中都出现的质数的最小幂相乘就得出结果了。

看题要仔细，做题前的 “ 静 ” 要做到！

AC代码

---

#include
#include
using namespace std;

#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define mod(x) (x) % 1000000007
#define debug(a) cout << #a << " = " << a << endl;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int N = 10000 + 10;
ll a[N], t[N];
unordered_map<ll, ll> ansMap;
int cnt[N];

void dive(ll x, ll p)
{
     
	for (int i = 2; 1ll * i * i <= x; ++i)
		if (x % i == 0)
		{
     
			ll s = 0;
			while (x % i == 0) x /= i, s++;
			if (!cnt[i]) ansMap[i] = s * p, cnt[i]++;
			else {
     
				ll o =  min(ansMap[i], s * p);
				ansMap[i] = o;
				cnt[i]++;
			}
		}
	if (x > 1) {
     
		if (!cnt[x]) ansMap[x] = p, cnt[x]++;
		else {
     
			ll o = min(ansMap[x], p);
			ansMap[x] = o;
			cnt[x]++;
		}
	}
}

ll qmi(ll a, ll b)
{
     
	ll res = 1;
	while (b)
	{
     
		if (b & 1) res = mod(res * a);
		a = mod(a * a);
		b >>= 1;
	}
	return res;
}

int main()
{
     
#ifdef LOCAL
	freopen("data.in", "r", stdin);
#endif
	ios::sync_with_stdio(false);
	cout.tie(0);
	cin.tie(0);

	int n;
	cin >> n;
	_for(i, 0, n) cin >> a[i];
	_for(i, 0, n) cin >> t[i];
	_for(i, 0, n) dive(a[i], t[i]);
	if (n == 1) {
     
		cout << qmi(a[0], t[0]) << endl;
		return 0;
	}
	
	ll ans = 1;
	for (const auto& p : ansMap)
		if (cnt[p.first] == n) ans = mod(ans * qmi(p.first, p.second));
	cout << ans << endl;
	return 0;
}

总结

---