最大流Edmondes-Karp,hlpp代码(2007-04-16 19:49)

 

搞了一下午总算写出来了= =...

刚开始学网络流,也不知道要怎么样优化,贴上随便写的代码~继续搞rtf...

------------------------Edmondes-Karp--------------------------------

1. #include "stdio.h"
2. #include "string.h"
4. int rm[201][201];
5. int m,n;
6. int que[201];
7. int pre[201];
8. int qnum,pos;
9. char sta[201];
10. int ans;
12. int fpath(){
13.           int i;
14.           memset(pre,0,201);
15.           memset(sta,0,201);
16.           pos=0;
17.           qnum=1;
18.           que[0]=1;
19.           sta[0]=1;
20.           pre[0]=-1;
21.           while(pos< qnum){
22.                   for(i=1;i< =n;++i){
23.                           if(rm[que[pos]][i]>0&&sta[i]==0){
24.                                   que[qnum]=i;
25.                                   pre[qnum]=pos;
26.                                   if(i==n){
27.                                           return qnum;
28.                                   }
29.                                   sta[i]=1;
30.                                   ++qnum;
31.                           }
32.                   }
33.                   ++pos;
34.           }
35.           return -1;
36. }
37. void add(int num){
38.           int small=0x7fffffff;
39.           int pos=num;
40.           while(pre[pos]!=-1){
41.                   if(rm[que[pre[pos]]][que[pos]]< small){
42.                           small=rm[que[pre[pos]]][que[pos]];
43.                   }
44.                   pos=pre[pos];
45.           }
46.           pos=num;
47.           ans+=small;
48.           while(pre[pos]!=-1){
49.                   rm[que[pre[pos]]][que[pos]]-=small;
50.                   rm[que[pos]][que[pre[pos]]]+=small;
51.                   pos=pre[pos];
52.           }
53. }
54. int main()
55. {
56.           while(scanf("%d %d",&m,&n)!=EOF){
57.                   memset(rm,0,201*201*4);
58.                   int i;
59.                   int s,d,r;
60.                   for(i=0;i< m;++i){
61.                           scanf("%d %d %d",&s,&d,&r);
62.                           rm[s][d]+=r;
63.                   }
64.                   int tar;
65.                   ans=0;
66.                   while(1){
67.                           tar=fpath();
68.                           if(tar< 0){
69.                                   break;
70.                           }
71.                           add(tar);
72.                   }
73.                   printf("%d/n",ans);
74.           }
75.           return 0;
76. }

------------------------------hlpp------------------------------------

1. #include "stdio.h"
2. #include < queue>
3. using namespace std;
5. queue< int> que;
6. int ori[201][201];
7. int rm[201][201];
8. int high[201];
9. int e[201];
10. int m,n;
11. void init(){
12.           memset(high,0,201*4);
13.           memset(e,0,201*4);
14.           while(!que.empty()){
15.                   que.pop();
16.           }
17.           high[1]=n;
18.           int i;
19.           for(i=1;i< =n;++i){
20.                   if(ori[1][i]>0){
21.                           e[1]-=ori[1][i];
22.                           e[i]+=ori[1][i];
23.                           rm[1][i]=ori[1][i];
24.                           rm[i][1]=-rm[1][i];
25.                           que.push(i);
26.                   }
27.           }
28. }
29. int fpath(int num){
30.           int i;
31.           int small=0x7fffffff;
32.           int spos;
33.           for(i=1;i< =n;++i){
34.                   if(ori[num][i]-rm[num][i]>0){                
35.                           if(high[num]==high[i]+1){
36.                                   return i;
37.                           }
38.                           if(high[i]< small){
39.                                   small=high[i];
40.                                   spos=i;
41.                           }
42.                   }
43.           }
44.           high[num]=small+1;
45.           return spos;
46. }
47. void push(int s,int d){
48.           int max=ori[s][d]-rm[s][d];
49.           if(e[s]< max){
50.                   max=e[s];
51.           }
52.           e[s]-=max;
53.           e[d]+=max;
54.           rm[s][d]+=max;
55.           rm[d][s]=-rm[s][d];
56. }
57. void deal(){
58.           int now;
59.           int psta;
60.           while(!que.empty()){
61.                   now=que.front();
62.                   que.pop();
63.                   if(now==n){
64.                           continue;
65.                   }
66.                   while(e[now]>0){
67.                           psta=fpath(now);
68.                           push(now,psta);
69.                           que.push(psta);
70.                   }
71.           }
72. }
73. int main()
74. {
75.           while(scanf("%d %d",&m,&n)!=EOF){
76.                   int i,s,d,r;
77.                   memset(ori,0,201*201*4);
78.                   memset(rm,0,201*201*4);
79.                   for(i=0;i< m;++i){
80.                           scanf("%d %d %d",&s,&d,&r);
81.                           ori[s][d]+=r;
82.                   }
83.                   init();
84.                   deal();
85.                   printf("%d/n",e[n]);
86.           }
87.           return 0;
88. }