POJ 1465【Multiple】

描述

a program that, given a natural number N between 0 and 4999 (inclusively), and M distinct decimal digits X1,X2..XM (at least one), finds the smallest strictly positive multiple of N that has no other digits besides X1,X2..XM (if such a multiple exists).

The input file has several data sets separated by an empty line, each data set having the following format:

给你一个数字N，0<=N<=4999
再给一个数字M，代表接下来会给你M类不同的数字
希望你找出一个N的倍数出来，这个值仅由给定的M类数字构成，不包含其它的数字
希望这个N的倍数的值越小越好，如果无解输出0

 

输入输出格式

 

输入

On the first line - the number N
On the second line - the number M
On the following M lines - the digits X1,X2..XM.

 

输出

For each data set, the program should write to standard output on a single line the multiple, if such a multiple exists, and 0 otherwise.

An example of input and output:

 

输入输出样例

 

输入样例

22
3
7
0
1

2
1
1

输出样例

110
0 

解题思路

　　本来呢，我开了个long long来存每次搜到的数，但是交上去，超空间？？？所以，机智的我用字符串来存，再写一个取余函数，边加边余，果然方便多了。然后这道题要特判0的情况，并且避免出现0000的情况，最后就出来了。

　　然后本题有一个剪枝的操作：举一个例子，因为36%24=12=60%24，所以36****%24=60****%24.所以我们搜到36时，记录余数，下次遇到60直接跳过就行。

题解1

 

#include<bits/stdc++.h>
using namespace std;
int n,m;
int x[10001];
bool flag[10001];
int MOD(string s)//取余函数 
{
    int ans=0;
    for(int i=0;i<s.size();i++)
    {
        ans=(ans*10+s[i]-'0')%n;//边加边余 
    }
    return ans;
}
string bfs()
{
    memset(flag,0,sizeof(flag));//初始化 
    queue<string> q;//队列 
    for(int i=1;i<=m;i++)
    {
        q.push(string(1,x[i]+'0'));//string（num，char）构造函数，转成字符串形式 
    }
    while(!q.empty())
    {
        string head=q.front();
        q.pop();
        if(head!="0"&&MOD(head)==0)//是倍数并且不是0 
        {
            return head;//返回 
        }
        for(int i=1;i<=m;i++)
        {
            string ans=head;
            if(ans=="0"&&x[i]==0)continue;//避免00000 
            ans+=string(1,x[i]+'0');//加上去 
            if(!flag[MOD(ans)])//剪枝操作 
            {
                flag[MOD(ans)]=true;//标记 
                q.push(ans);
            }
            else continue;
        }
    }
    return "0";//没找到 
}
int main()
{
    while(cin>>n>>m)//循环输入 
    {
        for(int i=1;i<=m;i++)
        {
            cin>>x[i];
        }
        if(n==0)//特判 
        {
            cout<<0<<endl;
            continue;
        }
        sort(x+1,x+1+m);//排个序 
         cout<<bfs()<<endl;
    }
} 

 题解2

　　这个的队列我用的余数，代码自己看一下，最后输出我是用了一个fa数组一步一步递归往回，最后输出。（这个没有while输入）

#include<bits/stdc++.h>
using namespace std;
int n,m,sum=0;
struct node{
    int father;//父节点 
    int ans;//数值 
}fa[10001];
int num[500005];
bitset<5000> flag;//bool 
queue<int> q;
void put(int x)
{
    if(x==0)return;//到根节点了，返回 
    put(fa[x].father);//继续向前递归 
    cout<<fa[x].ans;//打印操作 
}
void bfs()
{
    int l=1,r=0;//类似于手写队列，但我还是用的队列 
    for(int i=1;i<=m;i++)
    {
        if(num[i]!=0)//避免前导零 
        {
            q.push(num[i]%n);
            flag[num[i]%n]=1;//余数存储 
            r++;//
            fa[r].father=0;//根节点 
            fa[r].ans=num[i];//记录数字 
        }
    }
    while(!q.empty()) 
    {
        int head=q.front();
        q.pop();
        if(head==0)
        {
            put(l);//输出 
            return;
        }
        for(int i=1;i<=m;i++)
        {
            int t=head;
            t=(t*10+num[i])%n;//继续取余 
            if(!flag[t])
            {
                r++;//新建节点 
                flag[t]=1;//标记 
                fa[r].ans=num[i];//记录数字 
                fa[r].father=l;//记录father，也就是扩展它的节点的编号 
                q.push(t);
            }
        }
        l++;
    }
    cout<<0;//没找到 
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        scanf("%d",&num[i]);//输入 
    }
    if(n==0)//特判 
    {
        cout<<0;
        return 0;
    }
    sort(num+1,num+1+m);//排序 
    bfs();
}