BZOJ 4501: 旅行 01分数规划 最大权闭合子图

4501: 旅行

Time Limit: 10 Sec  Memory Limit: 256 MBSec  Special Judge
Submit: 169  Solved: 75

[Submit][Status][Discuss]

Description

小C来到了F国，小C想好好地参观F国。F国可以看一个有n个点m条边的有向无环图，小C刚开始站在1号点。假设现在小C站在x号点：
1．点x没有出边，结束旅游。
2．点x有o条出边，小C等概率地选一条边走过去。

小J是小C的好朋友，小J可以使用魔法让一些边消失，但是有一些限制(x,y)：第y条边如果被删掉了，那么第x条边也会受到影响，导致x条边被删掉。
现在小J想知道，如何删边使得小C所经过的边数期望最大。

Input

第一行三个整数，n,m,k(1 <= n <= 50, 0 <= m <= 500, 0 <= k <= 2000)，代表有n个点，m条边，k个限制。
接下来m行，第i行代表第i条边x,y(1 <= x, y <= n)，方向是从x到y。
接下来k行，每行有两个整数x,y(1 <= x, y <= m)，代表限制。
保证图是有向无环的，保证对于每个限制(x,y)，第x条边和第y条边的起点是相同的。可能有重边，限制可能重复。1 <= n <= 50, 0 <= m <= 500, 0 <= k <= 2000

Output

输出一个实数，最大的边数期望。只要和标准答案误差小于10^-2 就认为是相同的。

Sample Input

3 3 0

1 2

1 3

2 3

Sample Output

2.0000000

这道题读错了两遍。。。

首先啊 x,y的起点相同 所以说 每个点的边之间不会互相影响

所以 我们按拓扑序由后向前解决每一个点 令每一个点最优 答案一定最优

现在对于一个节点

我们令b[i]表由该点经过一个儿子节点i向下最多的边数期望

a[i]表示该点选不选 则答案如下



这时 下一步就很明显了
式子显然是 01分数规划的形式
那么二分答案就好



可是怎么判定呢？
老套路移项就好了



这时该怎么做呢
考虑

这些边之间存在没有y就一定没有x的情况 即有x就一定有y

那么 最大权闭合子图

之后 就结束啦

#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<string>
#include<bitset>
#include<queue>
#include<set>
#include<map>
using namespace std;

typedef long long ll;
typedef double db;

inline int read()
{
int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch<='9'&&ch>='0'){x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
return f*x;
}
void print(int x)
{if(x<0)putchar('-'),x=-x;if(x>=10)print(x/10);putchar(x%10+'0');}

const int N=55,M=510,inf=0X3f3f3f3f;
const db eps=1e-9;

int S=M-2,T=M-1;

namespace flow
{
int last[M],ecnt;
struct EDGE{int to,nt;db val;}e[M*M];
inline void readd(int u,int v,db val)
{e[++ecnt]=(EDGE){v,last[u],val};last[u]=ecnt;}
inline void add(int u,int v,db val)
{readd(u,v,val);readd(v,u,0);}

int d[M],q[M];

bool bfs()
{
memset(d,0,sizeof(d));
int head=0,tail=1;
d[S]=1;q[head]=S;
while(head<tail)
{
int u=q[head++];
for(int i=last[u];i;i=e[i].nt)
if(e[i].val>eps&&!d[e[i].to])
{
d[e[i].to]=d[u]+1;
q[tail++]=e[i].to;
}
}
return d[T];
}

db dfs(int u,db lim)
{
if(u==T)return lim;
db res=0;
for(int i=last[u];i;i=e[i].nt)
if(d[e[i].to]==d[u]+1&&e[i].val)
{
db tmp=dfs(e[i].to,min(e[i].val,lim));
res+=tmp;lim-=tmp;
e[i].val-=tmp;e[i^1].val+=tmp;
if(tmp<eps)d[e[i].to]=-1;
if(lim<eps)break;
}
return res;
}

db mxflow;

db dinic()
{while(bfs())mxflow+=dfs(S,inf);return mxflow;}

void init()
{
memset(last,0,sizeof(last));
ecnt=1;mxflow=0;
}
}

int last
,ecnt;
struct EDGE{int to,nt;}e[M];
inline void add(int u,int v)
{e[++ecnt]=(EDGE){v,last[u]};last[u]=ecnt;}

db f
;
bool vis
;
vector<int>vec[M];

void topo(int u)
{
if(vis[u])return ;
vis[u]=1;
db l=0,r=0,mid;
for(int i=last[u];i;i=e[i].nt)
{
topo(e[i].to);
r=max(r,f[e[i].to]+1);
}
while(r-l>eps)
{
mid=(l+r)/2.0;
flow::init();
db res=0;
for(int i=last[u];i;i=e[i].nt)
{
for(int j=0;j<vec[i].size();++j)
flow::add(i,vec[i][j],inf);
if(f[e[i].to]+1-mid<0)
flow::add(S,i,mid-f[e[i].to]-1);
else
res+=f[e[i].to]+1-mid,
flow::add(i,T,f[e[i].to]+1-mid);
}
res-=flow::dinic();
res>eps?(f[u]=mid,l=mid):r=mid;
}
}

int main()
{
int n=read(),m=read(),K=read();
register int i,u,v;
for(i=1;i<=m;++i)
{
u=read();v=read();
add(u,v);
}
for(i=1;i<=K;++i)
{
u=read();v=read();
vec[v].push_back(u);
}
topo(1);
printf("%.10lf",f[1]);
return 0;
}