整套题都没什么难度、

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 ==  ? 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 带你飞 最小生成树题解的更多相关文章

  1. KUANGBIN带你飞

    KUANGBIN带你飞 全专题整理 https://www.cnblogs.com/slzk/articles/7402292.html 专题一 简单搜索 POJ 1321 棋盘问题    //201 ...

  2. Tarjan 联通图 Kuangbin 带你飞 联通图题目及部分联通图题目

    Tarjan算法就不说了 想学看这 https://www.byvoid.com/blog/scc-tarjan/ https://www.byvoid.com/blog/biconnect/ 下面是 ...

  3. 「kuangbin带你飞」专题二十 斜率DP

    layout: post title: 「kuangbin带你飞」专题二十 斜率DP author: "luowentaoaa" catalog: true tags: mathj ...

  4. 「kuangbin带你飞」专题二十二 区间DP

    layout: post title: 「kuangbin带你飞」专题二十二 区间DP author: "luowentaoaa" catalog: true tags: - ku ...

  5. 「kuangbin带你飞」专题十九 矩阵

    layout: post title: 「kuangbin带你飞」专题十九 矩阵 author: "luowentaoaa" catalog: true tags: mathjax ...

  6. 「kuangbin带你飞」专题十八 后缀数组

    layout: post title: 「kuangbin带你飞」专题十八 后缀数组 author: "luowentaoaa" catalog: true tags: - kua ...

  7. 「kuangbin带你飞」专题十七 AC自动机

    layout: post title: 「kuangbin带你飞」专题十七 AC自动机 author: "luowentaoaa" catalog: true tags: - ku ...

  8. [kuangbin带你飞]专题1-23题目清单总结

    [kuangbin带你飞]专题1-23 专题一 简单搜索 POJ 1321 棋盘问题POJ 2251 Dungeon MasterPOJ 3278 Catch That CowPOJ 3279 Fli ...

  9. 【算法系列学习三】[kuangbin带你飞]专题二 搜索进阶 之 A-Eight 反向bfs打表和康拓展开

    [kuangbin带你飞]专题二 搜索进阶 之 A-Eight 这是一道经典的八数码问题.首先,简单介绍一下八数码问题: 八数码问题也称为九宫问题.在3×3的棋盘,摆有八个棋子,每个棋子上标有1至8的 ...

随机推荐

  1. 为什么mysqld启动报错

    在一台ubuntu测试机器上启动一个mysql实例,本来应该是一件很简单的事情, 启动的时候却报错了:   mysqld_safe --defaults-file=/etc/mysql/my3307. ...

  2. spring boot 过滤器实现接收 压缩数据 并解压

    1.新加类GzipRequestWrapper 继承HttpServletRequestWrapper类 public class GzipRequestWrapper extends HttpSer ...

  3. 领扣[LeetCode]从零开始[使用C++][1,10]

    0.序 以后不做后端开发是不是就用不到C++了?真香.话不多说,我已经躺倒在第一题上了.不贴题目了,持续更新. 1.两数之和 原文:https://www.cnblogs.com/grandyang/ ...

  4. WebSocket 与 HTTP/2

    个人笔记 WebSocket WebSocket 是一个双向通信协议,它在握手阶段采用 HTTP/1.1 协议(暂时不支持 HTTP/2). 握手过程如下: 首先客户端向服务端发起一个特殊的 HTTP ...

  5. POJ 1015 Jury Compromise (动态规划)

    dp[i][j]代表选了i个人,D(J)-P(J)的值为j的状态下,D(J)+P(J)的最大和. #include <cstdio> #include <cstring> #i ...

  6. for循环再探

    摘要:for循环头的组成.for的执行流程 一.for 语句的组成 0. 举个例子 for (int val = 1; val <= 10; ++val) sum += val; 1. 循环头的 ...

  7. JavaWeb笔记（十二）日志

    日志 日志信息根据用途与记录内容的不同,分为调试日志.运行日志.异常日志等. Java常用记录日志 logger log4j log4j2 logback 其中除了logger使用的概率较小,因此主要 ...

  8. 【bzoj3626】[LNOI2014]LCA 树链剖分+线段树

    题目描述 给出一个n个节点的有根树(编号为0到n-1,根节点为0).一个点的深度定义为这个节点到根的距离+1.设dep[i]表示点i的深度,LCA(i,j)表示i与j的最近公共祖先.有q次询问,每次询 ...

  9. IntellIJ IDEA 配置 Git，顺带解决Git Push rejected问题

    1.下载便携版本git https://git-scm.com/download/win 弹出的下载取消,重新选择 2.解压自压缩文件. 3.配置IDEA 4.测试 5.配置终端环境shell为bas ...

  10. Contest Hunter 模拟赛09 A [线段树维护斜率]

    题面 传送门 思路 首先看看我们到底要干什么:有$1e6$次询问,遍历$i$,每次要求一个形如$b_i \ast a_j - a_i \ast b_j$的东西的最大值 考虑如果一个$j$的决策在当前的 ...