Kuangbin 带你飞最小生成树题解

整套题都没什么难度、

#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 ==  ? b : gcd(b, a % b);}

const int MAXN = ;

struct Edge

{

    int u,v,w;

    friend bool operator < (const Edge &a,const Edge &b)

    {

        return a.w < b.w;

    }

}edge[];

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 =  ; i < MAXN ; i++) fa[i] = i;

    sort(edge,edge + M);

    int cnt = ;

    int ret = ;

    for (int i =  ; 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 - ) break;

    }

    printf("%d\n",ret);

}

int main()

{

    int N;

    while (scanf("%d",&N) != EOF)

    {

        if (N == ) break;

        M = ;

        for (int i =  ; i < N - ; i++)

        {

            char op[];

            int tot;

            scanf("%s%d",op,&tot);

            int id = op[] - 'A';

            while (tot--)

            {

                int val;

                char tag[];

                scanf("%s%d",tag,&val);

                edge[M].u = id;

                edge[M].v = tag[] - 'A';

                edge[M].w = val;

                M++;

            }

        }

        kruskal(N);

    }

    return ;

}

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 ==  ? b : gcd(b, a % b);}

const int MAXN = ;

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 =  ; i < MAXN ; i++) lowcost[i] = dis[][i];

    vis[] = true;

    lowcost[] = ;

    int ret = ;

    for (int i =  ; i <= N ; i++)

    {

        int mincost = INF;

        int pos = -;

        for (int j =  ; j <= N ; j++)

        {

            if (!vis[j] && lowcost[j] < mincost)

            {

                pos = j;

                mincost = lowcost[j];

            }

        }

        if (pos == -) break;

        ret += mincost;

        vis[pos] = true;

        for (int j =  ; 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 == ) break;

        scanf("%d",&M);

        memset(dis,0x3f,sizeof(dis));

        for (int i =  ; 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 ;

}

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 ==  ? b : gcd(b, a % b);}

const int MAXN = ;

const double eps = 1e-;

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 = ;

    int cnt = ;

    for (int i =  ; 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 - ) break;

    }

    printf("%.3lf\n",ret);

}

int main()

{

    while (scanf("%d",&N) != EOF)

    {

        if (N == ) break;

        for (int i =  ; i <= N ; i++)

            scanf("%lf%lf%lf%lf",&src[i].x,&src[i].y,&src[i].z,&src[i].r);

        tot = ;

        for (int i =  ; i <= N ; i++) fa[i] = i;

        for (int i =  ; i <= N ; i++)

        {

            for (int j = i +  ; 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 ;

}

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 ==  ? b : gcd(b, a % b);}

const int MAXN = ;

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 =  ; i <= N ; i++) lowcost[i] = dis[][i];

    lowcost[] = ;

    vis[] = true;

    int ret = ;

    for (int i =  ; i <= N ; i++)

    {

        int mincost = INF;

        int pos = -;

        for (int j =  ; j <= N ; j++)

        {

            if (!vis[j] && lowcost[j] < mincost)

            {

                mincost = lowcost[j];

                pos = j;

            }

        }

        if (pos == -) break;

        ret += mincost;

        vis[pos] = true;

        for (int j =  ; 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 =  ; i <= N ; i++)

            for (int j =  ; 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] = ;

        }

        prim(N);

    }

    return ;

}

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 ==  ? b : gcd(b, a % b);}

const int MAXN = ;

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 =  ; i <= N ; i++) fa[i] = i;

    sort(edge,edge + tot);

    int cnt =  ,ret = ;

    for (int i =  ; 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 - ) break;

    }

    printf("%d\n",ret);

}

int main()

