@codeforces - 594E@ Cutting the Line

---

@description@

给定一个字符串 s 与正整数 k。现在你需要进行恰好一次操作：

（1）将 s 切割成最多 k 个子串。即令 s = t1 + t2 + ... + tm (1 <= m <= k)。
（2）将其中的某些（不是全部） ti 翻转，得到 t1', t2', ... tm'。
（3）重新拼合得到 s' = t1' + t2' + ... tm'。

求字典序最小化的 s'。

原题请戳我查看ouo。

@solution@

先考虑假如可以任意划分，而没有段数的限制的话该怎么做。
注意到一个不翻转的子串可以拆解成若干个长度为 1 的翻转的子串，也就是说我们可以总默认所有子串都要翻转。
考虑将原串 \(S\) 翻转得到 \(S^r\)，则我们可以将操作等效地理解成将 \(S^r\) 划分成若干子串，然后从后往前取出这些串拼合得到 \(S'\)。
要使 \(S'\) 的字典序最小，不难联想到 lyndon 分解：\(S^r\) 的 lyndon 分解就是我们想要的答案（默认大家都会，不会可以百度.jpg）。

假如加上 k 的限制，注意到当 k > 2 时我们依然可以贪心地取出最末尾的 lyndon 串。
直观理解的话，大概就是这么做不会影响之后操作的合法性。
注意到长度为 1 的 lyndon 串我们可以一起取出（对应不翻转的情况），长得一样的 lyndon 串我们也可以一起取出（一起翻转和分别翻转的结果一样）。
（这里有一个处理的 trick：考虑 lyndon 分解的过程，在 lyndon 分解的时候我们就可以把长得一样的串处理出来）

接下来考虑 k <= 2 的情况。k = 1 没什么话说，主要说一下 k = 2。

分几种情况：

（1）划分线前后的串都不翻转。情况唯一。

（2）划分线前的串不翻转，划分线后的串翻转。发现得到的 \(S'\) = \(S\) 的一个前缀 + \(S^r\) 的一个前缀。
比较字典序时可以用求 lcp 的方法比较。注意到只需要求某个子串和 \(S^r\) 的 lcp，所以把 \(S^r \#S\) 拿去建 \(Z-algorithm\)（扩展 kmp）就 OK。

（3）划分线前的串翻转。此时划分线前的串是 \(S^r\) 的一个后缀 \(T\)。
我们先要让划分线前字典序最小，至少要满足 \(T\) 的所有后缀要么字典序严格大于 \(T\)，要么是 \(T\) 的前缀。
考虑依然对 \(S^r\) 进行 lyndon 分解，则 \(T\) 应该是末尾几个完整的 lyndon 串拼合，不然矛盾。
经过分析，满足上述条件的情况下，\(T\) 最多包含两种不同 lyndon 串。同时为了字典序最小，假如 \(T\) 包含了某一种 lyndon 串，就应包含所有与它相同的串。
再讨论后面要不要翻转，一共 4 种情况，暴力求出来比较字典序即可。

@accepted code@

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int MAXN = 5000000;

void solve1(char *S) {
    int lenS = strlen(S);
    for(int i=0,j=lenS-1;i<j;i++,j--)
        if( S[i] < S[j] ) break;
        else if( S[i] > S[j] ) {
            for(i=0,j=lenS-1;i<j;i++,j--)
                swap(S[i], S[j]);
            break;
        }
    puts(S);
}

void lyndon(char *S, int *f, int lenS) {
    int cnt = 0;
    for(int i=0;i<lenS;i++) f[i] = 0;
    for(int i=0;i<lenS;) {
        int j = i, k = i + 1;
        while( k < lenS && S[j] <= S[k] )
            j = (S[j] == S[k] ? j + 1 : i), k++;
        int t = k - j; cnt++;
        while( i + t - 1 < k )
            f[i + t - 1] = cnt, i += t;
    }
}

void algorithmZ(char *S, int *f, int lenS) {
    f[0] = lenS; int mx = 0, ps = 0;
    for(int i=1;i<lenS;i++) {
        f[i] = (i <= mx ? min(mx - i + 1, f[i - ps]) : 0);
        while( S[f[i]] == S[i+f[i]] ) f[i]++;
        if( i + f[i] - 1 > mx ) mx = i + f[i] - 1, ps = i;
    }
}

char ans[MAXN + 5], T[2*MAXN + 5]; int f[2*MAXN + 5];
int cmp(int l, int r) {
    int p = f[l];
    if( p >= r - l + 1 ) return 0;
    else return (T[l + p] < T[p] ? -1 : 1);
}// (s[l, r] == s[0, r-l] ? 0 : (s[l, r] < s[0, r-l] ? -1 : 1))
bool cmp2(char *S, char *T, int n) {
    for(int i=0;i<n;i++) {
        if( S[i] < T[i] ) return true;
        else if( S[i] > T[i] ) return false;
    }
    return true;
}// S < T
void update(char *T, int lenS) {
    if( cmp2(T, ans, lenS) ) for(int i=0;i<lenS;i++) ans[i] = T[i];
}
int get(int x) {
    int p; for(p = x - 1; p >= 0 && f[p] == 0; p--);
    return p;
}

void update2(char *S, int x, int lenS) {
    for(int i=0;i<x;i++) T[i] = S[x-i-1];
    for(int i=x;i<lenS;i++) T[i] = S[i];
    update(T, lenS);
    for(int i=x,j=lenS-1;i<j;i++,j--) swap(T[i], T[j]);
    update(T, lenS);
}

void solve2(char *S) {
    int lenS = strlen(S);
    for(int i=0;i<lenS;i++) ans[i] = S[i];
    
    for(int i=0;i<lenS;i++) T[lenS-i-1] = S[i], T[lenS+i+1] = S[i];
    algorithmZ(T, f, 2*lenS+1);
    int pos = 0;
    for(int i=1;i<lenS-1;i++) {
        int t = cmp(lenS + 1 + pos + 1, lenS + 1 + i);
        if( t == 0 ) {
            if( cmp(i - pos, lenS - pos - 2) == 1 ) pos = i;
        }
        else if( t == -1 ) pos = i;
    }
    for(int i=0;i<lenS;i++) T[i] = S[i];
    for(int i=pos+1,j=lenS-1;i<j;i++,j--) swap(T[i], T[j]);
    update(T, lenS);
    
    for(int i=0;i<lenS;i++) T[lenS-i-1] = S[i];
    lyndon(T, f, lenS);
    int tmp = get(lenS - 1);
    while( tmp >= 0 && f[tmp] == f[lenS - 1] ) tmp = get(tmp);
    update2(S, lenS - tmp - 1, lenS);
    if( tmp >= 0 ) {
        int p = get(tmp);
        while( p >= 0 && f[p] == f[tmp] ) p = get(p);
        update2(S, lenS - p - 1, lenS);
    }
    puts(ans);
}

void print(int l, int r) {
    for(int i=l;i<=r;i++)
        putchar(T[i]);
}

char S[MAXN + 5];
int main() {
    int k; scanf("%s%d", S, &k);
    if( k == 1 ) solve1(S);
    else {
        int lenS = strlen(S);
        for(int i=0;i<lenS;i++) T[lenS-i-1] = S[i];
        lyndon(T, f, lenS);
        int lst = lenS - 1, len = 0, tmp = 0;
        while( k >= 2 && lst >= 0 ) {
            int p = get(lst);
            if( !(len == 1 && lst - p == 1) && !(f[lst] == tmp)  ) {
                if( k == 2 ) break;
                k--;
            }
            print(p + 1, lst);
            len = lst - p, tmp = f[lst], lst = p;
        }
        if( lst >= 0 ) solve2(S + (lenS - lst - 1));
    }
}

@details@

直觉猜想和 lyndon 分解有关，然而想不到怎么处理 k = 2 的情况。。。

感觉考察了两个冷门的线性字符串算法。。。而且两个都是初见。。。

另外，正确性的证明什么的。。。不是很擅长不过直观理解起来都对所以就没写了啦啦啦。