01分数规划的理解以及练习poj2976 poj 3621 poj 2728

最新推荐文章于 2023-06-15 16:42:19 发布
最新推荐文章于 2023-06-15 16:42:19 发布
阅读量3.1k 收藏 2
点赞数
分类专栏： 数学 poj 文章标签： distance struct c 算法 图形 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lawrence_jang/article/details/8048278
版权



              01 分数规划的思想的描述如下：令 c=(c1,c2,…,cn) 和 d=(d1,d2,…,dn) 为 n 维整数向量，那么一个 0-1 分数规划问题用公式描述如下 :FP:  最小化或者最大化 (c1x1+…cnxn)/(d1x1…dnxn)=cx/dx xi∈{0,1}。这个问题的解决已经有了成形的算法，但是网上的解释大多过难难以直接理解，大部分对于数学基础的要求是很高的。

            先说说这种思想能够解决哪些问题 1：裸的01分数规划pku2976适合刚刚学习的练手以及试模板 2：01分数规划与图形的结合比如说环的判断pku3621 比如最优比例生成树pku2728 解决的思想大致一样 关键是对结论的简要证明，加深理解，然后灵活的运用。

           下面谈谈解决01分数规划的方法以及结论

           首先，假设要c*x/d*x最大（x，c，d均指向量），假设最优解为 val，设置这样的子问题，z(L)=c*x-d*x*L 分配x向量使 z最大，那么可以知道 如果c*x-L*x*d<0 那么无论怎么分配x向量都无法满足L值即val必然小于L 同样 我们看大于0的情况 这个时候说明可以分配x使得目标解大于L那么val必然大于L，那么很显然 L=val的时候c*x-d*x*L=0，并且z的值具有单调性下面是证明    

             设L1,L2,且L1>L2
   z(L1) = max { c*x-L1*d*x } = c*x1-L1*d*x1(x1是使得其最大的向量) <c*x1-L2*d*x1≤ max{ c*x-d*x*L2 } = z(L2)

   =>     z(l)是关于L的单调递减函数。

因此我们可以用二分或者迭代来解决

       这里只是简单的证明并没有很严格的证明 但是对于使用来讲已经足够。

      下面具体使用结论来解决上面的三道例子；

        pku2976   很直接的一道题 题意就是简单01分数规划

     来说说做法 由于题目已经告诉我们去掉K个x，我们要使得分数最高，设置子问题 z,根据上面的公式很容易写出程序。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<vector>
#include<sstream>
#include<string>
#include<climits>
#include<stack>
#include<set>
#include<bitset>
#include<cmath>
#include<deque>
#include<map>
#include<queue>
#define iinf 2000000000
#define linf 1000000000000000000LL
#define dinf 1e200
#define eps 1e-6
#define all(v) (v).begin(),(v).end()
#define sz(x)  x.size()
#define pb push_back
#define mp make_pair
#define lng long long
#define sqr(a) ((a)*(a))
#define pii pair<int,int>
#define pll pair<lng,lng>
#define pss pair<string,string>
#define pdd pair<double,double>
#define X first
#define Y second
#define pi 3.14159265359
#define ff(i,xi,n) for(int i=xi;i<=(int)(n);++i)
#define ffd(i,xi,n) for(int i=xi;i>=(int)(n);--i)
#define ffl(i,r) for(int i=head[r];i!=-1;i=edge[i].next)
#define cc(i,j) memset(i,j,sizeof(i))
#define two(x)			((lng)1<<(x))
#define N 555555
#define M 1000000
#define lson l , mid , rt << 1
#define rson mid + 1 , r , rt << 1 | 1
#define Mod  n
#define Pmod(x) (x%Mod+Mod)%Mod
using namespace std;
typedef vector<int>  vi;
typedef vector<string>  vs;
typedef unsigned int uint;
typedef unsigned lng ulng;
template<class T> inline void checkmax(T &x,T y)
{
    if(x<y) x=y;
}
template<class T> inline void checkmin(T &x,T y)
{
    if(x>y) x=y;
}
template<class T> inline T Min(T x,T y)
{
    return (x>y?y:x);
}
template<class T> inline T Max(T x,T y)
{
    return (x<y?y:x);
}
template<class T> T gcd(T a,T  b)
{
    return (a%b)==0?b:gcd(b,a%b);
}
template<class T> T lcm(T a,T b)
{
    return a*b/gcd(a,b);
}
template<class T> T Abs(T a)
{
    return a>0?a:(-a);
}
using namespace std;
struct node
{
    int x,y;
} a[1005];
double low,high,mid;
int cmp(node bb,node cc)
{
    return mid*bb.y-bb.x<mid*cc.y-cc.x;
}
int main()
{
    int n,k;
    double sub,par,res,ans;
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        if(n==0&&k==0) break;
        int i,j;
        for(i=0; i<n; i++)           scanf("%d",&a[i].x);
        for(i=0; i<n; i++)           scanf("%d",&a[i].y);
        low=0;
        high=1000;
        ans=0;
        while(low+eps<high)
        {
            mid=(low+high)/2.0;
            sort(a,a+n,cmp);
            sub=par=0;
            for(i=0; i<n-k; i++)
            {
                sub+=a[i].x;
                par+=a[i].y;
            }
            ans=sub/par;
            res=mid*par-sub;
            if(res<0) low=mid;
            else high=mid;
        }
        printf("%.0lf\n",100*ans);
    }
    return 0;
}



