[Algorithm]01分数规划——Update：2012年7月27日
【关键字】
0/1分数规划、最优比率生成树、最优比率环
【背景】
根据楼教主的回忆录，他曾经在某一场比赛中秒掉了一道最优比率生成树问题，导致很多人跟风失败，最终悲剧。
自己总结了一些这种问题的解法，因为水平有限，如果有错误或是麻烦的地方，尽管喷，邮箱或是下方留言。
联系我的话perseawe@163.com，欢迎讨论，请在标题前注明[acm]或是[oi]，以免被垃圾邮件。
【知识储备】
只会用到简单的公式的整理与变形，还有求和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算法，他就是基于这样的一个思想，他并不会去二分答案，而是先随便给定一个答案，然后根据更优的解不断移动答案，逼近最优解。由于他对每次判定使用的更加充分，所以它比二分会快上很多。但是，他的弊端就是需要保存这个解，而我们知道，有时候验证一个解和求得一个解的复杂度是不同的。二分和Dinkelbach算法写法都非常简单，各有长处，大家要根据题目谨慎使用。
【实践】
上面啰嗦了这么多，现在给出程序的框架。
二分法
Repeat
Mid:=(L+R)/2;
For I=1..X do D[i]:=A[i]-Mid*B[i];//根据Mid计算D数组
if 检查（Mid）成功 then L:=Mid else R:=Mid；
Until abs(L-R)<Eps;
Repeat
Ans:=L;
For I=1..X do D[i]:=A[i]-L*B[i];//根据L计算D数组
检查解并记录;
p:=0;q:=0;
for I=每一个元素 do
如果元素I在解中
begin
p:=p+A[i];q:=q+B[i];
end;
L:=p/q;//更新解
Until abs(Ans-L)<Eps;
其中检查解的部分是要看具体情况的。
【例题1Poj2976Dropping tests——普通的01分数规划】
大意：给定A数组B数组，从中选择N-K个使得R最大，输出Round(100*R);
分析：限制很简单，只是数目上有所限制，处理方法也很简单，求出D数组后从大到小排列，从先前向后取N-K个即可，这时的D一定是最大的。
代码：
二分代码 110MS
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.
Dinkelbach代码 32MS2
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比二分好的多。
Dinkelbach代码 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，记录一个负权环还是比较麻烦的，所以二分搞定。
二分代码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了，见谅。>_<
欢迎大家拍砖讨论，具体看背景。
————————————————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日————————————————————————————
这道题就把01分数规划作为一个工具，要求挖掘更加符合这个题目的特性，还是很难的。说实话，这道题是Poj上Usaco题目中最难的一道题目了。
——————————————————————————————————————
你说，我们的存在，永不消逝。对吧？
如果，我们都在努力创造了存在。我们，会幸福的。对吧？
