最大最小费用流

题目在这里https://hihocoder.com/problemset/problem/1591?sid=1197871

理解题目，用费用流以后，就抄个模板，建好图，跑就行。

源代码在这里http://blog.csdn.net/jzq233jzq/article/details/73123089

下面贴上代码，需要的时候，拷贝一下就行。

#include<bits/stdc++.h>
#define pb push_back
typedef long long ll;
using namespace std;
typedef pair<int, int> pii;
const int maxn = 1e3 + 10;
bool vis[200001];int dist[200001];
//解释一下各数组的含义：vis两个用处：spfa里的访问标记，増广时候的访问标记，dist是每个点的距离标号
int n,m,s,t,ans=0;
//s是起点，t是终点，ans是费用答案
int nedge=-1,p[200001],c[200001],cc[200001],nex[200001],head[200001];
//这里是边表，解释一下各数组的含义：p[i]表示以某一点出发的编号为i的边对应点，c表示编号为i的边的流量，cc表示编号为i的边的费用，nex和head不说了吧。。。
inline void addedge(int x,int y,int z,int zz){
    p[++nedge]=y;c[nedge]=z;cc[nedge]=zz;nex[nedge]=head[x];head[x]=nedge;
}
//建边（数组模拟边表倒挂）
inline bool spfa(int s,int t){
    memset(vis,0,sizeof vis);
    for(int i=0;i<=n;i++)dist[i]=1e9;dist[t]=0;vis[t]=1;
//首先SPFA我们维护距离标号的时候要倒着跑，这样可以维护出到终点的最短路径
    deque<int>q;q.push_back(t);
//使用了SPFA的SLF优化（SLF可以自行百度或Google）
    while(!q.empty()){
        int now=q.front();q.pop_front();
        //cout << now << " ddd " << endl;
        for(int k=head[now];k>-1;k=nex[k])if(c[k^1]&&dist[p[k]]>dist[now]-cc[k]){
//首先c[k^1]是为什么呢，因为我们要保证正流，但是SPFA是倒着跑的，所以说我们要求c[k]的对应反向边是正的，这样保证走的方向是正确的
            dist[p[k]]=dist[now]-cc[k];
//因为已经是倒着的了，我们也可以很清楚明白地知道建边的时候反向边的边权是负的，所以减一下就对了（负负得正）
            if(!vis[p[k]]){
                vis[p[k]]=1;
                if(!q.empty()&&dist[p[k]]<dist[q.front()])q.push_front(p[k]);else q.push_back(p[k]);
//SLF优化
            }
        }
        vis[now]=0;
    }
    return dist[s]<1e9;
//判断起点终点是否连通
}
inline int dfs(int x,int low){
//这里就是进行増广了
    if(x==t){vis[t]=1;return low;}
    int used=0,a;vis[x]=1;
//这边是不是和dinic很像啊
    for(int k=head[x];k>-1;k=nex[k])if(!vis[p[k]]&&c[k]&&dist[x]-cc[k]==dist[p[k]]){
//这个条件就表示这条边可以进行増广
        a=dfs(p[k],min(c[k],low-used));
        if(a)ans+=a*cc[k],c[k]-=a,c[k^1]+=a,used+=a;
//累加答案，加流等操作都在这了
        if(used==low)break;
    }
    return used;
}
inline int costflow(){
    int flow=0;
    while(spfa(s,t)){
//判断起点终点是否连通，不连通说明满流，做完了退出
        //cout <<"asd" << endl;
        vis[t]=1;
        while(vis[t]){
            memset(vis,0,sizeof vis);
            flow+=dfs(s,1e9);
//一直増广直到走不到为止（这样也可以省时间哦）
        }
    }
    return flow;//这里返回的是最大流，费用的答案在ans里
}
int tn, tmc;
int tc[110];
int te[110][110];
int ta[110][110];
int solve()
{
    cin >> tn;
    for (int i = 1; i <= tn; i++) cin >>tc[i];
    cin >> tmc;
    int x, y;
    for (int i = 0; i < tmc; i++) {
        cin >> x >> y;
        te[x][y] = 1; te[y][x] = -1;
    }
    for (int i = 1; i <= tn; i++) {
        for (int j = 1; j <= tn; j++)
            cin >> ta[i][j];
    }
    memset(nex,-1,sizeof nex);memset(head,-1,sizeof head);
    //scanf("%d%d%d%d",&n,&m,&s,&t);
    n = tn * (tn - 1) / 2 + tn + 2 + 1;
    s = n - 1; t = s - 1;
    for (int i = 1; i <= tn; i++) {
        addedge(i, t, tc[i], 0);addedge(t, i, 0, 0);
    }
    int cur = tn;
    for (int i = 1; i <= tn; i++) {
        for(int j = i + 1; j <= tn; j++) {
            cur++;
            addedge(s, cur, 1, 0); addedge(cur, s, 0, 0);
            if(te[i][j] > 0) {
                addedge(cur, i, 1, -ta[i][j]);addedge(i, cur, 0, ta[i][j]);
                //cout << cur << " " << i <<" " << j <<" " <<ta[i][j] << endl;
            } else if(te[i][j] == 0) {
                addedge(cur, i, 1, -ta[i][j]);addedge(i, cur, 0, ta[i][j]);
                addedge(cur, j, 1, -ta[j][i]);addedge(j, cur, 0, ta[j][i]);
            } else {
                addedge(cur, j, 1, -ta[j][i]);addedge(j, cur, 0, ta[j][i]);
            }
        }
    }
    /*
    for(int i=1;i<=m;i++){
        int x,y,z,zz;scanf("%d%d%d%d",&x,&y,&z,&zz);
        addedge(x,y,z,zz);addedge(y,x,0,-zz);
    } */
    costflow();
    //printf("%d ",costflow());
    printf("%d",-ans);
    return 0;
}

