AtCoder arc061C Snuke's Subway Trip

大意：

给你一张无向图，边有种类。

当你第一次/重新进入某种边时费用 + 1

在同一种边之间行走无费用。

求 1 到 n 的最小费用。

 

嗯...乍一看有一个很直观的想法：记录每个点的最短路的上一条边的种类。

但是这个算法是个错的......有些数据能够hack掉。

由于边权只有0 & 1，考虑01BFS。

事实上我们还要记录每个点来之前的边，然后就要写结构体/pair

然后还要判重...

 

正解：考虑按照每个点的边的type拆点。
在不同点的同一type分点之间边权为0
原点与拆出来的点之间边权为1
然后跑01BFS即可。

开n个map来存点的分点编号。
map 的 count 用法(虽然没啥卵用)

我照着正解写了个过了，然后写了自己的想法就WA.....

不知道为什么。对拍可能生成的数据太弱了，全是符合的。

#include <cstdio>
#include <map>
#include <deque>

const int N = 1000010;

int cnt;

std::map<int, int> mp[N];

struct Edge {
    int v, nex, len;
}edge[N << 2]; int top;

int e[N], dis[N], vis[N];

inline int get(int x, int type, int &f) {
    if(mp[x][type]) {
        f = 0;
        return mp[x][type];
    }
    f = 1;
    return mp[x][type] = ++cnt;
}

inline void add(int x, int y, int z) {
    ++top;
    edge[top].v = y;
    edge[top].len = z;
    edge[top].nex = e[x];
    e[x] = top++;
    edge[top].v = x;
    edge[top].len = z;
    edge[top].nex = e[y];
    e[y] = top;
    return;
}

inline int BFS(int s, int t) {
    vis[s] = 1;
    dis[s] = 0;
    std::deque<int> Q;
    Q.push_back(s);
    while(!Q.empty()) {
        int x = Q.front();
        Q.pop_front();
        for(int i = e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            if(vis[y]) {
                continue;
            }
            dis[y] = dis[x] + edge[i].len;
            if(y == t) { /// error : y == s
                return dis[y];
            }
            vis[y] = 1;
            if(edge[i].len) {
                Q.push_back(y);
            }
            else {
                Q.push_front(y);
            }
        }
    }
    return -1;
}

int main() {
    freopen("in.in", "r", stdin);
    freopen("my.out", "w", stdout);
    int n, m;
    scanf("%d%d", &n, &m);
    cnt = n;
    for(int i = 1, x, y, z, f; i <= m; i++) {
        scanf("%d%d%d", &x, &y, &z);
        int x_type = get(x, z, f);
        if(f) {
            add(x, x_type, 1);
        }
        int y_type = get(y, z, f);
        if(f) {
            add(y, y_type, 1);
        }
        add(x_type, y_type, 0);
    }

    int ans = BFS(1, n);
    printf("%d", ans >> 1);

    return 0;
}

#include <cstdio>
#include <map>
#include <deque>

const int N = 100010;

std::map<int, int> mp[N];

struct Edge {
    int v, nex, type;
}edge[N << 4]; int top;

int e[N];

inline void add(int x, int y, int z) {
    top++;
    edge[top].v = y;
    edge[top].type = z;
    edge[top].nex = e[x];
    e[x] = top;
    return;
}

struct Poi {
    int id, dis, pre;
    Poi(int id, int dis, int pre) {
        this->id = id;
        this->dis = dis;
        this->pre = pre;
    }
};

inline int BFS(int s, int t) {
    std::deque<Poi> Q;
    Q.push_back(Poi(s, 0, 0));
    while(!Q.empty()) {
        Poi x = Q.front();
        Q.pop_front();
        for(int i = e[x.id]; i; i = edge[i].nex) {
            int y = edge[i].v;
            int len = edge[i].type == x.pre ? 0 : 1;
            if(y == t) {
                return x.dis + len;
            }
            if(mp[y][edge[i].type]) {
                continue;
            }
            mp[y][edge[i].type] = 1;
            if(len) {
                Q.push_back(Poi(y, x.dis + 1, edge[i].type));
            }
            else {
                Q.push_front(Poi(y, x.dis, x.pre));
            }
        }
    }
    return -1;
}

int main() {
    int m, n;
    scanf("%d%d", &n, &m);
    for(int i = 1, x, y, z; i <= m; i++) {
        scanf("%d%d%d", &x, &y, &z);
        add(x, y, z);
        add(y, x, z);
    }

    int t = BFS(1, n);
    printf("%d", t);

    return 0;
}