bzoj3597: [Scoi2014]方伯伯运椰子

感人。。肝了一下午+一晚上，为啥别人省的签到题我都不会啊zzzzzz GDOI2017day2密码:easy?GDOI2018jian

01分数规划学得太差（低头

 

solve1:（优秀的解法是solve2，这个东西有点搞笑）

那么对于这道题，每条边我先把它看作拆成c条边(脑海里)

容易联想到了费用流，先解决一个弱化版，把分子搞出来

对于加边很好弄，有边相连的连一条无限流量的边，边权为-b-d，因为假如你新图多加了这条边，费用就多了b+d，原图的费用减新图的费用就得-b-d

同理对于减一条边，相当于费用差-a+d，但是怎么搞呢？

减边和加边我们可以看成一个单峰函数，只是加边时新图的花费随加的边数增大而增大比较好弄，减边相反不好弄，那就把它置反就好弄了

意思是我们可以视为先把所有的边减了，然后每用一条原本的边，相当于费用差+a-d，把原来多减的加回来

做法逐渐出来了：sum初始化为c*d-c*a(减掉所有的边)，然后对于加边，有边相连的两点连一条无限流量的边，边权为-b-d，对于减边，有边相连的两点连一条流量为c的边，边权为a-d。

考虑加上一个分数规划，先二分答案

回忆分数规划的形式(a1*x1+a2*x2……an*xn)/(b1*x1+b2*x2……bn*xn)

a数组放的是边权，要求选的连续，b放的是边数

要的是a-b*mid>0，也就是费用流跑出来费用为正

对于加边一点问题没有，b=1，边权变为-b-d-mid

然而减边我们遇到了同样的问题，也就是用的原来边越多，减的边越少

同样地我们可以直接在sum初始化的时候先视为减掉所有的边，也就是sum-=c*mid，（不难发现这是对的，因为在分母加了，然后乘到左边，移项，就是这个值）然后每多用一条原来的边，就加上mid，意思是令这些边对应b=-1，边权变为a-d+mid

有一个重要的东西放到最后，相信大家都有一个疑问，就是我们需要保证先用原本的边，再加边，如何保证？

考虑到用原边的费用为a-d+mid，加边费用为-b-d-mid，原边费用一定大于加边费用，那么我们可以把费用置反，然后跑出来费用为负，说明当前解能够算出。

 

solve2

我的捞比做法太慢了，跑了1s+，更快速的可以跑到100ms+

我们理解为方伯伯已经做完了一次费用流

考虑对于加边，相当于在费用流里面增广，减边相当于在费用流里面退流，那么我们对于一条边，x->y连边权为-b-d的边，若c!=0 y->x连-a+d的边，只要我们在里面找到一个正环，那么就可以退流+增广达到一个更小的值

同样的二分答案，同样我们需要把边权置反——负环才好找啊~~

比垃圾费用流好到不知道哪里去了

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;

int n,m;
struct node
{
    int x,y,c,next,other;double d;
}a[410000];int len,last[5100];
void ins(int x,int y,int c,double d)
{
    int k1,k2;
    
    len++;k1=len;
    a[len].x=x;a[len].y=y;a[len].c=c;a[len].d=d;
    a[len].next=last[x];last[x]=len;
    
    len++;k2=len;
    a[len].x=y;a[len].y=x;a[len].c=0;a[len].d=-d;
    a[len].next=last[y];last[y]=len;
    
    a[k1].other=k2;
    a[k2].other=k1;
}
double sum,cc;
int head,tail,list[5100];bool v[5100];
int pre[5100],c[5100];double d[5100];
bool spfa()
{
    memset(c,0,sizeof(c));c[n+1]=(1<<30);
    for(int i=0;i<=n+2;i++)d[i]=(1<<30); d[n+1]=0;
    head=1,tail=2;list[1]=n+1;v[n+1]=true;
    while(head!=tail)
    {
        int x=list[head];
        for(int k=last[x];k;k=a[k].next)
        {
             int y=a[k].y;
            if(a[k].c>0&&d[y]>d[x]+a[k].d)
            {
                d[y]=d[x]+a[k].d;
                c[y]=min(a[k].c,c[x]);
                pre[y]=k;
                if(v[y]==false)
                {
                    v[y]=true;
                    list[tail]=y;
                    tail++;if(tail==5050)tail=1;
                }
            }
        }
        head++;if(head==5050)head=1;
        v[x]=false;
    }
    if(d[n+2]!=d[0])
    {
        sum+=d[n+2]*c[n+2];
        cc+=c[n+2];
        int y=n+2;
        while(y!=n+1)
        {
            int k=pre[y];
            a[k].c-=c[n+2];
            a[a[k].other].c+=c[n+2];
            y=a[k].x;
        }
        return true;
    }
    return false;
}

