zoukankan      html  css  js  c++  java

  • 01分数规划(转)

     

    01分数规划

    分类： DP&&记忆化搜索2013-05-04 14:47 4193人阅读 评论(1) 收藏 举报
    【关键字】

    0/1分数规划、最优比率生成树、最优比率环

    【背景】

     根据楼教主的回忆录，他曾经在某一场比赛中秒掉了一道最优比率生成树问题，导致很多人跟风失败，最终悲剧。可见最优比率生成树是多么凶残的东西，但是这个东西只要好好研究半天就可以掌握，相信你在看了我写的这篇总结之后可以像楼教主一般秒掉这类问题。

    因为网上对于01分数规划问题的详细资料并不是太多，所以我就结合自己的一些理解总结这种问题的解法，因为水平有限，如果有错误或是麻烦的地方，尽管喷，邮箱或是下方留言。

    联系我的话perseawe@163.com，欢迎讨论，请在标题前注明[acm]或是[oi]，以免被垃圾邮件。

    【知识储备】

    高考数学能考84分以上的同学...... 因为只会用到公式的整理与变形，还有sigma.别说你连sigma都不会，那就没办法了。

    【定义】

    01分数规划问题：所谓的01分数规划问题就是指这样的一类问题，给定两个数组，a[i]表示选取i的收益，b[i]表示选取i的代价。如果选取i，定义x[i]=1否则x[i]=0。每一个物品只有选或者不选两种方案，求一个选择方案使得R=sigma(a[i]*x[i])/sigma(b[i]*x[i])取得最值，即所有选择物品的总收益/总代价的值最大或是最小。

    01分数规划问题主要包含一般的01分数规划、最优比率生成树问题、最优比率环问题等。我们将会对这三个问题进行讨论。

    永远要记得，我们的目标是使R取到最值，本文主要讨论取到最大值的情况。这句话我会在文中反复的强调。

    【一些分析】 

     数学分析中一个很重要的方法就是分析目标式，这样我们来看目标式。

    R=sigma(a[i]*x[i])/sigma(b[i]*x[i])

    我们来分析一下他有什么性质可以给我们使用。

    我们先定义一个函数F(L):=sigma(a[i]*x[i])-L*sigma(b[i]*x[i])，显然这只是对目标式的一个简单的变形。分离参数，得到F(L):=sigma((a[i]-L*b[i])*x[i])。这时我们就会发现，如果L已知的话，a[i]-L*b[i]就是已知的，当然x[i]是未知的。记d[i]=a[i]-L*b[i]，那么F(L):=sigma(d[i]*x[i])，多么简洁的式子。我们就对这些东西下手了。

    再次提醒一下，我们的目标是使R取到最大值。

    我们来分析一下这个函数，它与目标式的关系非常的密切，L就是目标式中的R，最大化R也就是最大化L。

    F的值是由两个变量共同决定的，即方案X和参数L。对于一个确定的参数L来说，方案的不同会导致对应的F值的不同，那么这些东西对我们有什么用呢?

    假设我们已知在存在一个方案X使得F(L)>0，这能够证明什么?

    F(L)=sigma(a[i]*x[i])-L*sigma(b[i]*x[i])>0即sigma(a[i]*x[i])/sigma(b[i]*x[i])>L也就是说，如果一个方案使得F(L)>0说明了这组方案可以得到一个比现在的L更优的一个L，既然有一个更优的解，那么为什么不用呢？

    显然，d数组是随着L的增大而单调减的。也就是说，存在一个临界的L使得不存在一种方案，能够使F(L)>0. 我们猜想，这个时候的L就是我们要求的最优解。之后更大的L值则会造成无论任何一种方案，都会使F(L)<0.类似于上面的那个变形，我们知道，F(L)<0是没有意义的，因为这时候的L是不能够被取得的。当F(L)=0使，对应方案的R值恰好等于此时的L值。

     综上，函数F(L)有这样的一个性质：在前一段L中可以找到一组对应的X使得F(L)>0，这就提供了一种证据，即有一个比现在的L更优的解，而在某个L值使，存在一组解使得F(L)=0,且其他的F(L)<0，这时的L无法继续增大，即这个L就是我们期望的最优解，之后的L会使得无论哪种方案都会造成F(L)<0.而我们已经知道，F(L)<0是没有任何意义的，因为此时的L值根本取不到。

    最后一次提醒，我们的目标是R！！！ 

    如果现在你觉得有些晕的话，那么我要提醒你的就是，千万不要把F值同R值混淆。F值是根据我们的变形式求的D数组来计算的，而R值则是我们所需要的真实值，他的计算是有目标式决定的。F值只是提供了一个证据，告诉我们真正最优的R值在哪里，他与R值本身并没有什么必然的联系。

    根据这样的一段性质，很自然的就可以想到二分L值，然后验证是否存在一组解使得F(L)>0，有就移动下界，没有就移动上界。

     所有的01分数规划都可以这么做，唯一的区别就在于求解时的不同——因为每一道题的限制条件不同，并不是每一个解都是可行解的。比如在普通的数组中，你可以选取1、2、3号元素，但在生成树问题中，假设1、2、3号元素恰好构成了一个环，那就不能够同时选择了，这就是需要具体问题，具体分析的部分。

    二分是一个非常通用的办法，但是我们来考虑这样的一个问题，二分的时候我们只是用到了F(L)>0这个条件，而对于使得F(L)>0的这组解所求到的R值没有使用。因为F(L)>0,我们已经知道了R是一个更优的解，与其漫无目的的二分，为什么不将解移动到R上去呢？求01分数规划的另一个方法就是

    ，他就是基于这样的一个思想，他并不会去二分答案，而是先随便给定一个答案，然后根据更优的解不断移动答案，逼近最优解。由于他对每次判定使用的更加充分，所以它比二分会快上很多。但是，他的弊端就是需要保存这个解，而我们知道，有时候验证一个解和求得一个解的复杂度是不同的。二分和Dinkelbach算法写法都非常简单，各有长处，大家要根据题目谨慎使用。

    【实践】

    上面啰嗦了这么多，现在给出程序的框架。

    [plain] view plaincopy
    1. 二分法  
    2. L:=...;R:=...;  
    3. Repeat  
    4.   Mid:=(L+R)/2;  
    5.   For I=1..X do D[i]:=A[i]-Mid*B[i];//根据Mid计算D数组  
    6.   if 检查（Mid）成功 then L:=Mid else R:=Mid；  
    7.   
    8. Until abs(L-R)<Eps;      
    Dinkelbach算法
    [plain] view plaincopy
    1. L:=随便什么东西;  
    2. Repeat  
    3.   Ans:=L;  
    4.   For I=1..X do D[i]:=A[i]-L*B[i];//根据L计算D数组  
    5.   检查解并记录;  
    6.   p:=0;q:=0;  
    7.   for I=每一个元素 do   
    8.      如果元素I在解中  
    9.         begin  
    10.           p:=p+A[i];q:=q+A[i];  
    11.         end;  
    12.   L:=p/q;//更新解  
    13. Until abs(Ans-L)<Eps;  

    其中检查解的部分是要看具体情况的。

    【例题1Poj2976Dropping tests——普通的01分数规划】

    大意：给定A数组B数组，从中选择N-K个使得R最大，输出Round(100*R);

    分析：限制很简单，只是数目上有所限制，处理方法也很简单，求出D数组后从大到小排列，从先前向后取N-K个即可，这时的D一定是最大的。

    代码：

    [vb] view plaincopy
    1. 二分代码 110MS 1 //10147353      perseawe        2976    Accepted        896K    110MS   Pascal  1517B   2012-05-03 10:09:47  
    2.    
    3.  Const  
    4.    Eps=1e-6;  
    5.    
    6.  Var  
    7.    n,k:Longint;  
    8.    Ans:Double;  
    9.    a,b,c:Array [0..1000+100] of Longint;  
    10.    d:Array [0..1000+100] of Double;  
    11.    
    12.  Procedure Init;  
    13.    var  
    14.      i:longint;  
    15.    begin  
    16.      readln(n,k);  
    17.      if (n=0)and(k=0) then Halt;  
    18.      for i:=1 to n do read(a[i]);readln;  
    19.      for i:=1 to n do read(b[i]);readln;  
    20.    end;  
    21.    
    22.  procedure swap(var a,b:Longint);var t:Longint;begin t:=a;a:=b;b:=t;end;  
    23.  procedure swap(var a,b:double);var t:Double;begin t:=a;a:=b;b:=t;end;  
    24.    
    25.  Procedure Qsort(l,r:Longint);  
    26.    var  
    27.      a,b:Longint;  
    28.      mid:Double;  
    29.    begin  
    30.      a:=l;b:=r;mid:=d[(l+r) shr 1];  
    31.      repeat  
    32.        while d[a]>mid do inc(a);  
    33.        while d[b]<mid do dec(b);  
    34.        if a<=b then  
    35.          begin  
    36.            swap(d[a],d[b]);  
    37.            swap(c[a],c[b]);  
    38.            inc(a);dec(b);  
    39.          end;  
    40.      until a>=b;  
    41.      if a<r then qsort(a,r);  
    42.      if l<b then qsort(l,b);  
    43.    end;  
    44.    
    45.  Procedure Main;  
    46.    var  
    47.      m,i:Longint;  
    48.      L,R,Mid,tmp:Double;  
    49.    begin  
    50.      //2'  
    51.      m:=n-k;  
    52.    
    53.      Mid:=0;  
    54.      for i:=1 to n do if a[i]/b[i]>Mid then Mid:=a[i]/b[i];  
    55.      L:=0;R:=Mid;  
    56.    
    57.      Repeat  
    58.        Mid:=(L+R)/2;  
    59.        for i:=1 to n do begin d[i]:=a[i]-Mid*b[i];c[i]:=i;end;  
    60.        Qsort(1,n);  
    61.        tmp:=0;  
    62.        for i:=1 to m do tmp:=tmp+d[i];  
    63.        if tmp>0 then L:=Mid else R:=Mid;  
    64.      Until abs(L-R)<Eps;  
    65.      Ans:=L;  
    66.    end;  
    67.    
    68.  Procedure Print;  
    69.    begin  
    70.      writeln(Round(Ans*100));  
    71.    end;  
    72.    
    73.  Begin  
    74.    While True Do  
    75.      begin  
    76.        Init;  
    77.        Main;  
    78.        Print;  
    79.      end;  
    80.  End.  
    [vb] view plaincopy
    1. Dinkelbach代码 32MS 1 //10147329      perseawe        2976    Accepted        896K    32MS    Pascal  1455B   2012-05-03 10:02:32  
    2.    
    3.  Const  
    4.    Eps=1e-6;  
    5.    
    6.  Var  
    7.    n,k:Longint;  
    8.    Ans:Double;  
    9.    a,b,c:Array [0..1000+100] of Longint;  
    10.    d:Array [0..1000+100] of Double;  
    11.    
    12.  Procedure Init;  
    13.    var  
    14.      i:longint;  
    15.    begin  
    16.      readln(n,k);  
    17.      if (n=0)and(k=0) then Halt;  
    18.      for i:=1 to n do read(a[i]);readln;  
    19.      for i:=1 to n do read(b[i]);readln;  
    20.    end;  
    21.    
    22.  procedure swap(var a,b:Longint);var t:Longint;begin t:=a;a:=b;b:=t;end;  
    23.  procedure swap(var a,b:double);var t:Double;begin t:=a;a:=b;b:=t;end;  
    24.    
    25.  Procedure Qsort(l,r:Longint);  
    26.    var  
    27.      a,b:Longint;  
    28.      mid:Double;  
    29.    begin  
    30.      a:=l;b:=r;mid:=d[(l+r) shr 1];  
    31.      repeat  
    32.        while d[a]>mid do inc(a);  
    33.        while d[b]<mid do dec(b);  
    34.        if a<=b then  
    35.          begin  
    36.            swap(d[a],d[b]);  
    37.            swap(c[a],c[b]);  
    38.            inc(a);dec(b);  
    39.          end;  
    40.      until a>=b;  
    41.      if a<r then qsort(a,r);  
    42.      if l<b then qsort(l,b);  
    43.    end;  
    44.    
    45.  Procedure Main;  
    46.    var  
    47.      p,q:Int64;  
    48.      m,i:Longint;  
    49.      L:Double;  
    50.    begin  
    51.      //Dinkelbach  
    52.      m:=n-k;  
    53.      l:=1;  
    54.      Repeat  
    55.        Ans:=L;  
    56.        for i:=1 to n do begin d[i]:=a[i]-L*b[i];c[i]:=i;end;  
    57.        Qsort(1,n);  
    58.        p:=0;q:=0;  
    59.        for i:=1 to m do  
    60.          begin  
    61.            inc(p,a[c[i]]);  
    62.            inc(q,b[c[i]]);  
    63.          end;  
    64.        L:=p/q;  
    65.      Until abs(L-Ans)<Eps;  
    66.    end;  
    67.    
    68.  Procedure Print;  
    69.    begin  
    70.      writeln(Round(Ans*100));  
    71.    end;  
    72.    
    73.  Begin  
    74.    While True Do  
    75.      begin  
    76.        Init;  
    77.        Main;  
    78.        Print;  
    79.      end;  
    80.  End.  

    另外：如果是最小选择N-K个怎么办？        办法是一样的，从大到小排列序，傻子才多选，能少选就少选。反正F值具体的大小没什么关系，我们只要知道他与0的关系即可。

    【例题2Poj2728Desert King——最优比率生成树】

    大意：给定一张图，每条边有一个收益值和一个花费值，求一个生成树，要求花费/收益最小，输出这个值

    分析：现在的限制就有点复杂了，要求解必须是一棵生成树。而且这道题目要求的花费/收益最小，当然你求收益/花费最大然后反过来也是可以的，注意处理花费为0的情况。如果求最小的，处理方法是也类似的，先求个D，然后做一次最小生成树，显然得到的就是函数值。不过这道题用Dinkelbach比二分好的多。

    [vb] view plaincopy
    1. Dinkelbach代码  1 //10148420      perseawe        2728    Accepted        916K    407MS   Pascal  1560B   2012-05-03 16:03:10  
    2.    
    3.  Const  
    4.    Eps=1e-6;  
    5.    MaxN=1000+100;  
    6.    
    7.  Var  
    8.    n:Longint;  
    9.    ans:Double;  
    10.    x,y,h:Array [0..MaxN] of Longint;  
    11.    Use:Array [0..MaxN] of Boolean;  
    12.    a,b,d:Array [0..MaxN] of Double;  
    13.    
    14.  Procedure Init;  
    15.    var  
    16.      i:Longint;  
    17.    begin  
    18.      readln(n);  
    19.      if n=0 then Halt;  
    20.      for i:=1 to n do readln(x[i],y[i],h[i]);  
    21.    end;  
    22.    
    23.  Procedure Main;  
    24.    var  
    25.      i,m,pos:Longint;  
    26.      L,tmp,ta,tb,p,q:Double;  
    27.    begin  
    28.      L:=0;  
    29.      Repeat  
    30.        Ans:=L;  
    31.        //Prim  
    32.        Fillchar(Use,sizeof(Use),False);Use[1]:=True;  
    33.        For i:=2 to n do  
    34.          begin  
    35.            a[i]:=abs(h[i]-h[1]);  
    36.            b[i]:=sqrt(sqr(x[i]-x[1])+sqr(y[i]-y[1]));  
    37.            d[i]:=a[i]-L*b[i];  
    38.          end;  
    39.        m:=1;p:=0;q:=0;  
    40.        While m<n do  
    41.          begin  
    42.            tmp:=1000000000;  
    43.            for i:=2 to n do  
    44.              if not(Use[i])and(d[i]<tmp) then  
    45.                begin  
    46.                  tmp:=d[i];pos:=i;  
    47.                end;  
    48.            Use[pos]:=true;p:=p+a[pos];q:=q+b[pos];  
    49.            for i:=2 to n do  
    50.              if not(Use[i]) then  
    51.                begin  
    52.                  ta:=abs(h[i]-h[pos]);tb:=sqrt(sqr(x[i]-x[pos])+sqr(y[i]-y[pos]));  
    53.                  if ta-L*tb<d[i] then  
    54.                    begin  
    55.                      d[i]:=ta-L*tb;  
    56.                      a[i]:=ta;b[i]:=tb;  
    57.                    end;  
    58.                end;  
    59.            Inc(m);  
    60.          end;  
    61.        L:=p/q;  
    62.      Until abs(L-Ans)<Eps;  
    63.    end;  
    64.    
    65.  Procedure Print;  
    66.    begin  
    67.      writeln(ans:0:3);  
    68.    end;  
    69.    
    70.  Begin  
    71.    while True Do  
    72.      begin  
    73.        Init;  
    74.        Main;  
    75.        Print;  
    76.      end;  
    77.  End.  

     最小生成树用了Prim，只要不是实在没办法，还是不要在稠密图特别是完全图上用Kruskal吧。

    【例题3Poj3621Sightseeing Cows——最优比率环】 

    大意：给定一张图，边上有花费，点上有收益，点可以多次经过，但是收益不叠加，边也可以多次经过，但是费用叠加。求一个环使得收益和/花费和最大，输出这个比值。

    分析：比上面更加的恶心了。先不说环的问题，就是花费和收益不在一处也令人蛋疼。这时候需要用到几个转化和结论。

         首先的一个结论就是，不会存在环套环的问题，即最优的方案一定是一个单独的环，而不是大环套着小环的形式。这个的证明其实非常的简单，大家可以自己想一下（提示，将大环上的收益和记为x1,花费为y1，小环上的为x2,y2。重叠部分的花费为S。表示出来分类讨论即可）。有了这个结论，我们就可以将花费和收益都转移到边上来了，因为答案最终一定是一个环，所以我们将每一条边的收益规定为其终点的收益，这样一个环上所有的花费和收益都能够被正确的统计。

         解决了蛋疼的问题之后，就是01分数规划的部分了，我们只需要计算出D数组后找找有没有正权环即可，不过这样不太好，不是我们熟悉的问题，将D数组全部取反之后，问题转换为查找有没有负权环，用spfa或是bellman_ford都可以。这道题目就是典型的不适合用Dinkelbach，记录一个负权环还是比较麻烦的，所以二分搞定。

    [vb] view plaincopy
    1. 二分代码 1 //10148804      perseawe        3621    Accepted        1000K   422MS   Pascal  1239B   2012-05-03 17:17:40  
    2.    
    3.  Const  
    4.    Eps=1e-6;  
    5.    MaxNode=1000+100;  
    6.    MaxEdge=5000+500;  
    7.    
    8.  Var  
    9.    Ans:Double;  
    10.    n,m:Longint;  
    11.    a:Array [0..MaxNode] of Longint;  
    12.    dis:array [0..MaxNode] of Double;  
    13.    b,u,v:Array [0..MaxEdge] of Longint;  
    14.    d:Array [0..MaxEdge] of Double;  
    15.    
    16.  Procedure Init;  
    17.    var  
    18.      i:Longint;  
    19.    begin  
    20.      readln(n,m);  
    21.      for i:=1 to n do readln(a[i]);  
    22.      for i:=1 to m do readln(u[i],v[i],b[i]);  
    23.    end;  
    24.    
    25.  Function Bellman_Ford(L:Double):Boolean;  
    26.    var  
    27.      i,j:Longint;  
    28.      Flag:Boolean;  
    29.    begin  
    30.      for i:=1 to m do d[i]:=-(a[v[i]]-L*b[i]);  
    31.      for i:=1 to n do dis[i]:=0;  
    32.      for i:=1 to n do  
    33.        begin  
    34.          Flag:=False;  
    35.          for j:=1 to m do  
    36.            if Dis[u[j]]+d[j]<Dis[v[j]] then  
    37.              begin  
    38.                Dis[v[j]]:=Dis[u[j]]+d[j];  
    39.                Flag:=True;  
    40.              end;  
    41.          If not(Flag) then Exit(False);  
    42.        end;  
    43.      Exit(True);  
    44.    end;  
    45.    
    46.  Procedure Main;  
    47.    var  
    48.      L,R,Mid:Double;  
    49.    begin  
    50.      L:=0;R:=20000;  
    51.      Repeat  
    52.        Mid:=(L+R)/2;  
    53.        if Bellman_Ford(Mid) then L:=Mid else R:=Mid;  
    54.      Until abs(L-R)<Eps;  
    55.      Ans:=L;  
    56.    end;  
    57.    
    58.  Procedure Print;  
    59.    begin  
    60.      if Ans>Eps then writeln(Ans:0:2) else writeln(0);  
    61.    end;  
    62.    
    63.  Begin  
    64.    Init;  
    65.    Main;  
    66.    Print;  
    67.  End.  

    因为图省事，所以用了Bellman_Ford。还有就是注意无解的判断，无解时检查会一直不成功的，你懂的。

    【后记】

    本来Zoj上还有一道题的，时间不够了就先放过去吧，但是常见的三种01规划我都已经列举到了并给出了常见的处理手段。

    算法运用之妙,存乎一心也。数学是最神奇的。强烈建议大家学好数学！

    本来还有一个例题0和一个非常巧妙的数学证明的，但是发觉没有什么太大的意义，就省略掉了。大意就是给定A数组和B数组（A、B的元素值都大于0），最小取一个，求最大的R值。显然直接计算所有的A[i]/B[i]取最大值就可以，因为两个分数分子分母对应相加得到的结果一定是小于较大的那个。具体的证明很简单，分类讨论即可。

    另一个被我省略的部分就是对Dinkelbach算法的分析，这需要更强的数学分析才行，因为这并不是重点，所以我将其省略掉了。如果有兴趣的同学可以找一下一篇叫做《对于0-1分数规划的Dinkelbach算法的分析》，由武钢三中 吴豪[译]的一篇文章看一下。

    最后感谢网上很多大牛的题解和心得，特别是This_poet的题解，第一二题中参考了她的代码，几乎已经是Copy了，见谅。>_<

    欢迎大家拍砖讨论，具体看背景。http://www.haogongju.net/art/1426981

    ————————————————Update：2012年5月10日——————————————

    【例题4Poj3155——Hard Life最大密度子图】

    大意：给定G=(V,E)求其中的一个子图使得边数/点数最大

    分析：详见《最小割模型在信息学竞赛中的应用》作者胡伯涛。 

     ————————————————Update：2012年6月19日——————————————

    【例题5Zoj2676——Network Wars】 

    大意：给定一张图，规定一个割的平均值是边权和/边数.求平均值最小的割.

    分析：非常显然，因为是求最小，所以只要对于某个L值，解空间中最小的一组解满足g(x)=0即可。于是，二分L后改变权值求解最小割。但是会出现负权的情况，这里需要特殊处理。负权是一定会出现在解中的，遇到负权直接加上即可。如果最小割<0则L增大,反之减少.还有就是注意精度的问题，小心处理。

     【例题6游戏——最大密度子图变种】

    大意：给定N个人，可以选择任意多个人，记为K。单个人是没有战斗力的，必须要合体才有战斗力（大雾），给定所有的Aij表示当选择方案同时出现i和j两个人时的战斗力加成。特殊的Aii=0。但是选择人不是没有代价的，代价是k*(200-k).定义这个方案的评分=sigma(A[i,j]|if i,j both selected)/(k*(200-k))。要求最大化评分。

     N<=50...也就是满足选择的人越多代价越多.

    分析：显然是一个最大密度子图的模型。但是与一般的模型中，表达式中的分母不仅仅含有点数，更含有一个点数的平方。这是令人非常难受的。问题的核心就在于如何将这个平方蕴含到图里面去。观察到这个图非常的特殊，当选择一些点时，这些点构成的子图是一个完全图，即边数是K*(K-1)/2.哈哈，这里也有一个K的平方，于是问题得以解决了。二分L后整理表达式，将分母上的K的平方蕴含到边权上去。这样就可以转化为一般的最大密度子图。

    【一些理解】

    从这篇文章写出来到现在也已经很长时间了，对01分数规划问题也有了很多新的看法。

    以下是一些个人的理解，很有可能存在错误。大家帮忙看看有没有问题。

    01分数规划问题求最值，但是最值有两种，一种是最大值，一种是最小值。

    在我看来，对于每一个L。我们先假定L是确定了的，这时问题还会有很多的方案，每一个方案有其评估值。我们求最小值时是找这样的一个L:所有的合法方案中，只有唯一的一个方案评估值为0，其他的方案评估值都>0.而最大值恰好相反，即也是只有唯一的一个方案评估值为0，但是其他的方案评估值都<0.

    在上面的推导中，我已经说过了，当存在评估值>0的方案时，说明L是可以增大的。因为计算方案对应的原始表达式值计算出的L'一定是大于L的，同理，而评估值<0的方案则是不优的。

    虽然题目要求的东西会不同，生成树呀，割呀，子图之类的呀。但是我觉得上面的这个东西是一个通用的玩意，是01分数规划本身决定的，而不是题目决定的。我现在还是有一个概念不是特别明白。先写到这里，欢迎讨论。

    ————————————————Update：2012年7月27日————————————————————————————

     【例题7Poj3266——CowSchool0/1分数规划+数据结构】
    大意:(From applepi)
    Bessie考了N科（N≤50000），每科的得分为Ti，满分为Pi（样例似乎是五科红灯……）。现在Bessie的老师要给她们统计最终得分，方法 是先算出每一科得分的百分比，去除D个百分比最低的科目，然后剩下科目的∑T / ∑P就是最终得分的百分比。很幸运，没有人有两科的得分比一样。Bessie的数学很牛X，她马上就发现她的老师在坑爹，因为有时候可以通过去除不同的科 目来获得更高的分数。现在Bessie想知道，对于哪些D值，她可以通过去除与老师不同的D科，从而获得更高的分数呢？
    题解：显然,Bessie的老师没有看过这篇文章(>_<)。要不他（她）就不会犯这么意识流的问题了。现在题目要求我们给出一个"证据"来证明那些D老师的做法并不是最优的.由上面的一些结论，我们可以知道，只要我们能够找到在老师给定的百分比下的一组解，其值>0即可,这就证明了存在一个百分比要优于老师的解.这时我们可以用一个巧妙的转化,显然,老师选定的解在加权之后的和一定是0.那么,一个简单的构造方法是找出老师选定中的最小加权值以及没选定的中最大的加权值,如果后者大于前者,那么显然将前者更换为后者得到的解值>0，说明存在更优的解。然后这样的一个问题可以把每一个分数看做平面上的一个点，用平衡树维护凸壳或是充分挖掘单调性后使用栈和队列来维护都是可以快速的完成查找操作的。具体见applepi的题解就好。

    这道题就把01分数规划作为一个工具，要求挖掘更加符合这个题目的特性，还是很难的。说实话，这道题是Poj上Usaco题目中最难的一道题目了。 

    —————————————————————————————————————— 

    你说，我们的存在，永不消逝。对吧？

    如果，我们都在努力创造了存在。我们，会幸福的。对吧？

    转载地址：http://www.cnblogs.com/perseawe/archive/2012/05/03/01fsgh.html
  • 相关阅读:
    cf D. Vessels
    cf C. Hamburgers
    zoj 3758 Singles' Day
    zoj 3777 Problem Arrangement
    zoj 3778 Talented Chef
    hdu 5087 Revenge of LIS II
    zoj 3785 What day is that day?
    zoj 3787 Access System
    判断给定图是否存在合法拓扑排序
    树-堆结构练习——合并果子之哈夫曼树
  • 原文地址：https://www.cnblogs.com/handsomecui/p/4964249.html
Copyright © 2011-2022 走看看