Atcoder Snuke's Subway Trip 构图

题目链接

　　这题主要是重构图的方法很难思考。

　　方法一：考虑在每个公司意义下的联通块，每个联通块对应一个虚拟节点，联通块内的节点到联通块对应的虚拟节点有一条边，构建出一个二分图，跑一遍BFS，将经过的边数除以2。这里有两种实现，                             细节都注释在了程序里

#include<bits/stdc++.h>
using namespace std;
vector<pair<int,int> > nei[1000005];
vector<int> cit[1000005];
vector<int>comp;
int col[1000005];
bool vis[1000005];
vector<int>newnei[1000005];
int dp[1000005];
int poi[1000005];
queue<int> q;                //无需跑最短路，直接写bfs，用queue 
int main()
{
    int n,m;
    cin>>n>>m;
    memset(col,-1,sizeof col);
    for(int i=0;i<m;i++)
    {
        int x,y,c;
        scanf("%d %d %d",&x,&y,&c);
        x--,y--,c--;
        nei[x].push_back(make_pair(c,y));
        nei[y].push_back(make_pair(c,x));
        cit[c].push_back(x);
        cit[c].push_back(y);
        comp.push_back(c);
    }
    sort(comp.begin(),comp.end());
    comp.erase(unique(comp.begin(),comp.end()),comp.end());
    for(int i=0;i<n;i++)
    {
        sort(nei[i].begin(),nei[i].end());
    }
    int newci=n;
    for(int i=0;i<comp.size();i++)
    {
        int cmp=comp[i];
        for(int j=0;j<cit[comp[i]].size();j++)
        {
            int v=cit[comp[i]][j];
            if(col[v]==cmp) continue;
            q.push(v);
            col[v]=cmp;
            vector<int> ciin;
            while(!q.empty())
            {
                v=q.front();
                ciin.push_back(v);
                q.pop();
                int k=0;
                for(;poi[v]<nei[v].size();poi[v]++)            //这里的poi[v]很好的利用了按公司编号从小到大的单调性 
                {
                    k=poi[v];
                    if(nei[v][k].first!=cmp) break;
                    int u=nei[v][k].second;
                    if(col[u]==cmp) continue;
                    col[u]=cmp;
                    q.push(u);
                }
            }
            for(int k=0;k<ciin.size();k++)
            {
                int v=ciin[k];
                newnei[v].push_back(newci);
                newnei[newci].push_back(v);
            }
            newci++;
        }
    }
    for(int i=0;i<newci;i++) dp[i]=-2;
    dp[0]=1;
    q.push(0);
    while(!q.empty())
    {
        int v=q.front();
        q.pop();
        for(int k=0;k<newnei[v].size();k++)
        {
            int u=newnei[v][k];
            if(dp[u]==-2)
            {
                dp[u]=dp[v]+1;q.push(u);
            }
            
        }
    }
    cout<<dp[n-1]/2;
}

#include<bits/stdc++.h>
using namespace std;
vector<pair<int,int> > nei[1000005],cit[1000005];
vector<int>comp;
int vis[1000005];
vector<int>newnei[1000005];
int dp[1000005];
int par[1000005];
void init(int x)
{
    par[x]=x;
}
int find(int x)
{
    return (par[x]==x)?x:par[x]=find(par[x]);
}
void merge(int x,int y)
{
    x=find(x);y=find(y);
    par[x]=y;
}
queue<int> q;
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=0;i<m;i++)
    {
        int x,y,c;
        scanf("%d %d %d",&x,&y,&c);
        x--,y--,c--;
        cit[c].push_back(make_pair(x,y));
        comp.push_back(c);
    } 
    sort(comp.begin(),comp.end());
    comp.erase(unique(comp.begin(),comp.end()),comp.end());
    int newci=n;
    for(int i=0;i<comp.size();i++)
    {
        int cmp=comp[i];
        for(int j=0;j<cit[cmp].size();j++)
        {
            int v=cit[cmp][j].first,u=cit[cmp][j].second;
            init(v);init(u);
            vis[v]=vis[u]=0;                                //用到哪些就将哪些初始化 
        }
        for(int j=0;j<cit[cmp].size();j++)
        {
            merge(cit[cmp][j].first,cit[cmp][j].second);
        }
        for(int j=0;j<cit[cmp].size();j++)
        {
            int v=cit[cmp][j].first;
            v=find(v);
            if(!vis[v])
            {
                vis[v]=newci;
                newnei[v].push_back(newci);
                newnei[newci].push_back(v);
                newci++;
            }
            if(!vis[cit[cmp][j].first])
            {
                int u=cit[cmp][j].first;
                newnei[vis[v]].push_back(u);
                newnei[u].push_back(vis[v]);
                vis[cit[cmp][j].first]=newci;
            }
            if(!vis[cit[cmp][j].second])
            {
                int u=cit[cmp][j].second;
                newnei[vis[v]].push_back(u);
                newnei[u].push_back(vis[v]);
                vis[cit[cmp][j].second]=newci;
            }
        }
    }
    for(int i=0;i<newci;i++) dp[i]=-2;
    dp[0]=1;
    q.push(0);
    while(!q.empty())
    {
        int v=q.front();
        q.pop();
        for(int k=0;k<newnei[v].size();k++)
        {
            int u=newnei[v][k];
            if(dp[u]==-2)
            {
                dp[u]=dp[v]+1;q.push(u);
            }
        }
    }
    cout<<dp[n-1]/2;
}