int main() {
    freopen("test.in", "r", stdin);
    //freopen("test.out", "w", stdout);
    solve();
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

const int N = 103;
int match[N][N], matchIdx;

const int MAXN = 10011;
const int MAXM = 100011;
const int INF = (1 << 30);

struct Edge {
    int next, from, to, cap, cost;
};

struct MCMF {
    Edge edge[MAXM];
    int head[MAXN], countedge;

    void Init(int N) {
        this->N = N;
        memset(head, -1, sizeof(head));
        countedge = 0;
    }

    int N;
    int inq[MAXN], dis[MAXN], pre[MAXN], ad[MAXN];

    void AddEdge(const int& start, const int& end, const int& cap,
                 const int& cost) {
        edge[countedge].to = end;
        edge[countedge].from = start;
        edge[countedge].next = head[start];
        edge[countedge].cap = cap;
        edge[countedge].cost = cost;
        head[start] = countedge++;
        edge[countedge].to = start;
        edge[countedge].from = end;
        edge[countedge].next = head[end];
        edge[countedge].cap = 0;
        edge[countedge].cost = -cost;
        head[end] = countedge++;
    }

    bool BF(int s, int t, int& cost) {
        int i;
        for (i = 0; i < N; i++) dis[i] = INF;
        memset(inq, 0, sizeof(inq));
        dis[s] = 0;
        inq[s] = 1;
        pre[s] = -1;
        ad[s] = INF;

        queue<int> que;
        que.push(s);
        int u, v, temp;
        while (!que.empty()) {
            u = que.front();
            que.pop();
            inq[u] = 0;
            for (temp = head[u]; temp != -1; temp = edge[temp].next) {
                v = edge[temp].to;
                if (edge[temp].cap && dis[v] > dis[u] + edge[temp].cost) {
                    dis[v] = dis[u] + edge[temp].cost;
                    pre[v] = temp;
                    ad[v] = min(ad[u], edge[temp].cap);
                    if (!inq[v]) {
                    inq[v] = 1;
                    que.push(v);
                    }
                }
            }
        }
        if (dis[t] == INF) return false;
        cost += dis[t] * ad[t];
        u = t;
        while (u != s) {
            edge[pre[u]].cap -= ad[t];
            edge[pre[u] ^ 1].cap += ad[t];
            u = edge[pre[u]].from;
        }
        return true;
    }

    int MinC(int s, int t) {
    int cost = 0;
    while (BF(s, t, cost))
        ;
    return cost;
    }
}f;

int score[N];
bool ban[N][N];
int u[10011], v[10011];
int add[N][N];

int main() {
    int n;
    scanf("%d", &n);

    f.Init(n + n * (n - 1) / 2 + 2);
    int S = n + n * (n - 1) / 2, T = S + 1;
    for (int i = 0; i < n; i++) {
        scanf("%d", &score[i]);
        f.AddEdge(S, i, score[i], 0);
    }

    matchIdx = n;
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            match[i][j] = matchIdx++;
            f.AddEdge(match[i][j], T, 1, 0);
        }
    }

    int see;
    scanf("%d", &see);
    for(int i = 0; i < see; i++) {
        scanf("%d%d", &u[i], &v[i]);
        u[i]--;
        v[i]--;
        ban[v[i]][u[i]] = true;
    }

    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            scanf("%d", &add[i][j]);
            if(i == j) {
                continue;
            }
            if(!ban[i][j]) {
                f.AddEdge(i, match[min(i, j)][max(i, j)], 1, -add[i][j]);
            }
        }
    }

    cout << -f.MinC(S, T) << endl;

    return 0;
}

