1。 TL / DR：

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 ... 26} 。 | A | = \ | A'| = 26。

然后让 w 表示由字符 w ₀，w ₁，……w _{| w |组成的单词。 –1}∈A'，顺序如下：

w = w _{| w | –1}……w ₁ w ₀ ，其中 | w | 表示字符长度。

现在，functional P（w）：（A'）^{| A'|}→→可以转换单词 w，|。 w | ≤| A'| ，其位置如下：

$\\\begin{aligned}&H_0(n)=1&\quad[1]\\&H_k(n)=\sum\limits_{i\,=\,1}^{n}H_{k-1}(i)\quad\forall{k}\in\mathbb{N}&\quad[2]\\&\binom{n}{k}=H_k(n-(k-1))\quad\forall{n,k}\in\mathbb{N}\cup\{0\},\;k\leq{n}&\quad[3]\\&\begin{aligned}P(w)&=\sum\limits_{k\,=\,0}^{|w|-1}[H_{k+1}(|A'|-k)-H_{k+1}(|A'|-w_k-k)]=\\&=\sum\limits_{k\,=\,0}^{|w|-1}\left[\binom{|A'|}{k+1}-\binom{|A'|-w_k}{k+1}\right]\end{aligned}&\quad[4]\end{aligned}$
将 w _k 从 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 更改时，随后的 n -s遵循的定律也随之变化。识别模式非常容易：当 k 等于某个 K 时，其对应的 n -s只是连续地缩短了“ tails”对应于 K–1 的单词堆栈，前面带有一个新字母。与当前的 t （两次迭代均在 K t + 1 缩短“ tail”的量>），等于从第 K–1 个堆栈中剩余的剩余“ tail”中最大的 n 。

让我们调用第 k 个堆栈的高度 H _k 。让我们也连续调用 t 个 n ，属于第 k 个堆栈， n _{k ^t}（自然， t 编号是每个 k 的本地编号；例如， n _{3 ²}通常与 n ₁ ² 不同）。最重要的是，我们使 t -向后移动（无论如何都是堆栈），因此在上面的示例中， n ₃ ⁴ = 10 ， n ₃ ³ = 6 ， n ₃ ² = 3 ， n ₃ ¹ == 1 。

根据以前的观察和约定，

$\\\begin{aligned}&H_k&=&\quad\sum\limits_{t\,=\,1}^{|n_k|}n_k^t\quad\forall{k}\in\overline{1,\,|A'|}\\&n_k^t&=&\quad\sum\limits_{i\,=\,1}^{t}n_{k-1}^i\quad\forall{t}\in\overline{1,\,|n_{k-1}|-1}\\&n_0^1&=&\quad\,1\\&n_0^{t+1}&=&\quad\,0\quad\forall{t}\in\overline{1,\,|A'|}\end{aligned}$

从这里可以明显看出 H _k–1 = n _k ^{| n _k | +1} （暂时忘记 {n _k} 实际上不包含 | n _k | +1 个元素）。这直接导致 [2] 中的 H _k（n）的定义：

