Kuangbin 带你飞 最小生成树题解

整套题都没什么难度、

POJ 1251 Jungle Roads

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 210;
struct Edge
{
    int u,v,w;
    friend bool operator < (const Edge &a,const Edge &b)
    {
        return a.w < b.w;
    }
}edge[100010];
int fa[MAXN];
int M;
int Find(int x){return x == fa[x] ? x : fa[x] = Find(fa[x]);}

void kruskal(int N)
{
    for (int i = 0 ; i < MAXN ; i++) fa[i] = i;
    sort(edge,edge + M);
    int cnt = 0;
    int ret = 0;
    for (int i = 0 ; i < M ; i++)
    {
        int fu = Find(edge[i].u);
        int fv = Find(edge[i].v);
        if (fu != fv)
        {
            fa[fv] = fu;
            cnt++;
            ret += edge[i].w;
        }
        if (cnt >= N - 1) break;
    }
    printf("%d\n",ret);
}

int main()
{
    int N;
    while (scanf("%d",&N) != EOF)
    {
        if (N == 0) break;
        M = 0;
        for (int i = 0 ; i < N - 1; i++)
        {
            char op[5];
            int tot;
            scanf("%s%d",op,&tot);
            int id = op[0] - 'A';
            while (tot--)
            {
                int val;
                char tag[5];
                scanf("%s%d",tag,&val);
                edge[M].u = id;
                edge[M].v = tag[0] - 'A';
                edge[M].w = val;
                M++;
            }
        }
        kruskal(N);
    }
    return 0;
}
View Code

POJ 1287 Networking

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 70;
const int INF = 0x3f3f3f3f;
int dis[MAXN][MAXN];
int lowcost[MAXN];
bool vis[MAXN];

void prim(int N)
{
    memset(vis,false,sizeof(vis));
    for (int i = 0 ; i < MAXN ; i++) lowcost[i] = dis[1][i];
    vis[1] = true;
    lowcost[1] = 0;
    int ret = 0;
    for (int i = 1 ; i <= N ; i++)
    {
        int mincost = INF;
        int pos = -1;
        for (int j = 1 ; j <= N ; j++)
        {
            if (!vis[j] && lowcost[j] < mincost)
            {
                pos = j;
                mincost = lowcost[j];
            }
        }
        if (pos == -1) break;
        ret += mincost;
        vis[pos] = true;
        for (int j = 1 ; j <= N ; j++)
        {
            if (!vis[j] && lowcost[j] > dis[pos][j])
                lowcost[j] = dis[pos][j];
        }
    }
    printf("%d\n",ret);
}

int main()
{
    int N,M;
    while (scanf("%d",&N) != EOF)
    {
        if (N == 0) break;
        scanf("%d",&M);
        memset(dis,0x3f,sizeof(dis));
        for (int i = 0 ; i < M ; i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            dis[u][v] = min(dis[u][v],w);
            dis[v][u] = min(dis[v][u],w);
        }
        prim(N);
    }
    return 0;
}
View Code

POJ 2031 Building a Space Station

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 110;
const double eps = 1e-8;
struct circle
{
    double x,y,z;
    double r;
}src[MAXN];
struct Edge
{
    int u,v;
    double w;
    friend bool operator < (const Edge &a,const Edge &b)
    {
        return a.w < b.w;
    }
}edge[MAXN * MAXN];
int tot,N;
int fa[MAXN];
int Find(int x){return x == fa[x] ? x : fa[x] = Find(fa[x]);}

void kruskal(int N)
{
    double ret = 0;
    int cnt = 0;
    for (int i = 0 ; i < tot ; i++)
    {
        int fu = Find(edge[i].u);
        int fv = Find(edge[i].v);
        if (fu != fv)
        {
            ret += edge[i].w;
            fa[fv] = fu;
            cnt++;
        }
        if (cnt >= N - 1) break;
    }
    printf("%.3lf\n",ret);
}

