NOI2006 最大获利

最大权闭合图。

按照经典构图法：

权重为正的，S连这些点，流量为那个数字。

权重为负的，这些点连T，流量为权重绝对值。

跑最大流。然后S所在的割集，就是选中的所有的点。

这段代码就是遍历从S出发的集合，然后把她们权重加起来（cost传递的就是权重，cost[i]表示i的权重。 S的权重为0）

	queue<int>q;
	void doit(int cost[])
	{
		int ans=0;
		memset(vis, 0, sizeof(vis));
		q.push(s);
		vis[s]=1;
		while (!q.empty())
		{
			int x = q.front();q.pop();
			//prln(x);
			ans+= cost[x];
			for (int i = 0; i <G[x].size(); ++i)
			{
				Edge& e = edges[G[x][i]];
				if (!vis[e.to] && e.cap > e.flow)
				{
					vis[e.to] = 1;
					q.push(e.to);
				}
			}
		}
		printf("%d\n", ans);
	}

然后就可以AC了

#include <bits/stdc++.h>
#include <ext/pb_ds/priority_queue.hpp>
#include <tr1/unordered_map>
using std::tr1::unordered_map;
//using std::setiosflags;
//using std::setprecision;
using std::sort;
using std::max;
using std::min;
using std::cout;
using std::stack;
using std::cin;
using std::endl;
using std::swap;
using std::pair;
using std::vector;
using std::set;
using std::map;
using std::make_pair;
using std::multiset;
using std::unique;
using std::queue;
using std::greater;
using std::string;
using std::priority_queue;
using std::lower_bound;//返回第一个不小于
using std::upper_bound;//返回第一个大于
using std::max_element;
using std::min_element;
using __gnu_pbds::pairing_heap_tag;
#define x first
#define y second
#define Hash unordered_map
#define clr(x,b) memset((x),(b),sizeof(x))
typedef unsigned long long uLL;
typedef long long LL;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef __gnu_pbds::priority_queue<pii, greater<pii>, pairing_heap_tag> Heap;//小根堆
typedef Heap::point_iterator Hit;
const Hit null;
const double PI = acos(-1);
const LL LINF = 0x3f3f3f3f3f3f3f3fll;//4e18
const int INF = 0x3f3f3f3f;//1e9
const double eps = 1e-8;
const int MOD = 1 << 16;
#define prln(x) cout<<#x<<" = "<<x<<endl
#define pr(x) cout<<#x<<" = "<<x<<" "

//调用方法：
//init(n) 初始化 n 为节点数
//clear_flow() 清空所有边的流量
//add_edge(from, to, cap) 添加边from -> to 容量为cap
//maxflow(s, t) 返回s->t的最大流
//void mincut(vector<int>& ans) // 调用完maxflow后才可以用，ans里面存最小割
//print() 打印整张图，调试用
const int maxn = 200010;
struct Edge { int from, to, cap, flow; };
struct ISAP {
	int n, m, s, t;
	vector<Edge> edges;
	vector<int> G[maxn];   // 邻接表，G[i][j]表示结点i的第j条边在e数组中的序号
	bool vis[maxn];        // BFS使用
	int d[maxn];           // 从起点到i的距离
	int cur[maxn];        // 当前弧指针
	int p[maxn];          // 可增广路上的上一条弧
	int num[maxn];        // 距离标号计数
	void add_edge(int from, int to, int cap) {
		//pr(from),pr(to),prln(cap);
		edges.push_back((Edge){from, to, cap, 0});
		edges.push_back((Edge){to, from, 0, 0});
		m = edges.size();
		G[from].push_back(m-2);
		G[to].push_back(m-1);
	}
	bool bfs() {
		memset(vis, 0, sizeof(vis));
		queue<int> q;
		q.push(t);
		vis[t] = 1;
		d[t] = 0;
		while(!q.empty()) {
			int x = q.front(); q.pop();
			for(int i = 0; i < G[x].size(); i++) {
				Edge& e = edges[G[x][i]^1];
				if(!vis[e.from] && e.cap > e.flow) {
					vis[e.from] = 1;
					d[e.from] = d[x] + 1;
					q.push(e.from);
				}
			}
		}
		return vis[s];
	}

