UVA 11865 Stream My Contest(最小树形图)

题意：N台机器，M条有向边，总资金C，现要到搭建一个以0号机（服务器）为跟的网路，已知每条网线可以把数据从u传递到v，其带宽为d，花费为c，且d越大，传输速度越快，问能够搭建的传输速度最快的网络d值是多少？（即：在C的支持下，网络中d的最小值最大是多少？）

一开始把问题想简单了，以为网线可以随便接，其实是确定了u->v的= =

最小树形图，概念蛮好理解的，要学习的话

理论：http://hi.baidu.com/bin183/item/5d93ef69ceb541176895e682

代码标注的很详细：http://blog.csdn.net/hehedounima/article/details/9320173

其实，实质就是不断地缩点。需要注意的是选取以每个点为终点的最小边，以及重建图。

因为看人家缩点部分的代码写得略挫，于是我就写了个更挫的T^T——基于强连通缩点的。。细节在代码里已经标明

#include<cstdio>
#include<cmath>
#include<cstring>
#include<vector>
#include<queue>
#include<stack>
#include<algorithm>
#define clr(a,m) memset(a,m,sizeof(a))
#define rep(i,a,b) for(int i=a;i<=b;i++)
using namespace std;

const int MAXN=66;
const int MAXM=11111;
const int INF =1e9;

struct Edge{
    int u,v,d,c;
};

int _n,m,w;
int root,u[MAXM],v[MAXM],d[MAXM],c[MAXM];

int head[MAXN],tol;

int pre[MAXN],low[MAXN],sccno[MAXN],scc_cnt,dfs_clock;
int stk[MAXN],top;

bool mark[MAXN];
Edge into[MAXN];

vector<Edge>edge;
vector<int>G[MAXN];

void init()
{
    edge.clear();
    rep(i,0,_n-1)//!!写成m-1，RE的泪啊
        G[i].clear();
}

void add(int u,int v,int d,int c)
{
    edge.push_back((Edge){u,v,d,c});
    int m=edge.size();
    G[u].push_back(m-1);
}

void build()
{
    rep(i,0,m-1)
        add(u[i],v[i],d[i],c[i]);
}

void rebuild()
{
    rep(i,0,m-1){
        int v=edge[i].v;
        edge[i].u=sccno[edge[i].u];//自环会在处理into[]时省略
        edge[i].v=sccno[edge[i].v];
        if(edge[i].u!=edge[i].v)
            edge[i].c-=into[v].c;
    }
    root=sccno[root];//更新root、n的值
    _n=scc_cnt;
}

void dfs(int v)//因为into[]里是以终点v记录，所以反向缩点
{
    int u;
    low[v]=pre[v]=dfs_clock++;
    stk[top++]=v;

    u=into[v].u;
    if(u!=root)//!!必不可少
        if(!pre[u]){
            dfs(u);
            low[v]=min(low[v],low[u]);
        }else if(!sccno[u])
            low[v]=min(low[v],pre[u]);

    if(low[v]==pre[v]){
        scc_cnt++;
        do{
            u=stk[--top];
            sccno[u]=scc_cnt;
        }while(u!=v);
    }
}

int find_scc()
{
    scc_cnt=dfs_clock=0;
    clr(pre,0);
    clr(sccno,0);

    top=0;
    rep(i,1,_n)
        if(!pre[i])
            dfs(i);
    return scc_cnt;
}

bool DMST(int lim,int n)
{
    _n=n;

    init();
    build();
    
    int cnt=0;
    while(1)
    {
        clr(mark,0);
        rep(i,0,m-1){
            if(edge[i].d<lim||edge[i].u==edge[i].v)//注意自环
                continue;
            if(!mark[edge[i].v]){
                into[edge[i].v]=(Edge){edge[i].u,edge[i].v,edge[i].d,edge[i].c};
                mark[edge[i].v]=true;
            }else if(into[edge[i].v].c>edge[i].c)
                into[edge[i].v]=(Edge){edge[i].u,edge[i].v,edge[i].d,edge[i].c};
        }
        into[root]=(Edge){root,root,0,0};//处理根

        rep(i,1,_n){//root的序号随缩点改变
            if(i==root)
                continue;
            if(!mark[i]){
                return false;
            }
            cnt+=into[i].c;
        }
        if(cnt>w)
            return false;

        if(find_scc()==_n)//若不成环
            return true;
        else
            rebuild();
    }
}

int main()
{
    int T,n;
    scanf("%d",&T);
    while(T--)
    {
        int up=0,down=INF;
        scanf("%d%d%d",&n,&m,&w);
        root=1;

        rep(i,0,m-1){
            scanf("%d%d%d%d",&u[i],&v[i],&d[i],&c[i]);
            u[i]++;v[i]++;//注意scc_cnt是从1开始的，意味着所有的点都是1~n
            up=max(up,d[i]);
            down=min(down,d[i]);
        }

        if(!DMST(down,n)){
            printf("streaming not possible.
");
            continue;
        }

        int l=down,r=up;
        while(l<r)
        {
            int x=l+(r-l+1)/2;
            if(DMST(x,n))
                l=x;
            else
                r=x-1;
        }
        printf("%d kbps
",l);
    }
    return 0;
}
/*
3
7 15 29
0 1 1 9
0 4 1 5
1 3 1 9
1 2 1 3
2 1 1 7
2 6 1 6
2 5 1 9
3 0 1 3
3 2 1 8
3 5 1 5
4 3 1 4
5 4 1 3
5 6 1 4
6 2 1 4
6 5 1 8
*/