POJ 2248 & ZOJ 1937 Addition Chains

题目点我 或 点我
题目大意：给出数字$n$，定义它的加法链为：
• $a_0 = 1$
• $a_m = n$
• $a_0 < a_1 < a_2 < ... < a_{m-1} < a_m$
• 对于每个$k (1 \le k \le m)$ 存在两个整数 (不一定不同)$i$和$j (0\le i, j\le k-1)$有$a_k=a_i+a_j$
让你输出长度最短的一条加法链。

基本思路就是深搜，枚举前面序列中每两个数字（也可以是同一个数字自己加自己）的和作为序列中下一个整数。然而这么暴力搜索肯定超时，需要剪枝。

如果有一个数组$Distance[i]$，记录数字$i$到达数字$n$的最短距离，记当前搜索到达的序列长度为$len$，当前搜索要拓展的数字为$Path[len]$，已经得到的最短序列长度为$Min$，那么当

$$len + Distance[Path[len]] \gt Min$$
时，就可以放弃搜索当前路径了。

奇妙的地方在于$Distance$数组的估算，按$init()$函数中的方法可以算出$Distance[i]$的上界，我也是从别的地方看到的。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define maxn 20
int nPath[maxn], nTempPath[maxn], nDistance[300], nMinLen;
int N;

void dfs(int nLen){ // nLen : current length, min value 1
    if(nLen + nDistance[nTempPath[nLen - 1]] > nMinLen)
        return;
    for(int i = nLen - 1; i >= 0; i--){
        for(int j = i; j >= 0; j--){
            nTempPath[nLen] = nTempPath[i] + nTempPath[j];
            if((nTempPath[nLen] > N) || (nTempPath[nLen] <= nTempPath[nLen - 1]))
                continue;
            if((nTempPath[nLen] == N) && (nLen + 1 < nMinLen)){
                memcpy(nPath, nTempPath, sizeof(nTempPath));
                nMinLen = nLen + 1;
                return;
            }
            dfs(nLen + 1);
        }
    }
    return;
}
void init(){
    nMinLen = N + 1;
    memset(nPath, 0, sizeof(nPath));
    memset(nTempPath, 0, sizeof(nTempPath));
    nPath[0] = nTempPath[0] = 1;
    for(int i = nMinLen; i <= nMinLen * 2; i++)
        nDistance[i] = 0;
    for(int i = nMinLen - 1; i > 0; i--)
        nDistance[i] = nDistance[i * 2] + 1;
}
int main(){
    while((scanf("%d", &N) != EOF) && (N != 0)){
        if(N == 1){
            printf("1\n");
        }else{
            init();
            dfs(1);
            for(int i = 0; i < nMinLen; i++){
                if(i == nMinLen - 1)    printf("%d\n", nPath[i]);
                else    printf("%d ", nPath[i]);
            }
        }
    }
    return 0;
}