ミフの答えは間違いなくエレガントです。とにかく私のものをほぼ完成させたので、それを提供します。良いことは、n = 500でも同じ結果が得られることです:-)
許可されている異なる文字の数をdとすると、d = 4になります。
文字列の長さをnとすると、最終的にはnの偶数の値が表示されます。
文字列内のペアになっていない文字の数をuとします。
N（n、d、u）を長さnの文字列の数とし、d個の異なる文字から構築され、u個のペアになっていない文字を持ちます。Nを計算してみましょう。
観察すべきかなりのコーナーケースがあります：
u> dまたはu> n => N = 0
u <0 => N = 0
n％2！= u％2 => N = 0。
nからn + 1にステップするとき、uは1ずつ増加するか、1ずつ減少する必要があるため、次のように再帰します。
N（n、d、u）= f（N（n-1、d、u-1）、N（n-1、d、u + 1））
uを1つ減らす方法はいくつありますか。これは、uのペアになっていない文字の1つをペアにする必要があるため、簡単です。したがって、fの2番目の部分は（u + 1）* N（n-1、d、u + 1）になります。もちろん、u + 1> n-1またはuの場合はN = 0であることに注意する必要があります。 +1> d。
これを理解したら、fの最初の部分が何であるかを簡単に確認できます。u-1個のペアになっていない文字がある場合に、いくつの方法でuを増やすことができますか。さて、ペアになっている（k-（u-1））文字の1つを選択する必要があります。
したがって、すべてのコーナーケースを考慮すると、Nの再帰的な式は次のようになります。
N（n、d、u）=（d-（u-1））* N（n-1、d、u-1）+（u + 1）* N（n-1、d、u + 1）
再帰の解決方法については、http：//en.wikipedia.org/wiki/Concrete_Mathematicsで説明するつもりはありません。
代わりに、Javaコードをいくつか作成しました。繰り返しになりますが、Javaは冗長であるため、とにかく少し不格好です。しかし、少なくともJavaでは、スタックが500または1000のネストレベルでオーバーフローしたときに、再帰がはるかに早く中断するため、再帰を使用しないという動機がありました。
n = 500、d = 4、u = 0の結果は次のとおりです。
N（500、4、0）= 133938575898283415118553131132500226320175601463191700930468798546293881390617015311649797351961982265949334114694143353148393160711539255449807219683895854579576904278803546802604812520890471375776580516387245505699580955662718322233732807745959460586868628584025594606426412298521256426464261285862562145862561282512659064256256256125590420に名を付けて（0）N（500、4、0）
中間結果を記憶するため、0.2秒で計算されます。N（40000,4,0）は5秒未満で計算します。ここにもコード：http : //ideone.com/KvB5Jv
import java.math.BigInteger;
public class EvenPairedString2 {
private final int nChars; // d above, number of different chars to use
private int count = 0;
private Map<Task,BigInteger> memo = new HashMap<>();
public EvenPairedString2(int nChars) {
this.nChars = nChars;
}
/*+******************************************************************/
// encodes for a fixed d the task to compute N(strlen,d,unpaired).
private static class Task {
public final int strlen;
public final int unpaired;
Task(int strlen, int unpaired) {
this.strlen = strlen;
this.unpaired = unpaired;
}
@Override
public int hashCode() {
return strlen*117 ^ unpaired;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Task)) {
return false;
}
Task t2 = (Task)other;
return strlen==t2.strlen && unpaired==t2.unpaired;
}
@Override
public String toString() {
return "("+strlen+","+unpaired+")";
}
}
/*+******************************************************************/
// return corner case or memorized result or null
private BigInteger getMemoed(Task t) {
if (t.strlen==0 || t.unpaired<0 || t.unpaired>t.strlen || t.unpaired>nChars
|| t.strlen%2 != t.unpaired%2) {
return BigInteger.valueOf(0);
}
if (t.strlen==1) {
return BigInteger.valueOf(nChars);
}
return memo.get(t);
}
public int getCount() {
return count;
}
public BigInteger computeNDeep(Task t) {
List<Task> stack = new ArrayList<Task>();
BigInteger result = null;
stack.add(t);
while (stack.size()>0) {
count += 1;
t = stack.remove(stack.size()-1);
result = getMemoed(t);
if (result!=null) {
continue;
}
Task t1 = new Task(t.strlen-1, t.unpaired+1);
BigInteger r1 = getMemoed(t1);
Task t2 = new Task(t.strlen-1, t.unpaired-1);
BigInteger r2 = getMemoed(t2);
if (r1==null) {
stack.add(t);
stack.add(t1);
if (r2==null) {
stack.add(t2);
}
continue;
}
if (r2==null) {
stack.add(t);
stack.add(t2);
continue;
}
result = compute(t1.unpaired, r1, nChars-t2.unpaired, r2);
memo.put(t, result);
}
return result;
}
private BigInteger compute(int u1, BigInteger r1, int u2, BigInteger r2) {
r1 = r1.multiply(BigInteger.valueOf(u1));
r2 = r2.multiply(BigInteger.valueOf(u2));
return r1.add(r2);
}
public static void main(String[] argv) {
int strlen = Integer.parseInt(argv[0]);
int nChars = Integer.parseInt(argv[1]);
EvenPairedString2 eps = new EvenPairedString2(nChars);
BigInteger result = eps.computeNDeep(new Task(strlen, 0));
System.out.printf("%d: N(%d, %d, 0) = %d%n",
eps.getCount(), strlen, nChars,
result);
}
}