arrays - 查找给定数组排列的（字典）索引。

Question

给定一个数组说“bca”，我需要找到字典序上大于给定排列的排列数。

因此，在本例中，cab、cba 是更大的排列。因此答案是 2。

我尝试通过查找数组的字典排序来解决这个问题，但我无法为这个说法设计一个有效的算法。

任何朝着正确方向的帮助/指针表示赞赏！

Answer 1

让我们看一下排列dacb。这在 4 中按字典顺序排列在哪里！= 的 24 个排列abcd？

• 考虑第一个字母d。在剩余的字母 ( acb) 中有三个小于d, 和 3! = 6 个排列，从每个排列开始，总共 18 个排列。
• 考虑前两个字母da。在剩余的字母 ( cb) 中，没有小于小于的字母a（如果有的话，将有 2！= 2 个排列，d每个排列都以加号开头），总共有 0 个排列。
• 考虑前三个字母dac。在剩余的字母 ( b) 中，有一个小于c, 和 1! = 1 个以 开头的排列dab，总共 1 个排列。

所以总共有 19 个排列小于dacb。让我们检查一下。

>>> from itertools import permutations
>>> list(enumerate(''.join(p) for p in permutations('abcd')))
[(0, 'abcd'), (1, 'abdc'), (2, 'acbd'), (3, 'acdb'),
 (4, 'adbc'), (5, 'adcb'), (6, 'bacd'), (7, 'badc'),
 (8, 'bcad'), (9, 'bcda'), (10, 'bdac'), (11, 'bdca'),
 (12, 'cabd'), (13, 'cadb'), (14, 'cbad'), (15, 'cbda'),
 (16, 'cdab'), (17, 'cdba'), (18, 'dabc'), (19, 'dacb'),
 (20, 'dbac'), (21, 'dbca'), (22, 'dcab'), (23, 'dcba')]

看起来不错。所以有4个！− 19 − 1 = 4 个大于 的排列dacb。

现在应该清楚如何概括该方法来制作算法了。这是 Python 中的一个实现：

from math import factorial

def lexicographic_index(p):
    """
    Return the lexicographic index of the permutation `p` among all
    permutations of its elements. `p` must be a sequence and all elements
    of `p` must be distinct.

    >>> lexicographic_index('dacb')
    19
    >>> from itertools import permutations
    >>> all(lexicographic_index(p) == i
    ...     for i, p in enumerate(permutations('abcde')))
    True
    """
    result = 0
    for j in range(len(p)):
        k = sum(1 for i in p[j + 1:] if i < p[j])
        result += k * factorial(len(p) - j - 1)
    return result

def lexicographic_followers(p):
    """
    Return the number of permutations of `p` that are greater than `p`
    in lexicographic order. `p` must be a sequence and all elements
    of `p` must be distinct.
    """
    return factorial(len(p)) - lexicographic_index(p) - 1

Answer 2

有一种基于阶乘数字系统和 Lehmer 代码的非常简洁的方法。这个想法是为每个可能的排列分配一个数字代码，该排列编码值出现的顺序（Lehmer 代码）。然后，您可以将 Lehmer 代码转换为一个数字，该数字确定所有排列列表中排列的索引（这使用阶乘数字系统）。给定排列的索引，然后您可以计算 (n! - 1) 并减去索引以确定还有多少排列。

如果你很好奇如何做到这一点，我有这个算法的实现，它可以让你从排列映射到索引，反之亦然。我还谈到了如何做到这一点；详情在幻灯片的后半部分。

希望这可以帮助！

Answer 3

这是回溯解决方案：

该程序排列给定字符串的所有解决方案，并返回解决方案列表以及这里有多少。

例如：因为acb它返回：

c a b
c b a
b a c
b c a
4

代码：

#include <iostream>
#include <stdio>

using namespace std;

int v[100], n, cnt;
char *str;

void init(int k)
{
    v[k] = -1;
}

bool solutionReached( int k ) 
{
    if (k == n + 1)
        return true;
    return false;
}

void printSolution( int k ) 
{
    for (int i = 1; i < k; i++)
    {
        printf("%c ", str[v[i]]);
    }

    printf("\n");

    cnt++;
}

bool hasSuccesor( int k ) 
{
    if(v[k] < n - 1)
    {
        v[k]++;
        return true;
    }
    return false;
}

bool isValid( int k ) 
{
    for (int i = 1; i < k; i++)
    {
        if (v[i] == v[k])
        {
            return false;
        }
    }

    if (k == n)
    {
        char *cuv = (char *) malloc(n * sizeof(char));

        for (i = 0; i < n; i++)
            cuv[i] = str[v[i + 1]];

        if (strcmp(cuv, str) > 0)
        {
            return true;
        }
        else
            return false;
    }

    return true;
}

void bkt(int k)
{
    if(solutionReached(k))
        printSolution(k);
    else
    {
        init(k);
        while(hasSuccesor(k))
            if(isValid(k))
                bkt(k + 1);
    }
}

int main(int argc, char* argv[])
{
    str = "bca";

    n = strlen(str);
    bkt(1);

    printf("%i \n", --cnt);

    return 0;
}

Answer 4

直接的 Python 解决方案依赖于 Python 排列生成器将从初始排序字符串按字典顺序生成的事实。

In [68]: from itertools import permutations

In [69]: from math import factorial

In [70]: def lexigreaterperms(perm):
    ...:     return factorial(len(perm)) - 1 -  list(permutations(sorted(perm))).index(tuple(perm))

In [71]: lexigreaterperms('bca')
Out[71]: 2

In [72]: lexigreaterperms('dacb')
Out[72]: 4