浅滩混洗是一种混洗，将甲板分为两个分区，然后将这些分区拼接在一起以创建新的混洗甲板。

卡以这样的方式拼接在一起：卡在它们所属的分区中保持其相对顺序。例如，如果卡片A在卡组中的卡片B之前，并且卡片A和B在同一分区中，则在最终结果中，卡片A必须在卡片B之前，即使它们之间的卡片数量增加了。如果A和B在不同的分区中，则它们在最终结果中可以采用任何顺序，而不管它们的开始顺序如何。

然后，可以将每个浅滩混洗视为原始纸牌的排列。例如排列

1,2,3 -> 1,3,2

是浅滩洗牌。如果你像这样分割甲板

1, 2 | 3

我们看到其中的每张卡1,3,2与其分区中的每张其他卡具有相同的相对顺序。 2仍在1。

另一方面，以下排列不是浅滩混洗。

1,2,3 -> 3,2,1

我们可以看到这一点，因为对于所有两个（非平凡的）分区

1, 2 | 3
1 | 2, 3 

有一对卡不保持其相对顺序。在第一个分区1，并2改变他们的排序，而在第二个分区2，并3改变它们的顺序。

但是我们确实看到3, 2, 1可以通过组合两个浅滩混洗来实现，

1, 3, 2 + 2, 3, 1 = 3, 2, 1

实际上，要证明的一个非常简单的事实是，通过结合一定数量的浅滩混洗排列，可以进行任何排列。

任务

您的任务是制作一个程序或函数，将一个排列（大小为N）作为输入，并输出最少数量的浅滩混洗排列（大小为N），可以组合形成输入排列。您无需输出浅滩混音本身，就可以输出多少。

这是代码高尔夫球，因此答案将以字节计分，而字节越少越好。

您可以输出1或0进行身份置换。

测试用例

1,3,2 -> 1
3,2,1 -> 2
3,1,2,4 -> 1
2,3,4,1 -> 1
4,3,2,1 -> 2

Python 3，255个字节

检查所有可能的浅滩直到列表的长度（所需的最大数量），因此对于较大的输入来说非常慢。也可能打了很多高尔夫球。

lambda x:f(range(1,len(x)+1),x)
f=lambda x,y,i=0:x==y and i or i<len(x)and min(f(q,y,i+1)for a in range(1,len(x))for q in g(x[:a],x[a:]))or i
g=lambda x,y:(x or y)and[[v]+q for v in x[:1]for q in g(x[1:],y)]+[[v]+q for v in y[:1]for q in g(x,y[1:])]or[[]]

在线尝试！

干净，206个 ... 185个字节

import StdEnv
f=flatten
$a b#[c:d]=b
|a>[]#[u:v]=a
=[a++b,b++a:f[[[u,c:e],[c,u:e]]\\e<- $v d]]=[b]
@l#i=length l
=hd[n\\n<-[0..],e<-iter n(f o map(uncurry$o splitAt(i/2)))[[1..i]]|l==e]

在线尝试！

生成混洗n时间的所有可能结果，并检查列表是否为成员。
尽管这是解决问题的极其低效的方法，但是由于使用列表推导而不是合成，因此该代码特别慢，这严重限制了任何基本图的缩减，并带来了Clean垃圾收集器的精彩展示。

取消高尔夫：

import StdEnv
shuffle [] l
    = [l]
shuffle [a: b] [c: d]
    = [[a: b]++[c: d], [c: d]++[a: b]: flatten [
        [[a, c: e], [c, a: e]]
        \\ e <- shuffle b d
        ]]
numReq l
    = until cond ((+)1) 0
where
    cond n 
        = let
            mapper
                = map (uncurry shuffle o splitAt (length l/2))
            options
                = iter n (removeDup o flatten o mapper) [[1..length l]]
        in isMember l options

在线尝试！