网络流24题解题报告小结

1
飞行员配对方案问题 二分图最大匹配
网络最大流

#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;

#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b) for( int i = (a) ; i <= (b) ; i ++)
#define FFF(i,a) for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b) for( int i = (a) ; i >= (b) ; i --)
#define S64(a) scanf(in64,&a)
#define SS(a) scanf("%d",&a)
#define LL(a) ((a)<<1)
#define RR(a) (((a)<<1)+1)
#define pb push_back
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define CL(Q) while(!Q.empty())Q.pop()
#define MM(name,what) memset(name,what,sizeof(name))
#define read freopen("in.txt","r",stdin)
#define write freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int maxn = 222;
const int head = 0;
const int end = 221;

struct zz
{
int from;
int to;
int c;
int id;
}zx;
int m,n;
vector<zz>g[maxn];
int cen[maxn];

void link(int now,int to,int c,int bc)
{
zx.from = now;
zx.to = to;
zx.c = c;
zx.id = g[zx.to].size();
g[zx.from].pb(zx);
swap(zx.from,zx.to);
zx.c = bc;
zx.id = g[zx.to].size()-1;
g[zx.from].pb(zx);
return ;
}

bool bfs()
{
MM(cen,-1);
queue<int>q;
int now,to;
q.push(head);
cen[head]=0;
while(!q.empty())
{
now = q.front();
q.pop();
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c > 0 && cen[to]==-1)
{
cen[to]=cen[now]+1;
q.push(to);
}
}
}
return cen[end]!=-1;
}

int dfs(int flow = inf,int now = head)
{
if(now == end)
{
return flow;
}
int to,sum=0;
int temp;
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c>0 && flow>sum && cen[to]==cen[now]+1)
{
temp = dfs(min(flow-sum,g[now][i].c),to);
sum+=temp;
g[now][i].c-=temp;
g[to][g[now][i].id].c+=temp;
}
}
if(!sum) cen[now]=-1;
return sum;
}

int dinic()
{
int ans = 0;
while(bfs())
{
ans+=dfs();
}
return ans;
}

int main()
{
int now,to;
while(cin>>m>>n)
{
for(int i=0;i<maxn;i++)
{
g[i].clear();
}
while(cin>>now>>to)
{
if(now==to && now==-1)
{
break;
}
else
{
link(now,to,1,0);
}
}
for(int i=1;i<=m;i++)
{
link(head,i,1,0);
}
for(int i=m+1;i<=m+n;i++)
{
link(i,end,1,0);
}
cout<<dinic()<<endl;
for(int i=1;i<=m;i++)
{
for(int j=0;j<g[i].size();j++)
{
if(g[i][j].c==0 && g[i][j].to!=head)
{
cout<<i<<" "<<g[i][j].to<<endl;
}
}
}
}
return 0;
}
2
太空飞行计划问题 最大权闭合图
网络最小割

#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;

#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b) for( int i = (a) ; i <= (b) ; i ++)
#define FFF(i,a) for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b) for( int i = (a) ; i >= (b) ; i --)
#define S64(a) scanf(in64,&a)
#define SS(a) scanf("%d",&a)
#define LL(a) ((a)<<1)
#define RR(a) (((a)<<1)+1)
#define pb push_back
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define CL(Q) while(!Q.empty())Q.pop()
#define MM(name,what) memset(name,what,sizeof(name))
#define read freopen("in.txt","r",stdin)
#define write freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int maxn = 222;
const int add = 111;
const int head = 0;
const int end = 221;

struct zz
{
int from;
int to;
int c;
int id;
}zx;

vector<zz>g[maxn];
int cen[maxn];
int tot;
vector<int>v;
int m,n;
bool vis[maxn];

void link(int now,int to,int c,int bc)
{
zx.from = now;
zx.to = to;
zx.c = c;
zx.id = g[zx.to].size();
g[zx.from].pb(zx);
swap(zx.from,zx.to);
zx.c = bc;
zx.id = g[zx.to].size()-1;
g[zx.from].pb(zx);
return ;
}

bool bfs()
{
MM(cen,-1);
queue<int>q;
cen[head] = 0;
q.push(head);
int now,to;
while(!q.empty())
{
now=q.front();
q.pop();
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c > 0 && cen[to]==-1)
{
cen[to] = cen[now]+1;
q.push(to);
}
}
}
return cen[end]!=-1;
}

int dfs(int flow = inf,int now = head)
{
if(now == end) return flow;
int to,temp,sum=0;
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(flow>sum && g[now][i].c>0 && cen[to]==cen[now]+1)
{
temp = dfs(min(g[now][i].c,flow-sum),to);
sum += temp;
g[now][i].c-=temp;
g[to][g[now][i].id].c+=temp;
}
}
if(!sum) cen[now]=-1;
return sum;
}

int dinic()
{
int ans = 0;
while(bfs())
{
ans+=dfs();
}
return tot-ans;
}

void find()
{
bfs();
MM(vis,false);
for(int now=0;now<maxn;now++)
{
if(cen[now]==-1) continue;
for(int i=0;i<g[now].size();i++)
{
int to = g[now][i].to;
if(cen[to]==-1)
{
if(now == head)
{
vis[to]=true;
}
else if(to == end)
{
v.pb(now-add);
}
}
}
}
return ;
}

int main()
{
while(cin>>m>>n)
{
tot=0;
for(int i=0;i<maxn;i++)
{
g[i].clear();
}
int s,to;
for(int now=1;now<=m;now++)
{
cin>>s;
tot+=s;
link(head,now,s,0);
while(cin.peek()!='\n')
{
cin>>to;
to+=add;
link(now,to,inf,0);
}
}
for(int now=1;now<=n;now++)
{
cin>>s;
to = now+add;
link(to,end,s,0);
}
int ans = dinic();
v.clear();
find();
int ti;
for(int i=1;i<=m;i++)
{
if(!vis[i])
{
ti = i;
cout<<i;
break;
}
}
for(int i=ti+1;i<=m;i++)
{
if(!vis[i])
{
cout<<" "<<i;
}
}
cout<<endl;
if(!v.empty()) cout<<v[0];
for(int i=1;i<v.size();i++)
{
cout<<" "<<v[i];
}
cout<<endl;
cout<<ans<<endl;
}
return 0;
} 3
最小路径覆盖问题 有向无环图最小路径覆盖
网络最大流

#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;

#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b)      for( int i = (a) ; i <= (b) ; i ++)
#define FFF(i,a)        for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b)      for( int i = (a) ; i >= (b) ; i --)
#define S64(a)          scanf(in64,&a)
#define SS(a)           scanf("%d",&a)
#define LL(a)           ((a)<<1)
#define RR(a)           (((a)<<1)+1)
#define pb              push_back
#define MAX(a,b)        ((a)>(b)?(a):(b))
#define MIN(a,b)        ((a)<(b)?(a):(b))
#define CL(Q)           while(!Q.empty())Q.pop()
#define MM(name,what)   memset(name,what,sizeof(name))
#define read            freopen("in.txt","r",stdin)
#define write           freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int maxn = 555;
const int add = 222;
const int head = 0;
const int end = 551;