int main()
{
    while (scanf("%d",&N) != EOF)
    {
        if (N == 0) break;
        for (int i = 1 ; i <= N ; i++)
            scanf("%lf%lf%lf%lf",&src[i].x,&src[i].y,&src[i].z,&src[i].r);
        tot = 0;
        for (int i = 0 ; i <= N ; i++) fa[i] = i;
        for (int i = 1 ; i <= N ; i++)
        {
            for (int j = i + 1 ; j <= N ; j++)
            {
                double dis = sqrt((src[i].x - src[j].x) * (src[i].x - src[j].x) + (src[i].y - src[j].y) * (src[i].y - src[j].y) + (src[i].z - src[j].z) * (src[i].z - src[j].z));
                if (dis > src[i].r + src[j].r)
                {
                    edge[tot].u = i;
                    edge[tot].v = j;
                    edge[tot].w = dis - src[i].r - src[j].r;
                    tot++;
                }
                else
                {
                    int fi = Find(i),fj = Find(j);
                    if (fi != fj)
                    {
                        fa[fj] = fi;
                    }
                }
            }
        }
        sort(edge,edge + tot);
        kruskal(N);
    }
    return 0;
}
View Code

POJ 2421 Constructing Roads

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 210;
const int INF = 0x3f3f3f3f;
int dis[MAXN][MAXN];
int lowcost[MAXN];
bool vis[MAXN];

void prim(int N)
{
    memset(vis,false,sizeof(vis));
    for (int i = 0 ; i <= N ; i++) lowcost[i] = dis[1][i];
    lowcost[1] = 0;
    vis[1] = true;
    int ret = 0;
    for (int i = 1 ; i <= N ; i++)
    {
        int mincost = INF;
        int pos = -1;
        for (int j = 1 ; j <= N ; j++)
        {
            if (!vis[j] && lowcost[j] < mincost)
            {
                mincost = lowcost[j];
                pos = j;
            }
        }
        if (pos == -1) break;
        ret += mincost;
        vis[pos] = true;
        for (int j = 1 ; j <= N ; j++)
        {
            if (!vis[j] && lowcost[j] > dis[pos][j])
                lowcost[j] = dis[pos][j];
        }
    }
    printf("%d\n",ret);
}

int main()
{
    int N,M;
    while (scanf("%d",&N) != EOF)
    {
        for (int i = 1 ; i <= N ; i++)
            for (int j = 1 ; j <= N ; j++) scanf("%d",&dis[i][j]);
        int Q;
        scanf("%d",&Q);
        while (Q--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            int tmp = dis[u][v];
            dis[u][v] = dis[v][u] = 0;
        }
        prim(N);
    }
    return 0;
}
View Code

ZOJ 1586 QS Network

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 1010;
const int MAXM = MAXN * MAXN;
struct Edge
{
    int u,v,w;
    friend bool operator < (const Edge &a,const Edge &b)
    {
        return a.w < b.w;
    }
}edge[MAXM];
int fa[MAXN],price[MAXN];
int tot;
int Find(int x) {return x == fa[x] ? x : fa[x] = Find(fa[x]);}

void kruskal(int N)
{
    for (int i = 0 ; i <= N ; i++) fa[i] = i;
    sort(edge,edge + tot);
    int cnt = 0 ,ret = 0;
    for (int i = 0 ; i < tot ; i++)
    {
        int fu = Find(edge[i].u);
        int fv = Find(edge[i].v);
        if (fu != fv)
        {
            fa[fv] = fu;
            cnt++;
            ret += edge[i].w;
        }
        if (cnt >= N - 1) break;
    }
    printf("%d\n",ret);
}

int main()
{
    int T;
    scanf("%d",&T);
    while (T--)
    {
        int N;
        scanf("%d",&N);
        for (int i = 1 ; i <= N ; i++) scanf("%d",&price[i]);
        tot = 0;
        for (int i = 1 ; i <= N ; i++)
        {
            for (int j = 1 ; j <= N ; j++)
            {
                int x;
                scanf("%d",&x);
                if (i < j)
                {
                    edge[tot].u = i;
                    edge[tot].v = j;
                    edge[tot++].w = x + price[i] + price[j];
                }
            }
        }
        kruskal(N);
    }
    return 0;
}
View Code

POJ 1789 Truck History

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 2010;
const int INF = 0x3f3f3f3f;
int dis[MAXN][MAXN];
char word[MAXN][10];
int lowcost[MAXN];
bool vis[MAXN];

void prim(int N)
{
    memset(vis,false,sizeof(vis));
    for (int i = 0 ; i <= N ; i++) lowcost[i] = dis[1][i];
    vis[1] = true;
    lowcost[1] = 0;
    int ret = 0;
    for (int i = 1 ; i <= N ; i++)
    {
        int mincost = INF;
        int pos = -1;
        for (int j = 1 ; j <= N ; j++)
        {
            if (!vis[j] && lowcost[j] < mincost)
            {
                mincost = lowcost[j];
                pos = j;
            }
        }
        if (pos == -1) break;
        vis[pos] = true;
        ret += mincost ;
        for (int j = 1 ; j <= N ; j++)
        {
            if (!vis[j] && lowcost[j] > dis[pos][j])
                lowcost[j] = dis[pos][j];
        }
    }
    printf("The highest possible quality is 1/%d.\n",ret);
}

