ACM+算法集--常用ACM算法

最新推荐文章于 2025-08-17 21:40:23 发布
转载 最新推荐文章于 2025-08-17 21:40:23 发布 · 1.8k 阅读 · 0
文章标签：

#算法 #iostream #vector #math.h #struct 

图算法
 kurXX最小生成树
 #include <iostream>
 #include <math.h>
 #include <algorithm>
 using namespace std;
 #define M 501
 #define LIM 20000000
 
 struct edg{
     int u,v;
     int w;
 }all_e[M*M/2];
 bool operator < (const edg &a,const edg &b){
     return a.w<b.w;
 }
 int set[M];
 
 inline bool uni(int set[],int a,int b){ 
     int ac=0,a2=a,b2=b,bc=0;
     while(set[a]!=0) {a=set[a];ac++;}
     if(a2!=a) set[a2]=a;
     while(set[b]!=0) {b=set[b];bc++;}
     if(b2!=b) set[b2]=b;  
     if(a==b) return false;
     if(ac<bc) set[a]=b;
     else set[b]=a;
     return true;
 }
 int main(){
     int i,j,k,n,m,u,v,t;
     cin >> t;
     for(k=0;k<t;k++){
     memset(set,0,sizeof(set));
     cin >> n;
     int ei=0;
     for(i=1;i<=n;i++){
         for(j=1;j<=n;j++){
             if(t!=0){
                 edg e;
                 e.u=i;e.v=j;
                 scanf("%d",&e.w);
                 if(i<j)
                     all_e[ei++]=e;
             }
         }
     }
     sort(&all_e[0],&all_e[ei]);
     int count=0;
     int size=ei;
     int max=0;
     for(i=0;i<size && count < n-1;i++){
         if(uni(set,all_e[i].u,all_e[i].v)){
             count++;
             if(all_e[i].w>all_e[max].w) max=i;
         }
     }
     printf("%d\n",all_e[max].w);
     }
     return 0;
 }
 Prim
 #include <iostream>
 using namespace std;
 #define M 2001
 
 int set[M]={0},g[M][M];
 char str[M][8];
 
 inline void make_map(int n,int g[M][M]){
     int i,j,k;
     for(i=1;i<=n;i++){
         for(j=i+1;j<=n;j++){
             int c=0;
             for(k=0;k<7;k++)
                 if(str[i][k]!=str[j][k]) c++;
             g[i][j]=g[j][i]=c;
         }
     }
 }
 
 int main(){
     int n,q[M],qf=0,ql=0,d[M],u;
     char c;
     scanf("%d%c",&n,&c);
     int i;
     while(n!=0){
         memset(set,0,sizeof(set)); memset(g,0,sizeof(g));
         for(i=1;i<=n;i++) {
             scanf("%s",&str[i]);
             q[i-1]=i;
             d[i]=2000000;
         }
         qf=0;ql=n-1;
         make_map(n,g);
         int sum=0;
         int f=false;
         while(qf<=ql){
             int min=qf;
             for(i=qf+1;i<=ql;i++){
                 if(d[q[i]] < d[q[min]]) min=i;
             }
             swap(q[qf],q[min]);
             u=q[qf]; qf++;
             if(f) sum+=d[u];
             for(i=1;i<=n;i++){
                 if(g[u][i] !=0 && g[u][i] < d[i]) d[i]=g[u][i];
             }
             f=true;
         }
         printf("The highest possible quality is 1/%d.\n",sum);
         scanf("%d%c",&n,&c);
     }
     return 0;
 }
 堆实现最短路
 #include <iostream>
 #include <string>
 #include <stdlib.h>
 #include <vector>;
 using namespace std;
 #define M 1001
 #define LIM 2000000000
 
 struct dd{ //最短距离
     int w,q;//w是距离值,q是堆中的相对位置
 }d[M],d2[M];
 struct node{
     int v,w;
 };
 int h[M],hs;
 vector<node> g[M],g2[M];
 void change_key(dd d[M],int v,int w){
     d[v].w=w;
     int i=d[v].q;
     while(i>1 && d[h[i/2]].w>d[h[i]].w){
         swap(h[i],h[i/2]);
         swap(d[h[i]].q,d[h[i/2]].q);
         i=i/2;
     }
 }
 inline void min_heaphy(dd d[M],int *a,int i,int s){//s 为堆大小
     int l=i*2,r=i*2+1;
     int miner=i;
     if (l<=s && d[a[i]].w>d[a[l]].w)
         miner = l;
     else miner=i;
     if (r<=s && d[a[miner]].w>d[a[r]].w)
         miner=r;
     if(miner!=i){
         swap(a[i],a[miner]);
         swap(d[a[i]].q,d[a[miner]].q);
         min_heaphy(d,a,miner,s);
     }
 }
 inline void init(dd d[M],int n,int s){  //初始化图和堆
     int i;
     hs=n;
     for(i=1;i<=n;i++){d[i].w=LIM;h[i]=d[i].q=i;}
     change_key(d,s,0);
 }
 inline void relax(dd d[M],int u,int v,int duv){
     if(d[v].w>d[u].w+duv) change_key(d,v,d[u].w+duv);
 }
 void dijkstra(vector<node> g[M],dd d[M],int n,int s){ //n is |V| && s is the source
     init(d,n,s);
     int i;
     while(hs!=0){
         int u=h[1];
         swap(h[1],h[hs]);
         swap(d[h[1]].q,d[h[hs]].q);
         hs--;
         min_heaphy(d,h,1,hs);
         for(i=0;i<g[u].size();i++) relax(d,u,g[u][i].v,g[u][i].w);
     }
 }
 最短路DIJ普通版
 #define M 101
 #define LIM 20000000
 
 int g[M][M],d[M],fd[2][M][M],gt[M][M],set[M];
 inline void init(int d[M],int n,int s){  //初始化图
     int i;
     for(i=1;i<=n;i++)    d[i]=LIM;
     d[s]=0;
 }
 
 inline void relax(int d[M],int u,int v,int duv){
     if(d[v]>d[u]+duv)    d[v]=d[u]+duv;
 }
 void dijkstra(int g[M][M],int d[M],int n,int s){ //n is |V| && s is the source
     init(d,n,s);
     int q[M],ql=1,qf=1; //队列
     int i;
     for(i=1;i<=n;i++) q[ql++]=i;
     while(qf!=ql){
         int min=qf;
         for(i=qf;i<ql;i++) if(d[q[i]]<d[q[min]]) min=i; 
         swap(q[qf],q[min]); //q[qf] is the min
         int u=q[qf++];
         for(i=1;i<=n;i++){
             if(g[u][i]!=0) relax(d,u,i,g[u][i]);
         }
     }
 }
 floyd
 #include <iostream>
 #include <vector>
 using namespace std;
 #define M 301
 #define LIM 200000000
 int w[M][M],d[2][M][M];
 
 void floyd(int g[M][M],int d[2][M][M],int n){
     int i,j,k;
     for(i=1;i<=n;i++){
         for(j=1;j<=n;j++){
             d[0][i][j]=g[i][j];
         }
         d[0][i][i]=0;
     }        //这里是令d[0]=g
     for(k=1;k<=n;k++){
         for(i=1;i<=n;i++)
             for(j=1;j<=n;j++){
                 int t1=k%2; int t2=(t1+1)%2;
                 d[t1][i][j]=d[t2][i][j] < d[t2][i][k]+d[t2][k][j]?d[t2][i][j]:d[t2][i][k]+d[t2][k][j];
             }
     }
 }
 BELL_MAN
 inline void init(int d[M],int n,int s){  //初始化图
     int i;
     for(i=1;i<=n;i++)    d[i]=2000000000;
     d[s]=0;
 }
 
 inline void relax(int d[M],int u,int v,int duv){
     if(d[v]>d[u]+duv)    d[v]=d[u]+duv;
 }
 
 void bell_man(int g[M][M],int d[M],int n,int s){ //n个结点 s为源点
     int i,j,k;
     init(d,n,s);
     for(k=1;k<n;k++){
         for(i=1;i<=n;i++)
             for(j=1;j<=n;j++){
                 if(g[i][j]!=0) relax(d,i,j,g[i][j]);
             }
     }
 }
 拓扑排序
 #include <iostream>
 #include <stack>
 #include <vector>
 #include <list>
 using namespace std;
 vector <int> order;
 void find_id(list<int> g[],int id[],int n){  //寻找入度,没有使用
     int i;
     list<int>::iterator k;
     for(i=0;i<n;i++){
         for(k=g[i].begin();k!=g[i].end();k++){
             id[*k]++;
         }
     }
 }
 void topo(list<int> g[],int id[],int n,bool &OK,bool &incon){//OK==false 表示未确定顺序 incon==true 表示发现矛盾
     stack<int> s;
     order.erase(order.begin(),order.end());
     int t[26];
     copy(&id[0],&id[n],&t[0]);
     int i;
     for(i=0;i<n;i++){
         if(id[i]==0) 
             s.push(i);
     }
     if(s.size()!=1) OK=false;
     int count=0;
     while(!s.empty()){
         int v=s.top(); s.pop(); count++;
         order.push_back(v);
         list<int>::iterator k;
         for(k=g[v].begin();k!=g[v].end();k++){
             id[*k]--;
             if(id[*k]==0) s.push(*k);
             if(s.size()>1) OK=false;
         }
     }
     if(order.size() < n) OK=false;   //矛盾发生,会导致这种情况,小心
     if(count < n) incon=true;
     copy(&t[0],&t[n],&id[0]);
 }
 DFS强连通分支
 #include <iostream>
 #include <algorithm>
 #include <vector>
 using namespace std;
 #define M 20005
 vector<int> g[M],gt[M];
 bool used[M];
 int ft[M],sort_v[M],tim;
 bool comp(const int &u,const int &v){
     return ft[u]>ft[v];
 }
 inline int findp(int set[],int n){
     int n2=n;
     while(set[n]!=0) n=set[n];
     if(n2!=n) set[n2]=n;
     return n;
 }
 inline bool uni(int set[],int a,int b){ 
     int ac=0,a2=a,b2=b,bc=0,t;
     while(set[a]!=0) {a=set[a];ac++;}
     while(a2!=a) {t=set[a2]; set[a2]=a; a2=t;};
     while(set[b]!=0) {b=set[b];bc++;}
     while(b2!=b) {t=set[b2]; set[b2]=b; b2=t;}; 
     if(a==b) return false;
     if(ac<bc) set[a]=b;
     else set[b]=a;
     return true;
 }
 void dfs(vector<int> g[M],int u){
     if(used[u]) return;
     tim++;
     used[u]=true;
     int i;
     for(i=0;i<g[u].size();i++){
         dfs(g,g[u][i]);
     }
     tim++;
     ft[u]=tim;
     return;
 }
 void dfs2(vector<int> g[],int u,int r,int set[]){
     if(used[u]) return;
     uni(set,u,r);
     used[u]=true;
     int i;
     for(i=0;i<g[u].size();i++){
         dfs2(g,g[u][i],u,set);
     }
     return;
 }
 void scc(int n,vector<int> g[M],int set[]){
     int i,j;
     tim=0;
     memset(used,0,sizeof(used));
     memset(set,0,sizeof(set));
     for(i=1;i<=n;i++) sort_v[i]=i;
     for(i=1;i<=n;i++) if(!used[i]) dfs(g,i); //compute finishing times
     sort(&sort_v[1],&sort_v[n+1],comp); //decreasing f[u] order
     memset(used,0,sizeof(used));  
     for(i=1;i<=n;i++) for(j=0;j<g[i].size();j++) gt[g[i][j]].push_back(i); //compute gt
     for(i=1;i<=n;i++) if(!used[sort_v[i]]) dfs2(gt,sort_v[i],sort_v[i],set);  //make the scc
 }
 int main(){
     int i,j,n,m,u,v,set[M];
     cin >> n >> m;
     for(i=0;i<m;i++){
         scanf("%d%d",&u,&v);
         g[u].push_back(v);
     }
     scc(n,g,set);
     int pi=1,ptosc[M];
     struct Scc{
         int p,n;
     }sc[M];
     memset(sc,0,sizeof(sc));
     for(i=1;i<=n;i++){
         int p=findp(set,i);
         if(sc[p].p==0) {sc[p].p=pi; ptosc[pi++]=p;}
         sc[p].n++;
     }
     int n2=pi-1,od[M];
     memset(od,0,sizeof(od));
     for(i=1;i<=n;i++){
         for(j=0;j<g[i].size();j++){
             u=findp(set,i); v=findp(set,g[i][j]);
             if(sc[u].p!=sc[v].p) od[sc[u].p]++;
         }
     }
     int sum=0,s1=0;
     for(i=1;i<=n2;i++) if(od[i]==0) {s1++; sum+=sc[ptosc[i]].n;}
     if(s1!=1) sum=0;
     cout << sum << endl;
 }
 最大匹配
 #include <iostream>
 #include <string>
 #include <math.h>
 using namespace std;
 #define M 1001
 
 int n,m,match[M],ans[M];
 bool visit[M],g[M][M];
 //O(n^3)
 bool dfs(int k,bool map[M][M]){  
     int t;
     for(int i = 1; i <= m; i++){
         if(map[k][i] && !visit[i]){
             visit[i] = true;
             t = match[i];
             match[i] = k;
             if(t == 0 || dfs(t,map))
                 return true;
             match[i] = t;
         }
     }
     return false;
 }
 int main(){
     int i,sum=0,t,j,u,v;
     cin >> t;
     while(t--){
         sum=0;
         memset(match,0,sizeof(match));
         memset(g,0,sizeof(g));
         scanf("%d%d",&n,&m);
         for(i=1;i<=m;i++){
             scanf("%d%d",&u,&v);
             g[u][v]=true;
         }
         m=n;
         for(i=1;i<=n; i++){
             memset(visit,0,sizeof(visit));
             if(dfs(i,g))  sum++;
         }
         cout << n-sum << endl;
     }
     return 0;
 }
 还有两个最大匹配模板
 #include <iostream>
 #include <string>
 #include <math.h>
 #include <vector>
 using namespace std;
 #define M 3001
 
 bool g[M][M];
 int mk[M] ,cx[M],pred[M],open[M],cy[M],nx,ny;
 
 
 //边少适用O(n^3)
 int MaxMatchBFS()
 {
     int i , u , v , t , d , e , cur , tail , res(0) ;
     memset(mk , 0xff , sizeof(mk)) ; 
     memset(cx , 0xff , sizeof(cx)) ;
     memset(cy , 0xff , sizeof(cy)) ;
     for (i = 0 ; i < nx ; i++){
         pred[i] = -1 ;
         for (open[cur = tail = 0] = i ; cur <= tail && cx[i] == -1 ; cur++){
             for (u = open[cur] , v = 0 ; v < ny && cx[i] == -1 ; v ++) if (g[u][v] && mk[v] != i)
             {
                 mk[v] = i ; open[++tail] = cy[v] ; if (open[tail] >= 0) { pred[open[tail]] = u ; continue ; }
                 for (d = u , e = v ; d != -1 ; t = cx[d] , cx[d] = e , cy[e] = d , e = t , d = pred[d]) ;
             }
         }
         if (cx[i] != -1) res++ ;
     }
     return res ;
 }
 
 int path(int u){
     for (int v = 0 ; v < ny ; v++) 
         if (g[u][v] && !mk[v]){
             mk[v] = 1 ; 
             if (cy[v] == -1 || path(cy[v])) {
                 cx[u] = v ; 
                 cy[v] = u ; 
                 return 1 ; 
             }
         } return 0 ;
 }
 //少适用O(n^3)
 int MaxMatchDFS()
 {
     int res(0) ;
     memset(cx , 0xff , sizeof(cx)) ; 
     memset(cy , 0xff , sizeof(cy)) ;
     for (int i = 0 ; i < nx ; i++) 
         if (cx[i] == -1){
             memset(mk , 0 , sizeof(mk)); 
             res += path(i) ;
         }
         return res ;
 }
 最大权匹配,KM算法
 //此KM算法，坐标从1开始，记住
 #include <iostream>
 #include <vector>
 #include <math.h>
 using namespace std;
 #define M 110
 
 int n;                // X 的大小
 int lx[M], ly[M];        // 标号
 bool sx[M], sy[M];    // 是否被搜索过
 int match[M];        // Y(i) 与 X(match [i]) 匹配
 
 // 从 X(u) 寻找增广道路，找到则返回 true
 bool path(int u,int weight[M][M]) {
     sx [u] = true;
     for (int v = 0; v < n; v ++)
         if (!sy [v] && lx[u] + ly [v] == weight [u] [v]) {
             sy [v] = true;
             if (match [v] == -1 || path(match [v],weight)) {
                 match [v] = u;
                 return true;
             }
         }
     return false;
 }
 // 参数 Msum 为 true ，返回最大权匹配，否则最小权匹配
 int km(bool Msum,int weight[M][M]) {
     int i, j;
     if (!Msum) {
         for (i = 0; i < n; i ++)
             for (j = 0; j < n; j ++)
                 weight [i] [j] = -weight [i] [j];
     }
     // 初始化标号
     for (i = 0; i < n; i ++) {
         lx [i] = -0x1FFFFFFF;
         ly [i] = 0;
         for (j = 0; j < n; j ++)
             if (lx [i] < weight [i] [j])
                 lx [i] = weight [i] [j];
     }  
     memset(match, -1, sizeof (match));
     for (int u = 0; u < n; u ++)
         while (1) {
             memset(sx, 0, sizeof (sx));
             memset(sy, 0, sizeof (sy));
             if (path(u,weight))
                 break;      
             // 修改标号
             int dx = 0x7FFFFFFF;
             for (i = 0; i < n; i ++)
                 if (sx [i])
                     for (j = 0; j < n; j ++)
                         if(!sy [j])
                             dx = min(lx[i] + ly [j] - weight [i] [j], dx);
             for (i = 0; i < n; i ++) {
                 if (sx [i])
                     lx [i] -= dx;
                 if (sy [i])
                     ly [i] += dx;
             }
         }
     
     int sum = 0;
     for (i = 0; i < n; i ++)
         sum += weight [match [i]] [i];
     
     if (!Msum) {
         sum = -sum;
         for (i = 0; i < n; i ++)
             for (j = 0; j < n; j ++)
                 weight [i] [j] = -weight [i] [j];         // 如果需要保持 weight [ ] [ ] 原来的值，这里需要将其还原
     }
     return sum;
 }
 
 struct Point{
     int r,c;
 };
 int main(){
     int i,j,m;
     freopen("in","r",stdin);
     int w[M][M];
     char c; Point pt;
     while(cin >> n >> m && (n!=0 || m!=0)){
         vector<Point> vh,vm;
         for(i=0;i<n;i++){
             getchar();
             for(j=0;j<m;j++){
                 scanf("%c",&c);
                 if(c=='H'){
                     pt.r=i; pt.c=j;
                     vh.push_back(pt);
                 }
                 if(c=='m'){
                     pt.r=i;pt.c=j;
                     vm.push_back(pt);
                 }
             }
         }
         for(i=0;i<vm.size();i++) for(j=0;j<vh.size();j++) w[i][j]=abs(vm[i].r-vh[j].r)+abs(vm[i].c-vh[j].c);
         n=vm.size();
         cout << km(false,w)<< endl;
     }
 }
 两种欧拉路
 无向图：
 #define M 45
 int used[M][M],id[M];
 void dfs(int u,vector<int> g[],vector<int> &vans){  //O（E^2）
     int j,w,v,t;
     for(j=g[u].size()-1;j>=0;j--){
         t=v=g[u][j]; w=u;
         if(v>w) swap(v,w);
         if(used[v][w]!=0){
             used[v][w]--;
             dfs(t,g,vans);
         }
     }
     vans.push_back(u);
 }
 
 有向图：
 int n,m;
 vector<int> g[M],vans;
 void dfs(int u){   //O（E^2*log(e)）
     int j,t;
     Edg et;
     for(j=g[u].size()-1;j>=0;j--){
         et.u=u; et.v=g[u][j];
         if(mp[et]!=0){
             mp[et]--;
             dfs(g[u][j]);
         }
     }
     vans.push_back(u);
 }
 
 【最大流】Edmonds Karp
 //求最小割集合的办法:
 //设置一个集合A, 最开始A={s},按如下方法不断扩张A:
 //1 若存在一条边(u,v), 其流量小于容量，且u属于A,则v加入A
 //2 若存在(v,u), 其流量大于0，且u属于A,则v加入A
 
 //A计算完毕，设B=V-A，
 //最大流对应的割集E={(u,v) | u∈A,v∈B}
 //E为割集，这是一定的
 
 //【最大流】Edmonds Karp算法求最大流,复杂度 O(V E^2)。返回最大流,输入图容量
 //矩阵g[M][M],取非零值表示有边，s为源点，t为汇点，f[M][M]返回流量矩阵。
 
 int f[M][M],g[M][M];
 
 int EdmondsKarp(int n,int s,int t){    
     int i,j,k,c,head,tail,flow=0;
     int r[M][M];
     int prev[M],visit[M],q[M];
     for (i=1;i<=n;i++) for (j=1;j<=n;j++) {f[i][j]=0;r[i][j]=g[i][j];} //初始化流量网络和残留网络
     while (1) { //在残留网络中找到一条s到t的最短路径
         head=tail=0;
         memset(visit,0,sizeof(visit));
         q[tail++]=s;
         prev[s]=-1; visit[s]=1;
         while(head!=tail){  //宽度优先搜索从s到t的最短路径
             k=q[head++];
             for (i=1;i<=n;i++)
                 if (!visit[i] && r[k][i]>0) {
                     visit[i]=1;
                     prev[i]=k;
                     if (i==t) goto next;
                     q[tail++]=i;
                 }
         }
 next:    
         if (!visit[t]) break; //流量已达到最大
         c=99999999;
         j=t;
         while (j!=s) {
             i=prev[j];
             if (c>r[i][j]) c=r[i][j];
             j=i;
         }
         //下面改进流量
         j=t;
         while (j!=s) {
             i=prev[j];
             f[i][j]+=c;
             f[j][i]=-f[i][j];
             r[i][j]=g[i][j]-f[i][j];
             r[j][i]=g[j][i]-f[j][i];
             j=i;
         }
         flow+=c;
         //cout << c << endl;
     }
     return flow;
 }
 dinic
 /* 
 dinic 
 BFS+多路增广 
 这个模板是OIBH上的Code_Rush的，他写的Dinic和别人的不太一样，速度更快 
 O(mn^2) 
 */ 
 
 #include<stdio.h> 
 #include<list> 
 #include<queue> 
 #include<string.h> 
 #include <vector>
 #include <iostream>
 using namespace std; 
 #define M 201
 int pre[M]; 
 int f[M][M],g[M][M]; 
 bool b[M]={0}; 
 
 //g为输入的图容量矩阵,f为返回流量矩阵
 int dinic(int n,int s,int t) 
 { 
     memset(f,0,sizeof(f));
     int ans=0; 
     while(true) 
     {
         queue<int> q; 
         fill(pre,pre+n+2,-1); 
         fill(b,b+n+2,0); 
         q.push(s);b[s]=1; 
         while(!q.empty()) 
         { 
             int x=q.front();q.pop(); 
             if(x==t)break; 
             for(int i=1;i<=n;i++) 
             {
                 if(!b[i]&&f[x][i]<g[x][i]) 
                 { 
                     pre[i]=x; 
                     b[i]=1; 
                     q.push(i); 
                 } 
             }
         } 
         if(pre[t]==-1)break; 
         for(int i=1;i<=n;i++) 
         {
             if(f[i][t]<g[i][t]&&(i==s||pre[i]!=-1)) 
             { 
                 int v,low=g[i][t]-f[i][t]; 
                 pre[t]=i; 
                 for(v=t;pre[v]!=-1;v=pre[v]) 
                     low=low<g[pre[v]][v]-f[pre[v]][v]?low:g[pre[v]][v]-f[pre[v]][v]; 
                 if(low==0)continue; 
                 for(v=t;pre[v]!=-1;v=pre[v]) 
                 { 
                     f[pre[v]][v]+=low; 
                     f[v][pre[v]]-=low; 
                 } 
                 ans+=low; 
             } 
         }
     } 
     return ans;
 }  
 
 int main(){
     int m,n,i,j,u,v,w;
     while(cin >> m >> n){
         memset(g,0,sizeof(g));
         for(i=0;i<m;i++){
             scanf("%d%d%d",&u,&v,&w);
             g[u][v]+=w;
         }
         cout << dinic(n,1,n) << endl;
     }
 }
 【最小费用最大流】Edmonds Karp对偶算法
 #define M 211
 #define LIM 99999999
 //【最小费用最大流】Edmonds Karp对偶算法,复杂度 O(V^3E^2)。返回最大流,输入图
 //容量矩阵g[M][M],费用矩阵w[M][M],取非零值表示有边，s为源点，t为汇点，f[M][M]返
 //回流量矩阵，minw返回最小费用。
 int g[M][M],w[M][M],minw,f[M][M];
 int DualityEdmondsKarp(int n,int s,int t){    
     int i,j,k,c,quit,flow=0;
     int best[M],prev[M];
     minw=0;
     for (i=1;i<=n;i++) {
         for (j=1;j<=n;j++){
             f[i][j]=0;
             if (g[i][j]) {g[j][i]=0;w[j][i]=-w[i][j];}
         }
     }
     while (1) {
         for (i=1;i<=n;i++) best[i]=LIM;
         best[s]=0;
         do {
             quit=1;
             for (i=1;i<=n;i++){
                 if (best[i]<LIM)
                     for (j=1;j<=n;j++){
                         if (f[i][j]<g[i][j] && best[i]+w[i][j]<best[j]){
                             best[j]=best[i]+w[i][j];
                             prev[j]=i;
                             quit=0;
                         }
                     }
             }
         }while(!quit);
         if (best[t]>=LIM) break;
         c=LIM;
         j=t;
         while (j!=s) {
             i=prev[j];
             if (c>g[i][j]-f[i][j]) c=g[i][j]-f[i][j];
             j=i;
         }
         j=t;
         while (j!=s) {
             i=prev[j];
             f[i][j]+=c;
             f[j][i]=-f[i][j];
             j=i;
         }
         flow+=c; minw+=c*best[t];
     }
     return flow;
 }


