解法
首先,假设所有的字符串都不会反转,注意到在连接的时候string的顺序是不会变的。
假设可以表示为
s
1
,
s
2
,
.
.
.
,
s
j
,
.
.
.
,
s
n
s_1,s_2,...,s_j,...,s_n
s1,s2,...,sj,...,sn
如果分割点在
s
j
s_j
sj的某处,把它分成了
s
j
p
r
e
s_{jpre}
sjpre和
s
j
p
o
s
t
s_{jpost}
sjpost,那么最后得到和字符串就是,
s
j
p
o
s
t
,
s
j
+
1
,
.
.
.
,
s
n
,
s
1
,
.
.
.
,
s
j
−
1
,
s
j
p
r
e
s_{jpost}, s_{j+1},...,s_n,s_1,...,s_{j-1},s_{jpre}
sjpost,sj+1,...,sn,s1,...,sj−1,sjpre
现在我们来考虑可以反转的情况。
注意到,只要我们决定分割
s
j
s_j
sj,不管分割位置在哪儿,中间那部分都是不会变的,所以我们可以直接排除掉一堆非最优结果,得到:
s
j
p
o
s
t
,
max
(
s
j
+
1
,
s
j
+
1
R
)
,
.
.
.
,
max
(
s
n
,
s
n
R
)
,
max
(
s
1
,
s
1
R
)
,
.
.
.
,
max
(
s
j
−
1
,
s
j
−
11
R
)
,
s
j
p
r
e
s_{jpost}, \max(s_{j+1},s_{j+1}^R),...,\max(s_{n},s_{n}^R),\max(s_1,s_1^R),...,\max(s_{j-1},s_{j-11}^R),s_{jpre}
sjpost,max(sj+1,sj+1R),...,max(sn,snR),max(s1,s1R),...,max(sj−1,sj−11R),sjpre,其中
s
i
R
s^R_i
siR表示第i个字符串的翻转。
所以最后的算法是:首先每个字符串保存它和它的翻转里较大的那个版本,然后枚举每个字符串的每个分割位置,同时也要模拟每个字符串的翻转和不翻转的两种情况,得到合成的字符串,最后返回最大的那个。
class Solution(object):
def splitLoopedString(self, strs):
"""
:type strs: List[str]
:rtype: str
"""
strs = map(lambda x:max(x,x[::-1]),strs)
ans = ""
for i,s in enumerate(strs):
l = len(s)
for j in xrange(l+1):
pre = s[:j]
post = s[j:]
mid = "".join(strs[i+1:])+"".join(strs[:i])
ans = max(ans, post+mid+pre,
pre[::-1]+mid+post[::-1])
return ans
每次都合成新的中间字符串效率低,预处理一下之后效率会提高一些:
class Solution(object):
def splitLoopedString(self, strs):
"""
:type strs: List[str]
:rtype: str
"""
total = ""
lens = [0]
for s in strs:
lens.append(len(s)+lens[-1])
total += max(s,s[::-1])
ans = ""
for i,e in enumerate(lens[1:]):
s = lens[i]
for j in xrange(s,e+1):
pre = total[s:j]
post = total[j:e]
mid = total[e:]+total[:s]
ans = max(post+mid+pre, pre[::-1]+mid+post[::-1], ans)
return ans