{

    int T;

    scanf("%d",&T);

    while (T--)

    {

        int N;

        scanf("%d",&N);

        for (int i =  ; i <= N ; i++) scanf("%d",&price[i]);

        tot = ;

        for (int i =  ; i <= N ; i++)

        {

            for (int j =  ; 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 ;

}

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 ==  ? b : gcd(b, a % b);}

const int MAXN = ;

const int INF = 0x3f3f3f3f;

int dis[MAXN][MAXN];

char word[MAXN][];

int lowcost[MAXN];

bool vis[MAXN];

void prim(int N)

{

    memset(vis,false,sizeof(vis));

    for (int i =  ; i <= N ; i++) lowcost[i] = dis[][i];

    vis[] = true;

    lowcost[] = ;

    int ret = ;

    for (int i =  ; i <= N ; i++)

    {

        int mincost = INF;

        int pos = -;

        for (int j =  ; j <= N ; j++)

        {

            if (!vis[j] && lowcost[j] < mincost)

            {

                mincost = lowcost[j];

                pos = j;

            }

        }

        if (pos == -) break;

        vis[pos] = true;

        ret += mincost ;

        for (int j =  ; 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 = ;

    for (int i =  ; i <  ; i++)

        if (word[x][i] != word[y][i]) cnt++;

    return cnt;

}

int main()

{

    int N;

    while (scanf("%d",&N) != EOF)

    {

        if (N == ) break;

        for (int i =  ; i <= N ; i++) scanf("%s",word[i]);

        for (int i =  ; i <= N ; i++)

        {

            for (int j = i +  ; j <= N ; j++)

            {

                int dist = cal(i,j);

                dis[i][j] = dist;

                dis[j][i] = dist;

            }

        }

        prim(N);

    }

    return ;

}

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 ==  ? b : gcd(b, a % b);}

const int MAXN = ;

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 = ;

    for (int i =  ; i <= P ; i++) scanf("%lf%lf",&src[i].x,&src[i].y);

    for (int i =  ; i <= P ; i++)

    {

        for (int j = i +  ; 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 =  ; i <= P ; i++) fa[i] = i;

    double ret = ;

    int cnt = ;

    ans.clear();

    sort(edge,edge + cas);

    for (int i =  ; 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 - ) 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 ;

}

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 ==  ? b : gcd(b, a % b);}

const int MAXN = ;

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 / ];

int N,tot;

void kruskal(int N)

{

    sort(edge,edge + tot);

    int cnt = ;

    for (int i =  ; 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 - ) break;

    }

}

int main()

{

scanf("%d",&N);

    {

        tot = ;

        for (int i =  ; i <= N ; i++)scanf("%d%d",&x[i],&y[i]);

        for (int i =  ; i <= N ; i++)

        {

            for (int j = i +  ; 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 =  ; 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 ;

}

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 ==  ? b : gcd(b, a % b);}

const int MAXN = ;

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 =  ; i <= N ; i++) lowcost[i] = dis[][i];

    lowcost[] = ;

    vis[] = true;

    LL ret = ;

    for (int i =  ; i <= N ; i++)

    {

        int mincost = INF;

        int pos = -;

        for (int j =  ; j <= N ; j++)

        {

            if (!vis[j] && lowcost[j] < mincost)

            {

                mincost = lowcost[j];

                pos = j;

            }

        }

        if (pos == -) break;

        ret += mincost;

        vis[pos] = true;

        for (int j =  ; 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 =  ; i <= N ; i++)

            for (int j =  ; j <= N ; j++) scanf("%lld",&dis[i][j]);

        prim(N);

    }

    return ;

}

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 ==  ? b : gcd(b, a % b);}

const int MAXN = ;

const int INF = 0x3f3f3f3f;

const int MAXD = ;

const int dx[] = {,,,-};