ACM中常用算法----字符串集合
西红柿爱炒番茄
09-15 268
链接： https://blog.csdn.net/ck_boss/article/details/47066727
ACM入门
越看越喜欢啊
08-22 2263
一般的入门顺序：0. C语言的基本语法(或者直接开C++也行，当一个java选手可能会更受欢迎，并且以后工作好找，但是难度有点大)，【参考书籍：刘汝佳的《算法竞赛入门经典》，C++入门可以考虑《c++ primer plus》，java选手可以考虑《think in java》or中文版《java编程思想》，请远离谭浩强…】可以选择切一些特别水的题巩固以及适应一下ACM中常见的输入输出格式…例如杭...
ACM常用算法分类
AC_Dreameng
09-02 4375
数据结构        栈，队列，链表        •哈希表，哈希数组        •堆，优先队列               双端队列               可并堆               左偏堆        •二叉查找树               Treap               伸展树        •并查集               集合
学ACM的必备基础算法
Fighting-Dawn丶的专栏
01-02 3153
不知是哪位大牛写的，迷茫的参考一下吧！ 参加ACM比赛一般要做到50行以内的程序不用调试、100行以内的二分钟内调试成功.acm主要是考算法的，主要时间是花在思考算法上，不是花在写程序与debug上。  第一阶段：  练经典常用算法，下面的每个算法给我打上十到二十遍，同时自己精简代码，因为太常用，所以要练到写时不用想，10-15分钟内打完，甚至关掉显示器都可以把程序打  出来.  1.最短路(Fl...
ACM算法竞赛---学习路线---初级
2301_82023330的博客
12-29 1196
1.1链表1.2队列1.3栈1.4二叉树和哈夫曼树。
ACM算法设计---BFS、DFS
lshsgbb2333的博客
06-02 453
点击打开链接
ACM算法竞赛---学习路线---中级
2301_82023330的博客
04-16 743
7.6 Catalan数和Stirling数。6.14 整除分块(数论分块)3.9IDDFS和IDA*10.4 无向图的连通性。10.5 有向图的连通性。2.5倍增法与ST算法。3.6BFS与优先队列。6.5 异或空间线性基。6.6 0/1分数规划。6.8 线性丢番图方程。2.10贪心法与拟阵。4.5分块与莫队算法。4.13Treap树。6.11 威尔逊定理。10.9 最小生成树。
ACM算法基础-kmp算法详解
PengHao666999的博客
10-03 1万+
问题背景：kmp算法最直接的引用就是模式串和文本串的匹配，我们假设直接用暴力的方法进行匹配的话，方法很简单，就是两个指针，i指针最初指向文本串的起始位置，j指针最初指向模式串的起始位置，然后从文本串的起始位置开始每一位与模式串的每一位进行匹配，如果每一位都是相同的话，那么就继续匹配下一位，当我们只要匹配到有一位是不相等的时候，我们就将文本串的起始位置变成i1，然后继续从模式串的起始位置开始匹配，假设模式串和文本串的长度分别是n和m，时间复杂度是O(n*m)​,暴力确实太可怕了。
简单易学的机器学习算法——K-Means++算法
热门推荐
null的专栏
12-06 3万+
K-Means++
ACM-ICPC算法汇总【基础篇】
佛系更新
06-15 8590
本篇博客包含ACM，NOIP所涉及的基础算法，涵盖七个模块：基础算法，数据结构，搜索与图论，STL，数学知识（数论），动态规划，贪心。涵盖内容范围较为全面，是面向初学者的算法汇总，第八个章节是所涉及的算法板子，可以直接使用。因为是面向算法竞赛，本文的所有设计算法都是用C++进行实现的，不提供其他语言的代码，共涉及106道算法题目，以题代讲，在题目中理解算法的内涵。
acm 算法集-常用acm算法.pdf
03-21
acm 算法集--常用acm算法
**acm协会算法模板-ACM资源
05-17
其算法模板是该协会为了帮助参赛者更好地准备比赛而提供的一系列常用的算法框架和解题思路。这些模板经过长时间的积累和总结，已经成为了ACM竞赛中的重要参考资源。 算法模板的核心内容通常包括了各种算法的实现，...
机试备考笔记 14/31
m0_73354184的博客
08-17 805
2025年8月14日小结：（17号整理14号的笔记，这辈子真是有了w(ﾟДﾟ)w）昨天摔了跤大的，今天好妈妈在家，松弛。省流：6道中等，明天只学了10分钟嘻嘻。
插入排序专栏
2202_75362996的博客
08-14 947
本文详细解析了插入排序算法，包括其工作原理、Java实现和时间复杂度分析。插入排序通过将数组分为已排序和未排序区间，逐步将元素插入到正确位置，平均和最坏时间复杂度均为O(n²)，最好情况为O(n)。文章分析了不同情况下的性能表现，指出其适用于小规模或基本有序数据，并讨论了优化思路（如减少交换次数和使用二分查找）。作为稳定且空间复杂度O(1)的原地排序算法，插入排序在特定场景下效率较高，也可作为复杂算法的子过程。
《算法导论》第 27 章 - 多线程算法
最新发布
2302_80961196的博客
08-17 572
本文介绍了《算法导论》第27章的多线程算法内容，包括动态多线程基础、多线程矩阵乘法和多线程归并排序。通过C++实现代码，详细讲解了这三个经典算法的并行化设计思路和实现方法。文章首先阐述了动态多线程模型中的工作量、持续时间和并行度等核心概念，然后分别给出了并行求和、分块矩阵乘法和并行归并排序的具体实现，并分析了各算法的性能优化要点。最后提出了关于并行度分析、阈值优化、负载均衡等问题的思考题，帮助读者深入理解多线程算法的设计要点。文章为开发高性能并行程序提供了实用的理论基础和代码参考。
十一，算法-快速排序
hai_qin的博客
08-14 1160
本文介绍了快速排序算法及其应用。快速排序是一种基于分区和递归的高效排序算法，其核心思想是通过选取基准值将数组分成两个子数组，然后递归排序。文章详细说明了分区过程的操作步骤和代码实现，并分析了其O(NlogN)的平均时间复杂度。此外还介绍了快速选择算法，该算法通过部分使用快速排序思想，能以接近线性时间复杂度O(N)解决选择特定顺序元素的问题。快速排序和快速选择虽然实现较复杂，但在效率上优于其他基础排序算法。
LeetCode 3467.将数组按照奇偶性转化
tus00000的博客
08-16 217
将偶数（4 和 2）替换为 0，将奇数（1, 5 和 1）替换为 1。现在，nums = [1, 1, 1, 0, 0]。现在，nums = [0, 1, 0, 1]。按非递减顺序排序 nums，得到 nums = [0, 0, 1, 1, 1]。按非递减顺序排序 nums，得到 nums = [0, 0, 1, 1]。输入：nums = [1,5,1,4,2]输入：nums = [4,3,2,1]输出：[0,0,1,1,1]输出：[0,0,1,1]将每个偶数替换为 0。将每个奇数替换为 1。
深入浅出讲解：DFS深度优先搜索+剪枝-解决最小互质分组问题
飞起来的喵
08-14 601
回溯就像你在迷宫中探索路径：遇到岔路口时，你选择一条路走下去如果发现是死路，你会返回到上一个岔路口（这就是回溯）然后尝试另一条路在DFS中，回溯就是撤销上一步操作，回到之前的状态，尝试其他可能性。探索所有可能性：每个数字都可能属于任何兼容的组或新组避免状态污染：DFS是一条路走到底，但我们需要"重置"状态尝试其他路径寻找最优解：只有尝试所有组合，才能保证找到最小分组数节省内存：通过状态重用，只需一个全局状态而非每个分支独立拷贝当前分组数超过最优解：发生在DFS探索非最优路径时剪枝原理。
ACM经典算法集：构建最小生成树与并查集应用
本文档是一份针对ACM（美国计算机协会）竞赛中的常用算法集合，特别是关于图算法部分。作者提供了一个名为Kruskal's Minimal Spanning Tree（克鲁斯卡尔最小生成树）的实现代码模板，这是解决图论问题中经典的一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值