atcoder 326-G 最小割

复健第一周

题目：当L11,L12,L13...Ln条件满足时A1条件满足，获得a1分，满足Lx条件需要消耗lx分。同时，每个Lx1,Lx2,Lx3条件还有前置条件Q1,Q2,Q3....

最小割的问题主要是建边。最后将割除来的S部分为未完成的条件，T部分为完成的条件

0.类似与先前条件满足才能满足之后条件的，在最小割中可以将所有条件与结果建一条INF的边，体现在dinic搜索中就是满足小的条件则大的结果无条件完成。

1.Ax条件满足获得ax分，则不满足Ax条件扣ax分，所以需要用ax的代价把这条边切掉，那Ax就可以与T建一条v=ax的边。

2.前置条件：可以串在一起与T建边，其中离T越远的边表示达到这个条件所需要付出的代价的总和，最终条件可以与S建一条INF边，代表无论如何这之上的条件都完不成

#include <iostream>
using namespace std;
#include <string>
#include <string.h>
#include <vector>
#include <math.h>
#include <algorithm>
#include <cstdlib>
#include<queue>
#define double long double
#define MOD (int) (1e9 + 7)
#define MAXN 105
#define INF 0x3fffffff

int N, M, G[MAXN][MAXN], dis[MAXN * MAXN];
int idx, head[MAXN * MAXN];
const int T = MAXN * MAXN - 1, S = MAXN * MAXN - 2;

struct Edge
{
    int v, cap, next;
}e[MAXN * MAXN * 4];

inline void init()
{
    idx = -1;
    memset(head, -1, sizeof(head));
}

inline void insert(int a, int b, int c)
{
    ++idx;
    e[idx].v = b, e[idx].cap = c, e[idx].next = head[a], head[a] = idx;
    ++idx;
    e[idx].v = a, e[idx].cap = 0, e[idx].next = head[b], head[b] = idx;
}

bool bfs()
{
    int pos;
    queue<int>q;
    memset(dis, -1, sizeof(dis));
    dis[S] = 0;
    q.push(S);
    while (!q.empty()) {
        pos = q.front();
        q.pop();
        for (int i = head[pos]; i != -1; i = e[i].next) {
            if (dis[e[i].v] == -1 && e[i].cap > 0) {
                dis[e[i].v] = dis[pos] + 1;
                //cout <<  e[i].v << ' '<< dis[e[i].v] << endl;
                q.push(e[i].v);
            }
        }
    }
    return dis[T] != -1;
}

int dfs(int u, int flow)
{
    if (u == T) {
        return flow;
    }
    int tf = 0, sf;
    for (int i = head[u]; i != -1; i = e[i].next) {
        if (dis[u] + 1 == dis[e[i].v] && e[i].cap > 0 && (sf = dfs(e[i].v, min(flow - tf, e[i].cap)))) {
            e[i].cap -= sf, e[i ^ 1].cap += sf;
            tf += sf;
            if (tf == flow) {
                return flow;
            }
        }
    }
    if (!tf) {
        dis[u] = -1;
    }
    //cout << tf << endl;
    return tf;
}

int dinic()
{
    int ans = 0, r;
    while (bfs()) {
        ans += dfs(S, INF);
    }
    return ans;
}

int C[MAXN][8], cost[MAXN], A[MAXN], Acost[MAXN];
int L[MAXN][MAXN];

int main()
{
    int ca = 0, i, j;
    cin >> N >> M;
    init();

    int num = 0, res=0;
    for (i = 1; i <= N; i++)
    {
        cin >> cost[i];
        for (j = 1; j<=6; j++)
            C[i][j] = ++num;
    }

    for (i = 1; i <= M; i++)
    {
        cin >> Acost[i];
        A[i] = ++num;
        insert(A[i], T, Acost[i]);
        res += Acost[i];
    }

    for (i = 1; i <= M; ++i) {
        for (j = 1; j <= N; ++j) {
            cin >> L[i][j];
        }
    }

    for (i = 1; i <= N; ++i) {
        insert(S, C[i][6], INF);
        for (j = 5; j ; --j) {
            insert(C[i][j+1], C[i][j], cost[i]*(j-1));
        }
        insert(C[i][1], T, INF);
    }
    for (i = 1; i <= M; ++i) {
        for (j = 1; j <= N; ++j) {
            int x = C[j][L[i][j]], y = A[i];
            insert(x, y, INF);
        }
    }

    cout << res - dinic() << endl;
    

    return 0;
}