　　方法二：对于每个节点V，设置虚拟节点V_C，V_C到V有一条边，若边（U,V）是由公司C造的，则V_C到U_C有一条边，所以虚拟节点到其它节点的边权为0，真实节点到虚拟节点的边权为1，跑一遍最短路

#include<stdio.h>
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;
typedef pair<int, int>pii;
typedef pair<pii, int>pi3;
vector<pii>pat[600000];
bool flag[600000];
int dist[600000];
int main()
{
    int num, way;
    scanf("%d%d", &num, &way);
    vector<pii>zat;
    vector<pi3>zp;
    for (int i = 0; i < way; i++)
    {
        int za, zb, zc;
        scanf("%d%d%d", &za, &zb, &zc);
        za--, zb--, zc--;
        zat.push_back(make_pair(za, zc));
        zat.push_back(make_pair(zb, zc));
        zp.push_back(make_pair(make_pair(za, zb), zc));
        zp.push_back(make_pair(make_pair(zb, za), zc));
    }
    sort(zat.begin(), zat.end());
    for (int i = 0; i < zat.size(); i++)
    {
        pat[num + i].push_back(make_pair(zat[i].first, 0));
        pat[zat[i].first].push_back(make_pair(num + i, 1));
    }
    for (int i = 0; i < zp.size(); i++)
    {
        int l1 = lower_bound(zat.begin(), zat.end(), make_pair(zp[i].first.first, zp[i].second)) - zat.begin();
        int l2 = lower_bound(zat.begin(), zat.end(), make_pair(zp[i].first.second, zp[i].second)) - zat.begin();
        pat[l1 + num].push_back(make_pair(l2 + num, 0));
    }
    priority_queue<pii>que;
    que.push(make_pair(0, 0));
    fill(dist, dist + 600000, 1000000000);
    for (;;)
    {
        if (que.empty())break;
        pii z = que.top();
        que.pop();
        if (flag[z.second])continue;
        flag[z.second] = true;
        for (int i = 0; i < pat[z.second].size(); i++)
        {
            if (dist[pat[z.second][i].first]>-z.first + pat[z.second][i].second)
            {
                dist[pat[z.second][i].first] = -z.first + pat[z.second][i].second;
                que.push(make_pair(-dist[pat[z.second][i].first], pat[z.second][i].first));
            }
        }
    }
    if (flag[num - 1])printf("%d\n", dist[num - 1]);
    else printf("-1\n");
}

 

还有一种很自然的构图方法：对于每个节点，用map<pair<v,col>,cost>来记录，直接暴力转移。由于这样会使边数太多，所以对每个节点再设一个虚拟节点(v,0)，所有(v,col)都有一条连向(v,0)，边权为1的边

#include<bits/stdc++.h>
//#include<unordered_map>
using namespace std;
map<int,vector<int> >  nei[100005];
map<int,int> dp[100005];
vector<pair<int,int> >alnei[100005];
struct Node
{
    int cost,color,v;
    Node (int cos,int col,int u)
    {
        cost=cos;
        color=col;
        v=u;
    }
    bool operator <(Node a) const
    {
        return cost>a.cost;
    }
};
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=0;i<m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        x--,y--;
        nei[x][z].push_back(y);
        nei[y][z].push_back(x);
        alnei[x].push_back(make_pair(y,z));
        alnei[y].push_back(make_pair(x,z));
    }
    priority_queue<Node> q;
    q.push(Node(0,0,0));
    while(!q.empty())
    {
        Node tmp=q.top();
        q.pop();
        int v=tmp.v,cost=tmp.cost,col=tmp.color;
        if(dp[v][col]!=cost) continue;
        if(dp[v].find(0)==dp[v].end()||dp[v][0]>cost)
        {
            dp[v][0]=cost;
            q.push(Node(cost,0,v));
        }
        if(col==0)
        {
            for(int i=0;i<alnei[v].size();i++)
            {
                int u=alnei[v][i].first,colu=alnei[v][i].second;
                if(dp[u].find(colu)==dp[u].end()||dp[u][colu]>cost+1)
                {
                    dp[u][colu]=cost+1;
                    q.push(Node(cost+1,colu,u));
                }
            }
            continue;
        }
        for(int i=0;i<nei[v][col].size();i++)
        {
            int u=nei[v][col][i],colu=col;
            if(dp[u].find(colu)==dp[u].end()||dp[u][colu]>cost)
            {
                dp[u][colu]=cost;
                q.push(Node(cost,colu,u));
            }
        }
    }
    int mi=1e9;
    for(map<int,int>::iterator it=dp[n-1].begin();it!=dp[n-1].end();it++)
    {
        mi=min(it->second,mi);
    }
    if(mi==1e9) cout<<-1; else cout<<mi;
}