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

最新推荐文章于 2025-08-18 15:35:46 发布
转载 最新推荐文章于 2025-08-18 15:35:46 发布 · 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 832
2025年8月14日小结：（17号整理14号的笔记，这辈子真是有了w(ﾟДﾟ)w）昨天摔了跤大的，今天好妈妈在家，松弛。省流：6道中等，明天只学了10分钟嘻嘻。
C++面试中的手写快速排序：从基础到最优的完整思考过程
码事漫谈
08-18 417
手写快速排序的面试过程，实际上是考察候选人从"能工作"到"优秀"的思维演进能力。从基础实现出发，保证正确性逐步加入优化，展示深度思考主动分析复杂度，体现计算机科学基础讨论工程实践，展现实际经验引导技术对话，掌握面试节奏记住：面试官关心的不是你能否背出算法，而是你解决问题的思路和持续优化的能力。通过这样结构化的应对策略，你就能在排序算法面试中脱颖而出。
《算法导论》第 27 章 - 多线程算法
2302_80961196的博客
08-17 690
本文介绍了《算法导论》第27章的多线程算法内容，包括动态多线程基础、多线程矩阵乘法和多线程归并排序。通过C++实现代码，详细讲解了这三个经典算法的并行化设计思路和实现方法。文章首先阐述了动态多线程模型中的工作量、持续时间和并行度等核心概念，然后分别给出了并行求和、分块矩阵乘法和并行归并排序的具体实现，并分析了各算法的性能优化要点。最后提出了关于并行度分析、阈值优化、负载均衡等问题的思考题，帮助读者深入理解多线程算法的设计要点。文章为开发高性能并行程序提供了实用的理论基础和代码参考。
十一，算法-快速排序
hai_qin的博客
08-14 1175
本文介绍了快速排序算法及其应用。快速排序是一种基于分区和递归的高效排序算法，其核心思想是通过选取基准值将数组分成两个子数组，然后递归排序。文章详细说明了分区过程的操作步骤和代码实现，并分析了其O(NlogN)的平均时间复杂度。此外还介绍了快速选择算法，该算法通过部分使用快速排序思想，能以接近线性时间复杂度O(N)解决选择特定顺序元素的问题。快速排序和快速选择虽然实现较复杂，但在效率上优于其他基础排序算法。
【秋招笔试】2025.08.09网易秋招机考
最新发布
春秋招笔试突围
08-18 8
难度：简单这道题目是一个经典的模拟题，核心在于理解"先到先得"的分配规则。通过维护每个社团的剩余名额，按照学生提交的志愿顺序进行贪心分配，可以得到 O(n) 的高效解法。难度：中等这道题目巧妙地将组合优化问题转化为滑动窗口问题。关键观察是最优解必然对应排序后数组中的某个连续区间，通过双指针技术可以在 O(nm log(nm)) 时间内求解。难度：中等偏难这道题目结合了图论最短路和状态枚举。虽然看似复杂，但 k≤5 的限制使得 k! 种枚举成为可能。通过精确的状态模拟和路径规划，可以找到最优的收集策略。难度：
LeetCode 面试经典 150_数组/字符串_最后一个单词的长度（19_58_C++_简单）(反向遍历)
huayimenghan的博客
08-14 615
LeetCode 面试经典 150_数组/字符串_最后一个单词的长度（19_58_C++_简单） 题目描述： 给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个单词的长度。 单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值