$\\\sum\limits_{t\,=\,1}^{|n_k|}n_k^t=H_k(|n_k|)=H_k(|A'|-(k-1))\quad\forall{k}\in\mathbb{N}\qquad[5]$

继续 [3] 中所述的 H _k（n）与binomial coefficients之间的联系的证明。
首先，基本身份（也称为Pascal`s Rule）：

$\\\binom{n}{k}={{n!}\over{k!(n-k)!}},\quad\forall{n,k}\in\mathbb{N}\cup\{0\},\;k\leq{n}\\\\\binom{n}{k}\stackrel{?}{=}\binom{n-1}{k}+\binom{n-1}{k-1}\\\\{{n!}\over{k!(n-k)!}}={{(n-1)!}\over{k!(n-k-1)!}}+{{(n-1)!}\over{(k-1)!(n-k)!}}\\\\{{n!}\over{k!(n-k)!}}={{n-k}\over{n}}\cdot{{n!}\over{k!(n-k)!}}+{{k}\over{n}}\cdot{{n!}\over{k!(n-k)!}}\qquad\left|\;:{{n!}\over{k!(n-k)!}}\right\\\\1={{n-k}\over{n}}+{{k}\over{n}}={{n}\over{n}}=1\qquad\square$

从帕斯卡定律中可以得出以下结论：

$\\\begin{aligned}\binom{n}{k}&=\binom{n-1}{k-1}+\binom{n-2}{k-1}+\;\cdots\;+\binom{k}{k-1}+\binom{k}{k}=\\&=\binom{n-1}{k-1}+\binom{n-2}{k-1}+\;\cdots\;+\binom{k}{k-1}+\binom{k-1}{k-1}\quad\Rightarrow\\\end{aligned}\\\\\\\binom{n}{k}=\sum\limits_{i\,=\,1}^{n-(k-1)}\binom{n-i}{k-1}=\sum\limits_{i\,=\,k}^{n}\binom{i-1}{k-1}$

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

$\\\binom{n}{1}=\sum\limits_{i\,=\,1}^{n}\binom{i-1}{0}=\;n\;=\sum\limits_{i\,=\,1}^{n}H_0(i)=H_1(n)$

精细，涵盖 H ₀（n）和 H ₁（n）。让我们通过归纳证明其余部分。

$\\\begin{aligned}&\binom{n}{2}=\sum\limits_{i\,=\,2}^{n}\binom{i-1}{1}=\sum\limits_{i\,=\,1}^{n-1}\binom{i+0}{1}=\sum\limits_{i\,=\,1}^{n-1}H_1(i)=H_2(n-1)\\&\binom{n}{3}=\sum\limits_{i\,=\,3}^{n}\binom{i-1}{2}=\sum\limits_{i\,=\,1}^{n-2}\binom{i+1}{2}=\sum\limits_{i\,=\,1}^{n-2}H_2(i)=H_3(n-2)\\&\binom{n}{4}=\sum\limits_{i\,=\,4}^{n}\binom{i-1}{3}=\sum\limits_{i\,=\,1}^{n-3}\binom{i+2}{3}=\sum\limits_{i\,=\,1}^{n-3}H_3(i)=H_4(n-3)\\&\vdots&\vdots\end{aligned}\\\binom{n}{k}=\sum\limits_{i\,=\,1}^{n-(k-1)}\binom{i+k-2}{k-1}=\sum\limits_{i\,=\,1}^{n-(k-1)}H_{k-1}(i)=H_k(n-(k-1))\qquad\square$

在证明 [3] 的情况下，唯一导出 [4] 的方法就是引入 P（w）并将其表达为 H -s的条款。

对于某个特定单词 w ，获得其在单词列表中的位置 P（w）意味着找到与 w 。
查找 P ₁（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] ，

$\\P_1(w)=\sum\limits_{k\,=\,1}^{|w|}H_k(|A'|-(k-1))=\sum\limits_{k\,=\,0}^{|w|-1}H_{k+1}(|A'|-k)\qquad[6]$

为什么 1≤k <| w | ？仅仅因为已经有一种计算堆栈“尾部”高度的方法，但是对于“头部”并没有设计出任何类似的方法。因此，为了细化近似值，应在 w 的位置将 H _{| w |} 堆栈一分为二，并求出新堆栈的高度。 «tail»将从近似值中减去。

好吧，让我们从堆栈底部开始向上爬。每当 w 等于 H _{| w |} 堆栈中的最后一个单词时， P ₁（w）完全不需要调整，因此等于 P（w）。

正在讨论的地方所用的单词由以下字符组成： W _{| w | –1} W _{| w | –2}…W ₁ W ₀ ，其中 W _i = A'_{| A'| –i} -例如（22）（23）（24）（25）（26），用于 H ₅ 堆叠在原始 A'（或音译为 A 时简称 vwxyz ）。这里主要要考虑的是，对于 H _{| w |} 中的所有 | w | ， W ₀ 始终等于字母的最后一个字母， W ₁ 等于倒数第二个，等等。

好吧。现在，如果目标单词在 H _{| w |} 中倒数第二个，该怎么办？普通来说， P ₁（w）会被调整为 –1 。倒数第二个单词需要用 –2 进行调整，依此类推，直到 W ₀ 用完允许的字母，即减少或等于 W ₁ （如果没有 W ₁ ，则等于 1 ）。让我们称此调整值为 P ₂（w）：P（w）= P ₁（w）–P ₂ （w）。对于 | w | = ，等式可以重写如下： P（w）= P ₁（w）–（（A）| –w ₀）。
与 A'_{| A'|} 不同的
W ₀ 已被覆盖。 W ₁ 和其他呢？在从 W ₀ 减去之前，我们首先假定它等于 A'_{| A'|} 。在这种情况下，显然为 W ₁ 调整 P ₁（w）等同于减去相应的 H ₂ 堆栈的“尾部”，即 | w | = 2 ， P（w）= P ₁（w）-（（| A'| –w ₀）+ H ₂（（（| A'| –1）–w ₁））。使用minuend （| A'| –1）代替 | A'| ，因为如前所述， W _{的最大可能值1} 等于 A'_{| A'| –1} == | A'| – 1 。相同的规则适用于 W ₂ （ H ₃ 堆栈， H ₃（（|| A'| –2）–w ₂））和所有其他归纳字符。

考虑到（| A'| –w ₀）= H ₁（| A'| –w _{0 ）}，

$\\P_2(w)=\sum\limits_{k\,=\,1}^{|w|}H_k(|A'|-(k-1)-w_{k-1})=\sum\limits_{k\,=\,0}^{|w|-1}H_{k+1}(|A'|-w_k-k)$

其中，考虑到 P（w）= P ₁（w）–P ₂（w），再加上 [6] ，最后引出 [4] 。

Answer 2

由于需要“一种数学上解决问题的方法”，因此我提供了一个伪算法。

正如已经提到的，我们不能对输入“ abc”使用“ 1 * 26 ^ 2 + 2 * 26 ^ 1 + 3 * 26 ^ 0”之类的内容。但是，这将是起点。

从该数字中我们将减去不允许的组合数（例如“ ba”），请注意不要相减两次（“ ba”和“ bba”计数为1）。

整个想法是，我们可以“轻松地”计算出多少个字母序列无效，而不是多少个字母序列有效。计算是逐个位置进行的（字母一个字母）。

有没有一种数学上解决UVA 417的方法？

2 个答案:

1。 TL / DR：

2。实施：

3。说明：