poj 3155 Hard Life 分数规划+最大权闭合图

分类： 网络流 2013-10-25 23:54  274人阅读  评论(0)  收藏  举报

这个就是完全按照论文中的做法来搞了，输出割边的时候就dfs判断一下在残余网络中该点是否可达汇点，不可达则是割边。

输出答案的证明可以百度到。

[cpp]  view plain copy

1. #include <iostream>  
2. #include <cstdio>  
3. #include <cstring>  
4. using namespace std;  
5. const int maxn=1e2+9,inf=1e9;  
6. const double epx=1e-6;  
7. int n,m;  
8. int d[maxn][maxn],level[maxn+1300],que[maxn+1300];  
9. int visit[maxn+1300];  
10. int S=0,T=1200;  
11. int head[maxn+1300],lon;  
12. struct  
13. {  
14.     int next,to;  
15.     double c;  
16. }e[111111];  
17. void edgeini()  
18. {  
19.     memset(head,-1,sizeof(head));  
20.     lon=-1;  
21. }  
22. void edgemake(int from,int to,double c)  
23. {  
24.     e[++lon].c=c;  
25.     e[lon].to=to;  
26.     e[lon].next=head[from];  
27.     head[from]=lon;  
28. }  
29.   
30. void makegraph(double ret)  
31. {  
32.     edgeini();  
33.     int tot=n;  
34.     for(int i=1;i<=n;i++)  
35.     {  
36.         edgemake(i,T,ret);  
37.         edgemake(T,i,0);  
38.     }  
39.     for(int i=1;i<=n;i++)  
40.     for(int j=1;j<=n;j++)  
41.     if(d[i][j])  
42.     {  
43.         ++tot;  
44.         edgemake(S,tot,1);  
45.         edgemake(tot,S,0);  
46.         edgemake(tot,i,inf);  
47.         edgemake(i,tot,0);  
48.         edgemake(tot,j,inf);  
49.         edgemake(j,tot,0);  
50.     }  
51. }  
52.   
53. bool makelevel(int s,int t)  
54. {  
55.     memset(level,0,sizeof(level));  
56.     int front=1,end=0;  
57.     que[++end]=s;  
58.     level[s]=1;  
59.     while(front<=end)  
60.     {  
61.         int u=que[front++];  
62. //        cout<<u<<endl;  
63.         if(u==t) return true;  
64.         for(int k=head[u];k!=-1;k=e[k].next)  
65.         {  
66.             int v=e[k].to;  
67.             if(e[k].c>0&&!level[v])  
68.             {  
69.                 level[v]=level[u]+1;  
70.                 que[++end]=v;  
71.             }  
72.         }  
73.     }  
74.     return false;  
75. }  
76.   
77. double dfs(int now,int t,double maxf)  
78. {  
79.     double ret=0;  
80.     if(now==t) return maxf;  
81.     for(int k=head[now];k!=-1;k=e[k].next)  
82.     {  
83.         int u=e[k].to;  
84.         if(level[u]==level[now]+1&&e[k].c>0)  
85.         {  
86.             double f=dfs(u,t,min(maxf-ret,e[k].c));  
87.             e[k].c-=f;  
88.             e[k^1].c+=f;  
89.             ret+=f;  
90.         }  
91.     }  
92.     return ret;  
93. }  
94.   
95. double maxflow(int s,int t)  
96. {  
97.     double ret=0;  
98.     while(makelevel(s,t))  
99.     {  
100.         ret+=dfs(s,t,inf);  
101.     }  
102.     return ret;  
103. }  
104.   
105. bool chk()  
106. {  
107.     double ans=maxflow(S,T);  
108. //    cout<<m-ans<<endl;  
109.     return (m-ans)>epx;  
110. }  
111.   
112. bool dfs(int now,int t)  
113. {  
114. //    printf("%d %d\n",now,t);  
115.     visit[now]=1;  
116.     if(now==t) return true;  
117.     for(int k=head[now];k!=-1;k=e[k].next)  
118.     {  
119.         int u=e[k].to;  
120.         if(e[k].c>0&&!visit[u])  
121.         if(dfs(u,t)) return true;  
122.     }  
123.     return false;  
124. }  
125.   
126. void prin()  
127. {  
128. //    for(int i=0;i<=T;i++)  
129. //    for(int k=head[i];k!=-1;k=e[k].next)  
130.     if(e[k].c>0)  
131. //    printf("%d %d %f\n",i,e[k].to,e[k].c);  
132. //  
133. //    dfs(4,T);  
134.   
135.     int sum=0;  
136.     for(int i=1;i<=n;i++)  
137.     {  
138.         memset(visit,0,sizeof(visit));  
139.         if(!dfs(i,T))  
140.         {  
141.             sum++;  
142.         }  
143.     }  
144.     cout<<sum<<endl;  
145.     for(int i=1;i<=n;i++)  
146.     {  
147.         memset(visit,0,sizeof(visit));  
148.         if(!dfs(i,T))  
149.         {  
150.             printf("%d\n",i);  
151.         }  
152.     }  
153. }  
154.   
155. int main()  
156. {  
157. //    freopen("in.txt","r",stdin);  
158.     while(scanf("%d%d",&n,&m)!=EOF)  
159.     {  
160.         memset(d,0,sizeof(d));  
161.         for(int i=1,from,to;i<=m;i++)  
162.         {  
163.             scanf("%d%d",&from,&to);  
164.             d[from][to]=1;  
165.         }  
166.         double l=0,r=n,mid;  
167.         while(r-l>epx)  
168.         {  
169.             mid=(l+r)/2;  
170.             makegraph(mid);  
171. //            cout<<mid<<endl;  
172.             if(chk()) l=mid;  
173.             else r=mid;  
174.             //prin();  
175.         }  
176. //        printf("%f\n",epx);  
177. //        cout<<l<<endl;  
178.         makegraph(l);  
179.         chk();  
180.         prin();  
181.     }  
182.     return 0;  
183. }