int cal(int x,int y)
{
    int cnt = 0;
    for (int i = 0 ; i < 7 ; i++)
        if (word[x][i] != word[y][i]) cnt++;
    return cnt;
}

int main()
{
    int N;
    while (scanf("%d",&N) != EOF)
    {
        if (N == 0) break;
        for (int i = 1 ; i <= N ; i++) scanf("%s",word[i]);
        for (int i = 1 ; i <= N ; i++)
        {
            for (int j = i + 1 ; j <= N ; j++)
            {
                int dist = cal(i,j);
                dis[i][j] = dist;
                dis[j][i] = dist;
            }
        }
        prim(N);
    }
    return 0;
}
View Code

POJ 2349 Arctic Network

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 510;
const int MAXM = MAXN * MAXN;
int fa[MAXN];
int Find(int x) {return x == fa[x] ? x : fa[x] = Find(fa[x]);}
struct node
{
    double x,y;
}src[MAXN];
struct Edge
{
    int u,v;
    double w;
    friend bool operator <(const Edge &a,const Edge & b)
    {
        return a.w < b.w;
    }
}edge[MAXM];
int S,P;
vector<double>ans;
int cas;

void build()
{
    cas = 0;
    for (int i = 1 ; i <= P ; i++) scanf("%lf%lf",&src[i].x,&src[i].y);
    for (int i = 1 ; i <= P ; i++)
    {
        for (int j = i + 1 ; j <= P ; j++)
        {
            double dis = sqrt((src[j].x - src[i].x) * (src[j].x - src[i].x)
                    + (src[j].y - src[i].y) * (src[j].y - src[i].y));
            edge[cas].u = i;
            edge[cas].v = j;
            edge[cas].w = dis;
            cas++;
            edge[cas].v = i;
            edge[cas].u = j;
            edge[cas].w = dis;
            cas++;
        }
    }
}
int cmp(const double &a,const double &b)
{
    return a > b;
}
void kruskal()
{
    for (int i = 0 ; i <= P ; i++) fa[i] = i;
    double ret = 0;
    int cnt = 0;
    ans.clear();
    sort(edge,edge + cas);
    for (int i = 0 ; i < cas ; i++)
    {
        int fu = Find(edge[i].u);
        int fv = Find(edge[i].v);
        if (fu != fv)
        {
            cnt++;
            ret += edge[i].w;
            ans.push_back(edge[i].w);
            fa[fu] = fv;
        }
        if (cnt >= P - 1) break;
    }
    //printf("%lf\n",ret);
    sort(ans.begin(),ans.end(),cmp);
    if (S >= P) printf("0.00\n");
    else
    {
        S--;
        printf("%.2f\n",ans[S]);
    }
    //printf("%.2lf\n",max(ret,0.0));
}

int main()
{
    int T;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d%d",&S,&P);
        build();
        kruskal();
    }
    return 0;
}
View Code

POJ 1751 Highways

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 760;
int fa[MAXN];
int Find(int x) {return x == fa[x] ? x : fa[x] = Find(fa[x]);}
int x[MAXN],y[MAXN];
struct Edge
{
    int u,v,w;
    friend bool operator < (const Edge &a,const Edge &b)
    {
        return a.w < b.w;
    }
}edge[MAXN * MAXN / 2];
int N,tot;

void kruskal(int N)
{
    sort(edge,edge + tot);
    int cnt = 0;
    for (int i = 0 ; i < tot ; i++)
    {
        int fu = Find(edge[i].u);
        int fv = Find(edge[i].v);
        if (fu != fv)
        {
            printf("%d %d\n",edge[i].u,edge[i].v);
            fa[fv] = fu;
            cnt++;
        }
        if (cnt >= N - 1) break;
    }
}