struct zz
{
int from;
int to;
int c;
int id;
}zx;

vector<zz>g[maxn];
int cen[maxn];
int n,m;
bool vis[maxn];
int go[maxn];

void link(int now,int to,int c,int bc)
{
zx.from = now;
zx.to = to;
zx.c = c;
zx.id = g[zx.to].size();
g[zx.from].pb(zx);
swap(zx.from,zx.to);
zx.c = bc;
zx.id = g[zx.to].size()-1;
g[zx.from].pb(zx);
return ;
}

bool bfs()
{
queue<int>q;
MM(cen,-1);
cen[head]=0;
q.push(head);
int now,to;
while(!q.empty())
{
now = q.front();
q.pop();
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(cen[to]==-1 && g[now][i].c>0)
{
cen[to]=cen[now]+1;
q.push(to);
}
}
}
return cen[end]!=-1;
}

int dfs(int flow=inf,int now=head)
{
if(now == end) return flow;
int to,temp,sum=0;
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c>0 && flow>sum && cen[to]==cen[now]+1)
{
temp = dfs(min(flow-sum,g[now][i].c),to);
sum+=temp;
g[now][i].c-=temp;
g[to][g[now][i].id].c+=temp;
}
}
if(!sum) cen[now] = -1;
return sum;
}

int dinic()
{
int ans = 0;
while(bfs())
{
ans+=dfs();
}
return ans;
}

int main()
{
while(cin>>n>>m)
{
for(int i=0;i<maxn;i++)
{
g[i].clear();
}
int now,to;
for(int i=1;i<=m;i++)
{
cin>>now>>to;
link(now,to+add,1,0);
}
for(int i=1;i<=n;i++)
{
link(head,i,1,0);
}
for(int i=1+add;i<=n+add;i++)
{
link(i,end,1,0);
}
int ans = dinic();
ans = n-ans;
MM(vis,false);
MM(go,0);
for(int i=1;i<=n;i++)
{
for(int j=0;j<g[i].size();j++)
{
to = g[i][j].to;
if(g[i][j].c == 0 && to!=head)
{
go[i]=to-add;
vis[to-add]=true;
}
}
}
for(int i=1;i<=n;i++)
{
if(!vis[i])
{
now = i;
cout<<now;
while(go[now])
{
cout<<" "<<go[now];
now = go[now];
}
cout<<endl;
}
}
cout<<ans<<endl;
}
return 0;
}

4 魔术球问题
有向无环图最小路径覆盖 网络最大流

#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;

#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b)      for( int i = (a) ; i <= (b) ; i ++)
#define FFF(i,a)        for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b)      for( int i = (a) ; i >= (b) ; i --)
#define S64(a)          scanf(in64,&a)
#define SS(a)           scanf("%d",&a)
#define LL(a)           ((a)<<1)
#define RR(a)           (((a)<<1)+1)
#define pb              push_back
#define MAX(a,b)        ((a)>(b)?(a):(b))
#define MIN(a,b)        ((a)<(b)?(a):(b))
#define CL(Q)           while(!Q.empty())Q.pop()
#define MM(name,what)   memset(name,what,sizeof(name))
#define read            freopen("in.txt","r",stdin)
#define write           freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int maxn = 4555;
const int add = 2222;
const int end = 4554;
const int head = 0;

struct zz
{
int from;
int to;
int c;
int id;
}zx;

vector<zz>g[maxn];
int cen[maxn];
int n;
bool vis[maxn];
int go[maxn];
bool sq[10001];

void link(int now,int to,int c,int bc)
{
zx.from = now;
zx.to = to;
zx.c = c;
zx.id = g[zx.to].size();
g[zx.from].pb(zx);
swap(zx.from,zx.to);
zx.c = bc;
zx.id = g[zx.to].size()-1;
g[zx.from].pb(zx);
return ;
}

bool bfs()
{
queue<int>q;
MM(cen,-1);
cen[head]=0;
q.push(head);
int now,to;
while(!q.empty())
{
now = q.front();
q.pop();
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(cen[to]==-1 && g[now][i].c>0)
{
cen[to]=cen[now]+1;
q.push(to);
}
}
}
return cen[end]!=-1;
}

int dfs(int flow=inf,int now=head)
{
if(now == end) return flow;
int to,temp,sum=0;
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c>0 && flow>sum && cen[to]==cen[now]+1)
{
temp = dfs(min(flow-sum,g[now][i].c),to);
sum+=temp;
g[now][i].c-=temp;
g[to][g[now][i].id].c+=temp;
}
}
if(!sum) cen[now] = -1;
return sum;
}

int dinic()
{
int ans = 0;
while(bfs())
{
ans+=dfs();
}
return ans;
}

void extend(int x)
{
for(int i=1;i<x;i++)
{
if(sq[i+x])
{
link(i,x+add,1,0);
}
}
link(head,x,1,0);
link(x+add,end,1,0);
return ;
}

void start()
{
for(int i=0;i<maxn;i++)
{
g[i].clear();
}
int flow = 0;
int temp = 0;
int tot;
for(int i=1;temp<=n;i++)
{
extend(i);
flow += dinic();
temp = i-flow;
tot=i;
}
tot--;
for(int i=0;i<maxn;i++)
{
g[i].clear();
}
for(int i=1;i<=tot;i++)
{
extend(i);
}
int ans = dinic();
MM(vis,false);
MM(go,0);
int to;
for(int i=1;i<=tot;i++)
{
for(int j=0;j<g[i].size();j++)
{
to = g[i][j].to;
if(to!=head && g[i][j].c == 0)
{
go[i]=to-add;
vis[to-add] = true;
}
}
}
int now;
cout<<tot<<endl;
for(int i=1;i<=tot;i++)
{
if(!vis[i])
{
cout<<i;
now = i;
while(go[now])
{
cout<<" "<<go[now];
now = go[now];
}
cout<<endl;
}
}
return ;
}

int main()
{
MM(sq,false);
for(int i=1;i<=100;i++)
{
sq[i*i]=true;
}
cin>>n;
start();
//  system("pause");
return 0;
}

5 圆桌问题
二分图多重匹配 网络最大流

6 最长递增子序列问题
最多不相交路径 网络最大流

7 试题库问题
二分图多重匹配 网络最大流

8 机器人路径规划问题
(未解决) 最小费用最大流         byvoid都没做

9 方格取数问题
二分图点权最大独立集 网络最小割
10
餐巾计划问题 线性规划网络优化
最小费用最大流

#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;
#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b) for( int i = (a) ; i <= (b) ; i ++)
#define FF(i,a) for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b) for( int i = (a) ; i >= (b) ; i --)
#define S64(a) scanf(in64,&a)
#define SS(a) scanf("%d",&a)
#define LL(a) ((a)<<1)
#define RR(a) (((a)<<1)+1)
#define pb push_back
#define pf push_front
#define X first
#define Y second
#define CL(Q) while(!Q.empty())Q.pop()
#define MM(name,what) memset(name,what,sizeof(name))
#define MC(a,b) memcpy(a,b,sizeof(b))
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define read freopen("in.txt","r",stdin)
#define write freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int maxn = 2022;
const int add = 1001;
const int head = 0;
const int end = 2021;

