Small Multiple（最短路）/// (双向队列)

题目原址：http://exam.upc.edu.cn/problem.php?cid=1368&pid=2

题意：给一个数 k,问在k的倍数中，求各个位数相加之和的最小的一个k的倍数。

看了题解才知道题意，我也来感叹一番，题解的用法真是巧妙啊    -_-

因为是k的倍数，对与数x,只需要取x属于[1,k]之间，在数后加0~9来构成一个新数y,保证y%k==0,即是各个

位数取和的最小的k的倍数，为了保证不必要的位数加进来，导致结果不是最优，所以采用取模处理，所

以只需要看对k取模的余数即可，

在每一个数之间建立边权，每个节点代表该数对k取模的结果，两节点之间的边权代表各个位数和的差值

x  -----x+1    各个位数的差值之和相差为1，所以边权为1；

x------x*10  各个位数的和加个0之后，其值不变，所以边权为0；

然后进行最短路，从取模为1,的节点，到取模为0 的节点的最短路的值，及时所求答案

先膜一下题解代码，等会再改：

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#include<vector>
#include<stdlib.h>
#include<math.h>
#include<queue>
#include<deque>
#include<ctype.h>
#include<map>
#include<set>
#include<stack>
#include<string>
#define INF 0x3f3f3f3f
#define FAST_IO ios::sync_with_stdio(false)
const double PI = acos(-1.0);
const double eps = 1e-6;
const int MAX=1e6+10;
const int mod=1e9+7;
typedef long long ll;
using namespace std;
#define gcd(a,b) __gcd(a,b)
inline ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
inline ll qpow(ll a,ll b){ll r=1,t=a; while(b){if(b&1)r=(r*t)%mod;b>>=1;t=(t*t)%mod;}return r;}
inline ll inv1(ll b){return qpow(b,mod-2);}
inline ll exgcd(ll a,ll b,ll &x,ll &y){if(!b){x=1;y=0;return a;}ll r=exgcd(b,a%b,y,x);y-=(a/b)*x;return r;}
inline ll read(){ll x=0,f=1;char c=getchar();for(;!isdigit(c);c=getchar()) if(c=='-') f=-1;for(;isdigit(c);c=getchar()) x=x*10+c-'0';return x*f;}
//freopen( "in.txt" , "r" , stdin );
//freopen( "data.txt" , "w" , stdout );
struct node
{
    int from, to, w;
} G[MAX];
int dist[MAX];
int head[MAX];
bool vis[MAX];
int cnt;
void add(int u, int v, int w)
{
    G[cnt].to=v;
    G[cnt].w=w;
    G[cnt].from=head[u];
    head[u]=cnt++;
}
int k;
void init()
{
    int i,j;
    memset(vis,0,sizeof(vis));
    memset(head,-1,sizeof(head));
    fill(dist,dist+MAX,100000);
 
    scanf("%d",&k);
    for(i=0;i<k;i++)
    {
        int a=i;
        int b=(i+1)%k;
        int c=i*10%k;
 
        add(a,b,1);
        add(a,c,0);
    }
}
 
void spfa(int s)
{
    memset(vis, false, sizeof(vis));
    queue<int> q;
    while(!q.empty())
        q.pop();
    vis[1]=true;
    q.push(s);
    dist[s]=0;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=false;
        for(int i=head[u]; ~i; i=G[i].from)
        {
            int v=G[i].to;
            if(dist[v]>dist[u]+G[i].w)
            {
                dist[v]=dist[u]+G[i].w;
                if(!vis[v])
                {
                    vis[v]=true;
                    q.push(v);
                }
            }
        }
    }
}
 
void output()
{
    printf("%d\n",dist[0]+1);
}
int main()
{
    init();
    spfa(1);
    output();
 
    return 0;
}
 
 
 
 
 

双向队列+抽屉原理的做法：

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std;
 
int vis[100009];
typedef pair<int, int> P;
 
 
int main()
{
    int k;
    scanf("%d", &k);
    deque<P> q;
    memset(vis, 0, sizeof(vis));
    q.push_back(make_pair(1, 1));
    while(!q.empty())
    {
        P x = q.front(); q.pop_front();
        if(vis[x.first]) continue;
        vis[x.first] = 1;
        if(x.first == 0)
        {
            printf("%d\n", x.second);
            break;
        }
        q.push_front(make_pair(x.first*10 % k, x.second));
        q.push_back(make_pair((x.first+1) % k, x.second+1));
 
    }
    return 0;
}