uva 11865 stream my contest

这明显是一个求最小树形图的题 ， 只不过这个题多了一个限制条件 。
因此问题可转化为：把每条网线的话费做为每条边的权值 ， 而对于最小宽带最大化 ， 可以用二分法来做 。
让确定宽带是多少时 ， 就禁用比这个宽带小的网线 ， 然后再用朱刘算法来求最小花费 ， 如果这个花费大于题目给出的限制那么就失败 ， 否则成功 。


代码：
#include
#include
#include
#include
#include
#include
using namespace std;

const int MAXN = 300;
const int inf = 0x3f3f3f3f ;
struct node
{
      int from , to , b , c;
      node(int from , int to , int b , int c)
      {
            this->from = from ;
            this->to = to;
            this->b = b;
            this->c= c;
      }
};
vectorgrap , grap1;
int pre[MAXN] , min_cost[MAXN];
int cost , n , m , root ;

void init()
{
      grap1.clear();
      memset(pre , 0 , sizeof(pre));
      root = 0;
}


bool solve(int maxb)
{
      long long ret = 0;
      int i;
      grap.clear();
      for(i = 0 ; i < grap1.size(); i++)
            if(grap1[i].b >= maxb)
                  grap.push_back(grap1[i]);
      while(1)
      {
            for(i = 0 ; i < n; i++)  min_cost[i] = inf;
            for(i = 0 ; i < grap.size() ; i++)
            {
                  int u = grap[i].from , v = grap[i].to ;
                  if(grap[i].c < min_cost[v] && u != v)
                  {
                        pre[v] = u;
                        min_cost[v] = grap[i].c;
                  }
            }
            for(i = 0; i < n; i++)
                  if(min_cost[i] == inf && i != root)  return false;
            int cntnode = 0 , vis[MAXN] , done[MAXN];
            memset(vis , -1 , sizeof(vis));
            memset(done , -1 , sizeof(done));
            min_cost[root] = 0;
            for(i = 0 ; i < n; i++)
            {
                  ret += min_cost[i];
                  int v = i;
                  while(vis[v] != i && done[v] == -1 && v != root)
                  {
                        vis[v] = i;
                        v = pre[v];
                  }
                  if(v != root && done[v] == -1)
                  {
                        for(int u = pre[v] ; u != v; u = pre[u])
                              done[u] = cntnode;
                        done[v] = cntnode++;
                  }
            }
           
            if(cntnode == 0)  break;
            for(i = 0 ; i < n; i++)
                  if(done[i] == -1)  done[i] = cntnode++;
            for(i = 0 ; i < grap.size(); i++)
            {
                  int v = grap[i].to ;
                  grap[i].from = done[grap[i].from] ;
                  grap[i].to = done[grap[i].to] ;
                  if(grap[i].from != grap[i].to)      grap[i].c -= min_cost[v];
            }
            n = cntnode;
            root = done[root];
      }
      if(ret <= cost)  return true;
      else return false;
}

int main()
{
      int t;
      cin>>t;
      while(t--)
      {
      //      cout<<endl;
            scanf("%d %d %d" , &n , &m , &cost);
            init();
            int i , x , y , b , c , l = inf , r = 0;
            for(i = 0 ; i < m; i++)
            {
                  scanf("%d %d %d %d" , &x , &y , &b , &c);
                  grap1.push_back(node(x , y , b , c));
                  if(b > r)  r = b;
                  if(b < l)  l = b;
            }
            x = n;
            if(!solve(l))  {printf("streaming not possible.\n");  continue ;}
            while(l < r)
            {
                  n = x;
                  root = 0;
                  int m = l + (r-l+1)/2;
                  if(solve(m)) l = m;
                  else r = m-1;
                 
            }
            printf("%d kbps\n" , l);
      }
      return 0;
}