zoj 2676 二分+ISAP模板求实型参数的最小割（0-1分数规划问题）（可做ISAP模板）

/*
参考博文：http://www.cnblogs.com/ylfdrib/archive/2010/09/01/1814478.html
以下题解为转载代码自己写的：
zoj2676
胡伯涛论文《最小割模型在信息学竞赛中的应用》中详细介绍了分数规划思想的应用。经典的有最优比率生成树。

对于分数规划的应用中，常用的就是0-1分数规划，即解向量X = {x1, ……,xi, ……}, 对于∀xi∈{0,1}。

主要求解过程是，首先将原分式优化问题，转换成非分式优化问题，利用单调的性质，用二分逼近的方法找到最优解。
题目要求最后能够截得信息，即求某个割，使得c/k最小。

这一题可以将问题转化为最小割，求c/k的最小值，即求sum(xi * ci) / sum(xi * 1)的最小值，(xi == 0  || xi == 1)

设ans = sum(xi * ci) / sum(xi * 1)

则 sum(xi * ci) - ans * sum(xi * 1) = 0

即 sum(xi * (ci - ans)) = 0;

令F(x) = sum(xi * (ci - ans)); 对于一定值ans，函数为单调递减的。

对于正解ANS, F(x) = 0;

则可以推出：

如果 F(x) = 0 那么 ans = ANS

如果 F(x) < 0 那么 ans > ANS

如果 F(x) > 0 那么 ans < ANS

用二分的方法逼近答案，令COST = ci - ans，作为第i条边的新花费，求得最小割ans进行验证即可。
*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<math.h>
using namespace std;
#define eps 1e-6//二分1e-10超时
#define inf 0x3fffffff
#define N 410
struct node
{
int u,v,next;
double w;
}f
,bian[N*4];
int yong,head
,cur
,q
,gap
,dis
;
void init()
{
yong=0;
memset(head,-1,sizeof(head));
}
void addedge(int u,int v,double w)
{
bian[yong].u=u;
bian[yong].v=v;
bian[yong].w=w;
bian[yong].next=head[u];
head[u]=yong++;
}
void bfs(int start,int endl)//建立到汇点的距离层次图存在dis[]数组中
{
int rear=0,i,j;
memset(dis,-1,sizeof(dis));
memset(gap,0,sizeof(gap));//gap[x]记录dis[i]=x出现了多少次
dis[endl]=0;
gap[dis[endl]]=1;
q[rear++]=endl;
for(i=0;i<rear;i++)
{
for(j=head[q[i]];j!=-1;j=bian[j].next)
{
int v=bian[j].v;
if(dis[v]==-1)
{
++gap[dis[v]=dis[q[i]]+1];
q[rear++]=v;
}
}
}
}
double SAP(int start,int endl,int n)
{
double ans=0;
bfs(start,endl);
int cur
;//代替head数组
memcpy(cur,head,sizeof(head));
int stack
,top=0;//建立手工栈
int u=start,i;
while(dis[start]<n)
{
if(u==endl)//当搜到终点时即找到从原点到汇点的增光路，正常处理即可
{
double mini=inf;
int tep;
for(i=0;i<top;i++)
{
if(mini>bian[stack[i]].w)
{
mini=bian[stack[i]].w;
tep=i;
}
}
for(i=0;i<top;i++)
{
bian[stack[i]].w-=mini;
bian[stack[i]^1].w+=mini;
}
ans+=mini;
top=tep;
u=bian[stack[top]].u;//此时的u为变容量为0的u
}
if(dis[u]&&gap[dis[u]-1]==0)//出现了断层，没有增广路
break;
for(i=cur[u];i!=-1;i=bian[i].next)//遍历与u相连的未遍历的节点
{
int v=bian[i].v;
if(dis[v]!=-1)
{
if(bian[i].w>eps&&dis[u]==dis[v]+1)//层次关系找到允许路径
break;
}
}
if(i!=-1)//找到允许弧
{
cur[u]=i;
stack[top++]=i;
u=bian[i].v;
}
else//无允许的路径，修改标号 当前点的标号比与之相连的点中最小的多1
{
int mini=n;
for(i=head[u];i!=-1;i=bian[i].next)
{
if(fabs(bian[i].w)<eps)continue;
int v=bian[i].v;
if(mini>dis[v])//找到与u相连的v中dep[v]最小的点
{
mini=dis[v];
cur[u]=i;//最小标号就是最新的允许弧
}
}
--gap[dis[u]];//dep[u] 的个数变化了 所以修改gap
++gap[dis[u]=mini+1];//将dep[u]设为min(dep[v]) + 1, 同时修改相应的gap[]
if(u!=start)//该点非源点&&以u开始的允许弧不存在，退点
u=bian[stack[--top]].u;
}
}
return ans;
}
int a
,len,vis
;
void dfss(int u) {
int i;
// printf("%d\n",u);
for(i=head[u];i!=-1;i=bian[i].next) {
int v=bian[i].v;
if(bian[i].w>eps&&!vis[v]) {
vis[v]=1;
dfss(v);
}
}
}
int main()
{
int n,m,i;
double st,en,mid,flow;
while(scanf("%d%d",&n,&m)!=EOF)
{
for(i=1; i<=m; i++)
scanf("%d%d%lf",&f[i].u,&f[i].v,&f[i].w);
st=0;
en=10000001;
while(st<en+eps)
{
mid=(st+en)/2;
init();
flow=0;
for(i=1; i<=m; i++)
{
//   printf("%.2f %.2f\n",f[i].w,mid);
if(f[i].w<mid+eps)
flow=flow+f[i].w-mid;
else
{
addedge(f[i].u,f[i].v,f[i].w-mid);
addedge(f[i].v,f[i].u,f[i].w-mid);
}
}
double k=SAP(1,n,n);
flow+=k;
//  printf("%.2f\n",k);
if(flow>eps)
st=mid+eps;
else
en=mid-eps;
}
//printf("mid=%.10f\n",mid);
memset(vis,0,sizeof(vis));
vis[1]=1;
dfss(1);
len=0;
for(i=1;i<=m;i++) {
//   printf("%.10f %.10f\n",f[i].w,mid+eps);//&&vis[f[i].u]+vis[f[i].v]==1
if(vis[f[i].u]+vis[f[i].v]==1||f[i].w<eps+mid)//如果是负边或者割边
len++;
}
printf("%d\n",len);
int ok=0;
for(i=1;i<=m;i++)
if(vis[f[i].u]+vis[f[i].v]==1||f[i].w<mid+eps) {//如果是负边或者割边
if(ok)
printf(" ");
printf("%d",i);
ok=1;
}
printf("\n");
}
return 0;
}