spanning tree

讲得挺好的：Spanning Tree

强联通图：边为  c=v*(v-1)/2

uva,544

kruskal求最大生成树，然后求数边里面最小的限制。用到了剪枝的方法，把字符串映射成整数，然后跑一遍就过了。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <sstream>
#include <map>
#include <algorithm>

using namespace std;
const int maxn=205;
map<string,int> mp;
int val;
int start;
int tar;
int hash[maxn];
int pos;
int n,r;
struct Edge
{
    int u,v;
    int weight;
    bool operator<(const Edge& x)const
    {
        return weight>x.weight;
    }
}E[maxn*maxn];

int parent[maxn];
int find(int y)
{
    return y==parent[y]?y:parent[y]=find(parent[y]);
}

void Kruskal()
{
    for(int i=0;i<pos;i++)
    {
        int pa=find(E[i].u);
        int pb=find(E[i].v);
        if(pa!=pb)
            parent[pa]=pb;
        if(find(start)==find(tar))
        {
            val=E[i].weight;
            return;
        }
    }
}

int main()
{
    int cas=1;
    string s1,s2;
    int tmp;
    while(scanf("%d%d",&n,&r) && n+r)
    {
        int cnt=0;
        pos=0;
        mp.clear();
        for(int i=0;i<n;i++)
            parent[i]=i;
        for(int i=0;i<r;i++)
        {
            cin>>s1>>s2>>tmp;
            if(!mp[s1])
                mp[s1]=cnt++;
            if(!mp[s2])
                mp[s2]=cnt++;
            E[pos].u=mp[s1];
            E[pos].v=mp[s2];
            E[pos++].weight=tmp;
        }
        cin>>s1>>s2;
        start=mp[s1];
        tar=mp[s2];
        sort(E,E+r);
        
        Kruskal();
        
        printf("Scenario #%d
%d tons

",cas++,val);
    }
    return 0;
}

 uva,10034

注意一下输入，每两个用例之间有换行，但是最后一个用例之后没有换行。。pr了几次

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;
const int maxn=105;
int n;
int pos;
double result;

struct Point
{
    double x,y;
    void read()
    {
        scanf("%lf%lf",&x,&y);
    }
}p[maxn];

double dist(Point a,Point b)
{
    double dx=a.x-b.x;
    double dy=a.y-b.y;
    return sqrt(dx*dx+dy*dy);
}


struct Edge
{
    int u,v;
    double dis;
    Edge(){}
    Edge(int x,int y)
    {
        this->u=x;
        this->v=y;
        dis=dist(p[x],p[y]);
    }
    
    bool operator<(const Edge& a)const
    {
        return dis<a.dis;
    }
}E[maxn*maxn];
int parent[maxn];

int find(int x)
{
    return x==parent[x]?x:parent[x]=find(parent[x]);
}

void Kruskal()
{
    for(int i=0;i<pos;i++)
    {
        int pa=find(E[i].u);
        int pb=find(E[i].v);
        if(pa!=pb)
        {
            parent[pa]=pb;
            result+=E[i].dis;
        }
    }
}

int main()
{
    int t;
    scanf("%d
",&t);  //cin>>t;也可以
    while(t--)
    {
        result=0;
        pos=0;
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
            parent[i]=i;
            p[i].read();
            for(int j=0;j<i;j++)
            {
                E[pos++]=Edge(i,j);
            }
        }
        sort(E,E+pos);
        Kruskal();
        printf("%.2lf
",result);
        if(t)
            printf("
");
    }
    return 0;
}

uva,10048

#include <iostream>
#include <cstdio>
#include <algorithm>

using namespace std;
const int maxn=100;
int start,tar;
int C,S,Q;
int flag;

struct Edge{
    int u,v;
    int dec;
    bool operator<(const Edge& a)const
    {
        return dec<a.dec;
    }
}E[1010];

struct query
{
    int a,b;
}q[10010];

int parent[maxn];

int find(int x)
{
    return x==parent[x] ? x : parent[x]=find(parent[x]);
}

void Kruskal()
{
    for(int i=0;i<S;i++)
    {
        int pa=find(E[i].u);
        int pb=find(E[i].v);
        
        if(pa!=pb)
            parent[pa]=pb;
        if(find(start)==find(tar))
        {
            flag=1;
            printf("%d
",E[i].dec);
            return;
        }
    }
}

int main()
{
    int cas=1;
    while(scanf("%d%d%d",&C,&S,&Q) && C+S+Q)
    {
        for(int i=0;i<S;i++)
        {
            scanf("%d%d%d",&E[i].u,&E[i].v,&E[i].dec);
        }
        sort(E,E+S);
        
        for(int i=0;i<Q;i++)
        {
            scanf("%d%d",&q[i].a,&q[i].b);  //不能一边输入一边输出
//wa了几次，晕
        }
        
        if(cas!=1)
            printf("
");  //这个点要注意，要不然就pr
        printf("Case #%d
",cas++);
        
        for(int i=0;i<Q;i++)
        {
            flag=0;
            for(int i=1;i<=C;i++)
                parent[i]=i;
            start=q[i].a;tar=q[i].b;
            Kruskal();
            if(!flag)
                printf("no path
");
        }
    }
    return 0;
}

 uva,10397

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>

using namespace std;
const int maxn=760;
int N,M;
int pos;
double result;

struct cable
{
    int a,b;
}p[1010];

struct Point
{
    int x,y;
    void read()
    {
        scanf("%d%d",&x,&y);
    }
}q[maxn];

double dist(Point a,Point b)
{
    int dx=a.x-b.x;
    int dy=a.y-b.y;
    return sqrt(dx*dx+dy*dy);
}

struct Edge
{
    int u,v;
    double dis;
    Edge(){}
    Edge(int x,int y)
    {
        this->u=x;
        this->v=y;
        dis=dist(q[x],q[y]);
    }
    bool operator<(const Edge& a)const
    {
        return dis<a.dis;
    }
}E[maxn*maxn];

int parent[maxn];
int find(int x)
{
    return x==parent[x] ? x:parent[x]=find(parent[x]);
}

void Kruskal()
{
    for(int i=0;i<pos;i++)
    {
        int pa=find(E[i].u);
        int pb=find(E[i].v);
        if(pa!=pb)
        {
            parent[pa]=pb;
            result+=E[i].dis;
        }
        
    }
}

int main()
{
    while(~scanf("%d",&N))
    {
        pos=0;
        for(int i=0;i<N;i++)
        {
            parent[i]=i;
            q[i].read();
            for(int j=0;j<i;j++)
                E[pos++]=Edge(i,j);
        }
        
        scanf("%d",&M);
        int m,n;
        for(int i=0;i<M;i++)
        {
            scanf("%d%d",&m,&n);
            int pa=find(m-1);
            int pb=find(n-1);
            if(pa!=pb)
                parent[pa]=pb; //直接做父亲，然后就就相当于标记了为0
        }
        sort(E,E+pos);
        result=0;
        Kruskal();
        printf("%.2lf
",result);
    }
}