【模板】0/1分数规划

参考题目：POJ2976

---

解析：

1.分数规划

分数规划的一般形式：
$$min\lambda =f(\text{x})=\frac{a(\text{x})}{b(\text{x})}(x\in S)$$
其中，解向量$\text{x}$在解空间$S$内，$a(x),b(x)$都是连续的实值函数。

设${\lambda }^{\ast }=f(x^{\ast })$为该规划最优解，有
$${\lambda }^{\ast }=f(x^{\ast })=\frac{a(x^{\ast })}{b(x^{\ast })}$$
则
$${\lambda }^{\ast }\ast b(x^{\ast })=a(x^{\ast })$$
于是，我们有
$$a(x^{\ast })-{\lambda }^{\ast }\ast b(x^{\ast })=0$$

我们构造函数$g(\lambda )=min(a(x)-\lambda \ast b(x))$

证明其满足单调性：
即证明对于$\forall {\lambda }_1<{\lambda }_2$，都有$g({\lambda }_1)>g({\lambda }_2)$。
证明：
设当$g({\lambda }_1)$取到最小值时，$\text{x}={\text{x}}_1$
$$g({\lambda }_1)=\underset{\text{x}\in S}{\min }(a(\text{x})-{\lambda }_1\ast b(\text{x}))$$$$=a({\text{x}}_1)-{\lambda }_1\ast b({\text{x}}_1)$$$$>a({\text{x}}_1)-{\lambda }_2\ast b({\text{x}}_1)$$$$\ge \underset{\text{x}\in S}{\min }(a(\text{x})-{\lambda }_2\ast b(\text{x}))$$$$=g({\lambda }_2)$$

由此看来，我们就可以二分$\lambda$然后计算$g(\lambda )$,不断逼近最终的准确解。

然而，我们还有一种快得多的方法
接下来，隆重介绍$Dinkelbach$迭代法：

$DinkelBach$定理

定理内容：设原规划解为${\lambda }^{\ast }$,则上述函数$g(\lambda )=0$当且仅当$\lambda ={\lambda }^{\ast }$。
是不是很简短？（然而接下来并不会用）

考虑每一次二分出的答案$\lambda$和验证出的函数$g(\lambda )$能不能再被利用。
考虑对于一个确定的向量$\text{x}$，我们考虑函数$f_x(\lambda )=a(x)-\lambda \ast b(x)$，显然这是一个一次函数（废话）。那么这个函数的横截距。。。是不是就可以利用一下。

于是我们每次将答案更新至新的横截距处，继续验证新的函数的横截距，要是横截距相等.。。
那么我们就已经找到最优$x$向量使得$f_x$的横截距最大，因为已经不能继续靠近真实值了。
即我们已经找到最优的答案

2,0/1分数规划

看懂上面那个这个自然就会了。

---

UPDATE:

今天班长又来问我$0/1$分数规划，感觉很多人可能存在一个误区，这里略作解释。

规划问题有两种，求解最大值或最小值，而这两种的区别不是在于上下界的调整或者是什么其他的问题。

其实我们最终的目的就是求解$g({\lambda }^{\ast })=0$
求解这两种问题的二分形式是一样的，对于二分到的解，我们会验证得出一个$g(\lambda )$，我们调整二分上下界的依据就是这个$g(\lambda )$是否大于$0$。

1、$g(\lambda )>0$的情况。求最大值的时候说明我们可以得到一个更大的解，求最小值的时候说明实际规划中不可能得到当前解，结论都是下界上移，
2、$g(\lambda )<0$的情况。求最小值的时候说明我们可以得到一个更小的解，求最大值的时候说明实际规划中不可能得到当前解，结论：上界下移。

所以二分的构架是一样的，区别只是在于$check$里面的东西。
$check$才是体现究竟求最大值还是最小值的地方。

但是用$DinkelBach$就不会有这种问题。。。

---

代码(二分)：

#include<cstdio>
#include<cctype>
#include<algorithm>
using namespace std;
#define ll long long
#define re register
#define gc getchar
#define pc putchar
#define cs const
#define st static

inline
ll getint(){
	re ll num=0;
	re char ch;
	for(ch=gc();!isdigit(ch);ch=gc());
	for(num=0;isdigit(ch);ch=gc())num=(num<<1)+(num<<3)+(ch^48); 
	return num;
}

inline
double max(cs double &a,cs double &b){
	return a<b?b:a;
}

inline
double min(cs double &a,cs double &b){
	return a<b?a:b;
}

ll a[1002],b[1002];
int n,k;
double c[1002];

inline
bool check(double x){
	double ans=0.0;
	for(int re i=1;i<=n;++i){
		c[i]=(double)a[i]-b[i]*x;
	}
	sort(c+1,c+n+1);
	for(int re i=n;i>k;--i){
		ans+=c[i];
	}
	return ans>0;
}

int main(){
	while(true){
		n=getint();
		k=getint();
		if(n==0&&k==0)return 0;
		for(int re i=1;i<=n;++i)a[i]=getint();
		for(int re i=1;i<=n;++i)b[i]=getint();
		double l=0,r=1.0;
		while(l+1e-4<r){
			double mid=(l+r)/2;
			if(check(mid))l=mid;
			else r=mid;
		}
		printf("%.0lf\n",l*100);
	}
	return 0;
} 

代码($Dinkelbach$迭代)：

#include<cstdio>
#include<cctype>
#include<algorithm>
#include<cmath>
using namespace std;
#define ll long long
#define re register
#define gc getchar
#define pc putchar
#define cs const
#define st static

inline
ll getint(){
	re ll num=0;
	re char ch;
	for(ch=gc();!isdigit(ch);ch=gc());
	for(num=0;isdigit(ch);ch=gc())num=(num<<1)+(num<<3)+(ch^48); 
	return num;
}

struct node{
	int a,b;
	double d;
	friend bool operator<(cs node &a,cs node &b){
		return a.d<b.d;
	}
};

node q[1001];

int n,k;
double ans,L;

int main(){
	while(true){
		n=getint();
		k=getint();
		if(n==0&&k==0)return 0;
		for(int re i=1;i<=n;++i)q[i].a=getint();
		for(int re i=1;i<=n;++i)q[i].b=getint();
		while(true){
			L=ans;
			for(int re i=1;i<=n;++i)q[i].d=(double)q[i].a-L*q[i].b;
			sort(q+1,q+n+1);
			double x=0,y=0;
			for(int re i=n;i>k;--i){
				x+=q[i].a;
				y+=q[i].b;
			}
			ans=x/y;
			if(fabs(ans-L)<=1e-4)break;
		}
		printf("%.0lf\n",ans*100);
	}
	return 0;
}