	queue<int>q;
	void doit(int cost[])
	{
		int ans=0;
		memset(vis, 0, sizeof(vis));
		q.push(s);
		vis[s]=1;
		while (!q.empty())
		{
			int x = q.front();q.pop();
			//prln(x);
			ans+= cost[x];
			for (int i = 0; i <G[x].size(); ++i)
			{
				Edge& e = edges[G[x][i]];
				if (!vis[e.to] && e.cap > e.flow)
				{
					vis[e.to] = 1;
					q.push(e.to);
				}
			}
		}
		printf("%d\n", ans);
	}


	void init(int n) {
		this->n = n;
		for(int i = 0; i < n; i++) G[i].clear();
		edges.clear();
	}
	void clear_flow() {
		for(int i = 0; i < edges.size(); i++) edges[i].flow = 0;    
	}
	int augment() {
		int x = t, a = INF;
		while(x != s) {
			Edge& e = edges[p[x]];
			a = min(a, e.cap-e.flow);
			x = edges[p[x]].from;
		}
		x = t;
		while(x != s) {
			edges[p[x]].flow += a;
			edges[p[x]^1].flow -= a;
			x = edges[p[x]].from;
		}
		return a;
	}
	int maxflow(int s, int t) {//到的最大流大于need就停止，如果没有限制，删去含有need的地方
		this->s = s; this->t = t;
		int flow = 0;
		bfs();
		memset(num, 0, sizeof(num));
		for(int i = 0; i < n; i++) num[d[i]]++;
		int x = s;
		memset(cur, 0, sizeof(cur));
		while(d[s] < n) {
			if(x == t) {
				flow += augment();
				x = s;
			}
			int ok = 0;
			for(int i = cur[x]; i < G[x].size(); i++) {
				Edge& e = edges[G[x][i]];
				if(e.cap > e.flow && d[x] == d[e.to] + 1) { // Advance
					ok = 1;
					p[e.to] = G[x][i];
					cur[x] = i; // 注意
					x = e.to;
					break;
				}
			}
			if(!ok) { // Retreat
				int m = n-1; // 初值注意
				for(int i = 0; i < G[x].size(); i++) {
					Edge& e = edges[G[x][i]];
					if(e.cap > e.flow) m = min(m, d[e.to]);
				}
				if(--num[d[x]] == 0) break;//gap优化
				num[d[x] = m+1]++;
				cur[x] = 0; // 注意
				if(x != s) x = edges[p[x]].from;
			}
		}
		return flow;
	}

	void mincut(vector<int>& ans) { // 调用完maxflow后才可以用，ans里面存最小割
		bfs();
		for(int i = 0; i < edges.size(); i++) {
			Edge& e = edges[i];
			if(!vis[e.from] && vis[e.to] && e.cap > 0) ans.push_back(i);
		}
	}
	void print() {
		printf("Graph:\n");
		for(int i = 0; i < edges.size(); i++)
			printf("%d->%d, %d, %d\n", edges[i].from, edges[i].to , edges[i].cap, edges[i].flow);
	}


} isap;

int n, m;
int cost[200000]={0};

void init()
{
	scanf("%d%d", &n, &m);
	isap.init(200000);
	for (int i = 1; i <= n ; ++ i)
	{
		scanf("%d", &cost[i+100000]);
		
		isap.add_edge(i+100000, 200000, cost[i+100000]);
		cost[i+100000] = - cost[i+100000];
	}
	for (int i = 1; i <= m; ++ i)
	{
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		cost[i]=c;
		isap.add_edge(0, i, c);
		isap.add_edge(i, 100000 + a, INF);
		isap.add_edge(i, 100000 + b, INF);
	}
	isap.maxflow(0, 200000);
	isap.doit(cost);
}


int main()
{
	int T=1;
	while (T--)
	{
		init();
	}
	return 0;
}