Wannafly 挑战赛12 E

链接：https://www.nowcoder.com/acm/contest/79/E
来源：牛客网

题目描述

小欧在上代数课的时候，老师向大家提出了一个问题，不定方程 ax+by=c 的整数解存在的充要条件是什么。
聪明的小欧立即举手给出了老师一个完美的回答,放学后，老师叫住小欧给了他一个思考题。
给出正整数 a 和 b 的值以及两个序列 S 和 V, 求出最小代价的正整数 c 使得不定方程 ax+by=c 有解，且 c 必须满足以下条件：
1. 组成 c 的数字必须是序列 S 内的。
2. 每使用序列 S 内的一个数字 S_i 就会消耗掉代价 V_i。
3. 序列 S 内的数字使用次数不限。
4. c 的首位为 u， c的末位为 v。(u，v 也是序列 S 内的) 
如果有多个代价一样小的答案，只需要 c 的字典序最小的那一个。

输入描述:

第一行三个个整数 a，b，n (1 <= a, b <= 100000,  2 <= n <= 10) 
第二行 n 个整数 S

_i

(0 <= S

_i

 <= 9) 
第三行 n 个整数 V

_i

(1 <= V

_i

<= 1000) 
最后一行两个整数 u，v(1 <= u <= 9,  0 <= v <= 9, u != v) 

输出描述:

输出一行表示满足条件的 c 。
如果有多个输出字典序最小的。
如果不存在输出 -1 。

示例1

输入

10 15 2
2 0
1 1
2 0

输出

20

示例2

输入

17 17 4
0 1 2 7
1 1 1 1000
1 0

输出

1020

思路：对于0到1e5的每一个值建一个节点，每个数字对应一条边，u到v有一条数字为x的边当且仅当(u * 10 + x) % gcd(a, b) == v。想到这里，建图完毕直接跑个dij就行了。但是有一个问题，要输出字典序最小路径，正向可能不好记录，
可以反向建图跑最短路。反向图的起点值是0，连接所有 满足(w * 10 + v) % 10 == 0的w节点即可，但这个0与路径上普通的节点0是不同的，我们要将这个点特殊化一下，可以赋成一个独特的下标10001。最后求10001到u的最短路即可，更新路径
时根据决策记录上一个节点以及到达此节点的边。

#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <iomanip>
#include <cctype>
#include <cassert>
#include <bitset>
#include <ctime>

using namespace std;

#define pau system("pause")
#define ll long long
#define pli pair<ll, int>
#define pii pair<int, int>
#define pb push_back
#define mp make_pair
#define clr(a, x) memset(a, x, sizeof(a))

const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;

/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
tree<pli, null_type, greater<pli>, rb_tree_tag, tree_order_statistics_node_update> T;
*/

int a, b, n, s[15], val[15], u, v, g, cost[15];
int dis[100015];
pii pre[100015];
struct edge {
    int v, x;
    edge () {}
    edge (int v, int x) : v(v), x(x) {}
};
vector<edge> E[100015];

int gcd(int a, int b) {
    return b ? gcd(b, a % b) : a;
}

void build_graph() {
    for (int i = 0; i <= 100000; ++i) {
        for (int j = 0; j < 10; ++j) {
            if (INF != cost[j]) {
                //E[i].pb(mp((i * 10 + j) % g, cost[j]));
                if ((i * 10 + j) % g == i) continue;
                E[(i * 10 + j) % g].pb(edge(i, j));
            }
        }
    }
    for (int i = 0; i <= 100000; ++i) {
        if (0 == (i * 10 + v) % g) {
            E[100001].pb(edge(i, v));
        }
    }
}

int dij() {
    clr(dis, INF);
    for (int i = 0; i < 100010; ++i) {
        pre[i].first = INF;
        pre[i].second = INF;
    }
    priority_queue<pli, vector<pli>, greater<pli> > que;
    int s = 100001;
    que.push(pli(dis[s] = 0, s));
    while (que.size()) {
        pli p = que.top(); que.pop();
        ll d = p.first;
        int x = p.second;
        if (dis[x] < d) continue;
        for (int i = 0; i < E[x].size(); ++i) {
            int y = E[x][i].v, v = E[x][i].x;
            /*if (x == y) {
                printf("x = y = %d\n", x);
                pau;
            }*/
            int td = d + cost[v];
            if (dis[y] < td) continue;
            if (td < dis[y]) {
                que.push(pli(dis[y] = td, y));
                pre[y] = mp(x, v);
            } else {
                if (v < pre[y].second) pre[y] = mp(x, v);
            }
        }
    }
    return dis[u];
}

int main() {
    scanf("%d%d%d", &a, &b, &n);
    g = gcd(a, b);
    clr(cost, INF);
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &s[i]);
    }
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &val[i]);
        cost[s[i]] = min(cost[s[i]], val[i]);
    }
    scanf("%d%d", &u, &v);
    build_graph();
    if (INF == dij()) {
        puts("-1");
    } else {
        printf("%d", u);
        int s = u;
        while (100001 != s) {
            printf("%d", pre[s].second);
            s = pre[s].first;
        }
    }
    return 0;
}