pku3621 这道题是要求一个最大（边权和/点权和)的环 同样设置子问题 边权-点权*L最大的回路，如果存在并大于0 r=mid 可以直接用spfa的判环 将权编程负值然后判断有没有负环即可 


#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<vector>
#include<sstream>
#include<string>
#include<climits>
#include<stack>
#include<set>
#include<bitset>
#include<cmath>
#include<deque>
#include<map>
#include<queue>
#define iinf 2000000000
#define linf 1000000000000000000LL
#define dinf 1e200
#define eps 1e-3
#define all(v) (v).begin(),(v).end()
#define sz(x)  x.size()
#define pb push_back
#define mp make_pair
#define lng long long
#define sqr(a) ((a)*(a))
#define pii pair<int,int>
#define pll pair<lng,lng>
#define pss pair<string,string>
#define pdd pair<double,double>
#define X first
#define Y second
#define pi 3.14159265359
#define ff(i,xi,n) for(int i=xi;i<=(int)(n);++i)
#define ffd(i,xi,n) for(int i=xi;i>=(int)(n);--i)
#define ffl(i,r) for(int i=head[r];i!=-1;i=edge[i].next)
#define cc(i,j) memset(i,j,sizeof(i))
#define two(x)			((lng)1<<(x))
#define N 1050
#define M 10000
#define lson l , mid , rt << 1
#define rson mid + 1 , r , rt << 1 | 1
#define Mod  n
#define Pmod(x) (x%Mod+Mod)%Mod
using namespace std;
typedef vector<int>  vi;
typedef vector<string>  vs;
typedef unsigned int uint;
typedef unsigned lng ulng;
template<class T> inline void checkmax(T &x,T y){if(x<y) x=y;}
template<class T> inline void checkmin(T &x,T y){if(x>y) x=y;}
template<class T> inline T Min(T x,T y){return (x>y?y:x);}
template<class T> inline T Max(T x,T y){return (x<y?y:x);}
template<class T> T gcd(T a,T  b){return (a%b)==0?b:gcd(b,a%b);}
template<class T> T lcm(T a,T b){return a*b/gcd(a,b);}
template<class T> T Abs(T a){return a>0?a:(-a);}
struct pp
{
    int v,next,w;
}edge[M];
double  dist[N];
int f[N],head[N];
bool inque[N];
int cnt[N];
int n,m,tot;
double l,r,ans,mid;
inline void addedge(int u,int v,int w)
{
    edge[tot].v=v,edge[tot].w=w,edge[tot].next=head[u],head[u]=tot++;
}
bool spfa()
{
    queue<int> q;
    ff(i,1,n) dist[i]=iinf;
    cc(cnt,0);
    cc(inque,0);
    q.push(1);
    inque[1]=1,cnt[1]=1;
    dist[1]=0;
    while(!q.empty())
    {
        int u=q.front();
        inque[u]=0;
        q.pop();
        ffl(i,u)
        {
            double w=edge[i].w;
            int v=edge[i].v;
            w=mid*w-f[v];
            if(dist[v]>dist[u]+w)
            {
                dist[v]=dist[u]+w;
                if(!inque[v])
                {
                    inque[v]=1;
                    q.push(v);
                    cnt[v]++;
                    if(cnt[v]>=n) return 1;
                }
            }
        }
    }
    return 0;
}
int main()
{
    while(scanf("%d%d",&n,&m)==2)
    {
        ff(i,1,n) scanf("%d",f+i);
        tot=0;
        cc(head,-1);
        ff(i,1,m)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            addedge(u,v,w);
        }
        l=0,r=1996;
        while(r-l>=0.001)
        {
            mid=(l+r)/2;
            if(spfa())
            {
                l=mid;
                ans=mid;
            }
            else
            r=mid;
        }
        printf("%.2f\n",ans);
    }
    return 0;
}
pku2728

