• 【洛谷3546_BZOJ2803】[POI2012]PRE-Prefixuffix(String Hash)


    Problem:

    洛谷3546

    Analysis:

    I gave up and saw other's solution when I had nearly thought of the method ... What a pity

    Let's define a border of string (s) as a prefix (p) of (s) that (p) is also a suffix of (s), and (p) is not longer than half of (s). What the problem asked us to look for is a number (L), that the prefix of length (L) can be divided into two string (s1) and (s2) , and the suffix of length (L) can be divided into two string (s2) and (s1), so that this pair of prefix and suffix is cyclically equivalent. Obviously, (s1) is a border of string (s). Another fact is, if (s1) is of length (len), (s2) is a border of the substring ([len, n - len - 1]). Define (f[len]) as the length of the maximum border of the substring ([len, n - len - 1]) . Let's enumerate the length of (s1) as (len) brutely, and for all legal (len) ("legal" means the prefix of length (len) is a border of (s). We can check it by hashing in (O(1)) time), the answer is (len + f[len]).

    Now the problem is how to calculate (f[len]). Brute force takes (O(n^2)) complexity, but the useful fact below can decrease the complexity to (O(n)) :

    [f[i]leq f[i+1]+2 ]

    To make it easy, look at the (beautiful) picture below.

    The first picture shows the situation when (f[i]=f[i+1]+2), and the second picture shows if (f[i]) (the black ones) is more than (f[i+1]) (the red ones) plus (2) , the (f[i+1]) must be wrong, for there's a longer border (the blue ones) of substring ([i+1, n-i-2]).

    Because of this fact, we can solve (f[len]) in (O(n)) time. We initialize (f[i]) as (f[i+1]+2), and decrease it until the substring ([i, n-i-1]) has a border of length (f[i]). The proof of the complexity is similar to the one of solving (height) array by Suffix Array.

    Code:

    #include <cstdio>
    #include <algorithm>
    #include <cstring>
    #include <cctype>
    using namespace std;
    
    namespace zyt
    {
    	template<typename T>
    	inline bool read(T &x)
    	{
    		char c;
    		bool f = false;
    		x = 0;
    		do
    			c = getchar();
    		while (c != EOF && c != '-' && !isdigit(c));
    		if (c == EOF)
    			return false;
    		if (c == '-')
    			f = true, c = getchar();
    		do
    			x = x * 10 + c - '0', c = getchar();
    		while (isdigit(c));
    		if (f)
    			x = -x;
    		return true;
    	}
    	inline bool read(char *const s)
    	{
    		return ~scanf("%s", s);
    	}
    	template<typename T>
    	inline void write(T x)
    	{
    		static char buf[20];
    		char *pos = buf;
    		if (x < 0)
    			putchar('-'), x = -x;
    		do
    			*pos++ = x % 10 + '0';
    		while (x /= 10);
    		while (pos > buf)
    			putchar(*--pos);
    	}
    	const int N = 1e6 + 10;
    	int f[N], n;
    	// f[i] is the maximum length of the border of substr[i, n - i - 1]
    	char str[N];
    	namespace Hash
    	{
    		typedef long long ll;
    		typedef pair<int, int> pii;
    		typedef pii hash_t;
    		hash_t h[N], pow[N];
    		const hash_t seed = hash_t(61, 67), p = hash_t(1e9 + 7, 1e9 + 9);
    		hash_t operator + (const hash_t &a, const hash_t &b)
    		{
    			return hash_t((a.first + b.first) % p.first, (a.second + b.second) % p.second);
    		}
    		hash_t operator - (const hash_t &a, const hash_t &b)
    		{
    			return hash_t((a.first - b.first + p.first) % p.first, 
    				(a.second - b.second + p.second) % p.second);
    		}
    		hash_t operator * (const hash_t &a, const hash_t &b)
    		{
    			return hash_t(int((ll)a.first * b.first % p.first), 
    				int((ll)a.second * b.second % p.second));
    		}
    		void init()
    		{
    			pow[0] = make_pair(1, 1);
    			for (int i = 1; i < N; i++)
    				pow[i] = pow[i - 1] * seed;
    		}
    		inline int ctoi(const char c)
    		{
    			return c - 'a';
    		}
    		void get(const char *const s)
    		{
    			h[0] = make_pair(ctoi(s[0]), ctoi(s[0]));
    			for (int i = 1; i < n; i++)
    				h[i] = h[i - 1] * seed + make_pair(ctoi(s[i]), ctoi(s[i]));
    		}
    		hash_t extract(const int l, const int r)
    		{
    			return l ? (h[r] - h[l - 1] * pow[r - l + 1]) : h[r];
    		}
    	}
    	using namespace Hash;
    	void mk_f()
    	{
    		f[n >> 1] = 0;
    		for (int i = (n >> 1) - 1; i >= 0; i--)
    		{
    			f[i] = min(f[i + 1] + 2, (n >> 1) - i);
    			while (f[i] && extract(i, i + f[i] - 1) != extract(n - i - f[i], n - i - 1))
    				--f[i];
    		}
    	}
    	int work()
    	{
    		read(n), read(str);
    		init();
    		get(str);
    		mk_f();
    		int ans = 0;
    		for (int i = 1; i <= (n >> 1); i++)
    			if (extract(0, i - 1) == extract(n - i, n - 1))
    				ans = max(ans, i + f[i]);
    		write(ans);
    		return 0;
    	}
    }
    int main()
    {
    	return zyt::work();
    }
    
  • 相关阅读:
    poj3268(Silver Cow Party)最短路
    关于Phaser
    关于StampedLock
    关于AQS
    关于Exechanger
    关于Semaphore
    关于CyclicBarrier
    关于CountDownLatch
    关于BlockingQueue
    关于ThreandLocal
  • 原文地址:https://www.cnblogs.com/zyt1253679098/p/10479425.html
Copyright © 2020-2023  润新知