int main()
{
scanf("%d",&N);
    {
        tot = 0;
        for (int i = 1 ; i <= N ; i++)scanf("%d%d",&x[i],&y[i]);
        for (int i = 1 ; i <= N ; i++)
        {
            for (int j = i + 1 ; j <= N ; j++)
            {
                int tmp = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
                edge[tot].u = i;
                edge[tot].v = j;
                edge[tot].w = tmp;
                tot++;
            }
        }
        for (int i = 1 ; i <= N ; i++) fa[i] = i;
        int M;
        scanf("%d",&M);
        while (M--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            int fu = Find(u);
            int fv = Find(v);
            if (fu != fv)
            {
                fa[fv] = fu;
            }
        }
        kruskal(N);
    }
    return 0;
}
View Code

POJ 1258 Agri-Net

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 110;
const int INF = 0x3f3f3f3f;
LL lowcost[MAXN];
LL dis[MAXN][MAXN];
bool vis[MAXN];

void prim(int N)
{
    memset(vis,false,sizeof(vis));
    for (int i = 0 ; i <= N ; i++) lowcost[i] = dis[1][i];
    lowcost[1] = 0;
    vis[1] = true;
    LL ret = 0;
    for (int i = 1 ; i <= N ; i++)
    {
        int mincost = INF;
        int pos = -1;
        for (int j = 1 ; j <= N ; j++)
        {
            if (!vis[j] && lowcost[j] < mincost)
            {
                mincost = lowcost[j];
                pos = j;
            }
        }
        if (pos == -1) break;
        ret += mincost;
        vis[pos] = true;
        for (int j = 1 ; j <= N ; j++)
        {
            if (!vis[j] && lowcost[j] > dis[pos][j])
                lowcost[j] = dis[pos][j];
        }
    }
    printf("%lld\n",ret);
}

int main()
{
    int    N;
    while (scanf("%d",&N) != EOF)
    {
        for (int i = 1 ; i <= N ; i++)
            for (int j = 1 ; j <= N ; j++) scanf("%lld",&dis[i][j]);
        prim(N);
    }
    return 0;
}
View Code

POJ 3026 Borg Maze

这道题我就也无语了。看了Discuss就知道他究竟就多多多多多坑，呵呵

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 210;
const int INF = 0x3f3f3f3f;
const int MAXD = 210;
const int dx[] = {0,0,1,-1};
const int dy[] = {1,-1,0,0};
char G[MAXN][MAXN];
queue<pair<int,int> >q;
int N,M;
int dis[MAXN][MAXN];
int dist[MAXD][MAXD];
bool vis[MAXD][MAXD];
int id[MAXN][MAXN],tot;

void bfs(int x,int y)
{
    memset(vis,false,sizeof(vis));
    int idx = id[x][y];
    while (!q.empty()) q.pop();
    dist[x][y] = 0;
    dis[idx][idx] = 0;
    q.push(make_pair(x,y));
    vis[x][y] = true;
    while (!q.empty())
    {
        pair<int,int>u = q.front(); q.pop();
        int fidx = id[u.first][u.second];
        for (int d = 0 ; d < 4 ; d++)
        {
            int nx = u.first + dx[d];
            int ny = u.second + dy[d];
            int nidx = id[nx][ny];
            if (!vis[nx][ny] && nx >= 1 && nx <= N && ny >= 1 && ny <= M && G[nx][ny] == ' ')
            {
                vis[nx][ny] = true;
                dist[nx][ny] = dist[u.first][u.second] + 1;
                q.push(make_pair(nx,ny));
            }
            else if (!vis[nx][ny] && nx >= 1 && nx <= N  && ny >= 1 && ny <= M && isupper(G[nx][ny]))
            {
                vis[nx][ny] = true;
                dist[nx][ny] = dist[u.first][u.second] + 1;
                q.push(make_pair(nx,ny));
                int nidx = id[nx][ny];
                dis[idx][nidx] = dist[nx][ny];
            }
        }
    }
}

int lowcost[MAXN];
bool used[MAXN];

void prim(int N)
{
    memset(used,false,sizeof(used));
    for (int i = 0 ; i <= N ; i++) lowcost[i] = dis[1][i];
    lowcost[1] = 0;
    used[1] = true;
    int ret = 0;
    for (int i = 1 ; i <= N ; i++)
    {
        int mincost = INF;
        int pos = -1;
        for (int j = 1 ; j <= N ; j++)
        {
            if (!used[j] && lowcost[j] < mincost)
            {
                mincost = lowcost[j];
                pos = j;
            }
        }
        if (pos == -1) break;
        ret += mincost;
        used[pos] = true;
        for (int j = 1 ; j <= N ; j++)
        {
            if (!used[j] && lowcost[j] > dis[pos][j])
                lowcost[j] = dis[pos][j];
        }
    }
    printf("%d\n",ret);
}