struct zz
{
int from;
int to;
int c;
int cost;
int id;
}zx;

vector<zz>g[maxn];
int n,p,m,f,nd,s;
int r[maxn];
int way[maxn];
int bid[maxn];
bool inq[maxn];

void link(int now,int to,int c,int cost,int bc=0)
{
zx.from = now;zx.to=to;zx.c=c;zx.cost=cost;
zx.id = g[zx.to].size();
g[zx.from].pb(zx);
swap(zx.from,zx.to);
zx.c=bc;zx.cost=-cost;
zx.id = g[zx.to].size()-1;
g[zx.from].pb(zx);
return ;
}

bool spfa()
{
for(int i=0;i<maxn;i++) way[i]=inf;
way[head]=0;
queue<int>q;
MM(inq,false);
inq[head]=true;
q.push(head);
int now,to,temp;
while(!q.empty())
{
now = q.front();
q.pop();
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c>0)
{
temp = g[now][i].cost+way[now];
if(temp<way[to])
{
bid[to] = g[now][i].id;
way[to] = temp;
if(!inq[to])
{
inq[to]=true;
q.push(to);
}
}
}
}
inq[now]=false;
}
return way[end]!=inf;
}
pair<int,int> dfs(int flow = inf,int to = end)
{
if(to == head) return make_pair(flow,0);
int now=g[to][bid[to]].to;
int id = g[to][bid[to]].id;
pair<int,int>temp=dfs(min(flow,g[now][id].c),now);
g[now][id].c-=temp.X;
g[to][bid[to]].c+=temp.X;
temp.Y+=temp.X*g[now][id].cost;
return temp;
}

int gao()
{
int ans=0;
while(spfa())
{
ans+=dfs().Y;
}
return ans;
}

int main()
{
while(cin>>n>>p>>m>>f>>nd>>s)
{
for(int i=0;i<maxn;i++)
{
g[i].clear();
}
for(int i=1;i<=n;i++)
{
SS(r[i]);
}
for(int i=1;i<=n;i++)
{
link(head,i,r[i],0);
link(head,i+add,inf,p);
link(i+add,end,r[i],0);
}
int now,to;
for(int i=1;i<=n-1;i++)
{
link(i,i+1,inf,0);
// link(i+add,i+add+1,inf,0);
}
for(int i=1;i<=n;i++)
{
now=i;to=i+add+m;
if(to<=add+n) link(now,to,inf,f);
now=i;to=i+add+nd;
if(to<=add+n) link(now,to,inf,s);
}
cout<<gao()<<endl;
}
return 0;
} 11
航空路线问题 最长不相交路径
最小费用最大流

#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;
#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b)      for( int i = (a) ; i <= (b) ; i ++)
#define FF(i,a)        for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b)      for( int i = (a) ; i >= (b) ; i --)
#define S64(a)          scanf(in64,&a)
#define SS(a)           scanf("%d",&a)
#define LL(a)           ((a)<<1)
#define RR(a)           (((a)<<1)+1)
#define pb              push_back
#define pf              push_front
#define X               first
#define Y               second
#define CL(Q)           while(!Q.empty())Q.pop()
#define MM(name,what)   memset(name,what,sizeof(name))
#define MC(a,b)         memcpy(a,b,sizeof(b))
#define MAX(a,b)        ((a)>(b)?(a):(b))
#define MIN(a,b)        ((a)<(b)?(a):(b))
#define read            freopen("in.txt","r",stdin)
#define write           freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int maxn = 2111;
const int add = 1001;
const int head = 0;
const int end = 2110;

struct zz
{
int from;
int to;
int c;
int cost;
int id;
}zx;

string s[maxn];
map<string,int>ms;
int n,m;
vector<zz>g[maxn];
vector<int>v;
vector<int>v2;
int way[maxn];
bool inq[maxn];
int bid[maxn];

void link(int now,int to,int c,int cost,int bc=0)
{
zx.from=now;zx.to=to;zx.c=c;zx.cost=cost;
zx.id=g[zx.to].size();
g[zx.from].pb(zx);
swap(zx.from,zx.to);
zx.c=bc;zx.cost=-cost;
zx.id=g[zx.to].size()-1;
g[zx.from].pb(zx);
return ;
}

bool spfa()
{
for(int i=0;i<maxn;i++)
{
way[i]=-inf;
}
way[head]=0;
deque<int>q;
MM(inq,false);
inq[head]=true;
q.pb(head);
int now,to,temp;
while(!q.empty())
{
now = q.front();
q.pop_front();
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c>0)
{
temp = g[now][i].cost+way[now];
if(temp>way[to])
{
bid[to] = g[now][i].id;
way[to] = temp;
if(!inq[to])
{
inq[to]=true;
//      if(q.empty() || way[to]<way[q.front()]) q.pf(to);  //最小费用流
//      else
if(q.empty() || way[to]>way[q.front()]) q.pf(to);  //最大费用流
else
q.pb(to);
}
}
}
}
inq[now]=false;
}
return way[end]!=-inf;
}
pair<int,int> dfs(int flow = inf,int to = end)
{
if(to == head) return make_pair(flow,0);
int now=g[to][bid[to]].to;
int id = g[to][bid[to]].id;
pair<int,int>temp=dfs(min(flow,g[now][id].c),now);
g[now][id].c-=temp.X;
g[to][bid[to]].c+=temp.X;
temp.Y+=temp.X*g[now][id].cost;
return temp;
}

bool gao()
{
pair<int,int>ans,temp;
ans.X=ans.Y=0;
while(spfa())
{
temp = dfs();
ans.X+=temp.X;
ans.Y+=temp.Y;
}
if(ans.X==2)
{
int now = 1;
int to;
v.clear();
v2.clear();
v.pb(now);
while(now!=n)
{
now+=add;
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c<2 && to!=now-add)
{
g[now][i].c++;
v.pb(to);
now = to;
break;
}
}
}
now = 1;
v2.pb(now);
while(now!=n)
{
now+=add;
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c<2 && to!=now-add)
{
g[now][i].c++;
v2.pb(to);
now = to;
break;
}
}
}
v2.pop_back();
cout<<ans.Y<<endl;
return true;
}
return false;
}

int main()
{
while(cin>>n>>m)
{
ms.clear();
for(int i=0;i<maxn;i++)
{
g[i].clear();
}
for(int i=1;i<=n;i++)
{
cin>>s[i];
}
for(int i=1;i<=n;i++)
{
link(i,i+add,1,1);
}
link(1,1+add,1,0);
link(n,n+add,1,0);
link(head,1,2,0);
link(n+add,end,2,0);

for(int i=1;i<=n;i++)
{
ms[s[i]]=i;
}
string sa,sb;
int now,to;
for(int i=1;i<=m;i++)
{
cin>>sa>>sb;
now = ms[sa];
to = ms[sb];
if(now>to) swap(now,to);
link(now+add,to,2,0);
}
if(gao())
{
for(int i=0;i<v.size();i++)
{
cout<<s[v[i]]<<endl;
}
int size = v2.size()-1;
for(int i=size;i>=0;i--)
{
cout<<s[v2[i]]<<endl;
}
}
else
{
cout<<"No Solution!"<<endl;
}
}
return 0;
}

