Codeforces Round #578 (Div. 2)
题目链接：https://codeforces.com/contest/1200
A - Hotelier
送分题。
B - Block Adventure
一条简单的dp，注意负数。
C - Round Corridor
简单数论，随便弄个gcd除一下。
D - White Lines
题意：给出一个边长不超过2000的黑白格矩阵，有一个橡皮擦工具，可以把以(i,j)为左上端点的一个边长为k的正方形全部变成白格，求用恰好一次橡皮擦工具，最多拥有多少个全白行和全白列。
题解：假如只看全白行，就把第i行的第一个黑格fi和最后一个黑格la找出来，那么当且仅当在[i-k+1,i]*[la-k+1,fi]中使用橡皮擦工具可以使这一行变成全白，用个差分暴力一下可以维护。同理可以算出全白列的情况，然后把两次差分的结果合并起来。
char g[2005][2005];
int dr[2005][2005];
int dc[2005][2005];
int ans[2005][2005];
void test_case() {
int n, k;
scanf("%d%d", &n, &k);
for(int i = 1; i <= n; ++i)
scanf("%s", g[i] + 1);
for(int i = 1; i <= n; ++i) {
int fi = 0, la = 0;
for(int j = 1; j <= n; ++j) {
if(g[i][j] == 'B') {
if(fi == 0)
fi = j;
la = j;
}
}
if(fi == 0) {
for(int j = 1; j <= n; ++j) {
++dr[j][1];
--dr[j][n + 1];
}
} else {
int L = max(1, la - k + 1), R = fi;
if(L <= R) {
for(int j = max(1, i - k + 1); j <= i; ++j) {
++dr[j][L];
--dr[j][R + 1];
}
}
}
}
for(int j = 1; j <= n; ++j) {
int fi = 0, la = 0;
for(int i = 1; i <= n; ++i) {
if(g[i][j] == 'B') {
if(fi == 0)
fi = i;
la = i;
}
}
if(fi == 0) {
for(int i = 1; i <= n; ++i) {
++dc[1][i];
--dc[n + 1][i];
}
} else {
int U = max(1, la - k + 1), D = fi;
if(U <= D) {
for(int i = max(1, j - k + 1); i <= j; ++i) {
++dc[U][i];
--dc[D + 1][i];
}
}
}
}
/*for(int i = 1; i <= n; ++i)
for(int j = 1; j <= n; ++j)
printf("%d%c", dr[i][j], " \n"[j == n]);
for(int i = 1; i <= n; ++i)
for(int j = 1; j <= n; ++j)
printf("%d%c", dc[i][j], " \n"[j == n]);*/
for(int i = 1; i <= n; ++i) {
int cur = 0;
for(int j = 1; j <= n + 1; ++j) {
cur += dr[i][j];
ans[i][j] += cur;
}
}
for(int j = 1; j <= n; ++j) {
int cur = 0;
for(int i = 1; i <= n + 1; ++i) {
cur += dc[i][j];
ans[i][j] += cur;
}
}
int res = 0;
for(int i = 1; i <= n; ++i) {
for(int j = 1; j <= n; ++j)
res = max(res, ans[i][j]);
}
printf("%d\n", res);
}
*E - Compress Words
题意：给n个字符串，要求把他们依次首尾连接，每次连接可以把最长的重叠的前后缀重叠在一起，求结果。
假算法：看起来可以二分每次重叠的长度，然后用哈希来验证，问题在于如何维护后缀哈希，更暴力就再用一个线段树。虽然看起来这个算法的复杂度是O(nlognlogn)，但是仔细想一想并不是这样，首先线段树更新的时候，单点更新一个字符，最多更新n次，这部分复杂度是O(nlogn)，然后在二分每次重叠的长度的时候，设新的字符串的长度是x，需要二分logx次，每次询问是logn，但是由于所有的x加起来才是n这么多，最坏的情况是一共添加n次长度为1的新字符串，复杂度也是O(nlogn)，直观理解可以知道，新增的字符串平均长度越长，复杂度越低，因为log是个增长及其缓慢的函数。
上面这个算法假在：最大的匹配长度并不是满足单调性的东西。
题解：把上面的二分去掉，直接换成暴力。反正新增的每个字符最多被检测一次，也就是说，需要注意到匹配的过程和原串的长度并没有什么必然联系。再想想，好像连线段树也可以不要了。
const int MAXN = 1000000;
const int BASE = 2333;
int BASEPOW[MAXN + 5];
void Init() {
BASEPOW[0] = 1;
for(int i = 1; i <= MAXN; ++i)
BASEPOW[i] = 1ll * BASEPOW[i - 1] * BASE % MOD;
}
char ans[MAXN + 5];
char tmp[MAXN + 5];
int anslen, tmplen;
int ha1[MAXN + 5];
int ha2[MAXN + 5];
void test_case() {
Init();
int n;
scanf("%d", &n);
anslen = 0;
while(n--) {
scanf("%s", tmp + 1);
tmplen = strlen(tmp + 1);
int maxlen = 0, ceilen = min(anslen, tmplen);
for(int x = 1; x <= ceilen; ++x) {
ha1[x] = (1ll * ans[anslen - x + 1] * BASEPOW[x - 1] + ha1[x - 1]) % MOD;
ha2[x] = (1ll * ha2[x - 1] * BASE + tmp[x]) % MOD;
if(ha1[x] == ha2[x])
maxlen = x;
}
for(int i = 1 + maxlen; i <= tmplen; ++i)
ans[++anslen] = tmp[i];
}
puts(ans + 1);
}
启示：哈希真是个好办法。
深入理解KMP：其实这个匹配形式一开始确实觉得像KMP，但是不知道假如套KMP的话，谁是text串，谁是pattern串。事实上因为每次匹配的长度最大就是min(anslen,tmplen)，截取ans串的这个长度的后缀放在后面，截取tmp串的这个长度的前缀放在前面，然后求一次前缀函数，得到的结果就是最长的重叠的真前后缀的长度。但是怎么保证结果不超过这个长度呢？
比如："ababa"+"babab"
正确的答案应该是："abab"
但求出的最长重叠串是："abababab"
解决的办法是在中间加个'#'。
变成："ababa"+"#"+"babab"
求出的最长重叠串是："abab"
#include<bits/stdc++.h>
using namespace std;
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1061109567;
const ll LINF = 4557430888798830399ll;
const int MOD = 1000000007;
/*---*/
const int MAXN = 1000000;
int pi[2 * MAXN + 5];
char s[2 * MAXN];
void GetPrefixFunction(char *s, int sl) {
pi[0] = 0, pi[1] = 0;
for(int i = 1, k = 0; i < sl; ++i) {
while(k && s[i] != s[k])
k = pi[k];
pi[i + 1] = (s[i] == s[k]) ? ++k : 0;
}
}
char ans[MAXN + 5];
char tmp[MAXN + 5];
int anslen, tmplen;
void test_case() {
int n;
scanf("%d", &n);
anslen = 0;
while(n--) {
scanf("%s", tmp + 1);
tmplen = strlen(tmp + 1);
int ceilen = min(anslen, tmplen), sl = 0;
for(int x = 1; x <= ceilen; ++x)
s[sl++] = tmp[x];
//s[sl++] = '#';
for(int x = 1; x <= ceilen; ++x)
s[sl++] = ans[anslen - ceilen + x];
GetPrefixFunction(s, sl);
int maxlen = min(ceilen, pi[sl]);
for(int i = 1 + maxlen; i <= tmplen; ++i)
ans[++anslen] = tmp[i];
}
puts(ans + 1);
}
int main() {
#ifdef KisekiPurin
freopen("KisekiPurin.in", "r", stdin);
#endif // KisekiPurin
int t = 1;
//scanf("%d", &t);
for(int i = 1; i <= t; ++i) {
//printf("Case #%d:", i);
test_case();
}
return 0;
}
*F - Graph Traveler
题目：有n(<=1000)个点，每个点有[1,10]条出边，且每个点有个权值，从某个点出发的时候会加上当前点的权值，然后根据权值mod当前点的出边数量，选择那条唯一的出边走出去。很显然无论从哪个点以什么初始权值出发，都会无限走下去。若干次询问，每次询问，回答某个起点以某个初始权值出发，无穷次经过的点的数量。
这个东西并不等价于问题“给一片1000*10个点的内向基环树森林，每个点记录当前的总权值，对每一个起点确定从它出发可以无穷次经过的点的数量。”，因为每个点的出边数量是不一定的，所以不能在某一个点模出边数量。遂看题解。
题解：虽然不能在某一个点模出边数量，但是因为[1,10]的lcm是2520，所以真正有用的权值是[0,2520)，构造一片1000*2520个点的内向基环树森林，dp即可。需要注意很多个细节，比如转移的时候是要加上终点的权值，而不是起点的权值。最好写个小的LCM=12观察样例，然后写几个id和反id观察是不是搞错了。
基环树计算环的大小，本身是不需要SET的，但是这里要记录原本的节点的编号，再去重，假如用不排序去重的方法有可能导致复杂度错误。
const int LCM = 2520;
const int MAXN = 1000;
const int MAXNLCM = MAXN * LCM;
int K[MAXN + 5];
int G[MAXNLCM + 5];
int id(int i, int j) {
return (i - 1) * LCM + j + 1;
}
int id_i(int id) {
return (id - 1) / LCM + 1;
}
int id_j(int id) {
return (id - 1) % LCM;
}
int C[MAXNLCM + 5], cntC;
int DP[MAXNLCM + 5];
set<int> SET;
stack<int> STACK;
int inC;
int dfs(int u, int c) {
if(C[u]) {
if(C[u] == c) {
inC = u;
return 0;
}
return DP[u];
}
C[u] = c;
if(DP[u] = dfs(G[u], c))
return DP[u];
if(inC) {
SET.insert(id_i(u));
STACK.push(u);
if(u == inC) {
int siz = SET.size();
while(!STACK.empty()) {
int TOP = STACK.top();
STACK.pop();
DP[TOP] = siz;
}
inC = 0;
SET.clear();
return DP[u];
}
return 0;
}
exit(-1);
}
void test_case() {
int n;
scanf("%d", &n);
int e[10];
for(int i = 1, k; i <= n; ++i) {
scanf("%d", &k);
k = (k % LCM + LCM) % LCM;
K[i] = k;
}
for(int i = 1, m; i <= n; ++i) {
scanf("%d", &m);
for(int mi = 0; mi < m; ++mi)
scanf("%d", &e[mi]);
for(int j = 0; j < LCM; ++j) {
int vi = e[j % m];
int vj = (j + K[vi]) % LCM;
G[id(i, j)] = id(vi, vj);
}
}
cntC = 0;
for(int i = 1; i <= LCM * n; ++i) {
if(C[i] == 0)
dfs(i, ++cntC);
}
int q;
scanf("%d", &q);
while(q--) {
int i, j;
scanf("%d%d", &i, &j);
j = (j % LCM + LCM) % LCM;
j = (j + K[i]) % LCM;
printf("%d\n", DP[id(i, j)]);
}
}
总结：基环树复杂版？基环树计算环的大小的方法大概就是这样了，若遇到环入口或者dfs返回值非0或者遇到其他dfs的染色块，则说明已经退出环，则计算栈中的环的信息，或者直接继承DP值。其他情况就是非环入口的环节点，返回值为0。注意在基环树中开始dfs并不能只从入度为0的点开始，有可能整个基环树就是一个环。但是从任意一个点开始是可以的，因为假如在环中，则这个就是环入口，会把整个环染色。否则一定会进入某个环入口，然后把整个环染色，无论如何都会把这个点能到达的环染色。
假如换成vector排序去重，好像使用了更多空间，不过节省了时间，道理是显然的，因为set是最多拥有1000个数，而vector是非常浪费空间的。有个办法是记录一个虚拟的vector大小，当大小超过某个极限时把vector中的元素插进set，然后改用set统计，这样貌似还不如直接用set统计，反正复杂度是对的。
基环树是否可以写成一个非递归的版本？