最优比例生成树

说白了就是求最小的(代价权和/边权和)的生成树问题 同样设置子问题 代价权-边权*L最小 即重新构造图 然后求最小生成树 同样如果 小于0 自己推导下就会知道 r=mid 另外poj会卡stl 裸奔的prim算法能过 优先队列优化的反而超时 


#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<vector>
#include<sstream>
#include<string>
#include<climits>
#include<stack>
#include<set>
#include<bitset>
#include<cmath>
#include<deque>
#include<map>
#include<queue>
#define iinf 2000000000
#define linf 1000000000000000000LL
#define dinf 1e200
#define eps 1e-5
#define all(v) (v).begin(),(v).end()
#define sz(x)  x.size()
#define pb push_back
#define mp make_pair
#define lng long long
#define sqr(a) ((a)*(a))
#define pii pair<int,int>
#define pll pair<lng,lng>
#define pss pair<string,string>
#define pdd pair<double,double>
#define X first
#define Y second
#define pi 3.14159265359
#define ff(i,xi,n) for(int i=xi;i<=(int)(n);++i)
#define ffd(i,xi,n) for(int i=xi;i>=(int)(n);--i)
#define ffl(i,r) for(int i=head[r];i!=-1;i=edge[i].next)
#define cc(i,j) memset(i,j,sizeof(i))
#define two(x)			((lng)1<<(x))
#define N 1050
#define M 1000000
#define lson l , mid , rt << 1
#define rson mid + 1 , r , rt << 1 | 1
#define Mod  n
#define Pmod(x) (x%Mod+Mod)%Mod
using namespace std;
typedef vector<int>  vi;
typedef vector<string>  vs;
typedef unsigned int uint;
typedef unsigned lng ulng;
template<class T> inline void checkmax(T &x,T y){if(x<y) x=y;}
template<class T> inline void checkmin(T &x,T y){if(x>y) x=y;}
template<class T> inline T Min(T x,T y){return (x>y?y:x);}
template<class T> inline T Max(T x,T y){return (x<y?y:x);}
template<class T> T gcd(T a,T  b){return (a%b)==0?b:gcd(b,a%b);}
template<class T> T lcm(T a,T b){return a*b/gcd(a,b);}
template<class T> T Abs(T a){return a>0?a:(-a);}
int n,h[N];
struct ps
{
    int x,y;
}cor[N];
inline double  Distance(ps &p, ps &q )
{
    return sqrt((double)sqr(p.x-q.x)+(double)sqr(p.y-q.y));
}
double l,r,ans,mid,dist[N];
double cost[N][N],len[N][N],ww[N][N];
inline void prim()
{
    ans=0;
    bool in[N]={};
    dist[1]=0;
    ff(i,2,n) dist[i]=iinf;
    ff(i,1,n)
    {
        double w=iinf;
        int id;
        ff(j,1,n)
        if(!in[j]&&dist[j]<w)
        w=dist[j],id=j;
        in[id]=1;
        ans+=w;
        ff(j,1,n)
        if(!in[j]&&ww[id][j]<dist[j]) dist[j]=ww[id][j];
    }
}
int main()
{
   while(scanf("%d",&n)==1&&n)
   {
       ff(i,1,n)
       scanf("%d%d%d",&cor[i].x,&cor[i].y,&h[i]);
       ff(i,1,n)
       ff(j,i+1,n)
       cost[i][j]=cost[j][i]=Abs(h[i]-h[j]),len[i][j]=len[j][i]=Distance(cor[i],cor[j]);
       l=0,r=500000;
       while(r-l>=eps)
       {
           mid=(l+r)/2;
              for(int i=1;i<=n;i++)
              for(int j=i+1;j<=n;j++)
                ww[i][j]=ww[j][i]=cost[i][j]-len[i][j]*mid;
           prim();
           if(ans<0) r=mid;
           else
            l=mid;
       }
       printf("%.3f\n",mid);
   }
    return 0;
}