12 软件补丁问题
最小转移代价 最短路径

#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;
#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b)      for( int i = (a) ; i <= (b) ; i ++)
#define FF(i,a)        for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b)      for( int i = (a) ; i >= (b) ; i --)
#define S64(a)          scanf(in64,&a)
#define SS(a)           scanf("%d",&a)
#define LL(a)           ((a)<<1)
#define RR(a)           (((a)<<1)+1)
#define pb              push_back
#define pf              push_front
#define X               first
#define Y               second
#define CL(Q)           while(!Q.empty())Q.pop()
#define MM(name,what)   memset(name,what,sizeof(name))
#define MC(a,b)     memcpy(a,b,sizeof(b))
#define MAX(a,b)        ((a)>(b)?(a):(b))
#define MIN(a,b)        ((a)<(b)?(a):(b))
#define read            freopen("in.txt","r",stdin)
#define write           freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int maxn = 1<<20;
const int maxz = 111;

struct zz
{
int from;
int to;
int cost;
}zx;

int dp[maxn];
int n,m;
int b[maxz];
int b2[maxz];
int f[maxz];
int f2[maxz];
int t[maxz];
vector<zz>g[maxn];

inline void link(int& now,int& to,int& cost)
{
zx.from = now;
zx.to = to;
zx.cost = cost;
g[zx.from].pb(zx);
return ;
}

int find(string &s)
{
int re=0;
int temp;
for(int i=0;i<s.length();i++)
{
if(s[i]=='+')
{
temp = 1<<i;
re+=temp;
}
}
return re;
}

int find2(string &s)
{
int re=0;
int temp;
for(int i=0;i<s.length();i++)
{
if(s[i]=='-')
{
temp = 1<<i;
re+= temp;
}
}
return re;
}

bool inq[maxn];

int spfa()
{
queue<int>q;
MM(inq,false);
for(int i=0;i<(1<<n);i++)
{
dp[i]=inf;
}
dp[0]=0;
inq[0] = true;
q.push(0);
int now,to,temp;
while(!q.empty())
{
now = q.front();
q.pop();
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
temp = dp[now]+g[now][i].cost;
if(temp<dp[to])
{
dp[to] =temp;
if(!inq[to])
{
inq[to]=true;
q.push(to);
}
}
}
inq[now]=false;
}
return dp[(1<<n)-1];
}

int main()
{
string sa,sb;
while(cin>>n>>m)
{
for(int i=0;i<(1<<n);i++)
{
g[i].clear();
}
for(int i=1;i<=m;i++)
{
cin>>t[i]>>sa>>sb;
b[i] = find(sa);
b2[i] = find2(sa);
f[i] = find2(sb);
f2[i] = find(sb);
}
int now,to,temp;
for(int i=0;i<(1<<n);i++)
{
for(int j=1;j<=m;j++)
{
if(i & b[j])    continue;
now = ~i;
if(now & b2[j]) continue;
now = i;
to = now | f[j];
temp = ~f2[j];
to &= temp;
link(now,to,t[j]);
}
}
int ans = spfa();
if(ans!=inf)
{
cout<<ans<<endl;
}
else
{
cout<<"0"<<endl;
}
}
return 0;
}

13 星际转移问题
网络判定 网络最大流

#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;
#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b)      for( int i = (a) ; i <= (b) ; i ++)
#define FF(i,a)        for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b)      for( int i = (a) ; i >= (b) ; i --)
#define S64(a)          scanf(in64,&a)
#define SS(a)           scanf("%d",&a)
#define LL(a)           ((a)<<1)
#define RR(a)           (((a)<<1)+1)
#define pb              push_back
#define pf              push_front
#define X               first
#define Y               second
#define CL(Q)           while(!Q.empty())Q.pop()
#define MM(name,what)   memset(name,what,sizeof(name))
#define MC(a,b)     memcpy(a,b,sizeof(b))
#define MAX(a,b)        ((a)>(b)?(a):(b))
#define MIN(a,b)        ((a)<(b)?(a):(b))
#define read            freopen("in.txt","r",stdin)
#define write           freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int maxn = 5111;
const int maxm = 22;
const int end = 5110;
const int head = 0;

struct zz
{
int from;
int to;
int c;
int id;
}zx;

int n,m,k;
vector<zz>g[maxn];
int c[maxm];
vector<int>v[maxm];
int p[maxm];
int back[maxn];
bool inq[maxn];
int f[maxm];

void link(int now,int to,int c,int bc=0)
{
zx.from = now;zx.to=to;zx.c=c;zx.id=g[zx.to].size();g[zx.from].pb(zx);
swap(zx.from,zx.to);zx.id=g[zx.to].size()-1;zx.c=bc;g[zx.from].pb(zx);
return ;
}

bool bfs()
{
MM(inq,false);
queue<int>q;
back[head]=back[end]=-1;
inq[head]=true;
q.push(head);
int now,to,temp;
while(!q.empty())
{
now = q.front();
q.pop();
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c>0)
{
if(!inq[to])
{
inq[to]=true;
back[to]=g[now][i].id;
q.push(to);
}
}
}
if(inq[end]) break;
}
return back[end]!=-1;
}

int dfs(int flow = inf,int to = end)
{
if(to == head) return flow;
int now = g[to][back[to]].to;
int id = g[to][back[to]].id;
int re = dfs(min(flow,g[now][id].c),now);
g[now][id].c-=re;
g[to][back[to]].c+=re;
return re;
}

int ek()
{
int re = 0;
while(bfs())
{
re+=dfs();
}
return re;
}

int num(int day,int x)
{
return (n+1)*day + x;
}

void add(int day)
{
int now,to,temp;
for(int i=1;i<=m;i++)
{
temp = day%p[i];
if(!temp) now = v[i].back();
else now = v[i][temp-1];
to = v[i][temp];
if(now!=-1)
{
if(to == -1)
{
link(num(day-1,now),end,c[i]);
}
else
{
link(num(day-1,now),num(day,to),c[i]);
}
}
}
for(int i=0;i<=n;i++)
{
link(num(day-1,i),num(day,i),inf);
}
return ;
}

int start()
{
int flow=0;
int ans;
for(ans=1;flow<k;ans++)
{
add(ans);
flow += ek();
}
return ans-1;
}

int find(int x)
{
if(x!=f[x])
return f[x]=find(f[x]);

return x;
}

int main()
{
while(cin>>n>>m>>k)
{
for(int i=0;i<maxm;i++) f[i]=i;
for(int i=0;i<maxn;i++)  g[i].clear();
for(int i=0;i<maxm;i++) v[i].clear();
for(int i=1;i<=m;i++)
{
cin>>c[i]>>p[i];
int temp;
int pre,t2;
for(int x=1;x<=p[i];x++)
{
cin>>temp;
v[i].pb(temp);
if(temp==-1)
{
t2 = n+1;
}
else t2 = temp;
if(x>=2)
{
f[find(pre)]=find(t2);
}
pre = t2;
}
f[find(pre)]=find(v[i][0]);
}
if(find(0)!=find(n+1))
{
cout<<"0"<<endl;
}
else
{
cout<<start()<<endl;
}
}
return 0;
}

