CSP 2017-3-4 地铁修建

附上一个完全超时的算法= =很心痛

思想是按路径长度排个序，每次添加一条最小的，然后深度搜索看能不能遍历全部。

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
#define maxn 1000001
typedef struct
{
    int a,b;
    long long dis;
}road;
typedef struct
{
    int ver;
    long long dis;
}vertex;
road r[maxn];
bool visited[maxn];
vector<vertex> adj[maxn];
bool cmp(road x,road y)
{
    return x.dis<y.dis;
}
void dfs(int i)
{
    visited[i]=1;
    for(int j=0;j<adj[i].size();j++)
        if(!visited[adj[i][j].ver])
            dfs(adj[i][j].ver);
}
int main()
{
    int n,m;
    int i,j;
    vertex t;
    cin>>n>>m;
    for(i=1;i<=m;i++)
    {
        cin>>r[i].a>>r[i].b;
        cin>>r[i].dis;
    }
    sort(r+1,r+m+1,cmp);
    for(i=1;i<=m;i++)
    {
        t.ver=r[i].a;   //添加路径
        t.dis=r[i].dis;
        adj[r[i].b].push_back(t);
        t.ver=r[i].b;
        adj[r[i].a].push_back(t);
        for(j=1;j<=n;j++)
            visited[j]=0;
        dfs(1);
        for(j=1;j<=n;j++)
            if(!visited[j])
                break;
        if(j==n+1)
            break;
    }
    cout<<r[i].dis;
    return 0;
}

用数据结构课老师的算法做同样超时，只有5分。

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
#define maxn 1000001
#define INF 1000001
typedef struct
{
    int a,b;
    int dis;
}road;
typedef struct
{
    int ver;
    int dis;
}vertex;
road r[maxn];
bool visited[maxn];
int v[maxn];
int edge[maxn];
vector<vertex> adj[maxn];
bool cmp(road x,road y)
{
    return x.dis<y.dis;
}

int main()
{
    int n,m;
    int i,j;
    int mark;
    vertex t;
    cin>>n>>m;
    for(i=1;i<=m;i++)
    {
        cin>>r[i].a>>r[i].b;
        cin>>r[i].dis;
        t.ver=r[i].a;   //添加路径
        t.dis=r[i].dis;
        adj[r[i].b].push_back(t);
        t.ver=r[i].b;
        adj[r[i].a].push_back(t);
    }
    sort(r+1,r+m+1,cmp);
    for(i=1;i<=n;i++)
    {
        visited[i]=0;
        edge[i]=INF;
    }
    visited[1]=1;
    for(i=0;i<adj[1].size();i++)
    {
        edge[adj[1][i].ver]=adj[1][i].dis;
        v[adj[1][i].ver]=1;
    }
    j=n-1;
    while(--j)
    {
        //找最短的
        mark=1;
        for(i=1;i<=n;i++)
        if(!visited[i]&&edge[i]<edge[mark])
                mark=i;
        visited[mark]=1;
        //更新
        for(i=0;i<adj[mark].size();i++)
            if(!visited[adj[mark][i].ver])
            {
                if(adj[mark][i].dis<edge[adj[mark][i].ver])
                {
                    edge[adj[mark][i].ver]=adj[mark][i].dis;
                    v[adj[mark][i].ver]=mark;
                }
            }
    }
    
    int max=0;
    edge[1]=0;
    for(i=1;i<=n;i++)
        if(edge[i]>max)
            max=edge[i];
    
    cout<<max<<endl;
    return 0;
}

正确题解都是拿路径压缩并查集和spfa做的。

可我用spfa还是超时。。只有85分。。不懂为啥。。

加了个临时变量vert然后变成95分= =

#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
#define maxn 1000001
#define INF 1000001
typedef struct
{
    int a,b;
    int dis;
}road;
typedef struct
{
    int ver;
    int dis;
}vertex;
road r[maxn];
bool visited[maxn];
int v[maxn];
int edge[maxn];
vector<vertex> adj[maxn];
bool cmp(road x,road y)
{
    return x.dis<y.dis;
}

int main()
{
    int n,m;
    int i;
    int temp;
    queue<int> q;
    vertex t;
    cin>>n>>m;
    for(i=1;i<=m;i++)
    {
        cin>>r[i].a>>r[i].b;
        cin>>r[i].dis;
        t.ver=r[i].a;   //添加路径
        t.dis=r[i].dis;
        adj[r[i].b].push_back(t);
        t.ver=r[i].b;
        adj[r[i].a].push_back(t);
    }
    for(i=1;i<=n;i++)
    {
        visited[i]=0;
        edge[i]=INF;
    }
    visited[1]=1;
    edge[1]=0;
    q.push(1);
   while(!q.empty())
   {
       temp=q.front();
       q.pop();
       visited[temp]=0;
       for(i=0;i<adj[temp].size();i++)
       {
           int vert=adj[temp][i].ver;
           int m=max(edge[temp],adj[temp][i].dis);
               if(edge[vert]>m)
               {
                   edge[vert]=m;
                    if(!visited[vert])
                    {
                        q.push(vert);
                        visited[vert]=1;
                    }
               }
       }
   }

    cout<<edge[n]<<endl;
    return 0;
}

最后还是用了压缩路径并查集的方法。。真是简单又方便。。轻松A掉了。。。

先给路径按大小排个序，每次加一条路径看两个端点在不在一个集合，不在就并起来，直到1和n的表头相等，就等价于1和n相通。

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
#define maxn 1000001
#define INF 1000001
typedef struct
{
    int a,b;
    int dis;
}road;
road r[maxn];
int uset[maxn];
bool cmp(road x,road y)
{
    return x.dis<y.dis;
}
int findset(int k)
{
    if(k!=uset[k])
        uset[k]=findset(uset[k]);
    return uset[k];
}
bool checkset(int x,int y)
{
    return findset(x)==findset(y);
}
void unionset(int x,int y)
{
    int p1=findset(x);
    int p2=findset(y);
    if(p1!=p2)
        uset[p1]=p2;
}
int main()
{
    int n,m;
    int i;
    cin>>n>>m;
    for(i=1;i<=m;i++)
    {
        cin>>r[i].a>>r[i].b;
        cin>>r[i].dis;
    }
    sort(r+1,r+m+1,cmp);
    
    for(i=1;i<=n;i++)
        uset[i]=i;
    
    for(i=1;i<=m;i++)
    {
        if(!checkset(r[i].a, r[i].b))
            unionset(r[i].a,r[i].b);
        if(checkset(1,n))
        {
            cout<<r[i].dis<<endl;
            break;
        }
    }
    return 0;
}