bzoj3232圈地游戏——0/1分数规划+差分建模+判环

Description

DZY家的后院有一块地，由N行M列的方格组成，格子内种的菜有一定的价值，并且每一条单位长度的格线有一定的费用。

DZY喜欢在地里散步。他总是从任意一个格点出发，沿着格线行走直到回到出发点，且在行走途中不允许与已走过的路线有任何相交或触碰（出发点除外）。记这条封闭路线内部的格子总价值为V，路线上的费用总和为C，DZY想知道V/C的最大值是多少。

Input

第一行为两个正整数n,m。

接下来n行，每行m个非负整数，表示对应格子的价值。

接下来n+1行，每行m个正整数，表示所有横向的格线上的费用。

接下来n行，每行m+1个正整数，表示所有纵向的格线上的费用。

（所有数据均按从左到右，从上到下的顺序输入，参见样例和配图）

Output

 

输出一行仅含一个数，表示最大的V/C，保留3位小数。

Sample Input

3 4
1 3 3 3
1 3 1 1
3 3 1 0
100 1 1 1
97 96 1 1
1 93 92 92
1 1 90 90
98 1 99 99 1
95 1 1 1 94
1 91 1 1 89

Sample Output

1.286

HINT

题解：

0/1分数规划，二分mid

转化为是否存在一组解

使得∑vi-mid*∑ci<=0

即，每个格线有一个边权，每个格有权，是否能找到一个封闭的图形，使得内部和-边权和>0

发现和一般的不同的是，每个元素不是可以直接访问然后取值的。

因为还有格线和封闭起来的块的问题。

假设先不管块的值。

我们发现题目是一个从某个点出发，再回到某个点，然后判断是否有一条>0的路径。

即，图中有没有正环。

那么，块的值怎么办？

可以前缀差分！！

sum[i][j]表示，∑val[1~i][j]

对于一个横边：(i,j)->(i,j+1)，边权是：mid*c+sum[i][j]

(i,j)->(i,j-1)，边权是：mid*c-sum[i][j]

竖边就是mid*c

那么对于一个闭合封闭图形，必然可以把块的贡献看作是一列一列的。

并且，如果这是一个正环，那么存在从左下角出发往右走再绕回来，然后边权之和恰好有∑sum[i][j]-sum[i-p][j]

就差分出来格内部的权值和了。

注意，最短路的时候，为了卡精度，但是赋值时不能dis[dx][dy]=dis[x][y]+w-eps或者+eps

eps只在比较的时候用，赋值就不能用了。

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=;
const double eps=0.000001;
int n,m;
int val[N][N];
int sum[N][N];
int mv[][]={{+,},{-,},{,+},{,-}};
int co[N][N][];
double dis[N][N];
bool vis[N][N];
int in[N][N];//ci in queue
struct node{
    int has,x,y;
};
queue<node>q;
double mid;
bool spfa(){
    while(!q.empty()) q.pop();
    node st;
    st.has=,st.x=,st.y=;
    dis[][]=0.00;
    q.push(st);
    while(!q.empty()){
        node now=q.front();q.pop();
        vis[now.x][now.y]=;
        if(now.has>(n+)*(m+)+) return true;
        for(int i=;i<;i++){
            int dx=now.x+mv[i][],dy=now.y+mv[i][];
            if(dx<||dx>n) continue;
            if(dy<||dy>m) continue;
            double w=-1.0*mid*co[now.x][now.y][i];
            if(i==) w+=sum[now.x][now.y+];
            if(i==) w-=sum[now.x][now.y];
            if(dis[dx][dy]+0.0001<dis[now.x][now.y]+w){
                dis[dx][dy]=dis[now.x][now.y]+w;
                in[dx][dy]++;
                if(in[dx][dy]>(n+)*(m+)+) return true;
                if(!vis[dx][dy]){
                    vis[dx][dy]=;
                    node tmp;
                    tmp.has=now.has+;
                    tmp.x=dx,tmp.y=dy;
                    q.push(tmp);
                }
            }
        }
    }
    return false;
}
bool che(){
    memset(dis,0xcf,sizeof dis);
    memset(in,,sizeof in);
    memset(vis,,sizeof vis);
    if(spfa()) return true;
}
int main(){
    scanf("%d%d",&n,&m);
    int mx=;
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            scanf("%d",&val[i][j]);
            mx+=val[i][j];
            sum[i][j]=sum[i-][j]+val[i][j];
        }
    }int t;
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            scanf("%d",&t);
            co[i][j-][]=co[i][j][]=t;
        }
    }
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            scanf("%d",&t);
            co[i-][j][]=co[i][j][]=t;
        }
    }
    double l=0.00,r=1.0*mx;
    double ans;
    while(r-l>eps){
        mid=(l+r)/2.0;
        if(che()) l=mid,ans=mid;
        else r=mid;
    }
    printf("%.3lf",ans);
    return ;
}