HDU-4474

题意：给出一个1到10000的整数n，然后再给出一些不能用的数字（0到9），求在该限制下能够整除n的最小数字，如果没有就输出-1。

思路：这题的基本思想还是对数字的每一位进行BFS，但是数字的位数最多能有10000位，暴力搜索肯定会超时，这里就需要剪枝。方法就是开一个大小为10000的数组对BFS判重，BFS的队列中保存每次对n取模的余数，这个余数作为数组的下标，一旦出现相同的余数就可以跳过这个数据。因为出现相同的余数就说明之前也有数字对n取模得到了该余数，那么之前的数据肯定比现在的数据更好，然后当a%n == b%n时，(a*10+c)%n == (b*10+c)%n也成立，所以之后的数据就没有必要再讨论了。

但是还有一个问题，BFS的队列中只保存余数的话在输出结果是就不能把结果完整的保存下来，这里我们可以选择再开两个数组（或者直接写一个结构体），一个数组用来保存所有余数的上一个余数（即父节点），另一个数组用来保存产生该余数时所选用的数字，在输出时就能通过不断的寻找父节点来得到完整的数字了。

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

int map[10001],num[10001];
bool value[11],flag[10001];

bool BFS(int n){
	queue<int> q;
	stack<int> s;
	int temp1,temp2;
	temp1 = 0;
	q.push(temp1);
	while(!q.empty()){
		temp1 = q.front();
		q.pop();
		for(int i=0;i<10;i++){
			if(value[i]) continue;
			if(temp1 == 0 && i == 0) continue;
			temp2 = (temp1*10+i)%n;
			if(temp2 == 0){
				s.push(i);
				while(map[temp1] != temp1){
					s.push(num[temp1]);
					temp1 = map[temp1];
				}
				while(!s.empty()){
					cout<<s.top();
					s.pop();
				}
				cout<<endl;
				return true;
			}
			else{
				if(!flag[temp2]){
					flag[temp2] = 1;
					map[temp2] = temp1;
					num[temp2] = i;
					q.push(temp2);
				}
			}
		}
	}
	return false;
}

int main(){
	int n,m,i,t=0,temp;
	while(cin>>n>>m){
		t++;
		memset(flag,0,sizeof(flag));
		memset(value,0,sizeof(value));
		memset(map,0,sizeof(map));
		memset(num,0,sizeof(num));
		for(i=0;i<m;i++){
			cin>>temp;
			value[temp] = 1;
		}
		cout<<"Case "<<t<<": ";
		if(!BFS(n)) cout<<"-1"<<endl;
	}
	return 0;
}