14 孤岛营救问题
分层图最短路径 最短路径
#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;
#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b) for( int i = (a) ; i <= (b) ; i ++)
#define FF(i,a) for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b) for( int i = (a) ; i >= (b) ; i --)
#define S64(a) scanf(in64,&a)
#define SS(a) scanf("%d",&a)
#define LL(a) ((a)<<1)
#define RR(a) (((a)<<1)+1)
#define pb push_back
#define pf push_front
#define X first
#define Y second
#define CL(Q) while(!Q.empty())Q.pop()
#define MM(name,what) memset(name,what,sizeof(name))
#define MC(a,b) memcpy(a,b,sizeof(b))
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define read freopen("in.txt","r",stdin)
#define write freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int maxs = 1<<11;
const int maxn = 222;
const int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
struct zz
{
int x;
int s;
}zx;
int head,end;
int dp[maxn][maxs];
int f[maxn];
int go[maxn][4];
int n,m,p,k,s;

int num(int x,int y)
{
return (x-1)*m+y;
}

int getx(int temp)
{
return (temp-1)/m+1;
}

int gety(int temp)
{
return (temp-1)%m+1;
}

bool yes(int x,int y)
{
if(x>=1 && x<=n && y>=1 && y<= m)
return true;
return false;
}

int fd(int dx,int dy)
{
if(dx==-1)
{
return 0;
}
if(dx==1)
{
return 1;
}
if(dy==-1)
{
return 2;
}
if(dy==1)
{
return 3;
}
assert(false);
}

bool inq[maxn][maxs];

int spfa()
{
zz now,to;
queue<zz>q;
MM(inq,false);
now.x = num(1,1);
now.s = f[num(1,1)];
inq[now.x][now.s]=true;
dp[now.x][now.s]=0;
q.push(now);
int x,y;
int temp;
while(!q.empty())
{
now = q.front();
q.pop();
for(int i=0;i<4;i++)
{
if(go[now.x][i]!=-1 && !(~now.s & go[now.x][i]) )
{
x=getx(now.x)+dir[i][0];
y=gety(now.x)+dir[i][1];
if(yes(x,y))
{
to.x = num(x,y);
to.s = now.s | f[to.x];
temp = dp[now.x][now.s]+1;
if(dp[to.x][to.s]>temp)
{
dp[to.x][to.s] = temp;
if(!inq[to.x][to.s])
{
inq[to.x][to.s]=true;
q.push(to);
}
}
}
}
}
inq[now.x][now.s]=false;
}
int ans=inf;
for(int i=0;i<(1<<p);i++)
{
ans=min(ans,dp[num(n,m)][i]);
}
if(ans == inf) return -1;
return ans;
}

int main()
{
while(cin>>n>>m>>p)
{
for(int i=0;i<maxn;i++)
{
for(int j=0;j<(1<<p);j++)
{
dp[i][j]=inf;
}
}
MM(go,0);
MM(f,0);
cin>>k;
int x,y,x2,y2,temp;
for(int i=1;i<=k;i++)
{
cin>>x>>y>>x2>>y2>>temp;
if(temp==0)
{
go[num(x,y)][fd(x2-x,y2-y)]=-1;
go[num(x2,y2)][fd(x-x2,y-y2)]=-1;
}
else
{
temp--;
go[num(x,y)][fd(x2-x,y2-y)]=(1<<temp);
go[num(x2,y2)][fd(x-x2,y-y2)]=(1<<temp);
}
}
cin>>s;
for(int i=1;i<=s;i++)
{
cin>>x>>y>>temp;
temp--;
f[num(x,y)]|=(1<<temp);
}
cout<<spfa()<<endl;
}
return 0;
}

15 汽车加油行驶问题
分层图最短路径 最短路径
#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;
#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b) for( int i = (a) ; i <= (b) ; i ++)
#define FF(i,a) for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b) for( int i = (a) ; i >= (b) ; i --)
#define S64(a) scanf(in64,&a)
#define SS(a) scanf("%d",&a)
#define LL(a) ((a)<<1)
#define RR(a) (((a)<<1)+1)
#define pb push_back
#define pf push_front
#define X first
#define Y second
#define CL(Q) while(!Q.empty())Q.pop()
#define MM(name,what) memset(name,what,sizeof(name))
#define MC(a,b) memcpy(a,b,sizeof(b))
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define read freopen("in.txt","r",stdin)
#define write freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int dir[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
const int maxn = 111;

struct zz
{
int x;
int y;
int s;
}zx;

int n,k,a,b,c;
int ary[maxn][maxn];
int dp[maxn][maxn][11];
bool inq[maxn][maxn][11];

bool yes(int x,int y)
{
if(x>=1 && x<=n && y>=1 && y<=n)
return true;
return false;
}

int spfa()
{
queue<zz>q;
zx.x = zx.y =1;
zx.s = k;
inq[zx.x][zx.y][zx.s]=true;
dp[zx.x][zx.y][zx.s]=0;
q.push(zx);
zz now,to;
int temp,add,ts;
while(!q.empty())
{
now = q.front();
q.pop();
if(now.s == 0)
{
ts=k;
add = a+c;
}
else
{
ts=now.s;
add=0;
}
for(int i=0;i<2;i++)
{
to.x = now.x + dir[i][0];
to.y = now.y + dir[i][1];
to.s = ts - 1;
if(yes(to.x,to.y))
{
temp = dp[now.x][now.y][now.s]+add;
if(ary[to.x][to.y])
{
temp+=a;
to.s = k;
}
if(temp<dp[to.x][to.y][to.s])
{
dp[to.x][to.y][to.s] = temp;
if(!inq[to.x][to.y][to.s])
{
inq[to.x][to.y][to.s] = true;
q.push(to);
}
}
}
}
add+=b;
for(int i=2;i<4;i++)
{
to.x = now.x + dir[i][0];
to.y = now.y + dir[i][1];
to.s = ts - 1;
if(yes(to.x,to.y))
{
temp = dp[now.x][now.y][now.s]+add;
if(ary[to.x][to.y])
{
temp+=a;
to.s = k;
}
if(temp<dp[to.x][to.y][to.s])
{
dp[to.x][to.y][to.s] = temp;
if(!inq[to.x][to.y][to.s])
{
inq[to.x][to.y][to.s] = true;
q.push(to);
}
}
}
}
inq[now.x][now.y][now.s]=false;
}
int re=inf;
for(int i=0;i<=k;i++)
{
re=min(re,dp

[i]);
}
if(re==inf) return -1;
return re;
}

int start()
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
for(int x=0;x<=k;x++)
{
dp[i][j][x]=inf;
inq[i][j][x]=false;
}
}
}
return spfa();
}

int main()
{
while(cin>>n>>k>>a>>b>>c)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
cin>>ary[i][j];
}
}
cout<<start()<<endl;
}
return 0;
} 16
数字梯形问题 最大权不相交路径
最小费用最大流