const int dy[] = {,-,,};

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] = ;

    dis[idx][idx] = ;

    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 =  ; d <  ; d++)

        {

            int nx = u.first + dx[d];

            int ny = u.second + dy[d];

            int nidx = id[nx][ny];

            if (!vis[nx][ny] && nx >=  && nx <= N && ny >=  && ny <= M && G[nx][ny] == ' ')

            {

                vis[nx][ny] = true;

                dist[nx][ny] = dist[u.first][u.second] + ;

                q.push(make_pair(nx,ny));

            }

            else if (!vis[nx][ny] && nx >=  && nx <= N  && ny >=  && ny <= M && isupper(G[nx][ny]))

            {

                vis[nx][ny] = true;

                dist[nx][ny] = dist[u.first][u.second] + ;

                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 =  ; i <= N ; i++) lowcost[i] = dis[][i];

    lowcost[] = ;

    used[] = true;

    int ret = ;

    for (int i =  ; i <= N ; i++)

    {

        int mincost = INF;

        int pos = -;

        for (int j =  ; j <= N ; j++)

        {

            if (!used[j] && lowcost[j] < mincost)

            {

                mincost = lowcost[j];

                pos = j;

            }

        }

        if (pos == -) break;

        ret += mincost;

        used[pos] = true;

        for (int j =  ; 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[];

    scanf("%d",&T);

    while (T--)

    {

        scanf("%d%d",&M,&N);

        gets(tmp);

        memset(id,-,sizeof(id));

        int cas = ;

        for (int i =  ; i <= N ; i++)gets(G[i] + );

        for (int i =  ; i <= N ; i++)

        {

            for (int j =  ; j <= M ; j++)

                if (G[i][j] == 'A' || G[i][j] == 'S')

                    id[i][j] = ++cas;

        }

        for (int i =  ; i <= N ; i++)\

        {

            for (int j =  ; j <= M ; j++)

                if (isupper(G[i][j]))

                    bfs(i,j);

        }

        prim(cas);

    }

    return ;

}

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 ==  ? b : gcd(b, a % b);}

const int MAXN = ;

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 = ;

    memset(vis,false,sizeof(vis));

    memset(MAX,,sizeof(MAX));

    memset(used,false,sizeof(used));

    vis[] = true;

    pre[] = -;

    for (int i =  ; i <= n ; i++)

    {

        lowcost[i] = cost[][i];

        pre[i] = ;

    }

    lowcost[] = ;

    pre[] = -;

    for (int i =  ; i <= n ; i++)

    {

        int mincost = INF;

        int pos = -;

        for (int j =  ; j <= n ; j++)

        {

            if (!vis[j] && lowcost[j] < mincost)

            {

                mincost = lowcost[j];

                pos = j;

            }

        }

        if (pos == -) return -;

        ret += mincost;

        vis[pos] = true;

        used[pos][pre[pos]] = used[pre[pos]][pos] = true;

        for (int j = ;  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 =  ; i <= n ; i++)

    {

        for (int j = i +  ; 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 -;

    return MIN;

}

int main()

{

    int T,N,M;

    scanf("%d",&T);

    while (T--)

    {

        scanf("%d%d",&N,&M);

        for (int i =  ; i <= N ; i++)

            for (int j =  ; j <= N ; j++) cost[i][j] = i == j ?  : 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 == -)

        {

            printf("Not Unique!\n");

            continue;

        }

        if (ret == calcusmst(cost,N,ret)) printf("Not Unique!\n");

        else printf("%d\n",ret);

    }

    return ;

}

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 ==  ? b : gcd(b, a % b);}

const int MAXN = ;

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 =  ; i <= N ; i++) lowcost[i] = dis[][i];

    vis[] = true;

    lowcost[] = ;

    int ret = ;

    for (int i =  ; i <= N ; i++)

    {

        int mincost = INF;

        int pos = -;

        for (int j =  ; j <= N ; j++)

        {

            if (!vis[j] && lowcost[j] < mincost)

            {

                mincost = lowcost[j];

                pos = j;

            }

        }

        if (pos == -) break;

        ret += mincost;

        vis[pos] = true;

        for (int j =  ; 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 == ) break;

        for (int i =  ; i <= N ; i++)

            for (int j =  ; j <= N ; j++) dis[i][j] = i == j ?  : INF;

        int tmp = N * (N - ) / ;

        for (int i =  ; i < tmp ; i++)

        {

            int u,v,w;

            scanf("%d%d%d",&u,&v,&w);

            dis[u][v] = dis[v][u] = w;

        }

        prim(N);

    }

    return ;

}

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 ==  ? b : gcd(b, a % b);}

const int MAXN = ;

struct Edge

{

    int u,v,w;

    friend bool operator < (const Edge &a,const Edge &b)

    {

        return a.w < b.w;

    }

}edge[];

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 =  ; i < MAXN ; i++) fa[i] = i;

    sort(edge,edge + M);

    int cnt = ;

    int ret = ;

    for (int i =  ; 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 - ) break;

    }

    printf("%d\n",ret);

}

int main()

{

    int N;

    while (scanf("%d",&N) != EOF)

    {

        if (N == ) break;

        M = ;

        for (int i =  ; i < N - ; i++)

        {

            char op[];

            int tot;

            scanf("%s%d",op,&tot);

            int id = op[] - 'A';

            while (tot--)

            {

                int val;

                char tag[];

                scanf("%s%d",tag,&val);

                edge[M].u = id;

                edge[M].v = tag[] - 'A';

                edge[M].w = val;

                M++;

            }

        }

        kruskal(N);

    }

    return ;

}

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 ==  ? b : gcd(b, a % b);}

