c++ - 有没有办法在数学上解决 UVA 417？

Question

我正在尝试解决 UVA 417 ，但我无法这样做。我见过的所有解决方案首先生成所有可能的值，将它们存储在映射中，然后搜索以找到所需的字符串。这对我来说似乎很不优雅。没有办法从数学上解决这个问题吗？

考虑输入“abc”。
如果不强加每个后续字符都应该大于当前字符的条件，我们可以通过简单地计算 1*26^2 +2*26^1 + 3*26^0 来解决它。没有办法以类似的方式解决原始问题吗？

我包含了我在网上找到的现有解决方案的代码:

#include <iostream>
#include <string>
#include <map>
#include <queue>

using namespace std;

map<string, int> M;

void generate_positions(){
    queue<string> Q;
    for(char c='a';c<='z';c++) Q.push(string(1,c));

    string s;

    int cont=1;

    while(!Q.empty()){
        s=Q.front();
        Q.pop();

        M[s]=cont;
        cont++;

        if(s.size()==5) continue;

        for(char c=s[s.size()-1]+1;c<='z';c++) Q.push(s+c);
    }
}

int main(){
    generate_positions();

    string s;
    map<string, int> :: iterator it;

    while(cin>>s){
        it=M.find(s);
        if(it==M.end()) cout<<0<<endl;
        else cout<<it->second<<endl;
    }

    return 0;
}

Answer 1

1. TL/DR:

让我们定义一个字母表 A = {a, b, c, ... z} 及其双射字母表 A' = {1, 2, 3, ... 26} . |A| = |A'| = 26 .

然后让 w 表示由字符组成的词 w0, w1, ... w|w|–1 ∈ A' ，按以下顺序:

w = w|w|–1 ... w1w0 ，其中 |w| 表示以字符为单位的字长。

