poj2248 Addition Chains 迭代加深搜索

Addition Chains

Time Limit: 1000MS   Memory Limit: 65536K
Total Submissions: 5454   Accepted: 2923   Special Judge

Description

An addition chain for n is an integer sequence <a0, a1,a2,...,am="">with the following four properties:

  • a0 = 1
  • am = n
  • a0 < a1 < a2 < ... < am-1 < am
  • For each k (1<=k<=m) there exist two (not necessarily different) integers i and j (0<=i, j<=k-1) with ak=ai+aj

You are given an integer n. Your job is to construct an addition chain for n with minimal length. If there is more than one such sequence, any one is acceptable. 
For example, <1,2,3,5> and <1,2,4,5> are both valid solutions when you are asked for an addition chain for 5.

Input

The input will contain one or more test cases. Each test case consists of one line containing one integer n (1<=n<=100). Input is terminated by a value of zero (0) for n.

Output

For each test case, print one line containing the required integer sequence. Separate the numbers by one blank. 
Hint: The problem is a little time-critical, so use proper break conditions where necessary to reduce the search space.

Sample Input

5
7
12
15
77
0

Sample Output

1 2 4 5
1 2 4 6 7
1 2 4 8 12
1 2 4 5 10 15
1 2 4 8 9 17 34 68 77

Source

Ulm Local 1997

提交地址 : poj

依次搜索一位k, 枚举之前的i, j, 把a[i] + a[j] 加到a[k]的位置上, 然后接着搜索;

剪枝:尽量从达到小枚举i,j让序列的数尽快逼近n;

为了不重复搜索,用一个bool数组存a[i] + a[j] 是否已经被搜过;

然后因为答案的深度很小, 所以一发迭代加深;

这样差不多A了;

这个代码在poj上通过但在UVa上Re, 看到的大佬可以帮我找错!

代码奉上:

//By zZhBr
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

int n;
int ans;

int a[1100];

bool use[1005];
bool DFS(int stp)
{
    memset(use, 0, sizeof use);

    if(stp > ans)
    {
        if(a[ans] == n) return 1;
        else return 0;
    }

    for(register int i = stp - 1 ; i >= 1 ; i --)
    {
        for(register int j = i ; j >= 1 ; j --)
        {
            if(a[i] + a[j] > n) continue;
            if(!use[a[i] + a[j]])
            {
                if(a[i] + a[j] <= a[stp - 1]) return 0;
                use[a[i] + a[j]] = 1;
                a[stp] = a[i] + a[j];
                if(DFS(stp + 1)) return 1;
                a[stp] = 0;
                use[a[i] + a[j]] = 0;
            }
        }
    }
}

int main()
{
    while(scanf("%d", &n) != EOF)
    {
        if(n == 0) return 0;
        if(n == 1)
        {
            printf("1\n");
            continue;
        }
        if(n == 2)
        {
            printf("1 2\n");
            continue;
        }
        a[1] = 1;a[2] = 2;
        for(ans = 3 ; !DFS(3) ; ans ++);
        for(register int i = 1 ; i <= ans ; i ++)
        {
            printf("%d ", a[i]);
        }
        printf("\n");
        memset(a, 0, sizeof a);
    }
    return 0;
}

zZhBr

原文地址:https://www.cnblogs.com/zZh-Brim/p/8977282.html

时间: 2024-11-08 08:23:38

poj2248 Addition Chains 迭代加深搜索的相关文章

POJ2248 Addition Chains 迭代加深

不知蓝书的标程在说什么,,,,于是自己想了一下...发现自己的代码短的一批... 限制搜索深度+枚举时从大往小枚举,以更接近n+bool判重,避免重复搜索 #include<cstdio> #include<iostream> #include<cstring> #define R register int using namespace std; inline int g() { R ret=0; register char ch; while(!isdigit(ch

C++解题报告 : 迭代加深搜索之 ZOJ 1937 Addition Chains

