51Nod - 1640 天气晴朗的魔法

51nod魔法学校近日开展了主题为“天气晴朗”的魔法交流活动。

N名魔法师按阵法站好，之后选取N - 1条魔法链将所有魔法师的魔力连接起来，形成一个魔法阵。

魔法链是做法成功与否的关键。每一条魔法链都有一个魔力值V，魔法最终的效果取决于阵中所有魔法链的魔力值的和。

由于逆天改命的魔法过于暴力，所以我们要求阵中的魔法链的魔力值最大值尽可能的小，与此同时，魔力值之和要尽可能的大。

现在给定魔法师人数N，魔法链数目M。求此魔法阵的最大效果。

Input

两个正整数N，M。(1 <= N <= 10^5, N <= M <= 2 * 10^5)

接下来M行，每一行有三个整数A, B, V。(1 <= A, B <= N, INT_MIN <= V <= INT_MAX)

保证输入数据合法。

Output

输出一个正整数R，表示符合条件的魔法阵的魔力值之和。

Sample Input

4 6
1 2 3
1 3 1
1 4 7
2 3 4
2 4 5
3 4 6

Sample Output

12

首先就是这个题意，我直接废掉，压根不懂，后来明白了最大值尽可能的小，就是指的是最小生成树里面最大的那条边，然后再以这条边为最大边控制生成最大生成树，这就是尽量大了，感觉很神奇。所以就是先最小生成树，找到这个尽量小的最大边，然后我们再去以这条边来构造最大生成树

#include <iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;

const int maxn=1e5+10;
int n,m;
int pre[maxn];

struct edge
{
    int u,v;
    int w;
}Edge[maxn*2];

int cmp(edge a,edge b)
{
    return a.w<b.w;
}

int find_root(int x)
{
    return pre[x]==x?x:pre[x]=find_root(pre[x]);
}

int cmp2(edge a,edge b)
{
    return a.w>b.w;
}

int main()
{
    scanf("%d %d",&n,&m);
    for(int i=0;i<m;i++)
    {
        int u,v,w;
        scanf("%d %d %d",&u,&v,&w);
        Edge[i].u=u,Edge[i].v=v,Edge[i].w=w;
    }
    for(int i=0;i<=n;i++)
        pre[i]=i;

    sort(Edge,Edge+m,cmp);
    int cnt=0;
    int id=0;
    for(int i=0;i<m;i++)
    {
        int x,y,rx,ry;
        x=Edge[i].u,y=Edge[i].v;
        rx=find_root(x),ry=find_root(y);
        if(rx!=ry)
        {
            pre[rx]=ry;
            cnt++;
            if(cnt==n-1)
            {
                id=Edge[i].w;
                break;//找到最小的最长边
            }
        }
    }

    memset(pre,0,sizeof(pre));
    for(int i=0;i<=n;i++)
        pre[i]=i;

    sort(Edge,Edge+m,cmp2);//不要只是对id前面的进行重新排序，他可能正好有好几条“最大边”，然而我们却只取了第一个，然后就尴尬了，WA好几发，才想到
    long long ans=0;
    for(int i=0;i<m;i++)
    {
        int x,y,rx,ry;
        x=Edge[i].u,y=Edge[i].v;
        rx=find_root(x),ry=find_root(y);
        if(rx!=ry&&Edge[i].w<=id)
        {
            pre[rx]=ry;
            ans += Edge[i].w;
        }
    }
    printf("%I64d\n",ans);
}

二分取值

#include <iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
/*
想着来个二分，没想到自己太菜了，写了半个多小时
1.pre[]数组的初始化，应该是调用一次，我们就去更新一次
2.至今不能理解为什么只能对数进行选择，而不是直接从权值里面选择
  现在明白了，以后我们的二分直接就去枚举数，不要枚举区间，不知道有什么坑，简直了
  他有相等的点，那我们去枚举的话，尽管是相同的数，但是我们选的区间，就会把一些相同的数，直接
  抹掉，这就回导致一些问题，而如果我们直接枚举line ,直接在所有边的权值里面去枚举，这样的话，我们就可以直接
  取到合适的边
*/
const int maxn=1e5+10;
int n,m;
int pre[maxn];
int val[maxn];

struct edge
{
    int u,v;
    int w;
}Edge[maxn*2];


int find_root(int x)
{
    return pre[x]==x?x:pre[x]=find_root(pre[x]);
}

int cmp(edge a,edge b)
{
    return a.w>b.w;
}

long long  max_tree(int line)
{
    int cnt=0;
    long long ans=0;
    memset(pre,0,sizeof(pre));
    for(int i=0;i<=n;i++)
        pre[i]=i;
    for(int i=0;i<m;i++)
    {
        if(Edge[i].w>line)
            continue;
        int x,y,rx,ry;
        x=Edge[i].u,y=Edge[i].v;
        rx=find_root(x),ry=find_root(y);
        if(rx!=ry)
        {
            pre[rx]=ry;
            ans += Edge[i].w;
            cnt++;
            if(cnt==n-1)
                return ans;//可以组成大树
        }
    }
    return 0;//没有组成树
}


int main()
{
    int l=0,r=0,mid;
    scanf("%d %d",&n,&m);
    for(int i=0;i<m;i++)
    {
        int u,v,w;
        scanf("%d %d %d",&u,&v,&w);
        Edge[i].u=u,Edge[i].v=v,Edge[i].w=w;
        r=max(r,w);
    }
    sort(Edge,Edge+m,cmp);
    long long  ans=0,temp;
    while(l<=r)
    {
        mid=(l+r)/2;
        temp=max_tree(mid);
        if(temp) ans=temp;
        if(temp)
        {
             r=mid-1;
        }
        else
        {
           l=mid+1;
        }
    }
    printf("%I64d\n",ans);
    return 0;
}