struct edge{int x,y,a,b,c;double d;}e[3100];
bool check(double mid)
{
    sum=0,cc=0;
    len=0;memset(last,0,sizeof(last));
    for(int i=1;i<=m;i++)
    {
        if(e[i].x==n+1){ins(e[i].x,e[i].y,e[i].c,0);continue;}
        
        sum+= -( e[i].c*e[i].d-e[i].c*e[i].a -e[i].c*mid) ;
        
        ins(e[i].x,e[i].y,e[i].c , -( -e[i].d+e[i].a +mid) );
        ins(e[i].x,e[i].y,(1<<30), -( -e[i].d-e[i].b -mid) );
    }
    while(spfa()==true);
    return sum<0;
}
int main()
{
    freopen("a.in","r",stdin);
    freopen("a.out","w",stdout);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
        scanf("%d%d%d%d%d%lf",&e[i].x,&e[i].y,&e[i].a,&e[i].b,&e[i].c,&e[i].d);
        
    double l=0,r=100000000,ans;
    while(r-l>=1e-3)
    {
        double mid=(l+r)/2;
        if(check(mid))l=mid;
        else r=mid;
    }
    printf("%.2lf",l);
    return 0;
}

费用流

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;

int n,m;
struct node
{
    int x,y,next;double d;
}a[410000];int len,last[5100];
void ins(int x,int y,double d)
{
    len++;
    a[len].x=x;a[len].y=y;a[len].d=d;
    a[len].next=last[x];last[x]=len;
}
bool v[5100]; double d[5100];
bool spfa(int x)
{
    v[x]=true;
    for(int k=last[x];k;k=a[k].next)
    {
        int y=a[k].y;
        if(d[y]>d[x]+a[k].d)
        {
            if(v[y])return true;
            d[y]=d[x]+a[k].d;
            if(spfa(y))return true;
        }
    }
    v[x]=false;
    return false;
}
struct edge{int x,y,a,b,c;double d;}e[3100];
bool check(double mid)
{
    len=0;memset(last,0,sizeof(last));
    for(int i=1;i<=m;i++)
    {
        if(e[i].x==n+1){ins(e[i].x,e[i].y,e[i].d);continue;}
        ins(e[i].x,e[i].y,-(-e[i].b-e[i].d-mid));
        if(e[i].c!=0)ins(e[i].y,e[i].x,-(-e[i].a+e[i].d-mid));
    }
    memset(v,false,sizeof(v));
    memset(d,0,sizeof(d));
    for(int i=1;i<=n+2;i++)
        if(spfa(i))return true;
    return false;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
        scanf("%d%d%d%d%d%lf",&e[i].x,&e[i].y,&e[i].a,&e[i].b,&e[i].c,&e[i].d);
        
    double l=0,r=100000000,ans;
    while(r-l>=1e-3)
    {
        double mid=(l+r)/2;
        if(check(mid))l=mid;
        else r=mid;
    }
    printf("%.2lf",l);
    return 0;
}

spfa判负环

 

转载于:https://www.cnblogs.com/AKCqhzdy/p/10187593.html