Arithmetic problem | 判定字符串是否为攀爬字符串

题目如下：

给定一个字符串 S1，将其递归地分割成两个非空子字符串,从而将其表示为二叉树。

下面是s1 = "great"的一个可能表达：

    great
   /    \
  gr    eat
 / \    /  \
g   r  e   at
           / \
          a   t

在攀爬字符串的过程中，我们可以选择其中任意一个非叶节点，然后交换该节点的两个儿子。

例如，我们选择了 "gr" 节点，并将该节点的两个儿子进行交换，从而产生了攀爬字符串 "rgeat"。

    rgeat
   /    \
  rg    eat
 / \    /  \
r   g  e   at
           / \
          a   t

我们认为， "rgeat" 是 "great" 的一个攀爬字符串.

类似地，如果我们继续将其节点 "eat" 和 "at" 进行交换，就会产生新的攀爬字符串 "rgtae"。

    rgtae
   /    \
  rg    tae
 / \    /  \
r   g  ta  e
       / \
      t   a

同样地，"rgtae" 也是 "great"的一个攀爬字符串。

给定两个相同长度的字符串s1 和 s2，判定 s2 是否为 s1的攀爬字符串。

解题思路：

这题目的重点在于不同位置之间的字符对比，要是尝试还原字符串或者一一罗列可能出现的字符位置显然是不明智的行为。主要是由于递归后的原二叉树的非子叶节点的独立性导致的。因此，本思路把字符串拆成阶梯状，每个阶梯的位置是由剩下阶梯除以2得来，如图：

这样，阶梯在不停汇合的同时，也会与下一个阶梯产生位置的攀爬（可调转位置）。也就保留了攀爬之间的独立性，并且因为可攀爬，因此下一个阶梯的位置定会出现在汇合成的阶梯左方或右方，并且扫描遍历的长度也是不超过阶梯的长度。或许有人说这难办，因为越往后的阶梯越宽，也就越无法保证是否攀爬。这其实不然，阶梯是独立的，那么阶梯也是可以拆成若干的阶梯，如此一来，最小粒度其实是每一个字符阶梯，如图：

然而，最后汇合成功的字符串也就是攀爬字符串了。

解构体定义如下：

typedef struct LR
{
	int left, right;
} LR;

思路实现代码如下：

LR Method_T(char *str, int len, char *s_str, int s_len, LR t_step = { 0,0 })
{
	int step = 0, range = 0, r_step = 0;
	stack<LR>s_range;
	LR cache = { -1,-1 }, o_cache = cache;
	if (len == 1)
	{
		r_step = t_step.left - len;
		range = r_step>0 ? r_step : 0;
		while (t_step.left-->range) {
			if (*str == s_str[t_step.left]) {
				cache.left = cache.right = t_step.left;
				return cache;
			}
		}
		r_step = t_step.right + len;
		range = t_step.right != -1 && r_step<s_len ? r_step : s_len;
		while (t_step.right++<range) {
			if (*str == s_str[t_step.right]) {
				cache.left = cache.right = t_step.right;
				return cache;
			}
		}return cache;
	}
	while (len) {
		step = len / 2;
		cache.left = step, cache.right = len - step;
		s_range.push(cache), len = step;
	}
	while (!s_range.empty()) {
		cache = s_range.top(), s_range.pop();
		cache = Method_T(str + cache.left, cache.right, s_str, s_len, o_cache);
		if (cache.left == -1)return cache;
		if (o_cache.left == -1) {
			o_cache = cache; continue;
		}
		if (o_cache.left - 1 == cache.right)
			o_cache.left = cache.left;
		else if (o_cache.right + 1 == cache.left)
			o_cache.right = cache.right;
		else {
			cache.left = cache.right = -1;
			return cache;
		}
	}return o_cache;
}

int Method(char *str, int len, char *s_str, int s_len)
{
	if (len != s_len)return 0;
	LR l = Method_T(str, len, s_str, s_len);
	if (l.left + l.right == s_len - 1)
		return 1;
	return 0;
}