int main()
{
    int T;
    char tmp[300];
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d%d",&M,&N);
        gets(tmp);
        memset(id,-1,sizeof(id));
        int cas = 0;
        for (int i = 1 ; i <= N ; i++)gets(G[i] + 1);
        for (int i = 1 ; i <= N ; i++)
        {
            for (int j = 1 ; j <= M ; j++)
                if (G[i][j] == 'A' || G[i][j] == 'S')
                    id[i][j] = ++cas;
        }
        for (int i = 1 ; i <= N ; i++)\
        {
            for (int j = 1 ; j <= M ; j++)
                if (isupper(G[i][j]))
                    bfs(i,j);
        }
        prim(cas);
    }
    return 0;
}
View Code

POJ 1679 The Unique MST

求次小生成树

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 210;
const int INF = 0x3f3f3f3f;
bool vis[MAXN];
int cost[MAXN][MAXN];
int lowcost[MAXN];
int pre[MAXN],MAX[MAXN][MAXN];
bool used[MAXN][MAXN];

int prim(int cost[][MAXN],int n)
{
    int ret = 0;
    memset(vis,false,sizeof(vis));
    memset(MAX,0,sizeof(MAX));
    memset(used,false,sizeof(used));
    vis[1] = true;
    pre[1] = -1;
    for (int i = 1 ; i <= n ; i++)
    {
        lowcost[i] = cost[1][i];
        pre[i] = 1;
    }
    lowcost[1] = 0;
    pre[1] = -1;
    for (int i = 2 ; i <= n ; i++)
    {
        int mincost = INF;
        int pos = -1;
        for (int j = 1 ; j <= n ; j++)
        {
            if (!vis[j] && lowcost[j] < mincost)
            {
                mincost = lowcost[j];
                pos = j;
            }
        }
        if (pos == -1) return -1;
        ret += mincost;
        vis[pos] = true;
        used[pos][pre[pos]] = used[pre[pos]][pos] = true;
        for (int j = 1;  j <= n ; j++)
        {
            if (vis[j]) MAX[j][pos] = MAX[pos][j] = max(MAX[j][pre[pos]],lowcost[pos]);
            if (!vis[j] && lowcost[j] > cost[pos][j])
            {
                lowcost[j] = cost[pos][j];
                pre[j] = pos;
            }
        }
    }
    return ret;
}

int calcusmst(int cost[][MAXN],int n,int ret)
{
    int MIN = INF;
    for (int i = 1 ; i <= n ; i++)
    {
        for (int j = i + 1 ; j <= n ; j++)
        {
            if (cost[i][j] < INF && !used[i][j])
                MIN = min(MIN,ret + cost[i][j] - MAX[i][j]);
        }
    }
    if (MIN == INF) return -1;
    return MIN;
}

int main()
{
    int T,N,M;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d%d",&N,&M);
        for (int i = 0 ; i <= N ; i++)
            for (int j = 0 ; j <= N ; j++) cost[i][j] = i == j ? 0 : INF;
        while (M--)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            cost[u][v] = cost[v][u] = w;
        }
        int ret = prim(cost,N);
        if (ret == -1)
        {
            printf("Not Unique!\n");
            continue;
        }
        if (ret == calcusmst(cost,N,ret)) printf("Not Unique!\n");
        else printf("%d\n",ret);
    }
    return 0;
}
View Code

HDU 1233 还是畅通工程

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 110;
const int INF = 0x3f3f3f3f;
int dis[MAXN][MAXN];
int lowcost[MAXN];
bool vis[MAXN];

void prim(int N)
{
    memset(vis,false,sizeof(vis));
    for (int i = 0 ; i <= N ; i++) lowcost[i] = dis[1][i];
    vis[1] = true;
    lowcost[1] = 0;
    int ret = 0;
    for (int i = 1 ; i <= N ; i++)
    {
        int mincost = INF;
        int pos = -1;
        for (int j = 1 ; j <= N ; j++)
        {
            if (!vis[j] && lowcost[j] < mincost)
            {
                mincost = lowcost[j];
                pos = j;
            }
        }
        if (pos == -1) break;
        ret += mincost;
        vis[pos] = true;
        for (int j = 1 ; j <= N ; j++)
        {
            if (!vis[j] && lowcost[j] > dis[pos][j])
                    lowcost[j] = dis[pos][j];
        }
    }
    printf("%d\n",ret);
}