此题不难,主要思路便是IDDFS(迭代加深搜索),关键在于优化. 一个IDDFS的简单介绍,没有了解的同学可以看看: https://www.cnblogs.com/MisakaMKT/articles/10767945.html 我们可以这么想,设当前规定长度为M,题目要求得出的数为N. 在搜索中,当前的步数为step,当前的数列为 数组a. 首先来确定思路,便是在以得出的数列a中枚举每两个数相加得出sum,然后继续搜索下一步. 初步的代码便是: void iddfs(int x) { for

UVA-11214 Guarding the Chessboard (迭代加深搜索)

题目大意:在一个国际象棋盘上放置皇后,使得目标全部被占领,求最少的皇后个数. 题目分析:迭代加深搜索,否则超时. 小技巧:用vis[0][r].vis[1][c].vis[2][r+c].vis[c-r+N]分别标志(r,c)位置相对应的行.列.主.副对角线有没有被占领(详见<入门经典(第2版)>P193),其中N表示任意一个比行数和列数都大(大于等于)的数. 代码如下: # include<iostream> # include<cstdio> # include&l

USACO/fence8 迭代加深搜索+剪枝

题目链接 迭代加深搜索思想. 枚举答案K,考虑到能否切出K个木头,那么我们当然选最小的K个来切. 1.对于原材料,我们是首选最大的还是最小的?显然,首选大的能够更容易切出,也更容易得到答案. 2.对于目标木头,我们是优先得到最大的还是最小的?显然,由于K个木头我们都要得到,那么当然先把最大的(最难得到的)先得到,这种搜索策略更优. 3.假设总原材料为all,前K个木头总和为sum,那么all-sum就是这一次切割过程中能[浪费]的最大数目.对于一个切剩下的原材料,若它比最小的目标木头还要小,则它

hdu 1560 DNA sequence(迭代加深搜索)

DNA sequence Time Limit : 15000/5000ms (Java/Other)   Memory Limit : 32768/32768K (Java/Other) Total Submission(s) : 15   Accepted Submission(s) : 7 Font: Times New Roman | Verdana | Georgia Font Size: ← → Problem Description The twenty-first century

【迭代加深搜索】埃及分数问题

谢谢阿苏~http://blog.csdn.net/urecvbnkuhbh_54245df/article/details/5856756 [迭代加深搜索(ID,iterative deepening)]:从小到大枚举上限maxd,每次执行只考虑深度不超过maxd的结点. ------对于可以用回溯法求解但解答树的深度没有明显上限的题目,可以考虑ID算法: ------优点:它主要是在递归搜索函数的开头判断当前搜索的深度是否大于预定义的最大搜索深度,如果大于,就退出这一层的搜索,如果不大于,就

hdu 1560 迭代加深搜索

链接:http://acm.hdu.edu.cn/showproblem.php?pid=1560 只能说bin神太给力了.. 又学到不少新知识.. 迭代加深搜索,貌似 又叫IDA*, 就是给搜索深度一个限制,搜索到一个满足条件就结束. 注意剪枝~ 代码: #include <iostream> #include <cstdio> #include <cstring> using namespace std; char g[10][10]; int size[10];

【wikioi】2495 水叮当的舞步(A*+迭代加深搜索)

这题我还是看题解啊囧.(搜索实在太弱.完全没想到A*,还有看题的时候想错了,.,- -) 好吧,估价还是那么的简单,判断颜色不同的数目即可(左上角的联通块不算在内) 然后A*还是一样的做法. 迭代加深还是一样的味道- 在这里我们用c[i][j]来表示左上角开始的联通块和联通块外面一层(因为要从外面一层拓展颜色),分别记为1和2 那么我们在搜索的时候,染色只要染c[i][j]为2的颜色种类,并且更新联通块(在这里不需要传图,因为一层一层的拓展下去的话,是单调递增的,所以用不到之前的颜色)我们在搜索

hdu 2485 Destroying the bus stations 迭代加深搜索

求最少去掉几个公交站使得从s到t的最短路径大于k. 迭代加深搜索. #include <cstdio> #include <cstring> #include <queue> using namespace std; #define maxn 60 #define maxm 50000 int n,m,K,cnt,up; int head[maxn],pre[maxn]; int road[maxn][maxn]; bool del[maxn]; queue<in