#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;
#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b)      for( int i = (a) ; i <= (b) ; i ++)
#define FF(i,a)        for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b)      for( int i = (a) ; i >= (b) ; i --)
#define S64(a)          scanf(in64,&a)
#define SS(a)           scanf("%d",&a)
#define LL(a)           ((a)<<1)
#define RR(a)           (((a)<<1)+1)
#define pb              push_back
#define pf              push_front
#define X               first
#define Y               second
#define CL(Q)           while(!Q.empty())Q.pop()
#define MM(name,what)   memset(name,what,sizeof(name))
#define MC(a,b)         memcpy(a,b,sizeof(b))
#define MAX(a,b)        ((a)>(b)?(a):(b))
#define MIN(a,b)        ((a)<(b)?(a):(b))
#define read            freopen("in.txt","r",stdin)
#define write           freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int maxn = 822;
const int add = 411;
const int head = 0;
const int end = 821;

struct zz
{
int from;
int to;
int c;
int cost;
int id;
}zx;

int a[22][22];
int n,m;
vector<zz>g[maxn];
int way[maxn];
int back[maxn];

void link(int now,int to,int c,int cost,int bc = 0)
{
zx.from = now;
zx.to = to;
zx.c = c;
zx.cost = cost;
zx.id = g[zx.to].size();
g[zx.from].pb(zx);
swap(zx.from,zx.to);
zx.c = bc;
zx.cost = -cost;
zx.id = g[zx.to].size()-1;
g[zx.from].pb(zx);
return ;
}

int num(int x,int y)
{
return (x-1)*20+y;
}

void build(int ax=1,int bx=1)
{
for(int i=0;i<maxn;i++)
{
g[i].clear();
}
int now,to;
for(int i=1;i<=m;i++)
{
now = num(1,i);
link(head,now,1,0);
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<i+m;j++)
{
link(num(i,j),num(i,j)+add,ax,a[i][j]);
}
}
for(int i=1;i<n;i++)
{
for(int j=1;j<i+m;j++)
{
link(num(i,j)+add,num(i+1,j),bx,0);
link(num(i,j)+add,num(i+1,j+1),bx,0);
}
}
for(int i=1;i<n+m;i++)
{
link(num(n,i)+add,end,inf,0);
}
return ;
}

bool inq[maxn];

int spfa()
{
MM(way,-1);
MM(back,-1);
deque<int>q;
q.clear();
MM(inq,false);
inq[head] = true;
q.push_back(head);
way[head] = 0;
int now,to,temp;
while(!q.empty())
{
now = q.front();
q.pop_front();
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c>0)
{
temp = g[now][i].cost+way[now];
if(temp>way[to])
{
back[to]=g[now][i].id;
way[to]=temp;
if(!inq[to])
{
inq[to]=true;
if(q.empty() || temp>way[q.front()]) q.pf(to);
else q.pb(to);
}
}
}
}
inq[now]=false;
}
return way[end]!=-1;
}

pair<int,int> dfs(int flow=inf,int to=end)
{
if(to == head) return make_pair(flow,0);
int now = g[to][back[to]].to;
int id  = g[to][back[to]].id;
pair<int,int>temp = dfs(min(g[now][id].c,flow),now);
g[now][id].c-=temp.X;
g[to][back[to]].c+=temp.X;
temp.Y+=temp.X*g[now][id].cost;
return temp;
}

int ek()
{
int re=0;
while(spfa())
{
re+=dfs().Y;
}
return re;
}

void start()
{
build(1,1);
cout<<ek()<<endl;
build(inf,1);
cout<<ek()<<endl;
build(inf,inf);
cout<<ek()<<endl;
return ;
}

int main()
{
while(cin>>m>>n)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<i+m;j++)
{
cin>>a[i][j];
}
}
start();
}
return 0;
}

17 运输问题
网络费用流量 最小费用最大流
#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;
#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b) for( int i = (a) ; i <= (b) ; i ++)
#define FF(i,a) for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b) for( int i = (a) ; i >= (b) ; i --)
#define S64(a) scanf(in64,&a)
#define SS(a) scanf("%d",&a)
#define LL(a) ((a)<<1)
#define RR(a) (((a)<<1)+1)
#define pb push_back
#define pf push_front
#define X first
#define Y second
#define CL(Q) while(!Q.empty())Q.pop()
#define MM(name,what) memset(name,what,sizeof(name))
#define MC(a,b) memcpy(a,b,sizeof(b))
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define read freopen("in.txt","r",stdin)
#define write freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int maxn = 222;
const int head = 0;
const int end = 221;

struct zz
{
int from;
int to;
int c;
int cost;
int id;
}zx;

vector<zz>g[maxn];
int m,n;
int a[maxn];
bool inq[maxn];
int way[maxn];
int back[maxn];
int f[maxn][maxn];

void link(int now,int to,int c,int cost,int bc=0)
{
zx.from = now; zx.to=to; zx.c=c; zx.cost=cost; zx.id=g[zx.to].size();
g[zx.from].pb(zx);
swap(zx.from,zx.to); zx.c=bc; zx.cost=-cost; zx.id=g[zx.to].size()-1;
g[zx.from].pb(zx);
return ;
}

bool spfa(bool x)
{
if(x)
{
for(int i=0;i<maxn;i++)
{
way[i]=-inf;
}
}
else
{
for(int i=0;i<maxn;i++)
{
way[i]=inf;
}
}
MM(back,-1);
queue<int>q;
MM(inq,false);
inq[head]=true;
way[head]=0;
q.push(head);
int now,to,temp;
while(!q.empty())
{
now = q.front();
q.pop();
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c>0)
{
temp = g[now][i].cost + way[now];
if(x)
{
if(temp>way[to])
{
back[to] = g[now][i].id;
way[to]=temp;
if(!inq[to])
{
inq[to]=true;
q.push(to);
}
}
}
else
{
if(temp<way[to])
{
back[to]=g[now][i].id;
way[to]=temp;
if(!inq[to])
{
inq[to]=true;
q.push(to);
}
}
}
}
}
inq[now]=false;
}
if(x)
{
return way[end]!=-inf;
}
else
{
return way[end]!=inf;
}
}

int dfs(int flow=inf,int to=end)
{
if(to == head) return flow;
int now = g[to][back[to]].to;
int id = g[to][back[to]].id;
int re = dfs(min(flow,g[now][id].c),now);
g[now][id].c-=re;
g[to][back[to]].c+=re;
return re;
}

int ek(bool x)
{
int ans = 0;
while(spfa(x))
{
ans+=dfs()*way[end];
}
return ans;
}

void build()
{
for(int i=0;i<maxn;i++)
{
g[i].clear();
}
for(int i=1;i<=m;i++)
{
link(head,i,a[i],0);
}
for(int i=m+1;i<=m+n;i++)
{
link(i,end,a[i],0);
}
int cost;
for(int i=1;i<=m;i++)
{
for(int j=m+1;j<=m+n;j++)
{
link(i,j,inf,f[i][j]);
}
}
return ;
}

int main()
{
while(cin>>m>>n)
{
for(int i=1;i<=m;i++)
{
cin>>a[i];
}
for(int i=1+m;i<=n+m;i++)
{
cin>>a[i];
}
for(int i=1;i<=m;i++)
{
for(int j=m+1;j<=m+n;j++)
{
cin>>f[i][j];
}
}
build();
cout<<ek(false)<<endl;
build();
cout<<ek(true)<<endl;
}
return 0;
}

