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

最新推荐文章于 2022-07-21 21:21:00 发布
最新推荐文章于 2022-07-21 21:21:00 发布
阅读量2.9k 收藏 2
点赞数
分类专栏： 数学 poj 文章标签： distance struct c 算法 图形 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lawrence_Jang/article/details/8048278
版权
poj 同时被 2 个专栏收录
17 篇文章 0 订阅
订阅专栏
数学
3 篇文章 0 订阅
订阅专栏



              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;
}

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


Lawrence_Jang
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ.rar_poj java_poj1048
09-24
POJ1048，加强版的约瑟夫问题 难度中等
poj1990.rar_POJ 19_poj_poj19
09-20
poj上第1990题目源码，用到了2个树状数组，这题数据结构是关键，想到了题目就很简单了
凸优化之通信系统的分式规划
Nved23的博客
07-21 3070
研究通信问题中的凸优化方法：二次变换和拉格朗日对偶变换
Bailian4145 放弃考试 POJ2976 ZOJ3068 Dropping tests【二分法+01分数规划】
海岛Blog
06-07 1554
4145:放弃考试 总时间限制: 1000ms 内存限制: 65536kB 描述 在一门课程中，一共有n场考试。假如你在i场考试中可以答对bi道题中的ai道，那么你的累计平均分定义为：100·Σai/Σbi。已知你这i场考试的答题情况，并且允许你放弃其中的k场考试，请你确定你最高能够得到多少的累计平均分。 假设该课程一共有3门考试，你的答题情况为5/5，0/1和2/6。如果你每门都参加，你的累计平均分为100·(5+0+2)/(5+1+6)= 50分。如果你放弃第3场考试，你的累计平均分则提高到了100·(
poj2976(01分数规划)
stay_accept的专栏
12-12 2529
链接：点击打开链接 题意；有n场考试，给出每场答对的题数a和这场一共有几道题b，求去掉k场考试后，公式.的最大值 代码： #include #include #include using namespace std; const int INF=0x3f3f3f3f; double a[1005],b[1005],v[1005]; int n,k; bool judge(
POJ 2728-Desert King(01分数规划_最优比率生成树)
Rocky0429
08-10 1118
题目地址：POJ 2728 题意：将n个村庄连在一起，告诉每个村庄的三维坐标，村庄之间的距离为水平方向上的距离，花费为垂直方向上的高度差，求把村庄连接起来的最小的花费与长度之比为多少。 思路：最优比率生成树。和普通的01分数规划差不多的思路，只不过这道题的函数变成了一颗树而已。我是用二分查找来做的，迭代法的话请看这篇博客Fatedayt。话说二分确实慢，在最坏的上限的情况G++还是会T的。经检验
POJ 2976-Dropping tests(01分数规划_二分||Dinkelbach算法)
Rocky0429
08-10 2662
题目地址：POJ 2976 题意：给出n个a和b，让选出n-k个使得最大 思路：这是一道典型的01规划的题，限制条件较少，较好解决。对于01规推荐[Algorithm]01分数规划 本题因为每个都能选择，所以x[i]的取值都为1，然后要求的值最大，那就把n个构造的d[i]从小到大排序，选择后n-k个，在所有的L中二分查找最适合的L即可。#include <stdio.h> #include <
poj2775.rar_poj_poj 27_poj27_poj2775
09-23
poj题目2775文件子目录源代码，递归经典题目，
POJ1753.rar_poj 1753_poj1753
09-20
POJ1753 Flip Game题目完整代码及报告
poj.rar_poj
09-20
POJ 上的近100道水题，基本涵盖了所有基本算法和数据结构，全部AC
poj 2761 treap
Lawrence_Jang
11-23 1002
利用区间的有序性才可以用treap 其实这题 线段树和树状数组时更好的选择 稍后补上 #include #include #include #include using namespace std; const int inf=~0U>>1; class treap { struct node { int val,key,size; node
poj 1785
Lawrence_Jang
11-26 997
#include #include #include #include #include using namespace std; const int inf=~0U>>1; struct ps { char s[11]; int w; int l,r; friend bool operator <(ps p,ps q){return strcmp(p.s,q.s
poj 3162 树形dp+单调队列 很好的题
Lawrence_Jang
10-08 884
#include #include #include #include #include #include #include #include #include #include #include #include #include #include #define iinf 1000000000 #define linf 1000000000000000000LL #define dinf 1e
poj 3481 sbt 版本
Lawrence_Jang
11-28 821
#include #include using namespace std; const int inf=~0U>>1; struct ps { int id,val; ps(int _i=0,int _val=0){id=_i;val=_val;} friend bool operator <(ps q,ps p) { return q.val<p
poj 3481 treap 练习
Lawrence_Jang
11-25 761
#include #include #include #include using namespace std; const int inf=~0U>>1; struct ps { int id,val; ps(int _i=0,int _val=0){id=_i;val=_val;} friend bool operator <(ps q,ps p) {
poj 3207 Ikki's Story IV - Panda's Trick
Lawrence_Jang
10-16 700
poj 3207 Ikki's Story IV - Panda's Trick m个pair连接，每种连接可以有2种方式 1：在内连接 2：在外连接 不难发现会相交的情况的只有同时在内或者 同时在外 将连接方式标志为1--2*m 在内为奇数 在外为偶数 下面只要统计矛盾建立图形 然后two sat求解是否存在即可 #include #include #inclu
poj 2892 hdu 1540 不错的线段树题
Lawrence_Jang
10-10 543
#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define iinf 2000000000 #define linf 1000000000000000000LL #defin
poj 3683 2-sat
Lawrence_Jang
10-15 442
poj 3683  2-sat  算法很容易想到 建图： 将每个婚礼可行2个区间建立左右界 N个婚礼 2*N个区间  然后根据区间相交的矛盾建立新边 这里求解可行解比较复杂 最好自己写一下模板 #include #include #include #include #include #include #include #include #include #inclu
poj Divisibility
最新发布
09-12
POJ Divisibility是一个编程题，要求编写一个程序来确定一系列整数是否可被K整除。输入文件的第一行包含两个整数N和K，用一个空格分隔。第二行包含一系列N个整数，以空格分隔。每个整数的绝对值不大于10000。在输出...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值