[网络流]codeforce round 1082 G. Petya and Graph

题意：

给你一个无向图，让你找一个它的子图，使得这个子图所有边权减去点权最大。

思路：

网络流最小割。

据说是一个很经典的题目，但是弱鸡表示没有做过。。

设所有边权和为sum，选中的边权和为esum,点权和为vsum，没有选的边的权值和为nesum,没有选的点的权值和为vesum,那么就是要esum-vsum是最大,也就是让sum-nesum-vsum最大，即令sum-（nesum+vsum）最大。

因为sum是固定的，所以我们可以求后面括号里的最小值，即求没有选中的边加上选中的点的最小值。

考虑以下建图方法：

①建立超级源点和超级汇点。

将所有的边都化成点，源点连接所有的边，cap为边权。

将所有的点都连接到汇点，cap为点权。

②所有边化成的点连接到它原来的边连接的点，边权为inf。

这个时候图被分成了四部分，从左到右分别为源点、边点、点、汇点。

求最小割。

因为边点到点的权值都是inf，所以最小割肯定是在源点到边点和点到汇点进行割边。

这个时候整个图被分成了两个部分，观察一下可以发现（其实就是因为我不知道怎么解释了，画个图看看 ），割掉的最左边的部分的边对应的就是ensum，割掉的最右边的部分的边对应的就是vsum，所以最小的(ensum+vsum)就求出来啦，用sum减去就是结果了。

总结：

没见过的题型，消化消化。

代码：

#define push_back pb
#define make_pair mk
#define rd read()
#define mem(a,b) memset(a,b,sizeof(a))
#define bug printf("*********\n");
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define FIN freopen(D://code//in.txt", "r", stdin);
#define debug(x) cout<<"["<
#define IO ios::sync_with_stdio(false),cin.tie(0);
#pragma comment(linker,"/STACk:1024000000,1024000000")
//#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using std::pair;


typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
//const double PI=acos(-1);


const int maxn = 3e3 + 10;
const int maxm = 1e6 + 10;
const int mod = 1000000007;
const int inf = 0x3f3f3f3f;
const ll INF=0x3f3f3f3f3f3f3f3f;
const double dinf=1e20;
const double eps=1e-8;
using namespace std;

ll read() {
    ll X = 0, p = 1; char c = getchar();
    for(; c > '9' || c < '0'; c = getchar()) if(c == '-') p = -1;
    for(; c >= '0' && c <= '9'; c = getchar()) X = X * 10 + c - '0';
    return X * p;
}
//*********************************************************************
int n,m,s,t;
struct node
{
    int to,next;
    ll cap;
}e[maxm];
int head[maxn],lev[maxn],cur[maxn];
int cnt=0;
void init()
{
    cnt=0;
    mem(head,-1);
}
void add(int u,int v,ll w)
{
    e[cnt].to=v;
    e[cnt].cap=w;
    e[cnt].next=head[u];
    head[u]=cnt++;
    e[cnt].to=u;
    e[cnt].cap=0;
    e[cnt].next=head[v];
    head[v]=cnt++;
}

bool bfs()
{
    mem(lev,-1);
    int que[maxn*2];
    int thead=0,tail=0;
    que[tail++]=s;
    lev[s]=0;
    while(thead<tail)
    {
        int u=que[thead];
        if(u==t) return 1;
        for(int i=head[u];~i;i=e[i].next)
        {
            int v=e[i].to;
            if(lev[v]==-1&&e[i].cap>0)
            {
                lev[v]=lev[u]+1;
                que[tail++]=v;
            }
        }
        thead++;
    }
    return false;
}
ll dfs(int u,ll cap)
{
    if(u==t||cap==0) return cap;
    ll flow=0,f;
    for(int i=head[u];~i;i=e[i].next)
    {
        int v=e[i].to;
        if(lev[v]==lev[u]+1&&(f=dfs(v,min(cap-flow,e[i].cap)))>0)
        {
            e[i].cap-=f;
            e[i^1].cap+=f;
            flow+=f;
            if(flow==cap) return cap;
        }
    }
    if(!flow) lev[u]=-1;
    return flow;
}

ll dinic()
{
    ll ans=0;
    while(bfs())
    {
        ans+=dfs(s,inf);
    }
    return ans;
}
int main()
{
    mem(head,-1);
    cin>>n>>m;
    s=1;
    t=m+n+2;
    ll sum=0;
    for(int i=1;i<=n;i++)
    {
        ll a;
        cin>>a;
        add(i+m+1,t,a);
    }
    for(int i=1;i<=m;i++)
    {
        ll u,v,w;
        cin>>u>>v>>w;
        sum+=w;
        add(s,i+1,w);
        add(i+1,u+m+1,INF);
        add(i+1,v+m+1,INF);
    }
    cout<<max(0ll,sum-dinic())<<endl;
}