18 分配问题
二分图最佳匹配 最小费用最大流

#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;
#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b)      for( int i = (a) ; i <= (b) ; i ++)
#define FF(i,a)        for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b)      for( int i = (a) ; i >= (b) ; i --)
#define S64(a)          scanf(in64,&a)
#define SS(a)           scanf("%d",&a)
#define LL(a)           ((a)<<1)
#define RR(a)           (((a)<<1)+1)
#define pb              push_back
#define pf              push_front
#define X               first
#define Y               second
#define CL(Q)           while(!Q.empty())Q.pop()
#define MM(name,what)   memset(name,what,sizeof(name))
#define MC(a,b)         memcpy(a,b,sizeof(b))
#define MAX(a,b)        ((a)>(b)?(a):(b))
#define MIN(a,b)        ((a)<(b)?(a):(b))
#define read            freopen("in.txt","r",stdin)
#define write           freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int maxn = 222;
const int head = 0;
const int end = 221;

struct zz
{
int from;
int to;
int c;
int cost;
int id;
}zx;

int n;
vector<zz>g[maxn];
int cx[maxn][maxn];

void link(int now,int to,int c,int cost,int bc=0)
{
zx.from = now,zx.to =to,zx.c = c,zx.cost=cost;
zx.id = g[zx.to].size();
g[zx.from].pb(zx);
swap(zx.from,zx.to),zx.c = bc,zx.cost = -cost;
zx.id = g[zx.to].size()-1;
g[zx.from].pb(zx);
return ;
}

int way[maxn];
bool inq[maxn];
int back[maxn];

bool spfa(bool x)
{
if(x) for(int i=0;i<maxn;i++) way[i] = inf;
else for(int i=0;i<maxn;i++) way[i] = -inf;
queue<int>q;
inq[head]=true;
q.push(head);
way[head]=0;
int now,to,temp;
while(!q.empty())
{
now = q.front();
q.pop();
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c>0)
{
temp = way[now]+g[now][i].cost;
if(x)
{
if(temp<way[to])
{
way[to]=temp;
back[to]=g[now][i].id;
if(!inq[to])
{
inq[to]=true;
q.push(to);
}
}
}
else
{
if(temp>way[to])
{
way[to]=temp;
back[to]=g[now][i].id;
if(!inq[to])
{
inq[to]=true;
q.push(to);
}
}
}
}
}
inq[now]=false;
}
if(x) return way[end]!=inf;
else return way[end]!=-inf;
}

int dfs(int flow=inf,int to=end)
{
if(to==head) return flow;
int now = g[to][back[to]].to;
int id  = g[to][back[to]].id;
int temp = dfs(min(flow,g[now][id].c),now);
g[now][id].c-=temp;
g[to][back[to]].c+=temp;
return temp;
}

int ek(bool x)
{
int ans=0;
while(spfa(x))
{
ans+=dfs()*way[end];
}
return ans;
}

void build()
{
for(int i=0;i<maxn;i++)
{
g[i].clear();
}
for(int i=1;i<=n;i++)
{
for(int j=n+1;j<=n+n;j++)
{
link(i,j,1,cx[i][j]);
}
}
for(int i=1;i<=n;i++)
{
link(head,i,1,0);
}
for(int i=n+1;i<=n+n;i++)
{
link(i,end,1,0);
}
return ;
}

int main()
{
while(cin>>n)
{
for(int i=1;i<=n;i++)
{
for(int j=n+1;j<=n+n;j++)
{
cin>>cx[i][j];
}
}
build();
cout<<ek(true)<<endl;
build();
cout<<ek(false)<<endl;
}
return 0;
}

19 负载平衡问题
最小代价供求 最小费用最大流

#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;
#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b)      for( int i = (a) ; i <= (b) ; i ++)
#define FF(i,a)        for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b)      for( int i = (a) ; i >= (b) ; i --)
#define S64(a)          scanf(in64,&a)
#define SS(a)           scanf("%d",&a)
#define LL(a)           ((a)<<1)
#define RR(a)           (((a)<<1)+1)
#define pb              push_back
#define pf              push_front
#define X               first
#define Y               second
#define CL(Q)           while(!Q.empty())Q.pop()
#define MM(name,what)   memset(name,what,sizeof(name))
#define MC(a,b)         memcpy(a,b,sizeof(b))
#define MAX(a,b)        ((a)>(b)?(a):(b))
#define MIN(a,b)        ((a)<(b)?(a):(b))
#define read            freopen("in.txt","r",stdin)
#define write           freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int maxn = 222;
const int head = 0;
const int end = 221;

struct zz
{
int from;
int to;
int c;
int cost;
int id;
}zx;

vector<zz>g[maxn];
int n;

int dis(int x,int y)
{
if(x>y) swap(x,y);
int re = y-x;
re = min(n-re,re);
return re;
}

int way[maxn];
bool inq[maxn];
int back[maxn];

void link(int now,int to,int c,int cost,int bc=0)
{
zx.from=now,zx.to=to,zx.c=c,zx.cost=cost;
zx.id=g[zx.to].size();
g[zx.from].pb(zx);
swap(zx.from,zx.to);zx.c=bc,zx.cost=-cost;
zx.id=g[zx.to].size()-1;
g[zx.from].pb(zx);
return ;
}

bool spfa()
{
MM(inq,false);
MM(back,-1);
for(int i=0;i<maxn;i++) way[i]=inf;
queue<int>q;
way[head]=0;
inq[head]=true;
q.push(head);
int now,to,temp;
while(!q.empty())
{
now = q.front();
q.pop();
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c>0)
{
temp = way[now]+g[now][i].cost;
if(temp<way[to])
{
way[to]=temp;
back[to]=g[now][i].id;
if(!inq[to])
{
inq[to]=true;
q.push(to);
}
}
}
}
inq[now]=false;
}
return way[end]!=inf;
}

int dfs(int flow=inf,int to=end)
{
if(to==head) return flow;
int now = g[to][back[to]].to;
int id = g[to][back[to]].id;
int temp = dfs(min(flow,g[now][id].c),now);
g[now][id].c-=temp;
g[to][back[to]].c+=temp;
return temp;
}

int ek()
{
int ans=0;
while(spfa())
{
ans+=dfs()*way[end];
}
return ans;
}

int main()
{
int temp,sum=0;
while(cin>>n)
{
for(int i=0;i<maxn;i++) g[i].clear();
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
link(i,j+n,inf,dis(i,j));
}
}
for(int i=1;i<=n;i++)
{
cin>>temp;
sum+=temp;
link(head,i,temp,0);
}
sum/=n;
for(int i=n+1;i<=n+n;i++)
{
link(i,end,sum,0);
}
cout<<ek()<<endl;
}

return 0;
}