hihocode offer收割赛33 第三题， 第二名，比较好的模板

#include <bits/stdc++.h>

using namespace std;

const int N = 200 + 5;
const int NN = N * N * 2 + 5;
const int M = NN * 4 + 5;

struct Edge {
  int u, v, c, cost, nxt;
  Edge() {}
  Edge(int _u, int _v, int _c, int _cost, int _nxt)
    : u(_u), v(_v), c(_c), cost(_cost), nxt(_nxt) {}
} es[M];

int head[NN], from[NN], dp[NN], tot;

int n;
int x[N][N];

void addEdge(int u, int v, int c, int cost) {
  es[tot] = Edge(u, v, c, cost, head[u]);
  head[u] = tot++;
}

void addDoubleEdge(int u, int v, int c, int cost) {
  addEdge(u, v, c, cost);
  addEdge(v, u, 0, -cost);
}

int spfa(int s, int t) {
  deque <int> de;
  memset(dp, -1, sizeof dp);
  dp[s] = 0;
  de.push_back(s);
  while (!de.empty()) {
    int u = de.front();
    de.pop_front();
    for (int i = head[u]; i != -1; i = es[i].nxt) {
      if (es[i].c == 0)
        continue;
      int v = es[i].v;
      if (dp[v] < dp[u] + es[i].cost) {
        dp[v] = dp[u] + es[i].cost;
        from[v] = i;
        de.push_back(v);
      }
    }
  }
  if (dp[t] == -1)
    return dp[t];
  int temp = t;
  while (temp != s) {
    int id = from[temp];
    --es[id].c;
    ++es[id ^ 1].c;
    temp = es[id].u;
  }
  return dp[t];
}

int mcmf(int s, int t) {
  int ret = 0;
  while (true) {
    int add = spfa(s, t);
    if (add == -1)
      break;
    ret += add;
  }
  return ret;
}

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(nullptr); cout.tie(nullptr);

  cin >> n;
  for (int i = 0; i < n; ++i)
    for (int j = 0; j < n; ++j)
      cin >> x[i][j];
  
  int all = n * n;
  tot = 0;
  memset(head, -1, sizeof head);
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      int c = 1;
      if (i == 0 && j == 0)
        c = 2;
      if (i == n - 1 && j == n - 1)
        c = 2;
      addDoubleEdge(i * n + j, i * n + j + all, c, x[i][j]);
      if (i + 1 < n)
        addDoubleEdge(i * n + j + all, (i + 1) * n + j, 1, 0);
      if (j + 1 < n)
        addDoubleEdge(i * n + j + all, i * n + j + 1, 1, 0);
    }
  }
  int s = all + all, t = s + 1;
  addDoubleEdge(s, 0, 2, 0);
  addDoubleEdge(all + all - 1, t, 2, 0);
  cout << mcmf(s, t) << '
';
  return 0;
}