poj 1426 Find The Multiple(搜索BFS的思想+ 同余模定理+二叉树+01哈夫曼编码)

http://poj.org/problem?id=1426

Find The Multiple

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 14519		Accepted: 5893		Special Judge

Description

Given a positive integer n, write a program to find out a nonzero multiple m of n whose decimal representation contains only the digits 0 and 1. You may assume that n is not greater than 200 and there is a corresponding m containing no more than 100 decimal digits.

Input

The input file may contain multiple test cases. Each line contains a value of n (1 <= n <= 200). A line containing a zero terminates the input.

Output

For each value of n in the input print a line containing the corresponding value of m. The decimal representation of m must not contain more than 100 digits. If there are multiple solutions for a given value of n, any one of them is acceptable.

Sample Input

2
6
19
0

Sample Output

10
100100100100100100
111111111111111111

思路：

这里结果只有01，所以首先想到的是用二叉树的结构，

 而又由于结果是一个01序列，那能不能把 *10得到k每一位的问题 转化为模2的操作得到k的每一位(0或1) 呢？

答案是可以的

首先我们利用 同余模定理 对得到余数的方式进行一个优化

（a*b）%n = （a%n *b%n）%n

（a+b）%n = （a%n +b%n）%n

 

代码1：

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;

int mod[600000];
int res[200];

int main()
{
    int n;
    while(~scanf("%d",&n)&&n)
    {
        mod[1]=1%n;  //初始化，n倍数的最高位必是1
        int i;

        for(i=2;mod[i-1];i++)
        {
            //利用同余模定理，从前一步的余数mod[i/2]得到下一步的余数mod[i]
            //mod[i/2]*10+i%2模拟了BFS的双入口搜索
            mod[i]=(mod[i/2]*10+i%2)%n;
        }
        int id=0;
        i--;
        while(i)  //像哈夫曼编码一样的，倒着求根节点的01编码
        {
            res[id++]=i%2;
            i/=2;
        }
        for(i=id-1;i>=0;i--)  //倒序输出
        {
            printf("%d",res[i]);
        }
        putchar(10);
    }
    return 0;
}

看来想得有点多了（下面这代码居然AC了）

代码2：

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;

__int64 mod[600000];

int main()
{
    int n;
    while(~scanf("%d",&n)&&n)
    {
        int i;
        for(i=1;;i++)
        {
            mod[i]=mod[i/2]*10+i%2;
            if(mod[i]%n==0)
            {
                break;
            }
        }
        printf("%I64d\n",mod[i]);
    }
    return 0;
}

想不通用BFS直接写为什么会超时，用数组模拟的可以优化这么多？？？？？

附上超时BFS代码（代码3）“下面代码poj超时”：

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;

__int64 bfs(int m)
{
    queue<__int64> q;
    __int64 temp;
    q.push(1);
    while(!q.empty())
    {
        temp=q.front();
        q.pop();
        if(temp%m==0)
            return temp;
        q.push(temp*10+1);
        q.push(temp*10);
    }
    return 0;
}

int main()
{
    int n;
    while(~scanf("%d",&n)&&n)
    {
        printf("%I64d\n",bfs(n));
    }
    return 0;
}