20 深海机器人问题
线性规划网络优化 最小费用最大流
#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;
#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b) for( int i = (a) ; i <= (b) ; i ++)
#define FF(i,a) for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b) for( int i = (a) ; i >= (b) ; i --)
#define S64(a) scanf(in64,&a)
#define SS(a) scanf("%d",&a)
#define LL(a) ((a)<<1)
#define RR(a) (((a)<<1)+1)
#define pb push_back
#define pf push_front
#define X first
#define Y second
#define CL(Q) while(!Q.empty())Q.pop()
#define MM(name,what) memset(name,what,sizeof(name))
#define MC(a,b) memcpy(a,b,sizeof(b))
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define read freopen("in.txt","r",stdin)
#define write freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int maxn = 333;
const int head = 0;
const int end = 332;

struct zz
{
int from;
int to;
int c;
int cost;
int id;
}zx;

vector<zz>g[maxn];
int ax,bx,n,m;

int num(int x,int y)
{
return (x-1)*(m+1)+y;
}

int way[maxn];
bool inq[maxn];
int back[maxn];

void link(int now,int to,int c,int cost,int bc=0)
{
zx.from=now;zx.to=to;zx.c=c;zx.cost=cost;
zx.id = g[zx.to].size();
g[zx.from].pb(zx);
swap(zx.from,zx.to);zx.c=bc;zx.cost=-cost;
zx.id = g[zx.to].size()-1;
g[zx.from].pb(zx);
return ;
}

bool spfa()
{
MM(inq,false);
MM(back,-1);
for(int i=0;i<maxn;i++) way[i]=-inf;
queue<int>q;
q.push(head);
inq[head]=true;
way[head]=0;
int now,to,temp;
while(!q.empty())
{
now = q.front();
q.pop();
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c>0)
{
temp = way[now]+g[now][i].cost;
if(temp>way[to])
{
way[to]=temp;
back[to]=g[now][i].id;
if(!inq[to])
{
inq[to]=true;
q.push(to);
}
}
}
}
inq[now]=false;
}
return way[end]!=-inf;
}

int dfs(int flow=inf,int to=end)
{
if(to==head) return flow;
int now=g[to][back[to]].to;
int id =g[to][back[to]].id;
int temp = dfs(min(flow,g[now][id].c),now);
g[now][id].c-=temp;
g[to][back[to]].c+=temp;
return temp;
}

int ek()
{
int ans=0;
while(spfa())
{
ans+=dfs()*way[end];
}
return ans;
}

int main()
{
while(cin>>ax>>bx)
{
cin>>n>>m;
int temp;
for(int i=1;i<=n+1;i++)
{
for(int j=1;j<=m;j++)
{
cin>>temp;
link(num(i,j),num(i,j+1),1,temp);
link(num(i,j),num(i,j+1),inf,0);
}
}
for(int i=1;i<=m+1;i++)
{
for(int j=1;j<=n;j++)
{
cin>>temp;
link(num(j,i),num(j+1,i),1,temp);
link(num(j,i),num(j+1,i),inf,0);
}
}
int x,y;
for(int i=1;i<=ax;i++)
{
cin>>temp>>x>>y;
x++;y++;
link(head,num(x,y),temp,0);
}
for(int i=1;i<=bx;i++)
{
cin>>temp>>x>>y;
x++;y++;
link(num(x,y),end,temp,0);
}
cout<<ek()<<endl;
}
return 0;
}

21 最长k可重区间集问题
最大权不相交路径 最小费用最大流
#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;
#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif
/************ for topcoder by zz1215 *******************/
#define FOR(i,a,b) for( int i = (a) ; i <= (b) ; i ++)
#define FF(i,a) for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a,b) for( int i = (a) ; i >= (b) ; i --)
#define S64(a) scanf(in64,&a)
#define SS(a) scanf("%d",&a)
#define LL(a) ((a)<<1)
#define RR(a) (((a)<<1)+1)
#define pb push_back
#define pf push_front
#define X first
#define Y second
#define CL(Q) while(!Q.empty())Q.pop()
#define MM(name,what) memset(name,what,sizeof(name))
#define MC(a,b) memcpy(a,b,sizeof(b))
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define read freopen("in.txt","r",stdin)
#define write freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);

const int maxn = 4111;
const int head = 0;
const int add = 2011;
const int end = 4110;

struct zz
{
int from;
int to;
int c;
int cost;
int id;
}zx;

int n,k;
int x[maxn];
int y[maxn];
map<int,int>mx;
vector<int>v,vx;
vector<zz>g[maxn];

void link(int now,int to,int c,int cost,int bc=0)
{
zx.from=now;zx.to=to;zx.c=c;zx.cost=cost;
zx.id=g[zx.to].size();
g[zx.from].pb(zx);
swap(zx.from,zx.to);zx.c=bc;zx.cost=-cost;
zx.id=g[zx.to].size()-1;
g[zx.from].pb(zx);
return ;
}

int way[maxn];
bool inq[maxn];
int back[maxn];

bool spfa()
{
for(int i=0;i<maxn;i++) way[i]=-inf;
MM(inq,false);
MM(back,-1);
queue<int>q;
inq[head]=true;
way[head]=0;
q.push(head);
int now,to,temp;
while(!q.empty())
{
now = q.front();
q.pop();
for(int i=0;i<g[now].size();i++)
{
to = g[now][i].to;
if(g[now][i].c>0)
{
temp = way[now]+g[now][i].cost;
if(temp>way[to])
{
way[to] = temp;
back[to]=g[now][i].id;
if(!inq[to])
{
inq[to]=true;
q.push(to);
}
}
}
}
inq[now]=false;
}
return way[end]!=-inf;
}

int dfs(int flow=inf,int to=end)
{
if(to==head)
{
return flow;
}
int now = g[to][back[to]].to;
int id = g[to][back[to]].id;
int temp = dfs(min(flow,g[now][id].c),now);
g[now][id].c -= temp;
g[to][back[to]].c += temp;
return temp;
}

int ek()
{
int ans = 0;
while(spfa())
{
ans+=dfs()*way[end];
}
return ans;
}

int main()
{
while(cin>>n>>k)
{
v.clear();
vx.clear();
mx.clear();
for(int i=1;i<=n;i++)
{
cin>>x[i]>>y[i];
vx.pb(x[i]);
vx.pb(y[i]);
}
sort(vx.begin(),vx.end());
int temp=inf;
v.pb(-1);
for(int i=0;i<vx.size();i++)
{
if(vx[i]!=temp)
{
temp = vx[i];
v.pb(vx[i]);
v.pb(-1);
}
}
for(int i=1;i<v.size();i++)
{
mx[v[i]]=i;
}
for(int i=0;i<maxn;i++)
{
g[i].clear();
}
int cnt = v.size()-1;
for(int i=1;i<=cnt;i++)
{
link(i,i+add,k,0);
}
for(int i=1;i<cnt;i++)
{
link(i+add,i+1,k,0);
}
link(head,1,k,0);
link(cnt+add,end,k,0);
int now,to;
int ans=0;
for(int i=1;i<=n;i++)
{
now = mx[x[i]];
to = mx[y[i]];
now++;to--;
link(now,to+add,1,y[i]-x[i]);
}
cout<<ek()<<endl;
}
return 0;
} 22
最长k可重线段集问题 最大权不相交路径
最小费用最大流

23 火星探险问题
线性规划网络优化 最小费用最大流

24 骑士共存问题
二分图最大独立集 网络最小割