这类问题的种类很少  基本属于模板题范畴 不如动态规划这些博大精深···


01分数规划 —— 入门介绍
_int_me的博客
08-14 621
对01分数规划及其拓展的介绍
浅谈01分数规划-代码改变世界
Phantom_stars的博客
08-02 929
浅谈01分数规划 所谓01分数规划，看到这个名字，可能会想到01背包，其实长得差不多。 这个算法就是要求“性价比”最高的解。sum(v)/sum(w)最高的解。 定义 我们给定两个数组，a[i]表示选取i的收益，b[i]表示选取i的代价。如果选取i，定义x[i]=1否则x[i]=0。每个物品只有选和不选的两种方案，求一个选择的方案使得R=sigma(a[i]*x[i])/sigma(b...
01分数规划 易懂+例题讲解 （c++）
qq_74156152的博客
06-15 1279
01分数规划 ：01即取还是不取，分数即所求型式为，规划就是选取最好的方案。一般情况题目给出n个物品，再给出每个物品的价值以及物重，选取k个物品，问你在所有可能选取的方案中，最大的单位价值为多少（单位价值为选取的 k 个物品的总价值和总重量的比值）。我们选择采用二分法，进行判断。我们要求的是选取的 k 个物品的总价值和总重量的比值最大，最终求得是。所以我们在可取的区间内每次取区间中值mid，判断是否符合，符合则可以取右边区间，不符合则取左区间。接下来是要写判断函数judge。
01分数规划与图论
CK1513710764的博客
08-22 1001
0/1分数规划模型是指,给定整数和,求一组解使得下列式子最大化:.
01分数规划
qq_35975367的博客
03-23 1055
参考文章 01分数规划 什么是01分数规划： 给定n个a[i]和b[i]，a[i]和b[i]绑定在一起要选同时选，求sum(a[i]) 除以 sum(b[i]) 的最大值，sum为求和函数 对于这种问题我们可以多定义一个数组x[1…n]，x为bool型只取0或者1,表示不选或者选，则对于每个x[1…n]的答案为： 那么这类问题称之为01分数规划问题 解决方法： 题目要求选几个，只需要根据d[i]的大小来选就可以了 ans则可以通过二分x来求，判断条件 如果max(f(x))>0,则x < a
凸优化之通信系统的分式规划
Nved23的博客
07-21 4325
研究通信问题中的凸优化方法：二次变换和拉格朗日对偶变换
分数规划问题解析：POJ2976与POJ3757
POJ2976题目涉及到的是01分数规划的典型应用。问题的目标是最大化剩余数对的比值T=sigma(a[i])/sigma(b[i])，其中我们需要从N对整数(a[i], b[i])中删除K对，使得比值最大。这种问题可以通过二分法来解决，首先随机...
poj2775.rar_poj_poj 27_poj27_poj2775
09-23
"poj"是"Programming Online Judge"的缩写，它是一个在线编程练习平台，允许用户提交代码并进行自动测试。"2775"是该平台上一个问题的编号，每个问题都有一个独特的编号，方便用户查找和讨论。 描述中提到的"递归...
POJ.rar_poj java_poj1048
09-24
【标题】"POJ.rar_poj java_poj1048" 涉及的知识点主要围绕编程竞赛中的“约瑟夫环”问题，这里是一个加强版，使用Java语言进行解决。 【描述】"POJ1048，加强版的约瑟夫问题 难度中等" 提示我们，这个问题是编程...
POJ_3131.zip_POJ 八数码_poj
09-20
标题中的“POJ_3131.zip_POJ 八数码_poj”指的是一个与编程竞赛网站POJ（Problem Set Algorithm）相关的项目，具体是针对3131号问题的解决方案，该问题涉及到了八数码游戏。八数码游戏，又称滑动拼图，是一个经典的...
jihe.rar_2289_POJ 3714_poj3714_poj3714 Ra_visual c
09-22
描述中提到的"三道几何题：hdu 1007、hdu 2289、poj 3714"暗示了这是一个关于几何算法的题目集，涉及到三个不同的在线判题系统：HDU（杭州电子科技大学在线评测系统）的1007题和2289题，以及POJ的3714题。...
无线通信中的分式规划（Fractional Programming）与Matlab实现
最新发布
08-02
无线通信中的处理分式规划问题，二次变换，功率控制问题，Matlab代码
0-1分数规划
dieguijin5790的博客
07-11 511
0-1分数规划 定义 我们给定两个数组，a[i]表示选取i的收益，b[i]表示选取i的代价。 如果选取i，定义x[i]=1否则x[i]=0。每个物品只有选和不选的两种方案，求一个选择的方案使得R=sigma(a[i]x[i])/sigma(b[i]x[i])，也就是选择物品的总收益/总代价最大或者最小。 主要问题分类 （1）一般01分数规划 （2）最优比率生成树...
01分数规划入门
mosquito_zm的博客
11-20 7484
01分数规划是这样的一类问题，有一堆物品，每一个物品有一个收益ai，一个代价bi，我们要求一个方案使选择的最大。 首先我们来一道例题吧，01分数规划的大体方法都是一样的。 友情提示：poj请选择C++提交，g++提交的话容易作死（poj的g++要用%f输入输出double，pojC++用%lf） 例1 Dropping Tests poj2976 给出n个物品，每个物品有两
[Algorithm]01分数规划——Update：2012年7月27日
weixin_30586085的博客
05-03 268
【关键字】0/1分数规划、最优比率生成树、最优比率环 【背景】 根据楼教主的回忆录，他曾经在某一场比赛中秒掉了一道最优比率生成树问题，导致很多人跟风失败，最终悲剧。自己总结了一些这种问题的解法，因为水平有限，如果有错误或是麻烦的地方，尽管喷，邮箱或是下方留言。 联系我的话perseawe@163.com，欢迎讨论，请在标题前注明[acm]或是[oi]，以免被垃圾邮件。 ...
分治 —— 01 分数规划
Alex_McAvoy的博客
10-08 2343
【概述】 分数规划的一般形式为： 特别的，当时，称为 01 分数规划 简单来说，就是有一些二元组 (a[i],b[i])，现在从中选择某些二元组，使得最大或最小 这一类题通用的解法是利用二分法来解决： 假设 x 为最优解，对应的最优函数值为λ，那么有： 即： 于是可以构造函数 当时，此时 λ 即为最优解 也就是说，当某一个值 λ满足上述式子的时候，就是要求的值，...
掌握01分数规划 思想+应用模型总结
harry12138小白的博客
02-01 602
理解什么是01分数规划 首先先分开看一下三个关键词：01、分数、规划 这类题一般是给一堆a[i]和一堆b[i]，这两个是有联系的，比如第i个物品的收益是a[i]，花费是b[i]，问选择哪k个物品使得∑选出来的a[i]∑选出来的b[i]\frac{\sum_{选出来的a[i]}}{\sum_{选出来的b[i]}}∑选出来的b[i]​∑选出来的a[i]​​最大，也就是求选出来的平均性价比最高。 1、那么01指的什么呢？ 我们可以这么理解，对于这n个数，每个数我们有两种抉择，选他或者不选他，选用1表示，不选用0表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值