poj 3522

很久很久没有写过了。【【这不代表朕什么都没写。

传送poj 3522

题目大意：
呃呃，就是求一颗生成树，它的边权最大值与最小值差最小。

输入：

4 5 //点的数量，边的数量
1 2 3 //u,v,w;
1 3 5
1 4 6
2 4 6
3 4 7
4 6
1 2 10
1 3 100
1 4 90
2 3 20
2 4 80
3 4 40
2 1
1 2 1
3 0
3 1
1 2 1
3 3
1 2 2
2 3 5
1 3 6
5 10
1 2 110
1 3 120
1 4 130
1 5 120
2 3 110
2 4 120
2 5 130
3 4 120
3 5 110
4 5 120
5 10
1 2 9384
1 3 887
1 4 2778
1 5 6916
2 3 7794
2 4 8336
2 5 5387
3 4 493
3 5 6650
4 5 1422
5 8
1 2 1
2 3 100
3 4 100
4 5 100
1 5 50
2 5 50
3 5 50
4 1 150
0 0 //遇到0停止输入。

思路：
关于最小生成的树的kruskal算法，需要先将边排序，然后选取最小的边进入树。
ps
先在这里贴一份kruskal的代码
思想也是贪心：
1.将图各边按照权值进行排序
2.将图遍历一次，找出权值最小的边，（条件：此次找出的边不能和已加入最小生成树集合的边构成环），若符合条件，则加入最小生成树的集合中。不符合条件则继续遍历图，寻找下一个最小权值的边。
3.递归重复步骤1，直到找出n-1条边为止（设图有n个结点，则最小生成树的边数应为n-1条），算法结束。得到的就是此图的最小生成树。

#include<iostream>  
#include<cstring>  
#include<string>  
#include<cstdio>  
#include<algorithm>  
using namespace std;  
#define MAX 1000  
int father[MAX], son[MAX];  
int v, l;  

typedef struct Kruskal //存储边的信息  
{  
    int a;  
    int b;  
    int value;  
};  

bool cmp(const Kruskal & a, const Kruskal & b)  
{  
    return a.value < b.value;  
}  

int unionsearch(int x) //查找根结点+路径压缩  
{  
    return x == father[x] ? x : unionsearch(father[x]);  
}  

bool join(int x, int y) //合并  
{  
    int root1, root2;  
    root1 = unionsearch(x);  
    root2 = unionsearch(y);  
    if(root1 == root2) //为环  
        return false;  
    else if(son[root1] >= son[root2])  
        {  
            father[root2] = root1;  
            son[root1] += son[root2];  
        }  
        else  
        {  
            father[root1] = root2;  
            son[root2] += son[root1];  
        }  
    return true;  
}  

int main()  
{  
    int ncase, ltotal, sum, flag;  
    Kruskal edge[MAX];  
    scanf("%d", &ncase);  
    while(ncase--)  
    {  
        scanf("%d%d", &v, &l);  
        ltotal = 0, sum = 0, flag = 0;  
        for(int i = 1; i <= v; ++i) //初始化  
        {  
            father[i] = i;  
            son[i] = 1;  
        }  
        for(int i = 1; i <= l ; ++i)  
        {  
            scanf("%d%d%d", &edge[i].a, &edge[i].b, &edge[i].value);  
        }  
        sort(edge + 1, edge + 1 + l, cmp); //按权值由小到大排序  
        for(int i = 1; i <= l; ++i)  
        {  
            if(join(edge[i].a, edge[i].b))  
            {  
                ltotal++; //边数加1  
                sum += edge[i].value; //记录权值之和  
                cout<<edge[i].a<<"->"<<edge[i].b<<endl;  
            }  
            if(ltotal == v - 1) //最小生成树条件：边数=顶点数-1  
            {  
                flag = 1;  
                break;  
            }  
        }  
        if(flag) printf("%d\n", sum);  
        else printf("data error.\n");  
    }  
    return 0;  
}  

此题：
因为每一棵最小生成树的最大值必然是能取到的最小值，所以枚举最小边，每一个都去一边最优解，输出就ok了。。
贴个代码：

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#define inf 0x3fffffff

using namespace std;

int u,v,w;
int n,m;
int ans;
int fa[101];

struct Edge
{
    int u,v;
    int wei;
}edge[10001];

int cmp(Edge a,Edge b)
{
    return a.wei<b.wei;
}

int find(int x)    //并查集哦 
{
    if(x!=father[x])
    {
        fa[x]=find(fa[x]);
    }
    return fa[x];
}

void kruskal()
{
    for(int i=0;i<m;i++)     //枚举最小边 
    {
        for(int k=1;k<=n;k++)
        {
            fa[k]=k;
        }
        int cnt=0;
        int temp=inf;
        for(int j=i;j<m;j++)
        {
            int fx=find(edge[j].u);
            int fy=find(edge[j].v);
            if(fx!=fy)   //如果是同一个祖先，会形成环
            {
                fa[fy]=fx;
                cnt++;       
                if(cnt == n-1)    //构成一棵树 
                {
                    temp=edge[j].wei-edge[i].wei;
                    break;
                }
            }
        }
        ans=min(ans,temp);    //每棵树的解取最小/ 
    }
}

int main()
{
    while(scanf("%d%d",&n,&m))
    {
        if(n == 0 && m == 0)
        {
            break;
        }
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].wei);
        }
        ans=inf;
        sort(edge,edge+m,cmp);
        kruskal();
        if(ans!=inf)
        {
            printf("%d\n",ans); 
        }
        else
        {
            printf("-1\n");
        }

    }
}

下一篇博客会是啥时候呢？？？？【谁知道呢。

【吾等大义毫无阴霾】】
忧郁大叔今天又忧郁了嗯。