const int MAXN = ;

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 =  ; i <= n ; i++) lowcost[i] = dis[][i];

    vis[] = true;

    lowcost[] = ;

    double ret = ;

    for (int i =  ; i <= n ; i++)

    {

        double mincost = INF;

        int pos = -;

        for (int j =  ; j <= n ; j++)

        {

            if (!vis[j] && lowcost[j] < mincost)

            {

                mincost = lowcost[j];

                pos = j;

            }

        }

        if (pos == -) break;

        vis[pos] = true;

        ret += mincost;

        for (int j =  ; 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 =  ; i <= N ; i++)

        {

            scanf("%lf%lf",&x[i],&y[i]);

        }

        for (int i =  ; i <= N ; i++)

            for (int j =  ; j <= N ; j++) dis[i][j] = i == j ?  : INF;

        for (int i =  ; i <= N ; i++)

        {

            for (int j = i +  ; 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 < )

                {

                    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 ;

}

Kuangbin 带你飞最小生成树题解的更多相关文章

KUANGBIN带你飞
KUANGBIN带你飞全专题整理 https://www.cnblogs.com/slzk/articles/7402292.html 专题一简单搜索 POJ 1321 棋盘问题 //201 ...
Tarjan 联通图 Kuangbin 带你飞联通图题目及部分联通图题目
Tarjan算法就不说了想学看这 https://www.byvoid.com/blog/scc-tarjan/ https://www.byvoid.com/blog/biconnect/ 下面是 ...
「kuangbin带你飞」专题二十斜率DP
layout: post title: 「kuangbin带你飞」专题二十斜率DP author: "luowentaoaa" catalog: true tags: mathj ...
「kuangbin带你飞」专题二十二区间DP
layout: post title: 「kuangbin带你飞」专题二十二区间DP author: "luowentaoaa" catalog: true tags: - ku ...
「kuangbin带你飞」专题十九矩阵
layout: post title: 「kuangbin带你飞」专题十九矩阵 author: "luowentaoaa" catalog: true tags: mathjax ...
「kuangbin带你飞」专题十八后缀数组
layout: post title: 「kuangbin带你飞」专题十八后缀数组 author: "luowentaoaa" catalog: true tags: - kua ...
「kuangbin带你飞」专题十七 AC自动机
layout: post title: 「kuangbin带你飞」专题十七 AC自动机 author: "luowentaoaa" catalog: true tags: - ku ...
[kuangbin带你飞]专题1-23题目清单总结
[kuangbin带你飞]专题1-23 专题一简单搜索 POJ 1321 棋盘问题POJ 2251 Dungeon MasterPOJ 3278 Catch That CowPOJ 3279 Fli ...
【算法系列学习三】[kuangbin带你飞]专题二搜索进阶之 A-Eight 反向bfs打表和康拓展开
[kuangbin带你飞]专题二搜索进阶之 A-Eight 这是一道经典的八数码问题.首先,简单介绍一下八数码问题: 八数码问题也称为九宫问题.在3×3的棋盘,摆有八个棋子,每个棋子上标有1至8的 ...

随机推荐

JSONP跨域jQuery处理整理（附天气数据实例）
写在前面跨域的解决方案有多种,其中最常见的是使用同一服务器下的代理来获取远端数据,再通过ajax进行读取,而在这期间经过了两次请求过程,使得获取数据的效率大大降低,这篇文章蓝飞就为大家介绍一下解决跨 ...
并查集——poj2492（带权并查集入门）
一.题目回顾题目链接:传送门题意:给定n只虫子,不同性别的可以在一起,相同性别的不能在一起.给你m对虫子,判断中间有没有同性别在一起的. 二.解题思路种类并查集和poj1073的本质一样详见 ...
Python中enumerate函数用法详解
enumerate函数用于遍历序列中的元素以及它们的下标,多用于在for循环中得到计数,enumerate参数为可遍历的变量,如字符串,列表等一般情况下对一个列表或数组既要遍历索引又要遍历元素时, ...
(转)mongdb性能优化收集
一.数据库最大连接数问题当你在后台日志中,发现大量“connection refused because too many open connections: 819”信息时,一般跟你没有设置合适的最 ...
python practive
定义新的操作指令,并将其组合到一起以便能够做一些有意义的事情,这就是编程工作的核心和灵魂. 计算型思维: 1,强调概念化,而非程序化.计算机科学不是计算机程序.像计算机科学家一样的思考,不只是说要编程 ...
java基础知识（一）- 数据类型
Java有两大数据类型: 基本数据类型,基本数据类型都可以直接分配到栈中引用数据类型,引用存放在栈中,对象本身存放在堆中基本数据类型共有四类八种第一类:字符型(char) 第二类:逻辑型(boo ...
hibernate笔记(四)
目标: 一.hibernate查询二.hibernate对连接池的支持三.二级缓存一.hibernate查询 1. 查询概述 1) Get/load主键查询 2) 对象导航查询 3) HQL查询 ...
kafka卡顿
一次kafka卡顿事故排查过程 https://www.cnblogs.com/yougewe/p/8975550.html 由于一次功能上线后,导致某数据量急剧下滑,给我们紧张的呢!排查过程也是个学 ...
BZOJ5343 [Ctsc2018]混合果汁【二分 + 主席树】
题目链接 BZOJ5343 题解明显要二分一下美味度,然后用尽量少的价格去购买饮料,看看能否买到\(L\)升,然后看看能否控制价格在\(g\)内尽量少的价格,就优先先选完便宜的饮料,由于询问的是一 ...
移动端弹窗滚动时window窗体也一起滚动的解决办法
在做移动端项目的时候发现,如果弹窗的内容很多很长,在滑动弹窗时,蒙层下面的window窗体也会跟着一起滚动,这样带来很差的视觉体验:当时也想了很多办法,比如判断滑动的元素,如果是弹窗里面的元素则禁止w ...

Kuangbin 带你飞 最小生成树题解

Kuangbin 带你飞 最小生成树题解的更多相关文章

随机推荐

热门专题

Kuangbin 带你飞最小生成树题解

Kuangbin 带你飞最小生成树题解的更多相关文章