H. Reverse the String【哈希+二分】

传送门 codeforces H. Reverse the String

题意

给定一个字符串，求可以将字符串中的任意区间的一个连续子串翻转一次的前提下，求翻转后字典序最小的字符串是什么

分析

将原串的所有字符排序，翻转肯定是从排序后的字符串与原字符串不同的位置开始的
那么可以遍历翻转的结束位置，比较所有翻转后字符串的大小
假如当前字典序最小的是 $s$，那么和翻转后的字符串 $t$比较时，可以先找到两个字符串的 最长公共前缀($lcp$)，前面都是相同的，只需比较不同的第一个位置的大小即可
此时，寻找两个字符串的$lcp$可以使用二分+哈希进行求解

代码

//E
/*
  @Author: YooQ
*/
#include <bits/stdc++.h>
using namespace std;
#define sc scanf
#define pr printf
#define ll long long
#define FILE_OUT freopen("out", "w", stdout);
#define FILE_IN freopen("in", "r", stdin);
#define debug(x) cout << #x << ": " << x << "\n";
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
#define MAX(a, b) (a >= b ? a : a = b)
#define MIN(a, b) (a <= b ? a : a = b)
#define AC 0
#define WA 1
#define INF 0x3f3f3f3f
const ll MAX_N = 2e6+5;
const ll MOD = 1e9+7;
int N, M, K;

char arr[MAX_N];
char brr[MAX_N];
unsigned long long hs[2][MAX_N];
unsigned long long P[MAX_N];
unsigned long long base = 151233;

unsigned long long hsA(int l, int r) {
	return hs[0][r] - hs[0][l-1] * P[r - l + 1];
}

unsigned long long hsB(int l, int r) {
	return hs[1][r] - hs[1][l-1] * P[r - l + 1];
}
 
void init() {
	P[0] = 1;
	for (int i = 1; i < MAX_N; ++i) {
		P[i] = P[i-1] * base;
	}
}

struct Node {
	int l, r, len, _l, _r, _len;
	
	Node(int l, int r) {
		this->l = l;
		this->r = r;
		len = r - l + 1;
		_l = N - r + 1;
		_r = N - l + 1;
		_len = len + N - r;
	}
	
	unsigned long long int h(int mid) {
		if (mid <= len) {
			return hsB(_l, _l + mid - 1); 
		} else {
			return hsB(_l, _l + len - 1) * P[mid-len] + hsA(r + 1, l + mid - 1);
		}
	}
	
	char at(int x) {
		if (x <= len) {
			return brr[_l + x - 1];
		} else if (x <= _len) {
			return arr[l + x - 1];
		}
	}
	
	void print() {
		cout << "l: " << l << " r: " << r << " len: " << len << " _l: " << _l << " _r: " << _r << " _len: " << _len << "\n";
	}
	
	bool operator < (Node& B) {
		int L = 0, R = min(_len, B._len), mid = 0, ans = 0;
		unsigned long long hs1, hs2;
		while (L <= R) {
			mid = L + ((R-L)>>1);
			hs1 = h(mid);
			hs2 = B.h(mid);
			if (hs1 == hs2) {
				L = mid + 1;
				ans = mid;
			} else {
				R = mid - 1;
			}
		}
		return at(ans+1) <= B.at(ans+1);
	}
};

void solve() {
	cin >> arr+1; 
	N = strlen(arr + 1);
	for (int i = 1; i <= N; ++i) {
		hs[0][i] = hs[0][i-1] * base + arr[i];
	}
	
	memcpy(brr+1, arr+1, N+1);
	reverse(brr+1, brr+1+N);
	for (int i = 1; i <= N; ++i) {
		hs[1][i] = hs[1][i-1] * base + brr[i];
	}
	
	sort(brr+1, brr+1+N);
	int l = 1;
	while (arr[l] == brr[l] && l <= N) ++l;
	if (l == N+1) {
		cout << arr + 1 << "\n";
		return;
	}
	
	memcpy(brr+1, arr+1, N+1);
	reverse(brr+1, brr+1+N);
	Node ans = Node(l, l);
	for (int i = l+1; i <= N; ++i) {
		Node t = Node(l, i);
		if (t < ans) {
			ans = t;
		}
	}
	
	reverse(arr+ans.l, arr+ans.r+1);
	cout << arr+1 << "\n";
}

/*
4
abcd
dcba
acbd
cabd
*/
signed main() {
	#ifndef ONLINE_JUDGE
//	FILE_IN
	FILE_OUT
	#endif
	init();
	int T = 1; cin >> T;
	while (T--) solve();

	return AC;
}