平邑集训（补题）
Day 1
A 咕咕
题目描述
解法
DP，设 \(dp_{i,j}\) 表示从 \((1,1)\) 走到 \((n,m)\) 的方案数。
转移的时候，需要按照给定的限制走，如果一个点的（2）（3）限制冲突了，那么就标记一下，经过他的时候绕过他，时间复杂度 \(O(nm)\)。
代码
点击查看代码
int n,m,t;
int f[3001][3001];
int dp[3001][3001];
void solve()
{
cin>>n>>m>>t;
int i,j;
while(t--)
{
int a,b,c,d;
cin>>a>>b>>c>>d;
bool flag = 0;
if(a==n&&b==m)
continue;
if((c==a+1&&d==b)||(d==b+1&&a==c))
flag = 1;
if(!flag||f[a][b]==-1)
{
f[a][b] = -1;
continue;
}
if(c==a+1)
{
if(f[a][b]==2)
f[a][b] = -1;
else
f[a][b] = 1;
}
else if(d==b+1)
{
if(f[a][b]==1)
f[a][b] = -1;
else
f[a][b] = 2;
}
}
if(f[1][1]==-1)
{
cout<<0<<endl;
return;
}
dp[1][1] = 1;
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
{
if(f[i][j]==-1)
dp[i][j]=0;
else
{
if(f[i-1][j]!=2)
dp[i][j] += dp[i-1][j];
if(f[i][j-1]!=1)
dp[i][j] += dp[i][j-1];
dp[i][j] %= mod;
}
}
cout<<dp[n][m]<<endl;
return;
}
B 找子串
题目描述
解法
- Subtask 1
每次删掉 \(T\) 后重新暴力再找第一个 \(T\)，时间复杂度 \(O(\dfrac{|S|}{|T|}\cdot |S| \cdot |T|)\)。
- Subtask 2
每次删掉 \(T\) 后用 kmp 或哈希找到第一个 \(T\)，时间复杂度 \(O(\dfrac{|S|}{|T|}\cdot |S|)\)。
- Subtask 3
每次删掉 \(T\) 后，从删掉位置之前的 \(T\) 个位置开始，用 kmp 或哈希找 \(T\)，时间复杂度 \(O(|S|\cdot |T|)\)。
- 满分做法
用 kmp 从 \(S\) 中找 \(T\) 时，对于 \(S\) 中的每一个位置 \(i\)，记录以 \(i\) 为结尾的子串，和 \(T\) 最多匹配到哪里，可以用一个数组记录下来，比如 \(match\)。
举个例子：若 \(S="gogoododgoodluck",T="good"\).
则 \(match_0 = 0\)，因为 \(S\) 中的 g 与 \(T\) 中的 g 匹配。
则 \(match_1 = 1\)，因为 \(S\) 中的 go 与 \(T\) 中的 go 匹配。
则 \(match_2 = 0\)，因为 \(S\) 中的 g 与 \(T\) 中的 g 匹配。
则 \(match_3 = 1\)，因为 \(S\) 中的 go 与 \(T\) 中的 go 匹配。
则 \(match_4 = 2\)，因为 \(S\) 中的 goo 与 \(T\) 中的 goo 匹配。
则 \(match_5 = 3\)，因为 \(S\) 中的 good 与 \(T\) 中的 good 匹配。
在上面的例子中，如果将第一个 good 从 \(S\) 中删除后，没有必要从头开始找 good，因为以前就知道 \(match_1=1\)，因此从 \(S_1\) 处继续 kmp 即可，可以通过栈来实现。
代码
点击查看代码
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
char s[maxn], t[maxn];
char sta[maxn];
int fail[maxn], fail1[maxn], n, m, top;
void init()
{
for (int i = 2, j = 0; i <= m; i++)
{
while (j && t[i] != t[j + 1])
{
j = fail[j];
}
if (t[i] == t[j + 1])
j++;
fail[i] = j;
}
}
void kmp()
{
for (int i = 1, j = 0; i <= n; i++)
{
sta[++top] = s[i];
while (j && sta[top] != t[j + 1])
{
j = fail[j];
}
if (sta[top] == t[j + 1])
j++;
fail1[top] = j;
if (j == m)
{
top -= m;
j = fail1[top];
}
}
}
int main()
{
scanf("%s", s + 1);
scanf("%s", t + 1);
n = strlen(s + 1);
m = strlen(t + 1);
init();
kmp();
for (int i = 1; i <= top; i++)
printf("%c", sta[i]);
return 0;
}
C LCS 问题
题目描述
思路
- 对于前 \(60\%\) 的数据
因为序列长度最多为 \(5000\)，所以可以暴力 LCS。考虑 dp，\(f_{i,j}\) 表示 \(a\) 数组前 \(i\) 个数和 \(b\) 数组前 \(i\) 个数的最长公共子序列。
如果 \(a_i=b_j\)，那么 \(f_{i,j} = max(f_{i-1,j},f_{i,j-1},f_{i-1,j-1}+1)\)。
然后 \(f_{i,j}=max(f_{i-1,j},f_{i,j-1})\)。
时间复杂度为 \(O(n^2)\)。
- 满分做法
关键在于保证 \(1~n\) 这 \(n\) 个数在 \(a,b\) 中分别出现 \(5\) 次。枚举 \(i\)，同时维护 \(f_j\) 表示 \(a\) 数组前 \(i\) 个数和 \(b\) 数组前 \(j\) 个数的最长公共子序列。同时要求这个最长公共子序列在 \(b\) 中必须以 \(b_j\) 结尾。
一开始对于每个 \(x\)，用二维数组存下数值 \(x\) 在 \(b\) 中的所有位置。枚举 \(i\) 时，枚举数值 \(a_i\) 在 \(b\) 中的所有位置 \(k\)。这时候所有的 \(f_j\) 都是 \(a\) 数组中前 \(i\) 个数和 \(b\) 数组中前 \(j\) 个数的最长公共子序列。
我们令 \(g_k = \max_{i=1}^{k-1} f_i+1\)，那么 \(g_k\) 也就是 \(a\) 数组中前 \(i\) 个数和 \(b\) 数组中前 \(k\) 个数的最长公共子序列。
对于 \(b_j \ne a_i\) 的 \(j\)，显然 \(g_j=f_j\)，也就是说 \(f_j\) 不用改动。
那么我们现在就要单点修改，求前缀最大值，用树状数组维护 \(f_j\) 的前缀最大值，时间复杂度 \(O(nlogn)\)。
代码
点击查看代码
inline int lowbit(int x)
{
return x&(-x);
}
inline void change(int x,int y)
{
for(int i=x;i<=N;i+=lowbit(i))
f[i]=max(f[i],y);
return;
}
inline int query(int x)
{
int res=0;
for(int i=x;i;i-=lowbit(i))
res=max(f[i],res);
return res;
}
for(int i=1;i<=n5;i++)
{
int x=read();
c[x][++cnt[x]]=i;
}
for(int i=1;i<=n5;i++)b[i]=read();
for(int i=1;i<=n*5;i++)
for(int j=5;j;j--)
{
int res=query(c[b[i]][j]-1);
change(c[b[i]][j],res+1);
D 舞步
题目描述
Farmer John 的奶牛们正在炫耀她们的最新舞步！
最初，所有的 \(N\) 头奶牛（\(2≤N≤10^5\)）站成一行，奶牛 \(i\) 排在其中第 \(i\) 位。舞步序列给定为 \(K\) （\(1≤K≤2\times10^5\)）个位置对 \((a_1,b_1),(a_2,b_2),…,(a_K,b_K)\)。在舞蹈的第 \(i=1…K\) 分钟，位置 \(a_i\) 与 \(b_i\) 上的奶牛交换位置。同样的 \(K\) 次交换在第 \(K+1…2K\) 分钟发生，在第 \(2K+1…3K\) 分钟再次发生，以此类推，周期性地持续共 \(M\) 分钟（\(1≤M≤10^{18}\)）。换言之，
- 在第 \(1\) 分钟，位置 \(a_1\) 与 \(b_1\) 上的奶牛交换位置。
- 在第 \(2\) 分钟，位置 \(a_2\) 与 \(b_2\) 上的奶牛交换位置。
- ……
- 在第 \(K\) 分钟，位置 \(a_K\) 与 \(b_K\) 上的奶牛交换位置。
- 在第 \(K+1\) 分钟，位置 \(a_1\) 与 \(b_1\) 上的奶牛交换位置。
- 在第 \(K+2\) 分钟，位置 \(a_2\) 与 \(b_2\) 上的奶牛交换位置。
- 以此类推……
对于每头奶牛，求她在队伍中会占据的不同的位置数量。
注意：本题每个测试点的时间限制为默认限制的两倍。
输入格式
输入的第一行包含 \(N\)、\(K\) 和 \(M\)。以下 \(K\) 行分别包含 \((a_1,b_1)…(a_K,b_K)\)（\(1≤a_i<b_i≤N\)）。
输出格式
输出 \(N\) 行，第 \(i\) 行包含奶牛 \(i\) 可以到达的不同的位置数量。
提示
\(7\) 分钟之后，各个位置上的奶牛为 \([3,4,5,2,1,6]\)。
- 奶牛 \(1\) 可以到达位置 \(\{1,2,3,4,5\}\)。
- 奶牛 \(2\) 可以到达位置 \(\{1,2,3,4\}\)。
- 奶牛 \(3\) 可以到达位置 \(\{1,2,3\}\)。
- 奶牛 \(4\) 可以到达位置 \(\{2,3,4\}\)。
- 奶牛 \(5\) 可以到达位置 \(\{3,4,5\}\)。
- 奶牛 \(6\) 从未移动，所以她没有离开过位置 \(6\)。
测试点性质：
- 测试点 1-5 满足 \(N≤100,K≤200\)。
- 测试点 6-10 满足 \(M=10^{18}\)。
- 测试点 11-20 没有额外限制。
我们先考虑弱化版，即将 周期性地持续共 M 分钟 改为 无限循环。
弱化版
考虑经过 \(k\) 分钟后，每头牛会途径某些点到达另一个点，假如 \(A\) 从 \(x\) 位置走到了 \(y\) 位置，\(B\) 从 \(x\) 走到了 \(x\)，那么再经过一轮，\(B\) 也会走到 \(y\) 位置。
也就是说 \(B\) 的运动轨迹会和 \(A\) 一样，只不过落后 \(k\) 分钟罢了。同时 \(B\) 经过的点也和 \(A\) 一样，所以像 \(A,B\) 一样的有相同运动轨迹的牛，它们的运动轨迹将会在 \(k\) 分钟之内构成一个环。
而环可以用并查集维护。接下来用 vector 记录每个点经过的点，对于一个环内的牛，用 set 统计每个点经过了多少个点，设为 \(x\)，则环内每一个牛能经过的点数也就是 \(x\)。
时间复杂度 \(O(n+k)\)。
普通版
也就是多了个时间限制。
令 \(times = \left \lfloor \dfrac{m}{k} \right \rfloor\) 表示一个点开始走会完整走 \(t\) 轮，\(w = m-kt\) 表示走完 \(t\) 轮还需要走 \(w\) 步。
手动模拟一下，发现类似滑动窗口，每次暴力加入 \(w\) 步，计算答案，再删除当前点，把加入 \(w\) 步的点剩下的都加进去，时间复杂度为 \(O(n+k)\)。
注意 \(times=0\) 的情况和特判环大小 \(\le times\) 的情况。
(补）
Day 2
A 江桥的均衡区间
题目描述
解法
- Subtask 1 & Subtask 2
枚举 \(i\)，然后往后扩展，每次遇到一个数把他扔进去
- Subtask 3
枚举区间的起点终点，左右端点为 \(j,i(j<i)\)
\(p1_i-p1_{j-1}=p2_i-p2_{j-1}\)，移项，\(p1_i-p2_i=p1_{j-1}-p2_{j-1}\)。