int main()
{
    int N;
    while (scanf("%d",&N) != EOF)
    {
        if (N == 0) break;
        for (int i = 1 ; i <= N ; i++)
            for (int j = 1 ; j <= N ; j++) dis[i][j] = i == j ? 0 : INF;
        int tmp = N * (N - 1) / 2;
        for (int i = 0 ; i < tmp ; i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            dis[u][v] = dis[v][u] = w;
        }
        prim(N);
    }
    return 0;
}
View Code

HDU 1301 Jungle Roads

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 210;
struct Edge
{
    int u,v,w;
    friend bool operator < (const Edge &a,const Edge &b)
    {
        return a.w < b.w;
    }
}edge[100010];
int fa[MAXN];
int M;
int Find(int x){return x == fa[x] ? x : fa[x] = Find(fa[x]);}

void kruskal(int N)
{
    for (int i = 0 ; i < MAXN ; i++) fa[i] = i;
    sort(edge,edge + M);
    int cnt = 0;
    int ret = 0;
    for (int i = 0 ; i < M ; i++)
    {
        int fu = Find(edge[i].u);
        int fv = Find(edge[i].v);
        if (fu != fv)
        {
            fa[fv] = fu;
            cnt++;
            ret += edge[i].w;
        }
        if (cnt >= N - 1) break;
    }
    printf("%d\n",ret);
}

int main()
{
    int N;
    while (scanf("%d",&N) != EOF)
    {
        if (N == 0) break;
        M = 0;
        for (int i = 0 ; i < N - 1; i++)
        {
            char op[5];
            int tot;
            scanf("%s%d",op,&tot);
            int id = op[0] - 'A';
            while (tot--)
            {
                int val;
                char tag[5];
                scanf("%s%d",tag,&val);
                edge[M].u = id;
                edge[M].v = tag[0] - 'A';
                edge[M].w = val;
                M++;
            }
        }
        kruskal(N);
    }
    return 0;
}
View Code

HDU 1875 畅通工程再续

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 210;
const double INF = 1e14;
double dis[MAXN][MAXN];
double lowcost[MAXN];
bool vis[MAXN];
double x[MAXN],y[MAXN];

double prim(int n)
{
    memset(vis,false,sizeof(vis));
    for (int i = 0 ; i <= n ; i++) lowcost[i] = dis[1][i];
    vis[1] = true;
    lowcost[1] = 0;
    double ret = 0;
    for (int i = 1 ; i <= n ; i++)
    {
        double mincost = INF;
        int pos = -1;
        for (int j = 1 ; j <= n ; j++)
        {
            if (!vis[j] && lowcost[j] < mincost)
            {
                mincost = lowcost[j];
                pos = j;
            }
        }
        if (pos == -1) break;
        vis[pos] = true;
        ret += mincost;
        for (int j = 1 ; j <= n ; j++)
        {
            if (!vis[j] && lowcost[j] > dis[pos][j])
                    lowcost[j] = dis[pos][j];
        }
    }
    return ret;
}

int main()
{
    int T;
    scanf("%d",&T);
    while (T--)
    {
        int N;
        scanf("%d",&N);
        for (int i = 1 ; i <= N ; i++)
        {
            scanf("%lf%lf",&x[i],&y[i]);
        }
        for (int i = 1 ; i <= N ; i++)
            for (int j = 1 ; j <= N ; j++) dis[i][j] = i == j ? 0 : INF;
        for (int i = 1 ; i <= N ; i++)
        {
            for (int j = i + 1 ; j <= N ; j++)
            {
                double dist = sqrt((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]));
               // printf("%lf\n",dist);
                if (dist >= 10.0 && dist < 1000)
                {
                    dis[i][j] = dis[j][i] = dist;
                   // printf("%lf\n",dist);
                }
            }
        }
       // for (int i = 1 ; i <= N ; i++)
       //     for (int j = 1 ; j <= N ; j++) printf("%lf%c",dis[i][j],j == N ? '\n' : ' ');
        double ret = prim(N);
        if (ret >= INF || ret == 0.0) puts("oh!");
        else
        {
            ret *= 100.0;
            printf("%.1lf\n",ret);
        }
    }
    return 0;
}
View Code

 

posted @ 2015-10-24 18:17  Commence  阅读(182)  评论(0)  编辑  收藏  举报