poj 1416 Find The Multiple 同余模定理
原来我用宽度搜索，结果TLE
#include "iostream"
#include "queue"
using namespace std;
typedef unsigned long long type;
queue<type> Q;
int chushu;
type a, b;
void bfs(){
a = 1;
Q.push(a);
while(!Q.empty()){
b = Q.front();
Q.pop();
int i = 2;
while(i--){
type m = b;
m = m * 10 + i % 2;
if(m % chushu == 0){ //如果可以整除， 那么输出
cout<<m<<endl;
return;
}
Q.push(m);
}
}
}
int main(){
while(cin>>chushu && chushu){
while(!Q.empty())
Q.pop();
bfs();
}
return 0;
}网上说用queue， 就会TLE, 下面两个程序一个用
同余模定理
（a*b）%n = （a%n *b%n）%n
（a+b）%n = （a%n +b%n）%n
下面解析到第一个程序来自http://user.qzone.qq.com/289065406/blog/1303946967
首先说说朴素的不剪枝搜索方法：
我以n=6为例
首先十进制数，开头第一个数字（最高位）一定不能为0，即最高位必为1
设6的 ”01十进制倍数” 为k，那么必有k%6 = 0
现在就是要用BFS求k值
1、先搜索k的最高位，最高位必为1，则此时k=1，但1%6 =1 != 0
因此k=1不是所求，存储余数 1
2、搜索下一位，下一位可能为0，即 k*10+0，此时k=10，那么k%6=4
可能为1，即 k*10+1，此时k=11，那么k%6=5
由于余数均不为0，即k=10与k=11均不是所求
3、继续搜索第三位，此时有四种可能了：
对于k=10，下一位可能为0，即 k*10+0，此时k=100，那么k%6=4
下一位可能为1，即 k*10+1，此时k=101，那么k%6=5
对于k=11，下一位可能为0，即 k*10+0，此时k=110，那么k%6=2
下一位可能为1，即 k*10+1，此时k=111，那么k%6=3
由于余数均不为0，即k=100，k=101，k=110，k=111均不是所求
4、继续搜索第四位，此时有八种可能了：
对于k=100，下一位可能为0，即 k*10+0，此时k=1000，那么k%6=4
下一位可能为1，即 k*10+1，此时k=1001，那么k%6=5
对于k=101，下一位可能为0，即 k*10+0，此时k=1010，那么k%6=2
下一位可能为1，即 k*10+1，此时k=1011，那么k%6=3
对于k=110，下一位可能为0，即 k*10+0，此时k=1100，那么k%6=2
下一位可能为1，即 k*10+1，此时k=1101，那么k%6=3
对于k=111，下一位可能为0，即 k*10+0，此时k=1110，那么k%6=0
下一位可能为1，即 k*10+1，此时k=1111，那么k%6=1
我们发现k=1110时，k%6=0，即1110就是所求的倍数
程序：
//Memory Time
//2236K 32MS
#include<iostream>
using namespace std;
int mod[524286]; //保存每次mod n的余数
//由于198的余数序列是最长的
//经过反复二分验证，436905是能存储198余数序列的最少空间
//但POJ肯定又越界测试了...524286是AC的最低下限，不然铁定RE
int main(int i)
{
int n;
while(cin>>n)
{
if(!n)
break;
mod[1]=1%n; //初始化，n倍数的最高位必是1
for(i=2;mod[i-1]!=0;i++) //利用同余模定理，从前一步的余数mod[i/2]得到下一步的余数mod[i]
mod[i]=(mod[i/2]*10+i%2)%n;
//mod[i/2]*10+i%2模拟了BFS的双入口搜索
//当i为偶数时，+0，即取当前位数字为0 。为奇数时，则+1,即取当前位数字为1
i--;
int pm=0;
while(i)
{
mod[pm++]=i%2; //把*10操作转化为%2操作，逆向求倍数的每一位数字
i/=2;
}
while(pm)
cout<<mod[--pm]; //倒序输出
cout<<endl;
}
return 0;
}
下面的程序不用queue，采用同样的机理实现了BFS， 非常值得学习，来自http://hi.baidu.com/cibiluozu/item/b80a1b14a984ee5ee75e0656
#include<iostream>
using namespace std;
long long a[23213213];
void BFS(int n)
{
int left = 0;int right = 0;
a[right] = 1;
right++;
while(left<right)
{
if((a[left]*10%n)) //填0不能整除
{
a[right] = a[left]*10;
right++;
}
else //填0后可以整除
{
cout<<a[left]*10<<endl;
return ;
}
if((a[left]*10+1)%n) //填1不能整除
{
a[right] = a[left]*10+1;
right++;
}
else //填1后可以整除
{
cout<<a[left]*10+1<<endl;
return;
}
left++;
}
}
int main()
{
int n;
while(cin>>n&&n)
{
if(n==1)
cout<<1<<endl;
else
BFS(n);
}
return 0;
}
从他这里还学到了另一个方法：打表， 这个方法的确很聪明
你的程序超时，但是可以得出正常结果， 想这题你就可以先用你的程序得出全部结果然后， 把结果在粘贴一个txt上保存
，然后写一新程序， 把前面的定义为数组。例子：
#include<iostream>
using namespace std;
int main()
{
long long a[205] = {0,1,10,
111,
100,
10,
1110,
1001,
1000,
111111111,
10,
11,
11100,
1001,
10010,
1110,
10000,
11101,
1111111110,
11001,
100,
10101,
110,
110101,
111000,
100,
10010,
1111111101,
100100,
1101101,
1110,
111011,
100000,
111111,
111010,
10010,
11111111100,
111,
110010,
10101,
1000,
11111,
101010,
1101101,
1100,
1111111110,
1101010,
10011,
1110000,
1100001,
100,
100011,
100100,
100011,
11111111010,
110,
1001000,
11001,
11011010,
11011111,
11100,
100101,
1110110,
1111011111,
1000000,
10010,
1111110,
1101011,
1110100,
11111001,
10010,
10011,
111111111000,
10001,
1110,
11100,
1100100,
1001,
101010,
11101001,
10000,
1111111101,
111110,
101011,
1010100,
111010,
11011010,
11010111,
11000,
11010101,
1111111110,
1001,
11010100,
10000011,
100110,
110010,
11100000,
11100001,
11000010,
111111111111111111,
100,
101,
1000110,
11100001,
1001000,
101010,
1000110,
110100111,
111111110100,
1111111011,
110,
111,
10010000,
1011011,
110010,
1101010,
110110100,
11111110101,
110111110,
110001101,
111000,
11011,
1001010,
10011100011,
11101100,
1000,
11110111110,
11010011,
10000000,
100100001,
10010,
101001,
11111100,
11101111,
11010110,
11111111010,
11101000,
10001,
111110010,
110110101,
100100,
10011,
100110,
1001,
1111111110000,
11011010,
100010,
1100001,
11100,
110111,
11100,
1110001,
11001000,
11111011011,
10010,
1110110,
1010100,
10101101011,
111010010,
100011,
100000,
11101111,
11111111010,
1010111,
1111100,
1111110,
1010110,
11111011,
10101000,
10111101,
111010,
1111011111,
110110100,
1111111011,
110101110,
100100,
110000,
101110011,
110101010,
11010111,
11111111100,
1001111,
10010,
100101,
110101000,
1110,
100000110,
1001011,
1001100,
1111111100001,
110010,
11101111,
111000000,
11001,
111000010,
101010,
110000100,
1101000101,
1111111111111111110,
111000011,
1000,
10010001,
1010,
11010111,
10001100
};
int n;
while(cin>>n&&n)
{
cout<<a[n]<<endl;
}
return 0;
}