现在，functional P(w): (A')|A'| → ℕ 转换单词 w, |w| ≤ |A'| ，其位置如下:



音译周至 A' 来自 一个 取决于用户。

2. 实现:

#include <stdio.h>
#include <math.h>

long bin26(long n, long k) {
    static const char nprm[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
    long root = (long)sqrt(n), coef[sizeof(nprm) / sizeof(*nprm)] = {0};
    long indx, iter, prod, curr, prev, ncur, kcur;

    if ((n <= 0) || ((k = (k > n / 2)? n - k : k) <= 0))
        return (n > 0) && (k >= 0);
    for (indx = iter = 0; (curr = (long)nprm[iter++]) <= n; )
        if (curr > n - k)
            coef[indx++] = curr;
        else if (curr <= n / 2) {
            if (curr > root) {
                if ((n % curr) < (k % curr))
                    coef[indx++] = curr;
                continue;
            }
            for (ncur = n, kcur = k, prod = 1, prev = 0; ncur > 0; ) {
                if ((prev = ((ncur % curr) < (kcur % curr + prev))? 1 : 0))
                    prod *= curr;
                ncur /= curr;
                kcur /= curr;
            }
            if (prod > 1)
                coef[indx++] = prod;
        }
    for (iter = 1; indx; iter *= coef[--indx]);
    return iter;
}

int main(int argc, char *argv[]) {
    const long size = 26;
    long retn, lstr, iter;

    for (--argc; argc > 0; argc--) {
        for (iter = lstr = 0; argv[argc][lstr]; iter = argv[argc][lstr++])
            if (iter >= argv[argc][lstr]) {
                lstr = 0;
                break;
            }
        for (--lstr, iter = retn = 0; iter <= lstr; iter++)
            retn += bin26(size, iter + 1)
                 -  bin26(size - argv[argc][lstr - iter] + 'a' - 1, iter + 1);
        printf("P(%s) = %ld\n", argv[argc], retn);
    }
    return 0;
}

3. 说明:

在不失一般性的情况下，让我们首先将字母大小和单词长度限制为较小的值，并尝试将问题可视化。

让 |A'| = 6, |w| = 3 .完整的单词列表如下所示:

 k n                        [ |  ]  be  →  14            [ | ] acf  →  28
[1|1]   a  →   1            [ |  ]  bf  →  15            [ | ] ade  →  29
[ |1]   b  →   2            [ | 3]  cd  →  16            [ | ] adf  →  30
[ |1]   c  →   3            [ |  ]  ce  →  17            [ | ] aef  →  31
[ |1]   d  →   4            [ |  ]  cf  →  18            [ |6] bcd  →  32
[ |1]   e  →   5            [ | 2]  de  →  19            [ | ] bce  →  33
[ |1]   f  →   6            [ |  ]  df  →  20            [ | ] bcf  →  34
[2|5]  ab  →   7            [ | 1]  ef  →  21            [ | ] bde  →  35
[ | ]  ac  →   8            [3|10] abc  →  22            [ | ] bdf  →  36
[ | ]  ad  →   9            [ |  ] abd  →  23            [ | ] bef  →  37
[ | ]  ae  →  10            [ |  ] abe  →  24            [ |3] cde  →  38
[ | ]  af  →  11            [ |  ] abf  →  25            [ | ] cdf  →  39
[ |4]  bc  →  12            [ |  ] acd  →  26            [ | ] cef  →  40
[ | ]  bd  →  13            [ |  ] ace  →  27            [ |1] def  →  41

括号中左边的数字(我们称之为 k )显示了相应单词中有多少个字母以及它下面的字母。正确的数字 ( n ) 依次显示第一个字母保持不变的连续单词数。

很明显，当 k 变化，随后的法律也随之变化 -s 跟随。很容易辨别模式:when k 等于一些 K ，其对应的 -s 只不过是连续缩短对应于 的单词堆栈的“尾部”。 K–1 ，以新字母开头。 «tail» 在下一次迭代中缩短的量 t+1 ，与当前相比， 电话 (在 K 内的两次迭代)，等于最大的 在从 离开这里的剩余“尾部”中K–1 -th 堆栈。

让我们称之为 的高度k -th 堆栈 香港 .我们也打个电话 电话 -th 连续，属于 k -th 堆栈， 安凯特 (自然， t 编号是每个 k 的局部编号；例如 n32 通常与 |1095|719 45|209 不同)。最重要的是，让我们做 电话 -s 倒退(无论如何它是一个堆栈)，所以在上面的例子中 n34 = 10 , n33 = 6 , n32 = 3 , n31 = 1 .

根据之前的观察和约定，



从这里可以明显看出 Hk–1 = nk|nk|+1 (暂时忘记 {nk} 实际上不包含 |nk|+1 -th 元素)。这就直接引出了 的定义Hk(n) 来自 [2] :



继续证明 之间的联系Hk(n) 和 binomial coefficients在 中说明[3] .

首先，基本身份(又名 Pascal`s Rule):



从帕斯卡法则可以推导出以下内容:



细心的读者可能已经注意到:



很好，涵盖了 H0(n) 和 H1(n) .让我们用归纳法证明其余的。



与 [3] 证明，唯一剩下的推导 [4] 是介绍 P(w) 并用 表示H -s。

对于某个词 w , 获取其位置 P(w) 在单词列表中意味着找到与 超相邻的单词堆栈的高度w .

寻找 P1(w) ， 的第一个近似值P(w) , 涉及将所有 的子堆栈的高度加在一起1 ≤ k ≤ |w| :

 ...
|w–2|
---------
|w–1|
|w–1|
|w–1|
|w–1|
|w–1|
|w–1|
---------
| w |
| w |<--- P(w)
| w |
| w |
| w |
-----<--- P₁(w)
|w+1|
 ...

根据 [5] ,



为什么不 1 ≤ k < |w| ?仅仅因为已经有一种计算堆栈“尾部”高度的方法，但是还没有为“头部”设计任何类型的方法。因此，要细化近似值 高|w| 堆栈应在 的位置一分为二w ，其新发现的“尾部”的高度将从近似值中减去。

好的，让我们从堆栈底部开始向上。每当 w 等于 中的最后一个字高|w| 堆栈， P1(w) 根本不需要调整，因此等于 P(w) .

占据讨论位置的单词由以下字符组成: W|w|–1W|w|–2…W1W0 ，其中 Wi = A'|A'|–i — 例如 (22)(23)(24)(25)(26) 为 H5 叠在原来的上面 A' (或简单地 vwxyz 当音译为 A 时)。这里要考虑的主要事情是对于所有 |w| 在 高|w| , W0 总是等于字母表的最后一个字母， W1 等于倒数第二个，以此类推。

好。现在，如果目标词是 中的倒数第二个，会发生什么变化高|w| ?很简单， P1(w) 由 调整–1 .倒数第三个字需要调整 –2 ，依此类推，直到 W0 用完允许的字母，即小于或等于 W1 (或到 1 如果没有 W1 )。让我们称这个调整值 P2(w):P(w) = P1(w) – P2(w) .对于 |w| = 1 ，方程可以改写如下: P(w) = P1(w) - (|A'| - w0) .

W0 不同于 A'|A'| 已被覆盖。怎么样 W1 和别的？减去之前 W0 让我们首先假设它等于 A'|A'| .在这种情况下，很明显调整 P1(w) 为 W1 相当于减去 对应的“尾部” H2 堆栈，即 |w| = 2 , P(w) = P1(w) - ((|A'| - w0) + H2((|A'| - 1) - w1)) .被减数 (|A'| - 1) 用于代替 |A'| 因为，如前所述，最大可能值 W1 等于 A'|A'|–1 = |A'| – 1 .同样的规则适用于 W2 ( H3 堆栈, H3((|A'| – 2) – w2) ) 和所有其他字符通过归纳。

考虑到 (|A'| - w0) = H1(|A'| - w0) ,



其中，考虑到 P(w) = P1(w) - P2(w) ，加上 [6] ，最后导致 [4] .