poj1426(bfs dfs）

输入一个整数，求大于等于这个整数的且满足条件的最小值 ,条件是这个整数能整出输入的整数，且这个整数只能包括0和1

解题思路：这题搜索的方向有两个而且它的下界不好确定。所以可以用迭代加深搜索的技巧.用一个maxed控制搜索的下界。主框架就是一个循环控制maxed的大小.

#include<cstdio>
#include<algorithm>
using namespace std;
long long n,maxed;
long long s;
bool flag;
void dfs(long long i,int step)
{
    if(flag) return;
    if(step>=maxed) return;//当当前的递归深度达到上界后就return;
    if(i%n==0)
    {
        printf("%lld\n",i);
        flag=true;
        return;
    }
    dfs(i*10,step+1);
    dfs(i*10+1,step+1);
}

int main()
{
    while(~scanf("%d",&n)&&n)
    {
        flag=false;
        for(maxed=1;;++maxed)//让第一个搜不到就结束
        {
            if(flag)
                break;
            dfs(1,0);
        }
    }
}

看到别的大牛做法，根据long long 大小推断递归的深度最多19层,超过这个就retrun

#include<cstdio>
#include<algorithm>
typedef long long ll;
ll n;
int ok;
void dfs(int cur,ll num)
{
    if(ok) return;
    if(num%n==0&&num>0){
       ok=1;
       printf("%lld\n",num);
       return;
    }
    if(cur==19) return;
    dfs(cur+1,num*10+1);
    dfs(cur+1,num*10);
}

int main()
{
    while(~scanf("%lld",&n)&&n)
    {
        ok=0;
        dfs(0,1);
    }
}

广搜

#include<cstdio>
#include<queue>
using namespace std;
typedef long long ll;
int main()
{
    ll n;
    while(~scanf("%lld",&n)){
        queue<ll>q;
        while(!q.empty()) q.pop();
        q.push(1);
        while(!q.empty()){
            ll x=q.front();q.pop();
            if(x%n==0){
                printf("%lld\n",x);
                break;
            }
            q.push(x*10+1);
            q.push(x*10);
        }
    }
}